1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * blk-integrity.c - Block layer data integrity extensions
4 *
5 * Copyright (C) 2007, 2008 Oracle Corporation
6 * Written by: Martin K. Petersen <martin.petersen@oracle.com>
7 */
8
9 #include <linux/blk-integrity.h>
10 #include <linux/backing-dev.h>
11 #include <linux/mempool.h>
12 #include <linux/bio.h>
13 #include <linux/scatterlist.h>
14 #include <linux/export.h>
15 #include <linux/slab.h>
16
17 #include "blk.h"
18
19 /**
20 * blk_rq_count_integrity_sg - Count number of integrity scatterlist elements
21 * @q: request queue
22 * @bio: bio with integrity metadata attached
23 *
24 * Description: Returns the number of elements required in a
25 * scatterlist corresponding to the integrity metadata in a bio.
26 */
blk_rq_count_integrity_sg(struct request_queue * q,struct bio * bio)27 int blk_rq_count_integrity_sg(struct request_queue *q, struct bio *bio)
28 {
29 struct bio_vec iv, ivprv = { NULL };
30 unsigned int segments = 0;
31 unsigned int seg_size = 0;
32 struct bvec_iter iter;
33 int prev = 0;
34
35 bio_for_each_integrity_vec(iv, bio, iter) {
36
37 if (prev) {
38 if (!biovec_phys_mergeable(q, &ivprv, &iv))
39 goto new_segment;
40 if (seg_size + iv.bv_len > queue_max_segment_size(q))
41 goto new_segment;
42
43 seg_size += iv.bv_len;
44 } else {
45 new_segment:
46 segments++;
47 seg_size = iv.bv_len;
48 }
49
50 prev = 1;
51 ivprv = iv;
52 }
53
54 return segments;
55 }
56
57 /**
58 * blk_rq_map_integrity_sg - Map integrity metadata into a scatterlist
59 * @rq: request to map
60 * @sglist: target scatterlist
61 *
62 * Description: Map the integrity vectors in request into a
63 * scatterlist. The scatterlist must be big enough to hold all
64 * elements. I.e. sized using blk_rq_count_integrity_sg() or
65 * rq->nr_integrity_segments.
66 */
blk_rq_map_integrity_sg(struct request * rq,struct scatterlist * sglist)67 int blk_rq_map_integrity_sg(struct request *rq, struct scatterlist *sglist)
68 {
69 struct bio_vec iv, ivprv = { NULL };
70 struct request_queue *q = rq->q;
71 struct scatterlist *sg = NULL;
72 struct bio *bio = rq->bio;
73 unsigned int segments = 0;
74 struct bvec_iter iter;
75 int prev = 0;
76
77 bio_for_each_integrity_vec(iv, bio, iter) {
78 if (prev) {
79 if (!biovec_phys_mergeable(q, &ivprv, &iv))
80 goto new_segment;
81 if (sg->length + iv.bv_len > queue_max_segment_size(q))
82 goto new_segment;
83
84 sg->length += iv.bv_len;
85 } else {
86 new_segment:
87 if (!sg)
88 sg = sglist;
89 else {
90 sg_unmark_end(sg);
91 sg = sg_next(sg);
92 }
93
94 sg_set_page(sg, iv.bv_page, iv.bv_len, iv.bv_offset);
95 segments++;
96 }
97
98 prev = 1;
99 ivprv = iv;
100 }
101
102 if (sg)
103 sg_mark_end(sg);
104
105 /*
106 * Something must have been wrong if the figured number of segment
107 * is bigger than number of req's physical integrity segments
108 */
109 BUG_ON(segments > rq->nr_integrity_segments);
110 BUG_ON(segments > queue_max_integrity_segments(q));
111 return segments;
112 }
113 EXPORT_SYMBOL(blk_rq_map_integrity_sg);
114
blk_rq_integrity_map_user(struct request * rq,void __user * ubuf,ssize_t bytes)115 int blk_rq_integrity_map_user(struct request *rq, void __user *ubuf,
116 ssize_t bytes)
117 {
118 int ret;
119 struct iov_iter iter;
120
121 iov_iter_ubuf(&iter, rq_data_dir(rq), ubuf, bytes);
122 ret = bio_integrity_map_user(rq->bio, &iter);
123 if (ret)
124 return ret;
125
126 rq->nr_integrity_segments = blk_rq_count_integrity_sg(rq->q, rq->bio);
127 rq->cmd_flags |= REQ_INTEGRITY;
128 return 0;
129 }
130 EXPORT_SYMBOL_GPL(blk_rq_integrity_map_user);
131
blk_integrity_merge_rq(struct request_queue * q,struct request * req,struct request * next)132 bool blk_integrity_merge_rq(struct request_queue *q, struct request *req,
133 struct request *next)
134 {
135 if (blk_integrity_rq(req) == 0 && blk_integrity_rq(next) == 0)
136 return true;
137
138 if (blk_integrity_rq(req) == 0 || blk_integrity_rq(next) == 0)
139 return false;
140
141 if (bio_integrity(req->bio)->bip_flags !=
142 bio_integrity(next->bio)->bip_flags)
143 return false;
144
145 if (req->nr_integrity_segments + next->nr_integrity_segments >
146 q->limits.max_integrity_segments)
147 return false;
148
149 if (integrity_req_gap_back_merge(req, next->bio))
150 return false;
151
152 return true;
153 }
154
blk_integrity_merge_bio(struct request_queue * q,struct request * req,struct bio * bio)155 bool blk_integrity_merge_bio(struct request_queue *q, struct request *req,
156 struct bio *bio)
157 {
158 int nr_integrity_segs;
159
160 if (blk_integrity_rq(req) == 0 && bio_integrity(bio) == NULL)
161 return true;
162
163 if (blk_integrity_rq(req) == 0 || bio_integrity(bio) == NULL)
164 return false;
165
166 if (bio_integrity(req->bio)->bip_flags != bio_integrity(bio)->bip_flags)
167 return false;
168
169 nr_integrity_segs = blk_rq_count_integrity_sg(q, bio);
170 if (req->nr_integrity_segments + nr_integrity_segs >
171 q->limits.max_integrity_segments)
172 return false;
173
174 return true;
175 }
176
dev_to_bi(struct device * dev)177 static inline struct blk_integrity *dev_to_bi(struct device *dev)
178 {
179 return &dev_to_disk(dev)->queue->limits.integrity;
180 }
181
blk_integrity_profile_name(struct blk_integrity * bi)182 const char *blk_integrity_profile_name(struct blk_integrity *bi)
183 {
184 switch (bi->csum_type) {
185 case BLK_INTEGRITY_CSUM_IP:
186 if (bi->flags & BLK_INTEGRITY_REF_TAG)
187 return "T10-DIF-TYPE1-IP";
188 return "T10-DIF-TYPE3-IP";
189 case BLK_INTEGRITY_CSUM_CRC:
190 if (bi->flags & BLK_INTEGRITY_REF_TAG)
191 return "T10-DIF-TYPE1-CRC";
192 return "T10-DIF-TYPE3-CRC";
193 case BLK_INTEGRITY_CSUM_CRC64:
194 if (bi->flags & BLK_INTEGRITY_REF_TAG)
195 return "EXT-DIF-TYPE1-CRC64";
196 return "EXT-DIF-TYPE3-CRC64";
197 case BLK_INTEGRITY_CSUM_NONE:
198 break;
199 }
200
201 return "nop";
202 }
203 EXPORT_SYMBOL_GPL(blk_integrity_profile_name);
204
flag_store(struct device * dev,const char * page,size_t count,unsigned char flag)205 static ssize_t flag_store(struct device *dev, const char *page, size_t count,
206 unsigned char flag)
207 {
208 struct request_queue *q = dev_to_disk(dev)->queue;
209 struct queue_limits lim;
210 unsigned long val;
211 int err;
212
213 err = kstrtoul(page, 10, &val);
214 if (err)
215 return err;
216
217 /* note that the flags are inverted vs the values in the sysfs files */
218 lim = queue_limits_start_update(q);
219 if (val)
220 lim.integrity.flags &= ~flag;
221 else
222 lim.integrity.flags |= flag;
223
224 err = queue_limits_commit_update_frozen(q, &lim);
225 if (err)
226 return err;
227 return count;
228 }
229
flag_show(struct device * dev,char * page,unsigned char flag)230 static ssize_t flag_show(struct device *dev, char *page, unsigned char flag)
231 {
232 struct blk_integrity *bi = dev_to_bi(dev);
233
234 return sysfs_emit(page, "%d\n", !(bi->flags & flag));
235 }
236
format_show(struct device * dev,struct device_attribute * attr,char * page)237 static ssize_t format_show(struct device *dev, struct device_attribute *attr,
238 char *page)
239 {
240 struct blk_integrity *bi = dev_to_bi(dev);
241
242 if (!bi->tuple_size)
243 return sysfs_emit(page, "none\n");
244 return sysfs_emit(page, "%s\n", blk_integrity_profile_name(bi));
245 }
246
tag_size_show(struct device * dev,struct device_attribute * attr,char * page)247 static ssize_t tag_size_show(struct device *dev, struct device_attribute *attr,
248 char *page)
249 {
250 struct blk_integrity *bi = dev_to_bi(dev);
251
252 return sysfs_emit(page, "%u\n", bi->tag_size);
253 }
254
protection_interval_bytes_show(struct device * dev,struct device_attribute * attr,char * page)255 static ssize_t protection_interval_bytes_show(struct device *dev,
256 struct device_attribute *attr,
257 char *page)
258 {
259 struct blk_integrity *bi = dev_to_bi(dev);
260
261 return sysfs_emit(page, "%u\n",
262 bi->interval_exp ? 1 << bi->interval_exp : 0);
263 }
264
read_verify_store(struct device * dev,struct device_attribute * attr,const char * page,size_t count)265 static ssize_t read_verify_store(struct device *dev,
266 struct device_attribute *attr,
267 const char *page, size_t count)
268 {
269 return flag_store(dev, page, count, BLK_INTEGRITY_NOVERIFY);
270 }
271
read_verify_show(struct device * dev,struct device_attribute * attr,char * page)272 static ssize_t read_verify_show(struct device *dev,
273 struct device_attribute *attr, char *page)
274 {
275 return flag_show(dev, page, BLK_INTEGRITY_NOVERIFY);
276 }
277
write_generate_store(struct device * dev,struct device_attribute * attr,const char * page,size_t count)278 static ssize_t write_generate_store(struct device *dev,
279 struct device_attribute *attr,
280 const char *page, size_t count)
281 {
282 return flag_store(dev, page, count, BLK_INTEGRITY_NOGENERATE);
283 }
284
write_generate_show(struct device * dev,struct device_attribute * attr,char * page)285 static ssize_t write_generate_show(struct device *dev,
286 struct device_attribute *attr, char *page)
287 {
288 return flag_show(dev, page, BLK_INTEGRITY_NOGENERATE);
289 }
290
device_is_integrity_capable_show(struct device * dev,struct device_attribute * attr,char * page)291 static ssize_t device_is_integrity_capable_show(struct device *dev,
292 struct device_attribute *attr,
293 char *page)
294 {
295 struct blk_integrity *bi = dev_to_bi(dev);
296
297 return sysfs_emit(page, "%u\n",
298 !!(bi->flags & BLK_INTEGRITY_DEVICE_CAPABLE));
299 }
300
301 static DEVICE_ATTR_RO(format);
302 static DEVICE_ATTR_RO(tag_size);
303 static DEVICE_ATTR_RO(protection_interval_bytes);
304 static DEVICE_ATTR_RW(read_verify);
305 static DEVICE_ATTR_RW(write_generate);
306 static DEVICE_ATTR_RO(device_is_integrity_capable);
307
308 static struct attribute *integrity_attrs[] = {
309 &dev_attr_format.attr,
310 &dev_attr_tag_size.attr,
311 &dev_attr_protection_interval_bytes.attr,
312 &dev_attr_read_verify.attr,
313 &dev_attr_write_generate.attr,
314 &dev_attr_device_is_integrity_capable.attr,
315 NULL
316 };
317
318 const struct attribute_group blk_integrity_attr_group = {
319 .name = "integrity",
320 .attrs = integrity_attrs,
321 };
322