jdb_bp.h

Go to the documentation of this file.

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

#ifndef jdb_bp_h
#define jdb_bp_h

#include "initcalls.h"
#include "l4_types.h"

//
// INTERFACE definition follows 
//


class Thread;

class Breakpoint
{
public:
  enum Mode { INSTRUCTION=0, WRITE=1, PORTIO=2, ACCESS=3 };
  enum Log  { BREAK=0, LOG=1 };

private:
  typedef struct 
    {
      int other;
      GThread_num thread; 
    } Bp_thread_res;

  typedef struct
    {
      int other;
      Task_num task;
    } Bp_task_res;

  typedef struct 
    {
      char reg;
      Address y, z;
    } Bp_reg_res;

  typedef struct 
    {
      unsigned char len;
      Address addr;
      Address y, z;
    } Bp_mem_res;

  typedef struct 
    {
      Bp_thread_res thread;
      Bp_task_res   task;
      Bp_reg_res    reg;
      Bp_mem_res    mem;
    } Restriction;

  Address      addr;
  Unsigned8    len;
  Address_type user;
  Mode         mode;
  Log          log;
  Restriction  restrict;
  static char const * const mode_names[4];

public:  
  Breakpoint();
  
  inline void kill();
  
  inline int unused();
  
  inline int break_at_instruction();
  
  inline int match_addr(Address virt, Mode m);
  
  inline void set_logmode(char m);
  
  inline int is_break();
  
  inline void restrict_task(int other, Task_num task);
  
  inline void restrict_thread(int other, GThread_num thread);
  
  inline void restrict_register(char reg, Mword y, Mword z);
  
  inline void restrict_memory(Mword addr, Mword len, Mword y, Mword z);
  
  inline void clear_restriction();
  
  void show();
  
  // return TRUE  if the breakpoint does NOT match
  // return FALSE if all restrictions do match
  int restricted(Thread *t);
  
  int test_break(Thread *t, char *errbuf, size_t bufsize);
  
  // Create log entry if breakpoint matches
  void test_log(Thread *t);
  
  inline void set(Address _addr, Mword _len, Mode _mode, Log _log);
};

class Jdb_bp 
{
public:
  static int            global_breakpoints();
  static void           init_arch();

private:
  static void           at_jdb_enter();
  static void           at_jdb_leave();
  static Breakpoint     bps[4];
private:

private:
  static int            Jdb_bp::test_sstep();
  static int            Jdb_bp::test_break(char *errbuf, size_t bufsize);
  static int            Jdb_bp::test_other(char *errbuf, size_t bufsize);
  static int            Jdb_bp::test_log_only();
  static Mword          dr7;

public:  
  static FIASCO_INIT void init();
  
  static int set_breakpoint(int num, Address addr, Mword len, Breakpoint::Mode mode, Breakpoint::Log log, Task_num task);
  
  static void clr_breakpoint(int num);
  
  static inline void logmode_breakpoint(int num, char mode);
  
  static int first_unused();
  
  // Return 1 if a breakpoint hits
  static int test_break(Mword dr6, char *errbuf, size_t bufsize);
  
  // Create log entry if breakpoint matches.
  // Return 1 if debugger should stop
  static void test_log(Mword &dr6);
  
  static Mword test_match(Address addr, Breakpoint::Mode mode);
  
  static inline void restrict_task(int num, int other, Task_num task);
  
  static inline void restrict_thread(int num, int other, GThread_num thread);
  
  static inline void restrict_register(int num, char reg, Mword y, Mword z);
  
  static inline void restrict_memory(int num, Mword addr, Mword len, Mword y, Mword z);
  
  static inline void clear_restriction(int num);
  
  static void list();
  
  static Mword get_dr(Mword i);

private:  
  static inline void clr_dr7(int num, Mword &dr7);
  
  static inline void set_dr7(int num, Mword len, Breakpoint::Mode mode, Mword &dr7);
  
  static int set_debug_address_register(int num, Mword addr, Mword len, Breakpoint::Mode mode, Task_num /* task */);
  
  static void clr_debug_address_register(int num);
};

#define write_debug_register(num, val) \
    asm volatile("movl %0, %%db" #num ";" : /* no output */ : "r" (val))

#define read_debug_register(num) \
    ({Mword val; asm volatile("movl %%db" #num ",%0;" : "=r"(val)); val;})

// external callable
int jdb_instruction_bp_at_addr(Address addr);

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


#include "kmem.h"

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




inline void
Breakpoint::restrict_task(int other, Task_num task)
{
  restrict.task.other = other;
  restrict.task.task  = task;
}



inline void
Breakpoint::set(Address _addr, Mword _len, Mode _mode, Log _log)
{
  addr = _addr;
  mode = _mode;
  user = Kmem::is_kmem_page_fault(_addr, 0) ? ADDR_KERNEL : ADDR_USER;
  log  = _log;
  len  = _len;
}

#endif // jdb_bp_h

---