LCOV - code coverage report
Current view: top level - lkbce/drivers/scsi - scsi_scan.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 625 801 78.0 %
Date: 2017-01-25 Functions: 19 34 55.9 %

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

Generated by: LCOV version 1.10