1 /* 2 * scsi_lib.c Copyright (C) 1999 Eric Youngdale 3 * 4 * SCSI queueing library. 5 * Initial versions: Eric Youngdale (eric@andante.org). 6 * Based upon conversations with large numbers 7 * of people at Linux Expo. 8 */ 9 10 #include <linux/bio.h> 11 #include <linux/bitops.h> 12 #include <linux/blkdev.h> 13 #include <linux/completion.h> 14 #include <linux/kernel.h> 15 #include <linux/mempool.h> 16 #include <linux/slab.h> 17 #include <linux/init.h> 18 #include <linux/pci.h> 19 #include <linux/delay.h> 20 #include <linux/hardirq.h> 21 #include <linux/scatterlist.h> 22 23 #include <scsi/scsi.h> 24 #include <scsi/scsi_cmnd.h> 25 #include <scsi/scsi_dbg.h> 26 #include <scsi/scsi_device.h> 27 #include <scsi/scsi_driver.h> 28 #include <scsi/scsi_eh.h> 29 #include <scsi/scsi_host.h> 30 31 #include "scsi_priv.h" 32 #include "scsi_logging.h" 33 34 35 #define SG_MEMPOOL_NR ARRAY_SIZE(scsi_sg_pools) 36 #define SG_MEMPOOL_SIZE 2 37 38 struct scsi_host_sg_pool { 39 size_t size; 40 char *name; 41 struct kmem_cache *slab; 42 mempool_t *pool; 43 }; 44 45 #define SP(x) { x, "sgpool-" __stringify(x) } 46 #if (SCSI_MAX_SG_SEGMENTS < 32) 47 #error SCSI_MAX_SG_SEGMENTS is too small (must be 32 or greater) 48 #endif 49 static struct scsi_host_sg_pool scsi_sg_pools[] = { 50 SP(8), 51 SP(16), 52 #if (SCSI_MAX_SG_SEGMENTS > 32) 53 SP(32), 54 #if (SCSI_MAX_SG_SEGMENTS > 64) 55 SP(64), 56 #if (SCSI_MAX_SG_SEGMENTS > 128) 57 SP(128), 58 #if (SCSI_MAX_SG_SEGMENTS > 256) 59 #error SCSI_MAX_SG_SEGMENTS is too large (256 MAX) 60 #endif 61 #endif 62 #endif 63 #endif 64 SP(SCSI_MAX_SG_SEGMENTS) 65 }; 66 #undef SP 67 68 struct kmem_cache *scsi_sdb_cache; 69 70 /* 71 * When to reinvoke queueing after a resource shortage. It's 3 msecs to 72 * not change behaviour from the previous unplug mechanism, experimentation 73 * may prove this needs changing. 74 */ 75 #define SCSI_QUEUE_DELAY 3 76 77 /* 78 * Function: scsi_unprep_request() 79 * 80 * Purpose: Remove all preparation done for a request, including its 81 * associated scsi_cmnd, so that it can be requeued. 82 * 83 * Arguments: req - request to unprepare 84 * 85 * Lock status: Assumed that no locks are held upon entry. 86 * 87 * Returns: Nothing. 88 */ 89 static void scsi_unprep_request(struct request *req) 90 { 91 struct scsi_cmnd *cmd = req->special; 92 93 blk_unprep_request(req); 94 req->special = NULL; 95 96 scsi_put_command(cmd); 97 } 98 99 /** 100 * __scsi_queue_insert - private queue insertion 101 * @cmd: The SCSI command being requeued 102 * @reason: The reason for the requeue 103 * @unbusy: Whether the queue should be unbusied 104 * 105 * This is a private queue insertion. The public interface 106 * scsi_queue_insert() always assumes the queue should be unbusied 107 * because it's always called before the completion. This function is 108 * for a requeue after completion, which should only occur in this 109 * file. 110 */ 111 static int __scsi_queue_insert(struct scsi_cmnd *cmd, int reason, int unbusy) 112 { 113 struct Scsi_Host *host = cmd->device->host; 114 struct scsi_device *device = cmd->device; 115 struct scsi_target *starget = scsi_target(device); 116 struct request_queue *q = device->request_queue; 117 unsigned long flags; 118 119 SCSI_LOG_MLQUEUE(1, 120 printk("Inserting command %p into mlqueue\n", cmd)); 121 122 /* 123 * Set the appropriate busy bit for the device/host. 124 * 125 * If the host/device isn't busy, assume that something actually 126 * completed, and that we should be able to queue a command now. 127 * 128 * Note that the prior mid-layer assumption that any host could 129 * always queue at least one command is now broken. The mid-layer 130 * will implement a user specifiable stall (see 131 * scsi_host.max_host_blocked and scsi_device.max_device_blocked) 132 * if a command is requeued with no other commands outstanding 133 * either for the device or for the host. 134 */ 135 switch (reason) { 136 case SCSI_MLQUEUE_HOST_BUSY: 137 host->host_blocked = host->max_host_blocked; 138 break; 139 case SCSI_MLQUEUE_DEVICE_BUSY: 140 case SCSI_MLQUEUE_EH_RETRY: 141 device->device_blocked = device->max_device_blocked; 142 break; 143 case SCSI_MLQUEUE_TARGET_BUSY: 144 starget->target_blocked = starget->max_target_blocked; 145 break; 146 } 147 148 /* 149 * Decrement the counters, since these commands are no longer 150 * active on the host/device. 151 */ 152 if (unbusy) 153 scsi_device_unbusy(device); 154 155 /* 156 * Requeue this command. It will go before all other commands 157 * that are already in the queue. 158 */ 159 spin_lock_irqsave(q->queue_lock, flags); 160 blk_requeue_request(q, cmd->request); 161 spin_unlock_irqrestore(q->queue_lock, flags); 162 163 kblockd_schedule_work(q, &device->requeue_work); 164 165 return 0; 166 } 167 168 /* 169 * Function: scsi_queue_insert() 170 * 171 * Purpose: Insert a command in the midlevel queue. 172 * 173 * Arguments: cmd - command that we are adding to queue. 174 * reason - why we are inserting command to queue. 175 * 176 * Lock status: Assumed that lock is not held upon entry. 177 * 178 * Returns: Nothing. 179 * 180 * Notes: We do this for one of two cases. Either the host is busy 181 * and it cannot accept any more commands for the time being, 182 * or the device returned QUEUE_FULL and can accept no more 183 * commands. 184 * Notes: This could be called either from an interrupt context or a 185 * normal process context. 186 */ 187 int scsi_queue_insert(struct scsi_cmnd *cmd, int reason) 188 { 189 return __scsi_queue_insert(cmd, reason, 1); 190 } 191 /** 192 * scsi_execute - insert request and wait for the result 193 * @sdev: scsi device 194 * @cmd: scsi command 195 * @data_direction: data direction 196 * @buffer: data buffer 197 * @bufflen: len of buffer 198 * @sense: optional sense buffer 199 * @timeout: request timeout in seconds 200 * @retries: number of times to retry request 201 * @flags: or into request flags; 202 * @resid: optional residual length 203 * 204 * returns the req->errors value which is the scsi_cmnd result 205 * field. 206 */ 207 int scsi_execute(struct scsi_device *sdev, const unsigned char *cmd, 208 int data_direction, void *buffer, unsigned bufflen, 209 unsigned char *sense, int timeout, int retries, int flags, 210 int *resid) 211 { 212 struct request *req; 213 int write = (data_direction == DMA_TO_DEVICE); 214 int ret = DRIVER_ERROR << 24; 215 216 req = blk_get_request(sdev->request_queue, write, __GFP_WAIT); 217 if (!req) 218 return ret; 219 220 if (bufflen && blk_rq_map_kern(sdev->request_queue, req, 221 buffer, bufflen, __GFP_WAIT)) 222 goto out; 223 224 req->cmd_len = COMMAND_SIZE(cmd[0]); 225 memcpy(req->cmd, cmd, req->cmd_len); 226 req->sense = sense; 227 req->sense_len = 0; 228 req->retries = retries; 229 req->timeout = timeout; 230 req->cmd_type = REQ_TYPE_BLOCK_PC; 231 req->cmd_flags |= flags | REQ_QUIET | REQ_PREEMPT; 232 233 /* 234 * head injection *required* here otherwise quiesce won't work 235 */ 236 blk_execute_rq(req->q, NULL, req, 1); 237 238 /* 239 * Some devices (USB mass-storage in particular) may transfer 240 * garbage data together with a residue indicating that the data 241 * is invalid. Prevent the garbage from being misinterpreted 242 * and prevent security leaks by zeroing out the excess data. 243 */ 244 if (unlikely(req->resid_len > 0 && req->resid_len <= bufflen)) 245 memset(buffer + (bufflen - req->resid_len), 0, req->resid_len); 246 247 if (resid) 248 *resid = req->resid_len; 249 ret = req->errors; 250 out: 251 blk_put_request(req); 252 253 return ret; 254 } 255 EXPORT_SYMBOL(scsi_execute); 256 257 258 int scsi_execute_req(struct scsi_device *sdev, const unsigned char *cmd, 259 int data_direction, void *buffer, unsigned bufflen, 260 struct scsi_sense_hdr *sshdr, int timeout, int retries, 261 int *resid) 262 { 263 char *sense = NULL; 264 int result; 265 266 if (sshdr) { 267 sense = kzalloc(SCSI_SENSE_BUFFERSIZE, GFP_NOIO); 268 if (!sense) 269 return DRIVER_ERROR << 24; 270 } 271 result = scsi_execute(sdev, cmd, data_direction, buffer, bufflen, 272 sense, timeout, retries, 0, resid); 273 if (sshdr) 274 scsi_normalize_sense(sense, SCSI_SENSE_BUFFERSIZE, sshdr); 275 276 kfree(sense); 277 return result; 278 } 279 EXPORT_SYMBOL(scsi_execute_req); 280 281 /* 282 * Function: scsi_init_cmd_errh() 283 * 284 * Purpose: Initialize cmd fields related to error handling. 285 * 286 * Arguments: cmd - command that is ready to be queued. 287 * 288 * Notes: This function has the job of initializing a number of 289 * fields related to error handling. Typically this will 290 * be called once for each command, as required. 291 */ 292 static void scsi_init_cmd_errh(struct scsi_cmnd *cmd) 293 { 294 cmd->serial_number = 0; 295 scsi_set_resid(cmd, 0); 296 memset(cmd->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE); 297 if (cmd->cmd_len == 0) 298 cmd->cmd_len = scsi_command_size(cmd->cmnd); 299 } 300 301 void scsi_device_unbusy(struct scsi_device *sdev) 302 { 303 struct Scsi_Host *shost = sdev->host; 304 struct scsi_target *starget = scsi_target(sdev); 305 unsigned long flags; 306 307 spin_lock_irqsave(shost->host_lock, flags); 308 shost->host_busy--; 309 starget->target_busy--; 310 if (unlikely(scsi_host_in_recovery(shost) && 311 (shost->host_failed || shost->host_eh_scheduled))) 312 scsi_eh_wakeup(shost); 313 spin_unlock(shost->host_lock); 314 spin_lock(sdev->request_queue->queue_lock); 315 sdev->device_busy--; 316 spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags); 317 } 318 319 /* 320 * Called for single_lun devices on IO completion. Clear starget_sdev_user, 321 * and call blk_run_queue for all the scsi_devices on the target - 322 * including current_sdev first. 323 * 324 * Called with *no* scsi locks held. 325 */ 326 static void scsi_single_lun_run(struct scsi_device *current_sdev) 327 { 328 struct Scsi_Host *shost = current_sdev->host; 329 struct scsi_device *sdev, *tmp; 330 struct scsi_target *starget = scsi_target(current_sdev); 331 unsigned long flags; 332 333 spin_lock_irqsave(shost->host_lock, flags); 334 starget->starget_sdev_user = NULL; 335 spin_unlock_irqrestore(shost->host_lock, flags); 336 337 /* 338 * Call blk_run_queue for all LUNs on the target, starting with 339 * current_sdev. We race with others (to set starget_sdev_user), 340 * but in most cases, we will be first. Ideally, each LU on the 341 * target would get some limited time or requests on the target. 342 */ 343 blk_run_queue(current_sdev->request_queue); 344 345 spin_lock_irqsave(shost->host_lock, flags); 346 if (starget->starget_sdev_user) 347 goto out; 348 list_for_each_entry_safe(sdev, tmp, &starget->devices, 349 same_target_siblings) { 350 if (sdev == current_sdev) 351 continue; 352 if (scsi_device_get(sdev)) 353 continue; 354 355 spin_unlock_irqrestore(shost->host_lock, flags); 356 blk_run_queue(sdev->request_queue); 357 spin_lock_irqsave(shost->host_lock, flags); 358 359 scsi_device_put(sdev); 360 } 361 out: 362 spin_unlock_irqrestore(shost->host_lock, flags); 363 } 364 365 static inline int scsi_device_is_busy(struct scsi_device *sdev) 366 { 367 if (sdev->device_busy >= sdev->queue_depth || sdev->device_blocked) 368 return 1; 369 370 return 0; 371 } 372 373 static inline int scsi_target_is_busy(struct scsi_target *starget) 374 { 375 return ((starget->can_queue > 0 && 376 starget->target_busy >= starget->can_queue) || 377 starget->target_blocked); 378 } 379 380 static inline int scsi_host_is_busy(struct Scsi_Host *shost) 381 { 382 if ((shost->can_queue > 0 && shost->host_busy >= shost->can_queue) || 383 shost->host_blocked || shost->host_self_blocked) 384 return 1; 385 386 return 0; 387 } 388 389 /* 390 * Function: scsi_run_queue() 391 * 392 * Purpose: Select a proper request queue to serve next 393 * 394 * Arguments: q - last request's queue 395 * 396 * Returns: Nothing 397 * 398 * Notes: The previous command was completely finished, start 399 * a new one if possible. 400 */ 401 static void scsi_run_queue(struct request_queue *q) 402 { 403 struct scsi_device *sdev = q->queuedata; 404 struct Scsi_Host *shost; 405 LIST_HEAD(starved_list); 406 unsigned long flags; 407 408 /* if the device is dead, sdev will be NULL, so no queue to run */ 409 if (!sdev) 410 return; 411 412 shost = sdev->host; 413 if (scsi_target(sdev)->single_lun) 414 scsi_single_lun_run(sdev); 415 416 spin_lock_irqsave(shost->host_lock, flags); 417 list_splice_init(&shost->starved_list, &starved_list); 418 419 while (!list_empty(&starved_list)) { 420 /* 421 * As long as shost is accepting commands and we have 422 * starved queues, call blk_run_queue. scsi_request_fn 423 * drops the queue_lock and can add us back to the 424 * starved_list. 425 * 426 * host_lock protects the starved_list and starved_entry. 427 * scsi_request_fn must get the host_lock before checking 428 * or modifying starved_list or starved_entry. 429 */ 430 if (scsi_host_is_busy(shost)) 431 break; 432 433 sdev = list_entry(starved_list.next, 434 struct scsi_device, starved_entry); 435 list_del_init(&sdev->starved_entry); 436 if (scsi_target_is_busy(scsi_target(sdev))) { 437 list_move_tail(&sdev->starved_entry, 438 &shost->starved_list); 439 continue; 440 } 441 442 spin_unlock(shost->host_lock); 443 spin_lock(sdev->request_queue->queue_lock); 444 __blk_run_queue(sdev->request_queue); 445 spin_unlock(sdev->request_queue->queue_lock); 446 spin_lock(shost->host_lock); 447 } 448 /* put any unprocessed entries back */ 449 list_splice(&starved_list, &shost->starved_list); 450 spin_unlock_irqrestore(shost->host_lock, flags); 451 452 blk_run_queue(q); 453 } 454 455 void scsi_requeue_run_queue(struct work_struct *work) 456 { 457 struct scsi_device *sdev; 458 struct request_queue *q; 459 460 sdev = container_of(work, struct scsi_device, requeue_work); 461 q = sdev->request_queue; 462 scsi_run_queue(q); 463 } 464 465 /* 466 * Function: scsi_requeue_command() 467 * 468 * Purpose: Handle post-processing of completed commands. 469 * 470 * Arguments: q - queue to operate on 471 * cmd - command that may need to be requeued. 472 * 473 * Returns: Nothing 474 * 475 * Notes: After command completion, there may be blocks left 476 * over which weren't finished by the previous command 477 * this can be for a number of reasons - the main one is 478 * I/O errors in the middle of the request, in which case 479 * we need to request the blocks that come after the bad 480 * sector. 481 * Notes: Upon return, cmd is a stale pointer. 482 */ 483 static void scsi_requeue_command(struct request_queue *q, struct scsi_cmnd *cmd) 484 { 485 struct request *req = cmd->request; 486 unsigned long flags; 487 488 spin_lock_irqsave(q->queue_lock, flags); 489 scsi_unprep_request(req); 490 blk_requeue_request(q, req); 491 spin_unlock_irqrestore(q->queue_lock, flags); 492 493 scsi_run_queue(q); 494 } 495 496 void scsi_next_command(struct scsi_cmnd *cmd) 497 { 498 struct scsi_device *sdev = cmd->device; 499 struct request_queue *q = sdev->request_queue; 500 501 /* need to hold a reference on the device before we let go of the cmd */ 502 get_device(&sdev->sdev_gendev); 503 504 scsi_put_command(cmd); 505 scsi_run_queue(q); 506 507 /* ok to remove device now */ 508 put_device(&sdev->sdev_gendev); 509 } 510 511 void scsi_run_host_queues(struct Scsi_Host *shost) 512 { 513 struct scsi_device *sdev; 514 515 shost_for_each_device(sdev, shost) 516 scsi_run_queue(sdev->request_queue); 517 } 518 519 static void __scsi_release_buffers(struct scsi_cmnd *, int); 520 521 /* 522 * Function: scsi_end_request() 523 * 524 * Purpose: Post-processing of completed commands (usually invoked at end 525 * of upper level post-processing and scsi_io_completion). 526 * 527 * Arguments: cmd - command that is complete. 528 * error - 0 if I/O indicates success, < 0 for I/O error. 529 * bytes - number of bytes of completed I/O 530 * requeue - indicates whether we should requeue leftovers. 531 * 532 * Lock status: Assumed that lock is not held upon entry. 533 * 534 * Returns: cmd if requeue required, NULL otherwise. 535 * 536 * Notes: This is called for block device requests in order to 537 * mark some number of sectors as complete. 538 * 539 * We are guaranteeing that the request queue will be goosed 540 * at some point during this call. 541 * Notes: If cmd was requeued, upon return it will be a stale pointer. 542 */ 543 static struct scsi_cmnd *scsi_end_request(struct scsi_cmnd *cmd, int error, 544 int bytes, int requeue) 545 { 546 struct request_queue *q = cmd->device->request_queue; 547 struct request *req = cmd->request; 548 549 /* 550 * If there are blocks left over at the end, set up the command 551 * to queue the remainder of them. 552 */ 553 if (blk_end_request(req, error, bytes)) { 554 /* kill remainder if no retrys */ 555 if (error && scsi_noretry_cmd(cmd)) 556 blk_end_request_all(req, error); 557 else { 558 if (requeue) { 559 /* 560 * Bleah. Leftovers again. Stick the 561 * leftovers in the front of the 562 * queue, and goose the queue again. 563 */ 564 scsi_release_buffers(cmd); 565 scsi_requeue_command(q, cmd); 566 cmd = NULL; 567 } 568 return cmd; 569 } 570 } 571 572 /* 573 * This will goose the queue request function at the end, so we don't 574 * need to worry about launching another command. 575 */ 576 __scsi_release_buffers(cmd, 0); 577 scsi_next_command(cmd); 578 return NULL; 579 } 580 581 static inline unsigned int scsi_sgtable_index(unsigned short nents) 582 { 583 unsigned int index; 584 585 BUG_ON(nents > SCSI_MAX_SG_SEGMENTS); 586 587 if (nents <= 8) 588 index = 0; 589 else 590 index = get_count_order(nents) - 3; 591 592 return index; 593 } 594 595 static void scsi_sg_free(struct scatterlist *sgl, unsigned int nents) 596 { 597 struct scsi_host_sg_pool *sgp; 598 599 sgp = scsi_sg_pools + scsi_sgtable_index(nents); 600 mempool_free(sgl, sgp->pool); 601 } 602 603 static struct scatterlist *scsi_sg_alloc(unsigned int nents, gfp_t gfp_mask) 604 { 605 struct scsi_host_sg_pool *sgp; 606 607 sgp = scsi_sg_pools + scsi_sgtable_index(nents); 608 return mempool_alloc(sgp->pool, gfp_mask); 609 } 610 611 static int scsi_alloc_sgtable(struct scsi_data_buffer *sdb, int nents, 612 gfp_t gfp_mask) 613 { 614 int ret; 615 616 BUG_ON(!nents); 617 618 ret = __sg_alloc_table(&sdb->table, nents, SCSI_MAX_SG_SEGMENTS, 619 gfp_mask, scsi_sg_alloc); 620 if (unlikely(ret)) 621 __sg_free_table(&sdb->table, SCSI_MAX_SG_SEGMENTS, 622 scsi_sg_free); 623 624 return ret; 625 } 626 627 static void scsi_free_sgtable(struct scsi_data_buffer *sdb) 628 { 629 __sg_free_table(&sdb->table, SCSI_MAX_SG_SEGMENTS, scsi_sg_free); 630 } 631 632 static void __scsi_release_buffers(struct scsi_cmnd *cmd, int do_bidi_check) 633 { 634 635 if (cmd->sdb.table.nents) 636 scsi_free_sgtable(&cmd->sdb); 637 638 memset(&cmd->sdb, 0, sizeof(cmd->sdb)); 639 640 if (do_bidi_check && scsi_bidi_cmnd(cmd)) { 641 struct scsi_data_buffer *bidi_sdb = 642 cmd->request->next_rq->special; 643 scsi_free_sgtable(bidi_sdb); 644 kmem_cache_free(scsi_sdb_cache, bidi_sdb); 645 cmd->request->next_rq->special = NULL; 646 } 647 648 if (scsi_prot_sg_count(cmd)) 649 scsi_free_sgtable(cmd->prot_sdb); 650 } 651 652 /* 653 * Function: scsi_release_buffers() 654 * 655 * Purpose: Completion processing for block device I/O requests. 656 * 657 * Arguments: cmd - command that we are bailing. 658 * 659 * Lock status: Assumed that no lock is held upon entry. 660 * 661 * Returns: Nothing 662 * 663 * Notes: In the event that an upper level driver rejects a 664 * command, we must release resources allocated during 665 * the __init_io() function. Primarily this would involve 666 * the scatter-gather table, and potentially any bounce 667 * buffers. 668 */ 669 void scsi_release_buffers(struct scsi_cmnd *cmd) 670 { 671 __scsi_release_buffers(cmd, 1); 672 } 673 EXPORT_SYMBOL(scsi_release_buffers); 674 675 static int __scsi_error_from_host_byte(struct scsi_cmnd *cmd, int result) 676 { 677 int error = 0; 678 679 switch(host_byte(result)) { 680 case DID_TRANSPORT_FAILFAST: 681 error = -ENOLINK; 682 break; 683 case DID_TARGET_FAILURE: 684 cmd->result |= (DID_OK << 16); 685 error = -EREMOTEIO; 686 break; 687 case DID_NEXUS_FAILURE: 688 cmd->result |= (DID_OK << 16); 689 error = -EBADE; 690 break; 691 default: 692 error = -EIO; 693 break; 694 } 695 696 return error; 697 } 698 699 /* 700 * Function: scsi_io_completion() 701 * 702 * Purpose: Completion processing for block device I/O requests. 703 * 704 * Arguments: cmd - command that is finished. 705 * 706 * Lock status: Assumed that no lock is held upon entry. 707 * 708 * Returns: Nothing 709 * 710 * Notes: This function is matched in terms of capabilities to 711 * the function that created the scatter-gather list. 712 * In other words, if there are no bounce buffers 713 * (the normal case for most drivers), we don't need 714 * the logic to deal with cleaning up afterwards. 715 * 716 * We must call scsi_end_request(). This will finish off 717 * the specified number of sectors. If we are done, the 718 * command block will be released and the queue function 719 * will be goosed. If we are not done then we have to 720 * figure out what to do next: 721 * 722 * a) We can call scsi_requeue_command(). The request 723 * will be unprepared and put back on the queue. Then 724 * a new command will be created for it. This should 725 * be used if we made forward progress, or if we want 726 * to switch from READ(10) to READ(6) for example. 727 * 728 * b) We can call scsi_queue_insert(). The request will 729 * be put back on the queue and retried using the same 730 * command as before, possibly after a delay. 731 * 732 * c) We can call blk_end_request() with -EIO to fail 733 * the remainder of the request. 734 */ 735 void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes) 736 { 737 int result = cmd->result; 738 struct request_queue *q = cmd->device->request_queue; 739 struct request *req = cmd->request; 740 int error = 0; 741 struct scsi_sense_hdr sshdr; 742 int sense_valid = 0; 743 int sense_deferred = 0; 744 enum {ACTION_FAIL, ACTION_REPREP, ACTION_RETRY, 745 ACTION_DELAYED_RETRY} action; 746 char *description = NULL; 747 748 if (result) { 749 sense_valid = scsi_command_normalize_sense(cmd, &sshdr); 750 if (sense_valid) 751 sense_deferred = scsi_sense_is_deferred(&sshdr); 752 } 753 754 if (req->cmd_type == REQ_TYPE_BLOCK_PC) { /* SG_IO ioctl from block level */ 755 req->errors = result; 756 if (result) { 757 if (sense_valid && req->sense) { 758 /* 759 * SG_IO wants current and deferred errors 760 */ 761 int len = 8 + cmd->sense_buffer[7]; 762 763 if (len > SCSI_SENSE_BUFFERSIZE) 764 len = SCSI_SENSE_BUFFERSIZE; 765 memcpy(req->sense, cmd->sense_buffer, len); 766 req->sense_len = len; 767 } 768 if (!sense_deferred) 769 error = __scsi_error_from_host_byte(cmd, result); 770 } 771 772 req->resid_len = scsi_get_resid(cmd); 773 774 if (scsi_bidi_cmnd(cmd)) { 775 /* 776 * Bidi commands Must be complete as a whole, 777 * both sides at once. 778 */ 779 req->next_rq->resid_len = scsi_in(cmd)->resid; 780 781 scsi_release_buffers(cmd); 782 blk_end_request_all(req, 0); 783 784 scsi_next_command(cmd); 785 return; 786 } 787 } 788 789 /* no bidi support for !REQ_TYPE_BLOCK_PC yet */ 790 BUG_ON(blk_bidi_rq(req)); 791 792 /* 793 * Next deal with any sectors which we were able to correctly 794 * handle. 795 */ 796 SCSI_LOG_HLCOMPLETE(1, printk("%u sectors total, " 797 "%d bytes done.\n", 798 blk_rq_sectors(req), good_bytes)); 799 800 /* 801 * Recovered errors need reporting, but they're always treated 802 * as success, so fiddle the result code here. For BLOCK_PC 803 * we already took a copy of the original into rq->errors which 804 * is what gets returned to the user 805 */ 806 if (sense_valid && (sshdr.sense_key == RECOVERED_ERROR)) { 807 /* if ATA PASS-THROUGH INFORMATION AVAILABLE skip 808 * print since caller wants ATA registers. Only occurs on 809 * SCSI ATA PASS_THROUGH commands when CK_COND=1 810 */ 811 if ((sshdr.asc == 0x0) && (sshdr.ascq == 0x1d)) 812 ; 813 else if (!(req->cmd_flags & REQ_QUIET)) 814 scsi_print_sense("", cmd); 815 result = 0; 816 /* BLOCK_PC may have set error */ 817 error = 0; 818 } 819 820 /* 821 * A number of bytes were successfully read. If there 822 * are leftovers and there is some kind of error 823 * (result != 0), retry the rest. 824 */ 825 if (scsi_end_request(cmd, error, good_bytes, result == 0) == NULL) 826 return; 827 828 error = __scsi_error_from_host_byte(cmd, result); 829 830 if (host_byte(result) == DID_RESET) { 831 /* Third party bus reset or reset for error recovery 832 * reasons. Just retry the command and see what 833 * happens. 834 */ 835 action = ACTION_RETRY; 836 } else if (sense_valid && !sense_deferred) { 837 switch (sshdr.sense_key) { 838 case UNIT_ATTENTION: 839 if (cmd->device->removable) { 840 /* Detected disc change. Set a bit 841 * and quietly refuse further access. 842 */ 843 cmd->device->changed = 1; 844 description = "Media Changed"; 845 action = ACTION_FAIL; 846 } else { 847 /* Must have been a power glitch, or a 848 * bus reset. Could not have been a 849 * media change, so we just retry the 850 * command and see what happens. 851 */ 852 action = ACTION_RETRY; 853 } 854 break; 855 case ILLEGAL_REQUEST: 856 /* If we had an ILLEGAL REQUEST returned, then 857 * we may have performed an unsupported 858 * command. The only thing this should be 859 * would be a ten byte read where only a six 860 * byte read was supported. Also, on a system 861 * where READ CAPACITY failed, we may have 862 * read past the end of the disk. 863 */ 864 if ((cmd->device->use_10_for_rw && 865 sshdr.asc == 0x20 && sshdr.ascq == 0x00) && 866 (cmd->cmnd[0] == READ_10 || 867 cmd->cmnd[0] == WRITE_10)) { 868 /* This will issue a new 6-byte command. */ 869 cmd->device->use_10_for_rw = 0; 870 action = ACTION_REPREP; 871 } else if (sshdr.asc == 0x10) /* DIX */ { 872 description = "Host Data Integrity Failure"; 873 action = ACTION_FAIL; 874 error = -EILSEQ; 875 /* INVALID COMMAND OPCODE or INVALID FIELD IN CDB */ 876 } else if ((sshdr.asc == 0x20 || sshdr.asc == 0x24) && 877 (cmd->cmnd[0] == UNMAP || 878 cmd->cmnd[0] == WRITE_SAME_16 || 879 cmd->cmnd[0] == WRITE_SAME)) { 880 description = "Discard failure"; 881 action = ACTION_FAIL; 882 } else 883 action = ACTION_FAIL; 884 break; 885 case ABORTED_COMMAND: 886 action = ACTION_FAIL; 887 if (sshdr.asc == 0x10) { /* DIF */ 888 description = "Target Data Integrity Failure"; 889 error = -EILSEQ; 890 } 891 break; 892 case NOT_READY: 893 /* If the device is in the process of becoming 894 * ready, or has a temporary blockage, retry. 895 */ 896 if (sshdr.asc == 0x04) { 897 switch (sshdr.ascq) { 898 case 0x01: /* becoming ready */ 899 case 0x04: /* format in progress */ 900 case 0x05: /* rebuild in progress */ 901 case 0x06: /* recalculation in progress */ 902 case 0x07: /* operation in progress */ 903 case 0x08: /* Long write in progress */ 904 case 0x09: /* self test in progress */ 905 case 0x14: /* space allocation in progress */ 906 action = ACTION_DELAYED_RETRY; 907 break; 908 default: 909 description = "Device not ready"; 910 action = ACTION_FAIL; 911 break; 912 } 913 } else { 914 description = "Device not ready"; 915 action = ACTION_FAIL; 916 } 917 break; 918 case VOLUME_OVERFLOW: 919 /* See SSC3rXX or current. */ 920 action = ACTION_FAIL; 921 break; 922 default: 923 description = "Unhandled sense code"; 924 action = ACTION_FAIL; 925 break; 926 } 927 } else { 928 description = "Unhandled error code"; 929 action = ACTION_FAIL; 930 } 931 932 switch (action) { 933 case ACTION_FAIL: 934 /* Give up and fail the remainder of the request */ 935 scsi_release_buffers(cmd); 936 if (!(req->cmd_flags & REQ_QUIET)) { 937 if (description) 938 scmd_printk(KERN_INFO, cmd, "%s\n", 939 description); 940 scsi_print_result(cmd); 941 if (driver_byte(result) & DRIVER_SENSE) 942 scsi_print_sense("", cmd); 943 scsi_print_command(cmd); 944 } 945 if (blk_end_request_err(req, error)) 946 scsi_requeue_command(q, cmd); 947 else 948 scsi_next_command(cmd); 949 break; 950 case ACTION_REPREP: 951 /* Unprep the request and put it back at the head of the queue. 952 * A new command will be prepared and issued. 953 */ 954 scsi_release_buffers(cmd); 955 scsi_requeue_command(q, cmd); 956 break; 957 case ACTION_RETRY: 958 /* Retry the same command immediately */ 959 __scsi_queue_insert(cmd, SCSI_MLQUEUE_EH_RETRY, 0); 960 break; 961 case ACTION_DELAYED_RETRY: 962 /* Retry the same command after a delay */ 963 __scsi_queue_insert(cmd, SCSI_MLQUEUE_DEVICE_BUSY, 0); 964 break; 965 } 966 } 967 968 static int scsi_init_sgtable(struct request *req, struct scsi_data_buffer *sdb, 969 gfp_t gfp_mask) 970 { 971 int count; 972 973 /* 974 * If sg table allocation fails, requeue request later. 975 */ 976 if (unlikely(scsi_alloc_sgtable(sdb, req->nr_phys_segments, 977 gfp_mask))) { 978 return BLKPREP_DEFER; 979 } 980 981 req->buffer = NULL; 982 983 /* 984 * Next, walk the list, and fill in the addresses and sizes of 985 * each segment. 986 */ 987 count = blk_rq_map_sg(req->q, req, sdb->table.sgl); 988 BUG_ON(count > sdb->table.nents); 989 sdb->table.nents = count; 990 sdb->length = blk_rq_bytes(req); 991 return BLKPREP_OK; 992 } 993 994 /* 995 * Function: scsi_init_io() 996 * 997 * Purpose: SCSI I/O initialize function. 998 * 999 * Arguments: cmd - Command descriptor we wish to initialize 1000 * 1001 * Returns: 0 on success 1002 * BLKPREP_DEFER if the failure is retryable 1003 * BLKPREP_KILL if the failure is fatal 1004 */ 1005 int scsi_init_io(struct scsi_cmnd *cmd, gfp_t gfp_mask) 1006 { 1007 struct request *rq = cmd->request; 1008 1009 int error = scsi_init_sgtable(rq, &cmd->sdb, gfp_mask); 1010 if (error) 1011 goto err_exit; 1012 1013 if (blk_bidi_rq(rq)) { 1014 struct scsi_data_buffer *bidi_sdb = kmem_cache_zalloc( 1015 scsi_sdb_cache, GFP_ATOMIC); 1016 if (!bidi_sdb) { 1017 error = BLKPREP_DEFER; 1018 goto err_exit; 1019 } 1020 1021 rq->next_rq->special = bidi_sdb; 1022 error = scsi_init_sgtable(rq->next_rq, bidi_sdb, GFP_ATOMIC); 1023 if (error) 1024 goto err_exit; 1025 } 1026 1027 if (blk_integrity_rq(rq)) { 1028 struct scsi_data_buffer *prot_sdb = cmd->prot_sdb; 1029 int ivecs, count; 1030 1031 BUG_ON(prot_sdb == NULL); 1032 ivecs = blk_rq_count_integrity_sg(rq->q, rq->bio); 1033 1034 if (scsi_alloc_sgtable(prot_sdb, ivecs, gfp_mask)) { 1035 error = BLKPREP_DEFER; 1036 goto err_exit; 1037 } 1038 1039 count = blk_rq_map_integrity_sg(rq->q, rq->bio, 1040 prot_sdb->table.sgl); 1041 BUG_ON(unlikely(count > ivecs)); 1042 BUG_ON(unlikely(count > queue_max_integrity_segments(rq->q))); 1043 1044 cmd->prot_sdb = prot_sdb; 1045 cmd->prot_sdb->table.nents = count; 1046 } 1047 1048 return BLKPREP_OK ; 1049 1050 err_exit: 1051 scsi_release_buffers(cmd); 1052 cmd->request->special = NULL; 1053 scsi_put_command(cmd); 1054 return error; 1055 } 1056 EXPORT_SYMBOL(scsi_init_io); 1057 1058 static struct scsi_cmnd *scsi_get_cmd_from_req(struct scsi_device *sdev, 1059 struct request *req) 1060 { 1061 struct scsi_cmnd *cmd; 1062 1063 if (!req->special) { 1064 cmd = scsi_get_command(sdev, GFP_ATOMIC); 1065 if (unlikely(!cmd)) 1066 return NULL; 1067 req->special = cmd; 1068 } else { 1069 cmd = req->special; 1070 } 1071 1072 /* pull a tag out of the request if we have one */ 1073 cmd->tag = req->tag; 1074 cmd->request = req; 1075 1076 cmd->cmnd = req->cmd; 1077 cmd->prot_op = SCSI_PROT_NORMAL; 1078 1079 return cmd; 1080 } 1081 1082 int scsi_setup_blk_pc_cmnd(struct scsi_device *sdev, struct request *req) 1083 { 1084 struct scsi_cmnd *cmd; 1085 int ret = scsi_prep_state_check(sdev, req); 1086 1087 if (ret != BLKPREP_OK) 1088 return ret; 1089 1090 cmd = scsi_get_cmd_from_req(sdev, req); 1091 if (unlikely(!cmd)) 1092 return BLKPREP_DEFER; 1093 1094 /* 1095 * BLOCK_PC requests may transfer data, in which case they must 1096 * a bio attached to them. Or they might contain a SCSI command 1097 * that does not transfer data, in which case they may optionally 1098 * submit a request without an attached bio. 1099 */ 1100 if (req->bio) { 1101 int ret; 1102 1103 BUG_ON(!req->nr_phys_segments); 1104 1105 ret = scsi_init_io(cmd, GFP_ATOMIC); 1106 if (unlikely(ret)) 1107 return ret; 1108 } else { 1109 BUG_ON(blk_rq_bytes(req)); 1110 1111 memset(&cmd->sdb, 0, sizeof(cmd->sdb)); 1112 req->buffer = NULL; 1113 } 1114 1115 cmd->cmd_len = req->cmd_len; 1116 if (!blk_rq_bytes(req)) 1117 cmd->sc_data_direction = DMA_NONE; 1118 else if (rq_data_dir(req) == WRITE) 1119 cmd->sc_data_direction = DMA_TO_DEVICE; 1120 else 1121 cmd->sc_data_direction = DMA_FROM_DEVICE; 1122 1123 cmd->transfersize = blk_rq_bytes(req); 1124 cmd->allowed = req->retries; 1125 return BLKPREP_OK; 1126 } 1127 EXPORT_SYMBOL(scsi_setup_blk_pc_cmnd); 1128 1129 /* 1130 * Setup a REQ_TYPE_FS command. These are simple read/write request 1131 * from filesystems that still need to be translated to SCSI CDBs from 1132 * the ULD. 1133 */ 1134 int scsi_setup_fs_cmnd(struct scsi_device *sdev, struct request *req) 1135 { 1136 struct scsi_cmnd *cmd; 1137 int ret = scsi_prep_state_check(sdev, req); 1138 1139 if (ret != BLKPREP_OK) 1140 return ret; 1141 1142 if (unlikely(sdev->scsi_dh_data && sdev->scsi_dh_data->scsi_dh 1143 && sdev->scsi_dh_data->scsi_dh->prep_fn)) { 1144 ret = sdev->scsi_dh_data->scsi_dh->prep_fn(sdev, req); 1145 if (ret != BLKPREP_OK) 1146 return ret; 1147 } 1148 1149 /* 1150 * Filesystem requests must transfer data. 1151 */ 1152 BUG_ON(!req->nr_phys_segments); 1153 1154 cmd = scsi_get_cmd_from_req(sdev, req); 1155 if (unlikely(!cmd)) 1156 return BLKPREP_DEFER; 1157 1158 memset(cmd->cmnd, 0, BLK_MAX_CDB); 1159 return scsi_init_io(cmd, GFP_ATOMIC); 1160 } 1161 EXPORT_SYMBOL(scsi_setup_fs_cmnd); 1162 1163 int scsi_prep_state_check(struct scsi_device *sdev, struct request *req) 1164 { 1165 int ret = BLKPREP_OK; 1166 1167 /* 1168 * If the device is not in running state we will reject some 1169 * or all commands. 1170 */ 1171 if (unlikely(sdev->sdev_state != SDEV_RUNNING)) { 1172 switch (sdev->sdev_state) { 1173 case SDEV_OFFLINE: 1174 /* 1175 * If the device is offline we refuse to process any 1176 * commands. The device must be brought online 1177 * before trying any recovery commands. 1178 */ 1179 sdev_printk(KERN_ERR, sdev, 1180 "rejecting I/O to offline device\n"); 1181 ret = BLKPREP_KILL; 1182 break; 1183 case SDEV_DEL: 1184 /* 1185 * If the device is fully deleted, we refuse to 1186 * process any commands as well. 1187 */ 1188 sdev_printk(KERN_ERR, sdev, 1189 "rejecting I/O to dead device\n"); 1190 ret = BLKPREP_KILL; 1191 break; 1192 case SDEV_QUIESCE: 1193 case SDEV_BLOCK: 1194 case SDEV_CREATED_BLOCK: 1195 /* 1196 * If the devices is blocked we defer normal commands. 1197 */ 1198 if (!(req->cmd_flags & REQ_PREEMPT)) 1199 ret = BLKPREP_DEFER; 1200 break; 1201 default: 1202 /* 1203 * For any other not fully online state we only allow 1204 * special commands. In particular any user initiated 1205 * command is not allowed. 1206 */ 1207 if (!(req->cmd_flags & REQ_PREEMPT)) 1208 ret = BLKPREP_KILL; 1209 break; 1210 } 1211 } 1212 return ret; 1213 } 1214 EXPORT_SYMBOL(scsi_prep_state_check); 1215 1216 int scsi_prep_return(struct request_queue *q, struct request *req, int ret) 1217 { 1218 struct scsi_device *sdev = q->queuedata; 1219 1220 switch (ret) { 1221 case BLKPREP_KILL: 1222 req->errors = DID_NO_CONNECT << 16; 1223 /* release the command and kill it */ 1224 if (req->special) { 1225 struct scsi_cmnd *cmd = req->special; 1226 scsi_release_buffers(cmd); 1227 scsi_put_command(cmd); 1228 req->special = NULL; 1229 } 1230 break; 1231 case BLKPREP_DEFER: 1232 /* 1233 * If we defer, the blk_peek_request() returns NULL, but the 1234 * queue must be restarted, so we schedule a callback to happen 1235 * shortly. 1236 */ 1237 if (sdev->device_busy == 0) 1238 blk_delay_queue(q, SCSI_QUEUE_DELAY); 1239 break; 1240 default: 1241 req->cmd_flags |= REQ_DONTPREP; 1242 } 1243 1244 return ret; 1245 } 1246 EXPORT_SYMBOL(scsi_prep_return); 1247 1248 int scsi_prep_fn(struct request_queue *q, struct request *req) 1249 { 1250 struct scsi_device *sdev = q->queuedata; 1251 int ret = BLKPREP_KILL; 1252 1253 if (req->cmd_type == REQ_TYPE_BLOCK_PC) 1254 ret = scsi_setup_blk_pc_cmnd(sdev, req); 1255 return scsi_prep_return(q, req, ret); 1256 } 1257 EXPORT_SYMBOL(scsi_prep_fn); 1258 1259 /* 1260 * scsi_dev_queue_ready: if we can send requests to sdev, return 1 else 1261 * return 0. 1262 * 1263 * Called with the queue_lock held. 1264 */ 1265 static inline int scsi_dev_queue_ready(struct request_queue *q, 1266 struct scsi_device *sdev) 1267 { 1268 if (sdev->device_busy == 0 && sdev->device_blocked) { 1269 /* 1270 * unblock after device_blocked iterates to zero 1271 */ 1272 if (--sdev->device_blocked == 0) { 1273 SCSI_LOG_MLQUEUE(3, 1274 sdev_printk(KERN_INFO, sdev, 1275 "unblocking device at zero depth\n")); 1276 } else { 1277 blk_delay_queue(q, SCSI_QUEUE_DELAY); 1278 return 0; 1279 } 1280 } 1281 if (scsi_device_is_busy(sdev)) 1282 return 0; 1283 1284 return 1; 1285 } 1286 1287 1288 /* 1289 * scsi_target_queue_ready: checks if there we can send commands to target 1290 * @sdev: scsi device on starget to check. 1291 * 1292 * Called with the host lock held. 1293 */ 1294 static inline int scsi_target_queue_ready(struct Scsi_Host *shost, 1295 struct scsi_device *sdev) 1296 { 1297 struct scsi_target *starget = scsi_target(sdev); 1298 1299 if (starget->single_lun) { 1300 if (starget->starget_sdev_user && 1301 starget->starget_sdev_user != sdev) 1302 return 0; 1303 starget->starget_sdev_user = sdev; 1304 } 1305 1306 if (starget->target_busy == 0 && starget->target_blocked) { 1307 /* 1308 * unblock after target_blocked iterates to zero 1309 */ 1310 if (--starget->target_blocked == 0) { 1311 SCSI_LOG_MLQUEUE(3, starget_printk(KERN_INFO, starget, 1312 "unblocking target at zero depth\n")); 1313 } else 1314 return 0; 1315 } 1316 1317 if (scsi_target_is_busy(starget)) { 1318 if (list_empty(&sdev->starved_entry)) 1319 list_add_tail(&sdev->starved_entry, 1320 &shost->starved_list); 1321 return 0; 1322 } 1323 1324 /* We're OK to process the command, so we can't be starved */ 1325 if (!list_empty(&sdev->starved_entry)) 1326 list_del_init(&sdev->starved_entry); 1327 return 1; 1328 } 1329 1330 /* 1331 * scsi_host_queue_ready: if we can send requests to shost, return 1 else 1332 * return 0. We must end up running the queue again whenever 0 is 1333 * returned, else IO can hang. 1334 * 1335 * Called with host_lock held. 1336 */ 1337 static inline int scsi_host_queue_ready(struct request_queue *q, 1338 struct Scsi_Host *shost, 1339 struct scsi_device *sdev) 1340 { 1341 if (scsi_host_in_recovery(shost)) 1342 return 0; 1343 if (shost->host_busy == 0 && shost->host_blocked) { 1344 /* 1345 * unblock after host_blocked iterates to zero 1346 */ 1347 if (--shost->host_blocked == 0) { 1348 SCSI_LOG_MLQUEUE(3, 1349 printk("scsi%d unblocking host at zero depth\n", 1350 shost->host_no)); 1351 } else { 1352 return 0; 1353 } 1354 } 1355 if (scsi_host_is_busy(shost)) { 1356 if (list_empty(&sdev->starved_entry)) 1357 list_add_tail(&sdev->starved_entry, &shost->starved_list); 1358 return 0; 1359 } 1360 1361 /* We're OK to process the command, so we can't be starved */ 1362 if (!list_empty(&sdev->starved_entry)) 1363 list_del_init(&sdev->starved_entry); 1364 1365 return 1; 1366 } 1367 1368 /* 1369 * Busy state exporting function for request stacking drivers. 1370 * 1371 * For efficiency, no lock is taken to check the busy state of 1372 * shost/starget/sdev, since the returned value is not guaranteed and 1373 * may be changed after request stacking drivers call the function, 1374 * regardless of taking lock or not. 1375 * 1376 * When scsi can't dispatch I/Os anymore and needs to kill I/Os 1377 * (e.g. !sdev), scsi needs to return 'not busy'. 1378 * Otherwise, request stacking drivers may hold requests forever. 1379 */ 1380 static int scsi_lld_busy(struct request_queue *q) 1381 { 1382 struct scsi_device *sdev = q->queuedata; 1383 struct Scsi_Host *shost; 1384 struct scsi_target *starget; 1385 1386 if (!sdev) 1387 return 0; 1388 1389 shost = sdev->host; 1390 starget = scsi_target(sdev); 1391 1392 if (scsi_host_in_recovery(shost) || scsi_host_is_busy(shost) || 1393 scsi_target_is_busy(starget) || scsi_device_is_busy(sdev)) 1394 return 1; 1395 1396 return 0; 1397 } 1398 1399 /* 1400 * Kill a request for a dead device 1401 */ 1402 static void scsi_kill_request(struct request *req, struct request_queue *q) 1403 { 1404 struct scsi_cmnd *cmd = req->special; 1405 struct scsi_device *sdev; 1406 struct scsi_target *starget; 1407 struct Scsi_Host *shost; 1408 1409 blk_start_request(req); 1410 1411 sdev = cmd->device; 1412 starget = scsi_target(sdev); 1413 shost = sdev->host; 1414 scsi_init_cmd_errh(cmd); 1415 cmd->result = DID_NO_CONNECT << 16; 1416 atomic_inc(&cmd->device->iorequest_cnt); 1417 1418 /* 1419 * SCSI request completion path will do scsi_device_unbusy(), 1420 * bump busy counts. To bump the counters, we need to dance 1421 * with the locks as normal issue path does. 1422 */ 1423 sdev->device_busy++; 1424 spin_unlock(sdev->request_queue->queue_lock); 1425 spin_lock(shost->host_lock); 1426 shost->host_busy++; 1427 starget->target_busy++; 1428 spin_unlock(shost->host_lock); 1429 spin_lock(sdev->request_queue->queue_lock); 1430 1431 blk_complete_request(req); 1432 } 1433 1434 static void scsi_softirq_done(struct request *rq) 1435 { 1436 struct scsi_cmnd *cmd = rq->special; 1437 unsigned long wait_for = (cmd->allowed + 1) * rq->timeout; 1438 int disposition; 1439 1440 INIT_LIST_HEAD(&cmd->eh_entry); 1441 1442 atomic_inc(&cmd->device->iodone_cnt); 1443 if (cmd->result) 1444 atomic_inc(&cmd->device->ioerr_cnt); 1445 1446 disposition = scsi_decide_disposition(cmd); 1447 if (disposition != SUCCESS && 1448 time_before(cmd->jiffies_at_alloc + wait_for, jiffies)) { 1449 sdev_printk(KERN_ERR, cmd->device, 1450 "timing out command, waited %lus\n", 1451 wait_for/HZ); 1452 disposition = SUCCESS; 1453 } 1454 1455 scsi_log_completion(cmd, disposition); 1456 1457 switch (disposition) { 1458 case SUCCESS: 1459 scsi_finish_command(cmd); 1460 break; 1461 case NEEDS_RETRY: 1462 scsi_queue_insert(cmd, SCSI_MLQUEUE_EH_RETRY); 1463 break; 1464 case ADD_TO_MLQUEUE: 1465 scsi_queue_insert(cmd, SCSI_MLQUEUE_DEVICE_BUSY); 1466 break; 1467 default: 1468 if (!scsi_eh_scmd_add(cmd, 0)) 1469 scsi_finish_command(cmd); 1470 } 1471 } 1472 1473 /* 1474 * Function: scsi_request_fn() 1475 * 1476 * Purpose: Main strategy routine for SCSI. 1477 * 1478 * Arguments: q - Pointer to actual queue. 1479 * 1480 * Returns: Nothing 1481 * 1482 * Lock status: IO request lock assumed to be held when called. 1483 */ 1484 static void scsi_request_fn(struct request_queue *q) 1485 { 1486 struct scsi_device *sdev = q->queuedata; 1487 struct Scsi_Host *shost; 1488 struct scsi_cmnd *cmd; 1489 struct request *req; 1490 1491 if (!sdev) { 1492 printk("scsi: killing requests for dead queue\n"); 1493 while ((req = blk_peek_request(q)) != NULL) 1494 scsi_kill_request(req, q); 1495 return; 1496 } 1497 1498 if(!get_device(&sdev->sdev_gendev)) 1499 /* We must be tearing the block queue down already */ 1500 return; 1501 1502 /* 1503 * To start with, we keep looping until the queue is empty, or until 1504 * the host is no longer able to accept any more requests. 1505 */ 1506 shost = sdev->host; 1507 for (;;) { 1508 int rtn; 1509 /* 1510 * get next queueable request. We do this early to make sure 1511 * that the request is fully prepared even if we cannot 1512 * accept it. 1513 */ 1514 req = blk_peek_request(q); 1515 if (!req || !scsi_dev_queue_ready(q, sdev)) 1516 break; 1517 1518 if (unlikely(!scsi_device_online(sdev))) { 1519 sdev_printk(KERN_ERR, sdev, 1520 "rejecting I/O to offline device\n"); 1521 scsi_kill_request(req, q); 1522 continue; 1523 } 1524 1525 1526 /* 1527 * Remove the request from the request list. 1528 */ 1529 if (!(blk_queue_tagged(q) && !blk_queue_start_tag(q, req))) 1530 blk_start_request(req); 1531 sdev->device_busy++; 1532 1533 spin_unlock(q->queue_lock); 1534 cmd = req->special; 1535 if (unlikely(cmd == NULL)) { 1536 printk(KERN_CRIT "impossible request in %s.\n" 1537 "please mail a stack trace to " 1538 "linux-scsi@vger.kernel.org\n", 1539 __func__); 1540 blk_dump_rq_flags(req, "foo"); 1541 BUG(); 1542 } 1543 spin_lock(shost->host_lock); 1544 1545 /* 1546 * We hit this when the driver is using a host wide 1547 * tag map. For device level tag maps the queue_depth check 1548 * in the device ready fn would prevent us from trying 1549 * to allocate a tag. Since the map is a shared host resource 1550 * we add the dev to the starved list so it eventually gets 1551 * a run when a tag is freed. 1552 */ 1553 if (blk_queue_tagged(q) && !blk_rq_tagged(req)) { 1554 if (list_empty(&sdev->starved_entry)) 1555 list_add_tail(&sdev->starved_entry, 1556 &shost->starved_list); 1557 goto not_ready; 1558 } 1559 1560 if (!scsi_target_queue_ready(shost, sdev)) 1561 goto not_ready; 1562 1563 if (!scsi_host_queue_ready(q, shost, sdev)) 1564 goto not_ready; 1565 1566 scsi_target(sdev)->target_busy++; 1567 shost->host_busy++; 1568 1569 /* 1570 * XXX(hch): This is rather suboptimal, scsi_dispatch_cmd will 1571 * take the lock again. 1572 */ 1573 spin_unlock_irq(shost->host_lock); 1574 1575 /* 1576 * Finally, initialize any error handling parameters, and set up 1577 * the timers for timeouts. 1578 */ 1579 scsi_init_cmd_errh(cmd); 1580 1581 /* 1582 * Dispatch the command to the low-level driver. 1583 */ 1584 rtn = scsi_dispatch_cmd(cmd); 1585 spin_lock_irq(q->queue_lock); 1586 if (rtn) 1587 goto out_delay; 1588 } 1589 1590 goto out; 1591 1592 not_ready: 1593 spin_unlock_irq(shost->host_lock); 1594 1595 /* 1596 * lock q, handle tag, requeue req, and decrement device_busy. We 1597 * must return with queue_lock held. 1598 * 1599 * Decrementing device_busy without checking it is OK, as all such 1600 * cases (host limits or settings) should run the queue at some 1601 * later time. 1602 */ 1603 spin_lock_irq(q->queue_lock); 1604 blk_requeue_request(q, req); 1605 sdev->device_busy--; 1606 out_delay: 1607 if (sdev->device_busy == 0) 1608 blk_delay_queue(q, SCSI_QUEUE_DELAY); 1609 out: 1610 /* must be careful here...if we trigger the ->remove() function 1611 * we cannot be holding the q lock */ 1612 spin_unlock_irq(q->queue_lock); 1613 put_device(&sdev->sdev_gendev); 1614 spin_lock_irq(q->queue_lock); 1615 } 1616 1617 u64 scsi_calculate_bounce_limit(struct Scsi_Host *shost) 1618 { 1619 struct device *host_dev; 1620 u64 bounce_limit = 0xffffffff; 1621 1622 if (shost->unchecked_isa_dma) 1623 return BLK_BOUNCE_ISA; 1624 /* 1625 * Platforms with virtual-DMA translation 1626 * hardware have no practical limit. 1627 */ 1628 if (!PCI_DMA_BUS_IS_PHYS) 1629 return BLK_BOUNCE_ANY; 1630 1631 host_dev = scsi_get_device(shost); 1632 if (host_dev && host_dev->dma_mask) 1633 bounce_limit = *host_dev->dma_mask; 1634 1635 return bounce_limit; 1636 } 1637 EXPORT_SYMBOL(scsi_calculate_bounce_limit); 1638 1639 struct request_queue *__scsi_alloc_queue(struct Scsi_Host *shost, 1640 request_fn_proc *request_fn) 1641 { 1642 struct request_queue *q; 1643 struct device *dev = shost->shost_gendev.parent; 1644 1645 q = blk_init_queue(request_fn, NULL); 1646 if (!q) 1647 return NULL; 1648 1649 /* 1650 * this limit is imposed by hardware restrictions 1651 */ 1652 blk_queue_max_segments(q, min_t(unsigned short, shost->sg_tablesize, 1653 SCSI_MAX_SG_CHAIN_SEGMENTS)); 1654 1655 if (scsi_host_prot_dma(shost)) { 1656 shost->sg_prot_tablesize = 1657 min_not_zero(shost->sg_prot_tablesize, 1658 (unsigned short)SCSI_MAX_PROT_SG_SEGMENTS); 1659 BUG_ON(shost->sg_prot_tablesize < shost->sg_tablesize); 1660 blk_queue_max_integrity_segments(q, shost->sg_prot_tablesize); 1661 } 1662 1663 blk_queue_max_hw_sectors(q, shost->max_sectors); 1664 blk_queue_bounce_limit(q, scsi_calculate_bounce_limit(shost)); 1665 blk_queue_segment_boundary(q, shost->dma_boundary); 1666 dma_set_seg_boundary(dev, shost->dma_boundary); 1667 1668 blk_queue_max_segment_size(q, dma_get_max_seg_size(dev)); 1669 1670 if (!shost->use_clustering) 1671 q->limits.cluster = 0; 1672 1673 /* 1674 * set a reasonable default alignment on word boundaries: the 1675 * host and device may alter it using 1676 * blk_queue_update_dma_alignment() later. 1677 */ 1678 blk_queue_dma_alignment(q, 0x03); 1679 1680 return q; 1681 } 1682 EXPORT_SYMBOL(__scsi_alloc_queue); 1683 1684 struct request_queue *scsi_alloc_queue(struct scsi_device *sdev) 1685 { 1686 struct request_queue *q; 1687 1688 q = __scsi_alloc_queue(sdev->host, scsi_request_fn); 1689 if (!q) 1690 return NULL; 1691 1692 blk_queue_prep_rq(q, scsi_prep_fn); 1693 blk_queue_softirq_done(q, scsi_softirq_done); 1694 blk_queue_rq_timed_out(q, scsi_times_out); 1695 blk_queue_lld_busy(q, scsi_lld_busy); 1696 return q; 1697 } 1698 1699 void scsi_free_queue(struct request_queue *q) 1700 { 1701 blk_cleanup_queue(q); 1702 } 1703 1704 /* 1705 * Function: scsi_block_requests() 1706 * 1707 * Purpose: Utility function used by low-level drivers to prevent further 1708 * commands from being queued to the device. 1709 * 1710 * Arguments: shost - Host in question 1711 * 1712 * Returns: Nothing 1713 * 1714 * Lock status: No locks are assumed held. 1715 * 1716 * Notes: There is no timer nor any other means by which the requests 1717 * get unblocked other than the low-level driver calling 1718 * scsi_unblock_requests(). 1719 */ 1720 void scsi_block_requests(struct Scsi_Host *shost) 1721 { 1722 shost->host_self_blocked = 1; 1723 } 1724 EXPORT_SYMBOL(scsi_block_requests); 1725 1726 /* 1727 * Function: scsi_unblock_requests() 1728 * 1729 * Purpose: Utility function used by low-level drivers to allow further 1730 * commands from being queued to the device. 1731 * 1732 * Arguments: shost - Host in question 1733 * 1734 * Returns: Nothing 1735 * 1736 * Lock status: No locks are assumed held. 1737 * 1738 * Notes: There is no timer nor any other means by which the requests 1739 * get unblocked other than the low-level driver calling 1740 * scsi_unblock_requests(). 1741 * 1742 * This is done as an API function so that changes to the 1743 * internals of the scsi mid-layer won't require wholesale 1744 * changes to drivers that use this feature. 1745 */ 1746 void scsi_unblock_requests(struct Scsi_Host *shost) 1747 { 1748 shost->host_self_blocked = 0; 1749 scsi_run_host_queues(shost); 1750 } 1751 EXPORT_SYMBOL(scsi_unblock_requests); 1752 1753 int __init scsi_init_queue(void) 1754 { 1755 int i; 1756 1757 scsi_sdb_cache = kmem_cache_create("scsi_data_buffer", 1758 sizeof(struct scsi_data_buffer), 1759 0, 0, NULL); 1760 if (!scsi_sdb_cache) { 1761 printk(KERN_ERR "SCSI: can't init scsi sdb cache\n"); 1762 return -ENOMEM; 1763 } 1764 1765 for (i = 0; i < SG_MEMPOOL_NR; i++) { 1766 struct scsi_host_sg_pool *sgp = scsi_sg_pools + i; 1767 int size = sgp->size * sizeof(struct scatterlist); 1768 1769 sgp->slab = kmem_cache_create(sgp->name, size, 0, 1770 SLAB_HWCACHE_ALIGN, NULL); 1771 if (!sgp->slab) { 1772 printk(KERN_ERR "SCSI: can't init sg slab %s\n", 1773 sgp->name); 1774 goto cleanup_sdb; 1775 } 1776 1777 sgp->pool = mempool_create_slab_pool(SG_MEMPOOL_SIZE, 1778 sgp->slab); 1779 if (!sgp->pool) { 1780 printk(KERN_ERR "SCSI: can't init sg mempool %s\n", 1781 sgp->name); 1782 goto cleanup_sdb; 1783 } 1784 } 1785 1786 return 0; 1787 1788 cleanup_sdb: 1789 for (i = 0; i < SG_MEMPOOL_NR; i++) { 1790 struct scsi_host_sg_pool *sgp = scsi_sg_pools + i; 1791 if (sgp->pool) 1792 mempool_destroy(sgp->pool); 1793 if (sgp->slab) 1794 kmem_cache_destroy(sgp->slab); 1795 } 1796 kmem_cache_destroy(scsi_sdb_cache); 1797 1798 return -ENOMEM; 1799 } 1800 1801 void scsi_exit_queue(void) 1802 { 1803 int i; 1804 1805 kmem_cache_destroy(scsi_sdb_cache); 1806 1807 for (i = 0; i < SG_MEMPOOL_NR; i++) { 1808 struct scsi_host_sg_pool *sgp = scsi_sg_pools + i; 1809 mempool_destroy(sgp->pool); 1810 kmem_cache_destroy(sgp->slab); 1811 } 1812 } 1813 1814 /** 1815 * scsi_mode_select - issue a mode select 1816 * @sdev: SCSI device to be queried 1817 * @pf: Page format bit (1 == standard, 0 == vendor specific) 1818 * @sp: Save page bit (0 == don't save, 1 == save) 1819 * @modepage: mode page being requested 1820 * @buffer: request buffer (may not be smaller than eight bytes) 1821 * @len: length of request buffer. 1822 * @timeout: command timeout 1823 * @retries: number of retries before failing 1824 * @data: returns a structure abstracting the mode header data 1825 * @sshdr: place to put sense data (or NULL if no sense to be collected). 1826 * must be SCSI_SENSE_BUFFERSIZE big. 1827 * 1828 * Returns zero if successful; negative error number or scsi 1829 * status on error 1830 * 1831 */ 1832 int 1833 scsi_mode_select(struct scsi_device *sdev, int pf, int sp, int modepage, 1834 unsigned char *buffer, int len, int timeout, int retries, 1835 struct scsi_mode_data *data, struct scsi_sense_hdr *sshdr) 1836 { 1837 unsigned char cmd[10]; 1838 unsigned char *real_buffer; 1839 int ret; 1840 1841 memset(cmd, 0, sizeof(cmd)); 1842 cmd[1] = (pf ? 0x10 : 0) | (sp ? 0x01 : 0); 1843 1844 if (sdev->use_10_for_ms) { 1845 if (len > 65535) 1846 return -EINVAL; 1847 real_buffer = kmalloc(8 + len, GFP_KERNEL); 1848 if (!real_buffer) 1849 return -ENOMEM; 1850 memcpy(real_buffer + 8, buffer, len); 1851 len += 8; 1852 real_buffer[0] = 0; 1853 real_buffer[1] = 0; 1854 real_buffer[2] = data->medium_type; 1855 real_buffer[3] = data->device_specific; 1856 real_buffer[4] = data->longlba ? 0x01 : 0; 1857 real_buffer[5] = 0; 1858 real_buffer[6] = data->block_descriptor_length >> 8; 1859 real_buffer[7] = data->block_descriptor_length; 1860 1861 cmd[0] = MODE_SELECT_10; 1862 cmd[7] = len >> 8; 1863 cmd[8] = len; 1864 } else { 1865 if (len > 255 || data->block_descriptor_length > 255 || 1866 data->longlba) 1867 return -EINVAL; 1868 1869 real_buffer = kmalloc(4 + len, GFP_KERNEL); 1870 if (!real_buffer) 1871 return -ENOMEM; 1872 memcpy(real_buffer + 4, buffer, len); 1873 len += 4; 1874 real_buffer[0] = 0; 1875 real_buffer[1] = data->medium_type; 1876 real_buffer[2] = data->device_specific; 1877 real_buffer[3] = data->block_descriptor_length; 1878 1879 1880 cmd[0] = MODE_SELECT; 1881 cmd[4] = len; 1882 } 1883 1884 ret = scsi_execute_req(sdev, cmd, DMA_TO_DEVICE, real_buffer, len, 1885 sshdr, timeout, retries, NULL); 1886 kfree(real_buffer); 1887 return ret; 1888 } 1889 EXPORT_SYMBOL_GPL(scsi_mode_select); 1890 1891 /** 1892 * scsi_mode_sense - issue a mode sense, falling back from 10 to six bytes if necessary. 1893 * @sdev: SCSI device to be queried 1894 * @dbd: set if mode sense will allow block descriptors to be returned 1895 * @modepage: mode page being requested 1896 * @buffer: request buffer (may not be smaller than eight bytes) 1897 * @len: length of request buffer. 1898 * @timeout: command timeout 1899 * @retries: number of retries before failing 1900 * @data: returns a structure abstracting the mode header data 1901 * @sshdr: place to put sense data (or NULL if no sense to be collected). 1902 * must be SCSI_SENSE_BUFFERSIZE big. 1903 * 1904 * Returns zero if unsuccessful, or the header offset (either 4 1905 * or 8 depending on whether a six or ten byte command was 1906 * issued) if successful. 1907 */ 1908 int 1909 scsi_mode_sense(struct scsi_device *sdev, int dbd, int modepage, 1910 unsigned char *buffer, int len, int timeout, int retries, 1911 struct scsi_mode_data *data, struct scsi_sense_hdr *sshdr) 1912 { 1913 unsigned char cmd[12]; 1914 int use_10_for_ms; 1915 int header_length; 1916 int result; 1917 struct scsi_sense_hdr my_sshdr; 1918 1919 memset(data, 0, sizeof(*data)); 1920 memset(&cmd[0], 0, 12); 1921 cmd[1] = dbd & 0x18; /* allows DBD and LLBA bits */ 1922 cmd[2] = modepage; 1923 1924 /* caller might not be interested in sense, but we need it */ 1925 if (!sshdr) 1926 sshdr = &my_sshdr; 1927 1928 retry: 1929 use_10_for_ms = sdev->use_10_for_ms; 1930 1931 if (use_10_for_ms) { 1932 if (len < 8) 1933 len = 8; 1934 1935 cmd[0] = MODE_SENSE_10; 1936 cmd[8] = len; 1937 header_length = 8; 1938 } else { 1939 if (len < 4) 1940 len = 4; 1941 1942 cmd[0] = MODE_SENSE; 1943 cmd[4] = len; 1944 header_length = 4; 1945 } 1946 1947 memset(buffer, 0, len); 1948 1949 result = scsi_execute_req(sdev, cmd, DMA_FROM_DEVICE, buffer, len, 1950 sshdr, timeout, retries, NULL); 1951 1952 /* This code looks awful: what it's doing is making sure an 1953 * ILLEGAL REQUEST sense return identifies the actual command 1954 * byte as the problem. MODE_SENSE commands can return 1955 * ILLEGAL REQUEST if the code page isn't supported */ 1956 1957 if (use_10_for_ms && !scsi_status_is_good(result) && 1958 (driver_byte(result) & DRIVER_SENSE)) { 1959 if (scsi_sense_valid(sshdr)) { 1960 if ((sshdr->sense_key == ILLEGAL_REQUEST) && 1961 (sshdr->asc == 0x20) && (sshdr->ascq == 0)) { 1962 /* 1963 * Invalid command operation code 1964 */ 1965 sdev->use_10_for_ms = 0; 1966 goto retry; 1967 } 1968 } 1969 } 1970 1971 if(scsi_status_is_good(result)) { 1972 if (unlikely(buffer[0] == 0x86 && buffer[1] == 0x0b && 1973 (modepage == 6 || modepage == 8))) { 1974 /* Initio breakage? */ 1975 header_length = 0; 1976 data->length = 13; 1977 data->medium_type = 0; 1978 data->device_specific = 0; 1979 data->longlba = 0; 1980 data->block_descriptor_length = 0; 1981 } else if(use_10_for_ms) { 1982 data->length = buffer[0]*256 + buffer[1] + 2; 1983 data->medium_type = buffer[2]; 1984 data->device_specific = buffer[3]; 1985 data->longlba = buffer[4] & 0x01; 1986 data->block_descriptor_length = buffer[6]*256 1987 + buffer[7]; 1988 } else { 1989 data->length = buffer[0] + 1; 1990 data->medium_type = buffer[1]; 1991 data->device_specific = buffer[2]; 1992 data->block_descriptor_length = buffer[3]; 1993 } 1994 data->header_length = header_length; 1995 } 1996 1997 return result; 1998 } 1999 EXPORT_SYMBOL(scsi_mode_sense); 2000 2001 /** 2002 * scsi_test_unit_ready - test if unit is ready 2003 * @sdev: scsi device to change the state of. 2004 * @timeout: command timeout 2005 * @retries: number of retries before failing 2006 * @sshdr_external: Optional pointer to struct scsi_sense_hdr for 2007 * returning sense. Make sure that this is cleared before passing 2008 * in. 2009 * 2010 * Returns zero if unsuccessful or an error if TUR failed. For 2011 * removable media, UNIT_ATTENTION sets ->changed flag. 2012 **/ 2013 int 2014 scsi_test_unit_ready(struct scsi_device *sdev, int timeout, int retries, 2015 struct scsi_sense_hdr *sshdr_external) 2016 { 2017 char cmd[] = { 2018 TEST_UNIT_READY, 0, 0, 0, 0, 0, 2019 }; 2020 struct scsi_sense_hdr *sshdr; 2021 int result; 2022 2023 if (!sshdr_external) 2024 sshdr = kzalloc(sizeof(*sshdr), GFP_KERNEL); 2025 else 2026 sshdr = sshdr_external; 2027 2028 /* try to eat the UNIT_ATTENTION if there are enough retries */ 2029 do { 2030 result = scsi_execute_req(sdev, cmd, DMA_NONE, NULL, 0, sshdr, 2031 timeout, retries, NULL); 2032 if (sdev->removable && scsi_sense_valid(sshdr) && 2033 sshdr->sense_key == UNIT_ATTENTION) 2034 sdev->changed = 1; 2035 } while (scsi_sense_valid(sshdr) && 2036 sshdr->sense_key == UNIT_ATTENTION && --retries); 2037 2038 if (!sshdr_external) 2039 kfree(sshdr); 2040 return result; 2041 } 2042 EXPORT_SYMBOL(scsi_test_unit_ready); 2043 2044 /** 2045 * scsi_device_set_state - Take the given device through the device state model. 2046 * @sdev: scsi device to change the state of. 2047 * @state: state to change to. 2048 * 2049 * Returns zero if unsuccessful or an error if the requested 2050 * transition is illegal. 2051 */ 2052 int 2053 scsi_device_set_state(struct scsi_device *sdev, enum scsi_device_state state) 2054 { 2055 enum scsi_device_state oldstate = sdev->sdev_state; 2056 2057 if (state == oldstate) 2058 return 0; 2059 2060 switch (state) { 2061 case SDEV_CREATED: 2062 switch (oldstate) { 2063 case SDEV_CREATED_BLOCK: 2064 break; 2065 default: 2066 goto illegal; 2067 } 2068 break; 2069 2070 case SDEV_RUNNING: 2071 switch (oldstate) { 2072 case SDEV_CREATED: 2073 case SDEV_OFFLINE: 2074 case SDEV_QUIESCE: 2075 case SDEV_BLOCK: 2076 break; 2077 default: 2078 goto illegal; 2079 } 2080 break; 2081 2082 case SDEV_QUIESCE: 2083 switch (oldstate) { 2084 case SDEV_RUNNING: 2085 case SDEV_OFFLINE: 2086 break; 2087 default: 2088 goto illegal; 2089 } 2090 break; 2091 2092 case SDEV_OFFLINE: 2093 switch (oldstate) { 2094 case SDEV_CREATED: 2095 case SDEV_RUNNING: 2096 case SDEV_QUIESCE: 2097 case SDEV_BLOCK: 2098 break; 2099 default: 2100 goto illegal; 2101 } 2102 break; 2103 2104 case SDEV_BLOCK: 2105 switch (oldstate) { 2106 case SDEV_RUNNING: 2107 case SDEV_CREATED_BLOCK: 2108 break; 2109 default: 2110 goto illegal; 2111 } 2112 break; 2113 2114 case SDEV_CREATED_BLOCK: 2115 switch (oldstate) { 2116 case SDEV_CREATED: 2117 break; 2118 default: 2119 goto illegal; 2120 } 2121 break; 2122 2123 case SDEV_CANCEL: 2124 switch (oldstate) { 2125 case SDEV_CREATED: 2126 case SDEV_RUNNING: 2127 case SDEV_QUIESCE: 2128 case SDEV_OFFLINE: 2129 case SDEV_BLOCK: 2130 break; 2131 default: 2132 goto illegal; 2133 } 2134 break; 2135 2136 case SDEV_DEL: 2137 switch (oldstate) { 2138 case SDEV_CREATED: 2139 case SDEV_RUNNING: 2140 case SDEV_OFFLINE: 2141 case SDEV_CANCEL: 2142 break; 2143 default: 2144 goto illegal; 2145 } 2146 break; 2147 2148 } 2149 sdev->sdev_state = state; 2150 return 0; 2151 2152 illegal: 2153 SCSI_LOG_ERROR_RECOVERY(1, 2154 sdev_printk(KERN_ERR, sdev, 2155 "Illegal state transition %s->%s\n", 2156 scsi_device_state_name(oldstate), 2157 scsi_device_state_name(state)) 2158 ); 2159 return -EINVAL; 2160 } 2161 EXPORT_SYMBOL(scsi_device_set_state); 2162 2163 /** 2164 * sdev_evt_emit - emit a single SCSI device uevent 2165 * @sdev: associated SCSI device 2166 * @evt: event to emit 2167 * 2168 * Send a single uevent (scsi_event) to the associated scsi_device. 2169 */ 2170 static void scsi_evt_emit(struct scsi_device *sdev, struct scsi_event *evt) 2171 { 2172 int idx = 0; 2173 char *envp[3]; 2174 2175 switch (evt->evt_type) { 2176 case SDEV_EVT_MEDIA_CHANGE: 2177 envp[idx++] = "SDEV_MEDIA_CHANGE=1"; 2178 break; 2179 2180 default: 2181 /* do nothing */ 2182 break; 2183 } 2184 2185 envp[idx++] = NULL; 2186 2187 kobject_uevent_env(&sdev->sdev_gendev.kobj, KOBJ_CHANGE, envp); 2188 } 2189 2190 /** 2191 * sdev_evt_thread - send a uevent for each scsi event 2192 * @work: work struct for scsi_device 2193 * 2194 * Dispatch queued events to their associated scsi_device kobjects 2195 * as uevents. 2196 */ 2197 void scsi_evt_thread(struct work_struct *work) 2198 { 2199 struct scsi_device *sdev; 2200 LIST_HEAD(event_list); 2201 2202 sdev = container_of(work, struct scsi_device, event_work); 2203 2204 while (1) { 2205 struct scsi_event *evt; 2206 struct list_head *this, *tmp; 2207 unsigned long flags; 2208 2209 spin_lock_irqsave(&sdev->list_lock, flags); 2210 list_splice_init(&sdev->event_list, &event_list); 2211 spin_unlock_irqrestore(&sdev->list_lock, flags); 2212 2213 if (list_empty(&event_list)) 2214 break; 2215 2216 list_for_each_safe(this, tmp, &event_list) { 2217 evt = list_entry(this, struct scsi_event, node); 2218 list_del(&evt->node); 2219 scsi_evt_emit(sdev, evt); 2220 kfree(evt); 2221 } 2222 } 2223 } 2224 2225 /** 2226 * sdev_evt_send - send asserted event to uevent thread 2227 * @sdev: scsi_device event occurred on 2228 * @evt: event to send 2229 * 2230 * Assert scsi device event asynchronously. 2231 */ 2232 void sdev_evt_send(struct scsi_device *sdev, struct scsi_event *evt) 2233 { 2234 unsigned long flags; 2235 2236 #if 0 2237 /* FIXME: currently this check eliminates all media change events 2238 * for polled devices. Need to update to discriminate between AN 2239 * and polled events */ 2240 if (!test_bit(evt->evt_type, sdev->supported_events)) { 2241 kfree(evt); 2242 return; 2243 } 2244 #endif 2245 2246 spin_lock_irqsave(&sdev->list_lock, flags); 2247 list_add_tail(&evt->node, &sdev->event_list); 2248 schedule_work(&sdev->event_work); 2249 spin_unlock_irqrestore(&sdev->list_lock, flags); 2250 } 2251 EXPORT_SYMBOL_GPL(sdev_evt_send); 2252 2253 /** 2254 * sdev_evt_alloc - allocate a new scsi event 2255 * @evt_type: type of event to allocate 2256 * @gfpflags: GFP flags for allocation 2257 * 2258 * Allocates and returns a new scsi_event. 2259 */ 2260 struct scsi_event *sdev_evt_alloc(enum scsi_device_event evt_type, 2261 gfp_t gfpflags) 2262 { 2263 struct scsi_event *evt = kzalloc(sizeof(struct scsi_event), gfpflags); 2264 if (!evt) 2265 return NULL; 2266 2267 evt->evt_type = evt_type; 2268 INIT_LIST_HEAD(&evt->node); 2269 2270 /* evt_type-specific initialization, if any */ 2271 switch (evt_type) { 2272 case SDEV_EVT_MEDIA_CHANGE: 2273 default: 2274 /* do nothing */ 2275 break; 2276 } 2277 2278 return evt; 2279 } 2280 EXPORT_SYMBOL_GPL(sdev_evt_alloc); 2281 2282 /** 2283 * sdev_evt_send_simple - send asserted event to uevent thread 2284 * @sdev: scsi_device event occurred on 2285 * @evt_type: type of event to send 2286 * @gfpflags: GFP flags for allocation 2287 * 2288 * Assert scsi device event asynchronously, given an event type. 2289 */ 2290 void sdev_evt_send_simple(struct scsi_device *sdev, 2291 enum scsi_device_event evt_type, gfp_t gfpflags) 2292 { 2293 struct scsi_event *evt = sdev_evt_alloc(evt_type, gfpflags); 2294 if (!evt) { 2295 sdev_printk(KERN_ERR, sdev, "event %d eaten due to OOM\n", 2296 evt_type); 2297 return; 2298 } 2299 2300 sdev_evt_send(sdev, evt); 2301 } 2302 EXPORT_SYMBOL_GPL(sdev_evt_send_simple); 2303 2304 /** 2305 * scsi_device_quiesce - Block user issued commands. 2306 * @sdev: scsi device to quiesce. 2307 * 2308 * This works by trying to transition to the SDEV_QUIESCE state 2309 * (which must be a legal transition). When the device is in this 2310 * state, only special requests will be accepted, all others will 2311 * be deferred. Since special requests may also be requeued requests, 2312 * a successful return doesn't guarantee the device will be 2313 * totally quiescent. 2314 * 2315 * Must be called with user context, may sleep. 2316 * 2317 * Returns zero if unsuccessful or an error if not. 2318 */ 2319 int 2320 scsi_device_quiesce(struct scsi_device *sdev) 2321 { 2322 int err = scsi_device_set_state(sdev, SDEV_QUIESCE); 2323 if (err) 2324 return err; 2325 2326 scsi_run_queue(sdev->request_queue); 2327 while (sdev->device_busy) { 2328 msleep_interruptible(200); 2329 scsi_run_queue(sdev->request_queue); 2330 } 2331 return 0; 2332 } 2333 EXPORT_SYMBOL(scsi_device_quiesce); 2334 2335 /** 2336 * scsi_device_resume - Restart user issued commands to a quiesced device. 2337 * @sdev: scsi device to resume. 2338 * 2339 * Moves the device from quiesced back to running and restarts the 2340 * queues. 2341 * 2342 * Must be called with user context, may sleep. 2343 */ 2344 void 2345 scsi_device_resume(struct scsi_device *sdev) 2346 { 2347 if(scsi_device_set_state(sdev, SDEV_RUNNING)) 2348 return; 2349 scsi_run_queue(sdev->request_queue); 2350 } 2351 EXPORT_SYMBOL(scsi_device_resume); 2352 2353 static void 2354 device_quiesce_fn(struct scsi_device *sdev, void *data) 2355 { 2356 scsi_device_quiesce(sdev); 2357 } 2358 2359 void 2360 scsi_target_quiesce(struct scsi_target *starget) 2361 { 2362 starget_for_each_device(starget, NULL, device_quiesce_fn); 2363 } 2364 EXPORT_SYMBOL(scsi_target_quiesce); 2365 2366 static void 2367 device_resume_fn(struct scsi_device *sdev, void *data) 2368 { 2369 scsi_device_resume(sdev); 2370 } 2371 2372 void 2373 scsi_target_resume(struct scsi_target *starget) 2374 { 2375 starget_for_each_device(starget, NULL, device_resume_fn); 2376 } 2377 EXPORT_SYMBOL(scsi_target_resume); 2378 2379 /** 2380 * scsi_internal_device_block - internal function to put a device temporarily into the SDEV_BLOCK state 2381 * @sdev: device to block 2382 * 2383 * Block request made by scsi lld's to temporarily stop all 2384 * scsi commands on the specified device. Called from interrupt 2385 * or normal process context. 2386 * 2387 * Returns zero if successful or error if not 2388 * 2389 * Notes: 2390 * This routine transitions the device to the SDEV_BLOCK state 2391 * (which must be a legal transition). When the device is in this 2392 * state, all commands are deferred until the scsi lld reenables 2393 * the device with scsi_device_unblock or device_block_tmo fires. 2394 * This routine assumes the host_lock is held on entry. 2395 */ 2396 int 2397 scsi_internal_device_block(struct scsi_device *sdev) 2398 { 2399 struct request_queue *q = sdev->request_queue; 2400 unsigned long flags; 2401 int err = 0; 2402 2403 err = scsi_device_set_state(sdev, SDEV_BLOCK); 2404 if (err) { 2405 err = scsi_device_set_state(sdev, SDEV_CREATED_BLOCK); 2406 2407 if (err) 2408 return err; 2409 } 2410 2411 /* 2412 * The device has transitioned to SDEV_BLOCK. Stop the 2413 * block layer from calling the midlayer with this device's 2414 * request queue. 2415 */ 2416 spin_lock_irqsave(q->queue_lock, flags); 2417 blk_stop_queue(q); 2418 spin_unlock_irqrestore(q->queue_lock, flags); 2419 2420 return 0; 2421 } 2422 EXPORT_SYMBOL_GPL(scsi_internal_device_block); 2423 2424 /** 2425 * scsi_internal_device_unblock - resume a device after a block request 2426 * @sdev: device to resume 2427 * 2428 * Called by scsi lld's or the midlayer to restart the device queue 2429 * for the previously suspended scsi device. Called from interrupt or 2430 * normal process context. 2431 * 2432 * Returns zero if successful or error if not. 2433 * 2434 * Notes: 2435 * This routine transitions the device to the SDEV_RUNNING state 2436 * (which must be a legal transition) allowing the midlayer to 2437 * goose the queue for this device. This routine assumes the 2438 * host_lock is held upon entry. 2439 */ 2440 int 2441 scsi_internal_device_unblock(struct scsi_device *sdev) 2442 { 2443 struct request_queue *q = sdev->request_queue; 2444 unsigned long flags; 2445 2446 /* 2447 * Try to transition the scsi device to SDEV_RUNNING 2448 * and goose the device queue if successful. 2449 */ 2450 if (sdev->sdev_state == SDEV_BLOCK) 2451 sdev->sdev_state = SDEV_RUNNING; 2452 else if (sdev->sdev_state == SDEV_CREATED_BLOCK) 2453 sdev->sdev_state = SDEV_CREATED; 2454 else if (sdev->sdev_state != SDEV_CANCEL && 2455 sdev->sdev_state != SDEV_OFFLINE) 2456 return -EINVAL; 2457 2458 spin_lock_irqsave(q->queue_lock, flags); 2459 blk_start_queue(q); 2460 spin_unlock_irqrestore(q->queue_lock, flags); 2461 2462 return 0; 2463 } 2464 EXPORT_SYMBOL_GPL(scsi_internal_device_unblock); 2465 2466 static void 2467 device_block(struct scsi_device *sdev, void *data) 2468 { 2469 scsi_internal_device_block(sdev); 2470 } 2471 2472 static int 2473 target_block(struct device *dev, void *data) 2474 { 2475 if (scsi_is_target_device(dev)) 2476 starget_for_each_device(to_scsi_target(dev), NULL, 2477 device_block); 2478 return 0; 2479 } 2480 2481 void 2482 scsi_target_block(struct device *dev) 2483 { 2484 if (scsi_is_target_device(dev)) 2485 starget_for_each_device(to_scsi_target(dev), NULL, 2486 device_block); 2487 else 2488 device_for_each_child(dev, NULL, target_block); 2489 } 2490 EXPORT_SYMBOL_GPL(scsi_target_block); 2491 2492 static void 2493 device_unblock(struct scsi_device *sdev, void *data) 2494 { 2495 scsi_internal_device_unblock(sdev); 2496 } 2497 2498 static int 2499 target_unblock(struct device *dev, void *data) 2500 { 2501 if (scsi_is_target_device(dev)) 2502 starget_for_each_device(to_scsi_target(dev), NULL, 2503 device_unblock); 2504 return 0; 2505 } 2506 2507 void 2508 scsi_target_unblock(struct device *dev) 2509 { 2510 if (scsi_is_target_device(dev)) 2511 starget_for_each_device(to_scsi_target(dev), NULL, 2512 device_unblock); 2513 else 2514 device_for_each_child(dev, NULL, target_unblock); 2515 } 2516 EXPORT_SYMBOL_GPL(scsi_target_unblock); 2517 2518 /** 2519 * scsi_kmap_atomic_sg - find and atomically map an sg-elemnt 2520 * @sgl: scatter-gather list 2521 * @sg_count: number of segments in sg 2522 * @offset: offset in bytes into sg, on return offset into the mapped area 2523 * @len: bytes to map, on return number of bytes mapped 2524 * 2525 * Returns virtual address of the start of the mapped page 2526 */ 2527 void *scsi_kmap_atomic_sg(struct scatterlist *sgl, int sg_count, 2528 size_t *offset, size_t *len) 2529 { 2530 int i; 2531 size_t sg_len = 0, len_complete = 0; 2532 struct scatterlist *sg; 2533 struct page *page; 2534 2535 WARN_ON(!irqs_disabled()); 2536 2537 for_each_sg(sgl, sg, sg_count, i) { 2538 len_complete = sg_len; /* Complete sg-entries */ 2539 sg_len += sg->length; 2540 if (sg_len > *offset) 2541 break; 2542 } 2543 2544 if (unlikely(i == sg_count)) { 2545 printk(KERN_ERR "%s: Bytes in sg: %zu, requested offset %zu, " 2546 "elements %d\n", 2547 __func__, sg_len, *offset, sg_count); 2548 WARN_ON(1); 2549 return NULL; 2550 } 2551 2552 /* Offset starting from the beginning of first page in this sg-entry */ 2553 *offset = *offset - len_complete + sg->offset; 2554 2555 /* Assumption: contiguous pages can be accessed as "page + i" */ 2556 page = nth_page(sg_page(sg), (*offset >> PAGE_SHIFT)); 2557 *offset &= ~PAGE_MASK; 2558 2559 /* Bytes in this sg-entry from *offset to the end of the page */ 2560 sg_len = PAGE_SIZE - *offset; 2561 if (*len > sg_len) 2562 *len = sg_len; 2563 2564 return kmap_atomic(page, KM_BIO_SRC_IRQ); 2565 } 2566 EXPORT_SYMBOL(scsi_kmap_atomic_sg); 2567 2568 /** 2569 * scsi_kunmap_atomic_sg - atomically unmap a virtual address, previously mapped with scsi_kmap_atomic_sg 2570 * @virt: virtual address to be unmapped 2571 */ 2572 void scsi_kunmap_atomic_sg(void *virt) 2573 { 2574 kunmap_atomic(virt, KM_BIO_SRC_IRQ); 2575 } 2576 EXPORT_SYMBOL(scsi_kunmap_atomic_sg); 2577