block/scsi: Provide a limit on the number of integrity segments

Some controllers have a hardware limit on the number of protection
information scatter-gather list segments they can handle.

Introduce a max_integrity_segments limit in the block layer and provide
a new scsi_host_template setting that allows HBA drivers to provide a
value suitable for the hardware.

Add support for honoring the integrity segment limit when merging both
bios and requests.

Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
Signed-off-by: Jens Axboe <axboe@carl.home.kernel.dk>

1 files changed, 18 insertions, 8 deletions

diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index 9ade720422c6..861c0b937ac9 100644
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -968,11 +968,13 @@ static int scsi_init_sgtable(struct request *req, struct scsi_data_buffer *sdb,
  */
 int scsi_init_io(struct scsi_cmnd *cmd, gfp_t gfp_mask)
 {
-        int error = scsi_init_sgtable(cmd->request, &cmd->sdb, gfp_mask);
+        struct request *rq = cmd->request;
+
+        int error = scsi_init_sgtable(rq, &cmd->sdb, gfp_mask);
         if (error)
                 goto err_exit;
 
-        if (blk_bidi_rq(cmd->request)) {
+        if (blk_bidi_rq(rq)) {
                 struct scsi_data_buffer *bidi_sdb = kmem_cache_zalloc(
                         scsi_sdb_cache, GFP_ATOMIC);
                 if (!bidi_sdb) {
@@ -980,28 +982,28 @@ int scsi_init_io(struct scsi_cmnd *cmd, gfp_t gfp_mask)
                         goto err_exit;
                 }
 
-                cmd->request->next_rq->special = bidi_sdb;
-                error = scsi_init_sgtable(cmd->request->next_rq, bidi_sdb,
-                                                                    GFP_ATOMIC);
+                rq->next_rq->special = bidi_sdb;
+                error = scsi_init_sgtable(rq->next_rq, bidi_sdb, GFP_ATOMIC);
                 if (error)
                         goto err_exit;
         }
 
-        if (blk_integrity_rq(cmd->request)) {
+        if (blk_integrity_rq(rq)) {
                 struct scsi_data_buffer *prot_sdb = cmd->prot_sdb;
                 int ivecs, count;
 
                 BUG_ON(prot_sdb == NULL);
-                ivecs = blk_rq_count_integrity_sg(cmd->request);
+                ivecs = blk_rq_count_integrity_sg(rq->q, rq->bio);
 
                 if (scsi_alloc_sgtable(prot_sdb, ivecs, gfp_mask)) {
                         error = BLKPREP_DEFER;
                         goto err_exit;
                 }
 
-                count = blk_rq_map_integrity_sg(cmd->request,
+                count = blk_rq_map_integrity_sg(rq->q, rq->bio,
                                                 prot_sdb->table.sgl);
                 BUG_ON(unlikely(count > ivecs));
+                BUG_ON(unlikely(count > queue_max_integrity_segments(rq->q)));
 
                 cmd->prot_sdb = prot_sdb;
                 cmd->prot_sdb->table.nents = count;
@@ -1625,6 +1627,14 @@ struct request_queue *__scsi_alloc_queue(struct Scsi_Host *shost,
         blk_queue_max_segments(q, min_t(unsigned short, shost->sg_tablesize,
                                         SCSI_MAX_SG_CHAIN_SEGMENTS));
 
+        if (scsi_host_prot_dma(shost)) {
+                shost->sg_prot_tablesize =
+                        min_not_zero(shost->sg_prot_tablesize,
+                                     (unsigned short)SCSI_MAX_PROT_SG_SEGMENTS);
+                BUG_ON(shost->sg_prot_tablesize < shost->sg_tablesize);
+                blk_queue_max_integrity_segments(q, shost->sg_prot_tablesize);
+        }
+
         blk_queue_max_hw_sectors(q, shost->max_sectors);
         blk_queue_bounce_limit(q, scsi_calculate_bounce_limit(shost));
         blk_queue_segment_boundary(q, shost->dma_boundary);