1 /* 2 * Copyright (C) 2001 Sistina Software (UK) Limited. 3 * Copyright (C) 2004 Red Hat, Inc. All rights reserved. 4 * 5 * This file is released under the GPL. 6 */ 7 8 #include "dm.h" 9 10 #include <linux/module.h> 11 #include <linux/vmalloc.h> 12 #include <linux/blkdev.h> 13 #include <linux/namei.h> 14 #include <linux/ctype.h> 15 #include <linux/slab.h> 16 #include <linux/interrupt.h> 17 #include <linux/mutex.h> 18 #include <asm/atomic.h> 19 20 #define DM_MSG_PREFIX "table" 21 22 #define MAX_DEPTH 16 23 #define NODE_SIZE L1_CACHE_BYTES 24 #define KEYS_PER_NODE (NODE_SIZE / sizeof(sector_t)) 25 #define CHILDREN_PER_NODE (KEYS_PER_NODE + 1) 26 27 struct dm_table { 28 struct mapped_device *md; 29 atomic_t holders; 30 31 /* btree table */ 32 unsigned int depth; 33 unsigned int counts[MAX_DEPTH]; /* in nodes */ 34 sector_t *index[MAX_DEPTH]; 35 36 unsigned int num_targets; 37 unsigned int num_allocated; 38 sector_t *highs; 39 struct dm_target *targets; 40 41 /* 42 * Indicates the rw permissions for the new logical 43 * device. This should be a combination of FMODE_READ 44 * and FMODE_WRITE. 45 */ 46 int mode; 47 48 /* a list of devices used by this table */ 49 struct list_head devices; 50 51 /* 52 * These are optimistic limits taken from all the 53 * targets, some targets will need smaller limits. 54 */ 55 struct io_restrictions limits; 56 57 /* events get handed up using this callback */ 58 void (*event_fn)(void *); 59 void *event_context; 60 }; 61 62 /* 63 * Similar to ceiling(log_size(n)) 64 */ 65 static unsigned int int_log(unsigned int n, unsigned int base) 66 { 67 int result = 0; 68 69 while (n > 1) { 70 n = dm_div_up(n, base); 71 result++; 72 } 73 74 return result; 75 } 76 77 /* 78 * Returns the minimum that is _not_ zero, unless both are zero. 79 */ 80 #define min_not_zero(l, r) (l == 0) ? r : ((r == 0) ? l : min(l, r)) 81 82 /* 83 * Combine two io_restrictions, always taking the lower value. 84 */ 85 static void combine_restrictions_low(struct io_restrictions *lhs, 86 struct io_restrictions *rhs) 87 { 88 lhs->max_sectors = 89 min_not_zero(lhs->max_sectors, rhs->max_sectors); 90 91 lhs->max_phys_segments = 92 min_not_zero(lhs->max_phys_segments, rhs->max_phys_segments); 93 94 lhs->max_hw_segments = 95 min_not_zero(lhs->max_hw_segments, rhs->max_hw_segments); 96 97 lhs->hardsect_size = max(lhs->hardsect_size, rhs->hardsect_size); 98 99 lhs->max_segment_size = 100 min_not_zero(lhs->max_segment_size, rhs->max_segment_size); 101 102 lhs->seg_boundary_mask = 103 min_not_zero(lhs->seg_boundary_mask, rhs->seg_boundary_mask); 104 105 lhs->no_cluster |= rhs->no_cluster; 106 } 107 108 /* 109 * Calculate the index of the child node of the n'th node k'th key. 110 */ 111 static inline unsigned int get_child(unsigned int n, unsigned int k) 112 { 113 return (n * CHILDREN_PER_NODE) + k; 114 } 115 116 /* 117 * Return the n'th node of level l from table t. 118 */ 119 static inline sector_t *get_node(struct dm_table *t, 120 unsigned int l, unsigned int n) 121 { 122 return t->index[l] + (n * KEYS_PER_NODE); 123 } 124 125 /* 126 * Return the highest key that you could lookup from the n'th 127 * node on level l of the btree. 128 */ 129 static sector_t high(struct dm_table *t, unsigned int l, unsigned int n) 130 { 131 for (; l < t->depth - 1; l++) 132 n = get_child(n, CHILDREN_PER_NODE - 1); 133 134 if (n >= t->counts[l]) 135 return (sector_t) - 1; 136 137 return get_node(t, l, n)[KEYS_PER_NODE - 1]; 138 } 139 140 /* 141 * Fills in a level of the btree based on the highs of the level 142 * below it. 143 */ 144 static int setup_btree_index(unsigned int l, struct dm_table *t) 145 { 146 unsigned int n, k; 147 sector_t *node; 148 149 for (n = 0U; n < t->counts[l]; n++) { 150 node = get_node(t, l, n); 151 152 for (k = 0U; k < KEYS_PER_NODE; k++) 153 node[k] = high(t, l + 1, get_child(n, k)); 154 } 155 156 return 0; 157 } 158 159 void *dm_vcalloc(unsigned long nmemb, unsigned long elem_size) 160 { 161 unsigned long size; 162 void *addr; 163 164 /* 165 * Check that we're not going to overflow. 166 */ 167 if (nmemb > (ULONG_MAX / elem_size)) 168 return NULL; 169 170 size = nmemb * elem_size; 171 addr = vmalloc(size); 172 if (addr) 173 memset(addr, 0, size); 174 175 return addr; 176 } 177 178 /* 179 * highs, and targets are managed as dynamic arrays during a 180 * table load. 181 */ 182 static int alloc_targets(struct dm_table *t, unsigned int num) 183 { 184 sector_t *n_highs; 185 struct dm_target *n_targets; 186 int n = t->num_targets; 187 188 /* 189 * Allocate both the target array and offset array at once. 190 */ 191 n_highs = (sector_t *) dm_vcalloc(num, sizeof(struct dm_target) + 192 sizeof(sector_t)); 193 if (!n_highs) 194 return -ENOMEM; 195 196 n_targets = (struct dm_target *) (n_highs + num); 197 198 if (n) { 199 memcpy(n_highs, t->highs, sizeof(*n_highs) * n); 200 memcpy(n_targets, t->targets, sizeof(*n_targets) * n); 201 } 202 203 memset(n_highs + n, -1, sizeof(*n_highs) * (num - n)); 204 vfree(t->highs); 205 206 t->num_allocated = num; 207 t->highs = n_highs; 208 t->targets = n_targets; 209 210 return 0; 211 } 212 213 int dm_table_create(struct dm_table **result, int mode, 214 unsigned num_targets, struct mapped_device *md) 215 { 216 struct dm_table *t = kmalloc(sizeof(*t), GFP_KERNEL); 217 218 if (!t) 219 return -ENOMEM; 220 221 memset(t, 0, sizeof(*t)); 222 INIT_LIST_HEAD(&t->devices); 223 atomic_set(&t->holders, 1); 224 225 if (!num_targets) 226 num_targets = KEYS_PER_NODE; 227 228 num_targets = dm_round_up(num_targets, KEYS_PER_NODE); 229 230 if (alloc_targets(t, num_targets)) { 231 kfree(t); 232 t = NULL; 233 return -ENOMEM; 234 } 235 236 t->mode = mode; 237 t->md = md; 238 *result = t; 239 return 0; 240 } 241 242 int dm_create_error_table(struct dm_table **result, struct mapped_device *md) 243 { 244 struct dm_table *t; 245 sector_t dev_size = 1; 246 int r; 247 248 /* 249 * Find current size of device. 250 * Default to 1 sector if inactive. 251 */ 252 t = dm_get_table(md); 253 if (t) { 254 dev_size = dm_table_get_size(t); 255 dm_table_put(t); 256 } 257 258 r = dm_table_create(&t, FMODE_READ, 1, md); 259 if (r) 260 return r; 261 262 r = dm_table_add_target(t, "error", 0, dev_size, NULL); 263 if (r) 264 goto out; 265 266 r = dm_table_complete(t); 267 if (r) 268 goto out; 269 270 *result = t; 271 272 out: 273 if (r) 274 dm_table_put(t); 275 276 return r; 277 } 278 EXPORT_SYMBOL_GPL(dm_create_error_table); 279 280 static void free_devices(struct list_head *devices) 281 { 282 struct list_head *tmp, *next; 283 284 for (tmp = devices->next; tmp != devices; tmp = next) { 285 struct dm_dev *dd = list_entry(tmp, struct dm_dev, list); 286 next = tmp->next; 287 kfree(dd); 288 } 289 } 290 291 static void table_destroy(struct dm_table *t) 292 { 293 unsigned int i; 294 295 /* free the indexes (see dm_table_complete) */ 296 if (t->depth >= 2) 297 vfree(t->index[t->depth - 2]); 298 299 /* free the targets */ 300 for (i = 0; i < t->num_targets; i++) { 301 struct dm_target *tgt = t->targets + i; 302 303 if (tgt->type->dtr) 304 tgt->type->dtr(tgt); 305 306 dm_put_target_type(tgt->type); 307 } 308 309 vfree(t->highs); 310 311 /* free the device list */ 312 if (t->devices.next != &t->devices) { 313 DMWARN("devices still present during destroy: " 314 "dm_table_remove_device calls missing"); 315 316 free_devices(&t->devices); 317 } 318 319 kfree(t); 320 } 321 322 void dm_table_get(struct dm_table *t) 323 { 324 atomic_inc(&t->holders); 325 } 326 327 void dm_table_put(struct dm_table *t) 328 { 329 if (!t) 330 return; 331 332 if (atomic_dec_and_test(&t->holders)) 333 table_destroy(t); 334 } 335 336 /* 337 * Checks to see if we need to extend highs or targets. 338 */ 339 static inline int check_space(struct dm_table *t) 340 { 341 if (t->num_targets >= t->num_allocated) 342 return alloc_targets(t, t->num_allocated * 2); 343 344 return 0; 345 } 346 347 /* 348 * Convert a device path to a dev_t. 349 */ 350 static int lookup_device(const char *path, dev_t *dev) 351 { 352 int r; 353 struct nameidata nd; 354 struct inode *inode; 355 356 if ((r = path_lookup(path, LOOKUP_FOLLOW, &nd))) 357 return r; 358 359 inode = nd.dentry->d_inode; 360 if (!inode) { 361 r = -ENOENT; 362 goto out; 363 } 364 365 if (!S_ISBLK(inode->i_mode)) { 366 r = -ENOTBLK; 367 goto out; 368 } 369 370 *dev = inode->i_rdev; 371 372 out: 373 path_release(&nd); 374 return r; 375 } 376 377 /* 378 * See if we've already got a device in the list. 379 */ 380 static struct dm_dev *find_device(struct list_head *l, dev_t dev) 381 { 382 struct dm_dev *dd; 383 384 list_for_each_entry (dd, l, list) 385 if (dd->bdev->bd_dev == dev) 386 return dd; 387 388 return NULL; 389 } 390 391 /* 392 * Open a device so we can use it as a map destination. 393 */ 394 static int open_dev(struct dm_dev *d, dev_t dev, struct mapped_device *md) 395 { 396 static char *_claim_ptr = "I belong to device-mapper"; 397 struct block_device *bdev; 398 399 int r; 400 401 BUG_ON(d->bdev); 402 403 bdev = open_by_devnum(dev, d->mode); 404 if (IS_ERR(bdev)) 405 return PTR_ERR(bdev); 406 r = bd_claim_by_disk(bdev, _claim_ptr, dm_disk(md)); 407 if (r) 408 blkdev_put(bdev); 409 else 410 d->bdev = bdev; 411 return r; 412 } 413 414 /* 415 * Close a device that we've been using. 416 */ 417 static void close_dev(struct dm_dev *d, struct mapped_device *md) 418 { 419 if (!d->bdev) 420 return; 421 422 bd_release_from_disk(d->bdev, dm_disk(md)); 423 blkdev_put(d->bdev); 424 d->bdev = NULL; 425 } 426 427 /* 428 * If possible (ie. blk_size[major] is set), this checks an area 429 * of a destination device is valid. 430 */ 431 static int check_device_area(struct dm_dev *dd, sector_t start, sector_t len) 432 { 433 sector_t dev_size; 434 dev_size = dd->bdev->bd_inode->i_size >> SECTOR_SHIFT; 435 return ((start < dev_size) && (len <= (dev_size - start))); 436 } 437 438 /* 439 * This upgrades the mode on an already open dm_dev. Being 440 * careful to leave things as they were if we fail to reopen the 441 * device. 442 */ 443 static int upgrade_mode(struct dm_dev *dd, int new_mode, struct mapped_device *md) 444 { 445 int r; 446 struct dm_dev dd_copy; 447 dev_t dev = dd->bdev->bd_dev; 448 449 dd_copy = *dd; 450 451 dd->mode |= new_mode; 452 dd->bdev = NULL; 453 r = open_dev(dd, dev, md); 454 if (!r) 455 close_dev(&dd_copy, md); 456 else 457 *dd = dd_copy; 458 459 return r; 460 } 461 462 /* 463 * Add a device to the list, or just increment the usage count if 464 * it's already present. 465 */ 466 static int __table_get_device(struct dm_table *t, struct dm_target *ti, 467 const char *path, sector_t start, sector_t len, 468 int mode, struct dm_dev **result) 469 { 470 int r; 471 dev_t dev; 472 struct dm_dev *dd; 473 unsigned int major, minor; 474 475 BUG_ON(!t); 476 477 if (sscanf(path, "%u:%u", &major, &minor) == 2) { 478 /* Extract the major/minor numbers */ 479 dev = MKDEV(major, minor); 480 if (MAJOR(dev) != major || MINOR(dev) != minor) 481 return -EOVERFLOW; 482 } else { 483 /* convert the path to a device */ 484 if ((r = lookup_device(path, &dev))) 485 return r; 486 } 487 488 dd = find_device(&t->devices, dev); 489 if (!dd) { 490 dd = kmalloc(sizeof(*dd), GFP_KERNEL); 491 if (!dd) 492 return -ENOMEM; 493 494 dd->mode = mode; 495 dd->bdev = NULL; 496 497 if ((r = open_dev(dd, dev, t->md))) { 498 kfree(dd); 499 return r; 500 } 501 502 format_dev_t(dd->name, dev); 503 504 atomic_set(&dd->count, 0); 505 list_add(&dd->list, &t->devices); 506 507 } else if (dd->mode != (mode | dd->mode)) { 508 r = upgrade_mode(dd, mode, t->md); 509 if (r) 510 return r; 511 } 512 atomic_inc(&dd->count); 513 514 if (!check_device_area(dd, start, len)) { 515 DMWARN("device %s too small for target", path); 516 dm_put_device(ti, dd); 517 return -EINVAL; 518 } 519 520 *result = dd; 521 522 return 0; 523 } 524 525 void dm_set_device_limits(struct dm_target *ti, struct block_device *bdev) 526 { 527 request_queue_t *q = bdev_get_queue(bdev); 528 struct io_restrictions *rs = &ti->limits; 529 530 /* 531 * Combine the device limits low. 532 * 533 * FIXME: if we move an io_restriction struct 534 * into q this would just be a call to 535 * combine_restrictions_low() 536 */ 537 rs->max_sectors = 538 min_not_zero(rs->max_sectors, q->max_sectors); 539 540 /* FIXME: Device-Mapper on top of RAID-0 breaks because DM 541 * currently doesn't honor MD's merge_bvec_fn routine. 542 * In this case, we'll force DM to use PAGE_SIZE or 543 * smaller I/O, just to be safe. A better fix is in the 544 * works, but add this for the time being so it will at 545 * least operate correctly. 546 */ 547 if (q->merge_bvec_fn) 548 rs->max_sectors = 549 min_not_zero(rs->max_sectors, 550 (unsigned int) (PAGE_SIZE >> 9)); 551 552 rs->max_phys_segments = 553 min_not_zero(rs->max_phys_segments, 554 q->max_phys_segments); 555 556 rs->max_hw_segments = 557 min_not_zero(rs->max_hw_segments, q->max_hw_segments); 558 559 rs->hardsect_size = max(rs->hardsect_size, q->hardsect_size); 560 561 rs->max_segment_size = 562 min_not_zero(rs->max_segment_size, q->max_segment_size); 563 564 rs->seg_boundary_mask = 565 min_not_zero(rs->seg_boundary_mask, 566 q->seg_boundary_mask); 567 568 rs->no_cluster |= !test_bit(QUEUE_FLAG_CLUSTER, &q->queue_flags); 569 } 570 EXPORT_SYMBOL_GPL(dm_set_device_limits); 571 572 int dm_get_device(struct dm_target *ti, const char *path, sector_t start, 573 sector_t len, int mode, struct dm_dev **result) 574 { 575 int r = __table_get_device(ti->table, ti, path, 576 start, len, mode, result); 577 578 if (!r) 579 dm_set_device_limits(ti, (*result)->bdev); 580 581 return r; 582 } 583 584 /* 585 * Decrement a devices use count and remove it if necessary. 586 */ 587 void dm_put_device(struct dm_target *ti, struct dm_dev *dd) 588 { 589 if (atomic_dec_and_test(&dd->count)) { 590 close_dev(dd, ti->table->md); 591 list_del(&dd->list); 592 kfree(dd); 593 } 594 } 595 596 /* 597 * Checks to see if the target joins onto the end of the table. 598 */ 599 static int adjoin(struct dm_table *table, struct dm_target *ti) 600 { 601 struct dm_target *prev; 602 603 if (!table->num_targets) 604 return !ti->begin; 605 606 prev = &table->targets[table->num_targets - 1]; 607 return (ti->begin == (prev->begin + prev->len)); 608 } 609 610 /* 611 * Used to dynamically allocate the arg array. 612 */ 613 static char **realloc_argv(unsigned *array_size, char **old_argv) 614 { 615 char **argv; 616 unsigned new_size; 617 618 new_size = *array_size ? *array_size * 2 : 64; 619 argv = kmalloc(new_size * sizeof(*argv), GFP_KERNEL); 620 if (argv) { 621 memcpy(argv, old_argv, *array_size * sizeof(*argv)); 622 *array_size = new_size; 623 } 624 625 kfree(old_argv); 626 return argv; 627 } 628 629 /* 630 * Destructively splits up the argument list to pass to ctr. 631 */ 632 int dm_split_args(int *argc, char ***argvp, char *input) 633 { 634 char *start, *end = input, *out, **argv = NULL; 635 unsigned array_size = 0; 636 637 *argc = 0; 638 639 if (!input) { 640 *argvp = NULL; 641 return 0; 642 } 643 644 argv = realloc_argv(&array_size, argv); 645 if (!argv) 646 return -ENOMEM; 647 648 while (1) { 649 start = end; 650 651 /* Skip whitespace */ 652 while (*start && isspace(*start)) 653 start++; 654 655 if (!*start) 656 break; /* success, we hit the end */ 657 658 /* 'out' is used to remove any back-quotes */ 659 end = out = start; 660 while (*end) { 661 /* Everything apart from '\0' can be quoted */ 662 if (*end == '\\' && *(end + 1)) { 663 *out++ = *(end + 1); 664 end += 2; 665 continue; 666 } 667 668 if (isspace(*end)) 669 break; /* end of token */ 670 671 *out++ = *end++; 672 } 673 674 /* have we already filled the array ? */ 675 if ((*argc + 1) > array_size) { 676 argv = realloc_argv(&array_size, argv); 677 if (!argv) 678 return -ENOMEM; 679 } 680 681 /* we know this is whitespace */ 682 if (*end) 683 end++; 684 685 /* terminate the string and put it in the array */ 686 *out = '\0'; 687 argv[*argc] = start; 688 (*argc)++; 689 } 690 691 *argvp = argv; 692 return 0; 693 } 694 695 static void check_for_valid_limits(struct io_restrictions *rs) 696 { 697 if (!rs->max_sectors) 698 rs->max_sectors = SAFE_MAX_SECTORS; 699 if (!rs->max_phys_segments) 700 rs->max_phys_segments = MAX_PHYS_SEGMENTS; 701 if (!rs->max_hw_segments) 702 rs->max_hw_segments = MAX_HW_SEGMENTS; 703 if (!rs->hardsect_size) 704 rs->hardsect_size = 1 << SECTOR_SHIFT; 705 if (!rs->max_segment_size) 706 rs->max_segment_size = MAX_SEGMENT_SIZE; 707 if (!rs->seg_boundary_mask) 708 rs->seg_boundary_mask = -1; 709 } 710 711 int dm_table_add_target(struct dm_table *t, const char *type, 712 sector_t start, sector_t len, char *params) 713 { 714 int r = -EINVAL, argc; 715 char **argv; 716 struct dm_target *tgt; 717 718 if ((r = check_space(t))) 719 return r; 720 721 tgt = t->targets + t->num_targets; 722 memset(tgt, 0, sizeof(*tgt)); 723 724 if (!len) { 725 DMERR("%s: zero-length target", dm_device_name(t->md)); 726 return -EINVAL; 727 } 728 729 tgt->type = dm_get_target_type(type); 730 if (!tgt->type) { 731 DMERR("%s: %s: unknown target type", dm_device_name(t->md), 732 type); 733 return -EINVAL; 734 } 735 736 tgt->table = t; 737 tgt->begin = start; 738 tgt->len = len; 739 tgt->error = "Unknown error"; 740 741 /* 742 * Does this target adjoin the previous one ? 743 */ 744 if (!adjoin(t, tgt)) { 745 tgt->error = "Gap in table"; 746 r = -EINVAL; 747 goto bad; 748 } 749 750 r = dm_split_args(&argc, &argv, params); 751 if (r) { 752 tgt->error = "couldn't split parameters (insufficient memory)"; 753 goto bad; 754 } 755 756 r = tgt->type->ctr(tgt, argc, argv); 757 kfree(argv); 758 if (r) 759 goto bad; 760 761 t->highs[t->num_targets++] = tgt->begin + tgt->len - 1; 762 763 /* FIXME: the plan is to combine high here and then have 764 * the merge fn apply the target level restrictions. */ 765 combine_restrictions_low(&t->limits, &tgt->limits); 766 return 0; 767 768 bad: 769 DMERR("%s: %s: %s", dm_device_name(t->md), type, tgt->error); 770 dm_put_target_type(tgt->type); 771 return r; 772 } 773 774 static int setup_indexes(struct dm_table *t) 775 { 776 int i; 777 unsigned int total = 0; 778 sector_t *indexes; 779 780 /* allocate the space for *all* the indexes */ 781 for (i = t->depth - 2; i >= 0; i--) { 782 t->counts[i] = dm_div_up(t->counts[i + 1], CHILDREN_PER_NODE); 783 total += t->counts[i]; 784 } 785 786 indexes = (sector_t *) dm_vcalloc(total, (unsigned long) NODE_SIZE); 787 if (!indexes) 788 return -ENOMEM; 789 790 /* set up internal nodes, bottom-up */ 791 for (i = t->depth - 2, total = 0; i >= 0; i--) { 792 t->index[i] = indexes; 793 indexes += (KEYS_PER_NODE * t->counts[i]); 794 setup_btree_index(i, t); 795 } 796 797 return 0; 798 } 799 800 /* 801 * Builds the btree to index the map. 802 */ 803 int dm_table_complete(struct dm_table *t) 804 { 805 int r = 0; 806 unsigned int leaf_nodes; 807 808 check_for_valid_limits(&t->limits); 809 810 /* how many indexes will the btree have ? */ 811 leaf_nodes = dm_div_up(t->num_targets, KEYS_PER_NODE); 812 t->depth = 1 + int_log(leaf_nodes, CHILDREN_PER_NODE); 813 814 /* leaf layer has already been set up */ 815 t->counts[t->depth - 1] = leaf_nodes; 816 t->index[t->depth - 1] = t->highs; 817 818 if (t->depth >= 2) 819 r = setup_indexes(t); 820 821 return r; 822 } 823 824 static DEFINE_MUTEX(_event_lock); 825 void dm_table_event_callback(struct dm_table *t, 826 void (*fn)(void *), void *context) 827 { 828 mutex_lock(&_event_lock); 829 t->event_fn = fn; 830 t->event_context = context; 831 mutex_unlock(&_event_lock); 832 } 833 834 void dm_table_event(struct dm_table *t) 835 { 836 /* 837 * You can no longer call dm_table_event() from interrupt 838 * context, use a bottom half instead. 839 */ 840 BUG_ON(in_interrupt()); 841 842 mutex_lock(&_event_lock); 843 if (t->event_fn) 844 t->event_fn(t->event_context); 845 mutex_unlock(&_event_lock); 846 } 847 848 sector_t dm_table_get_size(struct dm_table *t) 849 { 850 return t->num_targets ? (t->highs[t->num_targets - 1] + 1) : 0; 851 } 852 853 struct dm_target *dm_table_get_target(struct dm_table *t, unsigned int index) 854 { 855 if (index >= t->num_targets) 856 return NULL; 857 858 return t->targets + index; 859 } 860 861 /* 862 * Search the btree for the correct target. 863 */ 864 struct dm_target *dm_table_find_target(struct dm_table *t, sector_t sector) 865 { 866 unsigned int l, n = 0, k = 0; 867 sector_t *node; 868 869 for (l = 0; l < t->depth; l++) { 870 n = get_child(n, k); 871 node = get_node(t, l, n); 872 873 for (k = 0; k < KEYS_PER_NODE; k++) 874 if (node[k] >= sector) 875 break; 876 } 877 878 return &t->targets[(KEYS_PER_NODE * n) + k]; 879 } 880 881 void dm_table_set_restrictions(struct dm_table *t, struct request_queue *q) 882 { 883 /* 884 * Make sure we obey the optimistic sub devices 885 * restrictions. 886 */ 887 blk_queue_max_sectors(q, t->limits.max_sectors); 888 q->max_phys_segments = t->limits.max_phys_segments; 889 q->max_hw_segments = t->limits.max_hw_segments; 890 q->hardsect_size = t->limits.hardsect_size; 891 q->max_segment_size = t->limits.max_segment_size; 892 q->seg_boundary_mask = t->limits.seg_boundary_mask; 893 if (t->limits.no_cluster) 894 q->queue_flags &= ~(1 << QUEUE_FLAG_CLUSTER); 895 else 896 q->queue_flags |= (1 << QUEUE_FLAG_CLUSTER); 897 898 } 899 900 unsigned int dm_table_get_num_targets(struct dm_table *t) 901 { 902 return t->num_targets; 903 } 904 905 struct list_head *dm_table_get_devices(struct dm_table *t) 906 { 907 return &t->devices; 908 } 909 910 int dm_table_get_mode(struct dm_table *t) 911 { 912 return t->mode; 913 } 914 915 static void suspend_targets(struct dm_table *t, unsigned postsuspend) 916 { 917 int i = t->num_targets; 918 struct dm_target *ti = t->targets; 919 920 while (i--) { 921 if (postsuspend) { 922 if (ti->type->postsuspend) 923 ti->type->postsuspend(ti); 924 } else if (ti->type->presuspend) 925 ti->type->presuspend(ti); 926 927 ti++; 928 } 929 } 930 931 void dm_table_presuspend_targets(struct dm_table *t) 932 { 933 if (!t) 934 return; 935 936 return suspend_targets(t, 0); 937 } 938 939 void dm_table_postsuspend_targets(struct dm_table *t) 940 { 941 if (!t) 942 return; 943 944 return suspend_targets(t, 1); 945 } 946 947 int dm_table_resume_targets(struct dm_table *t) 948 { 949 int i, r = 0; 950 951 for (i = 0; i < t->num_targets; i++) { 952 struct dm_target *ti = t->targets + i; 953 954 if (!ti->type->preresume) 955 continue; 956 957 r = ti->type->preresume(ti); 958 if (r) 959 return r; 960 } 961 962 for (i = 0; i < t->num_targets; i++) { 963 struct dm_target *ti = t->targets + i; 964 965 if (ti->type->resume) 966 ti->type->resume(ti); 967 } 968 969 return 0; 970 } 971 972 int dm_table_any_congested(struct dm_table *t, int bdi_bits) 973 { 974 struct list_head *d, *devices; 975 int r = 0; 976 977 devices = dm_table_get_devices(t); 978 for (d = devices->next; d != devices; d = d->next) { 979 struct dm_dev *dd = list_entry(d, struct dm_dev, list); 980 request_queue_t *q = bdev_get_queue(dd->bdev); 981 r |= bdi_congested(&q->backing_dev_info, bdi_bits); 982 } 983 984 return r; 985 } 986 987 void dm_table_unplug_all(struct dm_table *t) 988 { 989 struct list_head *d, *devices = dm_table_get_devices(t); 990 991 for (d = devices->next; d != devices; d = d->next) { 992 struct dm_dev *dd = list_entry(d, struct dm_dev, list); 993 request_queue_t *q = bdev_get_queue(dd->bdev); 994 995 if (q->unplug_fn) 996 q->unplug_fn(q); 997 } 998 } 999 1000 int dm_table_flush_all(struct dm_table *t) 1001 { 1002 struct list_head *d, *devices = dm_table_get_devices(t); 1003 int ret = 0; 1004 unsigned i; 1005 1006 for (i = 0; i < t->num_targets; i++) 1007 if (t->targets[i].type->flush) 1008 t->targets[i].type->flush(&t->targets[i]); 1009 1010 for (d = devices->next; d != devices; d = d->next) { 1011 struct dm_dev *dd = list_entry(d, struct dm_dev, list); 1012 request_queue_t *q = bdev_get_queue(dd->bdev); 1013 int err; 1014 1015 if (!q->issue_flush_fn) 1016 err = -EOPNOTSUPP; 1017 else 1018 err = q->issue_flush_fn(q, dd->bdev->bd_disk, NULL); 1019 1020 if (!ret) 1021 ret = err; 1022 } 1023 1024 return ret; 1025 } 1026 1027 struct mapped_device *dm_table_get_md(struct dm_table *t) 1028 { 1029 dm_get(t->md); 1030 1031 return t->md; 1032 } 1033 1034 EXPORT_SYMBOL(dm_vcalloc); 1035 EXPORT_SYMBOL(dm_get_device); 1036 EXPORT_SYMBOL(dm_put_device); 1037 EXPORT_SYMBOL(dm_table_event); 1038 EXPORT_SYMBOL(dm_table_get_size); 1039 EXPORT_SYMBOL(dm_table_get_mode); 1040 EXPORT_SYMBOL(dm_table_get_md); 1041 EXPORT_SYMBOL(dm_table_put); 1042 EXPORT_SYMBOL(dm_table_get); 1043 EXPORT_SYMBOL(dm_table_unplug_all); 1044 EXPORT_SYMBOL(dm_table_flush_all); 1045