ipc_server_loop

// vi:set ft=cpp: -*- Mode: C++ -*-
/*
 * Copyright (C) 2015, 2017, 2019, 2021-2025 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  
};

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);
      }
  }
};

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);
      }
  }
 
  Printer _printer;
};
#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
  }

  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
  }
#endif
protected:
  inline l4_msgtag_t reply_n_wait(l4_msgtag_t reply, l4_umword_t *p, l4_utcb_t *);
 
private:
  template<typename U> static auto _has_setup_reply_cap(int)
    -> decltype(&U::setup_reply_cap, L4::Types::True());
  template<typename> static L4::Types::False _has_setup_reply_cap(...);
 
  // Backwards compatibility check via `if constexpr` in reply_n_wait() if
  // explicit reply cap mechanism is present. Once we move to C++20, this can
  // be replaced by `requires{Server::setup_reply_cap();}`.
  static constexpr bool Has_setup_reply_cap
    = L4::Types::Same_v<decltype(_has_setup_reply_cap<Server>(0)),
                        L4::Types::True>;
};
 
template< typename L >
inline l4_msgtag_t
Server<L>::reply_n_wait(l4_msgtag_t reply, l4_umword_t *p, l4_utcb_t *utcb)
{
  l4_cap_idx_t reply_cap = L4_INVALID_REPLY_CAP;
  if constexpr (Has_setup_reply_cap)
    reply_cap = this->setup_reply_cap().cap();
 
  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_cap, utcb, L4_SYSF_REPLY_AND_WAIT, 0, reply, p,
                        this->timeout()); // l4_ipc_reply_and_wait
        }
      else
        {
          l4_msgtag_t res = l4_ipc_reply(reply_cap, utcb, reply,
                                         this->timeout());
          if (res.has_error())
            return res;
        }
    }
  this->setup_wait(utcb, Ipc_svr::Reply_separate);
  return l4_ipc(reply_cap, utcb, L4_SYSF_WAIT, 0, l4_msgtag_t{0}, p,
                this->timeout()); // l4_ipc_wait
}
 
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