OSDev.org

Code: Select all

section .text
global switch_context

switch_context:
    push ebx
    push esi
    push edi
    push ebp
 
    mov edi,[now_executed]    ;edi = address of the previous task's "thread control block"
    mov [edi + TCB.esp],esp         ;Save ESP for previous task's kernel stack in the thread's TCB
 
    ;Load next task's state
 
    mov esi,[esp+(4+1)*4]         ;esi = address of the next task's "thread control block" (parameter passed on stack)
    mov [now_executed],esi    ;Current task's TCB is the next task TCB
 
    mov esp,[esi + TCB.esp]         ;Load ESP for next task's kernel stack from the thread's TCB
    mov eax,[esi + TCB.pgd]         ;eax = address of page directory for next task
    mov ebx,[esi + TCB.esp0]        ;ebx = address for the top of the next task's kernel stack
    mov [TSS + TSS_struc.esp0],ebx   ;Adjust the ESP0 field in the TSS (used by CPU for for CPL=3 -> CPL=0 privilege level changes)
    mov ecx,cr3                   ;ecx = previous task's virtual address space
 
    cmp eax,ecx                   ;Does the virtual address space need to being changed?
    je .doneVAS                   ; no, virtual address space is the same, so don't reload it and cause TLB flushes
    mov cr3,eax                   ; yes, load the next task's virtual address space
.doneVAS:
    pop ebp
    pop edi
    pop esi
    pop ebx
 
    ret                           ;Load next task's EIP from its kernel stack

Code: Select all

switch_context(&(task));

Code: Select all

void prepare_task(task_struct_t task, uint32_t eip) {
    uint32_t esp;
    asm volatile (
        "movl %%esp, %0"
        : "=r"(esp)
    );

    asm volatile (
        "mov %0, %%esp\n"
        "pushl %1\n"
        "push %%ebp\n"
        "push %%edi\n"
        "push %%esi\n"
        "push %%ebx\n"
        "movl %2, %%esp\n"
        :
        : "r"(task.esp), "r"(eip), "r"(esp)
    );
}

Code: Select all

void prepare_task(task_struct_t * task, uint32_t eip) {
    uint32_t * stack = (uint32_t *)task->esp;
    stack[-1] = eip;
    task->esp -= 5 * sizeof( uint32_t );
}

Code: Select all

task_struct_t create_kernel_task() {
    uint32_t esp, eip;
    asm volatile (
        "movl %%esp, %0\n"
        "call get_eip\n"
        "get_eip:\n"
        "pop %1\n"
        : "=r"(esp), "=r"(eip)
    );

    task_struct_t task = create_task(esp, TASK_EXEC_KERNEL);
    task.memory_map.pgd = page_directory;
    task.state = TASK_STATE_WAITING;
    task.exec_mode = TASK_EXEC_KERNEL;

    prepare_task(task, eip);
    return task;
}

Code: Select all

void Task::Initialize(EntryPoint entryPoint, const void* args)
{
    const char* stack = (char*)GetStack();

    // We use an InterruptContext to "return" to the task's entry point. The reason we can't only use a CpuContext
    // is that we need to be able to set arguments for the entry point. These need to go in registers (rdi, rsi, rdx)
    // that aren't part of the CpuContext.
    constexpr auto interruptContextSize = sizeof(InterruptContext);
    stack = stack - mtl::AlignUp(interruptContextSize, 16);

    const auto interruptContext = (InterruptContext*)stack;
    interruptContext->rip = (uintptr_t)Task::Entry;                    // "Return" to Task::Entry
    interruptContext->cs = (uint64_t)Selector::KernelCode;             // "Return" to kernel code
    interruptContext->rflags = mtl::EFLAGS_RESERVED;                   // Start with interrupts disabled
    interruptContext->rsp = (uintptr_t)(stack + interruptContextSize); // Required by iretq
    interruptContext->ss = (uint64_t)Selector::KernelData;             // Required by iretq
    interruptContext->rdi = (uintptr_t)this;                           // Param 1 for Task::Entry
    interruptContext->rsi = (uintptr_t)entryPoint;                     // Param 2 for Task::Entry
    interruptContext->rdx = (uintptr_t)args;                           // Param 3 for Task::Entry

    // Setup a task switch interruptContext to simulate returning from an interrupt.
    stack = stack - sizeof(CpuContext);

    const auto cpuContext = (CpuContext*)stack;
    cpuContext->rip = (uintptr_t)InterruptExit;

    m_context = cpuContext;
}

void Task::Entry(Task* task, EntryPoint entryPoint, const void* args)
{
    task->m_state = TaskState::Running;
    entryPoint(task, args);

    // TODO: die
    for (;;)
        ;
}

Code: Select all

  if (setjmp(currentthread->context)==0) {
    longjmp(nextthread->context, 1);
  }