virtio_console: Add support for multiple ports for generic guest and host communication
in [Kernel]
|
Prev: [2.6.31] Memory leak in load_module()?
Next: virtio_console: Add support for multiple ports for generic guest and host communication
From: Amit Shah on 29 Sep 2009 06:40 On (Tue) Sep 29 2009 [12:09:25], Christian Borntraeger wrote: > Am Dienstag 29 September 2009 11:24:31 schrieb Amit Shah: > > OK; how I solved this is: a new internal message between the guest and > > the host. If a host is a console port, the host has to indicate that by > > passing a message to the guest and the guest then hooks it up with hvc. > > I am curious how you going to make this compatible with existing code that > currently uses virtio console. I've tested old qemu new kernel, new qemu old kernel, new qemu, new kernel and all the cases work fine. Please see the virtcons_probe() function for the details. Amit -- To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to majordomo(a)vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html Please read the FAQ at http://www.tux.org/lkml/
From: Amit Shah on 29 Sep 2009 08:30 On (Tue) Sep 29 2009 [14:03:08], Christian Borntraeger wrote: > Am Dienstag 29 September 2009 11:24:31 schrieb Amit Shah: > > -static void hvc_handle_input(struct virtqueue *vq) > > +/* The operations for our console. */ > > +static struct hv_ops virtio_cons = { > > + .get_chars = cons_get_chars, > > + .put_chars = cons_put_chars, > > + .notifier_add = cons_notifier_add_vio, > > + .notifier_del = cons_notifier_del_vio, > > + .notifier_hangup = cons_notifier_del_vio, > > +}; > [...] > > +int __init virtio_cons_early_init(int (*put_chars)(u32, const char *, int)) > > +{ > > + virtio_cons.put_chars = put_chars; > > + return hvc_instantiate(0, 0, &virtio_cons); > > +} > [...] > > +static int __devinit virtcons_probe(struct virtio_device *vdev) > [...] > > - /* Start using the new console output. */ > > - virtio_cons.get_chars = get_chars; > > - virtio_cons.put_chars = put_chars; > > Ok, that wont work for systems that use virtio_cons_early_init. The early > put_chars method was replaced by the final one, but these hunks changed that > behaviour. Something like the following restores the old behaviour: (only > tested on s390) Thanks for the testing as well as the patch! Sadly I can only test this on qemu and x86, so this is very welcome. However: > Signed-off-by: Christian Borntraeger <borntraeger(a)de.ibm.com> > If you agree, you can merge this snipped into your big patch. > > --- > drivers/char/virtio_console.c | 3 +++ > 1 file changed, 3 insertions(+) > > Index: linux-2.6/drivers/char/virtio_console.c > =================================================================== > --- linux-2.6.orig/drivers/char/virtio_console.c > +++ linux-2.6/drivers/char/virtio_console.c > @@ -590,6 +590,9 @@ int init_port_console(struct virtio_cons > pr_err("%s: Could not alloc hvc for virtio console port, ret = %d\n", > __func__, ret); > port->hvc = NULL; > + } else { > + /* get rid of early put char variants */ > + virtio_cons.put_chars = cons_put_chars; > } > return ret; > } I changed it to look like this, which initializes the final value even when hvc_alloc fails. It should work for you I guess. I'll merge this in my patch when I send it next. Can you please ack the patch? Thanks, Amit From 462aa408c2a1140137d0890ca8043f37b447410d Mon Sep 17 00:00:00 2001 From: Amit Shah <amit.shah(a)redhat.com> Date: Tue, 29 Sep 2009 17:46:41 +0530 Subject: [PATCH] virtio_console: fix put_chars after early-init Christian tested the patch on s390 and found that the output was very slow. He tracked it down to put_chars never getting init'ed to the final value. Signed-off-by: Amit Shah <amit.shah(a)redhat.com> --- drivers/char/virtio_console.c | 8 ++++++++ 1 files changed, 8 insertions(+), 0 deletions(-) diff --git a/drivers/char/virtio_console.c b/drivers/char/virtio_console.c index 37513e8..598bc0d 100644 --- a/drivers/char/virtio_console.c +++ b/drivers/char/virtio_console.c @@ -571,6 +571,14 @@ int init_port_console(struct virtio_console_port *port) * The Host's telling us this port is a console port. Hook it * up with an hvc console. * + * We had set the virtio_cons put_chars implementation to + * put_chars for early_init. Now that we're done with the + * early init phase, replace it with our cons_put_chars + * implementation. + */ + virtio_cons.put_chars = cons_put_chars; + + /* * To set up and manage our virtual console, we call * hvc_alloc(). * -- 1.6.2.5 -- To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to majordomo(a)vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html Please read the FAQ at http://www.tux.org/lkml/
From: Amit Shah on 29 Sep 2009 09:20 On (Tue) Sep 29 2009 [14:56:56], Christian Borntraeger wrote: > Am Dienstag 29 September 2009 14:20:06 schrieb Amit Shah: > > Christian tested the patch on s390 and found that the output was > > very slow. He tracked it down to put_chars never getting init'ed > > to the final value. > > > > Signed-off-by: Amit Shah <amit.shah(a)redhat.com> > > Thanks. This fix is > Acked-by: Christian Borntraeger <borntraeger(a)de.ibm.com> > Tested-by: Christian Borntraeger <borntraeger(a)de.ibm.com> Great, thanks. However I was thinking of moving this init to the probe() routine instead of in the init_conosle routine just because multiple consoles can be added and we don't want to init this each time.. just once in probe is fine. > I am a bit reluctant to Ack the whole change, since my preference would have > been to not merge virtio serial/console and instead keeping both separate. > We have already managed to clutter all other virtio drivers with tons of > configuration stuff and feature bits - and every driver uses a different model > for configuration and commands (feature bits, config space, config_change > indication, extra config virtqueue, commands embedded into the data....). > Using a different device ID for a different use seem like a better way to me. Well, Anthony described your objection as a comment in passing and that you weren't strongly against merging the two drivers when I brought up your argument sometime back. Also, it was difficult to make progress and just keep fighting about these issues. So even though I didn't like merging the stuff, I had to. Rusty too in a recent mail mentioned he sees both the drivers as one because the functionlities are similar. > On the other hand, this patch allows more than one console (I have not tested > this feature) and with this fix applied I dont see any obvious problems. Note though that to use the multiple consoles, you'll have to modify your userspace to handle the new messages that get passed between the host and the guest (one can argue I've done the guest part; you only have the host part to be done :-)) > For the console part I can give a > Acked-by: Christian Borntraeger <borntraeger(a)de.ibm.com> (console) Thanks again. I'll put this in the next spin. > Ignoring my preference for having a separate driver and devids, I have no > opinion about the generic communication stuff - no ack or nack. Amit -- To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to majordomo(a)vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html Please read the FAQ at http://www.tux.org/lkml/
From: Amit Shah on 29 Sep 2009 09:30 On (Tue) Sep 29 2009 [22:41:45], Rusty Russell wrote: > On Fri, 11 Sep 2009 11:43:06 pm Amit Shah wrote: > > Expose multiple char devices ("ports") for simple communication > > between the host userspace and guest. > > OK, I think other comments have died down, so it's time for a review. This > was the latest patch I could find. I just sent a new patch in this thread; can you please review that one? > The obvious way to do this is to use multiple pairs of virtqueues. Is this > silly for some reason? Yes, we're restricted to 32k ports. There were a couple of things to note about that: - Avi, in the past, mentioned separate ivq and ovqs for each port for the kind of usage intended would be overkill. - With the MSI rework, we can't init new i/ovqs for hotplugged ports as we find them. The queues all have to be init'ed at probe() time. I had some discussion with Michael some time back on virtualization@, but thought the overhead of implementing that would be high. > It means that if we see the MULTIQUEUE feature, we can look for the other > queues. Our current MSI-X friendly API makes that a little painful, but > if we resolve that our code should be sweetness, no? If this is to solve the port numbering, etc., issues, I've thought of a new way this can be done in the newest patch. What's more, Christian tested it on s390 as well and it worked with a minor tweak. I tested the new patch with combinations of qemu and kernel (old/new) and they worked fine. Thanks, Amit -- To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to majordomo(a)vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html Please read the FAQ at http://www.tux.org/lkml/
From: Amit Shah on 30 Sep 2009 13:20
On (Tue) Sep 29 2009 [15:31:23], Christian Borntraeger wrote: > Am Dienstag 29 September 2009 15:09:50 schrieb Amit Shah: > > Great, thanks. However I was thinking of moving this init to the probe() > > routine instead of in the init_conosle routine just because multiple > > consoles can be added and we don't want to init this each time.. just > > once in probe is fine. > > If you have new patch CC me and I can give it a spin. Hey Christian, I have a new patch that changes a few things: - moves the put_char fix to probe instead of doing it in init_port_console(), which gets called on each console port found. - uses port->id instead of a static hvc_vtermno to pass on a value to hvc_alloc(). Motivation explained within comments in the code. - A few other changes that introduce and make use of port->vcon instead of accessing the static virtconsole directly -- aimed at easing future fix to have multiple virtio-console devices. It would be great if you could test this. Amit diff --git a/drivers/char/Kconfig b/drivers/char/Kconfig index 6a06913..7b4602f 100644 --- a/drivers/char/Kconfig +++ b/drivers/char/Kconfig @@ -679,6 +679,12 @@ config VIRTIO_CONSOLE help Virtio console for use with lguest and other hypervisors. + Also serves as a general-purpose serial device for data + transfer between the guest and host. Character devices at + /dev/vconNN will be created when corresponding ports are + found. If specified by the host, a sysfs attribute called + 'name' will be populated with a name for the port which can + be used by udev scripts to create a symlink to /dev/vconNN. config HVCS tristate "IBM Hypervisor Virtual Console Server support" diff --git a/drivers/char/virtio_console.c b/drivers/char/virtio_console.c index 0d328b5..16cdcec 100644 --- a/drivers/char/virtio_console.c +++ b/drivers/char/virtio_console.c @@ -9,10 +9,8 @@ * functions. :*/ -/*M:002 The console can be flooded: while the Guest is processing input the - * Host can send more. Buffering in the Host could alleviate this, but it is a - * difficult problem in general. :*/ /* Copyright (C) 2006, 2007 Rusty Russell, IBM Corporation + * Copyright (C) 2009, Amit Shah, Red Hat, Inc. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -28,115 +26,468 @@ * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include <linux/cdev.h> +#include <linux/device.h> #include <linux/err.h> +#include <linux/fs.h> #include <linux/init.h> +#include <linux/poll.h> +#include <linux/spinlock.h> #include <linux/virtio.h> #include <linux/virtio_ids.h> #include <linux/virtio_console.h> +#include <linux/workqueue.h> #include "hvc_console.h" -/*D:340 These represent our input and output console queues, and the virtio - * operations for them. */ -static struct virtqueue *in_vq, *out_vq; -static struct virtio_device *vdev; +/* This struct stores data that's common to all the ports */ +struct virtio_console_struct { + /* + * Workqueue handlers where we process deferred work after an + * interrupt + */ + struct work_struct rx_work; + struct work_struct tx_work; + struct work_struct config_work; -/* This is our input buffer, and how much data is left in it. */ -static unsigned int in_len; -static char *in, *inbuf; + struct list_head port_head; + struct list_head unused_read_head; + struct list_head unused_write_head; -/* The operations for our console. */ -static struct hv_ops virtio_cons; + /* To protect the list of unused write buffers */ + spinlock_t write_list_lock; -/* The hvc device */ -static struct hvc_struct *hvc; + struct virtio_device *vdev; + struct class *class; + /* The input and the output queues */ + struct virtqueue *in_vq, *out_vq; -/*D:310 The put_chars() callback is pretty straightforward. - * - * We turn the characters into a scatter-gather list, add it to the output - * queue and then kick the Host. Then we sit here waiting for it to finish: - * inefficient in theory, but in practice implementations will do it - * immediately (lguest's Launcher does). */ -static int put_chars(u32 vtermno, const char *buf, int count) + /* The current config space is stored here */ + struct virtio_console_config config; +}; + +/* This struct holds individual buffers received for each port */ +struct virtio_console_port_buffer { + struct list_head next; + + char *buf; + + /* length of the buffer */ + size_t len; + /* offset in the buf from which to consume data */ + size_t offset; +}; + +/* This struct holds the per-port data */ +struct virtio_console_port { + /* Next port in the list, head is in the virtio_console_struct */ + struct list_head next; + + /* Pointer to the virtio_console device */ + struct virtio_console_struct *vcon; + + /* Buffer management */ + struct list_head readbuf_head; + + /* A waitqueue for poll() or blocking read operations */ + wait_queue_head_t waitqueue; + + /* Each port associates with a separate char device */ + struct cdev cdev; + struct device *dev; + + /* The hvc device, if this port is associated with a console */ + struct hvc_struct *hvc; + + /* The 'name' of the port that we expose via sysfs properties */ + char *name; + + /* The 'id' to identify the port with the Host */ + u32 id; + + /* Is the host device open */ + bool host_connected; +}; + +static struct virtio_console_struct virtconsole; + +static struct virtio_console_port *get_port_from_devt(dev_t devt) { - struct scatterlist sg[1]; - unsigned int len; - - /* This is a convenient routine to initialize a single-elem sg list */ - sg_init_one(sg, buf, count); - - /* add_buf wants a token to identify this buffer: we hand it any - * non-NULL pointer, since there's only ever one buffer. */ - if (out_vq->vq_ops->add_buf(out_vq, sg, 1, 0, (void *)1) >= 0) { - /* Tell Host to go! */ - out_vq->vq_ops->kick(out_vq); - /* Chill out until it's done with the buffer. */ - while (!out_vq->vq_ops->get_buf(out_vq, &len)) - cpu_relax(); + struct virtio_console_port *port; + + list_for_each_entry(port, &virtconsole.port_head, next) { + if (port->dev->devt == devt) + return port; } + return NULL; +} + +static struct virtio_console_port *get_port_from_id(u32 id) +{ + struct virtio_console_port *port; - /* We're expected to return the amount of data we wrote: all of it. */ - return count; + list_for_each_entry(port, &virtconsole.port_head, next) { + if (port->id == id) + return port; + } + return NULL; } -/* Create a scatter-gather list representing our input buffer and put it in the - * queue. */ -static void add_inbuf(void) +static int get_id_from_port(struct virtio_console_port *port) { - struct scatterlist sg[1]; - sg_init_one(sg, inbuf, PAGE_SIZE); + return port->id; +} - /* We should always be able to add one buffer to an empty queue. */ - if (in_vq->vq_ops->add_buf(in_vq, sg, 0, 1, inbuf) < 0) - BUG(); - in_vq->vq_ops->kick(in_vq); +static bool is_console_port(struct virtio_console_port *port) +{ + if (port->hvc) + return true; + return false; } -/*D:350 get_chars() is the callback from the hvc_console infrastructure when - * an interrupt is received. - * - * Most of the code deals with the fact that the hvc_console() infrastructure - * only asks us for 16 bytes at a time. We keep in_offset and in_used fields - * for partially-filled buffers. */ -static int get_chars(u32 vtermno, char *buf, int count) +static inline bool use_multiport(void) { - /* If we don't have an input queue yet, we can't get input. */ - BUG_ON(!in_vq); + /* + * This condition can be true when put_chars is called from + * early_init + */ + if (!virtconsole.vdev) + return 0; + return virtconsole.vdev->features[0] & (1 << VIRTIO_CONSOLE_F_MULTIPORT); +} + +static inline bool is_internal(u32 flags) +{ + return flags & VIRTIO_CONSOLE_ID_INTERNAL; +} + +/* + * Give out the data that's requested from the buffers that we have + * queued up per port + */ +static ssize_t fill_readbuf(struct virtio_console_port *port, + char *out_buf, size_t out_count, bool to_user) +{ + struct virtio_console_port_buffer *buf, *buf2; + ssize_t out_offset, ret; + + out_offset = 0; + list_for_each_entry_safe(buf, buf2, &port->readbuf_head, next) { + size_t copy_size; + + copy_size = out_count; + if (copy_size > buf->len - buf->offset) + copy_size = buf->len - buf->offset; + + if (to_user) { + ret = copy_to_user(out_buf + out_offset, + buf->buf + buf->offset, + copy_size); + /* FIXME: Deal with ret != 0 */ + } else { + memcpy(out_buf + out_offset, + buf->buf + buf->offset, + copy_size); + ret = 0; /* Emulate copy_to_user behaviour */ + } + + /* Return the number of bytes actually copied */ + ret = copy_size - ret; + buf->offset += ret; + out_offset += ret; + out_count -= ret; + + if (buf->len - buf->offset == 0) { + list_del(&buf->next); + kfree(buf->buf); + kfree(buf); + } + if (!out_count) + break; + } + return out_offset; +} + +/* The condition that must be true for polling to end */ +static bool wait_is_over(struct virtio_console_port *port) +{ + return !list_empty(&port->readbuf_head) || !port->host_connected; +} + +static ssize_t virtconsole_read(struct file *filp, char __user *ubuf, + size_t count, loff_t *offp) +{ + struct virtio_console_port *port; + ssize_t ret; + + port = filp->private_data; - /* No buffer? Try to get one. */ - if (!in_len) { - in = in_vq->vq_ops->get_buf(in_vq, &in_len); - if (!in) + if (list_empty(&port->readbuf_head)) { + /* + * If nothing's connected on the host just return 0 in + * case of list_empty; this tells the userspace app + * that there's no connection + */ + if (!port->host_connected) return 0; + if (filp->f_flags & O_NONBLOCK) + return -EAGAIN; + + ret = wait_event_interruptible(port->waitqueue, + wait_is_over(port)); + if (ret < 0) + return ret; } + /* + * We could've received a disconnection message while we were + * waiting for more data. + * + * This check is not clubbed in the if() statement above as we + * might receive some data as well as the host could get + * disconnected after we got woken up from our wait. So we + * really want to give off whatever data we have and only then + * check for host_connected + */ + if (list_empty(&port->readbuf_head) && !port->host_connected) + return 0; - /* You want more than we have to give? Well, try wanting less! */ - if (in_len < count) - count = in_len; + return fill_readbuf(port, ubuf, count, true); +} + +static ssize_t send_buf(struct virtio_console_port *port, + const char *in_buf, size_t in_count, + u32 flags, bool from_user) +{ + struct virtqueue *out_vq; + struct virtio_console_port_buffer *buf, *buf2; + struct scatterlist sg[1]; + struct virtio_console_header header; + size_t in_offset, copy_size; + ssize_t ret; + unsigned int header_len; + + if (!in_count) + return 0; + + out_vq = virtconsole.out_vq; + /* + * We should not send internal messages to a host that won't + * understand them + */ + if (!use_multiport() && is_internal(flags)) + return 0; + header_len = 0; + if (use_multiport()) { + header.id = get_id_from_port(port); + header.flags = flags; + header.size = in_count; + header_len = sizeof(header); + } + in_offset = 0; /* offset in the user buffer */ + while (in_count - in_offset) { + copy_size = min(in_count - in_offset + header_len, PAGE_SIZE); - /* Copy across to their buffer and increment offset. */ - memcpy(buf, in, count); - in += count; - in_len -= count; + spin_lock(&virtconsole.write_list_lock); + list_for_each_entry_safe(buf, buf2, + &virtconsole.unused_write_head, + next) { + list_del(&buf->next); + break; + } + spin_unlock(&virtconsole.write_list_lock); + if (!buf) + break; + if (header_len) { + memcpy(buf->buf, &header, header_len); + copy_size -= header_len; + } + if (from_user) + ret = copy_from_user(buf->buf + header_len, + in_buf + in_offset, copy_size); + else { + /* + * Since we're not sure when the host will actually + * consume the data and tell us about it, we have + * to copy the data here in case the caller + * frees the in_buf + */ + memcpy(buf->buf + header_len, + in_buf + in_offset, copy_size); + ret = 0; /* Emulate copy_from_user behaviour */ + } + buf->len = header_len + copy_size - ret; + sg_init_one(sg, buf->buf, buf->len); - /* Finished? Re-register buffer so Host will use it again. */ - if (in_len == 0) - add_inbuf(); + ret = out_vq->vq_ops->add_buf(out_vq, sg, 1, 0, buf); + if (ret < 0) { + memset(buf->buf, 0, buf->len); + spin_lock(&virtconsole.write_list_lock); + list_add_tail(&buf->next, + &virtconsole.unused_write_head); + spin_unlock(&virtconsole.write_list_lock); + break; + } + in_offset += buf->len - header_len; + /* + * Only send size with the first buffer. This way + * userspace can find out a continuous stream of data + * belonging to one write request and consume it + * appropriately + */ + header.size = 0; - return count; + /* No space left in the vq anyway */ + if (!ret) + break; + } + /* Tell Host to go! */ + out_vq->vq_ops->kick(out_vq); + + /* We're expected to return the amount of data we wrote */ + return in_offset; } -/*:*/ -/*D:320 Console drivers are initialized very early so boot messages can go out, - * so we do things slightly differently from the generic virtio initialization - * of the net and block drivers. +static ssize_t virtconsole_write(struct file *filp, const char __user *ubuf, + size_t count, loff_t *offp) +{ + struct virtio_console_port *port; + + port = filp->private_data; + + return send_buf(port, ubuf, count, 0, true); +} + +static unsigned int virtconsole_poll(struct file *filp, poll_table *wait) +{ + struct virtio_console_port *port; + unsigned int ret; + + port = filp->private_data; + poll_wait(filp, &port->waitqueue, wait); + + ret = 0; + if (!list_empty(&port->readbuf_head)) + ret |= POLLIN | POLLRDNORM; + if (!port->host_connected) + ret |= POLLHUP; + + return ret; +} + +static int virtconsole_release(struct inode *inode, struct file *filp) +{ + struct virtio_console_control cpkt; + + /* Notify host of port being closed */ + cpkt.event = VIRTIO_CONSOLE_PORT_OPEN; + cpkt.value = 0; + send_buf(filp->private_data, (char *)&cpkt, sizeof(cpkt), + VIRTIO_CONSOLE_ID_INTERNAL, false); + return 0; +} + +static int virtconsole_open(struct inode *inode, struct file *filp) +{ + struct cdev *cdev = inode->i_cdev; + struct virtio_console_port *port; + struct virtio_console_control cpkt; + + port = container_of(cdev, struct virtio_console_port, cdev); + filp->private_data = port; + + /* Notify host of port being opened */ + cpkt.event = VIRTIO_CONSOLE_PORT_OPEN; + cpkt.value = 1; + send_buf(filp->private_data, (char *)&cpkt, sizeof(cpkt), + VIRTIO_CONSOLE_ID_INTERNAL, false); + + return 0; +} + +/* + * The file operations that we support: programs in the guest can open + * a console device, read from it, write to it, poll for data and + * close it. The devices are at /dev/vconNN + */ +static const struct file_operations virtconsole_fops = { + .owner = THIS_MODULE, + .open = virtconsole_open, + .read = virtconsole_read, + .write = virtconsole_write, + .poll = virtconsole_poll, + .release = virtconsole_release, +}; + + +static ssize_t show_port_name(struct device *dev, + struct device_attribute *attr, char *buffer) +{ + struct virtio_console_port *port; + + port = get_port_from_devt(dev->devt); + if (!port || !port->name) + return 0; + + return sprintf(buffer, "%s\n", port->name); +} + +static DEVICE_ATTR(name, S_IRUGO, show_port_name, NULL); + +static struct attribute *virtcon_sysfs_entries[] = { + &dev_attr_name.attr, + NULL +}; + +static struct attribute_group virtcon_attribute_group = { + .name = NULL, /* put in device directory */ + .attrs = virtcon_sysfs_entries, +}; + + +/*D:310 + * The cons_put_chars() callback is pretty straightforward. * - * At this stage, the console is output-only. It's too early to set up a - * virtqueue, so we let the drivers do some boutique early-output thing. */ -int __init virtio_cons_early_init(int (*put_chars)(u32, const char *, int)) + * We turn the characters into a scatter-gather list, add it to the output + * queue and then kick the Host. + * + * If the data to be outpu spans more than a page, it's split into + * page-sized buffers and then individual buffers are pushed to Host. + */ +static int cons_put_chars(u32 vtermno, const char *buf, int count) { - virtio_cons.put_chars = put_chars; - return hvc_instantiate(0, 0, &virtio_cons); + struct virtio_console_port *port; + + port = get_port_from_id(vtermno); + if (!port) + return 0; + + return send_buf(port, buf, count, 0, false); +} + +/*D:350 + * cons_get_chars() is the callback from the hvc_console + * infrastructure when an interrupt is received. + * + * We call out to fill_readbuf that gets us the required data from the + * buffers that are queued up. + */ +static int cons_get_chars(u32 vtermno, char *buf, int count) +{ + struct virtio_console_port *port; + + /* If we don't have an input queue yet, we can't get input. */ + BUG_ON(!virtconsole.in_vq); + + port = get_port_from_id(vtermno); + if (!port) + return 0; + + if (list_empty(&port->readbuf_head)) + return 0; + + return fill_readbuf(port, buf, count, false); } +/*:*/ /* * virtio console configuration. This supports: @@ -153,98 +504,579 @@ static void virtcons_apply_config(struct virtio_device *dev) dev->config->get(dev, offsetof(struct virtio_console_config, rows), &ws.ws_row, sizeof(u16)); - hvc_resize(hvc, ws); + /* + * We'll use this way of resizing only for legacy + * support. For newer userspace (VIRTIO_CONSOLE_F_MULTPORT+), + * use internal messages to indicate console size + * changes so that it can be done per-port + */ + if (!use_multiport()) + hvc_resize(get_port_from_id(0)->hvc, ws); } } /* - * we support only one console, the hvc struct is a global var * We set the configuration at this point, since we now have a tty */ -static int notifier_add_vio(struct hvc_struct *hp, int data) +static int cons_notifier_add_vio(struct hvc_struct *hp, int data) { hp->irq_requested = 1; - virtcons_apply_config(vdev); + virtcons_apply_config(virtconsole.vdev); return 0; } -static void notifier_del_vio(struct hvc_struct *hp, int data) +static void cons_notifier_del_vio(struct hvc_struct *hp, int data) { hp->irq_requested = 0; } -static void hvc_handle_input(struct virtqueue *vq) +/* The operations for our console. */ +static struct hv_ops virtio_cons = { + .get_chars = cons_get_chars, + .put_chars = cons_put_chars, + .notifier_add = cons_notifier_add_vio, + .notifier_del = cons_notifier_del_vio, + .notifier_hangup = cons_notifier_del_vio, +}; + +/*D:320 + * Console drivers are initialized very early so boot messages can go out, + * so we do things slightly differently from the generic virtio initialization + * of the net and block drivers. + * + * At this stage, the console is output-only. It's too early to set up a + * virtqueue, so we let the drivers do some boutique early-output thing. + */ +int __init virtio_cons_early_init(int (*put_chars)(u32, const char *, int)) { - if (hvc_poll(hvc)) - hvc_kick(); + virtio_cons.put_chars = put_chars; + return hvc_instantiate(0, 0, &virtio_cons); } -/*D:370 Once we're further in boot, we get probed like any other virtio device. - * At this stage we set up the output virtqueue. +int init_port_console(struct virtio_console_port *port) +{ + int ret = 0; + + /* + * The Host's telling us this port is a console port. Hook it + * up with an hvc console. + * + * To set up and manage our virtual console, we call + * hvc_alloc(). + * + * The first argument of hvc_alloc() is the virtual console + * number. hvc_alloc() checks if a console with the same value + * was used in hvc_instantiate(). We may not end up passing + * the same value here (we use the value 0 in + * hvc_instantiate() but the console port may not be at id + * 0). This isn't a problem, though. Nothing in hvc really + * depends on these numbers and since this number is passed on + * to us when cons_get/put_chars() is called, it's preferable + * to pass on the port->id so that we can get the port struct + * via get_port_from_id(). + * + * The second argument is the parameter for the notification + * mechanism (like irq number). We currently leave this as + * zero, virtqueues have implicit notifications. + * + * The third argument is a "struct hv_ops" containing the + * put_chars() get_chars(), notifier_add() and notifier_del() + * pointers. The final argument is the output buffer size: we + * can do any size, so we put PAGE_SIZE here. + */ + port->hvc = hvc_alloc(port->id, 0, &virtio_cons, PAGE_SIZE); + if (IS_ERR(port->hvc)) { + ret = PTR_ERR(port->hvc); + pr_err("%s: Could not alloc hvc for virtio console port, ret = %d\n", + __func__, ret); + port->hvc = NULL; + } + return ret; +} + +/* Any secret messages that the Host and Guest want to share */ +static void handle_control_message(struct virtio_console_port *port, + struct virtio_console_port_buffer *buf) +{ + struct virtio_console_control *cpkt; + size_t name_size; + + cpkt = (struct virtio_console_control *)(buf->buf + buf->offset); + + switch (cpkt->event) { + case VIRTIO_CONSOLE_PORT_OPEN: + port->host_connected = cpkt->value; + break; + case VIRTIO_CONSOLE_PORT_NAME: + /* + * Skip the size of the header and the cpkt to get the size + * of the name that was sent + */ + name_size = buf->len - buf->offset - sizeof(*cpkt) + 1; + + port->name = kmalloc(name_size, GFP_KERNEL); + if (!port->name) { + pr_err("%s: not enough space to store port name\n", + __func__); + break; + } + strncpy(port->name, buf->buf + buf->offset + sizeof(*cpkt), + name_size - 1); + port->name[name_size - 1] = 0; + break; + case VIRTIO_CONSOLE_CONSOLE_PORT: + if (!cpkt->value) + break; + init_port_console(port); + /* + * Could remove the port here in case init fails - but + * have to notify the host first + */ + break; + } +} + + +static struct virtio_console_port_buffer *get_buf(size_t buf_size) +{ + struct virtio_console_port_buffer *buf; + + buf = kzalloc(sizeof(*buf), GFP_KERNEL); + if (!buf) + goto out; + buf->buf = kzalloc(buf_size, GFP_KERNEL); + if (!buf->buf) { + kfree(buf); + goto out; + } + buf->len = buf_size; +out: + return buf; +} + +static void fill_queue(struct virtqueue *vq, size_t buf_size, + struct list_head *unused_head) +{ + struct scatterlist sg[1]; + struct virtio_console_port_buffer *buf; + int ret; + + do { + buf = get_buf(buf_size); + if (!buf) + break; + sg_init_one(sg, buf->buf, buf_size); + + ret = vq->vq_ops->add_buf(vq, sg, 0, 1, buf); + if (ret < 0) { + kfree(buf->buf); + kfree(buf); + break; + } + /* We have to keep track of the unused buffers + * so that they can be freed when the module + * is being removed + */ + list_add_tail(&buf->next, unused_head); + } while (ret > 0); + vq->vq_ops->kick(vq); +} + +static void fill_receive_queue(struct virtio_console_struct *vcon) +{ + fill_queue(vcon->in_vq, PAGE_SIZE, &vcon->unused_read_head); +} + +/* + * This function is only called from the init routine so the spinlock + * for the unused_write_head list isn't taken + */ +static void alloc_write_bufs(struct virtio_console_struct *vcon) +{ + struct virtio_console_port_buffer *buf; + int i; + + for (i = 0; i < 1024; i++) { + buf = get_buf(PAGE_SIZE); + if (!buf) + break; + list_add_tail(&buf->next, &vcon->unused_write_head); + } +} + +/* + * The workhandler for any buffers that appear on our input queue. + * Pick the buffer; if it's some internal communication meant for the + * us, just process it. Otherwise queue it up for the read() or + * get_chars() routines to pick the data up later. + */ +static void virtio_console_rx_work_handler(struct work_struct *work) +{ + struct virtio_console_struct *vcon; + struct virtio_console_port *port; + struct virtio_console_port_buffer *buf; + struct virtio_console_header header; + struct virtqueue *vq; + unsigned int tmplen, header_len; + + vcon = container_of(work, struct virtio_console_struct, rx_work); + header_len = use_multiport() ? sizeof(header) : 0; + + port = NULL; + vq = vcon->in_vq; + while ((buf = vq->vq_ops->get_buf(vq, &tmplen))) { + /* The buffer is no longer unused */ + list_del(&buf->next); + + if (use_multiport()) { + memcpy(&header, buf->buf, header_len); + port = get_port_from_id(header.id); + } else + port = get_port_from_id(0); + if (!port) { + /* No valid header at start of buffer. Drop it. */ + pr_debug("%s: invalid index in buffer, %c %d\n", + __func__, buf->buf[0], buf->buf[0]); + /* + * OPT: This buffer can be added to the unused + * list to avoid free / alloc + */ + kfree(buf->buf); + kfree(buf); + break; + } + buf->len = tmplen; + buf->offset = header_len; + if (use_multiport() && is_internal(header.flags)) { + handle_control_message(port, buf); + /* + * OPT: This buffer can be added to the unused + * list to avoid free/alloc + */ + kfree(buf->buf); + kfree(buf); + } else { + list_add_tail(&buf->next, &port->readbuf_head); + /* + * We might have missed a connection + * notification, e.g. before the queues were + * initialised. + */ + port->host_connected = true; + } + wake_up_interruptible(&port->waitqueue); + } + if (port) { + if(is_console_port(port) && !list_empty(&port->readbuf_head)) + if (hvc_poll(port->hvc)) + hvc_kick(); + /* Allocate buffers for all the ones that got used up */ + fill_receive_queue(port->vcon); + } +} + +/* + * This is the workhandler for buffers that get received on the output + * virtqueue, which is an indication that Host consumed the data we + * sent it. Since all our buffers going out are of a fixed size we can + * just reuse them instead of freeing them and allocating new ones. * - * To set up and manage our virtual console, we call hvc_alloc(). Since we - * never remove the console device we never need this pointer again. + * Zero out the buffer so that we don't leak any information from + * other processes. There's a small optimisation here as well: the + * buffers are PAGE_SIZE-sized; but instead of zeroing the entire + * page, we just zero the length that was most recently used and we + * can be sure the rest of the page is already set to 0s. * - * Finally we put our input buffer in the input queue, ready to receive. */ -static int __devinit virtcons_probe(struct virtio_device *dev) + * So once we zero them out we add them back to the unused buffers + * list + */ +static void virtio_console_tx_work_handler(struct work_struct *work) { - vq_callback_t *callbacks[] = { hvc_handle_input, NULL}; + struct virtio_console_struct *vcon; + struct virtqueue *vq; + struct virtio_console_port_buffer *buf; + unsigned int tmplen; + + vcon = container_of(work, struct virtio_console_struct, tx_work); + + vq = vcon->out_vq; + while ((buf = vq->vq_ops->get_buf(vq, &tmplen))) { + /* 0 the buffer to not leak data from other processes */ + memset(buf->buf, 0, buf->len); + spin_lock(&vcon->write_list_lock); + list_add_tail(&buf->next, &vcon->unused_write_head); + spin_unlock(&vcon->write_list_lock); + } +} + +static void rx_intr(struct virtqueue *vq) +{ + schedule_work(&virtconsole.rx_work); +} + +static void tx_intr(struct virtqueue *vq) +{ + schedule_work(&virtconsole.tx_work); +} + +static void config_intr(struct virtio_device *vdev) +{ + /* Handle port hot-add */ + schedule_work(&virtconsole.config_work); + + /* Handle console size changes */ + virtcons_apply_config(vdev); +} + +static int virtconsole_add_port(u32 port_nr) +{ + struct virtio_console_port *port; + struct virtio_console_control cpkt; + dev_t devt; + int ret; + + port = kzalloc(sizeof(*port), GFP_KERNEL); + if (!port) + return -ENOMEM; + + port->vcon = &virtconsole; + port->id = port_nr; + + cdev_init(&port->cdev, &virtconsole_fops); + + ret = alloc_chrdev_region(&devt, 0, 1, "virtio-console"); + if (ret < 0) { + pr_err("%s: error allocing chrdev region, ret = %d\n", + __func__, ret); + goto free_port; + } + ret = cdev_add(&port->cdev, devt, 1); + if (ret < 0) { + pr_err("%s: error adding cdev, ret = %d\n", __func__, ret); + goto free_chrdev; + } + port->dev = device_create(port->vcon->class, NULL, devt, NULL, + "vcon%u", port_nr); + if (IS_ERR(port->dev)) { + ret = PTR_ERR(port->dev); + pr_err("%s: error creating device, ret = %d\n", __func__, ret); + goto free_cdev; + } + ret = sysfs_create_group(&port->dev->kobj, &virtcon_attribute_group); + if (ret) { + pr_err("%s: error creating sysfs device attributes, ret = %d\n", + __func__, ret); + goto free_cdev; + } + + INIT_LIST_HEAD(&port->readbuf_head); + init_waitqueue_head(&port->waitqueue); + + list_add_tail(&port->next, &port->vcon->port_head); + + /* + * Ask for the port's name from Host. The string that we + * receive in 'name' can be of arbitrary length; so pass the + * maximum available buffer size: PAGE_SIZE. + */ + cpkt.event = VIRTIO_CONSOLE_PORT_NAME; + send_buf(port, (char *)&cpkt, sizeof(cpkt), + VIRTIO_CONSOLE_ID_INTERNAL, false); + + /* + * If we're not using multiport support, this has to be a console port + */ + if (!use_multiport()) { + ret = init_port_console(port); + if (ret) + goto free_cdev; + } + + pr_debug("virtio-console port found at id %u\n", port_nr); + + return 0; +free_cdev: + cdev_del(&port->cdev); +free_chrdev: + unregister_chrdev_region(devt, 1); +free_port: + kfree(port); + return ret; +} + + +/* The workhandler for config-space updates + * + * This is used when new ports are added + */ +static void virtio_console_config_work_handler(struct work_struct *work) +{ + struct virtio_console_struct *vcon; + struct virtio_console_config virtconconf; + struct virtio_device *vdev; + u32 i; + int ret; + + vcon = container_of(work, struct virtio_console_struct, config_work); + + vdev = vcon->vdev; + vdev->config->get(vdev, + offsetof(struct virtio_console_config, nr_active_ports), + &virtconconf.nr_active_ports, + sizeof(virtconconf.nr_active_ports)); + + /* Hot-add ports */ + for (i = virtconsole.config.nr_active_ports; + i < virtconconf.nr_active_ports; i++) { + ret = virtconsole_add_port(virtconsole.config.nr_active_ports + i); + if (!ret) + virtconsole.config.nr_active_ports++; + } +} + +/*D:370 + * Once we're further in boot, we get probed like any other virtio device. + * At this stage we set up the output virtqueue. + * + * Finally we put our input buffer in the input queue, ready to receive. + */ +static int __devinit virtcons_probe(struct virtio_device *vdev) +{ + vq_callback_t *callbacks[] = { rx_intr, tx_intr }; const char *names[] = { "input", "output" }; struct virtqueue *vqs[2]; - int err; + u32 i; + int ret; + bool multiport; - vdev = dev; - - /* This is the scratch page we use to receive console input */ - inbuf = kmalloc(PAGE_SIZE, GFP_KERNEL); - if (!inbuf) { - err = -ENOMEM; - goto fail; + if (virtconsole.vdev) { + pr_err("Multiple virtio-console devices not supported yet\n"); + return -EEXIST; } + virtconsole.vdev = vdev; + multiport = false; + if (virtio_has_feature(vdev, VIRTIO_CONSOLE_F_MULTIPORT)) { + multiport = true; + vdev->features[0] |= 1 << VIRTIO_CONSOLE_F_MULTIPORT; + vdev->config->finalize_features(vdev); + + vdev->config->get(vdev, offsetof(struct virtio_console_config, + nr_active_ports), + &virtconsole.config.nr_active_ports, + sizeof(virtconsole.config.nr_active_ports)); + } /* Find the queues. */ /* FIXME: This is why we want to wean off hvc: we do nothing * when input comes in. */ - err = vdev->config->find_vqs(vdev, 2, vqs, callbacks, names); - if (err) - goto free; + ret = vdev->config->find_vqs(vdev, 2, vqs, callbacks, names); + if (ret) + goto fail; - in_vq = vqs[0]; - out_vq = vqs[1]; + virtconsole.in_vq = vqs[0]; + virtconsole.out_vq = vqs[1]; - /* Start using the new console output. */ - virtio_cons.get_chars = get_chars; - virtio_cons.put_chars = put_chars; - virtio_cons.notifier_add = notifier_add_vio; - virtio_cons.notifier_del = notifier_del_vio; - virtio_cons.notifier_hangup = notifier_del_vio; - - /* The first argument of hvc_alloc() is the virtual console number, so - * we use zero. The second argument is the parameter for the - * notification mechanism (like irq number). We currently leave this - * as zero, virtqueues have implicit notifications. - * - * The third argument is a "struct hv_ops" containing the put_chars() - * get_chars(), notifier_add() and notifier_del() pointers. - * The final argument is the output buffer size: we can do any size, - * so we put PAGE_SIZE here. */ - hvc = hvc_alloc(0, 0, &virtio_cons, PAGE_SIZE); - if (IS_ERR(hvc)) { - err = PTR_ERR(hvc); - goto free_vqs; + /* + * We had set the virtio_cons put_chars implementation to + * put_chars for early_init. Now that we're done with the + * early init phase, replace it with our cons_put_chars + * implementation. + */ + virtio_cons.put_chars = cons_put_chars; + + INIT_LIST_HEAD(&virtconsole.port_head); + INIT_LIST_HEAD(&virtconsole.unused_read_head); + INIT_LIST_HEAD(&virtconsole.unused_write_head); + + INIT_WORK(&virtconsole.rx_work, &virtio_console_rx_work_handler); + INIT_WORK(&virtconsole.tx_work, &virtio_console_tx_work_handler); + INIT_WORK(&virtconsole.config_work, &virtio_console_config_work_handler); + spin_lock_init(&virtconsole.write_list_lock); + + fill_receive_queue(&virtconsole); + alloc_write_bufs(&virtconsole); + + virtconsole_add_port(0); + if (multiport) + for (i = 1; i < virtconsole.config.nr_active_ports; i++) + virtconsole_add_port(i); + + return 0; + +fail: + return ret; +} + +/* + * Remove port-specific data. + * In case the port can't be removed, return non-zero. This could + * then be used in the port hot-unplug case. + */ +static int virtcons_remove_port_data(struct virtio_console_port *port) +{ + struct virtio_console_port_buffer *buf, *buf2; + + if (is_console_port(port)) { + /* hvc_console is compiled in, at least on Fedora. */ + /* hvc_remove(hvc); */ + return 1; } - /* Register the input buffer the first time. */ - add_inbuf(); + sysfs_remove_group(&port->dev->kobj, &virtcon_attribute_group); + device_destroy(virtconsole.class, port->dev->devt); + unregister_chrdev_region(port->dev->devt, 1); + cdev_del(&port->cdev); + + kfree(port->name); + + /* Remove the buffers in which we have unconsumed data */ + list_for_each_entry_safe(buf, buf2, &port->readbuf_head, next) { + list_del(&buf->next); + kfree(buf->buf); + kfree(buf); + } return 0; +} + +static void virtcons_remove(struct virtio_device *vdev) +{ + struct virtio_console_port *port, *port2; + struct virtio_console_port_buffer *buf, *buf2; + char *tmpbuf; + int len; + + class_destroy(virtconsole.class); + + cancel_work_sync(&virtconsole.rx_work); + /* + * Free up the buffers that we queued up for the Host to pass + * us data + */ + while ((tmpbuf = virtconsole.in_vq->vq_ops->get_buf(virtconsole.in_vq, + &len))) + kfree(tmpbuf); -free_vqs: vdev->config->del_vqs(vdev); -free: - kfree(inbuf); -fail: - return err; + /* + * Free up the buffers that were sent to us by Host but were + * left unused + */ + list_for_each_entry_safe(buf, buf2, &virtconsole.unused_read_head, next) { + list_del(&buf->next); + kfree(buf->buf); + kfree(buf); + } + list_for_each_entry_safe(buf, buf2, &virtconsole.unused_write_head, next) { + list_del(&buf->next); + kfree(buf->buf); + kfree(buf); + } + list_for_each_entry_safe(port, port2, &virtconsole.port_head, next) { + list_del(&port->next); + virtcons_remove_port_data(port); + kfree(port); + } } static struct virtio_device_id id_table[] = { @@ -254,6 +1086,7 @@ static struct virtio_device_id id_table[] = { static unsigned int features[] = { VIRTIO_CONSOLE_F_SIZE, + VIRTIO_CONSOLE_F_MULTIPORT, }; static struct virtio_driver virtio_console = { @@ -263,14 +1096,34 @@ static struct virtio_driver virtio_console = { .driver.owner = THIS_MODULE, .id_table = id_table, .probe = virtcons_probe, - .config_changed = virtcons_apply_config, + .remove = virtcons_remove, + .config_changed = config_intr, }; static int __init init(void) { - return register_virtio_driver(&virtio_console); + int ret; + + virtconsole.class = class_create(THIS_MODULE, "virtio-console"); + if (IS_ERR(virtconsole.class)) { + pr_err("Error creating virtio-console class\n"); + ret = PTR_ERR(virtconsole.class); + return ret; + } + ret = register_virtio_driver(&virtio_console); + if (ret) { + class_destroy(virtconsole.class); + return ret; + } + return 0; +} + +static void __exit fini(void) +{ + unregister_virtio_driver(&virtio_console); } module_init(init); +module_exit(fini); MODULE_DEVICE_TABLE(virtio, id_table); MODULE_DESCRIPTION("Virtio console driver"); diff --git a/include/linux/virtio_console.h b/include/linux/virtio_console.h index b5f5198..96bb6f0 100644 --- a/include/linux/virtio_console.h +++ b/include/linux/virtio_console.h @@ -2,19 +2,63 @@ #define _LINUX_VIRTIO_CONSOLE_H #include <linux/types.h> #include <linux/virtio_config.h> -/* This header, excluding the #ifdef __KERNEL__ part, is BSD licensed so - * anyone can use the definitions to implement compatible drivers/servers. */ +/* + * This header, excluding the #ifdef __KERNEL__ part, is BSD licensed so + * anyone can use the definitions to implement compatible drivers/servers. + * + * Copyright (C) Red Hat, Inc., 2009 + */ /* Feature bits */ #define VIRTIO_CONSOLE_F_SIZE 0 /* Does host provide console size? */ +#define VIRTIO_CONSOLE_F_MULTIPORT 1 /* Does host provide multiple ports? */ + +#define VIRTIO_CONSOLE_BAD_ID (~(u32)0) /* Invalid port number */ struct virtio_console_config { /* colums of the screens */ __u16 cols; /* rows of the screens */ __u16 rows; + /* number of ports in use */ + __u32 nr_active_ports; +} __attribute__((packed)); + + +/* + * An internal-only message that's passed between the Host and the + * Guest for a particular port. + */ +struct virtio_console_control { + __u16 event; + __u16 value; +}; + +/* Some events for internal messages (control packets) */ +#define VIRTIO_CONSOLE_PORT_OPEN 0 +#define VIRTIO_CONSOLE_PORT_NAME 1 +#define VIRTIO_CONSOLE_CONSOLE_PORT 2 + + +/* + * This struct is put in each buffer that gets passed to userspace and + * vice-versa + */ +struct virtio_console_header { + /* Port number */ + u32 id; + /* Some message between host and guest */ + u32 flags; + /* + * Complete size of the write request - only sent with the + * first buffer for each write request + */ + u32 size; } __attribute__((packed)); +/* Messages between host and guest ('flags' field in the header above) */ +#define VIRTIO_CONSOLE_ID_INTERNAL (1 << 0) + #ifdef __KERNEL__ int __init virtio_cons_early_init(int (*put_chars)(u32, const char *, int)); -- To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to majordomo(a)vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html Please read the FAQ at http://www.tux.org/lkml/ |