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         if (elv_queue_empty(q))
 811                 blk_plug_device(q);
 812         blk_requeue_request(q, rq);
 813         spin_unlock_irqrestore(q->queue_lock, flags);
 814
 815         rq_completed(md, rw, 0);
 816 }
 817 EXPORT_SYMBOL_GPL(dm_requeue_unmapped_request);
 818
 819 static void __stop_queue(struct request_queue *q)
 820 {
 821         blk_stop_queue(q);
 822 }
 823
 824 static void stop_queue(struct request_queue *q)
 825 {
 826         unsigned long flags;
 827
 828         spin_lock_irqsave(q->queue_lock, flags);
 829         __stop_queue(q);
 830         spin_unlock_irqrestore(q->queue_lock, flags);
 831 }
 832
 833 static void __start_queue(struct request_queue *q)
 834 {
 835         if (blk_queue_stopped(q))
 836                 blk_start_queue(q);
 837 }
 838
 839 static void start_queue(struct request_queue *q)
 840 {
 841         unsigned long flags;
 842
 843         spin_lock_irqsave(q->queue_lock, flags);
 844         __start_queue(q);
 845         spin_unlock_irqrestore(q->queue_lock, flags);
 846 }
 847
 848 static void dm_done(struct request *clone, int error, bool mapped)
 849 {
 850         int r = error;
 851         struct dm_rq_target_io *tio = clone->end_io_data;
 852         dm_request_endio_fn rq_end_io = tio->ti->type->rq_end_io;
 853
 854         if (mapped && rq_end_io)
 855                 r = rq_end_io(tio->ti, clone, error, &tio->info);
 856
 857         if (r <= 0)
 858                 /* The target wants to complete the I/O */
 859                 dm_end_request(clone, r);
 860         else if (r == DM_ENDIO_INCOMPLETE)
 861                 /* The target will handle the I/O */
 862                 return;
 863         else if (r == DM_ENDIO_REQUEUE)
 864                 /* The target wants to requeue the I/O */
 865                 dm_requeue_unmapped_request(clone);
 866         else {
 867                 DMWARN("unimplemented target endio return value: %d", r);
 868                 BUG();
 869         }
 870 }
 871
 872 /*
 873  * Request completion handler for request-based dm
 874  */
 875 static void dm_softirq_done(struct request *rq)
 876 {
 877         bool mapped = true;
 878         struct request *clone = rq->completion_data;
 879         struct dm_rq_target_io *tio = clone->end_io_data;
 880
 881         if (rq->cmd_flags & REQ_FAILED)
 882                 mapped = false;
 883
 884         dm_done(clone, tio->error, mapped);
 885 }
 886
 887 /*
 888  * Complete the clone and the original request with the error status
 889  * through softirq context.
 890  */
 891 static void dm_complete_request(struct request *clone, int error)
 892 {
 893         struct dm_rq_target_io *tio = clone->end_io_data;
 894         struct request *rq = tio->orig;
 895
 896         tio->error = error;
 897         rq->completion_data = clone;
 898         blk_complete_request(rq);
 899 }
 900
 901 /*
 902  * Complete the not-mapped clone and the original request with the error status
 903  * through softirq context.
 904  * Target's rq_end_io() function isn't called.
 905  * This may be used when the target's map_rq() function fails.
 906  */
 907 void dm_kill_unmapped_request(struct request *clone, int error)
 908 {
 909         struct dm_rq_target_io *tio = clone->end_io_data;
 910         struct request *rq = tio->orig;
 911
 912         rq->cmd_flags |= REQ_FAILED;
 913         dm_complete_request(clone, error);
 914 }
 915 EXPORT_SYMBOL_GPL(dm_kill_unmapped_request);
 916
 917 /*
 918  * Called with the queue lock held
 919  */
 920 static void end_clone_request(struct request *clone, int error)
 921 {
 922         /*
 923          * For just cleaning up the information of the queue in which
 924          * the clone was dispatched.
 925          * The clone is *NOT* freed actually here because it is alloced from
 926          * dm own mempool and REQ_ALLOCED isn't set in clone->cmd_flags.
 927          */
 928         __blk_put_request(clone->q, clone);
 929
 930         /*
 931          * Actual request completion is done in a softirq context which doesn't
 932          * hold the queue lock.  Otherwise, deadlock could occur because:
 933          *     - another request may be submitted by the upper level driver
 934          *       of the stacking during the completion
 935          *     - the submission which requires queue lock may be done
 936          *       against this queue
 937          */
 938         dm_complete_request(clone, error);
 939 }
 940
 941 /*
 942  * Return maximum size of I/O possible at the supplied sector up to the current
 943  * target boundary.
 944  */
 945 static sector_t max_io_len_target_boundary(sector_t sector, struct dm_target *ti)
 946 {
 947         sector_t target_offset = dm_target_offset(ti, sector);
 948
 949         return ti->len - target_offset;
 950 }
 951
 952 static sector_t max_io_len(sector_t sector, struct dm_target *ti)
 953 {
 954         sector_t len = max_io_len_target_boundary(sector, ti);
 955
 956         /*
 957          * Does the target need to split even further ?
 958          */
 959         if (ti->split_io) {
 960                 sector_t boundary;
 961                 sector_t offset = dm_target_offset(ti, sector);
 962                 boundary = ((offset + ti->split_io) & ~(ti->split_io - 1))
 963                            - offset;
 964                 if (len > boundary)
 965                         len = boundary;
 966         }
 967
 968         return len;
 969 }
 970
 971 static void __map_bio(struct dm_target *ti, struct bio *clone,
 972                       struct dm_target_io *tio)
 973 {
 974         int r;
 975         sector_t sector;
 976         struct mapped_device *md;
 977
 978         clone->bi_end_io = clone_endio;
 979         clone->bi_private = tio;
 980
 981         /*
 982          * Map the clone.  If r == 0 we don't need to do
 983          * anything, the target has assumed ownership of
 984          * this io.
 985          */
 986         atomic_inc(&tio->io->io_count);
 987         sector = clone->bi_sector;
 988         r = ti->type->map(ti, clone, &tio->info);
 989         if (r == DM_MAPIO_REMAPPED) {
 990                 /* the bio has been remapped so dispatch it */
 991
 992                 trace_block_bio_remap(bdev_get_queue(clone->bi_bdev), clone,
 993                                       tio->io->bio->bi_bdev->bd_dev, sector);
 994
 995                 generic_make_request(clone);
 996         } else if (r < 0 || r == DM_MAPIO_REQUEUE) {
 997                 /* error the io and bail out, or requeue it if needed */
 998                 md = tio->io->md;
 999                 dec_pending(tio->io, r);
1000                 /*
1001                  * Store bio_set for cleanup.
1002                  */
1003                 clone->bi_private = md->bs;
1004                 bio_put(clone);
1005                 free_tio(md, tio);
1006         } else if (r) {
1007                 DMWARN("unimplemented target map return value: %d", r);
1008                 BUG();
1009         }
1010 }
1011
1012 struct clone_info {
1013         struct mapped_device *md;
1014         struct dm_table *map;
1015         struct bio *bio;
1016         struct dm_io *io;
1017         sector_t sector;
1018         sector_t sector_count;
1019         unsigned short idx;
1020 };
1021
1022 static void dm_bio_destructor(struct bio *bio)
1023 {
1024         struct bio_set *bs = bio->bi_private;
1025
1026         bio_free(bio, bs);
1027 }
1028
1029 /*
1030  * Creates a little bio that just does part of a bvec.
1031  */
1032 static struct bio *split_bvec(struct bio *bio, sector_t sector,
1033                               unsigned short idx, unsigned int offset,
1034                               unsigned int len, struct bio_set *bs)
1035 {
1036         struct bio *clone;
1037         struct bio_vec *bv = bio->bi_io_vec + idx;
1038
1039         clone = bio_alloc_bioset(GFP_NOIO, 1, bs);
1040         clone->bi_destructor = dm_bio_destructor;
1041         *clone->bi_io_vec = *bv;
1042
1043         clone->bi_sector = sector;
1044         clone->bi_bdev = bio->bi_bdev;
1045         clone->bi_rw = bio->bi_rw;
1046         clone->bi_vcnt = 1;
1047         clone->bi_size = to_bytes(len);
1048         clone->bi_io_vec->bv_offset = offset;
1049         clone->bi_io_vec->bv_len = clone->bi_size;
1050         clone->bi_flags |= 1 << BIO_CLONED;
1051
1052         if (bio_integrity(bio)) {
1053                 bio_integrity_clone(clone, bio, GFP_NOIO, bs);
1054                 bio_integrity_trim(clone,
1055                                    bio_sector_offset(bio, idx, offset), len);
1056         }
1057
1058         return clone;
1059 }
1060
1061 /*
1062  * Creates a bio that consists of range of complete bvecs.
1063  */
1064 static struct bio *clone_bio(struct bio *bio, sector_t sector,
1065                              unsigned short idx, unsigned short bv_count,
1066                              unsigned int len, struct bio_set *bs)
1067 {
1068         struct bio *clone;
1069
1070         clone = bio_alloc_bioset(GFP_NOIO, bio->bi_max_vecs, bs);
1071         __bio_clone(clone, bio);
1072         clone->bi_destructor = dm_bio_destructor;
1073         clone->bi_sector = sector;
1074         clone->bi_idx = idx;
1075         clone->bi_vcnt = idx + bv_count;
1076         clone->bi_size = to_bytes(len);
1077         clone->bi_flags &= ~(1 << BIO_SEG_VALID);
1078
1079         if (bio_integrity(bio)) {
1080                 bio_integrity_clone(clone, bio, GFP_NOIO, bs);
1081
1082                 if (idx != bio->bi_idx || clone->bi_size < bio->bi_size)
1083                         bio_integrity_trim(clone,
1084                                            bio_sector_offset(bio, idx, 0), len);
1085         }
1086
1087         return clone;
1088 }
1089
1090 static struct dm_target_io *alloc_tio(struct clone_info *ci,
1091                                       struct dm_target *ti)
1092 {
1093         struct dm_target_io *tio = mempool_alloc(ci->md->tio_pool, GFP_NOIO);
1094
1095         tio->io = ci->io;
1096         tio->ti = ti;
1097         memset(&tio->info, 0, sizeof(tio->info));
1098
1099         return tio;
1100 }
1101
1102 static void __issue_target_request(struct clone_info *ci, struct dm_target *ti,
1103                                    unsigned request_nr, sector_t len)
1104 {
1105         struct dm_target_io *tio = alloc_tio(ci, ti);
1106         struct bio *clone;
1107
1108         tio->info.target_request_nr = request_nr;
1109
1110         /*
1111          * Discard requests require the bio's inline iovecs be initialized.
1112          * ci->bio->bi_max_vecs is BIO_INLINE_VECS anyway, for both flush
1113          * and discard, so no need for concern about wasted bvec allocations.
1114          */
1115         clone = bio_alloc_bioset(GFP_NOIO, ci->bio->bi_max_vecs, ci->md->bs);
1116         __bio_clone(clone, ci->bio);
1117         clone->bi_destructor = dm_bio_destructor;
1118         if (len) {
1119                 clone->bi_sector = ci->sector;
1120                 clone->bi_size = to_bytes(len);
1121         }
1122
1123         __map_bio(ti, clone, tio);
1124 }
1125
1126 static void __issue_target_requests(struct clone_info *ci, struct dm_target *ti,
1127                                     unsigned num_requests, sector_t len)
1128 {
1129         unsigned request_nr;
1130
1131         for (request_nr = 0; request_nr < num_requests; request_nr++)
1132                 __issue_target_request(ci, ti, request_nr, len);
1133 }
1134
1135 static int __clone_and_map_empty_flush(struct clone_info *ci)
1136 {
1137         unsigned target_nr = 0;
1138         struct dm_target *ti;
1139
1140         BUG_ON(bio_has_data(ci->bio));
1141         while ((ti = dm_table_get_target(ci->map, target_nr++)))
1142                 __issue_target_requests(ci, ti, ti->num_flush_requests, 0);
1143
1144         return 0;
1145 }
1146
1147 /*
1148  * Perform all io with a single clone.
1149  */
1150 static void __clone_and_map_simple(struct clone_info *ci, struct dm_target *ti)
1151 {
1152         struct bio *clone, *bio = ci->bio;
1153         struct dm_target_io *tio;
1154
1155         tio = alloc_tio(ci, ti);
1156         clone = clone_bio(bio, ci->sector, ci->idx,
1157                           bio->bi_vcnt - ci->idx, ci->sector_count,
1158                           ci->md->bs);
1159         __map_bio(ti, clone, tio);
1160         ci->sector_count = 0;
1161 }
1162
1163 static int __clone_and_map_discard(struct clone_info *ci)
1164 {
1165         struct dm_target *ti;
1166         sector_t len;
1167
1168         do {
1169                 ti = dm_table_find_target(ci->map, ci->sector);
1170                 if (!dm_target_is_valid(ti))
1171                         return -EIO;
1172
1173                 /*
1174                  * Even though the device advertised discard support,
1175                  * reconfiguration might have changed that since the
1176                  * check was performed.
1177                  */
1178                 if (!ti->num_discard_requests)
1179                         return -EOPNOTSUPP;
1180
1181                 len = min(ci->sector_count, max_io_len_target_boundary(ci->sector, ti));
1182
1183                 __issue_target_requests(ci, ti, ti->num_discard_requests, len);
1184
1185                 ci->sector += len;
1186         } while (ci->sector_count -= len);
1187
1188         return 0;
1189 }
1190
1191 static int __clone_and_map(struct clone_info *ci)
1192 {
1193         struct bio *clone, *bio = ci->bio;
1194         struct dm_target *ti;
1195         sector_t len = 0, max;
1196         struct dm_target_io *tio;
1197
1198         if (unlikely(bio->bi_rw & REQ_DISCARD))
1199                 return __clone_and_map_discard(ci);
1200
1201         ti = dm_table_find_target(ci->map, ci->sector);
1202         if (!dm_target_is_valid(ti))
1203                 return -EIO;
1204
1205         max = max_io_len(ci->sector, ti);
1206
1207         if (ci->sector_count <= max) {
1208                 /*
1209                  * Optimise for the simple case where we can do all of
1210                  * the remaining io with a single clone.
1211                  */
1212                 __clone_and_map_simple(ci, ti);
1213
1214         } else if (to_sector(bio->bi_io_vec[ci->idx].bv_len) <= max) {
1215                 /*
1216                  * There are some bvecs that don't span targets.
1217                  * Do as many of these as possible.
1218                  */
1219                 int i;
1220                 sector_t remaining = max;
1221                 sector_t bv_len;
1222
1223                 for (i = ci->idx; remaining && (i < bio->bi_vcnt); i++) {
1224                         bv_len = to_sector(bio->bi_io_vec[i].bv_len);
1225
1226                         if (bv_len > remaining)
1227                                 break;
1228
1229                         remaining -= bv_len;
1230                         len += bv_len;
1231                 }
1232
1233                 tio = alloc_tio(ci, ti);
1234                 clone = clone_bio(bio, ci->sector, ci->idx, i - ci->idx, len,
1235                                   ci->md->bs);
1236                 __map_bio(ti, clone, tio);
1237
1238                 ci->sector += len;
1239                 ci->sector_count -= len;
1240                 ci->idx = i;
1241
1242         } else {
1243                 /*
1244                  * Handle a bvec that must be split between two or more targets.
1245                  */
1246                 struct bio_vec *bv = bio->bi_io_vec + ci->idx;
1247                 sector_t remaining = to_sector(bv->bv_len);
1248                 unsigned int offset = 0;
1249
1250                 do {
1251                         if (offset) {
1252                                 ti = dm_table_find_target(ci->map, ci->sector);
1253                                 if (!dm_target_is_valid(ti))
1254                                         return -EIO;
1255
1256                                 max = max_io_len(ci->sector, ti);
1257                         }
1258
1259                         len = min(remaining, max);
1260
1261                         tio = alloc_tio(ci, ti);
1262                         clone = split_bvec(bio, ci->sector, ci->idx,
1263                                            bv->bv_offset + offset, len,
1264                                            ci->md->bs);
1265
1266                         __map_bio(ti, clone, tio);
1267
1268                         ci->sector += len;
1269                         ci->sector_count -= len;
1270                         offset += to_bytes(len);
1271                 } while (remaining -= len);
1272
1273                 ci->idx++;
1274         }
1275
1276         return 0;
1277 }
1278
1279 /*
1280  * Split the bio into several clones and submit it to targets.
1281  */
1282 static void __split_and_process_bio(struct mapped_device *md, struct bio *bio)
1283 {
1284         struct clone_info ci;
1285         int error = 0;
1286
1287         ci.map = dm_get_live_table(md);
1288         if (unlikely(!ci.map)) {
1289                 bio_io_error(bio);
1290                 return;
1291         }
1292
1293         ci.md = md;
1294         ci.io = alloc_io(md);
1295         ci.io->error = 0;
1296         atomic_set(&ci.io->io_count, 1);
1297         ci.io->bio = bio;
1298         ci.io->md = md;
1299         spin_lock_init(&ci.io->endio_lock);
1300         ci.sector = bio->bi_sector;
1301         ci.idx = bio->bi_idx;
1302
1303         start_io_acct(ci.io);
1304         if (bio->bi_rw & REQ_FLUSH) {
1305                 ci.bio = &ci.md->flush_bio;
1306                 ci.sector_count = 0;
1307                 error = __clone_and_map_empty_flush(&ci);
1308                 /* dec_pending submits any data associated with flush */
1309         } else {
1310                 ci.bio = bio;
1311                 ci.sector_count = bio_sectors(bio);
1312                 while (ci.sector_count && !error)
1313                         error = __clone_and_map(&ci);
1314         }
1315
1316         /* drop the extra reference count */
1317         dec_pending(ci.io, error);
1318         dm_table_put(ci.map);
1319 }
1320 /*-----------------------------------------------------------------
1321  * CRUD END
1322  *---------------------------------------------------------------*/
1323
1324 static int dm_merge_bvec(struct request_queue *q,
1325                          struct bvec_merge_data *bvm,
1326                          struct bio_vec *biovec)
1327 {
1328         struct mapped_device *md = q->queuedata;
1329         struct dm_table *map = dm_get_live_table(md);
1330         struct dm_target *ti;
1331         sector_t max_sectors;
1332         int max_size = 0;
1333
1334         if (unlikely(!map))
1335                 goto out;
1336
1337         ti = dm_table_find_target(map, bvm->bi_sector);
1338         if (!dm_target_is_valid(ti))
1339                 goto out_table;
1340
1341         /*
1342          * Find maximum amount of I/O that won't need splitting
1343          */
1344         max_sectors = min(max_io_len(bvm->bi_sector, ti),
1345                           (sector_t) BIO_MAX_SECTORS);
1346         max_size = (max_sectors << SECTOR_SHIFT) - bvm->bi_size;
1347         if (max_size < 0)
1348                 max_size = 0;
1349
1350         /*
1351          * merge_bvec_fn() returns number of bytes
1352          * it can accept at this offset
1353          * max is precomputed maximal io size
1354          */
1355         if (max_size && ti->type->merge)
1356                 max_size = ti->type->merge(ti, bvm, biovec, max_size);
1357         /*
1358          * If the target doesn't support merge method and some of the devices
1359          * provided their merge_bvec method (we know this by looking at
1360          * queue_max_hw_sectors), then we can't allow bios with multiple vector
1361          * entries.  So always set max_size to 0, and the code below allows
1362          * just one page.
1363          */
1364         else if (queue_max_hw_sectors(q) <= PAGE_SIZE >> 9)
1365
1366                 max_size = 0;
1367
1368 out_table:
1369         dm_table_put(map);
1370
1371 out:
1372         /*
1373          * Always allow an entire first page
1374          */
1375         if (max_size <= biovec->bv_len && !(bvm->bi_size >> SECTOR_SHIFT))
1376                 max_size = biovec->bv_len;
1377
1378         return max_size;
1379 }
1380
1381 /*
1382  * The request function that just remaps the bio built up by
1383  * dm_merge_bvec.
1384  */
1385 static int _dm_request(struct request_queue *q, struct bio *bio)
1386 {
1387         int rw = bio_data_dir(bio);
1388         struct mapped_device *md = q->queuedata;
1389         int cpu;
1390
1391         down_read(&md->io_lock);
1392
1393         cpu = part_stat_lock();
1394         part_stat_inc(cpu, &dm_disk(md)->part0, ios[rw]);
1395         part_stat_add(cpu, &dm_disk(md)->part0, sectors[rw], bio_sectors(bio));
1396         part_stat_unlock();
1397
1398         /* if we're suspended, we have to queue this io for later */
1399         if (unlikely(test_bit(DMF_BLOCK_IO_FOR_SUSPEND, &md->flags))) {
1400                 up_read(&md->io_lock);
1401
1402                 if (bio_rw(bio) != READA)
1403                         queue_io(md, bio);
1404                 else
1405                         bio_io_error(bio);
1406                 return 0;
1407         }
1408
1409         __split_and_process_bio(md, bio);
1410         up_read(&md->io_lock);
1411         return 0;
1412 }
1413
1414 static int dm_make_request(struct request_queue *q, struct bio *bio)
1415 {
1416         struct mapped_device *md = q->queuedata;
1417
1418         return md->saved_make_request_fn(q, bio); /* call __make_request() */
1419 }
1420
1421 static int dm_request_based(struct mapped_device *md)
1422 {
1423         return blk_queue_stackable(md->queue);
1424 }
1425
1426 static int dm_request(struct request_queue *q, struct bio *bio)
1427 {
1428         struct mapped_device *md = q->queuedata;
1429
1430         if (dm_request_based(md))
1431                 return dm_make_request(q, bio);
1432
1433         return _dm_request(q, bio);
1434 }
1435
1436 void dm_dispatch_request(struct request *rq)
1437 {
1438         int r;
1439
1440         if (blk_queue_io_stat(rq->q))
1441                 rq->cmd_flags |= REQ_IO_STAT;
1442
1443         rq->start_time = jiffies;
1444         r = blk_insert_cloned_request(rq->q, rq);
1445         if (r)
1446                 dm_complete_request(rq, r);
1447 }
1448 EXPORT_SYMBOL_GPL(dm_dispatch_request);
1449
1450 static void dm_rq_bio_destructor(struct bio *bio)
1451 {
1452         struct dm_rq_clone_bio_info *info = bio->bi_private;
1453         struct mapped_device *md = info->tio->md;
1454
1455         free_bio_info(info);
1456         bio_free(bio, md->bs);
1457 }
1458
1459 static int dm_rq_bio_constructor(struct bio *bio, struct bio *bio_orig,
1460                                  void *data)
1461 {
1462         struct dm_rq_target_io *tio = data;
1463         struct mapped_device *md = tio->md;
1464         struct dm_rq_clone_bio_info *info = alloc_bio_info(md);
1465
1466         if (!info)
1467                 return -ENOMEM;
1468
1469         info->orig = bio_orig;
1470         info->tio = tio;
1471         bio->bi_end_io = end_clone_bio;
1472         bio->bi_private = info;
1473         bio->bi_destructor = dm_rq_bio_destructor;
1474
1475         return 0;
1476 }
1477
1478 static int setup_clone(struct request *clone, struct request *rq,
1479                        struct dm_rq_target_io *tio)
1480 {
1481         int r;
1482
1483         r = blk_rq_prep_clone(clone, rq, tio->md->bs, GFP_ATOMIC,
1484                               dm_rq_bio_constructor, tio);
1485         if (r)
1486                 return r;
1487
1488         clone->cmd = rq->cmd;
1489         clone->cmd_len = rq->cmd_len;
1490         clone->sense = rq->sense;
1491         clone->buffer = rq->buffer;
1492         clone->end_io = end_clone_request;
1493         clone->end_io_data = tio;
1494
1495         return 0;
1496 }
1497
1498 static struct request *clone_rq(struct request *rq, struct mapped_device *md,
1499                                 gfp_t gfp_mask)
1500 {
1501         struct request *clone;
1502         struct dm_rq_target_io *tio;
1503
1504         tio = alloc_rq_tio(md, gfp_mask);
1505         if (!tio)
1506                 return NULL;
1507
1508         tio->md = md;
1509         tio->ti = NULL;
1510         tio->orig = rq;
1511         tio->error = 0;
1512         memset(&tio->info, 0, sizeof(tio->info));
1513
1514         clone = &tio->clone;
1515         if (setup_clone(clone, rq, tio)) {
1516                 /* -ENOMEM */
1517                 free_rq_tio(tio);
1518                 return NULL;
1519         }
1520
1521         return clone;
1522 }
1523
1524 /*
1525  * Called with the queue lock held.
1526  */
1527 static int dm_prep_fn(struct request_queue *q, struct request *rq)
1528 {
1529         struct mapped_device *md = q->queuedata;
1530         struct request *clone;
1531
1532         if (unlikely(rq->special)) {
1533                 DMWARN("Already has something in rq->special.");
1534                 return BLKPREP_KILL;
1535         }
1536
1537         clone = clone_rq(rq, md, GFP_ATOMIC);
1538         if (!clone)
1539                 return BLKPREP_DEFER;
1540
1541         rq->special = clone;
1542         rq->cmd_flags |= REQ_DONTPREP;
1543
1544         return BLKPREP_OK;
1545 }
1546
1547 /*
1548  * Returns:
1549  * 0  : the request has been processed (not requeued)
1550  * !0 : the request has been requeued
1551  */
1552 static int map_request(struct dm_target *ti, struct request *clone,
1553                        struct mapped_device *md)
1554 {
1555         int r, requeued = 0;
1556         struct dm_rq_target_io *tio = clone->end_io_data;
1557
1558         /*
1559          * Hold the md reference here for the in-flight I/O.
1560          * We can't rely on the reference count by device opener,
1561          * because the device may be closed during the request completion
1562          * when all bios are completed.
1563          * See the comment in rq_completed() too.
1564          */
1565         dm_get(md);
1566
1567         tio->ti = ti;
1568         r = ti->type->map_rq(ti, clone, &tio->info);
1569         switch (r) {
1570         case DM_MAPIO_SUBMITTED:
1571                 /* The target has taken the I/O to submit by itself later */
1572                 break;
1573         case DM_MAPIO_REMAPPED:
1574                 /* The target has remapped the I/O so dispatch it */
1575                 trace_block_rq_remap(clone->q, clone, disk_devt(dm_disk(md)),
1576                                      blk_rq_pos(tio->orig));
1577                 dm_dispatch_request(clone);
1578                 break;
1579         case DM_MAPIO_REQUEUE:
1580                 /* The target wants to requeue the I/O */
1581                 dm_requeue_unmapped_request(clone);
1582                 requeued = 1;
1583                 break;
1584         default:
1585                 if (r > 0) {
1586                         DMWARN("unimplemented target map return value: %d", r);
1587                         BUG();
1588                 }
1589
1590                 /* The target wants to complete the I/O */
1591                 dm_kill_unmapped_request(clone, r);
1592                 break;
1593         }
1594
1595         return requeued;
1596 }
1597
1598 /*
1599  * q->request_fn for request-based dm.
1600  * Called with the queue lock held.
1601  */
1602 static void dm_request_fn(struct request_queue *q)
1603 {
1604         struct mapped_device *md = q->queuedata;
1605         struct dm_table *map = dm_get_live_table(md);
1606         struct dm_target *ti;
1607         struct request *rq, *clone;
1608         sector_t pos;
1609
1610         /*
1611          * For suspend, check blk_queue_stopped() and increment
1612          * ->pending within a single queue_lock not to increment the
1613          * number of in-flight I/Os after the queue is stopped in
1614          * dm_suspend().
1615          */
1616         while (!blk_queue_plugged(q) && !blk_queue_stopped(q)) {
1617                 rq = blk_peek_request(q);
1618                 if (!rq)
1619                         goto plug_and_out;
1620
1621                 /* always use block 0 to find the target for flushes for now */
1622                 pos = 0;
1623                 if (!(rq->cmd_flags & REQ_FLUSH))
1624                         pos = blk_rq_pos(rq);
1625
1626                 ti = dm_table_find_target(map, pos);
1627                 BUG_ON(!dm_target_is_valid(ti));
1628
1629                 if (ti->type->busy && ti->type->busy(ti))
1630                         goto plug_and_out;
1631
1632                 blk_start_request(rq);
1633                 clone = rq->special;
1634                 atomic_inc(&md->pending[rq_data_dir(clone)]);
1635
1636                 spin_unlock(q->queue_lock);
1637                 if (map_request(ti, clone, md))
1638                         goto requeued;
1639
1640                 BUG_ON(!irqs_disabled());
1641                 spin_lock(q->queue_lock);
1642         }
1643
1644         goto out;
1645
1646 requeued:
1647         BUG_ON(!irqs_disabled());
1648         spin_lock(q->queue_lock);
1649
1650 plug_and_out:
1651         if (!elv_queue_empty(q))
1652                 /* Some requests still remain, retry later */
1653                 blk_plug_device(q);
1654
1655 out:
1656         dm_table_put(map);
1657
1658         return;
1659 }
1660
1661 int dm_underlying_device_busy(struct request_queue *q)
1662 {
1663         return blk_lld_busy(q);
1664 }
1665 EXPORT_SYMBOL_GPL(dm_underlying_device_busy);
1666
1667 static int dm_lld_busy(struct request_queue *q)
1668 {
1669         int r;
1670         struct mapped_device *md = q->queuedata;
1671         struct dm_table *map = dm_get_live_table(md);
1672
1673         if (!map || test_bit(DMF_BLOCK_IO_FOR_SUSPEND, &md->flags))
1674                 r = 1;
1675         else
1676                 r = dm_table_any_busy_target(map);
1677
1678         dm_table_put(map);
1679
1680         return r;
1681 }
1682
1683 static void dm_unplug_all(struct request_queue *q)
1684 {
1685         struct mapped_device *md = q->queuedata;
1686         struct dm_table *map = dm_get_live_table(md);
1687
1688         if (map) {
1689                 if (dm_request_based(md))
1690                         generic_unplug_device(q);
1691
1692                 dm_table_unplug_all(map);
1693                 dm_table_put(map);
1694         }
1695 }
1696
1697 static int dm_any_congested(void *congested_data, int bdi_bits)
1698 {
1699         int r = bdi_bits;
1700         struct mapped_device *md = congested_data;
1701         struct dm_table *map;
1702
1703         if (!test_bit(DMF_BLOCK_IO_FOR_SUSPEND, &md->flags)) {
1704                 map = dm_get_live_table(md);
1705                 if (map) {
1706                         /*
1707                          * Request-based dm cares about only own queue for
1708                          * the query about congestion status of request_queue
1709                          */
1710                         if (dm_request_based(md))
1711                                 r = md->queue->backing_dev_info.state &
1712                                     bdi_bits;
1713                         else
1714                                 r = dm_table_any_congested(map, bdi_bits);
1715
1716                         dm_table_put(map);
1717                 }
1718         }
1719
1720         return r;
1721 }
1722
1723 /*-----------------------------------------------------------------
1724  * An IDR is used to keep track of allocated minor numbers.
1725  *---------------------------------------------------------------*/
1726 static DEFINE_IDR(_minor_idr);
1727
1728 static void free_minor(int minor)
1729 {
1730         spin_lock(&_minor_lock);
1731         idr_remove(&_minor_idr, minor);
1732         spin_unlock(&_minor_lock);
1733 }
1734
1735 /*
1736  * See if the device with a specific minor # is free.
1737  */
1738 static int specific_minor(int minor)
1739 {
1740         int r, m;
1741
1742         if (minor >= (1 << MINORBITS))
1743                 return -EINVAL;
1744
1745         r = idr_pre_get(&_minor_idr, GFP_KERNEL);
1746         if (!r)
1747                 return -ENOMEM;
1748
1749         spin_lock(&_minor_lock);
1750
1751         if (idr_find(&_minor_idr, minor)) {
1752                 r = -EBUSY;
1753                 goto out;
1754         }
1755
1756         r = idr_get_new_above(&_minor_idr, MINOR_ALLOCED, minor, &m);
1757         if (r)
1758                 goto out;
1759
1760         if (m != minor) {
1761                 idr_remove(&_minor_idr, m);
1762                 r = -EBUSY;
1763                 goto out;
1764         }
1765
1766 out:
1767         spin_unlock(&_minor_lock);
1768         return r;
1769 }
1770
1771 static int next_free_minor(int *minor)
1772 {
1773         int r, m;
1774
1775         r = idr_pre_get(&_minor_idr, GFP_KERNEL);
1776         if (!r)
1777                 return -ENOMEM;
1778
1779         spin_lock(&_minor_lock);
1780
1781         r = idr_get_new(&_minor_idr, MINOR_ALLOCED, &m);
1782         if (r)
1783                 goto out;
1784
1785         if (m >= (1 << MINORBITS)) {
1786                 idr_remove(&_minor_idr, m);
1787                 r = -ENOSPC;
1788                 goto out;
1789         }
1790
1791         *minor = m;
1792
1793 out:
1794         spin_unlock(&_minor_lock);
1795         return r;
1796 }
1797
1798 static const struct block_device_operations dm_blk_dops;
1799
1800 static void dm_wq_work(struct work_struct *work);
1801
1802 static void dm_init_md_queue(struct mapped_device *md)
1803 {
1804         /*
1805          * Request-based dm devices cannot be stacked on top of bio-based dm
1806          * devices.  The type of this dm device has not been decided yet.
1807          * The type is decided at the first table loading time.
1808          * To prevent problematic device stacking, clear the queue flag
1809          * for request stacking support until then.
1810          *
1811          * This queue is new, so no concurrency on the queue_flags.
1812          */
1813         queue_flag_clear_unlocked(QUEUE_FLAG_STACKABLE, md->queue);
1814
1815         md->queue->queuedata = md;
1816         md->queue->backing_dev_info.congested_fn = dm_any_congested;
1817         md->queue->backing_dev_info.congested_data = md;
1818         blk_queue_make_request(md->queue, dm_request);
1819         blk_queue_bounce_limit(md->queue, BLK_BOUNCE_ANY);
1820         md->queue->unplug_fn = dm_unplug_all;
1821         blk_queue_merge_bvec(md->queue, dm_merge_bvec);
1822         blk_queue_flush(md->queue, REQ_FLUSH | REQ_FUA);
1823 }
1824
1825 /*
1826  * Allocate and initialise a blank device with a given minor.
1827  */
1828 static struct mapped_device *alloc_dev(int minor)
1829 {
1830         int r;
1831         struct mapped_device *md = kzalloc(sizeof(*md), GFP_KERNEL);
1832         void *old_md;
1833
1834         if (!md) {
1835                 DMWARN("unable to allocate device, out of memory.");
1836                 return NULL;
1837         }
1838
1839         if (!try_module_get(THIS_MODULE))
1840                 goto bad_module_get;
1841
1842         /* get a minor number for the dev */
1843         if (minor == DM_ANY_MINOR)
1844                 r = next_free_minor(&minor);
1845         else
1846                 r = specific_minor(minor);
1847         if (r < 0)
1848                 goto bad_minor;
1849
1850         md->type = DM_TYPE_NONE;
1851         init_rwsem(&md->io_lock);
1852         mutex_init(&md->suspend_lock);
1853         mutex_init(&md->type_lock);
1854         spin_lock_init(&md->deferred_lock);
1855         rwlock_init(&md->map_lock);
1856         atomic_set(&md->holders, 1);
1857         atomic_set(&md->open_count, 0);
1858         atomic_set(&md->event_nr, 0);
1859         atomic_set(&md->uevent_seq, 0);
1860         INIT_LIST_HEAD(&md->uevent_list);
1861         spin_lock_init(&md->uevent_lock);
1862
1863         md->queue = blk_alloc_queue(GFP_KERNEL);
1864         if (!md->queue)
1865                 goto bad_queue;
1866
1867         dm_init_md_queue(md);
1868
1869         md->disk = alloc_disk(1);
1870         if (!md->disk)
1871                 goto bad_disk;
1872
1873         atomic_set(&md->pending[0], 0);
1874         atomic_set(&md->pending[1], 0);
1875         init_waitqueue_head(&md->wait);
1876         INIT_WORK(&md->work, dm_wq_work);
1877         init_waitqueue_head(&md->eventq);
1878
1879         md->disk->major = _major;
1880         md->disk->first_minor = minor;
1881         md->disk->fops = &dm_blk_dops;
1882         md->disk->queue = md->queue;
1883         md->disk->private_data = md;
1884         sprintf(md->disk->disk_name, "dm-%d", minor);
1885         add_disk(md->disk);
1886         format_dev_t(md->name, MKDEV(_major, minor));
1887
1888         md->wq = alloc_workqueue("kdmflush",
1889                                  WQ_NON_REENTRANT | WQ_MEM_RECLAIM, 0);
1890         if (!md->wq)
1891                 goto bad_thread;
1892
1893         md->bdev = bdget_disk(md->disk, 0);
1894         if (!md->bdev)
1895                 goto bad_bdev;
1896
1897         bio_init(&md->flush_bio);
1898         md->flush_bio.bi_bdev = md->bdev;
1899         md->flush_bio.bi_rw = WRITE_FLUSH;
1900
1901         /* Populate the mapping, nobody knows we exist yet */
1902         spin_lock(&_minor_lock);
1903         old_md = idr_replace(&_minor_idr, md, minor);
1904         spin_unlock(&_minor_lock);
1905
1906         BUG_ON(old_md != MINOR_ALLOCED);
1907
1908         return md;
1909
1910 bad_bdev:
1911         destroy_workqueue(md->wq);
1912 bad_thread:
1913         del_gendisk(md->disk);
1914         put_disk(md->disk);
1915 bad_disk:
1916         blk_cleanup_queue(md->queue);
1917 bad_queue:
1918         free_minor(minor);
1919 bad_minor:
1920         module_put(THIS_MODULE);
1921 bad_module_get:
1922         kfree(md);
1923         return NULL;
1924 }
1925
1926 static void unlock_fs(struct mapped_device *md);
1927
1928 static void free_dev(struct mapped_device *md)
1929 {
1930         int minor = MINOR(disk_devt(md->disk));
1931
1932         unlock_fs(md);
1933         bdput(md->bdev);
1934         destroy_workqueue(md->wq);
1935         if (md->tio_pool)
1936                 mempool_destroy(md->tio_pool);
1937         if (md->io_pool)
1938                 mempool_destroy(md->io_pool);
1939         if (md->bs)
1940                 bioset_free(md->bs);
1941         blk_integrity_unregister(md->disk);
1942         del_gendisk(md->disk);
1943         free_minor(minor);
1944
1945         spin_lock(&_minor_lock);
1946         md->disk->private_data = NULL;
1947         spin_unlock(&_minor_lock);
1948
1949         put_disk(md->disk);
1950         blk_cleanup_queue(md->queue);
1951         module_put(THIS_MODULE);
1952         kfree(md);
1953 }
1954
1955 static void __bind_mempools(struct mapped_device *md, struct dm_table *t)
1956 {
1957         struct dm_md_mempools *p;
1958
1959         if (md->io_pool && md->tio_pool && md->bs)
1960                 /* the md already has necessary mempools */
1961                 goto out;
1962
1963         p = dm_table_get_md_mempools(t);
1964         BUG_ON(!p || md->io_pool || md->tio_pool || md->bs);
1965
1966         md->io_pool = p->io_pool;
1967         p->io_pool = NULL;
1968         md->tio_pool = p->tio_pool;
1969         p->tio_pool = NULL;
1970         md->bs = p->bs;
1971         p->bs = NULL;
1972
1973 out:
1974         /* mempool bind completed, now no need any mempools in the table */
1975         dm_table_free_md_mempools(t);
1976 }
1977
1978 /*
1979  * Bind a table to the device.
1980  */
1981 static void event_callback(void *context)
1982 {
1983         unsigned long flags;
1984         LIST_HEAD(uevents);
1985         struct mapped_device *md = (struct mapped_device *) context;
1986
1987         spin_lock_irqsave(&md->uevent_lock, flags);
1988         list_splice_init(&md->uevent_list, &uevents);
1989         spin_unlock_irqrestore(&md->uevent_lock, flags);
1990
1991         dm_send_uevents(&uevents, &disk_to_dev(md->disk)->kobj);
1992
1993         atomic_inc(&md->event_nr);
1994         wake_up(&md->eventq);
1995 }
1996
1997 /*
1998  * Protected by md->suspend_lock obtained by dm_swap_table().
1999  */
2000 static void __set_size(struct mapped_device *md, sector_t size)
2001 {
2002         set_capacity(md->disk, size);
2003
2004         i_size_write(md->bdev->bd_inode, (loff_t)size << SECTOR_SHIFT);
2005 }
2006
2007 /*
2008  * Returns old map, which caller must destroy.
2009  */
2010 static struct dm_table *__bind(struct mapped_device *md, struct dm_table *t,
2011                                struct queue_limits *limits)
2012 {
2013         struct dm_table *old_map;
2014         struct request_queue *q = md->queue;
2015         sector_t size;
2016         unsigned long flags;
2017
2018         size = dm_table_get_size(t);
2019
2020         /*
2021          * Wipe any geometry if the size of the table changed.
2022          */
2023         if (size != get_capacity(md->disk))
2024                 memset(&md->geometry, 0, sizeof(md->geometry));
2025
2026         __set_size(md, size);
2027
2028         dm_table_event_callback(t, event_callback, md);
2029
2030         /*
2031          * The queue hasn't been stopped yet, if the old table type wasn't
2032          * for request-based during suspension.  So stop it to prevent
2033          * I/O mapping before resume.
2034          * This must be done before setting the queue restrictions,
2035          * because request-based dm may be run just after the setting.
2036          */
2037         if (dm_table_request_based(t) && !blk_queue_stopped(q))
2038                 stop_queue(q);
2039
2040         __bind_mempools(md, t);
2041
2042         write_lock_irqsave(&md->map_lock, flags);
2043         old_map = md->map;
2044         md->map = t;
2045         dm_table_set_restrictions(t, q, limits);
2046         write_unlock_irqrestore(&md->map_lock, flags);
2047
2048         return old_map;
2049 }
2050
2051 /*
2052  * Returns unbound table for the caller to free.
2053  */
2054 static struct dm_table *__unbind(struct mapped_device *md)
2055 {
2056         struct dm_table *map = md->map;
2057         unsigned long flags;
2058
2059         if (!map)
2060                 return NULL;
2061
2062         dm_table_event_callback(map, NULL, NULL);
2063         write_lock_irqsave(&md->map_lock, flags);
2064         md->map = NULL;
2065         write_unlock_irqrestore(&md->map_lock, flags);
2066
2067         return map;
2068 }
2069
2070 /*
2071  * Constructor for a new device.
2072  */
2073 int dm_create(int minor, struct mapped_device **result)
2074 {
2075         struct mapped_device *md;
2076
2077         md = alloc_dev(minor);
2078         if (!md)
2079                 return -ENXIO;
2080
2081         dm_sysfs_init(md);
2082
2083         *result = md;
2084         return 0;
2085 }
2086
2087 /*
2088  * Functions to manage md->type.
2089  * All are required to hold md->type_lock.
2090  */
2091 void dm_lock_md_type(struct mapped_device *md)
2092 {
2093         mutex_lock(&md->type_lock);
2094 }
2095
2096 void dm_unlock_md_type(struct mapped_device *md)
2097 {
2098         mutex_unlock(&md->type_lock);
2099 }
2100
2101 void dm_set_md_type(struct mapped_device *md, unsigned type)
2102 {
2103         md->type = type;
2104 }
2105
2106 unsigned dm_get_md_type(struct mapped_device *md)
2107 {
2108         return md->type;
2109 }
2110
2111 /*
2112  * Fully initialize a request-based queue (->elevator, ->request_fn, etc).
2113  */
2114 static int dm_init_request_based_queue(struct mapped_device *md)
2115 {
2116         struct request_queue *q = NULL;
2117
2118         if (md->queue->elevator)
2119                 return 1;
2120
2121         /* Fully initialize the queue */
2122         q = blk_init_allocated_queue(md->queue, dm_request_fn, NULL);
2123         if (!q)
2124                 return 0;
2125
2126         md->queue = q;
2127         md->saved_make_request_fn = md->queue->make_request_fn;
2128         dm_init_md_queue(md);
2129         blk_queue_softirq_done(md->queue, dm_softirq_done);
2130         blk_queue_prep_rq(md->queue, dm_prep_fn);
2131         blk_queue_lld_busy(md->queue, dm_lld_busy);
2132
2133         elv_register_queue(md->queue);
2134
2135         return 1;
2136 }
2137
2138 /*
2139  * Setup the DM device's queue based on md's type
2140  */
2141 int dm_setup_md_queue(struct mapped_device *md)
2142 {
2143         if ((dm_get_md_type(md) == DM_TYPE_REQUEST_BASED) &&
2144             !dm_init_request_based_queue(md)) {
2145                 DMWARN("Cannot initialize queue for request-based mapped device");
2146                 return -EINVAL;
2147         }
2148
2149         return 0;
2150 }
2151
2152 static struct mapped_device *dm_find_md(dev_t dev)
2153 {
2154         struct mapped_device *md;
2155         unsigned minor = MINOR(dev);
2156
2157         if (MAJOR(dev) != _major || minor >= (1 << MINORBITS))
2158                 return NULL;
2159
2160         spin_lock(&_minor_lock);
2161
2162         md = idr_find(&_minor_idr, minor);
2163         if (md && (md == MINOR_ALLOCED ||
2164                    (MINOR(disk_devt(dm_disk(md))) != minor) ||
2165                    dm_deleting_md(md) ||
2166                    test_bit(DMF_FREEING, &md->flags))) {
2167                 md = NULL;
2168                 goto out;
2169         }
2170
2171 out:
2172         spin_unlock(&_minor_lock);
2173
2174         return md;
2175 }
2176
2177 struct mapped_device *dm_get_md(dev_t dev)
2178 {
2179         struct mapped_device *md = dm_find_md(dev);
2180
2181         if (md)
2182                 dm_get(md);
2183
2184         return md;
2185 }
2186
2187 void *dm_get_mdptr(struct mapped_device *md)
2188 {
2189         return md->interface_ptr;
2190 }
2191
2192 void dm_set_mdptr(struct mapped_device *md, void *ptr)
2193 {
2194         md->interface_ptr = ptr;
2195 }
2196
2197 void dm_get(struct mapped_device *md)
2198 {
2199         atomic_inc(&md->holders);
2200         BUG_ON(test_bit(DMF_FREEING, &md->flags));
2201 }
2202
2203 const char *dm_device_name(struct mapped_device *md)
2204 {
2205         return md->name;
2206 }
2207 EXPORT_SYMBOL_GPL(dm_device_name);
2208
2209 static void __dm_destroy(struct mapped_device *md, bool wait)
2210 {
2211         struct dm_table *map;
2212
2213         might_sleep();
2214
2215         spin_lock(&_minor_lock);
2216         map = dm_get_live_table(md);
2217         idr_replace(&_minor_idr, MINOR_ALLOCED, MINOR(disk_devt(dm_disk(md))));
2218         set_bit(DMF_FREEING, &md->flags);
2219         spin_unlock(&_minor_lock);
2220
2221         if (!dm_suspended_md(md)) {
2222                 dm_table_presuspend_targets(map);
2223                 dm_table_postsuspend_targets(map);
2224         }
2225
2226         /*
2227          * Rare, but there may be I/O requests still going to complete,
2228          * for example.  Wait for all references to disappear.
2229          * No one should increment the reference count of the mapped_device,
2230          * after the mapped_device state becomes DMF_FREEING.
2231          */
2232         if (wait)
2233                 while (atomic_read(&md->holders))
2234                         msleep(1);
2235         else if (atomic_read(&md->holders))
2236                 DMWARN("%s: Forcibly removing mapped_device still in use! (%d users)",
2237                        dm_device_name(md), atomic_read(&md->holders));
2238
2239         dm_sysfs_exit(md);
2240         dm_table_put(map);
2241         dm_table_destroy(__unbind(md));
2242         free_dev(md);
2243 }
2244
2245 void dm_destroy(struct mapped_device *md)
2246 {
2247         __dm_destroy(md, true);
2248 }
2249
2250 void dm_destroy_immediate(struct mapped_device *md)
2251 {
2252         __dm_destroy(md, false);
2253 }
2254
2255 void dm_put(struct mapped_device *md)
2256 {
2257         atomic_dec(&md->holders);
2258 }
2259 EXPORT_SYMBOL_GPL(dm_put);
2260
2261 static int dm_wait_for_completion(struct mapped_device *md, int interruptible)
2262 {
2263         int r = 0;
2264         DECLARE_WAITQUEUE(wait, current);
2265
2266         dm_unplug_all(md->queue);
2267
2268         add_wait_queue(&md->wait, &wait);
2269
2270         while (1) {
2271                 set_current_state(interruptible);
2272
2273                 smp_mb();
2274                 if (!md_in_flight(md))
2275                         break;
2276
2277                 if (interruptible == TASK_INTERRUPTIBLE &&
2278                     signal_pending(current)) {
2279                         r = -EINTR;
2280                         break;
2281                 }
2282
2283                 io_schedule();
2284         }
2285         set_current_state(TASK_RUNNING);
2286
2287         remove_wait_queue(&md->wait, &wait);
2288
2289         return r;
2290 }
2291
2292 /*
2293  * Process the deferred bios
2294  */
2295 static void dm_wq_work(struct work_struct *work)
2296 {
2297         struct mapped_device *md = container_of(work, struct mapped_device,
2298                                                 work);
2299         struct bio *c;
2300
2301         down_read(&md->io_lock);
2302
2303         while (!test_bit(DMF_BLOCK_IO_FOR_SUSPEND, &md->flags)) {
2304                 spin_lock_irq(&md->deferred_lock);
2305                 c = bio_list_pop(&md->deferred);
2306                 spin_unlock_irq(&md->deferred_lock);
2307
2308                 if (!c)
2309                         break;
2310
2311                 up_read(&md->io_lock);
2312
2313                 if (dm_request_based(md))
2314                         generic_make_request(c);
2315                 else
2316                         __split_and_process_bio(md, c);
2317
2318                 down_read(&md->io_lock);
2319         }
2320
2321         up_read(&md->io_lock);
2322 }
2323
2324 static void dm_queue_flush(struct mapped_device *md)
2325 {
2326         clear_bit(DMF_BLOCK_IO_FOR_SUSPEND, &md->flags);
2327         smp_mb__after_clear_bit();
2328         queue_work(md->wq, &md->work);
2329 }
2330
2331 /*
2332  * Swap in a new table, returning the old one for the caller to destroy.
2333  */
2334 struct dm_table *dm_swap_table(struct mapped_device *md, struct dm_table *table)
2335 {
2336         struct dm_table *map = ERR_PTR(-EINVAL);
2337         struct queue_limits limits;
2338         int r;
2339
2340         mutex_lock(&md->suspend_lock);
2341
2342         /* device must be suspended */
2343         if (!dm_suspended_md(md))
2344                 goto out;
2345
2346         r = dm_calculate_queue_limits(table, &limits);
2347         if (r) {
2348                 map = ERR_PTR(r);
2349                 goto out;
2350         }
2351
2352         map = __bind(md, table, &limits);
2353
2354 out:
2355         mutex_unlock(&md->suspend_lock);
2356         return map;
2357 }
2358
2359 /*
2360  * Functions to lock and unlock any filesystem running on the
2361  * device.
2362  */
2363 static int lock_fs(struct mapped_device *md)
2364 {
2365         int r;
2366
2367         WARN_ON(md->frozen_sb);
2368
2369         md->frozen_sb = freeze_bdev(md->bdev);
2370         if (IS_ERR(md->frozen_sb)) {
2371                 r = PTR_ERR(md->frozen_sb);
2372                 md->frozen_sb = NULL;
2373                 return r;
2374         }
2375
2376         set_bit(DMF_FROZEN, &md->flags);
2377
2378         return 0;
2379 }
2380
2381 static void unlock_fs(struct mapped_device *md)
2382 {
2383         if (!test_bit(DMF_FROZEN, &md->flags))
2384                 return;
2385
2386         thaw_bdev(md->bdev, md->frozen_sb);
2387         md->frozen_sb = NULL;
2388         clear_bit(DMF_FROZEN, &md->flags);
2389 }
2390
2391 /*
2392  * We need to be able to change a mapping table under a mounted
2393  * filesystem.  For example we might want to move some data in
2394  * the background.  Before the table can be swapped with
2395  * dm_bind_table, dm_suspend must be called to flush any in
2396  * flight bios and ensure that any further io gets deferred.
2397  */
2398 /*
2399  * Suspend mechanism in request-based dm.
2400  *
2401  * 1. Flush all I/Os by lock_fs() if needed.
2402  * 2. Stop dispatching any I/O by stopping the request_queue.
2403  * 3. Wait for all in-flight I/Os to be completed or requeued.
2404  *
2405  * To abort suspend, start the request_queue.
2406  */
2407 int dm_suspend(struct mapped_device *md, unsigned suspend_flags)
2408 {
2409         struct dm_table *map = NULL;
2410         int r = 0;
2411         int do_lockfs = suspend_flags & DM_SUSPEND_LOCKFS_FLAG ? 1 : 0;
2412         int noflush = suspend_flags & DM_SUSPEND_NOFLUSH_FLAG ? 1 : 0;
2413
2414         mutex_lock(&md->suspend_lock);
2415
2416         if (dm_suspended_md(md)) {
2417                 r = -EINVAL;
2418                 goto out_unlock;
2419         }
2420
2421         map = dm_get_live_table(md);
2422
2423         /*
2424          * DMF_NOFLUSH_SUSPENDING must be set before presuspend.
2425          * This flag is cleared before dm_suspend returns.
2426          */
2427         if (noflush)
2428                 set_bit(DMF_NOFLUSH_SUSPENDING, &md->flags);
2429
2430         /* This does not get reverted if there's an error later. */
2431         dm_table_presuspend_targets(map);
2432
2433         /*
2434          * Flush I/O to the device.
2435          * Any I/O submitted after lock_fs() may not be flushed.
2436          * noflush takes precedence over do_lockfs.
2437          * (lock_fs() flushes I/Os and waits for them to complete.)
2438          */
2439         if (!noflush && do_lockfs) {
2440                 r = lock_fs(md);
2441                 if (r)
2442                         goto out;
2443         }
2444
2445         /*
2446          * Here we must make sure that no processes are submitting requests
2447          * to target drivers i.e. no one may be executing
2448          * __split_and_process_bio. This is called from dm_request and
2449          * dm_wq_work.
2450          *
2451          * To get all processes out of __split_and_process_bio in dm_request,
2452          * we take the write lock. To prevent any process from reentering
2453          * __split_and_process_bio from dm_request and quiesce the thread
2454          * (dm_wq_work), we set BMF_BLOCK_IO_FOR_SUSPEND and call
2455          * flush_workqueue(md->wq).
2456          */
2457         down_write(&md->io_lock);
2458         set_bit(DMF_BLOCK_IO_FOR_SUSPEND, &md->flags);
2459         up_write(&md->io_lock);
2460
2461         /*
2462          * Stop md->queue before flushing md->wq in case request-based
2463          * dm defers requests to md->wq from md->queue.
2464          */
2465         if (dm_request_based(md))
2466                 stop_queue(md->queue);
2467
2468         flush_workqueue(md->wq);
2469
2470         /*
2471          * At this point no more requests are entering target request routines.
2472          * We call dm_wait_for_completion to wait for all existing requests
2473          * to finish.
2474          */
2475         r = dm_wait_for_completion(md, TASK_INTERRUPTIBLE);
2476
2477         down_write(&md->io_lock);
2478         if (noflush)
2479                 clear_bit(DMF_NOFLUSH_SUSPENDING, &md->flags);
2480         up_write(&md->io_lock);
2481
2482         /* were we interrupted ? */
2483         if (r < 0) {
2484                 dm_queue_flush(md);
2485
2486                 if (dm_request_based(md))
2487                         start_queue(md->queue);
2488
2489                 unlock_fs(md);
2490                 goto out; /* pushback list is already flushed, so skip flush */
2491         }
2492
2493         /*
2494          * If dm_wait_for_completion returned 0, the device is completely
2495          * quiescent now. There is no request-processing activity. All new
2496          * requests are being added to md->deferred list.
2497          */
2498
2499         set_bit(DMF_SUSPENDED, &md->flags);
2500
2501         dm_table_postsuspend_targets(map);
2502
2503 out:
2504         dm_table_put(map);
2505
2506 out_unlock:
2507         mutex_unlock(&md->suspend_lock);
2508         return r;
2509 }
2510
2511 int dm_resume(struct mapped_device *md)
2512 {
2513         int r = -EINVAL;
2514         struct dm_table *map = NULL;
2515
2516         mutex_lock(&md->suspend_lock);
2517         if (!dm_suspended_md(md))
2518                 goto out;
2519
2520         map = dm_get_live_table(md);
2521         if (!map || !dm_table_get_size(map))
2522                 goto out;
2523
2524         r = dm_table_resume_targets(map);
2525         if (r)
2526                 goto out;
2527
2528         dm_queue_flush(md);
2529
2530         /*
2531          * Flushing deferred I/Os must be done after targets are resumed
2532          * so that mapping of targets can work correctly.
2533          * Request-based dm is queueing the deferred I/Os in its request_queue.
2534          */
2535         if (dm_request_based(md))
2536                 start_queue(md->queue);
2537
2538         unlock_fs(md);
2539
2540         clear_bit(DMF_SUSPENDED, &md->flags);
2541
2542         dm_table_unplug_all(map);
2543         r = 0;
2544 out:
2545         dm_table_put(map);
2546         mutex_unlock(&md->suspend_lock);
2547
2548         return r;
2549 }
2550
2551 /*-----------------------------------------------------------------
2552  * Event notification.
2553  *---------------------------------------------------------------*/
2554 int dm_kobject_uevent(struct mapped_device *md, enum kobject_action action,
2555                        unsigned cookie)
2556 {
2557         char udev_cookie[DM_COOKIE_LENGTH];
2558         char *envp[] = { udev_cookie, NULL };
2559
2560         if (!cookie)
2561                 return kobject_uevent(&disk_to_dev(md->disk)->kobj, action);
2562         else {
2563                 snprintf(udev_cookie, DM_COOKIE_LENGTH, "%s=%u",
2564                          DM_COOKIE_ENV_VAR_NAME, cookie);
2565                 return kobject_uevent_env(&disk_to_dev(md->disk)->kobj,
2566                                           action, envp);
2567         }
2568 }
2569
2570 uint32_t dm_next_uevent_seq(struct mapped_device *md)
2571 {
2572         return atomic_add_return(1, &md->uevent_seq);
2573 }
2574
2575 uint32_t dm_get_event_nr(struct mapped_device *md)
2576 {
2577         return atomic_read(&md->event_nr);
2578 }
2579
2580 int dm_wait_event(struct mapped_device *md, int event_nr)
2581 {
2582         return wait_event_interruptible(md->eventq,
2583                         (event_nr != atomic_read(&md->event_nr)));
2584 }
2585
2586 void dm_uevent_add(struct mapped_device *md, struct list_head *elist)
2587 {
2588         unsigned long flags;
2589
2590         spin_lock_irqsave(&md->uevent_lock, flags);
2591         list_add(elist, &md->uevent_list);
2592         spin_unlock_irqrestore(&md->uevent_lock, flags);
2593 }
2594
2595 /*
2596  * The gendisk is only valid as long as you have a reference
2597  * count on 'md'.
2598  */
2599 struct gendisk *dm_disk(struct mapped_device *md)
2600 {
2601         return md->disk;
2602 }
2603
2604 struct kobject *dm_kobject(struct mapped_device *md)
2605 {
2606         return &md->kobj;
2607 }
2608
2609 /*
2610  * struct mapped_device should not be exported outside of dm.c
2611  * so use this check to verify that kobj is part of md structure
2612  */
2613 struct mapped_device *dm_get_from_kobject(struct kobject *kobj)
2614 {
2615         struct mapped_device *md;
2616
2617         md = container_of(kobj, struct mapped_device, kobj);
2618         if (&md->kobj != kobj)
2619                 return NULL;
2620
2621         if (test_bit(DMF_FREEING, &md->flags) ||
2622             dm_deleting_md(md))
2623                 return NULL;
2624
2625         dm_get(md);
2626         return md;
2627 }
2628
2629 int dm_suspended_md(struct mapped_device *md)
2630 {
2631         return test_bit(DMF_SUSPENDED, &md->flags);
2632 }
2633
2634 int dm_suspended(struct dm_target *ti)
2635 {
2636         return dm_suspended_md(dm_table_get_md(ti->table));
2637 }
2638 EXPORT_SYMBOL_GPL(dm_suspended);
2639
2640 int dm_noflush_suspending(struct dm_target *ti)
2641 {
2642         return __noflush_suspending(dm_table_get_md(ti->table));
2643 }
2644 EXPORT_SYMBOL_GPL(dm_noflush_suspending);
2645
2646 struct dm_md_mempools *dm_alloc_md_mempools(unsigned type)
2647 {
2648         struct dm_md_mempools *pools = kmalloc(sizeof(*pools), GFP_KERNEL);
2649
2650         if (!pools)
2651                 return NULL;
2652
2653         pools->io_pool = (type == DM_TYPE_BIO_BASED) ?
2654                          mempool_create_slab_pool(MIN_IOS, _io_cache) :
2655                          mempool_create_slab_pool(MIN_IOS, _rq_bio_info_cache);
2656         if (!pools->io_pool)
2657                 goto free_pools_and_out;
2658
2659         pools->tio_pool = (type == DM_TYPE_BIO_BASED) ?
2660                           mempool_create_slab_pool(MIN_IOS, _tio_cache) :
2661                           mempool_create_slab_pool(MIN_IOS, _rq_tio_cache);
2662         if (!pools->tio_pool)
2663                 goto free_io_pool_and_out;
2664
2665         pools->bs = (type == DM_TYPE_BIO_BASED) ?
2666                     bioset_create(16, 0) : bioset_create(MIN_IOS, 0);
2667         if (!pools->bs)
2668                 goto free_tio_pool_and_out;
2669
2670         return pools;
2671
2672 free_tio_pool_and_out:
2673         mempool_destroy(pools->tio_pool);
2674
2675 free_io_pool_and_out:
2676         mempool_destroy(pools->io_pool);
2677
2678 free_pools_and_out:
2679         kfree(pools);
2680
2681         return NULL;
2682 }
2683
2684 void dm_free_md_mempools(struct dm_md_mempools *pools)
2685 {
2686         if (!pools)
2687                 return;
2688
2689         if (pools->io_pool)
2690                 mempool_destroy(pools->io_pool);
2691
2692         if (pools->tio_pool)
2693                 mempool_destroy(pools->tio_pool);
2694
2695         if (pools->bs)
2696                 bioset_free(pools->bs);
2697
2698         kfree(pools);
2699 }
2700
2701 static const struct block_device_operations dm_blk_dops = {
2702         .open = dm_blk_open,
2703         .release = dm_blk_close,
2704         .ioctl = dm_blk_ioctl,
2705         .getgeo = dm_blk_getgeo,
2706         .owner = THIS_MODULE
2707 };
2708
2709 EXPORT_SYMBOL(dm_get_mapinfo);
2710
2711 /*
2712  * module hooks
2713  */
2714 module_init(dm_init);
2715 module_exit(dm_exit);
2716
2717 module_param(major, uint, 0);
2718 MODULE_PARM_DESC(major, "The major number of the device mapper");
2719 MODULE_DESCRIPTION(DM_NAME " driver");
2720 MODULE_AUTHOR("Joe Thornber <dm-devel@redhat.com>");
2721 MODULE_LICENSE("GPL");