ipc_server_loop

// vi:set ft=cpp: -*- Mode: C++ -*-
/*
 * Copyright (C) 2015, 2017, 2019, 2021-2024 Kernkonzept GmbH.
 * Author(s): Alexander Warg <alexander.warg@kernkonzept.com>
 *
 * License: see LICENSE.spdx (in this directory or the directories above)
 */
#pragma once
 
#include "ipc_epiface"
 
namespace L4 {
 
namespace Ipc_svr {
 
enum Reply_mode
{
  Reply_compound, 
  Reply_separate  
};
enum Reply_mode {…};
 
struct Ignore_errors
{ static void error(l4_msgtag_t, l4_utcb_t *) {} };
struct Ignore_errors {…};
 
struct Default_timeout
{ static l4_timeout_t timeout() { return L4_IPC_SEND_TIMEOUT_0; } };
struct Default_timeout {…};
 
struct Compound_reply
{
  static Reply_mode before_reply(l4_msgtag_t, l4_utcb_t *)
  { return Reply_compound; }
};
struct Compound_reply {…};
 
struct Default_setup_wait
{ static void setup_wait(l4_utcb_t *, Reply_mode) {} };
struct Default_setup_wait {…};
 
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); }
  l4_msgtag_t operator () (l4_msgtag_t tag, l4_umword_t obj, l4_utcb_t *utcb) {…}
};
struct Direct_dispatch {…};
 
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); }
  l4_msgtag_t operator () (l4_msgtag_t tag, l4_umword_t obj, l4_utcb_t *utcb) {…}
};
struct Direct_dispatch<R*> {…};
 
#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);
      }
  }
  l4_msgtag_t operator () (l4_msgtag_t tag, l4_umword_t obj, l4_utcb_t *utcb) {…}
};
struct Exc_dispatch : private Direct_dispatch<R> {…};
 
template< typename R, typename Exc, typename Printer >
struct Dbg_dispatch : private Direct_dispatch<R>
{
  Dbg_dispatch(R r, Printer p) : Direct_dispatch<R>(r), _printer(p) {}
 
  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)
      {
        _printer.printf("Error in handling IPC: %s: %s\n", e.str(),
                        e.extra_str());
        return l4_msgtag(e.err_no(), 0, 0, 0);
      }
    catch (int err)
      {
        _printer.printf("Error in handling IPC: %d (%s)\n", err,
                        l4sys_errtostr(err));
        return l4_msgtag(err, 0, 0, 0);
      }
    catch (long err)
      {
        _printer.printf("Error in handling IPC: %ld (%s)\n", err,
                        l4sys_errtostr(err));
        return l4_msgtag(err, 0, 0, 0);
      }
  }
  l4_msgtag_t operator () (l4_msgtag_t tag, l4_umword_t obj, l4_utcb_t *utcb) {…}
 
  Printer _printer;
};
struct Dbg_dispatch : private Direct_dispatch<R> {…};
#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;
  }
  int alloc_buffer_demand(Demand const &demand) override {…}
 
  L4::Cap<void> get_rcv_cap(int) const override
  { return L4::Cap<void>::Invalid; }
  L4::Cap<void> get_rcv_cap(int) const override {…}
 
  int realloc_rcv_cap(int) override
  { return -L4_ENOMEM; }
  int realloc_rcv_cap(int) override {…}
 
  int add_timeout(Timeout *, l4_kernel_clock_t) override
  { return -L4_ENOSYS; }
  int add_timeout(Timeout *, l4_kernel_clock_t) override {…}
 
  int remove_timeout(Timeout *) override
  { return -L4_ENOSYS; }
  int remove_timeout(Timeout *) override {…}
 
protected:
  unsigned first_free_br() const
  { return 1; }
  unsigned first_free_br() const {…}
 
  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;
  }
  void setup_wait(l4_utcb_t *utcb, L4::Ipc_svr::Reply_mode) {…}
};
class Br_manager_no_buffers : public Server_iface {…};
 
struct Default_loop_hooks :
  public Ignore_errors, public Default_timeout, public Compound_reply,
  Br_manager_no_buffers
{};
struct Default_loop_hooks : {…};
 
}
 
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.")
  {}
  explicit Server(l4_utcb_t *) {…}
 
  /* 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); }
  inline L4_NORETURN void loop_noexc(R r, l4_utcb_t *u = l4_utcb()) {…}
 
#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
  }
  inline L4_NORETURN void loop(R r, l4_utcb_t *u = l4_utcb()) {…}
 
  template< typename EXC, typename R, typename Printer >
  inline L4_NORETURN void loop_dbg(R r, Printer p, l4_utcb_t *u = l4_utcb())
  {
    internal_loop(Ipc_svr::Dbg_dispatch<R, EXC, Printer>(r, p), u);
    // function will never return
  }
  inline L4_NORETURN void loop_dbg(R r, Printer p, l4_utcb_t *u = l4_utcb()) {…}
#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());
}
Server<L>::reply_n_wait(l4_msgtag_t reply, l4_umword_t *p, l4_utcb_t *utcb) {…}
  inline l4_msgtag_t reply_n_wait(l4_msgtag_t reply, l4_umword_t *p, l4_utcb_t *); {…}
 
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);
    }
}
Server<L>::internal_loop(DISPATCH dispatch, l4_utcb_t *utcb) {…}
  inline L4_NORETURN void internal_loop(DISPATCH dispatch, l4_utcb_t *); {…}
 
} // namespace L4
class Server : {…};