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

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