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