entry_frame.h

Go to the documentation of this file.

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

#ifndef entry_frame_h
#define entry_frame_h

#include "l4_types.h"

#include "types.h"

//
// INTERFACE definition follows 
//


class Syscall_frame
{private:

protected:
  Mword ecx;
  Mword edx;
  Mword esi;
  Mword edi;
  Mword ebx;
  Mword ebp;
  Mword eax;
};

class Return_frame
{
public:
  Mword ip() const;
  void  ip(Mword _pc);

  Mword sp() const;
  void  sp(Mword _sp);
private:

private:
  Mword eip;
  Unsigned16 csseg, __csu;
  Mword eflags;
  Mword esp;
  Unsigned16 ssseg, __ssu;

public:  
  inline Mword flags() const;
  
  inline void flags(Mword _flags);
  
  inline Mword cs() const;
  
  inline void cs(Mword _cs);
  
  inline Mword ss() const;
  
  inline void ss(Mword _ss);
};

class Entry_frame : public Syscall_frame, public Return_frame
{};

class Sys_ipc_frame : public Syscall_frame
{
public:
  Mword msg_word (Utcb *dst, unsigned index) const;

  void set_msg_word (Utcb *u, unsigned index, Mword value);

  void set_msg_word (unsigned index, Mword value);

  void rcv_src( L4_uid id ); 

  L4_uid rcv_src() const;

  L4_uid snd_dst() const;

  Mword has_snd_dst() const;

  Mword has_snd() const;

  Mword irq() const;

  L4_timeout timeout() const;

  static unsigned num_snd_reg_words();

  static unsigned num_rcv_reg_words();

  Mword has_abs_snd_timeout() const;

  Mword abs_snd_clock() const;

  Mword has_abs_rcv_timeout() const;

  Mword abs_rcv_clock() const;

  void snd_desc(Mword w);

  L4_snd_desc snd_desc() const;

  void copy_msg(Sys_ipc_frame *to) const;

  void rcv_desc(L4_rcv_desc d);

  L4_rcv_desc rcv_desc() const;

  Mword msg_word(unsigned index) const;

  L4_msgdope msg_dope() const;

  void msg_dope(L4_msgdope d);

  void msg_dope_set_error(Mword);

  void msg_dope_combine(Ipc_err e);

  static unsigned num_reg_words();
};

class Sys_id_nearest_frame : public Syscall_frame
{
public:
  L4_uid dst() const; 

  void type( Mword type );

  void nearest( L4_uid id );
};

class Sys_ex_regs_frame : public Syscall_frame
{
public:
  Mword sp() const;

  Mword ip() const;

  L4_uid pager()  const;

  void old_eflags( Mword oefl );

  void old_sp( Mword osp );

  void old_ip( Mword oip );

  void old_pager( L4_uid id );

  LThread_num lthread() const;

  Task_num task() const;

  Mword no_cancel() const;

  L4_uid preempter() const;

  void old_preempter(L4_uid id);

  Mword alien() const;
};

class Sys_thread_switch_frame : public Syscall_frame
{
public:
  L4_uid dst() const;

  Mword id() const;

  void left (Unsigned64 t);

  void ret (Mword val);
};

class Sys_unmap_frame : public Syscall_frame 
{
public:
  bool self_unmap() const;

  L4_fpage fpage() const;

  Mword map_mask() const;

  bool downgrade() const;
};

class Sys_task_new_frame : public Syscall_frame 
{
public:
  Mword mcp() const; 

  L4_uid new_chief() const;

  Mword sp() const;

  Mword ip() const;

  Mword has_pager() const;

  L4_uid pager() const; 

  L4_uid dst() const;

  void new_taskid( L4_uid id );

  Mword alien() const;
};

class Sys_thread_schedule_frame : public Syscall_frame
{
public:
  L4_sched_param param() const;

  Unsigned64 time() const;

  L4_uid preempter() const;

  L4_uid dst() const;

  void old_param(L4_sched_param op);

  void time(Unsigned64 t);

  void old_preempter(L4_uid id);

  void partner(L4_uid id);
};

class Sys_thread_privctrl_frame : public Syscall_frame
{
public:
  Mword  command()    const;
  L4_uid dst()        const;
  Mword  entry_func() const;
  void   ret_val(Mword v);
};

extern "C" void Entry_frame_Syscall_frame_cast_problem();
/*
 * Fiasco Kernel-Entry Frame-Layout Code
 * Shared between UX and native IA32.
 */


template< typename Cl > inline Cl *sys_frame_cast( Entry_frame *e );

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




inline Mword 
Return_frame::flags() const
{ return eflags; }



inline void
Return_frame::flags(Mword _flags)
{ eflags = _flags; }



inline Mword
Return_frame::cs() const
{ return csseg; }



inline void
Return_frame::cs(Mword _cs)
{ csseg = _cs; }



inline Mword
Return_frame::ss() const
{ return ssseg; }



inline void
Return_frame::ss(Mword _ss)
{ ssseg = _ss; }


//---------------------------------------------------------------------------
// basic Entry_frame methods for IA32
// 

inline Address
Return_frame::ip() const
{ return eip; }



inline void
Return_frame::ip(Mword _pc)
{ eip = _pc; }



inline Address
Return_frame::sp() const
{ return esp; }



inline void
Return_frame::sp(Mword _sp)
{ esp = _sp; }



inline Mword Sys_ipc_frame::msg_word(Utcb*, unsigned index) const
{
  return msg_word (index);
}


//---------------------------------------------------------------------------
// IPC frame methods for IA32 (x0 and v2)
// 

inline Mword Sys_ipc_frame::has_snd_dst() const
{
  return esi;
}

 

inline Mword Sys_ipc_frame::irq() const
{
  return esi -1;
}

 

inline void Sys_ipc_frame::snd_desc(Mword w)
{
  eax =w;
}

 

inline L4_snd_desc Sys_ipc_frame::snd_desc() const 
{
  return eax;
}



inline Mword Sys_ipc_frame::has_snd() const
{
  return snd_desc().has_snd();
}



inline L4_timeout Sys_ipc_frame::timeout() const
{
  return L4_timeout(ecx);
}



inline L4_rcv_desc Sys_ipc_frame::rcv_desc() const
{
  return ebp;
}



inline void Sys_ipc_frame::rcv_desc(L4_rcv_desc d)
{
  ebp = d.raw();
}



inline L4_msgdope Sys_ipc_frame::msg_dope() const
{
  return L4_msgdope(eax);
}



inline void Sys_ipc_frame::msg_dope_set_error(Mword e)
{
  reinterpret_cast<L4_msgdope&>(eax).error(e);
}



inline unsigned Sys_ipc_frame::num_snd_reg_words()
{
  return num_reg_words();
}



inline unsigned Sys_ipc_frame::num_rcv_reg_words()
{
  return num_reg_words();
}



inline void Sys_ipc_frame::msg_dope(L4_msgdope d)
{
  eax = d.raw();
}



inline void Sys_ipc_frame::msg_dope_combine(Ipc_err e)
{
  L4_msgdope m(eax);
  m.combine(e);
  eax = m.raw();
}



inline void Sys_ipc_frame::rcv_src(L4_uid id) 
{
  esi = id.raw();
  edi = (id.raw() >> 32);
}



inline L4_uid Sys_ipc_frame::rcv_src() const
{
  return L4_uid(((Unsigned64)edi << 32) | (Unsigned64)esi);
}



inline L4_uid Sys_ipc_frame::snd_dst() const
{
  return L4_uid( (Unsigned64)esi | ((Unsigned64)edi << 32) );
}



inline Mword Sys_ipc_frame::msg_word(unsigned index) const
{
  switch(index)
    {
    case 0:
      return edx;
    case 1:
      return ebx;
    default:
      return 0;
    }
}



inline void Sys_ipc_frame::set_msg_word(unsigned index, Mword value)
{
  switch(index)
    {
    case 0:
      edx = value;
      break;
    case 1:
      ebx = value;
      break;
    default:
      break;
    }
}



inline unsigned Sys_ipc_frame::num_reg_words()
{
  return 2;
}



inline void Sys_ipc_frame::copy_msg(Sys_ipc_frame *to) const
{ 
  // hint for gcc to prevent stall
  Unsigned32 tmp_edx = edx, tmp_ebx = ebx;
  to->edx = tmp_edx;
  to->ebx = tmp_ebx;
}



inline Mword Sys_ipc_frame::has_abs_snd_timeout() const
{
  return snd_dst().abs_snd_timeout();
}


inline Mword Sys_ipc_frame::abs_snd_clock() const
{
  return snd_dst().abs_snd_clock();
}



inline Mword Sys_ipc_frame::has_abs_rcv_timeout() const
{
  return snd_dst().abs_rcv_timeout();
}



inline Mword Sys_ipc_frame::abs_rcv_clock() const
{
  return snd_dst().abs_rcv_clock();
}


//---------------------------------------------------------------------------
// ID-nearest frame methods for IA32 (v2 and x0)
// 

inline void Sys_id_nearest_frame::type(Mword type)
{
  eax = type;
}


//Entry_id_nearest_data::-------------------------------------------------

inline L4_uid Sys_id_nearest_frame::dst() const
{
  return L4_uid( (Unsigned64)esi | ((Unsigned64)edi << 32) );
}



inline void Sys_id_nearest_frame::nearest(L4_uid id)
{
  esi = id.raw();
  edi = (id.raw() >> 32);
}


//---------------------------------------------------------------------------
// ex-regs frame methods for IA32 (v2 and x0)
// 

inline Task_num Sys_ex_regs_frame::lthread() const
{
  return eax & (1 << 7) - 1;
}



inline Task_num Sys_ex_regs_frame::task() const
{
  return (eax >> 7) & ((1 << 11) - 1);
}



inline Mword Sys_ex_regs_frame::alien() const
{
  return eax & (1 << 29);
}



inline Mword Sys_ex_regs_frame::no_cancel() const
{
  return eax & (1 << 30);
}



inline Mword Sys_ex_regs_frame::sp() const
{
  return ecx;
}



inline Mword Sys_ex_regs_frame::ip() const
{
  return edx;
}



inline void Sys_ex_regs_frame::old_eflags(Mword oefl)
{
  eax = oefl;
}



inline void Sys_ex_regs_frame::old_sp(Mword osp)
{
  ecx = osp;
}



inline void Sys_ex_regs_frame::old_ip(Mword oip)
{
  edx = oip;
}


//Sys_ex_regs_frame::----------------------------------------------------

inline L4_uid Sys_ex_regs_frame::preempter() const
{
  return L4_uid( (Unsigned64)ebx | ((Unsigned64)ebp << 32) );
}



inline L4_uid Sys_ex_regs_frame::pager() const
{
  return L4_uid( (Unsigned64)esi | ((Unsigned64)edi << 32) );
}



inline void Sys_ex_regs_frame::old_preempter(L4_uid id)
{
  ebx = id.raw(); ebp = id.raw() >> 32;
}



inline void Sys_ex_regs_frame::old_pager(L4_uid id)
{
  esi = id.raw();
  edi = id.raw() >> 32;
}


//---------------------------------------------------------------------------
// thread-switch frame for IA32 (v2 and x0)
//

inline Mword
Sys_thread_switch_frame::id() const
{
  return eax;
}



inline void
Sys_thread_switch_frame::left(Unsigned64 t)
{
  ecx = t;
  edx = t >> 32;
}



inline void
Sys_thread_switch_frame::ret(Mword val)
{
  eax = val;
}



//Sys_thread_switch_frame::-------------------------------------------------

inline L4_uid
Sys_thread_switch_frame::dst() const
{
  return L4_uid ((Unsigned64) esi);
}


//---------------------------------------------------------------------------
// Sys-unmap frame for IA32 (v2 and x0)
//

inline L4_fpage Sys_unmap_frame::fpage() const
{
  return L4_fpage(eax);
}



inline Mword Sys_unmap_frame::map_mask() const
{
  return ecx;
}



inline bool Sys_unmap_frame::downgrade() const
{
  return !(ecx & 2);
}



inline bool Sys_unmap_frame::self_unmap() const
{
  return ecx & 0x80000000;
}


//---------------------------------------------------------------------------
// Sys-task-new frame for IA32 (v2 and x0)
//

inline Mword Sys_task_new_frame::alien() const 
{
  return eax & (1 << 31);
}



inline Mword Sys_task_new_frame::mcp() const 
{
  return eax & ~(1 << 31);
}



inline Mword Sys_task_new_frame::sp() const
{
  return ecx;
}



inline Mword Sys_task_new_frame::ip() const
{
  return edx;
}

 

inline Mword Sys_task_new_frame::has_pager() const
{
  return ebx;
}


//Sys_task_new_frame::-------------------------------------------

inline L4_uid Sys_task_new_frame::new_chief() const
{
  return L4_uid( (Unsigned64)(eax & ~(1 << 31)));
}



inline L4_uid Sys_task_new_frame::pager() const
{
  return L4_uid( (Unsigned64)ebx | ((Unsigned64)ebp << 32) );
}



inline L4_uid Sys_task_new_frame::dst() const
{
  return L4_uid( (Unsigned64)esi | ((Unsigned64)edi << 32) );
}



inline void Sys_task_new_frame::new_taskid(L4_uid id)
{
  esi = id.raw();
  edi = id.raw() >> 32;
}


//---------------------------------------------------------------------------
// thread-schedule frame for IA32 (v2 and x0)
//

inline L4_sched_param
Sys_thread_schedule_frame::param() const
{
  return L4_sched_param (eax);
}



inline void
Sys_thread_schedule_frame::old_param(L4_sched_param op)
{
  eax = op.raw();
}



inline Unsigned64
Sys_thread_schedule_frame::time() const
{
  return (Unsigned64) edx << 32 | (Unsigned64) ecx;
}



inline void
Sys_thread_schedule_frame::time(Unsigned64 t)
{
  ecx = t;
  edx = t >> 32;
}


//Sys_thread_schedule_frame::----------------------------------------------

inline L4_uid
Sys_thread_schedule_frame::preempter() const 
{
  return L4_uid ((Unsigned64) ebx | (Unsigned64) ebp << 32);
}



inline L4_uid
Sys_thread_schedule_frame::dst() const
{
  return L4_uid ((Unsigned64) esi | (Unsigned64) edi << 32);
}



inline void
Sys_thread_schedule_frame::old_preempter(L4_uid id)
{
  ebx = id.raw();
  ebp = id.raw() >> 32;
}



inline void 
Sys_thread_schedule_frame::partner(L4_uid id)
{
  esi = id.raw();
  edi = id.raw() >> 32;
}



template< typename Cl > inline Cl *sys_frame_cast( Entry_frame *e ) 
{
  Cl *r = nonull_static_cast<Cl*>(nonull_static_cast<Syscall_frame*>(e));
  if(((void*)e) != ((void*)r))
    Entry_frame_Syscall_frame_cast_problem();
  return r;
}

#endif // entry_frame_h

---