dm: merge pushback and deferred bio lists
[linux-2.6/mini2440.git] / drivers / md / dm.c
blobf5703727d97421f7041f092601e5075f62e07902
1 /*
2 * Copyright (C) 2001, 2002 Sistina Software (UK) Limited.
3 * Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved.
5 * This file is released under the GPL.
6 */
8 #include "dm.h"
9 #include "dm-bio-list.h"
10 #include "dm-uevent.h"
12 #include <linux/init.h>
13 #include <linux/module.h>
14 #include <linux/mutex.h>
15 #include <linux/moduleparam.h>
16 #include <linux/blkpg.h>
17 #include <linux/bio.h>
18 #include <linux/buffer_head.h>
19 #include <linux/mempool.h>
20 #include <linux/slab.h>
21 #include <linux/idr.h>
22 #include <linux/hdreg.h>
23 #include <linux/blktrace_api.h>
24 #include <trace/block.h>
26 #define DM_MSG_PREFIX "core"
28 static const char *_name = DM_NAME;
30 static unsigned int major = 0;
31 static unsigned int _major = 0;
33 static DEFINE_SPINLOCK(_minor_lock);
35 * For bio-based dm.
36 * One of these is allocated per bio.
38 struct dm_io {
39 struct mapped_device *md;
40 int error;
41 atomic_t io_count;
42 struct bio *bio;
43 unsigned long start_time;
47 * For bio-based dm.
48 * One of these is allocated per target within a bio. Hopefully
49 * this will be simplified out one day.
51 struct dm_target_io {
52 struct dm_io *io;
53 struct dm_target *ti;
54 union map_info info;
57 DEFINE_TRACE(block_bio_complete);
60 * For request-based dm.
61 * One of these is allocated per request.
63 struct dm_rq_target_io {
64 struct mapped_device *md;
65 struct dm_target *ti;
66 struct request *orig, clone;
67 int error;
68 union map_info info;
72 * For request-based dm.
73 * One of these is allocated per bio.
75 struct dm_rq_clone_bio_info {
76 struct bio *orig;
77 struct request *rq;
80 union map_info *dm_get_mapinfo(struct bio *bio)
82 if (bio && bio->bi_private)
83 return &((struct dm_target_io *)bio->bi_private)->info;
84 return NULL;
87 #define MINOR_ALLOCED ((void *)-1)
90 * Bits for the md->flags field.
92 #define DMF_BLOCK_IO 0
93 #define DMF_SUSPENDED 1
94 #define DMF_FROZEN 2
95 #define DMF_FREEING 3
96 #define DMF_DELETING 4
97 #define DMF_NOFLUSH_SUSPENDING 5
100 * Work processed by per-device workqueue.
102 struct mapped_device {
103 struct rw_semaphore io_lock;
104 struct mutex suspend_lock;
105 rwlock_t map_lock;
106 atomic_t holders;
107 atomic_t open_count;
109 unsigned long flags;
111 struct request_queue *queue;
112 struct gendisk *disk;
113 char name[16];
115 void *interface_ptr;
118 * A list of ios that arrived while we were suspended.
120 atomic_t pending;
121 wait_queue_head_t wait;
122 struct work_struct work;
123 struct bio_list deferred;
124 spinlock_t deferred_lock;
127 * Processing queue (flush/barriers)
129 struct workqueue_struct *wq;
132 * The current mapping.
134 struct dm_table *map;
137 * io objects are allocated from here.
139 mempool_t *io_pool;
140 mempool_t *tio_pool;
142 struct bio_set *bs;
145 * Event handling.
147 atomic_t event_nr;
148 wait_queue_head_t eventq;
149 atomic_t uevent_seq;
150 struct list_head uevent_list;
151 spinlock_t uevent_lock; /* Protect access to uevent_list */
154 * freeze/thaw support require holding onto a super block
156 struct super_block *frozen_sb;
157 struct block_device *suspended_bdev;
159 /* forced geometry settings */
160 struct hd_geometry geometry;
162 /* sysfs handle */
163 struct kobject kobj;
166 #define MIN_IOS 256
167 static struct kmem_cache *_io_cache;
168 static struct kmem_cache *_tio_cache;
169 static struct kmem_cache *_rq_tio_cache;
170 static struct kmem_cache *_rq_bio_info_cache;
172 static int __init local_init(void)
174 int r = -ENOMEM;
176 /* allocate a slab for the dm_ios */
177 _io_cache = KMEM_CACHE(dm_io, 0);
178 if (!_io_cache)
179 return r;
181 /* allocate a slab for the target ios */
182 _tio_cache = KMEM_CACHE(dm_target_io, 0);
183 if (!_tio_cache)
184 goto out_free_io_cache;
186 _rq_tio_cache = KMEM_CACHE(dm_rq_target_io, 0);
187 if (!_rq_tio_cache)
188 goto out_free_tio_cache;
190 _rq_bio_info_cache = KMEM_CACHE(dm_rq_clone_bio_info, 0);
191 if (!_rq_bio_info_cache)
192 goto out_free_rq_tio_cache;
194 r = dm_uevent_init();
195 if (r)
196 goto out_free_rq_bio_info_cache;
198 _major = major;
199 r = register_blkdev(_major, _name);
200 if (r < 0)
201 goto out_uevent_exit;
203 if (!_major)
204 _major = r;
206 return 0;
208 out_uevent_exit:
209 dm_uevent_exit();
210 out_free_rq_bio_info_cache:
211 kmem_cache_destroy(_rq_bio_info_cache);
212 out_free_rq_tio_cache:
213 kmem_cache_destroy(_rq_tio_cache);
214 out_free_tio_cache:
215 kmem_cache_destroy(_tio_cache);
216 out_free_io_cache:
217 kmem_cache_destroy(_io_cache);
219 return r;
222 static void local_exit(void)
224 kmem_cache_destroy(_rq_bio_info_cache);
225 kmem_cache_destroy(_rq_tio_cache);
226 kmem_cache_destroy(_tio_cache);
227 kmem_cache_destroy(_io_cache);
228 unregister_blkdev(_major, _name);
229 dm_uevent_exit();
231 _major = 0;
233 DMINFO("cleaned up");
236 static int (*_inits[])(void) __initdata = {
237 local_init,
238 dm_target_init,
239 dm_linear_init,
240 dm_stripe_init,
241 dm_kcopyd_init,
242 dm_interface_init,
245 static void (*_exits[])(void) = {
246 local_exit,
247 dm_target_exit,
248 dm_linear_exit,
249 dm_stripe_exit,
250 dm_kcopyd_exit,
251 dm_interface_exit,
254 static int __init dm_init(void)
256 const int count = ARRAY_SIZE(_inits);
258 int r, i;
260 for (i = 0; i < count; i++) {
261 r = _inits[i]();
262 if (r)
263 goto bad;
266 return 0;
268 bad:
269 while (i--)
270 _exits[i]();
272 return r;
275 static void __exit dm_exit(void)
277 int i = ARRAY_SIZE(_exits);
279 while (i--)
280 _exits[i]();
284 * Block device functions
286 static int dm_blk_open(struct block_device *bdev, fmode_t mode)
288 struct mapped_device *md;
290 spin_lock(&_minor_lock);
292 md = bdev->bd_disk->private_data;
293 if (!md)
294 goto out;
296 if (test_bit(DMF_FREEING, &md->flags) ||
297 test_bit(DMF_DELETING, &md->flags)) {
298 md = NULL;
299 goto out;
302 dm_get(md);
303 atomic_inc(&md->open_count);
305 out:
306 spin_unlock(&_minor_lock);
308 return md ? 0 : -ENXIO;
311 static int dm_blk_close(struct gendisk *disk, fmode_t mode)
313 struct mapped_device *md = disk->private_data;
314 atomic_dec(&md->open_count);
315 dm_put(md);
316 return 0;
319 int dm_open_count(struct mapped_device *md)
321 return atomic_read(&md->open_count);
325 * Guarantees nothing is using the device before it's deleted.
327 int dm_lock_for_deletion(struct mapped_device *md)
329 int r = 0;
331 spin_lock(&_minor_lock);
333 if (dm_open_count(md))
334 r = -EBUSY;
335 else
336 set_bit(DMF_DELETING, &md->flags);
338 spin_unlock(&_minor_lock);
340 return r;
343 static int dm_blk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
345 struct mapped_device *md = bdev->bd_disk->private_data;
347 return dm_get_geometry(md, geo);
350 static int dm_blk_ioctl(struct block_device *bdev, fmode_t mode,
351 unsigned int cmd, unsigned long arg)
353 struct mapped_device *md = bdev->bd_disk->private_data;
354 struct dm_table *map = dm_get_table(md);
355 struct dm_target *tgt;
356 int r = -ENOTTY;
358 if (!map || !dm_table_get_size(map))
359 goto out;
361 /* We only support devices that have a single target */
362 if (dm_table_get_num_targets(map) != 1)
363 goto out;
365 tgt = dm_table_get_target(map, 0);
367 if (dm_suspended(md)) {
368 r = -EAGAIN;
369 goto out;
372 if (tgt->type->ioctl)
373 r = tgt->type->ioctl(tgt, cmd, arg);
375 out:
376 dm_table_put(map);
378 return r;
381 static struct dm_io *alloc_io(struct mapped_device *md)
383 return mempool_alloc(md->io_pool, GFP_NOIO);
386 static void free_io(struct mapped_device *md, struct dm_io *io)
388 mempool_free(io, md->io_pool);
391 static struct dm_target_io *alloc_tio(struct mapped_device *md)
393 return mempool_alloc(md->tio_pool, GFP_NOIO);
396 static void free_tio(struct mapped_device *md, struct dm_target_io *tio)
398 mempool_free(tio, md->tio_pool);
401 static void start_io_acct(struct dm_io *io)
403 struct mapped_device *md = io->md;
404 int cpu;
406 io->start_time = jiffies;
408 cpu = part_stat_lock();
409 part_round_stats(cpu, &dm_disk(md)->part0);
410 part_stat_unlock();
411 dm_disk(md)->part0.in_flight = atomic_inc_return(&md->pending);
414 static void end_io_acct(struct dm_io *io)
416 struct mapped_device *md = io->md;
417 struct bio *bio = io->bio;
418 unsigned long duration = jiffies - io->start_time;
419 int pending, cpu;
420 int rw = bio_data_dir(bio);
422 cpu = part_stat_lock();
423 part_round_stats(cpu, &dm_disk(md)->part0);
424 part_stat_add(cpu, &dm_disk(md)->part0, ticks[rw], duration);
425 part_stat_unlock();
427 dm_disk(md)->part0.in_flight = pending =
428 atomic_dec_return(&md->pending);
430 /* nudge anyone waiting on suspend queue */
431 if (!pending)
432 wake_up(&md->wait);
436 * Add the bio to the list of deferred io.
438 static int queue_io(struct mapped_device *md, struct bio *bio)
440 down_write(&md->io_lock);
442 if (!test_bit(DMF_BLOCK_IO, &md->flags)) {
443 up_write(&md->io_lock);
444 return 1;
447 spin_lock_irq(&md->deferred_lock);
448 bio_list_add(&md->deferred, bio);
449 spin_unlock_irq(&md->deferred_lock);
451 up_write(&md->io_lock);
452 return 0; /* deferred successfully */
456 * Everyone (including functions in this file), should use this
457 * function to access the md->map field, and make sure they call
458 * dm_table_put() when finished.
460 struct dm_table *dm_get_table(struct mapped_device *md)
462 struct dm_table *t;
464 read_lock(&md->map_lock);
465 t = md->map;
466 if (t)
467 dm_table_get(t);
468 read_unlock(&md->map_lock);
470 return t;
474 * Get the geometry associated with a dm device
476 int dm_get_geometry(struct mapped_device *md, struct hd_geometry *geo)
478 *geo = md->geometry;
480 return 0;
484 * Set the geometry of a device.
486 int dm_set_geometry(struct mapped_device *md, struct hd_geometry *geo)
488 sector_t sz = (sector_t)geo->cylinders * geo->heads * geo->sectors;
490 if (geo->start > sz) {
491 DMWARN("Start sector is beyond the geometry limits.");
492 return -EINVAL;
495 md->geometry = *geo;
497 return 0;
500 /*-----------------------------------------------------------------
501 * CRUD START:
502 * A more elegant soln is in the works that uses the queue
503 * merge fn, unfortunately there are a couple of changes to
504 * the block layer that I want to make for this. So in the
505 * interests of getting something for people to use I give
506 * you this clearly demarcated crap.
507 *---------------------------------------------------------------*/
509 static int __noflush_suspending(struct mapped_device *md)
511 return test_bit(DMF_NOFLUSH_SUSPENDING, &md->flags);
515 * Decrements the number of outstanding ios that a bio has been
516 * cloned into, completing the original io if necc.
518 static void dec_pending(struct dm_io *io, int error)
520 unsigned long flags;
521 int io_error;
522 struct bio *bio;
523 struct mapped_device *md = io->md;
525 /* Push-back supersedes any I/O errors */
526 if (error && !(io->error > 0 && __noflush_suspending(md)))
527 io->error = error;
529 if (atomic_dec_and_test(&io->io_count)) {
530 if (io->error == DM_ENDIO_REQUEUE) {
532 * Target requested pushing back the I/O.
534 spin_lock_irqsave(&md->deferred_lock, flags);
535 if (__noflush_suspending(md))
536 bio_list_add(&md->deferred, io->bio);
537 else
538 /* noflush suspend was interrupted. */
539 io->error = -EIO;
540 spin_unlock_irqrestore(&md->deferred_lock, flags);
543 end_io_acct(io);
545 io_error = io->error;
546 bio = io->bio;
548 free_io(md, io);
550 if (io_error != DM_ENDIO_REQUEUE) {
551 trace_block_bio_complete(md->queue, bio);
553 bio_endio(bio, io_error);
558 static void clone_endio(struct bio *bio, int error)
560 int r = 0;
561 struct dm_target_io *tio = bio->bi_private;
562 struct dm_io *io = tio->io;
563 struct mapped_device *md = tio->io->md;
564 dm_endio_fn endio = tio->ti->type->end_io;
566 if (!bio_flagged(bio, BIO_UPTODATE) && !error)
567 error = -EIO;
569 if (endio) {
570 r = endio(tio->ti, bio, error, &tio->info);
571 if (r < 0 || r == DM_ENDIO_REQUEUE)
573 * error and requeue request are handled
574 * in dec_pending().
576 error = r;
577 else if (r == DM_ENDIO_INCOMPLETE)
578 /* The target will handle the io */
579 return;
580 else if (r) {
581 DMWARN("unimplemented target endio return value: %d", r);
582 BUG();
587 * Store md for cleanup instead of tio which is about to get freed.
589 bio->bi_private = md->bs;
591 free_tio(md, tio);
592 bio_put(bio);
593 dec_pending(io, error);
596 static sector_t max_io_len(struct mapped_device *md,
597 sector_t sector, struct dm_target *ti)
599 sector_t offset = sector - ti->begin;
600 sector_t len = ti->len - offset;
603 * Does the target need to split even further ?
605 if (ti->split_io) {
606 sector_t boundary;
607 boundary = ((offset + ti->split_io) & ~(ti->split_io - 1))
608 - offset;
609 if (len > boundary)
610 len = boundary;
613 return len;
616 static void __map_bio(struct dm_target *ti, struct bio *clone,
617 struct dm_target_io *tio)
619 int r;
620 sector_t sector;
621 struct mapped_device *md;
624 * Sanity checks.
626 BUG_ON(!clone->bi_size);
628 clone->bi_end_io = clone_endio;
629 clone->bi_private = tio;
632 * Map the clone. If r == 0 we don't need to do
633 * anything, the target has assumed ownership of
634 * this io.
636 atomic_inc(&tio->io->io_count);
637 sector = clone->bi_sector;
638 r = ti->type->map(ti, clone, &tio->info);
639 if (r == DM_MAPIO_REMAPPED) {
640 /* the bio has been remapped so dispatch it */
642 trace_block_remap(bdev_get_queue(clone->bi_bdev), clone,
643 tio->io->bio->bi_bdev->bd_dev,
644 clone->bi_sector, sector);
646 generic_make_request(clone);
647 } else if (r < 0 || r == DM_MAPIO_REQUEUE) {
648 /* error the io and bail out, or requeue it if needed */
649 md = tio->io->md;
650 dec_pending(tio->io, r);
652 * Store bio_set for cleanup.
654 clone->bi_private = md->bs;
655 bio_put(clone);
656 free_tio(md, tio);
657 } else if (r) {
658 DMWARN("unimplemented target map return value: %d", r);
659 BUG();
663 struct clone_info {
664 struct mapped_device *md;
665 struct dm_table *map;
666 struct bio *bio;
667 struct dm_io *io;
668 sector_t sector;
669 sector_t sector_count;
670 unsigned short idx;
673 static void dm_bio_destructor(struct bio *bio)
675 struct bio_set *bs = bio->bi_private;
677 bio_free(bio, bs);
681 * Creates a little bio that is just does part of a bvec.
683 static struct bio *split_bvec(struct bio *bio, sector_t sector,
684 unsigned short idx, unsigned int offset,
685 unsigned int len, struct bio_set *bs)
687 struct bio *clone;
688 struct bio_vec *bv = bio->bi_io_vec + idx;
690 clone = bio_alloc_bioset(GFP_NOIO, 1, bs);
691 clone->bi_destructor = dm_bio_destructor;
692 *clone->bi_io_vec = *bv;
694 clone->bi_sector = sector;
695 clone->bi_bdev = bio->bi_bdev;
696 clone->bi_rw = bio->bi_rw;
697 clone->bi_vcnt = 1;
698 clone->bi_size = to_bytes(len);
699 clone->bi_io_vec->bv_offset = offset;
700 clone->bi_io_vec->bv_len = clone->bi_size;
701 clone->bi_flags |= 1 << BIO_CLONED;
703 return clone;
707 * Creates a bio that consists of range of complete bvecs.
709 static struct bio *clone_bio(struct bio *bio, sector_t sector,
710 unsigned short idx, unsigned short bv_count,
711 unsigned int len, struct bio_set *bs)
713 struct bio *clone;
715 clone = bio_alloc_bioset(GFP_NOIO, bio->bi_max_vecs, bs);
716 __bio_clone(clone, bio);
717 clone->bi_destructor = dm_bio_destructor;
718 clone->bi_sector = sector;
719 clone->bi_idx = idx;
720 clone->bi_vcnt = idx + bv_count;
721 clone->bi_size = to_bytes(len);
722 clone->bi_flags &= ~(1 << BIO_SEG_VALID);
724 return clone;
727 static int __clone_and_map(struct clone_info *ci)
729 struct bio *clone, *bio = ci->bio;
730 struct dm_target *ti;
731 sector_t len = 0, max;
732 struct dm_target_io *tio;
734 ti = dm_table_find_target(ci->map, ci->sector);
735 if (!dm_target_is_valid(ti))
736 return -EIO;
738 max = max_io_len(ci->md, ci->sector, ti);
741 * Allocate a target io object.
743 tio = alloc_tio(ci->md);
744 tio->io = ci->io;
745 tio->ti = ti;
746 memset(&tio->info, 0, sizeof(tio->info));
748 if (ci->sector_count <= max) {
750 * Optimise for the simple case where we can do all of
751 * the remaining io with a single clone.
753 clone = clone_bio(bio, ci->sector, ci->idx,
754 bio->bi_vcnt - ci->idx, ci->sector_count,
755 ci->md->bs);
756 __map_bio(ti, clone, tio);
757 ci->sector_count = 0;
759 } else if (to_sector(bio->bi_io_vec[ci->idx].bv_len) <= max) {
761 * There are some bvecs that don't span targets.
762 * Do as many of these as possible.
764 int i;
765 sector_t remaining = max;
766 sector_t bv_len;
768 for (i = ci->idx; remaining && (i < bio->bi_vcnt); i++) {
769 bv_len = to_sector(bio->bi_io_vec[i].bv_len);
771 if (bv_len > remaining)
772 break;
774 remaining -= bv_len;
775 len += bv_len;
778 clone = clone_bio(bio, ci->sector, ci->idx, i - ci->idx, len,
779 ci->md->bs);
780 __map_bio(ti, clone, tio);
782 ci->sector += len;
783 ci->sector_count -= len;
784 ci->idx = i;
786 } else {
788 * Handle a bvec that must be split between two or more targets.
790 struct bio_vec *bv = bio->bi_io_vec + ci->idx;
791 sector_t remaining = to_sector(bv->bv_len);
792 unsigned int offset = 0;
794 do {
795 if (offset) {
796 ti = dm_table_find_target(ci->map, ci->sector);
797 if (!dm_target_is_valid(ti))
798 return -EIO;
800 max = max_io_len(ci->md, ci->sector, ti);
802 tio = alloc_tio(ci->md);
803 tio->io = ci->io;
804 tio->ti = ti;
805 memset(&tio->info, 0, sizeof(tio->info));
808 len = min(remaining, max);
810 clone = split_bvec(bio, ci->sector, ci->idx,
811 bv->bv_offset + offset, len,
812 ci->md->bs);
814 __map_bio(ti, clone, tio);
816 ci->sector += len;
817 ci->sector_count -= len;
818 offset += to_bytes(len);
819 } while (remaining -= len);
821 ci->idx++;
824 return 0;
828 * Split the bio into several clones and submit it to targets.
830 static void __split_and_process_bio(struct mapped_device *md, struct bio *bio)
832 struct clone_info ci;
833 int error = 0;
835 ci.map = dm_get_table(md);
836 if (unlikely(!ci.map)) {
837 bio_io_error(bio);
838 return;
840 if (unlikely(bio_barrier(bio) && !dm_table_barrier_ok(ci.map))) {
841 dm_table_put(ci.map);
842 bio_endio(bio, -EOPNOTSUPP);
843 return;
845 ci.md = md;
846 ci.bio = bio;
847 ci.io = alloc_io(md);
848 ci.io->error = 0;
849 atomic_set(&ci.io->io_count, 1);
850 ci.io->bio = bio;
851 ci.io->md = md;
852 ci.sector = bio->bi_sector;
853 ci.sector_count = bio_sectors(bio);
854 ci.idx = bio->bi_idx;
856 start_io_acct(ci.io);
857 while (ci.sector_count && !error)
858 error = __clone_and_map(&ci);
860 /* drop the extra reference count */
861 dec_pending(ci.io, error);
862 dm_table_put(ci.map);
864 /*-----------------------------------------------------------------
865 * CRUD END
866 *---------------------------------------------------------------*/
868 static int dm_merge_bvec(struct request_queue *q,
869 struct bvec_merge_data *bvm,
870 struct bio_vec *biovec)
872 struct mapped_device *md = q->queuedata;
873 struct dm_table *map = dm_get_table(md);
874 struct dm_target *ti;
875 sector_t max_sectors;
876 int max_size = 0;
878 if (unlikely(!map))
879 goto out;
881 ti = dm_table_find_target(map, bvm->bi_sector);
882 if (!dm_target_is_valid(ti))
883 goto out_table;
886 * Find maximum amount of I/O that won't need splitting
888 max_sectors = min(max_io_len(md, bvm->bi_sector, ti),
889 (sector_t) BIO_MAX_SECTORS);
890 max_size = (max_sectors << SECTOR_SHIFT) - bvm->bi_size;
891 if (max_size < 0)
892 max_size = 0;
895 * merge_bvec_fn() returns number of bytes
896 * it can accept at this offset
897 * max is precomputed maximal io size
899 if (max_size && ti->type->merge)
900 max_size = ti->type->merge(ti, bvm, biovec, max_size);
902 out_table:
903 dm_table_put(map);
905 out:
907 * Always allow an entire first page
909 if (max_size <= biovec->bv_len && !(bvm->bi_size >> SECTOR_SHIFT))
910 max_size = biovec->bv_len;
912 return max_size;
916 * The request function that just remaps the bio built up by
917 * dm_merge_bvec.
919 static int dm_request(struct request_queue *q, struct bio *bio)
921 int r = -EIO;
922 int rw = bio_data_dir(bio);
923 struct mapped_device *md = q->queuedata;
924 int cpu;
926 down_read(&md->io_lock);
928 cpu = part_stat_lock();
929 part_stat_inc(cpu, &dm_disk(md)->part0, ios[rw]);
930 part_stat_add(cpu, &dm_disk(md)->part0, sectors[rw], bio_sectors(bio));
931 part_stat_unlock();
934 * If we're suspended we have to queue
935 * this io for later.
937 while (test_bit(DMF_BLOCK_IO, &md->flags)) {
938 up_read(&md->io_lock);
940 if (bio_rw(bio) != READA)
941 r = queue_io(md, bio);
943 if (r <= 0)
944 goto out_req;
947 * We're in a while loop, because someone could suspend
948 * before we get to the following read lock.
950 down_read(&md->io_lock);
953 __split_and_process_bio(md, bio);
954 up_read(&md->io_lock);
955 return 0;
957 out_req:
958 if (r < 0)
959 bio_io_error(bio);
961 return 0;
964 static void dm_unplug_all(struct request_queue *q)
966 struct mapped_device *md = q->queuedata;
967 struct dm_table *map = dm_get_table(md);
969 if (map) {
970 dm_table_unplug_all(map);
971 dm_table_put(map);
975 static int dm_any_congested(void *congested_data, int bdi_bits)
977 int r = bdi_bits;
978 struct mapped_device *md = congested_data;
979 struct dm_table *map;
981 if (!test_bit(DMF_BLOCK_IO, &md->flags)) {
982 map = dm_get_table(md);
983 if (map) {
984 r = dm_table_any_congested(map, bdi_bits);
985 dm_table_put(map);
989 return r;
992 /*-----------------------------------------------------------------
993 * An IDR is used to keep track of allocated minor numbers.
994 *---------------------------------------------------------------*/
995 static DEFINE_IDR(_minor_idr);
997 static void free_minor(int minor)
999 spin_lock(&_minor_lock);
1000 idr_remove(&_minor_idr, minor);
1001 spin_unlock(&_minor_lock);
1005 * See if the device with a specific minor # is free.
1007 static int specific_minor(int minor)
1009 int r, m;
1011 if (minor >= (1 << MINORBITS))
1012 return -EINVAL;
1014 r = idr_pre_get(&_minor_idr, GFP_KERNEL);
1015 if (!r)
1016 return -ENOMEM;
1018 spin_lock(&_minor_lock);
1020 if (idr_find(&_minor_idr, minor)) {
1021 r = -EBUSY;
1022 goto out;
1025 r = idr_get_new_above(&_minor_idr, MINOR_ALLOCED, minor, &m);
1026 if (r)
1027 goto out;
1029 if (m != minor) {
1030 idr_remove(&_minor_idr, m);
1031 r = -EBUSY;
1032 goto out;
1035 out:
1036 spin_unlock(&_minor_lock);
1037 return r;
1040 static int next_free_minor(int *minor)
1042 int r, m;
1044 r = idr_pre_get(&_minor_idr, GFP_KERNEL);
1045 if (!r)
1046 return -ENOMEM;
1048 spin_lock(&_minor_lock);
1050 r = idr_get_new(&_minor_idr, MINOR_ALLOCED, &m);
1051 if (r)
1052 goto out;
1054 if (m >= (1 << MINORBITS)) {
1055 idr_remove(&_minor_idr, m);
1056 r = -ENOSPC;
1057 goto out;
1060 *minor = m;
1062 out:
1063 spin_unlock(&_minor_lock);
1064 return r;
1067 static struct block_device_operations dm_blk_dops;
1069 static void dm_wq_work(struct work_struct *work);
1072 * Allocate and initialise a blank device with a given minor.
1074 static struct mapped_device *alloc_dev(int minor)
1076 int r;
1077 struct mapped_device *md = kzalloc(sizeof(*md), GFP_KERNEL);
1078 void *old_md;
1080 if (!md) {
1081 DMWARN("unable to allocate device, out of memory.");
1082 return NULL;
1085 if (!try_module_get(THIS_MODULE))
1086 goto bad_module_get;
1088 /* get a minor number for the dev */
1089 if (minor == DM_ANY_MINOR)
1090 r = next_free_minor(&minor);
1091 else
1092 r = specific_minor(minor);
1093 if (r < 0)
1094 goto bad_minor;
1096 init_rwsem(&md->io_lock);
1097 mutex_init(&md->suspend_lock);
1098 spin_lock_init(&md->deferred_lock);
1099 rwlock_init(&md->map_lock);
1100 atomic_set(&md->holders, 1);
1101 atomic_set(&md->open_count, 0);
1102 atomic_set(&md->event_nr, 0);
1103 atomic_set(&md->uevent_seq, 0);
1104 INIT_LIST_HEAD(&md->uevent_list);
1105 spin_lock_init(&md->uevent_lock);
1107 md->queue = blk_alloc_queue(GFP_KERNEL);
1108 if (!md->queue)
1109 goto bad_queue;
1111 md->queue->queuedata = md;
1112 md->queue->backing_dev_info.congested_fn = dm_any_congested;
1113 md->queue->backing_dev_info.congested_data = md;
1114 blk_queue_make_request(md->queue, dm_request);
1115 blk_queue_bounce_limit(md->queue, BLK_BOUNCE_ANY);
1116 md->queue->unplug_fn = dm_unplug_all;
1117 blk_queue_merge_bvec(md->queue, dm_merge_bvec);
1119 md->io_pool = mempool_create_slab_pool(MIN_IOS, _io_cache);
1120 if (!md->io_pool)
1121 goto bad_io_pool;
1123 md->tio_pool = mempool_create_slab_pool(MIN_IOS, _tio_cache);
1124 if (!md->tio_pool)
1125 goto bad_tio_pool;
1127 md->bs = bioset_create(16, 0);
1128 if (!md->bs)
1129 goto bad_no_bioset;
1131 md->disk = alloc_disk(1);
1132 if (!md->disk)
1133 goto bad_disk;
1135 atomic_set(&md->pending, 0);
1136 init_waitqueue_head(&md->wait);
1137 INIT_WORK(&md->work, dm_wq_work);
1138 init_waitqueue_head(&md->eventq);
1140 md->disk->major = _major;
1141 md->disk->first_minor = minor;
1142 md->disk->fops = &dm_blk_dops;
1143 md->disk->queue = md->queue;
1144 md->disk->private_data = md;
1145 sprintf(md->disk->disk_name, "dm-%d", minor);
1146 add_disk(md->disk);
1147 format_dev_t(md->name, MKDEV(_major, minor));
1149 md->wq = create_singlethread_workqueue("kdmflush");
1150 if (!md->wq)
1151 goto bad_thread;
1153 /* Populate the mapping, nobody knows we exist yet */
1154 spin_lock(&_minor_lock);
1155 old_md = idr_replace(&_minor_idr, md, minor);
1156 spin_unlock(&_minor_lock);
1158 BUG_ON(old_md != MINOR_ALLOCED);
1160 return md;
1162 bad_thread:
1163 put_disk(md->disk);
1164 bad_disk:
1165 bioset_free(md->bs);
1166 bad_no_bioset:
1167 mempool_destroy(md->tio_pool);
1168 bad_tio_pool:
1169 mempool_destroy(md->io_pool);
1170 bad_io_pool:
1171 blk_cleanup_queue(md->queue);
1172 bad_queue:
1173 free_minor(minor);
1174 bad_minor:
1175 module_put(THIS_MODULE);
1176 bad_module_get:
1177 kfree(md);
1178 return NULL;
1181 static void unlock_fs(struct mapped_device *md);
1183 static void free_dev(struct mapped_device *md)
1185 int minor = MINOR(disk_devt(md->disk));
1187 if (md->suspended_bdev) {
1188 unlock_fs(md);
1189 bdput(md->suspended_bdev);
1191 destroy_workqueue(md->wq);
1192 mempool_destroy(md->tio_pool);
1193 mempool_destroy(md->io_pool);
1194 bioset_free(md->bs);
1195 del_gendisk(md->disk);
1196 free_minor(minor);
1198 spin_lock(&_minor_lock);
1199 md->disk->private_data = NULL;
1200 spin_unlock(&_minor_lock);
1202 put_disk(md->disk);
1203 blk_cleanup_queue(md->queue);
1204 module_put(THIS_MODULE);
1205 kfree(md);
1209 * Bind a table to the device.
1211 static void event_callback(void *context)
1213 unsigned long flags;
1214 LIST_HEAD(uevents);
1215 struct mapped_device *md = (struct mapped_device *) context;
1217 spin_lock_irqsave(&md->uevent_lock, flags);
1218 list_splice_init(&md->uevent_list, &uevents);
1219 spin_unlock_irqrestore(&md->uevent_lock, flags);
1221 dm_send_uevents(&uevents, &disk_to_dev(md->disk)->kobj);
1223 atomic_inc(&md->event_nr);
1224 wake_up(&md->eventq);
1227 static void __set_size(struct mapped_device *md, sector_t size)
1229 set_capacity(md->disk, size);
1231 mutex_lock(&md->suspended_bdev->bd_inode->i_mutex);
1232 i_size_write(md->suspended_bdev->bd_inode, (loff_t)size << SECTOR_SHIFT);
1233 mutex_unlock(&md->suspended_bdev->bd_inode->i_mutex);
1236 static int __bind(struct mapped_device *md, struct dm_table *t)
1238 struct request_queue *q = md->queue;
1239 sector_t size;
1241 size = dm_table_get_size(t);
1244 * Wipe any geometry if the size of the table changed.
1246 if (size != get_capacity(md->disk))
1247 memset(&md->geometry, 0, sizeof(md->geometry));
1249 if (md->suspended_bdev)
1250 __set_size(md, size);
1252 if (!size) {
1253 dm_table_destroy(t);
1254 return 0;
1257 dm_table_event_callback(t, event_callback, md);
1259 write_lock(&md->map_lock);
1260 md->map = t;
1261 dm_table_set_restrictions(t, q);
1262 write_unlock(&md->map_lock);
1264 return 0;
1267 static void __unbind(struct mapped_device *md)
1269 struct dm_table *map = md->map;
1271 if (!map)
1272 return;
1274 dm_table_event_callback(map, NULL, NULL);
1275 write_lock(&md->map_lock);
1276 md->map = NULL;
1277 write_unlock(&md->map_lock);
1278 dm_table_destroy(map);
1282 * Constructor for a new device.
1284 int dm_create(int minor, struct mapped_device **result)
1286 struct mapped_device *md;
1288 md = alloc_dev(minor);
1289 if (!md)
1290 return -ENXIO;
1292 dm_sysfs_init(md);
1294 *result = md;
1295 return 0;
1298 static struct mapped_device *dm_find_md(dev_t dev)
1300 struct mapped_device *md;
1301 unsigned minor = MINOR(dev);
1303 if (MAJOR(dev) != _major || minor >= (1 << MINORBITS))
1304 return NULL;
1306 spin_lock(&_minor_lock);
1308 md = idr_find(&_minor_idr, minor);
1309 if (md && (md == MINOR_ALLOCED ||
1310 (MINOR(disk_devt(dm_disk(md))) != minor) ||
1311 test_bit(DMF_FREEING, &md->flags))) {
1312 md = NULL;
1313 goto out;
1316 out:
1317 spin_unlock(&_minor_lock);
1319 return md;
1322 struct mapped_device *dm_get_md(dev_t dev)
1324 struct mapped_device *md = dm_find_md(dev);
1326 if (md)
1327 dm_get(md);
1329 return md;
1332 void *dm_get_mdptr(struct mapped_device *md)
1334 return md->interface_ptr;
1337 void dm_set_mdptr(struct mapped_device *md, void *ptr)
1339 md->interface_ptr = ptr;
1342 void dm_get(struct mapped_device *md)
1344 atomic_inc(&md->holders);
1347 const char *dm_device_name(struct mapped_device *md)
1349 return md->name;
1351 EXPORT_SYMBOL_GPL(dm_device_name);
1353 void dm_put(struct mapped_device *md)
1355 struct dm_table *map;
1357 BUG_ON(test_bit(DMF_FREEING, &md->flags));
1359 if (atomic_dec_and_lock(&md->holders, &_minor_lock)) {
1360 map = dm_get_table(md);
1361 idr_replace(&_minor_idr, MINOR_ALLOCED,
1362 MINOR(disk_devt(dm_disk(md))));
1363 set_bit(DMF_FREEING, &md->flags);
1364 spin_unlock(&_minor_lock);
1365 if (!dm_suspended(md)) {
1366 dm_table_presuspend_targets(map);
1367 dm_table_postsuspend_targets(map);
1369 dm_sysfs_exit(md);
1370 dm_table_put(map);
1371 __unbind(md);
1372 free_dev(md);
1375 EXPORT_SYMBOL_GPL(dm_put);
1377 static int dm_wait_for_completion(struct mapped_device *md, int interruptible)
1379 int r = 0;
1381 while (1) {
1382 set_current_state(interruptible);
1384 smp_mb();
1385 if (!atomic_read(&md->pending))
1386 break;
1388 if (interruptible == TASK_INTERRUPTIBLE &&
1389 signal_pending(current)) {
1390 r = -EINTR;
1391 break;
1394 io_schedule();
1396 set_current_state(TASK_RUNNING);
1398 return r;
1402 * Process the deferred bios
1404 static void dm_wq_work(struct work_struct *work)
1406 struct mapped_device *md = container_of(work, struct mapped_device,
1407 work);
1408 struct bio *c;
1410 down_write(&md->io_lock);
1412 next_bio:
1413 spin_lock_irq(&md->deferred_lock);
1414 c = bio_list_pop(&md->deferred);
1415 spin_unlock_irq(&md->deferred_lock);
1417 if (c) {
1418 __split_and_process_bio(md, c);
1419 goto next_bio;
1422 clear_bit(DMF_BLOCK_IO, &md->flags);
1424 up_write(&md->io_lock);
1427 static void dm_queue_flush(struct mapped_device *md)
1429 queue_work(md->wq, &md->work);
1430 flush_workqueue(md->wq);
1434 * Swap in a new table (destroying old one).
1436 int dm_swap_table(struct mapped_device *md, struct dm_table *table)
1438 int r = -EINVAL;
1440 mutex_lock(&md->suspend_lock);
1442 /* device must be suspended */
1443 if (!dm_suspended(md))
1444 goto out;
1446 /* without bdev, the device size cannot be changed */
1447 if (!md->suspended_bdev)
1448 if (get_capacity(md->disk) != dm_table_get_size(table))
1449 goto out;
1451 __unbind(md);
1452 r = __bind(md, table);
1454 out:
1455 mutex_unlock(&md->suspend_lock);
1456 return r;
1460 * Functions to lock and unlock any filesystem running on the
1461 * device.
1463 static int lock_fs(struct mapped_device *md)
1465 int r;
1467 WARN_ON(md->frozen_sb);
1469 md->frozen_sb = freeze_bdev(md->suspended_bdev);
1470 if (IS_ERR(md->frozen_sb)) {
1471 r = PTR_ERR(md->frozen_sb);
1472 md->frozen_sb = NULL;
1473 return r;
1476 set_bit(DMF_FROZEN, &md->flags);
1478 /* don't bdput right now, we don't want the bdev
1479 * to go away while it is locked.
1481 return 0;
1484 static void unlock_fs(struct mapped_device *md)
1486 if (!test_bit(DMF_FROZEN, &md->flags))
1487 return;
1489 thaw_bdev(md->suspended_bdev, md->frozen_sb);
1490 md->frozen_sb = NULL;
1491 clear_bit(DMF_FROZEN, &md->flags);
1495 * We need to be able to change a mapping table under a mounted
1496 * filesystem. For example we might want to move some data in
1497 * the background. Before the table can be swapped with
1498 * dm_bind_table, dm_suspend must be called to flush any in
1499 * flight bios and ensure that any further io gets deferred.
1501 int dm_suspend(struct mapped_device *md, unsigned suspend_flags)
1503 struct dm_table *map = NULL;
1504 DECLARE_WAITQUEUE(wait, current);
1505 int r = 0;
1506 int do_lockfs = suspend_flags & DM_SUSPEND_LOCKFS_FLAG ? 1 : 0;
1507 int noflush = suspend_flags & DM_SUSPEND_NOFLUSH_FLAG ? 1 : 0;
1509 mutex_lock(&md->suspend_lock);
1511 if (dm_suspended(md)) {
1512 r = -EINVAL;
1513 goto out_unlock;
1516 map = dm_get_table(md);
1519 * DMF_NOFLUSH_SUSPENDING must be set before presuspend.
1520 * This flag is cleared before dm_suspend returns.
1522 if (noflush)
1523 set_bit(DMF_NOFLUSH_SUSPENDING, &md->flags);
1525 /* This does not get reverted if there's an error later. */
1526 dm_table_presuspend_targets(map);
1528 /* bdget() can stall if the pending I/Os are not flushed */
1529 if (!noflush) {
1530 md->suspended_bdev = bdget_disk(md->disk, 0);
1531 if (!md->suspended_bdev) {
1532 DMWARN("bdget failed in dm_suspend");
1533 r = -ENOMEM;
1534 goto out;
1538 * Flush I/O to the device. noflush supersedes do_lockfs,
1539 * because lock_fs() needs to flush I/Os.
1541 if (do_lockfs) {
1542 r = lock_fs(md);
1543 if (r)
1544 goto out;
1549 * First we set the BLOCK_IO flag so no more ios will be mapped.
1551 down_write(&md->io_lock);
1552 set_bit(DMF_BLOCK_IO, &md->flags);
1554 add_wait_queue(&md->wait, &wait);
1555 up_write(&md->io_lock);
1557 /* unplug */
1558 if (map)
1559 dm_table_unplug_all(map);
1562 * Wait for the already-mapped ios to complete.
1564 r = dm_wait_for_completion(md, TASK_INTERRUPTIBLE);
1566 down_write(&md->io_lock);
1567 remove_wait_queue(&md->wait, &wait);
1569 if (noflush)
1570 clear_bit(DMF_NOFLUSH_SUSPENDING, &md->flags);
1571 up_write(&md->io_lock);
1573 /* were we interrupted ? */
1574 if (r < 0) {
1575 dm_queue_flush(md);
1577 unlock_fs(md);
1578 goto out; /* pushback list is already flushed, so skip flush */
1581 dm_table_postsuspend_targets(map);
1583 set_bit(DMF_SUSPENDED, &md->flags);
1585 out:
1586 if (r && md->suspended_bdev) {
1587 bdput(md->suspended_bdev);
1588 md->suspended_bdev = NULL;
1591 dm_table_put(map);
1593 out_unlock:
1594 mutex_unlock(&md->suspend_lock);
1595 return r;
1598 int dm_resume(struct mapped_device *md)
1600 int r = -EINVAL;
1601 struct dm_table *map = NULL;
1603 mutex_lock(&md->suspend_lock);
1604 if (!dm_suspended(md))
1605 goto out;
1607 map = dm_get_table(md);
1608 if (!map || !dm_table_get_size(map))
1609 goto out;
1611 r = dm_table_resume_targets(map);
1612 if (r)
1613 goto out;
1615 dm_queue_flush(md);
1617 unlock_fs(md);
1619 if (md->suspended_bdev) {
1620 bdput(md->suspended_bdev);
1621 md->suspended_bdev = NULL;
1624 clear_bit(DMF_SUSPENDED, &md->flags);
1626 dm_table_unplug_all(map);
1628 dm_kobject_uevent(md);
1630 r = 0;
1632 out:
1633 dm_table_put(map);
1634 mutex_unlock(&md->suspend_lock);
1636 return r;
1639 /*-----------------------------------------------------------------
1640 * Event notification.
1641 *---------------------------------------------------------------*/
1642 void dm_kobject_uevent(struct mapped_device *md)
1644 kobject_uevent(&disk_to_dev(md->disk)->kobj, KOBJ_CHANGE);
1647 uint32_t dm_next_uevent_seq(struct mapped_device *md)
1649 return atomic_add_return(1, &md->uevent_seq);
1652 uint32_t dm_get_event_nr(struct mapped_device *md)
1654 return atomic_read(&md->event_nr);
1657 int dm_wait_event(struct mapped_device *md, int event_nr)
1659 return wait_event_interruptible(md->eventq,
1660 (event_nr != atomic_read(&md->event_nr)));
1663 void dm_uevent_add(struct mapped_device *md, struct list_head *elist)
1665 unsigned long flags;
1667 spin_lock_irqsave(&md->uevent_lock, flags);
1668 list_add(elist, &md->uevent_list);
1669 spin_unlock_irqrestore(&md->uevent_lock, flags);
1673 * The gendisk is only valid as long as you have a reference
1674 * count on 'md'.
1676 struct gendisk *dm_disk(struct mapped_device *md)
1678 return md->disk;
1681 struct kobject *dm_kobject(struct mapped_device *md)
1683 return &md->kobj;
1687 * struct mapped_device should not be exported outside of dm.c
1688 * so use this check to verify that kobj is part of md structure
1690 struct mapped_device *dm_get_from_kobject(struct kobject *kobj)
1692 struct mapped_device *md;
1694 md = container_of(kobj, struct mapped_device, kobj);
1695 if (&md->kobj != kobj)
1696 return NULL;
1698 dm_get(md);
1699 return md;
1702 int dm_suspended(struct mapped_device *md)
1704 return test_bit(DMF_SUSPENDED, &md->flags);
1707 int dm_noflush_suspending(struct dm_target *ti)
1709 struct mapped_device *md = dm_table_get_md(ti->table);
1710 int r = __noflush_suspending(md);
1712 dm_put(md);
1714 return r;
1716 EXPORT_SYMBOL_GPL(dm_noflush_suspending);
1718 static struct block_device_operations dm_blk_dops = {
1719 .open = dm_blk_open,
1720 .release = dm_blk_close,
1721 .ioctl = dm_blk_ioctl,
1722 .getgeo = dm_blk_getgeo,
1723 .owner = THIS_MODULE
1726 EXPORT_SYMBOL(dm_get_mapinfo);
1729 * module hooks
1731 module_init(dm_init);
1732 module_exit(dm_exit);
1734 module_param(major, uint, 0);
1735 MODULE_PARM_DESC(major, "The major number of the device mapper");
1736 MODULE_DESCRIPTION(DM_NAME " driver");
1737 MODULE_AUTHOR("Joe Thornber <dm-devel@redhat.com>");
1738 MODULE_LICENSE("GPL");