OSDev.org

Curufir wrote: a) Use the stack values for the return address to look back at the previous instruction and interpret the machine code for the interrupt (0xCD 0xNN from memory). This will only work for software interrupts of course (Although with some finesse it could be extended to IRQs as well).

b) Just make your IDT entries equivalent to gotos in your ISR wrapper.

For example:

Code: Select all

void isr_wrapper() {
  uint8 int_num = 0;

isr0:
  int_num++;
isr1:
  int_num++;
isr2:
  int_num++;

....

  actual_interrupt_handler(int_num);
}

Be aware that this will make some C people very annoyed though ;D.

c) (For fun and amusement) Create 256 identical GDT entries and arrange your IDT to load CS with the value of int_num*8.

Candy wrote:

Curufir wrote: a) Use the stack values for the return address to look back at the previous instruction and interpret the machine code for the interrupt (0xCD 0xNN from memory). This will only work for software interrupts of course (Although with some finesse it could be extended to IRQs as well).

No, you can't extend that to irq's by their nature. For software interrupts it's plausible though...

Candy wrote: Or make an engine which dynamically writes code for interrupts as you register them

The kernel provides a portable mechanism - a kernel control object called an interrupt object - that allows device drivers to register ISRs for their devices. An interrupt object contains all the information the kernel needs to associate a device ISR with a particular level of interrupt, including the address of the ISR, the IRQL at which the device interrupts, and the entry in the kernel's IDT with which the ISR should be associated. When an interrupt object is initialized, a few instructions of assembly language code, called the dispatch code, are stored in the object. When an interrupt occurs, this code is executed. This interrupt-object resident code calls the real interrupt dispatcher, passing it a pointer to the interrupt object. The interrupt object contains information this second dispatcher routine needs in order to locate and properly call the ISR the device driver provides. This two-step process is required because there is no way to pass a pointer to the interrupt object (or any other argument for that matter) on the initial dispatch since the initial dispatch is done by hardware.

purevoid wrote: That dynamically generating dispatcher code sounds almost like what we'd need. How to do that, I have no idea...

/*
code in bytes is equivalent to push $x (5b); call $y (5b); add esp, 4 (3b); iret (1b);
*/
char code[] = { 0x68, 0x00, 0x00, 0x00, 0x00, 0xE8, 0x00, 0x00, 0x00, 0x00, 0x83, 0xC4, 0x04, 0xCF, 0x00, 0x00};
char *newarray = (char *)malloc(16);
memcpy(newarray, code, 16);
newarray[1] = int_number;
newarray[6] = target_addr & 0xFF;
newarray[7] = (target_addr >> 8) & 0xFF;
newarray[8] = (target_addr >> 16) & 0xFF;
newarray[9] = (target_addr >> 24) & 0xFF;

But we've taken a slightly different approach, plus my understanding of interrupts was a little fuzzy before now.

For anyone interested in what's trying to be done, and maybe able to shed an extra bit of light on... we're writing our kernel in OCaml, and want to write interrupt handlers in OCaml too.

The biggest problem we face is calling into the OCaml function. Since we need to use a C callback function to call the actual OCaml function, I'm at a loss of how to put this information into the IDT, since you can't pass parameters easily.
[quote][/quote]
Use the code generator to generate an asm function to call C, and make some C wrapper that allows you to use it elegantly.

PS: no guarantees on the correctness of the code, you might want to ram some generated code through a disassembler first.

purevoid wrote: Been doing some reading of the Intel manuals, and here's the code I've come up with....

Code: Select all

char *isr_wrapper = {
  /* pusha, push gs, fs, es, ds */
  0x60, 0x0F, 0xA8, 0x0F, 0xA0, 0x06, 0x1E,
  /* push parameter 2 onto stack */
  0x68, 0x00, 0x00, 0x00, 0x00,
  /* push parameter 1 onto stack */
  0x68, 0x00, 0x00, 0x00, 0x00,
  /* call function */
  0x9A, 0x00, 0x00, 0x00, 0x00,
  /* pop ds, es, fs, gs, popa, iret */
  0x1F, 0x07, 0x0F, 0xA1, 0x0F, 0x09, 0x61, 0xCF
};

Where I'd replace the first lot of 0x00s with address of Val_unit, the second lot with address of *closure, and the last with address of the function `callback'.

It's just the call that I'm a little confused about, since there are a few different opcodes. From the Intel manual, I decided to use:

Opcode: 9A cd, Instruction: CALL ptr16:16, Description: Call far, absolute, address given in operand.

Assuming that's all correct, I'd just have to write the code to actually do all this work.