* [PATCH 1/5] scsi: Fix erratic device offline during EH
2013-11-05 7:05 [PATCHv10 0/5] New EH command timeout handler Hannes Reinecke
@ 2013-11-05 7:05 ` Hannes Reinecke
2013-11-05 7:05 ` [PATCH 2/5] scsi: improved eh timeout handler Hannes Reinecke
` (3 subsequent siblings)
4 siblings, 0 replies; 21+ messages in thread
From: Hannes Reinecke @ 2013-11-05 7:05 UTC (permalink / raw)
To: James Bottomley
Cc: Christoph Hellwig, linux-scsi, Ren Mingxin, Joern Engel,
James Smart, Hannes Reinecke
From: James Bottomley <jbottomley@parallels.com>
Commit 18a4d0a22ed6c54b67af7718c305cd010f09ddf8
(Handle disk devices which can not process medium access commands)
was introduced to offline any device which cannot process medium
access commands.
However, commit 3eef6257de48ff84a5d98ca533685df8a3beaeb8
(Reduce error recovery time by reducing use of TURs) reduced
the number of TURs by sending it only on the first failing
command, which might or might not be a medium access command.
So in combination this results in an erratic device offlining
during EH; if the command where the TUR was sent upon happens
to be a medium access command the device will be set offline,
if not everything proceeds as normal.
This patch moves the check to the final test, eliminating
this problem.
Signed-off-by: Hannes Reinecke <hare@suse.de>
Signed-off-by: James Bottomley <jbottomley@parallels.com>
---
drivers/scsi/scsi_error.c | 26 +++++++++++++++++---------
drivers/scsi/sd.c | 26 ++++++++++++--------------
include/scsi/scsi_driver.h | 2 +-
3 files changed, 30 insertions(+), 24 deletions(-)
diff --git a/drivers/scsi/scsi_error.c b/drivers/scsi/scsi_error.c
index e8bee9f..67c0014 100644
--- a/drivers/scsi/scsi_error.c
+++ b/drivers/scsi/scsi_error.c
@@ -941,12 +941,6 @@ retry:
scsi_eh_restore_cmnd(scmd, &ses);
- if (scmd->request->cmd_type != REQ_TYPE_BLOCK_PC) {
- struct scsi_driver *sdrv = scsi_cmd_to_driver(scmd);
- if (sdrv->eh_action)
- rtn = sdrv->eh_action(scmd, cmnd, cmnd_size, rtn);
- }
-
return rtn;
}
@@ -964,6 +958,16 @@ static int scsi_request_sense(struct scsi_cmnd *scmd)
return scsi_send_eh_cmnd(scmd, NULL, 0, scmd->device->eh_timeout, ~0);
}
+static int scsi_eh_action(struct scsi_cmnd *scmd, int rtn)
+{
+ if (scmd->request->cmd_type != REQ_TYPE_BLOCK_PC) {
+ struct scsi_driver *sdrv = scsi_cmd_to_driver(scmd);
+ if (sdrv->eh_action)
+ rtn = sdrv->eh_action(scmd, rtn);
+ }
+ return rtn;
+}
+
/**
* scsi_eh_finish_cmd - Handle a cmd that eh is finished with.
* @scmd: Original SCSI cmd that eh has finished.
@@ -1142,7 +1146,9 @@ static int scsi_eh_test_devices(struct list_head *cmd_list,
list_for_each_entry_safe(scmd, next, cmd_list, eh_entry)
if (scmd->device == sdev) {
- if (finish_cmds)
+ if (finish_cmds &&
+ (try_stu ||
+ scsi_eh_action(scmd, SUCCESS) == SUCCESS))
scsi_eh_finish_cmd(scmd, done_q);
else
list_move_tail(&scmd->eh_entry, work_q);
@@ -1283,7 +1289,8 @@ static int scsi_eh_stu(struct Scsi_Host *shost,
!scsi_eh_tur(stu_scmd)) {
list_for_each_entry_safe(scmd, next,
work_q, eh_entry) {
- if (scmd->device == sdev)
+ if (scmd->device == sdev &&
+ scsi_eh_action(scmd, SUCCESS) == SUCCESS)
scsi_eh_finish_cmd(scmd, done_q);
}
}
@@ -1350,7 +1357,8 @@ static int scsi_eh_bus_device_reset(struct Scsi_Host *shost,
!scsi_eh_tur(bdr_scmd)) {
list_for_each_entry_safe(scmd, next,
work_q, eh_entry) {
- if (scmd->device == sdev)
+ if (scmd->device == sdev &&
+ scsi_eh_action(scmd, rtn) != FAILED)
scsi_eh_finish_cmd(scmd,
done_q);
}
diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index fd874b8..1929838 100644
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -110,7 +110,7 @@ static int sd_suspend_runtime(struct device *);
static int sd_resume(struct device *);
static void sd_rescan(struct device *);
static int sd_done(struct scsi_cmnd *);
-static int sd_eh_action(struct scsi_cmnd *, unsigned char *, int, int);
+static int sd_eh_action(struct scsi_cmnd *, int);
static void sd_read_capacity(struct scsi_disk *sdkp, unsigned char *buffer);
static void scsi_disk_release(struct device *cdev);
static void sd_print_sense_hdr(struct scsi_disk *, struct scsi_sense_hdr *);
@@ -1551,23 +1551,23 @@ static const struct block_device_operations sd_fops = {
/**
* sd_eh_action - error handling callback
* @scmd: sd-issued command that has failed
- * @eh_cmnd: The command that was sent during error handling
- * @eh_cmnd_len: Length of eh_cmnd in bytes
* @eh_disp: The recovery disposition suggested by the midlayer
*
- * This function is called by the SCSI midlayer upon completion of
- * an error handling command (TEST UNIT READY, START STOP UNIT,
- * etc.) The command sent to the device by the error handler is
- * stored in eh_cmnd. The result of sending the eh command is
- * passed in eh_disp.
+ * This function is called by the SCSI midlayer upon completion of an
+ * error test command (currently TEST UNIT READY). The result of sending
+ * the eh command is passed in eh_disp. We're looking for devices that
+ * fail medium access commands but are OK with non access commands like
+ * test unit ready (so wrongly see the device as having a successful
+ * recovery)
**/
-static int sd_eh_action(struct scsi_cmnd *scmd, unsigned char *eh_cmnd,
- int eh_cmnd_len, int eh_disp)
+static int sd_eh_action(struct scsi_cmnd *scmd, int eh_disp)
{
struct scsi_disk *sdkp = scsi_disk(scmd->request->rq_disk);
if (!scsi_device_online(scmd->device) ||
- !scsi_medium_access_command(scmd))
+ !scsi_medium_access_command(scmd) ||
+ host_byte(scmd->result) != DID_TIME_OUT ||
+ eh_disp != SUCCESS)
return eh_disp;
/*
@@ -1577,9 +1577,7 @@ static int sd_eh_action(struct scsi_cmnd *scmd, unsigned char *eh_cmnd,
* process of recovering or has it suffered an internal failure
* that prevents access to the storage medium.
*/
- if (host_byte(scmd->result) == DID_TIME_OUT && eh_disp == SUCCESS &&
- eh_cmnd_len && eh_cmnd[0] == TEST_UNIT_READY)
- sdkp->medium_access_timed_out++;
+ sdkp->medium_access_timed_out++;
/*
* If the device keeps failing read/write commands but TEST UNIT
diff --git a/include/scsi/scsi_driver.h b/include/scsi/scsi_driver.h
index d443aa0..20fdfc2 100644
--- a/include/scsi/scsi_driver.h
+++ b/include/scsi/scsi_driver.h
@@ -16,7 +16,7 @@ struct scsi_driver {
void (*rescan)(struct device *);
int (*done)(struct scsi_cmnd *);
- int (*eh_action)(struct scsi_cmnd *, unsigned char *, int, int);
+ int (*eh_action)(struct scsi_cmnd *, int);
};
#define to_scsi_driver(drv) \
container_of((drv), struct scsi_driver, gendrv)
--
1.7.12.4
^ permalink raw reply related [flat|nested] 21+ messages in thread* [PATCH 2/5] scsi: improved eh timeout handler
2013-11-05 7:05 [PATCHv10 0/5] New EH command timeout handler Hannes Reinecke
2013-11-05 7:05 ` [PATCH 1/5] scsi: Fix erratic device offline during EH Hannes Reinecke
@ 2013-11-05 7:05 ` Hannes Reinecke
2013-11-05 19:19 ` Mike Christie
2013-11-05 7:05 ` [PATCH 3/5] scsi: Unlock accesses to eh_deadline Hannes Reinecke
` (2 subsequent siblings)
4 siblings, 1 reply; 21+ messages in thread
From: Hannes Reinecke @ 2013-11-05 7:05 UTC (permalink / raw)
To: James Bottomley
Cc: Christoph Hellwig, linux-scsi, Ren Mingxin, Joern Engel,
James Smart, Hannes Reinecke
When a command runs into a timeout we need to send an 'ABORT TASK'
TMF. This is typically done by the 'eh_abort_handler' LLDD callback.
Conceptually, however, this function is a normal SCSI command, so
there is no need to enter the error handler.
This patch implements a new scsi_abort_command() function which
invokes an asynchronous function scsi_eh_abort_handler() to
abort the commands via the usual 'eh_abort_handler'.
If abort succeeds the command is either retried or terminated,
depending on the number of allowed retries. However, 'eh_eflags'
records the abort, so if the retry would fail again the
command is pushed onto the error handler without trying to
abort it (again); it'll be cleared up from SCSI EH.
Signed-off-by: Hannes Reinecke <hare@suse.de>
Cc: Ren Mingxin <renmx@cn.fujitsu.com>
Cc: Christoph Hellwig <hch@infradead.org>
---
drivers/scsi/scsi.c | 3 +
drivers/scsi/scsi_error.c | 151 ++++++++++++++++++++++++++++++++++++++++++----
drivers/scsi/scsi_priv.h | 2 +
include/scsi/scsi_cmnd.h | 1 +
include/scsi/scsi_host.h | 5 ++
5 files changed, 149 insertions(+), 13 deletions(-)
diff --git a/drivers/scsi/scsi.c b/drivers/scsi/scsi.c
index fe0bcb1..2b04a57 100644
--- a/drivers/scsi/scsi.c
+++ b/drivers/scsi/scsi.c
@@ -297,6 +297,7 @@ struct scsi_cmnd *scsi_get_command(struct scsi_device *dev, gfp_t gfp_mask)
cmd->device = dev;
INIT_LIST_HEAD(&cmd->list);
+ INIT_DELAYED_WORK(&cmd->abort_work, scmd_eh_abort_handler);
spin_lock_irqsave(&dev->list_lock, flags);
list_add_tail(&cmd->list, &dev->cmd_list);
spin_unlock_irqrestore(&dev->list_lock, flags);
@@ -353,6 +354,8 @@ void scsi_put_command(struct scsi_cmnd *cmd)
list_del_init(&cmd->list);
spin_unlock_irqrestore(&cmd->device->list_lock, flags);
+ cancel_delayed_work(&cmd->abort_work);
+
__scsi_put_command(cmd->device->host, cmd, &sdev->sdev_gendev);
}
EXPORT_SYMBOL(scsi_put_command);
diff --git a/drivers/scsi/scsi_error.c b/drivers/scsi/scsi_error.c
index 67c0014..7eecbb5 100644
--- a/drivers/scsi/scsi_error.c
+++ b/drivers/scsi/scsi_error.c
@@ -53,6 +53,8 @@ static void scsi_eh_done(struct scsi_cmnd *scmd);
#define HOST_RESET_SETTLE_TIME (10)
static int scsi_eh_try_stu(struct scsi_cmnd *scmd);
+static int scsi_try_to_abort_cmd(struct scsi_host_template *,
+ struct scsi_cmnd *);
/* called with shost->host_lock held */
void scsi_eh_wakeup(struct Scsi_Host *shost)
@@ -100,6 +102,116 @@ static int scsi_host_eh_past_deadline(struct Scsi_Host *shost)
}
/**
+ * scmd_eh_abort_handler - Handle command aborts
+ * @work: command to be aborted.
+ */
+void
+scmd_eh_abort_handler(struct work_struct *work)
+{
+ struct scsi_cmnd *scmd =
+ container_of(work, struct scsi_cmnd, abort_work.work);
+ struct scsi_device *sdev = scmd->device;
+ unsigned long flags;
+ int rtn;
+
+ spin_lock_irqsave(sdev->host->host_lock, flags);
+ if (scsi_host_eh_past_deadline(sdev->host)) {
+ spin_unlock_irqrestore(sdev->host->host_lock, flags);
+ SCSI_LOG_ERROR_RECOVERY(3,
+ scmd_printk(KERN_INFO, scmd,
+ "scmd %p eh timeout, not aborting\n",
+ scmd));
+ } else {
+ spin_unlock_irqrestore(sdev->host->host_lock, flags);
+ SCSI_LOG_ERROR_RECOVERY(3,
+ scmd_printk(KERN_INFO, scmd,
+ "aborting command %p\n", scmd));
+ rtn = scsi_try_to_abort_cmd(sdev->host->hostt, scmd);
+ if (rtn == SUCCESS) {
+ scmd->result |= DID_TIME_OUT << 16;
+ if (!scsi_noretry_cmd(scmd) &&
+ (++scmd->retries <= scmd->allowed)) {
+ SCSI_LOG_ERROR_RECOVERY(3,
+ scmd_printk(KERN_WARNING, scmd,
+ "scmd %p retry "
+ "aborted command\n", scmd));
+ scsi_queue_insert(scmd, SCSI_MLQUEUE_EH_RETRY);
+ } else {
+ SCSI_LOG_ERROR_RECOVERY(3,
+ scmd_printk(KERN_WARNING, scmd,
+ "scmd %p finish "
+ "aborted command\n", scmd));
+ scsi_finish_command(scmd);
+ }
+ return;
+ }
+ SCSI_LOG_ERROR_RECOVERY(3,
+ scmd_printk(KERN_INFO, scmd,
+ "scmd %p abort failed, rtn %d\n",
+ scmd, rtn));
+ }
+
+ if (!scsi_eh_scmd_add(scmd, 0)) {
+ SCSI_LOG_ERROR_RECOVERY(3,
+ scmd_printk(KERN_WARNING, scmd,
+ "scmd %p terminate "
+ "aborted command\n", scmd));
+ scmd->result |= DID_TIME_OUT << 16;
+ scsi_finish_command(scmd);
+ }
+}
+
+/**
+ * scsi_abort_command - schedule a command abort
+ * @scmd: scmd to abort.
+ *
+ * We only need to abort commands after a command timeout
+ */
+static int
+scsi_abort_command(struct scsi_cmnd *scmd)
+{
+ struct scsi_device *sdev = scmd->device;
+ struct Scsi_Host *shost = sdev->host;
+ unsigned long flags;
+
+ if (scmd->eh_eflags & SCSI_EH_ABORT_SCHEDULED) {
+ /*
+ * command abort timed out.
+ */
+ SCSI_LOG_ERROR_RECOVERY(3,
+ scmd_printk(KERN_INFO, scmd,
+ "scmd %p abort timeout\n", scmd));
+ cancel_delayed_work(&scmd->abort_work);
+ return FAILED;
+ }
+
+ /*
+ * Do not try a command abort if
+ * SCSI EH has already started.
+ */
+ spin_lock_irqsave(shost->host_lock, flags);
+ if (scsi_host_in_recovery(shost)) {
+ spin_unlock_irqrestore(shost->host_lock, flags);
+ SCSI_LOG_ERROR_RECOVERY(3,
+ scmd_printk(KERN_INFO, scmd,
+ "scmd %p not aborting, host in recovery\n",
+ scmd));
+ return FAILED;
+ }
+
+ if (shost->eh_deadline && !shost->last_reset)
+ shost->last_reset = jiffies;
+ spin_unlock_irqrestore(shost->host_lock, flags);
+
+ scmd->eh_eflags |= SCSI_EH_ABORT_SCHEDULED;
+ SCSI_LOG_ERROR_RECOVERY(3,
+ scmd_printk(KERN_INFO, scmd,
+ "scmd %p abort scheduled\n", scmd));
+ schedule_delayed_work(&scmd->abort_work, HZ / 100);
+ return SUCCESS;
+}
+
+/**
* scsi_eh_scmd_add - add scsi cmd to error handling.
* @scmd: scmd to run eh on.
* @eh_flag: optional SCSI_EH flag.
@@ -125,6 +237,8 @@ int scsi_eh_scmd_add(struct scsi_cmnd *scmd, int eh_flag)
shost->last_reset = jiffies;
ret = 1;
+ if (scmd->eh_eflags & SCSI_EH_ABORT_SCHEDULED)
+ eh_flag &= ~SCSI_EH_CANCEL_CMD;
scmd->eh_eflags |= eh_flag;
list_add_tail(&scmd->eh_entry, &shost->eh_cmd_q);
shost->host_failed++;
@@ -161,6 +275,10 @@ enum blk_eh_timer_return scsi_times_out(struct request *req)
else if (host->hostt->eh_timed_out)
rtn = host->hostt->eh_timed_out(scmd);
+ if (rtn == BLK_EH_NOT_HANDLED && !host->hostt->no_async_abort)
+ if (scsi_abort_command(scmd) == SUCCESS)
+ return BLK_EH_NOT_HANDLED;
+
scmd->result |= DID_TIME_OUT << 16;
if (unlikely(rtn == BLK_EH_NOT_HANDLED &&
@@ -1577,7 +1695,7 @@ static void scsi_eh_offline_sdevs(struct list_head *work_q,
}
/**
- * scsi_noretry_cmd - determinte if command should be failed fast
+ * scsi_noretry_cmd - determine if command should be failed fast
* @scmd: SCSI cmd to examine.
*/
int scsi_noretry_cmd(struct scsi_cmnd *scmd)
@@ -1585,6 +1703,8 @@ int scsi_noretry_cmd(struct scsi_cmnd *scmd)
switch (host_byte(scmd->result)) {
case DID_OK:
break;
+ case DID_TIME_OUT:
+ goto check_type;
case DID_BUS_BUSY:
return (scmd->request->cmd_flags & REQ_FAILFAST_TRANSPORT);
case DID_PARITY:
@@ -1598,18 +1718,19 @@ int scsi_noretry_cmd(struct scsi_cmnd *scmd)
return (scmd->request->cmd_flags & REQ_FAILFAST_DRIVER);
}
- switch (status_byte(scmd->result)) {
- case CHECK_CONDITION:
- /*
- * assume caller has checked sense and determinted
- * the check condition was retryable.
- */
- if (scmd->request->cmd_flags & REQ_FAILFAST_DEV ||
- scmd->request->cmd_type == REQ_TYPE_BLOCK_PC)
- return 1;
- }
+ switch (status_byte(scmd->result) != CHECK_CONDITION)
+ return 0;
- return 0;
+check_type:
+ /*
+ * assume caller has checked sense and determined
+ * the check condition was retryable.
+ */
+ if (scmd->request->cmd_flags & REQ_FAILFAST_DEV ||
+ scmd->request->cmd_type == REQ_TYPE_BLOCK_PC)
+ return 1;
+ else
+ return 0;
}
/**
@@ -1659,9 +1780,13 @@ int scsi_decide_disposition(struct scsi_cmnd *scmd)
* looks good. drop through, and check the next byte.
*/
break;
+ case DID_ABORT:
+ if (scmd->eh_eflags & SCSI_EH_ABORT_SCHEDULED) {
+ scmd->result |= DID_TIME_OUT << 16;
+ return SUCCESS;
+ }
case DID_NO_CONNECT:
case DID_BAD_TARGET:
- case DID_ABORT:
/*
* note - this means that we just report the status back
* to the top level driver, not that we actually think
diff --git a/drivers/scsi/scsi_priv.h b/drivers/scsi/scsi_priv.h
index 8f9a0ca..f079a59 100644
--- a/drivers/scsi/scsi_priv.h
+++ b/drivers/scsi/scsi_priv.h
@@ -19,6 +19,7 @@ struct scsi_nl_hdr;
* Scsi Error Handler Flags
*/
#define SCSI_EH_CANCEL_CMD 0x0001 /* Cancel this cmd */
+#define SCSI_EH_ABORT_SCHEDULED 0x0002 /* Abort has been scheduled */
#define SCSI_SENSE_VALID(scmd) \
(((scmd)->sense_buffer[0] & 0x70) == 0x70)
@@ -66,6 +67,7 @@ extern int __init scsi_init_devinfo(void);
extern void scsi_exit_devinfo(void);
/* scsi_error.c */
+extern void scmd_eh_abort_handler(struct work_struct *work);
extern enum blk_eh_timer_return scsi_times_out(struct request *req);
extern int scsi_error_handler(void *host);
extern int scsi_decide_disposition(struct scsi_cmnd *cmd);
diff --git a/include/scsi/scsi_cmnd.h b/include/scsi/scsi_cmnd.h
index de5f5d8..91558a1 100644
--- a/include/scsi/scsi_cmnd.h
+++ b/include/scsi/scsi_cmnd.h
@@ -55,6 +55,7 @@ struct scsi_cmnd {
struct scsi_device *device;
struct list_head list; /* scsi_cmnd participates in queue lists */
struct list_head eh_entry; /* entry for the host eh_cmd_q */
+ struct delayed_work abort_work;
int eh_eflags; /* Used by error handlr */
/*
diff --git a/include/scsi/scsi_host.h b/include/scsi/scsi_host.h
index 5460849..85430ae 100644
--- a/include/scsi/scsi_host.h
+++ b/include/scsi/scsi_host.h
@@ -476,6 +476,11 @@ struct scsi_host_template {
unsigned ordered_tag:1;
/*
+ * True if asynchronous aborts are not supported
+ */
+ unsigned no_async_abort:1;
+
+ /*
* Countdown for host blocking with no commands outstanding.
*/
unsigned int max_host_blocked;
--
1.7.12.4
^ permalink raw reply related [flat|nested] 21+ messages in thread* Re: [PATCH 2/5] scsi: improved eh timeout handler
2013-11-05 7:05 ` [PATCH 2/5] scsi: improved eh timeout handler Hannes Reinecke
@ 2013-11-05 19:19 ` Mike Christie
2013-11-06 6:48 ` Hannes Reinecke
2013-11-06 14:47 ` Christoph Hellwig
0 siblings, 2 replies; 21+ messages in thread
From: Mike Christie @ 2013-11-05 19:19 UTC (permalink / raw)
To: Hannes Reinecke
Cc: James Bottomley, Christoph Hellwig, linux-scsi, Ren Mingxin,
Joern Engel, James Smart
On 11/04/2013 11:05 PM, Hannes Reinecke wrote:
> +
> + scmd->eh_eflags |= SCSI_EH_ABORT_SCHEDULED;
> + SCSI_LOG_ERROR_RECOVERY(3,
> + scmd_printk(KERN_INFO, scmd,
> + "scmd %p abort scheduled\n", scmd));
> + schedule_delayed_work(&scmd->abort_work, HZ / 100);
> + return SUCCESS;
> +}
Do we want to use our own workqueue_struct with WQ_MEM_RECLAIM set?
^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [PATCH 2/5] scsi: improved eh timeout handler
2013-11-05 19:19 ` Mike Christie
@ 2013-11-06 6:48 ` Hannes Reinecke
2013-11-06 17:23 ` Mike Christie
2013-11-06 14:47 ` Christoph Hellwig
1 sibling, 1 reply; 21+ messages in thread
From: Hannes Reinecke @ 2013-11-06 6:48 UTC (permalink / raw)
To: Mike Christie
Cc: James Bottomley, Christoph Hellwig, linux-scsi, Ren Mingxin,
Joern Engel, James Smart
On 11/05/2013 08:19 PM, Mike Christie wrote:
> On 11/04/2013 11:05 PM, Hannes Reinecke wrote:
>> +
>> + scmd->eh_eflags |= SCSI_EH_ABORT_SCHEDULED;
>> + SCSI_LOG_ERROR_RECOVERY(3,
>> + scmd_printk(KERN_INFO, scmd,
>> + "scmd %p abort scheduled\n", scmd));
>> + schedule_delayed_work(&scmd->abort_work, HZ / 100);
>> + return SUCCESS;
>> +}
>
> Do we want to use our own workqueue_struct with WQ_MEM_RECLAIM set?
>
Errm. Yes, why?
I must admit I'm not _that_ familiar with workqueues ...
Care to explain?
Cheers,
Hannes
--
Dr. Hannes Reinecke zSeries & Storage
hare@suse.de +49 911 74053 688
SUSE LINUX Products GmbH, Maxfeldstr. 5, 90409 Nürnberg
GF: J. Hawn, J. Guild, F. Imendörffer, HRB 16746 (AG Nürnberg)
--
To unsubscribe from this list: send the line "unsubscribe linux-scsi" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [PATCH 2/5] scsi: improved eh timeout handler
2013-11-06 6:48 ` Hannes Reinecke
@ 2013-11-06 17:23 ` Mike Christie
2013-11-07 6:45 ` Hannes Reinecke
0 siblings, 1 reply; 21+ messages in thread
From: Mike Christie @ 2013-11-06 17:23 UTC (permalink / raw)
To: Hannes Reinecke
Cc: James Bottomley, Christoph Hellwig, linux-scsi, Ren Mingxin,
Joern Engel, James Smart
On 11/05/2013 10:48 PM, Hannes Reinecke wrote:
> On 11/05/2013 08:19 PM, Mike Christie wrote:
>> On 11/04/2013 11:05 PM, Hannes Reinecke wrote:
>>> +
>>> + scmd->eh_eflags |= SCSI_EH_ABORT_SCHEDULED;
>>> + SCSI_LOG_ERROR_RECOVERY(3,
>>> + scmd_printk(KERN_INFO, scmd,
>>> + "scmd %p abort scheduled\n", scmd));
>>> + schedule_delayed_work(&scmd->abort_work, HZ / 100);
>>> + return SUCCESS;
>>> +}
>>
>> Do we want to use our own workqueue_struct with WQ_MEM_RECLAIM set?
>>
> Errm. Yes, why?
>
> I must admit I'm not _that_ familiar with workqueues ...
> Care to explain?
>
We all share the above workqueue_structs pool of threads, so if we get
stuck behind code doing GFP_KERNEL allocs that end up needing to write
data to the disk we are now trying to aborts on, then we could get
stuck. With WQ_MEM_RECLAIM, we have our own backup thread that gets
created at workqueue_struct create time which can get used in cases like
that so we can always make forward progress.
^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [PATCH 2/5] scsi: improved eh timeout handler
2013-11-06 17:23 ` Mike Christie
@ 2013-11-07 6:45 ` Hannes Reinecke
2013-11-07 18:33 ` Douglas Gilbert
2013-11-09 8:35 ` James Bottomley
0 siblings, 2 replies; 21+ messages in thread
From: Hannes Reinecke @ 2013-11-07 6:45 UTC (permalink / raw)
To: Mike Christie
Cc: James Bottomley, Christoph Hellwig, linux-scsi, Ren Mingxin,
Joern Engel, James Smart
On 11/06/2013 06:23 PM, Mike Christie wrote:
> On 11/05/2013 10:48 PM, Hannes Reinecke wrote:
>> On 11/05/2013 08:19 PM, Mike Christie wrote:
>>> On 11/04/2013 11:05 PM, Hannes Reinecke wrote:
>>>> +
>>>> + scmd->eh_eflags |= SCSI_EH_ABORT_SCHEDULED;
>>>> + SCSI_LOG_ERROR_RECOVERY(3,
>>>> + scmd_printk(KERN_INFO, scmd,
>>>> + "scmd %p abort scheduled\n", scmd));
>>>> + schedule_delayed_work(&scmd->abort_work, HZ / 100);
>>>> + return SUCCESS;
>>>> +}
>>>
>>> Do we want to use our own workqueue_struct with WQ_MEM_RECLAIM set?
>>>
>> Errm. Yes, why?
>>
>> I must admit I'm not _that_ familiar with workqueues ...
>> Care to explain?
>>
>
> We all share the above workqueue_structs pool of threads, so if we get
> stuck behind code doing GFP_KERNEL allocs that end up needing to write
> data to the disk we are now trying to aborts on, then we could get
> stuck. With WQ_MEM_RECLAIM, we have our own backup thread that gets
> created at workqueue_struct create time which can get used in cases like
> that so we can always make forward progress.
>
Ah. Right. Yes, that makes sense.
I guess I'll have to redo the patches _yet again_.
Cheers,
Hannes
--
Dr. Hannes Reinecke zSeries & Storage
hare@suse.de +49 911 74053 688
SUSE LINUX Products GmbH, Maxfeldstr. 5, 90409 Nürnberg
GF: J. Hawn, J. Guild, F. Imendörffer, HRB 16746 (AG Nürnberg)
--
To unsubscribe from this list: send the line "unsubscribe linux-scsi" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [PATCH 2/5] scsi: improved eh timeout handler
2013-11-07 6:45 ` Hannes Reinecke
@ 2013-11-07 18:33 ` Douglas Gilbert
2013-11-08 15:54 ` Hannes Reinecke
2013-11-09 8:35 ` James Bottomley
1 sibling, 1 reply; 21+ messages in thread
From: Douglas Gilbert @ 2013-11-07 18:33 UTC (permalink / raw)
To: Hannes Reinecke, Mike Christie
Cc: James Bottomley, Christoph Hellwig, linux-scsi, Ren Mingxin,
Joern Engel, James Smart
On 13-11-07 01:45 AM, Hannes Reinecke wrote:
> On 11/06/2013 06:23 PM, Mike Christie wrote:
>> On 11/05/2013 10:48 PM, Hannes Reinecke wrote:
>>> On 11/05/2013 08:19 PM, Mike Christie wrote:
>>>> On 11/04/2013 11:05 PM, Hannes Reinecke wrote:
>>>>> +
>>>>> + scmd->eh_eflags |= SCSI_EH_ABORT_SCHEDULED;
>>>>> + SCSI_LOG_ERROR_RECOVERY(3,
>>>>> + scmd_printk(KERN_INFO, scmd,
>>>>> + "scmd %p abort scheduled\n", scmd));
>>>>> + schedule_delayed_work(&scmd->abort_work, HZ / 100);
>>>>> + return SUCCESS;
>>>>> +}
>>>>
>>>> Do we want to use our own workqueue_struct with WQ_MEM_RECLAIM set?
>>>>
>>> Errm. Yes, why?
>>>
>>> I must admit I'm not _that_ familiar with workqueues ...
>>> Care to explain?
>>>
>>
>> We all share the above workqueue_structs pool of threads, so if we get
>> stuck behind code doing GFP_KERNEL allocs that end up needing to write
>> data to the disk we are now trying to aborts on, then we could get
>> stuck. With WQ_MEM_RECLAIM, we have our own backup thread that gets
>> created at workqueue_struct create time which can get used in cases like
>> that so we can always make forward progress.
>>
> Ah. Right. Yes, that makes sense.
>
> I guess I'll have to redo the patches _yet again_.
I wonder if it might be useful to flag a LU (disk)
with "try really hard to recover me, perhaps at the
expense of other LUs". Seems like a LU containing the
rootfs or swap might qualify for setting such a flag.
And LUs that have this flag cleared could be assumed
to not get wedged in the fashion that Mike pointed out.
Doug Gilbert
^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [PATCH 2/5] scsi: improved eh timeout handler
2013-11-07 18:33 ` Douglas Gilbert
@ 2013-11-08 15:54 ` Hannes Reinecke
0 siblings, 0 replies; 21+ messages in thread
From: Hannes Reinecke @ 2013-11-08 15:54 UTC (permalink / raw)
To: dgilbert
Cc: Mike Christie, James Bottomley, Christoph Hellwig, linux-scsi,
Ren Mingxin, Joern Engel, James Smart
On 11/07/2013 07:33 PM, Douglas Gilbert wrote:
> On 13-11-07 01:45 AM, Hannes Reinecke wrote:
>> On 11/06/2013 06:23 PM, Mike Christie wrote:
>>> On 11/05/2013 10:48 PM, Hannes Reinecke wrote:
>>>> On 11/05/2013 08:19 PM, Mike Christie wrote:
>>>>> On 11/04/2013 11:05 PM, Hannes Reinecke wrote:
>>>>>> +
>>>>>> + scmd->eh_eflags |= SCSI_EH_ABORT_SCHEDULED;
>>>>>> + SCSI_LOG_ERROR_RECOVERY(3,
>>>>>> + scmd_printk(KERN_INFO, scmd,
>>>>>> + "scmd %p abort scheduled\n", scmd));
>>>>>> + schedule_delayed_work(&scmd->abort_work, HZ / 100);
>>>>>> + return SUCCESS;
>>>>>> +}
>>>>>
>>>>> Do we want to use our own workqueue_struct with WQ_MEM_RECLAIM
>>>>> set?
>>>>>
>>>> Errm. Yes, why?
>>>>
>>>> I must admit I'm not _that_ familiar with workqueues ...
>>>> Care to explain?
>>>>
>>>
>>> We all share the above workqueue_structs pool of threads, so if
>>> we get
>>> stuck behind code doing GFP_KERNEL allocs that end up needing to
>>> write
>>> data to the disk we are now trying to aborts on, then we could get
>>> stuck. With WQ_MEM_RECLAIM, we have our own backup thread that gets
>>> created at workqueue_struct create time which can get used in
>>> cases like
>>> that so we can always make forward progress.
>>>
>> Ah. Right. Yes, that makes sense.
>>
>> I guess I'll have to redo the patches _yet again_.
>
> I wonder if it might be useful to flag a LU (disk)
> with "try really hard to recover me, perhaps at the
> expense of other LUs". Seems like a LU containing the
> rootfs or swap might qualify for setting such a flag.
> And LUs that have this flag cleared could be assumed
> to not get wedged in the fashion that Mike pointed out.
>
While this would be a good idea in general, I would _very much_ see
to have this patch accepted first. Without that proviso
any discussion is pretty much moot anyway.
So I would like to defer that until the patch has been accepted.
Cheers,
Hannes
--
Dr. Hannes Reinecke zSeries & Storage
hare@suse.de +49 911 74053 688
SUSE LINUX Products GmbH, Maxfeldstr. 5, 90409 Nürnberg
GF: J. Hawn, J. Guild, F. Imendörffer, HRB 16746 (AG Nürnberg)
--
To unsubscribe from this list: send the line "unsubscribe linux-scsi" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [PATCH 2/5] scsi: improved eh timeout handler
2013-11-07 6:45 ` Hannes Reinecke
2013-11-07 18:33 ` Douglas Gilbert
@ 2013-11-09 8:35 ` James Bottomley
2013-11-09 15:27 ` Hannes Reinecke
1 sibling, 1 reply; 21+ messages in thread
From: James Bottomley @ 2013-11-09 8:35 UTC (permalink / raw)
To: Hannes Reinecke
Cc: Mike Christie, Christoph Hellwig, linux-scsi@vger.kernel.org,
Ren Mingxin, Joern Engel, James Smart
On Thu, 2013-11-07 at 07:45 +0100, Hannes Reinecke wrote:
> On 11/06/2013 06:23 PM, Mike Christie wrote:
> > On 11/05/2013 10:48 PM, Hannes Reinecke wrote:
> >> On 11/05/2013 08:19 PM, Mike Christie wrote:
> >>> On 11/04/2013 11:05 PM, Hannes Reinecke wrote:
> >>>> +
> >>>> + scmd->eh_eflags |= SCSI_EH_ABORT_SCHEDULED;
> >>>> + SCSI_LOG_ERROR_RECOVERY(3,
> >>>> + scmd_printk(KERN_INFO, scmd,
> >>>> + "scmd %p abort scheduled\n", scmd));
> >>>> + schedule_delayed_work(&scmd->abort_work, HZ / 100);
> >>>> + return SUCCESS;
> >>>> +}
> >>>
> >>> Do we want to use our own workqueue_struct with WQ_MEM_RECLAIM set?
> >>>
> >> Errm. Yes, why?
> >>
> >> I must admit I'm not _that_ familiar with workqueues ...
> >> Care to explain?
> >>
> >
> > We all share the above workqueue_structs pool of threads, so if we get
> > stuck behind code doing GFP_KERNEL allocs that end up needing to write
> > data to the disk we are now trying to aborts on, then we could get
> > stuck. With WQ_MEM_RECLAIM, we have our own backup thread that gets
> > created at workqueue_struct create time which can get used in cases like
> > that so we can always make forward progress.
> >
> Ah. Right. Yes, that makes sense.
>
> I guess I'll have to redo the patches _yet again_.
So when were you going to send the redo? The merge window is now open
and Linus was shirty with me about a late merge last time ...
James
^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [PATCH 2/5] scsi: improved eh timeout handler
2013-11-09 8:35 ` James Bottomley
@ 2013-11-09 15:27 ` Hannes Reinecke
0 siblings, 0 replies; 21+ messages in thread
From: Hannes Reinecke @ 2013-11-09 15:27 UTC (permalink / raw)
To: James Bottomley
Cc: Mike Christie, Christoph Hellwig, linux-scsi@vger.kernel.org,
Ren Mingxin, Joern Engel, James Smart
On 11/09/2013 09:35 AM, James Bottomley wrote:
> On Thu, 2013-11-07 at 07:45 +0100, Hannes Reinecke wrote:
>> On 11/06/2013 06:23 PM, Mike Christie wrote:
>>> On 11/05/2013 10:48 PM, Hannes Reinecke wrote:
>>>> On 11/05/2013 08:19 PM, Mike Christie wrote:
>>>>> On 11/04/2013 11:05 PM, Hannes Reinecke wrote:
>>>>>> +
>>>>>> + scmd->eh_eflags |= SCSI_EH_ABORT_SCHEDULED;
>>>>>> + SCSI_LOG_ERROR_RECOVERY(3,
>>>>>> + scmd_printk(KERN_INFO, scmd,
>>>>>> + "scmd %p abort scheduled\n", scmd));
>>>>>> + schedule_delayed_work(&scmd->abort_work, HZ / 100);
>>>>>> + return SUCCESS;
>>>>>> +}
>>>>>
>>>>> Do we want to use our own workqueue_struct with WQ_MEM_RECLAIM set?
>>>>>
>>>> Errm. Yes, why?
>>>>
>>>> I must admit I'm not _that_ familiar with workqueues ...
>>>> Care to explain?
>>>>
>>>
>>> We all share the above workqueue_structs pool of threads, so if we get
>>> stuck behind code doing GFP_KERNEL allocs that end up needing to write
>>> data to the disk we are now trying to aborts on, then we could get
>>> stuck. With WQ_MEM_RECLAIM, we have our own backup thread that gets
>>> created at workqueue_struct create time which can get used in cases like
>>> that so we can always make forward progress.
>>>
>> Ah. Right. Yes, that makes sense.
>>
>> I guess I'll have to redo the patches _yet again_.
>
> So when were you going to send the redo? The merge window is now open
> and Linus was shirty with me about a late merge last time ...
>
Patch is prepared, I'll just have to run a verification on it.
Will be sending the updated patchset on Monday.
Cheers,
Hannes
--
Dr. Hannes Reinecke zSeries & Storage
hare@suse.de +49 911 74053 688
SUSE LINUX Products GmbH, Maxfeldstr. 5, 90409 Nürnberg
GF: J. Hawn, J. Guild, F. Imendörffer, HRB 16746 (AG Nürnberg)
--
To unsubscribe from this list: send the line "unsubscribe linux-scsi" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [PATCH 2/5] scsi: improved eh timeout handler
2013-11-05 19:19 ` Mike Christie
2013-11-06 6:48 ` Hannes Reinecke
@ 2013-11-06 14:47 ` Christoph Hellwig
2013-11-07 6:42 ` Hannes Reinecke
1 sibling, 1 reply; 21+ messages in thread
From: Christoph Hellwig @ 2013-11-06 14:47 UTC (permalink / raw)
To: Mike Christie
Cc: Hannes Reinecke, James Bottomley, Christoph Hellwig, linux-scsi,
Ren Mingxin, Joern Engel, James Smart
On Tue, Nov 05, 2013 at 11:19:27AM -0800, Mike Christie wrote:
> > + scmd->eh_eflags |= SCSI_EH_ABORT_SCHEDULED;
> > + SCSI_LOG_ERROR_RECOVERY(3,
> > + scmd_printk(KERN_INFO, scmd,
> > + "scmd %p abort scheduled\n", scmd));
> > + schedule_delayed_work(&scmd->abort_work, HZ / 100);
> > + return SUCCESS;
> > +}
>
> Do we want to use our own workqueue_struct with WQ_MEM_RECLAIM set?
That's probably required, I can think of all kinds of issues otherwise.
Not in this patch series, but in the near future it might make sense
to convert the whole EH thread to that workqueue.
^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [PATCH 2/5] scsi: improved eh timeout handler
2013-11-06 14:47 ` Christoph Hellwig
@ 2013-11-07 6:42 ` Hannes Reinecke
0 siblings, 0 replies; 21+ messages in thread
From: Hannes Reinecke @ 2013-11-07 6:42 UTC (permalink / raw)
To: Christoph Hellwig
Cc: Mike Christie, James Bottomley, linux-scsi, Ren Mingxin,
Joern Engel, James Smart
On 11/06/2013 03:47 PM, Christoph Hellwig wrote:
> On Tue, Nov 05, 2013 at 11:19:27AM -0800, Mike Christie wrote:
>>> + scmd->eh_eflags |= SCSI_EH_ABORT_SCHEDULED;
>>> + SCSI_LOG_ERROR_RECOVERY(3,
>>> + scmd_printk(KERN_INFO, scmd,
>>> + "scmd %p abort scheduled\n", scmd));
>>> + schedule_delayed_work(&scmd->abort_work, HZ / 100);
>>> + return SUCCESS;
>>> +}
>>
>> Do we want to use our own workqueue_struct with WQ_MEM_RECLAIM set?
>
> That's probably required, I can think of all kinds of issues otherwise.
>
> Not in this patch series, but in the near future it might make sense
> to convert the whole EH thread to that workqueue.
>
And given the recent issues we had with RT scheduling I guess this
is the way to go.
_After_ this patchset gets in, that is ...
Cheers,
Hannes
--
Dr. Hannes Reinecke zSeries & Storage
hare@suse.de +49 911 74053 688
SUSE LINUX Products GmbH, Maxfeldstr. 5, 90409 Nürnberg
GF: J. Hawn, J. Guild, F. Imendörffer, HRB 16746 (AG Nürnberg)
--
To unsubscribe from this list: send the line "unsubscribe linux-scsi" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply [flat|nested] 21+ messages in thread
* [PATCH 3/5] scsi: Unlock accesses to eh_deadline
2013-11-05 7:05 [PATCHv10 0/5] New EH command timeout handler Hannes Reinecke
2013-11-05 7:05 ` [PATCH 1/5] scsi: Fix erratic device offline during EH Hannes Reinecke
2013-11-05 7:05 ` [PATCH 2/5] scsi: improved eh timeout handler Hannes Reinecke
@ 2013-11-05 7:05 ` Hannes Reinecke
2013-11-05 7:05 ` [PATCH 4/5] scsi: Set the minimum valid value of 'eh_deadline' as 0 Hannes Reinecke
2013-11-05 7:05 ` [PATCH 5/5] scsi: Update documentation Hannes Reinecke
4 siblings, 0 replies; 21+ messages in thread
From: Hannes Reinecke @ 2013-11-05 7:05 UTC (permalink / raw)
To: James Bottomley
Cc: Christoph Hellwig, linux-scsi, Ren Mingxin, Joern Engel,
James Smart, Hannes Reinecke
32bit accesses are guaranteed to be atomic, so we can remove
the spinlock when checking for eh_deadline. We only need to
make sure to catch any updates which might happened during
the call to time_before(); if so we just recheck with the
correct value.
Signed-off-by: Hannes Reinecke <hare@suse.de>
---
drivers/scsi/scsi_error.c | 44 +++++++++-----------------------------------
1 file changed, 9 insertions(+), 35 deletions(-)
diff --git a/drivers/scsi/scsi_error.c b/drivers/scsi/scsi_error.c
index 7eecbb5..a3f8988 100644
--- a/drivers/scsi/scsi_error.c
+++ b/drivers/scsi/scsi_error.c
@@ -94,8 +94,15 @@ static int scsi_host_eh_past_deadline(struct Scsi_Host *shost)
if (!shost->last_reset || !shost->eh_deadline)
return 0;
- if (time_before(jiffies,
- shost->last_reset + shost->eh_deadline))
+ /*
+ * 32bit accesses are guaranteed to be atomic
+ * (on all supported architectures), so instead
+ * of using a spinlock we can as well double check
+ * if eh_deadline has been unset during the
+ * time_before call.
+ */
+ if (time_before(jiffies, shost->last_reset + shost->eh_deadline) &&
+ shost->eh_deadline != 0)
return 0;
return 1;
@@ -111,18 +118,14 @@ scmd_eh_abort_handler(struct work_struct *work)
struct scsi_cmnd *scmd =
container_of(work, struct scsi_cmnd, abort_work.work);
struct scsi_device *sdev = scmd->device;
- unsigned long flags;
int rtn;
- spin_lock_irqsave(sdev->host->host_lock, flags);
if (scsi_host_eh_past_deadline(sdev->host)) {
- spin_unlock_irqrestore(sdev->host->host_lock, flags);
SCSI_LOG_ERROR_RECOVERY(3,
scmd_printk(KERN_INFO, scmd,
"scmd %p eh timeout, not aborting\n",
scmd));
} else {
- spin_unlock_irqrestore(sdev->host->host_lock, flags);
SCSI_LOG_ERROR_RECOVERY(3,
scmd_printk(KERN_INFO, scmd,
"aborting command %p\n", scmd));
@@ -1132,7 +1135,6 @@ int scsi_eh_get_sense(struct list_head *work_q,
struct scsi_cmnd *scmd, *next;
struct Scsi_Host *shost;
int rtn;
- unsigned long flags;
list_for_each_entry_safe(scmd, next, work_q, eh_entry) {
if ((scmd->eh_eflags & SCSI_EH_CANCEL_CMD) ||
@@ -1140,16 +1142,13 @@ int scsi_eh_get_sense(struct list_head *work_q,
continue;
shost = scmd->device->host;
- spin_lock_irqsave(shost->host_lock, flags);
if (scsi_host_eh_past_deadline(shost)) {
- spin_unlock_irqrestore(shost->host_lock, flags);
SCSI_LOG_ERROR_RECOVERY(3,
shost_printk(KERN_INFO, shost,
"skip %s, past eh deadline\n",
__func__));
break;
}
- spin_unlock_irqrestore(shost->host_lock, flags);
SCSI_LOG_ERROR_RECOVERY(2, scmd_printk(KERN_INFO, scmd,
"%s: requesting sense\n",
current->comm));
@@ -1235,26 +1234,21 @@ static int scsi_eh_test_devices(struct list_head *cmd_list,
struct scsi_cmnd *scmd, *next;
struct scsi_device *sdev;
int finish_cmds;
- unsigned long flags;
while (!list_empty(cmd_list)) {
scmd = list_entry(cmd_list->next, struct scsi_cmnd, eh_entry);
sdev = scmd->device;
if (!try_stu) {
- spin_lock_irqsave(sdev->host->host_lock, flags);
if (scsi_host_eh_past_deadline(sdev->host)) {
/* Push items back onto work_q */
list_splice_init(cmd_list, work_q);
- spin_unlock_irqrestore(sdev->host->host_lock,
- flags);
SCSI_LOG_ERROR_RECOVERY(3,
shost_printk(KERN_INFO, sdev->host,
"skip %s, past eh deadline",
__func__));
break;
}
- spin_unlock_irqrestore(sdev->host->host_lock, flags);
}
finish_cmds = !scsi_device_online(scmd->device) ||
@@ -1295,15 +1289,12 @@ static int scsi_eh_abort_cmds(struct list_head *work_q,
LIST_HEAD(check_list);
int rtn;
struct Scsi_Host *shost;
- unsigned long flags;
list_for_each_entry_safe(scmd, next, work_q, eh_entry) {
if (!(scmd->eh_eflags & SCSI_EH_CANCEL_CMD))
continue;
shost = scmd->device->host;
- spin_lock_irqsave(shost->host_lock, flags);
if (scsi_host_eh_past_deadline(shost)) {
- spin_unlock_irqrestore(shost->host_lock, flags);
list_splice_init(&check_list, work_q);
SCSI_LOG_ERROR_RECOVERY(3,
shost_printk(KERN_INFO, shost,
@@ -1311,7 +1302,6 @@ static int scsi_eh_abort_cmds(struct list_head *work_q,
__func__));
return list_empty(work_q);
}
- spin_unlock_irqrestore(shost->host_lock, flags);
SCSI_LOG_ERROR_RECOVERY(3, printk("%s: aborting cmd:"
"0x%p\n", current->comm,
scmd));
@@ -1375,19 +1365,15 @@ static int scsi_eh_stu(struct Scsi_Host *shost,
{
struct scsi_cmnd *scmd, *stu_scmd, *next;
struct scsi_device *sdev;
- unsigned long flags;
shost_for_each_device(sdev, shost) {
- spin_lock_irqsave(shost->host_lock, flags);
if (scsi_host_eh_past_deadline(shost)) {
- spin_unlock_irqrestore(shost->host_lock, flags);
SCSI_LOG_ERROR_RECOVERY(3,
shost_printk(KERN_INFO, shost,
"skip %s, past eh deadline\n",
__func__));
break;
}
- spin_unlock_irqrestore(shost->host_lock, flags);
stu_scmd = NULL;
list_for_each_entry(scmd, work_q, eh_entry)
if (scmd->device == sdev && SCSI_SENSE_VALID(scmd) &&
@@ -1441,20 +1427,16 @@ static int scsi_eh_bus_device_reset(struct Scsi_Host *shost,
{
struct scsi_cmnd *scmd, *bdr_scmd, *next;
struct scsi_device *sdev;
- unsigned long flags;
int rtn;
shost_for_each_device(sdev, shost) {
- spin_lock_irqsave(shost->host_lock, flags);
if (scsi_host_eh_past_deadline(shost)) {
- spin_unlock_irqrestore(shost->host_lock, flags);
SCSI_LOG_ERROR_RECOVERY(3,
shost_printk(KERN_INFO, shost,
"skip %s, past eh deadline\n",
__func__));
break;
}
- spin_unlock_irqrestore(shost->host_lock, flags);
bdr_scmd = NULL;
list_for_each_entry(scmd, work_q, eh_entry)
if (scmd->device == sdev) {
@@ -1515,11 +1497,8 @@ static int scsi_eh_target_reset(struct Scsi_Host *shost,
struct scsi_cmnd *next, *scmd;
int rtn;
unsigned int id;
- unsigned long flags;
- spin_lock_irqsave(shost->host_lock, flags);
if (scsi_host_eh_past_deadline(shost)) {
- spin_unlock_irqrestore(shost->host_lock, flags);
/* push back on work queue for further processing */
list_splice_init(&check_list, work_q);
list_splice_init(&tmp_list, work_q);
@@ -1529,7 +1508,6 @@ static int scsi_eh_target_reset(struct Scsi_Host *shost,
__func__));
return list_empty(work_q);
}
- spin_unlock_irqrestore(shost->host_lock, flags);
scmd = list_entry(tmp_list.next, struct scsi_cmnd, eh_entry);
id = scmd_id(scmd);
@@ -1574,7 +1552,6 @@ static int scsi_eh_bus_reset(struct Scsi_Host *shost,
LIST_HEAD(check_list);
unsigned int channel;
int rtn;
- unsigned long flags;
/*
* we really want to loop over the various channels, and do this on
@@ -1584,9 +1561,7 @@ static int scsi_eh_bus_reset(struct Scsi_Host *shost,
*/
for (channel = 0; channel <= shost->max_channel; channel++) {
- spin_lock_irqsave(shost->host_lock, flags);
if (scsi_host_eh_past_deadline(shost)) {
- spin_unlock_irqrestore(shost->host_lock, flags);
list_splice_init(&check_list, work_q);
SCSI_LOG_ERROR_RECOVERY(3,
shost_printk(KERN_INFO, shost,
@@ -1594,7 +1569,6 @@ static int scsi_eh_bus_reset(struct Scsi_Host *shost,
__func__));
return list_empty(work_q);
}
- spin_unlock_irqrestore(shost->host_lock, flags);
chan_scmd = NULL;
list_for_each_entry(scmd, work_q, eh_entry) {
--
1.7.12.4
^ permalink raw reply related [flat|nested] 21+ messages in thread* [PATCH 4/5] scsi: Set the minimum valid value of 'eh_deadline' as 0
2013-11-05 7:05 [PATCHv10 0/5] New EH command timeout handler Hannes Reinecke
` (2 preceding siblings ...)
2013-11-05 7:05 ` [PATCH 3/5] scsi: Unlock accesses to eh_deadline Hannes Reinecke
@ 2013-11-05 7:05 ` Hannes Reinecke
2013-11-05 7:05 ` [PATCH 5/5] scsi: Update documentation Hannes Reinecke
4 siblings, 0 replies; 21+ messages in thread
From: Hannes Reinecke @ 2013-11-05 7:05 UTC (permalink / raw)
To: James Bottomley
Cc: Christoph Hellwig, linux-scsi, Ren Mingxin, Joern Engel,
James Smart, Hannes Reinecke
From: Ren Mingxin <renmx@cn.fujitsu.com>
The former minimum valid value of 'eh_deadline' is 1s, which means
the earliest occasion to shorten EH is 1 second later since a
command is failed or timed out. But if we want to skip EH steps
ASAP, we have to wait until the first EH step is finished. If the
duration of the first EH step is long, this waiting time is
excruciating. So, it is necessary to accept 0 as the minimum valid
value for 'eh_deadline'.
According to my test, with Hannes' patchset 'New EH command timeout
handler' as well, the minimum IO time is improved from 73s
(eh_deadline = 1) to 43s(eh_deadline = 0) when commands are timed
out by disabling RSCN and target port.
Signed-off-by: Ren Mingxin <renmx@cn.fujitsu.com>
Signed-off-by: Hannes Reinecke <hare@suse.de>
---
drivers/scsi/hosts.c | 16 ++++++++++++----
drivers/scsi/scsi_error.c | 34 +++++++++++++++++++++-------------
drivers/scsi/scsi_sysfs.c | 36 +++++++++++++++++++++++++-----------
3 files changed, 58 insertions(+), 28 deletions(-)
diff --git a/drivers/scsi/hosts.c b/drivers/scsi/hosts.c
index f334859..bc8c462 100644
--- a/drivers/scsi/hosts.c
+++ b/drivers/scsi/hosts.c
@@ -316,11 +316,11 @@ static void scsi_host_dev_release(struct device *dev)
kfree(shost);
}
-static unsigned int shost_eh_deadline;
+static int shost_eh_deadline = -1;
-module_param_named(eh_deadline, shost_eh_deadline, uint, S_IRUGO|S_IWUSR);
+module_param_named(eh_deadline, shost_eh_deadline, int, S_IRUGO|S_IWUSR);
MODULE_PARM_DESC(eh_deadline,
- "SCSI EH timeout in seconds (should be between 1 and 2^32-1)");
+ "SCSI EH timeout in seconds (should be between 0 and 2^31-1)");
static struct device_type scsi_host_type = {
.name = "scsi_host",
@@ -394,7 +394,15 @@ struct Scsi_Host *scsi_host_alloc(struct scsi_host_template *sht, int privsize)
shost->unchecked_isa_dma = sht->unchecked_isa_dma;
shost->use_clustering = sht->use_clustering;
shost->ordered_tag = sht->ordered_tag;
- shost->eh_deadline = shost_eh_deadline * HZ;
+ if (shost_eh_deadline == -1)
+ shost->eh_deadline = -1;
+ else if ((ulong) shost_eh_deadline * HZ > INT_MAX) {
+ shost_printk(KERN_WARNING, shost,
+ "eh_deadline %u too large, setting to %u\n",
+ shost_eh_deadline, INT_MAX / HZ);
+ shost->eh_deadline = INT_MAX;
+ } else
+ shost->eh_deadline = shost_eh_deadline * HZ;
if (sht->supported_mode == MODE_UNKNOWN)
/* means we didn't set it ... default to INITIATOR */
diff --git a/drivers/scsi/scsi_error.c b/drivers/scsi/scsi_error.c
index a3f8988..f2fe580 100644
--- a/drivers/scsi/scsi_error.c
+++ b/drivers/scsi/scsi_error.c
@@ -91,18 +91,18 @@ EXPORT_SYMBOL_GPL(scsi_schedule_eh);
static int scsi_host_eh_past_deadline(struct Scsi_Host *shost)
{
- if (!shost->last_reset || !shost->eh_deadline)
+ if (!shost->last_reset || shost->eh_deadline == -1)
return 0;
/*
* 32bit accesses are guaranteed to be atomic
* (on all supported architectures), so instead
* of using a spinlock we can as well double check
- * if eh_deadline has been unset during the
+ * if eh_deadline has been set to 'off' during the
* time_before call.
*/
if (time_before(jiffies, shost->last_reset + shost->eh_deadline) &&
- shost->eh_deadline != 0)
+ shost->eh_deadline > -1)
return 0;
return 1;
@@ -132,26 +132,34 @@ scmd_eh_abort_handler(struct work_struct *work)
rtn = scsi_try_to_abort_cmd(sdev->host->hostt, scmd);
if (rtn == SUCCESS) {
scmd->result |= DID_TIME_OUT << 16;
- if (!scsi_noretry_cmd(scmd) &&
+ if (scsi_host_eh_past_deadline(sdev->host)) {
+ SCSI_LOG_ERROR_RECOVERY(3,
+ scmd_printk(KERN_INFO, scmd,
+ "scmd %p eh timeout, "
+ "not retrying aborted "
+ "command\n", scmd));
+ } else if (!scsi_noretry_cmd(scmd) &&
(++scmd->retries <= scmd->allowed)) {
SCSI_LOG_ERROR_RECOVERY(3,
scmd_printk(KERN_WARNING, scmd,
"scmd %p retry "
"aborted command\n", scmd));
scsi_queue_insert(scmd, SCSI_MLQUEUE_EH_RETRY);
+ return;
} else {
SCSI_LOG_ERROR_RECOVERY(3,
scmd_printk(KERN_WARNING, scmd,
"scmd %p finish "
"aborted command\n", scmd));
scsi_finish_command(scmd);
+ return;
}
- return;
+ } else {
+ SCSI_LOG_ERROR_RECOVERY(3,
+ scmd_printk(KERN_INFO, scmd,
+ "scmd %p abort failed, rtn %d\n",
+ scmd, rtn));
}
- SCSI_LOG_ERROR_RECOVERY(3,
- scmd_printk(KERN_INFO, scmd,
- "scmd %p abort failed, rtn %d\n",
- scmd, rtn));
}
if (!scsi_eh_scmd_add(scmd, 0)) {
@@ -202,7 +210,7 @@ scsi_abort_command(struct scsi_cmnd *scmd)
return FAILED;
}
- if (shost->eh_deadline && !shost->last_reset)
+ if (shost->eh_deadline != -1 && !shost->last_reset)
shost->last_reset = jiffies;
spin_unlock_irqrestore(shost->host_lock, flags);
@@ -236,7 +244,7 @@ int scsi_eh_scmd_add(struct scsi_cmnd *scmd, int eh_flag)
if (scsi_host_set_state(shost, SHOST_CANCEL_RECOVERY))
goto out_unlock;
- if (shost->eh_deadline && !shost->last_reset)
+ if (shost->eh_deadline != -1 && !shost->last_reset)
shost->last_reset = jiffies;
ret = 1;
@@ -270,7 +278,7 @@ enum blk_eh_timer_return scsi_times_out(struct request *req)
trace_scsi_dispatch_cmd_timeout(scmd);
scsi_log_completion(scmd, TIMEOUT_ERROR);
- if (host->eh_deadline && !host->last_reset)
+ if (host->eh_deadline != -1 && !host->last_reset)
host->last_reset = jiffies;
if (host->transportt->eh_timed_out)
@@ -2106,7 +2114,7 @@ static void scsi_unjam_host(struct Scsi_Host *shost)
scsi_eh_ready_devs(shost, &eh_work_q, &eh_done_q);
spin_lock_irqsave(shost->host_lock, flags);
- if (shost->eh_deadline)
+ if (shost->eh_deadline != -1)
shost->last_reset = 0;
spin_unlock_irqrestore(shost->host_lock, flags);
scsi_eh_flush_done_q(&eh_done_q);
diff --git a/drivers/scsi/scsi_sysfs.c b/drivers/scsi/scsi_sysfs.c
index 8ff62c2..9117d0b 100644
--- a/drivers/scsi/scsi_sysfs.c
+++ b/drivers/scsi/scsi_sysfs.c
@@ -287,7 +287,9 @@ show_shost_eh_deadline(struct device *dev,
{
struct Scsi_Host *shost = class_to_shost(dev);
- return sprintf(buf, "%d\n", shost->eh_deadline / HZ);
+ if (shost->eh_deadline == -1)
+ return snprintf(buf, strlen("off") + 2, "off\n");
+ return sprintf(buf, "%u\n", shost->eh_deadline / HZ);
}
static ssize_t
@@ -296,22 +298,34 @@ store_shost_eh_deadline(struct device *dev, struct device_attribute *attr,
{
struct Scsi_Host *shost = class_to_shost(dev);
int ret = -EINVAL;
- int deadline;
- unsigned long flags;
+ unsigned long deadline, flags;
if (shost->transportt && shost->transportt->eh_strategy_handler)
return ret;
- if (sscanf(buf, "%d\n", &deadline) == 1) {
- spin_lock_irqsave(shost->host_lock, flags);
- if (scsi_host_in_recovery(shost))
- ret = -EBUSY;
- else {
+ if (!strncmp(buf, "off", strlen("off")))
+ deadline = -1;
+ else {
+ ret = kstrtoul(buf, 10, &deadline);
+ if (ret)
+ return ret;
+ if (deadline * HZ > UINT_MAX)
+ return -EINVAL;
+ }
+
+ spin_lock_irqsave(shost->host_lock, flags);
+ if (scsi_host_in_recovery(shost))
+ ret = -EBUSY;
+ else {
+ if (deadline == -1)
+ shost->eh_deadline = -1;
+ else
shost->eh_deadline = deadline * HZ;
- ret = count;
- }
- spin_unlock_irqrestore(shost->host_lock, flags);
+
+ ret = count;
}
+ spin_unlock_irqrestore(shost->host_lock, flags);
+
return ret;
}
--
1.7.12.4
^ permalink raw reply related [flat|nested] 21+ messages in thread* [PATCH 5/5] scsi: Update documentation
2013-11-05 7:05 [PATCHv10 0/5] New EH command timeout handler Hannes Reinecke
` (3 preceding siblings ...)
2013-11-05 7:05 ` [PATCH 4/5] scsi: Set the minimum valid value of 'eh_deadline' as 0 Hannes Reinecke
@ 2013-11-05 7:05 ` Hannes Reinecke
4 siblings, 0 replies; 21+ messages in thread
From: Hannes Reinecke @ 2013-11-05 7:05 UTC (permalink / raw)
To: James Bottomley
Cc: Christoph Hellwig, linux-scsi, Ren Mingxin, Joern Engel,
James Smart, Hannes Reinecke
The documentation has gone out-of-sync, so update it to
the current status.
Signed-off-by: Hannes Reinecke <hare@suse.de>
---
Documentation/scsi/scsi_eh.txt | 69 +++++++++++++++++++--------------
Documentation/scsi/scsi_mid_low_api.txt | 9 ++++-
drivers/scsi/scsi.c | 6 +--
3 files changed, 48 insertions(+), 36 deletions(-)
diff --git a/Documentation/scsi/scsi_eh.txt b/Documentation/scsi/scsi_eh.txt
index 6ff16b6..a0c8511 100644
--- a/Documentation/scsi/scsi_eh.txt
+++ b/Documentation/scsi/scsi_eh.txt
@@ -42,20 +42,14 @@ discussion.
Once LLDD gets hold of a scmd, either the LLDD will complete the
command by calling scsi_done callback passed from midlayer when
-invoking hostt->queuecommand() or SCSI midlayer will time it out.
+invoking hostt->queuecommand() or the block layer will time it out.
[1-2-1] Completing a scmd w/ scsi_done
For all non-EH commands, scsi_done() is the completion callback. It
-does the following.
-
- 1. Delete timeout timer. If it fails, it means that timeout timer
- has expired and is going to finish the command. Just return.
-
- 2. Link scmd to per-cpu scsi_done_q using scmd->en_entry
-
- 3. Raise SCSI_SOFTIRQ
+just calls blk_complete_request() to delete the block layer timer and
+raise SCSI_SOFTIRQ
SCSI_SOFTIRQ handler scsi_softirq calls scsi_decide_disposition() to
determine what to do with the command. scsi_decide_disposition()
@@ -64,10 +58,12 @@ with the command.
- SUCCESS
scsi_finish_command() is invoked for the command. The
- function does some maintenance choirs and notify completion by
- calling scmd->done() callback, which, for fs requests, would
- be HLD completion callback - sd:sd_rw_intr, sr:rw_intr,
- st:st_intr.
+ function does some maintenance chores and then calls
+ scsi_io_completion() to finish the I/O.
+ scsi_io_completion() then notifies the block layer on
+ the completed request by calling blk_end_request and
+ friends or figures out what to do with the remainder
+ of the data in case of an error.
- NEEDS_RETRY
- ADD_TO_MLQUEUE
@@ -86,33 +82,45 @@ function
1. invokes optional hostt->eh_timed_out() callback. Return value can
be one of
- - EH_HANDLED
- This indicates that eh_timed_out() dealt with the timeout. The
- scmd is passed to __scsi_done() and thus linked into per-cpu
- scsi_done_q. Normal command completion described in [1-2-1]
- follows.
+ - BLK_EH_HANDLED
+ This indicates that eh_timed_out() dealt with the timeout.
+ The command is passed back to the block layer and completed
+ via __blk_complete_requests().
+
+ *NOTE* After returning BLK_EH_HANDLED the SCSI layer is
+ assumed to be finished with the command, and no other
+ functions from the SCSI layer will be called. So this
+ should typically only be returned if the eh_timed_out()
+ handler raced with normal completion.
- - EH_RESET_TIMER
+ - BLK_EH_RESET_TIMER
This indicates that more time is required to finish the
command. Timer is restarted. This action is counted as a
retry and only allowed scmd->allowed + 1(!) times. Once the
- limit is reached, action for EH_NOT_HANDLED is taken instead.
+ limit is reached, action for BLK_EH_NOT_HANDLED is taken instead.
- *NOTE* This action is racy as the LLDD could finish the scmd
- after the timeout has expired but before it's added back. In
- such cases, scsi_done() would think that timeout has occurred
- and return without doing anything. We lose completion and the
- command will time out again.
-
- - EH_NOT_HANDLED
- This is the same as when eh_timed_out() callback doesn't exist.
+ - BLK_EH_NOT_HANDLED
+ eh_timed_out() callback did not handle the command.
Step #2 is taken.
+ 2. If the host supports asynchronous completion (as indicated by the
+ no_async_abort setting in the host template) scsi_abort_command()
+ is invoked to schedule an asynchrous abort. If that fails
+ Step #3 is taken.
+
2. scsi_eh_scmd_add(scmd, SCSI_EH_CANCEL_CMD) is invoked for the
command. See [1-3] for more information.
+[1-3] Asynchronous command aborts
+
+ After a timeout occurs a command abort is scheduled from
+ scsi_abort_command(). If the abort is successful the command
+ will either be retried (if the number of retries is not exhausted)
+ or terminated with DID_TIME_OUT.
+ Otherwise scsi_eh_scmd_add() is invoked for the command.
+ See [1-4] for more information.
-[1-3] How EH takes over
+[1-4] How EH takes over
scmds enter EH via scsi_eh_scmd_add(), which does the following.
@@ -320,7 +328,8 @@ scmd->allowed.
<<scsi_eh_abort_cmds>>
- This action is taken for each timed out command.
+ This action is taken for each timed out command when
+ no_async_abort is enabled in the host template.
hostt->eh_abort_handler() is invoked for each scmd. The
handler returns SUCCESS if it has succeeded to make LLDD and
all related hardware forget about the scmd.
diff --git a/Documentation/scsi/scsi_mid_low_api.txt b/Documentation/scsi/scsi_mid_low_api.txt
index 2b06aba..d6a9bde 100644
--- a/Documentation/scsi/scsi_mid_low_api.txt
+++ b/Documentation/scsi/scsi_mid_low_api.txt
@@ -882,8 +882,11 @@ Details:
*
* Calling context: kernel thread
*
- * Notes: Invoked from scsi_eh thread. No other commands will be
- * queued on current host during eh.
+ * Notes: If 'no_async_abort' is defined this callback
+ * will be invoked from scsi_eh thread. No other commands
+ * will then be queued on current host during eh.
+ * Otherwise it will be called whenever scsi_times_out()
+ * is called due to a command timeout.
*
* Optionally defined in: LLD
**/
@@ -1257,6 +1260,8 @@ of interest:
address space
use_clustering - 1=>SCSI commands in mid level's queue can be merged,
0=>disallow SCSI command merging
+ no_async_abort - 1=>Asynchronous aborts are not supported
+ 0=>Timed-out commands will be aborted asynchronously
hostt - pointer to driver's struct scsi_host_template from which
this struct Scsi_Host instance was spawned
hostt->proc_name - name of LLD. This is the driver name that sysfs uses
diff --git a/drivers/scsi/scsi.c b/drivers/scsi/scsi.c
index 2b04a57..d8afec8 100644
--- a/drivers/scsi/scsi.c
+++ b/drivers/scsi/scsi.c
@@ -745,15 +745,13 @@ int scsi_dispatch_cmd(struct scsi_cmnd *cmd)
}
/**
- * scsi_done - Enqueue the finished SCSI command into the done queue.
+ * 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
- * enqueues the command to the done queue for further processing.
- *
- * This is the producer of the done queue who enqueues at the tail.
+ * calls blk_complete_request() for further processing.
*
* This function is interrupt context safe.
*/
--
1.7.12.4
^ permalink raw reply related [flat|nested] 21+ messages in thread
* [PATCH 2/5] scsi: improved eh timeout handler
2013-11-11 12:44 [PATCHv11 0/5] New EH command timeout handler Hannes Reinecke
@ 2013-11-11 12:44 ` Hannes Reinecke
2014-02-11 14:01 ` Christoph Hellwig
0 siblings, 1 reply; 21+ messages in thread
From: Hannes Reinecke @ 2013-11-11 12:44 UTC (permalink / raw)
To: James Bottomley
Cc: linux-scsi, Christoph Hellwig, Ren Mingxin, Joern Engel,
James Smart, Hannes Reinecke, Christoph Hellwig
When a command runs into a timeout we need to send an 'ABORT TASK'
TMF. This is typically done by the 'eh_abort_handler' LLDD callback.
Conceptually, however, this function is a normal SCSI command, so
there is no need to enter the error handler.
This patch implements a new scsi_abort_command() function which
invokes an asynchronous function scsi_eh_abort_handler() to
abort the commands via the usual 'eh_abort_handler'.
If abort succeeds the command is either retried or terminated,
depending on the number of allowed retries. However, 'eh_eflags'
records the abort, so if the retry would fail again the
command is pushed onto the error handler without trying to
abort it (again); it'll be cleared up from SCSI EH.
Signed-off-by: Hannes Reinecke <hare@suse.de>
Cc: Ren Mingxin <renmx@cn.fujitsu.com>
Cc: Christoph Hellwig <hch@infradead.org>
---
drivers/scsi/hosts.c | 14 ++++-
drivers/scsi/scsi.c | 3 +
drivers/scsi/scsi_error.c | 151 ++++++++++++++++++++++++++++++++++++++++++----
drivers/scsi/scsi_priv.h | 2 +
include/scsi/scsi_cmnd.h | 1 +
include/scsi/scsi_host.h | 10 +++
6 files changed, 167 insertions(+), 14 deletions(-)
diff --git a/drivers/scsi/hosts.c b/drivers/scsi/hosts.c
index f334859..3b619819 100644
--- a/drivers/scsi/hosts.c
+++ b/drivers/scsi/hosts.c
@@ -169,6 +169,7 @@ void scsi_remove_host(struct Scsi_Host *shost)
spin_unlock_irqrestore(shost->host_lock, flags);
scsi_autopm_get_host(shost);
+ flush_workqueue(shost->tmf_work_q);
scsi_forget_host(shost);
mutex_unlock(&shost->scan_mutex);
scsi_proc_host_rm(shost);
@@ -294,6 +295,8 @@ static void scsi_host_dev_release(struct device *dev)
scsi_proc_hostdir_rm(shost->hostt);
+ if (shost->tmf_work_q)
+ destroy_workqueue(shost->tmf_work_q);
if (shost->ehandler)
kthread_stop(shost->ehandler);
if (shost->work_q)
@@ -360,7 +363,6 @@ struct Scsi_Host *scsi_host_alloc(struct scsi_host_template *sht, int privsize)
INIT_LIST_HEAD(&shost->eh_cmd_q);
INIT_LIST_HEAD(&shost->starved_list);
init_waitqueue_head(&shost->host_wait);
-
mutex_init(&shost->scan_mutex);
/*
@@ -443,9 +445,19 @@ struct Scsi_Host *scsi_host_alloc(struct scsi_host_template *sht, int privsize)
goto fail_kfree;
}
+ shost->tmf_work_q = alloc_workqueue("scsi_tmf_%d",
+ WQ_UNBOUND | WQ_MEM_RECLAIM,
+ 1, shost->host_no);
+ if (!shost->tmf_work_q) {
+ printk(KERN_WARNING "scsi%d: failed to create tmf workq\n",
+ shost->host_no);
+ goto fail_kthread;
+ }
scsi_proc_hostdir_add(shost->hostt);
return shost;
+ fail_kthread:
+ kthread_stop(shost->ehandler);
fail_kfree:
kfree(shost);
return NULL;
diff --git a/drivers/scsi/scsi.c b/drivers/scsi/scsi.c
index fe0bcb1..2b04a57 100644
--- a/drivers/scsi/scsi.c
+++ b/drivers/scsi/scsi.c
@@ -297,6 +297,7 @@ struct scsi_cmnd *scsi_get_command(struct scsi_device *dev, gfp_t gfp_mask)
cmd->device = dev;
INIT_LIST_HEAD(&cmd->list);
+ INIT_DELAYED_WORK(&cmd->abort_work, scmd_eh_abort_handler);
spin_lock_irqsave(&dev->list_lock, flags);
list_add_tail(&cmd->list, &dev->cmd_list);
spin_unlock_irqrestore(&dev->list_lock, flags);
@@ -353,6 +354,8 @@ void scsi_put_command(struct scsi_cmnd *cmd)
list_del_init(&cmd->list);
spin_unlock_irqrestore(&cmd->device->list_lock, flags);
+ cancel_delayed_work(&cmd->abort_work);
+
__scsi_put_command(cmd->device->host, cmd, &sdev->sdev_gendev);
}
EXPORT_SYMBOL(scsi_put_command);
diff --git a/drivers/scsi/scsi_error.c b/drivers/scsi/scsi_error.c
index 67c0014..cab3c9b 100644
--- a/drivers/scsi/scsi_error.c
+++ b/drivers/scsi/scsi_error.c
@@ -53,6 +53,8 @@ static void scsi_eh_done(struct scsi_cmnd *scmd);
#define HOST_RESET_SETTLE_TIME (10)
static int scsi_eh_try_stu(struct scsi_cmnd *scmd);
+static int scsi_try_to_abort_cmd(struct scsi_host_template *,
+ struct scsi_cmnd *);
/* called with shost->host_lock held */
void scsi_eh_wakeup(struct Scsi_Host *shost)
@@ -100,6 +102,116 @@ static int scsi_host_eh_past_deadline(struct Scsi_Host *shost)
}
/**
+ * scmd_eh_abort_handler - Handle command aborts
+ * @work: command to be aborted.
+ */
+void
+scmd_eh_abort_handler(struct work_struct *work)
+{
+ struct scsi_cmnd *scmd =
+ container_of(work, struct scsi_cmnd, abort_work.work);
+ struct scsi_device *sdev = scmd->device;
+ unsigned long flags;
+ int rtn;
+
+ spin_lock_irqsave(sdev->host->host_lock, flags);
+ if (scsi_host_eh_past_deadline(sdev->host)) {
+ spin_unlock_irqrestore(sdev->host->host_lock, flags);
+ SCSI_LOG_ERROR_RECOVERY(3,
+ scmd_printk(KERN_INFO, scmd,
+ "scmd %p eh timeout, not aborting\n",
+ scmd));
+ } else {
+ spin_unlock_irqrestore(sdev->host->host_lock, flags);
+ SCSI_LOG_ERROR_RECOVERY(3,
+ scmd_printk(KERN_INFO, scmd,
+ "aborting command %p\n", scmd));
+ rtn = scsi_try_to_abort_cmd(sdev->host->hostt, scmd);
+ if (rtn == SUCCESS) {
+ scmd->result |= DID_TIME_OUT << 16;
+ if (!scsi_noretry_cmd(scmd) &&
+ (++scmd->retries <= scmd->allowed)) {
+ SCSI_LOG_ERROR_RECOVERY(3,
+ scmd_printk(KERN_WARNING, scmd,
+ "scmd %p retry "
+ "aborted command\n", scmd));
+ scsi_queue_insert(scmd, SCSI_MLQUEUE_EH_RETRY);
+ } else {
+ SCSI_LOG_ERROR_RECOVERY(3,
+ scmd_printk(KERN_WARNING, scmd,
+ "scmd %p finish "
+ "aborted command\n", scmd));
+ scsi_finish_command(scmd);
+ }
+ return;
+ }
+ SCSI_LOG_ERROR_RECOVERY(3,
+ scmd_printk(KERN_INFO, scmd,
+ "scmd %p abort failed, rtn %d\n",
+ scmd, rtn));
+ }
+
+ if (!scsi_eh_scmd_add(scmd, 0)) {
+ SCSI_LOG_ERROR_RECOVERY(3,
+ scmd_printk(KERN_WARNING, scmd,
+ "scmd %p terminate "
+ "aborted command\n", scmd));
+ scmd->result |= DID_TIME_OUT << 16;
+ scsi_finish_command(scmd);
+ }
+}
+
+/**
+ * scsi_abort_command - schedule a command abort
+ * @scmd: scmd to abort.
+ *
+ * We only need to abort commands after a command timeout
+ */
+static int
+scsi_abort_command(struct scsi_cmnd *scmd)
+{
+ struct scsi_device *sdev = scmd->device;
+ struct Scsi_Host *shost = sdev->host;
+ unsigned long flags;
+
+ if (scmd->eh_eflags & SCSI_EH_ABORT_SCHEDULED) {
+ /*
+ * Retry after abort failed, escalate to next level.
+ */
+ SCSI_LOG_ERROR_RECOVERY(3,
+ scmd_printk(KERN_INFO, scmd,
+ "scmd %p previous abort failed\n", scmd));
+ cancel_delayed_work(&scmd->abort_work);
+ return FAILED;
+ }
+
+ /*
+ * Do not try a command abort if
+ * SCSI EH has already started.
+ */
+ spin_lock_irqsave(shost->host_lock, flags);
+ if (scsi_host_in_recovery(shost)) {
+ spin_unlock_irqrestore(shost->host_lock, flags);
+ SCSI_LOG_ERROR_RECOVERY(3,
+ scmd_printk(KERN_INFO, scmd,
+ "scmd %p not aborting, host in recovery\n",
+ scmd));
+ return FAILED;
+ }
+
+ if (shost->eh_deadline && !shost->last_reset)
+ shost->last_reset = jiffies;
+ spin_unlock_irqrestore(shost->host_lock, flags);
+
+ scmd->eh_eflags |= SCSI_EH_ABORT_SCHEDULED;
+ SCSI_LOG_ERROR_RECOVERY(3,
+ scmd_printk(KERN_INFO, scmd,
+ "scmd %p abort scheduled\n", scmd));
+ queue_delayed_work(shost->tmf_work_q, &scmd->abort_work, HZ / 100);
+ return SUCCESS;
+}
+
+/**
* scsi_eh_scmd_add - add scsi cmd to error handling.
* @scmd: scmd to run eh on.
* @eh_flag: optional SCSI_EH flag.
@@ -125,6 +237,8 @@ int scsi_eh_scmd_add(struct scsi_cmnd *scmd, int eh_flag)
shost->last_reset = jiffies;
ret = 1;
+ if (scmd->eh_eflags & SCSI_EH_ABORT_SCHEDULED)
+ eh_flag &= ~SCSI_EH_CANCEL_CMD;
scmd->eh_eflags |= eh_flag;
list_add_tail(&scmd->eh_entry, &shost->eh_cmd_q);
shost->host_failed++;
@@ -161,6 +275,10 @@ enum blk_eh_timer_return scsi_times_out(struct request *req)
else if (host->hostt->eh_timed_out)
rtn = host->hostt->eh_timed_out(scmd);
+ if (rtn == BLK_EH_NOT_HANDLED && !host->hostt->no_async_abort)
+ if (scsi_abort_command(scmd) == SUCCESS)
+ return BLK_EH_NOT_HANDLED;
+
scmd->result |= DID_TIME_OUT << 16;
if (unlikely(rtn == BLK_EH_NOT_HANDLED &&
@@ -1577,7 +1695,7 @@ static void scsi_eh_offline_sdevs(struct list_head *work_q,
}
/**
- * scsi_noretry_cmd - determinte if command should be failed fast
+ * scsi_noretry_cmd - determine if command should be failed fast
* @scmd: SCSI cmd to examine.
*/
int scsi_noretry_cmd(struct scsi_cmnd *scmd)
@@ -1585,6 +1703,8 @@ int scsi_noretry_cmd(struct scsi_cmnd *scmd)
switch (host_byte(scmd->result)) {
case DID_OK:
break;
+ case DID_TIME_OUT:
+ goto check_type;
case DID_BUS_BUSY:
return (scmd->request->cmd_flags & REQ_FAILFAST_TRANSPORT);
case DID_PARITY:
@@ -1598,18 +1718,19 @@ int scsi_noretry_cmd(struct scsi_cmnd *scmd)
return (scmd->request->cmd_flags & REQ_FAILFAST_DRIVER);
}
- switch (status_byte(scmd->result)) {
- case CHECK_CONDITION:
- /*
- * assume caller has checked sense and determinted
- * the check condition was retryable.
- */
- if (scmd->request->cmd_flags & REQ_FAILFAST_DEV ||
- scmd->request->cmd_type == REQ_TYPE_BLOCK_PC)
- return 1;
- }
+ switch (status_byte(scmd->result) != CHECK_CONDITION)
+ return 0;
- return 0;
+check_type:
+ /*
+ * assume caller has checked sense and determined
+ * the check condition was retryable.
+ */
+ if (scmd->request->cmd_flags & REQ_FAILFAST_DEV ||
+ scmd->request->cmd_type == REQ_TYPE_BLOCK_PC)
+ return 1;
+ else
+ return 0;
}
/**
@@ -1659,9 +1780,13 @@ int scsi_decide_disposition(struct scsi_cmnd *scmd)
* looks good. drop through, and check the next byte.
*/
break;
+ case DID_ABORT:
+ if (scmd->eh_eflags & SCSI_EH_ABORT_SCHEDULED) {
+ scmd->result |= DID_TIME_OUT << 16;
+ return SUCCESS;
+ }
case DID_NO_CONNECT:
case DID_BAD_TARGET:
- case DID_ABORT:
/*
* note - this means that we just report the status back
* to the top level driver, not that we actually think
diff --git a/drivers/scsi/scsi_priv.h b/drivers/scsi/scsi_priv.h
index 8f9a0ca..f079a59 100644
--- a/drivers/scsi/scsi_priv.h
+++ b/drivers/scsi/scsi_priv.h
@@ -19,6 +19,7 @@ struct scsi_nl_hdr;
* Scsi Error Handler Flags
*/
#define SCSI_EH_CANCEL_CMD 0x0001 /* Cancel this cmd */
+#define SCSI_EH_ABORT_SCHEDULED 0x0002 /* Abort has been scheduled */
#define SCSI_SENSE_VALID(scmd) \
(((scmd)->sense_buffer[0] & 0x70) == 0x70)
@@ -66,6 +67,7 @@ extern int __init scsi_init_devinfo(void);
extern void scsi_exit_devinfo(void);
/* scsi_error.c */
+extern void scmd_eh_abort_handler(struct work_struct *work);
extern enum blk_eh_timer_return scsi_times_out(struct request *req);
extern int scsi_error_handler(void *host);
extern int scsi_decide_disposition(struct scsi_cmnd *cmd);
diff --git a/include/scsi/scsi_cmnd.h b/include/scsi/scsi_cmnd.h
index de5f5d8..91558a1 100644
--- a/include/scsi/scsi_cmnd.h
+++ b/include/scsi/scsi_cmnd.h
@@ -55,6 +55,7 @@ struct scsi_cmnd {
struct scsi_device *device;
struct list_head list; /* scsi_cmnd participates in queue lists */
struct list_head eh_entry; /* entry for the host eh_cmd_q */
+ struct delayed_work abort_work;
int eh_eflags; /* Used by error handlr */
/*
diff --git a/include/scsi/scsi_host.h b/include/scsi/scsi_host.h
index 5460849..4d671ac 100644
--- a/include/scsi/scsi_host.h
+++ b/include/scsi/scsi_host.h
@@ -476,6 +476,11 @@ struct scsi_host_template {
unsigned ordered_tag:1;
/*
+ * True if asynchronous aborts are not supported
+ */
+ unsigned no_async_abort:1;
+
+ /*
* Countdown for host blocking with no commands outstanding.
*/
unsigned int max_host_blocked;
@@ -684,6 +689,11 @@ struct Scsi_Host {
struct workqueue_struct *work_q;
/*
+ * Task management function work queue
+ */
+ struct workqueue_struct *tmf_work_q;
+
+ /*
* Host has rejected a command because it was busy.
*/
unsigned int host_blocked;
--
1.7.12.4
^ permalink raw reply related [flat|nested] 21+ messages in thread* Re: [PATCH 2/5] scsi: improved eh timeout handler
2013-11-11 12:44 ` [PATCH 2/5] scsi: improved eh " Hannes Reinecke
@ 2014-02-11 14:01 ` Christoph Hellwig
2014-02-11 14:29 ` Hannes Reinecke
0 siblings, 1 reply; 21+ messages in thread
From: Christoph Hellwig @ 2014-02-11 14:01 UTC (permalink / raw)
To: Hannes Reinecke
Cc: James Bottomley, linux-scsi, Christoph Hellwig, Ren Mingxin,
Joern Engel, James Smart, Christoph Hellwig
Hi Hannes,
I'll need a little reminder how we came to the conclusion that the
cancel_delayed_work in scsi_put_command was safe and we didn't need
a cancel_delayed_work_sync or flush_delayed_work. I remember we had
that discussion, but it seems that same doesn't apply to the equivalent
call in the blk-mq codepath in my tree. If you remember anything that
might make my life debugging this a bit easier.
^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [PATCH 2/5] scsi: improved eh timeout handler
2014-02-11 14:01 ` Christoph Hellwig
@ 2014-02-11 14:29 ` Hannes Reinecke
2014-02-12 7:45 ` Christoph Hellwig
0 siblings, 1 reply; 21+ messages in thread
From: Hannes Reinecke @ 2014-02-11 14:29 UTC (permalink / raw)
To: Christoph Hellwig
Cc: James Bottomley, linux-scsi, Christoph Hellwig, Ren Mingxin,
Joern Engel, James Smart
On 02/11/2014 03:01 PM, Christoph Hellwig wrote:
> Hi Hannes,
>
> I'll need a little reminder how we came to the conclusion that the
> cancel_delayed_work in scsi_put_command was safe and we didn't need
> a cancel_delayed_work_sync or flush_delayed_work. I remember we had
> that discussion, but it seems that same doesn't apply to the equivalent
> call in the blk-mq codepath in my tree. If you remember anything that
> might make my life debugging this a bit easier.
>
Well, _actually_ the cancel_delayed_work should be pointless; I've
just added it as a terminal measure here.
(It'd actually be an idea to insert a BUG_ON() here ...)
Thing is whenever the eh_timeout thingie kicks in we most definitely
know there's a command in flight, and hence scsi_command_put()
should _never_ be called.
Only after eh_abort has finished the command will be returned via
scsi_command_put(), but then eh_abort is done for, too, and no item
should remain in the workqueue.
HTH.
Cheers,
Hannes
--
Dr. Hannes Reinecke zSeries & Storage
hare@suse.de +49 911 74053 688
SUSE LINUX Products GmbH, Maxfeldstr. 5, 90409 Nürnberg
GF: J. Hawn, J. Guild, F. Imendörffer, HRB 16746 (AG Nürnberg)
--
To unsubscribe from this list: send the line "unsubscribe linux-scsi" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [PATCH 2/5] scsi: improved eh timeout handler
2014-02-11 14:29 ` Hannes Reinecke
@ 2014-02-12 7:45 ` Christoph Hellwig
2014-02-12 7:49 ` Hannes Reinecke
0 siblings, 1 reply; 21+ messages in thread
From: Christoph Hellwig @ 2014-02-12 7:45 UTC (permalink / raw)
To: Hannes Reinecke
Cc: Christoph Hellwig, James Bottomley, linux-scsi, Christoph Hellwig,
Ren Mingxin, Joern Engel, James Smart
On Tue, Feb 11, 2014 at 03:29:10PM +0100, Hannes Reinecke wrote:
> Well, _actually_ the cancel_delayed_work should be pointless; I've
> just added it as a terminal measure here.
> (It'd actually be an idea to insert a BUG_ON() here ...)
>
> Thing is whenever the eh_timeout thingie kicks in we most definitely
> know there's a command in flight, and hence scsi_command_put()
> should _never_ be called.
> Only after eh_abort has finished the command will be returned via
> scsi_command_put(), but then eh_abort is done for, too, and no item
> should remain in the workqueue.
The issue I saw actually was with a different workqueue, sorry for the
noise. I have to say I really hate the generic workqueue workers which
make it almost impossible to debug issues before they hit the actual
worker function..
^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [PATCH 2/5] scsi: improved eh timeout handler
2014-02-12 7:45 ` Christoph Hellwig
@ 2014-02-12 7:49 ` Hannes Reinecke
0 siblings, 0 replies; 21+ messages in thread
From: Hannes Reinecke @ 2014-02-12 7:49 UTC (permalink / raw)
To: Christoph Hellwig
Cc: James Bottomley, linux-scsi, Christoph Hellwig, Ren Mingxin,
Joern Engel, James Smart
On 02/12/2014 08:45 AM, Christoph Hellwig wrote:
> On Tue, Feb 11, 2014 at 03:29:10PM +0100, Hannes Reinecke wrote:
>> Well, _actually_ the cancel_delayed_work should be pointless; I've
>> just added it as a terminal measure here.
>> (It'd actually be an idea to insert a BUG_ON() here ...)
>>
>> Thing is whenever the eh_timeout thingie kicks in we most definitely
>> know there's a command in flight, and hence scsi_command_put()
>> should _never_ be called.
>> Only after eh_abort has finished the command will be returned via
>> scsi_command_put(), but then eh_abort is done for, too, and no item
>> should remain in the workqueue.
>
> The issue I saw actually was with a different workqueue, sorry for the
> noise. I have to say I really hate the generic workqueue workers which
> make it almost impossible to debug issues before they hit the actual
> worker function..
>
Oh, workqueues are fun, no doubt.
_Especially_ when some poor deluded soul executes I/O from userspace
tasks running with RT priorities.
Handling that properly would be a fitting subject for LSF ...
Cheers,
Hannes
--
Dr. Hannes Reinecke zSeries & Storage
hare@suse.de +49 911 74053 688
SUSE LINUX Products GmbH, Maxfeldstr. 5, 90409 Nürnberg
GF: J. Hawn, J. Guild, F. Imendörffer, HRB 16746 (AG Nürnberg)
--
To unsubscribe from this list: send the line "unsubscribe linux-scsi" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply [flat|nested] 21+ messages in thread