blob: b88515936e4b3310741e6beefac62376bfe9d832 [file] [log] [blame]
Eric Van Hensbergenb530cc72007-10-23 13:47:31 -05001/*
Eric Van Hensbergenfea511a2008-10-13 18:45:23 -05002 * The Virtio 9p transport driver
Eric Van Hensbergenb530cc72007-10-23 13:47:31 -05003 *
Eric Van Hensbergene2735b72008-02-06 19:25:58 -06004 * This is a block based transport driver based on the lguest block driver
5 * code.
Eric Van Hensbergenb530cc72007-10-23 13:47:31 -05006 *
Eric Van Hensbergenfea511a2008-10-13 18:45:23 -05007 * Copyright (C) 2007, 2008 Eric Van Hensbergen, IBM Corporation
Eric Van Hensbergenb530cc72007-10-23 13:47:31 -05008 *
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>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090040#include <linux/slab.h>
Eric Van Hensbergenb530cc72007-10-23 13:47:31 -050041#include <net/9p/9p.h>
42#include <linux/parser.h>
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -050043#include <net/9p/client.h>
Eric Van Hensbergenb530cc72007-10-23 13:47:31 -050044#include <net/9p/transport.h>
45#include <linux/scatterlist.h>
46#include <linux/virtio.h>
47#include <linux/virtio_9p.h>
48
Eric Van Hensbergene2735b72008-02-06 19:25:58 -060049#define VIRTQUEUE_NUM 128
50
Eric Van Hensbergenb530cc72007-10-23 13:47:31 -050051/* a single mutex to manage channel initialization and attachment */
Josef 'Jeff' Sipekc1549492008-03-07 11:39:13 -060052static DEFINE_MUTEX(virtio_9p_lock);
Eric Van Hensbergenb530cc72007-10-23 13:47:31 -050053
Eric Van Hensbergenee443992008-03-05 07:08:09 -060054/**
55 * struct virtio_chan - per-instance transport information
56 * @initialized: whether the channel is initialized
57 * @inuse: whether the channel is in use
58 * @lock: protects multiple elements within this structure
Abhishek Kulkarni0e155972009-07-19 13:41:55 -060059 * @client: client instance
Eric Van Hensbergenee443992008-03-05 07:08:09 -060060 * @vdev: virtio dev associated with this channel
61 * @vq: virtio queue associated with this channel
Eric Van Hensbergenee443992008-03-05 07:08:09 -060062 * @sg: scatter gather list which is used to pack a request (protected?)
63 *
64 * We keep all per-channel information in a structure.
Eric Van Hensbergenb530cc72007-10-23 13:47:31 -050065 * This structure is allocated within the devices dev->mem space.
66 * A pointer to the structure will get put in the transport private.
Eric Van Hensbergenee443992008-03-05 07:08:09 -060067 *
Eric Van Hensbergenb530cc72007-10-23 13:47:31 -050068 */
Eric Van Hensbergenee443992008-03-05 07:08:09 -060069
Aneesh Kumar K.V37c1209d42010-02-15 17:27:01 +000070struct virtio_chan {
Eric Van Hensbergenee443992008-03-05 07:08:09 -060071 bool inuse;
Eric Van Hensbergenb530cc72007-10-23 13:47:31 -050072
Eric Van Hensbergene2735b72008-02-06 19:25:58 -060073 spinlock_t lock;
74
Eric Van Hensbergenfea511a2008-10-13 18:45:23 -050075 struct p9_client *client;
Eric Van Hensbergenb530cc72007-10-23 13:47:31 -050076 struct virtio_device *vdev;
Eric Van Hensbergene2735b72008-02-06 19:25:58 -060077 struct virtqueue *vq;
Eric Van Hensbergenb530cc72007-10-23 13:47:31 -050078
Eric Van Hensbergene2735b72008-02-06 19:25:58 -060079 /* Scatterlist: can be too big for stack. */
80 struct scatterlist sg[VIRTQUEUE_NUM];
Aneesh Kumar K.V37c1209d42010-02-15 17:27:01 +000081
Aneesh Kumar K.V97ee9b02010-03-06 04:44:14 +000082 int tag_len;
83 /*
84 * tag name to identify a mount Non-null terminated
85 */
86 char *tag;
87
Aneesh Kumar K.V37c1209d42010-02-15 17:27:01 +000088 struct list_head chan_list;
89};
90
91static struct list_head virtio_chan_list;
Eric Van Hensbergenb530cc72007-10-23 13:47:31 -050092
93/* How many bytes left in this page. */
94static unsigned int rest_of_page(void *data)
95{
96 return PAGE_SIZE - ((unsigned long)data % PAGE_SIZE);
97}
98
Eric Van Hensbergenee443992008-03-05 07:08:09 -060099/**
100 * p9_virtio_close - reclaim resources of a channel
Abhishek Kulkarni0e155972009-07-19 13:41:55 -0600101 * @client: client instance
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600102 *
103 * This reclaims a channel by freeing its resources and
104 * reseting its inuse flag.
105 *
106 */
107
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -0500108static void p9_virtio_close(struct p9_client *client)
Eric Van Hensbergenb530cc72007-10-23 13:47:31 -0500109{
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -0500110 struct virtio_chan *chan = client->trans;
Eric Van Hensbergenb530cc72007-10-23 13:47:31 -0500111
Josef 'Jeff' Sipekc1549492008-03-07 11:39:13 -0600112 mutex_lock(&virtio_9p_lock);
Aneesh Kumar K.Vfb786102010-02-08 11:50:32 +0000113 if (chan)
114 chan->inuse = false;
Josef 'Jeff' Sipekc1549492008-03-07 11:39:13 -0600115 mutex_unlock(&virtio_9p_lock);
Eric Van Hensbergenb530cc72007-10-23 13:47:31 -0500116}
117
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600118/**
119 * req_done - callback which signals activity from the server
120 * @vq: virtio queue activity was received on
121 *
122 * This notifies us that the server has triggered some activity
123 * on the virtio channel - most likely a response to request we
124 * sent. Figure out which requests now have responses and wake up
125 * those threads.
126 *
127 * Bugs: could do with some additional sanity checking, but appears to work.
128 *
129 */
130
Eric Van Hensbergene2735b72008-02-06 19:25:58 -0600131static void req_done(struct virtqueue *vq)
Eric Van Hensbergenb530cc72007-10-23 13:47:31 -0500132{
Eric Van Hensbergene2735b72008-02-06 19:25:58 -0600133 struct virtio_chan *chan = vq->vdev->priv;
134 struct p9_fcall *rc;
135 unsigned int len;
Eric Van Hensbergene2735b72008-02-06 19:25:58 -0600136 struct p9_req_t *req;
Eric Van Hensbergenb530cc72007-10-23 13:47:31 -0500137
Eric Van Hensbergen91b85342008-10-13 18:45:21 -0500138 P9_DPRINTK(P9_DEBUG_TRANS, ": request done\n");
139
Michael S. Tsirkindc3f5e62010-04-13 16:11:50 +0300140 while ((rc = virtqueue_get_buf(chan->vq, &len)) != NULL) {
Eric Van Hensbergen91b85342008-10-13 18:45:21 -0500141 P9_DPRINTK(P9_DEBUG_TRANS, ": rc %p\n", rc);
142 P9_DPRINTK(P9_DEBUG_TRANS, ": lookup tag %d\n", rc->tag);
Eric Van Hensbergenfea511a2008-10-13 18:45:23 -0500143 req = p9_tag_lookup(chan->client, rc->tag);
Latchesar Ionkov1bab88b2009-04-05 16:28:59 -0500144 req->status = REQ_STATUS_RCVD;
Eric Van Hensbergen91b85342008-10-13 18:45:21 -0500145 p9_client_cb(chan->client, req);
Eric Van Hensbergene2735b72008-02-06 19:25:58 -0600146 }
Eric Van Hensbergenb530cc72007-10-23 13:47:31 -0500147}
148
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600149/**
150 * pack_sg_list - pack a scatter gather list from a linear buffer
151 * @sg: scatter/gather list to pack into
152 * @start: which segment of the sg_list to start at
153 * @limit: maximum segment to pack data to
154 * @data: data to pack into scatter/gather list
155 * @count: amount of data to pack into the scatter/gather list
156 *
157 * sg_lists have multiple segments of various sizes. This will pack
158 * arbitrary data into an existing scatter gather list, segmenting the
159 * data as necessary within constraints.
160 *
161 */
162
Eric Van Hensbergene2735b72008-02-06 19:25:58 -0600163static int
164pack_sg_list(struct scatterlist *sg, int start, int limit, char *data,
165 int count)
166{
167 int s;
168 int index = start;
169
170 while (count) {
171 s = rest_of_page(data);
172 if (s > count)
173 s = count;
174 sg_set_buf(&sg[index++], data, s);
175 count -= s;
176 data += s;
Julia Lawalld6584f32008-02-17 18:42:53 -0800177 BUG_ON(index > limit);
Eric Van Hensbergene2735b72008-02-06 19:25:58 -0600178 }
179
180 return index-start;
181}
182
Eric Van Hensbergen91b85342008-10-13 18:45:21 -0500183/* We don't currently allow canceling of virtio requests */
184static int p9_virtio_cancel(struct p9_client *client, struct p9_req_t *req)
185{
186 return 1;
187}
188
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600189/**
Eric Van Hensbergen91b85342008-10-13 18:45:21 -0500190 * p9_virtio_request - issue a request
Abhishek Kulkarni0e155972009-07-19 13:41:55 -0600191 * @client: client instance issuing the request
192 * @req: request to be issued
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600193 *
194 */
195
Eric Van Hensbergene2735b72008-02-06 19:25:58 -0600196static int
Eric Van Hensbergen91b85342008-10-13 18:45:21 -0500197p9_virtio_request(struct p9_client *client, struct p9_req_t *req)
Eric Van Hensbergene2735b72008-02-06 19:25:58 -0600198{
199 int in, out;
Eric Van Hensbergen91b85342008-10-13 18:45:21 -0500200 struct virtio_chan *chan = client->trans;
201 char *rdata = (char *)req->rc+sizeof(struct p9_fcall);
Eric Van Hensbergene2735b72008-02-06 19:25:58 -0600202
Eric Van Hensbergen91b85342008-10-13 18:45:21 -0500203 P9_DPRINTK(P9_DEBUG_TRANS, "9p debug: virtio request\n");
Eric Van Hensbergene2735b72008-02-06 19:25:58 -0600204
Eric Van Hensbergen91b85342008-10-13 18:45:21 -0500205 out = pack_sg_list(chan->sg, 0, VIRTQUEUE_NUM, req->tc->sdata,
206 req->tc->size);
207 in = pack_sg_list(chan->sg, out, VIRTQUEUE_NUM-out, rdata,
208 client->msize);
Eric Van Hensbergene2735b72008-02-06 19:25:58 -0600209
210 req->status = REQ_STATUS_SENT;
211
Michael S. Tsirkindc3f5e62010-04-13 16:11:50 +0300212 if (virtqueue_add_buf(chan->vq, chan->sg, out, in, req->tc) < 0) {
Eric Van Hensbergene2735b72008-02-06 19:25:58 -0600213 P9_DPRINTK(P9_DEBUG_TRANS,
214 "9p debug: virtio rpc add_buf returned failure");
215 return -EIO;
216 }
217
Michael S. Tsirkindc3f5e62010-04-13 16:11:50 +0300218 virtqueue_kick(chan->vq);
Eric Van Hensbergene2735b72008-02-06 19:25:58 -0600219
Eric Van Hensbergen91b85342008-10-13 18:45:21 -0500220 P9_DPRINTK(P9_DEBUG_TRANS, "9p debug: virtio request kicked\n");
Eric Van Hensbergene2735b72008-02-06 19:25:58 -0600221 return 0;
222}
223
Aneesh Kumar K.V86c84372010-03-06 04:44:15 +0000224static ssize_t p9_mount_tag_show(struct device *dev,
225 struct device_attribute *attr, char *buf)
226{
227 struct virtio_chan *chan;
228 struct virtio_device *vdev;
229
230 vdev = dev_to_virtio(dev);
231 chan = vdev->priv;
232
233 return snprintf(buf, chan->tag_len + 1, "%s", chan->tag);
234}
235
236static DEVICE_ATTR(mount_tag, 0444, p9_mount_tag_show, NULL);
237
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600238/**
239 * p9_virtio_probe - probe for existence of 9P virtio channels
240 * @vdev: virtio device to probe
241 *
Aneesh Kumar K.V37c1209d42010-02-15 17:27:01 +0000242 * This probes for existing virtio channels.
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600243 *
244 */
245
Eric Van Hensbergene2735b72008-02-06 19:25:58 -0600246static int p9_virtio_probe(struct virtio_device *vdev)
Eric Van Hensbergenb530cc72007-10-23 13:47:31 -0500247{
Aneesh Kumar K.V97ee9b02010-03-06 04:44:14 +0000248 __u16 tag_len;
249 char *tag;
Eric Van Hensbergenb530cc72007-10-23 13:47:31 -0500250 int err;
251 struct virtio_chan *chan;
Eric Van Hensbergenb530cc72007-10-23 13:47:31 -0500252
Aneesh Kumar K.V37c1209d42010-02-15 17:27:01 +0000253 chan = kmalloc(sizeof(struct virtio_chan), GFP_KERNEL);
254 if (!chan) {
255 printk(KERN_ERR "9p: Failed to allocate virtio 9P channel\n");
Eric Van Hensbergenb530cc72007-10-23 13:47:31 -0500256 err = -ENOMEM;
257 goto fail;
258 }
259
Eric Van Hensbergene2735b72008-02-06 19:25:58 -0600260 chan->vdev = vdev;
261
262 /* We expect one virtqueue, for requests. */
Michael S. Tsirkind2a7ddd2009-06-12 22:16:36 -0600263 chan->vq = virtio_find_single_vq(vdev, req_done, "requests");
Eric Van Hensbergene2735b72008-02-06 19:25:58 -0600264 if (IS_ERR(chan->vq)) {
265 err = PTR_ERR(chan->vq);
266 goto out_free_vq;
Eric Van Hensbergenb530cc72007-10-23 13:47:31 -0500267 }
Eric Van Hensbergene2735b72008-02-06 19:25:58 -0600268 chan->vq->vdev->priv = chan;
269 spin_lock_init(&chan->lock);
Eric Van Hensbergenb530cc72007-10-23 13:47:31 -0500270
Eric Van Hensbergene2735b72008-02-06 19:25:58 -0600271 sg_init_table(chan->sg, VIRTQUEUE_NUM);
Eric Van Hensbergenb530cc72007-10-23 13:47:31 -0500272
Eric Van Hensbergenb530cc72007-10-23 13:47:31 -0500273 chan->inuse = false;
Aneesh Kumar K.V97ee9b02010-03-06 04:44:14 +0000274 if (virtio_has_feature(vdev, VIRTIO_9P_MOUNT_TAG)) {
275 vdev->config->get(vdev,
276 offsetof(struct virtio_9p_config, tag_len),
277 &tag_len, sizeof(tag_len));
278 } else {
279 err = -EINVAL;
280 goto out_free_vq;
281 }
282 tag = kmalloc(tag_len, GFP_KERNEL);
283 if (!tag) {
284 err = -ENOMEM;
285 goto out_free_vq;
286 }
287 vdev->config->get(vdev, offsetof(struct virtio_9p_config, tag),
288 tag, tag_len);
289 chan->tag = tag;
290 chan->tag_len = tag_len;
Aneesh Kumar K.V86c84372010-03-06 04:44:15 +0000291 err = sysfs_create_file(&(vdev->dev.kobj), &dev_attr_mount_tag.attr);
292 if (err) {
293 kfree(tag);
294 goto out_free_vq;
295 }
Aneesh Kumar K.V37c1209d42010-02-15 17:27:01 +0000296 mutex_lock(&virtio_9p_lock);
297 list_add_tail(&chan->chan_list, &virtio_chan_list);
298 mutex_unlock(&virtio_9p_lock);
Eric Van Hensbergenb530cc72007-10-23 13:47:31 -0500299 return 0;
300
Eric Van Hensbergene2735b72008-02-06 19:25:58 -0600301out_free_vq:
Michael S. Tsirkind2a7ddd2009-06-12 22:16:36 -0600302 vdev->config->del_vqs(vdev);
Aneesh Kumar K.V37c1209d42010-02-15 17:27:01 +0000303 kfree(chan);
Eric Van Hensbergenb530cc72007-10-23 13:47:31 -0500304fail:
Eric Van Hensbergenb530cc72007-10-23 13:47:31 -0500305 return err;
306}
307
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600308
309/**
310 * p9_virtio_create - allocate a new virtio channel
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -0500311 * @client: client instance invoking this transport
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600312 * @devname: string identifying the channel to connect to (unused)
313 * @args: args passed from sys_mount() for per-transport options (unused)
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600314 *
315 * This sets up a transport channel for 9p communication. Right now
Eric Van Hensbergenb530cc72007-10-23 13:47:31 -0500316 * we only match the first available channel, but eventually we couldlook up
317 * alternate channels by matching devname versus a virtio_config entry.
318 * We use a simple reference count mechanism to ensure that only a single
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600319 * mount has a channel open at a time.
320 *
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600321 */
322
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -0500323static int
324p9_virtio_create(struct p9_client *client, const char *devname, char *args)
Eric Van Hensbergenb530cc72007-10-23 13:47:31 -0500325{
Aneesh Kumar K.V37c1209d42010-02-15 17:27:01 +0000326 struct virtio_chan *chan;
Aneesh Kumar K.Vc1a7c222010-02-15 17:27:02 +0000327 int ret = -ENOENT;
Aneesh Kumar K.V37c1209d42010-02-15 17:27:01 +0000328 int found = 0;
Eric Van Hensbergenb530cc72007-10-23 13:47:31 -0500329
Josef 'Jeff' Sipekc1549492008-03-07 11:39:13 -0600330 mutex_lock(&virtio_9p_lock);
Aneesh Kumar K.V37c1209d42010-02-15 17:27:01 +0000331 list_for_each_entry(chan, &virtio_chan_list, chan_list) {
Sven Eckelmann0b204062010-09-27 15:54:44 -0700332 if (!strncmp(devname, chan->tag, chan->tag_len) &&
333 strlen(devname) == chan->tag_len) {
Aneesh Kumar K.Vf75580c2010-02-15 17:27:00 +0000334 if (!chan->inuse) {
335 chan->inuse = true;
Aneesh Kumar K.V37c1209d42010-02-15 17:27:01 +0000336 found = 1;
Aneesh Kumar K.Vf75580c2010-02-15 17:27:00 +0000337 break;
338 }
Aneesh Kumar K.Vc1a7c222010-02-15 17:27:02 +0000339 ret = -EBUSY;
Eric Van Hensbergenb530cc72007-10-23 13:47:31 -0500340 }
341 }
Josef 'Jeff' Sipekc1549492008-03-07 11:39:13 -0600342 mutex_unlock(&virtio_9p_lock);
Eric Van Hensbergenb530cc72007-10-23 13:47:31 -0500343
Aneesh Kumar K.V37c1209d42010-02-15 17:27:01 +0000344 if (!found) {
Eric Van Hensbergene2735b72008-02-06 19:25:58 -0600345 printk(KERN_ERR "9p: no channels available\n");
Aneesh Kumar K.Vc1a7c222010-02-15 17:27:02 +0000346 return ret;
Eric Van Hensbergenb530cc72007-10-23 13:47:31 -0500347 }
348
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -0500349 client->trans = (void *)chan;
Eric Van Hensbergen562ada62010-01-15 18:54:03 -0600350 client->status = Connected;
Eric Van Hensbergenfea511a2008-10-13 18:45:23 -0500351 chan->client = client;
Eric Van Hensbergenb530cc72007-10-23 13:47:31 -0500352
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -0500353 return 0;
Eric Van Hensbergenb530cc72007-10-23 13:47:31 -0500354}
355
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600356/**
357 * p9_virtio_remove - clean up resources associated with a virtio device
358 * @vdev: virtio device to remove
359 *
360 */
361
Eric Van Hensbergenf3933542008-02-06 19:25:04 -0600362static void p9_virtio_remove(struct virtio_device *vdev)
363{
364 struct virtio_chan *chan = vdev->priv;
365
366 BUG_ON(chan->inuse);
Aneesh Kumar K.V37c1209d42010-02-15 17:27:01 +0000367 vdev->config->del_vqs(vdev);
Eric Van Hensbergenf3933542008-02-06 19:25:04 -0600368
Aneesh Kumar K.V37c1209d42010-02-15 17:27:01 +0000369 mutex_lock(&virtio_9p_lock);
370 list_del(&chan->chan_list);
371 mutex_unlock(&virtio_9p_lock);
Aneesh Kumar K.V86c84372010-03-06 04:44:15 +0000372 sysfs_remove_file(&(vdev->dev.kobj), &dev_attr_mount_tag.attr);
Aneesh Kumar K.V97ee9b02010-03-06 04:44:14 +0000373 kfree(chan->tag);
Aneesh Kumar K.V37c1209d42010-02-15 17:27:01 +0000374 kfree(chan);
375
Eric Van Hensbergenf3933542008-02-06 19:25:04 -0600376}
377
Eric Van Hensbergenb530cc72007-10-23 13:47:31 -0500378static struct virtio_device_id id_table[] = {
379 { VIRTIO_ID_9P, VIRTIO_DEV_ANY_ID },
380 { 0 },
381};
382
Aneesh Kumar K.V97ee9b02010-03-06 04:44:14 +0000383static unsigned int features[] = {
384 VIRTIO_9P_MOUNT_TAG,
385};
386
Eric Van Hensbergenb530cc72007-10-23 13:47:31 -0500387/* The standard "struct lguest_driver": */
388static struct virtio_driver p9_virtio_drv = {
Aneesh Kumar K.V97ee9b02010-03-06 04:44:14 +0000389 .feature_table = features,
390 .feature_table_size = ARRAY_SIZE(features),
391 .driver.name = KBUILD_MODNAME,
392 .driver.owner = THIS_MODULE,
393 .id_table = id_table,
394 .probe = p9_virtio_probe,
395 .remove = p9_virtio_remove,
Eric Van Hensbergenb530cc72007-10-23 13:47:31 -0500396};
397
398static struct p9_trans_module p9_virtio_trans = {
399 .name = "virtio",
400 .create = p9_virtio_create,
Eric Van Hensbergen8b81ef52008-10-13 18:45:25 -0500401 .close = p9_virtio_close,
Eric Van Hensbergen91b85342008-10-13 18:45:21 -0500402 .request = p9_virtio_request,
403 .cancel = p9_virtio_cancel,
Eric Van Hensbergene2735b72008-02-06 19:25:58 -0600404 .maxsize = PAGE_SIZE*16,
Eric Van Hensbergenb530cc72007-10-23 13:47:31 -0500405 .def = 0,
Tejun Heo72029fe2008-09-24 16:22:23 -0500406 .owner = THIS_MODULE,
Eric Van Hensbergenb530cc72007-10-23 13:47:31 -0500407};
408
409/* The standard init function */
410static int __init p9_virtio_init(void)
411{
Aneesh Kumar K.V37c1209d42010-02-15 17:27:01 +0000412 INIT_LIST_HEAD(&virtio_chan_list);
Eric Van Hensbergenb530cc72007-10-23 13:47:31 -0500413
414 v9fs_register_trans(&p9_virtio_trans);
415 return register_virtio_driver(&p9_virtio_drv);
416}
417
Eric Van Hensbergenf3933542008-02-06 19:25:04 -0600418static void __exit p9_virtio_cleanup(void)
419{
420 unregister_virtio_driver(&p9_virtio_drv);
Tejun Heo72029fe2008-09-24 16:22:23 -0500421 v9fs_unregister_trans(&p9_virtio_trans);
Eric Van Hensbergenf3933542008-02-06 19:25:04 -0600422}
423
Eric Van Hensbergenb530cc72007-10-23 13:47:31 -0500424module_init(p9_virtio_init);
Eric Van Hensbergenf3933542008-02-06 19:25:04 -0600425module_exit(p9_virtio_cleanup);
Eric Van Hensbergenb530cc72007-10-23 13:47:31 -0500426
427MODULE_DEVICE_TABLE(virtio, id_table);
428MODULE_AUTHOR("Eric Van Hensbergen <ericvh@gmail.com>");
429MODULE_DESCRIPTION("Virtio 9p Transport");
430MODULE_LICENSE("GPL");