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 (blk_barrier_rq(scmd->request)) 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 blk_failfast_transport(scmd->request); 1335 case DID_PARITY: 1336 return blk_failfast_dev(scmd->request); 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 blk_failfast_driver(scmd->request); 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 return blk_failfast_dev(scmd->request); 1353 } 1354 1355 return 0; 1356 } 1357 1358 /** 1359 * scsi_decide_disposition - Disposition a cmd on return from LLD. 1360 * @scmd: SCSI cmd to examine. 1361 * 1362 * Notes: 1363 * This is *only* called when we are examining the status after sending 1364 * out the actual data command. any commands that are queued for error 1365 * recovery (e.g. test_unit_ready) do *not* come through here. 1366 * 1367 * When this routine returns failed, it means the error handler thread 1368 * is woken. In cases where the error code indicates an error that 1369 * doesn't require the error handler read (i.e. we don't need to 1370 * abort/reset), this function should return SUCCESS. 1371 */ 1372 int scsi_decide_disposition(struct scsi_cmnd *scmd) 1373 { 1374 int rtn; 1375 1376 /* 1377 * if the device is offline, then we clearly just pass the result back 1378 * up to the top level. 1379 */ 1380 if (!scsi_device_online(scmd->device)) { 1381 SCSI_LOG_ERROR_RECOVERY(5, printk("%s: device offline - report" 1382 " as SUCCESS\n", 1383 __func__)); 1384 return SUCCESS; 1385 } 1386 1387 /* 1388 * first check the host byte, to see if there is anything in there 1389 * that would indicate what we need to do. 1390 */ 1391 switch (host_byte(scmd->result)) { 1392 case DID_PASSTHROUGH: 1393 /* 1394 * no matter what, pass this through to the upper layer. 1395 * nuke this special code so that it looks like we are saying 1396 * did_ok. 1397 */ 1398 scmd->result &= 0xff00ffff; 1399 return SUCCESS; 1400 case DID_OK: 1401 /* 1402 * looks good. drop through, and check the next byte. 1403 */ 1404 break; 1405 case DID_NO_CONNECT: 1406 case DID_BAD_TARGET: 1407 case DID_ABORT: 1408 /* 1409 * note - this means that we just report the status back 1410 * to the top level driver, not that we actually think 1411 * that it indicates SUCCESS. 1412 */ 1413 return SUCCESS; 1414 /* 1415 * when the low level driver returns did_soft_error, 1416 * it is responsible for keeping an internal retry counter 1417 * in order to avoid endless loops (db) 1418 * 1419 * actually this is a bug in this function here. we should 1420 * be mindful of the maximum number of retries specified 1421 * and not get stuck in a loop. 1422 */ 1423 case DID_SOFT_ERROR: 1424 goto maybe_retry; 1425 case DID_IMM_RETRY: 1426 return NEEDS_RETRY; 1427 1428 case DID_REQUEUE: 1429 return ADD_TO_MLQUEUE; 1430 case DID_TRANSPORT_DISRUPTED: 1431 /* 1432 * LLD/transport was disrupted during processing of the IO. 1433 * The transport class is now blocked/blocking, 1434 * and the transport will decide what to do with the IO 1435 * based on its timers and recovery capablilities if 1436 * there are enough retries. 1437 */ 1438 goto maybe_retry; 1439 case DID_TRANSPORT_FAILFAST: 1440 /* 1441 * The transport decided to failfast the IO (most likely 1442 * the fast io fail tmo fired), so send IO directly upwards. 1443 */ 1444 return SUCCESS; 1445 case DID_ERROR: 1446 if (msg_byte(scmd->result) == COMMAND_COMPLETE && 1447 status_byte(scmd->result) == RESERVATION_CONFLICT) 1448 /* 1449 * execute reservation conflict processing code 1450 * lower down 1451 */ 1452 break; 1453 /* fallthrough */ 1454 1455 case DID_BUS_BUSY: 1456 case DID_PARITY: 1457 goto maybe_retry; 1458 case DID_TIME_OUT: 1459 /* 1460 * when we scan the bus, we get timeout messages for 1461 * these commands if there is no device available. 1462 * other hosts report did_no_connect for the same thing. 1463 */ 1464 if ((scmd->cmnd[0] == TEST_UNIT_READY || 1465 scmd->cmnd[0] == INQUIRY)) { 1466 return SUCCESS; 1467 } else { 1468 return FAILED; 1469 } 1470 case DID_RESET: 1471 return SUCCESS; 1472 default: 1473 return FAILED; 1474 } 1475 1476 /* 1477 * next, check the message byte. 1478 */ 1479 if (msg_byte(scmd->result) != COMMAND_COMPLETE) 1480 return FAILED; 1481 1482 /* 1483 * check the status byte to see if this indicates anything special. 1484 */ 1485 switch (status_byte(scmd->result)) { 1486 case QUEUE_FULL: 1487 scsi_handle_queue_full(scmd->device); 1488 /* 1489 * the case of trying to send too many commands to a 1490 * tagged queueing device. 1491 */ 1492 case BUSY: 1493 /* 1494 * device can't talk to us at the moment. Should only 1495 * occur (SAM-3) when the task queue is empty, so will cause 1496 * the empty queue handling to trigger a stall in the 1497 * device. 1498 */ 1499 return ADD_TO_MLQUEUE; 1500 case GOOD: 1501 scsi_handle_queue_ramp_up(scmd->device); 1502 case COMMAND_TERMINATED: 1503 return SUCCESS; 1504 case TASK_ABORTED: 1505 goto maybe_retry; 1506 case CHECK_CONDITION: 1507 rtn = scsi_check_sense(scmd); 1508 if (rtn == NEEDS_RETRY) 1509 goto maybe_retry; 1510 /* if rtn == FAILED, we have no sense information; 1511 * returning FAILED will wake the error handler thread 1512 * to collect the sense and redo the decide 1513 * disposition */ 1514 return rtn; 1515 case CONDITION_GOOD: 1516 case INTERMEDIATE_GOOD: 1517 case INTERMEDIATE_C_GOOD: 1518 case ACA_ACTIVE: 1519 /* 1520 * who knows? FIXME(eric) 1521 */ 1522 return SUCCESS; 1523 1524 case RESERVATION_CONFLICT: 1525 sdev_printk(KERN_INFO, scmd->device, 1526 "reservation conflict\n"); 1527 return SUCCESS; /* causes immediate i/o error */ 1528 default: 1529 return FAILED; 1530 } 1531 return FAILED; 1532 1533 maybe_retry: 1534 1535 /* we requeue for retry because the error was retryable, and 1536 * the request was not marked fast fail. Note that above, 1537 * even if the request is marked fast fail, we still requeue 1538 * for queue congestion conditions (QUEUE_FULL or BUSY) */ 1539 if ((++scmd->retries) <= scmd->allowed 1540 && !scsi_noretry_cmd(scmd)) { 1541 return NEEDS_RETRY; 1542 } else { 1543 /* 1544 * no more retries - report this one back to upper level. 1545 */ 1546 return SUCCESS; 1547 } 1548 } 1549 1550 static void eh_lock_door_done(struct request *req, int uptodate) 1551 { 1552 __blk_put_request(req->q, req); 1553 } 1554 1555 /** 1556 * scsi_eh_lock_door - Prevent medium removal for the specified device 1557 * @sdev: SCSI device to prevent medium removal 1558 * 1559 * Locking: 1560 * We must be called from process context. 1561 * 1562 * Notes: 1563 * We queue up an asynchronous "ALLOW MEDIUM REMOVAL" request on the 1564 * head of the devices request queue, and continue. 1565 */ 1566 static void scsi_eh_lock_door(struct scsi_device *sdev) 1567 { 1568 struct request *req; 1569 1570 /* 1571 * blk_get_request with GFP_KERNEL (__GFP_WAIT) sleeps until a 1572 * request becomes available 1573 */ 1574 req = blk_get_request(sdev->request_queue, READ, GFP_KERNEL); 1575 1576 req->cmd[0] = ALLOW_MEDIUM_REMOVAL; 1577 req->cmd[1] = 0; 1578 req->cmd[2] = 0; 1579 req->cmd[3] = 0; 1580 req->cmd[4] = SCSI_REMOVAL_PREVENT; 1581 req->cmd[5] = 0; 1582 1583 req->cmd_len = COMMAND_SIZE(req->cmd[0]); 1584 1585 req->cmd_type = REQ_TYPE_BLOCK_PC; 1586 req->cmd_flags |= REQ_QUIET; 1587 req->timeout = 10 * HZ; 1588 req->retries = 5; 1589 1590 blk_execute_rq_nowait(req->q, NULL, req, 1, eh_lock_door_done); 1591 } 1592 1593 /** 1594 * scsi_restart_operations - restart io operations to the specified host. 1595 * @shost: Host we are restarting. 1596 * 1597 * Notes: 1598 * When we entered the error handler, we blocked all further i/o to 1599 * this device. we need to 'reverse' this process. 1600 */ 1601 static void scsi_restart_operations(struct Scsi_Host *shost) 1602 { 1603 struct scsi_device *sdev; 1604 unsigned long flags; 1605 1606 /* 1607 * If the door was locked, we need to insert a door lock request 1608 * onto the head of the SCSI request queue for the device. There 1609 * is no point trying to lock the door of an off-line device. 1610 */ 1611 shost_for_each_device(sdev, shost) { 1612 if (scsi_device_online(sdev) && sdev->locked) 1613 scsi_eh_lock_door(sdev); 1614 } 1615 1616 /* 1617 * next free up anything directly waiting upon the host. this 1618 * will be requests for character device operations, and also for 1619 * ioctls to queued block devices. 1620 */ 1621 SCSI_LOG_ERROR_RECOVERY(3, printk("%s: waking up host to restart\n", 1622 __func__)); 1623 1624 spin_lock_irqsave(shost->host_lock, flags); 1625 if (scsi_host_set_state(shost, SHOST_RUNNING)) 1626 if (scsi_host_set_state(shost, SHOST_CANCEL)) 1627 BUG_ON(scsi_host_set_state(shost, SHOST_DEL)); 1628 spin_unlock_irqrestore(shost->host_lock, flags); 1629 1630 wake_up(&shost->host_wait); 1631 1632 /* 1633 * finally we need to re-initiate requests that may be pending. we will 1634 * have had everything blocked while error handling is taking place, and 1635 * now that error recovery is done, we will need to ensure that these 1636 * requests are started. 1637 */ 1638 scsi_run_host_queues(shost); 1639 } 1640 1641 /** 1642 * scsi_eh_ready_devs - check device ready state and recover if not. 1643 * @shost: host to be recovered. 1644 * @work_q: &list_head for pending commands. 1645 * @done_q: &list_head for processed commands. 1646 */ 1647 void scsi_eh_ready_devs(struct Scsi_Host *shost, 1648 struct list_head *work_q, 1649 struct list_head *done_q) 1650 { 1651 if (!scsi_eh_stu(shost, work_q, done_q)) 1652 if (!scsi_eh_bus_device_reset(shost, work_q, done_q)) 1653 if (!scsi_eh_target_reset(shost, work_q, done_q)) 1654 if (!scsi_eh_bus_reset(shost, work_q, done_q)) 1655 if (!scsi_eh_host_reset(work_q, done_q)) 1656 scsi_eh_offline_sdevs(work_q, 1657 done_q); 1658 } 1659 EXPORT_SYMBOL_GPL(scsi_eh_ready_devs); 1660 1661 /** 1662 * scsi_eh_flush_done_q - finish processed commands or retry them. 1663 * @done_q: list_head of processed commands. 1664 */ 1665 void scsi_eh_flush_done_q(struct list_head *done_q) 1666 { 1667 struct scsi_cmnd *scmd, *next; 1668 1669 list_for_each_entry_safe(scmd, next, done_q, eh_entry) { 1670 list_del_init(&scmd->eh_entry); 1671 if (scsi_device_online(scmd->device) && 1672 !scsi_noretry_cmd(scmd) && 1673 (++scmd->retries <= scmd->allowed)) { 1674 SCSI_LOG_ERROR_RECOVERY(3, printk("%s: flush" 1675 " retry cmd: %p\n", 1676 current->comm, 1677 scmd)); 1678 scsi_queue_insert(scmd, SCSI_MLQUEUE_EH_RETRY); 1679 } else { 1680 /* 1681 * If just we got sense for the device (called 1682 * scsi_eh_get_sense), scmd->result is already 1683 * set, do not set DRIVER_TIMEOUT. 1684 */ 1685 if (!scmd->result) 1686 scmd->result |= (DRIVER_TIMEOUT << 24); 1687 SCSI_LOG_ERROR_RECOVERY(3, printk("%s: flush finish" 1688 " cmd: %p\n", 1689 current->comm, scmd)); 1690 scsi_finish_command(scmd); 1691 } 1692 } 1693 } 1694 EXPORT_SYMBOL(scsi_eh_flush_done_q); 1695 1696 /** 1697 * scsi_unjam_host - Attempt to fix a host which has a cmd that failed. 1698 * @shost: Host to unjam. 1699 * 1700 * Notes: 1701 * When we come in here, we *know* that all commands on the bus have 1702 * either completed, failed or timed out. we also know that no further 1703 * commands are being sent to the host, so things are relatively quiet 1704 * and we have freedom to fiddle with things as we wish. 1705 * 1706 * This is only the *default* implementation. it is possible for 1707 * individual drivers to supply their own version of this function, and 1708 * if the maintainer wishes to do this, it is strongly suggested that 1709 * this function be taken as a template and modified. this function 1710 * was designed to correctly handle problems for about 95% of the 1711 * different cases out there, and it should always provide at least a 1712 * reasonable amount of error recovery. 1713 * 1714 * Any command marked 'failed' or 'timeout' must eventually have 1715 * scsi_finish_cmd() called for it. we do all of the retry stuff 1716 * here, so when we restart the host after we return it should have an 1717 * empty queue. 1718 */ 1719 static void scsi_unjam_host(struct Scsi_Host *shost) 1720 { 1721 unsigned long flags; 1722 LIST_HEAD(eh_work_q); 1723 LIST_HEAD(eh_done_q); 1724 1725 spin_lock_irqsave(shost->host_lock, flags); 1726 list_splice_init(&shost->eh_cmd_q, &eh_work_q); 1727 spin_unlock_irqrestore(shost->host_lock, flags); 1728 1729 SCSI_LOG_ERROR_RECOVERY(1, scsi_eh_prt_fail_stats(shost, &eh_work_q)); 1730 1731 if (!scsi_eh_get_sense(&eh_work_q, &eh_done_q)) 1732 if (!scsi_eh_abort_cmds(&eh_work_q, &eh_done_q)) 1733 scsi_eh_ready_devs(shost, &eh_work_q, &eh_done_q); 1734 1735 scsi_eh_flush_done_q(&eh_done_q); 1736 } 1737 1738 /** 1739 * scsi_error_handler - SCSI error handler thread 1740 * @data: Host for which we are running. 1741 * 1742 * Notes: 1743 * This is the main error handling loop. This is run as a kernel thread 1744 * for every SCSI host and handles all error handling activity. 1745 */ 1746 int scsi_error_handler(void *data) 1747 { 1748 struct Scsi_Host *shost = data; 1749 1750 /* 1751 * We use TASK_INTERRUPTIBLE so that the thread is not 1752 * counted against the load average as a running process. 1753 * We never actually get interrupted because kthread_run 1754 * disables signal delivery for the created thread. 1755 */ 1756 set_current_state(TASK_INTERRUPTIBLE); 1757 while (!kthread_should_stop()) { 1758 if ((shost->host_failed == 0 && shost->host_eh_scheduled == 0) || 1759 shost->host_failed != shost->host_busy) { 1760 SCSI_LOG_ERROR_RECOVERY(1, 1761 printk("Error handler scsi_eh_%d sleeping\n", 1762 shost->host_no)); 1763 schedule(); 1764 set_current_state(TASK_INTERRUPTIBLE); 1765 continue; 1766 } 1767 1768 __set_current_state(TASK_RUNNING); 1769 SCSI_LOG_ERROR_RECOVERY(1, 1770 printk("Error handler scsi_eh_%d waking up\n", 1771 shost->host_no)); 1772 1773 /* 1774 * We have a host that is failing for some reason. Figure out 1775 * what we need to do to get it up and online again (if we can). 1776 * If we fail, we end up taking the thing offline. 1777 */ 1778 if (scsi_autopm_get_host(shost) != 0) { 1779 SCSI_LOG_ERROR_RECOVERY(1, 1780 printk(KERN_ERR "Error handler scsi_eh_%d " 1781 "unable to autoresume\n", 1782 shost->host_no)); 1783 continue; 1784 } 1785 1786 if (shost->transportt->eh_strategy_handler) 1787 shost->transportt->eh_strategy_handler(shost); 1788 else 1789 scsi_unjam_host(shost); 1790 1791 /* 1792 * Note - if the above fails completely, the action is to take 1793 * individual devices offline and flush the queue of any 1794 * outstanding requests that may have been pending. When we 1795 * restart, we restart any I/O to any other devices on the bus 1796 * which are still online. 1797 */ 1798 scsi_restart_operations(shost); 1799 scsi_autopm_put_host(shost); 1800 set_current_state(TASK_INTERRUPTIBLE); 1801 } 1802 __set_current_state(TASK_RUNNING); 1803 1804 SCSI_LOG_ERROR_RECOVERY(1, 1805 printk("Error handler scsi_eh_%d exiting\n", shost->host_no)); 1806 shost->ehandler = NULL; 1807 return 0; 1808 } 1809 1810 /* 1811 * Function: scsi_report_bus_reset() 1812 * 1813 * Purpose: Utility function used by low-level drivers to report that 1814 * they have observed a bus reset on the bus being handled. 1815 * 1816 * Arguments: shost - Host in question 1817 * channel - channel on which reset was observed. 1818 * 1819 * Returns: Nothing 1820 * 1821 * Lock status: Host lock must be held. 1822 * 1823 * Notes: This only needs to be called if the reset is one which 1824 * originates from an unknown location. Resets originated 1825 * by the mid-level itself don't need to call this, but there 1826 * should be no harm. 1827 * 1828 * The main purpose of this is to make sure that a CHECK_CONDITION 1829 * is properly treated. 1830 */ 1831 void scsi_report_bus_reset(struct Scsi_Host *shost, int channel) 1832 { 1833 struct scsi_device *sdev; 1834 1835 __shost_for_each_device(sdev, shost) { 1836 if (channel == sdev_channel(sdev)) 1837 __scsi_report_device_reset(sdev, NULL); 1838 } 1839 } 1840 EXPORT_SYMBOL(scsi_report_bus_reset); 1841 1842 /* 1843 * Function: scsi_report_device_reset() 1844 * 1845 * Purpose: Utility function used by low-level drivers to report that 1846 * they have observed a device reset on the device being handled. 1847 * 1848 * Arguments: shost - Host in question 1849 * channel - channel on which reset was observed 1850 * target - target on which reset was observed 1851 * 1852 * Returns: Nothing 1853 * 1854 * Lock status: Host lock must be held 1855 * 1856 * Notes: This only needs to be called if the reset is one which 1857 * originates from an unknown location. Resets originated 1858 * by the mid-level itself don't need to call this, but there 1859 * should be no harm. 1860 * 1861 * The main purpose of this is to make sure that a CHECK_CONDITION 1862 * is properly treated. 1863 */ 1864 void scsi_report_device_reset(struct Scsi_Host *shost, int channel, int target) 1865 { 1866 struct scsi_device *sdev; 1867 1868 __shost_for_each_device(sdev, shost) { 1869 if (channel == sdev_channel(sdev) && 1870 target == sdev_id(sdev)) 1871 __scsi_report_device_reset(sdev, NULL); 1872 } 1873 } 1874 EXPORT_SYMBOL(scsi_report_device_reset); 1875 1876 static void 1877 scsi_reset_provider_done_command(struct scsi_cmnd *scmd) 1878 { 1879 } 1880 1881 /* 1882 * Function: scsi_reset_provider 1883 * 1884 * Purpose: Send requested reset to a bus or device at any phase. 1885 * 1886 * Arguments: device - device to send reset to 1887 * flag - reset type (see scsi.h) 1888 * 1889 * Returns: SUCCESS/FAILURE. 1890 * 1891 * Notes: This is used by the SCSI Generic driver to provide 1892 * Bus/Device reset capability. 1893 */ 1894 int 1895 scsi_reset_provider(struct scsi_device *dev, int flag) 1896 { 1897 struct scsi_cmnd *scmd; 1898 struct Scsi_Host *shost = dev->host; 1899 struct request req; 1900 unsigned long flags; 1901 int rtn; 1902 1903 if (scsi_autopm_get_host(shost) < 0) 1904 return FAILED; 1905 1906 scmd = scsi_get_command(dev, GFP_KERNEL); 1907 blk_rq_init(NULL, &req); 1908 scmd->request = &req; 1909 1910 scmd->cmnd = req.cmd; 1911 1912 scmd->scsi_done = scsi_reset_provider_done_command; 1913 memset(&scmd->sdb, 0, sizeof(scmd->sdb)); 1914 1915 scmd->cmd_len = 0; 1916 1917 scmd->sc_data_direction = DMA_BIDIRECTIONAL; 1918 1919 spin_lock_irqsave(shost->host_lock, flags); 1920 shost->tmf_in_progress = 1; 1921 spin_unlock_irqrestore(shost->host_lock, flags); 1922 1923 switch (flag) { 1924 case SCSI_TRY_RESET_DEVICE: 1925 rtn = scsi_try_bus_device_reset(scmd); 1926 if (rtn == SUCCESS) 1927 break; 1928 /* FALLTHROUGH */ 1929 case SCSI_TRY_RESET_TARGET: 1930 rtn = scsi_try_target_reset(scmd); 1931 if (rtn == SUCCESS) 1932 break; 1933 /* FALLTHROUGH */ 1934 case SCSI_TRY_RESET_BUS: 1935 rtn = scsi_try_bus_reset(scmd); 1936 if (rtn == SUCCESS) 1937 break; 1938 /* FALLTHROUGH */ 1939 case SCSI_TRY_RESET_HOST: 1940 rtn = scsi_try_host_reset(scmd); 1941 break; 1942 default: 1943 rtn = FAILED; 1944 } 1945 1946 spin_lock_irqsave(shost->host_lock, flags); 1947 shost->tmf_in_progress = 0; 1948 spin_unlock_irqrestore(shost->host_lock, flags); 1949 1950 /* 1951 * be sure to wake up anyone who was sleeping or had their queue 1952 * suspended while we performed the TMF. 1953 */ 1954 SCSI_LOG_ERROR_RECOVERY(3, 1955 printk("%s: waking up host to restart after TMF\n", 1956 __func__)); 1957 1958 wake_up(&shost->host_wait); 1959 1960 scsi_run_host_queues(shost); 1961 1962 scsi_next_command(scmd); 1963 scsi_autopm_put_host(shost); 1964 return rtn; 1965 } 1966 EXPORT_SYMBOL(scsi_reset_provider); 1967 1968 /** 1969 * scsi_normalize_sense - normalize main elements from either fixed or 1970 * descriptor sense data format into a common format. 1971 * 1972 * @sense_buffer: byte array containing sense data returned by device 1973 * @sb_len: number of valid bytes in sense_buffer 1974 * @sshdr: pointer to instance of structure that common 1975 * elements are written to. 1976 * 1977 * Notes: 1978 * The "main elements" from sense data are: response_code, sense_key, 1979 * asc, ascq and additional_length (only for descriptor format). 1980 * 1981 * Typically this function can be called after a device has 1982 * responded to a SCSI command with the CHECK_CONDITION status. 1983 * 1984 * Return value: 1985 * 1 if valid sense data information found, else 0; 1986 */ 1987 int scsi_normalize_sense(const u8 *sense_buffer, int sb_len, 1988 struct scsi_sense_hdr *sshdr) 1989 { 1990 if (!sense_buffer || !sb_len) 1991 return 0; 1992 1993 memset(sshdr, 0, sizeof(struct scsi_sense_hdr)); 1994 1995 sshdr->response_code = (sense_buffer[0] & 0x7f); 1996 1997 if (!scsi_sense_valid(sshdr)) 1998 return 0; 1999 2000 if (sshdr->response_code >= 0x72) { 2001 /* 2002 * descriptor format 2003 */ 2004 if (sb_len > 1) 2005 sshdr->sense_key = (sense_buffer[1] & 0xf); 2006 if (sb_len > 2) 2007 sshdr->asc = sense_buffer[2]; 2008 if (sb_len > 3) 2009 sshdr->ascq = sense_buffer[3]; 2010 if (sb_len > 7) 2011 sshdr->additional_length = sense_buffer[7]; 2012 } else { 2013 /* 2014 * fixed format 2015 */ 2016 if (sb_len > 2) 2017 sshdr->sense_key = (sense_buffer[2] & 0xf); 2018 if (sb_len > 7) { 2019 sb_len = (sb_len < (sense_buffer[7] + 8)) ? 2020 sb_len : (sense_buffer[7] + 8); 2021 if (sb_len > 12) 2022 sshdr->asc = sense_buffer[12]; 2023 if (sb_len > 13) 2024 sshdr->ascq = sense_buffer[13]; 2025 } 2026 } 2027 2028 return 1; 2029 } 2030 EXPORT_SYMBOL(scsi_normalize_sense); 2031 2032 int scsi_command_normalize_sense(struct scsi_cmnd *cmd, 2033 struct scsi_sense_hdr *sshdr) 2034 { 2035 return scsi_normalize_sense(cmd->sense_buffer, 2036 SCSI_SENSE_BUFFERSIZE, sshdr); 2037 } 2038 EXPORT_SYMBOL(scsi_command_normalize_sense); 2039 2040 /** 2041 * scsi_sense_desc_find - search for a given descriptor type in descriptor sense data format. 2042 * @sense_buffer: byte array of descriptor format sense data 2043 * @sb_len: number of valid bytes in sense_buffer 2044 * @desc_type: value of descriptor type to find 2045 * (e.g. 0 -> information) 2046 * 2047 * Notes: 2048 * only valid when sense data is in descriptor format 2049 * 2050 * Return value: 2051 * pointer to start of (first) descriptor if found else NULL 2052 */ 2053 const u8 * scsi_sense_desc_find(const u8 * sense_buffer, int sb_len, 2054 int desc_type) 2055 { 2056 int add_sen_len, add_len, desc_len, k; 2057 const u8 * descp; 2058 2059 if ((sb_len < 8) || (0 == (add_sen_len = sense_buffer[7]))) 2060 return NULL; 2061 if ((sense_buffer[0] < 0x72) || (sense_buffer[0] > 0x73)) 2062 return NULL; 2063 add_sen_len = (add_sen_len < (sb_len - 8)) ? 2064 add_sen_len : (sb_len - 8); 2065 descp = &sense_buffer[8]; 2066 for (desc_len = 0, k = 0; k < add_sen_len; k += desc_len) { 2067 descp += desc_len; 2068 add_len = (k < (add_sen_len - 1)) ? descp[1]: -1; 2069 desc_len = add_len + 2; 2070 if (descp[0] == desc_type) 2071 return descp; 2072 if (add_len < 0) // short descriptor ?? 2073 break; 2074 } 2075 return NULL; 2076 } 2077 EXPORT_SYMBOL(scsi_sense_desc_find); 2078 2079 /** 2080 * scsi_get_sense_info_fld - get information field from sense data (either fixed or descriptor format) 2081 * @sense_buffer: byte array of sense data 2082 * @sb_len: number of valid bytes in sense_buffer 2083 * @info_out: pointer to 64 integer where 8 or 4 byte information 2084 * field will be placed if found. 2085 * 2086 * Return value: 2087 * 1 if information field found, 0 if not found. 2088 */ 2089 int scsi_get_sense_info_fld(const u8 * sense_buffer, int sb_len, 2090 u64 * info_out) 2091 { 2092 int j; 2093 const u8 * ucp; 2094 u64 ull; 2095 2096 if (sb_len < 7) 2097 return 0; 2098 switch (sense_buffer[0] & 0x7f) { 2099 case 0x70: 2100 case 0x71: 2101 if (sense_buffer[0] & 0x80) { 2102 *info_out = (sense_buffer[3] << 24) + 2103 (sense_buffer[4] << 16) + 2104 (sense_buffer[5] << 8) + sense_buffer[6]; 2105 return 1; 2106 } else 2107 return 0; 2108 case 0x72: 2109 case 0x73: 2110 ucp = scsi_sense_desc_find(sense_buffer, sb_len, 2111 0 /* info desc */); 2112 if (ucp && (0xa == ucp[1])) { 2113 ull = 0; 2114 for (j = 0; j < 8; ++j) { 2115 if (j > 0) 2116 ull <<= 8; 2117 ull |= ucp[4 + j]; 2118 } 2119 *info_out = ull; 2120 return 1; 2121 } else 2122 return 0; 2123 default: 2124 return 0; 2125 } 2126 } 2127 EXPORT_SYMBOL(scsi_get_sense_info_fld); 2128 2129 /** 2130 * scsi_build_sense_buffer - build sense data in a buffer 2131 * @desc: Sense format (non zero == descriptor format, 2132 * 0 == fixed format) 2133 * @buf: Where to build sense data 2134 * @key: Sense key 2135 * @asc: Additional sense code 2136 * @ascq: Additional sense code qualifier 2137 * 2138 **/ 2139 void scsi_build_sense_buffer(int desc, u8 *buf, u8 key, u8 asc, u8 ascq) 2140 { 2141 if (desc) { 2142 buf[0] = 0x72; /* descriptor, current */ 2143 buf[1] = key; 2144 buf[2] = asc; 2145 buf[3] = ascq; 2146 buf[7] = 0; 2147 } else { 2148 buf[0] = 0x70; /* fixed, current */ 2149 buf[2] = key; 2150 buf[7] = 0xa; 2151 buf[12] = asc; 2152 buf[13] = ascq; 2153 } 2154 } 2155 EXPORT_SYMBOL(scsi_build_sense_buffer); 2156