ipc_basics

// 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
 
#include "types"
#include <l4/sys/utcb.h>
#include <l4/sys/err.h>
 
namespace L4 {

namespace Ipc {

namespace Msg {
 
using L4::Types::True;
using L4::Types::False;

constexpr unsigned long align_to(unsigned long bytes, unsigned long align) noexcept
{ return (bytes + align - 1) & ~(align - 1); }

template<typename T>
constexpr unsigned long align_to(unsigned long bytes) noexcept
{ return align_to(bytes, __alignof(T)); }

template<typename T>
constexpr bool check_size(unsigned offset, unsigned limit) noexcept
{
  return offset + sizeof(T) <= limit;
}

template<typename T, typename CTYPE>
inline bool check_size(unsigned offset, unsigned limit, CTYPE cnt) noexcept
{
  if (L4_UNLIKELY(sizeof(CTYPE) <= sizeof(unsigned) &&
                  ~0U / sizeof(T) <= static_cast<unsigned>(cnt)))
    return false;
 
  if (L4_UNLIKELY(sizeof(CTYPE) > sizeof(unsigned) &&
                  static_cast<CTYPE>(~0U / sizeof(T)) <= cnt))
    return false;
 
  return sizeof(T) * cnt <= limit - offset;
}
 
 
enum
{
  Word_bytes = sizeof(l4_umword_t),
  Item_words = 2,
  Item_bytes = Word_bytes * Item_words,
  Mr_words   = L4_UTCB_GENERIC_DATA_SIZE,
  Mr_bytes   = Word_bytes * Mr_words,
  Br_bytes   = Word_bytes * L4_UTCB_GENERIC_BUFFERS_SIZE,
};
 

template<typename T>
inline int msg_add(char *msg, unsigned offs, unsigned limit, T v) noexcept
{
  offs = align_to<T>(offs);
  if (L4_UNLIKELY(!check_size<T>(offs, limit)))
    return -L4_EMSGTOOLONG;
  *reinterpret_cast<L4::Types::Remove_const_t<T> *>(msg + offs) = v;
  return offs + sizeof(T);
}

template<typename T>
inline int msg_get(char *msg, unsigned offs, unsigned limit, T &v) noexcept
{
  offs = align_to<T>(offs);
  if (L4_UNLIKELY(!check_size<T>(offs, limit)))
    return -L4_EMSGTOOSHORT;
  v = *reinterpret_cast<T *>(msg + offs);
  return offs + sizeof(T);
}

struct Dir_in { using type = Dir_in;   using dir = Dir_in; };
struct Dir_out { using type = Dir_out; using dir = Dir_out; };

struct Cls_data { using type = Cls_data;     using cls = Cls_data; };
struct Cls_item { using type = Cls_item;     using cls = Cls_item; };
struct Cls_buffer { using type = Cls_buffer; using cls = Cls_buffer; };
 
// Typical combinations
struct Do_in_data : Dir_in, Cls_data {};
struct Do_out_data : Dir_out, Cls_data {};
struct Do_in_items : Dir_in, Cls_item {};
struct Do_out_items : Dir_out, Cls_item {};
struct Do_rcv_buffers : Dir_in, Cls_buffer {};
 
// implementation details
namespace Detail {
 
template<typename T> struct _Plain
{
  using type = T;
  static T deref(T v) noexcept { return v; }
};
 
template<typename T> struct _Plain<T *>
{
  using type = T;
  static T &deref(T *v) noexcept { return *v; }
};
 
template<typename T> struct _Plain<T &>
{
  using type = T;
  static T &deref(T &v) noexcept { return v; }
 
};
 
template<typename T> struct _Plain<T const &>
{
  using type = T;
  static T const &deref(T const &v) noexcept { return v; }
};
 
template<typename T> struct _Plain<T const *>
{
  using type = T;
  static T const &deref(T const *v) noexcept { return *v; }
};
}

template<typename MTYPE, typename DIR, typename CLASS> struct Clnt_val_ops;
 
// Provides empty default implementations for the Dir/Cls combinations in which
// the type does not participate (for the Do_in_items, Do_in_data, ... passes in
// Rpc_inline_call::call).
//
// The Clnt_val_ops specializations derive from Clnt_noops, and pull in the
// empty default implementations with `using Clnt_noops::{to,from}_msg`, to
// handle the other Dir/Cls combinations.
template<typename T> struct Clnt_noops
{
  template<typename A, typename B>
  static constexpr int to_msg(char *, unsigned offset, unsigned, T, A, B) noexcept
  { return offset; }

  template<typename A, typename B>
  static constexpr int from_msg(char *, unsigned offset, unsigned, long, T const &, A, B) noexcept
  { return offset; }
};
 
// Provides empty default implementations for the Dir/Class combinations in which
// the type does not participate (for the Do_in_items, Do_in_data, ... passes in
// handle_svr_obj_call).
//
// The Svr_val_ops specializations derive from Svr_noops, and pull in the
// empty default implementations with `using Svr_noops::{from,to}_svr`, to
// handle the other Dir/Cls combinations.
template<typename T> struct Svr_noops
{
  template<typename A, typename B>
  static constexpr int from_svr(char *, unsigned offset, unsigned, long, T, A, B) noexcept
  { return offset; }

  template<typename A, typename B>
  static constexpr int to_svr(char *, unsigned offset, unsigned, T const &, A, B) noexcept
  { return offset; }
};
 
// Default implementation, via reinterpret_cast.
// Override by partially specializing Clnt_val_ops.
template<typename MTYPE, typename CLASS>
struct Clnt_val_ops<MTYPE, Dir_in, CLASS> : Clnt_noops<MTYPE>
{
  using Clnt_noops<MTYPE>::to_msg;
  static int to_msg(char *msg, unsigned offset, unsigned limit,
                    MTYPE arg, Dir_in, CLASS) noexcept
  { return msg_add<MTYPE>(msg, offset, limit, arg); }
};
 
// Default implementation, via reinterpret_cast.
// Override by partially specializing Clnt_val_ops.
template<typename MTYPE, typename CLASS>
struct Clnt_val_ops<MTYPE, Dir_out, CLASS> : Clnt_noops<MTYPE>
{
  using Clnt_noops<MTYPE>::from_msg;
  static int from_msg(char *msg, unsigned offset, unsigned limit, long,
                      MTYPE &arg, Dir_out, CLASS) noexcept
  { return msg_get<MTYPE>(msg, offset, limit, arg); }
};

template<typename MTYPE, typename DIR, typename CLASS> struct Svr_val_ops;
 
// Default implementation, via reinterpret_cast.
// Override by partially specializing Clnt_val_ops.
template<typename MTYPE, typename CLASS>
struct Svr_val_ops<MTYPE, Dir_in, CLASS> : Svr_noops<MTYPE>
{
  using Svr_noops<MTYPE>::to_svr;
  static int to_svr(char *msg, unsigned offset, unsigned limit,
                    MTYPE &arg, Dir_in, CLASS) noexcept
  { return msg_get<MTYPE>(msg, offset, limit, arg); }
};
 
// Default implementation, via reinterpret_cast.
// Override by partially specializing Clnt_val_ops.
template<typename MTYPE, typename CLASS>
struct Svr_val_ops<MTYPE, Dir_out, CLASS> : Svr_noops<MTYPE>
{
  using Svr_noops<MTYPE>::to_svr;
  static int to_svr(char *, unsigned offs, unsigned limit,
                    MTYPE &, Dir_out, CLASS) noexcept
  {
    offs = align_to<MTYPE>(offs);
    if (L4_UNLIKELY(!check_size<MTYPE>(offs, limit)))
      return -L4_EMSGTOOLONG;
    return offs + sizeof(MTYPE);
  }
 
  using Svr_noops<MTYPE>::from_svr;
  static int from_svr(char *msg, unsigned offset, unsigned limit, long,
                      MTYPE arg, Dir_out, CLASS) noexcept
  { return msg_add<MTYPE>(msg, offset, limit, arg); }
};
 
template<typename T> struct Elem
{
  using arg_type = T;
  using svr_type = T;
  using svr_arg_type = T; // might be const & (depending on the size)
 
  enum { Is_optional = false };
 
};
 
template<typename T> struct Elem<T &>
{
  using arg_type = T &;
  using svr_type = T;
  using svr_arg_type = T &;
  enum { Is_optional = false };
};
 
template<typename T> struct Elem<T const &>
{
  using arg_type = T const &;
  using svr_type = T;
  // as the RPC uses a const reference we use it here too,
  // we could also use pass by value depending on the size
  using svr_arg_type = T const &;
  enum { Is_optional = false };
};
 
template<typename T> struct Elem<T *> : Elem<T &>
{
  using arg_type = T *;
};
 
template<typename T> struct Elem<T const *> : Elem<T const &>
{
  using arg_type = T const *;
};

template<typename T> struct Is_valid_rpc_type : L4::Types::True {};
 
// Static assertions outside functions work only properly from C++11
// onwards. On earlier version make sure the compiler fails on an ugly
// undefined struct instead.
template<typename T, bool B> struct Error_invalid_rpc_parameter_used;
template<typename T> struct Error_invalid_rpc_parameter_used<T, true> {};
 
#if __cplusplus >= 201103L
template<typename T>
struct _Elem : Elem<T>
{
  static_assert(Is_valid_rpc_type<T>::value,
                "L4::Ipc::Msg::_Elem<T>: type T is not a valid RPC parameter type.");
};
#else
template<typename T>
struct _Elem : Elem<T>,
               Error_invalid_rpc_parameter_used<T, Is_valid_rpc_type<T>::value>
{};
#endif
 
 
template<typename T> struct Class : Cls_data {};
template<typename T> struct Direction : Dir_in {};
template<typename T> struct Direction<T const &> : Dir_in {};
template<typename T> struct Direction<T const *> : Dir_in {};
template<typename T> struct Direction<T &> : Dir_out {};
template<typename T> struct Direction<T *> : Dir_out {};
 
template<typename T> struct _Clnt_noops :
  Clnt_noops<typename Detail::_Plain<typename _Elem<T>::arg_type>::type>
{};
 
namespace Detail {
 
template<typename T, typename DIR, typename CLASS>
struct _Clnt_val_ops :
  Clnt_val_ops<typename Detail::_Plain<T>::type, DIR, CLASS> {};
 
template<typename T,
         typename ELEM = _Elem<T>,
         typename CLNT_OPS = _Clnt_val_ops<typename ELEM::arg_type,
                                           typename Direction<T>::type,
                                           typename Class<typename Detail::_Plain<T>::type>::type>
         >
struct _Clnt_xmit : CLNT_OPS {};
 
template<typename T,
         typename ELEM = _Elem<T>,
         typename SVR_OPS = Svr_val_ops<typename ELEM::svr_type,
                                        typename Direction<T>::type,
                                        typename Class<typename Detail::_Plain<T>::type>::type>
         >
struct _Svr_xmit : SVR_OPS {};
 
} //namespace Detail
 
// Specialize to alias a type X to T in client call signature.
// Needs to be combined with a matching Elem< X > : Elem< T > specialization.
// Or alternatively X needs to inherit from T.
template<typename T> struct Clnt_xmit : Detail::_Clnt_xmit<T> {};
// Specialize to alias a type X to T in server op_... signature.
// Needs to be combined with a matching Elem< X > : Elem< T > specialization.
// Or alternatively X needs to inherit from T.
template<typename T> struct Svr_xmit : Detail::_Svr_xmit<T> {};
 
}}} // namespace Msg, Ipc, L4