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 = Jdb_tbuf::new_entry<Tb_entry_ke_reg>();
  57               tb->set(t, ip-1);
  58               tb->v[0] = ts->value();
  59               tb->v[1] = ts->value2();
  60               tb->v[2] = ts->value3();
  61               for (i=0; i<len; i++)
  62                 tb->msg.set_buf(i, s->peek(str++, user));
  63               tb->msg.term_buf(len);
  64             }
  65           else
  66             {
  67               // special: enter_kdebug("*...") => log entry
  68               // fill in entry
  69               Tb_entry_ke *tb = Jdb_tbuf::new_entry<Tb_entry_ke>();
  70               tb->set(t, ip-1);
  71               for (i=0; i<len; i++)
  72                 tb->msg.set_buf(i, s->peek(str++, user));
  73               tb->msg.term_buf(len);
  74             }
  75           Jdb_tbuf::commit_entry();
  76           break;
  77         }
  78       return 0; // => Jdb
  79
  80     case 0x90: // nop == l4kd_display()
  81       if (          s->peek((Unsigned8*)(ip+1), user) != 0xeb /*jmp*/
  82           || (len = s->peek((Unsigned8*)(ip+2), user)) <= 0)
  83         return 0; // => Jdb
  84       str = (Unsigned8*)(ip + 3);
  85       for (; len; len--)
  86         putchar(s->peek(str++, user));
  87       break;
  88
  89     case 0x3c: // cmpb
  90         {
  91       todo = s->peek((Unsigned8*)(ip+1), user);
  92       Jdb_output_frame *regs = reinterpret_cast<Jdb_output_frame*>(ts);
  93       switch (todo)
  94         {
  95         case  0: // l4kd_outchar
  96           putchar(regs->value() & 0xff);
  97           break;
  98         case  1: // l4kd_outnstring
  99           str = regs->str();
 100           len = regs->len();
 101           for(; len > 0; len--)
 102             putchar(s->peek(str++, user));
 103           break;
 104         case  2: // l4kd_outstr
 105           str = regs->str();
 106           for (; (c=s->peek(str++, user)); )
 107             putchar(c);
 108           break;
 109         case  5: // l4kd_outhex32
 110           printf("%08lx", regs->value() & 0xffffffff);
 111           break;
 112         case  6: // l4kd_outhex20
 113           printf("%05lx", regs->value() & 0xfffff);
 114           break;
 115         case  7: // l4kd_outhex16
 116           printf("%04lx", regs->value() & 0xffff);
 117           break;
 118         case  8: // L4kd_outhex12
 119           printf("%03lx", regs->value() & 0xfff);
 120           break;
 121         case  9: // l4kd_outhex8
 122           printf("%02lx", regs->value() & 0xff);
 123           break;
 124         case 11: // l4kd_outdec
 125           printf("%lu", regs->value());
 126           break;
 127         case 13: // l4kd_inchar
 128           return 0; // => Jdb
 129         case 29:
 130           switch (jef->param())
 131             {
 132             case 0: // fiasco_tbuf_get_status()
 133                 {
 134                   Jdb_status_page_frame *regs =
 135                     reinterpret_cast<Jdb_status_page_frame*>(ts);
 136                   regs->set(Mem_layout::Tbuf_ustatus_page);
 137                 }
 138               break;
 139             case 1: // fiasco_tbuf_log()
 140                 {
 141                   // interrupts are disabled in handle_slow_trap()
 142                   Jdb_log_frame *regs = reinterpret_cast<Jdb_log_frame*>(ts);
 143                   Tb_entry_ke *tb =
 144                     static_cast<Tb_entry_ke*>(Jdb_tbuf::new_entry());
 145                   str = regs->str();
 146                   tb->set(t, ip-1);
 147                   for (len=0; (c = s->peek(str++, user)); len++)
 148                     tb->msg.set_buf(len, c);
 149                   tb->msg.term_buf(len);
 150                   regs->set_tb_entry(tb);
 151                   Jdb_tbuf::commit_entry();
 152                 }
 153               break;
 154             case 2: // fiasco_tbuf_clear()
 155               Jdb_tbuf::clear_tbuf();
 156               break;
 157             case 3: // fiasco_tbuf_dump()
 158               return 0; // => Jdb
 159             case 4: // fiasco_tbuf_log_3val()
 160                 {
 161                   // interrupts are disabled in handle_slow_trap()
 162                   Jdb_log_3val_frame *regs =
 163                     reinterpret_cast<Jdb_log_3val_frame*>(ts);
 164                   Tb_entry_ke_reg *tb = Jdb_tbuf::new_entry<Tb_entry_ke_reg>();
 165                   str = regs->str();
 166                   tb->set(t, ip-1);
 167                   tb->v[0] = regs->val1();
 168                   tb->v[1] = regs->val2();
 169                   tb->v[2] = regs->val3();
 170                   for (len=0; (c = s->peek(str++, user)); len++)
 171                     tb->msg.set_buf(len, c);
 172                   tb->msg.term_buf(len);
 173                   regs->set_tb_entry(tb);
 174                   Jdb_tbuf::commit_entry();
 175                 }
 176               break;
 177             case 5: // fiasco_tbuf_get_status_phys()
 178                 {
 179                   Jdb_status_page_frame *regs =
 180                     reinterpret_cast<Jdb_status_page_frame*>(ts);
 181                   regs->set(s->virt_to_phys(Mem_layout::Tbuf_ustatus_page));
 182                 }
 183               break;
 184             case 6: // fiasco_timer_disable
 185               // XXX: no longer do Timer_tick::disable(0);
 186               break;
 187             case 7: // fiasco_timer_enable
 188               // XXX: no longer do Timer_tick::enable(0);
 189               break;
 190             case 8: // fiasco_tbuf_log_binary()
 191               // interrupts are disabled in handle_slow_trap()
 192               Jdb_log_frame *regs = reinterpret_cast<Jdb_log_frame*>(ts);
 193               Tb_entry_ke_bin *tb =
 194                 static_cast<Tb_entry_ke_bin*>(Jdb_tbuf::new_entry());
 195               str = regs->str();
 196               tb->set(t, ip-1);
 197               for (len=0; len < Tb_entry_ke_bin::SIZE; len++)
 198                 tb->set_buf(len, s->peek(str++, user));
 199               regs->set_tb_entry(tb);
 200               Jdb_tbuf::commit_entry();
 201               break;
 202             }
 203           break;
 204         case 30:
 205 #if 0
 206           switch (ts->value2())
 207             {
 208             case 1: // fiasco_register_symbols
 209                 {
 210                   Jdb_symbols_frame *regs =
 211                     reinterpret_cast<Jdb_symbols_frame*>(ts);
 212                   Jdb_dbinfo::set(Jdb_symbol::lookup(cxx::dyn_cast<Task*>(os->lookup(regs->task()))),
 213                                   regs->addr(), regs->size());
 214                 }
 215               break;
 216             case 2: // fiasco_register_lines
 217                 {
 218                   Jdb_lines_frame *regs =
 219                     reinterpret_cast<Jdb_lines_frame*>(ts);
 220                   Jdb_dbinfo::set(Jdb_lines::lookup(regs->task()),
 221                                   regs->addr(), regs->size());
 222                 }
 223               break;
 224             }
 225 #endif
 226           break;
 227         default: // ko
 228           if (todo < ' ')
 229             return 0; // => Jdb
 230
 231           putchar(todo);
 232           break;
 233         }
 234       break;
 235         }
 236
 237     default:
 238       return 0; // => Jdb
 239     }
 240
 241   return 1;
 242 }