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