*/
#include <acess.h>
#include <proc.h>
+#include <desctab.h>
#include <mm_virt.h>
#include <errno.h>
#if USE_MP
// === CONSTANTS ===
#define SWITCH_MAGIC 0xFFFACE55 // There is no code in this area
+// Base is 1193182
#define TIMER_DIVISOR 11931 //~100Hz
// === IMPORTS ===
extern tGDT gGDT[];
-extern void APStartup(); // 16-bit AP startup code
-extern Uint GetEIP(); // start.asm
+extern tIDT gIDT[];
+extern void APStartup(void); // 16-bit AP startup code
+extern Uint GetEIP(void); // start.asm
+extern int GetCPUNum(void); // start.asm
extern Uint32 gaInitPageDir[1024]; // start.asm
extern void Kernel_Stack_Top;
-extern volatile int giThreadListLock;
+extern tSpinlock glThreadListLock;
extern int giNumCPUs;
extern int giNextTID;
extern int giTotalTickets;
extern tThread *gSleepingThreads;
extern tThread *gDeleteThreads;
extern tThread *Threads_GetNextToRun(int CPU);
-extern void Threads_Dump();
+extern void Threads_Dump(void);
extern tThread *Threads_CloneTCB(Uint *Err, Uint Flags);
-extern void Isr7();
+extern void Isr8(void); // Double Fault
+extern void Proc_ReturnToUser(void);
// === PROTOTYPES ===
-void ArchThreads_Init();
+void ArchThreads_Init(void);
#if USE_MP
void MP_StartAP(int CPU);
void MP_SendIPI(Uint8 APICID, int Vector, int DeliveryMode);
#endif
-void Proc_Start();
-tThread *Proc_GetCurThread();
-void Proc_ChangeStack();
+void Proc_Start(void);
+tThread *Proc_GetCurThread(void);
+void Proc_ChangeStack(void);
int Proc_Clone(Uint *Err, Uint Flags);
-void Proc_Scheduler();
+void Proc_StartProcess(Uint16 SS, Uint Stack, Uint Flags, Uint16 CS, Uint IP);
+void Proc_CallFaultHandler(tThread *Thread);
+void Proc_Scheduler(int CPU);
// === GLOBALS ===
// --- Multiprocessing ---
tTSS gDoubleFault_TSS = {
.ESP0 = (Uint)&gaDoubleFaultStack[1023],
.SS0 = 0x10,
- .EIP = (Uint)Isr7
+ .CR3 = (Uint)gaInitPageDir - KERNEL_BASE,
+ .EIP = (Uint)Isr8,
+ .ESP = (Uint)&gaDoubleFaultStack[1023],
+ .CS = 0x08, .SS = 0x10,
+ .DS = 0x10, .ES = 0x10,
+ .FS = 0x10, .GS = 0x10,
};
// === CODE ===
/**
- * \fn void ArchThreads_Init()
+ * \fn void ArchThreads_Init(void)
* \brief Starts the process scheduler
*/
-void ArchThreads_Init()
+void ArchThreads_Init(void)
{
Uint pos = 0;
gGDT[5].BaseMid = (Uint)&gDoubleFault_TSS >> 16;
gGDT[5].BaseHi = (Uint)&gDoubleFault_TSS >> 24;
+ Log_Debug("Proc", "gIDT[8] = {OffsetLo:%04x, CS:%04x, Flags:%04x, OffsetHi:%04x}",
+ gIDT[8].OffsetLo, gIDT[8].CS, gIDT[8].Flags, gIDT[8].OffsetHi);
+ gIDT[8].OffsetLo = 0;
+ gIDT[8].CS = 5<<3;
+ gIDT[8].Flags = 0x8500;
+ gIDT[8].OffsetHi = 0;
+ Log_Debug("Proc", "gIDT[8] = {OffsetLo:%04x, CS:%04x, Flags:%04x, OffsetHi:%04x}",
+ gIDT[8].OffsetLo, gIDT[8].CS, gIDT[8].Flags, gIDT[8].OffsetHi);
+
+ //__asm__ __volatile__ ("xchg %bx, %bx");
+
#if USE_MP
// Initialise Normal TSS(s)
for(pos=0;pos<giNumCPUs;pos++)
#endif
/**
- * \fn void Proc_Start()
+ * \fn void Proc_Start(void)
* \brief Start process scheduler
*/
-void Proc_Start()
+void Proc_Start(void)
{
// Start Interrupts (and hence scheduler)
__asm__ __volatile__("sti");
}
/**
- * \fn tThread *Proc_GetCurThread()
+ * \fn tThread *Proc_GetCurThread(void)
* \brief Gets the current thread
*/
-tThread *Proc_GetCurThread()
+tThread *Proc_GetCurThread(void)
{
#if USE_MP
- return gaCPUs[ gaAPIC_to_CPU[gpMP_LocalAPIC->ID.Val&0xFF] ].Current;
+ //return gaCPUs[ gaAPIC_to_CPU[gpMP_LocalAPIC->ID.Val&0xFF] ].Current;
+ return gaCPUs[ GetCPUNum() ].Current;
#else
return gCurrentThread;
#endif
}
/**
- * \fn void Proc_ChangeStack()
+ * \fn void Proc_ChangeStack(void)
* \brief Swaps the current stack for a new one (in the proper stack reigon)
*/
-void Proc_ChangeStack()
+void Proc_ChangeStack(void)
{
Uint esp, ebp;
Uint tmpEbp, oldEsp;
}
/**
- * \fn int Proc_SpawnWorker()
+ * \fn int Proc_SpawnWorker(void)
* \brief Spawns a new worker thread
*/
-int Proc_SpawnWorker()
+int Proc_SpawnWorker(void)
{
tThread *new, *cur;
Uint eip, esp, ebp;
}
/**
- * \fn Uint Proc_MakeUserStack()
+ * \fn Uint Proc_MakeUserStack(void)
* \brief Creates a new user stack
*/
-Uint Proc_MakeUserStack()
+Uint Proc_MakeUserStack(void)
{
int i;
Uint base = USER_STACK_TOP - USER_STACK_SZ;
return base + USER_STACK_SZ;
}
-
/**
* \fn void Proc_StartUser(Uint Entrypoint, Uint *Bases, int ArgC, char **ArgV, char **EnvP, int DataSize)
* \brief Starts a user task
Uint delta;
Uint16 ss, cs;
- LOG("stack = 0x%x", stack);
+ //Log("stack = %p", stack);
// Copy Arguments
- stack = (void*)( (Uint)stack - DataSize );
+ stack -= DataSize/sizeof(*stack);
memcpy( stack, ArgV, DataSize );
- // Adjust Arguments and environment
- delta = (Uint)stack - (Uint)ArgV;
- ArgV = (char**)stack;
- for( i = 0; ArgV[i]; i++ ) ArgV[i] += delta;
- i ++;
- EnvP = &ArgV[i];
- for( i = 0; EnvP[i]; i++ ) EnvP[i] += delta;
+ //Log("stack = %p", stack);
+
+ if( DataSize )
+ {
+ // Adjust Arguments and environment
+ delta = (Uint)stack - (Uint)ArgV;
+ ArgV = (char**)stack;
+ for( i = 0; ArgV[i]; i++ )
+ ArgV[i] += delta;
+ i ++;
+
+ // Do we care about EnvP?
+ if( EnvP ) {
+ EnvP = &ArgV[i];
+ for( i = 0; EnvP[i]; i++ )
+ EnvP[i] += delta;
+ }
+ }
// User Mode Segments
ss = 0x23; cs = 0x1B;
while(*Bases)
*--stack = *Bases++;
*--stack = 0; // Return Address
- delta = (Uint)stack; // Reuse delta to save SP
- *--stack = ss; //Stack Segment
- *--stack = delta; //Stack Pointer
- *--stack = 0x0202; //EFLAGS (Resvd (0x2) and IF (0x20))
- *--stack = cs; //Code Segment
- *--stack = Entrypoint; //EIP
+ Proc_StartProcess(ss, (Uint)stack, 0x202, cs, Entrypoint);
+}
+
+void Proc_StartProcess(Uint16 SS, Uint Stack, Uint Flags, Uint16 CS, Uint IP)
+{
+ Uint *stack = (void*)Stack;
+ *--stack = SS; //Stack Segment
+ *--stack = Stack; //Stack Pointer
+ *--stack = Flags; //EFLAGS (Resvd (0x2) and IF (0x20))
+ *--stack = CS; //Code Segment
+ *--stack = IP; //EIP
//PUSHAD
*--stack = 0xAAAAAAAA; // eax
*--stack = 0xCCCCCCCC; // ecx
*--stack = 0x51515151; // esi
*--stack = 0xB4B4B4B4; // ebp
//Individual PUSHs
- *--stack = ss; // ds
- *--stack = ss; // es
- *--stack = ss; // fs
- *--stack = ss; // gs
+ *--stack = SS; // ds
+ *--stack = SS; // es
+ *--stack = SS; // fs
+ *--stack = SS; // gs
__asm__ __volatile__ (
"mov %%eax,%%esp;\n\t" // Set stack pointer
return 0;
}
+/**
+ * \brief Calls a signal handler in user mode
+ * \note Used for signals
+ */
+void Proc_CallFaultHandler(tThread *Thread)
+{
+ // Rewinds the stack and calls the user function
+ // Never returns
+ __asm__ __volatile__ ("mov %0, %%ebp;\n\tcall Proc_ReturnToUser" :: "r"(Thread->FaultHandler));
+ for(;;);
+}
+
/**
* \fn void Proc_Scheduler(int CPU)
* \brief Swap current thread and clears dead threads
tThread *thread;
// If the spinlock is set, let it complete
- if(giThreadListLock) return;
+ if(IS_LOCKED(&glThreadListLock)) return;
// Clear Delete Queue
while(gDeleteThreads)
#else
__asm__ __volatile__ ("mov %0, %%cr3"::"a"(thread->MemState.CR3));
#endif
+
+ #if 0
+ if(thread->SavedState.ESP > 0xC0000000
+ && thread->SavedState.ESP < thread->KernelStack-0x2000) {
+ Log_Warning("Proc", "Possible bad ESP %p (PID %i)", thread->SavedState.ESP);
+ }
+ #endif
+
// Switch threads
__asm__ __volatile__ (
"mov %1, %%esp\n\t" // Restore ESP