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 #include <linux/bio-integrity.h>
7 #include <linux/blk-mq-dma.h>
8
9 struct request;
10
11 /*
12 * Maximum contiguous integrity buffer allocation.
13 */
14 #define BLK_INTEGRITY_MAX_SIZE SZ_2M
15
16 enum blk_integrity_flags {
17 BLK_INTEGRITY_NOVERIFY = 1 << 0,
18 BLK_INTEGRITY_NOGENERATE = 1 << 1,
19 BLK_INTEGRITY_DEVICE_CAPABLE = 1 << 2,
20 BLK_INTEGRITY_REF_TAG = 1 << 3,
21 BLK_INTEGRITY_STACKED = 1 << 4,
22 };
23
24 const char *blk_integrity_profile_name(struct blk_integrity *bi);
25 bool queue_limits_stack_integrity(struct queue_limits *t,
26 struct queue_limits *b);
queue_limits_stack_integrity_bdev(struct queue_limits * t,struct block_device * bdev)27 static inline bool queue_limits_stack_integrity_bdev(struct queue_limits *t,
28 struct block_device *bdev)
29 {
30 return queue_limits_stack_integrity(t, &bdev->bd_disk->queue->limits);
31 }
32
33 #ifdef CONFIG_BLK_DEV_INTEGRITY
34 int blk_rq_map_integrity_sg(struct request *, struct scatterlist *);
35
36 int blk_rq_count_integrity_sg(struct request_queue *, struct bio *);
37 int blk_rq_integrity_map_user(struct request *rq, void __user *ubuf,
38 ssize_t bytes);
39 int blk_get_meta_cap(struct block_device *bdev, unsigned int cmd,
40 struct logical_block_metadata_cap __user *argp);
41 bool blk_rq_integrity_dma_map_iter_start(struct request *req,
42 struct device *dma_dev, struct dma_iova_state *state,
43 struct blk_dma_iter *iter);
44 bool blk_rq_integrity_dma_map_iter_next(struct request *req,
45 struct device *dma_dev, struct blk_dma_iter *iter);
46
47 static inline bool
blk_integrity_queue_supports_integrity(struct request_queue * q)48 blk_integrity_queue_supports_integrity(struct request_queue *q)
49 {
50 return q->limits.integrity.metadata_size;
51 }
52
blk_get_integrity(struct gendisk * disk)53 static inline struct blk_integrity *blk_get_integrity(struct gendisk *disk)
54 {
55 if (!blk_integrity_queue_supports_integrity(disk->queue))
56 return NULL;
57 return &disk->queue->limits.integrity;
58 }
59
60 static inline struct blk_integrity *
bdev_get_integrity(struct block_device * bdev)61 bdev_get_integrity(struct block_device *bdev)
62 {
63 return blk_get_integrity(bdev->bd_disk);
64 }
65
66 static inline unsigned short
queue_max_integrity_segments(const struct request_queue * q)67 queue_max_integrity_segments(const struct request_queue *q)
68 {
69 return q->limits.max_integrity_segments;
70 }
71
72 /**
73 * bio_integrity_intervals - Return number of integrity intervals for a bio
74 * @bi: blk_integrity profile for device
75 * @sectors: Size of the bio in 512-byte sectors
76 *
77 * Description: The block layer calculates everything in 512 byte
78 * sectors but integrity metadata is done in terms of the data integrity
79 * interval size of the storage device. Convert the block layer sectors
80 * to the appropriate number of integrity intervals.
81 */
bio_integrity_intervals(struct blk_integrity * bi,unsigned int sectors)82 static inline unsigned int bio_integrity_intervals(struct blk_integrity *bi,
83 unsigned int sectors)
84 {
85 return sectors >> (bi->interval_exp - 9);
86 }
87
bio_integrity_bytes(struct blk_integrity * bi,unsigned int sectors)88 static inline unsigned int bio_integrity_bytes(struct blk_integrity *bi,
89 unsigned int sectors)
90 {
91 return bio_integrity_intervals(bi, sectors) * bi->metadata_size;
92 }
93
blk_integrity_rq(const struct request * rq)94 static inline bool blk_integrity_rq(const struct request *rq)
95 {
96 return rq->cmd_flags & REQ_INTEGRITY;
97 }
98
99 /*
100 * Return the current bvec that contains the integrity data. bip_iter may be
101 * advanced to iterate over the integrity data.
102 */
rq_integrity_vec(struct request * rq)103 static inline struct bio_vec rq_integrity_vec(struct request *rq)
104 {
105 return mp_bvec_iter_bvec(rq->bio->bi_integrity->bip_vec,
106 rq->bio->bi_integrity->bip_iter);
107 }
108 #else /* CONFIG_BLK_DEV_INTEGRITY */
blk_get_meta_cap(struct block_device * bdev,unsigned int cmd,struct logical_block_metadata_cap __user * argp)109 static inline int blk_get_meta_cap(struct block_device *bdev, unsigned int cmd,
110 struct logical_block_metadata_cap __user *argp)
111 {
112 return -ENOIOCTLCMD;
113 }
blk_rq_count_integrity_sg(struct request_queue * q,struct bio * b)114 static inline int blk_rq_count_integrity_sg(struct request_queue *q,
115 struct bio *b)
116 {
117 return 0;
118 }
blk_rq_map_integrity_sg(struct request * q,struct scatterlist * s)119 static inline int blk_rq_map_integrity_sg(struct request *q,
120 struct scatterlist *s)
121 {
122 return 0;
123 }
blk_rq_integrity_map_user(struct request * rq,void __user * ubuf,ssize_t bytes)124 static inline int blk_rq_integrity_map_user(struct request *rq,
125 void __user *ubuf,
126 ssize_t bytes)
127 {
128 return -EINVAL;
129 }
blk_rq_integrity_dma_map_iter_start(struct request * req,struct device * dma_dev,struct dma_iova_state * state,struct blk_dma_iter * iter)130 static inline bool blk_rq_integrity_dma_map_iter_start(struct request *req,
131 struct device *dma_dev, struct dma_iova_state *state,
132 struct blk_dma_iter *iter)
133 {
134 return false;
135 }
blk_rq_integrity_dma_map_iter_next(struct request * req,struct device * dma_dev,struct blk_dma_iter * iter)136 static inline bool blk_rq_integrity_dma_map_iter_next(struct request *req,
137 struct device *dma_dev, struct blk_dma_iter *iter)
138 {
139 return false;
140 }
bdev_get_integrity(struct block_device * b)141 static inline struct blk_integrity *bdev_get_integrity(struct block_device *b)
142 {
143 return NULL;
144 }
blk_get_integrity(struct gendisk * disk)145 static inline struct blk_integrity *blk_get_integrity(struct gendisk *disk)
146 {
147 return NULL;
148 }
149 static inline bool
blk_integrity_queue_supports_integrity(struct request_queue * q)150 blk_integrity_queue_supports_integrity(struct request_queue *q)
151 {
152 return false;
153 }
154 static inline unsigned short
queue_max_integrity_segments(const struct request_queue * q)155 queue_max_integrity_segments(const struct request_queue *q)
156 {
157 return 0;
158 }
159
bio_integrity_intervals(struct blk_integrity * bi,unsigned int sectors)160 static inline unsigned int bio_integrity_intervals(struct blk_integrity *bi,
161 unsigned int sectors)
162 {
163 return 0;
164 }
165
bio_integrity_bytes(struct blk_integrity * bi,unsigned int sectors)166 static inline unsigned int bio_integrity_bytes(struct blk_integrity *bi,
167 unsigned int sectors)
168 {
169 return 0;
170 }
blk_integrity_rq(const struct request * rq)171 static inline bool blk_integrity_rq(const struct request *rq)
172 {
173 return false;
174 }
175
rq_integrity_vec(struct request * rq)176 static inline struct bio_vec rq_integrity_vec(struct request *rq)
177 {
178 /* the optimizer will remove all calls to this function */
179 return (struct bio_vec){ };
180 }
181 #endif /* CONFIG_BLK_DEV_INTEGRITY */
182
183 #endif /* _LINUX_BLK_INTEGRITY_H */
184