[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;
	int ring_bufs_avail;
	wait_queue_head_t *vc_wq;

	/* 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;
	unsigned long flags;

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

	do {
		spin_lock_irqsave(&chan->lock, flags);
		rc = virtqueue_get_buf(chan->vq, &len);

		if (rc != NULL) {
			if (!chan->ring_bufs_avail) {
				chan->ring_bufs_avail = 1;
				wake_up(chan->vc_wq);
			}
			spin_unlock_irqrestore(&chan->lock, flags);
			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);
		} else {
			spin_unlock_irqrestore(&chan->lock, flags);
		}
	} while (rc != NULL);
}

/**
 * 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);
	unsigned long flags;
	int err;

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

req_retry:
	req->status = REQ_STATUS_SENT;

	spin_lock_irqsave(&chan->lock, flags);
	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);

	err = virtqueue_add_buf(chan->vq, chan->sg, out, in, req->tc);
	if (err < 0) {
		if (err == -ENOSPC) {
			chan->ring_bufs_avail = 0;
			spin_unlock_irqrestore(&chan->lock, flags);
			err = wait_event_interruptible(*chan->vc_wq,
							chan->ring_bufs_avail);
			if (err  == -ERESTARTSYS)
				return err;

			P9_DPRINTK(P9_DEBUG_TRANS, "9p:Retry virtio request\n");
			goto req_retry;
		} else {
			spin_unlock_irqrestore(&chan->lock, flags);
			P9_DPRINTK(P9_DEBUG_TRANS,
					"9p debug: "
					"virtio rpc add_buf returned failure");
			return -EIO;
		}
	}

	virtqueue_kick(chan->vq);
	spin_unlock_irqrestore(&chan->lock, flags);

	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) {
		goto out_free_tag;
	}
	chan->vc_wq = kmalloc(sizeof(wait_queue_head_t), GFP_KERNEL);
	if (!chan->vc_wq) {
		err = -ENOMEM;
		goto out_free_tag;
	}
	init_waitqueue_head(chan->vc_wq);
	chan->ring_bufs_avail = 1;

	mutex_lock(&virtio_9p_lock);
	list_add_tail(&chan->chan_list, &virtio_chan_list);
	mutex_unlock(&virtio_9p_lock);
	return 0;

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