ipc_array

// 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 "ipc_basics"
#include "ipc_types"
 
namespace L4 { namespace Ipc L4_EXPORT {

using Array_len_default = unsigned short;

template< typename ELEM_TYPE, typename LEN_TYPE = Array_len_default >
struct Array_ref
{
  using ptr_type = ELEM_TYPE *;
  using len_type = LEN_TYPE;
 
  len_type length;
  ptr_type data;
  Array_ref() = default;
  Array_ref(len_type length, ptr_type data)
  : length(length), data(data)
  {}
 
  template<typename X> struct Non_const
  { using type = Array_ref<X, LEN_TYPE>; };
 
  template<typename X> struct Non_const<X const>
  { using type = Array_ref<X, LEN_TYPE>; };
 
  Array_ref(typename Non_const<ELEM_TYPE>::type const &other)
  : length(other.length), data(other.data)
  {}
 
  Array_ref &operator = (typename Non_const<ELEM_TYPE>::type const &other)
  {
    this->length = other.length;
    this->data = other.data;
    return *this;
  }
};

template<typename ELEM_TYPE, typename LEN_TYPE = Array_len_default>
struct Array : Array_ref<ELEM_TYPE , LEN_TYPE>
{
  Array() {}
  Array(LEN_TYPE length, ELEM_TYPE *data)
  : Array_ref<ELEM_TYPE, LEN_TYPE>(length, data)
  {}
 
  template<typename X> struct Non_const
  { using type = Array<X, LEN_TYPE>; };
 
  template<typename X> struct Non_const<X const>
  { using type = Array<X, LEN_TYPE>; };

  Array(typename Non_const<ELEM_TYPE>::type const &other)
  : Array_ref<ELEM_TYPE, LEN_TYPE>(other.length, other.data)
  {}
 
  Array &operator = (typename Non_const<ELEM_TYPE>::type const &other)
  {
    this->length = other.length;
    this->data = other.data;
    return *this;
  }
};

template< typename ELEM_TYPE,
          typename LEN_TYPE = Array_len_default,
          LEN_TYPE MAX      = (L4_UTCB_GENERIC_DATA_SIZE *
                                sizeof(l4_umword_t)) / sizeof(ELEM_TYPE) >
struct Array_in_buf
{
  using array = Array_ref<ELEM_TYPE, LEN_TYPE>;
  using const_array = Array_ref<ELEM_TYPE const, LEN_TYPE>;

  ELEM_TYPE data[MAX];
  LEN_TYPE length;

  void copy_in(const_array a)
  {
    length = a.length;
    if (length > MAX)
      length = MAX;
 
    for (LEN_TYPE i = 0; i < length; ++i)
      data[i] = a.data[i];
  }

  Array_in_buf(const_array a)  { copy_in(a); }
  Array_in_buf(array a)  { copy_in(a); }
};
 
// implementation details for transmission
namespace Msg {

template<typename A, typename LEN>
struct Elem< Array<A, LEN> >
{
  using arg_type = Array<A, LEN>;
  using svr_type = Array_ref<A, LEN>;
  using svr_arg_type = svr_type;
  static constexpr bool Is_optional = false;
  static constexpr bool Is_input = true;
  static constexpr bool Is_output = false;
};

template<typename A, typename LEN>
struct Elem< Array<A, LEN> & >
{
  using arg_type = Array<A, LEN> &;
  using svr_type = Array_ref<A, LEN>;
  using svr_arg_type = svr_type &;
  static constexpr bool Is_optional = false;
  static constexpr bool Is_input = false;
  static constexpr bool Is_output = true;
};

template<typename A, typename LEN>
struct Elem< Array_ref<A, LEN> & >
{
  using arg_type = Array_ref<A, LEN> &;
  using svr_type = Array_ref<L4::Types::Remove_const_t<A>, LEN>;
  using svr_arg_type = svr_type &;
  static constexpr bool Is_optional = false;
  static constexpr bool Is_input = false;
  static constexpr bool Is_output = true;
};
 
namespace Detail {
 
template<typename A, typename LEN, typename ARRAY, bool REF>
struct Clnt_val_ops_d_in : Clnt_noops<ARRAY>
{
  static int to_msg_data(char *msg, unsigned offset, unsigned limit,
                         ARRAY const &a)
  {
    offset = align_to<LEN>(offset);
    if (L4_UNLIKELY(!check_size<LEN>(offset, limit)))
      return -L4_EMSGTOOLONG;
    *reinterpret_cast<LEN *>(msg + offset) = a.length;
    offset = align_to<A>(offset + sizeof(LEN));
    if (L4_UNLIKELY(!check_size<A>(offset, limit, a.length)))
      return -L4_EMSGTOOLONG;
    using elem_type = L4::Types::Remove_const_t<A>;
    elem_type *data = reinterpret_cast<elem_type*>(msg + offset);
 
    // we do not correctly handle overlaps
    if (!REF || data != a.data)
      {
        for (LEN i = 0; i < a.length; ++i)
          data[i] = a.data[i];
      }
 
    return offset + a.length * sizeof(A);
  }
};
 
} // namespace Detail
 
template<typename A, typename LEN>
struct Clnt_val_ops<Array<A, LEN>> :
  Detail::Clnt_val_ops_d_in<A, LEN, Array<A, LEN>, false>
{
  using type = Array<A, LEN>;
 
  static int from_msg_data(char *msg, unsigned offset, unsigned limit, type &a)
  {
    offset = align_to<LEN>(offset);
    if (L4_UNLIKELY(!check_size<LEN>(offset, limit)))
      return -L4_EMSGTOOSHORT;
 
    LEN l = *reinterpret_cast<LEN *>(msg + offset);
 
    offset = align_to<A>(offset + sizeof(LEN));
    if (L4_UNLIKELY(!check_size<A>(offset, limit, l)))
      return -L4_EMSGTOOSHORT;
 
    A *data = reinterpret_cast<A*>(msg + offset);
 
    if (l > a.length)
      l = a.length;
    else
      a.length = l;
 
    for (unsigned i = 0; i < l; ++i)
      a.data[i] = data[i];
 
    return offset + l * sizeof(A);
  };
};
 
template<typename A, typename LEN>
struct Clnt_val_ops<Array_ref<A, LEN>> :
  Detail::Clnt_val_ops_d_in<A, LEN, Array_ref<A, LEN>, true>
{
  using type = Array_ref<A, LEN>;
 
  static int from_msg_data(char *msg, unsigned offset, unsigned limit, type &a)
  {
    offset = align_to<LEN>(offset);
    if (L4_UNLIKELY(!check_size<LEN>(offset, limit)))
      return -L4_EMSGTOOSHORT;
 
    LEN l = *reinterpret_cast<LEN *>(msg + offset);
 
    offset = align_to<A>(offset + sizeof(LEN));
    if (L4_UNLIKELY(!check_size<A>(offset, limit, l)))
      return -L4_EMSGTOOSHORT;
 
    a.data = reinterpret_cast<A*>(msg + offset);
    a.length = l;
    return offset + l * sizeof(A);
  };
};
 
template<typename A, typename LEN>
struct Svr_val_ops< Array_ref<A, LEN> > :
  Svr_noops< Array_ref<A, LEN> >
{
  using svr_type = Array_ref<A, LEN>;
  using elem_type = L4::Types::Remove_const_t<A>;
 
  static int to_svr_data(char *msg, unsigned offset, unsigned limit,
                         svr_type &a)
  {
    offset = align_to<LEN>(offset);
    if (L4_UNLIKELY(!check_size<LEN>(offset, limit)))
      return -L4_EMSGTOOSHORT;
    a.length = *reinterpret_cast<LEN *>(msg + offset);
    offset = align_to<A>(offset + sizeof(LEN));
    if (L4_UNLIKELY(!check_size<A>(offset, limit, a.length)))
      return -L4_EMSGTOOSHORT;
    a.data = reinterpret_cast<A*>(msg + offset);
    return offset + a.length * sizeof(A);
  }
 
  static int reserve_data(char *msg, unsigned offset, unsigned limit,
                          svr_type &a)
  {
    offset = align_to<LEN>(offset);
    if (L4_UNLIKELY(!check_size<LEN>(offset, limit)))
      return -L4_EMSGTOOLONG;
 
    offset = align_to<A>(offset + sizeof(LEN));
    a.data = reinterpret_cast<elem_type *>(msg + offset);
    a.length = (limit-offset) / sizeof(A);
    return offset;
  }
 
  static int from_svr_data(char *msg, unsigned offset, unsigned limit,
                           svr_type const &a)
  {
    offset = align_to<LEN>(offset);
    if (L4_UNLIKELY(!check_size<LEN>(offset, limit)))
      return -L4_EMSGTOOLONG;
 
    *reinterpret_cast<LEN *>(msg + offset) = a.length;
 
    offset = align_to<A>(offset + sizeof(LEN));
    if (L4_UNLIKELY(!check_size<A>(offset, limit, a.length)))
      return -L4_EMSGTOOLONG;
 
    // In case of deferred replies, the Array_ref is pointing to a server
    // provided buffer instead of the UTCB.
    elem_type *data = reinterpret_cast<elem_type *>(msg + offset);
    if (data != a.data)
      for (LEN i = 0; i < a.length; ++i)
        data[i] = a.data[i];
 
    return offset + a.length * sizeof(A);
  }
};
 
// Pointer to array is not implemented.
template<typename A, typename LEN>
struct Is_valid_rpc_type< Array_ref<A, LEN> *> : L4::Types::False {};
 
// Optional input arrays are not implemented.
template<typename A, typename LEN>
struct Is_valid_rpc_type< Opt<Array_ref<A, LEN> > > : L4::Types::False {};
 
} // namespace Msg
 
}}