OSDev.org

Velko wrote:What about not returning from exit syscall? Switch away from task immediately and never return to it.

Something like:
User task#1 calls exit(0);
Exit interrupt
System adds task#1 to remove queue
System switches to task#2.
Interrupt return (into task#2)
Task's#2 code...
IRQ0 (another task switch)
Task#1 gets removed, system switches to task#3.
Interrupt return
Task's#3 code...

Agola wrote: This is a good way to exit also, but again the systemcall handler doesn't pass the interrupt frame to exit, so I can't edit it from syscall_exit.
Should I build the interrupt frame myself and do an iret? (Same way with switching to user mode)

JAAman wrote:

Agola wrote: This is a good way to exit also, but again the systemcall handler doesn't pass the interrupt frame to exit, so I can't edit it from syscall_exit.
Should I build the interrupt frame myself and do an iret? (Same way with switching to user mode)

I think you are getting a little confused here...

all your exit syscall should do is:

add task to your remove_task queue
JMP to the scheduler to schedule the next task (this, of course, never returns, since the task is never re-scheduled)

the code that changes tasks here is:
the same code that changes tasks on irq0
the same code that changes tasks whenever the code calls a blocking syscall
the same code that changes tasks when you get an interrupt from the HDD
the same code that changes tasks when... any time you change tasks

therefore, there is nothing special you have to do, because it happens automatically -- the only difference between the exit syscall calling the scheduler and the irq0 handler calling the scheduler is that the task is never rescheduled after the exit syscall, and therefore the code never continues

edit:
actually, I would make a function that moves the current task to the remove queue and then calls SwitchThread() without returning... so that function (which I would consider part of the scheduler) would never return at all and all your exit function has to do to terminate the task is call SchedulerTerminateTask()

void task_handler(registers_t* regs)
{
    memcpy(current_task->regs, regs, sizeof(registers_t));

    if (!current_task->next || remove_queue) current_task = first_task;
    else current_task = current_task->next;

    while (remove_queue)
    {
        rq_task_t* rq_task = remove_queue;
        remove_queue = remove_queue->next;

         task_t* current = first_task;
         while (current->next != rq_task->task) current = current->next;

         current->next = rq_task->task->next;

         clean_task(rq_task->task);
    }

    memcpy(regs, current_task->regs, sizeof(registers_t));

    // asm volatile ("xchgw %bx, %bx"); (Bochs' magic break)
}

void tasking_install()
{
    first_task = create_task(&kernel_idle, 0);

    first_task->pid = 0;
    first_task->name = "KERNEL_IDLE";
    first_task->priority = PRIORITY_MID;

    current_task = first_task;

    set_kernel_stack((uintptr_t)memalign(0x10, 0x1000) + 0x1000);

    // asm volatile ("xchgw %bx, %bx"); (Bochs debugger breakpoint)

    asm volatile ("  \
        cli; \
        movl %%bx, %%ax; \
        movl %%ax, %%ds; \
        movl %%ax, %%es; \
        movl %%ax, %%fs; \
        movl %%ax, %%gs; \
    " : : "b"(first_task->regs->ds));

    asm volatile ("  \
        pushl %%eax; \
        pushl %%ebx; \
        pushl %%ecx; \
        pushl %%edx; \
        pushl %%edi; \
        iretl; \
    " : : "a"(first_task->regs->ss), "b"(first_task->regs->esp), "c"(first_task->regs->eflags), "d"(first_task->regs->cs), "D"(first_task->regs->eip));
}

Syscall is an interrupt, so processor pushes ss, esp, eflags, cs and eip.
Then I switch another task in half of interrupt handler, without clearing them.

Velko wrote:

Syscall is an interrupt, so processor pushes ss, esp, eflags, cs and eip.
Then I switch another task in half of interrupt handler, without clearing them.

And then you proceed to return to that second task. And pop out the register values in the process.

• save current register frame (processor does part of it, you may want to push more registers "manually")
• do some stuff in kernel
• return to userspace (pop off what you pushed "manually", iret takes care of the rest).

• save current register frame (processor does part of it, you may want to push more registers "manually")
• do some stuff
• decide that you need to switch to task_2
• store current register frame in task_1->regs
• load current register frame from task_2->regs
• do some housekeeping (mark task_2 as currently active), maybe switch address spaces
• return to userspace (pop off what you pushed "manually", iret takes care of the rest).

• yield - a syscall where thread voluntarly gives up its timeslice. Simple, great as an exercise, but won't be used much once your OS matures;
• sleep - thread wants to be suspended for a period of time. What should processor do? Also sleep or run code in another task?
• write() on pipe to another process. Again, you block current task until read() is completed at the other end of that pipe.

Velko wrote:For a moment forget about exit() syscall. Once you get everything else right, it becomes a simple switch away and never return (and clean up at some point).

Correct implementation of many syscalls requires them to switch tasks. Some examples:

• yield - a syscall where thread voluntarly gives up its timeslice. Simple, great as an exercise, but won't be used much once your OS matures;
• sleep - thread wants to be suspended for a period of time. What should processor do? Also sleep or run code in another task?
• write() on pipe to another process. Again, you block current task until read() is completed at the other end of that pipe.

I see, your main objection is about passing pointer to registers_t into syscall handlers. I can understand that - it messes up code clarity a bit. You will need to figure out another way how to initiate task reschedule then.

My scheduler is completely a part of IRQ0, that makes calling scheduler harder when I want.

uintptr_t syscall = (uintptr_t) syscalls[regs->eax];
if (!syscall) return;

syscall_t call = (syscall_t) syscall;
int needs_reschedule = 0;
uint32_t ret = call(&needs_reschedule, regs->ebx, regs->ecx, regs->edx, regs->esi, regs->edi);
if (needs_reschedule) call_scheduler(regs);

int sys_yield(int *needs_reschedule)
{
    *needs_reschedule = 1;
    return 0;
}