scsi_lib.c revision bb1d1073a10fdc8547e3eb821ee2488260094b39
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/blkdev.h> 12#include <linux/completion.h> 13#include <linux/kernel.h> 14#include <linux/mempool.h> 15#include <linux/slab.h> 16#include <linux/init.h> 17#include <linux/pci.h> 18#include <linux/delay.h> 19 20#include <scsi/scsi.h> 21#include <scsi/scsi_dbg.h> 22#include <scsi/scsi_device.h> 23#include <scsi/scsi_driver.h> 24#include <scsi/scsi_eh.h> 25#include <scsi/scsi_host.h> 26#include <scsi/scsi_request.h> 27 28#include "scsi_priv.h" 29#include "scsi_logging.h" 30 31 32#define SG_MEMPOOL_NR (sizeof(scsi_sg_pools)/sizeof(struct scsi_host_sg_pool)) 33#define SG_MEMPOOL_SIZE 32 34 35struct scsi_host_sg_pool { 36 size_t size; 37 char *name; 38 kmem_cache_t *slab; 39 mempool_t *pool; 40}; 41 42#if (SCSI_MAX_PHYS_SEGMENTS < 32) 43#error SCSI_MAX_PHYS_SEGMENTS is too small 44#endif 45 46#define SP(x) { x, "sgpool-" #x } 47static struct scsi_host_sg_pool scsi_sg_pools[] = { 48 SP(8), 49 SP(16), 50 SP(32), 51#if (SCSI_MAX_PHYS_SEGMENTS > 32) 52 SP(64), 53#if (SCSI_MAX_PHYS_SEGMENTS > 64) 54 SP(128), 55#if (SCSI_MAX_PHYS_SEGMENTS > 128) 56 SP(256), 57#if (SCSI_MAX_PHYS_SEGMENTS > 256) 58#error SCSI_MAX_PHYS_SEGMENTS is too large 59#endif 60#endif 61#endif 62#endif 63}; 64#undef SP 65 66static void scsi_run_queue(struct request_queue *q); 67 68/* 69 * Function: scsi_unprep_request() 70 * 71 * Purpose: Remove all preparation done for a request, including its 72 * associated scsi_cmnd, so that it can be requeued. 73 * 74 * Arguments: req - request to unprepare 75 * 76 * Lock status: Assumed that no locks are held upon entry. 77 * 78 * Returns: Nothing. 79 */ 80static void scsi_unprep_request(struct request *req) 81{ 82 struct scsi_cmnd *cmd = req->special; 83 84 req->flags &= ~REQ_DONTPREP; 85 req->special = (req->flags & REQ_SPECIAL) ? cmd->sc_request : NULL; 86 87 scsi_put_command(cmd); 88} 89 90/* 91 * Function: scsi_queue_insert() 92 * 93 * Purpose: Insert a command in the midlevel queue. 94 * 95 * Arguments: cmd - command that we are adding to queue. 96 * reason - why we are inserting command to queue. 97 * 98 * Lock status: Assumed that lock is not held upon entry. 99 * 100 * Returns: Nothing. 101 * 102 * Notes: We do this for one of two cases. Either the host is busy 103 * and it cannot accept any more commands for the time being, 104 * or the device returned QUEUE_FULL and can accept no more 105 * commands. 106 * Notes: This could be called either from an interrupt context or a 107 * normal process context. 108 */ 109int scsi_queue_insert(struct scsi_cmnd *cmd, int reason) 110{ 111 struct Scsi_Host *host = cmd->device->host; 112 struct scsi_device *device = cmd->device; 113 struct request_queue *q = device->request_queue; 114 unsigned long flags; 115 116 SCSI_LOG_MLQUEUE(1, 117 printk("Inserting command %p into mlqueue\n", cmd)); 118 119 /* 120 * Set the appropriate busy bit for the device/host. 121 * 122 * If the host/device isn't busy, assume that something actually 123 * completed, and that we should be able to queue a command now. 124 * 125 * Note that the prior mid-layer assumption that any host could 126 * always queue at least one command is now broken. The mid-layer 127 * will implement a user specifiable stall (see 128 * scsi_host.max_host_blocked and scsi_device.max_device_blocked) 129 * if a command is requeued with no other commands outstanding 130 * either for the device or for the host. 131 */ 132 if (reason == SCSI_MLQUEUE_HOST_BUSY) 133 host->host_blocked = host->max_host_blocked; 134 else if (reason == SCSI_MLQUEUE_DEVICE_BUSY) 135 device->device_blocked = device->max_device_blocked; 136 137 /* 138 * Decrement the counters, since these commands are no longer 139 * active on the host/device. 140 */ 141 scsi_device_unbusy(device); 142 143 /* 144 * Requeue this command. It will go before all other commands 145 * that are already in the queue. 146 * 147 * NOTE: there is magic here about the way the queue is plugged if 148 * we have no outstanding commands. 149 * 150 * Although we *don't* plug the queue, we call the request 151 * function. The SCSI request function detects the blocked condition 152 * and plugs the queue appropriately. 153 */ 154 spin_lock_irqsave(q->queue_lock, flags); 155 blk_requeue_request(q, cmd->request); 156 spin_unlock_irqrestore(q->queue_lock, flags); 157 158 scsi_run_queue(q); 159 160 return 0; 161} 162 163/* 164 * Function: scsi_do_req 165 * 166 * Purpose: Queue a SCSI request 167 * 168 * Arguments: sreq - command descriptor. 169 * cmnd - actual SCSI command to be performed. 170 * buffer - data buffer. 171 * bufflen - size of data buffer. 172 * done - completion function to be run. 173 * timeout - how long to let it run before timeout. 174 * retries - number of retries we allow. 175 * 176 * Lock status: No locks held upon entry. 177 * 178 * Returns: Nothing. 179 * 180 * Notes: This function is only used for queueing requests for things 181 * like ioctls and character device requests - this is because 182 * we essentially just inject a request into the queue for the 183 * device. 184 * 185 * In order to support the scsi_device_quiesce function, we 186 * now inject requests on the *head* of the device queue 187 * rather than the tail. 188 */ 189void scsi_do_req(struct scsi_request *sreq, const void *cmnd, 190 void *buffer, unsigned bufflen, 191 void (*done)(struct scsi_cmnd *), 192 int timeout, int retries) 193{ 194 /* 195 * If the upper level driver is reusing these things, then 196 * we should release the low-level block now. Another one will 197 * be allocated later when this request is getting queued. 198 */ 199 __scsi_release_request(sreq); 200 201 /* 202 * Our own function scsi_done (which marks the host as not busy, 203 * disables the timeout counter, etc) will be called by us or by the 204 * scsi_hosts[host].queuecommand() function needs to also call 205 * the completion function for the high level driver. 206 */ 207 memcpy(sreq->sr_cmnd, cmnd, sizeof(sreq->sr_cmnd)); 208 sreq->sr_bufflen = bufflen; 209 sreq->sr_buffer = buffer; 210 sreq->sr_allowed = retries; 211 sreq->sr_done = done; 212 sreq->sr_timeout_per_command = timeout; 213 214 if (sreq->sr_cmd_len == 0) 215 sreq->sr_cmd_len = COMMAND_SIZE(sreq->sr_cmnd[0]); 216 217 /* 218 * head injection *required* here otherwise quiesce won't work 219 * 220 * Because users of this function are apt to reuse requests with no 221 * modification, we have to sanitise the request flags here 222 */ 223 sreq->sr_request->flags &= ~REQ_DONTPREP; 224 blk_insert_request(sreq->sr_device->request_queue, sreq->sr_request, 225 1, sreq); 226} 227EXPORT_SYMBOL(scsi_do_req); 228 229/** 230 * scsi_execute - insert request and wait for the result 231 * @sdev: scsi device 232 * @cmd: scsi command 233 * @data_direction: data direction 234 * @buffer: data buffer 235 * @bufflen: len of buffer 236 * @sense: optional sense buffer 237 * @timeout: request timeout in seconds 238 * @retries: number of times to retry request 239 * @flags: or into request flags; 240 * 241 * returns the req->errors value which is the the scsi_cmnd result 242 * field. 243 **/ 244int scsi_execute(struct scsi_device *sdev, const unsigned char *cmd, 245 int data_direction, void *buffer, unsigned bufflen, 246 unsigned char *sense, int timeout, int retries, int flags) 247{ 248 struct request *req; 249 int write = (data_direction == DMA_TO_DEVICE); 250 int ret = DRIVER_ERROR << 24; 251 252 req = blk_get_request(sdev->request_queue, write, __GFP_WAIT); 253 254 if (bufflen && blk_rq_map_kern(sdev->request_queue, req, 255 buffer, bufflen, __GFP_WAIT)) 256 goto out; 257 258 req->cmd_len = COMMAND_SIZE(cmd[0]); 259 memcpy(req->cmd, cmd, req->cmd_len); 260 req->sense = sense; 261 req->sense_len = 0; 262 req->retries = retries; 263 req->timeout = timeout; 264 req->flags |= flags | REQ_BLOCK_PC | REQ_SPECIAL | REQ_QUIET; 265 266 /* 267 * head injection *required* here otherwise quiesce won't work 268 */ 269 blk_execute_rq(req->q, NULL, req, 1); 270 271 ret = req->errors; 272 out: 273 blk_put_request(req); 274 275 return ret; 276} 277EXPORT_SYMBOL(scsi_execute); 278 279 280int scsi_execute_req(struct scsi_device *sdev, const unsigned char *cmd, 281 int data_direction, void *buffer, unsigned bufflen, 282 struct scsi_sense_hdr *sshdr, int timeout, int retries) 283{ 284 char *sense = NULL; 285 int result; 286 287 if (sshdr) { 288 sense = kmalloc(SCSI_SENSE_BUFFERSIZE, GFP_NOIO); 289 if (!sense) 290 return DRIVER_ERROR << 24; 291 memset(sense, 0, SCSI_SENSE_BUFFERSIZE); 292 } 293 result = scsi_execute(sdev, cmd, data_direction, buffer, bufflen, 294 sense, timeout, retries, 0); 295 if (sshdr) 296 scsi_normalize_sense(sense, SCSI_SENSE_BUFFERSIZE, sshdr); 297 298 kfree(sense); 299 return result; 300} 301EXPORT_SYMBOL(scsi_execute_req); 302 303struct scsi_io_context { 304 void *data; 305 void (*done)(void *data, char *sense, int result, int resid); 306 char sense[SCSI_SENSE_BUFFERSIZE]; 307}; 308 309static kmem_cache_t *scsi_io_context_cache; 310 311static void scsi_end_async(struct request *req, int uptodate) 312{ 313 struct scsi_io_context *sioc = req->end_io_data; 314 315 if (sioc->done) 316 sioc->done(sioc->data, sioc->sense, req->errors, req->data_len); 317 318 kmem_cache_free(scsi_io_context_cache, sioc); 319 __blk_put_request(req->q, req); 320} 321 322static int scsi_merge_bio(struct request *rq, struct bio *bio) 323{ 324 struct request_queue *q = rq->q; 325 326 bio->bi_flags &= ~(1 << BIO_SEG_VALID); 327 if (rq_data_dir(rq) == WRITE) 328 bio->bi_rw |= (1 << BIO_RW); 329 blk_queue_bounce(q, &bio); 330 331 if (!rq->bio) 332 blk_rq_bio_prep(q, rq, bio); 333 else if (!q->back_merge_fn(q, rq, bio)) 334 return -EINVAL; 335 else { 336 rq->biotail->bi_next = bio; 337 rq->biotail = bio; 338 rq->hard_nr_sectors += bio_sectors(bio); 339 rq->nr_sectors = rq->hard_nr_sectors; 340 } 341 342 return 0; 343} 344 345static int scsi_bi_endio(struct bio *bio, unsigned int bytes_done, int error) 346{ 347 if (bio->bi_size) 348 return 1; 349 350 bio_put(bio); 351 return 0; 352} 353 354/** 355 * scsi_req_map_sg - map a scatterlist into a request 356 * @rq: request to fill 357 * @sg: scatterlist 358 * @nsegs: number of elements 359 * @bufflen: len of buffer 360 * @gfp: memory allocation flags 361 * 362 * scsi_req_map_sg maps a scatterlist into a request so that the 363 * request can be sent to the block layer. We do not trust the scatterlist 364 * sent to use, as some ULDs use that struct to only organize the pages. 365 */ 366static int scsi_req_map_sg(struct request *rq, struct scatterlist *sgl, 367 int nsegs, unsigned bufflen, gfp_t gfp) 368{ 369 struct request_queue *q = rq->q; 370 int nr_pages = (bufflen + PAGE_SIZE - 1) >> PAGE_SHIFT; 371 unsigned int data_len = 0, len, bytes, off; 372 struct page *page; 373 struct bio *bio = NULL; 374 int i, err, nr_vecs = 0; 375 376 for (i = 0; i < nsegs; i++) { 377 page = sgl[i].page; 378 off = sgl[i].offset; 379 len = sgl[i].length; 380 data_len += len; 381 382 while (len > 0) { 383 bytes = min_t(unsigned int, len, PAGE_SIZE - off); 384 385 if (!bio) { 386 nr_vecs = min_t(int, BIO_MAX_PAGES, nr_pages); 387 nr_pages -= nr_vecs; 388 389 bio = bio_alloc(gfp, nr_vecs); 390 if (!bio) { 391 err = -ENOMEM; 392 goto free_bios; 393 } 394 bio->bi_end_io = scsi_bi_endio; 395 } 396 397 if (bio_add_pc_page(q, bio, page, bytes, off) != 398 bytes) { 399 bio_put(bio); 400 err = -EINVAL; 401 goto free_bios; 402 } 403 404 if (bio->bi_vcnt >= nr_vecs) { 405 err = scsi_merge_bio(rq, bio); 406 if (err) { 407 bio_endio(bio, bio->bi_size, 0); 408 goto free_bios; 409 } 410 bio = NULL; 411 } 412 413 page++; 414 len -= bytes; 415 off = 0; 416 } 417 } 418 419 rq->buffer = rq->data = NULL; 420 rq->data_len = data_len; 421 return 0; 422 423free_bios: 424 while ((bio = rq->bio) != NULL) { 425 rq->bio = bio->bi_next; 426 /* 427 * call endio instead of bio_put incase it was bounced 428 */ 429 bio_endio(bio, bio->bi_size, 0); 430 } 431 432 return err; 433} 434 435/** 436 * scsi_execute_async - insert request 437 * @sdev: scsi device 438 * @cmd: scsi command 439 * @cmd_len: length of scsi cdb 440 * @data_direction: data direction 441 * @buffer: data buffer (this can be a kernel buffer or scatterlist) 442 * @bufflen: len of buffer 443 * @use_sg: if buffer is a scatterlist this is the number of elements 444 * @timeout: request timeout in seconds 445 * @retries: number of times to retry request 446 * @flags: or into request flags 447 **/ 448int scsi_execute_async(struct scsi_device *sdev, const unsigned char *cmd, 449 int cmd_len, int data_direction, void *buffer, unsigned bufflen, 450 int use_sg, int timeout, int retries, void *privdata, 451 void (*done)(void *, char *, int, int), gfp_t gfp) 452{ 453 struct request *req; 454 struct scsi_io_context *sioc; 455 int err = 0; 456 int write = (data_direction == DMA_TO_DEVICE); 457 458 sioc = kmem_cache_alloc(scsi_io_context_cache, gfp); 459 if (!sioc) 460 return DRIVER_ERROR << 24; 461 memset(sioc, 0, sizeof(*sioc)); 462 463 req = blk_get_request(sdev->request_queue, write, gfp); 464 if (!req) 465 goto free_sense; 466 req->flags |= REQ_BLOCK_PC | REQ_QUIET; 467 468 if (use_sg) 469 err = scsi_req_map_sg(req, buffer, use_sg, bufflen, gfp); 470 else if (bufflen) 471 err = blk_rq_map_kern(req->q, req, buffer, bufflen, gfp); 472 473 if (err) 474 goto free_req; 475 476 req->cmd_len = cmd_len; 477 memcpy(req->cmd, cmd, req->cmd_len); 478 req->sense = sioc->sense; 479 req->sense_len = 0; 480 req->timeout = timeout; 481 req->retries = retries; 482 req->end_io_data = sioc; 483 484 sioc->data = privdata; 485 sioc->done = done; 486 487 blk_execute_rq_nowait(req->q, NULL, req, 1, scsi_end_async); 488 return 0; 489 490free_req: 491 blk_put_request(req); 492free_sense: 493 kfree(sioc); 494 return DRIVER_ERROR << 24; 495} 496EXPORT_SYMBOL_GPL(scsi_execute_async); 497 498/* 499 * Function: scsi_init_cmd_errh() 500 * 501 * Purpose: Initialize cmd fields related to error handling. 502 * 503 * Arguments: cmd - command that is ready to be queued. 504 * 505 * Returns: Nothing 506 * 507 * Notes: This function has the job of initializing a number of 508 * fields related to error handling. Typically this will 509 * be called once for each command, as required. 510 */ 511static int scsi_init_cmd_errh(struct scsi_cmnd *cmd) 512{ 513 cmd->serial_number = 0; 514 515 memset(cmd->sense_buffer, 0, sizeof cmd->sense_buffer); 516 517 if (cmd->cmd_len == 0) 518 cmd->cmd_len = COMMAND_SIZE(cmd->cmnd[0]); 519 520 /* 521 * We need saved copies of a number of fields - this is because 522 * error handling may need to overwrite these with different values 523 * to run different commands, and once error handling is complete, 524 * we will need to restore these values prior to running the actual 525 * command. 526 */ 527 cmd->old_use_sg = cmd->use_sg; 528 cmd->old_cmd_len = cmd->cmd_len; 529 cmd->sc_old_data_direction = cmd->sc_data_direction; 530 cmd->old_underflow = cmd->underflow; 531 memcpy(cmd->data_cmnd, cmd->cmnd, sizeof(cmd->cmnd)); 532 cmd->buffer = cmd->request_buffer; 533 cmd->bufflen = cmd->request_bufflen; 534 535 return 1; 536} 537 538/* 539 * Function: scsi_setup_cmd_retry() 540 * 541 * Purpose: Restore the command state for a retry 542 * 543 * Arguments: cmd - command to be restored 544 * 545 * Returns: Nothing 546 * 547 * Notes: Immediately prior to retrying a command, we need 548 * to restore certain fields that we saved above. 549 */ 550void scsi_setup_cmd_retry(struct scsi_cmnd *cmd) 551{ 552 memcpy(cmd->cmnd, cmd->data_cmnd, sizeof(cmd->data_cmnd)); 553 cmd->request_buffer = cmd->buffer; 554 cmd->request_bufflen = cmd->bufflen; 555 cmd->use_sg = cmd->old_use_sg; 556 cmd->cmd_len = cmd->old_cmd_len; 557 cmd->sc_data_direction = cmd->sc_old_data_direction; 558 cmd->underflow = cmd->old_underflow; 559} 560 561void scsi_device_unbusy(struct scsi_device *sdev) 562{ 563 struct Scsi_Host *shost = sdev->host; 564 unsigned long flags; 565 566 spin_lock_irqsave(shost->host_lock, flags); 567 shost->host_busy--; 568 if (unlikely(scsi_host_in_recovery(shost) && 569 shost->host_failed)) 570 scsi_eh_wakeup(shost); 571 spin_unlock(shost->host_lock); 572 spin_lock(sdev->request_queue->queue_lock); 573 sdev->device_busy--; 574 spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags); 575} 576 577/* 578 * Called for single_lun devices on IO completion. Clear starget_sdev_user, 579 * and call blk_run_queue for all the scsi_devices on the target - 580 * including current_sdev first. 581 * 582 * Called with *no* scsi locks held. 583 */ 584static void scsi_single_lun_run(struct scsi_device *current_sdev) 585{ 586 struct Scsi_Host *shost = current_sdev->host; 587 struct scsi_device *sdev, *tmp; 588 struct scsi_target *starget = scsi_target(current_sdev); 589 unsigned long flags; 590 591 spin_lock_irqsave(shost->host_lock, flags); 592 starget->starget_sdev_user = NULL; 593 spin_unlock_irqrestore(shost->host_lock, flags); 594 595 /* 596 * Call blk_run_queue for all LUNs on the target, starting with 597 * current_sdev. We race with others (to set starget_sdev_user), 598 * but in most cases, we will be first. Ideally, each LU on the 599 * target would get some limited time or requests on the target. 600 */ 601 blk_run_queue(current_sdev->request_queue); 602 603 spin_lock_irqsave(shost->host_lock, flags); 604 if (starget->starget_sdev_user) 605 goto out; 606 list_for_each_entry_safe(sdev, tmp, &starget->devices, 607 same_target_siblings) { 608 if (sdev == current_sdev) 609 continue; 610 if (scsi_device_get(sdev)) 611 continue; 612 613 spin_unlock_irqrestore(shost->host_lock, flags); 614 blk_run_queue(sdev->request_queue); 615 spin_lock_irqsave(shost->host_lock, flags); 616 617 scsi_device_put(sdev); 618 } 619 out: 620 spin_unlock_irqrestore(shost->host_lock, flags); 621} 622 623/* 624 * Function: scsi_run_queue() 625 * 626 * Purpose: Select a proper request queue to serve next 627 * 628 * Arguments: q - last request's queue 629 * 630 * Returns: Nothing 631 * 632 * Notes: The previous command was completely finished, start 633 * a new one if possible. 634 */ 635static void scsi_run_queue(struct request_queue *q) 636{ 637 struct scsi_device *sdev = q->queuedata; 638 struct Scsi_Host *shost = sdev->host; 639 unsigned long flags; 640 641 if (sdev->single_lun) 642 scsi_single_lun_run(sdev); 643 644 spin_lock_irqsave(shost->host_lock, flags); 645 while (!list_empty(&shost->starved_list) && 646 !shost->host_blocked && !shost->host_self_blocked && 647 !((shost->can_queue > 0) && 648 (shost->host_busy >= shost->can_queue))) { 649 /* 650 * As long as shost is accepting commands and we have 651 * starved queues, call blk_run_queue. scsi_request_fn 652 * drops the queue_lock and can add us back to the 653 * starved_list. 654 * 655 * host_lock protects the starved_list and starved_entry. 656 * scsi_request_fn must get the host_lock before checking 657 * or modifying starved_list or starved_entry. 658 */ 659 sdev = list_entry(shost->starved_list.next, 660 struct scsi_device, starved_entry); 661 list_del_init(&sdev->starved_entry); 662 spin_unlock_irqrestore(shost->host_lock, flags); 663 664 blk_run_queue(sdev->request_queue); 665 666 spin_lock_irqsave(shost->host_lock, flags); 667 if (unlikely(!list_empty(&sdev->starved_entry))) 668 /* 669 * sdev lost a race, and was put back on the 670 * starved list. This is unlikely but without this 671 * in theory we could loop forever. 672 */ 673 break; 674 } 675 spin_unlock_irqrestore(shost->host_lock, flags); 676 677 blk_run_queue(q); 678} 679 680/* 681 * Function: scsi_requeue_command() 682 * 683 * Purpose: Handle post-processing of completed commands. 684 * 685 * Arguments: q - queue to operate on 686 * cmd - command that may need to be requeued. 687 * 688 * Returns: Nothing 689 * 690 * Notes: After command completion, there may be blocks left 691 * over which weren't finished by the previous command 692 * this can be for a number of reasons - the main one is 693 * I/O errors in the middle of the request, in which case 694 * we need to request the blocks that come after the bad 695 * sector. 696 * Notes: Upon return, cmd is a stale pointer. 697 */ 698static void scsi_requeue_command(struct request_queue *q, struct scsi_cmnd *cmd) 699{ 700 struct request *req = cmd->request; 701 unsigned long flags; 702 703 scsi_unprep_request(req); 704 spin_lock_irqsave(q->queue_lock, flags); 705 blk_requeue_request(q, req); 706 spin_unlock_irqrestore(q->queue_lock, flags); 707 708 scsi_run_queue(q); 709} 710 711void scsi_next_command(struct scsi_cmnd *cmd) 712{ 713 struct scsi_device *sdev = cmd->device; 714 struct request_queue *q = sdev->request_queue; 715 716 /* need to hold a reference on the device before we let go of the cmd */ 717 get_device(&sdev->sdev_gendev); 718 719 scsi_put_command(cmd); 720 scsi_run_queue(q); 721 722 /* ok to remove device now */ 723 put_device(&sdev->sdev_gendev); 724} 725 726void scsi_run_host_queues(struct Scsi_Host *shost) 727{ 728 struct scsi_device *sdev; 729 730 shost_for_each_device(sdev, shost) 731 scsi_run_queue(sdev->request_queue); 732} 733 734/* 735 * Function: scsi_end_request() 736 * 737 * Purpose: Post-processing of completed commands (usually invoked at end 738 * of upper level post-processing and scsi_io_completion). 739 * 740 * Arguments: cmd - command that is complete. 741 * uptodate - 1 if I/O indicates success, <= 0 for I/O error. 742 * bytes - number of bytes of completed I/O 743 * requeue - indicates whether we should requeue leftovers. 744 * 745 * Lock status: Assumed that lock is not held upon entry. 746 * 747 * Returns: cmd if requeue required, NULL otherwise. 748 * 749 * Notes: This is called for block device requests in order to 750 * mark some number of sectors as complete. 751 * 752 * We are guaranteeing that the request queue will be goosed 753 * at some point during this call. 754 * Notes: If cmd was requeued, upon return it will be a stale pointer. 755 */ 756static struct scsi_cmnd *scsi_end_request(struct scsi_cmnd *cmd, int uptodate, 757 int bytes, int requeue) 758{ 759 request_queue_t *q = cmd->device->request_queue; 760 struct request *req = cmd->request; 761 unsigned long flags; 762 763 /* 764 * If there are blocks left over at the end, set up the command 765 * to queue the remainder of them. 766 */ 767 if (end_that_request_chunk(req, uptodate, bytes)) { 768 int leftover = (req->hard_nr_sectors << 9); 769 770 if (blk_pc_request(req)) 771 leftover = req->data_len; 772 773 /* kill remainder if no retrys */ 774 if (!uptodate && blk_noretry_request(req)) 775 end_that_request_chunk(req, 0, leftover); 776 else { 777 if (requeue) { 778 /* 779 * Bleah. Leftovers again. Stick the 780 * leftovers in the front of the 781 * queue, and goose the queue again. 782 */ 783 scsi_requeue_command(q, cmd); 784 cmd = NULL; 785 } 786 return cmd; 787 } 788 } 789 790 add_disk_randomness(req->rq_disk); 791 792 spin_lock_irqsave(q->queue_lock, flags); 793 if (blk_rq_tagged(req)) 794 blk_queue_end_tag(q, req); 795 end_that_request_last(req, uptodate); 796 spin_unlock_irqrestore(q->queue_lock, flags); 797 798 /* 799 * This will goose the queue request function at the end, so we don't 800 * need to worry about launching another command. 801 */ 802 scsi_next_command(cmd); 803 return NULL; 804} 805 806static struct scatterlist *scsi_alloc_sgtable(struct scsi_cmnd *cmd, gfp_t gfp_mask) 807{ 808 struct scsi_host_sg_pool *sgp; 809 struct scatterlist *sgl; 810 811 BUG_ON(!cmd->use_sg); 812 813 switch (cmd->use_sg) { 814 case 1 ... 8: 815 cmd->sglist_len = 0; 816 break; 817 case 9 ... 16: 818 cmd->sglist_len = 1; 819 break; 820 case 17 ... 32: 821 cmd->sglist_len = 2; 822 break; 823#if (SCSI_MAX_PHYS_SEGMENTS > 32) 824 case 33 ... 64: 825 cmd->sglist_len = 3; 826 break; 827#if (SCSI_MAX_PHYS_SEGMENTS > 64) 828 case 65 ... 128: 829 cmd->sglist_len = 4; 830 break; 831#if (SCSI_MAX_PHYS_SEGMENTS > 128) 832 case 129 ... 256: 833 cmd->sglist_len = 5; 834 break; 835#endif 836#endif 837#endif 838 default: 839 return NULL; 840 } 841 842 sgp = scsi_sg_pools + cmd->sglist_len; 843 sgl = mempool_alloc(sgp->pool, gfp_mask); 844 return sgl; 845} 846 847static void scsi_free_sgtable(struct scatterlist *sgl, int index) 848{ 849 struct scsi_host_sg_pool *sgp; 850 851 BUG_ON(index >= SG_MEMPOOL_NR); 852 853 sgp = scsi_sg_pools + index; 854 mempool_free(sgl, sgp->pool); 855} 856 857/* 858 * Function: scsi_release_buffers() 859 * 860 * Purpose: Completion processing for block device I/O requests. 861 * 862 * Arguments: cmd - command that we are bailing. 863 * 864 * Lock status: Assumed that no lock is held upon entry. 865 * 866 * Returns: Nothing 867 * 868 * Notes: In the event that an upper level driver rejects a 869 * command, we must release resources allocated during 870 * the __init_io() function. Primarily this would involve 871 * the scatter-gather table, and potentially any bounce 872 * buffers. 873 */ 874static void scsi_release_buffers(struct scsi_cmnd *cmd) 875{ 876 struct request *req = cmd->request; 877 878 /* 879 * Free up any indirection buffers we allocated for DMA purposes. 880 */ 881 if (cmd->use_sg) 882 scsi_free_sgtable(cmd->request_buffer, cmd->sglist_len); 883 else if (cmd->request_buffer != req->buffer) 884 kfree(cmd->request_buffer); 885 886 /* 887 * Zero these out. They now point to freed memory, and it is 888 * dangerous to hang onto the pointers. 889 */ 890 cmd->buffer = NULL; 891 cmd->bufflen = 0; 892 cmd->request_buffer = NULL; 893 cmd->request_bufflen = 0; 894} 895 896/* 897 * Function: scsi_io_completion() 898 * 899 * Purpose: Completion processing for block device I/O requests. 900 * 901 * Arguments: cmd - command that is finished. 902 * 903 * Lock status: Assumed that no lock is held upon entry. 904 * 905 * Returns: Nothing 906 * 907 * Notes: This function is matched in terms of capabilities to 908 * the function that created the scatter-gather list. 909 * In other words, if there are no bounce buffers 910 * (the normal case for most drivers), we don't need 911 * the logic to deal with cleaning up afterwards. 912 * 913 * We must do one of several things here: 914 * 915 * a) Call scsi_end_request. This will finish off the 916 * specified number of sectors. If we are done, the 917 * command block will be released, and the queue 918 * function will be goosed. If we are not done, then 919 * scsi_end_request will directly goose the queue. 920 * 921 * b) We can just use scsi_requeue_command() here. This would 922 * be used if we just wanted to retry, for example. 923 */ 924void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes, 925 unsigned int block_bytes) 926{ 927 int result = cmd->result; 928 int this_count = cmd->bufflen; 929 request_queue_t *q = cmd->device->request_queue; 930 struct request *req = cmd->request; 931 int clear_errors = 1; 932 struct scsi_sense_hdr sshdr; 933 int sense_valid = 0; 934 int sense_deferred = 0; 935 936 /* 937 * Free up any indirection buffers we allocated for DMA purposes. 938 * For the case of a READ, we need to copy the data out of the 939 * bounce buffer and into the real buffer. 940 */ 941 if (cmd->use_sg) 942 scsi_free_sgtable(cmd->buffer, cmd->sglist_len); 943 else if (cmd->buffer != req->buffer) { 944 if (rq_data_dir(req) == READ) { 945 unsigned long flags; 946 char *to = bio_kmap_irq(req->bio, &flags); 947 memcpy(to, cmd->buffer, cmd->bufflen); 948 bio_kunmap_irq(to, &flags); 949 } 950 kfree(cmd->buffer); 951 } 952 953 if (result) { 954 sense_valid = scsi_command_normalize_sense(cmd, &sshdr); 955 if (sense_valid) 956 sense_deferred = scsi_sense_is_deferred(&sshdr); 957 } 958 if (blk_pc_request(req)) { /* SG_IO ioctl from block level */ 959 req->errors = result; 960 if (result) { 961 clear_errors = 0; 962 if (sense_valid && req->sense) { 963 /* 964 * SG_IO wants current and deferred errors 965 */ 966 int len = 8 + cmd->sense_buffer[7]; 967 968 if (len > SCSI_SENSE_BUFFERSIZE) 969 len = SCSI_SENSE_BUFFERSIZE; 970 memcpy(req->sense, cmd->sense_buffer, len); 971 req->sense_len = len; 972 } 973 } else 974 req->data_len = cmd->resid; 975 } 976 977 /* 978 * Zero these out. They now point to freed memory, and it is 979 * dangerous to hang onto the pointers. 980 */ 981 cmd->buffer = NULL; 982 cmd->bufflen = 0; 983 cmd->request_buffer = NULL; 984 cmd->request_bufflen = 0; 985 986 /* 987 * Next deal with any sectors which we were able to correctly 988 * handle. 989 */ 990 if (good_bytes >= 0) { 991 SCSI_LOG_HLCOMPLETE(1, printk("%ld sectors total, %d bytes done.\n", 992 req->nr_sectors, good_bytes)); 993 SCSI_LOG_HLCOMPLETE(1, printk("use_sg is %d\n", cmd->use_sg)); 994 995 if (clear_errors) 996 req->errors = 0; 997 /* 998 * If multiple sectors are requested in one buffer, then 999 * they will have been finished off by the first command. 1000 * If not, then we have a multi-buffer command. 1001 * 1002 * If block_bytes != 0, it means we had a medium error 1003 * of some sort, and that we want to mark some number of 1004 * sectors as not uptodate. Thus we want to inhibit 1005 * requeueing right here - we will requeue down below 1006 * when we handle the bad sectors. 1007 */ 1008 1009 /* 1010 * If the command completed without error, then either 1011 * finish off the rest of the command, or start a new one. 1012 */ 1013 if (scsi_end_request(cmd, 1, good_bytes, result == 0) == NULL) 1014 return; 1015 } 1016 /* 1017 * Now, if we were good little boys and girls, Santa left us a request 1018 * sense buffer. We can extract information from this, so we 1019 * can choose a block to remap, etc. 1020 */ 1021 if (sense_valid && !sense_deferred) { 1022 switch (sshdr.sense_key) { 1023 case UNIT_ATTENTION: 1024 if (cmd->device->removable) { 1025 /* detected disc change. set a bit 1026 * and quietly refuse further access. 1027 */ 1028 cmd->device->changed = 1; 1029 scsi_end_request(cmd, 0, 1030 this_count, 1); 1031 return; 1032 } else { 1033 /* 1034 * Must have been a power glitch, or a 1035 * bus reset. Could not have been a 1036 * media change, so we just retry the 1037 * request and see what happens. 1038 */ 1039 scsi_requeue_command(q, cmd); 1040 return; 1041 } 1042 break; 1043 case ILLEGAL_REQUEST: 1044 /* 1045 * If we had an ILLEGAL REQUEST returned, then we may 1046 * have performed an unsupported command. The only 1047 * thing this should be would be a ten byte read where 1048 * only a six byte read was supported. Also, on a 1049 * system where READ CAPACITY failed, we may have read 1050 * past the end of the disk. 1051 */ 1052 if ((cmd->device->use_10_for_rw && 1053 sshdr.asc == 0x20 && sshdr.ascq == 0x00) && 1054 (cmd->cmnd[0] == READ_10 || 1055 cmd->cmnd[0] == WRITE_10)) { 1056 cmd->device->use_10_for_rw = 0; 1057 /* 1058 * This will cause a retry with a 6-byte 1059 * command. 1060 */ 1061 scsi_requeue_command(q, cmd); 1062 result = 0; 1063 } else { 1064 scsi_end_request(cmd, 0, this_count, 1); 1065 return; 1066 } 1067 break; 1068 case NOT_READY: 1069 /* 1070 * If the device is in the process of becoming ready, 1071 * retry. 1072 */ 1073 if (sshdr.asc == 0x04 && sshdr.ascq == 0x01) { 1074 scsi_requeue_command(q, cmd); 1075 return; 1076 } 1077 if (!(req->flags & REQ_QUIET)) 1078 scmd_printk(KERN_INFO, cmd, 1079 "Device not ready.\n"); 1080 scsi_end_request(cmd, 0, this_count, 1); 1081 return; 1082 case VOLUME_OVERFLOW: 1083 if (!(req->flags & REQ_QUIET)) { 1084 scmd_printk(KERN_INFO, cmd, 1085 "Volume overflow, CDB: "); 1086 __scsi_print_command(cmd->data_cmnd); 1087 scsi_print_sense("", cmd); 1088 } 1089 scsi_end_request(cmd, 0, block_bytes, 1); 1090 return; 1091 default: 1092 break; 1093 } 1094 } /* driver byte != 0 */ 1095 if (host_byte(result) == DID_RESET) { 1096 /* 1097 * Third party bus reset or reset for error 1098 * recovery reasons. Just retry the request 1099 * and see what happens. 1100 */ 1101 scsi_requeue_command(q, cmd); 1102 return; 1103 } 1104 if (result) { 1105 if (!(req->flags & REQ_QUIET)) { 1106 scmd_printk(KERN_INFO, cmd, 1107 "SCSI error: return code = 0x%x\n", result); 1108 1109 if (driver_byte(result) & DRIVER_SENSE) 1110 scsi_print_sense("", cmd); 1111 } 1112 /* 1113 * Mark a single buffer as not uptodate. Queue the remainder. 1114 * We sometimes get this cruft in the event that a medium error 1115 * isn't properly reported. 1116 */ 1117 block_bytes = req->hard_cur_sectors << 9; 1118 if (!block_bytes) 1119 block_bytes = req->data_len; 1120 scsi_end_request(cmd, 0, block_bytes, 1); 1121 } 1122} 1123EXPORT_SYMBOL(scsi_io_completion); 1124 1125/* 1126 * Function: scsi_init_io() 1127 * 1128 * Purpose: SCSI I/O initialize function. 1129 * 1130 * Arguments: cmd - Command descriptor we wish to initialize 1131 * 1132 * Returns: 0 on success 1133 * BLKPREP_DEFER if the failure is retryable 1134 * BLKPREP_KILL if the failure is fatal 1135 */ 1136static int scsi_init_io(struct scsi_cmnd *cmd) 1137{ 1138 struct request *req = cmd->request; 1139 struct scatterlist *sgpnt; 1140 int count; 1141 1142 /* 1143 * if this is a rq->data based REQ_BLOCK_PC, setup for a non-sg xfer 1144 */ 1145 if ((req->flags & REQ_BLOCK_PC) && !req->bio) { 1146 cmd->request_bufflen = req->data_len; 1147 cmd->request_buffer = req->data; 1148 req->buffer = req->data; 1149 cmd->use_sg = 0; 1150 return 0; 1151 } 1152 1153 /* 1154 * we used to not use scatter-gather for single segment request, 1155 * but now we do (it makes highmem I/O easier to support without 1156 * kmapping pages) 1157 */ 1158 cmd->use_sg = req->nr_phys_segments; 1159 1160 /* 1161 * if sg table allocation fails, requeue request later. 1162 */ 1163 sgpnt = scsi_alloc_sgtable(cmd, GFP_ATOMIC); 1164 if (unlikely(!sgpnt)) { 1165 scsi_unprep_request(req); 1166 return BLKPREP_DEFER; 1167 } 1168 1169 cmd->request_buffer = (char *) sgpnt; 1170 cmd->request_bufflen = req->nr_sectors << 9; 1171 if (blk_pc_request(req)) 1172 cmd->request_bufflen = req->data_len; 1173 req->buffer = NULL; 1174 1175 /* 1176 * Next, walk the list, and fill in the addresses and sizes of 1177 * each segment. 1178 */ 1179 count = blk_rq_map_sg(req->q, req, cmd->request_buffer); 1180 1181 /* 1182 * mapped well, send it off 1183 */ 1184 if (likely(count <= cmd->use_sg)) { 1185 cmd->use_sg = count; 1186 return 0; 1187 } 1188 1189 printk(KERN_ERR "Incorrect number of segments after building list\n"); 1190 printk(KERN_ERR "counted %d, received %d\n", count, cmd->use_sg); 1191 printk(KERN_ERR "req nr_sec %lu, cur_nr_sec %u\n", req->nr_sectors, 1192 req->current_nr_sectors); 1193 1194 /* release the command and kill it */ 1195 scsi_release_buffers(cmd); 1196 scsi_put_command(cmd); 1197 return BLKPREP_KILL; 1198} 1199 1200static int scsi_issue_flush_fn(request_queue_t *q, struct gendisk *disk, 1201 sector_t *error_sector) 1202{ 1203 struct scsi_device *sdev = q->queuedata; 1204 struct scsi_driver *drv; 1205 1206 if (sdev->sdev_state != SDEV_RUNNING) 1207 return -ENXIO; 1208 1209 drv = *(struct scsi_driver **) disk->private_data; 1210 if (drv->issue_flush) 1211 return drv->issue_flush(&sdev->sdev_gendev, error_sector); 1212 1213 return -EOPNOTSUPP; 1214} 1215 1216static void scsi_blk_pc_done(struct scsi_cmnd *cmd) 1217{ 1218 BUG_ON(!blk_pc_request(cmd->request)); 1219 /* 1220 * This will complete the whole command with uptodate=1 so 1221 * as far as the block layer is concerned the command completed 1222 * successfully. Since this is a REQ_BLOCK_PC command the 1223 * caller should check the request's errors value 1224 */ 1225 scsi_io_completion(cmd, cmd->bufflen, 0); 1226} 1227 1228static void scsi_setup_blk_pc_cmnd(struct scsi_cmnd *cmd) 1229{ 1230 struct request *req = cmd->request; 1231 1232 BUG_ON(sizeof(req->cmd) > sizeof(cmd->cmnd)); 1233 memcpy(cmd->cmnd, req->cmd, sizeof(cmd->cmnd)); 1234 cmd->cmd_len = req->cmd_len; 1235 if (!req->data_len) 1236 cmd->sc_data_direction = DMA_NONE; 1237 else if (rq_data_dir(req) == WRITE) 1238 cmd->sc_data_direction = DMA_TO_DEVICE; 1239 else 1240 cmd->sc_data_direction = DMA_FROM_DEVICE; 1241 1242 cmd->transfersize = req->data_len; 1243 cmd->allowed = req->retries; 1244 cmd->timeout_per_command = req->timeout; 1245 cmd->done = scsi_blk_pc_done; 1246} 1247 1248static int scsi_prep_fn(struct request_queue *q, struct request *req) 1249{ 1250 struct scsi_device *sdev = q->queuedata; 1251 struct scsi_cmnd *cmd; 1252 int specials_only = 0; 1253 1254 /* 1255 * Just check to see if the device is online. If it isn't, we 1256 * refuse to process any commands. The device must be brought 1257 * online before trying any recovery commands 1258 */ 1259 if (unlikely(!scsi_device_online(sdev))) { 1260 sdev_printk(KERN_ERR, sdev, 1261 "rejecting I/O to offline device\n"); 1262 goto kill; 1263 } 1264 if (unlikely(sdev->sdev_state != SDEV_RUNNING)) { 1265 /* OK, we're not in a running state don't prep 1266 * user commands */ 1267 if (sdev->sdev_state == SDEV_DEL) { 1268 /* Device is fully deleted, no commands 1269 * at all allowed down */ 1270 sdev_printk(KERN_ERR, sdev, 1271 "rejecting I/O to dead device\n"); 1272 goto kill; 1273 } 1274 /* OK, we only allow special commands (i.e. not 1275 * user initiated ones */ 1276 specials_only = sdev->sdev_state; 1277 } 1278 1279 /* 1280 * Find the actual device driver associated with this command. 1281 * The SPECIAL requests are things like character device or 1282 * ioctls, which did not originate from ll_rw_blk. Note that 1283 * the special field is also used to indicate the cmd for 1284 * the remainder of a partially fulfilled request that can 1285 * come up when there is a medium error. We have to treat 1286 * these two cases differently. We differentiate by looking 1287 * at request->cmd, as this tells us the real story. 1288 */ 1289 if (req->flags & REQ_SPECIAL && req->special) { 1290 struct scsi_request *sreq = req->special; 1291 1292 if (sreq->sr_magic == SCSI_REQ_MAGIC) { 1293 cmd = scsi_get_command(sreq->sr_device, GFP_ATOMIC); 1294 if (unlikely(!cmd)) 1295 goto defer; 1296 scsi_init_cmd_from_req(cmd, sreq); 1297 } else 1298 cmd = req->special; 1299 } else if (req->flags & (REQ_CMD | REQ_BLOCK_PC)) { 1300 1301 if(unlikely(specials_only) && !(req->flags & REQ_SPECIAL)) { 1302 if(specials_only == SDEV_QUIESCE || 1303 specials_only == SDEV_BLOCK) 1304 goto defer; 1305 1306 sdev_printk(KERN_ERR, sdev, 1307 "rejecting I/O to device being removed\n"); 1308 goto kill; 1309 } 1310 1311 1312 /* 1313 * Now try and find a command block that we can use. 1314 */ 1315 if (!req->special) { 1316 cmd = scsi_get_command(sdev, GFP_ATOMIC); 1317 if (unlikely(!cmd)) 1318 goto defer; 1319 } else 1320 cmd = req->special; 1321 1322 /* pull a tag out of the request if we have one */ 1323 cmd->tag = req->tag; 1324 } else { 1325 blk_dump_rq_flags(req, "SCSI bad req"); 1326 goto kill; 1327 } 1328 1329 /* note the overloading of req->special. When the tag 1330 * is active it always means cmd. If the tag goes 1331 * back for re-queueing, it may be reset */ 1332 req->special = cmd; 1333 cmd->request = req; 1334 1335 /* 1336 * FIXME: drop the lock here because the functions below 1337 * expect to be called without the queue lock held. Also, 1338 * previously, we dequeued the request before dropping the 1339 * lock. We hope REQ_STARTED prevents anything untoward from 1340 * happening now. 1341 */ 1342 if (req->flags & (REQ_CMD | REQ_BLOCK_PC)) { 1343 int ret; 1344 1345 /* 1346 * This will do a couple of things: 1347 * 1) Fill in the actual SCSI command. 1348 * 2) Fill in any other upper-level specific fields 1349 * (timeout). 1350 * 1351 * If this returns 0, it means that the request failed 1352 * (reading past end of disk, reading offline device, 1353 * etc). This won't actually talk to the device, but 1354 * some kinds of consistency checking may cause the 1355 * request to be rejected immediately. 1356 */ 1357 1358 /* 1359 * This sets up the scatter-gather table (allocating if 1360 * required). 1361 */ 1362 ret = scsi_init_io(cmd); 1363 switch(ret) { 1364 /* For BLKPREP_KILL/DEFER the cmd was released */ 1365 case BLKPREP_KILL: 1366 goto kill; 1367 case BLKPREP_DEFER: 1368 goto defer; 1369 } 1370 1371 /* 1372 * Initialize the actual SCSI command for this request. 1373 */ 1374 if (req->flags & REQ_BLOCK_PC) { 1375 scsi_setup_blk_pc_cmnd(cmd); 1376 } else if (req->rq_disk) { 1377 struct scsi_driver *drv; 1378 1379 drv = *(struct scsi_driver **)req->rq_disk->private_data; 1380 if (unlikely(!drv->init_command(cmd))) { 1381 scsi_release_buffers(cmd); 1382 scsi_put_command(cmd); 1383 goto kill; 1384 } 1385 } 1386 } 1387 1388 /* 1389 * The request is now prepped, no need to come back here 1390 */ 1391 req->flags |= REQ_DONTPREP; 1392 return BLKPREP_OK; 1393 1394 defer: 1395 /* If we defer, the elv_next_request() returns NULL, but the 1396 * queue must be restarted, so we plug here if no returning 1397 * command will automatically do that. */ 1398 if (sdev->device_busy == 0) 1399 blk_plug_device(q); 1400 return BLKPREP_DEFER; 1401 kill: 1402 req->errors = DID_NO_CONNECT << 16; 1403 return BLKPREP_KILL; 1404} 1405 1406/* 1407 * scsi_dev_queue_ready: if we can send requests to sdev, return 1 else 1408 * return 0. 1409 * 1410 * Called with the queue_lock held. 1411 */ 1412static inline int scsi_dev_queue_ready(struct request_queue *q, 1413 struct scsi_device *sdev) 1414{ 1415 if (sdev->device_busy >= sdev->queue_depth) 1416 return 0; 1417 if (sdev->device_busy == 0 && sdev->device_blocked) { 1418 /* 1419 * unblock after device_blocked iterates to zero 1420 */ 1421 if (--sdev->device_blocked == 0) { 1422 SCSI_LOG_MLQUEUE(3, 1423 sdev_printk(KERN_INFO, sdev, 1424 "unblocking device at zero depth\n")); 1425 } else { 1426 blk_plug_device(q); 1427 return 0; 1428 } 1429 } 1430 if (sdev->device_blocked) 1431 return 0; 1432 1433 return 1; 1434} 1435 1436/* 1437 * scsi_host_queue_ready: if we can send requests to shost, return 1 else 1438 * return 0. We must end up running the queue again whenever 0 is 1439 * returned, else IO can hang. 1440 * 1441 * Called with host_lock held. 1442 */ 1443static inline int scsi_host_queue_ready(struct request_queue *q, 1444 struct Scsi_Host *shost, 1445 struct scsi_device *sdev) 1446{ 1447 if (scsi_host_in_recovery(shost)) 1448 return 0; 1449 if (shost->host_busy == 0 && shost->host_blocked) { 1450 /* 1451 * unblock after host_blocked iterates to zero 1452 */ 1453 if (--shost->host_blocked == 0) { 1454 SCSI_LOG_MLQUEUE(3, 1455 printk("scsi%d unblocking host at zero depth\n", 1456 shost->host_no)); 1457 } else { 1458 blk_plug_device(q); 1459 return 0; 1460 } 1461 } 1462 if ((shost->can_queue > 0 && shost->host_busy >= shost->can_queue) || 1463 shost->host_blocked || shost->host_self_blocked) { 1464 if (list_empty(&sdev->starved_entry)) 1465 list_add_tail(&sdev->starved_entry, &shost->starved_list); 1466 return 0; 1467 } 1468 1469 /* We're OK to process the command, so we can't be starved */ 1470 if (!list_empty(&sdev->starved_entry)) 1471 list_del_init(&sdev->starved_entry); 1472 1473 return 1; 1474} 1475 1476/* 1477 * Kill a request for a dead device 1478 */ 1479static void scsi_kill_request(struct request *req, request_queue_t *q) 1480{ 1481 struct scsi_cmnd *cmd = req->special; 1482 1483 blkdev_dequeue_request(req); 1484 1485 if (unlikely(cmd == NULL)) { 1486 printk(KERN_CRIT "impossible request in %s.\n", 1487 __FUNCTION__); 1488 BUG(); 1489 } 1490 1491 scsi_init_cmd_errh(cmd); 1492 cmd->result = DID_NO_CONNECT << 16; 1493 atomic_inc(&cmd->device->iorequest_cnt); 1494 __scsi_done(cmd); 1495} 1496 1497static void scsi_softirq_done(struct request *rq) 1498{ 1499 struct scsi_cmnd *cmd = rq->completion_data; 1500 unsigned long wait_for = cmd->allowed * cmd->timeout_per_command; 1501 int disposition; 1502 1503 INIT_LIST_HEAD(&cmd->eh_entry); 1504 1505 disposition = scsi_decide_disposition(cmd); 1506 if (disposition != SUCCESS && 1507 time_before(cmd->jiffies_at_alloc + wait_for, jiffies)) { 1508 sdev_printk(KERN_ERR, cmd->device, 1509 "timing out command, waited %lus\n", 1510 wait_for/HZ); 1511 disposition = SUCCESS; 1512 } 1513 1514 scsi_log_completion(cmd, disposition); 1515 1516 switch (disposition) { 1517 case SUCCESS: 1518 scsi_finish_command(cmd); 1519 break; 1520 case NEEDS_RETRY: 1521 scsi_retry_command(cmd); 1522 break; 1523 case ADD_TO_MLQUEUE: 1524 scsi_queue_insert(cmd, SCSI_MLQUEUE_DEVICE_BUSY); 1525 break; 1526 default: 1527 if (!scsi_eh_scmd_add(cmd, 0)) 1528 scsi_finish_command(cmd); 1529 } 1530} 1531 1532/* 1533 * Function: scsi_request_fn() 1534 * 1535 * Purpose: Main strategy routine for SCSI. 1536 * 1537 * Arguments: q - Pointer to actual queue. 1538 * 1539 * Returns: Nothing 1540 * 1541 * Lock status: IO request lock assumed to be held when called. 1542 */ 1543static void scsi_request_fn(struct request_queue *q) 1544{ 1545 struct scsi_device *sdev = q->queuedata; 1546 struct Scsi_Host *shost; 1547 struct scsi_cmnd *cmd; 1548 struct request *req; 1549 1550 if (!sdev) { 1551 printk("scsi: killing requests for dead queue\n"); 1552 while ((req = elv_next_request(q)) != NULL) 1553 scsi_kill_request(req, q); 1554 return; 1555 } 1556 1557 if(!get_device(&sdev->sdev_gendev)) 1558 /* We must be tearing the block queue down already */ 1559 return; 1560 1561 /* 1562 * To start with, we keep looping until the queue is empty, or until 1563 * the host is no longer able to accept any more requests. 1564 */ 1565 shost = sdev->host; 1566 while (!blk_queue_plugged(q)) { 1567 int rtn; 1568 /* 1569 * get next queueable request. We do this early to make sure 1570 * that the request is fully prepared even if we cannot 1571 * accept it. 1572 */ 1573 req = elv_next_request(q); 1574 if (!req || !scsi_dev_queue_ready(q, sdev)) 1575 break; 1576 1577 if (unlikely(!scsi_device_online(sdev))) { 1578 sdev_printk(KERN_ERR, sdev, 1579 "rejecting I/O to offline device\n"); 1580 scsi_kill_request(req, q); 1581 continue; 1582 } 1583 1584 1585 /* 1586 * Remove the request from the request list. 1587 */ 1588 if (!(blk_queue_tagged(q) && !blk_queue_start_tag(q, req))) 1589 blkdev_dequeue_request(req); 1590 sdev->device_busy++; 1591 1592 spin_unlock(q->queue_lock); 1593 cmd = req->special; 1594 if (unlikely(cmd == NULL)) { 1595 printk(KERN_CRIT "impossible request in %s.\n" 1596 "please mail a stack trace to " 1597 "linux-scsi@vger.kernel.org", 1598 __FUNCTION__); 1599 BUG(); 1600 } 1601 spin_lock(shost->host_lock); 1602 1603 if (!scsi_host_queue_ready(q, shost, sdev)) 1604 goto not_ready; 1605 if (sdev->single_lun) { 1606 if (scsi_target(sdev)->starget_sdev_user && 1607 scsi_target(sdev)->starget_sdev_user != sdev) 1608 goto not_ready; 1609 scsi_target(sdev)->starget_sdev_user = sdev; 1610 } 1611 shost->host_busy++; 1612 1613 /* 1614 * XXX(hch): This is rather suboptimal, scsi_dispatch_cmd will 1615 * take the lock again. 1616 */ 1617 spin_unlock_irq(shost->host_lock); 1618 1619 /* 1620 * Finally, initialize any error handling parameters, and set up 1621 * the timers for timeouts. 1622 */ 1623 scsi_init_cmd_errh(cmd); 1624 1625 /* 1626 * Dispatch the command to the low-level driver. 1627 */ 1628 rtn = scsi_dispatch_cmd(cmd); 1629 spin_lock_irq(q->queue_lock); 1630 if(rtn) { 1631 /* we're refusing the command; because of 1632 * the way locks get dropped, we need to 1633 * check here if plugging is required */ 1634 if(sdev->device_busy == 0) 1635 blk_plug_device(q); 1636 1637 break; 1638 } 1639 } 1640 1641 goto out; 1642 1643 not_ready: 1644 spin_unlock_irq(shost->host_lock); 1645 1646 /* 1647 * lock q, handle tag, requeue req, and decrement device_busy. We 1648 * must return with queue_lock held. 1649 * 1650 * Decrementing device_busy without checking it is OK, as all such 1651 * cases (host limits or settings) should run the queue at some 1652 * later time. 1653 */ 1654 spin_lock_irq(q->queue_lock); 1655 blk_requeue_request(q, req); 1656 sdev->device_busy--; 1657 if(sdev->device_busy == 0) 1658 blk_plug_device(q); 1659 out: 1660 /* must be careful here...if we trigger the ->remove() function 1661 * we cannot be holding the q lock */ 1662 spin_unlock_irq(q->queue_lock); 1663 put_device(&sdev->sdev_gendev); 1664 spin_lock_irq(q->queue_lock); 1665} 1666 1667u64 scsi_calculate_bounce_limit(struct Scsi_Host *shost) 1668{ 1669 struct device *host_dev; 1670 u64 bounce_limit = 0xffffffff; 1671 1672 if (shost->unchecked_isa_dma) 1673 return BLK_BOUNCE_ISA; 1674 /* 1675 * Platforms with virtual-DMA translation 1676 * hardware have no practical limit. 1677 */ 1678 if (!PCI_DMA_BUS_IS_PHYS) 1679 return BLK_BOUNCE_ANY; 1680 1681 host_dev = scsi_get_device(shost); 1682 if (host_dev && host_dev->dma_mask) 1683 bounce_limit = *host_dev->dma_mask; 1684 1685 return bounce_limit; 1686} 1687EXPORT_SYMBOL(scsi_calculate_bounce_limit); 1688 1689struct request_queue *scsi_alloc_queue(struct scsi_device *sdev) 1690{ 1691 struct Scsi_Host *shost = sdev->host; 1692 struct request_queue *q; 1693 1694 q = blk_init_queue(scsi_request_fn, NULL); 1695 if (!q) 1696 return NULL; 1697 1698 blk_queue_prep_rq(q, scsi_prep_fn); 1699 1700 blk_queue_max_hw_segments(q, shost->sg_tablesize); 1701 blk_queue_max_phys_segments(q, SCSI_MAX_PHYS_SEGMENTS); 1702 blk_queue_max_sectors(q, shost->max_sectors); 1703 blk_queue_bounce_limit(q, scsi_calculate_bounce_limit(shost)); 1704 blk_queue_segment_boundary(q, shost->dma_boundary); 1705 blk_queue_issue_flush_fn(q, scsi_issue_flush_fn); 1706 blk_queue_softirq_done(q, scsi_softirq_done); 1707 1708 if (!shost->use_clustering) 1709 clear_bit(QUEUE_FLAG_CLUSTER, &q->queue_flags); 1710 return q; 1711} 1712 1713void scsi_free_queue(struct request_queue *q) 1714{ 1715 blk_cleanup_queue(q); 1716} 1717 1718/* 1719 * Function: scsi_block_requests() 1720 * 1721 * Purpose: Utility function used by low-level drivers to prevent further 1722 * commands from being queued to the device. 1723 * 1724 * Arguments: shost - Host in question 1725 * 1726 * Returns: Nothing 1727 * 1728 * Lock status: No locks are assumed held. 1729 * 1730 * Notes: There is no timer nor any other means by which the requests 1731 * get unblocked other than the low-level driver calling 1732 * scsi_unblock_requests(). 1733 */ 1734void scsi_block_requests(struct Scsi_Host *shost) 1735{ 1736 shost->host_self_blocked = 1; 1737} 1738EXPORT_SYMBOL(scsi_block_requests); 1739 1740/* 1741 * Function: scsi_unblock_requests() 1742 * 1743 * Purpose: Utility function used by low-level drivers to allow further 1744 * commands from being queued to the device. 1745 * 1746 * Arguments: shost - Host in question 1747 * 1748 * Returns: Nothing 1749 * 1750 * Lock status: No locks are assumed held. 1751 * 1752 * Notes: There is no timer nor any other means by which the requests 1753 * get unblocked other than the low-level driver calling 1754 * scsi_unblock_requests(). 1755 * 1756 * This is done as an API function so that changes to the 1757 * internals of the scsi mid-layer won't require wholesale 1758 * changes to drivers that use this feature. 1759 */ 1760void scsi_unblock_requests(struct Scsi_Host *shost) 1761{ 1762 shost->host_self_blocked = 0; 1763 scsi_run_host_queues(shost); 1764} 1765EXPORT_SYMBOL(scsi_unblock_requests); 1766 1767int __init scsi_init_queue(void) 1768{ 1769 int i; 1770 1771 scsi_io_context_cache = kmem_cache_create("scsi_io_context", 1772 sizeof(struct scsi_io_context), 1773 0, 0, NULL, NULL); 1774 if (!scsi_io_context_cache) { 1775 printk(KERN_ERR "SCSI: can't init scsi io context cache\n"); 1776 return -ENOMEM; 1777 } 1778 1779 for (i = 0; i < SG_MEMPOOL_NR; i++) { 1780 struct scsi_host_sg_pool *sgp = scsi_sg_pools + i; 1781 int size = sgp->size * sizeof(struct scatterlist); 1782 1783 sgp->slab = kmem_cache_create(sgp->name, size, 0, 1784 SLAB_HWCACHE_ALIGN, NULL, NULL); 1785 if (!sgp->slab) { 1786 printk(KERN_ERR "SCSI: can't init sg slab %s\n", 1787 sgp->name); 1788 } 1789 1790 sgp->pool = mempool_create(SG_MEMPOOL_SIZE, 1791 mempool_alloc_slab, mempool_free_slab, 1792 sgp->slab); 1793 if (!sgp->pool) { 1794 printk(KERN_ERR "SCSI: can't init sg mempool %s\n", 1795 sgp->name); 1796 } 1797 } 1798 1799 return 0; 1800} 1801 1802void scsi_exit_queue(void) 1803{ 1804 int i; 1805 1806 kmem_cache_destroy(scsi_io_context_cache); 1807 1808 for (i = 0; i < SG_MEMPOOL_NR; i++) { 1809 struct scsi_host_sg_pool *sgp = scsi_sg_pools + i; 1810 mempool_destroy(sgp->pool); 1811 kmem_cache_destroy(sgp->slab); 1812 } 1813} 1814/** 1815 * scsi_mode_sense - issue a mode sense, falling back from 10 to 1816 * six bytes if necessary. 1817 * @sdev: SCSI device to be queried 1818 * @dbd: set if mode sense will allow block descriptors to be returned 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 * @sense: 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 unsuccessful, or the header offset (either 4 1829 * or 8 depending on whether a six or ten byte command was 1830 * issued) if successful. 1831 **/ 1832int 1833scsi_mode_sense(struct scsi_device *sdev, int dbd, int modepage, 1834 unsigned char *buffer, int len, int timeout, int retries, 1835 struct scsi_mode_data *data, struct scsi_sense_hdr *sshdr) { 1836 unsigned char cmd[12]; 1837 int use_10_for_ms; 1838 int header_length; 1839 int result; 1840 struct scsi_sense_hdr my_sshdr; 1841 1842 memset(data, 0, sizeof(*data)); 1843 memset(&cmd[0], 0, 12); 1844 cmd[1] = dbd & 0x18; /* allows DBD and LLBA bits */ 1845 cmd[2] = modepage; 1846 1847 /* caller might not be interested in sense, but we need it */ 1848 if (!sshdr) 1849 sshdr = &my_sshdr; 1850 1851 retry: 1852 use_10_for_ms = sdev->use_10_for_ms; 1853 1854 if (use_10_for_ms) { 1855 if (len < 8) 1856 len = 8; 1857 1858 cmd[0] = MODE_SENSE_10; 1859 cmd[8] = len; 1860 header_length = 8; 1861 } else { 1862 if (len < 4) 1863 len = 4; 1864 1865 cmd[0] = MODE_SENSE; 1866 cmd[4] = len; 1867 header_length = 4; 1868 } 1869 1870 memset(buffer, 0, len); 1871 1872 result = scsi_execute_req(sdev, cmd, DMA_FROM_DEVICE, buffer, len, 1873 sshdr, timeout, retries); 1874 1875 /* This code looks awful: what it's doing is making sure an 1876 * ILLEGAL REQUEST sense return identifies the actual command 1877 * byte as the problem. MODE_SENSE commands can return 1878 * ILLEGAL REQUEST if the code page isn't supported */ 1879 1880 if (use_10_for_ms && !scsi_status_is_good(result) && 1881 (driver_byte(result) & DRIVER_SENSE)) { 1882 if (scsi_sense_valid(sshdr)) { 1883 if ((sshdr->sense_key == ILLEGAL_REQUEST) && 1884 (sshdr->asc == 0x20) && (sshdr->ascq == 0)) { 1885 /* 1886 * Invalid command operation code 1887 */ 1888 sdev->use_10_for_ms = 0; 1889 goto retry; 1890 } 1891 } 1892 } 1893 1894 if(scsi_status_is_good(result)) { 1895 data->header_length = header_length; 1896 if(use_10_for_ms) { 1897 data->length = buffer[0]*256 + buffer[1] + 2; 1898 data->medium_type = buffer[2]; 1899 data->device_specific = buffer[3]; 1900 data->longlba = buffer[4] & 0x01; 1901 data->block_descriptor_length = buffer[6]*256 1902 + buffer[7]; 1903 } else { 1904 data->length = buffer[0] + 1; 1905 data->medium_type = buffer[1]; 1906 data->device_specific = buffer[2]; 1907 data->block_descriptor_length = buffer[3]; 1908 } 1909 } 1910 1911 return result; 1912} 1913EXPORT_SYMBOL(scsi_mode_sense); 1914 1915int 1916scsi_test_unit_ready(struct scsi_device *sdev, int timeout, int retries) 1917{ 1918 char cmd[] = { 1919 TEST_UNIT_READY, 0, 0, 0, 0, 0, 1920 }; 1921 struct scsi_sense_hdr sshdr; 1922 int result; 1923 1924 result = scsi_execute_req(sdev, cmd, DMA_NONE, NULL, 0, &sshdr, 1925 timeout, retries); 1926 1927 if ((driver_byte(result) & DRIVER_SENSE) && sdev->removable) { 1928 1929 if ((scsi_sense_valid(&sshdr)) && 1930 ((sshdr.sense_key == UNIT_ATTENTION) || 1931 (sshdr.sense_key == NOT_READY))) { 1932 sdev->changed = 1; 1933 result = 0; 1934 } 1935 } 1936 return result; 1937} 1938EXPORT_SYMBOL(scsi_test_unit_ready); 1939 1940/** 1941 * scsi_device_set_state - Take the given device through the device 1942 * state model. 1943 * @sdev: scsi device to change the state of. 1944 * @state: state to change to. 1945 * 1946 * Returns zero if unsuccessful or an error if the requested 1947 * transition is illegal. 1948 **/ 1949int 1950scsi_device_set_state(struct scsi_device *sdev, enum scsi_device_state state) 1951{ 1952 enum scsi_device_state oldstate = sdev->sdev_state; 1953 1954 if (state == oldstate) 1955 return 0; 1956 1957 switch (state) { 1958 case SDEV_CREATED: 1959 /* There are no legal states that come back to 1960 * created. This is the manually initialised start 1961 * state */ 1962 goto illegal; 1963 1964 case SDEV_RUNNING: 1965 switch (oldstate) { 1966 case SDEV_CREATED: 1967 case SDEV_OFFLINE: 1968 case SDEV_QUIESCE: 1969 case SDEV_BLOCK: 1970 break; 1971 default: 1972 goto illegal; 1973 } 1974 break; 1975 1976 case SDEV_QUIESCE: 1977 switch (oldstate) { 1978 case SDEV_RUNNING: 1979 case SDEV_OFFLINE: 1980 break; 1981 default: 1982 goto illegal; 1983 } 1984 break; 1985 1986 case SDEV_OFFLINE: 1987 switch (oldstate) { 1988 case SDEV_CREATED: 1989 case SDEV_RUNNING: 1990 case SDEV_QUIESCE: 1991 case SDEV_BLOCK: 1992 break; 1993 default: 1994 goto illegal; 1995 } 1996 break; 1997 1998 case SDEV_BLOCK: 1999 switch (oldstate) { 2000 case SDEV_CREATED: 2001 case SDEV_RUNNING: 2002 break; 2003 default: 2004 goto illegal; 2005 } 2006 break; 2007 2008 case SDEV_CANCEL: 2009 switch (oldstate) { 2010 case SDEV_CREATED: 2011 case SDEV_RUNNING: 2012 case SDEV_OFFLINE: 2013 case SDEV_BLOCK: 2014 break; 2015 default: 2016 goto illegal; 2017 } 2018 break; 2019 2020 case SDEV_DEL: 2021 switch (oldstate) { 2022 case SDEV_CANCEL: 2023 break; 2024 default: 2025 goto illegal; 2026 } 2027 break; 2028 2029 } 2030 sdev->sdev_state = state; 2031 return 0; 2032 2033 illegal: 2034 SCSI_LOG_ERROR_RECOVERY(1, 2035 sdev_printk(KERN_ERR, sdev, 2036 "Illegal state transition %s->%s\n", 2037 scsi_device_state_name(oldstate), 2038 scsi_device_state_name(state)) 2039 ); 2040 return -EINVAL; 2041} 2042EXPORT_SYMBOL(scsi_device_set_state); 2043 2044/** 2045 * scsi_device_quiesce - Block user issued commands. 2046 * @sdev: scsi device to quiesce. 2047 * 2048 * This works by trying to transition to the SDEV_QUIESCE state 2049 * (which must be a legal transition). When the device is in this 2050 * state, only special requests will be accepted, all others will 2051 * be deferred. Since special requests may also be requeued requests, 2052 * a successful return doesn't guarantee the device will be 2053 * totally quiescent. 2054 * 2055 * Must be called with user context, may sleep. 2056 * 2057 * Returns zero if unsuccessful or an error if not. 2058 **/ 2059int 2060scsi_device_quiesce(struct scsi_device *sdev) 2061{ 2062 int err = scsi_device_set_state(sdev, SDEV_QUIESCE); 2063 if (err) 2064 return err; 2065 2066 scsi_run_queue(sdev->request_queue); 2067 while (sdev->device_busy) { 2068 msleep_interruptible(200); 2069 scsi_run_queue(sdev->request_queue); 2070 } 2071 return 0; 2072} 2073EXPORT_SYMBOL(scsi_device_quiesce); 2074 2075/** 2076 * scsi_device_resume - Restart user issued commands to a quiesced device. 2077 * @sdev: scsi device to resume. 2078 * 2079 * Moves the device from quiesced back to running and restarts the 2080 * queues. 2081 * 2082 * Must be called with user context, may sleep. 2083 **/ 2084void 2085scsi_device_resume(struct scsi_device *sdev) 2086{ 2087 if(scsi_device_set_state(sdev, SDEV_RUNNING)) 2088 return; 2089 scsi_run_queue(sdev->request_queue); 2090} 2091EXPORT_SYMBOL(scsi_device_resume); 2092 2093static void 2094device_quiesce_fn(struct scsi_device *sdev, void *data) 2095{ 2096 scsi_device_quiesce(sdev); 2097} 2098 2099void 2100scsi_target_quiesce(struct scsi_target *starget) 2101{ 2102 starget_for_each_device(starget, NULL, device_quiesce_fn); 2103} 2104EXPORT_SYMBOL(scsi_target_quiesce); 2105 2106static void 2107device_resume_fn(struct scsi_device *sdev, void *data) 2108{ 2109 scsi_device_resume(sdev); 2110} 2111 2112void 2113scsi_target_resume(struct scsi_target *starget) 2114{ 2115 starget_for_each_device(starget, NULL, device_resume_fn); 2116} 2117EXPORT_SYMBOL(scsi_target_resume); 2118 2119/** 2120 * scsi_internal_device_block - internal function to put a device 2121 * temporarily into the SDEV_BLOCK state 2122 * @sdev: device to block 2123 * 2124 * Block request made by scsi lld's to temporarily stop all 2125 * scsi commands on the specified device. Called from interrupt 2126 * or normal process context. 2127 * 2128 * Returns zero if successful or error if not 2129 * 2130 * Notes: 2131 * This routine transitions the device to the SDEV_BLOCK state 2132 * (which must be a legal transition). When the device is in this 2133 * state, all commands are deferred until the scsi lld reenables 2134 * the device with scsi_device_unblock or device_block_tmo fires. 2135 * This routine assumes the host_lock is held on entry. 2136 **/ 2137int 2138scsi_internal_device_block(struct scsi_device *sdev) 2139{ 2140 request_queue_t *q = sdev->request_queue; 2141 unsigned long flags; 2142 int err = 0; 2143 2144 err = scsi_device_set_state(sdev, SDEV_BLOCK); 2145 if (err) 2146 return err; 2147 2148 /* 2149 * The device has transitioned to SDEV_BLOCK. Stop the 2150 * block layer from calling the midlayer with this device's 2151 * request queue. 2152 */ 2153 spin_lock_irqsave(q->queue_lock, flags); 2154 blk_stop_queue(q); 2155 spin_unlock_irqrestore(q->queue_lock, flags); 2156 2157 return 0; 2158} 2159EXPORT_SYMBOL_GPL(scsi_internal_device_block); 2160 2161/** 2162 * scsi_internal_device_unblock - resume a device after a block request 2163 * @sdev: device to resume 2164 * 2165 * Called by scsi lld's or the midlayer to restart the device queue 2166 * for the previously suspended scsi device. Called from interrupt or 2167 * normal process context. 2168 * 2169 * Returns zero if successful or error if not. 2170 * 2171 * Notes: 2172 * This routine transitions the device to the SDEV_RUNNING state 2173 * (which must be a legal transition) allowing the midlayer to 2174 * goose the queue for this device. This routine assumes the 2175 * host_lock is held upon entry. 2176 **/ 2177int 2178scsi_internal_device_unblock(struct scsi_device *sdev) 2179{ 2180 request_queue_t *q = sdev->request_queue; 2181 int err; 2182 unsigned long flags; 2183 2184 /* 2185 * Try to transition the scsi device to SDEV_RUNNING 2186 * and goose the device queue if successful. 2187 */ 2188 err = scsi_device_set_state(sdev, SDEV_RUNNING); 2189 if (err) 2190 return err; 2191 2192 spin_lock_irqsave(q->queue_lock, flags); 2193 blk_start_queue(q); 2194 spin_unlock_irqrestore(q->queue_lock, flags); 2195 2196 return 0; 2197} 2198EXPORT_SYMBOL_GPL(scsi_internal_device_unblock); 2199 2200static void 2201device_block(struct scsi_device *sdev, void *data) 2202{ 2203 scsi_internal_device_block(sdev); 2204} 2205 2206static int 2207target_block(struct device *dev, void *data) 2208{ 2209 if (scsi_is_target_device(dev)) 2210 starget_for_each_device(to_scsi_target(dev), NULL, 2211 device_block); 2212 return 0; 2213} 2214 2215void 2216scsi_target_block(struct device *dev) 2217{ 2218 if (scsi_is_target_device(dev)) 2219 starget_for_each_device(to_scsi_target(dev), NULL, 2220 device_block); 2221 else 2222 device_for_each_child(dev, NULL, target_block); 2223} 2224EXPORT_SYMBOL_GPL(scsi_target_block); 2225 2226static void 2227device_unblock(struct scsi_device *sdev, void *data) 2228{ 2229 scsi_internal_device_unblock(sdev); 2230} 2231 2232static int 2233target_unblock(struct device *dev, void *data) 2234{ 2235 if (scsi_is_target_device(dev)) 2236 starget_for_each_device(to_scsi_target(dev), NULL, 2237 device_unblock); 2238 return 0; 2239} 2240 2241void 2242scsi_target_unblock(struct device *dev) 2243{ 2244 if (scsi_is_target_device(dev)) 2245 starget_for_each_device(to_scsi_target(dev), NULL, 2246 device_unblock); 2247 else 2248 device_for_each_child(dev, NULL, target_unblock); 2249} 2250EXPORT_SYMBOL_GPL(scsi_target_unblock); 2251