ipc_server_loop

// vi:set ft=cpp: -*- Mode: C++ -*-
/*
 * Copyright (C) 2015, 2017, 2019, 2021-2022 Kernkonzept GmbH.
 * Author(s): Alexander Warg <alexander.warg@kernkonzept.com>
 *
 * This file is distributed under the terms of the GNU General Public
 * License, version 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 "ipc_epiface"
 
namespace L4 {
 
namespace Ipc_svr {
 
enum Reply_mode
{
  Reply_compound, 
  Reply_separate  
};
 
struct Ignore_errors
{ static void error(l4_msgtag_t, l4_utcb_t *) {} };
 
struct Default_timeout
{ static l4_timeout_t timeout() { return L4_IPC_SEND_TIMEOUT_0; } };
 
struct Compound_reply
{
  static Reply_mode before_reply(l4_msgtag_t, l4_utcb_t *)
  { return Reply_compound; }
};
 
struct Default_setup_wait
{ static void setup_wait(l4_utcb_t *, Reply_mode) {} };
 
template< typename R >
struct Direct_dispatch
{
  R &r;
 
  Direct_dispatch(R &r) : r(r) {}
 
  l4_msgtag_t operator () (l4_msgtag_t tag, l4_umword_t obj, l4_utcb_t *utcb)
  { return r.dispatch(tag, obj, utcb); }
};
 
template< typename R >
struct Direct_dispatch<R*>
{
  R *r;
 
  Direct_dispatch(R *r) : r(r) {}
 
  l4_msgtag_t operator () (l4_msgtag_t tag, l4_umword_t obj, l4_utcb_t *utcb)
  { return r->dispatch(tag, obj, utcb); }
};
 
#ifdef __EXCEPTIONS
template< typename R, typename Exc> // = L4::Runtime_error>
struct Exc_dispatch : private Direct_dispatch<R>
{
  Exc_dispatch(R r) : Direct_dispatch<R>(r) {}
 
  l4_msgtag_t operator () (l4_msgtag_t tag, l4_umword_t obj, l4_utcb_t *utcb)
  {
    try
      {
        return Direct_dispatch<R>::operator () (tag, obj, utcb);
      }
    catch (Exc &e)
      {
        return l4_msgtag(e.err_no(), 0, 0, 0);
      }
    catch (int err)
      {
        return l4_msgtag(err, 0, 0, 0);
      }
    catch (long err)
      {
        return l4_msgtag(err, 0, 0, 0);
      }
  }
};
#endif
 
class Br_manager_no_buffers : public Server_iface
{
public:
  int alloc_buffer_demand(Demand const &demand) override
  {
    if (!demand.no_demand())
      return -L4_ENOMEM;
    return L4_EOK;
  }
 
  L4::Cap<void> get_rcv_cap(int) const override
  { return L4::Cap<void>::Invalid; }
 
  int realloc_rcv_cap(int) override
  { return -L4_ENOMEM; }
 
  int add_timeout(Timeout *, l4_kernel_clock_t) override
  { return -L4_ENOSYS; }
 
  int remove_timeout(Timeout *) override
  { return -L4_ENOSYS; }
 
protected:
  unsigned first_free_br() const
  { return 1; }
 
  void setup_wait(l4_utcb_t *utcb, L4::Ipc_svr::Reply_mode)
  {
    l4_buf_regs_t *br = l4_utcb_br_u(utcb);
    br->bdr = 0;
    br->br[0] = 0;
  }
};
 
struct Default_loop_hooks :
  public Ignore_errors, public Default_timeout, public Compound_reply,
  Br_manager_no_buffers
{};
 
}
 
template< typename LOOP_HOOKS = Ipc_svr::Default_loop_hooks >
class Server :
  public LOOP_HOOKS
{
public:
  /* Internal note: After all users have been converted, remove this
   * constructor. Also remove the constructor below then. */
  explicit Server(l4_utcb_t *)
    L4_DEPRECATED("Do not specify the UTCB with the constructor. "
            "Supply it on the loop function if needed.")
  {}
 
  /* Internal note: Remove this constructor when the above deprecated
   * constructor with the UTCB pointer is also removed. */
  Server() {}
 
  template< typename DISPATCH >
  inline L4_NORETURN void internal_loop(DISPATCH dispatch, l4_utcb_t *);
 
  template< typename R >
  inline L4_NORETURN void loop_noexc(R r, l4_utcb_t *u = l4_utcb())
  { internal_loop(Ipc_svr::Direct_dispatch<R>(r), u); }
 
#ifdef __EXCEPTIONS
  template< typename EXC, typename R >
  inline L4_NORETURN void loop(R r, l4_utcb_t *u = l4_utcb())
  {
    internal_loop(Ipc_svr::Exc_dispatch<R, EXC>(r), u);
    // function will never return
  }
#endif
protected:
  inline l4_msgtag_t reply_n_wait(l4_msgtag_t reply, l4_umword_t *p, l4_utcb_t *);
};
 
template< typename L >
inline l4_msgtag_t
Server<L>::reply_n_wait(l4_msgtag_t reply, l4_umword_t *p, l4_utcb_t *utcb)
{
  if (reply.label() != -L4_ENOREPLY)
    {
      Ipc_svr::Reply_mode m = this->before_reply(reply, utcb);
      if (m == Ipc_svr::Reply_compound)
        {
          this->setup_wait(utcb, m);
          return l4_ipc_reply_and_wait(utcb, reply, p, this->timeout());
        }
      else
        {
          l4_msgtag_t res = l4_ipc_send(L4_INVALID_CAP | L4_SYSF_REPLY, utcb, reply, this->timeout());
          if (res.has_error())
            return res;
        }
    }
  this->setup_wait(utcb, Ipc_svr::Reply_separate);
  return l4_ipc_wait(utcb, p, this->timeout());
}
 
template< typename L >
template< typename DISPATCH >
inline L4_NORETURN void
Server<L>::internal_loop(DISPATCH dispatch, l4_utcb_t *utcb)
{
  l4_msgtag_t res;
  l4_umword_t p;
  l4_msgtag_t r = l4_msgtag(-L4_ENOREPLY, 0, 0, 0);
 
  while (true)
    {
      res = reply_n_wait(r, &p, utcb);
      if (res.has_error())
        {
          this->error(res, utcb);
          r = l4_msgtag(-L4_ENOREPLY, 0, 0, 0);
          continue;
        }
 
      r = dispatch(res, p, utcb);
    }
}
 
} // namespace L4