[PATCH] device-mapper multipath: Barriers not supported
[linux-2.6.git] / drivers / md / dm.c
1 /*
2  * Copyright (C) 2001, 2002 Sistina Software (UK) Limited.
3  * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
4  *
5  * This file is released under the GPL.
6  */
7
8 #include "dm.h"
9 #include "dm-bio-list.h"
10
11 #include <linux/init.h>
12 #include <linux/module.h>
13 #include <linux/moduleparam.h>
14 #include <linux/blkpg.h>
15 #include <linux/bio.h>
16 #include <linux/buffer_head.h>
17 #include <linux/mempool.h>
18 #include <linux/slab.h>
19 #include <linux/idr.h>
20
21 static const char *_name = DM_NAME;
22
23 static unsigned int major = 0;
24 static unsigned int _major = 0;
25
26 /*
27  * One of these is allocated per bio.
28  */
29 struct dm_io {
30         struct mapped_device *md;
31         int error;
32         struct bio *bio;
33         atomic_t io_count;
34 };
35
36 /*
37  * One of these is allocated per target within a bio.  Hopefully
38  * this will be simplified out one day.
39  */
40 struct target_io {
41         struct dm_io *io;
42         struct dm_target *ti;
43         union map_info info;
44 };
45
46 union map_info *dm_get_mapinfo(struct bio *bio)
47 {
48         if (bio && bio->bi_private)
49                 return &((struct target_io *)bio->bi_private)->info;
50         return NULL;
51 }
52
53 /*
54  * Bits for the md->flags field.
55  */
56 #define DMF_BLOCK_IO 0
57 #define DMF_SUSPENDED 1
58 #define DMF_FS_LOCKED 2
59
60 struct mapped_device {
61         struct rw_semaphore lock;
62         rwlock_t map_lock;
63         atomic_t holders;
64
65         unsigned long flags;
66
67         request_queue_t *queue;
68         struct gendisk *disk;
69
70         void *interface_ptr;
71
72         /*
73          * A list of ios that arrived while we were suspended.
74          */
75         atomic_t pending;
76         wait_queue_head_t wait;
77         struct bio_list deferred;
78
79         /*
80          * The current mapping.
81          */
82         struct dm_table *map;
83
84         /*
85          * io objects are allocated from here.
86          */
87         mempool_t *io_pool;
88         mempool_t *tio_pool;
89
90         /*
91          * Event handling.
92          */
93         atomic_t event_nr;
94         wait_queue_head_t eventq;
95
96         /*
97          * freeze/thaw support require holding onto a super block
98          */
99         struct super_block *frozen_sb;
100         struct block_device *frozen_bdev;
101 };
102
103 #define MIN_IOS 256
104 static kmem_cache_t *_io_cache;
105 static kmem_cache_t *_tio_cache;
106
107 static struct bio_set *dm_set;
108
109 static int __init local_init(void)
110 {
111         int r;
112
113         dm_set = bioset_create(16, 16, 4);
114         if (!dm_set)
115                 return -ENOMEM;
116
117         /* allocate a slab for the dm_ios */
118         _io_cache = kmem_cache_create("dm_io",
119                                       sizeof(struct dm_io), 0, 0, NULL, NULL);
120         if (!_io_cache)
121                 return -ENOMEM;
122
123         /* allocate a slab for the target ios */
124         _tio_cache = kmem_cache_create("dm_tio", sizeof(struct target_io),
125                                        0, 0, NULL, NULL);
126         if (!_tio_cache) {
127                 kmem_cache_destroy(_io_cache);
128                 return -ENOMEM;
129         }
130
131         _major = major;
132         r = register_blkdev(_major, _name);
133         if (r < 0) {
134                 kmem_cache_destroy(_tio_cache);
135                 kmem_cache_destroy(_io_cache);
136                 return r;
137         }
138
139         if (!_major)
140                 _major = r;
141
142         return 0;
143 }
144
145 static void local_exit(void)
146 {
147         kmem_cache_destroy(_tio_cache);
148         kmem_cache_destroy(_io_cache);
149
150         bioset_free(dm_set);
151
152         if (unregister_blkdev(_major, _name) < 0)
153                 DMERR("devfs_unregister_blkdev failed");
154
155         _major = 0;
156
157         DMINFO("cleaned up");
158 }
159
160 int (*_inits[])(void) __initdata = {
161         local_init,
162         dm_target_init,
163         dm_linear_init,
164         dm_stripe_init,
165         dm_interface_init,
166 };
167
168 void (*_exits[])(void) = {
169         local_exit,
170         dm_target_exit,
171         dm_linear_exit,
172         dm_stripe_exit,
173         dm_interface_exit,
174 };
175
176 static int __init dm_init(void)
177 {
178         const int count = ARRAY_SIZE(_inits);
179
180         int r, i;
181
182         for (i = 0; i < count; i++) {
183                 r = _inits[i]();
184                 if (r)
185                         goto bad;
186         }
187
188         return 0;
189
190       bad:
191         while (i--)
192                 _exits[i]();
193
194         return r;
195 }
196
197 static void __exit dm_exit(void)
198 {
199         int i = ARRAY_SIZE(_exits);
200
201         while (i--)
202                 _exits[i]();
203 }
204
205 /*
206  * Block device functions
207  */
208 static int dm_blk_open(struct inode *inode, struct file *file)
209 {
210         struct mapped_device *md;
211
212         md = inode->i_bdev->bd_disk->private_data;
213         dm_get(md);
214         return 0;
215 }
216
217 static int dm_blk_close(struct inode *inode, struct file *file)
218 {
219         struct mapped_device *md;
220
221         md = inode->i_bdev->bd_disk->private_data;
222         dm_put(md);
223         return 0;
224 }
225
226 static inline struct dm_io *alloc_io(struct mapped_device *md)
227 {
228         return mempool_alloc(md->io_pool, GFP_NOIO);
229 }
230
231 static inline void free_io(struct mapped_device *md, struct dm_io *io)
232 {
233         mempool_free(io, md->io_pool);
234 }
235
236 static inline struct target_io *alloc_tio(struct mapped_device *md)
237 {
238         return mempool_alloc(md->tio_pool, GFP_NOIO);
239 }
240
241 static inline void free_tio(struct mapped_device *md, struct target_io *tio)
242 {
243         mempool_free(tio, md->tio_pool);
244 }
245
246 /*
247  * Add the bio to the list of deferred io.
248  */
249 static int queue_io(struct mapped_device *md, struct bio *bio)
250 {
251         down_write(&md->lock);
252
253         if (!test_bit(DMF_BLOCK_IO, &md->flags)) {
254                 up_write(&md->lock);
255                 return 1;
256         }
257
258         bio_list_add(&md->deferred, bio);
259
260         up_write(&md->lock);
261         return 0;               /* deferred successfully */
262 }
263
264 /*
265  * Everyone (including functions in this file), should use this
266  * function to access the md->map field, and make sure they call
267  * dm_table_put() when finished.
268  */
269 struct dm_table *dm_get_table(struct mapped_device *md)
270 {
271         struct dm_table *t;
272
273         read_lock(&md->map_lock);
274         t = md->map;
275         if (t)
276                 dm_table_get(t);
277         read_unlock(&md->map_lock);
278
279         return t;
280 }
281
282 /*-----------------------------------------------------------------
283  * CRUD START:
284  *   A more elegant soln is in the works that uses the queue
285  *   merge fn, unfortunately there are a couple of changes to
286  *   the block layer that I want to make for this.  So in the
287  *   interests of getting something for people to use I give
288  *   you this clearly demarcated crap.
289  *---------------------------------------------------------------*/
290
291 /*
292  * Decrements the number of outstanding ios that a bio has been
293  * cloned into, completing the original io if necc.
294  */
295 static inline void dec_pending(struct dm_io *io, int error)
296 {
297         if (error)
298                 io->error = error;
299
300         if (atomic_dec_and_test(&io->io_count)) {
301                 if (atomic_dec_and_test(&io->md->pending))
302                         /* nudge anyone waiting on suspend queue */
303                         wake_up(&io->md->wait);
304
305                 bio_endio(io->bio, io->bio->bi_size, io->error);
306                 free_io(io->md, io);
307         }
308 }
309
310 static int clone_endio(struct bio *bio, unsigned int done, int error)
311 {
312         int r = 0;
313         struct target_io *tio = bio->bi_private;
314         struct dm_io *io = tio->io;
315         dm_endio_fn endio = tio->ti->type->end_io;
316
317         if (bio->bi_size)
318                 return 1;
319
320         if (!bio_flagged(bio, BIO_UPTODATE) && !error)
321                 error = -EIO;
322
323         if (endio) {
324                 r = endio(tio->ti, bio, error, &tio->info);
325                 if (r < 0)
326                         error = r;
327
328                 else if (r > 0)
329                         /* the target wants another shot at the io */
330                         return 1;
331         }
332
333         free_tio(io->md, tio);
334         dec_pending(io, error);
335         bio_put(bio);
336         return r;
337 }
338
339 static sector_t max_io_len(struct mapped_device *md,
340                            sector_t sector, struct dm_target *ti)
341 {
342         sector_t offset = sector - ti->begin;
343         sector_t len = ti->len - offset;
344
345         /*
346          * Does the target need to split even further ?
347          */
348         if (ti->split_io) {
349                 sector_t boundary;
350                 boundary = ((offset + ti->split_io) & ~(ti->split_io - 1))
351                            - offset;
352                 if (len > boundary)
353                         len = boundary;
354         }
355
356         return len;
357 }
358
359 static void __map_bio(struct dm_target *ti, struct bio *clone,
360                       struct target_io *tio)
361 {
362         int r;
363
364         /*
365          * Sanity checks.
366          */
367         BUG_ON(!clone->bi_size);
368
369         clone->bi_end_io = clone_endio;
370         clone->bi_private = tio;
371
372         /*
373          * Map the clone.  If r == 0 we don't need to do
374          * anything, the target has assumed ownership of
375          * this io.
376          */
377         atomic_inc(&tio->io->io_count);
378         r = ti->type->map(ti, clone, &tio->info);
379         if (r > 0)
380                 /* the bio has been remapped so dispatch it */
381                 generic_make_request(clone);
382
383         else if (r < 0) {
384                 /* error the io and bail out */
385                 struct dm_io *io = tio->io;
386                 free_tio(tio->io->md, tio);
387                 dec_pending(io, r);
388                 bio_put(clone);
389         }
390 }
391
392 struct clone_info {
393         struct mapped_device *md;
394         struct dm_table *map;
395         struct bio *bio;
396         struct dm_io *io;
397         sector_t sector;
398         sector_t sector_count;
399         unsigned short idx;
400 };
401
402 /*
403  * Creates a little bio that is just does part of a bvec.
404  */
405 static struct bio *split_bvec(struct bio *bio, sector_t sector,
406                               unsigned short idx, unsigned int offset,
407                               unsigned int len)
408 {
409         struct bio *clone;
410         struct bio_vec *bv = bio->bi_io_vec + idx;
411
412         clone = bio_alloc_bioset(GFP_NOIO, 1, dm_set);
413         *clone->bi_io_vec = *bv;
414
415         clone->bi_sector = sector;
416         clone->bi_bdev = bio->bi_bdev;
417         clone->bi_rw = bio->bi_rw;
418         clone->bi_vcnt = 1;
419         clone->bi_size = to_bytes(len);
420         clone->bi_io_vec->bv_offset = offset;
421         clone->bi_io_vec->bv_len = clone->bi_size;
422
423         return clone;
424 }
425
426 /*
427  * Creates a bio that consists of range of complete bvecs.
428  */
429 static struct bio *clone_bio(struct bio *bio, sector_t sector,
430                              unsigned short idx, unsigned short bv_count,
431                              unsigned int len)
432 {
433         struct bio *clone;
434
435         clone = bio_clone(bio, GFP_NOIO);
436         clone->bi_sector = sector;
437         clone->bi_idx = idx;
438         clone->bi_vcnt = idx + bv_count;
439         clone->bi_size = to_bytes(len);
440         clone->bi_flags &= ~(1 << BIO_SEG_VALID);
441
442         return clone;
443 }
444
445 static void __clone_and_map(struct clone_info *ci)
446 {
447         struct bio *clone, *bio = ci->bio;
448         struct dm_target *ti = dm_table_find_target(ci->map, ci->sector);
449         sector_t len = 0, max = max_io_len(ci->md, ci->sector, ti);
450         struct target_io *tio;
451
452         /*
453          * Allocate a target io object.
454          */
455         tio = alloc_tio(ci->md);
456         tio->io = ci->io;
457         tio->ti = ti;
458         memset(&tio->info, 0, sizeof(tio->info));
459
460         if (ci->sector_count <= max) {
461                 /*
462                  * Optimise for the simple case where we can do all of
463                  * the remaining io with a single clone.
464                  */
465                 clone = clone_bio(bio, ci->sector, ci->idx,
466                                   bio->bi_vcnt - ci->idx, ci->sector_count);
467                 __map_bio(ti, clone, tio);
468                 ci->sector_count = 0;
469
470         } else if (to_sector(bio->bi_io_vec[ci->idx].bv_len) <= max) {
471                 /*
472                  * There are some bvecs that don't span targets.
473                  * Do as many of these as possible.
474                  */
475                 int i;
476                 sector_t remaining = max;
477                 sector_t bv_len;
478
479                 for (i = ci->idx; remaining && (i < bio->bi_vcnt); i++) {
480                         bv_len = to_sector(bio->bi_io_vec[i].bv_len);
481
482                         if (bv_len > remaining)
483                                 break;
484
485                         remaining -= bv_len;
486                         len += bv_len;
487                 }
488
489                 clone = clone_bio(bio, ci->sector, ci->idx, i - ci->idx, len);
490                 __map_bio(ti, clone, tio);
491
492                 ci->sector += len;
493                 ci->sector_count -= len;
494                 ci->idx = i;
495
496         } else {
497                 /*
498                  * Create two copy bios to deal with io that has
499                  * been split across a target.
500                  */
501                 struct bio_vec *bv = bio->bi_io_vec + ci->idx;
502
503                 clone = split_bvec(bio, ci->sector, ci->idx,
504                                    bv->bv_offset, max);
505                 __map_bio(ti, clone, tio);
506
507                 ci->sector += max;
508                 ci->sector_count -= max;
509                 ti = dm_table_find_target(ci->map, ci->sector);
510
511                 len = to_sector(bv->bv_len) - max;
512                 clone = split_bvec(bio, ci->sector, ci->idx,
513                                    bv->bv_offset + to_bytes(max), len);
514                 tio = alloc_tio(ci->md);
515                 tio->io = ci->io;
516                 tio->ti = ti;
517                 memset(&tio->info, 0, sizeof(tio->info));
518                 __map_bio(ti, clone, tio);
519
520                 ci->sector += len;
521                 ci->sector_count -= len;
522                 ci->idx++;
523         }
524 }
525
526 /*
527  * Split the bio into several clones.
528  */
529 static void __split_bio(struct mapped_device *md, struct bio *bio)
530 {
531         struct clone_info ci;
532
533         ci.map = dm_get_table(md);
534         if (!ci.map) {
535                 bio_io_error(bio, bio->bi_size);
536                 return;
537         }
538
539         ci.md = md;
540         ci.bio = bio;
541         ci.io = alloc_io(md);
542         ci.io->error = 0;
543         atomic_set(&ci.io->io_count, 1);
544         ci.io->bio = bio;
545         ci.io->md = md;
546         ci.sector = bio->bi_sector;
547         ci.sector_count = bio_sectors(bio);
548         ci.idx = bio->bi_idx;
549
550         atomic_inc(&md->pending);
551         while (ci.sector_count)
552                 __clone_and_map(&ci);
553
554         /* drop the extra reference count */
555         dec_pending(ci.io, 0);
556         dm_table_put(ci.map);
557 }
558 /*-----------------------------------------------------------------
559  * CRUD END
560  *---------------------------------------------------------------*/
561
562 /*
563  * The request function that just remaps the bio built up by
564  * dm_merge_bvec.
565  */
566 static int dm_request(request_queue_t *q, struct bio *bio)
567 {
568         int r;
569         struct mapped_device *md = q->queuedata;
570
571         down_read(&md->lock);
572
573         /*
574          * If we're suspended we have to queue
575          * this io for later.
576          */
577         while (test_bit(DMF_BLOCK_IO, &md->flags)) {
578                 up_read(&md->lock);
579
580                 if (bio_rw(bio) == READA) {
581                         bio_io_error(bio, bio->bi_size);
582                         return 0;
583                 }
584
585                 r = queue_io(md, bio);
586                 if (r < 0) {
587                         bio_io_error(bio, bio->bi_size);
588                         return 0;
589
590                 } else if (r == 0)
591                         return 0;       /* deferred successfully */
592
593                 /*
594                  * We're in a while loop, because someone could suspend
595                  * before we get to the following read lock.
596                  */
597                 down_read(&md->lock);
598         }
599
600         __split_bio(md, bio);
601         up_read(&md->lock);
602         return 0;
603 }
604
605 static int dm_flush_all(request_queue_t *q, struct gendisk *disk,
606                         sector_t *error_sector)
607 {
608         struct mapped_device *md = q->queuedata;
609         struct dm_table *map = dm_get_table(md);
610         int ret = -ENXIO;
611
612         if (map) {
613                 ret = dm_table_flush_all(md->map);
614                 dm_table_put(map);
615         }
616
617         return ret;
618 }
619
620 static void dm_unplug_all(request_queue_t *q)
621 {
622         struct mapped_device *md = q->queuedata;
623         struct dm_table *map = dm_get_table(md);
624
625         if (map) {
626                 dm_table_unplug_all(map);
627                 dm_table_put(map);
628         }
629 }
630
631 static int dm_any_congested(void *congested_data, int bdi_bits)
632 {
633         int r;
634         struct mapped_device *md = (struct mapped_device *) congested_data;
635         struct dm_table *map = dm_get_table(md);
636
637         if (!map || test_bit(DMF_BLOCK_IO, &md->flags))
638                 r = bdi_bits;
639         else
640                 r = dm_table_any_congested(map, bdi_bits);
641
642         dm_table_put(map);
643         return r;
644 }
645
646 /*-----------------------------------------------------------------
647  * An IDR is used to keep track of allocated minor numbers.
648  *---------------------------------------------------------------*/
649 static DECLARE_MUTEX(_minor_lock);
650 static DEFINE_IDR(_minor_idr);
651
652 static void free_minor(unsigned int minor)
653 {
654         down(&_minor_lock);
655         idr_remove(&_minor_idr, minor);
656         up(&_minor_lock);
657 }
658
659 /*
660  * See if the device with a specific minor # is free.
661  */
662 static int specific_minor(struct mapped_device *md, unsigned int minor)
663 {
664         int r, m;
665
666         if (minor >= (1 << MINORBITS))
667                 return -EINVAL;
668
669         down(&_minor_lock);
670
671         if (idr_find(&_minor_idr, minor)) {
672                 r = -EBUSY;
673                 goto out;
674         }
675
676         r = idr_pre_get(&_minor_idr, GFP_KERNEL);
677         if (!r) {
678                 r = -ENOMEM;
679                 goto out;
680         }
681
682         r = idr_get_new_above(&_minor_idr, md, minor, &m);
683         if (r) {
684                 goto out;
685         }
686
687         if (m != minor) {
688                 idr_remove(&_minor_idr, m);
689                 r = -EBUSY;
690                 goto out;
691         }
692
693 out:
694         up(&_minor_lock);
695         return r;
696 }
697
698 static int next_free_minor(struct mapped_device *md, unsigned int *minor)
699 {
700         int r;
701         unsigned int m;
702
703         down(&_minor_lock);
704
705         r = idr_pre_get(&_minor_idr, GFP_KERNEL);
706         if (!r) {
707                 r = -ENOMEM;
708                 goto out;
709         }
710
711         r = idr_get_new(&_minor_idr, md, &m);
712         if (r) {
713                 goto out;
714         }
715
716         if (m >= (1 << MINORBITS)) {
717                 idr_remove(&_minor_idr, m);
718                 r = -ENOSPC;
719                 goto out;
720         }
721
722         *minor = m;
723
724 out:
725         up(&_minor_lock);
726         return r;
727 }
728
729 static struct block_device_operations dm_blk_dops;
730
731 /*
732  * Allocate and initialise a blank device with a given minor.
733  */
734 static struct mapped_device *alloc_dev(unsigned int minor, int persistent)
735 {
736         int r;
737         struct mapped_device *md = kmalloc(sizeof(*md), GFP_KERNEL);
738
739         if (!md) {
740                 DMWARN("unable to allocate device, out of memory.");
741                 return NULL;
742         }
743
744         /* get a minor number for the dev */
745         r = persistent ? specific_minor(md, minor) : next_free_minor(md, &minor);
746         if (r < 0)
747                 goto bad1;
748
749         memset(md, 0, sizeof(*md));
750         init_rwsem(&md->lock);
751         rwlock_init(&md->map_lock);
752         atomic_set(&md->holders, 1);
753         atomic_set(&md->event_nr, 0);
754
755         md->queue = blk_alloc_queue(GFP_KERNEL);
756         if (!md->queue)
757                 goto bad1;
758
759         md->queue->queuedata = md;
760         md->queue->backing_dev_info.congested_fn = dm_any_congested;
761         md->queue->backing_dev_info.congested_data = md;
762         blk_queue_make_request(md->queue, dm_request);
763         md->queue->unplug_fn = dm_unplug_all;
764         md->queue->issue_flush_fn = dm_flush_all;
765
766         md->io_pool = mempool_create(MIN_IOS, mempool_alloc_slab,
767                                      mempool_free_slab, _io_cache);
768         if (!md->io_pool)
769                 goto bad2;
770
771         md->tio_pool = mempool_create(MIN_IOS, mempool_alloc_slab,
772                                       mempool_free_slab, _tio_cache);
773         if (!md->tio_pool)
774                 goto bad3;
775
776         md->disk = alloc_disk(1);
777         if (!md->disk)
778                 goto bad4;
779
780         md->disk->major = _major;
781         md->disk->first_minor = minor;
782         md->disk->fops = &dm_blk_dops;
783         md->disk->queue = md->queue;
784         md->disk->private_data = md;
785         sprintf(md->disk->disk_name, "dm-%d", minor);
786         add_disk(md->disk);
787
788         atomic_set(&md->pending, 0);
789         init_waitqueue_head(&md->wait);
790         init_waitqueue_head(&md->eventq);
791
792         return md;
793
794  bad4:
795         mempool_destroy(md->tio_pool);
796  bad3:
797         mempool_destroy(md->io_pool);
798  bad2:
799         blk_put_queue(md->queue);
800         free_minor(minor);
801  bad1:
802         kfree(md);
803         return NULL;
804 }
805
806 static void free_dev(struct mapped_device *md)
807 {
808         free_minor(md->disk->first_minor);
809         mempool_destroy(md->tio_pool);
810         mempool_destroy(md->io_pool);
811         del_gendisk(md->disk);
812         put_disk(md->disk);
813         blk_put_queue(md->queue);
814         kfree(md);
815 }
816
817 /*
818  * Bind a table to the device.
819  */
820 static void event_callback(void *context)
821 {
822         struct mapped_device *md = (struct mapped_device *) context;
823
824         atomic_inc(&md->event_nr);
825         wake_up(&md->eventq);
826 }
827
828 static void __set_size(struct gendisk *disk, sector_t size)
829 {
830         struct block_device *bdev;
831
832         set_capacity(disk, size);
833         bdev = bdget_disk(disk, 0);
834         if (bdev) {
835                 down(&bdev->bd_inode->i_sem);
836                 i_size_write(bdev->bd_inode, (loff_t)size << SECTOR_SHIFT);
837                 up(&bdev->bd_inode->i_sem);
838                 bdput(bdev);
839         }
840 }
841
842 static int __bind(struct mapped_device *md, struct dm_table *t)
843 {
844         request_queue_t *q = md->queue;
845         sector_t size;
846
847         size = dm_table_get_size(t);
848         __set_size(md->disk, size);
849         if (size == 0)
850                 return 0;
851
852         write_lock(&md->map_lock);
853         md->map = t;
854         write_unlock(&md->map_lock);
855
856         dm_table_get(t);
857         dm_table_event_callback(md->map, event_callback, md);
858         dm_table_set_restrictions(t, q);
859         return 0;
860 }
861
862 static void __unbind(struct mapped_device *md)
863 {
864         struct dm_table *map = md->map;
865
866         if (!map)
867                 return;
868
869         dm_table_event_callback(map, NULL, NULL);
870         write_lock(&md->map_lock);
871         md->map = NULL;
872         write_unlock(&md->map_lock);
873         dm_table_put(map);
874 }
875
876 /*
877  * Constructor for a new device.
878  */
879 static int create_aux(unsigned int minor, int persistent,
880                       struct mapped_device **result)
881 {
882         struct mapped_device *md;
883
884         md = alloc_dev(minor, persistent);
885         if (!md)
886                 return -ENXIO;
887
888         *result = md;
889         return 0;
890 }
891
892 int dm_create(struct mapped_device **result)
893 {
894         return create_aux(0, 0, result);
895 }
896
897 int dm_create_with_minor(unsigned int minor, struct mapped_device **result)
898 {
899         return create_aux(minor, 1, result);
900 }
901
902 void *dm_get_mdptr(dev_t dev)
903 {
904         struct mapped_device *md;
905         void *mdptr = NULL;
906         unsigned minor = MINOR(dev);
907
908         if (MAJOR(dev) != _major || minor >= (1 << MINORBITS))
909                 return NULL;
910
911         down(&_minor_lock);
912
913         md = idr_find(&_minor_idr, minor);
914
915         if (md && (dm_disk(md)->first_minor == minor))
916                 mdptr = md->interface_ptr;
917
918         up(&_minor_lock);
919
920         return mdptr;
921 }
922
923 void dm_set_mdptr(struct mapped_device *md, void *ptr)
924 {
925         md->interface_ptr = ptr;
926 }
927
928 void dm_get(struct mapped_device *md)
929 {
930         atomic_inc(&md->holders);
931 }
932
933 void dm_put(struct mapped_device *md)
934 {
935         struct dm_table *map = dm_get_table(md);
936
937         if (atomic_dec_and_test(&md->holders)) {
938                 if (!test_bit(DMF_SUSPENDED, &md->flags) && map) {
939                         dm_table_presuspend_targets(map);
940                         dm_table_postsuspend_targets(map);
941                 }
942                 __unbind(md);
943                 free_dev(md);
944         }
945
946         dm_table_put(map);
947 }
948
949 /*
950  * Process the deferred bios
951  */
952 static void __flush_deferred_io(struct mapped_device *md, struct bio *c)
953 {
954         struct bio *n;
955
956         while (c) {
957                 n = c->bi_next;
958                 c->bi_next = NULL;
959                 __split_bio(md, c);
960                 c = n;
961         }
962 }
963
964 /*
965  * Swap in a new table (destroying old one).
966  */
967 int dm_swap_table(struct mapped_device *md, struct dm_table *table)
968 {
969         int r;
970
971         down_write(&md->lock);
972
973         /* device must be suspended */
974         if (!test_bit(DMF_SUSPENDED, &md->flags)) {
975                 up_write(&md->lock);
976                 return -EPERM;
977         }
978
979         __unbind(md);
980         r = __bind(md, table);
981         if (r)
982                 return r;
983
984         up_write(&md->lock);
985         return 0;
986 }
987
988 /*
989  * Functions to lock and unlock any filesystem running on the
990  * device.
991  */
992 static int __lock_fs(struct mapped_device *md)
993 {
994         int error = -ENOMEM;
995
996         if (test_and_set_bit(DMF_FS_LOCKED, &md->flags))
997                 return 0;
998
999         md->frozen_bdev = bdget_disk(md->disk, 0);
1000         if (!md->frozen_bdev) {
1001                 DMWARN("bdget failed in __lock_fs");
1002                 goto out;
1003         }
1004
1005         WARN_ON(md->frozen_sb);
1006
1007         md->frozen_sb = freeze_bdev(md->frozen_bdev);
1008         if (IS_ERR(md->frozen_sb)) {
1009                 error = PTR_ERR(md->frozen_sb);
1010                 goto out_bdput;
1011         }
1012
1013         /* don't bdput right now, we don't want the bdev
1014          * to go away while it is locked.  We'll bdput
1015          * in __unlock_fs
1016          */
1017         return 0;
1018
1019 out_bdput:
1020         bdput(md->frozen_bdev);
1021         md->frozen_sb = NULL;
1022         md->frozen_bdev = NULL;
1023 out:
1024         clear_bit(DMF_FS_LOCKED, &md->flags);
1025         return error;
1026 }
1027
1028 static void __unlock_fs(struct mapped_device *md)
1029 {
1030         if (!test_and_clear_bit(DMF_FS_LOCKED, &md->flags))
1031                 return;
1032
1033         thaw_bdev(md->frozen_bdev, md->frozen_sb);
1034         bdput(md->frozen_bdev);
1035
1036         md->frozen_sb = NULL;
1037         md->frozen_bdev = NULL;
1038 }
1039
1040 /*
1041  * We need to be able to change a mapping table under a mounted
1042  * filesystem.  For example we might want to move some data in
1043  * the background.  Before the table can be swapped with
1044  * dm_bind_table, dm_suspend must be called to flush any in
1045  * flight bios and ensure that any further io gets deferred.
1046  */
1047 int dm_suspend(struct mapped_device *md)
1048 {
1049         struct dm_table *map;
1050         DECLARE_WAITQUEUE(wait, current);
1051         int error = -EINVAL;
1052
1053         /* Flush I/O to the device. */
1054         down_read(&md->lock);
1055         if (test_bit(DMF_BLOCK_IO, &md->flags))
1056                 goto out_read_unlock;
1057
1058         error = __lock_fs(md);
1059         if (error)
1060                 goto out_read_unlock;
1061
1062         map = dm_get_table(md);
1063         if (map)
1064                 dm_table_presuspend_targets(map);
1065
1066         up_read(&md->lock);
1067
1068         /*
1069          * First we set the BLOCK_IO flag so no more ios will be mapped.
1070          *
1071          * If the flag is already set we know another thread is trying to
1072          * suspend as well, so we leave the fs locked for this thread.
1073          */
1074         error = -EINVAL;
1075         down_write(&md->lock);
1076         if (test_and_set_bit(DMF_BLOCK_IO, &md->flags)) {
1077                 if (map)
1078                         dm_table_put(map);
1079                 goto out_write_unlock;
1080         }
1081
1082         add_wait_queue(&md->wait, &wait);
1083         up_write(&md->lock);
1084
1085         /* unplug */
1086         if (map) {
1087                 dm_table_unplug_all(map);
1088                 dm_table_put(map);
1089         }
1090
1091         /*
1092          * Then we wait for the already mapped ios to
1093          * complete.
1094          */
1095         while (1) {
1096                 set_current_state(TASK_INTERRUPTIBLE);
1097
1098                 if (!atomic_read(&md->pending) || signal_pending(current))
1099                         break;
1100
1101                 io_schedule();
1102         }
1103         set_current_state(TASK_RUNNING);
1104
1105         down_write(&md->lock);
1106         remove_wait_queue(&md->wait, &wait);
1107
1108         /* were we interrupted ? */
1109         error = -EINTR;
1110         if (atomic_read(&md->pending))
1111                 goto out_unfreeze;
1112
1113         set_bit(DMF_SUSPENDED, &md->flags);
1114
1115         map = dm_get_table(md);
1116         if (map)
1117                 dm_table_postsuspend_targets(map);
1118         dm_table_put(map);
1119         up_write(&md->lock);
1120
1121         return 0;
1122
1123 out_unfreeze:
1124         /* FIXME Undo dm_table_presuspend_targets */
1125         __unlock_fs(md);
1126         clear_bit(DMF_BLOCK_IO, &md->flags);
1127 out_write_unlock:
1128         up_write(&md->lock);
1129         return error;
1130
1131 out_read_unlock:
1132         up_read(&md->lock);
1133         return error;
1134 }
1135
1136 int dm_resume(struct mapped_device *md)
1137 {
1138         struct bio *def;
1139         struct dm_table *map = dm_get_table(md);
1140
1141         down_write(&md->lock);
1142         if (!map ||
1143             !test_bit(DMF_SUSPENDED, &md->flags) ||
1144             !dm_table_get_size(map)) {
1145                 up_write(&md->lock);
1146                 dm_table_put(map);
1147                 return -EINVAL;
1148         }
1149
1150         dm_table_resume_targets(map);
1151         clear_bit(DMF_SUSPENDED, &md->flags);
1152         clear_bit(DMF_BLOCK_IO, &md->flags);
1153
1154         def = bio_list_get(&md->deferred);
1155         __flush_deferred_io(md, def);
1156         up_write(&md->lock);
1157         __unlock_fs(md);
1158         dm_table_unplug_all(map);
1159         dm_table_put(map);
1160
1161         return 0;
1162 }
1163
1164 /*-----------------------------------------------------------------
1165  * Event notification.
1166  *---------------------------------------------------------------*/
1167 uint32_t dm_get_event_nr(struct mapped_device *md)
1168 {
1169         return atomic_read(&md->event_nr);
1170 }
1171
1172 int dm_wait_event(struct mapped_device *md, int event_nr)
1173 {
1174         return wait_event_interruptible(md->eventq,
1175                         (event_nr != atomic_read(&md->event_nr)));
1176 }
1177
1178 /*
1179  * The gendisk is only valid as long as you have a reference
1180  * count on 'md'.
1181  */
1182 struct gendisk *dm_disk(struct mapped_device *md)
1183 {
1184         return md->disk;
1185 }
1186
1187 int dm_suspended(struct mapped_device *md)
1188 {
1189         return test_bit(DMF_SUSPENDED, &md->flags);
1190 }
1191
1192 static struct block_device_operations dm_blk_dops = {
1193         .open = dm_blk_open,
1194         .release = dm_blk_close,
1195         .owner = THIS_MODULE
1196 };
1197
1198 EXPORT_SYMBOL(dm_get_mapinfo);
1199
1200 /*
1201  * module hooks
1202  */
1203 module_init(dm_init);
1204 module_exit(dm_exit);
1205
1206 module_param(major, uint, 0);
1207 MODULE_PARM_DESC(major, "The major number of the device mapper");
1208 MODULE_DESCRIPTION(DM_NAME " driver");
1209 MODULE_AUTHOR("Joe Thornber <dm-devel@redhat.com>");
1210 MODULE_LICENSE("GPL");