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 unsigned short
  70 queue_max_integrity_segments(const struct request_queue *q)
  71 {
  72         return q->limits.max_integrity_segments;
  73 }
  74
  75 /**
  76  * bio_integrity_intervals - Return number of integrity intervals for a bio
  77  * @bi:         blk_integrity profile for device
  78  * @sectors:    Size of the bio in 512-byte sectors
  79  *
  80  * Description: The block layer calculates everything in 512 byte
  81  * sectors but integrity metadata is done in terms of the data integrity
  82  * interval size of the storage device.  Convert the block layer sectors
  83  * to the appropriate number of integrity intervals.
  84  */
  85 static inline unsigned int bio_integrity_intervals(struct blk_integrity *bi,
  86                                                    unsigned int sectors)
  87 {
  88         return sectors >> (bi->interval_exp - 9);
  89 }
  90
  91 static inline unsigned int bio_integrity_bytes(struct blk_integrity *bi,
  92                                                unsigned int sectors)
  93 {
  94         return bio_integrity_intervals(bi, sectors) * bi->tuple_size;
  95 }
  96
  97 static inline bool blk_integrity_rq(struct request *rq)
  98 {
  99         return rq->cmd_flags & REQ_INTEGRITY;
 100 }
 101
 102 /*
 103  * Return the first bvec that contains integrity data.  Only drivers that are
 104  * limited to a single integrity segment should use this helper.
 105  */
 106 static inline struct bio_vec *rq_integrity_vec(struct request *rq)
 107 {
 108         if (WARN_ON_ONCE(queue_max_integrity_segments(rq->q) > 1))
 109                 return NULL;
 110         return rq->bio->bi_integrity->bip_vec;
 111 }
 112 #else /* CONFIG_BLK_DEV_INTEGRITY */
 113 static inline int blk_rq_count_integrity_sg(struct request_queue *q,
 114                                             struct bio *b)
 115 {
 116         return 0;
 117 }
 118 static inline int blk_rq_map_integrity_sg(struct request_queue *q,
 119                                           struct bio *b,
 120                                           struct scatterlist *s)
 121 {
 122         return 0;
 123 }
 124 static inline struct blk_integrity *bdev_get_integrity(struct block_device *b)
 125 {
 126         return NULL;
 127 }
 128 static inline struct blk_integrity *blk_get_integrity(struct gendisk *disk)
 129 {
 130         return NULL;
 131 }
 132 static inline bool
 133 blk_integrity_queue_supports_integrity(struct request_queue *q)
 134 {
 135         return false;
 136 }
 137 static inline int blk_integrity_compare(struct gendisk *a, struct gendisk *b)
 138 {
 139         return 0;
 140 }
 141 static inline void blk_integrity_register(struct gendisk *d,
 142                                          struct blk_integrity *b)
 143 {
 144 }
 145 static inline void blk_integrity_unregister(struct gendisk *d)
 146 {
 147 }
 148 static inline unsigned short
 149 queue_max_integrity_segments(const struct request_queue *q)
 150 {
 151         return 0;
 152 }
 153
 154 static inline unsigned int bio_integrity_intervals(struct blk_integrity *bi,
 155                                                    unsigned int sectors)
 156 {
 157         return 0;
 158 }
 159
 160 static inline unsigned int bio_integrity_bytes(struct blk_integrity *bi,
 161                                                unsigned int sectors)
 162 {
 163         return 0;
 164 }
 165 static inline int blk_integrity_rq(struct request *rq)
 166 {
 167         return 0;
 168 }
 169
 170 static inline struct bio_vec *rq_integrity_vec(struct request *rq)
 171 {
 172         return NULL;
 173 }
 174 #endif /* CONFIG_BLK_DEV_INTEGRITY */
 175 #endif /* _LINUX_BLK_INTEGRITY_H */