[CODE]: s/interupt/interrupt/
[reactos.git] / reactos / ntoskrnl / ke / i386 / thrdini.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS kernel
4 * FILE: ntoskrnl/ke/i386/thrdini.c
5 * PURPOSE: i386 Thread Context Creation
6 * PROGRAMMER: Alex Ionescu (alex@relsoft.net)
7 */
8
9 /* INCLUDES ******************************************************************/
10
11 #include <ntoskrnl.h>
12 #define NDEBUG
13 #include <debug.h>
14
15 typedef struct _KSWITCHFRAME
16 {
17 PVOID ExceptionList;
18 BOOLEAN ApcBypassDisable;
19 PVOID RetAddr;
20 } KSWITCHFRAME, *PKSWITCHFRAME;
21
22 typedef struct _KSTART_FRAME
23 {
24 PKSYSTEM_ROUTINE SystemRoutine;
25 PKSTART_ROUTINE StartRoutine;
26 PVOID StartContext;
27 BOOLEAN UserThread;
28 } KSTART_FRAME, *PKSTART_FRAME;
29
30 typedef struct _KUINIT_FRAME
31 {
32 KSWITCHFRAME CtxSwitchFrame;
33 KSTART_FRAME StartFrame;
34 KTRAP_FRAME TrapFrame;
35 FX_SAVE_AREA FxSaveArea;
36 } KUINIT_FRAME, *PKUINIT_FRAME;
37
38 typedef struct _KKINIT_FRAME
39 {
40 KSWITCHFRAME CtxSwitchFrame;
41 KSTART_FRAME StartFrame;
42 FX_SAVE_AREA FxSaveArea;
43 } KKINIT_FRAME, *PKKINIT_FRAME;
44
45 VOID
46 FASTCALL
47 KiSwitchThreads(
48 IN PKTHREAD OldThread,
49 IN PKTHREAD NewThread
50 );
51
52 VOID
53 FASTCALL
54 KiRetireDpcListInDpcStack(
55 IN PKPRCB Prcb,
56 IN PVOID DpcStack
57 );
58
59 /* FUNCTIONS *****************************************************************/
60
61 VOID
62 NTAPI
63 KiThreadStartup(VOID)
64 {
65 PKTRAP_FRAME TrapFrame;
66 PKSTART_FRAME StartFrame;
67 PKUINIT_FRAME InitFrame;
68
69 /* Get the start and trap frames */
70 InitFrame = KeGetCurrentThread()->KernelStack;
71 StartFrame = &InitFrame->StartFrame;
72 TrapFrame = &InitFrame->TrapFrame;
73
74 /* Lower to APC level */
75 KfLowerIrql(APC_LEVEL);
76
77 /* Call the system routine */
78 StartFrame->SystemRoutine(StartFrame->StartRoutine, StartFrame->StartContext);
79
80 /* If we returned, we better be a user thread */
81 if (!StartFrame->UserThread) DbgBreakPoint();
82
83 /* Exit to user-mode */
84 KiServiceExit2(TrapFrame);
85 }
86
87 VOID
88 NTAPI
89 KiInitializeContextThread(IN PKTHREAD Thread,
90 IN PKSYSTEM_ROUTINE SystemRoutine,
91 IN PKSTART_ROUTINE StartRoutine,
92 IN PVOID StartContext,
93 IN PCONTEXT ContextPointer)
94 {
95 PFX_SAVE_AREA FxSaveArea;
96 PFXSAVE_FORMAT FxSaveFormat;
97 PKSTART_FRAME StartFrame;
98 PKSWITCHFRAME CtxSwitchFrame;
99 PKTRAP_FRAME TrapFrame;
100 CONTEXT LocalContext;
101 PCONTEXT Context = NULL;
102 ULONG ContextFlags;
103
104 /* Check if this is a With-Context Thread */
105 if (ContextPointer)
106 {
107 /* Set up the Initial Frame */
108 PKUINIT_FRAME InitFrame;
109 InitFrame = (PKUINIT_FRAME)((ULONG_PTR)Thread->InitialStack -
110 sizeof(KUINIT_FRAME));
111
112 /* Copy over the context we got */
113 RtlCopyMemory(&LocalContext, ContextPointer, sizeof(CONTEXT));
114 Context = &LocalContext;
115 ContextFlags = CONTEXT_CONTROL;
116
117 /* Zero out the trap frame and save area */
118 RtlZeroMemory(&InitFrame->TrapFrame,
119 KTRAP_FRAME_LENGTH + sizeof(FX_SAVE_AREA));
120
121 /* Setup the Fx Area */
122 FxSaveArea = &InitFrame->FxSaveArea;
123
124 /* Check if we support FXsr */
125 if (KeI386FxsrPresent)
126 {
127 /* Get the FX Save Format Area */
128 FxSaveFormat = (PFXSAVE_FORMAT)Context->ExtendedRegisters;
129
130 /* Set an initial state */
131 FxSaveFormat->ControlWord = 0x27F;
132 FxSaveFormat->StatusWord = 0;
133 FxSaveFormat->TagWord = 0;
134 FxSaveFormat->ErrorOffset = 0;
135 FxSaveFormat->ErrorSelector = 0;
136 FxSaveFormat->DataOffset = 0;
137 FxSaveFormat->DataSelector = 0;
138 FxSaveFormat->MXCsr = 0x1F80;
139 }
140 else
141 {
142 /* Setup the regular save area */
143 Context->FloatSave.ControlWord = 0x27F;
144 Context->FloatSave.StatusWord = 0;
145 Context->FloatSave.TagWord = -1;
146 Context->FloatSave.ErrorOffset = 0;
147 Context->FloatSave.ErrorSelector = 0;
148 Context->FloatSave.DataOffset =0;
149 Context->FloatSave.DataSelector = 0;
150 }
151
152 /* Check if the CPU has NPX */
153 if (KeI386NpxPresent)
154 {
155 /* Set an intial NPX State */
156 Context->FloatSave.Cr0NpxState = 0;
157 FxSaveArea->Cr0NpxState = 0;
158 FxSaveArea->NpxSavedCpu = 0;
159
160 /* Now set the context flags depending on XMM support */
161 ContextFlags |= (KeI386FxsrPresent) ? CONTEXT_EXTENDED_REGISTERS :
162 CONTEXT_FLOATING_POINT;
163
164 /* Set the Thread's NPX State */
165 Thread->NpxState = NPX_STATE_NOT_LOADED;
166 Thread->Header.NpxIrql = PASSIVE_LEVEL;
167 }
168 else
169 {
170 /* We'll use emulation */
171 FxSaveArea->Cr0NpxState = CR0_EM;
172 Thread->NpxState = NPX_STATE_NOT_LOADED &~ CR0_MP;
173 }
174
175 /* Disable any debug registers */
176 Context->ContextFlags &= ~CONTEXT_DEBUG_REGISTERS;
177
178 /* Setup the Trap Frame */
179 TrapFrame = &InitFrame->TrapFrame;
180
181 /* Set up a trap frame from the context. */
182 KeContextToTrapFrame(Context,
183 NULL,
184 TrapFrame,
185 Context->ContextFlags | ContextFlags,
186 UserMode);
187
188 /* Set SS, DS, ES's RPL Mask properly */
189 TrapFrame->HardwareSegSs |= RPL_MASK;
190 TrapFrame->SegDs |= RPL_MASK;
191 TrapFrame->SegEs |= RPL_MASK;
192 TrapFrame->Dr7 = 0;
193
194 /* Set the debug mark */
195 TrapFrame->DbgArgMark = 0xBADB0D00;
196
197 /* Set the previous mode as user */
198 TrapFrame->PreviousPreviousMode = UserMode;
199
200 /* Terminate the Exception Handler List */
201 TrapFrame->ExceptionList = EXCEPTION_CHAIN_END;
202
203 /* Setup the Stack for KiThreadStartup and Context Switching */
204 StartFrame = &InitFrame->StartFrame;
205 CtxSwitchFrame = &InitFrame->CtxSwitchFrame;
206
207 /* Tell the thread it will run in User Mode */
208 Thread->PreviousMode = UserMode;
209
210 /* Tell KiThreadStartup of that too */
211 StartFrame->UserThread = TRUE;
212 }
213 else
214 {
215 /* Set up the Initial Frame for the system thread */
216 PKKINIT_FRAME InitFrame;
217 InitFrame = (PKKINIT_FRAME)((ULONG_PTR)Thread->InitialStack -
218 sizeof(KKINIT_FRAME));
219
220 /* Setup the Fx Area */
221 FxSaveArea = &InitFrame->FxSaveArea;
222 RtlZeroMemory(FxSaveArea, sizeof(FX_SAVE_AREA));
223
224 /* Check if we have Fxsr support */
225 if (KeI386FxsrPresent)
226 {
227 /* Set the stub FX area */
228 FxSaveArea->U.FxArea.ControlWord = 0x27F;
229 FxSaveArea->U.FxArea.MXCsr = 0x1F80;
230 }
231 else
232 {
233 /* Set the stub FN area */
234 FxSaveArea->U.FnArea.ControlWord = 0x27F;
235 FxSaveArea->U.FnArea.TagWord = -1;
236 }
237
238 /* No NPX State */
239 Thread->NpxState = NPX_STATE_NOT_LOADED;
240
241 /* Setup the Stack for KiThreadStartup and Context Switching */
242 StartFrame = &InitFrame->StartFrame;
243 CtxSwitchFrame = &InitFrame->CtxSwitchFrame;
244
245 /* Tell the thread it will run in Kernel Mode */
246 Thread->PreviousMode = KernelMode;
247
248 /* Tell KiThreadStartup of that too */
249 StartFrame->UserThread = FALSE;
250 }
251
252 /* Now setup the remaining data for KiThreadStartup */
253 StartFrame->StartContext = StartContext;
254 StartFrame->StartRoutine = StartRoutine;
255 StartFrame->SystemRoutine = SystemRoutine;
256
257 /* And set up the Context Switch Frame */
258 CtxSwitchFrame->RetAddr = KiThreadStartup;
259 CtxSwitchFrame->ApcBypassDisable = TRUE;
260 CtxSwitchFrame->ExceptionList = EXCEPTION_CHAIN_END;
261
262 /* Save back the new value of the kernel stack. */
263 Thread->KernelStack = (PVOID)CtxSwitchFrame;
264 }
265
266 VOID
267 FASTCALL
268 KiIdleLoop(VOID)
269 {
270 PKPRCB Prcb = KeGetCurrentPrcb();
271 PKTHREAD OldThread, NewThread;
272
273 /* Initialize the idle loop: disable interrupts */
274 _enable();
275 YieldProcessor();
276 YieldProcessor();
277 _disable();
278
279 /* Now loop forever */
280 while (TRUE)
281 {
282 /* Check for pending timers, pending DPCs, or pending ready threads */
283 if ((Prcb->DpcData[0].DpcQueueDepth) ||
284 (Prcb->TimerRequest) ||
285 (Prcb->DeferredReadyListHead.Next))
286 {
287 /* Quiesce the DPC software interrupt */
288 HalClearSoftwareInterrupt(DISPATCH_LEVEL);
289
290 /* Handle it */
291 KiRetireDpcList(Prcb);
292 }
293
294 /* Check if a new thread is scheduled for execution */
295 if (Prcb->NextThread)
296 {
297 /* Enable interrupts */
298 _enable();
299
300 /* Capture current thread data */
301 OldThread = Prcb->CurrentThread;
302 NewThread = Prcb->NextThread;
303
304 /* Set new thread data */
305 Prcb->NextThread = NULL;
306 Prcb->CurrentThread = NewThread;
307
308 /* The thread is now running */
309 NewThread->State = Running;
310
311 /* Switch away from the idle thread */
312 KiSwapContext(APC_LEVEL, OldThread);
313
314 /* We are back in the idle thread -- disable interrupts again */
315 _enable();
316 YieldProcessor();
317 YieldProcessor();
318 _disable();
319 }
320 else
321 {
322 /* Continue staying idle. Note the HAL returns with interrupts on */
323 Prcb->PowerState.IdleFunction(&Prcb->PowerState);
324 }
325 }
326 }
327
328 BOOLEAN
329 FASTCALL
330 KiSwapContextExit(IN PKTHREAD OldThread,
331 IN PKSWITCHFRAME SwitchFrame)
332 {
333 PKIPCR Pcr = (PKIPCR)KeGetPcr();
334 PKPROCESS OldProcess, NewProcess;
335 PKTHREAD NewThread;
336
337 /* We are on the new thread stack now */
338 NewThread = Pcr->PrcbData.CurrentThread;
339
340 /* Now we are the new thread. Check if it's in a new process */
341 OldProcess = OldThread->ApcState.Process;
342 NewProcess = NewThread->ApcState.Process;
343 if (OldProcess != NewProcess)
344 {
345 /* Check if there is a different LDT */
346 if (*(PULONGLONG)&OldProcess->LdtDescriptor != *(PULONGLONG)&NewProcess->LdtDescriptor)
347 {
348 DPRINT1("LDT switch not implemented\n");
349 ASSERT(FALSE);
350 }
351
352 /* Switch address space and flush TLB */
353 __writecr3(NewProcess->DirectoryTableBase[0]);
354 }
355
356 /* Clear GS */
357 Ke386SetGs(0);
358
359 /* Set the TEB */
360 KiSetTebBase((PKPCR)Pcr, NewThread->Teb);
361
362 /* Set new TSS fields */
363 Pcr->TSS->Esp0 = (ULONG_PTR)NewThread->InitialStack;
364 if (!((KeGetTrapFrame(NewThread))->EFlags & EFLAGS_V86_MASK))
365 {
366 Pcr->TSS->Esp0 -= (FIELD_OFFSET(KTRAP_FRAME, V86Gs) - FIELD_OFFSET(KTRAP_FRAME, HardwareSegSs));
367 }
368 Pcr->TSS->Esp0 -= NPX_FRAME_LENGTH;
369 Pcr->TSS->IoMapBase = NewProcess->IopmOffset;
370
371 /* Increase thread context switches */
372 NewThread->ContextSwitches++;
373
374 /* Load data from switch frame */
375 Pcr->NtTib.ExceptionList = SwitchFrame->ExceptionList;
376
377 /* DPCs shouldn't be active */
378 if (Pcr->PrcbData.DpcRoutineActive)
379 {
380 /* Crash the machine */
381 KeBugCheckEx(ATTEMPTED_SWITCH_FROM_DPC,
382 (ULONG_PTR)OldThread,
383 (ULONG_PTR)NewThread,
384 (ULONG_PTR)OldThread->InitialStack,
385 0);
386 }
387
388 /* Kernel APCs may be pending */
389 if (NewThread->ApcState.KernelApcPending)
390 {
391 /* Are APCs enabled? */
392 if (!NewThread->SpecialApcDisable)
393 {
394 /* Request APC delivery */
395 if (SwitchFrame->ApcBypassDisable)
396 HalRequestSoftwareInterrupt(APC_LEVEL);
397 else
398 return TRUE;
399 }
400 }
401
402 /* Return stating that no kernel APCs are pending*/
403 return FALSE;
404 }
405
406 VOID
407 FASTCALL
408 KiSwapContextEntry(IN PKSWITCHFRAME SwitchFrame,
409 IN ULONG_PTR OldThreadAndApcFlag)
410 {
411 PKIPCR Pcr = (PKIPCR)KeGetPcr();
412 PKTHREAD OldThread, NewThread;
413 ULONG Cr0, NewCr0;
414
415 /* Save APC bypass disable */
416 SwitchFrame->ApcBypassDisable = OldThreadAndApcFlag & 3;
417 SwitchFrame->ExceptionList = Pcr->NtTib.ExceptionList;
418
419 /* Increase context switch count and check if tracing is enabled */
420 Pcr->ContextSwitches++;
421 if (Pcr->PerfGlobalGroupMask)
422 {
423 /* We don't support this yet on x86 either */
424 DPRINT1("WMI Tracing not supported\n");
425 ASSERT(FALSE);
426 }
427
428 /* Get thread pointers */
429 OldThread = (PKTHREAD)(OldThreadAndApcFlag & ~3);
430 NewThread = Pcr->PrcbData.CurrentThread;
431
432 /* Get the old thread and set its kernel stack */
433 OldThread->KernelStack = SwitchFrame;
434
435 /* ISRs can change FPU state, so disable interrupts while checking */
436 _disable();
437
438 /* Get current and new CR0 and check if they've changed */
439 Cr0 = __readcr0();
440 NewCr0 = NewThread->NpxState |
441 (Cr0 & ~(CR0_MP | CR0_EM | CR0_TS)) |
442 KiGetThreadNpxArea(NewThread)->Cr0NpxState;
443 if (Cr0 != NewCr0) __writecr0(NewCr0);
444
445 /* Now enable interrupts and do the switch */
446 _enable();
447 KiSwitchThreads(OldThread, NewThread->KernelStack);
448 }
449
450 VOID
451 NTAPI
452 KiDispatchInterrupt(VOID)
453 {
454 PKIPCR Pcr = (PKIPCR)KeGetPcr();
455 PKPRCB Prcb = &Pcr->PrcbData;
456 PVOID OldHandler;
457 PKTHREAD NewThread, OldThread;
458
459 /* Disable interrupts */
460 _disable();
461
462 /* Check for pending timers, pending DPCs, or pending ready threads */
463 if ((Prcb->DpcData[0].DpcQueueDepth) ||
464 (Prcb->TimerRequest) ||
465 (Prcb->DeferredReadyListHead.Next))
466 {
467 /* Switch to safe execution context */
468 OldHandler = Pcr->NtTib.ExceptionList;
469 Pcr->NtTib.ExceptionList = EXCEPTION_CHAIN_END;
470
471 /* Retire DPCs while under the DPC stack */
472 KiRetireDpcListInDpcStack(Prcb, Prcb->DpcStack);
473
474 /* Restore context */
475 Pcr->NtTib.ExceptionList = OldHandler;
476 }
477
478 /* Re-enable interrupts */
479 _enable();
480
481 /* Check for quantum end */
482 if (Prcb->QuantumEnd)
483 {
484 /* Handle quantum end */
485 Prcb->QuantumEnd = FALSE;
486 KiQuantumEnd();
487 }
488 else if (Prcb->NextThread)
489 {
490 /* Capture current thread data */
491 OldThread = Prcb->CurrentThread;
492 NewThread = Prcb->NextThread;
493
494 /* Set new thread data */
495 Prcb->NextThread = NULL;
496 Prcb->CurrentThread = NewThread;
497
498 /* The thread is now running */
499 NewThread->State = Running;
500 OldThread->WaitReason = WrDispatchInt;
501
502 /* Make the old thread ready */
503 KxQueueReadyThread(OldThread, Prcb);
504
505 /* Swap to the new thread */
506 KiSwapContext(APC_LEVEL, OldThread);
507 }
508 }
509
510
511 /* EOF */