OSDev.org

Code: Select all

void _declspec(naked) IDTManager::DefaultHandler()
{
    __asm{
        /*try to manage stack */
        }
    // try to insert some c++ code
    __asm{
        iretd
    }
}

Code: Select all

static void _cdecl IDTManager::DefaultHandler() {

	_asm add esp, 12
	_asm pushad

	// code..

	_asm popad
	_asm iretd
}

Code: Select all

Stack at the enter on interrupt
00000cc4  --> eip (low)
00000010     ... (hight
00000008 --> cs : code selector
00000000 
00000006 --> eflags 
00000000

Code: Select all

stack before iret
00000008
00000000 
00000006
00000000

Code: Select all

In source code
add	esp, 12
in bochs
add          sp, 12

Code: Select all

_asm add esp, 12

Code: Select all

_asm add esp, 8

Code: Select all

int x = 0;
int y = 10 /x;   // divide by zero

Code: Select all

void _cdecl IDTManager::DefaultHandler(){
    __asm{
        add    esp, 12
        pushad	
    }
    IDTManager::cs->Write("Exception fired !"); // cs : static pointer to static object console
    __asm{	
        popad
        iretd
    }
}

Code: Select all

IDT::IDTManager::DefaultHandler();

Code: Select all

00100c90: (                    ): push ebp                  ; 55
00100c91: (                    ): mov ebp, esp              ; 8bec
00100c93: (                    ): push ebx                  ; 53
00100c94: (                    ): push esi                  ; 56
00100c95: (                    ): push edi                  ; 57
00100c96: (                    ): add esp, 0x0000000c       ; 83c40c
00100c99: (                    ): pushad                    ; 60       
00100c9a: (                    ): push 0x0010163c           ; 683c161000
00100c9f: (                    ): mov ecx, dword ptr ds:0x102248 ; 8b0d48221000
00100ca5: (                    ): call .+0xfffff806         ; e806f8ffff                                  <--- the call to cs->Write(...
00100caa: (                    ): popad                     ; 61
00100cab: (                    ): iretd                     ; cf

Code: Select all

00100c90: (                    ): push bp                   ; 55
00100c91: (                    ): mov bp, sp                ; 8bec
00100c93: (                    ): push bx                   ; 53
00100c94: (                    ): push si                   ; 56
00100c95: (                    ): push di                   ; 57
00100c96: (                    ): add sp, 0x000c            ; 83c40c
00100c99: (                    ): pusha                     ; 60
00100c9a: (                    ): push 0x163c               ; 683c16
00100c9d: (                    ): adc byte ptr ds:[bx+si], al ; 1000
00100c9f: (                    ): mov cx, word ptr ds:[di]  ; 8b0d
00100ca1: (                    ): dec ax                    ; 48
00100ca2: (                    ): and dl, byte ptr ds:[bx+si] ; 2210
00100ca4: (                    ): add al, ch                ; 00e8
00100ca6: (                    ): push es                   ; 06
00100ca7: (                    ): clc                       ; f8
00100ca8: (                    ): (invalid)                 ; ffff                            ??? where is the call to cs->Write(...  ???
00100caa: (                    ): popa                      ; 61
00100cab: (                    ): iret                      ; cf

Code: Select all

gdt_data: 
	dd 0				; null descriptor
	dd 0 

; gdt code:				; code descriptor
	dw 0FFFFh			; limit low
	dw 0				; base low
	db 0				; base middle
	db 10011010b		; access
	db 11001111b		; granularity
	db 0				; base high

; gdt data:				; data descriptor
	dw 0FFFFh			; limit low (Same as code)10:56 AM 7/8/2007
	dw 0				; base low
	db 0				; base middle
	db 10010010b		; access
	db 11001111b		; granularity
	db 0				; base high
	
end_of_gdt:
toc: 
	dw end_of_gdt - gdt_data - 1	; limit (Size of GDT)
	dd gdt_data						; base of GDT

; give the descriptor offsets names

%define NULL_DESC 0
%define CODE_DESC 0x8
%define DATA_DESC 0x10

Code: Select all

#pragma once
#include <system/console/console.h>

namespace IDT{

#define MAX_INTERRUPTS 256

#define IDT_BIT16		0x06	//00000110
#define IDT_BIT32		0x0E	//00001110
#define IDT_RING1		0x40	//01000000
#define IDT_RING2		0x20	//00100000
#define IDT_RING3		0x60	//01100000
#define IDT_PRESENT		0x80	//10000000

#pragma pack (push,1)
	struct IDTDescriptor{
		unsigned __int16	BaseLow;
		unsigned __int16	Selector;
		unsigned __int8		Reserved;
		unsigned __int8		Flags;
		unsigned __int16	BaseHigh;
	};
#pragma pack (pop,1)

#pragma pack (push, 1)
struct idtr {
	unsigned __int16 Limit;
	unsigned __int32 Base;
};
#pragma pack (pop, 1)

typedef void (_cdecl *IRQ_HANDLER)(void);


class IDTManager
{
public:
	IDTManager(void);
	~IDTManager(void);
	static void LoadIDT();
	static __int32 InstallInterrupt(unsigned __int32 index, unsigned __int8 flags, unsigned __int16 selector, IRQ_HANDLER handler);
	static void /*_cdecl*/ DefaultHandler();//unsigned int cs, unsigned int eip, unsigned int eflags);//unsigned __int32 eip,unsigned __int32 cs,unsigned __int32 eflags);

	void GenerateInt (int n);
	void Init(unsigned __int16, Console * cons);
	static struct IDTDescriptor _idt[MAX_INTERRUPTS];
private:	
	static Console* cs;

	static struct idtr _idtr;	
};
}

Code: Select all

	/
#include <HAL/IDTManager.h>


namespace IDT{

struct IDTDescriptor IDTManager::_idt[MAX_INTERRUPTS] ={0} ;
struct idtr IDTManager::_idtr = {0};
Console *IDTManager::cs;


IDTManager::IDTManager(void)
{
}

IDTManager::~IDTManager(void)
{
}

void IDTManager::LoadIDT()
{
	__asm{
		//lea		eax, _idtr
		//lidt	[eax]
		lidt [_idtr]
	};
}
/*
 * Install an interrupt 
 * Return interrupt index or -1 on error
 */
__int32 IDTManager::InstallInterrupt(unsigned __int32 index, unsigned char flags, unsigned short selector, IRQ_HANDLER handler)
{
	
	if ((index>MAX_INTERRUPTS) || (!handler))
	{
		IDTManager::cs->SetForeColor(0x00880000);
		IDTManager::cs->Write("Error on int ");
		IDTManager::cs->WriteLine((int)index);
		IDTManager::cs->SetForeColor(0x00FFFFFF);
		return -1;
	}

	//! get base address of interrupt handler
	//unsigned long long base = (unsigned long long)&(*handler);
	unsigned __int64 base = (unsigned __int64)&(*handler);
	/*
	cs->Write("|");
	cs->Write((int)index);
	cs->Write(":");
	cs->WriteLine(selector);
	*/
	//! store base address into idt
	_idt[index].BaseLow	=	unsigned __int16(base & 0xffff);
	_idt[index].BaseHigh=	unsigned __int16((base >> 16) & 0xffff);
	_idt[index].Reserved=	0;
	_idt[index].Flags	=	unsigned __int8(flags);
	_idt[index].Selector=	selector;

	return	index;
}

void _declspec(naked) _cdecl IDTManager::DefaultHandler(){//unsigned int cs, unsigned int eip, unsigned int eflags){//unsigned __int32 eip,unsigned __int32 cs,unsigned __int32 eflags){
	__asm{
		cli
        pushad	
	}
	IDTManager::cs->SetBackColor(0x00FFFFFF);
	IDTManager::cs->SetBackColor(0x00FF0000);
	IDTManager::cs->WriteLine("!!!!!! Interrupt not handled !!!!!!!\nJust wait next version ;o) !");
	IDTManager::cs->SetBackColor(0x00000000);
	IDTManager::cs->SetBackColor(0x00FFFFFF);
	/* Restore the context */
	__asm{	
		popad
        iretd
	}
}
//! generate interrupt call
void IDTManager::GenerateInt (int n) {
	_asm {
		mov al, byte ptr [n]
		mov byte ptr [genint+1], al
		jmp genint
	genint:
		int 0	// above code modifies the 0 to int number to generate
	}
}

void IDTManager::Init(unsigned __int16 selector, Console * cons)
{
	// init console pointer
	*IDTManager::cs = *cons;
	IDTManager::cs->WriteLine("IDT initialization");
	//! set up idtr for processor
	_idtr.Limit = sizeof (struct IDTDescriptor) * (MAX_INTERRUPTS -1);
	_idtr.Base	= (unsigned __int32)&_idt[0];

	//! register default handlers
	for (int i=0; i<MAX_INTERRUPTS; i++)
	{
		_idt[i].BaseHigh = 0;
		_idt[i].BaseLow = 0;
		_idt[i].Flags = 0;
		_idt[i].Reserved = 0;
		_idt[i].Selector = 0;
		InstallInterrupt (i, IDT_PRESENT | IDT_BIT32,
		selector, 
		(IRQ_HANDLER)/*(void (__cdecl &)(void))*/IDTManager::DefaultHandler);
	}
	//! install our idt
	IDTManager::LoadIDT ();

}

}