kitten/arch/x86_64/kernel/interrupts.c

   1 #include <lwk/kernel.h>
   2 #include <lwk/init.h>
   3 #include <lwk/kallsyms.h>
   4 #include <lwk/task.h>
   5 #include <lwk/sched.h>
   6 #include <lwk/timer.h>
   7 #include <arch/desc.h>
   8 #include <arch/idt_vectors.h>
   9 #include <arch/show.h>
  10 #include <arch/xcall.h>
  11 #include <arch/i387.h>
  12
  13 typedef void (*idtvec_handler_t)(struct pt_regs *regs, unsigned int vector);
  14
  15 idtvec_handler_t idtvec_table[NUM_IDT_ENTRIES];
  16
  17 extern void asm_idtvec_table(void);
  18
  19 void
  20 do_unhandled_idt_vector(struct pt_regs *regs, unsigned int vector)
  21 {
  22         if ((vector >= IRQ0_VECTOR) && (vector <= IRQ15_VECTOR)) {
  23                 printk(KERN_EMERG
  24                        "Unhandled Interrupt! (vector=%u, isa_irq=%u)\n",
  25                        vector, vector - IRQ0_VECTOR);
  26         } else {
  27                 printk(KERN_EMERG
  28                        "Unhandled Interrupt! (vector=%u)\n", vector);
  29         }
  30 }
  31
  32 void
  33 do_divide_error(struct pt_regs *regs, unsigned int vector)
  34 {
  35         printk("Divide Error Exception\n");
  36         show_registers(regs);
  37         while (1) {}
  38 }
  39
  40 void
  41 do_nmi(struct pt_regs *regs, unsigned int vector)
  42 {
  43         printk("NMI Exception\n");
  44         show_registers(regs);
  45         while (1) {}
  46 }
  47
  48 void
  49 do_int3(struct pt_regs *regs, unsigned int vector)
  50 {
  51         printk("INT3 Exception\n");
  52         show_registers(regs);
  53         while (1) {}
  54 }
  55
  56 void
  57 do_overflow(struct pt_regs *regs, unsigned int vector)
  58 {
  59         printk("Overflow Exception\n");
  60         show_registers(regs);
  61         while (1) {}
  62 }
  63
  64 void
  65 do_bounds(struct pt_regs *regs, unsigned int vector)
  66 {
  67         printk("Bounds Exception\n");
  68         show_registers(regs);
  69         while (1) {}
  70 }
  71
  72 void
  73 do_invalid_op(struct pt_regs *regs, unsigned int vector)
  74 {
  75         printk("Invalid Op Exception\n");
  76         show_registers(regs);
  77         while (1) {}
  78 }
  79
  80 void
  81 do_device_not_available(struct pt_regs *regs, unsigned int vector)
  82 {
  83         BUG_ON(current->arch.flags & TF_USED_FPU);
  84         current->arch.flags |= TF_USED_FPU;
  85         clts();
  86         fpu_restore_state(current);
  87 }
  88
  89 void
  90 do_double_fault(struct pt_regs *regs, unsigned int vector)
  91 {
  92         printk("Double Fault Exception\n");
  93         show_registers(regs);
  94         while (1) {}
  95 }
  96
  97 void
  98 do_coproc_segment_overrun(struct pt_regs *regs, unsigned int vector)
  99 {
 100         printk("Coprocessor Segment Exception\n");
 101         show_registers(regs);
 102         while (1) {}
 103 }
 104
 105 void
 106 do_invalid_tss(struct pt_regs *regs, unsigned int vector)
 107 {
 108         printk("Invalid TSS Exception)\n");
 109         show_registers(regs);
 110         while (1) {}
 111 }
 112
 113 void
 114 do_segment_not_present(struct pt_regs *regs, unsigned int vector)
 115 {
 116         printk("Segment Not Present Exception\n");
 117         show_registers(regs);
 118         while (1) {}
 119 }
 120
 121 void
 122 do_stack_segment(struct pt_regs *regs, unsigned int vector)
 123 {
 124         printk("Stack Segment Exception\n");
 125         show_registers(regs);
 126         while (1) {}
 127 }
 128
 129 void
 130 do_general_protection(struct pt_regs *regs, unsigned int vector)
 131 {
 132         printk("General Protection Exception\n");
 133         show_registers(regs);
 134         while (1) {}
 135 }
 136
 137 void
 138 do_page_fault(struct pt_regs *regs, unsigned int vector)
 139 {
 140         printk("Page Fault Exception\n");
 141         show_registers(regs);
 142         while (1) {}
 143 }
 144
 145 void
 146 do_spurious_interrupt_bug(struct pt_regs *regs, unsigned int vector)
 147 {
 148         printk("Spurious Interrupt Exception\n");
 149         show_registers(regs);
 150         while (1) {}
 151 }
 152
 153 void
 154 do_coprocessor_error(struct pt_regs *regs, unsigned int vector)
 155 {
 156         printk("Coprocessor Error Exception\n");
 157         show_registers(regs);
 158         while (1) {}
 159 }
 160
 161 void
 162 do_alignment_check(struct pt_regs *regs, unsigned int vector)
 163 {
 164         printk("Alignment Check Exception\n");
 165         show_registers(regs);
 166         while (1) {}
 167 }
 168
 169 void
 170 do_machine_check(struct pt_regs *regs, unsigned int vector)
 171 {
 172         printk("Machine Check Exception\n");
 173         show_registers(regs);
 174         while (1) {}
 175 }
 176
 177 void
 178 do_simd_coprocessor_error(struct pt_regs *regs, unsigned int vector)
 179 {
 180         printk("SIMD Coprocessor Error Exception\n");
 181         show_registers(regs);
 182         while (1) {}
 183 }
 184
 185 void
 186 do_apic_timer(struct pt_regs *regs, unsigned int vector)
 187 {
 188         expire_timers();
 189 }
 190
 191 void
 192 do_apic_perf_counter(struct pt_regs *regs, unsigned int vector)
 193 {
 194         printk("APIC Perf. Counter Interrupt, vector=%u\n", vector);
 195         show_registers(regs);
 196         while (1) {}
 197 }
 198
 199 void
 200 do_apic_thermal(struct pt_regs *regs, unsigned int vector)
 201 {
 202         printk("APIC Thermal Interrupt, vector=%u\n", vector);
 203         show_registers(regs);
 204         while (1) {}
 205 }
 206
 207 void
 208 do_apic_error(struct pt_regs *regs, unsigned int vector)
 209 {
 210         printk("APIC Error Interrupt, vector=%u\n", vector);
 211         show_registers(regs);
 212         while (1) {}
 213 }
 214
 215 void
 216 do_apic_spurious(struct pt_regs *regs, unsigned int vector)
 217 {
 218         printk("APIC Spurious Interrupt, vector=%u\n", vector);
 219         show_registers(regs);
 220         while (1) {}
 221 }
 222
 223 void __init
 224 set_idtvec_handler(unsigned int vector, idtvec_handler_t handler)
 225 {
 226         char namebuf[KSYM_NAME_LEN+1];
 227         unsigned long symsize, offset;
 228
 229         ASSERT(vector < NUM_IDT_ENTRIES);
 230
 231         if (handler != &do_unhandled_idt_vector) {
 232                 printk(KERN_DEBUG "IDT Vector %3u -> %s()\n",
 233                         vector, kallsyms_lookup( (unsigned long)handler,
 234                                                   &symsize, &offset, namebuf )
 235                 );
 236         }
 237
 238         idtvec_table[vector] = handler;
 239 }
 240
 241 void
 242 do_interrupt(struct pt_regs *regs, unsigned int vector)
 243 {
 244         idtvec_table[vector](regs, vector);
 245         if (vector >= FIRST_EXTERNAL_VECTOR)
 246                 lapic_ack_interrupt();
 247 }
 248
 249 void __init
 250 interrupts_init(void)
 251 {
 252         int vector;
 253
 254         /*
 255          * Initialize the Interrupt Descriptor Table (IDT).
 256          */
 257         for (vector = 0; vector < NUM_IDT_ENTRIES; vector++) {
 258                 void *asm_handler = (void *) (
 259                   (unsigned long)(&asm_idtvec_table) + (vector * 16)
 260                 );
 261                 set_intr_gate(vector, asm_handler);
 262                 set_idtvec_handler(vector, &do_unhandled_idt_vector);
 263         }
 264
 265         /*
 266          * Register handlers for the standard x86_64 interrupts & exceptions.
 267          */
 268         set_idtvec_handler( DIVIDE_ERROR_VECTOR,           &do_divide_error           );
 269         set_idtvec_handler( NMI_VECTOR,                    &do_nmi                    );
 270         set_idtvec_handler( INT3_VECTOR,                   &do_int3                   );
 271         set_idtvec_handler( OVERFLOW_VECTOR,               &do_overflow               );
 272         set_idtvec_handler( BOUNDS_VECTOR,                 &do_bounds                 );
 273         set_idtvec_handler( INVALID_OP_VECTOR,             &do_invalid_op             );
 274         set_idtvec_handler( DEVICE_NOT_AVAILABLE_VECTOR,   &do_device_not_available   );
 275         set_idtvec_handler( DOUBLE_FAULT_VECTOR,           &do_double_fault           );
 276         set_idtvec_handler( COPROC_SEGMENT_OVERRUN_VECTOR, &do_coproc_segment_overrun );
 277         set_idtvec_handler( INVALID_TSS_VECTOR,            &do_invalid_tss            );
 278         set_idtvec_handler( SEGMENT_NOT_PRESENT_VECTOR,    &do_segment_not_present    );
 279         set_idtvec_handler( STACK_SEGMENT_VECTOR,          &do_stack_segment          );
 280         set_idtvec_handler( GENERAL_PROTECTION_VECTOR,     &do_general_protection     );
 281         set_idtvec_handler( PAGE_FAULT_VECTOR,             &do_page_fault             );
 282         set_idtvec_handler( SPURIOUS_INTERRUPT_BUG_VECTOR, &do_spurious_interrupt_bug );
 283         set_idtvec_handler( COPROCESSOR_ERROR_VECTOR,      &do_coprocessor_error      );
 284         set_idtvec_handler( ALIGNMENT_CHECK_VECTOR,        &do_alignment_check        );
 285         set_idtvec_handler( MACHINE_CHECK_VECTOR,          &do_machine_check          );
 286         set_idtvec_handler( SIMD_COPROCESSOR_ERROR_VECTOR, &do_simd_coprocessor_error );
 287
 288         /*
 289          * Register handlers for all of the local APIC vectors.
 290          */
 291         set_idtvec_handler( APIC_TIMER_VECTOR,        &do_apic_timer        );
 292         set_idtvec_handler( APIC_PERF_COUNTER_VECTOR, &do_apic_perf_counter );
 293         set_idtvec_handler( APIC_THERMAL_VECTOR,      &do_apic_thermal      );
 294         set_idtvec_handler( APIC_ERROR_VECTOR,        &do_apic_error        );
 295         set_idtvec_handler( APIC_SPURIOUS_VECTOR,     &do_apic_spurious     );
 296
 297         /*
 298          * Register handlers for inter-CPU interrupts (cross calls).
 299          */
 300         set_idtvec_handler( XCALL_FUNCTION_VECTOR,   &arch_xcall_function_interrupt   );
 301         set_idtvec_handler( XCALL_RESCHEDULE_VECTOR, &arch_xcall_reschedule_interrupt );
 302 }
 303
 304