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