virtio

// vi:ft=cpp
/* SPDX-License-Identifier: MIT */
/*
 * Copyright (C) 2014-2020 Kernkonzept GmbH.
 * Author(s): Alexander Warg <alexander.warg@kernkonzept.com>
 *
 */
#pragma once
 
#include <l4/sys/types.h>
#include <l4/cxx/bitfield>
#include <l4/cxx/minmax>
#include <l4/cxx/utils>
 
#include <limits.h>
#include <string.h>
#include <stdio.h>
 
#include "../virtqueue"
 
namespace L4virtio {
namespace Svr {
 
struct Dev_status
{
  unsigned char raw; 
  Dev_status() = default;
 
  explicit Dev_status(l4_uint32_t v) : raw(v) {}
 
  CXX_BITFIELD_MEMBER(0,  0, acked, raw);
  CXX_BITFIELD_MEMBER(1,  1, driver, raw);
  CXX_BITFIELD_MEMBER(2,  2, driver_ok, raw);
  CXX_BITFIELD_MEMBER(3,  3, features_ok, raw);
  CXX_BITFIELD_MEMBER(6,  7, fail_state, raw);
  CXX_BITFIELD_MEMBER(6,  6, device_needs_reset, raw);
  CXX_BITFIELD_MEMBER(7,  7, failed, raw);
 
  bool running() const
  {
    return (raw == 0xf);
  }
};
 
struct Dev_features
{
  l4_uint32_t raw;  
  Dev_features() = default;
 
  explicit Dev_features(l4_uint32_t v) : raw(v) {}
 
  CXX_BITFIELD_MEMBER(28, 28, ring_indirect_desc, raw);
  CXX_BITFIELD_MEMBER(29, 29, ring_event_idx, raw);
};
 
 
class Virtqueue : public L4virtio::Virtqueue
{
public:
  class Head_desc
  {
    friend class Virtqueue;
  private:
    Virtqueue::Desc const *_d;
    Head_desc(Virtqueue *r, unsigned i) : _d(r->desc(i)) {}
 
    struct Null_ptr_check;
 
  public:
    Head_desc() : _d(0) {}
 
    bool valid() const { return _d; }
 
    operator Null_ptr_check const * () const
    { return reinterpret_cast<Null_ptr_check const *>(_d); }
 
    Desc const *desc() const
    { return _d; }
  };
 
  struct Request : Head_desc
  {
    Virtqueue *ring = nullptr;
    Request() = default;
  private:
    friend class Virtqueue;
    Request(Virtqueue *r, unsigned i) : Head_desc(r, i), ring(r) {}
  };
 
 
  Request next_avail()
  {
    if (L4_LIKELY(_current_avail != _avail->idx))
      {
        rmb();
        unsigned head = _current_avail & _idx_mask;
        ++_current_avail;
        return Request(this, _avail->ring[head]);
      }
    return Request();
  }
 
  bool desc_avail() const
  {
    return _current_avail != _avail->idx;
  }
 
  void consumed(Head_desc const &r, l4_uint32_t len = 0)
  {
    l4_uint16_t i = _used->idx & _idx_mask;
    _used->ring[i] = Used_elem(r._d - _desc, len);
    wmb();
    ++_used->idx;
  }
 
  template<typename ITER>
  void consumed(ITER const &begin, ITER const &end)
  {
    l4_uint16_t added = 0;
    l4_uint16_t idx = _used->idx;
 
    for (auto elem = begin ; elem != end; ++elem, ++added)
      _used->ring[(idx + added) & _idx_mask]
        = Used_elem(elem->first._d - _desc, elem->second);
 
    wmb();
    _used->idx += added;
  }
 
  template<typename QUEUE_OBSERVER>
  void finish(Head_desc &d, QUEUE_OBSERVER *o, l4_uint32_t len = 0)
  {
    consumed(d, len);
    o->notify_queue(this);
    d._d = 0;
  }
 
  template<typename ITER, typename QUEUE_OBSERVER>
  void finish(ITER const &begin, ITER const &end, QUEUE_OBSERVER *o)
  {
    consumed(begin, end);
    o->notify_queue(this);
  }
 
  void disable_notify()
  {
    if (L4_LIKELY(ready()))
      _used->flags.no_notify() = 1;
  }
 
  void enable_notify()
  {
    if (L4_LIKELY(ready()))
      _used->flags.no_notify() = 0;
  }
 
  Desc const *desc(unsigned idx) const
  { return _desc + idx; }
 
};
 
struct Data_buffer
{
  char *pos;         
  l4_uint32_t left;  
 
  Data_buffer() = default;
 
  template<typename T>
  explicit Data_buffer(T *p)
  : pos(reinterpret_cast<char *>(p)), left(sizeof(T))
  {}
 
  template<typename T>
  void set(T *p)
  {
    pos = reinterpret_cast<char *>(p);
    left = sizeof(T);
  }
 
  l4_uint32_t copy_to(Data_buffer *dst, l4_uint32_t max = UINT_MAX)
  {
    unsigned long bytes = cxx::min(cxx::min(left, dst->left), max);
    memcpy(dst->pos, pos, bytes);
    left -= bytes;
    pos += bytes;
    dst->left -= bytes;
    dst->pos += bytes;
    return bytes;
  }
 
  l4_uint32_t skip(l4_uint32_t bytes)
  {
    unsigned long b = cxx::min(left, bytes);
    left -= b;
    pos += b;
    return b;
  }
 
  bool done() const
  { return left == 0; }
};
 
class Request_processor;
 
struct Bad_descriptor
{
  enum Error
  {
    Bad_address, 
    Bad_rights,  
    Bad_flags,   
    Bad_next,    
    Bad_size     
  };
 
  Request_processor const *proc;
 
  // The error code
  Error error;
 
  Bad_descriptor(Request_processor const *proc, Error e)
  : proc(proc), error(e)
  {}
 
  char const *message() const
  {
    static char const *const err[] =
    {
      [Bad_address] = "Descriptor address cannot be translated",
      [Bad_rights]  = "Insufficient memory access rights",
      [Bad_flags]   = "Invalid descriptor flags",
      [Bad_next]    = "The descriptor's `next` index is invalid",
      [Bad_size]    = "Invalid size of the memory block"
    };
 
    if (error >= (sizeof(err) / sizeof(err[0])) || !err[error])
      return "Unknown error";
 
    return err[error];
  }
};
 
 
class Request_processor
{
private:
  Virtqueue::Desc const *_table;
 
  Virtqueue::Desc _current;
 
  l4_uint16_t _num;
 
public:
  template<typename DESC_MAN, typename ...ARGS>
  void start(DESC_MAN *dm, Virtqueue *ring, Virtqueue::Head_desc const &request, ARGS... args)
  {
    _current = cxx::access_once(request.desc());
 
    if (_current.flags.indirect())
      {
        dm->load_desc(_current, this, &_table);
        _num = _current.len / sizeof(Virtqueue::Desc);
        if (L4_UNLIKELY(!_num))
          throw Bad_descriptor(this, Bad_descriptor::Bad_size);
 
        _current = cxx::access_once(_table);
      }
    else
      {
        _table = ring->desc(0);
        _num = ring->num();
      }
 
    dm->load_desc(_current, this, cxx::forward<ARGS>(args)...);
  }
 
  template<typename DESC_MAN, typename ...ARGS>
  Virtqueue::Request const &start(DESC_MAN *dm, Virtqueue::Request const &request, ARGS... args)
  {
    start(dm, request.ring, request, cxx::forward<ARGS>(args)...);
    return request;
  }
 
  Virtqueue::Desc::Flags current_flags() const
  { return _current.flags; }
 
  bool has_more() const
  { return _current.flags.next(); }
 
  template<typename DESC_MAN, typename ...ARGS>
  bool next(DESC_MAN *dm, ARGS... args)
  {
    if (!_current.flags.next())
      return false;
 
    if (L4_UNLIKELY(_current.next >= _num))
      throw Bad_descriptor(this, Bad_descriptor::Bad_next);
 
    _current = cxx::access_once(_table + _current.next);
 
    if (0) // we ignore this for performance reasons
      if (L4_UNLIKELY(_current.flags.indirect()))
        throw Bad_descriptor(this, Bad_descriptor::Bad_flags);
 
    // must throw an exception in case of a bad descriptor
    dm->load_desc(_current, this, cxx::forward<ARGS>(args)...);
    return true;
  }
};
 
}
}