block/bio-integrity.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * bio-integrity.c - bio data integrity extensions
   4  *
   5  * Copyright (C) 2007, 2008, 2009 Oracle Corporation
   6  * Written by: Martin K. Petersen <martin.petersen@oracle.com>
   7  */
   8
   9 #include <linux/blkdev.h>
  10 #include <linux/mempool.h>
  11 #include <linux/export.h>
  12 #include <linux/bio.h>
  13 #include <linux/workqueue.h>
  14 #include <linux/slab.h>
  15 #include "blk.h"
  16
  17 static struct kmem_cache *bip_slab;
  18 static struct workqueue_struct *kintegrityd_wq;
  19
  20 void blk_flush_integrity(void)
  21 {
  22         flush_workqueue(kintegrityd_wq);
  23 }
  24
  25 static void __bio_integrity_free(struct bio_set *bs,
  26                                  struct bio_integrity_payload *bip)
  27 {
  28         if (bs && mempool_initialized(&bs->bio_integrity_pool)) {
  29                 if (bip->bip_vec)
  30                         bvec_free(&bs->bvec_integrity_pool, bip->bip_vec,
  31                                   bip->bip_slab);
  32                 mempool_free(bip, &bs->bio_integrity_pool);
  33         } else {
  34                 kfree(bip);
  35         }
  36 }
  37
  38 /**
  39  * bio_integrity_alloc - Allocate integrity payload and attach it to bio
  40  * @bio:        bio to attach integrity metadata to
  41  * @gfp_mask:   Memory allocation mask
  42  * @nr_vecs:    Number of integrity metadata scatter-gather elements
  43  *
  44  * Description: This function prepares a bio for attaching integrity
  45  * metadata.  nr_vecs specifies the maximum number of pages containing
  46  * integrity metadata that can be attached.
  47  */
  48 struct bio_integrity_payload *bio_integrity_alloc(struct bio *bio,
  49                                                   gfp_t gfp_mask,
  50                                                   unsigned int nr_vecs)
  51 {
  52         struct bio_integrity_payload *bip;
  53         struct bio_set *bs = bio->bi_pool;
  54         unsigned inline_vecs;
  55
  56         if (WARN_ON_ONCE(bio_has_crypt_ctx(bio)))
  57                 return ERR_PTR(-EOPNOTSUPP);
  58
  59         if (!bs || !mempool_initialized(&bs->bio_integrity_pool)) {
  60                 bip = kmalloc(struct_size(bip, bip_inline_vecs, nr_vecs), gfp_mask);
  61                 inline_vecs = nr_vecs;
  62         } else {
  63                 bip = mempool_alloc(&bs->bio_integrity_pool, gfp_mask);
  64                 inline_vecs = BIO_INLINE_VECS;
  65         }
  66
  67         if (unlikely(!bip))
  68                 return ERR_PTR(-ENOMEM);
  69
  70         memset(bip, 0, sizeof(*bip));
  71
  72         if (nr_vecs > inline_vecs) {
  73                 unsigned long idx = 0;
  74
  75                 bip->bip_vec = bvec_alloc(gfp_mask, nr_vecs, &idx,
  76                                           &bs->bvec_integrity_pool);
  77                 if (!bip->bip_vec)
  78                         goto err;
  79                 bip->bip_max_vcnt = bvec_nr_vecs(idx);
  80                 bip->bip_slab = idx;
  81         } else {
  82                 bip->bip_vec = bip->bip_inline_vecs;
  83                 bip->bip_max_vcnt = inline_vecs;
  84         }
  85
  86         bip->bip_bio = bio;
  87         bio->bi_integrity = bip;
  88         bio->bi_opf |= REQ_INTEGRITY;
  89
  90         return bip;
  91 err:
  92         __bio_integrity_free(bs, bip);
  93         return ERR_PTR(-ENOMEM);
  94 }
  95 EXPORT_SYMBOL(bio_integrity_alloc);
  96
  97 /**
  98  * bio_integrity_free - Free bio integrity payload
  99  * @bio:        bio containing bip to be freed
 100  *
 101  * Description: Used to free the integrity portion of a bio. Usually
 102  * called from bio_free().
 103  */
 104 void bio_integrity_free(struct bio *bio)
 105 {
 106         struct bio_integrity_payload *bip = bio_integrity(bio);
 107         struct bio_set *bs = bio->bi_pool;
 108
 109         if (bip->bip_flags & BIP_BLOCK_INTEGRITY)
 110                 kfree(page_address(bip->bip_vec->bv_page) +
 111                       bip->bip_vec->bv_offset);
 112
 113         __bio_integrity_free(bs, bip);
 114         bio->bi_integrity = NULL;
 115         bio->bi_opf &= ~REQ_INTEGRITY;
 116 }
 117
 118 /**
 119  * bio_integrity_add_page - Attach integrity metadata
 120  * @bio:        bio to update
 121  * @page:       page containing integrity metadata
 122  * @len:        number of bytes of integrity metadata in page
 123  * @offset:     start offset within page
 124  *
 125  * Description: Attach a page containing integrity metadata to bio.
 126  */
 127 int bio_integrity_add_page(struct bio *bio, struct page *page,
 128                            unsigned int len, unsigned int offset)
 129 {
 130         struct bio_integrity_payload *bip = bio_integrity(bio);
 131         struct bio_vec *iv;
 132
 133         if (bip->bip_vcnt >= bip->bip_max_vcnt) {
 134                 printk(KERN_ERR "%s: bip_vec full\n", __func__);
 135                 return 0;
 136         }
 137
 138         iv = bip->bip_vec + bip->bip_vcnt;
 139
 140         if (bip->bip_vcnt &&
 141             bvec_gap_to_prev(bio->bi_bdev->bd_disk->queue,
 142                              &bip->bip_vec[bip->bip_vcnt - 1], offset))
 143                 return 0;
 144
 145         iv->bv_page = page;
 146         iv->bv_len = len;
 147         iv->bv_offset = offset;
 148         bip->bip_vcnt++;
 149
 150         return len;
 151 }
 152 EXPORT_SYMBOL(bio_integrity_add_page);
 153
 154 /**
 155  * bio_integrity_process - Process integrity metadata for a bio
 156  * @bio:        bio to generate/verify integrity metadata for
 157  * @proc_iter:  iterator to process
 158  * @proc_fn:    Pointer to the relevant processing function
 159  */
 160 static blk_status_t bio_integrity_process(struct bio *bio,
 161                 struct bvec_iter *proc_iter, integrity_processing_fn *proc_fn)
 162 {
 163         struct blk_integrity *bi = blk_get_integrity(bio->bi_bdev->bd_disk);
 164         struct blk_integrity_iter iter;
 165         struct bvec_iter bviter;
 166         struct bio_vec bv;
 167         struct bio_integrity_payload *bip = bio_integrity(bio);
 168         blk_status_t ret = BLK_STS_OK;
 169         void *prot_buf = page_address(bip->bip_vec->bv_page) +
 170                 bip->bip_vec->bv_offset;
 171
 172         iter.disk_name = bio->bi_bdev->bd_disk->disk_name;
 173         iter.interval = 1 << bi->interval_exp;
 174         iter.seed = proc_iter->bi_sector;
 175         iter.prot_buf = prot_buf;
 176
 177         __bio_for_each_segment(bv, bio, bviter, *proc_iter) {
 178                 void *kaddr = kmap_atomic(bv.bv_page);
 179
 180                 iter.data_buf = kaddr + bv.bv_offset;
 181                 iter.data_size = bv.bv_len;
 182
 183                 ret = proc_fn(&iter);
 184                 if (ret) {
 185                         kunmap_atomic(kaddr);
 186                         return ret;
 187                 }
 188
 189                 kunmap_atomic(kaddr);
 190         }
 191         return ret;
 192 }
 193
 194 /**
 195  * bio_integrity_prep - Prepare bio for integrity I/O
 196  * @bio:        bio to prepare
 197  *
 198  * Description:  Checks if the bio already has an integrity payload attached.
 199  * If it does, the payload has been generated by another kernel subsystem,
 200  * and we just pass it through. Otherwise allocates integrity payload.
 201  * The bio must have data direction, target device and start sector set priot
 202  * to calling.  In the WRITE case, integrity metadata will be generated using
 203  * the block device's integrity function.  In the READ case, the buffer
 204  * will be prepared for DMA and a suitable end_io handler set up.
 205  */
 206 bool bio_integrity_prep(struct bio *bio)
 207 {
 208         struct bio_integrity_payload *bip;
 209         struct blk_integrity *bi = blk_get_integrity(bio->bi_bdev->bd_disk);
 210         struct request_queue *q = bio->bi_bdev->bd_disk->queue;
 211         void *buf;
 212         unsigned long start, end;
 213         unsigned int len, nr_pages;
 214         unsigned int bytes, offset, i;
 215         unsigned int intervals;
 216         blk_status_t status;
 217
 218         if (!bi)
 219                 return true;
 220
 221         if (bio_op(bio) != REQ_OP_READ && bio_op(bio) != REQ_OP_WRITE)
 222                 return true;
 223
 224         if (!bio_sectors(bio))
 225                 return true;
 226
 227         /* Already protected? */
 228         if (bio_integrity(bio))
 229                 return true;
 230
 231         if (bio_data_dir(bio) == READ) {
 232                 if (!bi->profile->verify_fn ||
 233                     !(bi->flags & BLK_INTEGRITY_VERIFY))
 234                         return true;
 235         } else {
 236                 if (!bi->profile->generate_fn ||
 237                     !(bi->flags & BLK_INTEGRITY_GENERATE))
 238                         return true;
 239         }
 240         intervals = bio_integrity_intervals(bi, bio_sectors(bio));
 241
 242         /* Allocate kernel buffer for protection data */
 243         len = intervals * bi->tuple_size;
 244         buf = kmalloc(len, GFP_NOIO | q->bounce_gfp);
 245         status = BLK_STS_RESOURCE;
 246         if (unlikely(buf == NULL)) {
 247                 printk(KERN_ERR "could not allocate integrity buffer\n");
 248                 goto err_end_io;
 249         }
 250
 251         end = (((unsigned long) buf) + len + PAGE_SIZE - 1) >> PAGE_SHIFT;
 252         start = ((unsigned long) buf) >> PAGE_SHIFT;
 253         nr_pages = end - start;
 254
 255         /* Allocate bio integrity payload and integrity vectors */
 256         bip = bio_integrity_alloc(bio, GFP_NOIO, nr_pages);
 257         if (IS_ERR(bip)) {
 258                 printk(KERN_ERR "could not allocate data integrity bioset\n");
 259                 kfree(buf);
 260                 status = BLK_STS_RESOURCE;
 261                 goto err_end_io;
 262         }
 263
 264         bip->bip_flags |= BIP_BLOCK_INTEGRITY;
 265         bip->bip_iter.bi_size = len;
 266         bip_set_seed(bip, bio->bi_iter.bi_sector);
 267
 268         if (bi->flags & BLK_INTEGRITY_IP_CHECKSUM)
 269                 bip->bip_flags |= BIP_IP_CHECKSUM;
 270
 271         /* Map it */
 272         offset = offset_in_page(buf);
 273         for (i = 0 ; i < nr_pages ; i++) {
 274                 int ret;
 275                 bytes = PAGE_SIZE - offset;
 276
 277                 if (len <= 0)
 278                         break;
 279
 280                 if (bytes > len)
 281                         bytes = len;
 282
 283                 ret = bio_integrity_add_page(bio, virt_to_page(buf),
 284                                              bytes, offset);
 285
 286                 if (ret == 0) {
 287                         printk(KERN_ERR "could not attach integrity payload\n");
 288                         status = BLK_STS_RESOURCE;
 289                         goto err_end_io;
 290                 }
 291
 292                 if (ret < bytes)
 293                         break;
 294
 295                 buf += bytes;
 296                 len -= bytes;
 297                 offset = 0;
 298         }
 299
 300         /* Auto-generate integrity metadata if this is a write */
 301         if (bio_data_dir(bio) == WRITE) {
 302                 bio_integrity_process(bio, &bio->bi_iter,
 303                                       bi->profile->generate_fn);
 304         } else {
 305                 bip->bio_iter = bio->bi_iter;
 306         }
 307         return true;
 308
 309 err_end_io:
 310         bio->bi_status = status;
 311         bio_endio(bio);
 312         return false;
 313
 314 }
 315 EXPORT_SYMBOL(bio_integrity_prep);
 316
 317 /**
 318  * bio_integrity_verify_fn - Integrity I/O completion worker
 319  * @work:       Work struct stored in bio to be verified
 320  *
 321  * Description: This workqueue function is called to complete a READ
 322  * request.  The function verifies the transferred integrity metadata
 323  * and then calls the original bio end_io function.
 324  */
 325 static void bio_integrity_verify_fn(struct work_struct *work)
 326 {
 327         struct bio_integrity_payload *bip =
 328                 container_of(work, struct bio_integrity_payload, bip_work);
 329         struct bio *bio = bip->bip_bio;
 330         struct blk_integrity *bi = blk_get_integrity(bio->bi_bdev->bd_disk);
 331
 332         /*
 333          * At the moment verify is called bio's iterator was advanced
 334          * during split and completion, we need to rewind iterator to
 335          * it's original position.
 336          */
 337         bio->bi_status = bio_integrity_process(bio, &bip->bio_iter,
 338                                                 bi->profile->verify_fn);
 339         bio_integrity_free(bio);
 340         bio_endio(bio);
 341 }
 342
 343 /**
 344  * __bio_integrity_endio - Integrity I/O completion function
 345  * @bio:        Protected bio
 346  *
 347  * Description: Completion for integrity I/O
 348  *
 349  * Normally I/O completion is done in interrupt context.  However,
 350  * verifying I/O integrity is a time-consuming task which must be run
 351  * in process context.  This function postpones completion
 352  * accordingly.
 353  */
 354 bool __bio_integrity_endio(struct bio *bio)
 355 {
 356         struct blk_integrity *bi = blk_get_integrity(bio->bi_bdev->bd_disk);
 357         struct bio_integrity_payload *bip = bio_integrity(bio);
 358
 359         if (bio_op(bio) == REQ_OP_READ && !bio->bi_status &&
 360             (bip->bip_flags & BIP_BLOCK_INTEGRITY) && bi->profile->verify_fn) {
 361                 INIT_WORK(&bip->bip_work, bio_integrity_verify_fn);
 362                 queue_work(kintegrityd_wq, &bip->bip_work);
 363                 return false;
 364         }
 365
 366         bio_integrity_free(bio);
 367         return true;
 368 }
 369
 370 /**
 371  * bio_integrity_advance - Advance integrity vector
 372  * @bio:        bio whose integrity vector to update
 373  * @bytes_done: number of data bytes that have been completed
 374  *
 375  * Description: This function calculates how many integrity bytes the
 376  * number of completed data bytes correspond to and advances the
 377  * integrity vector accordingly.
 378  */
 379 void bio_integrity_advance(struct bio *bio, unsigned int bytes_done)
 380 {
 381         struct bio_integrity_payload *bip = bio_integrity(bio);
 382         struct blk_integrity *bi = blk_get_integrity(bio->bi_bdev->bd_disk);
 383         unsigned bytes = bio_integrity_bytes(bi, bytes_done >> 9);
 384
 385         bip->bip_iter.bi_sector += bytes_done >> 9;
 386         bvec_iter_advance(bip->bip_vec, &bip->bip_iter, bytes);
 387 }
 388
 389 /**
 390  * bio_integrity_trim - Trim integrity vector
 391  * @bio:        bio whose integrity vector to update
 392  *
 393  * Description: Used to trim the integrity vector in a cloned bio.
 394  */
 395 void bio_integrity_trim(struct bio *bio)
 396 {
 397         struct bio_integrity_payload *bip = bio_integrity(bio);
 398         struct blk_integrity *bi = blk_get_integrity(bio->bi_bdev->bd_disk);
 399
 400         bip->bip_iter.bi_size = bio_integrity_bytes(bi, bio_sectors(bio));
 401 }
 402 EXPORT_SYMBOL(bio_integrity_trim);
 403
 404 /**
 405  * bio_integrity_clone - Callback for cloning bios with integrity metadata
 406  * @bio:        New bio
 407  * @bio_src:    Original bio
 408  * @gfp_mask:   Memory allocation mask
 409  *
 410  * Description: Called to allocate a bip when cloning a bio
 411  */
 412 int bio_integrity_clone(struct bio *bio, struct bio *bio_src,
 413                         gfp_t gfp_mask)
 414 {
 415         struct bio_integrity_payload *bip_src = bio_integrity(bio_src);
 416         struct bio_integrity_payload *bip;
 417
 418         BUG_ON(bip_src == NULL);
 419
 420         bip = bio_integrity_alloc(bio, gfp_mask, bip_src->bip_vcnt);
 421         if (IS_ERR(bip))
 422                 return PTR_ERR(bip);
 423
 424         memcpy(bip->bip_vec, bip_src->bip_vec,
 425                bip_src->bip_vcnt * sizeof(struct bio_vec));
 426
 427         bip->bip_vcnt = bip_src->bip_vcnt;
 428         bip->bip_iter = bip_src->bip_iter;
 429
 430         return 0;
 431 }
 432 EXPORT_SYMBOL(bio_integrity_clone);
 433
 434 int bioset_integrity_create(struct bio_set *bs, int pool_size)
 435 {
 436         if (mempool_initialized(&bs->bio_integrity_pool))
 437                 return 0;
 438
 439         if (mempool_init_slab_pool(&bs->bio_integrity_pool,
 440                                    pool_size, bip_slab))
 441                 return -1;
 442
 443         if (biovec_init_pool(&bs->bvec_integrity_pool, pool_size)) {
 444                 mempool_exit(&bs->bio_integrity_pool);
 445                 return -1;
 446         }
 447
 448         return 0;
 449 }
 450 EXPORT_SYMBOL(bioset_integrity_create);
 451
 452 void bioset_integrity_free(struct bio_set *bs)
 453 {
 454         mempool_exit(&bs->bio_integrity_pool);
 455         mempool_exit(&bs->bvec_integrity_pool);
 456 }
 457
 458 void __init bio_integrity_init(void)
 459 {
 460         /*
 461          * kintegrityd won't block much but may burn a lot of CPU cycles.
 462          * Make it highpri CPU intensive wq with max concurrency of 1.
 463          */
 464         kintegrityd_wq = alloc_workqueue("kintegrityd", WQ_MEM_RECLAIM |
 465                                          WQ_HIGHPRI | WQ_CPU_INTENSIVE, 1);
 466         if (!kintegrityd_wq)
 467                 panic("Failed to create kintegrityd\n");
 468
 469         bip_slab = kmem_cache_create("bio_integrity_payload",
 470                                      sizeof(struct bio_integrity_payload) +
 471                                      sizeof(struct bio_vec) * BIO_INLINE_VECS,
 472                                      0, SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
 473 }