/*
 * Copyright (c) 2015 The DragonFly Project.  All rights reserved.
 *
 * This code is derived from software contributed to The DragonFly Project
 * 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.
 * 3. Neither the name of The DragonFly Project nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific, prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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
 * COPYRIGHT HOLDERS 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/param.h>
#include <sys/malloc.h>
#include <dev/disk/dm/dm.h>

MALLOC_DEFINE(M_DMFLAKEY, "dm_flakey", "Device Mapper Target Flakey");

/* dm_flakey never updates any field after initialization */
typedef struct target_flakey_config {
        dm_pdev_t *pdev;
        uint64_t offset;
        int up_int;
        int down_int;
        int offset_time;

        /* 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 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 bio*);
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 bio*);

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

        dmdebug("Flakey target init: argc=%d\n", argc);

        if (argc < 4) {
                kprintf("Flakey target takes 4 or more args\n");
                return EINVAL;
        }

        tfc = kmalloc(sizeof(*tfc), M_DMFLAKEY, M_WAITOK | M_ZERO);
        if (tfc == NULL)
                return ENOMEM;

        if ((dmp = dm_pdev_insert(argv[0])) == NULL) {
                err = ENOENT;
                goto fail;
        }
        tfc->pdev = dmp;
        tfc->offset = atoi64(argv[1]);
        tfc->up_int = atoi64(argv[2]);
        tfc->down_int = atoi64(argv[3]);
        tfc->offset_time = ticks;

        if ((tfc->up_int + tfc->down_int) == 0) {
                kprintf("Sum of up/down interval is 0\n");
                err = EINVAL;
                goto fail;
        }

        if (tfc->up_int + tfc->down_int < tfc->up_int) {
                kprintf("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);

        dm_table_init_target(table_en, tfc);

        return 0;
fail:
        kfree(tfc, M_DMFLAKEY);
        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) {
                kprintf("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) {
                                kprintf("Invalid # of feature args %d for "
                                        "corrupt_bio_byte\n", argc);
                                return EINVAL;
                        }

                        /* <Nth_byte> */
                        argc--;
                        value = atoi64(*argv++);
                        if (value < 1) {
                                kprintf("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 {
                                kprintf("Invalid corrupt_bio_byte "
                                        "<direction> arg %s\n", arg);
                                return EINVAL;
                        }

                        /* <value> */
                        argc--;
                        value = atoi64(*argv++);
                        if (value > 0xff) {
                                kprintf("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;
                }

                kprintf("Unknown Flakey target feature %s\n", arg);
                return EINVAL;
        }

        if (tfc->drop_writes && (tfc->corrupt_buf_rw == BUF_CMD_WRITE)) {
                kprintf("Flakey target doesn't allow drop_writes feature "
                        "and corrupt_bio_byte feature with 'w' set\n");
                return EINVAL;
        }

        return 0;
}

static int
dm_target_flakey_destroy(dm_table_entry_t *table_en)
{
        dm_target_flakey_config_t *tfc;

        tfc = table_en->target_config;
        if (tfc == NULL)
                return 0;

        dm_pdev_decr(tfc->pdev);

        kfree(tfc, M_DMFLAKEY);

        return 0;
}

static int
dm_target_flakey_strategy(dm_table_entry_t *table_en, struct buf *bp)
{
        dm_target_flakey_config_t *tfc;
        int elapsed;

        tfc = table_en->target_config;

        elapsed = (ticks - tfc->offset_time) / hz;
        if (elapsed % (tfc->up_int + tfc->down_int) >= tfc->up_int) {
                switch (bp->b_cmd) {
                case BUF_CMD_READ:
                        return _flakey_read(tfc, bp);
                case BUF_CMD_WRITE:
                        return _flakey_write(tfc, bp);
                default:
                        break;
                }
        }

        /* This is what linear target does */
        _submit(tfc, &bp->b_bio1);

        return 0;
}

static __inline
void
_submit(dm_target_flakey_config_t *tfc, struct bio *bio)
{
        bio->bio_offset += tfc->offset * DEV_BSIZE;
        vn_strategy(tfc->pdev->pdev_vnode, bio);
}

static __inline
void
_flakey_eio_buf(struct buf *bp)
{
        bp->b_error = EIO;
        bp->b_resid = 0;
}

static void
_flakey_read_iodone(struct bio *bio)
{
        struct bio *obio;
        dm_target_flakey_config_t *tfc;

        tfc = bio->bio_caller_info1.ptr;
        obio = pop_bio(bio);

        /*
         * 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, obio);
        else if (!tfc->drop_writes)
                _flakey_eio_buf(bio->bio_buf);

        biodone(obio);
}

static int
_flakey_read(dm_target_flakey_config_t *tfc, struct buf *bp)
{
        struct bio *bio = &bp->b_bio1;
        struct bio *nbio;

        /*
         * 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(bio);
                return 0;
        }

        nbio = push_bio(bio);
        nbio->bio_done = _flakey_read_iodone;
        nbio->bio_caller_info1.ptr = tfc;
        nbio->bio_offset = pop_bio(nbio)->bio_offset;

        _submit(tfc, nbio);

        return 0;
}

static int
_flakey_write(dm_target_flakey_config_t *tfc, struct buf *bp)
{
        struct bio *bio = &bp->b_bio1;

        if (tfc->drop_writes) {
                dmdebug("bio=%p drop_writes offset=%ju\n",
                        bio, bio->bio_offset);
                biodone(bio);
                return 0;
        }

        if (tfc->corrupt_buf_byte && tfc->corrupt_buf_rw == BUF_CMD_WRITE) {
                _flakey_corrupt_buf(tfc, bio);
                _submit(tfc, bio);
                return 0;
        }

        /* Error all I/Os if neither of the above two */
        _flakey_eio_buf(bp);
        biodone(bio);

        return 0;
}

static int
_flakey_corrupt_buf(dm_target_flakey_config_t *tfc, struct bio *bio)
{
        struct buf *bp;

        bp = bio->bio_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;

        bp->b_data[tfc->corrupt_buf_byte - 1] = tfc->corrupt_buf_value;
        dmdebug("bio=%p dir=%c offset=%ju Nth=%u value=%u\n",
                bio,
                FLAKEY_CORRUPT_DIR(tfc),
                bio->bio_offset,
                tfc->corrupt_buf_byte,
                tfc->corrupt_buf_value);

        return 0;
}

static char *
dm_target_flakey_table(void *target_config)
{
        dm_target_flakey_config_t *tfc;
        char *params, *p;
        int drop_writes;

        tfc = target_config;
        KKASSERT(tfc != NULL);

        drop_writes = tfc->drop_writes;

        params = dm_alloc_string(DM_MAX_PARAMS_SIZE);
        p = params;
        p += ksnprintf(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 += ksnprintf(p, DM_MAX_PARAMS_SIZE, "drop_writes ");

        if (tfc->corrupt_buf_byte)
                p += ksnprintf(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;
}

static int
dmtf_mod_handler(module_t mod, int type, void *unused)
{
        dm_target_t *dmt = NULL;
        int err = 0;

        switch(type) {
        case MOD_LOAD:
                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;
                strlcpy(dmt->name, "flakey", DM_MAX_TYPE_NAME);
                dmt->init = &dm_target_flakey_init;
                dmt->destroy = &dm_target_flakey_destroy;
                dmt->strategy = &dm_target_flakey_strategy;
                dmt->table = &dm_target_flakey_table;

                err = dm_target_insert(dmt);
                if (err == 0)
                        kprintf("dm_target_flakey: Successfully initialized\n");
                break;

        case MOD_UNLOAD:
                err = dm_target_remove("flakey");
                if (err == 0)
                        kprintf("dm_target_flakey: unloaded\n");
                break;
        }

        return err;
}

DM_TARGET_MODULE(dm_target_flakey, dmtf_mod_handler);