drivers/char/virtio_console.c

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