tb_entry.h

Go to the documentation of this file.

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

#ifndef tb_entry_h
#define tb_entry_h

#include "initcalls.h"

#include "l4_types.h"

//
// INTERFACE definition follows 
//


class Context;
class Space;
class Space;
class Sched_context;
class Sys_ipc_frame;
class Sys_ex_regs_frame;
class Sys_task_new_frame;
class Trap_state;

enum {
  Tbuf_unused             = 0,
  Tbuf_pf                 = 1,
  Tbuf_ipc                = 2,
  Tbuf_ipc_res            = 3,
  Tbuf_ipc_trace          = 4,
  Tbuf_ke                 = 5,
  Tbuf_ke_reg             = 6,
  Tbuf_unmap              = 7,
  Tbuf_shortcut_failed    = 8,
  Tbuf_shortcut_succeeded = 9,
  Tbuf_context_switch     = 10,
  Tbuf_exregs             = 11,
  Tbuf_breakpoint         = 12,
  Tbuf_trap               = 13,
  Tbuf_pf_res             = 14,
  Tbuf_sched              = 15,
  Tbuf_preemption         = 16,
  Tbuf_lipc               = 17,
  Tbuf_jean1              = 18,
  Tbuf_task_new           = 19,
  Tbuf_max                = 32,
  Tbuf_hidden             = 0x20,
};

class Tb_entry
{
protected:
  Mword         _number;        
  Address       _ip;            
  Context       *_ctx;          
  Unsigned64    _tsc;           
  Unsigned32    _pmc1;          
  Unsigned32    _pmc2;          
  Unsigned32    _kclock;        
  Unsigned8     _type;          
  static Mword (*rdcnt1)();
  static Mword (*rdcnt2)();
private:

public:
  enum
  {
    Tb_entry_size = 64,
  };

public:  
  static void set_rdcnt(int num, Mword (*f)());
  
  inline void clear();
  
  inline void hide();
  
  inline void unhide();
  
  inline Address ip() const;
  
  inline Context* ctx() const;
  
  inline Unsigned8 type() const;
  
  inline int hidden() const;
  
  inline Mword number() const;
  
  inline void number(Mword number);
  
  inline void rdpmc1();
  
  inline void rdpmc2();
  
  inline Unsigned32 kclock() const;
  
  inline Unsigned64 tsc() const;
  
  inline Unsigned32 pmc1() const;
  
  inline Unsigned32 pmc2() const;
  
  inline void rdtsc();

protected:  
  inline void set_global(char type, Context *ctx, Address ip);

private:  
  static Mword dummy_read_pmc();
} __attribute__((packed));

class Tb_entry_fit : public Tb_entry
{
private:
  char          _reserved[Tb_entry_size-sizeof(Tb_entry)];

public:  
  static FIASCO_INIT void init();
  
  static FIASCO_INIT void init_arch();
};

class Tb_entry_ipc : public Tb_entry
{
private:
  L4_snd_desc   _snd_desc;      
  L4_rcv_desc   _rcv_desc;      
  Mword         _dword[2];      
  Global_id     _dst;           
  L4_timeout    _timeout;       

public:  
  inline void set(Context *ctx, Mword ip, Sys_ipc_frame *ipc_regs, Unsigned64 left);
  
  inline void set_irq(Context *ctx, Mword ip, Mword irq);
  
  inline void set_sc(Context *ctx, Mword ip, Sys_ipc_frame *ipc_regs, Unsigned64 left);
  
  inline L4_snd_desc snd_desc() const;
  
  inline L4_rcv_desc rcv_desc() const;
  
  inline Global_id dst() const;
  
  inline L4_timeout timeout() const;
  
  inline Mword dword(unsigned index) const;
};

class Tb_entry_ipc_res : public Tb_entry
{
private:
  Unsigned8     _have_snd;      
  Unsigned8     _is_np;         
  Mword         _dword[2];      
  L4_msgdope    _result;        
  Global_id     _rcv_src;       
  L4_rcv_desc   _rcv_desc;      
  Mword         _pair_event;    

public:  
  inline void set(Context *ctx, Mword ip, Sys_ipc_frame *ipc_regs, Mword result, Mword pair_event, Unsigned8 have_snd, Unsigned8 is_np);
  
  inline int have_snd() const;
  
  inline int is_np() const;
  
  inline L4_rcv_desc rcv_desc() const;
  
  inline L4_msgdope result() const;
  
  inline Global_id rcv_src() const;
  
  inline Mword dword(unsigned index) const;
  
  inline Mword pair_event() const;
};

class Tb_entry_ipc_trace : public Tb_entry
{
private:
  Unsigned8     _snd_desc;
  Unsigned8     _rcv_desc;
  L4_msgdope    _result;        
  Unsigned64    _snd_tsc;       
  Global_id     _snd_dst;       
  Global_id     _rcv_dst;       

public:  
  inline void set(Context *ctx, Mword ip, Unsigned64 snd_tsc, Global_id snd_dst, Global_id rcv_dst, L4_msgdope result, Unsigned8 snd_desc, Unsigned8 rcv_desc);
};

class Tb_entry_ipc_sfl : public Tb_entry
{
private:
  L4_snd_desc   _snd_desc;      
  L4_rcv_desc   _rcv_desc;      
  L4_timeout    _timeout;       
  Global_id     _dst;           
  Unsigned8     _is_irq, _snd_lst, _dst_ok, _dst_lck, _preempt;

public:  
  inline void set(Context *ctx, Mword ip, L4_snd_desc snd_desc, L4_rcv_desc rcv_desc, L4_timeout timeout, Global_id dst, Unsigned8 is_irq, Unsigned8 snd_lst, Unsigned8 dst_ok, Unsigned8 dst_lck, Unsigned8 preempt);
  
  inline L4_timeout timeout() const;
  
  inline L4_snd_desc snd_desc() const;
  
  inline L4_rcv_desc rcv_desc() const;
  
  inline Global_id dst() const;
  
  inline Unsigned8 is_irq() const;
  
  inline Unsigned8 snd_lst() const;
  
  inline Unsigned8 dst_ok() const;
  
  inline Unsigned8 dst_lck() const;
  
  inline Unsigned8 preempt() const;
};

class Tb_entry_pf : public Tb_entry
{
private:
  Address       _pfa;           
  Mword         _error;         
  Space         *_space;

public:  
  inline void set(Context *ctx, Address ip, Address pfa, Mword error, Space *spc);
  
  inline Mword error() const;
  
  inline Address pfa() const;
  
  inline Space* space() const;
};

class Tb_entry_pf_res : public Tb_entry
{
private:
  Address       _pfa;
  Ipc_err       _err;
  Ipc_err       _ret;

public:  
  inline void set(Context *ctx, Address ip, Address pfa, Ipc_err err, Ipc_err ret);
  
  inline Address pfa() const;
  
  inline Ipc_err err() const;
  
  inline Ipc_err ret() const;
};

class Tb_entry_ke : public Tb_entry
{
private:
  char          _msg[31];       

public:  
  inline void set(Context *ctx, Address ip);
  
  inline void set_const(Context *ctx, Address ip, const char * const msg);
  
  inline void set_buf(unsigned i, char c);
  
  inline void term_buf(unsigned i);
  
  inline const char * msg() const;
};

class Tb_entry_unmap : public Tb_entry
{
private:
  L4_fpage      _fpage;         
  Mword         _mask;          
  bool          _result;        

public:  
  inline void set(Context *ctx, Address ip, L4_fpage fpage, Mword mask, bool result);
  
  inline L4_fpage fpage() const;
  
  inline Mword mask() const;
  
  inline bool result() const;
};

class Tb_entry_ex_regs : public Tb_entry
{
private:
  Mword         _lthread;       
  Mword         _task;          
  Address       _old_sp;        
  Address       _new_sp;        
  Address       _old_ip;        
  Address       _new_ip;        
  Mword         _failed;        

public:  
  inline void set(Context *ctx, Address ip, Sys_ex_regs_frame *regs, Address old_sp, Address old_ip, Mword failed);
  
  inline Mword lthread() const;
  
  inline Mword task() const;
  
  inline Address old_sp() const;
  
  inline Address new_sp() const;
  
  inline Address old_ip() const;
  
  inline Address new_ip() const;
  
  inline Mword failed() const;
};

class Tb_entry_task_new : public Tb_entry
{
private:
  Global_id     _task;
  Global_id     _pager;
  Address       _new_sp;
  Address       _new_ip;
  Mword         _mcp_or_chief;

public:  
  inline void set(Context *ctx, Address ip, Sys_task_new_frame *regs);
  
  inline Global_id task();
  
  inline Global_id pager();
  
  inline Address new_sp();
  
  inline Address new_ip();
  
  inline Mword mcp_or_chief();
};

class Tb_entry_bp : public Tb_entry
{
private:
  Address       _address;       
  int           _len;           
  Mword         _value;         
  int           _mode;          

public:  
  inline void set(Context *ctx, Address ip, int mode, int len, Mword value, Address address);
  
  inline int mode() const;
  
  inline int len() const;
  
  inline Mword value() const;
  
  inline Address addr() const;
};

class Tb_entry_ctx_sw : public Tb_entry
{
private:
  Context       *_dst;          
  Context       *_dst_orig;
  Address       _kernel_ip;
  Mword         _lock_cnt;
  Space *_from_space;
  Sched_context *_from_sched;
  Mword         _from_prio;

public:  
  inline void set(Context *ctx, Space *from_space, Address ip, Context *dst, Context *dst_orig, Mword lock_cnt, Sched_context *from_sched, Mword from_prio, Address kernel_ip);
  
  inline Space* from_space() const;
  
  inline Address kernel_ip() const;
  
  inline Mword lock_cnt() const;
  
  inline Context* dst() const;
  
  inline Context* dst_orig() const;
  
  inline Mword from_prio() const;
  
  inline Sched_context* from_sched() const;
};

class Tb_entry_sched : public Tb_entry
{
private:
  unsigned short _mode;
  Context        *_owner;
  unsigned short _id;
  unsigned short _prio;
  signed long    _left;
  unsigned long  _quantum;

public:  
  inline void set(Context *ctx, Address ip, unsigned short mode, Context *owner, unsigned short id, unsigned short prio, signed long left, unsigned long quantum);
  
  inline unsigned short mode() const;
  
  inline Context * owner() const;
  
  inline unsigned short id() const;
  
  inline unsigned short prio() const;
  
  inline unsigned long quantum() const;
  
  inline signed long left() const;
};

class Tb_entry_preemption : public Tb_entry
{
private:
  Context        *_preempter;

public:  
  inline void set(Context *ctx, Context *preempter, Address ip);
  
  inline Context* preempter() const;
};

class Tb_entry_lipc : public Tb_entry
{
private:
  short int     _type;
  Global_id     _old;
  Global_id     _new;
  Address       _c_utcb_ptr;

public:  
  inline void set(Context *tid, Address ip, unsigned short type, Global_id old_thread, Global_id new_thread, Address current_utcb_ptr);
  
  inline unsigned short type() const;
  
  inline Global_id old_thread() const;
  
  inline Global_id new_thread() const;
  
  inline Address c_utcb_ptr() const;
};

class Tb_entry_jean1 : public Tb_entry
{
private:
  Context       *_sched_owner1;
  Context       *_sched_owner2;

public:  
  inline void set(Context *tid, Address ip, Context *sched_owner1, Context *sched_owner2);
  
  inline Context* sched_owner1();
  
  inline Context* sched_owner2();
};

class Tb_entry_ke_reg : public Tb_entry
{
private:
  char          _msg[19];       
  Mword         _eax, _ecx, _edx; 

public:  
  inline void set(Context *ctx, Mword eip, Mword v1, Mword v2, Mword v3);
  
  inline void set(Context *ctx, Mword eip, Trap_state *ts);
  
  inline void set_const(Context *ctx, Mword eip, const char * const msg, Mword eax, Mword ecx, Mword edx);
  
  inline void set_buf(unsigned i, char c);
  
  inline void term_buf(unsigned i);
  
  inline const char * msg() const;
  
  inline Mword val1() const;
  
  inline Mword val2() const;
  
  inline Mword val3() const;
};

class Tb_entry_trap : public Tb_entry
{
private:
  char          _trapno;
  Unsigned16    _errno;
  Mword         _ebp, _edx, _cr2, _eax, _eflags, _esp;
  Unsigned16    _cs,  _ds;

public:  
  inline void set(Context *ctx, Mword eip, Trap_state *ts);
  
  inline void set(Context *ctx, Mword eip, Mword trapno);
  
  inline char trapno() const;
  
  inline Unsigned16 errno() const;
  
  inline Mword eax() const;
  
  inline Mword cr2() const;
  
  inline Mword edx() const;
  
  inline Mword ebp() const;
  
  inline Unsigned16 cs() const;
  
  inline Unsigned16 ds() const;
  
  inline Mword sp() const;
  
  inline Mword flags() const;
};

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


#include <cstring>

#include "entry_frame.h"
#include "kip.h"
#include "trap_state.h"

#include "cpu.h"

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




inline void
Tb_entry::clear()
{ _type = Tbuf_unused; }



inline void
Tb_entry::hide()
{ _type |= Tbuf_hidden; }



inline void
Tb_entry::unhide()
{ _type &= ~Tbuf_hidden; }



inline Address
Tb_entry::ip() const
{ return _ip; }



inline Context*
Tb_entry::ctx() const
{ return _ctx; }



inline Unsigned8
Tb_entry::type() const
{ return _type & (Tbuf_max-1); }



inline int
Tb_entry::hidden() const
{ return _type & Tbuf_hidden; }



inline Mword
Tb_entry::number() const
{ return _number; }



inline void
Tb_entry::number(Mword number)
{ _number = number; }



inline void
Tb_entry::rdpmc1()
{ _pmc1 = rdcnt1(); }



inline void
Tb_entry::rdpmc2()
{ _pmc2 = rdcnt2(); }



inline Unsigned32
Tb_entry::kclock() const
{ return _kclock; }



inline Unsigned64
Tb_entry::tsc() const
{ return _tsc; }



inline Unsigned32
Tb_entry::pmc1() const
{ return _pmc1; }



inline Unsigned32
Tb_entry::pmc2() const
{ return _pmc2; }



inline void
Tb_entry::rdtsc()
{ _tsc = Cpu::rdtsc(); }



inline void
Tb_entry::set_global(char type, Context *ctx, Address ip)
{
  _type   = type;
  _ctx    = ctx;
  _ip     = ip;
  _kclock = (Unsigned32)Kip::k()->clock;
}



inline void
Tb_entry_ipc::set(Context *ctx, Mword ip, Sys_ipc_frame *ipc_regs,
                  Unsigned64 left)
{
  set_global(Tbuf_ipc, ctx, ip);
  _snd_desc  = ipc_regs->snd_desc();
  _rcv_desc  = ipc_regs->rcv_desc();
  _dst       = ipc_regs->snd_dst();
  _timeout   = ipc_regs->timeout();
  if (_dst.next_period())
    {
      _dword[0]  = (Unsigned32)(left & 0xffffffff);
      _dword[1]  = (Unsigned32)(left >> 32);
    }
  else
    {
      // hint for gcc
      register Mword tmp0 = ipc_regs->msg_word(0);
      register Mword tmp1 = ipc_regs->msg_word(1);
      _dword[0]  = tmp0;
      _dword[1]  = tmp1;
    }
}



inline void
Tb_entry_ipc::set_irq(Context *ctx, Mword ip, Mword irq)
{
  set_global(Tbuf_ipc, ctx, ip);
  _snd_desc = L4_snd_desc(0);
  _rcv_desc = L4_rcv_desc(0);
  _dst      = Global_id::irq(irq);
}



inline void
Tb_entry_ipc::set_sc(Context *ctx, Mword ip, Sys_ipc_frame *ipc_regs,
                     Unsigned64 left)
{
  set_global(Tbuf_shortcut_succeeded, ctx, ip);
  _snd_desc  = ipc_regs->snd_desc();
  _rcv_desc  = ipc_regs->rcv_desc();
  _dst       = ipc_regs->snd_dst();
  _timeout   = ipc_regs->timeout();
  if (_dst.next_period())
    {
      _dword[0]  = (Unsigned32)(left & 0xffffffff);
      _dword[1]  = (Unsigned32)(left >> 32);
    }
  else
    {
      // hint for gcc
      register Mword tmp0 = ipc_regs->msg_word(0);
      register Mword tmp1 = ipc_regs->msg_word(1);
      _dword[0]  = tmp0;
      _dword[1]  = tmp1;
    }
}



inline L4_snd_desc
Tb_entry_ipc::snd_desc() const
{ return _snd_desc; }



inline L4_rcv_desc
Tb_entry_ipc::rcv_desc() const
{ return _rcv_desc; }



inline Global_id
Tb_entry_ipc::dst() const
{ return _dst; }



inline L4_timeout
Tb_entry_ipc::timeout() const
{ return _timeout; }



inline Mword
Tb_entry_ipc::dword(unsigned index) const
{ return _dword[index]; }



inline void
Tb_entry_ipc_res::set(Context *ctx, Mword ip, Sys_ipc_frame *ipc_regs,
                      Mword result, Mword pair_event, Unsigned8 have_snd,
                      Unsigned8 is_np)
{
  set_global(Tbuf_ipc_res, ctx, ip);
  // hint for gcc
  register Mword tmp0 = ipc_regs->msg_word(0);
  register Mword tmp1 = ipc_regs->msg_word(1);
  _dword[0]   = tmp0;
  _dword[1]   = tmp1;
  _pair_event = pair_event;
  _result     = result;
  _rcv_desc   = ipc_regs->rcv_desc();
  _rcv_src    = ipc_regs->rcv_src();
  _have_snd   = have_snd;
  _is_np      = is_np;
}



inline int
Tb_entry_ipc_res::have_snd() const
{ return _have_snd; }



inline int
Tb_entry_ipc_res::is_np() const
{ return _is_np; }



inline L4_rcv_desc
Tb_entry_ipc_res::rcv_desc() const
{ return _rcv_desc; }



inline L4_msgdope
Tb_entry_ipc_res::result() const
{ return _result; }



inline Global_id
Tb_entry_ipc_res::rcv_src() const
{ return _rcv_src; }



inline Mword
Tb_entry_ipc_res::dword(unsigned index) const
{ return _dword[index]; }



inline Mword
Tb_entry_ipc_res::pair_event() const
{ return _pair_event; }



inline void
Tb_entry_ipc_trace::set(Context *ctx, Mword ip, Unsigned64 snd_tsc,
                        Global_id snd_dst, Global_id rcv_dst,
                        L4_msgdope result, Unsigned8 snd_desc,
                        Unsigned8 rcv_desc)
{
  set_global(Tbuf_ipc_trace, ctx, ip);
  _snd_tsc  = snd_tsc;
  _snd_dst  = snd_dst;
  _rcv_dst  = rcv_dst;
  _result   = result;
  _snd_desc = snd_desc;
  _rcv_desc = rcv_desc;
}



inline void
Tb_entry_ipc_sfl::set(Context *ctx, Mword ip,
                      L4_snd_desc snd_desc, L4_rcv_desc rcv_desc,
                      L4_timeout timeout, Global_id dst,
                      Unsigned8 is_irq, Unsigned8 snd_lst,
                      Unsigned8 dst_ok, Unsigned8 dst_lck,
                      Unsigned8 preempt)
{
  set_global(Tbuf_shortcut_failed, ctx, ip);
  _snd_desc  = snd_desc;
  _rcv_desc  = rcv_desc;
  _timeout   = timeout;
  _dst       = dst;
  _is_irq    = is_irq;
  _snd_lst   = snd_lst;
  _dst_ok    = dst_ok;
  _dst_lck   = dst_lck;
  _preempt   = preempt;
}



inline L4_timeout
Tb_entry_ipc_sfl::timeout() const
{ return _timeout; }



inline L4_snd_desc
Tb_entry_ipc_sfl::snd_desc() const
{ return _snd_desc; }



inline L4_rcv_desc
Tb_entry_ipc_sfl::rcv_desc() const
{ return _rcv_desc; }



inline Global_id
Tb_entry_ipc_sfl::dst() const
{ return _dst; }



inline Unsigned8
Tb_entry_ipc_sfl::is_irq() const
{ return _is_irq; }



inline Unsigned8
Tb_entry_ipc_sfl::snd_lst() const
{ return _snd_lst; }



inline Unsigned8
Tb_entry_ipc_sfl::dst_ok() const
{ return _dst_ok; }



inline Unsigned8
Tb_entry_ipc_sfl::dst_lck() const
{ return _dst_lck; }



inline Unsigned8
Tb_entry_ipc_sfl::preempt() const
{ return _preempt; }



inline void
Tb_entry_pf::set(Context *ctx, Address ip, Address pfa,
                 Mword error, Space *spc)
{
  set_global(Tbuf_pf, ctx, ip);
  _pfa   = pfa;
  _error = error;
  _space = spc;
}



inline Mword
Tb_entry_pf::error() const
{ return _error; }



inline Address
Tb_entry_pf::pfa() const
{ return _pfa; }



inline Space*
Tb_entry_pf::space() const
{ return _space; }



inline void
Tb_entry_pf_res::set(Context *ctx, Address ip, Address pfa, 
                     Ipc_err err, Ipc_err ret)
{
  set_global(Tbuf_pf_res, ctx, ip);
  _pfa = pfa;
  _err = err;
  _ret = ret;
}



inline Address
Tb_entry_pf_res::pfa() const
{ return _pfa; }



inline Ipc_err
Tb_entry_pf_res::err() const
{ return _err; }



inline Ipc_err
Tb_entry_pf_res::ret() const
{ return _ret; }



inline void
Tb_entry_ke::set(Context *ctx, Address ip)
{ set_global(Tbuf_ke, ctx, ip); }



inline void
Tb_entry_ke::set_const(Context *ctx, Address ip, const char * const msg)
{
  set_global(Tbuf_ke, ctx, ip);
  _msg[0] = 0; _msg[1] = 1;
  *(char const ** const)(_msg + 3) = msg;
}



inline void
Tb_entry_ke::set_buf(unsigned i, char c)
{
  if (i < sizeof(_msg)-1)
    _msg[i] = c >= ' ' ? c : '.';
}



inline void
Tb_entry_ke::term_buf(unsigned i)
{ _msg[i < sizeof(_msg)-1 ? i : sizeof(_msg)-1] = '\0'; }



inline const char *
Tb_entry_ke::msg() const
{
  return _msg[0] == 0 && _msg[1] == 1
    ? *(char const ** const)(_msg + 3) : _msg;
}



inline void
Tb_entry_unmap::set(Context *ctx, Address ip, 
                    L4_fpage fpage, Mword mask, bool result)
{
  set_global(Tbuf_unmap, ctx, ip);
  _fpage  = fpage;
  _mask   = mask;
  _result = result;
}



inline L4_fpage
Tb_entry_unmap::fpage() const
{ return _fpage; }



inline Mword
Tb_entry_unmap::mask() const
{ return _mask; }



inline bool
Tb_entry_unmap::result() const
{ return _result; }



inline void
Tb_entry_ex_regs::set(Context *ctx, Address ip, Sys_ex_regs_frame *regs,
                      Address old_sp, Address old_ip, Mword failed)
{
  set_global(Tbuf_exregs, ctx, ip);
  _lthread = regs->lthread();
  _task    = regs->task();
  _old_sp  = old_sp; _new_sp = regs->sp();
  _old_ip  = old_ip; _new_ip = regs->ip();
  _failed  = failed;
}



inline Mword
Tb_entry_ex_regs::lthread() const
{ return _lthread; }



inline Mword
Tb_entry_ex_regs::task() const
{ return _task; }



inline Address
Tb_entry_ex_regs::old_sp() const
{ return _old_sp; }



inline Address
Tb_entry_ex_regs::new_sp() const
{ return _new_sp; }



inline Address
Tb_entry_ex_regs::old_ip() const
{ return _old_ip; }



inline Address
Tb_entry_ex_regs::new_ip() const
{ return _new_ip; }



inline Mword
Tb_entry_ex_regs::failed() const
{ return _failed; }



inline void
Tb_entry_task_new::set(Context *ctx, Address ip, Sys_task_new_frame *regs)
{
  set_global (Tbuf_task_new, ctx, ip);
  _task         = regs->dst();
  _pager        = regs->pager();
  _new_sp      = regs->sp();
  _new_ip      = regs->ip();
  _mcp_or_chief = regs->mcp();
}



inline Global_id
Tb_entry_task_new::task()
{ return _task; }



inline Global_id
Tb_entry_task_new::pager()
{ return _pager; }



inline Address
Tb_entry_task_new::new_sp()
{ return _new_sp; }



inline Address
Tb_entry_task_new::new_ip()
{ return _new_ip; }



inline Mword
Tb_entry_task_new::mcp_or_chief()
{ return _mcp_or_chief; }



inline void
Tb_entry_bp::set(Context *ctx, Address ip,
                 int mode, int len, Mword value, Address address)
{
  set_global(Tbuf_breakpoint, ctx, ip);
  _mode    = mode;
  _len     = len;
  _value   = value;
  _address = address;
}



inline int
Tb_entry_bp::mode() const
{ return _mode; }



inline int
Tb_entry_bp::len() const
{ return _len; }



inline Mword
Tb_entry_bp::value() const
{ return _value; }



inline Address
Tb_entry_bp::addr() const
{ return _address; }



inline void
Tb_entry_ctx_sw::set(Context *ctx, Space *from_space, Address ip,
                     Context *dst, Context *dst_orig, Mword lock_cnt,
                     Sched_context *from_sched, Mword from_prio,
                     Address kernel_ip)
{
  set_global(Tbuf_context_switch, ctx, ip);
  _kernel_ip = kernel_ip;
  _dst        = dst;
  _dst_orig   = dst_orig;
  _lock_cnt   = lock_cnt;
  _from_space = from_space;
  _from_sched = from_sched;
  _from_prio  = from_prio;
}



inline Space*
Tb_entry_ctx_sw::from_space() const
{ return _from_space; }



inline Address
Tb_entry_ctx_sw::kernel_ip() const
{ return _kernel_ip; }



inline Mword
Tb_entry_ctx_sw::lock_cnt() const
{ return _lock_cnt; }



inline Context*
Tb_entry_ctx_sw::dst() const
{ return _dst; }



inline Context*
Tb_entry_ctx_sw::dst_orig() const
{ return _dst_orig; }



inline Mword
Tb_entry_ctx_sw::from_prio() const
{ return _from_prio; }



inline Sched_context*
Tb_entry_ctx_sw::from_sched() const
{ return _from_sched; }



inline void
Tb_entry_sched::set(Context *ctx, Address ip, unsigned short mode,
                     Context *owner, unsigned short id, unsigned short prio,
                     signed long left, unsigned long quantum)
{
  set_global (Tbuf_sched, ctx, ip);
  _mode    = mode;
  _owner   = owner;
  _id      = id;
  _prio    = prio;
  _left    = left;
  _quantum = quantum;
}



inline unsigned short
Tb_entry_sched::mode() const
{ return _mode; }



inline Context *
Tb_entry_sched::owner() const
{ return _owner; }



inline unsigned short
Tb_entry_sched::id() const
{ return _id; }



inline unsigned short
Tb_entry_sched::prio() const
{ return _prio; }



inline unsigned long
Tb_entry_sched::quantum() const
{ return _quantum; }



inline signed long
Tb_entry_sched::left() const
{ return _left; }



inline void
Tb_entry_preemption::set(Context *ctx, Context *preempter, Address ip)
{
  set_global (Tbuf_preemption, ctx, ip);
  _preempter = preempter;
};



inline Context*
Tb_entry_preemption::preempter() const
{ return _preempter; }



inline void
Tb_entry_lipc::set(Context *tid, Address ip, unsigned short type,
                   Global_id old_thread, Global_id new_thread,
                   Address current_utcb_ptr)
{
  set_global(Tbuf_lipc, tid, ip);
  _type    = type;
  _new     = new_thread;
  _old     = old_thread;
  _c_utcb_ptr = current_utcb_ptr;
}



inline unsigned short
Tb_entry_lipc::type() const
{ return _type; }



inline Global_id
Tb_entry_lipc::old_thread() const
{ return _old; }



inline Global_id
Tb_entry_lipc::new_thread() const
{ return _new; }



inline Address
Tb_entry_lipc::c_utcb_ptr() const
{ return _c_utcb_ptr; }



inline void
Tb_entry_jean1::set(Context *tid, Address ip,
                     Context *sched_owner1, Context *sched_owner2)
{
  set_global(Tbuf_jean1, tid, ip);
  _sched_owner1 = sched_owner1;
  _sched_owner2 = sched_owner2;
}



inline Context*
Tb_entry_jean1::sched_owner1()
{ return _sched_owner1; }



inline Context*
Tb_entry_jean1::sched_owner2()
{ return _sched_owner2; }



inline void
Tb_entry_ke_reg::set(Context *ctx, Mword eip, Mword v1, Mword v2, Mword v3)
{
  set_global(Tbuf_ke_reg, ctx, eip);
  _eax = v1; _ecx = v2; _edx = v3;
}



inline void
Tb_entry_ke_reg::set(Context *ctx, Mword eip, Trap_state *ts)
{ set(ctx, eip, ts->eax, ts->ecx, ts->edx); }



inline void
Tb_entry_ke_reg::set_const(Context *ctx, Mword eip, const char * const msg,
                           Mword eax, Mword ecx, Mword edx)
{
  set(ctx, eip, eax, ecx, edx);
  _msg[0] = 0; _msg[1] = 1;
  *(char const ** const)(_msg + 3) = msg;
}



inline void
Tb_entry_ke_reg::set_buf(unsigned i, char c)
{
  if (i < sizeof(_msg)-1)
    _msg[i] = c >= ' ' ? c : '.';
}



inline void
Tb_entry_ke_reg::term_buf(unsigned i)
{ _msg[i < sizeof(_msg)-1 ? i : sizeof(_msg)-1] = '\0'; }



inline const char *
Tb_entry_ke_reg::msg() const
{ 
  return _msg[0] == 0 && _msg[1] == 1
    ? *(char const ** const)(_msg + 3) : _msg;
}



inline Mword
Tb_entry_ke_reg::val1() const
{ return _eax; }



inline Mword
Tb_entry_ke_reg::val2() const
{ return _ecx; }



inline Mword
Tb_entry_ke_reg::val3() const
{ return _edx; }



inline void
Tb_entry_trap::set(Context *ctx, Mword eip, Trap_state *ts)
{
  set_global(Tbuf_trap, ctx, eip);
  _trapno = ts->trapno;
  _errno  = ts->err;
  _edx    = ts->edx;
  _cr2    = ts->cr2;
  _eax    = ts->eax; 
  _cs     = (Unsigned16)ts->cs;
  _ds     = (Unsigned16)ts->ds;  
  _esp    = ts->esp;
  _eflags = ts->eflags;
}



inline void
Tb_entry_trap::set(Context *ctx, Mword eip, Mword trapno)
{
  set_global(Tbuf_trap, ctx, eip);
  _trapno = trapno | 0x80;
}



inline char
Tb_entry_trap::trapno() const
{ return _trapno; }



inline Unsigned16
Tb_entry_trap::errno() const
{ return _errno; }



inline Mword
Tb_entry_trap::eax() const
{ return _eax; }



inline Mword
Tb_entry_trap::cr2() const
{ return _cr2; }



inline Mword
Tb_entry_trap::edx() const
{ return _edx; }



inline Mword
Tb_entry_trap::ebp() const
{ return _ebp; }



inline Unsigned16
Tb_entry_trap::cs() const
{ return _cs; }



inline Unsigned16
Tb_entry_trap::ds() const
{ return _ds; }



inline Mword
Tb_entry_trap::sp() const
{ return _esp; }



inline Mword
Tb_entry_trap::flags() const
{ return _eflags; }

#endif // tb_entry_h

---