EXTENSION class Jdb
{
public:
- static const char * const reg_names[];
-
typedef enum
{
s_unknown, s_ipc, s_syscall, s_pagefault, s_fputrap,
IMPLEMENTATION [ux]:
#include <cstdio>
+#include <cstdlib>
#include <sys/ioctl.h>
#include <termios.h>
#include <unistd.h>
unsigned short Jdb::rows, Jdb::cols;
-const char * const Jdb::reg_names[] =
-{ "EAX", "EBX", "ECX", "EDX", "EBP", "ESI", "EDI", "EIP", "ESP", "EFL" };
-
static Proc::Status jdb_irq_state;
IMPLEMENT inline
void
-Jdb::enter_trap_handler(unsigned /*cpu*/)
+Jdb::enter_trap_handler(Cpu_number)
{
conf_screen();
IMPLEMENT inline
void
-Jdb::leave_trap_handler(unsigned)
+Jdb::leave_trap_handler(Cpu_number)
{
// Restore terminal mode
leave_getchar();
// Flush all output streams
fflush (NULL);
- if (!::running)
- signal (SIGIO, SIG_IGN); // Ignore hardware interrupts
}
PROTECTED static inline
void
-Jdb::monitor_address(unsigned, void *)
+Jdb::monitor_address(Cpu_number, void *)
{}
IMPLEMENT inline
bool
-Jdb::handle_user_request(unsigned /*cpu*/)
+Jdb::handle_user_request(Cpu_number)
{ return false; }
IMPLEMENT inline
// disable interrupts before entering the kernel debugger
IMPLEMENT
void
-Jdb::save_disable_irqs(unsigned cpu)
+Jdb::save_disable_irqs(Cpu_number cpu)
{
- assert(cpu == 0);
+ assert(cpu == Cpu_number::boot_cpu());
jdb_irq_state = Proc::cli_save();
}
// restore interrupts after leaving the kernel debugger
IMPLEMENT
void
-Jdb::restore_irqs(unsigned cpu)
+Jdb::restore_irqs(Cpu_number cpu)
{
- assert(cpu == 0);
+ assert(cpu == Cpu_number::boot_cpu());
Proc::sti_restore(jdb_irq_state);
}
Trap_state::base_handler = (Trap_state::Handler)enter_jdb;
// be sure that Push_console comes very first
- static Push_console c;
- Kconsole::console()->register_console(&c, 0);
+ Kconsole::console()->register_console(push_cons()),
register_libc_atexit(leave_getchar);
+ atexit(leave_getchar);
Thread::set_int3_handler(handle_int3_threadctx);
}
int
Jdb::int3_extension()
{
- Jdb_entry_frame *entry_frame = Jdb::entry_frame.cpu(0);
+ Jdb_entry_frame *entry_frame = Jdb::entry_frame.cpu(Cpu_number::boot_cpu());
Address addr = entry_frame->ip();
Address_type user = (entry_frame->cs() & 3) ? ADDR_USER : ADDR_KERNEL;
Unsigned8 todo = peek ((Unsigned8 *) addr, user);
}
else if (todo != 0xeb)
{
- snprintf (error_buffer.cpu(0), sizeof (error_buffer.cpu(0)), "INT 3");
+ snprintf (error_buffer.cpu(Cpu_number::boot_cpu()), sizeof (error_buffer.cpu(Cpu_number::boot_cpu())), "INT 3");
return 0;
}
return 1; // => leave Jdb
}
- len = len < sizeof(error_buffer.cpu(0))-1 ? len : sizeof(error_buffer.cpu(0))-1;
+ len = len < sizeof(error_buffer.cpu(Cpu_number::boot_cpu()))-1 ? len : sizeof(error_buffer.cpu(Cpu_number::boot_cpu()))-1;
for (i = 0; i < len; i++)
- error_buffer.cpu(0)[i] = peek ((Unsigned8 *) ++addr, user);
- error_buffer.cpu(0)[i] = 0;
+ error_buffer.cpu(Cpu_number::boot_cpu())[i] = peek ((Unsigned8 *) ++addr, user);
+ error_buffer.cpu(Cpu_number::boot_cpu())[i] = 0;
return 0;
}
IMPLEMENT
bool
-Jdb::handle_debug_traps(unsigned cpu)
+Jdb::handle_debug_traps(Cpu_number cpu)
{
switch (entry_frame.cpu(cpu)->_trapno)
{
IMPLEMENT inline
bool
-Jdb::handle_conditional_breakpoint(unsigned /*cpu*/)
+Jdb::handle_conditional_breakpoint(Cpu_number)
{ return false; }
-PUBLIC
-static int
-Jdb::get_register(char *reg)
-{
- char reg_name[4];
- int i;
-
- putchar(reg_name[0] = 'E');
-
- for (i=1; i<3; i++)
- {
- int c = getchar();
- if (c == KEY_ESC)
- return false;
- putchar(reg_name[i] = c & 0xdf);
- }
-
- reg_name[3] = '\0';
-
- for (i=0; i<9; i++)
- if (*((unsigned*)reg_name) == *((unsigned*)reg_names[i]))
- break;
-
- if (i==9)
- return false;
-
- *reg = i+1;
- return true;
-}
-
-
PUBLIC
static Space *
Jdb::translate_task(Address /*addr*/, Space *task)
Jdb::virt_to_kvirt(Address virt, Mem_space* space)
{
Mem_space::Phys_addr phys;
- Mem_space::Size size;
+ Mem_space::Page_order size;
if (!space)
{
virt < (Kernel_thread::init_done()
? (Address)&Mem_layout::end
: (Address)&Mem_layout::initcall_end)
- || Kernel_task::kernel_task()->mem_space()->v_lookup (
- Mem_space::Addr::create(virt), 0, 0, 0))
+ || (Kernel_task::kernel_task()->virt_to_phys(virt) != ~0UL))
? virt
: (Address) -1;
}
// We can't directly access it because it's in a different host process
// but if the task's pagetable has a mapping for it, we can translate
// task-virtual -> physical -> kernel-virtual address and then access.
- return (space->v_lookup (Mem_space::Addr::create(virt), &phys, &size, 0))
- ? (Address) Kmem::phys_to_virt (phys.value() + (virt & (size.value()-1)))
+ Virt_addr va(virt);
+ return (space->v_lookup(va, &phys, &size, 0))
+ ? (Address) Kmem::phys_to_virt(Mem_space::Phys_addr::val(phys) + Virt_size::val(cxx::get_lsb(va, size)))
: (Address) -1;
}
}
T
Jdb::peek (T const *addr, Address_type user)
{
- return current_mem_space()->peek(addr, user);
+ // FIXME: assume UP here (current_meme_space(0))
+ return Mem_space::current_mem_space(Cpu_number::boot_cpu())->peek(addr, user);
}
PUBLIC static
if (virt & (width-1))
return -1;
- Address kvirt = virt_to_kvirt(virt, space?space->mem_space():0);
+ Address kvirt = virt_to_kvirt(virt, space);
if (kvirt == (Address)-1)
return -1;
if (virt & (width-1))
return -1;
- Address kvirt = virt_to_kvirt(virt, space?space->mem_space():0);
+ Address kvirt = virt_to_kvirt(virt, space);
if (kvirt == (Address)-1)
return -1;
{
Guessed_thread_state state = s_unknown;
Mword *ktop = (Mword*)((Mword)context_of(t->get_kernel_sp()) +
- Config::thread_block_size);
+ Context::Size);
for (int i=-1; i>-26; i--)
{
tcsetattr (fileno (stdin), TCSAFLUSH, &raw);
}
+PROTECTED static inline
+template< typename T >
+void
+Jdb::set_monitored_address(T *dest, T val)
+{ *dest = val; }
+
+PROTECTED static inline
+template< typename T >
+T Jdb::monitor_address(Cpu_number, T volatile *addr)
+{
+ return *addr;
+}
+
//----------------------------------------------------------------------------
IMPLEMENTATION [ux && mp]:
static
void
-Jdb::send_nmi(unsigned /*cpu*/)
+Jdb::send_nmi(Cpu_number)
{
}
projects / l4.git / blobdiff