- Correctly zero out esi. Thanks to Patrick Baggett.
[reactos.git] / reactos / ntoskrnl / ke / i386 / ctxswitch.S
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS kernel
4 * FILE: ntoskrnl/ke/i386/ctxswitch.S
5 * PURPOSE: Thread Context Switching
6 *
7 * PROGRAMMERS: Alex Ionescu (alex@relsoft.net)
8 * Gregor Anich (FPU Code)
9 */
10
11 /* INCLUDES ******************************************************************/
12
13 #include <roscfg.h>
14 #include <internal/i386/ke.h>
15 #include <ndk/asm.h>
16 .intel_syntax noprefix
17
18 #define Running 2
19 #define SIZEOF_TRAP_FRAME 0x8c
20 #define APC_LEVEL 1
21
22 /* GLOBALS ****************************************************************/
23
24 /* FUNCTIONS ****************************************************************/
25
26 /*++
27 * KiThreadStartup
28 *
29 * The KiThreadStartup routine is the beginning of any thread.
30 *
31 * Params:
32 * SystemRoutine - Pointer to the System Startup Routine. Either
33 * PspUserThreadStartup or PspSystemThreadStartup
34 *
35 * StartRoutine - For Kernel Threads only, specifies the starting execution
36 * point of the new thread.
37 *
38 * StartContext - For Kernel Threads only, specifies a pointer to variable
39 * context data to be sent to the StartRoutine above.
40 *
41 * UserThread - Indicates whether or not this is a user thread. This tells
42 * us if the thread has a context or not.
43 *
44 * TrapFrame - Pointer to the KTHREAD to which the caller wishes to
45 * switch from.
46 *
47 * Returns:
48 * Should never return for a system thread. Returns through the System Call
49 * Exit Dispatcher for a user thread.
50 *
51 * Remarks:
52 * If a return from a system thread is detected, a bug check will occur.
53 *
54 *--*/
55 .globl _KiThreadStartup@156
56 _KiThreadStartup@156:
57
58 /*
59 * Clear all the non-volatile registers, so the thread won't be tempted to
60 * expect any static data (like some badly coded usermode/win9x apps do)
61 */
62 xor ebx, ebx
63 xor esi, esi
64 xor edi, edi
65 xor ebp, ebp
66
67 /* It's now safe to go to APC */
68 mov ecx, APC_LEVEL
69 call @KfLowerIrql@4
70
71 /*
72 * Call the System Routine which is right on our stack now.
73 * After we pop the pointer, the Start Routine/Context will be on the
74 * stack, as parameters to the System Routine
75 */
76 pop eax
77 call eax
78
79 /* The thread returned... was it a user-thread? */
80 pop ecx
81 or ecx, ecx
82 jz BadThread
83
84 /* Yes it was, set our trapframe for the System Call Exit Dispatcher */
85 mov ebp, esp
86
87 /* Exit back to user-mode */
88 jmp _KiServiceExit2
89
90 BadThread:
91
92 /* A system thread returned...this is very bad! */
93 int 3
94
95 /*++
96 * KiSwapContextInternal
97 *
98 * The KiSwapContextInternal routine switches context to another thread.
99 *
100 * Params:
101 * ESI - Pointer to the KTHREAD to which the caller wishes to
102 * switch to.
103 * EDI - Pointer to the KTHREAD to which the caller wishes to
104 * switch from.
105 *
106 * Returns:
107 * None.
108 *
109 * Remarks:
110 * Absolutely all registers except ESP can be trampled here for maximum code flexibility.
111 *
112 *--*/
113 .globl @KiSwapContextInternal@0
114 @KiSwapContextInternal@0:
115 #ifdef KDBG
116 //jmp SaveTrapFrameForKDB
117 SaveTrapFrameForKDB_Return:
118 #endif
119
120 /* Get the PCR. It's faster to use ebx+offset then fs:offset */
121 mov ebx, [fs:KPCR_SELF]
122
123 /* Set the Thread to running */
124 mov byte ptr [esi+KTHREAD_STATE], Running
125
126 /* Save the Exception list */
127 push [ebx+KPCR_EXCEPTION_LIST]
128
129 /* Switching, disable interrupts now */
130 cli
131
132 /* Save the initial stack in EAX */
133 mov eax, [edi+KTHREAD_INITIAL_STACK]
134
135 #ifdef CONFIG_SMP
136 /* Save FPU state if the thread has used it. */
137 mov dword ptr [ebx+KPCR_NPX_THREAD], 0
138 test byte ptr [edi+KTHREAD_NPX_STATE], NPX_STATE_DIRTY
139 jz 3f
140 cmp dword ptr _FxsrSupport, 0
141 je 1f
142 fxsave [eax-SIZEOF_FX_SAVE_AREA]
143 jmp 2f
144 1:
145 fnsave [eax-SIZEOF_FX_SAVE_AREA]
146 2:
147 mov byte ptr [edi+KTHREAD_NPX_STATE], NPX_STATE_VALID
148 3:
149 #endif /* CONFIG_SMP */
150
151 /* Save the stack pointer in this processors TSS */
152 mov ebp, [ebx+KPCR_TSS]
153
154 /* Check if this isn't V86 Mode, so we can bias the Esp0 */
155 test dword ptr [eax - KTRAP_FRAME_SIZE + KTRAP_FRAME_EFLAGS], X86_EFLAGS_VM
156 jnz NoAdjust
157
158 /* Bias esp */
159 //sub dword ptr ss:[ebp+KTSS_ESP0], KTRAP_FRAME_V86_GS - KTRAP_FRAME_SS
160
161 NoAdjust:
162 /* Push ESP0 Value */
163 push ss:[ebp+KTSS_ESP0]
164
165 /* Check if address space switch is needed */
166 mov eax, [esi+KTHREAD_APCSTATE_PROCESS]
167 cmp eax, [edi+KTHREAD_APCSTATE_PROCESS]
168 mov eax, [eax+KPROCESS_DIRECTORY_TABLE_BASE]
169
170 /* Switch stacks */
171 mov [edi+KTHREAD_KERNEL_STACK], esp
172 mov esp, [esi+KTHREAD_KERNEL_STACK]
173
174 jz NoAddressSpaceSwitch
175
176 /* Switch address space */
177 mov cr3, eax
178
179 NoAddressSpaceSwitch:
180
181 /* Stack is OK, safe to enable interrupts now */
182 sti
183
184 /* Check if address space switch is needed (the result from above is valid) */
185 /* If they match, then use the fast-path and skip all this */
186 jz SameProcess
187
188 /* Get the new Process. */
189 mov edi, [esi+KTHREAD_APCSTATE_PROCESS]
190
191 /* Check if we need an LDT */
192 xor eax, eax
193 cmp [edi+KPROCESS_LDT_DESCRIPTOR0], eax
194 jz NoLdt
195
196 /* Write the LDT Selector */
197 mov ebp, [ebx+KPCR_GDT]
198 mov eax, [edi+KPROCESS_LDT_DESCRIPTOR0]
199 mov [ebp+KGDT_LDT], eax
200 mov eax, [edi+KPROCESS_LDT_DESCRIPTOR1]
201 mov [ebp+KGDT_LDT+4], eax
202
203 /* Save LDT Selector */
204 mov eax, KGDT_LDT
205
206 NoLdt:
207
208 /* Load LDT */
209 lldt ax
210
211 /* Get the IOPM */
212 mov ecx, [edi+KPROCESS_IOPM_OFFSET]
213
214 /* Set current IOPM offset in the TSS */
215 mov [ebp+KTSS_IOMAPBASE], cx
216
217 SameProcess:
218
219 /* Set the TEB */
220 mov eax, [esi+KTHREAD_TEB]
221 mov ecx, [ebx+KPCR_GDT]
222 mov [ecx+0x3A], ax
223 shr eax, 16
224 mov [ecx+0x3C], al
225 mov [ecx+0x3F], ah
226
227 /* Increase context switches */
228 inc dword ptr [esi+KTHREAD_CONTEXT_SWITCHES]
229
230 /* Set TS in cr0 to catch FPU code and load the FPU state when needed */
231 #ifndef CONFIG_SMP
232 cmp [ebx+KPCR_NPX_THREAD], esi
233 je 4f
234 #endif /* !CONFIG_SMP */
235 mov eax, cr0
236 or eax, X86_CR0_TS
237 mov cr0, eax
238 4:
239
240 /* Restore the stack pointer in this processors TSS */
241 pop ss:[ebp+KTSS_ESP0]
242
243 /* Restore exception list */
244 pop [ebx+KPCR_EXCEPTION_LIST]
245
246 /* Return */
247 call @KeReleaseDispatcherDatabaseLockFromDpcLevel@0
248 ret
249
250 /*++
251 * KiSwapContext
252 *
253 * The KiSwapContext routine switches context to another thread.
254 *
255 * Params:
256 * TargetThread - Pointer to the KTHREAD to which the caller wishes to
257 * switch to.
258 *
259 * Returns:
260 * The WaitStatus of the Target Thread. NOT YET SUPPORTED.
261 *
262 * Remarks:
263 * This is a wrapper around KiSwapContextInternal which will save all the
264 * non-volatile registers so that the Internal function can use all of
265 * them. It will also save the old current thread and set the new one.
266 *
267 * The calling thread does not return after KiSwapContextInternal until
268 * another thread switches to IT.
269 *
270 *--*/
271 .globl @KiSwapContext@4
272 @KiSwapContext@4:
273 /* Note, we CANNOT touch ebp */
274
275 /* Save 4 registers */
276 sub esp, 4 * 4
277
278 /* Save all the non-volatile ones */
279 mov [esp+12], ebx
280 mov [esp+8], esi
281 mov [esp+4], edi
282 mov [esp+0], ebp
283
284 /* Get the Current Thread */
285 mov edi, fs:[KPCR_CURRENT_THREAD]
286
287 /* Get the New Thread */
288 mov esi, ecx
289
290 /* Save it as Current thread */
291 mov fs:[KPCR_CURRENT_THREAD], esi
292
293 /* Do the swap with the registers correctly setup */
294 call @KiSwapContextInternal@0
295
296 /* Return the registers */
297 mov ebp, [esp+0]
298 mov edi, [esp+4]
299 mov esi, [esp+8]
300 mov ebx, [esp+12]
301
302 /* Clean stack */
303 add esp, 4 * 4
304 ret
305
306 #ifdef KDBG
307
308 SaveTrapFrameForKDB:
309 /* Set up a trap frame */
310 pushf // 0x70
311 push cs // 0x6C
312 push 0 /* Error Code */ // 0x64
313 push ebp // 0x60
314 push ebx
315
316 /* Fake Interrupt Stack */
317 mov ebp, [esp+20] /* Eip */
318 mov ebx, [esp+16] /* Eflags */
319 mov [esp+20], ebx
320 mov ebx, [esp+12] /* Cs */
321 mov [esp+16], ebx
322 mov [esp+12], ebp
323
324 push esi
325 push edi
326 push fs
327 push -1 /* Exception List */ // 0x4C
328 push 0 /* Previous Mode */ // 0x48
329 push eax
330 push ecx
331 push edx
332 push ds
333 push es
334 push gs // 0x30
335
336 mov eax, dr7
337 push eax /* Dr7 */
338 /* Clear breakpoint enables in dr7. */
339 and eax, 0xffff0000
340 mov dr7, eax
341 mov eax, dr6
342 push eax /* Dr6 */
343 mov eax, dr3
344 push eax /* Dr3 */
345 mov eax, dr2
346 push eax /* Dr2 */
347 mov eax, dr1
348 push eax /* Dr1 */
349 mov eax, dr0
350 push eax /* Dr0 */
351
352 lea eax, [esp+0x58]
353 push eax /* TempEsp */
354 push ss /* TempSegSs */
355 push 0 /* DebugPointer */
356 push -1 /* DebugArgMark */
357 push [esp+60] /* Debug EIP */ // 0x4
358 push ebp /* Debug EBP */ // 0x0
359
360 /* Set Stack */
361 mov ebp, esp
362
363 /* Push old Trap Frame */
364 push [edi+KTHREAD_TRAP_FRAME]
365
366 /* Save new one */
367 mov [edi+KTHREAD_TRAP_FRAME], ebp
368
369 /* Restore EBP, EBX and EAX */
370 mov ebp, [ebp+KTRAP_FRAME_EBP]
371 mov ebx, [ebp+KTRAP_FRAME_EBX]
372 mov eax, [ebp+KTRAP_FRAME_EAX]
373
374 /* Return EIP */
375 push offset RestoreTrapFrameForKDB
376
377 /* Jump to normal code */
378 jmp SaveTrapFrameForKDB_Return
379
380 RestoreTrapFrameForKDB:
381
382 /* Restore the old trapframe */
383 pop [esi+KTHREAD_TRAP_FRAME]
384
385 /* Pop unused portions of the trap frame */
386 add esp, 0x30
387
388 /* Restore registers from Trap frame */
389 pop gs
390 pop es
391 pop ds
392 pop edx
393 pop ecx
394 pop eax
395 add esp, 8 /* ExceptionList and PreviousMode */
396 pop fs
397 pop edi
398 pop esi
399 pop ebx
400 pop ebp
401 add esp, 4 /* ErrorCode */
402
403 /* Return to the caller. */
404 iret
405 #endif /* KDBG */
406
407