/*        $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 <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.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;
}