kernel/fiasco/src/jdb/ppc32/jdb-ppc32.cpp

   1 IMPLEMENTATION [ppc32]:
   2
   3 #include "globals.h"
   4 #include "kmem_alloc.h"
   5 #include "space.h"
   6 #include "mem_layout.h"
   7 #include "mem_unit.h"
   8 #include "static_init.h"
   9
  10
  11 STATIC_INITIALIZE_P(Jdb, JDB_INIT_PRIO);
  12
  13 static Per_cpu<Proc::Status> DEFINE_PER_CPU jdb_irq_state;
  14
  15 // disable interrupts before entering the kernel debugger
  16 IMPLEMENT
  17 void
  18 Jdb::save_disable_irqs(unsigned cpu)
  19 {
  20   jdb_irq_state.cpu(cpu) = Proc::cli_save();
  21 }
  22
  23 // restore interrupts after leaving the kernel debugger
  24 IMPLEMENT
  25 void
  26 Jdb::restore_irqs(unsigned cpu)
  27 {
  28   Proc::sti_restore(jdb_irq_state.cpu(cpu));
  29 }
  30
  31 IMPLEMENT inline
  32 void
  33 Jdb::enter_trap_handler(unsigned /*cpu*/)
  34 {}
  35
  36 IMPLEMENT inline
  37 void
  38 Jdb::leave_trap_handler(unsigned /*cpu*/)
  39 {}
  40
  41 IMPLEMENT inline
  42 bool
  43 Jdb::handle_conditional_breakpoint(unsigned /*cpu*/)
  44 { return false; }
  45
  46 IMPLEMENT
  47 void
  48 Jdb::handle_nested_trap(Jdb_entry_frame *e)
  49 {
  50   printf("Trap in JDB: IP:%08lx SRR1=%08lx\n",
  51          e->ip(), e->srr1);
  52 }
  53
  54 IMPLEMENT
  55 bool
  56 Jdb::handle_debug_traps(unsigned cpu)
  57 {
  58   Jdb_entry_frame *ef = entry_frame.cpu(cpu);
  59   snprintf(error_buffer.cpu(cpu), sizeof(error_buffer.cpu(0)), "%s",
  60            (char const *)ef->r[2]);
  61
  62   return true;
  63 }
  64
  65 IMPLEMENT inline
  66 bool
  67 Jdb::handle_user_request(unsigned cpu)
  68 {
  69   Jdb_entry_frame *ef = Jdb::entry_frame.cpu(cpu);
  70   const char *str = (char const *)ef->r[2];
  71   Space * task = get_task(cpu);
  72   char tmp;
  73
  74   if (!peek(str, task, tmp) || tmp != '*')
  75     return false;
  76   if (!peek(str+1, task, tmp) || tmp != '#')
  77     return false;
  78
  79   return execute_command_ni(task, str+2);
  80 }
  81
  82 IMPLEMENT inline
  83 bool
  84 Jdb::test_checksums()
  85 { return true; }
  86
  87 static
  88 bool
  89 Jdb::handle_special_cmds(int)
  90 { return 1; }
  91
  92 PUBLIC static
  93 FIASCO_INIT FIASCO_NOINLINE void
  94 Jdb::init()
  95 {
  96   static Jdb_handler enter(at_jdb_enter);
  97   static Jdb_handler leave(at_jdb_leave);
  98
  99   Jdb::jdb_enter.add(&enter);
 100   Jdb::jdb_leave.add(&leave);
 101
 102   Thread::nested_trap_handler = (Trap_state::Handler)enter_jdb;
 103   Kconsole::console()->register_console(push_cons());
 104 }
 105
 106
 107 PRIVATE static
 108 void *
 109 Jdb::access_mem_task(Address virt, Space * task)
 110 {
 111   // align
 112
 113   virt &= ~0x03;
 114
 115   Address phys;
 116
 117   if (!task)
 118     {
 119       if (Mem_layout::in_kernel(virt))
 120         {
 121           phys = Kmem::virt_to_phys((void *)virt);
 122           if (phys == (Address)-1)
 123             return 0;
 124
 125         }
 126       else
 127         phys = virt;
 128     }
 129   else
 130     {
 131       phys = Address(task->mem_space()->virt_to_phys(virt));
 132
 133       if(phys = (Address)-1)
 134         phys = task->mem_space()->virt_to_phys_s0((void *)virt);
 135
 136       if (phys == (Address)-1)
 137         return 0;
 138     }
 139
 140    return (Mword*)phys;
 141 }
 142
 143 PUBLIC static
 144 Space *
 145 Jdb::translate_task(Address addr, Space * task)
 146 {
 147 //  return (Kmem::is_kmem_page_fault(addr, 0)) ? 0 : task;
 148
 149   return task;
 150 }
 151
 152 PUBLIC static
 153 int
 154 Jdb::peek_task(Address virt, Space * task, void *value, int width)
 155 {
 156
 157   void const *mem = access_mem_task(virt, task);
 158   if (!mem)
 159     return -1;
 160
 161   switch (width)
 162     {
 163     case 1:
 164         {
 165           Mword dealign = (virt & 0x3) * 8;
 166           *(Mword*)value = (*(Mword*)mem & (0xff << dealign)) >> dealign;
 167           break;
 168         }
 169     case 2:
 170         {
 171           Mword dealign = ((virt & 0x2) >> 1) * 16;
 172           *(Mword*)value = (*(Mword*)mem & (0xffff << dealign)) >> dealign;
 173           break;
 174         }
 175     case 4:
 176       memcpy(value, mem, width);
 177     }
 178
 179   return 0;
 180 }
 181
 182 PUBLIC static
 183 int
 184 Jdb::is_adapter_memory(Address, Space *)
 185 {
 186   return 0;
 187 }
 188
 189 PUBLIC static
 190 int
 191 Jdb::poke_task(Address virt, Space * task, void const *val, int width)
 192 {
 193   /*
 194   void *mem = access_mem_task(virt, task);
 195   if (!mem)
 196     return -1;
 197
 198   memcpy(mem, val, width);*/
 199   return 0;
 200 }
 201
 202
 203 PRIVATE static
 204 void
 205 Jdb::at_jdb_enter()
 206 {
 207 //  Mem_unit::clean_vdcache();
 208 }
 209
 210 PRIVATE static
 211 void
 212 Jdb::at_jdb_leave()
 213 {
 214 //  Mem_unit::flush_vcache();
 215 }
 216
 217 PUBLIC static inline
 218 void
 219 Jdb::enter_getchar()
 220 {}
 221
 222 PUBLIC static inline
 223 void
 224 Jdb::leave_getchar()
 225 {}
 226
 227 PUBLIC static
 228 void
 229 Jdb::write_tsc_s(Signed64 /*tsc*/, char * /*buf*/, int /*maxlen*/, bool /*sign*/)
 230 {}
 231
 232 PUBLIC static
 233 void
 234 Jdb::write_tsc(Signed64 /*tsc*/, char * /*buf*/, int /*maxlen*/, bool /*sign*/)
 235 {}
 236
 237 PROTECTED static inline
 238 template< typename T >
 239 void
 240 Jdb::set_monitored_address(T *dest, T val)
 241 {
 242   *dest = val;
 243 }