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