1 /* 2 * scsi_scan.c 3 * 4 * Copyright (C) 2000 Eric Youngdale, 5 * Copyright (C) 2002 Patrick Mansfield 6 * 7 * The general scanning/probing algorithm is as follows, exceptions are 8 * made to it depending on device specific flags, compilation options, and 9 * global variable (boot or module load time) settings. 10 * 11 * A specific LUN is scanned via an INQUIRY command; if the LUN has a 12 * device attached, a scsi_device is allocated and setup for it. 13 * 14 * For every id of every channel on the given host: 15 * 16 * Scan LUN 0; if the target responds to LUN 0 (even if there is no 17 * device or storage attached to LUN 0): 18 * 19 * If LUN 0 has a device attached, allocate and setup a 20 * scsi_device for it. 21 * 22 * If target is SCSI-3 or up, issue a REPORT LUN, and scan 23 * all of the LUNs returned by the REPORT LUN; else, 24 * sequentially scan LUNs up until some maximum is reached, 25 * or a LUN is seen that cannot have a device attached to it. 26 */ 27 28 #include <linux/module.h> 29 #include <linux/moduleparam.h> 30 #include <linux/init.h> 31 #include <linux/blkdev.h> 32 #include <linux/delay.h> 33 #include <linux/kthread.h> 34 #include <linux/spinlock.h> 35 #include <linux/async.h> 36 #include <linux/slab.h> 37 38 #include <scsi/scsi.h> 39 #include <scsi/scsi_cmnd.h> 40 #include <scsi/scsi_device.h> 41 #include <scsi/scsi_driver.h> 42 #include <scsi/scsi_devinfo.h> 43 #include <scsi/scsi_host.h> 44 #include <scsi/scsi_transport.h> 45 #include <scsi/scsi_eh.h> 46 47 #include "scsi_priv.h" 48 #include "scsi_logging.h" 49 50 #define ALLOC_FAILURE_MSG KERN_ERR "%s: Allocation failure during" \ 51 " SCSI scanning, some SCSI devices might not be configured\n" 52 53 /* 54 * Default timeout 55 */ 56 #define SCSI_TIMEOUT (2*HZ) 57 58 /* 59 * Prefix values for the SCSI id's (stored in sysfs name field) 60 */ 61 #define SCSI_UID_SER_NUM 'S' 62 #define SCSI_UID_UNKNOWN 'Z' 63 64 /* 65 * Return values of some of the scanning functions. 66 * 67 * SCSI_SCAN_NO_RESPONSE: no valid response received from the target, this 68 * includes allocation or general failures preventing IO from being sent. 69 * 70 * SCSI_SCAN_TARGET_PRESENT: target responded, but no device is available 71 * on the given LUN. 72 * 73 * SCSI_SCAN_LUN_PRESENT: target responded, and a device is available on a 74 * given LUN. 75 */ 76 #define SCSI_SCAN_NO_RESPONSE 0 77 #define SCSI_SCAN_TARGET_PRESENT 1 78 #define SCSI_SCAN_LUN_PRESENT 2 79 80 static const char *scsi_null_device_strs = "nullnullnullnull"; 81 82 #define MAX_SCSI_LUNS 512 83 84 static u64 max_scsi_luns = MAX_SCSI_LUNS; 85 86 module_param_named(max_luns, max_scsi_luns, ullong, S_IRUGO|S_IWUSR); 87 MODULE_PARM_DESC(max_luns, 88 "last scsi LUN (should be between 1 and 2^64-1)"); 89 90 #ifdef CONFIG_SCSI_SCAN_ASYNC 91 #define SCSI_SCAN_TYPE_DEFAULT "async" 92 #else 93 #define SCSI_SCAN_TYPE_DEFAULT "sync" 94 #endif 95 96 char scsi_scan_type[6] = SCSI_SCAN_TYPE_DEFAULT; 97 98 module_param_string(scan, scsi_scan_type, sizeof(scsi_scan_type), S_IRUGO); 99 MODULE_PARM_DESC(scan, "sync, async or none"); 100 101 /* 102 * max_scsi_report_luns: the maximum number of LUNS that will be 103 * returned from the REPORT LUNS command. 8 times this value must 104 * be allocated. In theory this could be up to an 8 byte value, but 105 * in practice, the maximum number of LUNs suppored by any device 106 * is about 16k. 107 */ 108 static unsigned int max_scsi_report_luns = 511; 109 110 module_param_named(max_report_luns, max_scsi_report_luns, uint, S_IRUGO|S_IWUSR); 111 MODULE_PARM_DESC(max_report_luns, 112 "REPORT LUNS maximum number of LUNS received (should be" 113 " between 1 and 16384)"); 114 115 static unsigned int scsi_inq_timeout = SCSI_TIMEOUT/HZ + 18; 116 117 module_param_named(inq_timeout, scsi_inq_timeout, uint, S_IRUGO|S_IWUSR); 118 MODULE_PARM_DESC(inq_timeout, 119 "Timeout (in seconds) waiting for devices to answer INQUIRY." 120 " Default is 20. Some devices may need more; most need less."); 121 122 /* This lock protects only this list */ 123 static DEFINE_SPINLOCK(async_scan_lock); 124 static LIST_HEAD(scanning_hosts); 125 126 struct async_scan_data { 127 struct list_head list; 128 struct Scsi_Host *shost; 129 struct completion prev_finished; 130 }; 131 132 /** 133 * scsi_complete_async_scans - Wait for asynchronous scans to complete 134 * 135 * When this function returns, any host which started scanning before 136 * this function was called will have finished its scan. Hosts which 137 * started scanning after this function was called may or may not have 138 * finished. 139 */ 140 int scsi_complete_async_scans(void) 141 { 142 struct async_scan_data *data; 143 144 do { 145 if (list_empty(&scanning_hosts)) 146 return 0; 147 /* If we can't get memory immediately, that's OK. Just 148 * sleep a little. Even if we never get memory, the async 149 * scans will finish eventually. 150 */ 151 data = kmalloc(sizeof(*data), GFP_KERNEL); 152 if (!data) 153 msleep(1); 154 } while (!data); 155 156 data->shost = NULL; 157 init_completion(&data->prev_finished); 158 159 spin_lock(&async_scan_lock); 160 /* Check that there's still somebody else on the list */ 161 if (list_empty(&scanning_hosts)) 162 goto done; 163 list_add_tail(&data->list, &scanning_hosts); 164 spin_unlock(&async_scan_lock); 165 166 printk(KERN_INFO "scsi: waiting for bus probes to complete ...\n"); 167 wait_for_completion(&data->prev_finished); 168 169 spin_lock(&async_scan_lock); 170 list_del(&data->list); 171 if (!list_empty(&scanning_hosts)) { 172 struct async_scan_data *next = list_entry(scanning_hosts.next, 173 struct async_scan_data, list); 174 complete(&next->prev_finished); 175 } 176 done: 177 spin_unlock(&async_scan_lock); 178 179 kfree(data); 180 return 0; 181 } 182 183 /** 184 * scsi_unlock_floptical - unlock device via a special MODE SENSE command 185 * @sdev: scsi device to send command to 186 * @result: area to store the result of the MODE SENSE 187 * 188 * Description: 189 * Send a vendor specific MODE SENSE (not a MODE SELECT) command. 190 * Called for BLIST_KEY devices. 191 **/ 192 static void scsi_unlock_floptical(struct scsi_device *sdev, 193 unsigned char *result) 194 { 195 unsigned char scsi_cmd[MAX_COMMAND_SIZE]; 196 197 sdev_printk(KERN_NOTICE, sdev, "unlocking floptical drive\n"); 198 scsi_cmd[0] = MODE_SENSE; 199 scsi_cmd[1] = 0; 200 scsi_cmd[2] = 0x2e; 201 scsi_cmd[3] = 0; 202 scsi_cmd[4] = 0x2a; /* size */ 203 scsi_cmd[5] = 0; 204 scsi_execute_req(sdev, scsi_cmd, DMA_FROM_DEVICE, result, 0x2a, NULL, 205 SCSI_TIMEOUT, 3, NULL); 206 } 207 208 /** 209 * scsi_alloc_sdev - allocate and setup a scsi_Device 210 * @starget: which target to allocate a &scsi_device for 211 * @lun: which lun 212 * @hostdata: usually NULL and set by ->slave_alloc instead 213 * 214 * Description: 215 * Allocate, initialize for io, and return a pointer to a scsi_Device. 216 * Stores the @shost, @channel, @id, and @lun in the scsi_Device, and 217 * adds scsi_Device to the appropriate list. 218 * 219 * Return value: 220 * scsi_Device pointer, or NULL on failure. 221 **/ 222 static struct scsi_device *scsi_alloc_sdev(struct scsi_target *starget, 223 u64 lun, void *hostdata) 224 { 225 struct scsi_device *sdev; 226 int display_failure_msg = 1, ret; 227 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); 228 extern void scsi_evt_thread(struct work_struct *work); 229 extern void scsi_requeue_run_queue(struct work_struct *work); 230 231 sdev = kzalloc(sizeof(*sdev) + shost->transportt->device_size, 232 GFP_ATOMIC); 233 if (!sdev) 234 goto out; 235 236 sdev->vendor = scsi_null_device_strs; 237 sdev->model = scsi_null_device_strs; 238 sdev->rev = scsi_null_device_strs; 239 sdev->host = shost; 240 sdev->queue_ramp_up_period = SCSI_DEFAULT_RAMP_UP_PERIOD; 241 sdev->id = starget->id; 242 sdev->lun = lun; 243 sdev->channel = starget->channel; 244 sdev->sdev_state = SDEV_CREATED; 245 INIT_LIST_HEAD(&sdev->siblings); 246 INIT_LIST_HEAD(&sdev->same_target_siblings); 247 INIT_LIST_HEAD(&sdev->cmd_list); 248 INIT_LIST_HEAD(&sdev->starved_entry); 249 INIT_LIST_HEAD(&sdev->event_list); 250 spin_lock_init(&sdev->list_lock); 251 INIT_WORK(&sdev->event_work, scsi_evt_thread); 252 INIT_WORK(&sdev->requeue_work, scsi_requeue_run_queue); 253 254 sdev->sdev_gendev.parent = get_device(&starget->dev); 255 sdev->sdev_target = starget; 256 257 /* usually NULL and set by ->slave_alloc instead */ 258 sdev->hostdata = hostdata; 259 260 /* if the device needs this changing, it may do so in the 261 * slave_configure function */ 262 sdev->max_device_blocked = SCSI_DEFAULT_DEVICE_BLOCKED; 263 264 /* 265 * Some low level driver could use device->type 266 */ 267 sdev->type = -1; 268 269 /* 270 * Assume that the device will have handshaking problems, 271 * and then fix this field later if it turns out it 272 * doesn't 273 */ 274 sdev->borken = 1; 275 276 if (shost_use_blk_mq(shost)) 277 sdev->request_queue = scsi_mq_alloc_queue(sdev); 278 else 279 sdev->request_queue = scsi_alloc_queue(sdev); 280 if (!sdev->request_queue) { 281 /* release fn is set up in scsi_sysfs_device_initialise, so 282 * have to free and put manually here */ 283 put_device(&starget->dev); 284 kfree(sdev); 285 goto out; 286 } 287 WARN_ON_ONCE(!blk_get_queue(sdev->request_queue)); 288 sdev->request_queue->queuedata = sdev; 289 scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun); 290 291 scsi_sysfs_device_initialize(sdev); 292 293 if (shost->hostt->slave_alloc) { 294 ret = shost->hostt->slave_alloc(sdev); 295 if (ret) { 296 /* 297 * if LLDD reports slave not present, don't clutter 298 * console with alloc failure messages 299 */ 300 if (ret == -ENXIO) 301 display_failure_msg = 0; 302 goto out_device_destroy; 303 } 304 } 305 306 return sdev; 307 308 out_device_destroy: 309 __scsi_remove_device(sdev); 310 out: 311 if (display_failure_msg) 312 printk(ALLOC_FAILURE_MSG, __func__); 313 return NULL; 314 } 315 316 static void scsi_target_destroy(struct scsi_target *starget) 317 { 318 struct device *dev = &starget->dev; 319 struct Scsi_Host *shost = dev_to_shost(dev->parent); 320 unsigned long flags; 321 322 starget->state = STARGET_DEL; 323 transport_destroy_device(dev); 324 spin_lock_irqsave(shost->host_lock, flags); 325 if (shost->hostt->target_destroy) 326 shost->hostt->target_destroy(starget); 327 list_del_init(&starget->siblings); 328 spin_unlock_irqrestore(shost->host_lock, flags); 329 put_device(dev); 330 } 331 332 static void scsi_target_dev_release(struct device *dev) 333 { 334 struct device *parent = dev->parent; 335 struct scsi_target *starget = to_scsi_target(dev); 336 337 kfree(starget); 338 put_device(parent); 339 } 340 341 static struct device_type scsi_target_type = { 342 .name = "scsi_target", 343 .release = scsi_target_dev_release, 344 }; 345 346 int scsi_is_target_device(const struct device *dev) 347 { 348 return dev->type == &scsi_target_type; 349 } 350 EXPORT_SYMBOL(scsi_is_target_device); 351 352 static struct scsi_target *__scsi_find_target(struct device *parent, 353 int channel, uint id) 354 { 355 struct scsi_target *starget, *found_starget = NULL; 356 struct Scsi_Host *shost = dev_to_shost(parent); 357 /* 358 * Search for an existing target for this sdev. 359 */ 360 list_for_each_entry(starget, &shost->__targets, siblings) { 361 if (starget->id == id && 362 starget->channel == channel) { 363 found_starget = starget; 364 break; 365 } 366 } 367 if (found_starget) 368 get_device(&found_starget->dev); 369 370 return found_starget; 371 } 372 373 /** 374 * scsi_target_reap_ref_release - remove target from visibility 375 * @kref: the reap_ref in the target being released 376 * 377 * Called on last put of reap_ref, which is the indication that no device 378 * under this target is visible anymore, so render the target invisible in 379 * sysfs. Note: we have to be in user context here because the target reaps 380 * should be done in places where the scsi device visibility is being removed. 381 */ 382 static void scsi_target_reap_ref_release(struct kref *kref) 383 { 384 struct scsi_target *starget 385 = container_of(kref, struct scsi_target, reap_ref); 386 387 /* 388 * if we get here and the target is still in the CREATED state that 389 * means it was allocated but never made visible (because a scan 390 * turned up no LUNs), so don't call device_del() on it. 391 */ 392 if (starget->state != STARGET_CREATED) { 393 transport_remove_device(&starget->dev); 394 device_del(&starget->dev); 395 } 396 scsi_target_destroy(starget); 397 } 398 399 static void scsi_target_reap_ref_put(struct scsi_target *starget) 400 { 401 kref_put(&starget->reap_ref, scsi_target_reap_ref_release); 402 } 403 404 /** 405 * scsi_alloc_target - allocate a new or find an existing target 406 * @parent: parent of the target (need not be a scsi host) 407 * @channel: target channel number (zero if no channels) 408 * @id: target id number 409 * 410 * Return an existing target if one exists, provided it hasn't already 411 * gone into STARGET_DEL state, otherwise allocate a new target. 412 * 413 * The target is returned with an incremented reference, so the caller 414 * is responsible for both reaping and doing a last put 415 */ 416 static struct scsi_target *scsi_alloc_target(struct device *parent, 417 int channel, uint id) 418 { 419 struct Scsi_Host *shost = dev_to_shost(parent); 420 struct device *dev = NULL; 421 unsigned long flags; 422 const int size = sizeof(struct scsi_target) 423 + shost->transportt->target_size; 424 struct scsi_target *starget; 425 struct scsi_target *found_target; 426 int error, ref_got; 427 428 starget = kzalloc(size, GFP_KERNEL); 429 if (!starget) { 430 printk(KERN_ERR "%s: allocation failure\n", __func__); 431 return NULL; 432 } 433 dev = &starget->dev; 434 device_initialize(dev); 435 kref_init(&starget->reap_ref); 436 dev->parent = get_device(parent); 437 dev_set_name(dev, "target%d:%d:%d", shost->host_no, channel, id); 438 dev->bus = &scsi_bus_type; 439 dev->type = &scsi_target_type; 440 starget->id = id; 441 starget->channel = channel; 442 starget->can_queue = 0; 443 INIT_LIST_HEAD(&starget->siblings); 444 INIT_LIST_HEAD(&starget->devices); 445 starget->state = STARGET_CREATED; 446 starget->scsi_level = SCSI_2; 447 starget->max_target_blocked = SCSI_DEFAULT_TARGET_BLOCKED; 448 retry: 449 spin_lock_irqsave(shost->host_lock, flags); 450 451 found_target = __scsi_find_target(parent, channel, id); 452 if (found_target) 453 goto found; 454 455 list_add_tail(&starget->siblings, &shost->__targets); 456 spin_unlock_irqrestore(shost->host_lock, flags); 457 /* allocate and add */ 458 transport_setup_device(dev); 459 if (shost->hostt->target_alloc) { 460 error = shost->hostt->target_alloc(starget); 461 462 if(error) { 463 dev_printk(KERN_ERR, dev, "target allocation failed, error %d\n", error); 464 /* don't want scsi_target_reap to do the final 465 * put because it will be under the host lock */ 466 scsi_target_destroy(starget); 467 return NULL; 468 } 469 } 470 get_device(dev); 471 472 return starget; 473 474 found: 475 /* 476 * release routine already fired if kref is zero, so if we can still 477 * take the reference, the target must be alive. If we can't, it must 478 * be dying and we need to wait for a new target 479 */ 480 ref_got = kref_get_unless_zero(&found_target->reap_ref); 481 482 spin_unlock_irqrestore(shost->host_lock, flags); 483 if (ref_got) { 484 put_device(dev); 485 return found_target; 486 } 487 /* 488 * Unfortunately, we found a dying target; need to wait until it's 489 * dead before we can get a new one. There is an anomaly here. We 490 * *should* call scsi_target_reap() to balance the kref_get() of the 491 * reap_ref above. However, since the target being released, it's 492 * already invisible and the reap_ref is irrelevant. If we call 493 * scsi_target_reap() we might spuriously do another device_del() on 494 * an already invisible target. 495 */ 496 put_device(&found_target->dev); 497 /* 498 * length of time is irrelevant here, we just want to yield the CPU 499 * for a tick to avoid busy waiting for the target to die. 500 */ 501 msleep(1); 502 goto retry; 503 } 504 505 /** 506 * scsi_target_reap - check to see if target is in use and destroy if not 507 * @starget: target to be checked 508 * 509 * This is used after removing a LUN or doing a last put of the target 510 * it checks atomically that nothing is using the target and removes 511 * it if so. 512 */ 513 void scsi_target_reap(struct scsi_target *starget) 514 { 515 /* 516 * serious problem if this triggers: STARGET_DEL is only set in the if 517 * the reap_ref drops to zero, so we're trying to do another final put 518 * on an already released kref 519 */ 520 BUG_ON(starget->state == STARGET_DEL); 521 scsi_target_reap_ref_put(starget); 522 } 523 524 /** 525 * sanitize_inquiry_string - remove non-graphical chars from an INQUIRY result string 526 * @s: INQUIRY result string to sanitize 527 * @len: length of the string 528 * 529 * Description: 530 * The SCSI spec says that INQUIRY vendor, product, and revision 531 * strings must consist entirely of graphic ASCII characters, 532 * padded on the right with spaces. Since not all devices obey 533 * this rule, we will replace non-graphic or non-ASCII characters 534 * with spaces. Exception: a NUL character is interpreted as a 535 * string terminator, so all the following characters are set to 536 * spaces. 537 **/ 538 static void sanitize_inquiry_string(unsigned char *s, int len) 539 { 540 int terminated = 0; 541 542 for (; len > 0; (--len, ++s)) { 543 if (*s == 0) 544 terminated = 1; 545 if (terminated || *s < 0x20 || *s > 0x7e) 546 *s = ' '; 547 } 548 } 549 550 /** 551 * scsi_probe_lun - probe a single LUN using a SCSI INQUIRY 552 * @sdev: scsi_device to probe 553 * @inq_result: area to store the INQUIRY result 554 * @result_len: len of inq_result 555 * @bflags: store any bflags found here 556 * 557 * Description: 558 * Probe the lun associated with @req using a standard SCSI INQUIRY; 559 * 560 * If the INQUIRY is successful, zero is returned and the 561 * INQUIRY data is in @inq_result; the scsi_level and INQUIRY length 562 * are copied to the scsi_device any flags value is stored in *@bflags. 563 **/ 564 static int scsi_probe_lun(struct scsi_device *sdev, unsigned char *inq_result, 565 int result_len, int *bflags) 566 { 567 unsigned char scsi_cmd[MAX_COMMAND_SIZE]; 568 int first_inquiry_len, try_inquiry_len, next_inquiry_len; 569 int response_len = 0; 570 int pass, count, result; 571 struct scsi_sense_hdr sshdr; 572 573 *bflags = 0; 574 575 /* Perform up to 3 passes. The first pass uses a conservative 576 * transfer length of 36 unless sdev->inquiry_len specifies a 577 * different value. */ 578 first_inquiry_len = sdev->inquiry_len ? sdev->inquiry_len : 36; 579 try_inquiry_len = first_inquiry_len; 580 pass = 1; 581 582 next_pass: 583 SCSI_LOG_SCAN_BUS(3, sdev_printk(KERN_INFO, sdev, 584 "scsi scan: INQUIRY pass %d length %d\n", 585 pass, try_inquiry_len)); 586 587 /* Each pass gets up to three chances to ignore Unit Attention */ 588 for (count = 0; count < 3; ++count) { 589 int resid; 590 591 memset(scsi_cmd, 0, 6); 592 scsi_cmd[0] = INQUIRY; 593 scsi_cmd[4] = (unsigned char) try_inquiry_len; 594 595 memset(inq_result, 0, try_inquiry_len); 596 597 result = scsi_execute_req(sdev, scsi_cmd, DMA_FROM_DEVICE, 598 inq_result, try_inquiry_len, &sshdr, 599 HZ / 2 + HZ * scsi_inq_timeout, 3, 600 &resid); 601 602 SCSI_LOG_SCAN_BUS(3, sdev_printk(KERN_INFO, sdev, 603 "scsi scan: INQUIRY %s with code 0x%x\n", 604 result ? "failed" : "successful", result)); 605 606 if (result) { 607 /* 608 * not-ready to ready transition [asc/ascq=0x28/0x0] 609 * or power-on, reset [asc/ascq=0x29/0x0], continue. 610 * INQUIRY should not yield UNIT_ATTENTION 611 * but many buggy devices do so anyway. 612 */ 613 if ((driver_byte(result) & DRIVER_SENSE) && 614 scsi_sense_valid(&sshdr)) { 615 if ((sshdr.sense_key == UNIT_ATTENTION) && 616 ((sshdr.asc == 0x28) || 617 (sshdr.asc == 0x29)) && 618 (sshdr.ascq == 0)) 619 continue; 620 } 621 } else { 622 /* 623 * if nothing was transferred, we try 624 * again. It's a workaround for some USB 625 * devices. 626 */ 627 if (resid == try_inquiry_len) 628 continue; 629 } 630 break; 631 } 632 633 if (result == 0) { 634 sanitize_inquiry_string(&inq_result[8], 8); 635 sanitize_inquiry_string(&inq_result[16], 16); 636 sanitize_inquiry_string(&inq_result[32], 4); 637 638 response_len = inq_result[4] + 5; 639 if (response_len > 255) 640 response_len = first_inquiry_len; /* sanity */ 641 642 /* 643 * Get any flags for this device. 644 * 645 * XXX add a bflags to scsi_device, and replace the 646 * corresponding bit fields in scsi_device, so bflags 647 * need not be passed as an argument. 648 */ 649 *bflags = scsi_get_device_flags(sdev, &inq_result[8], 650 &inq_result[16]); 651 652 /* When the first pass succeeds we gain information about 653 * what larger transfer lengths might work. */ 654 if (pass == 1) { 655 if (BLIST_INQUIRY_36 & *bflags) 656 next_inquiry_len = 36; 657 else if (BLIST_INQUIRY_58 & *bflags) 658 next_inquiry_len = 58; 659 else if (sdev->inquiry_len) 660 next_inquiry_len = sdev->inquiry_len; 661 else 662 next_inquiry_len = response_len; 663 664 /* If more data is available perform the second pass */ 665 if (next_inquiry_len > try_inquiry_len) { 666 try_inquiry_len = next_inquiry_len; 667 pass = 2; 668 goto next_pass; 669 } 670 } 671 672 } else if (pass == 2) { 673 sdev_printk(KERN_INFO, sdev, 674 "scsi scan: %d byte inquiry failed. " 675 "Consider BLIST_INQUIRY_36 for this device\n", 676 try_inquiry_len); 677 678 /* If this pass failed, the third pass goes back and transfers 679 * the same amount as we successfully got in the first pass. */ 680 try_inquiry_len = first_inquiry_len; 681 pass = 3; 682 goto next_pass; 683 } 684 685 /* If the last transfer attempt got an error, assume the 686 * peripheral doesn't exist or is dead. */ 687 if (result) 688 return -EIO; 689 690 /* Don't report any more data than the device says is valid */ 691 sdev->inquiry_len = min(try_inquiry_len, response_len); 692 693 /* 694 * XXX Abort if the response length is less than 36? If less than 695 * 32, the lookup of the device flags (above) could be invalid, 696 * and it would be possible to take an incorrect action - we do 697 * not want to hang because of a short INQUIRY. On the flip side, 698 * if the device is spun down or becoming ready (and so it gives a 699 * short INQUIRY), an abort here prevents any further use of the 700 * device, including spin up. 701 * 702 * On the whole, the best approach seems to be to assume the first 703 * 36 bytes are valid no matter what the device says. That's 704 * better than copying < 36 bytes to the inquiry-result buffer 705 * and displaying garbage for the Vendor, Product, or Revision 706 * strings. 707 */ 708 if (sdev->inquiry_len < 36) { 709 sdev_printk(KERN_INFO, sdev, 710 "scsi scan: INQUIRY result too short (%d)," 711 " using 36\n", sdev->inquiry_len); 712 sdev->inquiry_len = 36; 713 } 714 715 /* 716 * Related to the above issue: 717 * 718 * XXX Devices (disk or all?) should be sent a TEST UNIT READY, 719 * and if not ready, sent a START_STOP to start (maybe spin up) and 720 * then send the INQUIRY again, since the INQUIRY can change after 721 * a device is initialized. 722 * 723 * Ideally, start a device if explicitly asked to do so. This 724 * assumes that a device is spun up on power on, spun down on 725 * request, and then spun up on request. 726 */ 727 728 /* 729 * The scanning code needs to know the scsi_level, even if no 730 * device is attached at LUN 0 (SCSI_SCAN_TARGET_PRESENT) so 731 * non-zero LUNs can be scanned. 732 */ 733 sdev->scsi_level = inq_result[2] & 0x07; 734 if (sdev->scsi_level >= 2 || 735 (sdev->scsi_level == 1 && (inq_result[3] & 0x0f) == 1)) 736 sdev->scsi_level++; 737 sdev->sdev_target->scsi_level = sdev->scsi_level; 738 739 /* 740 * If SCSI-2 or lower, and if the transport requires it, 741 * store the LUN value in CDB[1]. 742 */ 743 sdev->lun_in_cdb = 0; 744 if (sdev->scsi_level <= SCSI_2 && 745 sdev->scsi_level != SCSI_UNKNOWN && 746 !sdev->host->no_scsi2_lun_in_cdb) 747 sdev->lun_in_cdb = 1; 748 749 return 0; 750 } 751 752 /** 753 * scsi_add_lun - allocate and fully initialze a scsi_device 754 * @sdev: holds information to be stored in the new scsi_device 755 * @inq_result: holds the result of a previous INQUIRY to the LUN 756 * @bflags: black/white list flag 757 * @async: 1 if this device is being scanned asynchronously 758 * 759 * Description: 760 * Initialize the scsi_device @sdev. Optionally set fields based 761 * on values in *@bflags. 762 * 763 * Return: 764 * SCSI_SCAN_NO_RESPONSE: could not allocate or setup a scsi_device 765 * SCSI_SCAN_LUN_PRESENT: a new scsi_device was allocated and initialized 766 **/ 767 static int scsi_add_lun(struct scsi_device *sdev, unsigned char *inq_result, 768 int *bflags, int async) 769 { 770 int ret; 771 772 /* 773 * XXX do not save the inquiry, since it can change underneath us, 774 * save just vendor/model/rev. 775 * 776 * Rather than save it and have an ioctl that retrieves the saved 777 * value, have an ioctl that executes the same INQUIRY code used 778 * in scsi_probe_lun, let user level programs doing INQUIRY 779 * scanning run at their own risk, or supply a user level program 780 * that can correctly scan. 781 */ 782 783 /* 784 * Copy at least 36 bytes of INQUIRY data, so that we don't 785 * dereference unallocated memory when accessing the Vendor, 786 * Product, and Revision strings. Badly behaved devices may set 787 * the INQUIRY Additional Length byte to a small value, indicating 788 * these strings are invalid, but often they contain plausible data 789 * nonetheless. It doesn't matter if the device sent < 36 bytes 790 * total, since scsi_probe_lun() initializes inq_result with 0s. 791 */ 792 sdev->inquiry = kmemdup(inq_result, 793 max_t(size_t, sdev->inquiry_len, 36), 794 GFP_ATOMIC); 795 if (sdev->inquiry == NULL) 796 return SCSI_SCAN_NO_RESPONSE; 797 798 sdev->vendor = (char *) (sdev->inquiry + 8); 799 sdev->model = (char *) (sdev->inquiry + 16); 800 sdev->rev = (char *) (sdev->inquiry + 32); 801 802 if (strncmp(sdev->vendor, "ATA ", 8) == 0) { 803 /* 804 * sata emulation layer device. This is a hack to work around 805 * the SATL power management specifications which state that 806 * when the SATL detects the device has gone into standby 807 * mode, it shall respond with NOT READY. 808 */ 809 sdev->allow_restart = 1; 810 } 811 812 if (*bflags & BLIST_ISROM) { 813 sdev->type = TYPE_ROM; 814 sdev->removable = 1; 815 } else { 816 sdev->type = (inq_result[0] & 0x1f); 817 sdev->removable = (inq_result[1] & 0x80) >> 7; 818 819 /* 820 * some devices may respond with wrong type for 821 * well-known logical units. Force well-known type 822 * to enumerate them correctly. 823 */ 824 if (scsi_is_wlun(sdev->lun) && sdev->type != TYPE_WLUN) { 825 sdev_printk(KERN_WARNING, sdev, 826 "%s: correcting incorrect peripheral device type 0x%x for W-LUN 0x%16xhN\n", 827 __func__, sdev->type, (unsigned int)sdev->lun); 828 sdev->type = TYPE_WLUN; 829 } 830 831 } 832 833 if (sdev->type == TYPE_RBC || sdev->type == TYPE_ROM) { 834 /* RBC and MMC devices can return SCSI-3 compliance and yet 835 * still not support REPORT LUNS, so make them act as 836 * BLIST_NOREPORTLUN unless BLIST_REPORTLUN2 is 837 * specifically set */ 838 if ((*bflags & BLIST_REPORTLUN2) == 0) 839 *bflags |= BLIST_NOREPORTLUN; 840 } 841 842 /* 843 * For a peripheral qualifier (PQ) value of 1 (001b), the SCSI 844 * spec says: The device server is capable of supporting the 845 * specified peripheral device type on this logical unit. However, 846 * the physical device is not currently connected to this logical 847 * unit. 848 * 849 * The above is vague, as it implies that we could treat 001 and 850 * 011 the same. Stay compatible with previous code, and create a 851 * scsi_device for a PQ of 1 852 * 853 * Don't set the device offline here; rather let the upper 854 * level drivers eval the PQ to decide whether they should 855 * attach. So remove ((inq_result[0] >> 5) & 7) == 1 check. 856 */ 857 858 sdev->inq_periph_qual = (inq_result[0] >> 5) & 7; 859 sdev->lockable = sdev->removable; 860 sdev->soft_reset = (inq_result[7] & 1) && ((inq_result[3] & 7) == 2); 861 862 if (sdev->scsi_level >= SCSI_3 || 863 (sdev->inquiry_len > 56 && inq_result[56] & 0x04)) 864 sdev->ppr = 1; 865 if (inq_result[7] & 0x60) 866 sdev->wdtr = 1; 867 if (inq_result[7] & 0x10) 868 sdev->sdtr = 1; 869 870 sdev_printk(KERN_NOTICE, sdev, "%s %.8s %.16s %.4s PQ: %d " 871 "ANSI: %d%s\n", scsi_device_type(sdev->type), 872 sdev->vendor, sdev->model, sdev->rev, 873 sdev->inq_periph_qual, inq_result[2] & 0x07, 874 (inq_result[3] & 0x0f) == 1 ? " CCS" : ""); 875 876 if ((sdev->scsi_level >= SCSI_2) && (inq_result[7] & 2) && 877 !(*bflags & BLIST_NOTQ)) 878 sdev->tagged_supported = 1; 879 880 /* 881 * Some devices (Texel CD ROM drives) have handshaking problems 882 * when used with the Seagate controllers. borken is initialized 883 * to 1, and then set it to 0 here. 884 */ 885 if ((*bflags & BLIST_BORKEN) == 0) 886 sdev->borken = 0; 887 888 if (*bflags & BLIST_NO_ULD_ATTACH) 889 sdev->no_uld_attach = 1; 890 891 /* 892 * Apparently some really broken devices (contrary to the SCSI 893 * standards) need to be selected without asserting ATN 894 */ 895 if (*bflags & BLIST_SELECT_NO_ATN) 896 sdev->select_no_atn = 1; 897 898 /* 899 * Maximum 512 sector transfer length 900 * broken RA4x00 Compaq Disk Array 901 */ 902 if (*bflags & BLIST_MAX_512) 903 blk_queue_max_hw_sectors(sdev->request_queue, 512); 904 905 /* 906 * Some devices may not want to have a start command automatically 907 * issued when a device is added. 908 */ 909 if (*bflags & BLIST_NOSTARTONADD) 910 sdev->no_start_on_add = 1; 911 912 if (*bflags & BLIST_SINGLELUN) 913 scsi_target(sdev)->single_lun = 1; 914 915 sdev->use_10_for_rw = 1; 916 917 if (*bflags & BLIST_MS_SKIP_PAGE_08) 918 sdev->skip_ms_page_8 = 1; 919 920 if (*bflags & BLIST_MS_SKIP_PAGE_3F) 921 sdev->skip_ms_page_3f = 1; 922 923 if (*bflags & BLIST_USE_10_BYTE_MS) 924 sdev->use_10_for_ms = 1; 925 926 /* some devices don't like REPORT SUPPORTED OPERATION CODES 927 * and will simply timeout causing sd_mod init to take a very 928 * very long time */ 929 if (*bflags & BLIST_NO_RSOC) 930 sdev->no_report_opcodes = 1; 931 932 /* set the device running here so that slave configure 933 * may do I/O */ 934 ret = scsi_device_set_state(sdev, SDEV_RUNNING); 935 if (ret) { 936 ret = scsi_device_set_state(sdev, SDEV_BLOCK); 937 938 if (ret) { 939 sdev_printk(KERN_ERR, sdev, 940 "in wrong state %s to complete scan\n", 941 scsi_device_state_name(sdev->sdev_state)); 942 return SCSI_SCAN_NO_RESPONSE; 943 } 944 } 945 946 if (*bflags & BLIST_MS_192_BYTES_FOR_3F) 947 sdev->use_192_bytes_for_3f = 1; 948 949 if (*bflags & BLIST_NOT_LOCKABLE) 950 sdev->lockable = 0; 951 952 if (*bflags & BLIST_RETRY_HWERROR) 953 sdev->retry_hwerror = 1; 954 955 if (*bflags & BLIST_NO_DIF) 956 sdev->no_dif = 1; 957 958 sdev->eh_timeout = SCSI_DEFAULT_EH_TIMEOUT; 959 960 if (*bflags & BLIST_TRY_VPD_PAGES) 961 sdev->try_vpd_pages = 1; 962 else if (*bflags & BLIST_SKIP_VPD_PAGES) 963 sdev->skip_vpd_pages = 1; 964 965 transport_configure_device(&sdev->sdev_gendev); 966 967 if (sdev->host->hostt->slave_configure) { 968 ret = sdev->host->hostt->slave_configure(sdev); 969 if (ret) { 970 /* 971 * if LLDD reports slave not present, don't clutter 972 * console with alloc failure messages 973 */ 974 if (ret != -ENXIO) { 975 sdev_printk(KERN_ERR, sdev, 976 "failed to configure device\n"); 977 } 978 return SCSI_SCAN_NO_RESPONSE; 979 } 980 } 981 982 if (sdev->scsi_level >= SCSI_3) 983 scsi_attach_vpd(sdev); 984 985 sdev->max_queue_depth = sdev->queue_depth; 986 987 /* 988 * Ok, the device is now all set up, we can 989 * register it and tell the rest of the kernel 990 * about it. 991 */ 992 if (!async && scsi_sysfs_add_sdev(sdev) != 0) 993 return SCSI_SCAN_NO_RESPONSE; 994 995 return SCSI_SCAN_LUN_PRESENT; 996 } 997 998 #ifdef CONFIG_SCSI_LOGGING 999 /** 1000 * scsi_inq_str - print INQUIRY data from min to max index, strip trailing whitespace 1001 * @buf: Output buffer with at least end-first+1 bytes of space 1002 * @inq: Inquiry buffer (input) 1003 * @first: Offset of string into inq 1004 * @end: Index after last character in inq 1005 */ 1006 static unsigned char *scsi_inq_str(unsigned char *buf, unsigned char *inq, 1007 unsigned first, unsigned end) 1008 { 1009 unsigned term = 0, idx; 1010 1011 for (idx = 0; idx + first < end && idx + first < inq[4] + 5; idx++) { 1012 if (inq[idx+first] > ' ') { 1013 buf[idx] = inq[idx+first]; 1014 term = idx+1; 1015 } else { 1016 buf[idx] = ' '; 1017 } 1018 } 1019 buf[term] = 0; 1020 return buf; 1021 } 1022 #endif 1023 1024 /** 1025 * scsi_probe_and_add_lun - probe a LUN, if a LUN is found add it 1026 * @starget: pointer to target device structure 1027 * @lun: LUN of target device 1028 * @bflagsp: store bflags here if not NULL 1029 * @sdevp: probe the LUN corresponding to this scsi_device 1030 * @rescan: if nonzero skip some code only needed on first scan 1031 * @hostdata: passed to scsi_alloc_sdev() 1032 * 1033 * Description: 1034 * Call scsi_probe_lun, if a LUN with an attached device is found, 1035 * allocate and set it up by calling scsi_add_lun. 1036 * 1037 * Return: 1038 * SCSI_SCAN_NO_RESPONSE: could not allocate or setup a scsi_device 1039 * SCSI_SCAN_TARGET_PRESENT: target responded, but no device is 1040 * attached at the LUN 1041 * SCSI_SCAN_LUN_PRESENT: a new scsi_device was allocated and initialized 1042 **/ 1043 static int scsi_probe_and_add_lun(struct scsi_target *starget, 1044 u64 lun, int *bflagsp, 1045 struct scsi_device **sdevp, int rescan, 1046 void *hostdata) 1047 { 1048 struct scsi_device *sdev; 1049 unsigned char *result; 1050 int bflags, res = SCSI_SCAN_NO_RESPONSE, result_len = 256; 1051 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); 1052 1053 /* 1054 * The rescan flag is used as an optimization, the first scan of a 1055 * host adapter calls into here with rescan == 0. 1056 */ 1057 sdev = scsi_device_lookup_by_target(starget, lun); 1058 if (sdev) { 1059 if (rescan || !scsi_device_created(sdev)) { 1060 SCSI_LOG_SCAN_BUS(3, sdev_printk(KERN_INFO, sdev, 1061 "scsi scan: device exists on %s\n", 1062 dev_name(&sdev->sdev_gendev))); 1063 if (sdevp) 1064 *sdevp = sdev; 1065 else 1066 scsi_device_put(sdev); 1067 1068 if (bflagsp) 1069 *bflagsp = scsi_get_device_flags(sdev, 1070 sdev->vendor, 1071 sdev->model); 1072 return SCSI_SCAN_LUN_PRESENT; 1073 } 1074 scsi_device_put(sdev); 1075 } else 1076 sdev = scsi_alloc_sdev(starget, lun, hostdata); 1077 if (!sdev) 1078 goto out; 1079 1080 result = kmalloc(result_len, GFP_ATOMIC | 1081 ((shost->unchecked_isa_dma) ? __GFP_DMA : 0)); 1082 if (!result) 1083 goto out_free_sdev; 1084 1085 if (scsi_probe_lun(sdev, result, result_len, &bflags)) 1086 goto out_free_result; 1087 1088 if (bflagsp) 1089 *bflagsp = bflags; 1090 /* 1091 * result contains valid SCSI INQUIRY data. 1092 */ 1093 if (((result[0] >> 5) == 3) && !(bflags & BLIST_ATTACH_PQ3)) { 1094 /* 1095 * For a Peripheral qualifier 3 (011b), the SCSI 1096 * spec says: The device server is not capable of 1097 * supporting a physical device on this logical 1098 * unit. 1099 * 1100 * For disks, this implies that there is no 1101 * logical disk configured at sdev->lun, but there 1102 * is a target id responding. 1103 */ 1104 SCSI_LOG_SCAN_BUS(2, sdev_printk(KERN_INFO, sdev, "scsi scan:" 1105 " peripheral qualifier of 3, device not" 1106 " added\n")) 1107 if (lun == 0) { 1108 SCSI_LOG_SCAN_BUS(1, { 1109 unsigned char vend[9]; 1110 unsigned char mod[17]; 1111 1112 sdev_printk(KERN_INFO, sdev, 1113 "scsi scan: consider passing scsi_mod." 1114 "dev_flags=%s:%s:0x240 or 0x1000240\n", 1115 scsi_inq_str(vend, result, 8, 16), 1116 scsi_inq_str(mod, result, 16, 32)); 1117 }); 1118 1119 } 1120 1121 res = SCSI_SCAN_TARGET_PRESENT; 1122 goto out_free_result; 1123 } 1124 1125 /* 1126 * Some targets may set slight variations of PQ and PDT to signal 1127 * that no LUN is present, so don't add sdev in these cases. 1128 * Two specific examples are: 1129 * 1) NetApp targets: return PQ=1, PDT=0x1f 1130 * 2) USB UFI: returns PDT=0x1f, with the PQ bits being "reserved" 1131 * in the UFI 1.0 spec (we cannot rely on reserved bits). 1132 * 1133 * References: 1134 * 1) SCSI SPC-3, pp. 145-146 1135 * PQ=1: "A peripheral device having the specified peripheral 1136 * device type is not connected to this logical unit. However, the 1137 * device server is capable of supporting the specified peripheral 1138 * device type on this logical unit." 1139 * PDT=0x1f: "Unknown or no device type" 1140 * 2) USB UFI 1.0, p. 20 1141 * PDT=00h Direct-access device (floppy) 1142 * PDT=1Fh none (no FDD connected to the requested logical unit) 1143 */ 1144 if (((result[0] >> 5) == 1 || starget->pdt_1f_for_no_lun) && 1145 (result[0] & 0x1f) == 0x1f && 1146 !scsi_is_wlun(lun)) { 1147 SCSI_LOG_SCAN_BUS(3, sdev_printk(KERN_INFO, sdev, 1148 "scsi scan: peripheral device type" 1149 " of 31, no device added\n")); 1150 res = SCSI_SCAN_TARGET_PRESENT; 1151 goto out_free_result; 1152 } 1153 1154 res = scsi_add_lun(sdev, result, &bflags, shost->async_scan); 1155 if (res == SCSI_SCAN_LUN_PRESENT) { 1156 if (bflags & BLIST_KEY) { 1157 sdev->lockable = 0; 1158 scsi_unlock_floptical(sdev, result); 1159 } 1160 } 1161 1162 out_free_result: 1163 kfree(result); 1164 out_free_sdev: 1165 if (res == SCSI_SCAN_LUN_PRESENT) { 1166 if (sdevp) { 1167 if (scsi_device_get(sdev) == 0) { 1168 *sdevp = sdev; 1169 } else { 1170 __scsi_remove_device(sdev); 1171 res = SCSI_SCAN_NO_RESPONSE; 1172 } 1173 } 1174 } else 1175 __scsi_remove_device(sdev); 1176 out: 1177 return res; 1178 } 1179 1180 /** 1181 * scsi_sequential_lun_scan - sequentially scan a SCSI target 1182 * @starget: pointer to target structure to scan 1183 * @bflags: black/white list flag for LUN 0 1184 * @scsi_level: Which version of the standard does this device adhere to 1185 * @rescan: passed to scsi_probe_add_lun() 1186 * 1187 * Description: 1188 * Generally, scan from LUN 1 (LUN 0 is assumed to already have been 1189 * scanned) to some maximum lun until a LUN is found with no device 1190 * attached. Use the bflags to figure out any oddities. 1191 * 1192 * Modifies sdevscan->lun. 1193 **/ 1194 static void scsi_sequential_lun_scan(struct scsi_target *starget, 1195 int bflags, int scsi_level, int rescan) 1196 { 1197 uint max_dev_lun; 1198 u64 sparse_lun, lun; 1199 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); 1200 1201 SCSI_LOG_SCAN_BUS(3, starget_printk(KERN_INFO, starget, 1202 "scsi scan: Sequential scan\n")); 1203 1204 max_dev_lun = min(max_scsi_luns, shost->max_lun); 1205 /* 1206 * If this device is known to support sparse multiple units, 1207 * override the other settings, and scan all of them. Normally, 1208 * SCSI-3 devices should be scanned via the REPORT LUNS. 1209 */ 1210 if (bflags & BLIST_SPARSELUN) { 1211 max_dev_lun = shost->max_lun; 1212 sparse_lun = 1; 1213 } else 1214 sparse_lun = 0; 1215 1216 /* 1217 * If less than SCSI_1_CSS, and no special lun scaning, stop 1218 * scanning; this matches 2.4 behaviour, but could just be a bug 1219 * (to continue scanning a SCSI_1_CSS device). 1220 * 1221 * This test is broken. We might not have any device on lun0 for 1222 * a sparselun device, and if that's the case then how would we 1223 * know the real scsi_level, eh? It might make sense to just not 1224 * scan any SCSI_1 device for non-0 luns, but that check would best 1225 * go into scsi_alloc_sdev() and just have it return null when asked 1226 * to alloc an sdev for lun > 0 on an already found SCSI_1 device. 1227 * 1228 if ((sdevscan->scsi_level < SCSI_1_CCS) && 1229 ((bflags & (BLIST_FORCELUN | BLIST_SPARSELUN | BLIST_MAX5LUN)) 1230 == 0)) 1231 return; 1232 */ 1233 /* 1234 * If this device is known to support multiple units, override 1235 * the other settings, and scan all of them. 1236 */ 1237 if (bflags & BLIST_FORCELUN) 1238 max_dev_lun = shost->max_lun; 1239 /* 1240 * REGAL CDC-4X: avoid hang after LUN 4 1241 */ 1242 if (bflags & BLIST_MAX5LUN) 1243 max_dev_lun = min(5U, max_dev_lun); 1244 /* 1245 * Do not scan SCSI-2 or lower device past LUN 7, unless 1246 * BLIST_LARGELUN. 1247 */ 1248 if (scsi_level < SCSI_3 && !(bflags & BLIST_LARGELUN)) 1249 max_dev_lun = min(8U, max_dev_lun); 1250 1251 /* 1252 * Stop scanning at 255 unless BLIST_SCSI3LUN 1253 */ 1254 if (!(bflags & BLIST_SCSI3LUN)) 1255 max_dev_lun = min(256U, max_dev_lun); 1256 1257 /* 1258 * We have already scanned LUN 0, so start at LUN 1. Keep scanning 1259 * until we reach the max, or no LUN is found and we are not 1260 * sparse_lun. 1261 */ 1262 for (lun = 1; lun < max_dev_lun; ++lun) 1263 if ((scsi_probe_and_add_lun(starget, lun, NULL, NULL, rescan, 1264 NULL) != SCSI_SCAN_LUN_PRESENT) && 1265 !sparse_lun) 1266 return; 1267 } 1268 1269 /** 1270 * scsilun_to_int - convert a scsi_lun to an int 1271 * @scsilun: struct scsi_lun to be converted. 1272 * 1273 * Description: 1274 * Convert @scsilun from a struct scsi_lun to a four byte host byte-ordered 1275 * integer, and return the result. The caller must check for 1276 * truncation before using this function. 1277 * 1278 * Notes: 1279 * For a description of the LUN format, post SCSI-3 see the SCSI 1280 * Architecture Model, for SCSI-3 see the SCSI Controller Commands. 1281 * 1282 * Given a struct scsi_lun of: d2 04 0b 03 00 00 00 00, this function 1283 * returns the integer: 0x0b03d204 1284 * 1285 * This encoding will return a standard integer LUN for LUNs smaller 1286 * than 256, which typically use a single level LUN structure with 1287 * addressing method 0. 1288 **/ 1289 u64 scsilun_to_int(struct scsi_lun *scsilun) 1290 { 1291 int i; 1292 u64 lun; 1293 1294 lun = 0; 1295 for (i = 0; i < sizeof(lun); i += 2) 1296 lun = lun | (((u64)scsilun->scsi_lun[i] << ((i + 1) * 8)) | 1297 ((u64)scsilun->scsi_lun[i + 1] << (i * 8))); 1298 return lun; 1299 } 1300 EXPORT_SYMBOL(scsilun_to_int); 1301 1302 /** 1303 * int_to_scsilun - reverts an int into a scsi_lun 1304 * @lun: integer to be reverted 1305 * @scsilun: struct scsi_lun to be set. 1306 * 1307 * Description: 1308 * Reverts the functionality of the scsilun_to_int, which packed 1309 * an 8-byte lun value into an int. This routine unpacks the int 1310 * back into the lun value. 1311 * 1312 * Notes: 1313 * Given an integer : 0x0b03d204, this function returns a 1314 * struct scsi_lun of: d2 04 0b 03 00 00 00 00 1315 * 1316 **/ 1317 void int_to_scsilun(u64 lun, struct scsi_lun *scsilun) 1318 { 1319 int i; 1320 1321 memset(scsilun->scsi_lun, 0, sizeof(scsilun->scsi_lun)); 1322 1323 for (i = 0; i < sizeof(lun); i += 2) { 1324 scsilun->scsi_lun[i] = (lun >> 8) & 0xFF; 1325 scsilun->scsi_lun[i+1] = lun & 0xFF; 1326 lun = lun >> 16; 1327 } 1328 } 1329 EXPORT_SYMBOL(int_to_scsilun); 1330 1331 /** 1332 * scsi_report_lun_scan - Scan using SCSI REPORT LUN results 1333 * @starget: which target 1334 * @bflags: Zero or a mix of BLIST_NOLUN, BLIST_REPORTLUN2, or BLIST_NOREPORTLUN 1335 * @rescan: nonzero if we can skip code only needed on first scan 1336 * 1337 * Description: 1338 * Fast scanning for modern (SCSI-3) devices by sending a REPORT LUN command. 1339 * Scan the resulting list of LUNs by calling scsi_probe_and_add_lun. 1340 * 1341 * If BLINK_REPORTLUN2 is set, scan a target that supports more than 8 1342 * LUNs even if it's older than SCSI-3. 1343 * If BLIST_NOREPORTLUN is set, return 1 always. 1344 * If BLIST_NOLUN is set, return 0 always. 1345 * If starget->no_report_luns is set, return 1 always. 1346 * 1347 * Return: 1348 * 0: scan completed (or no memory, so further scanning is futile) 1349 * 1: could not scan with REPORT LUN 1350 **/ 1351 static int scsi_report_lun_scan(struct scsi_target *starget, int bflags, 1352 int rescan) 1353 { 1354 char devname[64]; 1355 unsigned char scsi_cmd[MAX_COMMAND_SIZE]; 1356 unsigned int length; 1357 u64 lun; 1358 unsigned int num_luns; 1359 unsigned int retries; 1360 int result; 1361 struct scsi_lun *lunp, *lun_data; 1362 u8 *data; 1363 struct scsi_sense_hdr sshdr; 1364 struct scsi_device *sdev; 1365 struct Scsi_Host *shost = dev_to_shost(&starget->dev); 1366 int ret = 0; 1367 1368 /* 1369 * Only support SCSI-3 and up devices if BLIST_NOREPORTLUN is not set. 1370 * Also allow SCSI-2 if BLIST_REPORTLUN2 is set and host adapter does 1371 * support more than 8 LUNs. 1372 * Don't attempt if the target doesn't support REPORT LUNS. 1373 */ 1374 if (bflags & BLIST_NOREPORTLUN) 1375 return 1; 1376 if (starget->scsi_level < SCSI_2 && 1377 starget->scsi_level != SCSI_UNKNOWN) 1378 return 1; 1379 if (starget->scsi_level < SCSI_3 && 1380 (!(bflags & BLIST_REPORTLUN2) || shost->max_lun <= 8)) 1381 return 1; 1382 if (bflags & BLIST_NOLUN) 1383 return 0; 1384 if (starget->no_report_luns) 1385 return 1; 1386 1387 if (!(sdev = scsi_device_lookup_by_target(starget, 0))) { 1388 sdev = scsi_alloc_sdev(starget, 0, NULL); 1389 if (!sdev) 1390 return 0; 1391 if (scsi_device_get(sdev)) { 1392 __scsi_remove_device(sdev); 1393 return 0; 1394 } 1395 } 1396 1397 sprintf(devname, "host %d channel %d id %d", 1398 shost->host_no, sdev->channel, sdev->id); 1399 1400 /* 1401 * Allocate enough to hold the header (the same size as one scsi_lun) 1402 * plus the max number of luns we are requesting. 1403 * 1404 * Reallocating and trying again (with the exact amount we need) 1405 * would be nice, but then we need to somehow limit the size 1406 * allocated based on the available memory and the limits of 1407 * kmalloc - we don't want a kmalloc() failure of a huge value to 1408 * prevent us from finding any LUNs on this target. 1409 */ 1410 length = (max_scsi_report_luns + 1) * sizeof(struct scsi_lun); 1411 lun_data = kmalloc(length, GFP_ATOMIC | 1412 (sdev->host->unchecked_isa_dma ? __GFP_DMA : 0)); 1413 if (!lun_data) { 1414 printk(ALLOC_FAILURE_MSG, __func__); 1415 goto out; 1416 } 1417 1418 scsi_cmd[0] = REPORT_LUNS; 1419 1420 /* 1421 * bytes 1 - 5: reserved, set to zero. 1422 */ 1423 memset(&scsi_cmd[1], 0, 5); 1424 1425 /* 1426 * bytes 6 - 9: length of the command. 1427 */ 1428 scsi_cmd[6] = (unsigned char) (length >> 24) & 0xff; 1429 scsi_cmd[7] = (unsigned char) (length >> 16) & 0xff; 1430 scsi_cmd[8] = (unsigned char) (length >> 8) & 0xff; 1431 scsi_cmd[9] = (unsigned char) length & 0xff; 1432 1433 scsi_cmd[10] = 0; /* reserved */ 1434 scsi_cmd[11] = 0; /* control */ 1435 1436 /* 1437 * We can get a UNIT ATTENTION, for example a power on/reset, so 1438 * retry a few times (like sd.c does for TEST UNIT READY). 1439 * Experience shows some combinations of adapter/devices get at 1440 * least two power on/resets. 1441 * 1442 * Illegal requests (for devices that do not support REPORT LUNS) 1443 * should come through as a check condition, and will not generate 1444 * a retry. 1445 */ 1446 for (retries = 0; retries < 3; retries++) { 1447 SCSI_LOG_SCAN_BUS(3, sdev_printk (KERN_INFO, sdev, 1448 "scsi scan: Sending REPORT LUNS to (try %d)\n", 1449 retries)); 1450 1451 result = scsi_execute_req(sdev, scsi_cmd, DMA_FROM_DEVICE, 1452 lun_data, length, &sshdr, 1453 SCSI_TIMEOUT + 4 * HZ, 3, NULL); 1454 1455 SCSI_LOG_SCAN_BUS(3, sdev_printk (KERN_INFO, sdev, 1456 "scsi scan: REPORT LUNS" 1457 " %s (try %d) result 0x%x\n", 1458 result ? "failed" : "successful", 1459 retries, result)); 1460 if (result == 0) 1461 break; 1462 else if (scsi_sense_valid(&sshdr)) { 1463 if (sshdr.sense_key != UNIT_ATTENTION) 1464 break; 1465 } 1466 } 1467 1468 if (result) { 1469 /* 1470 * The device probably does not support a REPORT LUN command 1471 */ 1472 ret = 1; 1473 goto out_err; 1474 } 1475 1476 /* 1477 * Get the length from the first four bytes of lun_data. 1478 */ 1479 data = (u8 *) lun_data->scsi_lun; 1480 length = ((data[0] << 24) | (data[1] << 16) | 1481 (data[2] << 8) | (data[3] << 0)); 1482 1483 num_luns = (length / sizeof(struct scsi_lun)); 1484 if (num_luns > max_scsi_report_luns) { 1485 sdev_printk(KERN_WARNING, sdev, 1486 "Only %d (max_scsi_report_luns)" 1487 " of %d luns reported, try increasing" 1488 " max_scsi_report_luns.\n", 1489 max_scsi_report_luns, num_luns); 1490 num_luns = max_scsi_report_luns; 1491 } 1492 1493 SCSI_LOG_SCAN_BUS(3, sdev_printk (KERN_INFO, sdev, 1494 "scsi scan: REPORT LUN scan\n")); 1495 1496 /* 1497 * Scan the luns in lun_data. The entry at offset 0 is really 1498 * the header, so start at 1 and go up to and including num_luns. 1499 */ 1500 for (lunp = &lun_data[1]; lunp <= &lun_data[num_luns]; lunp++) { 1501 lun = scsilun_to_int(lunp); 1502 1503 if (lun > sdev->host->max_lun) { 1504 sdev_printk(KERN_WARNING, sdev, 1505 "lun%llu has a LUN larger than" 1506 " allowed by the host adapter\n", lun); 1507 } else { 1508 int res; 1509 1510 res = scsi_probe_and_add_lun(starget, 1511 lun, NULL, NULL, rescan, NULL); 1512 if (res == SCSI_SCAN_NO_RESPONSE) { 1513 /* 1514 * Got some results, but now none, abort. 1515 */ 1516 sdev_printk(KERN_ERR, sdev, 1517 "Unexpected response" 1518 " from lun %llu while scanning, scan" 1519 " aborted\n", (unsigned long long)lun); 1520 break; 1521 } 1522 } 1523 } 1524 1525 out_err: 1526 kfree(lun_data); 1527 out: 1528 scsi_device_put(sdev); 1529 if (scsi_device_created(sdev)) 1530 /* 1531 * the sdev we used didn't appear in the report luns scan 1532 */ 1533 __scsi_remove_device(sdev); 1534 return ret; 1535 } 1536 1537 struct scsi_device *__scsi_add_device(struct Scsi_Host *shost, uint channel, 1538 uint id, u64 lun, void *hostdata) 1539 { 1540 struct scsi_device *sdev = ERR_PTR(-ENODEV); 1541 struct device *parent = &shost->shost_gendev; 1542 struct scsi_target *starget; 1543 1544 if (strncmp(scsi_scan_type, "none", 4) == 0) 1545 return ERR_PTR(-ENODEV); 1546 1547 starget = scsi_alloc_target(parent, channel, id); 1548 if (!starget) 1549 return ERR_PTR(-ENOMEM); 1550 scsi_autopm_get_target(starget); 1551 1552 mutex_lock(&shost->scan_mutex); 1553 if (!shost->async_scan) 1554 scsi_complete_async_scans(); 1555 1556 if (scsi_host_scan_allowed(shost) && scsi_autopm_get_host(shost) == 0) { 1557 scsi_probe_and_add_lun(starget, lun, NULL, &sdev, 1, hostdata); 1558 scsi_autopm_put_host(shost); 1559 } 1560 mutex_unlock(&shost->scan_mutex); 1561 scsi_autopm_put_target(starget); 1562 /* 1563 * paired with scsi_alloc_target(). Target will be destroyed unless 1564 * scsi_probe_and_add_lun made an underlying device visible 1565 */ 1566 scsi_target_reap(starget); 1567 put_device(&starget->dev); 1568 1569 return sdev; 1570 } 1571 EXPORT_SYMBOL(__scsi_add_device); 1572 1573 int scsi_add_device(struct Scsi_Host *host, uint channel, 1574 uint target, u64 lun) 1575 { 1576 struct scsi_device *sdev = 1577 __scsi_add_device(host, channel, target, lun, NULL); 1578 if (IS_ERR(sdev)) 1579 return PTR_ERR(sdev); 1580 1581 scsi_device_put(sdev); 1582 return 0; 1583 } 1584 EXPORT_SYMBOL(scsi_add_device); 1585 1586 void scsi_rescan_device(struct device *dev) 1587 { 1588 struct scsi_driver *drv; 1589 1590 if (!dev->driver) 1591 return; 1592 1593 drv = to_scsi_driver(dev->driver); 1594 if (try_module_get(drv->owner)) { 1595 if (drv->rescan) 1596 drv->rescan(dev); 1597 module_put(drv->owner); 1598 } 1599 } 1600 EXPORT_SYMBOL(scsi_rescan_device); 1601 1602 static void __scsi_scan_target(struct device *parent, unsigned int channel, 1603 unsigned int id, u64 lun, int rescan) 1604 { 1605 struct Scsi_Host *shost = dev_to_shost(parent); 1606 int bflags = 0; 1607 int res; 1608 struct scsi_target *starget; 1609 1610 if (shost->this_id == id) 1611 /* 1612 * Don't scan the host adapter 1613 */ 1614 return; 1615 1616 starget = scsi_alloc_target(parent, channel, id); 1617 if (!starget) 1618 return; 1619 scsi_autopm_get_target(starget); 1620 1621 if (lun != SCAN_WILD_CARD) { 1622 /* 1623 * Scan for a specific host/chan/id/lun. 1624 */ 1625 scsi_probe_and_add_lun(starget, lun, NULL, NULL, rescan, NULL); 1626 goto out_reap; 1627 } 1628 1629 /* 1630 * Scan LUN 0, if there is some response, scan further. Ideally, we 1631 * would not configure LUN 0 until all LUNs are scanned. 1632 */ 1633 res = scsi_probe_and_add_lun(starget, 0, &bflags, NULL, rescan, NULL); 1634 if (res == SCSI_SCAN_LUN_PRESENT || res == SCSI_SCAN_TARGET_PRESENT) { 1635 if (scsi_report_lun_scan(starget, bflags, rescan) != 0) 1636 /* 1637 * The REPORT LUN did not scan the target, 1638 * do a sequential scan. 1639 */ 1640 scsi_sequential_lun_scan(starget, bflags, 1641 starget->scsi_level, rescan); 1642 } 1643 1644 out_reap: 1645 scsi_autopm_put_target(starget); 1646 /* 1647 * paired with scsi_alloc_target(): determine if the target has 1648 * any children at all and if not, nuke it 1649 */ 1650 scsi_target_reap(starget); 1651 1652 put_device(&starget->dev); 1653 } 1654 1655 /** 1656 * scsi_scan_target - scan a target id, possibly including all LUNs on the target. 1657 * @parent: host to scan 1658 * @channel: channel to scan 1659 * @id: target id to scan 1660 * @lun: Specific LUN to scan or SCAN_WILD_CARD 1661 * @rescan: passed to LUN scanning routines 1662 * 1663 * Description: 1664 * Scan the target id on @parent, @channel, and @id. Scan at least LUN 0, 1665 * and possibly all LUNs on the target id. 1666 * 1667 * First try a REPORT LUN scan, if that does not scan the target, do a 1668 * sequential scan of LUNs on the target id. 1669 **/ 1670 void scsi_scan_target(struct device *parent, unsigned int channel, 1671 unsigned int id, u64 lun, int rescan) 1672 { 1673 struct Scsi_Host *shost = dev_to_shost(parent); 1674 1675 if (strncmp(scsi_scan_type, "none", 4) == 0) 1676 return; 1677 1678 mutex_lock(&shost->scan_mutex); 1679 if (!shost->async_scan) 1680 scsi_complete_async_scans(); 1681 1682 if (scsi_host_scan_allowed(shost) && scsi_autopm_get_host(shost) == 0) { 1683 __scsi_scan_target(parent, channel, id, lun, rescan); 1684 scsi_autopm_put_host(shost); 1685 } 1686 mutex_unlock(&shost->scan_mutex); 1687 } 1688 EXPORT_SYMBOL(scsi_scan_target); 1689 1690 static void scsi_scan_channel(struct Scsi_Host *shost, unsigned int channel, 1691 unsigned int id, u64 lun, int rescan) 1692 { 1693 uint order_id; 1694 1695 if (id == SCAN_WILD_CARD) 1696 for (id = 0; id < shost->max_id; ++id) { 1697 /* 1698 * XXX adapter drivers when possible (FCP, iSCSI) 1699 * could modify max_id to match the current max, 1700 * not the absolute max. 1701 * 1702 * XXX add a shost id iterator, so for example, 1703 * the FC ID can be the same as a target id 1704 * without a huge overhead of sparse id's. 1705 */ 1706 if (shost->reverse_ordering) 1707 /* 1708 * Scan from high to low id. 1709 */ 1710 order_id = shost->max_id - id - 1; 1711 else 1712 order_id = id; 1713 __scsi_scan_target(&shost->shost_gendev, channel, 1714 order_id, lun, rescan); 1715 } 1716 else 1717 __scsi_scan_target(&shost->shost_gendev, channel, 1718 id, lun, rescan); 1719 } 1720 1721 int scsi_scan_host_selected(struct Scsi_Host *shost, unsigned int channel, 1722 unsigned int id, u64 lun, int rescan) 1723 { 1724 SCSI_LOG_SCAN_BUS(3, shost_printk (KERN_INFO, shost, 1725 "%s: <%u:%u:%llu>\n", 1726 __func__, channel, id, lun)); 1727 1728 if (((channel != SCAN_WILD_CARD) && (channel > shost->max_channel)) || 1729 ((id != SCAN_WILD_CARD) && (id >= shost->max_id)) || 1730 ((lun != SCAN_WILD_CARD) && (lun > shost->max_lun))) 1731 return -EINVAL; 1732 1733 mutex_lock(&shost->scan_mutex); 1734 if (!shost->async_scan) 1735 scsi_complete_async_scans(); 1736 1737 if (scsi_host_scan_allowed(shost) && scsi_autopm_get_host(shost) == 0) { 1738 if (channel == SCAN_WILD_CARD) 1739 for (channel = 0; channel <= shost->max_channel; 1740 channel++) 1741 scsi_scan_channel(shost, channel, id, lun, 1742 rescan); 1743 else 1744 scsi_scan_channel(shost, channel, id, lun, rescan); 1745 scsi_autopm_put_host(shost); 1746 } 1747 mutex_unlock(&shost->scan_mutex); 1748 1749 return 0; 1750 } 1751 1752 static void scsi_sysfs_add_devices(struct Scsi_Host *shost) 1753 { 1754 struct scsi_device *sdev; 1755 shost_for_each_device(sdev, shost) { 1756 /* target removed before the device could be added */ 1757 if (sdev->sdev_state == SDEV_DEL) 1758 continue; 1759 /* If device is already visible, skip adding it to sysfs */ 1760 if (sdev->is_visible) 1761 continue; 1762 if (!scsi_host_scan_allowed(shost) || 1763 scsi_sysfs_add_sdev(sdev) != 0) 1764 __scsi_remove_device(sdev); 1765 } 1766 } 1767 1768 /** 1769 * scsi_prep_async_scan - prepare for an async scan 1770 * @shost: the host which will be scanned 1771 * Returns: a cookie to be passed to scsi_finish_async_scan() 1772 * 1773 * Tells the midlayer this host is going to do an asynchronous scan. 1774 * It reserves the host's position in the scanning list and ensures 1775 * that other asynchronous scans started after this one won't affect the 1776 * ordering of the discovered devices. 1777 */ 1778 static struct async_scan_data *scsi_prep_async_scan(struct Scsi_Host *shost) 1779 { 1780 struct async_scan_data *data; 1781 unsigned long flags; 1782 1783 if (strncmp(scsi_scan_type, "sync", 4) == 0) 1784 return NULL; 1785 1786 if (shost->async_scan) { 1787 shost_printk(KERN_INFO, shost, "%s called twice\n", __func__); 1788 dump_stack(); 1789 return NULL; 1790 } 1791 1792 data = kmalloc(sizeof(*data), GFP_KERNEL); 1793 if (!data) 1794 goto err; 1795 data->shost = scsi_host_get(shost); 1796 if (!data->shost) 1797 goto err; 1798 init_completion(&data->prev_finished); 1799 1800 mutex_lock(&shost->scan_mutex); 1801 spin_lock_irqsave(shost->host_lock, flags); 1802 shost->async_scan = 1; 1803 spin_unlock_irqrestore(shost->host_lock, flags); 1804 mutex_unlock(&shost->scan_mutex); 1805 1806 spin_lock(&async_scan_lock); 1807 if (list_empty(&scanning_hosts)) 1808 complete(&data->prev_finished); 1809 list_add_tail(&data->list, &scanning_hosts); 1810 spin_unlock(&async_scan_lock); 1811 1812 return data; 1813 1814 err: 1815 kfree(data); 1816 return NULL; 1817 } 1818 1819 /** 1820 * scsi_finish_async_scan - asynchronous scan has finished 1821 * @data: cookie returned from earlier call to scsi_prep_async_scan() 1822 * 1823 * All the devices currently attached to this host have been found. 1824 * This function announces all the devices it has found to the rest 1825 * of the system. 1826 */ 1827 static void scsi_finish_async_scan(struct async_scan_data *data) 1828 { 1829 struct Scsi_Host *shost; 1830 unsigned long flags; 1831 1832 if (!data) 1833 return; 1834 1835 shost = data->shost; 1836 1837 mutex_lock(&shost->scan_mutex); 1838 1839 if (!shost->async_scan) { 1840 shost_printk(KERN_INFO, shost, "%s called twice\n", __func__); 1841 dump_stack(); 1842 mutex_unlock(&shost->scan_mutex); 1843 return; 1844 } 1845 1846 wait_for_completion(&data->prev_finished); 1847 1848 scsi_sysfs_add_devices(shost); 1849 1850 spin_lock_irqsave(shost->host_lock, flags); 1851 shost->async_scan = 0; 1852 spin_unlock_irqrestore(shost->host_lock, flags); 1853 1854 mutex_unlock(&shost->scan_mutex); 1855 1856 spin_lock(&async_scan_lock); 1857 list_del(&data->list); 1858 if (!list_empty(&scanning_hosts)) { 1859 struct async_scan_data *next = list_entry(scanning_hosts.next, 1860 struct async_scan_data, list); 1861 complete(&next->prev_finished); 1862 } 1863 spin_unlock(&async_scan_lock); 1864 1865 scsi_autopm_put_host(shost); 1866 scsi_host_put(shost); 1867 kfree(data); 1868 } 1869 1870 static void do_scsi_scan_host(struct Scsi_Host *shost) 1871 { 1872 if (shost->hostt->scan_finished) { 1873 unsigned long start = jiffies; 1874 if (shost->hostt->scan_start) 1875 shost->hostt->scan_start(shost); 1876 1877 while (!shost->hostt->scan_finished(shost, jiffies - start)) 1878 msleep(10); 1879 } else { 1880 scsi_scan_host_selected(shost, SCAN_WILD_CARD, SCAN_WILD_CARD, 1881 SCAN_WILD_CARD, 0); 1882 } 1883 } 1884 1885 static void do_scan_async(void *_data, async_cookie_t c) 1886 { 1887 struct async_scan_data *data = _data; 1888 struct Scsi_Host *shost = data->shost; 1889 1890 do_scsi_scan_host(shost); 1891 scsi_finish_async_scan(data); 1892 } 1893 1894 /** 1895 * scsi_scan_host - scan the given adapter 1896 * @shost: adapter to scan 1897 **/ 1898 void scsi_scan_host(struct Scsi_Host *shost) 1899 { 1900 struct async_scan_data *data; 1901 1902 if (strncmp(scsi_scan_type, "none", 4) == 0) 1903 return; 1904 if (scsi_autopm_get_host(shost) < 0) 1905 return; 1906 1907 data = scsi_prep_async_scan(shost); 1908 if (!data) { 1909 do_scsi_scan_host(shost); 1910 scsi_autopm_put_host(shost); 1911 return; 1912 } 1913 1914 /* register with the async subsystem so wait_for_device_probe() 1915 * will flush this work 1916 */ 1917 async_schedule(do_scan_async, data); 1918 1919 /* scsi_autopm_put_host(shost) is called in scsi_finish_async_scan() */ 1920 } 1921 EXPORT_SYMBOL(scsi_scan_host); 1922 1923 void scsi_forget_host(struct Scsi_Host *shost) 1924 { 1925 struct scsi_device *sdev; 1926 unsigned long flags; 1927 1928 restart: 1929 spin_lock_irqsave(shost->host_lock, flags); 1930 list_for_each_entry(sdev, &shost->__devices, siblings) { 1931 if (sdev->sdev_state == SDEV_DEL) 1932 continue; 1933 spin_unlock_irqrestore(shost->host_lock, flags); 1934 __scsi_remove_device(sdev); 1935 goto restart; 1936 } 1937 spin_unlock_irqrestore(shost->host_lock, flags); 1938 } 1939 1940 /** 1941 * scsi_get_host_dev - Create a scsi_device that points to the host adapter itself 1942 * @shost: Host that needs a scsi_device 1943 * 1944 * Lock status: None assumed. 1945 * 1946 * Returns: The scsi_device or NULL 1947 * 1948 * Notes: 1949 * Attach a single scsi_device to the Scsi_Host - this should 1950 * be made to look like a "pseudo-device" that points to the 1951 * HA itself. 1952 * 1953 * Note - this device is not accessible from any high-level 1954 * drivers (including generics), which is probably not 1955 * optimal. We can add hooks later to attach. 1956 */ 1957 struct scsi_device *scsi_get_host_dev(struct Scsi_Host *shost) 1958 { 1959 struct scsi_device *sdev = NULL; 1960 struct scsi_target *starget; 1961 1962 mutex_lock(&shost->scan_mutex); 1963 if (!scsi_host_scan_allowed(shost)) 1964 goto out; 1965 starget = scsi_alloc_target(&shost->shost_gendev, 0, shost->this_id); 1966 if (!starget) 1967 goto out; 1968 1969 sdev = scsi_alloc_sdev(starget, 0, NULL); 1970 if (sdev) 1971 sdev->borken = 0; 1972 else 1973 scsi_target_reap(starget); 1974 put_device(&starget->dev); 1975 out: 1976 mutex_unlock(&shost->scan_mutex); 1977 return sdev; 1978 } 1979 EXPORT_SYMBOL(scsi_get_host_dev); 1980 1981 /** 1982 * scsi_free_host_dev - Free a scsi_device that points to the host adapter itself 1983 * @sdev: Host device to be freed 1984 * 1985 * Lock status: None assumed. 1986 * 1987 * Returns: Nothing 1988 */ 1989 void scsi_free_host_dev(struct scsi_device *sdev) 1990 { 1991 BUG_ON(sdev->id != sdev->host->this_id); 1992 1993 __scsi_remove_device(sdev); 1994 } 1995 EXPORT_SYMBOL(scsi_free_host_dev); 1996 1997