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