factory

Go to the documentation of this file.

// 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/sys/factory.h>
#include <l4/sys/capability>
#include <l4/sys/cxx/ipc_iface>
#include <l4/sys/cxx/ipc_varg>
 
namespace L4 {
 
class Factory : public Kobject_t<Factory, Kobject, L4_PROTO_FACTORY>
{
public:
 
  typedef l4_mword_t Proto;
 
  struct Nil {};
 
  struct Lstr
  {
    char const *s;
 
    unsigned len;
 
    Lstr(char const *s, unsigned len) noexcept : s(s), len(len) {}
  };
 
  class S
  {
  private:
    l4_utcb_t *u;
    l4_msgtag_t t;
    l4_cap_idx_t f;
 
    template<typename T>
    static T &&_move(T &c) { return static_cast<T &&>(c); }
 
  public:
    S(S const &) = delete;
    S &operator = (S const &) & = delete;
 
    S(S &&o) noexcept
    : u(o.u), t(o.t), f(o.f)
    { o.t.raw = 0; }
 
    S &operator = (S &&o) & noexcept
    {
      u = o.u;
      t = o.t;
      f = o.f;
      o.t.raw = 0;
      return *this;
    }
 
    S(l4_cap_idx_t f, long obj, L4::Cap<void> target,
      l4_utcb_t *utcb) noexcept
    : u(utcb), t(l4_factory_create_start_u(obj, target.cap(), u)), f(f)
    {}
 
    ~S() noexcept
    {
      if (t.raw)
  l4_factory_create_commit_u(f, t, u);
    }
 
    operator l4_msgtag_t () noexcept
    {
      l4_msgtag_t r = l4_factory_create_commit_u(f, t, u);
      t.raw = 0;
      return r;
    }
 
    void put(l4_mword_t i) noexcept
    {
      l4_factory_create_add_int_u(i, &t, u);
    }
 
    void put(l4_umword_t i) noexcept
    {
      l4_factory_create_add_uint_u(i, &t, u);
    }
 
    void put(char const *s) & noexcept
    {
      l4_factory_create_add_str_u(s, &t, u);
    }
 
    void put(Lstr const &s) & noexcept
    {
      l4_factory_create_add_lstr_u(s.s, s.len, &t, u);
    }
 
    void put(Nil) & noexcept
    {
      l4_factory_create_add_nil_u(&t, u);
    }
 
    void put(l4_fpage_t d) & noexcept
    {
      l4_factory_create_add_fpage_u(d, &t, u);
    }
 
    template<typename T>
    S &operator << (T const &d) & noexcept
    {
      put(d);
      return *this;
    }
 
    template<typename T>
    S &&operator << (T const &d) && noexcept
    {
      put(d);
      return _move(*this);
    }
  };
 
 
public:
 
  S create(Cap<void> target, long obj, l4_utcb_t *utcb = l4_utcb()) noexcept
  {
    return S(cap(), obj, target, utcb);
  }
 
  template<typename OBJ>
  S create(Cap<OBJ> target, l4_utcb_t *utcb = l4_utcb()) noexcept
  {
    return S(cap(), OBJ::Protocol, target, utcb);
  }
 
  L4_INLINE_RPC_NF(
      l4_msgtag_t, create, (L4::Ipc::Out<L4::Cap<void> > target, l4_mword_t obj,
                            L4::Ipc::Varg const *args),
      L4::Ipc::Call_t<L4_CAP_FPAGE_S>);
 
  l4_msgtag_t create_task(Cap<Task> const & target_cap,
                          l4_fpage_t *utcb_area,
                          l4_utcb_t *utcb = l4_utcb()) noexcept
  { return l4_factory_create_task_u(cap(), target_cap.cap(), utcb_area, utcb); }
 
  l4_msgtag_t create_factory(Cap<Factory> const &target_cap,
                             unsigned long limit,
                             l4_utcb_t *utcb = l4_utcb()) noexcept
  { return l4_factory_create_factory_u(cap(), target_cap.cap(), limit, utcb); }
 
  l4_msgtag_t create_gate(Cap<void> const &target_cap,
                          Cap<Thread> const &thread_cap, l4_umword_t label,
                          l4_utcb_t *utcb = l4_utcb()) noexcept
  { return l4_factory_create_gate_u(cap(), target_cap.cap(), thread_cap.cap(), label, utcb); }
 
  typedef L4::Typeid::Rpc_nocode<create_t> Rpcs;
};
 
}