2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2001-2003 Sistina Software (UK) Limited.
|
|
|
|
*
|
|
|
|
* This file is released under the GPL.
|
|
|
|
*/
|
|
|
|
|
2008-10-21 18:44:59 +02:00
|
|
|
#include <linux/device-mapper.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/blkdev.h>
|
|
|
|
#include <linux/bio.h>
|
|
|
|
#include <linux/slab.h>
|
2007-10-19 23:38:44 +02:00
|
|
|
#include <linux/log2.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-06-26 09:27:35 +02:00
|
|
|
#define DM_MSG_PREFIX "striped"
|
2008-02-08 03:11:22 +01:00
|
|
|
#define DM_IO_ERROR_THRESHOLD 15
|
2006-06-26 09:27:35 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
struct stripe {
|
|
|
|
struct dm_dev *dev;
|
|
|
|
sector_t physical_start;
|
2008-02-08 03:11:22 +01:00
|
|
|
|
|
|
|
atomic_t error_count;
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
struct stripe_c {
|
|
|
|
uint32_t stripes;
|
2010-08-12 05:14:21 +02:00
|
|
|
int stripes_shift;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* The size of this target / num. stripes */
|
|
|
|
sector_t stripe_width;
|
|
|
|
|
2012-07-27 16:08:01 +02:00
|
|
|
uint32_t chunk_size;
|
2012-07-27 16:08:02 +02:00
|
|
|
int chunk_size_shift;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-02-08 03:11:22 +01:00
|
|
|
/* Needed for handling events */
|
|
|
|
struct dm_target *ti;
|
|
|
|
|
|
|
|
/* Work struct used for triggering events*/
|
2011-01-13 20:59:57 +01:00
|
|
|
struct work_struct trigger_event;
|
2008-02-08 03:11:22 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
struct stripe stripe[0];
|
|
|
|
};
|
|
|
|
|
2008-02-08 03:11:22 +01:00
|
|
|
/*
|
|
|
|
* An event is triggered whenever a drive
|
|
|
|
* drops out of a stripe volume.
|
|
|
|
*/
|
|
|
|
static void trigger_event(struct work_struct *work)
|
|
|
|
{
|
2011-01-13 20:59:57 +01:00
|
|
|
struct stripe_c *sc = container_of(work, struct stripe_c,
|
|
|
|
trigger_event);
|
2008-02-08 03:11:22 +01:00
|
|
|
dm_table_event(sc->ti->table);
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
static inline struct stripe_c *alloc_context(unsigned int stripes)
|
|
|
|
{
|
|
|
|
size_t len;
|
|
|
|
|
2008-10-21 18:44:57 +02:00
|
|
|
if (dm_array_too_big(sizeof(struct stripe_c), sizeof(struct stripe),
|
|
|
|
stripes))
|
2005-04-17 00:20:36 +02:00
|
|
|
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,
|
|
|
|
unsigned int stripe, char **argv)
|
|
|
|
{
|
2006-03-27 11:17:48 +02:00
|
|
|
unsigned long long start;
|
dm: reject trailing characters in sccanf input
Device mapper uses sscanf to convert arguments to numbers. The problem is that
the way we use it ignores additional unmatched characters in the scanned string.
For example, this `if (sscanf(string, "%d", &number) == 1)' will match a number,
but also it will match number with some garbage appended, like "123abc".
As a result, device mapper accepts garbage after some numbers. For example
the command `dmsetup create vg1-new --table "0 16384 linear 254:1bla 34816bla"'
will pass without an error.
This patch fixes all sscanf uses in device mapper. It appends "%c" with
a pointer to a dummy character variable to every sscanf statement.
The construct `if (sscanf(string, "%d%c", &number, &dummy) == 1)' succeeds
only if string is a null-terminated number (optionally preceded by some
whitespace characters). If there is some character appended after the number,
sscanf matches "%c", writes the character to the dummy variable and returns 2.
We check the return value for 1 and consequently reject numbers with some
garbage appended.
Signed-off-by: Mikulas Patocka <mpatocka@redhat.com>
Acked-by: Mike Snitzer <snitzer@redhat.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2012-03-28 19:41:26 +02:00
|
|
|
char dummy;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
dm: reject trailing characters in sccanf input
Device mapper uses sscanf to convert arguments to numbers. The problem is that
the way we use it ignores additional unmatched characters in the scanned string.
For example, this `if (sscanf(string, "%d", &number) == 1)' will match a number,
but also it will match number with some garbage appended, like "123abc".
As a result, device mapper accepts garbage after some numbers. For example
the command `dmsetup create vg1-new --table "0 16384 linear 254:1bla 34816bla"'
will pass without an error.
This patch fixes all sscanf uses in device mapper. It appends "%c" with
a pointer to a dummy character variable to every sscanf statement.
The construct `if (sscanf(string, "%d%c", &number, &dummy) == 1)' succeeds
only if string is a null-terminated number (optionally preceded by some
whitespace characters). If there is some character appended after the number,
sscanf matches "%c", writes the character to the dummy variable and returns 2.
We check the return value for 1 and consequently reject numbers with some
garbage appended.
Signed-off-by: Mikulas Patocka <mpatocka@redhat.com>
Acked-by: Mike Snitzer <snitzer@redhat.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2012-03-28 19:41:26 +02:00
|
|
|
if (sscanf(argv[1], "%llu%c", &start, &dummy) != 1)
|
2005-04-17 00:20:36 +02:00
|
|
|
return -EINVAL;
|
|
|
|
|
2010-03-06 03:32:27 +01:00
|
|
|
if (dm_get_device(ti, argv[0], dm_table_get_mode(ti->table),
|
2005-04-17 00:20:36 +02:00
|
|
|
&sc->stripe[stripe].dev))
|
|
|
|
return -ENXIO;
|
|
|
|
|
|
|
|
sc->stripe[stripe].physical_start = start;
|
2008-02-08 03:11:22 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Construct a striped mapping.
|
2012-07-27 16:08:01 +02:00
|
|
|
* <number of stripes> <chunk size> [<dev_path> <offset>]+
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
|
|
|
static int stripe_ctr(struct dm_target *ti, unsigned int argc, char **argv)
|
|
|
|
{
|
|
|
|
struct stripe_c *sc;
|
|
|
|
sector_t width;
|
|
|
|
uint32_t stripes;
|
|
|
|
uint32_t chunk_size;
|
|
|
|
int r;
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
if (argc < 2) {
|
2006-06-26 09:27:35 +02:00
|
|
|
ti->error = "Not enough arguments";
|
2005-04-17 00:20:36 +02:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2012-07-27 16:07:59 +02:00
|
|
|
if (kstrtouint(argv[0], 10, &stripes) || !stripes) {
|
2006-06-26 09:27:35 +02:00
|
|
|
ti->error = "Invalid stripe count";
|
2005-04-17 00:20:36 +02:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2012-07-27 16:08:01 +02:00
|
|
|
if (kstrtouint(argv[1], 10, &chunk_size) || !chunk_size) {
|
2012-07-27 16:08:01 +02:00
|
|
|
ti->error = "Invalid chunk_size";
|
2005-04-17 00:20:36 +02:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2012-07-27 16:08:01 +02:00
|
|
|
width = ti->len;
|
|
|
|
if (sector_div(width, chunk_size)) {
|
2006-06-26 09:27:35 +02:00
|
|
|
ti->error = "Target length not divisible by "
|
2006-03-17 08:04:03 +01:00
|
|
|
"chunk size";
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
if (sector_div(width, stripes)) {
|
2006-06-26 09:27:35 +02:00
|
|
|
ti->error = "Target length not divisible by "
|
2005-04-17 00:20:36 +02:00
|
|
|
"number of stripes";
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Do we have enough arguments for that many stripes ?
|
|
|
|
*/
|
|
|
|
if (argc != (2 + 2 * stripes)) {
|
2006-06-26 09:27:35 +02:00
|
|
|
ti->error = "Not enough destinations "
|
2005-04-17 00:20:36 +02:00
|
|
|
"specified";
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
sc = alloc_context(stripes);
|
|
|
|
if (!sc) {
|
2006-06-26 09:27:35 +02:00
|
|
|
ti->error = "Memory allocation for striped context "
|
2005-04-17 00:20:36 +02:00
|
|
|
"failed";
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2011-01-13 20:59:57 +01:00
|
|
|
INIT_WORK(&sc->trigger_event, trigger_event);
|
2008-02-08 03:11:22 +01:00
|
|
|
|
|
|
|
/* Set pointer to dm target; used in trigger_event */
|
|
|
|
sc->ti = ti;
|
2005-04-17 00:20:36 +02:00
|
|
|
sc->stripes = stripes;
|
|
|
|
sc->stripe_width = width;
|
2010-08-12 05:14:21 +02:00
|
|
|
|
|
|
|
if (stripes & (stripes - 1))
|
|
|
|
sc->stripes_shift = -1;
|
2012-07-27 16:08:00 +02:00
|
|
|
else
|
|
|
|
sc->stripes_shift = __ffs(stripes);
|
2010-08-12 05:14:21 +02:00
|
|
|
|
2012-07-27 16:08:00 +02:00
|
|
|
r = dm_set_target_max_io_len(ti, chunk_size);
|
|
|
|
if (r)
|
|
|
|
return r;
|
|
|
|
|
2009-06-22 11:12:22 +02:00
|
|
|
ti->num_flush_requests = stripes;
|
2010-08-12 05:14:26 +02:00
|
|
|
ti->num_discard_requests = stripes;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2012-07-27 16:08:01 +02:00
|
|
|
sc->chunk_size = chunk_size;
|
2012-07-27 16:08:02 +02:00
|
|
|
if (chunk_size & (chunk_size - 1))
|
|
|
|
sc->chunk_size_shift = -1;
|
|
|
|
else
|
|
|
|
sc->chunk_size_shift = __ffs(chunk_size);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Get the stripe destinations.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < stripes; i++) {
|
|
|
|
argv += 2;
|
|
|
|
|
|
|
|
r = get_stripe(ti, sc, i, argv);
|
|
|
|
if (r < 0) {
|
2006-06-26 09:27:35 +02:00
|
|
|
ti->error = "Couldn't parse stripe destination";
|
2005-04-17 00:20:36 +02:00
|
|
|
while (i--)
|
|
|
|
dm_put_device(ti, sc->stripe[i].dev);
|
|
|
|
kfree(sc);
|
|
|
|
return r;
|
|
|
|
}
|
2008-02-08 03:11:22 +01:00
|
|
|
atomic_set(&(sc->stripe[i].error_count), 0);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
ti->private = sc;
|
2008-02-08 03:11:22 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
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);
|
|
|
|
|
2012-08-20 23:51:24 +02:00
|
|
|
flush_work(&sc->trigger_event);
|
2005-04-17 00:20:36 +02:00
|
|
|
kfree(sc);
|
|
|
|
}
|
|
|
|
|
2010-08-12 05:14:14 +02:00
|
|
|
static void stripe_map_sector(struct stripe_c *sc, sector_t sector,
|
|
|
|
uint32_t *stripe, sector_t *result)
|
|
|
|
{
|
2012-07-27 16:08:01 +02:00
|
|
|
sector_t chunk = dm_target_offset(sc->ti, sector);
|
2012-07-27 16:08:02 +02:00
|
|
|
sector_t chunk_offset;
|
|
|
|
|
|
|
|
if (sc->chunk_size_shift < 0)
|
|
|
|
chunk_offset = sector_div(chunk, sc->chunk_size);
|
|
|
|
else {
|
|
|
|
chunk_offset = chunk & (sc->chunk_size - 1);
|
|
|
|
chunk >>= sc->chunk_size_shift;
|
|
|
|
}
|
2010-08-12 05:14:14 +02:00
|
|
|
|
2010-08-12 05:14:21 +02:00
|
|
|
if (sc->stripes_shift < 0)
|
|
|
|
*stripe = sector_div(chunk, sc->stripes);
|
|
|
|
else {
|
2012-07-27 16:08:00 +02:00
|
|
|
*stripe = chunk & (sc->stripes - 1);
|
2010-08-12 05:14:21 +02:00
|
|
|
chunk >>= sc->stripes_shift;
|
|
|
|
}
|
|
|
|
|
2012-07-27 16:08:02 +02:00
|
|
|
if (sc->chunk_size_shift < 0)
|
|
|
|
chunk *= sc->chunk_size;
|
|
|
|
else
|
|
|
|
chunk <<= sc->chunk_size_shift;
|
|
|
|
|
|
|
|
*result = chunk + chunk_offset;
|
2010-08-12 05:14:14 +02:00
|
|
|
}
|
|
|
|
|
2010-08-12 05:14:26 +02:00
|
|
|
static void stripe_map_range_sector(struct stripe_c *sc, sector_t sector,
|
|
|
|
uint32_t target_stripe, sector_t *result)
|
|
|
|
{
|
|
|
|
uint32_t stripe;
|
|
|
|
|
|
|
|
stripe_map_sector(sc, sector, &stripe, result);
|
|
|
|
if (stripe == target_stripe)
|
|
|
|
return;
|
2012-07-27 16:08:01 +02:00
|
|
|
|
|
|
|
/* round down */
|
|
|
|
sector = *result;
|
2012-07-27 16:08:02 +02:00
|
|
|
if (sc->chunk_size_shift < 0)
|
|
|
|
*result -= sector_div(sector, sc->chunk_size);
|
|
|
|
else
|
|
|
|
*result = sector & ~(sector_t)(sc->chunk_size - 1);
|
2012-07-27 16:08:01 +02:00
|
|
|
|
2010-08-12 05:14:26 +02:00
|
|
|
if (target_stripe < stripe)
|
2012-07-27 16:08:01 +02:00
|
|
|
*result += sc->chunk_size; /* next chunk */
|
2010-08-12 05:14:26 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int stripe_map_discard(struct stripe_c *sc, struct bio *bio,
|
|
|
|
uint32_t target_stripe)
|
|
|
|
{
|
|
|
|
sector_t begin, end;
|
|
|
|
|
|
|
|
stripe_map_range_sector(sc, bio->bi_sector, target_stripe, &begin);
|
|
|
|
stripe_map_range_sector(sc, bio->bi_sector + bio_sectors(bio),
|
|
|
|
target_stripe, &end);
|
|
|
|
if (begin < end) {
|
|
|
|
bio->bi_bdev = sc->stripe[target_stripe].dev->bdev;
|
|
|
|
bio->bi_sector = begin + sc->stripe[target_stripe].physical_start;
|
|
|
|
bio->bi_size = to_bytes(end - begin);
|
|
|
|
return DM_MAPIO_REMAPPED;
|
|
|
|
} else {
|
|
|
|
/* The range doesn't map to the target stripe */
|
|
|
|
bio_endio(bio, 0);
|
|
|
|
return DM_MAPIO_SUBMITTED;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
static int stripe_map(struct dm_target *ti, struct bio *bio,
|
|
|
|
union map_info *map_context)
|
|
|
|
{
|
2010-08-12 05:14:14 +02:00
|
|
|
struct stripe_c *sc = ti->private;
|
2009-06-22 11:12:22 +02:00
|
|
|
uint32_t stripe;
|
2010-08-12 05:14:04 +02:00
|
|
|
unsigned target_request_nr;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2010-09-03 11:56:19 +02:00
|
|
|
if (bio->bi_rw & REQ_FLUSH) {
|
2010-08-12 05:14:04 +02:00
|
|
|
target_request_nr = map_context->target_request_nr;
|
|
|
|
BUG_ON(target_request_nr >= sc->stripes);
|
|
|
|
bio->bi_bdev = sc->stripe[target_request_nr].dev->bdev;
|
2009-06-22 11:12:22 +02:00
|
|
|
return DM_MAPIO_REMAPPED;
|
|
|
|
}
|
2010-08-12 05:14:26 +02:00
|
|
|
if (unlikely(bio->bi_rw & REQ_DISCARD)) {
|
|
|
|
target_request_nr = map_context->target_request_nr;
|
|
|
|
BUG_ON(target_request_nr >= sc->stripes);
|
|
|
|
return stripe_map_discard(sc, bio, target_request_nr);
|
|
|
|
}
|
2009-06-22 11:12:22 +02:00
|
|
|
|
2010-08-12 05:14:14 +02:00
|
|
|
stripe_map_sector(sc, bio->bi_sector, &stripe, &bio->bi_sector);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2010-08-12 05:14:14 +02:00
|
|
|
bio->bi_sector += sc->stripe[stripe].physical_start;
|
2005-04-17 00:20:36 +02:00
|
|
|
bio->bi_bdev = sc->stripe[stripe].dev->bdev;
|
2010-08-12 05:14:14 +02:00
|
|
|
|
2006-12-08 11:41:06 +01:00
|
|
|
return DM_MAPIO_REMAPPED;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-02-08 03:11:24 +01:00
|
|
|
/*
|
|
|
|
* Stripe status:
|
|
|
|
*
|
|
|
|
* INFO
|
|
|
|
* #stripes [stripe_name <stripe_name>] [group word count]
|
|
|
|
* [error count 'A|D' <error count 'A|D'>]
|
|
|
|
*
|
|
|
|
* TABLE
|
|
|
|
* #stripes [stripe chunk size]
|
|
|
|
* [stripe_name physical_start <stripe_name physical_start>]
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2012-07-27 16:08:16 +02:00
|
|
|
static int stripe_status(struct dm_target *ti, status_type_t type,
|
|
|
|
unsigned status_flags, char *result, unsigned maxlen)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct stripe_c *sc = (struct stripe_c *) ti->private;
|
2008-02-08 03:11:24 +01:00
|
|
|
char buffer[sc->stripes + 1];
|
2005-04-17 00:20:36 +02:00
|
|
|
unsigned int sz = 0;
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
switch (type) {
|
|
|
|
case STATUSTYPE_INFO:
|
2008-02-08 03:11:24 +01:00
|
|
|
DMEMIT("%d ", sc->stripes);
|
|
|
|
for (i = 0; i < sc->stripes; i++) {
|
|
|
|
DMEMIT("%s ", sc->stripe[i].dev->name);
|
|
|
|
buffer[i] = atomic_read(&(sc->stripe[i].error_count)) ?
|
|
|
|
'D' : 'A';
|
|
|
|
}
|
|
|
|
buffer[i] = '\0';
|
|
|
|
DMEMIT("1 %s", buffer);
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
case STATUSTYPE_TABLE:
|
2006-03-27 11:17:48 +02:00
|
|
|
DMEMIT("%d %llu", sc->stripes,
|
2012-07-27 16:08:01 +02:00
|
|
|
(unsigned long long)sc->chunk_size);
|
2005-04-17 00:20:36 +02:00
|
|
|
for (i = 0; i < sc->stripes; i++)
|
2006-03-27 11:17:48 +02:00
|
|
|
DMEMIT(" %s %llu", sc->stripe[i].dev->name,
|
|
|
|
(unsigned long long)sc->stripe[i].physical_start);
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-02-08 03:11:22 +01:00
|
|
|
static int stripe_end_io(struct dm_target *ti, struct bio *bio,
|
|
|
|
int error, union map_info *map_context)
|
|
|
|
{
|
|
|
|
unsigned i;
|
|
|
|
char major_minor[16];
|
|
|
|
struct stripe_c *sc = ti->private;
|
|
|
|
|
|
|
|
if (!error)
|
|
|
|
return 0; /* I/O complete */
|
|
|
|
|
2010-08-07 18:20:39 +02:00
|
|
|
if ((error == -EWOULDBLOCK) && (bio->bi_rw & REQ_RAHEAD))
|
2008-02-08 03:11:22 +01:00
|
|
|
return error;
|
|
|
|
|
|
|
|
if (error == -EOPNOTSUPP)
|
|
|
|
return error;
|
|
|
|
|
|
|
|
memset(major_minor, 0, sizeof(major_minor));
|
|
|
|
sprintf(major_minor, "%d:%d",
|
2008-09-03 09:01:48 +02:00
|
|
|
MAJOR(disk_devt(bio->bi_bdev->bd_disk)),
|
|
|
|
MINOR(disk_devt(bio->bi_bdev->bd_disk)));
|
2008-02-08 03:11:22 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Test to see which stripe drive triggered the event
|
|
|
|
* and increment error count for all stripes on that device.
|
|
|
|
* If the error count for a given device exceeds the threshold
|
|
|
|
* value we will no longer trigger any further events.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < sc->stripes; i++)
|
|
|
|
if (!strcmp(sc->stripe[i].dev->name, major_minor)) {
|
|
|
|
atomic_inc(&(sc->stripe[i].error_count));
|
|
|
|
if (atomic_read(&(sc->stripe[i].error_count)) <
|
|
|
|
DM_IO_ERROR_THRESHOLD)
|
2011-01-13 20:59:57 +01:00
|
|
|
schedule_work(&sc->trigger_event);
|
2008-02-08 03:11:22 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2009-06-22 11:12:33 +02:00
|
|
|
static int stripe_iterate_devices(struct dm_target *ti,
|
|
|
|
iterate_devices_callout_fn fn, void *data)
|
|
|
|
{
|
|
|
|
struct stripe_c *sc = ti->private;
|
|
|
|
int ret = 0;
|
|
|
|
unsigned i = 0;
|
|
|
|
|
2009-07-23 21:30:42 +02:00
|
|
|
do {
|
2009-06-22 11:12:33 +02:00
|
|
|
ret = fn(ti, sc->stripe[i].dev,
|
2009-07-23 21:30:42 +02:00
|
|
|
sc->stripe[i].physical_start,
|
|
|
|
sc->stripe_width, data);
|
|
|
|
} while (!ret && ++i < sc->stripes);
|
2009-06-22 11:12:33 +02:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-09-04 21:40:25 +02:00
|
|
|
static void stripe_io_hints(struct dm_target *ti,
|
|
|
|
struct queue_limits *limits)
|
|
|
|
{
|
|
|
|
struct stripe_c *sc = ti->private;
|
2012-07-27 16:08:01 +02:00
|
|
|
unsigned chunk_size = sc->chunk_size << SECTOR_SHIFT;
|
2009-09-04 21:40:25 +02:00
|
|
|
|
|
|
|
blk_limits_io_min(limits, chunk_size);
|
2009-09-11 21:54:52 +02:00
|
|
|
blk_limits_io_opt(limits, chunk_size * sc->stripes);
|
2009-09-04 21:40:25 +02:00
|
|
|
}
|
|
|
|
|
2011-03-24 14:54:35 +01:00
|
|
|
static int stripe_merge(struct dm_target *ti, struct bvec_merge_data *bvm,
|
|
|
|
struct bio_vec *biovec, int max_size)
|
|
|
|
{
|
|
|
|
struct stripe_c *sc = ti->private;
|
|
|
|
sector_t bvm_sector = bvm->bi_sector;
|
|
|
|
uint32_t stripe;
|
|
|
|
struct request_queue *q;
|
|
|
|
|
|
|
|
stripe_map_sector(sc, bvm_sector, &stripe, &bvm_sector);
|
|
|
|
|
|
|
|
q = bdev_get_queue(sc->stripe[stripe].dev->bdev);
|
|
|
|
if (!q->merge_bvec_fn)
|
|
|
|
return max_size;
|
|
|
|
|
|
|
|
bvm->bi_bdev = sc->stripe[stripe].dev->bdev;
|
|
|
|
bvm->bi_sector = sc->stripe[stripe].physical_start + bvm_sector;
|
|
|
|
|
|
|
|
return min(max_size, q->merge_bvec_fn(q, bvm, biovec));
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
static struct target_type stripe_target = {
|
|
|
|
.name = "striped",
|
2012-07-27 16:08:01 +02:00
|
|
|
.version = {1, 5, 0},
|
2005-04-17 00:20:36 +02:00
|
|
|
.module = THIS_MODULE,
|
|
|
|
.ctr = stripe_ctr,
|
|
|
|
.dtr = stripe_dtr,
|
|
|
|
.map = stripe_map,
|
2008-02-08 03:11:22 +01:00
|
|
|
.end_io = stripe_end_io,
|
2005-04-17 00:20:36 +02:00
|
|
|
.status = stripe_status,
|
2009-06-22 11:12:33 +02:00
|
|
|
.iterate_devices = stripe_iterate_devices,
|
2009-09-04 21:40:25 +02:00
|
|
|
.io_hints = stripe_io_hints,
|
2011-03-24 14:54:35 +01:00
|
|
|
.merge = stripe_merge,
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
int __init dm_stripe_init(void)
|
|
|
|
{
|
|
|
|
int r;
|
|
|
|
|
|
|
|
r = dm_register_target(&stripe_target);
|
2008-11-14 00:38:56 +01:00
|
|
|
if (r < 0) {
|
2006-06-26 09:27:35 +02:00
|
|
|
DMWARN("target registration failed");
|
2008-11-14 00:38:56 +01:00
|
|
|
return r;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
void dm_stripe_exit(void)
|
|
|
|
{
|
2009-01-06 04:04:58 +01:00
|
|
|
dm_unregister_target(&stripe_target);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|