receiver.h

Go to the documentation of this file.

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

#ifndef receiver_h
#define receiver_h

#include "context.h"
#include "timeout.h"

//
// INTERFACE definition follows 
//


class Sys_ipc_frame;
class Sender;
class Thread;
class Space;

class Receiver : public Context
{
public:
  bool sender_ok (const Sender* sender) const;
  void deny_lipc();
  void deny_lipc_snd();

private:
  // DATA
  Sender*           _partner;   // IPC partner I'm waiting for/involved with
  Sys_ipc_frame    *_rcv_regs; // registers used for receive
  Address           _pagein_addr; // sender requests page in of this page
  Mword             _pagein_error_code;
  Thread*           _pagein_applicant;
  Sender*           _sender_first;

protected:
  // XXX Timeout for both, sender and receiver! In normal case we would have
  // to define own timeouts in Receiver and Sender but because only one
  // timeout can be set at one time we use the same timeout. The timeout
  // has to be defined here because Dirq::hit has to be able to reset the
  // timeout (Irq::_irq_thread is of type Receiver).
  Timeout *          _timeout;

  void maybe_enable_lipc();
  void allow_lipc();

public:  
  // Interface for senders
  
  inline Sys_ipc_frame* rcv_regs() const;
  
  inline void set_pagein_request(Address address, Mword error_code, Thread *notify);
  
  inline bool in_long_ipc(Sender* sender) const;
  
  inline Sender** sender_list();
  
  inline void set_timeout(Timeout *t);
  
  inline void reset_timeout();
  
  inline int ipc_try_lock(const Sender* sender);
  
  inline void ipc_init(Sender* sender);
  
  inline void ipc_unlock();

protected:  
  // Interface for receivers
  
  inline Receiver(Thread_lock *thread_lock, Space* space, unsigned short prio, unsigned short mcp, Unsigned64 quantum);
  
  inline Sender* partner() const;
  
  inline void restore_receiver_state(Sender* partner, Sys_ipc_frame* regs);
  
  inline void save_receiver_state(Sender** out_partner, Sys_ipc_frame** out_regs);
  
  inline void clear_pagein_request();
  
  inline Address pagein_addr() const;
  
  inline Mword pagein_error_code() const;
  
  inline Thread* pagein_applicant();
  
  // MANIPULATORS
  inline void set_rcv_regs(Sys_ipc_frame* regs);
  
  inline void set_partner(Sender* partner);
  
  inline void setup_receiver(Sender* sender, Sys_ipc_frame* regs);
  
  inline unsigned setup_receiver_state(Sender* sender, Sys_ipc_frame* regs, bool = false);
  
  inline void reload_ip_sp_from_utcb();
};

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


#include "l4_types.h"
#include <cassert>

#include "globals.h"
#include "sender.h"
#include "thread_lock.h"
#include "entry_frame.h"
#include "std_macros.h"
#include "thread_state.h"

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



// Interface for senders

inline Sys_ipc_frame*
Receiver::rcv_regs() const
{
  assert (state () & Thread_ipc_receiving_mask);

  return _rcv_regs;
}


inline void
Receiver::set_pagein_request(Address address, Mword error_code, Thread *notify)
{
  assert (address != (Address) -1);

  _pagein_applicant  = notify;
  _pagein_addr       = address;
  _pagein_error_code = error_code;

  state_change (~Thread_busy_long, Thread_ready);
}


inline Sender*
Receiver::partner() const
{
  return _partner;
}


inline bool
Receiver::in_long_ipc(Sender* sender) const
{
  if (((state() & (Thread_rcvlong_in_progress|Thread_ipc_in_progress)) 
       != (Thread_rcvlong_in_progress|Thread_ipc_in_progress))
      || partner() != sender)
    return false;

  return true;
}



inline Sender**
Receiver::sender_list()
{
  return &_sender_first;
}



inline void
Receiver::set_timeout(Timeout *t)
{
  _timeout = t;
}



inline void
Receiver::reset_timeout()
{
  if (EXPECT_TRUE(!_timeout))
    return;

  _timeout->reset();
  _timeout = 0;
}


inline bool
Receiver::sender_ok(const Sender *sender) const
{
  unsigned ipc_state = state() & (Thread_receiving |
                                  Thread_send_in_progress |
                                  Thread_ipc_in_progress);

  // If Thread_send_in_progress is still set, we're still in the send phase
  if (EXPECT_FALSE (ipc_state != (Thread_receiving | Thread_ipc_in_progress)))
    return false;

  // Check open wait; test if this sender is really the first in queue
  if (EXPECT_TRUE(!partner()))
#if 0
    // disabled until Rene proposes a working patch for the wakeup problem
    && (!_sender_first || sender == _sender_first)
#endif
    return true;

  // Check closed wait; test if this sender is really who we specified
  if (EXPECT_TRUE (sender == partner()))
    return true;

  return false;
}


inline void
Receiver::clear_pagein_request()
{
  _pagein_addr       = (Address) -1;
  _pagein_error_code = 0;
}



inline int
Receiver::ipc_try_lock(const Sender* sender)
{
  if (EXPECT_FALSE (state() == Thread_invalid))
    return Ipc_err::Enot_existent;

  thread_lock()->lock();

  if (EXPECT_FALSE (!sender_ok (sender)))
    {
      /*
        Mark for the receiver that someone is waiting for him.
        If the receiver wants to do the next LIPC, 
        it will check, if someone is waiting for him.
        If yes, then abort LIPC and use normal kernel IPC.
      */
      deny_lipc_snd();
      thread_lock()->clear();
      return -1;
    }

  return 0;                     // OK
}


inline void
Receiver::set_partner(Sender* partner)
{
  _partner = partner;
}


inline void
Receiver::ipc_init(Sender* sender)
{
  deny_lipc();
  set_partner (sender);
  rcv_regs()->rcv_src (sender->id());
  clear_pagein_request();
}


inline void
Receiver::ipc_unlock()
{
  assert (thread_lock()->lock_owner() == current());

  thread_lock()->clear();
}


// Interface for receivers

inline Receiver::Receiver(Thread_lock *thread_lock, 
                   Space* space,
                   unsigned short prio,
                   unsigned short mcp,
                   Unsigned64 quantum)
  : Context (thread_lock, space, prio, mcp, quantum)
{}


// MANIPULATORS

inline void
Receiver::set_rcv_regs(Sys_ipc_frame* regs)
{
  _rcv_regs = regs;
}


inline void
Receiver::restore_receiver_state(Sender* partner, 
                                  Sys_ipc_frame* regs)
{
  set_partner (partner);
  set_rcv_regs (regs);
}


inline void
Receiver::save_receiver_state(Sender** out_partner,
                               Sys_ipc_frame** out_regs)
{
  *out_partner = _partner;
  *out_regs = _rcv_regs;
}


inline Address
Receiver::pagein_addr() const
{
  return _pagein_addr;
}


inline Mword
Receiver::pagein_error_code() const
{
  return _pagein_error_code;
}


inline Thread*
Receiver::pagein_applicant() 
{
  return _pagein_applicant;
}


inline unsigned
Receiver::setup_receiver_state(Sender* sender,
                                Sys_ipc_frame* regs,
                                bool)
{
  set_rcv_regs (regs);  // message should be poked in here
  set_partner (sender);
  return Thread_receiving;
}


inline void
Receiver::setup_receiver(Sender* sender,
                          Sys_ipc_frame* regs)
{
  state_add (setup_receiver_state(sender, regs));
}


inline void
Receiver::reload_ip_sp_from_utcb() {}


inline void 
Receiver::maybe_enable_lipc() {}



inline void
Receiver::deny_lipc() {}


inline void
Receiver::allow_lipc() {}


inline void
Receiver::deny_lipc_snd() {}

#endif // receiver_h

---