virtio-console

// vi:ft=cpp
/* SPDX-License-Identifier: MIT */
/*
 * Copyright (C) 2019-2024 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,
    Port_num_states,
  };

  enum { Control_queue_size = 0x10 };
 
  Virtqueue tx; 
  Virtqueue rx; 
  Port_status status; 
  Port_status reported_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()
  {
    tx.disable();
    rx.disable();
    status = Port_disabled;
    reported_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(); }

  struct Transition {
    l4_int16_t  event;  
    l4_uint16_t value;  
    Port_status next;   
  };

  static constexpr Transition
  state_transitions[Port_num_states][Port_num_states] =
  {
    /*   reported            current     */
 
    /* Port_disabled */ /* Port_disabled */ {{ -1, 0, Port_disabled },
                        /* Port_added    */  { Control_message::Device_add, 0,
                                               Port_added },
                        /* Port_ready    */  { Control_message::Device_add, 0,
                                               Port_ready },
                        /* Port_open     */  { Control_message::Device_add, 0,
                                               Port_ready },
                        /* Port_failed   */  { Control_message::Device_add, 0,
                                               Port_failed }},
 
    /* Port_added    */ /* Port_disabled */ {{ Control_message::Device_remove,
                                               0, Port_disabled },
                        /* Port_added    */  { -1, 0, Port_added },
                        /* Port_ready    */  { -1, 0, Port_ready },
                        /* Port_open     */  { Control_message::Port_open, 1,
                                               Port_open },
                        /* Port_failed   */  { -1, 0, Port_failed }},
 
    /* Port_ready    */ /* Port_disabled */ {{ Control_message::Device_remove,
                                               0, Port_disabled },
                        /* Port_added    */  { -1, 0, Port_added },
                        /* Port_ready    */  { -1, 0, Port_ready },
                        /* Port_open     */  { Control_message::Port_open, 1,
                                               Port_open },
                        /* Port_failed   */  { -1, 0, Port_failed }},
 
    /* Port_open     */ /* Port_disabled */ {{ Control_message::Port_open, 0,
                                               Port_ready },
                        /* Port_added    */  { Control_message::Port_open, 0,
                                               Port_added },
                        /* Port_ready    */  { Control_message::Port_open, 0,
                                               Port_ready },
                        /* Port_open     */  { -1, 0, Port_open },
                        /* Port_failed   */  { Control_message::Port_open, 0,
                                               Port_ready }},
 
    /* Port_failed   */ /* Port_disabled */ {{ Control_message::Device_remove,
                                               0, Port_disabled },
                        /* Port_added    */  { -1, 0, Port_added },
                        /* Port_ready    */  { -1, 0, Port_ready },
                        /* Port_open     */  { Control_message::Port_open, 1,
                                               Port_open },
                        /* Port_failed   */  { -1, 0, Port_failed }},
  };
};

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;
 
    p->status = Port::Port_added;
    port_report_status(idx);
 
    return L4_EOK;
  }

  int port_remove(unsigned idx)
  {
    Port *p = port(idx);
 
    if (p->status == Port::Port_disabled)
      return -L4_EPERM;
 
    p->status = Port::Port_disabled;
    port_report_status(idx);
 
    return L4_EOK;
  }

  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;
 
    p->status = open ? Port::Port_open : Port::Port_ready;
    port_report_status(idx);
 
    return L4_EOK;
  }

  int port_name(unsigned idx, char const *name)
  {
    Port *p = port(idx);
 
    if (p->status == Port::Port_disabled)
      return -L4_EPERM;
 
    return send_control_message(idx, Control_message::Port_name, 0, name);
  }

  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()
  {
    // Report port state transitions if that failed in the past...
    if (_report_port_state)
      {
        _report_port_state = false;
 
        for (unsigned i = 0; i < _num_ports; ++i)
          if (!port_report_status(i))
            _report_port_state = true;
      }
 
    Virtqueue *q = &_ctrl_port.tx;
    if (!q->ready())
      return -L4_ENODEV;
 
    int ret = L4_EOK;
    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->finish(r, this);
            ret = -L4_EINVAL;
            continue;
          }
 
        memcpy(&msg, req.msg, sizeof(msg));
        q->finish(r, this);
 
        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);
              }
            else
              ret = -L4_EIO;
 
            continue;
          }
 
        if (!ctrl_queue_ready())
          continue;
 
        // Ignore invalid port ids
        if (msg.id >= max_ports())
          continue;
 
        switch (msg.event)
          {
          case Control_message::Port_ready:
            process_port_ready(msg.id, msg.value);
            break;
          case Control_message::Port_open:
            process_port_open(msg.id, msg.value);
            break;
          default:
            ret = -L4_EINVAL;
            break;
          }
      }
 
    return ret;
  }

  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);
    _report_port_state = false;
 
    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;
  }

  bool port_report_status(unsigned idx)
  {
    Port *p = port(idx);
    while (p->status != p->reported_status)
      {
        auto const &trans
          = Port::state_transitions[p->reported_status][p->status];
 
        if (trans.event >= 0
            && send_control_message(idx, trans.event, trans.value) < 0)
          {
            _report_port_state = true;
            return false;
          }
 
        p->reported_status = trans.next;
      }
 
    return true;
  }
 
  unsigned _num_ports;
  bool _report_port_state = false;
 
protected:
  Dev_config_t<Serial_config_space> _dev_config;
  Port _ctrl_port;
  Features _negotiated_features{0};
};
 
}}} // name space