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