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

   1 IMPLEMENTATION [sparc]:
   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 DEFINE_PER_CPU static Per_cpu<Proc::Status> jdb_irq_state;
  14
  15 // disable interrupts before entering the kernel debugger
  16 IMPLEMENT
  17 void
  18 Jdb::save_disable_irqs(Cpu_number 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(Cpu_number cpu)
  27 {
  28   Proc::sti_restore(jdb_irq_state.cpu(cpu));
  29 }
  30
  31 IMPLEMENT inline
  32 void
  33 Jdb::enter_trap_handler(Cpu_number)
  34 {}
  35
  36 IMPLEMENT inline
  37 void
  38 Jdb::leave_trap_handler(Cpu_number)
  39 {}
  40
  41 IMPLEMENT inline
  42 bool
  43 Jdb::handle_conditional_breakpoint(Cpu_number)
  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(Cpu_number cpu)
  57 {
  58   Jdb_entry_frame *ef = entry_frame.cpu(cpu);
  59   snprintf(error_buffer.cpu(cpu), sizeof(error_buffer.cpu(Cpu_number::first())), "%s",
  60            (char const *)ef->r[2]);
  61
  62   return true;
  63 }
  64
  65 IMPLEMENT inline
  66 bool
  67 Jdb::handle_user_request(Cpu_number 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->virt_to_phys(virt));
 132
 133       if(phys = (Address)-1)
 134         phys = task->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   (void)addr;
 148 //  return (Kmem::is_kmem_page_fault(addr, 0)) ? 0 : task;
 149
 150   return task;
 151 }
 152
 153 PUBLIC static
 154 int
 155 Jdb::peek_task(Address virt, Space * task, void *value, int width)
 156 {
 157
 158   void const *mem = access_mem_task(virt, task);
 159   if (!mem)
 160     return -1;
 161
 162   switch (width)
 163     {
 164     case 1:
 165         {
 166           Mword dealign = (virt & 0x3) * 8;
 167           *(Mword*)value = (*(Mword*)mem & (0xff << dealign)) >> dealign;
 168           break;
 169         }
 170     case 2:
 171         {
 172           Mword dealign = ((virt & 0x2) >> 1) * 16;
 173           *(Mword*)value = (*(Mword*)mem & (0xffff << dealign)) >> dealign;
 174           break;
 175         }
 176     case 4:
 177       memcpy(value, mem, width);
 178     }
 179
 180   return 0;
 181 }
 182
 183 PUBLIC static
 184 int
 185 Jdb::is_adapter_memory(Address, Space *)
 186 {
 187   return 0;
 188 }
 189
 190 PUBLIC static
 191 int
 192 Jdb::poke_task(Address virt, Space * task, void const *val, int width)
 193 {
 194   (void)virt; (void)task; (void)val; (void)width;
 195   /*
 196   void *mem = access_mem_task(virt, task);
 197   if (!mem)
 198     return -1;
 199
 200   memcpy(mem, val, width);*/
 201   return 0;
 202 }
 203
 204
 205 PRIVATE static
 206 void
 207 Jdb::at_jdb_enter()
 208 {
 209 //  Mem_unit::clean_vdcache();
 210 }
 211
 212 PRIVATE static
 213 void
 214 Jdb::at_jdb_leave()
 215 {
 216 //  Mem_unit::flush_vcache();
 217 }
 218
 219 PUBLIC static inline
 220 void
 221 Jdb::enter_getchar()
 222 {}
 223
 224 PUBLIC static inline
 225 void
 226 Jdb::leave_getchar()
 227 {}
 228
 229 PUBLIC static
 230 void
 231 Jdb::write_tsc_s(Signed64 /*tsc*/, char * /*buf*/, int /*maxlen*/, bool /*sign*/)
 232 {}
 233
 234 PUBLIC static
 235 void
 236 Jdb::write_tsc(Signed64 /*tsc*/, char * /*buf*/, int /*maxlen*/, bool /*sign*/)
 237 {}
 238
 239 PROTECTED static inline
 240 template< typename T >
 241 void
 242 Jdb::set_monitored_address(T *dest, T val)
 243 {
 244   *dest = val;
 245 }