ipc_epiface

// vi:set ft=cpp: -*- Mode: C++ -*-
/*
 * (c) 2014-2015 Alexander Warg <alexander.warg@kernkonzept.com>
 *
 * License: see LICENSE.spdx (in this directory or the directories above)
 */
#pragma once
#pragma GCC system_header
 
#include "capability.h"
#include "ipc_server"
#include "ipc_string"
#include <l4/sys/types.h>
#include <l4/sys/utcb.h>
#include <l4/sys/__typeinfo.h>
#include <l4/sys/meta>
#include <l4/cxx/result>
#include <l4/cxx/type_traits>
 
namespace L4 {
 
// forward for Irqep_t
class Irq;
class Rcv_endpoint;
 
namespace Ipc_svr {
 
class Timeout;

class Server_iface
{
private:
  Server_iface(Server_iface const &);
  Server_iface const &operator = (Server_iface const &);
 
public:
  class Mem_window final
  {
  public:
    class Allocator
    {
    public:
      virtual ~Allocator() = default;
 
      virtual void dispose(l4_fpage_t fp) noexcept = 0;
    };
 
    Mem_window() noexcept = default;
    Mem_window(l4_fpage_t fp, Allocator *allocator) noexcept
    : _fp(fp), _allocator(allocator)
    {}
 
    ~Mem_window()
    { reset(); }
 
    Mem_window(Mem_window const &) = delete;
    Mem_window &operator=(Mem_window const &) = delete;
 
    Mem_window(Mem_window &&other) noexcept
    : _fp(other._fp), _allocator(other._allocator)
    {
      other._fp = l4_fpage_invalid();
      other._allocator = nullptr;
    }
 
    Mem_window &operator=(Mem_window &&other) noexcept
    {
      if (this == &other)
        return *this;
 
      reset();
      _fp = other._fp;
      _allocator = other._allocator;
 
      other._fp = l4_fpage_invalid();
      other._allocator = nullptr;
 
      return *this;
    }
 
    void reset() noexcept
    {
      if (l4_is_fpage_valid(_fp))
        {
          _allocator->dispose(_fp);
          _fp = l4_fpage_invalid();
          _allocator = nullptr;
        }
    }
 
    l4_fpage_t release() noexcept
    {
      l4_fpage_t ret = _fp;
      _fp = l4_fpage_invalid();
      _allocator = nullptr;
      return ret;
    }
 
    explicit operator bool() const noexcept
    { return l4_is_fpage_valid(_fp); }
 
    l4_fpage_t fp() const noexcept
    { return _fp; }
 
    void *get() const noexcept
    { return reinterpret_cast<void *>(l4_fpage_memaddr(_fp)); }
 
    unsigned order() const noexcept
    { return l4_fpage_order(_fp); }
 
    l4_umword_t size() const noexcept
    { return l4_umword_t{1} << order(); }
 
  private:
    l4_fpage_t _fp = l4_fpage_invalid();
    Allocator *_allocator = nullptr;
  };

  using Demand = L4::Type_info::Demand;
 
  Server_iface(Server_iface &&) = delete;
  Server_iface &operator = (Server_iface &&) = delete;

  Server_iface() {}
 
  // Destroy the server interface
  virtual ~Server_iface() = 0;

  virtual int alloc_buffer_demand(Demand const &demand) = 0;

  virtual L4::Cap<void> get_rcv_cap(int index) const = 0;

  virtual int realloc_rcv_cap(int index) = 0;

  virtual cxx::Result<L4::Reply_cap> take_reply_cap() noexcept
  { return cxx::Error(-L4_ENOSYS); }

  virtual cxx::Result<Mem_window> get_rcv_mem() noexcept
  { return cxx::Error(-L4_ENOSYS); }

  virtual int add_timeout(Timeout *timeout, l4_kernel_clock_t time) = 0;

  virtual int remove_timeout(Timeout *timeout) = 0;

  template<typename T>
  L4::Cap<T> rcv_cap(int index) const
  { return L4::cap_cast<T>(get_rcv_cap(index)); }

  L4::Cap<void> rcv_cap(int index) const
  { return get_rcv_cap(index); }
};
 
inline Server_iface::~Server_iface() {}
 
} // namespace Ipc_svr

struct Epiface
{
  Epiface(Epiface const &) = delete;
  Epiface &operator = (Epiface const &) = delete;

  using Server_iface = Ipc_svr::Server_iface;
  using Demand = Ipc_svr::Server_iface::Demand;
 
  class Stored_cap : public Cap<void>
  {
  private:
    enum { Managed = 0x10 };
 
  public:
    Stored_cap() = default;
    Stored_cap(Cap<void> const &c, bool managed = false)
    : Cap<void>((c.cap() & L4_CAP_MASK) | (managed ? Managed : 0))
    {
      static_assert (!(L4_CAP_MASK & Managed), "conflicting bits used...");
    }
 
    bool managed() const { return cap() & Managed; }
  };

  Epiface() : _data(0) {}

  virtual l4_msgtag_t dispatch(l4_msgtag_t tag, unsigned rights,
                               l4_utcb_t *utcb) = 0;

  virtual Demand get_buffer_demand() const = 0; //{ return Demand(0); }

  virtual ~Epiface() = 0;

  Stored_cap obj_cap() const { return _cap; }

  Server_iface *server_iface() const { return _data; }

  int set_server(Server_iface *srv, Cap<void> cap, bool managed = false)
  {
    if ((srv && cap) || (!srv && !cap))
      {
        _data = srv;
        _cap  = Stored_cap(cap, managed);
        return 0;
      }
 
    return -L4_EINVAL;
  }

  void set_obj_cap(Cap<void> const &cap) { _cap = cap; }
 
private:
  Server_iface *_data;
  Stored_cap _cap;
};
 
inline Epiface::~Epiface() {}

template<typename RPC_IFACE, typename BASE = Epiface>
struct Epiface_t0 : BASE
{
  using Interface = RPC_IFACE;

  typename Type_info::Demand get_buffer_demand() const
  { return typename Kobject_typeid<RPC_IFACE>::Demand(); }

  Cap<RPC_IFACE> obj_cap() const
  { return L4::cap_cast<RPC_IFACE>(BASE::obj_cap()); }
};

template<typename Derived, typename BASE = Epiface,
         bool = cxx::is_polymorphic<BASE>::value>
struct Irqep_t : Epiface_t0<void, BASE>
{
  l4_msgtag_t dispatch(l4_msgtag_t, unsigned, l4_utcb_t *) final
  {
    static_cast<Derived*>(this)->handle_irq();
    return l4_msgtag(-L4_ENOREPLY, 0, 0, 0);
  }

  Cap<L4::Irq> obj_cap() const
  { return L4::cap_cast<L4::Irq>(BASE::obj_cap()); }
};
 
template<typename Derived, typename BASE>
struct Irqep_t<Derived, BASE, false> : Epiface_t0<void, BASE>
{
  l4_msgtag_t dispatch(l4_msgtag_t, unsigned, l4_utcb_t *)
  {
    static_cast<Derived*>(this)->handle_irq();
    return l4_msgtag(-L4_ENOREPLY, 0, 0, 0);
  }

  Cap<L4::Irq> obj_cap() const
  { return L4::cap_cast<L4::Irq>(BASE::obj_cap()); }
};

class Registry_iface
{
public:
  virtual ~Registry_iface() = 0;

  virtual L4::Cap<void>
  register_obj(L4::Epiface *o, char const *service) = 0;

  virtual L4::Cap<void>
  register_obj(L4::Epiface *o) = 0;

  virtual L4::Cap<L4::Irq> register_irq_obj(L4::Epiface *o) = 0;

  virtual L4::Cap<L4::Rcv_endpoint>
  register_obj(L4::Epiface *o, L4::Cap<L4::Rcv_endpoint> ep) = 0;

  virtual void
  unregister_obj(L4::Epiface *o, bool unmap = true) = 0;
};
 
inline Registry_iface::~Registry_iface() {}
 
namespace Ipc {
namespace Detail {
 
using namespace L4::Typeid;
 
template<typename IFACE>
struct Meta_svr
{
  l4_ret_t op_num_interfaces(L4::Meta::Rights)
  {
    l4_ret_t ret = 0;
    auto iter = [&ret](L4::Type_info const *)
      {
        ++ret;
        return false;
      };
    _iter_interfaces(iter);
    return ret;
  }
 
  l4_ret_t op_interface(L4::Meta::Rights, l4_umword_t idx, long &proto,
                        L4::Ipc::String<char> &name)
  {
    auto iter =
      [idx, &proto, &name, num = 0U](L4::Type_info const *t) mutable
      {
        if (idx == num)
          {
            proto = t->proto();
            if (auto *n = t->name())
              name.copy_in(n);
            else
              name.copy_in("");
 
            return true;
          }
 
        ++num;
        return false;
      };
 
    return _iter_interfaces(iter) ? 0 : -L4_ERANGE;
  }
 
  l4_ret_t op_supports(L4::Meta::Rights, l4_mword_t proto)
  { return L4::kobject_typeid<IFACE>()->has_proto(proto); }
 
private:
  template<typename F>
  static bool _iter_interfaces(F &f)
  { return _iter_interfaces<F>(L4::kobject_typeid<IFACE>(), f); }
 
  template<typename F>
  static bool _iter_interfaces(L4::Type_info const *t, F &f)
  {
    // Don't report L4::Kobject (no base) or L4::PROTO_EMPTY. The latter
    // interfaces are not dispatched and shall remain invisible.
    if (t->num_bases() && t->proto() != L4::PROTO_EMPTY)
      if (f(t))
        return true;
 
    for (unsigned i = 0; i < t->num_bases(); ++i)
      if (_iter_interfaces(t->base(i), f))
        return true;
 
    return false;
  }
};
 
template<typename IFACE, typename LIST>
struct _Dispatch;
 
// No match dispatcher found
template<typename IFACE>
struct _Dispatch<IFACE, Iface_list_end>
{
  template< typename THIS, typename A1, typename A2 >
  static l4_msgtag_t f(THIS *, l4_msgtag_t, A1, A2 &)
  { return l4_msgtag(-L4_EBADPROTO, 0, 0, 0); }
};
 
// call matching p_dispatch() function
template<typename IFACE, typename I, typename LIST >
struct _Dispatch<IFACE, Iface_list<I, LIST> >
{
  // special handling for the meta protocol, to avoid 'using' murx
  template< typename THIS >
  static l4_msgtag_t _f(THIS *, l4_msgtag_t tag, unsigned r,
                        l4_utcb_t *utcb, True::type)
  {
    using L4::Ipc::Msg::dispatch_call;
    using Meta = L4::Meta::Rpcs;
    using Msvr = Meta_svr<IFACE>;
    return dispatch_call<Meta>(static_cast<Msvr *>(nullptr), utcb, tag, r);
  }
 
  // normal dispatch to the op_<func> methods of \a self.
  template< typename THIS >
  static l4_msgtag_t _f(THIS *self, l4_msgtag_t t, unsigned r,
                        l4_utcb_t *utcb, False::type)
  {
    using L4::Ipc::Msg::dispatch_call;
    return dispatch_call<typename I::iface_type::Rpcs>(self, utcb, t, r);
  }
 
  // dispatch function with switch for meta protocol
  template< typename THIS >
  static l4_msgtag_t f(THIS *self, l4_msgtag_t tag, unsigned r,
                       l4_utcb_t *utcb)
  {
    if (I::Proto == tag.label())
      return _f(self, tag, r, utcb,
                Bool<I::Proto == static_cast<long>(L4_PROTO_META)>());
 
    return _Dispatch<IFACE, typename LIST::type>::f(self, tag, r, utcb);
  }
};
 
template<typename IFACE>
struct Dispatch :
  _Dispatch<IFACE, typename L4::Kobject_typeid<IFACE>::Iface_list::type>
{};
 
} // namespace Detail
 
template<typename EPIFACE>
struct Dispatch : Detail::Dispatch<typename EPIFACE::Interface>
{};
 
} // namespace Ipc

template<typename Derived, typename IFACE, typename BASE = L4::Epiface,
         bool = cxx::is_polymorphic<BASE>::value>
struct Epiface_t : Epiface_t0<IFACE, BASE>
{
  l4_msgtag_t
  dispatch(l4_msgtag_t tag, unsigned rights, l4_utcb_t *utcb) final
  {
    using Dispatch = Ipc::Dispatch<Derived>;
    return Dispatch::f(static_cast<Derived*>(this), tag, rights, utcb);
  }
};
 
template<typename Derived, typename IFACE, typename BASE>
struct Epiface_t<Derived, IFACE, BASE, false> : Epiface_t0<IFACE, BASE>
{
  l4_msgtag_t
  dispatch(l4_msgtag_t tag, unsigned rights, l4_utcb_t *utcb)
  {
    using Dispatch = Ipc::Dispatch<Derived>;
    return Dispatch::f(static_cast<Derived*>(this), tag, rights, utcb);
  }
};

class Basic_registry
{
public:
  using Value = Epiface;
  static Value *find(l4_umword_t label)
  { return reinterpret_cast<Value*>(label & ~3UL); }

  static l4_msgtag_t dispatch(l4_msgtag_t tag, l4_umword_t label,
                              l4_utcb_t *utcb)
  {
    return find(label)->dispatch(tag, label, utcb);
  }
};
 
 
} // namespace L4