jdb.h

Go to the documentation of this file.

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

#ifndef jdb_h
#define jdb_h

#include "l4_types.h"
#include "pic.h"

#include "jdb_core.h"
#include "jdb_handler_queue.h"
#include "trap_state.h"

//
// INTERFACE definition follows 
//


class Trap_state;
class Thread;
class Console_buffer;
class Jdb_entry_frame;

class Space;
class Thread;

class Space;
// Inside Jdb the method Jdb::get_thread() should be used instead of
// Thread::current_thread(). The latter function cannot not handle the
// case when we came from the kernel stack context!


class Jdb

: public Jdb_core
{
public:
  static void init();

  static Pic::Status pic_status;
  static const char * const reg_names[];
  static char lbr_active;
  static volatile char test_msr;

  typedef enum
    {
      s_unknown, s_ipc, s_syscall, s_pagefault, s_fputrap,
      s_interrupt, s_timer_interrupt, s_slowtrap, s_user_invoke,
    } Guessed_thread_state;

  template < typename T > static T peek(T const *addr, Address_type user);

  static int (*bp_test_log_only)();
  static int (*bp_test_sstep)();
  static int (*bp_test_break)(char *errbuf, size_t bufsize);
  static int (*bp_test_other)(char *errbuf, size_t bufsize);

private:
  Jdb();                        // default constructors are undefined
  Jdb(const Jdb&);

  template < typename T > static T peek(T const *addr);

  struct Traps
    {
      char const *name;
      char error_code;
    };

  static Traps const traps[20];
  static char error_buffer[81];

  static Mword gdb_trap_ip;
  static Mword gdb_trap_pfa;
  static Mword gdb_trap_no;
  static Mword gdb_trap_err;
  static unsigned old_phys_pte;

  static char _connected;
  static char was_input_error;
  static char permanent_single_step;
  static char hide_statline;
  static char use_nested;
  static char jdb_trap_recover;
  static char code_ret, code_call, code_bra, code_int;

  static const char *toplevel_cmds;
  static const char *non_interactive_cmds;

  typedef enum
    {
      SS_NONE=0, SS_BRANCH, SS_RETURN
    } Step_state;

  static Step_state ss_state;
  static int ss_level;

  static const Unsigned8 *debug_ctrl_str;
  static int              debug_ctrl_len;

  static int jdb_irqs_disabled;

public:
  static char  esc_iret[];
  static char  esc_bt[];
  static char  esc_emph[];
  static char  esc_emph2[];
  static char  esc_mark[];
  static char  esc_line[];
  static char  esc_symbol[];
private:

public:
  enum 
    {
      NOFANCY=0, 
      FANCY=1
    };
private:

public:
  static void    printf_statline (const char *prompt, const char *help,
                                  const char *format, ...)
    __attribute__((format(printf, 3, 4)));

  static int     getchar(void);
  static int     was_last_cmd(void);
  static int     get_next_cmd(void);
  static void    set_next_cmd(char c);
  static void    flush_next_cmd(void);
  static bool    is_toplevel_cmd(char c);

  static Jdb_handler_queue jdb_enter;
  static Jdb_handler_queue jdb_leave;

private:
  static Thread  *current_active;
  static char    last_cmd;
  static char    next_cmd;
  static Trap_state::Handler nested_trap_handler FIASCO_FASTCALL;
  static Jdb_entry_frame *entry_frame;
private:

public:
  static Thread *get_thread();

public:  
  static inline bool connected();
  
  static inline int source_level_debugging();
  
  // Command aborted. If we are interpreting a debug command like
  // enter_kdebugger("*#...") this is an error
  static void abort_command();
  
  static int get_register(char *reg);
  
  static Address establish_phys_mapping(Address phys, Address *offs);
  
  static Task_num translate_task(Address addr, Task_num task);
  
  static int peek_phys(Address phys);
  
  static int poke_phys(Address phys, Unsigned8 value);
  
  static int peek_task(Address addr, Task_num task);
  
  static int poke_task(Address addr, Task_num task, Unsigned8 value);
  
  static int peek_mword_task(Address addr, Task_num task, Mword *result);
  
  static int peek_addr_task(Address virt, Task_num task, Address *result);
  
  static void poke_mword_task(Address virt, Task_num task, Mword value);
  
  static int is_adapter_memory(Address addr, Task_num task);
  
  // Try to guess the thread state of t by walking down the kernel stack and
  // locking at the first return address we find.
  static Jdb::Guessed_thread_state guess_thread_state(Thread *t);
  
  static void set_single_step(int on);
  
  static inline void enter_getchar();
  
  static inline void leave_getchar();
  
  static void cursor(unsigned int row=0, unsigned int col=0);
  
  static inline void blink_cursor(unsigned int row, unsigned int col);
  
  static inline void cursor_save();
  
  static inline void cursor_restore();
  
  static inline void screen_erase();
  
  static void screen_scroll(unsigned int start, unsigned int end);
  
  static inline void clear_to_eol();
  
  // preserve the history of the serial console if fancy != 0
  static void clear_screen(int fancy=FANCY);
  
  // handling of standard cursor keys (Up/Down/PgUp/PgDn)
  static int std_cursor_key(int c, Mword cols, Mword lines, Mword max_absy, Mword *absy, Mword *addy, Mword *addx, bool *redraw);
  
  static int execute_command(const char *s, int first_char = -1);
  
  static void write_ll_ns(Signed64 ns, char *buf, int maxlen, bool sign);
  
  static void write_tsc_s(Signed64 tsc, char *buf, int maxlen, bool sign);
  
  static void write_tsc(Signed64 tsc, char *buf, int maxlen, bool sign);
  
  static void write_ll_hex(Signed64 x, char *buf, int maxlen, bool sign);
  
  static void write_ll_dec(Signed64 x, char *buf, int maxlen, bool sign);
  
  static inline Thread* get_current_active();
  
  static inline Jdb_entry_frame* get_entry_frame();
  
  static int is_valid_task(Task_num task);
  
  static Space* lookup_space(Task_num task);
  
  static void get_current();
  
  static inline Space* get_current_space();
  
  static inline Task_num get_current_task();

private:  
  static inline void backspace();
  
  // disable interrupts before entering the kernel debugger
  static void save_disable_irqs();
  
  // restore interrupts after leaving the kernel debugger
  static void restore_irqs();
  
  // save pic state and mask all interupts
  static void open_debug_console();
  
  static void close_debug_console();
  
  static int switch_debug_state();
  
  // mail loop
  static int execute_command();
  
  // take a look at the code of the current thread eip
  // set global indicators code_call, code_ret, code_bra, code_int
  // This can fail if the current page is still not mapped
  static void analyze_code();
  
  // entered debugger because of single step trap
  static inline int handle_single_step();
  
  // entered debugger due to debug exception
  static inline int handle_trap1();
  
  // entered debugger due to software breakpoint
  static inline int handle_trap3();
  
  // entered debugger due to other exception
  static inline int handle_trapX();
  
  static inline int handle_int3();
  
  static inline void enable_lbr();
  
  static FIASCO_FASTCALL int enter_kdebugger(Trap_state *ts);
  
  // Interprete str as non interactive commands for Jdb. We allow mostly 
  // non-interactive commands here (e.g. we don't allow d, t, l, u commands)
  static int execute_command_ni(Unsigned8 const *str, int len=0);
  
  static int handle_int3_threadctx(Trap_state *ts);
  
  static int handle_int3_threadctx_generic(Trap_state *ts);
};

/*
 * JDB Module implementing ANSI/vt100 functions
 */


class Jdb_entry_frame : public Trap_state
{
public:  
  inline Address_type from_user();
  
  inline Address get_ksp();
  
  inline Address _get_esp();
  
  inline Mword param();
  
  inline Mword _get_ss();
};

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


#include <flux/x86/gdb.h>

#include <cstring>
#include <csetjmp>
#include <cstdarg>
#include <climits>
#include <cstdlib>
#include <cstdio>
#include "simpleio.h"

#include "boot_info.h"
#include "checksum.h"
#include "cmdline.h"
#include "config.h"
#include "cpu.h"
#include "initcalls.h"
#include "idt.h"
#include "jdb_core.h"
#include "jdb_tbuf_init.h"
#include "jdb_screen.h"
#include "kernel_console.h"
#include "keycodes.h"
#include "kernel_uart.h"
#include "kmem.h"
#include "logdefs.h"
#include "mem_layout.h"
#include "pic.h"
#include "push_console.h"
#include "processor.h"
#include "regdefs.h"
#include "static_init.h"
#include "terminate.h"
#include "thread.h" 
#include "thread_state.h"
#include "timer.h"
#include "trap_state.h"
#include "virq.h"
#include "vkey.h"
#include "watchdog.h"

#include <cstdio>
#include <simpleio.h>
#include "jdb_screen.h"

#include "config.h"
#include "div32.h"
#include "kernel_console.h"
#include "paging.h"

#include "jdb_prompt_ext.h"
#include "jdb.h"
#include "thread.h"

#include "space_index.h"

#include "jdb.h"
#include "thread.h"

#include "profile.h"
#include "thread.h"

#include "jdb_dbinfo.h"
#include "jdb_lines.h"
#include "jdb_symbol.h"
#include "jdb_tbuf.h"
#include "jdb_thread_names.h"
#include "thread.h"
#include "timer.h"

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



inline bool
Jdb::connected()
{
  return _connected;
}


inline int 
Jdb::source_level_debugging() 
{
  return use_nested; 
}



inline void
Jdb::enter_getchar()
{}



inline void
Jdb::leave_getchar()
{}



inline void
Jdb::blink_cursor(unsigned int row, unsigned int col)
{
  printf ("\033[%d;%df", row, col);
}



inline void
Jdb::cursor_save()
{
  putstr ("\0337");
}



inline void
Jdb::cursor_restore()
{
  putstr ("\0338");
}



inline void
Jdb::screen_erase()
{
  putstr ("\033[2J");
}   



inline void
Jdb::clear_to_eol()
{
  putstr("\033[K");
}



inline Thread*
Jdb::get_current_active()
{
  return current_active;
}



inline Jdb_entry_frame*
Jdb::get_entry_frame()
{
  return entry_frame;
}



inline Space*
Jdb::get_current_space()
{
  return current_active ? current_active->space() : 0;
}



inline Task_num
Jdb::get_current_task()
{
  return current_active ? current_active->id().task() : 0;
}



 template <typename T> inline T
Jdb::peek(T const *addr, Address_type)
{
  // on IA32 we can touch directly into the user-space
  return *(T*)addr;
}



inline int
Jdb::was_last_cmd()
{
  return last_cmd;
}



inline int
Jdb::get_next_cmd()
{
  return next_cmd;
}



inline void
Jdb::set_next_cmd(char c)
{
  next_cmd = c;
}



inline Address_type
Jdb_entry_frame::from_user()
{
  return cs & 3 ? ADDR_USER : ADDR_KERNEL;
}



inline Address
Jdb_entry_frame::get_ksp()
{
  return (Address)&esp;
}



inline Address
Jdb_entry_frame::_get_esp()
{
  return from_user() ? esp : get_ksp();
}



inline Mword
Jdb_entry_frame::param()
{
  return eax;
}



inline Mword
Jdb_entry_frame::_get_ss()
{
  return from_user() ? ss : Cpu::get_ss();
}

//
// IMPLEMENTATION of function templates
//




 template <typename T> T
Jdb::peek(T const *addr)
{
  return current_space()->peek(addr, entry_frame->from_user());
}

#endif // jdb_h

---