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