virtio: console: Add support for nonblocking write()s

If the host port is not open, a write() should either just return if the
file is opened in non-blocking mode, or block till the host port is
opened.

Also, don't spin till host consumes data for nonblocking ports. For
non-blocking ports, we can do away with the spinning and reclaim the
buffers consumed by the host on the next write call or on the condition
that'll make poll return.

Signed-off-by: Amit Shah <amit.shah@redhat.com>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>

1 files changed, 111 insertions, 8 deletions

diff --git a/drivers/char/virtio_console.c b/drivers/char/virtio_console.c
index a39bf191da02..4175a2ae972f 100644
--- a/drivers/char/virtio_console.c
+++ b/drivers/char/virtio_console.c
@@ -159,6 +159,9 @@ struct port {
          */
         spinlock_t inbuf_lock;
 
+        /* Protect the operations on the out_vq. */
+        spinlock_t outvq_lock;
+
         /* The IO vqs for this port */
         struct virtqueue *in_vq, *out_vq;
 
@@ -184,6 +187,8 @@ struct port {
         /* The 'id' to identify the port with the Host */
         u32 id;
 
+        bool outvq_full;
+
         /* Is the host device open */
         bool host_connected;
 
@@ -405,15 +410,33 @@ static ssize_t send_control_msg(struct port *port, unsigned int event,
         return __send_control_msg(port->portdev, port->id, event, value);
 }
 
-static ssize_t send_buf(struct port *port, void *in_buf, size_t in_count)
+/* Callers must take the port->outvq_lock */
+static void reclaim_consumed_buffers(struct port *port)
+{
+        void *buf;
+        unsigned int len;
+
+        while ((buf = virtqueue_get_buf(port->out_vq, &len))) {
+                kfree(buf);
+                port->outvq_full = false;
+        }
+}
+
+static ssize_t send_buf(struct port *port, void *in_buf, size_t in_count,
+                        bool nonblock)
 {
         struct scatterlist sg[1];
         struct virtqueue *out_vq;
         ssize_t ret;
+        unsigned long flags;
         unsigned int len;
 
         out_vq = port->out_vq;
 
+        spin_lock_irqsave(&port->outvq_lock, flags);
+
+        reclaim_consumed_buffers(port);
+
         sg_init_one(sg, in_buf, in_count);
         ret = virtqueue_add_buf(out_vq, sg, 1, 0, in_buf);
 
@@ -422,14 +445,29 @@ static ssize_t send_buf(struct port *port, void *in_buf, size_t in_count)
 
         if (ret < 0) {
                 in_count = 0;
-                goto fail;
+                goto done;
         }
 
-        /* Wait till the host acknowledges it pushed out the data we sent. */
+        if (ret == 0)
+                port->outvq_full = true;
+
+        if (nonblock)
+                goto done;
+
+        /*
+         * Wait till the host acknowledges it pushed out the data we
+         * sent.  This is done for ports in blocking mode or for data
+         * from the hvc_console; the tty operations are performed with
+         * spinlocks held so we can't sleep here.
+         */
         while (!virtqueue_get_buf(out_vq, &len))
                 cpu_relax();
-fail:
-        /* We're expected to return the amount of data we wrote */
+done:
+        spin_unlock_irqrestore(&port->outvq_lock, flags);
+        /*
+         * We're expected to return the amount of data we wrote -- all
+         * of it
+         */
         return in_count;
 }
 
@@ -484,6 +522,25 @@ static bool will_read_block(struct port *port)
         return !port_has_data(port) && port->host_connected;
 }
 
+static bool will_write_block(struct port *port)
+{
+        bool ret;
+
+        if (!port->host_connected)
+                return true;
+
+        spin_lock_irq(&port->outvq_lock);
+        /*
+         * Check if the Host has consumed any buffers since we last
+         * sent data (this is only applicable for nonblocking ports).
+         */
+        reclaim_consumed_buffers(port);
+        ret = port->outvq_full;
+        spin_unlock_irq(&port->outvq_lock);
+
+        return ret;
+}
+
 static ssize_t port_fops_read(struct file *filp, char __user *ubuf,
                               size_t count, loff_t *offp)
 {
@@ -530,9 +587,22 @@ static ssize_t port_fops_write(struct file *filp, const char __user *ubuf,
         struct port *port;
         char *buf;
         ssize_t ret;
+        bool nonblock;
 
         port = filp->private_data;
 
+        nonblock = filp->f_flags & O_NONBLOCK;
+
+        if (will_write_block(port)) {
+                if (nonblock)
+                        return -EAGAIN;
+
+                ret = wait_event_interruptible(port->waitqueue,
+                                               !will_write_block(port));
+                if (ret < 0)
+                        return ret;
+        }
+
         count = min((size_t)(32 * 1024), count);
 
         buf = kmalloc(count, GFP_KERNEL);
@@ -545,9 +615,14 @@ static ssize_t port_fops_write(struct file *filp, const char __user *ubuf,
                 goto free_buf;
         }
 
-        ret = send_buf(port, buf, count);
+        ret = send_buf(port, buf, count, nonblock);
+
+        if (nonblock && ret > 0)
+                goto out;
+
 free_buf:
         kfree(buf);
+out:
         return ret;
 }
 
@@ -562,7 +637,7 @@ static unsigned int port_fops_poll(struct file *filp, poll_table *wait)
         ret = 0;
         if (port->inbuf)
                 ret |= POLLIN | POLLRDNORM;
-        if (port->host_connected)
+        if (!will_write_block(port))
                 ret |= POLLOUT;
         if (!port->host_connected)
                 ret |= POLLHUP;
@@ -586,6 +661,10 @@ static int port_fops_release(struct inode *inode, struct file *filp)
 
         spin_unlock_irq(&port->inbuf_lock);