iSCSI-block-sd-Fix-device-imposed-transfer-length-limits.patch

   1 diff -Naur a/block/blk-settings.c b/block/blk-settings.c
   2 --- a/block/blk-settings.c      2015-12-01 18:36:05.000000000 +0100
   3 +++ b/block/blk-settings.c      2015-12-18 12:02:27.076000000 +0100
   4 @@ -112,7 +112,7 @@
   5         lim->max_integrity_segments = 0;
   6         lim->seg_boundary_mask = BLK_SEG_BOUNDARY_MASK;
   7         lim->max_segment_size = BLK_MAX_SEGMENT_SIZE;
   8 -       lim->max_sectors = lim->max_hw_sectors = BLK_SAFE_MAX_SECTORS;
   9 +       lim->max_sectors = lim->max_dev_sectors = lim->max_hw_sectors = BLK_SAFE_MAX_SECTORS;
  10         lim->chunk_sectors = 0;
  11         lim->max_write_same_sectors = 0;
  12         lim->max_discard_sectors = 0;
  13 @@ -147,6 +147,7 @@
  14         lim->max_hw_sectors = UINT_MAX;
  15         lim->max_segment_size = UINT_MAX;
  16         lim->max_sectors = UINT_MAX;
  17 +       lim->max_dev_sectors = UINT_MAX;
  18         lim->max_write_same_sectors = UINT_MAX;
  19  }
  20  EXPORT_SYMBOL(blk_set_stacking_limits);
  21 @@ -544,6 +540,7 @@
  22
  23         t->max_sectors = min_not_zero(t->max_sectors, b->max_sectors);
  24         t->max_hw_sectors = min_not_zero(t->max_hw_sectors, b->max_hw_sectors);
  25 +       t->max_dev_sectors = min_not_zero(t->max_dev_sectors, b->max_dev_sectors);
  26         t->max_write_same_sectors = min(t->max_write_same_sectors,
  27                                         b->max_write_same_sectors);
  28         t->bounce_pfn = min_not_zero(t->bounce_pfn, b->bounce_pfn);
  29 diff -Naur a/block/blk-sysfs.c b/block/blk-sysfs.c
  30 --- a/block/blk-sysfs.c 2015-12-01 18:36:05.000000000 +0100
  31 +++ b/block/blk-sysfs.c 2015-12-18 12:06:20.040000000 +0100
  32 @@ -174,6 +174,9 @@
  33         if (ret < 0)
  34                 return ret;
  35
  36 +       max_hw_sectors_kb = min_not_zero(max_hw_sectors_kb, (unsigned long)
  37 +                                       q->limits.max_dev_sectors >> 1);
  38 +
  39         if (max_sectors_kb > max_hw_sectors_kb || max_sectors_kb < page_kb)
  40                 return -EINVAL;
  41
  42 diff -Naur a/drivers/scsi/sd.c b/drivers/scsi/sd.c
  43 --- a/drivers/scsi/sd.c 2015-12-01 18:36:07.000000000 +0100
  44 +++ b/drivers/scsi/sd.c 2015-12-18 13:27:08.472000000 +0100
  45 @@ -2224,11 +2224,8 @@
  46                 }
  47         }
  48
  49 -       if (sdkp->capacity > 0xffffffff) {
  50 +       if (sdkp->capacity > 0xffffffff)
  51                 sdp->use_16_for_rw = 1;
  52 -               sdkp->max_xfer_blocks = SD_MAX_XFER_BLOCKS;
  53 -       } else
  54 -               sdkp->max_xfer_blocks = SD_DEF_XFER_BLOCKS;
  55
  56         /* Rescale capacity to 512-byte units */
  57         if (sector_size == 4096)
  58 @@ -2545,7 +2542,6 @@
  59  {
  60         unsigned int sector_sz = sdkp->device->sector_size;
  61         const int vpd_len = 64;
  62 -       u32 max_xfer_length;
  63         unsigned char *buffer = kmalloc(vpd_len, GFP_KERNEL);
  64
  65         if (!buffer ||
  66 @@ -2553,14 +2549,11 @@
  67             scsi_get_vpd_page(sdkp->device, 0xb0, buffer, vpd_len))
  68                 goto out;
  69
  70 -       max_xfer_length = get_unaligned_be32(&buffer[8]);
  71 -       if (max_xfer_length)
  72 -               sdkp->max_xfer_blocks = max_xfer_length;
  73 -
  74         blk_queue_io_min(sdkp->disk->queue,
  75                          get_unaligned_be16(&buffer[6]) * sector_sz);
  76 -       blk_queue_io_opt(sdkp->disk->queue,
  77 -                        get_unaligned_be32(&buffer[12]) * sector_sz);
  78 +
  79 +       sdkp->max_xfer_blocks = get_unaligned_be32(&buffer[8]);
  80 +       sdkp->opt_xfer_blocks = get_unaligned_be32(&buffer[12]);
  81
  82         if (buffer[3] == 0x3c) {
  83                 unsigned int lba_count, desc_count;
  84 @@ -2709,6 +2702,11 @@
  85         return 0;
  86  }
  87
  88 +static inline u32 logical_to_sectors(struct scsi_device *sdev, u32 blocks)
  89 +{
  90 +       return blocks << (ilog2(sdev->sector_size) - 9);
  91 +}
  92 +
  93  /**
  94   *     sd_revalidate_disk - called the first time a new disk is seen,
  95   *     performs disk spin up, read_capacity, etc.
  96 @@ -2718,8 +2716,9 @@
  97  {
  98         struct scsi_disk *sdkp = scsi_disk(disk);
  99         struct scsi_device *sdp = sdkp->device;
 100 +       struct request_queue *q = sdkp->disk->queue;
 101         unsigned char *buffer;
 102 -       unsigned int max_xfer;
 103 +       unsigned int dev_max, rw_max;
 104
 105         SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp,
 106                                       "sd_revalidate_disk\n"));
 107 @@ -2767,11 +2766,26 @@
 108          */
 109         sd_set_flush_flag(sdkp);
 110
 111 -       max_xfer = sdkp->max_xfer_blocks;
 112 -       max_xfer <<= ilog2(sdp->sector_size) - 9;
 113 +       /* Initial block count limit based on CDB TRANSFER LENGTH field size. */
 114 +       dev_max = sdp->use_16_for_rw ? SD_MAX_XFER_BLOCKS : SD_DEF_XFER_BLOCKS;
 115 +
 116 +       /* Some devices report a maximum block count for READ/WRITE requests. */
 117 +       dev_max = min_not_zero(dev_max, sdkp->max_xfer_blocks);
 118 +       q->limits.max_dev_sectors = logical_to_sectors(sdp, dev_max);
 119 +
 120 +       /*
 121 +        * Use the device's preferred I/O size for reads and writes
 122 +        * unless the reported value is unreasonably large (or garbage).
 123 +        */
 124 +       if (sdkp->opt_xfer_blocks && sdkp->opt_xfer_blocks <= dev_max &&
 125 +           sdkp->opt_xfer_blocks <= SD_DEF_XFER_BLOCKS)
 126 +               rw_max = q->limits.io_opt =
 127 +               sdkp->opt_xfer_blocks * sdp->sector_size;
 128 +       else
 129 +               rw_max = BLK_DEF_MAX_SECTORS;
 130
 131 -       sdkp->disk->queue->limits.max_sectors =
 132 -               min_not_zero(queue_max_hw_sectors(sdkp->disk->queue), max_xfer);
 133 +       /* Combine with controller limits */
 134 +       q->limits.max_sectors = min(rw_max, queue_max_hw_sectors(q));
 135
 136         set_capacity(disk, sdkp->capacity);
 137         sd_config_write_same(sdkp);
 138 diff -Naur a/drivers/scsi/sd.h b/drivers/scsi/sd.h
 139 --- a/drivers/scsi/sd.h 2015-12-01 18:36:07.000000000 +0100
 140 +++ b/drivers/scsi/sd.h 2015-12-18 13:28:56.716000000 +0100
 141 @@ -67,6 +67,7 @@
 142         atomic_t        openers;
 143         sector_t        capacity;       /* size in 512-byte sectors */
 144         u32             max_xfer_blocks;
 145 +       u32             opt_xfer_blocks;
 146         u32             max_ws_blocks;
 147         u32             max_unmap_blocks;
 148         u32             unmap_granularity;
 149 diff -Naur a/include/linux/blkdev.h b/include/linux/blkdev.h
 150 --- a/include/linux/blkdev.h    2015-12-01 18:36:07.000000000 +0100
 151 +++ b/include/linux/blkdev.h    2015-12-18 13:30:55.772000000 +0100
 152 @@ -260,6 +260,7 @@
 153         unsigned long           seg_boundary_mask;
 154
 155         unsigned int            max_hw_sectors;
 156 +       unsigned int            max_dev_sectors;
 157         unsigned int            chunk_sectors;
 158         unsigned int            max_sectors;
 159         unsigned int            max_segment_size;
 160 @@ -1138,6 +1138,7 @@
 161  enum blk_default_limits {
 162         BLK_MAX_SEGMENTS        = 128,
 163         BLK_SAFE_MAX_SECTORS    = 255,
 164 +       BLK_DEF_MAX_SECTORS     = 2560,
 165         BLK_MAX_SEGMENT_SIZE    = 65536,
 166         BLK_SEG_BOUNDARY_MASK   = 0xFFFFFFFFUL,
 167  };