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.h"
   9 #include "dm-uevent.h"
  10
  11 #include <linux/init.h>
  12 #include <linux/module.h>
  13 #include <linux/mutex.h>
  14 #include <linux/moduleparam.h>
  15 #include <linux/blkpg.h>
  16 #include <linux/bio.h>
  17 #include <linux/buffer_head.h>
  18 #include <linux/mempool.h>
  19 #include <linux/slab.h>
  20 #include <linux/idr.h>
  21 #include <linux/hdreg.h>
  22 #include <linux/delay.h>
  23
  24 #include <trace/events/block.h>
  25
  26 #define DM_MSG_PREFIX "core"
  27
  28 /*
  29  * Cookies are numeric values sent with CHANGE and REMOVE
  30  * uevents while resuming, removing or renaming the device.
  31  */
  32 #define DM_COOKIE_ENV_VAR_NAME "DM_COOKIE"
  33 #define DM_COOKIE_LENGTH 24
  34
  35 static const char *_name = DM_NAME;
  36
  37 static unsigned int major = 0;
  38 static unsigned int _major = 0;
  39
  40 static DEFINE_SPINLOCK(_minor_lock);
  41 /*
  42  * For bio-based dm.
  43  * One of these is allocated per bio.
  44  */
  45 struct dm_io {
  46         struct mapped_device *md;
  47         int error;
  48         atomic_t io_count;
  49         struct bio *bio;
  50         unsigned long start_time;
  51         spinlock_t endio_lock;
  52 };
  53
  54 /*
  55  * For bio-based dm.
  56  * One of these is allocated per target within a bio.  Hopefully
  57  * this will be simplified out one day.
  58  */
  59 struct dm_target_io {
  60         struct dm_io *io;
  61         struct dm_target *ti;
  62         union map_info info;
  63 };
  64
  65 /*
  66  * For request-based dm.
  67  * One of these is allocated per request.
  68  */
  69 struct dm_rq_target_io {
  70         struct mapped_device *md;
  71         struct dm_target *ti;
  72         struct request *orig, clone;
  73         int error;
  74         union map_info info;
  75 };
  76
  77 /*
  78  * For request-based dm.
  79  * One of these is allocated per bio.
  80  */
  81 struct dm_rq_clone_bio_info {
  82         struct bio *orig;
  83         struct dm_rq_target_io *tio;
  84 };
  85
  86 union map_info *dm_get_mapinfo(struct bio *bio)
  87 {
  88         if (bio && bio->bi_private)
  89                 return &((struct dm_target_io *)bio->bi_private)->info;
  90         return NULL;
  91 }
  92
  93 union map_info *dm_get_rq_mapinfo(struct request *rq)
  94 {
  95         if (rq && rq->end_io_data)
  96                 return &((struct dm_rq_target_io *)rq->end_io_data)->info;
  97         return NULL;
  98 }
  99 EXPORT_SYMBOL_GPL(dm_get_rq_mapinfo);
 100
 101 #define MINOR_ALLOCED ((void *)-1)
 102
 103 /*
 104  * Bits for the md->flags field.
 105  */
 106 #define DMF_BLOCK_IO_FOR_SUSPEND 0
 107 #define DMF_SUSPENDED 1
 108 #define DMF_FROZEN 2
 109 #define DMF_FREEING 3
 110 #define DMF_DELETING 4
 111 #define DMF_NOFLUSH_SUSPENDING 5
 112
 113 /*
 114  * Work processed by per-device workqueue.
 115  */
 116 struct mapped_device {
 117         struct rw_semaphore io_lock;
 118         struct mutex suspend_lock;
 119         rwlock_t map_lock;
 120         atomic_t holders;
 121         atomic_t open_count;
 122
 123         unsigned long flags;
 124
 125         struct request_queue *queue;
 126         unsigned type;
 127         /* Protect queue and type against concurrent access. */
 128         struct mutex type_lock;
 129
 130         struct gendisk *disk;
 131         char name[16];
 132
 133         void *interface_ptr;
 134
 135         /*
 136          * A list of ios that arrived while we were suspended.
 137          */
 138         atomic_t pending[2];
 139         wait_queue_head_t wait;
 140         struct work_struct work;
 141         struct bio_list deferred;
 142         spinlock_t deferred_lock;
 143
 144         /*
 145          * Processing queue (flush)
 146          */
 147         struct workqueue_struct *wq;
 148
 149         /*
 150          * The current mapping.
 151          */
 152         struct dm_table *map;
 153
 154         /*
 155          * io objects are allocated from here.
 156          */
 157         mempool_t *io_pool;
 158         mempool_t *tio_pool;
 159
 160         struct bio_set *bs;
 161
 162         /*
 163          * Event handling.
 164          */
 165         atomic_t event_nr;
 166         wait_queue_head_t eventq;
 167         atomic_t uevent_seq;
 168         struct list_head uevent_list;
 169         spinlock_t uevent_lock; /* Protect access to uevent_list */
 170
 171         /*
 172          * freeze/thaw support require holding onto a super block
 173          */
 174         struct super_block *frozen_sb;
 175         struct block_device *bdev;
 176
 177         /* forced geometry settings */
 178         struct hd_geometry geometry;
 179
 180         /* For saving the address of __make_request for request based dm */
 181         make_request_fn *saved_make_request_fn;
 182
 183         /* sysfs handle */
 184         struct kobject kobj;
 185
 186         /* zero-length flush that will be cloned and submitted to targets */
 187         struct bio flush_bio;
 188 };
 189
 190 /*
 191  * For mempools pre-allocation at the table loading time.
 192  */
 193 struct dm_md_mempools {
 194         mempool_t *io_pool;
 195         mempool_t *tio_pool;
 196         struct bio_set *bs;
 197 };
 198
 199 #define MIN_IOS 256
 200 static struct kmem_cache *_io_cache;
 201 static struct kmem_cache *_tio_cache;
 202 static struct kmem_cache *_rq_tio_cache;
 203 static struct kmem_cache *_rq_bio_info_cache;
 204
 205 static int __init local_init(void)
 206 {
 207         int r = -ENOMEM;
 208
 209         /* allocate a slab for the dm_ios */
 210         _io_cache = KMEM_CACHE(dm_io, 0);
 211         if (!_io_cache)
 212                 return r;
 213
 214         /* allocate a slab for the target ios */
 215         _tio_cache = KMEM_CACHE(dm_target_io, 0);
 216         if (!_tio_cache)
 217                 goto out_free_io_cache;
 218
 219         _rq_tio_cache = KMEM_CACHE(dm_rq_target_io, 0);
 220         if (!_rq_tio_cache)
 221                 goto out_free_tio_cache;
 222
 223         _rq_bio_info_cache = KMEM_CACHE(dm_rq_clone_bio_info, 0);
 224         if (!_rq_bio_info_cache)
 225                 goto out_free_rq_tio_cache;
 226
 227         r = dm_uevent_init();
 228         if (r)
 229                 goto out_free_rq_bio_info_cache;
 230
 231         _major = major;
 232         r = register_blkdev(_major, _name);
 233         if (r < 0)
 234                 goto out_uevent_exit;
 235
 236         if (!_major)
 237                 _major = r;
 238
 239         return 0;
 240
 241 out_uevent_exit:
 242         dm_uevent_exit();
 243 out_free_rq_bio_info_cache:
 244         kmem_cache_destroy(_rq_bio_info_cache);
 245 out_free_rq_tio_cache:
 246         kmem_cache_destroy(_rq_tio_cache);
 247 out_free_tio_cache:
 248         kmem_cache_destroy(_tio_cache);
 249 out_free_io_cache:
 250         kmem_cache_destroy(_io_cache);
 251
 252         return r;
 253 }
 254
 255 static void local_exit(void)
 256 {
 257         kmem_cache_destroy(_rq_bio_info_cache);
 258         kmem_cache_destroy(_rq_tio_cache);
 259         kmem_cache_destroy(_tio_cache);
 260         kmem_cache_destroy(_io_cache);
 261         unregister_blkdev(_major, _name);
 262         dm_uevent_exit();
 263
 264         _major = 0;
 265
 266         DMINFO("cleaned up");
 267 }
 268
 269 static int (*_inits[])(void) __initdata = {
 270         local_init,
 271         dm_target_init,
 272         dm_linear_init,
 273         dm_stripe_init,
 274         dm_io_init,
 275         dm_kcopyd_init,
 276         dm_interface_init,
 277 };
 278
 279 static void (*_exits[])(void) = {
 280         local_exit,
 281         dm_target_exit,
 282         dm_linear_exit,
 283         dm_stripe_exit,
 284         dm_io_exit,
 285         dm_kcopyd_exit,
 286         dm_interface_exit,
 287 };
 288
 289 static int __init dm_init(void)
 290 {
 291         const int count = ARRAY_SIZE(_inits);
 292
 293         int r, i;
 294
 295         for (i = 0; i < count; i++) {
 296                 r = _inits[i]();
 297                 if (r)
 298                         goto bad;
 299         }
 300
 301         return 0;
 302
 303       bad:
 304         while (i--)
 305                 _exits[i]();
 306
 307         return r;
 308 }
 309
 310 static void __exit dm_exit(void)
 311 {
 312         int i = ARRAY_SIZE(_exits);
 313
 314         while (i--)
 315                 _exits[i]();
 316 }
 317
 318 /*
 319  * Block device functions
 320  */
 321 int dm_deleting_md(struct mapped_device *md)
 322 {
 323         return test_bit(DMF_DELETING, &md->flags);
 324 }
 325
 326 static int dm_blk_open(struct block_device *bdev, fmode_t mode)
 327 {
 328         struct mapped_device *md;
 329
 330         spin_lock(&_minor_lock);
 331
 332         md = bdev->bd_disk->private_data;
 333         if (!md)
 334                 goto out;
 335
 336         if (test_bit(DMF_FREEING, &md->flags) ||
 337             dm_deleting_md(md)) {
 338                 md = NULL;
 339                 goto out;
 340         }
 341
 342         dm_get(md);
 343         atomic_inc(&md->open_count);
 344
 345 out:
 346         spin_unlock(&_minor_lock);
 347
 348         return md ? 0 : -ENXIO;
 349 }
 350
 351 static int dm_blk_close(struct gendisk *disk, fmode_t mode)
 352 {
 353         struct mapped_device *md = disk->private_data;
 354
 355         spin_lock(&_minor_lock);
 356
 357         atomic_dec(&md->open_count);
 358         dm_put(md);
 359
 360         spin_unlock(&_minor_lock);
 361
 362         return 0;
 363 }
 364
 365 int dm_open_count(struct mapped_device *md)
 366 {
 367         return atomic_read(&md->open_count);
 368 }
 369
 370 /*
 371  * Guarantees nothing is using the device before it's deleted.
 372  */
 373 int dm_lock_for_deletion(struct mapped_device *md)
 374 {
 375         int r = 0;
 376
 377         spin_lock(&_minor_lock);
 378
 379         if (dm_open_count(md))
 380                 r = -EBUSY;
 381         else
 382                 set_bit(DMF_DELETING, &md->flags);
 383
 384         spin_unlock(&_minor_lock);
 385
 386         return r;
 387 }
 388
 389 static int dm_blk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
 390 {
 391         struct mapped_device *md = bdev->bd_disk->private_data;
 392
 393         return dm_get_geometry(md, geo);
 394 }
 395
 396 static int dm_blk_ioctl(struct block_device *bdev, fmode_t mode,
 397                         unsigned int cmd, unsigned long arg)
 398 {
 399         struct mapped_device *md = bdev->bd_disk->private_data;
 400         struct dm_table *map = dm_get_live_table(md);
 401         struct dm_target *tgt;
 402         int r = -ENOTTY;
 403
 404         if (!map || !dm_table_get_size(map))
 405                 goto out;
 406
 407         /* We only support devices that have a single target */
 408         if (dm_table_get_num_targets(map) != 1)
 409                 goto out;
 410
 411         tgt = dm_table_get_target(map, 0);
 412
 413         if (dm_suspended_md(md)) {
 414                 r = -EAGAIN;
 415                 goto out;
 416         }
 417
 418         if (tgt->type->ioctl)
 419                 r = tgt->type->ioctl(tgt, cmd, arg);
 420
 421 out:
 422         dm_table_put(map);
 423
 424         return r;
 425 }
 426
 427 static struct dm_io *alloc_io(struct mapped_device *md)
 428 {
 429         return mempool_alloc(md->io_pool, GFP_NOIO);
 430 }
 431
 432 static void free_io(struct mapped_device *md, struct dm_io *io)
 433 {
 434         mempool_free(io, md->io_pool);
 435 }
 436
 437 static void free_tio(struct mapped_device *md, struct dm_target_io *tio)
 438 {
 439         mempool_free(tio, md->tio_pool);
 440 }
 441
 442 static struct dm_rq_target_io *alloc_rq_tio(struct mapped_device *md,
 443                                             gfp_t gfp_mask)
 444 {
 445         return mempool_alloc(md->tio_pool, gfp_mask);
 446 }
 447
 448 static void free_rq_tio(struct dm_rq_target_io *tio)
 449 {
 450         mempool_free(tio, tio->md->tio_pool);
 451 }
 452
 453 static struct dm_rq_clone_bio_info *alloc_bio_info(struct mapped_device *md)
 454 {
 455         return mempool_alloc(md->io_pool, GFP_ATOMIC);
 456 }
 457
 458 static void free_bio_info(struct dm_rq_clone_bio_info *info)
 459 {
 460         mempool_free(info, info->tio->md->io_pool);
 461 }
 462
 463 static int md_in_flight(struct mapped_device *md)
 464 {
 465         return atomic_read(&md->pending[READ]) +
 466                atomic_read(&md->pending[WRITE]);
 467 }
 468
 469 static void start_io_acct(struct dm_io *io)
 470 {
 471         struct mapped_device *md = io->md;
 472         int cpu;
 473         int rw = bio_data_dir(io->bio);
 474
 475         io->start_time = jiffies;
 476
 477         cpu = part_stat_lock();
 478         part_round_stats(cpu, &dm_disk(md)->part0);
 479         part_stat_unlock();
 480         dm_disk(md)->part0.in_flight[rw] = atomic_inc_return(&md->pending[rw]);
 481 }
 482
 483 static void end_io_acct(struct dm_io *io)
 484 {
 485         struct mapped_device *md = io->md;
 486         struct bio *bio = io->bio;
 487         unsigned long duration = jiffies - io->start_time;
 488         int pending, cpu;
 489         int rw = bio_data_dir(bio);
 490
 491         cpu = part_stat_lock();
 492         part_round_stats(cpu, &dm_disk(md)->part0);
 493         part_stat_add(cpu, &dm_disk(md)->part0, ticks[rw], duration);
 494         part_stat_unlock();
 495
 496         /*
 497          * After this is decremented the bio must not be touched if it is
 498          * a flush.
 499          */
 500         dm_disk(md)->part0.in_flight[rw] = pending =
 501                 atomic_dec_return(&md->pending[rw]);
 502         pending += atomic_read(&md->pending[rw^0x1]);
 503
 504         /* nudge anyone waiting on suspend queue */
 505         if (!pending)
 506                 wake_up(&md->wait);
 507 }
 508
 509 /*
 510  * Add the bio to the list of deferred io.
 511  */
 512 static void queue_io(struct mapped_device *md, struct bio *bio)
 513 {
 514         unsigned long flags;
 515
 516         spin_lock_irqsave(&md->deferred_lock, flags);
 517         bio_list_add(&md->deferred, bio);
 518         spin_unlock_irqrestore(&md->deferred_lock, flags);
 519         queue_work(md->wq, &md->work);
 520 }
 521
 522 /*
 523  * Everyone (including functions in this file), should use this
 524  * function to access the md->map field, and make sure they call
 525  * dm_table_put() when finished.
 526  */
 527 struct dm_table *dm_get_live_table(struct mapped_device *md)
 528 {
 529         struct dm_table *t;
 530         unsigned long flags;
 531
 532         read_lock_irqsave(&md->map_lock, flags);
 533         t = md->map;
 534         if (t)
 535                 dm_table_get(t);
 536         read_unlock_irqrestore(&md->map_lock, flags);
 537
 538         return t;
 539 }
 540
 541 /*
 542  * Get the geometry associated with a dm device
 543  */
 544 int dm_get_geometry(struct mapped_device *md, struct hd_geometry *geo)
 545 {
 546         *geo = md->geometry;
 547
 548         return 0;
 549 }
 550
 551 /*
 552  * Set the geometry of a device.
 553  */
 554 int dm_set_geometry(struct mapped_device *md, struct hd_geometry *geo)
 555 {
 556         sector_t sz = (sector_t)geo->cylinders * geo->heads * geo->sectors;
 557
 558         if (geo->start > sz) {
 559                 DMWARN("Start sector is beyond the geometry limits.");
 560                 return -EINVAL;
 561         }
 562
 563         md->geometry = *geo;
 564
 565         return 0;
 566 }
 567
 568 /*-----------------------------------------------------------------
 569  * CRUD START:
 570  *   A more elegant soln is in the works that uses the queue
 571  *   merge fn, unfortunately there are a couple of changes to
 572  *   the block layer that I want to make for this.  So in the
 573  *   interests of getting something for people to use I give
 574  *   you this clearly demarcated crap.
 575  *---------------------------------------------------------------*/
 576
 577 static int __noflush_suspending(struct mapped_device *md)
 578 {
 579         return test_bit(DMF_NOFLUSH_SUSPENDING, &md->flags);
 580 }
 581
 582 /*
 583  * Decrements the number of outstanding ios that a bio has been
 584  * cloned into, completing the original io if necc.
 585  */
 586 static void dec_pending(struct dm_io *io, int error)
 587 {
 588         unsigned long flags;
 589         int io_error;
 590         struct bio *bio;
 591         struct mapped_device *md = io->md;
 592
 593         /* Push-back supersedes any I/O errors */
 594         if (unlikely(error)) {
 595                 spin_lock_irqsave(&io->endio_lock, flags);
 596                 if (!(io->error > 0 && __noflush_suspending(md)))
 597                         io->error = error;
 598                 spin_unlock_irqrestore(&io->endio_lock, flags);
 599         }
 600
 601         if (atomic_dec_and_test(&io->io_count)) {
 602                 if (io->error == DM_ENDIO_REQUEUE) {
 603                         /*
 604                          * Target requested pushing back the I/O.
 605                          */
 606                         spin_lock_irqsave(&md->deferred_lock, flags);
 607                         if (__noflush_suspending(md))
 608                                 bio_list_add_head(&md->deferred, io->bio);
 609                         else
 610                                 /* noflush suspend was interrupted. */
 611                                 io->error = -EIO;
 612                         spin_unlock_irqrestore(&md->deferred_lock, flags);
 613                 }
 614
 615                 io_error = io->error;
 616                 bio = io->bio;
 617                 end_io_acct(io);
 618                 free_io(md, io);
 619
 620                 if (io_error == DM_ENDIO_REQUEUE)
 621                         return;
 622
 623                 if ((bio->bi_rw & REQ_FLUSH) && bio->bi_size) {
 624                         /*
 625                          * Preflush done for flush with data, reissue
 626                          * without REQ_FLUSH.
 627                          */
 628                         bio->bi_rw &= ~REQ_FLUSH;
 629                         queue_io(md, bio);
 630                 } else {
 631                         /* done with normal IO or empty flush */
 632                         trace_block_bio_complete(md->queue, bio, io_error);
 633                         bio_endio(bio, io_error);
 634                 }
 635         }
 636 }
 637
 638 static void clone_endio(struct bio *bio, int error)
 639 {
 640         int r = 0;
 641         struct dm_target_io *tio = bio->bi_private;
 642         struct dm_io *io = tio->io;
 643         struct mapped_device *md = tio->io->md;
 644         dm_endio_fn endio = tio->ti->type->end_io;
 645
 646         if (!bio_flagged(bio, BIO_UPTODATE) && !error)
 647                 error = -EIO;
 648
 649         if (endio) {
 650                 r = endio(tio->ti, bio, error, &tio->info);
 651                 if (r < 0 || r == DM_ENDIO_REQUEUE)
 652                         /*
 653                          * error and requeue request are handled
 654                          * in dec_pending().
 655                          */
 656                         error = r;
 657                 else if (r == DM_ENDIO_INCOMPLETE)
 658                         /* The target will handle the io */
 659                         return;
 660                 else if (r) {
 661                         DMWARN("unimplemented target endio return value: %d", r);
 662                         BUG();
 663                 }
 664         }
 665
 666         /*
 667          * Store md for cleanup instead of tio which is about to get freed.
 668          */
 669         bio->bi_private = md->bs;
 670
 671         free_tio(md, tio);
 672         bio_put(bio);
 673         dec_pending(io, error);
 674 }
 675
 676 /*
 677  * Partial completion handling for request-based dm
 678  */
 679 static void end_clone_bio(struct bio *clone, int error)
 680 {
 681         struct dm_rq_clone_bio_info *info = clone->bi_private;
 682         struct dm_rq_target_io *tio = info->tio;
 683         struct bio *bio = info->orig;
 684         unsigned int nr_bytes = info->orig->bi_size;
 685
 686         bio_put(clone);
 687
 688         if (tio->error)
 689                 /*
 690                  * An error has already been detected on the request.
 691                  * Once error occurred, just let clone->end_io() handle
 692                  * the remainder.
 693                  */
 694                 return;
 695         else if (error) {
 696                 /*
 697                  * Don't notice the error to the upper layer yet.
 698                  * The error handling decision is made by the target driver,
 699                  * when the request is completed.
 700                  */
 701                 tio->error = error;
 702                 return;
 703         }
 704
 705         /*
 706          * I/O for the bio successfully completed.
 707          * Notice the data completion to the upper layer.
 708          */
 709
 710         /*
 711          * bios are processed from the head of the list.
 712          * So the completing bio should always be rq->bio.
 713          * If it's not, something wrong is happening.
 714          */
 715         if (tio->orig->bio != bio)
 716                 DMERR("bio completion is going in the middle of the request");
 717
 718         /*
 719          * Update the original request.
 720          * Do not use blk_end_request() here, because it may complete
 721          * the original request before the clone, and break the ordering.
 722          */
 723         blk_update_request(tio->orig, 0, nr_bytes);
 724 }
 725
 726 /*
 727  * Don't touch any member of the md after calling this function because
 728  * the md may be freed in dm_put() at the end of this function.
 729  * Or do dm_get() before calling this function and dm_put() later.
 730  */
 731 static void rq_completed(struct mapped_device *md, int rw, int run_queue)
 732 {
 733         atomic_dec(&md->pending[rw]);
 734
 735         /* nudge anyone waiting on suspend queue */
 736         if (!md_in_flight(md))
 737                 wake_up(&md->wait);
 738
 739         if (run_queue)
 740                 blk_run_queue(md->queue);
 741
 742         /*
 743          * dm_put() must be at the end of this function. See the comment above
 744          */
 745         dm_put(md);
 746 }
 747
 748 static void free_rq_clone(struct request *clone)
 749 {
 750         struct dm_rq_target_io *tio = clone->end_io_data;
 751
 752         blk_rq_unprep_clone(clone);
 753         free_rq_tio(tio);
 754 }
 755
 756 /*
 757  * Complete the clone and the original request.
 758  * Must be called without queue lock.
 759  */
 760 static void dm_end_request(struct request *clone, int error)
 761 {
 762         int rw = rq_data_dir(clone);
 763         struct dm_rq_target_io *tio = clone->end_io_data;
 764         struct mapped_device *md = tio->md;
 765         struct request *rq = tio->orig;
 766
 767         if (rq->cmd_type == REQ_TYPE_BLOCK_PC) {
 768                 rq->errors = clone->errors;
 769                 rq->resid_len = clone->resid_len;
 770
 771                 if (rq->sense)
 772                         /*
 773                          * We are using the sense buffer of the original
 774                          * request.
 775                          * So setting the length of the sense data is enough.
 776                          */
 777                         rq->sense_len = clone->sense_len;
 778         }
 779
 780         free_rq_clone(clone);
 781         blk_end_request_all(rq, error);
 782         rq_completed(md, rw, true);
 783 }
 784
 785 static void dm_unprep_request(struct request *rq)
 786 {
 787         struct request *clone = rq->special;
 788
 789         rq->special = NULL;
 790         rq->cmd_flags &= ~REQ_DONTPREP;
 791
 792         free_rq_clone(clone);
 793 }
 794
 795 /*
 796  * Requeue the original request of a clone.
 797  */
 798 void dm_requeue_unmapped_request(struct request *clone)
 799 {
 800         int rw = rq_data_dir(clone);
 801         struct dm_rq_target_io *tio = clone->end_io_data;
 802         struct mapped_device *md = tio->md;
 803         struct request *rq = tio->orig;
 804         struct request_queue *q = rq->q;
 805         unsigned long flags;
 806
 807         dm_unprep_request(rq);
 808
 809         spin_lock_irqsave(q->queue_lock, flags);
 810         blk_requeue_request(q, rq);
 811         spin_unlock_irqrestore(q->queue_lock, flags);
 812
 813         rq_completed(md, rw, 0);
 814 }
 815 EXPORT_SYMBOL_GPL(dm_requeue_unmapped_request);
 816
 817 static void __stop_queue(struct request_queue *q)
 818 {
 819         blk_stop_queue(q);
 820 }
 821
 822 static void stop_queue(struct request_queue *q)
 823 {
 824         unsigned long flags;
 825
 826         spin_lock_irqsave(q->queue_lock, flags);
 827         __stop_queue(q);
 828         spin_unlock_irqrestore(q->queue_lock, flags);
 829 }
 830
 831 static void __start_queue(struct request_queue *q)
 832 {
 833         if (blk_queue_stopped(q))
 834                 blk_start_queue(q);
 835 }
 836
 837 static void start_queue(struct request_queue *q)
 838 {
 839         unsigned long flags;
 840
 841         spin_lock_irqsave(q->queue_lock, flags);
 842         __start_queue(q);
 843         spin_unlock_irqrestore(q->queue_lock, flags);
 844 }
 845
 846 static void dm_done(struct request *clone, int error, bool mapped)
 847 {
 848         int r = error;
 849         struct dm_rq_target_io *tio = clone->end_io_data;
 850         dm_request_endio_fn rq_end_io = tio->ti->type->rq_end_io;
 851
 852         if (mapped && rq_end_io)
 853                 r = rq_end_io(tio->ti, clone, error, &tio->info);
 854
 855         if (r <= 0)
 856                 /* The target wants to complete the I/O */
 857                 dm_end_request(clone, r);
 858         else if (r == DM_ENDIO_INCOMPLETE)
 859                 /* The target will handle the I/O */
 860                 return;
 861         else if (r == DM_ENDIO_REQUEUE)
 862                 /* The target wants to requeue the I/O */
 863                 dm_requeue_unmapped_request(clone);
 864         else {
 865                 DMWARN("unimplemented target endio return value: %d", r);
 866                 BUG();
 867         }
 868 }
 869
 870 /*
 871  * Request completion handler for request-based dm
 872  */
 873 static void dm_softirq_done(struct request *rq)
 874 {
 875         bool mapped = true;
 876         struct request *clone = rq->completion_data;
 877         struct dm_rq_target_io *tio = clone->end_io_data;
 878
 879         if (rq->cmd_flags & REQ_FAILED)
 880                 mapped = false;
 881
 882         dm_done(clone, tio->error, mapped);
 883 }
 884
 885 /*
 886  * Complete the clone and the original request with the error status
 887  * through softirq context.
 888  */
 889 static void dm_complete_request(struct request *clone, int error)
 890 {
 891         struct dm_rq_target_io *tio = clone->end_io_data;
 892         struct request *rq = tio->orig;
 893
 894         tio->error = error;
 895         rq->completion_data = clone;
 896         blk_complete_request(rq);
 897 }
 898
 899 /*
 900  * Complete the not-mapped clone and the original request with the error status
 901  * through softirq context.
 902  * Target's rq_end_io() function isn't called.
 903  * This may be used when the target's map_rq() function fails.
 904  */
 905 void dm_kill_unmapped_request(struct request *clone, int error)
 906 {
 907         struct dm_rq_target_io *tio = clone->end_io_data;
 908         struct request *rq = tio->orig;
 909
 910         rq->cmd_flags |= REQ_FAILED;
 911         dm_complete_request(clone, error);
 912 }
 913 EXPORT_SYMBOL_GPL(dm_kill_unmapped_request);
 914
 915 /*
 916  * Called with the queue lock held
 917  */
 918 static void end_clone_request(struct request *clone, int error)
 919 {
 920         /*
 921          * For just cleaning up the information of the queue in which
 922          * the clone was dispatched.
 923          * The clone is *NOT* freed actually here because it is alloced from
 924          * dm own mempool and REQ_ALLOCED isn't set in clone->cmd_flags.
 925          */
 926         __blk_put_request(clone->q, clone);
 927
 928         /*
 929          * Actual request completion is done in a softirq context which doesn't
 930          * hold the queue lock.  Otherwise, deadlock could occur because:
 931          *     - another request may be submitted by the upper level driver
 932          *       of the stacking during the completion
 933          *     - the submission which requires queue lock may be done
 934          *       against this queue
 935          */
 936         dm_complete_request(clone, error);
 937 }
 938
 939 /*
 940  * Return maximum size of I/O possible at the supplied sector up to the current
 941  * target boundary.
 942  */
 943 static sector_t max_io_len_target_boundary(sector_t sector, struct dm_target *ti)
 944 {
 945         sector_t target_offset = dm_target_offset(ti, sector);
 946
 947         return ti->len - target_offset;
 948 }
 949
 950 static sector_t max_io_len(sector_t sector, struct dm_target *ti)
 951 {
 952         sector_t len = max_io_len_target_boundary(sector, ti);
 953
 954         /*
 955          * Does the target need to split even further ?
 956          */
 957         if (ti->split_io) {
 958                 sector_t boundary;
 959                 sector_t offset = dm_target_offset(ti, sector);
 960                 boundary = ((offset + ti->split_io) & ~(ti->split_io - 1))
 961                            - offset;
 962                 if (len > boundary)
 963                         len = boundary;
 964         }
 965
 966         return len;
 967 }
 968
 969 static void __map_bio(struct dm_target *ti, struct bio *clone,
 970                       struct dm_target_io *tio)
 971 {
 972         int r;
 973         sector_t sector;
 974         struct mapped_device *md;
 975
 976         clone->bi_end_io = clone_endio;
 977         clone->bi_private = tio;
 978
 979         /*
 980          * Map the clone.  If r == 0 we don't need to do
 981          * anything, the target has assumed ownership of
 982          * this io.
 983          */
 984         atomic_inc(&tio->io->io_count);
 985         sector = clone->bi_sector;
 986         r = ti->type->map(ti, clone, &tio->info);
 987         if (r == DM_MAPIO_REMAPPED) {
 988                 /* the bio has been remapped so dispatch it */
 989
 990                 trace_block_bio_remap(bdev_get_queue(clone->bi_bdev), clone,
 991                                       tio->io->bio->bi_bdev->bd_dev, sector);
 992
 993                 generic_make_request(clone);
 994         } else if (r < 0 || r == DM_MAPIO_REQUEUE) {
 995                 /* error the io and bail out, or requeue it if needed */
 996                 md = tio->io->md;
 997                 dec_pending(tio->io, r);
 998                 /*
 999                  * Store bio_set for cleanup.
1000                  */
1001                 clone->bi_private = md->bs;
1002                 bio_put(clone);
1003                 free_tio(md, tio);
1004         } else if (r) {
1005                 DMWARN("unimplemented target map return value: %d", r);
1006                 BUG();
1007         }
1008 }
1009
1010 struct clone_info {
1011         struct mapped_device *md;
1012         struct dm_table *map;
1013         struct bio *bio;
1014         struct dm_io *io;
1015         sector_t sector;
1016         sector_t sector_count;
1017         unsigned short idx;
1018 };
1019
1020 static void dm_bio_destructor(struct bio *bio)
1021 {
1022         struct bio_set *bs = bio->bi_private;
1023
1024         bio_free(bio, bs);
1025 }
1026
1027 /*
1028  * Creates a little bio that just does part of a bvec.
1029  */
1030 static struct bio *split_bvec(struct bio *bio, sector_t sector,
1031                               unsigned short idx, unsigned int offset,
1032                               unsigned int len, struct bio_set *bs)
1033 {
1034         struct bio *clone;
1035         struct bio_vec *bv = bio->bi_io_vec + idx;
1036
1037         clone = bio_alloc_bioset(GFP_NOIO, 1, bs);
1038         clone->bi_destructor = dm_bio_destructor;
1039         *clone->bi_io_vec = *bv;
1040
1041         clone->bi_sector = sector;
1042         clone->bi_bdev = bio->bi_bdev;
1043         clone->bi_rw = bio->bi_rw;
1044         clone->bi_vcnt = 1;
1045         clone->bi_size = to_bytes(len);
1046         clone->bi_io_vec->bv_offset = offset;
1047         clone->bi_io_vec->bv_len = clone->bi_size;
1048         clone->bi_flags |= 1 << BIO_CLONED;
1049
1050         if (bio_integrity(bio)) {
1051                 bio_integrity_clone(clone, bio, GFP_NOIO, bs);
1052                 bio_integrity_trim(clone,
1053                                    bio_sector_offset(bio, idx, offset), len);
1054         }
1055
1056         return clone;
1057 }
1058
1059 /*
1060  * Creates a bio that consists of range of complete bvecs.
1061  */
1062 static struct bio *clone_bio(struct bio *bio, sector_t sector,
1063                              unsigned short idx, unsigned short bv_count,
1064                              unsigned int len, struct bio_set *bs)
1065 {
1066         struct bio *clone;
1067
1068         clone = bio_alloc_bioset(GFP_NOIO, bio->bi_max_vecs, bs);
1069         __bio_clone(clone, bio);
1070         clone->bi_destructor = dm_bio_destructor;
1071         clone->bi_sector = sector;
1072         clone->bi_idx = idx;
1073         clone->bi_vcnt = idx + bv_count;
1074         clone->bi_size = to_bytes(len);
1075         clone->bi_flags &= ~(1 << BIO_SEG_VALID);
1076
1077         if (bio_integrity(bio)) {
1078                 bio_integrity_clone(clone, bio, GFP_NOIO, bs);
1079
1080                 if (idx != bio->bi_idx || clone->bi_size < bio->bi_size)
1081                         bio_integrity_trim(clone,
1082                                            bio_sector_offset(bio, idx, 0), len);
1083         }
1084
1085         return clone;
1086 }
1087
1088 static struct dm_target_io *alloc_tio(struct clone_info *ci,
1089                                       struct dm_target *ti)
1090 {
1091         struct dm_target_io *tio = mempool_alloc(ci->md->tio_pool, GFP_NOIO);
1092
1093         tio->io = ci->io;
1094         tio->ti = ti;
1095         memset(&tio->info, 0, sizeof(tio->info));
1096
1097         return tio;
1098 }
1099
1100 static void __issue_target_request(struct clone_info *ci, struct dm_target *ti,
1101                                    unsigned request_nr, sector_t len)
1102 {
1103         struct dm_target_io *tio = alloc_tio(ci, ti);
1104         struct bio *clone;
1105
1106         tio->info.target_request_nr = request_nr;
1107
1108         /*
1109          * Discard requests require the bio's inline iovecs be initialized.
1110          * ci->bio->bi_max_vecs is BIO_INLINE_VECS anyway, for both flush
1111          * and discard, so no need for concern about wasted bvec allocations.
1112          */
1113         clone = bio_alloc_bioset(GFP_NOIO, ci->bio->bi_max_vecs, ci->md->bs);
1114         __bio_clone(clone, ci->bio);
1115         clone->bi_destructor = dm_bio_destructor;
1116         if (len) {
1117                 clone->bi_sector = ci->sector;
1118                 clone->bi_size = to_bytes(len);
1119         }
1120
1121         __map_bio(ti, clone, tio);
1122 }
1123
1124 static void __issue_target_requests(struct clone_info *ci, struct dm_target *ti,
1125                                     unsigned num_requests, sector_t len)
1126 {
1127         unsigned request_nr;
1128
1129         for (request_nr = 0; request_nr < num_requests; request_nr++)
1130                 __issue_target_request(ci, ti, request_nr, len);
1131 }
1132
1133 static int __clone_and_map_empty_flush(struct clone_info *ci)
1134 {
1135         unsigned target_nr = 0;
1136         struct dm_target *ti;
1137
1138         BUG_ON(bio_has_data(ci->bio));
1139         while ((ti = dm_table_get_target(ci->map, target_nr++)))
1140                 __issue_target_requests(ci, ti, ti->num_flush_requests, 0);
1141
1142         return 0;
1143 }
1144
1145 /*
1146  * Perform all io with a single clone.
1147  */
1148 static void __clone_and_map_simple(struct clone_info *ci, struct dm_target *ti)
1149 {
1150         struct bio *clone, *bio = ci->bio;
1151         struct dm_target_io *tio;
1152
1153         tio = alloc_tio(ci, ti);
1154         clone = clone_bio(bio, ci->sector, ci->idx,
1155                           bio->bi_vcnt - ci->idx, ci->sector_count,
1156                           ci->md->bs);
1157         __map_bio(ti, clone, tio);
1158         ci->sector_count = 0;
1159 }
1160
1161 static int __clone_and_map_discard(struct clone_info *ci)
1162 {
1163         struct dm_target *ti;
1164         sector_t len;
1165
1166         do {
1167                 ti = dm_table_find_target(ci->map, ci->sector);
1168                 if (!dm_target_is_valid(ti))
1169                         return -EIO;
1170
1171                 /*
1172                  * Even though the device advertised discard support,
1173                  * reconfiguration might have changed that since the
1174                  * check was performed.
1175                  */
1176                 if (!ti->num_discard_requests)
1177                         return -EOPNOTSUPP;
1178
1179                 len = min(ci->sector_count, max_io_len_target_boundary(ci->sector, ti));
1180
1181                 __issue_target_requests(ci, ti, ti->num_discard_requests, len);
1182
1183                 ci->sector += len;
1184         } while (ci->sector_count -= len);
1185
1186         return 0;
1187 }
1188
1189 static int __clone_and_map(struct clone_info *ci)
1190 {
1191         struct bio *clone, *bio = ci->bio;
1192         struct dm_target *ti;
1193         sector_t len = 0, max;
1194         struct dm_target_io *tio;
1195
1196         if (unlikely(bio->bi_rw & REQ_DISCARD))
1197                 return __clone_and_map_discard(ci);
1198
1199         ti = dm_table_find_target(ci->map, ci->sector);
1200         if (!dm_target_is_valid(ti))
1201                 return -EIO;
1202
1203         max = max_io_len(ci->sector, ti);
1204
1205         if (ci->sector_count <= max) {
1206                 /*
1207                  * Optimise for the simple case where we can do all of
1208                  * the remaining io with a single clone.
1209                  */
1210                 __clone_and_map_simple(ci, ti);
1211
1212         } else if (to_sector(bio->bi_io_vec[ci->idx].bv_len) <= max) {
1213                 /*
1214                  * There are some bvecs that don't span targets.
1215                  * Do as many of these as possible.
1216                  */
1217                 int i;
1218                 sector_t remaining = max;
1219                 sector_t bv_len;
1220
1221                 for (i = ci->idx; remaining && (i < bio->bi_vcnt); i++) {
1222                         bv_len = to_sector(bio->bi_io_vec[i].bv_len);
1223
1224                         if (bv_len > remaining)
1225                                 break;
1226
1227                         remaining -= bv_len;
1228                         len += bv_len;
1229                 }
1230
1231                 tio = alloc_tio(ci, ti);
1232                 clone = clone_bio(bio, ci->sector, ci->idx, i - ci->idx, len,
1233                                   ci->md->bs);
1234                 __map_bio(ti, clone, tio);
1235
1236                 ci->sector += len;
1237                 ci->sector_count -= len;
1238                 ci->idx = i;
1239
1240         } else {
1241                 /*
1242                  * Handle a bvec that must be split between two or more targets.
1243                  */
1244                 struct bio_vec *bv = bio->bi_io_vec + ci->idx;
1245                 sector_t remaining = to_sector(bv->bv_len);
1246                 unsigned int offset = 0;
1247
1248                 do {
1249                         if (offset) {
1250                                 ti = dm_table_find_target(ci->map, ci->sector);
1251                                 if (!dm_target_is_valid(ti))
1252                                         return -EIO;
1253
1254                                 max = max_io_len(ci->sector, ti);
1255                         }
1256
1257                         len = min(remaining, max);
1258
1259                         tio = alloc_tio(ci, ti);
1260                         clone = split_bvec(bio, ci->sector, ci->idx,
1261                                            bv->bv_offset + offset, len,
1262                                            ci->md->bs);
1263
1264                         __map_bio(ti, clone, tio);
1265
1266                         ci->sector += len;
1267                         ci->sector_count -= len;
1268                         offset += to_bytes(len);
1269                 } while (remaining -= len);
1270
1271                 ci->idx++;
1272         }
1273
1274         return 0;
1275 }
1276
1277 /*
1278  * Split the bio into several clones and submit it to targets.
1279  */
1280 static void __split_and_process_bio(struct mapped_device *md, struct bio *bio)
1281 {
1282         struct clone_info ci;
1283         int error = 0;
1284
1285         ci.map = dm_get_live_table(md);
1286         if (unlikely(!ci.map)) {
1287                 bio_io_error(bio);
1288                 return;
1289         }
1290
1291         ci.md = md;
1292         ci.io = alloc_io(md);
1293         ci.io->error = 0;
1294         atomic_set(&ci.io->io_count, 1);
1295         ci.io->bio = bio;
1296         ci.io->md = md;
1297         spin_lock_init(&ci.io->endio_lock);
1298         ci.sector = bio->bi_sector;
1299         ci.idx = bio->bi_idx;
1300
1301         start_io_acct(ci.io);
1302         if (bio->bi_rw & REQ_FLUSH) {
1303                 ci.bio = &ci.md->flush_bio;
1304                 ci.sector_count = 0;
1305                 error = __clone_and_map_empty_flush(&ci);
1306                 /* dec_pending submits any data associated with flush */
1307         } else {
1308                 ci.bio = bio;
1309                 ci.sector_count = bio_sectors(bio);
1310                 while (ci.sector_count && !error)
1311                         error = __clone_and_map(&ci);
1312         }
1313
1314         /* drop the extra reference count */
1315         dec_pending(ci.io, error);
1316         dm_table_put(ci.map);
1317 }
1318 /*-----------------------------------------------------------------
1319  * CRUD END
1320  *---------------------------------------------------------------*/
1321
1322 static int dm_merge_bvec(struct request_queue *q,
1323                          struct bvec_merge_data *bvm,
1324                          struct bio_vec *biovec)
1325 {
1326         struct mapped_device *md = q->queuedata;
1327         struct dm_table *map = dm_get_live_table(md);
1328         struct dm_target *ti;
1329         sector_t max_sectors;
1330         int max_size = 0;
1331
1332         if (unlikely(!map))
1333                 goto out;
1334
1335         ti = dm_table_find_target(map, bvm->bi_sector);
1336         if (!dm_target_is_valid(ti))
1337                 goto out_table;
1338
1339         /*
1340          * Find maximum amount of I/O that won't need splitting
1341          */
1342         max_sectors = min(max_io_len(bvm->bi_sector, ti),
1343                           (sector_t) BIO_MAX_SECTORS);
1344         max_size = (max_sectors << SECTOR_SHIFT) - bvm->bi_size;
1345         if (max_size < 0)
1346                 max_size = 0;
1347
1348         /*
1349          * merge_bvec_fn() returns number of bytes
1350          * it can accept at this offset
1351          * max is precomputed maximal io size
1352          */
1353         if (max_size && ti->type->merge)
1354                 max_size = ti->type->merge(ti, bvm, biovec, max_size);
1355         /*
1356          * If the target doesn't support merge method and some of the devices
1357          * provided their merge_bvec method (we know this by looking at
1358          * queue_max_hw_sectors), then we can't allow bios with multiple vector
1359          * entries.  So always set max_size to 0, and the code below allows
1360          * just one page.
1361          */
1362         else if (queue_max_hw_sectors(q) <= PAGE_SIZE >> 9)
1363
1364                 max_size = 0;
1365
1366 out_table:
1367         dm_table_put(map);
1368
1369 out:
1370         /*
1371          * Always allow an entire first page
1372          */
1373         if (max_size <= biovec->bv_len && !(bvm->bi_size >> SECTOR_SHIFT))
1374                 max_size = biovec->bv_len;
1375
1376         return max_size;
1377 }
1378
1379 /*
1380  * The request function that just remaps the bio built up by
1381  * dm_merge_bvec.
1382  */
1383 static int _dm_request(struct request_queue *q, struct bio *bio)
1384 {
1385         int rw = bio_data_dir(bio);
1386         struct mapped_device *md = q->queuedata;
1387         int cpu;
1388
1389         down_read(&md->io_lock);
1390
1391         cpu = part_stat_lock();
1392         part_stat_inc(cpu, &dm_disk(md)->part0, ios[rw]);
1393         part_stat_add(cpu, &dm_disk(md)->part0, sectors[rw], bio_sectors(bio));
1394         part_stat_unlock();
1395
1396         /* if we're suspended, we have to queue this io for later */
1397         if (unlikely(test_bit(DMF_BLOCK_IO_FOR_SUSPEND, &md->flags))) {
1398                 up_read(&md->io_lock);
1399
1400                 if (bio_rw(bio) != READA)
1401                         queue_io(md, bio);
1402                 else
1403                         bio_io_error(bio);
1404                 return 0;
1405         }
1406
1407         __split_and_process_bio(md, bio);
1408         up_read(&md->io_lock);
1409         return 0;
1410 }
1411
1412 static int dm_make_request(struct request_queue *q, struct bio *bio)
1413 {
1414         struct mapped_device *md = q->queuedata;
1415
1416         return md->saved_make_request_fn(q, bio); /* call __make_request() */
1417 }
1418
1419 static int dm_request_based(struct mapped_device *md)
1420 {
1421         return blk_queue_stackable(md->queue);
1422 }
1423
1424 static int dm_request(struct request_queue *q, struct bio *bio)
1425 {
1426         struct mapped_device *md = q->queuedata;
1427
1428         if (dm_request_based(md))
1429                 return dm_make_request(q, bio);
1430
1431         return _dm_request(q, bio);
1432 }
1433
1434 void dm_dispatch_request(struct request *rq)
1435 {
1436         int r;
1437
1438         if (blk_queue_io_stat(rq->q))
1439                 rq->cmd_flags |= REQ_IO_STAT;
1440
1441         rq->start_time = jiffies;
1442         r = blk_insert_cloned_request(rq->q, rq);
1443         if (r)
1444                 dm_complete_request(rq, r);
1445 }
1446 EXPORT_SYMBOL_GPL(dm_dispatch_request);
1447
1448 static void dm_rq_bio_destructor(struct bio *bio)
1449 {
1450         struct dm_rq_clone_bio_info *info = bio->bi_private;
1451         struct mapped_device *md = info->tio->md;
1452
1453         free_bio_info(info);
1454         bio_free(bio, md->bs);
1455 }
1456
1457 static int dm_rq_bio_constructor(struct bio *bio, struct bio *bio_orig,
1458                                  void *data)
1459 {
1460         struct dm_rq_target_io *tio = data;
1461         struct mapped_device *md = tio->md;
1462         struct dm_rq_clone_bio_info *info = alloc_bio_info(md);
1463
1464         if (!info)
1465                 return -ENOMEM;
1466
1467         info->orig = bio_orig;
1468         info->tio = tio;
1469         bio->bi_end_io = end_clone_bio;
1470         bio->bi_private = info;
1471         bio->bi_destructor = dm_rq_bio_destructor;
1472
1473         return 0;
1474 }
1475
1476 static int setup_clone(struct request *clone, struct request *rq,
1477                        struct dm_rq_target_io *tio)
1478 {
1479         int r;
1480
1481         r = blk_rq_prep_clone(clone, rq, tio->md->bs, GFP_ATOMIC,
1482                               dm_rq_bio_constructor, tio);
1483         if (r)
1484                 return r;
1485
1486         clone->cmd = rq->cmd;
1487         clone->cmd_len = rq->cmd_len;
1488         clone->sense = rq->sense;
1489         clone->buffer = rq->buffer;
1490         clone->end_io = end_clone_request;
1491         clone->end_io_data = tio;
1492
1493         return 0;
1494 }
1495
1496 static struct request *clone_rq(struct request *rq, struct mapped_device *md,
1497                                 gfp_t gfp_mask)
1498 {
1499         struct request *clone;
1500         struct dm_rq_target_io *tio;
1501
1502         tio = alloc_rq_tio(md, gfp_mask);
1503         if (!tio)
1504                 return NULL;
1505
1506         tio->md = md;
1507         tio->ti = NULL;
1508         tio->orig = rq;
1509         tio->error = 0;
1510         memset(&tio->info, 0, sizeof(tio->info));
1511
1512         clone = &tio->clone;
1513         if (setup_clone(clone, rq, tio)) {
1514                 /* -ENOMEM */
1515                 free_rq_tio(tio);
1516                 return NULL;
1517         }
1518
1519         return clone;
1520 }
1521
1522 /*
1523  * Called with the queue lock held.
1524  */
1525 static int dm_prep_fn(struct request_queue *q, struct request *rq)
1526 {
1527         struct mapped_device *md = q->queuedata;
1528         struct request *clone;
1529
1530         if (unlikely(rq->special)) {
1531                 DMWARN("Already has something in rq->special.");
1532                 return BLKPREP_KILL;
1533         }
1534
1535         clone = clone_rq(rq, md, GFP_ATOMIC);
1536         if (!clone)
1537                 return BLKPREP_DEFER;
1538
1539         rq->special = clone;
1540         rq->cmd_flags |= REQ_DONTPREP;
1541
1542         return BLKPREP_OK;
1543 }
1544
1545 /*
1546  * Returns:
1547  * 0  : the request has been processed (not requeued)
1548  * !0 : the request has been requeued
1549  */
1550 static int map_request(struct dm_target *ti, struct request *clone,
1551                        struct mapped_device *md)
1552 {
1553         int r, requeued = 0;
1554         struct dm_rq_target_io *tio = clone->end_io_data;
1555
1556         /*
1557          * Hold the md reference here for the in-flight I/O.
1558          * We can't rely on the reference count by device opener,
1559          * because the device may be closed during the request completion
1560          * when all bios are completed.
1561          * See the comment in rq_completed() too.
1562          */
1563         dm_get(md);
1564
1565         tio->ti = ti;
1566         r = ti->type->map_rq(ti, clone, &tio->info);
1567         switch (r) {
1568         case DM_MAPIO_SUBMITTED:
1569                 /* The target has taken the I/O to submit by itself later */
1570                 break;
1571         case DM_MAPIO_REMAPPED:
1572                 /* The target has remapped the I/O so dispatch it */
1573                 trace_block_rq_remap(clone->q, clone, disk_devt(dm_disk(md)),
1574                                      blk_rq_pos(tio->orig));
1575                 dm_dispatch_request(clone);
1576                 break;
1577         case DM_MAPIO_REQUEUE:
1578                 /* The target wants to requeue the I/O */
1579                 dm_requeue_unmapped_request(clone);
1580                 requeued = 1;
1581                 break;
1582         default:
1583                 if (r > 0) {
1584                         DMWARN("unimplemented target map return value: %d", r);
1585                         BUG();
1586                 }
1587
1588                 /* The target wants to complete the I/O */
1589                 dm_kill_unmapped_request(clone, r);
1590                 break;
1591         }
1592
1593         return requeued;
1594 }
1595
1596 /*
1597  * q->request_fn for request-based dm.
1598  * Called with the queue lock held.
1599  */
1600 static void dm_request_fn(struct request_queue *q)
1601 {
1602         struct mapped_device *md = q->queuedata;
1603         struct dm_table *map = dm_get_live_table(md);
1604         struct dm_target *ti;
1605         struct request *rq, *clone;
1606         sector_t pos;
1607
1608         /*
1609          * For suspend, check blk_queue_stopped() and increment
1610          * ->pending within a single queue_lock not to increment the
1611          * number of in-flight I/Os after the queue is stopped in
1612          * dm_suspend().
1613          */
1614         while (!blk_queue_stopped(q)) {
1615                 rq = blk_peek_request(q);
1616                 if (!rq)
1617                         goto delay_and_out;
1618
1619                 /* always use block 0 to find the target for flushes for now */
1620                 pos = 0;
1621                 if (!(rq->cmd_flags & REQ_FLUSH))
1622                         pos = blk_rq_pos(rq);
1623
1624                 ti = dm_table_find_target(map, pos);
1625                 BUG_ON(!dm_target_is_valid(ti));
1626
1627                 if (ti->type->busy && ti->type->busy(ti))
1628                         goto delay_and_out;
1629
1630                 blk_start_request(rq);
1631                 clone = rq->special;
1632                 atomic_inc(&md->pending[rq_data_dir(clone)]);
1633
1634                 spin_unlock(q->queue_lock);
1635                 if (map_request(ti, clone, md))
1636                         goto requeued;
1637
1638                 BUG_ON(!irqs_disabled());
1639                 spin_lock(q->queue_lock);
1640         }
1641
1642         goto out;
1643
1644 requeued:
1645         BUG_ON(!irqs_disabled());
1646         spin_lock(q->queue_lock);
1647
1648 delay_and_out:
1649         blk_delay_queue(q, HZ / 10);
1650 out:
1651         dm_table_put(map);
1652
1653         return;
1654 }
1655
1656 int dm_underlying_device_busy(struct request_queue *q)
1657 {
1658         return blk_lld_busy(q);
1659 }
1660 EXPORT_SYMBOL_GPL(dm_underlying_device_busy);
1661
1662 static int dm_lld_busy(struct request_queue *q)
1663 {
1664         int r;
1665         struct mapped_device *md = q->queuedata;
1666         struct dm_table *map = dm_get_live_table(md);
1667
1668         if (!map || test_bit(DMF_BLOCK_IO_FOR_SUSPEND, &md->flags))
1669                 r = 1;
1670         else
1671                 r = dm_table_any_busy_target(map);
1672
1673         dm_table_put(map);
1674
1675         return r;
1676 }
1677
1678 static int dm_any_congested(void *congested_data, int bdi_bits)
1679 {
1680         int r = bdi_bits;
1681         struct mapped_device *md = congested_data;
1682         struct dm_table *map;
1683
1684         if (!test_bit(DMF_BLOCK_IO_FOR_SUSPEND, &md->flags)) {
1685                 map = dm_get_live_table(md);
1686                 if (map) {
1687                         /*
1688                          * Request-based dm cares about only own queue for
1689                          * the query about congestion status of request_queue
1690                          */
1691                         if (dm_request_based(md))
1692                                 r = md->queue->backing_dev_info.state &
1693                                     bdi_bits;
1694                         else
1695                                 r = dm_table_any_congested(map, bdi_bits);
1696
1697                         dm_table_put(map);
1698                 }
1699         }
1700
1701         return r;
1702 }
1703
1704 /*-----------------------------------------------------------------
1705  * An IDR is used to keep track of allocated minor numbers.
1706  *---------------------------------------------------------------*/
1707 static DEFINE_IDR(_minor_idr);
1708
1709 static void free_minor(int minor)
1710 {
1711         spin_lock(&_minor_lock);
1712         idr_remove(&_minor_idr, minor);
1713         spin_unlock(&_minor_lock);
1714 }
1715
1716 /*
1717  * See if the device with a specific minor # is free.
1718  */
1719 static int specific_minor(int minor)
1720 {
1721         int r, m;
1722
1723         if (minor >= (1 << MINORBITS))
1724                 return -EINVAL;
1725
1726         r = idr_pre_get(&_minor_idr, GFP_KERNEL);
1727         if (!r)
1728                 return -ENOMEM;
1729
1730         spin_lock(&_minor_lock);
1731
1732         if (idr_find(&_minor_idr, minor)) {
1733                 r = -EBUSY;
1734                 goto out;
1735         }
1736
1737         r = idr_get_new_above(&_minor_idr, MINOR_ALLOCED, minor, &m);
1738         if (r)
1739                 goto out;
1740
1741         if (m != minor) {
1742                 idr_remove(&_minor_idr, m);
1743                 r = -EBUSY;
1744                 goto out;
1745         }
1746
1747 out:
1748         spin_unlock(&_minor_lock);
1749         return r;
1750 }
1751
1752 static int next_free_minor(int *minor)
1753 {
1754         int r, m;
1755
1756         r = idr_pre_get(&_minor_idr, GFP_KERNEL);
1757         if (!r)
1758                 return -ENOMEM;
1759
1760         spin_lock(&_minor_lock);
1761
1762         r = idr_get_new(&_minor_idr, MINOR_ALLOCED, &m);
1763         if (r)
1764                 goto out;
1765
1766         if (m >= (1 << MINORBITS)) {
1767                 idr_remove(&_minor_idr, m);
1768                 r = -ENOSPC;
1769                 goto out;
1770         }
1771
1772         *minor = m;
1773
1774 out:
1775         spin_unlock(&_minor_lock);
1776         return r;
1777 }
1778
1779 static const struct block_device_operations dm_blk_dops;
1780
1781 static void dm_wq_work(struct work_struct *work);
1782
1783 static void dm_init_md_queue(struct mapped_device *md)
1784 {
1785         /*
1786          * Request-based dm devices cannot be stacked on top of bio-based dm
1787          * devices.  The type of this dm device has not been decided yet.
1788          * The type is decided at the first table loading time.
1789          * To prevent problematic device stacking, clear the queue flag
1790          * for request stacking support until then.
1791          *
1792          * This queue is new, so no concurrency on the queue_flags.
1793          */
1794         queue_flag_clear_unlocked(QUEUE_FLAG_STACKABLE, md->queue);
1795
1796         md->queue->queuedata = md;
1797         md->queue->backing_dev_info.congested_fn = dm_any_congested;
1798         md->queue->backing_dev_info.congested_data = md;
1799         blk_queue_make_request(md->queue, dm_request);
1800         blk_queue_bounce_limit(md->queue, BLK_BOUNCE_ANY);
1801         blk_queue_merge_bvec(md->queue, dm_merge_bvec);
1802         blk_queue_flush(md->queue, REQ_FLUSH | REQ_FUA);
1803 }
1804
1805 /*
1806  * Allocate and initialise a blank device with a given minor.
1807  */
1808 static struct mapped_device *alloc_dev(int minor)
1809 {
1810         int r;
1811         struct mapped_device *md = kzalloc(sizeof(*md), GFP_KERNEL);
1812         void *old_md;
1813
1814         if (!md) {
1815                 DMWARN("unable to allocate device, out of memory.");
1816                 return NULL;
1817         }
1818
1819         if (!try_module_get(THIS_MODULE))
1820                 goto bad_module_get;
1821
1822         /* get a minor number for the dev */
1823         if (minor == DM_ANY_MINOR)
1824                 r = next_free_minor(&minor);
1825         else
1826                 r = specific_minor(minor);
1827         if (r < 0)
1828                 goto bad_minor;
1829
1830         md->type = DM_TYPE_NONE;
1831         init_rwsem(&md->io_lock);
1832         mutex_init(&md->suspend_lock);
1833         mutex_init(&md->type_lock);
1834         spin_lock_init(&md->deferred_lock);
1835         rwlock_init(&md->map_lock);
1836         atomic_set(&md->holders, 1);
1837         atomic_set(&md->open_count, 0);
1838         atomic_set(&md->event_nr, 0);
1839         atomic_set(&md->uevent_seq, 0);
1840         INIT_LIST_HEAD(&md->uevent_list);
1841         spin_lock_init(&md->uevent_lock);
1842
1843         md->queue = blk_alloc_queue(GFP_KERNEL);
1844         if (!md->queue)
1845                 goto bad_queue;
1846
1847         dm_init_md_queue(md);
1848
1849         md->disk = alloc_disk(1);
1850         if (!md->disk)
1851                 goto bad_disk;
1852
1853         atomic_set(&md->pending[0], 0);
1854         atomic_set(&md->pending[1], 0);
1855         init_waitqueue_head(&md->wait);
1856         INIT_WORK(&md->work, dm_wq_work);
1857         init_waitqueue_head(&md->eventq);
1858
1859         md->disk->major = _major;
1860         md->disk->first_minor = minor;
1861         md->disk->fops = &dm_blk_dops;
1862         md->disk->queue = md->queue;
1863         md->disk->private_data = md;
1864         sprintf(md->disk->disk_name, "dm-%d", minor);
1865         add_disk(md->disk);
1866         format_dev_t(md->name, MKDEV(_major, minor));
1867
1868         md->wq = alloc_workqueue("kdmflush",
1869                                  WQ_NON_REENTRANT | WQ_MEM_RECLAIM, 0);
1870         if (!md->wq)
1871                 goto bad_thread;
1872
1873         md->bdev = bdget_disk(md->disk, 0);
1874         if (!md->bdev)
1875                 goto bad_bdev;
1876
1877         bio_init(&md->flush_bio);
1878         md->flush_bio.bi_bdev = md->bdev;
1879         md->flush_bio.bi_rw = WRITE_FLUSH;
1880
1881         /* Populate the mapping, nobody knows we exist yet */
1882         spin_lock(&_minor_lock);
1883         old_md = idr_replace(&_minor_idr, md, minor);
1884         spin_unlock(&_minor_lock);
1885
1886         BUG_ON(old_md != MINOR_ALLOCED);
1887
1888         return md;
1889
1890 bad_bdev:
1891         destroy_workqueue(md->wq);
1892 bad_thread:
1893         del_gendisk(md->disk);
1894         put_disk(md->disk);
1895 bad_disk:
1896         blk_cleanup_queue(md->queue);
1897 bad_queue:
1898         free_minor(minor);
1899 bad_minor:
1900         module_put(THIS_MODULE);
1901 bad_module_get:
1902         kfree(md);
1903         return NULL;
1904 }
1905
1906 static void unlock_fs(struct mapped_device *md);
1907
1908 static void free_dev(struct mapped_device *md)
1909 {
1910         int minor = MINOR(disk_devt(md->disk));
1911
1912         unlock_fs(md);
1913         bdput(md->bdev);
1914         destroy_workqueue(md->wq);
1915         if (md->tio_pool)
1916                 mempool_destroy(md->tio_pool);
1917         if (md->io_pool)
1918                 mempool_destroy(md->io_pool);
1919         if (md->bs)
1920                 bioset_free(md->bs);
1921         blk_integrity_unregister(md->disk);
1922         del_gendisk(md->disk);
1923         free_minor(minor);
1924
1925         spin_lock(&_minor_lock);
1926         md->disk->private_data = NULL;
1927         spin_unlock(&_minor_lock);
1928
1929         put_disk(md->disk);
1930         blk_cleanup_queue(md->queue);
1931         module_put(THIS_MODULE);
1932         kfree(md);
1933 }
1934
1935 static void __bind_mempools(struct mapped_device *md, struct dm_table *t)
1936 {
1937         struct dm_md_mempools *p;
1938
1939         if (md->io_pool && md->tio_pool && md->bs)
1940                 /* the md already has necessary mempools */
1941                 goto out;
1942
1943         p = dm_table_get_md_mempools(t);
1944         BUG_ON(!p || md->io_pool || md->tio_pool || md->bs);
1945
1946         md->io_pool = p->io_pool;
1947         p->io_pool = NULL;
1948         md->tio_pool = p->tio_pool;
1949         p->tio_pool = NULL;
1950         md->bs = p->bs;
1951         p->bs = NULL;
1952
1953 out:
1954         /* mempool bind completed, now no need any mempools in the table */
1955         dm_table_free_md_mempools(t);
1956 }
1957
1958 /*
1959  * Bind a table to the device.
1960  */
1961 static void event_callback(void *context)
1962 {
1963         unsigned long flags;
1964         LIST_HEAD(uevents);
1965         struct mapped_device *md = (struct mapped_device *) context;
1966
1967         spin_lock_irqsave(&md->uevent_lock, flags);
1968         list_splice_init(&md->uevent_list, &uevents);
1969         spin_unlock_irqrestore(&md->uevent_lock, flags);
1970
1971         dm_send_uevents(&uevents, &disk_to_dev(md->disk)->kobj);
1972
1973         atomic_inc(&md->event_nr);
1974         wake_up(&md->eventq);
1975 }
1976
1977 /*
1978  * Protected by md->suspend_lock obtained by dm_swap_table().
1979  */
1980 static void __set_size(struct mapped_device *md, sector_t size)
1981 {
1982         set_capacity(md->disk, size);
1983
1984         i_size_write(md->bdev->bd_inode, (loff_t)size << SECTOR_SHIFT);
1985 }
1986
1987 /*
1988  * Returns old map, which caller must destroy.
1989  */
1990 static struct dm_table *__bind(struct mapped_device *md, struct dm_table *t,
1991                                struct queue_limits *limits)
1992 {
1993         struct dm_table *old_map;
1994         struct request_queue *q = md->queue;
1995         sector_t size;
1996         unsigned long flags;
1997
1998         size = dm_table_get_size(t);
1999
2000         /*
2001          * Wipe any geometry if the size of the table changed.
2002          */
2003         if (size != get_capacity(md->disk))
2004                 memset(&md->geometry, 0, sizeof(md->geometry));
2005
2006         __set_size(md, size);
2007
2008         dm_table_event_callback(t, event_callback, md);
2009
2010         /*
2011          * The queue hasn't been stopped yet, if the old table type wasn't
2012          * for request-based during suspension.  So stop it to prevent
2013          * I/O mapping before resume.
2014          * This must be done before setting the queue restrictions,
2015          * because request-based dm may be run just after the setting.
2016          */
2017         if (dm_table_request_based(t) && !blk_queue_stopped(q))
2018                 stop_queue(q);
2019
2020         __bind_mempools(md, t);
2021
2022         write_lock_irqsave(&md->map_lock, flags);
2023         old_map = md->map;
2024         md->map = t;
2025         dm_table_set_restrictions(t, q, limits);
2026         write_unlock_irqrestore(&md->map_lock, flags);
2027
2028         return old_map;
2029 }
2030
2031 /*
2032  * Returns unbound table for the caller to free.
2033  */
2034 static struct dm_table *__unbind(struct mapped_device *md)
2035 {
2036         struct dm_table *map = md->map;
2037         unsigned long flags;
2038
2039         if (!map)
2040                 return NULL;
2041
2042         dm_table_event_callback(map, NULL, NULL);
2043         write_lock_irqsave(&md->map_lock, flags);
2044         md->map = NULL;
2045         write_unlock_irqrestore(&md->map_lock, flags);
2046
2047         return map;
2048 }
2049
2050 /*
2051  * Constructor for a new device.
2052  */
2053 int dm_create(int minor, struct mapped_device **result)
2054 {
2055         struct mapped_device *md;
2056
2057         md = alloc_dev(minor);
2058         if (!md)
2059                 return -ENXIO;
2060
2061         dm_sysfs_init(md);
2062
2063         *result = md;
2064         return 0;
2065 }
2066
2067 /*
2068  * Functions to manage md->type.
2069  * All are required to hold md->type_lock.
2070  */
2071 void dm_lock_md_type(struct mapped_device *md)
2072 {
2073         mutex_lock(&md->type_lock);
2074 }
2075
2076 void dm_unlock_md_type(struct mapped_device *md)
2077 {
2078         mutex_unlock(&md->type_lock);
2079 }
2080
2081 void dm_set_md_type(struct mapped_device *md, unsigned type)
2082 {
2083         md->type = type;
2084 }
2085
2086 unsigned dm_get_md_type(struct mapped_device *md)
2087 {
2088         return md->type;
2089 }
2090
2091 /*
2092  * Fully initialize a request-based queue (->elevator, ->request_fn, etc).
2093  */
2094 static int dm_init_request_based_queue(struct mapped_device *md)
2095 {
2096         struct request_queue *q = NULL;
2097
2098         if (md->queue->elevator)
2099                 return 1;
2100
2101         /* Fully initialize the queue */
2102         q = blk_init_allocated_queue(md->queue, dm_request_fn, NULL);
2103         if (!q)
2104                 return 0;
2105
2106         md->queue = q;
2107         md->saved_make_request_fn = md->queue->make_request_fn;
2108         dm_init_md_queue(md);
2109         blk_queue_softirq_done(md->queue, dm_softirq_done);
2110         blk_queue_prep_rq(md->queue, dm_prep_fn);
2111         blk_queue_lld_busy(md->queue, dm_lld_busy);
2112
2113         elv_register_queue(md->queue);
2114
2115         return 1;
2116 }
2117
2118 /*
2119  * Setup the DM device's queue based on md's type
2120  */
2121 int dm_setup_md_queue(struct mapped_device *md)
2122 {
2123         if ((dm_get_md_type(md) == DM_TYPE_REQUEST_BASED) &&
2124             !dm_init_request_based_queue(md)) {
2125                 DMWARN("Cannot initialize queue for request-based mapped device");
2126                 return -EINVAL;
2127         }
2128
2129         return 0;
2130 }
2131
2132 static struct mapped_device *dm_find_md(dev_t dev)
2133 {
2134         struct mapped_device *md;
2135         unsigned minor = MINOR(dev);
2136
2137         if (MAJOR(dev) != _major || minor >= (1 << MINORBITS))
2138                 return NULL;
2139
2140         spin_lock(&_minor_lock);
2141
2142         md = idr_find(&_minor_idr, minor);
2143         if (md && (md == MINOR_ALLOCED ||
2144                    (MINOR(disk_devt(dm_disk(md))) != minor) ||
2145                    dm_deleting_md(md) ||
2146                    test_bit(DMF_FREEING, &md->flags))) {
2147                 md = NULL;
2148                 goto out;
2149         }
2150
2151 out:
2152         spin_unlock(&_minor_lock);
2153
2154         return md;
2155 }
2156
2157 struct mapped_device *dm_get_md(dev_t dev)
2158 {
2159         struct mapped_device *md = dm_find_md(dev);
2160
2161         if (md)
2162                 dm_get(md);
2163
2164         return md;
2165 }
2166
2167 void *dm_get_mdptr(struct mapped_device *md)
2168 {
2169         return md->interface_ptr;
2170 }
2171
2172 void dm_set_mdptr(struct mapped_device *md, void *ptr)
2173 {
2174         md->interface_ptr = ptr;
2175 }
2176
2177 void dm_get(struct mapped_device *md)
2178 {
2179         atomic_inc(&md->holders);
2180         BUG_ON(test_bit(DMF_FREEING, &md->flags));
2181 }
2182
2183 const char *dm_device_name(struct mapped_device *md)
2184 {
2185         return md->name;
2186 }
2187 EXPORT_SYMBOL_GPL(dm_device_name);
2188
2189 static void __dm_destroy(struct mapped_device *md, bool wait)
2190 {
2191         struct dm_table *map;
2192
2193         might_sleep();
2194
2195         spin_lock(&_minor_lock);
2196         map = dm_get_live_table(md);
2197         idr_replace(&_minor_idr, MINOR_ALLOCED, MINOR(disk_devt(dm_disk(md))));
2198         set_bit(DMF_FREEING, &md->flags);
2199         spin_unlock(&_minor_lock);
2200
2201         if (!dm_suspended_md(md)) {
2202                 dm_table_presuspend_targets(map);
2203                 dm_table_postsuspend_targets(map);
2204         }
2205
2206         /*
2207          * Rare, but there may be I/O requests still going to complete,
2208          * for example.  Wait for all references to disappear.
2209          * No one should increment the reference count of the mapped_device,
2210          * after the mapped_device state becomes DMF_FREEING.
2211          */
2212         if (wait)
2213                 while (atomic_read(&md->holders))
2214                         msleep(1);
2215         else if (atomic_read(&md->holders))
2216                 DMWARN("%s: Forcibly removing mapped_device still in use! (%d users)",
2217                        dm_device_name(md), atomic_read(&md->holders));
2218
2219         dm_sysfs_exit(md);
2220         dm_table_put(map);
2221         dm_table_destroy(__unbind(md));
2222         free_dev(md);
2223 }
2224
2225 void dm_destroy(struct mapped_device *md)
2226 {
2227         __dm_destroy(md, true);
2228 }
2229
2230 void dm_destroy_immediate(struct mapped_device *md)
2231 {
2232         __dm_destroy(md, false);
2233 }
2234
2235 void dm_put(struct mapped_device *md)
2236 {
2237         atomic_dec(&md->holders);
2238 }
2239 EXPORT_SYMBOL_GPL(dm_put);
2240
2241 static int dm_wait_for_completion(struct mapped_device *md, int interruptible)
2242 {
2243         int r = 0;
2244         DECLARE_WAITQUEUE(wait, current);
2245
2246         add_wait_queue(&md->wait, &wait);
2247
2248         while (1) {
2249                 set_current_state(interruptible);
2250
2251                 smp_mb();
2252                 if (!md_in_flight(md))
2253                         break;
2254
2255                 if (interruptible == TASK_INTERRUPTIBLE &&
2256                     signal_pending(current)) {
2257                         r = -EINTR;
2258                         break;
2259                 }
2260
2261                 io_schedule();
2262         }
2263         set_current_state(TASK_RUNNING);
2264
2265         remove_wait_queue(&md->wait, &wait);
2266
2267         return r;
2268 }
2269
2270 /*
2271  * Process the deferred bios
2272  */
2273 static void dm_wq_work(struct work_struct *work)
2274 {
2275         struct mapped_device *md = container_of(work, struct mapped_device,
2276                                                 work);
2277         struct bio *c;
2278
2279         down_read(&md->io_lock);
2280
2281         while (!test_bit(DMF_BLOCK_IO_FOR_SUSPEND, &md->flags)) {
2282                 spin_lock_irq(&md->deferred_lock);
2283                 c = bio_list_pop(&md->deferred);
2284                 spin_unlock_irq(&md->deferred_lock);
2285
2286                 if (!c)
2287                         break;
2288
2289                 up_read(&md->io_lock);
2290
2291                 if (dm_request_based(md))
2292                         generic_make_request(c);
2293                 else
2294                         __split_and_process_bio(md, c);
2295
2296                 down_read(&md->io_lock);
2297         }
2298
2299         up_read(&md->io_lock);
2300 }
2301
2302 static void dm_queue_flush(struct mapped_device *md)
2303 {
2304         clear_bit(DMF_BLOCK_IO_FOR_SUSPEND, &md->flags);
2305         smp_mb__after_clear_bit();
2306         queue_work(md->wq, &md->work);
2307 }
2308
2309 /*
2310  * Swap in a new table, returning the old one for the caller to destroy.
2311  */
2312 struct dm_table *dm_swap_table(struct mapped_device *md, struct dm_table *table)
2313 {
2314         struct dm_table *map = ERR_PTR(-EINVAL);
2315         struct queue_limits limits;
2316         int r;
2317
2318         mutex_lock(&md->suspend_lock);
2319
2320         /* device must be suspended */
2321         if (!dm_suspended_md(md))
2322                 goto out;
2323
2324         r = dm_calculate_queue_limits(table, &limits);
2325         if (r) {
2326                 map = ERR_PTR(r);
2327                 goto out;
2328         }
2329
2330         map = __bind(md, table, &limits);
2331
2332 out:
2333         mutex_unlock(&md->suspend_lock);
2334         return map;
2335 }
2336
2337 /*
2338  * Functions to lock and unlock any filesystem running on the
2339  * device.
2340  */
2341 static int lock_fs(struct mapped_device *md)
2342 {
2343         int r;
2344
2345         WARN_ON(md->frozen_sb);
2346
2347         md->frozen_sb = freeze_bdev(md->bdev);
2348         if (IS_ERR(md->frozen_sb)) {
2349                 r = PTR_ERR(md->frozen_sb);
2350                 md->frozen_sb = NULL;
2351                 return r;
2352         }
2353
2354         set_bit(DMF_FROZEN, &md->flags);
2355
2356         return 0;
2357 }
2358
2359 static void unlock_fs(struct mapped_device *md)
2360 {
2361         if (!test_bit(DMF_FROZEN, &md->flags))
2362                 return;
2363
2364         thaw_bdev(md->bdev, md->frozen_sb);
2365         md->frozen_sb = NULL;
2366         clear_bit(DMF_FROZEN, &md->flags);
2367 }
2368
2369 /*
2370  * We need to be able to change a mapping table under a mounted
2371  * filesystem.  For example we might want to move some data in
2372  * the background.  Before the table can be swapped with
2373  * dm_bind_table, dm_suspend must be called to flush any in
2374  * flight bios and ensure that any further io gets deferred.
2375  */
2376 /*
2377  * Suspend mechanism in request-based dm.
2378  *
2379  * 1. Flush all I/Os by lock_fs() if needed.
2380  * 2. Stop dispatching any I/O by stopping the request_queue.
2381  * 3. Wait for all in-flight I/Os to be completed or requeued.
2382  *
2383  * To abort suspend, start the request_queue.
2384  */
2385 int dm_suspend(struct mapped_device *md, unsigned suspend_flags)
2386 {
2387         struct dm_table *map = NULL;
2388         int r = 0;
2389         int do_lockfs = suspend_flags & DM_SUSPEND_LOCKFS_FLAG ? 1 : 0;
2390         int noflush = suspend_flags & DM_SUSPEND_NOFLUSH_FLAG ? 1 : 0;
2391
2392         mutex_lock(&md->suspend_lock);
2393
2394         if (dm_suspended_md(md)) {
2395                 r = -EINVAL;
2396                 goto out_unlock;
2397         }
2398
2399         map = dm_get_live_table(md);
2400
2401         /*
2402          * DMF_NOFLUSH_SUSPENDING must be set before presuspend.
2403          * This flag is cleared before dm_suspend returns.
2404          */
2405         if (noflush)
2406                 set_bit(DMF_NOFLUSH_SUSPENDING, &md->flags);
2407
2408         /* This does not get reverted if there's an error later. */
2409         dm_table_presuspend_targets(map);
2410
2411         /*
2412          * Flush I/O to the device.
2413          * Any I/O submitted after lock_fs() may not be flushed.
2414          * noflush takes precedence over do_lockfs.
2415          * (lock_fs() flushes I/Os and waits for them to complete.)
2416          */
2417         if (!noflush && do_lockfs) {
2418                 r = lock_fs(md);
2419                 if (r)
2420                         goto out;
2421         }
2422
2423         /*
2424          * Here we must make sure that no processes are submitting requests
2425          * to target drivers i.e. no one may be executing
2426          * __split_and_process_bio. This is called from dm_request and
2427          * dm_wq_work.
2428          *
2429          * To get all processes out of __split_and_process_bio in dm_request,
2430          * we take the write lock. To prevent any process from reentering
2431          * __split_and_process_bio from dm_request and quiesce the thread
2432          * (dm_wq_work), we set BMF_BLOCK_IO_FOR_SUSPEND and call
2433          * flush_workqueue(md->wq).
2434          */
2435         down_write(&md->io_lock);
2436         set_bit(DMF_BLOCK_IO_FOR_SUSPEND, &md->flags);
2437         up_write(&md->io_lock);
2438
2439         /*
2440          * Stop md->queue before flushing md->wq in case request-based
2441          * dm defers requests to md->wq from md->queue.
2442          */
2443         if (dm_request_based(md))
2444                 stop_queue(md->queue);
2445
2446         flush_workqueue(md->wq);
2447
2448         /*
2449          * At this point no more requests are entering target request routines.
2450          * We call dm_wait_for_completion to wait for all existing requests
2451          * to finish.
2452          */
2453         r = dm_wait_for_completion(md, TASK_INTERRUPTIBLE);
2454
2455         down_write(&md->io_lock);
2456         if (noflush)
2457                 clear_bit(DMF_NOFLUSH_SUSPENDING, &md->flags);
2458         up_write(&md->io_lock);
2459
2460         /* were we interrupted ? */
2461         if (r < 0) {
2462                 dm_queue_flush(md);
2463
2464                 if (dm_request_based(md))
2465                         start_queue(md->queue);
2466
2467                 unlock_fs(md);
2468                 goto out; /* pushback list is already flushed, so skip flush */
2469         }
2470
2471         /*
2472          * If dm_wait_for_completion returned 0, the device is completely
2473          * quiescent now. There is no request-processing activity. All new
2474          * requests are being added to md->deferred list.
2475          */
2476
2477         set_bit(DMF_SUSPENDED, &md->flags);
2478
2479         dm_table_postsuspend_targets(map);
2480
2481 out:
2482         dm_table_put(map);
2483
2484 out_unlock:
2485         mutex_unlock(&md->suspend_lock);
2486         return r;
2487 }
2488
2489 int dm_resume(struct mapped_device *md)
2490 {
2491         int r = -EINVAL;
2492         struct dm_table *map = NULL;
2493
2494         mutex_lock(&md->suspend_lock);
2495         if (!dm_suspended_md(md))
2496                 goto out;
2497
2498         map = dm_get_live_table(md);
2499         if (!map || !dm_table_get_size(map))
2500                 goto out;
2501
2502         r = dm_table_resume_targets(map);
2503         if (r)
2504                 goto out;
2505
2506         dm_queue_flush(md);
2507
2508         /*
2509          * Flushing deferred I/Os must be done after targets are resumed
2510          * so that mapping of targets can work correctly.
2511          * Request-based dm is queueing the deferred I/Os in its request_queue.
2512          */
2513         if (dm_request_based(md))
2514                 start_queue(md->queue);
2515
2516         unlock_fs(md);
2517
2518         clear_bit(DMF_SUSPENDED, &md->flags);
2519
2520         r = 0;
2521 out:
2522         dm_table_put(map);
2523         mutex_unlock(&md->suspend_lock);
2524
2525         return r;
2526 }
2527
2528 /*-----------------------------------------------------------------
2529  * Event notification.
2530  *---------------------------------------------------------------*/
2531 int dm_kobject_uevent(struct mapped_device *md, enum kobject_action action,
2532                        unsigned cookie)
2533 {
2534         char udev_cookie[DM_COOKIE_LENGTH];
2535         char *envp[] = { udev_cookie, NULL };
2536
2537         if (!cookie)
2538                 return kobject_uevent(&disk_to_dev(md->disk)->kobj, action);
2539         else {
2540                 snprintf(udev_cookie, DM_COOKIE_LENGTH, "%s=%u",
2541                          DM_COOKIE_ENV_VAR_NAME, cookie);
2542                 return kobject_uevent_env(&disk_to_dev(md->disk)->kobj,
2543                                           action, envp);
2544         }
2545 }
2546
2547 uint32_t dm_next_uevent_seq(struct mapped_device *md)
2548 {
2549         return atomic_add_return(1, &md->uevent_seq);
2550 }
2551
2552 uint32_t dm_get_event_nr(struct mapped_device *md)
2553 {
2554         return atomic_read(&md->event_nr);
2555 }
2556
2557 int dm_wait_event(struct mapped_device *md, int event_nr)
2558 {
2559         return wait_event_interruptible(md->eventq,
2560                         (event_nr != atomic_read(&md->event_nr)));
2561 }
2562
2563 void dm_uevent_add(struct mapped_device *md, struct list_head *elist)
2564 {
2565         unsigned long flags;
2566
2567         spin_lock_irqsave(&md->uevent_lock, flags);
2568         list_add(elist, &md->uevent_list);
2569         spin_unlock_irqrestore(&md->uevent_lock, flags);
2570 }
2571
2572 /*
2573  * The gendisk is only valid as long as you have a reference
2574  * count on 'md'.
2575  */
2576 struct gendisk *dm_disk(struct mapped_device *md)
2577 {
2578         return md->disk;
2579 }
2580
2581 struct kobject *dm_kobject(struct mapped_device *md)
2582 {
2583         return &md->kobj;
2584 }
2585
2586 /*
2587  * struct mapped_device should not be exported outside of dm.c
2588  * so use this check to verify that kobj is part of md structure
2589  */
2590 struct mapped_device *dm_get_from_kobject(struct kobject *kobj)
2591 {
2592         struct mapped_device *md;
2593
2594         md = container_of(kobj, struct mapped_device, kobj);
2595         if (&md->kobj != kobj)
2596                 return NULL;
2597
2598         if (test_bit(DMF_FREEING, &md->flags) ||
2599             dm_deleting_md(md))
2600                 return NULL;
2601
2602         dm_get(md);
2603         return md;
2604 }
2605
2606 int dm_suspended_md(struct mapped_device *md)
2607 {
2608         return test_bit(DMF_SUSPENDED, &md->flags);
2609 }
2610
2611 int dm_suspended(struct dm_target *ti)
2612 {
2613         return dm_suspended_md(dm_table_get_md(ti->table));
2614 }
2615 EXPORT_SYMBOL_GPL(dm_suspended);
2616
2617 int dm_noflush_suspending(struct dm_target *ti)
2618 {
2619         return __noflush_suspending(dm_table_get_md(ti->table));
2620 }
2621 EXPORT_SYMBOL_GPL(dm_noflush_suspending);
2622
2623 struct dm_md_mempools *dm_alloc_md_mempools(unsigned type)
2624 {
2625         struct dm_md_mempools *pools = kmalloc(sizeof(*pools), GFP_KERNEL);
2626
2627         if (!pools)
2628                 return NULL;
2629
2630         pools->io_pool = (type == DM_TYPE_BIO_BASED) ?
2631                          mempool_create_slab_pool(MIN_IOS, _io_cache) :
2632                          mempool_create_slab_pool(MIN_IOS, _rq_bio_info_cache);
2633         if (!pools->io_pool)
2634                 goto free_pools_and_out;
2635
2636         pools->tio_pool = (type == DM_TYPE_BIO_BASED) ?
2637                           mempool_create_slab_pool(MIN_IOS, _tio_cache) :
2638                           mempool_create_slab_pool(MIN_IOS, _rq_tio_cache);
2639         if (!pools->tio_pool)
2640                 goto free_io_pool_and_out;
2641
2642         pools->bs = (type == DM_TYPE_BIO_BASED) ?
2643                     bioset_create(16, 0) : bioset_create(MIN_IOS, 0);
2644         if (!pools->bs)
2645                 goto free_tio_pool_and_out;
2646
2647         return pools;
2648
2649 free_tio_pool_and_out:
2650         mempool_destroy(pools->tio_pool);
2651
2652 free_io_pool_and_out:
2653         mempool_destroy(pools->io_pool);
2654
2655 free_pools_and_out:
2656         kfree(pools);
2657
2658         return NULL;
2659 }
2660
2661 void dm_free_md_mempools(struct dm_md_mempools *pools)
2662 {
2663         if (!pools)
2664                 return;
2665
2666         if (pools->io_pool)
2667                 mempool_destroy(pools->io_pool);
2668
2669         if (pools->tio_pool)
2670                 mempool_destroy(pools->tio_pool);
2671
2672         if (pools->bs)
2673                 bioset_free(pools->bs);
2674
2675         kfree(pools);
2676 }
2677
2678 static const struct block_device_operations dm_blk_dops = {
2679         .open = dm_blk_open,
2680         .release = dm_blk_close,
2681         .ioctl = dm_blk_ioctl,
2682         .getgeo = dm_blk_getgeo,
2683         .owner = THIS_MODULE
2684 };
2685
2686 EXPORT_SYMBOL(dm_get_mapinfo);
2687
2688 /*
2689  * module hooks
2690  */
2691 module_init(dm_init);
2692 module_exit(dm_exit);
2693
2694 module_param(major, uint, 0);
2695 MODULE_PARM_DESC(major, "The major number of the device mapper");
2696 MODULE_DESCRIPTION(DM_NAME " driver");
2697 MODULE_AUTHOR("Joe Thornber <dm-devel@redhat.com>");
2698 MODULE_LICENSE("GPL");