dm: Add dm-flakey target
Ported from DragonFlyBSD, but this target had originally existed in Linux kernel. See below for details. https://www.kernel.org/doc/Documentation/device-mapper/dm-flakey.txt Due to two technical issues, this hasn't been hooked to dm.kmod yet. 1) "tick" in hz(9) not working. 2) Unable to use ->b_private in nestiobuf callback when it's already used for mbp (see HAS_BUF_PRIV2). taken-from: DragonFlyBSD
This commit is contained in:
tkusumi
parent
06758b70da
commit
8dab45b63f
@ -1,4 +1,4 @@
|
||||
/* $NetBSD: dm.h,v 1.52 2019/12/23 16:17:35 tkusumi Exp $ */
|
||||
/* $NetBSD: dm.h,v 1.53 2020/01/02 06:22:23 tkusumi Exp $ */
|
||||
|
||||
/*
|
||||
* Copyright (c) 2008 The NetBSD Foundation, Inc.
|
||||
@ -272,6 +272,17 @@ int dm_target_zero_strategy(dm_table_entry_t *, struct buf *);
|
||||
int dm_target_zero_destroy(dm_table_entry_t *);
|
||||
int dm_target_zero_upcall(dm_table_entry_t *, struct buf *);
|
||||
|
||||
#if 0
|
||||
/* dm_target_flakey.c */
|
||||
int dm_target_flakey_init(dm_table_entry_t *, int, char **);
|
||||
char *dm_target_flakey_table(void *);
|
||||
int dm_target_flakey_strategy(dm_table_entry_t *, struct buf *);
|
||||
int dm_target_flakey_sync(dm_table_entry_t *);
|
||||
int dm_target_flakey_destroy(dm_table_entry_t *);
|
||||
int dm_target_flakey_upcall(dm_table_entry_t *, struct buf *);
|
||||
int dm_target_flakey_secsize(dm_table_entry_t *, unsigned int *);
|
||||
#endif
|
||||
|
||||
/* dm_table.c */
|
||||
#define DM_TABLE_ACTIVE 0
|
||||
#define DM_TABLE_INACTIVE 1
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
/* $NetBSD: dm_target.c,v 1.37 2019/12/23 16:17:35 tkusumi Exp $ */
|
||||
/* $NetBSD: dm_target.c,v 1.38 2020/01/02 06:22:23 tkusumi Exp $ */
|
||||
|
||||
/*
|
||||
* Copyright (c) 2008 The NetBSD Foundation, Inc.
|
||||
@ -29,7 +29,7 @@
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
#include <sys/cdefs.h>
|
||||
__KERNEL_RCSID(0, "$NetBSD: dm_target.c,v 1.37 2019/12/23 16:17:35 tkusumi Exp $");
|
||||
__KERNEL_RCSID(0, "$NetBSD: dm_target.c,v 1.38 2020/01/02 06:22:23 tkusumi Exp $");
|
||||
|
||||
#include <sys/types.h>
|
||||
#include <sys/param.h>
|
||||
@ -358,6 +358,20 @@ dm_target_init(void)
|
||||
dmt->upcall = &dm_target_zero_upcall;
|
||||
if (dm_target_insert(dmt))
|
||||
printf("Failed to insert zero\n");
|
||||
|
||||
#if 0
|
||||
dmt = dm_target_alloc("flakey");
|
||||
dmt->version[0] = 1;
|
||||
dmt->version[1] = 0;
|
||||
dmt->version[2] = 0;
|
||||
dmt->init = &dm_target_flakey_init;
|
||||
dmt->table = &dm_target_flakey_table;
|
||||
dmt->strategy = &dm_target_flakey_strategy;
|
||||
dmt->sync = &dm_target_flakey_sync;
|
||||
dmt->destroy = &dm_target_flakey_destroy;
|
||||
dmt->upcall = &dm_target_flakey_upcall;
|
||||
dmt->secsize = &dm_target_flakey_secsize;
|
||||
if (dm_target_insert(dmt))
|
||||
printf("Failed to insert flakey\n");
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
|
||||
518
sys/dev/dm/dm_target_flakey.c
Normal file
518
sys/dev/dm/dm_target_flakey.c
Normal file
@ -0,0 +1,518 @@
|
||||
/* $NetBSD: dm_target_flakey.c,v 1.1 2020/01/02 06:22:23 tkusumi Exp $ */
|
||||
|
||||
/*
|
||||
* Copyright (c) 2020 The NetBSD Foundation, Inc.
|
||||
* All rights reserved.
|
||||
*
|
||||
* This code is derived from software contributed to The NetBSD Foundation
|
||||
* by Tomohiro Kusumi <tkusumi@netbsd.org>.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
|
||||
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
|
||||
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
|
||||
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
#include <sys/cdefs.h>
|
||||
__KERNEL_RCSID(0, "$NetBSD: dm_target_flakey.c,v 1.1 2020/01/02 06:22:23 tkusumi Exp $");
|
||||
|
||||
#include <sys/types.h>
|
||||
#include <sys/param.h>
|
||||
#include <sys/kernel.h>
|
||||
#include <sys/buf.h>
|
||||
#include <sys/kmem.h>
|
||||
|
||||
#include "dm.h"
|
||||
|
||||
//#define DEBUG_FLAKEY
|
||||
//#define HAS_BUF_PRIV2 /* XXX requires nonexistent buf::b_private2. */
|
||||
|
||||
typedef struct target_flakey_config {
|
||||
dm_pdev_t *pdev;
|
||||
uint64_t offset;
|
||||
int up_int;
|
||||
int down_int;
|
||||
int offset_time; /* XXX "tick" in hz(9) not working. */
|
||||
|
||||
/* drop_writes feature */
|
||||
int drop_writes;
|
||||
|
||||
/* corrupt_bio_byte feature */
|
||||
unsigned int corrupt_buf_byte;
|
||||
unsigned int corrupt_buf_rw;
|
||||
unsigned int corrupt_buf_value;
|
||||
unsigned int corrupt_buf_flags; /* for B_XXX flags */
|
||||
} dm_target_flakey_config_t;
|
||||
|
||||
#define BUF_CMD_READ 1
|
||||
#define BUF_CMD_WRITE 2
|
||||
|
||||
#define FLAKEY_CORRUPT_DIR(tfc) \
|
||||
((tfc)->corrupt_buf_rw == BUF_CMD_READ ? 'r' : 'w')
|
||||
|
||||
static int _init_features(dm_target_flakey_config_t*, int, char**);
|
||||
static __inline void _submit(dm_target_flakey_config_t*, struct buf*);
|
||||
static int _flakey_read(dm_target_flakey_config_t*, struct buf*);
|
||||
static int _flakey_write(dm_target_flakey_config_t*, struct buf*);
|
||||
static int _flakey_corrupt_buf(dm_target_flakey_config_t*, struct buf*);
|
||||
|
||||
#ifdef DM_TARGET_MODULE
|
||||
/*
|
||||
* Every target can be compiled directly to dm driver or as a
|
||||
* separate module this part of target is used for loading targets
|
||||
* to dm driver.
|
||||
* Target can be unloaded from kernel only if there are no users of
|
||||
* it e.g. there are no devices which uses that target.
|
||||
*/
|
||||
#include <sys/kernel.h>
|
||||
#include <sys/module.h>
|
||||
|
||||
MODULE(MODULE_CLASS_MISC, dm_target_flakey, NULL);
|
||||
|
||||
static int
|
||||
dm_target_flakey_modcmd(modcmd_t cmd, void *arg)
|
||||
{
|
||||
dm_target_t *dmt;
|
||||
int r;
|
||||
|
||||
switch (cmd) {
|
||||
case MODULE_CMD_INIT:
|
||||
if ((dmt = dm_target_lookup("flakey")) != NULL) {
|
||||
dm_target_unbusy(dmt);
|
||||
return EEXIST;
|
||||
}
|
||||
dmt = dm_target_alloc("flakey");
|
||||
|
||||
dmt->version[0] = 1;
|
||||
dmt->version[1] = 0;
|
||||
dmt->version[2] = 0;
|
||||
dmt->init = &dm_target_flakey_init;
|
||||
dmt->table = &dm_target_flakey_table;
|
||||
dmt->strategy = &dm_target_flakey_strategy;
|
||||
dmt->sync = &dm_target_flakey_sync;
|
||||
dmt->destroy = &dm_target_flakey_destroy;
|
||||
dmt->upcall = &dm_target_flakey_upcall;
|
||||
dmt->secsize = &dm_target_flakey_secsize;
|
||||
|
||||
r = dm_target_insert(dmt);
|
||||
|
||||
break;
|
||||
|
||||
case MODULE_CMD_FINI:
|
||||
r = dm_target_rem("flakey");
|
||||
break;
|
||||
|
||||
case MODULE_CMD_STAT:
|
||||
return ENOTTY;
|
||||
|
||||
default:
|
||||
return ENOTTY;
|
||||
}
|
||||
|
||||
return r;
|
||||
}
|
||||
#endif
|
||||
|
||||
int
|
||||
dm_target_flakey_init(dm_table_entry_t *table_en, int argc, char **argv)
|
||||
{
|
||||
dm_target_flakey_config_t *tfc;
|
||||
dm_pdev_t *dmp;
|
||||
int err;
|
||||
|
||||
if (argc < 4) {
|
||||
printf("Flakey target takes at least 4 args, %d given\n", argc);
|
||||
return EINVAL;
|
||||
}
|
||||
|
||||
aprint_debug("Flakey target init function called: argc=%d\n", argc);
|
||||
|
||||
/* Insert dmp to global pdev list */
|
||||
if ((dmp = dm_pdev_insert(argv[0])) == NULL)
|
||||
return ENOENT;
|
||||
|
||||
tfc = kmem_alloc(sizeof(dm_target_flakey_config_t), KM_SLEEP);
|
||||
tfc->pdev = dmp;
|
||||
tfc->offset = atoi64(argv[1]);
|
||||
tfc->up_int = atoi64(argv[2]);
|
||||
tfc->down_int = atoi64(argv[3]);
|
||||
tfc->offset_time = tick;
|
||||
|
||||
if ((tfc->up_int + tfc->down_int) == 0) {
|
||||
printf("Sum of up/down interval is 0\n");
|
||||
err = EINVAL;
|
||||
goto fail;
|
||||
}
|
||||
|
||||
if (tfc->up_int + tfc->down_int < tfc->up_int) {
|
||||
printf("Interval time overflow\n");
|
||||
err = EINVAL;
|
||||
goto fail;
|
||||
}
|
||||
|
||||
err = _init_features(tfc, argc - 4, argv + 4);
|
||||
if (err)
|
||||
goto fail;
|
||||
|
||||
dm_table_add_deps(table_en, dmp);
|
||||
table_en->target_config = tfc;
|
||||
|
||||
return 0;
|
||||
fail:
|
||||
kmem_free(tfc, sizeof(*tfc));
|
||||
return err;
|
||||
}
|
||||
|
||||
static int
|
||||
_init_features(dm_target_flakey_config_t *tfc, int argc, char **argv)
|
||||
{
|
||||
char *arg;
|
||||
unsigned int value;
|
||||
|
||||
if (argc == 0)
|
||||
return 0;
|
||||
|
||||
argc = atoi64(*argv++); /* # of args for features */
|
||||
if (argc > 6) {
|
||||
printf("Invalid # of feature args %d\n", argc);
|
||||
return EINVAL;
|
||||
}
|
||||
|
||||
while (argc) {
|
||||
argc--;
|
||||
arg = *argv++;
|
||||
|
||||
/* drop_writes */
|
||||
if (strcmp(arg, "drop_writes") == 0) {
|
||||
tfc->drop_writes = 1;
|
||||
continue;
|
||||
}
|
||||
|
||||
/* corrupt_bio_byte <Nth_byte> <direction> <value> <flags> */
|
||||
if (strcmp(arg, "corrupt_bio_byte") == 0) {
|
||||
if (argc < 4) {
|
||||
printf("Invalid # of feature args %d for "
|
||||
"corrupt_bio_byte\n", argc);
|
||||
return EINVAL;
|
||||
}
|
||||
|
||||
/* <Nth_byte> */
|
||||
argc--;
|
||||
value = atoi64(*argv++);
|
||||
if (value < 1) {
|
||||
printf("Invalid corrupt_bio_byte "
|
||||
"<Nth_byte> arg %u\n", value);
|
||||
return EINVAL;
|
||||
}
|
||||
tfc->corrupt_buf_byte = value;
|
||||
|
||||
/* <direction> */
|
||||
argc--;
|
||||
arg = *argv++;
|
||||
if (strcmp(arg, "r") == 0) {
|
||||
tfc->corrupt_buf_rw = BUF_CMD_READ;
|
||||
} else if (strcmp(arg, "w") == 0) {
|
||||
tfc->corrupt_buf_rw = BUF_CMD_WRITE;
|
||||
} else {
|
||||
printf("Invalid corrupt_bio_byte "
|
||||
"<direction> arg %s\n", arg);
|
||||
return EINVAL;
|
||||
}
|
||||
|
||||
/* <value> */
|
||||
argc--;
|
||||
value = atoi64(*argv++);
|
||||
if (value > 0xff) {
|
||||
printf("Invalid corrupt_bio_byte "
|
||||
"<value> arg %u\n", value);
|
||||
return EINVAL;
|
||||
}
|
||||
tfc->corrupt_buf_value = value;
|
||||
|
||||
/* <flags> */
|
||||
argc--;
|
||||
tfc->corrupt_buf_flags = atoi64(*argv++);
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
printf("Unknown Flakey target feature %s\n", arg);
|
||||
return EINVAL;
|
||||
}
|
||||
|
||||
if (tfc->drop_writes && (tfc->corrupt_buf_rw == BUF_CMD_WRITE)) {
|
||||
printf("Flakey target doesn't allow drop_writes feature and "
|
||||
"corrupt_bio_byte feature with 'w' set\n");
|
||||
return EINVAL;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
char *
|
||||
dm_target_flakey_table(void *target_config)
|
||||
{
|
||||
dm_target_flakey_config_t *tfc;
|
||||
char *params, *p;
|
||||
int drop_writes;
|
||||
|
||||
tfc = target_config;
|
||||
KASSERT(tfc != NULL);
|
||||
|
||||
aprint_debug("Flakey target table function called\n");
|
||||
|
||||
drop_writes = tfc->drop_writes;
|
||||
|
||||
params = kmem_alloc(DM_MAX_PARAMS_SIZE, KM_SLEEP);
|
||||
p = params;
|
||||
p += snprintf(p, DM_MAX_PARAMS_SIZE, "%s %d %d %d %u ",
|
||||
tfc->pdev->udev_name, tfc->offset_time,
|
||||
tfc->up_int, tfc->down_int,
|
||||
drop_writes + (tfc->corrupt_buf_byte > 0) * 5);
|
||||
|
||||
if (drop_writes)
|
||||
p += snprintf(p, DM_MAX_PARAMS_SIZE, "drop_writes ");
|
||||
|
||||
if (tfc->corrupt_buf_byte)
|
||||
p += snprintf(p, DM_MAX_PARAMS_SIZE,
|
||||
"corrupt_bio_byte %u %c %u %u ",
|
||||
tfc->corrupt_buf_byte,
|
||||
FLAKEY_CORRUPT_DIR(tfc),
|
||||
tfc->corrupt_buf_value,
|
||||
tfc->corrupt_buf_flags);
|
||||
*(--p) = '\0';
|
||||
|
||||
return params;
|
||||
}
|
||||
|
||||
#ifdef DEBUG_FLAKEY
|
||||
static int count = 0;
|
||||
#endif
|
||||
|
||||
int
|
||||
dm_target_flakey_strategy(dm_table_entry_t *table_en, struct buf *bp)
|
||||
{
|
||||
dm_target_flakey_config_t *tfc;
|
||||
#ifndef DEBUG_FLAKEY
|
||||
int elapsed;
|
||||
#endif
|
||||
|
||||
tfc = table_en->target_config;
|
||||
#ifndef DEBUG_FLAKEY
|
||||
elapsed = (tick - tfc->offset_time) / hz;
|
||||
if (elapsed % (tfc->up_int + tfc->down_int) >= tfc->up_int) {
|
||||
#else
|
||||
if (++count % 100 == 0) {
|
||||
#endif
|
||||
if (bp->b_flags & B_READ)
|
||||
return _flakey_read(tfc, bp);
|
||||
else
|
||||
return _flakey_write(tfc, bp);
|
||||
}
|
||||
|
||||
/* This is what linear target does */
|
||||
_submit(tfc, bp);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static __inline void
|
||||
_submit(dm_target_flakey_config_t *tfc, struct buf *bp)
|
||||
{
|
||||
|
||||
bp->b_blkno += tfc->offset;
|
||||
VOP_STRATEGY(tfc->pdev->pdev_vnode, bp);
|
||||
}
|
||||
|
||||
static __inline void
|
||||
_flakey_eio_buf(struct buf *bp)
|
||||
{
|
||||
|
||||
bp->b_error = EIO;
|
||||
bp->b_resid = 0;
|
||||
}
|
||||
|
||||
static void
|
||||
_flakey_nestiobuf_iodone(buf_t *bp)
|
||||
{
|
||||
#ifdef HAS_BUF_PRIV2
|
||||
dm_target_flakey_config_t *tfc;
|
||||
#endif
|
||||
buf_t *mbp = bp->b_private;
|
||||
int error;
|
||||
int donebytes;
|
||||
|
||||
KASSERT(bp->b_bcount <= bp->b_bufsize);
|
||||
KASSERT(mbp != bp);
|
||||
|
||||
error = bp->b_error;
|
||||
if (bp->b_error == 0 &&
|
||||
(bp->b_bcount < bp->b_bufsize || bp->b_resid > 0)) {
|
||||
/*
|
||||
* Not all got transfered, raise an error. We have no way to
|
||||
* propagate these conditions to mbp.
|
||||
*/
|
||||
error = EIO;
|
||||
}
|
||||
|
||||
#ifdef HAS_BUF_PRIV2
|
||||
tfc = bp->b_private2;
|
||||
/*
|
||||
* Linux dm-flakey has changed its read behavior in 2016.
|
||||
* This conditional is to sync with that change.
|
||||
*/
|
||||
if (tfc->corrupt_buf_byte && tfc->corrupt_buf_rw == BUF_CMD_READ)
|
||||
_flakey_corrupt_buf(tfc, mbp);
|
||||
else if (!tfc->drop_writes)
|
||||
_flakey_eio_buf(mbp);
|
||||
#endif
|
||||
donebytes = bp->b_bufsize;
|
||||
putiobuf(bp);
|
||||
nestiobuf_done(mbp, donebytes, error);
|
||||
}
|
||||
|
||||
static int
|
||||
_flakey_read(dm_target_flakey_config_t *tfc, struct buf *bp)
|
||||
{
|
||||
struct buf *nestbuf;
|
||||
|
||||
/*
|
||||
* Linux dm-flakey has changed its read behavior in 2016.
|
||||
* This conditional is to sync with that change.
|
||||
*/
|
||||
if (!tfc->corrupt_buf_byte && !tfc->drop_writes) {
|
||||
_flakey_eio_buf(bp);
|
||||
biodone(bp);
|
||||
return 0;
|
||||
}
|
||||
|
||||
nestbuf = getiobuf(NULL, true);
|
||||
nestiobuf_setup(bp, nestbuf, 0, bp->b_bcount);
|
||||
nestbuf->b_iodone = _flakey_nestiobuf_iodone;
|
||||
nestbuf->b_blkno = bp->b_blkno;
|
||||
#ifdef HAS_BUF_PRIV2
|
||||
nestbuf->b_private2 = tfc;
|
||||
#endif
|
||||
_submit(tfc, nestbuf);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
_flakey_write(dm_target_flakey_config_t *tfc, struct buf *bp)
|
||||
{
|
||||
|
||||
if (tfc->drop_writes) {
|
||||
aprint_debug("bp=%p drop_writes blkno=%ju\n", bp, bp->b_blkno);
|
||||
biodone(bp);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (tfc->corrupt_buf_byte && tfc->corrupt_buf_rw == BUF_CMD_WRITE) {
|
||||
_flakey_corrupt_buf(tfc, bp);
|
||||
_submit(tfc, bp);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Error all I/Os if neither of the above two */
|
||||
_flakey_eio_buf(bp);
|
||||
biodone(bp);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
_flakey_corrupt_buf(dm_target_flakey_config_t *tfc, struct buf *bp)
|
||||
{
|
||||
char *buf;
|
||||
|
||||
if (bp->b_data == NULL)
|
||||
return 1;
|
||||
if (bp->b_error)
|
||||
return 1; /* Don't corrupt on error */
|
||||
if (bp->b_bcount < tfc->corrupt_buf_byte)
|
||||
return 1;
|
||||
if ((bp->b_flags & tfc->corrupt_buf_flags) != tfc->corrupt_buf_flags)
|
||||
return 1;
|
||||
|
||||
buf = bp->b_data;
|
||||
buf[tfc->corrupt_buf_byte - 1] = tfc->corrupt_buf_value;
|
||||
|
||||
aprint_debug("bp=%p dir=%c blkno=%ju Nth=%u value=%u\n",
|
||||
bp, FLAKEY_CORRUPT_DIR(tfc), bp->b_blkno, tfc->corrupt_buf_byte,
|
||||
tfc->corrupt_buf_value);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
dm_target_flakey_sync(dm_table_entry_t *table_en)
|
||||
{
|
||||
dm_target_flakey_config_t *tfc;
|
||||
int cmd;
|
||||
|
||||
tfc = table_en->target_config;
|
||||
cmd = 1;
|
||||
|
||||
return VOP_IOCTL(tfc->pdev->pdev_vnode, DIOCCACHESYNC, &cmd,
|
||||
FREAD | FWRITE, kauth_cred_get());
|
||||
}
|
||||
|
||||
int
|
||||
dm_target_flakey_destroy(dm_table_entry_t *table_en)
|
||||
{
|
||||
|
||||
if (table_en->target_config == NULL)
|
||||
goto out;
|
||||
|
||||
dm_target_flakey_config_t *tfc = table_en->target_config;
|
||||
|
||||
/* Decrement pdev ref counter if 0 remove it */
|
||||
dm_pdev_decr(tfc->pdev);
|
||||
|
||||
kmem_free(tfc, sizeof(*tfc));
|
||||
out:
|
||||
/* Unbusy target so we can unload it */
|
||||
dm_target_unbusy(table_en->target);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
dm_target_flakey_upcall(dm_table_entry_t *table_en, struct buf *bp)
|
||||
{
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
dm_target_flakey_secsize(dm_table_entry_t *table_en, unsigned int *secsizep)
|
||||
{
|
||||
dm_target_flakey_config_t *tfc;
|
||||
unsigned int secsize;
|
||||
|
||||
secsize = 0;
|
||||
|
||||
tfc = table_en->target_config;
|
||||
if (tfc != NULL)
|
||||
secsize = tfc->pdev->pdev_secsize;
|
||||
|
||||
*secsizep = secsize;
|
||||
|
||||
return 0;
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user