/*
* Copyright (C) 2001, 2002 Sistina Software (UK) Limited.
- * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
*
* This file is released under the GPL.
*/
#include <linux/hdreg.h>
#include <linux/blktrace_api.h>
-#define DM_MSG_PREFIX "core"
-
static const char *_name = DM_NAME;
static unsigned int major = 0;
union map_info *dm_get_mapinfo(struct bio *bio)
{
- if (bio && bio->bi_private)
- return &((struct target_io *)bio->bi_private)->info;
- return NULL;
+ if (bio && bio->bi_private)
+ return &((struct target_io *)bio->bi_private)->info;
+ return NULL;
}
#define MINOR_ALLOCED ((void *)-1)
#define DMF_SUSPENDED 1
#define DMF_FROZEN 2
#define DMF_FREEING 3
-#define DMF_DELETING 4
struct mapped_device {
struct rw_semaphore io_lock;
struct semaphore suspend_lock;
rwlock_t map_lock;
atomic_t holders;
- atomic_t open_count;
unsigned long flags;
bioset_free(dm_set);
if (unregister_blkdev(_major, _name) < 0)
- DMERR("unregister_blkdev failed");
+ DMERR("devfs_unregister_blkdev failed");
_major = 0;
if (!md)
goto out;
- if (test_bit(DMF_FREEING, &md->flags) ||
- test_bit(DMF_DELETING, &md->flags)) {
+ if (test_bit(DMF_FREEING, &md->flags)) {
md = NULL;
goto out;
}
dm_get(md);
- atomic_inc(&md->open_count);
out:
spin_unlock(&_minor_lock);
struct mapped_device *md;
md = inode->i_bdev->bd_disk->private_data;
- atomic_dec(&md->open_count);
dm_put(md);
return 0;
}
-int dm_open_count(struct mapped_device *md)
-{
- return atomic_read(&md->open_count);
-}
-
-/*
- * Guarantees nothing is using the device before it's deleted.
- */
-int dm_lock_for_deletion(struct mapped_device *md)
-{
- int r = 0;
-
- spin_lock(&_minor_lock);
-
- if (dm_open_count(md))
- r = -EBUSY;
- else
- set_bit(DMF_DELETING, &md->flags);
-
- spin_unlock(&_minor_lock);
-
- return r;
-}
-
static int dm_blk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
{
struct mapped_device *md = bdev->bd_disk->private_data;
if (r > 0) {
/* the bio has been remapped so dispatch it */
- blk_add_trace_remap(bdev_get_queue(clone->bi_bdev), clone,
- tio->io->bio->bi_bdev->bd_dev, sector,
+ blk_add_trace_remap(bdev_get_queue(clone->bi_bdev), clone,
+ tio->io->bio->bi_bdev->bd_dev, sector,
clone->bi_sector);
generic_make_request(clone);
*---------------------------------------------------------------*/
static DEFINE_IDR(_minor_idr);
-static void free_minor(int minor)
+static void free_minor(unsigned int minor)
{
spin_lock(&_minor_lock);
idr_remove(&_minor_idr, minor);
/*
* See if the device with a specific minor # is free.
*/
-static int specific_minor(struct mapped_device *md, int minor)
+static int specific_minor(struct mapped_device *md, unsigned int minor)
{
int r, m;
return r;
}
-static int next_free_minor(struct mapped_device *md, int *minor)
+static int next_free_minor(struct mapped_device *md, unsigned int *minor)
{
- int r, m;
+ int r;
+ unsigned int m;
r = idr_pre_get(&_minor_idr, GFP_KERNEL);
if (!r)
/*
* Allocate and initialise a blank device with a given minor.
*/
-static struct mapped_device *alloc_dev(int minor)
+static struct mapped_device *alloc_dev(unsigned int minor, int persistent)
{
int r;
struct mapped_device *md = kmalloc(sizeof(*md), GFP_KERNEL);
goto bad0;
/* get a minor number for the dev */
- if (minor == DM_ANY_MINOR)
- r = next_free_minor(md, &minor);
- else
- r = specific_minor(md, minor);
+ r = persistent ? specific_minor(md, minor) : next_free_minor(md, &minor);
if (r < 0)
goto bad1;
init_MUTEX(&md->suspend_lock);
rwlock_init(&md->map_lock);
atomic_set(&md->holders, 1);
- atomic_set(&md->open_count, 0);
atomic_set(&md->event_nr, 0);
md->queue = blk_alloc_queue(GFP_KERNEL);
static void free_dev(struct mapped_device *md)
{
- int minor = md->disk->first_minor;
+ unsigned int minor = md->disk->first_minor;
if (md->suspended_bdev) {
thaw_bdev(md->suspended_bdev, NULL);
/*
* Constructor for a new device.
*/
-int dm_create(int minor, struct mapped_device **result)
+static int create_aux(unsigned int minor, int persistent,
+ struct mapped_device **result)
{
struct mapped_device *md;
- md = alloc_dev(minor);
+ md = alloc_dev(minor, persistent);
if (!md)
return -ENXIO;
return 0;
}
+int dm_create(struct mapped_device **result)
+{
+ return create_aux(0, 0, result);
+}
+
+int dm_create_with_minor(unsigned int minor, struct mapped_device **result)
+{
+ return create_aux(minor, 1, result);
+}
+
static struct mapped_device *dm_find_md(dev_t dev)
{
struct mapped_device *md;
md = idr_find(&_minor_idr, minor);
if (md && (md == MINOR_ALLOCED ||
(dm_disk(md)->first_minor != minor) ||
- test_bit(DMF_FREEING, &md->flags))) {
+ test_bit(DMF_FREEING, &md->flags))) {
md = NULL;
goto out;
}
atomic_inc(&md->holders);
}
-const char *dm_device_name(struct mapped_device *md)
-{
- return md->name;
-}
-EXPORT_SYMBOL_GPL(dm_device_name);
-
void dm_put(struct mapped_device *md)
{
struct dm_table *map;