[dm-devel] [PATCH v4] dm ebs: new block size emulating target
Heinz Mauelshagen
heinzm at redhat.com
Tue Mar 10 12:39:09 UTC 2020
On 3/9/20 11:44 PM, Damien Le Moal wrote:
> On 2020/03/10 7:26, heinzm at redhat.com wrote:
>> From: Heinz Mauelshagen <heinzm at redhat.com>
>>
>> dm ebs: new block size emulating target
>>
>> This new target is similar to the linear target except that it emulates
>> a smaller logical block size on devices with larger ones. It's main
>> purpose is to emulate 512 byte sectors on 4K native disks (i.e. 512e).
>>
>> See Documentation/admin-guide/device-mapper/dm-ebs.rst for details.
>>
>> Changes versus version 3 sent on 2/19/2020:
>>
>> - document 'struct ebs_c' and rename its blocksize and block shift fields
>> - inline functions (e.g. __nr_blocks())
>> - adjust __ebs_rw_bvec() function header format
>> - access page_address() after bv_page check; typo
>> - avoid superfluous check defining bi_status in __ebs_process_bios()
>> - correct indentation
>> - avoid op_is_flush() causing REQ_FUA bios to be
>> remapped hence not processed by the target
>> - call flush_dcache_page() correlated with memcpy() to ensure
>> D-cache aliasing as of cache and TLB flushing guidelines
>> - comments
> Generally, the change log is not added as part of the commit message and
> mentioned after the "---" and all change logs "from v1", "from v2" etc kept so
> that everybody can see the progression.
As of the kernel patch submission guidelines it should be part of:
'Describe your changes in imperative mood, e.g. “make xyzzy do frotz”
instead of “[This patch] makes xyzzy do frotz” or “[I] changed xyzzy to
do frotz”, as if you are giving orders to the codebase to change its
behaviour.'
The limitation to the v3 -> v4 changes was negotiated with Mike.
I'll keep it as is until further decision.
>> Reviewed-by: Damien Le Moal <DamienLeMoal at wdc.com>
>> Signed-off-by: Heinz Mauelshagen <heinzm at redhat.com>
>> ---
>> .../admin-guide/device-mapper/dm-ebs.rst | 51 ++
>> drivers/md/Kconfig | 8 +
>> drivers/md/Makefile | 2 +
>> drivers/md/dm-ebs-target.c | 439 ++++++++++++++++++
>> 4 files changed, 500 insertions(+)
>> create mode 100644 Documentation/admin-guide/device-mapper/dm-ebs.rst
>> create mode 100644 drivers/md/dm-ebs-target.c
>>
>> diff --git a/Documentation/admin-guide/device-mapper/dm-ebs.rst b/Documentation/admin-guide/device-mapper/dm-ebs.rst
>> new file mode 100644
>> index 000000000000..9e7abd3e0ae1
>> --- /dev/null
>> +++ b/Documentation/admin-guide/device-mapper/dm-ebs.rst
>> @@ -0,0 +1,51 @@
>> +======
>> +dm-ebs
>> +======
>> +
>> +
>> +This target is similar to the linear target, except that it emulates
>> +a smaller logical block size on devices with larger ones. Its main
>> +purpose is to provide emulation of 512 byte sectors on devices
>> +that do not provide this emulation (i.e. 4K native disks).
>> +
>> +Supported emulated logical block sizes 512, 1024, 2048 and 4096.
> Nit: there is no verb in this sentence.
Nit: colon missing ;)
Thanks,
Heinz
>
>> +
>> +Underlying block size can be set to > 4K to test buffering larger units.
>> +
>> +
>> +Table parameters
>> +----------------
>> + <dev path> <offset> <emulated sectors> [<underlying sectors>]
>> +
>> +Mandatory parameters:
>> +
>> + <dev path>:
>> + Full pathname to the underlying block-device,
>> + or a "major:minor" device-number.
>> + <offset>:
>> + Starting sector within the device;
>> + has to be a multiple of <emulated sectors>.
>> + <emulated sectors>:
>> + Number of sectors defining the logical block size to be emulated;
>> + 1, 2, 4, 8 sectors of 512 bytes supported.
>> +
>> +Optional parameter:
>> +
>> + <underyling sectors>:
>> + Number of sectors defining the logical block size of <dev path>.
>> + 2^N supported, e.g. 8 = emulate 8 sectors of 512 bytes = 4KiB.
>> + If not provided, the logical block size of <dev path> will be used.
>> +
>> +
>> +Examples:
>> +
>> +Emulate 1 sector = 512 bytes logical block size on /dev/sda starting at
>> +offset 1024 sectors with underlying devices block size automatically set:
>> +
>> +ebs /dev/sda 1024 1
>> +
>> +Emulate 2 sector = 1KiB logical block size on /dev/sda starting at
>> +offset 128 sectors, enforce 2KiB underlying device block size.
>> +This presumes 2KiB logical blocksize on /dev/sda or less to work:
>> +
>> +ebs /dev/sda 128 2 4
>> diff --git a/drivers/md/Kconfig b/drivers/md/Kconfig
>> index d6d5ab23c088..392974a2999d 100644
>> --- a/drivers/md/Kconfig
>> +++ b/drivers/md/Kconfig
>> @@ -336,6 +336,14 @@ config DM_WRITECACHE
>> The writecache target doesn't cache reads because reads are supposed
>> to be cached in standard RAM.
>>
>> +config DM_EBS
>> + tristate "Emulated block size target (EXPERIMENTAL)"
>> + depends on BLK_DEV_DM
>> + default n
>> + ---help---
>> + dm-ebs emulates smaller logical block size on backing devices
>> + with larger ones (e.g. 512 byte sectors on 4K native disks).
>> +
>> config DM_ERA
>> tristate "Era target (EXPERIMENTAL)"
>> depends on BLK_DEV_DM
>> diff --git a/drivers/md/Makefile b/drivers/md/Makefile
>> index d91a7edcd2ab..9a2d673f94bc 100644
>> --- a/drivers/md/Makefile
>> +++ b/drivers/md/Makefile
>> @@ -17,6 +17,7 @@ dm-thin-pool-y += dm-thin.o dm-thin-metadata.o
>> dm-cache-y += dm-cache-target.o dm-cache-metadata.o dm-cache-policy.o \
>> dm-cache-background-tracker.o
>> dm-cache-smq-y += dm-cache-policy-smq.o
>> +dm-ebs-y += dm-ebs-target.o
>> dm-era-y += dm-era-target.o
>> dm-clone-y += dm-clone-target.o dm-clone-metadata.o
>> dm-verity-y += dm-verity-target.o
>> @@ -65,6 +66,7 @@ obj-$(CONFIG_DM_THIN_PROVISIONING) += dm-thin-pool.o
>> obj-$(CONFIG_DM_VERITY) += dm-verity.o
>> obj-$(CONFIG_DM_CACHE) += dm-cache.o
>> obj-$(CONFIG_DM_CACHE_SMQ) += dm-cache-smq.o
>> +obj-$(CONFIG_DM_EBS) += dm-ebs.o
>> obj-$(CONFIG_DM_ERA) += dm-era.o
>> obj-$(CONFIG_DM_CLONE) += dm-clone.o
>> obj-$(CONFIG_DM_LOG_WRITES) += dm-log-writes.o
>> diff --git a/drivers/md/dm-ebs-target.c b/drivers/md/dm-ebs-target.c
>> new file mode 100644
>> index 000000000000..023354210dd2
>> --- /dev/null
>> +++ b/drivers/md/dm-ebs-target.c
>> @@ -0,0 +1,439 @@
>> +/*
>> + * Copyright (C) 2020 Red Hat GmbH
>> + *
>> + * This file is released under the GPL.
> Please us a SPDX header on top of the file instead of this sentence.
> E.g.
>
> // SPDX-License-Identifier: GPL-2.0
>
> as the file first line.
>
>> + *
>> + * Device-mapper target to emulate smaller logical block
>> + * size on backing devices exposing (natively) larger ones.
>> + *
>> + * E.g. 512 byte sector emulation on 4K native disks.
>> + */
>> +
>> +#include "dm.h"
>> +#include <linux/module.h>
>> +#include <linux/workqueue.h>
>> +#include <linux/dm-bufio.h>
>> +
>> +#define DM_MSG_PREFIX "ebs"
>> +
>> +static void ebs_dtr(struct dm_target *ti);
>> +
>> +/* Emulated block size context. */
>> +struct ebs_c {
>> + struct dm_dev *dev; /* Underlying device to emulate block size on. */
>> + struct dm_bufio_client *bufio; /* Use dm-bufio for read and read-modify-write processing. */
>> + struct workqueue_struct *wq; /* Workqueue for ^ processing of bios. */
>> + struct work_struct ws; /* Work item used for ^. */
>> + struct bio_list bios_in; /* Worker bios input list. */
>> + spinlock_t lock; /* Guard bios input list above. */
>> + sector_t start; /* <start> table line argument, see ebs_ctr below. */
>> + unsigned int e_bs; /* Emulated block size in sectors exposed to upper layer. */
>> + unsigned int u_bs; /* Underlying block size in sectors retrievd from/set on lower layer device. */
>> + unsigned char block_shift; /* bitshift sectors -> blocks used in dm-bufio API. */
>> + bool u_bs_set:1; /* Flag to indicate underlying block size is set on table line. */
>> +};
>> +
>> +static inline sector_t __sector_to_block(struct ebs_c *ec, sector_t sector)
>> +{
>> + return sector >> ec->block_shift;
>> +}
>> +
>> +static inline sector_t __block_mod(sector_t sector, unsigned int bs)
>> +{
>> + return sector & (bs - 1);
>> +}
>> +
>> +/* Return number of blocks for a bio accounting for misalignement of start and end sectors. */
>> +static inline unsigned int __nr_blocks(struct ebs_c *ec, struct bio *bio)
>> +{
>> + sector_t end_sector = __block_mod(bio->bi_iter.bi_sector, ec->u_bs) + bio_sectors(bio);
>> +
>> + return __sector_to_block(ec, end_sector) + (__block_mod(end_sector, ec->u_bs) ? 1 : 0);
>> +}
>> +
>> +static inline bool __ebs_check_bs(unsigned int bs)
>> +{
>> + return bs && is_power_of_2(bs);
>> +}
>> +
>> +/*
>> + * READ/WRITE:
>> + *
>> + * copy blocks between bufio blocks and bio vector's (partial/overlapping) pages.
>> + */
>> +static int __ebs_rw_bvec(struct ebs_c *ec, int rw, struct bio_vec *bv, struct bvec_iter *iter)
>> +{
>> + int r = 0;
>> + unsigned char *ba, *pa;
>> + unsigned int cur_len;
>> + unsigned int bv_len = bv->bv_len;
>> + unsigned int buf_off = to_bytes(__block_mod(iter->bi_sector, ec->u_bs));
>> + sector_t block = __sector_to_block(ec, iter->bi_sector);
>> + struct dm_buffer *b;
>> +
>> + if (unlikely(!bv->bv_page || !bv_len))
>> + return -EIO;
>> +
>> + pa = page_address(bv->bv_page) + bv->bv_offset;
>> +
>> + /* Handle overlapping page <-> blocks */
>> + while (bv_len) {
>> + cur_len = min(dm_bufio_get_block_size(ec->bufio) - buf_off, bv_len);
>> +
>> + /* Avoid reading for writes in case bio vector's page overwrites block completely. */
>> + if (rw == READ || buf_off || bv_len < dm_bufio_get_block_size(ec->bufio))
>> + ba = dm_bufio_read(ec->bufio, block, &b);
>> + else
>> + ba = dm_bufio_new(ec->bufio, block, &b);
>> +
>> + if (unlikely(IS_ERR(ba)))
>> + r = PTR_ERR(ba); /* Carry on with next buffer if any to I/O all possible data but return error. */
>> + else {
>> + /* Copy data to/from bio to buffer if read/new was successful above. */
>> + ba += buf_off;
>> + if (rw == READ) {
>> + memcpy(pa, ba, cur_len);
>> + flush_dcache_page(bv->bv_page);
>> + } else {
>> + flush_dcache_page(bv->bv_page);
>> + memcpy(ba, pa, cur_len);
>> + dm_bufio_mark_partial_buffer_dirty(b, buf_off, buf_off + cur_len);
>> + }
>> +
>> + dm_bufio_release(b);
>> + }
>> +
>> + pa += cur_len;
>> + bv_len -= cur_len;
>> + buf_off = 0;
>> + block++;
>> + }
>> +
>> + return r;
>> +}
>> +
>> +/* READ/WRITE: iterate bio vector's copying between (partial) pages and bufio blocks. */
>> +static int __ebs_rw_bio(struct ebs_c *ec, int rw, struct bio *bio)
>> +{
>> + int r = 0, rr;
>> + struct bio_vec bv;
>> + struct bvec_iter iter;
>> +
>> + bio_for_each_bvec(bv, bio, iter) {
>> + rr = __ebs_rw_bvec(ec, rw, &bv, &iter);
>> + if (rr)
>> + r = rr;
>> + }
>> +
>> + return r;
>> +}
>> +
>> +/* 'Discard' blocks, i.e. release them from the bufio cache. */
>> +static int __ebs_forget_bio(struct ebs_c *ec, struct bio *bio)
>> +{
>> + sector_t blocks, sector = bio->bi_iter.bi_sector;;
>> +
>> + blocks = __nr_blocks(ec, bio);
>> + for (; blocks--; sector += ec->u_bs)
>> + dm_bufio_forget(ec->bufio, __sector_to_block(ec, sector));
>> +
>> + return 0;
>> +}
>> +
>> +/* Worker funtion to process incoming bios. */
>> +static void __ebs_process_bios(struct work_struct *ws)
>> +{
>> + int r;
>> + bool write = false;
>> + sector_t block1, block2;
>> + struct ebs_c *ec = container_of(ws, struct ebs_c, ws);
>> + struct bio *bio;
>> + struct bio_list bios;
>> +
>> + bio_list_init(&bios);
>> +
>> + spin_lock_irq(&ec->lock);
>> + bios = ec->bios_in;
>> + bio_list_init(&ec->bios_in);
>> + spin_unlock_irq(&ec->lock);
>> +
>> + /* Prefetch all read and any mis-aligned write buffers */
>> + bio_list_for_each(bio, &bios) {
>> + block1 = __sector_to_block(ec, bio->bi_iter.bi_sector);
>> + if (bio_op(bio) == REQ_OP_READ)
>> + dm_bufio_prefetch(ec->bufio, block1, __nr_blocks(ec, bio));
>> + else if (bio_op(bio) == REQ_OP_WRITE && !(bio->bi_opf & REQ_PREFLUSH)) {
>> + block2 = __sector_to_block(ec, bio_end_sector(bio));
>> + if (__block_mod(bio->bi_iter.bi_sector, ec->u_bs))
>> + dm_bufio_prefetch(ec->bufio, block1, 1);
>> + if (__block_mod(bio_end_sector(bio), ec->u_bs) && block2 != block1)
>> + dm_bufio_prefetch(ec->bufio, block2, 1);
>> + }
>> + }
>> +
>> + bio_list_for_each(bio, &bios) {
>> + r = -EIO;
>> +
>> + if (bio_op(bio) == REQ_OP_READ)
>> + r = __ebs_rw_bio(ec, READ, bio);
>> + else if (bio_op(bio) == REQ_OP_WRITE) {
>> + write = true;
>> + r = __ebs_rw_bio(ec, WRITE, bio);
>> + } else if (bio_op(bio) == REQ_OP_DISCARD)
>> + /* FIXME: (optionally) call dm_bufio_discard_buffers() once upstream. */
>> + r = __ebs_forget_bio(ec, bio);
>> +
>> + bio->bi_status = r;
>> + }
>> +
>> + /*
>> + * We write dirty buffers after processing I/O on them
>> + * but before we endio thus addressing REQ_FUA/REQ_SYNC.
>> + */
>> + r = write ? dm_bufio_write_dirty_buffers(ec->bufio) : 0;
>> +
>> + while ((bio = bio_list_pop(&bios))) {
>> + /* Any other request is endioed. */
>> + if (unlikely(r && bio_op(bio) == REQ_OP_WRITE))
>> + bio_io_error(bio);
>> + else
>> + bio_endio(bio);
>> + }
>> +}
>> +
>> +/*
>> + * Construct an emulated block size mapping: <dev_path> <offset> <ebs> [<ubs>]
>> + *
>> + * <dev_path>: path of the underlying device
>> + * <offset>: offset in 512 bytes sectors into <dev_path>
>> + * <ebs>: emulated block size in units of 512 bytes exposed to the upper layer
>> + * [<ubs>]: underlying block size in units of 512 bytes imposed on the lower layer;
>> + * optional, if not supplied, retrieve logical block size from underlying device
>> + */
>> +static int ebs_ctr(struct dm_target *ti, unsigned int argc, char **argv)
>> +{
>> + int r;
>> + unsigned short tmp1;
>> + unsigned long long tmp;
>> + char dummy;
>> + struct ebs_c *ec;
>> +
>> + if (argc < 3 || argc > 4) {
>> + ti->error = "Invalid argument count";
>> + return -EINVAL;
>> + }
>> +
>> + ec = ti->private = kzalloc(sizeof(*ec), GFP_KERNEL);
>> + if (!ec) {
>> + ti->error = "Cannot allocate ebs context";
>> + return -ENOMEM;
>> + }
>> +
>> + r = -EINVAL;
>> + if (sscanf(argv[1], "%llu%c", &tmp, &dummy) != 1 ||
>> + tmp != (sector_t)tmp ||
>> + (sector_t)tmp >= ti->len) {
>> + ti->error = "Invalid device offset sector";
>> + goto bad;
>> + }
>> + ec->start = tmp;
>> +
>> + if (sscanf(argv[2], "%hu%c", &tmp1, &dummy) != 1 ||
>> + !__ebs_check_bs(tmp1) ||
>> + to_bytes(tmp1) > PAGE_SIZE) {
>> + ti->error = "Invalid emulated block size";
>> + goto bad;
>> + }
>> + ec->e_bs = tmp1;
>> +
>> + if (argc > 3) {
>> + if (sscanf(argv[3], "%hu%c", &tmp1, &dummy) != 1 || !__ebs_check_bs(tmp1)) {
>> + ti->error = "Invalid underlying block size";
>> + goto bad;
>> + }
>> + ec->u_bs = tmp1;
>> + ec->u_bs_set = true;
>> + } else
>> + ec->u_bs_set = false;
>> +
>> + r = dm_get_device(ti, argv[0], dm_table_get_mode(ti->table), &ec->dev);
>> + if (r) {
>> + ti->error = "Device lookup failed";
>> + ec->dev = NULL;
>> + goto bad;
>> + }
>> +
>> + r = -EINVAL;
>> + if (!ec->u_bs_set) {
>> + ec->u_bs = to_sector(bdev_logical_block_size(ec->dev->bdev));
>> + if (!__ebs_check_bs(ec->u_bs)) {
>> + ti->error = "Invalid retrieved underlying block size";
>> + goto bad;
>> + }
>> + }
>> +
>> + if (!ec->u_bs_set && ec->e_bs == ec->u_bs)
>> + DMINFO("Emulation superfluous: emulated equal to underlying block size");
>> +
>> + if (__block_mod(ec->start, ec->u_bs)) {
>> + ti->error = "Device offset must be multiple of underlying block size";
>> + goto bad;
>> + }
>> +
>> + ec->bufio = dm_bufio_client_create(ec->dev->bdev, to_bytes(ec->u_bs), 1, 0, NULL, NULL);
>> + if (IS_ERR(ec->bufio)) {
>> + ti->error = "Cannot create dm bufio client";
>> + r = PTR_ERR(ec->bufio);
>> + ec->bufio = NULL;
>> + goto bad;
>> + }
>> +
>> + ec->wq = alloc_ordered_workqueue("dm-" DM_MSG_PREFIX, WQ_MEM_RECLAIM);
>> + if (!ec->wq) {
>> + ti->error = "Cannot create dm-" DM_MSG_PREFIX " workqueue";
>> + r = -ENOMEM;
>> + goto bad;
>> + }
>> +
>> + ec->block_shift = __ffs(ec->u_bs);
>> + INIT_WORK(&ec->ws, &__ebs_process_bios);
>> + bio_list_init(&ec->bios_in);
>> + spin_lock_init(&ec->lock);
>> +
>> + ti->num_flush_bios = 1;
>> + ti->num_discard_bios = 1;
>> + ti->num_secure_erase_bios = 0;
>> + ti->num_write_same_bios = 0;
>> + ti->num_write_zeroes_bios = 0;
>> + return 0;
>> +bad:
>> + ebs_dtr(ti);
>> + return r;
>> +}
>> +
>> +static void ebs_dtr(struct dm_target *ti)
>> +{
>> + struct ebs_c *ec = ti->private;
>> +
>> + if (ec->wq)
>> + destroy_workqueue(ec->wq);
>> + if (ec->bufio)
>> + dm_bufio_client_destroy(ec->bufio);
>> + if (ec->dev)
>> + dm_put_device(ti, ec->dev);
>> + kfree(ec);
>> +}
>> +
>> +static int ebs_map(struct dm_target *ti, struct bio *bio)
>> +{
>> + struct ebs_c *ec = ti->private;
>> +
>> + bio_set_dev(bio, ec->dev->bdev);
>> + bio->bi_iter.bi_sector = ec->start + dm_target_offset(ti, bio->bi_iter.bi_sector);
>> +
>> + if (unlikely(bio->bi_opf & REQ_OP_FLUSH))
>> + return DM_MAPIO_REMAPPED;
>> + /*
>> + * Only queue for bufio processing in case of partial or overlapping buffers
>> + * -or-
>> + * emulation with ebs == ubs aiming for tests of dm-bufio overhead.
>> + */
>> + if (likely(__block_mod(bio->bi_iter.bi_sector, ec->u_bs) ||
>> + __block_mod(bio_end_sector(bio), ec->u_bs) ||
>> + ec->e_bs == ec->u_bs)) {
>> + spin_lock_irq(&ec->lock);
>> + bio_list_add(&ec->bios_in, bio);
>> + spin_unlock_irq(&ec->lock);
>> +
>> + queue_work(ec->wq, &ec->ws);
>> +
>> + return DM_MAPIO_SUBMITTED;
>> + }
>> +
>> + /* Forget any buffer content relative to this direct backing device I/O. */
>> + __ebs_forget_bio(ec, bio);
>> +
>> + return DM_MAPIO_REMAPPED;
>> +}
>> +
>> +static void ebs_status(struct dm_target *ti, status_type_t type,
>> + unsigned status_flags, char *result, unsigned maxlen)
>> +{
>> + struct ebs_c *ec = ti->private;
>> +
>> + switch (type) {
>> + case STATUSTYPE_INFO:
>> + *result = '\0';
>> + break;
>> + case STATUSTYPE_TABLE:
>> + snprintf(result, maxlen, ec->u_bs_set ? "%s %llu %u %u" : "%s %llu %u",
>> + ec->dev->name, (unsigned long long) ec->start, ec->e_bs, ec->u_bs);
>> + break;
>> + }
>> +}
>> +
>> +static int ebs_prepare_ioctl(struct dm_target *ti, struct block_device **bdev)
>> +{
>> + struct ebs_c *ec = ti->private;
>> + struct dm_dev *dev = ec->dev;
>> +
>> + /*
>> + * Only pass ioctls through if the device sizes match exactly.
>> + */
>> + *bdev = dev->bdev;
>> + return !!(ec->start || ti->len != i_size_read(dev->bdev->bd_inode) >> SECTOR_SHIFT);
>> +}
>> +
>> +static void ebs_io_hints(struct dm_target *ti, struct queue_limits *limits)
>> +{
>> + struct ebs_c *ec = ti->private;
>> +
>> + limits->logical_block_size = to_bytes(ec->e_bs);
>> + limits->physical_block_size = to_bytes(ec->u_bs);
>> + limits->alignment_offset = limits->physical_block_size;
>> + blk_limits_io_min(limits, limits->logical_block_size);
>> +}
>> +
>> +static int ebs_iterate_devices(struct dm_target *ti,
>> + iterate_devices_callout_fn fn, void *data)
>> +{
>> + struct ebs_c *ec = ti->private;
>> +
>> + return fn(ti, ec->dev, ec->start, ti->len, data);
>> +}
>> +
>> +static struct target_type ebs_target = {
>> + .name = "ebs",
>> + .version = {1, 0, 0},
>> + .features = DM_TARGET_PASSES_INTEGRITY,
>> + .module = THIS_MODULE,
>> + .ctr = ebs_ctr,
>> + .dtr = ebs_dtr,
>> + .map = ebs_map,
>> + .status = ebs_status,
>> + .io_hints = ebs_io_hints,
>> + .prepare_ioctl = ebs_prepare_ioctl,
>> + .iterate_devices = ebs_iterate_devices,
>> +};
>> +
>> +int __init dm_ebs_init(void)
>> +{
>> + int r = dm_register_target(&ebs_target);
>> +
>> + if (r < 0)
>> + DMERR("register failed %d", r);
>> +
>> + return r;
>> +}
>> +
>> +void dm_ebs_exit(void)
>> +{
>> + dm_unregister_target(&ebs_target);
>> +}
>> +
>> +module_init(dm_ebs_init);
>> +module_exit(dm_ebs_exit);
>> +
>> +MODULE_AUTHOR("Heinz Mauelshagen <dm-devel at redhat.com>");
>> +MODULE_DESCRIPTION(DM_NAME " emulated block size target");
>> +MODULE_LICENSE("GPL");
>>
More information about the dm-devel
mailing list