- New ERESOURCE implementation: fixes the return value of some functions (VOID vs...
[reactos.git] / reactos / ntoskrnl / include / internal / ex.h
1 #ifndef __NTOSKRNL_INCLUDE_INTERNAL_EXECUTIVE_H
2 #define __NTOSKRNL_INCLUDE_INTERNAL_EXECUTIVE_H
3
4 /* GLOBAL VARIABLES *********************************************************/
5
6 extern TIME_ZONE_INFORMATION ExpTimeZoneInfo;
7 extern LARGE_INTEGER ExpTimeZoneBias;
8 extern ULONG ExpTimeZoneId;
9 extern POBJECT_TYPE ExEventPairObjectType;
10
11 #define EX_OBJ_TO_HDR(eob) ((POBJECT_HEADER)((ULONG_PTR)(eob) & \
12 ~(EX_HANDLE_ENTRY_PROTECTFROMCLOSE | EX_HANDLE_ENTRY_INHERITABLE | \
13 EX_HANDLE_ENTRY_AUDITONCLOSE)))
14 #define EX_HTE_TO_HDR(hte) ((POBJECT_HEADER)((ULONG_PTR)((hte)->u1.Object) & \
15 ~(EX_HANDLE_ENTRY_PROTECTFROMCLOSE | EX_HANDLE_ENTRY_INHERITABLE | \
16 EX_HANDLE_ENTRY_AUDITONCLOSE)))
17
18 /* Note: we only use a spinlock on SMP. On UP, we cli/sti intead */
19 #ifndef CONFIG_SMP
20 #define ExAcquireResourceLock(l, i) \
21 UNREFERENCED_PARAMETER(*i); \
22 Ke386DisableInterrupts();
23 #define ExReleaseResourceLock(l, i) Ke386EnableInterrupts();
24 #else
25 #define ExAcquireResourceLock(l, i) KeAcquireSpinLock(l, i);
26 #define ExReleaseResourceLock(l, i) KeReleaseSpinLock(l, i);
27 #endif
28
29 /* INITIALIZATION FUNCTIONS *************************************************/
30
31 VOID
32 STDCALL
33 ExpWin32kInit(VOID);
34
35 VOID
36 STDCALL
37 ExInit2(VOID);
38
39 VOID
40 STDCALL
41 ExpInitTimeZoneInfo(VOID);
42
43 VOID
44 STDCALL
45 ExpInitializeWorkerThreads(VOID);
46
47 VOID
48 STDCALL
49 ExpInitLookasideLists(VOID);
50
51 VOID
52 STDCALL
53 ExpInitializeCallbacks(VOID);
54
55 VOID
56 STDCALL
57 ExpInitUuids(VOID);
58
59 VOID
60 STDCALL
61 ExpInitializeExecutive(VOID);
62
63 VOID
64 STDCALL
65 ExpInitializeEventImplementation(VOID);
66
67 VOID
68 STDCALL
69 ExpInitializeEventImplementation(VOID);
70
71 VOID
72 STDCALL
73 ExpInitializeEventPairImplementation(VOID);
74
75 VOID
76 STDCALL
77 ExpInitializeSemaphoreImplementation(VOID);
78
79 VOID
80 STDCALL
81 ExpInitializeMutantImplementation(VOID);
82
83 VOID
84 STDCALL
85 ExpInitializeTimerImplementation(VOID);
86
87 VOID
88 STDCALL
89 ExpInitializeProfileImplementation(VOID);
90
91 VOID
92 NTAPI
93 ExpResourceInitialization(VOID);
94
95 /* Rundown Functions ********************************************************/
96
97 VOID
98 FASTCALL
99 ExfInitializeRundownProtection(
100 OUT PEX_RUNDOWN_REF RunRef
101 );
102
103 VOID
104 FASTCALL
105 ExfReInitializeRundownProtection(
106 OUT PEX_RUNDOWN_REF RunRef
107 );
108
109 BOOLEAN
110 FASTCALL
111 ExfAcquireRundownProtection(
112 IN OUT PEX_RUNDOWN_REF RunRef
113 );
114
115 BOOLEAN
116 FASTCALL
117 ExfAcquireRundownProtectionEx(
118 IN OUT PEX_RUNDOWN_REF RunRef,
119 IN ULONG Count
120 );
121
122 VOID
123 FASTCALL
124 ExfReleaseRundownProtection(
125 IN OUT PEX_RUNDOWN_REF RunRef
126 );
127
128 VOID
129 FASTCALL
130 ExfReleaseRundownProtectionEx(
131 IN OUT PEX_RUNDOWN_REF RunRef,
132 IN ULONG Count
133 );
134
135 VOID
136 FASTCALL
137 ExfRundownCompleted(
138 OUT PEX_RUNDOWN_REF RunRef
139 );
140
141 VOID
142 FASTCALL
143 ExfWaitForRundownProtectionRelease(
144 IN OUT PEX_RUNDOWN_REF RunRef
145 );
146
147 /* HANDLE TABLE FUNCTIONS ***************************************************/
148
149 #define EX_HANDLE_ENTRY_LOCKED (1 << ((sizeof(PVOID) * 8) - 1))
150 #define EX_HANDLE_ENTRY_PROTECTFROMCLOSE (1 << 0)
151 #define EX_HANDLE_ENTRY_INHERITABLE (1 << 1)
152 #define EX_HANDLE_ENTRY_AUDITONCLOSE (1 << 2)
153
154 #define EX_HANDLE_TABLE_CLOSING 0x1
155
156 #define EX_HANDLE_ENTRY_FLAGSMASK (EX_HANDLE_ENTRY_LOCKED | \
157 EX_HANDLE_ENTRY_PROTECTFROMCLOSE | \
158 EX_HANDLE_ENTRY_INHERITABLE | \
159 EX_HANDLE_ENTRY_AUDITONCLOSE)
160
161 typedef VOID (STDCALL PEX_SWEEP_HANDLE_CALLBACK)(
162 PHANDLE_TABLE HandleTable,
163 PVOID Object,
164 ULONG GrantedAccess,
165 PVOID Context
166 );
167
168 typedef BOOLEAN (STDCALL PEX_DUPLICATE_HANDLE_CALLBACK)(
169 PHANDLE_TABLE HandleTable,
170 PHANDLE_TABLE_ENTRY HandleTableEntry,
171 PVOID Context
172 );
173
174 typedef BOOLEAN (STDCALL PEX_CHANGE_HANDLE_CALLBACK)(
175 PHANDLE_TABLE HandleTable,
176 PHANDLE_TABLE_ENTRY HandleTableEntry,
177 PVOID Context
178 );
179
180 VOID
181 ExpInitializeHandleTables(VOID);
182
183 PHANDLE_TABLE
184 ExCreateHandleTable(IN PEPROCESS QuotaProcess OPTIONAL);
185
186 VOID
187 ExDestroyHandleTable(
188 IN PHANDLE_TABLE HandleTable
189 );
190
191 VOID
192 ExSweepHandleTable(
193 IN PHANDLE_TABLE HandleTable,
194 IN PEX_SWEEP_HANDLE_CALLBACK SweepHandleCallback OPTIONAL,
195 IN PVOID Context OPTIONAL
196 );
197
198 PHANDLE_TABLE
199 ExDupHandleTable(
200 IN PEPROCESS QuotaProcess OPTIONAL,
201 IN PEX_DUPLICATE_HANDLE_CALLBACK DuplicateHandleCallback OPTIONAL,
202 IN PVOID Context OPTIONAL,
203 IN PHANDLE_TABLE SourceHandleTable
204 );
205
206 BOOLEAN
207 ExLockHandleTableEntry(
208 IN PHANDLE_TABLE HandleTable,
209 IN PHANDLE_TABLE_ENTRY Entry
210 );
211
212 VOID
213 ExUnlockHandleTableEntry(
214 IN PHANDLE_TABLE HandleTable,
215 IN PHANDLE_TABLE_ENTRY Entry
216 );
217
218 HANDLE
219 ExCreateHandle(
220 IN PHANDLE_TABLE HandleTable,
221 IN PHANDLE_TABLE_ENTRY Entry
222 );
223
224 BOOLEAN
225 ExDestroyHandle(
226 IN PHANDLE_TABLE HandleTable,
227 IN HANDLE Handle
228 );
229
230 VOID
231 ExDestroyHandleByEntry(
232 IN PHANDLE_TABLE HandleTable,
233 IN PHANDLE_TABLE_ENTRY Entry,
234 IN HANDLE Handle
235 );
236
237 PHANDLE_TABLE_ENTRY
238 ExMapHandleToPointer(
239 IN PHANDLE_TABLE HandleTable,
240 IN HANDLE Handle
241 );
242
243 BOOLEAN
244 ExChangeHandle(
245 IN PHANDLE_TABLE HandleTable,
246 IN HANDLE Handle,
247 IN PEX_CHANGE_HANDLE_CALLBACK ChangeHandleCallback,
248 IN PVOID Context
249 );
250
251 /* PSEH EXCEPTION HANDLING **************************************************/
252
253 LONG
254 STDCALL
255 ExSystemExceptionFilter(VOID);
256
257 static __inline _SEH_FILTER(_SEH_ExSystemExceptionFilter)
258 {
259 return ExSystemExceptionFilter();
260 }
261
262 /* RUNDOWN *******************************************************************/
263
264 #ifdef _WIN64
265 #define ExpChangeRundown(x, y, z) InterlockedCompareExchange64((PLONGLONG)x, y, z)
266 #define ExpSetRundown(x, y) InterlockedExchange64((PLONGLONG)x, y)
267 #else
268 #define ExpChangeRundown(x, y, z) InterlockedCompareExchange((PLONG)x, y, z)
269 #define ExpSetRundown(x, y) InterlockedExchange((PLONG)x, y)
270 #endif
271
272 /*++
273 * @name ExfAcquireRundownProtection
274 * INTERNAL MACRO
275 *
276 * The ExfAcquireRundownProtection routine acquires rundown protection for
277 * the specified descriptor.
278 *
279 * @param RunRef
280 * Pointer to a rundown reference descriptor.
281 *
282 * @return TRUE if access to the protected structure was granted, FALSE otherwise.
283 *
284 * @remarks This is the internal macro for system use only.In case the rundown
285 * was active, then the slow-path will be called through the exported
286 * function.
287 *
288 *--*/
289 BOOLEAN
290 FORCEINLINE
291 ExAcquireRundownProtection(IN PEX_RUNDOWN_REF RunRef)
292 {
293 ULONG_PTR Value, NewValue, OldValue;
294
295 /* Get the current value and mask the active bit */
296 Value = RunRef->Count &~ EX_RUNDOWN_ACTIVE;
297
298 /* Add a reference */
299 NewValue = Value + EX_RUNDOWN_COUNT_INC;
300
301 /* Change the value */
302 OldValue = ExpChangeRundown(RunRef, NewValue, Value);
303 if (OldValue != Value)
304 {
305 /* Rundown was active, use long path */
306 return ExfAcquireRundownProtection(RunRef);
307 }
308
309 /* Success */
310 return TRUE;
311 }
312
313 /*++
314 * @name ExReleaseRundownProtection
315 * INTERNAL MACRO
316 *
317 * The ExReleaseRundownProtection routine releases rundown protection for
318 * the specified descriptor.
319 *
320 * @param RunRef
321 * Pointer to a rundown reference descriptor.
322 *
323 * @return TRUE if access to the protected structure was granted, FALSE otherwise.
324 *
325 * @remarks This is the internal macro for system use only.In case the rundown
326 * was active, then the slow-path will be called through the exported
327 * function.
328 *
329 *--*/
330 VOID
331 FORCEINLINE
332 ExReleaseRundownProtection(IN PEX_RUNDOWN_REF RunRef)
333 {
334 ULONG_PTR Value, NewValue, OldValue;
335
336 /* Get the current value and mask the active bit */
337 Value = RunRef->Count &~ EX_RUNDOWN_ACTIVE;
338
339 /* Remove a reference */
340 NewValue = Value - EX_RUNDOWN_COUNT_INC;
341
342 /* Change the value */
343 OldValue = ExpChangeRundown(RunRef, NewValue, Value);
344
345 /* Check if the rundown was active */
346 if (OldValue != Value)
347 {
348 /* Rundown was active, use long path */
349 ExfReleaseRundownProtection(RunRef);
350 }
351 else
352 {
353 /* Sanity check */
354 ASSERT((Value >= EX_RUNDOWN_COUNT_INC) || (KeNumberProcessors > 1));
355 }
356 }
357
358 /*++
359 * @name ExInitializeRundownProtection
360 * INTERNAL MACRO
361 *
362 * The ExInitializeRundownProtection routine initializes a rundown
363 * protection descriptor.
364 *
365 * @param RunRef
366 * Pointer to a rundown reference descriptor.
367 *
368 * @return None.
369 *
370 * @remarks This is the internal macro for system use only.
371 *
372 *--*/
373 VOID
374 FORCEINLINE
375 ExInitializeRundownProtection(IN PEX_RUNDOWN_REF RunRef)
376 {
377 /* Set the count to zero */
378 RunRef->Count = 0;
379 }
380
381 /*++
382 * @name ExWaitForRundownProtectionRelease
383 * INTERNAL MACRO
384 *
385 * The ExWaitForRundownProtectionRelease routine waits until the specified
386 * rundown descriptor has been released.
387 *
388 * @param RunRef
389 * Pointer to a rundown reference descriptor.
390 *
391 * @return None.
392 *
393 * @remarks This is the internal macro for system use only. If a wait is actually
394 * necessary, then the slow path is taken through the exported function.
395 *
396 *--*/
397 VOID
398 FORCEINLINE
399 ExWaitForRundownProtectionRelease(IN PEX_RUNDOWN_REF RunRef)
400 {
401 ULONG_PTR Value;
402
403 /* Set the active bit */
404 Value = ExpChangeRundown(RunRef, EX_RUNDOWN_ACTIVE, 0);
405 if ((Value) || (Value != EX_RUNDOWN_ACTIVE))
406 {
407 /* If the the rundown wasn't already active, then take the long path */
408 ExfWaitForRundownProtectionRelease(RunRef);
409 }
410 }
411
412 /*++
413 * @name ExRundownCompleted
414 * INTERNAL MACRO
415 *
416 * The ExRundownCompleted routine completes the rundown of the specified
417 * descriptor by setting the active bit.
418 *
419 * @param RunRef
420 * Pointer to a rundown reference descriptor.
421 *
422 * @return None.
423 *
424 * @remarks This is the internal macro for system use only.
425 *
426 *--*/
427 VOID
428 FORCEINLINE
429 ExRundownCompleted(IN PEX_RUNDOWN_REF RunRef)
430 {
431 /* Sanity check */
432 ASSERT((RunRef->Count & EX_RUNDOWN_ACTIVE) != 0);
433
434 /* Mark the counter as active */
435 ExpSetRundown(&RunRef->Count, EX_RUNDOWN_ACTIVE);
436 }
437
438 /* PUSHLOCKS *****************************************************************/
439
440 /*++
441 * @name ExAcquirePushLockExclusive
442 * INTERNAL MACRO
443 *
444 * The ExAcquirePushLockExclusive macro exclusively acquires a PushLock.
445 *
446 * @params PushLock
447 * Pointer to the pushlock which is to be acquired.
448 *
449 * @return None.
450 *
451 * @remarks The function attempts the quickest route to acquire the lock, which is
452 * to simply set the lock bit.
453 * However, if the pushlock is already shared, the slower path is taken.
454 *
455 * Callers of ExAcquirePushLockShared must be running at IRQL <= APC_LEVEL.
456 * This macro should usually be paired up with KeAcquireCriticalRegion.
457 *
458 *--*/
459 VOID
460 FORCEINLINE
461 ExAcquirePushLockExclusive(PEX_PUSH_LOCK PushLock)
462 {
463 /* Try acquiring the lock */
464 if (InterlockedBitTestAndSet((PLONG)PushLock, EX_PUSH_LOCK_LOCK_V))
465 {
466 /* Someone changed it, use the slow path */
467 ExfAcquirePushLockExclusive(PushLock);
468 }
469
470 /* Sanity check */
471 ASSERT(PushLock->Locked);
472 }
473
474 /*++
475 * @name ExAcquirePushLockShared
476 * INTERNAL MACRO
477 *
478 * The ExAcquirePushLockShared macro acquires a shared PushLock.
479 *
480 * @params PushLock
481 * Pointer to the pushlock which is to be acquired.
482 *
483 * @return None.
484 *
485 * @remarks The function attempts the quickest route to acquire the lock, which is
486 * to simply set the lock bit and set the share count to one.
487 * However, if the pushlock is already shared, the slower path is taken.
488 *
489 * Callers of ExAcquirePushLockShared must be running at IRQL <= APC_LEVEL.
490 * This macro should usually be paired up with KeAcquireCriticalRegion.
491 *
492 *--*/
493 VOID
494 FORCEINLINE
495 ExAcquirePushLockShared(PEX_PUSH_LOCK PushLock)
496 {
497 EX_PUSH_LOCK NewValue;
498
499 /* Try acquiring the lock */
500 NewValue.Value = EX_PUSH_LOCK_LOCK | EX_PUSH_LOCK_SHARE_INC;
501 if (!InterlockedCompareExchangePointer(PushLock, NewValue.Ptr, 0))
502 {
503 /* Someone changed it, use the slow path */
504 ExfAcquirePushLockShared(PushLock);
505 }
506
507 /* Sanity checks */
508 ASSERT(PushLock->Locked);
509 ASSERT(PushLock->Waiting || PushLock->Shared > 0);
510 }
511
512 /*++
513 * @name ExWaitOnPushLock
514 * INTERNAL MACRO
515 *
516 * The ExWaitOnPushLock macro acquires and instantly releases a pushlock.
517 *
518 * @params PushLock
519 * Pointer to a pushlock.
520 *
521 * @return None.
522 *
523 * @remarks The function attempts to get any exclusive waiters out of their slow
524 * path by forcing an instant acquire/release operation.
525 *
526 * Callers of ExWaitOnPushLock must be running at IRQL <= APC_LEVEL.
527 *
528 *--*/
529 VOID
530 FORCEINLINE
531 ExWaitOnPushLock(PEX_PUSH_LOCK PushLock)
532 {
533 /* Acquire the lock */
534 ExfAcquirePushLockExclusive(PushLock);
535 ASSERT(PushLock->Locked);
536
537 /* Release it */
538 ExfReleasePushLockExclusive(PushLock);
539 }
540
541 /*++
542 * @name ExReleasePushLockShared
543 * INTERNAL MACRO
544 *
545 * The ExReleasePushLockShared macro releases a previously acquired PushLock.
546 *
547 * @params PushLock
548 * Pointer to a previously acquired pushlock.
549 *
550 * @return None.
551 *
552 * @remarks The function attempts the quickest route to release the lock, which is
553 * to simply decrease the share count and remove the lock bit.
554 * However, if the pushlock is being waited on then the long path is taken.
555 *
556 * Callers of ExReleasePushLockShared must be running at IRQL <= APC_LEVEL.
557 * This macro should usually be paired up with KeLeaveCriticalRegion.
558 *
559 *--*/
560 VOID
561 FORCEINLINE
562 ExReleasePushLockShared(PEX_PUSH_LOCK PushLock)
563 {
564 EX_PUSH_LOCK OldValue;
565
566 /* Sanity checks */
567 ASSERT(PushLock->Locked);
568 ASSERT(PushLock->Waiting || PushLock->Shared > 0);
569
570 /* Try to clear the pushlock */
571 OldValue.Value = EX_PUSH_LOCK_LOCK | EX_PUSH_LOCK_SHARE_INC;
572 if (InterlockedCompareExchangePointer(PushLock, 0, OldValue.Ptr) !=
573 OldValue.Ptr)
574 {
575 /* There are still other people waiting on it */
576 ExfReleasePushLockShared(PushLock);
577 }
578 }
579
580 /*++
581 * @name ExReleasePushLockExclusive
582 * INTERNAL MACRO
583 *
584 * The ExReleasePushLockExclusive macro releases a previously
585 * exclusively acquired PushLock.
586 *
587 * @params PushLock
588 * Pointer to a previously acquired pushlock.
589 *
590 * @return None.
591 *
592 * @remarks The function attempts the quickest route to release the lock, which is
593 * to simply clear the locked bit.
594 * However, if the pushlock is being waited on, the slow path is taken
595 * in an attempt to wake up the lock.
596 *
597 * Callers of ExReleasePushLockExclusive must be running at IRQL <= APC_LEVEL.
598 * This macro should usually be paired up with KeLeaveCriticalRegion.
599 *
600 *--*/
601 VOID
602 FORCEINLINE
603 ExReleasePushLockExclusive(PEX_PUSH_LOCK PushLock)
604 {
605 EX_PUSH_LOCK OldValue;
606
607 /* Sanity checks */
608 ASSERT(PushLock->Locked);
609 ASSERT(PushLock->Waiting || PushLock->Shared == 0);
610
611 /* Unlock the pushlock */
612 OldValue.Value = InterlockedExchangeAddSizeT((PLONG)PushLock, -1);
613
614 /* Sanity checks */
615 ASSERT(OldValue.Locked);
616 ASSERT(OldValue.Waiting || OldValue.Shared == 0);
617
618 /* Check if anyone is waiting on it and it's not already waking*/
619 if ((OldValue.Waiting) && !(OldValue.Waking))
620 {
621 /* Wake it up */
622 ExfTryToWakePushLock(PushLock);
623 }
624 }
625
626 /*++
627 * @name ExReleasePushLock
628 * INTERNAL MACRO
629 *
630 * The ExReleasePushLock macro releases a previously acquired PushLock.
631 *
632 * @params PushLock
633 * Pointer to a previously acquired pushlock.
634 *
635 * @return None.
636 *
637 * @remarks The function attempts the quickest route to release the lock, which is
638 * to simply clear all the fields and decrease the share count if required.
639 * However, if the pushlock is being waited on then the long path is taken.
640 *
641 * Callers of ExReleasePushLock must be running at IRQL <= APC_LEVEL.
642 * This macro should usually be paired up with KeLeaveCriticalRegion.
643 *
644 *--*/
645 VOID
646 FORCEINLINE
647 ExReleasePushLock(PEX_PUSH_LOCK PushLock)
648 {
649 EX_PUSH_LOCK OldValue = *PushLock;
650 EX_PUSH_LOCK NewValue;
651
652 /* Sanity checks */
653 ASSERT(OldValue.Locked);
654
655 /* Check if the pushlock is shared */
656 if (OldValue.Shared > 1)
657 {
658 /* Decrease the share count */
659 NewValue.Value = OldValue.Value &~ EX_PUSH_LOCK_SHARE_INC;
660 }
661 else
662 {
663 /* Clear the pushlock entirely */
664 NewValue.Value = 0;
665 }
666
667 /* Check if nobody is waiting on us and try clearing the lock here */
668 if ((OldValue.Waiting) ||
669 (InterlockedCompareExchangePointer(PushLock, NewValue.Ptr, OldValue.Ptr) ==
670 OldValue.Ptr))
671 {
672 /* We have waiters, use the long path */
673 ExfReleasePushLock(PushLock);
674 }
675 }
676
677 /* OTHER FUNCTIONS **********************************************************/
678
679 LONGLONG
680 FASTCALL
681 ExfpInterlockedExchange64(
682 LONGLONG volatile * Destination,
683 PLONGLONG Exchange
684 );
685
686 NTSTATUS
687 ExpSetTimeZoneInformation(PTIME_ZONE_INFORMATION TimeZoneInformation);
688
689 NTSTATUS
690 NTAPI
691 ExpAllocateLocallyUniqueId(OUT LUID *LocallyUniqueId);
692
693 VOID
694 STDCALL
695 ExTimerRundown(VOID);
696
697 #define InterlockedDecrementUL(Addend) \
698 (ULONG)InterlockedDecrement((PLONG)(Addend))
699
700 #define InterlockedIncrementUL(Addend) \
701 (ULONG)InterlockedIncrement((PLONG)(Addend))
702
703 #define InterlockedExchangeUL(Target, Value) \
704 (ULONG)InterlockedExchange((PLONG)(Target), (LONG)(Value))
705
706 #define InterlockedExchangeAddUL(Addend, Value) \
707 (ULONG)InterlockedExchangeAdd((PLONG)(Addend), (LONG)(Value))
708
709 #define InterlockedCompareExchangeUL(Destination, Exchange, Comperand) \
710 (ULONG)InterlockedCompareExchange((PLONG)(Destination), (LONG)(Exchange), (LONG)(Comperand))
711
712 #define ExfInterlockedCompareExchange64UL(Destination, Exchange, Comperand) \
713 (ULONGLONG)ExfInterlockedCompareExchange64((PLONGLONG)(Destination), (PLONGLONG)(Exchange), (PLONGLONG)(Comperand))
714
715 #define ExfpInterlockedExchange64UL(Target, Value) \
716 (ULONGLONG)ExfpInterlockedExchange64((PLONGLONG)(Target), (PLONGLONG)(Value))
717
718 #endif /* __NTOSKRNL_INCLUDE_INTERNAL_EXECUTIVE_H */