/*        $NetBSD: dm_target_flakey.c,v 1.4 2021/07/24 21:31:37 andvar Exp $      */

/*
* Copyright (c) 2020 The NetBSD Foundation, Inc.
* Copyright (c) 2015 The DragonFly Project.  All rights reserved.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Tomohiro Kusumi <[email protected]>.
*
* 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.4 2021/07/24 21:31:37 andvar 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 transferred, 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;
}

#if 0
int
dm_target_flakey_upcall(dm_table_entry_t *table_en, struct buf *bp)
{

       return 0;
}
#endif

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;
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.