Attachment #13235 for bug #22768

View | Details | Raw Unified | Return to bug 22768
Collapse All | Expand All




  want), say M here and read <file:Documentation/modules.txt>.  The
  module will be called lvm-mod.o.

Device-mapper support
CONFIG_BLK_DEV_DM
  Device-mapper is a low level volume manager.  It works by allowing
  people to specify mappings for ranges of logical sectors.  Various
  mapping types are available, in addition people may write their own
  modules containing custom mappings if they wish.

  Higher level volume managers such as LVM2 use this driver.

  If you want to compile this as a module, say M here and read 
  <file:Documentation/modules.txt>.  The module will be called dm-mod.o.

  If unsure, say N.

Multiple devices driver support (RAID and LVM)
CONFIG_MD
  Support multiple physical spindles through a single logical device.

Lines 441-446 Link Here

(-)linux-2.4.20-gentoo-r5/MAINTAINERS (+7 lines)
441	W: http://www.debian.org/~dz/i8k/	441	W: http://www.debian.org/~dz/i8k/
442	S: Maintained	442	S: Maintained
443		443
		444	DEVICE MAPPER
		445	P: Joe Thornber
		446	M: dm@uk.sistina.com
		447	L: linux-LVM@sistina.com
		448	W: http://www.sistina.com/lvm
		449	S: Maintained
		450
444	DEVICE NUMBER REGISTRY	451	DEVICE NUMBER REGISTRY
445	P: H. Peter Anvin	452	P: H. Peter Anvin
446	M: hpa@zytor.com	453	M: hpa@zytor.com




#include <linux/auto_fs.h>
#include <linux/ext2_fs.h>
#include <linux/raid/md_u.h>
#include <linux/dm-ioctl.h>

#include <scsi/scsi.h>
#undef __KERNEL__		/* This file was born to be ugly ...  */

	IOCTL32_DEFAULT(RESTART_ARRAY_RW),
#endif /* CONFIG_MD */

#if defined(CONFIG_BLK_DEV_DM) || defined(CONFIG_BLK_DEV_DM_MODULE)
	IOCTL32_DEFAULT(DM_VERSION),
	IOCTL32_DEFAULT(DM_REMOVE_ALL),
	IOCTL32_DEFAULT(DM_DEV_CREATE),
	IOCTL32_DEFAULT(DM_DEV_REMOVE),
	IOCTL32_DEFAULT(DM_DEV_RELOAD),
	IOCTL32_DEFAULT(DM_DEV_SUSPEND),
	IOCTL32_DEFAULT(DM_DEV_RENAME),
	IOCTL32_DEFAULT(DM_DEV_DEPS),
	IOCTL32_DEFAULT(DM_DEV_STATUS),
	IOCTL32_DEFAULT(DM_TARGET_STATUS),
	IOCTL32_DEFAULT(DM_TARGET_WAIT),
#endif /* CONFIG_BLK_DEV_DM */

	IOCTL32_DEFAULT(MTIOCTOP),			/* mtio.h ioctls  */
	IOCTL32_HANDLER(MTIOCGET32, mt_ioctl_trans),
	IOCTL32_HANDLER(MTIOCPOS32, mt_ioctl_trans),




#define max max */
#include <linux/lvm.h>
#endif /* LVM */
#include <linux/dm-ioctl.h>

#include <scsi/scsi.h>
/* Ugly hack. */

COMPATIBLE_IOCTL(LV_BMAP)
COMPATIBLE_IOCTL(LV_SNAPSHOT_USE_RATE)
#endif /* LVM */
/* Device-Mapper */
#if defined(CONFIG_BLK_DEV_DM) || defined(CONFIG_BLK_DEV_DM_MODULE)
COMPATIBLE_IOCTL(DM_VERSION)
COMPATIBLE_IOCTL(DM_REMOVE_ALL)
COMPATIBLE_IOCTL(DM_DEV_CREATE)
COMPATIBLE_IOCTL(DM_DEV_REMOVE)
COMPATIBLE_IOCTL(DM_DEV_RELOAD)
COMPATIBLE_IOCTL(DM_DEV_SUSPEND)
COMPATIBLE_IOCTL(DM_DEV_RENAME)
COMPATIBLE_IOCTL(DM_DEV_DEPS)
COMPATIBLE_IOCTL(DM_DEV_STATUS)
COMPATIBLE_IOCTL(DM_TARGET_STATUS)
COMPATIBLE_IOCTL(DM_TARGET_WAIT)
#endif /* CONFIG_BLK_DEV_DM */
#if defined(CONFIG_DRM) || defined(CONFIG_DRM_MODULE)
COMPATIBLE_IOCTL(DRM_IOCTL_GET_MAGIC)
COMPATIBLE_IOCTL(DRM_IOCTL_IRQ_BUSID)




#if defined(CONFIG_BLK_DEV_LVM) || defined(CONFIG_BLK_DEV_LVM_MODULE)
#include <linux/lvm.h>
#endif /* LVM */
#include <linux/dm-ioctl.h>

#include <scsi/scsi.h>
/* Ugly hack. */

COMPATIBLE_IOCTL(NBD_PRINT_DEBUG),
COMPATIBLE_IOCTL(NBD_SET_SIZE_BLOCKS),
COMPATIBLE_IOCTL(NBD_DISCONNECT),
/* device-mapper */
#if defined(CONFIG_BLK_DEV_DM) || defined(CONFIG_BLK_DEV_DM_MODULE)
COMPATIBLE_IOCTL(DM_VERSION),
COMPATIBLE_IOCTL(DM_REMOVE_ALL),
COMPATIBLE_IOCTL(DM_DEV_CREATE),
COMPATIBLE_IOCTL(DM_DEV_REMOVE),
COMPATIBLE_IOCTL(DM_DEV_RELOAD),
COMPATIBLE_IOCTL(DM_DEV_SUSPEND),
COMPATIBLE_IOCTL(DM_DEV_RENAME),
COMPATIBLE_IOCTL(DM_DEV_DEPS),
COMPATIBLE_IOCTL(DM_DEV_STATUS),
COMPATIBLE_IOCTL(DM_TARGET_STATUS),
COMPATIBLE_IOCTL(DM_TARGET_WAIT),
#endif /* CONFIG_BLK_DEV_DM */
/* Remove *PRIVATE in 2.5 */
COMPATIBLE_IOCTL(SIOCDEVPRIVATE),
COMPATIBLE_IOCTL(SIOCDEVPRIVATE+1),




#include <linux/ext2_fs.h>
#include <linux/hdreg.h>
#include <linux/if_bonding.h>
#include <linux/dm-ioctl.h>
#include <asm/types.h>
#include <asm/uaccess.h>
#include <asm/dasd.h>


	IOCTL32_DEFAULT(SIOCGSTAMP),

	IOCTL32_DEFAULT(DM_VERSION),
	IOCTL32_DEFAULT(DM_REMOVE_ALL),
	IOCTL32_DEFAULT(DM_DEV_CREATE),
	IOCTL32_DEFAULT(DM_DEV_REMOVE),
	IOCTL32_DEFAULT(DM_DEV_RELOAD),
	IOCTL32_DEFAULT(DM_DEV_SUSPEND),
	IOCTL32_DEFAULT(DM_DEV_RENAME),
	IOCTL32_DEFAULT(DM_DEV_DEPS),
	IOCTL32_DEFAULT(DM_DEV_STATUS),
	IOCTL32_DEFAULT(DM_TARGET_STATUS),
	IOCTL32_DEFAULT(DM_TARGET_WAIT),

	IOCTL32_HANDLER(SIOCGIFNAME, dev_ifname32),
	IOCTL32_HANDLER(SIOCGIFCONF, dev_ifconf),
	IOCTL32_HANDLER(SIOCGIFFLAGS, dev_ifsioc),




#if defined(CONFIG_BLK_DEV_LVM) || defined(CONFIG_BLK_DEV_LVM_MODULE)
#include <linux/lvm.h>
#endif /* LVM */
#include <linux/dm-ioctl.h>

#include <scsi/scsi.h>
/* Ugly hack. */

COMPATIBLE_IOCTL(NBD_PRINT_DEBUG)
COMPATIBLE_IOCTL(NBD_SET_SIZE_BLOCKS)
COMPATIBLE_IOCTL(NBD_DISCONNECT)
/* device-mapper */
#if defined(CONFIG_BLK_DEV_DM) || defined(CONFIG_BLK_DEV_DM_MODULE)
COMPATIBLE_IOCTL(DM_VERSION)
COMPATIBLE_IOCTL(DM_REMOVE_ALL)
COMPATIBLE_IOCTL(DM_DEV_CREATE)
COMPATIBLE_IOCTL(DM_DEV_REMOVE)
COMPATIBLE_IOCTL(DM_DEV_RELOAD)
COMPATIBLE_IOCTL(DM_DEV_SUSPEND)
COMPATIBLE_IOCTL(DM_DEV_RENAME)
COMPATIBLE_IOCTL(DM_DEV_DEPS)
COMPATIBLE_IOCTL(DM_DEV_STATUS)
COMPATIBLE_IOCTL(DM_TARGET_STATUS)
COMPATIBLE_IOCTL(DM_TARGET_WAIT)
#endif /* CONFIG_BLK_DEV_DM */

/* SCSI Changer */
COMPATIBLE_IOCTL(CHIOMOVE)
COMPATIBLE_IOCTL(CHIOEXCHANGE)




#define max max
#include <linux/lvm.h>
#endif /* LVM */
#include <linux/dm-ioctl.h>

#include <scsi/scsi.h>
/* Ugly hack. */

COMPATIBLE_IOCTL(LV_BMAP)
COMPATIBLE_IOCTL(LV_SNAPSHOT_USE_RATE)
#endif /* LVM */
/* Device-Mapper */
#if defined(CONFIG_BLK_DEV_DM) || defined(CONFIG_BLK_DEV_DM_MODULE)
COMPATIBLE_IOCTL(DM_VERSION)
COMPATIBLE_IOCTL(DM_REMOVE_ALL)
COMPATIBLE_IOCTL(DM_DEV_CREATE)
COMPATIBLE_IOCTL(DM_DEV_REMOVE)
COMPATIBLE_IOCTL(DM_DEV_RELOAD)
COMPATIBLE_IOCTL(DM_DEV_SUSPEND)
COMPATIBLE_IOCTL(DM_DEV_RENAME)
COMPATIBLE_IOCTL(DM_DEV_DEPS)
COMPATIBLE_IOCTL(DM_DEV_STATUS)
COMPATIBLE_IOCTL(DM_TARGET_STATUS)
COMPATIBLE_IOCTL(DM_TARGET_WAIT)
#endif /* CONFIG_BLK_DEV_DM */
#if defined(CONFIG_DRM) || defined(CONFIG_DRM_MODULE)
COMPATIBLE_IOCTL(DRM_IOCTL_GET_MAGIC)
COMPATIBLE_IOCTL(DRM_IOCTL_IRQ_BUSID)

Lines 14-18 Link Here

(-)linux-2.4.20-gentoo-r5/drivers/md/Config.in (+3 lines)
14	dep_tristate ' Multipath I/O support' CONFIG_MD_MULTIPATH $CONFIG_BLK_DEV_MD	14	dep_tristate ' Multipath I/O support' CONFIG_MD_MULTIPATH $CONFIG_BLK_DEV_MD
15		15
16	dep_tristate ' Logical volume manager (LVM) support' CONFIG_BLK_DEV_LVM $CONFIG_MD	16	dep_tristate ' Logical volume manager (LVM) support' CONFIG_BLK_DEV_LVM $CONFIG_MD
		17	if [ "$CONFIG_EXPERIMENTAL" = "y" ]; then
		18	dep_tristate ' Device-mapper support (EXPERIMENTAL)' CONFIG_BLK_DEV_DM $CONFIG_MD
		19	fi
17		20
18	endmenu	21	endmenu

Lines 4-12 Link Here

(-)linux-2.4.20-gentoo-r5/drivers/md/Makefile (-1 / +8 lines)
4		4
5	O_TARGET := mddev.o	5	O_TARGET := mddev.o
6		6
7	export-objs := md.o xor.o	7	export-objs := md.o xor.o dm-table.o dm-target.o kcopyd.o
8	list-multi := lvm-mod.o	8	list-multi := lvm-mod.o
9	lvm-mod-objs := lvm.o lvm-snap.o lvm-fs.o	9	lvm-mod-objs := lvm.o lvm-snap.o lvm-fs.o
		10	dm-mod-objs := dm.o dm-table.o dm-target.o dm-ioctl.o \
		11	dm-linear.o dm-stripe.o dm-snapshot.o dm-exception-store.o \
		12	kcopyd.o
10		13
11	# Note: link order is important. All raid personalities	14	# Note: link order is important. All raid personalities
12	# and xor.o must come before md.o, as they each initialise	15	# and xor.o must come before md.o, as they each initialise
Lines 20-27 Link Here
20	obj-$(CONFIG_MD_MULTIPATH) += multipath.o	23	obj-$(CONFIG_MD_MULTIPATH) += multipath.o
21	obj-$(CONFIG_BLK_DEV_MD) += md.o	24	obj-$(CONFIG_BLK_DEV_MD) += md.o
22	obj-$(CONFIG_BLK_DEV_LVM) += lvm-mod.o	25	obj-$(CONFIG_BLK_DEV_LVM) += lvm-mod.o
		26	obj-$(CONFIG_BLK_DEV_DM) += dm-mod.o
23		27
24	include $(TOPDIR)/Rules.make	28	include $(TOPDIR)/Rules.make
25		29
26	lvm-mod.o: $(lvm-mod-objs)	30	lvm-mod.o: $(lvm-mod-objs)
27	$(LD) -r -o $@ $(lvm-mod-objs)	31	$(LD) -r -o $@ $(lvm-mod-objs)
		32
		33	dm-mod.o: $(dm-mod-objs)
		34	$(LD) -r -o $@ $(dm-mod-objs)




/*
 * dm-snapshot.c
 *
 * Copyright (C) 2001-2002 Sistina Software (UK) Limited.
 *
 * This file is released under the GPL.
 */

#include "dm-snapshot.h"
#include "kcopyd.h"

#include <linux/mm.h>
#include <linux/pagemap.h>
#include <linux/vmalloc.h>
#include <linux/slab.h>

/*-----------------------------------------------------------------
 * Persistent snapshots, by persistent we mean that the snapshot
 * will survive a reboot.
 *---------------------------------------------------------------*/

/*
 * We need to store a record of which parts of the origin have
 * been copied to the snapshot device.  The snapshot code
 * requires that we copy exception chunks to chunk aligned areas
 * of the COW store.  It makes sense therefore, to store the
 * metadata in chunk size blocks.
 *
 * There is no backward or forward compatibility implemented,
 * snapshots with different disk versions than the kernel will
 * not be usable.  It is expected that "lvcreate" will blank out
 * the start of a fresh COW device before calling the snapshot
 * constructor.
 *
 * The first chunk of the COW device just contains the header.
 * After this there is a chunk filled with exception metadata,
 * followed by as many exception chunks as can fit in the
 * metadata areas.
 *
 * All on disk structures are in little-endian format.  The end
 * of the exceptions info is indicated by an exception with a
 * new_chunk of 0, which is invalid since it would point to the
 * header chunk.
 */

/*
 * Magic for persistent snapshots: "SnAp" - Feeble isn't it.
 */
#define SNAP_MAGIC 0x70416e53

/*
 * The on-disk version of the metadata.
 */
#define SNAPSHOT_DISK_VERSION 1

struct disk_header {
	uint32_t magic;

	/*
	 * Is this snapshot valid.  There is no way of recovering
	 * an invalid snapshot.
	 */
	int valid;

	/*
	 * Simple, incrementing version. no backward
	 * compatibility.
	 */
	uint32_t version;

	/* In sectors */
	uint32_t chunk_size;
};

struct disk_exception {
	uint64_t old_chunk;
	uint64_t new_chunk;
};

struct commit_callback {
	void (*callback) (void *, int success);
	void *context;
};

/*
 * The top level structure for a persistent exception store.
 */
struct pstore {
	struct dm_snapshot *snap;	/* up pointer to my snapshot */
	int version;
	int valid;
	uint32_t chunk_size;
	uint32_t exceptions_per_area;

	/*
	 * Now that we have an asynchronous kcopyd there is no
	 * need for large chunk sizes, so it wont hurt to have a
	 * whole chunks worth of metadata in memory at once.
	 */
	void *area;
	struct kiobuf *iobuf;

	/*
	 * Used to keep track of which metadata area the data in
	 * 'chunk' refers to.
	 */
	uint32_t current_area;

	/*
	 * The next free chunk for an exception.
	 */
	uint32_t next_free;

	/*
	 * The index of next free exception in the current
	 * metadata area.
	 */
	uint32_t current_committed;

	atomic_t pending_count;
	uint32_t callback_count;
	struct commit_callback *callbacks;
};

/*
 * For performance reasons we want to defer writing a committed
 * exceptions metadata to disk so that we can amortise away this
 * exensive operation.
 *
 * For the initial version of this code we will remain with
 * synchronous io.  There are some deadlock issues with async
 * that I haven't yet worked out.
 */
static int do_io(int rw, struct kcopyd_region *where, struct kiobuf *iobuf)
{
	int i, sectors_per_block, nr_blocks, start;
	int blocksize = get_hardsect_size(where->dev);
	int status;

	sectors_per_block = blocksize / SECTOR_SIZE;

	nr_blocks = where->count / sectors_per_block;
	start = where->sector / sectors_per_block;

	for (i = 0; i < nr_blocks; i++)
		iobuf->blocks[i] = start++;

	iobuf->length = where->count << 9;
	iobuf->locked = 1;

	status = brw_kiovec(rw, 1, &iobuf, where->dev, iobuf->blocks,
			    blocksize);
	if (status != (where->count << 9))
		return -EIO;

	return 0;
}

static int allocate_iobuf(struct pstore *ps)
{
	size_t i, r = -ENOMEM, len, nr_pages;
	struct page *page;

	len = ps->chunk_size << SECTOR_SHIFT;

	/*
	 * Allocate the chunk_size block of memory that will hold
	 * a single metadata area.
	 */
	ps->area = vmalloc(len);
	if (!ps->area)
		return r;

	if (alloc_kiovec(1, &ps->iobuf))
		goto bad;

	nr_pages = ps->chunk_size / (PAGE_SIZE / SECTOR_SIZE);
	r = expand_kiobuf(ps->iobuf, nr_pages);
	if (r)
		goto bad;

	/*
	 * We lock the pages for ps->area into memory since they'll be
	 * doing a lot of io.
	 */
	for (i = 0; i < nr_pages; i++) {
		page = vmalloc_to_page(ps->area + (i * PAGE_SIZE));
		LockPage(page);
		ps->iobuf->maplist[i] = page;
		ps->iobuf->nr_pages++;
	}

	ps->iobuf->nr_pages = nr_pages;
	ps->iobuf->offset = 0;

	return 0;

      bad:
	if (ps->iobuf)
		free_kiovec(1, &ps->iobuf);

	if (ps->area)
		vfree(ps->area);
	ps->iobuf = NULL;
	return r;
}

static void free_iobuf(struct pstore *ps)
{
	int i;

	for (i = 0; i < ps->iobuf->nr_pages; i++)
		UnlockPage(ps->iobuf->maplist[i]);
	ps->iobuf->locked = 0;

	free_kiovec(1, &ps->iobuf);
	vfree(ps->area);
}

/*
 * Read or write a chunk aligned and sized block of data from a device.
 */
static int chunk_io(struct pstore *ps, uint32_t chunk, int rw)
{
	int r;
	struct kcopyd_region where;

	where.dev = ps->snap->cow->dev;
	where.sector = ps->chunk_size * chunk;
	where.count = ps->chunk_size;

	r = do_io(rw, &where, ps->iobuf);
	if (r)
		return r;

	return 0;
}

/*
 * Read or write a metadata area.  Remembering to skip the first
 * chunk which holds the header.
 */
static int area_io(struct pstore *ps, uint32_t area, int rw)
{
	int r;
	uint32_t chunk;

	/* convert a metadata area index to a chunk index */
	chunk = 1 + ((ps->exceptions_per_area + 1) * area);

	r = chunk_io(ps, chunk, rw);
	if (r)
		return r;

	ps->current_area = area;
	return 0;
}

static int zero_area(struct pstore *ps, uint32_t area)
{
	memset(ps->area, 0, ps->chunk_size << SECTOR_SHIFT);
	return area_io(ps, area, WRITE);
}

static int read_header(struct pstore *ps, int *new_snapshot)
{
	int r;
	struct disk_header *dh;

	r = chunk_io(ps, 0, READ);
	if (r)
		return r;

	dh = (struct disk_header *) ps->area;

	if (dh->magic == 0) {
		*new_snapshot = 1;

	} else if (dh->magic == SNAP_MAGIC) {
		*new_snapshot = 0;
		ps->valid = dh->valid;
		ps->version = dh->version;
		ps->chunk_size = dh->chunk_size;

	} else {
		DMWARN("Invalid/corrupt snapshot");
		r = -ENXIO;
	}

	return r;
}

static int write_header(struct pstore *ps)
{
	struct disk_header *dh;

	memset(ps->area, 0, ps->chunk_size << SECTOR_SHIFT);

	dh = (struct disk_header *) ps->area;
	dh->magic = SNAP_MAGIC;
	dh->valid = ps->valid;
	dh->version = ps->version;
	dh->chunk_size = ps->chunk_size;

	return chunk_io(ps, 0, WRITE);
}

/*
 * Access functions for the disk exceptions, these do the endian conversions.
 */
static struct disk_exception *get_exception(struct pstore *ps, uint32_t index)
{
	if (index >= ps->exceptions_per_area)
		return NULL;

	return ((struct disk_exception *) ps->area) + index;
}

static int read_exception(struct pstore *ps,
			  uint32_t index, struct disk_exception *result)
{
	struct disk_exception *e;

	e = get_exception(ps, index);
	if (!e)
		return -EINVAL;

	/* copy it */
	result->old_chunk = le64_to_cpu(e->old_chunk);
	result->new_chunk = le64_to_cpu(e->new_chunk);

	return 0;
}

static int write_exception(struct pstore *ps,
			   uint32_t index, struct disk_exception *de)
{
	struct disk_exception *e;

	e = get_exception(ps, index);
	if (!e)
		return -EINVAL;

	/* copy it */
	e->old_chunk = cpu_to_le64(de->old_chunk);
	e->new_chunk = cpu_to_le64(de->new_chunk);

	return 0;
}

/*
 * Registers the exceptions that are present in the current area.
 * 'full' is filled in to indicate if the area has been
 * filled.
 */
static int insert_exceptions(struct pstore *ps, int *full)
{
	int i, r;
	struct disk_exception de;

	/* presume the area is full */
	*full = 1;

	for (i = 0; i < ps->exceptions_per_area; i++) {
		r = read_exception(ps, i, &de);

		if (r)
			return r;

		/*
		 * If the new_chunk is pointing at the start of
		 * the COW device, where the first metadata area
		 * is we know that we've hit the end of the
		 * exceptions.  Therefore the area is not full.
		 */
		if (de.new_chunk == 0LL) {
			ps->current_committed = i;
			*full = 0;
			break;
		}

		/*
		 * Keep track of the start of the free chunks.
		 */
		if (ps->next_free <= de.new_chunk)
			ps->next_free = de.new_chunk + 1;

		/*
		 * Otherwise we add the exception to the snapshot.
		 */
		r = dm_add_exception(ps->snap, de.old_chunk, de.new_chunk);
		if (r)
			return r;
	}

	return 0;
}

static int read_exceptions(struct pstore *ps)
{
	uint32_t area;
	int r, full = 1;

	/*
	 * Keeping reading chunks and inserting exceptions until
	 * we find a partially full area.
	 */
	for (area = 0; full; area++) {
		r = area_io(ps, area, READ);
		if (r)
			return r;

		r = insert_exceptions(ps, &full);
		if (r)
			return r;

		area++;
	}

	return 0;
}

static inline struct pstore *get_info(struct exception_store *store)
{
	return (struct pstore *) store->context;
}

static int persistent_percentfull(struct exception_store *store)
{
	struct pstore *ps = get_info(store);
	return (ps->next_free * store->snap->chunk_size * 100) /
	    get_dev_size(store->snap->cow->dev);
}

static void persistent_destroy(struct exception_store *store)
{
	struct pstore *ps = get_info(store);

	vfree(ps->callbacks);
	free_iobuf(ps);
	kfree(ps);
}

static int persistent_prepare(struct exception_store *store,
			      struct exception *e)
{
	struct pstore *ps = get_info(store);
	uint32_t stride;
	sector_t size = get_dev_size(store->snap->cow->dev);

	/* Is there enough room ? */
	if (size < ((ps->next_free + 1) * store->snap->chunk_size))
		return -ENOSPC;

	e->new_chunk = ps->next_free;

	/*
	 * Move onto the next free pending, making sure to take
	 * into account the location of the metadata chunks.
	 */
	stride = (ps->exceptions_per_area + 1);
	if ((++ps->next_free % stride) == 1)
		ps->next_free++;

	atomic_inc(&ps->pending_count);
	return 0;
}

static void persistent_commit(struct exception_store *store,
			      struct exception *e,
			      void (*callback) (void *, int success),
			      void *callback_context)
{
	int r, i;
	struct pstore *ps = get_info(store);
	struct disk_exception de;
	struct commit_callback *cb;

	de.old_chunk = e->old_chunk;
	de.new_chunk = e->new_chunk;
	write_exception(ps, ps->current_committed++, &de);

	/*
	 * Add the callback to the back of the array.  This code
	 * is the only place where the callback array is
	 * manipulated, and we know that it will never be called
	 * multiple times concurrently.
	 */
	cb = ps->callbacks + ps->callback_count++;
	cb->callback = callback;
	cb->context = callback_context;

	/*
	 * If there are no more exceptions in flight, or we have
	 * filled this metadata area we commit the exceptions to
	 * disk.
	 */
	if (atomic_dec_and_test(&ps->pending_count) ||
	    (ps->current_committed == ps->exceptions_per_area)) {
		r = area_io(ps, ps->current_area, WRITE);
		if (r)
			ps->valid = 0;

		for (i = 0; i < ps->callback_count; i++) {
			cb = ps->callbacks + i;
			cb->callback(cb->context, r == 0 ? 1 : 0);
		}

		ps->callback_count = 0;
	}

	/*
	 * Have we completely filled the current area ?
	 */
	if (ps->current_committed == ps->exceptions_per_area) {
		ps->current_committed = 0;
		r = zero_area(ps, ps->current_area + 1);
		if (r)
			ps->valid = 0;
	}
}

static void persistent_drop(struct exception_store *store)
{
	struct pstore *ps = get_info(store);

	ps->valid = 0;
	if (write_header(ps))
		DMWARN("write header failed");
}

int dm_create_persistent(struct exception_store *store, uint32_t chunk_size)
{
	int r, new_snapshot;
	struct pstore *ps;

	/* allocate the pstore */
	ps = kmalloc(sizeof(*ps), GFP_KERNEL);
	if (!ps)
		return -ENOMEM;

	ps->snap = store->snap;
	ps->valid = 1;
	ps->version = SNAPSHOT_DISK_VERSION;
	ps->chunk_size = chunk_size;
	ps->exceptions_per_area = (chunk_size << SECTOR_SHIFT) /
	    sizeof(struct disk_exception);
	ps->next_free = 2;	/* skipping the header and first area */
	ps->current_committed = 0;

	r = allocate_iobuf(ps);
	if (r)
		goto bad;

	/*
	 * Allocate space for all the callbacks.
	 */
	ps->callback_count = 0;
	atomic_set(&ps->pending_count, 0);
	ps->callbacks = vcalloc(ps->exceptions_per_area,
				sizeof(*ps->callbacks));

	if (!ps->callbacks)
		goto bad;

	/*
	 * Read the snapshot header.
	 */
	r = read_header(ps, &new_snapshot);
	if (r)
		goto bad;

	/*
	 * Do we need to setup a new snapshot ?
	 */
	if (new_snapshot) {
		r = write_header(ps);
		if (r) {
			DMWARN("write_header failed");
			goto bad;
		}

		r = zero_area(ps, 0);
		if (r) {
			DMWARN("zero_area(0) failed");
			goto bad;
		}

	} else {
		/*
		 * Sanity checks.
		 */
		if (!ps->valid) {
			DMWARN("snapshot is marked invalid");
			r = -EINVAL;
			goto bad;   
		}

		if (ps->chunk_size != chunk_size) {
			DMWARN("chunk size for existing snapshot different "
			       "from that requested");
			r = -EINVAL;
			goto bad;
		}

		if (ps->version != SNAPSHOT_DISK_VERSION) {
			DMWARN("unable to handle snapshot disk version %d",
			       ps->version);
			r = -EINVAL;
			goto bad;
		}

		/*
		 * Read the metadata.
		 */
		r = read_exceptions(ps);
		if (r)
			goto bad;
	}

	store->destroy = persistent_destroy;
	store->prepare_exception = persistent_prepare;
	store->commit_exception = persistent_commit;
	store->drop_snapshot = persistent_drop;
	store->percent_full = persistent_percentfull;
	store->context = ps;

	return r;

      bad:
	if (ps) {
		if (ps->callbacks)
			vfree(ps->callbacks);

		if (ps->iobuf)
			free_iobuf(ps);

		kfree(ps);
	}
	return r;
}

/*-----------------------------------------------------------------
 * Implementation of the store for non-persistent snapshots.
 *---------------------------------------------------------------*/
struct transient_c {
	sector_t next_free;
};

void transient_destroy(struct exception_store *store)
{
	kfree(store->context);
}

int transient_prepare(struct exception_store *store, struct exception *e)
{
	struct transient_c *tc = (struct transient_c *) store->context;
	sector_t size = get_dev_size(store->snap->cow->dev);

	if (size < (tc->next_free + store->snap->chunk_size))
		return -1;

	e->new_chunk = sector_to_chunk(store->snap, tc->next_free);
	tc->next_free += store->snap->chunk_size;

	return 0;
}

void transient_commit(struct exception_store *store,
		      struct exception *e,
		      void (*callback) (void *, int success),
		      void *callback_context)
{
	/* Just succeed */
	callback(callback_context, 1);
}

static int transient_percentfull(struct exception_store *store)
{
	struct transient_c *tc = (struct transient_c *) store->context;
	return (tc->next_free * 100) / get_dev_size(store->snap->cow->dev);
}

int dm_create_transient(struct exception_store *store,
			struct dm_snapshot *s, int blocksize)
{
	struct transient_c *tc;

	memset(store, 0, sizeof(*store));
	store->destroy = transient_destroy;
	store->prepare_exception = transient_prepare;
	store->commit_exception = transient_commit;
	store->percent_full = transient_percentfull;
	store->snap = s;

	tc = kmalloc(sizeof(struct transient_c), GFP_KERNEL);
	if (!tc)
		return -ENOMEM;

	tc->next_free = 0;
	store->context = tc;

	return 0;
}




/*
 * Copyright (C) 2001, 2002 Sistina Software (UK) Limited.
 *
 * This file is released under the GPL.
 */

#include "dm.h"

#include <linux/module.h>
#include <linux/vmalloc.h>
#include <linux/miscdevice.h>
#include <linux/dm-ioctl.h>
#include <linux/init.h>
#include <linux/wait.h>
#include <linux/blk.h>
#include <linux/slab.h>

#include <asm/uaccess.h>

#define DM_DRIVER_EMAIL "dm@uk.sistina.com"

/*-----------------------------------------------------------------
 * The ioctl interface needs to be able to look up devices by
 * name or uuid.
 *---------------------------------------------------------------*/
struct hash_cell {
	struct list_head name_list;
	struct list_head uuid_list;

	char *name;
	char *uuid;
	struct mapped_device *md;

	/* I hate devfs */
	devfs_handle_t devfs_entry;
};

#define NUM_BUCKETS 64
#define MASK_BUCKETS (NUM_BUCKETS - 1)
static struct list_head _name_buckets[NUM_BUCKETS];
static struct list_head _uuid_buckets[NUM_BUCKETS];

static devfs_handle_t _dev_dir;
void dm_hash_remove_all(void);

/*
 * Guards access to all three tables.
 */
static DECLARE_RWSEM(_hash_lock);

static void init_buckets(struct list_head *buckets)
{
	unsigned int i;

	for (i = 0; i < NUM_BUCKETS; i++)
		INIT_LIST_HEAD(buckets + i);
}

int dm_hash_init(void)
{
	init_buckets(_name_buckets);
	init_buckets(_uuid_buckets);
	_dev_dir = devfs_mk_dir(0, DM_DIR, NULL);
	return 0;
}

void dm_hash_exit(void)
{
	dm_hash_remove_all();
	devfs_unregister(_dev_dir);
}

/*-----------------------------------------------------------------
 * Hash function:
 * We're not really concerned with the str hash function being
 * fast since it's only used by the ioctl interface.
 *---------------------------------------------------------------*/
static unsigned int hash_str(const char *str)
{
	const unsigned int hash_mult = 2654435387U;
	unsigned int h = 0;

	while (*str)
		h = (h + (unsigned int) *str++) * hash_mult;

	return h & MASK_BUCKETS;
}

/*-----------------------------------------------------------------
 * Code for looking up a device by name
 *---------------------------------------------------------------*/
static struct hash_cell *__get_name_cell(const char *str)
{
	struct list_head *tmp;
	struct hash_cell *hc;
	unsigned int h = hash_str(str);

	list_for_each(tmp, _name_buckets + h) {
		hc = list_entry(tmp, struct hash_cell, name_list);
		if (!strcmp(hc->name, str))
			return hc;
	}

	return NULL;
}

static struct hash_cell *__get_uuid_cell(const char *str)
{
	struct list_head *tmp;
	struct hash_cell *hc;
	unsigned int h = hash_str(str);

	list_for_each(tmp, _uuid_buckets + h) {
		hc = list_entry(tmp, struct hash_cell, uuid_list);
		if (!strcmp(hc->uuid, str))
			return hc;
	}

	return NULL;
}

/*-----------------------------------------------------------------
 * Inserting, removing and renaming a device.
 *---------------------------------------------------------------*/
static inline char *kstrdup(const char *str)
{
	char *r = kmalloc(strlen(str) + 1, GFP_KERNEL);
	if (r)
		strcpy(r, str);
	return r;
}

static struct hash_cell *alloc_cell(const char *name, const char *uuid,
				    struct mapped_device *md)
{
	struct hash_cell *hc;

	hc = kmalloc(sizeof(*hc), GFP_KERNEL);
	if (!hc)
		return NULL;

	hc->name = kstrdup(name);
	if (!hc->name) {
		kfree(hc);
		return NULL;
	}

	if (!uuid)
		hc->uuid = NULL;

	else {
		hc->uuid = kstrdup(uuid);
		if (!hc->uuid) {
			kfree(hc->name);
			kfree(hc);
			return NULL;
		}
	}

	INIT_LIST_HEAD(&hc->name_list);
	INIT_LIST_HEAD(&hc->uuid_list);
	hc->md = md;
	return hc;
}

static void free_cell(struct hash_cell *hc)
{
	if (hc) {
		kfree(hc->name);
		kfree(hc->uuid);
		kfree(hc);
	}
}

/*
 * devfs stuff.
 */
static int register_with_devfs(struct hash_cell *hc)
{
	kdev_t dev = dm_kdev(hc->md);

	hc->devfs_entry =
	    devfs_register(_dev_dir, hc->name, DEVFS_FL_CURRENT_OWNER,
			   major(dev), minor(dev),
			   S_IFBLK | S_IRUSR | S_IWUSR | S_IRGRP,
			   &dm_blk_dops, NULL);

	return 0;
}

static int unregister_with_devfs(struct hash_cell *hc)
{
	devfs_unregister(hc->devfs_entry);
	return 0;
}

/*
 * The kdev_t and uuid of a device can never change once it is
 * initially inserted.
 */
int dm_hash_insert(const char *name, const char *uuid, struct mapped_device *md)
{
	struct hash_cell *cell;

	/*
	 * Allocate the new cells.
	 */
	cell = alloc_cell(name, uuid, md);
	if (!cell)
		return -ENOMEM;

	/*
	 * Insert the cell into all three hash tables.
	 */
	down_write(&_hash_lock);
	if (__get_name_cell(name))
		goto bad;

	list_add(&cell->name_list, _name_buckets + hash_str(name));

	if (uuid) {
		if (__get_uuid_cell(uuid)) {
			list_del(&cell->name_list);
			goto bad;
		}
		list_add(&cell->uuid_list, _uuid_buckets + hash_str(uuid));
	}
	register_with_devfs(cell);
	dm_get(md);
	up_write(&_hash_lock);

	return 0;

      bad:
	up_write(&_hash_lock);
	free_cell(cell);
	return -EBUSY;
}

void __hash_remove(struct hash_cell *hc)
{
	/* remove from the dev hash */
	list_del(&hc->uuid_list);
	list_del(&hc->name_list);
	unregister_with_devfs(hc);
	dm_put(hc->md);
}

void dm_hash_remove_all(void)
{
	int i;
	struct hash_cell *hc;
	struct list_head *tmp, *n;

	down_write(&_hash_lock);
	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);
			__hash_remove(hc);
		}
	}
	up_write(&_hash_lock);
}

int dm_hash_rename(const char *old, const char *new)
{
	char *new_name, *old_name;
	struct hash_cell *hc;

	/*
	 * duplicate new.
	 */
	new_name = kstrdup(new);
	if (!new_name)
		return -ENOMEM;

	down_write(&_hash_lock);

	/*
	 * Is new free ?
	 */
	hc = __get_name_cell(new);
	if (hc) {
		DMWARN("asked to rename to an already existing name %s -> %s",
		       old, new);
		up_write(&_hash_lock);
		return -EBUSY;
	}

	/*
	 * Is there such a device as 'old' ?
	 */
	hc = __get_name_cell(old);
	if (!hc) {
		DMWARN("asked to rename a non existent device %s -> %s",
		       old, new);
		up_write(&_hash_lock);
		return -ENXIO;
	}

	/*
	 * rename and move the name cell.
	 */
	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 */
	unregister_with_devfs(hc);
	register_with_devfs(hc);

	up_write(&_hash_lock);
	kfree(old_name);
	return 0;
}


/*-----------------------------------------------------------------
 * Implementation of the ioctl commands
 *---------------------------------------------------------------*/

/*
 * All the ioctl commands get dispatched to functions with this
 * prototype.
 */
typedef int (*ioctl_fn)(struct dm_ioctl *param, struct dm_ioctl *user);

/*
 * Check a string doesn't overrun the chunk of
 * memory we copied from userland.
 */
static int valid_str(char *str, void *begin, void *end)
{
	while (((void *) str >= begin) && ((void *) str < end))
		if (!*str++)
			return 0;

	return -EINVAL;
}

static int next_target(struct dm_target_spec *last, uint32_t next,
		       void *begin, void *end,
		       struct dm_target_spec **spec, char **params)
{
	*spec = (struct dm_target_spec *)
	    ((unsigned char *) last + next);
	*params = (char *) (*spec + 1);

	if (*spec < (last + 1) || ((void *) *spec > end))
		return -EINVAL;

	return valid_str(*params, begin, end);
}

static int populate_table(struct dm_table *table, struct dm_ioctl *args)
{
	int i = 0, r, first = 1;
	struct dm_target_spec *spec;
	char *params;
	void *begin, *end;

	if (!args->target_count) {
		DMWARN("populate_table: no targets specified");
		return -EINVAL;
	}

	begin = (void *) args;
	end = begin + args->data_size;

	for (i = 0; i < args->target_count; i++) {

		if (first)
			r = next_target((struct dm_target_spec *) args,
					args->data_start,
					begin, end, &spec, &params);
		else
			r = next_target(spec, spec->next, begin, end,
					&spec, &params);

		if (r) {
			DMWARN("unable to find target");
			return -EINVAL;
		}

		r = dm_table_add_target(table, spec->target_type,
					spec->sector_start, spec->length,
					params);
		if (r) {
			DMWARN("error adding target to table");
			return -EINVAL;
		}

		first = 0;
	}

	return dm_table_complete(table);
}

/*
 * Round up the ptr to the next 'align' boundary.  Obviously
 * 'align' must be a power of 2.
 */
static inline void *align_ptr(void *ptr, unsigned int align)
{
	align--;
	return (void *) (((unsigned long) (ptr + align)) & ~align);
}

/*
 * Copies a dm_ioctl and an optional additional payload to
 * userland.
 */
static int results_to_user(struct dm_ioctl *user, struct dm_ioctl *param,
			   void *data, uint32_t len)
{
	int r;
	void *ptr = NULL;

	if (data) {
		ptr = align_ptr(user + 1, sizeof(unsigned long));
		param->data_start = ptr - (void *) user;
	}

	/*
	 * The version number has already been filled in, so we
	 * just copy later fields.
	 */
	r = copy_to_user(&user->data_size, &param->data_size,
			 sizeof(*param) - sizeof(param->version));
	if (r)
		return -EFAULT;

	if (data) {
		if (param->data_start + len > param->data_size)
			return -ENOSPC;

		if (copy_to_user(ptr, data, len))
			r = -EFAULT;
	}

	return r;
}

/*
 * Fills in a dm_ioctl structure, ready for sending back to
 * userland.
 */
static int __info(struct mapped_device *md, struct dm_ioctl *param)
{
	kdev_t dev = dm_kdev(md);
	struct dm_table *table;
	struct block_device *bdev;

	param->flags = DM_EXISTS_FLAG;
	if (dm_suspended(md))
		param->flags |= DM_SUSPEND_FLAG;

	param->dev = kdev_t_to_nr(dev);
	bdev = bdget(param->dev);
	if (!bdev)
		return -ENXIO;

	param->open_count = bdev->bd_openers;
	bdput(bdev);

	if (is_read_only(dev))
		param->flags |= DM_READONLY_FLAG;

	table = dm_get_table(md);
	param->target_count = dm_table_get_num_targets(table);
	dm_table_put(table);

	return 0;
}

/*
 * Always use UUID for lookups if it's present, otherwise use name.
 */
static inline struct mapped_device *find_device(struct dm_ioctl *param)
{
	struct hash_cell *hc;
	struct mapped_device *md = NULL;

	down_read(&_hash_lock);
	hc = *param->uuid ? __get_uuid_cell(param->uuid) :
	    __get_name_cell(param->name);
	if (hc) {
		md = hc->md;

		/*
		 * Sneakily write in both the name and the uuid
		 * while we have the cell.
		 */
		strncpy(param->name, hc->name, sizeof(param->name));
		if (hc->uuid)
			strncpy(param->uuid, hc->uuid, sizeof(param->uuid) - 1);
		else
			param->uuid[0] = '\0';

		dm_get(md);
	}
	up_read(&_hash_lock);

	return md;
}

#define ALIGNMENT sizeof(int)
static void *_align(void *ptr, unsigned int a)
{
	register unsigned long align = --a;

	return (void *) (((unsigned long) ptr + align) & ~align);
}

/*
 * Copies device info back to user space, used by
 * the create and info ioctls.
 */
static int info(struct dm_ioctl *param, struct dm_ioctl *user)
{
	struct mapped_device *md;

	param->flags = 0;

	md = find_device(param);
	if (!md)
		/*
		 * Device not found - returns cleared exists flag.
		 */
		goto out;

	__info(md, param);
	dm_put(md);

      out:
	return results_to_user(user, param, NULL, 0);
}

static inline int get_mode(struct dm_ioctl *param)
{
	int mode = FMODE_READ | FMODE_WRITE;

	if (param->flags & DM_READONLY_FLAG)
		mode = FMODE_READ;

	return mode;
}

static int check_name(const char *name)
{
	if (strchr(name, '/')) {
		DMWARN("invalid device name");
		return -EINVAL;
	}

	return 0;
}

static int create(struct dm_ioctl *param, struct dm_ioctl *user)
{
	int r;
	kdev_t dev;
	struct dm_table *t;
	struct mapped_device *md;
	int minor;

	r = check_name(param->name);
	if (r)
		return r;

	r = dm_table_create(&t, get_mode(param));
	if (r)
		return r;

	r = populate_table(t, param);
	if (r) {
		dm_table_put(t);
		return r;
	}

	minor = (param->flags & DM_PERSISTENT_DEV_FLAG) ?
	    minor(to_kdev_t(param->dev)) : -1;

	r = dm_create(minor, t, &md);
	if (r) {
		dm_table_put(t);
		return r;
	}
	dm_table_put(t);	/* md will have grabbed its own reference */

	dev = dm_kdev(md);
	set_device_ro(dev, (param->flags & DM_READONLY_FLAG));
	r = dm_hash_insert(param->name, *param->uuid ? param->uuid : NULL, md);
	dm_put(md);

	return r ? r : info(param, user);
}

/*
 * Build up the status struct for each target
 */
static int __status(struct mapped_device *md, struct dm_ioctl *param,
		    char *outbuf, int *len)
{
	int i, num_targets;
	struct dm_target_spec *spec;
	char *outptr;
	status_type_t type;
	struct dm_table *table = dm_get_table(md);

	if (param->flags & DM_STATUS_TABLE_FLAG)
		type = STATUSTYPE_TABLE;
	else
		type = STATUSTYPE_INFO;

	outptr = outbuf;

	/* Get all the target info */
	num_targets = dm_table_get_num_targets(table);
	for (i = 0; i < num_targets; i++) {
		struct dm_target *ti = dm_table_get_target(table, i);

		if (outptr - outbuf +
		    sizeof(struct dm_target_spec) > param->data_size) {
			dm_table_put(table);
			return -ENOMEM;
		}

		spec = (struct dm_target_spec *) outptr;

		spec->status = 0;
		spec->sector_start = ti->begin;
		spec->length = ti->len;
		strncpy(spec->target_type, ti->type->name,
			sizeof(spec->target_type));

		outptr += sizeof(struct dm_target_spec);

		/* Get the status/table string from the target driver */
		if (ti->type->status)
			ti->type->status(ti, type, outptr,
					 outbuf + param->data_size - outptr);
		else
			outptr[0] = '\0';

		outptr += strlen(outptr) + 1;
		_align(outptr, ALIGNMENT);
		spec->next = outptr - outbuf;
	}

	param->target_count = num_targets;
	*len = outptr - outbuf;
	dm_table_put(table);

	return 0;
}

/*
 * Return the status of a device as a text string for each
 * target.
 */
static int get_status(struct dm_ioctl *param, struct dm_ioctl *user)
{
	struct mapped_device *md;
	int len = 0;
	int ret;
	char *outbuf = NULL;

	md = find_device(param);
	if (!md)
		/*
		 * Device not found - returns cleared exists flag.
		 */
		goto out;

	/* We haven't a clue how long the resultant data will be so
	   just allocate as much as userland has allowed us and make sure
	   we don't overun it */
	outbuf = kmalloc(param->data_size, GFP_KERNEL);
	if (!outbuf)
		goto out;
	/*
	 * Get the status of all targets
	 */
	__status(md, param, outbuf, &len);

	/*
	 * Setup the basic dm_ioctl structure.
	 */
	__info(md, param);

      out:
	if (md)
		dm_put(md);

	ret = results_to_user(user, param, outbuf, len);

	if (outbuf)
		kfree(outbuf);

	return ret;
}

/*
 * Wait for a device to report an event
 */
static int wait_device_event(struct dm_ioctl *param, struct dm_ioctl *user)
{
	struct mapped_device *md;
	struct dm_table *table;
	DECLARE_WAITQUEUE(wq, current);

	md = find_device(param);
	if (!md)
		/*
		 * Device not found - returns cleared exists flag.
		 */
		goto out;

	/*
	 * Setup the basic dm_ioctl structure.
	 */
	__info(md, param);

	/*
	 * Wait for a notification event
	 */
	set_current_state(TASK_INTERRUPTIBLE);
	table = dm_get_table(md);
	dm_table_add_wait_queue(table, &wq);
	dm_table_put(table);
	dm_put(md);

	yield();
	set_current_state(TASK_RUNNING);

      out:
	return results_to_user(user, param, NULL, 0);
}

/*
 * Retrieves a list of devices used by a particular dm device.
 */
static int dep(struct dm_ioctl *param, struct dm_ioctl *user)
{
	int count, r;
	struct mapped_device *md;
	struct list_head *tmp;
	size_t len = 0;
	struct dm_target_deps *deps = NULL;
	struct dm_table *table;

	md = find_device(param);
	if (!md)
		goto out;
	table = dm_get_table(md);

	/*
	 * Setup the basic dm_ioctl structure.
	 */
	__info(md, param);

	/*
	 * Count the devices.
	 */
	count = 0;
	list_for_each(tmp, dm_table_get_devices(table))
	    count++;

	/*
	 * Allocate a kernel space version of the dm_target_status
	 * struct.
	 */
	if (array_too_big(sizeof(*deps), sizeof(*deps->dev), count)) {
		dm_table_put(table);
		dm_put(md);
		return -ENOMEM;
	}

	len = sizeof(*deps) + (sizeof(*deps->dev) * count);
	deps = kmalloc(len, GFP_KERNEL);
	if (!deps) {
		dm_table_put(table);
		dm_put(md);
		return -ENOMEM;
	}

	/*
	 * Fill in the devices.
	 */
	deps->count = count;
	count = 0;
	list_for_each(tmp, dm_table_get_devices(table)) {
		struct dm_dev *dd = list_entry(tmp, struct dm_dev, list);
		deps->dev[count++] = dd->bdev->bd_dev;
	}
	dm_table_put(table);
	dm_put(md);

      out:
	r = results_to_user(user, param, deps, len);

	kfree(deps);
	return r;
}

static int remove(struct dm_ioctl *param, struct dm_ioctl *user)
{
	struct hash_cell *hc;

	down_write(&_hash_lock);
	hc = *param->uuid ? __get_uuid_cell(param->uuid) :
	    __get_name_cell(param->name);
	if (!hc) {
		DMWARN("device doesn't appear to be in the dev hash table.");
		up_write(&_hash_lock);
		return -EINVAL;
	}

	/*
	 * You may ask the interface to drop its reference to an
	 * in use device.  This is no different to unlinking a
	 * file that someone still has open.  The device will not
	 * actually be destroyed until the last opener closes it.
	 * The name and uuid of the device (both are interface
	 * properties) will be available for reuse immediately.
	 *
	 * You don't want to drop a _suspended_ device from the
	 * interface, since that will leave you with no way of
	 * resuming it.
	 */
	if (dm_suspended(hc->md)) {
		DMWARN("refusing to remove a suspended device.");
		up_write(&_hash_lock);
		return -EPERM;
	}

	__hash_remove(hc);
	up_write(&_hash_lock);
	return 0;
}

static int remove_all(struct dm_ioctl *param, struct dm_ioctl *user)
{
	dm_hash_remove_all();
	return 0;
}

static int suspend(struct dm_ioctl *param, struct dm_ioctl *user)
{
	int r;
	struct mapped_device *md;

	md = find_device(param);
	if (!md)
		return -ENXIO;

	if (param->flags & DM_SUSPEND_FLAG)
		r = dm_suspend(md);
	else
		r = dm_resume(md);

	dm_put(md);
	return r;
}

static int reload(struct dm_ioctl *param, struct dm_ioctl *user)
{
	int r;
	kdev_t dev;
	struct mapped_device *md;
	struct dm_table *t;

	r = dm_table_create(&t, get_mode(param));
	if (r)
		return r;

	r = populate_table(t, param);
	if (r) {
		dm_table_put(t);
		return r;
	}

	md = find_device(param);
	if (!md) {
		dm_table_put(t);
		return -ENXIO;
	}

	r = dm_swap_table(md, t);
	if (r) {
		dm_put(md);
		dm_table_put(t);
		return r;
	}
	dm_table_put(t);	/* md will have taken its own reference */

	dev = dm_kdev(md);
	set_device_ro(dev, (param->flags & DM_READONLY_FLAG));
	dm_put(md);

	r = info(param, user);
	return r;
}

static int rename(struct dm_ioctl *param, struct dm_ioctl *user)
{
	int r;
	char *new_name = (char *) param + param->data_start;

	if (valid_str(new_name, (void *) param,
		      (void *) param + param->data_size)) {
		DMWARN("Invalid new logical volume name supplied.");
		return -EINVAL;
	}

	r = check_name(new_name);
	if (r)
		return r;

	return dm_hash_rename(param->name, new_name);
}


/*-----------------------------------------------------------------
 * Implementation of open/close/ioctl on the special char
 * device.
 *---------------------------------------------------------------*/
static ioctl_fn lookup_ioctl(unsigned int cmd)
{
	static struct {
		int cmd;
		ioctl_fn fn;
	} _ioctls[] = {
		{DM_VERSION_CMD, NULL},	/* version is dealt with elsewhere */
		{DM_REMOVE_ALL_CMD, remove_all},
		{DM_DEV_CREATE_CMD, create},
		{DM_DEV_REMOVE_CMD, remove},
		{DM_DEV_RELOAD_CMD, reload},
		{DM_DEV_RENAME_CMD, rename},
		{DM_DEV_SUSPEND_CMD, suspend},
		{DM_DEV_DEPS_CMD, dep},
		{DM_DEV_STATUS_CMD, info},
		{DM_TARGET_STATUS_CMD, get_status},
		{DM_TARGET_WAIT_CMD, wait_device_event},
	};

	return (cmd >= ARRAY_SIZE(_ioctls)) ? NULL : _ioctls[cmd].fn;
}

/*
 * As well as checking the version compatibility this always
 * copies the kernel interface version out.
 */
static int check_version(int cmd, struct dm_ioctl *user)
{
	uint32_t version[3];
	int r = 0;

	if (copy_from_user(version, user->version, sizeof(version)))
		return -EFAULT;

	if ((DM_VERSION_MAJOR != version[0]) ||
	    (DM_VERSION_MINOR < version[1])) {
		DMWARN("ioctl interface mismatch: "
		       "kernel(%u.%u.%u), user(%u.%u.%u), cmd(%d)",
		       DM_VERSION_MAJOR, DM_VERSION_MINOR,
		       DM_VERSION_PATCHLEVEL,
		       version[0], version[1], version[2], cmd);
		r = -EINVAL;
	}

	/*
	 * Fill in the kernel version.
	 */
	version[0] = DM_VERSION_MAJOR;
	version[1] = DM_VERSION_MINOR;
	version[2] = DM_VERSION_PATCHLEVEL;
	if (copy_to_user(user->version, version, sizeof(version)))
		return -EFAULT;

	return r;
}

static void free_params(struct dm_ioctl *param)
{
	vfree(param);
}

static int copy_params(struct dm_ioctl *user, struct dm_ioctl **param)
{
	struct dm_ioctl tmp, *dmi;

	if (copy_from_user(&tmp, user, sizeof(tmp)))
		return -EFAULT;

	if (tmp.data_size < sizeof(tmp))
		return -EINVAL;

	dmi = (struct dm_ioctl *) vmalloc(tmp.data_size);
	if (!dmi)
		return -ENOMEM;

	if (copy_from_user(dmi, user, tmp.data_size)) {
		vfree(dmi);
		return -EFAULT;
	}

	*param = dmi;
	return 0;
}

static int validate_params(uint cmd, struct dm_ioctl *param)
{
	/* Ignores parameters */
	if (cmd == DM_REMOVE_ALL_CMD)
		return 0;

	/* Unless creating, either name of uuid but not both */
	if (cmd != DM_DEV_CREATE_CMD) {
		if ((!*param->uuid && !*param->name) ||
		    (*param->uuid && *param->name)) {
			DMWARN("one of name or uuid must be supplied");
			return -EINVAL;
		}
	}

	/* Ensure strings are terminated */
	param->name[DM_NAME_LEN - 1] = '\0';
	param->uuid[DM_UUID_LEN - 1] = '\0';

	return 0;
}

static int ctl_ioctl(struct inode *inode, struct file *file,
		     uint command, ulong u)
{
	int r = 0, cmd;
	struct dm_ioctl *param;
	struct dm_ioctl *user = (struct dm_ioctl *) u;
	ioctl_fn fn = NULL;

	/* only root can play with this */
	if (!capable(CAP_SYS_ADMIN))
		return -EACCES;

	if (_IOC_TYPE(command) != DM_IOCTL)
		return -ENOTTY;

	cmd = _IOC_NR(command);

	/*
	 * Check the interface version passed in.  This also
	 * writes out the kernel's interface version.
	 */
	r = check_version(cmd, user);
	if (r)
		return r;

	/*
	 * Nothing more to do for the version command.
	 */
	if (cmd == DM_VERSION_CMD)
		return 0;

	fn = lookup_ioctl(cmd);
	if (!fn) {
		DMWARN("dm_ctl_ioctl: unknown command 0x%x", command);
		return -ENOTTY;
	}

	/*
	 * Copy the parameters into kernel space.
	 */
	r = copy_params(user, &param);
	if (r)
		return r;

	r = validate_params(cmd, param);
	if (r) {
		free_params(param);
		return r;
	}

	r = fn(param, user);
	free_params(param);
	return r;
}

static struct file_operations _ctl_fops = {
	.ioctl	 = ctl_ioctl,
	.owner	 = THIS_MODULE,
};

static devfs_handle_t _ctl_handle;

static struct miscdevice _dm_misc = {
	.minor = MISC_DYNAMIC_MINOR,
	.name  = DM_NAME,
	.fops  = &_ctl_fops
};

/*
 * Create misc character device and link to DM_DIR/control.
 */
int __init dm_interface_init(void)
{
	int r;
	char rname[64];

	r = dm_hash_init();
	if (r)
		return r;

	r = misc_register(&_dm_misc);
	if (r) {
		DMERR("misc_register failed for control device");
		dm_hash_exit();
		return r;
	}

	r = devfs_generate_path(_dm_misc.devfs_handle, rname + 3,
				sizeof rname - 3);
	if (r == -ENOSYS)
		goto done;	/* devfs not present */

	if (r < 0) {
		DMERR("devfs_generate_path failed for control device");
		goto failed;
	}

	strncpy(rname + r, "../", 3);
	r = devfs_mk_symlink(NULL, DM_DIR "/control",
			     DEVFS_FL_DEFAULT, rname + r, &_ctl_handle, NULL);
	if (r) {
		DMERR("devfs_mk_symlink failed for control device");
		goto failed;
	}
	devfs_auto_unregister(_dm_misc.devfs_handle, _ctl_handle);

      done:
	DMINFO("%d.%d.%d%s initialised: %s", DM_VERSION_MAJOR,
	       DM_VERSION_MINOR, DM_VERSION_PATCHLEVEL, DM_VERSION_EXTRA,
	       DM_DRIVER_EMAIL);
	return 0;

      failed:
	misc_deregister(&_dm_misc);
	dm_hash_exit();
	return r;
}

void dm_interface_exit(void)
{
	if (misc_deregister(&_dm_misc) < 0)
		DMERR("misc_deregister failed for control device");

	dm_hash_exit();
}




/*
 * Copyright (C) 2001 Sistina Software (UK) Limited.
 *
 * This file is released under the GPL.
 */

#include "dm.h"

#include <linux/module.h>
#include <linux/init.h>
#include <linux/blkdev.h>
#include <linux/slab.h>

/*
 * Linear: maps a linear range of a device.
 */
struct linear_c {
	struct dm_dev *dev;
	sector_t start;
};

/*
 * Construct a linear mapping: <dev_path> <offset>
 */
static int linear_ctr(struct dm_target *ti, int argc, char **argv)
{
	struct linear_c *lc;

	if (argc != 2) {
		ti->error = "dm-linear: Not enough arguments";
		return -EINVAL;
	}

	lc = kmalloc(sizeof(*lc), GFP_KERNEL);
	if (lc == NULL) {
		ti->error = "dm-linear: Cannot allocate linear context";
		return -ENOMEM;
	}

	if (sscanf(argv[1], SECTOR_FORMAT, &lc->start) != 1) {
		ti->error = "dm-linear: Invalid device sector";
		goto bad;
	}

	if (dm_get_device(ti, argv[0], lc->start, ti->len,
			  dm_table_get_mode(ti->table), &lc->dev)) {
		ti->error = "dm-linear: Device lookup failed";
		goto bad;
	}

	ti->private = lc;
	return 0;

      bad:
	kfree(lc);
	return -EINVAL;
}

static void linear_dtr(struct dm_target *ti)
{
	struct linear_c *lc = (struct linear_c *) ti->private;

	dm_put_device(ti, lc->dev);
	kfree(lc);
}

static int linear_map(struct dm_target *ti, struct buffer_head *bh, int rw,
		      void **map_context)
{
	struct linear_c *lc = (struct linear_c *) ti->private;

	bh->b_rdev = lc->dev->dev;
	bh->b_rsector = lc->start + (bh->b_rsector - ti->begin);

	return 1;
}

static int linear_status(struct dm_target *ti, status_type_t type,
			 char *result, int maxlen)
{
	struct linear_c *lc = (struct linear_c *) ti->private;

	switch (type) {
	case STATUSTYPE_INFO:
		result[0] = '\0';
		break;

	case STATUSTYPE_TABLE:
		snprintf(result, maxlen, "%s " SECTOR_FORMAT,
			 kdevname(to_kdev_t(lc->dev->bdev->bd_dev)), lc->start);
		break;
	}
	return 0;
}

static struct target_type linear_target = {
	.name   = "linear",
	.module = THIS_MODULE,
	.ctr    = linear_ctr,
	.dtr    = linear_dtr,
	.map    = linear_map,
	.status = linear_status,
};

int __init dm_linear_init(void)
{
	int r = dm_register_target(&linear_target);

	if (r < 0)
		DMERR("linear: register failed %d", r);

	return r;
}

void dm_linear_exit(void)
{
	int r = dm_unregister_target(&linear_target);

	if (r < 0)
		DMERR("linear: unregister failed %d", r);
}




/*
 * dm-snapshot.c
 *
 * Copyright (C) 2001-2002 Sistina Software (UK) Limited.
 *
 * This file is released under the GPL.
 */

#include <linux/config.h>
#include <linux/ctype.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/list.h>
#include <linux/fs.h>
#include <linux/blkdev.h>
#include <linux/mempool.h>
#include <linux/device-mapper.h>
#include <linux/vmalloc.h>

#include "dm-snapshot.h"
#include "kcopyd.h"

/*
 * FIXME: Remove this before release.
 */
#if 0
#define DMDEBUG(x...) DMWARN( ## x)
#else
#define DMDEBUG(x...)
#endif

/*
 * The percentage increment we will wake up users at
 */
#define WAKE_UP_PERCENT 5

/*
 * kcopyd priority of snapshot operations
 */
#define SNAPSHOT_COPY_PRIORITY 2

struct pending_exception {
	struct exception e;

	/*
	 * Origin buffers waiting for this to complete are held
	 * in a list (using b_reqnext).
	 */
	struct buffer_head *origin_bhs;
	struct buffer_head *snapshot_bhs;

	/*
	 * Other pending_exceptions that are processing this
	 * chunk.  When this list is empty, we know we can
	 * complete the origins.
	 */
	struct list_head siblings;

	/* Pointer back to snapshot context */
	struct dm_snapshot *snap;

	/*
	 * 1 indicates the exception has already been sent to
	 * kcopyd.
	 */
	int started;
};

/*
 * Hash table mapping origin volumes to lists of snapshots and
 * a lock to protect it
 */
static kmem_cache_t *exception_cache;
static kmem_cache_t *pending_cache;
static mempool_t *pending_pool;

/*
 * One of these per registered origin, held in the snapshot_origins hash
 */
struct origin {
	/* The origin device */
	kdev_t dev;

	struct list_head hash_list;

	/* List of snapshots for this origin */
	struct list_head snapshots;
};

/*
 * Size of the hash table for origin volumes. If we make this
 * the size of the minors list then it should be nearly perfect
 */
#define ORIGIN_HASH_SIZE 256
#define ORIGIN_MASK      0xFF
static struct list_head *_origins;
static struct rw_semaphore _origins_lock;

static int init_origin_hash(void)
{
	int i;

	_origins = kmalloc(ORIGIN_HASH_SIZE * sizeof(struct list_head),
			   GFP_KERNEL);
	if (!_origins) {
		DMERR("Device mapper: Snapshot: unable to allocate memory");
		return -ENOMEM;
	}

	for (i = 0; i < ORIGIN_HASH_SIZE; i++)
		INIT_LIST_HEAD(_origins + i);
	init_rwsem(&_origins_lock);

	return 0;
}

static void exit_origin_hash(void)
{
	kfree(_origins);
}

static inline unsigned int origin_hash(kdev_t dev)
{
	return MINOR(dev) & ORIGIN_MASK;
}

static struct origin *__lookup_origin(kdev_t origin)
{
	struct list_head *slist;
	struct list_head *ol;
	struct origin *o;

	ol = &_origins[origin_hash(origin)];
	list_for_each(slist, ol) {
		o = list_entry(slist, struct origin, hash_list);

		if (o->dev == origin)
			return o;
	}

	return NULL;
}

static void __insert_origin(struct origin *o)
{
	struct list_head *sl = &_origins[origin_hash(o->dev)];
	list_add_tail(&o->hash_list, sl);
}

/*
 * Make a note of the snapshot and its origin so we can look it
 * up when the origin has a write on it.
 */
static int register_snapshot(struct dm_snapshot *snap)
{
	struct origin *o;
	kdev_t dev = snap->origin->dev;

	down_write(&_origins_lock);
	o = __lookup_origin(dev);

	if (!o) {
		/* New origin */
		o = kmalloc(sizeof(*o), GFP_KERNEL);
		if (!o) {
			up_write(&_origins_lock);
			return -ENOMEM;
		}

		/* Initialise the struct */
		INIT_LIST_HEAD(&o->snapshots);
		o->dev = dev;

		__insert_origin(o);
	}

	list_add_tail(&snap->list, &o->snapshots);

	up_write(&_origins_lock);
	return 0;
}

static void unregister_snapshot(struct dm_snapshot *s)
{
	struct origin *o;

	down_write(&_origins_lock);
	o = __lookup_origin(s->origin->dev);

	list_del(&s->list);
	if (list_empty(&o->snapshots)) {
		list_del(&o->hash_list);
		kfree(o);
	}

	up_write(&_origins_lock);
}

/*
 * Implementation of the exception hash tables.
 */
static int init_exception_table(struct exception_table *et, uint32_t size)
{
	int i;

	et->hash_mask = size - 1;
	et->table = vcalloc(size, sizeof(struct list_head));
	if (!et->table)
		return -ENOMEM;

	for (i = 0; i < size; i++)
		INIT_LIST_HEAD(et->table + i);

	return 0;
}

static void exit_exception_table(struct exception_table *et, kmem_cache_t *mem)
{
	struct list_head *slot, *entry, *temp;
	struct exception *ex;
	int i, size;

	size = et->hash_mask + 1;
	for (i = 0; i < size; i++) {
		slot = et->table + i;

		list_for_each_safe(entry, temp, slot) {
			ex = list_entry(entry, struct exception, hash_list);
			kmem_cache_free(mem, ex);
		}
	}

	vfree(et->table);
}

/*
 * FIXME: check how this hash fn is performing.
 */
static inline uint32_t exception_hash(struct exception_table *et, chunk_t chunk)
{
	return chunk & et->hash_mask;
}

static void insert_exception(struct exception_table *eh, struct exception *e)
{
	struct list_head *l = &eh->table[exception_hash(eh, e->old_chunk)];
	list_add(&e->hash_list, l);
}

static inline void remove_exception(struct exception *e)
{
	list_del(&e->hash_list);
}

/*
 * Return the exception data for a sector, or NULL if not
 * remapped.
 */
static struct exception *lookup_exception(struct exception_table *et,
					  chunk_t chunk)
{
	struct list_head *slot, *el;
	struct exception *e;

	slot = &et->table[exception_hash(et, chunk)];
	list_for_each(el, slot) {
		e = list_entry(el, struct exception, hash_list);
		if (e->old_chunk == chunk)
			return e;
	}

	return NULL;
}

static inline struct exception *alloc_exception(void)
{
	struct exception *e;

	e = kmem_cache_alloc(exception_cache, GFP_NOIO);
	if (!e)
		e = kmem_cache_alloc(exception_cache, GFP_ATOMIC);

	return e;
}

static inline void free_exception(struct exception *e)
{
	kmem_cache_free(exception_cache, e);
}

static inline struct pending_exception *alloc_pending_exception(void)
{
	return mempool_alloc(pending_pool, GFP_NOIO);
}

static inline void free_pending_exception(struct pending_exception *pe)
{
	mempool_free(pe, pending_pool);
}

int dm_add_exception(struct dm_snapshot *s, chunk_t old, chunk_t new)
{
	struct exception *e;

	e = alloc_exception();
	if (!e)
		return -ENOMEM;

	e->old_chunk = old;
	e->new_chunk = new;
	insert_exception(&s->complete, e);
	return 0;
}

/*
 * Hard coded magic.
 */
static int calc_max_buckets(void)
{
	unsigned long mem;

	mem = num_physpages << PAGE_SHIFT;
	mem /= 50;
	mem /= sizeof(struct list_head);

	return mem;
}

/*
 * Rounds a number down to a power of 2.
 */
static inline uint32_t round_down(uint32_t n)
{
	while (n & (n - 1))
		n &= (n - 1);
	return n;
}

/*
 * Allocate room for a suitable hash table.
 */
static int init_hash_tables(struct dm_snapshot *s)
{
	sector_t hash_size, cow_dev_size, origin_dev_size, max_buckets;

	/*
	 * Calculate based on the size of the original volume or
	 * the COW volume...
	 */
	cow_dev_size = get_dev_size(s->cow->dev);
	origin_dev_size = get_dev_size(s->origin->dev);
	max_buckets = calc_max_buckets();

	hash_size = min(origin_dev_size, cow_dev_size) / s->chunk_size;
	hash_size = min(hash_size, max_buckets);

	/* Round it down to a power of 2 */
	hash_size = round_down(hash_size);
	if (init_exception_table(&s->complete, hash_size))
		return -ENOMEM;

	/*
	 * Allocate hash table for in-flight exceptions
	 * Make this smaller than the real hash table
	 */
	hash_size >>= 3;
	if (!hash_size)
		hash_size = 64;

	if (init_exception_table(&s->pending, hash_size)) {
		exit_exception_table(&s->complete, exception_cache);
		return -ENOMEM;
	}

	return 0;
}

/*
 * Round a number up to the nearest 'size' boundary.  size must
 * be a power of 2.
 */
static inline ulong round_up(ulong n, ulong size)
{
	size--;
	return (n + size) & ~size;
}

/*
 * Construct a snapshot mapping: <origin_dev> <COW-dev> <p/n> <chunk-size>
 */
static int snapshot_ctr(struct dm_target *ti, int argc, char **argv)
{
	struct dm_snapshot *s;
	unsigned long chunk_size;
	int r = -EINVAL;
	char persistent;
	char *origin_path;
	char *cow_path;
	char *value;
	int blocksize;

	if (argc < 4) {
		ti->error = "dm-snapshot: requires exactly 4 arguments";
		r = -EINVAL;
		goto bad;
	}

	origin_path = argv[0];
	cow_path = argv[1];
	persistent = toupper(*argv[2]);

	if (persistent != 'P' && persistent != 'N') {
		ti->error = "Persistent flag is not P or N";
		r = -EINVAL;
		goto bad;
	}

	chunk_size = simple_strtoul(argv[3], &value, 10);
	if (chunk_size == 0 || value == NULL) {
		ti->error = "Invalid chunk size";
		r = -EINVAL;
		goto bad;
	}

	s = kmalloc(sizeof(*s), GFP_KERNEL);
	if (s == NULL) {
		ti->error = "Cannot allocate snapshot context private "
		    "structure";
		r = -ENOMEM;
		goto bad;
	}

	r = dm_get_device(ti, origin_path, 0, ti->len, FMODE_READ, &s->origin);
	if (r) {
		ti->error = "Cannot get origin device";
		goto bad_free;
	}

	/* FIXME: get cow length */
	r = dm_get_device(ti, cow_path, 0, 0,
			  FMODE_READ | FMODE_WRITE, &s->cow);
	if (r) {
		dm_put_device(ti, s->origin);
		ti->error = "Cannot get COW device";
		goto bad_free;
	}

	/*
	 * Chunk size must be multiple of page size.  Silently
	 * round up if it's not.
	 */
	chunk_size = round_up(chunk_size, PAGE_SIZE / SECTOR_SIZE);

	/* Validate the chunk size against the device block size */
	blocksize = get_hardsect_size(s->cow->dev);
	if (chunk_size % (blocksize / SECTOR_SIZE)) {
		ti->error = "Chunk size is not a multiple of device blocksize";
		r = -EINVAL;
		goto bad_putdev;
	}

	/* Check the sizes are small enough to fit in one kiovec */
	if (chunk_size > KIO_MAX_SECTORS) {
		ti->error = "Chunk size is too big";
		r = -EINVAL;
		goto bad_putdev;
	}

	/* Check chunk_size is a power of 2 */
	if (chunk_size & (chunk_size - 1)) {
		ti->error = "Chunk size is not a power of 2";
		r = -EINVAL;
		goto bad_putdev;
	}

	s->chunk_size = chunk_size;
	s->chunk_mask = chunk_size - 1;
	s->type = persistent;
	for (s->chunk_shift = 0; chunk_size;
	     s->chunk_shift++, chunk_size >>= 1)
		;
	s->chunk_shift--;

	s->valid = 1;
	s->last_percent = 0;
	init_rwsem(&s->lock);
	s->table = ti->table;

	/* Allocate hash table for COW data */
	if (init_hash_tables(s)) {
		ti->error = "Unable to allocate hash table space";
		r = -ENOMEM;
		goto bad_putdev;
	}

	/*
	 * Check the persistent flag - done here because we need the iobuf
	 * to check the LV header
	 */
	s->store.snap = s;

	if (persistent == 'P')
		r = dm_create_persistent(&s->store, s->chunk_size);
	else
		r = dm_create_transient(&s->store, s, blocksize);

	if (r) {
		ti->error = "Couldn't create exception store";
		r = -EINVAL;
		goto bad_free1;
	}

	/* Flush IO to the origin device */
#if LVM_VFS_ENHANCEMENT
	fsync_dev_lockfs(s->origin->dev);
#else
	fsync_dev(s->origin->dev);
#endif

	/* Add snapshot to the list of snapshots for this origin */
	if (register_snapshot(s)) {
		r = -EINVAL;
		ti->error = "Cannot register snapshot origin";
		goto bad_free2;
	}
#if LVM_VFS_ENHANCEMENT
	unlockfs(s->origin->dev);
#endif
	kcopyd_inc_client_count();

	ti->private = s;
	return 0;

      bad_free2:
#if LVM_VFS_ENHANCEMENT
	unlockfs(s->origin->dev);
#endif
	s->store.destroy(&s->store);

      bad_free1:
	exit_exception_table(&s->pending, pending_cache);
	exit_exception_table(&s->complete, exception_cache);

      bad_putdev:
	dm_put_device(ti, s->cow);
	dm_put_device(ti, s->origin);

      bad_free:
	kfree(s);

      bad:
	return r;
}

static void snapshot_dtr(struct dm_target *ti)
{
	struct dm_snapshot *s = (struct dm_snapshot *) ti->private;

	dm_table_event(ti->table);

	unregister_snapshot(s);

	exit_exception_table(&s->pending, pending_cache);
	exit_exception_table(&s->complete, exception_cache);

	/* Deallocate memory used */
	s->store.destroy(&s->store);

	dm_put_device(ti, s->origin);
	dm_put_device(ti, s->cow);
	kfree(s);

	kcopyd_dec_client_count();
}

/*
 * We hold lists of buffer_heads, using the b_reqnext field.
 */
static void queue_buffer(struct buffer_head **queue, struct buffer_head *bh)
{
	bh->b_reqnext = *queue;
	*queue = bh;
}

/*
 * Flush a list of buffers.
 */
static void flush_buffers(struct buffer_head *bh)
{
	struct buffer_head *n;

	DMDEBUG("begin flush");
	while (bh) {
		n = bh->b_reqnext;
		bh->b_reqnext = NULL;
		DMDEBUG("flushing %p", bh);
		generic_make_request(WRITE, bh);
		bh = n;
	}

	run_task_queue(&tq_disk);
}

/*
 * Error a list of buffers.
 */
static void error_buffers(struct buffer_head *bh)
{
	struct buffer_head *n;

	while (bh) {
		n = bh->b_reqnext;
		bh->b_reqnext = NULL;
		buffer_IO_error(bh);
		bh = n;
	}
}

static void pending_complete(struct pending_exception *pe, int success)
{
	struct exception *e;
	struct dm_snapshot *s = pe->snap;

	if (success) {
		e = alloc_exception();
		if (!e) {
			printk("Unable to allocate exception.");
			down_write(&s->lock);
			s->store.drop_snapshot(&s->store);
			s->valid = 0;
			up_write(&s->lock);
			return;
		}

		/*
		 * Add a proper exception, and remove the
		 * inflight exception from the list.
		 */
		down_write(&s->lock);

		memcpy(e, &pe->e, sizeof(*e));
		insert_exception(&s->complete, e);
		remove_exception(&pe->e);

		/* Submit any pending write BHs */
		up_write(&s->lock);

		flush_buffers(pe->snapshot_bhs);
		DMDEBUG("Exception completed successfully.");

		/* Notify any interested parties */
		if (s->store.percent_full) {
			int pc = s->store.percent_full(&s->store);

			if (pc >= s->last_percent + WAKE_UP_PERCENT) {
				dm_table_event(s->table);
				s->last_percent = pc - pc % WAKE_UP_PERCENT;
			}
		}

	} else {
		/* Read/write error - snapshot is unusable */
		DMERR("Error reading/writing snapshot");

		down_write(&s->lock);
		s->store.drop_snapshot(&s->store);
		s->valid = 0;
		remove_exception(&pe->e);
		up_write(&s->lock);

		error_buffers(pe->snapshot_bhs);

		dm_table_event(s->table);
		DMDEBUG("Exception failed.");
	}

	if (list_empty(&pe->siblings))
		flush_buffers(pe->origin_bhs);
	else
		list_del(&pe->siblings);

	free_pending_exception(pe);
}

static void commit_callback(void *context, int success)
{
	struct pending_exception *pe = (struct pending_exception *) context;
	pending_complete(pe, success);
}

/*
 * Called when the copy I/O has finished.  kcopyd actually runs
 * this code so don't block.
 */
static void copy_callback(int err, void *context)
{
	struct pending_exception *pe = (struct pending_exception *) context;
	struct dm_snapshot *s = pe->snap;

	if (err)
		pending_complete(pe, 0);

	else
		/* Update the metadata if we are persistent */
		s->store.commit_exception(&s->store, &pe->e, commit_callback,
					  pe);
}

/*
 * Dispatches the copy operation to kcopyd.
 */
static inline void start_copy(struct pending_exception *pe)
{
	struct dm_snapshot *s = pe->snap;
	struct kcopyd_region src, dest;

	src.dev = s->origin->dev;
	src.sector = chunk_to_sector(s, pe->e.old_chunk);
	src.count = s->chunk_size;

	dest.dev = s->cow->dev;
	dest.sector = chunk_to_sector(s, pe->e.new_chunk);
	dest.count = s->chunk_size;

	if (!pe->started) {
		/* Hand over to kcopyd */
		kcopyd_copy(&src, &dest, copy_callback, pe);
		pe->started = 1;
	}
}

/*
 * Looks to see if this snapshot already has a pending exception
 * for this chunk, otherwise it allocates a new one and inserts
 * it into the pending table.
 */
static struct pending_exception *find_pending_exception(struct dm_snapshot *s,
							struct buffer_head *bh)
{
	struct exception *e;
	struct pending_exception *pe;
	chunk_t chunk = sector_to_chunk(s, bh->b_rsector);

	/*
	 * Is there a pending exception for this already ?
	 */
	e = lookup_exception(&s->pending, chunk);
	if (e) {
		/* cast the exception to a pending exception */
		pe = list_entry(e, struct pending_exception, e);

	} else {
		/* Create a new pending exception */
		pe = alloc_pending_exception();
		if (!pe) {
			DMWARN("Couldn't allocate pending exception.");
			return NULL;
		}

		pe->e.old_chunk = chunk;
		pe->origin_bhs = pe->snapshot_bhs = NULL;
		INIT_LIST_HEAD(&pe->siblings);
		pe->snap = s;
		pe->started = 0;

		if (s->store.prepare_exception(&s->store, &pe->e)) {
			free_pending_exception(pe);
			s->valid = 0;
			return NULL;
		}

		insert_exception(&s->pending, &pe->e);
	}

	return pe;
}

static inline void remap_exception(struct dm_snapshot *s, struct exception *e,
				   struct buffer_head *bh)
{
	bh->b_rdev = s->cow->dev;
	bh->b_rsector = chunk_to_sector(s, e->new_chunk) +
	    (bh->b_rsector & s->chunk_mask);
}

static int snapshot_map(struct dm_target *ti, struct buffer_head *bh, int rw,
			void **map_context)
{
	struct exception *e;
	struct dm_snapshot *s = (struct dm_snapshot *) ti->private;
	int r = 1;
	chunk_t chunk;
	struct pending_exception *pe;

	chunk = sector_to_chunk(s, bh->b_rsector);

	/* Full snapshots are not usable */
	if (!s->valid)
		return -1;

	/*
	 * Write to snapshot - higher level takes care of RW/RO
	 * flags so we should only get this if we are
	 * writeable.
	 */
	if (rw == WRITE) {

		down_write(&s->lock);

		/* If the block is already remapped - use that, else remap it */
		e = lookup_exception(&s->complete, chunk);
		if (e)
			remap_exception(s, e, bh);

		else {
			pe = find_pending_exception(s, bh);

			if (!pe) {
				s->store.drop_snapshot(&s->store);
				s->valid = 0;
			}

			queue_buffer(&pe->snapshot_bhs, bh);
			start_copy(pe);
			r = 0;
		}

		up_write(&s->lock);

	} else {
		/*
		 * FIXME: this read path scares me because we
		 * always use the origin when we have a pending
		 * exception.  However I can't think of a
		 * situation where this is wrong - ejt.
		 */

		/* Do reads */
		down_read(&s->lock);

		/* See if it it has been remapped */
		e = lookup_exception(&s->complete, chunk);
		if (e)
			remap_exception(s, e, bh);
		else
			bh->b_rdev = s->origin->dev;

		up_read(&s->lock);
	}

	return r;
}

static void list_merge(struct list_head *l1, struct list_head *l2)
{
	struct list_head *l1_n, *l2_p;

	l1_n = l1->next;
	l2_p = l2->prev;

	l1->next = l2;
	l2->prev = l1;

	l2_p->next = l1_n;
	l1_n->prev = l2_p;
}

static int __origin_write(struct list_head *snapshots, struct buffer_head *bh)
{
	int r = 1;
	struct list_head *sl;
	struct dm_snapshot *snap;
	struct exception *e;
	struct pending_exception *pe, *last = NULL;
	chunk_t chunk;

	/* Do all the snapshots on this origin */
	list_for_each(sl, snapshots) {
		snap = list_entry(sl, struct dm_snapshot, list);

		/* Only deal with valid snapshots */
		if (!snap->valid)
			continue;

		down_write(&snap->lock);

		/*
		 * Remember, different snapshots can have
		 * different chunk sizes.
		 */
		chunk = sector_to_chunk(snap, bh->b_rsector);

		/*
		 * Check exception table to see if block
		 * is already remapped in this snapshot
		 * and trigger an exception if not.
		 */
		e = lookup_exception(&snap->complete, chunk);
		if (!e) {
			pe = find_pending_exception(snap, bh);
			if (!pe) {
				snap->store.drop_snapshot(&snap->store);
				snap->valid = 0;

			} else {
				if (last)
					list_merge(&pe->siblings,
						   &last->siblings);

				last = pe;
				r = 0;
			}
		}

		up_write(&snap->lock);
	}

	/*
	 * Now that we have a complete pe list we can start the copying.
	 */
	if (last) {
		pe = last;
		do {
			down_write(&pe->snap->lock);
			queue_buffer(&pe->origin_bhs, bh);
			start_copy(pe);
			up_write(&pe->snap->lock);
			pe = list_entry(pe->siblings.next,
					struct pending_exception, siblings);

		} while (pe != last);
	}

	return r;
}

static int snapshot_status(struct dm_target *ti, status_type_t type,
			   char *result, int maxlen)
{
	struct dm_snapshot *snap = (struct dm_snapshot *) ti->private;
	char cow[16];
	char org[16];

	switch (type) {
	case STATUSTYPE_INFO:
		if (!snap->valid)
			snprintf(result, maxlen, "Invalid");
		else {
			if (snap->store.percent_full)
				snprintf(result, maxlen, "%d%%",
					 snap->store.percent_full(&snap->
								  store));
			else
				snprintf(result, maxlen, "Unknown");
		}
		break;

	case STATUSTYPE_TABLE:
		/*
		 * kdevname returns a static pointer so we need
		 * to make private copies if the output is to
		 * make sense.
		 */
		strncpy(cow, kdevname(snap->cow->dev), sizeof(cow));
		strncpy(org, kdevname(snap->origin->dev), sizeof(org));
		snprintf(result, maxlen, "%s %s %c %ld", org, cow,
			 snap->type, snap->chunk_size);
		break;
	}

	return 0;
}

/*
 * Called on a write from the origin driver.
 */
int do_origin(struct dm_dev *origin, struct buffer_head *bh)
{
	struct origin *o;
	int r;

	down_read(&_origins_lock);
	o = __lookup_origin(origin->dev);
	if (!o)
		BUG();

	r = __origin_write(&o->snapshots, bh);
	up_read(&_origins_lock);

	return r;
}

/*
 * Origin: maps a linear range of a device, with hooks for snapshotting.
 */

/*
 * Construct an origin mapping: <dev_path>
 * The context for an origin is merely a 'struct dm_dev *'
 * pointing to the real device.
 */
static int origin_ctr(struct dm_target *ti, int argc, char **argv)
{
	int r;
	struct dm_dev *dev;

	if (argc != 1) {
		ti->error = "dm-origin: incorrect number of arguments";
		return -EINVAL;
	}

	r = dm_get_device(ti, argv[0], 0, ti->len,
			  dm_table_get_mode(ti->table), &dev);
	if (r) {
		ti->error = "Cannot get target device";
		return r;
	}

	ti->private = dev;

	return 0;
}

static void origin_dtr(struct dm_target *ti)
{
	struct dm_dev *dev = (struct dm_dev *) ti->private;
	dm_put_device(ti, dev);
}

static int origin_map(struct dm_target *ti, struct buffer_head *bh, int rw,
		      void **map_context)
{
	struct dm_dev *dev = (struct dm_dev *) ti->private;
	bh->b_rdev = dev->dev;

	/* Only tell snapshots if this is a write */
	return (rw == WRITE) ? do_origin(dev, bh) : 1;
}

static int origin_status(struct dm_target *ti, status_type_t type, char *result,
			 int maxlen)
{
	struct dm_dev *dev = (struct dm_dev *) ti->private;

	switch (type) {
	case STATUSTYPE_INFO:
		result[0] = '\0';
		break;

	case STATUSTYPE_TABLE:
		snprintf(result, maxlen, "%s", kdevname(dev->dev));
		break;
	}

	return 0;
}

static struct target_type origin_target = {
	name:	"snapshot-origin",
	module:	THIS_MODULE,
	ctr:	origin_ctr,
	dtr:	origin_dtr,
	map:	origin_map,
	status:	origin_status,
};

static struct target_type snapshot_target = {
	name:	"snapshot",
	module:	THIS_MODULE,
	ctr:	snapshot_ctr,
	dtr:	snapshot_dtr,
	map:	snapshot_map,
	status:	snapshot_status,
};

int __init dm_snapshot_init(void)
{
	int r;

	r = dm_register_target(&snapshot_target);
	if (r) {
		DMERR("snapshot target register failed %d", r);
		return r;
	}

	r = dm_register_target(&origin_target);
	if (r < 0) {
		DMERR("Device mapper: Origin: register failed %d\n", r);
		goto bad1;
	}

	r = init_origin_hash();
	if (r) {
		DMERR("init_origin_hash failed.");
		goto bad2;
	}

	exception_cache = kmem_cache_create("dm-snapshot-ex",
					    sizeof(struct exception),
					    __alignof__(struct exception),
					    0, NULL, NULL);
	if (!exception_cache) {
		DMERR("Couldn't create exception cache.");
		r = -ENOMEM;
		goto bad3;
	}

	pending_cache =
	    kmem_cache_create("dm-snapshot-in",
			      sizeof(struct pending_exception),
			      __alignof__(struct pending_exception),
			      0, NULL, NULL);
	if (!pending_cache) {
		DMERR("Couldn't create pending cache.");
		r = -ENOMEM;
		goto bad4;
	}

	pending_pool = mempool_create(128, mempool_alloc_slab,
				      mempool_free_slab, pending_cache);
	if (!pending_pool) {
		DMERR("Couldn't create pending pool.");
		r = -ENOMEM;
		goto bad5;
	}

	return 0;

      bad5:
	kmem_cache_destroy(pending_cache);
      bad4:
	kmem_cache_destroy(exception_cache);
      bad3:
	exit_origin_hash();
      bad2:
	dm_unregister_target(&origin_target);
      bad1:
	dm_unregister_target(&snapshot_target);
	return r;
}

void dm_snapshot_exit(void)
{
	int r;

	r = dm_unregister_target(&snapshot_target);
	if (r)
		DMERR("snapshot unregister failed %d", r);

	r = dm_unregister_target(&origin_target);
	if (r)
		DMERR("origin unregister failed %d", r);

	exit_origin_hash();
	mempool_destroy(pending_pool);
	kmem_cache_destroy(pending_cache);
	kmem_cache_destroy(exception_cache);
}

/*
 * Overrides for Emacs so that we follow Linus's tabbing style.
 * Emacs will notice this stuff at the end of the file and automatically
 * adjust the settings for this buffer only.  This must remain at the end
 * of the file.
 * ---------------------------------------------------------------------------
 * Local variables:
 * c-file-style: "linux"
 * End:
 */




/*
 * dm-snapshot.c
 *
 * Copyright (C) 2001-2002 Sistina Software (UK) Limited.
 *
 * This file is released under the GPL.
 */

#ifndef DM_SNAPSHOT_H
#define DM_SNAPSHOT_H

#include "dm.h"
#include <linux/blkdev.h>

struct exception_table {
	uint32_t hash_mask;
	struct list_head *table;
};

/*
 * The snapshot code deals with largish chunks of the disk at a
 * time. Typically 64k - 256k.
 */
/* FIXME: can we get away with limiting these to a uint32_t ? */
typedef sector_t chunk_t;

/*
 * An exception is used where an old chunk of data has been
 * replaced by a new one.
 */
struct exception {
	struct list_head hash_list;

	chunk_t old_chunk;
	chunk_t new_chunk;
};

/*
 * Abstraction to handle the meta/layout of exception stores (the
 * COW device).
 */
struct exception_store {

	/*
	 * Destroys this object when you've finished with it.
	 */
	void (*destroy) (struct exception_store *store);

	/*
	 * Find somewhere to store the next exception.
	 */
	int (*prepare_exception) (struct exception_store *store,
				  struct exception *e);

	/*
	 * Update the metadata with this exception.
	 */
	void (*commit_exception) (struct exception_store *store,
				  struct exception *e,
				  void (*callback) (void *, int success),
				  void *callback_context);

	/*
	 * The snapshot is invalid, note this in the metadata.
	 */
	void (*drop_snapshot) (struct exception_store *store);

	/*
	 * Return the %age full of the snapshot
	 */
	int (*percent_full) (struct exception_store *store);

	struct dm_snapshot *snap;
	void *context;
};

struct dm_snapshot {
	struct rw_semaphore lock;
	struct dm_table *table;

	struct dm_dev *origin;
	struct dm_dev *cow;

	/* List of snapshots per Origin */
	struct list_head list;

	/* Size of data blocks saved - must be a power of 2 */
	chunk_t chunk_size;
	chunk_t chunk_mask;
	chunk_t chunk_shift;

	/* You can't use a snapshot if this is 0 (e.g. if full) */
	int valid;

	/* Used for display of table */
	char type;

	/* The last percentage we notified */
	int last_percent;

	struct exception_table pending;
	struct exception_table complete;

	/* The on disk metadata handler */
	struct exception_store store;
};

/*
 * Used by the exception stores to load exceptions hen
 * initialising.
 */
int dm_add_exception(struct dm_snapshot *s, chunk_t old, chunk_t new);

/*
 * Constructor and destructor for the default persistent
 * store.
 */
int dm_create_persistent(struct exception_store *store, uint32_t chunk_size);

int dm_create_transient(struct exception_store *store,
			struct dm_snapshot *s, int blocksize);

/*
 * Return the number of sectors in the device.
 */
static inline sector_t get_dev_size(kdev_t dev)
{
	int *sizes;

	sizes = blk_size[MAJOR(dev)];
	if (sizes)
		return sizes[MINOR(dev)] << 1;

	return 0;
}

static inline chunk_t sector_to_chunk(struct dm_snapshot *s, sector_t sector)
{
	return (sector & ~s->chunk_mask) >> s->chunk_shift;
}

static inline sector_t chunk_to_sector(struct dm_snapshot *s, chunk_t chunk)
{
	return chunk << s->chunk_shift;
}

#endif




/*
 * Copyright (C) 2001 Sistina Software (UK) Limited.
 *
 * This file is released under the GPL.
 */

#include "dm.h"

#include <linux/module.h>
#include <linux/init.h>
#include <linux/blkdev.h>
#include <linux/slab.h>

struct stripe {
	struct dm_dev *dev;
	sector_t physical_start;
};

struct stripe_c {
	uint32_t stripes;

	/* The size of this target / num. stripes */
	uint32_t stripe_width;

	/* stripe chunk size */
	uint32_t chunk_shift;
	sector_t chunk_mask;

	struct stripe stripe[0];
};

static inline struct stripe_c *alloc_context(int stripes)
{
	size_t len;

	if (array_too_big(sizeof(struct stripe_c), sizeof(struct stripe),
			  stripes))
		return NULL;

	len = sizeof(struct stripe_c) + (sizeof(struct stripe) * stripes);

	return kmalloc(len, GFP_KERNEL);
}

/*
 * Parse a single <dev> <sector> pair
 */
static int get_stripe(struct dm_target *ti, struct stripe_c *sc,
		      int stripe, char **argv)
{
	sector_t start;

	if (sscanf(argv[1], SECTOR_FORMAT, &start) != 1)
		return -EINVAL;

	if (dm_get_device(ti, argv[0], start, sc->stripe_width,
			  dm_table_get_mode(ti->table),
			  &sc->stripe[stripe].dev))
		return -ENXIO;

	sc->stripe[stripe].physical_start = start;
	return 0;
}

/*
 * FIXME: Nasty function, only present because we can't link
 * against __moddi3 and __divdi3.
 *
 * returns a == b * n
 */
static int multiple(sector_t a, sector_t b, sector_t *n)
{
	sector_t acc, prev, i;

	*n = 0;
	while (a >= b) {
		for (acc = b, prev = 0, i = 1;
		     acc <= a;
		     prev = acc, acc <<= 1, i <<= 1)
			;

		a -= prev;
		*n += i >> 1;
	}

	return a == 0;
}

/*
 * Construct a striped mapping.
 * <number of stripes> <chunk size (2^^n)> [<dev_path> <offset>]+
 */
static int stripe_ctr(struct dm_target *ti, int argc, char **argv)
{
	struct stripe_c *sc;
	sector_t width;
	uint32_t stripes;
	uint32_t chunk_size;
	char *end;
	int r, i;

	if (argc < 2) {
		ti->error = "dm-stripe: Not enough arguments";
		return -EINVAL;
	}

	stripes = simple_strtoul(argv[0], &end, 10);
	if (*end) {
		ti->error = "dm-stripe: Invalid stripe count";
		return -EINVAL;
	}

	chunk_size = simple_strtoul(argv[1], &end, 10);
	if (*end) {
		ti->error = "dm-stripe: Invalid chunk_size";
		return -EINVAL;
	}

	/*
	 * chunk_size is a power of two
	 */
	if (!chunk_size || (chunk_size & (chunk_size - 1))) {
		ti->error = "dm-stripe: Invalid chunk size";
		return -EINVAL;
	}

	if (!multiple(ti->len, stripes, &width)) {
		ti->error = "dm-stripe: Target length not divisable by "
		    "number of stripes";
		return -EINVAL;
	}

	/*
	 * Do we have enough arguments for that many stripes ?
	 */
	if (argc != (2 + 2 * stripes)) {
		ti->error = "dm-stripe: Not enough destinations specified";
		return -EINVAL;
	}

	sc = alloc_context(stripes);
	if (!sc) {
		ti->error = "dm-stripe: Memory allocation for striped context "
		    "failed";
		return -ENOMEM;
	}

	sc->stripes = stripes;
	sc->stripe_width = width;

	sc->chunk_mask = ((sector_t) chunk_size) - 1;
	for (sc->chunk_shift = 0; chunk_size; sc->chunk_shift++)
		chunk_size >>= 1;
	sc->chunk_shift--;

	/*
	 * Get the stripe destinations.
	 */
	for (i = 0; i < stripes; i++) {
		argv += 2;

		r = get_stripe(ti, sc, i, argv);
		if (r < 0) {
			ti->error = "dm-stripe: Couldn't parse stripe "
			    "destination";
			while (i--)
				dm_put_device(ti, sc->stripe[i].dev);
			kfree(sc);
			return r;
		}
	}

	ti->private = sc;
	return 0;
}

static void stripe_dtr(struct dm_target *ti)
{
	unsigned int i;
	struct stripe_c *sc = (struct stripe_c *) ti->private;

	for (i = 0; i < sc->stripes; i++)
		dm_put_device(ti, sc->stripe[i].dev);

	kfree(sc);
}

static int stripe_map(struct dm_target *ti, struct buffer_head *bh, int rw,
		      void **context)
{
	struct stripe_c *sc = (struct stripe_c *) ti->private;

	sector_t offset = bh->b_rsector - ti->begin;
	uint32_t chunk = (uint32_t) (offset >> sc->chunk_shift);
	uint32_t stripe = chunk % sc->stripes;	/* 32bit modulus */
	chunk = chunk / sc->stripes;

	bh->b_rdev = sc->stripe[stripe].dev->dev;
	bh->b_rsector = sc->stripe[stripe].physical_start +
	    (chunk << sc->chunk_shift) + (offset & sc->chunk_mask);
	return 1;
}

static int stripe_status(struct dm_target *ti,
			 status_type_t type, char *result, int maxlen)
{
	struct stripe_c *sc = (struct stripe_c *) ti->private;
	int offset;
	int i;

	switch (type) {
	case STATUSTYPE_INFO:
		result[0] = '\0';
		break;

	case STATUSTYPE_TABLE:
		offset = snprintf(result, maxlen, "%d " SECTOR_FORMAT,
				  sc->stripes, sc->chunk_mask + 1);
		for (i = 0; i < sc->stripes; i++) {
			offset +=
			    snprintf(result + offset, maxlen - offset,
				     " %s " SECTOR_FORMAT,
		       kdevname(to_kdev_t(sc->stripe[i].dev->bdev->bd_dev)),
				     sc->stripe[i].physical_start);
		}
		break;
	}
	return 0;
}

static struct target_type stripe_target = {
	.name   = "striped",
	.module = THIS_MODULE,
	.ctr    = stripe_ctr,
	.dtr    = stripe_dtr,
	.map    = stripe_map,
	.status = stripe_status,
};

int __init dm_stripe_init(void)
{
	int r;

	r = dm_register_target(&stripe_target);
	if (r < 0)
		DMWARN("striped target registration failed");

	return r;
}

void dm_stripe_exit(void)
{
	if (dm_unregister_target(&stripe_target))
		DMWARN("striped target unregistration failed");

	return;
}




/*
 * Copyright (C) 2001 Sistina Software (UK) Limited.
 *
 * This file is released under the GPL.
 */

#include "dm.h"

#include <linux/module.h>
#include <linux/vmalloc.h>
#include <linux/blkdev.h>
#include <linux/ctype.h>
#include <linux/slab.h>
#include <asm/atomic.h>

#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 {
	atomic_t holders;

	/* btree table */
	int depth;
	int counts[MAX_DEPTH];	/* in nodes */
	sector_t *index[MAX_DEPTH];

	int num_targets;
	int num_allocated;
	sector_t *highs;
	struct dm_target *targets;

	/*
	 * Indicates the rw permissions for the new logical
	 * device.  This should be a combination of FMODE_READ
	 * and FMODE_WRITE.
	 */
	int mode;

	/* a list of devices used by this table */
	struct list_head devices;

	/*
	 * A waitqueue for processes waiting for something
	 * interesting to happen to this table.
	 */
	wait_queue_head_t eventq;
};

/*
 * Ceiling(n / size)
 */
static inline unsigned long div_up(unsigned long n, unsigned long size)
{
	return dm_round_up(n, size) / size;
}

/*
 * Similar to ceiling(log_size(n))
 */
static unsigned int int_log(unsigned long n, unsigned long base)
{
	int result = 0;

	while (n > 1) {
		n = div_up(n, base);
		result++;
	}

	return result;
}

/*
 * Calculate the index of the child node of the n'th node k'th key.
 */
static inline int get_child(int n, int k)
{
	return (n * CHILDREN_PER_NODE) + k;
}

/*
 * Return the n'th node of level l from table t.
 */
static inline sector_t *get_node(struct dm_table *t, int l, int n)
{
	return t->index[l] + (n * KEYS_PER_NODE);
}

/*
 * Return the highest key that you could lookup from the n'th
 * node on level l of the btree.
 */
static sector_t high(struct dm_table *t, int l, int n)
{
	for (; l < t->depth - 1; l++)
		n = get_child(n, CHILDREN_PER_NODE - 1);

	if (n >= t->counts[l])
		return (sector_t) - 1;

	return get_node(t, l, n)[KEYS_PER_NODE - 1];
}

/*
 * Fills in a level of the btree based on the highs of the level
 * below it.
 */
static int setup_btree_index(int l, struct dm_table *t)
{
	int n, k;
	sector_t *node;

	for (n = 0; n < t->counts[l]; n++) {
		node = get_node(t, l, n);

		for (k = 0; k < KEYS_PER_NODE; k++)
			node[k] = high(t, l + 1, get_child(n, k));
	}

	return 0;
}

/*
 * highs, and targets are managed as dynamic arrays during a
 * table load.
 */
static int alloc_targets(struct dm_table *t, int num)
{
	sector_t *n_highs;
	struct dm_target *n_targets;
	int n = t->num_targets;

	/*
	 * Allocate both the target array and offset array at once.
	 */
	n_highs = (sector_t *) vcalloc(sizeof(struct dm_target) +
				       sizeof(sector_t), num);
	if (!n_highs)
		return -ENOMEM;

	n_targets = (struct dm_target *) (n_highs + num);

	if (n) {
		memcpy(n_highs, t->highs, sizeof(*n_highs) * n);
		memcpy(n_targets, t->targets, sizeof(*n_targets) * n);
	}

	memset(n_highs + n, -1, sizeof(*n_highs) * (num - n));
	vfree(t->highs);

	t->num_allocated = num;
	t->highs = n_highs;
	t->targets = n_targets;

	return 0;
}

int dm_table_create(struct dm_table **result, int mode)
{
	struct dm_table *t = kmalloc(sizeof(*t), GFP_NOIO);

	if (!t)
		return -ENOMEM;

	memset(t, 0, sizeof(*t));
	INIT_LIST_HEAD(&t->devices);
	atomic_set(&t->holders, 1);

	/* allocate a single nodes worth of targets to begin with */
	if (alloc_targets(t, KEYS_PER_NODE)) {
		kfree(t);
		t = NULL;
		return -ENOMEM;
	}

	init_waitqueue_head(&t->eventq);
	t->mode = mode;
	*result = t;
	return 0;
}

static void free_devices(struct list_head *devices)
{
	struct list_head *tmp, *next;

	for (tmp = devices->next; tmp != devices; tmp = next) {
		struct dm_dev *dd = list_entry(tmp, struct dm_dev, list);
		next = tmp->next;
		kfree(dd);
	}
}

void table_destroy(struct dm_table *t)
{
	int i;

	/* destroying the table counts as an event */
	dm_table_event(t);

	/* free the indexes (see dm_table_complete) */
	if (t->depth >= 2)
		vfree(t->index[t->depth - 2]);

	/* free the targets */
	for (i = 0; i < t->num_targets; i++) {
		struct dm_target *tgt = t->targets + i;

		if (tgt->type->dtr)
			tgt->type->dtr(tgt);

		dm_put_target_type(tgt->type);
	}

	vfree(t->highs);

	/* free the device list */
	if (t->devices.next != &t->devices) {
		DMWARN("devices still present during destroy: "
		       "dm_table_remove_device calls missing");

		free_devices(&t->devices);
	}

	kfree(t);
}

void dm_table_get(struct dm_table *t)
{
	atomic_inc(&t->holders);
}

void dm_table_put(struct dm_table *t)
{
	if (atomic_dec_and_test(&t->holders))
		table_destroy(t);
}

/*
 * Checks to see if we need to extend highs or targets.
 */
static inline int check_space(struct dm_table *t)
{
	if (t->num_targets >= t->num_allocated)
		return alloc_targets(t, t->num_allocated * 2);

	return 0;
}

/*
 * Convert a device path to a dev_t.
 */
static int lookup_device(const char *path, kdev_t *dev)
{
	int r;
	struct nameidata nd;
	struct inode *inode;

	if (!path_init(path, LOOKUP_FOLLOW, &nd))
		return 0;

	if ((r = path_walk(path, &nd)))
		goto out;

	inode = nd.dentry->d_inode;
	if (!inode) {
		r = -ENOENT;
		goto out;
	}

	if (!S_ISBLK(inode->i_mode)) {
		r = -ENOTBLK;
		goto out;
	}

	*dev = inode->i_rdev;

      out:
	path_release(&nd);
	return r;
}

/*
 * See if we've already got a device in the list.
 */
static struct dm_dev *find_device(struct list_head *l, kdev_t dev)
{
	struct list_head *tmp;

	list_for_each(tmp, l) {
		struct dm_dev *dd = list_entry(tmp, struct dm_dev, list);
		if (kdev_same(dd->dev, dev))
			return dd;
	}

	return NULL;
}

/*
 * Open a device so we can use it as a map destination.
 */
static int open_dev(struct dm_dev *dd)
{
	if (dd->bdev)
		BUG();

	dd->bdev = bdget(kdev_t_to_nr(dd->dev));
	if (!dd->bdev)
		return -ENOMEM;

	return blkdev_get(dd->bdev, dd->mode, 0, BDEV_RAW);
}

/*
 * Close a device that we've been using.
 */
static void close_dev(struct dm_dev *dd)
{
	if (!dd->bdev)
		return;

	blkdev_put(dd->bdev, BDEV_RAW);
	dd->bdev = NULL;
}

/*
 * If possible (ie. blk_size[major] is set), this checks an area
 * of a destination device is valid.
 */
static int check_device_area(kdev_t dev, sector_t start, sector_t len)
{
	int *sizes;
	sector_t dev_size;

	if (!(sizes = blk_size[major(dev)]) || !(dev_size = sizes[minor(dev)]))
		/* we don't know the device details,
		 * so give the benefit of the doubt */
		return 1;

	/* convert to 512-byte sectors */
	dev_size <<= 1;

	return ((start < dev_size) && (len <= (dev_size - start)));
}

/*
 * This upgrades the mode on an already open dm_dev.  Being
 * 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)
{
	int r;
	struct dm_dev dd_copy;

	memcpy(&dd_copy, dd, sizeof(dd_copy));

	dd->mode |= new_mode;
	dd->bdev = NULL;
	r = open_dev(dd);
	if (!r)
		close_dev(&dd_copy);
	else
		memcpy(dd, &dd_copy, sizeof(dd_copy));

	return r;
}

/*
 * Add a device to the list, or just increment the usage count if
 * it's already present.
 */
int dm_get_device(struct dm_target *ti, const char *path, sector_t start,
		  sector_t len, int mode, struct dm_dev **result)
{
	int r;
	kdev_t dev;
	struct dm_dev *dd;
	int major, minor;
	struct dm_table *t = ti->table;

	if (!t)
		BUG();

	if (sscanf(path, "%x:%x", &major, &minor) == 2) {
		/* Extract the major/minor numbers */
		dev = mk_kdev(major, minor);
	} else {
		/* convert the path to a device */
		if ((r = lookup_device(path, &dev)))
			return r;
	}

	dd = find_device(&t->devices, dev);
	if (!dd) {
		dd = kmalloc(sizeof(*dd), GFP_KERNEL);
		if (!dd)
			return -ENOMEM;

		dd->dev = dev;
		dd->mode = mode;
		dd->bdev = NULL;

		if ((r = open_dev(dd))) {
			kfree(dd);
			return r;
		}

		atomic_set(&dd->count, 0);
		list_add(&dd->list, &t->devices);

	} else if (dd->mode != (mode | dd->mode)) {
		r = upgrade_mode(dd, mode);
		if (r)
			return r;
	}
	atomic_inc(&dd->count);

	if (!check_device_area(dd->dev, start, len)) {
		DMWARN("device %s too small for target", path);
		dm_put_device(ti, dd);
		return -EINVAL;
	}

	*result = dd;

	return 0;
}

/*
 * Decrement a devices use count and remove it if neccessary.
 */
void dm_put_device(struct dm_target *ti, struct dm_dev *dd)
{
	if (atomic_dec_and_test(&dd->count)) {
		close_dev(dd);
		list_del(&dd->list);
		kfree(dd);
	}
}

/*
 * Checks to see if the target joins onto the end of the table.
 */
static int adjoin(struct dm_table *table, struct dm_target *ti)
{
	struct dm_target *prev;

	if (!table->num_targets)
		return !ti->begin;

	prev = &table->targets[table->num_targets - 1];
	return (ti->begin == (prev->begin + prev->len));
}

/*
 * Destructively splits up the argument list to pass to ctr.
 */
static int split_args(int max, int *argc, char **argv, char *input)
{
	char *start, *end = input, *out;
	*argc = 0;

	while (1) {
		start = end;

		/* Skip whitespace */
		while (*start && isspace(*start))
			start++;

		if (!*start)
			break;	/* success, we hit the end */

		/* 'out' is used to remove any back-quotes */
		end = out = start;
		while (*end) {
			/* Everything apart from '\0' can be quoted */
			if (*end == '\\' && *(end + 1)) {
				*out++ = *(end + 1);
				end += 2;
				continue;
			}

			if (isspace(*end))
				break;	/* end of token */

			*out++ = *end++;
		}

		/* have we already filled the array ? */
		if ((*argc + 1) > max)
			return -EINVAL;

		/* we know this is whitespace */
		if (*end)
			end++;

		/* terminate the string and put it in the array */
		*out = '\0';
		argv[*argc] = start;
		(*argc)++;
	}

	return 0;
}

int dm_table_add_target(struct dm_table *t, const char *type,
			sector_t start, sector_t len, char *params)
{
	int r = -EINVAL, argc;
	char *argv[32];
	struct dm_target *tgt;

	if ((r = check_space(t)))
		return r;

	tgt = t->targets + t->num_targets;
	memset(tgt, 0, sizeof(*tgt));

	tgt->type = dm_get_target_type(type);
	if (!tgt->type) {
		tgt->error = "unknown target type";
		return -EINVAL;
	}

	tgt->table = t;
	tgt->begin = start;
	tgt->len = len;
	tgt->error = "Unknown error";

	/*
	 * Does this target adjoin the previous one ?
	 */
	if (!adjoin(t, tgt)) {
		tgt->error = "Gap in table";
		r = -EINVAL;
		goto bad;
	}

	r = split_args(ARRAY_SIZE(argv), &argc, argv, params);
	if (r) {
		tgt->error = "couldn't split parameters";
		goto bad;
	}

	r = tgt->type->ctr(tgt, argc, argv);
	if (r)
		goto bad;

	t->highs[t->num_targets++] = tgt->begin + tgt->len - 1;
	return 0;

      bad:
	printk(KERN_ERR DM_NAME ": %s\n", tgt->error);
	dm_put_target_type(tgt->type);
	return r;
}

static int setup_indexes(struct dm_table *t)
{
	int i, total = 0;
	sector_t *indexes;

	/* allocate the space for *all* the indexes */
	for (i = t->depth - 2; i >= 0; i--) {
		t->counts[i] = div_up(t->counts[i + 1], CHILDREN_PER_NODE);
		total += t->counts[i];
	}

	indexes = (sector_t *) vcalloc(total, (unsigned long) NODE_SIZE);
	if (!indexes)
		return -ENOMEM;

	/* set up internal nodes, bottom-up */
	for (i = t->depth - 2, total = 0; i >= 0; i--) {
		t->index[i] = indexes;
		indexes += (KEYS_PER_NODE * t->counts[i]);
		setup_btree_index(i, t);
	}

	return 0;
}

/*
 * Builds the btree to index the map.
 */
int dm_table_complete(struct dm_table *t)
{
	int leaf_nodes, r = 0;

	/* how many indexes will the btree have ? */
	leaf_nodes = div_up(t->num_targets, KEYS_PER_NODE);
	t->depth = 1 + int_log(leaf_nodes, CHILDREN_PER_NODE);

	/* leaf layer has already been set up */
	t->counts[t->depth - 1] = leaf_nodes;
	t->index[t->depth - 1] = t->highs;

	if (t->depth >= 2)
		r = setup_indexes(t);

	return r;
}

void dm_table_event(struct dm_table *t)
{
	wake_up_interruptible(&t->eventq);
}

sector_t dm_table_get_size(struct dm_table *t)
{
	return t->num_targets ? (t->highs[t->num_targets - 1] + 1) : 0;
}

struct dm_target *dm_table_get_target(struct dm_table *t, int index)
{
	if (index > t->num_targets)
		return NULL;

	return t->targets + index;
}

/*
 * Search the btree for the correct target.
 */
struct dm_target *dm_table_find_target(struct dm_table *t, sector_t sector)
{
	int l, n = 0, k = 0;
	sector_t *node;

	for (l = 0; l < t->depth; l++) {
		n = get_child(n, k);
		node = get_node(t, l, n);

		for (k = 0; k < KEYS_PER_NODE; k++)
			if (node[k] >= sector)
				break;
	}

	return &t->targets[(KEYS_PER_NODE * n) + k];
}

unsigned int dm_table_get_num_targets(struct dm_table *t)
{
	return t->num_targets;
}

struct list_head *dm_table_get_devices(struct dm_table *t)
{
	return &t->devices;
}

int dm_table_get_mode(struct dm_table *t)
{
	return t->mode;
}

void dm_table_add_wait_queue(struct dm_table *t, wait_queue_t *wq)
{
	add_wait_queue(&t->eventq, wq);
}

EXPORT_SYMBOL(dm_get_device);
EXPORT_SYMBOL(dm_put_device);
EXPORT_SYMBOL(dm_table_event);
EXPORT_SYMBOL(dm_table_get_mode);




/*
 * Copyright (C) 2001 Sistina Software (UK) Limited
 *
 * This file is released under the GPL.
 */

#include "dm.h"

#include <linux/module.h>
#include <linux/kmod.h>
#include <linux/slab.h>

struct tt_internal {
	struct target_type tt;

	struct list_head list;
	long use;
};

static LIST_HEAD(_targets);
static DECLARE_RWSEM(_lock);

#define DM_MOD_NAME_SIZE 32

static inline struct tt_internal *__find_target_type(const char *name)
{
	struct list_head *tih;
	struct tt_internal *ti;

	list_for_each(tih, &_targets) {
		ti = list_entry(tih, struct tt_internal, list);

		if (!strcmp(name, ti->tt.name))
			return ti;
	}

	return NULL;
}

static struct tt_internal *get_target_type(const char *name)
{
	struct tt_internal *ti;

	down_read(&_lock);
	ti = __find_target_type(name);

	if (ti) {
		if (ti->use == 0 && ti->tt.module)
			__MOD_INC_USE_COUNT(ti->tt.module);
		ti->use++;
	}
	up_read(&_lock);

	return ti;
}

static void load_module(const char *name)
{
	char module_name[DM_MOD_NAME_SIZE] = "dm-";

	/* Length check for strcat() below */
	if (strlen(name) > (DM_MOD_NAME_SIZE - 4))
		return;

	strcat(module_name, name);
	request_module(module_name);
}

struct target_type *dm_get_target_type(const char *name)
{
	struct tt_internal *ti = get_target_type(name);

	if (!ti) {
		load_module(name);
		ti = get_target_type(name);
	}

	return ti ? &ti->tt : NULL;
}

void dm_put_target_type(struct target_type *t)
{
	struct tt_internal *ti = (struct tt_internal *) t;

	down_read(&_lock);
	if (--ti->use == 0 && ti->tt.module)
		__MOD_DEC_USE_COUNT(ti->tt.module);

	if (ti->use < 0)
		BUG();
	up_read(&_lock);

	return;
}

static struct tt_internal *alloc_target(struct target_type *t)
{
	struct tt_internal *ti = kmalloc(sizeof(*ti), GFP_KERNEL);

	if (ti) {
		memset(ti, 0, sizeof(*ti));
		ti->tt = *t;
	}

	return ti;
}

int dm_register_target(struct target_type *t)
{
	int rv = 0;
	struct tt_internal *ti = alloc_target(t);

	if (!ti)
		return -ENOMEM;

	down_write(&_lock);
	if (__find_target_type(t->name))
		rv = -EEXIST;
	else
		list_add(&ti->list, &_targets);

	up_write(&_lock);
	return rv;
}

int dm_unregister_target(struct target_type *t)
{
	struct tt_internal *ti;

	down_write(&_lock);
	if (!(ti = __find_target_type(t->name))) {
		up_write(&_lock);
		return -EINVAL;
	}

	if (ti->use) {
		up_write(&_lock);
		return -ETXTBSY;
	}

	list_del(&ti->list);
	kfree(ti);

	up_write(&_lock);
	return 0;
}

/*
 * io-err: always fails an io, useful for bringing
 * up LVs that have holes in them.
 */
static int io_err_ctr(struct dm_target *ti, int argc, char **args)
{
	return 0;
}

static void io_err_dtr(struct dm_target *ti)
{
	/* empty */
}

static int io_err_map(struct dm_target *ti, struct buffer_head *bh, int rw,
		      void **map_context)
{
	return -EIO;
}

static struct target_type error_target = {
	.name = "error",
	.ctr  = io_err_ctr,
	.dtr  = io_err_dtr,
	.map  = io_err_map,
};

int dm_target_init(void)
{
	return dm_register_target(&error_target);
}

void dm_target_exit(void)
{
	if (dm_unregister_target(&error_target))
		DMWARN("error target unregistration failed");
}

EXPORT_SYMBOL(dm_register_target);
EXPORT_SYMBOL(dm_unregister_target);




/*
 * Copyright (C) 2001, 2002 Sistina Software (UK) Limited.
 *
 * This file is released under the GPL.
 */

#include "dm.h"

#include <linux/init.h>
#include <linux/module.h>
#include <linux/blk.h>
#include <linux/blkpg.h>
#include <linux/mempool.h>
#include <linux/slab.h>
#include <linux/kdev_t.h>
#include <linux/lvm.h>

#include <asm/uaccess.h>

static const char *_name = DM_NAME;
#define MAX_DEVICES (1 << MINORBITS)
#define DEFAULT_READ_AHEAD 64

static int major = 0;
static int _major = 0;

struct dm_io {
	struct mapped_device *md;

	struct dm_target *ti;
	int rw;
	void *map_context;
	void (*end_io) (struct buffer_head * bh, int uptodate);
	void *context;
};

struct deferred_io {
	int rw;
	struct buffer_head *bh;
	struct deferred_io *next;
};

/*
 * Bits for the md->flags field.
 */
#define DMF_BLOCK_IO 0
#define DMF_SUSPENDED 1

struct mapped_device {
	struct rw_semaphore lock;
	atomic_t holders;

	kdev_t dev;
	unsigned long flags;

	/*
	 * A list of ios that arrived while we were suspended.
	 */
	atomic_t pending;
	wait_queue_head_t wait;
	struct deferred_io *deferred;

	/*
	 * The current mapping.
	 */
	struct dm_table *map;

	/*
	 * io objects are allocated from here.
	 */
	mempool_t *io_pool;
};

#define MIN_IOS 256
static kmem_cache_t *_io_cache;

/* block device arrays */
static int _block_size[MAX_DEVICES];
static int _blksize_size[MAX_DEVICES];
static int _hardsect_size[MAX_DEVICES];

static struct mapped_device *get_kdev(kdev_t dev);
static int dm_request(request_queue_t *q, int rw, struct buffer_head *bh);
static int dm_user_bmap(struct inode *inode, struct lv_bmap *lvb);

static __init int local_init(void)
{
	int r;

	/* allocate a slab for the dm_ios */
	_io_cache = kmem_cache_create("dm io",
				      sizeof(struct dm_io), 0, 0, NULL, NULL);

	if (!_io_cache)
		return -ENOMEM;

	_major = major;
	r = register_blkdev(_major, _name, &dm_blk_dops);
	if (r < 0) {
		DMERR("register_blkdev failed");
		kmem_cache_destroy(_io_cache);
		return r;
	}

	if (!_major)
		_major = r;

	/* set up the arrays */
	read_ahead[_major] = DEFAULT_READ_AHEAD;
	blk_size[_major] = _block_size;
	blksize_size[_major] = _blksize_size;
	hardsect_size[_major] = _hardsect_size;

	blk_queue_make_request(BLK_DEFAULT_QUEUE(_major), dm_request);

	return 0;
}

static void local_exit(void)
{
	kmem_cache_destroy(_io_cache);

	if (unregister_blkdev(_major, _name) < 0)
		DMERR("devfs_unregister_blkdev failed");

	read_ahead[_major] = 0;
	blk_size[_major] = NULL;
	blksize_size[_major] = NULL;
	hardsect_size[_major] = NULL;
	_major = 0;

	DMINFO("cleaned up");
}

/*
 * We have a lot of init/exit functions, so it seems easier to
 * store them in an array.  The disposable macro 'xx'
 * expands a prefix into a pair of function names.
 */
static struct {
	int (*init) (void);
	void (*exit) (void);

} _inits[] = {
#define xx(n) {n ## _init, n ## _exit},
	xx(local)
	xx(dm_target)
	xx(dm_linear)
	xx(dm_stripe)
	xx(dm_snapshot)
	xx(dm_interface)
#undef xx
};

static int __init dm_init(void)
{
	const int count = ARRAY_SIZE(_inits);

	int r, i;

	for (i = 0; i < count; i++) {
		r = _inits[i].init();
		if (r)
			goto bad;
	}

	return 0;

      bad:
	while (i--)
		_inits[i].exit();

	return r;
}

static void __exit dm_exit(void)
{
	int i = ARRAY_SIZE(_inits);

	while (i--)
		_inits[i].exit();
}

/*
 * Block device functions
 */
static int dm_blk_open(struct inode *inode, struct file *file)
{
	struct mapped_device *md;

	md = get_kdev(inode->i_rdev);
	if (!md)
		return -ENXIO;

	return 0;
}

static int dm_blk_close(struct inode *inode, struct file *file)
{
	struct mapped_device *md;

	md = get_kdev(inode->i_rdev);
	dm_put(md);		/* put the reference gained by dm_blk_open */
	dm_put(md);
	return 0;
}

static inline struct dm_io *alloc_io(struct mapped_device *md)
{
	return mempool_alloc(md->io_pool, GFP_NOIO);
}

static inline void free_io(struct mapped_device *md, struct dm_io *io)
{
	mempool_free(io, md->io_pool);
}

static inline struct deferred_io *alloc_deferred(void)
{
	return kmalloc(sizeof(struct deferred_io), GFP_NOIO);
}

static inline void free_deferred(struct deferred_io *di)
{
	kfree(di);
}

/* In 512-byte units */
#define VOLUME_SIZE(minor) (_block_size[(minor)] << 1)

/* FIXME: check this */
static int dm_blk_ioctl(struct inode *inode, struct file *file,
			uint command, unsigned long a)
{
	int minor = MINOR(inode->i_rdev);
	long size;

	if (minor >= MAX_DEVICES)
		return -ENXIO;

	switch (command) {
	case BLKROSET:
	case BLKROGET:
	case BLKRASET:
	case BLKRAGET:
	case BLKFLSBUF:
	case BLKSSZGET:
		//case BLKRRPART: /* Re-read partition tables */
		//case BLKPG:
	case BLKELVGET:
	case BLKELVSET:
	case BLKBSZGET:
	case BLKBSZSET:
		return blk_ioctl(inode->i_rdev, command, a);
		break;

	case BLKGETSIZE:
		size = VOLUME_SIZE(minor);
		if (copy_to_user((void *) a, &size, sizeof(long)))
			return -EFAULT;
		break;

	case BLKGETSIZE64:
		size = VOLUME_SIZE(minor);
		if (put_user((u64) ((u64) size) << 9, (u64 *) a))
			return -EFAULT;
		break;

	case BLKRRPART:
		return -ENOTTY;

	case LV_BMAP:
		return dm_user_bmap(inode, (struct lv_bmap *) a);

	default:
		DMWARN("unknown block ioctl 0x%x", command);
		return -ENOTTY;
	}

	return 0;
}

/*
 * Add the buffer to the list of deferred io.
 */
static int queue_io(struct mapped_device *md, struct buffer_head *bh, int rw)
{
	struct deferred_io *di;

	di = alloc_deferred();
	if (!di)
		return -ENOMEM;

	down_write(&md->lock);

	if (!test_bit(DMF_BLOCK_IO, &md->flags)) {
		up_write(&md->lock);
		free_deferred(di);
		return 1;
	}

	di->bh = bh;
	di->rw = rw;
	di->next = md->deferred;
	md->deferred = di;

	up_write(&md->lock);
	return 0;		/* deferred successfully */
}

/*
 * bh->b_end_io routine that decrements the pending count
 * and then calls the original bh->b_end_io fn.
 */
static void dec_pending(struct buffer_head *bh, int uptodate)
{
	int r;
	struct dm_io *io = bh->b_private;
	dm_endio_fn endio = io->ti->type->end_io;

	if (endio) {
		r = endio(io->ti, bh, io->rw, uptodate ? 0 : -EIO,
			  io->map_context);
		if (r < 0)
			uptodate = 0;

		else if (r > 0)
			/* the target wants another shot at the io */
			return;
	}

	if (atomic_dec_and_test(&io->md->pending))
		/* nudge anyone waiting on suspend queue */
		wake_up(&io->md->wait);

	bh->b_end_io = io->end_io;
	bh->b_private = io->context;
	free_io(io->md, io);

	bh->b_end_io(bh, uptodate);
}

/*
 * Do the bh mapping for a given leaf
 */
static inline int __map_buffer(struct mapped_device *md, int rw,
			       struct buffer_head *bh, struct dm_io *io)
{
	struct dm_target *ti;

	ti = dm_table_find_target(md->map, bh->b_rsector);
	if (!ti || !ti->type)
		return -EINVAL;

	/* hook the end io request fn */
	atomic_inc(&md->pending);
	io->md = md;
	io->ti = ti;
	io->rw = rw;
	io->end_io = bh->b_end_io;
	io->context = bh->b_private;
	bh->b_end_io = dec_pending;
	bh->b_private = io;

	return ti->type->map(ti, bh, rw, &io->map_context);
}

/*
 * Checks to see if we should be deferring io, if so it queues it
 * and returns 1.
 */
static inline int __deferring(struct mapped_device *md, int rw,
			      struct buffer_head *bh)
{
	int r;

	/*
	 * If we're suspended we have to queue this io for later.
	 */
	while (test_bit(DMF_BLOCK_IO, &md->flags)) {
		up_read(&md->lock);

		/*
		 * There's no point deferring a read ahead
		 * request, just drop it.
		 */
		if (rw == READA) {
			down_read(&md->lock);
			return -EIO;
		}

		r = queue_io(md, bh, rw);
		down_read(&md->lock);

		if (r < 0)
			return r;

		if (r == 0)
			return 1; /* deferred successfully */

	}

	return 0;
}

static int dm_request(request_queue_t *q, int rw, struct buffer_head *bh)
{
	int r;
	struct dm_io *io;
	struct mapped_device *md;

	md = get_kdev(bh->b_rdev);
	if (!md) {
		buffer_IO_error(bh);
		return 0;
	}

	io = alloc_io(md);
	down_read(&md->lock);

	r = __deferring(md, rw, bh);
	if (r < 0)
		goto bad;

	else if (!r) {
		/* not deferring */
		r = __map_buffer(md, rw, bh, io);
		if (r < 0)
			goto bad;
	} else
		r = 0;

	up_read(&md->lock);
	dm_put(md);
	return r;

      bad:
	buffer_IO_error(bh);
	up_read(&md->lock);
	dm_put(md);
	return 0;
}

static int check_dev_size(kdev_t dev, unsigned long block)
{
	/* FIXME: check this */
	int minor = MINOR(dev);
	unsigned long max_sector = (_block_size[minor] << 1) + 1;
	unsigned long sector = (block + 1) * (_blksize_size[minor] >> 9);

	return (sector > max_sector) ? 0 : 1;
}

/*
 * Creates a dummy buffer head and maps it (for lilo).
 */
static int __bmap(struct mapped_device *md, kdev_t dev, unsigned long block,
		  kdev_t *r_dev, unsigned long *r_block)
{
	struct buffer_head bh;
	struct dm_target *ti;
	void *map_context;
	int r;

	if (test_bit(DMF_BLOCK_IO, &md->flags)) {
		return -EPERM;
	}

	if (!check_dev_size(dev, block)) {
		return -EINVAL;
	}

	/* setup dummy bh */
	memset(&bh, 0, sizeof(bh));
	bh.b_blocknr = block;
	bh.b_dev = bh.b_rdev = dev;
	bh.b_size = _blksize_size[MINOR(dev)];
	bh.b_rsector = block * (bh.b_size >> 9);

	/* find target */
	ti = dm_table_find_target(md->map, bh.b_rsector);

	/* do the mapping */
	r = ti->type->map(ti, &bh, READ, &map_context);
	ti->type->end_io(ti, &bh, READ, 0, map_context);

	if (!r) {
		*r_dev = bh.b_rdev;
		*r_block = bh.b_rsector / (bh.b_size >> 9);
	}

	return r;
}

/*
 * Marshals arguments and results between user and kernel space.
 */
static int dm_user_bmap(struct inode *inode, struct lv_bmap *lvb)
{
	struct mapped_device *md;
	unsigned long block, r_block;
	kdev_t r_dev;
	int r;

	if (get_user(block, &lvb->lv_block))
		return -EFAULT;

	md = get_kdev(inode->i_rdev);
	if (!md)
		return -ENXIO;

	down_read(&md->lock);
	r = __bmap(md, inode->i_rdev, block, &r_dev, &r_block);
	up_read(&md->lock);
	dm_put(md);

	if (!r && (put_user(kdev_t_to_nr(r_dev), &lvb->lv_dev) ||
		   put_user(r_block, &lvb->lv_block)))
		r = -EFAULT;

	return r;
}

/*-----------------------------------------------------------------
 * A bitset is used to keep track of allocated minor numbers.
 *---------------------------------------------------------------*/
static spinlock_t _minor_lock = SPIN_LOCK_UNLOCKED;
static struct mapped_device *_mds[MAX_DEVICES];

static void free_minor(int minor)
{
	spin_lock(&_minor_lock);
	_mds[minor] = NULL;
	spin_unlock(&_minor_lock);
}

/*
 * See if the device with a specific minor # is free.
 */
static int specific_minor(int minor, struct mapped_device *md)
{
	int r = -EBUSY;

	if (minor >= MAX_DEVICES) {
		DMWARN("request for a mapped_device beyond MAX_DEVICES (%d)",
		       MAX_DEVICES);
		return -EINVAL;
	}

	spin_lock(&_minor_lock);
	if (!_mds[minor]) {
		_mds[minor] = md;
		r = minor;
	}
	spin_unlock(&_minor_lock);

	return r;
}

static int next_free_minor(struct mapped_device *md)
{
	int i;

	spin_lock(&_minor_lock);
	for (i = 0; i < MAX_DEVICES; i++) {
		if (!_mds[i]) {
			_mds[i] = md;
			break;
		}
	}
	spin_unlock(&_minor_lock);

	return (i < MAX_DEVICES) ? i : -EBUSY;
}

static struct mapped_device *get_kdev(kdev_t dev)
{
	struct mapped_device *md;

	if (major(dev) != _major)
		return NULL;

	spin_lock(&_minor_lock);
	md = _mds[minor(dev)];
	if (md)
		dm_get(md);
	spin_unlock(&_minor_lock);

	return md;
}

/*
 * Allocate and initialise a blank device with a given minor.
 */
static struct mapped_device *alloc_dev(int minor)
{
	struct mapped_device *md = kmalloc(sizeof(*md), GFP_KERNEL);

	if (!md) {
		DMWARN("unable to allocate device, out of memory.");
		return NULL;
	}

	/* get a minor number for the dev */
	minor = (minor < 0) ? next_free_minor(md) : specific_minor(minor, md);
	if (minor < 0) {
		kfree(md);
		return NULL;
	}

	memset(md, 0, sizeof(*md));

	md->io_pool = mempool_create(MIN_IOS, mempool_alloc_slab,
				     mempool_free_slab, _io_cache);
	if (!md->io_pool) {
		free_minor(minor);
		kfree(md);
		return NULL;
	}

	md->dev = mk_kdev(_major, minor);
	init_rwsem(&md->lock);
	atomic_set(&md->holders, 1);
	atomic_set(&md->pending, 0);
	init_waitqueue_head(&md->wait);

	return md;
}

static void free_dev(struct mapped_device *md)
{
	free_minor(minor(md->dev));
	mempool_destroy(md->io_pool);
	kfree(md);
}

/*
 * The hardsect size for a mapped device is the largest hardsect size
 * from the devices it maps onto.
 */
static int __find_hardsect_size(struct list_head *devices)
{
	int result = 512, size;
	struct list_head *tmp;

	list_for_each(tmp, devices) {
		struct dm_dev *dd = list_entry(tmp, struct dm_dev, list);
		size = get_hardsect_size(dd->dev);
		if (size > result)
			result = size;
	}

	return result;
}

/*
 * Bind a table to the device.
 */
static int __bind(struct mapped_device *md, struct dm_table *t)
{
	int minor = minor(md->dev);
	md->map = t;

	/* in k */
	_block_size[minor] = dm_table_get_size(t) >> 1;
	_blksize_size[minor] = BLOCK_SIZE;
	_hardsect_size[minor] = __find_hardsect_size(dm_table_get_devices(t));
	register_disk(NULL, md->dev, 1, &dm_blk_dops, _block_size[minor]);

	dm_table_get(t);
	return 0;
}

static void __unbind(struct mapped_device *md)
{
	int minor = minor(md->dev);

	dm_table_put(md->map);
	md->map = NULL;

	_block_size[minor] = 0;
	_blksize_size[minor] = 0;
	_hardsect_size[minor] = 0;
}

/*
 * Constructor for a new device.
 */
int dm_create(int minor, struct dm_table *table, struct mapped_device **result)
{
	int r;
	struct mapped_device *md;

	md = alloc_dev(minor);
	if (!md)
		return -ENXIO;

	r = __bind(md, table);
	if (r) {
		free_dev(md);
		return r;
	}

	*result = md;
	return 0;
}

void dm_get(struct mapped_device *md)
{
	atomic_inc(&md->holders);
}

void dm_put(struct mapped_device *md)
{
	if (atomic_dec_and_test(&md->holders)) {
		__unbind(md);
		free_dev(md);
	}
}

/*
 * Requeue the deferred io by calling generic_make_request.
 */
static void flush_deferred_io(struct deferred_io *c)
{
	struct deferred_io *n;

	while (c) {
		n = c->next;
		generic_make_request(c->rw, c->bh);
		free_deferred(c);
		c = n;
	}
}

/*
 * Swap in a new table (destroying old one).
 */
int dm_swap_table(struct mapped_device *md, struct dm_table *table)
{
	int r;

	down_write(&md->lock);

	/* device must be suspended */
	if (!test_bit(DMF_SUSPENDED, &md->flags)) {
		up_write(&md->lock);
		return -EPERM;
	}

	__unbind(md);
	r = __bind(md, table);
	if (r)
		return r;

	up_write(&md->lock);
	return 0;
}

/*
 * We need to be able to change a mapping table under a mounted
 * filesystem.  For example we might want to move some data in
 * the background.  Before the table can be swapped with
 * dm_bind_table, dm_suspend must be called to flush any in
 * flight io and ensure that any further io gets deferred.
 */
int dm_suspend(struct mapped_device *md)
{
	DECLARE_WAITQUEUE(wait, current);

	down_write(&md->lock);

	/*
	 * First we set the BLOCK_IO flag so no more ios will be
	 * mapped.
	 */
	if (test_bit(DMF_BLOCK_IO, &md->flags)) {
		up_write(&md->lock);
		return -EINVAL;
	}

	set_bit(DMF_BLOCK_IO, &md->flags);
	add_wait_queue(&md->wait, &wait);
	up_write(&md->lock);

	/*
	 * Then we wait for the already mapped ios to
	 * complete.
	 */
	run_task_queue(&tq_disk);
	while (1) {
		set_current_state(TASK_INTERRUPTIBLE);

		if (!atomic_read(&md->pending))
			break;

		schedule();
	}

	current->state = TASK_RUNNING;

	down_write(&md->lock);
	remove_wait_queue(&md->wait, &wait);
	set_bit(DMF_SUSPENDED, &md->flags);
	up_write(&md->lock);

	return 0;
}

int dm_resume(struct mapped_device *md)
{
	struct deferred_io *def;

	down_write(&md->lock);
	if (!test_bit(DMF_SUSPENDED, &md->flags) ||
	    !dm_table_get_size(md->map)) {
		up_write(&md->lock);
		return -EINVAL;
	}

	clear_bit(DMF_SUSPENDED, &md->flags);
	clear_bit(DMF_BLOCK_IO, &md->flags);
	def = md->deferred;
	md->deferred = NULL;
	up_write(&md->lock);

	flush_deferred_io(def);
	run_task_queue(&tq_disk);

	return 0;
}

struct dm_table *dm_get_table(struct mapped_device *md)
{
	struct dm_table *t;

	down_read(&md->lock);
	t = md->map;
	dm_table_get(t);
	up_read(&md->lock);

	return t;
}

kdev_t dm_kdev(struct mapped_device *md)
{
	kdev_t dev;

	down_read(&md->lock);
	dev = md->dev;
	up_read(&md->lock);

	return dev;
}

int dm_suspended(struct mapped_device *md)
{
	return test_bit(DMF_SUSPENDED, &md->flags);
}

struct block_device_operations dm_blk_dops = {
	.open = dm_blk_open,
	.release = dm_blk_close,
	.ioctl = dm_blk_ioctl,
	.owner = THIS_MODULE
};

/*
 * module hooks
 */
module_init(dm_init);
module_exit(dm_exit);

MODULE_PARM(major, "i");
MODULE_PARM_DESC(major, "The major number of the device mapper");
MODULE_DESCRIPTION(DM_NAME " driver");
MODULE_AUTHOR("Joe Thornber <thornber@sistina.com>");
MODULE_LICENSE("GPL");




/*
 * Internal header file for device mapper
 *
 * Copyright (C) 2001, 2002 Sistina Software
 *
 * This file is released under the LGPL.
 */

#ifndef DM_INTERNAL_H
#define DM_INTERNAL_H

#include <linux/fs.h>
#include <linux/device-mapper.h>
#include <linux/list.h>
#include <linux/blkdev.h>

#define DM_NAME "device-mapper"
#define DMWARN(f, x...) printk(KERN_WARNING DM_NAME ": " f "\n" , ## x)
#define DMERR(f, x...) printk(KERN_ERR DM_NAME ": " f "\n" , ## x)
#define DMINFO(f, x...) printk(KERN_INFO DM_NAME ": " f "\n" , ## x)

/*
 * FIXME: I think this should be with the definition of sector_t
 * in types.h.
 */
#ifdef CONFIG_LBD
#define SECTOR_FORMAT "%Lu"
#else
#define SECTOR_FORMAT "%lu"
#endif

#define SECTOR_SHIFT 9
#define SECTOR_SIZE (1 << SECTOR_SHIFT)

extern struct block_device_operations dm_blk_dops;

/*
 * List of devices that a metadevice uses and should open/close.
 */
struct dm_dev {
	struct list_head list;

	atomic_t count;
	int mode;
	kdev_t dev;
	struct block_device *bdev;
};

struct dm_table;
struct mapped_device;

/*-----------------------------------------------------------------
 * Functions for manipulating a struct mapped_device.
 * Drop the reference with dm_put when you finish with the object.
 *---------------------------------------------------------------*/
int dm_create(int minor, struct dm_table *table, struct mapped_device **md);

/*
 * Reference counting for md.
 */
void dm_get(struct mapped_device *md);
void dm_put(struct mapped_device *md);

/*
 * A device can still be used while suspended, but I/O is deferred.
 */
int dm_suspend(struct mapped_device *md);
int dm_resume(struct mapped_device *md);

/*
 * The device must be suspended before calling this method.
 */
int dm_swap_table(struct mapped_device *md, struct dm_table *t);

/*
 * Drop a reference on the table when you've finished with the
 * result.
 */
struct dm_table *dm_get_table(struct mapped_device *md);

/*
 * Info functions.
 */
kdev_t dm_kdev(struct mapped_device *md);
int dm_suspended(struct mapped_device *md);

/*-----------------------------------------------------------------
 * Functions for manipulating a table.  Tables are also reference
 * counted.
 *---------------------------------------------------------------*/
int dm_table_create(struct dm_table **result, int mode);

void dm_table_get(struct dm_table *t);
void dm_table_put(struct dm_table *t);

int dm_table_add_target(struct dm_table *t, const char *type,
			sector_t start,	sector_t len, char *params);
int dm_table_complete(struct dm_table *t);
void dm_table_event(struct dm_table *t);
sector_t dm_table_get_size(struct dm_table *t);
struct dm_target *dm_table_get_target(struct dm_table *t, int index);
struct dm_target *dm_table_find_target(struct dm_table *t, sector_t sector);
unsigned int dm_table_get_num_targets(struct dm_table *t);
struct list_head *dm_table_get_devices(struct dm_table *t);
int dm_table_get_mode(struct dm_table *t);
void dm_table_add_wait_queue(struct dm_table *t, wait_queue_t *wq);

/*-----------------------------------------------------------------
 * A registry of target types.
 *---------------------------------------------------------------*/
int dm_target_init(void);
void dm_target_exit(void);
struct target_type *dm_get_target_type(const char *name);
void dm_put_target_type(struct target_type *t);


/*-----------------------------------------------------------------
 * Useful inlines.
 *---------------------------------------------------------------*/
static inline int array_too_big(unsigned long fixed, unsigned long obj,
				unsigned long num)
{
	return (num > (ULONG_MAX - fixed) / obj);
}

/*
 * ceiling(n / size) * size
 */
static inline unsigned long dm_round_up(unsigned long n, unsigned long size)
{
	unsigned long r = n % size;
	return n + (r ? (size - r) : 0);
}

/*
 * The device-mapper can be driven through one of two interfaces;
 * ioctl or filesystem, depending which patch you have applied.
 */
int dm_interface_init(void);
void dm_interface_exit(void);

/*
 * Targets for linear and striped mappings
 */
int dm_linear_init(void);
void dm_linear_exit(void);

int dm_stripe_init(void);
void dm_stripe_exit(void);

int dm_snapshot_init(void);
void dm_snapshot_exit(void);

#endif




/*
 * Copyright (C) 2002 Sistina Software (UK) Limited.
 *
 * This file is released under the GPL.
 */

#include <asm/atomic.h>

#include <linux/blkdev.h>
#include <linux/config.h>
#include <linux/device-mapper.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/list.h>
#include <linux/locks.h>
#include <linux/mempool.h>
#include <linux/module.h>
#include <linux/pagemap.h>
#include <linux/slab.h>
#include <linux/vmalloc.h>

#include "kcopyd.h"

/* FIXME: this is only needed for the DMERR macros */
#include "dm.h"

static void wake_kcopyd(void);

/*-----------------------------------------------------------------
 * We reserve our own pool of preallocated pages that are
 * only used for kcopyd io.
 *---------------------------------------------------------------*/

/*
 * FIXME: This should be configurable.
 */
#define NUM_PAGES 512

static DECLARE_MUTEX(_pages_lock);
static int _num_free_pages;
static struct page *_pages_array[NUM_PAGES];
static DECLARE_MUTEX(start_lock);

static int init_pages(void)
{
	int i;
	struct page *p;

	for (i = 0; i < NUM_PAGES; i++) {
		p = alloc_page(GFP_KERNEL);
		if (!p)
			goto bad;

		LockPage(p);
		_pages_array[i] = p;
	}

	_num_free_pages = NUM_PAGES;
	return 0;

      bad:
	while (i--) {
		UnlockPage(_pages_array[i]);
		__free_page(_pages_array[i]);
	}
	return -ENOMEM;
}

static void exit_pages(void)
{
	int i;
	struct page *p;

	for (i = 0; i < NUM_PAGES; i++) {
		p = _pages_array[i];
		UnlockPage(p);
		__free_page(p);
	}

	_num_free_pages = 0;
}

static int kcopyd_get_pages(int num, struct page **result)
{
	int i;

	down(&_pages_lock);
	if (_num_free_pages < num) {
		up(&_pages_lock);
		return -ENOMEM;
	}

	for (i = 0; i < num; i++) {
		_num_free_pages--;
		result[i] = _pages_array[_num_free_pages];
	}
	up(&_pages_lock);

	return 0;
}

static void kcopyd_free_pages(int num, struct page **result)
{
	int i;

	down(&_pages_lock);
	for (i = 0; i < num; i++)
		_pages_array[_num_free_pages++] = result[i];
	up(&_pages_lock);
}

/*-----------------------------------------------------------------
 * We keep our own private pool of buffer_heads.  These are just
 * held in a list on the b_reqnext field.
 *---------------------------------------------------------------*/

/*
 * Make sure we have enough buffers to always keep the pages
 * occupied.  So we assume the worst case scenario where blocks
 * are the size of a single sector.
 */
#define NUM_BUFFERS NUM_PAGES * (PAGE_SIZE / SECTOR_SIZE)

static spinlock_t _buffer_lock = SPIN_LOCK_UNLOCKED;
static struct buffer_head *_all_buffers;
static struct buffer_head *_free_buffers;

static int init_buffers(void)
{
	int i;
	struct buffer_head *buffers;

	buffers = vcalloc(NUM_BUFFERS, sizeof(struct buffer_head));
	if (!buffers) {
		DMWARN("Couldn't allocate buffer heads.");
		return -ENOMEM;
	}

	for (i = 0; i < NUM_BUFFERS; i++) {
		if (i < NUM_BUFFERS - 1)
			buffers[i].b_reqnext = &buffers[i + 1];
		init_waitqueue_head(&buffers[i].b_wait);
		INIT_LIST_HEAD(&buffers[i].b_inode_buffers);
	}

	_all_buffers = _free_buffers = buffers;
	return 0;
}

static void exit_buffers(void)
{
	vfree(_all_buffers);
}

static struct buffer_head *alloc_buffer(void)
{
	struct buffer_head *r;
	int flags;

	spin_lock_irqsave(&_buffer_lock, flags);

	if (!_free_buffers)
		r = NULL;
	else {
		r = _free_buffers;
		_free_buffers = _free_buffers->b_reqnext;
		r->b_reqnext = NULL;
	}

	spin_unlock_irqrestore(&_buffer_lock, flags);

	return r;
}

/*
 * Only called from interrupt context.
 */
static void free_buffer(struct buffer_head *bh)
{
	int flags, was_empty;

	spin_lock_irqsave(&_buffer_lock, flags);
	was_empty = (_free_buffers == NULL) ? 1 : 0;
	bh->b_reqnext = _free_buffers;
	_free_buffers = bh;
	spin_unlock_irqrestore(&_buffer_lock, flags);

	/*
	 * If the buffer list was empty then kcopyd probably went
	 * to sleep because it ran out of buffer heads, so let's
	 * wake it up.
	 */
	if (was_empty)
		wake_kcopyd();
}

/*-----------------------------------------------------------------
 * kcopyd_jobs need to be allocated by the *clients* of kcopyd,
 * for this reason we use a mempool to prevent the client from
 * ever having to do io (which could cause a
 * deadlock).
 *---------------------------------------------------------------*/
#define MIN_JOBS NUM_PAGES

static kmem_cache_t *_job_cache = NULL;
static mempool_t *_job_pool = NULL;

/*
 * We maintain three lists of jobs:
 *
 * i)   jobs waiting for pages
 * ii)  jobs that have pages, and are waiting for the io to be issued.
 * iii) jobs that have completed.
 *
 * All three of these are protected by job_lock.
 */

static spinlock_t _job_lock = SPIN_LOCK_UNLOCKED;

static LIST_HEAD(_complete_jobs);
static LIST_HEAD(_io_jobs);
static LIST_HEAD(_pages_jobs);

static int init_jobs(void)
{
	INIT_LIST_HEAD(&_complete_jobs);
	INIT_LIST_HEAD(&_io_jobs);
	INIT_LIST_HEAD(&_pages_jobs);

	_job_cache = kmem_cache_create("kcopyd-jobs", sizeof(struct kcopyd_job),
				       __alignof__(struct kcopyd_job),
				       0, NULL, NULL);
	if (!_job_cache)
		return -ENOMEM;

	_job_pool = mempool_create(MIN_JOBS, mempool_alloc_slab,
				   mempool_free_slab, _job_cache);
	if (!_job_pool) {
		kmem_cache_destroy(_job_cache);
		return -ENOMEM;
	}

	return 0;
}

static void exit_jobs(void)
{
	mempool_destroy(_job_pool);
	kmem_cache_destroy(_job_cache);
}

struct kcopyd_job *kcopyd_alloc_job(void)
{
	struct kcopyd_job *job;

	job = mempool_alloc(_job_pool, GFP_NOIO);
	if (!job)
		return NULL;

	memset(job, 0, sizeof(*job));
	return job;
}

void kcopyd_free_job(struct kcopyd_job *job)
{
	mempool_free(job, _job_pool);
}

/*
 * Functions to push and pop a job onto the head of a given job
 * list.
 */
static inline struct kcopyd_job *pop(struct list_head *jobs)
{
	struct kcopyd_job *job = NULL;
	int flags;

	spin_lock_irqsave(&_job_lock, flags);

	if (!list_empty(jobs)) {
		job = list_entry(jobs->next, struct kcopyd_job, list);
		list_del(&job->list);
	}
	spin_unlock_irqrestore(&_job_lock, flags);

	return job;
}

static inline void push(struct list_head *jobs, struct kcopyd_job *job)
{
	int flags;

	spin_lock_irqsave(&_job_lock, flags);
	list_add(&job->list, jobs);
	spin_unlock_irqrestore(&_job_lock, flags);
}

/*
 * Completion function for one of our buffers.
 */
static void end_bh(struct buffer_head *bh, int uptodate)
{
	struct kcopyd_job *job = bh->b_private;

	mark_buffer_uptodate(bh, uptodate);
	unlock_buffer(bh);

	if (!uptodate)
		job->err = -EIO;

	/* are we the last ? */
	if (atomic_dec_and_test(&job->nr_incomplete)) {
		push(&_complete_jobs, job);
		wake_kcopyd();
	}

	free_buffer(bh);
}

static void dispatch_bh(struct kcopyd_job *job,
			struct buffer_head *bh, int block)
{
	int p;

	/*
	 * Add in the job offset
	 */
	bh->b_blocknr = (job->disk.sector >> job->block_shift) + block;

	p = block >> job->bpp_shift;
	block &= job->bpp_mask;

	bh->b_size = job->block_size;
	set_bh_page(bh, job->pages[p], ((block << job->block_shift) +
					job->offset) << SECTOR_SHIFT);
	bh->b_this_page = bh;

	init_buffer(bh, end_bh, job);

	bh->b_dev = job->disk.dev;
	atomic_set(&bh->b_count, 1);

	bh->b_state = ((1 << BH_Uptodate) | (1 << BH_Mapped) |
		       (1 << BH_Lock) | (1 << BH_Req));

	if (job->rw == WRITE)
		clear_bit(BH_Dirty, &bh->b_state);

	submit_bh(job->rw, bh);
}

/*
 * These three functions process 1 item from the corresponding
 * job list.
 *
 * They return:
 * < 0: error
 *   0: success
 * > 0: can't process yet.
 */
static int run_complete_job(struct kcopyd_job *job)
{
	job->callback(job);
	return 0;
}

/*
 * Request io on as many buffer heads as we can currently get for
 * a particular job.
 */
static int run_io_job(struct kcopyd_job *job)
{
	unsigned int block;
	struct buffer_head *bh;

	for (block = atomic_read(&job->nr_requested);
	     block < job->nr_blocks; block++) {
		bh = alloc_buffer();
		if (!bh)
			break;

		atomic_inc(&job->nr_requested);
		dispatch_bh(job, bh, block);
	}

	return (block == job->nr_blocks) ? 0 : 1;
}

static int run_pages_job(struct kcopyd_job *job)
{
	int r;

	job->nr_pages = (job->disk.count + job->offset) /
	    (PAGE_SIZE / SECTOR_SIZE);
	r = kcopyd_get_pages(job->nr_pages, job->pages);

	if (!r) {
		/* this job is ready for io */
		push(&_io_jobs, job);
		return 0;
	}

	if (r == -ENOMEM)
		/* can't complete now */
		return 1;

	return r;
}

/*
 * Run through a list for as long as possible.  Returns the count
 * of successful jobs.
 */
static int process_jobs(struct list_head *jobs, int (*fn) (struct kcopyd_job *))
{
	struct kcopyd_job *job;
	int r, count = 0;

	while ((job = pop(jobs))) {

		r = fn(job);

		if (r < 0) {
			/* error this rogue job */
			job->err = r;
			push(&_complete_jobs, job);
			break;
		}

		if (r > 0) {
			/*
			 * We couldn't service this job ATM, so
			 * push this job back onto the list.
			 */
			push(jobs, job);
			break;
		}

		count++;
	}

	return count;
}

/*
 * kcopyd does this every time it's woken up.
 */
static void do_work(void)
{
	int count;

	/*
	 * We loop round until there is no more work to do.
	 */
	do {
		count = process_jobs(&_complete_jobs, run_complete_job);
		count += process_jobs(&_io_jobs, run_io_job);
		count += process_jobs(&_pages_jobs, run_pages_job);

	} while (count);

	run_task_queue(&tq_disk);
}

/*-----------------------------------------------------------------
 * The daemon
 *---------------------------------------------------------------*/
static atomic_t _kcopyd_must_die;
static DECLARE_MUTEX(_run_lock);
static DECLARE_WAIT_QUEUE_HEAD(_job_queue);

static int kcopyd(void *arg)
{
	DECLARE_WAITQUEUE(wq, current);

	daemonize();
	strcpy(current->comm, "kcopyd");
	atomic_set(&_kcopyd_must_die, 0);

	add_wait_queue(&_job_queue, &wq);

	down(&_run_lock);
	up(&start_lock);

	while (1) {
		set_current_state(TASK_INTERRUPTIBLE);

		if (atomic_read(&_kcopyd_must_die))
			break;

		do_work();
		schedule();
	}

	set_current_state(TASK_RUNNING);
	remove_wait_queue(&_job_queue, &wq);

	up(&_run_lock);

	return 0;
}

static int start_daemon(void)
{
	static pid_t pid = 0;

	down(&start_lock);

	pid = kernel_thread(kcopyd, NULL, 0);
	if (pid <= 0) {
		DMERR("Failed to start kcopyd thread");
		return -EAGAIN;
	}

	/*
	 * wait for the daemon to up this mutex.
	 */
	down(&start_lock);
	up(&start_lock);

	return 0;
}

static int stop_daemon(void)
{
	atomic_set(&_kcopyd_must_die, 1);
	wake_kcopyd();
	down(&_run_lock);
	up(&_run_lock);

	return 0;
}

static void wake_kcopyd(void)
{
	wake_up_interruptible(&_job_queue);
}

static int calc_shift(unsigned int n)
{
	int s;

	for (s = 0; n; s++, n >>= 1)
		;

	return --s;
}

static void calc_block_sizes(struct kcopyd_job *job)
{
	job->block_size = get_hardsect_size(job->disk.dev);
	job->block_shift = calc_shift(job->block_size / SECTOR_SIZE);
	job->bpp_shift = PAGE_SHIFT - job->block_shift - SECTOR_SHIFT;
	job->bpp_mask = (1 << job->bpp_shift) - 1;
	job->nr_blocks = job->disk.count >> job->block_shift;
	atomic_set(&job->nr_requested, 0);
	atomic_set(&job->nr_incomplete, job->nr_blocks);
}

int kcopyd_io(struct kcopyd_job *job)
{
	calc_block_sizes(job);
	push(job->pages[0] ? &_io_jobs : &_pages_jobs, job);
	wake_kcopyd();
	return 0;
}

/*-----------------------------------------------------------------
 * The copier is implemented on top of the simpler async io
 * daemon above.
 *---------------------------------------------------------------*/
struct copy_info {
	kcopyd_notify_fn notify;
	void *notify_context;

	struct kcopyd_region to;
};

#define MIN_INFOS 128
static kmem_cache_t *_copy_cache = NULL;
static mempool_t *_copy_pool = NULL;

static int init_copier(void)
{
	_copy_cache = kmem_cache_create("kcopyd-info",
					sizeof(struct copy_info),
					__alignof__(struct copy_info),
					0, NULL, NULL);
	if (!_copy_cache)
		return -ENOMEM;

	_copy_pool = mempool_create(MIN_INFOS, mempool_alloc_slab,
				    mempool_free_slab, _copy_cache);
	if (!_copy_pool) {
		kmem_cache_destroy(_copy_cache);
		return -ENOMEM;
	}

	return 0;
}

static void exit_copier(void)
{
	if (_copy_pool)
		mempool_destroy(_copy_pool);

	if (_copy_cache)
		kmem_cache_destroy(_copy_cache);
}

static inline struct copy_info *alloc_copy_info(void)
{
	return mempool_alloc(_copy_pool, GFP_NOIO);
}

static inline void free_copy_info(struct copy_info *info)
{
	mempool_free(info, _copy_pool);
}

void copy_complete(struct kcopyd_job *job)
{
	struct copy_info *info = (struct copy_info *) job->context;

	if (info->notify)
		info->notify(job->err, info->notify_context);

	free_copy_info(info);

	kcopyd_free_pages(job->nr_pages, job->pages);

	kcopyd_free_job(job);
}

static void page_write_complete(struct kcopyd_job *job)
{
	struct copy_info *info = (struct copy_info *) job->context;
	int i;

	if (info->notify)
		info->notify(job->err, info->notify_context);

	free_copy_info(info);
	for (i = 0; i < job->nr_pages; i++)
		put_page(job->pages[i]);

	kcopyd_free_job(job);
}

/*
 * These callback functions implement the state machine that copies regions.
 */
void copy_write(struct kcopyd_job *job)
{
	struct copy_info *info = (struct copy_info *) job->context;

	if (job->err) {
		if (info->notify)
			info->notify(job->err, job->context);

		kcopyd_free_job(job);
		free_copy_info(info);
		return;
	}

	job->rw = WRITE;
	memcpy(&job->disk, &info->to, sizeof(job->disk));
	job->callback = copy_complete;

	/*
	 * Queue the write.
	 */
	kcopyd_io(job);
}

int kcopyd_write_pages(struct kcopyd_region *to, int nr_pages,
		       struct page **pages, int offset, kcopyd_notify_fn fn,
		       void *context)
{
	struct copy_info *info;
	struct kcopyd_job *job;
	int i;

	/*
	 * Allocate a new copy_info.
	 */
	info = alloc_copy_info();
	if (!info)
		return -ENOMEM;

	job = kcopyd_alloc_job();
	if (!job) {
		free_copy_info(info);
		return -ENOMEM;
	}

	/*
	 * set up for the write.
	 */
	info->notify = fn;
	info->notify_context = context;
	memcpy(&info->to, to, sizeof(*to));

	/* Get the pages */
	job->nr_pages = nr_pages;
	for (i = 0; i < nr_pages; i++) {
		get_page(pages[i]);
		job->pages[i] = pages[i];
	}

	job->rw = WRITE;

	memcpy(&job->disk, &info->to, sizeof(job->disk));
	job->offset = offset;
	job->callback = page_write_complete;
	job->context = info;

	/*
	 * Trigger job.
	 */
	kcopyd_io(job);
	return 0;
}

int kcopyd_copy(struct kcopyd_region *from, struct kcopyd_region *to,
		kcopyd_notify_fn fn, void *context)
{
	struct copy_info *info;
	struct kcopyd_job *job;

	/*
	 * Allocate a new copy_info.
	 */
	info = alloc_copy_info();
	if (!info)
		return -ENOMEM;

	job = kcopyd_alloc_job();
	if (!job) {
		free_copy_info(info);
		return -ENOMEM;
	}

	/*
	 * set up for the read.
	 */
	info->notify = fn;
	info->notify_context = context;
	memcpy(&info->to, to, sizeof(*to));

	job->rw = READ;
	memcpy(&job->disk, from, sizeof(*from));

	job->offset = 0;
	job->callback = copy_write;
	job->context = info;

	/*
	 * Trigger job.
	 */
	kcopyd_io(job);
	return 0;
}

/*-----------------------------------------------------------------
 * Unit setup
 *---------------------------------------------------------------*/
static struct {
	int (*init) (void);
	void (*exit) (void);

} _inits[] = {
#define xx(n) { init_ ## n, exit_ ## n}
	xx(pages),
	xx(buffers),
	xx(jobs),
	xx(copier)
#undef xx
};

static int _client_count = 0;
static DECLARE_MUTEX(_client_count_sem);

static int kcopyd_init(void)
{
	const int count = sizeof(_inits) / sizeof(*_inits);

	int r, i;

	for (i = 0; i < count; i++) {
		r = _inits[i].init();
		if (r)
			goto bad;
	}

	start_daemon();
	return 0;

      bad:
	while (i--)
		_inits[i].exit();

	return r;
}

static void kcopyd_exit(void)
{
	int i = sizeof(_inits) / sizeof(*_inits);

	if (stop_daemon())
		DMWARN("Couldn't stop kcopyd.");

	while (i--)
		_inits[i].exit();
}

void kcopyd_inc_client_count(void)
{
	/*
	 * What I need here is an atomic_test_and_inc that returns
	 * the previous value of the atomic...  In its absence I lock
	 * an int with a semaphore. :-(
	 */
	down(&_client_count_sem);
	if (_client_count == 0)
		kcopyd_init();
	_client_count++;

	up(&_client_count_sem);
}

void kcopyd_dec_client_count(void)
{
	down(&_client_count_sem);
	if (--_client_count == 0)
		kcopyd_exit();

	up(&_client_count_sem);
}




/*
 * Copyright (C) 2001 Sistina Software
 *
 * This file is released under the GPL.
 */

#ifndef DM_KCOPYD_H
#define DM_KCOPYD_H

/*
 * Needed for the definition of offset_t.
 */
#include <linux/device-mapper.h>
#include <linux/iobuf.h>

struct kcopyd_region {
	kdev_t dev;
	sector_t sector;
	sector_t count;
};

#define MAX_KCOPYD_PAGES 128

struct kcopyd_job {
	struct list_head list;

	/*
	 * Error state of the job.
	 */
	int err;

	/*
	 * Either READ or WRITE
	 */
	int rw;

	/*
	 * The source or destination for the transfer.
	 */
	struct kcopyd_region disk;

	int nr_pages;
	struct page *pages[MAX_KCOPYD_PAGES];

	/*
	 * Shifts and masks that will be useful when dispatching
	 * each buffer_head.
	 */
	sector_t offset;
	sector_t block_size;
	sector_t block_shift;
	sector_t bpp_shift;	/* blocks per page */
	sector_t bpp_mask;

	/*
	 * nr_blocks is how many buffer heads will have to be
	 * displatched to service this job, nr_requested is how
	 * many have been dispatched and nr_complete is how many
	 * have come back.
	 */
	unsigned int nr_blocks;
	atomic_t nr_requested;
	atomic_t nr_incomplete;

	/*
	 * Set this to ensure you are notified when the job has
	 * completed.  'context' is for callback to use.
	 */
	void (*callback) (struct kcopyd_job * job);
	void *context;
};

/*
 * Low level async io routines.
 */
struct kcopyd_job *kcopyd_alloc_job(void);
void kcopyd_free_job(struct kcopyd_job *job);

int kcopyd_queue_job(struct kcopyd_job *job);

/*
 * Submit a copy job to kcopyd.  This is built on top of the
 * previous three fns.
 */
typedef void (*kcopyd_notify_fn) (int err, void *context);

int kcopyd_copy(struct kcopyd_region *from, struct kcopyd_region *to,
		kcopyd_notify_fn fn, void *context);

int kcopyd_write_pages(struct kcopyd_region *to, int nr_pages,
		       struct page **pages, int offset, kcopyd_notify_fn fn,
		       void *context);

/*
 * We only want kcopyd to reserve resources if someone is
 * actually using it.
 */
void kcopyd_inc_client_count(void);
void kcopyd_dec_client_count(void);

#endif




void buffer_insert_inode_queue(struct buffer_head *bh, struct inode *inode)
{
	spin_lock(&lru_list_lock);
	if (buffer_inode(bh))
		list_del(&bh->b_inode_buffers);
	else
		set_buffer_inode(bh);
	list_add(&bh->b_inode_buffers, &inode->i_dirty_buffers);
	spin_unlock(&lru_list_lock);
}

void buffer_insert_inode_data_queue(struct buffer_head *bh, struct inode *inode)
{
	spin_lock(&lru_list_lock);
	if (buffer_inode(bh))
		list_del(&bh->b_inode_buffers);
	else
		set_buffer_inode(bh);
	list_add(&bh->b_inode_buffers, &inode->i_dirty_data_buffers);
	spin_unlock(&lru_list_lock);
}

   remove_inode_queue functions.  */
static void __remove_inode_queue(struct buffer_head *bh)
{
	clear_buffer_inode(bh);
	list_del(&bh->b_inode_buffers);
}

static inline void remove_inode_queue(struct buffer_head *bh)
{
	if (buffer_inode(bh))
		__remove_inode_queue(bh);
}


	bh->b_list = BUF_CLEAN;
	bh->b_end_io = handler;
	bh->b_private = private;
	bh->b_journal_head = NULL;
}

static void end_buffer_io_async(struct buffer_head * bh, int uptodate)

		bh = BH_ENTRY(list->next);
		list_del(&bh->b_inode_buffers);
		if (!buffer_dirty(bh) && !buffer_locked(bh))
			clear_buffer_inode(bh);
		else {
			set_buffer_inode(bh);
			list_add(&bh->b_inode_buffers, &tmp.i_dirty_buffers);
			if (buffer_dirty(bh)) {
				get_bh(bh);

 */
static void __put_unused_buffer_head(struct buffer_head * bh)
{
	if (buffer_inode(bh))
		BUG();
	if (nr_unused_buffer_heads >= MAX_UNUSED_BUFFERS) {
		kmem_cache_free(bh_cachep, bh);




 *
 * Whenever a buffer has an attached journal_head, its ->b_state:BH_JBD bit
 * is set.  This bit is tested in core kernel code where we need to take
 * JBD-specific actions.  Testing the zeroness of ->b_journal_head is not
 * reliable there.
 *
 * When a buffer has its BH_JBD bit set, its ->b_count is elevated by one.
 *


		if (buffer_jbd(bh)) {
			/* Someone did it for us! */
			J_ASSERT_BH(bh, bh->b_journal_head != NULL);
			journal_free_journal_head(jh);
			jh = bh->b_journal_head;
		} else {
			/*
			 * We actually don't need jh_splice_lock when

			 */
			spin_lock(&jh_splice_lock);
			set_bit(BH_JBD, &bh->b_state);
			bh->b_journal_head = jh;
			jh->b_bh = bh;
			atomic_inc(&bh->b_count);
			spin_unlock(&jh_splice_lock);

	}
	jh->b_jcount++;
	spin_unlock(&journal_datalist_lock);
	return bh->b_journal_head;
}

/*

			J_ASSERT_BH(bh, jh2bh(jh) == bh);
			BUFFER_TRACE(bh, "remove journal_head");
			spin_lock(&jh_splice_lock);
			bh->b_journal_head = NULL;
			jh->b_bh = NULL;	/* debug, really */
			clear_bit(BH_JBD, &bh->b_state);
			__brelse(bh);




/*
 * Copyright (C) 2001 Sistina Software (UK) Limited.
 *
 * This file is released under the LGPL.
 */

#ifndef _LINUX_DEVICE_MAPPER_H
#define _LINUX_DEVICE_MAPPER_H

typedef unsigned long sector_t;

struct dm_target;
struct dm_table;
struct dm_dev;

typedef enum { STATUSTYPE_INFO, STATUSTYPE_TABLE } status_type_t;

/*
 * In the constructor the target parameter will already have the
 * table, type, begin and len fields filled in.
 */
typedef int (*dm_ctr_fn) (struct dm_target * target, int argc, char **argv);

/*
 * The destructor doesn't need to free the dm_target, just
 * anything hidden ti->private.
 */
typedef void (*dm_dtr_fn) (struct dm_target * ti);

/*
 * The map function must return:
 * < 0: error
 * = 0: The target will handle the io by resubmitting it later
 * > 0: simple remap complete
 */
typedef int (*dm_map_fn) (struct dm_target * ti, struct buffer_head * bh,
			  int rw, void **map_context);

/*
 * Returns:
 * < 0 : error (currently ignored)
 * 0   : ended successfully
 * 1   : for some reason the io has still not completed (eg,
 *       multipath target might want to requeue a failed io).
 */
typedef int (*dm_endio_fn) (struct dm_target * ti,
			    struct buffer_head * bh, int rw, int error,
			    void *map_context);
typedef int (*dm_status_fn) (struct dm_target * ti, status_type_t status_type,
			     char *result, int maxlen);

void dm_error(const char *message);

/*
 * Constructors should call these functions to ensure destination devices
 * are opened/closed correctly.
 * FIXME: too many arguments.
 */
int dm_get_device(struct dm_target *ti, const char *path, sector_t start,
		  sector_t len, int mode, struct dm_dev **result);
void dm_put_device(struct dm_target *ti, struct dm_dev *d);

/*
 * Information about a target type
 */
struct target_type {
	const char *name;
	struct module *module;
	dm_ctr_fn ctr;
	dm_dtr_fn dtr;
	dm_map_fn map;
	dm_endio_fn end_io;
	dm_status_fn status;
};

struct dm_target {
	struct dm_table *table;
	struct target_type *type;

	/* target limits */
	sector_t begin;
	sector_t len;

	/* target specific data */
	void *private;

	/* Used to provide an error string from the ctr */
	char *error;
};

int dm_register_target(struct target_type *t);
int dm_unregister_target(struct target_type *t);

#endif				/* _LINUX_DEVICE_MAPPER_H */




/*
 * Copyright (C) 2001 Sistina Software (UK) Limited.
 *
 * This file is released under the LGPL.
 */

#ifndef _LINUX_DM_IOCTL_H
#define _LINUX_DM_IOCTL_H

#include <linux/types.h>

#define DM_DIR "mapper"		/* Slashes not supported */
#define DM_MAX_TYPE_NAME 16
#define DM_NAME_LEN 128
#define DM_UUID_LEN 129

/*
 * Implements a traditional ioctl interface to the device mapper.
 */

/*
 * All ioctl arguments consist of a single chunk of memory, with
 * this structure at the start.  If a uuid is specified any
 * lookup (eg. for a DM_INFO) will be done on that, *not* the
 * name.
 */
struct dm_ioctl {
	/*
	 * The version number is made up of three parts:
	 * major - no backward or forward compatibility,
	 * minor - only backwards compatible,
	 * patch - both backwards and forwards compatible.
	 *
	 * All clients of the ioctl interface should fill in the
	 * version number of the interface that they were
	 * compiled with.
	 *
	 * All recognised ioctl commands (ie. those that don't
	 * return -ENOTTY) fill out this field, even if the
	 * command failed.
	 */
	uint32_t version[3];	/* in/out */
	uint32_t data_size;	/* total size of data passed in
				 * including this struct */

	uint32_t data_start;	/* offset to start of data
				 * relative to start of this struct */

	uint32_t target_count;	/* in/out */
	uint32_t open_count;	/* out */
	uint32_t flags;		/* in/out */

	__kernel_dev_t dev;	/* in/out */

	char name[DM_NAME_LEN];	/* device name */
	char uuid[DM_UUID_LEN];	/* unique identifier for
				 * the block device */
};

/*
 * Used to specify tables.  These structures appear after the
 * dm_ioctl.
 */
struct dm_target_spec {
	int32_t status;		/* used when reading from kernel only */
	uint64_t sector_start;
	uint32_t length;

	/*
	 * Offset in bytes (from the start of this struct) to
	 * next target_spec.
	 */
	uint32_t next;

	char target_type[DM_MAX_TYPE_NAME];

	/*
	 * Parameter string starts immediately after this object.
	 * Be careful to add padding after string to ensure correct
	 * alignment of subsequent dm_target_spec.
	 */
};

/*
 * Used to retrieve the target dependencies.
 */
struct dm_target_deps {
	uint32_t count;

	__kernel_dev_t dev[0];	/* out */
};

/*
 * If you change this make sure you make the corresponding change
 * to dm-ioctl.c:lookup_ioctl()
 */
enum {
	/* Top level cmds */
	DM_VERSION_CMD = 0,
	DM_REMOVE_ALL_CMD,

	/* device level cmds */
	DM_DEV_CREATE_CMD,
	DM_DEV_REMOVE_CMD,
	DM_DEV_RELOAD_CMD,
	DM_DEV_RENAME_CMD,
	DM_DEV_SUSPEND_CMD,
	DM_DEV_DEPS_CMD,
	DM_DEV_STATUS_CMD,

	/* target level cmds */
	DM_TARGET_STATUS_CMD,
	DM_TARGET_WAIT_CMD
};

#define DM_IOCTL 0xfd

#define DM_VERSION       _IOWR(DM_IOCTL, DM_VERSION_CMD, struct dm_ioctl)
#define DM_REMOVE_ALL    _IOWR(DM_IOCTL, DM_REMOVE_ALL_CMD, struct dm_ioctl)

#define DM_DEV_CREATE    _IOWR(DM_IOCTL, DM_DEV_CREATE_CMD, struct dm_ioctl)
#define DM_DEV_REMOVE    _IOWR(DM_IOCTL, DM_DEV_REMOVE_CMD, struct dm_ioctl)
#define DM_DEV_RELOAD    _IOWR(DM_IOCTL, DM_DEV_RELOAD_CMD, struct dm_ioctl)
#define DM_DEV_SUSPEND   _IOWR(DM_IOCTL, DM_DEV_SUSPEND_CMD, struct dm_ioctl)
#define DM_DEV_RENAME    _IOWR(DM_IOCTL, DM_DEV_RENAME_CMD, struct dm_ioctl)
#define DM_DEV_DEPS      _IOWR(DM_IOCTL, DM_DEV_DEPS_CMD, struct dm_ioctl)
#define DM_DEV_STATUS    _IOWR(DM_IOCTL, DM_DEV_STATUS_CMD, struct dm_ioctl)

#define DM_TARGET_STATUS _IOWR(DM_IOCTL, DM_TARGET_STATUS_CMD, struct dm_ioctl)
#define DM_TARGET_WAIT   _IOWR(DM_IOCTL, DM_TARGET_WAIT_CMD, struct dm_ioctl)

#define DM_VERSION_MAJOR	1
#define DM_VERSION_MINOR	0
#define DM_VERSION_PATCHLEVEL	10
#define DM_VERSION_EXTRA	"-ioctl (2003-03-27)"

/* Status bits */
#define DM_READONLY_FLAG	0x00000001
#define DM_SUSPEND_FLAG		0x00000002
#define DM_EXISTS_FLAG		0x00000004
#define DM_PERSISTENT_DEV_FLAG	0x00000008

/*
 * Flag passed into ioctl STATUS command to get table information
 * rather than current status.
 */
#define DM_STATUS_TABLE_FLAG	0x00000010

#endif				/* _LINUX_DM_IOCTL_H */




	BH_Wait_IO,	/* 1 if we should write out this buffer */
	BH_Launder,	/* 1 if we can throttle on this buffer */
	BH_JBD,		/* 1 if it has an attached journal_head */
	BH_Inode,	/* 1 if it is attached to i_dirty[_data]_buffers */

	BH_PrivateStart,/* not a state bit, but the first bit available
			 * for private allocation by other entities

	struct page *b_page;		/* the page this bh is mapped to */
	void (*b_end_io)(struct buffer_head *bh, int uptodate); /* I/O completion */
 	void *b_private;		/* reserved for b_end_io */
 	void *b_journal_head;		/* ext3 journal_heads */
	unsigned long b_rsector;	/* Real buffer location on disk */
	wait_queue_head_t b_wait;

	struct inode *	     b_inode;
	struct list_head     b_inode_buffers;	/* doubly linked list of inode dirty buffers */
};


		clear_bit(BH_Async, &bh->b_state);
}

static inline void set_buffer_inode(struct buffer_head *bh)
{
	set_bit(BH_Inode, &bh->b_state);
}

static inline void clear_buffer_inode(struct buffer_head *bh)
{
	clear_bit(BH_Inode, &bh->b_state);
}

static inline int buffer_inode(struct buffer_head *bh)
{
	return test_bit(BH_Inode, &bh->b_state);
}

/*
 * If an error happens during the make_request, this function
 * has to be recalled. It marks the buffer as clean and not

Lines 254-260 Link Here

(-)linux-2.4.20-gentoo-r5/include/linux/jbd.h (-1 / +1 lines)
254		254
255	static inline struct journal_head bh2jh(struct buffer_head bh)	255	static inline struct journal_head bh2jh(struct buffer_head bh)
256	{	256	{
257	return bh->b_private;	257	return bh->b_journal_head;
258	}	258	}
259		259
260	#define HAVE_JOURNAL_CALLBACK_STATUS	260	#define HAVE_JOURNAL_CALLBACK_STATUS




#ifndef _LINUX_MEMPOOL_H
#define _LINUX_MEMPOOL_H

#include <linux/list.h>
#include <linux/wait.h>

typedef void * (mempool_alloc_t)(int gfp_mask, void *pool_data);
typedef void (mempool_free_t)(void *element, void *pool_data);

struct mempool_s;
typedef struct mempool_s {
	spinlock_t lock;
	int min_nr;		/* nr of elements at *elements */

extern void * mempool_alloc(mempool_t *pool, int gfp_mask);
extern void mempool_free(void *element, mempool_t *pool);

/*
 * A mempool_alloc_t and mempool_free_t that get the memory from
 * a slab that is passed in through pool_data.
 */
void *mempool_alloc_slab(int gfp_mask, void *pool_data);
void mempool_free_slab(void *element, void *pool_data);

#endif /* _LINUX_MEMPOOL_H */

Lines 26-31 Link Here

(-)linux-2.4.20-gentoo-r5/include/linux/vmalloc.h (+1 lines)
26	extern void vmfree_area_pages(unsigned long address, unsigned long size);	26	extern void vmfree_area_pages(unsigned long address, unsigned long size);
27	extern int vmalloc_area_pages(unsigned long address, unsigned long size,	27	extern int vmalloc_area_pages(unsigned long address, unsigned long size,
28	int gfp_mask, pgprot_t prot);	28	int gfp_mask, pgprot_t prot);
		29	extern void *vcalloc(unsigned long nmemb, unsigned long elem_size);
29		30
30	/*	31	/*
31	* Allocate any pages	32	* Allocate any pages

Lines 116-121 Link Here

(-)linux-2.4.20-gentoo-r5/kernel/ksyms.c (+1 lines)
116	EXPORT_SYMBOL(vfree);	116	EXPORT_SYMBOL(vfree);
117	EXPORT_SYMBOL(__vmalloc);	117	EXPORT_SYMBOL(__vmalloc);
118	EXPORT_SYMBOL(vmalloc_to_page);	118	EXPORT_SYMBOL(vmalloc_to_page);
		119	EXPORT_SYMBOL(vcalloc);
119	EXPORT_SYMBOL(mem_map);	120	EXPORT_SYMBOL(mem_map);
120	EXPORT_SYMBOL(remap_page_range);	121	EXPORT_SYMBOL(remap_page_range);
121	EXPORT_SYMBOL(max_mapnr);	122	EXPORT_SYMBOL(max_mapnr);




	pool->free(element, pool->pool_data);
}

/*
 * A commonly used alloc and free fn.
 */
void *mempool_alloc_slab(int gfp_mask, void *pool_data)
{
       kmem_cache_t *mem = (kmem_cache_t *) pool_data;
       return kmem_cache_alloc(mem, gfp_mask);
}

void mempool_free_slab(void *element, void *pool_data)
{
       kmem_cache_t *mem = (kmem_cache_t *) pool_data;
       kmem_cache_free(mem, element);
}



EXPORT_SYMBOL(mempool_create);
EXPORT_SYMBOL(mempool_resize);
EXPORT_SYMBOL(mempool_destroy);
EXPORT_SYMBOL(mempool_alloc);
EXPORT_SYMBOL(mempool_free);
EXPORT_SYMBOL(mempool_alloc_slab);
EXPORT_SYMBOL(mempool_free_slab);





	read_unlock(&vmlist_lock);
	return buf - buf_start;
}

void *vcalloc(unsigned long nmemb, unsigned long elem_size)
{
	unsigned long size;
	void *addr;

	/*
	 * Check that we're not going to overflow.
	 */
	if (nmemb > (ULONG_MAX / elem_size))
		return NULL;

	size = nmemb * elem_size;
	addr = vmalloc(size);
	if (addr)
		memset(addr, 0, size);

	return addr;
}

Return to bug 22768

Lines 2048-2053 Link Here

(-)linux-2.4.20-gentoo-r5/Documentation/Configure.help (+14 lines)
2048	want), say M here and read <file:Documentation/modules.txt>. The	2048	want), say M here and read <file:Documentation/modules.txt>. The
2049	module will be called lvm-mod.o.	2049	module will be called lvm-mod.o.
2050		2050
		2051	Device-mapper support
		2052	CONFIG_BLK_DEV_DM
		2053	Device-mapper is a low level volume manager. It works by allowing
		2054	people to specify mappings for ranges of logical sectors. Various
		2055	mapping types are available, in addition people may write their own
		2056	modules containing custom mappings if they wish.
		2057
		2058	Higher level volume managers such as LVM2 use this driver.
		2059
		2060	If you want to compile this as a module, say M here and read
		2061	<file:Documentation/modules.txt>. The module will be called dm-mod.o.
		2062
		2063	If unsure, say N.
		2064
2051	Multiple devices driver support (RAID and LVM)	2065	Multiple devices driver support (RAID and LVM)
2052	CONFIG_MD	2066	CONFIG_MD
2053	Support multiple physical spindles through a single logical device.	2067	Support multiple physical spindles through a single logical device.

Lines 649-657 Link Here

(-)linux-2.4.20-gentoo-r5/fs/buffer.c (-9 / +12 lines)
649	void buffer_insert_inode_queue(struct buffer_head bh, struct inode inode)	649	void buffer_insert_inode_queue(struct buffer_head bh, struct inode inode)
650	{	650	{
651	spin_lock(&lru_list_lock);	651	spin_lock(&lru_list_lock);
652	if (bh->b_inode)	652	if (buffer_inode(bh))
653	list_del(&bh->b_inode_buffers);	653	list_del(&bh->b_inode_buffers);
654	bh->b_inode = inode;	654	else
		655	set_buffer_inode(bh);
655	list_add(&bh->b_inode_buffers, &inode->i_dirty_buffers);	656	list_add(&bh->b_inode_buffers, &inode->i_dirty_buffers);
656	spin_unlock(&lru_list_lock);	657	spin_unlock(&lru_list_lock);
657	}	658	}
Lines 659-667 Link Here
659	void buffer_insert_inode_data_queue(struct buffer_head bh, struct inode inode)	660	void buffer_insert_inode_data_queue(struct buffer_head bh, struct inode inode)
660	{	661	{
661	spin_lock(&lru_list_lock);	662	spin_lock(&lru_list_lock);
662	if (bh->b_inode)	663	if (buffer_inode(bh))
663	list_del(&bh->b_inode_buffers);	664	list_del(&bh->b_inode_buffers);
664	bh->b_inode = inode;	665	else
		666	set_buffer_inode(bh);
665	list_add(&bh->b_inode_buffers, &inode->i_dirty_data_buffers);	667	list_add(&bh->b_inode_buffers, &inode->i_dirty_data_buffers);
666	spin_unlock(&lru_list_lock);	668	spin_unlock(&lru_list_lock);
667	}	669	}
Lines 670-682 Link Here
670	remove_inode_queue functions. */	672	remove_inode_queue functions. */
671	static void __remove_inode_queue(struct buffer_head *bh)	673	static void __remove_inode_queue(struct buffer_head *bh)
672	{	674	{
673	bh->b_inode = NULL;	675	clear_buffer_inode(bh);
674	list_del(&bh->b_inode_buffers);	676	list_del(&bh->b_inode_buffers);
675	}	677	}
676		678
677	static inline void remove_inode_queue(struct buffer_head *bh)	679	static inline void remove_inode_queue(struct buffer_head *bh)
678	{	680	{
679	if (bh->b_inode)	681	if (buffer_inode(bh))
680	__remove_inode_queue(bh);	682	__remove_inode_queue(bh);
681	}	683	}
682		684
Lines 814-819 Link Here
814	bh->b_list = BUF_CLEAN;	816	bh->b_list = BUF_CLEAN;
815	bh->b_end_io = handler;	817	bh->b_end_io = handler;
816	bh->b_private = private;	818	bh->b_private = private;
		819	bh->b_journal_head = NULL;
817	}	820	}
818		821
819	static void end_buffer_io_async(struct buffer_head * bh, int uptodate)	822	static void end_buffer_io_async(struct buffer_head * bh, int uptodate)
Lines 922-930 Link Here
922	bh = BH_ENTRY(list->next);	925	bh = BH_ENTRY(list->next);
923	list_del(&bh->b_inode_buffers);	926	list_del(&bh->b_inode_buffers);
924	if (!buffer_dirty(bh) && !buffer_locked(bh))	927	if (!buffer_dirty(bh) && !buffer_locked(bh))
925	bh->b_inode = NULL;	928	clear_buffer_inode(bh);
926	else {	929	else {
927	bh->b_inode = &tmp;	930	set_buffer_inode(bh);
928	list_add(&bh->b_inode_buffers, &tmp.i_dirty_buffers);	931	list_add(&bh->b_inode_buffers, &tmp.i_dirty_buffers);
929	if (buffer_dirty(bh)) {	932	if (buffer_dirty(bh)) {
930	get_bh(bh);	933	get_bh(bh);
Lines 1251-1257 Link Here
1251	*/	1254	*/
1252	static void __put_unused_buffer_head(struct buffer_head * bh)	1255	static void __put_unused_buffer_head(struct buffer_head * bh)
1253	{	1256	{
1254	if (bh->b_inode)	1257	if (buffer_inode(bh))
1255	BUG();	1258	BUG();
1256	if (nr_unused_buffer_heads >= MAX_UNUSED_BUFFERS) {	1259	if (nr_unused_buffer_heads >= MAX_UNUSED_BUFFERS) {
1257	kmem_cache_free(bh_cachep, bh);	1260	kmem_cache_free(bh_cachep, bh);

Lines 1664-1671 Link Here

(-)linux-2.4.20-gentoo-r5/fs/jbd/journal.c (-7 / +7 lines)
1664	*	1664	*
1665	* Whenever a buffer has an attached journal_head, its ->b_state:BH_JBD bit	1665	* Whenever a buffer has an attached journal_head, its ->b_state:BH_JBD bit
1666	* is set. This bit is tested in core kernel code where we need to take	1666	* is set. This bit is tested in core kernel code where we need to take
1667	* JBD-specific actions. Testing the zeroness of ->b_private is not reliable	1667	* JBD-specific actions. Testing the zeroness of ->b_journal_head is not
1668	* there.	1668	* reliable there.
1669	*	1669	*
1670	* When a buffer has its BH_JBD bit set, its ->b_count is elevated by one.	1670	* When a buffer has its BH_JBD bit set, its ->b_count is elevated by one.
1671	*	1671	*
Lines 1720-1728 Link Here
1720		1720
1721	if (buffer_jbd(bh)) {	1721	if (buffer_jbd(bh)) {
1722	/* Someone did it for us! */	1722	/* Someone did it for us! */
1723	J_ASSERT_BH(bh, bh->b_private != NULL);	1723	J_ASSERT_BH(bh, bh->b_journal_head != NULL);
1724	journal_free_journal_head(jh);	1724	journal_free_journal_head(jh);
1725	jh = bh->b_private;	1725	jh = bh->b_journal_head;
1726	} else {	1726	} else {
1727	/*	1727	/*
1728	* We actually don't need jh_splice_lock when	1728	* We actually don't need jh_splice_lock when
Lines 1730-1736 Link Here
1730	*/	1730	*/
1731	spin_lock(&jh_splice_lock);	1731	spin_lock(&jh_splice_lock);
1732	set_bit(BH_JBD, &bh->b_state);	1732	set_bit(BH_JBD, &bh->b_state);
1733	bh->b_private = jh;	1733	bh->b_journal_head = jh;
1734	jh->b_bh = bh;	1734	jh->b_bh = bh;
1735	atomic_inc(&bh->b_count);	1735	atomic_inc(&bh->b_count);
1736	spin_unlock(&jh_splice_lock);	1736	spin_unlock(&jh_splice_lock);
Lines 1739-1745 Link Here
1739	}	1739	}
1740	jh->b_jcount++;	1740	jh->b_jcount++;
1741	spin_unlock(&journal_datalist_lock);	1741	spin_unlock(&journal_datalist_lock);
1742	return bh->b_private;	1742	return bh->b_journal_head;
1743	}	1743	}
1744		1744
1745	/*	1745	/*
Lines 1772-1778 Link Here
1772	J_ASSERT_BH(bh, jh2bh(jh) == bh);	1772	J_ASSERT_BH(bh, jh2bh(jh) == bh);
1773	BUFFER_TRACE(bh, "remove journal_head");	1773	BUFFER_TRACE(bh, "remove journal_head");
1774	spin_lock(&jh_splice_lock);	1774	spin_lock(&jh_splice_lock);
1775	bh->b_private = NULL;	1775	bh->b_journal_head = NULL;
1776	jh->b_bh = NULL; /* debug, really */	1776	jh->b_bh = NULL; /* debug, really */
1777	clear_bit(BH_JBD, &bh->b_state);	1777	clear_bit(BH_JBD, &bh->b_state);
1778	__brelse(bh);	1778	__brelse(bh);

Lines 223-228 Link Here

(-)linux-2.4.20-gentoo-r5/include/linux/fs.h (-2 / +17 lines)
223	BH_Wait_IO, /* 1 if we should write out this buffer */	223	BH_Wait_IO, /* 1 if we should write out this buffer */
224	BH_Launder, /* 1 if we can throttle on this buffer */	224	BH_Launder, /* 1 if we can throttle on this buffer */
225	BH_JBD, /* 1 if it has an attached journal_head */	225	BH_JBD, /* 1 if it has an attached journal_head */
		226	BH_Inode, /* 1 if it is attached to i_dirty[_data]_buffers */
226		227
227	BH_PrivateStart,/* not a state bit, but the first bit available	228	BH_PrivateStart,/* not a state bit, but the first bit available
228	* for private allocation by other entities	229	* for private allocation by other entities
Lines 265-275 Link Here
265	struct page b_page; / the page this bh is mapped to */	266	struct page b_page; / the page this bh is mapped to */
266	void (b_end_io)(struct buffer_head bh, int uptodate); /* I/O completion */	267	void (b_end_io)(struct buffer_head bh, int uptodate); /* I/O completion */
267	void b_private; / reserved for b_end_io */	268	void b_private; / reserved for b_end_io */
268		269	void b_journal_head; / ext3 journal_heads */
269	unsigned long b_rsector; /* Real buffer location on disk */	270	unsigned long b_rsector; /* Real buffer location on disk */
270	wait_queue_head_t b_wait;	271	wait_queue_head_t b_wait;
271		272
272	struct inode * b_inode;
273	struct list_head b_inode_buffers; /* doubly linked list of inode dirty buffers */	273	struct list_head b_inode_buffers; /* doubly linked list of inode dirty buffers */
274	};	274	};
275		275
Lines 1225-1230 Link Here
1225	clear_bit(BH_Async, &bh->b_state);	1225	clear_bit(BH_Async, &bh->b_state);
1226	}	1226	}
1227		1227
		1228	static inline void set_buffer_inode(struct buffer_head *bh)
		1229	{
		1230	set_bit(BH_Inode, &bh->b_state);
		1231	}
		1232
		1233	static inline void clear_buffer_inode(struct buffer_head *bh)
		1234	{
		1235	clear_bit(BH_Inode, &bh->b_state);
		1236	}
		1237
		1238	static inline int buffer_inode(struct buffer_head *bh)
		1239	{
		1240	return test_bit(BH_Inode, &bh->b_state);
		1241	}
		1242
1228	/*	1243	/*
1229	* If an error happens during the make_request, this function	1244	* If an error happens during the make_request, this function
1230	* has to be recalled. It marks the buffer as clean and not	1245	* has to be recalled. It marks the buffer as clean and not

Lines 266-273 Link Here

(-)linux-2.4.20-gentoo-r5/mm/mempool.c (+20 lines)
266	pool->free(element, pool->pool_data);	266	pool->free(element, pool->pool_data);
267	}	267	}
268		268
		269	/*
		270	* A commonly used alloc and free fn.
		271	*/
		272	void mempool_alloc_slab(int gfp_mask, void pool_data)
		273	{
		274	kmem_cache_t mem = (kmem_cache_t ) pool_data;
		275	return kmem_cache_alloc(mem, gfp_mask);
		276	}
		277
		278	void mempool_free_slab(void element, void pool_data)
		279	{
		280	kmem_cache_t mem = (kmem_cache_t ) pool_data;
		281	kmem_cache_free(mem, element);
		282	}
		283
		284
		285
269	EXPORT_SYMBOL(mempool_create);	286	EXPORT_SYMBOL(mempool_create);
270	EXPORT_SYMBOL(mempool_resize);	287	EXPORT_SYMBOL(mempool_resize);
271	EXPORT_SYMBOL(mempool_destroy);	288	EXPORT_SYMBOL(mempool_destroy);
272	EXPORT_SYMBOL(mempool_alloc);	289	EXPORT_SYMBOL(mempool_alloc);
273	EXPORT_SYMBOL(mempool_free);	290	EXPORT_SYMBOL(mempool_free);
		291	EXPORT_SYMBOL(mempool_alloc_slab);
		292	EXPORT_SYMBOL(mempool_free_slab);
		293

Lines 33-38 Link Here

(-)linux-2.4.20-gentoo-r5/arch/mips64/kernel/ioctl32.c (+15 lines)
33	#include <linux/auto_fs.h>	33	#include <linux/auto_fs.h>
34	#include <linux/ext2_fs.h>	34	#include <linux/ext2_fs.h>
35	#include <linux/raid/md_u.h>	35	#include <linux/raid/md_u.h>
		36	#include <linux/dm-ioctl.h>
36		37
37	#include <scsi/scsi.h>	38	#include <scsi/scsi.h>
38	#undef __KERNEL__ /* This file was born to be ugly ... */	39	#undef __KERNEL__ /* This file was born to be ugly ... */
Lines 915-920 Link Here
915	IOCTL32_DEFAULT(RESTART_ARRAY_RW),	916	IOCTL32_DEFAULT(RESTART_ARRAY_RW),
916	#endif /* CONFIG_MD */	917	#endif /* CONFIG_MD */
917		918
		919	#if defined(CONFIG_BLK_DEV_DM) \|\| defined(CONFIG_BLK_DEV_DM_MODULE)
		920	IOCTL32_DEFAULT(DM_VERSION),
		921	IOCTL32_DEFAULT(DM_REMOVE_ALL),
		922	IOCTL32_DEFAULT(DM_DEV_CREATE),
		923	IOCTL32_DEFAULT(DM_DEV_REMOVE),
		924	IOCTL32_DEFAULT(DM_DEV_RELOAD),
		925	IOCTL32_DEFAULT(DM_DEV_SUSPEND),
		926	IOCTL32_DEFAULT(DM_DEV_RENAME),
		927	IOCTL32_DEFAULT(DM_DEV_DEPS),
		928	IOCTL32_DEFAULT(DM_DEV_STATUS),
		929	IOCTL32_DEFAULT(DM_TARGET_STATUS),
		930	IOCTL32_DEFAULT(DM_TARGET_WAIT),
		931	#endif /* CONFIG_BLK_DEV_DM */
		932
918	IOCTL32_DEFAULT(MTIOCTOP), /* mtio.h ioctls */	933	IOCTL32_DEFAULT(MTIOCTOP), /* mtio.h ioctls */
919	IOCTL32_HANDLER(MTIOCGET32, mt_ioctl_trans),	934	IOCTL32_HANDLER(MTIOCGET32, mt_ioctl_trans),
920	IOCTL32_HANDLER(MTIOCPOS32, mt_ioctl_trans),	935	IOCTL32_HANDLER(MTIOCPOS32, mt_ioctl_trans),

Lines 55-60 Link Here

(-)linux-2.4.20-gentoo-r5/arch/parisc/kernel/ioctl32.c (+15 lines)
55	#define max max */	55	#define max max */
56	#include <linux/lvm.h>	56	#include <linux/lvm.h>
57	#endif /* LVM */	57	#endif /* LVM */
		58	#include <linux/dm-ioctl.h>
58		59
59	#include <scsi/scsi.h>	60	#include <scsi/scsi.h>
60	/* Ugly hack. */	61	/* Ugly hack. */
Lines 3419-3424 Link Here
3419	COMPATIBLE_IOCTL(LV_BMAP)	3420	COMPATIBLE_IOCTL(LV_BMAP)
3420	COMPATIBLE_IOCTL(LV_SNAPSHOT_USE_RATE)	3421	COMPATIBLE_IOCTL(LV_SNAPSHOT_USE_RATE)
3421	#endif /* LVM */	3422	#endif /* LVM */
		3423	/* Device-Mapper */
		3424	#if defined(CONFIG_BLK_DEV_DM) \|\| defined(CONFIG_BLK_DEV_DM_MODULE)
		3425	COMPATIBLE_IOCTL(DM_VERSION)
		3426	COMPATIBLE_IOCTL(DM_REMOVE_ALL)
		3427	COMPATIBLE_IOCTL(DM_DEV_CREATE)
		3428	COMPATIBLE_IOCTL(DM_DEV_REMOVE)
		3429	COMPATIBLE_IOCTL(DM_DEV_RELOAD)
		3430	COMPATIBLE_IOCTL(DM_DEV_SUSPEND)
		3431	COMPATIBLE_IOCTL(DM_DEV_RENAME)
		3432	COMPATIBLE_IOCTL(DM_DEV_DEPS)
		3433	COMPATIBLE_IOCTL(DM_DEV_STATUS)
		3434	COMPATIBLE_IOCTL(DM_TARGET_STATUS)
		3435	COMPATIBLE_IOCTL(DM_TARGET_WAIT)
		3436	#endif /* CONFIG_BLK_DEV_DM */
3422	#if defined(CONFIG_DRM) \|\| defined(CONFIG_DRM_MODULE)	3437	#if defined(CONFIG_DRM) \|\| defined(CONFIG_DRM_MODULE)
3423	COMPATIBLE_IOCTL(DRM_IOCTL_GET_MAGIC)	3438	COMPATIBLE_IOCTL(DRM_IOCTL_GET_MAGIC)
3424	COMPATIBLE_IOCTL(DRM_IOCTL_IRQ_BUSID)	3439	COMPATIBLE_IOCTL(DRM_IOCTL_IRQ_BUSID)

Lines 66-71 Link Here

(-)linux-2.4.20-gentoo-r5/arch/ppc64/kernel/ioctl32.c (+15 lines)
66	#if defined(CONFIG_BLK_DEV_LVM) \|\| defined(CONFIG_BLK_DEV_LVM_MODULE)	66	#if defined(CONFIG_BLK_DEV_LVM) \|\| defined(CONFIG_BLK_DEV_LVM_MODULE)
67	#include <linux/lvm.h>	67	#include <linux/lvm.h>
68	#endif /* LVM */	68	#endif /* LVM */
		69	#include <linux/dm-ioctl.h>
69		70
70	#include <scsi/scsi.h>	71	#include <scsi/scsi.h>
71	/* Ugly hack. */	72	/* Ugly hack. */
Lines 4366-4371 Link Here
4366	COMPATIBLE_IOCTL(NBD_PRINT_DEBUG),	4367	COMPATIBLE_IOCTL(NBD_PRINT_DEBUG),
4367	COMPATIBLE_IOCTL(NBD_SET_SIZE_BLOCKS),	4368	COMPATIBLE_IOCTL(NBD_SET_SIZE_BLOCKS),
4368	COMPATIBLE_IOCTL(NBD_DISCONNECT),	4369	COMPATIBLE_IOCTL(NBD_DISCONNECT),
		4370	/* device-mapper */
		4371	#if defined(CONFIG_BLK_DEV_DM) \|\| defined(CONFIG_BLK_DEV_DM_MODULE)
		4372	COMPATIBLE_IOCTL(DM_VERSION),
		4373	COMPATIBLE_IOCTL(DM_REMOVE_ALL),
		4374	COMPATIBLE_IOCTL(DM_DEV_CREATE),
		4375	COMPATIBLE_IOCTL(DM_DEV_REMOVE),
		4376	COMPATIBLE_IOCTL(DM_DEV_RELOAD),
		4377	COMPATIBLE_IOCTL(DM_DEV_SUSPEND),
		4378	COMPATIBLE_IOCTL(DM_DEV_RENAME),
		4379	COMPATIBLE_IOCTL(DM_DEV_DEPS),
		4380	COMPATIBLE_IOCTL(DM_DEV_STATUS),
		4381	COMPATIBLE_IOCTL(DM_TARGET_STATUS),
		4382	COMPATIBLE_IOCTL(DM_TARGET_WAIT),
		4383	#endif /* CONFIG_BLK_DEV_DM */
4369	/* Remove PRIVATE in 2.5 /	4384	/* Remove PRIVATE in 2.5 /
4370	COMPATIBLE_IOCTL(SIOCDEVPRIVATE),	4385	COMPATIBLE_IOCTL(SIOCDEVPRIVATE),
4371	COMPATIBLE_IOCTL(SIOCDEVPRIVATE+1),	4386	COMPATIBLE_IOCTL(SIOCDEVPRIVATE+1),

Lines 25-30 Link Here

(-)linux-2.4.20-gentoo-r5/arch/s390x/kernel/ioctl32.c (+13 lines)
25	#include <linux/ext2_fs.h>	25	#include <linux/ext2_fs.h>
26	#include <linux/hdreg.h>	26	#include <linux/hdreg.h>
27	#include <linux/if_bonding.h>	27	#include <linux/if_bonding.h>
		28	#include <linux/dm-ioctl.h>
28	#include <asm/types.h>	29	#include <asm/types.h>
29	#include <asm/uaccess.h>	30	#include <asm/uaccess.h>
30	#include <asm/dasd.h>	31	#include <asm/dasd.h>
Lines 508-513 Link Here
508		509
509	IOCTL32_DEFAULT(SIOCGSTAMP),	510	IOCTL32_DEFAULT(SIOCGSTAMP),
510		511
		512	IOCTL32_DEFAULT(DM_VERSION),
		513	IOCTL32_DEFAULT(DM_REMOVE_ALL),
		514	IOCTL32_DEFAULT(DM_DEV_CREATE),
		515	IOCTL32_DEFAULT(DM_DEV_REMOVE),
		516	IOCTL32_DEFAULT(DM_DEV_RELOAD),
		517	IOCTL32_DEFAULT(DM_DEV_SUSPEND),
		518	IOCTL32_DEFAULT(DM_DEV_RENAME),
		519	IOCTL32_DEFAULT(DM_DEV_DEPS),
		520	IOCTL32_DEFAULT(DM_DEV_STATUS),
		521	IOCTL32_DEFAULT(DM_TARGET_STATUS),
		522	IOCTL32_DEFAULT(DM_TARGET_WAIT),
		523
511	IOCTL32_HANDLER(SIOCGIFNAME, dev_ifname32),	524	IOCTL32_HANDLER(SIOCGIFNAME, dev_ifname32),
512	IOCTL32_HANDLER(SIOCGIFCONF, dev_ifconf),	525	IOCTL32_HANDLER(SIOCGIFCONF, dev_ifconf),
513	IOCTL32_HANDLER(SIOCGIFFLAGS, dev_ifsioc),	526	IOCTL32_HANDLER(SIOCGIFFLAGS, dev_ifsioc),

Lines 55-60 Link Here

(-)linux-2.4.20-gentoo-r5/arch/sparc64/kernel/ioctl32.c (+16 lines)
55	#if defined(CONFIG_BLK_DEV_LVM) \|\| defined(CONFIG_BLK_DEV_LVM_MODULE)	55	#if defined(CONFIG_BLK_DEV_LVM) \|\| defined(CONFIG_BLK_DEV_LVM_MODULE)
56	#include <linux/lvm.h>	56	#include <linux/lvm.h>
57	#endif /* LVM */	57	#endif /* LVM */
		58	#include <linux/dm-ioctl.h>
58		59
59	#include <scsi/scsi.h>	60	#include <scsi/scsi.h>
60	/* Ugly hack. */	61	/* Ugly hack. */
Lines 5131-5136 Link Here
5131	COMPATIBLE_IOCTL(NBD_PRINT_DEBUG)	5132	COMPATIBLE_IOCTL(NBD_PRINT_DEBUG)
5132	COMPATIBLE_IOCTL(NBD_SET_SIZE_BLOCKS)	5133	COMPATIBLE_IOCTL(NBD_SET_SIZE_BLOCKS)
5133	COMPATIBLE_IOCTL(NBD_DISCONNECT)	5134	COMPATIBLE_IOCTL(NBD_DISCONNECT)
		5135	/* device-mapper */
		5136	#if defined(CONFIG_BLK_DEV_DM) \|\| defined(CONFIG_BLK_DEV_DM_MODULE)
		5137	COMPATIBLE_IOCTL(DM_VERSION)
		5138	COMPATIBLE_IOCTL(DM_REMOVE_ALL)
		5139	COMPATIBLE_IOCTL(DM_DEV_CREATE)
		5140	COMPATIBLE_IOCTL(DM_DEV_REMOVE)
		5141	COMPATIBLE_IOCTL(DM_DEV_RELOAD)
		5142	COMPATIBLE_IOCTL(DM_DEV_SUSPEND)
		5143	COMPATIBLE_IOCTL(DM_DEV_RENAME)
		5144	COMPATIBLE_IOCTL(DM_DEV_DEPS)
		5145	COMPATIBLE_IOCTL(DM_DEV_STATUS)
		5146	COMPATIBLE_IOCTL(DM_TARGET_STATUS)
		5147	COMPATIBLE_IOCTL(DM_TARGET_WAIT)
		5148	#endif /* CONFIG_BLK_DEV_DM */
		5149
5134	/* SCSI Changer */	5150	/* SCSI Changer */
5135	COMPATIBLE_IOCTL(CHIOMOVE)	5151	COMPATIBLE_IOCTL(CHIOMOVE)
5136	COMPATIBLE_IOCTL(CHIOEXCHANGE)	5152	COMPATIBLE_IOCTL(CHIOEXCHANGE)

Lines 62-67 Link Here

(-)linux-2.4.20-gentoo-r5/arch/x86_64/ia32/ia32_ioctl.c (+15 lines)
62	#define max max	62	#define max max
63	#include <linux/lvm.h>	63	#include <linux/lvm.h>
64	#endif /* LVM */	64	#endif /* LVM */
		65	#include <linux/dm-ioctl.h>
65		66
66	#include <scsi/scsi.h>	67	#include <scsi/scsi.h>
67	/* Ugly hack. */	68	/* Ugly hack. */
Lines 3780-3785 Link Here
3780	COMPATIBLE_IOCTL(LV_BMAP)	3781	COMPATIBLE_IOCTL(LV_BMAP)
3781	COMPATIBLE_IOCTL(LV_SNAPSHOT_USE_RATE)	3782	COMPATIBLE_IOCTL(LV_SNAPSHOT_USE_RATE)
3782	#endif /* LVM */	3783	#endif /* LVM */
		3784	/* Device-Mapper */
		3785	#if defined(CONFIG_BLK_DEV_DM) \|\| defined(CONFIG_BLK_DEV_DM_MODULE)
		3786	COMPATIBLE_IOCTL(DM_VERSION)
		3787	COMPATIBLE_IOCTL(DM_REMOVE_ALL)
		3788	COMPATIBLE_IOCTL(DM_DEV_CREATE)
		3789	COMPATIBLE_IOCTL(DM_DEV_REMOVE)
		3790	COMPATIBLE_IOCTL(DM_DEV_RELOAD)
		3791	COMPATIBLE_IOCTL(DM_DEV_SUSPEND)
		3792	COMPATIBLE_IOCTL(DM_DEV_RENAME)
		3793	COMPATIBLE_IOCTL(DM_DEV_DEPS)
		3794	COMPATIBLE_IOCTL(DM_DEV_STATUS)
		3795	COMPATIBLE_IOCTL(DM_TARGET_STATUS)
		3796	COMPATIBLE_IOCTL(DM_TARGET_WAIT)
		3797	#endif /* CONFIG_BLK_DEV_DM */
3783	#if defined(CONFIG_DRM) \|\| defined(CONFIG_DRM_MODULE)	3798	#if defined(CONFIG_DRM) \|\| defined(CONFIG_DRM_MODULE)
3784	COMPATIBLE_IOCTL(DRM_IOCTL_GET_MAGIC)	3799	COMPATIBLE_IOCTL(DRM_IOCTL_GET_MAGIC)
3785	COMPATIBLE_IOCTL(DRM_IOCTL_IRQ_BUSID)	3800	COMPATIBLE_IOCTL(DRM_IOCTL_IRQ_BUSID)

Line 0 Link Here

(-)linux-2.4.20-gentoo-r5/drivers/md/dm-exception-store.c (+704 lines)
		1	/*
		2	* dm-snapshot.c
		3	*
		4	* Copyright (C) 2001-2002 Sistina Software (UK) Limited.
		5	*
		6	* This file is released under the GPL.
		7	*/
		8
		9	#include "dm-snapshot.h"
		10	#include "kcopyd.h"
		11
		12	#include <linux/mm.h>
		13	#include <linux/pagemap.h>
		14	#include <linux/vmalloc.h>
		15	#include <linux/slab.h>
		16
		17	/*-----------------------------------------------------------------
		18	* Persistent snapshots, by persistent we mean that the snapshot
		19	* will survive a reboot.
		20	---------------------------------------------------------------/
		21
		22	/*
		23	* We need to store a record of which parts of the origin have
		24	* been copied to the snapshot device. The snapshot code
		25	* requires that we copy exception chunks to chunk aligned areas
		26	* of the COW store. It makes sense therefore, to store the
		27	* metadata in chunk size blocks.
		28	*
		29	* There is no backward or forward compatibility implemented,
		30	* snapshots with different disk versions than the kernel will
		31	* not be usable. It is expected that "lvcreate" will blank out
		32	* the start of a fresh COW device before calling the snapshot
		33	* constructor.
		34	*
		35	* The first chunk of the COW device just contains the header.
		36	* After this there is a chunk filled with exception metadata,
		37	* followed by as many exception chunks as can fit in the
		38	* metadata areas.
		39	*
		40	* All on disk structures are in little-endian format. The end
		41	* of the exceptions info is indicated by an exception with a
		42	* new_chunk of 0, which is invalid since it would point to the
		43	* header chunk.
		44	*/
		45
		46	/*
		47	* Magic for persistent snapshots: "SnAp" - Feeble isn't it.
		48	*/
		49	#define SNAP_MAGIC 0x70416e53
		50
		51	/*
		52	* The on-disk version of the metadata.
		53	*/
		54	#define SNAPSHOT_DISK_VERSION 1
		55
		56	struct disk_header {
		57	uint32_t magic;
		58
		59	/*
		60	* Is this snapshot valid. There is no way of recovering
		61	* an invalid snapshot.
		62	*/
		63	int valid;
		64
65	/*
66	* Simple, incrementing version. no backward
67	* compatibility.
68	*/
69	uint32_t version;
70
71	/* In sectors */
72	uint32_t chunk_size;
73	};
74
75	struct disk_exception {
76	uint64_t old_chunk;
77	uint64_t new_chunk;
78	};
79
80	struct commit_callback {
81	void (callback) (void , int success);
82	void *context;
83	};
84
85	/*
86	* The top level structure for a persistent exception store.
87	*/
88	struct pstore {
89	struct dm_snapshot snap; / up pointer to my snapshot */
90	int version;
91	int valid;
92	uint32_t chunk_size;
93	uint32_t exceptions_per_area;
94
95	/*
96	* Now that we have an asynchronous kcopyd there is no
97	* need for large chunk sizes, so it wont hurt to have a
98	* whole chunks worth of metadata in memory at once.
99	*/
100	void *area;
101	struct kiobuf *iobuf;
102
103	/*
104	* Used to keep track of which metadata area the data in
105	* 'chunk' refers to.
106	*/
107	uint32_t current_area;
108
109	/*
110	* The next free chunk for an exception.
111	*/
112	uint32_t next_free;
113
114	/*
115	* The index of next free exception in the current
116	* metadata area.
117	*/
118	uint32_t current_committed;
119
120	atomic_t pending_count;
121	uint32_t callback_count;
122	struct commit_callback *callbacks;
123	};
124
125	/*
126	* For performance reasons we want to defer writing a committed
127	* exceptions metadata to disk so that we can amortise away this
128	* exensive operation.
129	*
130	* For the initial version of this code we will remain with
131	* synchronous io. There are some deadlock issues with async
132	* that I haven't yet worked out.
133	*/
134	static int do_io(int rw, struct kcopyd_region where, struct kiobuf iobuf)
135	{
136	int i, sectors_per_block, nr_blocks, start;
137	int blocksize = get_hardsect_size(where->dev);
138	int status;
139
140	sectors_per_block = blocksize / SECTOR_SIZE;
141
142	nr_blocks = where->count / sectors_per_block;
143	start = where->sector / sectors_per_block;
144
145	for (i = 0; i < nr_blocks; i++)
146	iobuf->blocks[i] = start++;
147
148	iobuf->length = where->count << 9;
149	iobuf->locked = 1;
150
151	status = brw_kiovec(rw, 1, &iobuf, where->dev, iobuf->blocks,
152	blocksize);
153	if (status != (where->count << 9))
154	return -EIO;
155
156	return 0;
157	}
158
159	static int allocate_iobuf(struct pstore *ps)
160	{
161	size_t i, r = -ENOMEM, len, nr_pages;
162	struct page *page;
163
164	len = ps->chunk_size << SECTOR_SHIFT;
165
166	/*
167	* Allocate the chunk_size block of memory that will hold
168	* a single metadata area.
169	*/
170	ps->area = vmalloc(len);
171	if (!ps->area)
172	return r;
173
174	if (alloc_kiovec(1, &ps->iobuf))
175	goto bad;
176
177	nr_pages = ps->chunk_size / (PAGE_SIZE / SECTOR_SIZE);
178	r = expand_kiobuf(ps->iobuf, nr_pages);
179	if (r)
180	goto bad;
181
182	/*
183	* We lock the pages for ps->area into memory since they'll be
184	* doing a lot of io.
185	*/
186	for (i = 0; i < nr_pages; i++) {
187	page = vmalloc_to_page(ps->area + (i * PAGE_SIZE));
188	LockPage(page);
189	ps->iobuf->maplist[i] = page;
190	ps->iobuf->nr_pages++;
191	}
192
193	ps->iobuf->nr_pages = nr_pages;
194	ps->iobuf->offset = 0;
195
196	return 0;
197
198	bad:
199	if (ps->iobuf)
200	free_kiovec(1, &ps->iobuf);
201
202	if (ps->area)
203	vfree(ps->area);
204	ps->iobuf = NULL;
205	return r;
206	}
207
208	static void free_iobuf(struct pstore *ps)
209	{
210	int i;
211
212	for (i = 0; i < ps->iobuf->nr_pages; i++)
213	UnlockPage(ps->iobuf->maplist[i]);
214	ps->iobuf->locked = 0;
215
216	free_kiovec(1, &ps->iobuf);
217	vfree(ps->area);
218	}
219
220	/*
221	* Read or write a chunk aligned and sized block of data from a device.
222	*/
223	static int chunk_io(struct pstore *ps, uint32_t chunk, int rw)
224	{
225	int r;
226	struct kcopyd_region where;
227
228	where.dev = ps->snap->cow->dev;
229	where.sector = ps->chunk_size * chunk;
230	where.count = ps->chunk_size;
231
232	r = do_io(rw, &where, ps->iobuf);
233	if (r)
234	return r;
235
236	return 0;
237	}
238
239	/*
240	* Read or write a metadata area. Remembering to skip the first
241	* chunk which holds the header.
242	*/
243	static int area_io(struct pstore *ps, uint32_t area, int rw)
244	{
245	int r;
246	uint32_t chunk;
247
248	/* convert a metadata area index to a chunk index */
249	chunk = 1 + ((ps->exceptions_per_area + 1) * area);
250
251	r = chunk_io(ps, chunk, rw);
252	if (r)
253	return r;
254
255	ps->current_area = area;
256	return 0;
257	}
258
259	static int zero_area(struct pstore *ps, uint32_t area)
260	{
261	memset(ps->area, 0, ps->chunk_size << SECTOR_SHIFT);
262	return area_io(ps, area, WRITE);
263	}
264
265	static int read_header(struct pstore ps, int new_snapshot)
266	{
267	int r;
268	struct disk_header *dh;
269
270	r = chunk_io(ps, 0, READ);
271	if (r)
272	return r;
273
274	dh = (struct disk_header *) ps->area;
275
276	if (dh->magic == 0) {
277	*new_snapshot = 1;
278
279	} else if (dh->magic == SNAP_MAGIC) {
280	*new_snapshot = 0;
281	ps->valid = dh->valid;
282	ps->version = dh->version;
283	ps->chunk_size = dh->chunk_size;
284
285	} else {
286	DMWARN("Invalid/corrupt snapshot");
287	r = -ENXIO;
288	}
289
290	return r;
291	}
292
293	static int write_header(struct pstore *ps)
294	{
295	struct disk_header *dh;
296
297	memset(ps->area, 0, ps->chunk_size << SECTOR_SHIFT);
298
299	dh = (struct disk_header *) ps->area;
300	dh->magic = SNAP_MAGIC;
301	dh->valid = ps->valid;
302	dh->version = ps->version;
303	dh->chunk_size = ps->chunk_size;
304
305	return chunk_io(ps, 0, WRITE);
306	}
307
308	/*
309	* Access functions for the disk exceptions, these do the endian conversions.
310	*/
311	static struct disk_exception get_exception(struct pstore ps, uint32_t index)
312	{
313	if (index >= ps->exceptions_per_area)
314	return NULL;
315
316	return ((struct disk_exception *) ps->area) + index;
317	}
318
319	static int read_exception(struct pstore *ps,
320	uint32_t index, struct disk_exception *result)
321	{
322	struct disk_exception *e;
323
324	e = get_exception(ps, index);
325	if (!e)
326	return -EINVAL;
327
328	/* copy it */
329	result->old_chunk = le64_to_cpu(e->old_chunk);
330	result->new_chunk = le64_to_cpu(e->new_chunk);
331
332	return 0;
333	}
334
335	static int write_exception(struct pstore *ps,
336	uint32_t index, struct disk_exception *de)
337	{
338	struct disk_exception *e;
339
340	e = get_exception(ps, index);
341	if (!e)
342	return -EINVAL;
343
344	/* copy it */
345	e->old_chunk = cpu_to_le64(de->old_chunk);
346	e->new_chunk = cpu_to_le64(de->new_chunk);
347
348	return 0;
349	}
350
351	/*
352	* Registers the exceptions that are present in the current area.
353	* 'full' is filled in to indicate if the area has been
354	* filled.
355	*/
356	static int insert_exceptions(struct pstore ps, int full)
357	{
358	int i, r;
359	struct disk_exception de;
360
361	/* presume the area is full */
362	*full = 1;
363
364	for (i = 0; i < ps->exceptions_per_area; i++) {
365	r = read_exception(ps, i, &de);
366
367	if (r)
368	return r;
369
370	/*
371	* If the new_chunk is pointing at the start of
372	* the COW device, where the first metadata area
373	* is we know that we've hit the end of the
374	* exceptions. Therefore the area is not full.
375	*/
376	if (de.new_chunk == 0LL) {
377	ps->current_committed = i;
378	*full = 0;
379	break;
380	}
381
382	/*
383	* Keep track of the start of the free chunks.
384	*/
385	if (ps->next_free <= de.new_chunk)
386	ps->next_free = de.new_chunk + 1;
387
388	/*
389	* Otherwise we add the exception to the snapshot.
390	*/
391	r = dm_add_exception(ps->snap, de.old_chunk, de.new_chunk);
392	if (r)
393	return r;
394	}
395
396	return 0;
397	}
398
399	static int read_exceptions(struct pstore *ps)
400	{
401	uint32_t area;
402	int r, full = 1;
403
404	/*
405	* Keeping reading chunks and inserting exceptions until
406	* we find a partially full area.
407	*/
408	for (area = 0; full; area++) {
409	r = area_io(ps, area, READ);
410	if (r)
411	return r;
412
413	r = insert_exceptions(ps, &full);
414	if (r)
415	return r;
416
417	area++;
418	}
419
420	return 0;
421	}
422
423	static inline struct pstore get_info(struct exception_store store)
424	{
425	return (struct pstore *) store->context;
426	}
427
428	static int persistent_percentfull(struct exception_store *store)
429	{
430	struct pstore *ps = get_info(store);
431	return (ps->next_free * store->snap->chunk_size * 100) /
432	get_dev_size(store->snap->cow->dev);
433	}
434
435	static void persistent_destroy(struct exception_store *store)
436	{
437	struct pstore *ps = get_info(store);
438
439	vfree(ps->callbacks);
440	free_iobuf(ps);
441	kfree(ps);
442	}
443
444	static int persistent_prepare(struct exception_store *store,
445	struct exception *e)
446	{
447	struct pstore *ps = get_info(store);
448	uint32_t stride;
449	sector_t size = get_dev_size(store->snap->cow->dev);
450
451	/* Is there enough room ? */
452	if (size < ((ps->next_free + 1) * store->snap->chunk_size))
453	return -ENOSPC;
454
455	e->new_chunk = ps->next_free;
456
457	/*
458	* Move onto the next free pending, making sure to take
459	* into account the location of the metadata chunks.
460	*/
461	stride = (ps->exceptions_per_area + 1);
462	if ((++ps->next_free % stride) == 1)
463	ps->next_free++;
464
465	atomic_inc(&ps->pending_count);
466	return 0;
467	}
468
469	static void persistent_commit(struct exception_store *store,
470	struct exception *e,
471	void (callback) (void , int success),
472	void *callback_context)
473	{
474	int r, i;
475	struct pstore *ps = get_info(store);
476	struct disk_exception de;
477	struct commit_callback *cb;
478
479	de.old_chunk = e->old_chunk;
480	de.new_chunk = e->new_chunk;
481	write_exception(ps, ps->current_committed++, &de);
482
483	/*
484	* Add the callback to the back of the array. This code
485	* is the only place where the callback array is
486	* manipulated, and we know that it will never be called
487	* multiple times concurrently.
488	*/
489	cb = ps->callbacks + ps->callback_count++;
490	cb->callback = callback;
491	cb->context = callback_context;
492
493	/*
494	* If there are no more exceptions in flight, or we have
495	* filled this metadata area we commit the exceptions to
496	* disk.
497	*/
498	if (atomic_dec_and_test(&ps->pending_count) \|\|
499	(ps->current_committed == ps->exceptions_per_area)) {
500	r = area_io(ps, ps->current_area, WRITE);
501	if (r)
502	ps->valid = 0;
503
504	for (i = 0; i < ps->callback_count; i++) {
505	cb = ps->callbacks + i;
506	cb->callback(cb->context, r == 0 ? 1 : 0);
507	}
508
509	ps->callback_count = 0;
510	}
511
512	/*
513	* Have we completely filled the current area ?
514	*/
515	if (ps->current_committed == ps->exceptions_per_area) {
516	ps->current_committed = 0;
517	r = zero_area(ps, ps->current_area + 1);
518	if (r)
519	ps->valid = 0;
520	}
521	}
522
523	static void persistent_drop(struct exception_store *store)
524	{
525	struct pstore *ps = get_info(store);
526
527	ps->valid = 0;
528	if (write_header(ps))
529	DMWARN("write header failed");
530	}
531
532	int dm_create_persistent(struct exception_store *store, uint32_t chunk_size)
533	{
534	int r, new_snapshot;
535	struct pstore *ps;
536
537	/* allocate the pstore */
538	ps = kmalloc(sizeof(*ps), GFP_KERNEL);
539	if (!ps)
540	return -ENOMEM;
541
542	ps->snap = store->snap;
543	ps->valid = 1;
544	ps->version = SNAPSHOT_DISK_VERSION;
545	ps->chunk_size = chunk_size;
546	ps->exceptions_per_area = (chunk_size << SECTOR_SHIFT) /
547	sizeof(struct disk_exception);
548	ps->next_free = 2; /* skipping the header and first area */
549	ps->current_committed = 0;
550
551	r = allocate_iobuf(ps);
552	if (r)
553	goto bad;
554
555	/*
556	* Allocate space for all the callbacks.
557	*/
558	ps->callback_count = 0;
559	atomic_set(&ps->pending_count, 0);
560	ps->callbacks = vcalloc(ps->exceptions_per_area,
561	sizeof(*ps->callbacks));
562
563	if (!ps->callbacks)
564	goto bad;
565
566	/*
567	* Read the snapshot header.
568	*/
569	r = read_header(ps, &new_snapshot);
570	if (r)
571	goto bad;
572
573	/*
574	* Do we need to setup a new snapshot ?
575	*/
576	if (new_snapshot) {
577	r = write_header(ps);
578	if (r) {
579	DMWARN("write_header failed");
580	goto bad;
581	}
582
583	r = zero_area(ps, 0);
584	if (r) {
585	DMWARN("zero_area(0) failed");
586	goto bad;
587	}
588
589	} else {
590	/*
591	* Sanity checks.
592	*/
593	if (!ps->valid) {
594	DMWARN("snapshot is marked invalid");
595	r = -EINVAL;
596	goto bad;
597	}
598
599	if (ps->chunk_size != chunk_size) {
600	DMWARN("chunk size for existing snapshot different "
601	"from that requested");
602	r = -EINVAL;
603	goto bad;
604	}
605
606	if (ps->version != SNAPSHOT_DISK_VERSION) {
607	DMWARN("unable to handle snapshot disk version %d",
608	ps->version);
609	r = -EINVAL;
610	goto bad;
611	}
612
613	/*
614	* Read the metadata.
615	*/
616	r = read_exceptions(ps);
617	if (r)
618	goto bad;
619	}
620
621	store->destroy = persistent_destroy;
622	store->prepare_exception = persistent_prepare;
623	store->commit_exception = persistent_commit;
624	store->drop_snapshot = persistent_drop;
625	store->percent_full = persistent_percentfull;
626	store->context = ps;
627
628	return r;
629
630	bad:
631	if (ps) {
632	if (ps->callbacks)
633	vfree(ps->callbacks);
634
635	if (ps->iobuf)
636	free_iobuf(ps);
637
638	kfree(ps);
639	}
640	return r;
641	}
642
643	/*-----------------------------------------------------------------
644	* Implementation of the store for non-persistent snapshots.
645	---------------------------------------------------------------/
646	struct transient_c {
647	sector_t next_free;
648	};
649
650	void transient_destroy(struct exception_store *store)
651	{
652	kfree(store->context);
653	}
654
655	int transient_prepare(struct exception_store store, struct exception e)
656	{
657	struct transient_c tc = (struct transient_c ) store->context;
658	sector_t size = get_dev_size(store->snap->cow->dev);
659
660	if (size < (tc->next_free + store->snap->chunk_size))
661	return -1;
662
663	e->new_chunk = sector_to_chunk(store->snap, tc->next_free);
664	tc->next_free += store->snap->chunk_size;
665
666	return 0;
667	}
668
669	void transient_commit(struct exception_store *store,
670	struct exception *e,
671	void (callback) (void , int success),
672	void *callback_context)
673	{
674	/* Just succeed */
675	callback(callback_context, 1);
676	}
677
678	static int transient_percentfull(struct exception_store *store)
679	{
680	struct transient_c tc = (struct transient_c ) store->context;
681	return (tc->next_free * 100) / get_dev_size(store->snap->cow->dev);
682	}
683
684	int dm_create_transient(struct exception_store *store,
685	struct dm_snapshot *s, int blocksize)
686	{
687	struct transient_c *tc;
688
689	memset(store, 0, sizeof(*store));
690	store->destroy = transient_destroy;
691	store->prepare_exception = transient_prepare;
692	store->commit_exception = transient_commit;
693	store->percent_full = transient_percentfull;
694	store->snap = s;
695
696	tc = kmalloc(sizeof(struct transient_c), GFP_KERNEL);
697	if (!tc)
698	return -ENOMEM;
699
700	tc->next_free = 0;
701	store->context = tc;
702
703	return 0;
704	}

Line 0 Link Here

(-)linux-2.4.20-gentoo-r5/drivers/md/dm-linear.c (+121 lines)
		1	/*
		2	* Copyright (C) 2001 Sistina Software (UK) Limited.
		3	*
		4	* This file is released under the GPL.
		5	*/
		6
		7	#include "dm.h"
		8
		9	#include <linux/module.h>
		10	#include <linux/init.h>
		11	#include <linux/blkdev.h>
		12	#include <linux/slab.h>
		13
		14	/*
		15	* Linear: maps a linear range of a device.
		16	*/
		17	struct linear_c {
		18	struct dm_dev *dev;
		19	sector_t start;
		20	};
		21
		22	/*
		23	* Construct a linear mapping: <dev_path> <offset>
		24	*/
		25	static int linear_ctr(struct dm_target ti, int argc, char *argv)
		26	{
		27	struct linear_c *lc;
		28
		29	if (argc != 2) {
		30	ti->error = "dm-linear: Not enough arguments";
		31	return -EINVAL;
		32	}
		33
		34	lc = kmalloc(sizeof(*lc), GFP_KERNEL);
		35	if (lc == NULL) {
		36	ti->error = "dm-linear: Cannot allocate linear context";
		37	return -ENOMEM;
		38	}
		39
		40	if (sscanf(argv[1], SECTOR_FORMAT, &lc->start) != 1) {
		41	ti->error = "dm-linear: Invalid device sector";
		42	goto bad;
		43	}
		44
		45	if (dm_get_device(ti, argv[0], lc->start, ti->len,
		46	dm_table_get_mode(ti->table), &lc->dev)) {
		47	ti->error = "dm-linear: Device lookup failed";
		48	goto bad;
		49	}
		50
		51	ti->private = lc;
		52	return 0;
		53
		54	bad:
		55	kfree(lc);
		56	return -EINVAL;
		57	}
		58
		59	static void linear_dtr(struct dm_target *ti)
		60	{
		61	struct linear_c lc = (struct linear_c ) ti->private;
		62
		63	dm_put_device(ti, lc->dev);
		64	kfree(lc);
65	}
66
67	static int linear_map(struct dm_target ti, struct buffer_head bh, int rw,
68	void **map_context)
69	{
70	struct linear_c lc = (struct linear_c ) ti->private;
71
72	bh->b_rdev = lc->dev->dev;
73	bh->b_rsector = lc->start + (bh->b_rsector - ti->begin);
74
75	return 1;
76	}
77
78	static int linear_status(struct dm_target *ti, status_type_t type,
79	char *result, int maxlen)
80	{
81	struct linear_c lc = (struct linear_c ) ti->private;
82
83	switch (type) {
84	case STATUSTYPE_INFO:
85	result[0] = '\0';
86	break;
87
88	case STATUSTYPE_TABLE:
89	snprintf(result, maxlen, "%s " SECTOR_FORMAT,
90	kdevname(to_kdev_t(lc->dev->bdev->bd_dev)), lc->start);
91	break;
92	}
93	return 0;
94	}
95
96	static struct target_type linear_target = {
97	.name = "linear",
98	.module = THIS_MODULE,
99	.ctr = linear_ctr,
100	.dtr = linear_dtr,
101	.map = linear_map,
102	.status = linear_status,
103	};
104
105	int __init dm_linear_init(void)
106	{
107	int r = dm_register_target(&linear_target);
108
109	if (r < 0)
110	DMERR("linear: register failed %d", r);
111
112	return r;
113	}
114
115	void dm_linear_exit(void)
116	{
117	int r = dm_unregister_target(&linear_target);
118
119	if (r < 0)
120	DMERR("linear: unregister failed %d", r);
121	}

Line 0 Link Here

(-)linux-2.4.20-gentoo-r5/drivers/md/dm.c (+878 lines)
		1	/*
		2	* Copyright (C) 2001, 2002 Sistina Software (UK) Limited.
		3	*
		4	* This file is released under the GPL.
		5	*/
		6
		7	#include "dm.h"
		8
		9	#include <linux/init.h>
		10	#include <linux/module.h>
		11	#include <linux/blk.h>
		12	#include <linux/blkpg.h>
		13	#include <linux/mempool.h>
		14	#include <linux/slab.h>
		15	#include <linux/kdev_t.h>
		16	#include <linux/lvm.h>
		17
		18	#include <asm/uaccess.h>
		19
		20	static const char *_name = DM_NAME;
		21	#define MAX_DEVICES (1 << MINORBITS)
		22	#define DEFAULT_READ_AHEAD 64
		23
		24	static int major = 0;
		25	static int _major = 0;
		26
		27	struct dm_io {
		28	struct mapped_device *md;
		29
		30	struct dm_target *ti;
		31	int rw;
		32	void *map_context;
		33	void (end_io) (struct buffer_head bh, int uptodate);
		34	void *context;
		35	};
		36
		37	struct deferred_io {
		38	int rw;
		39	struct buffer_head *bh;
		40	struct deferred_io *next;
		41	};
		42
		43	/*
		44	* Bits for the md->flags field.
		45	*/
		46	#define DMF_BLOCK_IO 0
		47	#define DMF_SUSPENDED 1
		48
		49	struct mapped_device {
		50	struct rw_semaphore lock;
		51	atomic_t holders;
		52
		53	kdev_t dev;
		54	unsigned long flags;
		55
		56	/*
		57	* A list of ios that arrived while we were suspended.
		58	*/
		59	atomic_t pending;
		60	wait_queue_head_t wait;
		61	struct deferred_io *deferred;
		62
		63	/*
		64	* The current mapping.
65	*/
66	struct dm_table *map;
67
68	/*
69	* io objects are allocated from here.
70	*/
71	mempool_t *io_pool;
72	};
73
74	#define MIN_IOS 256
75	static kmem_cache_t *_io_cache;
76
77	/* block device arrays */
78	static int _block_size[MAX_DEVICES];
79	static int _blksize_size[MAX_DEVICES];
80	static int _hardsect_size[MAX_DEVICES];
81
82	static struct mapped_device *get_kdev(kdev_t dev);
83	static int dm_request(request_queue_t q, int rw, struct buffer_head bh);
84	static int dm_user_bmap(struct inode inode, struct lv_bmap lvb);
85
86	static __init int local_init(void)
87	{
88	int r;
89
90	/* allocate a slab for the dm_ios */
91	_io_cache = kmem_cache_create("dm io",
92	sizeof(struct dm_io), 0, 0, NULL, NULL);
93
94	if (!_io_cache)
95	return -ENOMEM;
96
97	_major = major;
98	r = register_blkdev(_major, _name, &dm_blk_dops);
99	if (r < 0) {
100	DMERR("register_blkdev failed");
101	kmem_cache_destroy(_io_cache);
102	return r;
103	}
104
105	if (!_major)
106	_major = r;
107
108	/* set up the arrays */
109	read_ahead[_major] = DEFAULT_READ_AHEAD;
110	blk_size[_major] = _block_size;
111	blksize_size[_major] = _blksize_size;
112	hardsect_size[_major] = _hardsect_size;
113
114	blk_queue_make_request(BLK_DEFAULT_QUEUE(_major), dm_request);
115
116	return 0;
117	}
118
119	static void local_exit(void)
120	{
121	kmem_cache_destroy(_io_cache);
122
123	if (unregister_blkdev(_major, _name) < 0)
124	DMERR("devfs_unregister_blkdev failed");
125
126	read_ahead[_major] = 0;
127	blk_size[_major] = NULL;
128	blksize_size[_major] = NULL;
129	hardsect_size[_major] = NULL;
130	_major = 0;
131
132	DMINFO("cleaned up");
133	}
134
135	/*
136	* We have a lot of init/exit functions, so it seems easier to
137	* store them in an array. The disposable macro 'xx'
138	* expands a prefix into a pair of function names.
139	*/
140	static struct {
141	int (*init) (void);
142	void (*exit) (void);
143
144	} _inits[] = {
145	#define xx(n) {n ## _init, n ## _exit},
146	xx(local)
147	xx(dm_target)
148	xx(dm_linear)
149	xx(dm_stripe)
150	xx(dm_snapshot)
151	xx(dm_interface)
152	#undef xx
153	};
154
155	static int __init dm_init(void)
156	{
157	const int count = ARRAY_SIZE(_inits);
158
159	int r, i;
160
161	for (i = 0; i < count; i++) {
162	r = _inits[i].init();
163	if (r)
164	goto bad;
165	}
166
167	return 0;
168
169	bad:
170	while (i--)
171	_inits[i].exit();
172
173	return r;
174	}
175
176	static void __exit dm_exit(void)
177	{
178	int i = ARRAY_SIZE(_inits);
179
180	while (i--)
181	_inits[i].exit();
182	}
183
184	/*
185	* Block device functions
186	*/
187	static int dm_blk_open(struct inode inode, struct file file)
188	{
189	struct mapped_device *md;
190
191	md = get_kdev(inode->i_rdev);
192	if (!md)
193	return -ENXIO;
194
195	return 0;
196	}
197
198	static int dm_blk_close(struct inode inode, struct file file)
199	{
200	struct mapped_device *md;
201
202	md = get_kdev(inode->i_rdev);
203	dm_put(md); /* put the reference gained by dm_blk_open */
204	dm_put(md);
205	return 0;
206	}
207
208	static inline struct dm_io alloc_io(struct mapped_device md)
209	{
210	return mempool_alloc(md->io_pool, GFP_NOIO);
211	}
212
213	static inline void free_io(struct mapped_device md, struct dm_io io)
214	{
215	mempool_free(io, md->io_pool);
216	}
217
218	static inline struct deferred_io *alloc_deferred(void)
219	{
220	return kmalloc(sizeof(struct deferred_io), GFP_NOIO);
221	}
222
223	static inline void free_deferred(struct deferred_io *di)
224	{
225	kfree(di);
226	}
227
228	/* In 512-byte units */
229	#define VOLUME_SIZE(minor) (_block_size[(minor)] << 1)
230
231	/* FIXME: check this */
232	static int dm_blk_ioctl(struct inode inode, struct file file,
233	uint command, unsigned long a)
234	{
235	int minor = MINOR(inode->i_rdev);
236	long size;
237
238	if (minor >= MAX_DEVICES)
239	return -ENXIO;
240
241	switch (command) {
242	case BLKROSET:
243	case BLKROGET:
244	case BLKRASET:
245	case BLKRAGET:
246	case BLKFLSBUF:
247	case BLKSSZGET:
248	//case BLKRRPART: /* Re-read partition tables */
249	//case BLKPG:
250	case BLKELVGET:
251	case BLKELVSET:
252	case BLKBSZGET:
253	case BLKBSZSET:
254	return blk_ioctl(inode->i_rdev, command, a);
255	break;
256
257	case BLKGETSIZE:
258	size = VOLUME_SIZE(minor);
259	if (copy_to_user((void *) a, &size, sizeof(long)))
260	return -EFAULT;
261	break;
262
263	case BLKGETSIZE64:
264	size = VOLUME_SIZE(minor);
265	if (put_user((u64) ((u64) size) << 9, (u64 *) a))
266	return -EFAULT;
267	break;
268
269	case BLKRRPART:
270	return -ENOTTY;
271
272	case LV_BMAP:
273	return dm_user_bmap(inode, (struct lv_bmap *) a);
274
275	default:
276	DMWARN("unknown block ioctl 0x%x", command);
277	return -ENOTTY;
278	}
279
280	return 0;
281	}
282
283	/*
284	* Add the buffer to the list of deferred io.
285	*/
286	static int queue_io(struct mapped_device md, struct buffer_head bh, int rw)
287	{
288	struct deferred_io *di;
289
290	di = alloc_deferred();
291	if (!di)
292	return -ENOMEM;
293
294	down_write(&md->lock);
295
296	if (!test_bit(DMF_BLOCK_IO, &md->flags)) {
297	up_write(&md->lock);
298	free_deferred(di);
299	return 1;
300	}
301
302	di->bh = bh;
303	di->rw = rw;
304	di->next = md->deferred;
305	md->deferred = di;
306
307	up_write(&md->lock);
308	return 0; /* deferred successfully */
309	}
310
311	/*
312	* bh->b_end_io routine that decrements the pending count
313	* and then calls the original bh->b_end_io fn.
314	*/
315	static void dec_pending(struct buffer_head *bh, int uptodate)
316	{
317	int r;
318	struct dm_io *io = bh->b_private;
319	dm_endio_fn endio = io->ti->type->end_io;
320
321	if (endio) {
322	r = endio(io->ti, bh, io->rw, uptodate ? 0 : -EIO,
323	io->map_context);
324	if (r < 0)
325	uptodate = 0;
326
327	else if (r > 0)
328	/* the target wants another shot at the io */
329	return;
330	}
331
332	if (atomic_dec_and_test(&io->md->pending))
333	/* nudge anyone waiting on suspend queue */
334	wake_up(&io->md->wait);
335
336	bh->b_end_io = io->end_io;
337	bh->b_private = io->context;
338	free_io(io->md, io);
339
340	bh->b_end_io(bh, uptodate);
341	}
342
343	/*
344	* Do the bh mapping for a given leaf
345	*/
346	static inline int __map_buffer(struct mapped_device *md, int rw,
347	struct buffer_head bh, struct dm_io io)
348	{
349	struct dm_target *ti;
350
351	ti = dm_table_find_target(md->map, bh->b_rsector);
352	if (!ti \|\| !ti->type)
353	return -EINVAL;
354
355	/* hook the end io request fn */
356	atomic_inc(&md->pending);
357	io->md = md;
358	io->ti = ti;
359	io->rw = rw;
360	io->end_io = bh->b_end_io;
361	io->context = bh->b_private;
362	bh->b_end_io = dec_pending;
363	bh->b_private = io;
364
365	return ti->type->map(ti, bh, rw, &io->map_context);
366	}
367
368	/*
369	* Checks to see if we should be deferring io, if so it queues it
370	* and returns 1.
371	*/
372	static inline int __deferring(struct mapped_device *md, int rw,
373	struct buffer_head *bh)
374	{
375	int r;
376
377	/*
378	* If we're suspended we have to queue this io for later.
379	*/
380	while (test_bit(DMF_BLOCK_IO, &md->flags)) {
381	up_read(&md->lock);
382
383	/*
384	* There's no point deferring a read ahead
385	* request, just drop it.
386	*/
387	if (rw == READA) {
388	down_read(&md->lock);
389	return -EIO;
390	}
391
392	r = queue_io(md, bh, rw);
393	down_read(&md->lock);
394
395	if (r < 0)
396	return r;
397
398	if (r == 0)
399	return 1; /* deferred successfully */
400
401	}
402
403	return 0;
404	}
405
406	static int dm_request(request_queue_t q, int rw, struct buffer_head bh)
407	{
408	int r;
409	struct dm_io *io;
410	struct mapped_device *md;
411
412	md = get_kdev(bh->b_rdev);
413	if (!md) {
414	buffer_IO_error(bh);
415	return 0;
416	}
417
418	io = alloc_io(md);
419	down_read(&md->lock);
420
421	r = __deferring(md, rw, bh);
422	if (r < 0)
423	goto bad;
424
425	else if (!r) {
426	/* not deferring */
427	r = __map_buffer(md, rw, bh, io);
428	if (r < 0)
429	goto bad;
430	} else
431	r = 0;
432
433	up_read(&md->lock);
434	dm_put(md);
435	return r;
436
437	bad:
438	buffer_IO_error(bh);
439	up_read(&md->lock);
440	dm_put(md);
441	return 0;
442	}
443
444	static int check_dev_size(kdev_t dev, unsigned long block)
445	{
446	/* FIXME: check this */
447	int minor = MINOR(dev);
448	unsigned long max_sector = (_block_size[minor] << 1) + 1;
449	unsigned long sector = (block + 1) * (_blksize_size[minor] >> 9);
450
451	return (sector > max_sector) ? 0 : 1;
452	}
453
454	/*
455	* Creates a dummy buffer head and maps it (for lilo).
456	*/
457	static int __bmap(struct mapped_device *md, kdev_t dev, unsigned long block,
458	kdev_t r_dev, unsigned long r_block)
459	{
460	struct buffer_head bh;
461	struct dm_target *ti;
462	void *map_context;
463	int r;
464
465	if (test_bit(DMF_BLOCK_IO, &md->flags)) {
466	return -EPERM;
467	}
468
469	if (!check_dev_size(dev, block)) {
470	return -EINVAL;
471	}
472
473	/* setup dummy bh */
474	memset(&bh, 0, sizeof(bh));
475	bh.b_blocknr = block;
476	bh.b_dev = bh.b_rdev = dev;
477	bh.b_size = _blksize_size[MINOR(dev)];
478	bh.b_rsector = block * (bh.b_size >> 9);
479
480	/* find target */
481	ti = dm_table_find_target(md->map, bh.b_rsector);
482
483	/* do the mapping */
484	r = ti->type->map(ti, &bh, READ, &map_context);
485	ti->type->end_io(ti, &bh, READ, 0, map_context);
486
487	if (!r) {
488	*r_dev = bh.b_rdev;
489	*r_block = bh.b_rsector / (bh.b_size >> 9);
490	}
491
492	return r;
493	}
494
495	/*
496	* Marshals arguments and results between user and kernel space.
497	*/
498	static int dm_user_bmap(struct inode inode, struct lv_bmap lvb)
499	{
500	struct mapped_device *md;
501	unsigned long block, r_block;
502	kdev_t r_dev;
503	int r;
504
505	if (get_user(block, &lvb->lv_block))
506	return -EFAULT;
507
508	md = get_kdev(inode->i_rdev);
509	if (!md)
510	return -ENXIO;
511
512	down_read(&md->lock);
513	r = __bmap(md, inode->i_rdev, block, &r_dev, &r_block);
514	up_read(&md->lock);
515	dm_put(md);
516
517	if (!r && (put_user(kdev_t_to_nr(r_dev), &lvb->lv_dev) \|\|
518	put_user(r_block, &lvb->lv_block)))
519	r = -EFAULT;
520
521	return r;
522	}
523
524	/*-----------------------------------------------------------------
525	* A bitset is used to keep track of allocated minor numbers.
526	---------------------------------------------------------------/
527	static spinlock_t _minor_lock = SPIN_LOCK_UNLOCKED;
528	static struct mapped_device *_mds[MAX_DEVICES];
529
530	static void free_minor(int minor)
531	{
532	spin_lock(&_minor_lock);
533	_mds[minor] = NULL;
534	spin_unlock(&_minor_lock);
535	}
536
537	/*
538	* See if the device with a specific minor # is free.
539	*/
540	static int specific_minor(int minor, struct mapped_device *md)
541	{
542	int r = -EBUSY;
543
544	if (minor >= MAX_DEVICES) {
545	DMWARN("request for a mapped_device beyond MAX_DEVICES (%d)",
546	MAX_DEVICES);
547	return -EINVAL;
548	}
549
550	spin_lock(&_minor_lock);
551	if (!_mds[minor]) {
552	_mds[minor] = md;
553	r = minor;
554	}
555	spin_unlock(&_minor_lock);
556
557	return r;
558	}
559
560	static int next_free_minor(struct mapped_device *md)
561	{
562	int i;
563
564	spin_lock(&_minor_lock);
565	for (i = 0; i < MAX_DEVICES; i++) {
566	if (!_mds[i]) {
567	_mds[i] = md;
568	break;
569	}
570	}
571	spin_unlock(&_minor_lock);
572
573	return (i < MAX_DEVICES) ? i : -EBUSY;
574	}
575
576	static struct mapped_device *get_kdev(kdev_t dev)
577	{
578	struct mapped_device *md;
579
580	if (major(dev) != _major)
581	return NULL;
582
583	spin_lock(&_minor_lock);
584	md = _mds[minor(dev)];
585	if (md)
586	dm_get(md);
587	spin_unlock(&_minor_lock);
588
589	return md;
590	}
591
592	/*
593	* Allocate and initialise a blank device with a given minor.
594	*/
595	static struct mapped_device *alloc_dev(int minor)
596	{
597	struct mapped_device md = kmalloc(sizeof(md), GFP_KERNEL);
598
599	if (!md) {
600	DMWARN("unable to allocate device, out of memory.");
601	return NULL;
602	}
603
604	/* get a minor number for the dev */
605	minor = (minor < 0) ? next_free_minor(md) : specific_minor(minor, md);
606	if (minor < 0) {
607	kfree(md);
608	return NULL;
609	}
610
611	memset(md, 0, sizeof(*md));
612
613	md->io_pool = mempool_create(MIN_IOS, mempool_alloc_slab,
614	mempool_free_slab, _io_cache);
615	if (!md->io_pool) {
616	free_minor(minor);
617	kfree(md);
618	return NULL;
619	}
620
621	md->dev = mk_kdev(_major, minor);
622	init_rwsem(&md->lock);
623	atomic_set(&md->holders, 1);
624	atomic_set(&md->pending, 0);
625	init_waitqueue_head(&md->wait);
626
627	return md;
628	}
629
630	static void free_dev(struct mapped_device *md)
631	{
632	free_minor(minor(md->dev));
633	mempool_destroy(md->io_pool);
634	kfree(md);
635	}
636
637	/*
638	* The hardsect size for a mapped device is the largest hardsect size
639	* from the devices it maps onto.
640	*/
641	static int __find_hardsect_size(struct list_head *devices)
642	{
643	int result = 512, size;
644	struct list_head *tmp;
645
646	list_for_each(tmp, devices) {
647	struct dm_dev *dd = list_entry(tmp, struct dm_dev, list);
648	size = get_hardsect_size(dd->dev);
649	if (size > result)
650	result = size;
651	}
652
653	return result;
654	}
655
656	/*
657	* Bind a table to the device.
658	*/
659	static int __bind(struct mapped_device md, struct dm_table t)
660	{
661	int minor = minor(md->dev);
662	md->map = t;
663
664	/* in k */
665	_block_size[minor] = dm_table_get_size(t) >> 1;
666	_blksize_size[minor] = BLOCK_SIZE;
667	_hardsect_size[minor] = __find_hardsect_size(dm_table_get_devices(t));
668	register_disk(NULL, md->dev, 1, &dm_blk_dops, _block_size[minor]);
669
670	dm_table_get(t);
671	return 0;
672	}
673
674	static void __unbind(struct mapped_device *md)
675	{
676	int minor = minor(md->dev);
677
678	dm_table_put(md->map);
679	md->map = NULL;
680
681	_block_size[minor] = 0;
682	_blksize_size[minor] = 0;
683	_hardsect_size[minor] = 0;
684	}
685
686	/*
687	* Constructor for a new device.
688	*/
689	int dm_create(int minor, struct dm_table table, struct mapped_device *result)
690	{
691	int r;
692	struct mapped_device *md;
693
694	md = alloc_dev(minor);
695	if (!md)
696	return -ENXIO;
697
698	r = __bind(md, table);
699	if (r) {
700	free_dev(md);
701	return r;
702	}
703
704	*result = md;
705	return 0;
706	}
707
708	void dm_get(struct mapped_device *md)
709	{
710	atomic_inc(&md->holders);
711	}
712
713	void dm_put(struct mapped_device *md)
714	{
715	if (atomic_dec_and_test(&md->holders)) {
716	__unbind(md);
717	free_dev(md);
718	}
719	}
720
721	/*
722	* Requeue the deferred io by calling generic_make_request.
723	*/
724	static void flush_deferred_io(struct deferred_io *c)
725	{
726	struct deferred_io *n;
727
728	while (c) {
729	n = c->next;
730	generic_make_request(c->rw, c->bh);
731	free_deferred(c);
732	c = n;
733	}
734	}
735
736	/*
737	* Swap in a new table (destroying old one).
738	*/
739	int dm_swap_table(struct mapped_device md, struct dm_table table)
740	{
741	int r;
742
743	down_write(&md->lock);
744
745	/* device must be suspended */
746	if (!test_bit(DMF_SUSPENDED, &md->flags)) {
747	up_write(&md->lock);
748	return -EPERM;
749	}
750
751	__unbind(md);
752	r = __bind(md, table);
753	if (r)
754	return r;
755
756	up_write(&md->lock);
757	return 0;
758	}
759
760	/*
761	* We need to be able to change a mapping table under a mounted
762	* filesystem. For example we might want to move some data in
763	* the background. Before the table can be swapped with
764	* dm_bind_table, dm_suspend must be called to flush any in
765	* flight io and ensure that any further io gets deferred.
766	*/
767	int dm_suspend(struct mapped_device *md)
768	{
769	DECLARE_WAITQUEUE(wait, current);
770
771	down_write(&md->lock);
772
773	/*
774	* First we set the BLOCK_IO flag so no more ios will be
775	* mapped.
776	*/
777	if (test_bit(DMF_BLOCK_IO, &md->flags)) {
778	up_write(&md->lock);
779	return -EINVAL;
780	}
781
782	set_bit(DMF_BLOCK_IO, &md->flags);
783	add_wait_queue(&md->wait, &wait);
784	up_write(&md->lock);
785
786	/*
787	* Then we wait for the already mapped ios to
788	* complete.
789	*/
790	run_task_queue(&tq_disk);
791	while (1) {
792	set_current_state(TASK_INTERRUPTIBLE);
793
794	if (!atomic_read(&md->pending))
795	break;
796
797	schedule();
798	}
799
800	current->state = TASK_RUNNING;
801
802	down_write(&md->lock);
803	remove_wait_queue(&md->wait, &wait);
804	set_bit(DMF_SUSPENDED, &md->flags);
805	up_write(&md->lock);
806
807	return 0;
808	}
809
810	int dm_resume(struct mapped_device *md)
811	{
812	struct deferred_io *def;
813
814	down_write(&md->lock);
815	if (!test_bit(DMF_SUSPENDED, &md->flags) \|\|
816	!dm_table_get_size(md->map)) {
817	up_write(&md->lock);
818	return -EINVAL;
819	}
820
821	clear_bit(DMF_SUSPENDED, &md->flags);
822	clear_bit(DMF_BLOCK_IO, &md->flags);
823	def = md->deferred;
824	md->deferred = NULL;
825	up_write(&md->lock);
826
827	flush_deferred_io(def);
828	run_task_queue(&tq_disk);
829
830	return 0;
831	}
832
833	struct dm_table dm_get_table(struct mapped_device md)
834	{
835	struct dm_table *t;
836
837	down_read(&md->lock);
838	t = md->map;
839	dm_table_get(t);
840	up_read(&md->lock);
841
842	return t;
843	}
844
845	kdev_t dm_kdev(struct mapped_device *md)
846	{
847	kdev_t dev;
848
849	down_read(&md->lock);
850	dev = md->dev;
851	up_read(&md->lock);
852
853	return dev;
854	}
855
856	int dm_suspended(struct mapped_device *md)
857	{
858	return test_bit(DMF_SUSPENDED, &md->flags);
859	}
860
861	struct block_device_operations dm_blk_dops = {
862	.open = dm_blk_open,
863	.release = dm_blk_close,
864	.ioctl = dm_blk_ioctl,
865	.owner = THIS_MODULE
866	};
867
868	/*
869	* module hooks
870	*/
871	module_init(dm_init);
872	module_exit(dm_exit);
873
874	MODULE_PARM(major, "i");
875	MODULE_PARM_DESC(major, "The major number of the device mapper");
876	MODULE_DESCRIPTION(DM_NAME " driver");
877	MODULE_AUTHOR("Joe Thornber <thornber@sistina.com>");
878	MODULE_LICENSE("GPL");

Line 0 Link Here

(-)linux-2.4.20-gentoo-r5/drivers/md/dm.h (+154 lines)
		1	/*
		2	* Internal header file for device mapper
		3	*
		4	* Copyright (C) 2001, 2002 Sistina Software
		5	*
		6	* This file is released under the LGPL.
		7	*/
		8
		9	#ifndef DM_INTERNAL_H
		10	#define DM_INTERNAL_H
		11
		12	#include <linux/fs.h>
		13	#include <linux/device-mapper.h>
		14	#include <linux/list.h>
		15	#include <linux/blkdev.h>
		16
		17	#define DM_NAME "device-mapper"
		18	#define DMWARN(f, x...) printk(KERN_WARNING DM_NAME ": " f "\n" , ## x)
		19	#define DMERR(f, x...) printk(KERN_ERR DM_NAME ": " f "\n" , ## x)
		20	#define DMINFO(f, x...) printk(KERN_INFO DM_NAME ": " f "\n" , ## x)
		21
		22	/*
		23	* FIXME: I think this should be with the definition of sector_t
		24	* in types.h.
		25	*/
		26	#ifdef CONFIG_LBD
		27	#define SECTOR_FORMAT "%Lu"
		28	#else
		29	#define SECTOR_FORMAT "%lu"
		30	#endif
		31
		32	#define SECTOR_SHIFT 9
		33	#define SECTOR_SIZE (1 << SECTOR_SHIFT)
		34
		35	extern struct block_device_operations dm_blk_dops;
		36
		37	/*
		38	* List of devices that a metadevice uses and should open/close.
		39	*/
		40	struct dm_dev {
		41	struct list_head list;
		42
		43	atomic_t count;
		44	int mode;
		45	kdev_t dev;
		46	struct block_device *bdev;
		47	};
		48
		49	struct dm_table;
		50	struct mapped_device;
		51
		52	/*-----------------------------------------------------------------
		53	* Functions for manipulating a struct mapped_device.
		54	* Drop the reference with dm_put when you finish with the object.
		55	---------------------------------------------------------------/
		56	int dm_create(int minor, struct dm_table table, struct mapped_device *md);
		57
		58	/*
		59	* Reference counting for md.
		60	*/
		61	void dm_get(struct mapped_device *md);
		62	void dm_put(struct mapped_device *md);
		63
		64	/*
65	* A device can still be used while suspended, but I/O is deferred.
66	*/
67	int dm_suspend(struct mapped_device *md);
68	int dm_resume(struct mapped_device *md);
69
70	/*
71	* The device must be suspended before calling this method.
72	*/
73	int dm_swap_table(struct mapped_device md, struct dm_table t);
74
75	/*
76	* Drop a reference on the table when you've finished with the
77	* result.
78	*/
79	struct dm_table dm_get_table(struct mapped_device md);
80
81	/*
82	* Info functions.
83	*/
84	kdev_t dm_kdev(struct mapped_device *md);
85	int dm_suspended(struct mapped_device *md);
86
87	/*-----------------------------------------------------------------
88	* Functions for manipulating a table. Tables are also reference
89	* counted.
90	---------------------------------------------------------------/
91	int dm_table_create(struct dm_table **result, int mode);
92
93	void dm_table_get(struct dm_table *t);
94	void dm_table_put(struct dm_table *t);
95
96	int dm_table_add_target(struct dm_table t, const char type,
97	sector_t start, sector_t len, char *params);
98	int dm_table_complete(struct dm_table *t);
99	void dm_table_event(struct dm_table *t);
100	sector_t dm_table_get_size(struct dm_table *t);
101	struct dm_target dm_table_get_target(struct dm_table t, int index);
102	struct dm_target dm_table_find_target(struct dm_table t, sector_t sector);
103	unsigned int dm_table_get_num_targets(struct dm_table *t);
104	struct list_head dm_table_get_devices(struct dm_table t);
105	int dm_table_get_mode(struct dm_table *t);
106	void dm_table_add_wait_queue(struct dm_table t, wait_queue_t wq);
107
108	/*-----------------------------------------------------------------
109	* A registry of target types.
110	---------------------------------------------------------------/
111	int dm_target_init(void);
112	void dm_target_exit(void);
113	struct target_type dm_get_target_type(const char name);
114	void dm_put_target_type(struct target_type *t);
115
116
117	/*-----------------------------------------------------------------
118	* Useful inlines.
119	---------------------------------------------------------------/
120	static inline int array_too_big(unsigned long fixed, unsigned long obj,
121	unsigned long num)
122	{
123	return (num > (ULONG_MAX - fixed) / obj);
124	}
125
126	/*
127	* ceiling(n / size) * size
128	*/
129	static inline unsigned long dm_round_up(unsigned long n, unsigned long size)
130	{
131	unsigned long r = n % size;
132	return n + (r ? (size - r) : 0);
133	}
134
135	/*
136	* The device-mapper can be driven through one of two interfaces;
137	* ioctl or filesystem, depending which patch you have applied.
138	*/
139	int dm_interface_init(void);
140	void dm_interface_exit(void);
141
142	/*
143	* Targets for linear and striped mappings
144	*/
145	int dm_linear_init(void);
146	void dm_linear_exit(void);
147
148	int dm_stripe_init(void);
149	void dm_stripe_exit(void);
150
151	int dm_snapshot_init(void);
152	void dm_snapshot_exit(void);
153
154	#endif

Line 0 Link Here

(-)linux-2.4.20-gentoo-r5/drivers/md/kcopyd.c (+839 lines)
		1	/*
		2	* Copyright (C) 2002 Sistina Software (UK) Limited.
		3	*
		4	* This file is released under the GPL.
		5	*/
		6
		7	#include <asm/atomic.h>
		8
		9	#include <linux/blkdev.h>
		10	#include <linux/config.h>
		11	#include <linux/device-mapper.h>
		12	#include <linux/fs.h>
		13	#include <linux/init.h>
		14	#include <linux/list.h>
		15	#include <linux/locks.h>
		16	#include <linux/mempool.h>
		17	#include <linux/module.h>
		18	#include <linux/pagemap.h>
		19	#include <linux/slab.h>
		20	#include <linux/vmalloc.h>
		21
		22	#include "kcopyd.h"
		23
		24	/* FIXME: this is only needed for the DMERR macros */
		25	#include "dm.h"
		26
		27	static void wake_kcopyd(void);
		28
		29	/*-----------------------------------------------------------------
		30	* We reserve our own pool of preallocated pages that are
		31	* only used for kcopyd io.
		32	---------------------------------------------------------------/
		33
		34	/*
		35	* FIXME: This should be configurable.
		36	*/
		37	#define NUM_PAGES 512
		38
		39	static DECLARE_MUTEX(_pages_lock);
		40	static int _num_free_pages;
		41	static struct page *_pages_array[NUM_PAGES];
		42	static DECLARE_MUTEX(start_lock);
		43
		44	static int init_pages(void)
		45	{
		46	int i;
		47	struct page *p;
		48
		49	for (i = 0; i < NUM_PAGES; i++) {
		50	p = alloc_page(GFP_KERNEL);
		51	if (!p)
		52	goto bad;
		53
		54	LockPage(p);
		55	_pages_array[i] = p;
		56	}
		57
		58	_num_free_pages = NUM_PAGES;
		59	return 0;
		60
		61	bad:
		62	while (i--) {
		63	UnlockPage(_pages_array[i]);
		64	__free_page(_pages_array[i]);
65	}
66	return -ENOMEM;
67	}
68
69	static void exit_pages(void)
70	{
71	int i;
72	struct page *p;
73
74	for (i = 0; i < NUM_PAGES; i++) {
75	p = _pages_array[i];
76	UnlockPage(p);
77	__free_page(p);
78	}
79
80	_num_free_pages = 0;
81	}
82
83	static int kcopyd_get_pages(int num, struct page **result)
84	{
85	int i;
86
87	down(&_pages_lock);
88	if (_num_free_pages < num) {
89	up(&_pages_lock);
90	return -ENOMEM;
91	}
92
93	for (i = 0; i < num; i++) {
94	_num_free_pages--;
95	result[i] = _pages_array[_num_free_pages];
96	}
97	up(&_pages_lock);
98
99	return 0;
100	}
101
102	static void kcopyd_free_pages(int num, struct page **result)
103	{
104	int i;
105
106	down(&_pages_lock);
107	for (i = 0; i < num; i++)
108	_pages_array[_num_free_pages++] = result[i];
109	up(&_pages_lock);
110	}
111
112	/*-----------------------------------------------------------------
113	* We keep our own private pool of buffer_heads. These are just
114	* held in a list on the b_reqnext field.
115	---------------------------------------------------------------/
116
117	/*
118	* Make sure we have enough buffers to always keep the pages
119	* occupied. So we assume the worst case scenario where blocks
120	* are the size of a single sector.
121	*/
122	#define NUM_BUFFERS NUM_PAGES * (PAGE_SIZE / SECTOR_SIZE)
123
124	static spinlock_t _buffer_lock = SPIN_LOCK_UNLOCKED;
125	static struct buffer_head *_all_buffers;
126	static struct buffer_head *_free_buffers;
127
128	static int init_buffers(void)
129	{
130	int i;
131	struct buffer_head *buffers;
132
133	buffers = vcalloc(NUM_BUFFERS, sizeof(struct buffer_head));
134	if (!buffers) {
135	DMWARN("Couldn't allocate buffer heads.");
136	return -ENOMEM;
137	}
138
139	for (i = 0; i < NUM_BUFFERS; i++) {
140	if (i < NUM_BUFFERS - 1)
141	buffers[i].b_reqnext = &buffers[i + 1];
142	init_waitqueue_head(&buffers[i].b_wait);
143	INIT_LIST_HEAD(&buffers[i].b_inode_buffers);
144	}
145
146	_all_buffers = _free_buffers = buffers;
147	return 0;
148	}
149
150	static void exit_buffers(void)
151	{
152	vfree(_all_buffers);
153	}
154
155	static struct buffer_head *alloc_buffer(void)
156	{
157	struct buffer_head *r;
158	int flags;
159
160	spin_lock_irqsave(&_buffer_lock, flags);
161
162	if (!_free_buffers)
163	r = NULL;
164	else {
165	r = _free_buffers;
166	_free_buffers = _free_buffers->b_reqnext;
167	r->b_reqnext = NULL;
168	}
169
170	spin_unlock_irqrestore(&_buffer_lock, flags);
171
172	return r;
173	}
174
175	/*
176	* Only called from interrupt context.
177	*/
178	static void free_buffer(struct buffer_head *bh)
179	{
180	int flags, was_empty;
181
182	spin_lock_irqsave(&_buffer_lock, flags);
183	was_empty = (_free_buffers == NULL) ? 1 : 0;
184	bh->b_reqnext = _free_buffers;
185	_free_buffers = bh;
186	spin_unlock_irqrestore(&_buffer_lock, flags);
187
188	/*
189	* If the buffer list was empty then kcopyd probably went
190	* to sleep because it ran out of buffer heads, so let's
191	* wake it up.
192	*/
193	if (was_empty)
194	wake_kcopyd();
195	}
196
197	/*-----------------------------------------------------------------
198	* kcopyd_jobs need to be allocated by the clients of kcopyd,
199	* for this reason we use a mempool to prevent the client from
200	* ever having to do io (which could cause a
201	* deadlock).
202	---------------------------------------------------------------/
203	#define MIN_JOBS NUM_PAGES
204
205	static kmem_cache_t *_job_cache = NULL;
206	static mempool_t *_job_pool = NULL;
207
208	/*
209	* We maintain three lists of jobs:
210	*
211	* i) jobs waiting for pages
212	* ii) jobs that have pages, and are waiting for the io to be issued.
213	* iii) jobs that have completed.
214	*
215	* All three of these are protected by job_lock.
216	*/
217
218	static spinlock_t _job_lock = SPIN_LOCK_UNLOCKED;
219
220	static LIST_HEAD(_complete_jobs);
221	static LIST_HEAD(_io_jobs);
222	static LIST_HEAD(_pages_jobs);
223
224	static int init_jobs(void)
225	{
226	INIT_LIST_HEAD(&_complete_jobs);
227	INIT_LIST_HEAD(&_io_jobs);
228	INIT_LIST_HEAD(&_pages_jobs);
229
230	_job_cache = kmem_cache_create("kcopyd-jobs", sizeof(struct kcopyd_job),
231	__alignof__(struct kcopyd_job),
232	0, NULL, NULL);
233	if (!_job_cache)
234	return -ENOMEM;
235
236	_job_pool = mempool_create(MIN_JOBS, mempool_alloc_slab,
237	mempool_free_slab, _job_cache);
238	if (!_job_pool) {
239	kmem_cache_destroy(_job_cache);
240	return -ENOMEM;
241	}
242
243	return 0;
244	}
245
246	static void exit_jobs(void)
247	{
248	mempool_destroy(_job_pool);
249	kmem_cache_destroy(_job_cache);
250	}
251
252	struct kcopyd_job *kcopyd_alloc_job(void)
253	{
254	struct kcopyd_job *job;
255
256	job = mempool_alloc(_job_pool, GFP_NOIO);
257	if (!job)
258	return NULL;
259
260	memset(job, 0, sizeof(*job));
261	return job;
262	}
263
264	void kcopyd_free_job(struct kcopyd_job *job)
265	{
266	mempool_free(job, _job_pool);
267	}
268
269	/*
270	* Functions to push and pop a job onto the head of a given job
271	* list.
272	*/
273	static inline struct kcopyd_job pop(struct list_head jobs)
274	{
275	struct kcopyd_job *job = NULL;
276	int flags;
277
278	spin_lock_irqsave(&_job_lock, flags);
279
280	if (!list_empty(jobs)) {
281	job = list_entry(jobs->next, struct kcopyd_job, list);
282	list_del(&job->list);
283	}
284	spin_unlock_irqrestore(&_job_lock, flags);
285
286	return job;
287	}
288
289	static inline void push(struct list_head jobs, struct kcopyd_job job)
290	{
291	int flags;
292
293	spin_lock_irqsave(&_job_lock, flags);
294	list_add(&job->list, jobs);
295	spin_unlock_irqrestore(&_job_lock, flags);
296	}
297
298	/*
299	* Completion function for one of our buffers.
300	*/
301	static void end_bh(struct buffer_head *bh, int uptodate)
302	{
303	struct kcopyd_job *job = bh->b_private;
304
305	mark_buffer_uptodate(bh, uptodate);
306	unlock_buffer(bh);
307
308	if (!uptodate)
309	job->err = -EIO;
310
311	/* are we the last ? */
312	if (atomic_dec_and_test(&job->nr_incomplete)) {
313	push(&_complete_jobs, job);
314	wake_kcopyd();
315	}
316
317	free_buffer(bh);
318	}
319
320	static void dispatch_bh(struct kcopyd_job *job,
321	struct buffer_head *bh, int block)
322	{
323	int p;
324
325	/*
326	* Add in the job offset
327	*/
328	bh->b_blocknr = (job->disk.sector >> job->block_shift) + block;
329
330	p = block >> job->bpp_shift;
331	block &= job->bpp_mask;
332
333	bh->b_size = job->block_size;
334	set_bh_page(bh, job->pages[p], ((block << job->block_shift) +
335	job->offset) << SECTOR_SHIFT);
336	bh->b_this_page = bh;
337
338	init_buffer(bh, end_bh, job);
339
340	bh->b_dev = job->disk.dev;
341	atomic_set(&bh->b_count, 1);
342
343	bh->b_state = ((1 << BH_Uptodate) \| (1 << BH_Mapped) \|
344	(1 << BH_Lock) \| (1 << BH_Req));
345
346	if (job->rw == WRITE)
347	clear_bit(BH_Dirty, &bh->b_state);
348
349	submit_bh(job->rw, bh);
350	}
351
352	/*
353	* These three functions process 1 item from the corresponding
354	* job list.
355	*
356	* They return:
357	* < 0: error
358	* 0: success
359	* > 0: can't process yet.
360	*/
361	static int run_complete_job(struct kcopyd_job *job)
362	{
363	job->callback(job);
364	return 0;
365	}
366
367	/*
368	* Request io on as many buffer heads as we can currently get for
369	* a particular job.
370	*/
371	static int run_io_job(struct kcopyd_job *job)
372	{
373	unsigned int block;
374	struct buffer_head *bh;
375
376	for (block = atomic_read(&job->nr_requested);
377	block < job->nr_blocks; block++) {
378	bh = alloc_buffer();
379	if (!bh)
380	break;
381
382	atomic_inc(&job->nr_requested);
383	dispatch_bh(job, bh, block);
384	}
385
386	return (block == job->nr_blocks) ? 0 : 1;
387	}
388
389	static int run_pages_job(struct kcopyd_job *job)
390	{
391	int r;
392
393	job->nr_pages = (job->disk.count + job->offset) /
394	(PAGE_SIZE / SECTOR_SIZE);
395	r = kcopyd_get_pages(job->nr_pages, job->pages);
396
397	if (!r) {
398	/* this job is ready for io */
399	push(&_io_jobs, job);
400	return 0;
401	}
402
403	if (r == -ENOMEM)
404	/* can't complete now */
405	return 1;
406
407	return r;
408	}
409
410	/*
411	* Run through a list for as long as possible. Returns the count
412	* of successful jobs.
413	*/
414	static int process_jobs(struct list_head jobs, int (fn) (struct kcopyd_job *))
415	{
416	struct kcopyd_job *job;
417	int r, count = 0;
418
419	while ((job = pop(jobs))) {
420
421	r = fn(job);
422
423	if (r < 0) {
424	/* error this rogue job */
425	job->err = r;
426	push(&_complete_jobs, job);
427	break;
428	}
429
430	if (r > 0) {
431	/*
432	* We couldn't service this job ATM, so
433	* push this job back onto the list.
434	*/
435	push(jobs, job);
436	break;
437	}
438
439	count++;
440	}
441
442	return count;
443	}
444
445	/*
446	* kcopyd does this every time it's woken up.
447	*/
448	static void do_work(void)
449	{
450	int count;
451
452	/*
453	* We loop round until there is no more work to do.
454	*/
455	do {
456	count = process_jobs(&_complete_jobs, run_complete_job);
457	count += process_jobs(&_io_jobs, run_io_job);
458	count += process_jobs(&_pages_jobs, run_pages_job);
459
460	} while (count);
461
462	run_task_queue(&tq_disk);
463	}
464
465	/*-----------------------------------------------------------------
466	* The daemon
467	---------------------------------------------------------------/
468	static atomic_t _kcopyd_must_die;
469	static DECLARE_MUTEX(_run_lock);
470	static DECLARE_WAIT_QUEUE_HEAD(_job_queue);
471
472	static int kcopyd(void *arg)
473	{
474	DECLARE_WAITQUEUE(wq, current);
475
476	daemonize();
477	strcpy(current->comm, "kcopyd");
478	atomic_set(&_kcopyd_must_die, 0);
479
480	add_wait_queue(&_job_queue, &wq);
481
482	down(&_run_lock);
483	up(&start_lock);
484
485	while (1) {
486	set_current_state(TASK_INTERRUPTIBLE);
487
488	if (atomic_read(&_kcopyd_must_die))
489	break;
490
491	do_work();
492	schedule();
493	}
494
495	set_current_state(TASK_RUNNING);
496	remove_wait_queue(&_job_queue, &wq);
497
498	up(&_run_lock);
499
500	return 0;
501	}
502
503	static int start_daemon(void)
504	{
505	static pid_t pid = 0;
506
507	down(&start_lock);
508
509	pid = kernel_thread(kcopyd, NULL, 0);
510	if (pid <= 0) {
511	DMERR("Failed to start kcopyd thread");
512	return -EAGAIN;
513	}
514
515	/*
516	* wait for the daemon to up this mutex.
517	*/
518	down(&start_lock);
519	up(&start_lock);
520
521	return 0;
522	}
523
524	static int stop_daemon(void)
525	{
526	atomic_set(&_kcopyd_must_die, 1);
527	wake_kcopyd();
528	down(&_run_lock);
529	up(&_run_lock);
530
531	return 0;
532	}
533
534	static void wake_kcopyd(void)
535	{
536	wake_up_interruptible(&_job_queue);
537	}
538
539	static int calc_shift(unsigned int n)
540	{
541	int s;
542
543	for (s = 0; n; s++, n >>= 1)
544	;
545
546	return --s;
547	}
548
549	static void calc_block_sizes(struct kcopyd_job *job)
550	{
551	job->block_size = get_hardsect_size(job->disk.dev);
552	job->block_shift = calc_shift(job->block_size / SECTOR_SIZE);
553	job->bpp_shift = PAGE_SHIFT - job->block_shift - SECTOR_SHIFT;
554	job->bpp_mask = (1 << job->bpp_shift) - 1;
555	job->nr_blocks = job->disk.count >> job->block_shift;
556	atomic_set(&job->nr_requested, 0);
557	atomic_set(&job->nr_incomplete, job->nr_blocks);
558	}
559
560	int kcopyd_io(struct kcopyd_job *job)
561	{
562	calc_block_sizes(job);
563	push(job->pages[0] ? &_io_jobs : &_pages_jobs, job);
564	wake_kcopyd();
565	return 0;
566	}
567
568	/*-----------------------------------------------------------------
569	* The copier is implemented on top of the simpler async io
570	* daemon above.
571	---------------------------------------------------------------/
572	struct copy_info {
573	kcopyd_notify_fn notify;
574	void *notify_context;
575
576	struct kcopyd_region to;
577	};
578
579	#define MIN_INFOS 128
580	static kmem_cache_t *_copy_cache = NULL;
581	static mempool_t *_copy_pool = NULL;
582
583	static int init_copier(void)
584	{
585	_copy_cache = kmem_cache_create("kcopyd-info",
586	sizeof(struct copy_info),
587	__alignof__(struct copy_info),
588	0, NULL, NULL);
589	if (!_copy_cache)
590	return -ENOMEM;
591
592	_copy_pool = mempool_create(MIN_INFOS, mempool_alloc_slab,
593	mempool_free_slab, _copy_cache);
594	if (!_copy_pool) {
595	kmem_cache_destroy(_copy_cache);
596	return -ENOMEM;
597	}
598
599	return 0;
600	}
601
602	static void exit_copier(void)
603	{
604	if (_copy_pool)
605	mempool_destroy(_copy_pool);
606
607	if (_copy_cache)
608	kmem_cache_destroy(_copy_cache);
609	}
610
611	static inline struct copy_info *alloc_copy_info(void)
612	{
613	return mempool_alloc(_copy_pool, GFP_NOIO);
614	}
615
616	static inline void free_copy_info(struct copy_info *info)
617	{
618	mempool_free(info, _copy_pool);
619	}
620
621	void copy_complete(struct kcopyd_job *job)
622	{
623	struct copy_info info = (struct copy_info ) job->context;
624
625	if (info->notify)
626	info->notify(job->err, info->notify_context);
627
628	free_copy_info(info);
629
630	kcopyd_free_pages(job->nr_pages, job->pages);
631
632	kcopyd_free_job(job);
633	}
634
635	static void page_write_complete(struct kcopyd_job *job)
636	{
637	struct copy_info info = (struct copy_info ) job->context;
638	int i;
639
640	if (info->notify)
641	info->notify(job->err, info->notify_context);
642
643	free_copy_info(info);
644	for (i = 0; i < job->nr_pages; i++)
645	put_page(job->pages[i]);
646
647	kcopyd_free_job(job);
648	}
649
650	/*
651	* These callback functions implement the state machine that copies regions.
652	*/
653	void copy_write(struct kcopyd_job *job)
654	{
655	struct copy_info info = (struct copy_info ) job->context;
656
657	if (job->err) {
658	if (info->notify)
659	info->notify(job->err, job->context);
660
661	kcopyd_free_job(job);
662	free_copy_info(info);
663	return;
664	}
665
666	job->rw = WRITE;
667	memcpy(&job->disk, &info->to, sizeof(job->disk));
668	job->callback = copy_complete;
669
670	/*
671	* Queue the write.
672	*/
673	kcopyd_io(job);
674	}
675
676	int kcopyd_write_pages(struct kcopyd_region *to, int nr_pages,
677	struct page **pages, int offset, kcopyd_notify_fn fn,
678	void *context)
679	{
680	struct copy_info *info;
681	struct kcopyd_job *job;
682	int i;
683
684	/*
685	* Allocate a new copy_info.
686	*/
687	info = alloc_copy_info();
688	if (!info)
689	return -ENOMEM;
690
691	job = kcopyd_alloc_job();
692	if (!job) {
693	free_copy_info(info);
694	return -ENOMEM;
695	}
696
697	/*
698	* set up for the write.
699	*/
700	info->notify = fn;
701	info->notify_context = context;
702	memcpy(&info->to, to, sizeof(*to));
703
704	/* Get the pages */
705	job->nr_pages = nr_pages;
706	for (i = 0; i < nr_pages; i++) {
707	get_page(pages[i]);
708	job->pages[i] = pages[i];
709	}
710
711	job->rw = WRITE;
712
713	memcpy(&job->disk, &info->to, sizeof(job->disk));
714	job->offset = offset;
715	job->callback = page_write_complete;
716	job->context = info;
717
718	/*
719	* Trigger job.
720	*/
721	kcopyd_io(job);
722	return 0;
723	}
724
725	int kcopyd_copy(struct kcopyd_region from, struct kcopyd_region to,
726	kcopyd_notify_fn fn, void *context)
727	{
728	struct copy_info *info;
729	struct kcopyd_job *job;
730
731	/*
732	* Allocate a new copy_info.
733	*/
734	info = alloc_copy_info();
735	if (!info)
736	return -ENOMEM;
737
738	job = kcopyd_alloc_job();
739	if (!job) {
740	free_copy_info(info);
741	return -ENOMEM;
742	}
743
744	/*
745	* set up for the read.
746	*/
747	info->notify = fn;
748	info->notify_context = context;
749	memcpy(&info->to, to, sizeof(*to));
750
751	job->rw = READ;
752	memcpy(&job->disk, from, sizeof(*from));
753
754	job->offset = 0;
755	job->callback = copy_write;
756	job->context = info;
757
758	/*
759	* Trigger job.
760	*/
761	kcopyd_io(job);
762	return 0;
763	}
764
765	/*-----------------------------------------------------------------
766	* Unit setup
767	---------------------------------------------------------------/
768	static struct {
769	int (*init) (void);
770	void (*exit) (void);
771
772	} _inits[] = {
773	#define xx(n) { init_ ## n, exit_ ## n}
774	xx(pages),
775	xx(buffers),
776	xx(jobs),
777	xx(copier)
778	#undef xx
779	};
780
781	static int _client_count = 0;
782	static DECLARE_MUTEX(_client_count_sem);
783
784	static int kcopyd_init(void)
785	{
786	const int count = sizeof(_inits) / sizeof(*_inits);
787
788	int r, i;
789
790	for (i = 0; i < count; i++) {
791	r = _inits[i].init();
792	if (r)
793	goto bad;
794	}
795
796	start_daemon();
797	return 0;
798
799	bad:
800	while (i--)
801	_inits[i].exit();
802
803	return r;
804	}
805
806	static void kcopyd_exit(void)
807	{
808	int i = sizeof(_inits) / sizeof(*_inits);
809
810	if (stop_daemon())
811	DMWARN("Couldn't stop kcopyd.");
812
813	while (i--)
814	_inits[i].exit();
815	}
816
817	void kcopyd_inc_client_count(void)
818	{
819	/*
820	* What I need here is an atomic_test_and_inc that returns
821	* the previous value of the atomic... In its absence I lock
822	* an int with a semaphore. :-(
823	*/
824	down(&_client_count_sem);
825	if (_client_count == 0)
826	kcopyd_init();
827	_client_count++;
828
829	up(&_client_count_sem);
830	}
831
832	void kcopyd_dec_client_count(void)
833	{
834	down(&_client_count_sem);
835	if (--_client_count == 0)
836	kcopyd_exit();
837
838	up(&_client_count_sem);
839	}

Line 0 Link Here

(-)linux-2.4.20-gentoo-r5/drivers/md/kcopyd.h (+101 lines)
		1	/*
		2	* Copyright (C) 2001 Sistina Software
		3	*
		4	* This file is released under the GPL.
		5	*/
		6
		7	#ifndef DM_KCOPYD_H
		8	#define DM_KCOPYD_H
		9
		10	/*
		11	* Needed for the definition of offset_t.
		12	*/
		13	#include <linux/device-mapper.h>
		14	#include <linux/iobuf.h>
		15
		16	struct kcopyd_region {
		17	kdev_t dev;
		18	sector_t sector;
		19	sector_t count;
		20	};
		21
		22	#define MAX_KCOPYD_PAGES 128
		23
		24	struct kcopyd_job {
		25	struct list_head list;
		26
		27	/*
		28	* Error state of the job.
		29	*/
		30	int err;
		31
		32	/*
		33	* Either READ or WRITE
		34	*/
		35	int rw;
		36
		37	/*
		38	* The source or destination for the transfer.
		39	*/
		40	struct kcopyd_region disk;
		41
		42	int nr_pages;
		43	struct page *pages[MAX_KCOPYD_PAGES];
		44
		45	/*
		46	* Shifts and masks that will be useful when dispatching
		47	* each buffer_head.
		48	*/
		49	sector_t offset;
		50	sector_t block_size;
		51	sector_t block_shift;
		52	sector_t bpp_shift; /* blocks per page */
		53	sector_t bpp_mask;
		54
		55	/*
		56	* nr_blocks is how many buffer heads will have to be
		57	* displatched to service this job, nr_requested is how
		58	* many have been dispatched and nr_complete is how many
		59	* have come back.
		60	*/
		61	unsigned int nr_blocks;
		62	atomic_t nr_requested;
		63	atomic_t nr_incomplete;
		64
65	/*
66	* Set this to ensure you are notified when the job has
67	* completed. 'context' is for callback to use.
68	*/
69	void (callback) (struct kcopyd_job job);
70	void *context;
71	};
72
73	/*
74	* Low level async io routines.
75	*/
76	struct kcopyd_job *kcopyd_alloc_job(void);
77	void kcopyd_free_job(struct kcopyd_job *job);
78
79	int kcopyd_queue_job(struct kcopyd_job *job);
80
81	/*
82	* Submit a copy job to kcopyd. This is built on top of the
83	* previous three fns.
84	*/
85	typedef void (kcopyd_notify_fn) (int err, void context);
86
87	int kcopyd_copy(struct kcopyd_region from, struct kcopyd_region to,
88	kcopyd_notify_fn fn, void *context);
89
90	int kcopyd_write_pages(struct kcopyd_region *to, int nr_pages,
91	struct page **pages, int offset, kcopyd_notify_fn fn,
92	void *context);
93
94	/*
95	* We only want kcopyd to reserve resources if someone is
96	* actually using it.
97	*/
98	void kcopyd_inc_client_count(void);
99	void kcopyd_dec_client_count(void);
100
101	#endif

Lines 4-14 Link Here

(-)linux-2.4.20-gentoo-r5/include/linux/mempool.h (+9 lines)
4	#ifndef _LINUX_MEMPOOL_H	4	#ifndef _LINUX_MEMPOOL_H
5	#define _LINUX_MEMPOOL_H	5	#define _LINUX_MEMPOOL_H
6		6
		7	#include <linux/list.h>
7	#include <linux/wait.h>	8	#include <linux/wait.h>
8		9
9	typedef void * (mempool_alloc_t)(int gfp_mask, void *pool_data);	10	typedef void * (mempool_alloc_t)(int gfp_mask, void *pool_data);
10	typedef void (mempool_free_t)(void element, void pool_data);	11	typedef void (mempool_free_t)(void element, void pool_data);
11		12
		13	struct mempool_s;
12	typedef struct mempool_s {	14	typedef struct mempool_s {
13	spinlock_t lock;	15	spinlock_t lock;
14	int min_nr; /* nr of elements at elements /	16	int min_nr; /* nr of elements at elements /
Lines 27-30 Link Here
27	extern void * mempool_alloc(mempool_t *pool, int gfp_mask);	29	extern void * mempool_alloc(mempool_t *pool, int gfp_mask);
28	extern void mempool_free(void element, mempool_t pool);	30	extern void mempool_free(void element, mempool_t pool);
29		31
		32	/*
		33	* A mempool_alloc_t and mempool_free_t that get the memory from
		34	* a slab that is passed in through pool_data.
		35	*/
		36	void mempool_alloc_slab(int gfp_mask, void pool_data);
		37	void mempool_free_slab(void element, void pool_data);
		38
30	#endif /* _LINUX_MEMPOOL_H */	39	#endif /* _LINUX_MEMPOOL_H */

Lines 327-329 Link Here

(-)linux-2.4.20-gentoo-r5/mm/vmalloc.c (+19 lines)
327	read_unlock(&vmlist_lock);	327	read_unlock(&vmlist_lock);
328	return buf - buf_start;	328	return buf - buf_start;
329	}	329	}
		330
		331	void *vcalloc(unsigned long nmemb, unsigned long elem_size)
		332	{
		333	unsigned long size;
		334	void *addr;
		335
		336	/*
		337	* Check that we're not going to overflow.
		338	*/
		339	if (nmemb > (ULONG_MAX / elem_size))
		340	return NULL;
		341
		342	size = nmemb * elem_size;
		343	addr = vmalloc(size);
		344	if (addr)
		345	memset(addr, 0, size);
		346
		347	return addr;
		348	}