[dragonfly.git] / sys / dev / virtual / disk / vdisk.c

/*
 * Copyright (c) 2006 The DragonFly Project.  All rights reserved.
 * 
 * This code is derived from software contributed to The DragonFly Project
 * by Matthew Dillon <dillon@backplane.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.
 * 
 * $DragonFly: src/sys/dev/virtual/disk/vdisk.c,v 1.8 2008/03/20 02:14:56 dillon Exp $
 */

/*
 * Virtual disk driver
 */
#include <sys/types.h>
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/malloc.h>
#include <sys/conf.h>
#include <sys/bus.h>
#include <sys/buf.h>
#include <sys/devicestat.h>
#include <sys/disk.h>
#include <machine/cothread.h>
#include <machine/md_var.h>

#include <sys/buf2.h>

#include <sys/stat.h>
#include <unistd.h>

struct vkd_softc {
	struct bio_queue_head bio_queue;
	struct devstat stats;
	struct disk disk;
	cothread_t	cotd;
	TAILQ_HEAD(, bio) cotd_queue;
	TAILQ_HEAD(, bio) cotd_done;
	cdev_t dev;
	int unit;
	int fd;
};

#define CDEV_MAJOR	97

static void vkd_io_thread(cothread_t cotd);
static void vkd_io_intr(cothread_t cotd);
static void vkd_doio(struct vkd_softc *sc, struct bio *bio);

static d_strategy_t	vkdstrategy;
static d_open_t		vkdopen;

static struct dev_ops vkd_ops = {
	{ "vkd", CDEV_MAJOR, D_DISK },
        .d_open =	vkdopen,
        .d_close =	nullclose,
        .d_read =	physread,
        .d_write =	physwrite,
        .d_strategy =	vkdstrategy,
};

static void
vkdinit(void *dummy __unused)
{
	struct vkdisk_info *dsk;
	struct vkd_softc *sc;
	struct stat st;
	int i;

	for (i = 0; i < DiskNum; i++) {
		/* check that the 'bus device' has been initialized */
		dsk = &DiskInfo[i];
		if (dsk == NULL || dsk->type != VKD_DISK)
			continue;
		if (dsk->fd < 0 || fstat(dsk->fd, &st) < 0)
			continue;

		/* and create a new device */
		sc = kmalloc(sizeof(*sc), M_DEVBUF, M_WAITOK | M_ZERO);
		sc->unit = dsk->unit;
		sc->fd = dsk->fd;
		bioq_init(&sc->bio_queue);
		devstat_add_entry(&sc->stats, "vkd", sc->unit, DEV_BSIZE,
				  DEVSTAT_NO_ORDERED_TAGS,
				  DEVSTAT_TYPE_DIRECT | DEVSTAT_TYPE_IF_OTHER,
				  DEVSTAT_PRIORITY_DISK);
		sc->dev = disk_create(sc->unit, &sc->disk, &vkd_ops);
		sc->dev->si_drv1 = sc;
		sc->dev->si_iosize_max = 256 * 1024;

		TAILQ_INIT(&sc->cotd_queue);
		TAILQ_INIT(&sc->cotd_done);
		sc->cotd = cothread_create(vkd_io_thread, vkd_io_intr, sc, 
					   "vkd");
	}
}

SYSINIT(vkdisk, SI_SUB_DRIVERS, SI_ORDER_FIRST, vkdinit, NULL);

static int
vkdopen(struct dev_open_args *ap)
{
	struct vkd_softc *sc;
	struct disk_info info;
	struct stat st;
	cdev_t dev;

	dev = ap->a_head.a_dev;
	sc = dev->si_drv1;
	if (fstat(sc->fd, &st) < 0 || st.st_size == 0)
		return(ENXIO);

	bzero(&info, sizeof(info));
	info.d_media_blksize = DEV_BSIZE;
	info.d_media_blocks = st.st_size / info.d_media_blksize;

	info.d_nheads = 1;
	info.d_ncylinders = 1;
	info.d_secpertrack = info.d_media_blocks;
	info.d_secpercyl = info.d_secpertrack * info.d_nheads;

	disk_setdiskinfo(&sc->disk, &info);
	return(0);
}

static int
vkdstrategy(struct dev_strategy_args *ap)
{
	struct bio *bio = ap->a_bio;
	struct vkd_softc *sc;
	cdev_t dev;

	dev = ap->a_head.a_dev;
	sc = dev->si_drv1;

	devstat_start_transaction(&sc->stats);
	cothread_lock(sc->cotd, 0);
	TAILQ_INSERT_TAIL(&sc->cotd_queue, bio, bio_act);
	cothread_signal(sc->cotd);
	cothread_unlock(sc->cotd, 0);

	return(0);
}

static
void
vkd_io_intr(cothread_t cotd)
{
	struct vkd_softc *sc;
	struct bio *bio;

	sc = cotd->arg;

	cothread_lock(cotd, 0);
	while (!TAILQ_EMPTY(&sc->cotd_done)) {
		bio = TAILQ_FIRST(&sc->cotd_done);
		TAILQ_REMOVE(&sc->cotd_done, bio, bio_act);
		devstat_end_transaction_buf(&sc->stats, bio->bio_buf);
		biodone(bio);
	}
	cothread_unlock(sc->cotd, 0);
}

/*
 * WARNING!  This runs as a cothread and has no access to mycpu nor can it
 * make vkernel-specific calls other then cothread_*() calls.
 *
 * WARNING!  A signal can occur and be discarded prior to our initial
 * call to cothread_lock().  Process pending I/O before waiting.
 */
static
void
vkd_io_thread(cothread_t cotd)
{
	struct bio *bio;
	struct vkd_softc *sc = cotd->arg;
	int count;

	cothread_lock(cotd, 1);
	for (;;) {
		count = 0;
		while ((bio = TAILQ_FIRST(&sc->cotd_queue)) != NULL) {
			TAILQ_REMOVE(&sc->cotd_queue, bio, bio_act);
			cothread_unlock(cotd, 1);
			vkd_doio(sc, bio);
			cothread_lock(cotd, 1);
			TAILQ_INSERT_TAIL(&sc->cotd_done, bio, bio_act);
			if (++count == 8) {
				cothread_intr(cotd);
				count = 0;
			}
		}
		if (count)
			cothread_intr(cotd);
		cothread_wait(cotd);	/* interlocks cothread lock */
	}
	/* NOT REACHED */
	cothread_unlock(cotd, 1);
}

static
void
vkd_doio(struct vkd_softc *sc, struct bio *bio)
{
	struct buf *bp = bio->bio_buf;
	int n;

	switch(bp->b_cmd) {
	case BUF_CMD_READ:
		n = pread(sc->fd, bp->b_data, bp->b_bcount, bio->bio_offset);
		break;
	case BUF_CMD_WRITE:
		/* XXX HANDLE SHORT WRITE XXX */
		n = pwrite(sc->fd, bp->b_data, bp->b_bcount, bio->bio_offset);
		break;
	case BUF_CMD_FLUSH:
		if (fsync(sc->fd) < 0)
			n = -1;
		else
			n = bp->b_bcount;
		break;
	default:
		panic("vkd: bad b_cmd %d", bp->b_cmd);
		break; /* not reached */
	}
	if (n != bp->b_bcount) {
		bp->b_error = EIO;
		bp->b_flags |= B_ERROR;
	}
	bp->b_resid = bp->b_bcount - n;
}
Commit	Line	Data
d87174b3 MD	1	/*
	2	* Copyright (c) 2006 The DragonFly Project. All rights reserved.
	3	*
	4	* This code is derived from software contributed to The DragonFly Project
	5	* by Matthew Dillon <dillon@backplane.com>
	6	*
	7	* Redistribution and use in source and binary forms, with or without
	8	* modification, are permitted provided that the following conditions
	9	* are met:
	10	*
	11	* 1. Redistributions of source code must retain the above copyright
	12	* notice, this list of conditions and the following disclaimer.
	13	* 2. Redistributions in binary form must reproduce the above copyright
	14	* notice, this list of conditions and the following disclaimer in
	15	* the documentation and/or other materials provided with the
	16	* distribution.
	17	* 3. Neither the name of The DragonFly Project nor the names of its
	18	* contributors may be used to endorse or promote products derived
	19	* from this software without specific, prior written permission.
	20	*
	21	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	22	* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	23	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
	24	* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
	25	* COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
	26	* INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
	27	* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
	28	* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
	29	* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
	30	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
	31	* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	32	* SUCH DAMAGE.
	33	*
9c2ed617	34	* $DragonFly: src/sys/dev/virtual/disk/vdisk.c,v 1.8 2008/03/20 02:14:56 dillon Exp $
d87174b3 MD	35	*/
	36
	37	/*
	38	* Virtual disk driver
	39	*/
	40	#include <sys/types.h>
	41	#include <sys/param.h>
	42	#include <sys/systm.h>
	43	#include <sys/kernel.h>
	44	#include <sys/malloc.h>
	45	#include <sys/conf.h>
3448c124	46	#include <sys/bus.h>
d87174b3 MD	47	#include <sys/buf.h>
d87174b3 MD	48	#include <sys/devicestat.h>
d87174b3	49	#include <sys/disk.h>
9c2ed617	50	#include <machine/cothread.h>
d87174b3 MD	51	#include <machine/md_var.h>
	52
	53	#include <sys/buf2.h>
	54
	55	#include <sys/stat.h>
	56	#include <unistd.h>
	57
e1002718	58	struct vkd_softc {
d87174b3 MD	59	struct bio_queue_head bio_queue;
	60	struct devstat stats;
	61	struct disk disk;
9c2ed617 MD	62	cothread_t cotd;
	63	TAILQ_HEAD(, bio) cotd_queue;
	64	TAILQ_HEAD(, bio) cotd_done;
d87174b3 MD	65	cdev_t dev;
	66	int unit;
	67	int fd;
	68	};
	69
d87174b3 MD	70	#define CDEV_MAJOR 97
d87174b3 MD	71
9c2ed617 MD	72	static void vkd_io_thread(cothread_t cotd);
9c2ed617 MD	73	static void vkd_io_intr(cothread_t cotd);
3448c124 MD	74	static void vkd_doio(struct vkd_softc sc, struct bio bio);
3448c124 MD	75
e1002718 MD	76	static d_strategy_t vkdstrategy;
e1002718 MD	77	static d_open_t vkdopen;
d87174b3	78
e1002718 MD	79	static struct dev_ops vkd_ops = {
	80	{ "vkd", CDEV_MAJOR, D_DISK },
	81	.d_open = vkdopen,
d87174b3 MD	82	.d_close = nullclose,
	83	.d_read = physread,
	84	.d_write = physwrite,
e1002718	85	.d_strategy = vkdstrategy,
d87174b3 MD	86	};
	87
	88	static void
e1002718	89	vkdinit(void *dummy __unused)
d87174b3	90	{
ee63ee00	91	struct vkdisk_info *dsk;
e1002718	92	struct vkd_softc *sc;
d87174b3	93	struct stat st;
ee63ee00 SW	94	int i;
ee63ee00 SW	95
ee63ee00	96	for (i = 0; i < DiskNum; i++) {
ee63ee00 SW	97	/* check that the 'bus device' has been initialized */
ee63ee00 SW	98	dsk = &DiskInfo[i];
a72d8a9f	99	if (dsk == NULL \|\| dsk->type != VKD_DISK)
ee63ee00 SW	100	continue;
	101	if (dsk->fd < 0 \|\| fstat(dsk->fd, &st) < 0)
	102	continue;
	103
	104	/* and create a new device */
	105	sc = kmalloc(sizeof(*sc), M_DEVBUF, M_WAITOK \| M_ZERO);
	106	sc->unit = dsk->unit;
	107	sc->fd = dsk->fd;
	108	bioq_init(&sc->bio_queue);
	109	devstat_add_entry(&sc->stats, "vkd", sc->unit, DEV_BSIZE,
	110	DEVSTAT_NO_ORDERED_TAGS,
	111	DEVSTAT_TYPE_DIRECT \| DEVSTAT_TYPE_IF_OTHER,
	112	DEVSTAT_PRIORITY_DISK);
a688b15c	113	sc->dev = disk_create(sc->unit, &sc->disk, &vkd_ops);
ee63ee00 SW	114	sc->dev->si_drv1 = sc;
ee63ee00 SW	115	sc->dev->si_iosize_max = 256 * 1024;
9c2ed617 MD	116
	117	TAILQ_INIT(&sc->cotd_queue);
	118	TAILQ_INIT(&sc->cotd_done);
	119	sc->cotd = cothread_create(vkd_io_thread, vkd_io_intr, sc,
	120	"vkd");
ee63ee00	121	}
d87174b3 MD	122	}
d87174b3 MD	123
e1002718	124	SYSINIT(vkdisk, SI_SUB_DRIVERS, SI_ORDER_FIRST, vkdinit, NULL);
d87174b3 MD	125
d87174b3 MD	126	static int
e1002718	127	vkdopen(struct dev_open_args *ap)
d87174b3	128	{
e1002718	129	struct vkd_softc *sc;
a688b15c	130	struct disk_info info;
d87174b3 MD	131	struct stat st;
	132	cdev_t dev;
	133
	134	dev = ap->a_head.a_dev;
	135	sc = dev->si_drv1;
d87174b3 MD	136	if (fstat(sc->fd, &st) < 0 \|\| st.st_size == 0)
	137	return(ENXIO);
	138
a688b15c MD	139	bzero(&info, sizeof(info));
	140	info.d_media_blksize = DEV_BSIZE;
	141	info.d_media_blocks = st.st_size / info.d_media_blksize;
	142
	143	info.d_nheads = 1;
	144	info.d_ncylinders = 1;
	145	info.d_secpertrack = info.d_media_blocks;
	146	info.d_secpercyl = info.d_secpertrack * info.d_nheads;
	147
	148	disk_setdiskinfo(&sc->disk, &info);
d87174b3 MD	149	return(0);
	150	}
	151
	152	static int
e1002718	153	vkdstrategy(struct dev_strategy_args *ap)
d87174b3 MD	154	{
d87174b3 MD	155	struct bio *bio = ap->a_bio;
e1002718	156	struct vkd_softc *sc;
d87174b3	157	cdev_t dev;
d87174b3 MD	158
	159	dev = ap->a_head.a_dev;
	160	sc = dev->si_drv1;
	161
9c2ed617	162	devstat_start_transaction(&sc->stats);
94131955	163	cothread_lock(sc->cotd, 0);
9c2ed617 MD	164	TAILQ_INSERT_TAIL(&sc->cotd_queue, bio, bio_act);
9c2ed617 MD	165	cothread_signal(sc->cotd);
94131955	166	cothread_unlock(sc->cotd, 0);
9c2ed617	167
d87174b3 MD	168	return(0);
	169	}
	170
3448c124 MD	171	static
3448c124 MD	172	void
9c2ed617	173	vkd_io_intr(cothread_t cotd)
3448c124	174	{
3448c124	175	struct vkd_softc *sc;
9c2ed617 MD	176	struct bio *bio;
	177
	178	sc = cotd->arg;
3448c124	179
94131955	180	cothread_lock(cotd, 0);
9c2ed617 MD	181	while (!TAILQ_EMPTY(&sc->cotd_done)) {
	182	bio = TAILQ_FIRST(&sc->cotd_done);
	183	TAILQ_REMOVE(&sc->cotd_done, bio, bio_act);
	184	devstat_end_transaction_buf(&sc->stats, bio->bio_buf);
	185	biodone(bio);
	186	}
94131955	187	cothread_unlock(sc->cotd, 0);
9c2ed617	188	}
3448c124	189
9c2ed617 MD	190	/*
	191	* WARNING! This runs as a cothread and has no access to mycpu nor can it
	192	* make vkernel-specific calls other then cothread_*() calls.
65905e94 MD	193	*
	194	* WARNING! A signal can occur and be discarded prior to our initial
	195	* call to cothread_lock(). Process pending I/O before waiting.
9c2ed617 MD	196	*/
	197	static
	198	void
	199	vkd_io_thread(cothread_t cotd)
	200	{
	201	struct bio *bio;
	202	struct vkd_softc *sc = cotd->arg;
	203	int count;
3448c124	204
94131955	205	cothread_lock(cotd, 1);
3448c124	206	for (;;) {
9c2ed617 MD	207	count = 0;
	208	while ((bio = TAILQ_FIRST(&sc->cotd_queue)) != NULL) {
	209	TAILQ_REMOVE(&sc->cotd_queue, bio, bio_act);
94131955	210	cothread_unlock(cotd, 1);
3448c124	211	vkd_doio(sc, bio);
94131955	212	cothread_lock(cotd, 1);
9c2ed617 MD	213	TAILQ_INSERT_TAIL(&sc->cotd_done, bio, bio_act);
	214	if (++count == 8) {
	215	cothread_intr(cotd);
	216	count = 0;
	217	}
3448c124	218	}
9c2ed617 MD	219	if (count)
9c2ed617 MD	220	cothread_intr(cotd);
65905e94	221	cothread_wait(cotd); /* interlocks cothread lock */
3448c124	222	}
9c2ed617	223	/* NOT REACHED */
94131955	224	cothread_unlock(cotd, 1);
3448c124 MD	225	}
	226
	227	static
	228	void
	229	vkd_doio(struct vkd_softc sc, struct bio bio)
	230	{
	231	struct buf *bp = bio->bio_buf;
	232	int n;
	233
3448c124 MD	234	switch(bp->b_cmd) {
	235	case BUF_CMD_READ:
	236	n = pread(sc->fd, bp->b_data, bp->b_bcount, bio->bio_offset);
	237	break;
	238	case BUF_CMD_WRITE:
	239	/* XXX HANDLE SHORT WRITE XXX */
	240	n = pwrite(sc->fd, bp->b_data, bp->b_bcount, bio->bio_offset);
	241	break;
8c9c78e2 MD	242	case BUF_CMD_FLUSH:
	243	if (fsync(sc->fd) < 0)
	244	n = -1;
	245	else
	246	n = bp->b_bcount;
	247	break;
3448c124 MD	248	default:
	249	panic("vkd: bad b_cmd %d", bp->b_cmd);
	250	break; /* not reached */
	251	}
	252	if (n != bp->b_bcount) {
	253	bp->b_error = EIO;
	254	bp->b_flags \|= B_ERROR;
	255	}
3448c124	256	bp->b_resid = bp->b_bcount - n;
3448c124 MD	257	}
3448c124 MD	258