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