OSDev.org

Code: Select all

int_00:
push es
push ds
push fs
push gs
pusha

call int_handler

popa
pop gs
pop fs
pop ds
pop es

iret

/*----------c code -----------*/

voit int_handler(context c) {
/* call scheduler */
c.eax = next->eax;
c.ebx = next->ebx;
c.ecx = next->ecx;
c.edx = next->edx;

/*etc etc*/
}

Code: Select all

TaskState NextTask;
TaskState TaskList[2];
int CurrentTask = 0;

void SetTask(int a, TaskState b){
 TaskList[a] = b;
}

void TaskSwitcher(RegStateExt* r){
 if(CurrentTask == 0)CurrentTask = 1;
 else CurrentTask = 0;
 
 memcpy((UCHAR*)r, (UCHAR*)&TaskList[CurrentTask], 64);
}

void StartMultitask(){
 IRQ_InstallHandler(0, TaskSwitcher);
}

Code: Select all

void BeepThis(){
 for(;;)PrintString("* TASK1! *");
}

void BeepThat(){
 for(;;)PrintString("+ TASK2! +");
}

TaskState BeepThisTask = {
 0x10, 0x10, 0x10, 0x10,
 0x00, 0x00, 0x00, 0x100000, 0x00, 0x00, 0x00, 0x00,
 0x00, 0x00,
 (UINT)BeepThis, 0x08, 0x00,
};

TaskState BeepThatTask = {
 0x10, 0x10, 0x10, 0x10,
 0x00, 0x00, 0x00, 0x200000, 0x00, 0x00, 0x00, 0x00,
 0x00, 0x00,
 (UINT)BeepThat, 0x08, 0x00,
};

void KernelEntry(LoaderInfoBlock* argv){
 int i, x;
 int NextMsgLine = 0;
 char a;
 
 SetSystemMemory(16);
 SetSystemBitmap(0x7E0000, 0xFFFE0000);
 
 GDT_Init();
 GDT_Install();
 
 IDT_Install();
 ISR_Install();
 IRQ_Install();
 
 PIT_Install();
 Keyboard_Install();
 
 EnableInterrupts();
 
 ClearScreenTo(0x00);
 
 PrintString("--DEMI OS--  (Version 0.0.5b)\n");
 PrintString("   + Memory Page Manager\n");
 PrintString("   + GDT\n");
 PrintString("   + IDT\n");
 PrintString("   + ISR\n");
 PrintString("   + IRQ\n");
 PrintString("   + Default Module: Console(CGA)\n\n");
 
 PrintString("Time it took to get to here: 0x");
 PrintHex(PIT_GetTime());
 
 SetTask(0, BeepThisTask);
 SetTask(1, BeepThatTask);
 StartMultitask();
 
 for(;;);
}

Code: Select all

;Common stub for all ISRs. Pushes all registers, then pointer to that structure
IsrStub:
 pushad    ;Push this stuff, in opposite order of memory (stack grows DOWN!)
 push ds
 push es
 push fs
 push gs
 
 mov ax, 0x10 ;Kernel Data Segment!
 mov ds, ax ;Restore data segment
 mov es, ax
 mov fs, ax
 mov gs, ax
 
 mov eax, esp ;Get stack pointer
 push eax     ;Push it. Pointer to structure formed in memory above
 
 call _IsrEntry    ;Call C handler
 
 pop eax   ;Pop back the standard registers
 pop gs
 pop fs
 pop es
 pop ds
 popad
 add esp, 8 ;Clean up pushed error code and ISR number
 iret       ;Return to interrupted whatever

Code: Select all

typedef struct{
 unsigned int gs, fs, es, ds;
 unsigned int edi, esi, ebp, esp, ebx, edx, ecx, eax;
 unsigned int IdNum, ErrorCode;
 unsigned int eip, cs, eflags, useresp, ss;
} __attribute__ ((packed)) RegStateExt;

Code: Select all

typedef RegStateExt TaskState;

Code: Select all

pop edi
pop esi
pop ebp
add $4, esp
pop ebx
pop edx
pop ecx
pop eax

Code: Select all

irq_00:
push %ds
push %es
push %fs
push %gs
pusha

mov $0x10, %ax
mov %ax, %ds
mov %ax, %es
mov %ax, %fs
mov %ax, %gs

push %esp /*this allows the function to return the oriiginal esp if neccessary */

call IsrEntry  /* this will return the stack kernel esp of the new task */

add $4, %esp /* counter that push esp */

mov %eax, %esp /* set esp to what _IsrEntry returned */

/* at this point we are running on the NEW esp, pop all the other registers */

popa
pop %gs
pop %fs
pop %es
pop %ds

add $8, %esp
iret

Code: Select all

uint32_t IsrEntry(uint32_t old_esp) {
    Thread *oldThread = current;    
    Thread *newThread = pickNextThread();
    if(oldThread != newThread) {
        /* update TSS's esp0 entry for new thread */
        /* maybe update cr3 if neccessary */
        return newThread->esp0;
    } else {
        return oldThread->esp0;
    }
}

Code: Select all

typedef struct{
 UINT esp0;
 UINT esp3;
} __attribute__ ((packed)) Task;

extern void ASM_TaskStub();

Task TaskList[25];
int CurrentTask = -1;

void MT_ScheduleThread(int a, void (*thread)()){
 UINT *Stack;
 
 TaskList[a].esp0 = (UINT)AllocPage()+4096; //Stack for when kernel is called
 TaskList[a].esp3 = (UINT)AllocPage()+4096; //Stack for process itself
 
 TaskList[a].esp0--;              //Offset kernel stack into actual 4kb page
 
 TaskList[a].esp3--;              //Offset user/app stack into actual 4kb page
 Stack = (UINT*)TaskList[a].esp3; //Get stack pointer for process
 
 //IRET
 *Stack-- = 0x0202;       //EFLAGS
 *Stack-- = 0x08;         //CS
 *Stack-- = (UINT)thread; //EIP
 
 //PUSHa / POPa
 *Stack-- = 0; //EAX
 *Stack-- = 0; //ECX
 *Stack-- = 0; //EDX
 *Stack-- = 0; //EBX
 *Stack-- = 0; //Temp/Unused
 *Stack-- = 0; //EBP
 *Stack-- = 0; //ESI
 *Stack-- = 0; //EDI
 
 //PUSH ds, es, fs, gs / POP gs, fs, es, ds
 *Stack-- = 0x10; //DS
 *Stack-- = 0x10; //ES
 *Stack-- = 0x10; //FS
 *Stack-- = 0x10; //GS
 
 TaskList[a].esp3 = (UINT)Stack; //Update stack position in process info struct
}

UINT MT_SwitchTask(UINT esp){
 if(CurrentTask != -1)
  TaskList[CurrentTask].esp3 = esp;
 else
  CurrentTask = 0;
 
 CurrentTask++;
 if(CurrentTask > 1)CurrentTask = 0;
 
 return TaskList[CurrentTask].esp3;
}

void MT_Start(){
 IDT_InstallHandler(32, (UINT)ASM_TaskStub, 0x08, 0);
} /*32 is mapped to IRQ 0 */

Code: Select all

global _ASM_TaskStub
extern _MT_SwitchTask

;When called by an IRQ from processor, allows task switches
_ASM_TaskStub:
 pushad              ;Push all general purpose registers
 
 push ds             ;Push data segment
 push es             ;Push data segment 'e'
 push fs             ;Push data segment 'f'
 push gs             ;Push data segment 'g'
 
 mov eax, esp        ;Get current stack pointer
 push eax            ;Push it as argument to C function
 
 call _MT_SwitchTask ;Call 'C code' task scheduler
 
 add esp, 4          ;Clean up pushed argument to 'C code'
 
 mov esp, eax        ;Set new task's stack pointer. (EAX from C code return value)
 
 pop gs              ;Pop off data segment 'g'
 pop fs              ;Pop off data segment 'f'
 pop es              ;Pop off data segment 'e'
 pop ds              ;Pop off data segmemt
 
 popad               ;Pop all general purpose registers
 iret                ;Interrupt Return. Installs EIP etc. of new task