scsi_lib.c revision a3bec5c5aea0da263111c4d8f8eabc1f8560d7bf
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 ret = sgl; 774 775 /* 776 * chain previous sglist, if any. we know the previous 777 * sglist must be the biggest one, or we would not have 778 * ended up doing another loop. 779 */ 780 if (prev) 781 sg_chain(prev, SCSI_MAX_SG_SEGMENTS, sgl); 782 783 /* 784 * don't allow subsequent mempool allocs to sleep, it would 785 * violate the mempool principle. 786 */ 787 gfp_mask &= ~__GFP_WAIT; 788 gfp_mask |= __GFP_HIGH; 789 prev = sgl; 790 } while (left); 791 792 /* 793 * ->use_sg may get modified after dma mapping has potentially 794 * shrunk the number of segments, so keep a copy of it for free. 795 */ 796 cmd->__use_sg = cmd->use_sg; 797 return ret; 798enomem: 799 if (ret) { 800 /* 801 * Free entries chained off ret. Since we were trying to 802 * allocate another sglist, we know that all entries are of 803 * the max size. 804 */ 805 sgp = scsi_sg_pools + SG_MEMPOOL_NR - 1; 806 prev = ret; 807 ret = &ret[SCSI_MAX_SG_SEGMENTS - 1]; 808 809 while ((sgl = sg_chain_ptr(ret)) != NULL) { 810 ret = &sgl[SCSI_MAX_SG_SEGMENTS - 1]; 811 mempool_free(sgl, sgp->pool); 812 } 813 814 mempool_free(prev, sgp->pool); 815 } 816 return NULL; 817} 818 819EXPORT_SYMBOL(scsi_alloc_sgtable); 820 821void scsi_free_sgtable(struct scsi_cmnd *cmd) 822{ 823 struct scatterlist *sgl = cmd->request_buffer; 824 struct scsi_host_sg_pool *sgp; 825 826 /* 827 * if this is the biggest size sglist, check if we have 828 * chained parts we need to free 829 */ 830 if (cmd->__use_sg > SCSI_MAX_SG_SEGMENTS) { 831 unsigned short this, left; 832 struct scatterlist *next; 833 unsigned int index; 834 835 left = cmd->__use_sg - (SCSI_MAX_SG_SEGMENTS - 1); 836 next = sg_chain_ptr(&sgl[SCSI_MAX_SG_SEGMENTS - 1]); 837 while (left && next) { 838 sgl = next; 839 this = left; 840 if (this > SCSI_MAX_SG_SEGMENTS) { 841 this = SCSI_MAX_SG_SEGMENTS - 1; 842 index = SG_MEMPOOL_NR - 1; 843 } else 844 index = scsi_sgtable_index(this); 845 846 left -= this; 847 848 sgp = scsi_sg_pools + index; 849 850 if (left) 851 next = sg_chain_ptr(&sgl[sgp->size - 1]); 852 853 mempool_free(sgl, sgp->pool); 854 } 855 856 /* 857 * Restore original, will be freed below 858 */ 859 sgl = cmd->request_buffer; 860 sgp = scsi_sg_pools + SG_MEMPOOL_NR - 1; 861 } else 862 sgp = scsi_sg_pools + scsi_sgtable_index(cmd->__use_sg); 863 864 mempool_free(sgl, sgp->pool); 865} 866 867EXPORT_SYMBOL(scsi_free_sgtable); 868 869/* 870 * Function: scsi_release_buffers() 871 * 872 * Purpose: Completion processing for block device I/O requests. 873 * 874 * Arguments: cmd - command that we are bailing. 875 * 876 * Lock status: Assumed that no lock is held upon entry. 877 * 878 * Returns: Nothing 879 * 880 * Notes: In the event that an upper level driver rejects a 881 * command, we must release resources allocated during 882 * the __init_io() function. Primarily this would involve 883 * the scatter-gather table, and potentially any bounce 884 * buffers. 885 */ 886static void scsi_release_buffers(struct scsi_cmnd *cmd) 887{ 888 if (cmd->use_sg) 889 scsi_free_sgtable(cmd); 890 891 /* 892 * Zero these out. They now point to freed memory, and it is 893 * dangerous to hang onto the pointers. 894 */ 895 cmd->request_buffer = NULL; 896 cmd->request_bufflen = 0; 897} 898 899/* 900 * Function: scsi_io_completion() 901 * 902 * Purpose: Completion processing for block device I/O requests. 903 * 904 * Arguments: cmd - command that is finished. 905 * 906 * Lock status: Assumed that no lock is held upon entry. 907 * 908 * Returns: Nothing 909 * 910 * Notes: This function is matched in terms of capabilities to 911 * the function that created the scatter-gather list. 912 * In other words, if there are no bounce buffers 913 * (the normal case for most drivers), we don't need 914 * the logic to deal with cleaning up afterwards. 915 * 916 * We must do one of several things here: 917 * 918 * a) Call scsi_end_request. This will finish off the 919 * specified number of sectors. If we are done, the 920 * command block will be released, and the queue 921 * function will be goosed. If we are not done, then 922 * scsi_end_request will directly goose the queue. 923 * 924 * b) We can just use scsi_requeue_command() here. This would 925 * be used if we just wanted to retry, for example. 926 */ 927void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes) 928{ 929 int result = cmd->result; 930 int this_count = cmd->request_bufflen; 931 struct request_queue *q = cmd->device->request_queue; 932 struct request *req = cmd->request; 933 int clear_errors = 1; 934 struct scsi_sense_hdr sshdr; 935 int sense_valid = 0; 936 int sense_deferred = 0; 937 938 scsi_release_buffers(cmd); 939 940 if (result) { 941 sense_valid = scsi_command_normalize_sense(cmd, &sshdr); 942 if (sense_valid) 943 sense_deferred = scsi_sense_is_deferred(&sshdr); 944 } 945 946 if (blk_pc_request(req)) { /* SG_IO ioctl from block level */ 947 req->errors = result; 948 if (result) { 949 clear_errors = 0; 950 if (sense_valid && req->sense) { 951 /* 952 * SG_IO wants current and deferred errors 953 */ 954 int len = 8 + cmd->sense_buffer[7]; 955 956 if (len > SCSI_SENSE_BUFFERSIZE) 957 len = SCSI_SENSE_BUFFERSIZE; 958 memcpy(req->sense, cmd->sense_buffer, len); 959 req->sense_len = len; 960 } 961 } 962 req->data_len = cmd->resid; 963 } 964 965 /* 966 * Next deal with any sectors which we were able to correctly 967 * handle. 968 */ 969 SCSI_LOG_HLCOMPLETE(1, printk("%ld sectors total, " 970 "%d bytes done.\n", 971 req->nr_sectors, good_bytes)); 972 SCSI_LOG_HLCOMPLETE(1, printk("use_sg is %d\n", cmd->use_sg)); 973 974 if (clear_errors) 975 req->errors = 0; 976 977 /* A number of bytes were successfully read. If there 978 * are leftovers and there is some kind of error 979 * (result != 0), retry the rest. 980 */ 981 if (scsi_end_request(cmd, 1, good_bytes, result == 0) == NULL) 982 return; 983 984 /* good_bytes = 0, or (inclusive) there were leftovers and 985 * result = 0, so scsi_end_request couldn't retry. 986 */ 987 if (sense_valid && !sense_deferred) { 988 switch (sshdr.sense_key) { 989 case UNIT_ATTENTION: 990 if (cmd->device->removable) { 991 /* Detected disc change. Set a bit 992 * and quietly refuse further access. 993 */ 994 cmd->device->changed = 1; 995 scsi_end_request(cmd, 0, this_count, 1); 996 return; 997 } else { 998 /* Must have been a power glitch, or a 999 * bus reset. Could not have been a 1000 * media change, so we just retry the 1001 * request and see what happens. 1002 */ 1003 scsi_requeue_command(q, cmd); 1004 return; 1005 } 1006 break; 1007 case ILLEGAL_REQUEST: 1008 /* If we had an ILLEGAL REQUEST returned, then 1009 * we may have performed an unsupported 1010 * command. The only thing this should be 1011 * would be a ten byte read where only a six 1012 * byte read was supported. Also, on a system 1013 * where READ CAPACITY failed, we may have 1014 * read past the end of the disk. 1015 */ 1016 if ((cmd->device->use_10_for_rw && 1017 sshdr.asc == 0x20 && sshdr.ascq == 0x00) && 1018 (cmd->cmnd[0] == READ_10 || 1019 cmd->cmnd[0] == WRITE_10)) { 1020 cmd->device->use_10_for_rw = 0; 1021 /* This will cause a retry with a 1022 * 6-byte command. 1023 */ 1024 scsi_requeue_command(q, cmd); 1025 return; 1026 } else { 1027 scsi_end_request(cmd, 0, this_count, 1); 1028 return; 1029 } 1030 break; 1031 case NOT_READY: 1032 /* If the device is in the process of becoming 1033 * ready, or has a temporary blockage, retry. 1034 */ 1035 if (sshdr.asc == 0x04) { 1036 switch (sshdr.ascq) { 1037 case 0x01: /* becoming ready */ 1038 case 0x04: /* format in progress */ 1039 case 0x05: /* rebuild in progress */ 1040 case 0x06: /* recalculation in progress */ 1041 case 0x07: /* operation in progress */ 1042 case 0x08: /* Long write in progress */ 1043 case 0x09: /* self test in progress */ 1044 scsi_requeue_command(q, cmd); 1045 return; 1046 default: 1047 break; 1048 } 1049 } 1050 if (!(req->cmd_flags & REQ_QUIET)) 1051 scsi_cmd_print_sense_hdr(cmd, 1052 "Device not ready", 1053 &sshdr); 1054 1055 scsi_end_request(cmd, 0, this_count, 1); 1056 return; 1057 case VOLUME_OVERFLOW: 1058 if (!(req->cmd_flags & REQ_QUIET)) { 1059 scmd_printk(KERN_INFO, cmd, 1060 "Volume overflow, CDB: "); 1061 __scsi_print_command(cmd->cmnd); 1062 scsi_print_sense("", cmd); 1063 } 1064 /* See SSC3rXX or current. */ 1065 scsi_end_request(cmd, 0, this_count, 1); 1066 return; 1067 default: 1068 break; 1069 } 1070 } 1071 if (host_byte(result) == DID_RESET) { 1072 /* Third party bus reset or reset for error recovery 1073 * reasons. Just retry the request and see what 1074 * happens. 1075 */ 1076 scsi_requeue_command(q, cmd); 1077 return; 1078 } 1079 if (result) { 1080 if (!(req->cmd_flags & REQ_QUIET)) { 1081 scsi_print_result(cmd); 1082 if (driver_byte(result) & DRIVER_SENSE) 1083 scsi_print_sense("", cmd); 1084 } 1085 } 1086 scsi_end_request(cmd, 0, this_count, !result); 1087} 1088 1089/* 1090 * Function: scsi_init_io() 1091 * 1092 * Purpose: SCSI I/O initialize function. 1093 * 1094 * Arguments: cmd - Command descriptor we wish to initialize 1095 * 1096 * Returns: 0 on success 1097 * BLKPREP_DEFER if the failure is retryable 1098 * BLKPREP_KILL if the failure is fatal 1099 */ 1100static int scsi_init_io(struct scsi_cmnd *cmd) 1101{ 1102 struct request *req = cmd->request; 1103 int count; 1104 1105 /* 1106 * We used to not use scatter-gather for single segment request, 1107 * but now we do (it makes highmem I/O easier to support without 1108 * kmapping pages) 1109 */ 1110 cmd->use_sg = req->nr_phys_segments; 1111 1112 /* 1113 * If sg table allocation fails, requeue request later. 1114 */ 1115 cmd->request_buffer = scsi_alloc_sgtable(cmd, GFP_ATOMIC); 1116 if (unlikely(!cmd->request_buffer)) { 1117 scsi_unprep_request(req); 1118 return BLKPREP_DEFER; 1119 } 1120 1121 req->buffer = NULL; 1122 if (blk_pc_request(req)) 1123 cmd->request_bufflen = req->data_len; 1124 else 1125 cmd->request_bufflen = req->nr_sectors << 9; 1126 1127 /* 1128 * Next, walk the list, and fill in the addresses and sizes of 1129 * each segment. 1130 */ 1131 count = blk_rq_map_sg(req->q, req, cmd->request_buffer); 1132 if (likely(count <= cmd->use_sg)) { 1133 cmd->use_sg = count; 1134 return BLKPREP_OK; 1135 } 1136 1137 printk(KERN_ERR "Incorrect number of segments after building list\n"); 1138 printk(KERN_ERR "counted %d, received %d\n", count, cmd->use_sg); 1139 printk(KERN_ERR "req nr_sec %lu, cur_nr_sec %u\n", req->nr_sectors, 1140 req->current_nr_sectors); 1141 1142 return BLKPREP_KILL; 1143} 1144 1145static struct scsi_cmnd *scsi_get_cmd_from_req(struct scsi_device *sdev, 1146 struct request *req) 1147{ 1148 struct scsi_cmnd *cmd; 1149 1150 if (!req->special) { 1151 cmd = scsi_get_command(sdev, GFP_ATOMIC); 1152 if (unlikely(!cmd)) 1153 return NULL; 1154 req->special = cmd; 1155 } else { 1156 cmd = req->special; 1157 } 1158 1159 /* pull a tag out of the request if we have one */ 1160 cmd->tag = req->tag; 1161 cmd->request = req; 1162 1163 return cmd; 1164} 1165 1166int scsi_setup_blk_pc_cmnd(struct scsi_device *sdev, struct request *req) 1167{ 1168 struct scsi_cmnd *cmd; 1169 int ret = scsi_prep_state_check(sdev, req); 1170 1171 if (ret != BLKPREP_OK) 1172 return ret; 1173 1174 cmd = scsi_get_cmd_from_req(sdev, req); 1175 if (unlikely(!cmd)) 1176 return BLKPREP_DEFER; 1177 1178 /* 1179 * BLOCK_PC requests may transfer data, in which case they must 1180 * a bio attached to them. Or they might contain a SCSI command 1181 * that does not transfer data, in which case they may optionally 1182 * submit a request without an attached bio. 1183 */ 1184 if (req->bio) { 1185 int ret; 1186 1187 BUG_ON(!req->nr_phys_segments); 1188 1189 ret = scsi_init_io(cmd); 1190 if (unlikely(ret)) 1191 return ret; 1192 } else { 1193 BUG_ON(req->data_len); 1194 BUG_ON(req->data); 1195 1196 cmd->request_bufflen = 0; 1197 cmd->request_buffer = NULL; 1198 cmd->use_sg = 0; 1199 req->buffer = NULL; 1200 } 1201 1202 BUILD_BUG_ON(sizeof(req->cmd) > sizeof(cmd->cmnd)); 1203 memcpy(cmd->cmnd, req->cmd, sizeof(cmd->cmnd)); 1204 cmd->cmd_len = req->cmd_len; 1205 if (!req->data_len) 1206 cmd->sc_data_direction = DMA_NONE; 1207 else if (rq_data_dir(req) == WRITE) 1208 cmd->sc_data_direction = DMA_TO_DEVICE; 1209 else 1210 cmd->sc_data_direction = DMA_FROM_DEVICE; 1211 1212 cmd->transfersize = req->data_len; 1213 cmd->allowed = req->retries; 1214 cmd->timeout_per_command = req->timeout; 1215 return BLKPREP_OK; 1216} 1217EXPORT_SYMBOL(scsi_setup_blk_pc_cmnd); 1218 1219/* 1220 * Setup a REQ_TYPE_FS command. These are simple read/write request 1221 * from filesystems that still need to be translated to SCSI CDBs from 1222 * the ULD. 1223 */ 1224int scsi_setup_fs_cmnd(struct scsi_device *sdev, struct request *req) 1225{ 1226 struct scsi_cmnd *cmd; 1227 int ret = scsi_prep_state_check(sdev, req); 1228 1229 if (ret != BLKPREP_OK) 1230 return ret; 1231 /* 1232 * Filesystem requests must transfer data. 1233 */ 1234 BUG_ON(!req->nr_phys_segments); 1235 1236 cmd = scsi_get_cmd_from_req(sdev, req); 1237 if (unlikely(!cmd)) 1238 return BLKPREP_DEFER; 1239 1240 return scsi_init_io(cmd); 1241} 1242EXPORT_SYMBOL(scsi_setup_fs_cmnd); 1243 1244int scsi_prep_state_check(struct scsi_device *sdev, struct request *req) 1245{ 1246 int ret = BLKPREP_OK; 1247 1248 /* 1249 * If the device is not in running state we will reject some 1250 * or all commands. 1251 */ 1252 if (unlikely(sdev->sdev_state != SDEV_RUNNING)) { 1253 switch (sdev->sdev_state) { 1254 case SDEV_OFFLINE: 1255 /* 1256 * If the device is offline we refuse to process any 1257 * commands. The device must be brought online 1258 * before trying any recovery commands. 1259 */ 1260 sdev_printk(KERN_ERR, sdev, 1261 "rejecting I/O to offline device\n"); 1262 ret = BLKPREP_KILL; 1263 break; 1264 case SDEV_DEL: 1265 /* 1266 * If the device is fully deleted, we refuse to 1267 * process any commands as well. 1268 */ 1269 sdev_printk(KERN_ERR, sdev, 1270 "rejecting I/O to dead device\n"); 1271 ret = BLKPREP_KILL; 1272 break; 1273 case SDEV_QUIESCE: 1274 case SDEV_BLOCK: 1275 /* 1276 * If the devices is blocked we defer normal commands. 1277 */ 1278 if (!(req->cmd_flags & REQ_PREEMPT)) 1279 ret = BLKPREP_DEFER; 1280 break; 1281 default: 1282 /* 1283 * For any other not fully online state we only allow 1284 * special commands. In particular any user initiated 1285 * command is not allowed. 1286 */ 1287 if (!(req->cmd_flags & REQ_PREEMPT)) 1288 ret = BLKPREP_KILL; 1289 break; 1290 } 1291 } 1292 return ret; 1293} 1294EXPORT_SYMBOL(scsi_prep_state_check); 1295 1296int scsi_prep_return(struct request_queue *q, struct request *req, int ret) 1297{ 1298 struct scsi_device *sdev = q->queuedata; 1299 1300 switch (ret) { 1301 case BLKPREP_KILL: 1302 req->errors = DID_NO_CONNECT << 16; 1303 /* release the command and kill it */ 1304 if (req->special) { 1305 struct scsi_cmnd *cmd = req->special; 1306 scsi_release_buffers(cmd); 1307 scsi_put_command(cmd); 1308 req->special = NULL; 1309 } 1310 break; 1311 case BLKPREP_DEFER: 1312 /* 1313 * If we defer, the elv_next_request() returns NULL, but the 1314 * queue must be restarted, so we plug here if no returning 1315 * command will automatically do that. 1316 */ 1317 if (sdev->device_busy == 0) 1318 blk_plug_device(q); 1319 break; 1320 default: 1321 req->cmd_flags |= REQ_DONTPREP; 1322 } 1323 1324 return ret; 1325} 1326EXPORT_SYMBOL(scsi_prep_return); 1327 1328static int scsi_prep_fn(struct request_queue *q, struct request *req) 1329{ 1330 struct scsi_device *sdev = q->queuedata; 1331 int ret = BLKPREP_KILL; 1332 1333 if (req->cmd_type == REQ_TYPE_BLOCK_PC) 1334 ret = scsi_setup_blk_pc_cmnd(sdev, req); 1335 return scsi_prep_return(q, req, ret); 1336} 1337 1338/* 1339 * scsi_dev_queue_ready: if we can send requests to sdev, return 1 else 1340 * return 0. 1341 * 1342 * Called with the queue_lock held. 1343 */ 1344static inline int scsi_dev_queue_ready(struct request_queue *q, 1345 struct scsi_device *sdev) 1346{ 1347 if (sdev->device_busy >= sdev->queue_depth) 1348 return 0; 1349 if (sdev->device_busy == 0 && sdev->device_blocked) { 1350 /* 1351 * unblock after device_blocked iterates to zero 1352 */ 1353 if (--sdev->device_blocked == 0) { 1354 SCSI_LOG_MLQUEUE(3, 1355 sdev_printk(KERN_INFO, sdev, 1356 "unblocking device at zero depth\n")); 1357 } else { 1358 blk_plug_device(q); 1359 return 0; 1360 } 1361 } 1362 if (sdev->device_blocked) 1363 return 0; 1364 1365 return 1; 1366} 1367 1368/* 1369 * scsi_host_queue_ready: if we can send requests to shost, return 1 else 1370 * return 0. We must end up running the queue again whenever 0 is 1371 * returned, else IO can hang. 1372 * 1373 * Called with host_lock held. 1374 */ 1375static inline int scsi_host_queue_ready(struct request_queue *q, 1376 struct Scsi_Host *shost, 1377 struct scsi_device *sdev) 1378{ 1379 if (scsi_host_in_recovery(shost)) 1380 return 0; 1381 if (shost->host_busy == 0 && shost->host_blocked) { 1382 /* 1383 * unblock after host_blocked iterates to zero 1384 */ 1385 if (--shost->host_blocked == 0) { 1386 SCSI_LOG_MLQUEUE(3, 1387 printk("scsi%d unblocking host at zero depth\n", 1388 shost->host_no)); 1389 } else { 1390 blk_plug_device(q); 1391 return 0; 1392 } 1393 } 1394 if ((shost->can_queue > 0 && shost->host_busy >= shost->can_queue) || 1395 shost->host_blocked || shost->host_self_blocked) { 1396 if (list_empty(&sdev->starved_entry)) 1397 list_add_tail(&sdev->starved_entry, &shost->starved_list); 1398 return 0; 1399 } 1400 1401 /* We're OK to process the command, so we can't be starved */ 1402 if (!list_empty(&sdev->starved_entry)) 1403 list_del_init(&sdev->starved_entry); 1404 1405 return 1; 1406} 1407 1408/* 1409 * Kill a request for a dead device 1410 */ 1411static void scsi_kill_request(struct request *req, struct request_queue *q) 1412{ 1413 struct scsi_cmnd *cmd = req->special; 1414 struct scsi_device *sdev = cmd->device; 1415 struct Scsi_Host *shost = sdev->host; 1416 1417 blkdev_dequeue_request(req); 1418 1419 if (unlikely(cmd == NULL)) { 1420 printk(KERN_CRIT "impossible request in %s.\n", 1421 __FUNCTION__); 1422 BUG(); 1423 } 1424 1425 scsi_init_cmd_errh(cmd); 1426 cmd->result = DID_NO_CONNECT << 16; 1427 atomic_inc(&cmd->device->iorequest_cnt); 1428 1429 /* 1430 * SCSI request completion path will do scsi_device_unbusy(), 1431 * bump busy counts. To bump the counters, we need to dance 1432 * with the locks as normal issue path does. 1433 */ 1434 sdev->device_busy++; 1435 spin_unlock(sdev->request_queue->queue_lock); 1436 spin_lock(shost->host_lock); 1437 shost->host_busy++; 1438 spin_unlock(shost->host_lock); 1439 spin_lock(sdev->request_queue->queue_lock); 1440 1441 __scsi_done(cmd); 1442} 1443 1444static void scsi_softirq_done(struct request *rq) 1445{ 1446 struct scsi_cmnd *cmd = rq->completion_data; 1447 unsigned long wait_for = (cmd->allowed + 1) * cmd->timeout_per_command; 1448 int disposition; 1449 1450 INIT_LIST_HEAD(&cmd->eh_entry); 1451 1452 disposition = scsi_decide_disposition(cmd); 1453 if (disposition != SUCCESS && 1454 time_before(cmd->jiffies_at_alloc + wait_for, jiffies)) { 1455 sdev_printk(KERN_ERR, cmd->device, 1456 "timing out command, waited %lus\n", 1457 wait_for/HZ); 1458 disposition = SUCCESS; 1459 } 1460 1461 scsi_log_completion(cmd, disposition); 1462 1463 switch (disposition) { 1464 case SUCCESS: 1465 scsi_finish_command(cmd); 1466 break; 1467 case NEEDS_RETRY: 1468 scsi_queue_insert(cmd, SCSI_MLQUEUE_EH_RETRY); 1469 break; 1470 case ADD_TO_MLQUEUE: 1471 scsi_queue_insert(cmd, SCSI_MLQUEUE_DEVICE_BUSY); 1472 break; 1473 default: 1474 if (!scsi_eh_scmd_add(cmd, 0)) 1475 scsi_finish_command(cmd); 1476 } 1477} 1478 1479/* 1480 * Function: scsi_request_fn() 1481 * 1482 * Purpose: Main strategy routine for SCSI. 1483 * 1484 * Arguments: q - Pointer to actual queue. 1485 * 1486 * Returns: Nothing 1487 * 1488 * Lock status: IO request lock assumed to be held when called. 1489 */ 1490static void scsi_request_fn(struct request_queue *q) 1491{ 1492 struct scsi_device *sdev = q->queuedata; 1493 struct Scsi_Host *shost; 1494 struct scsi_cmnd *cmd; 1495 struct request *req; 1496 1497 if (!sdev) { 1498 printk("scsi: killing requests for dead queue\n"); 1499 while ((req = elv_next_request(q)) != NULL) 1500 scsi_kill_request(req, q); 1501 return; 1502 } 1503 1504 if(!get_device(&sdev->sdev_gendev)) 1505 /* We must be tearing the block queue down already */ 1506 return; 1507 1508 /* 1509 * To start with, we keep looping until the queue is empty, or until 1510 * the host is no longer able to accept any more requests. 1511 */ 1512 shost = sdev->host; 1513 while (!blk_queue_plugged(q)) { 1514 int rtn; 1515 /* 1516 * get next queueable request. We do this early to make sure 1517 * that the request is fully prepared even if we cannot 1518 * accept it. 1519 */ 1520 req = elv_next_request(q); 1521 if (!req || !scsi_dev_queue_ready(q, sdev)) 1522 break; 1523 1524 if (unlikely(!scsi_device_online(sdev))) { 1525 sdev_printk(KERN_ERR, sdev, 1526 "rejecting I/O to offline device\n"); 1527 scsi_kill_request(req, q); 1528 continue; 1529 } 1530 1531 1532 /* 1533 * Remove the request from the request list. 1534 */ 1535 if (!(blk_queue_tagged(q) && !blk_queue_start_tag(q, req))) 1536 blkdev_dequeue_request(req); 1537 sdev->device_busy++; 1538 1539 spin_unlock(q->queue_lock); 1540 cmd = req->special; 1541 if (unlikely(cmd == NULL)) { 1542 printk(KERN_CRIT "impossible request in %s.\n" 1543 "please mail a stack trace to " 1544 "linux-scsi@vger.kernel.org\n", 1545 __FUNCTION__); 1546 blk_dump_rq_flags(req, "foo"); 1547 BUG(); 1548 } 1549 spin_lock(shost->host_lock); 1550 1551 if (!scsi_host_queue_ready(q, shost, sdev)) 1552 goto not_ready; 1553 if (sdev->single_lun) { 1554 if (scsi_target(sdev)->starget_sdev_user && 1555 scsi_target(sdev)->starget_sdev_user != sdev) 1556 goto not_ready; 1557 scsi_target(sdev)->starget_sdev_user = sdev; 1558 } 1559 shost->host_busy++; 1560 1561 /* 1562 * XXX(hch): This is rather suboptimal, scsi_dispatch_cmd will 1563 * take the lock again. 1564 */ 1565 spin_unlock_irq(shost->host_lock); 1566 1567 /* 1568 * Finally, initialize any error handling parameters, and set up 1569 * the timers for timeouts. 1570 */ 1571 scsi_init_cmd_errh(cmd); 1572 1573 /* 1574 * Dispatch the command to the low-level driver. 1575 */ 1576 rtn = scsi_dispatch_cmd(cmd); 1577 spin_lock_irq(q->queue_lock); 1578 if(rtn) { 1579 /* we're refusing the command; because of 1580 * the way locks get dropped, we need to 1581 * check here if plugging is required */ 1582 if(sdev->device_busy == 0) 1583 blk_plug_device(q); 1584 1585 break; 1586 } 1587 } 1588 1589 goto out; 1590 1591 not_ready: 1592 spin_unlock_irq(shost->host_lock); 1593 1594 /* 1595 * lock q, handle tag, requeue req, and decrement device_busy. We 1596 * must return with queue_lock held. 1597 * 1598 * Decrementing device_busy without checking it is OK, as all such 1599 * cases (host limits or settings) should run the queue at some 1600 * later time. 1601 */ 1602 spin_lock_irq(q->queue_lock); 1603 blk_requeue_request(q, req); 1604 sdev->device_busy--; 1605 if(sdev->device_busy == 0) 1606 blk_plug_device(q); 1607 out: 1608 /* must be careful here...if we trigger the ->remove() function 1609 * we cannot be holding the q lock */ 1610 spin_unlock_irq(q->queue_lock); 1611 put_device(&sdev->sdev_gendev); 1612 spin_lock_irq(q->queue_lock); 1613} 1614 1615u64 scsi_calculate_bounce_limit(struct Scsi_Host *shost) 1616{ 1617 struct device *host_dev; 1618 u64 bounce_limit = 0xffffffff; 1619 1620 if (shost->unchecked_isa_dma) 1621 return BLK_BOUNCE_ISA; 1622 /* 1623 * Platforms with virtual-DMA translation 1624 * hardware have no practical limit. 1625 */ 1626 if (!PCI_DMA_BUS_IS_PHYS) 1627 return BLK_BOUNCE_ANY; 1628 1629 host_dev = scsi_get_device(shost); 1630 if (host_dev && host_dev->dma_mask) 1631 bounce_limit = *host_dev->dma_mask; 1632 1633 return bounce_limit; 1634} 1635EXPORT_SYMBOL(scsi_calculate_bounce_limit); 1636 1637struct request_queue *__scsi_alloc_queue(struct Scsi_Host *shost, 1638 request_fn_proc *request_fn) 1639{ 1640 struct request_queue *q; 1641 1642 q = blk_init_queue(request_fn, NULL); 1643 if (!q) 1644 return NULL; 1645 1646 /* 1647 * this limit is imposed by hardware restrictions 1648 */ 1649 blk_queue_max_hw_segments(q, shost->sg_tablesize); 1650 1651 /* 1652 * In the future, sg chaining support will be mandatory and this 1653 * ifdef can then go away. Right now we don't have all archs 1654 * converted, so better keep it safe. 1655 */ 1656#ifdef ARCH_HAS_SG_CHAIN 1657 if (shost->use_sg_chaining) 1658 blk_queue_max_phys_segments(q, SCSI_MAX_SG_CHAIN_SEGMENTS); 1659 else 1660 blk_queue_max_phys_segments(q, SCSI_MAX_SG_SEGMENTS); 1661#else 1662 blk_queue_max_phys_segments(q, SCSI_MAX_SG_SEGMENTS); 1663#endif 1664 1665 blk_queue_max_sectors(q, shost->max_sectors); 1666 blk_queue_bounce_limit(q, scsi_calculate_bounce_limit(shost)); 1667 blk_queue_segment_boundary(q, shost->dma_boundary); 1668 1669 if (!shost->use_clustering) 1670 clear_bit(QUEUE_FLAG_CLUSTER, &q->queue_flags); 1671 return q; 1672} 1673EXPORT_SYMBOL(__scsi_alloc_queue); 1674 1675struct request_queue *scsi_alloc_queue(struct scsi_device *sdev) 1676{ 1677 struct request_queue *q; 1678 1679 q = __scsi_alloc_queue(sdev->host, scsi_request_fn); 1680 if (!q) 1681 return NULL; 1682 1683 blk_queue_prep_rq(q, scsi_prep_fn); 1684 blk_queue_softirq_done(q, scsi_softirq_done); 1685 return q; 1686} 1687 1688void scsi_free_queue(struct request_queue *q) 1689{ 1690 blk_cleanup_queue(q); 1691} 1692 1693/* 1694 * Function: scsi_block_requests() 1695 * 1696 * Purpose: Utility function used by low-level drivers to prevent further 1697 * commands from being queued to the device. 1698 * 1699 * Arguments: shost - Host in question 1700 * 1701 * Returns: Nothing 1702 * 1703 * Lock status: No locks are assumed held. 1704 * 1705 * Notes: There is no timer nor any other means by which the requests 1706 * get unblocked other than the low-level driver calling 1707 * scsi_unblock_requests(). 1708 */ 1709void scsi_block_requests(struct Scsi_Host *shost) 1710{ 1711 shost->host_self_blocked = 1; 1712} 1713EXPORT_SYMBOL(scsi_block_requests); 1714 1715/* 1716 * Function: scsi_unblock_requests() 1717 * 1718 * Purpose: Utility function used by low-level drivers to allow further 1719 * commands from being queued to the device. 1720 * 1721 * Arguments: shost - Host in question 1722 * 1723 * Returns: Nothing 1724 * 1725 * Lock status: No locks are assumed held. 1726 * 1727 * Notes: There is no timer nor any other means by which the requests 1728 * get unblocked other than the low-level driver calling 1729 * scsi_unblock_requests(). 1730 * 1731 * This is done as an API function so that changes to the 1732 * internals of the scsi mid-layer won't require wholesale 1733 * changes to drivers that use this feature. 1734 */ 1735void scsi_unblock_requests(struct Scsi_Host *shost) 1736{ 1737 shost->host_self_blocked = 0; 1738 scsi_run_host_queues(shost); 1739} 1740EXPORT_SYMBOL(scsi_unblock_requests); 1741 1742int __init scsi_init_queue(void) 1743{ 1744 int i; 1745 1746 scsi_io_context_cache = kmem_cache_create("scsi_io_context", 1747 sizeof(struct scsi_io_context), 1748 0, 0, NULL); 1749 if (!scsi_io_context_cache) { 1750 printk(KERN_ERR "SCSI: can't init scsi io context cache\n"); 1751 return -ENOMEM; 1752 } 1753 1754 for (i = 0; i < SG_MEMPOOL_NR; i++) { 1755 struct scsi_host_sg_pool *sgp = scsi_sg_pools + i; 1756 int size = sgp->size * sizeof(struct scatterlist); 1757 1758 sgp->slab = kmem_cache_create(sgp->name, size, 0, 1759 SLAB_HWCACHE_ALIGN, NULL); 1760 if (!sgp->slab) { 1761 printk(KERN_ERR "SCSI: can't init sg slab %s\n", 1762 sgp->name); 1763 } 1764 1765 sgp->pool = mempool_create_slab_pool(SG_MEMPOOL_SIZE, 1766 sgp->slab); 1767 if (!sgp->pool) { 1768 printk(KERN_ERR "SCSI: can't init sg mempool %s\n", 1769 sgp->name); 1770 } 1771 } 1772 1773 return 0; 1774} 1775 1776void scsi_exit_queue(void) 1777{ 1778 int i; 1779 1780 kmem_cache_destroy(scsi_io_context_cache); 1781 1782 for (i = 0; i < SG_MEMPOOL_NR; i++) { 1783 struct scsi_host_sg_pool *sgp = scsi_sg_pools + i; 1784 mempool_destroy(sgp->pool); 1785 kmem_cache_destroy(sgp->slab); 1786 } 1787} 1788 1789/** 1790 * scsi_mode_select - issue a mode select 1791 * @sdev: SCSI device to be queried 1792 * @pf: Page format bit (1 == standard, 0 == vendor specific) 1793 * @sp: Save page bit (0 == don't save, 1 == save) 1794 * @modepage: mode page being requested 1795 * @buffer: request buffer (may not be smaller than eight bytes) 1796 * @len: length of request buffer. 1797 * @timeout: command timeout 1798 * @retries: number of retries before failing 1799 * @data: returns a structure abstracting the mode header data 1800 * @sense: place to put sense data (or NULL if no sense to be collected). 1801 * must be SCSI_SENSE_BUFFERSIZE big. 1802 * 1803 * Returns zero if successful; negative error number or scsi 1804 * status on error 1805 * 1806 */ 1807int 1808scsi_mode_select(struct scsi_device *sdev, int pf, int sp, int modepage, 1809 unsigned char *buffer, int len, int timeout, int retries, 1810 struct scsi_mode_data *data, struct scsi_sense_hdr *sshdr) 1811{ 1812 unsigned char cmd[10]; 1813 unsigned char *real_buffer; 1814 int ret; 1815 1816 memset(cmd, 0, sizeof(cmd)); 1817 cmd[1] = (pf ? 0x10 : 0) | (sp ? 0x01 : 0); 1818 1819 if (sdev->use_10_for_ms) { 1820 if (len > 65535) 1821 return -EINVAL; 1822 real_buffer = kmalloc(8 + len, GFP_KERNEL); 1823 if (!real_buffer) 1824 return -ENOMEM; 1825 memcpy(real_buffer + 8, buffer, len); 1826 len += 8; 1827 real_buffer[0] = 0; 1828 real_buffer[1] = 0; 1829 real_buffer[2] = data->medium_type; 1830 real_buffer[3] = data->device_specific; 1831 real_buffer[4] = data->longlba ? 0x01 : 0; 1832 real_buffer[5] = 0; 1833 real_buffer[6] = data->block_descriptor_length >> 8; 1834 real_buffer[7] = data->block_descriptor_length; 1835 1836 cmd[0] = MODE_SELECT_10; 1837 cmd[7] = len >> 8; 1838 cmd[8] = len; 1839 } else { 1840 if (len > 255 || data->block_descriptor_length > 255 || 1841 data->longlba) 1842 return -EINVAL; 1843 1844 real_buffer = kmalloc(4 + len, GFP_KERNEL); 1845 if (!real_buffer) 1846 return -ENOMEM; 1847 memcpy(real_buffer + 4, buffer, len); 1848 len += 4; 1849 real_buffer[0] = 0; 1850 real_buffer[1] = data->medium_type; 1851 real_buffer[2] = data->device_specific; 1852 real_buffer[3] = data->block_descriptor_length; 1853 1854 1855 cmd[0] = MODE_SELECT; 1856 cmd[4] = len; 1857 } 1858 1859 ret = scsi_execute_req(sdev, cmd, DMA_TO_DEVICE, real_buffer, len, 1860 sshdr, timeout, retries); 1861 kfree(real_buffer); 1862 return ret; 1863} 1864EXPORT_SYMBOL_GPL(scsi_mode_select); 1865 1866/** 1867 * scsi_mode_sense - issue a mode sense, falling back from 10 to 1868 * six bytes if necessary. 1869 * @sdev: SCSI device to be queried 1870 * @dbd: set if mode sense will allow block descriptors to be returned 1871 * @modepage: mode page being requested 1872 * @buffer: request buffer (may not be smaller than eight bytes) 1873 * @len: length of request buffer. 1874 * @timeout: command timeout 1875 * @retries: number of retries before failing 1876 * @data: returns a structure abstracting the mode header data 1877 * @sense: place to put sense data (or NULL if no sense to be collected). 1878 * must be SCSI_SENSE_BUFFERSIZE big. 1879 * 1880 * Returns zero if unsuccessful, or the header offset (either 4 1881 * or 8 depending on whether a six or ten byte command was 1882 * issued) if successful. 1883 **/ 1884int 1885scsi_mode_sense(struct scsi_device *sdev, int dbd, int modepage, 1886 unsigned char *buffer, int len, int timeout, int retries, 1887 struct scsi_mode_data *data, struct scsi_sense_hdr *sshdr) 1888{ 1889 unsigned char cmd[12]; 1890 int use_10_for_ms; 1891 int header_length; 1892 int result; 1893 struct scsi_sense_hdr my_sshdr; 1894 1895 memset(data, 0, sizeof(*data)); 1896 memset(&cmd[0], 0, 12); 1897 cmd[1] = dbd & 0x18; /* allows DBD and LLBA bits */ 1898 cmd[2] = modepage; 1899 1900 /* caller might not be interested in sense, but we need it */ 1901 if (!sshdr) 1902 sshdr = &my_sshdr; 1903 1904 retry: 1905 use_10_for_ms = sdev->use_10_for_ms; 1906 1907 if (use_10_for_ms) { 1908 if (len < 8) 1909 len = 8; 1910 1911 cmd[0] = MODE_SENSE_10; 1912 cmd[8] = len; 1913 header_length = 8; 1914 } else { 1915 if (len < 4) 1916 len = 4; 1917 1918 cmd[0] = MODE_SENSE; 1919 cmd[4] = len; 1920 header_length = 4; 1921 } 1922 1923 memset(buffer, 0, len); 1924 1925 result = scsi_execute_req(sdev, cmd, DMA_FROM_DEVICE, buffer, len, 1926 sshdr, timeout, retries); 1927 1928 /* This code looks awful: what it's doing is making sure an 1929 * ILLEGAL REQUEST sense return identifies the actual command 1930 * byte as the problem. MODE_SENSE commands can return 1931 * ILLEGAL REQUEST if the code page isn't supported */ 1932 1933 if (use_10_for_ms && !scsi_status_is_good(result) && 1934 (driver_byte(result) & DRIVER_SENSE)) { 1935 if (scsi_sense_valid(sshdr)) { 1936 if ((sshdr->sense_key == ILLEGAL_REQUEST) && 1937 (sshdr->asc == 0x20) && (sshdr->ascq == 0)) { 1938 /* 1939 * Invalid command operation code 1940 */ 1941 sdev->use_10_for_ms = 0; 1942 goto retry; 1943 } 1944 } 1945 } 1946 1947 if(scsi_status_is_good(result)) { 1948 if (unlikely(buffer[0] == 0x86 && buffer[1] == 0x0b && 1949 (modepage == 6 || modepage == 8))) { 1950 /* Initio breakage? */ 1951 header_length = 0; 1952 data->length = 13; 1953 data->medium_type = 0; 1954 data->device_specific = 0; 1955 data->longlba = 0; 1956 data->block_descriptor_length = 0; 1957 } else if(use_10_for_ms) { 1958 data->length = buffer[0]*256 + buffer[1] + 2; 1959 data->medium_type = buffer[2]; 1960 data->device_specific = buffer[3]; 1961 data->longlba = buffer[4] & 0x01; 1962 data->block_descriptor_length = buffer[6]*256 1963 + buffer[7]; 1964 } else { 1965 data->length = buffer[0] + 1; 1966 data->medium_type = buffer[1]; 1967 data->device_specific = buffer[2]; 1968 data->block_descriptor_length = buffer[3]; 1969 } 1970 data->header_length = header_length; 1971 } 1972 1973 return result; 1974} 1975EXPORT_SYMBOL(scsi_mode_sense); 1976 1977int 1978scsi_test_unit_ready(struct scsi_device *sdev, int timeout, int retries) 1979{ 1980 char cmd[] = { 1981 TEST_UNIT_READY, 0, 0, 0, 0, 0, 1982 }; 1983 struct scsi_sense_hdr sshdr; 1984 int result; 1985 1986 result = scsi_execute_req(sdev, cmd, DMA_NONE, NULL, 0, &sshdr, 1987 timeout, retries); 1988 1989 if ((driver_byte(result) & DRIVER_SENSE) && sdev->removable) { 1990 1991 if ((scsi_sense_valid(&sshdr)) && 1992 ((sshdr.sense_key == UNIT_ATTENTION) || 1993 (sshdr.sense_key == NOT_READY))) { 1994 sdev->changed = 1; 1995 result = 0; 1996 } 1997 } 1998 return result; 1999} 2000EXPORT_SYMBOL(scsi_test_unit_ready); 2001 2002/** 2003 * scsi_device_set_state - Take the given device through the device 2004 * state model. 2005 * @sdev: scsi device to change the state of. 2006 * @state: state to change to. 2007 * 2008 * Returns zero if unsuccessful or an error if the requested 2009 * transition is illegal. 2010 **/ 2011int 2012scsi_device_set_state(struct scsi_device *sdev, enum scsi_device_state state) 2013{ 2014 enum scsi_device_state oldstate = sdev->sdev_state; 2015 2016 if (state == oldstate) 2017 return 0; 2018 2019 switch (state) { 2020 case SDEV_CREATED: 2021 /* There are no legal states that come back to 2022 * created. This is the manually initialised start 2023 * state */ 2024 goto illegal; 2025 2026 case SDEV_RUNNING: 2027 switch (oldstate) { 2028 case SDEV_CREATED: 2029 case SDEV_OFFLINE: 2030 case SDEV_QUIESCE: 2031 case SDEV_BLOCK: 2032 break; 2033 default: 2034 goto illegal; 2035 } 2036 break; 2037 2038 case SDEV_QUIESCE: 2039 switch (oldstate) { 2040 case SDEV_RUNNING: 2041 case SDEV_OFFLINE: 2042 break; 2043 default: 2044 goto illegal; 2045 } 2046 break; 2047 2048 case SDEV_OFFLINE: 2049 switch (oldstate) { 2050 case SDEV_CREATED: 2051 case SDEV_RUNNING: 2052 case SDEV_QUIESCE: 2053 case SDEV_BLOCK: 2054 break; 2055 default: 2056 goto illegal; 2057 } 2058 break; 2059 2060 case SDEV_BLOCK: 2061 switch (oldstate) { 2062 case SDEV_CREATED: 2063 case SDEV_RUNNING: 2064 break; 2065 default: 2066 goto illegal; 2067 } 2068 break; 2069 2070 case SDEV_CANCEL: 2071 switch (oldstate) { 2072 case SDEV_CREATED: 2073 case SDEV_RUNNING: 2074 case SDEV_QUIESCE: 2075 case SDEV_OFFLINE: 2076 case SDEV_BLOCK: 2077 break; 2078 default: 2079 goto illegal; 2080 } 2081 break; 2082 2083 case SDEV_DEL: 2084 switch (oldstate) { 2085 case SDEV_CREATED: 2086 case SDEV_RUNNING: 2087 case SDEV_OFFLINE: 2088 case SDEV_CANCEL: 2089 break; 2090 default: 2091 goto illegal; 2092 } 2093 break; 2094 2095 } 2096 sdev->sdev_state = state; 2097 return 0; 2098 2099 illegal: 2100 SCSI_LOG_ERROR_RECOVERY(1, 2101 sdev_printk(KERN_ERR, sdev, 2102 "Illegal state transition %s->%s\n", 2103 scsi_device_state_name(oldstate), 2104 scsi_device_state_name(state)) 2105 ); 2106 return -EINVAL; 2107} 2108EXPORT_SYMBOL(scsi_device_set_state); 2109 2110/** 2111 * scsi_device_quiesce - Block user issued commands. 2112 * @sdev: scsi device to quiesce. 2113 * 2114 * This works by trying to transition to the SDEV_QUIESCE state 2115 * (which must be a legal transition). When the device is in this 2116 * state, only special requests will be accepted, all others will 2117 * be deferred. Since special requests may also be requeued requests, 2118 * a successful return doesn't guarantee the device will be 2119 * totally quiescent. 2120 * 2121 * Must be called with user context, may sleep. 2122 * 2123 * Returns zero if unsuccessful or an error if not. 2124 **/ 2125int 2126scsi_device_quiesce(struct scsi_device *sdev) 2127{ 2128 int err = scsi_device_set_state(sdev, SDEV_QUIESCE); 2129 if (err) 2130 return err; 2131 2132 scsi_run_queue(sdev->request_queue); 2133 while (sdev->device_busy) { 2134 msleep_interruptible(200); 2135 scsi_run_queue(sdev->request_queue); 2136 } 2137 return 0; 2138} 2139EXPORT_SYMBOL(scsi_device_quiesce); 2140 2141/** 2142 * scsi_device_resume - Restart user issued commands to a quiesced device. 2143 * @sdev: scsi device to resume. 2144 * 2145 * Moves the device from quiesced back to running and restarts the 2146 * queues. 2147 * 2148 * Must be called with user context, may sleep. 2149 **/ 2150void 2151scsi_device_resume(struct scsi_device *sdev) 2152{ 2153 if(scsi_device_set_state(sdev, SDEV_RUNNING)) 2154 return; 2155 scsi_run_queue(sdev->request_queue); 2156} 2157EXPORT_SYMBOL(scsi_device_resume); 2158 2159static void 2160device_quiesce_fn(struct scsi_device *sdev, void *data) 2161{ 2162 scsi_device_quiesce(sdev); 2163} 2164 2165void 2166scsi_target_quiesce(struct scsi_target *starget) 2167{ 2168 starget_for_each_device(starget, NULL, device_quiesce_fn); 2169} 2170EXPORT_SYMBOL(scsi_target_quiesce); 2171 2172static void 2173device_resume_fn(struct scsi_device *sdev, void *data) 2174{ 2175 scsi_device_resume(sdev); 2176} 2177 2178void 2179scsi_target_resume(struct scsi_target *starget) 2180{ 2181 starget_for_each_device(starget, NULL, device_resume_fn); 2182} 2183EXPORT_SYMBOL(scsi_target_resume); 2184 2185/** 2186 * scsi_internal_device_block - internal function to put a device 2187 * temporarily into the SDEV_BLOCK state 2188 * @sdev: device to block 2189 * 2190 * Block request made by scsi lld's to temporarily stop all 2191 * scsi commands on the specified device. Called from interrupt 2192 * or normal process context. 2193 * 2194 * Returns zero if successful or error if not 2195 * 2196 * Notes: 2197 * This routine transitions the device to the SDEV_BLOCK state 2198 * (which must be a legal transition). When the device is in this 2199 * state, all commands are deferred until the scsi lld reenables 2200 * the device with scsi_device_unblock or device_block_tmo fires. 2201 * This routine assumes the host_lock is held on entry. 2202 **/ 2203int 2204scsi_internal_device_block(struct scsi_device *sdev) 2205{ 2206 struct request_queue *q = sdev->request_queue; 2207 unsigned long flags; 2208 int err = 0; 2209 2210 err = scsi_device_set_state(sdev, SDEV_BLOCK); 2211 if (err) 2212 return err; 2213 2214 /* 2215 * The device has transitioned to SDEV_BLOCK. Stop the 2216 * block layer from calling the midlayer with this device's 2217 * request queue. 2218 */ 2219 spin_lock_irqsave(q->queue_lock, flags); 2220 blk_stop_queue(q); 2221 spin_unlock_irqrestore(q->queue_lock, flags); 2222 2223 return 0; 2224} 2225EXPORT_SYMBOL_GPL(scsi_internal_device_block); 2226 2227/** 2228 * scsi_internal_device_unblock - resume a device after a block request 2229 * @sdev: device to resume 2230 * 2231 * Called by scsi lld's or the midlayer to restart the device queue 2232 * for the previously suspended scsi device. Called from interrupt or 2233 * normal process context. 2234 * 2235 * Returns zero if successful or error if not. 2236 * 2237 * Notes: 2238 * This routine transitions the device to the SDEV_RUNNING state 2239 * (which must be a legal transition) allowing the midlayer to 2240 * goose the queue for this device. This routine assumes the 2241 * host_lock is held upon entry. 2242 **/ 2243int 2244scsi_internal_device_unblock(struct scsi_device *sdev) 2245{ 2246 struct request_queue *q = sdev->request_queue; 2247 int err; 2248 unsigned long flags; 2249 2250 /* 2251 * Try to transition the scsi device to SDEV_RUNNING 2252 * and goose the device queue if successful. 2253 */ 2254 err = scsi_device_set_state(sdev, SDEV_RUNNING); 2255 if (err) 2256 return err; 2257 2258 spin_lock_irqsave(q->queue_lock, flags); 2259 blk_start_queue(q); 2260 spin_unlock_irqrestore(q->queue_lock, flags); 2261 2262 return 0; 2263} 2264EXPORT_SYMBOL_GPL(scsi_internal_device_unblock); 2265 2266static void 2267device_block(struct scsi_device *sdev, void *data) 2268{ 2269 scsi_internal_device_block(sdev); 2270} 2271 2272static int 2273target_block(struct device *dev, void *data) 2274{ 2275 if (scsi_is_target_device(dev)) 2276 starget_for_each_device(to_scsi_target(dev), NULL, 2277 device_block); 2278 return 0; 2279} 2280 2281void 2282scsi_target_block(struct device *dev) 2283{ 2284 if (scsi_is_target_device(dev)) 2285 starget_for_each_device(to_scsi_target(dev), NULL, 2286 device_block); 2287 else 2288 device_for_each_child(dev, NULL, target_block); 2289} 2290EXPORT_SYMBOL_GPL(scsi_target_block); 2291 2292static void 2293device_unblock(struct scsi_device *sdev, void *data) 2294{ 2295 scsi_internal_device_unblock(sdev); 2296} 2297 2298static int 2299target_unblock(struct device *dev, void *data) 2300{ 2301 if (scsi_is_target_device(dev)) 2302 starget_for_each_device(to_scsi_target(dev), NULL, 2303 device_unblock); 2304 return 0; 2305} 2306 2307void 2308scsi_target_unblock(struct device *dev) 2309{ 2310 if (scsi_is_target_device(dev)) 2311 starget_for_each_device(to_scsi_target(dev), NULL, 2312 device_unblock); 2313 else 2314 device_for_each_child(dev, NULL, target_unblock); 2315} 2316EXPORT_SYMBOL_GPL(scsi_target_unblock); 2317 2318/** 2319 * scsi_kmap_atomic_sg - find and atomically map an sg-elemnt 2320 * @sg: scatter-gather list 2321 * @sg_count: number of segments in sg 2322 * @offset: offset in bytes into sg, on return offset into the mapped area 2323 * @len: bytes to map, on return number of bytes mapped 2324 * 2325 * Returns virtual address of the start of the mapped page 2326 */ 2327void *scsi_kmap_atomic_sg(struct scatterlist *sgl, int sg_count, 2328 size_t *offset, size_t *len) 2329{ 2330 int i; 2331 size_t sg_len = 0, len_complete = 0; 2332 struct scatterlist *sg; 2333 struct page *page; 2334 2335 WARN_ON(!irqs_disabled()); 2336 2337 for_each_sg(sgl, sg, sg_count, i) { 2338 len_complete = sg_len; /* Complete sg-entries */ 2339 sg_len += sg->length; 2340 if (sg_len > *offset) 2341 break; 2342 } 2343 2344 if (unlikely(i == sg_count)) { 2345 printk(KERN_ERR "%s: Bytes in sg: %zu, requested offset %zu, " 2346 "elements %d\n", 2347 __FUNCTION__, sg_len, *offset, sg_count); 2348 WARN_ON(1); 2349 return NULL; 2350 } 2351 2352 /* Offset starting from the beginning of first page in this sg-entry */ 2353 *offset = *offset - len_complete + sg->offset; 2354 2355 /* Assumption: contiguous pages can be accessed as "page + i" */ 2356 page = nth_page(sg->page, (*offset >> PAGE_SHIFT)); 2357 *offset &= ~PAGE_MASK; 2358 2359 /* Bytes in this sg-entry from *offset to the end of the page */ 2360 sg_len = PAGE_SIZE - *offset; 2361 if (*len > sg_len) 2362 *len = sg_len; 2363 2364 return kmap_atomic(page, KM_BIO_SRC_IRQ); 2365} 2366EXPORT_SYMBOL(scsi_kmap_atomic_sg); 2367 2368/** 2369 * scsi_kunmap_atomic_sg - atomically unmap a virtual address, previously 2370 * mapped with scsi_kmap_atomic_sg 2371 * @virt: virtual address to be unmapped 2372 */ 2373void scsi_kunmap_atomic_sg(void *virt) 2374{ 2375 kunmap_atomic(virt, KM_BIO_SRC_IRQ); 2376} 2377EXPORT_SYMBOL(scsi_kunmap_atomic_sg); 2378