/*
 * Copyright (c) 2010 The DragonFly Project.  All rights reserved.
 *
 * This code is derived from software contributed to The DragonFly Project
 * by Alex Hornung <ahornung@gmail.com>
 *
 * 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.
 */

/*
 * This file implements initial version of a mirror target
 */
#include <sys/bio.h>
#include <sys/malloc.h>
#include <sys/uuid.h>

#include <dev/disk/dm/dm.h>
MALLOC_DEFINE(M_DMDMIRROR, "dm_dmirror", "Device Mapper Target DMIRROR");

/* segdesc flags */
#define MEDIA_UNSTABLE		0x0001
#define	MEDIA_READ_DEGRADED	0x0002
#define MEDIA_WRITE_DEGRADED	0x0004
#define MEDIA_MASTER		0x0008
#define UNINITIALIZED		0x0010
#define OLD_UNSTABLE		0x0020
#define OLD_MSATER		0x0040

/* dmirror disk flags */
#define DISK_ONLINE		0x0001


#define	dmirror_set_bio_disk(bio, x)	((bio)->bio_caller_info1.ptr = (x))
#define	dmirror_get_bio_disk(bio)	((bio)?((bio)->bio_caller_info1.ptr):NULL)
#define	dmirror_set_bio_seg(bio, x)	((bio)->bio_caller_info2.offset = (x))
#define	dmirror_get_bio_segno(bio)	((bio)?((bio)->bio_caller_info2.offset):0)

#define	dmirror_set_bio_retries(bio, x)	((bio)->bio_caller_info3.value = (x))
#define	dmirror_get_bio_retries(bio)	((bio)?((bio)->bio_caller_info3.value):0)

#define dmirror_set_bio_mbuf(bio, x)	((bio)->bio_caller_info3.ptr = (x))
#define dmirror_get_bio_mbuf(bio)	((bio)?((bio)->bio_caller_info3.ptr):NULL)



/* Segment descriptor for each logical segment */
typedef struct segdesc {
	uint32_t	flags;		/* Flags, including state */
	uint32_t	zf_bitmap;	/* Zero-fill bitmap */
	uint8_t		disk_no;
	uint8_t		spare1;
	uint16_t	spare2;
	uint32_t	spare3;
	/* XXX: some timestamp/serial */
} segdesc_t;

typedef struct dmirror_disk {
	uint32_t	flags;
	dm_pdev_t 	*pdev;
} dmirror_disk_t;

typedef struct target_dmirror_config {
	size_t	params_len;
	dmirror_disk_t	disks[4];
	uint8_t	ndisks;
	/* XXX: uuid stuff */

} dm_target_dmirror_config_t;

static
struct bio*
dmirror_clone_bio(struct bio *obio)
{
	struct bio *bio;
	struct buf *mbp;
	struct buf *bp;

	mbp = obio->bio_buf;
	bp = getpbuf(NULL);

	BUF_KERNPROC(bp);
	bp->b_vp = mbp->b_vp;
	bp->b_cmd = mbp->b_cmd;
	bp->b_data = (char *)mbp->b_data;
	bp->b_resid = bp->b_bcount = mbp->b_bcount;
	bp->b_bufsize = bp->b_bcount;

	bio = &bp->b_bio1;
	bio->bio_offset = obio->bio_offset;

	return (bio);
}

static void
dmirror_write_done(struct bio *bio)
{
	dmirror_disk_t disk;
	off_t segno;
	struct bio *obio, *mbio;
	int retries;

	disk = dmirror_get_bio_disk(bio);
	segno = dmirror_get_bio_segno(bio);
	mbio = dmirror_get_bio_mbuf(bio);

	if (bio->bio_buf->b_flags & B_ERROR) {
		/* write failed */
	}

	obio = pop_bio(bio);
	biodone(obio);
}

void
dmirror_issue_write(dmirror_disk_t disk, struct bio *bio)
{
	dmirror_set_bio_disk(bio, disk);
	dmirror_set_bio_segno(bio, SEGNO_FROM_OFFSET(bio->bio_offset));

	bio->bio_done = dmirror_write_done;
	vn_strategy(disk->pdev, bio);
}

void
dmirror_write(dm_target_crypt_config_t config, struct bio *bio)
{
	dmirror_disk_t disk, m_disk;
	struct bio *wbio1, *wbio2;
	segdesc_t segdesc;
	int i, masters = 0;

	for(i = 0; i < XXX config->ndisks; i++) {
		disk = &config->disks[i];
		segdesc = SEGDESC_FROM_OFFSET(disk, bio->bio_offset);
		if (segdesc->flags & MEDIA_MASTER) {
			if (++masters == 1)
				m_disk = disk;
		}
	}

	if (masters == 1) {
		dmirror_set_bio_mbuf(bio, NULL);
		dmirror_issue_write(m_disk, bio);
	} else {
		wbio1 = dmirror_clone_bio(bio);
		wbio2 = dmirror_clone_bio(bio);
		dmirror_set_bio_mbuf(wbio1, bio);
		dmirror_set_bio_mbuf(wbio2, bio);
		dmirror_issue_write(XXX disk1, wbio1);
		dmirror_issue_write(XXX disk2, wbio2);
	}

}

static void
segdesc_set_flag(dmirror_disk_t disk, off_t segno, int flag)
{
	/*
	 * XXX: set the flag on the in-memory descriptor and write back to disks.
	 */
	foo |= flag;
}


static void
segdesc_clear_flag(dmirror_disk_t disk, off_t segno, int flag)
{
	/*
	 * XXX: set the flag on the in-memory descriptor and write back to disks.
	 */
	foo &= ~flag;
}

static void
dmirror_read_done(struct bio *bio)
{
	dmirror_disk_t disk;
	off_t segno;
	struct bio *obio;
	int retries;

	disk = dmirror_get_bio_disk(bio);
	segno = dmirror_get_bio_segno(bio);
	retries = dmirror_get_bio_retries(bio);

	if (bio->bio_buf->b_flags & B_ERROR) {
		/* read failed, so redispatch to a different disk */
		segdesc_set_flag(disk, segno, MEDIA_READ_DEGRADED);
		/* XXX: set other disk to master, if possible */
		if (retries < disk->config->max_retries) {
			dmirror_set_bio_retries(bio, retries + 1);
			/*
			 * XXX: how do we restore the bio to health? Like this?
			 */
			bio->bio_buf->b_flags &= ~(B_ERROR | B_INVAL);
			/*
			 * XXX: something tells me that dispatching stuff from a
			 *	biodone routine is not the greatest idea
			 */
			dmirror_issue_read(next_disk, bio);
			return;
		}
	}

	obio = pop_bio(bio);
	biodone(obio);
}

void
dmirror_issue_read(dmirror_disk_t disk, struct bio *bio)
{
	dmirror_set_bio_disk(bio, disk);
	dmirror_set_bio_segno(bio, SEGNO_FROM_OFFSET(bio->bio_offset));

	bio->bio_done = dmirror_read_done;
	vn_strategy(disk->pdev, bio);
}

void
dmirror_read(dm_target_crypt_config_t config, struct bio *bio)
{
	dmirror_disk_t disk, m_disk;
	segdesc_t segdesc;
	int i, masters = 0;

	for(i = 0; i < XXX config->ndisks; i++) {
		disk = &config->disks[i];
		segdesc = SEGDESC_FROM_OFFSET(disk, bio->bio_offset);
		if (segdesc->flags & MEDIA_MASTER) {
			if (++masters == 1)
				m_disk = disk;
		}
	}

	if (masters > 1) {
		/* XXX: fail. */
		biodone(foo);
		return;
	}

	if (masters == 1) {
		segdesc = SEGDESC_FROM_OFFSET(m_disk, bio->bio_offset);
		if (segdesc->flags & UNINITIALIZED) {
			/* XXX: ... */
		}
		dmirror_issue_read(m_disk, bio);
	} else {
		/* dispatch read to any disk */
		/* but try not to send to a READ_DEGRADED drive */
		m_disk = NULL;
		for (i = 0; i < config->ndisks; i++) {
			disk = &config->disks[i];
			segdesc = SEGDESC_FROM_OFFSET(disk, bio->bio_offset);
			if (!(segdesc->flags & MEDIA_READ_DEGRADED)) {
				m_disk = disk;
				break;
			}
		}
		/* XXX: do the uninitialized magic here, too */
		if (m_disk) {
			/*
			 * XXX: we found some non-degraded disk. We might want to
			 * optimize performance by sending reads to different disks,
			 * not just the first one.
			 */
			dmirror_set_bio_retries(bio, 0);
			dmirror_issue_read(m_disk, bio);
		} else {
			/* XXX: all disks are read degraded, just sent to any */
			m_disk = &config->disks[i];
			dmirror_set_bio_retries(bio, 0);
			dmirror_issue_read(m_disk, bio);
		}
	}
}

/* Strategy routine called from dm_strategy. */
/*
 * Do IO operation, called from dmstrategy routine.
 */
int
dm_target_dmirror_strategy(dm_table_entry_t *table_en, struct buf *bp)
{
	struct bio *bio, *split_bio1, *split_bio2;
	struct buf *bp;
	off_t bseg, eseg, seg_end;
	size_t fsb;
	int split_transaction = 0;

	dm_target_crypt_config_t *priv;
	priv = table_en->target_config;

	if ((bp->b_cmd == BUF_CMD_READ) || (bp->b_cmd == BUF_CMD_WRITE)) {
		/* Get rid of stuff we can't really handle */
		if (((bp->b_bcount % DEV_BSIZE) != 0) || (bp->b_bcount == 0)) {
			kprintf("dm_target_dmirror_strategy: can't really handle bp->b_bcount = %d\n", bp->b_bcount);
			bp->b_error = EINVAL;
			bp->b_flags |= B_ERROR | B_INVAL;
			biodone(&bp->b_bio1);
			return 0;
		}

		bseg = SEGNO_FROM_OFFSET(bp->b_bio1.bio_offset);
		eseg = SEGNO_FROM_OFFSET(bp->b_bio1.bio_offset + bp->b_resid);
		seg_end = OFFSET_FROM_SEGNO(eseg);

		if (bseg != eseg) {
			split_transaction = 1;
			/* fsb = first segment bytes (bytes in the first segment) */
			fsb = seg_end - bp->b_bio1.bio_offset;

			nestbuf = getpbuf(NULL);
			nestiobuf_setup(&bp->b_bio1, nestbuf, 0, fsb);
			split_bio1 = push_bio(&nestbuf->b_bio1);
			split_bio1->bio_offset = bp->b_bio1.bio_offset +
			    priv->block_offset*DEV_BSIZE;

			nestbuf = getpbuf(NULL);
			nestiobuf_setup(&bp->b_bio1, nestbuf, fsb, bp->b_resid - fsb);
			split_bio2 = push_bio(&nestbuf->b_bio1);
			split_bio2->bio_offset = bp->b_bio1.bio_offset + fsb +
			    priv->block_offset*DEV_BSIZE;
		}
	}

	switch (bp->b_cmd) {
	case BUF_CMD_READ:
		if (split_transaction) {
			dmirror_read(priv, split_bio1);
			dmirror_read(priv, split_bio2);
		} else {
			bio = push_bio(&bp->b_bio1);
			bio->bio_offset = bp->b_bio1.bio_offset + priv->block_offset*DEV_BSIZE;
			dmirror_read(priv, bio);
		}
		break;

	case BUF_CMD_WRITE:
		if (split_transaction) {
			dmirror_write(priv, split_bio1);
			dmirror_write(priv, split_bio2);
		} else {
			bio = push_bio(&bp->b_bio1);
			bio->bio_offset = bp->b_bio1.bio_offset + priv->block_offset*DEV_BSIZE;
			dmirror_write(priv, bio);
		}
		break;

	default:
		/* XXX: clone... */
		vn_strategy(priv->pdev[0]->pdev_vnode, &bp->b_bio1);
		vn_strategy(priv->pdev[1]->pdev_vnode, &bp->b_bio1);
	}

	return 0;

}

/* XXX: add missing dm functions */