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