2 * The Virtio 9p transport driver
4 * This is a block based transport driver based on the lguest block driver
7 * Copyright (C) 2007, 2008 Eric Van Hensbergen, IBM Corporation
9 * Based on virtio console driver
10 * Copyright (C) 2006, 2007 Rusty Russell, IBM Corporation
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.
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.
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
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>
36 #include <linux/uaccess.h>
37 #include <linux/inet.h>
38 #include <linux/idr.h>
39 #include <linux/file.h>
40 #include <linux/slab.h>
41 #include <net/9p/9p.h>
42 #include <linux/parser.h>
43 #include <net/9p/client.h>
44 #include <net/9p/transport.h>
45 #include <linux/scatterlist.h>
46 #include <linux/virtio.h>
47 #include <linux/virtio_9p.h>
48 #include "trans_common.h"
50 #define VIRTQUEUE_NUM 128
52 /* a single mutex to manage channel initialization and attachment */
53 static DEFINE_MUTEX(virtio_9p_lock);
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
60 * @client: client instance
61 * @vdev: virtio dev associated with this channel
62 * @vq: virtio queue associated with this channel
63 * @sg: scatter gather list which is used to pack a request (protected?)
65 * We keep all per-channel information in a structure.
66 * This structure is allocated within the devices dev->mem space.
67 * A pointer to the structure will get put in the transport private.
76 struct p9_client *client;
77 struct virtio_device *vdev;
80 wait_queue_head_t *vc_wq;
82 /* Scatterlist: can be too big for stack. */
83 struct scatterlist sg[VIRTQUEUE_NUM];
87 * tag name to identify a mount Non-null terminated
91 struct list_head chan_list;
94 static struct list_head virtio_chan_list;
96 /* How many bytes left in this page. */
97 static unsigned int rest_of_page(void *data)
99 return PAGE_SIZE - ((unsigned long)data % PAGE_SIZE);
103 * p9_virtio_close - reclaim resources of a channel
104 * @client: client instance
106 * This reclaims a channel by freeing its resources and
107 * reseting its inuse flag.
111 static void p9_virtio_close(struct p9_client *client)
113 struct virtio_chan *chan = client->trans;
115 mutex_lock(&virtio_9p_lock);
118 mutex_unlock(&virtio_9p_lock);
122 * req_done - callback which signals activity from the server
123 * @vq: virtio queue activity was received on
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
130 * Bugs: could do with some additional sanity checking, but appears to work.
134 static void req_done(struct virtqueue *vq)
136 struct virtio_chan *chan = vq->vdev->priv;
139 struct p9_req_t *req;
142 P9_DPRINTK(P9_DEBUG_TRANS, ": request done\n");
145 spin_lock_irqsave(&chan->lock, flags);
146 rc = virtqueue_get_buf(chan->vq, &len);
149 spin_unlock_irqrestore(&chan->lock, flags);
153 chan->ring_bufs_avail = 1;
154 spin_unlock_irqrestore(&chan->lock, flags);
155 /* Wakeup if anyone waiting for VirtIO ring space. */
156 wake_up(chan->vc_wq);
157 P9_DPRINTK(P9_DEBUG_TRANS, ": rc %p\n", rc);
158 P9_DPRINTK(P9_DEBUG_TRANS, ": lookup tag %d\n", rc->tag);
159 req = p9_tag_lookup(chan->client, rc->tag);
160 if (req->tc->private) {
161 struct trans_rpage_info *rp = req->tc->private;
163 p9_release_req_pages(rp);
166 req->tc->private = NULL;
168 req->status = REQ_STATUS_RCVD;
169 p9_client_cb(chan->client, req);
174 * pack_sg_list - pack a scatter gather list from a linear buffer
175 * @sg: scatter/gather list to pack into
176 * @start: which segment of the sg_list to start at
177 * @limit: maximum segment to pack data to
178 * @data: data to pack into scatter/gather list
179 * @count: amount of data to pack into the scatter/gather list
181 * sg_lists have multiple segments of various sizes. This will pack
182 * arbitrary data into an existing scatter gather list, segmenting the
183 * data as necessary within constraints.
188 pack_sg_list(struct scatterlist *sg, int start, int limit, char *data,
195 s = rest_of_page(data);
198 sg_set_buf(&sg[index++], data, s);
201 BUG_ON(index > limit);
207 /* We don't currently allow canceling of virtio requests */
208 static int p9_virtio_cancel(struct p9_client *client, struct p9_req_t *req)
214 * pack_sg_list_p - Just like pack_sg_list. Instead of taking a buffer,
215 * this takes a list of pages.
216 * @sg: scatter/gather list to pack into
217 * @start: which segment of the sg_list to start at
218 * @pdata_off: Offset into the first page
219 * @**pdata: a list of pages to add into sg.
220 * @count: amount of data to pack into the scatter/gather list
223 pack_sg_list_p(struct scatterlist *sg, int start, int limit, size_t pdata_off,
224 struct page **pdata, int count)
231 s = min((int)(PAGE_SIZE - pdata_off), count);
232 sg_set_page(&sg[index++], pdata[i++], s, pdata_off);
237 BUG_ON(index > limit);
238 s = min((int)PAGE_SIZE, count);
239 sg_set_page(&sg[index++], pdata[i++], s, 0);
246 * p9_virtio_request - issue a request
247 * @client: client instance issuing the request
248 * @req: request to be issued
253 p9_virtio_request(struct p9_client *client, struct p9_req_t *req)
255 int in, out, inp, outp;
256 struct virtio_chan *chan = client->trans;
257 char *rdata = (char *)req->rc+sizeof(struct p9_fcall);
259 size_t pdata_off = 0;
260 struct trans_rpage_info *rpinfo = NULL;
261 int err, pdata_len = 0;
263 P9_DPRINTK(P9_DEBUG_TRANS, "9p debug: virtio request\n");
265 req->status = REQ_STATUS_SENT;
267 if (req->tc->pbuf_size && (req->tc->pubuf && P9_IS_USER_CONTEXT)) {
268 int nr_pages = p9_nr_pages(req);
269 int rpinfo_size = sizeof(struct trans_rpage_info) +
270 sizeof(struct page *) * nr_pages;
272 if (rpinfo_size <= (req->tc->capacity - req->tc->size)) {
273 /* We can use sdata */
274 req->tc->private = req->tc->sdata + req->tc->size;
275 rpinfo = (struct trans_rpage_info *)req->tc->private;
276 rpinfo->rp_alloc = 0;
278 req->tc->private = kmalloc(rpinfo_size, GFP_NOFS);
279 if (!req->tc->private) {
280 P9_DPRINTK(P9_DEBUG_TRANS, "9p debug: "
281 "private kmalloc returned NULL");
284 rpinfo = (struct trans_rpage_info *)req->tc->private;
285 rpinfo->rp_alloc = 1;
288 err = p9_payload_gup(req, &pdata_off, &pdata_len, nr_pages,
289 req->tc->id == P9_TREAD ? 1 : 0);
291 if (rpinfo->rp_alloc)
298 spin_lock_irqsave(&chan->lock, flags);
300 /* Handle out VirtIO ring buffers */
301 out = pack_sg_list(chan->sg, 0, VIRTQUEUE_NUM, req->tc->sdata,
304 if (req->tc->pbuf_size && (req->tc->id == P9_TWRITE)) {
305 /* We have additional write payload buffer to take care */
306 if (req->tc->pubuf && P9_IS_USER_CONTEXT) {
307 outp = pack_sg_list_p(chan->sg, out, VIRTQUEUE_NUM,
308 pdata_off, rpinfo->rp_data, pdata_len);
310 char *pbuf = req->tc->pubuf ? req->tc->pubuf :
312 outp = pack_sg_list(chan->sg, out, VIRTQUEUE_NUM, pbuf,
318 /* Handle in VirtIO ring buffers */
319 if (req->tc->pbuf_size &&
320 ((req->tc->id == P9_TREAD) || (req->tc->id == P9_TREADDIR))) {
322 * Take care of additional Read payload.
323 * 11 is the read/write header = PDU Header(7) + IO Size (4).
324 * Arrange in such a way that server places header in the
325 * alloced memory and payload onto the user buffer.
327 inp = pack_sg_list(chan->sg, out, VIRTQUEUE_NUM, rdata, 11);
329 * Running executables in the filesystem may result in
330 * a read request with kernel buffer as opposed to user buffer.
332 if (req->tc->pubuf && P9_IS_USER_CONTEXT) {
333 in = pack_sg_list_p(chan->sg, out+inp, VIRTQUEUE_NUM,
334 pdata_off, rpinfo->rp_data, pdata_len);
336 char *pbuf = req->tc->pubuf ? req->tc->pubuf :
338 in = pack_sg_list(chan->sg, out+inp, VIRTQUEUE_NUM,
339 pbuf, req->tc->pbuf_size);
343 in = pack_sg_list(chan->sg, out, VIRTQUEUE_NUM, rdata,
347 err = virtqueue_add_buf(chan->vq, chan->sg, out, in, req->tc);
349 if (err == -ENOSPC) {
350 chan->ring_bufs_avail = 0;
351 spin_unlock_irqrestore(&chan->lock, flags);
352 err = wait_event_interruptible(*chan->vc_wq,
353 chan->ring_bufs_avail);
354 if (err == -ERESTARTSYS)
357 P9_DPRINTK(P9_DEBUG_TRANS, "9p:Retry virtio request\n");
358 goto req_retry_pinned;
360 spin_unlock_irqrestore(&chan->lock, flags);
361 P9_DPRINTK(P9_DEBUG_TRANS,
363 "virtio rpc add_buf returned failure");
364 if (rpinfo && rpinfo->rp_alloc)
370 virtqueue_kick(chan->vq);
371 spin_unlock_irqrestore(&chan->lock, flags);
373 P9_DPRINTK(P9_DEBUG_TRANS, "9p debug: virtio request kicked\n");
377 static ssize_t p9_mount_tag_show(struct device *dev,
378 struct device_attribute *attr, char *buf)
380 struct virtio_chan *chan;
381 struct virtio_device *vdev;
383 vdev = dev_to_virtio(dev);
386 return snprintf(buf, chan->tag_len + 1, "%s", chan->tag);
389 static DEVICE_ATTR(mount_tag, 0444, p9_mount_tag_show, NULL);
392 * p9_virtio_probe - probe for existence of 9P virtio channels
393 * @vdev: virtio device to probe
395 * This probes for existing virtio channels.
399 static int p9_virtio_probe(struct virtio_device *vdev)
404 struct virtio_chan *chan;
406 chan = kmalloc(sizeof(struct virtio_chan), GFP_KERNEL);
408 printk(KERN_ERR "9p: Failed to allocate virtio 9P channel\n");
415 /* We expect one virtqueue, for requests. */
416 chan->vq = virtio_find_single_vq(vdev, req_done, "requests");
417 if (IS_ERR(chan->vq)) {
418 err = PTR_ERR(chan->vq);
421 chan->vq->vdev->priv = chan;
422 spin_lock_init(&chan->lock);
424 sg_init_table(chan->sg, VIRTQUEUE_NUM);
427 if (virtio_has_feature(vdev, VIRTIO_9P_MOUNT_TAG)) {
428 vdev->config->get(vdev,
429 offsetof(struct virtio_9p_config, tag_len),
430 &tag_len, sizeof(tag_len));
435 tag = kmalloc(tag_len, GFP_KERNEL);
440 vdev->config->get(vdev, offsetof(struct virtio_9p_config, tag),
443 chan->tag_len = tag_len;
444 err = sysfs_create_file(&(vdev->dev.kobj), &dev_attr_mount_tag.attr);
448 chan->vc_wq = kmalloc(sizeof(wait_queue_head_t), GFP_KERNEL);
453 init_waitqueue_head(chan->vc_wq);
454 chan->ring_bufs_avail = 1;
456 mutex_lock(&virtio_9p_lock);
457 list_add_tail(&chan->chan_list, &virtio_chan_list);
458 mutex_unlock(&virtio_9p_lock);
464 vdev->config->del_vqs(vdev);
472 * p9_virtio_create - allocate a new virtio channel
473 * @client: client instance invoking this transport
474 * @devname: string identifying the channel to connect to (unused)
475 * @args: args passed from sys_mount() for per-transport options (unused)
477 * This sets up a transport channel for 9p communication. Right now
478 * we only match the first available channel, but eventually we couldlook up
479 * alternate channels by matching devname versus a virtio_config entry.
480 * We use a simple reference count mechanism to ensure that only a single
481 * mount has a channel open at a time.
486 p9_virtio_create(struct p9_client *client, const char *devname, char *args)
488 struct virtio_chan *chan;
492 mutex_lock(&virtio_9p_lock);
493 list_for_each_entry(chan, &virtio_chan_list, chan_list) {
494 if (!strncmp(devname, chan->tag, chan->tag_len) &&
495 strlen(devname) == chan->tag_len) {
504 mutex_unlock(&virtio_9p_lock);
507 printk(KERN_ERR "9p: no channels available\n");
511 client->trans = (void *)chan;
512 client->status = Connected;
513 chan->client = client;
519 * p9_virtio_remove - clean up resources associated with a virtio device
520 * @vdev: virtio device to remove
524 static void p9_virtio_remove(struct virtio_device *vdev)
526 struct virtio_chan *chan = vdev->priv;
529 vdev->config->del_vqs(vdev);
531 mutex_lock(&virtio_9p_lock);
532 list_del(&chan->chan_list);
533 mutex_unlock(&virtio_9p_lock);
534 sysfs_remove_file(&(vdev->dev.kobj), &dev_attr_mount_tag.attr);
541 static struct virtio_device_id id_table[] = {
542 { VIRTIO_ID_9P, VIRTIO_DEV_ANY_ID },
546 static unsigned int features[] = {
550 /* The standard "struct lguest_driver": */
551 static struct virtio_driver p9_virtio_drv = {
552 .feature_table = features,
553 .feature_table_size = ARRAY_SIZE(features),
554 .driver.name = KBUILD_MODNAME,
555 .driver.owner = THIS_MODULE,
556 .id_table = id_table,
557 .probe = p9_virtio_probe,
558 .remove = p9_virtio_remove,
561 static struct p9_trans_module p9_virtio_trans = {
563 .create = p9_virtio_create,
564 .close = p9_virtio_close,
565 .request = p9_virtio_request,
566 .cancel = p9_virtio_cancel,
567 .maxsize = PAGE_SIZE*16,
568 .pref = P9_TRANS_PREF_PAYLOAD_SEP,
570 .owner = THIS_MODULE,
573 /* The standard init function */
574 static int __init p9_virtio_init(void)
576 INIT_LIST_HEAD(&virtio_chan_list);
578 v9fs_register_trans(&p9_virtio_trans);
579 return register_virtio_driver(&p9_virtio_drv);
582 static void __exit p9_virtio_cleanup(void)
584 unregister_virtio_driver(&p9_virtio_drv);
585 v9fs_unregister_trans(&p9_virtio_trans);
588 module_init(p9_virtio_init);
589 module_exit(p9_virtio_cleanup);
591 MODULE_DEVICE_TABLE(virtio, id_table);
592 MODULE_AUTHOR("Eric Van Hensbergen <ericvh@gmail.com>");
593 MODULE_DESCRIPTION("Virtio 9p Transport");
594 MODULE_LICENSE("GPL");