1 /* 2 * Copyright (C) 2001, 2002 Sistina Software (UK) Limited. 3 * Copyright (C) 2004-2006 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 #include "dm-uevent.h" 11 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> 25 26 #define DM_MSG_PREFIX "core" 27 28 static const char *_name = DM_NAME; 29 30 static unsigned int major = 0; 31 static unsigned int _major = 0; 32 33 static DEFINE_SPINLOCK(_minor_lock); 34 /* 35 * For bio-based dm. 36 * One of these is allocated per bio. 37 */ 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; 44 }; 45 46 /* 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. 50 */ 51 struct dm_target_io { 52 struct dm_io *io; 53 struct dm_target *ti; 54 union map_info info; 55 }; 56 57 DEFINE_TRACE(block_bio_complete); 58 59 /* 60 * For request-based dm. 61 * One of these is allocated per request. 62 */ 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; 69 }; 70 71 /* 72 * For request-based dm. 73 * One of these is allocated per bio. 74 */ 75 struct dm_rq_clone_bio_info { 76 struct bio *orig; 77 struct request *rq; 78 }; 79 80 union map_info *dm_get_mapinfo(struct bio *bio) 81 { 82 if (bio && bio->bi_private) 83 return &((struct dm_target_io *)bio->bi_private)->info; 84 return NULL; 85 } 86 87 #define MINOR_ALLOCED ((void *)-1) 88 89 /* 90 * Bits for the md->flags field. 91 */ 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 98 99 /* 100 * Work processed by per-device workqueue. 101 */ 102 struct dm_wq_req { 103 enum { 104 DM_WQ_FLUSH_DEFERRED, 105 } type; 106 struct work_struct work; 107 struct mapped_device *md; 108 void *context; 109 }; 110 111 struct mapped_device { 112 struct rw_semaphore io_lock; 113 struct mutex suspend_lock; 114 spinlock_t pushback_lock; 115 rwlock_t map_lock; 116 atomic_t holders; 117 atomic_t open_count; 118 119 unsigned long flags; 120 121 struct request_queue *queue; 122 struct gendisk *disk; 123 char name[16]; 124 125 void *interface_ptr; 126 127 /* 128 * A list of ios that arrived while we were suspended. 129 */ 130 atomic_t pending; 131 wait_queue_head_t wait; 132 struct bio_list deferred; 133 struct bio_list pushback; 134 135 /* 136 * Processing queue (flush/barriers) 137 */ 138 struct workqueue_struct *wq; 139 140 /* 141 * The current mapping. 142 */ 143 struct dm_table *map; 144 145 /* 146 * io objects are allocated from here. 147 */ 148 mempool_t *io_pool; 149 mempool_t *tio_pool; 150 151 struct bio_set *bs; 152 153 /* 154 * Event handling. 155 */ 156 atomic_t event_nr; 157 wait_queue_head_t eventq; 158 atomic_t uevent_seq; 159 struct list_head uevent_list; 160 spinlock_t uevent_lock; /* Protect access to uevent_list */ 161 162 /* 163 * freeze/thaw support require holding onto a super block 164 */ 165 struct super_block *frozen_sb; 166 struct block_device *suspended_bdev; 167 168 /* forced geometry settings */ 169 struct hd_geometry geometry; 170 }; 171 172 #define MIN_IOS 256 173 static struct kmem_cache *_io_cache; 174 static struct kmem_cache *_tio_cache; 175 static struct kmem_cache *_rq_tio_cache; 176 static struct kmem_cache *_rq_bio_info_cache; 177 178 static int __init local_init(void) 179 { 180 int r = -ENOMEM; 181 182 /* allocate a slab for the dm_ios */ 183 _io_cache = KMEM_CACHE(dm_io, 0); 184 if (!_io_cache) 185 return r; 186 187 /* allocate a slab for the target ios */ 188 _tio_cache = KMEM_CACHE(dm_target_io, 0); 189 if (!_tio_cache) 190 goto out_free_io_cache; 191 192 _rq_tio_cache = KMEM_CACHE(dm_rq_target_io, 0); 193 if (!_rq_tio_cache) 194 goto out_free_tio_cache; 195 196 _rq_bio_info_cache = KMEM_CACHE(dm_rq_clone_bio_info, 0); 197 if (!_rq_bio_info_cache) 198 goto out_free_rq_tio_cache; 199 200 r = dm_uevent_init(); 201 if (r) 202 goto out_free_rq_bio_info_cache; 203 204 _major = major; 205 r = register_blkdev(_major, _name); 206 if (r < 0) 207 goto out_uevent_exit; 208 209 if (!_major) 210 _major = r; 211 212 return 0; 213 214 out_uevent_exit: 215 dm_uevent_exit(); 216 out_free_rq_bio_info_cache: 217 kmem_cache_destroy(_rq_bio_info_cache); 218 out_free_rq_tio_cache: 219 kmem_cache_destroy(_rq_tio_cache); 220 out_free_tio_cache: 221 kmem_cache_destroy(_tio_cache); 222 out_free_io_cache: 223 kmem_cache_destroy(_io_cache); 224 225 return r; 226 } 227 228 static void local_exit(void) 229 { 230 kmem_cache_destroy(_rq_bio_info_cache); 231 kmem_cache_destroy(_rq_tio_cache); 232 kmem_cache_destroy(_tio_cache); 233 kmem_cache_destroy(_io_cache); 234 unregister_blkdev(_major, _name); 235 dm_uevent_exit(); 236 237 _major = 0; 238 239 DMINFO("cleaned up"); 240 } 241 242 static int (*_inits[])(void) __initdata = { 243 local_init, 244 dm_target_init, 245 dm_linear_init, 246 dm_stripe_init, 247 dm_kcopyd_init, 248 dm_interface_init, 249 }; 250 251 static void (*_exits[])(void) = { 252 local_exit, 253 dm_target_exit, 254 dm_linear_exit, 255 dm_stripe_exit, 256 dm_kcopyd_exit, 257 dm_interface_exit, 258 }; 259 260 static int __init dm_init(void) 261 { 262 const int count = ARRAY_SIZE(_inits); 263 264 int r, i; 265 266 for (i = 0; i < count; i++) { 267 r = _inits[i](); 268 if (r) 269 goto bad; 270 } 271 272 return 0; 273 274 bad: 275 while (i--) 276 _exits[i](); 277 278 return r; 279 } 280 281 static void __exit dm_exit(void) 282 { 283 int i = ARRAY_SIZE(_exits); 284 285 while (i--) 286 _exits[i](); 287 } 288 289 /* 290 * Block device functions 291 */ 292 static int dm_blk_open(struct block_device *bdev, fmode_t mode) 293 { 294 struct mapped_device *md; 295 296 spin_lock(&_minor_lock); 297 298 md = bdev->bd_disk->private_data; 299 if (!md) 300 goto out; 301 302 if (test_bit(DMF_FREEING, &md->flags) || 303 test_bit(DMF_DELETING, &md->flags)) { 304 md = NULL; 305 goto out; 306 } 307 308 dm_get(md); 309 atomic_inc(&md->open_count); 310 311 out: 312 spin_unlock(&_minor_lock); 313 314 return md ? 0 : -ENXIO; 315 } 316 317 static int dm_blk_close(struct gendisk *disk, fmode_t mode) 318 { 319 struct mapped_device *md = disk->private_data; 320 atomic_dec(&md->open_count); 321 dm_put(md); 322 return 0; 323 } 324 325 int dm_open_count(struct mapped_device *md) 326 { 327 return atomic_read(&md->open_count); 328 } 329 330 /* 331 * Guarantees nothing is using the device before it's deleted. 332 */ 333 int dm_lock_for_deletion(struct mapped_device *md) 334 { 335 int r = 0; 336 337 spin_lock(&_minor_lock); 338 339 if (dm_open_count(md)) 340 r = -EBUSY; 341 else 342 set_bit(DMF_DELETING, &md->flags); 343 344 spin_unlock(&_minor_lock); 345 346 return r; 347 } 348 349 static int dm_blk_getgeo(struct block_device *bdev, struct hd_geometry *geo) 350 { 351 struct mapped_device *md = bdev->bd_disk->private_data; 352 353 return dm_get_geometry(md, geo); 354 } 355 356 static int dm_blk_ioctl(struct block_device *bdev, fmode_t mode, 357 unsigned int cmd, unsigned long arg) 358 { 359 struct mapped_device *md = bdev->bd_disk->private_data; 360 struct dm_table *map = dm_get_table(md); 361 struct dm_target *tgt; 362 int r = -ENOTTY; 363 364 if (!map || !dm_table_get_size(map)) 365 goto out; 366 367 /* We only support devices that have a single target */ 368 if (dm_table_get_num_targets(map) != 1) 369 goto out; 370 371 tgt = dm_table_get_target(map, 0); 372 373 if (dm_suspended(md)) { 374 r = -EAGAIN; 375 goto out; 376 } 377 378 if (tgt->type->ioctl) 379 r = tgt->type->ioctl(tgt, cmd, arg); 380 381 out: 382 dm_table_put(map); 383 384 return r; 385 } 386 387 static struct dm_io *alloc_io(struct mapped_device *md) 388 { 389 return mempool_alloc(md->io_pool, GFP_NOIO); 390 } 391 392 static void free_io(struct mapped_device *md, struct dm_io *io) 393 { 394 mempool_free(io, md->io_pool); 395 } 396 397 static struct dm_target_io *alloc_tio(struct mapped_device *md) 398 { 399 return mempool_alloc(md->tio_pool, GFP_NOIO); 400 } 401 402 static void free_tio(struct mapped_device *md, struct dm_target_io *tio) 403 { 404 mempool_free(tio, md->tio_pool); 405 } 406 407 static void start_io_acct(struct dm_io *io) 408 { 409 struct mapped_device *md = io->md; 410 int cpu; 411 412 io->start_time = jiffies; 413 414 cpu = part_stat_lock(); 415 part_round_stats(cpu, &dm_disk(md)->part0); 416 part_stat_unlock(); 417 dm_disk(md)->part0.in_flight = atomic_inc_return(&md->pending); 418 } 419 420 static void end_io_acct(struct dm_io *io) 421 { 422 struct mapped_device *md = io->md; 423 struct bio *bio = io->bio; 424 unsigned long duration = jiffies - io->start_time; 425 int pending, cpu; 426 int rw = bio_data_dir(bio); 427 428 cpu = part_stat_lock(); 429 part_round_stats(cpu, &dm_disk(md)->part0); 430 part_stat_add(cpu, &dm_disk(md)->part0, ticks[rw], duration); 431 part_stat_unlock(); 432 433 dm_disk(md)->part0.in_flight = pending = 434 atomic_dec_return(&md->pending); 435 436 /* nudge anyone waiting on suspend queue */ 437 if (!pending) 438 wake_up(&md->wait); 439 } 440 441 /* 442 * Add the bio to the list of deferred io. 443 */ 444 static int queue_io(struct mapped_device *md, struct bio *bio) 445 { 446 down_write(&md->io_lock); 447 448 if (!test_bit(DMF_BLOCK_IO, &md->flags)) { 449 up_write(&md->io_lock); 450 return 1; 451 } 452 453 bio_list_add(&md->deferred, bio); 454 455 up_write(&md->io_lock); 456 return 0; /* deferred successfully */ 457 } 458 459 /* 460 * Everyone (including functions in this file), should use this 461 * function to access the md->map field, and make sure they call 462 * dm_table_put() when finished. 463 */ 464 struct dm_table *dm_get_table(struct mapped_device *md) 465 { 466 struct dm_table *t; 467 468 read_lock(&md->map_lock); 469 t = md->map; 470 if (t) 471 dm_table_get(t); 472 read_unlock(&md->map_lock); 473 474 return t; 475 } 476 477 /* 478 * Get the geometry associated with a dm device 479 */ 480 int dm_get_geometry(struct mapped_device *md, struct hd_geometry *geo) 481 { 482 *geo = md->geometry; 483 484 return 0; 485 } 486 487 /* 488 * Set the geometry of a device. 489 */ 490 int dm_set_geometry(struct mapped_device *md, struct hd_geometry *geo) 491 { 492 sector_t sz = (sector_t)geo->cylinders * geo->heads * geo->sectors; 493 494 if (geo->start > sz) { 495 DMWARN("Start sector is beyond the geometry limits."); 496 return -EINVAL; 497 } 498 499 md->geometry = *geo; 500 501 return 0; 502 } 503 504 /*----------------------------------------------------------------- 505 * CRUD START: 506 * A more elegant soln is in the works that uses the queue 507 * merge fn, unfortunately there are a couple of changes to 508 * the block layer that I want to make for this. So in the 509 * interests of getting something for people to use I give 510 * you this clearly demarcated crap. 511 *---------------------------------------------------------------*/ 512 513 static int __noflush_suspending(struct mapped_device *md) 514 { 515 return test_bit(DMF_NOFLUSH_SUSPENDING, &md->flags); 516 } 517 518 /* 519 * Decrements the number of outstanding ios that a bio has been 520 * cloned into, completing the original io if necc. 521 */ 522 static void dec_pending(struct dm_io *io, int error) 523 { 524 unsigned long flags; 525 526 /* Push-back supersedes any I/O errors */ 527 if (error && !(io->error > 0 && __noflush_suspending(io->md))) 528 io->error = error; 529 530 if (atomic_dec_and_test(&io->io_count)) { 531 if (io->error == DM_ENDIO_REQUEUE) { 532 /* 533 * Target requested pushing back the I/O. 534 * This must be handled before the sleeper on 535 * suspend queue merges the pushback list. 536 */ 537 spin_lock_irqsave(&io->md->pushback_lock, flags); 538 if (__noflush_suspending(io->md)) 539 bio_list_add(&io->md->pushback, io->bio); 540 else 541 /* noflush suspend was interrupted. */ 542 io->error = -EIO; 543 spin_unlock_irqrestore(&io->md->pushback_lock, flags); 544 } 545 546 end_io_acct(io); 547 548 if (io->error != DM_ENDIO_REQUEUE) { 549 trace_block_bio_complete(io->md->queue, io->bio); 550 551 bio_endio(io->bio, io->error); 552 } 553 554 free_io(io->md, io); 555 } 556 } 557 558 static void clone_endio(struct bio *bio, int error) 559 { 560 int r = 0; 561 struct dm_target_io *tio = bio->bi_private; 562 struct mapped_device *md = tio->io->md; 563 dm_endio_fn endio = tio->ti->type->end_io; 564 565 if (!bio_flagged(bio, BIO_UPTODATE) && !error) 566 error = -EIO; 567 568 if (endio) { 569 r = endio(tio->ti, bio, error, &tio->info); 570 if (r < 0 || r == DM_ENDIO_REQUEUE) 571 /* 572 * error and requeue request are handled 573 * in dec_pending(). 574 */ 575 error = r; 576 else if (r == DM_ENDIO_INCOMPLETE) 577 /* The target will handle the io */ 578 return; 579 else if (r) { 580 DMWARN("unimplemented target endio return value: %d", r); 581 BUG(); 582 } 583 } 584 585 dec_pending(tio->io, error); 586 587 /* 588 * Store md for cleanup instead of tio which is about to get freed. 589 */ 590 bio->bi_private = md->bs; 591 592 bio_put(bio); 593 free_tio(md, tio); 594 } 595 596 static sector_t max_io_len(struct mapped_device *md, 597 sector_t sector, struct dm_target *ti) 598 { 599 sector_t offset = sector - ti->begin; 600 sector_t len = ti->len - offset; 601 602 /* 603 * Does the target need to split even further ? 604 */ 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; 611 } 612 613 return len; 614 } 615 616 static void __map_bio(struct dm_target *ti, struct bio *clone, 617 struct dm_target_io *tio) 618 { 619 int r; 620 sector_t sector; 621 struct mapped_device *md; 622 623 /* 624 * Sanity checks. 625 */ 626 BUG_ON(!clone->bi_size); 627 628 clone->bi_end_io = clone_endio; 629 clone->bi_private = tio; 630 631 /* 632 * Map the clone. If r == 0 we don't need to do 633 * anything, the target has assumed ownership of 634 * this io. 635 */ 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 */ 641 642 trace_block_remap(bdev_get_queue(clone->bi_bdev), clone, 643 tio->io->bio->bi_bdev->bd_dev, 644 clone->bi_sector, sector); 645 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); 651 /* 652 * Store bio_set for cleanup. 653 */ 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(); 660 } 661 } 662 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; 671 }; 672 673 static void dm_bio_destructor(struct bio *bio) 674 { 675 struct bio_set *bs = bio->bi_private; 676 677 bio_free(bio, bs); 678 } 679 680 /* 681 * Creates a little bio that is just does part of a bvec. 682 */ 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) 686 { 687 struct bio *clone; 688 struct bio_vec *bv = bio->bi_io_vec + idx; 689 690 clone = bio_alloc_bioset(GFP_NOIO, 1, bs); 691 clone->bi_destructor = dm_bio_destructor; 692 *clone->bi_io_vec = *bv; 693 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; 702 703 return clone; 704 } 705 706 /* 707 * Creates a bio that consists of range of complete bvecs. 708 */ 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) 712 { 713 struct bio *clone; 714 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); 723 724 return clone; 725 } 726 727 static int __clone_and_map(struct clone_info *ci) 728 { 729 struct bio *clone, *bio = ci->bio; 730 struct dm_target *ti; 731 sector_t len = 0, max; 732 struct dm_target_io *tio; 733 734 ti = dm_table_find_target(ci->map, ci->sector); 735 if (!dm_target_is_valid(ti)) 736 return -EIO; 737 738 max = max_io_len(ci->md, ci->sector, ti); 739 740 /* 741 * Allocate a target io object. 742 */ 743 tio = alloc_tio(ci->md); 744 tio->io = ci->io; 745 tio->ti = ti; 746 memset(&tio->info, 0, sizeof(tio->info)); 747 748 if (ci->sector_count <= max) { 749 /* 750 * Optimise for the simple case where we can do all of 751 * the remaining io with a single clone. 752 */ 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; 758 759 } else if (to_sector(bio->bi_io_vec[ci->idx].bv_len) <= max) { 760 /* 761 * There are some bvecs that don't span targets. 762 * Do as many of these as possible. 763 */ 764 int i; 765 sector_t remaining = max; 766 sector_t bv_len; 767 768 for (i = ci->idx; remaining && (i < bio->bi_vcnt); i++) { 769 bv_len = to_sector(bio->bi_io_vec[i].bv_len); 770 771 if (bv_len > remaining) 772 break; 773 774 remaining -= bv_len; 775 len += bv_len; 776 } 777 778 clone = clone_bio(bio, ci->sector, ci->idx, i - ci->idx, len, 779 ci->md->bs); 780 __map_bio(ti, clone, tio); 781 782 ci->sector += len; 783 ci->sector_count -= len; 784 ci->idx = i; 785 786 } else { 787 /* 788 * Handle a bvec that must be split between two or more targets. 789 */ 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; 793 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; 799 800 max = max_io_len(ci->md, ci->sector, ti); 801 802 tio = alloc_tio(ci->md); 803 tio->io = ci->io; 804 tio->ti = ti; 805 memset(&tio->info, 0, sizeof(tio->info)); 806 } 807 808 len = min(remaining, max); 809 810 clone = split_bvec(bio, ci->sector, ci->idx, 811 bv->bv_offset + offset, len, 812 ci->md->bs); 813 814 __map_bio(ti, clone, tio); 815 816 ci->sector += len; 817 ci->sector_count -= len; 818 offset += to_bytes(len); 819 } while (remaining -= len); 820 821 ci->idx++; 822 } 823 824 return 0; 825 } 826 827 /* 828 * Split the bio into several clones. 829 */ 830 static int __split_bio(struct mapped_device *md, struct bio *bio) 831 { 832 struct clone_info ci; 833 int error = 0; 834 835 ci.map = dm_get_table(md); 836 if (unlikely(!ci.map)) 837 return -EIO; 838 if (unlikely(bio_barrier(bio) && !dm_table_barrier_ok(ci.map))) { 839 dm_table_put(ci.map); 840 bio_endio(bio, -EOPNOTSUPP); 841 return 0; 842 } 843 ci.md = md; 844 ci.bio = bio; 845 ci.io = alloc_io(md); 846 ci.io->error = 0; 847 atomic_set(&ci.io->io_count, 1); 848 ci.io->bio = bio; 849 ci.io->md = md; 850 ci.sector = bio->bi_sector; 851 ci.sector_count = bio_sectors(bio); 852 ci.idx = bio->bi_idx; 853 854 start_io_acct(ci.io); 855 while (ci.sector_count && !error) 856 error = __clone_and_map(&ci); 857 858 /* drop the extra reference count */ 859 dec_pending(ci.io, error); 860 dm_table_put(ci.map); 861 862 return 0; 863 } 864 /*----------------------------------------------------------------- 865 * CRUD END 866 *---------------------------------------------------------------*/ 867 868 static int dm_merge_bvec(struct request_queue *q, 869 struct bvec_merge_data *bvm, 870 struct bio_vec *biovec) 871 { 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; 877 878 if (unlikely(!map)) 879 goto out; 880 881 ti = dm_table_find_target(map, bvm->bi_sector); 882 if (!dm_target_is_valid(ti)) 883 goto out_table; 884 885 /* 886 * Find maximum amount of I/O that won't need splitting 887 */ 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; 893 894 /* 895 * merge_bvec_fn() returns number of bytes 896 * it can accept at this offset 897 * max is precomputed maximal io size 898 */ 899 if (max_size && ti->type->merge) 900 max_size = ti->type->merge(ti, bvm, biovec, max_size); 901 902 out_table: 903 dm_table_put(map); 904 905 out: 906 /* 907 * Always allow an entire first page 908 */ 909 if (max_size <= biovec->bv_len && !(bvm->bi_size >> SECTOR_SHIFT)) 910 max_size = biovec->bv_len; 911 912 return max_size; 913 } 914 915 /* 916 * The request function that just remaps the bio built up by 917 * dm_merge_bvec. 918 */ 919 static int dm_request(struct request_queue *q, struct bio *bio) 920 { 921 int r = -EIO; 922 int rw = bio_data_dir(bio); 923 struct mapped_device *md = q->queuedata; 924 int cpu; 925 926 down_read(&md->io_lock); 927 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(); 932 933 /* 934 * If we're suspended we have to queue 935 * this io for later. 936 */ 937 while (test_bit(DMF_BLOCK_IO, &md->flags)) { 938 up_read(&md->io_lock); 939 940 if (bio_rw(bio) != READA) 941 r = queue_io(md, bio); 942 943 if (r <= 0) 944 goto out_req; 945 946 /* 947 * We're in a while loop, because someone could suspend 948 * before we get to the following read lock. 949 */ 950 down_read(&md->io_lock); 951 } 952 953 r = __split_bio(md, bio); 954 up_read(&md->io_lock); 955 956 out_req: 957 if (r < 0) 958 bio_io_error(bio); 959 960 return 0; 961 } 962 963 static void dm_unplug_all(struct request_queue *q) 964 { 965 struct mapped_device *md = q->queuedata; 966 struct dm_table *map = dm_get_table(md); 967 968 if (map) { 969 dm_table_unplug_all(map); 970 dm_table_put(map); 971 } 972 } 973 974 static int dm_any_congested(void *congested_data, int bdi_bits) 975 { 976 int r = bdi_bits; 977 struct mapped_device *md = congested_data; 978 struct dm_table *map; 979 980 atomic_inc(&md->pending); 981 982 if (!test_bit(DMF_BLOCK_IO, &md->flags)) { 983 map = dm_get_table(md); 984 if (map) { 985 r = dm_table_any_congested(map, bdi_bits); 986 dm_table_put(map); 987 } 988 } 989 990 if (!atomic_dec_return(&md->pending)) 991 /* nudge anyone waiting on suspend queue */ 992 wake_up(&md->wait); 993 994 return r; 995 } 996 997 /*----------------------------------------------------------------- 998 * An IDR is used to keep track of allocated minor numbers. 999 *---------------------------------------------------------------*/ 1000 static DEFINE_IDR(_minor_idr); 1001 1002 static void free_minor(int minor) 1003 { 1004 spin_lock(&_minor_lock); 1005 idr_remove(&_minor_idr, minor); 1006 spin_unlock(&_minor_lock); 1007 } 1008 1009 /* 1010 * See if the device with a specific minor # is free. 1011 */ 1012 static int specific_minor(int minor) 1013 { 1014 int r, m; 1015 1016 if (minor >= (1 << MINORBITS)) 1017 return -EINVAL; 1018 1019 r = idr_pre_get(&_minor_idr, GFP_KERNEL); 1020 if (!r) 1021 return -ENOMEM; 1022 1023 spin_lock(&_minor_lock); 1024 1025 if (idr_find(&_minor_idr, minor)) { 1026 r = -EBUSY; 1027 goto out; 1028 } 1029 1030 r = idr_get_new_above(&_minor_idr, MINOR_ALLOCED, minor, &m); 1031 if (r) 1032 goto out; 1033 1034 if (m != minor) { 1035 idr_remove(&_minor_idr, m); 1036 r = -EBUSY; 1037 goto out; 1038 } 1039 1040 out: 1041 spin_unlock(&_minor_lock); 1042 return r; 1043 } 1044 1045 static int next_free_minor(int *minor) 1046 { 1047 int r, m; 1048 1049 r = idr_pre_get(&_minor_idr, GFP_KERNEL); 1050 if (!r) 1051 return -ENOMEM; 1052 1053 spin_lock(&_minor_lock); 1054 1055 r = idr_get_new(&_minor_idr, MINOR_ALLOCED, &m); 1056 if (r) 1057 goto out; 1058 1059 if (m >= (1 << MINORBITS)) { 1060 idr_remove(&_minor_idr, m); 1061 r = -ENOSPC; 1062 goto out; 1063 } 1064 1065 *minor = m; 1066 1067 out: 1068 spin_unlock(&_minor_lock); 1069 return r; 1070 } 1071 1072 static struct block_device_operations dm_blk_dops; 1073 1074 /* 1075 * Allocate and initialise a blank device with a given minor. 1076 */ 1077 static struct mapped_device *alloc_dev(int minor) 1078 { 1079 int r; 1080 struct mapped_device *md = kzalloc(sizeof(*md), GFP_KERNEL); 1081 void *old_md; 1082 1083 if (!md) { 1084 DMWARN("unable to allocate device, out of memory."); 1085 return NULL; 1086 } 1087 1088 if (!try_module_get(THIS_MODULE)) 1089 goto bad_module_get; 1090 1091 /* get a minor number for the dev */ 1092 if (minor == DM_ANY_MINOR) 1093 r = next_free_minor(&minor); 1094 else 1095 r = specific_minor(minor); 1096 if (r < 0) 1097 goto bad_minor; 1098 1099 init_rwsem(&md->io_lock); 1100 mutex_init(&md->suspend_lock); 1101 spin_lock_init(&md->pushback_lock); 1102 rwlock_init(&md->map_lock); 1103 atomic_set(&md->holders, 1); 1104 atomic_set(&md->open_count, 0); 1105 atomic_set(&md->event_nr, 0); 1106 atomic_set(&md->uevent_seq, 0); 1107 INIT_LIST_HEAD(&md->uevent_list); 1108 spin_lock_init(&md->uevent_lock); 1109 1110 md->queue = blk_alloc_queue(GFP_KERNEL); 1111 if (!md->queue) 1112 goto bad_queue; 1113 1114 md->queue->queuedata = md; 1115 md->queue->backing_dev_info.congested_fn = dm_any_congested; 1116 md->queue->backing_dev_info.congested_data = md; 1117 blk_queue_make_request(md->queue, dm_request); 1118 blk_queue_bounce_limit(md->queue, BLK_BOUNCE_ANY); 1119 md->queue->unplug_fn = dm_unplug_all; 1120 blk_queue_merge_bvec(md->queue, dm_merge_bvec); 1121 1122 md->io_pool = mempool_create_slab_pool(MIN_IOS, _io_cache); 1123 if (!md->io_pool) 1124 goto bad_io_pool; 1125 1126 md->tio_pool = mempool_create_slab_pool(MIN_IOS, _tio_cache); 1127 if (!md->tio_pool) 1128 goto bad_tio_pool; 1129 1130 md->bs = bioset_create(16, 0); 1131 if (!md->bs) 1132 goto bad_no_bioset; 1133 1134 md->disk = alloc_disk(1); 1135 if (!md->disk) 1136 goto bad_disk; 1137 1138 atomic_set(&md->pending, 0); 1139 init_waitqueue_head(&md->wait); 1140 init_waitqueue_head(&md->eventq); 1141 1142 md->disk->major = _major; 1143 md->disk->first_minor = minor; 1144 md->disk->fops = &dm_blk_dops; 1145 md->disk->queue = md->queue; 1146 md->disk->private_data = md; 1147 sprintf(md->disk->disk_name, "dm-%d", minor); 1148 add_disk(md->disk); 1149 format_dev_t(md->name, MKDEV(_major, minor)); 1150 1151 md->wq = create_singlethread_workqueue("kdmflush"); 1152 if (!md->wq) 1153 goto bad_thread; 1154 1155 /* Populate the mapping, nobody knows we exist yet */ 1156 spin_lock(&_minor_lock); 1157 old_md = idr_replace(&_minor_idr, md, minor); 1158 spin_unlock(&_minor_lock); 1159 1160 BUG_ON(old_md != MINOR_ALLOCED); 1161 1162 return md; 1163 1164 bad_thread: 1165 put_disk(md->disk); 1166 bad_disk: 1167 bioset_free(md->bs); 1168 bad_no_bioset: 1169 mempool_destroy(md->tio_pool); 1170 bad_tio_pool: 1171 mempool_destroy(md->io_pool); 1172 bad_io_pool: 1173 blk_cleanup_queue(md->queue); 1174 bad_queue: 1175 free_minor(minor); 1176 bad_minor: 1177 module_put(THIS_MODULE); 1178 bad_module_get: 1179 kfree(md); 1180 return NULL; 1181 } 1182 1183 static void unlock_fs(struct mapped_device *md); 1184 1185 static void free_dev(struct mapped_device *md) 1186 { 1187 int minor = MINOR(disk_devt(md->disk)); 1188 1189 if (md->suspended_bdev) { 1190 unlock_fs(md); 1191 bdput(md->suspended_bdev); 1192 } 1193 destroy_workqueue(md->wq); 1194 mempool_destroy(md->tio_pool); 1195 mempool_destroy(md->io_pool); 1196 bioset_free(md->bs); 1197 del_gendisk(md->disk); 1198 free_minor(minor); 1199 1200 spin_lock(&_minor_lock); 1201 md->disk->private_data = NULL; 1202 spin_unlock(&_minor_lock); 1203 1204 put_disk(md->disk); 1205 blk_cleanup_queue(md->queue); 1206 module_put(THIS_MODULE); 1207 kfree(md); 1208 } 1209 1210 /* 1211 * Bind a table to the device. 1212 */ 1213 static void event_callback(void *context) 1214 { 1215 unsigned long flags; 1216 LIST_HEAD(uevents); 1217 struct mapped_device *md = (struct mapped_device *) context; 1218 1219 spin_lock_irqsave(&md->uevent_lock, flags); 1220 list_splice_init(&md->uevent_list, &uevents); 1221 spin_unlock_irqrestore(&md->uevent_lock, flags); 1222 1223 dm_send_uevents(&uevents, &disk_to_dev(md->disk)->kobj); 1224 1225 atomic_inc(&md->event_nr); 1226 wake_up(&md->eventq); 1227 } 1228 1229 static void __set_size(struct mapped_device *md, sector_t size) 1230 { 1231 set_capacity(md->disk, size); 1232 1233 mutex_lock(&md->suspended_bdev->bd_inode->i_mutex); 1234 i_size_write(md->suspended_bdev->bd_inode, (loff_t)size << SECTOR_SHIFT); 1235 mutex_unlock(&md->suspended_bdev->bd_inode->i_mutex); 1236 } 1237 1238 static int __bind(struct mapped_device *md, struct dm_table *t) 1239 { 1240 struct request_queue *q = md->queue; 1241 sector_t size; 1242 1243 size = dm_table_get_size(t); 1244 1245 /* 1246 * Wipe any geometry if the size of the table changed. 1247 */ 1248 if (size != get_capacity(md->disk)) 1249 memset(&md->geometry, 0, sizeof(md->geometry)); 1250 1251 if (md->suspended_bdev) 1252 __set_size(md, size); 1253 if (size == 0) 1254 return 0; 1255 1256 dm_table_get(t); 1257 dm_table_event_callback(t, event_callback, md); 1258 1259 write_lock(&md->map_lock); 1260 md->map = t; 1261 dm_table_set_restrictions(t, q); 1262 write_unlock(&md->map_lock); 1263 1264 return 0; 1265 } 1266 1267 static void __unbind(struct mapped_device *md) 1268 { 1269 struct dm_table *map = md->map; 1270 1271 if (!map) 1272 return; 1273 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_put(map); 1279 } 1280 1281 /* 1282 * Constructor for a new device. 1283 */ 1284 int dm_create(int minor, struct mapped_device **result) 1285 { 1286 struct mapped_device *md; 1287 1288 md = alloc_dev(minor); 1289 if (!md) 1290 return -ENXIO; 1291 1292 *result = md; 1293 return 0; 1294 } 1295 1296 static struct mapped_device *dm_find_md(dev_t dev) 1297 { 1298 struct mapped_device *md; 1299 unsigned minor = MINOR(dev); 1300 1301 if (MAJOR(dev) != _major || minor >= (1 << MINORBITS)) 1302 return NULL; 1303 1304 spin_lock(&_minor_lock); 1305 1306 md = idr_find(&_minor_idr, minor); 1307 if (md && (md == MINOR_ALLOCED || 1308 (MINOR(disk_devt(dm_disk(md))) != minor) || 1309 test_bit(DMF_FREEING, &md->flags))) { 1310 md = NULL; 1311 goto out; 1312 } 1313 1314 out: 1315 spin_unlock(&_minor_lock); 1316 1317 return md; 1318 } 1319 1320 struct mapped_device *dm_get_md(dev_t dev) 1321 { 1322 struct mapped_device *md = dm_find_md(dev); 1323 1324 if (md) 1325 dm_get(md); 1326 1327 return md; 1328 } 1329 1330 void *dm_get_mdptr(struct mapped_device *md) 1331 { 1332 return md->interface_ptr; 1333 } 1334 1335 void dm_set_mdptr(struct mapped_device *md, void *ptr) 1336 { 1337 md->interface_ptr = ptr; 1338 } 1339 1340 void dm_get(struct mapped_device *md) 1341 { 1342 atomic_inc(&md->holders); 1343 } 1344 1345 const char *dm_device_name(struct mapped_device *md) 1346 { 1347 return md->name; 1348 } 1349 EXPORT_SYMBOL_GPL(dm_device_name); 1350 1351 void dm_put(struct mapped_device *md) 1352 { 1353 struct dm_table *map; 1354 1355 BUG_ON(test_bit(DMF_FREEING, &md->flags)); 1356 1357 if (atomic_dec_and_lock(&md->holders, &_minor_lock)) { 1358 map = dm_get_table(md); 1359 idr_replace(&_minor_idr, MINOR_ALLOCED, 1360 MINOR(disk_devt(dm_disk(md)))); 1361 set_bit(DMF_FREEING, &md->flags); 1362 spin_unlock(&_minor_lock); 1363 if (!dm_suspended(md)) { 1364 dm_table_presuspend_targets(map); 1365 dm_table_postsuspend_targets(map); 1366 } 1367 dm_table_put(map); 1368 __unbind(md); 1369 free_dev(md); 1370 } 1371 } 1372 EXPORT_SYMBOL_GPL(dm_put); 1373 1374 static int dm_wait_for_completion(struct mapped_device *md) 1375 { 1376 int r = 0; 1377 1378 while (1) { 1379 set_current_state(TASK_INTERRUPTIBLE); 1380 1381 smp_mb(); 1382 if (!atomic_read(&md->pending)) 1383 break; 1384 1385 if (signal_pending(current)) { 1386 r = -EINTR; 1387 break; 1388 } 1389 1390 io_schedule(); 1391 } 1392 set_current_state(TASK_RUNNING); 1393 1394 return r; 1395 } 1396 1397 /* 1398 * Process the deferred bios 1399 */ 1400 static void __flush_deferred_io(struct mapped_device *md) 1401 { 1402 struct bio *c; 1403 1404 while ((c = bio_list_pop(&md->deferred))) { 1405 if (__split_bio(md, c)) 1406 bio_io_error(c); 1407 } 1408 1409 clear_bit(DMF_BLOCK_IO, &md->flags); 1410 } 1411 1412 static void __merge_pushback_list(struct mapped_device *md) 1413 { 1414 unsigned long flags; 1415 1416 spin_lock_irqsave(&md->pushback_lock, flags); 1417 clear_bit(DMF_NOFLUSH_SUSPENDING, &md->flags); 1418 bio_list_merge_head(&md->deferred, &md->pushback); 1419 bio_list_init(&md->pushback); 1420 spin_unlock_irqrestore(&md->pushback_lock, flags); 1421 } 1422 1423 static void dm_wq_work(struct work_struct *work) 1424 { 1425 struct dm_wq_req *req = container_of(work, struct dm_wq_req, work); 1426 struct mapped_device *md = req->md; 1427 1428 down_write(&md->io_lock); 1429 switch (req->type) { 1430 case DM_WQ_FLUSH_DEFERRED: 1431 __flush_deferred_io(md); 1432 break; 1433 default: 1434 DMERR("dm_wq_work: unrecognised work type %d", req->type); 1435 BUG(); 1436 } 1437 up_write(&md->io_lock); 1438 } 1439 1440 static void dm_wq_queue(struct mapped_device *md, int type, void *context, 1441 struct dm_wq_req *req) 1442 { 1443 req->type = type; 1444 req->md = md; 1445 req->context = context; 1446 INIT_WORK(&req->work, dm_wq_work); 1447 queue_work(md->wq, &req->work); 1448 } 1449 1450 static void dm_queue_flush(struct mapped_device *md, int type, void *context) 1451 { 1452 struct dm_wq_req req; 1453 1454 dm_wq_queue(md, type, context, &req); 1455 flush_workqueue(md->wq); 1456 } 1457 1458 /* 1459 * Swap in a new table (destroying old one). 1460 */ 1461 int dm_swap_table(struct mapped_device *md, struct dm_table *table) 1462 { 1463 int r = -EINVAL; 1464 1465 mutex_lock(&md->suspend_lock); 1466 1467 /* device must be suspended */ 1468 if (!dm_suspended(md)) 1469 goto out; 1470 1471 /* without bdev, the device size cannot be changed */ 1472 if (!md->suspended_bdev) 1473 if (get_capacity(md->disk) != dm_table_get_size(table)) 1474 goto out; 1475 1476 __unbind(md); 1477 r = __bind(md, table); 1478 1479 out: 1480 mutex_unlock(&md->suspend_lock); 1481 return r; 1482 } 1483 1484 /* 1485 * Functions to lock and unlock any filesystem running on the 1486 * device. 1487 */ 1488 static int lock_fs(struct mapped_device *md) 1489 { 1490 int r; 1491 1492 WARN_ON(md->frozen_sb); 1493 1494 md->frozen_sb = freeze_bdev(md->suspended_bdev); 1495 if (IS_ERR(md->frozen_sb)) { 1496 r = PTR_ERR(md->frozen_sb); 1497 md->frozen_sb = NULL; 1498 return r; 1499 } 1500 1501 set_bit(DMF_FROZEN, &md->flags); 1502 1503 /* don't bdput right now, we don't want the bdev 1504 * to go away while it is locked. 1505 */ 1506 return 0; 1507 } 1508 1509 static void unlock_fs(struct mapped_device *md) 1510 { 1511 if (!test_bit(DMF_FROZEN, &md->flags)) 1512 return; 1513 1514 thaw_bdev(md->suspended_bdev, md->frozen_sb); 1515 md->frozen_sb = NULL; 1516 clear_bit(DMF_FROZEN, &md->flags); 1517 } 1518 1519 /* 1520 * We need to be able to change a mapping table under a mounted 1521 * filesystem. For example we might want to move some data in 1522 * the background. Before the table can be swapped with 1523 * dm_bind_table, dm_suspend must be called to flush any in 1524 * flight bios and ensure that any further io gets deferred. 1525 */ 1526 int dm_suspend(struct mapped_device *md, unsigned suspend_flags) 1527 { 1528 struct dm_table *map = NULL; 1529 DECLARE_WAITQUEUE(wait, current); 1530 int r = 0; 1531 int do_lockfs = suspend_flags & DM_SUSPEND_LOCKFS_FLAG ? 1 : 0; 1532 int noflush = suspend_flags & DM_SUSPEND_NOFLUSH_FLAG ? 1 : 0; 1533 1534 mutex_lock(&md->suspend_lock); 1535 1536 if (dm_suspended(md)) { 1537 r = -EINVAL; 1538 goto out_unlock; 1539 } 1540 1541 map = dm_get_table(md); 1542 1543 /* 1544 * DMF_NOFLUSH_SUSPENDING must be set before presuspend. 1545 * This flag is cleared before dm_suspend returns. 1546 */ 1547 if (noflush) 1548 set_bit(DMF_NOFLUSH_SUSPENDING, &md->flags); 1549 1550 /* This does not get reverted if there's an error later. */ 1551 dm_table_presuspend_targets(map); 1552 1553 /* bdget() can stall if the pending I/Os are not flushed */ 1554 if (!noflush) { 1555 md->suspended_bdev = bdget_disk(md->disk, 0); 1556 if (!md->suspended_bdev) { 1557 DMWARN("bdget failed in dm_suspend"); 1558 r = -ENOMEM; 1559 goto out; 1560 } 1561 1562 /* 1563 * Flush I/O to the device. noflush supersedes do_lockfs, 1564 * because lock_fs() needs to flush I/Os. 1565 */ 1566 if (do_lockfs) { 1567 r = lock_fs(md); 1568 if (r) 1569 goto out; 1570 } 1571 } 1572 1573 /* 1574 * First we set the BLOCK_IO flag so no more ios will be mapped. 1575 */ 1576 down_write(&md->io_lock); 1577 set_bit(DMF_BLOCK_IO, &md->flags); 1578 1579 add_wait_queue(&md->wait, &wait); 1580 up_write(&md->io_lock); 1581 1582 /* unplug */ 1583 if (map) 1584 dm_table_unplug_all(map); 1585 1586 /* 1587 * Wait for the already-mapped ios to complete. 1588 */ 1589 r = dm_wait_for_completion(md); 1590 1591 down_write(&md->io_lock); 1592 remove_wait_queue(&md->wait, &wait); 1593 1594 if (noflush) 1595 __merge_pushback_list(md); 1596 up_write(&md->io_lock); 1597 1598 /* were we interrupted ? */ 1599 if (r < 0) { 1600 dm_queue_flush(md, DM_WQ_FLUSH_DEFERRED, NULL); 1601 1602 unlock_fs(md); 1603 goto out; /* pushback list is already flushed, so skip flush */ 1604 } 1605 1606 dm_table_postsuspend_targets(map); 1607 1608 set_bit(DMF_SUSPENDED, &md->flags); 1609 1610 out: 1611 if (r && md->suspended_bdev) { 1612 bdput(md->suspended_bdev); 1613 md->suspended_bdev = NULL; 1614 } 1615 1616 dm_table_put(map); 1617 1618 out_unlock: 1619 mutex_unlock(&md->suspend_lock); 1620 return r; 1621 } 1622 1623 int dm_resume(struct mapped_device *md) 1624 { 1625 int r = -EINVAL; 1626 struct dm_table *map = NULL; 1627 1628 mutex_lock(&md->suspend_lock); 1629 if (!dm_suspended(md)) 1630 goto out; 1631 1632 map = dm_get_table(md); 1633 if (!map || !dm_table_get_size(map)) 1634 goto out; 1635 1636 r = dm_table_resume_targets(map); 1637 if (r) 1638 goto out; 1639 1640 dm_queue_flush(md, DM_WQ_FLUSH_DEFERRED, NULL); 1641 1642 unlock_fs(md); 1643 1644 if (md->suspended_bdev) { 1645 bdput(md->suspended_bdev); 1646 md->suspended_bdev = NULL; 1647 } 1648 1649 clear_bit(DMF_SUSPENDED, &md->flags); 1650 1651 dm_table_unplug_all(map); 1652 1653 dm_kobject_uevent(md); 1654 1655 r = 0; 1656 1657 out: 1658 dm_table_put(map); 1659 mutex_unlock(&md->suspend_lock); 1660 1661 return r; 1662 } 1663 1664 /*----------------------------------------------------------------- 1665 * Event notification. 1666 *---------------------------------------------------------------*/ 1667 void dm_kobject_uevent(struct mapped_device *md) 1668 { 1669 kobject_uevent(&disk_to_dev(md->disk)->kobj, KOBJ_CHANGE); 1670 } 1671 1672 uint32_t dm_next_uevent_seq(struct mapped_device *md) 1673 { 1674 return atomic_add_return(1, &md->uevent_seq); 1675 } 1676 1677 uint32_t dm_get_event_nr(struct mapped_device *md) 1678 { 1679 return atomic_read(&md->event_nr); 1680 } 1681 1682 int dm_wait_event(struct mapped_device *md, int event_nr) 1683 { 1684 return wait_event_interruptible(md->eventq, 1685 (event_nr != atomic_read(&md->event_nr))); 1686 } 1687 1688 void dm_uevent_add(struct mapped_device *md, struct list_head *elist) 1689 { 1690 unsigned long flags; 1691 1692 spin_lock_irqsave(&md->uevent_lock, flags); 1693 list_add(elist, &md->uevent_list); 1694 spin_unlock_irqrestore(&md->uevent_lock, flags); 1695 } 1696 1697 /* 1698 * The gendisk is only valid as long as you have a reference 1699 * count on 'md'. 1700 */ 1701 struct gendisk *dm_disk(struct mapped_device *md) 1702 { 1703 return md->disk; 1704 } 1705 1706 int dm_suspended(struct mapped_device *md) 1707 { 1708 return test_bit(DMF_SUSPENDED, &md->flags); 1709 } 1710 1711 int dm_noflush_suspending(struct dm_target *ti) 1712 { 1713 struct mapped_device *md = dm_table_get_md(ti->table); 1714 int r = __noflush_suspending(md); 1715 1716 dm_put(md); 1717 1718 return r; 1719 } 1720 EXPORT_SYMBOL_GPL(dm_noflush_suspending); 1721 1722 static struct block_device_operations dm_blk_dops = { 1723 .open = dm_blk_open, 1724 .release = dm_blk_close, 1725 .ioctl = dm_blk_ioctl, 1726 .getgeo = dm_blk_getgeo, 1727 .owner = THIS_MODULE 1728 }; 1729 1730 EXPORT_SYMBOL(dm_get_mapinfo); 1731 1732 /* 1733 * module hooks 1734 */ 1735 module_init(dm_init); 1736 module_exit(dm_exit); 1737 1738 module_param(major, uint, 0); 1739 MODULE_PARM_DESC(major, "The major number of the device mapper"); 1740 MODULE_DESCRIPTION(DM_NAME " driver"); 1741 MODULE_AUTHOR("Joe Thornber <dm-devel@redhat.com>"); 1742 MODULE_LICENSE("GPL"); 1743