[USETUP] Use _wcstoui64() instead of atoi() to convert the partition size in order...
[reactos.git] / ntoskrnl / ps / debug.c
1 /*
2 * PROJECT: ReactOS Kernel
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: ntoskrnl/ps/debug.c
5 * PURPOSE: Process Manager: Debugging Support (Set/Get Context)
6 * PROGRAMMERS: Alex Ionescu (alex.ionescu@reactos.org)
7 * Thomas Weidenmueller (w3seek@reactos.org)
8 */
9
10 /* INCLUDES ****************************************************************/
11
12 #include <ntoskrnl.h>
13 #define NDEBUG
14 #include <debug.h>
15
16 /* PRIVATE FUNCTIONS *********************************************************/
17
18 #if DBG
19 VOID
20 NTAPI
21 PspDumpThreads(BOOLEAN IncludeSystem)
22 {
23 PLIST_ENTRY CurrentThread, CurrentProcess;
24 PEPROCESS Process;
25 PETHREAD Thread;
26 ULONG nThreads = 0;
27
28 /* Loop all Active Processes */
29 CurrentProcess = PsActiveProcessHead.Flink;
30 while(CurrentProcess != &PsActiveProcessHead)
31 {
32 /* Get the process */
33 Process = CONTAINING_RECORD(CurrentProcess, EPROCESS, ActiveProcessLinks);
34
35 /* Skip the Initial Process if requested */
36 if((Process != PsInitialSystemProcess) ||
37 (Process == PsInitialSystemProcess && IncludeSystem))
38 {
39 /* Loop all its threads */
40 CurrentThread = Process->ThreadListHead.Flink;
41 while(CurrentThread != &Process->ThreadListHead)
42 {
43
44 /* Get teh Thread */
45 Thread = CONTAINING_RECORD(CurrentThread, ETHREAD, ThreadListEntry);
46 nThreads++;
47
48 /* Print the Info */
49 DbgPrint("State %u Affinity %08x Priority %d PID.TID %d.%d Name %.8s Stack: \n",
50 Thread->Tcb.State,
51 Thread->Tcb.Affinity,
52 Thread->Tcb.Priority,
53 Thread->Cid.UniqueProcess,
54 Thread->Cid.UniqueThread,
55 Thread->ThreadsProcess->ImageFileName);
56
57 /* Make sure it's not running */
58 if(Thread->Tcb.State == Ready ||
59 Thread->Tcb.State == Standby ||
60 Thread->Tcb.State == Waiting)
61 {
62 #ifdef _M_IX86
63 ULONG i = 0;
64 PULONG Esp = (PULONG)Thread->Tcb.KernelStack;
65 PULONG Ebp = (PULONG)Esp[4];
66
67 /* Print EBP */
68 DbgPrint("Ebp %p\n", Ebp);
69
70 /* Walk it */
71 while(Ebp != 0 && Ebp >= (PULONG)Thread->Tcb.StackLimit)
72 {
73 /* Print what's on the stack */
74 DbgPrint("%.8X %.8X%s", Ebp[0], Ebp[1], (i % 8) == 7 ? "\n" : " ");
75 Ebp = (PULONG)Ebp[0];
76 i++;
77 }
78
79 /* Print a new line if there's nothing */
80 if((i % 8) != 0) DbgPrint("\n");
81 #else
82 DbgPrint("FIXME: Backtrace skipped on non-x86\n");
83 #endif
84 }
85
86 /* Move to the next Thread */
87 CurrentThread = CurrentThread->Flink;
88 }
89 }
90
91 /* Move to the next Process */
92 CurrentProcess = CurrentProcess->Flink;
93 }
94 }
95 #endif
96
97 /* PUBLIC FUNCTIONS **********************************************************/
98
99 /*
100 * @implemented
101 */
102 NTSTATUS
103 NTAPI
104 PsGetContextThread(IN PETHREAD Thread,
105 IN OUT PCONTEXT ThreadContext,
106 IN KPROCESSOR_MODE PreviousMode)
107 {
108 GET_SET_CTX_CONTEXT GetSetContext;
109 ULONG Size = 0, Flags = 0;
110 NTSTATUS Status;
111
112 /* Enter SEH */
113 _SEH2_TRY
114 {
115 /* Set default ength */
116 Size = sizeof(CONTEXT);
117
118 /* Read the flags */
119 Flags = ProbeForReadUlong(&ThreadContext->ContextFlags);
120
121 #ifdef _M_IX86
122 /* Check if the caller wanted extended registers */
123 if ((Flags & CONTEXT_EXTENDED_REGISTERS) !=
124 CONTEXT_EXTENDED_REGISTERS)
125 {
126 /* Cut them out of the size */
127 Size = FIELD_OFFSET(CONTEXT, ExtendedRegisters);
128 }
129 #endif
130
131 /* Check if we came from user mode */
132 if (PreviousMode != KernelMode)
133 {
134 /* Probe the context */
135 ProbeForWrite(ThreadContext, Size, sizeof(ULONG));
136 }
137 }
138 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
139 {
140 /* Return the exception code */
141 _SEH2_YIELD(return _SEH2_GetExceptionCode());
142 }
143 _SEH2_END;
144
145 /* Initialize the wait event */
146 KeInitializeEvent(&GetSetContext.Event, NotificationEvent, FALSE);
147
148 /* Set the flags and previous mode */
149 GetSetContext.Context.ContextFlags = Flags;
150 GetSetContext.Mode = PreviousMode;
151
152 /* Check if we're running in the same thread */
153 if (Thread == PsGetCurrentThread())
154 {
155 /* Setup APC parameters manually */
156 GetSetContext.Apc.SystemArgument1 = NULL;
157 GetSetContext.Apc.SystemArgument2 = Thread;
158
159 /* Enter a guarded region to simulate APC_LEVEL */
160 KeEnterGuardedRegion();
161
162 /* Manually call the APC */
163 PspGetOrSetContextKernelRoutine(&GetSetContext.Apc,
164 NULL,
165 NULL,
166 &GetSetContext.Apc.SystemArgument1,
167 &GetSetContext.Apc.SystemArgument2);
168
169 /* Leave the guarded region */
170 KeLeaveGuardedRegion();
171
172 /* We are done */
173 Status = STATUS_SUCCESS;
174 }
175 else
176 {
177 /* Initialize the APC */
178 KeInitializeApc(&GetSetContext.Apc,
179 &Thread->Tcb,
180 OriginalApcEnvironment,
181 PspGetOrSetContextKernelRoutine,
182 NULL,
183 NULL,
184 KernelMode,
185 NULL);
186
187 /* Queue it as a Get APC */
188 if (!KeInsertQueueApc(&GetSetContext.Apc, NULL, Thread, 2))
189 {
190 /* It was already queued, so fail */
191 Status = STATUS_UNSUCCESSFUL;
192 }
193 else
194 {
195 /* Wait for the APC to complete */
196 Status = KeWaitForSingleObject(&GetSetContext.Event,
197 0,
198 KernelMode,
199 FALSE,
200 NULL);
201 }
202 }
203
204 _SEH2_TRY
205 {
206 /* Copy the context */
207 RtlCopyMemory(ThreadContext, &GetSetContext.Context, Size);
208 }
209 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
210 {
211 /* Get the exception code */
212 Status = _SEH2_GetExceptionCode();
213 }
214 _SEH2_END;
215
216 /* Return status */
217 return Status;
218 }
219
220 /*
221 * @implemented
222 */
223 NTSTATUS
224 NTAPI
225 PsSetContextThread(IN PETHREAD Thread,
226 IN OUT PCONTEXT ThreadContext,
227 IN KPROCESSOR_MODE PreviousMode)
228 {
229 GET_SET_CTX_CONTEXT GetSetContext;
230 ULONG Size = 0, Flags = 0;
231 NTSTATUS Status;
232
233 /* Enter SEH */
234 _SEH2_TRY
235 {
236 /* Set default length */
237 Size = sizeof(CONTEXT);
238
239 /* Read the flags */
240 Flags = ProbeForReadUlong(&ThreadContext->ContextFlags);
241
242 #ifdef _M_IX86
243 /* Check if the caller wanted extended registers */
244 if ((Flags & CONTEXT_EXTENDED_REGISTERS) !=
245 CONTEXT_EXTENDED_REGISTERS)
246 {
247 /* Cut them out of the size */
248 Size = FIELD_OFFSET(CONTEXT, ExtendedRegisters);
249 }
250 #endif
251
252 /* Check if we came from user mode */
253 if (PreviousMode != KernelMode)
254 {
255 /* Probe the context */
256 ProbeForRead(ThreadContext, Size, sizeof(ULONG));
257 }
258
259 /* Copy the context */
260 RtlCopyMemory(&GetSetContext.Context, ThreadContext, Size);
261 }
262 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
263 {
264 /* Return the exception code */
265 _SEH2_YIELD(return _SEH2_GetExceptionCode());
266 }
267 _SEH2_END;
268
269 /* Initialize the wait event */
270 KeInitializeEvent(&GetSetContext.Event, NotificationEvent, FALSE);
271
272 /* Set the flags and previous mode */
273 GetSetContext.Context.ContextFlags = Flags;
274 GetSetContext.Mode = PreviousMode;
275
276 /* Check if we're running in the same thread */
277 if (Thread == PsGetCurrentThread())
278 {
279 /* Setup APC parameters manually */
280 GetSetContext.Apc.SystemArgument1 = UlongToPtr(1);
281 GetSetContext.Apc.SystemArgument2 = Thread;
282
283 /* Enter a guarded region to simulate APC_LEVEL */
284 KeEnterGuardedRegion();
285
286 /* Manually call the APC */
287 PspGetOrSetContextKernelRoutine(&GetSetContext.Apc,
288 NULL,
289 NULL,
290 &GetSetContext.Apc.SystemArgument1,
291 &GetSetContext.Apc.SystemArgument2);
292
293 /* Leave the guarded region */
294 KeLeaveGuardedRegion();
295
296 /* We are done */
297 Status = STATUS_SUCCESS;
298 }
299 else
300 {
301 /* Initialize the APC */
302 KeInitializeApc(&GetSetContext.Apc,
303 &Thread->Tcb,
304 OriginalApcEnvironment,
305 PspGetOrSetContextKernelRoutine,
306 NULL,
307 NULL,
308 KernelMode,
309 NULL);
310
311 /* Queue it as a Get APC */
312 if (!KeInsertQueueApc(&GetSetContext.Apc, UlongToPtr(1), Thread, 2))
313 {
314 /* It was already queued, so fail */
315 Status = STATUS_UNSUCCESSFUL;
316 }
317 else
318 {
319 /* Wait for the APC to complete */
320 Status = KeWaitForSingleObject(&GetSetContext.Event,
321 0,
322 KernelMode,
323 FALSE,
324 NULL);
325 }
326 }
327
328 /* Return status */
329 return Status;
330 }
331
332 NTSTATUS
333 NTAPI
334 NtGetContextThread(IN HANDLE ThreadHandle,
335 IN OUT PCONTEXT ThreadContext)
336 {
337 PETHREAD Thread;
338 NTSTATUS Status;
339 KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
340 PAGED_CODE();
341
342 /* Get the Thread Object */
343 Status = ObReferenceObjectByHandle(ThreadHandle,
344 THREAD_GET_CONTEXT,
345 PsThreadType,
346 PreviousMode,
347 (PVOID*)&Thread,
348 NULL);
349
350 if (!NT_SUCCESS(Status)) return Status;
351
352 /* Make sure it's not a system thread */
353 if (Thread->SystemThread)
354 {
355 /* Fail */
356 Status = STATUS_INVALID_HANDLE;
357 }
358 else
359 {
360 /* Call the kernel API */
361 Status = PsGetContextThread(Thread, ThreadContext, PreviousMode);
362 }
363
364 /* Dereference it and return */
365 ObDereferenceObject(Thread);
366 return Status;
367 }
368
369 NTSTATUS
370 NTAPI
371 NtSetContextThread(IN HANDLE ThreadHandle,
372 IN PCONTEXT ThreadContext)
373 {
374 PETHREAD Thread;
375 NTSTATUS Status;
376 KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
377 PAGED_CODE();
378
379 /* Get the Thread Object */
380 Status = ObReferenceObjectByHandle(ThreadHandle,
381 THREAD_SET_CONTEXT,
382 PsThreadType,
383 PreviousMode,
384 (PVOID*)&Thread,
385 NULL);
386
387 if (!NT_SUCCESS(Status)) return Status;
388
389 /* Make sure it's not a system thread */
390 if (Thread->SystemThread)
391 {
392 /* Fail */
393 Status = STATUS_INVALID_HANDLE;
394 }
395 else
396 {
397 /* Call the kernel API */
398 Status = PsSetContextThread(Thread, ThreadContext, PreviousMode);
399 }
400
401 /* Dereference it and return */
402 ObDereferenceObject(Thread);
403 return Status;
404 }
405
406 /* EOF */