First, decide if you're going to use hardware task switching or software task switching.GLneo wrote:hi all, ok im back and ready for multi-tasking, i understand that tss is for storing a tasks state but how? do i, at a switch, push all registers on a stack pointing to my tss table, then move stack pointer to new table, pop registers + iret???, thx
When you do software task switching, you use the TSS only to tell the processor what kernel stack pointer and segment to use when it makes a ring3->ring0 transition. You save registers elsewhere.GLneo wrote: i'm going for software task switching, but what do you mean 1 place to store all those redgisters???
Ahh - with software task switching you don't store all the registers in the TSS.GLneo wrote:i'm going for software task switching, but what do you mean 1 place to store all those redgisters???
Code: Select all
switch_tasks:
pushad
pushfd
cli
<push segment registers if necessary>
<store ESP in the previous task's Task Structure>
<get new task's CR3 from it's Task Structure>
<change address spaces if necessary>
<get new task's ESP from it's Task Structure>
<switch to the new task's stack>
<pop segment registers if necessary>
popfd
popad
retCode: Select all
switch_tasks:
pushad
pushfd
cli
<push segment registers if necessary>
<store ESP in previous task's task structure>
<get new task's CR3 from it's task structure>
<change address spaces if necessary>
<get new task's top of CPL=0 stack address from it's task structure>
<set ESP0 in the TSS for the new task>
<get new task's ESP from it's task structure>
<switch to the new task's stack>
<pop segment registers if necessary>
popfd
popad
retCode: Select all
struct task_state
{
unsigned int eax;
unsigned int ebx;
unsigned int ecx;
unsigned int edx;
unsigned int edi;
unsigned int esi;
unsigned int cs;
unsigned int eflags;
unsigned int eip;
unsigned int esp;
};
struct task_data
{
unsigned char name[32]
unsigned int esp;
unsigned int time;
unsigned int priority;
struct task_state *state;
};
unsigned int create_task(void (*function)(), unsigned int priority)
{
struct task_data *new_task = (struct task_data *)malloc(sizeof(struct task_data));
new_task[0].esp = getesp();
new_task[0].time = 10;
new_task[0].task_priority = priority;
new_task[0].state = (struct task_state *)malloc(sizeof(struct task_state));
new_task[0].state->eax = 0;
new_task[0].state->ebx = 0;
new_task[0].state->ecx = 0;
new_task[0].state->edx = 0;
new_task[0].state->edi = 0;
new_task[0].state->esi = 0;
new_task[0].state->cs = 0x8;
new_task[0].state->eflags = 0x202;
new_task[0].state->eip = (unsigned)function;
new_task[0].state->esp = (unsigned int)new_task[0].state;
return (unsigned int) new_task;
}
The key to doing the task switch is swapping from one task's stack to another task's stack (everything else, like changing address spaces, etc, can be added to this after it works).GLneo wrote:but how do i put it together???, what do i do at a switch???
And this is why you don't use a do_task_switch() function if you're writing your OS in C.Brendan wrote:You would also need to be very careful with C's stack frames, input parameters and local variables (unless you do the entire task switch routine in assembly). The reason for this is that the input parameters and local variables will be on the previous task's stack, which you'd stop using half way through the task switch.
To complicate this the compiler's optimizer may store some of these values in the CPUs registers, so that after switching stacks you won't know which input parameters and local variables are still current, and you won't be able to rely on tested behaviour because it could change every time the code is changed (or the compiler/optimizer's settings, or the compiler itself).
Code: Select all
_irq0:
cli
push byte 0
push byte 32
jmp irq
Code: Select all
irq:
pusha
push ds
push es
push fs
push gs
mov ax, 0x10
mov ds, ax
mov es, ax
mov fs, ax
mov gs, ax
mov eax, esp
push eax
mov eax, _irq_handler
call eax
pop eax
pop gs
pop fs
pop es
pop ds
popa
add esp, 8
iret
Code: Select all
void irq_handler(struct registers *r)
{
void (*handler)(struct registers *r);
handler = irq_pointers[r->int_no - 32];
if (handler)
{
handler(r);
}
if (r->int_no >= 40)
{
outport(0xA0, 0x20);
}
outport(0x20, 0x20);
}
Code: Select all
void timer_handler()
{
if(cur_task_time() > 0)
{
dec_cur_task_time();
if(cur_task_time() < 1)
schedule();
}
}
Code: Select all
if (r->int_no >= 40)
{
outport(0xA0, 0x20);
}
outport(0x20, 0x20);
}
Code: Select all
irq:
pusha
push ds
push es
push fs
push gs
mov ax, 0x10
mov ds, ax
mov es, ax
mov fs, ax
mov gs, ax
mov eax, esp
push eax
mov eax, _irq_handler
call eax
pop eax
pop gs
pop fs
pop es
pop ds
popa
add esp, 8
iret