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