OSDev.org

Code: Select all

void CalculateGate(unsigned char* descriptor, void* function)
{
   // Get the address.
   unsigned int address = (unsigned int)function;
   unsigned char* addressSplit = (unsigned char*)&address;

   // Set the stuff.
   descriptor[0] = addressSplit[0];
   descriptor[1] = addressSplit[1];
   descriptor[6] = addressSplit[2];
   descriptor[7] = addressSplit[3];

   // Enable the interrupt.
   descriptor[5] |= 0x80;
}

void SetupGates(void* function, unsigned short position, unsigned short count, void* idt)
{
   unsigned short t;
   idt += position * 8;
   for(t = 0; t < count; t++)
   {
      CalculateGate(idt, function);
      idt += 8;
   }
}

Code: Select all

; Note that irrelevant code has been cut
push IDTStart
mov eax, 256
push eax
mov eax, 0
push eax
push _itest
call _SetupGates
add esp, 16

lidt[IDTR]

int 32         ; Works.
int 33         ; Works.
int 34         ; Works.
int 0x80      ; Works(bochs). Resets the computer(hardware).

jmp $

_itest:
 mov eax, mFoo
 push eax
 call _Print
 add esp, 0x04
 iret
mFoo db "Interrupt!", 0x00

IDTR:
 dw IDTEnd - IDTStart
 dd IDTStart

; This should describe an unprotected flat memory model:
align 8, db 0      ; Optimization!
IDTStart:
 times 0x14 dd 0x00000000, 0x00000000      ; Exceptions!
 times 0x0C   dd 0x00000000, 0x00000000      ; Intel's reserved space.
 times 0xD0   dd 0x00080000, 0x00000E00      ; Interrupts for me, interrupts for you.
 times 0x10 dd 0x00080000, 0x00000E00      ; Interrupts for the IRQ lines.
IDTEnd:

Code: Select all

 setup_idt() {
                        /* idt_table[256] defined in arch/i386/kernel/traps.c
                         *   located in section .data.idt
                        EAX = __KERNEL_CS << 16 + ignore_int;
                        DX = 0x8E00;    // interrupt gate, dpl = 0, present
                        idt_table[0..255] = {EAX, EDX};
                }

Code: Select all

 ; Map the interrupts to a function.
 mov eax, 0x00080000   ; Interrupt part 1 to eax.
 mov edx, _itest      ; The function to map.
 and edx, 0x0000FFFF   ; Get the lower half of the function's address.
 or eax, edx         ; Add that to eax.
 
 mov ebx, 0x00008E00   ; Interrupt part 2 to ebx. (Including the type and flags)
 mov edx, _itest      ; The function to map again.
 and edx, 0xFFFF0000   ; Get the higher half.
 or ebx, edx         ; Add it to ebx. Note there's no bitshifting needed.
 
 mov ecx, 256         ; Fill 256 entries.
 mov edx, IDTStart      ; The start of the table.
 
 FillInterrupts:
 mov [ds:edx], eax      ; Set interrupt part 1.
 add edx, 4            ; Move on to the next part.
 mov [ds:edx], ebx      ; Set interrupt part 2.
 add edx, 4            ; Move on to the next entry.
 loop FillInterrupts   ; Loop until all the interrupts have been filled.