Date: Thu, 23 Oct 2014 04:47:33 +0000 (UTC) From: Bryan Venteicher <bryanv@FreeBSD.org> To: src-committers@freebsd.org, svn-src-all@freebsd.org, svn-src-head@freebsd.org Subject: svn commit: r273515 - in head: share/man/man4 sys/dev/virtio/console sys/modules/virtio sys/modules/virtio/console Message-ID: <201410230447.s9N4lXih092846@svn.freebsd.org>
next in thread | raw e-mail | index | archive | help
Author: bryanv Date: Thu Oct 23 04:47:32 2014 New Revision: 273515 URL: https://svnweb.freebsd.org/changeset/base/273515 Log: Add VirtIO console driver Support for the multiport feature is mostly implemented, but currently disabled due to some potential races in the hot plug code paths. Requested by: marcel MFC after: 1 month Relnotes: yes Added: head/share/man/man4/virtio_console.4 (contents, props changed) head/sys/dev/virtio/console/ head/sys/dev/virtio/console/virtio_console.c (contents, props changed) head/sys/dev/virtio/console/virtio_console.h (contents, props changed) head/sys/modules/virtio/console/ head/sys/modules/virtio/console/Makefile (contents, props changed) Modified: head/share/man/man4/Makefile head/share/man/man4/virtio.4 head/sys/modules/virtio/Makefile Modified: head/share/man/man4/Makefile ============================================================================== --- head/share/man/man4/Makefile Thu Oct 23 03:13:14 2014 (r273514) +++ head/share/man/man4/Makefile Thu Oct 23 04:47:32 2014 (r273515) @@ -563,6 +563,7 @@ MAN= aac.4 \ ${_virtio.4} \ ${_virtio_balloon.4} \ ${_virtio_blk.4} \ + ${_virtio_console.4} \ ${_virtio_random.4} \ ${_virtio_scsi.4} \ vkbd.4 \ @@ -814,6 +815,7 @@ _nxge.4= nxge.4 _virtio.4= virtio.4 _virtio_balloon.4=virtio_balloon.4 _virtio_blk.4= virtio_blk.4 +_virtio_console.4=virtio_console.4 _virtio_random.4= virtio_random.4 _virtio_scsi.4= virtio_scsi.4 _vmx.4= vmx.4 Modified: head/share/man/man4/virtio.4 ============================================================================== --- head/share/man/man4/virtio.4 Thu Oct 23 03:13:14 2014 (r273514) +++ head/share/man/man4/virtio.4 Thu Oct 23 04:47:32 2014 (r273515) @@ -85,6 +85,7 @@ device driver. .Sh SEE ALSO .Xr virtio_balloon 4 , .Xr virtio_blk 4 , +.Xr virtio_console 4 , .Xr virtio_scsi 4 , .Xr vtnet 4 .Sh HISTORY Added: head/share/man/man4/virtio_console.4 ============================================================================== --- /dev/null 00:00:00 1970 (empty, because file is newly added) +++ head/share/man/man4/virtio_console.4 Thu Oct 23 04:47:32 2014 (r273515) @@ -0,0 +1,66 @@ +.\" Copyright (c) 2014 Bryan Venteicher +.\" All rights reserved. +.\" +.\" Redistribution and use in source and binary forms, with or without +.\" modification, are permitted provided that the following conditions +.\" are met: +.\" 1. Redistributions of source code must retain the above copyright +.\" notice, this list of conditions and the following disclaimer. +.\" 2. Redistributions in binary form must reproduce the above copyright +.\" notice, this list of conditions and the following disclaimer in the +.\" documentation and/or other materials provided with the distribution. +.\" +.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND +.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +.\" ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE +.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +.\" SUCH DAMAGE. +.\" +.\" $FreeBSD$ +.\" +.Dd October 22, 2014 +.Dt VIRTIO_CONSOLE 4 +.Os +.Sh NAME +.Nm virtio_console +.Nd VirtIO Console driver +.Sh SYNOPSIS +To compile this driver into the kernel, +place the following lines in your +kernel configuration file: +.Bd -ragged -offset indent +.Cd "device virtio_console" +.Ed +.Pp +Alternatively, to load the driver as a +module at boot time, place the following line in +.Xr loader.conf 5 : +.Bd -literal -offset indent +virtio_console_load="YES" +.Ed +.Sh DESCRIPTION +The +.Nm +device driver provides support for VirtIO console devices. +.Pp +The console device may have one or more ports. +Each port is similar to a simple serial interface, and +each port is accessible through +.Xr tty 4 . +.Sh FILES +.Bl -tag -width ".Pa /dev/ttyV?.??" -compact +.It Pa /dev/ttyV?.?? +.Sh SEE ALSO +.Xr tty 4 +.Xr virtio 4 +.Sh HISTORY +The +.Nm +driver was written by +.An Bryan Venteicher Aq bryanv@FreeBSD.org . Added: head/sys/dev/virtio/console/virtio_console.c ============================================================================== --- /dev/null 00:00:00 1970 (empty, because file is newly added) +++ head/sys/dev/virtio/console/virtio_console.c Thu Oct 23 04:47:32 2014 (r273515) @@ -0,0 +1,1238 @@ +/*- + * Copyright (c) 2014, Bryan Venteicher <bryanv@FreeBSD.org> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice unmodified, this list of conditions, and the following + * disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/* Driver for VirtIO console devices. */ + +#include <sys/cdefs.h> +__FBSDID("$FreeBSD$"); + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/kernel.h> +#include <sys/malloc.h> +#include <sys/module.h> +#include <sys/lock.h> +#include <sys/mutex.h> +#include <sys/sglist.h> +#include <sys/sysctl.h> +#include <sys/taskqueue.h> +#include <sys/queue.h> + +#include <sys/conf.h> +#include <sys/cons.h> +#include <sys/tty.h> + +#include <machine/bus.h> +#include <machine/resource.h> +#include <sys/bus.h> + +#include <dev/virtio/virtio.h> +#include <dev/virtio/virtqueue.h> +#include <dev/virtio/console/virtio_console.h> + +#include "virtio_if.h" + +#define VTCON_MAX_PORTS 1 +#define VTCON_TTY_PREFIX "V" +#define VTCON_BULK_BUFSZ 128 + +struct vtcon_softc; + +struct vtcon_port { + struct vtcon_softc *vtcport_sc; + TAILQ_ENTRY(vtcon_port) vtcport_next; + struct mtx vtcport_mtx; + int vtcport_id; + struct tty *vtcport_tty; + struct virtqueue *vtcport_invq; + struct virtqueue *vtcport_outvq; + char vtcport_name[16]; +}; + +#define VTCON_PORT_MTX(_port) &(_port)->vtcport_mtx +#define VTCON_PORT_LOCK_INIT(_port) \ + mtx_init(VTCON_PORT_MTX((_port)), (_port)->vtcport_name, NULL, MTX_DEF) +#define VTCON_PORT_LOCK(_port) mtx_lock(VTCON_PORT_MTX((_port))) +#define VTCON_PORT_UNLOCK(_port) mtx_unlock(VTCON_PORT_MTX((_port))) +#define VTCON_PORT_LOCK_DESTROY(_port) mtx_destroy(VTCON_PORT_MTX((_port))) +#define VTCON_PORT_LOCK_ASSERT(_port) \ + mtx_assert(VTCON_PORT_MTX((_port)), MA_OWNED) +#define VTCON_PORT_LOCK_ASSERT_NOTOWNED(_port) \ + mtx_assert(VTCON_PORT_MTX((_port)), MA_NOTOWNED) + +struct vtcon_softc { + device_t vtcon_dev; + struct mtx vtcon_mtx; + uint64_t vtcon_features; + uint32_t vtcon_flags; +#define VTCON_FLAG_DETACHED 0x0001 +#define VTCON_FLAG_SIZE 0x0010 +#define VTCON_FLAG_MULTIPORT 0x0020 + + struct task vtcon_ctrl_task; + struct virtqueue *vtcon_ctrl_rxvq; + struct virtqueue *vtcon_ctrl_txvq; + + uint32_t vtcon_max_ports; + TAILQ_HEAD(, vtcon_port) + vtcon_ports; + + /* + * Ports can be added and removed during runtime, but we have + * to allocate all the virtqueues during attach. This array is + * indexed by the port ID. + */ + struct vtcon_port_extra { + struct vtcon_port *port; + struct virtqueue *invq; + struct virtqueue *outvq; + } *vtcon_portsx; +}; + +#define VTCON_MTX(_sc) &(_sc)->vtcon_mtx +#define VTCON_LOCK_INIT(_sc, _name) \ + mtx_init(VTCON_MTX((_sc)), (_name), NULL, MTX_DEF) +#define VTCON_LOCK(_sc) mtx_lock(VTCON_MTX((_sc))) +#define VTCON_UNLOCK(_sc) mtx_unlock(VTCON_MTX((_sc))) +#define VTCON_LOCK_DESTROY(_sc) mtx_destroy(VTCON_MTX((_sc))) +#define VTCON_LOCK_ASSERT(_sc) mtx_assert(VTCON_MTX((_sc)), MA_OWNED) +#define VTCON_LOCK_ASSERT_NOTOWNED(_sc) \ + mtx_assert(VTCON_MTX((_sc)), MA_NOTOWNED) + +#define VTCON_ASSERT_VALID_PORTID(_sc, _id) \ + KASSERT((_id) >= 0 && (_id) < (_sc)->vtcon_max_ports, \ + ("%s: port ID %d out of range", __func__, _id)) + +#define VTCON_FEATURES 0 + +static struct virtio_feature_desc vtcon_feature_desc[] = { + { VIRTIO_CONSOLE_F_SIZE, "ConsoleSize" }, + { VIRTIO_CONSOLE_F_MULTIPORT, "MultiplePorts" }, + + { 0, NULL } +}; + +static int vtcon_modevent(module_t, int, void *); + +static int vtcon_probe(device_t); +static int vtcon_attach(device_t); +static int vtcon_detach(device_t); +static int vtcon_config_change(device_t); + +static void vtcon_negotiate_features(struct vtcon_softc *); +static int vtcon_alloc_virtqueues(struct vtcon_softc *); +static void vtcon_read_config(struct vtcon_softc *, + struct virtio_console_config *); + +static void vtcon_determine_max_ports(struct vtcon_softc *, + struct virtio_console_config *); +static void vtcon_deinit_ports(struct vtcon_softc *); +static void vtcon_stop(struct vtcon_softc *); + +static void vtcon_ctrl_rx_vq_intr(void *); +static int vtcon_ctrl_enqueue_msg(struct vtcon_softc *, + struct virtio_console_control *); +static int vtcon_ctrl_add_msg(struct vtcon_softc *); +static void vtcon_ctrl_readd_msg(struct vtcon_softc *, + struct virtio_console_control *); +static int vtcon_ctrl_populate(struct vtcon_softc *); +static void vtcon_ctrl_send_msg(struct vtcon_softc *, + struct virtio_console_control *control); +static void vtcon_ctrl_send_event(struct vtcon_softc *, uint32_t, + uint16_t, uint16_t); +static int vtcon_ctrl_init(struct vtcon_softc *); +static void vtcon_ctrl_drain(struct vtcon_softc *); +static void vtcon_ctrl_deinit(struct vtcon_softc *); +static void vtcon_ctrl_port_add_event(struct vtcon_softc *, int); +static void vtcon_ctrl_port_remove_event(struct vtcon_softc *, int); +static void vtcon_ctrl_port_console_event(struct vtcon_softc *, int); +static void vtcon_ctrl_port_open_event(struct vtcon_softc *, int); +static void vtcon_ctrl_process_msg(struct vtcon_softc *, + struct virtio_console_control *); +static void vtcon_ctrl_task_cb(void *, int); + +static int vtcon_port_add_inbuf(struct vtcon_port *); +static void vtcon_port_readd_inbuf(struct vtcon_port *, void *); +static int vtcon_port_populate(struct vtcon_port *); +static void vtcon_port_destroy(struct vtcon_port *); +static int vtcon_port_create(struct vtcon_softc *, int, + struct vtcon_port **); +static void vtcon_port_drain_inbufs(struct vtcon_port *); +static void vtcon_port_teardown(struct vtcon_port *, int); +static void vtcon_port_change_size(struct vtcon_port *, uint16_t, + uint16_t); +static void vtcon_port_enable_intr(struct vtcon_port *); +static void vtcon_port_disable_intr(struct vtcon_port *); +static void vtcon_port_intr(struct vtcon_port *); +static void vtcon_port_in_vq_intr(void *); +static void vtcon_port_put(struct vtcon_port *, void *, int); +static void vtcon_port_send_ctrl_msg(struct vtcon_port *, uint16_t, + uint16_t); +static struct vtcon_port *vtcon_port_lookup_by_id(struct vtcon_softc *, int); + +static int vtcon_tty_open(struct tty *); +static void vtcon_tty_close(struct tty *); +static void vtcon_tty_outwakeup(struct tty *); +static void vtcon_tty_free(void *); + +static void vtcon_get_console_size(struct vtcon_softc *, uint16_t *, + uint16_t *); + +static void vtcon_enable_interrupts(struct vtcon_softc *); +static void vtcon_disable_interrupts(struct vtcon_softc *); + +static int vtcon_pending_free; + +static struct ttydevsw vtcon_tty_class = { + .tsw_flags = 0, + .tsw_open = vtcon_tty_open, + .tsw_close = vtcon_tty_close, + .tsw_outwakeup = vtcon_tty_outwakeup, + .tsw_free = vtcon_tty_free, +}; + +static device_method_t vtcon_methods[] = { + /* Device methods. */ + DEVMETHOD(device_probe, vtcon_probe), + DEVMETHOD(device_attach, vtcon_attach), + DEVMETHOD(device_detach, vtcon_detach), + + /* VirtIO methods. */ + DEVMETHOD(virtio_config_change, vtcon_config_change), + + DEVMETHOD_END +}; + +static driver_t vtcon_driver = { + "vtcon", + vtcon_methods, + sizeof(struct vtcon_softc) +}; +static devclass_t vtcon_devclass; + +DRIVER_MODULE(virtio_console, virtio_pci, vtcon_driver, vtcon_devclass, + vtcon_modevent, 0); +MODULE_VERSION(virtio_console, 1); +MODULE_DEPEND(virtio_console, virtio, 1, 1, 1); + +static int +vtcon_modevent(module_t mod, int type, void *unused) +{ + int error; + + switch (type) { + case MOD_LOAD: + error = 0; + break; + case MOD_QUIESCE: + case MOD_UNLOAD: + error = vtcon_pending_free != 0 ? EBUSY : 0; + /* error = EOPNOTSUPP; */ + break; + case MOD_SHUTDOWN: + error = 0; + break; + default: + error = EOPNOTSUPP; + break; + } + + return (error); +} + +static int +vtcon_probe(device_t dev) +{ + + if (virtio_get_device_type(dev) != VIRTIO_ID_CONSOLE) + return (ENXIO); + + device_set_desc(dev, "VirtIO Console Adapter"); + + return (BUS_PROBE_DEFAULT); +} + +static int +vtcon_attach(device_t dev) +{ + struct vtcon_softc *sc; + struct virtio_console_config concfg; + int error; + + sc = device_get_softc(dev); + sc->vtcon_dev = dev; + + VTCON_LOCK_INIT(sc, device_get_nameunit(dev)); + TASK_INIT(&sc->vtcon_ctrl_task, 0, vtcon_ctrl_task_cb, sc); + TAILQ_INIT(&sc->vtcon_ports); + + virtio_set_feature_desc(dev, vtcon_feature_desc); + vtcon_negotiate_features(sc); + + if (virtio_with_feature(dev, VIRTIO_CONSOLE_F_SIZE)) + sc->vtcon_flags |= VTCON_FLAG_SIZE; + if (virtio_with_feature(dev, VIRTIO_CONSOLE_F_MULTIPORT)) + sc->vtcon_flags |= VTCON_FLAG_MULTIPORT; + + vtcon_read_config(sc, &concfg); + vtcon_determine_max_ports(sc, &concfg); + + error = vtcon_alloc_virtqueues(sc); + if (error) { + device_printf(dev, "cannot allocate virtqueues\n"); + goto fail; + } + + if (sc->vtcon_flags & VTCON_FLAG_MULTIPORT) + error = vtcon_ctrl_init(sc); + else + error = vtcon_port_create(sc, 0, NULL); + if (error) + goto fail; + + error = virtio_setup_intr(dev, INTR_TYPE_TTY); + if (error) { + device_printf(dev, "cannot setup virtqueue interrupts\n"); + goto fail; + } + + vtcon_enable_interrupts(sc); + + vtcon_ctrl_send_event(sc, VIRTIO_CONSOLE_BAD_ID, + VIRTIO_CONSOLE_DEVICE_READY, 1); + +fail: + if (error) + vtcon_detach(dev); + + return (error); +} + +static int +vtcon_detach(device_t dev) +{ + struct vtcon_softc *sc; + + sc = device_get_softc(dev); + + VTCON_LOCK(sc); + sc->vtcon_flags |= VTCON_FLAG_DETACHED; + if (device_is_attached(dev)) + vtcon_stop(sc); + VTCON_UNLOCK(sc); + + taskqueue_drain(taskqueue_thread, &sc->vtcon_ctrl_task); + + if (sc->vtcon_flags & VTCON_FLAG_MULTIPORT) + vtcon_ctrl_deinit(sc); + + vtcon_deinit_ports(sc); + + VTCON_LOCK_DESTROY(sc); + + return (0); +} + +static int +vtcon_config_change(device_t dev) +{ + struct vtcon_softc *sc; + struct vtcon_port *port; + uint16_t cols, rows; + + sc = device_get_softc(dev); + + /* + * With the multiport feature, all configuration changes are + * done through control virtqueue events. This is a spurious + * interrupt. + */ + if (sc->vtcon_flags & VTCON_FLAG_MULTIPORT) + return (0); + + if (sc->vtcon_flags & VTCON_FLAG_SIZE) { + /* + * For now, assume the first (only) port is the 'console'. + * Note QEMU does not implement this feature yet. + */ + VTCON_LOCK(sc); + if ((port = vtcon_port_lookup_by_id(sc, 0)) != NULL) { + vtcon_get_console_size(sc, &cols, &rows); + vtcon_port_change_size(port, cols, rows); + } + VTCON_UNLOCK(sc); + } + + return (0); +} + +static void +vtcon_negotiate_features(struct vtcon_softc *sc) +{ + device_t dev; + uint64_t features; + + dev = sc->vtcon_dev; + features = VTCON_FEATURES; + + sc->vtcon_features = virtio_negotiate_features(dev, features); +} + +#define VTCON_GET_CONFIG(_dev, _feature, _field, _cfg) \ + if (virtio_with_feature(_dev, _feature)) { \ + virtio_read_device_config(_dev, \ + offsetof(struct virtio_console_config, _field), \ + &(_cfg)->_field, sizeof((_cfg)->_field)); \ + } + +static void +vtcon_read_config(struct vtcon_softc *sc, struct virtio_console_config *concfg) +{ + device_t dev; + + dev = sc->vtcon_dev; + + bzero(concfg, sizeof(struct virtio_console_config)); + + /* Read the configuration if the feature was negotiated. */ + VTCON_GET_CONFIG(dev, VIRTIO_CONSOLE_F_SIZE, cols, concfg); + VTCON_GET_CONFIG(dev, VIRTIO_CONSOLE_F_SIZE, rows, concfg); + VTCON_GET_CONFIG(dev, VIRTIO_CONSOLE_F_MULTIPORT, max_nr_ports, concfg); +} + +#undef VTCON_GET_CONFIG + +static int +vtcon_alloc_virtqueues(struct vtcon_softc *sc) +{ + device_t dev; + struct vq_alloc_info *info; + struct vtcon_port_extra *portx; + int i, idx, portidx, nvqs, error; + + dev = sc->vtcon_dev; + + sc->vtcon_portsx = malloc(sizeof(struct vtcon_port_extra) * + sc->vtcon_max_ports, M_DEVBUF, M_NOWAIT | M_ZERO); + if (sc->vtcon_portsx == NULL) + return (ENOMEM); + + nvqs = sc->vtcon_max_ports * 2; + if (sc->vtcon_flags & VTCON_FLAG_MULTIPORT) + nvqs += 2; + + info = malloc(sizeof(struct vq_alloc_info) * nvqs, M_TEMP, M_NOWAIT); + if (info == NULL) + return (ENOMEM); + + for (i = 0, idx = 0, portidx = 0; i < nvqs / 2; i++, idx+=2) { + + if (i == 1) { + /* The control virtqueues are after the first port. */ + VQ_ALLOC_INFO_INIT(&info[idx], 0, + vtcon_ctrl_rx_vq_intr, sc, &sc->vtcon_ctrl_rxvq, + "%s-control rx", device_get_nameunit(dev)); + VQ_ALLOC_INFO_INIT(&info[idx+1], 0, + NULL, sc, &sc->vtcon_ctrl_txvq, + "%s-control tx", device_get_nameunit(dev)); + continue; + } + + portx = &sc->vtcon_portsx[portidx]; + + VQ_ALLOC_INFO_INIT(&info[idx], 0, vtcon_port_in_vq_intr, + portx, &portx->invq, "%s-port%d in", + device_get_nameunit(dev), portidx); + VQ_ALLOC_INFO_INIT(&info[idx+1], 0, NULL, + NULL, &portx->outvq, "%s-port%d out", + device_get_nameunit(dev), portidx); + + portidx++; + } + + error = virtio_alloc_virtqueues(dev, 0, nvqs, info); + free(info, M_TEMP); + + return (error); +} + +static void +vtcon_determine_max_ports(struct vtcon_softc *sc, + struct virtio_console_config *concfg) +{ + + if (sc->vtcon_flags & VTCON_FLAG_MULTIPORT) { + sc->vtcon_max_ports = + min(concfg->max_nr_ports, VTCON_MAX_PORTS); + if (sc->vtcon_max_ports == 0) + sc->vtcon_max_ports = 1; + } else + sc->vtcon_max_ports = 1; +} + +static void +vtcon_deinit_ports(struct vtcon_softc *sc) +{ + struct vtcon_port *port, *tmp; + + TAILQ_FOREACH_SAFE(port, &sc->vtcon_ports, vtcport_next, tmp) { + vtcon_port_teardown(port, 1); + } + + if (sc->vtcon_portsx != NULL) { + free(sc->vtcon_portsx, M_DEVBUF); + sc->vtcon_portsx = NULL; + } +} + +static void +vtcon_stop(struct vtcon_softc *sc) +{ + + vtcon_disable_interrupts(sc); + virtio_stop(sc->vtcon_dev); +} + +static void +vtcon_ctrl_rx_vq_intr(void *xsc) +{ + struct vtcon_softc *sc; + + sc = xsc; + + /* + * Some events require us to potentially block, but it easier + * to just defer all event handling to a seperate thread. + */ + taskqueue_enqueue(taskqueue_thread, &sc->vtcon_ctrl_task); +} + +static int +vtcon_ctrl_enqueue_msg(struct vtcon_softc *sc, + struct virtio_console_control *control) +{ + struct sglist_seg segs[1]; + struct sglist sg; + struct virtqueue *vq; + int error __unused; + + vq = sc->vtcon_ctrl_rxvq; + + sglist_init(&sg, 1, segs); + error = sglist_append(&sg, control, sizeof(*control)); + KASSERT(error == 0 && sg.sg_nseg == 1, + ("%s: error %d adding control msg to sglist", __func__, error)); + + return (virtqueue_enqueue(vq, control, &sg, 0, 1)); +} + +static int +vtcon_ctrl_add_msg(struct vtcon_softc *sc) +{ + struct virtio_console_control *control; + int error; + + control = malloc(sizeof(*control), M_DEVBUF, M_ZERO | M_NOWAIT); + if (control == NULL) + return (ENOMEM); + + error = vtcon_ctrl_enqueue_msg(sc, control); + if (error) + free(control, M_DEVBUF); + + return (error); +} + +static void +vtcon_ctrl_readd_msg(struct vtcon_softc *sc, + struct virtio_console_control *control) +{ + int error; + + bzero(control, sizeof(*control)); + + error = vtcon_ctrl_enqueue_msg(sc, control); + KASSERT(error == 0, + ("%s: cannot requeue control buffer %d", __func__, error)); +} + +static int +vtcon_ctrl_populate(struct vtcon_softc *sc) +{ + struct virtqueue *vq; + int nbufs, error; + + vq = sc->vtcon_ctrl_rxvq; + error = ENOSPC; + + for (nbufs = 0; !virtqueue_full(vq); nbufs++) { + error = vtcon_ctrl_add_msg(sc); + if (error) + break; + } + + if (nbufs > 0) { + virtqueue_notify(vq); + /* + * EMSGSIZE signifies the virtqueue did not have enough + * entries available to hold the last buf. This is not + * an error. + */ + if (error == EMSGSIZE) + error = 0; + } + + return (error); +} + +static void +vtcon_ctrl_send_msg(struct vtcon_softc *sc, + struct virtio_console_control *control) +{ + struct sglist_seg segs[1]; + struct sglist sg; + struct virtqueue *vq; + int error; + + vq = sc->vtcon_ctrl_txvq; + KASSERT(virtqueue_empty(vq), + ("%s: virtqueue is not emtpy", __func__)); + + sglist_init(&sg, 1, segs); + error = sglist_append(&sg, control, sizeof(*control)); + KASSERT(error == 0 && sg.sg_nseg == 1, + ("%s: error %d adding control msg to sglist", __func__, error)); + + error = virtqueue_enqueue(vq, control, &sg, 1, 0); + if (error == 0) { + virtqueue_notify(vq); + virtqueue_poll(vq, NULL); + } +} + +static void +vtcon_ctrl_send_event(struct vtcon_softc *sc, uint32_t portid, uint16_t event, + uint16_t value) +{ + struct virtio_console_control control; + + if ((sc->vtcon_flags & VTCON_FLAG_MULTIPORT) == 0) + return; + + control.id = portid; + control.event = event; + control.value = value; + + vtcon_ctrl_send_msg(sc, &control); +} + +static int +vtcon_ctrl_init(struct vtcon_softc *sc) +{ + int error; + + error = vtcon_ctrl_populate(sc); + + return (error); +} + +static void +vtcon_ctrl_drain(struct vtcon_softc *sc) +{ + struct virtio_console_control *control; + struct virtqueue *vq; + int last; + + vq = sc->vtcon_ctrl_rxvq; + last = 0; + + if (vq == NULL) + return; + + while ((control = virtqueue_drain(vq, &last)) != NULL) + free(control, M_DEVBUF); +} + +static void +vtcon_ctrl_deinit(struct vtcon_softc *sc) +{ + + vtcon_ctrl_drain(sc); +} + +static void +vtcon_ctrl_port_add_event(struct vtcon_softc *sc, int id) +{ + device_t dev; + struct vtcon_port *port; + int error; + + dev = sc->vtcon_dev; + + if (vtcon_port_lookup_by_id(sc, id) != NULL) { + device_printf(dev, "%s: adding port %d, but already exists\n", + __func__, id); + return; + } + + error = vtcon_port_create(sc, id, &port); + if (error) { + device_printf(dev, "%s: cannot create port %d: %d\n", + __func__, id, error); + return; + } + + vtcon_port_send_ctrl_msg(port, VIRTIO_CONSOLE_PORT_READY, 1); +} + +static void +vtcon_ctrl_port_remove_event(struct vtcon_softc *sc, int id) +{ + device_t dev; + struct vtcon_port *port; + + dev = sc->vtcon_dev; + + port = vtcon_port_lookup_by_id(sc, id); + if (port == NULL) { + device_printf(dev, "%s: remove port %d, but does not exist\n", + __func__, id); + return; + } + + vtcon_port_teardown(port, 1); +} + +static void +vtcon_ctrl_port_console_event(struct vtcon_softc *sc, int id) +{ + device_t dev; + + dev = sc->vtcon_dev; + + /* + * BMV: I don't think we need to do anything. + */ + device_printf(dev, "%s: port %d console event\n", __func__, id); +} + +static void +vtcon_ctrl_port_open_event(struct vtcon_softc *sc, int id) +{ + device_t dev; + struct vtcon_port *port; + + dev = sc->vtcon_dev; + + port = vtcon_port_lookup_by_id(sc, id); + if (port == NULL) { + device_printf(dev, "%s: open port %d, but does not exist\n", + __func__, id); + return; + } + + vtcon_port_enable_intr(port); +} + +static void +vtcon_ctrl_process_msg(struct vtcon_softc *sc, + struct virtio_console_control *control) +{ + device_t dev; + int id; + + dev = sc->vtcon_dev; + id = control->id; + + if (id < 0 || id >= sc->vtcon_max_ports) { + device_printf(dev, "%s: invalid port ID %d\n", __func__, id); + return; + } + + switch (control->event) { + case VIRTIO_CONSOLE_PORT_ADD: + vtcon_ctrl_port_add_event(sc, id); + break; + + case VIRTIO_CONSOLE_PORT_REMOVE: + vtcon_ctrl_port_remove_event(sc, id); + break; + + case VIRTIO_CONSOLE_CONSOLE_PORT: + vtcon_ctrl_port_console_event(sc, id); + break; + + case VIRTIO_CONSOLE_RESIZE: + break; + + case VIRTIO_CONSOLE_PORT_OPEN: + vtcon_ctrl_port_open_event(sc, id); + break; + + case VIRTIO_CONSOLE_PORT_NAME: + break; + } +} + +static void +vtcon_ctrl_task_cb(void *xsc, int pending) +{ + struct vtcon_softc *sc; + struct virtqueue *vq; + struct virtio_console_control *control; + + sc = xsc; + vq = sc->vtcon_ctrl_rxvq; + + VTCON_LOCK(sc); + while ((sc->vtcon_flags & VTCON_FLAG_DETACHED) == 0) { + control = virtqueue_dequeue(vq, NULL); + if (control == NULL) + break; + + VTCON_UNLOCK(sc); + vtcon_ctrl_process_msg(sc, control); + VTCON_LOCK(sc); + vtcon_ctrl_readd_msg(sc, control); + } + VTCON_UNLOCK(sc); + + if (virtqueue_enable_intr(vq) != 0) + taskqueue_enqueue(taskqueue_thread, &sc->vtcon_ctrl_task); +} + +static int +vtcon_port_enqueue_inbuf(struct vtcon_port *port, void *buf, size_t len) +{ + struct sglist_seg segs[1]; + struct sglist sg; + struct virtqueue *vq; + int error; + + vq = port->vtcport_invq; + + sglist_init(&sg, 1, segs); + error = sglist_append(&sg, buf, len); + KASSERT(error == 0 && sg.sg_nseg == 1, + ("%s: error %d adding buffer to sglist", __func__, error)); + + return (virtqueue_enqueue(vq, buf, &sg, 0, 1)); +} + +static int +vtcon_port_add_inbuf(struct vtcon_port *port) +{ + void *buf; + int error; + + buf = malloc(VTCON_BULK_BUFSZ, M_DEVBUF, M_ZERO | M_NOWAIT); + if (buf == NULL) + return (ENOMEM); + + error = vtcon_port_enqueue_inbuf(port, buf, VTCON_BULK_BUFSZ); + if (error) + free(buf, M_DEVBUF); + + return (error); +} + +static void +vtcon_port_readd_inbuf(struct vtcon_port *port, void *buf) +{ + int error __unused; + + error = vtcon_port_enqueue_inbuf(port, buf, VTCON_BULK_BUFSZ); + KASSERT(error == 0, + ("%s: cannot requeue input buffer %d", __func__, error)); +} + +static int +vtcon_port_populate(struct vtcon_port *port) +{ + struct virtqueue *vq; + int nbufs, error; + + vq = port->vtcport_invq; + error = ENOSPC; + + for (nbufs = 0; !virtqueue_full(vq); nbufs++) { + error = vtcon_port_add_inbuf(port); + if (error) + break; + } + + if (nbufs > 0) { + virtqueue_notify(vq); + /* + * EMSGSIZE signifies the virtqueue did not have enough + * entries available to hold the last buf. This is not + * an error. + */ + if (error == EMSGSIZE) + error = 0; + } + + return (error); +} + *** DIFF OUTPUT TRUNCATED AT 1000 LINES ***
Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?201410230447.s9N4lXih092846>