1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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
51static DEFINE_MUTEX(virtio_9p_lock);
52
53static int chan_index;
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71static struct virtio_chan {
72 bool initialized;
73 bool inuse;
74
75 spinlock_t lock;
76
77 struct p9_client *client;
78 struct virtio_device *vdev;
79 struct virtqueue *vq;
80
81
82 struct scatterlist sg[VIRTQUEUE_NUM];
83} channels[MAX_9P_CHAN];
84
85
86static unsigned int rest_of_page(void *data)
87{
88 return PAGE_SIZE - ((unsigned long)data % PAGE_SIZE);
89}
90
91
92
93
94
95
96
97
98
99
100static void p9_virtio_close(struct p9_client *client)
101{
102 struct virtio_chan *chan = client->trans;
103
104 mutex_lock(&virtio_9p_lock);
105 chan->inuse = false;
106 mutex_unlock(&virtio_9p_lock);
107}
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122static void req_done(struct virtqueue *vq)
123{
124 struct virtio_chan *chan = vq->vdev->priv;
125 struct p9_fcall *rc;
126 unsigned int len;
127 struct p9_req_t *req;
128
129 P9_DPRINTK(P9_DEBUG_TRANS, ": request done\n");
130
131 while ((rc = chan->vq->vq_ops->get_buf(chan->vq, &len)) != NULL) {
132 P9_DPRINTK(P9_DEBUG_TRANS, ": rc %p\n", rc);
133 P9_DPRINTK(P9_DEBUG_TRANS, ": lookup tag %d\n", rc->tag);
134 req = p9_tag_lookup(chan->client, rc->tag);
135 req->status = REQ_STATUS_RCVD;
136 p9_client_cb(chan->client, req);
137 }
138}
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154static int
155pack_sg_list(struct scatterlist *sg, int start, int limit, char *data,
156 int count)
157{
158 int s;
159 int index = start;
160
161 while (count) {
162 s = rest_of_page(data);
163 if (s > count)
164 s = count;
165 sg_set_buf(&sg[index++], data, s);
166 count -= s;
167 data += s;
168 BUG_ON(index > limit);
169 }
170
171 return index-start;
172}
173
174
175static int p9_virtio_cancel(struct p9_client *client, struct p9_req_t *req)
176{
177 return 1;
178}
179
180
181
182
183
184
185
186
187static int
188p9_virtio_request(struct p9_client *client, struct p9_req_t *req)
189{
190 int in, out;
191 struct virtio_chan *chan = client->trans;
192 char *rdata = (char *)req->rc+sizeof(struct p9_fcall);
193
194 P9_DPRINTK(P9_DEBUG_TRANS, "9p debug: virtio request\n");
195
196 out = pack_sg_list(chan->sg, 0, VIRTQUEUE_NUM, req->tc->sdata,
197 req->tc->size);
198 in = pack_sg_list(chan->sg, out, VIRTQUEUE_NUM-out, rdata,
199 client->msize);
200
201 req->status = REQ_STATUS_SENT;
202
203 if (chan->vq->vq_ops->add_buf(chan->vq, chan->sg, out, in, req->tc) < 0) {
204 P9_DPRINTK(P9_DEBUG_TRANS,
205 "9p debug: virtio rpc add_buf returned failure");
206 return -EIO;
207 }
208
209 chan->vq->vq_ops->kick(chan->vq);
210
211 P9_DPRINTK(P9_DEBUG_TRANS, "9p debug: virtio request kicked\n");
212 return 0;
213}
214
215
216
217
218
219
220
221
222
223
224
225static int p9_virtio_probe(struct virtio_device *vdev)
226{
227 int err;
228 struct virtio_chan *chan;
229 int index;
230
231 mutex_lock(&virtio_9p_lock);
232 index = chan_index++;
233 chan = &channels[index];
234 mutex_unlock(&virtio_9p_lock);
235
236 if (chan_index > MAX_9P_CHAN) {
237 printk(KERN_ERR "9p: virtio: Maximum channels exceeded\n");
238 BUG();
239 err = -ENOMEM;
240 goto fail;
241 }
242
243 chan->vdev = vdev;
244
245
246 chan->vq = virtio_find_single_vq(vdev, req_done, "requests");
247 if (IS_ERR(chan->vq)) {
248 err = PTR_ERR(chan->vq);
249 goto out_free_vq;
250 }
251 chan->vq->vdev->priv = chan;
252 spin_lock_init(&chan->lock);
253
254 sg_init_table(chan->sg, VIRTQUEUE_NUM);
255
256 chan->inuse = false;
257 chan->initialized = true;
258 return 0;
259
260out_free_vq:
261 vdev->config->del_vqs(vdev);
262fail:
263 mutex_lock(&virtio_9p_lock);
264 chan_index--;
265 mutex_unlock(&virtio_9p_lock);
266 return err;
267}
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290static int
291p9_virtio_create(struct p9_client *client, const char *devname, char *args)
292{
293 struct virtio_chan *chan = channels;
294 int index = 0;
295
296 mutex_lock(&virtio_9p_lock);
297 while (index < MAX_9P_CHAN) {
298 if (chan->initialized && !chan->inuse) {
299 chan->inuse = true;
300 break;
301 } else {
302 index++;
303 chan = &channels[index];
304 }
305 }
306 mutex_unlock(&virtio_9p_lock);
307
308 if (index >= MAX_9P_CHAN) {
309 printk(KERN_ERR "9p: no channels available\n");
310 return -ENODEV;
311 }
312
313 client->trans = (void *)chan;
314 chan->client = client;
315
316 return 0;
317}
318
319
320
321
322
323
324
325static void p9_virtio_remove(struct virtio_device *vdev)
326{
327 struct virtio_chan *chan = vdev->priv;
328
329 BUG_ON(chan->inuse);
330
331 if (chan->initialized) {
332 vdev->config->del_vqs(vdev);
333 chan->initialized = false;
334 }
335}
336
337static struct virtio_device_id id_table[] = {
338 { VIRTIO_ID_9P, VIRTIO_DEV_ANY_ID },
339 { 0 },
340};
341
342
343static struct virtio_driver p9_virtio_drv = {
344 .driver.name = KBUILD_MODNAME,
345 .driver.owner = THIS_MODULE,
346 .id_table = id_table,
347 .probe = p9_virtio_probe,
348 .remove = p9_virtio_remove,
349};
350
351static struct p9_trans_module p9_virtio_trans = {
352 .name = "virtio",
353 .create = p9_virtio_create,
354 .close = p9_virtio_close,
355 .request = p9_virtio_request,
356 .cancel = p9_virtio_cancel,
357 .maxsize = PAGE_SIZE*16,
358 .def = 0,
359 .owner = THIS_MODULE,
360};
361
362
363static int __init p9_virtio_init(void)
364{
365 int count;
366
367 for (count = 0; count < MAX_9P_CHAN; count++)
368 channels[count].initialized = false;
369
370 v9fs_register_trans(&p9_virtio_trans);
371 return register_virtio_driver(&p9_virtio_drv);
372}
373
374static void __exit p9_virtio_cleanup(void)
375{
376 unregister_virtio_driver(&p9_virtio_drv);
377 v9fs_unregister_trans(&p9_virtio_trans);
378}
379
380module_init(p9_virtio_init);
381module_exit(p9_virtio_cleanup);
382
383MODULE_DEVICE_TABLE(virtio, id_table);
384MODULE_AUTHOR("Eric Van Hensbergen <ericvh@gmail.com>");
385MODULE_DESCRIPTION("Virtio 9p Transport");
386MODULE_LICENSE("GPL");
387