include/linux/blk-integrity.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #ifndef _LINUX_BLK_INTEGRITY_H
   3 #define _LINUX_BLK_INTEGRITY_H
   4
   5 #include <linux/blk-mq.h>
   6
   7 struct request;
   8
   9 enum blk_integrity_flags {
  10         BLK_INTEGRITY_VERIFY            = 1 << 0,
  11         BLK_INTEGRITY_GENERATE          = 1 << 1,
  12         BLK_INTEGRITY_DEVICE_CAPABLE    = 1 << 2,
  13         BLK_INTEGRITY_IP_CHECKSUM       = 1 << 3,
  14 };
  15
  16 struct blk_integrity_iter {
  17         void                    *prot_buf;
  18         void                    *data_buf;
  19         sector_t                seed;
  20         unsigned int            data_size;
  21         unsigned short          interval;
  22         unsigned char           tuple_size;
  23         unsigned char           pi_offset;
  24         const char              *disk_name;
  25 };
  26
  27 typedef blk_status_t (integrity_processing_fn) (struct blk_integrity_iter *);
  28 typedef void (integrity_prepare_fn) (struct request *);
  29 typedef void (integrity_complete_fn) (struct request *, unsigned int);
  30
  31 struct blk_integrity_profile {
  32         integrity_processing_fn         *generate_fn;
  33         integrity_processing_fn         *verify_fn;
  34         integrity_prepare_fn            *prepare_fn;
  35         integrity_complete_fn           *complete_fn;
  36         const char                      *name;
  37 };
  38
  39 #ifdef CONFIG_BLK_DEV_INTEGRITY
  40 void blk_integrity_register(struct gendisk *, struct blk_integrity *);
  41 void blk_integrity_unregister(struct gendisk *);
  42 int blk_integrity_compare(struct gendisk *, struct gendisk *);
  43 int blk_rq_map_integrity_sg(struct request_queue *, struct bio *,
  44                                    struct scatterlist *);
  45 int blk_rq_count_integrity_sg(struct request_queue *, struct bio *);
  46
  47 static inline struct blk_integrity *blk_get_integrity(struct gendisk *disk)
  48 {
  49         struct blk_integrity *bi = &disk->queue->integrity;
  50
  51         if (!bi->profile)
  52                 return NULL;
  53
  54         return bi;
  55 }
  56
  57 static inline struct blk_integrity *
  58 bdev_get_integrity(struct block_device *bdev)
  59 {
  60         return blk_get_integrity(bdev->bd_disk);
  61 }
  62
  63 static inline bool
  64 blk_integrity_queue_supports_integrity(struct request_queue *q)
  65 {
  66         return q->integrity.profile;
  67 }
  68
  69 static inline void blk_queue_max_integrity_segments(struct request_queue *q,
  70                                                     unsigned int segs)
  71 {
  72         q->limits.max_integrity_segments = segs;
  73 }
  74
  75 static inline unsigned short
  76 queue_max_integrity_segments(const struct request_queue *q)
  77 {
  78         return q->limits.max_integrity_segments;
  79 }
  80
  81 /**
  82  * bio_integrity_intervals - Return number of integrity intervals for a bio
  83  * @bi:         blk_integrity profile for device
  84  * @sectors:    Size of the bio in 512-byte sectors
  85  *
  86  * Description: The block layer calculates everything in 512 byte
  87  * sectors but integrity metadata is done in terms of the data integrity
  88  * interval size of the storage device.  Convert the block layer sectors
  89  * to the appropriate number of integrity intervals.
  90  */
  91 static inline unsigned int bio_integrity_intervals(struct blk_integrity *bi,
  92                                                    unsigned int sectors)
  93 {
  94         return sectors >> (bi->interval_exp - 9);
  95 }
  96
  97 static inline unsigned int bio_integrity_bytes(struct blk_integrity *bi,
  98                                                unsigned int sectors)
  99 {
 100         return bio_integrity_intervals(bi, sectors) * bi->tuple_size;
 101 }
 102
 103 static inline bool blk_integrity_rq(struct request *rq)
 104 {
 105         return rq->cmd_flags & REQ_INTEGRITY;
 106 }
 107
 108 /*
 109  * Return the first bvec that contains integrity data.  Only drivers that are
 110  * limited to a single integrity segment should use this helper.
 111  */
 112 static inline struct bio_vec *rq_integrity_vec(struct request *rq)
 113 {
 114         if (WARN_ON_ONCE(queue_max_integrity_segments(rq->q) > 1))
 115                 return NULL;
 116         return rq->bio->bi_integrity->bip_vec;
 117 }
 118 #else /* CONFIG_BLK_DEV_INTEGRITY */
 119 static inline int blk_rq_count_integrity_sg(struct request_queue *q,
 120                                             struct bio *b)
 121 {
 122         return 0;
 123 }
 124 static inline int blk_rq_map_integrity_sg(struct request_queue *q,
 125                                           struct bio *b,
 126                                           struct scatterlist *s)
 127 {
 128         return 0;
 129 }
 130 static inline struct blk_integrity *bdev_get_integrity(struct block_device *b)
 131 {
 132         return NULL;
 133 }
 134 static inline struct blk_integrity *blk_get_integrity(struct gendisk *disk)
 135 {
 136         return NULL;
 137 }
 138 static inline bool
 139 blk_integrity_queue_supports_integrity(struct request_queue *q)
 140 {
 141         return false;
 142 }
 143 static inline int blk_integrity_compare(struct gendisk *a, struct gendisk *b)
 144 {
 145         return 0;
 146 }
 147 static inline void blk_integrity_register(struct gendisk *d,
 148                                          struct blk_integrity *b)
 149 {
 150 }
 151 static inline void blk_integrity_unregister(struct gendisk *d)
 152 {
 153 }
 154 static inline void blk_queue_max_integrity_segments(struct request_queue *q,
 155                                                     unsigned int segs)
 156 {
 157 }
 158 static inline unsigned short
 159 queue_max_integrity_segments(const struct request_queue *q)
 160 {
 161         return 0;
 162 }
 163
 164 static inline unsigned int bio_integrity_intervals(struct blk_integrity *bi,
 165                                                    unsigned int sectors)
 166 {
 167         return 0;
 168 }
 169
 170 static inline unsigned int bio_integrity_bytes(struct blk_integrity *bi,
 171                                                unsigned int sectors)
 172 {
 173         return 0;
 174 }
 175 static inline int blk_integrity_rq(struct request *rq)
 176 {
 177         return 0;
 178 }
 179
 180 static inline struct bio_vec *rq_integrity_vec(struct request *rq)
 181 {
 182         return NULL;
 183 }
 184 #endif /* CONFIG_BLK_DEV_INTEGRITY */
 185 #endif /* _LINUX_BLK_INTEGRITY_H */