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