errand.h

/*
 * Copyright (C) 2014, 2020 Kernkonzept GmbH.
 * Author(s): Sarah Hoffmann <sarah.hoffmann@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 <l4/re/env.h>
#include <l4/re/util/object_registry>
#include <l4/re/util/br_manager>
#include <l4/cxx/ipc_timeout_queue>
#include <l4/cxx/ref_ptr>
#include <l4/cxx/exceptions>
#include <l4/libblock-device/debug.h>
 
#include <functional>
 
namespace Block_device { namespace Errand {
 
extern L4::Ipc_svr::Server_iface *_sif;
 
typedef std::function<void()> Callback;
 
class Poll_errand
: public L4::Ipc_svr::Timeout_queue::Timeout,
  public cxx::Ref_obj
{
public:
  void expired() final
  {
    // Recapture the reference pointer from the timeout queue.
    cxx::Ref_ptr<Poll_errand> p(this, false);
 
    try
      {
        if (_poll())
          _callback(true);
        else
            if (--_retries <= 0)
              _callback(false);
            else
              reschedule();
      }
    catch (L4::Runtime_error const &e)
      {
        Err().printf("Polling task failed: %s\n", e.str());
      }
  }
 
 
  void reschedule()
  {
    // create a place holder reference pointer for the timeout queue
    cxx::Ref_ptr<Poll_errand> p(this);
 
    _sif->add_timeout(p.release(), l4_kip_clock(l4re_kip()) + _interval);
  }
 
  // Class can only be instantiated as a reference counting object.
  template< typename T, typename... Args >
  friend
  cxx::Ref_ptr<T> cxx::make_ref_obj(Args &&... args);
 
private:
  Poll_errand(int retries, int interval,
              std::function<bool()> const &poll_func,
              std::function<void(bool)> const &callback)
  : _retries(retries),
    _interval(interval),
    _poll(poll_func),
    _callback(callback)
  {}
 
  int _retries;
  int _interval;
  std::function<bool()> _poll;
  std::function<void(bool)> _callback;
};
 
class Errand
: public L4::Ipc_svr::Timeout_queue::Timeout,
  public cxx::Ref_obj
{
public:
  void expired() final
  {
    // Recapture the reference pointer from the timeout queue.
    cxx::Ref_ptr<Errand> p(this, false);
 
    if (_callback)
      {
        try
          {
            _callback();
          }
        catch (L4::Runtime_error const &e)
          {
            Err().printf("Asynchronous task failed: %s\n", e.str());
          }
      }
  }
 
  void reschedule(unsigned interval = 0)
  {
    // create a placeholder reference pointer for the timeout queue
    cxx::Ref_ptr<Errand> p(this);
 
    _sif->add_timeout(p.release(), l4_kip_clock(l4re_kip()) + interval);
  }
 
  // Class can only be instantiated as a reference counting object.
  template< typename T, typename... Args >
  friend
  cxx::Ref_ptr<T> cxx::make_ref_obj(Args &&... args);
 
private:
  Errand(Callback const &callback) : _callback(callback) {}
 
  Callback _callback; 
};
 
struct Loop_hooks
: L4::Ipc_svr::Timeout_queue_hooks<Loop_hooks, L4Re::Util::Br_manager>,
  L4::Ipc_svr::Ignore_errors
{
  l4_kernel_clock_t now() { return l4_kip_clock(l4re_kip()); }
};
 
using Errand_server = L4Re::Util::Registry_server<Loop_hooks>;
 
inline void set_server_iface(L4::Ipc_svr::Server_iface *sif) { _sif = sif; }
 
inline void schedule(Callback const &callback, int interval)
{
  cxx::make_ref_obj<Errand>(callback)->reschedule(interval);
}
 
inline void poll(int retries, int interval,
                 std::function<bool()> const &poll_func,
                 std::function<void(bool)> const &callback)
{
  if (poll_func())
    callback(true);
  else
    cxx::make_ref_obj<Poll_errand>(retries, interval, poll_func,
                                   callback)->reschedule();
}
 
 
} } // name space