fs/bio-integrity.c

   1 /*
   2  * bio-integrity.c - bio data integrity extensions
   3  *
   4  * Copyright (C) 2007, 2008, 2009 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/mempool.h>
  25 #include <linux/bio.h>
  26 #include <linux/workqueue.h>
  27
  28 struct integrity_slab {
  29         struct kmem_cache *slab;
  30         unsigned short nr_vecs;
  31         char name[8];
  32 };
  33
  34 #define IS(x) { .nr_vecs = x, .name = "bip-"__stringify(x) }
  35 struct integrity_slab bip_slab[BIOVEC_NR_POOLS] __read_mostly = {
  36         IS(1), IS(4), IS(16), IS(64), IS(128), IS(BIO_MAX_PAGES),
  37 };
  38 #undef IS
  39
  40 static struct workqueue_struct *kintegrityd_wq;
  41
  42 static inline unsigned int vecs_to_idx(unsigned int nr)
  43 {
  44         switch (nr) {
  45         case 1:
  46                 return 0;
  47         case 2 ... 4:
  48                 return 1;
  49         case 5 ... 16:
  50                 return 2;
  51         case 17 ... 64:
  52                 return 3;
  53         case 65 ... 128:
  54                 return 4;
  55         case 129 ... BIO_MAX_PAGES:
  56                 return 5;
  57         default:
  58                 BUG();
  59         }
  60 }
  61
  62 static inline int use_bip_pool(unsigned int idx)
  63 {
  64         if (idx == BIOVEC_MAX_IDX)
  65                 return 1;
  66
  67         return 0;
  68 }
  69
  70 /**
  71  * bio_integrity_alloc_bioset - Allocate integrity payload and attach it to bio
  72  * @bio:        bio to attach integrity metadata to
  73  * @gfp_mask:   Memory allocation mask
  74  * @nr_vecs:    Number of integrity metadata scatter-gather elements
  75  * @bs:         bio_set to allocate from
  76  *
  77  * Description: This function prepares a bio for attaching integrity
  78  * metadata.  nr_vecs specifies the maximum number of pages containing
  79  * integrity metadata that can be attached.
  80  */
  81 struct bio_integrity_payload *bio_integrity_alloc_bioset(struct bio *bio,
  82                                                          gfp_t gfp_mask,
  83                                                          unsigned int nr_vecs,
  84                                                          struct bio_set *bs)
  85 {
  86         struct bio_integrity_payload *bip;
  87         unsigned int idx = vecs_to_idx(nr_vecs);
  88
  89         BUG_ON(bio == NULL);
  90         bip = NULL;
  91
  92         /* Lower order allocations come straight from slab */
  93         if (!use_bip_pool(idx))
  94                 bip = kmem_cache_alloc(bip_slab[idx].slab, gfp_mask);
  95
  96         /* Use mempool if lower order alloc failed or max vecs were requested */
  97         if (bip == NULL) {
  98                 idx = BIOVEC_MAX_IDX;  /* so we free the payload properly later */
  99                 bip = mempool_alloc(bs->bio_integrity_pool, gfp_mask);
 100
 101                 if (unlikely(bip == NULL)) {
 102                         printk(KERN_ERR "%s: could not alloc bip\n", __func__);
 103                         return NULL;
 104                 }
 105         }
 106
 107         memset(bip, 0, sizeof(*bip));
 108
 109         bip->bip_slab = idx;
 110         bip->bip_bio = bio;
 111         bio->bi_integrity = bip;
 112
 113         return bip;
 114 }
 115 EXPORT_SYMBOL(bio_integrity_alloc_bioset);
 116
 117 /**
 118  * bio_integrity_alloc - Allocate integrity payload and attach it to bio
 119  * @bio:        bio to attach integrity metadata to
 120  * @gfp_mask:   Memory allocation mask
 121  * @nr_vecs:    Number of integrity metadata scatter-gather elements
 122  *
 123  * Description: This function prepares a bio for attaching integrity
 124  * metadata.  nr_vecs specifies the maximum number of pages containing
 125  * integrity metadata that can be attached.
 126  */
 127 struct bio_integrity_payload *bio_integrity_alloc(struct bio *bio,
 128                                                   gfp_t gfp_mask,
 129                                                   unsigned int nr_vecs)
 130 {
 131         return bio_integrity_alloc_bioset(bio, gfp_mask, nr_vecs, fs_bio_set);
 132 }
 133 EXPORT_SYMBOL(bio_integrity_alloc);
 134
 135 /**
 136  * bio_integrity_free - Free bio integrity payload
 137  * @bio:        bio containing bip to be freed
 138  * @bs:         bio_set this bio was allocated from
 139  *
 140  * Description: Used to free the integrity portion of a bio. Usually
 141  * called from bio_free().
 142  */
 143 void bio_integrity_free(struct bio *bio, struct bio_set *bs)
 144 {
 145         struct bio_integrity_payload *bip = bio->bi_integrity;
 146
 147         BUG_ON(bip == NULL);
 148
 149         /* A cloned bio doesn't own the integrity metadata */
 150         if (!bio_flagged(bio, BIO_CLONED) && !bio_flagged(bio, BIO_FS_INTEGRITY)
 151             && bip->bip_buf != NULL)
 152                 kfree(bip->bip_buf);
 153
 154         if (use_bip_pool(bip->bip_slab))
 155                 mempool_free(bip, bs->bio_integrity_pool);
 156         else
 157                 kmem_cache_free(bip_slab[bip->bip_slab].slab, bip);
 158
 159         bio->bi_integrity = NULL;
 160 }
 161 EXPORT_SYMBOL(bio_integrity_free);
 162
 163 /**
 164  * bio_integrity_add_page - Attach integrity metadata
 165  * @bio:        bio to update
 166  * @page:       page containing integrity metadata
 167  * @len:        number of bytes of integrity metadata in page
 168  * @offset:     start offset within page
 169  *
 170  * Description: Attach a page containing integrity metadata to bio.
 171  */
 172 int bio_integrity_add_page(struct bio *bio, struct page *page,
 173                            unsigned int len, unsigned int offset)
 174 {
 175         struct bio_integrity_payload *bip = bio->bi_integrity;
 176         struct bio_vec *iv;
 177
 178         if (bip->bip_vcnt >= bvec_nr_vecs(bip->bip_slab)) {
 179                 printk(KERN_ERR "%s: bip_vec full\n", __func__);
 180                 return 0;
 181         }
 182
 183         iv = bip_vec_idx(bip, bip->bip_vcnt);
 184         BUG_ON(iv == NULL);
 185
 186         iv->bv_page = page;
 187         iv->bv_len = len;
 188         iv->bv_offset = offset;
 189         bip->bip_vcnt++;
 190
 191         return len;
 192 }
 193 EXPORT_SYMBOL(bio_integrity_add_page);
 194
 195 static int bdev_integrity_enabled(struct block_device *bdev, int rw)
 196 {
 197         struct blk_integrity *bi = bdev_get_integrity(bdev);
 198
 199         if (bi == NULL)
 200                 return 0;
 201
 202         if (rw == READ && bi->verify_fn != NULL &&
 203             (bi->flags & INTEGRITY_FLAG_READ))
 204                 return 1;
 205
 206         if (rw == WRITE && bi->generate_fn != NULL &&
 207             (bi->flags & INTEGRITY_FLAG_WRITE))
 208                 return 1;
 209
 210         return 0;
 211 }
 212
 213 /**
 214  * bio_integrity_enabled - Check whether integrity can be passed
 215  * @bio:        bio to check
 216  *
 217  * Description: Determines whether bio_integrity_prep() can be called
 218  * on this bio or not.  bio data direction and target device must be
 219  * set prior to calling.  The functions honors the write_generate and
 220  * read_verify flags in sysfs.
 221  */
 222 int bio_integrity_enabled(struct bio *bio)
 223 {
 224         /* Already protected? */
 225         if (bio_integrity(bio))
 226                 return 0;
 227
 228         return bdev_integrity_enabled(bio->bi_bdev, bio_data_dir(bio));
 229 }
 230 EXPORT_SYMBOL(bio_integrity_enabled);
 231
 232 /**
 233  * bio_integrity_hw_sectors - Convert 512b sectors to hardware ditto
 234  * @bi:         blk_integrity profile for device
 235  * @sectors:    Number of 512 sectors to convert
 236  *
 237  * Description: The block layer calculates everything in 512 byte
 238  * sectors but integrity metadata is done in terms of the hardware
 239  * sector size of the storage device.  Convert the block layer sectors
 240  * to physical sectors.
 241  */
 242 static inline unsigned int bio_integrity_hw_sectors(struct blk_integrity *bi,
 243                                                     unsigned int sectors)
 244 {
 245         /* At this point there are only 512b or 4096b DIF/EPP devices */
 246         if (bi->sector_size == 4096)
 247                 return sectors >>= 3;
 248
 249         return sectors;
 250 }
 251
 252 /**
 253  * bio_integrity_tag_size - Retrieve integrity tag space
 254  * @bio:        bio to inspect
 255  *
 256  * Description: Returns the maximum number of tag bytes that can be
 257  * attached to this bio. Filesystems can use this to determine how
 258  * much metadata to attach to an I/O.
 259  */
 260 unsigned int bio_integrity_tag_size(struct bio *bio)
 261 {
 262         struct blk_integrity *bi = bdev_get_integrity(bio->bi_bdev);
 263
 264         BUG_ON(bio->bi_size == 0);
 265
 266         return bi->tag_size * (bio->bi_size / bi->sector_size);
 267 }
 268 EXPORT_SYMBOL(bio_integrity_tag_size);
 269
 270 int bio_integrity_tag(struct bio *bio, void *tag_buf, unsigned int len, int set)
 271 {
 272         struct bio_integrity_payload *bip = bio->bi_integrity;
 273         struct blk_integrity *bi = bdev_get_integrity(bio->bi_bdev);
 274         unsigned int nr_sectors;
 275
 276         BUG_ON(bip->bip_buf == NULL);
 277
 278         if (bi->tag_size == 0)
 279                 return -1;
 280
 281         nr_sectors = bio_integrity_hw_sectors(bi,
 282                                         DIV_ROUND_UP(len, bi->tag_size));
 283
 284         if (nr_sectors * bi->tuple_size > bip->bip_size) {
 285                 printk(KERN_ERR "%s: tag too big for bio: %u > %u\n",
 286                        __func__, nr_sectors * bi->tuple_size, bip->bip_size);
 287                 return -1;
 288         }
 289
 290         if (set)
 291                 bi->set_tag_fn(bip->bip_buf, tag_buf, nr_sectors);
 292         else
 293                 bi->get_tag_fn(bip->bip_buf, tag_buf, nr_sectors);
 294
 295         return 0;
 296 }
 297
 298 /**
 299  * bio_integrity_set_tag - Attach a tag buffer to a bio
 300  * @bio:        bio to attach buffer to
 301  * @tag_buf:    Pointer to a buffer containing tag data
 302  * @len:        Length of the included buffer
 303  *
 304  * Description: Use this function to tag a bio by leveraging the extra
 305  * space provided by devices formatted with integrity protection.  The
 306  * size of the integrity buffer must be <= to the size reported by
 307  * bio_integrity_tag_size().
 308  */
 309 int bio_integrity_set_tag(struct bio *bio, void *tag_buf, unsigned int len)
 310 {
 311         BUG_ON(bio_data_dir(bio) != WRITE);
 312
 313         return bio_integrity_tag(bio, tag_buf, len, 1);
 314 }
 315 EXPORT_SYMBOL(bio_integrity_set_tag);
 316
 317 /**
 318  * bio_integrity_get_tag - Retrieve a tag buffer from a bio
 319  * @bio:        bio to retrieve buffer from
 320  * @tag_buf:    Pointer to a buffer for the tag data
 321  * @len:        Length of the target buffer
 322  *
 323  * Description: Use this function to retrieve the tag buffer from a
 324  * completed I/O. The size of the integrity buffer must be <= to the
 325  * size reported by bio_integrity_tag_size().
 326  */
 327 int bio_integrity_get_tag(struct bio *bio, void *tag_buf, unsigned int len)
 328 {
 329         BUG_ON(bio_data_dir(bio) != READ);
 330
 331         return bio_integrity_tag(bio, tag_buf, len, 0);
 332 }
 333 EXPORT_SYMBOL(bio_integrity_get_tag);
 334
 335 /**
 336  * bio_integrity_generate - Generate integrity metadata for a bio
 337  * @bio:        bio to generate integrity metadata for
 338  *
 339  * Description: Generates integrity metadata for a bio by calling the
 340  * block device's generation callback function.  The bio must have a
 341  * bip attached with enough room to accommodate the generated
 342  * integrity metadata.
 343  */
 344 static void bio_integrity_generate(struct bio *bio)
 345 {
 346         struct blk_integrity *bi = bdev_get_integrity(bio->bi_bdev);
 347         struct blk_integrity_exchg bix;
 348         struct bio_vec *bv;
 349         sector_t sector = bio->bi_sector;
 350         unsigned int i, sectors, total;
 351         void *prot_buf = bio->bi_integrity->bip_buf;
 352
 353         total = 0;
 354         bix.disk_name = bio->bi_bdev->bd_disk->disk_name;
 355         bix.sector_size = bi->sector_size;
 356
 357         bio_for_each_segment(bv, bio, i) {
 358                 void *kaddr = kmap_atomic(bv->bv_page, KM_USER0);
 359                 bix.data_buf = kaddr + bv->bv_offset;
 360                 bix.data_size = bv->bv_len;
 361                 bix.prot_buf = prot_buf;
 362                 bix.sector = sector;
 363
 364                 bi->generate_fn(&bix);
 365
 366                 sectors = bv->bv_len / bi->sector_size;
 367                 sector += sectors;
 368                 prot_buf += sectors * bi->tuple_size;
 369                 total += sectors * bi->tuple_size;
 370                 BUG_ON(total > bio->bi_integrity->bip_size);
 371
 372                 kunmap_atomic(kaddr, KM_USER0);
 373         }
 374 }
 375
 376 static inline unsigned short blk_integrity_tuple_size(struct blk_integrity *bi)
 377 {
 378         if (bi)
 379                 return bi->tuple_size;
 380
 381         return 0;
 382 }
 383
 384 /**
 385  * bio_integrity_prep - Prepare bio for integrity I/O
 386  * @bio:        bio to prepare
 387  *
 388  * Description: Allocates a buffer for integrity metadata, maps the
 389  * pages and attaches them to a bio.  The bio must have data
 390  * direction, target device and start sector set priot to calling.  In
 391  * the WRITE case, integrity metadata will be generated using the
 392  * block device's integrity function.  In the READ case, the buffer
 393  * will be prepared for DMA and a suitable end_io handler set up.
 394  */
 395 int bio_integrity_prep(struct bio *bio)
 396 {
 397         struct bio_integrity_payload *bip;
 398         struct blk_integrity *bi;
 399         struct request_queue *q;
 400         void *buf;
 401         unsigned long start, end;
 402         unsigned int len, nr_pages;
 403         unsigned int bytes, offset, i;
 404         unsigned int sectors;
 405
 406         bi = bdev_get_integrity(bio->bi_bdev);
 407         q = bdev_get_queue(bio->bi_bdev);
 408         BUG_ON(bi == NULL);
 409         BUG_ON(bio_integrity(bio));
 410
 411         sectors = bio_integrity_hw_sectors(bi, bio_sectors(bio));
 412
 413         /* Allocate kernel buffer for protection data */
 414         len = sectors * blk_integrity_tuple_size(bi);
 415         buf = kmalloc(len, GFP_NOIO | __GFP_NOFAIL | q->bounce_gfp);
 416         if (unlikely(buf == NULL)) {
 417                 printk(KERN_ERR "could not allocate integrity buffer\n");
 418                 return -EIO;
 419         }
 420
 421         end = (((unsigned long) buf) + len + PAGE_SIZE - 1) >> PAGE_SHIFT;
 422         start = ((unsigned long) buf) >> PAGE_SHIFT;
 423         nr_pages = end - start;
 424
 425         /* Allocate bio integrity payload and integrity vectors */
 426         bip = bio_integrity_alloc(bio, GFP_NOIO, nr_pages);
 427         if (unlikely(bip == NULL)) {
 428                 printk(KERN_ERR "could not allocate data integrity bioset\n");
 429                 kfree(buf);
 430                 return -EIO;
 431         }
 432
 433         bip->bip_buf = buf;
 434         bip->bip_size = len;
 435         bip->bip_sector = bio->bi_sector;
 436
 437         /* Map it */
 438         offset = offset_in_page(buf);
 439         for (i = 0 ; i < nr_pages ; i++) {
 440                 int ret;
 441                 bytes = PAGE_SIZE - offset;
 442
 443                 if (len <= 0)
 444                         break;
 445
 446                 if (bytes > len)
 447                         bytes = len;
 448
 449                 ret = bio_integrity_add_page(bio, virt_to_page(buf),
 450                                              bytes, offset);
 451
 452                 if (ret == 0)
 453                         return 0;
 454
 455                 if (ret < bytes)
 456                         break;
 457
 458                 buf += bytes;
 459                 len -= bytes;
 460                 offset = 0;
 461         }
 462
 463         /* Install custom I/O completion handler if read verify is enabled */
 464         if (bio_data_dir(bio) == READ) {
 465                 bip->bip_end_io = bio->bi_end_io;
 466                 bio->bi_end_io = bio_integrity_endio;
 467         }
 468
 469         /* Auto-generate integrity metadata if this is a write */
 470         if (bio_data_dir(bio) == WRITE)
 471                 bio_integrity_generate(bio);
 472
 473         return 0;
 474 }
 475 EXPORT_SYMBOL(bio_integrity_prep);
 476
 477 /**
 478  * bio_integrity_verify - Verify integrity metadata for a bio
 479  * @bio:        bio to verify
 480  *
 481  * Description: This function is called to verify the integrity of a
 482  * bio.  The data in the bio io_vec is compared to the integrity
 483  * metadata returned by the HBA.
 484  */
 485 static int bio_integrity_verify(struct bio *bio)
 486 {
 487         struct blk_integrity *bi = bdev_get_integrity(bio->bi_bdev);
 488         struct blk_integrity_exchg bix;
 489         struct bio_vec *bv;
 490         sector_t sector = bio->bi_integrity->bip_sector;
 491         unsigned int i, sectors, total, ret;
 492         void *prot_buf = bio->bi_integrity->bip_buf;
 493
 494         ret = total = 0;
 495         bix.disk_name = bio->bi_bdev->bd_disk->disk_name;
 496         bix.sector_size = bi->sector_size;
 497
 498         bio_for_each_segment(bv, bio, i) {
 499                 void *kaddr = kmap_atomic(bv->bv_page, KM_USER0);
 500                 bix.data_buf = kaddr + bv->bv_offset;
 501                 bix.data_size = bv->bv_len;
 502                 bix.prot_buf = prot_buf;
 503                 bix.sector = sector;
 504
 505                 ret = bi->verify_fn(&bix);
 506
 507                 if (ret) {
 508                         kunmap_atomic(kaddr, KM_USER0);
 509                         return ret;
 510                 }
 511
 512                 sectors = bv->bv_len / bi->sector_size;
 513                 sector += sectors;
 514                 prot_buf += sectors * bi->tuple_size;
 515                 total += sectors * bi->tuple_size;
 516                 BUG_ON(total > bio->bi_integrity->bip_size);
 517
 518                 kunmap_atomic(kaddr, KM_USER0);
 519         }
 520
 521         return ret;
 522 }
 523
 524 /**
 525  * bio_integrity_verify_fn - Integrity I/O completion worker
 526  * @work:       Work struct stored in bio to be verified
 527  *
 528  * Description: This workqueue function is called to complete a READ
 529  * request.  The function verifies the transferred integrity metadata
 530  * and then calls the original bio end_io function.
 531  */
 532 static void bio_integrity_verify_fn(struct work_struct *work)
 533 {
 534         struct bio_integrity_payload *bip =
 535                 container_of(work, struct bio_integrity_payload, bip_work);
 536         struct bio *bio = bip->bip_bio;
 537         int error;
 538
 539         error = bio_integrity_verify(bio);
 540
 541         /* Restore original bio completion handler */
 542         bio->bi_end_io = bip->bip_end_io;
 543         bio_endio(bio, error);
 544 }
 545
 546 /**
 547  * bio_integrity_endio - Integrity I/O completion function
 548  * @bio:        Protected bio
 549  * @error:      Pointer to errno
 550  *
 551  * Description: Completion for integrity I/O
 552  *
 553  * Normally I/O completion is done in interrupt context.  However,
 554  * verifying I/O integrity is a time-consuming task which must be run
 555  * in process context.  This function postpones completion
 556  * accordingly.
 557  */
 558 void bio_integrity_endio(struct bio *bio, int error)
 559 {
 560         struct bio_integrity_payload *bip = bio->bi_integrity;
 561
 562         BUG_ON(bip->bip_bio != bio);
 563
 564         /* In case of an I/O error there is no point in verifying the
 565          * integrity metadata.  Restore original bio end_io handler
 566          * and run it.
 567          */
 568         if (error) {
 569                 bio->bi_end_io = bip->bip_end_io;
 570                 bio_endio(bio, error);
 571
 572                 return;
 573         }
 574
 575         INIT_WORK(&bip->bip_work, bio_integrity_verify_fn);
 576         queue_work(kintegrityd_wq, &bip->bip_work);
 577 }
 578 EXPORT_SYMBOL(bio_integrity_endio);
 579
 580 /**
 581  * bio_integrity_mark_head - Advance bip_vec skip bytes
 582  * @bip:        Integrity vector to advance
 583  * @skip:       Number of bytes to advance it
 584  */
 585 void bio_integrity_mark_head(struct bio_integrity_payload *bip,
 586                              unsigned int skip)
 587 {
 588         struct bio_vec *iv;
 589         unsigned int i;
 590
 591         bip_for_each_vec(iv, bip, i) {
 592                 if (skip == 0) {
 593                         bip->bip_idx = i;
 594                         return;
 595                 } else if (skip >= iv->bv_len) {
 596                         skip -= iv->bv_len;
 597                 } else { /* skip < iv->bv_len) */
 598                         iv->bv_offset += skip;
 599                         iv->bv_len -= skip;
 600                         bip->bip_idx = i;
 601                         return;
 602                 }
 603         }
 604 }
 605
 606 /**
 607  * bio_integrity_mark_tail - Truncate bip_vec to be len bytes long
 608  * @bip:        Integrity vector to truncate
 609  * @len:        New length of integrity vector
 610  */
 611 void bio_integrity_mark_tail(struct bio_integrity_payload *bip,
 612                              unsigned int len)
 613 {
 614         struct bio_vec *iv;
 615         unsigned int i;
 616
 617         bip_for_each_vec(iv, bip, i) {
 618                 if (len == 0) {
 619                         bip->bip_vcnt = i;
 620                         return;
 621                 } else if (len >= iv->bv_len) {
 622                         len -= iv->bv_len;
 623                 } else { /* len < iv->bv_len) */
 624                         iv->bv_len = len;
 625                         len = 0;
 626                 }
 627         }
 628 }
 629
 630 /**
 631  * bio_integrity_advance - Advance integrity vector
 632  * @bio:        bio whose integrity vector to update
 633  * @bytes_done: number of data bytes that have been completed
 634  *
 635  * Description: This function calculates how many integrity bytes the
 636  * number of completed data bytes correspond to and advances the
 637  * integrity vector accordingly.
 638  */
 639 void bio_integrity_advance(struct bio *bio, unsigned int bytes_done)
 640 {
 641         struct bio_integrity_payload *bip = bio->bi_integrity;
 642         struct blk_integrity *bi = bdev_get_integrity(bio->bi_bdev);
 643         unsigned int nr_sectors;
 644
 645         BUG_ON(bip == NULL);
 646         BUG_ON(bi == NULL);
 647
 648         nr_sectors = bio_integrity_hw_sectors(bi, bytes_done >> 9);
 649         bio_integrity_mark_head(bip, nr_sectors * bi->tuple_size);
 650 }
 651 EXPORT_SYMBOL(bio_integrity_advance);
 652
 653 /**
 654  * bio_integrity_trim - Trim integrity vector
 655  * @bio:        bio whose integrity vector to update
 656  * @offset:     offset to first data sector
 657  * @sectors:    number of data sectors
 658  *
 659  * Description: Used to trim the integrity vector in a cloned bio.
 660  * The ivec will be advanced corresponding to 'offset' data sectors
 661  * and the length will be truncated corresponding to 'len' data
 662  * sectors.
 663  */
 664 void bio_integrity_trim(struct bio *bio, unsigned int offset,
 665                         unsigned int sectors)
 666 {
 667         struct bio_integrity_payload *bip = bio->bi_integrity;
 668         struct blk_integrity *bi = bdev_get_integrity(bio->bi_bdev);
 669         unsigned int nr_sectors;
 670
 671         BUG_ON(bip == NULL);
 672         BUG_ON(bi == NULL);
 673         BUG_ON(!bio_flagged(bio, BIO_CLONED));
 674
 675         nr_sectors = bio_integrity_hw_sectors(bi, sectors);
 676         bip->bip_sector = bip->bip_sector + offset;
 677         bio_integrity_mark_head(bip, offset * bi->tuple_size);
 678         bio_integrity_mark_tail(bip, sectors * bi->tuple_size);
 679 }
 680 EXPORT_SYMBOL(bio_integrity_trim);
 681
 682 /**
 683  * bio_integrity_split - Split integrity metadata
 684  * @bio:        Protected bio
 685  * @bp:         Resulting bio_pair
 686  * @sectors:    Offset
 687  *
 688  * Description: Splits an integrity page into a bio_pair.
 689  */
 690 void bio_integrity_split(struct bio *bio, struct bio_pair *bp, int sectors)
 691 {
 692         struct blk_integrity *bi;
 693         struct bio_integrity_payload *bip = bio->bi_integrity;
 694         unsigned int nr_sectors;
 695
 696         if (bio_integrity(bio) == 0)
 697                 return;
 698
 699         bi = bdev_get_integrity(bio->bi_bdev);
 700         BUG_ON(bi == NULL);
 701         BUG_ON(bip->bip_vcnt != 1);
 702
 703         nr_sectors = bio_integrity_hw_sectors(bi, sectors);
 704
 705         bp->bio1.bi_integrity = &bp->bip1;
 706         bp->bio2.bi_integrity = &bp->bip2;
 707
 708         bp->iv1 = bip->bip_vec[0];
 709         bp->iv2 = bip->bip_vec[0];
 710
 711         bp->bip1.bip_vec[0] = bp->iv1;
 712         bp->bip2.bip_vec[0] = bp->iv2;
 713
 714         bp->iv1.bv_len = sectors * bi->tuple_size;
 715         bp->iv2.bv_offset += sectors * bi->tuple_size;
 716         bp->iv2.bv_len -= sectors * bi->tuple_size;
 717
 718         bp->bip1.bip_sector = bio->bi_integrity->bip_sector;
 719         bp->bip2.bip_sector = bio->bi_integrity->bip_sector + nr_sectors;
 720
 721         bp->bip1.bip_vcnt = bp->bip2.bip_vcnt = 1;
 722         bp->bip1.bip_idx = bp->bip2.bip_idx = 0;
 723 }
 724 EXPORT_SYMBOL(bio_integrity_split);
 725
 726 /**
 727  * bio_integrity_clone - Callback for cloning bios with integrity metadata
 728  * @bio:        New bio
 729  * @bio_src:    Original bio
 730  * @gfp_mask:   Memory allocation mask
 731  * @bs:         bio_set to allocate bip from
 732  *
 733  * Description: Called to allocate a bip when cloning a bio
 734  */
 735 int bio_integrity_clone(struct bio *bio, struct bio *bio_src,
 736                         gfp_t gfp_mask, struct bio_set *bs)
 737 {
 738         struct bio_integrity_payload *bip_src = bio_src->bi_integrity;
 739         struct bio_integrity_payload *bip;
 740
 741         BUG_ON(bip_src == NULL);
 742
 743         bip = bio_integrity_alloc_bioset(bio, gfp_mask, bip_src->bip_vcnt, bs);
 744
 745         if (bip == NULL)
 746                 return -EIO;
 747
 748         memcpy(bip->bip_vec, bip_src->bip_vec,
 749                bip_src->bip_vcnt * sizeof(struct bio_vec));
 750
 751         bip->bip_sector = bip_src->bip_sector;
 752         bip->bip_vcnt = bip_src->bip_vcnt;
 753         bip->bip_idx = bip_src->bip_idx;
 754
 755         return 0;
 756 }
 757 EXPORT_SYMBOL(bio_integrity_clone);
 758
 759 int bioset_integrity_create(struct bio_set *bs, int pool_size)
 760 {
 761         unsigned int max_slab = vecs_to_idx(BIO_MAX_PAGES);
 762
 763         bs->bio_integrity_pool =
 764                 mempool_create_slab_pool(pool_size, bip_slab[max_slab].slab);
 765
 766         if (!bs->bio_integrity_pool)
 767                 return -1;
 768
 769         return 0;
 770 }
 771 EXPORT_SYMBOL(bioset_integrity_create);
 772
 773 void bioset_integrity_free(struct bio_set *bs)
 774 {
 775         if (bs->bio_integrity_pool)
 776                 mempool_destroy(bs->bio_integrity_pool);
 777 }
 778 EXPORT_SYMBOL(bioset_integrity_free);
 779
 780 void __init bio_integrity_init(void)
 781 {
 782         unsigned int i;
 783
 784         kintegrityd_wq = create_workqueue("kintegrityd");
 785         if (!kintegrityd_wq)
 786                 panic("Failed to create kintegrityd\n");
 787
 788         for (i = 0 ; i < BIOVEC_NR_POOLS ; i++) {
 789                 unsigned int size;
 790
 791                 size = sizeof(struct bio_integrity_payload)
 792                         + bip_slab[i].nr_vecs * sizeof(struct bio_vec);
 793
 794                 bip_slab[i].slab =
 795                         kmem_cache_create(bip_slab[i].name, size, 0,
 796                                           SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
 797         }
 798 }