linux/block/blk-integrity.c
<<
>>
Prefs
   1/*
   2 * blk-integrity.c - Block layer data integrity extensions
   3 *
   4 * Copyright (C) 2007, 2008 Oracle Corporation
   5 * Written by: Martin K. Petersen <martin.petersen@oracle.com>
   6 *
   7 * This program is free software; you can redistribute it and/or
   8 * modify it under the terms of the GNU General Public License version
   9 * 2 as published by the Free Software Foundation.
  10 *
  11 * This program is distributed in the hope that it will be useful, but
  12 * WITHOUT ANY WARRANTY; without even the implied warranty of
  13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 * General Public License for more details.
  15 *
  16 * You should have received a copy of the GNU General Public License
  17 * along with this program; see the file COPYING.  If not, write to
  18 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139,
  19 * USA.
  20 *
  21 */
  22
  23#include <linux/blkdev.h>
  24#include <linux/backing-dev.h>
  25#include <linux/mempool.h>
  26#include <linux/bio.h>
  27#include <linux/scatterlist.h>
  28#include <linux/export.h>
  29#include <linux/slab.h>
  30
  31#include "blk.h"
  32
  33/**
  34 * blk_rq_count_integrity_sg - Count number of integrity scatterlist elements
  35 * @q:          request queue
  36 * @bio:        bio with integrity metadata attached
  37 *
  38 * Description: Returns the number of elements required in a
  39 * scatterlist corresponding to the integrity metadata in a bio.
  40 */
  41int blk_rq_count_integrity_sg(struct request_queue *q, struct bio *bio)
  42{
  43        struct bio_vec iv, ivprv = { NULL };
  44        unsigned int segments = 0;
  45        unsigned int seg_size = 0;
  46        struct bvec_iter iter;
  47        int prev = 0;
  48
  49        bio_for_each_integrity_vec(iv, bio, iter) {
  50
  51                if (prev) {
  52                        if (!biovec_phys_mergeable(q, &ivprv, &iv))
  53                                goto new_segment;
  54                        if (seg_size + iv.bv_len > queue_max_segment_size(q))
  55                                goto new_segment;
  56
  57                        seg_size += iv.bv_len;
  58                } else {
  59new_segment:
  60                        segments++;
  61                        seg_size = iv.bv_len;
  62                }
  63
  64                prev = 1;
  65                ivprv = iv;
  66        }
  67
  68        return segments;
  69}
  70EXPORT_SYMBOL(blk_rq_count_integrity_sg);
  71
  72/**
  73 * blk_rq_map_integrity_sg - Map integrity metadata into a scatterlist
  74 * @q:          request queue
  75 * @bio:        bio with integrity metadata attached
  76 * @sglist:     target scatterlist
  77 *
  78 * Description: Map the integrity vectors in request into a
  79 * scatterlist.  The scatterlist must be big enough to hold all
  80 * elements.  I.e. sized using blk_rq_count_integrity_sg().
  81 */
  82int blk_rq_map_integrity_sg(struct request_queue *q, struct bio *bio,
  83                            struct scatterlist *sglist)
  84{
  85        struct bio_vec iv, ivprv = { NULL };
  86        struct scatterlist *sg = NULL;
  87        unsigned int segments = 0;
  88        struct bvec_iter iter;
  89        int prev = 0;
  90
  91        bio_for_each_integrity_vec(iv, bio, iter) {
  92
  93                if (prev) {
  94                        if (!biovec_phys_mergeable(q, &ivprv, &iv))
  95                                goto new_segment;
  96                        if (sg->length + iv.bv_len > queue_max_segment_size(q))
  97                                goto new_segment;
  98
  99                        sg->length += iv.bv_len;
 100                } else {
 101new_segment:
 102                        if (!sg)
 103                                sg = sglist;
 104                        else {
 105                                sg_unmark_end(sg);
 106                                sg = sg_next(sg);
 107                        }
 108
 109                        sg_set_page(sg, iv.bv_page, iv.bv_len, iv.bv_offset);
 110                        segments++;
 111                }
 112
 113                prev = 1;
 114                ivprv = iv;
 115        }
 116
 117        if (sg)
 118                sg_mark_end(sg);
 119
 120        return segments;
 121}
 122EXPORT_SYMBOL(blk_rq_map_integrity_sg);
 123
 124/**
 125 * blk_integrity_compare - Compare integrity profile of two disks
 126 * @gd1:        Disk to compare
 127 * @gd2:        Disk to compare
 128 *
 129 * Description: Meta-devices like DM and MD need to verify that all
 130 * sub-devices use the same integrity format before advertising to
 131 * upper layers that they can send/receive integrity metadata.  This
 132 * function can be used to check whether two gendisk devices have
 133 * compatible integrity formats.
 134 */
 135int blk_integrity_compare(struct gendisk *gd1, struct gendisk *gd2)
 136{
 137        struct blk_integrity *b1 = &gd1->queue->integrity;
 138        struct blk_integrity *b2 = &gd2->queue->integrity;
 139
 140        if (!b1->profile && !b2->profile)
 141                return 0;
 142
 143        if (!b1->profile || !b2->profile)
 144                return -1;
 145
 146        if (b1->interval_exp != b2->interval_exp) {
 147                pr_err("%s: %s/%s protection interval %u != %u\n",
 148                       __func__, gd1->disk_name, gd2->disk_name,
 149                       1 << b1->interval_exp, 1 << b2->interval_exp);
 150                return -1;
 151        }
 152
 153        if (b1->tuple_size != b2->tuple_size) {
 154                pr_err("%s: %s/%s tuple sz %u != %u\n", __func__,
 155                       gd1->disk_name, gd2->disk_name,
 156                       b1->tuple_size, b2->tuple_size);
 157                return -1;
 158        }
 159
 160        if (b1->tag_size && b2->tag_size && (b1->tag_size != b2->tag_size)) {
 161                pr_err("%s: %s/%s tag sz %u != %u\n", __func__,
 162                       gd1->disk_name, gd2->disk_name,
 163                       b1->tag_size, b2->tag_size);
 164                return -1;
 165        }
 166
 167        if (b1->profile != b2->profile) {
 168                pr_err("%s: %s/%s type %s != %s\n", __func__,
 169                       gd1->disk_name, gd2->disk_name,
 170                       b1->profile->name, b2->profile->name);
 171                return -1;
 172        }
 173
 174        return 0;
 175}
 176EXPORT_SYMBOL(blk_integrity_compare);
 177
 178bool blk_integrity_merge_rq(struct request_queue *q, struct request *req,
 179                            struct request *next)
 180{
 181        if (blk_integrity_rq(req) == 0 && blk_integrity_rq(next) == 0)
 182                return true;
 183
 184        if (blk_integrity_rq(req) == 0 || blk_integrity_rq(next) == 0)
 185                return false;
 186
 187        if (bio_integrity(req->bio)->bip_flags !=
 188            bio_integrity(next->bio)->bip_flags)
 189                return false;
 190
 191        if (req->nr_integrity_segments + next->nr_integrity_segments >
 192            q->limits.max_integrity_segments)
 193                return false;
 194
 195        if (integrity_req_gap_back_merge(req, next->bio))
 196                return false;
 197
 198        return true;
 199}
 200EXPORT_SYMBOL(blk_integrity_merge_rq);
 201
 202bool blk_integrity_merge_bio(struct request_queue *q, struct request *req,
 203                             struct bio *bio)
 204{
 205        int nr_integrity_segs;
 206        struct bio *next = bio->bi_next;
 207
 208        if (blk_integrity_rq(req) == 0 && bio_integrity(bio) == NULL)
 209                return true;
 210
 211        if (blk_integrity_rq(req) == 0 || bio_integrity(bio) == NULL)
 212                return false;
 213
 214        if (bio_integrity(req->bio)->bip_flags != bio_integrity(bio)->bip_flags)
 215                return false;
 216
 217        bio->bi_next = NULL;
 218        nr_integrity_segs = blk_rq_count_integrity_sg(q, bio);
 219        bio->bi_next = next;
 220
 221        if (req->nr_integrity_segments + nr_integrity_segs >
 222            q->limits.max_integrity_segments)
 223                return false;
 224
 225        req->nr_integrity_segments += nr_integrity_segs;
 226
 227        return true;
 228}
 229EXPORT_SYMBOL(blk_integrity_merge_bio);
 230
 231struct integrity_sysfs_entry {
 232        struct attribute attr;
 233        ssize_t (*show)(struct blk_integrity *, char *);
 234        ssize_t (*store)(struct blk_integrity *, const char *, size_t);
 235};
 236
 237static ssize_t integrity_attr_show(struct kobject *kobj, struct attribute *attr,
 238                                   char *page)
 239{
 240        struct gendisk *disk = container_of(kobj, struct gendisk, integrity_kobj);
 241        struct blk_integrity *bi = &disk->queue->integrity;
 242        struct integrity_sysfs_entry *entry =
 243                container_of(attr, struct integrity_sysfs_entry, attr);
 244
 245        return entry->show(bi, page);
 246}
 247
 248static ssize_t integrity_attr_store(struct kobject *kobj,
 249                                    struct attribute *attr, const char *page,
 250                                    size_t count)
 251{
 252        struct gendisk *disk = container_of(kobj, struct gendisk, integrity_kobj);
 253        struct blk_integrity *bi = &disk->queue->integrity;
 254        struct integrity_sysfs_entry *entry =
 255                container_of(attr, struct integrity_sysfs_entry, attr);
 256        ssize_t ret = 0;
 257
 258        if (entry->store)
 259                ret = entry->store(bi, page, count);
 260
 261        return ret;
 262}
 263
 264static ssize_t integrity_format_show(struct blk_integrity *bi, char *page)
 265{
 266        if (bi->profile && bi->profile->name)
 267                return sprintf(page, "%s\n", bi->profile->name);
 268        else
 269                return sprintf(page, "none\n");
 270}
 271
 272static ssize_t integrity_tag_size_show(struct blk_integrity *bi, char *page)
 273{
 274        return sprintf(page, "%u\n", bi->tag_size);
 275}
 276
 277static ssize_t integrity_interval_show(struct blk_integrity *bi, char *page)
 278{
 279        return sprintf(page, "%u\n",
 280                       bi->interval_exp ? 1 << bi->interval_exp : 0);
 281}
 282
 283static ssize_t integrity_verify_store(struct blk_integrity *bi,
 284                                      const char *page, size_t count)
 285{
 286        char *p = (char *) page;
 287        unsigned long val = simple_strtoul(p, &p, 10);
 288
 289        if (val)
 290                bi->flags |= BLK_INTEGRITY_VERIFY;
 291        else
 292                bi->flags &= ~BLK_INTEGRITY_VERIFY;
 293
 294        return count;
 295}
 296
 297static ssize_t integrity_verify_show(struct blk_integrity *bi, char *page)
 298{
 299        return sprintf(page, "%d\n", (bi->flags & BLK_INTEGRITY_VERIFY) != 0);
 300}
 301
 302static ssize_t integrity_generate_store(struct blk_integrity *bi,
 303                                        const char *page, size_t count)
 304{
 305        char *p = (char *) page;
 306        unsigned long val = simple_strtoul(p, &p, 10);
 307
 308        if (val)
 309                bi->flags |= BLK_INTEGRITY_GENERATE;
 310        else
 311                bi->flags &= ~BLK_INTEGRITY_GENERATE;
 312
 313        return count;
 314}
 315
 316static ssize_t integrity_generate_show(struct blk_integrity *bi, char *page)
 317{
 318        return sprintf(page, "%d\n", (bi->flags & BLK_INTEGRITY_GENERATE) != 0);
 319}
 320
 321static ssize_t integrity_device_show(struct blk_integrity *bi, char *page)
 322{
 323        return sprintf(page, "%u\n",
 324                       (bi->flags & BLK_INTEGRITY_DEVICE_CAPABLE) != 0);
 325}
 326
 327static struct integrity_sysfs_entry integrity_format_entry = {
 328        .attr = { .name = "format", .mode = 0444 },
 329        .show = integrity_format_show,
 330};
 331
 332static struct integrity_sysfs_entry integrity_tag_size_entry = {
 333        .attr = { .name = "tag_size", .mode = 0444 },
 334        .show = integrity_tag_size_show,
 335};
 336
 337static struct integrity_sysfs_entry integrity_interval_entry = {
 338        .attr = { .name = "protection_interval_bytes", .mode = 0444 },
 339        .show = integrity_interval_show,
 340};
 341
 342static struct integrity_sysfs_entry integrity_verify_entry = {
 343        .attr = { .name = "read_verify", .mode = 0644 },
 344        .show = integrity_verify_show,
 345        .store = integrity_verify_store,
 346};
 347
 348static struct integrity_sysfs_entry integrity_generate_entry = {
 349        .attr = { .name = "write_generate", .mode = 0644 },
 350        .show = integrity_generate_show,
 351        .store = integrity_generate_store,
 352};
 353
 354static struct integrity_sysfs_entry integrity_device_entry = {
 355        .attr = { .name = "device_is_integrity_capable", .mode = 0444 },
 356        .show = integrity_device_show,
 357};
 358
 359static struct attribute *integrity_attrs[] = {
 360        &integrity_format_entry.attr,
 361        &integrity_tag_size_entry.attr,
 362        &integrity_interval_entry.attr,
 363        &integrity_verify_entry.attr,
 364        &integrity_generate_entry.attr,
 365        &integrity_device_entry.attr,
 366        NULL,
 367};
 368
 369static const struct sysfs_ops integrity_ops = {
 370        .show   = &integrity_attr_show,
 371        .store  = &integrity_attr_store,
 372};
 373
 374static struct kobj_type integrity_ktype = {
 375        .default_attrs  = integrity_attrs,
 376        .sysfs_ops      = &integrity_ops,
 377};
 378
 379static blk_status_t blk_integrity_nop_fn(struct blk_integrity_iter *iter)
 380{
 381        return BLK_STS_OK;
 382}
 383
 384static const struct blk_integrity_profile nop_profile = {
 385        .name = "nop",
 386        .generate_fn = blk_integrity_nop_fn,
 387        .verify_fn = blk_integrity_nop_fn,
 388};
 389
 390/**
 391 * blk_integrity_register - Register a gendisk as being integrity-capable
 392 * @disk:       struct gendisk pointer to make integrity-aware
 393 * @template:   block integrity profile to register
 394 *
 395 * Description: When a device needs to advertise itself as being able to
 396 * send/receive integrity metadata it must use this function to register
 397 * the capability with the block layer. The template is a blk_integrity
 398 * struct with values appropriate for the underlying hardware. See
 399 * Documentation/block/data-integrity.txt.
 400 */
 401void blk_integrity_register(struct gendisk *disk, struct blk_integrity *template)
 402{
 403        struct blk_integrity *bi = &disk->queue->integrity;
 404
 405        bi->flags = BLK_INTEGRITY_VERIFY | BLK_INTEGRITY_GENERATE |
 406                template->flags;
 407        bi->interval_exp = template->interval_exp ? :
 408                ilog2(queue_logical_block_size(disk->queue));
 409        bi->profile = template->profile ? template->profile : &nop_profile;
 410        bi->tuple_size = template->tuple_size;
 411        bi->tag_size = template->tag_size;
 412
 413        disk->queue->backing_dev_info->capabilities |= BDI_CAP_STABLE_WRITES;
 414}
 415EXPORT_SYMBOL(blk_integrity_register);
 416
 417/**
 418 * blk_integrity_unregister - Unregister block integrity profile
 419 * @disk:       disk whose integrity profile to unregister
 420 *
 421 * Description: This function unregisters the integrity capability from
 422 * a block device.
 423 */
 424void blk_integrity_unregister(struct gendisk *disk)
 425{
 426        disk->queue->backing_dev_info->capabilities &= ~BDI_CAP_STABLE_WRITES;
 427        memset(&disk->queue->integrity, 0, sizeof(struct blk_integrity));
 428}
 429EXPORT_SYMBOL(blk_integrity_unregister);
 430
 431void blk_integrity_add(struct gendisk *disk)
 432{
 433        if (kobject_init_and_add(&disk->integrity_kobj, &integrity_ktype,
 434                                 &disk_to_dev(disk)->kobj, "%s", "integrity"))
 435                return;
 436
 437        kobject_uevent(&disk->integrity_kobj, KOBJ_ADD);
 438}
 439
 440void blk_integrity_del(struct gendisk *disk)
 441{
 442        kobject_uevent(&disk->integrity_kobj, KOBJ_REMOVE);
 443        kobject_del(&disk->integrity_kobj);
 444        kobject_put(&disk->integrity_kobj);
 445}
 446