2 * AcessOS Microkernel Version
14 #define SWITCH_MAGIC 0xFFFACE55 // There is no code in this area
15 #define TIMER_DIVISOR 11931 //~100Hz
19 extern Uint GetEIP(); // start.asm
20 extern Uint32 gaInitPageDir[1024]; // start.asm
21 extern void Kernel_Stack_Top;
22 extern volatile int giThreadListLock;
25 extern int giTotalTickets;
26 extern int giNumActiveThreads;
27 extern tThread gThreadZero;
28 extern tThread *gActiveThreads;
29 extern tThread *gSleepingThreads;
30 extern tThread *gDeleteThreads;
31 extern tThread *Threads_GetNextToRun(int CPU);
34 void ArchThreads_Init();
35 tThread *Proc_GetCurThread();
36 void Proc_ChangeStack();
37 int Proc_Clone(Uint *Err, Uint Flags);
38 void Proc_Scheduler();
41 // --- Current State ---
43 tThread *gCurrentThread[MAX_CPUS] = {NULL};
45 tThread *gCurrentThread = NULL;
47 // --- Multiprocessing ---
49 tMPInfo *gMPTable = NULL;
52 Uint32 *gPML4s[4] = NULL;
61 * \fn void ArchThreads_Init()
62 * \brief Starts the process scheduler
64 void ArchThreads_Init()
68 // -- Initialise Multiprocessing
69 // Find MP Floating Table
71 for(pos = KERNEL_BASE|0x9FC00; pos < (KERNEL_BASE|0xA0000); pos += 16) {
72 if( *(Uint*)(pos) == MPTABLE_IDENT ) {
73 if(ByteSum( (void*)pos, sizeof(tMPInfo) ) != 0) continue;
74 gMPTable = (void*)pos;
84 for(pos = KERNEL_BASE|0xF0000; pos < (KERNEL_BASE|0x100000); pos += 16) {
85 if( *(Uint*)(pos) == MPTABLE_IDENT ) {
86 if(ByteSum( (void*)pos, sizeof(tMPInfo) ) != 0) continue;
87 gMPTable = (void*)pos;
93 // If the MP Table Exists, parse it
96 Panic("Uh oh... MP Table Parsing is unimplemented\n");
105 for(pos=0;pos<giNumCPUs;pos++)
110 gTSSs[pos].SS0 = 0x10;
111 gTSSs[pos].ESP0 = 0; // Set properly by scheduler
112 gGDT[5+pos].LimitLow = sizeof(tTSS);
113 gGDT[5+pos].LimitHi = 0;
114 gGDT[5+pos].Access = 0x89; // Type
115 gGDT[5+pos].Flags = 0x4;
116 gGDT[5+pos].BaseLow = (Uint)&gTSSs[pos] & 0xFFFF;
117 gGDT[5+pos].BaseMid = (Uint)&gTSSs[pos] >> 16;
118 gGDT[5+pos].BaseHi = (Uint)&gTSSs[pos] >> 24;
121 for(pos=0;pos<giNumCPUs;pos++) {
123 __asm__ __volatile__ ("ltr %%ax"::"a"(0x28+pos*8));
129 gCurrentThread[0] = &gThreadZero;
131 gCurrentThread = &gThreadZero;
135 gThreadZero.MemState.PDP[0] = 0;
136 gThreadZero.MemState.PDP[1] = 0;
137 gThreadZero.MemState.PDP[2] = 0;
139 gThreadZero.MemState.CR3 = (Uint)gaInitPageDir - KERNEL_BASE;
142 // Set timer frequency
143 outb(0x43, 0x34); // Set Channel 0, Low/High, Rate Generator
144 outb(0x40, TIMER_DIVISOR&0xFF); // Low Byte of Divisor
145 outb(0x40, (TIMER_DIVISOR>>8)&0xFF); // High Byte
147 // Create Per-Process Data Block
148 MM_Allocate(MM_PPD_CFG);
155 * \fn void Proc_Start()
156 * \brief Start process scheduler
160 // Start Interrupts (and hence scheduler)
161 __asm__ __volatile__("sti");
165 * \fn tThread *Proc_GetCurThread()
166 * \brief Gets the current thread
168 tThread *Proc_GetCurThread()
173 return gCurrentThread;
178 * \fn void Proc_ChangeStack()
179 * \brief Swaps the current stack for a new one (in the proper stack reigon)
181 void Proc_ChangeStack()
185 Uint curBase, newBase;
187 __asm__ __volatile__ ("mov %%esp, %0":"=r"(esp));
188 __asm__ __volatile__ ("mov %%ebp, %0":"=r"(ebp));
193 newBase = MM_NewKStack();
196 Panic("What the?? Unable to allocate space for initial kernel stack");
200 curBase = (Uint)&Kernel_Stack_Top;
202 LOG("curBase = 0x%x, newBase = 0x%x", curBase, newBase);
204 // Get ESP as a used size
206 LOG("memcpy( %p, %p, 0x%x )", (void*)(newBase - esp), (void*)(curBase - esp), esp );
208 memcpy( (void*)(newBase - esp), (void*)(curBase - esp), esp );
209 // Get ESP as an offset in the new stack
212 ebp = newBase - (curBase - ebp);
214 // Repair EBPs & Stack Addresses
215 // Catches arguments also, but may trash stack-address-like values
216 for(tmpEbp = esp; tmpEbp < newBase; tmpEbp += 4)
218 if(oldEsp < *(Uint*)tmpEbp && *(Uint*)tmpEbp < curBase)
219 *(Uint*)tmpEbp += newBase - curBase;
222 gCurrentThread->KernelStack = newBase;
224 __asm__ __volatile__ ("mov %0, %%esp"::"r"(esp));
225 __asm__ __volatile__ ("mov %0, %%ebp"::"r"(ebp));
229 * \fn int Proc_Clone(Uint *Err, Uint Flags)
230 * \brief Clone the current process
232 int Proc_Clone(Uint *Err, Uint Flags)
237 __asm__ __volatile__ ("mov %%esp, %0": "=r"(esp));
238 __asm__ __volatile__ ("mov %%ebp, %0": "=r"(ebp));
240 // Create new thread structure
241 newThread = malloc( sizeof(tThread) );
243 Warning("Proc_Clone - Out of memory when creating thread\n");
247 // Base new thread on old
248 memcpy(newThread, gCurrentThread, sizeof(tThread));
249 // Initialise Memory Space (New Addr space or kernel stack)
250 if(Flags & CLONE_VM) {
251 newThread->TGID = newThread->TID;
252 newThread->MemState.CR3 = MM_Clone();
254 Uint tmpEbp, oldEsp = esp;
257 newThread->KernelStack = MM_NewKStack();
259 if(newThread->KernelStack == 0) {
264 // Get ESP as a used size
265 esp = gCurrentThread->KernelStack - esp;
267 memcpy( (void*)(newThread->KernelStack - esp), (void*)(gCurrentThread->KernelStack - esp), esp );
268 // Get ESP as an offset in the new stack
269 esp = newThread->KernelStack - esp;
271 ebp = newThread->KernelStack - (gCurrentThread->KernelStack - ebp);
273 // Repair EBPs & Stack Addresses
274 // Catches arguments also, but may trash stack-address-like values
275 for(tmpEbp = esp; tmpEbp < newThread->KernelStack; tmpEbp += 4)
277 if(oldEsp < *(Uint*)tmpEbp && *(Uint*)tmpEbp < gCurrentThread->KernelStack)
278 *(Uint*)tmpEbp += newThread->KernelStack - gCurrentThread->KernelStack;
282 // Set Pointer, Spinlock and TID
283 newThread->Next = NULL;
284 newThread->IsLocked = 0;
285 newThread->TID = giNextTID++;
286 newThread->PTID = gCurrentThread->TID;
288 // Clear message list (messages are not inherited)
289 newThread->Messages = NULL;
290 newThread->LastMessage = NULL;
292 // Set remaining (sheduler expects remaining to be correct)
293 newThread->Remaining = newThread->Quantum;
295 // Save core machine state
296 newThread->SavedState.ESP = esp;
297 newThread->SavedState.EBP = ebp;
299 if(eip == SWITCH_MAGIC) {
300 outb(0x20, 0x20); // ACK Timer and return as child
305 newThread->SavedState.EIP = eip;
307 // Lock list and add to active
308 LOCK( &giThreadListLock );
309 newThread->Next = gActiveThreads;
310 gActiveThreads = newThread;
311 giNumActiveThreads ++;
312 giTotalTickets += newThread->NumTickets;
313 RELEASE( &giThreadListLock );
315 return newThread->TID;
319 * \fn Uint Proc_MakeUserStack()
320 * \brief Creates a new user stack
322 Uint Proc_MakeUserStack()
325 Uint base = USER_STACK_TOP - USER_STACK_SZ;
327 // Check Prospective Space
328 for( i = USER_STACK_SZ >> 12; i--; )
329 if( MM_GetPhysAddr( base + (i<<12) ) != 0 )
332 if(i != -1) return 0;
334 // Allocate Stack - Allocate incrementally to clean up MM_Dump output
335 for( i = 0; i < USER_STACK_SZ/4069; i++ )
336 MM_Allocate( base + (i<<12) );
338 return base + USER_STACK_SZ;
343 * \fn void Proc_StartUser(Uint Entrypoint, Uint Base, int ArgC, char **ArgV, char **EnvP, int DataSize)
344 * \brief Starts a user task
346 void Proc_StartUser(Uint Entrypoint, Uint *Bases, int ArgC, char **ArgV, char **EnvP, int DataSize)
348 Uint *stack = (void*)Proc_MakeUserStack();
353 LOG("stack = 0x%x", stack);
356 stack = (void*)( (Uint)stack - DataSize );
357 memcpy( stack, ArgV, DataSize );
359 // Adjust Arguments and environment
360 delta = (Uint)stack - (Uint)ArgV;
361 ArgV = (char**)stack;
362 for( i = 0; ArgV[i]; i++ ) ArgV[i] += delta;
365 for( i = 0; EnvP[i]; i++ ) EnvP[i] += delta;
367 // User Mode Segments
368 ss = 0x23; cs = 0x1B;
371 *--stack = (Uint)EnvP;
372 *--stack = (Uint)ArgV;
373 *--stack = (Uint)ArgC;
376 *--stack = 0; // Return Address
377 delta = (Uint)stack; // Reuse delta to save SP
379 *--stack = ss; //Stack Segment
380 *--stack = delta; //Stack Pointer
381 *--stack = 0x0202; //EFLAGS (Resvd (0x2) and IF (0x20))
382 *--stack = cs; //Code Segment
383 *--stack = Entrypoint; //EIP
385 *--stack = 0xAAAAAAAA; // eax
386 *--stack = 0xCCCCCCCC; // ecx
387 *--stack = 0xDDDDDDDD; // edx
388 *--stack = 0xBBBBBBBB; // ebx
389 *--stack = 0xD1D1D1D1; // edi
390 *--stack = 0x54545454; // esp - NOT POPED
391 *--stack = 0x51515151; // esi
392 *--stack = 0xB4B4B4B4; // ebp
399 __asm__ __volatile__ (
400 "mov %%eax,%%esp;\n\t" // Set stack pointer
406 "iret;\n\t" : : "a" (stack));
411 * \fn int Proc_Demote(Uint *Err, int Dest, tRegs *Regs)
412 * \brief Demotes a process to a lower permission level
413 * \param Err Pointer to user's errno
415 int Proc_Demote(Uint *Err, int Dest, tRegs *Regs)
417 int cpl = Regs->cs & 3;
419 if(Dest > 3 || Dest < 0) {
430 // Change the Segment Registers
431 Regs->cs = (((Dest+1)<<4) | Dest) - 8;
432 Regs->ss = ((Dest+1)<<4) | Dest;
433 // Check if the GP Segs are GDT, then change them
434 if(!(Regs->ds & 4)) Regs->ds = ((Dest+1)<<4) | Dest;
435 if(!(Regs->es & 4)) Regs->es = ((Dest+1)<<4) | Dest;
436 if(!(Regs->fs & 4)) Regs->fs = ((Dest+1)<<4) | Dest;
437 if(!(Regs->gs & 4)) Regs->gs = ((Dest+1)<<4) | Dest;
443 * \fn void Proc_Scheduler(int CPU)
444 * \brief Swap current thread and clears dead threads
446 void Proc_Scheduler(int CPU)
451 // If the spinlock is set, let it complete
452 if(giThreadListLock) return;
454 // Clear Delete Queue
455 while(gDeleteThreads)
457 thread = gDeleteThreads->Next;
458 if(gDeleteThreads->IsLocked) { // Only free if structure is unused
459 gDeleteThreads->Status = THREAD_STAT_NULL;
460 free( gDeleteThreads );
462 gDeleteThreads = thread;
465 // Check if there is any tasks running
466 if(giNumActiveThreads == 0) {
467 Log("No Active threads, sleeping\n");
468 __asm__ __volatile__ ("hlt");
472 // Reduce remaining quantum and continue timeslice if non-zero
473 if(gCurrentThread->Remaining--) return;
474 // Reset quantum for next call
475 gCurrentThread->Remaining = gCurrentThread->Quantum;
478 __asm__ __volatile__ ("mov %%esp, %0":"=r"(esp));
479 __asm__ __volatile__ ("mov %%ebp, %0":"=r"(ebp));
481 if(eip == SWITCH_MAGIC) return; // Check if a switch happened
483 // Save machine state
484 gCurrentThread->SavedState.ESP = esp;
485 gCurrentThread->SavedState.EBP = ebp;
486 gCurrentThread->SavedState.EIP = eip;
489 thread = Threads_GetNextToRun(CPU);
493 Warning("Hmm... Threads_GetNextToRun returned NULL, I don't think this should happen.\n");
497 // Set current thread
498 gCurrentThread = thread;
500 // Update Kernel Stack pointer
501 gTSSs[CPU].ESP0 = thread->KernelStack;
504 __asm__ __volatile__ ("mov %0, %%cr3"::"a"(gCurrentThread->MemState.CR3));
506 __asm__ __volatile__ (
510 "a"(SWITCH_MAGIC), "b"(gCurrentThread->SavedState.ESP),
511 "d"(gCurrentThread->SavedState.EBP), "c"(gCurrentThread->SavedState.EIP));
512 for(;;); // Shouldn't reach here