2579 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * scsi_error.c Copyright (C) 1997 Eric Youngdale4 *5 * SCSI error/timeout handling6 * Initial versions: Eric Youngdale. Based upon conversations with7 * 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 and14 * 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 <linux/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 60static int scsi_eh_try_stu(struct scsi_cmnd *scmd);61static enum scsi_disposition scsi_try_to_abort_cmd(const struct scsi_host_template *,62 struct scsi_cmnd *);63 64void 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(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 host78 * @shost: SCSI host to invoke error handling on.79 *80 * Schedule SCSI EH without scmd.81 */82void 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, scsi_host_busy(shost));92 }93 94 spin_unlock_irqrestore(shost->host_lock, flags);95}96EXPORT_SYMBOL_GPL(scsi_schedule_eh);97 98static 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 atomic105 * (on all supported architectures), so instead106 * of using a spinlock we can as well double check107 * if eh_deadline has been set to 'off' during the108 * 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 117static 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 125static 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 aborts138 * @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 calls142 * scsi_timeout(), a .scsi_done() call from the LLD for a command that has143 * timed out do not have any effect. Hence it is safe to call144 * scsi_finish_command() from this function.145 */146void147scmd_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(scmd, 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(&scmd->eh_entry);186 187 /*188 * If the abort succeeds, and there is no further189 * EH action, clear the ->last_reset time.190 */191 if (list_empty(&shost->eh_abort_list) &&192 list_empty(&shost->eh_cmd_q))193 if (shost->eh_deadline != -1)194 shost->last_reset = 0;195 196 spin_unlock_irqrestore(shost->host_lock, flags);197 198 if (!scsi_noretry_cmd(scmd) &&199 scsi_cmd_retry_allowed(scmd) &&200 scsi_eh_should_retry_cmd(scmd)) {201 SCSI_LOG_ERROR_RECOVERY(3,202 scmd_printk(KERN_WARNING, scmd,203 "retry aborted command\n"));204 scsi_queue_insert(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(scmd);210 }211 return;212 213out:214 spin_lock_irqsave(shost->host_lock, flags);215 list_del_init(&scmd->eh_entry);216 spin_unlock_irqrestore(shost->host_lock, flags);217 218 scsi_eh_scmd_add(scmd);219}220 221/**222 * scsi_abort_command - schedule a command abort223 * @scmd: scmd to abort.224 *225 * We only need to abort commands after a command timeout226 */227static int228scsi_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(&scmd->eh_entry, &shost->eh_abort_list);255 spin_unlock_irqrestore(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(shost->tmf_work_q, &scmd->abort_work, HZ / 100);261 return SUCCESS;262}263 264/**265 * scsi_eh_reset - call into ->eh_action to reset internal counters266 * @scmd: scmd to run eh on.267 *268 * The scsi driver might be carrying internal state about the269 * devices, so we need to call into the driver to reset the270 * internal state once the error handler is started.271 */272static void scsi_eh_reset(struct scsi_cmnd *scmd)273{274 if (!blk_rq_is_passthrough(scsi_cmd_to_rq(scmd))) {275 struct scsi_driver *sdrv = scsi_cmd_to_driver(scmd);276 if (sdrv->eh_reset)277 sdrv->eh_reset(scmd);278 }279}280 281static 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(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 */298void 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(&scmd->eh_entry, &shost->eh_cmd_q);317 spin_unlock_irqrestore(shost->host_lock, flags);318 /*319 * Ensure that all tasks observe the host state change before the320 * host_failed change.321 */322 call_rcu_hurry(&scmd->rcu, 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 race331 * only in that the normal completion handling might run, but if the332 * normal completion function determines that the timer has already333 * fired, then it mustn't do anything.334 */335enum blk_eh_timer_return scsi_timeout(struct request *req)336{337 struct scsi_cmnd *scmd = blk_mq_rq_to_pdu(req);338 struct Scsi_Host *host = scmd->device->host;339 340 trace_scsi_dispatch_cmd_timeout(scmd);341 scsi_log_completion(scmd, TIMEOUT_ERROR);342 343 atomic_inc(&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 modify360 * *scmd.361 */362 if (test_and_set_bit(SCMD_STATE_COMPLETE, &scmd->state))363 return BLK_EH_DONE;364 atomic_inc(&scmd->device->iodone_cnt);365 if (scsi_abort_command(scmd) != SUCCESS) {366 set_host_byte(scmd, 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 to379 * 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 */384int 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}394EXPORT_SYMBOL(scsi_block_when_processing_errors);395 396#ifdef CONFIG_SCSI_LOGGING397/**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 */402static 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 else419 ++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#endif441 442 /**443 * scsi_report_lun_change - Set flag on all *other* devices on the same target444 * to indicate that a UNIT ATTENTION is expected.445 * @sdev: Device reporting the UNIT ATTENTION446 */447static 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 for454 * certain conditions, also issue uevents for some of them.455 * @sdev: Device reporting the sense code456 * @sshdr: sshdr to be examined457 */458static 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-effect493 * 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(evt_type, sdev->pending_events);519 schedule_work(&sdev->event_work);520 }521}522 523static 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 sense530 * @scmd: Cmd to have sense checked.531 *532 * Return value:533 * SUCCESS or FAILED or NEEDS_RETRY or ADD_TO_MLQUEUE534 *535 * Notes:536 * When a deferred error is detected the current command has537 * not been executed and needs retrying.538 */539enum 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(scmd, &sshdr))546 return FAILED; /* no valid sense data */547 548 scsi_report_sense(sdev, &sshdr);549 550 if (scsi_sense_is_deferred(&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 the566 * actual sense data without any recovery attempt. For eh567 * issued ones, we need to try to recover and interpret568 */569 return SUCCESS;570 571 /*572 * Previous logic looked for FILEMARK, EOM or ILI which are573 * 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 data582 * descriptor" (see SSC-3). Assume single sense data583 * 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 the604 * COMMAND TIMEOUT BEFORE PROCESSING or605 * COMMAND TIMEOUT DURING PROCESSING or606 * COMMAND TIMEOUT DURING PROCESSING DUE TO ERROR RECOVERY607 * additional sense code qualifiers.608 */609 if (sshdr.asc == 0x2e &&610 sshdr.ascq >= 0x01 && sshdr.ascq <= 0x03) {611 set_scsi_ml_byte(scmd, 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 we628 * performed, treat this just as a retry. otherwise this is629 * information that we should pass up to the upper-level driver630 * so that we can deal with it there.631 */632 if (scmd->device->expecting_cc_ua) {633 /*634 * Because some device does not queue unit635 * attentions correctly, we carefully check636 * additional sense code and qualifier so as637 * 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 target646 * 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, we654 * 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 wake660 * the error handler to start the motor661 */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 completion667 * 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(scmd, 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(scmd, 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(scmd, 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 else699 set_scsi_ml_byte(scmd, 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(scmd, 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(scmd, 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}725EXPORT_SYMBOL_GPL(scsi_check_sense);726 727static 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 do746 * 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 759static 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 at773 * the device when we got the queue full so we start774 * 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 commands786 * queued during error recovery. the main difference here is that we787 * don't allow for the possibility of retries here, and we are a lot788 * more restrictive about what we consider acceptable.789 */790static 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 there794 * 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 now799 * get to try and figure out what to do next. if the sense800 * 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 indicates810 * anything special.811 */812 switch (get_status_byte(scmd)) {813 case SAM_STAT_GOOD:814 scsi_handle_queue_ramp_up(scmd->device);815 if (scmd->sense_buffer && SCSI_SENSE_VALID(scmd))816 /*817 * If we have sense data, call scsi_check_sense() in818 * order to set the correct SCSI ML byte (if any).819 * No point in checking the return value, since the820 * 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 and838 * 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(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 */857void 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 itself871 * @scmd: SCSI cmd to send host reset.872 */873static 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(host->host_lock, flags);894 }895 896 return rtn;897}898 899/**900 * scsi_try_bus_reset - ask host to perform a bus reset901 * @scmd: SCSI cmd to send bus reset.902 */903static 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(host->host_lock, flags);924 }925 926 return rtn;927}928 929static 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 reset937 * @scmd: SCSI cmd used to send a target reset938 *939 * Notes:940 * There is no timeout for this operation. if this operation is941 * unreliable for a given host, then the host itself needs to put a942 * timer on it, and set the host back to a consistent state prior to943 * returning.944 */945static 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(scmd->device), NULL,959 __scsi_report_device_reset);960 spin_unlock_irqrestore(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 dev968 * @scmd: SCSI cmd used to send BDR969 *970 * Notes:971 * There is no timeout for this operation. if this operation is972 * unreliable for a given host, then the host itself needs to put a973 * timer on it, and set the host back to a consistent state prior to974 * returning.975 */976static 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(scmd->device, NULL);987 return rtn;988}989 990/**991 * scsi_try_to_abort_cmd - Ask host to abort a SCSI command992 * @hostt: SCSI driver host template993 * @scmd: SCSI cmd used to send a target reset994 *995 * Return value:996 * SUCCESS, FAILED, or FAST_IO_FAIL997 *998 * Notes:999 * SUCCESS does not necessarily indicate that the command1000 * has been aborted; it only indicates that the LLDDs1001 * has cleared all references to that command.1002 * LLDDs should return FAILED only if an abort was required1003 * but could not be executed. LLDDs should return FAST_IO_FAIL1004 * if the device is temporarily unavailable (eg due to a1005 * link down on FibreChannel)1006 */1007static enum scsi_disposition1008scsi_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 1016static void scsi_abort_eh_cmnd(struct scsi_cmnd *scmd)1017{1018 if (scsi_try_to_abort_cmd(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 recovery1027 * @scmd: SCSI command structure to hijack1028 * @ses: structure to save restore information1029 * @cmnd: CDB to send. Can be NULL if no new cmnd is needed1030 * @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-execution1034 * as part of the error recovery process. If @sense_bytes is 0 the command1035 * sent must be one that does not transfer any data. If @sense_bytes != 01036 * @cmnd is ignored and this functions sets up a REQUEST_SENSE command1037 * and cmnd buffers to read @sense_bytes into @scmd->sense_buffer.1038 */1039void 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 because1046 * error handling may need to overwrite these with different values1047 * to run different commands, and once error handling is complete,1048 * we will need to restore these values prior to running the actual1049 * 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 any1096 * untransferred sense data should be interpreted as being zero.1097 */1098 memset(scmd->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);1099}1100EXPORT_SYMBOL(scsi_eh_prep_cmnd);1101 1102/**1103 * scsi_eh_restore_cmnd - Restore a scsi command info as part of error recovery1104 * @scmd: SCSI command structure to restore1105 * @ses: saved information from a coresponding call to scsi_eh_prep_cmnd1106 *1107 * Undo any damage done by above scsi_eh_prep_cmnd().1108 */1109void scsi_eh_restore_cmnd(struct scsi_cmnd* scmd, struct scsi_eh_save *ses)1110{1111 /*1112 * Restore original data1113 */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}1124EXPORT_SYMBOL(scsi_eh_restore_cmnd);1125 1126/**1127 * scsi_send_eh_cmnd - submit a scsi command as part of error recovery1128 * @scmd: SCSI command structure to hijack1129 * @cmnd: CDB to send1130 * @cmnd_size: size in bytes of @cmnd1131 * @timeout: timeout for this request1132 * @sense_bytes: size of sense data to copy or 01133 *1134 * This function is used to send a scsi command down to a target device1135 * as part of the error recovery process. See also scsi_eh_prep_cmnd() above.1136 *1137 * Return value:1138 * SUCCESS or FAILED or NEEDS_RETRY1139 */1140static 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(100);1149 int rtn;1150 1151retry:1152 scsi_eh_prep_cmnd(scmd, &ses, cmnd, cmnd_size, sense_bytes);1153 shost->eh_action = &done;1154 1155 scsi_log_send(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() can1161 * change the SCSI device state after we have examined it and before1162 * .queuecommand() is called.1163 */1164 mutex_lock(&sdev->state_mutex);1165 while (sdev->sdev_state == SDEV_BLOCK && timeleft > 0) {1166 mutex_unlock(&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(jiffies_to_msecs(delay));1173 mutex_lock(&sdev->state_mutex);1174 }1175 if (sdev->sdev_state != SDEV_BLOCK)1176 rtn = shost->hostt->queuecommand(shost, scmd);1177 else1178 rtn = FAILED;1179 mutex_unlock(&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(jiffies_to_msecs(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(&done, timeout);1194 rtn = SUCCESS;1195 }1196 1197 shost->eh_action = NULL;1198 1199 scsi_log_completion(scmd, 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 examine1207 * the actual status codes to see whether the command actually did1208 * 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, because1211 * ->queuecommand() kept returning non zero, use the rtn = FAILED1212 * 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 require1247 * that we obtain it on our own. This function will *not* return until1248 * the command either times out, or it completes.1249 */1250static enum scsi_disposition scsi_request_sense(struct scsi_cmnd *scmd)1251{1252 return scsi_send_eh_cmnd(scmd, NULL, 0, scmd->device->eh_timeout, ~0);1253}1254 1255static enum scsi_disposition1256scsi_eh_action(struct scsi_cmnd *scmd, enum scsi_disposition rtn)1257{1258 if (!blk_rq_is_passthrough(scsi_cmd_to_rq(scmd))) {1259 struct scsi_driver *sdrv = scsi_cmd_to_driver(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 are1273 * still handling errors - it may cause other commands to be queued,1274 * and that would disturb what we are doing. Thus we really want to1275 * keep a list of pending commands for final completion, and once we1276 * are ready to leave error handling we handle completion for real.1277 */1278void scsi_eh_finish_cmd(struct scsi_cmnd *scmd, struct list_head *done_q)1279{1280 list_move_tail(&scmd->eh_entry, done_q);1281}1282EXPORT_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 it1291 * 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 does1295 * not automatically request sense information, we end up shutting1296 * 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 of1302 * all LLDDs first.1303 */1304int 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(scmd->result))1329 /*1330 * don't request sense if there's no check condition1331 * status because the error we're processing isn't one1332 * that has a sense code (and some devices get1333 * 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(scmd);1349 1350 /*1351 * if the result was normal, then just pass it along to the1352 * upper level.1353 */1354 if (rtn == SUCCESS)1355 /*1356 * We don't want this command reissued, just finished1357 * with the sense data, so set retries to the max1358 * allowed to ensure it won't get reissued. If the user1359 * has requested infinite retries, we also want to1360 * finish this command, so force completion by setting1361 * retries and allowed to the same value.1362 */1363 if (scmd->allowed == SCSI_CMD_RETRIES_NO_LIMIT)1364 scmd->retries = scmd->allowed = 1;1365 else1366 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(work_q);1374}1375EXPORT_SYMBOL_GPL(scsi_eh_get_sense);1376 1377/**1378 * scsi_eh_tur - Send TUR to device.1379 * @scmd: &scsi_cmnd to send TUR1380 *1381 * Return value:1382 * 0 - Device is ready. 1 - Device NOT ready.1383 */1384static 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 1390retry_tur:1391 rtn = scsi_send_eh_cmnd(scmd, tur_command, 6,1392 scmd->device->eh_timeout, 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 recovery1413 * @done_q: queue for commands which are finished1414 * @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 in1418 * a working state are sent to the done_q while commands to devices which1419 * are still failing to respond are returned to the work_q for more1420 * processing.1421 **/1422static 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(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(sdev->host)) {1436 /* Push items back onto work_q */1437 list_splice_init(cmd_list, 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(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, SUCCESS) == SUCCESS))1456 scsi_eh_finish_cmd(scmd, done_q);1457 else1458 list_move_tail(&scmd->eh_entry, work_q);1459 }1460 }1461 return list_empty(work_q);1462}1463 1464/**1465 * scsi_eh_try_stu - Send START_UNIT to device.1466 * @scmd: &scsi_cmnd to send START_UNIT1467 *1468 * Return value:1469 * 0 - Device is ready. 1 - Device NOT ready.1470 */1471static 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, stu_command, 6,1481 scmd->device->eh_timeout, 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 needed1492 * @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 */1500static 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(stu_scmd)) {1533 if (!scsi_device_online(sdev) ||1534 !scsi_eh_tur(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, 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(work_q);1551}1552 1553 1554/**1555 * scsi_eh_bus_device_reset - send bdr if needed1556 * @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 multiple1562 * devices that are jammed or not - if we have multiple devices, it1563 * makes no sense to try bus_device_reset - we really would need to try1564 * a bus_reset instead.1565 */1566static 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(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(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(work_q);1617}1618 1619/**1620 * scsi_eh_target_reset - send target reset if needed1621 * @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 */1628static 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(work_q, &tmp_list);1636 1637 while (!list_empty(&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(&check_list, work_q);1645 list_splice_init(&tmp_list, 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(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(&scmd->eh_entry, &check_list);1673 else if (rtn == FAST_IO_FAIL)1674 scsi_eh_finish_cmd(scmd, done_q);1675 else1676 /* push back on work queue for further processing */1677 list_move(&scmd->eh_entry, work_q);1678 }1679 }1680 1681 return scsi_eh_test_devices(&check_list, work_q, done_q, 0);1682}1683 1684/**1685 * scsi_eh_bus_reset - send a bus reset1686 * @shost: &scsi host being recovered.1687 * @work_q: &list_head for pending commands.1688 * @done_q: &list_head for processed commands.1689 */1690static 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 on1701 * a channel by channel basis. we should also check to see if any1702 * of the failed commands are on soft_reset devices, and if so, skip1703 * 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(&check_list, 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(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 for1723 * 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(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 else1742 list_move_tail(&scmd->eh_entry,1743 &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(&check_list, work_q, done_q, 0);1754}1755 1756/**1757 * scsi_eh_host_reset - send a host reset1758 * @shost: host to be reset.1759 * @work_q: &list_head for pending commands.1760 * @done_q: &list_head for processed commands.1761 */1762static 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(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(work_q, &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(&check_list, work_q, done_q, 1);1794}1795 1796/**1797 * scsi_eh_offline_sdevs - offline scsi devices that fail to recover1798 * @work_q: &list_head for pending commands.1799 * @done_q: &list_head for processed commands.1800 */1801static 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, SDEV_OFFLINE);1814 mutex_unlock(&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 fast1823 * @scmd: SCSI cmd to examine.1824 */1825bool 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(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(scmd->result) == SCSIML_STAT_DL_TIMEOUT)1848 return true;1849 1850 if (!scsi_status_is_check_condition(scmd->result))1851 return false;1852 1853check_type:1854 /*1855 * assume caller has checked sense and determined1856 * the check condition was retryable.1857 */1858 if (req->cmd_flags & REQ_FAILFAST_DEV || blk_rq_is_passthrough(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 sending1870 * out the actual data command. any commands that are queued for error1871 * recovery (e.g. test_unit_ready) do *not* come through here.1872 *1873 * When this routine returns failed, it means the error handler thread1874 * is woken. In cases where the error code indicates an error that1875 * doesn't require the error handler read (i.e. we don't need to1876 * abort/reset), this function should return SUCCESS.1877 */1878enum 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 back1884 * up to the top level.1885 */1886 if (!scsi_device_online(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 there1894 * 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 saying1901 * 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(scmd, 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 back1920 * to the top level driver, not that we actually think1921 * 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 counter1928 * 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 IO1941 * based on its timers and recovery capablilities if1942 * there are enough retries.1943 */1944 goto maybe_retry;1945 case DID_TRANSPORT_FAILFAST:1946 /*1947 * The transport decided to failfast the IO (most likely1948 * 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 on1954 * abort success, so send IO directly upwards1955 */1956 return SUCCESS;1957 case DID_ERROR:1958 if (get_status_byte(scmd) == SAM_STAT_RESERVATION_CONFLICT)1959 /*1960 * execute reservation conflict processing code1961 * lower down1962 */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 for1971 * 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(scmd)) {1990 case SAM_STAT_TASK_SET_FULL:1991 scsi_handle_queue_full(scmd->device);1992 /*1993 * the case of trying to send too many commands to a1994 * tagged queueing device.1995 */1996 fallthrough;1997 case SAM_STAT_BUSY:1998 /*1999 * device can't talk to us at the moment. Should only2000 * occur (SAM-3) when the task queue is empty, so will cause2001 * the empty queue handling to trigger a stall in the2002 * 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(scmd->device);2009 if (scmd->sense_buffer && SCSI_SENSE_VALID(scmd))2010 /*2011 * If we have sense data, call scsi_check_sense() in2012 * order to set the correct SCSI ML byte (if any).2013 * No point in checking the return value, since the2014 * 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 thread2028 * to collect the sense and redo the decide2029 * 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(scmd, SCSIML_STAT_RESV_CONFLICT);2044 return SUCCESS; /* causes immediate i/o error */2045 }2046 return FAILED;2047 2048maybe_retry:2049 2050 /* we requeue for retry because the error was retryable, and2051 * the request was not marked fast fail. Note that above,2052 * even if the request is marked fast fail, we still requeue2053 * for queue congestion conditions (QUEUE_FULL or BUSY) */2054 if (scsi_cmd_retry_allowed(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 2064static enum rq_end_io_ret eh_lock_door_done(struct request *req,2065 blk_status_t status)2066{2067 blk_mq_free_request(req);2068 return RQ_END_IO_NONE;2069}2070 2071/**2072 * scsi_eh_lock_door - Prevent medium removal for the specified device2073 * @sdev: SCSI device to prevent medium removal2074 *2075 * Locking:2076 * We must be called from process context.2077 *2078 * Notes:2079 * We queue up an asynchronous "ALLOW MEDIUM REMOVAL" request on the2080 * head of the devices request queue, and continue.2081 */2082static 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(sdev->request_queue, REQ_OP_DRV_IN, 0);2088 if (IS_ERR(req))2089 return;2090 scmd = blk_mq_rq_to_pdu(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(req, 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 to2114 * this device. we need to 'reverse' this process.2115 */2116static 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 request2123 * onto the head of the SCSI request queue for the device. There2124 * 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. this2135 * will be requests for character device operations, and also for2136 * 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(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 will2151 * have had everything blocked while error handling is taking place, and2152 * now that error recovery is done, we will need to ensure that these2153 * 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-run2159 * recovery. we do this check after scsi_run_host_queues() to allow2160 * everything pent up since the last eh run a chance to make forward2161 * progress before we sync again. Either we'll immediately re-run2162 * recovery or scsi_device_unbusy() will wake us again when these2163 * 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(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 */2178void 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}2190EXPORT_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 */2196void 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(&scmd->eh_entry);2204 if (scsi_device_online(sdev) && !scsi_noretry_cmd(scmd) &&2205 scsi_cmd_retry_allowed(scmd) &&2206 scsi_eh_should_retry_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(scmd, SCSI_MLQUEUE_EH_RETRY);2212 blk_mq_kick_requeue_list(sdev->request_queue);2213 } else {2214 /*2215 * If just we got sense for the device (called2216 * scsi_eh_get_sense), scmd->result is already2217 * 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(scmd);2227 }2228 }2229}2230EXPORT_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 have2238 * either completed, failed or timed out. we also know that no further2239 * commands are being sent to the host, so things are relatively quiet2240 * and we have freedom to fiddle with things as we wish.2241 *2242 * This is only the *default* implementation. it is possible for2243 * individual drivers to supply their own version of this function, and2244 * if the maintainer wishes to do this, it is strongly suggested that2245 * this function be taken as a template and modified. this function2246 * was designed to correctly handle problems for about 95% of the2247 * different cases out there, and it should always provide at least a2248 * reasonable amount of error recovery.2249 *2250 * Any command marked 'failed' or 'timeout' must eventually have2251 * scsi_finish_cmd() called for it. we do all of the retry stuff2252 * here, so when we restart the host after we return it should have an2253 * empty queue.2254 */2255static 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(&shost->eh_cmd_q, &eh_work_q);2263 spin_unlock_irqrestore(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(shost->host_lock, flags);2274 scsi_eh_flush_done_q(&eh_done_q);2275}2276 2277/**2278 * scsi_error_handler - SCSI error handler thread2279 * @data: Host for which we are running.2280 *2281 * Notes:2282 * This is the main error handling loop. This is run as a kernel thread2283 * for every SCSI host and handles all error handling activity.2284 */2285int scsi_error_handler(void *data)2286{2287 struct Scsi_Host *shost = data;2288 2289 /*2290 * We use TASK_INTERRUPTIBLE so that the thread is not2291 * counted against the load average as a running process.2292 * We never actually get interrupted because kthread_run2293 * disables signal delivery for the created thread.2294 */2295 while (true) {2296 /*2297 * The sequence in kthread_stop() sets the stop flag first2298 * then wakes the process. To avoid missed wakeups, the task2299 * should always be in a non running state before the stop2300 * flag is checked2301 */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 out2326 * 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 else2340 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 take2347 * individual devices offline and flush the queue of any2348 * outstanding requests that may have been pending. When we2349 * restart, we restart any I/O to any other devices on the bus2350 * 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 that2370 * they have observed a bus reset on the bus being handled.2371 *2372 * Arguments: shost - Host in question2373 * channel - channel on which reset was observed.2374 *2375 * Returns: Nothing2376 *2377 * Lock status: Host lock must be held.2378 *2379 * Notes: This only needs to be called if the reset is one which2380 * originates from an unknown location. Resets originated2381 * by the mid-level itself don't need to call this, but there2382 * should be no harm.2383 *2384 * The main purpose of this is to make sure that a CHECK_CONDITION2385 * is properly treated.2386 */2387void 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}2396EXPORT_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 that2402 * they have observed a device reset on the device being handled.2403 *2404 * Arguments: shost - Host in question2405 * channel - channel on which reset was observed2406 * target - target on which reset was observed2407 *2408 * Returns: Nothing2409 *2410 * Lock status: Host lock must be held2411 *2412 * Notes: This only needs to be called if the reset is one which2413 * originates from an unknown location. Resets originated2414 * by the mid-level itself don't need to call this, but there2415 * should be no harm.2416 *2417 * The main purpose of this is to make sure that a CHECK_CONDITION2418 * is properly treated.2419 */2420void 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}2430EXPORT_SYMBOL(scsi_report_device_reset);2431 2432/**2433 * scsi_ioctl_reset: explicitly reset a host/bus/target/device2434 * @dev: scsi_device to operate on2435 * @arg: reset type (see sg.h)2436 */2437int2438scsi_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(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, 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(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(shost->host_lock, flags);2513 2514 /*2515 * be sure to wake up anyone who was sleeping or had their queue2516 * 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(rq);2526 2527out_put_autopm_host:2528 scsi_autopm_put_host(shost);2529 return error;2530}2531 2532bool scsi_command_normalize_sense(const struct scsi_cmnd *cmd,2533 struct scsi_sense_hdr *sshdr)2534{2535 return scsi_normalize_sense(cmd->sense_buffer,2536 SCSI_SENSE_BUFFERSIZE, sshdr);2537}2538EXPORT_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 data2543 * @sb_len: number of valid bytes in sense_buffer2544 * @info_out: pointer to 64 integer where 8 or 4 byte information2545 * field will be placed if found.2546 *2547 * Return value:2548 * true if information field found, false if not found.2549 */2550bool 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(&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 0 /* info desc */);2569 if (ucp && (0xa == ucp[1])) {2570 *info_out = get_unaligned_be64(&ucp[4]);2571 return true;2572 }2573 return false;2574 default:2575 return false;2576 }2577}2578EXPORT_SYMBOL(scsi_get_sense_info_fld);2579