virtio-console

// vi:ft=cpp
/* SPDX-License-Identifier: MIT */
/*
 * Copyright (C) 2019-2023 Kernkonzept GmbH.
 * Author(s): Sarah Hoffmann <sarah.hoffmann@kernkonzept.com>
 *            Phillip Raffeck <phillip.raffeck@kernkonzept.com>
 *            Steffen Liebergeld <steffen.liebergeld@kernkonzept.com>
 *            Jan Klötzke <jan.kloetzke@kernkonzept.com>
 */
#pragma once
 
#include <l4/l4virtio/server/l4virtio>
#include <l4/re/error_helper>
 
namespace L4virtio { namespace Svr { namespace Console {
 
struct Features : Dev_config::Features
{
  Features() = default;
  explicit Features(l4_uint32_t raw) : Dev_config::Features(raw) {}
  CXX_BITFIELD_MEMBER(0, 0, console_size, raw);
  CXX_BITFIELD_MEMBER(1, 1, console_multiport, raw);
  CXX_BITFIELD_MEMBER(2, 2, emerg_write, raw);
};
 
struct Control_message
{
  enum Events
  {
    Device_ready  = 0,
    Device_add    = 1,
    Device_remove = 2,
    Port_ready    = 3,
    Console_port  = 4,
    Resize        = 5,
    Port_open     = 6,
    Port_name     = 7,
  };
 
  l4_uint32_t id; 
  l4_uint16_t event; 
  l4_uint16_t value; 
 
  Control_message() {}
  Control_message(l4_uint32_t i, l4_uint16_t e, l4_uint16_t v)
  : id(i), event(e), value(v)
  {}
};
 
struct Control_request
{
  Control_message *msg;
  l4_uint32_t len;
  Driver_mem_region *mem;
};
 
struct Port
{
  enum Port_status
  {
    Port_disabled = 0,
    Port_added,
    Port_ready,
    Port_open,
    Port_failed
  };
 
  enum { Control_queue_size = 0x10 };
 
  Virtqueue tx; 
  Virtqueue rx; 
  Port_status status; 
  unsigned vq_max; 
 
  Port() : status(Port_disabled), vq_max(Control_queue_size) {}
  Port(Port const &) = delete;
  Port &operator = (Port const &) = delete;
 
  virtual ~Port() = default;
 
  bool is_open() const
  { return status == Port_open; }
 
  virtual void reset()
  {
    status = Port_disabled;
  }
 
  bool queues_ready() const
  { return tx.ready() && rx.ready(); }
 
  bool rx_ready() const
  { return is_open() && rx.ready(); }
 
  bool tx_ready() const
  { return is_open() && tx.ready(); }
};
 
class Virtio_con : public L4virtio::Svr::Device
{
  enum Virtqueue_names
  {
    Ctrl_rx = 2, 
    Ctrl_tx = 3, 
  };
 
  struct Serial_config_space
  {
    l4_uint16_t cols;
    l4_uint16_t rows;
    l4_uint32_t max_nr_ports;
    l4_uint32_t emerg_wr;
  } __attribute__((packed));
 
public:
  explicit Virtio_con(unsigned max_ports, bool enable_multiport)
  : L4virtio::Svr::Device(&_dev_config),
    _num_ports(enable_multiport ? max_ports : 1),
    _dev_config(L4VIRTIO_VENDOR_KK, L4VIRTIO_ID_CONSOLE,
                enable_multiport ? max_ports * 2 + 2 : 2)
  {
    if (_num_ports < 1)
      L4Re::chksys(-L4_EINVAL, "At least one port is required.");
 
    Features hf(0);
 
    hf.console_multiport() = enable_multiport;
 
    _dev_config.host_features(0) = hf.raw;
 
    if (enable_multiport)
      _dev_config.priv_config()->max_nr_ports = _num_ports;
    _dev_config.reset_hdr();
  }
 
  void reset_queue_configs()
  {
    for (unsigned q = 0; q < _dev_config.num_queues(); ++q)
      reset_queue_config(q, max_queue_size(q));
  }
 
  int reconfig_queue(unsigned index) override
  {
    if (index >= _dev_config.num_queues())
      return -L4_ERANGE;
 
    if (setup_queue(get_queue(index), index, max_queue_size(index)))
      return 0;
 
    return -L4_EINVAL;
  }
 
  bool multiport_enabled() const
  {
    return _negotiated_features.console_multiport()
              && _dev_config.num_queues() > Ctrl_rx;
  }
 
  bool ctrl_queue_ready() const
  { return _ctrl_port.is_open(); }
 
  bool check_features(void) override
  {
    _negotiated_features = Features(_dev_config.negotiated_features(0));
    return true;
  }
 
  bool check_queues() override
  {
    // NOTE
    // The VIRTIO specification states:
    // "The port 0 receive and transmit queues always exist"
    // The linux driver however does not setup port 0 if the multiport feature
    // is negotiated.
    // We just go along with the linux driver and do not expect port 0 to be up,
    // if the multiport feature is negotiated.
 
    if (multiport_enabled())
      // If MULTIPORT was negotiated, ctrl queues should be set up.
      return _ctrl_port.queues_ready();
 
    // If MULTIPORT was not negotiated, port 0 should be set up.
    port(0)->status = Port::Port_open;
    return port(0)->queues_ready();
  }
 
  int port_add(unsigned idx)
  {
    Port *p = port(idx);
 
    if (p->status != Port::Port_disabled)
      return -L4_EPERM;
 
    int ret = send_control_message(idx, Control_message::Device_add);
 
    if (ret == L4_EOK)
      p->status = Port::Port_added;
 
    return ret;
  }
 
  int port_remove(unsigned idx)
  {
    Port *p = port(idx);
 
    if (p->status != Port::Port_open
        && p->status != Port::Port_ready
        && p->status != Port::Port_failed)
      return -L4_EPERM;
 
    int ret = send_control_message(idx, Control_message::Device_remove);
 
    if (ret == L4_EOK)
      p->reset();
 
    return ret;
  }
 
  int port_open(unsigned idx, bool open)
  {
    Port *p = port(idx);
 
    if ((open && p->status != Port::Port_ready)
        || (!open && p->status != Port::Port_open))
      return -L4_EPERM;
 
    int ret = send_control_message(idx, Control_message::Port_open, open);
 
    if (ret == L4_EOK)
      p->status = open ? Port::Port_open : Port::Port_ready;
 
    return ret;
  }
 
  int send_control_message(l4_uint32_t idx, l4_uint16_t event,
                           l4_uint16_t value = 0, const char *name = 0)
  {
    if (!ctrl_queue_ready())
      return  -L4_ENODEV;
 
    Virtqueue *q = &_ctrl_port.rx;
    if (!q->ready())
      return -L4_ENODEV;
 
    Virtqueue::Request r = q->next_avail();
    if (!r)
      return -L4_EBUSY;
 
    Request_processor rp;
    Control_request req;
    rp.start(this, r, &req);
 
    if (req.len < sizeof(Control_message))
      return -L4_ENOMEM;
 
    Control_message msg(idx, event, value);
 
    memcpy(req.msg, &msg, sizeof(msg));
 
    if (event == Control_message::Port_name && name)
      {
        size_t name_len = cxx::min(req.len - sizeof(msg), strlen(name));
        memcpy(reinterpret_cast<char*>(req.msg) + sizeof(msg), name, name_len);
        q->finish(r, this, sizeof(msg) + name_len);
      }
    else
      q->finish(r, this, sizeof(msg));
 
    return L4_EOK;
  }
 
  int handle_control_message()
  {
    Virtqueue *q = &_ctrl_port.tx;
    if (!q->ready())
      return -L4_ENODEV;
 
    Virtqueue::Request r;
    while ((r = q->next_avail()))
      {
        Request_processor rp;
        Control_request req;
 
        rp.start(this, r, &req);
 
        Control_message msg;
        if (req.len < sizeof(msg))
          {
            // Just ignore malformed input.
            q->consumed(r);
            return L4_EOK;
          }
 
        memcpy(&msg, req.msg, sizeof(msg));
        q->consumed(r);
 
        if (_ctrl_port.status == Port::Port_disabled)
          {
            // When the control queue is disabled, only device ready is accepted.
            if (msg.event == Control_message::Device_ready)
              {
                if (msg.value)
                  _ctrl_port.status = Port::Port_open;
              }
 
            process_device_ready(msg.value);
            continue;
          }
 
        if (!ctrl_queue_ready())
          continue;
 
        switch (msg.event)
          {
          case Control_message::Port_ready:
            // Ignore invalid port ids
            if (msg.id >= max_ports())
              break;
 
            // Ignore repeated PORT_READY messages.
            if ((port(msg.id)->status == Port::Port_disabled)
                || (!msg.value && port(msg.id)->status == Port::Port_added))
              break;
 
            process_port_ready(msg.id, msg.value);
            break;
 
          case Control_message::Port_open:
            // Ignore invalid port ids
            if (msg.id >= max_ports())
              break;
 
            // Ignore misplaced PORT_OPEN messages.
            if ((msg.value && port(msg.id)->status != Port::Port_ready)
                || (!msg.value && port(msg.id)->status != Port::Port_open))
              break;
 
            process_port_open(msg.id, msg.value);
            break;
          default:
            return -L4_EINVAL;
          }
      }
 
    return L4_EOK;
  }
 
  void load_desc(L4virtio::Virtqueue::Desc const &desc,
                 Request_processor const *proc,
                 L4virtio::Virtqueue::Desc const **table)
  {
    this->_mem_info.load_desc(desc, proc, table);
  }
 
  void load_desc(L4virtio::Virtqueue::Desc const &desc,
                 Request_processor const *proc,
                 Control_request *data)
  {
    auto *region = this->_mem_info.find(desc.addr.get(), desc.len);
    if (L4_UNLIKELY(!region))
      throw Bad_descriptor(proc, Bad_descriptor::Bad_address);
 
    data->msg = reinterpret_cast<Control_message *>(region->local(desc.addr));
    data->len = desc.len;
    data->mem = region;
  }
 
  void reset() override
  {
    for (unsigned p = 0; p < _num_ports; ++p)
      port(p)->reset();
 
    _ctrl_port.reset();
    reset_queue_configs();
    _dev_config.reset_hdr();
    _negotiated_features = Features(0);
 
    reset_device();
  }
 
  virtual void reset_device() {}
 
  virtual void notify_queue(Virtqueue *queue) = 0;
 
  virtual Port *port(unsigned port) = 0;
  virtual Port const *port(unsigned port) const = 0;
 
  virtual void process_device_ready(l4_uint16_t value) = 0;
 
  virtual void process_port_ready(l4_uint32_t id, l4_uint16_t value)
  {
    Port *p = port(id);
 
    switch (p->status)
      {
      case Port::Port_added:
      case Port::Port_ready:
        p->status = value ? Port::Port_ready : Port::Port_failed;
        break;
      case Port::Port_open:
        if (!value)
          p->status = Port::Port_failed;
        break;
      default:
        // invalid state for PORT_READY message
        break;
      }
  }
 
  virtual void process_port_open(l4_uint32_t id, l4_uint16_t value) = 0;
 
  unsigned max_ports() const
  { return _num_ports; }
 
private:
  bool is_control_queue(unsigned q) const
  { return q == Ctrl_rx || q == Ctrl_tx; }
 
  unsigned queue_to_port(unsigned q) const
  { return (q == 0 || q == 1) ? 0 : (q / 2) - 1; }
 
  unsigned max_queue_size(unsigned q) const
  {
    if (is_control_queue(q))
      return _ctrl_port.vq_max;
 
    return port(queue_to_port(q))->vq_max;
  }
 
  Virtqueue *get_queue(unsigned q)
  {
    Port *p;
    if (is_control_queue(q))
      p = &_ctrl_port;
    else
      p = port(queue_to_port(q));
 
    if (q & 1)
      return &p->tx;
    else
      return &p->rx;
  }
 
  unsigned _num_ports;
 
protected:
  Dev_config_t<Serial_config_space> _dev_config;
  Port _ctrl_port;
  Features _negotiated_features{0};
};
 
}}} // name space