Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16

Linux/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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 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 <linux/highmem.h>
 43 #include <linux/slab.h>
 44 #include <net/9p/9p.h>
 45 #include <linux/parser.h>
 46 #include <net/9p/client.h>
 47 #include <net/9p/transport.h>
 48 #include <linux/scatterlist.h>
 49 #include <linux/swap.h>
 50 #include <linux/virtio.h>
 51 #include <linux/virtio_9p.h>
 52 #include "trans_common.h"
 53 
 54 #define VIRTQUEUE_NUM   128
 55 
 56 /* a single mutex to manage channel initialization and attachment */
 57 static DEFINE_MUTEX(virtio_9p_lock);
 58 static DECLARE_WAIT_QUEUE_HEAD(vp_wq);
 59 static atomic_t vp_pinned = ATOMIC_INIT(0);
 60 
 61 /**
 62  * struct virtio_chan - per-instance transport information
 63  * @initialized: whether the channel is initialized
 64  * @inuse: whether the channel is in use
 65  * @lock: protects multiple elements within this structure
 66  * @client: client instance
 67  * @vdev: virtio dev associated with this channel
 68  * @vq: virtio queue associated with this channel
 69  * @sg: scatter gather list which is used to pack a request (protected?)
 70  *
 71  * We keep all per-channel information in a structure.
 72  * This structure is allocated within the devices dev->mem space.
 73  * A pointer to the structure will get put in the transport private.
 74  *
 75  */
 76 
 77 struct virtio_chan {
 78         bool inuse;
 79 
 80         spinlock_t lock;
 81 
 82         struct p9_client *client;
 83         struct virtio_device *vdev;
 84         struct virtqueue *vq;
 85         int ring_bufs_avail;
 86         wait_queue_head_t *vc_wq;
 87         /* This is global limit. Since we don't have a global structure,
 88          * will be placing it in each channel.
 89          */
 90         unsigned long p9_max_pages;
 91         /* Scatterlist: can be too big for stack. */
 92         struct scatterlist sg[VIRTQUEUE_NUM];
 93 
 94         int tag_len;
 95         /*
 96          * tag name to identify a mount Non-null terminated
 97          */
 98         char *tag;
 99 
100         struct list_head chan_list;
101 };
102 
103 static struct list_head virtio_chan_list;
104 
105 /* How many bytes left in this page. */
106 static unsigned int rest_of_page(void *data)
107 {
108         return PAGE_SIZE - ((unsigned long)data % PAGE_SIZE);
109 }
110 
111 /**
112  * p9_virtio_close - reclaim resources of a channel
113  * @client: client instance
114  *
115  * This reclaims a channel by freeing its resources and
116  * reseting its inuse flag.
117  *
118  */
119 
120 static void p9_virtio_close(struct p9_client *client)
121 {
122         struct virtio_chan *chan = client->trans;
123 
124         mutex_lock(&virtio_9p_lock);
125         if (chan)
126                 chan->inuse = false;
127         mutex_unlock(&virtio_9p_lock);
128 }
129 
130 /**
131  * req_done - callback which signals activity from the server
132  * @vq: virtio queue activity was received on
133  *
134  * This notifies us that the server has triggered some activity
135  * on the virtio channel - most likely a response to request we
136  * sent.  Figure out which requests now have responses and wake up
137  * those threads.
138  *
139  * Bugs: could do with some additional sanity checking, but appears to work.
140  *
141  */
142 
143 static void req_done(struct virtqueue *vq)
144 {
145         struct virtio_chan *chan = vq->vdev->priv;
146         struct p9_fcall *rc;
147         unsigned int len;
148         struct p9_req_t *req;
149         unsigned long flags;
150 
151         p9_debug(P9_DEBUG_TRANS, ": request done\n");
152 
153         while (1) {
154                 spin_lock_irqsave(&chan->lock, flags);
155                 rc = virtqueue_get_buf(chan->vq, &len);
156                 if (rc == NULL) {
157                         spin_unlock_irqrestore(&chan->lock, flags);
158                         break;
159                 }
160                 chan->ring_bufs_avail = 1;
161                 spin_unlock_irqrestore(&chan->lock, flags);
162                 /* Wakeup if anyone waiting for VirtIO ring space. */
163                 wake_up(chan->vc_wq);
164                 p9_debug(P9_DEBUG_TRANS, ": rc %p\n", rc);
165                 p9_debug(P9_DEBUG_TRANS, ": lookup tag %d\n", rc->tag);
166                 req = p9_tag_lookup(chan->client, rc->tag);
167                 p9_client_cb(chan->client, req, REQ_STATUS_RCVD);
168         }
169 }
170 
171 /**
172  * pack_sg_list - pack a scatter gather list from a linear buffer
173  * @sg: scatter/gather list to pack into
174  * @start: which segment of the sg_list to start at
175  * @limit: maximum segment to pack data to
176  * @data: data to pack into scatter/gather list
177  * @count: amount of data to pack into the scatter/gather list
178  *
179  * sg_lists have multiple segments of various sizes.  This will pack
180  * arbitrary data into an existing scatter gather list, segmenting the
181  * data as necessary within constraints.
182  *
183  */
184 
185 static int pack_sg_list(struct scatterlist *sg, int start,
186                         int limit, char *data, int count)
187 {
188         int s;
189         int index = start;
190 
191         while (count) {
192                 s = rest_of_page(data);
193                 if (s > count)
194                         s = count;
195                 BUG_ON(index > limit);
196                 /* Make sure we don't terminate early. */
197                 sg_unmark_end(&sg[index]);
198                 sg_set_buf(&sg[index++], data, s);
199                 count -= s;
200                 data += s;
201         }
202         if (index-start)
203                 sg_mark_end(&sg[index - 1]);
204         return index-start;
205 }
206 
207 /* We don't currently allow canceling of virtio requests */
208 static int p9_virtio_cancel(struct p9_client *client, struct p9_req_t *req)
209 {
210         return 1;
211 }
212 
213 /**
214  * pack_sg_list_p - Just like pack_sg_list. Instead of taking a buffer,
215  * this takes a list of pages.
216  * @sg: scatter/gather list to pack into
217  * @start: which segment of the sg_list to start at
218  * @pdata: a list of pages to add into sg.
219  * @nr_pages: number of pages to pack into the scatter/gather list
220  * @data: data to pack into scatter/gather list
221  * @count: amount of data to pack into the scatter/gather list
222  */
223 static int
224 pack_sg_list_p(struct scatterlist *sg, int start, int limit,
225                struct page **pdata, int nr_pages, char *data, int count)
226 {
227         int i = 0, s;
228         int data_off;
229         int index = start;
230 
231         BUG_ON(nr_pages > (limit - start));
232         /*
233          * if the first page doesn't start at
234          * page boundary find the offset
235          */
236         data_off = offset_in_page(data);
237         while (nr_pages) {
238                 s = rest_of_page(data);
239                 if (s > count)
240                         s = count;
241                 /* Make sure we don't terminate early. */
242                 sg_unmark_end(&sg[index]);
243                 sg_set_page(&sg[index++], pdata[i++], s, data_off);
244                 data_off = 0;
245                 data += s;
246                 count -= s;
247                 nr_pages--;
248         }
249 
250         if (index-start)
251                 sg_mark_end(&sg[index - 1]);
252         return index - start;
253 }
254 
255 /**
256  * p9_virtio_request - issue a request
257  * @client: client instance issuing the request
258  * @req: request to be issued
259  *
260  */
261 
262 static int
263 p9_virtio_request(struct p9_client *client, struct p9_req_t *req)
264 {
265         int err;
266         int in, out, out_sgs, in_sgs;
267         unsigned long flags;
268         struct virtio_chan *chan = client->trans;
269         struct scatterlist *sgs[2];
270 
271         p9_debug(P9_DEBUG_TRANS, "9p debug: virtio request\n");
272 
273         req->status = REQ_STATUS_SENT;
274 req_retry:
275         spin_lock_irqsave(&chan->lock, flags);
276 
277         out_sgs = in_sgs = 0;
278         /* Handle out VirtIO ring buffers */
279         out = pack_sg_list(chan->sg, 0,
280                            VIRTQUEUE_NUM, req->tc->sdata, req->tc->size);
281         if (out)
282                 sgs[out_sgs++] = chan->sg;
283 
284         in = pack_sg_list(chan->sg, out,
285                           VIRTQUEUE_NUM, req->rc->sdata, req->rc->capacity);
286         if (in)
287                 sgs[out_sgs + in_sgs++] = chan->sg + out;
288 
289         err = virtqueue_add_sgs(chan->vq, sgs, out_sgs, in_sgs, req->tc,
290                                 GFP_ATOMIC);
291         if (err < 0) {
292                 if (err == -ENOSPC) {
293                         chan->ring_bufs_avail = 0;
294                         spin_unlock_irqrestore(&chan->lock, flags);
295                         err = wait_event_interruptible(*chan->vc_wq,
296                                                         chan->ring_bufs_avail);
297                         if (err  == -ERESTARTSYS)
298                                 return err;
299 
300                         p9_debug(P9_DEBUG_TRANS, "Retry virtio request\n");
301                         goto req_retry;
302                 } else {
303                         spin_unlock_irqrestore(&chan->lock, flags);
304                         p9_debug(P9_DEBUG_TRANS,
305                                  "virtio rpc add_sgs returned failure\n");
306                         return -EIO;
307                 }
308         }
309         virtqueue_kick(chan->vq);
310         spin_unlock_irqrestore(&chan->lock, flags);
311 
312         p9_debug(P9_DEBUG_TRANS, "virtio request kicked\n");
313         return 0;
314 }
315 
316 static int p9_get_mapped_pages(struct virtio_chan *chan,
317                                struct page **pages, char *data,
318                                int nr_pages, int write, int kern_buf)
319 {
320         int err;
321         if (!kern_buf) {
322                 /*
323                  * We allow only p9_max_pages pinned. We wait for the
324                  * Other zc request to finish here
325                  */
326                 if (atomic_read(&vp_pinned) >= chan->p9_max_pages) {
327                         err = wait_event_interruptible(vp_wq,
328                               (atomic_read(&vp_pinned) < chan->p9_max_pages));
329                         if (err == -ERESTARTSYS)
330                                 return err;
331                 }
332                 err = p9_payload_gup(data, &nr_pages, pages, write);
333                 if (err < 0)
334                         return err;
335                 atomic_add(nr_pages, &vp_pinned);
336         } else {
337                 /* kernel buffer, no need to pin pages */
338                 int s, index = 0;
339                 int count = nr_pages;
340                 while (nr_pages) {
341                         s = rest_of_page(data);
342                         if (is_vmalloc_addr(data))
343                                 pages[index++] = vmalloc_to_page(data);
344                         else
345                                 pages[index++] = kmap_to_page(data);
346                         data += s;
347                         nr_pages--;
348                 }
349                 nr_pages = count;
350         }
351         return nr_pages;
352 }
353 
354 /**
355  * p9_virtio_zc_request - issue a zero copy request
356  * @client: client instance issuing the request
357  * @req: request to be issued
358  * @uidata: user bffer that should be ued for zero copy read
359  * @uodata: user buffer that shoud be user for zero copy write
360  * @inlen: read buffer size
361  * @olen: write buffer size
362  * @hdrlen: reader header size, This is the size of response protocol data
363  *
364  */
365 static int
366 p9_virtio_zc_request(struct p9_client *client, struct p9_req_t *req,
367                      char *uidata, char *uodata, int inlen,
368                      int outlen, int in_hdr_len, int kern_buf)
369 {
370         int in, out, err, out_sgs, in_sgs;
371         unsigned long flags;
372         int in_nr_pages = 0, out_nr_pages = 0;
373         struct page **in_pages = NULL, **out_pages = NULL;
374         struct virtio_chan *chan = client->trans;
375         struct scatterlist *sgs[4];
376 
377         p9_debug(P9_DEBUG_TRANS, "virtio request\n");
378 
379         if (uodata) {
380                 out_nr_pages = p9_nr_pages(uodata, outlen);
381                 out_pages = kmalloc(sizeof(struct page *) * out_nr_pages,
382                                     GFP_NOFS);
383                 if (!out_pages) {
384                         err = -ENOMEM;
385                         goto err_out;
386                 }
387                 out_nr_pages = p9_get_mapped_pages(chan, out_pages, uodata,
388                                                    out_nr_pages, 0, kern_buf);
389                 if (out_nr_pages < 0) {
390                         err = out_nr_pages;
391                         kfree(out_pages);
392                         out_pages = NULL;
393                         goto err_out;
394                 }
395         }
396         if (uidata) {
397                 in_nr_pages = p9_nr_pages(uidata, inlen);
398                 in_pages = kmalloc(sizeof(struct page *) * in_nr_pages,
399                                    GFP_NOFS);
400                 if (!in_pages) {
401                         err = -ENOMEM;
402                         goto err_out;
403                 }
404                 in_nr_pages = p9_get_mapped_pages(chan, in_pages, uidata,
405                                                   in_nr_pages, 1, kern_buf);
406                 if (in_nr_pages < 0) {
407                         err = in_nr_pages;
408                         kfree(in_pages);
409                         in_pages = NULL;
410                         goto err_out;
411                 }
412         }
413         req->status = REQ_STATUS_SENT;
414 req_retry_pinned:
415         spin_lock_irqsave(&chan->lock, flags);
416 
417         out_sgs = in_sgs = 0;
418 
419         /* out data */
420         out = pack_sg_list(chan->sg, 0,
421                            VIRTQUEUE_NUM, req->tc->sdata, req->tc->size);
422 
423         if (out)
424                 sgs[out_sgs++] = chan->sg;
425 
426         if (out_pages) {
427                 sgs[out_sgs++] = chan->sg + out;
428                 out += pack_sg_list_p(chan->sg, out, VIRTQUEUE_NUM,
429                                       out_pages, out_nr_pages, uodata, outlen);
430         }
431                 
432         /*
433          * Take care of in data
434          * For example TREAD have 11.
435          * 11 is the read/write header = PDU Header(7) + IO Size (4).
436          * Arrange in such a way that server places header in the
437          * alloced memory and payload onto the user buffer.
438          */
439         in = pack_sg_list(chan->sg, out,
440                           VIRTQUEUE_NUM, req->rc->sdata, in_hdr_len);
441         if (in)
442                 sgs[out_sgs + in_sgs++] = chan->sg + out;
443 
444         if (in_pages) {
445                 sgs[out_sgs + in_sgs++] = chan->sg + out + in;
446                 in += pack_sg_list_p(chan->sg, out + in, VIRTQUEUE_NUM,
447                                      in_pages, in_nr_pages, uidata, inlen);
448         }
449 
450         BUG_ON(out_sgs + in_sgs > ARRAY_SIZE(sgs));
451         err = virtqueue_add_sgs(chan->vq, sgs, out_sgs, in_sgs, req->tc,
452                                 GFP_ATOMIC);
453         if (err < 0) {
454                 if (err == -ENOSPC) {
455                         chan->ring_bufs_avail = 0;
456                         spin_unlock_irqrestore(&chan->lock, flags);
457                         err = wait_event_interruptible(*chan->vc_wq,
458                                                        chan->ring_bufs_avail);
459                         if (err  == -ERESTARTSYS)
460                                 goto err_out;
461 
462                         p9_debug(P9_DEBUG_TRANS, "Retry virtio request\n");
463                         goto req_retry_pinned;
464                 } else {
465                         spin_unlock_irqrestore(&chan->lock, flags);
466                         p9_debug(P9_DEBUG_TRANS,
467                                  "virtio rpc add_sgs returned failure\n");
468                         err = -EIO;
469                         goto err_out;
470                 }
471         }
472         virtqueue_kick(chan->vq);
473         spin_unlock_irqrestore(&chan->lock, flags);
474         p9_debug(P9_DEBUG_TRANS, "virtio request kicked\n");
475         err = wait_event_interruptible(*req->wq,
476                                        req->status >= REQ_STATUS_RCVD);
477         /*
478          * Non kernel buffers are pinned, unpin them
479          */
480 err_out:
481         if (!kern_buf) {
482                 if (in_pages) {
483                         p9_release_pages(in_pages, in_nr_pages);
484                         atomic_sub(in_nr_pages, &vp_pinned);
485                 }
486                 if (out_pages) {
487                         p9_release_pages(out_pages, out_nr_pages);
488                         atomic_sub(out_nr_pages, &vp_pinned);
489                 }
490                 /* wakeup anybody waiting for slots to pin pages */
491                 wake_up(&vp_wq);
492         }
493         kfree(in_pages);
494         kfree(out_pages);
495         return err;
496 }
497 
498 static ssize_t p9_mount_tag_show(struct device *dev,
499                                 struct device_attribute *attr, char *buf)
500 {
501         struct virtio_chan *chan;
502         struct virtio_device *vdev;
503 
504         vdev = dev_to_virtio(dev);
505         chan = vdev->priv;
506 
507         return snprintf(buf, chan->tag_len + 1, "%s", chan->tag);
508 }
509 
510 static DEVICE_ATTR(mount_tag, 0444, p9_mount_tag_show, NULL);
511 
512 /**
513  * p9_virtio_probe - probe for existence of 9P virtio channels
514  * @vdev: virtio device to probe
515  *
516  * This probes for existing virtio channels.
517  *
518  */
519 
520 static int p9_virtio_probe(struct virtio_device *vdev)
521 {
522         __u16 tag_len;
523         char *tag;
524         int err;
525         struct virtio_chan *chan;
526 
527         chan = kmalloc(sizeof(struct virtio_chan), GFP_KERNEL);
528         if (!chan) {
529                 pr_err("Failed to allocate virtio 9P channel\n");
530                 err = -ENOMEM;
531                 goto fail;
532         }
533 
534         chan->vdev = vdev;
535 
536         /* We expect one virtqueue, for requests. */
537         chan->vq = virtio_find_single_vq(vdev, req_done, "requests");
538         if (IS_ERR(chan->vq)) {
539                 err = PTR_ERR(chan->vq);
540                 goto out_free_vq;
541         }
542         chan->vq->vdev->priv = chan;
543         spin_lock_init(&chan->lock);
544 
545         sg_init_table(chan->sg, VIRTQUEUE_NUM);
546 
547         chan->inuse = false;
548         if (virtio_has_feature(vdev, VIRTIO_9P_MOUNT_TAG)) {
549                 virtio_cread(vdev, struct virtio_9p_config, tag_len, &tag_len);
550         } else {
551                 err = -EINVAL;
552                 goto out_free_vq;
553         }
554         tag = kmalloc(tag_len, GFP_KERNEL);
555         if (!tag) {
556                 err = -ENOMEM;
557                 goto out_free_vq;
558         }
559 
560         virtio_cread_bytes(vdev, offsetof(struct virtio_9p_config, tag),
561                            tag, tag_len);
562         chan->tag = tag;
563         chan->tag_len = tag_len;
564         err = sysfs_create_file(&(vdev->dev.kobj), &dev_attr_mount_tag.attr);
565         if (err) {
566                 goto out_free_tag;
567         }
568         chan->vc_wq = kmalloc(sizeof(wait_queue_head_t), GFP_KERNEL);
569         if (!chan->vc_wq) {
570                 err = -ENOMEM;
571                 goto out_free_tag;
572         }
573         init_waitqueue_head(chan->vc_wq);
574         chan->ring_bufs_avail = 1;
575         /* Ceiling limit to avoid denial of service attacks */
576         chan->p9_max_pages = nr_free_buffer_pages()/4;
577 
578         mutex_lock(&virtio_9p_lock);
579         list_add_tail(&chan->chan_list, &virtio_chan_list);
580         mutex_unlock(&virtio_9p_lock);
581 
582         /* Let udev rules use the new mount_tag attribute. */
583         kobject_uevent(&(vdev->dev.kobj), KOBJ_CHANGE);
584 
585         return 0;
586 
587 out_free_tag:
588         kfree(tag);
589 out_free_vq:
590         vdev->config->del_vqs(vdev);
591         kfree(chan);
592 fail:
593         return err;
594 }
595 
596 
597 /**
598  * p9_virtio_create - allocate a new virtio channel
599  * @client: client instance invoking this transport
600  * @devname: string identifying the channel to connect to (unused)
601  * @args: args passed from sys_mount() for per-transport options (unused)
602  *
603  * This sets up a transport channel for 9p communication.  Right now
604  * we only match the first available channel, but eventually we couldlook up
605  * alternate channels by matching devname versus a virtio_config entry.
606  * We use a simple reference count mechanism to ensure that only a single
607  * mount has a channel open at a time.
608  *
609  */
610 
611 static int
612 p9_virtio_create(struct p9_client *client, const char *devname, char *args)
613 {
614         struct virtio_chan *chan;
615         int ret = -ENOENT;
616         int found = 0;
617 
618         mutex_lock(&virtio_9p_lock);
619         list_for_each_entry(chan, &virtio_chan_list, chan_list) {
620                 if (!strncmp(devname, chan->tag, chan->tag_len) &&
621                     strlen(devname) == chan->tag_len) {
622                         if (!chan->inuse) {
623                                 chan->inuse = true;
624                                 found = 1;
625                                 break;
626                         }
627                         ret = -EBUSY;
628                 }
629         }
630         mutex_unlock(&virtio_9p_lock);
631 
632         if (!found) {
633                 pr_err("no channels available\n");
634                 return ret;
635         }
636 
637         client->trans = (void *)chan;
638         client->status = Connected;
639         chan->client = client;
640 
641         return 0;
642 }
643 
644 /**
645  * p9_virtio_remove - clean up resources associated with a virtio device
646  * @vdev: virtio device to remove
647  *
648  */
649 
650 static void p9_virtio_remove(struct virtio_device *vdev)
651 {
652         struct virtio_chan *chan = vdev->priv;
653 
654         if (chan->inuse)
655                 p9_virtio_close(chan->client);
656         vdev->config->del_vqs(vdev);
657 
658         mutex_lock(&virtio_9p_lock);
659         list_del(&chan->chan_list);
660         mutex_unlock(&virtio_9p_lock);
661         sysfs_remove_file(&(vdev->dev.kobj), &dev_attr_mount_tag.attr);
662         kobject_uevent(&(vdev->dev.kobj), KOBJ_CHANGE);
663         kfree(chan->tag);
664         kfree(chan->vc_wq);
665         kfree(chan);
666 
667 }
668 
669 static struct virtio_device_id id_table[] = {
670         { VIRTIO_ID_9P, VIRTIO_DEV_ANY_ID },
671         { 0 },
672 };
673 
674 static unsigned int features[] = {
675         VIRTIO_9P_MOUNT_TAG,
676 };
677 
678 /* The standard "struct lguest_driver": */
679 static struct virtio_driver p9_virtio_drv = {
680         .feature_table  = features,
681         .feature_table_size = ARRAY_SIZE(features),
682         .driver.name    = KBUILD_MODNAME,
683         .driver.owner   = THIS_MODULE,
684         .id_table       = id_table,
685         .probe          = p9_virtio_probe,
686         .remove         = p9_virtio_remove,
687 };
688 
689 static struct p9_trans_module p9_virtio_trans = {
690         .name = "virtio",
691         .create = p9_virtio_create,
692         .close = p9_virtio_close,
693         .request = p9_virtio_request,
694         .zc_request = p9_virtio_zc_request,
695         .cancel = p9_virtio_cancel,
696         /*
697          * We leave one entry for input and one entry for response
698          * headers. We also skip one more entry to accomodate, address
699          * that are not at page boundary, that can result in an extra
700          * page in zero copy.
701          */
702         .maxsize = PAGE_SIZE * (VIRTQUEUE_NUM - 3),
703         .def = 1,
704         .owner = THIS_MODULE,
705 };
706 
707 /* The standard init function */
708 static int __init p9_virtio_init(void)
709 {
710         INIT_LIST_HEAD(&virtio_chan_list);
711 
712         v9fs_register_trans(&p9_virtio_trans);
713         return register_virtio_driver(&p9_virtio_drv);
714 }
715 
716 static void __exit p9_virtio_cleanup(void)
717 {
718         unregister_virtio_driver(&p9_virtio_drv);
719         v9fs_unregister_trans(&p9_virtio_trans);
720 }
721 
722 module_init(p9_virtio_init);
723 module_exit(p9_virtio_cleanup);
724 
725 MODULE_DEVICE_TABLE(virtio, id_table);
726 MODULE_AUTHOR("Eric Van Hensbergen <ericvh@gmail.com>");
727 MODULE_DESCRIPTION("Virtio 9p Transport");
728 MODULE_LICENSE("GPL");
729 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us