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