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