kernel/traps.c

   1 #include <stdio.h>
   2 #include <asm/system.h>
   3 #include <asm/io.h>
   4 #include <thunix.h>
   5 #include <malloc.h>
   6
   7 #include <syscall.h>
   8
   9 unsigned long long *idt = (unsigned long long  *)0x80000;
  10
  11 #define get_seg_byte(seg,addr) ({                                       \
  12                         register char __res;                            \
  13                         __asm__("push %%fs;mov %%ax,%%fs;movb %%fs:%2,%%al;pop %%fs" \
  14                                 :"=a" (__res):"0" (seg),"m" (*(addr))); \
  15                         __res;})
  16
  17 #define get_seg_long(seg,addr) ({                                       \
  18                         register unsigned long __res;                   \
  19                         __asm__("push %%fs;mov %%ax,%%fs;movl %%fs:%2,%%eax;pop %%fs" \
  20                                 :"=a" (__res):"0" (seg),"m" (*(addr))); \
  21                         __res;})
  22
  23 #define _fs() ({                                                \
  24                         register unsigned short __res;          \
  25                         __asm__("mov %%fs,%%ax":"=a" (__res):); \
  26                         __res;})
  27
  28 #define _ds() ({                                                \
  29                         register unsigned short __res;          \
  30                         __asm__("mov %%ds,%%ax":"=a" (__res):); \
  31                         __res;})
  32
  33 #define _es() ({                                                \
  34                         register unsigned short __res;          \
  35                         __asm__("mov %%es,%%ax":"=a" (__res):); \
  36                         __res;})
  37
  38
  39 /*int do_exit(long code);   *** Not finished *** */
  40
  41 void ipc_install(void);
  42
  43 void page_exception(void);
  44 void divide_error(void);
  45 void debug(void);
  46 void nmi(void);
  47 void int3(void);
  48 void overflow(void);
  49 void bounds(void);
  50 void invalid_op(void);
  51 void device_not_available(void);
  52 void double_fault(void);
  53 void coprocessor_segment_overrun(void);
  54 void invalid_TSS(void);
  55 void segment_not_present(void);
  56 void stack_segment(void);
  57 void general_protection(void);
  58 void page_fault(void);
  59 void coprocessor_error(void);
  60 void reserved(void);
  61
  62 static void die(char * str,long esp_ptr,long nr)
  63 {
  64         long * esp = (long *) esp_ptr;
  65         int i;
  66         //unsigned long eip = esp[0];
  67
  68         printk("\n");
  69
  70         printk("%s: %04x\n\r",str,nr&0xffff);
  71         printk("EIP:\t%04x:%p\nEFLAGS:\t%p\nESP:\t%04x:%p\n",
  72                esp[1],esp[0],esp[2],esp[4],esp[3]);
  73         printk("fs: %04x\n",_fs());
  74         printk("ds: %04x\n",_ds());
  75         printk("es: %04x\n",_es());
  76
  77         if (esp[4] == 0x17) {
  78                 printk("Stack: ");
  79                 for (i=0;i<4;i++)
  80                         printk("%p ",get_seg_long(0x17,i+(long *)esp[3]));
  81                 printk("\n");
  82         }
  83
  84         /*
  85           if (strcmp(str, "divide error" == 0)) {
  86                   esp[0] += 0x03;
  87                   return;
  88           }
  89         */
  90         while(1)
  91                 ;
  92 }
  93
  94 void do_double_fault(long esp, long error_code)
  95 {
  96         die("double fault",esp,error_code);
  97 }
  98
  99 void do_general_protection(long esp, long error_code)
 100 {
 101         die("general protection",esp,error_code);
 102 }
 103
 104 void do_divide_error(long esp, long error_code)
 105 {
 106         die("divide error",esp,error_code);
 107 }
 108
 109 void do_int3(long * esp, long error_code,
 110              long fs,long es,long ds,
 111              long ebp,long esi,long edi,
 112              long edx,long ecx,long ebx,long eax)
 113 {
 114
 115         /*      __asm__("str %%ax":"=a" (tr):"0" (0));*/
 116         printk("eax\t\tebx\t\tecx\t\tedx\n\r%8x\t%8x\t%8x\t%8x\n\r",
 117                eax,ebx,ecx,edx);
 118         printk("esi\t\tedi\t\tebp\t\tesp\n\r%8x\t%8x\t%8x\t%8x\n\r",
 119                esi,edi,ebp,(long) esp);
 120         printk("\n\rds\tes\tfs\ttr\n\r%4x\t%4x\t%4x\t\n\r",
 121                ds,es,fs/*,tr*/);
 122         printk("EIP: %8x   CS: %4x  EFLAGS: %8x\n\r",esp[0],esp[1],esp[2]);
 123
 124         for (;;)
 125                 ;
 126 }
 127
 128 void do_nmi(long esp, long error_code)
 129 {
 130         die("nmi",esp,error_code);
 131 }
 132
 133 void do_debug(long esp, long error_code)
 134 {
 135         die("debug",esp,error_code);
 136 }
 137
 138 void do_overflow(long esp, long error_code)
 139 {
 140         die("overflow",esp,error_code);
 141 }
 142
 143 void do_bounds(long esp, long error_code)
 144 {
 145         die("bounds",esp,error_code);
 146 }
 147
 148 void do_invalid_op(long esp, long error_code)
 149 {
 150         die("invalid operand",esp,error_code);
 151 }
 152
 153 void do_device_not_available(long esp, long error_code)
 154 {
 155         die("device not available",esp,error_code);
 156 }
 157
 158 void do_coprocessor_segment_overrun(long esp, long error_code)
 159 {
 160         die("coprocessor segment overrun",esp,error_code);
 161 }
 162
 163 void do_invalid_TSS(long esp,long error_code)
 164 {
 165         die("invalid TSS",esp,error_code);
 166 }
 167
 168 void do_segment_not_present(long esp,long error_code)
 169 {
 170         die("segment not present",esp,error_code);
 171 }
 172
 173 void do_stack_segment(long esp,long error_code)
 174 {
 175         die("stack segment",esp,error_code);
 176 }
 177
 178 void do_coprocessor_error(long esp, long error_code)
 179 {
 180         die("coprocessor error",esp,error_code);
 181 }
 182
 183 void do_reserved(long esp, long error_code)
 184 {
 185         die("reserved (15,17-31) error",esp,error_code);
 186 }
 187
 188
 189
 190 void ipc_install(void)
 191 {
 192         outb_p(0x11, 0x20);
 193         outb_p(0x11, 0xa0);
 194
 195         outb_p(0x20, 0x21);
 196         outb_p(0x28, 0xa1);
 197
 198         outb_p(0x04, 0x21);
 199         outb_p(0x02, 0xa1);
 200
 201         outb_p(0x01, 0x21);
 202         outb_p(0x01, 0xa1);
 203
 204         outb_p(0x11, 0x21);
 205         outb_p(0x11, 0xa1);
 206 }
 207
 208
 209 void trap_init(void)
 210 {
 211         extern void keyboard_interrupt();
 212         int i;
 213         struct DESCR {
 214                 unsigned short length;
 215                 unsigned long long  *address;
 216         } __attribute__((packed)) idt_descr = {256*8-1, idt};
 217
 218         ipc_install();
 219
 220         set_trap_gate(0,&divide_error);
 221         set_trap_gate(1,&debug);
 222         set_trap_gate(2,&nmi);
 223         set_system_gate(3,&int3);  /*int3*/
 224         set_system_gate(4,&overflow);
 225         set_system_gate(5,&bounds);
 226         set_trap_gate(6,&invalid_op);
 227         set_trap_gate(7,&reserved);/*device_not_available*/
 228         set_trap_gate(8,&double_fault);
 229         set_trap_gate(9,&coprocessor_segment_overrun);
 230         set_trap_gate(10,&invalid_TSS);
 231         set_trap_gate(11,&segment_not_present);
 232         set_trap_gate(12,&stack_segment);
 233         set_trap_gate(13,&general_protection);
 234         set_trap_gate(14,&reserved);/*page_fault*/
 235         set_trap_gate(15,&reserved);
 236         set_trap_gate(16,&reserved); /*coprocessor_error*/
 237
 238         for (i=17;i < 48;i++)
 239                 set_trap_gate(i,&reserved);
 240
 241
 242
 243         __asm__ ("lidt %0\n\t"::"m"(idt_descr));
 244
 245
 246
 247         /*set_trap_gate(45,&irq13);*/
 248
 249         outb_p(inb_p(0x21)&0xfb, 0x21);
 250         outb_p(inb_p(0xa1)&0xdf, 0xa1);
 251
 252         /* set_trap_gate(39,&parallel_interrupt);*/
 253
 254
 255         /* Install system call handler */
 256         set_system_gate(0x80, &syscall_interrupt);
 257 }