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 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 host 78 * @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 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 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 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 */ 146void 147scmd_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 further 189 * 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 abort 223 * @scmd: scmd to abort. 224 * 225 * We only need to abort commands after a command timeout 226 */ 227static int 228scsi_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 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 */ 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 the 320 * 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 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 */ 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 modify 360 * *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 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 */ 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_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 */ 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 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 */ 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 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 */ 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-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(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 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 */ 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 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(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 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(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 else 699 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 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 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 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 */ 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 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(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() 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(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 itself 871 * @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 reset 901 * @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 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 */ 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 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 */ 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 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 */ 1007static enum scsi_disposition 1008scsi_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 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 */ 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 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} 1100EXPORT_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 */ 1109void 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} 1124EXPORT_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 */ 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() 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(&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 else 1178 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 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 */ 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_disposition 1256scsi_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 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 */ 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 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 */ 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 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(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(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 TUR 1380 * 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 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 **/ 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 else 1458 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_UNIT 1467 * 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 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 */ 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 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 */ 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 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 */ 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 else 1676 /* 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 reset 1686 * @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 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(&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 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(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(&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 reset 1758 * @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 recover 1798 * @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 fast 1823 * @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 determined 1856 * 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 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 */ 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 back 1884 * 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 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(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 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(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(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 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(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(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, 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(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 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 */ 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 to 2114 * 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 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(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(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 (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(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 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 */ 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 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 */ 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 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 */ 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 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 */ 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/device 2434 * @dev: scsi_device to operate on 2435 * @arg: reset type (see sg.h) 2436 */ 2437int 2438scsi_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 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(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 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 */ 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