drivers/md/dm.c

   1 /*
   2  * Copyright (C) 2001, 2002 Sistina Software (UK) Limited.
   3  * Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved.
   4  *
   5  * This file is released under the GPL.
   6  */
   7
   8 #include "dm-core.h"
   9 #include "dm-rq.h"
  10 #include "dm-uevent.h"
  11 #include "dm-ima.h"
  12
  13 #include <linux/init.h>
  14 #include <linux/module.h>
  15 #include <linux/mutex.h>
  16 #include <linux/sched/mm.h>
  17 #include <linux/sched/signal.h>
  18 #include <linux/blkpg.h>
  19 #include <linux/bio.h>
  20 #include <linux/mempool.h>
  21 #include <linux/dax.h>
  22 #include <linux/slab.h>
  23 #include <linux/idr.h>
  24 #include <linux/uio.h>
  25 #include <linux/hdreg.h>
  26 #include <linux/delay.h>
  27 #include <linux/wait.h>
  28 #include <linux/pr.h>
  29 #include <linux/refcount.h>
  30 #include <linux/part_stat.h>
  31 #include <linux/blk-crypto.h>
  32 #include <linux/blk-crypto-profile.h>
  33
  34 #define DM_MSG_PREFIX "core"
  35
  36 /*
  37  * Cookies are numeric values sent with CHANGE and REMOVE
  38  * uevents while resuming, removing or renaming the device.
  39  */
  40 #define DM_COOKIE_ENV_VAR_NAME "DM_COOKIE"
  41 #define DM_COOKIE_LENGTH 24
  42
  43 static const char *_name = DM_NAME;
  44
  45 static unsigned int major = 0;
  46 static unsigned int _major = 0;
  47
  48 static DEFINE_IDR(_minor_idr);
  49
  50 static DEFINE_SPINLOCK(_minor_lock);
  51
  52 static void do_deferred_remove(struct work_struct *w);
  53
  54 static DECLARE_WORK(deferred_remove_work, do_deferred_remove);
  55
  56 static struct workqueue_struct *deferred_remove_workqueue;
  57
  58 atomic_t dm_global_event_nr = ATOMIC_INIT(0);
  59 DECLARE_WAIT_QUEUE_HEAD(dm_global_eventq);
  60
  61 void dm_issue_global_event(void)
  62 {
  63         atomic_inc(&dm_global_event_nr);
  64         wake_up(&dm_global_eventq);
  65 }
  66
  67 /*
  68  * One of these is allocated (on-stack) per original bio.
  69  */
  70 struct clone_info {
  71         struct dm_table *map;
  72         struct bio *bio;
  73         struct dm_io *io;
  74         sector_t sector;
  75         unsigned sector_count;
  76 };
  77
  78 #define DM_TARGET_IO_BIO_OFFSET (offsetof(struct dm_target_io, clone))
  79 #define DM_IO_BIO_OFFSET \
  80         (offsetof(struct dm_target_io, clone) + offsetof(struct dm_io, tio))
  81
  82 void *dm_per_bio_data(struct bio *bio, size_t data_size)
  83 {
  84         struct dm_target_io *tio = container_of(bio, struct dm_target_io, clone);
  85         if (!tio->inside_dm_io)
  86                 return (char *)bio - DM_TARGET_IO_BIO_OFFSET - data_size;
  87         return (char *)bio - DM_IO_BIO_OFFSET - data_size;
  88 }
  89 EXPORT_SYMBOL_GPL(dm_per_bio_data);
  90
  91 struct bio *dm_bio_from_per_bio_data(void *data, size_t data_size)
  92 {
  93         struct dm_io *io = (struct dm_io *)((char *)data + data_size);
  94         if (io->magic == DM_IO_MAGIC)
  95                 return (struct bio *)((char *)io + DM_IO_BIO_OFFSET);
  96         BUG_ON(io->magic != DM_TIO_MAGIC);
  97         return (struct bio *)((char *)io + DM_TARGET_IO_BIO_OFFSET);
  98 }
  99 EXPORT_SYMBOL_GPL(dm_bio_from_per_bio_data);
 100
 101 unsigned dm_bio_get_target_bio_nr(const struct bio *bio)
 102 {
 103         return container_of(bio, struct dm_target_io, clone)->target_bio_nr;
 104 }
 105 EXPORT_SYMBOL_GPL(dm_bio_get_target_bio_nr);
 106
 107 #define MINOR_ALLOCED ((void *)-1)
 108
 109 #define DM_NUMA_NODE NUMA_NO_NODE
 110 static int dm_numa_node = DM_NUMA_NODE;
 111
 112 #define DEFAULT_SWAP_BIOS       (8 * 1048576 / PAGE_SIZE)
 113 static int swap_bios = DEFAULT_SWAP_BIOS;
 114 static int get_swap_bios(void)
 115 {
 116         int latch = READ_ONCE(swap_bios);
 117         if (unlikely(latch <= 0))
 118                 latch = DEFAULT_SWAP_BIOS;
 119         return latch;
 120 }
 121
 122 /*
 123  * For mempools pre-allocation at the table loading time.
 124  */
 125 struct dm_md_mempools {
 126         struct bio_set bs;
 127         struct bio_set io_bs;
 128 };
 129
 130 struct table_device {
 131         struct list_head list;
 132         refcount_t count;
 133         struct dm_dev dm_dev;
 134 };
 135
 136 /*
 137  * Bio-based DM's mempools' reserved IOs set by the user.
 138  */
 139 #define RESERVED_BIO_BASED_IOS          16
 140 static unsigned reserved_bio_based_ios = RESERVED_BIO_BASED_IOS;
 141
 142 static int __dm_get_module_param_int(int *module_param, int min, int max)
 143 {
 144         int param = READ_ONCE(*module_param);
 145         int modified_param = 0;
 146         bool modified = true;
 147
 148         if (param < min)
 149                 modified_param = min;
 150         else if (param > max)
 151                 modified_param = max;
 152         else
 153                 modified = false;
 154
 155         if (modified) {
 156                 (void)cmpxchg(module_param, param, modified_param);
 157                 param = modified_param;
 158         }
 159
 160         return param;
 161 }
 162
 163 unsigned __dm_get_module_param(unsigned *module_param,
 164                                unsigned def, unsigned max)
 165 {
 166         unsigned param = READ_ONCE(*module_param);
 167         unsigned modified_param = 0;
 168
 169         if (!param)
 170                 modified_param = def;
 171         else if (param > max)
 172                 modified_param = max;
 173
 174         if (modified_param) {
 175                 (void)cmpxchg(module_param, param, modified_param);
 176                 param = modified_param;
 177         }
 178
 179         return param;
 180 }
 181
 182 unsigned dm_get_reserved_bio_based_ios(void)
 183 {
 184         return __dm_get_module_param(&reserved_bio_based_ios,
 185                                      RESERVED_BIO_BASED_IOS, DM_RESERVED_MAX_IOS);
 186 }
 187 EXPORT_SYMBOL_GPL(dm_get_reserved_bio_based_ios);
 188
 189 static unsigned dm_get_numa_node(void)
 190 {
 191         return __dm_get_module_param_int(&dm_numa_node,
 192                                          DM_NUMA_NODE, num_online_nodes() - 1);
 193 }
 194
 195 static int __init local_init(void)
 196 {
 197         int r;
 198
 199         r = dm_uevent_init();
 200         if (r)
 201                 return r;
 202
 203         deferred_remove_workqueue = alloc_workqueue("kdmremove", WQ_UNBOUND, 1);
 204         if (!deferred_remove_workqueue) {
 205                 r = -ENOMEM;
 206                 goto out_uevent_exit;
 207         }
 208
 209         _major = major;
 210         r = register_blkdev(_major, _name);
 211         if (r < 0)
 212                 goto out_free_workqueue;
 213
 214         if (!_major)
 215                 _major = r;
 216
 217         return 0;
 218
 219 out_free_workqueue:
 220         destroy_workqueue(deferred_remove_workqueue);
 221 out_uevent_exit:
 222         dm_uevent_exit();
 223
 224         return r;
 225 }
 226
 227 static void local_exit(void)
 228 {
 229         flush_scheduled_work();
 230         destroy_workqueue(deferred_remove_workqueue);
 231
 232         unregister_blkdev(_major, _name);
 233         dm_uevent_exit();
 234
 235         _major = 0;
 236
 237         DMINFO("cleaned up");
 238 }
 239
 240 static int (*_inits[])(void) __initdata = {
 241         local_init,
 242         dm_target_init,
 243         dm_linear_init,
 244         dm_stripe_init,
 245         dm_io_init,
 246         dm_kcopyd_init,
 247         dm_interface_init,
 248         dm_statistics_init,
 249 };
 250
 251 static void (*_exits[])(void) = {
 252         local_exit,
 253         dm_target_exit,
 254         dm_linear_exit,
 255         dm_stripe_exit,
 256         dm_io_exit,
 257         dm_kcopyd_exit,
 258         dm_interface_exit,
 259         dm_statistics_exit,
 260 };
 261
 262 static int __init dm_init(void)
 263 {
 264         const int count = ARRAY_SIZE(_inits);
 265         int r, i;
 266
 267 #if (IS_ENABLED(CONFIG_IMA) && !IS_ENABLED(CONFIG_IMA_DISABLE_HTABLE))
 268         DMWARN("CONFIG_IMA_DISABLE_HTABLE is disabled."
 269                " Duplicate IMA measurements will not be recorded in the IMA log.");
 270 #endif
 271
 272         for (i = 0; i < count; i++) {
 273                 r = _inits[i]();
 274                 if (r)
 275                         goto bad;
 276         }
 277
 278         return 0;
 279 bad:
 280         while (i--)
 281                 _exits[i]();
 282
 283         return r;
 284 }
 285
 286 static void __exit dm_exit(void)
 287 {
 288         int i = ARRAY_SIZE(_exits);
 289
 290         while (i--)
 291                 _exits[i]();
 292
 293         /*
 294          * Should be empty by this point.
 295          */
 296         idr_destroy(&_minor_idr);
 297 }
 298
 299 /*
 300  * Block device functions
 301  */
 302 int dm_deleting_md(struct mapped_device *md)
 303 {
 304         return test_bit(DMF_DELETING, &md->flags);
 305 }
 306
 307 static int dm_blk_open(struct block_device *bdev, fmode_t mode)
 308 {
 309         struct mapped_device *md;
 310
 311         spin_lock(&_minor_lock);
 312
 313         md = bdev->bd_disk->private_data;
 314         if (!md)
 315                 goto out;
 316
 317         if (test_bit(DMF_FREEING, &md->flags) ||
 318             dm_deleting_md(md)) {
 319                 md = NULL;
 320                 goto out;
 321         }
 322
 323         dm_get(md);
 324         atomic_inc(&md->open_count);
 325 out:
 326         spin_unlock(&_minor_lock);
 327
 328         return md ? 0 : -ENXIO;
 329 }
 330
 331 static void dm_blk_close(struct gendisk *disk, fmode_t mode)
 332 {
 333         struct mapped_device *md;
 334
 335         spin_lock(&_minor_lock);
 336
 337         md = disk->private_data;
 338         if (WARN_ON(!md))
 339                 goto out;
 340
 341         if (atomic_dec_and_test(&md->open_count) &&
 342             (test_bit(DMF_DEFERRED_REMOVE, &md->flags)))
 343                 queue_work(deferred_remove_workqueue, &deferred_remove_work);
 344
 345         dm_put(md);
 346 out:
 347         spin_unlock(&_minor_lock);
 348 }
 349
 350 int dm_open_count(struct mapped_device *md)
 351 {
 352         return atomic_read(&md->open_count);
 353 }
 354
 355 /*
 356  * Guarantees nothing is using the device before it's deleted.
 357  */
 358 int dm_lock_for_deletion(struct mapped_device *md, bool mark_deferred, bool only_deferred)
 359 {
 360         int r = 0;
 361
 362         spin_lock(&_minor_lock);
 363
 364         if (dm_open_count(md)) {
 365                 r = -EBUSY;
 366                 if (mark_deferred)
 367                         set_bit(DMF_DEFERRED_REMOVE, &md->flags);
 368         } else if (only_deferred && !test_bit(DMF_DEFERRED_REMOVE, &md->flags))
 369                 r = -EEXIST;
 370         else
 371                 set_bit(DMF_DELETING, &md->flags);
 372
 373         spin_unlock(&_minor_lock);
 374
 375         return r;
 376 }
 377
 378 int dm_cancel_deferred_remove(struct mapped_device *md)
 379 {
 380         int r = 0;
 381
 382         spin_lock(&_minor_lock);
 383
 384         if (test_bit(DMF_DELETING, &md->flags))
 385                 r = -EBUSY;
 386         else
 387                 clear_bit(DMF_DEFERRED_REMOVE, &md->flags);
 388
 389         spin_unlock(&_minor_lock);
 390
 391         return r;
 392 }
 393
 394 static void do_deferred_remove(struct work_struct *w)
 395 {
 396         dm_deferred_remove();
 397 }
 398
 399 static int dm_blk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
 400 {
 401         struct mapped_device *md = bdev->bd_disk->private_data;
 402
 403         return dm_get_geometry(md, geo);
 404 }
 405
 406 static int dm_prepare_ioctl(struct mapped_device *md, int *srcu_idx,
 407                             struct block_device **bdev)
 408 {
 409         struct dm_target *tgt;
 410         struct dm_table *map;
 411         int r;
 412
 413 retry:
 414         r = -ENOTTY;
 415         map = dm_get_live_table(md, srcu_idx);
 416         if (!map || !dm_table_get_size(map))
 417                 return r;
 418
 419         /* We only support devices that have a single target */
 420         if (dm_table_get_num_targets(map) != 1)
 421                 return r;
 422
 423         tgt = dm_table_get_target(map, 0);
 424         if (!tgt->type->prepare_ioctl)
 425                 return r;
 426
 427         if (dm_suspended_md(md))
 428                 return -EAGAIN;
 429
 430         r = tgt->type->prepare_ioctl(tgt, bdev);
 431         if (r == -ENOTCONN && !fatal_signal_pending(current)) {
 432                 dm_put_live_table(md, *srcu_idx);
 433                 msleep(10);
 434                 goto retry;
 435         }
 436
 437         return r;
 438 }
 439
 440 static void dm_unprepare_ioctl(struct mapped_device *md, int srcu_idx)
 441 {
 442         dm_put_live_table(md, srcu_idx);
 443 }
 444
 445 static int dm_blk_ioctl(struct block_device *bdev, fmode_t mode,
 446                         unsigned int cmd, unsigned long arg)
 447 {
 448         struct mapped_device *md = bdev->bd_disk->private_data;
 449         int r, srcu_idx;
 450
 451         r = dm_prepare_ioctl(md, &srcu_idx, &bdev);
 452         if (r < 0)
 453                 goto out;
 454
 455         if (r > 0) {
 456                 /*
 457                  * Target determined this ioctl is being issued against a
 458                  * subset of the parent bdev; require extra privileges.
 459                  */
 460                 if (!capable(CAP_SYS_RAWIO)) {
 461                         DMDEBUG_LIMIT(
 462         "%s: sending ioctl %x to DM device without required privilege.",
 463                                 current->comm, cmd);
 464                         r = -ENOIOCTLCMD;
 465                         goto out;
 466                 }
 467         }
 468
 469         if (!bdev->bd_disk->fops->ioctl)
 470                 r = -ENOTTY;
 471         else
 472                 r = bdev->bd_disk->fops->ioctl(bdev, mode, cmd, arg);
 473 out:
 474         dm_unprepare_ioctl(md, srcu_idx);
 475         return r;
 476 }
 477
 478 u64 dm_start_time_ns_from_clone(struct bio *bio)
 479 {
 480         struct dm_target_io *tio = container_of(bio, struct dm_target_io, clone);
 481         struct dm_io *io = tio->io;
 482
 483         return jiffies_to_nsecs(io->start_time);
 484 }
 485 EXPORT_SYMBOL_GPL(dm_start_time_ns_from_clone);
 486
 487 static void start_io_acct(struct dm_io *io)
 488 {
 489         struct mapped_device *md = io->md;
 490         struct bio *bio = io->orig_bio;
 491
 492         bio_start_io_acct_time(bio, io->start_time);
 493         if (unlikely(dm_stats_used(&md->stats)))
 494                 dm_stats_account_io(&md->stats, bio_data_dir(bio),
 495                                     bio->bi_iter.bi_sector, bio_sectors(bio),
 496                                     false, 0, &io->stats_aux);
 497 }
 498
 499 static void end_io_acct(struct mapped_device *md, struct bio *bio,
 500                         unsigned long start_time, struct dm_stats_aux *stats_aux)
 501 {
 502         unsigned long duration = jiffies - start_time;
 503
 504         bio_end_io_acct(bio, start_time);
 505
 506         if (unlikely(dm_stats_used(&md->stats)))
 507                 dm_stats_account_io(&md->stats, bio_data_dir(bio),
 508                                     bio->bi_iter.bi_sector, bio_sectors(bio),
 509                                     true, duration, stats_aux);
 510
 511         /* nudge anyone waiting on suspend queue */
 512         if (unlikely(wq_has_sleeper(&md->wait)))
 513                 wake_up(&md->wait);
 514 }
 515
 516 static struct dm_io *alloc_io(struct mapped_device *md, struct bio *bio)
 517 {
 518         struct dm_io *io;
 519         struct dm_target_io *tio;
 520         struct bio *clone;
 521
 522         clone = bio_alloc_bioset(GFP_NOIO, 0, &md->io_bs);
 523         if (!clone)
 524                 return NULL;
 525
 526         tio = container_of(clone, struct dm_target_io, clone);
 527         tio->inside_dm_io = true;
 528         tio->io = NULL;
 529
 530         io = container_of(tio, struct dm_io, tio);
 531         io->magic = DM_IO_MAGIC;
 532         io->status = 0;
 533         atomic_set(&io->io_count, 1);
 534         io->orig_bio = bio;
 535         io->md = md;
 536         spin_lock_init(&io->endio_lock);
 537
 538         io->start_time = jiffies;
 539
 540         return io;
 541 }
 542
 543 static void free_io(struct mapped_device *md, struct dm_io *io)
 544 {
 545         bio_put(&io->tio.clone);
 546 }
 547
 548 static struct dm_target_io *alloc_tio(struct clone_info *ci, struct dm_target *ti,
 549                                       unsigned target_bio_nr, gfp_t gfp_mask)
 550 {
 551         struct dm_target_io *tio;
 552
 553         if (!ci->io->tio.io) {
 554                 /* the dm_target_io embedded in ci->io is available */
 555                 tio = &ci->io->tio;
 556         } else {
 557                 struct bio *clone = bio_alloc_bioset(gfp_mask, 0, &ci->io->md->bs);
 558                 if (!clone)
 559                         return NULL;
 560
 561                 tio = container_of(clone, struct dm_target_io, clone);
 562                 tio->inside_dm_io = false;
 563         }
 564
 565         tio->magic = DM_TIO_MAGIC;
 566         tio->io = ci->io;
 567         tio->ti = ti;
 568         tio->target_bio_nr = target_bio_nr;
 569
 570         return tio;
 571 }
 572
 573 static void free_tio(struct dm_target_io *tio)
 574 {
 575         if (tio->inside_dm_io)
 576                 return;
 577         bio_put(&tio->clone);
 578 }
 579
 580 /*
 581  * Add the bio to the list of deferred io.
 582  */
 583 static void queue_io(struct mapped_device *md, struct bio *bio)
 584 {
 585         unsigned long flags;
 586
 587         spin_lock_irqsave(&md->deferred_lock, flags);
 588         bio_list_add(&md->deferred, bio);
 589         spin_unlock_irqrestore(&md->deferred_lock, flags);
 590         queue_work(md->wq, &md->work);
 591 }
 592
 593 /*
 594  * Everyone (including functions in this file), should use this
 595  * function to access the md->map field, and make sure they call
 596  * dm_put_live_table() when finished.
 597  */
 598 struct dm_table *dm_get_live_table(struct mapped_device *md, int *srcu_idx) __acquires(md->io_barrier)
 599 {
 600         *srcu_idx = srcu_read_lock(&md->io_barrier);
 601
 602         return srcu_dereference(md->map, &md->io_barrier);
 603 }
 604
 605 void dm_put_live_table(struct mapped_device *md, int srcu_idx) __releases(md->io_barrier)
 606 {
 607         srcu_read_unlock(&md->io_barrier, srcu_idx);
 608 }
 609
 610 void dm_sync_table(struct mapped_device *md)
 611 {
 612         synchronize_srcu(&md->io_barrier);
 613         synchronize_rcu_expedited();
 614 }
 615
 616 /*
 617  * A fast alternative to dm_get_live_table/dm_put_live_table.
 618  * The caller must not block between these two functions.
 619  */
 620 static struct dm_table *dm_get_live_table_fast(struct mapped_device *md) __acquires(RCU)
 621 {
 622         rcu_read_lock();
 623         return rcu_dereference(md->map);
 624 }
 625
 626 static void dm_put_live_table_fast(struct mapped_device *md) __releases(RCU)
 627 {
 628         rcu_read_unlock();
 629 }
 630
 631 static char *_dm_claim_ptr = "I belong to device-mapper";
 632
 633 /*
 634  * Open a table device so we can use it as a map destination.
 635  */
 636 static int open_table_device(struct table_device *td, dev_t dev,
 637                              struct mapped_device *md)
 638 {
 639         struct block_device *bdev;
 640         u64 part_off;
 641         int r;
 642
 643         BUG_ON(td->dm_dev.bdev);
 644
 645         bdev = blkdev_get_by_dev(dev, td->dm_dev.mode | FMODE_EXCL, _dm_claim_ptr);
 646         if (IS_ERR(bdev))
 647                 return PTR_ERR(bdev);
 648
 649         r = bd_link_disk_holder(bdev, dm_disk(md));
 650         if (r) {
 651                 blkdev_put(bdev, td->dm_dev.mode | FMODE_EXCL);
 652                 return r;
 653         }
 654
 655         td->dm_dev.bdev = bdev;
 656         td->dm_dev.dax_dev = fs_dax_get_by_bdev(bdev, &part_off);
 657         return 0;
 658 }
 659
 660 /*
 661  * Close a table device that we've been using.
 662  */
 663 static void close_table_device(struct table_device *td, struct mapped_device *md)
 664 {
 665         if (!td->dm_dev.bdev)
 666                 return;
 667
 668         bd_unlink_disk_holder(td->dm_dev.bdev, dm_disk(md));
 669         blkdev_put(td->dm_dev.bdev, td->dm_dev.mode | FMODE_EXCL);
 670         put_dax(td->dm_dev.dax_dev);
 671         td->dm_dev.bdev = NULL;
 672         td->dm_dev.dax_dev = NULL;
 673 }
 674
 675 static struct table_device *find_table_device(struct list_head *l, dev_t dev,
 676                                               fmode_t mode)
 677 {
 678         struct table_device *td;
 679
 680         list_for_each_entry(td, l, list)
 681                 if (td->dm_dev.bdev->bd_dev == dev && td->dm_dev.mode == mode)
 682                         return td;
 683
 684         return NULL;
 685 }
 686
 687 int dm_get_table_device(struct mapped_device *md, dev_t dev, fmode_t mode,
 688                         struct dm_dev **result)
 689 {
 690         int r;
 691         struct table_device *td;
 692
 693         mutex_lock(&md->table_devices_lock);
 694         td = find_table_device(&md->table_devices, dev, mode);
 695         if (!td) {
 696                 td = kmalloc_node(sizeof(*td), GFP_KERNEL, md->numa_node_id);
 697                 if (!td) {
 698                         mutex_unlock(&md->table_devices_lock);
 699                         return -ENOMEM;
 700                 }
 701
 702                 td->dm_dev.mode = mode;
 703                 td->dm_dev.bdev = NULL;
 704
 705                 if ((r = open_table_device(td, dev, md))) {
 706                         mutex_unlock(&md->table_devices_lock);
 707                         kfree(td);
 708                         return r;
 709                 }
 710
 711                 format_dev_t(td->dm_dev.name, dev);
 712
 713                 refcount_set(&td->count, 1);
 714                 list_add(&td->list, &md->table_devices);
 715         } else {
 716                 refcount_inc(&td->count);
 717         }
 718         mutex_unlock(&md->table_devices_lock);
 719
 720         *result = &td->dm_dev;
 721         return 0;
 722 }
 723
 724 void dm_put_table_device(struct mapped_device *md, struct dm_dev *d)
 725 {
 726         struct table_device *td = container_of(d, struct table_device, dm_dev);
 727
 728         mutex_lock(&md->table_devices_lock);
 729         if (refcount_dec_and_test(&td->count)) {
 730                 close_table_device(td, md);
 731                 list_del(&td->list);
 732                 kfree(td);
 733         }
 734         mutex_unlock(&md->table_devices_lock);
 735 }
 736
 737 static void free_table_devices(struct list_head *devices)
 738 {
 739         struct list_head *tmp, *next;
 740
 741         list_for_each_safe(tmp, next, devices) {
 742                 struct table_device *td = list_entry(tmp, struct table_device, list);
 743
 744                 DMWARN("dm_destroy: %s still exists with %d references",
 745                        td->dm_dev.name, refcount_read(&td->count));
 746                 kfree(td);
 747         }
 748 }
 749
 750 /*
 751  * Get the geometry associated with a dm device
 752  */
 753 int dm_get_geometry(struct mapped_device *md, struct hd_geometry *geo)
 754 {
 755         *geo = md->geometry;
 756
 757         return 0;
 758 }
 759
 760 /*
 761  * Set the geometry of a device.
 762  */
 763 int dm_set_geometry(struct mapped_device *md, struct hd_geometry *geo)
 764 {
 765         sector_t sz = (sector_t)geo->cylinders * geo->heads * geo->sectors;
 766
 767         if (geo->start > sz) {
 768                 DMWARN("Start sector is beyond the geometry limits.");
 769                 return -EINVAL;
 770         }
 771
 772         md->geometry = *geo;
 773
 774         return 0;
 775 }
 776
 777 static int __noflush_suspending(struct mapped_device *md)
 778 {
 779         return test_bit(DMF_NOFLUSH_SUSPENDING, &md->flags);
 780 }
 781
 782 /*
 783  * Decrements the number of outstanding ios that a bio has been
 784  * cloned into, completing the original io if necc.
 785  */
 786 void dm_io_dec_pending(struct dm_io *io, blk_status_t error)
 787 {
 788         unsigned long flags;
 789         blk_status_t io_error;
 790         struct bio *bio;
 791         struct mapped_device *md = io->md;
 792         unsigned long start_time = 0;
 793         struct dm_stats_aux stats_aux;
 794
 795         /* Push-back supersedes any I/O errors */
 796         if (unlikely(error)) {
 797                 spin_lock_irqsave(&io->endio_lock, flags);
 798                 if (!(io->status == BLK_STS_DM_REQUEUE && __noflush_suspending(md)))
 799                         io->status = error;
 800                 spin_unlock_irqrestore(&io->endio_lock, flags);
 801         }
 802
 803         if (atomic_dec_and_test(&io->io_count)) {
 804                 bio = io->orig_bio;
 805                 if (io->status == BLK_STS_DM_REQUEUE) {
 806                         /*
 807                          * Target requested pushing back the I/O.
 808                          */
 809                         spin_lock_irqsave(&md->deferred_lock, flags);
 810                         if (__noflush_suspending(md) &&
 811                             !WARN_ON_ONCE(dm_is_zone_write(md, bio))) {
 812                                 /* NOTE early return due to BLK_STS_DM_REQUEUE below */
 813                                 bio_list_add_head(&md->deferred, bio);
 814                         } else {
 815                                 /*
 816                                  * noflush suspend was interrupted or this is
 817                                  * a write to a zoned target.
 818                                  */
 819                                 io->status = BLK_STS_IOERR;
 820                         }
 821                         spin_unlock_irqrestore(&md->deferred_lock, flags);
 822                 }
 823
 824                 io_error = io->status;
 825                 start_time = io->start_time;
 826                 stats_aux = io->stats_aux;
 827                 free_io(md, io);
 828                 end_io_acct(md, bio, start_time, &stats_aux);
 829
 830                 if (io_error == BLK_STS_DM_REQUEUE)
 831                         return;
 832
 833                 if ((bio->bi_opf & REQ_PREFLUSH) && bio->bi_iter.bi_size) {
 834                         /*
 835                          * Preflush done for flush with data, reissue
 836                          * without REQ_PREFLUSH.
 837                          */
 838                         bio->bi_opf &= ~REQ_PREFLUSH;
 839                         queue_io(md, bio);
 840                 } else {
 841                         /* done with normal IO or empty flush */
 842                         if (io_error)
 843                                 bio->bi_status = io_error;
 844                         bio_endio(bio);
 845                 }
 846         }
 847 }
 848
 849 void disable_discard(struct mapped_device *md)
 850 {
 851         struct queue_limits *limits = dm_get_queue_limits(md);
 852
 853         /* device doesn't really support DISCARD, disable it */
 854         limits->max_discard_sectors = 0;
 855         blk_queue_flag_clear(QUEUE_FLAG_DISCARD, md->queue);
 856 }
 857
 858 void disable_write_same(struct mapped_device *md)
 859 {
 860         struct queue_limits *limits = dm_get_queue_limits(md);
 861
 862         /* device doesn't really support WRITE SAME, disable it */
 863         limits->max_write_same_sectors = 0;
 864 }
 865
 866 void disable_write_zeroes(struct mapped_device *md)
 867 {
 868         struct queue_limits *limits = dm_get_queue_limits(md);
 869
 870         /* device doesn't really support WRITE ZEROES, disable it */
 871         limits->max_write_zeroes_sectors = 0;
 872 }
 873
 874 static bool swap_bios_limit(struct dm_target *ti, struct bio *bio)
 875 {
 876         return unlikely((bio->bi_opf & REQ_SWAP) != 0) && unlikely(ti->limit_swap_bios);
 877 }
 878
 879 static void clone_endio(struct bio *bio)
 880 {
 881         blk_status_t error = bio->bi_status;
 882         struct dm_target_io *tio = container_of(bio, struct dm_target_io, clone);
 883         struct dm_io *io = tio->io;
 884         struct mapped_device *md = tio->io->md;
 885         dm_endio_fn endio = tio->ti->type->end_io;
 886         struct request_queue *q = bio->bi_bdev->bd_disk->queue;
 887
 888         if (unlikely(error == BLK_STS_TARGET)) {
 889                 if (bio_op(bio) == REQ_OP_DISCARD &&
 890                     !q->limits.max_discard_sectors)
 891                         disable_discard(md);
 892                 else if (bio_op(bio) == REQ_OP_WRITE_SAME &&
 893                          !q->limits.max_write_same_sectors)
 894                         disable_write_same(md);
 895                 else if (bio_op(bio) == REQ_OP_WRITE_ZEROES &&
 896                          !q->limits.max_write_zeroes_sectors)
 897                         disable_write_zeroes(md);
 898         }
 899
 900         if (blk_queue_is_zoned(q))
 901                 dm_zone_endio(io, bio);
 902
 903         if (endio) {
 904                 int r = endio(tio->ti, bio, &error);
 905                 switch (r) {
 906                 case DM_ENDIO_REQUEUE:
 907                         /*
 908                          * Requeuing writes to a sequential zone of a zoned
 909                          * target will break the sequential write pattern:
 910                          * fail such IO.
 911                          */
 912                         if (WARN_ON_ONCE(dm_is_zone_write(md, bio)))
 913                                 error = BLK_STS_IOERR;
 914                         else
 915                                 error = BLK_STS_DM_REQUEUE;
 916                         fallthrough;
 917                 case DM_ENDIO_DONE:
 918                         break;
 919                 case DM_ENDIO_INCOMPLETE:
 920                         /* The target will handle the io */
 921                         return;
 922                 default:
 923                         DMWARN("unimplemented target endio return value: %d", r);
 924                         BUG();
 925                 }
 926         }
 927
 928         if (unlikely(swap_bios_limit(tio->ti, bio))) {
 929                 struct mapped_device *md = io->md;
 930                 up(&md->swap_bios_semaphore);
 931         }
 932
 933         free_tio(tio);
 934         dm_io_dec_pending(io, error);
 935 }
 936
 937 /*
 938  * Return maximum size of I/O possible at the supplied sector up to the current
 939  * target boundary.
 940  */
 941 static inline sector_t max_io_len_target_boundary(struct dm_target *ti,
 942                                                   sector_t target_offset)
 943 {
 944         return ti->len - target_offset;
 945 }
 946
 947 static sector_t max_io_len(struct dm_target *ti, sector_t sector)
 948 {
 949         sector_t target_offset = dm_target_offset(ti, sector);
 950         sector_t len = max_io_len_target_boundary(ti, target_offset);
 951         sector_t max_len;
 952
 953         /*
 954          * Does the target need to split IO even further?
 955          * - varied (per target) IO splitting is a tenet of DM; this
 956          *   explains why stacked chunk_sectors based splitting via
 957          *   blk_max_size_offset() isn't possible here. So pass in
 958          *   ti->max_io_len to override stacked chunk_sectors.
 959          */
 960         if (ti->max_io_len) {
 961                 max_len = blk_max_size_offset(ti->table->md->queue,
 962                                               target_offset, ti->max_io_len);
 963                 if (len > max_len)
 964                         len = max_len;
 965         }
 966
 967         return len;
 968 }
 969
 970 int dm_set_target_max_io_len(struct dm_target *ti, sector_t len)
 971 {
 972         if (len > UINT_MAX) {
 973                 DMERR("Specified maximum size of target IO (%llu) exceeds limit (%u)",
 974                       (unsigned long long)len, UINT_MAX);
 975                 ti->error = "Maximum size of target IO is too large";
 976                 return -EINVAL;
 977         }
 978
 979         ti->max_io_len = (uint32_t) len;
 980
 981         return 0;
 982 }
 983 EXPORT_SYMBOL_GPL(dm_set_target_max_io_len);
 984
 985 static struct dm_target *dm_dax_get_live_target(struct mapped_device *md,
 986                                                 sector_t sector, int *srcu_idx)
 987         __acquires(md->io_barrier)
 988 {
 989         struct dm_table *map;
 990         struct dm_target *ti;
 991
 992         map = dm_get_live_table(md, srcu_idx);
 993         if (!map)
 994                 return NULL;
 995
 996         ti = dm_table_find_target(map, sector);
 997         if (!ti)
 998                 return NULL;
 999
1000         return ti;
1001 }
1002
1003 static long dm_dax_direct_access(struct dax_device *dax_dev, pgoff_t pgoff,
1004                                  long nr_pages, void **kaddr, pfn_t *pfn)
1005 {
1006         struct mapped_device *md = dax_get_private(dax_dev);
1007         sector_t sector = pgoff * PAGE_SECTORS;
1008         struct dm_target *ti;
1009         long len, ret = -EIO;
1010         int srcu_idx;
1011
1012         ti = dm_dax_get_live_target(md, sector, &srcu_idx);
1013
1014         if (!ti)
1015                 goto out;
1016         if (!ti->type->direct_access)
1017                 goto out;
1018         len = max_io_len(ti, sector) / PAGE_SECTORS;
1019         if (len < 1)
1020                 goto out;
1021         nr_pages = min(len, nr_pages);
1022         ret = ti->type->direct_access(ti, pgoff, nr_pages, kaddr, pfn);
1023
1024  out:
1025         dm_put_live_table(md, srcu_idx);
1026
1027         return ret;
1028 }
1029
1030 static int dm_dax_zero_page_range(struct dax_device *dax_dev, pgoff_t pgoff,
1031                                   size_t nr_pages)
1032 {
1033         struct mapped_device *md = dax_get_private(dax_dev);
1034         sector_t sector = pgoff * PAGE_SECTORS;
1035         struct dm_target *ti;
1036         int ret = -EIO;
1037         int srcu_idx;
1038
1039         ti = dm_dax_get_live_target(md, sector, &srcu_idx);
1040
1041         if (!ti)
1042                 goto out;
1043         if (WARN_ON(!ti->type->dax_zero_page_range)) {
1044                 /*
1045                  * ->zero_page_range() is mandatory dax operation. If we are
1046                  *  here, something is wrong.
1047                  */
1048                 goto out;
1049         }
1050         ret = ti->type->dax_zero_page_range(ti, pgoff, nr_pages);
1051  out:
1052         dm_put_live_table(md, srcu_idx);
1053
1054         return ret;
1055 }
1056
1057 /*
1058  * A target may call dm_accept_partial_bio only from the map routine.  It is
1059  * allowed for all bio types except REQ_PREFLUSH, REQ_OP_ZONE_* zone management
1060  * operations and REQ_OP_ZONE_APPEND (zone append writes).
1061  *
1062  * dm_accept_partial_bio informs the dm that the target only wants to process
1063  * additional n_sectors sectors of the bio and the rest of the data should be
1064  * sent in a next bio.
1065  *
1066  * A diagram that explains the arithmetics:
1067  * +--------------------+---------------+-------+
1068  * |         1          |       2       |   3   |
1069  * +--------------------+---------------+-------+
1070  *
1071  * <-------------- *tio->len_ptr --------------->
1072  *                      <------- bi_size ------->
1073  *                      <-- n_sectors -->
1074  *
1075  * Region 1 was already iterated over with bio_advance or similar function.
1076  *      (it may be empty if the target doesn't use bio_advance)
1077  * Region 2 is the remaining bio size that the target wants to process.
1078  *      (it may be empty if region 1 is non-empty, although there is no reason
1079  *       to make it empty)
1080  * The target requires that region 3 is to be sent in the next bio.
1081  *
1082  * If the target wants to receive multiple copies of the bio (via num_*bios, etc),
1083  * the partially processed part (the sum of regions 1+2) must be the same for all
1084  * copies of the bio.
1085  */
1086 void dm_accept_partial_bio(struct bio *bio, unsigned n_sectors)
1087 {
1088         struct dm_target_io *tio = container_of(bio, struct dm_target_io, clone);
1089         unsigned bi_size = bio->bi_iter.bi_size >> SECTOR_SHIFT;
1090
1091         BUG_ON(bio->bi_opf & REQ_PREFLUSH);
1092         BUG_ON(op_is_zone_mgmt(bio_op(bio)));
1093         BUG_ON(bio_op(bio) == REQ_OP_ZONE_APPEND);
1094         BUG_ON(bi_size > *tio->len_ptr);
1095         BUG_ON(n_sectors > bi_size);
1096
1097         *tio->len_ptr -= bi_size - n_sectors;
1098         bio->bi_iter.bi_size = n_sectors << SECTOR_SHIFT;
1099 }
1100 EXPORT_SYMBOL_GPL(dm_accept_partial_bio);
1101
1102 static noinline void __set_swap_bios_limit(struct mapped_device *md, int latch)
1103 {
1104         mutex_lock(&md->swap_bios_lock);
1105         while (latch < md->swap_bios) {
1106                 cond_resched();
1107                 down(&md->swap_bios_semaphore);
1108                 md->swap_bios--;
1109         }
1110         while (latch > md->swap_bios) {
1111                 cond_resched();
1112                 up(&md->swap_bios_semaphore);
1113                 md->swap_bios++;
1114         }
1115         mutex_unlock(&md->swap_bios_lock);
1116 }
1117
1118 static void __map_bio(struct dm_target_io *tio)
1119 {
1120         int r;
1121         sector_t sector;
1122         struct bio *clone = &tio->clone;
1123         struct dm_io *io = tio->io;
1124         struct dm_target *ti = tio->ti;
1125
1126         clone->bi_end_io = clone_endio;
1127
1128         /*
1129          * Map the clone.  If r == 0 we don't need to do
1130          * anything, the target has assumed ownership of
1131          * this io.
1132          */
1133         dm_io_inc_pending(io);
1134         sector = clone->bi_iter.bi_sector;
1135
1136         if (unlikely(swap_bios_limit(ti, clone))) {
1137                 struct mapped_device *md = io->md;
1138                 int latch = get_swap_bios();
1139                 if (unlikely(latch != md->swap_bios))
1140                         __set_swap_bios_limit(md, latch);
1141                 down(&md->swap_bios_semaphore);
1142         }
1143
1144         /*
1145          * Check if the IO needs a special mapping due to zone append emulation
1146          * on zoned target. In this case, dm_zone_map_bio() calls the target
1147          * map operation.
1148          */
1149         if (dm_emulate_zone_append(io->md))
1150                 r = dm_zone_map_bio(tio);
1151         else
1152                 r = ti->type->map(ti, clone);
1153
1154         switch (r) {
1155         case DM_MAPIO_SUBMITTED:
1156                 break;
1157         case DM_MAPIO_REMAPPED:
1158                 /* the bio has been remapped so dispatch it */
1159                 trace_block_bio_remap(clone, bio_dev(io->orig_bio), sector);
1160                 submit_bio_noacct(clone);
1161                 break;
1162         case DM_MAPIO_KILL:
1163                 if (unlikely(swap_bios_limit(ti, clone))) {
1164                         struct mapped_device *md = io->md;
1165                         up(&md->swap_bios_semaphore);
1166                 }
1167                 free_tio(tio);
1168                 dm_io_dec_pending(io, BLK_STS_IOERR);
1169                 break;
1170         case DM_MAPIO_REQUEUE:
1171                 if (unlikely(swap_bios_limit(ti, clone))) {
1172                         struct mapped_device *md = io->md;
1173                         up(&md->swap_bios_semaphore);
1174                 }
1175                 free_tio(tio);
1176                 dm_io_dec_pending(io, BLK_STS_DM_REQUEUE);
1177                 break;
1178         default:
1179                 DMWARN("unimplemented target map return value: %d", r);
1180                 BUG();
1181         }
1182 }
1183
1184 static void bio_setup_sector(struct bio *bio, sector_t sector, unsigned len)
1185 {
1186         bio->bi_iter.bi_sector = sector;
1187         bio->bi_iter.bi_size = to_bytes(len);
1188 }
1189
1190 /*
1191  * Creates a bio that consists of range of complete bvecs.
1192  */
1193 static int clone_bio(struct dm_target_io *tio, struct bio *bio,
1194                      sector_t sector, unsigned len)
1195 {
1196         struct bio *clone = &tio->clone;
1197         int r;
1198
1199         __bio_clone_fast(clone, bio);
1200
1201         r = bio_crypt_clone(clone, bio, GFP_NOIO);
1202         if (r < 0)
1203                 return r;
1204
1205         if (bio_integrity(bio)) {
1206                 if (unlikely(!dm_target_has_integrity(tio->ti->type) &&
1207                              !dm_target_passes_integrity(tio->ti->type))) {
1208                         DMWARN("%s: the target %s doesn't support integrity data.",
1209                                 dm_device_name(tio->io->md),
1210                                 tio->ti->type->name);
1211                         return -EIO;
1212                 }
1213
1214                 r = bio_integrity_clone(clone, bio, GFP_NOIO);
1215                 if (r < 0)
1216                         return r;
1217         }
1218
1219         bio_advance(clone, to_bytes(sector - clone->bi_iter.bi_sector));
1220         clone->bi_iter.bi_size = to_bytes(len);
1221
1222         if (bio_integrity(bio))
1223                 bio_integrity_trim(clone);
1224
1225         return 0;
1226 }
1227
1228 static void alloc_multiple_bios(struct bio_list *blist, struct clone_info *ci,
1229                                 struct dm_target *ti, unsigned num_bios)
1230 {
1231         struct dm_target_io *tio;
1232         int try;
1233
1234         if (!num_bios)
1235                 return;
1236
1237         if (num_bios == 1) {
1238                 tio = alloc_tio(ci, ti, 0, GFP_NOIO);
1239                 bio_list_add(blist, &tio->clone);
1240                 return;
1241         }
1242
1243         for (try = 0; try < 2; try++) {
1244                 int bio_nr;
1245                 struct bio *bio;
1246
1247                 if (try)
1248                         mutex_lock(&ci->io->md->table_devices_lock);
1249                 for (bio_nr = 0; bio_nr < num_bios; bio_nr++) {
1250                         tio = alloc_tio(ci, ti, bio_nr, try ? GFP_NOIO : GFP_NOWAIT);
1251                         if (!tio)
1252                                 break;
1253
1254                         bio_list_add(blist, &tio->clone);
1255                 }
1256                 if (try)
1257                         mutex_unlock(&ci->io->md->table_devices_lock);
1258                 if (bio_nr == num_bios)
1259                         return;
1260
1261                 while ((bio = bio_list_pop(blist))) {
1262                         tio = container_of(bio, struct dm_target_io, clone);
1263                         free_tio(tio);
1264                 }
1265         }
1266 }
1267
1268 static void __clone_and_map_simple_bio(struct clone_info *ci,
1269                                            struct dm_target_io *tio, unsigned *len)
1270 {
1271         struct bio *clone = &tio->clone;
1272
1273         tio->len_ptr = len;
1274
1275         __bio_clone_fast(clone, ci->bio);
1276         if (len)
1277                 bio_setup_sector(clone, ci->sector, *len);
1278         __map_bio(tio);
1279 }
1280
1281 static void __send_duplicate_bios(struct clone_info *ci, struct dm_target *ti,
1282                                   unsigned num_bios, unsigned *len)
1283 {
1284         struct bio_list blist = BIO_EMPTY_LIST;
1285         struct bio *bio;
1286         struct dm_target_io *tio;
1287
1288         alloc_multiple_bios(&blist, ci, ti, num_bios);
1289
1290         while ((bio = bio_list_pop(&blist))) {
1291                 tio = container_of(bio, struct dm_target_io, clone);
1292                 __clone_and_map_simple_bio(ci, tio, len);
1293         }
1294 }
1295
1296 static int __send_empty_flush(struct clone_info *ci)
1297 {
1298         unsigned target_nr = 0;
1299         struct dm_target *ti;
1300         struct bio flush_bio;
1301
1302         /*
1303          * Use an on-stack bio for this, it's safe since we don't
1304          * need to reference it after submit. It's just used as
1305          * the basis for the clone(s).
1306          */
1307         bio_init(&flush_bio, NULL, 0);
1308         flush_bio.bi_opf = REQ_OP_WRITE | REQ_PREFLUSH | REQ_SYNC;
1309         bio_set_dev(&flush_bio, ci->io->md->disk->part0);
1310
1311         ci->bio = &flush_bio;
1312         ci->sector_count = 0;
1313
1314         BUG_ON(bio_has_data(ci->bio));
1315         while ((ti = dm_table_get_target(ci->map, target_nr++)))
1316                 __send_duplicate_bios(ci, ti, ti->num_flush_bios, NULL);
1317
1318         bio_uninit(ci->bio);
1319         return 0;
1320 }
1321
1322 static int __clone_and_map_data_bio(struct clone_info *ci, struct dm_target *ti,
1323                                     sector_t sector, unsigned *len)
1324 {
1325         struct bio *bio = ci->bio;
1326         struct dm_target_io *tio;
1327         int r;
1328
1329         tio = alloc_tio(ci, ti, 0, GFP_NOIO);
1330         tio->len_ptr = len;
1331         r = clone_bio(tio, bio, sector, *len);
1332         if (r < 0) {
1333                 free_tio(tio);
1334                 return r;
1335         }
1336         __map_bio(tio);
1337
1338         return 0;
1339 }
1340
1341 static int __send_changing_extent_only(struct clone_info *ci, struct dm_target *ti,
1342                                        unsigned num_bios)
1343 {
1344         unsigned len;
1345
1346         /*
1347          * Even though the device advertised support for this type of
1348          * request, that does not mean every target supports it, and
1349          * reconfiguration might also have changed that since the
1350          * check was performed.
1351          */
1352         if (!num_bios)
1353                 return -EOPNOTSUPP;
1354
1355         len = min_t(sector_t, ci->sector_count,
1356                     max_io_len_target_boundary(ti, dm_target_offset(ti, ci->sector)));
1357
1358         __send_duplicate_bios(ci, ti, num_bios, &len);
1359
1360         ci->sector += len;
1361         ci->sector_count -= len;
1362
1363         return 0;
1364 }
1365
1366 static bool is_abnormal_io(struct bio *bio)
1367 {
1368         bool r = false;
1369
1370         switch (bio_op(bio)) {
1371         case REQ_OP_DISCARD:
1372         case REQ_OP_SECURE_ERASE:
1373         case REQ_OP_WRITE_SAME:
1374         case REQ_OP_WRITE_ZEROES:
1375                 r = true;
1376                 break;
1377         }
1378
1379         return r;
1380 }
1381
1382 static bool __process_abnormal_io(struct clone_info *ci, struct dm_target *ti,
1383                                   int *result)
1384 {
1385         struct bio *bio = ci->bio;
1386         unsigned num_bios = 0;
1387
1388         switch (bio_op(bio)) {
1389         case REQ_OP_DISCARD:
1390                 num_bios = ti->num_discard_bios;
1391                 break;
1392         case REQ_OP_SECURE_ERASE:
1393                 num_bios = ti->num_secure_erase_bios;
1394                 break;
1395         case REQ_OP_WRITE_SAME:
1396                 num_bios = ti->num_write_same_bios;
1397                 break;
1398         case REQ_OP_WRITE_ZEROES:
1399                 num_bios = ti->num_write_zeroes_bios;
1400                 break;
1401         default:
1402                 return false;
1403         }
1404
1405         *result = __send_changing_extent_only(ci, ti, num_bios);
1406         return true;
1407 }
1408
1409 /*
1410  * Select the correct strategy for processing a non-flush bio.
1411  */
1412 static int __split_and_process_non_flush(struct clone_info *ci)
1413 {
1414         struct dm_target *ti;
1415         unsigned len;
1416         int r;
1417
1418         ti = dm_table_find_target(ci->map, ci->sector);
1419         if (!ti)
1420                 return -EIO;
1421
1422         if (__process_abnormal_io(ci, ti, &r))
1423                 return r;
1424
1425         len = min_t(sector_t, max_io_len(ti, ci->sector), ci->sector_count);
1426
1427         r = __clone_and_map_data_bio(ci, ti, ci->sector, &len);
1428         if (r < 0)
1429                 return r;
1430
1431         ci->sector += len;
1432         ci->sector_count -= len;
1433
1434         return 0;
1435 }
1436
1437 static void init_clone_info(struct clone_info *ci, struct mapped_device *md,
1438                             struct dm_table *map, struct bio *bio)
1439 {
1440         ci->map = map;
1441         ci->io = alloc_io(md, bio);
1442         ci->sector = bio->bi_iter.bi_sector;
1443 }
1444
1445 /*
1446  * Entry point to split a bio into clones and submit them to the targets.
1447  */
1448 static void __split_and_process_bio(struct mapped_device *md,
1449                                         struct dm_table *map, struct bio *bio)
1450 {
1451         struct clone_info ci;
1452         int error = 0;
1453
1454         init_clone_info(&ci, md, map, bio);
1455
1456         if (bio->bi_opf & REQ_PREFLUSH) {
1457                 error = __send_empty_flush(&ci);
1458                 /* dm_io_dec_pending submits any data associated with flush */
1459         } else if (op_is_zone_mgmt(bio_op(bio))) {
1460                 ci.bio = bio;
1461                 ci.sector_count = 0;
1462                 error = __split_and_process_non_flush(&ci);
1463         } else {
1464                 ci.bio = bio;
1465                 ci.sector_count = bio_sectors(bio);
1466                 error = __split_and_process_non_flush(&ci);
1467                 if (ci.sector_count && !error) {
1468                         /*
1469                          * Remainder must be passed to submit_bio_noacct()
1470                          * so that it gets handled *after* bios already submitted
1471                          * have been completely processed.
1472                          * We take a clone of the original to store in
1473                          * ci.io->orig_bio to be used by end_io_acct() and
1474                          * for dec_pending to use for completion handling.
1475                          */
1476                         struct bio *b = bio_split(bio, bio_sectors(bio) - ci.sector_count,
1477                                                   GFP_NOIO, &md->queue->bio_split);
1478                         ci.io->orig_bio = b;
1479
1480                         bio_chain(b, bio);
1481                         trace_block_split(b, bio->bi_iter.bi_sector);
1482                         submit_bio_noacct(bio);
1483                 }
1484         }
1485         start_io_acct(ci.io);
1486
1487         /* drop the extra reference count */
1488         dm_io_dec_pending(ci.io, errno_to_blk_status(error));
1489 }
1490
1491 static void dm_submit_bio(struct bio *bio)
1492 {
1493         struct mapped_device *md = bio->bi_bdev->bd_disk->private_data;
1494         int srcu_idx;
1495         struct dm_table *map;
1496
1497         map = dm_get_live_table(md, &srcu_idx);
1498         if (unlikely(!map)) {
1499                 DMERR_LIMIT("%s: mapping table unavailable, erroring io",
1500                             dm_device_name(md));
1501                 bio_io_error(bio);
1502                 goto out;
1503         }
1504
1505         /* If suspended, queue this IO for later */
1506         if (unlikely(test_bit(DMF_BLOCK_IO_FOR_SUSPEND, &md->flags))) {
1507                 if (bio->bi_opf & REQ_NOWAIT)
1508                         bio_wouldblock_error(bio);
1509                 else if (bio->bi_opf & REQ_RAHEAD)
1510                         bio_io_error(bio);
1511                 else
1512                         queue_io(md, bio);
1513                 goto out;
1514         }
1515
1516         /*
1517          * Use blk_queue_split() for abnormal IO (e.g. discard, writesame, etc)
1518          * otherwise associated queue_limits won't be imposed.
1519          */
1520         if (is_abnormal_io(bio))
1521                 blk_queue_split(&bio);
1522
1523         __split_and_process_bio(md, map, bio);
1524 out:
1525         dm_put_live_table(md, srcu_idx);
1526 }
1527
1528 /*-----------------------------------------------------------------
1529  * An IDR is used to keep track of allocated minor numbers.
1530  *---------------------------------------------------------------*/
1531 static void free_minor(int minor)
1532 {
1533         spin_lock(&_minor_lock);
1534         idr_remove(&_minor_idr, minor);
1535         spin_unlock(&_minor_lock);
1536 }
1537
1538 /*
1539  * See if the device with a specific minor # is free.
1540  */
1541 static int specific_minor(int minor)
1542 {
1543         int r;
1544
1545         if (minor >= (1 << MINORBITS))
1546                 return -EINVAL;
1547
1548         idr_preload(GFP_KERNEL);
1549         spin_lock(&_minor_lock);
1550
1551         r = idr_alloc(&_minor_idr, MINOR_ALLOCED, minor, minor + 1, GFP_NOWAIT);
1552
1553         spin_unlock(&_minor_lock);
1554         idr_preload_end();
1555         if (r < 0)
1556                 return r == -ENOSPC ? -EBUSY : r;
1557         return 0;
1558 }
1559
1560 static int next_free_minor(int *minor)
1561 {
1562         int r;
1563
1564         idr_preload(GFP_KERNEL);
1565         spin_lock(&_minor_lock);
1566
1567         r = idr_alloc(&_minor_idr, MINOR_ALLOCED, 0, 1 << MINORBITS, GFP_NOWAIT);
1568
1569         spin_unlock(&_minor_lock);
1570         idr_preload_end();
1571         if (r < 0)
1572                 return r;
1573         *minor = r;
1574         return 0;
1575 }
1576
1577 static const struct block_device_operations dm_blk_dops;
1578 static const struct block_device_operations dm_rq_blk_dops;
1579 static const struct dax_operations dm_dax_ops;
1580
1581 static void dm_wq_work(struct work_struct *work);
1582
1583 #ifdef CONFIG_BLK_INLINE_ENCRYPTION
1584 static void dm_queue_destroy_crypto_profile(struct request_queue *q)
1585 {
1586         dm_destroy_crypto_profile(q->crypto_profile);
1587 }
1588
1589 #else /* CONFIG_BLK_INLINE_ENCRYPTION */
1590
1591 static inline void dm_queue_destroy_crypto_profile(struct request_queue *q)
1592 {
1593 }
1594 #endif /* !CONFIG_BLK_INLINE_ENCRYPTION */
1595
1596 static void cleanup_mapped_device(struct mapped_device *md)
1597 {
1598         if (md->wq)
1599                 destroy_workqueue(md->wq);
1600         bioset_exit(&md->bs);
1601         bioset_exit(&md->io_bs);
1602
1603         if (md->dax_dev) {
1604                 dax_remove_host(md->disk);
1605                 kill_dax(md->dax_dev);
1606                 put_dax(md->dax_dev);
1607                 md->dax_dev = NULL;
1608         }
1609
1610         if (md->disk) {
1611                 spin_lock(&_minor_lock);
1612                 md->disk->private_data = NULL;
1613                 spin_unlock(&_minor_lock);
1614                 if (dm_get_md_type(md) != DM_TYPE_NONE) {
1615                         dm_sysfs_exit(md);
1616                         del_gendisk(md->disk);
1617                 }
1618                 dm_queue_destroy_crypto_profile(md->queue);
1619                 blk_cleanup_disk(md->disk);
1620         }
1621
1622         cleanup_srcu_struct(&md->io_barrier);
1623
1624         mutex_destroy(&md->suspend_lock);
1625         mutex_destroy(&md->type_lock);
1626         mutex_destroy(&md->table_devices_lock);
1627         mutex_destroy(&md->swap_bios_lock);
1628
1629         dm_mq_cleanup_mapped_device(md);
1630         dm_cleanup_zoned_dev(md);
1631 }
1632
1633 /*
1634  * Allocate and initialise a blank device with a given minor.
1635  */
1636 static struct mapped_device *alloc_dev(int minor)
1637 {
1638         int r, numa_node_id = dm_get_numa_node();
1639         struct mapped_device *md;
1640         void *old_md;
1641
1642         md = kvzalloc_node(sizeof(*md), GFP_KERNEL, numa_node_id);
1643         if (!md) {
1644                 DMWARN("unable to allocate device, out of memory.");
1645                 return NULL;
1646         }
1647
1648         if (!try_module_get(THIS_MODULE))
1649                 goto bad_module_get;
1650
1651         /* get a minor number for the dev */
1652         if (minor == DM_ANY_MINOR)
1653                 r = next_free_minor(&minor);
1654         else
1655                 r = specific_minor(minor);
1656         if (r < 0)
1657                 goto bad_minor;
1658
1659         r = init_srcu_struct(&md->io_barrier);
1660         if (r < 0)
1661                 goto bad_io_barrier;
1662
1663         md->numa_node_id = numa_node_id;
1664         md->init_tio_pdu = false;
1665         md->type = DM_TYPE_NONE;
1666         mutex_init(&md->suspend_lock);
1667         mutex_init(&md->type_lock);
1668         mutex_init(&md->table_devices_lock);
1669         spin_lock_init(&md->deferred_lock);
1670         atomic_set(&md->holders, 1);
1671         atomic_set(&md->open_count, 0);
1672         atomic_set(&md->event_nr, 0);
1673         atomic_set(&md->uevent_seq, 0);
1674         INIT_LIST_HEAD(&md->uevent_list);
1675         INIT_LIST_HEAD(&md->table_devices);
1676         spin_lock_init(&md->uevent_lock);
1677
1678         /*
1679          * default to bio-based until DM table is loaded and md->type
1680          * established. If request-based table is loaded: blk-mq will
1681          * override accordingly.
1682          */
1683         md->disk = blk_alloc_disk(md->numa_node_id);
1684         if (!md->disk)
1685                 goto bad;
1686         md->queue = md->disk->queue;
1687
1688         init_waitqueue_head(&md->wait);
1689         INIT_WORK(&md->work, dm_wq_work);
1690         init_waitqueue_head(&md->eventq);
1691         init_completion(&md->kobj_holder.completion);
1692
1693         md->swap_bios = get_swap_bios();
1694         sema_init(&md->swap_bios_semaphore, md->swap_bios);
1695         mutex_init(&md->swap_bios_lock);
1696
1697         md->disk->major = _major;
1698         md->disk->first_minor = minor;
1699         md->disk->minors = 1;
1700         md->disk->flags |= GENHD_FL_NO_PART;
1701         md->disk->fops = &dm_blk_dops;
1702         md->disk->queue = md->queue;
1703         md->disk->private_data = md;
1704         sprintf(md->disk->disk_name, "dm-%d", minor);
1705
1706         if (IS_ENABLED(CONFIG_FS_DAX)) {
1707                 md->dax_dev = alloc_dax(md, &dm_dax_ops);
1708                 if (IS_ERR(md->dax_dev)) {
1709                         md->dax_dev = NULL;
1710                         goto bad;
1711                 }
1712                 set_dax_nocache(md->dax_dev);
1713                 set_dax_nomc(md->dax_dev);
1714                 if (dax_add_host(md->dax_dev, md->disk))
1715                         goto bad;
1716         }
1717
1718         format_dev_t(md->name, MKDEV(_major, minor));
1719
1720         md->wq = alloc_workqueue("kdmflush/%s", WQ_MEM_RECLAIM, 0, md->name);
1721         if (!md->wq)
1722                 goto bad;
1723
1724         dm_stats_init(&md->stats);
1725
1726         /* Populate the mapping, nobody knows we exist yet */
1727         spin_lock(&_minor_lock);
1728         old_md = idr_replace(&_minor_idr, md, minor);
1729         spin_unlock(&_minor_lock);
1730
1731         BUG_ON(old_md != MINOR_ALLOCED);
1732
1733         return md;
1734
1735 bad:
1736         cleanup_mapped_device(md);
1737 bad_io_barrier:
1738         free_minor(minor);
1739 bad_minor:
1740         module_put(THIS_MODULE);
1741 bad_module_get:
1742         kvfree(md);
1743         return NULL;
1744 }
1745
1746 static void unlock_fs(struct mapped_device *md);
1747
1748 static void free_dev(struct mapped_device *md)
1749 {
1750         int minor = MINOR(disk_devt(md->disk));
1751
1752         unlock_fs(md);
1753
1754         cleanup_mapped_device(md);
1755
1756         free_table_devices(&md->table_devices);
1757         dm_stats_cleanup(&md->stats);
1758         free_minor(minor);
1759
1760         module_put(THIS_MODULE);
1761         kvfree(md);
1762 }
1763
1764 static int __bind_mempools(struct mapped_device *md, struct dm_table *t)
1765 {
1766         struct dm_md_mempools *p = dm_table_get_md_mempools(t);
1767         int ret = 0;
1768
1769         if (dm_table_bio_based(t)) {
1770                 /*
1771                  * The md may already have mempools that need changing.
1772                  * If so, reload bioset because front_pad may have changed
1773                  * because a different table was loaded.
1774                  */
1775                 bioset_exit(&md->bs);
1776                 bioset_exit(&md->io_bs);
1777
1778         } else if (bioset_initialized(&md->bs)) {
1779                 /*
1780                  * There's no need to reload with request-based dm
1781                  * because the size of front_pad doesn't change.
1782                  * Note for future: If you are to reload bioset,
1783                  * prep-ed requests in the queue may refer
1784                  * to bio from the old bioset, so you must walk
1785                  * through the queue to unprep.
1786                  */
1787                 goto out;
1788         }
1789
1790         BUG_ON(!p ||
1791                bioset_initialized(&md->bs) ||
1792                bioset_initialized(&md->io_bs));
1793
1794         ret = bioset_init_from_src(&md->bs, &p->bs);
1795         if (ret)
1796                 goto out;
1797         ret = bioset_init_from_src(&md->io_bs, &p->io_bs);
1798         if (ret)
1799                 bioset_exit(&md->bs);
1800 out:
1801         /* mempool bind completed, no longer need any mempools in the table */
1802         dm_table_free_md_mempools(t);
1803         return ret;
1804 }
1805
1806 /*
1807  * Bind a table to the device.
1808  */
1809 static void event_callback(void *context)
1810 {
1811         unsigned long flags;
1812         LIST_HEAD(uevents);
1813         struct mapped_device *md = (struct mapped_device *) context;
1814
1815         spin_lock_irqsave(&md->uevent_lock, flags);
1816         list_splice_init(&md->uevent_list, &uevents);
1817         spin_unlock_irqrestore(&md->uevent_lock, flags);
1818
1819         dm_send_uevents(&uevents, &disk_to_dev(md->disk)->kobj);
1820
1821         atomic_inc(&md->event_nr);
1822         wake_up(&md->eventq);
1823         dm_issue_global_event();
1824 }
1825
1826 /*
1827  * Returns old map, which caller must destroy.
1828  */
1829 static struct dm_table *__bind(struct mapped_device *md, struct dm_table *t,
1830                                struct queue_limits *limits)
1831 {
1832         struct dm_table *old_map;
1833         struct request_queue *q = md->queue;
1834         bool request_based = dm_table_request_based(t);
1835         sector_t size;
1836         int ret;
1837
1838         lockdep_assert_held(&md->suspend_lock);
1839
1840         size = dm_table_get_size(t);
1841
1842         /*
1843          * Wipe any geometry if the size of the table changed.
1844          */
1845         if (size != dm_get_size(md))
1846                 memset(&md->geometry, 0, sizeof(md->geometry));
1847
1848         if (!get_capacity(md->disk))
1849                 set_capacity(md->disk, size);
1850         else
1851                 set_capacity_and_notify(md->disk, size);
1852
1853         dm_table_event_callback(t, event_callback, md);
1854
1855         if (request_based) {
1856                 /*
1857                  * Leverage the fact that request-based DM targets are
1858                  * immutable singletons - used to optimize dm_mq_queue_rq.
1859                  */
1860                 md->immutable_target = dm_table_get_immutable_target(t);
1861         }
1862
1863         ret = __bind_mempools(md, t);
1864         if (ret) {
1865                 old_map = ERR_PTR(ret);
1866                 goto out;
1867         }
1868
1869         ret = dm_table_set_restrictions(t, q, limits);
1870         if (ret) {
1871                 old_map = ERR_PTR(ret);
1872                 goto out;
1873         }
1874
1875         old_map = rcu_dereference_protected(md->map, lockdep_is_held(&md->suspend_lock));
1876         rcu_assign_pointer(md->map, (void *)t);
1877         md->immutable_target_type = dm_table_get_immutable_target_type(t);
1878
1879         if (old_map)
1880                 dm_sync_table(md);
1881
1882 out:
1883         return old_map;
1884 }
1885
1886 /*
1887  * Returns unbound table for the caller to free.
1888  */
1889 static struct dm_table *__unbind(struct mapped_device *md)
1890 {
1891         struct dm_table *map = rcu_dereference_protected(md->map, 1);
1892
1893         if (!map)
1894                 return NULL;
1895
1896         dm_table_event_callback(map, NULL, NULL);
1897         RCU_INIT_POINTER(md->map, NULL);
1898         dm_sync_table(md);
1899
1900         return map;
1901 }
1902
1903 /*
1904  * Constructor for a new device.
1905  */
1906 int dm_create(int minor, struct mapped_device **result)
1907 {
1908         struct mapped_device *md;
1909
1910         md = alloc_dev(minor);
1911         if (!md)
1912                 return -ENXIO;
1913
1914         dm_ima_reset_data(md);
1915
1916         *result = md;
1917         return 0;
1918 }
1919
1920 /*
1921  * Functions to manage md->type.
1922  * All are required to hold md->type_lock.
1923  */
1924 void dm_lock_md_type(struct mapped_device *md)
1925 {
1926         mutex_lock(&md->type_lock);
1927 }
1928
1929 void dm_unlock_md_type(struct mapped_device *md)
1930 {
1931         mutex_unlock(&md->type_lock);
1932 }
1933
1934 void dm_set_md_type(struct mapped_device *md, enum dm_queue_mode type)
1935 {
1936         BUG_ON(!mutex_is_locked(&md->type_lock));
1937         md->type = type;
1938 }
1939
1940 enum dm_queue_mode dm_get_md_type(struct mapped_device *md)
1941 {
1942         return md->type;
1943 }
1944
1945 struct target_type *dm_get_immutable_target_type(struct mapped_device *md)
1946 {
1947         return md->immutable_target_type;
1948 }
1949
1950 /*
1951  * The queue_limits are only valid as long as you have a reference
1952  * count on 'md'.
1953  */
1954 struct queue_limits *dm_get_queue_limits(struct mapped_device *md)
1955 {
1956         BUG_ON(!atomic_read(&md->holders));
1957         return &md->queue->limits;
1958 }
1959 EXPORT_SYMBOL_GPL(dm_get_queue_limits);
1960
1961 /*
1962  * Setup the DM device's queue based on md's type
1963  */
1964 int dm_setup_md_queue(struct mapped_device *md, struct dm_table *t)
1965 {
1966         enum dm_queue_mode type = dm_table_get_type(t);
1967         struct queue_limits limits;
1968         int r;
1969
1970         switch (type) {
1971         case DM_TYPE_REQUEST_BASED:
1972                 md->disk->fops = &dm_rq_blk_dops;
1973                 r = dm_mq_init_request_queue(md, t);
1974                 if (r) {
1975                         DMERR("Cannot initialize queue for request-based dm mapped device");
1976                         return r;
1977                 }
1978                 break;
1979         case DM_TYPE_BIO_BASED:
1980         case DM_TYPE_DAX_BIO_BASED:
1981                 break;
1982         case DM_TYPE_NONE:
1983                 WARN_ON_ONCE(true);
1984                 break;
1985         }
1986
1987         r = dm_calculate_queue_limits(t, &limits);
1988         if (r) {
1989                 DMERR("Cannot calculate initial queue limits");
1990                 return r;
1991         }
1992         r = dm_table_set_restrictions(t, md->queue, &limits);
1993         if (r)
1994                 return r;
1995
1996         r = add_disk(md->disk);
1997         if (r)
1998                 return r;
1999
2000         r = dm_sysfs_init(md);
2001         if (r) {
2002                 del_gendisk(md->disk);
2003                 return r;
2004         }
2005         md->type = type;
2006         return 0;
2007 }
2008
2009 struct mapped_device *dm_get_md(dev_t dev)
2010 {
2011         struct mapped_device *md;
2012         unsigned minor = MINOR(dev);
2013
2014         if (MAJOR(dev) != _major || minor >= (1 << MINORBITS))
2015                 return NULL;
2016
2017         spin_lock(&_minor_lock);
2018
2019         md = idr_find(&_minor_idr, minor);
2020         if (!md || md == MINOR_ALLOCED || (MINOR(disk_devt(dm_disk(md))) != minor) ||
2021             test_bit(DMF_FREEING, &md->flags) || dm_deleting_md(md)) {
2022                 md = NULL;
2023                 goto out;
2024         }
2025         dm_get(md);
2026 out:
2027         spin_unlock(&_minor_lock);
2028
2029         return md;
2030 }
2031 EXPORT_SYMBOL_GPL(dm_get_md);
2032
2033 void *dm_get_mdptr(struct mapped_device *md)
2034 {
2035         return md->interface_ptr;
2036 }
2037
2038 void dm_set_mdptr(struct mapped_device *md, void *ptr)
2039 {
2040         md->interface_ptr = ptr;
2041 }
2042
2043 void dm_get(struct mapped_device *md)
2044 {
2045         atomic_inc(&md->holders);
2046         BUG_ON(test_bit(DMF_FREEING, &md->flags));
2047 }
2048
2049 int dm_hold(struct mapped_device *md)
2050 {
2051         spin_lock(&_minor_lock);
2052         if (test_bit(DMF_FREEING, &md->flags)) {
2053                 spin_unlock(&_minor_lock);
2054                 return -EBUSY;
2055         }
2056         dm_get(md);
2057         spin_unlock(&_minor_lock);
2058         return 0;
2059 }
2060 EXPORT_SYMBOL_GPL(dm_hold);
2061
2062 const char *dm_device_name(struct mapped_device *md)
2063 {
2064         return md->name;
2065 }
2066 EXPORT_SYMBOL_GPL(dm_device_name);
2067
2068 static void __dm_destroy(struct mapped_device *md, bool wait)
2069 {
2070         struct dm_table *map;
2071         int srcu_idx;
2072
2073         might_sleep();
2074
2075         spin_lock(&_minor_lock);
2076         idr_replace(&_minor_idr, MINOR_ALLOCED, MINOR(disk_devt(dm_disk(md))));
2077         set_bit(DMF_FREEING, &md->flags);
2078         spin_unlock(&_minor_lock);
2079
2080         blk_set_queue_dying(md->queue);
2081
2082         /*
2083          * Take suspend_lock so that presuspend and postsuspend methods
2084          * do not race with internal suspend.
2085          */
2086         mutex_lock(&md->suspend_lock);
2087         map = dm_get_live_table(md, &srcu_idx);
2088         if (!dm_suspended_md(md)) {
2089                 dm_table_presuspend_targets(map);
2090                 set_bit(DMF_SUSPENDED, &md->flags);
2091                 set_bit(DMF_POST_SUSPENDING, &md->flags);
2092                 dm_table_postsuspend_targets(map);
2093         }
2094         /* dm_put_live_table must be before msleep, otherwise deadlock is possible */
2095         dm_put_live_table(md, srcu_idx);
2096         mutex_unlock(&md->suspend_lock);
2097
2098         /*
2099          * Rare, but there may be I/O requests still going to complete,
2100          * for example.  Wait for all references to disappear.
2101          * No one should increment the reference count of the mapped_device,
2102          * after the mapped_device state becomes DMF_FREEING.
2103          */
2104         if (wait)
2105                 while (atomic_read(&md->holders))
2106                         msleep(1);
2107         else if (atomic_read(&md->holders))
2108                 DMWARN("%s: Forcibly removing mapped_device still in use! (%d users)",
2109                        dm_device_name(md), atomic_read(&md->holders));
2110
2111         dm_table_destroy(__unbind(md));
2112         free_dev(md);
2113 }
2114
2115 void dm_destroy(struct mapped_device *md)
2116 {
2117         __dm_destroy(md, true);
2118 }
2119
2120 void dm_destroy_immediate(struct mapped_device *md)
2121 {
2122         __dm_destroy(md, false);
2123 }
2124
2125 void dm_put(struct mapped_device *md)
2126 {
2127         atomic_dec(&md->holders);
2128 }
2129 EXPORT_SYMBOL_GPL(dm_put);
2130
2131 static bool md_in_flight_bios(struct mapped_device *md)
2132 {
2133         int cpu;
2134         struct block_device *part = dm_disk(md)->part0;
2135         long sum = 0;
2136
2137         for_each_possible_cpu(cpu) {
2138                 sum += part_stat_local_read_cpu(part, in_flight[0], cpu);
2139                 sum += part_stat_local_read_cpu(part, in_flight[1], cpu);
2140         }
2141
2142         return sum != 0;
2143 }
2144
2145 static int dm_wait_for_bios_completion(struct mapped_device *md, unsigned int task_state)
2146 {
2147         int r = 0;
2148         DEFINE_WAIT(wait);
2149
2150         while (true) {
2151                 prepare_to_wait(&md->wait, &wait, task_state);
2152
2153                 if (!md_in_flight_bios(md))
2154                         break;
2155
2156                 if (signal_pending_state(task_state, current)) {
2157                         r = -EINTR;
2158                         break;
2159                 }
2160
2161                 io_schedule();
2162         }
2163         finish_wait(&md->wait, &wait);
2164
2165         return r;
2166 }
2167
2168 static int dm_wait_for_completion(struct mapped_device *md, unsigned int task_state)
2169 {
2170         int r = 0;
2171
2172         if (!queue_is_mq(md->queue))
2173                 return dm_wait_for_bios_completion(md, task_state);
2174
2175         while (true) {
2176                 if (!blk_mq_queue_inflight(md->queue))
2177                         break;
2178
2179                 if (signal_pending_state(task_state, current)) {
2180                         r = -EINTR;
2181                         break;
2182                 }
2183
2184                 msleep(5);
2185         }
2186
2187         return r;
2188 }
2189
2190 /*
2191  * Process the deferred bios
2192  */
2193 static void dm_wq_work(struct work_struct *work)
2194 {
2195         struct mapped_device *md = container_of(work, struct mapped_device, work);
2196         struct bio *bio;
2197
2198         while (!test_bit(DMF_BLOCK_IO_FOR_SUSPEND, &md->flags)) {
2199                 spin_lock_irq(&md->deferred_lock);
2200                 bio = bio_list_pop(&md->deferred);
2201                 spin_unlock_irq(&md->deferred_lock);
2202
2203                 if (!bio)
2204                         break;
2205
2206                 submit_bio_noacct(bio);
2207         }
2208 }
2209
2210 static void dm_queue_flush(struct mapped_device *md)
2211 {
2212         clear_bit(DMF_BLOCK_IO_FOR_SUSPEND, &md->flags);
2213         smp_mb__after_atomic();
2214         queue_work(md->wq, &md->work);
2215 }
2216
2217 /*
2218  * Swap in a new table, returning the old one for the caller to destroy.
2219  */
2220 struct dm_table *dm_swap_table(struct mapped_device *md, struct dm_table *table)
2221 {
2222         struct dm_table *live_map = NULL, *map = ERR_PTR(-EINVAL);
2223         struct queue_limits limits;
2224         int r;
2225
2226         mutex_lock(&md->suspend_lock);
2227
2228         /* device must be suspended */
2229         if (!dm_suspended_md(md))
2230                 goto out;
2231
2232         /*
2233          * If the new table has no data devices, retain the existing limits.
2234          * This helps multipath with queue_if_no_path if all paths disappear,
2235          * then new I/O is queued based on these limits, and then some paths
2236          * reappear.
2237          */
2238         if (dm_table_has_no_data_devices(table)) {
2239                 live_map = dm_get_live_table_fast(md);
2240                 if (live_map)
2241                         limits = md->queue->limits;
2242                 dm_put_live_table_fast(md);
2243         }
2244
2245         if (!live_map) {
2246                 r = dm_calculate_queue_limits(table, &limits);
2247                 if (r) {
2248                         map = ERR_PTR(r);
2249                         goto out;
2250                 }
2251         }
2252
2253         map = __bind(md, table, &limits);
2254         dm_issue_global_event();
2255
2256 out:
2257         mutex_unlock(&md->suspend_lock);
2258         return map;
2259 }
2260
2261 /*
2262  * Functions to lock and unlock any filesystem running on the
2263  * device.
2264  */
2265 static int lock_fs(struct mapped_device *md)
2266 {
2267         int r;
2268
2269         WARN_ON(test_bit(DMF_FROZEN, &md->flags));
2270
2271         r = freeze_bdev(md->disk->part0);
2272         if (!r)
2273                 set_bit(DMF_FROZEN, &md->flags);
2274         return r;
2275 }
2276
2277 static void unlock_fs(struct mapped_device *md)
2278 {
2279         if (!test_bit(DMF_FROZEN, &md->flags))
2280                 return;
2281         thaw_bdev(md->disk->part0);
2282         clear_bit(DMF_FROZEN, &md->flags);
2283 }
2284
2285 /*
2286  * @suspend_flags: DM_SUSPEND_LOCKFS_FLAG and/or DM_SUSPEND_NOFLUSH_FLAG
2287  * @task_state: e.g. TASK_INTERRUPTIBLE or TASK_UNINTERRUPTIBLE
2288  * @dmf_suspended_flag: DMF_SUSPENDED or DMF_SUSPENDED_INTERNALLY
2289  *
2290  * If __dm_suspend returns 0, the device is completely quiescent
2291  * now. There is no request-processing activity. All new requests
2292  * are being added to md->deferred list.
2293  */
2294 static int __dm_suspend(struct mapped_device *md, struct dm_table *map,
2295                         unsigned suspend_flags, unsigned int task_state,
2296                         int dmf_suspended_flag)
2297 {
2298         bool do_lockfs = suspend_flags & DM_SUSPEND_LOCKFS_FLAG;
2299         bool noflush = suspend_flags & DM_SUSPEND_NOFLUSH_FLAG;
2300         int r;
2301
2302         lockdep_assert_held(&md->suspend_lock);
2303
2304         /*
2305          * DMF_NOFLUSH_SUSPENDING must be set before presuspend.
2306          * This flag is cleared before dm_suspend returns.
2307          */
2308         if (noflush)
2309                 set_bit(DMF_NOFLUSH_SUSPENDING, &md->flags);
2310         else
2311                 DMDEBUG("%s: suspending with flush", dm_device_name(md));
2312
2313         /*
2314          * This gets reverted if there's an error later and the targets
2315          * provide the .presuspend_undo hook.
2316          */
2317         dm_table_presuspend_targets(map);
2318
2319         /*
2320          * Flush I/O to the device.
2321          * Any I/O submitted after lock_fs() may not be flushed.
2322          * noflush takes precedence over do_lockfs.
2323          * (lock_fs() flushes I/Os and waits for them to complete.)
2324          */
2325         if (!noflush && do_lockfs) {
2326                 r = lock_fs(md);
2327                 if (r) {
2328                         dm_table_presuspend_undo_targets(map);
2329                         return r;
2330                 }
2331         }
2332
2333         /*
2334          * Here we must make sure that no processes are submitting requests
2335          * to target drivers i.e. no one may be executing
2336          * __split_and_process_bio from dm_submit_bio.
2337          *
2338          * To get all processes out of __split_and_process_bio in dm_submit_bio,
2339          * we take the write lock. To prevent any process from reentering
2340          * __split_and_process_bio from dm_submit_bio and quiesce the thread
2341          * (dm_wq_work), we set DMF_BLOCK_IO_FOR_SUSPEND and call
2342          * flush_workqueue(md->wq).
2343          */
2344         set_bit(DMF_BLOCK_IO_FOR_SUSPEND, &md->flags);
2345         if (map)
2346                 synchronize_srcu(&md->io_barrier);
2347
2348         /*
2349          * Stop md->queue before flushing md->wq in case request-based
2350          * dm defers requests to md->wq from md->queue.
2351          */
2352         if (dm_request_based(md))
2353                 dm_stop_queue(md->queue);
2354
2355         flush_workqueue(md->wq);
2356
2357         /*
2358          * At this point no more requests are entering target request routines.
2359          * We call dm_wait_for_completion to wait for all existing requests
2360          * to finish.
2361          */
2362         r = dm_wait_for_completion(md, task_state);
2363         if (!r)
2364                 set_bit(dmf_suspended_flag, &md->flags);
2365
2366         if (noflush)
2367                 clear_bit(DMF_NOFLUSH_SUSPENDING, &md->flags);
2368         if (map)
2369                 synchronize_srcu(&md->io_barrier);
2370
2371         /* were we interrupted ? */
2372         if (r < 0) {
2373                 dm_queue_flush(md);
2374
2375                 if (dm_request_based(md))
2376                         dm_start_queue(md->queue);
2377
2378                 unlock_fs(md);
2379                 dm_table_presuspend_undo_targets(map);
2380                 /* pushback list is already flushed, so skip flush */
2381         }
2382
2383         return r;
2384 }
2385
2386 /*
2387  * We need to be able to change a mapping table under a mounted
2388  * filesystem.  For example we might want to move some data in
2389  * the background.  Before the table can be swapped with
2390  * dm_bind_table, dm_suspend must be called to flush any in
2391  * flight bios and ensure that any further io gets deferred.
2392  */
2393 /*
2394  * Suspend mechanism in request-based dm.
2395  *
2396  * 1. Flush all I/Os by lock_fs() if needed.
2397  * 2. Stop dispatching any I/O by stopping the request_queue.
2398  * 3. Wait for all in-flight I/Os to be completed or requeued.
2399  *
2400  * To abort suspend, start the request_queue.
2401  */
2402 int dm_suspend(struct mapped_device *md, unsigned suspend_flags)
2403 {
2404         struct dm_table *map = NULL;
2405         int r = 0;
2406
2407 retry:
2408         mutex_lock_nested(&md->suspend_lock, SINGLE_DEPTH_NESTING);
2409
2410         if (dm_suspended_md(md)) {
2411                 r = -EINVAL;
2412                 goto out_unlock;
2413         }
2414
2415         if (dm_suspended_internally_md(md)) {
2416                 /* already internally suspended, wait for internal resume */
2417                 mutex_unlock(&md->suspend_lock);
2418                 r = wait_on_bit(&md->flags, DMF_SUSPENDED_INTERNALLY, TASK_INTERRUPTIBLE);
2419                 if (r)
2420                         return r;
2421                 goto retry;
2422         }
2423
2424         map = rcu_dereference_protected(md->map, lockdep_is_held(&md->suspend_lock));
2425
2426         r = __dm_suspend(md, map, suspend_flags, TASK_INTERRUPTIBLE, DMF_SUSPENDED);
2427         if (r)
2428                 goto out_unlock;
2429
2430         set_bit(DMF_POST_SUSPENDING, &md->flags);
2431         dm_table_postsuspend_targets(map);
2432         clear_bit(DMF_POST_SUSPENDING, &md->flags);
2433
2434 out_unlock:
2435         mutex_unlock(&md->suspend_lock);
2436         return r;
2437 }
2438
2439 static int __dm_resume(struct mapped_device *md, struct dm_table *map)
2440 {
2441         if (map) {
2442                 int r = dm_table_resume_targets(map);
2443                 if (r)
2444                         return r;
2445         }
2446
2447         dm_queue_flush(md);
2448
2449         /*
2450          * Flushing deferred I/Os must be done after targets are resumed
2451          * so that mapping of targets can work correctly.
2452          * Request-based dm is queueing the deferred I/Os in its request_queue.
2453          */
2454         if (dm_request_based(md))
2455                 dm_start_queue(md->queue);
2456
2457         unlock_fs(md);
2458
2459         return 0;
2460 }
2461
2462 int dm_resume(struct mapped_device *md)
2463 {
2464         int r;
2465         struct dm_table *map = NULL;
2466
2467 retry:
2468         r = -EINVAL;
2469         mutex_lock_nested(&md->suspend_lock, SINGLE_DEPTH_NESTING);
2470
2471         if (!dm_suspended_md(md))
2472                 goto out;
2473
2474         if (dm_suspended_internally_md(md)) {
2475                 /* already internally suspended, wait for internal resume */
2476                 mutex_unlock(&md->suspend_lock);
2477                 r = wait_on_bit(&md->flags, DMF_SUSPENDED_INTERNALLY, TASK_INTERRUPTIBLE);
2478                 if (r)
2479                         return r;
2480                 goto retry;
2481         }
2482
2483         map = rcu_dereference_protected(md->map, lockdep_is_held(&md->suspend_lock));
2484         if (!map || !dm_table_get_size(map))
2485                 goto out;
2486
2487         r = __dm_resume(md, map);
2488         if (r)
2489                 goto out;
2490
2491         clear_bit(DMF_SUSPENDED, &md->flags);
2492 out:
2493         mutex_unlock(&md->suspend_lock);
2494
2495         return r;
2496 }
2497
2498 /*
2499  * Internal suspend/resume works like userspace-driven suspend. It waits
2500  * until all bios finish and prevents issuing new bios to the target drivers.
2501  * It may be used only from the kernel.
2502  */
2503
2504 static void __dm_internal_suspend(struct mapped_device *md, unsigned suspend_flags)
2505 {
2506         struct dm_table *map = NULL;
2507
2508         lockdep_assert_held(&md->suspend_lock);
2509
2510         if (md->internal_suspend_count++)
2511                 return; /* nested internal suspend */
2512
2513         if (dm_suspended_md(md)) {
2514                 set_bit(DMF_SUSPENDED_INTERNALLY, &md->flags);
2515                 return; /* nest suspend */
2516         }
2517
2518         map = rcu_dereference_protected(md->map, lockdep_is_held(&md->suspend_lock));
2519
2520         /*
2521          * Using TASK_UNINTERRUPTIBLE because only NOFLUSH internal suspend is
2522          * supported.  Properly supporting a TASK_INTERRUPTIBLE internal suspend
2523          * would require changing .presuspend to return an error -- avoid this
2524          * until there is a need for more elaborate variants of internal suspend.
2525          */
2526         (void) __dm_suspend(md, map, suspend_flags, TASK_UNINTERRUPTIBLE,
2527                             DMF_SUSPENDED_INTERNALLY);
2528
2529         set_bit(DMF_POST_SUSPENDING, &md->flags);
2530         dm_table_postsuspend_targets(map);
2531         clear_bit(DMF_POST_SUSPENDING, &md->flags);
2532 }
2533
2534 static void __dm_internal_resume(struct mapped_device *md)
2535 {
2536         BUG_ON(!md->internal_suspend_count);
2537
2538         if (--md->internal_suspend_count)
2539                 return; /* resume from nested internal suspend */
2540
2541         if (dm_suspended_md(md))
2542                 goto done; /* resume from nested suspend */
2543
2544         /*
2545          * NOTE: existing callers don't need to call dm_table_resume_targets
2546          * (which may fail -- so best to avoid it for now by passing NULL map)
2547          */
2548         (void) __dm_resume(md, NULL);
2549
2550 done:
2551         clear_bit(DMF_SUSPENDED_INTERNALLY, &md->flags);
2552         smp_mb__after_atomic();
2553         wake_up_bit(&md->flags, DMF_SUSPENDED_INTERNALLY);
2554 }
2555
2556 void dm_internal_suspend_noflush(struct mapped_device *md)
2557 {
2558         mutex_lock(&md->suspend_lock);
2559         __dm_internal_suspend(md, DM_SUSPEND_NOFLUSH_FLAG);
2560         mutex_unlock(&md->suspend_lock);
2561 }
2562 EXPORT_SYMBOL_GPL(dm_internal_suspend_noflush);
2563
2564 void dm_internal_resume(struct mapped_device *md)
2565 {
2566         mutex_lock(&md->suspend_lock);
2567         __dm_internal_resume(md);
2568         mutex_unlock(&md->suspend_lock);
2569 }
2570 EXPORT_SYMBOL_GPL(dm_internal_resume);
2571
2572 /*
2573  * Fast variants of internal suspend/resume hold md->suspend_lock,
2574  * which prevents interaction with userspace-driven suspend.
2575  */
2576
2577 void dm_internal_suspend_fast(struct mapped_device *md)
2578 {
2579         mutex_lock(&md->suspend_lock);
2580         if (dm_suspended_md(md) || dm_suspended_internally_md(md))
2581                 return;
2582
2583         set_bit(DMF_BLOCK_IO_FOR_SUSPEND, &md->flags);
2584         synchronize_srcu(&md->io_barrier);
2585         flush_workqueue(md->wq);
2586         dm_wait_for_completion(md, TASK_UNINTERRUPTIBLE);
2587 }
2588 EXPORT_SYMBOL_GPL(dm_internal_suspend_fast);
2589
2590 void dm_internal_resume_fast(struct mapped_device *md)
2591 {
2592         if (dm_suspended_md(md) || dm_suspended_internally_md(md))
2593                 goto done;
2594
2595         dm_queue_flush(md);
2596
2597 done:
2598         mutex_unlock(&md->suspend_lock);
2599 }
2600 EXPORT_SYMBOL_GPL(dm_internal_resume_fast);
2601
2602 /*-----------------------------------------------------------------
2603  * Event notification.
2604  *---------------------------------------------------------------*/
2605 int dm_kobject_uevent(struct mapped_device *md, enum kobject_action action,
2606                        unsigned cookie)
2607 {
2608         int r;
2609         unsigned noio_flag;
2610         char udev_cookie[DM_COOKIE_LENGTH];
2611         char *envp[] = { udev_cookie, NULL };
2612
2613         noio_flag = memalloc_noio_save();
2614
2615         if (!cookie)
2616                 r = kobject_uevent(&disk_to_dev(md->disk)->kobj, action);
2617         else {
2618                 snprintf(udev_cookie, DM_COOKIE_LENGTH, "%s=%u",
2619                          DM_COOKIE_ENV_VAR_NAME, cookie);
2620                 r = kobject_uevent_env(&disk_to_dev(md->disk)->kobj,
2621                                        action, envp);
2622         }
2623
2624         memalloc_noio_restore(noio_flag);
2625
2626         return r;
2627 }
2628
2629 uint32_t dm_next_uevent_seq(struct mapped_device *md)
2630 {
2631         return atomic_add_return(1, &md->uevent_seq);
2632 }
2633
2634 uint32_t dm_get_event_nr(struct mapped_device *md)
2635 {
2636         return atomic_read(&md->event_nr);
2637 }
2638
2639 int dm_wait_event(struct mapped_device *md, int event_nr)
2640 {
2641         return wait_event_interruptible(md->eventq,
2642                         (event_nr != atomic_read(&md->event_nr)));
2643 }
2644
2645 void dm_uevent_add(struct mapped_device *md, struct list_head *elist)
2646 {
2647         unsigned long flags;
2648
2649         spin_lock_irqsave(&md->uevent_lock, flags);
2650         list_add(elist, &md->uevent_list);
2651         spin_unlock_irqrestore(&md->uevent_lock, flags);
2652 }
2653
2654 /*
2655  * The gendisk is only valid as long as you have a reference
2656  * count on 'md'.
2657  */
2658 struct gendisk *dm_disk(struct mapped_device *md)
2659 {
2660         return md->disk;
2661 }
2662 EXPORT_SYMBOL_GPL(dm_disk);
2663
2664 struct kobject *dm_kobject(struct mapped_device *md)
2665 {
2666         return &md->kobj_holder.kobj;
2667 }
2668
2669 struct mapped_device *dm_get_from_kobject(struct kobject *kobj)
2670 {
2671         struct mapped_device *md;
2672
2673         md = container_of(kobj, struct mapped_device, kobj_holder.kobj);
2674
2675         spin_lock(&_minor_lock);
2676         if (test_bit(DMF_FREEING, &md->flags) || dm_deleting_md(md)) {
2677                 md = NULL;
2678                 goto out;
2679         }
2680         dm_get(md);
2681 out:
2682         spin_unlock(&_minor_lock);
2683
2684         return md;
2685 }
2686
2687 int dm_suspended_md(struct mapped_device *md)
2688 {
2689         return test_bit(DMF_SUSPENDED, &md->flags);
2690 }
2691
2692 static int dm_post_suspending_md(struct mapped_device *md)
2693 {
2694         return test_bit(DMF_POST_SUSPENDING, &md->flags);
2695 }
2696
2697 int dm_suspended_internally_md(struct mapped_device *md)
2698 {
2699         return test_bit(DMF_SUSPENDED_INTERNALLY, &md->flags);
2700 }
2701
2702 int dm_test_deferred_remove_flag(struct mapped_device *md)
2703 {
2704         return test_bit(DMF_DEFERRED_REMOVE, &md->flags);
2705 }
2706
2707 int dm_suspended(struct dm_target *ti)
2708 {
2709         return dm_suspended_md(ti->table->md);
2710 }
2711 EXPORT_SYMBOL_GPL(dm_suspended);
2712
2713 int dm_post_suspending(struct dm_target *ti)
2714 {
2715         return dm_post_suspending_md(ti->table->md);
2716 }
2717 EXPORT_SYMBOL_GPL(dm_post_suspending);
2718
2719 int dm_noflush_suspending(struct dm_target *ti)
2720 {
2721         return __noflush_suspending(ti->table->md);
2722 }
2723 EXPORT_SYMBOL_GPL(dm_noflush_suspending);
2724
2725 struct dm_md_mempools *dm_alloc_md_mempools(struct mapped_device *md, enum dm_queue_mode type,
2726                                             unsigned integrity, unsigned per_io_data_size,
2727                                             unsigned min_pool_size)
2728 {
2729         struct dm_md_mempools *pools = kzalloc_node(sizeof(*pools), GFP_KERNEL, md->numa_node_id);
2730         unsigned int pool_size = 0;
2731         unsigned int front_pad, io_front_pad;
2732         int ret;
2733
2734         if (!pools)
2735                 return NULL;
2736
2737         switch (type) {
2738         case DM_TYPE_BIO_BASED:
2739         case DM_TYPE_DAX_BIO_BASED:
2740                 pool_size = max(dm_get_reserved_bio_based_ios(), min_pool_size);
2741                 front_pad = roundup(per_io_data_size, __alignof__(struct dm_target_io)) + DM_TARGET_IO_BIO_OFFSET;
2742                 io_front_pad = roundup(per_io_data_size,  __alignof__(struct dm_io)) + DM_IO_BIO_OFFSET;
2743                 ret = bioset_init(&pools->io_bs, pool_size, io_front_pad, 0);
2744                 if (ret)
2745                         goto out;
2746                 if (integrity && bioset_integrity_create(&pools->io_bs, pool_size))
2747                         goto out;
2748                 break;
2749         case DM_TYPE_REQUEST_BASED:
2750                 pool_size = max(dm_get_reserved_rq_based_ios(), min_pool_size);
2751                 front_pad = offsetof(struct dm_rq_clone_bio_info, clone);
2752                 /* per_io_data_size is used for blk-mq pdu at queue allocation */
2753                 break;
2754         default:
2755                 BUG();
2756         }
2757
2758         ret = bioset_init(&pools->bs, pool_size, front_pad, 0);
2759         if (ret)
2760                 goto out;
2761
2762         if (integrity && bioset_integrity_create(&pools->bs, pool_size))
2763                 goto out;
2764
2765         return pools;
2766
2767 out:
2768         dm_free_md_mempools(pools);
2769
2770         return NULL;
2771 }
2772
2773 void dm_free_md_mempools(struct dm_md_mempools *pools)
2774 {
2775         if (!pools)
2776                 return;
2777
2778         bioset_exit(&pools->bs);
2779         bioset_exit(&pools->io_bs);
2780
2781         kfree(pools);
2782 }
2783
2784 struct dm_pr {
2785         u64     old_key;
2786         u64     new_key;
2787         u32     flags;
2788         bool    fail_early;
2789 };
2790
2791 static int dm_call_pr(struct block_device *bdev, iterate_devices_callout_fn fn,
2792                       void *data)
2793 {
2794         struct mapped_device *md = bdev->bd_disk->private_data;
2795         struct dm_table *table;
2796         struct dm_target *ti;
2797         int ret = -ENOTTY, srcu_idx;
2798
2799         table = dm_get_live_table(md, &srcu_idx);
2800         if (!table || !dm_table_get_size(table))
2801                 goto out;
2802
2803         /* We only support devices that have a single target */
2804         if (dm_table_get_num_targets(table) != 1)
2805                 goto out;
2806         ti = dm_table_get_target(table, 0);
2807
2808         ret = -EINVAL;
2809         if (!ti->type->iterate_devices)
2810                 goto out;
2811
2812         ret = ti->type->iterate_devices(ti, fn, data);
2813 out:
2814         dm_put_live_table(md, srcu_idx);
2815         return ret;
2816 }
2817
2818 /*
2819  * For register / unregister we need to manually call out to every path.
2820  */
2821 static int __dm_pr_register(struct dm_target *ti, struct dm_dev *dev,
2822                             sector_t start, sector_t len, void *data)
2823 {
2824         struct dm_pr *pr = data;
2825         const struct pr_ops *ops = dev->bdev->bd_disk->fops->pr_ops;
2826
2827         if (!ops || !ops->pr_register)
2828                 return -EOPNOTSUPP;
2829         return ops->pr_register(dev->bdev, pr->old_key, pr->new_key, pr->flags);
2830 }
2831
2832 static int dm_pr_register(struct block_device *bdev, u64 old_key, u64 new_key,
2833                           u32 flags)
2834 {
2835         struct dm_pr pr = {
2836                 .old_key        = old_key,
2837                 .new_key        = new_key,
2838                 .flags          = flags,
2839                 .fail_early     = true,
2840         };
2841         int ret;
2842
2843         ret = dm_call_pr(bdev, __dm_pr_register, &pr);
2844         if (ret && new_key) {
2845                 /* unregister all paths if we failed to register any path */
2846                 pr.old_key = new_key;
2847                 pr.new_key = 0;
2848                 pr.flags = 0;
2849                 pr.fail_early = false;
2850                 dm_call_pr(bdev, __dm_pr_register, &pr);
2851         }
2852
2853         return ret;
2854 }
2855
2856 static int dm_pr_reserve(struct block_device *bdev, u64 key, enum pr_type type,
2857                          u32 flags)
2858 {
2859         struct mapped_device *md = bdev->bd_disk->private_data;
2860         const struct pr_ops *ops;
2861         int r, srcu_idx;
2862
2863         r = dm_prepare_ioctl(md, &srcu_idx, &bdev);
2864         if (r < 0)
2865                 goto out;
2866
2867         ops = bdev->bd_disk->fops->pr_ops;
2868         if (ops && ops->pr_reserve)
2869                 r = ops->pr_reserve(bdev, key, type, flags);
2870         else
2871                 r = -EOPNOTSUPP;
2872 out:
2873         dm_unprepare_ioctl(md, srcu_idx);
2874         return r;
2875 }
2876
2877 static int dm_pr_release(struct block_device *bdev, u64 key, enum pr_type type)
2878 {
2879         struct mapped_device *md = bdev->bd_disk->private_data;
2880         const struct pr_ops *ops;
2881         int r, srcu_idx;
2882
2883         r = dm_prepare_ioctl(md, &srcu_idx, &bdev);
2884         if (r < 0)
2885                 goto out;
2886
2887         ops = bdev->bd_disk->fops->pr_ops;
2888         if (ops && ops->pr_release)
2889                 r = ops->pr_release(bdev, key, type);
2890         else
2891                 r = -EOPNOTSUPP;
2892 out:
2893         dm_unprepare_ioctl(md, srcu_idx);
2894         return r;
2895 }
2896
2897 static int dm_pr_preempt(struct block_device *bdev, u64 old_key, u64 new_key,
2898                          enum pr_type type, bool abort)
2899 {
2900         struct mapped_device *md = bdev->bd_disk->private_data;
2901         const struct pr_ops *ops;
2902         int r, srcu_idx;
2903
2904         r = dm_prepare_ioctl(md, &srcu_idx, &bdev);
2905         if (r < 0)
2906                 goto out;
2907
2908         ops = bdev->bd_disk->fops->pr_ops;
2909         if (ops && ops->pr_preempt)
2910                 r = ops->pr_preempt(bdev, old_key, new_key, type, abort);
2911         else
2912                 r = -EOPNOTSUPP;
2913 out:
2914         dm_unprepare_ioctl(md, srcu_idx);
2915         return r;
2916 }
2917
2918 static int dm_pr_clear(struct block_device *bdev, u64 key)
2919 {
2920         struct mapped_device *md = bdev->bd_disk->private_data;
2921         const struct pr_ops *ops;
2922         int r, srcu_idx;
2923
2924         r = dm_prepare_ioctl(md, &srcu_idx, &bdev);
2925         if (r < 0)
2926                 goto out;
2927
2928         ops = bdev->bd_disk->fops->pr_ops;
2929         if (ops && ops->pr_clear)
2930                 r = ops->pr_clear(bdev, key);
2931         else
2932                 r = -EOPNOTSUPP;
2933 out:
2934         dm_unprepare_ioctl(md, srcu_idx);
2935         return r;
2936 }
2937
2938 static const struct pr_ops dm_pr_ops = {
2939         .pr_register    = dm_pr_register,
2940         .pr_reserve     = dm_pr_reserve,
2941         .pr_release     = dm_pr_release,
2942         .pr_preempt     = dm_pr_preempt,
2943         .pr_clear       = dm_pr_clear,
2944 };
2945
2946 static const struct block_device_operations dm_blk_dops = {
2947         .submit_bio = dm_submit_bio,
2948         .open = dm_blk_open,
2949         .release = dm_blk_close,
2950         .ioctl = dm_blk_ioctl,
2951         .getgeo = dm_blk_getgeo,
2952         .report_zones = dm_blk_report_zones,
2953         .pr_ops = &dm_pr_ops,
2954         .owner = THIS_MODULE
2955 };
2956
2957 static const struct block_device_operations dm_rq_blk_dops = {
2958         .open = dm_blk_open,
2959         .release = dm_blk_close,
2960         .ioctl = dm_blk_ioctl,
2961         .getgeo = dm_blk_getgeo,
2962         .pr_ops = &dm_pr_ops,
2963         .owner = THIS_MODULE
2964 };
2965
2966 static const struct dax_operations dm_dax_ops = {
2967         .direct_access = dm_dax_direct_access,
2968         .zero_page_range = dm_dax_zero_page_range,
2969 };
2970
2971 /*
2972  * module hooks
2973  */
2974 module_init(dm_init);
2975 module_exit(dm_exit);
2976
2977 module_param(major, uint, 0);
2978 MODULE_PARM_DESC(major, "The major number of the device mapper");
2979
2980 module_param(reserved_bio_based_ios, uint, S_IRUGO | S_IWUSR);
2981 MODULE_PARM_DESC(reserved_bio_based_ios, "Reserved IOs in bio-based mempools");
2982
2983 module_param(dm_numa_node, int, S_IRUGO | S_IWUSR);
2984 MODULE_PARM_DESC(dm_numa_node, "NUMA node for DM device memory allocations");
2985
2986 module_param(swap_bios, int, S_IRUGO | S_IWUSR);
2987 MODULE_PARM_DESC(swap_bios, "Maximum allowed inflight swap IOs");
2988
2989 MODULE_DESCRIPTION(DM_NAME " driver");
2990 MODULE_AUTHOR("Joe Thornber <dm-devel@redhat.com>");
2991 MODULE_LICENSE("GPL");