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