2007-05-09 16:33:06 +07:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2005-2007 Red Hat GmbH
|
|
|
|
*
|
|
|
|
* A target that delays reads and/or writes and can send
|
|
|
|
* them to different devices.
|
|
|
|
*
|
|
|
|
* This file is released under the GPL.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/blkdev.h>
|
|
|
|
#include <linux/bio.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
|
2008-10-21 23:44:59 +07:00
|
|
|
#include <linux/device-mapper.h>
|
|
|
|
|
2007-05-09 16:33:06 +07:00
|
|
|
#define DM_MSG_PREFIX "delay"
|
|
|
|
|
|
|
|
struct delay_c {
|
|
|
|
struct timer_list delay_timer;
|
2007-07-12 23:26:47 +07:00
|
|
|
struct mutex timer_lock;
|
2013-11-16 04:12:20 +07:00
|
|
|
struct workqueue_struct *kdelayd_wq;
|
2007-05-09 16:33:06 +07:00
|
|
|
struct work_struct flush_expired_bios;
|
|
|
|
struct list_head delayed_bios;
|
|
|
|
atomic_t may_delay;
|
|
|
|
|
|
|
|
struct dm_dev *dev_read;
|
|
|
|
sector_t start_read;
|
|
|
|
unsigned read_delay;
|
|
|
|
unsigned reads;
|
|
|
|
|
|
|
|
struct dm_dev *dev_write;
|
|
|
|
sector_t start_write;
|
|
|
|
unsigned write_delay;
|
|
|
|
unsigned writes;
|
|
|
|
};
|
|
|
|
|
2007-07-12 23:26:32 +07:00
|
|
|
struct dm_delay_info {
|
2007-05-09 16:33:06 +07:00
|
|
|
struct delay_c *context;
|
|
|
|
struct list_head list;
|
|
|
|
unsigned long expires;
|
|
|
|
};
|
|
|
|
|
|
|
|
static DEFINE_MUTEX(delayed_bios_lock);
|
|
|
|
|
|
|
|
static void handle_delayed_timer(unsigned long data)
|
|
|
|
{
|
|
|
|
struct delay_c *dc = (struct delay_c *)data;
|
|
|
|
|
2013-11-16 04:12:20 +07:00
|
|
|
queue_work(dc->kdelayd_wq, &dc->flush_expired_bios);
|
2007-05-09 16:33:06 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void queue_timeout(struct delay_c *dc, unsigned long expires)
|
|
|
|
{
|
2007-07-12 23:26:47 +07:00
|
|
|
mutex_lock(&dc->timer_lock);
|
2007-05-09 16:33:06 +07:00
|
|
|
|
|
|
|
if (!timer_pending(&dc->delay_timer) || expires < dc->delay_timer.expires)
|
|
|
|
mod_timer(&dc->delay_timer, expires);
|
|
|
|
|
2007-07-12 23:26:47 +07:00
|
|
|
mutex_unlock(&dc->timer_lock);
|
2007-05-09 16:33:06 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void flush_bios(struct bio *bio)
|
|
|
|
{
|
|
|
|
struct bio *n;
|
|
|
|
|
|
|
|
while (bio) {
|
|
|
|
n = bio->bi_next;
|
|
|
|
bio->bi_next = NULL;
|
|
|
|
generic_make_request(bio);
|
|
|
|
bio = n;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct bio *flush_delayed_bios(struct delay_c *dc, int flush_all)
|
|
|
|
{
|
2007-07-12 23:26:32 +07:00
|
|
|
struct dm_delay_info *delayed, *next;
|
2007-05-09 16:33:06 +07:00
|
|
|
unsigned long next_expires = 0;
|
|
|
|
int start_timer = 0;
|
2007-10-20 04:38:55 +07:00
|
|
|
struct bio_list flush_bios = { };
|
2007-05-09 16:33:06 +07:00
|
|
|
|
|
|
|
mutex_lock(&delayed_bios_lock);
|
|
|
|
list_for_each_entry_safe(delayed, next, &dc->delayed_bios, list) {
|
|
|
|
if (flush_all || time_after_eq(jiffies, delayed->expires)) {
|
2013-11-16 04:12:51 +07:00
|
|
|
struct bio *bio = dm_bio_from_per_bio_data(delayed,
|
|
|
|
sizeof(struct dm_delay_info));
|
2007-05-09 16:33:06 +07:00
|
|
|
list_del(&delayed->list);
|
2013-11-16 04:12:51 +07:00
|
|
|
bio_list_add(&flush_bios, bio);
|
|
|
|
if ((bio_data_dir(bio) == WRITE))
|
2007-05-09 16:33:06 +07:00
|
|
|
delayed->context->writes--;
|
|
|
|
else
|
|
|
|
delayed->context->reads--;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!start_timer) {
|
|
|
|
start_timer = 1;
|
|
|
|
next_expires = delayed->expires;
|
|
|
|
} else
|
|
|
|
next_expires = min(next_expires, delayed->expires);
|
|
|
|
}
|
|
|
|
|
|
|
|
mutex_unlock(&delayed_bios_lock);
|
|
|
|
|
|
|
|
if (start_timer)
|
|
|
|
queue_timeout(dc, next_expires);
|
|
|
|
|
|
|
|
return bio_list_get(&flush_bios);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void flush_expired_bios(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct delay_c *dc;
|
|
|
|
|
|
|
|
dc = container_of(work, struct delay_c, flush_expired_bios);
|
|
|
|
flush_bios(flush_delayed_bios(dc, 0));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Mapping parameters:
|
|
|
|
* <device> <offset> <delay> [<write_device> <write_offset> <write_delay>]
|
|
|
|
*
|
|
|
|
* With separate write parameters, the first set is only used for reads.
|
|
|
|
* Delays are specified in milliseconds.
|
|
|
|
*/
|
|
|
|
static int delay_ctr(struct dm_target *ti, unsigned int argc, char **argv)
|
|
|
|
{
|
|
|
|
struct delay_c *dc;
|
|
|
|
unsigned long long tmpll;
|
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-29 00:41:26 +07:00
|
|
|
char dummy;
|
2015-07-31 20:20:36 +07:00
|
|
|
int ret;
|
2007-05-09 16:33:06 +07:00
|
|
|
|
|
|
|
if (argc != 3 && argc != 6) {
|
|
|
|
ti->error = "requires exactly 3 or 6 arguments";
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
dc = kmalloc(sizeof(*dc), GFP_KERNEL);
|
|
|
|
if (!dc) {
|
|
|
|
ti->error = "Cannot allocate context";
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
dc->reads = dc->writes = 0;
|
|
|
|
|
2015-07-31 20:20:36 +07:00
|
|
|
ret = -EINVAL;
|
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-29 00:41:26 +07:00
|
|
|
if (sscanf(argv[1], "%llu%c", &tmpll, &dummy) != 1) {
|
2007-05-09 16:33:06 +07:00
|
|
|
ti->error = "Invalid device sector";
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
dc->start_read = tmpll;
|
|
|
|
|
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-29 00:41:26 +07:00
|
|
|
if (sscanf(argv[2], "%u%c", &dc->read_delay, &dummy) != 1) {
|
2007-05-09 16:33:06 +07:00
|
|
|
ti->error = "Invalid delay";
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
|
2015-07-31 20:20:36 +07:00
|
|
|
ret = dm_get_device(ti, argv[0], dm_table_get_mode(ti->table),
|
|
|
|
&dc->dev_read);
|
|
|
|
if (ret) {
|
2007-05-09 16:33:06 +07:00
|
|
|
ti->error = "Device lookup failed";
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
|
2015-07-31 20:20:36 +07:00
|
|
|
ret = -EINVAL;
|
2007-10-20 04:38:41 +07:00
|
|
|
dc->dev_write = NULL;
|
|
|
|
if (argc == 3)
|
2007-05-09 16:33:06 +07:00
|
|
|
goto out;
|
|
|
|
|
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-29 00:41:26 +07:00
|
|
|
if (sscanf(argv[4], "%llu%c", &tmpll, &dummy) != 1) {
|
2007-05-09 16:33:06 +07:00
|
|
|
ti->error = "Invalid write device sector";
|
2007-10-20 04:38:41 +07:00
|
|
|
goto bad_dev_read;
|
2007-05-09 16:33:06 +07:00
|
|
|
}
|
|
|
|
dc->start_write = tmpll;
|
|
|
|
|
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-29 00:41:26 +07:00
|
|
|
if (sscanf(argv[5], "%u%c", &dc->write_delay, &dummy) != 1) {
|
2007-05-09 16:33:06 +07:00
|
|
|
ti->error = "Invalid write delay";
|
2007-10-20 04:38:41 +07:00
|
|
|
goto bad_dev_read;
|
2007-05-09 16:33:06 +07:00
|
|
|
}
|
|
|
|
|
2015-07-31 20:20:36 +07:00
|
|
|
ret = dm_get_device(ti, argv[3], dm_table_get_mode(ti->table),
|
|
|
|
&dc->dev_write);
|
|
|
|
if (ret) {
|
2007-05-09 16:33:06 +07:00
|
|
|
ti->error = "Write device lookup failed";
|
2007-10-20 04:38:41 +07:00
|
|
|
goto bad_dev_read;
|
2007-05-09 16:33:06 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
2015-07-31 20:20:36 +07:00
|
|
|
ret = -EINVAL;
|
2013-11-16 04:12:20 +07:00
|
|
|
dc->kdelayd_wq = alloc_workqueue("kdelayd", WQ_MEM_RECLAIM, 0);
|
|
|
|
if (!dc->kdelayd_wq) {
|
|
|
|
DMERR("Couldn't start kdelayd");
|
|
|
|
goto bad_queue;
|
|
|
|
}
|
|
|
|
|
2007-07-12 23:26:47 +07:00
|
|
|
setup_timer(&dc->delay_timer, handle_delayed_timer, (unsigned long)dc);
|
2007-05-09 16:33:06 +07:00
|
|
|
|
|
|
|
INIT_WORK(&dc->flush_expired_bios, flush_expired_bios);
|
|
|
|
INIT_LIST_HEAD(&dc->delayed_bios);
|
2007-07-12 23:26:47 +07:00
|
|
|
mutex_init(&dc->timer_lock);
|
2007-05-09 16:33:06 +07:00
|
|
|
atomic_set(&dc->may_delay, 1);
|
|
|
|
|
2013-03-02 05:45:47 +07:00
|
|
|
ti->num_flush_bios = 1;
|
|
|
|
ti->num_discard_bios = 1;
|
2013-11-16 04:12:51 +07:00
|
|
|
ti->per_bio_data_size = sizeof(struct dm_delay_info);
|
2007-05-09 16:33:06 +07:00
|
|
|
ti->private = dc;
|
|
|
|
return 0;
|
|
|
|
|
2013-11-16 04:12:20 +07:00
|
|
|
bad_queue:
|
2007-10-20 04:38:41 +07:00
|
|
|
if (dc->dev_write)
|
|
|
|
dm_put_device(ti, dc->dev_write);
|
|
|
|
bad_dev_read:
|
|
|
|
dm_put_device(ti, dc->dev_read);
|
2007-05-09 16:33:06 +07:00
|
|
|
bad:
|
|
|
|
kfree(dc);
|
2015-07-31 20:20:36 +07:00
|
|
|
return ret;
|
2007-05-09 16:33:06 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void delay_dtr(struct dm_target *ti)
|
|
|
|
{
|
|
|
|
struct delay_c *dc = ti->private;
|
|
|
|
|
2013-11-16 04:12:20 +07:00
|
|
|
destroy_workqueue(dc->kdelayd_wq);
|
2007-05-09 16:33:06 +07:00
|
|
|
|
|
|
|
dm_put_device(ti, dc->dev_read);
|
|
|
|
|
|
|
|
if (dc->dev_write)
|
|
|
|
dm_put_device(ti, dc->dev_write);
|
|
|
|
|
|
|
|
kfree(dc);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int delay_bio(struct delay_c *dc, int delay, struct bio *bio)
|
|
|
|
{
|
2007-07-12 23:26:32 +07:00
|
|
|
struct dm_delay_info *delayed;
|
2007-05-09 16:33:06 +07:00
|
|
|
unsigned long expires = 0;
|
|
|
|
|
|
|
|
if (!delay || !atomic_read(&dc->may_delay))
|
|
|
|
return 1;
|
|
|
|
|
2013-11-16 04:12:51 +07:00
|
|
|
delayed = dm_per_bio_data(bio, sizeof(struct dm_delay_info));
|
2007-05-09 16:33:06 +07:00
|
|
|
|
|
|
|
delayed->context = dc;
|
2015-03-17 18:47:58 +07:00
|
|
|
delayed->expires = expires = jiffies + msecs_to_jiffies(delay);
|
2007-05-09 16:33:06 +07:00
|
|
|
|
|
|
|
mutex_lock(&delayed_bios_lock);
|
|
|
|
|
|
|
|
if (bio_data_dir(bio) == WRITE)
|
|
|
|
dc->writes++;
|
|
|
|
else
|
|
|
|
dc->reads++;
|
|
|
|
|
|
|
|
list_add_tail(&delayed->list, &dc->delayed_bios);
|
|
|
|
|
|
|
|
mutex_unlock(&delayed_bios_lock);
|
|
|
|
|
|
|
|
queue_timeout(dc, expires);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void delay_presuspend(struct dm_target *ti)
|
|
|
|
{
|
|
|
|
struct delay_c *dc = ti->private;
|
|
|
|
|
|
|
|
atomic_set(&dc->may_delay, 0);
|
|
|
|
del_timer_sync(&dc->delay_timer);
|
|
|
|
flush_bios(flush_delayed_bios(dc, 1));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void delay_resume(struct dm_target *ti)
|
|
|
|
{
|
|
|
|
struct delay_c *dc = ti->private;
|
|
|
|
|
|
|
|
atomic_set(&dc->may_delay, 1);
|
|
|
|
}
|
|
|
|
|
2012-12-22 03:23:41 +07:00
|
|
|
static int delay_map(struct dm_target *ti, struct bio *bio)
|
2007-05-09 16:33:06 +07:00
|
|
|
{
|
|
|
|
struct delay_c *dc = ti->private;
|
|
|
|
|
|
|
|
if ((bio_data_dir(bio) == WRITE) && (dc->dev_write)) {
|
|
|
|
bio->bi_bdev = dc->dev_write->bdev;
|
2009-06-22 16:12:23 +07:00
|
|
|
if (bio_sectors(bio))
|
2013-10-12 05:44:27 +07:00
|
|
|
bio->bi_iter.bi_sector = dc->start_write +
|
|
|
|
dm_target_offset(ti, bio->bi_iter.bi_sector);
|
2007-05-09 16:33:06 +07:00
|
|
|
|
|
|
|
return delay_bio(dc, dc->write_delay, bio);
|
|
|
|
}
|
|
|
|
|
|
|
|
bio->bi_bdev = dc->dev_read->bdev;
|
2013-10-12 05:44:27 +07:00
|
|
|
bio->bi_iter.bi_sector = dc->start_read +
|
|
|
|
dm_target_offset(ti, bio->bi_iter.bi_sector);
|
2007-05-09 16:33:06 +07:00
|
|
|
|
|
|
|
return delay_bio(dc, dc->read_delay, bio);
|
|
|
|
}
|
|
|
|
|
2013-03-02 05:45:44 +07:00
|
|
|
static void delay_status(struct dm_target *ti, status_type_t type,
|
|
|
|
unsigned status_flags, char *result, unsigned maxlen)
|
2007-05-09 16:33:06 +07:00
|
|
|
{
|
|
|
|
struct delay_c *dc = ti->private;
|
|
|
|
int sz = 0;
|
|
|
|
|
|
|
|
switch (type) {
|
|
|
|
case STATUSTYPE_INFO:
|
|
|
|
DMEMIT("%u %u", dc->reads, dc->writes);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case STATUSTYPE_TABLE:
|
|
|
|
DMEMIT("%s %llu %u", dc->dev_read->name,
|
|
|
|
(unsigned long long) dc->start_read,
|
|
|
|
dc->read_delay);
|
|
|
|
if (dc->dev_write)
|
2007-10-20 04:38:42 +07:00
|
|
|
DMEMIT(" %s %llu %u", dc->dev_write->name,
|
2007-05-09 16:33:06 +07:00
|
|
|
(unsigned long long) dc->start_write,
|
|
|
|
dc->write_delay);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-06-22 16:12:33 +07:00
|
|
|
static int delay_iterate_devices(struct dm_target *ti,
|
|
|
|
iterate_devices_callout_fn fn, void *data)
|
|
|
|
{
|
|
|
|
struct delay_c *dc = ti->private;
|
|
|
|
int ret = 0;
|
|
|
|
|
2009-07-24 02:30:42 +07:00
|
|
|
ret = fn(ti, dc->dev_read, dc->start_read, ti->len, data);
|
2009-06-22 16:12:33 +07:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (dc->dev_write)
|
2009-07-24 02:30:42 +07:00
|
|
|
ret = fn(ti, dc->dev_write, dc->start_write, ti->len, data);
|
2009-06-22 16:12:33 +07:00
|
|
|
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2007-05-09 16:33:06 +07:00
|
|
|
static struct target_type delay_target = {
|
|
|
|
.name = "delay",
|
2013-03-02 05:45:44 +07:00
|
|
|
.version = {1, 2, 1},
|
2007-05-09 16:33:06 +07:00
|
|
|
.module = THIS_MODULE,
|
|
|
|
.ctr = delay_ctr,
|
|
|
|
.dtr = delay_dtr,
|
|
|
|
.map = delay_map,
|
|
|
|
.presuspend = delay_presuspend,
|
|
|
|
.resume = delay_resume,
|
|
|
|
.status = delay_status,
|
2009-06-22 16:12:33 +07:00
|
|
|
.iterate_devices = delay_iterate_devices,
|
2007-05-09 16:33:06 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
static int __init dm_delay_init(void)
|
|
|
|
{
|
2013-11-16 04:12:51 +07:00
|
|
|
int r;
|
2007-05-09 16:33:06 +07:00
|
|
|
|
|
|
|
r = dm_register_target(&delay_target);
|
|
|
|
if (r < 0) {
|
|
|
|
DMERR("register failed %d", r);
|
|
|
|
goto bad_register;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
bad_register:
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit dm_delay_exit(void)
|
|
|
|
{
|
2009-01-06 10:04:58 +07:00
|
|
|
dm_unregister_target(&delay_target);
|
2007-05-09 16:33:06 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Module hooks */
|
|
|
|
module_init(dm_delay_init);
|
|
|
|
module_exit(dm_delay_exit);
|
|
|
|
|
|
|
|
MODULE_DESCRIPTION(DM_NAME " delay target");
|
|
|
|
MODULE_AUTHOR("Heinz Mauelshagen <mauelshagen@redhat.com>");
|
|
|
|
MODULE_LICENSE("GPL");
|