[NTOSKRNL] Add a raw implementation of !irpfind in kdbg
[reactos.git] / ntoskrnl / ps / state.c
1 /*
2 * PROJECT: ReactOS Kernel
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: ntoskrnl/ps/state.c
5 * PURPOSE: Process Manager: Process/Thread State Control
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 VOID
19 NTAPI
20 PspQueueApcSpecialApc(IN PKAPC Apc,
21 IN OUT PKNORMAL_ROUTINE* NormalRoutine,
22 IN OUT PVOID* NormalContext,
23 IN OUT PVOID* SystemArgument1,
24 IN OUT PVOID* SystemArgument2)
25 {
26 /* Free the APC and do nothing else */
27 ExFreePool(Apc);
28 }
29
30 NTSTATUS
31 NTAPI
32 PsResumeThread(IN PETHREAD Thread,
33 OUT PULONG PreviousCount OPTIONAL)
34 {
35 ULONG OldCount;
36 PAGED_CODE();
37
38 /* Resume the thread */
39 OldCount = KeResumeThread(&Thread->Tcb);
40
41 /* Return the count if asked */
42 if (PreviousCount) *PreviousCount = OldCount;
43 return STATUS_SUCCESS;
44 }
45
46 NTSTATUS
47 NTAPI
48 PsSuspendThread(
49 IN PETHREAD Thread,
50 OUT PULONG PreviousCount OPTIONAL)
51 {
52 NTSTATUS Status;
53 ULONG OldCount = 0;
54 PAGED_CODE();
55
56 /* Assume success */
57 Status = STATUS_SUCCESS;
58
59 /* Check if we're suspending ourselves */
60 if (Thread == PsGetCurrentThread())
61 {
62 /* Guard with SEH because KeSuspendThread can raise an exception */
63 _SEH2_TRY
64 {
65 /* Do the suspend */
66 OldCount = KeSuspendThread(&Thread->Tcb);
67 }
68 _SEH2_EXCEPT(_SEH2_GetExceptionCode() == STATUS_SUSPEND_COUNT_EXCEEDED)
69 {
70 /* Get the exception code */
71 Status = _SEH2_GetExceptionCode();
72 }
73 _SEH2_END;
74 }
75 else
76 {
77 /* Acquire rundown protection */
78 if (ExAcquireRundownProtection(&Thread->RundownProtect))
79 {
80 /* Make sure the thread isn't terminating */
81 if (Thread->Terminated)
82 {
83 /* Fail */
84 Status = STATUS_THREAD_IS_TERMINATING;
85 }
86 else
87 {
88 /* Guard with SEH because KeSuspendThread can raise an exception */
89 _SEH2_TRY
90 {
91 /* Do the suspend */
92 OldCount = KeSuspendThread(&Thread->Tcb);
93 }
94 _SEH2_EXCEPT(_SEH2_GetExceptionCode() == STATUS_SUSPEND_COUNT_EXCEEDED)
95 {
96 /* Get the exception code */
97 Status = _SEH2_GetExceptionCode();
98 }
99 _SEH2_END;
100
101 /* Check if it was terminated during the suspend */
102 if (Thread->Terminated)
103 {
104 /* Wake it back up and fail */
105 KeForceResumeThread(&Thread->Tcb);
106 Status = STATUS_THREAD_IS_TERMINATING;
107 OldCount = 0;
108 }
109 }
110
111 /* Release rundown protection */
112 ExReleaseRundownProtection(&Thread->RundownProtect);
113 }
114 else
115 {
116 /* Thread is terminating */
117 Status = STATUS_THREAD_IS_TERMINATING;
118 }
119 }
120
121 /* Write back the previous count */
122 if (PreviousCount) *PreviousCount = OldCount;
123 return Status;
124 }
125
126 NTSTATUS
127 NTAPI
128 PsResumeProcess(IN PEPROCESS Process)
129 {
130 PETHREAD Thread;
131 PAGED_CODE();
132
133 /* Lock the Process */
134 if (!ExAcquireRundownProtection(&Process->RundownProtect))
135 {
136 /* Process is terminating */
137 return STATUS_PROCESS_IS_TERMINATING;
138 }
139
140 /* Get the first thread */
141 Thread = PsGetNextProcessThread(Process, NULL);
142 while (Thread)
143 {
144 /* Resume it */
145 KeResumeThread(&Thread->Tcb);
146
147 /* Move to the next thread */
148 Thread = PsGetNextProcessThread(Process, Thread);
149 }
150
151 /* Unlock the process */
152 ExReleaseRundownProtection(&Process->RundownProtect);
153 return STATUS_SUCCESS;
154 }
155
156 NTSTATUS
157 NTAPI
158 PsSuspendProcess(IN PEPROCESS Process)
159 {
160 PETHREAD Thread;
161 PAGED_CODE();
162
163 /* Lock the Process */
164 if (!ExAcquireRundownProtection(&Process->RundownProtect))
165 {
166 /* Process is terminating */
167 return STATUS_PROCESS_IS_TERMINATING;
168 }
169
170 /* Get the first thread */
171 Thread = PsGetNextProcessThread(Process, NULL);
172 while (Thread)
173 {
174 /* Resume it */
175 PsSuspendThread(Thread, NULL);
176
177 /* Move to the next thread */
178 Thread = PsGetNextProcessThread(Process, Thread);
179 }
180
181 /* Unlock the process */
182 ExReleaseRundownProtection(&Process->RundownProtect);
183 return STATUS_SUCCESS;
184 }
185
186 /* PUBLIC FUNCTIONS **********************************************************/
187
188 /*
189 * @implemented
190 */
191 NTSTATUS
192 NTAPI
193 NtAlertThread(IN HANDLE ThreadHandle)
194 {
195 KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
196 PETHREAD Thread;
197 NTSTATUS Status;
198
199 /* Reference the Object */
200 Status = ObReferenceObjectByHandle(ThreadHandle,
201 THREAD_SUSPEND_RESUME,
202 PsThreadType,
203 PreviousMode,
204 (PVOID*)&Thread,
205 NULL);
206 if (NT_SUCCESS(Status))
207 {
208 /*
209 * Do an alert depending on the processor mode. If some kmode code wants to
210 * enforce a umode alert it should call KeAlertThread() directly. If kmode
211 * code wants to do a kmode alert it's sufficient to call it with Zw or just
212 * use KeAlertThread() directly
213 */
214 KeAlertThread(&Thread->Tcb, PreviousMode);
215
216 /* Dereference Object */
217 ObDereferenceObject(Thread);
218 }
219
220 /* Return status */
221 return Status;
222 }
223
224 NTSTATUS
225 NTAPI
226 NtAlertResumeThread(IN HANDLE ThreadHandle,
227 OUT PULONG SuspendCount)
228 {
229 KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
230 PETHREAD Thread;
231 NTSTATUS Status;
232 ULONG PreviousState;
233
234 /* Check if we came from user mode with a suspend count */
235 if ((SuspendCount) && (PreviousMode != KernelMode))
236 {
237 /* Enter SEH for probing */
238 _SEH2_TRY
239 {
240 /* Probe the count */
241 ProbeForWriteUlong(SuspendCount);
242 }
243 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
244 {
245 /* Return the exception code */
246 _SEH2_YIELD(return _SEH2_GetExceptionCode());
247 }
248 _SEH2_END;
249 }
250
251 /* Reference the Object */
252 Status = ObReferenceObjectByHandle(ThreadHandle,
253 THREAD_SUSPEND_RESUME,
254 PsThreadType,
255 PreviousMode,
256 (PVOID*)&Thread,
257 NULL);
258 if (NT_SUCCESS(Status))
259 {
260 /* Call the Kernel Function */
261 PreviousState = KeAlertResumeThread(&Thread->Tcb);
262
263 /* Dereference Object */
264 ObDereferenceObject(Thread);
265
266 /* Check if the caller gave a suspend count */
267 if (SuspendCount)
268 {
269 /* Enter SEH for write */
270 _SEH2_TRY
271 {
272 /* Write state back */
273 *SuspendCount = PreviousState;
274 }
275 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
276 {
277 /* Get exception code */
278 Status = _SEH2_GetExceptionCode();
279 }
280 _SEH2_END;
281 }
282 }
283
284 /* Return status */
285 return Status;
286 }
287
288 NTSTATUS
289 NTAPI
290 NtResumeThread(IN HANDLE ThreadHandle,
291 OUT PULONG SuspendCount OPTIONAL)
292 {
293 PETHREAD Thread;
294 ULONG Prev;
295 KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
296 NTSTATUS Status;
297 PAGED_CODE();
298
299 /* Check if caller gave a suspend count from user mode */
300 if ((SuspendCount) && (PreviousMode != KernelMode))
301 {
302 /* Enter SEH for probing */
303 _SEH2_TRY
304 {
305 /* Probe the count */
306 ProbeForWriteUlong(SuspendCount);
307 }
308 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
309 {
310 /* Return the exception code */
311 _SEH2_YIELD(return _SEH2_GetExceptionCode());
312 }
313 _SEH2_END;
314 }
315
316 /* Get the Thread Object */
317 Status = ObReferenceObjectByHandle(ThreadHandle,
318 THREAD_SUSPEND_RESUME,
319 PsThreadType,
320 PreviousMode,
321 (PVOID*)&Thread,
322 NULL);
323 if (!NT_SUCCESS(Status)) return Status;
324
325 /* Call the internal function */
326 Status = PsResumeThread(Thread, &Prev);
327
328 /* Check if the caller wanted the count back */
329 if (SuspendCount)
330 {
331 /* Enter SEH for write back */
332 _SEH2_TRY
333 {
334 /* Write the count */
335 *SuspendCount = Prev;
336 }
337 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
338 {
339 /* Get the exception code */
340 Status = _SEH2_GetExceptionCode();
341 }
342 _SEH2_END;
343 }
344
345 /* Dereference and return */
346 ObDereferenceObject(Thread);
347 return Status;
348 }
349
350 NTSTATUS
351 NTAPI
352 NtSuspendThread(IN HANDLE ThreadHandle,
353 OUT PULONG PreviousSuspendCount OPTIONAL)
354 {
355 PETHREAD Thread;
356 ULONG Prev;
357 KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
358 NTSTATUS Status;
359 PAGED_CODE();
360
361 /* Check if caller gave a suspend count from user mode */
362 if ((PreviousSuspendCount) && (PreviousMode != KernelMode))
363 {
364 /* Enter SEH for probing */
365 _SEH2_TRY
366 {
367 /* Probe the count */
368 ProbeForWriteUlong(PreviousSuspendCount);
369 }
370 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
371 {
372 /* Return the exception code */
373 _SEH2_YIELD(return _SEH2_GetExceptionCode());
374 }
375 _SEH2_END;
376 }
377
378 /* Get the Thread Object */
379 Status = ObReferenceObjectByHandle(ThreadHandle,
380 THREAD_SUSPEND_RESUME,
381 PsThreadType,
382 PreviousMode,
383 (PVOID*)&Thread,
384 NULL);
385 if (!NT_SUCCESS(Status)) return Status;
386
387 /* Call the internal function */
388 Status = PsSuspendThread(Thread, &Prev);
389 ObDereferenceObject(Thread);
390 if (!NT_SUCCESS(Status)) return Status;
391
392 /* Protect write with SEH */
393 _SEH2_TRY
394 {
395 /* Return the Previous Count */
396 if (PreviousSuspendCount) *PreviousSuspendCount = Prev;
397 }
398 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
399 {
400 /* Get the exception code */
401 Status = _SEH2_GetExceptionCode();
402 }
403 _SEH2_END;
404
405 /* Return */
406 return Status;
407 }
408
409 NTSTATUS
410 NTAPI
411 NtSuspendProcess(IN HANDLE ProcessHandle)
412 {
413 KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
414 PEPROCESS Process;
415 NTSTATUS Status;
416 PAGED_CODE();
417
418 /* Reference the process */
419 Status = ObReferenceObjectByHandle(ProcessHandle,
420 PROCESS_SUSPEND_RESUME,
421 PsProcessType,
422 PreviousMode,
423 (PVOID*)&Process,
424 NULL);
425 if (NT_SUCCESS(Status))
426 {
427 /* Call the internal function */
428 Status = PsSuspendProcess(Process);
429 ObDereferenceObject(Process);
430 }
431
432 /* Return status */
433 return Status;
434 }
435
436 NTSTATUS
437 NTAPI
438 NtResumeProcess(IN HANDLE ProcessHandle)
439 {
440 KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
441 PEPROCESS Process;
442 NTSTATUS Status;
443 PAGED_CODE();
444
445 /* Reference the process */
446 Status = ObReferenceObjectByHandle(ProcessHandle,
447 PROCESS_SUSPEND_RESUME,
448 PsProcessType,
449 PreviousMode,
450 (PVOID*)&Process,
451 NULL);
452 if (NT_SUCCESS(Status))
453 {
454 /* Call the internal function */
455 Status = PsResumeProcess(Process);
456 ObDereferenceObject(Process);
457 }
458
459 /* Return status */
460 return Status;
461 }
462
463 NTSTATUS
464 NTAPI
465 NtTestAlert(VOID)
466 {
467 /* Check and Alert Thread if needed */
468 return KeTestAlertThread(ExGetPreviousMode()) ?
469 STATUS_ALERTED : STATUS_SUCCESS;
470 }
471
472 /*++
473 * @name NtQueueApcThread
474 * NT4
475 *
476 * This routine is used to queue an APC from user-mode for the specified
477 * thread.
478 *
479 * @param ThreadHandle
480 * Handle to the Thread.
481 * This handle must have THREAD_SET_CONTEXT privileges.
482 *
483 * @param ApcRoutine
484 * Pointer to the APC Routine to call when the APC executes.
485 *
486 * @param NormalContext
487 * Pointer to the context to send to the Normal Routine.
488 *
489 * @param SystemArgument[1-2]
490 * Pointer to a set of two parameters that contain untyped data.
491 *
492 * @return STATUS_SUCCESS or failure cute from associated calls.
493 *
494 * @remarks The thread must enter an alertable wait before the APC will be
495 * delivered.
496 *
497 *--*/
498 NTSTATUS
499 NTAPI
500 NtQueueApcThread(IN HANDLE ThreadHandle,
501 IN PKNORMAL_ROUTINE ApcRoutine,
502 IN PVOID NormalContext,
503 IN PVOID SystemArgument1,
504 IN PVOID SystemArgument2)
505 {
506 PKAPC Apc;
507 PETHREAD Thread;
508 NTSTATUS Status = STATUS_SUCCESS;
509 PAGED_CODE();
510
511 /* Get ETHREAD from Handle */
512 Status = ObReferenceObjectByHandle(ThreadHandle,
513 THREAD_SET_CONTEXT,
514 PsThreadType,
515 ExGetPreviousMode(),
516 (PVOID)&Thread,
517 NULL);
518 if (!NT_SUCCESS(Status)) return Status;
519
520 /* Check if this is a System Thread */
521 if (Thread->SystemThread)
522 {
523 /* Fail */
524 Status = STATUS_INVALID_HANDLE;
525 goto Quit;
526 }
527
528 /* Allocate an APC */
529 Apc = ExAllocatePoolWithQuotaTag(NonPagedPool |
530 POOL_QUOTA_FAIL_INSTEAD_OF_RAISE,
531 sizeof(KAPC),
532 TAG_PS_APC);
533 if (!Apc)
534 {
535 /* Fail */
536 Status = STATUS_NO_MEMORY;
537 goto Quit;
538 }
539
540 /* Initialize the APC */
541 KeInitializeApc(Apc,
542 &Thread->Tcb,
543 OriginalApcEnvironment,
544 PspQueueApcSpecialApc,
545 NULL,
546 ApcRoutine,
547 UserMode,
548 NormalContext);
549
550 /* Queue it */
551 if (!KeInsertQueueApc(Apc,
552 SystemArgument1,
553 SystemArgument2,
554 IO_NO_INCREMENT))
555 {
556 /* We failed, free it */
557 ExFreePool(Apc);
558 Status = STATUS_UNSUCCESSFUL;
559 }
560
561 /* Dereference Thread and Return */
562 Quit:
563 ObDereferenceObject(Thread);
564 return Status;
565 }
566
567 /* EOF */