OSDev.org

Code: Select all

static void timer_irq0(struct registers * r) {
    timer_tenths++;

    if(timer_tenths > 100) {
        Scheduler::next(r);
        timer_tenths = 0;
    }
}

Code: Select all

extern "C" struct registers * isr_handler(registers_t* registers) {
	if ((registers->isr_num >= IRQ0) && (registers->isr_num <= IRQ15)) { // IRQ
		if (registers->isr_num >= IRQ8) { // IRQ originated from the slave PIC
			outportb(PIC2_COMMAND, PIC_EOI);
		}
		outportb(PIC1_COMMAND, PIC_EOI);
	}

	if (isr_handlers[registers->isr_num] != 0) {
		isr_handlers[registers->isr_num](registers);
	}

	return registers;
}

Code: Select all

void Scheduler::next(registers* r) {
	if(!has_initialised) {
		memcpy(&base_state, r, sizeof(registers));
		has_initialised = true;
		return;
	}

	if(!thread_list[task_idx]->ran) {
		// if this is the first time the thread has been scheduled,
		// we need to initialize it's state register beforehand

		thread_list[task_idx]->state_reg.eflags = base_state.eflags;
		thread_list[task_idx]->state_reg.cs = base_state.cs;
		thread_list[task_idx]->state_reg.ss = base_state.ss;

		thread_list[task_idx]->ran = true;
	}


	int lastThread = task_idx - 1;

	if(task_idx == 0)
		lastThread = thread_list.size()-1;
	
	// save the previous threads state
	if(thread_list[lastThread]->ran) {
		memcpy(&(thread_list[lastThread]->state_reg), r, sizeof(registers));
	}

	// set the registers from the current thread's saved state
	memcpy(r, &(thread_list[task_idx]->state_reg), sizeof(registers));

	task_idx++;

	// Loop around 0 -> 1 -> 2 -> 0 -> ...
	if(task_idx >= thread_list.size()) {
		task_idx = 0;
	}
}

Code: Select all

class Thread {
public:
	size_t thread_id;
	registers state_reg;
	
	uintptr_t entry_ptr;
	
	bool ran;

	Thread() : ran(false) {}
};

Code: Select all

void start_thread(void_fn entry) {
	Thread* thread = new Thread();

	thread->thread_id = next_tid;

	thread->entry_ptr = reinterpret_cast<uintptr_t>(entry);

	thread->state_reg.eax = 0;
	thread->state_reg.ebx = 0;
	thread->state_reg.ecx = 0;
	thread->state_reg.edx = 0;

	thread->state_reg.esi = 0;
	thread->state_reg.edi = 0;

	thread_list.push_back(thread);

	next_tid++;
}

Code: Select all

   // save the previous threads state
   if(thread_list[lastThread]->ran) {
      memcpy(&(thread_list[lastThread]->state_reg), r, sizeof(registers));
   }

Code: Select all

	if(!thread_list[task_idx]->ran) {
		// if this is the first time the thread has been scheduled,
		// we need to initialize it's state register beforehand
		memcpy(&(thread_list[task_idx]->state_reg), &base_state, sizeof(registers));

		thread_list[task_idx]->state_reg.eflags = base_state.eflags;
		thread_list[task_idx]->state_reg.cs = base_state.cs;
		thread_list[task_idx]->state_reg.ss = base_state.ss;

		thread_list[task_idx]->state_reg.eip = (uint32_t)thread_list[task_idx]->entry_ptr;
		thread_list[task_idx]->ran = true;
	}

Code: Select all

void Scheduler::next(registers * r) {
	if(!thread_running->ran) {
		// if this is the first time the thread has been scheduled,
		// we need to initialize it's state register beforehand

		thread_running->state_reg.eflags = r->eflags;
		thread_running->state_reg.esp = r->esp;
		thread_running->state_reg.isr_num = 0;

		thread_running->state_reg.eip = (uint32_t)thread_running->entry_ptr;
	
		thread_running->ran = true;
	} 
	else {
		// save the previous threads state
		memcpy(&(thread_running->state_reg), r, sizeof(registers));
	}

	thread_running = thread_running->next;

	if(thread_running->ran) {
		bcprintf("\nthread: %s (%d)", thread_running->title, thread_running->thread_id);

		// set the registers from the current thread's saved state
		memcpy(r, &(thread_running->state_reg), sizeof(registers));	
	}
}

Code: Select all

void Scheduler::next(registers * r) {
	// save the previous threads state
	if(thread_running->ran) {
		memcpy(&(thread_running->state_reg), r, sizeof(registers));
	}

	// Lets move on with task switching!
	thread_running->ran = true;
	thread_running = thread_running->next;

	bcprintf("\nthread: %s (%d)", thread_running->title, thread_running->thread_id);
	// set the registers from the current thread's saved state
	memcpy(r, &(thread_running->state_reg), sizeof(registers));	
	
}

Code: Select all

thread stack pointer: 0xE0001168
thread stack pointer: 0xE00052F7
thread stack pointer: 0xE0009486

Code: Select all

Old stack pointer (saved): 0xE00052F7
New stack pointer (saved): 0xC010ED3C

Code: Select all

    ask_VFS_to_read_from_file();
    block_thread(reason);                // Wait for VFS and file system and whatever to read
                                         //  the file and unblock this thread
    status = process_results_from_VFS();
    return status;                       // Tell the thread that called this kernel API function what happened

Code: Select all

memcpy(&(thread_running->state_reg), r, sizeof(registers));

Code: Select all

set_stack_ptr(r->esp);

Code: Select all

global set_stack_ptr
set_stack_ptr:
	mov eax, [esp + 4]
	mov ebx, esp
	mov esp, eax

	mov ecx, 16
loop_stack:
	mov edx, [ebx + 4*ecx]
	push edx
	dec ecx
loop_bottom:
	cmp ecx, 1
	jne loop_stack

	ret

Code: Select all

   // save the previous threads state
   if(thread_running->ran) {
      memcpy(&(thread_running->state_reg), r, sizeof(registers));
   }

Code: Select all

   // Lets move on with task switching!
   thread_running->ran = true;
   thread_running = thread_running->next;

Code: Select all

   bcprintf("\nthread: %s (%d)", thread_running->title, thread_running->thread_id);
   // set the registers from the current thread's saved state
   memcpy(r, &(thread_running->state_reg), sizeof(registers));