irq.hpp

#if !defined(__IRQ_HPP__)
#define __IRQ_HPP__

//
// local includes
//
#include "core/common.hpp"

//
// classes to implement different locking strategies using a semaphore or IPC respectively.
//
namespace detail
{
    //
    // does not support a client-server model, deprecated
    //
    struct semaphore_irq
    {
        l4_threadid_t client;
        struct semaphore semaphore;

        inline semaphore_irq(void)
            : client(L4_INVALID_ID), semaphore(L4SEMAPHORE_LOCKED)
        {}

        inline unsigned timeout2us(const l4_timeout_t timeout)
        {
            // the timeout cannot be absolute
            assert_logd(L4VMM_DEBUG_IRQS, !l4_timeout_is_absolute(timeout.p.rcv),
                        "invalid absolute timeout. can only handle relative timeouts up to 4294s.\n");

            const l4_kernel_clock_t us=l4_timeout_rel_get(timeout.p.rcv);

            // the code later on uses unsigned to specify a timeout, so check for overflows
            assert_logd(L4VMM_DEBUG_IRQS, (timeout.raw == L4_IPC_NEVER.raw) ||
                                              (us <= integer_traits<unsigned>::const_max),
                        "timeout %lluus (0x%llx) too large. can only handle 4294s.\n", us, us);

            return us;
        }

        inline void do_wait(const l4_threadid_t client, const l4_timeout_t timeout)
        {
            this->client=client;
            logd(L4VMM_DEBUG_IRQS >= 3, L4VMM_DEBUG": %s: "l4util_idfmt"\n",
                 __func__, l4util_idstr(client));

            semaphore.down(timeout2us(timeout));
            this->client=L4_INVALID_ID;
        }

        inline void do_assert(void)
        {
            logd(L4VMM_DEBUG_IRQS >= 2, L4VMM_DEBUG": %s: "l4util_idfmt" -> "l4util_idfmt"\n",
                 __func__, l4util_idstr(l4_myself()), l4util_idstr(client));

            semaphore.up();
        }
    };

    struct ipc_irq
    {
        l4_threadid_t client;

        inline ipc_irq(void)
            : client(L4_INVALID_ID)
        {}

        inline void do_wait(const l4_threadid_t client, const l4_timeout_t timeout)
        {
            this->client=client;
            logd(L4VMM_DEBUG_IRQS >= 3, L4VMM_DEBUG": %s: "l4util_idfmt"\n",
                 __func__, l4util_idstr(client));

            l4_threadid_t src;
            l4_umword_t dummy;
            l4_msgdope_t result;
            do {
                l4_ipc_wait(&src, L4_IPC_SHORT_MSG, &dummy, &dummy, timeout, &result);
            } while (!l4_task_equal(src, client));

            this->client=L4_INVALID_ID;
        }

        inline void do_assert(void)
        {
            logd(L4VMM_DEBUG_IRQS >= 2, L4VMM_DEBUG": %s: "l4util_idfmt" -> "l4util_idfmt"\n",
                 __func__, l4util_idstr(l4_myself()), l4util_idstr(client));

            // use no send timeout, because the invoking thread may be the receiver too (sic!)
            l4_msgdope_t dope;
            l4_ipc_send(client, L4_IPC_SHORT_MSG, 0, 0, L4_IPC_BOTH_TIMEOUT_0, &dope);
        }
    };
}

struct irq
  #if L4VMM_IRQ_SAFE_LOCKS
    : private detail::semaphore_irq
  #else
    : private detail::ipc_irq
  #endif
{
  protected:
    enum state_bits
    {
        PENDING = 0,
        MASKED  = 1
    };

    bitops state;

  public:
    inline irq(void)
        : state(1 << MASKED)
    {}

    //
    // query functions
    //
    inline bool is_pending(void) const
    {
        return state.test_bit(PENDING);
    }

    inline bool is_masked(void) const
    {
        return state.test_bit(MASKED);
    }

    inline l4_umword_t get_state(void) const
    {
        return state;
    }

    inline void consume(void)
    {
        state.clear_bit(PENDING);
    }

    inline void mask(void)
    {
        state.set_bit(MASKED);
    }

    inline void unmask(void)
    {
        const bitops old_state=state;
        state.clear_bit(MASKED);
        if (old_state.test_bit(PENDING) && old_state.test_bit(MASKED))
            do_assert();
    }

    inline void wait(const l4_threadid_t client, const l4_timeout_t timeout)
    {
        const bitops old_state=state;
        if (!old_state.test_bit(PENDING) || old_state.test_bit(MASKED))
            do_wait(client, timeout);
        consume();
    }

    inline void assert_irq(void)
    {
        const bitops old_state=state;
        state.set_bit(PENDING);
        if (!old_state.test_bit(PENDING) && !old_state.test_bit(MASKED))
            do_assert();
    }
};

#endif

// ***** end of source ***** //