9p: make rpc code common and rework flush code
[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 /* global which tracks highest initialized channel */
53 static int chan_index;
54
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
60  * @vdev: virtio dev associated with this channel
61  * @vq: virtio queue associated with this channel
62  * @tagpool: accounting for tag ids (and request slots)
63  * @reqs: array of request slots
64  * @max_tag: current number of request_slots allocated
65  * @sg: scatter gather list which is used to pack a request (protected?)
66  *
67  * We keep all per-channel information in a structure.
68  * This structure is allocated within the devices dev->mem space.
69  * A pointer to the structure will get put in the transport private.
70  *
71  */
72
73 static struct virtio_chan {
74         bool initialized;
75         bool inuse;
76
77         spinlock_t lock;
78
79         struct p9_client *client;
80         struct virtio_device *vdev;
81         struct virtqueue *vq;
82
83         /* Scatterlist: can be too big for stack. */
84         struct scatterlist sg[VIRTQUEUE_NUM];
85 } channels[MAX_9P_CHAN];
86
87 /* How many bytes left in this page. */
88 static unsigned int rest_of_page(void *data)
89 {
90         return PAGE_SIZE - ((unsigned long)data % PAGE_SIZE);
91 }
92
93 /**
94  * p9_virtio_close - reclaim resources of a channel
95  * @trans: transport state
96  *
97  * This reclaims a channel by freeing its resources and
98  * reseting its inuse flag.
99  *
100  */
101
102 static void p9_virtio_close(struct p9_client *client)
103 {
104         struct virtio_chan *chan = client->trans;
105
106         mutex_lock(&virtio_9p_lock);
107         chan->inuse = false;
108         mutex_unlock(&virtio_9p_lock);
109 }
110
111 /**
112  * req_done - callback which signals activity from the server
113  * @vq: virtio queue activity was received on
114  *
115  * This notifies us that the server has triggered some activity
116  * on the virtio channel - most likely a response to request we
117  * sent.  Figure out which requests now have responses and wake up
118  * those threads.
119  *
120  * Bugs: could do with some additional sanity checking, but appears to work.
121  *
122  */
123
124 static void req_done(struct virtqueue *vq)
125 {
126         struct virtio_chan *chan = vq->vdev->priv;
127         struct p9_fcall *rc;
128         unsigned int len;
129         struct p9_req_t *req;
130
131         P9_DPRINTK(P9_DEBUG_TRANS, ": request done\n");
132
133         while ((rc = chan->vq->vq_ops->get_buf(chan->vq, &len)) != NULL) {
134                 P9_DPRINTK(P9_DEBUG_TRANS, ": rc %p\n", rc);
135                 P9_DPRINTK(P9_DEBUG_TRANS, ": lookup tag %d\n", rc->tag);
136                 req = p9_tag_lookup(chan->client, rc->tag);
137                 p9_client_cb(chan->client, req);
138         }
139 }
140
141 /**
142  * pack_sg_list - pack a scatter gather list from a linear buffer
143  * @sg: scatter/gather list to pack into
144  * @start: which segment of the sg_list to start at
145  * @limit: maximum segment to pack data to
146  * @data: data to pack into scatter/gather list
147  * @count: amount of data to pack into the scatter/gather list
148  *
149  * sg_lists have multiple segments of various sizes.  This will pack
150  * arbitrary data into an existing scatter gather list, segmenting the
151  * data as necessary within constraints.
152  *
153  */
154
155 static int
156 pack_sg_list(struct scatterlist *sg, int start, int limit, char *data,
157                                                                 int count)
158 {
159         int s;
160         int index = start;
161
162         while (count) {
163                 s = rest_of_page(data);
164                 if (s > count)
165                         s = count;
166                 sg_set_buf(&sg[index++], data, s);
167                 count -= s;
168                 data += s;
169                 BUG_ON(index > limit);
170         }
171
172         return index-start;
173 }
174
175 /* We don't currently allow canceling of virtio requests */
176 static int p9_virtio_cancel(struct p9_client *client, struct p9_req_t *req)
177 {
178         return 1;
179 }
180
181 /**
182  * p9_virtio_request - issue a request
183  * @t: transport state
184  * @tc: &p9_fcall request to transmit
185  * @rc: &p9_fcall to put reponse into
186  *
187  */
188
189 static int
190 p9_virtio_request(struct p9_client *client, struct p9_req_t *req)
191 {
192         int in, out;
193         struct virtio_chan *chan = client->trans;
194         char *rdata = (char *)req->rc+sizeof(struct p9_fcall);
195
196         P9_DPRINTK(P9_DEBUG_TRANS, "9p debug: virtio request\n");
197
198         out = pack_sg_list(chan->sg, 0, VIRTQUEUE_NUM, req->tc->sdata,
199                                                                 req->tc->size);
200         in = pack_sg_list(chan->sg, out, VIRTQUEUE_NUM-out, rdata,
201                                                                 client->msize);
202
203         req->status = REQ_STATUS_SENT;
204
205         if (chan->vq->vq_ops->add_buf(chan->vq, chan->sg, out, in, req->tc)) {
206                 P9_DPRINTK(P9_DEBUG_TRANS,
207                         "9p debug: virtio rpc add_buf returned failure");
208                 return -EIO;
209         }
210
211         chan->vq->vq_ops->kick(chan->vq);
212
213         P9_DPRINTK(P9_DEBUG_TRANS, "9p debug: virtio request kicked\n");
214         return 0;
215 }
216
217 /**
218  * p9_virtio_probe - probe for existence of 9P virtio channels
219  * @vdev: virtio device to probe
220  *
221  * This probes for existing virtio channels.  At present only
222  * a single channel is in use, so in the future more work may need
223  * to be done here.
224  *
225  */
226
227 static int p9_virtio_probe(struct virtio_device *vdev)
228 {
229         int err;
230         struct virtio_chan *chan;
231         int index;
232
233         mutex_lock(&virtio_9p_lock);
234         index = chan_index++;
235         chan = &channels[index];
236         mutex_unlock(&virtio_9p_lock);
237
238         if (chan_index > MAX_9P_CHAN) {
239                 printk(KERN_ERR "9p: virtio: Maximum channels exceeded\n");
240                 BUG();
241                 err = -ENOMEM;
242                 goto fail;
243         }
244
245         chan->vdev = vdev;
246
247         /* We expect one virtqueue, for requests. */
248         chan->vq = vdev->config->find_vq(vdev, 0, req_done);
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         chan->initialized = true;
260         return 0;
261
262 out_free_vq:
263         vdev->config->del_vq(chan->vq);
264 fail:
265         mutex_lock(&virtio_9p_lock);
266         chan_index--;
267         mutex_unlock(&virtio_9p_lock);
268         return err;
269 }
270
271
272 /**
273  * p9_virtio_create - allocate a new virtio channel
274  * @client: client instance invoking this transport
275  * @devname: string identifying the channel to connect to (unused)
276  * @args: args passed from sys_mount() for per-transport options (unused)
277  *
278  * This sets up a transport channel for 9p communication.  Right now
279  * we only match the first available channel, but eventually we couldlook up
280  * alternate channels by matching devname versus a virtio_config entry.
281  * We use a simple reference count mechanism to ensure that only a single
282  * mount has a channel open at a time.
283  *
284  * Bugs: doesn't allow identification of a specific channel
285  * to allocate, channels are allocated sequentially. This was
286  * a pragmatic decision to get things rolling, but ideally some
287  * way of identifying the channel to attach to would be nice
288  * if we are going to support multiple channels.
289  *
290  */
291
292 static int
293 p9_virtio_create(struct p9_client *client, const char *devname, char *args)
294 {
295         struct virtio_chan *chan = channels;
296         int index = 0;
297
298         mutex_lock(&virtio_9p_lock);
299         while (index < MAX_9P_CHAN) {
300                 if (chan->initialized && !chan->inuse) {
301                         chan->inuse = true;
302                         break;
303                 } else {
304                         index++;
305                         chan = &channels[index];
306                 }
307         }
308         mutex_unlock(&virtio_9p_lock);
309
310         if (index >= MAX_9P_CHAN) {
311                 printk(KERN_ERR "9p: no channels available\n");
312                 return -ENODEV;
313         }
314
315         client->trans = (void *)chan;
316         chan->client = client;
317
318         return 0;
319 }
320
321 /**
322  * p9_virtio_remove - clean up resources associated with a virtio device
323  * @vdev: virtio device to remove
324  *
325  */
326
327 static void p9_virtio_remove(struct virtio_device *vdev)
328 {
329         struct virtio_chan *chan = vdev->priv;
330
331         BUG_ON(chan->inuse);
332
333         if (chan->initialized) {
334                 vdev->config->del_vq(chan->vq);
335                 chan->initialized = false;
336         }
337 }
338
339 #define VIRTIO_ID_9P 9
340
341 static struct virtio_device_id id_table[] = {
342         { VIRTIO_ID_9P, VIRTIO_DEV_ANY_ID },
343         { 0 },
344 };
345
346 /* The standard "struct lguest_driver": */
347 static struct virtio_driver p9_virtio_drv = {
348         .driver.name =  KBUILD_MODNAME,
349         .driver.owner = THIS_MODULE,
350         .id_table =     id_table,
351         .probe =        p9_virtio_probe,
352         .remove =       p9_virtio_remove,
353 };
354
355 static struct p9_trans_module p9_virtio_trans = {
356         .name = "virtio",
357         .create = p9_virtio_create,
358         .close = p9_virtio_close,
359         .request = p9_virtio_request,
360         .cancel = p9_virtio_cancel,
361         .maxsize = PAGE_SIZE*16,
362         .def = 0,
363         .owner = THIS_MODULE,
364 };
365
366 /* The standard init function */
367 static int __init p9_virtio_init(void)
368 {
369         int count;
370
371         for (count = 0; count < MAX_9P_CHAN; count++)
372                 channels[count].initialized = false;
373
374         v9fs_register_trans(&p9_virtio_trans);
375         return register_virtio_driver(&p9_virtio_drv);
376 }
377
378 static void __exit p9_virtio_cleanup(void)
379 {
380         unregister_virtio_driver(&p9_virtio_drv);
381         v9fs_unregister_trans(&p9_virtio_trans);
382 }
383
384 module_init(p9_virtio_init);
385 module_exit(p9_virtio_cleanup);
386
387 MODULE_DEVICE_TABLE(virtio, id_table);
388 MODULE_AUTHOR("Eric Van Hensbergen <ericvh@gmail.com>");
389 MODULE_DESCRIPTION("Virtio 9p Transport");
390 MODULE_LICENSE("GPL");