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