ipc_timeout_queue

// vim:set ft=cpp: -*- Mode: C++ -*-
/*
 * (c) 2014 Steffen Liebergeld <steffen.liebergeld@kernkonzept.com>
 *
 * This file is licensed under the terms of the GNU General Public License 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 <l4/cxx/hlist>
#include <l4/sys/cxx/ipc_server_loop>
 
namespace L4 { namespace Ipc_svr {
 
class Timeout : public cxx::H_list_item
{
  friend class Timeout_queue;
public:
  Timeout() : _timeout(0) {}
 
  virtual ~Timeout() = 0;
 
  virtual void expired() = 0;
 
  l4_kernel_clock_t timeout() const
  { return _timeout; }
 
private:
  l4_kernel_clock_t _timeout;
};
 
inline Timeout::~Timeout() {}
 
class Timeout_queue
{
public:
  typedef L4::Ipc_svr::Timeout Timeout;
 
  l4_kernel_clock_t next_timeout() const
  {
    if (auto e = _timeouts.front())
      return e->timeout();
 
    return 0;
  }
 
  bool timeout_expired(l4_kernel_clock_t now) const
  {
    l4_kernel_clock_t next = next_timeout();
    return (next != 0) && (next <= now);
  }
 
  void handle_expired_timeouts(l4_kernel_clock_t now)
  {
    while (!_timeouts.empty())
      {
        Queue::Iterator top = _timeouts.begin();
        if ((*top)->_timeout > now)
          return;
 
        Timeout *t = *top;
        top = _timeouts.erase(top);
        t->expired();
      }
  }
 
  void add(Timeout *timeout, l4_kernel_clock_t time)
  {
    timeout->_timeout = time;
    Queue::Iterator i = _timeouts.begin();
    while (i != _timeouts.end() && (*i)->timeout() < time)
      ++i;
 
    _timeouts.insert_before(timeout, i);
  }
 
  void remove(Timeout *timeout)
  {
    _timeouts.remove(timeout);
  }
 
private:
  typedef cxx::H_list<Timeout> Queue;
  Queue _timeouts;
};
 
template< typename HOOKS, typename BR_MAN = Br_manager_no_buffers >
class Timeout_queue_hooks : public BR_MAN
{
  l4_kernel_clock_t _now()
  { return static_cast<HOOKS*>(this)->now(); }
 
  unsigned _timeout_br()
  { return this->first_free_br(); }
 
public:
  l4_timeout_t timeout()
  {
    l4_kernel_clock_t t = queue.next_timeout();
    if (t)
       return l4_timeout(L4_IPC_TIMEOUT_0, l4_timeout_abs(t, _timeout_br()));
    return L4_IPC_SEND_TIMEOUT_0;
  }
 
  void setup_wait(l4_utcb_t *utcb, L4::Ipc_svr::Reply_mode mode)
  {
    // we must handle the timer only when called after a possible reply
    // otherwise we probably destroy the reply message.
    if (mode == L4::Ipc_svr::Reply_separate)
      {
        l4_kernel_clock_t now = _now();
        if (queue.timeout_expired(now))
          queue.handle_expired_timeouts(now);
      }
 
    BR_MAN::setup_wait(utcb, mode);
  }
 
  L4::Ipc_svr::Reply_mode before_reply(l4_msgtag_t, l4_utcb_t *)
  {
    // split up reply and wait when a timeout has expired
    if (queue.timeout_expired(_now()))
      return L4::Ipc_svr::Reply_separate;
    return L4::Ipc_svr::Reply_compound;
  }
 
  int add_timeout(Timeout *timeout, l4_kernel_clock_t time) override
  {
    queue.add(timeout, time);
    return 0;
  }
 
  int remove_timeout(Timeout *timeout) override
  {
    queue.remove(timeout);
    return 0;
  }
 
  Timeout_queue queue; 
};
 
}}