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