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 /* 477 * let issuer deal with this, it could be just fine 478 */ 479 return SUCCESS; 480 case QUEUE_FULL: 481 scsi_handle_queue_full(scmd->device); 482 /* fall through */ 483 case BUSY: 484 default: 485 return FAILED; 486 } 487 return FAILED; 488 } 489 490 /** 491 * scsi_eh_done - Completion function for error handling. 492 * @scmd: Cmd that is done. 493 */ 494 static void scsi_eh_done(struct scsi_cmnd *scmd) 495 { 496 struct completion *eh_action; 497 498 SCSI_LOG_ERROR_RECOVERY(3, 499 printk("%s scmd: %p result: %x\n", 500 __func__, scmd, scmd->result)); 501 502 eh_action = scmd->device->host->eh_action; 503 if (eh_action) 504 complete(eh_action); 505 } 506 507 /** 508 * scsi_try_host_reset - ask host adapter to reset itself 509 * @scmd: SCSI cmd to send hsot reset. 510 */ 511 static int scsi_try_host_reset(struct scsi_cmnd *scmd) 512 { 513 unsigned long flags; 514 int rtn; 515 516 SCSI_LOG_ERROR_RECOVERY(3, printk("%s: Snd Host RST\n", 517 __func__)); 518 519 if (!scmd->device->host->hostt->eh_host_reset_handler) 520 return FAILED; 521 522 rtn = scmd->device->host->hostt->eh_host_reset_handler(scmd); 523 524 if (rtn == SUCCESS) { 525 if (!scmd->device->host->hostt->skip_settle_delay) 526 ssleep(HOST_RESET_SETTLE_TIME); 527 spin_lock_irqsave(scmd->device->host->host_lock, flags); 528 scsi_report_bus_reset(scmd->device->host, 529 scmd_channel(scmd)); 530 spin_unlock_irqrestore(scmd->device->host->host_lock, flags); 531 } 532 533 return rtn; 534 } 535 536 /** 537 * scsi_try_bus_reset - ask host to perform a bus reset 538 * @scmd: SCSI cmd to send bus reset. 539 */ 540 static int scsi_try_bus_reset(struct scsi_cmnd *scmd) 541 { 542 unsigned long flags; 543 int rtn; 544 545 SCSI_LOG_ERROR_RECOVERY(3, printk("%s: Snd Bus RST\n", 546 __func__)); 547 548 if (!scmd->device->host->hostt->eh_bus_reset_handler) 549 return FAILED; 550 551 rtn = scmd->device->host->hostt->eh_bus_reset_handler(scmd); 552 553 if (rtn == SUCCESS) { 554 if (!scmd->device->host->hostt->skip_settle_delay) 555 ssleep(BUS_RESET_SETTLE_TIME); 556 spin_lock_irqsave(scmd->device->host->host_lock, flags); 557 scsi_report_bus_reset(scmd->device->host, 558 scmd_channel(scmd)); 559 spin_unlock_irqrestore(scmd->device->host->host_lock, flags); 560 } 561 562 return rtn; 563 } 564 565 static void __scsi_report_device_reset(struct scsi_device *sdev, void *data) 566 { 567 sdev->was_reset = 1; 568 sdev->expecting_cc_ua = 1; 569 } 570 571 /** 572 * scsi_try_target_reset - Ask host to perform a target reset 573 * @scmd: SCSI cmd used to send a target reset 574 * 575 * Notes: 576 * There is no timeout for this operation. if this operation is 577 * unreliable for a given host, then the host itself needs to put a 578 * timer on it, and set the host back to a consistent state prior to 579 * returning. 580 */ 581 static int scsi_try_target_reset(struct scsi_cmnd *scmd) 582 { 583 unsigned long flags; 584 int rtn; 585 586 if (!scmd->device->host->hostt->eh_target_reset_handler) 587 return FAILED; 588 589 rtn = scmd->device->host->hostt->eh_target_reset_handler(scmd); 590 if (rtn == SUCCESS) { 591 spin_lock_irqsave(scmd->device->host->host_lock, flags); 592 __starget_for_each_device(scsi_target(scmd->device), NULL, 593 __scsi_report_device_reset); 594 spin_unlock_irqrestore(scmd->device->host->host_lock, flags); 595 } 596 597 return rtn; 598 } 599 600 /** 601 * scsi_try_bus_device_reset - Ask host to perform a BDR on a dev 602 * @scmd: SCSI cmd used to send BDR 603 * 604 * Notes: 605 * There is no timeout for this operation. if this operation is 606 * unreliable for a given host, then the host itself needs to put a 607 * timer on it, and set the host back to a consistent state prior to 608 * returning. 609 */ 610 static int scsi_try_bus_device_reset(struct scsi_cmnd *scmd) 611 { 612 int rtn; 613 614 if (!scmd->device->host->hostt->eh_device_reset_handler) 615 return FAILED; 616 617 rtn = scmd->device->host->hostt->eh_device_reset_handler(scmd); 618 if (rtn == SUCCESS) 619 __scsi_report_device_reset(scmd->device, NULL); 620 return rtn; 621 } 622 623 static int __scsi_try_to_abort_cmd(struct scsi_cmnd *scmd) 624 { 625 if (!scmd->device->host->hostt->eh_abort_handler) 626 return FAILED; 627 628 return scmd->device->host->hostt->eh_abort_handler(scmd); 629 } 630 631 /** 632 * scsi_try_to_abort_cmd - Ask host to abort a running command. 633 * @scmd: SCSI cmd to abort from Lower Level. 634 * 635 * Notes: 636 * This function will not return until the user's completion function 637 * has been called. there is no timeout on this operation. if the 638 * author of the low-level driver wishes this operation to be timed, 639 * they can provide this facility themselves. helper functions in 640 * scsi_error.c can be supplied to make this easier to do. 641 */ 642 static int scsi_try_to_abort_cmd(struct scsi_cmnd *scmd) 643 { 644 /* 645 * scsi_done was called just after the command timed out and before 646 * we had a chance to process it. (db) 647 */ 648 if (scmd->serial_number == 0) 649 return SUCCESS; 650 return __scsi_try_to_abort_cmd(scmd); 651 } 652 653 static void scsi_abort_eh_cmnd(struct scsi_cmnd *scmd) 654 { 655 if (__scsi_try_to_abort_cmd(scmd) != SUCCESS) 656 if (scsi_try_bus_device_reset(scmd) != SUCCESS) 657 if (scsi_try_target_reset(scmd) != SUCCESS) 658 if (scsi_try_bus_reset(scmd) != SUCCESS) 659 scsi_try_host_reset(scmd); 660 } 661 662 /** 663 * scsi_eh_prep_cmnd - Save a scsi command info as part of error recory 664 * @scmd: SCSI command structure to hijack 665 * @ses: structure to save restore information 666 * @cmnd: CDB to send. Can be NULL if no new cmnd is needed 667 * @cmnd_size: size in bytes of @cmnd (must be <= BLK_MAX_CDB) 668 * @sense_bytes: size of sense data to copy. or 0 (if != 0 @cmnd is ignored) 669 * 670 * This function is used to save a scsi command information before re-execution 671 * as part of the error recovery process. If @sense_bytes is 0 the command 672 * sent must be one that does not transfer any data. If @sense_bytes != 0 673 * @cmnd is ignored and this functions sets up a REQUEST_SENSE command 674 * and cmnd buffers to read @sense_bytes into @scmd->sense_buffer. 675 */ 676 void scsi_eh_prep_cmnd(struct scsi_cmnd *scmd, struct scsi_eh_save *ses, 677 unsigned char *cmnd, int cmnd_size, unsigned sense_bytes) 678 { 679 struct scsi_device *sdev = scmd->device; 680 681 /* 682 * We need saved copies of a number of fields - this is because 683 * error handling may need to overwrite these with different values 684 * to run different commands, and once error handling is complete, 685 * we will need to restore these values prior to running the actual 686 * command. 687 */ 688 ses->cmd_len = scmd->cmd_len; 689 ses->cmnd = scmd->cmnd; 690 ses->data_direction = scmd->sc_data_direction; 691 ses->sdb = scmd->sdb; 692 ses->next_rq = scmd->request->next_rq; 693 ses->result = scmd->result; 694 ses->underflow = scmd->underflow; 695 ses->prot_op = scmd->prot_op; 696 697 scmd->prot_op = SCSI_PROT_NORMAL; 698 scmd->cmnd = ses->eh_cmnd; 699 memset(scmd->cmnd, 0, BLK_MAX_CDB); 700 memset(&scmd->sdb, 0, sizeof(scmd->sdb)); 701 scmd->request->next_rq = NULL; 702 703 if (sense_bytes) { 704 scmd->sdb.length = min_t(unsigned, SCSI_SENSE_BUFFERSIZE, 705 sense_bytes); 706 sg_init_one(&ses->sense_sgl, scmd->sense_buffer, 707 scmd->sdb.length); 708 scmd->sdb.table.sgl = &ses->sense_sgl; 709 scmd->sc_data_direction = DMA_FROM_DEVICE; 710 scmd->sdb.table.nents = 1; 711 scmd->cmnd[0] = REQUEST_SENSE; 712 scmd->cmnd[4] = scmd->sdb.length; 713 scmd->cmd_len = COMMAND_SIZE(scmd->cmnd[0]); 714 } else { 715 scmd->sc_data_direction = DMA_NONE; 716 if (cmnd) { 717 BUG_ON(cmnd_size > BLK_MAX_CDB); 718 memcpy(scmd->cmnd, cmnd, cmnd_size); 719 scmd->cmd_len = COMMAND_SIZE(scmd->cmnd[0]); 720 } 721 } 722 723 scmd->underflow = 0; 724 725 if (sdev->scsi_level <= SCSI_2 && sdev->scsi_level != SCSI_UNKNOWN) 726 scmd->cmnd[1] = (scmd->cmnd[1] & 0x1f) | 727 (sdev->lun << 5 & 0xe0); 728 729 /* 730 * Zero the sense buffer. The scsi spec mandates that any 731 * untransferred sense data should be interpreted as being zero. 732 */ 733 memset(scmd->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE); 734 } 735 EXPORT_SYMBOL(scsi_eh_prep_cmnd); 736 737 /** 738 * scsi_eh_restore_cmnd - Restore a scsi command info as part of error recory 739 * @scmd: SCSI command structure to restore 740 * @ses: saved information from a coresponding call to scsi_eh_prep_cmnd 741 * 742 * Undo any damage done by above scsi_eh_prep_cmnd(). 743 */ 744 void scsi_eh_restore_cmnd(struct scsi_cmnd* scmd, struct scsi_eh_save *ses) 745 { 746 /* 747 * Restore original data 748 */ 749 scmd->cmd_len = ses->cmd_len; 750 scmd->cmnd = ses->cmnd; 751 scmd->sc_data_direction = ses->data_direction; 752 scmd->sdb = ses->sdb; 753 scmd->request->next_rq = ses->next_rq; 754 scmd->result = ses->result; 755 scmd->underflow = ses->underflow; 756 scmd->prot_op = ses->prot_op; 757 } 758 EXPORT_SYMBOL(scsi_eh_restore_cmnd); 759 760 /** 761 * scsi_send_eh_cmnd - submit a scsi command as part of error recory 762 * @scmd: SCSI command structure to hijack 763 * @cmnd: CDB to send 764 * @cmnd_size: size in bytes of @cmnd 765 * @timeout: timeout for this request 766 * @sense_bytes: size of sense data to copy or 0 767 * 768 * This function is used to send a scsi command down to a target device 769 * as part of the error recovery process. See also scsi_eh_prep_cmnd() above. 770 * 771 * Return value: 772 * SUCCESS or FAILED or NEEDS_RETRY 773 */ 774 static int scsi_send_eh_cmnd(struct scsi_cmnd *scmd, unsigned char *cmnd, 775 int cmnd_size, int timeout, unsigned sense_bytes) 776 { 777 struct scsi_device *sdev = scmd->device; 778 struct Scsi_Host *shost = sdev->host; 779 DECLARE_COMPLETION_ONSTACK(done); 780 unsigned long timeleft; 781 unsigned long flags; 782 struct scsi_eh_save ses; 783 int rtn; 784 785 scsi_eh_prep_cmnd(scmd, &ses, cmnd, cmnd_size, sense_bytes); 786 shost->eh_action = &done; 787 788 spin_lock_irqsave(shost->host_lock, flags); 789 scsi_log_send(scmd); 790 shost->hostt->queuecommand(scmd, scsi_eh_done); 791 spin_unlock_irqrestore(shost->host_lock, flags); 792 793 timeleft = wait_for_completion_timeout(&done, timeout); 794 795 shost->eh_action = NULL; 796 797 scsi_log_completion(scmd, SUCCESS); 798 799 SCSI_LOG_ERROR_RECOVERY(3, 800 printk("%s: scmd: %p, timeleft: %ld\n", 801 __func__, scmd, timeleft)); 802 803 /* 804 * If there is time left scsi_eh_done got called, and we will 805 * examine the actual status codes to see whether the command 806 * actually did complete normally, else tell the host to forget 807 * about this command. 808 */ 809 if (timeleft) { 810 rtn = scsi_eh_completed_normally(scmd); 811 SCSI_LOG_ERROR_RECOVERY(3, 812 printk("%s: scsi_eh_completed_normally %x\n", 813 __func__, rtn)); 814 815 switch (rtn) { 816 case SUCCESS: 817 case NEEDS_RETRY: 818 case FAILED: 819 break; 820 case ADD_TO_MLQUEUE: 821 rtn = NEEDS_RETRY; 822 break; 823 default: 824 rtn = FAILED; 825 break; 826 } 827 } else { 828 scsi_abort_eh_cmnd(scmd); 829 rtn = FAILED; 830 } 831 832 scsi_eh_restore_cmnd(scmd, &ses); 833 return rtn; 834 } 835 836 /** 837 * scsi_request_sense - Request sense data from a particular target. 838 * @scmd: SCSI cmd for request sense. 839 * 840 * Notes: 841 * Some hosts automatically obtain this information, others require 842 * that we obtain it on our own. This function will *not* return until 843 * the command either times out, or it completes. 844 */ 845 static int scsi_request_sense(struct scsi_cmnd *scmd) 846 { 847 return scsi_send_eh_cmnd(scmd, NULL, 0, SENSE_TIMEOUT, ~0); 848 } 849 850 /** 851 * scsi_eh_finish_cmd - Handle a cmd that eh is finished with. 852 * @scmd: Original SCSI cmd that eh has finished. 853 * @done_q: Queue for processed commands. 854 * 855 * Notes: 856 * We don't want to use the normal command completion while we are are 857 * still handling errors - it may cause other commands to be queued, 858 * and that would disturb what we are doing. Thus we really want to 859 * keep a list of pending commands for final completion, and once we 860 * are ready to leave error handling we handle completion for real. 861 */ 862 void scsi_eh_finish_cmd(struct scsi_cmnd *scmd, struct list_head *done_q) 863 { 864 scmd->device->host->host_failed--; 865 scmd->eh_eflags = 0; 866 list_move_tail(&scmd->eh_entry, done_q); 867 } 868 EXPORT_SYMBOL(scsi_eh_finish_cmd); 869 870 /** 871 * scsi_eh_get_sense - Get device sense data. 872 * @work_q: Queue of commands to process. 873 * @done_q: Queue of processed commands. 874 * 875 * Description: 876 * See if we need to request sense information. if so, then get it 877 * now, so we have a better idea of what to do. 878 * 879 * Notes: 880 * This has the unfortunate side effect that if a shost adapter does 881 * not automatically request sense information, we end up shutting 882 * it down before we request it. 883 * 884 * All drivers should request sense information internally these days, 885 * so for now all I have to say is tough noogies if you end up in here. 886 * 887 * XXX: Long term this code should go away, but that needs an audit of 888 * all LLDDs first. 889 */ 890 int scsi_eh_get_sense(struct list_head *work_q, 891 struct list_head *done_q) 892 { 893 struct scsi_cmnd *scmd, *next; 894 int rtn; 895 896 list_for_each_entry_safe(scmd, next, work_q, eh_entry) { 897 if ((scmd->eh_eflags & SCSI_EH_CANCEL_CMD) || 898 SCSI_SENSE_VALID(scmd)) 899 continue; 900 901 SCSI_LOG_ERROR_RECOVERY(2, scmd_printk(KERN_INFO, scmd, 902 "%s: requesting sense\n", 903 current->comm)); 904 rtn = scsi_request_sense(scmd); 905 if (rtn != SUCCESS) 906 continue; 907 908 SCSI_LOG_ERROR_RECOVERY(3, printk("sense requested for %p" 909 " result %x\n", scmd, 910 scmd->result)); 911 SCSI_LOG_ERROR_RECOVERY(3, scsi_print_sense("bh", scmd)); 912 913 rtn = scsi_decide_disposition(scmd); 914 915 /* 916 * if the result was normal, then just pass it along to the 917 * upper level. 918 */ 919 if (rtn == SUCCESS) 920 /* we don't want this command reissued, just 921 * finished with the sense data, so set 922 * retries to the max allowed to ensure it 923 * won't get reissued */ 924 scmd->retries = scmd->allowed; 925 else if (rtn != NEEDS_RETRY) 926 continue; 927 928 scsi_eh_finish_cmd(scmd, done_q); 929 } 930 931 return list_empty(work_q); 932 } 933 EXPORT_SYMBOL_GPL(scsi_eh_get_sense); 934 935 /** 936 * scsi_eh_tur - Send TUR to device. 937 * @scmd: &scsi_cmnd to send TUR 938 * 939 * Return value: 940 * 0 - Device is ready. 1 - Device NOT ready. 941 */ 942 static int scsi_eh_tur(struct scsi_cmnd *scmd) 943 { 944 static unsigned char tur_command[6] = {TEST_UNIT_READY, 0, 0, 0, 0, 0}; 945 int retry_cnt = 1, rtn; 946 947 retry_tur: 948 rtn = scsi_send_eh_cmnd(scmd, tur_command, 6, SENSE_TIMEOUT, 0); 949 950 SCSI_LOG_ERROR_RECOVERY(3, printk("%s: scmd %p rtn %x\n", 951 __func__, scmd, rtn)); 952 953 switch (rtn) { 954 case NEEDS_RETRY: 955 if (retry_cnt--) 956 goto retry_tur; 957 /*FALLTHRU*/ 958 case SUCCESS: 959 return 0; 960 default: 961 return 1; 962 } 963 } 964 965 /** 966 * scsi_eh_abort_cmds - abort pending commands. 967 * @work_q: &list_head for pending commands. 968 * @done_q: &list_head for processed commands. 969 * 970 * Decription: 971 * Try and see whether or not it makes sense to try and abort the 972 * running command. This only works out to be the case if we have one 973 * command that has timed out. If the command simply failed, it makes 974 * no sense to try and abort the command, since as far as the shost 975 * adapter is concerned, it isn't running. 976 */ 977 static int scsi_eh_abort_cmds(struct list_head *work_q, 978 struct list_head *done_q) 979 { 980 struct scsi_cmnd *scmd, *next; 981 int rtn; 982 983 list_for_each_entry_safe(scmd, next, work_q, eh_entry) { 984 if (!(scmd->eh_eflags & SCSI_EH_CANCEL_CMD)) 985 continue; 986 SCSI_LOG_ERROR_RECOVERY(3, printk("%s: aborting cmd:" 987 "0x%p\n", current->comm, 988 scmd)); 989 rtn = scsi_try_to_abort_cmd(scmd); 990 if (rtn == SUCCESS || rtn == FAST_IO_FAIL) { 991 scmd->eh_eflags &= ~SCSI_EH_CANCEL_CMD; 992 if (!scsi_device_online(scmd->device) || 993 rtn == FAST_IO_FAIL || 994 !scsi_eh_tur(scmd)) { 995 scsi_eh_finish_cmd(scmd, done_q); 996 } 997 998 } else 999 SCSI_LOG_ERROR_RECOVERY(3, printk("%s: aborting" 1000 " cmd failed:" 1001 "0x%p\n", 1002 current->comm, 1003 scmd)); 1004 } 1005 1006 return list_empty(work_q); 1007 } 1008 1009 /** 1010 * scsi_eh_try_stu - Send START_UNIT to device. 1011 * @scmd: &scsi_cmnd to send START_UNIT 1012 * 1013 * Return value: 1014 * 0 - Device is ready. 1 - Device NOT ready. 1015 */ 1016 static int scsi_eh_try_stu(struct scsi_cmnd *scmd) 1017 { 1018 static unsigned char stu_command[6] = {START_STOP, 0, 0, 0, 1, 0}; 1019 1020 if (scmd->device->allow_restart) { 1021 int i, rtn = NEEDS_RETRY; 1022 1023 for (i = 0; rtn == NEEDS_RETRY && i < 2; i++) 1024 rtn = scsi_send_eh_cmnd(scmd, stu_command, 6, scmd->device->request_queue->rq_timeout, 0); 1025 1026 if (rtn == SUCCESS) 1027 return 0; 1028 } 1029 1030 return 1; 1031 } 1032 1033 /** 1034 * scsi_eh_stu - send START_UNIT if needed 1035 * @shost: &scsi host being recovered. 1036 * @work_q: &list_head for pending commands. 1037 * @done_q: &list_head for processed commands. 1038 * 1039 * Notes: 1040 * If commands are failing due to not ready, initializing command required, 1041 * try revalidating the device, which will end up sending a start unit. 1042 */ 1043 static int scsi_eh_stu(struct Scsi_Host *shost, 1044 struct list_head *work_q, 1045 struct list_head *done_q) 1046 { 1047 struct scsi_cmnd *scmd, *stu_scmd, *next; 1048 struct scsi_device *sdev; 1049 1050 shost_for_each_device(sdev, shost) { 1051 stu_scmd = NULL; 1052 list_for_each_entry(scmd, work_q, eh_entry) 1053 if (scmd->device == sdev && SCSI_SENSE_VALID(scmd) && 1054 scsi_check_sense(scmd) == FAILED ) { 1055 stu_scmd = scmd; 1056 break; 1057 } 1058 1059 if (!stu_scmd) 1060 continue; 1061 1062 SCSI_LOG_ERROR_RECOVERY(3, printk("%s: Sending START_UNIT to sdev:" 1063 " 0x%p\n", current->comm, sdev)); 1064 1065 if (!scsi_eh_try_stu(stu_scmd)) { 1066 if (!scsi_device_online(sdev) || 1067 !scsi_eh_tur(stu_scmd)) { 1068 list_for_each_entry_safe(scmd, next, 1069 work_q, eh_entry) { 1070 if (scmd->device == sdev) 1071 scsi_eh_finish_cmd(scmd, done_q); 1072 } 1073 } 1074 } else { 1075 SCSI_LOG_ERROR_RECOVERY(3, 1076 printk("%s: START_UNIT failed to sdev:" 1077 " 0x%p\n", current->comm, sdev)); 1078 } 1079 } 1080 1081 return list_empty(work_q); 1082 } 1083 1084 1085 /** 1086 * scsi_eh_bus_device_reset - send bdr if needed 1087 * @shost: scsi host being recovered. 1088 * @work_q: &list_head for pending commands. 1089 * @done_q: &list_head for processed commands. 1090 * 1091 * Notes: 1092 * Try a bus device reset. Still, look to see whether we have multiple 1093 * devices that are jammed or not - if we have multiple devices, it 1094 * makes no sense to try bus_device_reset - we really would need to try 1095 * a bus_reset instead. 1096 */ 1097 static int scsi_eh_bus_device_reset(struct Scsi_Host *shost, 1098 struct list_head *work_q, 1099 struct list_head *done_q) 1100 { 1101 struct scsi_cmnd *scmd, *bdr_scmd, *next; 1102 struct scsi_device *sdev; 1103 int rtn; 1104 1105 shost_for_each_device(sdev, shost) { 1106 bdr_scmd = NULL; 1107 list_for_each_entry(scmd, work_q, eh_entry) 1108 if (scmd->device == sdev) { 1109 bdr_scmd = scmd; 1110 break; 1111 } 1112 1113 if (!bdr_scmd) 1114 continue; 1115 1116 SCSI_LOG_ERROR_RECOVERY(3, printk("%s: Sending BDR sdev:" 1117 " 0x%p\n", current->comm, 1118 sdev)); 1119 rtn = scsi_try_bus_device_reset(bdr_scmd); 1120 if (rtn == SUCCESS || rtn == FAST_IO_FAIL) { 1121 if (!scsi_device_online(sdev) || 1122 rtn == FAST_IO_FAIL || 1123 !scsi_eh_tur(bdr_scmd)) { 1124 list_for_each_entry_safe(scmd, next, 1125 work_q, eh_entry) { 1126 if (scmd->device == sdev) 1127 scsi_eh_finish_cmd(scmd, 1128 done_q); 1129 } 1130 } 1131 } else { 1132 SCSI_LOG_ERROR_RECOVERY(3, printk("%s: BDR" 1133 " failed sdev:" 1134 "0x%p\n", 1135 current->comm, 1136 sdev)); 1137 } 1138 } 1139 1140 return list_empty(work_q); 1141 } 1142 1143 /** 1144 * scsi_eh_target_reset - send target reset if needed 1145 * @shost: scsi host being recovered. 1146 * @work_q: &list_head for pending commands. 1147 * @done_q: &list_head for processed commands. 1148 * 1149 * Notes: 1150 * Try a target reset. 1151 */ 1152 static int scsi_eh_target_reset(struct Scsi_Host *shost, 1153 struct list_head *work_q, 1154 struct list_head *done_q) 1155 { 1156 struct scsi_cmnd *scmd, *tgtr_scmd, *next; 1157 unsigned int id = 0; 1158 int rtn; 1159 1160 do { 1161 tgtr_scmd = NULL; 1162 list_for_each_entry(scmd, work_q, eh_entry) { 1163 if (id == scmd_id(scmd)) { 1164 tgtr_scmd = scmd; 1165 break; 1166 } 1167 } 1168 if (!tgtr_scmd) { 1169 /* not one exactly equal; find the next highest */ 1170 list_for_each_entry(scmd, work_q, eh_entry) { 1171 if (scmd_id(scmd) > id && 1172 (!tgtr_scmd || 1173 scmd_id(tgtr_scmd) > scmd_id(scmd))) 1174 tgtr_scmd = scmd; 1175 } 1176 } 1177 if (!tgtr_scmd) 1178 /* no more commands, that's it */ 1179 break; 1180 1181 SCSI_LOG_ERROR_RECOVERY(3, printk("%s: Sending target reset " 1182 "to target %d\n", 1183 current->comm, id)); 1184 rtn = scsi_try_target_reset(tgtr_scmd); 1185 if (rtn == SUCCESS || rtn == FAST_IO_FAIL) { 1186 list_for_each_entry_safe(scmd, next, work_q, eh_entry) { 1187 if (id == scmd_id(scmd)) 1188 if (!scsi_device_online(scmd->device) || 1189 rtn == FAST_IO_FAIL || 1190 !scsi_eh_tur(tgtr_scmd)) 1191 scsi_eh_finish_cmd(scmd, 1192 done_q); 1193 } 1194 } else 1195 SCSI_LOG_ERROR_RECOVERY(3, printk("%s: Target reset" 1196 " failed target: " 1197 "%d\n", 1198 current->comm, id)); 1199 id++; 1200 } while(id != 0); 1201 1202 return list_empty(work_q); 1203 } 1204 1205 /** 1206 * scsi_eh_bus_reset - send a bus reset 1207 * @shost: &scsi host being recovered. 1208 * @work_q: &list_head for pending commands. 1209 * @done_q: &list_head for processed commands. 1210 */ 1211 static int scsi_eh_bus_reset(struct Scsi_Host *shost, 1212 struct list_head *work_q, 1213 struct list_head *done_q) 1214 { 1215 struct scsi_cmnd *scmd, *chan_scmd, *next; 1216 unsigned int channel; 1217 int rtn; 1218 1219 /* 1220 * we really want to loop over the various channels, and do this on 1221 * a channel by channel basis. we should also check to see if any 1222 * of the failed commands are on soft_reset devices, and if so, skip 1223 * the reset. 1224 */ 1225 1226 for (channel = 0; channel <= shost->max_channel; channel++) { 1227 chan_scmd = NULL; 1228 list_for_each_entry(scmd, work_q, eh_entry) { 1229 if (channel == scmd_channel(scmd)) { 1230 chan_scmd = scmd; 1231 break; 1232 /* 1233 * FIXME add back in some support for 1234 * soft_reset devices. 1235 */ 1236 } 1237 } 1238 1239 if (!chan_scmd) 1240 continue; 1241 SCSI_LOG_ERROR_RECOVERY(3, printk("%s: Sending BRST chan:" 1242 " %d\n", current->comm, 1243 channel)); 1244 rtn = scsi_try_bus_reset(chan_scmd); 1245 if (rtn == SUCCESS || rtn == FAST_IO_FAIL) { 1246 list_for_each_entry_safe(scmd, next, work_q, eh_entry) { 1247 if (channel == scmd_channel(scmd)) 1248 if (!scsi_device_online(scmd->device) || 1249 rtn == FAST_IO_FAIL || 1250 !scsi_eh_tur(scmd)) 1251 scsi_eh_finish_cmd(scmd, 1252 done_q); 1253 } 1254 } else { 1255 SCSI_LOG_ERROR_RECOVERY(3, printk("%s: BRST" 1256 " failed chan: %d\n", 1257 current->comm, 1258 channel)); 1259 } 1260 } 1261 return list_empty(work_q); 1262 } 1263 1264 /** 1265 * scsi_eh_host_reset - send a host reset 1266 * @work_q: list_head for processed commands. 1267 * @done_q: list_head for processed commands. 1268 */ 1269 static int scsi_eh_host_reset(struct list_head *work_q, 1270 struct list_head *done_q) 1271 { 1272 struct scsi_cmnd *scmd, *next; 1273 int rtn; 1274 1275 if (!list_empty(work_q)) { 1276 scmd = list_entry(work_q->next, 1277 struct scsi_cmnd, eh_entry); 1278 1279 SCSI_LOG_ERROR_RECOVERY(3, printk("%s: Sending HRST\n" 1280 , current->comm)); 1281 1282 rtn = scsi_try_host_reset(scmd); 1283 if (rtn == SUCCESS || rtn == FAST_IO_FAIL) { 1284 list_for_each_entry_safe(scmd, next, work_q, eh_entry) { 1285 if (!scsi_device_online(scmd->device) || 1286 rtn == FAST_IO_FAIL || 1287 (!scsi_eh_try_stu(scmd) && !scsi_eh_tur(scmd)) || 1288 !scsi_eh_tur(scmd)) 1289 scsi_eh_finish_cmd(scmd, done_q); 1290 } 1291 } else { 1292 SCSI_LOG_ERROR_RECOVERY(3, printk("%s: HRST" 1293 " failed\n", 1294 current->comm)); 1295 } 1296 } 1297 return list_empty(work_q); 1298 } 1299 1300 /** 1301 * scsi_eh_offline_sdevs - offline scsi devices that fail to recover 1302 * @work_q: list_head for processed commands. 1303 * @done_q: list_head for processed commands. 1304 */ 1305 static void scsi_eh_offline_sdevs(struct list_head *work_q, 1306 struct list_head *done_q) 1307 { 1308 struct scsi_cmnd *scmd, *next; 1309 1310 list_for_each_entry_safe(scmd, next, work_q, eh_entry) { 1311 sdev_printk(KERN_INFO, scmd->device, "Device offlined - " 1312 "not ready after error recovery\n"); 1313 scsi_device_set_state(scmd->device, SDEV_OFFLINE); 1314 if (scmd->eh_eflags & SCSI_EH_CANCEL_CMD) { 1315 /* 1316 * FIXME: Handle lost cmds. 1317 */ 1318 } 1319 scsi_eh_finish_cmd(scmd, done_q); 1320 } 1321 return; 1322 } 1323 1324 /** 1325 * scsi_noretry_cmd - determinte if command should be failed fast 1326 * @scmd: SCSI cmd to examine. 1327 */ 1328 int scsi_noretry_cmd(struct scsi_cmnd *scmd) 1329 { 1330 switch (host_byte(scmd->result)) { 1331 case DID_OK: 1332 break; 1333 case DID_BUS_BUSY: 1334 return (scmd->request->cmd_flags & REQ_FAILFAST_TRANSPORT); 1335 case DID_PARITY: 1336 return (scmd->request->cmd_flags & REQ_FAILFAST_DEV); 1337 case DID_ERROR: 1338 if (msg_byte(scmd->result) == COMMAND_COMPLETE && 1339 status_byte(scmd->result) == RESERVATION_CONFLICT) 1340 return 0; 1341 /* fall through */ 1342 case DID_SOFT_ERROR: 1343 return (scmd->request->cmd_flags & REQ_FAILFAST_DRIVER); 1344 } 1345 1346 switch (status_byte(scmd->result)) { 1347 case CHECK_CONDITION: 1348 /* 1349 * assume caller has checked sense and determinted 1350 * the check condition was retryable. 1351 */ 1352 if (scmd->request->cmd_flags & REQ_FAILFAST_DEV || 1353 scmd->request->cmd_type == REQ_TYPE_BLOCK_PC) 1354 return 1; 1355 } 1356 1357 return 0; 1358 } 1359 1360 /** 1361 * scsi_decide_disposition - Disposition a cmd on return from LLD. 1362 * @scmd: SCSI cmd to examine. 1363 * 1364 * Notes: 1365 * This is *only* called when we are examining the status after sending 1366 * out the actual data command. any commands that are queued for error 1367 * recovery (e.g. test_unit_ready) do *not* come through here. 1368 * 1369 * When this routine returns failed, it means the error handler thread 1370 * is woken. In cases where the error code indicates an error that 1371 * doesn't require the error handler read (i.e. we don't need to 1372 * abort/reset), this function should return SUCCESS. 1373 */ 1374 int scsi_decide_disposition(struct scsi_cmnd *scmd) 1375 { 1376 int rtn; 1377 1378 /* 1379 * if the device is offline, then we clearly just pass the result back 1380 * up to the top level. 1381 */ 1382 if (!scsi_device_online(scmd->device)) { 1383 SCSI_LOG_ERROR_RECOVERY(5, printk("%s: device offline - report" 1384 " as SUCCESS\n", 1385 __func__)); 1386 return SUCCESS; 1387 } 1388 1389 /* 1390 * first check the host byte, to see if there is anything in there 1391 * that would indicate what we need to do. 1392 */ 1393 switch (host_byte(scmd->result)) { 1394 case DID_PASSTHROUGH: 1395 /* 1396 * no matter what, pass this through to the upper layer. 1397 * nuke this special code so that it looks like we are saying 1398 * did_ok. 1399 */ 1400 scmd->result &= 0xff00ffff; 1401 return SUCCESS; 1402 case DID_OK: 1403 /* 1404 * looks good. drop through, and check the next byte. 1405 */ 1406 break; 1407 case DID_NO_CONNECT: 1408 case DID_BAD_TARGET: 1409 case DID_ABORT: 1410 /* 1411 * note - this means that we just report the status back 1412 * to the top level driver, not that we actually think 1413 * that it indicates SUCCESS. 1414 */ 1415 return SUCCESS; 1416 /* 1417 * when the low level driver returns did_soft_error, 1418 * it is responsible for keeping an internal retry counter 1419 * in order to avoid endless loops (db) 1420 * 1421 * actually this is a bug in this function here. we should 1422 * be mindful of the maximum number of retries specified 1423 * and not get stuck in a loop. 1424 */ 1425 case DID_SOFT_ERROR: 1426 goto maybe_retry; 1427 case DID_IMM_RETRY: 1428 return NEEDS_RETRY; 1429 1430 case DID_REQUEUE: 1431 return ADD_TO_MLQUEUE; 1432 case DID_TRANSPORT_DISRUPTED: 1433 /* 1434 * LLD/transport was disrupted during processing of the IO. 1435 * The transport class is now blocked/blocking, 1436 * and the transport will decide what to do with the IO 1437 * based on its timers and recovery capablilities if 1438 * there are enough retries. 1439 */ 1440 goto maybe_retry; 1441 case DID_TRANSPORT_FAILFAST: 1442 /* 1443 * The transport decided to failfast the IO (most likely 1444 * the fast io fail tmo fired), so send IO directly upwards. 1445 */ 1446 return SUCCESS; 1447 case DID_ERROR: 1448 if (msg_byte(scmd->result) == COMMAND_COMPLETE && 1449 status_byte(scmd->result) == RESERVATION_CONFLICT) 1450 /* 1451 * execute reservation conflict processing code 1452 * lower down 1453 */ 1454 break; 1455 /* fallthrough */ 1456 1457 case DID_BUS_BUSY: 1458 case DID_PARITY: 1459 goto maybe_retry; 1460 case DID_TIME_OUT: 1461 /* 1462 * when we scan the bus, we get timeout messages for 1463 * these commands if there is no device available. 1464 * other hosts report did_no_connect for the same thing. 1465 */ 1466 if ((scmd->cmnd[0] == TEST_UNIT_READY || 1467 scmd->cmnd[0] == INQUIRY)) { 1468 return SUCCESS; 1469 } else { 1470 return FAILED; 1471 } 1472 case DID_RESET: 1473 return SUCCESS; 1474 default: 1475 return FAILED; 1476 } 1477 1478 /* 1479 * next, check the message byte. 1480 */ 1481 if (msg_byte(scmd->result) != COMMAND_COMPLETE) 1482 return FAILED; 1483 1484 /* 1485 * check the status byte to see if this indicates anything special. 1486 */ 1487 switch (status_byte(scmd->result)) { 1488 case QUEUE_FULL: 1489 scsi_handle_queue_full(scmd->device); 1490 /* 1491 * the case of trying to send too many commands to a 1492 * tagged queueing device. 1493 */ 1494 case BUSY: 1495 /* 1496 * device can't talk to us at the moment. Should only 1497 * occur (SAM-3) when the task queue is empty, so will cause 1498 * the empty queue handling to trigger a stall in the 1499 * device. 1500 */ 1501 return ADD_TO_MLQUEUE; 1502 case GOOD: 1503 scsi_handle_queue_ramp_up(scmd->device); 1504 case COMMAND_TERMINATED: 1505 return SUCCESS; 1506 case TASK_ABORTED: 1507 goto maybe_retry; 1508 case CHECK_CONDITION: 1509 rtn = scsi_check_sense(scmd); 1510 if (rtn == NEEDS_RETRY) 1511 goto maybe_retry; 1512 /* if rtn == FAILED, we have no sense information; 1513 * returning FAILED will wake the error handler thread 1514 * to collect the sense and redo the decide 1515 * disposition */ 1516 return rtn; 1517 case CONDITION_GOOD: 1518 case INTERMEDIATE_GOOD: 1519 case INTERMEDIATE_C_GOOD: 1520 case ACA_ACTIVE: 1521 /* 1522 * who knows? FIXME(eric) 1523 */ 1524 return SUCCESS; 1525 1526 case RESERVATION_CONFLICT: 1527 sdev_printk(KERN_INFO, scmd->device, 1528 "reservation conflict\n"); 1529 return SUCCESS; /* causes immediate i/o error */ 1530 default: 1531 return FAILED; 1532 } 1533 return FAILED; 1534 1535 maybe_retry: 1536 1537 /* we requeue for retry because the error was retryable, and 1538 * the request was not marked fast fail. Note that above, 1539 * even if the request is marked fast fail, we still requeue 1540 * for queue congestion conditions (QUEUE_FULL or BUSY) */ 1541 if ((++scmd->retries) <= scmd->allowed 1542 && !scsi_noretry_cmd(scmd)) { 1543 return NEEDS_RETRY; 1544 } else { 1545 /* 1546 * no more retries - report this one back to upper level. 1547 */ 1548 return SUCCESS; 1549 } 1550 } 1551 1552 static void eh_lock_door_done(struct request *req, int uptodate) 1553 { 1554 __blk_put_request(req->q, req); 1555 } 1556 1557 /** 1558 * scsi_eh_lock_door - Prevent medium removal for the specified device 1559 * @sdev: SCSI device to prevent medium removal 1560 * 1561 * Locking: 1562 * We must be called from process context. 1563 * 1564 * Notes: 1565 * We queue up an asynchronous "ALLOW MEDIUM REMOVAL" request on the 1566 * head of the devices request queue, and continue. 1567 */ 1568 static void scsi_eh_lock_door(struct scsi_device *sdev) 1569 { 1570 struct request *req; 1571 1572 /* 1573 * blk_get_request with GFP_KERNEL (__GFP_WAIT) sleeps until a 1574 * request becomes available 1575 */ 1576 req = blk_get_request(sdev->request_queue, READ, GFP_KERNEL); 1577 1578 req->cmd[0] = ALLOW_MEDIUM_REMOVAL; 1579 req->cmd[1] = 0; 1580 req->cmd[2] = 0; 1581 req->cmd[3] = 0; 1582 req->cmd[4] = SCSI_REMOVAL_PREVENT; 1583 req->cmd[5] = 0; 1584 1585 req->cmd_len = COMMAND_SIZE(req->cmd[0]); 1586 1587 req->cmd_type = REQ_TYPE_BLOCK_PC; 1588 req->cmd_flags |= REQ_QUIET; 1589 req->timeout = 10 * HZ; 1590 req->retries = 5; 1591 1592 blk_execute_rq_nowait(req->q, NULL, req, 1, eh_lock_door_done); 1593 } 1594 1595 /** 1596 * scsi_restart_operations - restart io operations to the specified host. 1597 * @shost: Host we are restarting. 1598 * 1599 * Notes: 1600 * When we entered the error handler, we blocked all further i/o to 1601 * this device. we need to 'reverse' this process. 1602 */ 1603 static void scsi_restart_operations(struct Scsi_Host *shost) 1604 { 1605 struct scsi_device *sdev; 1606 unsigned long flags; 1607 1608 /* 1609 * If the door was locked, we need to insert a door lock request 1610 * onto the head of the SCSI request queue for the device. There 1611 * is no point trying to lock the door of an off-line device. 1612 */ 1613 shost_for_each_device(sdev, shost) { 1614 if (scsi_device_online(sdev) && sdev->locked) 1615 scsi_eh_lock_door(sdev); 1616 } 1617 1618 /* 1619 * next free up anything directly waiting upon the host. this 1620 * will be requests for character device operations, and also for 1621 * ioctls to queued block devices. 1622 */ 1623 SCSI_LOG_ERROR_RECOVERY(3, printk("%s: waking up host to restart\n", 1624 __func__)); 1625 1626 spin_lock_irqsave(shost->host_lock, flags); 1627 if (scsi_host_set_state(shost, SHOST_RUNNING)) 1628 if (scsi_host_set_state(shost, SHOST_CANCEL)) 1629 BUG_ON(scsi_host_set_state(shost, SHOST_DEL)); 1630 spin_unlock_irqrestore(shost->host_lock, flags); 1631 1632 wake_up(&shost->host_wait); 1633 1634 /* 1635 * finally we need to re-initiate requests that may be pending. we will 1636 * have had everything blocked while error handling is taking place, and 1637 * now that error recovery is done, we will need to ensure that these 1638 * requests are started. 1639 */ 1640 scsi_run_host_queues(shost); 1641 } 1642 1643 /** 1644 * scsi_eh_ready_devs - check device ready state and recover if not. 1645 * @shost: host to be recovered. 1646 * @work_q: &list_head for pending commands. 1647 * @done_q: &list_head for processed commands. 1648 */ 1649 void scsi_eh_ready_devs(struct Scsi_Host *shost, 1650 struct list_head *work_q, 1651 struct list_head *done_q) 1652 { 1653 if (!scsi_eh_stu(shost, work_q, done_q)) 1654 if (!scsi_eh_bus_device_reset(shost, work_q, done_q)) 1655 if (!scsi_eh_target_reset(shost, work_q, done_q)) 1656 if (!scsi_eh_bus_reset(shost, work_q, done_q)) 1657 if (!scsi_eh_host_reset(work_q, done_q)) 1658 scsi_eh_offline_sdevs(work_q, 1659 done_q); 1660 } 1661 EXPORT_SYMBOL_GPL(scsi_eh_ready_devs); 1662 1663 /** 1664 * scsi_eh_flush_done_q - finish processed commands or retry them. 1665 * @done_q: list_head of processed commands. 1666 */ 1667 void scsi_eh_flush_done_q(struct list_head *done_q) 1668 { 1669 struct scsi_cmnd *scmd, *next; 1670 1671 list_for_each_entry_safe(scmd, next, done_q, eh_entry) { 1672 list_del_init(&scmd->eh_entry); 1673 if (scsi_device_online(scmd->device) && 1674 !scsi_noretry_cmd(scmd) && 1675 (++scmd->retries <= scmd->allowed)) { 1676 SCSI_LOG_ERROR_RECOVERY(3, printk("%s: flush" 1677 " retry cmd: %p\n", 1678 current->comm, 1679 scmd)); 1680 scsi_queue_insert(scmd, SCSI_MLQUEUE_EH_RETRY); 1681 } else { 1682 /* 1683 * If just we got sense for the device (called 1684 * scsi_eh_get_sense), scmd->result is already 1685 * set, do not set DRIVER_TIMEOUT. 1686 */ 1687 if (!scmd->result) 1688 scmd->result |= (DRIVER_TIMEOUT << 24); 1689 SCSI_LOG_ERROR_RECOVERY(3, printk("%s: flush finish" 1690 " cmd: %p\n", 1691 current->comm, scmd)); 1692 scsi_finish_command(scmd); 1693 } 1694 } 1695 } 1696 EXPORT_SYMBOL(scsi_eh_flush_done_q); 1697 1698 /** 1699 * scsi_unjam_host - Attempt to fix a host which has a cmd that failed. 1700 * @shost: Host to unjam. 1701 * 1702 * Notes: 1703 * When we come in here, we *know* that all commands on the bus have 1704 * either completed, failed or timed out. we also know that no further 1705 * commands are being sent to the host, so things are relatively quiet 1706 * and we have freedom to fiddle with things as we wish. 1707 * 1708 * This is only the *default* implementation. it is possible for 1709 * individual drivers to supply their own version of this function, and 1710 * if the maintainer wishes to do this, it is strongly suggested that 1711 * this function be taken as a template and modified. this function 1712 * was designed to correctly handle problems for about 95% of the 1713 * different cases out there, and it should always provide at least a 1714 * reasonable amount of error recovery. 1715 * 1716 * Any command marked 'failed' or 'timeout' must eventually have 1717 * scsi_finish_cmd() called for it. we do all of the retry stuff 1718 * here, so when we restart the host after we return it should have an 1719 * empty queue. 1720 */ 1721 static void scsi_unjam_host(struct Scsi_Host *shost) 1722 { 1723 unsigned long flags; 1724 LIST_HEAD(eh_work_q); 1725 LIST_HEAD(eh_done_q); 1726 1727 spin_lock_irqsave(shost->host_lock, flags); 1728 list_splice_init(&shost->eh_cmd_q, &eh_work_q); 1729 spin_unlock_irqrestore(shost->host_lock, flags); 1730 1731 SCSI_LOG_ERROR_RECOVERY(1, scsi_eh_prt_fail_stats(shost, &eh_work_q)); 1732 1733 if (!scsi_eh_get_sense(&eh_work_q, &eh_done_q)) 1734 if (!scsi_eh_abort_cmds(&eh_work_q, &eh_done_q)) 1735 scsi_eh_ready_devs(shost, &eh_work_q, &eh_done_q); 1736 1737 scsi_eh_flush_done_q(&eh_done_q); 1738 } 1739 1740 /** 1741 * scsi_error_handler - SCSI error handler thread 1742 * @data: Host for which we are running. 1743 * 1744 * Notes: 1745 * This is the main error handling loop. This is run as a kernel thread 1746 * for every SCSI host and handles all error handling activity. 1747 */ 1748 int scsi_error_handler(void *data) 1749 { 1750 struct Scsi_Host *shost = data; 1751 1752 /* 1753 * We use TASK_INTERRUPTIBLE so that the thread is not 1754 * counted against the load average as a running process. 1755 * We never actually get interrupted because kthread_run 1756 * disables signal delivery for the created thread. 1757 */ 1758 set_current_state(TASK_INTERRUPTIBLE); 1759 while (!kthread_should_stop()) { 1760 if ((shost->host_failed == 0 && shost->host_eh_scheduled == 0) || 1761 shost->host_failed != shost->host_busy) { 1762 SCSI_LOG_ERROR_RECOVERY(1, 1763 printk("Error handler scsi_eh_%d sleeping\n", 1764 shost->host_no)); 1765 schedule(); 1766 set_current_state(TASK_INTERRUPTIBLE); 1767 continue; 1768 } 1769 1770 __set_current_state(TASK_RUNNING); 1771 SCSI_LOG_ERROR_RECOVERY(1, 1772 printk("Error handler scsi_eh_%d waking up\n", 1773 shost->host_no)); 1774 1775 /* 1776 * We have a host that is failing for some reason. Figure out 1777 * what we need to do to get it up and online again (if we can). 1778 * If we fail, we end up taking the thing offline. 1779 */ 1780 if (scsi_autopm_get_host(shost) != 0) { 1781 SCSI_LOG_ERROR_RECOVERY(1, 1782 printk(KERN_ERR "Error handler scsi_eh_%d " 1783 "unable to autoresume\n", 1784 shost->host_no)); 1785 continue; 1786 } 1787 1788 if (shost->transportt->eh_strategy_handler) 1789 shost->transportt->eh_strategy_handler(shost); 1790 else 1791 scsi_unjam_host(shost); 1792 1793 /* 1794 * Note - if the above fails completely, the action is to take 1795 * individual devices offline and flush the queue of any 1796 * outstanding requests that may have been pending. When we 1797 * restart, we restart any I/O to any other devices on the bus 1798 * which are still online. 1799 */ 1800 scsi_restart_operations(shost); 1801 scsi_autopm_put_host(shost); 1802 set_current_state(TASK_INTERRUPTIBLE); 1803 } 1804 __set_current_state(TASK_RUNNING); 1805 1806 SCSI_LOG_ERROR_RECOVERY(1, 1807 printk("Error handler scsi_eh_%d exiting\n", shost->host_no)); 1808 shost->ehandler = NULL; 1809 return 0; 1810 } 1811 1812 /* 1813 * Function: scsi_report_bus_reset() 1814 * 1815 * Purpose: Utility function used by low-level drivers to report that 1816 * they have observed a bus reset on the bus being handled. 1817 * 1818 * Arguments: shost - Host in question 1819 * channel - channel on which reset was observed. 1820 * 1821 * Returns: Nothing 1822 * 1823 * Lock status: Host lock must be held. 1824 * 1825 * Notes: This only needs to be called if the reset is one which 1826 * originates from an unknown location. Resets originated 1827 * by the mid-level itself don't need to call this, but there 1828 * should be no harm. 1829 * 1830 * The main purpose of this is to make sure that a CHECK_CONDITION 1831 * is properly treated. 1832 */ 1833 void scsi_report_bus_reset(struct Scsi_Host *shost, int channel) 1834 { 1835 struct scsi_device *sdev; 1836 1837 __shost_for_each_device(sdev, shost) { 1838 if (channel == sdev_channel(sdev)) 1839 __scsi_report_device_reset(sdev, NULL); 1840 } 1841 } 1842 EXPORT_SYMBOL(scsi_report_bus_reset); 1843 1844 /* 1845 * Function: scsi_report_device_reset() 1846 * 1847 * Purpose: Utility function used by low-level drivers to report that 1848 * they have observed a device reset on the device being handled. 1849 * 1850 * Arguments: shost - Host in question 1851 * channel - channel on which reset was observed 1852 * target - target on which reset was observed 1853 * 1854 * Returns: Nothing 1855 * 1856 * Lock status: Host lock must be held 1857 * 1858 * Notes: This only needs to be called if the reset is one which 1859 * originates from an unknown location. Resets originated 1860 * by the mid-level itself don't need to call this, but there 1861 * should be no harm. 1862 * 1863 * The main purpose of this is to make sure that a CHECK_CONDITION 1864 * is properly treated. 1865 */ 1866 void scsi_report_device_reset(struct Scsi_Host *shost, int channel, int target) 1867 { 1868 struct scsi_device *sdev; 1869 1870 __shost_for_each_device(sdev, shost) { 1871 if (channel == sdev_channel(sdev) && 1872 target == sdev_id(sdev)) 1873 __scsi_report_device_reset(sdev, NULL); 1874 } 1875 } 1876 EXPORT_SYMBOL(scsi_report_device_reset); 1877 1878 static void 1879 scsi_reset_provider_done_command(struct scsi_cmnd *scmd) 1880 { 1881 } 1882 1883 /* 1884 * Function: scsi_reset_provider 1885 * 1886 * Purpose: Send requested reset to a bus or device at any phase. 1887 * 1888 * Arguments: device - device to send reset to 1889 * flag - reset type (see scsi.h) 1890 * 1891 * Returns: SUCCESS/FAILURE. 1892 * 1893 * Notes: This is used by the SCSI Generic driver to provide 1894 * Bus/Device reset capability. 1895 */ 1896 int 1897 scsi_reset_provider(struct scsi_device *dev, int flag) 1898 { 1899 struct scsi_cmnd *scmd; 1900 struct Scsi_Host *shost = dev->host; 1901 struct request req; 1902 unsigned long flags; 1903 int rtn; 1904 1905 if (scsi_autopm_get_host(shost) < 0) 1906 return FAILED; 1907 1908 scmd = scsi_get_command(dev, GFP_KERNEL); 1909 blk_rq_init(NULL, &req); 1910 scmd->request = &req; 1911 1912 scmd->cmnd = req.cmd; 1913 1914 scmd->scsi_done = scsi_reset_provider_done_command; 1915 memset(&scmd->sdb, 0, sizeof(scmd->sdb)); 1916 1917 scmd->cmd_len = 0; 1918 1919 scmd->sc_data_direction = DMA_BIDIRECTIONAL; 1920 1921 spin_lock_irqsave(shost->host_lock, flags); 1922 shost->tmf_in_progress = 1; 1923 spin_unlock_irqrestore(shost->host_lock, flags); 1924 1925 switch (flag) { 1926 case SCSI_TRY_RESET_DEVICE: 1927 rtn = scsi_try_bus_device_reset(scmd); 1928 if (rtn == SUCCESS) 1929 break; 1930 /* FALLTHROUGH */ 1931 case SCSI_TRY_RESET_TARGET: 1932 rtn = scsi_try_target_reset(scmd); 1933 if (rtn == SUCCESS) 1934 break; 1935 /* FALLTHROUGH */ 1936 case SCSI_TRY_RESET_BUS: 1937 rtn = scsi_try_bus_reset(scmd); 1938 if (rtn == SUCCESS) 1939 break; 1940 /* FALLTHROUGH */ 1941 case SCSI_TRY_RESET_HOST: 1942 rtn = scsi_try_host_reset(scmd); 1943 break; 1944 default: 1945 rtn = FAILED; 1946 } 1947 1948 spin_lock_irqsave(shost->host_lock, flags); 1949 shost->tmf_in_progress = 0; 1950 spin_unlock_irqrestore(shost->host_lock, flags); 1951 1952 /* 1953 * be sure to wake up anyone who was sleeping or had their queue 1954 * suspended while we performed the TMF. 1955 */ 1956 SCSI_LOG_ERROR_RECOVERY(3, 1957 printk("%s: waking up host to restart after TMF\n", 1958 __func__)); 1959 1960 wake_up(&shost->host_wait); 1961 1962 scsi_run_host_queues(shost); 1963 1964 scsi_next_command(scmd); 1965 scsi_autopm_put_host(shost); 1966 return rtn; 1967 } 1968 EXPORT_SYMBOL(scsi_reset_provider); 1969 1970 /** 1971 * scsi_normalize_sense - normalize main elements from either fixed or 1972 * descriptor sense data format into a common format. 1973 * 1974 * @sense_buffer: byte array containing sense data returned by device 1975 * @sb_len: number of valid bytes in sense_buffer 1976 * @sshdr: pointer to instance of structure that common 1977 * elements are written to. 1978 * 1979 * Notes: 1980 * The "main elements" from sense data are: response_code, sense_key, 1981 * asc, ascq and additional_length (only for descriptor format). 1982 * 1983 * Typically this function can be called after a device has 1984 * responded to a SCSI command with the CHECK_CONDITION status. 1985 * 1986 * Return value: 1987 * 1 if valid sense data information found, else 0; 1988 */ 1989 int scsi_normalize_sense(const u8 *sense_buffer, int sb_len, 1990 struct scsi_sense_hdr *sshdr) 1991 { 1992 if (!sense_buffer || !sb_len) 1993 return 0; 1994 1995 memset(sshdr, 0, sizeof(struct scsi_sense_hdr)); 1996 1997 sshdr->response_code = (sense_buffer[0] & 0x7f); 1998 1999 if (!scsi_sense_valid(sshdr)) 2000 return 0; 2001 2002 if (sshdr->response_code >= 0x72) { 2003 /* 2004 * descriptor format 2005 */ 2006 if (sb_len > 1) 2007 sshdr->sense_key = (sense_buffer[1] & 0xf); 2008 if (sb_len > 2) 2009 sshdr->asc = sense_buffer[2]; 2010 if (sb_len > 3) 2011 sshdr->ascq = sense_buffer[3]; 2012 if (sb_len > 7) 2013 sshdr->additional_length = sense_buffer[7]; 2014 } else { 2015 /* 2016 * fixed format 2017 */ 2018 if (sb_len > 2) 2019 sshdr->sense_key = (sense_buffer[2] & 0xf); 2020 if (sb_len > 7) { 2021 sb_len = (sb_len < (sense_buffer[7] + 8)) ? 2022 sb_len : (sense_buffer[7] + 8); 2023 if (sb_len > 12) 2024 sshdr->asc = sense_buffer[12]; 2025 if (sb_len > 13) 2026 sshdr->ascq = sense_buffer[13]; 2027 } 2028 } 2029 2030 return 1; 2031 } 2032 EXPORT_SYMBOL(scsi_normalize_sense); 2033 2034 int scsi_command_normalize_sense(struct scsi_cmnd *cmd, 2035 struct scsi_sense_hdr *sshdr) 2036 { 2037 return scsi_normalize_sense(cmd->sense_buffer, 2038 SCSI_SENSE_BUFFERSIZE, sshdr); 2039 } 2040 EXPORT_SYMBOL(scsi_command_normalize_sense); 2041 2042 /** 2043 * scsi_sense_desc_find - search for a given descriptor type in descriptor sense data format. 2044 * @sense_buffer: byte array of descriptor format sense data 2045 * @sb_len: number of valid bytes in sense_buffer 2046 * @desc_type: value of descriptor type to find 2047 * (e.g. 0 -> information) 2048 * 2049 * Notes: 2050 * only valid when sense data is in descriptor format 2051 * 2052 * Return value: 2053 * pointer to start of (first) descriptor if found else NULL 2054 */ 2055 const u8 * scsi_sense_desc_find(const u8 * sense_buffer, int sb_len, 2056 int desc_type) 2057 { 2058 int add_sen_len, add_len, desc_len, k; 2059 const u8 * descp; 2060 2061 if ((sb_len < 8) || (0 == (add_sen_len = sense_buffer[7]))) 2062 return NULL; 2063 if ((sense_buffer[0] < 0x72) || (sense_buffer[0] > 0x73)) 2064 return NULL; 2065 add_sen_len = (add_sen_len < (sb_len - 8)) ? 2066 add_sen_len : (sb_len - 8); 2067 descp = &sense_buffer[8]; 2068 for (desc_len = 0, k = 0; k < add_sen_len; k += desc_len) { 2069 descp += desc_len; 2070 add_len = (k < (add_sen_len - 1)) ? descp[1]: -1; 2071 desc_len = add_len + 2; 2072 if (descp[0] == desc_type) 2073 return descp; 2074 if (add_len < 0) // short descriptor ?? 2075 break; 2076 } 2077 return NULL; 2078 } 2079 EXPORT_SYMBOL(scsi_sense_desc_find); 2080 2081 /** 2082 * scsi_get_sense_info_fld - get information field from sense data (either fixed or descriptor format) 2083 * @sense_buffer: byte array of sense data 2084 * @sb_len: number of valid bytes in sense_buffer 2085 * @info_out: pointer to 64 integer where 8 or 4 byte information 2086 * field will be placed if found. 2087 * 2088 * Return value: 2089 * 1 if information field found, 0 if not found. 2090 */ 2091 int scsi_get_sense_info_fld(const u8 * sense_buffer, int sb_len, 2092 u64 * info_out) 2093 { 2094 int j; 2095 const u8 * ucp; 2096 u64 ull; 2097 2098 if (sb_len < 7) 2099 return 0; 2100 switch (sense_buffer[0] & 0x7f) { 2101 case 0x70: 2102 case 0x71: 2103 if (sense_buffer[0] & 0x80) { 2104 *info_out = (sense_buffer[3] << 24) + 2105 (sense_buffer[4] << 16) + 2106 (sense_buffer[5] << 8) + sense_buffer[6]; 2107 return 1; 2108 } else 2109 return 0; 2110 case 0x72: 2111 case 0x73: 2112 ucp = scsi_sense_desc_find(sense_buffer, sb_len, 2113 0 /* info desc */); 2114 if (ucp && (0xa == ucp[1])) { 2115 ull = 0; 2116 for (j = 0; j < 8; ++j) { 2117 if (j > 0) 2118 ull <<= 8; 2119 ull |= ucp[4 + j]; 2120 } 2121 *info_out = ull; 2122 return 1; 2123 } else 2124 return 0; 2125 default: 2126 return 0; 2127 } 2128 } 2129 EXPORT_SYMBOL(scsi_get_sense_info_fld); 2130 2131 /** 2132 * scsi_build_sense_buffer - build sense data in a buffer 2133 * @desc: Sense format (non zero == descriptor format, 2134 * 0 == fixed format) 2135 * @buf: Where to build sense data 2136 * @key: Sense key 2137 * @asc: Additional sense code 2138 * @ascq: Additional sense code qualifier 2139 * 2140 **/ 2141 void scsi_build_sense_buffer(int desc, u8 *buf, u8 key, u8 asc, u8 ascq) 2142 { 2143 if (desc) { 2144 buf[0] = 0x72; /* descriptor, current */ 2145 buf[1] = key; 2146 buf[2] = asc; 2147 buf[3] = ascq; 2148 buf[7] = 0; 2149 } else { 2150 buf[0] = 0x70; /* fixed, current */ 2151 buf[2] = key; 2152 buf[7] = 0xa; 2153 buf[12] = asc; 2154 buf[13] = ascq; 2155 } 2156 } 2157 EXPORT_SYMBOL(scsi_build_sense_buffer); 2158