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 #include <linux/t10-pi.h>
17
18 #include "blk.h"
19
20 /**
21 * blk_rq_count_integrity_sg - Count number of integrity scatterlist elements
22 * @q: request queue
23 * @bio: bio with integrity metadata attached
24 *
25 * Description: Returns the number of elements required in a
26 * scatterlist corresponding to the integrity metadata in a bio.
27 */
blk_rq_count_integrity_sg(struct request_queue * q,struct bio * bio)28 int blk_rq_count_integrity_sg(struct request_queue *q, struct bio *bio)
29 {
30 struct bio_vec iv, ivprv = { NULL };
31 unsigned int segments = 0;
32 unsigned int seg_size = 0;
33 struct bvec_iter iter;
34 int prev = 0;
35
36 bio_for_each_integrity_vec(iv, bio, iter) {
37
38 if (prev) {
39 if (!biovec_phys_mergeable(q, &ivprv, &iv))
40 goto new_segment;
41 if (seg_size + iv.bv_len > queue_max_segment_size(q))
42 goto new_segment;
43
44 seg_size += iv.bv_len;
45 } else {
46 new_segment:
47 segments++;
48 seg_size = iv.bv_len;
49 }
50
51 prev = 1;
52 ivprv = iv;
53 }
54
55 return segments;
56 }
57
blk_get_meta_cap(struct block_device * bdev,unsigned int cmd,struct logical_block_metadata_cap __user * argp)58 int blk_get_meta_cap(struct block_device *bdev, unsigned int cmd,
59 struct logical_block_metadata_cap __user *argp)
60 {
61 struct blk_integrity *bi;
62 struct logical_block_metadata_cap meta_cap = {};
63 size_t usize = _IOC_SIZE(cmd);
64
65 if (!extensible_ioctl_valid(cmd, FS_IOC_GETLBMD_CAP, LBMD_SIZE_VER0))
66 return -ENOIOCTLCMD;
67
68 bi = blk_get_integrity(bdev->bd_disk);
69 if (!bi)
70 goto out;
71
72 if (bi->flags & BLK_INTEGRITY_DEVICE_CAPABLE)
73 meta_cap.lbmd_flags |= LBMD_PI_CAP_INTEGRITY;
74 if (bi->flags & BLK_INTEGRITY_REF_TAG)
75 meta_cap.lbmd_flags |= LBMD_PI_CAP_REFTAG;
76 meta_cap.lbmd_interval = 1 << bi->interval_exp;
77 meta_cap.lbmd_size = bi->metadata_size;
78 meta_cap.lbmd_pi_size = bi->pi_tuple_size;
79 meta_cap.lbmd_pi_offset = bi->pi_offset;
80 meta_cap.lbmd_opaque_size = bi->metadata_size - bi->pi_tuple_size;
81 if (meta_cap.lbmd_opaque_size && !bi->pi_offset)
82 meta_cap.lbmd_opaque_offset = bi->pi_tuple_size;
83
84 switch (bi->csum_type) {
85 case BLK_INTEGRITY_CSUM_NONE:
86 meta_cap.lbmd_guard_tag_type = LBMD_PI_CSUM_NONE;
87 break;
88 case BLK_INTEGRITY_CSUM_IP:
89 meta_cap.lbmd_guard_tag_type = LBMD_PI_CSUM_IP;
90 break;
91 case BLK_INTEGRITY_CSUM_CRC:
92 meta_cap.lbmd_guard_tag_type = LBMD_PI_CSUM_CRC16_T10DIF;
93 break;
94 case BLK_INTEGRITY_CSUM_CRC64:
95 meta_cap.lbmd_guard_tag_type = LBMD_PI_CSUM_CRC64_NVME;
96 break;
97 }
98
99 if (bi->csum_type != BLK_INTEGRITY_CSUM_NONE)
100 meta_cap.lbmd_app_tag_size = 2;
101
102 if (bi->flags & BLK_INTEGRITY_REF_TAG) {
103 switch (bi->csum_type) {
104 case BLK_INTEGRITY_CSUM_CRC64:
105 meta_cap.lbmd_ref_tag_size =
106 sizeof_field(struct crc64_pi_tuple, ref_tag);
107 break;
108 case BLK_INTEGRITY_CSUM_CRC:
109 case BLK_INTEGRITY_CSUM_IP:
110 meta_cap.lbmd_ref_tag_size =
111 sizeof_field(struct t10_pi_tuple, ref_tag);
112 break;
113 default:
114 break;
115 }
116 }
117
118 out:
119 return copy_struct_to_user(argp, usize, &meta_cap, sizeof(meta_cap),
120 NULL);
121 }
122
blk_rq_integrity_map_user(struct request * rq,void __user * ubuf,ssize_t bytes)123 int blk_rq_integrity_map_user(struct request *rq, void __user *ubuf,
124 ssize_t bytes)
125 {
126 int ret;
127 struct iov_iter iter;
128
129 iov_iter_ubuf(&iter, rq_data_dir(rq), ubuf, bytes);
130 ret = bio_integrity_map_user(rq->bio, &iter);
131 if (ret)
132 return ret;
133
134 rq->nr_integrity_segments = blk_rq_count_integrity_sg(rq->q, rq->bio);
135 rq->cmd_flags |= REQ_INTEGRITY;
136 return 0;
137 }
138 EXPORT_SYMBOL_GPL(blk_rq_integrity_map_user);
139
blk_integrity_merge_rq(struct request_queue * q,struct request * req,struct request * next)140 bool blk_integrity_merge_rq(struct request_queue *q, struct request *req,
141 struct request *next)
142 {
143 struct bio_integrity_payload *bip, *bip_next;
144
145 if (blk_integrity_rq(req) == 0 && blk_integrity_rq(next) == 0)
146 return true;
147
148 if (blk_integrity_rq(req) == 0 || blk_integrity_rq(next) == 0)
149 return false;
150
151 bip = bio_integrity(req->bio);
152 bip_next = bio_integrity(next->bio);
153 if (bip->bip_flags != bip_next->bip_flags)
154 return false;
155
156 if (bip->bip_flags & BIP_CHECK_APPTAG &&
157 bip->app_tag != bip_next->app_tag)
158 return false;
159
160 if (req->nr_integrity_segments + next->nr_integrity_segments >
161 q->limits.max_integrity_segments)
162 return false;
163
164 if (integrity_req_gap_back_merge(req, next->bio))
165 return false;
166
167 return true;
168 }
169
blk_integrity_merge_bio(struct request_queue * q,struct request * req,struct bio * bio)170 bool blk_integrity_merge_bio(struct request_queue *q, struct request *req,
171 struct bio *bio)
172 {
173 struct bio_integrity_payload *bip, *bip_bio = bio_integrity(bio);
174 int nr_integrity_segs;
175
176 if (blk_integrity_rq(req) == 0 && bip_bio == NULL)
177 return true;
178
179 if (blk_integrity_rq(req) == 0 || bip_bio == NULL)
180 return false;
181
182 bip = bio_integrity(req->bio);
183 if (bip->bip_flags != bip_bio->bip_flags)
184 return false;
185
186 if (bip->bip_flags & BIP_CHECK_APPTAG &&
187 bip->app_tag != bip_bio->app_tag)
188 return false;
189
190 nr_integrity_segs = blk_rq_count_integrity_sg(q, bio);
191 if (req->nr_integrity_segments + nr_integrity_segs >
192 q->limits.max_integrity_segments)
193 return false;
194
195 return true;
196 }
197
dev_to_bi(struct device * dev)198 static inline struct blk_integrity *dev_to_bi(struct device *dev)
199 {
200 return &dev_to_disk(dev)->queue->limits.integrity;
201 }
202
blk_integrity_profile_name(struct blk_integrity * bi)203 const char *blk_integrity_profile_name(struct blk_integrity *bi)
204 {
205 switch (bi->csum_type) {
206 case BLK_INTEGRITY_CSUM_IP:
207 if (bi->flags & BLK_INTEGRITY_REF_TAG)
208 return "T10-DIF-TYPE1-IP";
209 return "T10-DIF-TYPE3-IP";
210 case BLK_INTEGRITY_CSUM_CRC:
211 if (bi->flags & BLK_INTEGRITY_REF_TAG)
212 return "T10-DIF-TYPE1-CRC";
213 return "T10-DIF-TYPE3-CRC";
214 case BLK_INTEGRITY_CSUM_CRC64:
215 if (bi->flags & BLK_INTEGRITY_REF_TAG)
216 return "EXT-DIF-TYPE1-CRC64";
217 return "EXT-DIF-TYPE3-CRC64";
218 case BLK_INTEGRITY_CSUM_NONE:
219 break;
220 }
221
222 return "nop";
223 }
224 EXPORT_SYMBOL_GPL(blk_integrity_profile_name);
225
flag_store(struct device * dev,const char * page,size_t count,unsigned char flag)226 static ssize_t flag_store(struct device *dev, const char *page, size_t count,
227 unsigned char flag)
228 {
229 struct request_queue *q = dev_to_disk(dev)->queue;
230 struct queue_limits lim;
231 unsigned long val;
232 int err;
233
234 err = kstrtoul(page, 10, &val);
235 if (err)
236 return err;
237
238 /* note that the flags are inverted vs the values in the sysfs files */
239 lim = queue_limits_start_update(q);
240 if (val)
241 lim.integrity.flags &= ~flag;
242 else
243 lim.integrity.flags |= flag;
244
245 err = queue_limits_commit_update_frozen(q, &lim);
246 if (err)
247 return err;
248 return count;
249 }
250
flag_show(struct device * dev,char * page,unsigned char flag)251 static ssize_t flag_show(struct device *dev, char *page, unsigned char flag)
252 {
253 struct blk_integrity *bi = dev_to_bi(dev);
254
255 return sysfs_emit(page, "%d\n", !(bi->flags & flag));
256 }
257
format_show(struct device * dev,struct device_attribute * attr,char * page)258 static ssize_t format_show(struct device *dev, struct device_attribute *attr,
259 char *page)
260 {
261 struct blk_integrity *bi = dev_to_bi(dev);
262
263 if (!bi->metadata_size)
264 return sysfs_emit(page, "none\n");
265 return sysfs_emit(page, "%s\n", blk_integrity_profile_name(bi));
266 }
267
tag_size_show(struct device * dev,struct device_attribute * attr,char * page)268 static ssize_t tag_size_show(struct device *dev, struct device_attribute *attr,
269 char *page)
270 {
271 struct blk_integrity *bi = dev_to_bi(dev);
272
273 return sysfs_emit(page, "%u\n", bi->tag_size);
274 }
275
protection_interval_bytes_show(struct device * dev,struct device_attribute * attr,char * page)276 static ssize_t protection_interval_bytes_show(struct device *dev,
277 struct device_attribute *attr,
278 char *page)
279 {
280 struct blk_integrity *bi = dev_to_bi(dev);
281
282 return sysfs_emit(page, "%u\n",
283 bi->interval_exp ? 1 << bi->interval_exp : 0);
284 }
285
read_verify_store(struct device * dev,struct device_attribute * attr,const char * page,size_t count)286 static ssize_t read_verify_store(struct device *dev,
287 struct device_attribute *attr,
288 const char *page, size_t count)
289 {
290 return flag_store(dev, page, count, BLK_INTEGRITY_NOVERIFY);
291 }
292
read_verify_show(struct device * dev,struct device_attribute * attr,char * page)293 static ssize_t read_verify_show(struct device *dev,
294 struct device_attribute *attr, char *page)
295 {
296 return flag_show(dev, page, BLK_INTEGRITY_NOVERIFY);
297 }
298
write_generate_store(struct device * dev,struct device_attribute * attr,const char * page,size_t count)299 static ssize_t write_generate_store(struct device *dev,
300 struct device_attribute *attr,
301 const char *page, size_t count)
302 {
303 return flag_store(dev, page, count, BLK_INTEGRITY_NOGENERATE);
304 }
305
write_generate_show(struct device * dev,struct device_attribute * attr,char * page)306 static ssize_t write_generate_show(struct device *dev,
307 struct device_attribute *attr, char *page)
308 {
309 return flag_show(dev, page, BLK_INTEGRITY_NOGENERATE);
310 }
311
device_is_integrity_capable_show(struct device * dev,struct device_attribute * attr,char * page)312 static ssize_t device_is_integrity_capable_show(struct device *dev,
313 struct device_attribute *attr,
314 char *page)
315 {
316 struct blk_integrity *bi = dev_to_bi(dev);
317
318 return sysfs_emit(page, "%u\n",
319 !!(bi->flags & BLK_INTEGRITY_DEVICE_CAPABLE));
320 }
321
322 static DEVICE_ATTR_RO(format);
323 static DEVICE_ATTR_RO(tag_size);
324 static DEVICE_ATTR_RO(protection_interval_bytes);
325 static DEVICE_ATTR_RW(read_verify);
326 static DEVICE_ATTR_RW(write_generate);
327 static DEVICE_ATTR_RO(device_is_integrity_capable);
328
329 static struct attribute *integrity_attrs[] = {
330 &dev_attr_format.attr,
331 &dev_attr_tag_size.attr,
332 &dev_attr_protection_interval_bytes.attr,
333 &dev_attr_read_verify.attr,
334 &dev_attr_write_generate.attr,
335 &dev_attr_device_is_integrity_capable.attr,
336 NULL
337 };
338
339 const struct attribute_group blk_integrity_attr_group = {
340 .name = "integrity",
341 .attrs = integrity_attrs,
342 };
343