1/* 2 * Copyright (C) 2006, 2007, 2009 Rusty Russell, IBM Corporation 3 * Copyright (C) 2009, 2010 Red Hat, Inc. 4 * 5 * This program is free software; you can redistribute it and/or modify 6 * it under the terms of the GNU General Public License as published by 7 * the Free Software Foundation; either version 2 of the License, or 8 * (at your option) any later version. 9 * 10 * This program is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * GNU General Public License for more details. 14 * 15 * You should have received a copy of the GNU General Public License 16 * along with this program; if not, write to the Free Software 17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 18 */ 19#include <linux/cdev.h> 20#include <linux/debugfs.h> 21#include <linux/device.h> 22#include <linux/err.h> 23#include <linux/fs.h> 24#include <linux/init.h> 25#include <linux/list.h> 26#include <linux/poll.h> 27#include <linux/sched.h> 28#include <linux/slab.h> 29#include <linux/spinlock.h> 30#include <linux/virtio.h> 31#include <linux/virtio_console.h> 32#include <linux/wait.h> 33#include <linux/workqueue.h> 34#include "hvc_console.h" 35 36/* 37 * This is a global struct for storing common data for all the devices 38 * this driver handles. 39 * 40 * Mainly, it has a linked list for all the consoles in one place so 41 * that callbacks from hvc for get_chars(), put_chars() work properly 42 * across multiple devices and multiple ports per device. 43 */ 44struct ports_driver_data { 45 /* Used for registering chardevs */ 46 struct class *class; 47 48 /* Used for exporting per-port information to debugfs */ 49 struct dentry *debugfs_dir; 50 51 /* Number of devices this driver is handling */ 52 unsigned int index; 53 54 /* 55 * This is used to keep track of the number of hvc consoles 56 * spawned by this driver. This number is given as the first 57 * argument to hvc_alloc(). To correctly map an initial 58 * console spawned via hvc_instantiate to the console being 59 * hooked up via hvc_alloc, we need to pass the same vtermno. 60 * 61 * We also just assume the first console being initialised was 62 * the first one that got used as the initial console. 63 */ 64 unsigned int next_vtermno; 65 66 /* All the console devices handled by this driver */ 67 struct list_head consoles; 68}; 69static struct ports_driver_data pdrvdata; 70 71DEFINE_SPINLOCK(pdrvdata_lock); 72 73/* This struct holds information that's relevant only for console ports */ 74struct console { 75 /* We'll place all consoles in a list in the pdrvdata struct */ 76 struct list_head list; 77 78 /* The hvc device associated with this console port */ 79 struct hvc_struct *hvc; 80 81 /* The size of the console */ 82 struct winsize ws; 83 84 /* 85 * This number identifies the number that we used to register 86 * with hvc in hvc_instantiate() and hvc_alloc(); this is the 87 * number passed on by the hvc callbacks to us to 88 * differentiate between the other console ports handled by 89 * this driver 90 */ 91 u32 vtermno; 92}; 93 94struct port_buffer { 95 char *buf; 96 97 /* size of the buffer in *buf above */ 98 size_t size; 99 100 /* used length of the buffer */ 101 size_t len; 102 /* offset in the buf from which to consume data */ 103 size_t offset; 104}; 105 106/* 107 * This is a per-device struct that stores data common to all the 108 * ports for that device (vdev->priv). 109 */ 110struct ports_device { 111 /* 112 * Workqueue handlers where we process deferred work after 113 * notification 114 */ 115 struct work_struct control_work; 116 117 struct list_head ports; 118 119 /* To protect the list of ports */ 120 spinlock_t ports_lock; 121 122 /* To protect the vq operations for the control channel */ 123 spinlock_t cvq_lock; 124 125 /* The current config space is stored here */ 126 struct virtio_console_config config; 127 128 /* The virtio device we're associated with */ 129 struct virtio_device *vdev; 130 131 /* 132 * A couple of virtqueues for the control channel: one for 133 * guest->host transfers, one for host->guest transfers 134 */ 135 struct virtqueue *c_ivq, *c_ovq; 136 137 /* Array of per-port IO virtqueues */ 138 struct virtqueue **in_vqs, **out_vqs; 139 140 /* Used for numbering devices for sysfs and debugfs */ 141 unsigned int drv_index; 142 143 /* Major number for this device. Ports will be created as minors. */ 144 int chr_major; 145}; 146 147/* This struct holds the per-port data */ 148struct port { 149 /* Next port in the list, head is in the ports_device */ 150 struct list_head list; 151 152 /* Pointer to the parent virtio_console device */ 153 struct ports_device *portdev; 154 155 /* The current buffer from which data has to be fed to readers */ 156 struct port_buffer *inbuf; 157 158 /* 159 * To protect the operations on the in_vq associated with this 160 * port. Has to be a spinlock because it can be called from 161 * interrupt context (get_char()). 162 */ 163 spinlock_t inbuf_lock; 164 165 /* Protect the operations on the out_vq. */ 166 spinlock_t outvq_lock; 167 168 /* The IO vqs for this port */ 169 struct virtqueue *in_vq, *out_vq; 170 171 /* File in the debugfs directory that exposes this port's information */ 172 struct dentry *debugfs_file; 173 174 /* 175 * The entries in this struct will be valid if this port is 176 * hooked up to an hvc console 177 */ 178 struct console cons; 179 180 /* Each port associates with a separate char device */ 181 struct cdev cdev; 182 struct device *dev; 183 184 /* A waitqueue for poll() or blocking read operations */ 185 wait_queue_head_t waitqueue; 186 187 /* The 'name' of the port that we expose via sysfs properties */ 188 char *name; 189 190 /* The 'id' to identify the port with the Host */ 191 u32 id; 192 193 bool outvq_full; 194 195 /* Is the host device open */ 196 bool host_connected; 197 198 /* We should allow only one process to open a port */ 199 bool guest_connected; 200}; 201 202/* This is the very early arch-specified put chars function. */ 203static int (*early_put_chars)(u32, const char *, int); 204 205static struct port *find_port_by_vtermno(u32 vtermno) 206{ 207 struct port *port; 208 struct console *cons; 209 unsigned long flags; 210 211 spin_lock_irqsave(&pdrvdata_lock, flags); 212 list_for_each_entry(cons, &pdrvdata.consoles, list) { 213 if (cons->vtermno == vtermno) { 214 port = container_of(cons, struct port, cons); 215 goto out; 216 } 217 } 218 port = NULL; 219out: 220 spin_unlock_irqrestore(&pdrvdata_lock, flags); 221 return port; 222} 223 224static struct port *find_port_by_id(struct ports_device *portdev, u32 id) 225{ 226 struct port *port; 227 unsigned long flags; 228 229 spin_lock_irqsave(&portdev->ports_lock, flags); 230 list_for_each_entry(port, &portdev->ports, list) 231 if (port->id == id) 232 goto out; 233 port = NULL; 234out: 235 spin_unlock_irqrestore(&portdev->ports_lock, flags); 236 237 return port; 238} 239 240static struct port *find_port_by_vq(struct ports_device *portdev, 241 struct virtqueue *vq) 242{ 243 struct port *port; 244 unsigned long flags; 245 246 spin_lock_irqsave(&portdev->ports_lock, flags); 247 list_for_each_entry(port, &portdev->ports, list) 248 if (port->in_vq == vq || port->out_vq == vq) 249 goto out; 250 port = NULL; 251out: 252 spin_unlock_irqrestore(&portdev->ports_lock, flags); 253 return port; 254} 255 256static bool is_console_port(struct port *port) 257{ 258 if (port->cons.hvc) 259 return true; 260 return false; 261} 262 263static inline bool use_multiport(struct ports_device *portdev) 264{ 265 /* 266 * This condition can be true when put_chars is called from 267 * early_init 268 */ 269 if (!portdev->vdev) 270 return 0; 271 return portdev->vdev->features[0] & (1 << VIRTIO_CONSOLE_F_MULTIPORT); 272} 273 274static void free_buf(struct port_buffer *buf) 275{ 276 kfree(buf->buf); 277 kfree(buf); 278} 279 280static struct port_buffer *alloc_buf(size_t buf_size) 281{ 282 struct port_buffer *buf; 283 284 buf = kmalloc(sizeof(*buf), GFP_KERNEL); 285 if (!buf) 286 goto fail; 287 buf->buf = kzalloc(buf_size, GFP_KERNEL); 288 if (!buf->buf) 289 goto free_buf; 290 buf->len = 0; 291 buf->offset = 0; 292 buf->size = buf_size; 293 return buf; 294 295free_buf: 296 kfree(buf); 297fail: 298 return NULL; 299} 300 301/* Callers should take appropriate locks */ 302static void *get_inbuf(struct port *port) 303{ 304 struct port_buffer *buf; 305 struct virtqueue *vq; 306 unsigned int len; 307 308 vq = port->in_vq; 309 buf = virtqueue_get_buf(vq, &len); 310 if (buf) { 311 buf->len = len; 312 buf->offset = 0; 313 } 314 return buf; 315} 316 317/* 318 * Create a scatter-gather list representing our input buffer and put 319 * it in the queue. 320 * 321 * Callers should take appropriate locks. 322 */ 323static int add_inbuf(struct virtqueue *vq, struct port_buffer *buf) 324{ 325 struct scatterlist sg[1]; 326 int ret; 327 328 sg_init_one(sg, buf->buf, buf->size); 329 330 ret = virtqueue_add_buf(vq, sg, 0, 1, buf); 331 virtqueue_kick(vq); 332 return ret; 333} 334 335/* Discard any unread data this port has. Callers lockers. */ 336static void discard_port_data(struct port *port) 337{ 338 struct port_buffer *buf; 339 struct virtqueue *vq; 340 unsigned int len; 341 int ret; 342 343 vq = port->in_vq; 344 if (port->inbuf) 345 buf = port->inbuf; 346 else 347 buf = virtqueue_get_buf(vq, &len); 348 349 ret = 0; 350 while (buf) { 351 if (add_inbuf(vq, buf) < 0) { 352 ret++; 353 free_buf(buf); 354 } 355 buf = virtqueue_get_buf(vq, &len); 356 } 357 port->inbuf = NULL; 358 if (ret) 359 dev_warn(port->dev, "Errors adding %d buffers back to vq\n", 360 ret); 361} 362 363static bool port_has_data(struct port *port) 364{ 365 unsigned long flags; 366 bool ret; 367 368 spin_lock_irqsave(&port->inbuf_lock, flags); 369 if (port->inbuf) { 370 ret = true; 371 goto out; 372 } 373 port->inbuf = get_inbuf(port); 374 if (port->inbuf) { 375 ret = true; 376 goto out; 377 } 378 ret = false; 379out: 380 spin_unlock_irqrestore(&port->inbuf_lock, flags); 381 return ret; 382} 383 384static ssize_t __send_control_msg(struct ports_device *portdev, u32 port_id, 385 unsigned int event, unsigned int value) 386{ 387 struct scatterlist sg[1]; 388 struct virtio_console_control cpkt; 389 struct virtqueue *vq; 390 unsigned int len; 391 392 if (!use_multiport(portdev)) 393 return 0; 394 395 cpkt.id = port_id; 396 cpkt.event = event; 397 cpkt.value = value; 398 399 vq = portdev->c_ovq; 400 401 sg_init_one(sg, &cpkt, sizeof(cpkt)); 402 if (virtqueue_add_buf(vq, sg, 1, 0, &cpkt) >= 0) { 403 virtqueue_kick(vq); 404 while (!virtqueue_get_buf(vq, &len)) 405 cpu_relax(); 406 } 407 return 0; 408} 409 410static ssize_t send_control_msg(struct port *port, unsigned int event, 411 unsigned int value) 412{ 413 return __send_control_msg(port->portdev, port->id, event, value); 414} 415 416/* Callers must take the port->outvq_lock */ 417static void reclaim_consumed_buffers(struct port *port) 418{ 419 void *buf; 420 unsigned int len; 421 422 while ((buf = virtqueue_get_buf(port->out_vq, &len))) { 423 kfree(buf); 424 port->outvq_full = false; 425 } 426} 427 428static ssize_t send_buf(struct port *port, void *in_buf, size_t in_count, 429 bool nonblock) 430{ 431 struct scatterlist sg[1]; 432 struct virtqueue *out_vq; 433 ssize_t ret; 434 unsigned long flags; 435 unsigned int len; 436 437 out_vq = port->out_vq; 438 439 spin_lock_irqsave(&port->outvq_lock, flags); 440 441 reclaim_consumed_buffers(port); 442 443 sg_init_one(sg, in_buf, in_count); 444 ret = virtqueue_add_buf(out_vq, sg, 1, 0, in_buf); 445 446 /* Tell Host to go! */ 447 virtqueue_kick(out_vq); 448 449 if (ret < 0) { 450 in_count = 0; 451 goto done; 452 } 453 454 if (ret == 0) 455 port->outvq_full = true; 456 457 if (nonblock) 458 goto done; 459 460 /* 461 * Wait till the host acknowledges it pushed out the data we 462 * sent. This is done for data from the hvc_console; the tty 463 * operations are performed with spinlocks held so we can't 464 * sleep here. An alternative would be to copy the data to a 465 * buffer and relax the spinning requirement. The downside is 466 * we need to kmalloc a GFP_ATOMIC buffer each time the 467 * console driver writes something out. 468 */ 469 while (!virtqueue_get_buf(out_vq, &len)) 470 cpu_relax(); 471done: 472 spin_unlock_irqrestore(&port->outvq_lock, flags); 473 /* 474 * We're expected to return the amount of data we wrote -- all 475 * of it 476 */ 477 return in_count; 478} 479 480/* 481 * Give out the data that's requested from the buffer that we have 482 * queued up. 483 */ 484static ssize_t fill_readbuf(struct port *port, char *out_buf, size_t out_count, 485 bool to_user) 486{ 487 struct port_buffer *buf; 488 unsigned long flags; 489 490 if (!out_count || !port_has_data(port)) 491 return 0; 492 493 buf = port->inbuf; 494 out_count = min(out_count, buf->len - buf->offset); 495 496 if (to_user) { 497 ssize_t ret; 498 499 ret = copy_to_user(out_buf, buf->buf + buf->offset, out_count); 500 if (ret) 501 return -EFAULT; 502 } else { 503 memcpy(out_buf, buf->buf + buf->offset, out_count); 504 } 505 506 buf->offset += out_count; 507 508 if (buf->offset == buf->len) { 509 /* 510 * We're done using all the data in this buffer. 511 * Re-queue so that the Host can send us more data. 512 */ 513 spin_lock_irqsave(&port->inbuf_lock, flags); 514 port->inbuf = NULL; 515 516 if (add_inbuf(port->in_vq, buf) < 0) 517 dev_warn(port->dev, "failed add_buf\n"); 518 519 spin_unlock_irqrestore(&port->inbuf_lock, flags); 520 } 521 /* Return the number of bytes actually copied */ 522 return out_count; 523} 524 525/* The condition that must be true for polling to end */ 526static bool will_read_block(struct port *port) 527{ 528 return !port_has_data(port) && port->host_connected; 529} 530 531static bool will_write_block(struct port *port) 532{ 533 bool ret; 534 535 if (!port->guest_connected) { 536 /* Port got hot-unplugged. Let's exit. */ 537 return false; 538 } 539 if (!port->host_connected) 540 return true; 541 542 spin_lock_irq(&port->outvq_lock); 543 /* 544 * Check if the Host has consumed any buffers since we last 545 * sent data (this is only applicable for nonblocking ports). 546 */ 547 reclaim_consumed_buffers(port); 548 ret = port->outvq_full; 549 spin_unlock_irq(&port->outvq_lock); 550 551 return ret; 552} 553 554static ssize_t port_fops_read(struct file *filp, char __user *ubuf, 555 size_t count, loff_t *offp) 556{ 557 struct port *port; 558 ssize_t ret; 559 560 port = filp->private_data; 561 562 if (!port_has_data(port)) { 563 /* 564 * If nothing's connected on the host just return 0 in 565 * case of list_empty; this tells the userspace app 566 * that there's no connection 567 */ 568 if (!port->host_connected) 569 return 0; 570 if (filp->f_flags & O_NONBLOCK) 571 return -EAGAIN; 572 573 ret = wait_event_interruptible(port->waitqueue, 574 !will_read_block(port)); 575 if (ret < 0) 576 return ret; 577 } 578 /* 579 * We could've received a disconnection message while we were 580 * waiting for more data. 581 * 582 * This check is not clubbed in the if() statement above as we 583 * might receive some data as well as the host could get 584 * disconnected after we got woken up from our wait. So we 585 * really want to give off whatever data we have and only then 586 * check for host_connected. 587 */ 588 if (!port_has_data(port) && !port->host_connected) 589 return 0; 590 591 return fill_readbuf(port, ubuf, count, true); 592} 593 594static ssize_t port_fops_write(struct file *filp, const char __user *ubuf, 595 size_t count, loff_t *offp) 596{ 597 struct port *port; 598 char *buf; 599 ssize_t ret; 600 bool nonblock; 601 602 /* Userspace could be out to fool us */ 603 if (!count) 604 return 0; 605 606 port = filp->private_data; 607 608 nonblock = filp->f_flags & O_NONBLOCK; 609 610 if (will_write_block(port)) { 611 if (nonblock) 612 return -EAGAIN; 613 614 ret = wait_event_interruptible(port->waitqueue, 615 !will_write_block(port)); 616 if (ret < 0) 617 return ret; 618 } 619 620 count = min((size_t)(32 * 1024), count); 621 622 buf = kmalloc(count, GFP_KERNEL); 623 if (!buf) 624 return -ENOMEM; 625 626 ret = copy_from_user(buf, ubuf, count); 627 if (ret) { 628 ret = -EFAULT; 629 goto free_buf; 630 } 631 632 /* 633 * We now ask send_buf() to not spin for generic ports -- we 634 * can re-use the same code path that non-blocking file 635 * descriptors take for blocking file descriptors since the 636 * wait is already done and we're certain the write will go 637 * through to the host. 638 */ 639 nonblock = true; 640 ret = send_buf(port, buf, count, nonblock); 641 642 if (nonblock && ret > 0) 643 goto out; 644 645free_buf: 646 kfree(buf); 647out: 648 return ret; 649} 650 651static unsigned int port_fops_poll(struct file *filp, poll_table *wait) 652{ 653 struct port *port; 654 unsigned int ret; 655 656 port = filp->private_data; 657 poll_wait(filp, &port->waitqueue, wait); 658 659 ret = 0; 660 if (!will_read_block(port)) 661 ret |= POLLIN | POLLRDNORM; 662 if (!will_write_block(port)) 663 ret |= POLLOUT; 664 if (!port->host_connected) 665 ret |= POLLHUP; 666 667 return ret; 668} 669 670static int port_fops_release(struct inode *inode, struct file *filp) 671{ 672 struct port *port; 673 674 port = filp->private_data; 675 676 /* Notify host of port being closed */ 677 send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 0); 678 679 spin_lock_irq(&port->inbuf_lock); 680 port->guest_connected = false; 681 682 discard_port_data(port); 683 684 spin_unlock_irq(&port->inbuf_lock); 685 686 spin_lock_irq(&port->outvq_lock); 687 reclaim_consumed_buffers(port); 688 spin_unlock_irq(&port->outvq_lock); 689 690 return 0; 691} 692 693static int port_fops_open(struct inode *inode, struct file *filp) 694{ 695 struct cdev *cdev = inode->i_cdev; 696 struct port *port; 697 698 port = container_of(cdev, struct port, cdev); 699 filp->private_data = port; 700 701 /* 702 * Don't allow opening of console port devices -- that's done 703 * via /dev/hvc 704 */ 705 if (is_console_port(port)) 706 return -ENXIO; 707 708 /* Allow only one process to open a particular port at a time */ 709 spin_lock_irq(&port->inbuf_lock); 710 if (port->guest_connected) { 711 spin_unlock_irq(&port->inbuf_lock); 712 return -EMFILE; 713 } 714 715 port->guest_connected = true; 716 spin_unlock_irq(&port->inbuf_lock); 717 718 spin_lock_irq(&port->outvq_lock); 719 /* 720 * There might be a chance that we missed reclaiming a few 721 * buffers in the window of the port getting previously closed 722 * and opening now. 723 */ 724 reclaim_consumed_buffers(port); 725 spin_unlock_irq(&port->outvq_lock); 726 727 /* Notify host of port being opened */ 728 send_control_msg(filp->private_data, VIRTIO_CONSOLE_PORT_OPEN, 1); 729 730 return 0; 731} 732 733/* 734 * The file operations that we support: programs in the guest can open 735 * a console device, read from it, write to it, poll for data and 736 * close it. The devices are at 737 * /dev/vport<device number>p<port number> 738 */ 739static const struct file_operations port_fops = { 740 .owner = THIS_MODULE, 741 .open = port_fops_open, 742 .read = port_fops_read, 743 .write = port_fops_write, 744 .poll = port_fops_poll, 745 .release = port_fops_release, 746}; 747 748/* 749 * The put_chars() callback is pretty straightforward. 750 * 751 * We turn the characters into a scatter-gather list, add it to the 752 * output queue and then kick the Host. Then we sit here waiting for 753 * it to finish: inefficient in theory, but in practice 754 * implementations will do it immediately (lguest's Launcher does). 755 */ 756static int put_chars(u32 vtermno, const char *buf, int count) 757{ 758 struct port *port; 759 760 if (unlikely(early_put_chars)) 761 return early_put_chars(vtermno, buf, count); 762 763 port = find_port_by_vtermno(vtermno); 764 if (!port) 765 return -EPIPE; 766 767 return send_buf(port, (void *)buf, count, false); 768} 769 770/* 771 * get_chars() is the callback from the hvc_console infrastructure 772 * when an interrupt is received. 773 * 774 * We call out to fill_readbuf that gets us the required data from the 775 * buffers that are queued up. 776 */ 777static int get_chars(u32 vtermno, char *buf, int count) 778{ 779 struct port *port; 780 781 /* If we've not set up the port yet, we have no input to give. */ 782 if (unlikely(early_put_chars)) 783 return 0; 784 785 port = find_port_by_vtermno(vtermno); 786 if (!port) 787 return -EPIPE; 788 789 /* If we don't have an input queue yet, we can't get input. */ 790 BUG_ON(!port->in_vq); 791 792 return fill_readbuf(port, buf, count, false); 793} 794 795static void resize_console(struct port *port) 796{ 797 struct virtio_device *vdev; 798 799 /* The port could have been hot-unplugged */ 800 if (!port || !is_console_port(port)) 801 return; 802 803 vdev = port->portdev->vdev; 804 if (virtio_has_feature(vdev, VIRTIO_CONSOLE_F_SIZE)) 805 hvc_resize(port->cons.hvc, port->cons.ws); 806} 807 808/* We set the configuration at this point, since we now have a tty */ 809static int notifier_add_vio(struct hvc_struct *hp, int data) 810{ 811 struct port *port; 812 813 port = find_port_by_vtermno(hp->vtermno); 814 if (!port) 815 return -EINVAL; 816 817 hp->irq_requested = 1; 818 resize_console(port); 819 820 return 0; 821} 822 823static void notifier_del_vio(struct hvc_struct *hp, int data) 824{ 825 hp->irq_requested = 0; 826} 827 828/* The operations for console ports. */ 829static const struct hv_ops hv_ops = { 830 .get_chars = get_chars, 831 .put_chars = put_chars, 832 .notifier_add = notifier_add_vio, 833 .notifier_del = notifier_del_vio, 834 .notifier_hangup = notifier_del_vio, 835}; 836 837/* 838 * Console drivers are initialized very early so boot messages can go 839 * out, so we do things slightly differently from the generic virtio 840 * initialization of the net and block drivers. 841 * 842 * At this stage, the console is output-only. It's too early to set 843 * up a virtqueue, so we let the drivers do some boutique early-output 844 * thing. 845 */ 846int __init virtio_cons_early_init(int (*put_chars)(u32, const char *, int)) 847{ 848 early_put_chars = put_chars; 849 return hvc_instantiate(0, 0, &hv_ops); 850} 851 852int init_port_console(struct port *port) 853{ 854 int ret; 855 856 /* 857 * The Host's telling us this port is a console port. Hook it 858 * up with an hvc console. 859 * 860 * To set up and manage our virtual console, we call 861 * hvc_alloc(). 862 * 863 * The first argument of hvc_alloc() is the virtual console 864 * number. The second argument is the parameter for the 865 * notification mechanism (like irq number). We currently 866 * leave this as zero, virtqueues have implicit notifications. 867 * 868 * The third argument is a "struct hv_ops" containing the 869 * put_chars() get_chars(), notifier_add() and notifier_del() 870 * pointers. The final argument is the output buffer size: we 871 * can do any size, so we put PAGE_SIZE here. 872 */ 873 port->cons.vtermno = pdrvdata.next_vtermno; 874 875 port->cons.hvc = hvc_alloc(port->cons.vtermno, 0, &hv_ops, PAGE_SIZE); 876 if (IS_ERR(port->cons.hvc)) { 877 ret = PTR_ERR(port->cons.hvc); 878 dev_err(port->dev, 879 "error %d allocating hvc for port\n", ret); 880 port->cons.hvc = NULL; 881 return ret; 882 } 883 spin_lock_irq(&pdrvdata_lock); 884 pdrvdata.next_vtermno++; 885 list_add_tail(&port->cons.list, &pdrvdata.consoles); 886 spin_unlock_irq(&pdrvdata_lock); 887 port->guest_connected = true; 888 889 /* 890 * Start using the new console output if this is the first 891 * console to come up. 892 */ 893 if (early_put_chars) 894 early_put_chars = NULL; 895 896 /* Notify host of port being opened */ 897 send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 1); 898 899 return 0; 900} 901 902static ssize_t show_port_name(struct device *dev, 903 struct device_attribute *attr, char *buffer) 904{ 905 struct port *port; 906 907 port = dev_get_drvdata(dev); 908 909 return sprintf(buffer, "%s\n", port->name); 910} 911 912static DEVICE_ATTR(name, S_IRUGO, show_port_name, NULL); 913 914static struct attribute *port_sysfs_entries[] = { 915 &dev_attr_name.attr, 916 NULL 917}; 918 919static struct attribute_group port_attribute_group = { 920 .name = NULL, /* put in device directory */ 921 .attrs = port_sysfs_entries, 922}; 923 924static int debugfs_open(struct inode *inode, struct file *filp) 925{ 926 filp->private_data = inode->i_private; 927 return 0; 928} 929 930static ssize_t debugfs_read(struct file *filp, char __user *ubuf, 931 size_t count, loff_t *offp) 932{ 933 struct port *port; 934 char *buf; 935 ssize_t ret, out_offset, out_count; 936 937 out_count = 1024; 938 buf = kmalloc(out_count, GFP_KERNEL); 939 if (!buf) 940 return -ENOMEM; 941 942 port = filp->private_data; 943 out_offset = 0; 944 out_offset += snprintf(buf + out_offset, out_count, 945 "name: %s\n", port->name ? port->name : ""); 946 out_offset += snprintf(buf + out_offset, out_count - out_offset, 947 "guest_connected: %d\n", port->guest_connected); 948 out_offset += snprintf(buf + out_offset, out_count - out_offset, 949 "host_connected: %d\n", port->host_connected); 950 out_offset += snprintf(buf + out_offset, out_count - out_offset, 951 "outvq_full: %d\n", port->outvq_full); 952 out_offset += snprintf(buf + out_offset, out_count - out_offset, 953 "is_console: %s\n", 954 is_console_port(port) ? "yes" : "no"); 955 out_offset += snprintf(buf + out_offset, out_count - out_offset, 956 "console_vtermno: %u\n", port->cons.vtermno); 957 958 ret = simple_read_from_buffer(ubuf, count, offp, buf, out_offset); 959 kfree(buf); 960 return ret; 961} 962 963static const struct file_operations port_debugfs_ops = { 964 .owner = THIS_MODULE, 965 .open = debugfs_open, 966 .read = debugfs_read, 967}; 968 969static void set_console_size(struct port *port, u16 rows, u16 cols) 970{ 971 if (!port || !is_console_port(port)) 972 return; 973 974 port->cons.ws.ws_row = rows; 975 port->cons.ws.ws_col = cols; 976} 977 978static unsigned int fill_queue(struct virtqueue *vq, spinlock_t *lock) 979{ 980 struct port_buffer *buf; 981 unsigned int nr_added_bufs; 982 int ret; 983 984 nr_added_bufs = 0; 985 do { 986 buf = alloc_buf(PAGE_SIZE); 987 if (!buf) 988 break; 989 990 spin_lock_irq(lock); 991 ret = add_inbuf(vq, buf); 992 if (ret < 0) { 993 spin_unlock_irq(lock); 994 free_buf(buf); 995 break; 996 } 997 nr_added_bufs++; 998 spin_unlock_irq(lock); 999 } while (ret > 0); 1000 1001 return nr_added_bufs; 1002} 1003 1004static int add_port(struct ports_device *portdev, u32 id) 1005{ 1006 char debugfs_name[16]; 1007 struct port *port; 1008 struct port_buffer *buf; 1009 dev_t devt; 1010 unsigned int nr_added_bufs; 1011 int err; 1012 1013 port = kmalloc(sizeof(*port), GFP_KERNEL); 1014 if (!port) { 1015 err = -ENOMEM; 1016 goto fail; 1017 } 1018 1019 port->portdev = portdev; 1020 port->id = id; 1021 1022 port->name = NULL; 1023 port->inbuf = NULL; 1024 port->cons.hvc = NULL; 1025 1026 port->cons.ws.ws_row = port->cons.ws.ws_col = 0; 1027 1028 port->host_connected = port->guest_connected = false; 1029 1030 port->outvq_full = false; 1031 1032 port->in_vq = portdev->in_vqs[port->id]; 1033 port->out_vq = portdev->out_vqs[port->id]; 1034 1035 cdev_init(&port->cdev, &port_fops); 1036 1037 devt = MKDEV(portdev->chr_major, id); 1038 err = cdev_add(&port->cdev, devt, 1); 1039 if (err < 0) { 1040 dev_err(&port->portdev->vdev->dev, 1041 "Error %d adding cdev for port %u\n", err, id); 1042 goto free_port; 1043 } 1044 port->dev = device_create(pdrvdata.class, &port->portdev->vdev->dev, 1045 devt, port, "vport%up%u", 1046 port->portdev->drv_index, id); 1047 if (IS_ERR(port->dev)) { 1048 err = PTR_ERR(port->dev); 1049 dev_err(&port->portdev->vdev->dev, 1050 "Error %d creating device for port %u\n", 1051 err, id); 1052 goto free_cdev; 1053 } 1054 1055 spin_lock_init(&port->inbuf_lock); 1056 spin_lock_init(&port->outvq_lock); 1057 init_waitqueue_head(&port->waitqueue); 1058 1059 /* Fill the in_vq with buffers so the host can send us data. */ 1060 nr_added_bufs = fill_queue(port->in_vq, &port->inbuf_lock); 1061 if (!nr_added_bufs) { 1062 dev_err(port->dev, "Error allocating inbufs\n"); 1063 err = -ENOMEM; 1064 goto free_device; 1065 } 1066 1067 /* 1068 * If we're not using multiport support, this has to be a console port 1069 */ 1070 if (!use_multiport(port->portdev)) { 1071 err = init_port_console(port); 1072 if (err) 1073 goto free_inbufs; 1074 } 1075 1076 spin_lock_irq(&portdev->ports_lock); 1077 list_add_tail(&port->list, &port->portdev->ports); 1078 spin_unlock_irq(&portdev->ports_lock); 1079 1080 /* 1081 * Tell the Host we're set so that it can send us various 1082 * configuration parameters for this port (eg, port name, 1083 * caching, whether this is a console port, etc.) 1084 */ 1085 send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1); 1086 1087 if (pdrvdata.debugfs_dir) { 1088 /* 1089 * Finally, create the debugfs file that we can use to 1090 * inspect a port's state at any time 1091 */ 1092 sprintf(debugfs_name, "vport%up%u", 1093 port->portdev->drv_index, id); 1094 port->debugfs_file = debugfs_create_file(debugfs_name, 0444, 1095 pdrvdata.debugfs_dir, 1096 port, 1097 &port_debugfs_ops); 1098 } 1099 return 0; 1100 1101free_inbufs: 1102 while ((buf = virtqueue_detach_unused_buf(port->in_vq))) 1103 free_buf(buf); 1104free_device: 1105 device_destroy(pdrvdata.class, port->dev->devt); 1106free_cdev: 1107 cdev_del(&port->cdev); 1108free_port: 1109 kfree(port); 1110fail: 1111 /* The host might want to notify management sw about port add failure */ 1112 __send_control_msg(portdev, id, VIRTIO_CONSOLE_PORT_READY, 0); 1113 return err; 1114} 1115 1116/* Remove all port-specific data. */ 1117static int remove_port(struct port *port) 1118{ 1119 struct port_buffer *buf; 1120 1121 if (port->guest_connected) { 1122 port->guest_connected = false; 1123 port->host_connected = false; 1124 wake_up_interruptible(&port->waitqueue); 1125 send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 0); 1126 } 1127 1128 spin_lock_irq(&port->portdev->ports_lock); 1129 list_del(&port->list); 1130 spin_unlock_irq(&port->portdev->ports_lock); 1131 1132 if (is_console_port(port)) { 1133 spin_lock_irq(&pdrvdata_lock); 1134 list_del(&port->cons.list); 1135 spin_unlock_irq(&pdrvdata_lock); 1136 } 1137 sysfs_remove_group(&port->dev->kobj, &port_attribute_group); 1138 device_destroy(pdrvdata.class, port->dev->devt); 1139 cdev_del(&port->cdev); 1140 1141 /* Remove unused data this port might have received. */ 1142 discard_port_data(port); 1143 1144 reclaim_consumed_buffers(port); 1145 1146 /* Remove buffers we queued up for the Host to send us data in. */ 1147 while ((buf = virtqueue_detach_unused_buf(port->in_vq))) 1148 free_buf(buf); 1149 1150 kfree(port->name); 1151 1152 debugfs_remove(port->debugfs_file); 1153 1154 kfree(port); 1155 return 0; 1156} 1157 1158/* Any private messages that the Host and Guest want to share */ 1159static void handle_control_message(struct ports_device *portdev, 1160 struct port_buffer *buf) 1161{ 1162 struct virtio_console_control *cpkt; 1163 struct port *port; 1164 size_t name_size; 1165 int err; 1166 1167 cpkt = (struct virtio_console_control *)(buf->buf + buf->offset); 1168 1169 port = find_port_by_id(portdev, cpkt->id); 1170 if (!port && cpkt->event != VIRTIO_CONSOLE_PORT_ADD) { 1171 /* No valid header at start of buffer. Drop it. */ 1172 dev_dbg(&portdev->vdev->dev, 1173 "Invalid index %u in control packet\n", cpkt->id); 1174 return; 1175 } 1176 1177 switch (cpkt->event) { 1178 case VIRTIO_CONSOLE_PORT_ADD: 1179 if (port) { 1180 dev_dbg(&portdev->vdev->dev, 1181 "Port %u already added\n", port->id); 1182 send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1); 1183 break; 1184 } 1185 if (cpkt->id >= portdev->config.max_nr_ports) { 1186 dev_warn(&portdev->vdev->dev, 1187 "Request for adding port with out-of-bound id %u, max. supported id: %u\n", 1188 cpkt->id, portdev->config.max_nr_ports - 1); 1189 break; 1190 } 1191 add_port(portdev, cpkt->id); 1192 break; 1193 case VIRTIO_CONSOLE_PORT_REMOVE: 1194 remove_port(port); 1195 break; 1196 case VIRTIO_CONSOLE_CONSOLE_PORT: 1197 if (!cpkt->value) 1198 break; 1199 if (is_console_port(port)) 1200 break; 1201 1202 init_port_console(port); 1203 /* 1204 * Could remove the port here in case init fails - but 1205 * have to notify the host first. 1206 */ 1207 break; 1208 case VIRTIO_CONSOLE_RESIZE: { 1209 struct { 1210 __u16 rows; 1211 __u16 cols; 1212 } size; 1213 1214 if (!is_console_port(port)) 1215 break; 1216 1217 memcpy(&size, buf->buf + buf->offset + sizeof(*cpkt), 1218 sizeof(size)); 1219 set_console_size(port, size.rows, size.cols); 1220 1221 port->cons.hvc->irq_requested = 1; 1222 resize_console(port); 1223 break; 1224 } 1225 case VIRTIO_CONSOLE_PORT_OPEN: 1226 port->host_connected = cpkt->value; 1227 wake_up_interruptible(&port->waitqueue); 1228 /* 1229 * If the host port got closed and the host had any 1230 * unconsumed buffers, we'll be able to reclaim them 1231 * now. 1232 */ 1233 spin_lock_irq(&port->outvq_lock); 1234 reclaim_consumed_buffers(port); 1235 spin_unlock_irq(&port->outvq_lock); 1236 break; 1237 case VIRTIO_CONSOLE_PORT_NAME: 1238 /* 1239 * Skip the size of the header and the cpkt to get the size 1240 * of the name that was sent 1241 */ 1242 name_size = buf->len - buf->offset - sizeof(*cpkt) + 1; 1243 1244 port->name = kmalloc(name_size, GFP_KERNEL); 1245 if (!port->name) { 1246 dev_err(port->dev, 1247 "Not enough space to store port name\n"); 1248 break; 1249 } 1250 strncpy(port->name, buf->buf + buf->offset + sizeof(*cpkt), 1251 name_size - 1); 1252 port->name[name_size - 1] = 0; 1253 1254 /* 1255 * Since we only have one sysfs attribute, 'name', 1256 * create it only if we have a name for the port. 1257 */ 1258 err = sysfs_create_group(&port->dev->kobj, 1259 &port_attribute_group); 1260 if (err) { 1261 dev_err(port->dev, 1262 "Error %d creating sysfs device attributes\n", 1263 err); 1264 } else { 1265 /* 1266 * Generate a udev event so that appropriate 1267 * symlinks can be created based on udev 1268 * rules. 1269 */ 1270 kobject_uevent(&port->dev->kobj, KOBJ_CHANGE); 1271 } 1272 break; 1273 } 1274} 1275 1276static void control_work_handler(struct work_struct *work) 1277{ 1278 struct ports_device *portdev; 1279 struct virtqueue *vq; 1280 struct port_buffer *buf; 1281 unsigned int len; 1282 1283 portdev = container_of(work, struct ports_device, control_work); 1284 vq = portdev->c_ivq; 1285 1286 spin_lock(&portdev->cvq_lock); 1287 while ((buf = virtqueue_get_buf(vq, &len))) { 1288 spin_unlock(&portdev->cvq_lock); 1289 1290 buf->len = len; 1291 buf->offset = 0; 1292 1293 handle_control_message(portdev, buf); 1294 1295 spin_lock(&portdev->cvq_lock); 1296 if (add_inbuf(portdev->c_ivq, buf) < 0) { 1297 dev_warn(&portdev->vdev->dev, 1298 "Error adding buffer to queue\n"); 1299 free_buf(buf); 1300 } 1301 } 1302 spin_unlock(&portdev->cvq_lock); 1303} 1304 1305static void out_intr(struct virtqueue *vq) 1306{ 1307 struct port *port; 1308 1309 port = find_port_by_vq(vq->vdev->priv, vq); 1310 if (!port) 1311 return; 1312 1313 wake_up_interruptible(&port->waitqueue); 1314} 1315 1316static void in_intr(struct virtqueue *vq) 1317{ 1318 struct port *port; 1319 unsigned long flags; 1320 1321 port = find_port_by_vq(vq->vdev->priv, vq); 1322 if (!port) 1323 return; 1324 1325 spin_lock_irqsave(&port->inbuf_lock, flags); 1326 if (!port->inbuf) 1327 port->inbuf = get_inbuf(port); 1328 1329 /* 1330 * Don't queue up data when port is closed. This condition 1331 * can be reached when a console port is not yet connected (no 1332 * tty is spawned) and the host sends out data to console 1333 * ports. For generic serial ports, the host won't 1334 * (shouldn't) send data till the guest is connected. 1335 */ 1336 if (!port->guest_connected) 1337 discard_port_data(port); 1338 1339 spin_unlock_irqrestore(&port->inbuf_lock, flags); 1340 1341 wake_up_interruptible(&port->waitqueue); 1342 1343 if (is_console_port(port) && hvc_poll(port->cons.hvc)) 1344 hvc_kick(); 1345} 1346 1347static void control_intr(struct virtqueue *vq) 1348{ 1349 struct ports_device *portdev; 1350 1351 portdev = vq->vdev->priv; 1352 schedule_work(&portdev->control_work); 1353} 1354 1355static void config_intr(struct virtio_device *vdev) 1356{ 1357 struct ports_device *portdev; 1358 1359 portdev = vdev->priv; 1360 1361 if (!use_multiport(portdev)) { 1362 struct port *port; 1363 u16 rows, cols; 1364 1365 vdev->config->get(vdev, 1366 offsetof(struct virtio_console_config, cols), 1367 &cols, sizeof(u16)); 1368 vdev->config->get(vdev, 1369 offsetof(struct virtio_console_config, rows), 1370 &rows, sizeof(u16)); 1371 1372 port = find_port_by_id(portdev, 0); 1373 set_console_size(port, rows, cols); 1374 1375 /* 1376 * We'll use this way of resizing only for legacy 1377 * support. For newer userspace 1378 * (VIRTIO_CONSOLE_F_MULTPORT+), use control messages 1379 * to indicate console size changes so that it can be 1380 * done per-port. 1381 */ 1382 resize_console(port); 1383 } 1384} 1385 1386static int init_vqs(struct ports_device *portdev) 1387{ 1388 vq_callback_t **io_callbacks; 1389 char **io_names; 1390 struct virtqueue **vqs; 1391 u32 i, j, nr_ports, nr_queues; 1392 int err; 1393 1394 nr_ports = portdev->config.max_nr_ports; 1395 nr_queues = use_multiport(portdev) ? (nr_ports + 1) * 2 : 2; 1396 1397 vqs = kmalloc(nr_queues * sizeof(struct virtqueue *), GFP_KERNEL); 1398 if (!vqs) { 1399 err = -ENOMEM; 1400 goto fail; 1401 } 1402 io_callbacks = kmalloc(nr_queues * sizeof(vq_callback_t *), GFP_KERNEL); 1403 if (!io_callbacks) { 1404 err = -ENOMEM; 1405 goto free_vqs; 1406 } 1407 io_names = kmalloc(nr_queues * sizeof(char *), GFP_KERNEL); 1408 if (!io_names) { 1409 err = -ENOMEM; 1410 goto free_callbacks; 1411 } 1412 portdev->in_vqs = kmalloc(nr_ports * sizeof(struct virtqueue *), 1413 GFP_KERNEL); 1414 if (!portdev->in_vqs) { 1415 err = -ENOMEM; 1416 goto free_names; 1417 } 1418 portdev->out_vqs = kmalloc(nr_ports * sizeof(struct virtqueue *), 1419 GFP_KERNEL); 1420 if (!portdev->out_vqs) { 1421 err = -ENOMEM; 1422 goto free_invqs; 1423 } 1424 1425 /* 1426 * For backward compat (newer host but older guest), the host 1427 * spawns a console port first and also inits the vqs for port 1428 * 0 before others. 1429 */ 1430 j = 0; 1431 io_callbacks[j] = in_intr; 1432 io_callbacks[j + 1] = out_intr; 1433 io_names[j] = "input"; 1434 io_names[j + 1] = "output"; 1435 j += 2; 1436 1437 if (use_multiport(portdev)) { 1438 io_callbacks[j] = control_intr; 1439 io_callbacks[j + 1] = NULL; 1440 io_names[j] = "control-i"; 1441 io_names[j + 1] = "control-o"; 1442 1443 for (i = 1; i < nr_ports; i++) { 1444 j += 2; 1445 io_callbacks[j] = in_intr; 1446 io_callbacks[j + 1] = out_intr; 1447 io_names[j] = "input"; 1448 io_names[j + 1] = "output"; 1449 } 1450 } 1451 /* Find the queues. */ 1452 err = portdev->vdev->config->find_vqs(portdev->vdev, nr_queues, vqs, 1453 io_callbacks, 1454 (const char **)io_names); 1455 if (err) 1456 goto free_outvqs; 1457 1458 j = 0; 1459 portdev->in_vqs[0] = vqs[0]; 1460 portdev->out_vqs[0] = vqs[1]; 1461 j += 2; 1462 if (use_multiport(portdev)) { 1463 portdev->c_ivq = vqs[j]; 1464 portdev->c_ovq = vqs[j + 1]; 1465 1466 for (i = 1; i < nr_ports; i++) { 1467 j += 2; 1468 portdev->in_vqs[i] = vqs[j]; 1469 portdev->out_vqs[i] = vqs[j + 1]; 1470 } 1471 } 1472 kfree(io_callbacks); 1473 kfree(io_names); 1474 kfree(vqs); 1475 1476 return 0; 1477 1478free_names: 1479 kfree(io_names); 1480free_callbacks: 1481 kfree(io_callbacks); 1482free_outvqs: 1483 kfree(portdev->out_vqs); 1484free_invqs: 1485 kfree(portdev->in_vqs); 1486free_vqs: 1487 kfree(vqs); 1488fail: 1489 return err; 1490} 1491 1492static const struct file_operations portdev_fops = { 1493 .owner = THIS_MODULE, 1494}; 1495 1496/* 1497 * Once we're further in boot, we get probed like any other virtio 1498 * device. 1499 * 1500 * If the host also supports multiple console ports, we check the 1501 * config space to see how many ports the host has spawned. We 1502 * initialize each port found. 1503 */ 1504static int __devinit virtcons_probe(struct virtio_device *vdev) 1505{ 1506 struct ports_device *portdev; 1507 int err; 1508 bool multiport; 1509 1510 portdev = kmalloc(sizeof(*portdev), GFP_KERNEL); 1511 if (!portdev) { 1512 err = -ENOMEM; 1513 goto fail; 1514 } 1515 1516 /* Attach this portdev to this virtio_device, and vice-versa. */ 1517 portdev->vdev = vdev; 1518 vdev->priv = portdev; 1519 1520 spin_lock_irq(&pdrvdata_lock); 1521 portdev->drv_index = pdrvdata.index++; 1522 spin_unlock_irq(&pdrvdata_lock); 1523 1524 portdev->chr_major = register_chrdev(0, "virtio-portsdev", 1525 &portdev_fops); 1526 if (portdev->chr_major < 0) { 1527 dev_err(&vdev->dev, 1528 "Error %d registering chrdev for device %u\n", 1529 portdev->chr_major, portdev->drv_index); 1530 err = portdev->chr_major; 1531 goto free; 1532 } 1533 1534 multiport = false; 1535 portdev->config.max_nr_ports = 1; 1536 if (virtio_has_feature(vdev, VIRTIO_CONSOLE_F_MULTIPORT)) { 1537 multiport = true; 1538 vdev->features[0] |= 1 << VIRTIO_CONSOLE_F_MULTIPORT; 1539 1540 vdev->config->get(vdev, offsetof(struct virtio_console_config, 1541 max_nr_ports), 1542 &portdev->config.max_nr_ports, 1543 sizeof(portdev->config.max_nr_ports)); 1544 } 1545 1546 /* Let the Host know we support multiple ports.*/ 1547 vdev->config->finalize_features(vdev); 1548 1549 err = init_vqs(portdev); 1550 if (err < 0) { 1551 dev_err(&vdev->dev, "Error %d initializing vqs\n", err); 1552 goto free_chrdev; 1553 } 1554 1555 spin_lock_init(&portdev->ports_lock); 1556 INIT_LIST_HEAD(&portdev->ports); 1557 1558 if (multiport) { 1559 unsigned int nr_added_bufs; 1560 1561 spin_lock_init(&portdev->cvq_lock); 1562 INIT_WORK(&portdev->control_work, &control_work_handler); 1563 1564 nr_added_bufs = fill_queue(portdev->c_ivq, &portdev->cvq_lock); 1565 if (!nr_added_bufs) { 1566 dev_err(&vdev->dev, 1567 "Error allocating buffers for control queue\n"); 1568 err = -ENOMEM; 1569 goto free_vqs; 1570 } 1571 } else { 1572 /* 1573 * For backward compatibility: Create a console port 1574 * if we're running on older host. 1575 */ 1576 add_port(portdev, 0); 1577 } 1578 1579 __send_control_msg(portdev, VIRTIO_CONSOLE_BAD_ID, 1580 VIRTIO_CONSOLE_DEVICE_READY, 1); 1581 return 0; 1582 1583free_vqs: 1584 /* The host might want to notify mgmt sw about device add failure */ 1585 __send_control_msg(portdev, VIRTIO_CONSOLE_BAD_ID, 1586 VIRTIO_CONSOLE_DEVICE_READY, 0); 1587 vdev->config->del_vqs(vdev); 1588 kfree(portdev->in_vqs); 1589 kfree(portdev->out_vqs); 1590free_chrdev: 1591 unregister_chrdev(portdev->chr_major, "virtio-portsdev"); 1592free: 1593 kfree(portdev); 1594fail: 1595 return err; 1596} 1597 1598static void virtcons_remove(struct virtio_device *vdev) 1599{ 1600 struct ports_device *portdev; 1601 struct port *port, *port2; 1602 struct port_buffer *buf; 1603 unsigned int len; 1604 1605 portdev = vdev->priv; 1606 1607 cancel_work_sync(&portdev->control_work); 1608 1609 list_for_each_entry_safe(port, port2, &portdev->ports, list) 1610 remove_port(port); 1611 1612 unregister_chrdev(portdev->chr_major, "virtio-portsdev"); 1613 1614 while ((buf = virtqueue_get_buf(portdev->c_ivq, &len))) 1615 free_buf(buf); 1616 1617 while ((buf = virtqueue_detach_unused_buf(portdev->c_ivq))) 1618 free_buf(buf); 1619 1620 vdev->config->del_vqs(vdev); 1621 kfree(portdev->in_vqs); 1622 kfree(portdev->out_vqs); 1623 1624 kfree(portdev); 1625} 1626 1627static struct virtio_device_id id_table[] = { 1628 { VIRTIO_ID_CONSOLE, VIRTIO_DEV_ANY_ID }, 1629 { 0 }, 1630}; 1631 1632static unsigned int features[] = { 1633 VIRTIO_CONSOLE_F_SIZE, 1634 VIRTIO_CONSOLE_F_MULTIPORT, 1635}; 1636 1637static struct virtio_driver virtio_console = { 1638 .feature_table = features, 1639 .feature_table_size = ARRAY_SIZE(features), 1640 .driver.name = KBUILD_MODNAME, 1641 .driver.owner = THIS_MODULE, 1642 .id_table = id_table, 1643 .probe = virtcons_probe, 1644 .remove = virtcons_remove, 1645 .config_changed = config_intr, 1646}; 1647 1648static int __init init(void) 1649{ 1650 int err; 1651 1652 pdrvdata.class = class_create(THIS_MODULE, "virtio-ports"); 1653 if (IS_ERR(pdrvdata.class)) { 1654 err = PTR_ERR(pdrvdata.class); 1655 pr_err("Error %d creating virtio-ports class\n", err); 1656 return err; 1657 } 1658 1659 pdrvdata.debugfs_dir = debugfs_create_dir("virtio-ports", NULL); 1660 if (!pdrvdata.debugfs_dir) { 1661 pr_warning("Error %ld creating debugfs dir for virtio-ports\n", 1662 PTR_ERR(pdrvdata.debugfs_dir)); 1663 } 1664 INIT_LIST_HEAD(&pdrvdata.consoles); 1665 1666 return register_virtio_driver(&virtio_console); 1667} 1668 1669static void __exit fini(void) 1670{ 1671 unregister_virtio_driver(&virtio_console); 1672 1673 class_destroy(pdrvdata.class); 1674 if (pdrvdata.debugfs_dir) 1675 debugfs_remove_recursive(pdrvdata.debugfs_dir); 1676} 1677module_init(init); 1678module_exit(fini); 1679 1680MODULE_DEVICE_TABLE(virtio, id_table); 1681MODULE_DESCRIPTION("Virtio console driver"); 1682MODULE_LICENSE("GPL"); 1683