]>
Commit | Line | Data |
---|---|---|
b530cc79 EVH |
1 | /* |
2 | * The Guest 9p transport driver | |
3 | * | |
e2735b77 EVH |
4 | * This is a block based transport driver based on the lguest block driver |
5 | * code. | |
b530cc79 EVH |
6 | * |
7 | */ | |
8 | /* | |
9 | * Copyright (C) 2007 Eric Van Hensbergen, IBM Corporation | |
10 | * | |
11 | * Based on virtio console driver | |
12 | * Copyright (C) 2006, 2007 Rusty Russell, IBM Corporation | |
13 | * | |
14 | * This program is free software; you can redistribute it and/or modify | |
15 | * it under the terms of the GNU General Public License version 2 | |
16 | * as published by the Free Software Foundation. | |
17 | * | |
18 | * This program is distributed in the hope that it will be useful, | |
19 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
20 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
21 | * GNU General Public License for more details. | |
22 | * | |
23 | * You should have received a copy of the GNU General Public License | |
24 | * along with this program; if not, write to: | |
25 | * Free Software Foundation | |
26 | * 51 Franklin Street, Fifth Floor | |
27 | * Boston, MA 02111-1301 USA | |
28 | * | |
29 | */ | |
30 | ||
31 | #include <linux/in.h> | |
32 | #include <linux/module.h> | |
33 | #include <linux/net.h> | |
34 | #include <linux/ipv6.h> | |
35 | #include <linux/errno.h> | |
36 | #include <linux/kernel.h> | |
37 | #include <linux/un.h> | |
38 | #include <linux/uaccess.h> | |
39 | #include <linux/inet.h> | |
40 | #include <linux/idr.h> | |
41 | #include <linux/file.h> | |
42 | #include <net/9p/9p.h> | |
43 | #include <linux/parser.h> | |
8b81ef58 | 44 | #include <net/9p/client.h> |
b530cc79 EVH |
45 | #include <net/9p/transport.h> |
46 | #include <linux/scatterlist.h> | |
47 | #include <linux/virtio.h> | |
48 | #include <linux/virtio_9p.h> | |
49 | ||
e2735b77 EVH |
50 | #define VIRTQUEUE_NUM 128 |
51 | ||
b530cc79 | 52 | /* a single mutex to manage channel initialization and attachment */ |
c1549497 | 53 | static DEFINE_MUTEX(virtio_9p_lock); |
b530cc79 EVH |
54 | /* global which tracks highest initialized channel */ |
55 | static int chan_index; | |
56 | ||
e2735b77 EVH |
57 | #define P9_INIT_MAXTAG 16 |
58 | ||
ee443996 EVH |
59 | /** |
60 | * enum p9_req_status_t - virtio request status | |
61 | * @REQ_STATUS_IDLE: request slot unused | |
62 | * @REQ_STATUS_SENT: request sent to server | |
63 | * @REQ_STATUS_RCVD: response received from server | |
64 | * @REQ_STATUS_FLSH: request has been flushed | |
65 | * | |
66 | * The @REQ_STATUS_IDLE state is used to mark a request slot as unused | |
67 | * but use is actually tracked by the idpool structure which handles tag | |
68 | * id allocation. | |
69 | * | |
70 | */ | |
71 | ||
72 | enum p9_req_status_t { | |
73 | REQ_STATUS_IDLE, | |
74 | REQ_STATUS_SENT, | |
75 | REQ_STATUS_RCVD, | |
76 | REQ_STATUS_FLSH, | |
77 | }; | |
78 | ||
79 | /** | |
80 | * struct p9_req_t - virtio request slots | |
81 | * @status: status of this request slot | |
82 | * @wq: wait_queue for the client to block on for this request | |
83 | * | |
84 | * The virtio transport uses an array to track outstanding requests | |
85 | * instead of a list. While this may incurr overhead during initial | |
86 | * allocation or expansion, it makes request lookup much easier as the | |
87 | * tag id is a index into an array. (We use tag+1 so that we can accomodate | |
88 | * the -1 tag for the T_VERSION request). | |
89 | * This also has the nice effect of only having to allocate wait_queues | |
90 | * once, instead of constantly allocating and freeing them. Its possible | |
91 | * other resources could benefit from this scheme as well. | |
92 | * | |
93 | */ | |
e2735b77 EVH |
94 | |
95 | struct p9_req_t { | |
96 | int status; | |
97 | wait_queue_head_t *wq; | |
98 | }; | |
99 | ||
ee443996 EVH |
100 | /** |
101 | * struct virtio_chan - per-instance transport information | |
102 | * @initialized: whether the channel is initialized | |
103 | * @inuse: whether the channel is in use | |
104 | * @lock: protects multiple elements within this structure | |
105 | * @vdev: virtio dev associated with this channel | |
106 | * @vq: virtio queue associated with this channel | |
107 | * @tagpool: accounting for tag ids (and request slots) | |
108 | * @reqs: array of request slots | |
109 | * @max_tag: current number of request_slots allocated | |
110 | * @sg: scatter gather list which is used to pack a request (protected?) | |
111 | * | |
112 | * We keep all per-channel information in a structure. | |
b530cc79 EVH |
113 | * This structure is allocated within the devices dev->mem space. |
114 | * A pointer to the structure will get put in the transport private. | |
ee443996 | 115 | * |
b530cc79 | 116 | */ |
ee443996 | 117 | |
b530cc79 | 118 | static struct virtio_chan { |
ee443996 EVH |
119 | bool initialized; |
120 | bool inuse; | |
b530cc79 | 121 | |
e2735b77 EVH |
122 | spinlock_t lock; |
123 | ||
b530cc79 | 124 | struct virtio_device *vdev; |
e2735b77 | 125 | struct virtqueue *vq; |
b530cc79 | 126 | |
e2735b77 EVH |
127 | struct p9_idpool *tagpool; |
128 | struct p9_req_t *reqs; | |
129 | int max_tag; | |
b530cc79 | 130 | |
e2735b77 EVH |
131 | /* Scatterlist: can be too big for stack. */ |
132 | struct scatterlist sg[VIRTQUEUE_NUM]; | |
b530cc79 EVH |
133 | } channels[MAX_9P_CHAN]; |
134 | ||
ee443996 EVH |
135 | /** |
136 | * p9_lookup_tag - Lookup requests by tag | |
137 | * @c: virtio channel to lookup tag within | |
138 | * @tag: numeric id for transaction | |
139 | * | |
140 | * this is a simple array lookup, but will grow the | |
141 | * request_slots as necessary to accomodate transaction | |
142 | * ids which did not previously have a slot. | |
143 | * | |
144 | * Bugs: there is currently no upper limit on request slots set | |
145 | * here, but that should be constrained by the id accounting. | |
146 | */ | |
147 | ||
e2735b77 EVH |
148 | static struct p9_req_t *p9_lookup_tag(struct virtio_chan *c, u16 tag) |
149 | { | |
150 | /* This looks up the original request by tag so we know which | |
151 | * buffer to read the data into */ | |
152 | tag++; | |
153 | ||
154 | while (tag >= c->max_tag) { | |
155 | int old_max = c->max_tag; | |
156 | int count; | |
157 | ||
158 | if (c->max_tag) | |
159 | c->max_tag *= 2; | |
160 | else | |
161 | c->max_tag = P9_INIT_MAXTAG; | |
162 | ||
163 | c->reqs = krealloc(c->reqs, sizeof(struct p9_req_t)*c->max_tag, | |
164 | GFP_ATOMIC); | |
165 | if (!c->reqs) { | |
166 | printk(KERN_ERR "Couldn't grow tag array\n"); | |
167 | BUG(); | |
168 | } | |
169 | for (count = old_max; count < c->max_tag; count++) { | |
170 | c->reqs[count].status = REQ_STATUS_IDLE; | |
15e29b8b | 171 | c->reqs[count].wq = kmalloc(sizeof(wait_queue_head_t), |
e2735b77 EVH |
172 | GFP_ATOMIC); |
173 | if (!c->reqs[count].wq) { | |
174 | printk(KERN_ERR "Couldn't grow tag array\n"); | |
175 | BUG(); | |
176 | } | |
177 | init_waitqueue_head(c->reqs[count].wq); | |
178 | } | |
179 | } | |
180 | ||
181 | return &c->reqs[tag]; | |
182 | } | |
183 | ||
184 | ||
b530cc79 EVH |
185 | /* How many bytes left in this page. */ |
186 | static unsigned int rest_of_page(void *data) | |
187 | { | |
188 | return PAGE_SIZE - ((unsigned long)data % PAGE_SIZE); | |
189 | } | |
190 | ||
ee443996 EVH |
191 | /** |
192 | * p9_virtio_close - reclaim resources of a channel | |
193 | * @trans: transport state | |
194 | * | |
195 | * This reclaims a channel by freeing its resources and | |
196 | * reseting its inuse flag. | |
197 | * | |
198 | */ | |
199 | ||
8b81ef58 | 200 | static void p9_virtio_close(struct p9_client *client) |
e2735b77 | 201 | { |
8b81ef58 | 202 | struct virtio_chan *chan = client->trans; |
e2735b77 | 203 | int count; |
d0c44718 | 204 | unsigned long flags; |
b530cc79 | 205 | |
e2735b77 EVH |
206 | spin_lock_irqsave(&chan->lock, flags); |
207 | p9_idpool_destroy(chan->tagpool); | |
208 | for (count = 0; count < chan->max_tag; count++) | |
209 | kfree(chan->reqs[count].wq); | |
210 | kfree(chan->reqs); | |
211 | chan->max_tag = 0; | |
212 | spin_unlock_irqrestore(&chan->lock, flags); | |
b530cc79 | 213 | |
c1549497 | 214 | mutex_lock(&virtio_9p_lock); |
e2735b77 | 215 | chan->inuse = false; |
c1549497 | 216 | mutex_unlock(&virtio_9p_lock); |
b530cc79 | 217 | |
8b81ef58 | 218 | client->trans = NULL; |
b530cc79 EVH |
219 | } |
220 | ||
ee443996 EVH |
221 | /** |
222 | * req_done - callback which signals activity from the server | |
223 | * @vq: virtio queue activity was received on | |
224 | * | |
225 | * This notifies us that the server has triggered some activity | |
226 | * on the virtio channel - most likely a response to request we | |
227 | * sent. Figure out which requests now have responses and wake up | |
228 | * those threads. | |
229 | * | |
230 | * Bugs: could do with some additional sanity checking, but appears to work. | |
231 | * | |
232 | */ | |
233 | ||
e2735b77 | 234 | static void req_done(struct virtqueue *vq) |
b530cc79 | 235 | { |
e2735b77 EVH |
236 | struct virtio_chan *chan = vq->vdev->priv; |
237 | struct p9_fcall *rc; | |
238 | unsigned int len; | |
239 | unsigned long flags; | |
240 | struct p9_req_t *req; | |
241 | ||
242 | spin_lock_irqsave(&chan->lock, flags); | |
243 | while ((rc = chan->vq->vq_ops->get_buf(chan->vq, &len)) != NULL) { | |
244 | req = p9_lookup_tag(chan, rc->tag); | |
245 | req->status = REQ_STATUS_RCVD; | |
246 | wake_up(req->wq); | |
247 | } | |
248 | /* In case queue is stopped waiting for more buffers. */ | |
249 | spin_unlock_irqrestore(&chan->lock, flags); | |
250 | } | |
b530cc79 | 251 | |
ee443996 EVH |
252 | /** |
253 | * pack_sg_list - pack a scatter gather list from a linear buffer | |
254 | * @sg: scatter/gather list to pack into | |
255 | * @start: which segment of the sg_list to start at | |
256 | * @limit: maximum segment to pack data to | |
257 | * @data: data to pack into scatter/gather list | |
258 | * @count: amount of data to pack into the scatter/gather list | |
259 | * | |
260 | * sg_lists have multiple segments of various sizes. This will pack | |
261 | * arbitrary data into an existing scatter gather list, segmenting the | |
262 | * data as necessary within constraints. | |
263 | * | |
264 | */ | |
265 | ||
e2735b77 EVH |
266 | static int |
267 | pack_sg_list(struct scatterlist *sg, int start, int limit, char *data, | |
268 | int count) | |
269 | { | |
270 | int s; | |
271 | int index = start; | |
272 | ||
273 | while (count) { | |
274 | s = rest_of_page(data); | |
275 | if (s > count) | |
276 | s = count; | |
277 | sg_set_buf(&sg[index++], data, s); | |
278 | count -= s; | |
279 | data += s; | |
d6584f3a | 280 | BUG_ON(index > limit); |
e2735b77 | 281 | } |
b530cc79 | 282 | |
e2735b77 | 283 | return index-start; |
b530cc79 EVH |
284 | } |
285 | ||
ee443996 EVH |
286 | /** |
287 | * p9_virtio_rpc - issue a request and wait for a response | |
288 | * @t: transport state | |
289 | * @tc: &p9_fcall request to transmit | |
290 | * @rc: &p9_fcall to put reponse into | |
291 | * | |
292 | */ | |
293 | ||
e2735b77 | 294 | static int |
8b81ef58 | 295 | p9_virtio_rpc(struct p9_client *c, struct p9_fcall *tc, struct p9_fcall **rc) |
b530cc79 | 296 | { |
e2735b77 EVH |
297 | int in, out; |
298 | int n, err, size; | |
8b81ef58 | 299 | struct virtio_chan *chan = c->trans; |
e2735b77 EVH |
300 | char *rdata; |
301 | struct p9_req_t *req; | |
302 | unsigned long flags; | |
303 | ||
304 | if (*rc == NULL) { | |
8b81ef58 | 305 | *rc = kmalloc(sizeof(struct p9_fcall) + c->msize, GFP_KERNEL); |
e2735b77 EVH |
306 | if (!*rc) |
307 | return -ENOMEM; | |
308 | } | |
b530cc79 | 309 | |
e2735b77 | 310 | rdata = (char *)*rc+sizeof(struct p9_fcall); |
b530cc79 | 311 | |
e2735b77 EVH |
312 | n = P9_NOTAG; |
313 | if (tc->id != P9_TVERSION) { | |
314 | n = p9_idpool_get(chan->tagpool); | |
315 | if (n < 0) | |
316 | return -ENOMEM; | |
b530cc79 EVH |
317 | } |
318 | ||
7c7d90f2 | 319 | spin_lock_irqsave(&chan->lock, flags); |
e2735b77 EVH |
320 | req = p9_lookup_tag(chan, n); |
321 | spin_unlock_irqrestore(&chan->lock, flags); | |
b530cc79 | 322 | |
e2735b77 | 323 | p9_set_tag(tc, n); |
b530cc79 | 324 | |
e2735b77 | 325 | P9_DPRINTK(P9_DEBUG_TRANS, "9p debug: virtio rpc tag %d\n", n); |
b530cc79 | 326 | |
e2735b77 | 327 | out = pack_sg_list(chan->sg, 0, VIRTQUEUE_NUM, tc->sdata, tc->size); |
8b81ef58 | 328 | in = pack_sg_list(chan->sg, out, VIRTQUEUE_NUM-out, rdata, c->msize); |
b530cc79 | 329 | |
e2735b77 | 330 | req->status = REQ_STATUS_SENT; |
b530cc79 | 331 | |
e2735b77 EVH |
332 | if (chan->vq->vq_ops->add_buf(chan->vq, chan->sg, out, in, tc)) { |
333 | P9_DPRINTK(P9_DEBUG_TRANS, | |
334 | "9p debug: virtio rpc add_buf returned failure"); | |
335 | return -EIO; | |
336 | } | |
b530cc79 | 337 | |
e2735b77 | 338 | chan->vq->vq_ops->kick(chan->vq); |
b530cc79 | 339 | |
e2735b77 | 340 | wait_event(*req->wq, req->status == REQ_STATUS_RCVD); |
b530cc79 | 341 | |
e2735b77 | 342 | size = le32_to_cpu(*(__le32 *) rdata); |
b530cc79 | 343 | |
8b81ef58 | 344 | err = p9_deserialize_fcall(rdata, size, *rc, c->dotu); |
e2735b77 EVH |
345 | if (err < 0) { |
346 | P9_DPRINTK(P9_DEBUG_TRANS, | |
347 | "9p debug: virtio rpc deserialize returned %d\n", err); | |
348 | return err; | |
349 | } | |
b530cc79 | 350 | |
e2735b77 EVH |
351 | #ifdef CONFIG_NET_9P_DEBUG |
352 | if ((p9_debug_level&P9_DEBUG_FCALL) == P9_DEBUG_FCALL) { | |
353 | char buf[150]; | |
b530cc79 | 354 | |
8b81ef58 EVH |
355 | p9_printfcall(buf, sizeof(buf), *rc, c->dotu); |
356 | printk(KERN_NOTICE ">>> %p %s\n", c, buf); | |
e2735b77 EVH |
357 | } |
358 | #endif | |
b530cc79 | 359 | |
e2735b77 EVH |
360 | if (n != P9_NOTAG && p9_idpool_check(n, chan->tagpool)) |
361 | p9_idpool_put(n, chan->tagpool); | |
b530cc79 | 362 | |
e2735b77 | 363 | req->status = REQ_STATUS_IDLE; |
b530cc79 | 364 | |
e2735b77 | 365 | return 0; |
b530cc79 EVH |
366 | } |
367 | ||
ee443996 EVH |
368 | /** |
369 | * p9_virtio_probe - probe for existence of 9P virtio channels | |
370 | * @vdev: virtio device to probe | |
371 | * | |
372 | * This probes for existing virtio channels. At present only | |
373 | * a single channel is in use, so in the future more work may need | |
374 | * to be done here. | |
375 | * | |
376 | */ | |
377 | ||
e2735b77 | 378 | static int p9_virtio_probe(struct virtio_device *vdev) |
b530cc79 EVH |
379 | { |
380 | int err; | |
381 | struct virtio_chan *chan; | |
382 | int index; | |
383 | ||
c1549497 | 384 | mutex_lock(&virtio_9p_lock); |
b530cc79 EVH |
385 | index = chan_index++; |
386 | chan = &channels[index]; | |
c1549497 | 387 | mutex_unlock(&virtio_9p_lock); |
b530cc79 EVH |
388 | |
389 | if (chan_index > MAX_9P_CHAN) { | |
390 | printk(KERN_ERR "9p: virtio: Maximum channels exceeded\n"); | |
391 | BUG(); | |
b530cc79 EVH |
392 | err = -ENOMEM; |
393 | goto fail; | |
394 | } | |
395 | ||
e2735b77 | 396 | chan->vdev = vdev; |
b530cc79 | 397 | |
e2735b77 EVH |
398 | /* We expect one virtqueue, for requests. */ |
399 | chan->vq = vdev->config->find_vq(vdev, 0, req_done); | |
400 | if (IS_ERR(chan->vq)) { | |
401 | err = PTR_ERR(chan->vq); | |
402 | goto out_free_vq; | |
b530cc79 | 403 | } |
e2735b77 EVH |
404 | chan->vq->vdev->priv = chan; |
405 | spin_lock_init(&chan->lock); | |
b530cc79 | 406 | |
e2735b77 | 407 | sg_init_table(chan->sg, VIRTQUEUE_NUM); |
b530cc79 | 408 | |
b530cc79 EVH |
409 | chan->inuse = false; |
410 | chan->initialized = true; | |
b530cc79 EVH |
411 | return 0; |
412 | ||
e2735b77 EVH |
413 | out_free_vq: |
414 | vdev->config->del_vq(chan->vq); | |
b530cc79 | 415 | fail: |
c1549497 | 416 | mutex_lock(&virtio_9p_lock); |
b530cc79 | 417 | chan_index--; |
c1549497 | 418 | mutex_unlock(&virtio_9p_lock); |
b530cc79 EVH |
419 | return err; |
420 | } | |
421 | ||
ee443996 EVH |
422 | |
423 | /** | |
424 | * p9_virtio_create - allocate a new virtio channel | |
8b81ef58 | 425 | * @client: client instance invoking this transport |
ee443996 EVH |
426 | * @devname: string identifying the channel to connect to (unused) |
427 | * @args: args passed from sys_mount() for per-transport options (unused) | |
ee443996 EVH |
428 | * |
429 | * This sets up a transport channel for 9p communication. Right now | |
b530cc79 EVH |
430 | * we only match the first available channel, but eventually we couldlook up |
431 | * alternate channels by matching devname versus a virtio_config entry. | |
432 | * We use a simple reference count mechanism to ensure that only a single | |
ee443996 EVH |
433 | * mount has a channel open at a time. |
434 | * | |
435 | * Bugs: doesn't allow identification of a specific channel | |
436 | * to allocate, channels are allocated sequentially. This was | |
437 | * a pragmatic decision to get things rolling, but ideally some | |
438 | * way of identifying the channel to attach to would be nice | |
439 | * if we are going to support multiple channels. | |
440 | * | |
441 | */ | |
442 | ||
8b81ef58 EVH |
443 | static int |
444 | p9_virtio_create(struct p9_client *client, const char *devname, char *args) | |
b530cc79 | 445 | { |
b530cc79 | 446 | struct virtio_chan *chan = channels; |
e2735b77 | 447 | int index = 0; |
b530cc79 | 448 | |
c1549497 | 449 | mutex_lock(&virtio_9p_lock); |
b530cc79 EVH |
450 | while (index < MAX_9P_CHAN) { |
451 | if (chan->initialized && !chan->inuse) { | |
452 | chan->inuse = true; | |
453 | break; | |
454 | } else { | |
455 | index++; | |
456 | chan = &channels[index]; | |
457 | } | |
458 | } | |
c1549497 | 459 | mutex_unlock(&virtio_9p_lock); |
b530cc79 EVH |
460 | |
461 | if (index >= MAX_9P_CHAN) { | |
e2735b77 | 462 | printk(KERN_ERR "9p: no channels available\n"); |
8b81ef58 | 463 | return -ENODEV; |
e2735b77 EVH |
464 | } |
465 | ||
466 | chan->tagpool = p9_idpool_create(); | |
467 | if (IS_ERR(chan->tagpool)) { | |
468 | printk(KERN_ERR "9p: couldn't allocate tagpool\n"); | |
8b81ef58 | 469 | return -ENOMEM; |
b530cc79 | 470 | } |
e2735b77 EVH |
471 | p9_idpool_get(chan->tagpool); /* reserve tag 0 */ |
472 | chan->max_tag = 0; | |
473 | chan->reqs = NULL; | |
b530cc79 | 474 | |
8b81ef58 | 475 | client->trans = (void *)chan; |
b530cc79 | 476 | |
8b81ef58 | 477 | return 0; |
b530cc79 EVH |
478 | } |
479 | ||
ee443996 EVH |
480 | /** |
481 | * p9_virtio_remove - clean up resources associated with a virtio device | |
482 | * @vdev: virtio device to remove | |
483 | * | |
484 | */ | |
485 | ||
f3933545 EVH |
486 | static void p9_virtio_remove(struct virtio_device *vdev) |
487 | { | |
488 | struct virtio_chan *chan = vdev->priv; | |
489 | ||
490 | BUG_ON(chan->inuse); | |
491 | ||
492 | if (chan->initialized) { | |
493 | vdev->config->del_vq(chan->vq); | |
494 | chan->initialized = false; | |
495 | } | |
496 | } | |
497 | ||
b530cc79 EVH |
498 | #define VIRTIO_ID_9P 9 |
499 | ||
500 | static struct virtio_device_id id_table[] = { | |
501 | { VIRTIO_ID_9P, VIRTIO_DEV_ANY_ID }, | |
502 | { 0 }, | |
503 | }; | |
504 | ||
505 | /* The standard "struct lguest_driver": */ | |
506 | static struct virtio_driver p9_virtio_drv = { | |
507 | .driver.name = KBUILD_MODNAME, | |
508 | .driver.owner = THIS_MODULE, | |
509 | .id_table = id_table, | |
510 | .probe = p9_virtio_probe, | |
f3933545 | 511 | .remove = p9_virtio_remove, |
b530cc79 EVH |
512 | }; |
513 | ||
514 | static struct p9_trans_module p9_virtio_trans = { | |
515 | .name = "virtio", | |
516 | .create = p9_virtio_create, | |
8b81ef58 EVH |
517 | .close = p9_virtio_close, |
518 | .rpc = p9_virtio_rpc, | |
e2735b77 | 519 | .maxsize = PAGE_SIZE*16, |
b530cc79 | 520 | .def = 0, |
72029fe8 | 521 | .owner = THIS_MODULE, |
b530cc79 EVH |
522 | }; |
523 | ||
524 | /* The standard init function */ | |
525 | static int __init p9_virtio_init(void) | |
526 | { | |
527 | int count; | |
528 | ||
529 | for (count = 0; count < MAX_9P_CHAN; count++) | |
530 | channels[count].initialized = false; | |
531 | ||
532 | v9fs_register_trans(&p9_virtio_trans); | |
533 | return register_virtio_driver(&p9_virtio_drv); | |
534 | } | |
535 | ||
f3933545 EVH |
536 | static void __exit p9_virtio_cleanup(void) |
537 | { | |
538 | unregister_virtio_driver(&p9_virtio_drv); | |
72029fe8 | 539 | v9fs_unregister_trans(&p9_virtio_trans); |
f3933545 EVH |
540 | } |
541 | ||
b530cc79 | 542 | module_init(p9_virtio_init); |
f3933545 | 543 | module_exit(p9_virtio_cleanup); |
b530cc79 EVH |
544 | |
545 | MODULE_DEVICE_TABLE(virtio, id_table); | |
546 | MODULE_AUTHOR("Eric Van Hensbergen <ericvh@gmail.com>"); | |
547 | MODULE_DESCRIPTION("Virtio 9p Transport"); | |
548 | MODULE_LICENSE("GPL"); |