event_buffer

// vi:set ft=cpp: -*- Mode: C++ -*-
/*
 * (c) 2008-2009 Adam Lackorzynski <adam@os.inf.tu-dresden.de>,
 *               Alexander Warg <warg@os.inf.tu-dresden.de>
 *     economic rights: Technische Universität Dresden (Germany)
 *
 * License: see LICENSE.spdx (in this directory or the directories above)
 */
 
#pragma once
 
#include <l4/re/event>
#include <l4/re/event-sys.h>
#include <l4/re/rm>
 
#include <string.h>
 
namespace L4Re { namespace Util {
 
template< typename PAYLOAD >
class Event_buffer_t : public L4Re::Event_buffer_t<PAYLOAD>
{
private:
  void *_buf;
public:
  void *buf() const noexcept { return _buf; }
 
  long attach(L4::Cap<L4Re::Dataspace> ds, L4::Cap<L4Re::Rm> rm) noexcept
  {
    l4_addr_t sz = ds->size();
    _buf = 0;
 
    long r = rm->attach(&_buf, sz,
                        L4Re::Rm::F::Search_addr | L4Re::Rm::F::RW,
                        L4::Ipc::make_cap_rw(ds));
    if (r < 0)
      return r;
 
    *static_cast<L4Re::Event_buffer_t<PAYLOAD> *>(this)
      = L4Re::Event_buffer_t<PAYLOAD>(_buf, sz);
    return 0;
  }
  long attach(L4::Cap<L4Re::Dataspace> ds, L4::Cap<L4Re::Rm> rm) noexcept {…}
 
  long detach(L4::Cap<L4Re::Rm> rm) noexcept
  {
    L4::Cap<L4Re::Dataspace> ds;
    if (_buf)
      return rm->detach(_buf, &ds);
    return 0;
  }
  long detach(L4::Cap<L4Re::Rm> rm) noexcept {…}
 
};
class Event_buffer_t : public L4Re::Event_buffer_t<PAYLOAD> {…};
 
template< typename PAYLOAD >
class Event_buffer_consumer_t : public Event_buffer_t<PAYLOAD>
{
public:
 
  template< typename CB, typename D >
  void foreach_available_event(CB const &cb, D data = D())
  {
    typename Event_buffer_t<PAYLOAD>::Event *e;
    while ((e = Event_buffer_t<PAYLOAD>::next()))
      {
        cb(e, data);
        e->free();
      }
  }
  void foreach_available_event(CB const &cb, D data = D()) {…}
 
  template< typename CB, typename D >
  void process(L4::Cap<L4::Irq> irq,
               L4::Cap<L4::Thread> thread,
               CB const &cb, D data = D())
  {
 
    if (l4_error(irq->bind_thread(thread, 0)))
      return;
 
    while (1)
      {
        long r;
        r = l4_ipc_error(l4_irq_receive(irq.cap(), L4_IPC_NEVER),
                         l4_utcb());
        if (r)
          continue;
 
        foreach_available_event(cb, data);
      }
  }
  void process(L4::Cap<L4::Irq> irq, {…}
};
class Event_buffer_consumer_t : public Event_buffer_t<PAYLOAD> {…};
 
typedef Event_buffer_t<Default_event_payload> Event_buffer;
typedef Event_buffer_consumer_t<Default_event_payload> Event_buffer_consumer;
 
}}