2234 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*3 * Copyright (C) 2006, 2007, 2009 Rusty Russell, IBM Corporation4 * Copyright (C) 2009, 2010, 2011 Red Hat, Inc.5 * Copyright (C) 2009, 2010, 2011 Amit Shah <amit.shah@redhat.com>6 */7#include <linux/cdev.h>8#include <linux/debugfs.h>9#include <linux/completion.h>10#include <linux/device.h>11#include <linux/err.h>12#include <linux/freezer.h>13#include <linux/fs.h>14#include <linux/splice.h>15#include <linux/pagemap.h>16#include <linux/idr.h>17#include <linux/init.h>18#include <linux/list.h>19#include <linux/poll.h>20#include <linux/sched.h>21#include <linux/slab.h>22#include <linux/spinlock.h>23#include <linux/virtio.h>24#include <linux/virtio_console.h>25#include <linux/wait.h>26#include <linux/workqueue.h>27#include <linux/module.h>28#include <linux/dma-mapping.h>29#include "../tty/hvc/hvc_console.h"30 31#define is_rproc_enabled IS_ENABLED(CONFIG_REMOTEPROC)32#define VIRTCONS_MAX_PORTS 0x800033 34/*35 * This is a global struct for storing common data for all the devices36 * this driver handles.37 *38 * Mainly, it has a linked list for all the consoles in one place so39 * that callbacks from hvc for get_chars(), put_chars() work properly40 * across multiple devices and multiple ports per device.41 */42struct ports_driver_data {43 /* Used for exporting per-port information to debugfs */44 struct dentry *debugfs_dir;45 46 /* List of all the devices we're handling */47 struct list_head portdevs;48 49 /* All the console devices handled by this driver */50 struct list_head consoles;51};52 53static struct ports_driver_data pdrvdata;54 55static const struct class port_class = {56 .name = "virtio-ports",57};58 59static DEFINE_SPINLOCK(pdrvdata_lock);60static DECLARE_COMPLETION(early_console_added);61 62/* This struct holds information that's relevant only for console ports */63struct console {64 /* We'll place all consoles in a list in the pdrvdata struct */65 struct list_head list;66 67 /* The hvc device associated with this console port */68 struct hvc_struct *hvc;69 70 /* The size of the console */71 struct winsize ws;72 73 /*74 * This number identifies the number that we used to register75 * with hvc in hvc_instantiate() and hvc_alloc(); this is the76 * number passed on by the hvc callbacks to us to77 * differentiate between the other console ports handled by78 * this driver79 */80 u32 vtermno;81};82 83static DEFINE_IDA(vtermno_ida);84 85struct port_buffer {86 char *buf;87 88 /* size of the buffer in *buf above */89 size_t size;90 91 /* used length of the buffer */92 size_t len;93 /* offset in the buf from which to consume data */94 size_t offset;95 96 /* DMA address of buffer */97 dma_addr_t dma;98 99 /* Device we got DMA memory from */100 struct device *dev;101 102 /* List of pending dma buffers to free */103 struct list_head list;104 105 /* If sgpages == 0 then buf is used */106 unsigned int sgpages;107 108 /* sg is used if spages > 0. sg must be the last in is struct */109 struct scatterlist sg[] __counted_by(sgpages);110};111 112/*113 * This is a per-device struct that stores data common to all the114 * ports for that device (vdev->priv).115 */116struct ports_device {117 /* Next portdev in the list, head is in the pdrvdata struct */118 struct list_head list;119 120 /*121 * Workqueue handlers where we process deferred work after122 * notification123 */124 struct work_struct control_work;125 struct work_struct config_work;126 127 struct list_head ports;128 129 /* To protect the list of ports */130 spinlock_t ports_lock;131 132 /* To protect the vq operations for the control channel */133 spinlock_t c_ivq_lock;134 spinlock_t c_ovq_lock;135 136 /* max. number of ports this device can hold */137 u32 max_nr_ports;138 139 /* The virtio device we're associated with */140 struct virtio_device *vdev;141 142 /*143 * A couple of virtqueues for the control channel: one for144 * guest->host transfers, one for host->guest transfers145 */146 struct virtqueue *c_ivq, *c_ovq;147 148 /*149 * A control packet buffer for guest->host requests, protected150 * by c_ovq_lock.151 */152 struct virtio_console_control cpkt;153 154 /* Array of per-port IO virtqueues */155 struct virtqueue **in_vqs, **out_vqs;156 157 /* Major number for this device. Ports will be created as minors. */158 int chr_major;159};160 161struct port_stats {162 unsigned long bytes_sent, bytes_received, bytes_discarded;163};164 165/* This struct holds the per-port data */166struct port {167 /* Next port in the list, head is in the ports_device */168 struct list_head list;169 170 /* Pointer to the parent virtio_console device */171 struct ports_device *portdev;172 173 /* The current buffer from which data has to be fed to readers */174 struct port_buffer *inbuf;175 176 /*177 * To protect the operations on the in_vq associated with this178 * port. Has to be a spinlock because it can be called from179 * interrupt context (get_char()).180 */181 spinlock_t inbuf_lock;182 183 /* Protect the operations on the out_vq. */184 spinlock_t outvq_lock;185 186 /* The IO vqs for this port */187 struct virtqueue *in_vq, *out_vq;188 189 /* File in the debugfs directory that exposes this port's information */190 struct dentry *debugfs_file;191 192 /*193 * Keep count of the bytes sent, received and discarded for194 * this port for accounting and debugging purposes. These195 * counts are not reset across port open / close events.196 */197 struct port_stats stats;198 199 /*200 * The entries in this struct will be valid if this port is201 * hooked up to an hvc console202 */203 struct console cons;204 205 /* Each port associates with a separate char device */206 struct cdev *cdev;207 struct device *dev;208 209 /* Reference-counting to handle port hot-unplugs and file operations */210 struct kref kref;211 212 /* A waitqueue for poll() or blocking read operations */213 wait_queue_head_t waitqueue;214 215 /* The 'name' of the port that we expose via sysfs properties */216 char *name;217 218 /* We can notify apps of host connect / disconnect events via SIGIO */219 struct fasync_struct *async_queue;220 221 /* The 'id' to identify the port with the Host */222 u32 id;223 224 bool outvq_full;225 226 /* Is the host device open */227 bool host_connected;228 229 /* We should allow only one process to open a port */230 bool guest_connected;231};232 233static struct port *find_port_by_vtermno(u32 vtermno)234{235 struct port *port;236 struct console *cons;237 unsigned long flags;238 239 spin_lock_irqsave(&pdrvdata_lock, flags);240 list_for_each_entry(cons, &pdrvdata.consoles, list) {241 if (cons->vtermno == vtermno) {242 port = container_of(cons, struct port, cons);243 goto out;244 }245 }246 port = NULL;247out:248 spin_unlock_irqrestore(&pdrvdata_lock, flags);249 return port;250}251 252static struct port *find_port_by_devt_in_portdev(struct ports_device *portdev,253 dev_t dev)254{255 struct port *port;256 unsigned long flags;257 258 spin_lock_irqsave(&portdev->ports_lock, flags);259 list_for_each_entry(port, &portdev->ports, list) {260 if (port->cdev->dev == dev) {261 kref_get(&port->kref);262 goto out;263 }264 }265 port = NULL;266out:267 spin_unlock_irqrestore(&portdev->ports_lock, flags);268 269 return port;270}271 272static struct port *find_port_by_devt(dev_t dev)273{274 struct ports_device *portdev;275 struct port *port;276 unsigned long flags;277 278 spin_lock_irqsave(&pdrvdata_lock, flags);279 list_for_each_entry(portdev, &pdrvdata.portdevs, list) {280 port = find_port_by_devt_in_portdev(portdev, dev);281 if (port)282 goto out;283 }284 port = NULL;285out:286 spin_unlock_irqrestore(&pdrvdata_lock, flags);287 return port;288}289 290static struct port *find_port_by_id(struct ports_device *portdev, u32 id)291{292 struct port *port;293 unsigned long flags;294 295 spin_lock_irqsave(&portdev->ports_lock, flags);296 list_for_each_entry(port, &portdev->ports, list)297 if (port->id == id)298 goto out;299 port = NULL;300out:301 spin_unlock_irqrestore(&portdev->ports_lock, flags);302 303 return port;304}305 306static struct port *find_port_by_vq(struct ports_device *portdev,307 struct virtqueue *vq)308{309 struct port *port;310 unsigned long flags;311 312 spin_lock_irqsave(&portdev->ports_lock, flags);313 list_for_each_entry(port, &portdev->ports, list)314 if (port->in_vq == vq || port->out_vq == vq)315 goto out;316 port = NULL;317out:318 spin_unlock_irqrestore(&portdev->ports_lock, flags);319 return port;320}321 322static bool is_console_port(struct port *port)323{324 if (port->cons.hvc)325 return true;326 return false;327}328 329static bool is_rproc_serial(const struct virtio_device *vdev)330{331 return is_rproc_enabled && vdev->id.device == VIRTIO_ID_RPROC_SERIAL;332}333 334static inline bool use_multiport(struct ports_device *portdev)335{336 /*337 * This condition can be true when put_chars is called from338 * early_init339 */340 if (!portdev->vdev)341 return false;342 return __virtio_test_bit(portdev->vdev, VIRTIO_CONSOLE_F_MULTIPORT);343}344 345static DEFINE_SPINLOCK(dma_bufs_lock);346static LIST_HEAD(pending_free_dma_bufs);347 348static void free_buf(struct port_buffer *buf, bool can_sleep)349{350 unsigned int i;351 352 for (i = 0; i < buf->sgpages; i++) {353 struct page *page = sg_page(&buf->sg[i]);354 if (!page)355 break;356 put_page(page);357 }358 359 if (!buf->dev) {360 kfree(buf->buf);361 } else if (is_rproc_enabled) {362 unsigned long flags;363 364 /* dma_free_coherent requires interrupts to be enabled. */365 if (!can_sleep) {366 /* queue up dma-buffers to be freed later */367 spin_lock_irqsave(&dma_bufs_lock, flags);368 list_add_tail(&buf->list, &pending_free_dma_bufs);369 spin_unlock_irqrestore(&dma_bufs_lock, flags);370 return;371 }372 dma_free_coherent(buf->dev, buf->size, buf->buf, buf->dma);373 374 /* Release device refcnt and allow it to be freed */375 put_device(buf->dev);376 }377 378 kfree(buf);379}380 381static void reclaim_dma_bufs(void)382{383 unsigned long flags;384 struct port_buffer *buf, *tmp;385 LIST_HEAD(tmp_list);386 387 if (list_empty(&pending_free_dma_bufs))388 return;389 390 /* Create a copy of the pending_free_dma_bufs while holding the lock */391 spin_lock_irqsave(&dma_bufs_lock, flags);392 list_cut_position(&tmp_list, &pending_free_dma_bufs,393 pending_free_dma_bufs.prev);394 spin_unlock_irqrestore(&dma_bufs_lock, flags);395 396 /* Release the dma buffers, without irqs enabled */397 list_for_each_entry_safe(buf, tmp, &tmp_list, list) {398 list_del(&buf->list);399 free_buf(buf, true);400 }401}402 403static struct port_buffer *alloc_buf(struct virtio_device *vdev, size_t buf_size,404 int pages)405{406 struct port_buffer *buf;407 408 reclaim_dma_bufs();409 410 /*411 * Allocate buffer and the sg list. The sg list array is allocated412 * directly after the port_buffer struct.413 */414 buf = kmalloc(struct_size(buf, sg, pages), GFP_KERNEL);415 if (!buf)416 goto fail;417 418 buf->sgpages = pages;419 if (pages > 0) {420 buf->dev = NULL;421 buf->buf = NULL;422 return buf;423 }424 425 if (is_rproc_serial(vdev)) {426 /*427 * Allocate DMA memory from ancestor. When a virtio428 * device is created by remoteproc, the DMA memory is429 * associated with the parent device:430 * virtioY => remoteprocX#vdevYbuffer.431 */432 buf->dev = vdev->dev.parent;433 if (!buf->dev)434 goto free_buf;435 436 /* Increase device refcnt to avoid freeing it */437 get_device(buf->dev);438 buf->buf = dma_alloc_coherent(buf->dev, buf_size, &buf->dma,439 GFP_KERNEL);440 } else {441 buf->dev = NULL;442 buf->buf = kmalloc(buf_size, GFP_KERNEL);443 }444 445 if (!buf->buf)446 goto free_buf;447 buf->len = 0;448 buf->offset = 0;449 buf->size = buf_size;450 return buf;451 452free_buf:453 kfree(buf);454fail:455 return NULL;456}457 458/* Callers should take appropriate locks */459static struct port_buffer *get_inbuf(struct port *port)460{461 struct port_buffer *buf;462 unsigned int len;463 464 if (port->inbuf)465 return port->inbuf;466 467 buf = virtqueue_get_buf(port->in_vq, &len);468 if (buf) {469 buf->len = min_t(size_t, len, buf->size);470 buf->offset = 0;471 port->stats.bytes_received += len;472 }473 return buf;474}475 476/*477 * Create a scatter-gather list representing our input buffer and put478 * it in the queue.479 *480 * Callers should take appropriate locks.481 */482static int add_inbuf(struct virtqueue *vq, struct port_buffer *buf)483{484 struct scatterlist sg[1];485 int ret;486 487 sg_init_one(sg, buf->buf, buf->size);488 489 ret = virtqueue_add_inbuf(vq, sg, 1, buf, GFP_ATOMIC);490 virtqueue_kick(vq);491 if (!ret)492 ret = vq->num_free;493 return ret;494}495 496/* Discard any unread data this port has. Callers lockers. */497static void discard_port_data(struct port *port)498{499 struct port_buffer *buf;500 unsigned int err;501 502 if (!port->portdev) {503 /* Device has been unplugged. vqs are already gone. */504 return;505 }506 buf = get_inbuf(port);507 508 err = 0;509 while (buf) {510 port->stats.bytes_discarded += buf->len - buf->offset;511 if (add_inbuf(port->in_vq, buf) < 0) {512 err++;513 free_buf(buf, false);514 }515 port->inbuf = NULL;516 buf = get_inbuf(port);517 }518 if (err)519 dev_warn(port->dev, "Errors adding %d buffers back to vq\n",520 err);521}522 523static bool port_has_data(struct port *port)524{525 unsigned long flags;526 bool ret;527 528 ret = false;529 spin_lock_irqsave(&port->inbuf_lock, flags);530 port->inbuf = get_inbuf(port);531 if (port->inbuf)532 ret = true;533 534 spin_unlock_irqrestore(&port->inbuf_lock, flags);535 return ret;536}537 538static ssize_t __send_control_msg(struct ports_device *portdev, u32 port_id,539 unsigned int event, unsigned int value)540{541 struct scatterlist sg[1];542 struct virtqueue *vq;543 unsigned int len;544 545 if (!use_multiport(portdev))546 return 0;547 548 vq = portdev->c_ovq;549 550 spin_lock(&portdev->c_ovq_lock);551 552 portdev->cpkt.id = cpu_to_virtio32(portdev->vdev, port_id);553 portdev->cpkt.event = cpu_to_virtio16(portdev->vdev, event);554 portdev->cpkt.value = cpu_to_virtio16(portdev->vdev, value);555 556 sg_init_one(sg, &portdev->cpkt, sizeof(struct virtio_console_control));557 558 if (virtqueue_add_outbuf(vq, sg, 1, &portdev->cpkt, GFP_ATOMIC) == 0) {559 virtqueue_kick(vq);560 while (!virtqueue_get_buf(vq, &len)561 && !virtqueue_is_broken(vq))562 cpu_relax();563 }564 565 spin_unlock(&portdev->c_ovq_lock);566 return 0;567}568 569static ssize_t send_control_msg(struct port *port, unsigned int event,570 unsigned int value)571{572 /* Did the port get unplugged before userspace closed it? */573 if (port->portdev)574 return __send_control_msg(port->portdev, port->id, event, value);575 return 0;576}577 578 579/* Callers must take the port->outvq_lock */580static void reclaim_consumed_buffers(struct port *port)581{582 struct port_buffer *buf;583 unsigned int len;584 585 if (!port->portdev) {586 /* Device has been unplugged. vqs are already gone. */587 return;588 }589 while ((buf = virtqueue_get_buf(port->out_vq, &len))) {590 free_buf(buf, false);591 port->outvq_full = false;592 }593}594 595static ssize_t __send_to_port(struct port *port, struct scatterlist *sg,596 int nents, size_t in_count,597 void *data, bool nonblock)598{599 struct virtqueue *out_vq;600 int err;601 unsigned long flags;602 unsigned int len;603 604 out_vq = port->out_vq;605 606 spin_lock_irqsave(&port->outvq_lock, flags);607 608 reclaim_consumed_buffers(port);609 610 err = virtqueue_add_outbuf(out_vq, sg, nents, data, GFP_ATOMIC);611 612 /* Tell Host to go! */613 virtqueue_kick(out_vq);614 615 if (err) {616 in_count = 0;617 goto done;618 }619 620 if (out_vq->num_free == 0)621 port->outvq_full = true;622 623 if (nonblock)624 goto done;625 626 /*627 * Wait till the host acknowledges it pushed out the data we628 * sent. This is done for data from the hvc_console; the tty629 * operations are performed with spinlocks held so we can't630 * sleep here. An alternative would be to copy the data to a631 * buffer and relax the spinning requirement. The downside is632 * we need to kmalloc a GFP_ATOMIC buffer each time the633 * console driver writes something out.634 */635 while (!virtqueue_get_buf(out_vq, &len)636 && !virtqueue_is_broken(out_vq))637 cpu_relax();638done:639 spin_unlock_irqrestore(&port->outvq_lock, flags);640 641 port->stats.bytes_sent += in_count;642 /*643 * We're expected to return the amount of data we wrote -- all644 * of it645 */646 return in_count;647}648 649/*650 * Give out the data that's requested from the buffer that we have651 * queued up.652 */653static ssize_t fill_readbuf(struct port *port, u8 __user *out_buf,654 size_t out_count, bool to_user)655{656 struct port_buffer *buf;657 unsigned long flags;658 659 if (!out_count || !port_has_data(port))660 return 0;661 662 buf = port->inbuf;663 out_count = min(out_count, buf->len - buf->offset);664 665 if (to_user) {666 ssize_t ret;667 668 ret = copy_to_user(out_buf, buf->buf + buf->offset, out_count);669 if (ret)670 return -EFAULT;671 } else {672 memcpy((__force u8 *)out_buf, buf->buf + buf->offset,673 out_count);674 }675 676 buf->offset += out_count;677 678 if (buf->offset == buf->len) {679 /*680 * We're done using all the data in this buffer.681 * Re-queue so that the Host can send us more data.682 */683 spin_lock_irqsave(&port->inbuf_lock, flags);684 port->inbuf = NULL;685 686 if (add_inbuf(port->in_vq, buf) < 0)687 dev_warn(port->dev, "failed add_buf\n");688 689 spin_unlock_irqrestore(&port->inbuf_lock, flags);690 }691 /* Return the number of bytes actually copied */692 return out_count;693}694 695/* The condition that must be true for polling to end */696static bool will_read_block(struct port *port)697{698 if (!port->guest_connected) {699 /* Port got hot-unplugged. Let's exit. */700 return false;701 }702 return !port_has_data(port) && port->host_connected;703}704 705static bool will_write_block(struct port *port)706{707 bool ret;708 709 if (!port->guest_connected) {710 /* Port got hot-unplugged. Let's exit. */711 return false;712 }713 if (!port->host_connected)714 return true;715 716 spin_lock_irq(&port->outvq_lock);717 /*718 * Check if the Host has consumed any buffers since we last719 * sent data (this is only applicable for nonblocking ports).720 */721 reclaim_consumed_buffers(port);722 ret = port->outvq_full;723 spin_unlock_irq(&port->outvq_lock);724 725 return ret;726}727 728static HWJS_SUSPENDS ssize_t port_fops_read(struct file *filp, char __user *ubuf,729 size_t count, loff_t *offp)730{731 struct port *port;732 ssize_t ret;733 734 port = filp->private_data;735 736 /* Port is hot-unplugged. */737 if (!port->guest_connected)738 return -ENODEV;739 740 if (!port_has_data(port)) {741 /*742 * If nothing's connected on the host just return 0 in743 * case of list_empty; this tells the userspace app744 * that there's no connection745 */746 if (!port->host_connected)747 return 0;748 if (filp->f_flags & O_NONBLOCK)749 return -EAGAIN;750 751 ret = wait_event_freezable(port->waitqueue,752 !will_read_block(port));753 if (ret < 0)754 return ret;755 }756 /* Port got hot-unplugged while we were waiting above. */757 if (!port->guest_connected)758 return -ENODEV;759 /*760 * We could've received a disconnection message while we were761 * waiting for more data.762 *763 * This check is not clubbed in the if() statement above as we764 * might receive some data as well as the host could get765 * disconnected after we got woken up from our wait. So we766 * really want to give off whatever data we have and only then767 * check for host_connected.768 */769 if (!port_has_data(port) && !port->host_connected)770 return 0;771 772 return fill_readbuf(port, ubuf, count, true);773}774 775static HWJS_SUSPENDS int wait_port_writable(struct port *port, bool nonblock)776{777 int ret;778 779 if (will_write_block(port)) {780 if (nonblock)781 return -EAGAIN;782 783 ret = wait_event_freezable(port->waitqueue,784 !will_write_block(port));785 if (ret < 0)786 return ret;787 }788 /* Port got hot-unplugged. */789 if (!port->guest_connected)790 return -ENODEV;791 792 return 0;793}794 795static HWJS_SUSPENDS ssize_t port_fops_write(struct file *filp, const char __user *ubuf,796 size_t count, loff_t *offp)797{798 struct port *port;799 struct port_buffer *buf;800 ssize_t ret;801 bool nonblock;802 struct scatterlist sg[1];803 804 /* Userspace could be out to fool us */805 if (!count)806 return 0;807 808 port = filp->private_data;809 810 nonblock = filp->f_flags & O_NONBLOCK;811 812 ret = wait_port_writable(port, nonblock);813 if (ret < 0)814 return ret;815 816 count = min((size_t)(32 * 1024), count);817 818 buf = alloc_buf(port->portdev->vdev, count, 0);819 if (!buf)820 return -ENOMEM;821 822 ret = copy_from_user(buf->buf, ubuf, count);823 if (ret) {824 ret = -EFAULT;825 goto free_buf;826 }827 828 /*829 * We now ask send_buf() to not spin for generic ports -- we830 * can re-use the same code path that non-blocking file831 * descriptors take for blocking file descriptors since the832 * wait is already done and we're certain the write will go833 * through to the host.834 */835 nonblock = true;836 sg_init_one(sg, buf->buf, count);837 ret = __send_to_port(port, sg, 1, count, buf, nonblock);838 839 if (nonblock && ret > 0)840 goto out;841 842free_buf:843 free_buf(buf, true);844out:845 return ret;846}847 848struct sg_list {849 unsigned int n;850 unsigned int size;851 size_t len;852 struct scatterlist *sg;853};854 855static HWJS_SUSPENDS int pipe_to_sg(struct pipe_inode_info *pipe, struct pipe_buffer *buf,856 struct splice_desc *sd)857{858 struct sg_list *sgl = sd->u.data;859 unsigned int offset, len;860 861 if (sgl->n == sgl->size)862 return 0;863 864 /* Try lock this page */865 if (pipe_buf_try_steal(pipe, buf)) {866 /* Get reference and unlock page for moving */867 get_page(buf->page);868 unlock_page(buf->page);869 870 len = min(buf->len, sd->len);871 sg_set_page(&(sgl->sg[sgl->n]), buf->page, len, buf->offset);872 } else {873 /* Failback to copying a page */874 struct page *page = alloc_page(GFP_KERNEL);875 char *src;876 877 if (!page)878 return -ENOMEM;879 880 offset = sd->pos & ~PAGE_MASK;881 882 len = sd->len;883 if (len + offset > PAGE_SIZE)884 len = PAGE_SIZE - offset;885 886 src = kmap_atomic(buf->page);887 memcpy(page_address(page) + offset, src + buf->offset, len);888 kunmap_atomic(src);889 890 sg_set_page(&(sgl->sg[sgl->n]), page, len, offset);891 }892 sgl->n++;893 sgl->len += len;894 895 return len;896}897 898/* Faster zero-copy write by splicing */899static HWJS_SUSPENDS ssize_t port_fops_splice_write(struct pipe_inode_info *pipe,900 struct file *filp, loff_t *ppos,901 size_t len, unsigned int flags)902{903 struct port *port = filp->private_data;904 struct sg_list sgl;905 ssize_t ret;906 struct port_buffer *buf;907 struct splice_desc sd = {908 .total_len = len,909 .flags = flags,910 .pos = *ppos,911 .u.data = &sgl,912 };913 unsigned int occupancy;914 915 /*916 * Rproc_serial does not yet support splice. To support splice917 * pipe_to_sg() must allocate dma-buffers and copy content from918 * regular pages to dma pages. And alloc_buf and free_buf must919 * support allocating and freeing such a list of dma-buffers.920 */921 if (is_rproc_serial(port->out_vq->vdev))922 return -EINVAL;923 924 pipe_lock(pipe);925 ret = 0;926 if (pipe_empty(pipe->head, pipe->tail))927 goto error_out;928 929 ret = wait_port_writable(port, filp->f_flags & O_NONBLOCK);930 if (ret < 0)931 goto error_out;932 933 occupancy = pipe_occupancy(pipe->head, pipe->tail);934 buf = alloc_buf(port->portdev->vdev, 0, occupancy);935 936 if (!buf) {937 ret = -ENOMEM;938 goto error_out;939 }940 941 sgl.n = 0;942 sgl.len = 0;943 sgl.size = occupancy;944 sgl.sg = buf->sg;945 sg_init_table(sgl.sg, sgl.size);946 ret = __splice_from_pipe(pipe, &sd, pipe_to_sg);947 pipe_unlock(pipe);948 if (likely(ret > 0))949 ret = __send_to_port(port, buf->sg, sgl.n, sgl.len, buf, true);950 951 if (unlikely(ret <= 0))952 free_buf(buf, true);953 return ret;954 955error_out:956 pipe_unlock(pipe);957 return ret;958}959 960static HWJS_SUSPENDS __poll_t port_fops_poll(struct file *filp, poll_table *wait)961{962 struct port *port;963 __poll_t ret;964 965 port = filp->private_data;966 poll_wait(filp, &port->waitqueue, wait);967 968 if (!port->guest_connected) {969 /* Port got unplugged */970 return EPOLLHUP;971 }972 ret = 0;973 if (!will_read_block(port))974 ret |= EPOLLIN | EPOLLRDNORM;975 if (!will_write_block(port))976 ret |= EPOLLOUT;977 if (!port->host_connected)978 ret |= EPOLLHUP;979 980 return ret;981}982 983static void remove_port(struct kref *kref);984 985static HWJS_SUSPENDS int port_fops_release(struct inode *inode, struct file *filp)986{987 struct port *port;988 989 port = filp->private_data;990 991 /* Notify host of port being closed */992 send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 0);993 994 spin_lock_irq(&port->inbuf_lock);995 port->guest_connected = false;996 997 discard_port_data(port);998 999 spin_unlock_irq(&port->inbuf_lock);1000 1001 spin_lock_irq(&port->outvq_lock);1002 reclaim_consumed_buffers(port);1003 spin_unlock_irq(&port->outvq_lock);1004 1005 reclaim_dma_bufs();1006 /*1007 * Locks aren't necessary here as a port can't be opened after1008 * unplug, and if a port isn't unplugged, a kref would already1009 * exist for the port. Plus, taking ports_lock here would1010 * create a dependency on other locks taken by functions1011 * inside remove_port if we're the last holder of the port,1012 * creating many problems.1013 */1014 kref_put(&port->kref, remove_port);1015 1016 return 0;1017}1018 1019static HWJS_SUSPENDS int port_fops_open(struct inode *inode, struct file *filp)1020{1021 struct cdev *cdev = inode->i_cdev;1022 struct port *port;1023 int ret;1024 1025 /* We get the port with a kref here */1026 port = find_port_by_devt(cdev->dev);1027 if (!port) {1028 /* Port was unplugged before we could proceed */1029 return -ENXIO;1030 }1031 filp->private_data = port;1032 1033 /*1034 * Don't allow opening of console port devices -- that's done1035 * via /dev/hvc1036 */1037 if (is_console_port(port)) {1038 ret = -ENXIO;1039 goto out;1040 }1041 1042 /* Allow only one process to open a particular port at a time */1043 spin_lock_irq(&port->inbuf_lock);1044 if (port->guest_connected) {1045 spin_unlock_irq(&port->inbuf_lock);1046 ret = -EBUSY;1047 goto out;1048 }1049 1050 port->guest_connected = true;1051 spin_unlock_irq(&port->inbuf_lock);1052 1053 spin_lock_irq(&port->outvq_lock);1054 /*1055 * There might be a chance that we missed reclaiming a few1056 * buffers in the window of the port getting previously closed1057 * and opening now.1058 */1059 reclaim_consumed_buffers(port);1060 spin_unlock_irq(&port->outvq_lock);1061 1062 nonseekable_open(inode, filp);1063 1064 /* Notify host of port being opened */1065 send_control_msg(filp->private_data, VIRTIO_CONSOLE_PORT_OPEN, 1);1066 1067 return 0;1068out:1069 kref_put(&port->kref, remove_port);1070 return ret;1071}1072 1073static int port_fops_fasync(int fd, struct file *filp, int mode)1074{1075 struct port *port;1076 1077 port = filp->private_data;1078 return fasync_helper(fd, filp, mode, &port->async_queue);1079}1080 1081/*1082 * The file operations that we support: programs in the guest can open1083 * a console device, read from it, write to it, poll for data and1084 * close it. The devices are at1085 * /dev/vport<device number>p<port number>1086 */1087static const struct file_operations port_fops = {1088 .owner = THIS_MODULE,1089 .open = port_fops_open,1090 .read = port_fops_read,1091 .write = port_fops_write,1092 .splice_write = port_fops_splice_write,1093 .poll = port_fops_poll,1094 .release = port_fops_release,1095 .fasync = port_fops_fasync,1096};1097 1098/*1099 * The put_chars() callback is pretty straightforward.1100 *1101 * We turn the characters into a scatter-gather list, add it to the1102 * output queue and then kick the Host. Then we sit here waiting for1103 * it to finish: inefficient in theory, but in practice1104 * implementations will do it immediately.1105 */1106static ssize_t put_chars(u32 vtermno, const u8 *buf, size_t count)1107{1108 struct port *port;1109 struct scatterlist sg[1];1110 void *data;1111 int ret;1112 1113 port = find_port_by_vtermno(vtermno);1114 if (!port)1115 return -EPIPE;1116 1117 data = kmemdup(buf, count, GFP_ATOMIC);1118 if (!data)1119 return -ENOMEM;1120 1121 sg_init_one(sg, data, count);1122 ret = __send_to_port(port, sg, 1, count, data, false);1123 kfree(data);1124 return ret;1125}1126 1127/*1128 * get_chars() is the callback from the hvc_console infrastructure1129 * when an interrupt is received.1130 *1131 * We call out to fill_readbuf that gets us the required data from the1132 * buffers that are queued up.1133 */1134static ssize_t get_chars(u32 vtermno, u8 *buf, size_t count)1135{1136 struct port *port;1137 1138 port = find_port_by_vtermno(vtermno);1139 if (!port)1140 return -EPIPE;1141 1142 /* If we don't have an input queue yet, we can't get input. */1143 BUG_ON(!port->in_vq);1144 1145 return fill_readbuf(port, (__force u8 __user *)buf, count, false);1146}1147 1148static HWJS_SUSPENDS void resize_console(struct port *port)1149{1150 struct virtio_device *vdev;1151 1152 /* The port could have been hot-unplugged */1153 if (!port || !is_console_port(port))1154 return;1155 1156 vdev = port->portdev->vdev;1157 1158 /* Don't test F_SIZE at all if we're rproc: not a valid feature! */1159 if (!is_rproc_serial(vdev) &&1160 virtio_has_feature(vdev, VIRTIO_CONSOLE_F_SIZE))1161 hvc_resize(port->cons.hvc, port->cons.ws);1162}1163 1164/* We set the configuration at this point, since we now have a tty */1165static HWJS_SUSPENDS int notifier_add_vio(struct hvc_struct *hp, int data)1166{1167 struct port *port;1168 1169 port = find_port_by_vtermno(hp->vtermno);1170 if (!port)1171 return -EINVAL;1172 1173 hp->irq_requested = 1;1174 resize_console(port);1175 1176 return 0;1177}1178 1179static void notifier_del_vio(struct hvc_struct *hp, int data)1180{1181 hp->irq_requested = 0;1182}1183 1184/* The operations for console ports. */1185static const struct hv_ops hv_ops = {1186 .get_chars = get_chars,1187 .put_chars = put_chars,1188 .notifier_add = notifier_add_vio,1189 .notifier_del = notifier_del_vio,1190 .notifier_hangup = notifier_del_vio,1191};1192 1193static HWJS_SUSPENDS int init_port_console(struct port *port)1194{1195 int ret;1196 1197 /*1198 * The Host's telling us this port is a console port. Hook it1199 * up with an hvc console.1200 *1201 * To set up and manage our virtual console, we call1202 * hvc_alloc().1203 *1204 * The first argument of hvc_alloc() is the virtual console1205 * number. The second argument is the parameter for the1206 * notification mechanism (like irq number). We currently1207 * leave this as zero, virtqueues have implicit notifications.1208 *1209 * The third argument is a "struct hv_ops" containing the1210 * put_chars() get_chars(), notifier_add() and notifier_del()1211 * pointers. The final argument is the output buffer size: we1212 * can do any size, so we put PAGE_SIZE here.1213 */1214 ret = ida_alloc_min(&vtermno_ida, 1, GFP_KERNEL);1215 if (ret < 0)1216 return ret;1217 1218 port->cons.vtermno = ret;1219 port->cons.hvc = hvc_alloc(port->cons.vtermno, 0, &hv_ops, PAGE_SIZE);1220 if (IS_ERR(port->cons.hvc)) {1221 ret = PTR_ERR(port->cons.hvc);1222 dev_err(port->dev,1223 "error %d allocating hvc for port\n", ret);1224 port->cons.hvc = NULL;1225 ida_free(&vtermno_ida, port->cons.vtermno);1226 return ret;1227 }1228 spin_lock_irq(&pdrvdata_lock);1229 list_add_tail(&port->cons.list, &pdrvdata.consoles);1230 spin_unlock_irq(&pdrvdata_lock);1231 port->guest_connected = true;1232 1233 /* Notify host of port being opened */1234 send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 1);1235 1236 return 0;1237}1238 1239static ssize_t show_port_name(struct device *dev,1240 struct device_attribute *attr, char *buffer)1241{1242 struct port *port;1243 1244 port = dev_get_drvdata(dev);1245 1246 return sprintf(buffer, "%s\n", port->name);1247}1248 1249static DEVICE_ATTR(name, S_IRUGO, show_port_name, NULL);1250 1251static struct attribute *port_sysfs_entries[] = {1252 &dev_attr_name.attr,1253 NULL1254};1255 1256static const struct attribute_group port_attribute_group = {1257 .name = NULL, /* put in device directory */1258 .attrs = port_sysfs_entries,1259};1260 1261static int port_debugfs_show(struct seq_file *s, void *data)1262{1263 struct port *port = s->private;1264 1265 seq_printf(s, "name: %s\n", port->name ? port->name : "");1266 seq_printf(s, "guest_connected: %d\n", port->guest_connected);1267 seq_printf(s, "host_connected: %d\n", port->host_connected);1268 seq_printf(s, "outvq_full: %d\n", port->outvq_full);1269 seq_printf(s, "bytes_sent: %lu\n", port->stats.bytes_sent);1270 seq_printf(s, "bytes_received: %lu\n", port->stats.bytes_received);1271 seq_printf(s, "bytes_discarded: %lu\n", port->stats.bytes_discarded);1272 seq_printf(s, "is_console: %s\n",1273 is_console_port(port) ? "yes" : "no");1274 seq_printf(s, "console_vtermno: %u\n", port->cons.vtermno);1275 1276 return 0;1277}1278 1279DEFINE_SHOW_ATTRIBUTE(port_debugfs);1280 1281static void set_console_size(struct port *port, u16 rows, u16 cols)1282{1283 if (!port || !is_console_port(port))1284 return;1285 1286 port->cons.ws.ws_row = rows;1287 port->cons.ws.ws_col = cols;1288}1289 1290static int fill_queue(struct virtqueue *vq, spinlock_t *lock)1291{1292 struct port_buffer *buf;1293 int nr_added_bufs;1294 int ret;1295 1296 nr_added_bufs = 0;1297 do {1298 buf = alloc_buf(vq->vdev, PAGE_SIZE, 0);1299 if (!buf)1300 return -ENOMEM;1301 1302 spin_lock_irq(lock);1303 ret = add_inbuf(vq, buf);1304 if (ret < 0) {1305 spin_unlock_irq(lock);1306 free_buf(buf, true);1307 return ret;1308 }1309 nr_added_bufs++;1310 spin_unlock_irq(lock);1311 } while (ret > 0);1312 1313 return nr_added_bufs;1314}1315 1316static void send_sigio_to_port(struct port *port)1317{1318 if (port->async_queue && port->guest_connected)1319 kill_fasync(&port->async_queue, SIGIO, POLL_OUT);1320}1321 1322static HWJS_SUSPENDS int add_port(struct ports_device *portdev, u32 id)1323{1324 char debugfs_name[16];1325 struct port *port;1326 dev_t devt;1327 int err;1328 1329 port = kmalloc(sizeof(*port), GFP_KERNEL);1330 if (!port) {1331 err = -ENOMEM;1332 goto fail;1333 }1334 kref_init(&port->kref);1335 1336 port->portdev = portdev;1337 port->id = id;1338 1339 port->name = NULL;1340 port->inbuf = NULL;1341 port->cons.hvc = NULL;1342 port->async_queue = NULL;1343 1344 port->cons.ws.ws_row = port->cons.ws.ws_col = 0;1345 port->cons.vtermno = 0;1346 1347 port->host_connected = port->guest_connected = false;1348 port->stats = (struct port_stats) { 0 };1349 1350 port->outvq_full = false;1351 1352 port->in_vq = portdev->in_vqs[port->id];1353 port->out_vq = portdev->out_vqs[port->id];1354 1355 port->cdev = cdev_alloc();1356 if (!port->cdev) {1357 dev_err(&port->portdev->vdev->dev, "Error allocating cdev\n");1358 err = -ENOMEM;1359 goto free_port;1360 }1361 port->cdev->ops = &port_fops;1362 1363 devt = MKDEV(portdev->chr_major, id);1364 err = cdev_add(port->cdev, devt, 1);1365 if (err < 0) {1366 dev_err(&port->portdev->vdev->dev,1367 "Error %d adding cdev for port %u\n", err, id);1368 goto free_cdev;1369 }1370 port->dev = device_create(&port_class, &port->portdev->vdev->dev,1371 devt, port, "vport%up%u",1372 port->portdev->vdev->index, id);1373 if (IS_ERR(port->dev)) {1374 err = PTR_ERR(port->dev);1375 dev_err(&port->portdev->vdev->dev,1376 "Error %d creating device for port %u\n",1377 err, id);1378 goto free_cdev;1379 }1380 1381 spin_lock_init(&port->inbuf_lock);1382 spin_lock_init(&port->outvq_lock);1383 init_waitqueue_head(&port->waitqueue);1384 1385 /* We can safely ignore ENOSPC because it means1386 * the queue already has buffers. Buffers are removed1387 * only by virtcons_remove(), not by unplug_port()1388 */1389 err = fill_queue(port->in_vq, &port->inbuf_lock);1390 if (err < 0 && err != -ENOSPC) {1391 dev_err(port->dev, "Error allocating inbufs\n");1392 goto free_device;1393 }1394 1395 if (is_rproc_serial(port->portdev->vdev))1396 /*1397 * For rproc_serial assume remote processor is connected.1398 * rproc_serial does not want the console port, only1399 * the generic port implementation.1400 */1401 port->host_connected = true;1402 else if (!use_multiport(port->portdev)) {1403 /*1404 * If we're not using multiport support,1405 * this has to be a console port.1406 */1407 err = init_port_console(port);1408 if (err)1409 goto free_inbufs;1410 }1411 1412 spin_lock_irq(&portdev->ports_lock);1413 list_add_tail(&port->list, &port->portdev->ports);1414 spin_unlock_irq(&portdev->ports_lock);1415 1416 /*1417 * Tell the Host we're set so that it can send us various1418 * configuration parameters for this port (eg, port name,1419 * caching, whether this is a console port, etc.)1420 */1421 send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1);1422 1423 /*1424 * Finally, create the debugfs file that we can use to1425 * inspect a port's state at any time1426 */1427 snprintf(debugfs_name, sizeof(debugfs_name), "vport%up%u",1428 port->portdev->vdev->index, id);1429 port->debugfs_file = debugfs_create_file(debugfs_name, 0444,1430 pdrvdata.debugfs_dir,1431 port, &port_debugfs_fops);1432 return 0;1433 1434free_inbufs:1435free_device:1436 device_destroy(&port_class, port->dev->devt);1437free_cdev:1438 cdev_del(port->cdev);1439free_port:1440 kfree(port);1441fail:1442 /* The host might want to notify management sw about port add failure */1443 __send_control_msg(portdev, id, VIRTIO_CONSOLE_PORT_READY, 0);1444 return err;1445}1446 1447/* No users remain, remove all port-specific data. */1448static void remove_port(struct kref *kref)1449{1450 struct port *port;1451 1452 port = container_of(kref, struct port, kref);1453 1454 kfree(port);1455}1456 1457static void remove_port_data(struct port *port)1458{1459 spin_lock_irq(&port->inbuf_lock);1460 /* Remove unused data this port might have received. */1461 discard_port_data(port);1462 spin_unlock_irq(&port->inbuf_lock);1463 1464 spin_lock_irq(&port->outvq_lock);1465 reclaim_consumed_buffers(port);1466 spin_unlock_irq(&port->outvq_lock);1467}1468 1469/*1470 * Port got unplugged. Remove port from portdev's list and drop the1471 * kref reference. If no userspace has this port opened, it will1472 * result in immediate removal the port.1473 */1474static HWJS_SUSPENDS void unplug_port(struct port *port)1475{1476 spin_lock_irq(&port->portdev->ports_lock);1477 list_del(&port->list);1478 spin_unlock_irq(&port->portdev->ports_lock);1479 1480 spin_lock_irq(&port->inbuf_lock);1481 if (port->guest_connected) {1482 /* Let the app know the port is going down. */1483 send_sigio_to_port(port);1484 1485 /* Do this after sigio is actually sent */1486 port->guest_connected = false;1487 port->host_connected = false;1488 1489 wake_up_interruptible(&port->waitqueue);1490 }1491 spin_unlock_irq(&port->inbuf_lock);1492 1493 if (is_console_port(port)) {1494 spin_lock_irq(&pdrvdata_lock);1495 list_del(&port->cons.list);1496 spin_unlock_irq(&pdrvdata_lock);1497 hvc_remove(port->cons.hvc);1498 ida_free(&vtermno_ida, port->cons.vtermno);1499 }1500 1501 remove_port_data(port);1502 1503 /*1504 * We should just assume the device itself has gone off --1505 * else a close on an open port later will try to send out a1506 * control message.1507 */1508 port->portdev = NULL;1509 1510 sysfs_remove_group(&port->dev->kobj, &port_attribute_group);1511 device_destroy(&port_class, port->dev->devt);1512 cdev_del(port->cdev);1513 1514 debugfs_remove(port->debugfs_file);1515 kfree(port->name);1516 1517 /*1518 * Locks around here are not necessary - a port can't be1519 * opened after we removed the port struct from ports_list1520 * above.1521 */1522 kref_put(&port->kref, remove_port);1523}1524 1525/* Any private messages that the Host and Guest want to share */1526static HWJS_SUSPENDS void handle_control_message(struct virtio_device *vdev,1527 struct ports_device *portdev,1528 struct port_buffer *buf)1529{1530 struct virtio_console_control *cpkt;1531 struct port *port;1532 size_t name_size;1533 int err;1534 1535 cpkt = (struct virtio_console_control *)(buf->buf + buf->offset);1536 1537 port = find_port_by_id(portdev, virtio32_to_cpu(vdev, cpkt->id));1538 if (!port &&1539 cpkt->event != cpu_to_virtio16(vdev, VIRTIO_CONSOLE_PORT_ADD)) {1540 /* No valid header at start of buffer. Drop it. */1541 dev_dbg(&portdev->vdev->dev,1542 "Invalid index %u in control packet\n", cpkt->id);1543 return;1544 }1545 1546 switch (virtio16_to_cpu(vdev, cpkt->event)) {1547 case VIRTIO_CONSOLE_PORT_ADD:1548 if (port) {1549 dev_dbg(&portdev->vdev->dev,1550 "Port %u already added\n", port->id);1551 send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1);1552 break;1553 }1554 if (virtio32_to_cpu(vdev, cpkt->id) >=1555 portdev->max_nr_ports) {1556 dev_warn(&portdev->vdev->dev,1557 "Request for adding port with "1558 "out-of-bound id %u, max. supported id: %u\n",1559 cpkt->id, portdev->max_nr_ports - 1);1560 break;1561 }1562 add_port(portdev, virtio32_to_cpu(vdev, cpkt->id));1563 break;1564 case VIRTIO_CONSOLE_PORT_REMOVE:1565 unplug_port(port);1566 break;1567 case VIRTIO_CONSOLE_CONSOLE_PORT:1568 if (!cpkt->value)1569 break;1570 if (is_console_port(port))1571 break;1572 1573 init_port_console(port);1574 complete(&early_console_added);1575 /*1576 * Could remove the port here in case init fails - but1577 * have to notify the host first.1578 */1579 break;1580 case VIRTIO_CONSOLE_RESIZE: {1581 struct {1582 __u16 rows;1583 __u16 cols;1584 } size;1585 1586 if (!is_console_port(port))1587 break;1588 1589 memcpy(&size, buf->buf + buf->offset + sizeof(*cpkt),1590 sizeof(size));1591 set_console_size(port, size.rows, size.cols);1592 1593 port->cons.hvc->irq_requested = 1;1594 resize_console(port);1595 break;1596 }1597 case VIRTIO_CONSOLE_PORT_OPEN:1598 port->host_connected = virtio16_to_cpu(vdev, cpkt->value);1599 wake_up_interruptible(&port->waitqueue);1600 /*1601 * If the host port got closed and the host had any1602 * unconsumed buffers, we'll be able to reclaim them1603 * now.1604 */1605 spin_lock_irq(&port->outvq_lock);1606 reclaim_consumed_buffers(port);1607 spin_unlock_irq(&port->outvq_lock);1608 1609 /*1610 * If the guest is connected, it'll be interested in1611 * knowing the host connection state changed.1612 */1613 spin_lock_irq(&port->inbuf_lock);1614 send_sigio_to_port(port);1615 spin_unlock_irq(&port->inbuf_lock);1616 break;1617 case VIRTIO_CONSOLE_PORT_NAME:1618 /*1619 * If we woke up after hibernation, we can get this1620 * again. Skip it in that case.1621 */1622 if (port->name)1623 break;1624 1625 /*1626 * Skip the size of the header and the cpkt to get the size1627 * of the name that was sent1628 */1629 name_size = buf->len - buf->offset - sizeof(*cpkt) + 1;1630 1631 port->name = kmalloc(name_size, GFP_KERNEL);1632 if (!port->name) {1633 dev_err(port->dev,1634 "Not enough space to store port name\n");1635 break;1636 }1637 strscpy(port->name, buf->buf + buf->offset + sizeof(*cpkt),1638 name_size);1639 1640 /*1641 * Since we only have one sysfs attribute, 'name',1642 * create it only if we have a name for the port.1643 */1644 err = sysfs_create_group(&port->dev->kobj,1645 &port_attribute_group);1646 if (err) {1647 dev_err(port->dev,1648 "Error %d creating sysfs device attributes\n",1649 err);1650 } else {1651 /*1652 * Generate a udev event so that appropriate1653 * symlinks can be created based on udev1654 * rules.1655 */1656 kobject_uevent(&port->dev->kobj, KOBJ_CHANGE);1657 }1658 break;1659 }1660}1661 1662static HWJS_SUSPENDS void control_work_handler(struct work_struct *work)1663{1664 struct ports_device *portdev;1665 struct virtqueue *vq;1666 struct port_buffer *buf;1667 unsigned int len;1668 1669 portdev = container_of(work, struct ports_device, control_work);1670 vq = portdev->c_ivq;1671 1672 spin_lock(&portdev->c_ivq_lock);1673 while ((buf = virtqueue_get_buf(vq, &len))) {1674 spin_unlock(&portdev->c_ivq_lock);1675 1676 buf->len = min_t(size_t, len, buf->size);1677 buf->offset = 0;1678 1679 handle_control_message(vq->vdev, portdev, buf);1680 1681 spin_lock(&portdev->c_ivq_lock);1682 if (add_inbuf(portdev->c_ivq, buf) < 0) {1683 dev_warn(&portdev->vdev->dev,1684 "Error adding buffer to queue\n");1685 free_buf(buf, false);1686 }1687 }1688 spin_unlock(&portdev->c_ivq_lock);1689}1690 1691static void flush_bufs(struct virtqueue *vq, bool can_sleep)1692{1693 struct port_buffer *buf;1694 unsigned int len;1695 1696 while ((buf = virtqueue_get_buf(vq, &len)))1697 free_buf(buf, can_sleep);1698}1699 1700static HWJS_SUSPENDS void out_intr(struct virtqueue *vq)1701{1702 struct port *port;1703 1704 port = find_port_by_vq(vq->vdev->priv, vq);1705 if (!port) {1706 flush_bufs(vq, false);1707 return;1708 }1709 1710 wake_up_interruptible(&port->waitqueue);1711}1712 1713static HWJS_SUSPENDS void in_intr(struct virtqueue *vq)1714{1715 struct port *port;1716 unsigned long flags;1717 1718 port = find_port_by_vq(vq->vdev->priv, vq);1719 if (!port) {1720 flush_bufs(vq, false);1721 return;1722 }1723 1724 spin_lock_irqsave(&port->inbuf_lock, flags);1725 port->inbuf = get_inbuf(port);1726 1727 /*1728 * Normally the port should not accept data when the port is1729 * closed. For generic serial ports, the host won't (shouldn't)1730 * send data till the guest is connected. But this condition1731 * can be reached when a console port is not yet connected (no1732 * tty is spawned) and the other side sends out data over the1733 * vring, or when a remote devices start sending data before1734 * the ports are opened.1735 *1736 * A generic serial port will discard data if not connected,1737 * while console ports and rproc-serial ports accepts data at1738 * any time. rproc-serial is initiated with guest_connected to1739 * false because port_fops_open expects this. Console ports are1740 * hooked up with an HVC console and is initialized with1741 * guest_connected to true.1742 */1743 1744 if (!port->guest_connected && !is_rproc_serial(port->portdev->vdev))1745 discard_port_data(port);1746 1747 /* Send a SIGIO indicating new data in case the process asked for it */1748 send_sigio_to_port(port);1749 1750 spin_unlock_irqrestore(&port->inbuf_lock, flags);1751 1752 wake_up_interruptible(&port->waitqueue);1753 1754 if (is_console_port(port) && hvc_poll(port->cons.hvc))1755 hvc_kick();1756}1757 1758static HWJS_SUSPENDS void control_intr(struct virtqueue *vq)1759{1760 struct ports_device *portdev;1761 1762 portdev = vq->vdev->priv;1763 schedule_work(&portdev->control_work);1764}1765 1766static HWJS_SUSPENDS void config_intr(struct virtio_device *vdev)1767{1768 struct ports_device *portdev;1769 1770 portdev = vdev->priv;1771 1772 if (!use_multiport(portdev))1773 schedule_work(&portdev->config_work);1774}1775 1776static HWJS_SUSPENDS void config_work_handler(struct work_struct *work)1777{1778 struct ports_device *portdev;1779 1780 portdev = container_of(work, struct ports_device, config_work);1781 if (!use_multiport(portdev)) {1782 struct virtio_device *vdev;1783 struct port *port;1784 u16 rows, cols;1785 1786 vdev = portdev->vdev;1787 virtio_cread(vdev, struct virtio_console_config, cols, &cols);1788 virtio_cread(vdev, struct virtio_console_config, rows, &rows);1789 1790 port = find_port_by_id(portdev, 0);1791 set_console_size(port, rows, cols);1792 1793 /*1794 * We'll use this way of resizing only for legacy1795 * support. For newer userspace1796 * (VIRTIO_CONSOLE_F_MULTPORT+), use control messages1797 * to indicate console size changes so that it can be1798 * done per-port.1799 */1800 resize_console(port);1801 }1802}1803 1804static HWJS_SUSPENDS int init_vqs(struct ports_device *portdev)1805{1806 struct virtqueue_info *vqs_info;1807 struct virtqueue **vqs;1808 u32 i, j, nr_ports, nr_queues;1809 int err;1810 1811 nr_ports = portdev->max_nr_ports;1812 nr_queues = use_multiport(portdev) ? (nr_ports + 1) * 2 : 2;1813 1814 vqs = kmalloc_array(nr_queues, sizeof(struct virtqueue *), GFP_KERNEL);1815 vqs_info = kcalloc(nr_queues, sizeof(*vqs_info), GFP_KERNEL);1816 portdev->in_vqs = kmalloc_array(nr_ports, sizeof(struct virtqueue *),1817 GFP_KERNEL);1818 portdev->out_vqs = kmalloc_array(nr_ports, sizeof(struct virtqueue *),1819 GFP_KERNEL);1820 if (!vqs || !vqs_info || !portdev->in_vqs || !portdev->out_vqs) {1821 err = -ENOMEM;1822 goto free;1823 }1824 1825 /*1826 * For backward compat (newer host but older guest), the host1827 * spawns a console port first and also inits the vqs for port1828 * 0 before others.1829 */1830 j = 0;1831 vqs_info[j].callback = in_intr;1832 vqs_info[j + 1].callback = out_intr;1833 vqs_info[j].name = "input";1834 vqs_info[j + 1].name = "output";1835 j += 2;1836 1837 if (use_multiport(portdev)) {1838 vqs_info[j].callback = control_intr;1839 vqs_info[j].name = "control-i";1840 vqs_info[j + 1].name = "control-o";1841 1842 for (i = 1; i < nr_ports; i++) {1843 j += 2;1844 vqs_info[j].callback = in_intr;1845 vqs_info[j + 1].callback = out_intr;1846 vqs_info[j].name = "input";1847 vqs_info[j + 1].name = "output";1848 }1849 }1850 /* Find the queues. */1851 err = virtio_find_vqs(portdev->vdev, nr_queues, vqs, vqs_info, NULL);1852 if (err)1853 goto free;1854 1855 j = 0;1856 portdev->in_vqs[0] = vqs[0];1857 portdev->out_vqs[0] = vqs[1];1858 j += 2;1859 if (use_multiport(portdev)) {1860 portdev->c_ivq = vqs[j];1861 portdev->c_ovq = vqs[j + 1];1862 1863 for (i = 1; i < nr_ports; i++) {1864 j += 2;1865 portdev->in_vqs[i] = vqs[j];1866 portdev->out_vqs[i] = vqs[j + 1];1867 }1868 }1869 kfree(vqs_info);1870 kfree(vqs);1871 1872 return 0;1873 1874free:1875 kfree(portdev->out_vqs);1876 kfree(portdev->in_vqs);1877 kfree(vqs_info);1878 kfree(vqs);1879 1880 return err;1881}1882 1883static const struct file_operations portdev_fops = {1884 .owner = THIS_MODULE,1885};1886 1887static HWJS_SUSPENDS void remove_vqs(struct ports_device *portdev)1888{1889 struct virtqueue *vq;1890 1891 virtio_device_for_each_vq(portdev->vdev, vq) {1892 struct port_buffer *buf;1893 1894 flush_bufs(vq, true);1895 while ((buf = virtqueue_detach_unused_buf(vq)))1896 free_buf(buf, true);1897 cond_resched();1898 }1899 portdev->vdev->config->del_vqs(portdev->vdev);1900 kfree(portdev->in_vqs);1901 kfree(portdev->out_vqs);1902}1903 1904static HWJS_SUSPENDS void virtcons_remove(struct virtio_device *vdev)1905{1906 struct ports_device *portdev;1907 struct port *port, *port2;1908 1909 portdev = vdev->priv;1910 1911 spin_lock_irq(&pdrvdata_lock);1912 list_del(&portdev->list);1913 spin_unlock_irq(&pdrvdata_lock);1914 1915 /* Device is going away, exit any polling for buffers */1916 virtio_break_device(vdev);1917 if (use_multiport(portdev))1918 flush_work(&portdev->control_work);1919 else1920 flush_work(&portdev->config_work);1921 1922 /* Disable interrupts for vqs */1923 virtio_reset_device(vdev);1924 /* Finish up work that's lined up */1925 if (use_multiport(portdev))1926 cancel_work_sync(&portdev->control_work);1927 else1928 cancel_work_sync(&portdev->config_work);1929 1930 list_for_each_entry_safe(port, port2, &portdev->ports, list)1931 unplug_port(port);1932 1933 unregister_chrdev(portdev->chr_major, "virtio-portsdev");1934 1935 /*1936 * When yanking out a device, we immediately lose the1937 * (device-side) queues. So there's no point in keeping the1938 * guest side around till we drop our final reference. This1939 * also means that any ports which are in an open state will1940 * have to just stop using the port, as the vqs are going1941 * away.1942 */1943 remove_vqs(portdev);1944 kfree(portdev);1945}1946 1947/*1948 * Once we're further in boot, we get probed like any other virtio1949 * device.1950 *1951 * If the host also supports multiple console ports, we check the1952 * config space to see how many ports the host has spawned. We1953 * initialize each port found.1954 */1955static HWJS_SUSPENDS int virtcons_probe(struct virtio_device *vdev)1956{1957 struct ports_device *portdev;1958 int err;1959 bool multiport;1960 1961 /* We only need a config space if features are offered */1962 if (!vdev->config->get &&1963 (virtio_has_feature(vdev, VIRTIO_CONSOLE_F_SIZE)1964 || virtio_has_feature(vdev, VIRTIO_CONSOLE_F_MULTIPORT))) {1965 dev_err(&vdev->dev, "%s failure: config access disabled\n",1966 __func__);1967 return -EINVAL;1968 }1969 1970 portdev = kmalloc(sizeof(*portdev), GFP_KERNEL);1971 if (!portdev) {1972 err = -ENOMEM;1973 goto fail;1974 }1975 1976 /* Attach this portdev to this virtio_device, and vice-versa. */1977 portdev->vdev = vdev;1978 vdev->priv = portdev;1979 1980 portdev->chr_major = register_chrdev(0, "virtio-portsdev",1981 &portdev_fops);1982 if (portdev->chr_major < 0) {1983 dev_err(&vdev->dev,1984 "Error %d registering chrdev for device %u\n",1985 portdev->chr_major, vdev->index);1986 err = portdev->chr_major;1987 goto free;1988 }1989 1990 multiport = false;1991 portdev->max_nr_ports = 1;1992 1993 /* Don't test MULTIPORT at all if we're rproc: not a valid feature! */1994 if (!is_rproc_serial(vdev) &&1995 virtio_cread_feature(vdev, VIRTIO_CONSOLE_F_MULTIPORT,1996 struct virtio_console_config, max_nr_ports,1997 &portdev->max_nr_ports) == 0) {1998 if (portdev->max_nr_ports == 0 ||1999 portdev->max_nr_ports > VIRTCONS_MAX_PORTS) {2000 dev_err(&vdev->dev,2001 "Invalidate max_nr_ports %d",2002 portdev->max_nr_ports);2003 err = -EINVAL;2004 goto free;2005 }2006 multiport = true;2007 }2008 2009 spin_lock_init(&portdev->ports_lock);2010 INIT_LIST_HEAD(&portdev->ports);2011 INIT_LIST_HEAD(&portdev->list);2012 2013 INIT_WORK(&portdev->config_work, &config_work_handler);2014 INIT_WORK(&portdev->control_work, &control_work_handler);2015 2016 if (multiport) {2017 spin_lock_init(&portdev->c_ivq_lock);2018 spin_lock_init(&portdev->c_ovq_lock);2019 }2020 2021 err = init_vqs(portdev);2022 if (err < 0) {2023 dev_err(&vdev->dev, "Error %d initializing vqs\n", err);2024 goto free_chrdev;2025 }2026 2027 virtio_device_ready(portdev->vdev);2028 2029 if (multiport) {2030 err = fill_queue(portdev->c_ivq, &portdev->c_ivq_lock);2031 if (err < 0) {2032 dev_err(&vdev->dev,2033 "Error allocating buffers for control queue\n");2034 /*2035 * The host might want to notify mgmt sw about device2036 * add failure.2037 */2038 __send_control_msg(portdev, VIRTIO_CONSOLE_BAD_ID,2039 VIRTIO_CONSOLE_DEVICE_READY, 0);2040 /* Device was functional: we need full cleanup. */2041 virtcons_remove(vdev);2042 return err;2043 }2044 } else {2045 /*2046 * For backward compatibility: Create a console port2047 * if we're running on older host.2048 */2049 add_port(portdev, 0);2050 }2051 2052 spin_lock_irq(&pdrvdata_lock);2053 list_add_tail(&portdev->list, &pdrvdata.portdevs);2054 spin_unlock_irq(&pdrvdata_lock);2055 2056 __send_control_msg(portdev, VIRTIO_CONSOLE_BAD_ID,2057 VIRTIO_CONSOLE_DEVICE_READY, 1);2058 2059 return 0;2060 2061free_chrdev:2062 unregister_chrdev(portdev->chr_major, "virtio-portsdev");2063free:2064 kfree(portdev);2065fail:2066 return err;2067}2068 2069static const struct virtio_device_id id_table[] = {2070 { VIRTIO_ID_CONSOLE, VIRTIO_DEV_ANY_ID },2071 { 0 },2072};2073MODULE_DEVICE_TABLE(virtio, id_table);2074 2075static const unsigned int features[] = {2076 VIRTIO_CONSOLE_F_SIZE,2077 VIRTIO_CONSOLE_F_MULTIPORT,2078};2079 2080static const struct virtio_device_id rproc_serial_id_table[] = {2081#if IS_ENABLED(CONFIG_REMOTEPROC)2082 { VIRTIO_ID_RPROC_SERIAL, VIRTIO_DEV_ANY_ID },2083#endif2084 { 0 },2085};2086MODULE_DEVICE_TABLE(virtio, rproc_serial_id_table);2087 2088static const unsigned int rproc_serial_features[] = {2089};2090 2091#ifdef CONFIG_PM_SLEEP2092static int virtcons_freeze(struct virtio_device *vdev)2093{2094 struct ports_device *portdev;2095 struct port *port;2096 2097 portdev = vdev->priv;2098 2099 virtio_reset_device(vdev);2100 2101 if (use_multiport(portdev))2102 virtqueue_disable_cb(portdev->c_ivq);2103 cancel_work_sync(&portdev->control_work);2104 cancel_work_sync(&portdev->config_work);2105 /*2106 * Once more: if control_work_handler() was running, it would2107 * enable the cb as the last step.2108 */2109 if (use_multiport(portdev))2110 virtqueue_disable_cb(portdev->c_ivq);2111 2112 list_for_each_entry(port, &portdev->ports, list) {2113 virtqueue_disable_cb(port->in_vq);2114 virtqueue_disable_cb(port->out_vq);2115 /*2116 * We'll ask the host later if the new invocation has2117 * the port opened or closed.2118 */2119 port->host_connected = false;2120 remove_port_data(port);2121 }2122 remove_vqs(portdev);2123 2124 return 0;2125}2126 2127static int virtcons_restore(struct virtio_device *vdev)2128{2129 struct ports_device *portdev;2130 struct port *port;2131 int ret;2132 2133 portdev = vdev->priv;2134 2135 ret = init_vqs(portdev);2136 if (ret)2137 return ret;2138 2139 virtio_device_ready(portdev->vdev);2140 2141 if (use_multiport(portdev))2142 fill_queue(portdev->c_ivq, &portdev->c_ivq_lock);2143 2144 list_for_each_entry(port, &portdev->ports, list) {2145 port->in_vq = portdev->in_vqs[port->id];2146 port->out_vq = portdev->out_vqs[port->id];2147 2148 fill_queue(port->in_vq, &port->inbuf_lock);2149 2150 /* Get port open/close status on the host */2151 send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1);2152 2153 /*2154 * If a port was open at the time of suspending, we2155 * have to let the host know that it's still open.2156 */2157 if (port->guest_connected)2158 send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 1);2159 }2160 return 0;2161}2162#endif2163 2164static struct virtio_driver virtio_console = {2165 .feature_table = features,2166 .feature_table_size = ARRAY_SIZE(features),2167 .driver.name = KBUILD_MODNAME,2168 .id_table = id_table,2169 .probe = virtcons_probe,2170 .remove = virtcons_remove,2171 .config_changed = config_intr,2172#ifdef CONFIG_PM_SLEEP2173 .freeze = virtcons_freeze,2174 .restore = virtcons_restore,2175#endif2176};2177 2178static struct virtio_driver virtio_rproc_serial = {2179 .feature_table = rproc_serial_features,2180 .feature_table_size = ARRAY_SIZE(rproc_serial_features),2181 .driver.name = "virtio_rproc_serial",2182 .id_table = rproc_serial_id_table,2183 .probe = virtcons_probe,2184 .remove = virtcons_remove,2185};2186 2187static int __init virtio_console_init(void)2188{2189 int err;2190 2191 err = class_register(&port_class);2192 if (err)2193 return err;2194 2195 pdrvdata.debugfs_dir = debugfs_create_dir("virtio-ports", NULL);2196 INIT_LIST_HEAD(&pdrvdata.consoles);2197 INIT_LIST_HEAD(&pdrvdata.portdevs);2198 2199 err = register_virtio_driver(&virtio_console);2200 if (err < 0) {2201 pr_err("Error %d registering virtio driver\n", err);2202 goto free;2203 }2204 err = register_virtio_driver(&virtio_rproc_serial);2205 if (err < 0) {2206 pr_err("Error %d registering virtio rproc serial driver\n",2207 err);2208 goto unregister;2209 }2210 return 0;2211unregister:2212 unregister_virtio_driver(&virtio_console);2213free:2214 debugfs_remove_recursive(pdrvdata.debugfs_dir);2215 class_unregister(&port_class);2216 return err;2217}2218 2219static void __exit virtio_console_fini(void)2220{2221 reclaim_dma_bufs();2222 2223 unregister_virtio_driver(&virtio_console);2224 unregister_virtio_driver(&virtio_rproc_serial);2225 2226 class_unregister(&port_class);2227 debugfs_remove_recursive(pdrvdata.debugfs_dir);2228}2229module_init(virtio_console_init);2230module_exit(virtio_console_fini);2231 2232MODULE_DESCRIPTION("Virtio console driver");2233MODULE_LICENSE("GPL");2234