OSDev.org

AR wrote:Why exactly do you need more than one return value? I usually use "void" as the return value for the C function to the interrupt stub, I don't see what exactly you're referring to.

AR wrote:I believe the one return value is built on the mathematical principles of an algebraic equation. eg: m = f(b), m = a + 3b + 2. In maths there is always only one result from an equation, all languages that I know which are higher than assembly seem to be built on this principle which basically means that any and all algorithms can be broken down to components that will only require 1 return value. Of course in computers there are more than just numbers (strings, images) but the instances where multiple return values are absolutely necessary don't come around that often.

long int strtol (const char *restrict string, char **restrict tailptr, int base);

FILE * fopen (const char *filename, const char *opentype);

 _task_timer
    cld
    pushad
    push ds
    push es
    push fs
    push gs

    ;Load new segment registers here???

    call _timer_handler

    mov al,0x20                      ;Do the EOI
    out 0x20,al

    call _do_task_switch

    pop gs
    pop fs
    pop es
    pop ds
    popad
    iretd


;Note: Registers must be saved on the stack, and interrupt must be disabled
;      before calling this routine.

_do_task_switch:
    mov eax,[current_task_pointer]   ;eax = address of current task structure
    mov ebx,[next_task_pointer]      ;ebx = address of new task structure
    cmp eax,ebx                      ;Is a task switch needed?
    je .doneTaskSwitch               ; no, skip it

    mov [eax],esp                    ;Save ESP in the current task structure
    mov esp,[eax]                    ;Load ESP from the new task structure
    mov ebx,[eax+TASK_ESP0]          ;Get ESP0 from the new task structure
    mov [sys_tss+TSS_ESP0],ebx       ;Set ESP0 in the TSS for the new task
    mov [current_task_pointer],ebx   ;The new task is now the current task
.doneTaskSwitch:
    ret

GLneo wrote:it would get the kernel stack but how do i put that for later or how do i get it to do it only the first time???

pusha ; Input parameters are saved on the stack here.
; etc....
; call C code to get the system timer tick...
call something...
mov esp, eax
; etc...
popa ; Puts output parameters in the caller's registers.
iret

// Somewhere else...
TrapFrame* get_timer_tick( TrapFrame* callerRegs )
{
    uint32_t someParam = callerRegs->ebx;  // For example...
    ...
    callerRegs->eax = system_timer_tick; // Return value
    return callerRegs; // Don't switch to another task.
}

So far the only benefit mentioned for this method is that it allows system code to be written without caring where in the code any task switches might be done (by forcing the task switch to be postponed until kernel exit). This itself can cause problems with some kernel functions (e.g. terminate a task), and can make a mess of interrupt latency - if an IRQ handler interrupts a kernel function then both can't cause a task switch with any sanity, and you end up disabling interrupts while any kernel code is being run (the kernel itself can't be interruptable or pre-emptable).

Colonel Kernel wrote:Brendan, with all due respect, your advice on this matter confuses me. I think that it would also confuse newbies pretty badly.

Colonel Kernel wrote:First of all, why do you think you can't pass parameters to and from the kernel in registers just because you're using C?

kernel_API_entry_point:
    cmp edi,MAX_FUNCTION_NUMBER
    ja .function_not_defined_error

    pusha
    mov eax,esp
    call [kernel_API_function_table + edi * 4]
    cmp eax,esp
    jne .noTaskSwitch
    mov esp,eax
    ; if ? mov cr3,? (skipped - reason for the branch)
    ; fxload/fxsave or set TS flag (skipped - reason for the branch)
.noTaskSwitch:
    popa
    iret

.function_not_defined_error:
    mov eax,ERROR_FUNCTION_NOT_DEFINED
    iretd


_get_timer_tick:
    mov eax,[esp+4]             ;eax = address of callerRegs structure
    mov ebx,[system_timer_tick]
    mov [eax+callerRegs._EBX]
    ret

Colonel Kernel wrote:First, what problem with task termination are you seeing? You would just never switch to that task again, and de-allocate its kernel stack. I don't see a problem here.

Secondly, the bit about non-preemptability just isn't true either. It's true that you have to be choosy about switching tasks in an interrupt -- especially if you support nested interrupts. However, it's perfectly ok to switch tasks in the least-nested interrupt, even if it interrupt kernel code. You just have to make sure it didn't interrupt the scheduler or something else really critical.

Brendan wrote:You de-allocate the kernel stack and then use the de-allocated kernel stack to return to the assembly stub where the task switch occurs? Perhaps you mean that you return from the function, do a task switch and then something happens in the future that causes the kernel to de-allocate the kernel stack, or maybe the assembly stub itself de-allocates the kernel stack during the task switch or...?

How about the page fault handler - how does that work considering it might terminate the task or need file IO?

However, complex topics are complex by nature - IMHO it would be difficult for anyone to explain all options that can effect scheduling and scheduler design without at least a little confusion (which seems to include a little confusion of my own).

GLneo wrote: well what i meant was: do i need to pop kernel data at a timer handler so i can save data???, what i want to know is at the very first time my kernel ticks the data it pushes will be my kernel's data, how do i store that for latter popping???

GLneo wrote: well what i meant was: do i need to pop kernel data at a timer handler so i can save data???, what i want to know is at the very first time my kernel ticks the data it pushes will be my kernel's data, how do i store that for latter popping???

Colonel Kernel wrote:Complex topics are complex, but if you look closely enough they are really a set of interacting slightly-less complex topics. What's confused me a lot in the past is when I see a connection between two complex things where there really isn't a connection. In this case I think you connected C calling conventions with kernel calling conventions, which need not be related.

I will also assume that, for the kernel API, parameters are passed in registers through a software interrupt, which includes a "function number" that is used with a table to find the address of the kernel function to be executed. I'm making this assumption for a few reasons - it's almost exactly what Linux and my own OS does, and it's one of the cleanest, most efficient methods. I will also assume that all kernel functions return a 32 bit status code, such as "OK", "function not defined", "out of memory" or "time-out error". This is just my personal preference.

The application would need this code to use the function:

Code: Select all

Code:
  mov eax,GET_SYSTEM_TIMER_TICK
  mov ebx,ADDRESS_TO_STORE_STATUS
  mov ecx,ADDRESS_TO_STORE_TIMER_TICK
  int KERNEL_API_INTERRUPT
  cmp dword [ADDRESS_TO_STORE_STATUS],STATUS_OK
  jne .error
  mov eax,[ADDRESS_TO_STORE_STATUS]

GLneo wrote: nope still not what i meant, ok, all the tutorials i see they do this:

Code: Select all

push everything
mov esp, [kernel_esp]
pop everything; all kernels data
call task_switcher
push everything; kernels data
mov esp, [new_esp]
pop everthing
iret

but for the first time how do i get kernel data in the first place, so i can do things in the kernel, or am i just lost???, thx

GLneo wrote:

Code: Select all

 _task_timer
    cld
    pushad
    push ds
    push es
    push fs
    push gs
;    mov eax,[p] 
;    mov [eax],esp 
;    lea eax,[kstackend] 
;    mov esp,eax
    mov eax, _timer_handler
    call eax
;    mov eax,[p] 
;    mov esp,[eax] 
;    mov ebx,[eax+8]
;    mov [sys_tss+4],ebx
    mov al,0x20
    out 0x20,al
    pop gs
    pop fs
    pop es
    pop ds
    popad
    iretd

   %macro REG_SAVE 0
      ;save all registers in the kernel-level stack of the process and switch to the kernel stack
        cld
        pushad
        push ds
        push es
        push fs
        push gs
        mov eax,[p] ;put the adress of the struct of CURRENT PROCESS in eax.(the CONTENT of pointer p)
        mov [eax],esp ;save esp in the location of esp in the CURRENT PROCESS-STRUCT.
        lea eax,[kstackend] ; switch to the kernel's own stack.
        mov esp,eax
        %endmacro

Brendan wrote:I not sure I completely understand what the code is meant to do (hint: comments are good). For example, what are [p] and [kstackend], and what's at [sys_tss+4]?

The name [kstackend] makes me wonder if it's the "kernel stack top" and if you're intending to have a single kernel stack that's shared by all tasks (which may be reasonable, unless it's a monolithic kernel or you might want to support multiple CPUs one day). Even if you are intending to use a single kernel stack for all tasks, that isn't the way to do it (you need the data that is pushed on the stack to return to the task and it must not be overwritten, and you wouldn't need to reset ESP0 in the TSS).

GLneo wrote:

Code: Select all

push everything
mov esp, [kernel_esp]
pop everything; all kernels data

call task_switcher

push everything; kernels data
mov esp, [new_esp]
pop everthing

iret