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>
49 #define VIRTQUEUE_NUM 128
51 /* a single mutex to manage channel initialization and attachment */
52 static DEFINE_MUTEX(virtio_9p_lock);
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
59 * @client: client instance
60 * @vdev: virtio dev associated with this channel
61 * @vq: virtio queue associated with this channel
62 * @sg: scatter gather list which is used to pack a request (protected?)
64 * We keep all per-channel information in a structure.
65 * This structure is allocated within the devices dev->mem space.
66 * A pointer to the structure will get put in the transport private.
75 struct p9_client *client;
76 struct virtio_device *vdev;
79 /* Scatterlist: can be too big for stack. */
80 struct scatterlist sg[VIRTQUEUE_NUM];
84 * tag name to identify a mount Non-null terminated
88 struct list_head chan_list;
91 static struct list_head virtio_chan_list;
93 /* How many bytes left in this page. */
94 static unsigned int rest_of_page(void *data)
96 return PAGE_SIZE - ((unsigned long)data % PAGE_SIZE);
100 * p9_virtio_close - reclaim resources of a channel
101 * @client: client instance
103 * This reclaims a channel by freeing its resources and
104 * reseting its inuse flag.
108 static void p9_virtio_close(struct p9_client *client)
110 struct virtio_chan *chan = client->trans;
112 mutex_lock(&virtio_9p_lock);
115 mutex_unlock(&virtio_9p_lock);
119 * req_done - callback which signals activity from the server
120 * @vq: virtio queue activity was received on
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
127 * Bugs: could do with some additional sanity checking, but appears to work.
131 static void req_done(struct virtqueue *vq)
133 struct virtio_chan *chan = vq->vdev->priv;
136 struct p9_req_t *req;
139 P9_DPRINTK(P9_DEBUG_TRANS, ": request done\n");
142 spin_lock_irqsave(&chan->lock, flags);
143 rc = virtqueue_get_buf(chan->vq, &len);
144 spin_unlock_irqrestore(&chan->lock, flags);
147 P9_DPRINTK(P9_DEBUG_TRANS, ": rc %p\n", rc);
148 P9_DPRINTK(P9_DEBUG_TRANS, ": lookup tag %d\n",
150 req = p9_tag_lookup(chan->client, rc->tag);
151 req->status = REQ_STATUS_RCVD;
152 p9_client_cb(chan->client, req);
154 } while (rc != NULL);
158 * pack_sg_list - pack a scatter gather list from a linear buffer
159 * @sg: scatter/gather list to pack into
160 * @start: which segment of the sg_list to start at
161 * @limit: maximum segment to pack data to
162 * @data: data to pack into scatter/gather list
163 * @count: amount of data to pack into the scatter/gather list
165 * sg_lists have multiple segments of various sizes. This will pack
166 * arbitrary data into an existing scatter gather list, segmenting the
167 * data as necessary within constraints.
172 pack_sg_list(struct scatterlist *sg, int start, int limit, char *data,
179 s = rest_of_page(data);
182 sg_set_buf(&sg[index++], data, s);
185 BUG_ON(index > limit);
191 /* We don't currently allow canceling of virtio requests */
192 static int p9_virtio_cancel(struct p9_client *client, struct p9_req_t *req)
198 * p9_virtio_request - issue a request
199 * @client: client instance issuing the request
200 * @req: request to be issued
205 p9_virtio_request(struct p9_client *client, struct p9_req_t *req)
208 struct virtio_chan *chan = client->trans;
209 char *rdata = (char *)req->rc+sizeof(struct p9_fcall);
213 P9_DPRINTK(P9_DEBUG_TRANS, "9p debug: virtio request\n");
215 req->status = REQ_STATUS_SENT;
217 spin_lock_irqsave(&chan->lock, flags);
218 out = pack_sg_list(chan->sg, 0, VIRTQUEUE_NUM, req->tc->sdata,
220 in = pack_sg_list(chan->sg, out, VIRTQUEUE_NUM-out, rdata,
223 err = virtqueue_add_buf(chan->vq, chan->sg, out, in, req->tc);
225 spin_unlock_irqrestore(&chan->lock, flags);
226 P9_DPRINTK(P9_DEBUG_TRANS,
227 "9p debug: virtio rpc add_buf returned failure");
231 virtqueue_kick(chan->vq);
232 spin_unlock_irqrestore(&chan->lock, flags);
234 P9_DPRINTK(P9_DEBUG_TRANS, "9p debug: virtio request kicked\n");
238 static ssize_t p9_mount_tag_show(struct device *dev,
239 struct device_attribute *attr, char *buf)
241 struct virtio_chan *chan;
242 struct virtio_device *vdev;
244 vdev = dev_to_virtio(dev);
247 return snprintf(buf, chan->tag_len + 1, "%s", chan->tag);
250 static DEVICE_ATTR(mount_tag, 0444, p9_mount_tag_show, NULL);
253 * p9_virtio_probe - probe for existence of 9P virtio channels
254 * @vdev: virtio device to probe
256 * This probes for existing virtio channels.
260 static int p9_virtio_probe(struct virtio_device *vdev)
265 struct virtio_chan *chan;
267 chan = kmalloc(sizeof(struct virtio_chan), GFP_KERNEL);
269 printk(KERN_ERR "9p: Failed to allocate virtio 9P channel\n");
276 /* We expect one virtqueue, for requests. */
277 chan->vq = virtio_find_single_vq(vdev, req_done, "requests");
278 if (IS_ERR(chan->vq)) {
279 err = PTR_ERR(chan->vq);
282 chan->vq->vdev->priv = chan;
283 spin_lock_init(&chan->lock);
285 sg_init_table(chan->sg, VIRTQUEUE_NUM);
288 if (virtio_has_feature(vdev, VIRTIO_9P_MOUNT_TAG)) {
289 vdev->config->get(vdev,
290 offsetof(struct virtio_9p_config, tag_len),
291 &tag_len, sizeof(tag_len));
296 tag = kmalloc(tag_len, GFP_KERNEL);
301 vdev->config->get(vdev, offsetof(struct virtio_9p_config, tag),
304 chan->tag_len = tag_len;
305 err = sysfs_create_file(&(vdev->dev.kobj), &dev_attr_mount_tag.attr);
310 mutex_lock(&virtio_9p_lock);
311 list_add_tail(&chan->chan_list, &virtio_chan_list);
312 mutex_unlock(&virtio_9p_lock);
316 vdev->config->del_vqs(vdev);
324 * p9_virtio_create - allocate a new virtio channel
325 * @client: client instance invoking this transport
326 * @devname: string identifying the channel to connect to (unused)
327 * @args: args passed from sys_mount() for per-transport options (unused)
329 * This sets up a transport channel for 9p communication. Right now
330 * we only match the first available channel, but eventually we couldlook up
331 * alternate channels by matching devname versus a virtio_config entry.
332 * We use a simple reference count mechanism to ensure that only a single
333 * mount has a channel open at a time.
338 p9_virtio_create(struct p9_client *client, const char *devname, char *args)
340 struct virtio_chan *chan;
344 mutex_lock(&virtio_9p_lock);
345 list_for_each_entry(chan, &virtio_chan_list, chan_list) {
346 if (!strncmp(devname, chan->tag, chan->tag_len) &&
347 strlen(devname) == chan->tag_len) {
356 mutex_unlock(&virtio_9p_lock);
359 printk(KERN_ERR "9p: no channels available\n");
363 client->trans = (void *)chan;
364 client->status = Connected;
365 chan->client = client;
371 * p9_virtio_remove - clean up resources associated with a virtio device
372 * @vdev: virtio device to remove
376 static void p9_virtio_remove(struct virtio_device *vdev)
378 struct virtio_chan *chan = vdev->priv;
381 vdev->config->del_vqs(vdev);
383 mutex_lock(&virtio_9p_lock);
384 list_del(&chan->chan_list);
385 mutex_unlock(&virtio_9p_lock);
386 sysfs_remove_file(&(vdev->dev.kobj), &dev_attr_mount_tag.attr);
392 static struct virtio_device_id id_table[] = {
393 { VIRTIO_ID_9P, VIRTIO_DEV_ANY_ID },
397 static unsigned int features[] = {
401 /* The standard "struct lguest_driver": */
402 static struct virtio_driver p9_virtio_drv = {
403 .feature_table = features,
404 .feature_table_size = ARRAY_SIZE(features),
405 .driver.name = KBUILD_MODNAME,
406 .driver.owner = THIS_MODULE,
407 .id_table = id_table,
408 .probe = p9_virtio_probe,
409 .remove = p9_virtio_remove,
412 static struct p9_trans_module p9_virtio_trans = {
414 .create = p9_virtio_create,
415 .close = p9_virtio_close,
416 .request = p9_virtio_request,
417 .cancel = p9_virtio_cancel,
418 .maxsize = PAGE_SIZE*16,
420 .owner = THIS_MODULE,
423 /* The standard init function */
424 static int __init p9_virtio_init(void)
426 INIT_LIST_HEAD(&virtio_chan_list);
428 v9fs_register_trans(&p9_virtio_trans);
429 return register_virtio_driver(&p9_virtio_drv);
432 static void __exit p9_virtio_cleanup(void)
434 unregister_virtio_driver(&p9_virtio_drv);
435 v9fs_unregister_trans(&p9_virtio_trans);
438 module_init(p9_virtio_init);
439 module_exit(p9_virtio_cleanup);
441 MODULE_DEVICE_TABLE(virtio, id_table);
442 MODULE_AUTHOR("Eric Van Hensbergen <ericvh@gmail.com>");
443 MODULE_DESCRIPTION("Virtio 9p Transport");
444 MODULE_LICENSE("GPL");