virq.h

Go to the documentation of this file.

// AUTOMATICALLY GENERATED -- DO NOT EDIT!         -*- c++ -*-

#ifndef virq_h
#define virq_h

#include "observer.h"
#include "irq.h"

//
// INTERFACE definition follows 
//


class Virq : public Irq, public Observer
{
private:
  Virq();
  Virq(Virq&);

public:  
  explicit inline Virq(unsigned irqnum);
  
  inline bool alloc(Receiver *t, bool /*ack_in_kernel*/);
  
  inline bool free(Receiver *t);
  
  inline void hit();
  
  inline void notify();
  
  void acknowledge();
};

//
// IMPLEMENTATION includes follow (for use by inline functions)
//


#include "config.h"
#include "kdb_ke.h"
#include "atomic.h"
#include "receiver.h"

//
// IMPLEMENTATION of inline functions (and needed classes)
//




inline Virq::Virq(unsigned irqnum) 
  : Irq(irqnum)
{
}


inline bool
Virq::alloc(Receiver *t, bool /*ack_in_kernel*/)
{
  bool ret = cas (&_irq_thread, static_cast<Receiver*>(0), t);

  if (ret)
    {
      _ack_in_kernel = 0;
      _queued = 0;
    }

  return ret;
}


inline bool
Virq::free(Receiver *t)
{
  bool ret = cas (&_irq_thread, t, static_cast<Receiver*>(0));

  if (ret) 
    {
      sender_dequeue(t->sender_list());
    }

  return ret;
}


inline void
Virq::hit()
{
  // We're entered holding the kernel lock, which also means irqs are
  // disabled on this CPU (XXX always correct?).  We never enable irqs
  // in this stack frame (except maybe in a nonnested invocation of
  // switch_exec() -> switchin_context()) -- they will be re-enabled
  // once we return from it (iret in entry.S:all_irqs) or we switch to
  // a different thread.
  if (_irq_thread == (void*)-1) /* debugger attached to IRQ */ 
    {
#if defined(CONFIG_JDB)
      kdb_ke("IRQ ENTRY");
#endif
      return;
    }

  if (! _irq_thread)
    return;

  if (_queued++ == 0)   // increase hit counter
    {
      set_receiver (_irq_thread);
      sender_enqueue(_irq_thread->sender_list());

      // if the thread is waiting for this interrupt, make it ready;
      // this will cause it to run irq->receiver_ready(), which
      // handles the rest

      // XXX careful!  This code may run in midst of an ipc_send_regs
      // operation (or similar)!

      if (_irq_thread->sender_ok (this))
        {
          // we don't need to manipulate the state in a safe way
          // because we are still running with interrupts turned off
          _irq_thread->state_change_dirty(~Thread_busy, Thread_ready);

          _irq_thread->ready_enqueue();
        }
    }
}



inline void
Virq::notify()
{
  hit();
}

#endif // virq_h

---