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