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