Version:  2.0.40 2.2.26 2.4.37 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us