ipc_types

Go to the documentation of this file.

// vi:set ft=cpp: -*- Mode: C++ -*-
/*
 * (c) 2014 Alexander Warg <alexander.warg@kernkonzept.com>
 *
 * 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 "capability.h"
#include "types"
#include "ipc_basics"
namespace L4 {
 
typedef int Opcode;
 
namespace Ipc {
 
template<typename T> struct L4_EXPORT Out;
 
 
template<typename T> struct  L4_EXPORT In_out
{
  T v;
  In_out() {}
  In_out(T v) : v(v) {}
  operator T () const { return v; }
  operator T & () { return v; }
};
 
namespace Msg {
template<typename A> struct Elem< In_out<A *> > : Elem<A *> {};
 
template<typename A>
struct Svr_xmit< In_out<A *> > : Svr_xmit<A *>, Svr_xmit<A const *>
{
  using Svr_xmit<A *>::from_svr;
  using Svr_xmit<A const *>::to_svr;
};
 
template<typename A>
struct Clnt_xmit< In_out<A *> > : Clnt_xmit<A *>, Clnt_xmit<A const *>
{
  using Clnt_xmit<A *>::from_msg;
  using Clnt_xmit<A const *>::to_msg;
};
 
template<typename A>
struct Is_valid_rpc_type< In_out<A *> > : Is_valid_rpc_type<A *> {};
template<typename A>
struct Is_valid_rpc_type< In_out<A const *> > : L4::Types::False {};
 
#ifdef CONFIG_ALLOW_REFS
template<typename A> struct Elem< In_out<A &> > : Elem<A &> {};
 
template<typename A>
struct Svr_xmit< In_out<A &> > : Svr_xmit<A &>, Svr_xmit<A const &>
{
  using Svr_xmit<A &>::from_svr;
  using Svr_xmit<A const &>::to_svr;
};
 
template<typename A>
struct Clnt_xmit< In_out<A &> > : Clnt_xmit<A &>, Clnt_xmit<A const &>
{
  using Clnt_xmit<A &>::from_msg;
  using Clnt_xmit<A const &>::to_msg;
};
 
template<typename A>
struct Is_valid_rpc_type< In_out<A &> > : Is_valid_rpc_type<A &> {};
template<typename A>
struct Is_valid_rpc_type< In_out<A const &> > : L4::Types::False {};
 
#else
 
template<typename A>
struct Is_valid_rpc_type< In_out<A &> > : L4::Types::False {};
 
#endif
 
// Value types don't make sense for output.
template<typename A>
struct Is_valid_rpc_type< In_out<A> > : L4::Types::False {};
 
}
 
 
template<typename T> struct L4_EXPORT As_value
{
  typedef T value_type;
  T v;
  As_value() noexcept {}
  As_value(T v) noexcept : v(v) {}
  operator T () const noexcept { return v; }
  operator T & () noexcept { return v; }
};
 
namespace Msg {
template<typename T> struct Class< As_value<T> > : Cls_data {};
template<typename T> struct Elem< As_value<T> > : Elem<T> {};
template<typename T> struct Elem< As_value<T> *> : Elem<T *> {};
}
 
 
template<typename T> struct L4_EXPORT Opt
{
  T _value;    
  bool _valid; 
 
  Opt() noexcept : _valid(false) {}
 
  Opt(T value) noexcept : _value(value), _valid(true) {}
 
  Opt &operator = (T value) noexcept
  {
    this->_value = value;
    this->_valid = true;
    return *this;
  }
 
  void set_valid(bool valid = true) noexcept { _valid = valid; }
 
  T *operator -> () noexcept { return &this->_value; }
  T const *operator -> () const noexcept { return &this->_value; }
  T value() const noexcept { return this->_value; }
  T &value() noexcept { return this->_value; }
  bool is_valid() const noexcept { return this->_valid; }
};
 
namespace Msg {
template<typename T> struct Elem< Opt<T &> > : Elem<T &>
{
  enum { Is_optional = true };
  typedef Opt<typename Elem<T &>::svr_type> &svr_arg_type;
  typedef Opt<typename Elem<T &>::svr_type> svr_type;
};
 
template<typename T> struct Elem< Opt<T *> > : Elem<T *>
{
  enum { Is_optional = true };
  typedef Opt<typename Elem<T *>::svr_type> &svr_arg_type;
  typedef Opt<typename Elem<T *>::svr_type> svr_type;
};
 
 
 
template<typename T, typename CLASS>
struct Svr_val_ops<Opt<T>, Dir_out, CLASS> : Svr_noops< Opt<T> >
{
  typedef Opt<T> svr_type;
  typedef Svr_val_ops<T, Dir_out, CLASS> Native;
 
  using Svr_noops< Opt<T> >::to_svr;
  static int to_svr(char *msg, unsigned offset, unsigned limit,
                    Opt<T> &arg, Dir_out, CLASS) noexcept
  {
    return Native::to_svr(msg, offset, limit, arg.value(), Dir_out(), CLASS());
  }
 
  using Svr_noops< Opt<T> >::from_svr;
  static int from_svr(char *msg, unsigned offset, unsigned limit, long ret,
                      svr_type &arg, Dir_out, CLASS) noexcept
  {
    if (arg.is_valid())
      return Native::from_svr(msg, offset, limit, ret, arg.value(),
                              Dir_out(), CLASS());
    return offset;
  }
};
 
template<typename T> struct Elem< Opt<T> > : Elem<T>
{
  enum { Is_optional = true };
  typedef Opt<T> arg_type;
};
 
template<typename T> struct Elem< Opt<T const *> > : Elem<T const *>
{
  enum { Is_optional = true };
  typedef Opt<T const *> arg_type;
};
 
template<typename T>
struct Is_valid_rpc_type< Opt<T const &> > : L4::Types::False {};
 
template<typename T, typename CLASS>
struct Clnt_val_ops<Opt<T>, Dir_in, CLASS> : Clnt_noops< Opt<T> >
{
  typedef Opt<T> arg_type;
  typedef Detail::_Clnt_val_ops<typename Elem<T>::arg_type, Dir_in, CLASS> Native;
 
  using Clnt_noops< Opt<T> >::to_msg;
  static int to_msg(char *msg, unsigned offset, unsigned limit,
                    arg_type arg, Dir_in, CLASS) noexcept
  {
    if (arg.is_valid())
      return Native::to_msg(msg, offset, limit,
                            Detail::_Plain<T>::deref(arg.value()),
                            Dir_in(), CLASS());
    return offset;
  }
};
 
template<typename T> struct Class< Opt<T> > :
  Class< typename Detail::_Plain<T>::type > {};
template<typename T> struct Direction< Opt<T> > : Direction<T> {};
}
 
class  L4_EXPORT Small_buf
{
public:
  explicit Small_buf(L4::Cap<void> cap, unsigned long flags = 0) noexcept
  : _data(cap.cap() | L4_RCV_ITEM_SINGLE_CAP | flags) {}
 
  explicit Small_buf(l4_cap_idx_t cap, unsigned long flags = 0) noexcept
  : _data(cap | L4_RCV_ITEM_SINGLE_CAP | flags) {}
 
  l4_umword_t raw() const noexcept { return _data; }
private:
  l4_umword_t _data;
};
 
class L4_EXPORT Gen_fpage
{
public:
  enum Type
  {
    Special = L4_FPAGE_SPECIAL << 4,
    Memory  = L4_FPAGE_MEMORY << 4,
    Io      = L4_FPAGE_IO << 4,
    Obj     = L4_FPAGE_OBJ << 4
  };
 
  enum Map_type
  {
    Map   = L4_MAP_ITEM_MAP,
    Grant = L4_MAP_ITEM_GRANT,
  };
 
  enum Cacheopt
  {
    None     = 0,
    Cached   = L4_FPAGE_CACHEABLE << 4,
    Buffered = L4_FPAGE_BUFFERABLE << 4,
    Uncached = L4_FPAGE_UNCACHEABLE << 4
  };
 
  enum Continue
  {
    Single   = 0,
    Last     = 0,
    More     = L4_ITEM_CONT,
    Compound = L4_ITEM_CONT,
  };
 
  Gen_fpage(l4_umword_t base, l4_umword_t data) noexcept
  : _base(base), _data(data)
  {}
 
  Gen_fpage(Type type, l4_addr_t base, int order,
            unsigned char rights,
            l4_addr_t snd_base,
            Map_type map_type,
            Cacheopt cache, Continue cont) noexcept
  : _base(L4_ITEM_MAP | (snd_base & (~0UL << 12)) | l4_umword_t(map_type)
          | l4_umword_t(cache) | l4_umword_t(cont)),
    _data(base | l4_umword_t(type) | rights | (l4_umword_t(order) << 6))
  {}
 
  unsigned order() const noexcept { return (_data >> 6) & 0x3f; }
  unsigned snd_order() const noexcept { return (_data >> 6) & 0x3f; }
  unsigned rcv_order() const noexcept { return (_base >> 6) & 0x3f; }
  l4_addr_t base() const noexcept { return _data & (~0UL << 12); }
  l4_addr_t snd_base() const noexcept { return _base & (~0UL << 12); }
  void snd_base(l4_addr_t b) noexcept { _base = (_base & ~(~0UL << 12)) | (b & (~0UL << 12)); }
 
  bool is_valid() const noexcept { return _base & L4_ITEM_MAP; }
  bool cap_received() const noexcept { return (_base & 0x3e) == 0x38; }
  bool id_received() const noexcept { return (_base & 0x3e) == 0x3c; }
  bool local_id_received() const noexcept { return (_base & 0x3e) == 0x3e; }
 
  bool is_compound() const noexcept { return _base & 1; }
  l4_umword_t data() const noexcept { return _data; }
  l4_umword_t base_x() const noexcept { return _base; }
 
protected:
  l4_umword_t _base;
  l4_umword_t _data;
};
 
class Snd_fpage : public Gen_fpage
{
public:
  Snd_fpage(l4_umword_t base = 0, l4_umword_t data = 0) noexcept
  : Gen_fpage(base, data)
  {}
 
  Snd_fpage(l4_fpage_t const &fp, l4_addr_t snd_base = 0,
            Map_type map_type = Map,
            Cacheopt cache = None, Continue cont = Last) noexcept
  : Gen_fpage(L4_ITEM_MAP | (snd_base & (~0UL << 12)) | l4_umword_t(map_type)
                | l4_umword_t(cache) | l4_umword_t(cont),
              fp.raw)
  {}
 
  Snd_fpage(L4::Cap<void> cap, unsigned rights, Map_type map_type = Map) noexcept
  : Gen_fpage(L4_ITEM_MAP | l4_umword_t(map_type) | (rights & 0xf0),
              cap.fpage(rights).raw)
  {}
 
  static Snd_fpage obj(l4_cap_idx_t base, int order,
                       unsigned char rights,
                       l4_addr_t snd_base = 0,
                       Map_type map_type = Map,
                       Continue cont = Last) noexcept
  {
    return Snd_fpage(l4_obj_fpage(base, order, rights), snd_base,
                     map_type, None, cont);
  }
 
  static Snd_fpage mem(l4_addr_t base, int order,
                       unsigned char rights,
                       l4_addr_t snd_base = 0,
                       Map_type map_type = Map,
                       Cacheopt cache = None, Continue cont = Last) noexcept
  {
    return Snd_fpage(l4_fpage(base, order, rights), snd_base, map_type, cache,
                     cont);
  }
 
  static Snd_fpage io(unsigned long base, int order,
                      unsigned char rights,
                      l4_addr_t snd_base = 0,
                      Map_type map_type = Map,
                      Continue cont = Last) noexcept
  {
    return Snd_fpage(l4_fpage_set_rights(l4_iofpage(base, order), rights),
                     snd_base, map_type, None, cont);
  }
};
 
class Rcv_fpage : public Gen_fpage
{
public:
  Rcv_fpage() noexcept : Gen_fpage(0, 0), _rcv_task(L4_INVALID_CAP) {}
  Rcv_fpage(l4_fpage_t const &fp, l4_addr_t snd_base = 0,
            l4_cap_idx_t rcv_task = L4_INVALID_CAP) noexcept
  : Gen_fpage(L4_ITEM_MAP | (snd_base & (~0UL << 12))
                | (l4_is_valid_cap(rcv_task) ? Compound : 0),
              fp.raw),
    _rcv_task(rcv_task)
  {}
 
  static Rcv_fpage obj(l4_cap_idx_t base, int order, l4_addr_t snd_base = 0,
                      L4::Cap<void> rcv_task = L4::Cap<void>::Invalid) noexcept
  {
    return Rcv_fpage(l4_obj_fpage(base, order, 0), snd_base,
                     rcv_task.cap());
  }
 
  static Rcv_fpage mem(l4_addr_t base, int order, l4_addr_t snd_base = 0,
                       L4::Cap<void> rcv_task = L4::Cap<void>::Invalid) noexcept
  {
    return Rcv_fpage(l4_fpage(base, order, 0), snd_base, rcv_task.cap());
  }
 
  static Rcv_fpage io(unsigned long base, int order, l4_addr_t snd_base = 0,
                      L4::Cap<void> rcv_task = L4::Cap<void>::Invalid) noexcept
  {
    return Rcv_fpage(l4_iofpage(base, order), snd_base, rcv_task.cap());
  }
 
  l4_cap_idx_t rcv_task() const { return _rcv_task; }
 
protected:
  l4_cap_idx_t _rcv_task;
};
 
 
namespace Msg {
 
// Snd_fpage are out items
template<> struct Class<L4::Ipc::Snd_fpage> : Cls_item {};
 
// Rcv_fpage are buffer items
template<> struct Class<L4::Ipc::Rcv_fpage> : Cls_buffer {};
 
template<>
struct Clnt_val_ops<L4::Ipc::Rcv_fpage, Dir_in, Cls_buffer>
  : Clnt_noops<L4::Ipc::Rcv_fpage>
{
  using Clnt_noops<L4::Ipc::Rcv_fpage>::to_msg;
 
  static int to_msg(char *msg, unsigned offs, unsigned limit,
                    L4::Ipc::Rcv_fpage arg, Dir_in, Cls_buffer) noexcept
  {
    offs = align_to<l4_umword_t>(offs);
    unsigned words = arg.is_compound() ? 3 : 2;
    if (L4_UNLIKELY(!check_size<l4_umword_t>(offs, limit, words)))
      return -L4_EMSGTOOLONG;
    auto *buf = reinterpret_cast<l4_umword_t*>(msg + offs);
    *buf++ = arg.base_x();
    *buf++ = arg.data();
    if (arg.is_compound())
      *buf++ = arg.rcv_task();
    return offs + sizeof(l4_umword_t) * words;
  }
};
 
 
// Remove receive buffers from server-side arguments
template<> struct Elem<L4::Ipc::Rcv_fpage>
{
  typedef L4::Ipc::Rcv_fpage arg_type;
  typedef void svr_type;
  typedef void svr_arg_type;
  enum { Is_optional = false };
};
 
// Small_buf are buffer items
template<> struct Class<L4::Ipc::Small_buf> : Cls_buffer {};
 
// Remove receive buffers from server-side arguments
template<> struct Elem<L4::Ipc::Small_buf>
{
  typedef L4::Ipc::Small_buf arg_type;
  typedef void svr_type;
  typedef void svr_arg_type;
  enum { Is_optional = false };
};
} // namespace Msg
 
// L4::Cap<> handling
 
template<typename T> class Cap
{
  template<typename O> friend class Cap;
  l4_umword_t _cap_n_rights;
 
public:
  enum
  {
    Rights_mask = 0xff,
 
    Cap_mask    = L4_CAP_MASK
  };
 
  template<typename O>
  Cap(Cap<O> const &o) noexcept : _cap_n_rights(o._cap_n_rights)
  {
    L4::Cap<T>::template check_convertible_from<O>();
  }
 
  Cap(L4::Cap<T> cap) noexcept
  : _cap_n_rights((cap.cap() & Cap_mask) | (cap ? L4_CAP_FPAGE_R : 0))
  {}
 
  template<typename O>
  Cap(L4::Cap<O> cap) noexcept
  : _cap_n_rights((cap.cap() & Cap_mask) | (cap ? L4_CAP_FPAGE_R : 0))
  {
    L4::Cap<T>::template check_convertible_from<O>();
  }
 
  Cap() noexcept : _cap_n_rights(L4_INVALID_CAP) {}
 
  Cap(L4::Cap<T> cap, unsigned char rights) noexcept
  : _cap_n_rights((cap.cap() & Cap_mask) | (rights & Rights_mask)) {}
 
  static Cap from_ci(l4_cap_idx_t c) noexcept
  { return Cap(L4::Cap<T>(c & Cap_mask), c & Rights_mask); }
 
  L4::Cap<T> cap() const noexcept
  { return L4::Cap<T>(_cap_n_rights & Cap_mask); }
 
  unsigned rights() const noexcept
  { return _cap_n_rights & Rights_mask; }
 
  L4::Ipc::Snd_fpage fpage() const noexcept
  { return L4::Ipc::Snd_fpage(cap(), rights()); }
 
  bool is_valid() const noexcept
  { return !(_cap_n_rights & L4_INVALID_CAP_BIT); }
};
 
template<typename T>
Cap<T> make_cap(L4::Cap<T> cap, unsigned rights) noexcept
{ return Cap<T>(cap, rights); }
 
template<typename T>
Cap<T> make_cap_rw(L4::Cap<T> cap) noexcept
{ return Cap<T>(cap, L4_CAP_FPAGE_RW); }
 
template<typename T>
Cap<T> make_cap_rws(L4::Cap<T> cap) noexcept
{ return Cap<T>(cap, L4_CAP_FPAGE_RWS); }
 
template<typename T>
Cap<T> make_cap_full(L4::Cap<T> cap) noexcept
{ return Cap<T>(cap, L4_CAP_FPAGE_RWSD | L4_FPAGE_C_OBJ_RIGHTS); }
 
// caps are special the have an invalid representation
template<typename T> struct L4_EXPORT Opt< Cap<T> >
{
  Cap<T> _value;
  Opt() noexcept {}
  Opt(Cap<T> value) noexcept : _value(value) {}
  Opt(L4::Cap<T> value) noexcept : _value(value) {}
  Opt &operator = (Cap<T> value) noexcept
  { this->_value = value; }
  Opt &operator = (L4::Cap<T> value) noexcept
  { this->_value = value; }
 
  Cap<T> value() const noexcept { return this->_value; }
  bool is_valid() const noexcept { return this->_value.is_valid(); }
};
 
 
namespace Msg {
// prohibit L4::Cap as argument
template<typename A>
struct Is_valid_rpc_type< L4::Cap<A> > : L4::Types::False {};
 
template<typename A> struct Class< Cap<A> > : Cls_item {};
template<typename A> struct Elem< Cap<A> >
{
  enum { Is_optional = false };
  typedef Cap<A> arg_type;
  typedef L4::Ipc::Snd_fpage svr_type;
  typedef L4::Ipc::Snd_fpage svr_arg_type;
};
 
 
template<typename A, typename CLASS>
struct Svr_val_ops<Cap<A>, Dir_in, CLASS> :
  Svr_val_ops<L4::Ipc::Snd_fpage, Dir_in, CLASS>
{};
 
template<typename A, typename CLASS>
struct Clnt_val_ops<Cap<A>, Dir_in, CLASS> :
  Clnt_noops< Cap<A> >
{
  using Clnt_noops< Cap<A> >::to_msg;
 
  static int to_msg(char *msg, unsigned offset, unsigned limit,
                    Cap<A> arg, Dir_in, Cls_item) noexcept
  {
    // passing an invalid cap as mandatory argument is an error
    // XXX: This checks for a client calling error, we could
    //      also just ignore this for performance reasons and
    //      let the client fail badly (Alex: I'd prefer this)
    if (L4_UNLIKELY(!arg.is_valid()))
      return -L4_EMSGMISSARG;
 
    return msg_add(msg, offset, limit, arg.fpage());
  }
};
 
template<typename A>
struct Elem<Out<L4::Cap<A> > >
{
  enum { Is_optional = false };
  typedef L4::Cap<A> arg_type;
  typedef Ipc::Cap<A> svr_type;
  typedef svr_type &svr_arg_type;
};
 
template<typename A> struct Direction< Out< L4::Cap<A> > > : Dir_out {};
template<typename A> struct Class< Out< L4::Cap<A> > > : Cls_item {};
 
template<typename A>
struct Clnt_val_ops< L4::Cap<A>, Dir_out, Cls_item > :
  Clnt_noops< L4::Cap<A> >
{
  using Clnt_noops< L4::Cap<A> >::to_msg;
  static int to_msg(char *msg, unsigned offset, unsigned limit,
                    L4::Cap<A> arg, Dir_in, Cls_buffer) noexcept
  {
    if (L4_UNLIKELY(!arg.is_valid()))
      return -L4_EMSGMISSARG; // no buffer inserted
    return msg_add(msg, offset, limit, Small_buf(arg));
  }
};
 
template<typename A>
struct Svr_val_ops< L4::Ipc::Cap<A>, Dir_out, Cls_item > :
  Svr_noops<Cap<A> &>
{
  using Svr_noops<Cap<A> &>::from_svr;
  static int from_svr(char *msg, unsigned offset, unsigned limit, long,
                      Cap<A> arg, Dir_out, Cls_item) noexcept
  {
    if (L4_UNLIKELY(!arg.is_valid()))
      // do not map anything
      return msg_add(msg, offset, limit, L4::Ipc::Snd_fpage(arg.cap(), 0));
 
    return msg_add(msg, offset, limit, arg.fpage());
  }
};
 
// prohibit a UTCB pointer as normal RPC argument
template<> struct Is_valid_rpc_type<l4_utcb_t *> : L4::Types::False {};
 
} // namespace Msg
} // namespace Ipc
} // namespace L4