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