object_registry

// vi:set ft=cpp: -*- Mode: C++ -*-
/*
 * (c) 2008-2009 Adam Lackorzynski <adam@os.inf.tu-dresden.de>,
 *               Alexander Warg <warg@os.inf.tu-dresden.de>
 *     economic rights: Technische Universität Dresden (Germany)
 *
 * This file is part of TUD:OS and distributed under the terms of the
 * GNU General Public License 2.
 * Please see the COPYING-GPL-2 file for details.
 *
 * As a special exception, you may use this file as part of a free software
 * library without restriction.  Specifically, if other files instantiate
 * templates or use macros or inline functions from this file, or you compile
 * this file and link it with other files to produce an executable, this
 * file does not by itself cause the resulting executable to be covered by
 * the GNU General Public License.  This exception does not however
 * invalidate any other reasons why the executable file might be covered by
 * the GNU General Public License.
 */
 
#pragma once
 
#include <l4/re/util/cap_alloc>
#include <l4/re/util/unique_cap>
#include <l4/re/consts>
#include <l4/re/env>
 
#include <l4/sys/cxx/ipc_server_loop>
#include <l4/sys/factory>
#include <l4/sys/task>
#include <l4/sys/thread>
#include <l4/sys/ipc_gate>
 
#include <l4/cxx/exceptions>
 
namespace L4Re { namespace Util {
 
class Object_registry :
  public L4::Basic_registry,
  public L4::Registry_iface
{
  struct Null_handler : L4::Epiface_t<Null_handler, L4::Kobject>
  {};
 
protected:
  L4::Cap<L4::Thread> _server;
  L4::Cap<L4::Factory> _factory;
  L4::Ipc_svr::Server_iface *_sif;
 
private:
  Null_handler _null_handler;
 
public:
  explicit
  Object_registry(L4::Ipc_svr::Server_iface *sif)
  : _server(L4Re::Env::env()->main_thread()),
    _factory(L4Re::Env::env()->factory()),
    _sif(sif)
  {}
 
  Object_registry(L4::Ipc_svr::Server_iface *sif,
                  L4::Cap<L4::Thread> server,
                  L4::Cap<L4::Factory> factory)
  : _server(server), _factory(factory), _sif(sif)
  {}
 
private:
  typedef L4::Ipc_svr::Server_iface Server_iface;
  typedef Server_iface::Demand Demand;
 
  L4::Cap<L4::Rcv_endpoint>
  _register_ep(L4::Epiface *o, L4::Cap<L4::Rcv_endpoint> ep,
               Demand const &demand)
  {
    int err = _sif->alloc_buffer_demand(demand);
    if (err < 0)
      return L4::Cap<L4::Rcv_endpoint>(err | L4_INVALID_CAP_BIT);
 
    err = o->set_server(_sif, ep);
    if (err < 0)
      return L4::Cap<L4::Rcv_endpoint>(err | L4_INVALID_CAP_BIT);
 
    l4_umword_t id = l4_umword_t(o);
    err = l4_error(ep->bind_thread(_server, id));
    if (err < 0)
      return L4::Cap<L4::Rcv_endpoint>(err | L4_INVALID_CAP_BIT);
 
    return ep;
  }
 
  L4::Cap<void> _register_ep(L4::Epiface *o, char const *service,
                             Demand const &demand)
  {
    L4::Cap<L4::Rcv_endpoint> cap = L4Re::Env::env()->get_cap<L4::Rcv_endpoint>(service);
    if (!cap.is_valid())
      return cap;
 
    return _register_ep(o, cap, demand);
  }
 
  L4::Cap<void> _register_gate(L4::Epiface *o, Demand const &demand)
  {
    int err = _sif->alloc_buffer_demand(demand);
    if (err < 0)
      return L4::Cap<void>(err | L4_INVALID_CAP_BIT);
 
   auto cap = L4Re::Util::make_unique_cap<L4::Kobject>();
 
    if (!cap.is_valid())
      return cap.get();
 
    l4_umword_t id = l4_umword_t(o);
    err = l4_error(_factory->create_gate(cap.get(), _server, id));
    if (err < 0)
      return L4::Cap<void>(err | L4_INVALID_CAP_BIT);
 
    err = o->set_server(_sif, cap.get(), true);
    if (err < 0)
      return L4::Cap<void>(err | L4_INVALID_CAP_BIT);
 
    return cap.release();
  }
 
  L4::Cap<L4::Irq> _register_irq(L4::Epiface *o,
                                 Demand const &demand)
  {
    int err = _sif->alloc_buffer_demand(demand);
    if (err < 0)
      return L4::Cap<L4::Irq>(err | L4_INVALID_CAP_BIT);
 
    auto cap = L4Re::Util::make_unique_cap<L4::Irq>();
 
    if (!cap.is_valid())
      return cap.get();
 
    l4_umword_t id = l4_umword_t(o);
    err = l4_error(_factory->create(cap.get()));
    if (err < 0)
      return L4::Cap<L4::Irq>(err | L4_INVALID_CAP_BIT);
 
    err = o->set_server(_sif, cap.get(), true);
    if (err < 0)
      return L4::Cap<L4::Irq>(err | L4_INVALID_CAP_BIT);
 
    err = l4_error(cap->bind_thread(_server, id));
    if (err < 0)
      return L4::Cap<L4::Irq>(err | L4_INVALID_CAP_BIT);
 
    return cap.release();
  }
 
  static Demand _get_buffer_demand(L4::Epiface *o)
  { return o->get_buffer_demand(); }
 
  template<typename T>
  static Demand _get_buffer_demand(T *,
      typename L4::Kobject_typeid<typename T::Interface>::Demand
        d = typename L4::Kobject_typeid<typename T::Interface>::Demand())
  { return d; }
 
public:
  L4::Cap<void> register_obj(L4::Epiface *o, char const *service) override
  {
    return _register_ep(o, service, _get_buffer_demand(o));
  }
 
  L4::Cap<void> register_obj(L4::Epiface *o) override
  {
    return _register_gate(o, _get_buffer_demand(o));
  }
 
  L4::Cap<L4::Irq> register_irq_obj(L4::Epiface *o) override
  {
    return _register_irq(o, _get_buffer_demand(o));
  }
 
  // pass access to deprecated register_irq_obj
  using L4::Registry_iface::register_irq_obj;
 
  L4::Cap<L4::Rcv_endpoint>
  register_obj(L4::Epiface *o, L4::Cap<L4::Rcv_endpoint> ep) override
  {
    return _register_ep(o, ep, _get_buffer_demand(o));
  }
 
 
  void unregister_obj(L4::Epiface *o, bool unmap = true) override
  {
    L4::Epiface::Stored_cap c;
 
    if (!o || !o->obj_cap().is_valid())
      return;
 
    c = o->obj_cap();
 
    if (unmap)
      L4::Cap<L4::Task>(L4Re::This_task)->unmap(c.fpage(), L4_FP_ALL_SPACES);
 
    // make sure unhandled ipc ends up with the null handler
    L4::Thread::Modify_senders todo;
    todo.add(~3UL, reinterpret_cast<l4_umword_t>(o),
             ~0UL, reinterpret_cast<l4_umword_t>((L4::Epiface*)&_null_handler));
    _server->modify_senders(todo);
 
    // we use bit 4 to indicated an internally allocated cap
    if (c.managed())
      cap_alloc.free(c);
 
    o->set_server(0, L4::Cap<void>::Invalid);
  }
};
 
template< typename LOOP_HOOKS = L4::Ipc_svr::Default_loop_hooks >
class Registry_server : public L4::Server<LOOP_HOOKS>
{
private:
  typedef L4::Server<LOOP_HOOKS> Base;
  Object_registry _registry;
 
public:
  Registry_server() : _registry(this)
  {}
 
  Registry_server(l4_utcb_t *, L4::Cap<L4::Thread> server,
                  L4::Cap<L4::Factory> factory)
  : _registry(this, server, factory)
  {}
 
  Registry_server(L4::Cap<L4::Thread> server,
                  L4::Cap<L4::Factory> factory)
  : _registry(this, server, factory)
  {}
 
  Object_registry const *registry() const { return &_registry; }
  Object_registry *registry() { return &_registry; }
 
  void L4_NORETURN loop(l4_utcb_t *utcb = l4_utcb())
  { Base::template loop<L4::Runtime_error, Object_registry &>(_registry, utcb); }
};
 
}}