[deliverable/linux.git] / drivers / md / dm-linear.c

/*
 * Copyright (C) 2001-2003 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/bio.h>
#include <linux/slab.h>

#define DM_MSG_PREFIX "linear"

/*
 * 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, unsigned int argc, char **argv)
{
	struct linear_c *lc;
	unsigned long long tmp;

	if (argc != 2) {
		ti->error = "Invalid argument count";
		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], "%llu", &tmp) != 1) {
		ti->error = "dm-linear: Invalid device sector";
		goto bad;
	}
	lc->start = tmp;

	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 bio *bio,
		      union map_info *map_context)
{
	struct linear_c *lc = (struct linear_c *) ti->private;

	bio->bi_bdev = lc->dev->bdev;
	bio->bi_sector = lc->start + (bio->bi_sector - ti->begin);

	return 1;
}

static int linear_status(struct dm_target *ti, status_type_t type,
			 char *result, unsigned 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 %llu", lc->dev->name,
				(unsigned long long)lc->start);
		break;
	}
	return 0;
}

static struct target_type linear_target = {
	.name   = "linear",
	.version= {1, 0, 1},
	.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("register failed %d", r);

	return r;
}

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

	if (r < 0)
		DMERR("unregister failed %d", r);
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Copyright (C) 2001-2003 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/bio.h>
	13	#include <linux/slab.h>
	14
72d94861 AK	15	#define DM_MSG_PREFIX "linear"
72d94861 AK	16
1da177e4 LT	17	/*
	18	* Linear: maps a linear range of a device.
	19	*/
	20	struct linear_c {
	21	struct dm_dev *dev;
	22	sector_t start;
	23	};
	24
	25	/*
	26	* Construct a linear mapping: <dev_path> <offset>
	27	*/
	28	static int linear_ctr(struct dm_target ti, unsigned int argc, char *argv)
	29	{
	30	struct linear_c *lc;
4ee218cd	31	unsigned long long tmp;
1da177e4 LT	32
1da177e4 LT	33	if (argc != 2) {
72d94861	34	ti->error = "Invalid argument count";
1da177e4 LT	35	return -EINVAL;
	36	}
	37
	38	lc = kmalloc(sizeof(*lc), GFP_KERNEL);
	39	if (lc == NULL) {
	40	ti->error = "dm-linear: Cannot allocate linear context";
	41	return -ENOMEM;
	42	}
	43
4ee218cd	44	if (sscanf(argv[1], "%llu", &tmp) != 1) {
1da177e4 LT	45	ti->error = "dm-linear: Invalid device sector";
	46	goto bad;
	47	}
4ee218cd	48	lc->start = tmp;
1da177e4 LT	49
	50	if (dm_get_device(ti, argv[0], lc->start, ti->len,
	51	dm_table_get_mode(ti->table), &lc->dev)) {
	52	ti->error = "dm-linear: Device lookup failed";
	53	goto bad;
	54	}
	55
	56	ti->private = lc;
	57	return 0;
	58
	59	bad:
	60	kfree(lc);
	61	return -EINVAL;
	62	}
	63
	64	static void linear_dtr(struct dm_target *ti)
	65	{
	66	struct linear_c lc = (struct linear_c ) ti->private;
	67
	68	dm_put_device(ti, lc->dev);
	69	kfree(lc);
	70	}
	71
	72	static int linear_map(struct dm_target ti, struct bio bio,
	73	union map_info *map_context)
	74	{
	75	struct linear_c lc = (struct linear_c ) ti->private;
	76
	77	bio->bi_bdev = lc->dev->bdev;
	78	bio->bi_sector = lc->start + (bio->bi_sector - ti->begin);
	79
	80	return 1;
	81	}
	82
	83	static int linear_status(struct dm_target *ti, status_type_t type,
	84	char *result, unsigned int maxlen)
	85	{
	86	struct linear_c lc = (struct linear_c ) ti->private;
	87
	88	switch (type) {
	89	case STATUSTYPE_INFO:
	90	result[0] = '\0';
	91	break;
	92
	93	case STATUSTYPE_TABLE:
4ee218cd AM	94	snprintf(result, maxlen, "%s %llu", lc->dev->name,
4ee218cd AM	95	(unsigned long long)lc->start);
1da177e4 LT	96	break;
	97	}
	98	return 0;
	99	}
	100
	101	static struct target_type linear_target = {
	102	.name = "linear",
	103	.version= {1, 0, 1},
	104	.module = THIS_MODULE,
	105	.ctr = linear_ctr,
	106	.dtr = linear_dtr,
	107	.map = linear_map,
	108	.status = linear_status,
	109	};
	110
	111	int __init dm_linear_init(void)
	112	{
	113	int r = dm_register_target(&linear_target);
	114
	115	if (r < 0)
72d94861	116	DMERR("register failed %d", r);
1da177e4 LT	117
	118	return r;
	119	}
	120
	121	void dm_linear_exit(void)
	122	{
	123	int r = dm_unregister_target(&linear_target);
	124
	125	if (r < 0)
72d94861	126	DMERR("unregister failed %d", r);
1da177e4	127	}