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

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