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/blkdev.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 struct integrity_sysfs_entry
{
216 struct attribute attr
;
217 ssize_t (*show
)(struct blk_integrity
*, char *);
218 ssize_t (*store
)(struct blk_integrity
*, const char *, size_t);
221 static ssize_t
integrity_attr_show(struct kobject
*kobj
, struct attribute
*attr
,
224 struct gendisk
*disk
= container_of(kobj
, struct gendisk
, integrity_kobj
);
225 struct blk_integrity
*bi
= &disk
->queue
->integrity
;
226 struct integrity_sysfs_entry
*entry
=
227 container_of(attr
, struct integrity_sysfs_entry
, attr
);
229 return entry
->show(bi
, page
);
232 static ssize_t
integrity_attr_store(struct kobject
*kobj
,
233 struct attribute
*attr
, const char *page
,
236 struct gendisk
*disk
= container_of(kobj
, struct gendisk
, integrity_kobj
);
237 struct blk_integrity
*bi
= &disk
->queue
->integrity
;
238 struct integrity_sysfs_entry
*entry
=
239 container_of(attr
, struct integrity_sysfs_entry
, attr
);
243 ret
= entry
->store(bi
, page
, count
);
248 static ssize_t
integrity_format_show(struct blk_integrity
*bi
, char *page
)
250 if (bi
->profile
&& bi
->profile
->name
)
251 return sprintf(page
, "%s\n", bi
->profile
->name
);
253 return sprintf(page
, "none\n");
256 static ssize_t
integrity_tag_size_show(struct blk_integrity
*bi
, char *page
)
258 return sprintf(page
, "%u\n", bi
->tag_size
);
261 static ssize_t
integrity_interval_show(struct blk_integrity
*bi
, char *page
)
263 return sprintf(page
, "%u\n",
264 bi
->interval_exp
? 1 << bi
->interval_exp
: 0);
267 static ssize_t
integrity_verify_store(struct blk_integrity
*bi
,
268 const char *page
, size_t count
)
270 char *p
= (char *) page
;
271 unsigned long val
= simple_strtoul(p
, &p
, 10);
274 bi
->flags
|= BLK_INTEGRITY_VERIFY
;
276 bi
->flags
&= ~BLK_INTEGRITY_VERIFY
;
281 static ssize_t
integrity_verify_show(struct blk_integrity
*bi
, char *page
)
283 return sprintf(page
, "%d\n", (bi
->flags
& BLK_INTEGRITY_VERIFY
) != 0);
286 static ssize_t
integrity_generate_store(struct blk_integrity
*bi
,
287 const char *page
, size_t count
)
289 char *p
= (char *) page
;
290 unsigned long val
= simple_strtoul(p
, &p
, 10);
293 bi
->flags
|= BLK_INTEGRITY_GENERATE
;
295 bi
->flags
&= ~BLK_INTEGRITY_GENERATE
;
300 static ssize_t
integrity_generate_show(struct blk_integrity
*bi
, char *page
)
302 return sprintf(page
, "%d\n", (bi
->flags
& BLK_INTEGRITY_GENERATE
) != 0);
305 static ssize_t
integrity_device_show(struct blk_integrity
*bi
, char *page
)
307 return sprintf(page
, "%u\n",
308 (bi
->flags
& BLK_INTEGRITY_DEVICE_CAPABLE
) != 0);
311 static struct integrity_sysfs_entry integrity_format_entry
= {
312 .attr
= { .name
= "format", .mode
= 0444 },
313 .show
= integrity_format_show
,
316 static struct integrity_sysfs_entry integrity_tag_size_entry
= {
317 .attr
= { .name
= "tag_size", .mode
= 0444 },
318 .show
= integrity_tag_size_show
,
321 static struct integrity_sysfs_entry integrity_interval_entry
= {
322 .attr
= { .name
= "protection_interval_bytes", .mode
= 0444 },
323 .show
= integrity_interval_show
,
326 static struct integrity_sysfs_entry integrity_verify_entry
= {
327 .attr
= { .name
= "read_verify", .mode
= 0644 },
328 .show
= integrity_verify_show
,
329 .store
= integrity_verify_store
,
332 static struct integrity_sysfs_entry integrity_generate_entry
= {
333 .attr
= { .name
= "write_generate", .mode
= 0644 },
334 .show
= integrity_generate_show
,
335 .store
= integrity_generate_store
,
338 static struct integrity_sysfs_entry integrity_device_entry
= {
339 .attr
= { .name
= "device_is_integrity_capable", .mode
= 0444 },
340 .show
= integrity_device_show
,
343 static struct attribute
*integrity_attrs
[] = {
344 &integrity_format_entry
.attr
,
345 &integrity_tag_size_entry
.attr
,
346 &integrity_interval_entry
.attr
,
347 &integrity_verify_entry
.attr
,
348 &integrity_generate_entry
.attr
,
349 &integrity_device_entry
.attr
,
352 ATTRIBUTE_GROUPS(integrity
);
354 static const struct sysfs_ops integrity_ops
= {
355 .show
= &integrity_attr_show
,
356 .store
= &integrity_attr_store
,
359 static struct kobj_type integrity_ktype
= {
360 .default_groups
= integrity_groups
,
361 .sysfs_ops
= &integrity_ops
,
364 static blk_status_t
blk_integrity_nop_fn(struct blk_integrity_iter
*iter
)
369 static void blk_integrity_nop_prepare(struct request
*rq
)
373 static void blk_integrity_nop_complete(struct request
*rq
,
374 unsigned int nr_bytes
)
378 static const struct blk_integrity_profile nop_profile
= {
380 .generate_fn
= blk_integrity_nop_fn
,
381 .verify_fn
= blk_integrity_nop_fn
,
382 .prepare_fn
= blk_integrity_nop_prepare
,
383 .complete_fn
= blk_integrity_nop_complete
,
387 * blk_integrity_register - Register a gendisk as being integrity-capable
388 * @disk: struct gendisk pointer to make integrity-aware
389 * @template: block integrity profile to register
391 * Description: When a device needs to advertise itself as being able to
392 * send/receive integrity metadata it must use this function to register
393 * the capability with the block layer. The template is a blk_integrity
394 * struct with values appropriate for the underlying hardware. See
395 * Documentation/block/data-integrity.rst.
397 void blk_integrity_register(struct gendisk
*disk
, struct blk_integrity
*template)
399 struct blk_integrity
*bi
= &disk
->queue
->integrity
;
401 bi
->flags
= BLK_INTEGRITY_VERIFY
| BLK_INTEGRITY_GENERATE
|
403 bi
->interval_exp
= template->interval_exp
? :
404 ilog2(queue_logical_block_size(disk
->queue
));
405 bi
->profile
= template->profile
? template->profile
: &nop_profile
;
406 bi
->tuple_size
= template->tuple_size
;
407 bi
->tag_size
= template->tag_size
;
409 blk_queue_flag_set(QUEUE_FLAG_STABLE_WRITES
, disk
->queue
);
411 #ifdef CONFIG_BLK_INLINE_ENCRYPTION
412 if (disk
->queue
->ksm
) {
413 pr_warn("blk-integrity: Integrity and hardware inline encryption are not supported together. Disabling hardware inline encryption.\n");
414 blk_ksm_unregister(disk
->queue
);
418 EXPORT_SYMBOL(blk_integrity_register
);
421 * blk_integrity_unregister - Unregister block integrity profile
422 * @disk: disk whose integrity profile to unregister
424 * Description: This function unregisters the integrity capability from
427 void blk_integrity_unregister(struct gendisk
*disk
)
429 blk_queue_flag_clear(QUEUE_FLAG_STABLE_WRITES
, disk
->queue
);
430 memset(&disk
->queue
->integrity
, 0, sizeof(struct blk_integrity
));
432 EXPORT_SYMBOL(blk_integrity_unregister
);
434 void blk_integrity_add(struct gendisk
*disk
)
436 if (kobject_init_and_add(&disk
->integrity_kobj
, &integrity_ktype
,
437 &disk_to_dev(disk
)->kobj
, "%s", "integrity"))
440 kobject_uevent(&disk
->integrity_kobj
, KOBJ_ADD
);
443 void blk_integrity_del(struct gendisk
*disk
)
445 kobject_uevent(&disk
->integrity_kobj
, KOBJ_REMOVE
);
446 kobject_del(&disk
->integrity_kobj
);
447 kobject_put(&disk
->integrity_kobj
);