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, 29 insertions, 4 deletions

diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index 2c54906f678f..7e661106270a 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -124,6 +124,9 @@ struct request {
          * physical address coalescing is performed.
          */
         unsigned short nr_phys_segments;
+#if defined(CONFIG_BLK_DEV_INTEGRITY)
+        unsigned short nr_integrity_segments;
+#endif
 
         unsigned short ioprio;
 
@@ -243,6 +246,7 @@ struct queue_limits {
 
         unsigned short          logical_block_size;
         unsigned short          max_segments;
+        unsigned short          max_integrity_segments;
 
         unsigned char           misaligned;
         unsigned char           discard_misaligned;
@@ -1213,8 +1217,13 @@ struct blk_integrity {
 extern int blk_integrity_register(struct gendisk *, struct blk_integrity *);
 extern void blk_integrity_unregister(struct gendisk *);
 extern int blk_integrity_compare(struct gendisk *, struct gendisk *);
-extern int blk_rq_map_integrity_sg(struct request *, struct scatterlist *);
-extern int blk_rq_count_integrity_sg(struct request *);
+extern int blk_rq_map_integrity_sg(struct request_queue *, struct bio *,
+                                   struct scatterlist *);
+extern int blk_rq_count_integrity_sg(struct request_queue *, struct bio *);
+extern int blk_integrity_merge_rq(struct request_queue *, struct request *,
+                                  struct request *);
+extern int blk_integrity_merge_bio(struct request_queue *, struct request *,
+                                   struct bio *);
 
 static inline
 struct blk_integrity *bdev_get_integrity(struct block_device *bdev)
@@ -1235,16 +1244,32 @@ static inline int blk_integrity_rq(struct request *rq)
         return bio_integrity(rq->bio);
 }
 
+static inline void blk_queue_max_integrity_segments(struct request_queue *q,
+                                                    unsigned int segs)
+{
+        q->limits.max_integrity_segments = segs;
+}
+
+static inline unsigned short
+queue_max_integrity_segments(struct request_queue *q)
+{
+        return q->limits.max_integrity_segments;
+}
+
 #else /* CONFIG_BLK_DEV_INTEGRITY */
 
 #define blk_integrity_rq(rq)                    (0)
-#define blk_rq_count_integrity_sg(a)            (0)
-#define blk_rq_map_integrity_sg(a, b)           (0)
+#define blk_rq_count_integrity_sg(a, b)         (0)
+#define blk_rq_map_integrity_sg(a, b, c)        (0)
 #define bdev_get_integrity(a)                   (0)
 #define blk_get_integrity(a)                    (0)
 #define blk_integrity_compare(a, b)             (0)
 #define blk_integrity_register(a, b)            (0)
 #define blk_integrity_unregister(a)             do { } while (0);
+#define blk_queue_max_integrity_segments(a, b)  do { } while (0);
+#define queue_max_integrity_segments(a)         (0)
+#define blk_integrity_merge_rq(a, b, c)         (0)
+#define blk_integrity_merge_bio(a, b, c)        (0)
 
 #endif /* CONFIG_BLK_DEV_INTEGRITY */