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