ReactOS 0.4.16-dev-1946-g52006dd
Macros | Functions
context.c File Reference
#include <ntoskrnl.h>
#include <debug.h>
Include dependency graph for context.c:

Go to the source code of this file.

Macros

#define NDEBUG
 

Functions

VOID NTAPI KeContextToTrapFrame (IN PCONTEXT Context, IN OUT PKEXCEPTION_FRAME ExceptionFrame, IN OUT PKTRAP_FRAME TrapFrame, IN ULONG ContextFlags, IN KPROCESSOR_MODE PreviousMode)
 
VOID NTAPI KeTrapFrameToContext (IN PKTRAP_FRAME TrapFrame, IN PKEXCEPTION_FRAME ExceptionFrame, IN OUT PCONTEXT Context)
 
VOID RtlGetUnwindContext (_Out_ PCONTEXT Context, _In_ DWORD64 TargetFrame)
 
VOID KiGetTrapContextInternal (_In_ PKTRAP_FRAME TrapFrame, _Out_ PCONTEXT Context)
 
VOID RtlSetUnwindContext (_In_ PCONTEXT Context, _In_ DWORD64 TargetFrame)
 
VOID KiSetTrapContextInternal (_Out_ PKTRAP_FRAME TrapFrame, _In_ PCONTEXT Context, _In_ KPROCESSOR_MODE RequestorMode)
 

Macro Definition Documentation

◆ NDEBUG

#define NDEBUG

Definition at line 12 of file context.c.

Function Documentation

◆ KeContextToTrapFrame()

VOID NTAPI KeContextToTrapFrame ( IN PCONTEXT  Context,
IN OUT PKEXCEPTION_FRAME  ExceptionFrame,
IN OUT PKTRAP_FRAME  TrapFrame,
IN ULONG  ContextFlags,
IN KPROCESSOR_MODE  PreviousMode 
)

Definition at line 19 of file context.c.

24{
25 KIRQL OldIrql;
26
27 /* Make sure we have an amd64 context, then remove the flag */
28 ASSERT(ContextFlags & CONTEXT_AMD64);
29 ContextFlags &= ~CONTEXT_AMD64;
30
31 /* Do this at APC_LEVEL */
32 OldIrql = KeGetCurrentIrql();
33 if (OldIrql < APC_LEVEL) KeRaiseIrql(APC_LEVEL, &OldIrql);
34
35 /* Handle integer registers */
36 if (ContextFlags & CONTEXT_INTEGER)
37 {
38 TrapFrame->Rax = Context->Rax;
39 TrapFrame->Rcx = Context->Rcx;
40 TrapFrame->Rdx = Context->Rdx;
41 TrapFrame->Rbp = Context->Rbp;
42 TrapFrame->R8 = Context->R8;
43 TrapFrame->R9 = Context->R9;
44 TrapFrame->R10 = Context->R10;
45 TrapFrame->R11 = Context->R11;
46 if (ExceptionFrame)
47 {
48 ExceptionFrame->Rbx = Context->Rbx;
49 ExceptionFrame->Rsi = Context->Rsi;
50 ExceptionFrame->Rdi = Context->Rdi;
51 ExceptionFrame->R12 = Context->R12;
52 ExceptionFrame->R13 = Context->R13;
53 ExceptionFrame->R14 = Context->R14;
54 ExceptionFrame->R15 = Context->R15;
55 }
56 }
57
58 /* Handle floating point registers */
59 if (ContextFlags & CONTEXT_FLOATING_POINT)
60 {
61 TrapFrame->MxCsr = Context->MxCsr;
62 TrapFrame->Xmm0 = Context->Xmm0;
63 TrapFrame->Xmm1 = Context->Xmm1;
64 TrapFrame->Xmm2 = Context->Xmm2;
65 TrapFrame->Xmm3 = Context->Xmm3;
66 TrapFrame->Xmm4 = Context->Xmm4;
67 TrapFrame->Xmm5 = Context->Xmm5;
68 if (ExceptionFrame)
69 {
70 ExceptionFrame->Xmm6 = Context->Xmm6;
71 ExceptionFrame->Xmm7 = Context->Xmm7;
72 ExceptionFrame->Xmm8 = Context->Xmm8;
73 ExceptionFrame->Xmm9 = Context->Xmm9;
74 ExceptionFrame->Xmm10 = Context->Xmm10;
75 ExceptionFrame->Xmm11 = Context->Xmm11;
76 ExceptionFrame->Xmm12 = Context->Xmm12;
77 ExceptionFrame->Xmm13 = Context->Xmm13;
78 ExceptionFrame->Xmm14 = Context->Xmm14;
79 ExceptionFrame->Xmm15 = Context->Xmm15;
80 }
81 }
82
83 /* Handle control registers */
84 if (ContextFlags & CONTEXT_CONTROL)
85 {
86 /* RIP, RSP, EFLAGS */
87 TrapFrame->Rip = Context->Rip;
88 TrapFrame->Rsp = Context->Rsp;
89 TrapFrame->EFlags = Context->EFlags;
90
91 if ((Context->SegCs & MODE_MASK) == KernelMode)
92 {
93 /* Set valid selectors */
94 TrapFrame->SegCs = KGDT64_R0_CODE;
95 TrapFrame->SegSs = KGDT64_R0_DATA;
96
97 /* Set valid EFLAGS */
98 TrapFrame->EFlags &= (EFLAGS_USER_SANITIZE | EFLAGS_INTERRUPT_MASK);
99 }
100 else
101 {
102 /* Copy selectors */
103 TrapFrame->SegCs = Context->SegCs;
104 if (TrapFrame->SegCs != (KGDT64_R3_CODE | RPL_MASK))
105 {
106 TrapFrame->SegCs = (KGDT64_R3_CMCODE | RPL_MASK);
107 }
108
109 TrapFrame->SegSs = Context->SegSs;
110
111 /* Set valid EFLAGS */
112 TrapFrame->EFlags &= EFLAGS_USER_SANITIZE;
113 TrapFrame->EFlags |= EFLAGS_INTERRUPT_MASK;
114 }
115 }
116
117 /* Handle segment selectors */
118 if (ContextFlags & CONTEXT_SEGMENTS)
119 {
120 /* Check if this was a Kernel Trap */
121 if ((Context->SegCs & MODE_MASK) == KernelMode)
122 {
123 /* Set valid selectors */
124 TrapFrame->SegDs = KGDT64_R3_DATA | RPL_MASK;
125 TrapFrame->SegEs = KGDT64_R3_DATA | RPL_MASK;
126 TrapFrame->SegFs = KGDT64_R3_CMTEB | RPL_MASK;
127 TrapFrame->SegGs = KGDT64_R3_DATA | RPL_MASK;
128 }
129 else
130 {
131 /* Copy selectors */
132 TrapFrame->SegDs = Context->SegDs;
133 TrapFrame->SegEs = Context->SegEs;
134 TrapFrame->SegFs = Context->SegFs;
135 TrapFrame->SegGs = Context->SegGs;
136 }
137 }
138
139 /* Handle debug registers */
140 if (ContextFlags & CONTEXT_DEBUG_REGISTERS)
141 {
142 /* Copy the debug registers */
143 TrapFrame->Dr0 = Context->Dr0;
144 TrapFrame->Dr1 = Context->Dr1;
145 TrapFrame->Dr2 = Context->Dr2;
146 TrapFrame->Dr3 = Context->Dr3;
147 TrapFrame->Dr6 = Context->Dr6;
148 TrapFrame->Dr7 = Context->Dr7;
149
150 if ((Context->SegCs & MODE_MASK) != KernelMode)
151 {
152 if (TrapFrame->Dr0 > (ULONG64)MmHighestUserAddress)
153 TrapFrame->Dr0 = 0;
154 if (TrapFrame->Dr1 > (ULONG64)MmHighestUserAddress)
155 TrapFrame->Dr1 = 0;
156 if (TrapFrame->Dr2 > (ULONG64)MmHighestUserAddress)
157 TrapFrame->Dr2 = 0;
158 if (TrapFrame->Dr3 > (ULONG64)MmHighestUserAddress)
159 TrapFrame->Dr3 = 0;
160 }
161 }
162
163 /* Restore IRQL */
164 if (OldIrql < APC_LEVEL) KeLowerIrql(OldIrql);
165}
EFLAGS_INTERRUPT_MASK
#define EFLAGS_INTERRUPT_MASK
Definition: SystemCall.c:11
MODE_MASK
#define MODE_MASK
Definition: orders.h:326
KIRQL
UCHAR KIRQL
Definition: env_spec_w32.h:591
KeRaiseIrql
#define KeRaiseIrql(irql, oldIrql)
Definition: env_spec_w32.h:597
APC_LEVEL
#define APC_LEVEL
Definition: env_spec_w32.h:695
KeLowerIrql
#define KeLowerIrql(oldIrql)
Definition: env_spec_w32.h:602
KeGetCurrentIrql
#define KeGetCurrentIrql()
Definition: env_spec_w32.h:706
if
if(dx< 0)
Definition: linetemp.h:194
ASSERT
#define ASSERT(a)
Definition: mode.c:44
ULONG64
unsigned __int64 ULONG64
Definition: imports.h:198
EFLAGS_USER_SANITIZE
#define EFLAGS_USER_SANITIZE
Definition: ketypes.h:207
KGDT64_R3_CODE
#define KGDT64_R3_CODE
Definition: ketypes.h:131
KGDT64_R0_CODE
#define KGDT64_R0_CODE
Definition: ketypes.h:127
KGDT64_R3_DATA
#define KGDT64_R3_DATA
Definition: ketypes.h:130
KGDT64_R3_CMCODE
#define KGDT64_R3_CMCODE
Definition: ketypes.h:129
KGDT64_R3_CMTEB
#define KGDT64_R3_CMTEB
Definition: ketypes.h:133
KGDT64_R0_DATA
#define KGDT64_R0_DATA
Definition: ketypes.h:128
RPL_MASK
#define RPL_MASK
Definition: ketypes.h:124
KernelMode
#define KernelMode
Definition: asm.h:38
CONTEXT_DEBUG_REGISTERS
#define CONTEXT_DEBUG_REGISTERS
Definition: nt_native.h:1376
CONTEXT_CONTROL
#define CONTEXT_CONTROL
Definition: nt_native.h:1372
CONTEXT_INTEGER
#define CONTEXT_INTEGER
Definition: nt_native.h:1373
CONTEXT_FLOATING_POINT
#define CONTEXT_FLOATING_POINT
Definition: nt_native.h:1375
CONTEXT_SEGMENTS
#define CONTEXT_SEGMENTS
Definition: nt_native.h:1374
MmHighestUserAddress
PVOID MmHighestUserAddress
Definition: rtlcompat.c:29
CONTEXT_AMD64
#define CONTEXT_AMD64
Definition: winnt.h:26
OldIrql
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:778

Referenced by KiSetTrapContextInternal().

◆ KeTrapFrameToContext()

VOID NTAPI KeTrapFrameToContext ( IN PKTRAP_FRAME  TrapFrame,
IN PKEXCEPTION_FRAME  ExceptionFrame,
IN OUT PCONTEXT  Context 
)

Definition at line 169 of file context.c.

172{
173 ULONG ContextFlags;
174 KIRQL OldIrql;
175
176 /* Do this at APC_LEVEL */
177 OldIrql = KeGetCurrentIrql();
178 if (OldIrql < APC_LEVEL) KeRaiseIrql(APC_LEVEL, &OldIrql);
179
180 /* Make sure we have an amd64 context, then remove the flag */
181 ContextFlags = Context->ContextFlags;
182 ASSERT(ContextFlags & CONTEXT_AMD64);
183 ContextFlags &= ~CONTEXT_AMD64;
184
185 /* Handle integer registers */
186 if (ContextFlags & CONTEXT_INTEGER)
187 {
188 Context->Rax = TrapFrame->Rax;
189 Context->Rcx = TrapFrame->Rcx;
190 Context->Rdx = TrapFrame->Rdx;
191 Context->Rbp = TrapFrame->Rbp;
192 Context->R8 = TrapFrame->R8;
193 Context->R9 = TrapFrame->R9;
194 Context->R10 = TrapFrame->R10;
195 Context->R11 = TrapFrame->R11;
196
197 if (ExceptionFrame)
198 {
199 Context->Rbx = ExceptionFrame->Rbx;
200 Context->Rsi = ExceptionFrame->Rsi;
201 Context->Rdi = ExceptionFrame->Rdi;
202 Context->R12 = ExceptionFrame->R12;
203 Context->R13 = ExceptionFrame->R13;
204 Context->R14 = ExceptionFrame->R14;
205 Context->R15 = ExceptionFrame->R15;
206 }
207 }
208
209 /* Handle floating point registers */
210 if (ContextFlags & CONTEXT_FLOATING_POINT)
211 {
212 Context->MxCsr = TrapFrame->MxCsr;
213 Context->Xmm0 = TrapFrame->Xmm0;
214 Context->Xmm1 = TrapFrame->Xmm1;
215 Context->Xmm2 = TrapFrame->Xmm2;
216 Context->Xmm3 = TrapFrame->Xmm3;
217 Context->Xmm4 = TrapFrame->Xmm4;
218 Context->Xmm5 = TrapFrame->Xmm5;
219 if (ExceptionFrame)
220 {
221 Context->Xmm6 = ExceptionFrame->Xmm6;
222 Context->Xmm7 = ExceptionFrame->Xmm7;
223 Context->Xmm8 = ExceptionFrame->Xmm8;
224 Context->Xmm9 = ExceptionFrame->Xmm9;
225 Context->Xmm10 = ExceptionFrame->Xmm10;
226 Context->Xmm11 = ExceptionFrame->Xmm11;
227 Context->Xmm12 = ExceptionFrame->Xmm12;
228 Context->Xmm13 = ExceptionFrame->Xmm13;
229 Context->Xmm14 = ExceptionFrame->Xmm14;
230 Context->Xmm15 = ExceptionFrame->Xmm15;
231 }
232 }
233
234 /* Handle control registers */
235 if (ContextFlags & CONTEXT_CONTROL)
236 {
237 /* Check if this was a Kernel Trap */
238 if ((TrapFrame->SegCs & MODE_MASK) == KernelMode)
239 {
240 /* Set valid selectors */
241 Context->SegCs = KGDT64_R0_CODE;
242 Context->SegSs = KGDT64_R0_DATA;
243 }
244 else
245 {
246 /* Copy selectors */
247 Context->SegCs = TrapFrame->SegCs;
248 Context->SegSs = TrapFrame->SegSs;
249 }
250
251 /* Copy RIP, RSP, EFLAGS */
252 Context->Rip = TrapFrame->Rip;
253 Context->Rsp = TrapFrame->Rsp;
254 Context->EFlags = TrapFrame->EFlags;
255 }
256
257 /* Handle segment selectors */
258 if (ContextFlags & CONTEXT_SEGMENTS)
259 {
260 /* Check if this was a Kernel Trap */
261 if ((TrapFrame->SegCs & MODE_MASK) == KernelMode)
262 {
263 /* Set valid selectors */
264 Context->SegDs = KGDT64_R3_DATA | RPL_MASK;
265 Context->SegEs = KGDT64_R3_DATA | RPL_MASK;
266 Context->SegFs = KGDT64_R3_CMTEB | RPL_MASK;
267 Context->SegGs = KGDT64_R3_DATA | RPL_MASK;
268 }
269 else
270 {
271 /* Copy selectors */
272 Context->SegDs = TrapFrame->SegDs;
273 Context->SegEs = TrapFrame->SegEs;
274 Context->SegFs = TrapFrame->SegFs;
275 Context->SegGs = TrapFrame->SegGs;
276 }
277 }
278
279 /* Handle debug registers */
280 if (ContextFlags & CONTEXT_DEBUG_REGISTERS)
281 {
282 /* Copy the debug registers */
283 Context->Dr0 = TrapFrame->Dr0;
284 Context->Dr1 = TrapFrame->Dr1;
285 Context->Dr2 = TrapFrame->Dr2;
286 Context->Dr3 = TrapFrame->Dr3;
287 Context->Dr6 = TrapFrame->Dr6;
288 Context->Dr7 = TrapFrame->Dr7;
289 }
290
291 /* Restore IRQL */
292 if (OldIrql < APC_LEVEL) KeLowerIrql(OldIrql);
293}
ULONG
uint32_t ULONG
Definition: typedefs.h:59

Referenced by KiGetTrapContextInternal().

◆ KiGetTrapContextInternal()

VOID KiGetTrapContextInternal ( _In_ PKTRAP_FRAME  TrapFrame,
_Out_ PCONTEXT  Context 
)

Definition at line 301 of file context.c.

304{
305 ULONG64 TargetFrame;
306
307 /* Get the volatile register context from the trap frame */
308 KeTrapFrameToContext(TrapFrame, NULL, Context);
309
310 /* The target frame is MAX_SYSCALL_PARAM_SIZE bytes before the trap frame */
311 TargetFrame = (ULONG64)TrapFrame - MAX_SYSCALL_PARAM_SIZE;
312
313 /* Get the nonvolatiles on the stack */
314 RtlGetUnwindContext(Context, TargetFrame);
315}
NULL
#define NULL
Definition: types.h:112
MAX_SYSCALL_PARAM_SIZE
#define MAX_SYSCALL_PARAM_SIZE
Definition: ketypes.h:371
KeTrapFrameToContext
VOID NTAPI KeTrapFrameToContext(IN PKTRAP_FRAME TrapFrame, IN PKEXCEPTION_FRAME ExceptionFrame, IN OUT PCONTEXT Context)
Definition: context.c:169
RtlGetUnwindContext
VOID RtlGetUnwindContext(_Out_ PCONTEXT Context, _In_ DWORD64 TargetFrame)
Definition: unwind.c:1206

◆ KiSetTrapContextInternal()

VOID KiSetTrapContextInternal ( _Out_ PKTRAP_FRAME  TrapFrame,
_In_ PCONTEXT  Context,
_In_ KPROCESSOR_MODE  RequestorMode 
)

Definition at line 323 of file context.c.

327{
328 ULONG64 TargetFrame;
329
330 /* Save the volatile register context in the trap frame */
331 KeContextToTrapFrame(Context,
332 NULL,
333 TrapFrame,
334 Context->ContextFlags,
335 RequestorMode);
336
337 /* The target frame is MAX_SYSCALL_PARAM_SIZE bytes before the trap frame */
338 TargetFrame = (ULONG64)TrapFrame - MAX_SYSCALL_PARAM_SIZE ;
339
340 /* Set the nonvolatiles on the stack */
341 RtlSetUnwindContext(Context, TargetFrame);
342}
KeContextToTrapFrame
VOID NTAPI KeContextToTrapFrame(IN PCONTEXT Context, IN OUT PKEXCEPTION_FRAME ExceptionFrame, IN OUT PKTRAP_FRAME TrapFrame, IN ULONG ContextFlags, IN KPROCESSOR_MODE PreviousMode)
Definition: context.c:19
RtlSetUnwindContext
VOID RtlSetUnwindContext(_In_ PCONTEXT Context, _In_ DWORD64 TargetFrame)
Definition: unwind.c:1243

◆ RtlGetUnwindContext()

VOID RtlGetUnwindContext ( _Out_ PCONTEXT  Context,
_In_ DWORD64  TargetFrame 
)

Definition at line 1206 of file unwind.c.

1209{
1210 KNONVOLATILE_CONTEXT_POINTERS ContextPointers;
1211 ULONG ContextFlags = Context->ContextFlags & ~CONTEXT_AMD64;
1212
1213 /* Capture pointers to the non-volatiles up to the target frame */
1214 RtlpCaptureNonVolatileContextPointers(&ContextPointers, TargetFrame);
1215
1216 /* Copy the nonvolatiles from the captured locations */
1217 if (ContextFlags & CONTEXT_INTEGER)
1218 {
1219 Context->Rbx = *ContextPointers.Rbx;
1220 Context->Rsi = *ContextPointers.Rsi;
1221 Context->Rdi = *ContextPointers.Rdi;
1222 Context->R12 = *ContextPointers.R12;
1223 Context->R13 = *ContextPointers.R13;
1224 Context->R14 = *ContextPointers.R14;
1225 Context->R15 = *ContextPointers.R15;
1226 }
1227 if (ContextFlags & CONTEXT_FLOATING_POINT)
1228 {
1229 Context->Xmm6 = *ContextPointers.Xmm6;
1230 Context->Xmm7 = *ContextPointers.Xmm7;
1231 Context->Xmm8 = *ContextPointers.Xmm8;
1232 Context->Xmm9 = *ContextPointers.Xmm9;
1233 Context->Xmm10 = *ContextPointers.Xmm10;
1234 Context->Xmm11 = *ContextPointers.Xmm11;
1235 Context->Xmm12 = *ContextPointers.Xmm12;
1236 Context->Xmm13 = *ContextPointers.Xmm13;
1237 Context->Xmm14 = *ContextPointers.Xmm14;
1238 Context->Xmm15 = *ContextPointers.Xmm15;
1239 }
1240}
RtlpCaptureNonVolatileContextPointers
static VOID RtlpCaptureNonVolatileContextPointers(_Out_ PKNONVOLATILE_CONTEXT_POINTERS NonvolatileContextPointers, _In_ ULONG64 TargetFrame)
Definition: unwind.c:1154

Referenced by KiGetTrapContextInternal().

◆ RtlSetUnwindContext()

VOID RtlSetUnwindContext ( _In_ PCONTEXT  Context,
_In_ DWORD64  TargetFrame 
)

Definition at line 1243 of file unwind.c.

1246{
1247 KNONVOLATILE_CONTEXT_POINTERS ContextPointers;
1248 ULONG ContextFlags = Context->ContextFlags & ~CONTEXT_AMD64;
1249
1250 /* Capture pointers to the non-volatiles up to the target frame */
1251 RtlpCaptureNonVolatileContextPointers(&ContextPointers, TargetFrame);
1252
1253 /* Copy the nonvolatiles to the captured locations */
1254 if (ContextFlags & CONTEXT_INTEGER)
1255 {
1256 *ContextPointers.Rbx = Context->Rbx;
1257 *ContextPointers.Rsi = Context->Rsi;
1258 *ContextPointers.Rdi = Context->Rdi;
1259 *ContextPointers.R12 = Context->R12;
1260 *ContextPointers.R13 = Context->R13;
1261 *ContextPointers.R14 = Context->R14;
1262 *ContextPointers.R15 = Context->R15;
1263 }
1264 if (ContextFlags & CONTEXT_FLOATING_POINT)
1265 {
1266 *ContextPointers.Xmm6 = Context->Xmm6;
1267 *ContextPointers.Xmm7 = Context->Xmm7;
1268 *ContextPointers.Xmm8 = Context->Xmm8;
1269 *ContextPointers.Xmm9 = Context->Xmm9;
1270 *ContextPointers.Xmm10 = Context->Xmm10;
1271 *ContextPointers.Xmm11 = Context->Xmm11;
1272 *ContextPointers.Xmm12 = Context->Xmm12;
1273 *ContextPointers.Xmm13 = Context->Xmm13;
1274 *ContextPointers.Xmm14 = Context->Xmm14;
1275 *ContextPointers.Xmm15 = Context->Xmm15;
1276 }
1277}

Referenced by KiSetTrapContextInternal().