ReactOS 0.4.15-dev-8109-gd7be748
state.c File Reference
#include <ntoskrnl.h>
#include <debug.h>
Include dependency graph for state.c:

Go to the source code of this file.

Macros

#define NDEBUG
 

Functions

VOID NTAPI PspQueueApcSpecialApc (IN PKAPC Apc, IN OUT PKNORMAL_ROUTINE *NormalRoutine, IN OUT PVOID *NormalContext, IN OUT PVOID *SystemArgument1, IN OUT PVOID *SystemArgument2)
 
NTSTATUS NTAPI PsResumeThread (IN PETHREAD Thread, OUT PULONG PreviousCount OPTIONAL)
 
NTSTATUS NTAPI PsSuspendThread (IN PETHREAD Thread, OUT PULONG PreviousCount OPTIONAL)
 
NTSTATUS NTAPI PsResumeProcess (IN PEPROCESS Process)
 
NTSTATUS NTAPI PsSuspendProcess (IN PEPROCESS Process)
 
NTSTATUS NTAPI NtAlertThread (IN HANDLE ThreadHandle)
 
NTSTATUS NTAPI NtAlertResumeThread (IN HANDLE ThreadHandle, OUT PULONG SuspendCount)
 
NTSTATUS NTAPI NtResumeThread (IN HANDLE ThreadHandle, OUT PULONG SuspendCount OPTIONAL)
 
NTSTATUS NTAPI NtSuspendThread (IN HANDLE ThreadHandle, OUT PULONG PreviousSuspendCount OPTIONAL)
 
NTSTATUS NTAPI NtSuspendProcess (IN HANDLE ProcessHandle)
 
NTSTATUS NTAPI NtResumeProcess (IN HANDLE ProcessHandle)
 
NTSTATUS NTAPI NtTestAlert (VOID)
 
NTSTATUS NTAPI NtQueueApcThreadEx (IN HANDLE ThreadHandle, IN OPTIONAL HANDLE UserApcReserveHandle, IN PKNORMAL_ROUTINE ApcRoutine, IN PVOID NormalContext, IN OPTIONAL PVOID SystemArgument1, IN OPTIONAL PVOID SystemArgument2)
 
NTSTATUS NTAPI NtQueueApcThread (IN HANDLE ThreadHandle, IN PKNORMAL_ROUTINE ApcRoutine, IN PVOID NormalContext, IN PVOID SystemArgument1, IN PVOID SystemArgument2)
 

Macro Definition Documentation

◆ NDEBUG

#define NDEBUG

Definition at line 13 of file state.c.

Function Documentation

◆ NtAlertResumeThread()

NTSTATUS NTAPI NtAlertResumeThread ( IN HANDLE  ThreadHandle,
OUT PULONG  SuspendCount 
)

Definition at line 226 of file state.c.

228{
233
234 /* Check if we came from user mode with a suspend count */
235 if ((SuspendCount) && (PreviousMode != KernelMode))
236 {
237 /* Enter SEH for probing */
239 {
240 /* Probe the count */
241 ProbeForWriteUlong(SuspendCount);
242 }
244 {
245 /* Return the exception code */
247 }
248 _SEH2_END;
249 }
250
251 /* Reference the Object */
252 Status = ObReferenceObjectByHandle(ThreadHandle,
256 (PVOID*)&Thread,
257 NULL);
258 if (NT_SUCCESS(Status))
259 {
260 /* Call the Kernel Function */
262
263 /* Dereference Object */
265
266 /* Check if the caller gave a suspend count */
267 if (SuspendCount)
268 {
269 /* Enter SEH for write */
271 {
272 /* Write state back */
273 *SuspendCount = PreviousState;
274 }
276 {
277 /* Get exception code */
279 }
280 _SEH2_END;
281 }
282 }
283
284 /* Return status */
285 return Status;
286}
LONG NTSTATUS
Definition: precomp.h:26
#define NULL
Definition: types.h:112
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define ExGetPreviousMode
Definition: ex.h:140
#define _SEH2_END
Definition: filesup.c:22
#define _SEH2_TRY
Definition: filesup.c:19
_In_opt_ PFILE_OBJECT _In_opt_ PETHREAD Thread
Definition: fltkernel.h:2653
Status
Definition: gdiplustypes.h:25
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
#define THREAD_SUSPEND_RESUME
#define KernelMode
Definition: asm.h:34
ULONG NTAPI KeAlertResumeThread(IN PKTHREAD Thread)
Definition: thrdobj.c:124
POBJECT_TYPE PsThreadType
Definition: thread.c:20
NTSTATUS NTAPI ObReferenceObjectByHandle(IN HANDLE Handle, IN ACCESS_MASK DesiredAccess, IN POBJECT_TYPE ObjectType, IN KPROCESSOR_MODE AccessMode, OUT PVOID *Object, OUT POBJECT_HANDLE_INFORMATION HandleInformation OPTIONAL)
Definition: obref.c:494
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:165
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:66
#define _SEH2_YIELD(__stmt)
Definition: pseh2_64.h:168
#define ProbeForWriteUlong(Ptr)
Definition: probe.h:36
KTHREAD Tcb
Definition: pstypes.h:1103
uint32_t ULONG
Definition: typedefs.h:59
_In_ WDF_POWER_DEVICE_STATE PreviousState
Definition: wdfdevice.h:829
CCHAR KPROCESSOR_MODE
Definition: ketypes.h:7
#define ObDereferenceObject
Definition: obfuncs.h:203
_In_ KPROCESSOR_MODE PreviousMode
Definition: sefuncs.h:103

◆ NtAlertThread()

NTSTATUS NTAPI NtAlertThread ( IN HANDLE  ThreadHandle)

Definition at line 193 of file state.c.

194{
198
199 /* Reference the Object */
200 Status = ObReferenceObjectByHandle(ThreadHandle,
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 */
215
216 /* Dereference Object */
218 }
219
220 /* Return status */
221 return Status;
222}
BOOLEAN NTAPI KeAlertThread(IN PKTHREAD Thread, IN KPROCESSOR_MODE AlertMode)
Definition: thrdobj.c:176

◆ NtQueueApcThread()

NTSTATUS NTAPI NtQueueApcThread ( IN HANDLE  ThreadHandle,
IN PKNORMAL_ROUTINE  ApcRoutine,
IN PVOID  NormalContext,
IN PVOID  SystemArgument1,
IN PVOID  SystemArgument2 
)

Definition at line 600 of file state.c.

605{
606 return NtQueueApcThreadEx(ThreadHandle, NULL, ApcRoutine, NormalContext, SystemArgument1, SystemArgument2);
607}
_In_opt_ HANDLE _In_opt_ PIO_APC_ROUTINE ApcRoutine
Definition: iofuncs.h:726
NTSTATUS NTAPI NtQueueApcThreadEx(IN HANDLE ThreadHandle, IN OPTIONAL HANDLE UserApcReserveHandle, IN PKNORMAL_ROUTINE ApcRoutine, IN PVOID NormalContext, IN OPTIONAL PVOID SystemArgument1, IN OPTIONAL PVOID SystemArgument2)
Definition: state.c:504
_In_opt_ PVOID _In_opt_ PVOID SystemArgument1
Definition: ketypes.h:688
_In_opt_ PVOID _In_opt_ PVOID _In_opt_ PVOID SystemArgument2
Definition: ketypes.h:689

Referenced by QueueUserAPC(), RtlpQueueIoWorkerThread(), RtlpQueueWorkerThread(), and RtlQueueApcWow64Thread().

◆ NtQueueApcThreadEx()

NTSTATUS NTAPI NtQueueApcThreadEx ( IN HANDLE  ThreadHandle,
IN OPTIONAL HANDLE  UserApcReserveHandle,
IN PKNORMAL_ROUTINE  ApcRoutine,
IN PVOID  NormalContext,
IN OPTIONAL PVOID  SystemArgument1,
IN OPTIONAL PVOID  SystemArgument2 
)

Definition at line 504 of file state.c.

510{
511 PKAPC Apc;
514 PAGED_CODE();
515
516 /* Get ETHREAD from Handle */
517 Status = ObReferenceObjectByHandle(ThreadHandle,
521 (PVOID)&Thread,
522 NULL);
523 if (!NT_SUCCESS(Status)) return Status;
524
525 /* Check if this is a System Thread */
526 if (Thread->SystemThread)
527 {
528 /* Fail */
530 goto Quit;
531 }
532
533 /* Allocate an APC */
536 sizeof(KAPC),
537 TAG_PS_APC);
538 if (!Apc)
539 {
540 /* Fail */
542 goto Quit;
543 }
544
545 /* Initialize the APC */
546 KeInitializeApc(Apc,
547 &Thread->Tcb,
550 NULL,
552 UserMode,
553 NormalContext);
554
555 /* Queue it */
556 if (!KeInsertQueueApc(Apc,
560 {
561 /* We failed, free it */
562 ExFreePool(Apc);
564 }
565
566 /* Dereference Thread and Return */
567Quit:
569 return Status;
570}
#define PAGED_CODE()
#define ExFreePool(addr)
Definition: env_spec_w32.h:352
#define NonPagedPool
Definition: env_spec_w32.h:307
#define THREAD_SET_CONTEXT
#define UserMode
Definition: asm.h:35
@ OriginalApcEnvironment
Definition: ketypes.h:767
BOOLEAN NTAPI KeInsertQueueApc(IN PKAPC Apc, IN PVOID SystemArgument1, IN PVOID SystemArgument2, IN KPRIORITY PriorityBoost)
Definition: apc.c:735
VOID NTAPI KeInitializeApc(IN PKAPC Apc, IN PKTHREAD Thread, IN KAPC_ENVIRONMENT TargetEnvironment, IN PKKERNEL_ROUTINE KernelRoutine, IN PKRUNDOWN_ROUTINE RundownRoutine OPTIONAL, IN PKNORMAL_ROUTINE NormalRoutine, IN KPROCESSOR_MODE Mode, IN PVOID Context)
Definition: apc.c:651
VOID NTAPI PspQueueApcSpecialApc(IN PKAPC Apc, IN OUT PKNORMAL_ROUTINE *NormalRoutine, IN OUT PVOID *NormalContext, IN OUT PVOID *SystemArgument1, IN OUT PVOID *SystemArgument2)
Definition: state.c:20
#define STATUS_INVALID_HANDLE
Definition: ntstatus.h:245
#define STATUS_NO_MEMORY
Definition: ntstatus.h:260
#define STATUS_SUCCESS
Definition: shellext.h:65
ULONG SystemThread
Definition: pstypes.h:1182
Definition: ketypes.h:547
#define TAG_PS_APC
Definition: tag.h:137
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
#define ExAllocatePoolWithQuotaTag(a, b, c)
Definition: exfuncs.h:530
#define IO_NO_INCREMENT
Definition: iotypes.h:598
#define POOL_QUOTA_FAIL_INSTEAD_OF_RAISE

Referenced by NtQueueApcThread().

◆ NtResumeProcess()

NTSTATUS NTAPI NtResumeProcess ( IN HANDLE  ProcessHandle)

Definition at line 438 of file state.c.

439{
443 PAGED_CODE();
444
445 /* Reference the process */
450 (PVOID*)&Process,
451 NULL);
452 if (NT_SUCCESS(Status))
453 {
454 /* Call the internal function */
457 }
458
459 /* Return status */
460 return Status;
461}
_Must_inspect_result_ _In_ PLARGE_INTEGER _In_ PLARGE_INTEGER _In_ ULONG _In_ PFILE_OBJECT _In_ PVOID Process
Definition: fsrtlfuncs.h:223
#define PROCESS_SUSPEND_RESUME
Definition: pstypes.h:167
_In_ HANDLE ProcessHandle
Definition: mmfuncs.h:403
POBJECT_TYPE PsProcessType
Definition: process.c:20
NTSTATUS NTAPI PsResumeProcess(IN PEPROCESS Process)
Definition: state.c:128

◆ NtResumeThread()

NTSTATUS NTAPI NtResumeThread ( IN HANDLE  ThreadHandle,
OUT PULONG SuspendCount  OPTIONAL 
)

Definition at line 290 of file state.c.

292{
294 ULONG Prev;
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 */
304 {
305 /* Probe the count */
306 ProbeForWriteUlong(SuspendCount);
307 }
309 {
310 /* Return the exception code */
312 }
313 _SEH2_END;
314 }
315
316 /* Get the Thread Object */
317 Status = ObReferenceObjectByHandle(ThreadHandle,
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 */
333 {
334 /* Write the count */
335 *SuspendCount = Prev;
336 }
338 {
339 /* Get the exception code */
341 }
342 _SEH2_END;
343 }
344
345 /* Dereference and return */
347 return Status;
348}
NTSTATUS NTAPI PsResumeThread(IN PETHREAD Thread, OUT PULONG PreviousCount OPTIONAL)
Definition: state.c:32

Referenced by CreateProcessInternalW(), CreateRemoteThread(), CsrApiPortInitialize(), CsrpCheckRequestThreads(), CsrSbApiPortInitialize(), CsrSbCreateSession(), EnableUserModePnpManager(), GuiInit(), ResumeThread(), RtlCreateTimerQueue(), RtlpStartWorkerThread(), SmpExecuteImage(), SmpExecuteInitialCommand(), SmpLoadSubSystem(), SmpSbCreateSession(), and test_NtSuspendProcess().

◆ NtSuspendProcess()

NTSTATUS NTAPI NtSuspendProcess ( IN HANDLE  ProcessHandle)

Definition at line 411 of file state.c.

412{
416 PAGED_CODE();
417
418 /* Reference the process */
423 (PVOID*)&Process,
424 NULL);
425 if (NT_SUCCESS(Status))
426 {
427 /* Call the internal function */
430 }
431
432 /* Return status */
433 return Status;
434}
NTSTATUS NTAPI PsSuspendProcess(IN PEPROCESS Process)
Definition: state.c:158

◆ NtSuspendThread()

NTSTATUS NTAPI NtSuspendThread ( IN HANDLE  ThreadHandle,
OUT PULONG PreviousSuspendCount  OPTIONAL 
)

Definition at line 352 of file state.c.

354{
356 ULONG Prev;
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 */
366 {
367 /* Probe the count */
368 ProbeForWriteUlong(PreviousSuspendCount);
369 }
371 {
372 /* Return the exception code */
374 }
375 _SEH2_END;
376 }
377
378 /* Get the Thread Object */
379 Status = ObReferenceObjectByHandle(ThreadHandle,
383 (PVOID*)&Thread,
384 NULL);
385 if (!NT_SUCCESS(Status)) return Status;
386
387 /* Call the internal function */
388 Status = PsSuspendThread(Thread, &Prev);
390 if (!NT_SUCCESS(Status)) return Status;
391
392 /* Protect write with SEH */
394 {
395 /* Return the Previous Count */
396 if (PreviousSuspendCount) *PreviousSuspendCount = Prev;
397 }
399 {
400 /* Get the exception code */
402 }
403 _SEH2_END;
404
405 /* Return */
406 return Status;
407}
NTSTATUS NTAPI PsSuspendThread(IN PETHREAD Thread, OUT PULONG PreviousCount OPTIONAL)
Definition: state.c:48

Referenced by DisableUserModePnpManager(), and SuspendThread().

◆ NtTestAlert()

NTSTATUS NTAPI NtTestAlert ( VOID  )

Definition at line 465 of file state.c.

466{
467 /* Check and Alert Thread if needed */
470}
BOOLEAN NTAPI KeTestAlertThread(IN KPROCESSOR_MODE AlertMode)
Definition: thrdobj.c:722
#define STATUS_ALERTED
Definition: ntstatus.h:80

Referenced by LdrpInit().

◆ PspQueueApcSpecialApc()

VOID NTAPI PspQueueApcSpecialApc ( IN PKAPC  Apc,
IN OUT PKNORMAL_ROUTINE NormalRoutine,
IN OUT PVOID NormalContext,
IN OUT PVOID SystemArgument1,
IN OUT PVOID SystemArgument2 
)

Definition at line 20 of file state.c.

25{
26 /* Free the APC and do nothing else */
27 ExFreePool(Apc);
28}

Referenced by NtQueueApcThreadEx().

◆ PsResumeProcess()

NTSTATUS NTAPI PsResumeProcess ( IN PEPROCESS  Process)

Definition at line 128 of file state.c.

129{
131 PAGED_CODE();
132
133 /* Lock the Process */
134 if (!ExAcquireRundownProtection(&Process->RundownProtect))
135 {
136 /* Process is terminating */
138 }
139
140 /* Get the first thread */
142 while (Thread)
143 {
144 /* Resume it */
146
147 /* Move to the next thread */
149 }
150
151 /* Unlock the process */
152 ExReleaseRundownProtection(&Process->RundownProtect);
153 return STATUS_SUCCESS;
154}
#define ExReleaseRundownProtection
Definition: ex.h:136
#define ExAcquireRundownProtection
Definition: ex.h:135
ULONG NTAPI KeResumeThread(IN PKTHREAD Thread)
Definition: thrdobj.c:388
#define STATUS_PROCESS_IS_TERMINATING
Definition: ntstatus.h:502
PETHREAD NTAPI PsGetNextProcessThread(IN PEPROCESS Process, IN PETHREAD Thread OPTIONAL)
Definition: process.c:75

Referenced by NtResumeProcess().

◆ PsResumeThread()

NTSTATUS NTAPI PsResumeThread ( IN PETHREAD  Thread,
OUT PULONG PreviousCount  OPTIONAL 
)

Definition at line 32 of file state.c.

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}

Referenced by DbgkpPostFakeThreadMessages(), DbgkpWakeTarget(), and NtResumeThread().

◆ PsSuspendProcess()

NTSTATUS NTAPI PsSuspendProcess ( IN PEPROCESS  Process)

Definition at line 158 of file state.c.

159{
161 PAGED_CODE();
162
163 /* Lock the Process */
164 if (!ExAcquireRundownProtection(&Process->RundownProtect))
165 {
166 /* Process is terminating */
168 }
169
170 /* Get the first thread */
172 while (Thread)
173 {
174 /* Resume it */
176
177 /* Move to the next thread */
179 }
180
181 /* Unlock the process */
182 ExReleaseRundownProtection(&Process->RundownProtect);
183 return STATUS_SUCCESS;
184}

Referenced by NtSuspendProcess().

◆ PsSuspendThread()

NTSTATUS NTAPI PsSuspendThread ( IN PETHREAD  Thread,
OUT PULONG PreviousCount  OPTIONAL 
)

Definition at line 48 of file state.c.

51{
53 ULONG OldCount = 0;
54 PAGED_CODE();
55
56 /* Assume success */
58
59 /* Check if we're suspending ourselves */
61 {
62 /* Guard with SEH because KeSuspendThread can raise an exception */
64 {
65 /* Do the suspend */
66 OldCount = KeSuspendThread(&Thread->Tcb);
67 }
69 {
70 /* Get the exception code */
72 }
74 }
75 else
76 {
77 /* Acquire rundown protection */
79 {
80 /* Make sure the thread isn't terminating */
81 if (Thread->Terminated)
82 {
83 /* Fail */
85 }
86 else
87 {
88 /* Guard with SEH because KeSuspendThread can raise an exception */
90 {
91 /* Do the suspend */
92 OldCount = KeSuspendThread(&Thread->Tcb);
93 }
95 {
96 /* Get the exception code */
98 }
100
101 /* Check if it was terminated during the suspend */
102 if (Thread->Terminated)
103 {
104 /* Wake it back up and fail */
107 OldCount = 0;
108 }
109 }
110
111 /* Release rundown protection */
113 }
114 else
115 {
116 /* Thread is terminating */
118 }
119 }
120
121 /* Write back the previous count */
122 if (PreviousCount) *PreviousCount = OldCount;
123 return Status;
124}
#define PsGetCurrentThread()
Definition: env_spec_w32.h:81
ULONG NTAPI KeForceResumeThread(IN PKTHREAD Thread)
Definition: thrdobj.c:267
ULONG NTAPI KeSuspendThread(PKTHREAD Thread)
Definition: thrdobj.c:601
#define STATUS_THREAD_IS_TERMINATING
Definition: ntstatus.h:311
#define STATUS_SUSPEND_COUNT_EXCEEDED
Definition: ntstatus.h:310
EX_RUNDOWN_REF RundownProtect
Definition: pstypes.h:1159
ULONG Terminated
Definition: pstypes.h:1174

Referenced by DbgkpPostFakeThreadMessages(), NtSuspendThread(), and PsSuspendProcess().