976d2ebddc79a3ea273d89e2505c0a415618d970
[reactos.git] / reactos / ntoskrnl / ke / i386 / exp.c
1 /*
2 * PROJECT: ReactOS Kernel
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: ntoskrnl/ke/i386/exp.c
5 * PURPOSE: Exception Dispatching and Context<->Trap Frame Conversion
6 * PROGRAMMERS: Alex Ionescu (alex.ionescu@reactos.org)
7 * Gregor Anich
8 * Skywing (skywing@valhallalegends.com)
9 */
10
11 /* INCLUDES ******************************************************************/
12
13 #include <ntoskrnl.h>
14 #define NDEBUG
15 #include <debug.h>
16
17
18 /* FUNCTIONS *****************************************************************/
19
20 VOID
21 INIT_FUNCTION
22 NTAPI
23 KeInitExceptions(VOID)
24 {
25 ULONG i;
26 USHORT FlippedSelector;
27
28 /* Loop the IDT */
29 for (i = 0; i <= MAXIMUM_IDTVECTOR; i++)
30 {
31 /* Save the current Selector */
32 FlippedSelector = KiIdt[i].Selector;
33
34 /* Flip Selector and Extended Offset */
35 KiIdt[i].Selector = KiIdt[i].ExtendedOffset;
36 KiIdt[i].ExtendedOffset = FlippedSelector;
37 }
38 }
39
40 ULONG
41 FASTCALL
42 KiUpdateDr7(IN ULONG Dr7)
43 {
44 ULONG DebugMask = KeGetCurrentThread()->Header.DebugActive;
45
46 /* Check if debugging is enabled */
47 if (DebugMask & DR_MASK(DR7_OVERRIDE_V))
48 {
49 /* Sanity checks */
50 ASSERT((DebugMask & DR_REG_MASK) != 0);
51 ASSERT((Dr7 & ~DR7_RESERVED_MASK) == DR7_OVERRIDE_MASK);
52 return 0;
53 }
54
55 /* Return DR7 itself */
56 return Dr7;
57 }
58
59 BOOLEAN
60 FASTCALL
61 KiRecordDr7(OUT PULONG Dr7Ptr,
62 OUT PULONG DrMask)
63 {
64 ULONG NewMask, Mask;
65 UCHAR Result;
66
67 /* Check if the caller gave us a mask */
68 if (!DrMask)
69 {
70 /* He didn't, use the one from the thread */
71 Mask = KeGetCurrentThread()->Header.DebugActive;
72 }
73 else
74 {
75 /* He did, read it */
76 Mask = *DrMask;
77 }
78
79 /* Sanity check */
80 ASSERT((*Dr7Ptr & DR7_RESERVED_MASK) == 0);
81
82 /* Check if DR7 is empty */
83 NewMask = Mask;
84 if (!(*Dr7Ptr))
85 {
86 /* Assume failure */
87 Result = FALSE;
88
89 /* Check the DR mask */
90 NewMask &= ~(DR_MASK(7));
91 if (NewMask & DR_REG_MASK)
92 {
93 /* Set the active mask */
94 NewMask |= DR_MASK(DR7_OVERRIDE_V);
95
96 /* Set DR7 override */
97 *Dr7Ptr |= DR7_OVERRIDE_MASK;
98 }
99 else
100 {
101 /* Sanity check */
102 ASSERT(NewMask == 0);
103 }
104 }
105 else
106 {
107 /* Check if we have a mask or not */
108 Result = NewMask ? TRUE: FALSE;
109
110 /* Update the mask to disable debugging */
111 NewMask &= ~(DR_MASK(DR7_OVERRIDE_V));
112 NewMask |= DR_MASK(7);
113 }
114
115 /* Check if caller wants the new mask */
116 if (DrMask)
117 {
118 /* Update it */
119 *DrMask = NewMask;
120 }
121 else
122 {
123 /* Check if the mask changed */
124 if (Mask != NewMask)
125 {
126 /* Update it */
127 KeGetCurrentThread()->Header.DebugActive = (UCHAR)NewMask;
128 }
129 }
130
131 /* Return the result */
132 return Result;
133 }
134
135 ULONG
136 NTAPI
137 KiEspFromTrapFrame(IN PKTRAP_FRAME TrapFrame)
138 {
139 /* Check if this is user-mode or V86 */
140 if (KiUserTrap(TrapFrame) ||
141 (TrapFrame->EFlags & EFLAGS_V86_MASK))
142 {
143 /* Return it directly */
144 return TrapFrame->HardwareEsp;
145 }
146 else
147 {
148 /* Edited frame */
149 if (!(TrapFrame->SegCs & FRAME_EDITED))
150 {
151 /* Return edited value */
152 return TrapFrame->TempEsp;
153 }
154 else
155 {
156 /* Virgin frame, calculate */
157 return (ULONG)&TrapFrame->HardwareEsp;
158 }
159 }
160 }
161
162 VOID
163 NTAPI
164 KiEspToTrapFrame(IN PKTRAP_FRAME TrapFrame,
165 IN ULONG Esp)
166 {
167 KIRQL OldIrql;
168 ULONG Previous;
169
170 /* Raise to APC_LEVEL if needed */
171 OldIrql = KeGetCurrentIrql();
172 if (OldIrql < APC_LEVEL) KeRaiseIrql(APC_LEVEL, &OldIrql);
173
174 /* Get the old ESP */
175 Previous = KiEspFromTrapFrame(TrapFrame);
176
177 /* Check if this is user-mode or V86 */
178 if (KiUserTrap(TrapFrame) ||
179 (TrapFrame->EFlags & EFLAGS_V86_MASK))
180 {
181 /* Write it directly */
182 TrapFrame->HardwareEsp = Esp;
183 }
184 else
185 {
186 /* Don't allow ESP to be lowered, this is illegal */
187 if (Esp < Previous) KeBugCheckEx(SET_OF_INVALID_CONTEXT,
188 Esp,
189 Previous,
190 (ULONG_PTR)TrapFrame,
191 0);
192
193 /* Create an edit frame, check if it was alrady */
194 if (!(TrapFrame->SegCs & FRAME_EDITED))
195 {
196 /* Update the value */
197 TrapFrame->TempEsp = Esp;
198 }
199 else
200 {
201 /* Check if ESP changed */
202 if (Previous != Esp)
203 {
204 /* Save CS */
205 TrapFrame->TempSegCs = TrapFrame->SegCs;
206 TrapFrame->SegCs &= ~FRAME_EDITED;
207
208 /* Save ESP */
209 TrapFrame->TempEsp = Esp;
210 }
211 }
212 }
213
214 /* Restore IRQL */
215 if (OldIrql < APC_LEVEL) KeLowerIrql(OldIrql);
216 }
217
218 ULONG
219 NTAPI
220 KiSsFromTrapFrame(IN PKTRAP_FRAME TrapFrame)
221 {
222 /* Check if this was V86 Mode */
223 if (TrapFrame->EFlags & EFLAGS_V86_MASK)
224 {
225 /* Just return it */
226 return TrapFrame->HardwareSegSs;
227 }
228 else if (KiUserTrap(TrapFrame))
229 {
230 /* User mode, return the User SS */
231 return TrapFrame->HardwareSegSs | RPL_MASK;
232 }
233 else
234 {
235 /* Kernel mode */
236 return KGDT_R0_DATA;
237 }
238 }
239
240 VOID
241 NTAPI
242 KiSsToTrapFrame(IN PKTRAP_FRAME TrapFrame,
243 IN ULONG Ss)
244 {
245 /* Remove the high-bits */
246 Ss &= 0xFFFF;
247
248 /* If this was V86 Mode */
249 if (TrapFrame->EFlags & EFLAGS_V86_MASK)
250 {
251 /* Just write it */
252 TrapFrame->HardwareSegSs = Ss;
253 }
254 else if (KiUserTrap(TrapFrame))
255 {
256 /* Usermode, save the User SS */
257 TrapFrame->HardwareSegSs = Ss | RPL_MASK;
258 }
259 }
260
261 USHORT
262 NTAPI
263 KiTagWordFnsaveToFxsave(USHORT TagWord)
264 {
265 INT FxTagWord = ~TagWord;
266
267 /*
268 * Empty is now 00, any 2 bits containing 1 mean valid
269 * Now convert the rest (11->0 and the rest to 1)
270 */
271 FxTagWord = (FxTagWord | (FxTagWord >> 1)) & 0x5555; /* 0V0V0V0V0V0V0V0V */
272 FxTagWord = (FxTagWord | (FxTagWord >> 1)) & 0x3333; /* 00VV00VV00VV00VV */
273 FxTagWord = (FxTagWord | (FxTagWord >> 2)) & 0x0f0f; /* 0000VVVV0000VVVV */
274 FxTagWord = (FxTagWord | (FxTagWord >> 4)) & 0x00ff; /* 00000000VVVVVVVV */
275 return FxTagWord;
276 }
277
278 VOID
279 NTAPI
280 Ki386AdjustEsp0(IN PKTRAP_FRAME TrapFrame)
281 {
282 PKTHREAD Thread;
283 ULONG_PTR Stack;
284 ULONG EFlags;
285
286 /* Get the current thread's stack */
287 Thread = KeGetCurrentThread();
288 Stack = (ULONG_PTR)Thread->InitialStack;
289
290 /* Check if we are in V8086 mode */
291 if (!(TrapFrame->EFlags & EFLAGS_V86_MASK))
292 {
293 /* Bias the stack for the V86 segments */
294 Stack -= (FIELD_OFFSET(KTRAP_FRAME, V86Gs) -
295 FIELD_OFFSET(KTRAP_FRAME, HardwareSegSs));
296 }
297
298 /* Bias the stack for the FPU area */
299 Stack -= sizeof(FX_SAVE_AREA);
300
301 /* Disable interrupts */
302 EFlags = __readeflags();
303 _disable();
304
305 /* Set new ESP0 value in the TSS */
306 KeGetPcr()->TSS->Esp0 = Stack;
307
308 /* Restore old interrupt state */
309 __writeeflags(EFlags);
310 }
311
312 VOID
313 NTAPI
314 KeContextToTrapFrame(IN PCONTEXT Context,
315 IN OUT PKEXCEPTION_FRAME ExceptionFrame,
316 IN OUT PKTRAP_FRAME TrapFrame,
317 IN ULONG ContextFlags,
318 IN KPROCESSOR_MODE PreviousMode)
319 {
320 PFX_SAVE_AREA FxSaveArea;
321 ULONG i;
322 BOOLEAN V86Switch = FALSE;
323 KIRQL OldIrql;
324 ULONG DrMask = 0;
325
326 /* Do this at APC_LEVEL */
327 OldIrql = KeGetCurrentIrql();
328 if (OldIrql < APC_LEVEL) KeRaiseIrql(APC_LEVEL, &OldIrql);
329
330 /* Start with the basic Registers */
331 if ((ContextFlags & CONTEXT_CONTROL) == CONTEXT_CONTROL)
332 {
333 /* Check if we went through a V86 switch */
334 if ((Context->EFlags & EFLAGS_V86_MASK) !=
335 (TrapFrame->EFlags & EFLAGS_V86_MASK))
336 {
337 /* We did, remember this for later */
338 V86Switch = TRUE;
339 }
340
341 /* Copy EFLAGS and sanitize them*/
342 TrapFrame->EFlags = Ke386SanitizeFlags(Context->EFlags, PreviousMode);
343
344 /* Copy EBP and EIP */
345 TrapFrame->Ebp = Context->Ebp;
346 TrapFrame->Eip = Context->Eip;
347
348 /* Check if we were in V86 Mode */
349 if (TrapFrame->EFlags & EFLAGS_V86_MASK)
350 {
351 /* Simply copy the CS value */
352 TrapFrame->SegCs = Context->SegCs;
353 }
354 else
355 {
356 /* We weren't in V86, so sanitize the CS */
357 TrapFrame->SegCs = Ke386SanitizeSeg(Context->SegCs, PreviousMode);
358
359 /* Don't let it under 8, that's invalid */
360 if ((PreviousMode != KernelMode) && (TrapFrame->SegCs < 8))
361 {
362 /* Force it to User CS */
363 TrapFrame->SegCs = KGDT_R3_CODE | RPL_MASK;
364 }
365 }
366
367 /* Handle SS Specially for validation */
368 KiSsToTrapFrame(TrapFrame, Context->SegSs);
369
370 /* Write ESP back; take into account Edited Trap Frames */
371 KiEspToTrapFrame(TrapFrame, Context->Esp);
372
373 /* Handle our V86 Bias if we went through a switch */
374 if (V86Switch) Ki386AdjustEsp0(TrapFrame);
375 }
376
377 /* Process the Integer Registers */
378 if ((ContextFlags & CONTEXT_INTEGER) == CONTEXT_INTEGER)
379 {
380 /* Copy them manually */
381 TrapFrame->Eax = Context->Eax;
382 TrapFrame->Ebx = Context->Ebx;
383 TrapFrame->Ecx = Context->Ecx;
384 TrapFrame->Edx = Context->Edx;
385 TrapFrame->Esi = Context->Esi;
386 TrapFrame->Edi = Context->Edi;
387 }
388
389 /* Process the Context Segments */
390 if ((ContextFlags & CONTEXT_SEGMENTS) == CONTEXT_SEGMENTS)
391 {
392 /* Check if we were in V86 Mode */
393 if (TrapFrame->EFlags & EFLAGS_V86_MASK)
394 {
395 /* Copy the V86 Segments directly */
396 TrapFrame->V86Ds = Context->SegDs;
397 TrapFrame->V86Es = Context->SegEs;
398 TrapFrame->V86Fs = Context->SegFs;
399 TrapFrame->V86Gs = Context->SegGs;
400 }
401 else if (!KiUserTrap(TrapFrame))
402 {
403 /* For kernel mode, write the standard values */
404 TrapFrame->SegDs = KGDT_R3_DATA | RPL_MASK;
405 TrapFrame->SegEs = KGDT_R3_DATA | RPL_MASK;
406 TrapFrame->SegFs = Ke386SanitizeSeg(Context->SegFs, PreviousMode);
407 TrapFrame->SegGs = 0;
408 }
409 else
410 {
411 /* For user mode, return the values directly */
412 TrapFrame->SegDs = Context->SegDs;
413 TrapFrame->SegEs = Context->SegEs;
414 TrapFrame->SegFs = Context->SegFs;
415
416 /* Handle GS specially */
417 if (TrapFrame->SegCs == (KGDT_R3_CODE | RPL_MASK))
418 {
419 /* Don't use it, if user */
420 TrapFrame->SegGs = 0;
421 }
422 else
423 {
424 /* Copy it if kernel */
425 TrapFrame->SegGs = Context->SegGs;
426 }
427 }
428 }
429
430 /* Handle the extended registers */
431 if (((ContextFlags & CONTEXT_EXTENDED_REGISTERS) ==
432 CONTEXT_EXTENDED_REGISTERS) && KiUserTrap(TrapFrame))
433 {
434 /* Get the FX Area */
435 FxSaveArea = (PFX_SAVE_AREA)(TrapFrame + 1);
436
437 /* Check if NPX is present */
438 if (KeI386NpxPresent)
439 {
440 /* Flush the NPX State */
441 KiFlushNPXState(NULL);
442
443 /* Copy the FX State */
444 RtlCopyMemory(&FxSaveArea->U.FxArea,
445 &Context->ExtendedRegisters[0],
446 MAXIMUM_SUPPORTED_EXTENSION);
447
448 /* Remove reserved bits from MXCSR */
449 FxSaveArea->U.FxArea.MXCsr &= KiMXCsrMask;
450
451 /* Mask out any invalid flags */
452 FxSaveArea->Cr0NpxState &= ~(CR0_EM | CR0_MP | CR0_TS);
453
454 /* Check if this is a VDM app */
455 if (PsGetCurrentProcess()->VdmObjects)
456 {
457 /* Allow the EM flag */
458 FxSaveArea->Cr0NpxState |= Context->FloatSave.Cr0NpxState &
459 (CR0_EM | CR0_MP);
460 }
461 }
462 }
463
464 /* Handle the floating point state */
465 if (((ContextFlags & CONTEXT_FLOATING_POINT) ==
466 CONTEXT_FLOATING_POINT) && KiUserTrap(TrapFrame))
467 {
468 /* Get the FX Area */
469 FxSaveArea = (PFX_SAVE_AREA)(TrapFrame + 1);
470
471 /* Check if NPX is present */
472 if (KeI386NpxPresent)
473 {
474 /* Flush the NPX State */
475 KiFlushNPXState(NULL);
476
477 /* Check if we have Fxsr support */
478 if (KeI386FxsrPresent)
479 {
480 /* Convert the Fn Floating Point state to Fx */
481 FxSaveArea->U.FxArea.ControlWord =
482 (USHORT)Context->FloatSave.ControlWord;
483 FxSaveArea->U.FxArea.StatusWord =
484 (USHORT)Context->FloatSave.StatusWord;
485 FxSaveArea->U.FxArea.TagWord =
486 KiTagWordFnsaveToFxsave((USHORT)Context->FloatSave.TagWord);
487 FxSaveArea->U.FxArea.ErrorOpcode =
488 (USHORT)((Context->FloatSave.ErrorSelector >> 16) & 0xFFFF);
489 FxSaveArea->U.FxArea.ErrorOffset =
490 Context->FloatSave.ErrorOffset;
491 FxSaveArea->U.FxArea.ErrorSelector =
492 Context->FloatSave.ErrorSelector & 0xFFFF;
493 FxSaveArea->U.FxArea.DataOffset =
494 Context->FloatSave.DataOffset;
495 FxSaveArea->U.FxArea.DataSelector =
496 Context->FloatSave.DataSelector;
497
498 /* Clear out the Register Area */
499 RtlZeroMemory(&FxSaveArea->U.FxArea.RegisterArea[0],
500 SIZE_OF_FX_REGISTERS);
501
502 /* Loop the 8 floating point registers */
503 for (i = 0; i < 8; i++)
504 {
505 /* Copy from Fn to Fx */
506 RtlCopyMemory(FxSaveArea->U.FxArea.RegisterArea + (i * 16),
507 Context->FloatSave.RegisterArea + (i * 10),
508 10);
509 }
510 }
511 else
512 {
513 /* Copy the structure */
514 FxSaveArea->U.FnArea.ControlWord = Context->FloatSave.
515 ControlWord;
516 FxSaveArea->U.FnArea.StatusWord = Context->FloatSave.
517 StatusWord;
518 FxSaveArea->U.FnArea.TagWord = Context->FloatSave.TagWord;
519 FxSaveArea->U.FnArea.ErrorOffset = Context->FloatSave.
520 ErrorOffset;
521 FxSaveArea->U.FnArea.ErrorSelector = Context->FloatSave.
522 ErrorSelector;
523 FxSaveArea->U.FnArea.DataOffset = Context->FloatSave.
524 DataOffset;
525 FxSaveArea->U.FnArea.DataSelector = Context->FloatSave.
526 DataSelector;
527
528 /* Loop registers */
529 for (i = 0; i < SIZE_OF_80387_REGISTERS; i++)
530 {
531 /* Copy registers */
532 FxSaveArea->U.FnArea.RegisterArea[i] =
533 Context->FloatSave.RegisterArea[i];
534 }
535 }
536
537 /* Mask out any invalid flags */
538 FxSaveArea->Cr0NpxState &= ~(CR0_EM | CR0_MP | CR0_TS);
539
540 /* Check if this is a VDM app */
541 if (PsGetCurrentProcess()->VdmObjects)
542 {
543 /* Allow the EM flag */
544 FxSaveArea->Cr0NpxState |= Context->FloatSave.Cr0NpxState &
545 (CR0_EM | CR0_MP);
546 }
547 }
548 else
549 {
550 /* FIXME: Handle FPU Emulation */
551 //ASSERT(FALSE);
552 }
553 }
554
555 /* Handle the Debug Registers */
556 if ((ContextFlags & CONTEXT_DEBUG_REGISTERS) == CONTEXT_DEBUG_REGISTERS)
557 {
558 /* Copy Dr0 - Dr4 */
559 TrapFrame->Dr0 = Context->Dr0;
560 TrapFrame->Dr1 = Context->Dr1;
561 TrapFrame->Dr2 = Context->Dr2;
562 TrapFrame->Dr3 = Context->Dr3;
563
564 /* If we're in user-mode */
565 if (PreviousMode != KernelMode)
566 {
567 /* Make sure, no Dr address is above user space */
568 if (Context->Dr0 > (ULONG)MmHighestUserAddress) TrapFrame->Dr0 = 0;
569 if (Context->Dr1 > (ULONG)MmHighestUserAddress) TrapFrame->Dr1 = 0;
570 if (Context->Dr2 > (ULONG)MmHighestUserAddress) TrapFrame->Dr2 = 0;
571 if (Context->Dr3 > (ULONG)MmHighestUserAddress) TrapFrame->Dr3 = 0;
572 }
573
574 /* Now sanitize and save DR6 */
575 TrapFrame->Dr6 = Context->Dr6 & DR6_LEGAL;
576
577 /* Update the Dr active mask */
578 if (TrapFrame->Dr0) DrMask |= DR_MASK(0);
579 if (TrapFrame->Dr1) DrMask |= DR_MASK(1);
580 if (TrapFrame->Dr2) DrMask |= DR_MASK(2);
581 if (TrapFrame->Dr3) DrMask |= DR_MASK(3);
582 if (TrapFrame->Dr6) DrMask |= DR_MASK(6);
583
584 /* Sanitize and save DR7 */
585 TrapFrame->Dr7 = Context->Dr7 & DR7_LEGAL;
586 KiRecordDr7(&TrapFrame->Dr7, &DrMask);
587
588 /* If we're in user-mode */
589 if (PreviousMode != KernelMode)
590 {
591 /* Save the mask */
592 KeGetCurrentThread()->Header.DebugActive = (UCHAR)DrMask;
593 }
594 }
595
596 /* Check if thread has IOPL and force it enabled if so */
597 if (KeGetCurrentThread()->Iopl) TrapFrame->EFlags |= EFLAGS_IOPL;
598
599 /* Restore IRQL */
600 if (OldIrql < APC_LEVEL) KeLowerIrql(OldIrql);
601 }
602
603 VOID
604 NTAPI
605 KeTrapFrameToContext(IN PKTRAP_FRAME TrapFrame,
606 IN PKEXCEPTION_FRAME ExceptionFrame,
607 IN OUT PCONTEXT Context)
608 {
609 PFX_SAVE_AREA FxSaveArea;
610 struct _AlignHack
611 {
612 UCHAR Hack[15];
613 FLOATING_SAVE_AREA UnalignedArea;
614 } FloatSaveBuffer;
615 FLOATING_SAVE_AREA *FloatSaveArea;
616 KIRQL OldIrql;
617 ULONG i;
618
619 /* Do this at APC_LEVEL */
620 OldIrql = KeGetCurrentIrql();
621 if (OldIrql < APC_LEVEL) KeRaiseIrql(APC_LEVEL, &OldIrql);
622
623 /* Start with the Control flags */
624 if ((Context->ContextFlags & CONTEXT_CONTROL) == CONTEXT_CONTROL)
625 {
626 /* EBP, EIP and EFLAGS */
627 Context->Ebp = TrapFrame->Ebp;
628 Context->Eip = TrapFrame->Eip;
629 Context->EFlags = TrapFrame->EFlags;
630
631 /* Return the correct CS */
632 if (!(TrapFrame->SegCs & FRAME_EDITED) &&
633 !(TrapFrame->EFlags & EFLAGS_V86_MASK))
634 {
635 /* Get it from the Temp location */
636 Context->SegCs = TrapFrame->TempSegCs & 0xFFFF;
637 }
638 else
639 {
640 /* Return it directly */
641 Context->SegCs = TrapFrame->SegCs & 0xFFFF;
642 }
643
644 /* Get the Ss and ESP */
645 Context->SegSs = KiSsFromTrapFrame(TrapFrame);
646 Context->Esp = KiEspFromTrapFrame(TrapFrame);
647 }
648
649 /* Handle the Segments */
650 if ((Context->ContextFlags & CONTEXT_SEGMENTS) == CONTEXT_SEGMENTS)
651 {
652 /* Do V86 Mode first */
653 if (TrapFrame->EFlags & EFLAGS_V86_MASK)
654 {
655 /* Return from the V86 location */
656 Context->SegGs = TrapFrame->V86Gs & 0xFFFF;
657 Context->SegFs = TrapFrame->V86Fs & 0xFFFF;
658 Context->SegEs = TrapFrame->V86Es & 0xFFFF;
659 Context->SegDs = TrapFrame->V86Ds & 0xFFFF;
660 }
661 else
662 {
663 /* Check if this was a Kernel Trap */
664 if (TrapFrame->SegCs == KGDT_R0_CODE)
665 {
666 /* Set valid selectors */
667 TrapFrame->SegGs = 0;
668 TrapFrame->SegFs = KGDT_R0_PCR;
669 TrapFrame->SegEs = KGDT_R3_DATA | RPL_MASK;
670 TrapFrame->SegDs = KGDT_R3_DATA | RPL_MASK;
671 }
672
673 /* Return the segments */
674 Context->SegGs = TrapFrame->SegGs & 0xFFFF;
675 Context->SegFs = TrapFrame->SegFs & 0xFFFF;
676 Context->SegEs = TrapFrame->SegEs & 0xFFFF;
677 Context->SegDs = TrapFrame->SegDs & 0xFFFF;
678 }
679 }
680
681 /* Handle the simple registers */
682 if ((Context->ContextFlags & CONTEXT_INTEGER) == CONTEXT_INTEGER)
683 {
684 /* Return them directly */
685 Context->Eax = TrapFrame->Eax;
686 Context->Ebx = TrapFrame->Ebx;
687 Context->Ecx = TrapFrame->Ecx;
688 Context->Edx = TrapFrame->Edx;
689 Context->Esi = TrapFrame->Esi;
690 Context->Edi = TrapFrame->Edi;
691 }
692
693 /* Handle extended registers */
694 if (((Context->ContextFlags & CONTEXT_EXTENDED_REGISTERS) ==
695 CONTEXT_EXTENDED_REGISTERS) && KiUserTrap(TrapFrame))
696 {
697 /* Get the FX Save Area */
698 FxSaveArea = (PFX_SAVE_AREA)(TrapFrame + 1);
699
700 /* Make sure NPX is present */
701 if (KeI386NpxPresent)
702 {
703 /* Flush the NPX State */
704 KiFlushNPXState(NULL);
705
706 /* Copy the registers */
707 RtlCopyMemory(&Context->ExtendedRegisters[0],
708 &FxSaveArea->U.FxArea,
709 MAXIMUM_SUPPORTED_EXTENSION);
710 }
711 }
712
713 /* Handle Floating Point */
714 if (((Context->ContextFlags & CONTEXT_FLOATING_POINT) ==
715 CONTEXT_FLOATING_POINT) && KiUserTrap(TrapFrame))
716 {
717 /* Get the FX Save Area */
718 FxSaveArea = (PFX_SAVE_AREA)(TrapFrame + 1);
719
720 /* Make sure we have an NPX */
721 if (KeI386NpxPresent)
722 {
723 /* Check if we have Fxsr support */
724 if (KeI386FxsrPresent)
725 {
726 /* Align the floating area to 16-bytes */
727 FloatSaveArea = (FLOATING_SAVE_AREA*)
728 ((ULONG_PTR)&FloatSaveBuffer.UnalignedArea &~ 0xF);
729
730 /* Get the State */
731 KiFlushNPXState(FloatSaveArea);
732 }
733 else
734 {
735 /* We don't, use the FN area and flush the NPX State */
736 FloatSaveArea = (FLOATING_SAVE_AREA*)&FxSaveArea->U.FnArea;
737 KiFlushNPXState(NULL);
738 }
739
740 /* Copy structure */
741 Context->FloatSave.ControlWord = FloatSaveArea->ControlWord;
742 Context->FloatSave.StatusWord = FloatSaveArea->StatusWord;
743 Context->FloatSave.TagWord = FloatSaveArea->TagWord;
744 Context->FloatSave.ErrorOffset = FloatSaveArea->ErrorOffset;
745 Context->FloatSave.ErrorSelector = FloatSaveArea->ErrorSelector;
746 Context->FloatSave.DataOffset = FloatSaveArea->DataOffset;
747 Context->FloatSave.DataSelector = FloatSaveArea->DataSelector;
748 Context->FloatSave.Cr0NpxState = FxSaveArea->Cr0NpxState;
749
750 /* Loop registers */
751 for (i = 0; i < SIZE_OF_80387_REGISTERS; i++)
752 {
753 /* Copy them */
754 Context->FloatSave.RegisterArea[i] =
755 FloatSaveArea->RegisterArea[i];
756 }
757 }
758 else
759 {
760 /* FIXME: Handle Emulation */
761 ASSERT(FALSE);
762 }
763 }
764
765 /* Handle debug registers */
766 if ((Context->ContextFlags & CONTEXT_DEBUG_REGISTERS) ==
767 CONTEXT_DEBUG_REGISTERS)
768 {
769 /* Make sure DR7 is valid */
770 if (TrapFrame->Dr7 & ~DR7_RESERVED_MASK)
771 {
772 /* Copy the debug registers */
773 Context->Dr0 = TrapFrame->Dr0;
774 Context->Dr1 = TrapFrame->Dr1;
775 Context->Dr2 = TrapFrame->Dr2;
776 Context->Dr3 = TrapFrame->Dr3;
777 Context->Dr6 = TrapFrame->Dr6;
778
779 /* Update DR7 */
780 Context->Dr7 = KiUpdateDr7(TrapFrame->Dr7);
781 }
782 else
783 {
784 /* Otherwise clear DR registers */
785 Context->Dr0 =
786 Context->Dr1 =
787 Context->Dr2 =
788 Context->Dr3 =
789 Context->Dr6 =
790 Context->Dr7 = 0;
791 }
792 }
793
794 /* Restore IRQL */
795 if (OldIrql < APC_LEVEL) KeLowerIrql(OldIrql);
796 }
797
798 BOOLEAN
799 FASTCALL
800 KeInvalidAccessAllowed(IN PVOID TrapInformation OPTIONAL)
801 {
802 ULONG Eip;
803 PKTRAP_FRAME TrapFrame = TrapInformation;
804 VOID NTAPI ExpInterlockedPopEntrySListFault(VOID);
805
806 /* Don't do anything if we didn't get a trap frame */
807 if (!TrapInformation) return FALSE;
808
809 /* Check where we came from */
810 switch (TrapFrame->SegCs)
811 {
812 /* Kernel mode */
813 case KGDT_R0_CODE:
814
815 /* Allow S-LIST Routine to fail */
816 Eip = (ULONG)&ExpInterlockedPopEntrySListFault;
817 break;
818
819 /* User code */
820 case KGDT_R3_CODE | RPL_MASK:
821
822 /* Allow S-LIST Routine to fail */
823 //Eip = (ULONG)KeUserPopEntrySListFault;
824 Eip = 0;
825 break;
826
827 default:
828
829 /* Anything else gets a bugcheck */
830 Eip = 0;
831 }
832
833 /* Return TRUE if we want to keep the system up */
834 return (TrapFrame->Eip == Eip) ? TRUE : FALSE;
835 }
836
837 VOID
838 NTAPI
839 KiDispatchException(IN PEXCEPTION_RECORD ExceptionRecord,
840 IN PKEXCEPTION_FRAME ExceptionFrame,
841 IN PKTRAP_FRAME TrapFrame,
842 IN KPROCESSOR_MODE PreviousMode,
843 IN BOOLEAN FirstChance)
844 {
845 CONTEXT Context;
846 EXCEPTION_RECORD LocalExceptRecord;
847
848 /* Increase number of Exception Dispatches */
849 KeGetCurrentPrcb()->KeExceptionDispatchCount++;
850
851 /* Set the context flags */
852 Context.ContextFlags = CONTEXT_FULL | CONTEXT_DEBUG_REGISTERS;
853
854 /* Check if User Mode or if the kernel debugger is enabled */
855 if ((PreviousMode == UserMode) || (KeGetPcr()->KdVersionBlock))
856 {
857 /* Add the FPU Flag */
858 Context.ContextFlags |= CONTEXT_FLOATING_POINT;
859
860 /* Check for NPX Support */
861 if (KeI386FxsrPresent)
862 {
863 /* Save those too */
864 Context.ContextFlags |= CONTEXT_EXTENDED_REGISTERS;
865 }
866 }
867
868 /* Get a Context */
869 KeTrapFrameToContext(TrapFrame, ExceptionFrame, &Context);
870
871 /* Look at our exception code */
872 switch (ExceptionRecord->ExceptionCode)
873 {
874 /* Breakpoint */
875 case STATUS_BREAKPOINT:
876
877 /* Decrement EIP by one */
878 Context.Eip--;
879 break;
880
881 /* Internal exception */
882 case KI_EXCEPTION_ACCESS_VIOLATION:
883
884 /* Set correct code */
885 ExceptionRecord->ExceptionCode = STATUS_ACCESS_VIOLATION;
886 if (PreviousMode == UserMode)
887 {
888 /* FIXME: Handle no execute */
889 }
890 break;
891 }
892
893 /* Sanity check */
894 ASSERT(!((PreviousMode == KernelMode) &&
895 (Context.EFlags & EFLAGS_V86_MASK)));
896
897 /* Handle kernel-mode first, it's simpler */
898 if (PreviousMode == KernelMode)
899 {
900 /* Check if this is a first-chance exception */
901 if (FirstChance == TRUE)
902 {
903 /* Break into the debugger for the first time */
904 if (KiDebugRoutine(TrapFrame,
905 ExceptionFrame,
906 ExceptionRecord,
907 &Context,
908 PreviousMode,
909 FALSE))
910 {
911 /* Exception was handled */
912 goto Handled;
913 }
914
915 /* If the Debugger couldn't handle it, dispatch the exception */
916 if (RtlDispatchException(ExceptionRecord, &Context)) goto Handled;
917 }
918
919 /* This is a second-chance exception, only for the debugger */
920 if (KiDebugRoutine(TrapFrame,
921 ExceptionFrame,
922 ExceptionRecord,
923 &Context,
924 PreviousMode,
925 TRUE))
926 {
927 /* Exception was handled */
928 goto Handled;
929 }
930
931 /* Third strike; you're out */
932 KeBugCheckEx(KMODE_EXCEPTION_NOT_HANDLED,
933 ExceptionRecord->ExceptionCode,
934 (ULONG_PTR)ExceptionRecord->ExceptionAddress,
935 (ULONG_PTR)TrapFrame,
936 0);
937 }
938 else
939 {
940 /* User mode exception, was it first-chance? */
941 if (FirstChance)
942 {
943 /*
944 * Break into the kernel debugger unless a user mode debugger
945 * is present or user mode exceptions are ignored, except if this
946 * is a debug service which we must always pass to KD
947 */
948 if ((!(PsGetCurrentProcess()->DebugPort) &&
949 !(KdIgnoreUmExceptions)) ||
950 (KdIsThisAKdTrap(ExceptionRecord,
951 &Context,
952 PreviousMode)))
953 {
954 /* Call the kernel debugger */
955 if (KiDebugRoutine(TrapFrame,
956 ExceptionFrame,
957 ExceptionRecord,
958 &Context,
959 PreviousMode,
960 FALSE))
961 {
962 /* Exception was handled */
963 goto Handled;
964 }
965 }
966
967 /* Forward exception to user mode debugger */
968 if (DbgkForwardException(ExceptionRecord, TRUE, FALSE)) return;
969
970 /* Set up the user-stack */
971 DispatchToUser:
972 _SEH2_TRY
973 {
974 ULONG Size;
975 ULONG_PTR Stack, NewStack;
976
977 /* Make sure we have a valid SS and that this isn't V86 mode */
978 if ((TrapFrame->HardwareSegSs != (KGDT_R3_DATA | RPL_MASK)) ||
979 (TrapFrame->EFlags & EFLAGS_V86_MASK))
980 {
981 /* Raise an exception instead */
982 LocalExceptRecord.ExceptionCode = STATUS_ACCESS_VIOLATION;
983 LocalExceptRecord.ExceptionFlags = 0;
984 LocalExceptRecord.NumberParameters = 0;
985 RtlRaiseException(&LocalExceptRecord);
986 }
987
988 /* Align context size and get stack pointer */
989 Size = (sizeof(CONTEXT) + 3) & ~3;
990 Stack = (Context.Esp & ~3) - Size;
991
992 /* Probe stack and copy Context */
993 ProbeForWrite((PVOID)Stack, Size, sizeof(ULONG));
994 RtlCopyMemory((PVOID)Stack, &Context, sizeof(CONTEXT));
995
996 /* Align exception record size and get stack pointer */
997 Size = (sizeof(EXCEPTION_RECORD) -
998 (EXCEPTION_MAXIMUM_PARAMETERS -
999 ExceptionRecord->NumberParameters) *
1000 sizeof(ULONG) + 3) & ~3;
1001 NewStack = Stack - Size;
1002
1003 /* Probe stack and copy exception record */
1004 ProbeForWrite((PVOID)(NewStack - 2 * sizeof(ULONG_PTR)),
1005 Size + 2 * sizeof(ULONG_PTR),
1006 sizeof(ULONG));
1007 RtlCopyMemory((PVOID)NewStack, ExceptionRecord, Size);
1008
1009 /* Now write the two params for the user-mode dispatcher */
1010 *(PULONG_PTR)(NewStack - 1 * sizeof(ULONG_PTR)) = Stack;
1011 *(PULONG_PTR)(NewStack - 2 * sizeof(ULONG_PTR)) = NewStack;
1012
1013 /* Set new Stack Pointer */
1014 KiSsToTrapFrame(TrapFrame, KGDT_R3_DATA);
1015 KiEspToTrapFrame(TrapFrame, NewStack - 2 * sizeof(ULONG_PTR));
1016
1017 /* Force correct segments */
1018 TrapFrame->SegCs = Ke386SanitizeSeg(KGDT_R3_CODE, PreviousMode);
1019 TrapFrame->SegDs = Ke386SanitizeSeg(KGDT_R3_DATA, PreviousMode);
1020 TrapFrame->SegEs = Ke386SanitizeSeg(KGDT_R3_DATA, PreviousMode);
1021 TrapFrame->SegFs = Ke386SanitizeSeg(KGDT_R3_TEB, PreviousMode);
1022 TrapFrame->SegGs = 0;
1023
1024 /* Set EIP to the User-mode Dispatcher */
1025 TrapFrame->Eip = (ULONG)KeUserExceptionDispatcher;
1026
1027 /* Dispatch exception to user-mode */
1028 _SEH2_YIELD(return);
1029 }
1030 _SEH2_EXCEPT((RtlCopyMemory(&LocalExceptRecord, _SEH2_GetExceptionInformation()->ExceptionRecord, sizeof(EXCEPTION_RECORD)), EXCEPTION_EXECUTE_HANDLER))
1031 {
1032 /* Check if we got a stack overflow and raise that instead */
1033 if ((NTSTATUS)LocalExceptRecord.ExceptionCode ==
1034 STATUS_STACK_OVERFLOW)
1035 {
1036 /* Copy the exception address and record */
1037 LocalExceptRecord.ExceptionAddress =
1038 ExceptionRecord->ExceptionAddress;
1039 RtlCopyMemory(ExceptionRecord,
1040 (PVOID)&LocalExceptRecord,
1041 sizeof(EXCEPTION_RECORD));
1042
1043 /* Do the exception again */
1044 _SEH2_YIELD(goto DispatchToUser);
1045 }
1046 }
1047 _SEH2_END;
1048
1049 DPRINT("First chance exception in %.16s, ExceptionCode: %lx, ExceptionAddress: %p, P0: %lx, P1: %lx\n",
1050 PsGetCurrentProcess()->ImageFileName,
1051 ExceptionRecord->ExceptionCode,
1052 ExceptionRecord->ExceptionAddress,
1053 ExceptionRecord->ExceptionInformation[0],
1054 ExceptionRecord->ExceptionInformation[1]);
1055 }
1056
1057 /* Try second chance */
1058 if (DbgkForwardException(ExceptionRecord, TRUE, TRUE))
1059 {
1060 /* Handled, get out */
1061 return;
1062 }
1063 else if (DbgkForwardException(ExceptionRecord, FALSE, TRUE))
1064 {
1065 /* Handled, get out */
1066 return;
1067 }
1068
1069 /* 3rd strike, kill the process */
1070 DPRINT1("Kill %.16s, ExceptionCode: %lx, ExceptionAddress: %p, BaseAddress: %p, P0: %lx, P1: %lx\n",
1071 PsGetCurrentProcess()->ImageFileName,
1072 ExceptionRecord->ExceptionCode,
1073 ExceptionRecord->ExceptionAddress,
1074 PsGetCurrentProcess()->SectionBaseAddress,
1075 ExceptionRecord->ExceptionInformation[0],
1076 ExceptionRecord->ExceptionInformation[1]);
1077
1078 ZwTerminateProcess(NtCurrentProcess(), ExceptionRecord->ExceptionCode);
1079 KeBugCheckEx(KMODE_EXCEPTION_NOT_HANDLED,
1080 ExceptionRecord->ExceptionCode,
1081 (ULONG_PTR)ExceptionRecord->ExceptionAddress,
1082 (ULONG_PTR)TrapFrame,
1083 0);
1084 }
1085
1086 Handled:
1087 /* Convert the context back into Trap/Exception Frames */
1088 KeContextToTrapFrame(&Context,
1089 ExceptionFrame,
1090 TrapFrame,
1091 Context.ContextFlags,
1092 PreviousMode);
1093 return;
1094 }
1095
1096 DECLSPEC_NORETURN
1097 VOID
1098 NTAPI
1099 KiDispatchExceptionFromTrapFrame(IN NTSTATUS Code,
1100 IN ULONG_PTR Address,
1101 IN ULONG ParameterCount,
1102 IN ULONG_PTR Parameter1,
1103 IN ULONG_PTR Parameter2,
1104 IN ULONG_PTR Parameter3,
1105 IN PKTRAP_FRAME TrapFrame)
1106 {
1107 EXCEPTION_RECORD ExceptionRecord;
1108
1109 /* Build the exception record */
1110 ExceptionRecord.ExceptionCode = Code;
1111 ExceptionRecord.ExceptionFlags = 0;
1112 ExceptionRecord.ExceptionRecord = NULL;
1113 ExceptionRecord.ExceptionAddress = (PVOID)Address;
1114 ExceptionRecord.NumberParameters = ParameterCount;
1115 if (ParameterCount)
1116 {
1117 /* Copy extra parameters */
1118 ExceptionRecord.ExceptionInformation[0] = Parameter1;
1119 ExceptionRecord.ExceptionInformation[1] = Parameter2;
1120 ExceptionRecord.ExceptionInformation[2] = Parameter3;
1121 }
1122
1123 /* Now go dispatch the exception */
1124 KiDispatchException(&ExceptionRecord,
1125 NULL,
1126 TrapFrame,
1127 TrapFrame->EFlags & EFLAGS_V86_MASK ?
1128 -1 : KiUserTrap(TrapFrame),
1129 TRUE);
1130
1131 /* Return from this trap */
1132 KiEoiHelper(TrapFrame);
1133 }
1134
1135 DECLSPEC_NORETURN
1136 VOID
1137 FASTCALL
1138 KiSystemFatalException(IN ULONG ExceptionCode,
1139 IN PKTRAP_FRAME TrapFrame)
1140 {
1141 /* Bugcheck the system */
1142 KeBugCheckWithTf(UNEXPECTED_KERNEL_MODE_TRAP,
1143 ExceptionCode,
1144 0,
1145 0,
1146 0,
1147 TrapFrame);
1148 }
1149
1150 /* PUBLIC FUNCTIONS ***********************************************************/
1151
1152 /*
1153 * @implemented
1154 */
1155 NTSTATUS
1156 NTAPI
1157 KeRaiseUserException(IN NTSTATUS ExceptionCode)
1158 {
1159 ULONG OldEip;
1160 PTEB Teb = KeGetCurrentThread()->Teb;
1161 PKTRAP_FRAME TrapFrame = KeGetCurrentThread()->TrapFrame;
1162
1163 /* Make sure we can access the TEB */
1164 _SEH2_TRY
1165 {
1166 /* Set the exception code */
1167 Teb->ExceptionCode = ExceptionCode;
1168 }
1169 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1170 {
1171 /* Return the exception code */
1172 _SEH2_YIELD(return _SEH2_GetExceptionCode());
1173 }
1174 _SEH2_END;
1175
1176 /* Get the old EIP */
1177 OldEip = TrapFrame->Eip;
1178
1179 /* Change it to the user-mode dispatcher */
1180 TrapFrame->Eip = (ULONG_PTR)KeRaiseUserExceptionDispatcher;
1181
1182 /* Return the old EIP */
1183 return (NTSTATUS)OldEip;
1184 }