#include <linux/ctype.h>
#include <linux/slab.h>
#include <linux/interrupt.h>
-#include <linux/mutex.h>
#include <asm/atomic.h>
#define MAX_DEPTH 16
#define CHILDREN_PER_NODE (KEYS_PER_NODE + 1)
struct dm_table {
- struct mapped_device *md;
atomic_t holders;
/* btree table */
lhs->seg_boundary_mask =
min_not_zero(lhs->seg_boundary_mask, rhs->seg_boundary_mask);
-
- lhs->no_cluster |= rhs->no_cluster;
}
/*
return 0;
}
-int dm_table_create(struct dm_table **result, int mode,
- unsigned num_targets, struct mapped_device *md)
+int dm_table_create(struct dm_table **result, int mode, unsigned num_targets)
{
struct dm_table *t = kmalloc(sizeof(*t), GFP_KERNEL);
}
t->mode = mode;
- t->md = md;
*result = t;
return 0;
}
/*
* Open a device so we can use it as a map destination.
*/
-static int open_dev(struct dm_dev *d, dev_t dev, struct mapped_device *md)
+static int open_dev(struct dm_dev *d, dev_t dev)
{
static char *_claim_ptr = "I belong to device-mapper";
struct block_device *bdev;
int r;
- BUG_ON(d->bdev);
+ if (d->bdev)
+ BUG();
bdev = open_by_devnum(dev, d->mode);
if (IS_ERR(bdev))
return PTR_ERR(bdev);
- r = bd_claim_by_disk(bdev, _claim_ptr, dm_disk(md));
+ r = bd_claim(bdev, _claim_ptr);
if (r)
blkdev_put(bdev);
else
/*
* Close a device that we've been using.
*/
-static void close_dev(struct dm_dev *d, struct mapped_device *md)
+static void close_dev(struct dm_dev *d)
{
if (!d->bdev)
return;
- bd_release_from_disk(d->bdev, dm_disk(md));
+ bd_release(d->bdev);
blkdev_put(d->bdev);
d->bdev = NULL;
}
* careful to leave things as they were if we fail to reopen the
* device.
*/
-static int upgrade_mode(struct dm_dev *dd, int new_mode, struct mapped_device *md)
+static int upgrade_mode(struct dm_dev *dd, int new_mode)
{
int r;
struct dm_dev dd_copy;
dd->mode |= new_mode;
dd->bdev = NULL;
- r = open_dev(dd, dev, md);
+ r = open_dev(dd, dev);
if (!r)
- close_dev(&dd_copy, md);
+ close_dev(&dd_copy);
else
*dd = dd_copy;
struct dm_dev *dd;
unsigned int major, minor;
- BUG_ON(!t);
+ if (!t)
+ BUG();
if (sscanf(path, "%u:%u", &major, &minor) == 2) {
/* Extract the major/minor numbers */
dd->mode = mode;
dd->bdev = NULL;
- if ((r = open_dev(dd, dev, t->md))) {
+ if ((r = open_dev(dd, dev))) {
kfree(dd);
return r;
}
list_add(&dd->list, &t->devices);
} else if (dd->mode != (mode | dd->mode)) {
- r = upgrade_mode(dd, mode, t->md);
+ r = upgrade_mode(dd, mode);
if (r)
return r;
}
rs->seg_boundary_mask =
min_not_zero(rs->seg_boundary_mask,
q->seg_boundary_mask);
-
- rs->no_cluster |= !test_bit(QUEUE_FLAG_CLUSTER, &q->queue_flags);
}
return r;
void dm_put_device(struct dm_target *ti, struct dm_dev *dd)
{
if (atomic_dec_and_test(&dd->count)) {
- close_dev(dd, ti->table->md);
+ close_dev(dd);
list_del(&dd->list);
kfree(dd);
}
return r;
}
-static DEFINE_MUTEX(_event_lock);
+static DECLARE_MUTEX(_event_lock);
void dm_table_event_callback(struct dm_table *t,
void (*fn)(void *), void *context)
{
- mutex_lock(&_event_lock);
+ down(&_event_lock);
t->event_fn = fn;
t->event_context = context;
- mutex_unlock(&_event_lock);
+ up(&_event_lock);
}
void dm_table_event(struct dm_table *t)
*/
BUG_ON(in_interrupt());
- mutex_lock(&_event_lock);
+ down(&_event_lock);
if (t->event_fn)
t->event_fn(t->event_context);
- mutex_unlock(&_event_lock);
+ up(&_event_lock);
}
sector_t dm_table_get_size(struct dm_table *t)
q->hardsect_size = t->limits.hardsect_size;
q->max_segment_size = t->limits.max_segment_size;
q->seg_boundary_mask = t->limits.seg_boundary_mask;
- if (t->limits.no_cluster)
- q->queue_flags &= ~(1 << QUEUE_FLAG_CLUSTER);
- else
- q->queue_flags |= (1 << QUEUE_FLAG_CLUSTER);
-
}
unsigned int dm_table_get_num_targets(struct dm_table *t)
return ret;
}
-struct mapped_device *dm_table_get_md(struct dm_table *t)
-{
- dm_get(t->md);
-
- return t->md;
-}
-
EXPORT_SYMBOL(dm_vcalloc);
EXPORT_SYMBOL(dm_get_device);
EXPORT_SYMBOL(dm_put_device);
EXPORT_SYMBOL(dm_table_event);
EXPORT_SYMBOL(dm_table_get_size);
EXPORT_SYMBOL(dm_table_get_mode);
-EXPORT_SYMBOL(dm_table_get_md);
EXPORT_SYMBOL(dm_table_put);
EXPORT_SYMBOL(dm_table_get);
EXPORT_SYMBOL(dm_table_unplug_all);