OSDev.org

Code: Select all

u32int next_thread_id = 1;
volatile thread_t *current_thread = 0;

void new_stack(thread_t *thread, u32int current_esp, u32int current_ebp)
{
	u32int size, offset, new_stack_start, i;
	size = current_thread->stack_start - current_esp;
	thread->stack = (u32int)malloc(0x2000); // reserve 8192 bytes for stack
	// start of stack is at _end_ of allocation
	new_stack_start = thread->stack + 0x2000;
	offset = new_stack_start - current_thread->stack_start;
	// find the esp and ebp for the new stack
	thread->stack_start = new_stack_start;
	thread->esp = current_esp + offset;
	thread->ebp = current_ebp + offset;
	// copy over the old stack to the new one
	memcpyd((u32int*)thread->esp, (u32int*)current_esp, size);
	u32int *tmp;
	for (tmp = thread->esp; tmp <= thread->stack_start; tmp++)
	{
		if (*tmp < current_thread->stack_start && *tmp > current_esp)
		{
			*tmp += offset;
		}
	}
	thread->stack_start = new_stack_start;
	thread->stack_size = size;
}
void threads_install()
{
	u32int esp, ebp;
	current_thread = (thread_t*)malloc(sizeof(thread_t));
	current_thread->stack_start = initial_esp;
	asm volatile("mov %%esp, %0" : "=r"(esp));
	asm volatile("mov %%ebp, %0" : "=r"(ebp));
	new_stack(current_thread, esp, ebp);
	asm volatile("mov %0, %%esp" :: "r"(current_thread->esp));
	asm volatile("mov %0, %%ebp" :: "r"(current_thread->ebp));
	current_thread->id = next_thread_id++;
	current_thread->status = 0;
	current_thread->next = current_thread;
	current_thread->previous = current_thread;
	current_thread->priority = 20;
	current_thread->counter = 20;
}
u32int fork()
{   // make new thread
	__asm__ __volatile__("cli");
	thread_t *parent_thread = (thread_t*)current_thread;
	thread_t *new_thread = (thread_t*)malloc(sizeof(thread_t));
	new_thread-> id = next_thread_id++;
	new_thread->next = parent_thread->next;
	new_thread->next->previous = new_thread;
	parent_thread->next = new_thread;
	new_thread->previous = parent_thread;
	new_thread->priority = parent_thread->priority;
	new_thread->counter = new_thread->priority;
	new_thread->status = 1; // ready
	current_thread->counter = 0;
	switch_thread(); // force switch to new thread
	__asm__ __volatile__("sti");
	if (current_thread == parent_thread)
		return new_thread->id;
	return 0;
}
void switch_thread()
{
	if (current_thread->counter)
	{
		current_thread->counter--;
		return;
	}
	
	if (current_thread->next == current_thread) return;
	// reset counter
	current_thread->counter = current_thread->priority;
	// get stack
	u32int esp, ebp;
	asm volatile("mov %%esp, %0" : "=r"(esp));
	asm volatile("mov %%ebp, %0" : "=r"(ebp));
	// save stack
	current_thread->esp = esp;
	current_thread->ebp = ebp;
	// advance current_thread
	thread_t *working_thread = current_thread;
	do
	{
		working_thread = working_thread->next;
		switch (working_thread->status)
		{
			case 1: // ready
				new_stack(working_thread, esp, ebp);
				working_thread->status = 0;
			break;
			case 3: // zombie
				working_thread->previous->next = working_thread->next;
				working_thread->next->previous = working_thread->previous;
				free(working_thread->stack);
				free(working_thread);
			break;
		}
	}
	while (working_thread->status);
	current_thread = working_thread;
	// switch stack
	esp = current_thread->esp;
	ebp = current_thread->ebp;
	/// CRASH ///
	__asm__ __volatile__("mov %0, %%esp" :: "r"(esp));
	__asm__ __volatile__("mov %0, %%ebp" :: "r"(ebp));
}
void exit()
{
	current_thread->status = 3; // zombie
	current_thread->counter = 0;
	switch_thread();
	panic("Failed to kill thread\n");
}
u32int get_pid()
{
	return current_thread->id;
}

Code: Select all

   esp = current_thread->esp;
   ebp = current_thread->ebp;
   /// CRASH ///
   __asm__ __volatile__("mov %0, %%esp" :: "r"(esp));
   __asm__ __volatile__("mov %0, %%ebp" :: "r"(ebp));