OSDev.org

Code: Select all

unsigned long ticks = 0;

extern void switch_to(unsigned long);

thread* prev;

void schedule(struct regs* r)
{
   /* get next thread */
   SchedulerGetNextNode();

   if(ticks % 10000 == 0)
   {
      puts("1 second passed\n");
   }

   ticks++;

   int sw = 0;

   if(node != prev)
   {
      sw = 1;
   }

   prev = node;

   if(sw)
   {
      switch_to(node->gdt); /* after this nothing happens */
   }
}

extern _schedule

; 32: IRQ0
_irq0:
    cli
    pusha
    push ds
    push es
    push fs
    push gs

    mov ax, 0x10
    mov ds, ax
    mov es, ax
    mov fs, ax
    mov gs, ax
    mov eax, esp

    push eax
    mov eax, _schedule
    call eax
    pop eax

    pop gs
    pop fs
    pop es
    pop ds
    popa
    add esp, 8
    sti
    iret

.globl _switch_to

_switch_to:
   ljmp *(%esp)
        ret

Code: Select all

IRQ0:
    cli
    pusha and other pushes
    call _schedule <<-------- C function schedule
        {
            account_for_passed_ticks;
            find_next_thread();
            switch_to(tread->gdt);   <<---------- ASM proc switch_to
                ljmp *(%esp) <<--- jump to the procedure
                ret
        }
    other pops and popa
    sti
    iret

Code: Select all

IRQ0:
    cli
    push %ebp
    mov %esp, %ebp <<---- return address would be at 4(%ebp)
    pusha and other pushes
    <<-- save current thread info from the stack to the thread table
    call _schedule <<---- C functions return value is at %EAX
    mov %eax, 4(%ebp) <<-- modify return address
    <<-- if the task will change, load the new state from the thread table to the stack
    other pops and popa
    pop %ebp
    sti
    iret <<-- this will return to the modified return address


void* schedule()
{
    account_for_ticks;
    nextThread = GetNextThread();
    return nextThread->eip;
}

Code: Select all

idt_set_gate(32, (unsigned)irq0, 0x08, 0x8E);

Code: Select all

/* Use this function to set an entry in the IDT. Alot simpler

*  than twiddling with the GDT ;) */

void idt_set_gate(unsigned char num, unsigned long base, unsigned short sel, unsigned char flags)

{

    /* The interrupt routine's base address */

    idt[num].base_lo = (base & 0xFFFF);

    idt[num].base_hi = (base >> 16) & 0xFFFF;



    /* The segment or 'selector' that this IDT entry will use

    *  is set here, along with any access flags */

    idt[num].sel = sel;

    idt[num].always0 = 0;

    idt[num].flags = flags;

}

Code: Select all

global _switch_to
_switch_to:
        push    ebp
        mov     ebp, esp
        jmp far [ss:ebp+4]
        pop     ebp
        ret

Code: Select all

; 32: IRQ0
_irq0:
    cli
    push byte 0
    push byte 32
    jmp irq_common_stub

extern _irq_handler

irq_common_stub:
    pusha
    push ds
    push es
    push fs
    push gs

    mov ax, 0x10
    mov ds, ax
    mov es, ax
    mov fs, ax
    mov gs, ax
    mov eax, esp

    push eax
    mov eax, _irq_handler
    call eax
    pop eax

    pop gs
    pop fs
    pop es
    pop ds
    popa
    add esp, 8
    iret

Code: Select all

; have your next task ready in [nexttask], 
; maybe on the current stack or somewhere in global memory 
; both should work
MOV EAX, [scheduler_curtask] ; load current task info pointer
MOV [EAX+STACK], ESP ; store ESP
MOV EAX, [nexttask] ; get next task info pointer
MOV [scheduler_curtask], EAX ; set current task info pointer
MOV ESP, [EAX+STACK]  ; load new ESP 

Code: Select all

tmp_stack: dd 0

_irq0:
    cli
    cld
    pushad
    push ds
    push es
    push fs
    push gs

    mov [tmp_stack], esp ; save current stack value
    mov esp, _tss_stack ; move to new stack
    
    call _schedule

    mov esp, [tmp_stack] ; restore stack
    
    pop gs
    pop fs
    pop es
    pop ds
    popad
    
    mov al, 0x20
    out 0x20, al
    sti
    iretd

SECTION .bss
    resb 4096               ; This reserves 4KBytes of memory here
[global _tss_stack]
_tss_stack: