/*
* Copyright (C) 2001, 2002 Sistina Software (UK) Limited.
- * Copyright (C) 2004 - 2006 Red Hat, Inc. All rights reserved.
+ * Copyright (C) 2004 - 2005 Red Hat, Inc. All rights reserved.
*
* This file is released under the GPL.
*/
#include <linux/init.h>
#include <linux/wait.h>
#include <linux/slab.h>
+#include <linux/devfs_fs_kernel.h>
#include <linux/dm-ioctl.h>
-#include <linux/hdreg.h>
#include <asm/uaccess.h>
-#define DM_MSG_PREFIX "ioctl"
#define DM_DRIVER_EMAIL "dm-devel@redhat.com"
/*-----------------------------------------------------------------
static struct list_head _name_buckets[NUM_BUCKETS];
static struct list_head _uuid_buckets[NUM_BUCKETS];
-static void dm_hash_remove_all(int keep_open_devices);
+static void dm_hash_remove_all(void);
/*
* Guards access to both hash tables.
{
init_buckets(_name_buckets);
init_buckets(_uuid_buckets);
+ devfs_mk_dir(DM_DIR);
return 0;
}
static void dm_hash_exit(void)
{
- dm_hash_remove_all(0);
+ dm_hash_remove_all();
+ devfs_remove(DM_DIR);
}
/*-----------------------------------------------------------------
unsigned int h = hash_str(str);
list_for_each_entry (hc, _name_buckets + h, name_list)
- if (!strcmp(hc->name, str)) {
- dm_get(hc->md);
+ if (!strcmp(hc->name, str))
return hc;
- }
return NULL;
}
unsigned int h = hash_str(str);
list_for_each_entry (hc, _uuid_buckets + h, uuid_list)
- if (!strcmp(hc->uuid, str)) {
- dm_get(hc->md);
+ if (!strcmp(hc->uuid, str))
return hc;
- }
return NULL;
}
}
}
+/*
+ * devfs stuff.
+ */
+static int register_with_devfs(struct hash_cell *hc)
+{
+ struct gendisk *disk = dm_disk(hc->md);
+
+ devfs_mk_bdev(MKDEV(disk->major, disk->first_minor),
+ S_IFBLK | S_IRUSR | S_IWUSR | S_IRGRP,
+ DM_DIR "/%s", hc->name);
+ return 0;
+}
+
+static int unregister_with_devfs(struct hash_cell *hc)
+{
+ devfs_remove(DM_DIR"/%s", hc->name);
+ return 0;
+}
+
/*
* The kdev_t and uuid of a device can never change once it is
* initially inserted.
*/
static int dm_hash_insert(const char *name, const char *uuid, struct mapped_device *md)
{
- struct hash_cell *cell, *hc;
+ struct hash_cell *cell;
/*
* Allocate the new cells.
* Insert the cell into both hash tables.
*/
down_write(&_hash_lock);
- hc = __get_name_cell(name);
- if (hc) {
- dm_put(hc->md);
+ if (__get_name_cell(name))
goto bad;
- }
list_add(&cell->name_list, _name_buckets + hash_str(name));
if (uuid) {
- hc = __get_uuid_cell(uuid);
- if (hc) {
+ if (__get_uuid_cell(uuid)) {
list_del(&cell->name_list);
- dm_put(hc->md);
goto bad;
}
list_add(&cell->uuid_list, _uuid_buckets + hash_str(uuid));
}
+ register_with_devfs(cell);
dm_get(md);
dm_set_mdptr(md, cell);
up_write(&_hash_lock);
/* remove from the dev hash */
list_del(&hc->uuid_list);
list_del(&hc->name_list);
+ unregister_with_devfs(hc);
dm_set_mdptr(hc->md, NULL);
table = dm_get_table(hc->md);
dm_table_put(table);
}
+ dm_put(hc->md);
if (hc->new_map)
dm_table_put(hc->new_map);
- dm_put(hc->md);
free_cell(hc);
}
-static void dm_hash_remove_all(int keep_open_devices)
+static void dm_hash_remove_all(void)
{
- int i, dev_skipped, dev_removed;
+ int i;
struct hash_cell *hc;
struct list_head *tmp, *n;
down_write(&_hash_lock);
-
-retry:
- dev_skipped = dev_removed = 0;
for (i = 0; i < NUM_BUCKETS; i++) {
list_for_each_safe (tmp, n, _name_buckets + i) {
hc = list_entry(tmp, struct hash_cell, name_list);
-
- if (keep_open_devices &&
- dm_lock_for_deletion(hc->md)) {
- dev_skipped++;
- continue;
- }
__hash_remove(hc);
- dev_removed = 1;
}
}
-
- /*
- * Some mapped devices may be using other mapped devices, so if any
- * still exist, repeat until we make no further progress.
- */
- if (dev_skipped) {
- if (dev_removed)
- goto retry;
-
- DMWARN("remove_all left %d open device(s)", dev_skipped);
- }
-
up_write(&_hash_lock);
}
if (hc) {
DMWARN("asked to rename to an already existing name %s -> %s",
old, new);
- dm_put(hc->md);
up_write(&_hash_lock);
kfree(new_name);
return -EBUSY;
/*
* rename and move the name cell.
*/
+ unregister_with_devfs(hc);
+
list_del(&hc->name_list);
old_name = hc->name;
hc->name = new_name;
list_add(&hc->name_list, _name_buckets + hash_str(new_name));
+ /* rename the device node in devfs */
+ register_with_devfs(hc);
+
/*
* Wake up any dm event waiters.
*/
dm_table_put(table);
}
- dm_put(hc->md);
up_write(&_hash_lock);
kfree(old_name);
return 0;
static int remove_all(struct dm_ioctl *param, size_t param_size)
{
- dm_hash_remove_all(1);
+ dm_hash_remove_all();
param->data_size = 0;
return 0;
}
{
struct gendisk *disk = dm_disk(md);
struct dm_table *table;
+ struct block_device *bdev;
param->flags &= ~(DM_SUSPEND_FLAG | DM_READONLY_FLAG |
DM_ACTIVE_PRESENT_FLAG);
param->dev = huge_encode_dev(MKDEV(disk->major, disk->first_minor));
- /*
- * Yes, this will be out of date by the time it gets back
- * to userland, but it is still very useful for
- * debugging.
- */
- param->open_count = dm_open_count(md);
+ if (!(param->flags & DM_SKIP_BDGET_FLAG)) {
+ bdev = bdget_disk(disk, 0);
+ if (!bdev)
+ return -ENXIO;
+
+ /*
+ * Yes, this will be out of date by the time it gets back
+ * to userland, but it is still very useful for
+ * debugging.
+ */
+ param->open_count = bdev->bd_openers;
+ bdput(bdev);
+ } else
+ param->open_count = -1;
if (disk->policy)
param->flags |= DM_READONLY_FLAG;
static int dev_create(struct dm_ioctl *param, size_t param_size)
{
- int r, m = DM_ANY_MINOR;
+ int r;
struct mapped_device *md;
r = check_name(param->name);
return r;
if (param->flags & DM_PERSISTENT_DEV_FLAG)
- m = MINOR(huge_decode_dev(param->dev));
+ r = dm_create_with_minor(MINOR(huge_decode_dev(param->dev)), &md);
+ else
+ r = dm_create(&md);
- r = dm_create(m, &md);
if (r)
return r;
*/
static struct hash_cell *__find_device_hash_cell(struct dm_ioctl *param)
{
- struct mapped_device *md;
- void *mdptr = NULL;
-
if (*param->uuid)
return __get_uuid_cell(param->uuid);
-
- if (*param->name)
+ else if (*param->name)
return __get_name_cell(param->name);
-
- md = dm_get_md(huge_decode_dev(param->dev));
- if (md)
- mdptr = dm_get_mdptr(md);
-
- return mdptr;
+ else
+ return dm_get_mdptr(huge_decode_dev(param->dev));
}
static struct mapped_device *find_device(struct dm_ioctl *param)
hc = __find_device_hash_cell(param);
if (hc) {
md = hc->md;
+ dm_get(md);
/*
* Sneakily write in both the name and the uuid
static int dev_remove(struct dm_ioctl *param, size_t param_size)
{
struct hash_cell *hc;
- struct mapped_device *md;
- int r;
down_write(&_hash_lock);
hc = __find_device_hash_cell(param);
return -ENXIO;
}
- md = hc->md;
-
- /*
- * Ensure the device is not open and nothing further can open it.
- */
- r = dm_lock_for_deletion(md);
- if (r) {
- DMWARN("unable to remove open device %s", hc->name);
- up_write(&_hash_lock);
- dm_put(md);
- return r;
- }
-
__hash_remove(hc);
up_write(&_hash_lock);
- dm_put(md);
param->data_size = 0;
return 0;
}
return dm_hash_rename(param->name, new_name);
}
-static int dev_set_geometry(struct dm_ioctl *param, size_t param_size)
-{
- int r = -EINVAL, x;
- struct mapped_device *md;
- struct hd_geometry geometry;
- unsigned long indata[4];
- char *geostr = (char *) param + param->data_start;
-
- md = find_device(param);
- if (!md)
- return -ENXIO;
-
- if (geostr < (char *) (param + 1) ||
- invalid_str(geostr, (void *) param + param_size)) {
- DMWARN("Invalid geometry supplied.");
- goto out;
- }
-
- x = sscanf(geostr, "%lu %lu %lu %lu", indata,
- indata + 1, indata + 2, indata + 3);
-
- if (x != 4) {
- DMWARN("Unable to interpret geometry settings.");
- goto out;
- }
-
- if (indata[0] > 65535 || indata[1] > 255 ||
- indata[2] > 255 || indata[3] > ULONG_MAX) {
- DMWARN("Geometry exceeds range limits.");
- goto out;
- }
-
- geometry.cylinders = indata[0];
- geometry.heads = indata[1];
- geometry.sectors = indata[2];
- geometry.start = indata[3];
-
- r = dm_set_geometry(md, &geometry);
- if (!r)
- r = __dev_status(md, param);
-
- param->data_size = 0;
-
-out:
- dm_put(md);
- return r;
-}
-
static int do_suspend(struct dm_ioctl *param)
{
int r = 0;
}
md = hc->md;
+ dm_get(md);
new_map = hc->new_map;
hc->new_map = NULL;
int r;
struct hash_cell *hc;
struct dm_table *t;
- struct mapped_device *md;
- md = find_device(param);
- if (!md)
- return -ENXIO;
-
- r = dm_table_create(&t, get_mode(param), param->target_count, md);
+ r = dm_table_create(&t, get_mode(param), param->target_count);
if (r)
- goto out;
+ return r;
r = populate_table(t, param, param_size);
if (r) {
dm_table_put(t);
- goto out;
+ return r;
}
down_write(&_hash_lock);
- hc = dm_get_mdptr(md);
- if (!hc || hc->md != md) {
- DMWARN("device has been removed from the dev hash table.");
- dm_table_put(t);
+ hc = __find_device_hash_cell(param);
+ if (!hc) {
+ DMWARN("device doesn't appear to be in the dev hash table.");
up_write(&_hash_lock);
- r = -ENXIO;
- goto out;
+ dm_table_put(t);
+ return -ENXIO;
}
if (hc->new_map)
dm_table_put(hc->new_map);
hc->new_map = t;
- up_write(&_hash_lock);
-
param->flags |= DM_INACTIVE_PRESENT_FLAG;
- r = __dev_status(md, param);
-
-out:
- dm_put(md);
+ r = __dev_status(hc->md, param);
+ up_write(&_hash_lock);
return r;
}
{
int r;
struct hash_cell *hc;
- struct mapped_device *md;
down_write(&_hash_lock);
param->flags &= ~DM_INACTIVE_PRESENT_FLAG;
r = __dev_status(hc->md, param);
- md = hc->md;
up_write(&_hash_lock);
- dm_put(md);
return r;
}
{DM_LIST_VERSIONS_CMD, list_versions},
- {DM_TARGET_MSG_CMD, target_message},
- {DM_DEV_SET_GEOMETRY_CMD, dev_set_geometry}
+ {DM_TARGET_MSG_CMD, target_message}
};
return (cmd >= ARRAY_SIZE(_ioctls)) ? NULL : _ioctls[cmd].fn;
static struct miscdevice _dm_misc = {
.minor = MISC_DYNAMIC_MINOR,
.name = DM_NAME,
+ .devfs_name = "mapper/control",
.fops = &_ctl_fops
};
git://git.onelab.eu / linux-2.6.git / blobdiff