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