1 // SPDX-License-Identifier: GPL-2.0
3 * blk-integrity.c - Block layer data integrity extensions
5 * Copyright (C) 2007, 2008 Oracle Corporation
6 * Written by: Martin K. Petersen <martin.petersen@oracle.com>
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>
20 * blk_rq_count_integrity_sg - Count number of integrity scatterlist elements
22 * @bio: bio with integrity metadata attached
24 * Description: Returns the number of elements required in a
25 * scatterlist corresponding to the integrity metadata in a bio.
27 int blk_rq_count_integrity_sg(struct request_queue
*q
, struct bio
*bio
)
29 struct bio_vec iv
, ivprv
= { NULL
};
30 unsigned int segments
= 0;
31 unsigned int seg_size
= 0;
32 struct bvec_iter iter
;
35 bio_for_each_integrity_vec(iv
, bio
, iter
) {
38 if (!biovec_phys_mergeable(q
, &ivprv
, &iv
))
40 if (seg_size
+ iv
.bv_len
> queue_max_segment_size(q
))
43 seg_size
+= iv
.bv_len
;
56 EXPORT_SYMBOL(blk_rq_count_integrity_sg
);
59 * blk_rq_map_integrity_sg - Map integrity metadata into a scatterlist
61 * @bio: bio with integrity metadata attached
62 * @sglist: target scatterlist
64 * Description: Map the integrity vectors in request into a
65 * scatterlist. The scatterlist must be big enough to hold all
66 * elements. I.e. sized using blk_rq_count_integrity_sg().
68 int blk_rq_map_integrity_sg(struct request_queue
*q
, struct bio
*bio
,
69 struct scatterlist
*sglist
)
71 struct bio_vec iv
, ivprv
= { NULL
};
72 struct scatterlist
*sg
= NULL
;
73 unsigned int segments
= 0;
74 struct bvec_iter iter
;
77 bio_for_each_integrity_vec(iv
, bio
, iter
) {
80 if (!biovec_phys_mergeable(q
, &ivprv
, &iv
))
82 if (sg
->length
+ iv
.bv_len
> queue_max_segment_size(q
))
85 sg
->length
+= iv
.bv_len
;
95 sg_set_page(sg
, iv
.bv_page
, iv
.bv_len
, iv
.bv_offset
);
108 EXPORT_SYMBOL(blk_rq_map_integrity_sg
);
111 * blk_integrity_compare - Compare integrity profile of two disks
112 * @gd1: Disk to compare
113 * @gd2: Disk to compare
115 * Description: Meta-devices like DM and MD need to verify that all
116 * sub-devices use the same integrity format before advertising to
117 * upper layers that they can send/receive integrity metadata. This
118 * function can be used to check whether two gendisk devices have
119 * compatible integrity formats.
121 int blk_integrity_compare(struct gendisk
*gd1
, struct gendisk
*gd2
)
123 struct blk_integrity
*b1
= &gd1
->queue
->integrity
;
124 struct blk_integrity
*b2
= &gd2
->queue
->integrity
;
126 if (!b1
->profile
&& !b2
->profile
)
129 if (!b1
->profile
|| !b2
->profile
)
132 if (b1
->interval_exp
!= b2
->interval_exp
) {
133 pr_err("%s: %s/%s protection interval %u != %u\n",
134 __func__
, gd1
->disk_name
, gd2
->disk_name
,
135 1 << b1
->interval_exp
, 1 << b2
->interval_exp
);
139 if (b1
->tuple_size
!= b2
->tuple_size
) {
140 pr_err("%s: %s/%s tuple sz %u != %u\n", __func__
,
141 gd1
->disk_name
, gd2
->disk_name
,
142 b1
->tuple_size
, b2
->tuple_size
);
146 if (b1
->tag_size
&& b2
->tag_size
&& (b1
->tag_size
!= b2
->tag_size
)) {
147 pr_err("%s: %s/%s tag sz %u != %u\n", __func__
,
148 gd1
->disk_name
, gd2
->disk_name
,
149 b1
->tag_size
, b2
->tag_size
);
153 if (b1
->profile
!= b2
->profile
) {
154 pr_err("%s: %s/%s type %s != %s\n", __func__
,
155 gd1
->disk_name
, gd2
->disk_name
,
156 b1
->profile
->name
, b2
->profile
->name
);
162 EXPORT_SYMBOL(blk_integrity_compare
);
164 bool blk_integrity_merge_rq(struct request_queue
*q
, struct request
*req
,
165 struct request
*next
)
167 if (blk_integrity_rq(req
) == 0 && blk_integrity_rq(next
) == 0)
170 if (blk_integrity_rq(req
) == 0 || blk_integrity_rq(next
) == 0)
173 if (bio_integrity(req
->bio
)->bip_flags
!=
174 bio_integrity(next
->bio
)->bip_flags
)
177 if (req
->nr_integrity_segments
+ next
->nr_integrity_segments
>
178 q
->limits
.max_integrity_segments
)
181 if (integrity_req_gap_back_merge(req
, next
->bio
))
187 bool blk_integrity_merge_bio(struct request_queue
*q
, struct request
*req
,
190 int nr_integrity_segs
;
191 struct bio
*next
= bio
->bi_next
;
193 if (blk_integrity_rq(req
) == 0 && bio_integrity(bio
) == NULL
)
196 if (blk_integrity_rq(req
) == 0 || bio_integrity(bio
) == NULL
)
199 if (bio_integrity(req
->bio
)->bip_flags
!= bio_integrity(bio
)->bip_flags
)
203 nr_integrity_segs
= blk_rq_count_integrity_sg(q
, bio
);
206 if (req
->nr_integrity_segments
+ nr_integrity_segs
>
207 q
->limits
.max_integrity_segments
)
210 req
->nr_integrity_segments
+= nr_integrity_segs
;
215 static inline struct blk_integrity
*dev_to_bi(struct device
*dev
)
217 return &dev_to_disk(dev
)->queue
->integrity
;
220 static ssize_t
format_show(struct device
*dev
, struct device_attribute
*attr
,
223 struct blk_integrity
*bi
= dev_to_bi(dev
);
225 if (bi
->profile
&& bi
->profile
->name
)
226 return sysfs_emit(page
, "%s\n", bi
->profile
->name
);
227 return sysfs_emit(page
, "none\n");
230 static ssize_t
tag_size_show(struct device
*dev
, struct device_attribute
*attr
,
233 struct blk_integrity
*bi
= dev_to_bi(dev
);
235 return sysfs_emit(page
, "%u\n", bi
->tag_size
);
238 static ssize_t
protection_interval_bytes_show(struct device
*dev
,
239 struct device_attribute
*attr
,
242 struct blk_integrity
*bi
= dev_to_bi(dev
);
244 return sysfs_emit(page
, "%u\n",
245 bi
->interval_exp
? 1 << bi
->interval_exp
: 0);
248 static ssize_t
read_verify_store(struct device
*dev
,
249 struct device_attribute
*attr
,
250 const char *page
, size_t count
)
252 struct blk_integrity
*bi
= dev_to_bi(dev
);
253 char *p
= (char *) page
;
254 unsigned long val
= simple_strtoul(p
, &p
, 10);
257 bi
->flags
|= BLK_INTEGRITY_VERIFY
;
259 bi
->flags
&= ~BLK_INTEGRITY_VERIFY
;
264 static ssize_t
read_verify_show(struct device
*dev
,
265 struct device_attribute
*attr
, char *page
)
267 struct blk_integrity
*bi
= dev_to_bi(dev
);
269 return sysfs_emit(page
, "%d\n", !!(bi
->flags
& BLK_INTEGRITY_VERIFY
));
272 static ssize_t
write_generate_store(struct device
*dev
,
273 struct device_attribute
*attr
,
274 const char *page
, size_t count
)
276 struct blk_integrity
*bi
= dev_to_bi(dev
);
278 char *p
= (char *) page
;
279 unsigned long val
= simple_strtoul(p
, &p
, 10);
282 bi
->flags
|= BLK_INTEGRITY_GENERATE
;
284 bi
->flags
&= ~BLK_INTEGRITY_GENERATE
;
289 static ssize_t
write_generate_show(struct device
*dev
,
290 struct device_attribute
*attr
, char *page
)
292 struct blk_integrity
*bi
= dev_to_bi(dev
);
294 return sysfs_emit(page
, "%d\n", !!(bi
->flags
& BLK_INTEGRITY_GENERATE
));
297 static ssize_t
device_is_integrity_capable_show(struct device
*dev
,
298 struct device_attribute
*attr
,
301 struct blk_integrity
*bi
= dev_to_bi(dev
);
303 return sysfs_emit(page
, "%u\n",
304 !!(bi
->flags
& BLK_INTEGRITY_DEVICE_CAPABLE
));
307 static DEVICE_ATTR_RO(format
);
308 static DEVICE_ATTR_RO(tag_size
);
309 static DEVICE_ATTR_RO(protection_interval_bytes
);
310 static DEVICE_ATTR_RW(read_verify
);
311 static DEVICE_ATTR_RW(write_generate
);
312 static DEVICE_ATTR_RO(device_is_integrity_capable
);
314 static struct attribute
*integrity_attrs
[] = {
315 &dev_attr_format
.attr
,
316 &dev_attr_tag_size
.attr
,
317 &dev_attr_protection_interval_bytes
.attr
,
318 &dev_attr_read_verify
.attr
,
319 &dev_attr_write_generate
.attr
,
320 &dev_attr_device_is_integrity_capable
.attr
,
324 const struct attribute_group blk_integrity_attr_group
= {
326 .attrs
= integrity_attrs
,
329 static blk_status_t
blk_integrity_nop_fn(struct blk_integrity_iter
*iter
)
334 static void blk_integrity_nop_prepare(struct request
*rq
)
338 static void blk_integrity_nop_complete(struct request
*rq
,
339 unsigned int nr_bytes
)
343 static const struct blk_integrity_profile nop_profile
= {
345 .generate_fn
= blk_integrity_nop_fn
,
346 .verify_fn
= blk_integrity_nop_fn
,
347 .prepare_fn
= blk_integrity_nop_prepare
,
348 .complete_fn
= blk_integrity_nop_complete
,
352 * blk_integrity_register - Register a gendisk as being integrity-capable
353 * @disk: struct gendisk pointer to make integrity-aware
354 * @template: block integrity profile to register
356 * Description: When a device needs to advertise itself as being able to
357 * send/receive integrity metadata it must use this function to register
358 * the capability with the block layer. The template is a blk_integrity
359 * struct with values appropriate for the underlying hardware. See
360 * Documentation/block/data-integrity.rst.
362 void blk_integrity_register(struct gendisk
*disk
, struct blk_integrity
*template)
364 struct blk_integrity
*bi
= &disk
->queue
->integrity
;
366 bi
->flags
= BLK_INTEGRITY_VERIFY
| BLK_INTEGRITY_GENERATE
|
368 bi
->interval_exp
= template->interval_exp
? :
369 ilog2(queue_logical_block_size(disk
->queue
));
370 bi
->profile
= template->profile
? template->profile
: &nop_profile
;
371 bi
->tuple_size
= template->tuple_size
;
372 bi
->tag_size
= template->tag_size
;
374 blk_queue_flag_set(QUEUE_FLAG_STABLE_WRITES
, disk
->queue
);
376 #ifdef CONFIG_BLK_INLINE_ENCRYPTION
377 if (disk
->queue
->crypto_profile
) {
378 pr_warn("blk-integrity: Integrity and hardware inline encryption are not supported together. Disabling hardware inline encryption.\n");
379 disk
->queue
->crypto_profile
= NULL
;
383 EXPORT_SYMBOL(blk_integrity_register
);
386 * blk_integrity_unregister - Unregister block integrity profile
387 * @disk: disk whose integrity profile to unregister
389 * Description: This function unregisters the integrity capability from
392 void blk_integrity_unregister(struct gendisk
*disk
)
394 struct blk_integrity
*bi
= &disk
->queue
->integrity
;
399 /* ensure all bios are off the integrity workqueue */
400 blk_flush_integrity();
401 blk_queue_flag_clear(QUEUE_FLAG_STABLE_WRITES
, disk
->queue
);
402 memset(bi
, 0, sizeof(*bi
));
404 EXPORT_SYMBOL(blk_integrity_unregister
);