Merge branch 'perf-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...

[deliverable/linux.git] / drivers / scsi / scsi_scan.c

diff --git a/drivers/scsi/scsi_scan.c b/drivers/scsi/scsi_scan.c
index 983aed10ff2f8d97c9d34254768ecd3ec819ab9b..9c0a520d933c91eaaf793a259ba099d87c8d3176 100644 (file)
--- a/drivers/scsi/scsi_scan.c
+++ b/drivers/scsi/scsi_scan.c
@@ -34,6 +34,7 @@
 #include <linux/spinlock.h>
 #include <linux/async.h>
 #include <linux/slab.h>
+#include <asm/unaligned.h>
 
 #include <scsi/scsi.h>
 #include <scsi/scsi_cmnd.h>
@@ -98,20 +99,6 @@ char scsi_scan_type[6] = SCSI_SCAN_TYPE_DEFAULT;
 module_param_string(scan, scsi_scan_type, sizeof(scsi_scan_type), S_IRUGO);
 MODULE_PARM_DESC(scan, "sync, async or none");
 
-/*
- * max_scsi_report_luns: the maximum number of LUNS that will be
- * returned from the REPORT LUNS command. 8 times this value must
- * be allocated. In theory this could be up to an 8 byte value, but
- * in practice, the maximum number of LUNs suppored by any device
- * is about 16k.
- */
-static unsigned int max_scsi_report_luns = 511;
-
-module_param_named(max_report_luns, max_scsi_report_luns, uint, S_IRUGO|S_IWUSR);
-MODULE_PARM_DESC(max_report_luns,
-                "REPORT LUNS maximum number of LUNS received (should be"
-                " between 1 and 16384)");
-
 static unsigned int scsi_inq_timeout = SCSI_TIMEOUT/HZ + 18;
 
 module_param_named(inq_timeout, scsi_inq_timeout, uint, S_IRUGO|S_IWUSR);
@@ -290,7 +277,8 @@ static struct scsi_device *scsi_alloc_sdev(struct scsi_target *starget,
        if (!shost_use_blk_mq(sdev->host) &&
            (shost->bqt || shost->hostt->use_blk_tags)) {
                blk_queue_init_tags(sdev->request_queue,
-                                   sdev->host->cmd_per_lun, shost->bqt);
+                                   sdev->host->cmd_per_lun, shost->bqt,
+                                   shost->hostt->tag_alloc_policy);
        }
        scsi_change_queue_depth(sdev, sdev->host->cmd_per_lun);
 
@@ -1367,7 +1355,6 @@ static int scsi_report_lun_scan(struct scsi_target *starget, int bflags,
        unsigned int retries;
        int result;
        struct scsi_lun *lunp, *lun_data;
-       u8 *data;
        struct scsi_sense_hdr sshdr;
        struct scsi_device *sdev;
        struct Scsi_Host *shost = dev_to_shost(&starget->dev);
@@ -1407,16 +1394,12 @@ static int scsi_report_lun_scan(struct scsi_target *starget, int bflags,
 
        /*
         * Allocate enough to hold the header (the same size as one scsi_lun)
-        * plus the max number of luns we are requesting.
-        *
-        * Reallocating and trying again (with the exact amount we need)
-        * would be nice, but then we need to somehow limit the size
-        * allocated based on the available memory and the limits of
-        * kmalloc - we don't want a kmalloc() failure of a huge value to
-        * prevent us from finding any LUNs on this target.
+        * plus the number of luns we are requesting.  511 was the default
+        * value of the now removed max_report_luns parameter.
         */
-       length = (max_scsi_report_luns + 1) * sizeof(struct scsi_lun);
-       lun_data = kmalloc(length, GFP_ATOMIC |
+       length = (511 + 1) * sizeof(struct scsi_lun);
+retry:
+       lun_data = kmalloc(length, GFP_KERNEL |
                           (sdev->host->unchecked_isa_dma ? __GFP_DMA : 0));
        if (!lun_data) {
                printk(ALLOC_FAILURE_MSG, __func__);
@@ -1433,10 +1416,7 @@ static int scsi_report_lun_scan(struct scsi_target *starget, int bflags,
        /*
         * bytes 6 - 9: length of the command.
         */
-       scsi_cmd[6] = (unsigned char) (length >> 24) & 0xff;
-       scsi_cmd[7] = (unsigned char) (length >> 16) & 0xff;
-       scsi_cmd[8] = (unsigned char) (length >> 8) & 0xff;
-       scsi_cmd[9] = (unsigned char) length & 0xff;
+       put_unaligned_be32(length, &scsi_cmd[6]);
 
        scsi_cmd[10] = 0;       /* reserved */
        scsi_cmd[11] = 0;       /* control */
@@ -1484,19 +1464,16 @@ static int scsi_report_lun_scan(struct scsi_target *starget, int bflags,
        /*
         * Get the length from the first four bytes of lun_data.
         */
-       data = (u8 *) lun_data->scsi_lun;
-       length = ((data[0] << 24) | (data[1] << 16) |
-                 (data[2] << 8) | (data[3] << 0));
+       if (get_unaligned_be32(lun_data->scsi_lun) +
+           sizeof(struct scsi_lun) > length) {
+               length = get_unaligned_be32(lun_data->scsi_lun) +
+                        sizeof(struct scsi_lun);
+               kfree(lun_data);
+               goto retry;
+       }
+       length = get_unaligned_be32(lun_data->scsi_lun);
 
        num_luns = (length / sizeof(struct scsi_lun));
-       if (num_luns > max_scsi_report_luns) {
-               sdev_printk(KERN_WARNING, sdev,
-                           "Only %d (max_scsi_report_luns)"
-                           " of %d luns reported, try increasing"
-                           " max_scsi_report_luns.\n",
-                           max_scsi_report_luns, num_luns);
-               num_luns = max_scsi_report_luns;
-       }
 
        SCSI_LOG_SCAN_BUS(3, sdev_printk (KERN_INFO, sdev,
                "scsi scan: REPORT LUN scan\n"));