kernel/fiasco/src/jdb/ia32/jdb-int3-ia32-ux.cpp

   1 IMPLEMENTATION[ia32,amd64,ux]:
   2
   3 #include "jdb_dbinfo.h"
   4 #include "jdb_lines.h"
   5 #include "jdb_symbol.h"
   6 #include "jdb_tbuf.h"
   7 #include "thread.h"
   8 #include "timer.h"
   9
  10 /**
  11  * Handle int3 extensions in the current thread's context. All functions
  12  * for which we don't need/want to switch to the debugging stack.
  13  * \return 0 if this function should be handled in the context of Jdb
  14  *         1 successfully handled
  15  */
  16 PRIVATE static
  17 int
  18 Jdb::handle_int3_threadctx_generic(Trap_state *ts)
  19 {
  20   Thread *t  = current_thread();
  21   Mem_space *s = t->mem_space();
  22
  23   //Obj_space *os = t->space()->obj_space();
  24   Address ip = ts->ip();
  25   Address_type user;
  26   Unsigned8 *str, todo;
  27   int len;
  28   char c;
  29
  30   Jdb_entry_frame *jef = reinterpret_cast<Jdb_entry_frame*>(ts);
  31   user = jef->from_user();
  32   todo = s->peek((Unsigned8*)ip, user);
  33
  34   switch (todo)
  35     {
  36     case 0xeb: // jmp == enter_kdebug()
  37       len = s->peek((Unsigned8*)(ip+1), user);
  38       str = (Unsigned8*)(ip + 2);
  39
  40       if ((len > 0) && s->peek(str, user) == '*')
  41         {
  42           int i;
  43
  44           // skip '*'
  45           len--; str++;
  46
  47           if ((len > 0) && s->peek(str, user) == '#')
  48             // special: enter_kdebug("*#...")
  49             return 0; // => Jdb
  50
  51           if (s->peek(str, user) == '+')
  52             {
  53               // special: enter_kdebug("*+...") => extended log msg
  54               // skip '+'
  55               len--; str++;
  56               Tb_entry_ke_reg *tb =
  57                 static_cast<Tb_entry_ke_reg*>(Jdb_tbuf::new_entry());
  58               tb->set(t, ip-1, ts);
  59               for (i=0; i<len; i++)
  60                 tb->set_buf(i, s->peek(str++, user));
  61               tb->term_buf(len);
  62             }
  63           else
  64             {
  65               // special: enter_kdebug("*...") => log entry
  66               // fill in entry
  67               Tb_entry_ke *tb =
  68                 static_cast<Tb_entry_ke*>(Jdb_tbuf::new_entry());
  69               tb->set(t, ip-1);
  70               for (i=0; i<len; i++)
  71                 tb->set_buf(i, s->peek(str++, user));
  72               tb->term_buf(len);
  73             }
  74           Jdb_tbuf::commit_entry();
  75           break;
  76         }
  77       return 0; // => Jdb
  78
  79     case 0x90: // nop == l4kd_display()
  80       if (          s->peek((Unsigned8*)(ip+1), user) != 0xeb /*jmp*/
  81           || (len = s->peek((Unsigned8*)(ip+2), user)) <= 0)
  82         return 0; // => Jdb
  83       str = (Unsigned8*)(ip + 3);
  84       for (; len; len--)
  85         putchar(s->peek(str++, user));
  86       break;
  87
  88     case 0x3c: // cmpb
  89         {
  90       todo = s->peek((Unsigned8*)(ip+1), user);
  91       Jdb_output_frame *regs = reinterpret_cast<Jdb_output_frame*>(ts);
  92       switch (todo)
  93         {
  94         case  0: // l4kd_outchar
  95           putchar(regs->value() & 0xff);
  96           break;
  97         case  1: // l4kd_outnstring
  98           str = regs->str();
  99           len = regs->len();
 100           for(; len > 0; len--)
 101             putchar(s->peek(str++, user));
 102           break;
 103         case  2: // l4kd_outstr
 104           str = regs->str();
 105           for (; (c=s->peek(str++, user)); )
 106             putchar(c);
 107           break;
 108         case  5: // l4kd_outhex32
 109           printf("%08lx", regs->value() & 0xffffffff);
 110           break;
 111         case  6: // l4kd_outhex20
 112           printf("%05lx", regs->value() & 0xfffff);
 113           break;
 114         case  7: // l4kd_outhex16
 115           printf("%04lx", regs->value() & 0xffff);
 116           break;
 117         case  8: // L4kd_outhex12
 118           printf("%03lx", regs->value() & 0xfff);
 119           break;
 120         case  9: // l4kd_outhex8
 121           printf("%02lx", regs->value() & 0xff);
 122           break;
 123         case 11: // l4kd_outdec
 124           printf("%ld", regs->value());
 125           break;
 126         case 13: // l4kd_inchar
 127           return 0; // => Jdb
 128         case 29:
 129           switch (jef->param())
 130             {
 131             case 0: // fiasco_tbuf_get_status()
 132                 {
 133                   Jdb_status_page_frame *regs =
 134                     reinterpret_cast<Jdb_status_page_frame*>(ts);
 135                   regs->set(Mem_layout::Tbuf_ustatus_page);
 136                 }
 137               break;
 138             case 1: // fiasco_tbuf_log()
 139                 {
 140                   // interrupts are disabled in handle_slow_trap()
 141                   Jdb_log_frame *regs = reinterpret_cast<Jdb_log_frame*>(ts);
 142                   Tb_entry_ke *tb =
 143                     static_cast<Tb_entry_ke*>(Jdb_tbuf::new_entry());
 144                   str = regs->str();
 145                   tb->set(t, ip-1);
 146                   for (len=0; (c = s->peek(str++, user)); len++)
 147                     tb->set_buf(len, c);
 148                   tb->term_buf(len);
 149                   regs->set_tb_entry(tb);
 150                   Jdb_tbuf::commit_entry();
 151                 }
 152               break;
 153             case 2: // fiasco_tbuf_clear()
 154               Jdb_tbuf::clear_tbuf();
 155               break;
 156             case 3: // fiasco_tbuf_dump()
 157               return 0; // => Jdb
 158             case 4: // fiasco_tbuf_log_3val()
 159                 {
 160                   // interrupts are disabled in handle_slow_trap()
 161                   Jdb_log_3val_frame *regs =
 162                     reinterpret_cast<Jdb_log_3val_frame*>(ts);
 163                   Tb_entry_ke_reg *tb =
 164                     static_cast<Tb_entry_ke_reg*>(Jdb_tbuf::new_entry());
 165                   str = regs->str();
 166                   tb->set(t, ip-1, regs->val1(), regs->val2(), regs->val3());
 167                   for (len=0; (c = s->peek(str++, user)); len++)
 168                     tb->set_buf(len, c);
 169                   tb->term_buf(len);
 170                   regs->set_tb_entry(tb);
 171                   Jdb_tbuf::commit_entry();
 172                 }
 173               break;
 174             case 5: // fiasco_tbuf_get_status_phys()
 175                 {
 176                   Jdb_status_page_frame *regs =
 177                     reinterpret_cast<Jdb_status_page_frame*>(ts);
 178                   regs->set(s->virt_to_phys(Mem_layout::Tbuf_ustatus_page));
 179                 }
 180               break;
 181             case 6: // fiasco_timer_disable
 182               Timer::disable();
 183               break;
 184             case 7: // fiasco_timer_enable
 185               Timer::enable();
 186               break;
 187             case 8: // fiasco_tbuf_log_binary()
 188               // interrupts are disabled in handle_slow_trap()
 189               Jdb_log_frame *regs = reinterpret_cast<Jdb_log_frame*>(ts);
 190               Tb_entry_ke_bin *tb =
 191                 static_cast<Tb_entry_ke_bin*>(Jdb_tbuf::new_entry());
 192               str = regs->str();
 193               tb->set(t, ip-1);
 194               for (len=0; len < Tb_entry_ke_bin::SIZE; len++)
 195                 tb->set_buf(len, s->peek(str++, user));
 196               regs->set_tb_entry(tb);
 197               Jdb_tbuf::commit_entry();
 198               break;
 199             }
 200           break;
 201         case 30:
 202 #if 0
 203           switch (ts->value2())
 204             {
 205             case 1: // fiasco_register_symbols
 206                 {
 207                   Jdb_symbols_frame *regs =
 208                     reinterpret_cast<Jdb_symbols_frame*>(ts);
 209                   Jdb_dbinfo::set(Jdb_symbol::lookup(Kobject::dcast<Task*>(os->lookup(regs->task()))),
 210                                   regs->addr(), regs->size());
 211                 }
 212               break;
 213             case 2: // fiasco_register_lines
 214                 {
 215                   Jdb_lines_frame *regs =
 216                     reinterpret_cast<Jdb_lines_frame*>(ts);
 217                   Jdb_dbinfo::set(Jdb_lines::lookup(regs->task()),
 218                                   regs->addr(), regs->size());
 219                 }
 220               break;
 221             }
 222 #endif
 223           break;
 224         default: // ko
 225           if (todo < ' ')
 226             return 0; // => Jdb
 227
 228           putchar(todo);
 229           break;
 230         }
 231       break;
 232         }
 233
 234     default:
 235       return 0; // => Jdb
 236     }
 237
 238   return 1;
 239 }