[net-next-2.6.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 <linux/slab.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 = virtqueue_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 (virtqueue_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;
	}

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