OSDev.org

Code: Select all

irq0 --> irq_0_handler --> k_switch_task --> start_kthread
                                        |
                                        |--> swap_kthread_regs --> ir0 --> iret (page fault somewhere in here)

Code: Select all

.global resume_irq0 # allow register swapper proc to jump back to irq0

irq_0:
	pushal
	pushfl
	call irq_0_handler
	popfl
	popal
resume_irq0:
	iret

Code: Select all

void irq_0_handler(
	uint32_t eflags,
	uint32_t edi,
	uint32_t esi,
	uint32_t ebp,
	uint32_t esp,
	uint32_t ebx,
	uint32_t edx,
	uint32_t ecx,
	uint32_t eax
)
{
	if (ticks > 0)
		ticks--;

	main_ticks++;

	// Send the EOI before doing task switch logic
	// since we don't normally return from a task switch.
	k_outb(0x20, 0x20);

	// Here is where we initiate a task switch
	if (main_ticks % 2000 == 0)
	{
		k_switch_task(eflags,
			edi,
			esi,
			ebp,
			esp,
			ebx,
			edx,
			ecx,
			eax);
	}
}

Code: Select all

void k_switch_task(uint32_t eflags,
	uint32_t edi,
	uint32_t esi,
	uint32_t ebp,
	uint32_t esp,
	uint32_t ebx,
	uint32_t edx,
	uint32_t ecx,
	uint32_t eax)
{
    // If there is no current task,
    // then tasking has not yet been initialized.
    if (current_task == NULL)
        return;
        
    // Update the stored CPU state of the current task.
    current_task->eflags = eflags;
    current_task->edi = edi;
    current_task->esi = esi;
    current_task->ebp = ebp;
    current_task->esp = esp;
    current_task->ebx = ebx;
    current_task->edx = edx;
    current_task->ecx = ecx;
    current_task->eax = eax;

    // Alternate between task a and task b.
    switch (current_task->id)
    {
        case 2:
            current_task = &task_b;
            break;

        case 1:
        case 3:
            current_task = &task_a;
            break;

        default:
            break;
    }

    // If the current task is new, start it.
    if (current_task->status == TASK_NEW)
    {
        current_task->status = TASK_RUNNING;

        start_kthread(
            current_task->esp,
            current_task->ebp,
            current_task->start
        );

        return;
    }

    // Swap the registers. (jumps to irq0)
    swap_kthread_regs(
        current_task->eflags,
        current_task->edi,
        current_task->esi,
        current_task->ebp,
        current_task->esp,
        current_task->ebx,
        current_task->edx,
        current_task->ecx,
        current_task->eax
    );
}

Code: Select all

# Starts a kernel thread.
# Updates esp and ebp, then calls the start function.
#
# Params:
#   8(%ebp)  - the new esp value
#   12(%ebp) - the new ebp value
#   16(%ebp) - the address of the starting function
#
start_kthread:
    
    pushl %ebp
    movl %esp, %ebp
    subl $8, %esp

    movl 8(%ebp), %eax
    movl %eax, -4(%ebp)  # temporarily store esp

    movl 12(%ebp), %eax
    movl %eax, -8(%ebp)  # temporarily store ebp

    movl 16(%ebp), %ecx  # put the address of the start function in ecx

    movl -4(%ebp), %esp  # update esp
    movl -8(%ebp), %ebp  # update ebp

    sti                  # enable interrupts
    call *%ecx           # call the start function
    
    leave
    ret

Code: Select all

# Populates the registers with the values from the next task.
# This procedure is only called while handling IRQ0, so after
# loading the register values, it jumps to IRQ0.
#
# Params:
#   8(%ebp)  - eflags
#   12(%ebp) - edi
#   16(%ebp) - esi
#   20(%ebp) - ebp
#   24(%ebp) - esp
#   28(%ebp) - ebx
#   32(%ebp) - edx
#   36(%ebp) - ecx
#   40(%ebp) - eax
#
swap_kthread_regs:

	 movl %esp, %ebp
    subl $12, %esp

    movl 8(%ebp), %eax
    movl %eax, -4(%ebp)  # temporarily store eflags

    movl 20(%ebp), %eax
    movl %eax, -8(%ebp)  # temporarily store ebp

    movl 24(%ebp), %eax
    movl %eax, -12(%ebp) # temporarily store esp

    movl 12(%ebp), %edi  # update edi
    movl 16(%ebp), %esi  # update esi

    movl 28(%ebp), %ebx  # update ebx
    movl 32(%ebp), %edx  # update edx
    movl 36(%ebp), %ecx  # update ecx
    movl 40(%ebp), %eax  # update eax

    pushl -4(%ebp)
    popfl                # update eflags

    movl -12(%ebp), %esp # update esp
    movl -8(%ebp), %ebp  # update ebp

    jmp resume_irq0      # resume IRQ0

Code: Select all

void task_a_action()
{
    for(;;)
    {
        printf("This is task a.\n");
    }
}

Code: Select all

void task_b_action()
{
    for(;;)
    {
        printf("This is task b.\n");
    }
}

Code: Select all

irq_0:

	pushal
	call irq_0_handler

	cmp $0, %eax      # check if there has been a task switch
	jz end_irq_0      # if there was no task switch, jump to the end

	addl $44, %esp    # discard the old registers

	# push the new registers onto the stack

	pushl 36(%eax)    # save esp for updating later

	pushl 8(%eax)     # eflags
	pushl 12(%eax)    # cs
	pushl 16(%eax)    # eip
	pushl 20(%eax)    # eax
	pushl 24(%eax)    # ecx
	pushl 28(%eax)    # edx
	pushl 32(%eax)    # ebx
	pushl 36(%eax)    # esp
	pushl 40(%eax)    # ebp
	pushl 44(%eax)    # esi
	pushl 48(%eax)    # edi

	popal
	popl %esp         # update esp using the value we stored earlier (I get a general protection fault if I do this)
	jmp end_task_switch

end_irq_0:
	popal
	
end_task_switch:
	iret

Code: Select all

irq_0:

	pushal             # Store GPRs on the stack. This pushes the value of esp before pusha was executed.
	pushl %esp         # Store value of esp after pushing GPRs.
	call irq_0_handler
	movl %eax, %esp    # Update esp to point to the stack of the next task.
	popal              # Retrieve the GPR values of the next task.
	iret

Code: Select all

// C function
void store_value(uint32_t val)
{
    data_storage->x = val;
}

# Assembly procedure (prologue and epilogue omitted)
abi_test:
    movl $4, %eax
    pushl %eax
    call store_value

Code: Select all

irq_0:

	pushal
	call irq_0_handler

	# Update the esp
	movl 36(%eax), %esp

	# Rebuild the ISR stack (assumes no CPL change)
	addl $12, %esp
	pushl 8(%eax)  # eflags
	pushl 12(%eax) # cs
	pushl 16(%eax) # eip

	# push the GPRs from the next task onto the stack
	pushl 20(%eax) # eax
	pushl 24(%eax) # ecx
	pushl 28(%eax) # edx
	pushl 32(%eax) # ebx
	pushl 36(%eax) # esp
	pushl 40(%eax) # ebp
	pushl 44(%eax) # esi
	pushl 48(%eax) # edi

	popal
	iret

Code: Select all

void irq_0_handler(
	uint32_t eflags,
	uint32_t edi,
	uint32_t esi,
	uint32_t ebp,
	uint32_t esp,
	uint32_t ebx,
	uint32_t edx,
	uint32_t ecx,
	uint32_t eax
)

Code: Select all

pusha          # push some registers onto the stack (max pushes individual registers and does some segment switching, I just pusha for now)
push esp       # push the latest esp value onto the stack
switch task    # returns new esp
mov %eax, %esp # update esp
popa           # pop the registers of the next task off the stack
iret           # pop the ISR stack

Code: Select all

// address types
typedef uint32_t g_address;
typedef g_address g_physical_address;
typedef g_address g_virtual_address;
typedef uint32_t g_far_pointer;

/**
 * Image of the stack on interrupt
 */
struct g_processor_state
{
	// Pushed by the interrupt request/routine handler
	uint32_t gs;
	uint32_t fs;
	uint32_t es;
	uint32_t ds;

	uint32_t eax;
	uint32_t ecx;
	uint32_t edx;
	uint32_t ebx;
	uint32_t ebp;
	uint32_t esi;
	uint32_t edi;

	// Pushed by ISR handler if available
	uint32_t intr;
	uint32_t error;

	// Pushed by the processor
	uint32_t eip;
	uint32_t cs;
	uint32_t eflags;

	// Only pushed/popped on Ring 3 <-> Ring 0 switches
	uint32_t esp;
	uint32_t ss;
}__attribute__((packed));



interruptRoutine (assembly procedure, Intel syntax):

    push registers
	push esp
	
	_interruptHandler (C function that returns esp):
	{
	
		taskingStore (C function):
		{
			cast esp as pointer to register struct (g_processor_state*)
			update register struct of current task
		}
			
		requestsHandle (C function):
		{
			select next task
		}
			
		taskingRestore (C function):
		{
			cast g_processor_state pointer of next task as uint32_t (g_virtual_address)
			this uint32_t value is now considered the esp of the next task
		}
	
		return esp of next task
	}
	
	# eax now contains the esp value of the next task
	mov esp, eax
	
	pop registers
	
	# skip over the intr and error fields of the g_processor_state struct
	# esp now should point to the ISR stack of the next task (eflags, cs, eip, ...)
	add esp, 8
	
	# pop the ISR stack
	iret

Code: Select all

// register struct
typedef struct k_task{
    uint32_t id;
    uint32_t status;
    uint32_t eflags;
    uint32_t cs;
    uint32_t eip;
    uint32_t eax;
    uint32_t ecx;
    uint32_t edx;
    uint32_t ebx;
    uint32_t esp;
    uint32_t ebp;
    uint32_t esi;
    uint32_t edi;
    
    struct k_task* next;
    void (*start)();
    
}__attribute__((packed))k_task;

Code: Select all

# ISR entry point for IRQ0
irq_0:
	pushal             # push all GPRs
	pushl %esp         # push the current esp
	call irq_0_handler # handle timer and store ISR stack, GPRs, and esp of current task 
	movl %eax, %esp    # update esp
	popal              # pop all GPRs of the next task
	iret               # pop the ISR stack of the next task

Code: Select all

// handle IRQ0
uint32_t irq_0_handler(
	uint32_t real_esp, // This points to the stack that contains the GPRs on top of the ISR stack
	uint32_t edi,
	uint32_t esi,
	uint32_t ebp,
	uint32_t esp, // This value is ignored, since it contains the value of esp before pusha was executed
	uint32_t ebx,
	uint32_t edx,
	uint32_t ecx,
	uint32_t eax,
	uint32_t eip,
	uint32_t cs,
	uint32_t eflags
)
{
	// Increment the tick count.
	// We don't have synchronization primitives yet,
	// so for now this is used to determine whether we should switch tasks.
	main_ticks++;

	// Send the EOI.
	k_outb(0x20, 0x20);

	// Update the ISR stack, GPRs, and esp of the current task.
	// Select the next task.
	k_task* task = k_switch_task(
		main_ticks,
		real_esp,
		edi,
		esi,
		ebp,
		esp,
		ebx,
		edx,
		ecx,
		eax,
		eip,
		cs,
		eflags
	);
	
	// Return the esp of the next task.
	return task->esp;
}

Code: Select all

// select the next task
k_task* k_switch_task(
	uint32_t main_ticks,
	uint32_t real_esp,
	uint32_t edi,
	uint32_t esi,
	uint32_t ebp,
	uint32_t esp,
	uint32_t ebx,
	uint32_t edx,
	uint32_t ecx,
	uint32_t eax,
	uint32_t eip,
	uint32_t cs,
	uint32_t eflags
)
{
    // Use the esp parameter since ignoring it causes a warning.
	 // Yes, this is silly. I'll improve the CPU state transition later.
    if (esp){}

    // If there is no current task,
    // then tasking has not yet been initialized.
    if (current_task == NULL || initialized == 0)
    {
        fprintf(stddbg, "tasking has not yet been initialized\n");
        return NULL;
    }

    // Update the stored CPU state of the current task.
    current_task->edi = edi;
    current_task->esi = esi;
    current_task->ebp = ebp;
    current_task->esp = real_esp;
    current_task->ebx = ebx;
    current_task->edx = edx;
    current_task->ecx = ecx;
    current_task->eax = eax;
    current_task->eip = eip;
    current_task->cs = cs;
    current_task->eflags = eflags;

    // If it's not time to switch tasks,
    // return the current task.
    if (main_ticks % 2000 != 0)
        return current_task;

    // Alternate between the three kernel threads.
    switch (current_task->id)
    {
        case 2:
            current_task = &task_b;
            break;

        case 1:
            current_task = &task_a;
            break;

        case 3:
            current_task = &main_task;
            break;

        default:
            break;
    }

    // If the current task is new, start it.
    if (current_task->status == TASK_NEW)
    {
        current_task->status = TASK_RUNNING;

		 // TODO: figure out a better way to start a task.
        start_kthread(
            current_task->esp,
            current_task->ebp,
            current_task->start
        );

		// For now, all the threads contain infinite loops,
		// so they should never terminate of their own accord.
		// TODO: implement proper thread termination.
        return NULL;
    }

    return current_task;
}

Code: Select all

# start a new task
start_kthread:
    
    pushl %ebp
    movl %esp, %ebp
    subl $8, %esp

    movl 8(%ebp), %eax
    movl %eax, -4(%ebp) # store esp

    movl 12(%ebp), %eax
    movl %eax, -8(%ebp) # store ebp

    movl 16(%ebp), %ecx # put the address of the start function in ecx

    movl -4(%ebp), %esp # update esp
    movl -8(%ebp), %ebp # update ebp

    sti                 # enable interrupts
    call *%ecx          # call the start function
    
    leave
    ret