1 /* 2 * Copyright (C) 1999 Eric Youngdale 3 * Copyright (C) 2014 Christoph Hellwig 4 * 5 * SCSI queueing library. 6 * Initial versions: Eric Youngdale (eric@andante.org). 7 * Based upon conversations with large numbers 8 * of people at Linux Expo. 9 */ 10 11 #include <linux/bio.h> 12 #include <linux/bitops.h> 13 #include <linux/blkdev.h> 14 #include <linux/completion.h> 15 #include <linux/kernel.h> 16 #include <linux/export.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 #include <linux/blk-mq.h> 23 #include <linux/ratelimit.h> 24 #include <asm/unaligned.h> 25 26 #include <scsi/scsi.h> 27 #include <scsi/scsi_cmnd.h> 28 #include <scsi/scsi_dbg.h> 29 #include <scsi/scsi_device.h> 30 #include <scsi/scsi_driver.h> 31 #include <scsi/scsi_eh.h> 32 #include <scsi/scsi_host.h> 33 #include <scsi/scsi_transport.h> /* __scsi_init_queue() */ 34 #include <scsi/scsi_dh.h> 35 36 #include <trace/events/scsi.h> 37 38 #include "scsi_debugfs.h" 39 #include "scsi_priv.h" 40 #include "scsi_logging.h" 41 42 static struct kmem_cache *scsi_sdb_cache; 43 static struct kmem_cache *scsi_sense_cache; 44 static struct kmem_cache *scsi_sense_isadma_cache; 45 static DEFINE_MUTEX(scsi_sense_cache_mutex); 46 47 static void scsi_mq_uninit_cmd(struct scsi_cmnd *cmd); 48 49 static inline struct kmem_cache * 50 scsi_select_sense_cache(bool unchecked_isa_dma) 51 { 52 return unchecked_isa_dma ? scsi_sense_isadma_cache : scsi_sense_cache; 53 } 54 55 static void scsi_free_sense_buffer(bool unchecked_isa_dma, 56 unsigned char *sense_buffer) 57 { 58 kmem_cache_free(scsi_select_sense_cache(unchecked_isa_dma), 59 sense_buffer); 60 } 61 62 static unsigned char *scsi_alloc_sense_buffer(bool unchecked_isa_dma, 63 gfp_t gfp_mask, int numa_node) 64 { 65 return kmem_cache_alloc_node(scsi_select_sense_cache(unchecked_isa_dma), 66 gfp_mask, numa_node); 67 } 68 69 int scsi_init_sense_cache(struct Scsi_Host *shost) 70 { 71 struct kmem_cache *cache; 72 int ret = 0; 73 74 cache = scsi_select_sense_cache(shost->unchecked_isa_dma); 75 if (cache) 76 return 0; 77 78 mutex_lock(&scsi_sense_cache_mutex); 79 if (shost->unchecked_isa_dma) { 80 scsi_sense_isadma_cache = 81 kmem_cache_create("scsi_sense_cache(DMA)", 82 SCSI_SENSE_BUFFERSIZE, 0, 83 SLAB_HWCACHE_ALIGN | SLAB_CACHE_DMA, NULL); 84 if (!scsi_sense_isadma_cache) 85 ret = -ENOMEM; 86 } else { 87 scsi_sense_cache = 88 kmem_cache_create("scsi_sense_cache", 89 SCSI_SENSE_BUFFERSIZE, 0, SLAB_HWCACHE_ALIGN, NULL); 90 if (!scsi_sense_cache) 91 ret = -ENOMEM; 92 } 93 94 mutex_unlock(&scsi_sense_cache_mutex); 95 return ret; 96 } 97 98 /* 99 * When to reinvoke queueing after a resource shortage. It's 3 msecs to 100 * not change behaviour from the previous unplug mechanism, experimentation 101 * may prove this needs changing. 102 */ 103 #define SCSI_QUEUE_DELAY 3 104 105 static void 106 scsi_set_blocked(struct scsi_cmnd *cmd, int reason) 107 { 108 struct Scsi_Host *host = cmd->device->host; 109 struct scsi_device *device = cmd->device; 110 struct scsi_target *starget = scsi_target(device); 111 112 /* 113 * Set the appropriate busy bit for the device/host. 114 * 115 * If the host/device isn't busy, assume that something actually 116 * completed, and that we should be able to queue a command now. 117 * 118 * Note that the prior mid-layer assumption that any host could 119 * always queue at least one command is now broken. The mid-layer 120 * will implement a user specifiable stall (see 121 * scsi_host.max_host_blocked and scsi_device.max_device_blocked) 122 * if a command is requeued with no other commands outstanding 123 * either for the device or for the host. 124 */ 125 switch (reason) { 126 case SCSI_MLQUEUE_HOST_BUSY: 127 atomic_set(&host->host_blocked, host->max_host_blocked); 128 break; 129 case SCSI_MLQUEUE_DEVICE_BUSY: 130 case SCSI_MLQUEUE_EH_RETRY: 131 atomic_set(&device->device_blocked, 132 device->max_device_blocked); 133 break; 134 case SCSI_MLQUEUE_TARGET_BUSY: 135 atomic_set(&starget->target_blocked, 136 starget->max_target_blocked); 137 break; 138 } 139 } 140 141 static void scsi_mq_requeue_cmd(struct scsi_cmnd *cmd) 142 { 143 struct scsi_device *sdev = cmd->device; 144 145 if (cmd->request->rq_flags & RQF_DONTPREP) { 146 cmd->request->rq_flags &= ~RQF_DONTPREP; 147 scsi_mq_uninit_cmd(cmd); 148 } else { 149 WARN_ON_ONCE(true); 150 } 151 blk_mq_requeue_request(cmd->request, true); 152 put_device(&sdev->sdev_gendev); 153 } 154 155 /** 156 * __scsi_queue_insert - private queue insertion 157 * @cmd: The SCSI command being requeued 158 * @reason: The reason for the requeue 159 * @unbusy: Whether the queue should be unbusied 160 * 161 * This is a private queue insertion. The public interface 162 * scsi_queue_insert() always assumes the queue should be unbusied 163 * because it's always called before the completion. This function is 164 * for a requeue after completion, which should only occur in this 165 * file. 166 */ 167 static void __scsi_queue_insert(struct scsi_cmnd *cmd, int reason, int unbusy) 168 { 169 struct scsi_device *device = cmd->device; 170 struct request_queue *q = device->request_queue; 171 unsigned long flags; 172 173 SCSI_LOG_MLQUEUE(1, scmd_printk(KERN_INFO, cmd, 174 "Inserting command %p into mlqueue\n", cmd)); 175 176 scsi_set_blocked(cmd, reason); 177 178 /* 179 * Decrement the counters, since these commands are no longer 180 * active on the host/device. 181 */ 182 if (unbusy) 183 scsi_device_unbusy(device); 184 185 /* 186 * Requeue this command. It will go before all other commands 187 * that are already in the queue. Schedule requeue work under 188 * lock such that the kblockd_schedule_work() call happens 189 * before blk_cleanup_queue() finishes. 190 */ 191 cmd->result = 0; 192 if (q->mq_ops) { 193 scsi_mq_requeue_cmd(cmd); 194 return; 195 } 196 spin_lock_irqsave(q->queue_lock, flags); 197 blk_requeue_request(q, cmd->request); 198 kblockd_schedule_work(&device->requeue_work); 199 spin_unlock_irqrestore(q->queue_lock, flags); 200 } 201 202 /* 203 * Function: scsi_queue_insert() 204 * 205 * Purpose: Insert a command in the midlevel queue. 206 * 207 * Arguments: cmd - command that we are adding to queue. 208 * reason - why we are inserting command to queue. 209 * 210 * Lock status: Assumed that lock is not held upon entry. 211 * 212 * Returns: Nothing. 213 * 214 * Notes: We do this for one of two cases. Either the host is busy 215 * and it cannot accept any more commands for the time being, 216 * or the device returned QUEUE_FULL and can accept no more 217 * commands. 218 * Notes: This could be called either from an interrupt context or a 219 * normal process context. 220 */ 221 void scsi_queue_insert(struct scsi_cmnd *cmd, int reason) 222 { 223 __scsi_queue_insert(cmd, reason, 1); 224 } 225 226 227 /** 228 * scsi_execute - insert request and wait for the result 229 * @sdev: scsi device 230 * @cmd: scsi command 231 * @data_direction: data direction 232 * @buffer: data buffer 233 * @bufflen: len of buffer 234 * @sense: optional sense buffer 235 * @sshdr: optional decoded sense header 236 * @timeout: request timeout in seconds 237 * @retries: number of times to retry request 238 * @flags: flags for ->cmd_flags 239 * @rq_flags: flags for ->rq_flags 240 * @resid: optional residual length 241 * 242 * Returns the scsi_cmnd result field if a command was executed, or a negative 243 * Linux error code if we didn't get that far. 244 */ 245 int scsi_execute(struct scsi_device *sdev, const unsigned char *cmd, 246 int data_direction, void *buffer, unsigned bufflen, 247 unsigned char *sense, struct scsi_sense_hdr *sshdr, 248 int timeout, int retries, u64 flags, req_flags_t rq_flags, 249 int *resid) 250 { 251 struct request *req; 252 struct scsi_request *rq; 253 int ret = DRIVER_ERROR << 24; 254 255 req = blk_get_request_flags(sdev->request_queue, 256 data_direction == DMA_TO_DEVICE ? 257 REQ_OP_SCSI_OUT : REQ_OP_SCSI_IN, BLK_MQ_REQ_PREEMPT); 258 if (IS_ERR(req)) 259 return ret; 260 rq = scsi_req(req); 261 262 if (bufflen && blk_rq_map_kern(sdev->request_queue, req, 263 buffer, bufflen, __GFP_RECLAIM)) 264 goto out; 265 266 rq->cmd_len = COMMAND_SIZE(cmd[0]); 267 memcpy(rq->cmd, cmd, rq->cmd_len); 268 rq->retries = retries; 269 req->timeout = timeout; 270 req->cmd_flags |= flags; 271 req->rq_flags |= rq_flags | RQF_QUIET; 272 273 /* 274 * head injection *required* here otherwise quiesce won't work 275 */ 276 blk_execute_rq(req->q, NULL, req, 1); 277 278 /* 279 * Some devices (USB mass-storage in particular) may transfer 280 * garbage data together with a residue indicating that the data 281 * is invalid. Prevent the garbage from being misinterpreted 282 * and prevent security leaks by zeroing out the excess data. 283 */ 284 if (unlikely(rq->resid_len > 0 && rq->resid_len <= bufflen)) 285 memset(buffer + (bufflen - rq->resid_len), 0, rq->resid_len); 286 287 if (resid) 288 *resid = rq->resid_len; 289 if (sense && rq->sense_len) 290 memcpy(sense, rq->sense, SCSI_SENSE_BUFFERSIZE); 291 if (sshdr) 292 scsi_normalize_sense(rq->sense, rq->sense_len, sshdr); 293 ret = rq->result; 294 out: 295 blk_put_request(req); 296 297 return ret; 298 } 299 EXPORT_SYMBOL(scsi_execute); 300 301 /* 302 * Function: scsi_init_cmd_errh() 303 * 304 * Purpose: Initialize cmd fields related to error handling. 305 * 306 * Arguments: cmd - command that is ready to be queued. 307 * 308 * Notes: This function has the job of initializing a number of 309 * fields related to error handling. Typically this will 310 * be called once for each command, as required. 311 */ 312 static void scsi_init_cmd_errh(struct scsi_cmnd *cmd) 313 { 314 cmd->serial_number = 0; 315 scsi_set_resid(cmd, 0); 316 memset(cmd->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE); 317 if (cmd->cmd_len == 0) 318 cmd->cmd_len = scsi_command_size(cmd->cmnd); 319 } 320 321 void scsi_device_unbusy(struct scsi_device *sdev) 322 { 323 struct Scsi_Host *shost = sdev->host; 324 struct scsi_target *starget = scsi_target(sdev); 325 unsigned long flags; 326 327 atomic_dec(&shost->host_busy); 328 if (starget->can_queue > 0) 329 atomic_dec(&starget->target_busy); 330 331 if (unlikely(scsi_host_in_recovery(shost) && 332 (shost->host_failed || shost->host_eh_scheduled))) { 333 spin_lock_irqsave(shost->host_lock, flags); 334 scsi_eh_wakeup(shost); 335 spin_unlock_irqrestore(shost->host_lock, flags); 336 } 337 338 atomic_dec(&sdev->device_busy); 339 } 340 341 static void scsi_kick_queue(struct request_queue *q) 342 { 343 if (q->mq_ops) 344 blk_mq_start_hw_queues(q); 345 else 346 blk_run_queue(q); 347 } 348 349 /* 350 * Called for single_lun devices on IO completion. Clear starget_sdev_user, 351 * and call blk_run_queue for all the scsi_devices on the target - 352 * including current_sdev first. 353 * 354 * Called with *no* scsi locks held. 355 */ 356 static void scsi_single_lun_run(struct scsi_device *current_sdev) 357 { 358 struct Scsi_Host *shost = current_sdev->host; 359 struct scsi_device *sdev, *tmp; 360 struct scsi_target *starget = scsi_target(current_sdev); 361 unsigned long flags; 362 363 spin_lock_irqsave(shost->host_lock, flags); 364 starget->starget_sdev_user = NULL; 365 spin_unlock_irqrestore(shost->host_lock, flags); 366 367 /* 368 * Call blk_run_queue for all LUNs on the target, starting with 369 * current_sdev. We race with others (to set starget_sdev_user), 370 * but in most cases, we will be first. Ideally, each LU on the 371 * target would get some limited time or requests on the target. 372 */ 373 scsi_kick_queue(current_sdev->request_queue); 374 375 spin_lock_irqsave(shost->host_lock, flags); 376 if (starget->starget_sdev_user) 377 goto out; 378 list_for_each_entry_safe(sdev, tmp, &starget->devices, 379 same_target_siblings) { 380 if (sdev == current_sdev) 381 continue; 382 if (scsi_device_get(sdev)) 383 continue; 384 385 spin_unlock_irqrestore(shost->host_lock, flags); 386 scsi_kick_queue(sdev->request_queue); 387 spin_lock_irqsave(shost->host_lock, flags); 388 389 scsi_device_put(sdev); 390 } 391 out: 392 spin_unlock_irqrestore(shost->host_lock, flags); 393 } 394 395 static inline bool scsi_device_is_busy(struct scsi_device *sdev) 396 { 397 if (atomic_read(&sdev->device_busy) >= sdev->queue_depth) 398 return true; 399 if (atomic_read(&sdev->device_blocked) > 0) 400 return true; 401 return false; 402 } 403 404 static inline bool scsi_target_is_busy(struct scsi_target *starget) 405 { 406 if (starget->can_queue > 0) { 407 if (atomic_read(&starget->target_busy) >= starget->can_queue) 408 return true; 409 if (atomic_read(&starget->target_blocked) > 0) 410 return true; 411 } 412 return false; 413 } 414 415 static inline bool scsi_host_is_busy(struct Scsi_Host *shost) 416 { 417 if (shost->can_queue > 0 && 418 atomic_read(&shost->host_busy) >= shost->can_queue) 419 return true; 420 if (atomic_read(&shost->host_blocked) > 0) 421 return true; 422 if (shost->host_self_blocked) 423 return true; 424 return false; 425 } 426 427 static void scsi_starved_list_run(struct Scsi_Host *shost) 428 { 429 LIST_HEAD(starved_list); 430 struct scsi_device *sdev; 431 unsigned long flags; 432 433 spin_lock_irqsave(shost->host_lock, flags); 434 list_splice_init(&shost->starved_list, &starved_list); 435 436 while (!list_empty(&starved_list)) { 437 struct request_queue *slq; 438 439 /* 440 * As long as shost is accepting commands and we have 441 * starved queues, call blk_run_queue. scsi_request_fn 442 * drops the queue_lock and can add us back to the 443 * starved_list. 444 * 445 * host_lock protects the starved_list and starved_entry. 446 * scsi_request_fn must get the host_lock before checking 447 * or modifying starved_list or starved_entry. 448 */ 449 if (scsi_host_is_busy(shost)) 450 break; 451 452 sdev = list_entry(starved_list.next, 453 struct scsi_device, starved_entry); 454 list_del_init(&sdev->starved_entry); 455 if (scsi_target_is_busy(scsi_target(sdev))) { 456 list_move_tail(&sdev->starved_entry, 457 &shost->starved_list); 458 continue; 459 } 460 461 /* 462 * Once we drop the host lock, a racing scsi_remove_device() 463 * call may remove the sdev from the starved list and destroy 464 * it and the queue. Mitigate by taking a reference to the 465 * queue and never touching the sdev again after we drop the 466 * host lock. Note: if __scsi_remove_device() invokes 467 * blk_cleanup_queue() before the queue is run from this 468 * function then blk_run_queue() will return immediately since 469 * blk_cleanup_queue() marks the queue with QUEUE_FLAG_DYING. 470 */ 471 slq = sdev->request_queue; 472 if (!blk_get_queue(slq)) 473 continue; 474 spin_unlock_irqrestore(shost->host_lock, flags); 475 476 scsi_kick_queue(slq); 477 blk_put_queue(slq); 478 479 spin_lock_irqsave(shost->host_lock, flags); 480 } 481 /* put any unprocessed entries back */ 482 list_splice(&starved_list, &shost->starved_list); 483 spin_unlock_irqrestore(shost->host_lock, flags); 484 } 485 486 /* 487 * Function: scsi_run_queue() 488 * 489 * Purpose: Select a proper request queue to serve next 490 * 491 * Arguments: q - last request's queue 492 * 493 * Returns: Nothing 494 * 495 * Notes: The previous command was completely finished, start 496 * a new one if possible. 497 */ 498 static void scsi_run_queue(struct request_queue *q) 499 { 500 struct scsi_device *sdev = q->queuedata; 501 502 if (scsi_target(sdev)->single_lun) 503 scsi_single_lun_run(sdev); 504 if (!list_empty(&sdev->host->starved_list)) 505 scsi_starved_list_run(sdev->host); 506 507 if (q->mq_ops) 508 blk_mq_run_hw_queues(q, false); 509 else 510 blk_run_queue(q); 511 } 512 513 void scsi_requeue_run_queue(struct work_struct *work) 514 { 515 struct scsi_device *sdev; 516 struct request_queue *q; 517 518 sdev = container_of(work, struct scsi_device, requeue_work); 519 q = sdev->request_queue; 520 scsi_run_queue(q); 521 } 522 523 /* 524 * Function: scsi_requeue_command() 525 * 526 * Purpose: Handle post-processing of completed commands. 527 * 528 * Arguments: q - queue to operate on 529 * cmd - command that may need to be requeued. 530 * 531 * Returns: Nothing 532 * 533 * Notes: After command completion, there may be blocks left 534 * over which weren't finished by the previous command 535 * this can be for a number of reasons - the main one is 536 * I/O errors in the middle of the request, in which case 537 * we need to request the blocks that come after the bad 538 * sector. 539 * Notes: Upon return, cmd is a stale pointer. 540 */ 541 static void scsi_requeue_command(struct request_queue *q, struct scsi_cmnd *cmd) 542 { 543 struct scsi_device *sdev = cmd->device; 544 struct request *req = cmd->request; 545 unsigned long flags; 546 547 spin_lock_irqsave(q->queue_lock, flags); 548 blk_unprep_request(req); 549 req->special = NULL; 550 scsi_put_command(cmd); 551 blk_requeue_request(q, req); 552 spin_unlock_irqrestore(q->queue_lock, flags); 553 554 scsi_run_queue(q); 555 556 put_device(&sdev->sdev_gendev); 557 } 558 559 void scsi_run_host_queues(struct Scsi_Host *shost) 560 { 561 struct scsi_device *sdev; 562 563 shost_for_each_device(sdev, shost) 564 scsi_run_queue(sdev->request_queue); 565 } 566 567 static void scsi_uninit_cmd(struct scsi_cmnd *cmd) 568 { 569 if (!blk_rq_is_passthrough(cmd->request)) { 570 struct scsi_driver *drv = scsi_cmd_to_driver(cmd); 571 572 if (drv->uninit_command) 573 drv->uninit_command(cmd); 574 } 575 } 576 577 static void scsi_mq_free_sgtables(struct scsi_cmnd *cmd) 578 { 579 struct scsi_data_buffer *sdb; 580 581 if (cmd->sdb.table.nents) 582 sg_free_table_chained(&cmd->sdb.table, true); 583 if (cmd->request->next_rq) { 584 sdb = cmd->request->next_rq->special; 585 if (sdb) 586 sg_free_table_chained(&sdb->table, true); 587 } 588 if (scsi_prot_sg_count(cmd)) 589 sg_free_table_chained(&cmd->prot_sdb->table, true); 590 } 591 592 static void scsi_mq_uninit_cmd(struct scsi_cmnd *cmd) 593 { 594 scsi_mq_free_sgtables(cmd); 595 scsi_uninit_cmd(cmd); 596 scsi_del_cmd_from_list(cmd); 597 } 598 599 /* 600 * Function: scsi_release_buffers() 601 * 602 * Purpose: Free resources allocate for a scsi_command. 603 * 604 * Arguments: cmd - command that we are bailing. 605 * 606 * Lock status: Assumed that no lock is held upon entry. 607 * 608 * Returns: Nothing 609 * 610 * Notes: In the event that an upper level driver rejects a 611 * command, we must release resources allocated during 612 * the __init_io() function. Primarily this would involve 613 * the scatter-gather table. 614 */ 615 static void scsi_release_buffers(struct scsi_cmnd *cmd) 616 { 617 if (cmd->sdb.table.nents) 618 sg_free_table_chained(&cmd->sdb.table, false); 619 620 memset(&cmd->sdb, 0, sizeof(cmd->sdb)); 621 622 if (scsi_prot_sg_count(cmd)) 623 sg_free_table_chained(&cmd->prot_sdb->table, false); 624 } 625 626 static void scsi_release_bidi_buffers(struct scsi_cmnd *cmd) 627 { 628 struct scsi_data_buffer *bidi_sdb = cmd->request->next_rq->special; 629 630 sg_free_table_chained(&bidi_sdb->table, false); 631 kmem_cache_free(scsi_sdb_cache, bidi_sdb); 632 cmd->request->next_rq->special = NULL; 633 } 634 635 static bool scsi_end_request(struct request *req, blk_status_t error, 636 unsigned int bytes, unsigned int bidi_bytes) 637 { 638 struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(req); 639 struct scsi_device *sdev = cmd->device; 640 struct request_queue *q = sdev->request_queue; 641 642 if (blk_update_request(req, error, bytes)) 643 return true; 644 645 /* Bidi request must be completed as a whole */ 646 if (unlikely(bidi_bytes) && 647 blk_update_request(req->next_rq, error, bidi_bytes)) 648 return true; 649 650 if (blk_queue_add_random(q)) 651 add_disk_randomness(req->rq_disk); 652 653 if (!blk_rq_is_scsi(req)) { 654 WARN_ON_ONCE(!(cmd->flags & SCMD_INITIALIZED)); 655 cmd->flags &= ~SCMD_INITIALIZED; 656 } 657 658 if (req->mq_ctx) { 659 /* 660 * In the MQ case the command gets freed by __blk_mq_end_request, 661 * so we have to do all cleanup that depends on it earlier. 662 * 663 * We also can't kick the queues from irq context, so we 664 * will have to defer it to a workqueue. 665 */ 666 scsi_mq_uninit_cmd(cmd); 667 668 __blk_mq_end_request(req, error); 669 670 if (scsi_target(sdev)->single_lun || 671 !list_empty(&sdev->host->starved_list)) 672 kblockd_schedule_work(&sdev->requeue_work); 673 else 674 blk_mq_run_hw_queues(q, true); 675 } else { 676 unsigned long flags; 677 678 if (bidi_bytes) 679 scsi_release_bidi_buffers(cmd); 680 scsi_release_buffers(cmd); 681 scsi_put_command(cmd); 682 683 spin_lock_irqsave(q->queue_lock, flags); 684 blk_finish_request(req, error); 685 spin_unlock_irqrestore(q->queue_lock, flags); 686 687 scsi_run_queue(q); 688 } 689 690 put_device(&sdev->sdev_gendev); 691 return false; 692 } 693 694 /** 695 * __scsi_error_from_host_byte - translate SCSI error code into errno 696 * @cmd: SCSI command (unused) 697 * @result: scsi error code 698 * 699 * Translate SCSI error code into block errors. 700 */ 701 static blk_status_t __scsi_error_from_host_byte(struct scsi_cmnd *cmd, 702 int result) 703 { 704 switch (host_byte(result)) { 705 case DID_TRANSPORT_FAILFAST: 706 return BLK_STS_TRANSPORT; 707 case DID_TARGET_FAILURE: 708 set_host_byte(cmd, DID_OK); 709 return BLK_STS_TARGET; 710 case DID_NEXUS_FAILURE: 711 return BLK_STS_NEXUS; 712 case DID_ALLOC_FAILURE: 713 set_host_byte(cmd, DID_OK); 714 return BLK_STS_NOSPC; 715 case DID_MEDIUM_ERROR: 716 set_host_byte(cmd, DID_OK); 717 return BLK_STS_MEDIUM; 718 default: 719 return BLK_STS_IOERR; 720 } 721 } 722 723 /* 724 * Function: scsi_io_completion() 725 * 726 * Purpose: Completion processing for block device I/O requests. 727 * 728 * Arguments: cmd - command that is finished. 729 * 730 * Lock status: Assumed that no lock is held upon entry. 731 * 732 * Returns: Nothing 733 * 734 * Notes: We will finish off the specified number of sectors. If we 735 * are done, the command block will be released and the queue 736 * function will be goosed. If we are not done then we have to 737 * figure out what to do next: 738 * 739 * a) We can call scsi_requeue_command(). The request 740 * will be unprepared and put back on the queue. Then 741 * a new command will be created for it. This should 742 * be used if we made forward progress, or if we want 743 * to switch from READ(10) to READ(6) for example. 744 * 745 * b) We can call __scsi_queue_insert(). The request will 746 * be put back on the queue and retried using the same 747 * command as before, possibly after a delay. 748 * 749 * c) We can call scsi_end_request() with -EIO to fail 750 * the remainder of the request. 751 */ 752 void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes) 753 { 754 int result = cmd->result; 755 struct request_queue *q = cmd->device->request_queue; 756 struct request *req = cmd->request; 757 blk_status_t error = BLK_STS_OK; 758 struct scsi_sense_hdr sshdr; 759 bool sense_valid = false; 760 int sense_deferred = 0, level = 0; 761 enum {ACTION_FAIL, ACTION_REPREP, ACTION_RETRY, 762 ACTION_DELAYED_RETRY} action; 763 unsigned long wait_for = (cmd->allowed + 1) * req->timeout; 764 765 if (result) { 766 sense_valid = scsi_command_normalize_sense(cmd, &sshdr); 767 if (sense_valid) 768 sense_deferred = scsi_sense_is_deferred(&sshdr); 769 } 770 771 if (blk_rq_is_passthrough(req)) { 772 if (result) { 773 if (sense_valid) { 774 /* 775 * SG_IO wants current and deferred errors 776 */ 777 scsi_req(req)->sense_len = 778 min(8 + cmd->sense_buffer[7], 779 SCSI_SENSE_BUFFERSIZE); 780 } 781 if (!sense_deferred) 782 error = __scsi_error_from_host_byte(cmd, result); 783 } 784 /* 785 * __scsi_error_from_host_byte may have reset the host_byte 786 */ 787 scsi_req(req)->result = cmd->result; 788 scsi_req(req)->resid_len = scsi_get_resid(cmd); 789 790 if (scsi_bidi_cmnd(cmd)) { 791 /* 792 * Bidi commands Must be complete as a whole, 793 * both sides at once. 794 */ 795 scsi_req(req->next_rq)->resid_len = scsi_in(cmd)->resid; 796 if (scsi_end_request(req, BLK_STS_OK, blk_rq_bytes(req), 797 blk_rq_bytes(req->next_rq))) 798 BUG(); 799 return; 800 } 801 } else if (blk_rq_bytes(req) == 0 && result && !sense_deferred) { 802 /* 803 * Flush commands do not transfers any data, and thus cannot use 804 * good_bytes != blk_rq_bytes(req) as the signal for an error. 805 * This sets the error explicitly for the problem case. 806 */ 807 error = __scsi_error_from_host_byte(cmd, result); 808 } 809 810 /* no bidi support for !blk_rq_is_passthrough yet */ 811 BUG_ON(blk_bidi_rq(req)); 812 813 /* 814 * Next deal with any sectors which we were able to correctly 815 * handle. 816 */ 817 SCSI_LOG_HLCOMPLETE(1, scmd_printk(KERN_INFO, cmd, 818 "%u sectors total, %d bytes done.\n", 819 blk_rq_sectors(req), good_bytes)); 820 821 /* 822 * Recovered errors need reporting, but they're always treated as 823 * success, so fiddle the result code here. For passthrough requests 824 * we already took a copy of the original into sreq->result which 825 * is what gets returned to the user 826 */ 827 if (sense_valid && (sshdr.sense_key == RECOVERED_ERROR)) { 828 /* if ATA PASS-THROUGH INFORMATION AVAILABLE skip 829 * print since caller wants ATA registers. Only occurs on 830 * SCSI ATA PASS_THROUGH commands when CK_COND=1 831 */ 832 if ((sshdr.asc == 0x0) && (sshdr.ascq == 0x1d)) 833 ; 834 else if (!(req->rq_flags & RQF_QUIET)) 835 scsi_print_sense(cmd); 836 result = 0; 837 /* for passthrough error may be set */ 838 error = BLK_STS_OK; 839 } 840 841 /* 842 * special case: failed zero length commands always need to 843 * drop down into the retry code. Otherwise, if we finished 844 * all bytes in the request we are done now. 845 */ 846 if (!(blk_rq_bytes(req) == 0 && error) && 847 !scsi_end_request(req, error, good_bytes, 0)) 848 return; 849 850 /* 851 * Kill remainder if no retrys. 852 */ 853 if (error && scsi_noretry_cmd(cmd)) { 854 if (scsi_end_request(req, error, blk_rq_bytes(req), 0)) 855 BUG(); 856 return; 857 } 858 859 /* 860 * If there had been no error, but we have leftover bytes in the 861 * requeues just queue the command up again. 862 */ 863 if (result == 0) 864 goto requeue; 865 866 error = __scsi_error_from_host_byte(cmd, result); 867 868 if (host_byte(result) == DID_RESET) { 869 /* Third party bus reset or reset for error recovery 870 * reasons. Just retry the command and see what 871 * happens. 872 */ 873 action = ACTION_RETRY; 874 } else if (sense_valid && !sense_deferred) { 875 switch (sshdr.sense_key) { 876 case UNIT_ATTENTION: 877 if (cmd->device->removable) { 878 /* Detected disc change. Set a bit 879 * and quietly refuse further access. 880 */ 881 cmd->device->changed = 1; 882 action = ACTION_FAIL; 883 } else { 884 /* Must have been a power glitch, or a 885 * bus reset. Could not have been a 886 * media change, so we just retry the 887 * command and see what happens. 888 */ 889 action = ACTION_RETRY; 890 } 891 break; 892 case ILLEGAL_REQUEST: 893 /* If we had an ILLEGAL REQUEST returned, then 894 * we may have performed an unsupported 895 * command. The only thing this should be 896 * would be a ten byte read where only a six 897 * byte read was supported. Also, on a system 898 * where READ CAPACITY failed, we may have 899 * read past the end of the disk. 900 */ 901 if ((cmd->device->use_10_for_rw && 902 sshdr.asc == 0x20 && sshdr.ascq == 0x00) && 903 (cmd->cmnd[0] == READ_10 || 904 cmd->cmnd[0] == WRITE_10)) { 905 /* This will issue a new 6-byte command. */ 906 cmd->device->use_10_for_rw = 0; 907 action = ACTION_REPREP; 908 } else if (sshdr.asc == 0x10) /* DIX */ { 909 action = ACTION_FAIL; 910 error = BLK_STS_PROTECTION; 911 /* INVALID COMMAND OPCODE or INVALID FIELD IN CDB */ 912 } else if (sshdr.asc == 0x20 || sshdr.asc == 0x24) { 913 action = ACTION_FAIL; 914 error = BLK_STS_TARGET; 915 } else 916 action = ACTION_FAIL; 917 break; 918 case ABORTED_COMMAND: 919 action = ACTION_FAIL; 920 if (sshdr.asc == 0x10) /* DIF */ 921 error = BLK_STS_PROTECTION; 922 break; 923 case NOT_READY: 924 /* If the device is in the process of becoming 925 * ready, or has a temporary blockage, retry. 926 */ 927 if (sshdr.asc == 0x04) { 928 switch (sshdr.ascq) { 929 case 0x01: /* becoming ready */ 930 case 0x04: /* format in progress */ 931 case 0x05: /* rebuild in progress */ 932 case 0x06: /* recalculation in progress */ 933 case 0x07: /* operation in progress */ 934 case 0x08: /* Long write in progress */ 935 case 0x09: /* self test in progress */ 936 case 0x14: /* space allocation in progress */ 937 action = ACTION_DELAYED_RETRY; 938 break; 939 default: 940 action = ACTION_FAIL; 941 break; 942 } 943 } else 944 action = ACTION_FAIL; 945 break; 946 case VOLUME_OVERFLOW: 947 /* See SSC3rXX or current. */ 948 action = ACTION_FAIL; 949 break; 950 default: 951 action = ACTION_FAIL; 952 break; 953 } 954 } else 955 action = ACTION_FAIL; 956 957 if (action != ACTION_FAIL && 958 time_before(cmd->jiffies_at_alloc + wait_for, jiffies)) 959 action = ACTION_FAIL; 960 961 switch (action) { 962 case ACTION_FAIL: 963 /* Give up and fail the remainder of the request */ 964 if (!(req->rq_flags & RQF_QUIET)) { 965 static DEFINE_RATELIMIT_STATE(_rs, 966 DEFAULT_RATELIMIT_INTERVAL, 967 DEFAULT_RATELIMIT_BURST); 968 969 if (unlikely(scsi_logging_level)) 970 level = SCSI_LOG_LEVEL(SCSI_LOG_MLCOMPLETE_SHIFT, 971 SCSI_LOG_MLCOMPLETE_BITS); 972 973 /* 974 * if logging is enabled the failure will be printed 975 * in scsi_log_completion(), so avoid duplicate messages 976 */ 977 if (!level && __ratelimit(&_rs)) { 978 scsi_print_result(cmd, NULL, FAILED); 979 if (driver_byte(result) & DRIVER_SENSE) 980 scsi_print_sense(cmd); 981 scsi_print_command(cmd); 982 } 983 } 984 if (!scsi_end_request(req, error, blk_rq_err_bytes(req), 0)) 985 return; 986 /*FALLTHRU*/ 987 case ACTION_REPREP: 988 requeue: 989 /* Unprep the request and put it back at the head of the queue. 990 * A new command will be prepared and issued. 991 */ 992 if (q->mq_ops) { 993 scsi_mq_requeue_cmd(cmd); 994 } else { 995 scsi_release_buffers(cmd); 996 scsi_requeue_command(q, cmd); 997 } 998 break; 999 case ACTION_RETRY: 1000 /* Retry the same command immediately */ 1001 __scsi_queue_insert(cmd, SCSI_MLQUEUE_EH_RETRY, 0); 1002 break; 1003 case ACTION_DELAYED_RETRY: 1004 /* Retry the same command after a delay */ 1005 __scsi_queue_insert(cmd, SCSI_MLQUEUE_DEVICE_BUSY, 0); 1006 break; 1007 } 1008 } 1009 1010 static int scsi_init_sgtable(struct request *req, struct scsi_data_buffer *sdb) 1011 { 1012 int count; 1013 1014 /* 1015 * If sg table allocation fails, requeue request later. 1016 */ 1017 if (unlikely(sg_alloc_table_chained(&sdb->table, 1018 blk_rq_nr_phys_segments(req), sdb->table.sgl))) 1019 return BLKPREP_DEFER; 1020 1021 /* 1022 * Next, walk the list, and fill in the addresses and sizes of 1023 * each segment. 1024 */ 1025 count = blk_rq_map_sg(req->q, req, sdb->table.sgl); 1026 BUG_ON(count > sdb->table.nents); 1027 sdb->table.nents = count; 1028 sdb->length = blk_rq_payload_bytes(req); 1029 return BLKPREP_OK; 1030 } 1031 1032 /* 1033 * Function: scsi_init_io() 1034 * 1035 * Purpose: SCSI I/O initialize function. 1036 * 1037 * Arguments: cmd - Command descriptor we wish to initialize 1038 * 1039 * Returns: 0 on success 1040 * BLKPREP_DEFER if the failure is retryable 1041 * BLKPREP_KILL if the failure is fatal 1042 */ 1043 int scsi_init_io(struct scsi_cmnd *cmd) 1044 { 1045 struct scsi_device *sdev = cmd->device; 1046 struct request *rq = cmd->request; 1047 bool is_mq = (rq->mq_ctx != NULL); 1048 int error = BLKPREP_KILL; 1049 1050 if (WARN_ON_ONCE(!blk_rq_nr_phys_segments(rq))) 1051 goto err_exit; 1052 1053 error = scsi_init_sgtable(rq, &cmd->sdb); 1054 if (error) 1055 goto err_exit; 1056 1057 if (blk_bidi_rq(rq)) { 1058 if (!rq->q->mq_ops) { 1059 struct scsi_data_buffer *bidi_sdb = 1060 kmem_cache_zalloc(scsi_sdb_cache, GFP_ATOMIC); 1061 if (!bidi_sdb) { 1062 error = BLKPREP_DEFER; 1063 goto err_exit; 1064 } 1065 1066 rq->next_rq->special = bidi_sdb; 1067 } 1068 1069 error = scsi_init_sgtable(rq->next_rq, rq->next_rq->special); 1070 if (error) 1071 goto err_exit; 1072 } 1073 1074 if (blk_integrity_rq(rq)) { 1075 struct scsi_data_buffer *prot_sdb = cmd->prot_sdb; 1076 int ivecs, count; 1077 1078 if (prot_sdb == NULL) { 1079 /* 1080 * This can happen if someone (e.g. multipath) 1081 * queues a command to a device on an adapter 1082 * that does not support DIX. 1083 */ 1084 WARN_ON_ONCE(1); 1085 error = BLKPREP_KILL; 1086 goto err_exit; 1087 } 1088 1089 ivecs = blk_rq_count_integrity_sg(rq->q, rq->bio); 1090 1091 if (sg_alloc_table_chained(&prot_sdb->table, ivecs, 1092 prot_sdb->table.sgl)) { 1093 error = BLKPREP_DEFER; 1094 goto err_exit; 1095 } 1096 1097 count = blk_rq_map_integrity_sg(rq->q, rq->bio, 1098 prot_sdb->table.sgl); 1099 BUG_ON(unlikely(count > ivecs)); 1100 BUG_ON(unlikely(count > queue_max_integrity_segments(rq->q))); 1101 1102 cmd->prot_sdb = prot_sdb; 1103 cmd->prot_sdb->table.nents = count; 1104 } 1105 1106 return BLKPREP_OK; 1107 err_exit: 1108 if (is_mq) { 1109 scsi_mq_free_sgtables(cmd); 1110 } else { 1111 scsi_release_buffers(cmd); 1112 cmd->request->special = NULL; 1113 scsi_put_command(cmd); 1114 put_device(&sdev->sdev_gendev); 1115 } 1116 return error; 1117 } 1118 EXPORT_SYMBOL(scsi_init_io); 1119 1120 /** 1121 * scsi_initialize_rq - initialize struct scsi_cmnd partially 1122 * @rq: Request associated with the SCSI command to be initialized. 1123 * 1124 * This function initializes the members of struct scsi_cmnd that must be 1125 * initialized before request processing starts and that won't be 1126 * reinitialized if a SCSI command is requeued. 1127 * 1128 * Called from inside blk_get_request() for pass-through requests and from 1129 * inside scsi_init_command() for filesystem requests. 1130 */ 1131 void scsi_initialize_rq(struct request *rq) 1132 { 1133 struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(rq); 1134 1135 scsi_req_init(&cmd->req); 1136 cmd->jiffies_at_alloc = jiffies; 1137 cmd->retries = 0; 1138 } 1139 EXPORT_SYMBOL(scsi_initialize_rq); 1140 1141 /* Add a command to the list used by the aacraid and dpt_i2o drivers */ 1142 void scsi_add_cmd_to_list(struct scsi_cmnd *cmd) 1143 { 1144 struct scsi_device *sdev = cmd->device; 1145 struct Scsi_Host *shost = sdev->host; 1146 unsigned long flags; 1147 1148 if (shost->use_cmd_list) { 1149 spin_lock_irqsave(&sdev->list_lock, flags); 1150 list_add_tail(&cmd->list, &sdev->cmd_list); 1151 spin_unlock_irqrestore(&sdev->list_lock, flags); 1152 } 1153 } 1154 1155 /* Remove a command from the list used by the aacraid and dpt_i2o drivers */ 1156 void scsi_del_cmd_from_list(struct scsi_cmnd *cmd) 1157 { 1158 struct scsi_device *sdev = cmd->device; 1159 struct Scsi_Host *shost = sdev->host; 1160 unsigned long flags; 1161 1162 if (shost->use_cmd_list) { 1163 spin_lock_irqsave(&sdev->list_lock, flags); 1164 BUG_ON(list_empty(&cmd->list)); 1165 list_del_init(&cmd->list); 1166 spin_unlock_irqrestore(&sdev->list_lock, flags); 1167 } 1168 } 1169 1170 /* Called after a request has been started. */ 1171 void scsi_init_command(struct scsi_device *dev, struct scsi_cmnd *cmd) 1172 { 1173 void *buf = cmd->sense_buffer; 1174 void *prot = cmd->prot_sdb; 1175 struct request *rq = blk_mq_rq_from_pdu(cmd); 1176 unsigned int flags = cmd->flags & SCMD_PRESERVED_FLAGS; 1177 unsigned long jiffies_at_alloc; 1178 int retries; 1179 1180 if (!blk_rq_is_scsi(rq) && !(flags & SCMD_INITIALIZED)) { 1181 flags |= SCMD_INITIALIZED; 1182 scsi_initialize_rq(rq); 1183 } 1184 1185 jiffies_at_alloc = cmd->jiffies_at_alloc; 1186 retries = cmd->retries; 1187 /* zero out the cmd, except for the embedded scsi_request */ 1188 memset((char *)cmd + sizeof(cmd->req), 0, 1189 sizeof(*cmd) - sizeof(cmd->req) + dev->host->hostt->cmd_size); 1190 1191 cmd->device = dev; 1192 cmd->sense_buffer = buf; 1193 cmd->prot_sdb = prot; 1194 cmd->flags = flags; 1195 INIT_DELAYED_WORK(&cmd->abort_work, scmd_eh_abort_handler); 1196 cmd->jiffies_at_alloc = jiffies_at_alloc; 1197 cmd->retries = retries; 1198 1199 scsi_add_cmd_to_list(cmd); 1200 } 1201 1202 static int scsi_setup_scsi_cmnd(struct scsi_device *sdev, struct request *req) 1203 { 1204 struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(req); 1205 1206 /* 1207 * Passthrough requests may transfer data, in which case they must 1208 * a bio attached to them. Or they might contain a SCSI command 1209 * that does not transfer data, in which case they may optionally 1210 * submit a request without an attached bio. 1211 */ 1212 if (req->bio) { 1213 int ret = scsi_init_io(cmd); 1214 if (unlikely(ret)) 1215 return ret; 1216 } else { 1217 BUG_ON(blk_rq_bytes(req)); 1218 1219 memset(&cmd->sdb, 0, sizeof(cmd->sdb)); 1220 } 1221 1222 cmd->cmd_len = scsi_req(req)->cmd_len; 1223 cmd->cmnd = scsi_req(req)->cmd; 1224 cmd->transfersize = blk_rq_bytes(req); 1225 cmd->allowed = scsi_req(req)->retries; 1226 return BLKPREP_OK; 1227 } 1228 1229 /* 1230 * Setup a normal block command. These are simple request from filesystems 1231 * that still need to be translated to SCSI CDBs from the ULD. 1232 */ 1233 static int scsi_setup_fs_cmnd(struct scsi_device *sdev, struct request *req) 1234 { 1235 struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(req); 1236 1237 if (unlikely(sdev->handler && sdev->handler->prep_fn)) { 1238 int ret = sdev->handler->prep_fn(sdev, req); 1239 if (ret != BLKPREP_OK) 1240 return ret; 1241 } 1242 1243 cmd->cmnd = scsi_req(req)->cmd = scsi_req(req)->__cmd; 1244 memset(cmd->cmnd, 0, BLK_MAX_CDB); 1245 return scsi_cmd_to_driver(cmd)->init_command(cmd); 1246 } 1247 1248 static int scsi_setup_cmnd(struct scsi_device *sdev, struct request *req) 1249 { 1250 struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(req); 1251 1252 if (!blk_rq_bytes(req)) 1253 cmd->sc_data_direction = DMA_NONE; 1254 else if (rq_data_dir(req) == WRITE) 1255 cmd->sc_data_direction = DMA_TO_DEVICE; 1256 else 1257 cmd->sc_data_direction = DMA_FROM_DEVICE; 1258 1259 if (blk_rq_is_scsi(req)) 1260 return scsi_setup_scsi_cmnd(sdev, req); 1261 else 1262 return scsi_setup_fs_cmnd(sdev, req); 1263 } 1264 1265 static int 1266 scsi_prep_state_check(struct scsi_device *sdev, struct request *req) 1267 { 1268 int ret = BLKPREP_OK; 1269 1270 /* 1271 * If the device is not in running state we will reject some 1272 * or all commands. 1273 */ 1274 if (unlikely(sdev->sdev_state != SDEV_RUNNING)) { 1275 switch (sdev->sdev_state) { 1276 case SDEV_OFFLINE: 1277 case SDEV_TRANSPORT_OFFLINE: 1278 /* 1279 * If the device is offline we refuse to process any 1280 * commands. The device must be brought online 1281 * before trying any recovery commands. 1282 */ 1283 sdev_printk(KERN_ERR, sdev, 1284 "rejecting I/O to offline device\n"); 1285 ret = BLKPREP_KILL; 1286 break; 1287 case SDEV_DEL: 1288 /* 1289 * If the device is fully deleted, we refuse to 1290 * process any commands as well. 1291 */ 1292 sdev_printk(KERN_ERR, sdev, 1293 "rejecting I/O to dead device\n"); 1294 ret = BLKPREP_KILL; 1295 break; 1296 case SDEV_BLOCK: 1297 case SDEV_CREATED_BLOCK: 1298 ret = BLKPREP_DEFER; 1299 break; 1300 case SDEV_QUIESCE: 1301 /* 1302 * If the devices is blocked we defer normal commands. 1303 */ 1304 if (req && !(req->rq_flags & RQF_PREEMPT)) 1305 ret = BLKPREP_DEFER; 1306 break; 1307 default: 1308 /* 1309 * For any other not fully online state we only allow 1310 * special commands. In particular any user initiated 1311 * command is not allowed. 1312 */ 1313 if (req && !(req->rq_flags & RQF_PREEMPT)) 1314 ret = BLKPREP_KILL; 1315 break; 1316 } 1317 } 1318 return ret; 1319 } 1320 1321 static int 1322 scsi_prep_return(struct request_queue *q, struct request *req, int ret) 1323 { 1324 struct scsi_device *sdev = q->queuedata; 1325 1326 switch (ret) { 1327 case BLKPREP_KILL: 1328 case BLKPREP_INVALID: 1329 scsi_req(req)->result = DID_NO_CONNECT << 16; 1330 /* release the command and kill it */ 1331 if (req->special) { 1332 struct scsi_cmnd *cmd = req->special; 1333 scsi_release_buffers(cmd); 1334 scsi_put_command(cmd); 1335 put_device(&sdev->sdev_gendev); 1336 req->special = NULL; 1337 } 1338 break; 1339 case BLKPREP_DEFER: 1340 /* 1341 * If we defer, the blk_peek_request() returns NULL, but the 1342 * queue must be restarted, so we schedule a callback to happen 1343 * shortly. 1344 */ 1345 if (atomic_read(&sdev->device_busy) == 0) 1346 blk_delay_queue(q, SCSI_QUEUE_DELAY); 1347 break; 1348 default: 1349 req->rq_flags |= RQF_DONTPREP; 1350 } 1351 1352 return ret; 1353 } 1354 1355 static int scsi_prep_fn(struct request_queue *q, struct request *req) 1356 { 1357 struct scsi_device *sdev = q->queuedata; 1358 struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(req); 1359 int ret; 1360 1361 ret = scsi_prep_state_check(sdev, req); 1362 if (ret != BLKPREP_OK) 1363 goto out; 1364 1365 if (!req->special) { 1366 /* Bail if we can't get a reference to the device */ 1367 if (unlikely(!get_device(&sdev->sdev_gendev))) { 1368 ret = BLKPREP_DEFER; 1369 goto out; 1370 } 1371 1372 scsi_init_command(sdev, cmd); 1373 req->special = cmd; 1374 } 1375 1376 cmd->tag = req->tag; 1377 cmd->request = req; 1378 cmd->prot_op = SCSI_PROT_NORMAL; 1379 1380 ret = scsi_setup_cmnd(sdev, req); 1381 out: 1382 return scsi_prep_return(q, req, ret); 1383 } 1384 1385 static void scsi_unprep_fn(struct request_queue *q, struct request *req) 1386 { 1387 scsi_uninit_cmd(blk_mq_rq_to_pdu(req)); 1388 } 1389 1390 /* 1391 * scsi_dev_queue_ready: if we can send requests to sdev, return 1 else 1392 * return 0. 1393 * 1394 * Called with the queue_lock held. 1395 */ 1396 static inline int scsi_dev_queue_ready(struct request_queue *q, 1397 struct scsi_device *sdev) 1398 { 1399 unsigned int busy; 1400 1401 busy = atomic_inc_return(&sdev->device_busy) - 1; 1402 if (atomic_read(&sdev->device_blocked)) { 1403 if (busy) 1404 goto out_dec; 1405 1406 /* 1407 * unblock after device_blocked iterates to zero 1408 */ 1409 if (atomic_dec_return(&sdev->device_blocked) > 0) { 1410 /* 1411 * For the MQ case we take care of this in the caller. 1412 */ 1413 if (!q->mq_ops) 1414 blk_delay_queue(q, SCSI_QUEUE_DELAY); 1415 goto out_dec; 1416 } 1417 SCSI_LOG_MLQUEUE(3, sdev_printk(KERN_INFO, sdev, 1418 "unblocking device at zero depth\n")); 1419 } 1420 1421 if (busy >= sdev->queue_depth) 1422 goto out_dec; 1423 1424 return 1; 1425 out_dec: 1426 atomic_dec(&sdev->device_busy); 1427 return 0; 1428 } 1429 1430 /* 1431 * scsi_target_queue_ready: checks if there we can send commands to target 1432 * @sdev: scsi device on starget to check. 1433 */ 1434 static inline int scsi_target_queue_ready(struct Scsi_Host *shost, 1435 struct scsi_device *sdev) 1436 { 1437 struct scsi_target *starget = scsi_target(sdev); 1438 unsigned int busy; 1439 1440 if (starget->single_lun) { 1441 spin_lock_irq(shost->host_lock); 1442 if (starget->starget_sdev_user && 1443 starget->starget_sdev_user != sdev) { 1444 spin_unlock_irq(shost->host_lock); 1445 return 0; 1446 } 1447 starget->starget_sdev_user = sdev; 1448 spin_unlock_irq(shost->host_lock); 1449 } 1450 1451 if (starget->can_queue <= 0) 1452 return 1; 1453 1454 busy = atomic_inc_return(&starget->target_busy) - 1; 1455 if (atomic_read(&starget->target_blocked) > 0) { 1456 if (busy) 1457 goto starved; 1458 1459 /* 1460 * unblock after target_blocked iterates to zero 1461 */ 1462 if (atomic_dec_return(&starget->target_blocked) > 0) 1463 goto out_dec; 1464 1465 SCSI_LOG_MLQUEUE(3, starget_printk(KERN_INFO, starget, 1466 "unblocking target at zero depth\n")); 1467 } 1468 1469 if (busy >= starget->can_queue) 1470 goto starved; 1471 1472 return 1; 1473 1474 starved: 1475 spin_lock_irq(shost->host_lock); 1476 list_move_tail(&sdev->starved_entry, &shost->starved_list); 1477 spin_unlock_irq(shost->host_lock); 1478 out_dec: 1479 if (starget->can_queue > 0) 1480 atomic_dec(&starget->target_busy); 1481 return 0; 1482 } 1483 1484 /* 1485 * scsi_host_queue_ready: if we can send requests to shost, return 1 else 1486 * return 0. We must end up running the queue again whenever 0 is 1487 * returned, else IO can hang. 1488 */ 1489 static inline int scsi_host_queue_ready(struct request_queue *q, 1490 struct Scsi_Host *shost, 1491 struct scsi_device *sdev) 1492 { 1493 unsigned int busy; 1494 1495 if (scsi_host_in_recovery(shost)) 1496 return 0; 1497 1498 busy = atomic_inc_return(&shost->host_busy) - 1; 1499 if (atomic_read(&shost->host_blocked) > 0) { 1500 if (busy) 1501 goto starved; 1502 1503 /* 1504 * unblock after host_blocked iterates to zero 1505 */ 1506 if (atomic_dec_return(&shost->host_blocked) > 0) 1507 goto out_dec; 1508 1509 SCSI_LOG_MLQUEUE(3, 1510 shost_printk(KERN_INFO, shost, 1511 "unblocking host at zero depth\n")); 1512 } 1513 1514 if (shost->can_queue > 0 && busy >= shost->can_queue) 1515 goto starved; 1516 if (shost->host_self_blocked) 1517 goto starved; 1518 1519 /* We're OK to process the command, so we can't be starved */ 1520 if (!list_empty(&sdev->starved_entry)) { 1521 spin_lock_irq(shost->host_lock); 1522 if (!list_empty(&sdev->starved_entry)) 1523 list_del_init(&sdev->starved_entry); 1524 spin_unlock_irq(shost->host_lock); 1525 } 1526 1527 return 1; 1528 1529 starved: 1530 spin_lock_irq(shost->host_lock); 1531 if (list_empty(&sdev->starved_entry)) 1532 list_add_tail(&sdev->starved_entry, &shost->starved_list); 1533 spin_unlock_irq(shost->host_lock); 1534 out_dec: 1535 atomic_dec(&shost->host_busy); 1536 return 0; 1537 } 1538 1539 /* 1540 * Busy state exporting function for request stacking drivers. 1541 * 1542 * For efficiency, no lock is taken to check the busy state of 1543 * shost/starget/sdev, since the returned value is not guaranteed and 1544 * may be changed after request stacking drivers call the function, 1545 * regardless of taking lock or not. 1546 * 1547 * When scsi can't dispatch I/Os anymore and needs to kill I/Os scsi 1548 * needs to return 'not busy'. Otherwise, request stacking drivers 1549 * may hold requests forever. 1550 */ 1551 static int scsi_lld_busy(struct request_queue *q) 1552 { 1553 struct scsi_device *sdev = q->queuedata; 1554 struct Scsi_Host *shost; 1555 1556 if (blk_queue_dying(q)) 1557 return 0; 1558 1559 shost = sdev->host; 1560 1561 /* 1562 * Ignore host/starget busy state. 1563 * Since block layer does not have a concept of fairness across 1564 * multiple queues, congestion of host/starget needs to be handled 1565 * in SCSI layer. 1566 */ 1567 if (scsi_host_in_recovery(shost) || scsi_device_is_busy(sdev)) 1568 return 1; 1569 1570 return 0; 1571 } 1572 1573 /* 1574 * Kill a request for a dead device 1575 */ 1576 static void scsi_kill_request(struct request *req, struct request_queue *q) 1577 { 1578 struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(req); 1579 struct scsi_device *sdev; 1580 struct scsi_target *starget; 1581 struct Scsi_Host *shost; 1582 1583 blk_start_request(req); 1584 1585 scmd_printk(KERN_INFO, cmd, "killing request\n"); 1586 1587 sdev = cmd->device; 1588 starget = scsi_target(sdev); 1589 shost = sdev->host; 1590 scsi_init_cmd_errh(cmd); 1591 cmd->result = DID_NO_CONNECT << 16; 1592 atomic_inc(&cmd->device->iorequest_cnt); 1593 1594 /* 1595 * SCSI request completion path will do scsi_device_unbusy(), 1596 * bump busy counts. To bump the counters, we need to dance 1597 * with the locks as normal issue path does. 1598 */ 1599 atomic_inc(&sdev->device_busy); 1600 atomic_inc(&shost->host_busy); 1601 if (starget->can_queue > 0) 1602 atomic_inc(&starget->target_busy); 1603 1604 blk_complete_request(req); 1605 } 1606 1607 static void scsi_softirq_done(struct request *rq) 1608 { 1609 struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(rq); 1610 unsigned long wait_for = (cmd->allowed + 1) * rq->timeout; 1611 int disposition; 1612 1613 INIT_LIST_HEAD(&cmd->eh_entry); 1614 1615 atomic_inc(&cmd->device->iodone_cnt); 1616 if (cmd->result) 1617 atomic_inc(&cmd->device->ioerr_cnt); 1618 1619 disposition = scsi_decide_disposition(cmd); 1620 if (disposition != SUCCESS && 1621 time_before(cmd->jiffies_at_alloc + wait_for, jiffies)) { 1622 sdev_printk(KERN_ERR, cmd->device, 1623 "timing out command, waited %lus\n", 1624 wait_for/HZ); 1625 disposition = SUCCESS; 1626 } 1627 1628 scsi_log_completion(cmd, disposition); 1629 1630 switch (disposition) { 1631 case SUCCESS: 1632 scsi_finish_command(cmd); 1633 break; 1634 case NEEDS_RETRY: 1635 scsi_queue_insert(cmd, SCSI_MLQUEUE_EH_RETRY); 1636 break; 1637 case ADD_TO_MLQUEUE: 1638 scsi_queue_insert(cmd, SCSI_MLQUEUE_DEVICE_BUSY); 1639 break; 1640 default: 1641 scsi_eh_scmd_add(cmd); 1642 break; 1643 } 1644 } 1645 1646 /** 1647 * scsi_dispatch_command - Dispatch a command to the low-level driver. 1648 * @cmd: command block we are dispatching. 1649 * 1650 * Return: nonzero return request was rejected and device's queue needs to be 1651 * plugged. 1652 */ 1653 static int scsi_dispatch_cmd(struct scsi_cmnd *cmd) 1654 { 1655 struct Scsi_Host *host = cmd->device->host; 1656 int rtn = 0; 1657 1658 atomic_inc(&cmd->device->iorequest_cnt); 1659 1660 /* check if the device is still usable */ 1661 if (unlikely(cmd->device->sdev_state == SDEV_DEL)) { 1662 /* in SDEV_DEL we error all commands. DID_NO_CONNECT 1663 * returns an immediate error upwards, and signals 1664 * that the device is no longer present */ 1665 cmd->result = DID_NO_CONNECT << 16; 1666 goto done; 1667 } 1668 1669 /* Check to see if the scsi lld made this device blocked. */ 1670 if (unlikely(scsi_device_blocked(cmd->device))) { 1671 /* 1672 * in blocked state, the command is just put back on 1673 * the device queue. The suspend state has already 1674 * blocked the queue so future requests should not 1675 * occur until the device transitions out of the 1676 * suspend state. 1677 */ 1678 SCSI_LOG_MLQUEUE(3, scmd_printk(KERN_INFO, cmd, 1679 "queuecommand : device blocked\n")); 1680 return SCSI_MLQUEUE_DEVICE_BUSY; 1681 } 1682 1683 /* Store the LUN value in cmnd, if needed. */ 1684 if (cmd->device->lun_in_cdb) 1685 cmd->cmnd[1] = (cmd->cmnd[1] & 0x1f) | 1686 (cmd->device->lun << 5 & 0xe0); 1687 1688 scsi_log_send(cmd); 1689 1690 /* 1691 * Before we queue this command, check if the command 1692 * length exceeds what the host adapter can handle. 1693 */ 1694 if (cmd->cmd_len > cmd->device->host->max_cmd_len) { 1695 SCSI_LOG_MLQUEUE(3, scmd_printk(KERN_INFO, cmd, 1696 "queuecommand : command too long. " 1697 "cdb_size=%d host->max_cmd_len=%d\n", 1698 cmd->cmd_len, cmd->device->host->max_cmd_len)); 1699 cmd->result = (DID_ABORT << 16); 1700 goto done; 1701 } 1702 1703 if (unlikely(host->shost_state == SHOST_DEL)) { 1704 cmd->result = (DID_NO_CONNECT << 16); 1705 goto done; 1706 1707 } 1708 1709 trace_scsi_dispatch_cmd_start(cmd); 1710 rtn = host->hostt->queuecommand(host, cmd); 1711 if (rtn) { 1712 trace_scsi_dispatch_cmd_error(cmd, rtn); 1713 if (rtn != SCSI_MLQUEUE_DEVICE_BUSY && 1714 rtn != SCSI_MLQUEUE_TARGET_BUSY) 1715 rtn = SCSI_MLQUEUE_HOST_BUSY; 1716 1717 SCSI_LOG_MLQUEUE(3, scmd_printk(KERN_INFO, cmd, 1718 "queuecommand : request rejected\n")); 1719 } 1720 1721 return rtn; 1722 done: 1723 cmd->scsi_done(cmd); 1724 return 0; 1725 } 1726 1727 /** 1728 * scsi_done - Invoke completion on finished SCSI command. 1729 * @cmd: The SCSI Command for which a low-level device driver (LLDD) gives 1730 * ownership back to SCSI Core -- i.e. the LLDD has finished with it. 1731 * 1732 * Description: This function is the mid-level's (SCSI Core) interrupt routine, 1733 * which regains ownership of the SCSI command (de facto) from a LLDD, and 1734 * calls blk_complete_request() for further processing. 1735 * 1736 * This function is interrupt context safe. 1737 */ 1738 static void scsi_done(struct scsi_cmnd *cmd) 1739 { 1740 trace_scsi_dispatch_cmd_done(cmd); 1741 blk_complete_request(cmd->request); 1742 } 1743 1744 /* 1745 * Function: scsi_request_fn() 1746 * 1747 * Purpose: Main strategy routine for SCSI. 1748 * 1749 * Arguments: q - Pointer to actual queue. 1750 * 1751 * Returns: Nothing 1752 * 1753 * Lock status: request queue lock assumed to be held when called. 1754 * 1755 * Note: See sd_zbc.c sd_zbc_write_lock_zone() for write order 1756 * protection for ZBC disks. 1757 */ 1758 static void scsi_request_fn(struct request_queue *q) 1759 __releases(q->queue_lock) 1760 __acquires(q->queue_lock) 1761 { 1762 struct scsi_device *sdev = q->queuedata; 1763 struct Scsi_Host *shost; 1764 struct scsi_cmnd *cmd; 1765 struct request *req; 1766 1767 /* 1768 * To start with, we keep looping until the queue is empty, or until 1769 * the host is no longer able to accept any more requests. 1770 */ 1771 shost = sdev->host; 1772 for (;;) { 1773 int rtn; 1774 /* 1775 * get next queueable request. We do this early to make sure 1776 * that the request is fully prepared even if we cannot 1777 * accept it. 1778 */ 1779 req = blk_peek_request(q); 1780 if (!req) 1781 break; 1782 1783 if (unlikely(!scsi_device_online(sdev))) { 1784 sdev_printk(KERN_ERR, sdev, 1785 "rejecting I/O to offline device\n"); 1786 scsi_kill_request(req, q); 1787 continue; 1788 } 1789 1790 if (!scsi_dev_queue_ready(q, sdev)) 1791 break; 1792 1793 /* 1794 * Remove the request from the request list. 1795 */ 1796 if (!(blk_queue_tagged(q) && !blk_queue_start_tag(q, req))) 1797 blk_start_request(req); 1798 1799 spin_unlock_irq(q->queue_lock); 1800 cmd = blk_mq_rq_to_pdu(req); 1801 if (cmd != req->special) { 1802 printk(KERN_CRIT "impossible request in %s.\n" 1803 "please mail a stack trace to " 1804 "linux-scsi@vger.kernel.org\n", 1805 __func__); 1806 blk_dump_rq_flags(req, "foo"); 1807 BUG(); 1808 } 1809 1810 /* 1811 * We hit this when the driver is using a host wide 1812 * tag map. For device level tag maps the queue_depth check 1813 * in the device ready fn would prevent us from trying 1814 * to allocate a tag. Since the map is a shared host resource 1815 * we add the dev to the starved list so it eventually gets 1816 * a run when a tag is freed. 1817 */ 1818 if (blk_queue_tagged(q) && !(req->rq_flags & RQF_QUEUED)) { 1819 spin_lock_irq(shost->host_lock); 1820 if (list_empty(&sdev->starved_entry)) 1821 list_add_tail(&sdev->starved_entry, 1822 &shost->starved_list); 1823 spin_unlock_irq(shost->host_lock); 1824 goto not_ready; 1825 } 1826 1827 if (!scsi_target_queue_ready(shost, sdev)) 1828 goto not_ready; 1829 1830 if (!scsi_host_queue_ready(q, shost, sdev)) 1831 goto host_not_ready; 1832 1833 if (sdev->simple_tags) 1834 cmd->flags |= SCMD_TAGGED; 1835 else 1836 cmd->flags &= ~SCMD_TAGGED; 1837 1838 /* 1839 * Finally, initialize any error handling parameters, and set up 1840 * the timers for timeouts. 1841 */ 1842 scsi_init_cmd_errh(cmd); 1843 1844 /* 1845 * Dispatch the command to the low-level driver. 1846 */ 1847 cmd->scsi_done = scsi_done; 1848 rtn = scsi_dispatch_cmd(cmd); 1849 if (rtn) { 1850 scsi_queue_insert(cmd, rtn); 1851 spin_lock_irq(q->queue_lock); 1852 goto out_delay; 1853 } 1854 spin_lock_irq(q->queue_lock); 1855 } 1856 1857 return; 1858 1859 host_not_ready: 1860 if (scsi_target(sdev)->can_queue > 0) 1861 atomic_dec(&scsi_target(sdev)->target_busy); 1862 not_ready: 1863 /* 1864 * lock q, handle tag, requeue req, and decrement device_busy. We 1865 * must return with queue_lock held. 1866 * 1867 * Decrementing device_busy without checking it is OK, as all such 1868 * cases (host limits or settings) should run the queue at some 1869 * later time. 1870 */ 1871 spin_lock_irq(q->queue_lock); 1872 blk_requeue_request(q, req); 1873 atomic_dec(&sdev->device_busy); 1874 out_delay: 1875 if (!atomic_read(&sdev->device_busy) && !scsi_device_blocked(sdev)) 1876 blk_delay_queue(q, SCSI_QUEUE_DELAY); 1877 } 1878 1879 static inline blk_status_t prep_to_mq(int ret) 1880 { 1881 switch (ret) { 1882 case BLKPREP_OK: 1883 return BLK_STS_OK; 1884 case BLKPREP_DEFER: 1885 return BLK_STS_RESOURCE; 1886 default: 1887 return BLK_STS_IOERR; 1888 } 1889 } 1890 1891 /* Size in bytes of the sg-list stored in the scsi-mq command-private data. */ 1892 static unsigned int scsi_mq_sgl_size(struct Scsi_Host *shost) 1893 { 1894 return min_t(unsigned int, shost->sg_tablesize, SG_CHUNK_SIZE) * 1895 sizeof(struct scatterlist); 1896 } 1897 1898 static int scsi_mq_prep_fn(struct request *req) 1899 { 1900 struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(req); 1901 struct scsi_device *sdev = req->q->queuedata; 1902 struct Scsi_Host *shost = sdev->host; 1903 struct scatterlist *sg; 1904 1905 scsi_init_command(sdev, cmd); 1906 1907 req->special = cmd; 1908 1909 cmd->request = req; 1910 1911 cmd->tag = req->tag; 1912 cmd->prot_op = SCSI_PROT_NORMAL; 1913 1914 sg = (void *)cmd + sizeof(struct scsi_cmnd) + shost->hostt->cmd_size; 1915 cmd->sdb.table.sgl = sg; 1916 1917 if (scsi_host_get_prot(shost)) { 1918 memset(cmd->prot_sdb, 0, sizeof(struct scsi_data_buffer)); 1919 1920 cmd->prot_sdb->table.sgl = 1921 (struct scatterlist *)(cmd->prot_sdb + 1); 1922 } 1923 1924 if (blk_bidi_rq(req)) { 1925 struct request *next_rq = req->next_rq; 1926 struct scsi_data_buffer *bidi_sdb = blk_mq_rq_to_pdu(next_rq); 1927 1928 memset(bidi_sdb, 0, sizeof(struct scsi_data_buffer)); 1929 bidi_sdb->table.sgl = 1930 (struct scatterlist *)(bidi_sdb + 1); 1931 1932 next_rq->special = bidi_sdb; 1933 } 1934 1935 blk_mq_start_request(req); 1936 1937 return scsi_setup_cmnd(sdev, req); 1938 } 1939 1940 static void scsi_mq_done(struct scsi_cmnd *cmd) 1941 { 1942 trace_scsi_dispatch_cmd_done(cmd); 1943 blk_mq_complete_request(cmd->request); 1944 } 1945 1946 static void scsi_mq_put_budget(struct blk_mq_hw_ctx *hctx) 1947 { 1948 struct request_queue *q = hctx->queue; 1949 struct scsi_device *sdev = q->queuedata; 1950 1951 atomic_dec(&sdev->device_busy); 1952 put_device(&sdev->sdev_gendev); 1953 } 1954 1955 static bool scsi_mq_get_budget(struct blk_mq_hw_ctx *hctx) 1956 { 1957 struct request_queue *q = hctx->queue; 1958 struct scsi_device *sdev = q->queuedata; 1959 1960 if (!get_device(&sdev->sdev_gendev)) 1961 goto out; 1962 if (!scsi_dev_queue_ready(q, sdev)) 1963 goto out_put_device; 1964 1965 return true; 1966 1967 out_put_device: 1968 put_device(&sdev->sdev_gendev); 1969 out: 1970 return false; 1971 } 1972 1973 static blk_status_t scsi_queue_rq(struct blk_mq_hw_ctx *hctx, 1974 const struct blk_mq_queue_data *bd) 1975 { 1976 struct request *req = bd->rq; 1977 struct request_queue *q = req->q; 1978 struct scsi_device *sdev = q->queuedata; 1979 struct Scsi_Host *shost = sdev->host; 1980 struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(req); 1981 blk_status_t ret; 1982 int reason; 1983 1984 ret = prep_to_mq(scsi_prep_state_check(sdev, req)); 1985 if (ret != BLK_STS_OK) 1986 goto out_put_budget; 1987 1988 ret = BLK_STS_RESOURCE; 1989 if (!scsi_target_queue_ready(shost, sdev)) 1990 goto out_put_budget; 1991 if (!scsi_host_queue_ready(q, shost, sdev)) 1992 goto out_dec_target_busy; 1993 1994 if (!(req->rq_flags & RQF_DONTPREP)) { 1995 ret = prep_to_mq(scsi_mq_prep_fn(req)); 1996 if (ret != BLK_STS_OK) 1997 goto out_dec_host_busy; 1998 req->rq_flags |= RQF_DONTPREP; 1999 } else { 2000 blk_mq_start_request(req); 2001 } 2002 2003 if (sdev->simple_tags) 2004 cmd->flags |= SCMD_TAGGED; 2005 else 2006 cmd->flags &= ~SCMD_TAGGED; 2007 2008 scsi_init_cmd_errh(cmd); 2009 cmd->scsi_done = scsi_mq_done; 2010 2011 reason = scsi_dispatch_cmd(cmd); 2012 if (reason) { 2013 scsi_set_blocked(cmd, reason); 2014 ret = BLK_STS_RESOURCE; 2015 goto out_dec_host_busy; 2016 } 2017 2018 return BLK_STS_OK; 2019 2020 out_dec_host_busy: 2021 atomic_dec(&shost->host_busy); 2022 out_dec_target_busy: 2023 if (scsi_target(sdev)->can_queue > 0) 2024 atomic_dec(&scsi_target(sdev)->target_busy); 2025 out_put_budget: 2026 scsi_mq_put_budget(hctx); 2027 switch (ret) { 2028 case BLK_STS_OK: 2029 break; 2030 case BLK_STS_RESOURCE: 2031 if (atomic_read(&sdev->device_busy) == 0 && 2032 !scsi_device_blocked(sdev)) 2033 blk_mq_delay_run_hw_queue(hctx, SCSI_QUEUE_DELAY); 2034 break; 2035 default: 2036 /* 2037 * Make sure to release all allocated ressources when 2038 * we hit an error, as we will never see this command 2039 * again. 2040 */ 2041 if (req->rq_flags & RQF_DONTPREP) 2042 scsi_mq_uninit_cmd(cmd); 2043 break; 2044 } 2045 return ret; 2046 } 2047 2048 static enum blk_eh_timer_return scsi_timeout(struct request *req, 2049 bool reserved) 2050 { 2051 if (reserved) 2052 return BLK_EH_RESET_TIMER; 2053 return scsi_times_out(req); 2054 } 2055 2056 static int scsi_mq_init_request(struct blk_mq_tag_set *set, struct request *rq, 2057 unsigned int hctx_idx, unsigned int numa_node) 2058 { 2059 struct Scsi_Host *shost = set->driver_data; 2060 const bool unchecked_isa_dma = shost->unchecked_isa_dma; 2061 struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(rq); 2062 struct scatterlist *sg; 2063 2064 if (unchecked_isa_dma) 2065 cmd->flags |= SCMD_UNCHECKED_ISA_DMA; 2066 cmd->sense_buffer = scsi_alloc_sense_buffer(unchecked_isa_dma, 2067 GFP_KERNEL, numa_node); 2068 if (!cmd->sense_buffer) 2069 return -ENOMEM; 2070 cmd->req.sense = cmd->sense_buffer; 2071 2072 if (scsi_host_get_prot(shost)) { 2073 sg = (void *)cmd + sizeof(struct scsi_cmnd) + 2074 shost->hostt->cmd_size; 2075 cmd->prot_sdb = (void *)sg + scsi_mq_sgl_size(shost); 2076 } 2077 2078 return 0; 2079 } 2080 2081 static void scsi_mq_exit_request(struct blk_mq_tag_set *set, struct request *rq, 2082 unsigned int hctx_idx) 2083 { 2084 struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(rq); 2085 2086 scsi_free_sense_buffer(cmd->flags & SCMD_UNCHECKED_ISA_DMA, 2087 cmd->sense_buffer); 2088 } 2089 2090 static int scsi_map_queues(struct blk_mq_tag_set *set) 2091 { 2092 struct Scsi_Host *shost = container_of(set, struct Scsi_Host, tag_set); 2093 2094 if (shost->hostt->map_queues) 2095 return shost->hostt->map_queues(shost); 2096 return blk_mq_map_queues(set); 2097 } 2098 2099 static u64 scsi_calculate_bounce_limit(struct Scsi_Host *shost) 2100 { 2101 struct device *host_dev; 2102 u64 bounce_limit = 0xffffffff; 2103 2104 if (shost->unchecked_isa_dma) 2105 return BLK_BOUNCE_ISA; 2106 /* 2107 * Platforms with virtual-DMA translation 2108 * hardware have no practical limit. 2109 */ 2110 if (!PCI_DMA_BUS_IS_PHYS) 2111 return BLK_BOUNCE_ANY; 2112 2113 host_dev = scsi_get_device(shost); 2114 if (host_dev && host_dev->dma_mask) 2115 bounce_limit = (u64)dma_max_pfn(host_dev) << PAGE_SHIFT; 2116 2117 return bounce_limit; 2118 } 2119 2120 void __scsi_init_queue(struct Scsi_Host *shost, struct request_queue *q) 2121 { 2122 struct device *dev = shost->dma_dev; 2123 2124 queue_flag_set_unlocked(QUEUE_FLAG_SCSI_PASSTHROUGH, q); 2125 2126 /* 2127 * this limit is imposed by hardware restrictions 2128 */ 2129 blk_queue_max_segments(q, min_t(unsigned short, shost->sg_tablesize, 2130 SG_MAX_SEGMENTS)); 2131 2132 if (scsi_host_prot_dma(shost)) { 2133 shost->sg_prot_tablesize = 2134 min_not_zero(shost->sg_prot_tablesize, 2135 (unsigned short)SCSI_MAX_PROT_SG_SEGMENTS); 2136 BUG_ON(shost->sg_prot_tablesize < shost->sg_tablesize); 2137 blk_queue_max_integrity_segments(q, shost->sg_prot_tablesize); 2138 } 2139 2140 blk_queue_max_hw_sectors(q, shost->max_sectors); 2141 blk_queue_bounce_limit(q, scsi_calculate_bounce_limit(shost)); 2142 blk_queue_segment_boundary(q, shost->dma_boundary); 2143 dma_set_seg_boundary(dev, shost->dma_boundary); 2144 2145 blk_queue_max_segment_size(q, dma_get_max_seg_size(dev)); 2146 2147 if (!shost->use_clustering) 2148 q->limits.cluster = 0; 2149 2150 /* 2151 * set a reasonable default alignment on word boundaries: the 2152 * host and device may alter it using 2153 * blk_queue_update_dma_alignment() later. 2154 */ 2155 blk_queue_dma_alignment(q, 0x03); 2156 } 2157 EXPORT_SYMBOL_GPL(__scsi_init_queue); 2158 2159 static int scsi_old_init_rq(struct request_queue *q, struct request *rq, 2160 gfp_t gfp) 2161 { 2162 struct Scsi_Host *shost = q->rq_alloc_data; 2163 const bool unchecked_isa_dma = shost->unchecked_isa_dma; 2164 struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(rq); 2165 2166 memset(cmd, 0, sizeof(*cmd)); 2167 2168 if (unchecked_isa_dma) 2169 cmd->flags |= SCMD_UNCHECKED_ISA_DMA; 2170 cmd->sense_buffer = scsi_alloc_sense_buffer(unchecked_isa_dma, gfp, 2171 NUMA_NO_NODE); 2172 if (!cmd->sense_buffer) 2173 goto fail; 2174 cmd->req.sense = cmd->sense_buffer; 2175 2176 if (scsi_host_get_prot(shost) >= SHOST_DIX_TYPE0_PROTECTION) { 2177 cmd->prot_sdb = kmem_cache_zalloc(scsi_sdb_cache, gfp); 2178 if (!cmd->prot_sdb) 2179 goto fail_free_sense; 2180 } 2181 2182 return 0; 2183 2184 fail_free_sense: 2185 scsi_free_sense_buffer(unchecked_isa_dma, cmd->sense_buffer); 2186 fail: 2187 return -ENOMEM; 2188 } 2189 2190 static void scsi_old_exit_rq(struct request_queue *q, struct request *rq) 2191 { 2192 struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(rq); 2193 2194 if (cmd->prot_sdb) 2195 kmem_cache_free(scsi_sdb_cache, cmd->prot_sdb); 2196 scsi_free_sense_buffer(cmd->flags & SCMD_UNCHECKED_ISA_DMA, 2197 cmd->sense_buffer); 2198 } 2199 2200 struct request_queue *scsi_old_alloc_queue(struct scsi_device *sdev) 2201 { 2202 struct Scsi_Host *shost = sdev->host; 2203 struct request_queue *q; 2204 2205 q = blk_alloc_queue_node(GFP_KERNEL, NUMA_NO_NODE); 2206 if (!q) 2207 return NULL; 2208 q->cmd_size = sizeof(struct scsi_cmnd) + shost->hostt->cmd_size; 2209 q->rq_alloc_data = shost; 2210 q->request_fn = scsi_request_fn; 2211 q->init_rq_fn = scsi_old_init_rq; 2212 q->exit_rq_fn = scsi_old_exit_rq; 2213 q->initialize_rq_fn = scsi_initialize_rq; 2214 2215 if (blk_init_allocated_queue(q) < 0) { 2216 blk_cleanup_queue(q); 2217 return NULL; 2218 } 2219 2220 __scsi_init_queue(shost, q); 2221 blk_queue_prep_rq(q, scsi_prep_fn); 2222 blk_queue_unprep_rq(q, scsi_unprep_fn); 2223 blk_queue_softirq_done(q, scsi_softirq_done); 2224 blk_queue_rq_timed_out(q, scsi_times_out); 2225 blk_queue_lld_busy(q, scsi_lld_busy); 2226 return q; 2227 } 2228 2229 static const struct blk_mq_ops scsi_mq_ops = { 2230 .get_budget = scsi_mq_get_budget, 2231 .put_budget = scsi_mq_put_budget, 2232 .queue_rq = scsi_queue_rq, 2233 .complete = scsi_softirq_done, 2234 .timeout = scsi_timeout, 2235 #ifdef CONFIG_BLK_DEBUG_FS 2236 .show_rq = scsi_show_rq, 2237 #endif 2238 .init_request = scsi_mq_init_request, 2239 .exit_request = scsi_mq_exit_request, 2240 .initialize_rq_fn = scsi_initialize_rq, 2241 .map_queues = scsi_map_queues, 2242 }; 2243 2244 struct request_queue *scsi_mq_alloc_queue(struct scsi_device *sdev) 2245 { 2246 sdev->request_queue = blk_mq_init_queue(&sdev->host->tag_set); 2247 if (IS_ERR(sdev->request_queue)) 2248 return NULL; 2249 2250 sdev->request_queue->queuedata = sdev; 2251 __scsi_init_queue(sdev->host, sdev->request_queue); 2252 return sdev->request_queue; 2253 } 2254 2255 int scsi_mq_setup_tags(struct Scsi_Host *shost) 2256 { 2257 unsigned int cmd_size, sgl_size; 2258 2259 sgl_size = scsi_mq_sgl_size(shost); 2260 cmd_size = sizeof(struct scsi_cmnd) + shost->hostt->cmd_size + sgl_size; 2261 if (scsi_host_get_prot(shost)) 2262 cmd_size += sizeof(struct scsi_data_buffer) + sgl_size; 2263 2264 memset(&shost->tag_set, 0, sizeof(shost->tag_set)); 2265 shost->tag_set.ops = &scsi_mq_ops; 2266 shost->tag_set.nr_hw_queues = shost->nr_hw_queues ? : 1; 2267 shost->tag_set.queue_depth = shost->can_queue; 2268 shost->tag_set.cmd_size = cmd_size; 2269 shost->tag_set.numa_node = NUMA_NO_NODE; 2270 shost->tag_set.flags = BLK_MQ_F_SHOULD_MERGE | BLK_MQ_F_SG_MERGE; 2271 shost->tag_set.flags |= 2272 BLK_ALLOC_POLICY_TO_MQ_FLAG(shost->hostt->tag_alloc_policy); 2273 shost->tag_set.driver_data = shost; 2274 2275 return blk_mq_alloc_tag_set(&shost->tag_set); 2276 } 2277 2278 void scsi_mq_destroy_tags(struct Scsi_Host *shost) 2279 { 2280 blk_mq_free_tag_set(&shost->tag_set); 2281 } 2282 2283 /** 2284 * scsi_device_from_queue - return sdev associated with a request_queue 2285 * @q: The request queue to return the sdev from 2286 * 2287 * Return the sdev associated with a request queue or NULL if the 2288 * request_queue does not reference a SCSI device. 2289 */ 2290 struct scsi_device *scsi_device_from_queue(struct request_queue *q) 2291 { 2292 struct scsi_device *sdev = NULL; 2293 2294 if (q->mq_ops) { 2295 if (q->mq_ops == &scsi_mq_ops) 2296 sdev = q->queuedata; 2297 } else if (q->request_fn == scsi_request_fn) 2298 sdev = q->queuedata; 2299 if (!sdev || !get_device(&sdev->sdev_gendev)) 2300 sdev = NULL; 2301 2302 return sdev; 2303 } 2304 EXPORT_SYMBOL_GPL(scsi_device_from_queue); 2305 2306 /* 2307 * Function: scsi_block_requests() 2308 * 2309 * Purpose: Utility function used by low-level drivers to prevent further 2310 * commands from being queued to the device. 2311 * 2312 * Arguments: shost - Host in question 2313 * 2314 * Returns: Nothing 2315 * 2316 * Lock status: No locks are assumed held. 2317 * 2318 * Notes: There is no timer nor any other means by which the requests 2319 * get unblocked other than the low-level driver calling 2320 * scsi_unblock_requests(). 2321 */ 2322 void scsi_block_requests(struct Scsi_Host *shost) 2323 { 2324 shost->host_self_blocked = 1; 2325 } 2326 EXPORT_SYMBOL(scsi_block_requests); 2327 2328 /* 2329 * Function: scsi_unblock_requests() 2330 * 2331 * Purpose: Utility function used by low-level drivers to allow further 2332 * commands from being queued to the device. 2333 * 2334 * Arguments: shost - Host in question 2335 * 2336 * Returns: Nothing 2337 * 2338 * Lock status: No locks are assumed held. 2339 * 2340 * Notes: There is no timer nor any other means by which the requests 2341 * get unblocked other than the low-level driver calling 2342 * scsi_unblock_requests(). 2343 * 2344 * This is done as an API function so that changes to the 2345 * internals of the scsi mid-layer won't require wholesale 2346 * changes to drivers that use this feature. 2347 */ 2348 void scsi_unblock_requests(struct Scsi_Host *shost) 2349 { 2350 shost->host_self_blocked = 0; 2351 scsi_run_host_queues(shost); 2352 } 2353 EXPORT_SYMBOL(scsi_unblock_requests); 2354 2355 int __init scsi_init_queue(void) 2356 { 2357 scsi_sdb_cache = kmem_cache_create("scsi_data_buffer", 2358 sizeof(struct scsi_data_buffer), 2359 0, 0, NULL); 2360 if (!scsi_sdb_cache) { 2361 printk(KERN_ERR "SCSI: can't init scsi sdb cache\n"); 2362 return -ENOMEM; 2363 } 2364 2365 return 0; 2366 } 2367 2368 void scsi_exit_queue(void) 2369 { 2370 kmem_cache_destroy(scsi_sense_cache); 2371 kmem_cache_destroy(scsi_sense_isadma_cache); 2372 kmem_cache_destroy(scsi_sdb_cache); 2373 } 2374 2375 /** 2376 * scsi_mode_select - issue a mode select 2377 * @sdev: SCSI device to be queried 2378 * @pf: Page format bit (1 == standard, 0 == vendor specific) 2379 * @sp: Save page bit (0 == don't save, 1 == save) 2380 * @modepage: mode page being requested 2381 * @buffer: request buffer (may not be smaller than eight bytes) 2382 * @len: length of request buffer. 2383 * @timeout: command timeout 2384 * @retries: number of retries before failing 2385 * @data: returns a structure abstracting the mode header data 2386 * @sshdr: place to put sense data (or NULL if no sense to be collected). 2387 * must be SCSI_SENSE_BUFFERSIZE big. 2388 * 2389 * Returns zero if successful; negative error number or scsi 2390 * status on error 2391 * 2392 */ 2393 int 2394 scsi_mode_select(struct scsi_device *sdev, int pf, int sp, int modepage, 2395 unsigned char *buffer, int len, int timeout, int retries, 2396 struct scsi_mode_data *data, struct scsi_sense_hdr *sshdr) 2397 { 2398 unsigned char cmd[10]; 2399 unsigned char *real_buffer; 2400 int ret; 2401 2402 memset(cmd, 0, sizeof(cmd)); 2403 cmd[1] = (pf ? 0x10 : 0) | (sp ? 0x01 : 0); 2404 2405 if (sdev->use_10_for_ms) { 2406 if (len > 65535) 2407 return -EINVAL; 2408 real_buffer = kmalloc(8 + len, GFP_KERNEL); 2409 if (!real_buffer) 2410 return -ENOMEM; 2411 memcpy(real_buffer + 8, buffer, len); 2412 len += 8; 2413 real_buffer[0] = 0; 2414 real_buffer[1] = 0; 2415 real_buffer[2] = data->medium_type; 2416 real_buffer[3] = data->device_specific; 2417 real_buffer[4] = data->longlba ? 0x01 : 0; 2418 real_buffer[5] = 0; 2419 real_buffer[6] = data->block_descriptor_length >> 8; 2420 real_buffer[7] = data->block_descriptor_length; 2421 2422 cmd[0] = MODE_SELECT_10; 2423 cmd[7] = len >> 8; 2424 cmd[8] = len; 2425 } else { 2426 if (len > 255 || data->block_descriptor_length > 255 || 2427 data->longlba) 2428 return -EINVAL; 2429 2430 real_buffer = kmalloc(4 + len, GFP_KERNEL); 2431 if (!real_buffer) 2432 return -ENOMEM; 2433 memcpy(real_buffer + 4, buffer, len); 2434 len += 4; 2435 real_buffer[0] = 0; 2436 real_buffer[1] = data->medium_type; 2437 real_buffer[2] = data->device_specific; 2438 real_buffer[3] = data->block_descriptor_length; 2439 2440 2441 cmd[0] = MODE_SELECT; 2442 cmd[4] = len; 2443 } 2444 2445 ret = scsi_execute_req(sdev, cmd, DMA_TO_DEVICE, real_buffer, len, 2446 sshdr, timeout, retries, NULL); 2447 kfree(real_buffer); 2448 return ret; 2449 } 2450 EXPORT_SYMBOL_GPL(scsi_mode_select); 2451 2452 /** 2453 * scsi_mode_sense - issue a mode sense, falling back from 10 to six bytes if necessary. 2454 * @sdev: SCSI device to be queried 2455 * @dbd: set if mode sense will allow block descriptors to be returned 2456 * @modepage: mode page being requested 2457 * @buffer: request buffer (may not be smaller than eight bytes) 2458 * @len: length of request buffer. 2459 * @timeout: command timeout 2460 * @retries: number of retries before failing 2461 * @data: returns a structure abstracting the mode header data 2462 * @sshdr: place to put sense data (or NULL if no sense to be collected). 2463 * must be SCSI_SENSE_BUFFERSIZE big. 2464 * 2465 * Returns zero if unsuccessful, or the header offset (either 4 2466 * or 8 depending on whether a six or ten byte command was 2467 * issued) if successful. 2468 */ 2469 int 2470 scsi_mode_sense(struct scsi_device *sdev, int dbd, int modepage, 2471 unsigned char *buffer, int len, int timeout, int retries, 2472 struct scsi_mode_data *data, struct scsi_sense_hdr *sshdr) 2473 { 2474 unsigned char cmd[12]; 2475 int use_10_for_ms; 2476 int header_length; 2477 int result, retry_count = retries; 2478 struct scsi_sense_hdr my_sshdr; 2479 2480 memset(data, 0, sizeof(*data)); 2481 memset(&cmd[0], 0, 12); 2482 cmd[1] = dbd & 0x18; /* allows DBD and LLBA bits */ 2483 cmd[2] = modepage; 2484 2485 /* caller might not be interested in sense, but we need it */ 2486 if (!sshdr) 2487 sshdr = &my_sshdr; 2488 2489 retry: 2490 use_10_for_ms = sdev->use_10_for_ms; 2491 2492 if (use_10_for_ms) { 2493 if (len < 8) 2494 len = 8; 2495 2496 cmd[0] = MODE_SENSE_10; 2497 cmd[8] = len; 2498 header_length = 8; 2499 } else { 2500 if (len < 4) 2501 len = 4; 2502 2503 cmd[0] = MODE_SENSE; 2504 cmd[4] = len; 2505 header_length = 4; 2506 } 2507 2508 memset(buffer, 0, len); 2509 2510 result = scsi_execute_req(sdev, cmd, DMA_FROM_DEVICE, buffer, len, 2511 sshdr, timeout, retries, NULL); 2512 2513 /* This code looks awful: what it's doing is making sure an 2514 * ILLEGAL REQUEST sense return identifies the actual command 2515 * byte as the problem. MODE_SENSE commands can return 2516 * ILLEGAL REQUEST if the code page isn't supported */ 2517 2518 if (use_10_for_ms && !scsi_status_is_good(result) && 2519 (driver_byte(result) & DRIVER_SENSE)) { 2520 if (scsi_sense_valid(sshdr)) { 2521 if ((sshdr->sense_key == ILLEGAL_REQUEST) && 2522 (sshdr->asc == 0x20) && (sshdr->ascq == 0)) { 2523 /* 2524 * Invalid command operation code 2525 */ 2526 sdev->use_10_for_ms = 0; 2527 goto retry; 2528 } 2529 } 2530 } 2531 2532 if(scsi_status_is_good(result)) { 2533 if (unlikely(buffer[0] == 0x86 && buffer[1] == 0x0b && 2534 (modepage == 6 || modepage == 8))) { 2535 /* Initio breakage? */ 2536 header_length = 0; 2537 data->length = 13; 2538 data->medium_type = 0; 2539 data->device_specific = 0; 2540 data->longlba = 0; 2541 data->block_descriptor_length = 0; 2542 } else if(use_10_for_ms) { 2543 data->length = buffer[0]*256 + buffer[1] + 2; 2544 data->medium_type = buffer[2]; 2545 data->device_specific = buffer[3]; 2546 data->longlba = buffer[4] & 0x01; 2547 data->block_descriptor_length = buffer[6]*256 2548 + buffer[7]; 2549 } else { 2550 data->length = buffer[0] + 1; 2551 data->medium_type = buffer[1]; 2552 data->device_specific = buffer[2]; 2553 data->block_descriptor_length = buffer[3]; 2554 } 2555 data->header_length = header_length; 2556 } else if ((status_byte(result) == CHECK_CONDITION) && 2557 scsi_sense_valid(sshdr) && 2558 sshdr->sense_key == UNIT_ATTENTION && retry_count) { 2559 retry_count--; 2560 goto retry; 2561 } 2562 2563 return result; 2564 } 2565 EXPORT_SYMBOL(scsi_mode_sense); 2566 2567 /** 2568 * scsi_test_unit_ready - test if unit is ready 2569 * @sdev: scsi device to change the state of. 2570 * @timeout: command timeout 2571 * @retries: number of retries before failing 2572 * @sshdr: outpout pointer for decoded sense information. 2573 * 2574 * Returns zero if unsuccessful or an error if TUR failed. For 2575 * removable media, UNIT_ATTENTION sets ->changed flag. 2576 **/ 2577 int 2578 scsi_test_unit_ready(struct scsi_device *sdev, int timeout, int retries, 2579 struct scsi_sense_hdr *sshdr) 2580 { 2581 char cmd[] = { 2582 TEST_UNIT_READY, 0, 0, 0, 0, 0, 2583 }; 2584 int result; 2585 2586 /* try to eat the UNIT_ATTENTION if there are enough retries */ 2587 do { 2588 result = scsi_execute_req(sdev, cmd, DMA_NONE, NULL, 0, sshdr, 2589 timeout, retries, NULL); 2590 if (sdev->removable && scsi_sense_valid(sshdr) && 2591 sshdr->sense_key == UNIT_ATTENTION) 2592 sdev->changed = 1; 2593 } while (scsi_sense_valid(sshdr) && 2594 sshdr->sense_key == UNIT_ATTENTION && --retries); 2595 2596 return result; 2597 } 2598 EXPORT_SYMBOL(scsi_test_unit_ready); 2599 2600 /** 2601 * scsi_device_set_state - Take the given device through the device state model. 2602 * @sdev: scsi device to change the state of. 2603 * @state: state to change to. 2604 * 2605 * Returns zero if successful or an error if the requested 2606 * transition is illegal. 2607 */ 2608 int 2609 scsi_device_set_state(struct scsi_device *sdev, enum scsi_device_state state) 2610 { 2611 enum scsi_device_state oldstate = sdev->sdev_state; 2612 2613 if (state == oldstate) 2614 return 0; 2615 2616 switch (state) { 2617 case SDEV_CREATED: 2618 switch (oldstate) { 2619 case SDEV_CREATED_BLOCK: 2620 break; 2621 default: 2622 goto illegal; 2623 } 2624 break; 2625 2626 case SDEV_RUNNING: 2627 switch (oldstate) { 2628 case SDEV_CREATED: 2629 case SDEV_OFFLINE: 2630 case SDEV_TRANSPORT_OFFLINE: 2631 case SDEV_QUIESCE: 2632 case SDEV_BLOCK: 2633 break; 2634 default: 2635 goto illegal; 2636 } 2637 break; 2638 2639 case SDEV_QUIESCE: 2640 switch (oldstate) { 2641 case SDEV_RUNNING: 2642 case SDEV_OFFLINE: 2643 case SDEV_TRANSPORT_OFFLINE: 2644 break; 2645 default: 2646 goto illegal; 2647 } 2648 break; 2649 2650 case SDEV_OFFLINE: 2651 case SDEV_TRANSPORT_OFFLINE: 2652 switch (oldstate) { 2653 case SDEV_CREATED: 2654 case SDEV_RUNNING: 2655 case SDEV_QUIESCE: 2656 case SDEV_BLOCK: 2657 break; 2658 default: 2659 goto illegal; 2660 } 2661 break; 2662 2663 case SDEV_BLOCK: 2664 switch (oldstate) { 2665 case SDEV_RUNNING: 2666 case SDEV_CREATED_BLOCK: 2667 break; 2668 default: 2669 goto illegal; 2670 } 2671 break; 2672 2673 case SDEV_CREATED_BLOCK: 2674 switch (oldstate) { 2675 case SDEV_CREATED: 2676 break; 2677 default: 2678 goto illegal; 2679 } 2680 break; 2681 2682 case SDEV_CANCEL: 2683 switch (oldstate) { 2684 case SDEV_CREATED: 2685 case SDEV_RUNNING: 2686 case SDEV_QUIESCE: 2687 case SDEV_OFFLINE: 2688 case SDEV_TRANSPORT_OFFLINE: 2689 break; 2690 default: 2691 goto illegal; 2692 } 2693 break; 2694 2695 case SDEV_DEL: 2696 switch (oldstate) { 2697 case SDEV_CREATED: 2698 case SDEV_RUNNING: 2699 case SDEV_OFFLINE: 2700 case SDEV_TRANSPORT_OFFLINE: 2701 case SDEV_CANCEL: 2702 case SDEV_BLOCK: 2703 case SDEV_CREATED_BLOCK: 2704 break; 2705 default: 2706 goto illegal; 2707 } 2708 break; 2709 2710 } 2711 sdev->sdev_state = state; 2712 return 0; 2713 2714 illegal: 2715 SCSI_LOG_ERROR_RECOVERY(1, 2716 sdev_printk(KERN_ERR, sdev, 2717 "Illegal state transition %s->%s", 2718 scsi_device_state_name(oldstate), 2719 scsi_device_state_name(state)) 2720 ); 2721 return -EINVAL; 2722 } 2723 EXPORT_SYMBOL(scsi_device_set_state); 2724 2725 /** 2726 * sdev_evt_emit - emit a single SCSI device uevent 2727 * @sdev: associated SCSI device 2728 * @evt: event to emit 2729 * 2730 * Send a single uevent (scsi_event) to the associated scsi_device. 2731 */ 2732 static void scsi_evt_emit(struct scsi_device *sdev, struct scsi_event *evt) 2733 { 2734 int idx = 0; 2735 char *envp[3]; 2736 2737 switch (evt->evt_type) { 2738 case SDEV_EVT_MEDIA_CHANGE: 2739 envp[idx++] = "SDEV_MEDIA_CHANGE=1"; 2740 break; 2741 case SDEV_EVT_INQUIRY_CHANGE_REPORTED: 2742 scsi_rescan_device(&sdev->sdev_gendev); 2743 envp[idx++] = "SDEV_UA=INQUIRY_DATA_HAS_CHANGED"; 2744 break; 2745 case SDEV_EVT_CAPACITY_CHANGE_REPORTED: 2746 envp[idx++] = "SDEV_UA=CAPACITY_DATA_HAS_CHANGED"; 2747 break; 2748 case SDEV_EVT_SOFT_THRESHOLD_REACHED_REPORTED: 2749 envp[idx++] = "SDEV_UA=THIN_PROVISIONING_SOFT_THRESHOLD_REACHED"; 2750 break; 2751 case SDEV_EVT_MODE_PARAMETER_CHANGE_REPORTED: 2752 envp[idx++] = "SDEV_UA=MODE_PARAMETERS_CHANGED"; 2753 break; 2754 case SDEV_EVT_LUN_CHANGE_REPORTED: 2755 envp[idx++] = "SDEV_UA=REPORTED_LUNS_DATA_HAS_CHANGED"; 2756 break; 2757 case SDEV_EVT_ALUA_STATE_CHANGE_REPORTED: 2758 envp[idx++] = "SDEV_UA=ASYMMETRIC_ACCESS_STATE_CHANGED"; 2759 break; 2760 case SDEV_EVT_POWER_ON_RESET_OCCURRED: 2761 envp[idx++] = "SDEV_UA=POWER_ON_RESET_OCCURRED"; 2762 break; 2763 default: 2764 /* do nothing */ 2765 break; 2766 } 2767 2768 envp[idx++] = NULL; 2769 2770 kobject_uevent_env(&sdev->sdev_gendev.kobj, KOBJ_CHANGE, envp); 2771 } 2772 2773 /** 2774 * sdev_evt_thread - send a uevent for each scsi event 2775 * @work: work struct for scsi_device 2776 * 2777 * Dispatch queued events to their associated scsi_device kobjects 2778 * as uevents. 2779 */ 2780 void scsi_evt_thread(struct work_struct *work) 2781 { 2782 struct scsi_device *sdev; 2783 enum scsi_device_event evt_type; 2784 LIST_HEAD(event_list); 2785 2786 sdev = container_of(work, struct scsi_device, event_work); 2787 2788 for (evt_type = SDEV_EVT_FIRST; evt_type <= SDEV_EVT_LAST; evt_type++) 2789 if (test_and_clear_bit(evt_type, sdev->pending_events)) 2790 sdev_evt_send_simple(sdev, evt_type, GFP_KERNEL); 2791 2792 while (1) { 2793 struct scsi_event *evt; 2794 struct list_head *this, *tmp; 2795 unsigned long flags; 2796 2797 spin_lock_irqsave(&sdev->list_lock, flags); 2798 list_splice_init(&sdev->event_list, &event_list); 2799 spin_unlock_irqrestore(&sdev->list_lock, flags); 2800 2801 if (list_empty(&event_list)) 2802 break; 2803 2804 list_for_each_safe(this, tmp, &event_list) { 2805 evt = list_entry(this, struct scsi_event, node); 2806 list_del(&evt->node); 2807 scsi_evt_emit(sdev, evt); 2808 kfree(evt); 2809 } 2810 } 2811 } 2812 2813 /** 2814 * sdev_evt_send - send asserted event to uevent thread 2815 * @sdev: scsi_device event occurred on 2816 * @evt: event to send 2817 * 2818 * Assert scsi device event asynchronously. 2819 */ 2820 void sdev_evt_send(struct scsi_device *sdev, struct scsi_event *evt) 2821 { 2822 unsigned long flags; 2823 2824 #if 0 2825 /* FIXME: currently this check eliminates all media change events 2826 * for polled devices. Need to update to discriminate between AN 2827 * and polled events */ 2828 if (!test_bit(evt->evt_type, sdev->supported_events)) { 2829 kfree(evt); 2830 return; 2831 } 2832 #endif 2833 2834 spin_lock_irqsave(&sdev->list_lock, flags); 2835 list_add_tail(&evt->node, &sdev->event_list); 2836 schedule_work(&sdev->event_work); 2837 spin_unlock_irqrestore(&sdev->list_lock, flags); 2838 } 2839 EXPORT_SYMBOL_GPL(sdev_evt_send); 2840 2841 /** 2842 * sdev_evt_alloc - allocate a new scsi event 2843 * @evt_type: type of event to allocate 2844 * @gfpflags: GFP flags for allocation 2845 * 2846 * Allocates and returns a new scsi_event. 2847 */ 2848 struct scsi_event *sdev_evt_alloc(enum scsi_device_event evt_type, 2849 gfp_t gfpflags) 2850 { 2851 struct scsi_event *evt = kzalloc(sizeof(struct scsi_event), gfpflags); 2852 if (!evt) 2853 return NULL; 2854 2855 evt->evt_type = evt_type; 2856 INIT_LIST_HEAD(&evt->node); 2857 2858 /* evt_type-specific initialization, if any */ 2859 switch (evt_type) { 2860 case SDEV_EVT_MEDIA_CHANGE: 2861 case SDEV_EVT_INQUIRY_CHANGE_REPORTED: 2862 case SDEV_EVT_CAPACITY_CHANGE_REPORTED: 2863 case SDEV_EVT_SOFT_THRESHOLD_REACHED_REPORTED: 2864 case SDEV_EVT_MODE_PARAMETER_CHANGE_REPORTED: 2865 case SDEV_EVT_LUN_CHANGE_REPORTED: 2866 case SDEV_EVT_ALUA_STATE_CHANGE_REPORTED: 2867 case SDEV_EVT_POWER_ON_RESET_OCCURRED: 2868 default: 2869 /* do nothing */ 2870 break; 2871 } 2872 2873 return evt; 2874 } 2875 EXPORT_SYMBOL_GPL(sdev_evt_alloc); 2876 2877 /** 2878 * sdev_evt_send_simple - send asserted event to uevent thread 2879 * @sdev: scsi_device event occurred on 2880 * @evt_type: type of event to send 2881 * @gfpflags: GFP flags for allocation 2882 * 2883 * Assert scsi device event asynchronously, given an event type. 2884 */ 2885 void sdev_evt_send_simple(struct scsi_device *sdev, 2886 enum scsi_device_event evt_type, gfp_t gfpflags) 2887 { 2888 struct scsi_event *evt = sdev_evt_alloc(evt_type, gfpflags); 2889 if (!evt) { 2890 sdev_printk(KERN_ERR, sdev, "event %d eaten due to OOM\n", 2891 evt_type); 2892 return; 2893 } 2894 2895 sdev_evt_send(sdev, evt); 2896 } 2897 EXPORT_SYMBOL_GPL(sdev_evt_send_simple); 2898 2899 /** 2900 * scsi_request_fn_active() - number of kernel threads inside scsi_request_fn() 2901 * @sdev: SCSI device to count the number of scsi_request_fn() callers for. 2902 */ 2903 static int scsi_request_fn_active(struct scsi_device *sdev) 2904 { 2905 struct request_queue *q = sdev->request_queue; 2906 int request_fn_active; 2907 2908 WARN_ON_ONCE(sdev->host->use_blk_mq); 2909 2910 spin_lock_irq(q->queue_lock); 2911 request_fn_active = q->request_fn_active; 2912 spin_unlock_irq(q->queue_lock); 2913 2914 return request_fn_active; 2915 } 2916 2917 /** 2918 * scsi_wait_for_queuecommand() - wait for ongoing queuecommand() calls 2919 * @sdev: SCSI device pointer. 2920 * 2921 * Wait until the ongoing shost->hostt->queuecommand() calls that are 2922 * invoked from scsi_request_fn() have finished. 2923 */ 2924 static void scsi_wait_for_queuecommand(struct scsi_device *sdev) 2925 { 2926 WARN_ON_ONCE(sdev->host->use_blk_mq); 2927 2928 while (scsi_request_fn_active(sdev)) 2929 msleep(20); 2930 } 2931 2932 /** 2933 * scsi_device_quiesce - Block user issued commands. 2934 * @sdev: scsi device to quiesce. 2935 * 2936 * This works by trying to transition to the SDEV_QUIESCE state 2937 * (which must be a legal transition). When the device is in this 2938 * state, only special requests will be accepted, all others will 2939 * be deferred. Since special requests may also be requeued requests, 2940 * a successful return doesn't guarantee the device will be 2941 * totally quiescent. 2942 * 2943 * Must be called with user context, may sleep. 2944 * 2945 * Returns zero if unsuccessful or an error if not. 2946 */ 2947 int 2948 scsi_device_quiesce(struct scsi_device *sdev) 2949 { 2950 struct request_queue *q = sdev->request_queue; 2951 int err; 2952 2953 /* 2954 * It is allowed to call scsi_device_quiesce() multiple times from 2955 * the same context but concurrent scsi_device_quiesce() calls are 2956 * not allowed. 2957 */ 2958 WARN_ON_ONCE(sdev->quiesced_by && sdev->quiesced_by != current); 2959 2960 blk_set_preempt_only(q); 2961 2962 blk_mq_freeze_queue(q); 2963 /* 2964 * Ensure that the effect of blk_set_preempt_only() will be visible 2965 * for percpu_ref_tryget() callers that occur after the queue 2966 * unfreeze even if the queue was already frozen before this function 2967 * was called. See also https://lwn.net/Articles/573497/. 2968 */ 2969 synchronize_rcu(); 2970 blk_mq_unfreeze_queue(q); 2971 2972 mutex_lock(&sdev->state_mutex); 2973 err = scsi_device_set_state(sdev, SDEV_QUIESCE); 2974 if (err == 0) 2975 sdev->quiesced_by = current; 2976 else 2977 blk_clear_preempt_only(q); 2978 mutex_unlock(&sdev->state_mutex); 2979 2980 return err; 2981 } 2982 EXPORT_SYMBOL(scsi_device_quiesce); 2983 2984 /** 2985 * scsi_device_resume - Restart user issued commands to a quiesced device. 2986 * @sdev: scsi device to resume. 2987 * 2988 * Moves the device from quiesced back to running and restarts the 2989 * queues. 2990 * 2991 * Must be called with user context, may sleep. 2992 */ 2993 void scsi_device_resume(struct scsi_device *sdev) 2994 { 2995 /* check if the device state was mutated prior to resume, and if 2996 * so assume the state is being managed elsewhere (for example 2997 * device deleted during suspend) 2998 */ 2999 mutex_lock(&sdev->state_mutex); 3000 WARN_ON_ONCE(!sdev->quiesced_by); 3001 sdev->quiesced_by = NULL; 3002 blk_clear_preempt_only(sdev->request_queue); 3003 if (sdev->sdev_state == SDEV_QUIESCE) 3004 scsi_device_set_state(sdev, SDEV_RUNNING); 3005 mutex_unlock(&sdev->state_mutex); 3006 } 3007 EXPORT_SYMBOL(scsi_device_resume); 3008 3009 static void 3010 device_quiesce_fn(struct scsi_device *sdev, void *data) 3011 { 3012 scsi_device_quiesce(sdev); 3013 } 3014 3015 void 3016 scsi_target_quiesce(struct scsi_target *starget) 3017 { 3018 starget_for_each_device(starget, NULL, device_quiesce_fn); 3019 } 3020 EXPORT_SYMBOL(scsi_target_quiesce); 3021 3022 static void 3023 device_resume_fn(struct scsi_device *sdev, void *data) 3024 { 3025 scsi_device_resume(sdev); 3026 } 3027 3028 void 3029 scsi_target_resume(struct scsi_target *starget) 3030 { 3031 starget_for_each_device(starget, NULL, device_resume_fn); 3032 } 3033 EXPORT_SYMBOL(scsi_target_resume); 3034 3035 /** 3036 * scsi_internal_device_block_nowait - try to transition to the SDEV_BLOCK state 3037 * @sdev: device to block 3038 * 3039 * Pause SCSI command processing on the specified device. Does not sleep. 3040 * 3041 * Returns zero if successful or a negative error code upon failure. 3042 * 3043 * Notes: 3044 * This routine transitions the device to the SDEV_BLOCK state (which must be 3045 * a legal transition). When the device is in this state, command processing 3046 * is paused until the device leaves the SDEV_BLOCK state. See also 3047 * scsi_internal_device_unblock_nowait(). 3048 */ 3049 int scsi_internal_device_block_nowait(struct scsi_device *sdev) 3050 { 3051 struct request_queue *q = sdev->request_queue; 3052 unsigned long flags; 3053 int err = 0; 3054 3055 err = scsi_device_set_state(sdev, SDEV_BLOCK); 3056 if (err) { 3057 err = scsi_device_set_state(sdev, SDEV_CREATED_BLOCK); 3058 3059 if (err) 3060 return err; 3061 } 3062 3063 /* 3064 * The device has transitioned to SDEV_BLOCK. Stop the 3065 * block layer from calling the midlayer with this device's 3066 * request queue. 3067 */ 3068 if (q->mq_ops) { 3069 blk_mq_quiesce_queue_nowait(q); 3070 } else { 3071 spin_lock_irqsave(q->queue_lock, flags); 3072 blk_stop_queue(q); 3073 spin_unlock_irqrestore(q->queue_lock, flags); 3074 } 3075 3076 return 0; 3077 } 3078 EXPORT_SYMBOL_GPL(scsi_internal_device_block_nowait); 3079 3080 /** 3081 * scsi_internal_device_block - try to transition to the SDEV_BLOCK state 3082 * @sdev: device to block 3083 * 3084 * Pause SCSI command processing on the specified device and wait until all 3085 * ongoing scsi_request_fn() / scsi_queue_rq() calls have finished. May sleep. 3086 * 3087 * Returns zero if successful or a negative error code upon failure. 3088 * 3089 * Note: 3090 * This routine transitions the device to the SDEV_BLOCK state (which must be 3091 * a legal transition). When the device is in this state, command processing 3092 * is paused until the device leaves the SDEV_BLOCK state. See also 3093 * scsi_internal_device_unblock(). 3094 * 3095 * To do: avoid that scsi_send_eh_cmnd() calls queuecommand() after 3096 * scsi_internal_device_block() has blocked a SCSI device and also 3097 * remove the rport mutex lock and unlock calls from srp_queuecommand(). 3098 */ 3099 static int scsi_internal_device_block(struct scsi_device *sdev) 3100 { 3101 struct request_queue *q = sdev->request_queue; 3102 int err; 3103 3104 mutex_lock(&sdev->state_mutex); 3105 err = scsi_internal_device_block_nowait(sdev); 3106 if (err == 0) { 3107 if (q->mq_ops) 3108 blk_mq_quiesce_queue(q); 3109 else 3110 scsi_wait_for_queuecommand(sdev); 3111 } 3112 mutex_unlock(&sdev->state_mutex); 3113 3114 return err; 3115 } 3116 3117 void scsi_start_queue(struct scsi_device *sdev) 3118 { 3119 struct request_queue *q = sdev->request_queue; 3120 unsigned long flags; 3121 3122 if (q->mq_ops) { 3123 blk_mq_unquiesce_queue(q); 3124 } else { 3125 spin_lock_irqsave(q->queue_lock, flags); 3126 blk_start_queue(q); 3127 spin_unlock_irqrestore(q->queue_lock, flags); 3128 } 3129 } 3130 3131 /** 3132 * scsi_internal_device_unblock_nowait - resume a device after a block request 3133 * @sdev: device to resume 3134 * @new_state: state to set the device to after unblocking 3135 * 3136 * Restart the device queue for a previously suspended SCSI device. Does not 3137 * sleep. 3138 * 3139 * Returns zero if successful or a negative error code upon failure. 3140 * 3141 * Notes: 3142 * This routine transitions the device to the SDEV_RUNNING state or to one of 3143 * the offline states (which must be a legal transition) allowing the midlayer 3144 * to goose the queue for this device. 3145 */ 3146 int scsi_internal_device_unblock_nowait(struct scsi_device *sdev, 3147 enum scsi_device_state new_state) 3148 { 3149 /* 3150 * Try to transition the scsi device to SDEV_RUNNING or one of the 3151 * offlined states and goose the device queue if successful. 3152 */ 3153 switch (sdev->sdev_state) { 3154 case SDEV_BLOCK: 3155 case SDEV_TRANSPORT_OFFLINE: 3156 sdev->sdev_state = new_state; 3157 break; 3158 case SDEV_CREATED_BLOCK: 3159 if (new_state == SDEV_TRANSPORT_OFFLINE || 3160 new_state == SDEV_OFFLINE) 3161 sdev->sdev_state = new_state; 3162 else 3163 sdev->sdev_state = SDEV_CREATED; 3164 break; 3165 case SDEV_CANCEL: 3166 case SDEV_OFFLINE: 3167 break; 3168 default: 3169 return -EINVAL; 3170 } 3171 scsi_start_queue(sdev); 3172 3173 return 0; 3174 } 3175 EXPORT_SYMBOL_GPL(scsi_internal_device_unblock_nowait); 3176 3177 /** 3178 * scsi_internal_device_unblock - resume a device after a block request 3179 * @sdev: device to resume 3180 * @new_state: state to set the device to after unblocking 3181 * 3182 * Restart the device queue for a previously suspended SCSI device. May sleep. 3183 * 3184 * Returns zero if successful or a negative error code upon failure. 3185 * 3186 * Notes: 3187 * This routine transitions the device to the SDEV_RUNNING state or to one of 3188 * the offline states (which must be a legal transition) allowing the midlayer 3189 * to goose the queue for this device. 3190 */ 3191 static int scsi_internal_device_unblock(struct scsi_device *sdev, 3192 enum scsi_device_state new_state) 3193 { 3194 int ret; 3195 3196 mutex_lock(&sdev->state_mutex); 3197 ret = scsi_internal_device_unblock_nowait(sdev, new_state); 3198 mutex_unlock(&sdev->state_mutex); 3199 3200 return ret; 3201 } 3202 3203 static void 3204 device_block(struct scsi_device *sdev, void *data) 3205 { 3206 scsi_internal_device_block(sdev); 3207 } 3208 3209 static int 3210 target_block(struct device *dev, void *data) 3211 { 3212 if (scsi_is_target_device(dev)) 3213 starget_for_each_device(to_scsi_target(dev), NULL, 3214 device_block); 3215 return 0; 3216 } 3217 3218 void 3219 scsi_target_block(struct device *dev) 3220 { 3221 if (scsi_is_target_device(dev)) 3222 starget_for_each_device(to_scsi_target(dev), NULL, 3223 device_block); 3224 else 3225 device_for_each_child(dev, NULL, target_block); 3226 } 3227 EXPORT_SYMBOL_GPL(scsi_target_block); 3228 3229 static void 3230 device_unblock(struct scsi_device *sdev, void *data) 3231 { 3232 scsi_internal_device_unblock(sdev, *(enum scsi_device_state *)data); 3233 } 3234 3235 static int 3236 target_unblock(struct device *dev, void *data) 3237 { 3238 if (scsi_is_target_device(dev)) 3239 starget_for_each_device(to_scsi_target(dev), data, 3240 device_unblock); 3241 return 0; 3242 } 3243 3244 void 3245 scsi_target_unblock(struct device *dev, enum scsi_device_state new_state) 3246 { 3247 if (scsi_is_target_device(dev)) 3248 starget_for_each_device(to_scsi_target(dev), &new_state, 3249 device_unblock); 3250 else 3251 device_for_each_child(dev, &new_state, target_unblock); 3252 } 3253 EXPORT_SYMBOL_GPL(scsi_target_unblock); 3254 3255 /** 3256 * scsi_kmap_atomic_sg - find and atomically map an sg-elemnt 3257 * @sgl: scatter-gather list 3258 * @sg_count: number of segments in sg 3259 * @offset: offset in bytes into sg, on return offset into the mapped area 3260 * @len: bytes to map, on return number of bytes mapped 3261 * 3262 * Returns virtual address of the start of the mapped page 3263 */ 3264 void *scsi_kmap_atomic_sg(struct scatterlist *sgl, int sg_count, 3265 size_t *offset, size_t *len) 3266 { 3267 int i; 3268 size_t sg_len = 0, len_complete = 0; 3269 struct scatterlist *sg; 3270 struct page *page; 3271 3272 WARN_ON(!irqs_disabled()); 3273 3274 for_each_sg(sgl, sg, sg_count, i) { 3275 len_complete = sg_len; /* Complete sg-entries */ 3276 sg_len += sg->length; 3277 if (sg_len > *offset) 3278 break; 3279 } 3280 3281 if (unlikely(i == sg_count)) { 3282 printk(KERN_ERR "%s: Bytes in sg: %zu, requested offset %zu, " 3283 "elements %d\n", 3284 __func__, sg_len, *offset, sg_count); 3285 WARN_ON(1); 3286 return NULL; 3287 } 3288 3289 /* Offset starting from the beginning of first page in this sg-entry */ 3290 *offset = *offset - len_complete + sg->offset; 3291 3292 /* Assumption: contiguous pages can be accessed as "page + i" */ 3293 page = nth_page(sg_page(sg), (*offset >> PAGE_SHIFT)); 3294 *offset &= ~PAGE_MASK; 3295 3296 /* Bytes in this sg-entry from *offset to the end of the page */ 3297 sg_len = PAGE_SIZE - *offset; 3298 if (*len > sg_len) 3299 *len = sg_len; 3300 3301 return kmap_atomic(page); 3302 } 3303 EXPORT_SYMBOL(scsi_kmap_atomic_sg); 3304 3305 /** 3306 * scsi_kunmap_atomic_sg - atomically unmap a virtual address, previously mapped with scsi_kmap_atomic_sg 3307 * @virt: virtual address to be unmapped 3308 */ 3309 void scsi_kunmap_atomic_sg(void *virt) 3310 { 3311 kunmap_atomic(virt); 3312 } 3313 EXPORT_SYMBOL(scsi_kunmap_atomic_sg); 3314 3315 void sdev_disable_disk_events(struct scsi_device *sdev) 3316 { 3317 atomic_inc(&sdev->disk_events_disable_depth); 3318 } 3319 EXPORT_SYMBOL(sdev_disable_disk_events); 3320 3321 void sdev_enable_disk_events(struct scsi_device *sdev) 3322 { 3323 if (WARN_ON_ONCE(atomic_read(&sdev->disk_events_disable_depth) <= 0)) 3324 return; 3325 atomic_dec(&sdev->disk_events_disable_depth); 3326 } 3327 EXPORT_SYMBOL(sdev_enable_disk_events); 3328 3329 /** 3330 * scsi_vpd_lun_id - return a unique device identification 3331 * @sdev: SCSI device 3332 * @id: buffer for the identification 3333 * @id_len: length of the buffer 3334 * 3335 * Copies a unique device identification into @id based 3336 * on the information in the VPD page 0x83 of the device. 3337 * The string will be formatted as a SCSI name string. 3338 * 3339 * Returns the length of the identification or error on failure. 3340 * If the identifier is longer than the supplied buffer the actual 3341 * identifier length is returned and the buffer is not zero-padded. 3342 */ 3343 int scsi_vpd_lun_id(struct scsi_device *sdev, char *id, size_t id_len) 3344 { 3345 u8 cur_id_type = 0xff; 3346 u8 cur_id_size = 0; 3347 const unsigned char *d, *cur_id_str; 3348 const struct scsi_vpd *vpd_pg83; 3349 int id_size = -EINVAL; 3350 3351 rcu_read_lock(); 3352 vpd_pg83 = rcu_dereference(sdev->vpd_pg83); 3353 if (!vpd_pg83) { 3354 rcu_read_unlock(); 3355 return -ENXIO; 3356 } 3357 3358 /* 3359 * Look for the correct descriptor. 3360 * Order of preference for lun descriptor: 3361 * - SCSI name string 3362 * - NAA IEEE Registered Extended 3363 * - EUI-64 based 16-byte 3364 * - EUI-64 based 12-byte 3365 * - NAA IEEE Registered 3366 * - NAA IEEE Extended 3367 * - T10 Vendor ID 3368 * as longer descriptors reduce the likelyhood 3369 * of identification clashes. 3370 */ 3371 3372 /* The id string must be at least 20 bytes + terminating NULL byte */ 3373 if (id_len < 21) { 3374 rcu_read_unlock(); 3375 return -EINVAL; 3376 } 3377 3378 memset(id, 0, id_len); 3379 d = vpd_pg83->data + 4; 3380 while (d < vpd_pg83->data + vpd_pg83->len) { 3381 /* Skip designators not referring to the LUN */ 3382 if ((d[1] & 0x30) != 0x00) 3383 goto next_desig; 3384 3385 switch (d[1] & 0xf) { 3386 case 0x1: 3387 /* T10 Vendor ID */ 3388 if (cur_id_size > d[3]) 3389 break; 3390 /* Prefer anything */ 3391 if (cur_id_type > 0x01 && cur_id_type != 0xff) 3392 break; 3393 cur_id_size = d[3]; 3394 if (cur_id_size + 4 > id_len) 3395 cur_id_size = id_len - 4; 3396 cur_id_str = d + 4; 3397 cur_id_type = d[1] & 0xf; 3398 id_size = snprintf(id, id_len, "t10.%*pE", 3399 cur_id_size, cur_id_str); 3400 break; 3401 case 0x2: 3402 /* EUI-64 */ 3403 if (cur_id_size > d[3]) 3404 break; 3405 /* Prefer NAA IEEE Registered Extended */ 3406 if (cur_id_type == 0x3 && 3407 cur_id_size == d[3]) 3408 break; 3409 cur_id_size = d[3]; 3410 cur_id_str = d + 4; 3411 cur_id_type = d[1] & 0xf; 3412 switch (cur_id_size) { 3413 case 8: 3414 id_size = snprintf(id, id_len, 3415 "eui.%8phN", 3416 cur_id_str); 3417 break; 3418 case 12: 3419 id_size = snprintf(id, id_len, 3420 "eui.%12phN", 3421 cur_id_str); 3422 break; 3423 case 16: 3424 id_size = snprintf(id, id_len, 3425 "eui.%16phN", 3426 cur_id_str); 3427 break; 3428 default: 3429 cur_id_size = 0; 3430 break; 3431 } 3432 break; 3433 case 0x3: 3434 /* NAA */ 3435 if (cur_id_size > d[3]) 3436 break; 3437 cur_id_size = d[3]; 3438 cur_id_str = d + 4; 3439 cur_id_type = d[1] & 0xf; 3440 switch (cur_id_size) { 3441 case 8: 3442 id_size = snprintf(id, id_len, 3443 "naa.%8phN", 3444 cur_id_str); 3445 break; 3446 case 16: 3447 id_size = snprintf(id, id_len, 3448 "naa.%16phN", 3449 cur_id_str); 3450 break; 3451 default: 3452 cur_id_size = 0; 3453 break; 3454 } 3455 break; 3456 case 0x8: 3457 /* SCSI name string */ 3458 if (cur_id_size + 4 > d[3]) 3459 break; 3460 /* Prefer others for truncated descriptor */ 3461 if (cur_id_size && d[3] > id_len) 3462 break; 3463 cur_id_size = id_size = d[3]; 3464 cur_id_str = d + 4; 3465 cur_id_type = d[1] & 0xf; 3466 if (cur_id_size >= id_len) 3467 cur_id_size = id_len - 1; 3468 memcpy(id, cur_id_str, cur_id_size); 3469 /* Decrease priority for truncated descriptor */ 3470 if (cur_id_size != id_size) 3471 cur_id_size = 6; 3472 break; 3473 default: 3474 break; 3475 } 3476 next_desig: 3477 d += d[3] + 4; 3478 } 3479 rcu_read_unlock(); 3480 3481 return id_size; 3482 } 3483 EXPORT_SYMBOL(scsi_vpd_lun_id); 3484 3485 /* 3486 * scsi_vpd_tpg_id - return a target port group identifier 3487 * @sdev: SCSI device 3488 * 3489 * Returns the Target Port Group identifier from the information 3490 * froom VPD page 0x83 of the device. 3491 * 3492 * Returns the identifier or error on failure. 3493 */ 3494 int scsi_vpd_tpg_id(struct scsi_device *sdev, int *rel_id) 3495 { 3496 const unsigned char *d; 3497 const struct scsi_vpd *vpd_pg83; 3498 int group_id = -EAGAIN, rel_port = -1; 3499 3500 rcu_read_lock(); 3501 vpd_pg83 = rcu_dereference(sdev->vpd_pg83); 3502 if (!vpd_pg83) { 3503 rcu_read_unlock(); 3504 return -ENXIO; 3505 } 3506 3507 d = vpd_pg83->data + 4; 3508 while (d < vpd_pg83->data + vpd_pg83->len) { 3509 switch (d[1] & 0xf) { 3510 case 0x4: 3511 /* Relative target port */ 3512 rel_port = get_unaligned_be16(&d[6]); 3513 break; 3514 case 0x5: 3515 /* Target port group */ 3516 group_id = get_unaligned_be16(&d[6]); 3517 break; 3518 default: 3519 break; 3520 } 3521 d += d[3] + 4; 3522 } 3523 rcu_read_unlock(); 3524 3525 if (group_id >= 0 && rel_id && rel_port != -1) 3526 *rel_id = rel_port; 3527 3528 return group_id; 3529 } 3530 EXPORT_SYMBOL(scsi_vpd_tpg_id); 3531