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