include/linux/blk-integrity.h

0001 /* SPDX-License-Identifier: GPL-2.0 */
0002 #ifndef _LINUX_BLK_INTEGRITY_H
0003 #define _LINUX_BLK_INTEGRITY_H
0004
0005 #include <linux/blk-mq.h>
0006
0007 struct request;
0008
0009 enum blk_integrity_flags {
0010     BLK_INTEGRITY_VERIFY        = 1 << 0,
0011     BLK_INTEGRITY_GENERATE      = 1 << 1,
0012     BLK_INTEGRITY_DEVICE_CAPABLE    = 1 << 2,
0013     BLK_INTEGRITY_IP_CHECKSUM   = 1 << 3,
0014 };
0015
0016 struct blk_integrity_iter {
0017     void            *prot_buf;
0018     void            *data_buf;
0019     sector_t        seed;
0020     unsigned int        data_size;
0021     unsigned short      interval;
0022     unsigned char       tuple_size;
0023     const char      *disk_name;
0024 };
0025
0026 typedef blk_status_t (integrity_processing_fn) (struct blk_integrity_iter *);
0027 typedef void (integrity_prepare_fn) (struct request *);
0028 typedef void (integrity_complete_fn) (struct request *, unsigned int);
0029
0030 struct blk_integrity_profile {
0031     integrity_processing_fn     *generate_fn;
0032     integrity_processing_fn     *verify_fn;
0033     integrity_prepare_fn        *prepare_fn;
0034     integrity_complete_fn       *complete_fn;
0035     const char          *name;
0036 };
0037
0038 #ifdef CONFIG_BLK_DEV_INTEGRITY
0039 void blk_integrity_register(struct gendisk *, struct blk_integrity *);
0040 void blk_integrity_unregister(struct gendisk *);
0041 int blk_integrity_compare(struct gendisk *, struct gendisk *);
0042 int blk_rq_map_integrity_sg(struct request_queue *, struct bio *,
0043                    struct scatterlist *);
0044 int blk_rq_count_integrity_sg(struct request_queue *, struct bio *);
0045
0046 static inline struct blk_integrity *blk_get_integrity(struct gendisk *disk)
0047 {
0048     struct blk_integrity *bi = &disk->queue->integrity;
0049
0050     if (!bi->profile)
0051         return NULL;
0052
0053     return bi;
0054 }
0055
0056 static inline struct blk_integrity *
0057 bdev_get_integrity(struct block_device *bdev)
0058 {
0059     return blk_get_integrity(bdev->bd_disk);
0060 }
0061
0062 static inline bool
0063 blk_integrity_queue_supports_integrity(struct request_queue *q)
0064 {
0065     return q->integrity.profile;
0066 }
0067
0068 static inline void blk_queue_max_integrity_segments(struct request_queue *q,
0069                             unsigned int segs)
0070 {
0071     q->limits.max_integrity_segments = segs;
0072 }
0073
0074 static inline unsigned short
0075 queue_max_integrity_segments(const struct request_queue *q)
0076 {
0077     return q->limits.max_integrity_segments;
0078 }
0079
0080 /**
0081  * bio_integrity_intervals - Return number of integrity intervals for a bio
0082  * @bi:     blk_integrity profile for device
0083  * @sectors:    Size of the bio in 512-byte sectors
0084  *
0085  * Description: The block layer calculates everything in 512 byte
0086  * sectors but integrity metadata is done in terms of the data integrity
0087  * interval size of the storage device.  Convert the block layer sectors
0088  * to the appropriate number of integrity intervals.
0089  */
0090 static inline unsigned int bio_integrity_intervals(struct blk_integrity *bi,
0091                            unsigned int sectors)
0092 {
0093     return sectors >> (bi->interval_exp - 9);
0094 }
0095
0096 static inline unsigned int bio_integrity_bytes(struct blk_integrity *bi,
0097                            unsigned int sectors)
0098 {
0099     return bio_integrity_intervals(bi, sectors) * bi->tuple_size;
0100 }
0101
0102 static inline bool blk_integrity_rq(struct request *rq)
0103 {
0104     return rq->cmd_flags & REQ_INTEGRITY;
0105 }
0106
0107 /*
0108  * Return the first bvec that contains integrity data.  Only drivers that are
0109  * limited to a single integrity segment should use this helper.
0110  */
0111 static inline struct bio_vec *rq_integrity_vec(struct request *rq)
0112 {
0113     if (WARN_ON_ONCE(queue_max_integrity_segments(rq->q) > 1))
0114         return NULL;
0115     return rq->bio->bi_integrity->bip_vec;
0116 }
0117 #else /* CONFIG_BLK_DEV_INTEGRITY */
0118 static inline int blk_rq_count_integrity_sg(struct request_queue *q,
0119                         struct bio *b)
0120 {
0121     return 0;
0122 }
0123 static inline int blk_rq_map_integrity_sg(struct request_queue *q,
0124                       struct bio *b,
0125                       struct scatterlist *s)
0126 {
0127     return 0;
0128 }
0129 static inline struct blk_integrity *bdev_get_integrity(struct block_device *b)
0130 {
0131     return NULL;
0132 }
0133 static inline struct blk_integrity *blk_get_integrity(struct gendisk *disk)
0134 {
0135     return NULL;
0136 }
0137 static inline bool
0138 blk_integrity_queue_supports_integrity(struct request_queue *q)
0139 {
0140     return false;
0141 }
0142 static inline int blk_integrity_compare(struct gendisk *a, struct gendisk *b)
0143 {
0144     return 0;
0145 }
0146 static inline void blk_integrity_register(struct gendisk *d,
0147                      struct blk_integrity *b)
0148 {
0149 }
0150 static inline void blk_integrity_unregister(struct gendisk *d)
0151 {
0152 }
0153 static inline void blk_queue_max_integrity_segments(struct request_queue *q,
0154                             unsigned int segs)
0155 {
0156 }
0157 static inline unsigned short
0158 queue_max_integrity_segments(const struct request_queue *q)
0159 {
0160     return 0;
0161 }
0162
0163 static inline unsigned int bio_integrity_intervals(struct blk_integrity *bi,
0164                            unsigned int sectors)
0165 {
0166     return 0;
0167 }
0168
0169 static inline unsigned int bio_integrity_bytes(struct blk_integrity *bi,
0170                            unsigned int sectors)
0171 {
0172     return 0;
0173 }
0174 static inline int blk_integrity_rq(struct request *rq)
0175 {
0176     return 0;
0177 }
0178
0179 static inline struct bio_vec *rq_integrity_vec(struct request *rq)
0180 {
0181     return NULL;
0182 }
0183 #endif /* CONFIG_BLK_DEV_INTEGRITY */
0184 #endif /* _LINUX_BLK_INTEGRITY_H */