Interrupts Tutorial: Difference between revisions

 

This is the structure of a single (32-bit) IDT entry:

typedef struct {

uint16_t isr_low; // The lower 16 bits of the ISR's address

uint16_t isr_high; // The higher 16 bits of the ISR's address

} __attribute__((packed)) idt_entry_t;

and this is the structure of a single (64-bit) IDT entry:

typedef struct {

uint16_t isr_low; // The lower 16 bits of the ISR's address

uint32_t reserved; // Set to zero

} __attribute__((packed)) idt_entry_t;

===Table===

To create an IDT, simply create a 256-entry array of descriptors:

__attribute__((aligned(0x10)))

static idt_entry_t idt[256]; // Create an array of IDT entries; aligned for performance

You will also need a special IDTR structure, which looks like:

typedef struct {

uint16_t limit;

uint32_t base;

} __attribute__((packed)) idtr_t;

for a 32-bit IDT, or like:

typedef struct {

uint16_t limit;

uint64_t base;

} __attribute__((packed)) idtr_t;

for a 64-bit IDT.

 

Don't forget to define an IDTR:

static idtr_t idtr;

 

===ISRs===

In a C source file, define a general exception handler:

__attribute__((noreturn))

void exception_handler(void);

__asm__ volatile ("cli; hlt"); // Completely hangs the computer

}

This will act as your main exception handler. When you receive a CPU exception, this is the handler you will call.

 

Now, in an assembly file ('''nasm''' '''assembler''' specifically), define these two macros:

%macro isr_err_stub 1

isr_stub_%+%1:

iret

%endmacro

Then, use these macros to define your 32 exception handlers:

extern exception_handler

isr_no_err_stub 0

isr_err_stub 30

isr_no_err_stub 31

Finally, in assembly, define a "stub table". (This is used to prevent excessive code reuse, and not related to actual function.)

 

Using NASM macros:

global isr_stub_table

isr_stub_table:

%assign i i+1

%endrep

===Assembling===

Finally, we can assemble the IDT:

 

To define the entries, it is appropriate to make use of a helper function. That helper function would look like:

void idt_set_descriptor(uint8_t vector, void* isr, uint8_t flags);

void idt_set_descriptor(uint8_t vector, void* isr, uint8_t flags) {

descriptor->reserved = 0;

}

for a 32-bit IDT, or like:

void idt_set_descriptor(uint8_t vector, void* isr, uint8_t flags);

void idt_set_descriptor(uint8_t vector, void* isr, uint8_t flags) {

 

descriptor->ist = 0;

descriptor->attributes = flags;

}

for a 64-bit IDT.

 

Finally, to set the entries at last, this is what the function would look like:

extern void* isr_stub_table[];

 

void idt_init() {

idtr.base = (uintptr_t)&idt[0];

 

for (uint8_t vector = 0; vector < 32; vector++) {

vectors[vector] = true;

}

 

__asm__ volatile ("sti"); // set the interrupt flag

}

Congratulations! You have successfully defined your IDT, loaded it, and enabled interrupts.

 

* [https://forum.osdev.org/viewtopic.php?f=1&t=33160&p=285871#p285871 Interrupts don't work in GRUB]

===References===