[deliverable/linux.git] / net / 9p / trans_virtio.c

/*
 * The Virtio 9p transport driver
 *
 * This is a block based transport driver based on the lguest block driver
 * code.
 *
 *  Copyright (C) 2007, 2008 Eric Van Hensbergen, IBM Corporation
 *
 *  Based on virtio console driver
 *  Copyright (C) 2006, 2007 Rusty Russell, IBM Corporation
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License version 2
 *  as published by the Free Software Foundation.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to:
 *  Free Software Foundation
 *  51 Franklin Street, Fifth Floor
 *  Boston, MA  02111-1301  USA
 *
 */

#include <linux/in.h>
#include <linux/module.h>
#include <linux/net.h>
#include <linux/ipv6.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/un.h>
#include <linux/uaccess.h>
#include <linux/inet.h>
#include <linux/idr.h>
#include <linux/file.h>
#include <net/9p/9p.h>
#include <linux/parser.h>
#include <net/9p/client.h>
#include <net/9p/transport.h>
#include <linux/scatterlist.h>
#include <linux/virtio.h>
#include <linux/virtio_9p.h>

#define VIRTQUEUE_NUM	128

/* a single mutex to manage channel initialization and attachment */
static DEFINE_MUTEX(virtio_9p_lock);

/**
 * struct virtio_chan - per-instance transport information
 * @initialized: whether the channel is initialized
 * @inuse: whether the channel is in use
 * @lock: protects multiple elements within this structure
 * @client: client instance
 * @vdev: virtio dev associated with this channel
 * @vq: virtio queue associated with this channel
 * @sg: scatter gather list which is used to pack a request (protected?)
 *
 * We keep all per-channel information in a structure.
 * This structure is allocated within the devices dev->mem space.
 * A pointer to the structure will get put in the transport private.
 *
 */

struct virtio_chan {
	bool inuse;

	spinlock_t lock;

	struct p9_client *client;
	struct virtio_device *vdev;
	struct virtqueue *vq;

	/* Scatterlist: can be too big for stack. */
	struct scatterlist sg[VIRTQUEUE_NUM];

	int tag_len;
	/*
	 * tag name to identify a mount Non-null terminated
	 */
	char *tag;

	struct list_head chan_list;
};

static struct list_head virtio_chan_list;

/* How many bytes left in this page. */
static unsigned int rest_of_page(void *data)
{
	return PAGE_SIZE - ((unsigned long)data % PAGE_SIZE);
}

/**
 * p9_virtio_close - reclaim resources of a channel
 * @client: client instance
 *
 * This reclaims a channel by freeing its resources and
 * reseting its inuse flag.
 *
 */

static void p9_virtio_close(struct p9_client *client)
{
	struct virtio_chan *chan = client->trans;

	mutex_lock(&virtio_9p_lock);
	if (chan)
		chan->inuse = false;
	mutex_unlock(&virtio_9p_lock);
}

/**
 * req_done - callback which signals activity from the server
 * @vq: virtio queue activity was received on
 *
 * This notifies us that the server has triggered some activity
 * on the virtio channel - most likely a response to request we
 * sent.  Figure out which requests now have responses and wake up
 * those threads.
 *
 * Bugs: could do with some additional sanity checking, but appears to work.
 *
 */

static void req_done(struct virtqueue *vq)
{
	struct virtio_chan *chan = vq->vdev->priv;
	struct p9_fcall *rc;
	unsigned int len;
	struct p9_req_t *req;

	P9_DPRINTK(P9_DEBUG_TRANS, ": request done\n");

	while ((rc = chan->vq->vq_ops->get_buf(chan->vq, &len)) != NULL) {
		P9_DPRINTK(P9_DEBUG_TRANS, ": rc %p\n", rc);
		P9_DPRINTK(P9_DEBUG_TRANS, ": lookup tag %d\n", rc->tag);
		req = p9_tag_lookup(chan->client, rc->tag);
		req->status = REQ_STATUS_RCVD;
		p9_client_cb(chan->client, req);
	}
}

/**
 * pack_sg_list - pack a scatter gather list from a linear buffer
 * @sg: scatter/gather list to pack into
 * @start: which segment of the sg_list to start at
 * @limit: maximum segment to pack data to
 * @data: data to pack into scatter/gather list
 * @count: amount of data to pack into the scatter/gather list
 *
 * sg_lists have multiple segments of various sizes.  This will pack
 * arbitrary data into an existing scatter gather list, segmenting the
 * data as necessary within constraints.
 *
 */

static int
pack_sg_list(struct scatterlist *sg, int start, int limit, char *data,
								int count)
{
	int s;
	int index = start;

	while (count) {
		s = rest_of_page(data);
		if (s > count)
			s = count;
		sg_set_buf(&sg[index++], data, s);
		count -= s;
		data += s;
		BUG_ON(index > limit);
	}

	return index-start;
}

/* We don't currently allow canceling of virtio requests */
static int p9_virtio_cancel(struct p9_client *client, struct p9_req_t *req)
{
	return 1;
}

/**
 * p9_virtio_request - issue a request
 * @client: client instance issuing the request
 * @req: request to be issued
 *
 */

static int
p9_virtio_request(struct p9_client *client, struct p9_req_t *req)
{
	int in, out;
	struct virtio_chan *chan = client->trans;
	char *rdata = (char *)req->rc+sizeof(struct p9_fcall);

	P9_DPRINTK(P9_DEBUG_TRANS, "9p debug: virtio request\n");

	out = pack_sg_list(chan->sg, 0, VIRTQUEUE_NUM, req->tc->sdata,
								req->tc->size);
	in = pack_sg_list(chan->sg, out, VIRTQUEUE_NUM-out, rdata,
								client->msize);

	req->status = REQ_STATUS_SENT;

	if (chan->vq->vq_ops->add_buf(chan->vq, chan->sg, out, in, req->tc) < 0) {
		P9_DPRINTK(P9_DEBUG_TRANS,
			"9p debug: virtio rpc add_buf returned failure");
		return -EIO;
	}

	chan->vq->vq_ops->kick(chan->vq);

	P9_DPRINTK(P9_DEBUG_TRANS, "9p debug: virtio request kicked\n");
	return 0;
}

static ssize_t p9_mount_tag_show(struct device *dev,
				struct device_attribute *attr, char *buf)
{
	struct virtio_chan *chan;
	struct virtio_device *vdev;

	vdev = dev_to_virtio(dev);
	chan = vdev->priv;

	return snprintf(buf, chan->tag_len + 1, "%s", chan->tag);
}

static DEVICE_ATTR(mount_tag, 0444, p9_mount_tag_show, NULL);

/**
 * p9_virtio_probe - probe for existence of 9P virtio channels
 * @vdev: virtio device to probe
 *
 * This probes for existing virtio channels.
 *
 */

static int p9_virtio_probe(struct virtio_device *vdev)
{
	__u16 tag_len;
	char *tag;
	int err;
	struct virtio_chan *chan;

	chan = kmalloc(sizeof(struct virtio_chan), GFP_KERNEL);
	if (!chan) {
		printk(KERN_ERR "9p: Failed to allocate virtio 9P channel\n");
		err = -ENOMEM;
		goto fail;
	}

	chan->vdev = vdev;

	/* We expect one virtqueue, for requests. */
	chan->vq = virtio_find_single_vq(vdev, req_done, "requests");
	if (IS_ERR(chan->vq)) {
		err = PTR_ERR(chan->vq);
		goto out_free_vq;
	}
	chan->vq->vdev->priv = chan;
	spin_lock_init(&chan->lock);

	sg_init_table(chan->sg, VIRTQUEUE_NUM);

	chan->inuse = false;
	if (virtio_has_feature(vdev, VIRTIO_9P_MOUNT_TAG)) {
		vdev->config->get(vdev,
				offsetof(struct virtio_9p_config, tag_len),
				&tag_len, sizeof(tag_len));
	} else {
		err = -EINVAL;
		goto out_free_vq;
	}
	tag = kmalloc(tag_len, GFP_KERNEL);
	if (!tag) {
		err = -ENOMEM;
		goto out_free_vq;
	}
	vdev->config->get(vdev, offsetof(struct virtio_9p_config, tag),
			tag, tag_len);
	chan->tag = tag;
	chan->tag_len = tag_len;
	err = sysfs_create_file(&(vdev->dev.kobj), &dev_attr_mount_tag.attr);
	if (err) {
		kfree(tag);
		goto out_free_vq;
	}
	mutex_lock(&virtio_9p_lock);
	list_add_tail(&chan->chan_list, &virtio_chan_list);
	mutex_unlock(&virtio_9p_lock);
	return 0;

out_free_vq:
	vdev->config->del_vqs(vdev);
	kfree(chan);
fail:
	return err;
}


/**
 * p9_virtio_create - allocate a new virtio channel
 * @client: client instance invoking this transport
 * @devname: string identifying the channel to connect to (unused)
 * @args: args passed from sys_mount() for per-transport options (unused)
 *
 * This sets up a transport channel for 9p communication.  Right now
 * we only match the first available channel, but eventually we couldlook up
 * alternate channels by matching devname versus a virtio_config entry.
 * We use a simple reference count mechanism to ensure that only a single
 * mount has a channel open at a time.
 *
 */

static int
p9_virtio_create(struct p9_client *client, const char *devname, char *args)
{
	struct virtio_chan *chan;
	int ret = -ENOENT;
	int found = 0;

	mutex_lock(&virtio_9p_lock);
	list_for_each_entry(chan, &virtio_chan_list, chan_list) {
		if (!strncmp(devname, chan->tag, chan->tag_len)) {
			if (!chan->inuse) {
				chan->inuse = true;
				found = 1;
				break;
			}
			ret = -EBUSY;
		}
	}
	mutex_unlock(&virtio_9p_lock);

	if (!found) {
		printk(KERN_ERR "9p: no channels available\n");
		return ret;
	}

	client->trans = (void *)chan;
	client->status = Connected;
	chan->client = client;

	return 0;
}

/**
 * p9_virtio_remove - clean up resources associated with a virtio device
 * @vdev: virtio device to remove
 *
 */

static void p9_virtio_remove(struct virtio_device *vdev)
{
	struct virtio_chan *chan = vdev->priv;

	BUG_ON(chan->inuse);
	vdev->config->del_vqs(vdev);

	mutex_lock(&virtio_9p_lock);
	list_del(&chan->chan_list);
	mutex_unlock(&virtio_9p_lock);
	sysfs_remove_file(&(vdev->dev.kobj), &dev_attr_mount_tag.attr);
	kfree(chan->tag);
	kfree(chan);

}

static struct virtio_device_id id_table[] = {
	{ VIRTIO_ID_9P, VIRTIO_DEV_ANY_ID },
	{ 0 },
};

static unsigned int features[] = {
	VIRTIO_9P_MOUNT_TAG,
};

/* The standard "struct lguest_driver": */
static struct virtio_driver p9_virtio_drv = {
	.feature_table  = features,
	.feature_table_size = ARRAY_SIZE(features),
	.driver.name    = KBUILD_MODNAME,
	.driver.owner	= THIS_MODULE,
	.id_table	= id_table,
	.probe		= p9_virtio_probe,
	.remove		= p9_virtio_remove,
};

static struct p9_trans_module p9_virtio_trans = {
	.name = "virtio",
	.create = p9_virtio_create,
	.close = p9_virtio_close,
	.request = p9_virtio_request,
	.cancel = p9_virtio_cancel,
	.maxsize = PAGE_SIZE*16,
	.def = 0,
	.owner = THIS_MODULE,
};

/* The standard init function */
static int __init p9_virtio_init(void)
{
	INIT_LIST_HEAD(&virtio_chan_list);

	v9fs_register_trans(&p9_virtio_trans);
	return register_virtio_driver(&p9_virtio_drv);
}

static void __exit p9_virtio_cleanup(void)
{
	unregister_virtio_driver(&p9_virtio_drv);
	v9fs_unregister_trans(&p9_virtio_trans);
}

module_init(p9_virtio_init);
module_exit(p9_virtio_cleanup);

MODULE_DEVICE_TABLE(virtio, id_table);
MODULE_AUTHOR("Eric Van Hensbergen <ericvh@gmail.com>");
MODULE_DESCRIPTION("Virtio 9p Transport");
MODULE_LICENSE("GPL");
Commit	Line	Data
b530cc79	1	/*
fea511a6	2	* The Virtio 9p transport driver
b530cc79	3	*
e2735b77 EVH	4	* This is a block based transport driver based on the lguest block driver
e2735b77 EVH	5	* code.
b530cc79	6	*
fea511a6	7	* Copyright (C) 2007, 2008 Eric Van Hensbergen, IBM Corporation
b530cc79 EVH	8	*
	9	* Based on virtio console driver
	10	* Copyright (C) 2006, 2007 Rusty Russell, IBM Corporation
	11	*
	12	* This program is free software; you can redistribute it and/or modify
	13	* it under the terms of the GNU General Public License version 2
	14	* as published by the Free Software Foundation.
	15	*
	16	* This program is distributed in the hope that it will be useful,
	17	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	19	* GNU General Public License for more details.
	20	*
	21	* You should have received a copy of the GNU General Public License
	22	* along with this program; if not, write to:
	23	* Free Software Foundation
	24	* 51 Franklin Street, Fifth Floor
	25	* Boston, MA 02111-1301 USA
	26	*
	27	*/
	28
	29	#include <linux/in.h>
	30	#include <linux/module.h>
	31	#include <linux/net.h>
	32	#include <linux/ipv6.h>
	33	#include <linux/errno.h>
	34	#include <linux/kernel.h>
	35	#include <linux/un.h>
	36	#include <linux/uaccess.h>
	37	#include <linux/inet.h>
	38	#include <linux/idr.h>
	39	#include <linux/file.h>
	40	#include <net/9p/9p.h>
	41	#include <linux/parser.h>
8b81ef58	42	#include <net/9p/client.h>
b530cc79 EVH	43	#include <net/9p/transport.h>
	44	#include <linux/scatterlist.h>
	45	#include <linux/virtio.h>
	46	#include <linux/virtio_9p.h>
	47
e2735b77 EVH	48	#define VIRTQUEUE_NUM 128
e2735b77 EVH	49
b530cc79	50	/* a single mutex to manage channel initialization and attachment */
c1549497	51	static DEFINE_MUTEX(virtio_9p_lock);
b530cc79	52
ee443996 EVH	53	/**
	54	* struct virtio_chan - per-instance transport information
	55	* @initialized: whether the channel is initialized
	56	* @inuse: whether the channel is in use
	57	* @lock: protects multiple elements within this structure
0e15597e	58	* @client: client instance
ee443996 EVH	59	* @vdev: virtio dev associated with this channel
ee443996 EVH	60	* @vq: virtio queue associated with this channel
ee443996 EVH	61	* @sg: scatter gather list which is used to pack a request (protected?)
	62	*
	63	* We keep all per-channel information in a structure.
b530cc79 EVH	64	* This structure is allocated within the devices dev->mem space.
b530cc79 EVH	65	* A pointer to the structure will get put in the transport private.
ee443996	66	*
b530cc79	67	*/
ee443996	68
37c1209d	69	struct virtio_chan {
ee443996	70	bool inuse;
b530cc79	71
e2735b77 EVH	72	spinlock_t lock;
e2735b77 EVH	73
fea511a6	74	struct p9_client *client;
b530cc79	75	struct virtio_device *vdev;
e2735b77	76	struct virtqueue *vq;
b530cc79	77
e2735b77 EVH	78	/* Scatterlist: can be too big for stack. */
e2735b77 EVH	79	struct scatterlist sg[VIRTQUEUE_NUM];
37c1209d	80
97ee9b02 AK	81	int tag_len;
	82	/*
	83	* tag name to identify a mount Non-null terminated
	84	*/
	85	char *tag;
	86
37c1209d AK	87	struct list_head chan_list;
	88	};
	89
	90	static struct list_head virtio_chan_list;
b530cc79 EVH	91
	92	/* How many bytes left in this page. */
	93	static unsigned int rest_of_page(void *data)
	94	{
	95	return PAGE_SIZE - ((unsigned long)data % PAGE_SIZE);
	96	}
	97
ee443996 EVH	98	/**
ee443996 EVH	99	* p9_virtio_close - reclaim resources of a channel
0e15597e	100	* @client: client instance
ee443996 EVH	101	*
	102	* This reclaims a channel by freeing its resources and
	103	* reseting its inuse flag.
	104	*
	105	*/
	106
8b81ef58	107	static void p9_virtio_close(struct p9_client *client)
e2735b77	108	{
8b81ef58	109	struct virtio_chan *chan = client->trans;
b530cc79	110
c1549497	111	mutex_lock(&virtio_9p_lock);
fb786100 AK	112	if (chan)
fb786100 AK	113	chan->inuse = false;
c1549497	114	mutex_unlock(&virtio_9p_lock);
b530cc79 EVH	115	}
b530cc79 EVH	116
ee443996 EVH	117	/**
	118	* req_done - callback which signals activity from the server
	119	* @vq: virtio queue activity was received on
	120	*
	121	* This notifies us that the server has triggered some activity
	122	* on the virtio channel - most likely a response to request we
	123	* sent. Figure out which requests now have responses and wake up
	124	* those threads.
	125	*
	126	* Bugs: could do with some additional sanity checking, but appears to work.
	127	*
	128	*/
	129
e2735b77	130	static void req_done(struct virtqueue *vq)
b530cc79	131	{
e2735b77 EVH	132	struct virtio_chan *chan = vq->vdev->priv;
	133	struct p9_fcall *rc;
	134	unsigned int len;
e2735b77 EVH	135	struct p9_req_t *req;
e2735b77 EVH	136
91b8534f EVH	137	P9_DPRINTK(P9_DEBUG_TRANS, ": request done\n");
91b8534f EVH	138
e2735b77	139	while ((rc = chan->vq->vq_ops->get_buf(chan->vq, &len)) != NULL) {
91b8534f EVH	140	P9_DPRINTK(P9_DEBUG_TRANS, ": rc %p\n", rc);
91b8534f EVH	141	P9_DPRINTK(P9_DEBUG_TRANS, ": lookup tag %d\n", rc->tag);
fea511a6	142	req = p9_tag_lookup(chan->client, rc->tag);
1bab88b2	143	req->status = REQ_STATUS_RCVD;
91b8534f	144	p9_client_cb(chan->client, req);
e2735b77	145	}
e2735b77	146	}
b530cc79	147
ee443996 EVH	148	/**
	149	* pack_sg_list - pack a scatter gather list from a linear buffer
	150	* @sg: scatter/gather list to pack into
	151	* @start: which segment of the sg_list to start at
	152	* @limit: maximum segment to pack data to
	153	* @data: data to pack into scatter/gather list
	154	* @count: amount of data to pack into the scatter/gather list
	155	*
	156	* sg_lists have multiple segments of various sizes. This will pack
	157	* arbitrary data into an existing scatter gather list, segmenting the
	158	* data as necessary within constraints.
	159	*
	160	*/
	161
e2735b77 EVH	162	static int
	163	pack_sg_list(struct scatterlist sg, int start, int limit, char data,
	164	int count)
	165	{
	166	int s;
	167	int index = start;
	168
	169	while (count) {
	170	s = rest_of_page(data);
	171	if (s > count)
	172	s = count;
	173	sg_set_buf(&sg[index++], data, s);
	174	count -= s;
	175	data += s;
d6584f3a	176	BUG_ON(index > limit);
e2735b77	177	}
b530cc79	178
e2735b77	179	return index-start;
b530cc79 EVH	180	}
b530cc79 EVH	181
91b8534f EVH	182	/* We don't currently allow canceling of virtio requests */
	183	static int p9_virtio_cancel(struct p9_client client, struct p9_req_t req)
	184	{
	185	return 1;
	186	}
	187
ee443996	188	/**
91b8534f	189	* p9_virtio_request - issue a request
0e15597e AK	190	* @client: client instance issuing the request
0e15597e AK	191	* @req: request to be issued
ee443996 EVH	192	*
	193	*/
	194
e2735b77	195	static int
91b8534f	196	p9_virtio_request(struct p9_client client, struct p9_req_t req)
b530cc79	197	{
e2735b77	198	int in, out;
91b8534f EVH	199	struct virtio_chan *chan = client->trans;
91b8534f EVH	200	char rdata = (char )req->rc+sizeof(struct p9_fcall);
b530cc79	201
91b8534f	202	P9_DPRINTK(P9_DEBUG_TRANS, "9p debug: virtio request\n");
b530cc79	203
91b8534f EVH	204	out = pack_sg_list(chan->sg, 0, VIRTQUEUE_NUM, req->tc->sdata,
	205	req->tc->size);
	206	in = pack_sg_list(chan->sg, out, VIRTQUEUE_NUM-out, rdata,
	207	client->msize);
b530cc79	208
e2735b77	209	req->status = REQ_STATUS_SENT;
b530cc79	210
3c1b27d5	211	if (chan->vq->vq_ops->add_buf(chan->vq, chan->sg, out, in, req->tc) < 0) {
e2735b77 EVH	212	P9_DPRINTK(P9_DEBUG_TRANS,
	213	"9p debug: virtio rpc add_buf returned failure");
	214	return -EIO;
	215	}
b530cc79	216
e2735b77	217	chan->vq->vq_ops->kick(chan->vq);
b530cc79	218
91b8534f	219	P9_DPRINTK(P9_DEBUG_TRANS, "9p debug: virtio request kicked\n");
e2735b77	220	return 0;
b530cc79 EVH	221	}
b530cc79 EVH	222
86c84373 AK	223	static ssize_t p9_mount_tag_show(struct device *dev,
	224	struct device_attribute attr, char buf)
	225	{
	226	struct virtio_chan *chan;
	227	struct virtio_device *vdev;
	228
	229	vdev = dev_to_virtio(dev);
	230	chan = vdev->priv;
	231
	232	return snprintf(buf, chan->tag_len + 1, "%s", chan->tag);
	233	}
	234
	235	static DEVICE_ATTR(mount_tag, 0444, p9_mount_tag_show, NULL);
	236
ee443996 EVH	237	/**
	238	* p9_virtio_probe - probe for existence of 9P virtio channels
	239	* @vdev: virtio device to probe
	240	*
37c1209d	241	* This probes for existing virtio channels.
ee443996 EVH	242	*
	243	*/
	244
e2735b77	245	static int p9_virtio_probe(struct virtio_device *vdev)
b530cc79	246	{
97ee9b02 AK	247	__u16 tag_len;
97ee9b02 AK	248	char *tag;
b530cc79 EVH	249	int err;
b530cc79 EVH	250	struct virtio_chan *chan;
b530cc79	251
37c1209d AK	252	chan = kmalloc(sizeof(struct virtio_chan), GFP_KERNEL);
	253	if (!chan) {
	254	printk(KERN_ERR "9p: Failed to allocate virtio 9P channel\n");
b530cc79 EVH	255	err = -ENOMEM;
	256	goto fail;
	257	}
	258
e2735b77	259	chan->vdev = vdev;
b530cc79	260
e2735b77	261	/* We expect one virtqueue, for requests. */
d2a7ddda	262	chan->vq = virtio_find_single_vq(vdev, req_done, "requests");
e2735b77 EVH	263	if (IS_ERR(chan->vq)) {
	264	err = PTR_ERR(chan->vq);
	265	goto out_free_vq;
b530cc79	266	}
e2735b77 EVH	267	chan->vq->vdev->priv = chan;
e2735b77 EVH	268	spin_lock_init(&chan->lock);
b530cc79	269
e2735b77	270	sg_init_table(chan->sg, VIRTQUEUE_NUM);
b530cc79	271
b530cc79	272	chan->inuse = false;
97ee9b02 AK	273	if (virtio_has_feature(vdev, VIRTIO_9P_MOUNT_TAG)) {
	274	vdev->config->get(vdev,
	275	offsetof(struct virtio_9p_config, tag_len),
	276	&tag_len, sizeof(tag_len));
	277	} else {
	278	err = -EINVAL;
	279	goto out_free_vq;
	280	}
	281	tag = kmalloc(tag_len, GFP_KERNEL);
	282	if (!tag) {
	283	err = -ENOMEM;
	284	goto out_free_vq;
	285	}
	286	vdev->config->get(vdev, offsetof(struct virtio_9p_config, tag),
	287	tag, tag_len);
	288	chan->tag = tag;
	289	chan->tag_len = tag_len;
86c84373 AK	290	err = sysfs_create_file(&(vdev->dev.kobj), &dev_attr_mount_tag.attr);
	291	if (err) {
	292	kfree(tag);
	293	goto out_free_vq;
	294	}
37c1209d AK	295	mutex_lock(&virtio_9p_lock);
	296	list_add_tail(&chan->chan_list, &virtio_chan_list);
	297	mutex_unlock(&virtio_9p_lock);
b530cc79 EVH	298	return 0;
b530cc79 EVH	299
e2735b77	300	out_free_vq:
d2a7ddda	301	vdev->config->del_vqs(vdev);
37c1209d	302	kfree(chan);
b530cc79	303	fail:
b530cc79 EVH	304	return err;
	305	}
	306
ee443996 EVH	307
	308	/**
	309	* p9_virtio_create - allocate a new virtio channel
8b81ef58	310	* @client: client instance invoking this transport
ee443996 EVH	311	* @devname: string identifying the channel to connect to (unused)
ee443996 EVH	312	* @args: args passed from sys_mount() for per-transport options (unused)
ee443996 EVH	313	*
ee443996 EVH	314	* This sets up a transport channel for 9p communication. Right now
b530cc79 EVH	315	* we only match the first available channel, but eventually we couldlook up
	316	* alternate channels by matching devname versus a virtio_config entry.
	317	* We use a simple reference count mechanism to ensure that only a single
ee443996 EVH	318	* mount has a channel open at a time.
ee443996 EVH	319	*
ee443996 EVH	320	*/
ee443996 EVH	321
8b81ef58 EVH	322	static int
8b81ef58 EVH	323	p9_virtio_create(struct p9_client client, const char devname, char *args)
b530cc79	324	{
37c1209d	325	struct virtio_chan *chan;
c1a7c226	326	int ret = -ENOENT;
37c1209d	327	int found = 0;
b530cc79	328
c1549497	329	mutex_lock(&virtio_9p_lock);
37c1209d	330	list_for_each_entry(chan, &virtio_chan_list, chan_list) {
97ee9b02	331	if (!strncmp(devname, chan->tag, chan->tag_len)) {
f75580c4 AK	332	if (!chan->inuse) {
f75580c4 AK	333	chan->inuse = true;
37c1209d	334	found = 1;
f75580c4 AK	335	break;
f75580c4 AK	336	}
c1a7c226	337	ret = -EBUSY;
b530cc79 EVH	338	}
b530cc79 EVH	339	}
c1549497	340	mutex_unlock(&virtio_9p_lock);
b530cc79	341
37c1209d	342	if (!found) {
e2735b77	343	printk(KERN_ERR "9p: no channels available\n");
c1a7c226	344	return ret;
e2735b77 EVH	345	}
e2735b77 EVH	346
8b81ef58	347	client->trans = (void *)chan;
562ada61	348	client->status = Connected;
fea511a6	349	chan->client = client;
b530cc79	350
8b81ef58	351	return 0;
b530cc79 EVH	352	}
b530cc79 EVH	353
ee443996 EVH	354	/**
	355	* p9_virtio_remove - clean up resources associated with a virtio device
	356	* @vdev: virtio device to remove
	357	*
	358	*/
	359
f3933545 EVH	360	static void p9_virtio_remove(struct virtio_device *vdev)
	361	{
	362	struct virtio_chan *chan = vdev->priv;
	363
	364	BUG_ON(chan->inuse);
37c1209d AK	365	vdev->config->del_vqs(vdev);
	366
	367	mutex_lock(&virtio_9p_lock);
	368	list_del(&chan->chan_list);
	369	mutex_unlock(&virtio_9p_lock);
86c84373	370	sysfs_remove_file(&(vdev->dev.kobj), &dev_attr_mount_tag.attr);
97ee9b02	371	kfree(chan->tag);
37c1209d	372	kfree(chan);
f3933545	373
f3933545 EVH	374	}
f3933545 EVH	375
b530cc79 EVH	376	static struct virtio_device_id id_table[] = {
	377	{ VIRTIO_ID_9P, VIRTIO_DEV_ANY_ID },
	378	{ 0 },
	379	};
	380
97ee9b02 AK	381	static unsigned int features[] = {
	382	VIRTIO_9P_MOUNT_TAG,
	383	};
	384
b530cc79 EVH	385	/* The standard "struct lguest_driver": */
b530cc79 EVH	386	static struct virtio_driver p9_virtio_drv = {
97ee9b02 AK	387	.feature_table = features,
	388	.feature_table_size = ARRAY_SIZE(features),
	389	.driver.name = KBUILD_MODNAME,
	390	.driver.owner = THIS_MODULE,
	391	.id_table = id_table,
	392	.probe = p9_virtio_probe,
	393	.remove = p9_virtio_remove,
b530cc79 EVH	394	};
	395
	396	static struct p9_trans_module p9_virtio_trans = {
	397	.name = "virtio",
	398	.create = p9_virtio_create,
8b81ef58	399	.close = p9_virtio_close,
91b8534f EVH	400	.request = p9_virtio_request,
91b8534f EVH	401	.cancel = p9_virtio_cancel,
e2735b77	402	.maxsize = PAGE_SIZE*16,
b530cc79	403	.def = 0,
72029fe8	404	.owner = THIS_MODULE,
b530cc79 EVH	405	};
	406
	407	/* The standard init function */
	408	static int __init p9_virtio_init(void)
	409	{
37c1209d	410	INIT_LIST_HEAD(&virtio_chan_list);
b530cc79 EVH	411
	412	v9fs_register_trans(&p9_virtio_trans);
	413	return register_virtio_driver(&p9_virtio_drv);
	414	}
	415
f3933545 EVH	416	static void __exit p9_virtio_cleanup(void)
	417	{
	418	unregister_virtio_driver(&p9_virtio_drv);
72029fe8	419	v9fs_unregister_trans(&p9_virtio_trans);
f3933545 EVH	420	}
f3933545 EVH	421
b530cc79	422	module_init(p9_virtio_init);
f3933545	423	module_exit(p9_virtio_cleanup);
b530cc79 EVH	424
	425	MODULE_DEVICE_TABLE(virtio, id_table);
	426	MODULE_AUTHOR("Eric Van Hensbergen <ericvh@gmail.com>");
	427	MODULE_DESCRIPTION("Virtio 9p Transport");
	428	MODULE_LICENSE("GPL");