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, Jdb_entry_frame *)
  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   error_buffer.cpu(cpu).clear();
  60   error_buffer.cpu(cpu).printf("%s", (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 (ef->debug_ipi())
  75     return cpu != Cpu_number::boot_cpu();
  76
  77   if (!peek(str, task, tmp) || tmp != '*')
  78     return false;
  79   if (!peek(str+1, task, tmp) || tmp != '#')
  80     return false;
  81
  82   return execute_command_ni(task, str+2);
  83 }
  84
  85 IMPLEMENT inline
  86 bool
  87 Jdb::test_checksums()
  88 { return true; }
  89
  90 static
  91 bool
  92 Jdb::handle_special_cmds(int)
  93 { return 1; }
  94
  95 PUBLIC static
  96 FIASCO_INIT FIASCO_NOINLINE void
  97 Jdb::init()
  98 {
  99   static Jdb_handler enter(at_jdb_enter);
 100   static Jdb_handler leave(at_jdb_leave);
 101
 102   Jdb::jdb_enter.add(&enter);
 103   Jdb::jdb_leave.add(&leave);
 104
 105   Thread::nested_trap_handler = (Trap_state::Handler)enter_jdb;
 106   Kconsole::console()->register_console(push_cons());
 107 }
 108
 109
 110 PRIVATE static
 111 void *
 112 Jdb::access_mem_task(Address virt, Space * task)
 113 {
 114   // align
 115
 116   virt &= ~0x03;
 117
 118   Address phys;
 119
 120   if (!task)
 121     {
 122       if (Mem_layout::in_kernel(virt))
 123         {
 124           phys = Kmem::virt_to_phys((void *)virt);
 125           if (phys == (Address)-1)
 126             return 0;
 127
 128         }
 129       else
 130         phys = virt;
 131     }
 132   else
 133     {
 134       phys = Address(task->virt_to_phys(virt));
 135
 136       if(phys = (Address)-1)
 137         phys = task->virt_to_phys_s0((void *)virt);
 138
 139       if (phys == (Address)-1)
 140         return 0;
 141     }
 142
 143    return (Mword*)phys;
 144 }
 145
 146 PUBLIC static
 147 Space *
 148 Jdb::translate_task(Address addr, Space * task)
 149 {
 150   (void)addr;
 151 //  return (Kmem::is_kmem_page_fault(addr, 0)) ? 0 : task;
 152
 153   return task;
 154 }
 155
 156 PUBLIC static
 157 int
 158 Jdb::peek_task(Address virt, Space * task, void *value, int width)
 159 {
 160
 161   void const *mem = access_mem_task(virt, task);
 162   if (!mem)
 163     return -1;
 164
 165   switch (width)
 166     {
 167     case 1:
 168         {
 169           Mword dealign = (virt & 0x3) * 8;
 170           *(Mword*)value = (*(Mword*)mem & (0xff << dealign)) >> dealign;
 171           break;
 172         }
 173     case 2:
 174         {
 175           Mword dealign = ((virt & 0x2) >> 1) * 16;
 176           *(Mword*)value = (*(Mword*)mem & (0xffff << dealign)) >> dealign;
 177           break;
 178         }
 179     case 4:
 180       memcpy(value, mem, width);
 181     }
 182
 183   return 0;
 184 }
 185
 186 PUBLIC static
 187 int
 188 Jdb::is_adapter_memory(Address, Space *)
 189 {
 190   return 0;
 191 }
 192
 193 PUBLIC static
 194 int
 195 Jdb::poke_task(Address virt, Space * task, void const *val, int width)
 196 {
 197   (void)virt; (void)task; (void)val; (void)width;
 198   /*
 199   void *mem = access_mem_task(virt, task);
 200   if (!mem)
 201     return -1;
 202
 203   memcpy(mem, val, width);*/
 204   return 0;
 205 }
 206
 207
 208 PRIVATE static
 209 void
 210 Jdb::at_jdb_enter()
 211 {
 212 //  Mem_unit::clean_vdcache();
 213 }
 214
 215 PRIVATE static
 216 void
 217 Jdb::at_jdb_leave()
 218 {
 219 //  Mem_unit::flush_vcache();
 220 }
 221
 222 PUBLIC static inline
 223 void
 224 Jdb::enter_getchar()
 225 {}
 226
 227 PUBLIC static inline
 228 void
 229 Jdb::leave_getchar()
 230 {}
 231
 232 PUBLIC static
 233 void
 234 Jdb::write_tsc_s(String_buffer *, Signed64 /*tsc*/, bool /*sign*/)
 235 {}
 236
 237 PUBLIC static
 238 void
 239 Jdb::write_tsc(String_buffer *, Signed64 /*tsc*/, bool /*sign*/)
 240 {}
 241