1	// SPDX-License-Identifier: GPL-2.0-only
2	/*
3	* scsi_error.c Copyright (C) 1997 Eric Youngdale
4	*
5	* SCSI error/timeout handling
6	* Initial versions: Eric Youngdale. Based upon conversations with
7	* Leonard Zubkoff and David Miller at Linux Expo,
8	* ideas originating from all over the place.
9	*
10	* Restructured scsi_unjam_host and associated functions.
11	* September 04, 2002 Mike Anderson (andmike@us.ibm.com)
12	*
13	* Forward port of Russell King's (rmk@arm.linux.org.uk) changes and
14	* minor cleanups.
15	* September 30, 2002 Mike Anderson (andmike@us.ibm.com)
16	*/
17
18	#include <linux/module.h>
19	#include <linux/sched.h>
20	#include <linux/gfp.h>
21	#include <linux/timer.h>
22	#include <linux/string.h>
23	#include <linux/kernel.h>
24	#include <linux/freezer.h>
25	#include <linux/kthread.h>
26	#include <linux/interrupt.h>
27	#include <linux/blkdev.h>
28	#include <linux/delay.h>
29	#include <linux/jiffies.h>
30
31	#include <scsi/scsi.h>
32	#include <scsi/scsi_cmnd.h>
33	#include <scsi/scsi_dbg.h>
34	#include <scsi/scsi_device.h>
35	#include <scsi/scsi_driver.h>
36	#include <scsi/scsi_eh.h>
37	#include <scsi/scsi_common.h>
38	#include <scsi/scsi_transport.h>
39	#include <scsi/scsi_host.h>
40	#include <scsi/scsi_ioctl.h>
41	#include <scsi/scsi_dh.h>
42	#include <scsi/scsi_devinfo.h>
43	#include <scsi/sg.h>
44
45	#include "scsi_priv.h"
46	#include "scsi_logging.h"
47	#include "scsi_transport_api.h"
48
49	#include <trace/events/scsi.h>
50
51	#include <asm/unaligned.h>
52
53	/*
54	* These should *probably* be handled by the host itself.
55	* Since it is allowed to sleep, it probably should.
56	*/
57	#define BUS_RESET_SETTLE_TIME (10)
58	#define HOST_RESET_SETTLE_TIME (10)
59
60	static int scsi_eh_try_stu(struct scsi_cmnd *scmd);
61	static enum scsi_disposition scsi_try_to_abort_cmd(const struct scsi_host_template *,
62	struct scsi_cmnd *);
63
64	void scsi_eh_wakeup(struct Scsi_Host *shost, unsigned int busy)
65	{
66	lockdep_assert_held(shost->host_lock);
67
68	if (busy == shost->host_failed) {
69	trace_scsi_eh_wakeup(shost);
70	wake_up_process(tsk: shost->ehandler);
71	SCSI_LOG_ERROR_RECOVERY(5, shost_printk(KERN_INFO, shost,
72	"Waking error handler thread\n"));
73	}
74	}
75
76	/**
77	* scsi_schedule_eh - schedule EH for SCSI host
78	* @shost: SCSI host to invoke error handling on.
79	*
80	* Schedule SCSI EH without scmd.
81	*/
82	void scsi_schedule_eh(struct Scsi_Host *shost)
83	{
84	unsigned long flags;
85
86	spin_lock_irqsave(shost->host_lock, flags);
87
88	if (scsi_host_set_state(shost, SHOST_RECOVERY) == 0 ||
89	scsi_host_set_state(shost, SHOST_CANCEL_RECOVERY) == 0) {
90	shost->host_eh_scheduled++;
91	scsi_eh_wakeup(shost, busy: scsi_host_busy(shost));
92	}
93
94	spin_unlock_irqrestore(lock: shost->host_lock, flags);
95	}
96	EXPORT_SYMBOL_GPL(scsi_schedule_eh);
97
98	static int scsi_host_eh_past_deadline(struct Scsi_Host *shost)
99	{
100	if (!shost->last_reset || shost->eh_deadline == -1)
101	return 0;
102
103	/*
104	* 32bit accesses are guaranteed to be atomic
105	* (on all supported architectures), so instead
106	* of using a spinlock we can as well double check
107	* if eh_deadline has been set to 'off' during the
108	* time_before call.
109	*/
110	if (time_before(jiffies, shost->last_reset + shost->eh_deadline) &&
111	shost->eh_deadline > -1)
112	return 0;
113
114	return 1;
115	}
116
117	static bool scsi_cmd_retry_allowed(struct scsi_cmnd *cmd)
118	{
119	if (cmd->allowed == SCSI_CMD_RETRIES_NO_LIMIT)
120	return true;
121
122	return ++cmd->retries <= cmd->allowed;
123	}
124
125	static bool scsi_eh_should_retry_cmd(struct scsi_cmnd *cmd)
126	{
127	struct scsi_device *sdev = cmd->device;
128	struct Scsi_Host *host = sdev->host;
129
130	if (host->hostt->eh_should_retry_cmd)
131	return host->hostt->eh_should_retry_cmd(cmd);
132
133	return true;
134	}
135
136	/**
137	* scmd_eh_abort_handler - Handle command aborts
138	* @work: command to be aborted.
139	*
140	* Note: this function must be called only for a command that has timed out.
141	* Because the block layer marks a request as complete before it calls
142	* scsi_timeout(), a .scsi_done() call from the LLD for a command that has
143	* timed out do not have any effect. Hence it is safe to call
144	* scsi_finish_command() from this function.
145	*/
146	void
147	scmd_eh_abort_handler(struct work_struct *work)
148	{
149	struct scsi_cmnd *scmd =
150	container_of(work, struct scsi_cmnd, abort_work.work);
151	struct scsi_device *sdev = scmd->device;
152	struct Scsi_Host *shost = sdev->host;
153	enum scsi_disposition rtn;
154	unsigned long flags;
155
156	if (scsi_host_eh_past_deadline(shost)) {
157	SCSI_LOG_ERROR_RECOVERY(3,
158	scmd_printk(KERN_INFO, scmd,
159	"eh timeout, not aborting\n"));
160	goto out;
161	}
162
163	SCSI_LOG_ERROR_RECOVERY(3,
164	scmd_printk(KERN_INFO, scmd,
165	"aborting command\n"));
166	rtn = scsi_try_to_abort_cmd(shost->hostt, scmd);
167	if (rtn != SUCCESS) {
168	SCSI_LOG_ERROR_RECOVERY(3,
169	scmd_printk(KERN_INFO, scmd,
170	"cmd abort %s\n",
171	(rtn == FAST_IO_FAIL) ?
172	"not send" : "failed"));
173	goto out;
174	}
175	set_host_byte(cmd: scmd, status: DID_TIME_OUT);
176	if (scsi_host_eh_past_deadline(shost)) {
177	SCSI_LOG_ERROR_RECOVERY(3,
178	scmd_printk(KERN_INFO, scmd,
179	"eh timeout, not retrying "
180	"aborted command\n"));
181	goto out;
182	}
183
184	spin_lock_irqsave(shost->host_lock, flags);
185	list_del_init(entry: &scmd->eh_entry);
186
187	/*
188	* If the abort succeeds, and there is no further
189	* EH action, clear the ->last_reset time.
190	*/
191	if (list_empty(head: &shost->eh_abort_list) &&
192	list_empty(head: &shost->eh_cmd_q))
193	if (shost->eh_deadline != -1)
194	shost->last_reset = 0;
195
196	spin_unlock_irqrestore(lock: shost->host_lock, flags);
197
198	if (!scsi_noretry_cmd(scmd) &&
199	scsi_cmd_retry_allowed(cmd: scmd) &&
200	scsi_eh_should_retry_cmd(cmd: scmd)) {
201	SCSI_LOG_ERROR_RECOVERY(3,
202	scmd_printk(KERN_WARNING, scmd,
203	"retry aborted command\n"));
204	scsi_queue_insert(cmd: scmd, SCSI_MLQUEUE_EH_RETRY);
205	} else {
206	SCSI_LOG_ERROR_RECOVERY(3,
207	scmd_printk(KERN_WARNING, scmd,
208	"finish aborted command\n"));
209	scsi_finish_command(cmd: scmd);
210	}
211	return;
212
213	out:
214	spin_lock_irqsave(shost->host_lock, flags);
215	list_del_init(entry: &scmd->eh_entry);
216	spin_unlock_irqrestore(lock: shost->host_lock, flags);
217
218	scsi_eh_scmd_add(scmd);
219	}
220
221	/**
222	* scsi_abort_command - schedule a command abort
223	* @scmd: scmd to abort.
224	*
225	* We only need to abort commands after a command timeout
226	*/
227	static int
228	scsi_abort_command(struct scsi_cmnd *scmd)
229	{
230	struct scsi_device *sdev = scmd->device;
231	struct Scsi_Host *shost = sdev->host;
232	unsigned long flags;
233
234	if (!shost->hostt->eh_abort_handler) {
235	/* No abort handler, fail command directly */
236	return FAILED;
237	}
238
239	if (scmd->eh_eflags & SCSI_EH_ABORT_SCHEDULED) {
240	/*
241	* Retry after abort failed, escalate to next level.
242	*/
243	SCSI_LOG_ERROR_RECOVERY(3,
244	scmd_printk(KERN_INFO, scmd,
245	"previous abort failed\n"));
246	BUG_ON(delayed_work_pending(&scmd->abort_work));
247	return FAILED;
248	}
249
250	spin_lock_irqsave(shost->host_lock, flags);
251	if (shost->eh_deadline != -1 && !shost->last_reset)
252	shost->last_reset = jiffies;
253	BUG_ON(!list_empty(&scmd->eh_entry));
254	list_add_tail(new: &scmd->eh_entry, head: &shost->eh_abort_list);
255	spin_unlock_irqrestore(lock: shost->host_lock, flags);
256
257	scmd->eh_eflags |= SCSI_EH_ABORT_SCHEDULED;
258	SCSI_LOG_ERROR_RECOVERY(3,
259	scmd_printk(KERN_INFO, scmd, "abort scheduled\n"));
260	queue_delayed_work(wq: shost->tmf_work_q, dwork: &scmd->abort_work, HZ / 100);
261	return SUCCESS;
262	}
263
264	/**
265	* scsi_eh_reset - call into ->eh_action to reset internal counters
266	* @scmd: scmd to run eh on.
267	*
268	* The scsi driver might be carrying internal state about the
269	* devices, so we need to call into the driver to reset the
270	* internal state once the error handler is started.
271	*/
272	static void scsi_eh_reset(struct scsi_cmnd *scmd)
273	{
274	if (!blk_rq_is_passthrough(rq: scsi_cmd_to_rq(scmd))) {
275	struct scsi_driver *sdrv = scsi_cmd_to_driver(cmd: scmd);
276	if (sdrv->eh_reset)
277	sdrv->eh_reset(scmd);
278	}
279	}
280
281	static void scsi_eh_inc_host_failed(struct rcu_head *head)
282	{
283	struct scsi_cmnd *scmd = container_of(head, typeof(*scmd), rcu);
284	struct Scsi_Host *shost = scmd->device->host;
285	unsigned int busy = scsi_host_busy(shost);
286	unsigned long flags;
287
288	spin_lock_irqsave(shost->host_lock, flags);
289	shost->host_failed++;
290	scsi_eh_wakeup(shost, busy);
291	spin_unlock_irqrestore(lock: shost->host_lock, flags);
292	}
293
294	/**
295	* scsi_eh_scmd_add - add scsi cmd to error handling.
296	* @scmd: scmd to run eh on.
297	*/
298	void scsi_eh_scmd_add(struct scsi_cmnd *scmd)
299	{
300	struct Scsi_Host *shost = scmd->device->host;
301	unsigned long flags;
302	int ret;
303
304	WARN_ON_ONCE(!shost->ehandler);
305	WARN_ON_ONCE(!test_bit(SCMD_STATE_INFLIGHT, &scmd->state));
306
307	spin_lock_irqsave(shost->host_lock, flags);
308	if (scsi_host_set_state(shost, SHOST_RECOVERY)) {
309	ret = scsi_host_set_state(shost, SHOST_CANCEL_RECOVERY);
310	WARN_ON_ONCE(ret);
311	}
312	if (shost->eh_deadline != -1 && !shost->last_reset)
313	shost->last_reset = jiffies;
314
315	scsi_eh_reset(scmd);
316	list_add_tail(new: &scmd->eh_entry, head: &shost->eh_cmd_q);
317	spin_unlock_irqrestore(lock: shost->host_lock, flags);
318	/*
319	* Ensure that all tasks observe the host state change before the
320	* host_failed change.
321	*/
322	call_rcu_hurry(head: &scmd->rcu, func: scsi_eh_inc_host_failed);
323	}
324
325	/**
326	* scsi_timeout - Timeout function for normal scsi commands.
327	* @req: request that is timing out.
328	*
329	* Notes:
330	* We do not need to lock this. There is the potential for a race
331	* only in that the normal completion handling might run, but if the
332	* normal completion function determines that the timer has already
333	* fired, then it mustn't do anything.
334	*/
335	enum blk_eh_timer_return scsi_timeout(struct request *req)
336	{
337	struct scsi_cmnd *scmd = blk_mq_rq_to_pdu(rq: req);
338	struct Scsi_Host *host = scmd->device->host;
339
340	trace_scsi_dispatch_cmd_timeout(cmd: scmd);
341	scsi_log_completion(cmd: scmd, disposition: TIMEOUT_ERROR);
342
343	atomic_inc(v: &scmd->device->iotmo_cnt);
344	if (host->eh_deadline != -1 && !host->last_reset)
345	host->last_reset = jiffies;
346
347	if (host->hostt->eh_timed_out) {
348	switch (host->hostt->eh_timed_out(scmd)) {
349	case SCSI_EH_DONE:
350	return BLK_EH_DONE;
351	case SCSI_EH_RESET_TIMER:
352	return BLK_EH_RESET_TIMER;
353	case SCSI_EH_NOT_HANDLED:
354	break;
355	}
356	}
357
358	/*
359	* If scsi_done() has already set SCMD_STATE_COMPLETE, do not modify
360	* *scmd.
361	*/
362	if (test_and_set_bit(SCMD_STATE_COMPLETE, addr: &scmd->state))
363	return BLK_EH_DONE;
364	atomic_inc(v: &scmd->device->iodone_cnt);
365	if (scsi_abort_command(scmd) != SUCCESS) {
366	set_host_byte(cmd: scmd, status: DID_TIME_OUT);
367	scsi_eh_scmd_add(scmd);
368	}
369
370	return BLK_EH_DONE;
371	}
372
373	/**
374	* scsi_block_when_processing_errors - Prevent cmds from being queued.
375	* @sdev: Device on which we are performing recovery.
376	*
377	* Description:
378	* We block until the host is out of error recovery, and then check to
379	* see whether the host or the device is offline.
380	*
381	* Return value:
382	* 0 when dev was taken offline by error recovery. 1 OK to proceed.
383	*/
384	int scsi_block_when_processing_errors(struct scsi_device *sdev)
385	{
386	int online;
387
388	wait_event(sdev->host->host_wait, !scsi_host_in_recovery(sdev->host));
389
390	online = scsi_device_online(sdev);
391
392	return online;
393	}
394	EXPORT_SYMBOL(scsi_block_when_processing_errors);
395
396	#ifdef CONFIG_SCSI_LOGGING
397	/**
398	* scsi_eh_prt_fail_stats - Log info on failures.
399	* @shost: scsi host being recovered.
400	* @work_q: Queue of scsi cmds to process.
401	*/
402	static inline void scsi_eh_prt_fail_stats(struct Scsi_Host *shost,
403	struct list_head *work_q)
404	{
405	struct scsi_cmnd *scmd;
406	struct scsi_device *sdev;
407	int total_failures = 0;
408	int cmd_failed = 0;
409	int cmd_cancel = 0;
410	int devices_failed = 0;
411
412	shost_for_each_device(sdev, shost) {
413	list_for_each_entry(scmd, work_q, eh_entry) {
414	if (scmd->device == sdev) {
415	++total_failures;
416	if (scmd->eh_eflags & SCSI_EH_ABORT_SCHEDULED)
417	++cmd_cancel;
418	else
419	++cmd_failed;
420	}
421	}
422
423	if (cmd_cancel || cmd_failed) {
424	SCSI_LOG_ERROR_RECOVERY(3,
425	shost_printk(KERN_INFO, shost,
426	"%s: cmds failed: %d, cancel: %d\n",
427	__func__, cmd_failed,
428	cmd_cancel));
429	cmd_cancel = 0;
430	cmd_failed = 0;
431	++devices_failed;
432	}
433	}
434
435	SCSI_LOG_ERROR_RECOVERY(2, shost_printk(KERN_INFO, shost,
436	"Total of %d commands on %d"
437	" devices require eh work\n",
438	total_failures, devices_failed));
439	}
440	#endif
441
442	/**
443	* scsi_report_lun_change - Set flag on all *other* devices on the same target
444	* to indicate that a UNIT ATTENTION is expected.
445	* @sdev: Device reporting the UNIT ATTENTION
446	*/
447	static void scsi_report_lun_change(struct scsi_device *sdev)
448	{
449	sdev->sdev_target->expecting_lun_change = 1;
450	}
451
452	/**
453	* scsi_report_sense - Examine scsi sense information and log messages for
454	* certain conditions, also issue uevents for some of them.
455	* @sdev: Device reporting the sense code
456	* @sshdr: sshdr to be examined
457	*/
458	static void scsi_report_sense(struct scsi_device *sdev,
459	struct scsi_sense_hdr *sshdr)
460	{
461	enum scsi_device_event evt_type = SDEV_EVT_MAXBITS; /* i.e. none */
462
463	if (sshdr->sense_key == UNIT_ATTENTION) {
464	if (sshdr->asc == 0x3f && sshdr->ascq == 0x03) {
465	evt_type = SDEV_EVT_INQUIRY_CHANGE_REPORTED;
466	sdev_printk(KERN_WARNING, sdev,
467	"Inquiry data has changed");
468	} else if (sshdr->asc == 0x3f && sshdr->ascq == 0x0e) {
469	evt_type = SDEV_EVT_LUN_CHANGE_REPORTED;
470	scsi_report_lun_change(sdev);
471	sdev_printk(KERN_WARNING, sdev,
472	"LUN assignments on this target have "
473	"changed. The Linux SCSI layer does not "
474	"automatically remap LUN assignments.\n");
475	} else if (sshdr->asc == 0x3f)
476	sdev_printk(KERN_WARNING, sdev,
477	"Operating parameters on this target have "
478	"changed. The Linux SCSI layer does not "
479	"automatically adjust these parameters.\n");
480
481	if (sshdr->asc == 0x38 && sshdr->ascq == 0x07) {
482	evt_type = SDEV_EVT_SOFT_THRESHOLD_REACHED_REPORTED;
483	sdev_printk(KERN_WARNING, sdev,
484	"Warning! Received an indication that the "
485	"LUN reached a thin provisioning soft "
486	"threshold.\n");
487	}
488
489	if (sshdr->asc == 0x29) {
490	evt_type = SDEV_EVT_POWER_ON_RESET_OCCURRED;
491	/*
492	* Do not print message if it is an expected side-effect
493	* of runtime PM.
494	*/
495	if (!sdev->silence_suspend)
496	sdev_printk(KERN_WARNING, sdev,
497	"Power-on or device reset occurred\n");
498	}
499
500	if (sshdr->asc == 0x2a && sshdr->ascq == 0x01) {
501	evt_type = SDEV_EVT_MODE_PARAMETER_CHANGE_REPORTED;
502	sdev_printk(KERN_WARNING, sdev,
503	"Mode parameters changed");
504	} else if (sshdr->asc == 0x2a && sshdr->ascq == 0x06) {
505	evt_type = SDEV_EVT_ALUA_STATE_CHANGE_REPORTED;
506	sdev_printk(KERN_WARNING, sdev,
507	"Asymmetric access state changed");
508	} else if (sshdr->asc == 0x2a && sshdr->ascq == 0x09) {
509	evt_type = SDEV_EVT_CAPACITY_CHANGE_REPORTED;
510	sdev_printk(KERN_WARNING, sdev,
511	"Capacity data has changed");
512	} else if (sshdr->asc == 0x2a)
513	sdev_printk(KERN_WARNING, sdev,
514	"Parameters changed");
515	}
516
517	if (evt_type != SDEV_EVT_MAXBITS) {
518	set_bit(nr: evt_type, addr: sdev->pending_events);
519	schedule_work(work: &sdev->event_work);
520	}
521	}
522
523	static inline void set_scsi_ml_byte(struct scsi_cmnd *cmd, u8 status)
524	{
525	cmd->result = (cmd->result & 0xffff00ff) | (status << 8);
526	}
527
528	/**
529	* scsi_check_sense - Examine scsi cmd sense
530	* @scmd: Cmd to have sense checked.
531	*
532	* Return value:
533	* SUCCESS or FAILED or NEEDS_RETRY or ADD_TO_MLQUEUE
534	*
535	* Notes:
536	* When a deferred error is detected the current command has
537	* not been executed and needs retrying.
538	*/
539	enum scsi_disposition scsi_check_sense(struct scsi_cmnd *scmd)
540	{
541	struct request *req = scsi_cmd_to_rq(scmd);
542	struct scsi_device *sdev = scmd->device;
543	struct scsi_sense_hdr sshdr;
544
545	if (! scsi_command_normalize_sense(cmd: scmd, sshdr: &sshdr))
546	return FAILED; /* no valid sense data */
547
548	scsi_report_sense(sdev, sshdr: &sshdr);
549
550	if (scsi_sense_is_deferred(sshdr: &sshdr))
551	return NEEDS_RETRY;
552
553	if (sdev->handler && sdev->handler->check_sense) {
554	enum scsi_disposition rc;
555
556	rc = sdev->handler->check_sense(sdev, &sshdr);
557	if (rc != SCSI_RETURN_NOT_HANDLED)
558	return rc;
559	/* handler does not care. Drop down to default handling */
560	}
561
562	if (scmd->cmnd[0] == TEST_UNIT_READY &&
563	scmd->submitter != SUBMITTED_BY_SCSI_ERROR_HANDLER)
564	/*
565	* nasty: for mid-layer issued TURs, we need to return the
566	* actual sense data without any recovery attempt. For eh
567	* issued ones, we need to try to recover and interpret
568	*/
569	return SUCCESS;
570
571	/*
572	* Previous logic looked for FILEMARK, EOM or ILI which are
573	* mainly associated with tapes and returned SUCCESS.
574	*/
575	if (sshdr.response_code == 0x70) {
576	/* fixed format */
577	if (scmd->sense_buffer[2] & 0xe0)
578	return SUCCESS;
579	} else {
580	/*
581	* descriptor format: look for "stream commands sense data
582	* descriptor" (see SSC-3). Assume single sense data
583	* descriptor. Ignore ILI from SBC-2 READ LONG and WRITE LONG.
584	*/
585	if ((sshdr.additional_length > 3) &&
586	(scmd->sense_buffer[8] == 0x4) &&
587	(scmd->sense_buffer[11] & 0xe0))
588	return SUCCESS;
589	}
590
591	switch (sshdr.sense_key) {
592	case NO_SENSE:
593	return SUCCESS;
594	case RECOVERED_ERROR:
595	return /* soft_error */ SUCCESS;
596
597	case ABORTED_COMMAND:
598	if (sshdr.asc == 0x10) /* DIF */
599	return SUCCESS;
600
601	/*
602	* Check aborts due to command duration limit policy:
603	* ABORTED COMMAND additional sense code with the
604	* COMMAND TIMEOUT BEFORE PROCESSING or
605	* COMMAND TIMEOUT DURING PROCESSING or
606	* COMMAND TIMEOUT DURING PROCESSING DUE TO ERROR RECOVERY
607	* additional sense code qualifiers.
608	*/
609	if (sshdr.asc == 0x2e &&
610	sshdr.ascq >= 0x01 && sshdr.ascq <= 0x03) {
611	set_scsi_ml_byte(cmd: scmd, status: SCSIML_STAT_DL_TIMEOUT);
612	req->cmd_flags |= REQ_FAILFAST_DEV;
613	req->rq_flags |= RQF_QUIET;
614	return SUCCESS;
615	}
616
617	if (sshdr.asc == 0x44 && sdev->sdev_bflags & BLIST_RETRY_ITF)
618	return ADD_TO_MLQUEUE;
619	if (sshdr.asc == 0xc1 && sshdr.ascq == 0x01 &&
620	sdev->sdev_bflags & BLIST_RETRY_ASC_C1)
621	return ADD_TO_MLQUEUE;
622
623	return NEEDS_RETRY;
624	case NOT_READY:
625	case UNIT_ATTENTION:
626	/*
627	* if we are expecting a cc/ua because of a bus reset that we
628	* performed, treat this just as a retry. otherwise this is
629	* information that we should pass up to the upper-level driver
630	* so that we can deal with it there.
631	*/
632	if (scmd->device->expecting_cc_ua) {
633	/*
634	* Because some device does not queue unit
635	* attentions correctly, we carefully check
636	* additional sense code and qualifier so as
637	* not to squash media change unit attention.
638	*/
639	if (sshdr.asc != 0x28 || sshdr.ascq != 0x00) {
640	scmd->device->expecting_cc_ua = 0;
641	return NEEDS_RETRY;
642	}
643	}
644	/*
645	* we might also expect a cc/ua if another LUN on the target
646	* reported a UA with an ASC/ASCQ of 3F 0E -
647	* REPORTED LUNS DATA HAS CHANGED.
648	*/
649	if (scmd->device->sdev_target->expecting_lun_change &&
650	sshdr.asc == 0x3f && sshdr.ascq == 0x0e)
651	return NEEDS_RETRY;
652	/*
653	* if the device is in the process of becoming ready, we
654	* should retry.
655	*/
656	if ((sshdr.asc == 0x04) && (sshdr.ascq == 0x01))
657	return NEEDS_RETRY;
658	/*
659	* if the device is not started, we need to wake
660	* the error handler to start the motor
661	*/
662	if (scmd->device->allow_restart &&
663	(sshdr.asc == 0x04) && (sshdr.ascq == 0x02))
664	return FAILED;
665	/*
666	* Pass the UA upwards for a determination in the completion
667	* functions.
668	*/
669	return SUCCESS;
670
671	/* these are not supported */
672	case DATA_PROTECT:
673	if (sshdr.asc == 0x27 && sshdr.ascq == 0x07) {
674	/* Thin provisioning hard threshold reached */
675	set_scsi_ml_byte(cmd: scmd, status: SCSIML_STAT_NOSPC);
676	return SUCCESS;
677	}
678	fallthrough;
679	case COPY_ABORTED:
680	case VOLUME_OVERFLOW:
681	case MISCOMPARE:
682	case BLANK_CHECK:
683	set_scsi_ml_byte(cmd: scmd, status: SCSIML_STAT_TGT_FAILURE);
684	return SUCCESS;
685
686	case MEDIUM_ERROR:
687	if (sshdr.asc == 0x11 || /* UNRECOVERED READ ERR */
688	sshdr.asc == 0x13 || /* AMNF DATA FIELD */
689	sshdr.asc == 0x14) { /* RECORD NOT FOUND */
690	set_scsi_ml_byte(cmd: scmd, status: SCSIML_STAT_MED_ERROR);
691	return SUCCESS;
692	}
693	return NEEDS_RETRY;
694
695	case HARDWARE_ERROR:
696	if (scmd->device->retry_hwerror)
697	return ADD_TO_MLQUEUE;
698	else
699	set_scsi_ml_byte(cmd: scmd, status: SCSIML_STAT_TGT_FAILURE);
700	fallthrough;
701
702	case ILLEGAL_REQUEST:
703	if (sshdr.asc == 0x20 || /* Invalid command operation code */
704	sshdr.asc == 0x21 || /* Logical block address out of range */
705	sshdr.asc == 0x22 || /* Invalid function */
706	sshdr.asc == 0x24 || /* Invalid field in cdb */
707	sshdr.asc == 0x26 || /* Parameter value invalid */
708	sshdr.asc == 0x27) { /* Write protected */
709	set_scsi_ml_byte(cmd: scmd, status: SCSIML_STAT_TGT_FAILURE);
710	}
711	return SUCCESS;
712
713	case COMPLETED:
714	if (sshdr.asc == 0x55 && sshdr.ascq == 0x0a) {
715	set_scsi_ml_byte(cmd: scmd, status: SCSIML_STAT_DL_TIMEOUT);
716	req->cmd_flags |= REQ_FAILFAST_DEV;
717	req->rq_flags |= RQF_QUIET;
718	}
719	return SUCCESS;
720
721	default:
722	return SUCCESS;
723	}
724	}
725	EXPORT_SYMBOL_GPL(scsi_check_sense);
726
727	static void scsi_handle_queue_ramp_up(struct scsi_device *sdev)
728	{
729	const struct scsi_host_template *sht = sdev->host->hostt;
730	struct scsi_device *tmp_sdev;
731
732	if (!sht->track_queue_depth ||
733	sdev->queue_depth >= sdev->max_queue_depth)
734	return;
735
736	if (time_before(jiffies,
737	sdev->last_queue_ramp_up + sdev->queue_ramp_up_period))
738	return;
739
740	if (time_before(jiffies,
741	sdev->last_queue_full_time + sdev->queue_ramp_up_period))
742	return;
743
744	/*
745	* Walk all devices of a target and do
746	* ramp up on them.
747	*/
748	shost_for_each_device(tmp_sdev, sdev->host) {
749	if (tmp_sdev->channel != sdev->channel ||
750	tmp_sdev->id != sdev->id ||
751	tmp_sdev->queue_depth == sdev->max_queue_depth)
752	continue;
753
754	scsi_change_queue_depth(tmp_sdev, tmp_sdev->queue_depth + 1);
755	sdev->last_queue_ramp_up = jiffies;
756	}
757	}
758
759	static void scsi_handle_queue_full(struct scsi_device *sdev)
760	{
761	const struct scsi_host_template *sht = sdev->host->hostt;
762	struct scsi_device *tmp_sdev;
763
764	if (!sht->track_queue_depth)
765	return;
766
767	shost_for_each_device(tmp_sdev, sdev->host) {
768	if (tmp_sdev->channel != sdev->channel ||
769	tmp_sdev->id != sdev->id)
770	continue;
771	/*
772	* We do not know the number of commands that were at
773	* the device when we got the queue full so we start
774	* from the highest possible value and work our way down.
775	*/
776	scsi_track_queue_full(tmp_sdev, tmp_sdev->queue_depth - 1);
777	}
778	}
779
780	/**
781	* scsi_eh_completed_normally - Disposition a eh cmd on return from LLD.
782	* @scmd: SCSI cmd to examine.
783	*
784	* Notes:
785	* This is *only* called when we are examining the status of commands
786	* queued during error recovery. the main difference here is that we
787	* don't allow for the possibility of retries here, and we are a lot
788	* more restrictive about what we consider acceptable.
789	*/
790	static enum scsi_disposition scsi_eh_completed_normally(struct scsi_cmnd *scmd)
791	{
792	/*
793	* first check the host byte, to see if there is anything in there
794	* that would indicate what we need to do.
795	*/
796	if (host_byte(scmd->result) == DID_RESET) {
797	/*
798	* rats. we are already in the error handler, so we now
799	* get to try and figure out what to do next. if the sense
800	* is valid, we have a pretty good idea of what to do.
801	* if not, we mark it as FAILED.
802	*/
803	return scsi_check_sense(scmd);
804	}
805	if (host_byte(scmd->result) != DID_OK)
806	return FAILED;
807
808	/*
809	* now, check the status byte to see if this indicates
810	* anything special.
811	*/
812	switch (get_status_byte(cmd: scmd)) {
813	case SAM_STAT_GOOD:
814	scsi_handle_queue_ramp_up(sdev: scmd->device);
815	if (scmd->sense_buffer && SCSI_SENSE_VALID(scmd))
816	/*
817	* If we have sense data, call scsi_check_sense() in
818	* order to set the correct SCSI ML byte (if any).
819	* No point in checking the return value, since the
820	* command has already completed successfully.
821	*/
822	scsi_check_sense(scmd);
823	fallthrough;
824	case SAM_STAT_COMMAND_TERMINATED:
825	return SUCCESS;
826	case SAM_STAT_CHECK_CONDITION:
827	return scsi_check_sense(scmd);
828	case SAM_STAT_CONDITION_MET:
829	case SAM_STAT_INTERMEDIATE:
830	case SAM_STAT_INTERMEDIATE_CONDITION_MET:
831	/*
832	* who knows? FIXME(eric)
833	*/
834	return SUCCESS;
835	case SAM_STAT_RESERVATION_CONFLICT:
836	if (scmd->cmnd[0] == TEST_UNIT_READY)
837	/* it is a success, we probed the device and
838	* found it */
839	return SUCCESS;
840	/* otherwise, we failed to send the command */
841	return FAILED;
842	case SAM_STAT_TASK_SET_FULL:
843	scsi_handle_queue_full(sdev: scmd->device);
844	fallthrough;
845	case SAM_STAT_BUSY:
846	return NEEDS_RETRY;
847	default:
848	return FAILED;
849	}
850	return FAILED;
851	}
852
853	/**
854	* scsi_eh_done - Completion function for error handling.
855	* @scmd: Cmd that is done.
856	*/
857	void scsi_eh_done(struct scsi_cmnd *scmd)
858	{
859	struct completion *eh_action;
860
861	SCSI_LOG_ERROR_RECOVERY(3, scmd_printk(KERN_INFO, scmd,
862	"%s result: %x\n", __func__, scmd->result));
863
864	eh_action = scmd->device->host->eh_action;
865	if (eh_action)
866	complete(eh_action);
867	}
868
869	/**
870	* scsi_try_host_reset - ask host adapter to reset itself
871	* @scmd: SCSI cmd to send host reset.
872	*/
873	static enum scsi_disposition scsi_try_host_reset(struct scsi_cmnd *scmd)
874	{
875	unsigned long flags;
876	enum scsi_disposition rtn;
877	struct Scsi_Host *host = scmd->device->host;
878	const struct scsi_host_template *hostt = host->hostt;
879
880	SCSI_LOG_ERROR_RECOVERY(3,
881	shost_printk(KERN_INFO, host, "Snd Host RST\n"));
882
883	if (!hostt->eh_host_reset_handler)
884	return FAILED;
885
886	rtn = hostt->eh_host_reset_handler(scmd);
887
888	if (rtn == SUCCESS) {
889	if (!hostt->skip_settle_delay)
890	ssleep(HOST_RESET_SETTLE_TIME);
891	spin_lock_irqsave(host->host_lock, flags);
892	scsi_report_bus_reset(host, scmd_channel(scmd));
893	spin_unlock_irqrestore(lock: host->host_lock, flags);
894	}
895
896	return rtn;
897	}
898
899	/**
900	* scsi_try_bus_reset - ask host to perform a bus reset
901	* @scmd: SCSI cmd to send bus reset.
902	*/
903	static enum scsi_disposition scsi_try_bus_reset(struct scsi_cmnd *scmd)
904	{
905	unsigned long flags;
906	enum scsi_disposition rtn;
907	struct Scsi_Host *host = scmd->device->host;
908	const struct scsi_host_template *hostt = host->hostt;
909
910	SCSI_LOG_ERROR_RECOVERY(3, scmd_printk(KERN_INFO, scmd,
911	"%s: Snd Bus RST\n", __func__));
912
913	if (!hostt->eh_bus_reset_handler)
914	return FAILED;
915
916	rtn = hostt->eh_bus_reset_handler(scmd);
917
918	if (rtn == SUCCESS) {
919	if (!hostt->skip_settle_delay)
920	ssleep(BUS_RESET_SETTLE_TIME);
921	spin_lock_irqsave(host->host_lock, flags);
922	scsi_report_bus_reset(host, scmd_channel(scmd));
923	spin_unlock_irqrestore(lock: host->host_lock, flags);
924	}
925
926	return rtn;
927	}
928
929	static void __scsi_report_device_reset(struct scsi_device *sdev, void *data)
930	{
931	sdev->was_reset = 1;
932	sdev->expecting_cc_ua = 1;
933	}
934
935	/**
936	* scsi_try_target_reset - Ask host to perform a target reset
937	* @scmd: SCSI cmd used to send a target reset
938	*
939	* Notes:
940	* There is no timeout for this operation. if this operation is
941	* unreliable for a given host, then the host itself needs to put a
942	* timer on it, and set the host back to a consistent state prior to
943	* returning.
944	*/
945	static enum scsi_disposition scsi_try_target_reset(struct scsi_cmnd *scmd)
946	{
947	unsigned long flags;
948	enum scsi_disposition rtn;
949	struct Scsi_Host *host = scmd->device->host;
950	const struct scsi_host_template *hostt = host->hostt;
951
952	if (!hostt->eh_target_reset_handler)
953	return FAILED;
954
955	rtn = hostt->eh_target_reset_handler(scmd);
956	if (rtn == SUCCESS) {
957	spin_lock_irqsave(host->host_lock, flags);
958	__starget_for_each_device(scsi_target(sdev: scmd->device), NULL,
959	fn: __scsi_report_device_reset);
960	spin_unlock_irqrestore(lock: host->host_lock, flags);
961	}
962
963	return rtn;
964	}
965
966	/**
967	* scsi_try_bus_device_reset - Ask host to perform a BDR on a dev
968	* @scmd: SCSI cmd used to send BDR
969	*
970	* Notes:
971	* There is no timeout for this operation. if this operation is
972	* unreliable for a given host, then the host itself needs to put a
973	* timer on it, and set the host back to a consistent state prior to
974	* returning.
975	*/
976	static enum scsi_disposition scsi_try_bus_device_reset(struct scsi_cmnd *scmd)
977	{
978	enum scsi_disposition rtn;
979	const struct scsi_host_template *hostt = scmd->device->host->hostt;
980
981	if (!hostt->eh_device_reset_handler)
982	return FAILED;
983
984	rtn = hostt->eh_device_reset_handler(scmd);
985	if (rtn == SUCCESS)
986	__scsi_report_device_reset(sdev: scmd->device, NULL);
987	return rtn;
988	}
989
990	/**
991	* scsi_try_to_abort_cmd - Ask host to abort a SCSI command
992	* @hostt: SCSI driver host template
993	* @scmd: SCSI cmd used to send a target reset
994	*
995	* Return value:
996	* SUCCESS, FAILED, or FAST_IO_FAIL
997	*
998	* Notes:
999	* SUCCESS does not necessarily indicate that the command
1000	* has been aborted; it only indicates that the LLDDs
1001	* has cleared all references to that command.
1002	* LLDDs should return FAILED only if an abort was required
1003	* but could not be executed. LLDDs should return FAST_IO_FAIL
1004	* if the device is temporarily unavailable (eg due to a
1005	* link down on FibreChannel)
1006	*/
1007	static enum scsi_disposition
1008	scsi_try_to_abort_cmd(const struct scsi_host_template *hostt, struct scsi_cmnd *scmd)
1009	{
1010	if (!hostt->eh_abort_handler)
1011	return FAILED;
1012
1013	return hostt->eh_abort_handler(scmd);
1014	}
1015
1016	static void scsi_abort_eh_cmnd(struct scsi_cmnd *scmd)
1017	{
1018	if (scsi_try_to_abort_cmd(hostt: scmd->device->host->hostt, scmd) != SUCCESS)
1019	if (scsi_try_bus_device_reset(scmd) != SUCCESS)
1020	if (scsi_try_target_reset(scmd) != SUCCESS)
1021	if (scsi_try_bus_reset(scmd) != SUCCESS)
1022	scsi_try_host_reset(scmd);
1023	}
1024
1025	/**
1026	* scsi_eh_prep_cmnd - Save a scsi command info as part of error recovery
1027	* @scmd: SCSI command structure to hijack
1028	* @ses: structure to save restore information
1029	* @cmnd: CDB to send. Can be NULL if no new cmnd is needed
1030	* @cmnd_size: size in bytes of @cmnd (must be <= MAX_COMMAND_SIZE)
1031	* @sense_bytes: size of sense data to copy. or 0 (if != 0 @cmnd is ignored)
1032	*
1033	* This function is used to save a scsi command information before re-execution
1034	* as part of the error recovery process. If @sense_bytes is 0 the command
1035	* sent must be one that does not transfer any data. If @sense_bytes != 0
1036	* @cmnd is ignored and this functions sets up a REQUEST_SENSE command
1037	* and cmnd buffers to read @sense_bytes into @scmd->sense_buffer.
1038	*/
1039	void scsi_eh_prep_cmnd(struct scsi_cmnd *scmd, struct scsi_eh_save *ses,
1040	unsigned char *cmnd, int cmnd_size, unsigned sense_bytes)
1041	{
1042	struct scsi_device *sdev = scmd->device;
1043
1044	/*
1045	* We need saved copies of a number of fields - this is because
1046	* error handling may need to overwrite these with different values
1047	* to run different commands, and once error handling is complete,
1048	* we will need to restore these values prior to running the actual
1049	* command.
1050	*/
1051	ses->cmd_len = scmd->cmd_len;
1052	ses->data_direction = scmd->sc_data_direction;
1053	ses->sdb = scmd->sdb;
1054	ses->result = scmd->result;
1055	ses->resid_len = scmd->resid_len;
1056	ses->underflow = scmd->underflow;
1057	ses->prot_op = scmd->prot_op;
1058	ses->eh_eflags = scmd->eh_eflags;
1059
1060	scmd->prot_op = SCSI_PROT_NORMAL;
1061	scmd->eh_eflags = 0;
1062	memcpy(ses->cmnd, scmd->cmnd, sizeof(ses->cmnd));
1063	memset(scmd->cmnd, 0, sizeof(scmd->cmnd));
1064	memset(&scmd->sdb, 0, sizeof(scmd->sdb));
1065	scmd->result = 0;
1066	scmd->resid_len = 0;
1067
1068	if (sense_bytes) {
1069	scmd->sdb.length = min_t(unsigned, SCSI_SENSE_BUFFERSIZE,
1070	sense_bytes);
1071	sg_init_one(&ses->sense_sgl, scmd->sense_buffer,
1072	scmd->sdb.length);
1073	scmd->sdb.table.sgl = &ses->sense_sgl;
1074	scmd->sc_data_direction = DMA_FROM_DEVICE;
1075	scmd->sdb.table.nents = scmd->sdb.table.orig_nents = 1;
1076	scmd->cmnd[0] = REQUEST_SENSE;
1077	scmd->cmnd[4] = scmd->sdb.length;
1078	scmd->cmd_len = COMMAND_SIZE(scmd->cmnd[0]);
1079	} else {
1080	scmd->sc_data_direction = DMA_NONE;
1081	if (cmnd) {
1082	BUG_ON(cmnd_size > sizeof(scmd->cmnd));
1083	memcpy(scmd->cmnd, cmnd, cmnd_size);
1084	scmd->cmd_len = COMMAND_SIZE(scmd->cmnd[0]);
1085	}
1086	}
1087
1088	scmd->underflow = 0;
1089
1090	if (sdev->scsi_level <= SCSI_2 && sdev->scsi_level != SCSI_UNKNOWN)
1091	scmd->cmnd[1] = (scmd->cmnd[1] & 0x1f) |
1092	(sdev->lun << 5 & 0xe0);
1093
1094	/*
1095	* Zero the sense buffer. The scsi spec mandates that any
1096	* untransferred sense data should be interpreted as being zero.
1097	*/
1098	memset(scmd->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
1099	}
1100	EXPORT_SYMBOL(scsi_eh_prep_cmnd);
1101
1102	/**
1103	* scsi_eh_restore_cmnd - Restore a scsi command info as part of error recovery
1104	* @scmd: SCSI command structure to restore
1105	* @ses: saved information from a coresponding call to scsi_eh_prep_cmnd
1106	*
1107	* Undo any damage done by above scsi_eh_prep_cmnd().
1108	*/
1109	void scsi_eh_restore_cmnd(struct scsi_cmnd* scmd, struct scsi_eh_save *ses)
1110	{
1111	/*
1112	* Restore original data
1113	*/
1114	scmd->cmd_len = ses->cmd_len;
1115	memcpy(scmd->cmnd, ses->cmnd, sizeof(ses->cmnd));
1116	scmd->sc_data_direction = ses->data_direction;
1117	scmd->sdb = ses->sdb;
1118	scmd->result = ses->result;
1119	scmd->resid_len = ses->resid_len;
1120	scmd->underflow = ses->underflow;
1121	scmd->prot_op = ses->prot_op;
1122	scmd->eh_eflags = ses->eh_eflags;
1123	}
1124	EXPORT_SYMBOL(scsi_eh_restore_cmnd);
1125
1126	/**
1127	* scsi_send_eh_cmnd - submit a scsi command as part of error recovery
1128	* @scmd: SCSI command structure to hijack
1129	* @cmnd: CDB to send
1130	* @cmnd_size: size in bytes of @cmnd
1131	* @timeout: timeout for this request
1132	* @sense_bytes: size of sense data to copy or 0
1133	*
1134	* This function is used to send a scsi command down to a target device
1135	* as part of the error recovery process. See also scsi_eh_prep_cmnd() above.
1136	*
1137	* Return value:
1138	* SUCCESS or FAILED or NEEDS_RETRY
1139	*/
1140	static enum scsi_disposition scsi_send_eh_cmnd(struct scsi_cmnd *scmd,
1141	unsigned char *cmnd, int cmnd_size, int timeout, unsigned sense_bytes)
1142	{
1143	struct scsi_device *sdev = scmd->device;
1144	struct Scsi_Host *shost = sdev->host;
1145	DECLARE_COMPLETION_ONSTACK(done);
1146	unsigned long timeleft = timeout, delay;
1147	struct scsi_eh_save ses;
1148	const unsigned long stall_for = msecs_to_jiffies(m: 100);
1149	int rtn;
1150
1151	retry:
1152	scsi_eh_prep_cmnd(scmd, &ses, cmnd, cmnd_size, sense_bytes);
1153	shost->eh_action = &done;
1154
1155	scsi_log_send(cmd: scmd);
1156	scmd->submitter = SUBMITTED_BY_SCSI_ERROR_HANDLER;
1157	scmd->flags |= SCMD_LAST;
1158
1159	/*
1160	* Lock sdev->state_mutex to avoid that scsi_device_quiesce() can
1161	* change the SCSI device state after we have examined it and before
1162	* .queuecommand() is called.
1163	*/
1164	mutex_lock(&sdev->state_mutex);
1165	while (sdev->sdev_state == SDEV_BLOCK && timeleft > 0) {
1166	mutex_unlock(lock: &sdev->state_mutex);
1167	SCSI_LOG_ERROR_RECOVERY(5, sdev_printk(KERN_DEBUG, sdev,
1168	"%s: state %d <> %d\n", __func__, sdev->sdev_state,
1169	SDEV_BLOCK));
1170	delay = min(timeleft, stall_for);
1171	timeleft -= delay;
1172	msleep(msecs: jiffies_to_msecs(j: delay));
1173	mutex_lock(&sdev->state_mutex);
1174	}
1175	if (sdev->sdev_state != SDEV_BLOCK)
1176	rtn = shost->hostt->queuecommand(shost, scmd);
1177	else
1178	rtn = FAILED;
1179	mutex_unlock(lock: &sdev->state_mutex);
1180
1181	if (rtn) {
1182	if (timeleft > stall_for) {
1183	scsi_eh_restore_cmnd(scmd, &ses);
1184
1185	timeleft -= stall_for;
1186	msleep(msecs: jiffies_to_msecs(j: stall_for));
1187	goto retry;
1188	}
1189	/* signal not to enter either branch of the if () below */
1190	timeleft = 0;
1191	rtn = FAILED;
1192	} else {
1193	timeleft = wait_for_completion_timeout(x: &done, timeout);
1194	rtn = SUCCESS;
1195	}
1196
1197	shost->eh_action = NULL;
1198
1199	scsi_log_completion(cmd: scmd, disposition: rtn);
1200
1201	SCSI_LOG_ERROR_RECOVERY(3, scmd_printk(KERN_INFO, scmd,
1202	"%s timeleft: %ld\n",
1203	__func__, timeleft));
1204
1205	/*
1206	* If there is time left scsi_eh_done got called, and we will examine
1207	* the actual status codes to see whether the command actually did
1208	* complete normally, else if we have a zero return and no time left,
1209	* the command must still be pending, so abort it and return FAILED.
1210	* If we never actually managed to issue the command, because
1211	* ->queuecommand() kept returning non zero, use the rtn = FAILED
1212	* value above (so don't execute either branch of the if)
1213	*/
1214	if (timeleft) {
1215	rtn = scsi_eh_completed_normally(scmd);
1216	SCSI_LOG_ERROR_RECOVERY(3, scmd_printk(KERN_INFO, scmd,
1217	"%s: scsi_eh_completed_normally %x\n", __func__, rtn));
1218
1219	switch (rtn) {
1220	case SUCCESS:
1221	case NEEDS_RETRY:
1222	case FAILED:
1223	break;
1224	case ADD_TO_MLQUEUE:
1225	rtn = NEEDS_RETRY;
1226	break;
1227	default:
1228	rtn = FAILED;
1229	break;
1230	}
1231	} else if (rtn != FAILED) {
1232	scsi_abort_eh_cmnd(scmd);
1233	rtn = FAILED;
1234	}
1235
1236	scsi_eh_restore_cmnd(scmd, &ses);
1237
1238	return rtn;
1239	}
1240
1241	/**
1242	* scsi_request_sense - Request sense data from a particular target.
1243	* @scmd: SCSI cmd for request sense.
1244	*
1245	* Notes:
1246	* Some hosts automatically obtain this information, others require
1247	* that we obtain it on our own. This function will *not* return until
1248	* the command either times out, or it completes.
1249	*/
1250	static enum scsi_disposition scsi_request_sense(struct scsi_cmnd *scmd)
1251	{
1252	return scsi_send_eh_cmnd(scmd, NULL, cmnd_size: 0, timeout: scmd->device->eh_timeout, sense_bytes: ~0);
1253	}
1254
1255	static enum scsi_disposition
1256	scsi_eh_action(struct scsi_cmnd *scmd, enum scsi_disposition rtn)
1257	{
1258	if (!blk_rq_is_passthrough(rq: scsi_cmd_to_rq(scmd))) {
1259	struct scsi_driver *sdrv = scsi_cmd_to_driver(cmd: scmd);
1260	if (sdrv->eh_action)
1261	rtn = sdrv->eh_action(scmd, rtn);
1262	}
1263	return rtn;
1264	}
1265
1266	/**
1267	* scsi_eh_finish_cmd - Handle a cmd that eh is finished with.
1268	* @scmd: Original SCSI cmd that eh has finished.
1269	* @done_q: Queue for processed commands.
1270	*
1271	* Notes:
1272	* We don't want to use the normal command completion while we are are
1273	* still handling errors - it may cause other commands to be queued,
1274	* and that would disturb what we are doing. Thus we really want to
1275	* keep a list of pending commands for final completion, and once we
1276	* are ready to leave error handling we handle completion for real.
1277	*/
1278	void scsi_eh_finish_cmd(struct scsi_cmnd *scmd, struct list_head *done_q)
1279	{
1280	list_move_tail(list: &scmd->eh_entry, head: done_q);
1281	}
1282	EXPORT_SYMBOL(scsi_eh_finish_cmd);
1283
1284	/**
1285	* scsi_eh_get_sense - Get device sense data.
1286	* @work_q: Queue of commands to process.
1287	* @done_q: Queue of processed commands.
1288	*
1289	* Description:
1290	* See if we need to request sense information. if so, then get it
1291	* now, so we have a better idea of what to do.
1292	*
1293	* Notes:
1294	* This has the unfortunate side effect that if a shost adapter does
1295	* not automatically request sense information, we end up shutting
1296	* it down before we request it.
1297	*
1298	* All drivers should request sense information internally these days,
1299	* so for now all I have to say is tough noogies if you end up in here.
1300	*
1301	* XXX: Long term this code should go away, but that needs an audit of
1302	* all LLDDs first.
1303	*/
1304	int scsi_eh_get_sense(struct list_head *work_q,
1305	struct list_head *done_q)
1306	{
1307	struct scsi_cmnd *scmd, *next;
1308	struct Scsi_Host *shost;
1309	enum scsi_disposition rtn;
1310
1311	/*
1312	* If SCSI_EH_ABORT_SCHEDULED has been set, it is timeout IO,
1313	* should not get sense.
1314	*/
1315	list_for_each_entry_safe(scmd, next, work_q, eh_entry) {
1316	if ((scmd->eh_eflags & SCSI_EH_ABORT_SCHEDULED) ||
1317	SCSI_SENSE_VALID(scmd))
1318	continue;
1319
1320	shost = scmd->device->host;
1321	if (scsi_host_eh_past_deadline(shost)) {
1322	SCSI_LOG_ERROR_RECOVERY(3,
1323	scmd_printk(KERN_INFO, scmd,
1324	"%s: skip request sense, past eh deadline\n",
1325	current->comm));
1326	break;
1327	}
1328	if (!scsi_status_is_check_condition(status: scmd->result))
1329	/*
1330	* don't request sense if there's no check condition
1331	* status because the error we're processing isn't one
1332	* that has a sense code (and some devices get
1333	* confused by sense requests out of the blue)
1334	*/
1335	continue;
1336
1337	SCSI_LOG_ERROR_RECOVERY(2, scmd_printk(KERN_INFO, scmd,
1338	"%s: requesting sense\n",
1339	current->comm));
1340	rtn = scsi_request_sense(scmd);
1341	if (rtn != SUCCESS)
1342	continue;
1343
1344	SCSI_LOG_ERROR_RECOVERY(3, scmd_printk(KERN_INFO, scmd,
1345	"sense requested, result %x\n", scmd->result));
1346	SCSI_LOG_ERROR_RECOVERY(3, scsi_print_sense(scmd));
1347
1348	rtn = scsi_decide_disposition(cmd: scmd);
1349
1350	/*
1351	* if the result was normal, then just pass it along to the
1352	* upper level.
1353	*/
1354	if (rtn == SUCCESS)
1355	/*
1356	* We don't want this command reissued, just finished
1357	* with the sense data, so set retries to the max
1358	* allowed to ensure it won't get reissued. If the user
1359	* has requested infinite retries, we also want to
1360	* finish this command, so force completion by setting
1361	* retries and allowed to the same value.
1362	*/
1363	if (scmd->allowed == SCSI_CMD_RETRIES_NO_LIMIT)
1364	scmd->retries = scmd->allowed = 1;
1365	else
1366	scmd->retries = scmd->allowed;
1367	else if (rtn != NEEDS_RETRY)
1368	continue;
1369
1370	scsi_eh_finish_cmd(scmd, done_q);
1371	}
1372
1373	return list_empty(head: work_q);
1374	}
1375	EXPORT_SYMBOL_GPL(scsi_eh_get_sense);
1376
1377	/**
1378	* scsi_eh_tur - Send TUR to device.
1379	* @scmd: &scsi_cmnd to send TUR
1380	*
1381	* Return value:
1382	* 0 - Device is ready. 1 - Device NOT ready.
1383	*/
1384	static int scsi_eh_tur(struct scsi_cmnd *scmd)
1385	{
1386	static unsigned char tur_command[6] = {TEST_UNIT_READY, 0, 0, 0, 0, 0};
1387	int retry_cnt = 1;
1388	enum scsi_disposition rtn;
1389
1390	retry_tur:
1391	rtn = scsi_send_eh_cmnd(scmd, cmnd: tur_command, cmnd_size: 6,
1392	timeout: scmd->device->eh_timeout, sense_bytes: 0);
1393
1394	SCSI_LOG_ERROR_RECOVERY(3, scmd_printk(KERN_INFO, scmd,
1395	"%s return: %x\n", __func__, rtn));
1396
1397	switch (rtn) {
1398	case NEEDS_RETRY:
1399	if (retry_cnt--)
1400	goto retry_tur;
1401	fallthrough;
1402	case SUCCESS:
1403	return 0;
1404	default:
1405	return 1;
1406	}
1407	}
1408
1409	/**
1410	* scsi_eh_test_devices - check if devices are responding from error recovery.
1411	* @cmd_list: scsi commands in error recovery.
1412	* @work_q: queue for commands which still need more error recovery
1413	* @done_q: queue for commands which are finished
1414	* @try_stu: boolean on if a STU command should be tried in addition to TUR.
1415	*
1416	* Decription:
1417	* Tests if devices are in a working state. Commands to devices now in
1418	* a working state are sent to the done_q while commands to devices which
1419	* are still failing to respond are returned to the work_q for more
1420	* processing.
1421	**/
1422	static int scsi_eh_test_devices(struct list_head *cmd_list,
1423	struct list_head *work_q,
1424	struct list_head *done_q, int try_stu)
1425	{
1426	struct scsi_cmnd *scmd, *next;
1427	struct scsi_device *sdev;
1428	int finish_cmds;
1429
1430	while (!list_empty(head: cmd_list)) {
1431	scmd = list_entry(cmd_list->next, struct scsi_cmnd, eh_entry);
1432	sdev = scmd->device;
1433
1434	if (!try_stu) {
1435	if (scsi_host_eh_past_deadline(shost: sdev->host)) {
1436	/* Push items back onto work_q */
1437	list_splice_init(list: cmd_list, head: work_q);
1438	SCSI_LOG_ERROR_RECOVERY(3,
1439	sdev_printk(KERN_INFO, sdev,
1440	"%s: skip test device, past eh deadline",
1441	current->comm));
1442	break;
1443	}
1444	}
1445
1446	finish_cmds = !scsi_device_online(sdev: scmd->device) ||
1447	(try_stu && !scsi_eh_try_stu(scmd) &&
1448	!scsi_eh_tur(scmd)) ||
1449	!scsi_eh_tur(scmd);
1450
1451	list_for_each_entry_safe(scmd, next, cmd_list, eh_entry)
1452	if (scmd->device == sdev) {
1453	if (finish_cmds &&
1454	(try_stu ||
1455	scsi_eh_action(scmd, rtn: SUCCESS) == SUCCESS))
1456	scsi_eh_finish_cmd(scmd, done_q);
1457	else
1458	list_move_tail(list: &scmd->eh_entry, head: work_q);
1459	}
1460	}
1461	return list_empty(head: work_q);
1462	}
1463
1464	/**
1465	* scsi_eh_try_stu - Send START_UNIT to device.
1466	* @scmd: &scsi_cmnd to send START_UNIT
1467	*
1468	* Return value:
1469	* 0 - Device is ready. 1 - Device NOT ready.
1470	*/
1471	static int scsi_eh_try_stu(struct scsi_cmnd *scmd)
1472	{
1473	static unsigned char stu_command[6] = {START_STOP, 0, 0, 0, 1, 0};
1474
1475	if (scmd->device->allow_restart) {
1476	int i;
1477	enum scsi_disposition rtn = NEEDS_RETRY;
1478
1479	for (i = 0; rtn == NEEDS_RETRY && i < 2; i++)
1480	rtn = scsi_send_eh_cmnd(scmd, cmnd: stu_command, cmnd_size: 6,
1481	timeout: scmd->device->eh_timeout, sense_bytes: 0);
1482
1483	if (rtn == SUCCESS)
1484	return 0;
1485	}
1486
1487	return 1;
1488	}
1489
1490	/**
1491	* scsi_eh_stu - send START_UNIT if needed
1492	* @shost: &scsi host being recovered.
1493	* @work_q: &list_head for pending commands.
1494	* @done_q: &list_head for processed commands.
1495	*
1496	* Notes:
1497	* If commands are failing due to not ready, initializing command required,
1498	* try revalidating the device, which will end up sending a start unit.
1499	*/
1500	static int scsi_eh_stu(struct Scsi_Host *shost,
1501	struct list_head *work_q,
1502	struct list_head *done_q)
1503	{
1504	struct scsi_cmnd *scmd, *stu_scmd, *next;
1505	struct scsi_device *sdev;
1506
1507	shost_for_each_device(sdev, shost) {
1508	if (scsi_host_eh_past_deadline(shost)) {
1509	SCSI_LOG_ERROR_RECOVERY(3,
1510	sdev_printk(KERN_INFO, sdev,
1511	"%s: skip START_UNIT, past eh deadline\n",
1512	current->comm));
1513	scsi_device_put(sdev);
1514	break;
1515	}
1516	stu_scmd = NULL;
1517	list_for_each_entry(scmd, work_q, eh_entry)
1518	if (scmd->device == sdev && SCSI_SENSE_VALID(scmd) &&
1519	scsi_check_sense(scmd) == FAILED ) {
1520	stu_scmd = scmd;
1521	break;
1522	}
1523
1524	if (!stu_scmd)
1525	continue;
1526
1527	SCSI_LOG_ERROR_RECOVERY(3,
1528	sdev_printk(KERN_INFO, sdev,
1529	"%s: Sending START_UNIT\n",
1530	current->comm));
1531
1532	if (!scsi_eh_try_stu(scmd: stu_scmd)) {
1533	if (!scsi_device_online(sdev) ||
1534	!scsi_eh_tur(scmd: stu_scmd)) {
1535	list_for_each_entry_safe(scmd, next,
1536	work_q, eh_entry) {
1537	if (scmd->device == sdev &&
1538	scsi_eh_action(scmd, rtn: SUCCESS) == SUCCESS)
1539	scsi_eh_finish_cmd(scmd, done_q);
1540	}
1541	}
1542	} else {
1543	SCSI_LOG_ERROR_RECOVERY(3,
1544	sdev_printk(KERN_INFO, sdev,
1545	"%s: START_UNIT failed\n",
1546	current->comm));
1547	}
1548	}
1549
1550	return list_empty(head: work_q);
1551	}
1552
1553
1554	/**
1555	* scsi_eh_bus_device_reset - send bdr if needed
1556	* @shost: scsi host being recovered.
1557	* @work_q: &list_head for pending commands.
1558	* @done_q: &list_head for processed commands.
1559	*
1560	* Notes:
1561	* Try a bus device reset. Still, look to see whether we have multiple
1562	* devices that are jammed or not - if we have multiple devices, it
1563	* makes no sense to try bus_device_reset - we really would need to try
1564	* a bus_reset instead.
1565	*/
1566	static int scsi_eh_bus_device_reset(struct Scsi_Host *shost,
1567	struct list_head *work_q,
1568	struct list_head *done_q)
1569	{
1570	struct scsi_cmnd *scmd, *bdr_scmd, *next;
1571	struct scsi_device *sdev;
1572	enum scsi_disposition rtn;
1573
1574	shost_for_each_device(sdev, shost) {
1575	if (scsi_host_eh_past_deadline(shost)) {
1576	SCSI_LOG_ERROR_RECOVERY(3,
1577	sdev_printk(KERN_INFO, sdev,
1578	"%s: skip BDR, past eh deadline\n",
1579	current->comm));
1580	scsi_device_put(sdev);
1581	break;
1582	}
1583	bdr_scmd = NULL;
1584	list_for_each_entry(scmd, work_q, eh_entry)
1585	if (scmd->device == sdev) {
1586	bdr_scmd = scmd;
1587	break;
1588	}
1589
1590	if (!bdr_scmd)
1591	continue;
1592
1593	SCSI_LOG_ERROR_RECOVERY(3,
1594	sdev_printk(KERN_INFO, sdev,
1595	"%s: Sending BDR\n", current->comm));
1596	rtn = scsi_try_bus_device_reset(scmd: bdr_scmd);
1597	if (rtn == SUCCESS || rtn == FAST_IO_FAIL) {
1598	if (!scsi_device_online(sdev) ||
1599	rtn == FAST_IO_FAIL ||
1600	!scsi_eh_tur(scmd: bdr_scmd)) {
1601	list_for_each_entry_safe(scmd, next,
1602	work_q, eh_entry) {
1603	if (scmd->device == sdev &&
1604	scsi_eh_action(scmd, rtn) != FAILED)
1605	scsi_eh_finish_cmd(scmd,
1606	done_q);
1607	}
1608	}
1609	} else {
1610	SCSI_LOG_ERROR_RECOVERY(3,
1611	sdev_printk(KERN_INFO, sdev,
1612	"%s: BDR failed\n", current->comm));
1613	}
1614	}
1615
1616	return list_empty(head: work_q);
1617	}
1618
1619	/**
1620	* scsi_eh_target_reset - send target reset if needed
1621	* @shost: scsi host being recovered.
1622	* @work_q: &list_head for pending commands.
1623	* @done_q: &list_head for processed commands.
1624	*
1625	* Notes:
1626	* Try a target reset.
1627	*/
1628	static int scsi_eh_target_reset(struct Scsi_Host *shost,
1629	struct list_head *work_q,
1630	struct list_head *done_q)
1631	{
1632	LIST_HEAD(tmp_list);
1633	LIST_HEAD(check_list);
1634
1635	list_splice_init(list: work_q, head: &tmp_list);
1636
1637	while (!list_empty(head: &tmp_list)) {
1638	struct scsi_cmnd *next, *scmd;
1639	enum scsi_disposition rtn;
1640	unsigned int id;
1641
1642	if (scsi_host_eh_past_deadline(shost)) {
1643	/* push back on work queue for further processing */
1644	list_splice_init(list: &check_list, head: work_q);
1645	list_splice_init(list: &tmp_list, head: work_q);
1646	SCSI_LOG_ERROR_RECOVERY(3,
1647	shost_printk(KERN_INFO, shost,
1648	"%s: Skip target reset, past eh deadline\n",
1649	current->comm));
1650	return list_empty(head: work_q);
1651	}
1652
1653	scmd = list_entry(tmp_list.next, struct scsi_cmnd, eh_entry);
1654	id = scmd_id(scmd);
1655
1656	SCSI_LOG_ERROR_RECOVERY(3,
1657	shost_printk(KERN_INFO, shost,
1658	"%s: Sending target reset to target %d\n",
1659	current->comm, id));
1660	rtn = scsi_try_target_reset(scmd);
1661	if (rtn != SUCCESS && rtn != FAST_IO_FAIL)
1662	SCSI_LOG_ERROR_RECOVERY(3,
1663	shost_printk(KERN_INFO, shost,
1664	"%s: Target reset failed"
1665	" target: %d\n",
1666	current->comm, id));
1667	list_for_each_entry_safe(scmd, next, &tmp_list, eh_entry) {
1668	if (scmd_id(scmd) != id)
1669	continue;
1670
1671	if (rtn == SUCCESS)
1672	list_move_tail(list: &scmd->eh_entry, head: &check_list);
1673	else if (rtn == FAST_IO_FAIL)
1674	scsi_eh_finish_cmd(scmd, done_q);
1675	else
1676	/* push back on work queue for further processing */
1677	list_move(list: &scmd->eh_entry, head: work_q);
1678	}
1679	}
1680
1681	return scsi_eh_test_devices(cmd_list: &check_list, work_q, done_q, try_stu: 0);
1682	}
1683
1684	/**
1685	* scsi_eh_bus_reset - send a bus reset
1686	* @shost: &scsi host being recovered.
1687	* @work_q: &list_head for pending commands.
1688	* @done_q: &list_head for processed commands.
1689	*/
1690	static int scsi_eh_bus_reset(struct Scsi_Host *shost,
1691	struct list_head *work_q,
1692	struct list_head *done_q)
1693	{
1694	struct scsi_cmnd *scmd, *chan_scmd, *next;
1695	LIST_HEAD(check_list);
1696	unsigned int channel;
1697	enum scsi_disposition rtn;
1698
1699	/*
1700	* we really want to loop over the various channels, and do this on
1701	* a channel by channel basis. we should also check to see if any
1702	* of the failed commands are on soft_reset devices, and if so, skip
1703	* the reset.
1704	*/
1705
1706	for (channel = 0; channel <= shost->max_channel; channel++) {
1707	if (scsi_host_eh_past_deadline(shost)) {
1708	list_splice_init(list: &check_list, head: work_q);
1709	SCSI_LOG_ERROR_RECOVERY(3,
1710	shost_printk(KERN_INFO, shost,
1711	"%s: skip BRST, past eh deadline\n",
1712	current->comm));
1713	return list_empty(head: work_q);
1714	}
1715
1716	chan_scmd = NULL;
1717	list_for_each_entry(scmd, work_q, eh_entry) {
1718	if (channel == scmd_channel(scmd)) {
1719	chan_scmd = scmd;
1720	break;
1721	/*
1722	* FIXME add back in some support for
1723	* soft_reset devices.
1724	*/
1725	}
1726	}
1727
1728	if (!chan_scmd)
1729	continue;
1730	SCSI_LOG_ERROR_RECOVERY(3,
1731	shost_printk(KERN_INFO, shost,
1732	"%s: Sending BRST chan: %d\n",
1733	current->comm, channel));
1734	rtn = scsi_try_bus_reset(scmd: chan_scmd);
1735	if (rtn == SUCCESS || rtn == FAST_IO_FAIL) {
1736	list_for_each_entry_safe(scmd, next, work_q, eh_entry) {
1737	if (channel == scmd_channel(scmd)) {
1738	if (rtn == FAST_IO_FAIL)
1739	scsi_eh_finish_cmd(scmd,
1740	done_q);
1741	else
1742	list_move_tail(list: &scmd->eh_entry,
1743	head: &check_list);
1744	}
1745	}
1746	} else {
1747	SCSI_LOG_ERROR_RECOVERY(3,
1748	shost_printk(KERN_INFO, shost,
1749	"%s: BRST failed chan: %d\n",
1750	current->comm, channel));
1751	}
1752	}
1753	return scsi_eh_test_devices(cmd_list: &check_list, work_q, done_q, try_stu: 0);
1754	}
1755
1756	/**
1757	* scsi_eh_host_reset - send a host reset
1758	* @shost: host to be reset.
1759	* @work_q: &list_head for pending commands.
1760	* @done_q: &list_head for processed commands.
1761	*/
1762	static int scsi_eh_host_reset(struct Scsi_Host *shost,
1763	struct list_head *work_q,
1764	struct list_head *done_q)
1765	{
1766	struct scsi_cmnd *scmd, *next;
1767	LIST_HEAD(check_list);
1768	enum scsi_disposition rtn;
1769
1770	if (!list_empty(head: work_q)) {
1771	scmd = list_entry(work_q->next,
1772	struct scsi_cmnd, eh_entry);
1773
1774	SCSI_LOG_ERROR_RECOVERY(3,
1775	shost_printk(KERN_INFO, shost,
1776	"%s: Sending HRST\n",
1777	current->comm));
1778
1779	rtn = scsi_try_host_reset(scmd);
1780	if (rtn == SUCCESS) {
1781	list_splice_init(list: work_q, head: &check_list);
1782	} else if (rtn == FAST_IO_FAIL) {
1783	list_for_each_entry_safe(scmd, next, work_q, eh_entry) {
1784	scsi_eh_finish_cmd(scmd, done_q);
1785	}
1786	} else {
1787	SCSI_LOG_ERROR_RECOVERY(3,
1788	shost_printk(KERN_INFO, shost,
1789	"%s: HRST failed\n",
1790	current->comm));
1791	}
1792	}
1793	return scsi_eh_test_devices(cmd_list: &check_list, work_q, done_q, try_stu: 1);
1794	}
1795
1796	/**
1797	* scsi_eh_offline_sdevs - offline scsi devices that fail to recover
1798	* @work_q: &list_head for pending commands.
1799	* @done_q: &list_head for processed commands.
1800	*/
1801	static void scsi_eh_offline_sdevs(struct list_head *work_q,
1802	struct list_head *done_q)
1803	{
1804	struct scsi_cmnd *scmd, *next;
1805	struct scsi_device *sdev;
1806
1807	list_for_each_entry_safe(scmd, next, work_q, eh_entry) {
1808	sdev_printk(KERN_INFO, scmd->device, "Device offlined - "
1809	"not ready after error recovery\n");
1810	sdev = scmd->device;
1811
1812	mutex_lock(&sdev->state_mutex);
1813	scsi_device_set_state(sdev, state: SDEV_OFFLINE);
1814	mutex_unlock(lock: &sdev->state_mutex);
1815
1816	scsi_eh_finish_cmd(scmd, done_q);
1817	}
1818	return;
1819	}
1820
1821	/**
1822	* scsi_noretry_cmd - determine if command should be failed fast
1823	* @scmd: SCSI cmd to examine.
1824	*/
1825	bool scsi_noretry_cmd(struct scsi_cmnd *scmd)
1826	{
1827	struct request *req = scsi_cmd_to_rq(scmd);
1828
1829	switch (host_byte(scmd->result)) {
1830	case DID_OK:
1831	break;
1832	case DID_TIME_OUT:
1833	goto check_type;
1834	case DID_BUS_BUSY:
1835	return !!(req->cmd_flags & REQ_FAILFAST_TRANSPORT);
1836	case DID_PARITY:
1837	return !!(req->cmd_flags & REQ_FAILFAST_DEV);
1838	case DID_ERROR:
1839	if (get_status_byte(cmd: scmd) == SAM_STAT_RESERVATION_CONFLICT)
1840	return false;
1841	fallthrough;
1842	case DID_SOFT_ERROR:
1843	return !!(req->cmd_flags & REQ_FAILFAST_DRIVER);
1844	}
1845
1846	/* Never retry commands aborted due to a duration limit timeout */
1847	if (scsi_ml_byte(result: scmd->result) == SCSIML_STAT_DL_TIMEOUT)
1848	return true;
1849
1850	if (!scsi_status_is_check_condition(status: scmd->result))
1851	return false;
1852
1853	check_type:
1854	/*
1855	* assume caller has checked sense and determined
1856	* the check condition was retryable.
1857	*/
1858	if (req->cmd_flags & REQ_FAILFAST_DEV || blk_rq_is_passthrough(rq: req))
1859	return true;
1860
1861	return false;
1862	}
1863
1864	/**
1865	* scsi_decide_disposition - Disposition a cmd on return from LLD.
1866	* @scmd: SCSI cmd to examine.
1867	*
1868	* Notes:
1869	* This is *only* called when we are examining the status after sending
1870	* out the actual data command. any commands that are queued for error
1871	* recovery (e.g. test_unit_ready) do *not* come through here.
1872	*
1873	* When this routine returns failed, it means the error handler thread
1874	* is woken. In cases where the error code indicates an error that
1875	* doesn't require the error handler read (i.e. we don't need to
1876	* abort/reset), this function should return SUCCESS.
1877	*/
1878	enum scsi_disposition scsi_decide_disposition(struct scsi_cmnd *scmd)
1879	{
1880	enum scsi_disposition rtn;
1881
1882	/*
1883	* if the device is offline, then we clearly just pass the result back
1884	* up to the top level.
1885	*/
1886	if (!scsi_device_online(sdev: scmd->device)) {
1887	SCSI_LOG_ERROR_RECOVERY(5, scmd_printk(KERN_INFO, scmd,
1888	"%s: device offline - report as SUCCESS\n", __func__));
1889	return SUCCESS;
1890	}
1891
1892	/*
1893	* first check the host byte, to see if there is anything in there
1894	* that would indicate what we need to do.
1895	*/
1896	switch (host_byte(scmd->result)) {
1897	case DID_PASSTHROUGH:
1898	/*
1899	* no matter what, pass this through to the upper layer.
1900	* nuke this special code so that it looks like we are saying
1901	* did_ok.
1902	*/
1903	scmd->result &= 0xff00ffff;
1904	return SUCCESS;
1905	case DID_OK:
1906	/*
1907	* looks good. drop through, and check the next byte.
1908	*/
1909	break;
1910	case DID_ABORT:
1911	if (scmd->eh_eflags & SCSI_EH_ABORT_SCHEDULED) {
1912	set_host_byte(cmd: scmd, status: DID_TIME_OUT);
1913	return SUCCESS;
1914	}
1915	fallthrough;
1916	case DID_NO_CONNECT:
1917	case DID_BAD_TARGET:
1918	/*
1919	* note - this means that we just report the status back
1920	* to the top level driver, not that we actually think
1921	* that it indicates SUCCESS.
1922	*/
1923	return SUCCESS;
1924	case DID_SOFT_ERROR:
1925	/*
1926	* when the low level driver returns did_soft_error,
1927	* it is responsible for keeping an internal retry counter
1928	* in order to avoid endless loops (db)
1929	*/
1930	goto maybe_retry;
1931	case DID_IMM_RETRY:
1932	return NEEDS_RETRY;
1933
1934	case DID_REQUEUE:
1935	return ADD_TO_MLQUEUE;
1936	case DID_TRANSPORT_DISRUPTED:
1937	/*
1938	* LLD/transport was disrupted during processing of the IO.
1939	* The transport class is now blocked/blocking,
1940	* and the transport will decide what to do with the IO
1941	* based on its timers and recovery capablilities if
1942	* there are enough retries.
1943	*/
1944	goto maybe_retry;
1945	case DID_TRANSPORT_FAILFAST:
1946	/*
1947	* The transport decided to failfast the IO (most likely
1948	* the fast io fail tmo fired), so send IO directly upwards.
1949	*/
1950	return SUCCESS;
1951	case DID_TRANSPORT_MARGINAL:
1952	/*
1953	* caller has decided not to do retries on
1954	* abort success, so send IO directly upwards
1955	*/
1956	return SUCCESS;
1957	case DID_ERROR:
1958	if (get_status_byte(cmd: scmd) == SAM_STAT_RESERVATION_CONFLICT)
1959	/*
1960	* execute reservation conflict processing code
1961	* lower down
1962	*/
1963	break;
1964	fallthrough;
1965	case DID_BUS_BUSY:
1966	case DID_PARITY:
1967	goto maybe_retry;
1968	case DID_TIME_OUT:
1969	/*
1970	* when we scan the bus, we get timeout messages for
1971	* these commands if there is no device available.
1972	* other hosts report did_no_connect for the same thing.
1973	*/
1974	if ((scmd->cmnd[0] == TEST_UNIT_READY ||
1975	scmd->cmnd[0] == INQUIRY)) {
1976	return SUCCESS;
1977	} else {
1978	return FAILED;
1979	}
1980	case DID_RESET:
1981	return SUCCESS;
1982	default:
1983	return FAILED;
1984	}
1985
1986	/*
1987	* check the status byte to see if this indicates anything special.
1988	*/
1989	switch (get_status_byte(cmd: scmd)) {
1990	case SAM_STAT_TASK_SET_FULL:
1991	scsi_handle_queue_full(sdev: scmd->device);
1992	/*
1993	* the case of trying to send too many commands to a
1994	* tagged queueing device.
1995	*/
1996	fallthrough;
1997	case SAM_STAT_BUSY:
1998	/*
1999	* device can't talk to us at the moment. Should only
2000	* occur (SAM-3) when the task queue is empty, so will cause
2001	* the empty queue handling to trigger a stall in the
2002	* device.
2003	*/
2004	return ADD_TO_MLQUEUE;
2005	case SAM_STAT_GOOD:
2006	if (scmd->cmnd[0] == REPORT_LUNS)
2007	scmd->device->sdev_target->expecting_lun_change = 0;
2008	scsi_handle_queue_ramp_up(sdev: scmd->device);
2009	if (scmd->sense_buffer && SCSI_SENSE_VALID(scmd))
2010	/*
2011	* If we have sense data, call scsi_check_sense() in
2012	* order to set the correct SCSI ML byte (if any).
2013	* No point in checking the return value, since the
2014	* command has already completed successfully.
2015	*/
2016	scsi_check_sense(scmd);
2017	fallthrough;
2018	case SAM_STAT_COMMAND_TERMINATED:
2019	return SUCCESS;
2020	case SAM_STAT_TASK_ABORTED:
2021	goto maybe_retry;
2022	case SAM_STAT_CHECK_CONDITION:
2023	rtn = scsi_check_sense(scmd);
2024	if (rtn == NEEDS_RETRY)
2025	goto maybe_retry;
2026	/* if rtn == FAILED, we have no sense information;
2027	* returning FAILED will wake the error handler thread
2028	* to collect the sense and redo the decide
2029	* disposition */
2030	return rtn;
2031	case SAM_STAT_CONDITION_MET:
2032	case SAM_STAT_INTERMEDIATE:
2033	case SAM_STAT_INTERMEDIATE_CONDITION_MET:
2034	case SAM_STAT_ACA_ACTIVE:
2035	/*
2036	* who knows? FIXME(eric)
2037	*/
2038	return SUCCESS;
2039
2040	case SAM_STAT_RESERVATION_CONFLICT:
2041	sdev_printk(KERN_INFO, scmd->device,
2042	"reservation conflict\n");
2043	set_scsi_ml_byte(cmd: scmd, status: SCSIML_STAT_RESV_CONFLICT);
2044	return SUCCESS; /* causes immediate i/o error */
2045	}
2046	return FAILED;
2047
2048	maybe_retry:
2049
2050	/* we requeue for retry because the error was retryable, and
2051	* the request was not marked fast fail. Note that above,
2052	* even if the request is marked fast fail, we still requeue
2053	* for queue congestion conditions (QUEUE_FULL or BUSY) */
2054	if (scsi_cmd_retry_allowed(cmd: scmd) && !scsi_noretry_cmd(scmd)) {
2055	return NEEDS_RETRY;
2056	} else {
2057	/*
2058	* no more retries - report this one back to upper level.
2059	*/
2060	return SUCCESS;
2061	}
2062	}
2063
2064	static enum rq_end_io_ret eh_lock_door_done(struct request *req,
2065	blk_status_t status)
2066	{
2067	blk_mq_free_request(rq: req);
2068	return RQ_END_IO_NONE;
2069	}
2070
2071	/**
2072	* scsi_eh_lock_door - Prevent medium removal for the specified device
2073	* @sdev: SCSI device to prevent medium removal
2074	*
2075	* Locking:
2076	* We must be called from process context.
2077	*
2078	* Notes:
2079	* We queue up an asynchronous "ALLOW MEDIUM REMOVAL" request on the
2080	* head of the devices request queue, and continue.
2081	*/
2082	static void scsi_eh_lock_door(struct scsi_device *sdev)
2083	{
2084	struct scsi_cmnd *scmd;
2085	struct request *req;
2086
2087	req = scsi_alloc_request(q: sdev->request_queue, opf: REQ_OP_DRV_IN, flags: 0);
2088	if (IS_ERR(ptr: req))
2089	return;
2090	scmd = blk_mq_rq_to_pdu(rq: req);
2091
2092	scmd->cmnd[0] = ALLOW_MEDIUM_REMOVAL;
2093	scmd->cmnd[1] = 0;
2094	scmd->cmnd[2] = 0;
2095	scmd->cmnd[3] = 0;
2096	scmd->cmnd[4] = SCSI_REMOVAL_PREVENT;
2097	scmd->cmnd[5] = 0;
2098	scmd->cmd_len = COMMAND_SIZE(scmd->cmnd[0]);
2099	scmd->allowed = 5;
2100
2101	req->rq_flags |= RQF_QUIET;
2102	req->timeout = 10 * HZ;
2103	req->end_io = eh_lock_door_done;
2104
2105	blk_execute_rq_nowait(rq: req, at_head: true);
2106	}
2107
2108	/**
2109	* scsi_restart_operations - restart io operations to the specified host.
2110	* @shost: Host we are restarting.
2111	*
2112	* Notes:
2113	* When we entered the error handler, we blocked all further i/o to
2114	* this device. we need to 'reverse' this process.
2115	*/
2116	static void scsi_restart_operations(struct Scsi_Host *shost)
2117	{
2118	struct scsi_device *sdev;
2119	unsigned long flags;
2120
2121	/*
2122	* If the door was locked, we need to insert a door lock request
2123	* onto the head of the SCSI request queue for the device. There
2124	* is no point trying to lock the door of an off-line device.
2125	*/
2126	shost_for_each_device(sdev, shost) {
2127	if (scsi_device_online(sdev) && sdev->was_reset && sdev->locked) {
2128	scsi_eh_lock_door(sdev);
2129	sdev->was_reset = 0;
2130	}
2131	}
2132
2133	/*
2134	* next free up anything directly waiting upon the host. this
2135	* will be requests for character device operations, and also for
2136	* ioctls to queued block devices.
2137	*/
2138	SCSI_LOG_ERROR_RECOVERY(3,
2139	shost_printk(KERN_INFO, shost, "waking up host to restart\n"));
2140
2141	spin_lock_irqsave(shost->host_lock, flags);
2142	if (scsi_host_set_state(shost, SHOST_RUNNING))
2143	if (scsi_host_set_state(shost, SHOST_CANCEL))
2144	BUG_ON(scsi_host_set_state(shost, SHOST_DEL));
2145	spin_unlock_irqrestore(lock: shost->host_lock, flags);
2146
2147	wake_up(&shost->host_wait);
2148
2149	/*
2150	* finally we need to re-initiate requests that may be pending. we will
2151	* have had everything blocked while error handling is taking place, and
2152	* now that error recovery is done, we will need to ensure that these
2153	* requests are started.
2154	*/
2155	scsi_run_host_queues(shost);
2156
2157	/*
2158	* if eh is active and host_eh_scheduled is pending we need to re-run
2159	* recovery. we do this check after scsi_run_host_queues() to allow
2160	* everything pent up since the last eh run a chance to make forward
2161	* progress before we sync again. Either we'll immediately re-run
2162	* recovery or scsi_device_unbusy() will wake us again when these
2163	* pending commands complete.
2164	*/
2165	spin_lock_irqsave(shost->host_lock, flags);
2166	if (shost->host_eh_scheduled)
2167	if (scsi_host_set_state(shost, SHOST_RECOVERY))
2168	WARN_ON(scsi_host_set_state(shost, SHOST_CANCEL_RECOVERY));
2169	spin_unlock_irqrestore(lock: shost->host_lock, flags);
2170	}
2171
2172	/**
2173	* scsi_eh_ready_devs - check device ready state and recover if not.
2174	* @shost: host to be recovered.
2175	* @work_q: &list_head for pending commands.
2176	* @done_q: &list_head for processed commands.
2177	*/
2178	void scsi_eh_ready_devs(struct Scsi_Host *shost,
2179	struct list_head *work_q,
2180	struct list_head *done_q)
2181	{
2182	if (!scsi_eh_stu(shost, work_q, done_q))
2183	if (!scsi_eh_bus_device_reset(shost, work_q, done_q))
2184	if (!scsi_eh_target_reset(shost, work_q, done_q))
2185	if (!scsi_eh_bus_reset(shost, work_q, done_q))
2186	if (!scsi_eh_host_reset(shost, work_q, done_q))
2187	scsi_eh_offline_sdevs(work_q,
2188	done_q);
2189	}
2190	EXPORT_SYMBOL_GPL(scsi_eh_ready_devs);
2191
2192	/**
2193	* scsi_eh_flush_done_q - finish processed commands or retry them.
2194	* @done_q: list_head of processed commands.
2195	*/
2196	void scsi_eh_flush_done_q(struct list_head *done_q)
2197	{
2198	struct scsi_cmnd *scmd, *next;
2199
2200	list_for_each_entry_safe(scmd, next, done_q, eh_entry) {
2201	struct scsi_device *sdev = scmd->device;
2202
2203	list_del_init(entry: &scmd->eh_entry);
2204	if (scsi_device_online(sdev) && !scsi_noretry_cmd(scmd) &&
2205	scsi_cmd_retry_allowed(cmd: scmd) &&
2206	scsi_eh_should_retry_cmd(cmd: scmd)) {
2207	SCSI_LOG_ERROR_RECOVERY(3,
2208	scmd_printk(KERN_INFO, scmd,
2209	"%s: flush retry cmd\n",
2210	current->comm));
2211	scsi_queue_insert(cmd: scmd, SCSI_MLQUEUE_EH_RETRY);
2212	blk_mq_kick_requeue_list(q: sdev->request_queue);
2213	} else {
2214	/*
2215	* If just we got sense for the device (called
2216	* scsi_eh_get_sense), scmd->result is already
2217	* set, do not set DID_TIME_OUT.
2218	*/
2219	if (!scmd->result &&
2220	!(scmd->flags & SCMD_FORCE_EH_SUCCESS))
2221	scmd->result |= (DID_TIME_OUT << 16);
2222	SCSI_LOG_ERROR_RECOVERY(3,
2223	scmd_printk(KERN_INFO, scmd,
2224	"%s: flush finish cmd\n",
2225	current->comm));
2226	scsi_finish_command(cmd: scmd);
2227	}
2228	}
2229	}
2230	EXPORT_SYMBOL(scsi_eh_flush_done_q);
2231
2232	/**
2233	* scsi_unjam_host - Attempt to fix a host which has a cmd that failed.
2234	* @shost: Host to unjam.
2235	*
2236	* Notes:
2237	* When we come in here, we *know* that all commands on the bus have
2238	* either completed, failed or timed out. we also know that no further
2239	* commands are being sent to the host, so things are relatively quiet
2240	* and we have freedom to fiddle with things as we wish.
2241	*
2242	* This is only the *default* implementation. it is possible for
2243	* individual drivers to supply their own version of this function, and
2244	* if the maintainer wishes to do this, it is strongly suggested that
2245	* this function be taken as a template and modified. this function
2246	* was designed to correctly handle problems for about 95% of the
2247	* different cases out there, and it should always provide at least a
2248	* reasonable amount of error recovery.
2249	*
2250	* Any command marked 'failed' or 'timeout' must eventually have
2251	* scsi_finish_cmd() called for it. we do all of the retry stuff
2252	* here, so when we restart the host after we return it should have an
2253	* empty queue.
2254	*/
2255	static void scsi_unjam_host(struct Scsi_Host *shost)
2256	{
2257	unsigned long flags;
2258	LIST_HEAD(eh_work_q);
2259	LIST_HEAD(eh_done_q);
2260
2261	spin_lock_irqsave(shost->host_lock, flags);
2262	list_splice_init(list: &shost->eh_cmd_q, head: &eh_work_q);
2263	spin_unlock_irqrestore(lock: shost->host_lock, flags);
2264
2265	SCSI_LOG_ERROR_RECOVERY(1, scsi_eh_prt_fail_stats(shost, &eh_work_q));
2266
2267	if (!scsi_eh_get_sense(&eh_work_q, &eh_done_q))
2268	scsi_eh_ready_devs(shost, &eh_work_q, &eh_done_q);
2269
2270	spin_lock_irqsave(shost->host_lock, flags);
2271	if (shost->eh_deadline != -1)
2272	shost->last_reset = 0;
2273	spin_unlock_irqrestore(lock: shost->host_lock, flags);
2274	scsi_eh_flush_done_q(&eh_done_q);
2275	}
2276
2277	/**
2278	* scsi_error_handler - SCSI error handler thread
2279	* @data: Host for which we are running.
2280	*
2281	* Notes:
2282	* This is the main error handling loop. This is run as a kernel thread
2283	* for every SCSI host and handles all error handling activity.
2284	*/
2285	int scsi_error_handler(void *data)
2286	{
2287	struct Scsi_Host *shost = data;
2288
2289	/*
2290	* We use TASK_INTERRUPTIBLE so that the thread is not
2291	* counted against the load average as a running process.
2292	* We never actually get interrupted because kthread_run
2293	* disables signal delivery for the created thread.
2294	*/
2295	while (true) {
2296	/*
2297	* The sequence in kthread_stop() sets the stop flag first
2298	* then wakes the process. To avoid missed wakeups, the task
2299	* should always be in a non running state before the stop
2300	* flag is checked
2301	*/
2302	set_current_state(TASK_INTERRUPTIBLE);
2303	if (kthread_should_stop())
2304	break;
2305
2306	if ((shost->host_failed == 0 && shost->host_eh_scheduled == 0) ||
2307	shost->host_failed != scsi_host_busy(shost)) {
2308	SCSI_LOG_ERROR_RECOVERY(1,
2309	shost_printk(KERN_INFO, shost,
2310	"scsi_eh_%d: sleeping\n",
2311	shost->host_no));
2312	schedule();
2313	continue;
2314	}
2315
2316	__set_current_state(TASK_RUNNING);
2317	SCSI_LOG_ERROR_RECOVERY(1,
2318	shost_printk(KERN_INFO, shost,
2319	"scsi_eh_%d: waking up %d/%d/%d\n",
2320	shost->host_no, shost->host_eh_scheduled,
2321	shost->host_failed,
2322	scsi_host_busy(shost)));
2323
2324	/*
2325	* We have a host that is failing for some reason. Figure out
2326	* what we need to do to get it up and online again (if we can).
2327	* If we fail, we end up taking the thing offline.
2328	*/
2329	if (!shost->eh_noresume && scsi_autopm_get_host(shost) != 0) {
2330	SCSI_LOG_ERROR_RECOVERY(1,
2331	shost_printk(KERN_ERR, shost,
2332	"scsi_eh_%d: unable to autoresume\n",
2333	shost->host_no));
2334	continue;
2335	}
2336
2337	if (shost->transportt->eh_strategy_handler)
2338	shost->transportt->eh_strategy_handler(shost);
2339	else
2340	scsi_unjam_host(shost);
2341
2342	/* All scmds have been handled */
2343	shost->host_failed = 0;
2344
2345	/*
2346	* Note - if the above fails completely, the action is to take
2347	* individual devices offline and flush the queue of any
2348	* outstanding requests that may have been pending. When we
2349	* restart, we restart any I/O to any other devices on the bus
2350	* which are still online.
2351	*/
2352	scsi_restart_operations(shost);
2353	if (!shost->eh_noresume)
2354	scsi_autopm_put_host(shost);
2355	}
2356	__set_current_state(TASK_RUNNING);
2357
2358	SCSI_LOG_ERROR_RECOVERY(1,
2359	shost_printk(KERN_INFO, shost,
2360	"Error handler scsi_eh_%d exiting\n",
2361	shost->host_no));
2362	shost->ehandler = NULL;
2363	return 0;
2364	}
2365
2366	/*
2367	* Function: scsi_report_bus_reset()
2368	*
2369	* Purpose: Utility function used by low-level drivers to report that
2370	* they have observed a bus reset on the bus being handled.
2371	*
2372	* Arguments: shost - Host in question
2373	* channel - channel on which reset was observed.
2374	*
2375	* Returns: Nothing
2376	*
2377	* Lock status: Host lock must be held.
2378	*
2379	* Notes: This only needs to be called if the reset is one which
2380	* originates from an unknown location. Resets originated
2381	* by the mid-level itself don't need to call this, but there
2382	* should be no harm.
2383	*
2384	* The main purpose of this is to make sure that a CHECK_CONDITION
2385	* is properly treated.
2386	*/
2387	void scsi_report_bus_reset(struct Scsi_Host *shost, int channel)
2388	{
2389	struct scsi_device *sdev;
2390
2391	__shost_for_each_device(sdev, shost) {
2392	if (channel == sdev_channel(sdev))
2393	__scsi_report_device_reset(sdev, NULL);
2394	}
2395	}
2396	EXPORT_SYMBOL(scsi_report_bus_reset);
2397
2398	/*
2399	* Function: scsi_report_device_reset()
2400	*
2401	* Purpose: Utility function used by low-level drivers to report that
2402	* they have observed a device reset on the device being handled.
2403	*
2404	* Arguments: shost - Host in question
2405	* channel - channel on which reset was observed
2406	* target - target on which reset was observed
2407	*
2408	* Returns: Nothing
2409	*
2410	* Lock status: Host lock must be held
2411	*
2412	* Notes: This only needs to be called if the reset is one which
2413	* originates from an unknown location. Resets originated
2414	* by the mid-level itself don't need to call this, but there
2415	* should be no harm.
2416	*
2417	* The main purpose of this is to make sure that a CHECK_CONDITION
2418	* is properly treated.
2419	*/
2420	void scsi_report_device_reset(struct Scsi_Host *shost, int channel, int target)
2421	{
2422	struct scsi_device *sdev;
2423
2424	__shost_for_each_device(sdev, shost) {
2425	if (channel == sdev_channel(sdev) &&
2426	target == sdev_id(sdev))
2427	__scsi_report_device_reset(sdev, NULL);
2428	}
2429	}
2430	EXPORT_SYMBOL(scsi_report_device_reset);
2431
2432	/**
2433	* scsi_ioctl_reset: explicitly reset a host/bus/target/device
2434	* @dev: scsi_device to operate on
2435	* @arg: reset type (see sg.h)
2436	*/
2437	int
2438	scsi_ioctl_reset(struct scsi_device *dev, int __user *arg)
2439	{
2440	struct scsi_cmnd *scmd;
2441	struct Scsi_Host *shost = dev->host;
2442	struct request *rq;
2443	unsigned long flags;
2444	int error = 0, val;
2445	enum scsi_disposition rtn;
2446
2447	if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
2448	return -EACCES;
2449
2450	error = get_user(val, arg);
2451	if (error)
2452	return error;
2453
2454	if (scsi_autopm_get_host(shost) < 0)
2455	return -EIO;
2456
2457	error = -EIO;
2458	rq = kzalloc(size: sizeof(struct request) + sizeof(struct scsi_cmnd) +
2459	shost->hostt->cmd_size, GFP_KERNEL);
2460	if (!rq)
2461	goto out_put_autopm_host;
2462	blk_rq_init(NULL, rq);
2463
2464	scmd = (struct scsi_cmnd *)(rq + 1);
2465	scsi_init_command(dev, cmd: scmd);
2466
2467	scmd->submitter = SUBMITTED_BY_SCSI_RESET_IOCTL;
2468	scmd->flags |= SCMD_LAST;
2469	memset(&scmd->sdb, 0, sizeof(scmd->sdb));
2470
2471	scmd->cmd_len = 0;
2472
2473	scmd->sc_data_direction = DMA_BIDIRECTIONAL;
2474
2475	spin_lock_irqsave(shost->host_lock, flags);
2476	shost->tmf_in_progress = 1;
2477	spin_unlock_irqrestore(lock: shost->host_lock, flags);
2478
2479	switch (val & ~SG_SCSI_RESET_NO_ESCALATE) {
2480	case SG_SCSI_RESET_NOTHING:
2481	rtn = SUCCESS;
2482	break;
2483	case SG_SCSI_RESET_DEVICE:
2484	rtn = scsi_try_bus_device_reset(scmd);
2485	if (rtn == SUCCESS || (val & SG_SCSI_RESET_NO_ESCALATE))
2486	break;
2487	fallthrough;
2488	case SG_SCSI_RESET_TARGET:
2489	rtn = scsi_try_target_reset(scmd);
2490	if (rtn == SUCCESS || (val & SG_SCSI_RESET_NO_ESCALATE))
2491	break;
2492	fallthrough;
2493	case SG_SCSI_RESET_BUS:
2494	rtn = scsi_try_bus_reset(scmd);
2495	if (rtn == SUCCESS || (val & SG_SCSI_RESET_NO_ESCALATE))
2496	break;
2497	fallthrough;
2498	case SG_SCSI_RESET_HOST:
2499	rtn = scsi_try_host_reset(scmd);
2500	if (rtn == SUCCESS)
2501	break;
2502	fallthrough;
2503	default:
2504	rtn = FAILED;
2505	break;
2506	}
2507
2508	error = (rtn == SUCCESS) ? 0 : -EIO;
2509
2510	spin_lock_irqsave(shost->host_lock, flags);
2511	shost->tmf_in_progress = 0;
2512	spin_unlock_irqrestore(lock: shost->host_lock, flags);
2513
2514	/*
2515	* be sure to wake up anyone who was sleeping or had their queue
2516	* suspended while we performed the TMF.
2517	*/
2518	SCSI_LOG_ERROR_RECOVERY(3,
2519	shost_printk(KERN_INFO, shost,
2520	"waking up host to restart after TMF\n"));
2521
2522	wake_up(&shost->host_wait);
2523	scsi_run_host_queues(shost);
2524
2525	kfree(objp: rq);
2526
2527	out_put_autopm_host:
2528	scsi_autopm_put_host(shost);
2529	return error;
2530	}
2531
2532	bool scsi_command_normalize_sense(const struct scsi_cmnd *cmd,
2533	struct scsi_sense_hdr *sshdr)
2534	{
2535	return scsi_normalize_sense(sense_buffer: cmd->sense_buffer,
2536	SCSI_SENSE_BUFFERSIZE, sshdr);
2537	}
2538	EXPORT_SYMBOL(scsi_command_normalize_sense);
2539
2540	/**
2541	* scsi_get_sense_info_fld - get information field from sense data (either fixed or descriptor format)
2542	* @sense_buffer: byte array of sense data
2543	* @sb_len: number of valid bytes in sense_buffer
2544	* @info_out: pointer to 64 integer where 8 or 4 byte information
2545	* field will be placed if found.
2546	*
2547	* Return value:
2548	* true if information field found, false if not found.
2549	*/
2550	bool scsi_get_sense_info_fld(const u8 *sense_buffer, int sb_len,
2551	u64 *info_out)
2552	{
2553	const u8 * ucp;
2554
2555	if (sb_len < 7)
2556	return false;
2557	switch (sense_buffer[0] & 0x7f) {
2558	case 0x70:
2559	case 0x71:
2560	if (sense_buffer[0] & 0x80) {
2561	*info_out = get_unaligned_be32(p: &sense_buffer[3]);
2562	return true;
2563	}
2564	return false;
2565	case 0x72:
2566	case 0x73:
2567	ucp = scsi_sense_desc_find(sense_buffer, sb_len,
2568	desc_type: 0 /* info desc */);
2569	if (ucp && (0xa == ucp[1])) {
2570	*info_out = get_unaligned_be64(p: &ucp[4]);
2571	return true;
2572	}
2573	return false;
2574	default:
2575	return false;
2576	}
2577	}
2578	EXPORT_SYMBOL(scsi_get_sense_info_fld);
2579