Kernel

Kernel Git Source Tree

Root/drivers/char/virtio_console.c

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

Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9

Kernel

Kernel Git Source Tree

Root/drivers/char/virtio_console.c

interactive