xref: /reactos/ntoskrnl/ps/debug.c (revision fc82f8e2) 
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 */
407