virtio-console-device

// 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/cxx/bitmap>
#include <l4/cxx/static_vector>
#include <l4/l4virtio/server/l4virtio>
#include <l4/l4virtio/server/virtio-console>
#include <l4/re/error_helper>
 
namespace L4virtio { namespace Svr { namespace Console {
 
struct Device_port : public Port
{
  struct Buffer : Data_buffer
  {
    Buffer() = default;
    Buffer(Driver_mem_region const *r,
           Virtqueue::Desc const &d,
           Request_processor const *)
    {
      pos = static_cast<char *>(r->local(d.addr));
      left = d.len;
    }
  };
 
  Request_processor rp; 
  Virtqueue::Request request; 
  Buffer src; 
 
  bool poll_in_req = true;
  bool poll_out_req = true;
 
  void reset() override
  {
    Port::reset();
    request = Virtqueue::Request();
    poll_in_req = true;
    poll_out_req = true;
  }
  void reset() override {…}
};
struct Device_port : public Port {…};
 
class Device
: public Virtio_con
{
  class Irq_object : public L4::Irqep_t<Irq_object>
  {
  public:
    Irq_object(Device *parent) : _parent(parent) {}
 
    void handle_irq() { _parent->kick(); }
 
  private:
    Device *_parent;
  };
 
protected:
  L4::Epiface *irq_iface()
  { return &_irq_handler; }
 
public:
  explicit Device(unsigned vq_max)
  : Virtio_con(1, false),
    _irq_handler(this),
    _ports(cxx::make_unique<Device_port[]>(1))
  {
    _ports[0].vq_max = vq_max;
    reset_queue_configs();
  }
  explicit Device(unsigned vq_max) {…}
 
  explicit Device(unsigned vq_max, unsigned ports)
  : Virtio_con(ports, true),
    _irq_handler(this),
    _ports(cxx::make_unique<Device_port[]>(ports))
  {
    for (unsigned i = 0; i < ports; ++i)
      _ports[i].vq_max = vq_max;
    reset_queue_configs();
  }
  explicit Device(unsigned vq_max, unsigned ports) {…}
 
  explicit Device(cxx::static_vector<unsigned> const &vq_max_nums)
  : Virtio_con(vq_max_nums.size(), true),
    _irq_handler(this),
    _ports(cxx::make_unique<Device_port[]>(max_ports()))
  {
    for (unsigned i = 0; i < vq_max_nums.size(); ++i)
      _ports[i].vq_max = vq_max_nums[i];
    reset_queue_configs();
  }
  explicit Device(cxx::static_vector<unsigned> const &vq_max_nums) {…}
 
  void register_single_driver_irq() override
  {
    _kick_driver_irq = L4Re::Util::Unique_cap<L4::Irq>(
      L4Re::chkcap(server_iface()->rcv_cap<L4::Irq>(0)));
    L4Re::chksys(server_iface()->realloc_rcv_cap(0));
  }
  void register_single_driver_irq() override {…}
 
  L4::Cap<L4::Irq> device_notify_irq() const override
  { return _irq_handler.obj_cap(); }
  L4::Cap<L4::Irq> device_notify_irq() const override {…}
 
  void notify_queue(Virtqueue *queue) override
  {
    if (queue->no_notify_guest())
      return;
 
    _dev_config.add_irq_status(L4VIRTIO_IRQ_STATUS_VRING);
    _kick_driver_irq->trigger();
  }
  void notify_queue(Virtqueue *queue) override {…}
 
  virtual void rx_data_available(unsigned port) = 0;
 
  virtual void tx_space_available(unsigned port) = 0;
 
  virtual bool queues_stopped()
  { return false; }
  virtual bool queues_stopped() {…}
 
  void trigger_driver_config_irq() override
  {
    _dev_config.add_irq_status(L4VIRTIO_IRQ_STATUS_CONFIG);
    _kick_driver_irq->trigger();
  }
  void trigger_driver_config_irq() override {…}
 
  void kick()
  {
    if (queues_stopped())
      return;
 
    // We're not interested in logging any errors, just ignore return value.
    handle_control_message();
 
    for (unsigned i = 0; i < max_ports(); ++i)
      {
        auto &p = _ports[i];
        if (p.poll_in_req && p.tx_ready() && p.tx.desc_avail())
          {
            p.poll_in_req = false;
            rx_data_available(i);
          }
 
        if (p.poll_out_req && p.rx_ready() && p.rx.desc_avail())
          {
            p.poll_out_req = false;
            tx_space_available(i);
          }
      }
  }
 
  unsigned port_read(char *buf, unsigned len, unsigned port = 0)
  {
    unsigned total = 0;
    Device_port &p = _ports[port];
    Virtqueue *q = &p.tx;
 
    Data_buffer dst;
    dst.pos = buf;
    dst.left = len;
 
    while (dst.left)
      {
        try
          {
            // Make sure we have a valid request where we can read data from
            if (!p.request.valid())
              {
                p.request = p.tx_ready() ? q->next_avail()
                                         : Virtqueue::Request();
                if (!p.request.valid())
                  break;
 
                p.rp.start(mem_info(), p.request, &p.src);
              }
 
            total += p.src.copy_to(&dst);
 
            // We might have eaten up the current descriptor. Move to the next
            // if this is the case. At the end of the descriptor chain we have
            // to retire the current request altogether.
            if (!p.src.left)
              {
                if (!p.rp.next(mem_info(), &p.src))
                  {
                    q->finish(p.request, this);
                    p.request = Virtqueue::Request();
                  }
              }
          }
        catch (Bad_descriptor const &)
          {
            q->finish(p.request, this);
            p.request = Virtqueue::Request();
            device_error();
            break;
          }
      }
 
    if (total < len)
      p.poll_in_req = true;
 
    return total;
  }
  unsigned port_read(char *buf, unsigned len, unsigned port = 0) {…}
 
  unsigned port_write(char const *buf, unsigned len, unsigned port = 0)
  {
    unsigned total = 0;
    Device_port &p = _ports[port];
    Virtqueue *q = &p.rx;
 
    Data_buffer src;
    src.pos = const_cast<char*>(buf);
    src.left = len;
 
    Request_processor rp;
    while (src.left)
      {
        auto r = p.rx_ready() ? q->next_avail() : Virtqueue::Request();
        if (!r.valid())
          break;
 
        l4_uint32_t chunk = 0;
        try
          {
            Device_port::Buffer dst;
            rp.start(mem_info(), r, &dst);
 
            for (;;)
              {
                chunk += src.copy_to(&dst);
                if (!src.left)
                  break;
                if (!rp.next(mem_info(), &dst))
                  break;
              }
          }
        catch (Bad_descriptor const &)
          {
            device_error();
          }
 
        q->finish(r, this, chunk);
        total += chunk;
      }
 
    if (total < len)
      p.poll_out_req = true;
 
    return total;
  }
  unsigned port_write(char const *buf, unsigned len, unsigned port = 0) {…}
 
  void process_device_ready(l4_uint16_t value) override
  {
    if (!value)
      return;
 
    for (unsigned i = 0; i < max_ports(); ++i)
      port_add(i);
  }
  void process_device_ready(l4_uint16_t value) override {…}
 
  void process_port_ready(l4_uint32_t id, l4_uint16_t value) override
  {
    Virtio_con::process_port_ready(id, value);
 
    Port *p = port(id);
    if (p->status == Port::Port_failed)
      port_remove(id);
    else if (p->status == Port::Port_ready)
      port_open(id, true);
  }
  void process_port_ready(l4_uint32_t id, l4_uint16_t value) override {…}
 
  virtual void process_port_open(l4_uint32_t id, l4_uint16_t value)
  {
    static_cast<void>(id);
    static_cast<void>(value);
  }
  virtual void process_port_open(l4_uint32_t id, l4_uint16_t value) {…}
 
protected:
  Port* port(unsigned idx) override
  {
    return &_ports[idx];
  }
  Port* port(unsigned idx) override {…}
 
  Port const *port(unsigned idx) const override
  {
    return &_ports[idx];
  }
 
private:
  Irq_object _irq_handler;
  cxx::unique_ptr<Device_port[]> _ports;
  L4Re::Util::Unique_cap<L4::Irq> _kick_driver_irq;
};
class Device {…};
 
}}} // name space