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/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:
  typedef L4::Type_info::Demand 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 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<T> rcv_cap(int index) const {…}
 
  L4::Cap<void> rcv_cap(int index) const
  { return get_rcv_cap(index); }
  L4::Cap<void> rcv_cap(int index) const {…}
};
class Server_iface {…};
 
inline Server_iface::~Server_iface() {}
 
} // namespace Ipc_svr
namespace Ipc_svr {…}
 
struct Epiface
{
  Epiface(Epiface const &) = delete;
  Epiface &operator = (Epiface const &) = delete;
 
  typedef Ipc_svr::Server_iface Server_iface;
  typedef Ipc_svr::Server_iface::Demand 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;
  }
  int set_server(Server_iface *srv, Cap<void> cap, bool managed = false) {…}
 
  void set_obj_cap(Cap<void> const &cap) { _cap = cap; }
 
private:
  Server_iface *_data;
  Stored_cap _cap;
};
struct Epiface {…};
 
inline Epiface::~Epiface() {}
 
template<typename RPC_IFACE, typename BASE = Epiface>
struct Epiface_t0 : BASE
{
  typedef RPC_IFACE Interface;
 
  typename Type_info::Demand get_buffer_demand() const
  { return typename Kobject_typeid<RPC_IFACE>::Demand(); }
  typename Type_info::Demand get_buffer_demand() const {…}
 
  Cap<RPC_IFACE> obj_cap() const
  { return L4::cap_cast<RPC_IFACE>(BASE::obj_cap()); }
  Cap<RPC_IFACE> obj_cap() const {…}
};
struct Epiface_t0 : BASE {…};
 
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);
  }
  l4_msgtag_t dispatch(l4_msgtag_t, unsigned, l4_utcb_t *) final {…}
 
  Cap<L4::Irq> obj_cap() const
  { return L4::cap_cast<L4::Irq>(BASE::obj_cap()); }
  Cap<L4::Irq> obj_cap() const {…}
};
struct Irqep_t : Epiface_t0<void, BASE> {…};
 
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;
};
class Registry_iface {…};
 
inline Registry_iface::~Registry_iface() {}
 
namespace Ipc {
namespace Detail {
 
using namespace L4::Typeid;
 
template<typename IFACE>
struct Meta_svr
{
  long op_num_interfaces(L4::Meta::Rights)
  { return 1; }
 
  long op_interface(L4::Meta::Rights, l4_umword_t ifx, long &proto, L4::Ipc::String<char> &name)
  {
    if (ifx > 0)
      return -L4_ERANGE;
    proto = L4::kobject_typeid<IFACE>()->proto();
    if (auto *n = L4::kobject_typeid<IFACE>()->name())
      name.copy_in(n);
 
    return 0;
  }
 
  long op_supports(L4::Meta::Rights, l4_mword_t proto)
  { return L4::kobject_typeid<IFACE>()->has_proto(proto); }
};
 
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;
    typedef L4::Meta::Rpcs Meta;
    typedef Meta_svr<IFACE> Msvr;
    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
  {
    typedef Ipc::Dispatch<Derived> Dispatch;
    return Dispatch::f(static_cast<Derived*>(this), tag, rights, utcb);
  }
  dispatch(l4_msgtag_t tag, unsigned rights, l4_utcb_t *utcb) final {…}
};
struct Epiface_t : Epiface_t0<IFACE, BASE> {…};
 
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)
  {
    typedef Ipc::Dispatch<Derived> Dispatch;
    return Dispatch::f(static_cast<Derived*>(this), tag, rights, utcb);
  }
};
 
class Basic_registry
{
public:
  typedef Epiface Value;
  static Value *find(l4_umword_t label)
  { return reinterpret_cast<Value*>(label & ~3UL); }
  static Value *find(l4_umword_t label) {…}
 
  static l4_msgtag_t dispatch(l4_msgtag_t tag, l4_umword_t label,
                              l4_utcb_t *utcb)
  {
    return find(label)->dispatch(tag, label, utcb);
  }
  static l4_msgtag_t dispatch(l4_msgtag_t tag, l4_umword_t label, {…}
};
class Basic_registry {…};
 
 
} // namespace L4