ReactOS  r75907
timer.c
Go to the documentation of this file.
1 /*
2  * PROJECT: ReactOS Kernel
3  * LICENSE: GPL - See COPYING in the top level directory
4  * FILE: ntoskrnl/ex/timer.c
5  * PURPOSE: Executive Timer Implementation
6  * PROGRAMMERS: Alex Ionescu (alex.ionescu@reactos.org)
7  */
8 
9 /* INCLUDES ******************************************************************/
10 
11 #include <ntoskrnl.h>
12 #define NDEBUG
13 #include <debug.h>
14 
15 /* GLOBALS *******************************************************************/
16 
17 /* Timer Object Type */
19 
22 
23 /* Timer Mapping */
25 {
30 };
31 
32 /* Timer Information Classes */
33 static const INFORMATION_CLASS_INFO ExTimerInfoClass[] =
34 {
35  /* TimerBasicInformation */
36  ICI_SQ_SAME(sizeof(TIMER_BASIC_INFORMATION), sizeof(ULONG), ICIF_QUERY),
37 };
38 
39 /* PRIVATE FUNCTIONS *********************************************************/
40 
41 VOID
42 NTAPI
44 {
46  KIRQL OldIrql;
47  PLIST_ENTRY CurrentEntry;
48  PETIMER Timer;
49  ULONG DerefsToDo;
50 
51  /* Lock the Thread's Active Timer List and loop it */
52  KeAcquireSpinLock(&Thread->ActiveTimerListLock, &OldIrql);
53  CurrentEntry = Thread->ActiveTimerListHead.Flink;
54  while (CurrentEntry != &Thread->ActiveTimerListHead)
55  {
56  /* Get the timer */
57  Timer = CONTAINING_RECORD(CurrentEntry, ETIMER, ActiveTimerListEntry);
58 
59  /* Reference it */
60  ObReferenceObject(Timer);
61  DerefsToDo = 1;
62 
63  /* Unlock the list */
64  KeReleaseSpinLock(&Thread->ActiveTimerListLock, OldIrql);
65 
66  /* Lock the Timer */
67  KeAcquireSpinLock(&Timer->Lock, &OldIrql);
68 
69  /* Lock the list again */
71 
72  /* Make sure that the timer is valid */
73  if ((Timer->ApcAssociated) && (&Thread->Tcb == Timer->TimerApc.Thread))
74  {
75  /* Remove it from the list */
77  Timer->ApcAssociated = FALSE;
78 
79  /* Cancel the timer and remove its DPC and APC */
80  KeCancelTimer(&Timer->KeTimer);
81  KeRemoveQueueDpc(&Timer->TimerDpc);
82  if (KeRemoveQueueApc(&Timer->TimerApc)) DerefsToDo++;
83 
84  /* Add another dereference to do */
85  DerefsToDo++;
86  }
87 
88  /* Unlock the list */
90 
91  /* Unlock the Timer */
92  KeReleaseSpinLock(&Timer->Lock, OldIrql);
93 
94  /* Dereference it */
95  ObDereferenceObjectEx(Timer, DerefsToDo);
96 
97  /* Loop again */
98  KeAcquireSpinLock(&Thread->ActiveTimerListLock, &OldIrql);
99  CurrentEntry = Thread->ActiveTimerListHead.Flink;
100  }
101 
102  /* Release lock and return */
103  KeReleaseSpinLock(&Thread->ActiveTimerListLock, OldIrql);
104 }
105 
106 VOID
107 NTAPI
109 {
110  KIRQL OldIrql;
111  PETIMER Timer = ObjectBody;
112 
113  /* Check if it has a Wait List */
114  if (Timer->WakeTimerListEntry.Flink)
115  {
116  /* Lock the Wake List */
118 
119  /* Check again, since it might've changed before we locked */
120  if (Timer->WakeTimerListEntry.Flink)
121  {
122  /* Remove it from the Wait List */
124  Timer->WakeTimerListEntry.Flink = NULL;
125  }
126 
127  /* Release the Wake List */
129  }
130 
131  /* Tell the Kernel to cancel the Timer and flush all queued DPCs */
132  KeCancelTimer(&Timer->KeTimer);
134 }
135 
136 _Function_class_(KDEFERRED_ROUTINE)
137 VOID
138 NTAPI
139 ExpTimerDpcRoutine(IN PKDPC Dpc,
143 {
145  BOOLEAN Inserted = FALSE;
146 
147  /* Reference the timer */
148  if (!ObReferenceObjectSafe(Timer)) return;
149 
150  /* Lock the Timer */
152 
153  /* Check if the timer is associated */
154  if (Timer->ApcAssociated)
155  {
156  /* Queue the APC */
157  Inserted = KeInsertQueueApc(&Timer->TimerApc,
158  SystemArgument1,
159  SystemArgument2,
161  }
162 
163  /* Release the Timer */
165 
166  /* Dereference it if we couldn't queue the APC */
167  if (!Inserted) ObDereferenceObject(Timer);
168 }
169 
170 VOID
171 NTAPI
173  IN OUT PKNORMAL_ROUTINE* NormalRoutine,
174  IN OUT PVOID* NormalContext,
176  IN OUT PVOID* SystemArguemnt2)
177 {
178  PETIMER Timer;
179  KIRQL OldIrql;
180  ULONG DerefsToDo = 1;
182 
183  /* We need to find out which Timer we are */
184  Timer = CONTAINING_RECORD(Apc, ETIMER, TimerApc);
185 
186  /* Lock the Timer */
187  KeAcquireSpinLock(&Timer->Lock, &OldIrql);
188 
189  /* Lock the Thread's Active Timer List*/
191 
192  /* Make sure that the Timer is valid, and that it belongs to this thread */
193  if ((Timer->ApcAssociated) && (&Thread->Tcb == Timer->TimerApc.Thread))
194  {
195  /* Check if it's not periodic */
196  if (!Timer->Period)
197  {
198  /* Remove it from the Active Timers List */
200 
201  /* Disable it */
202  Timer->ApcAssociated = FALSE;
203  DerefsToDo++;
204  }
205  }
206  else
207  {
208  /* Clear the normal routine */
209  *NormalRoutine = NULL;
210  }
211 
212  /* Release locks */
214  KeReleaseSpinLock(&Timer->Lock, OldIrql);
215 
216  /* Dereference as needed */
217  ObDereferenceObjectEx(Timer, DerefsToDo);
218 }
219 
220 BOOLEAN
222 NTAPI
224 {
225  OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
228 
229  /* Create the Timer Object Type */
230  RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
231  RtlInitUnicodeString(&Name, L"Timer");
232  ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
233  ObjectTypeInitializer.InvalidAttributes = OBJ_OPENLINK;
234  ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(ETIMER);
235  ObjectTypeInitializer.GenericMapping = ExpTimerMapping;
236  ObjectTypeInitializer.PoolType = NonPagedPool;
237  ObjectTypeInitializer.ValidAccessMask = TIMER_ALL_ACCESS;
238  ObjectTypeInitializer.DeleteProcedure = ExpDeleteTimer;
239  Status = ObCreateObjectType(&Name, &ObjectTypeInitializer, NULL, &ExTimerType);
240  if (!NT_SUCCESS(Status)) return FALSE;
241 
242  /* Initialize the Wait List and Lock */
244  InitializeListHead(&ExpWakeList);
245  return TRUE;
246 }
247 
248 /* PUBLIC FUNCTIONS **********************************************************/
249 
250 NTSTATUS
251 NTAPI
252 NtCancelTimer(IN HANDLE TimerHandle,
254 {
255  PETIMER Timer;
257  BOOLEAN State;
258  KIRQL OldIrql;
259  PETHREAD TimerThread;
260  ULONG DerefsToDo = 1;
262  PAGED_CODE();
263 
264  /* Check if we need to probe */
265  if ((CurrentState) && (PreviousMode != KernelMode))
266  {
267  _SEH2_TRY
268  {
269  /* Make sure the pointer is valid */
271  }
273  {
274  /* Return the exception code */
276  }
277  _SEH2_END;
278  }
279 
280  /* Get the Timer Object */
281  Status = ObReferenceObjectByHandle(TimerHandle,
283  ExTimerType,
284  PreviousMode,
285  (PVOID*)&Timer,
286  NULL);
287  if (NT_SUCCESS(Status))
288  {
289  /* Lock the Timer */
290  KeAcquireSpinLock(&Timer->Lock, &OldIrql);
291 
292  /* Check if it's enabled */
293  if (Timer->ApcAssociated)
294  {
295  /* Get the Thread. */
296  TimerThread = CONTAINING_RECORD(Timer->TimerApc.Thread,
297  ETHREAD,
298  Tcb);
299 
300  /* Lock its active list */
302 
303  /* Remove it */
305  Timer->ApcAssociated = FALSE;
306 
307  /* Unlock the list */
309 
310  /* Cancel the Timer */
311  KeCancelTimer(&Timer->KeTimer);
312  KeRemoveQueueDpc(&Timer->TimerDpc);
313  if (KeRemoveQueueApc(&Timer->TimerApc)) DerefsToDo++;
314  DerefsToDo++;
315  }
316  else
317  {
318  /* If timer was disabled, we still need to cancel it */
319  KeCancelTimer(&Timer->KeTimer);
320  }
321 
322  /* Handle a Wake Timer */
323  if (Timer->WakeTimerListEntry.Flink)
324  {
325  /* Lock the Wake List */
327 
328  /* Check again, since it might've changed before we locked */
329  if (Timer->WakeTimerListEntry.Flink)
330  {
331  /* Remove it from the Wait List */
333  Timer->WakeTimerListEntry.Flink = NULL;
334  }
335 
336  /* Release the Wake List */
338  }
339 
340  /* Unlock the Timer */
341  KeReleaseSpinLock(&Timer->Lock, OldIrql);
342 
343  /* Read the old State */
344  State = KeReadStateTimer(&Timer->KeTimer);
345 
346  /* Dereference the Object */
347  ObDereferenceObjectEx(Timer, DerefsToDo);
348 
349  /* Check if caller wants the state */
350  if (CurrentState)
351  {
352  _SEH2_TRY
353  {
354  /* Return the Timer State */
355  *CurrentState = State;
356  }
358  {
359  /* Do nothing */
360  (void)0;
361  }
362  _SEH2_END;
363  }
364  }
365 
366  /* Return to Caller */
367  return Status;
368 }
369 
370 NTSTATUS
371 NTAPI
376 {
377  PETIMER Timer;
378  HANDLE hTimer;
381  PAGED_CODE();
382 
383  /* Check for correct timer type */
384  if ((TimerType != NotificationTimer) &&
385  (TimerType != SynchronizationTimer))
386  {
387  /* Fail */
389  }
390 
391  /* Check if we need to probe */
392  if (PreviousMode != KernelMode)
393  {
394  _SEH2_TRY
395  {
396  /* Make sure the pointer is valid */
397  ProbeForWriteHandle(TimerHandle);
398  }
400  {
401  /* Return the exception code */
403  }
404  _SEH2_END;
405  }
406 
407  /* Create the Object */
408  Status = ObCreateObject(PreviousMode,
409  ExTimerType,
411  PreviousMode,
412  NULL,
413  sizeof(ETIMER),
414  0,
415  0,
416  (PVOID*)&Timer);
417  if (NT_SUCCESS(Status))
418  {
419  /* Initialize the DPC */
420  KeInitializeDpc(&Timer->TimerDpc, ExpTimerDpcRoutine, Timer);
421 
422  /* Initialize the Kernel Timer */
423  KeInitializeTimerEx(&Timer->KeTimer, TimerType);
424 
425  /* Initialize the timer fields */
426  KeInitializeSpinLock(&Timer->Lock);
427  Timer->ApcAssociated = FALSE;
428  Timer->WakeTimer = FALSE;
429  Timer->WakeTimerListEntry.Flink = NULL;
430 
431  /* Insert the Timer */
432  Status = ObInsertObject((PVOID)Timer,
433  NULL,
434  DesiredAccess,
435  0,
436  NULL,
437  &hTimer);
438 
439  /* Check for success */
440  if (NT_SUCCESS(Status))
441  {
442  /* Enter SEH */
443  _SEH2_TRY
444  {
445  /* Return the Timer Handle */
446  *TimerHandle = hTimer;
447  }
449  {
450  /* Do nothing */
451  (void)0;
452  }
453  _SEH2_END;
454  }
455  }
456 
457  /* Return to Caller */
458  return Status;
459 }
460 
461 NTSTATUS
462 NTAPI
463 NtOpenTimer(OUT PHANDLE TimerHandle,
466 {
467  HANDLE hTimer;
470  PAGED_CODE();
471 
472  /* Check Parameter Validity */
473  if (PreviousMode != KernelMode)
474  {
475  _SEH2_TRY
476  {
477  /* Make sure the pointer is valid */
478  ProbeForWriteHandle(TimerHandle);
479  }
481  {
482  /* Return the exception code */
484  }
485  _SEH2_END;
486  }
487 
488  /* Open the Timer */
489  Status = ObOpenObjectByName(ObjectAttributes,
490  ExTimerType,
491  PreviousMode,
492  NULL,
493  DesiredAccess,
494  NULL,
495  &hTimer);
496  if (NT_SUCCESS(Status))
497  {
498  /* Enter SEH */
499  _SEH2_TRY
500  {
501  /* Return the Timer Handle */
502  *TimerHandle = hTimer;
503  }
505  {
506  /* Do nothing */
507  (void)0;
508  }
509  _SEH2_END;
510  }
511 
512  /* Return to Caller */
513  return Status;
514 }
515 
516 NTSTATUS
517 NTAPI
518 NtQueryTimer(IN HANDLE TimerHandle,
519  IN TIMER_INFORMATION_CLASS TimerInformationClass,
520  OUT PVOID TimerInformation,
521  IN ULONG TimerInformationLength,
523 {
524  PETIMER Timer;
527  PTIMER_BASIC_INFORMATION BasicInfo = TimerInformation;
528  PAGED_CODE();
529 
530  /* Check Validity */
531  Status = DefaultQueryInfoBufferCheck(TimerInformationClass,
533  sizeof(ExTimerInfoClass) /
534  sizeof(ExTimerInfoClass[0]),
535  TimerInformation,
536  TimerInformationLength,
537  ReturnLength,
538  NULL,
539  PreviousMode);
540  if (!NT_SUCCESS(Status)) return Status;
541 
542  /* Get the Timer Object */
543  Status = ObReferenceObjectByHandle(TimerHandle,
545  ExTimerType,
546  PreviousMode,
547  (PVOID*)&Timer,
548  NULL);
549  if (NT_SUCCESS(Status))
550  {
551  /* Return the Basic Information */
552  _SEH2_TRY
553  {
554  /* Return the remaining time, corrected */
555  BasicInfo->TimeRemaining.QuadPart = Timer->
556  KeTimer.DueTime.QuadPart -
558 
559  /* Return the current state */
560  BasicInfo->SignalState = KeReadStateTimer(&Timer->KeTimer);
561 
562  /* Return the buffer length if requested */
564  }
566  {
567  /* Get the exception code */
568  Status = _SEH2_GetExceptionCode();
569  }
570  _SEH2_END;
571 
572  /* Dereference Object */
573  ObDereferenceObject(Timer);
574  }
575 
576  /* Return Status */
577  return Status;
578 }
579 
580 NTSTATUS
581 NTAPI
582 NtSetTimer(IN HANDLE TimerHandle,
585  IN PVOID TimerContext OPTIONAL,
586  IN BOOLEAN WakeTimer,
587  IN LONG Period OPTIONAL,
588  OUT PBOOLEAN PreviousState OPTIONAL)
589 {
590  PETIMER Timer;
591  KIRQL OldIrql;
592  BOOLEAN State;
595  LARGE_INTEGER TimerDueTime;
596  PETHREAD TimerThread;
597  ULONG DerefsToDo = 1;
599  PAGED_CODE();
600 
601  /* Check for a valid Period */
602  if (Period < 0) return STATUS_INVALID_PARAMETER_6;
603 
604  /* Check if we need to probe */
605  if (PreviousMode != KernelMode)
606  {
607  _SEH2_TRY
608  {
609  /* Probe and capture the due time */
610  TimerDueTime = ProbeForReadLargeInteger(DueTime);
611 
612  /* Probe the state pointer if one was passed */
614  }
616  {
617  /* Return the exception code */
619  }
620  _SEH2_END;
621  }
622  else
623  {
624  /* Capture the time directly */
625  TimerDueTime = *DueTime;
626  }
627 
628  /* Get the Timer Object */
629  Status = ObReferenceObjectByHandle(TimerHandle,
631  ExTimerType,
632  PreviousMode,
633  (PVOID*)&Timer,
634  NULL);
635 
636  /*
637  * Tell the user we don't support Wake Timers...
638  * when we have the ability to use/detect the Power Management
639  * functionality required to support them, make this check dependent
640  * on the actual PM capabilities
641  */
642  if (WakeTimer) Status = STATUS_TIMER_RESUME_IGNORED;
643 
644  /* Check status */
645  if (NT_SUCCESS(Status))
646  {
647  /* Lock the Timer */
648  KeAcquireSpinLock(&Timer->Lock, &OldIrql);
649 
650  /* Cancel Running Timer */
651  if (Timer->ApcAssociated)
652  {
653  /* Get the Thread. */
654  TimerThread = CONTAINING_RECORD(Timer->TimerApc.Thread,
655  ETHREAD,
656  Tcb);
657 
658  /* Lock its active list */
660 
661  /* Remove it */
663  Timer->ApcAssociated = FALSE;
664 
665  /* Unlock the list */
667 
668  /* Cancel the Timer */
669  KeCancelTimer(&Timer->KeTimer);
670  KeRemoveQueueDpc(&Timer->TimerDpc);
671  if (KeRemoveQueueApc(&Timer->TimerApc)) DerefsToDo++;
672  DerefsToDo++;
673  }
674  else
675  {
676  /* If timer was disabled, we still need to cancel it */
677  KeCancelTimer(&Timer->KeTimer);
678  }
679 
680  /* Read the State */
681  State = KeReadStateTimer(&Timer->KeTimer);
682 
683  /* Handle Wake Timers */
684  Timer->WakeTimer = WakeTimer;
686  if ((WakeTimer) && !(Timer->WakeTimerListEntry.Flink))
687  {
688  /* Insert it into the list */
689  InsertTailList(&ExpWakeList, &Timer->WakeTimerListEntry);
690  }
691  else if (!(WakeTimer) && (Timer->WakeTimerListEntry.Flink))
692  {
693  /* Remove it from the list */
695  Timer->WakeTimerListEntry.Flink = NULL;
696  }
698 
699  /* Set up the APC Routine if specified */
700  Timer->Period = Period;
701  if (TimerApcRoutine)
702  {
703  /* Initialize the APC */
704  KeInitializeApc(&Timer->TimerApc,
705  &Thread->Tcb,
710  PreviousMode,
711  TimerContext);
712 
713  /* Lock the Thread's Active List and Insert */
716  &Timer->ActiveTimerListEntry);
717  Timer->ApcAssociated = TRUE;
719 
720  /* One less dereference to do */
721  DerefsToDo--;
722  }
723 
724  /* Enable and Set the Timer */
725  KeSetTimerEx(&Timer->KeTimer,
726  TimerDueTime,
727  Period,
728  TimerApcRoutine ? &Timer->TimerDpc : NULL);
729 
730  /* Unlock the Timer */
731  KeReleaseSpinLock(&Timer->Lock, OldIrql);
732 
733  /* Dereference if it was previously enabled */
734  if (DerefsToDo) ObDereferenceObjectEx(Timer, DerefsToDo);
735 
736  /* Check if we need to return the State */
737  if (PreviousState)
738  {
739  /* Enter SEH */
740  _SEH2_TRY
741  {
742  /* Return the Timer State */
743  *PreviousState = State;
744  }
746  {
747  /* Do nothing */
748  (void)0;
749  }
750  _SEH2_END;
751  }
752  }
753 
754  /* Return to Caller */
755  return Status;
756 }
NTSTATUS NTAPI ObOpenObjectByName(IN POBJECT_ATTRIBUTES ObjectAttributes, IN POBJECT_TYPE ObjectType, IN KPROCESSOR_MODE AccessMode, IN PACCESS_STATE PassedAccessState, IN ACCESS_MASK DesiredAccess, IN OUT PVOID ParseContext, OUT PHANDLE Handle)
Definition: obhandle.c:2522
DWORD *typedef PVOID
Definition: winlogon.h:52
LIST_ENTRY WakeTimerListEntry
Definition: ex.h:102
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
#define TIMER_QUERY_STATE
Definition: extypes.h:114
IN PUNICODE_STRING IN POBJECT_ATTRIBUTES ObjectAttributes
Definition: conport.c:35
IN CINT OUT PVOID IN ULONG OUT PULONG ReturnLength
Definition: dumpinfo.c:39
#define IN
Definition: typedefs.h:39
NTSTATUS NTAPI ObCreateObjectType(IN PUNICODE_STRING TypeName, IN POBJECT_TYPE_INITIALIZER ObjectTypeInitializer, IN PVOID Reserved, OUT POBJECT_TYPE *ObjectType)
Definition: oblife.c:1034
#define TRUE
Definition: types.h:120
LONG Period
Definition: ex.h:99
BOOLEAN INIT_FUNCTION NTAPI ExpInitializeTimerImplementation(VOID)
Definition: timer.c:223
#define STANDARD_RIGHTS_WRITE
Definition: nt_native.h:66
#define PsGetCurrentThread()
Definition: env_spec_w32.h:81
VOID NTAPI ExTimerRundown(VOID)
Definition: timer.c:43
Definition: bidi.c:75
_In_ LARGE_INTEGER DueTime
Definition: kefuncs.h:524
return STATUS_SUCCESS
Definition: btrfs.c:2664
BOOLEAN WakeTimer
Definition: ex.h:101
VOID NTAPI KeAcquireSpinLockAtDpcLevel(IN PKSPIN_LOCK SpinLock)
Definition: spinlock.c:192
KTHREAD Tcb
Definition: pstypes.h:1035
BOOLEAN NTAPI KeReadStateTimer(IN PKTIMER Timer)
Definition: timerobj.c:269
BOOLEAN NTAPI KeRemoveQueueDpc(IN PKDPC Dpc)
Definition: dpc.c:877
#define OBJ_OPENLINK
Definition: winternl.h:230
_In_ LARGE_INTEGER _In_ ULONG Period
Definition: kefuncs.h:1268
LIST_ENTRY ActiveTimerListHead
Definition: pstypes.h:1059
KPROCESSOR_MODE NTAPI ExGetPreviousMode(VOID)
Definition: sysinfo.c:2740
VOID NTAPI ObDereferenceObject(IN PVOID Object)
Definition: obref.c:267
BOOLEAN NTAPI KeSetTimerEx(IN OUT PKTIMER Timer, IN LARGE_INTEGER DueTime, IN LONG Period, IN PKDPC Dpc OPTIONAL)
Definition: timerobj.c:294
BOOLEAN ApcAssociated
Definition: ex.h:100
struct _TIMER_BASIC_INFORMATION TIMER_BASIC_INFORMATION
IN POBJECT_ATTRIBUTES PortAttributes IN ACCESS_MASK DesiredAccess
Definition: creport.c:28
#define InsertTailList(ListHead, Entry)
#define STANDARD_RIGHTS_EXECUTE
Definition: nt_native.h:67
LIST_ENTRY ActiveTimerListEntry
Definition: ex.h:97
static const INFORMATION_CLASS_INFO ExTimerInfoClass[]
Definition: timer.c:33
BOOLEAN FASTCALL ObReferenceObjectSafe(IN PVOID Object)
Definition: obref.c:22
_Function_class_(KDEFERRED_ROUTINE)
Definition: timer.c:136
FORCEINLINE BOOLEAN RemoveEntryList(_In_ PLIST_ENTRY Entry)
Definition: rtlfuncs.h:105
UCHAR KIRQL
Definition: env_spec_w32.h:591
NTSTATUS NTAPI NtOpenTimer(OUT PHANDLE TimerHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes)
Definition: timer.c:463
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:388
NTSTATUS(* NTAPI)(IN PFILE_FULL_EA_INFORMATION EaBuffer, IN ULONG EaLength, OUT PULONG ErrorOffset)
Definition: IoEaTest.cpp:117
static GENERIC_MAPPING ExpTimerMapping
Definition: timer.c:24
#define FALSE
Definition: types.h:117
LIST_ENTRY ExpWakeList
Definition: timer.c:21
BOOLEAN NTAPI KeRemoveQueueApc(PKAPC Apc)
long LONG
Definition: pedump.c:60
NTSTATUS NTAPI NtCancelTimer(IN HANDLE TimerHandle, OUT PBOOLEAN CurrentState OPTIONAL)
Definition: timer.c:252
#define _SEH2_END
Definition: pseh2_64.h:7
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:47
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
FORCEINLINE VOID KeInitializeSpinLock(_Out_ PKSPIN_LOCK SpinLock)
Definition: kefuncs.h:251
KSPIN_LOCK Lock
Definition: ex.h:98
smooth NULL
Definition: ftsmooth.c:513
VOID NTAPI ExpDeleteTimer(IN PVOID ObjectBody)
Definition: timer.c:108
LARGE_INTEGER TimeRemaining
Definition: extypes.h:713
NTSTATUS NTAPI NtQueryTimer(IN HANDLE TimerHandle, IN TIMER_INFORMATION_CLASS TimerInformationClass, OUT PVOID TimerInformation, IN ULONG TimerInformationLength, OUT PULONG ReturnLength OPTIONAL)
Definition: timer.c:518
NTSTATUS NTAPI ObCreateObject(IN KPROCESSOR_MODE ProbeMode OPTIONAL, IN POBJECT_TYPE Type, IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL, IN KPROCESSOR_MODE AccessMode, IN OUT PVOID ParseContext OPTIONAL, IN ULONG ObjectSize, IN ULONG PagedPoolCharge OPTIONAL, IN ULONG NonPagedPoolCharge OPTIONAL, OUT PVOID *Object)
Definition: oblife.c:938
_In_opt_ PVOID _In_opt_ PVOID SystemArgument1
Definition: ketypes.h:660
VOID(NTAPI * PTIMER_APC_ROUTINE)(_In_ PVOID TimerContext, _In_ ULONG TimerLowValue, _In_ LONG TimerHighValue)
Definition: ketypes.h:1081
struct _LIST_ENTRY * Flink
Definition: typedefs.h:120
unsigned char BOOLEAN
_In_ KPROCESSOR_MODE PreviousMode
Definition: sefuncs.h:103
_In_ LARGE_INTEGER _In_opt_ PKDPC Dpc
Definition: kefuncs.h:524
BOOLEAN NTAPI KeCancelTimer(IN OUT PKTIMER Timer)
Definition: timerobj.c:206
#define _SEH2_YIELD(STMT_)
Definition: pseh2_64.h:8
#define TIMER_ALL_ACCESS
Definition: extypes.h:116
VOID NTAPI KeReleaseSpinLockFromDpcLevel(IN PKSPIN_LOCK SpinLock)
Definition: spinlock.c:215
#define KeAcquireSpinLock(sl, irql)
Definition: env_spec_w32.h:609
VOID(NTAPI * PKRUNDOWN_ROUTINE)(IN struct _KAPC *Apc)
Definition: ketypes.h:638
#define ProbeForWriteHandle(Ptr)
Definition: probe.h:43
_In_opt_ PFILE_OBJECT _In_opt_ PETHREAD Thread
Definition: fltkernel.h:2653
enum _TIMER_INFORMATION_CLASS TIMER_INFORMATION_CLASS
#define ProbeForWriteBoolean(Ptr)
Definition: probe.h:31
VOID(NTAPI * PKNORMAL_ROUTINE)(IN PVOID NormalContext OPTIONAL, IN PVOID SystemArgument1 OPTIONAL, IN PVOID SystemArgument2 OPTIONAL)
Definition: ketypes.h:632
#define PAGED_CODE()
Definition: video.h:57
#define ProbeForReadLargeInteger(Ptr)
Definition: probe.h:75
CCHAR KPROCESSOR_MODE
Definition: ketypes.h:7
Definition: ex.h:92
_In_ PUNICODE_STRING Name
Definition: mrx.h:218
KAPC TimerApc
Definition: ex.h:95
enum _TIMER_TYPE TIMER_TYPE
char * PBOOLEAN
Definition: retypes.h:11
_In_ ACCESS_MASK _In_opt_ POBJECT_ATTRIBUTES _In_ TIMER_TYPE TimerType
Definition: zwfuncs.h:401
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:803
Definition: ketypes.h:672
VOID NTAPI ExpTimerApcKernelRoutine(IN PKAPC Apc, IN OUT PKNORMAL_ROUTINE *NormalRoutine, IN OUT PVOID *NormalContext, IN OUT PVOID *SystemArgument1, IN OUT PVOID *SystemArguemnt2)
Definition: timer.c:172
PVOID *typedef PHANDLE
Definition: ntsecpkg.h:411
NTSTATUS NTAPI NtCreateTimer(OUT PHANDLE TimerHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL, IN TIMER_TYPE TimerType)
Definition: timer.c:372
static __inline NTSTATUS DefaultQueryInfoBufferCheck(ULONG Class, const INFORMATION_CLASS_INFO *ClassList, ULONG ClassListEntries, PVOID Buffer, ULONG BufferLength, PULONG ReturnLength, PULONG_PTR ReturnLengthPtr, KPROCESSOR_MODE PreviousMode)
Definition: probe.h:59
KDPC TimerDpc
Definition: ex.h:96
Definition: ketypes.h:520
Definition: typedefs.h:118
#define STANDARD_RIGHTS_READ
Definition: nt_native.h:65
#define SYNCHRONIZE
Definition: nt_native.h:61
Status
Definition: gdiplustypes.h:24
_In_opt_ PVOID _In_opt_ PVOID _In_opt_ PVOID SystemArgument2
Definition: ketypes.h:660
_In_ PLARGE_INTEGER _In_opt_ PTIMER_APC_ROUTINE _In_opt_ PVOID _In_ BOOLEAN _In_opt_ LONG _Out_opt_ PBOOLEAN PreviousState
Definition: zwfuncs.h:428
#define NT_SUCCESS(StatCode)
Definition: cmd.c:149
enum State_ State
Definition: pofuncs.h:54
DWORD *typedef HANDLE
Definition: winlogon.h:52
NTSTATUS NTAPI ObInsertObject(IN PVOID Object, IN PACCESS_STATE AccessState OPTIONAL, IN ACCESS_MASK DesiredAccess, IN ULONG ObjectPointerBias, OUT PVOID *NewObject OPTIONAL, OUT PHANDLE Handle)
Definition: obhandle.c:2925
UINT Timer
Definition: capclock.c:11
LONG NTSTATUS
Definition: DriverTester.h:11
LONG NTAPI ExSystemExceptionFilter(VOID)
Definition: harderr.c:325
GENERIC_MAPPING GenericMapping
Definition: obtypes.h:358
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
NTSTATUS NTAPI NtSetTimer(IN HANDLE TimerHandle, IN PLARGE_INTEGER DueTime, IN PTIMER_APC_ROUTINE TimerApcRoutine OPTIONAL, IN PVOID TimerContext OPTIONAL, IN BOOLEAN WakeTimer, IN LONG Period OPTIONAL, OUT PBOOLEAN PreviousState OPTIONAL)
Definition: timer.c:582
ULONG KSPIN_LOCK
Definition: env_spec_w32.h:72
#define _SEH2_TRY
Definition: pseh2_64.h:5
#define STATUS_INVALID_PARAMETER_6
Definition: ntstatus.h:466
LONG FASTCALL ObDereferenceObjectEx(IN PVOID Object, IN LONG Count)
Definition: obref.c:88
unsigned int * PULONG
Definition: retypes.h:1
#define KeReleaseSpinLock(sl, irql)
Definition: env_spec_w32.h:627
BOOLEAN NTAPI KeInsertQueueApc(IN PKAPC Apc, IN PVOID SystemArgument1, IN PVOID SystemArgument2, IN KPRIORITY PriorityBoost)
Definition: apc.c:735
#define STATUS_TIMER_RESUME_IGNORED
Definition: ntstatus.h:151
#define TIMER_MODIFY_STATE
Definition: extypes.h:115
#define OUT
Definition: typedefs.h:40
POBJECT_TYPE ExTimerType
Definition: timer.c:18
#define ObReferenceObject
Definition: obfuncs.h:204
KTIMER KeTimer
Definition: ex.h:94
unsigned int ULONG
Definition: retypes.h:1
#define IO_NO_INCREMENT
Definition: iotypes.h:565
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
_In_ PLARGE_INTEGER _In_opt_ PTIMER_APC_ROUTINE _In_opt_ PVOID TimerContext
Definition: zwfuncs.h:428
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
_In_ PLARGE_INTEGER _In_opt_ PTIMER_APC_ROUTINE TimerApcRoutine
Definition: zwfuncs.h:428
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:6
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:12
struct _KTHREAD * Thread
Definition: ketypes.h:526
VOID NTAPI KeInitializeDpc(IN PKDPC Dpc, IN PKDEFERRED_ROUTINE DeferredRoutine, IN PVOID DeferredContext)
Definition: dpc.c:711
#define STATUS_INVALID_PARAMETER_4
Definition: ntstatus.h:464
struct _ETIMER ETIMER
OB_DELETE_METHOD DeleteProcedure
Definition: obtypes.h:369
KSPIN_LOCK ExpWakeListLock
Definition: timer.c:20
VOID NTAPI KeFlushQueuedDpcs(VOID)
Definition: dpc.c:918
ULONGLONG NTAPI KeQueryInterruptTime(VOID)
Definition: clock.c:203
ULONG DefaultNonPagedPoolCharge
Definition: obtypes.h:365
IN HDEVINFO IN PSP_DEVINFO_DATA DeviceInfoData OPTIONAL
Definition: devinst.c:44
ULONG ACCESS_MASK
Definition: nt_native.h:40
VOID NTAPI KeInitializeTimerEx(OUT PKTIMER Timer, IN TIMER_TYPE Type)
Definition: timerobj.c:244
_Out_opt_ PBOOLEAN CurrentState
Definition: zwfuncs.h:393
LONGLONG QuadPart
Definition: typedefs.h:113
#define INIT_FUNCTION
Definition: ntoskrnl.h:11
_In_opt_ PVOID DeferredContext
Definition: ketypes.h:660
KSPIN_LOCK ActiveTimerListLock
Definition: pstypes.h:1058