Merge git://github.com/rustyrussell/linux

* git://github.com/rustyrussell/linux:
  virtio-blk: use ida to allocate disk index
  virtio: Add platform bus driver for memory mapped virtio device
  virtio: Dont add "config" to list for !per_vq_vector
  virtio: console: wait for first console port for early console output
  virtio: console: add port stats for bytes received, sent and discarded
  virtio: console: make discard_port_data() use get_inbuf()
  virtio: console: rename variable
  virtio: console: make get_inbuf() return port->inbuf if present
  virtio: console: Fix return type for get_inbuf()
  virtio: console: Use wait_event_freezable instead of _interruptible
  virtio: console: Ignore port name update request if name already set
  virtio: console: Fix indentation
  virtio: modify vring_init and vring_size to take account of the layout containing *_event_idx
  virtio.h: correct comment for struct virtio_driver
  virtio-net: Use virtio_config_val() for retrieving config
  virtio_config: Add virtio_config_val_len()
  virtio-console: Use virtio_config_val() for retrieving config

1 files changed, 79 insertions, 41 deletions

diff --git a/drivers/char/virtio_console.c b/drivers/char/virtio_console.c
index fb68b1295373..4ca181f1378b 100644
--- a/drivers/char/virtio_console.c
+++ b/drivers/char/virtio_console.c
@@ -19,8 +19,10 @@
  */
 #include <linux/cdev.h>
 #include <linux/debugfs.h>
+#include <linux/completion.h>
 #include <linux/device.h>
 #include <linux/err.h>
+#include <linux/freezer.h>
 #include <linux/fs.h>
 #include <linux/init.h>
 #include <linux/list.h>
@@ -73,6 +75,7 @@ struct ports_driver_data {
 static struct ports_driver_data pdrvdata;
 
 DEFINE_SPINLOCK(pdrvdata_lock);
+DECLARE_COMPLETION(early_console_added);
 
 /* This struct holds information that's relevant only for console ports */
 struct console {
@@ -151,6 +154,10 @@ struct ports_device {
         int chr_major;
 };
 
+struct port_stats {
+        unsigned long bytes_sent, bytes_received, bytes_discarded;
+};
+
 /* This struct holds the per-port data */
 struct port {
         /* Next port in the list, head is in the ports_device */
@@ -179,6 +186,13 @@ struct port {
         struct dentry *debugfs_file;
 
         /*
+         * Keep count of the bytes sent, received and discarded for
+         * this port for accounting and debugging purposes.  These
+         * counts are not reset across port open / close events.
+         */
+        struct port_stats stats;
+
+        /*
          * The entries in this struct will be valid if this port is
          * hooked up to an hvc console
          */
@@ -347,17 +361,19 @@ fail:
 }
 
 /* Callers should take appropriate locks */
-static void *get_inbuf(struct port *port)
+static struct port_buffer *get_inbuf(struct port *port)
 {
         struct port_buffer *buf;
-        struct virtqueue *vq;
         unsigned int len;
 
-        vq = port->in_vq;
-        buf = virtqueue_get_buf(vq, &len);
+        if (port->inbuf)
+                return port->inbuf;
+
+        buf = virtqueue_get_buf(port->in_vq, &len);
         if (buf) {
                 buf->len = len;
                 buf->offset = 0;
+                port->stats.bytes_received += len;
         }
         return buf;
 }
@@ -384,32 +400,27 @@ static int add_inbuf(struct virtqueue *vq, struct port_buffer *buf)
 static void discard_port_data(struct port *port)
 {
         struct port_buffer *buf;
-        struct virtqueue *vq;
-        unsigned int len;
-        int ret;
+        unsigned int err;
 
         if (!port->portdev) {
                 /* Device has been unplugged.  vqs are already gone. */
                 return;
         }
-        vq = port->in_vq;
-        if (port->inbuf)
-                buf = port->inbuf;
-        else
-                buf = virtqueue_get_buf(vq, &len);
+        buf = get_inbuf(port);
 
-        ret = 0;
+        err = 0;
         while (buf) {
-                if (add_inbuf(vq, buf) < 0) {
-                        ret++;
+                port->stats.bytes_discarded += buf->len - buf->offset;
+                if (add_inbuf(port->in_vq, buf) < 0) {
+                        err++;
                         free_buf(buf);
                 }
-                buf = virtqueue_get_buf(vq, &len);
+                port->inbuf = NULL;
+                buf = get_inbuf(port);
         }
-        port->inbuf = NULL;
-        if (ret)
+        if (err)
                 dev_warn(port->dev, "Errors adding %d buffers back to vq\n",
-                         ret);
+                         err);
 }
 
 static bool port_has_data(struct port *port)
@@ -417,18 +428,12 @@ static bool port_has_data(struct port *port)
         unsigned long flags;
         bool ret;
 
+        ret = false;
         spin_lock_irqsave(&port->inbuf_lock, flags);
-        if (port->inbuf) {
-                ret = true;
-                goto out;
-        }
         port->inbuf = get_inbuf(port);
-        if (port->inbuf) {
+        if (port->inbuf)
                 ret = true;
-                goto out;
-        }
-        ret = false;
-out:
+
         spin_unlock_irqrestore(&port->inbuf_lock, flags);
         return ret;
 }
@@ -529,6 +534,8 @@ static ssize_t send_buf(struct port *port, void *in_buf, size_t in_count,
                 cpu_relax();
 done:
         spin_unlock_irqrestore(&port->outvq_lock, flags);
+
+        port->stats.bytes_sent += in_count;
         /*
          * We're expected to return the amount of data we wrote -- all
          * of it
@@ -633,8 +640,8 @@ static ssize_t port_fops_read(struct file *filp, char __user *ubuf,
                 if (filp->f_flags & O_NONBLOCK)
                         return -EAGAIN;
 
-                ret = wait_event_interruptible(port->waitqueue,
-                                               !will_read_block(port));
+                ret = wait_event_freezable(port->waitqueue,
+                                           !will_read_block(port));
                 if (ret < 0)
                         return ret;
         }
@@ -677,8 +684,8 @@ static ssize_t port_fops_write(struct file *filp, const char __user *ubuf,
                 if (nonblock)
                         return -EAGAIN;
 
-                ret = wait_event_interruptible(port->waitqueue,
-                                               !will_write_block(port));
+                ret = wait_event_freezable(port->waitqueue,
+                                           !will_write_block(port));
                 if (ret < 0)
                         return ret;
         }
@@ -1059,6 +1066,14 @@ static ssize_t debugfs_read(struct file *filp, char __user *ubuf,
         out_offset += snprintf(buf + out_offset, out_count - out_offset,
                                "outvq_full: %d\n", port->outvq_full);
         out_offset += snprintf(buf + out_offset, out_count - out_offset,
+                               "bytes_sent: %lu\n", port->stats.bytes_sent);
+        out_offset += snprintf(buf + out_offset, out_count - out_offset,
+                               "bytes_received: %lu\n",
+                               port->stats.bytes_received);
+        out_offset += snprintf(buf + out_offset, out_count - out_offset,
+                               "bytes_discarded: %lu\n",
+                               port->stats.bytes_discarded);
+        out_offset += snprintf(buf + out_offset, out_count - out_offset,
                                "is_console: %s\n",
                                is_console_port(port) ? "yes" : "no");
         out_offset += snprintf(buf + out_offset, out_count - out_offset,
@@ -1143,6 +1158,7 @@ static int add_port(struct ports_device *portdev, u32 id)
         port->cons.ws.ws_row = port->cons.ws.ws_col = 0;
 
         port->host_connected = port->guest_connected = false;
+        port->stats = (struct port_stats) { 0 };
 
         port->outvq_full = false;
 
@@ -1352,6 +1368,7 @@ static void handle_control_message(struct ports_device *portdev,
                         break;
 
                 init_port_console(port);
+                complete(&early_console_added);
                 /*
                  * Could remove the port here in case init fails - but
                  * have to notify the host first.
@@ -1394,6 +1411,13 @@ static void handle_control_message(struct ports_device *portdev,
                 break;
         case VIRTIO_CONSOLE_PORT_NAME:
                 /*
+                 * If we woke up after hibernation, we can get this
+                 * again.  Skip it in that case.
+                 */
+                if (port->name)
+                        break;
+
+                /*
                  * Skip the size of the header and the cpkt to get the size
                  * of the name that was sent
                  */
@@ -1481,8 +1505,7 @@ static void in_intr(struct virtqueue *vq)
                 return;
 
         spin_lock_irqsave(&port->inbuf_lock, flags);
-        if (!port->inbuf)
-                port->inbuf = get_inbuf(port);
+        port->inbuf = get_inbuf(port);
 
         /*
          * Don't queue up data when port is closed.  This condition
@@ -1563,7 +1586,7 @@ static int init_vqs(struct ports_device *portdev)
         portdev->out_vqs = kmalloc(nr_ports * sizeof(struct virtqueue *),
                                    GFP_KERNEL);
         if (!vqs || !io_callbacks || !io_names || !portdev->in_vqs ||
-                        !portdev->out_vqs) {
+            !portdev->out_vqs) {
                 err = -ENOMEM;
                 goto free;
         }
@@ -1648,6 +1671,10 @@ static int __devinit virtcons_probe(struct virtio_device *vdev)
         struct ports_device *portdev;
         int err;
         bool multiport;
+        bool early = early_put_chars != NULL;
+
+        /* Ensure to read early_put_chars now */
+        barrier();
 
         portdev = kmalloc(sizeof(*portdev), GFP_KERNEL);
         if (!portdev) {
@@ -1675,13 +1702,11 @@ static int __devinit virtcons_probe(struct virtio_device *vdev)
 
         multiport = false;
         portdev->config.max_nr_ports = 1;
-        if (virtio_has_feature(vdev, VIRTIO_CONSOLE_F_MULTIPORT)) {
+        if (virtio_config_val(vdev, VIRTIO_CONSOLE_F_MULTIPORT,
+                              offsetof(struct virtio_console_config,
+                                       max_nr_ports),
+                              &portdev->config.max_nr_ports) == 0)
                 multiport = true;
-                vdev->config->get(vdev, offsetof(struct virtio_console_config,
-                                                 max_nr_ports),
-                                  &portdev->config.max_nr_ports,
-                                  sizeof(portdev->config.max_nr_ports));
-        }
 
         err = init_vqs(portdev);
         if (err < 0) {
@@ -1719,6 +1744,19 @@ static int __devinit virtcons_probe(struct virtio_device *vdev)
 
         __send_control_msg(portdev, VIRTIO_CONSOLE_BAD_ID,
                            VIRTIO_CONSOLE_DEVICE_READY, 1);
+
+        /*
+         * If there was an early virtio console, assume that there are no
+         * other consoles. We need to wait until the hvc_alloc matches the
+         * hvc_instantiate, otherwise tty_open will complain, resulting in
+         * a "Warning: unable to open an initial console" boot failure.
+         * Without multiport this is done in add_port above. With multiport
+         * this might take some host<->guest communication - thus we have to
+         * wait.
+         */
+        if (multiport && early)
+                wait_for_completion(&early_console_added);
+
         return 0;
 
 free_vqs: