haiku.git

/*
 * Copyright 2011, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */


#include "interrupts.h"

#include <stdio.h>
#include <string.h>

#include <algorithm>

#include <KernelExport.h>

#include <boot/platform.h>
#include <boot/platform/generic/text_console.h>

#include <arch_cpu.h>
#include <arch/x86/descriptors.h>

#include "debug.h"
#include "keyboard.h"


//#define TRACE_INTERRUPTS
#ifdef TRACE_INTERRUPTS
#	define TRACE(x...) dprintf(x)
#else
#	define TRACE(x...) ;
#endif


// interrupt function prototypes
#define INTERRUPT_FUNCTION(vector) \
	extern "C" void interrupt_function##vector();
INTERRUPT_FUNCTIONS()
#undef INTERRUPT_FUNCTION

#define INTERRUPT_FUNCTION(vector) \
	extern "C" void exception_interrupt_function##vector();
INTERRUPT_FUNCTIONS()
#undef INTERRUPT_FUNCTION


static const char *kInterruptNames[DEBUG_IDT_SLOT_COUNT] = {
	/*  0 */ "Divide Error Exception",
	/*  1 */ "Debug Exception",
	/*  2 */ "NMI Interrupt",
	/*  3 */ "Breakpoint Exception",
	/*  4 */ "Overflow Exception",
	/*  5 */ "BOUND Range Exceeded Exception",
	/*  6 */ "Invalid Opcode Exception",
	/*  7 */ "Device Not Available Exception",
	/*  8 */ "Double Fault Exception",
	/*  9 */ "Coprocessor Segment Overrun",
	/* 10 */ "Invalid TSS Exception",
	/* 11 */ "Segment Not Present",
	/* 12 */ "Stack Fault Exception",
	/* 13 */ "General Protection Exception",
	/* 14 */ "Page-Fault Exception",
	/* 15 */ "-",
	/* 16 */ "x87 FPU Floating-Point Error",
	/* 17 */ "Alignment Check Exception",
	/* 18 */ "Machine-Check Exception",
	/* 19 */ "SIMD Floating-Point Exception",
};


struct interrupt_frame {
    uint32 vector;
    uint32 edi;
    uint32 esi;
    uint32 ebp;
    uint32 esp;
    uint32 ebx;
    uint32 edx;
    uint32 ecx;
    uint32 eax;
	uint32 error_code;
	uint32 eip;
	uint32 cs;
	uint32 eflags;
};


static interrupt_descriptor sDebugIDT[DEBUG_IDT_SLOT_COUNT];

static gdt_idt_descr sBIOSIDTDescriptor;
static gdt_idt_descr sDebugIDTDescriptor = { sizeof(sDebugIDT) - 1, sDebugIDT };


static void
set_interrupt_gate(int n, void (*function)())
{
	if (n >= DEBUG_IDT_SLOT_COUNT)
		return;

	sDebugIDT[n].a
		= (KERNEL_CODE_SELECTOR << 16) | (0x0000ffff & (addr_t)function);
	sDebugIDT[n].b = (0xffff0000 & (addr_t)function) | 0x8e00;
}


static void
set_idt(const gdt_idt_descr& idtDescriptor)
{
	asm("lidt	%0;" : : "m" (idtDescriptor));
}


extern "C" void
handle_exception_exception()
{
	while (true);
}


extern "C" void
handle_exception(interrupt_frame frame)
{
	// Before doing anything else, set the interrupt gates so that
	// handle_exception_exception() is called. This way we may avoid
	// triple-faulting, if e.g. the stack is messed up and the user has at
	// least the already printed output.
	#define INTERRUPT_FUNCTION(vector) \
		set_interrupt_gate(vector, &exception_interrupt_function##vector);
	INTERRUPT_FUNCTIONS()
	#undef INTERRUPT_FUNCTION

	// If the console is already/still initialized, clear the screen and prepare
	// for output.
	if (stdout != NULL) {
		console_set_color(RED, BLACK);
		console_clear_screen();
		console_set_cursor(0, 0);
		console_hide_cursor();
	}

	// print exception name
	if (frame.vector < DEBUG_IDT_SLOT_COUNT)
		kprintf("%s", kInterruptNames[frame.vector]);
	else
		kprintf("Unknown exception %" B_PRIu32, frame.vector);

	// additional info for page fault
	if (frame.vector == 14) {
		uint32 cr2;
		asm("movl %%cr2, %0" : "=r"(cr2));
		kprintf(": %s fault at address: %#" B_PRIx32,
			(frame.error_code & 0x2) != 0 ? "write" : "read", cr2);
	}

	kprintf("\n");

	// print greeting and registers
	kprintf("Welcome to Boot Loader Death Land!\n");
	kprintf("\n");

	#define REG(name)	" " #name " %-#10" B_PRIx32

	kprintf(REG(eax) "   " REG(ebx) "    " REG(ecx) " " REG(edx) "\n",
		frame.eax, frame.ebx, frame.ecx, frame.edx);
	kprintf(REG(esi) "   " REG(edi) "    " REG(ebp) " " REG(esp) "\n",
		frame.esi, frame.edi, frame.ebp, frame.esp);
	kprintf(REG(eip) REG(eflags) "\n", frame.eip, frame.eflags);

	#undef REG

	// print stack trace (max 10 frames)
	kprintf("\n       frame    return address\n");

	struct x86_stack_frame {
		x86_stack_frame*	next;
		void*				return_address;
	};

	x86_stack_frame* stackFrame = (x86_stack_frame*)frame.ebp;
	void* instructionPointer = (void*)frame.eip;

	for (int32 i = 0; i < 10 && stackFrame != NULL; i++) {
		kprintf("  %p        %p\n", stackFrame, instructionPointer);

		instructionPointer = stackFrame->return_address;
		stackFrame = stackFrame->next;
	}

	if (stdout != NULL) {
		kprintf("\nPress a key to reboot.\n");
		clear_key_buffer();
		wait_for_key();
		platform_exit();
	}

	while (true);
}


void
interrupts_init()
{
	// get the IDT
	asm("sidt	%0;" : : "m" (sBIOSIDTDescriptor));

	TRACE("IDT: base: %p, limit: %u\n", sBIOSIDTDescriptor.base,
		sBIOSIDTDescriptor.limit);

	// set interrupt gates
	#define INTERRUPT_FUNCTION(vector) \
		set_interrupt_gate(vector, &interrupt_function##vector);
	INTERRUPT_FUNCTIONS()
	#undef INTERRUPT_FUNCTION

	// set the debug IDT
	set_debug_idt();
}


void
restore_bios_idt()
{
	set_idt(sBIOSIDTDescriptor);
}


void
set_debug_idt()
{
	set_idt(sDebugIDTDescriptor);
}