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