OSDev.org

Code: Select all

isr_common_stub:
    pusha                    // Pushes edi,esi,ebp,esp,ebx,edx,ecx,eax

    mov ax, ds               // Lower 16-bits of eax = ds.
    push eax                 // save the data segment descriptor

    mov ax, 0x10  // load the kernel data segment descriptor
    mov ds, ax
    mov es, ax
    mov fs, ax
    mov gs, ax

    call isr_stub_handler

    pop ebx        // reload the original data segment descriptor
    mov ds, bx
    mov es, bx
    mov fs, bx
    mov gs, bx

    popa                     // Pops edi,esi,ebp...
    add esp, 8     // Cleans up the pushed error code and pushed ISR number
    sti
    iret           // pops 5 things at once: CS, EIP, EFLAGS

Code: Select all

typedef struct cpu_status_struct {
    uint32_t ds;
    // Pushed by pusha.
    uint32_t edi, esi, ebp, esp, ebx, edx, ecx, eax;
    uint32_t int_no, err_code;
    // Pushed by the processor automatically.
    uint32_t eip, cs, eflags;
} cpu_status_t;

Code: Select all

add esp, 8     // Cleans up the pushed error code and pushed ISR number

Code: Select all

.global isr32
isr32:
    cli
    jmp isr_timer_stub

...

isr_timer_stub:
    pusha                    // Pushes edi, esi, ebp, esp, ebx, edx, ecx, eax

    mov ax, ds
    push eax                 // Save data segment

    mov ax, 0x10             // Load kernel data segment
    mov ds, ax
    mov es, ax
    mov fs, ax
    mov gs, ax

    call timer_interrupt_handler

    pop ebx                  // Restore original data segment
    mov ds, bx
    mov es, bx
    mov fs, bx
    mov gs, bx

    popa
    sti
    iret                     // Pops EIP, CS, EFLAGS

Code: Select all

struct task {
  ...
  uint32_t *stack_top;
};
void lowlevel_switch_to_task(uint32_t **oldstack, uint32_t *newstack);

Code: Select all

void schedule(void) {
  struct task *old = current;
  struct task *next = find_next_task();
  /* questions to ponder in future: Can next == old? Can next == NULL? */
  /* switching the "current" variable here is also hairy, because the stack isn't switched yet. May need improvement later. */
  current = next;
  lowlevel_switch_to_task(&old->stack_top, next->stack_top);
}

Code: Select all

lowlevel_switch_to_task:
  movl 4(%esp), %ecx ; oldstack
  movl 8(%esp), %edx ; newstack
  pushl %ebp
  pushl %ebx
  pushl %esi
  pushl %edi
  movl %esp, (%ecx)
  movl %edx, %esp
  popl %edi
  popl %esi
  popl %ebx
  popl %ebp
  retl

Code: Select all

extern const char start_thread[]; /* why declare it as a function when you can't call it? */
struct task *task_create(void (*entry)(void *), void *arg, size_t stack_size) {
  stack_size = (stack_size + 15) & -16; /* stack alignment is 16 bytes */
  char *stack = kalloc(stack_size + sizeof (struct task));
  struct task *new = (void *)(stack + stack_size);
  uint32_t *ctx = (uint32_t *)new - 5;
  ctx[0] = (uint32_t) entry; // edi
  ctx[1] = (uint32_t) arg; // esi
  ctx[2] = 0; // ebx
  ctx[3] = 0; // ebp
  ctx[4] = (uint32_t) start_thread; // return pointer
  new->stack_top = ctx;
  return new;
}

Code: Select all

start_thread:
  ; when we get here, EDI = entry pointer and ESI = argument and EBP = 0, so we don't need to clear it
  andl $-16, %esp
  subl $12, %esp
  pushl %esi
  calll *%edi
  call exit_thread
  ud2

Code: Select all

(higher stack addresses)
- address of start_thread
- 0 (ebp)
- 0 (ebx)
- arg   (edi)
- entry (esi)
(lower stack addresses)

Code: Select all

andl $-16, %esp    // align stack to 16 bytes
subl $12, %esp     // move the stack 12 bytes lower (*)
pushl %esi         // set up the argument pointer for the entry function
calll *%edi        // jump to the entry point