#include <linux/ctype.h>
#include <linux/slab.h>
#include <linux/interrupt.h>
-#include <linux/mutex.h>
#include <asm/atomic.h>
-#define DM_MSG_PREFIX "table"
-
#define MAX_DEPTH 16
#define NODE_SIZE L1_CACHE_BYTES
#define KEYS_PER_NODE (NODE_SIZE / sizeof(sector_t))
#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;
}
-int dm_create_error_table(struct dm_table **result, struct mapped_device *md)
-{
- struct dm_table *t;
- sector_t dev_size = 1;
- int r;
-
- /*
- * Find current size of device.
- * Default to 1 sector if inactive.
- */
- t = dm_get_table(md);
- if (t) {
- dev_size = dm_table_get_size(t);
- dm_table_put(t);
- }
-
- r = dm_table_create(&t, FMODE_READ, 1, md);
- if (r)
- return r;
-
- r = dm_table_add_target(t, "error", 0, dev_size, NULL);
- if (r)
- goto out;
-
- r = dm_table_complete(t);
- if (r)
- goto out;
-
- *result = t;
-
-out:
- if (r)
- dm_table_put(t);
-
- return r;
-}
-EXPORT_SYMBOL_GPL(dm_create_error_table);
-
static void free_devices(struct list_head *devices)
{
struct list_head *tmp, *next;
/*
* 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);
}
unsigned array_size = 0;
*argc = 0;
-
- if (!input) {
- *argvp = NULL;
- return 0;
- }
-
argv = realloc_argv(&array_size, argv);
if (!argv)
return -ENOMEM;
memset(tgt, 0, sizeof(*tgt));
if (!len) {
- DMERR("%s: zero-length target", dm_device_name(t->md));
+ tgt->error = "zero-length target";
+ DMERR("%s", tgt->error);
return -EINVAL;
}
tgt->type = dm_get_target_type(type);
if (!tgt->type) {
- DMERR("%s: %s: unknown target type", dm_device_name(t->md),
- type);
+ tgt->error = "unknown target type";
+ DMERR("%s", tgt->error);
return -EINVAL;
}
return 0;
bad:
- DMERR("%s: %s: %s", dm_device_name(t->md), type, tgt->error);
+ DMERR("%s", tgt->error);
dm_put_target_type(tgt->type);
return r;
}
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)
struct dm_target *dm_table_get_target(struct dm_table *t, unsigned int index)
{
- if (index >= t->num_targets)
+ if (index > t->num_targets)
return NULL;
return t->targets + index;
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);
git://git.onelab.eu / linux-2.6.git / blobdiff