ipc_iface

Go to the documentation of this file.

// vi:set ft=cpp: -*- Mode: C++ -*-
/*
 * (c) 2014 Alexander Warg <alexander.warg@kernkonzept.com>
 *
 * License: see LICENSE.spdx (in this directory or the directories above)
 */
#pragma once
#pragma GCC system_header
 
#include <l4/sys/cxx/ipc_basics>
#include <l4/sys/cxx/ipc_types>
#include <l4/sys/__typeinfo.h>


 
// TODO: add some more documentation
namespace L4 { namespace Ipc {

struct L4_EXPORT Call
{
  enum { Is_call = true };
  enum { Rights = 0 };
  static l4_timeout_t timeout() { return L4_IPC_NEVER; }
};

struct L4_EXPORT Call_zero_send_timeout : Call
{
  static l4_timeout_t timeout() { return L4_IPC_SEND_TIMEOUT_0; }
};

template<unsigned RIGHTS>
struct L4_EXPORT Call_t : Call
{
  enum { Rights = RIGHTS };
};

struct L4_EXPORT Send_only
{
  enum { Is_call = false };
  enum { Rights = 0 };
  static l4_timeout_t timeout() { return L4_IPC_NEVER; }
};
 
namespace Msg {

template<typename OP, typename CLASS, typename SIG, typename FLAGS = Call>
struct L4_EXPORT Rpc_inline_call;

template<typename OP, typename CLASS, typename FLAGS, typename R,
         typename ...ARGS>
struct L4_EXPORT Rpc_inline_call<OP, CLASS, R (ARGS...), FLAGS>
{
  template<typename T> struct Result { using result_type = T; };
  enum
  {
    Return_tag = L4::Types::Same_v<R, l4_msgtag_t>
  };

  using type = Rpc_inline_call;
  using op_type = OP;
  using class_type = CLASS;
  using result_type = typename Result<R>::result_type;
  using ipc_type = R (ARGS...);
  using func_type = result_type (typename _Elem<ARGS>::arg_type...);

  using flags_type = FLAGS;
 
  template<typename RES>
  static L4::Types::Enable_if_t< Return_tag, RES >
  return_err(l4_ret_t err) noexcept { return l4_msgtag(err, 0, 0, 0); }
 
  template<typename RES>
  static L4::Types::Enable_if_t< Return_tag, RES >
  return_ipc_err(l4_msgtag_t tag, l4_utcb_t const *) noexcept { return tag; }
 
  template<typename RES>
  static L4::Types::Enable_if_t< Return_tag, RES >
  return_code(l4_msgtag_t tag) noexcept { return tag; }
 
  template<typename RES>
  static L4::Types::Enable_if_t< !Return_tag, RES >
  return_err(long err) noexcept { return err; }
 
  template<typename RES>
  static L4::Types::Enable_if_t< !Return_tag, RES >
  return_ipc_err(l4_msgtag_t, l4_utcb_t *utcb) noexcept
  { return l4_ipc_to_errno(l4_ipc_error_code(utcb)); }
 
  template<typename RES>
  static L4::Types::Enable_if_t< !Return_tag, RES >
  return_code(l4_msgtag_t tag) noexcept { return tag.label(); }
 
  static R call(L4::Cap<class_type> cap,
                typename _Elem<ARGS>::arg_type ...a,
                l4_utcb_t *utcb = l4_utcb()) noexcept;
};

template<typename OP, typename CLASS, typename SIG, typename FLAGS = Call>
struct L4_EXPORT Rpc_call;

template<typename IPC, typename SIG> struct _Call;

template<typename IPC, typename R, typename ...ARGS>
struct _Call<IPC, R (ARGS...)>
{
public:
  using class_type = typename IPC::class_type;
  using result_type = typename IPC::result_type;
 
private:
  L4::Cap<class_type> cap() const noexcept
  {
    return L4::Cap<class_type>(reinterpret_cast<l4_cap_idx_t>(this)
                               & L4_CAP_MASK);
  }
 
public:
  result_type operator () (ARGS ...a, l4_utcb_t *utcb = l4_utcb()) const noexcept
  { return IPC::call(cap(), a..., utcb); }
};

template<typename IPC> struct Call : _Call<IPC, typename IPC::func_type> {};

template<typename OP,
         typename CLASS,
         typename FLAGS,
         typename R,
         typename ...ARGS>
struct L4_EXPORT Rpc_call<OP, CLASS, R (ARGS...), FLAGS> :
  Rpc_inline_call<OP, CLASS, R (ARGS...), FLAGS>
{
  static R call(L4::Cap<CLASS> cap,
                typename _Elem<ARGS>::arg_type ...a,
                l4_utcb_t *utcb = l4_utcb()) noexcept;
};
 
#define L4_INLINE_RPC_SRV_FORWARD(name)                                    \
  template<typename OBJ> struct fwd                                        \
  {                                                                        \
    OBJ *o;                                                                \
    fwd(OBJ *o) noexcept : o(o) {}                                         \
    template<typename ...ARGS>                                             \
    decltype(auto) call(ARGS ...a) noexcept(noexcept(o->op_##name(a...)))  \
    { return o->op_##name(a...); }                                         \
  }
 

#define L4_INLINE_RPC_NF(res, name, args...)                                 \
  struct name##_t : L4::Ipc::Msg::Rpc_inline_call<name##_t, Class, res args> \
  {                                                                          \
    using type = L4::Ipc::Msg::Rpc_inline_call<name##_t, Class, res args>;   \
    L4_INLINE_RPC_SRV_FORWARD(name);                                         \
  }

#define L4_INLINE_RPC_NF_OP(op, res, name, args...)                          \
  struct name##_t : L4::Ipc::Msg::Rpc_inline_call<name##_t, Class, res args> \
  {                                                                          \
    using type = L4::Ipc::Msg::Rpc_inline_call<name##_t, Class, res args>;   \
    enum { Opcode = (op) };                                                  \
    L4_INLINE_RPC_SRV_FORWARD(name);                                         \
  }
 
#ifdef DOXYGEN
#define L4_INLINE_RPC(res, name, args, attr...) res name args
#else
#define L4_INLINE_RPC(res, name, args...)                                    \
  L4_INLINE_RPC_NF(res, name, args); L4::Ipc::Msg::Call<name##_t> name
#endif
 
#ifdef DOXYGEN
#define L4_INLINE_RPC_OP(op, res, name, args, attr...) res name args
#else
#define L4_INLINE_RPC_OP(op, res, name, args...)                             \
  L4_INLINE_RPC_NF_OP(op, res, name, args); L4::Ipc::Msg::Call<name##_t> name
#endif

#define L4_RPC_NF(res, name, args...)                                        \
  struct name##_t : L4::Ipc::Msg::Rpc_call<name##_t, Class, res args>        \
  {                                                                          \
    using type = L4::Ipc::Msg::Rpc_call<name##_t, Class, res args>;          \
    L4_INLINE_RPC_SRV_FORWARD(name);                                         \
  }

#define L4_RPC_NF_OP(op, res, name, args...)                                 \
  struct name##_t : L4::Ipc::Msg::Rpc_call<name##_t, Class, res args>        \
  {                                                                          \
    using type = L4::Ipc::Msg::Rpc_call<name##_t, Class, res args>;          \
    enum { Opcode = (op) };                                                  \
    L4_INLINE_RPC_SRV_FORWARD(name);                                         \
  }
 
#ifdef DOXYGEN
#define L4_RPC(res, name, args, attr...) res name args
#else
#define L4_RPC(res, name, args...)                                           \
  L4_RPC_NF(res, name, args); L4::Ipc::Msg::Call<name##_t> name
#endif
 
#ifdef DOXYGEN
#define L4_RPC_OP(op, res, name, args, attr...) res name args
#else
#define L4_RPC_OP(op, res, name, args...)                                    \
  L4_RPC_NF_OP(op, res, name, args); L4::Ipc::Msg::Call<name##_t> name
#endif
 

namespace Detail {

template<typename ...ARGS>
struct Buf
{
public:
  template<Phase PHASE>
  static constexpr int write(char *, int offset, int) noexcept
  { return offset; }
 
  template<Phase PHASE>
  static constexpr int read(char *, int offset, int) noexcept
  { return offset; }
 
  using Base = void;
};
 
template<typename A, typename ...M>
struct Buf<A, M...> : Buf<M...>
{
  using Base = Buf<M...>;
 
  using xmit = Clnt_xmit<A>;
  using arg_type = typename _Elem<A>::arg_type;
  using plain = Detail::_Plain<arg_type>;
  static constexpr bool Is_input = _Elem<A>::Is_input;
  static constexpr bool Is_output = _Elem<A>::Is_output;
 
  template<Phase PHASE>
  static int
  write(char *base, int offset, int limit,
        arg_type a, typename _Elem<M>::arg_type ...m) noexcept
  {
    if constexpr (PHASE == Phase::Data && Is_input)
      offset = xmit::to_msg_data(base, offset, limit, plain::deref(a));
    else if constexpr (PHASE == Phase::Items && Is_input)
      offset = xmit::to_msg_items(base, offset, limit, plain::deref(a));
    else if constexpr (PHASE == Phase::Buffers && Is_output)
      offset = xmit::to_msg_buffers(base, offset, limit, plain::deref(a));
 
    return Base::template write<PHASE>(base, offset, limit, m...);
  }
 
  template<Phase PHASE>
  static int
  read(char *base, int offset, int limit,
       arg_type a, typename _Elem<M>::arg_type ...m) noexcept
  {
    int r = offset;
    // Read output parameters from UTCB MRs.
    if constexpr (Is_output)
      {
        static_assert(PHASE == Phase::Data || PHASE == Phase::Items);
        if constexpr (PHASE == Phase::Data)
          r = xmit::from_msg_data(base, offset, limit, plain::deref(a));
        else // PHASE == Phase::Items
          r = xmit::from_msg_items(base, offset, limit, plain::deref(a));
      }
 
    if (L4_LIKELY(r >= 0))
      return Base::template read<PHASE>(base, r, limit, m...);
 
    if (_Elem<A>::Is_optional)
      return Base::template read<PHASE>(base, offset, limit, m...);
 
    return r;
  }
};
 
template <typename ...ARGS> struct _Part
{
  using Data = Buf<ARGS...>;
 
  template<Phase PHASE>
  static int write(void *b, int offset, int limit,
                        typename _Elem<ARGS>::arg_type ...m) noexcept
  {
    char *buf = static_cast<char *>(b);
    int r = Data::template write<PHASE>(buf, offset, limit, m...);
    if (L4_LIKELY(r >= offset))
      return r - offset;
    return r;
  }
 
  template<Phase PHASE>
  static int read(void *b, int offset, int limit,
                       typename _Elem<ARGS>::arg_type ...m) noexcept
  {
    char *buf = static_cast<char *>(b);
    int r = Data::template read<PHASE>(buf, offset, limit, m...);
    if (L4_LIKELY(r >= offset))
      return r - offset;
    return r;
  }
};

template<typename IPC_TYPE, typename OPCODE = void>
struct Part;
 
// The version without an op-code
template<typename R, typename ...ARGS>
struct Part<R (ARGS...), void> : _Part<ARGS...>
{
  using Data = Buf<ARGS...>;
 
  // write arguments, skipping the dummy opcode
  static int write_op(void *b, int offset, int limit,
                      int /*placeholder for op*/,
                      typename _Elem<ARGS>::arg_type ...m) noexcept
  {
    char *buf = static_cast<char *>(b);
    int r = Data::template write<Phase::Data>(buf, offset, limit, m...);
    if (L4_LIKELY(r >= offset))
      return r - offset;
    return r;
  }
};
 
// Message part with additional opcode
template<typename OPCODE, typename R, typename ...ARGS>
struct Part<R (ARGS...), OPCODE> : _Part<ARGS...>
{
  using opcode_type = OPCODE;
  using Data = Buf<opcode_type, ARGS...>;
 
  // write arguments, including the opcode
  static int write_op(void *b, int offset, int limit,
                      opcode_type op, typename _Elem<ARGS>::arg_type ...m) noexcept
  {
    char *buf = static_cast<char *>(b);
    int r = Data::template write<Phase::Data>(buf, offset, limit, op, m...);
    if (L4_LIKELY(r >= offset))
      return r - offset;
    return r;
  }
};
 
 
} // namespace Detail
 
//----------------------------------------------------
// Implementation of the RPC call
// TODO: Add support for timeout via special RPC argument
// TODO: Add support for passing the UTCB pointer as argument
//
template<typename OP, typename CLASS, typename FLAGS, typename R,
         typename ...ARGS>
inline R
Rpc_inline_call<OP, CLASS, R (ARGS...), FLAGS>::
  call(L4::Cap<CLASS> cap,
       typename _Elem<ARGS>::arg_type ...a,
       l4_utcb_t *utcb) noexcept
{
  using namespace Ipc::Msg;
 
  using Rpcs = typename Kobject_typeid<CLASS>::Iface::Rpcs;
  using Opt = typename Rpcs::template Rpc<OP>;
  using Args = Detail::Part<ipc_type, typename Rpcs::opcode_type>;
 
  l4_msg_regs_t *mrs = l4_utcb_mr_u(utcb);
 
  // handle in-data part of the arguments
  int send_bytes =
    Args::write_op(mrs->mr, 0, Mr_bytes, Opt::Opcode, a...);
 
  if (L4_UNLIKELY(send_bytes < 0))
    return return_err<R>(send_bytes);
 
  send_bytes = align_to<l4_umword_t>(send_bytes);
  int const send_words = send_bytes / Word_bytes;
  // write the in-items part of the message if there is one
  int item_bytes =
    Args::template write<Phase::Items>(&mrs->mr[send_words], 0,
                                       Mr_bytes - send_bytes, a...);
 
  if (L4_UNLIKELY(item_bytes < 0))
    return return_err<R>(item_bytes);
 
  int send_items = item_bytes / Item_bytes;
 
    {
      // setup the receive buffers for the RPC call
      l4_buf_regs_t *brs = l4_utcb_br_u(utcb);
      // XXX: we currently support only one type of receive buffers per call
      brs->bdr = 0; // we always start at br[0]
 
      // the limit leaves us at least one register for the zero terminator
      // add the buffers given as arguments to the buffer registers
      int bytes =
        Args::template write<Phase::Buffers>(brs->br, 0, Br_bytes - Word_bytes,
                                             a...);
 
      if (L4_UNLIKELY(bytes < 0))
        return return_err<R>(bytes);
 
      brs->br[bytes / Word_bytes] = 0;
    }
 
 
  // here we do the actual IPC ---------------------------------
  l4_msgtag_t t;
  t = l4_msgtag(CLASS::Protocol, send_words, send_items, 0);
  // do the call (Q: do we need support for timeouts?)
  if (flags_type::Is_call)
    t = l4_ipc_call(cap.cap(), utcb, t, flags_type::timeout());
  else
    {
      t = l4_ipc_send(cap.cap(), utcb, t, flags_type::timeout());
      if (L4_UNLIKELY(t.has_error()))
        return return_ipc_err<R>(t, utcb);
 
      return return_code<R>(l4_msgtag(0, 0, 0, t.flags()));
    }
 
  // unmarshalling starts here ---------------------------------
 
  // bail out early in the case of an IPC error
  if (L4_UNLIKELY(t.has_error()))
    return return_ipc_err<R>(t, utcb);
 
  // take the label as return value
  l4_ret_t r = t.label();
 
  // bail out on negative error codes too
  if (L4_UNLIKELY(r < 0))
    return return_err<R>(r);
 
  int const rcv_bytes = t.words() * Word_bytes;
 
  // read the static out-data values to the arguments
  int err = Args::template read<Phase::Data>(mrs->mr, 0, rcv_bytes, a...);
 
  int const item_limit = t.items() * Item_bytes;
 
  if (L4_UNLIKELY(err < 0 || item_limit > Mr_bytes))
    return return_err<R>(-L4_EMSGTOOSHORT);
 
  // read the static out-items to the arguments
  err = Args::template read<Phase::Items>(&mrs->mr[t.words()], 0, item_limit,
                                          a...);
 
  if (L4_UNLIKELY(err < 0))
    return return_err<R>(-L4_EMSGTOOSHORT);
 
  return return_code<R>(t);
}
 
} // namespace Msg
} // namespace Ipc
} // namespace L4