the-tree/block/blk-integrity.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * blk-integrity.c - Block layer data integrity extensions
0004  *
0005  * Copyright (C) 2007, 2008 Oracle Corporation
0006  * Written by: Martin K. Petersen <martin.petersen@oracle.com>
0007  */
0008
0009 #include <linux/blk-integrity.h>
0010 #include <linux/backing-dev.h>
0011 #include <linux/mempool.h>
0012 #include <linux/bio.h>
0013 #include <linux/scatterlist.h>
0014 #include <linux/export.h>
0015 #include <linux/slab.h>
0016
0017 #include "blk.h"
0018
0019 /**
0020  * blk_rq_count_integrity_sg - Count number of integrity scatterlist elements
0021  * @q:      request queue
0022  * @bio:    bio with integrity metadata attached
0023  *
0024  * Description: Returns the number of elements required in a
0025  * scatterlist corresponding to the integrity metadata in a bio.
0026  */
0027 int blk_rq_count_integrity_sg(struct request_queue *q, struct bio *bio)
0028 {
0029     struct bio_vec iv, ivprv = { NULL };
0030     unsigned int segments = 0;
0031     unsigned int seg_size = 0;
0032     struct bvec_iter iter;
0033     int prev = 0;
0034
0035     bio_for_each_integrity_vec(iv, bio, iter) {
0036
0037         if (prev) {
0038             if (!biovec_phys_mergeable(q, &ivprv, &iv))
0039                 goto new_segment;
0040             if (seg_size + iv.bv_len > queue_max_segment_size(q))
0041                 goto new_segment;
0042
0043             seg_size += iv.bv_len;
0044         } else {
0045 new_segment:
0046             segments++;
0047             seg_size = iv.bv_len;
0048         }
0049
0050         prev = 1;
0051         ivprv = iv;
0052     }
0053
0054     return segments;
0055 }
0056 EXPORT_SYMBOL(blk_rq_count_integrity_sg);
0057
0058 /**
0059  * blk_rq_map_integrity_sg - Map integrity metadata into a scatterlist
0060  * @q:      request queue
0061  * @bio:    bio with integrity metadata attached
0062  * @sglist: target scatterlist
0063  *
0064  * Description: Map the integrity vectors in request into a
0065  * scatterlist.  The scatterlist must be big enough to hold all
0066  * elements.  I.e. sized using blk_rq_count_integrity_sg().
0067  */
0068 int blk_rq_map_integrity_sg(struct request_queue *q, struct bio *bio,
0069                 struct scatterlist *sglist)
0070 {
0071     struct bio_vec iv, ivprv = { NULL };
0072     struct scatterlist *sg = NULL;
0073     unsigned int segments = 0;
0074     struct bvec_iter iter;
0075     int prev = 0;
0076
0077     bio_for_each_integrity_vec(iv, bio, iter) {
0078
0079         if (prev) {
0080             if (!biovec_phys_mergeable(q, &ivprv, &iv))
0081                 goto new_segment;
0082             if (sg->length + iv.bv_len > queue_max_segment_size(q))
0083                 goto new_segment;
0084
0085             sg->length += iv.bv_len;
0086         } else {
0087 new_segment:
0088             if (!sg)
0089                 sg = sglist;
0090             else {
0091                 sg_unmark_end(sg);
0092                 sg = sg_next(sg);
0093             }
0094
0095             sg_set_page(sg, iv.bv_page, iv.bv_len, iv.bv_offset);
0096             segments++;
0097         }
0098
0099         prev = 1;
0100         ivprv = iv;
0101     }
0102
0103     if (sg)
0104         sg_mark_end(sg);
0105
0106     return segments;
0107 }
0108 EXPORT_SYMBOL(blk_rq_map_integrity_sg);
0109
0110 /**
0111  * blk_integrity_compare - Compare integrity profile of two disks
0112  * @gd1:    Disk to compare
0113  * @gd2:    Disk to compare
0114  *
0115  * Description: Meta-devices like DM and MD need to verify that all
0116  * sub-devices use the same integrity format before advertising to
0117  * upper layers that they can send/receive integrity metadata.  This
0118  * function can be used to check whether two gendisk devices have
0119  * compatible integrity formats.
0120  */
0121 int blk_integrity_compare(struct gendisk *gd1, struct gendisk *gd2)
0122 {
0123     struct blk_integrity *b1 = &gd1->queue->integrity;
0124     struct blk_integrity *b2 = &gd2->queue->integrity;
0125
0126     if (!b1->profile && !b2->profile)
0127         return 0;
0128
0129     if (!b1->profile || !b2->profile)
0130         return -1;
0131
0132     if (b1->interval_exp != b2->interval_exp) {
0133         pr_err("%s: %s/%s protection interval %u != %u\n",
0134                __func__, gd1->disk_name, gd2->disk_name,
0135                1 << b1->interval_exp, 1 << b2->interval_exp);
0136         return -1;
0137     }
0138
0139     if (b1->tuple_size != b2->tuple_size) {
0140         pr_err("%s: %s/%s tuple sz %u != %u\n", __func__,
0141                gd1->disk_name, gd2->disk_name,
0142                b1->tuple_size, b2->tuple_size);
0143         return -1;
0144     }
0145
0146     if (b1->tag_size && b2->tag_size && (b1->tag_size != b2->tag_size)) {
0147         pr_err("%s: %s/%s tag sz %u != %u\n", __func__,
0148                gd1->disk_name, gd2->disk_name,
0149                b1->tag_size, b2->tag_size);
0150         return -1;
0151     }
0152
0153     if (b1->profile != b2->profile) {
0154         pr_err("%s: %s/%s type %s != %s\n", __func__,
0155                gd1->disk_name, gd2->disk_name,
0156                b1->profile->name, b2->profile->name);
0157         return -1;
0158     }
0159
0160     return 0;
0161 }
0162 EXPORT_SYMBOL(blk_integrity_compare);
0163
0164 bool blk_integrity_merge_rq(struct request_queue *q, struct request *req,
0165                 struct request *next)
0166 {
0167     if (blk_integrity_rq(req) == 0 && blk_integrity_rq(next) == 0)
0168         return true;
0169
0170     if (blk_integrity_rq(req) == 0 || blk_integrity_rq(next) == 0)
0171         return false;
0172
0173     if (bio_integrity(req->bio)->bip_flags !=
0174         bio_integrity(next->bio)->bip_flags)
0175         return false;
0176
0177     if (req->nr_integrity_segments + next->nr_integrity_segments >
0178         q->limits.max_integrity_segments)
0179         return false;
0180
0181     if (integrity_req_gap_back_merge(req, next->bio))
0182         return false;
0183
0184     return true;
0185 }
0186
0187 bool blk_integrity_merge_bio(struct request_queue *q, struct request *req,
0188                  struct bio *bio)
0189 {
0190     int nr_integrity_segs;
0191     struct bio *next = bio->bi_next;
0192
0193     if (blk_integrity_rq(req) == 0 && bio_integrity(bio) == NULL)
0194         return true;
0195
0196     if (blk_integrity_rq(req) == 0 || bio_integrity(bio) == NULL)
0197         return false;
0198
0199     if (bio_integrity(req->bio)->bip_flags != bio_integrity(bio)->bip_flags)
0200         return false;
0201
0202     bio->bi_next = NULL;
0203     nr_integrity_segs = blk_rq_count_integrity_sg(q, bio);
0204     bio->bi_next = next;
0205
0206     if (req->nr_integrity_segments + nr_integrity_segs >
0207         q->limits.max_integrity_segments)
0208         return false;
0209
0210     req->nr_integrity_segments += nr_integrity_segs;
0211
0212     return true;
0213 }
0214
0215 struct integrity_sysfs_entry {
0216     struct attribute attr;
0217     ssize_t (*show)(struct blk_integrity *, char *);
0218     ssize_t (*store)(struct blk_integrity *, const char *, size_t);
0219 };
0220
0221 static ssize_t integrity_attr_show(struct kobject *kobj, struct attribute *attr,
0222                    char *page)
0223 {
0224     struct gendisk *disk = container_of(kobj, struct gendisk, integrity_kobj);
0225     struct blk_integrity *bi = &disk->queue->integrity;
0226     struct integrity_sysfs_entry *entry =
0227         container_of(attr, struct integrity_sysfs_entry, attr);
0228
0229     return entry->show(bi, page);
0230 }
0231
0232 static ssize_t integrity_attr_store(struct kobject *kobj,
0233                     struct attribute *attr, const char *page,
0234                     size_t count)
0235 {
0236     struct gendisk *disk = container_of(kobj, struct gendisk, integrity_kobj);
0237     struct blk_integrity *bi = &disk->queue->integrity;
0238     struct integrity_sysfs_entry *entry =
0239         container_of(attr, struct integrity_sysfs_entry, attr);
0240     ssize_t ret = 0;
0241
0242     if (entry->store)
0243         ret = entry->store(bi, page, count);
0244
0245     return ret;
0246 }
0247
0248 static ssize_t integrity_format_show(struct blk_integrity *bi, char *page)
0249 {
0250     if (bi->profile && bi->profile->name)
0251         return sprintf(page, "%s\n", bi->profile->name);
0252     else
0253         return sprintf(page, "none\n");
0254 }
0255
0256 static ssize_t integrity_tag_size_show(struct blk_integrity *bi, char *page)
0257 {
0258     return sprintf(page, "%u\n", bi->tag_size);
0259 }
0260
0261 static ssize_t integrity_interval_show(struct blk_integrity *bi, char *page)
0262 {
0263     return sprintf(page, "%u\n",
0264                bi->interval_exp ? 1 << bi->interval_exp : 0);
0265 }
0266
0267 static ssize_t integrity_verify_store(struct blk_integrity *bi,
0268                       const char *page, size_t count)
0269 {
0270     char *p = (char *) page;
0271     unsigned long val = simple_strtoul(p, &p, 10);
0272
0273     if (val)
0274         bi->flags |= BLK_INTEGRITY_VERIFY;
0275     else
0276         bi->flags &= ~BLK_INTEGRITY_VERIFY;
0277
0278     return count;
0279 }
0280
0281 static ssize_t integrity_verify_show(struct blk_integrity *bi, char *page)
0282 {
0283     return sprintf(page, "%d\n", (bi->flags & BLK_INTEGRITY_VERIFY) != 0);
0284 }
0285
0286 static ssize_t integrity_generate_store(struct blk_integrity *bi,
0287                     const char *page, size_t count)
0288 {
0289     char *p = (char *) page;
0290     unsigned long val = simple_strtoul(p, &p, 10);
0291
0292     if (val)
0293         bi->flags |= BLK_INTEGRITY_GENERATE;
0294     else
0295         bi->flags &= ~BLK_INTEGRITY_GENERATE;
0296
0297     return count;
0298 }
0299
0300 static ssize_t integrity_generate_show(struct blk_integrity *bi, char *page)
0301 {
0302     return sprintf(page, "%d\n", (bi->flags & BLK_INTEGRITY_GENERATE) != 0);
0303 }
0304
0305 static ssize_t integrity_device_show(struct blk_integrity *bi, char *page)
0306 {
0307     return sprintf(page, "%u\n",
0308                (bi->flags & BLK_INTEGRITY_DEVICE_CAPABLE) != 0);
0309 }
0310
0311 static struct integrity_sysfs_entry integrity_format_entry = {
0312     .attr = { .name = "format", .mode = 0444 },
0313     .show = integrity_format_show,
0314 };
0315
0316 static struct integrity_sysfs_entry integrity_tag_size_entry = {
0317     .attr = { .name = "tag_size", .mode = 0444 },
0318     .show = integrity_tag_size_show,
0319 };
0320
0321 static struct integrity_sysfs_entry integrity_interval_entry = {
0322     .attr = { .name = "protection_interval_bytes", .mode = 0444 },
0323     .show = integrity_interval_show,
0324 };
0325
0326 static struct integrity_sysfs_entry integrity_verify_entry = {
0327     .attr = { .name = "read_verify", .mode = 0644 },
0328     .show = integrity_verify_show,
0329     .store = integrity_verify_store,
0330 };
0331
0332 static struct integrity_sysfs_entry integrity_generate_entry = {
0333     .attr = { .name = "write_generate", .mode = 0644 },
0334     .show = integrity_generate_show,
0335     .store = integrity_generate_store,
0336 };
0337
0338 static struct integrity_sysfs_entry integrity_device_entry = {
0339     .attr = { .name = "device_is_integrity_capable", .mode = 0444 },
0340     .show = integrity_device_show,
0341 };
0342
0343 static struct attribute *integrity_attrs[] = {
0344     &integrity_format_entry.attr,
0345     &integrity_tag_size_entry.attr,
0346     &integrity_interval_entry.attr,
0347     &integrity_verify_entry.attr,
0348     &integrity_generate_entry.attr,
0349     &integrity_device_entry.attr,
0350     NULL,
0351 };
0352 ATTRIBUTE_GROUPS(integrity);
0353
0354 static const struct sysfs_ops integrity_ops = {
0355     .show   = &integrity_attr_show,
0356     .store  = &integrity_attr_store,
0357 };
0358
0359 static struct kobj_type integrity_ktype = {
0360     .default_groups = integrity_groups,
0361     .sysfs_ops  = &integrity_ops,
0362 };
0363
0364 static blk_status_t blk_integrity_nop_fn(struct blk_integrity_iter *iter)
0365 {
0366     return BLK_STS_OK;
0367 }
0368
0369 static void blk_integrity_nop_prepare(struct request *rq)
0370 {
0371 }
0372
0373 static void blk_integrity_nop_complete(struct request *rq,
0374         unsigned int nr_bytes)
0375 {
0376 }
0377
0378 static const struct blk_integrity_profile nop_profile = {
0379     .name = "nop",
0380     .generate_fn = blk_integrity_nop_fn,
0381     .verify_fn = blk_integrity_nop_fn,
0382     .prepare_fn = blk_integrity_nop_prepare,
0383     .complete_fn = blk_integrity_nop_complete,
0384 };
0385
0386 /**
0387  * blk_integrity_register - Register a gendisk as being integrity-capable
0388  * @disk:   struct gendisk pointer to make integrity-aware
0389  * @template:   block integrity profile to register
0390  *
0391  * Description: When a device needs to advertise itself as being able to
0392  * send/receive integrity metadata it must use this function to register
0393  * the capability with the block layer. The template is a blk_integrity
0394  * struct with values appropriate for the underlying hardware. See
0395  * Documentation/block/data-integrity.rst.
0396  */
0397 void blk_integrity_register(struct gendisk *disk, struct blk_integrity *template)
0398 {
0399     struct blk_integrity *bi = &disk->queue->integrity;
0400
0401     bi->flags = BLK_INTEGRITY_VERIFY | BLK_INTEGRITY_GENERATE |
0402         template->flags;
0403     bi->interval_exp = template->interval_exp ? :
0404         ilog2(queue_logical_block_size(disk->queue));
0405     bi->profile = template->profile ? template->profile : &nop_profile;
0406     bi->tuple_size = template->tuple_size;
0407     bi->tag_size = template->tag_size;
0408
0409     blk_queue_flag_set(QUEUE_FLAG_STABLE_WRITES, disk->queue);
0410
0411 #ifdef CONFIG_BLK_INLINE_ENCRYPTION
0412     if (disk->queue->crypto_profile) {
0413         pr_warn("blk-integrity: Integrity and hardware inline encryption are not supported together. Disabling hardware inline encryption.\n");
0414         disk->queue->crypto_profile = NULL;
0415     }
0416 #endif
0417 }
0418 EXPORT_SYMBOL(blk_integrity_register);
0419
0420 /**
0421  * blk_integrity_unregister - Unregister block integrity profile
0422  * @disk:   disk whose integrity profile to unregister
0423  *
0424  * Description: This function unregisters the integrity capability from
0425  * a block device.
0426  */
0427 void blk_integrity_unregister(struct gendisk *disk)
0428 {
0429     struct blk_integrity *bi = &disk->queue->integrity;
0430
0431     if (!bi->profile)
0432         return;
0433
0434     /* ensure all bios are off the integrity workqueue */
0435     blk_flush_integrity();
0436     blk_queue_flag_clear(QUEUE_FLAG_STABLE_WRITES, disk->queue);
0437     memset(bi, 0, sizeof(*bi));
0438 }
0439 EXPORT_SYMBOL(blk_integrity_unregister);
0440
0441 int blk_integrity_add(struct gendisk *disk)
0442 {
0443     int ret;
0444
0445     ret = kobject_init_and_add(&disk->integrity_kobj, &integrity_ktype,
0446                    &disk_to_dev(disk)->kobj, "%s", "integrity");
0447     if (!ret)
0448         kobject_uevent(&disk->integrity_kobj, KOBJ_ADD);
0449     return ret;
0450 }
0451
0452 void blk_integrity_del(struct gendisk *disk)
0453 {
0454     kobject_uevent(&disk->integrity_kobj, KOBJ_REMOVE);
0455     kobject_del(&disk->integrity_kobj);
0456     kobject_put(&disk->integrity_kobj);
0457 }