[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 <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>
#include "trans_common.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;
			if (req->tc->private) {
				struct trans_rpage_info *rp = req->tc->private;
				/*Release pages */
				p9_release_req_pages(rp);
				if (rp->rp_alloc)
					kfree(rp);
				req->tc->private = NULL;
			}
			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;
}

/**
 * pack_sg_list_p - Just like pack_sg_list. Instead of taking a buffer,
 * this takes a list of pages.
 * @sg: scatter/gather list to pack into
 * @start: which segment of the sg_list to start at
 * @pdata_off: Offset into the first page
 * @**pdata: a list of pages to add into sg.
 * @count: amount of data to pack into the scatter/gather list
 */
static int
pack_sg_list_p(struct scatterlist *sg, int start, int limit, size_t pdata_off,
		struct page **pdata, int count)
{
	int s;
	int i = 0;
	int index = start;

	if (pdata_off) {
		s = min((int)(PAGE_SIZE - pdata_off), count);
		sg_set_page(&sg[index++], pdata[i++], s, pdata_off);
		count -= s;
	}

	while (count) {
		BUG_ON(index > limit);
		s = min((int)PAGE_SIZE, count);
		sg_set_page(&sg[index++], pdata[i++], s, 0);
		count -= s;
	}
	return index-start;
}

/**
 * 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, inp, outp;
	struct virtio_chan *chan = client->trans;
	char *rdata = (char *)req->rc+sizeof(struct p9_fcall);
	unsigned long flags;
	size_t pdata_off = 0;
	struct trans_rpage_info *rpinfo = NULL;
	int err, pdata_len = 0;

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

req_retry:
	req->status = REQ_STATUS_SENT;

	if (req->tc->pbuf_size && (req->tc->pubuf && P9_IS_USER_CONTEXT)) {
		int nr_pages = p9_nr_pages(req);
		int rpinfo_size = sizeof(struct trans_rpage_info) +
			sizeof(struct page *) * nr_pages;

		if (rpinfo_size <= (req->tc->capacity - req->tc->size)) {
			/* We can use sdata */
			req->tc->private = req->tc->sdata + req->tc->size;
			rpinfo = (struct trans_rpage_info *)req->tc->private;
			rpinfo->rp_alloc = 0;
		} else {
			req->tc->private = kmalloc(rpinfo_size, GFP_NOFS);
			if (!req->tc->private) {
				P9_DPRINTK(P9_DEBUG_TRANS, "9p debug: "
					"private kmalloc returned NULL");
				return -ENOMEM;
			}
			rpinfo = (struct trans_rpage_info *)req->tc->private;
			rpinfo->rp_alloc = 1;
		}

		err = p9_payload_gup(req, &pdata_off, &pdata_len, nr_pages,
				req->tc->id == P9_TREAD ? 1 : 0);
		if (err < 0) {
			if (rpinfo->rp_alloc)
				kfree(rpinfo);
			return err;
		}
	}

	spin_lock_irqsave(&chan->lock, flags);

	/* Handle out VirtIO ring buffers */
	out = pack_sg_list(chan->sg, 0, VIRTQUEUE_NUM, req->tc->sdata,
			req->tc->size);

	if (req->tc->pbuf_size && (req->tc->id == P9_TWRITE)) {
		/* We have additional write payload buffer to take care */
		if (req->tc->pubuf && P9_IS_USER_CONTEXT) {
			outp = pack_sg_list_p(chan->sg, out, VIRTQUEUE_NUM,
					pdata_off, rpinfo->rp_data, pdata_len);
		} else {
			char *pbuf = req->tc->pubuf ? req->tc->pubuf :
								req->tc->pkbuf;
			outp = pack_sg_list(chan->sg, out, VIRTQUEUE_NUM, pbuf,
					req->tc->pbuf_size);
		}
		out += outp;
	}

	/* Handle in VirtIO ring buffers */
	if (req->tc->pbuf_size &&
		((req->tc->id == P9_TREAD) || (req->tc->id == P9_TREADDIR))) {
		/*
		 * Take care of additional Read payload.
		 * 11 is the read/write header = PDU Header(7) + IO Size (4).
		 * Arrange in such a way that server places header in the
		 * alloced memory and payload onto the user buffer.
		 */
		inp = pack_sg_list(chan->sg, out, VIRTQUEUE_NUM, rdata, 11);
		/*
		 * Running executables in the filesystem may result in
		 * a read request with kernel buffer as opposed to user buffer.
		 */
		if (req->tc->pubuf && P9_IS_USER_CONTEXT) {
			in = pack_sg_list_p(chan->sg, out+inp, VIRTQUEUE_NUM,
					pdata_off, rpinfo->rp_data, pdata_len);
		} else {
			char *pbuf = req->tc->pubuf ? req->tc->pubuf :
								req->tc->pkbuf;
			in = pack_sg_list(chan->sg, out+inp, VIRTQUEUE_NUM,
					pbuf, req->tc->pbuf_size);
		}
		in += inp;
	} else {
		in = pack_sg_list(chan->sg, out, VIRTQUEUE_NUM, 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");
			if (rpinfo && rpinfo->rp_alloc)
				kfree(rpinfo);
			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,
	.pref = P9_TRANS_PREF_PAYLOAD_SEP,
	.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 <[email protected]>");
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>
4038866d	48	#include "trans_common.h"
b530cc79	49
e2735b77 EVH	50	#define VIRTQUEUE_NUM 128
e2735b77 EVH	51
b530cc79	52	/* a single mutex to manage channel initialization and attachment */
c1549497	53	static DEFINE_MUTEX(virtio_9p_lock);
b530cc79	54
ee443996 EVH	55	/**
	56	* struct virtio_chan - per-instance transport information
	57	* @initialized: whether the channel is initialized
	58	* @inuse: whether the channel is in use
	59	* @lock: protects multiple elements within this structure
0e15597e	60	* @client: client instance
ee443996 EVH	61	* @vdev: virtio dev associated with this channel
ee443996 EVH	62	* @vq: virtio queue associated with this channel
ee443996 EVH	63	* @sg: scatter gather list which is used to pack a request (protected?)
	64	*
	65	* We keep all per-channel information in a structure.
b530cc79 EVH	66	* This structure is allocated within the devices dev->mem space.
b530cc79 EVH	67	* A pointer to the structure will get put in the transport private.
ee443996	68	*
b530cc79	69	*/
ee443996	70
37c1209d	71	struct virtio_chan {
ee443996	72	bool inuse;
b530cc79	73
e2735b77 EVH	74	spinlock_t lock;
e2735b77 EVH	75
fea511a6	76	struct p9_client *client;
b530cc79	77	struct virtio_device *vdev;
e2735b77	78	struct virtqueue *vq;
52f44e0d VJJ	79	int ring_bufs_avail;
52f44e0d VJJ	80	wait_queue_head_t *vc_wq;
b530cc79	81
e2735b77 EVH	82	/* Scatterlist: can be too big for stack. */
e2735b77 EVH	83	struct scatterlist sg[VIRTQUEUE_NUM];
37c1209d	84
97ee9b02 AK	85	int tag_len;
	86	/*
	87	* tag name to identify a mount Non-null terminated
	88	*/
	89	char *tag;
	90
37c1209d AK	91	struct list_head chan_list;
	92	};
	93
	94	static struct list_head virtio_chan_list;
b530cc79 EVH	95
	96	/* How many bytes left in this page. */
	97	static unsigned int rest_of_page(void *data)
	98	{
	99	return PAGE_SIZE - ((unsigned long)data % PAGE_SIZE);
	100	}
	101
ee443996 EVH	102	/**
ee443996 EVH	103	* p9_virtio_close - reclaim resources of a channel
0e15597e	104	* @client: client instance
ee443996 EVH	105	*
	106	* This reclaims a channel by freeing its resources and
	107	* reseting its inuse flag.
	108	*
	109	*/
	110
8b81ef58	111	static void p9_virtio_close(struct p9_client *client)
e2735b77	112	{
8b81ef58	113	struct virtio_chan *chan = client->trans;
b530cc79	114
c1549497	115	mutex_lock(&virtio_9p_lock);
fb786100 AK	116	if (chan)
fb786100 AK	117	chan->inuse = false;
c1549497	118	mutex_unlock(&virtio_9p_lock);
b530cc79 EVH	119	}
b530cc79 EVH	120
ee443996 EVH	121	/**
	122	* req_done - callback which signals activity from the server
	123	* @vq: virtio queue activity was received on
	124	*
	125	* This notifies us that the server has triggered some activity
	126	* on the virtio channel - most likely a response to request we
	127	* sent. Figure out which requests now have responses and wake up
	128	* those threads.
	129	*
	130	* Bugs: could do with some additional sanity checking, but appears to work.
	131	*
	132	*/
	133
e2735b77	134	static void req_done(struct virtqueue *vq)
b530cc79	135	{
e2735b77 EVH	136	struct virtio_chan *chan = vq->vdev->priv;
	137	struct p9_fcall *rc;
	138	unsigned int len;
e2735b77	139	struct p9_req_t *req;
419b3956	140	unsigned long flags;
e2735b77	141
91b8534f EVH	142	P9_DPRINTK(P9_DEBUG_TRANS, ": request done\n");
91b8534f EVH	143
419b3956 VJJ	144	do {
	145	spin_lock_irqsave(&chan->lock, flags);
	146	rc = virtqueue_get_buf(chan->vq, &len);
419b3956 VJJ	147
419b3956 VJJ	148	if (rc != NULL) {
52f44e0d VJJ	149	if (!chan->ring_bufs_avail) {
	150	chan->ring_bufs_avail = 1;
	151	wake_up(chan->vc_wq);
	152	}
	153	spin_unlock_irqrestore(&chan->lock, flags);
419b3956 VJJ	154	P9_DPRINTK(P9_DEBUG_TRANS, ": rc %p\n", rc);
	155	P9_DPRINTK(P9_DEBUG_TRANS, ": lookup tag %d\n",
	156	rc->tag);
	157	req = p9_tag_lookup(chan->client, rc->tag);
	158	req->status = REQ_STATUS_RCVD;
4038866d VJJ	159	if (req->tc->private) {
	160	struct trans_rpage_info *rp = req->tc->private;
	161	/Release pages /
	162	p9_release_req_pages(rp);
	163	if (rp->rp_alloc)
	164	kfree(rp);
	165	req->tc->private = NULL;
	166	}
419b3956	167	p9_client_cb(chan->client, req);
52f44e0d VJJ	168	} else {
52f44e0d VJJ	169	spin_unlock_irqrestore(&chan->lock, flags);
419b3956 VJJ	170	}
419b3956 VJJ	171	} while (rc != NULL);
e2735b77	172	}
b530cc79	173
ee443996 EVH	174	/**
	175	* pack_sg_list - pack a scatter gather list from a linear buffer
	176	* @sg: scatter/gather list to pack into
	177	* @start: which segment of the sg_list to start at
	178	* @limit: maximum segment to pack data to
	179	* @data: data to pack into scatter/gather list
	180	* @count: amount of data to pack into the scatter/gather list
	181	*
	182	* sg_lists have multiple segments of various sizes. This will pack
	183	* arbitrary data into an existing scatter gather list, segmenting the
	184	* data as necessary within constraints.
	185	*
	186	*/
	187
e2735b77 EVH	188	static int
	189	pack_sg_list(struct scatterlist sg, int start, int limit, char data,
	190	int count)
	191	{
	192	int s;
	193	int index = start;
	194
	195	while (count) {
	196	s = rest_of_page(data);
	197	if (s > count)
	198	s = count;
	199	sg_set_buf(&sg[index++], data, s);
	200	count -= s;
	201	data += s;
d6584f3a	202	BUG_ON(index > limit);
e2735b77	203	}
b530cc79	204
e2735b77	205	return index-start;
b530cc79 EVH	206	}
b530cc79 EVH	207
91b8534f EVH	208	/* We don't currently allow canceling of virtio requests */
	209	static int p9_virtio_cancel(struct p9_client client, struct p9_req_t req)
	210	{
	211	return 1;
	212	}
	213
4038866d VJJ	214	/**
	215	* pack_sg_list_p - Just like pack_sg_list. Instead of taking a buffer,
	216	* this takes a list of pages.
	217	* @sg: scatter/gather list to pack into
	218	* @start: which segment of the sg_list to start at
	219	* @pdata_off: Offset into the first page
	220	* @**pdata: a list of pages to add into sg.
	221	* @count: amount of data to pack into the scatter/gather list
	222	*/
	223	static int
	224	pack_sg_list_p(struct scatterlist *sg, int start, int limit, size_t pdata_off,
	225	struct page **pdata, int count)
	226	{
	227	int s;
	228	int i = 0;
	229	int index = start;
	230
	231	if (pdata_off) {
	232	s = min((int)(PAGE_SIZE - pdata_off), count);
	233	sg_set_page(&sg[index++], pdata[i++], s, pdata_off);
	234	count -= s;
	235	}
	236
	237	while (count) {
	238	BUG_ON(index > limit);
	239	s = min((int)PAGE_SIZE, count);
	240	sg_set_page(&sg[index++], pdata[i++], s, 0);
	241	count -= s;
	242	}
	243	return index-start;
	244	}
	245
ee443996	246	/**
91b8534f	247	* p9_virtio_request - issue a request
0e15597e AK	248	* @client: client instance issuing the request
0e15597e AK	249	* @req: request to be issued
ee443996 EVH	250	*
	251	*/
	252
e2735b77	253	static int
91b8534f	254	p9_virtio_request(struct p9_client client, struct p9_req_t req)
b530cc79	255	{
4038866d	256	int in, out, inp, outp;
91b8534f EVH	257	struct virtio_chan *chan = client->trans;
91b8534f EVH	258	char rdata = (char )req->rc+sizeof(struct p9_fcall);
419b3956	259	unsigned long flags;
4038866d VJJ	260	size_t pdata_off = 0;
	261	struct trans_rpage_info *rpinfo = NULL;
	262	int err, pdata_len = 0;
b530cc79	263
91b8534f	264	P9_DPRINTK(P9_DEBUG_TRANS, "9p debug: virtio request\n");
b530cc79	265
52f44e0d	266	req_retry:
419b3956 VJJ	267	req->status = REQ_STATUS_SENT;
419b3956 VJJ	268
4038866d VJJ	269	if (req->tc->pbuf_size && (req->tc->pubuf && P9_IS_USER_CONTEXT)) {
	270	int nr_pages = p9_nr_pages(req);
	271	int rpinfo_size = sizeof(struct trans_rpage_info) +
	272	sizeof(struct page ) nr_pages;
	273
	274	if (rpinfo_size <= (req->tc->capacity - req->tc->size)) {
	275	/* We can use sdata */
	276	req->tc->private = req->tc->sdata + req->tc->size;
	277	rpinfo = (struct trans_rpage_info *)req->tc->private;
	278	rpinfo->rp_alloc = 0;
	279	} else {
	280	req->tc->private = kmalloc(rpinfo_size, GFP_NOFS);
	281	if (!req->tc->private) {
	282	P9_DPRINTK(P9_DEBUG_TRANS, "9p debug: "
	283	"private kmalloc returned NULL");
	284	return -ENOMEM;
	285	}
	286	rpinfo = (struct trans_rpage_info *)req->tc->private;
	287	rpinfo->rp_alloc = 1;
	288	}
	289
	290	err = p9_payload_gup(req, &pdata_off, &pdata_len, nr_pages,
	291	req->tc->id == P9_TREAD ? 1 : 0);
	292	if (err < 0) {
	293	if (rpinfo->rp_alloc)
	294	kfree(rpinfo);
	295	return err;
	296	}
	297	}
	298
419b3956	299	spin_lock_irqsave(&chan->lock, flags);
4038866d VJJ	300
4038866d VJJ	301	/* Handle out VirtIO ring buffers */
91b8534f	302	out = pack_sg_list(chan->sg, 0, VIRTQUEUE_NUM, req->tc->sdata,
4038866d VJJ	303	req->tc->size);
	304
	305	if (req->tc->pbuf_size && (req->tc->id == P9_TWRITE)) {
	306	/* We have additional write payload buffer to take care */
	307	if (req->tc->pubuf && P9_IS_USER_CONTEXT) {
	308	outp = pack_sg_list_p(chan->sg, out, VIRTQUEUE_NUM,
	309	pdata_off, rpinfo->rp_data, pdata_len);
	310	} else {
	311	char *pbuf = req->tc->pubuf ? req->tc->pubuf :
	312	req->tc->pkbuf;
	313	outp = pack_sg_list(chan->sg, out, VIRTQUEUE_NUM, pbuf,
	314	req->tc->pbuf_size);
	315	}
	316	out += outp;
	317	}
	318
	319	/* Handle in VirtIO ring buffers */
	320	if (req->tc->pbuf_size &&
	321	((req->tc->id == P9_TREAD) \|\| (req->tc->id == P9_TREADDIR))) {
	322	/*
	323	* Take care of additional Read payload.
	324	* 11 is the read/write header = PDU Header(7) + IO Size (4).
	325	* Arrange in such a way that server places header in the
	326	* alloced memory and payload onto the user buffer.
	327	*/
	328	inp = pack_sg_list(chan->sg, out, VIRTQUEUE_NUM, rdata, 11);
	329	/*
	330	* Running executables in the filesystem may result in
	331	* a read request with kernel buffer as opposed to user buffer.
	332	*/
	333	if (req->tc->pubuf && P9_IS_USER_CONTEXT) {
	334	in = pack_sg_list_p(chan->sg, out+inp, VIRTQUEUE_NUM,
	335	pdata_off, rpinfo->rp_data, pdata_len);
	336	} else {
	337	char *pbuf = req->tc->pubuf ? req->tc->pubuf :
	338	req->tc->pkbuf;
	339	in = pack_sg_list(chan->sg, out+inp, VIRTQUEUE_NUM,
	340	pbuf, req->tc->pbuf_size);
	341	}
	342	in += inp;
	343	} else {
	344	in = pack_sg_list(chan->sg, out, VIRTQUEUE_NUM, rdata,
	345	client->msize);
	346	}
b530cc79	347
419b3956 VJJ	348	err = virtqueue_add_buf(chan->vq, chan->sg, out, in, req->tc);
419b3956 VJJ	349	if (err < 0) {
52f44e0d VJJ	350	if (err == -ENOSPC) {
	351	chan->ring_bufs_avail = 0;
	352	spin_unlock_irqrestore(&chan->lock, flags);
	353	err = wait_event_interruptible(*chan->vc_wq,
	354	chan->ring_bufs_avail);
	355	if (err == -ERESTARTSYS)
	356	return err;
	357
	358	P9_DPRINTK(P9_DEBUG_TRANS, "9p:Retry virtio request\n");
	359	goto req_retry;
	360	} else {
	361	spin_unlock_irqrestore(&chan->lock, flags);
	362	P9_DPRINTK(P9_DEBUG_TRANS,
	363	"9p debug: "
	364	"virtio rpc add_buf returned failure");
4038866d VJJ	365	if (rpinfo && rpinfo->rp_alloc)
4038866d VJJ	366	kfree(rpinfo);
52f44e0d VJJ	367	return -EIO;
52f44e0d VJJ	368	}
e2735b77	369	}
b530cc79	370
dc3f5e68	371	virtqueue_kick(chan->vq);
419b3956	372	spin_unlock_irqrestore(&chan->lock, flags);
b530cc79	373
91b8534f	374	P9_DPRINTK(P9_DEBUG_TRANS, "9p debug: virtio request kicked\n");
e2735b77	375	return 0;
b530cc79 EVH	376	}
b530cc79 EVH	377
86c84373 AK	378	static ssize_t p9_mount_tag_show(struct device *dev,
	379	struct device_attribute attr, char buf)
	380	{
	381	struct virtio_chan *chan;
	382	struct virtio_device *vdev;
	383
	384	vdev = dev_to_virtio(dev);
	385	chan = vdev->priv;
	386
	387	return snprintf(buf, chan->tag_len + 1, "%s", chan->tag);
	388	}
	389
	390	static DEVICE_ATTR(mount_tag, 0444, p9_mount_tag_show, NULL);
	391
ee443996 EVH	392	/**
	393	* p9_virtio_probe - probe for existence of 9P virtio channels
	394	* @vdev: virtio device to probe
	395	*
37c1209d	396	* This probes for existing virtio channels.
ee443996 EVH	397	*
	398	*/
	399
e2735b77	400	static int p9_virtio_probe(struct virtio_device *vdev)
b530cc79	401	{
97ee9b02 AK	402	__u16 tag_len;
97ee9b02 AK	403	char *tag;
b530cc79 EVH	404	int err;
b530cc79 EVH	405	struct virtio_chan *chan;
b530cc79	406
37c1209d AK	407	chan = kmalloc(sizeof(struct virtio_chan), GFP_KERNEL);
	408	if (!chan) {
	409	printk(KERN_ERR "9p: Failed to allocate virtio 9P channel\n");
b530cc79 EVH	410	err = -ENOMEM;
	411	goto fail;
	412	}
	413
e2735b77	414	chan->vdev = vdev;
b530cc79	415
e2735b77	416	/* We expect one virtqueue, for requests. */
d2a7ddda	417	chan->vq = virtio_find_single_vq(vdev, req_done, "requests");
e2735b77 EVH	418	if (IS_ERR(chan->vq)) {
	419	err = PTR_ERR(chan->vq);
	420	goto out_free_vq;
b530cc79	421	}
e2735b77 EVH	422	chan->vq->vdev->priv = chan;
e2735b77 EVH	423	spin_lock_init(&chan->lock);
b530cc79	424
e2735b77	425	sg_init_table(chan->sg, VIRTQUEUE_NUM);
b530cc79	426
b530cc79	427	chan->inuse = false;
97ee9b02 AK	428	if (virtio_has_feature(vdev, VIRTIO_9P_MOUNT_TAG)) {
	429	vdev->config->get(vdev,
	430	offsetof(struct virtio_9p_config, tag_len),
	431	&tag_len, sizeof(tag_len));
	432	} else {
	433	err = -EINVAL;
	434	goto out_free_vq;
	435	}
	436	tag = kmalloc(tag_len, GFP_KERNEL);
	437	if (!tag) {
	438	err = -ENOMEM;
	439	goto out_free_vq;
	440	}
	441	vdev->config->get(vdev, offsetof(struct virtio_9p_config, tag),
	442	tag, tag_len);
	443	chan->tag = tag;
	444	chan->tag_len = tag_len;
86c84373 AK	445	err = sysfs_create_file(&(vdev->dev.kobj), &dev_attr_mount_tag.attr);
86c84373 AK	446	if (err) {
52f44e0d	447	goto out_free_tag;
86c84373	448	}
52f44e0d VJJ	449	chan->vc_wq = kmalloc(sizeof(wait_queue_head_t), GFP_KERNEL);
	450	if (!chan->vc_wq) {
	451	err = -ENOMEM;
	452	goto out_free_tag;
	453	}
	454	init_waitqueue_head(chan->vc_wq);
	455	chan->ring_bufs_avail = 1;
	456
37c1209d AK	457	mutex_lock(&virtio_9p_lock);
	458	list_add_tail(&chan->chan_list, &virtio_chan_list);
	459	mutex_unlock(&virtio_9p_lock);
b530cc79 EVH	460	return 0;
b530cc79 EVH	461
52f44e0d VJJ	462	out_free_tag:
52f44e0d VJJ	463	kfree(tag);
e2735b77	464	out_free_vq:
d2a7ddda	465	vdev->config->del_vqs(vdev);
37c1209d	466	kfree(chan);
b530cc79	467	fail:
b530cc79 EVH	468	return err;
	469	}
	470
ee443996 EVH	471
	472	/**
	473	* p9_virtio_create - allocate a new virtio channel
8b81ef58	474	* @client: client instance invoking this transport
ee443996 EVH	475	* @devname: string identifying the channel to connect to (unused)
ee443996 EVH	476	* @args: args passed from sys_mount() for per-transport options (unused)
ee443996 EVH	477	*
ee443996 EVH	478	* This sets up a transport channel for 9p communication. Right now
b530cc79 EVH	479	* we only match the first available channel, but eventually we couldlook up
	480	* alternate channels by matching devname versus a virtio_config entry.
	481	* We use a simple reference count mechanism to ensure that only a single
ee443996 EVH	482	* mount has a channel open at a time.
ee443996 EVH	483	*
ee443996 EVH	484	*/
ee443996 EVH	485
8b81ef58 EVH	486	static int
8b81ef58 EVH	487	p9_virtio_create(struct p9_client client, const char devname, char *args)
b530cc79	488	{
37c1209d	489	struct virtio_chan *chan;
c1a7c226	490	int ret = -ENOENT;
37c1209d	491	int found = 0;
b530cc79	492
c1549497	493	mutex_lock(&virtio_9p_lock);
37c1209d	494	list_for_each_entry(chan, &virtio_chan_list, chan_list) {
0b20406c SE	495	if (!strncmp(devname, chan->tag, chan->tag_len) &&
0b20406c SE	496	strlen(devname) == chan->tag_len) {
f75580c4 AK	497	if (!chan->inuse) {
f75580c4 AK	498	chan->inuse = true;
37c1209d	499	found = 1;
f75580c4 AK	500	break;
f75580c4 AK	501	}
c1a7c226	502	ret = -EBUSY;
b530cc79 EVH	503	}
b530cc79 EVH	504	}
c1549497	505	mutex_unlock(&virtio_9p_lock);
b530cc79	506
37c1209d	507	if (!found) {
e2735b77	508	printk(KERN_ERR "9p: no channels available\n");
c1a7c226	509	return ret;
e2735b77 EVH	510	}
e2735b77 EVH	511
8b81ef58	512	client->trans = (void *)chan;
562ada61	513	client->status = Connected;
fea511a6	514	chan->client = client;
b530cc79	515
8b81ef58	516	return 0;
b530cc79 EVH	517	}
b530cc79 EVH	518
ee443996 EVH	519	/**
	520	* p9_virtio_remove - clean up resources associated with a virtio device
	521	* @vdev: virtio device to remove
	522	*
	523	*/
	524
f3933545 EVH	525	static void p9_virtio_remove(struct virtio_device *vdev)
	526	{
	527	struct virtio_chan *chan = vdev->priv;
	528
	529	BUG_ON(chan->inuse);
37c1209d AK	530	vdev->config->del_vqs(vdev);
	531
	532	mutex_lock(&virtio_9p_lock);
	533	list_del(&chan->chan_list);
	534	mutex_unlock(&virtio_9p_lock);
86c84373	535	sysfs_remove_file(&(vdev->dev.kobj), &dev_attr_mount_tag.attr);
97ee9b02	536	kfree(chan->tag);
52f44e0d	537	kfree(chan->vc_wq);
37c1209d	538	kfree(chan);
f3933545	539
f3933545 EVH	540	}
f3933545 EVH	541
b530cc79 EVH	542	static struct virtio_device_id id_table[] = {
	543	{ VIRTIO_ID_9P, VIRTIO_DEV_ANY_ID },
	544	{ 0 },
	545	};
	546
97ee9b02 AK	547	static unsigned int features[] = {
	548	VIRTIO_9P_MOUNT_TAG,
	549	};
	550
b530cc79 EVH	551	/* The standard "struct lguest_driver": */
b530cc79 EVH	552	static struct virtio_driver p9_virtio_drv = {
97ee9b02 AK	553	.feature_table = features,
	554	.feature_table_size = ARRAY_SIZE(features),
	555	.driver.name = KBUILD_MODNAME,
	556	.driver.owner = THIS_MODULE,
	557	.id_table = id_table,
	558	.probe = p9_virtio_probe,
	559	.remove = p9_virtio_remove,
b530cc79 EVH	560	};
	561
	562	static struct p9_trans_module p9_virtio_trans = {
	563	.name = "virtio",
	564	.create = p9_virtio_create,
8b81ef58	565	.close = p9_virtio_close,
91b8534f EVH	566	.request = p9_virtio_request,
91b8534f EVH	567	.cancel = p9_virtio_cancel,
e2735b77	568	.maxsize = PAGE_SIZE*16,
6f69c395	569	.pref = P9_TRANS_PREF_PAYLOAD_SEP,
b530cc79	570	.def = 0,
72029fe8	571	.owner = THIS_MODULE,
b530cc79 EVH	572	};
	573
	574	/* The standard init function */
	575	static int __init p9_virtio_init(void)
	576	{
37c1209d	577	INIT_LIST_HEAD(&virtio_chan_list);
b530cc79 EVH	578
	579	v9fs_register_trans(&p9_virtio_trans);
	580	return register_virtio_driver(&p9_virtio_drv);
	581	}
	582
f3933545 EVH	583	static void __exit p9_virtio_cleanup(void)
	584	{
	585	unregister_virtio_driver(&p9_virtio_drv);
72029fe8	586	v9fs_unregister_trans(&p9_virtio_trans);
f3933545 EVH	587	}
f3933545 EVH	588
b530cc79	589	module_init(p9_virtio_init);
f3933545	590	module_exit(p9_virtio_cleanup);
b530cc79 EVH	591
	592	MODULE_DEVICE_TABLE(virtio, id_table);
	593	MODULE_AUTHOR("Eric Van Hensbergen <[email protected]>");
	594	MODULE_DESCRIPTION("Virtio 9p Transport");
	595	MODULE_LICENSE("GPL");