net/9p: Use the tag name in the config space for identifying mount point
[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 /**
224  * p9_virtio_probe - probe for existence of 9P virtio channels
225  * @vdev: virtio device to probe
226  *
227  * This probes for existing virtio channels.
228  *
229  */
230
231 static int p9_virtio_probe(struct virtio_device *vdev)
232 {
233         __u16 tag_len;
234         char *tag;
235         int err;
236         struct virtio_chan *chan;
237
238         chan = kmalloc(sizeof(struct virtio_chan), GFP_KERNEL);
239         if (!chan) {
240                 printk(KERN_ERR "9p: Failed to allocate virtio 9P channel\n");
241                 err = -ENOMEM;
242                 goto fail;
243         }
244
245         chan->vdev = vdev;
246
247         /* We expect one virtqueue, for requests. */
248         chan->vq = virtio_find_single_vq(vdev, req_done, "requests");
249         if (IS_ERR(chan->vq)) {
250                 err = PTR_ERR(chan->vq);
251                 goto out_free_vq;
252         }
253         chan->vq->vdev->priv = chan;
254         spin_lock_init(&chan->lock);
255
256         sg_init_table(chan->sg, VIRTQUEUE_NUM);
257
258         chan->inuse = false;
259         if (virtio_has_feature(vdev, VIRTIO_9P_MOUNT_TAG)) {
260                 vdev->config->get(vdev,
261                                 offsetof(struct virtio_9p_config, tag_len),
262                                 &tag_len, sizeof(tag_len));
263         } else {
264                 err = -EINVAL;
265                 goto out_free_vq;
266         }
267         tag = kmalloc(tag_len, GFP_KERNEL);
268         if (!tag) {
269                 err = -ENOMEM;
270                 goto out_free_vq;
271         }
272         vdev->config->get(vdev, offsetof(struct virtio_9p_config, tag),
273                         tag, tag_len);
274         chan->tag = tag;
275         chan->tag_len = tag_len;
276         mutex_lock(&virtio_9p_lock);
277         list_add_tail(&chan->chan_list, &virtio_chan_list);
278         mutex_unlock(&virtio_9p_lock);
279         return 0;
280
281 out_free_vq:
282         vdev->config->del_vqs(vdev);
283         kfree(chan);
284 fail:
285         return err;
286 }
287
288
289 /**
290  * p9_virtio_create - allocate a new virtio channel
291  * @client: client instance invoking this transport
292  * @devname: string identifying the channel to connect to (unused)
293  * @args: args passed from sys_mount() for per-transport options (unused)
294  *
295  * This sets up a transport channel for 9p communication.  Right now
296  * we only match the first available channel, but eventually we couldlook up
297  * alternate channels by matching devname versus a virtio_config entry.
298  * We use a simple reference count mechanism to ensure that only a single
299  * mount has a channel open at a time.
300  *
301  */
302
303 static int
304 p9_virtio_create(struct p9_client *client, const char *devname, char *args)
305 {
306         struct virtio_chan *chan;
307         int ret = -ENOENT;
308         int found = 0;
309
310         mutex_lock(&virtio_9p_lock);
311         list_for_each_entry(chan, &virtio_chan_list, chan_list) {
312                 if (!strncmp(devname, chan->tag, chan->tag_len)) {
313                         if (!chan->inuse) {
314                                 chan->inuse = true;
315                                 found = 1;
316                                 break;
317                         }
318                         ret = -EBUSY;
319                 }
320         }
321         mutex_unlock(&virtio_9p_lock);
322
323         if (!found) {
324                 printk(KERN_ERR "9p: no channels available\n");
325                 return ret;
326         }
327
328         client->trans = (void *)chan;
329         client->status = Connected;
330         chan->client = client;
331
332         return 0;
333 }
334
335 /**
336  * p9_virtio_remove - clean up resources associated with a virtio device
337  * @vdev: virtio device to remove
338  *
339  */
340
341 static void p9_virtio_remove(struct virtio_device *vdev)
342 {
343         struct virtio_chan *chan = vdev->priv;
344
345         BUG_ON(chan->inuse);
346         vdev->config->del_vqs(vdev);
347
348         mutex_lock(&virtio_9p_lock);
349         list_del(&chan->chan_list);
350         mutex_unlock(&virtio_9p_lock);
351         kfree(chan->tag);
352         kfree(chan);
353
354 }
355
356 static struct virtio_device_id id_table[] = {
357         { VIRTIO_ID_9P, VIRTIO_DEV_ANY_ID },
358         { 0 },
359 };
360
361 static unsigned int features[] = {
362         VIRTIO_9P_MOUNT_TAG,
363 };
364
365 /* The standard "struct lguest_driver": */
366 static struct virtio_driver p9_virtio_drv = {
367         .feature_table  = features,
368         .feature_table_size = ARRAY_SIZE(features),
369         .driver.name    = KBUILD_MODNAME,
370         .driver.owner   = THIS_MODULE,
371         .id_table       = id_table,
372         .probe          = p9_virtio_probe,
373         .remove         = p9_virtio_remove,
374 };
375
376 static struct p9_trans_module p9_virtio_trans = {
377         .name = "virtio",
378         .create = p9_virtio_create,
379         .close = p9_virtio_close,
380         .request = p9_virtio_request,
381         .cancel = p9_virtio_cancel,
382         .maxsize = PAGE_SIZE*16,
383         .def = 0,
384         .owner = THIS_MODULE,
385 };
386
387 /* The standard init function */
388 static int __init p9_virtio_init(void)
389 {
390         INIT_LIST_HEAD(&virtio_chan_list);
391
392         v9fs_register_trans(&p9_virtio_trans);
393         return register_virtio_driver(&p9_virtio_drv);
394 }
395
396 static void __exit p9_virtio_cleanup(void)
397 {
398         unregister_virtio_driver(&p9_virtio_drv);
399         v9fs_unregister_trans(&p9_virtio_trans);
400 }
401
402 module_init(p9_virtio_init);
403 module_exit(p9_virtio_cleanup);
404
405 MODULE_DEVICE_TABLE(virtio, id_table);
406 MODULE_AUTHOR("Eric Van Hensbergen <ericvh@gmail.com>");
407 MODULE_DESCRIPTION("Virtio 9p Transport");
408 MODULE_LICENSE("GPL");