ReactOS  0.4.15-dev-499-g1f31905
ExInterlocked.c
Go to the documentation of this file.
1 /*
2  * PROJECT: ReactOS kernel-mode tests
3  * LICENSE: GPLv2+ - See COPYING in the top level directory
4  * PURPOSE: Kernel-Mode Test Suite Interlocked function test
5  * PROGRAMMER: Thomas Faber <thomas.faber@reactos.org>
6  */
7 
8 #include <stddef.h>
9 
10 /* missing prototypes >:| */
11 __declspec(dllimport) long __fastcall InterlockedCompareExchange(volatile long *, long, long);
13 __declspec(dllimport) __int64 __fastcall ExfInterlockedCompareExchange64(volatile __int64 *, __int64 *, __int64 *);
14 __declspec(dllimport) long __fastcall InterlockedExchange(volatile long *, long);
15 __declspec(dllimport) unsigned long __stdcall ExInterlockedExchangeUlong(unsigned long *, unsigned long, void *);
16 __declspec(dllimport) long __fastcall InterlockedExchangeAdd(volatile long *, long);
17 #ifdef _X86_
18 __declspec(dllimport) unsigned long __stdcall ExInterlockedAddUlong(unsigned long *, unsigned long, unsigned long *);
19 #endif
20 __declspec(dllimport) unsigned long __stdcall Exi386InterlockedExchangeUlong(unsigned long *, unsigned long);
21 __declspec(dllimport) long __fastcall InterlockedIncrement(long *);
22 __declspec(dllimport) long __fastcall InterlockedDecrement(long *);
23 __declspec(dllimport) int __stdcall ExInterlockedIncrementLong(long *, void *);
24 __declspec(dllimport) int __stdcall ExInterlockedDecrementLong(long *, void *);
27 
28 #include <kmt_test.h>
29 
30 /* TODO: There are quite some changes needed for other architectures!
31  ExInterlockedAddLargeInteger, ExInterlockedAddUlong are the only two
32  functions actually exported by my win7/x64 kernel! */
33 
34 /* TODO: stress-testing */
35 
36 static KSPIN_LOCK SpinLock;
37 
38 #ifdef _M_IX86
39 typedef struct
40 {
41  unsigned long esi, edi, ebx, ebp, esp;
42 } PROCESSOR_STATE;
43 #elif defined(_M_AMD64)
44 typedef struct
45 {
46  unsigned long long rsi, rdi, rbx, rbp, rsp, r12, r13, r14, r15;
47 } PROCESSOR_STATE;
48 #else
49 // dummy
50 typedef int PROCESSOR_STATE;
51 #endif
52 
53 /* TODO: these need to be rewritten in proper assembly to account for registers
54  * saved by the caller */
55 #if defined(_MSC_VER) && defined(_M_IX86)
56 #define SaveState(State) do \
57 { \
58  __asm lea ecx, [State] \
59  __asm mov [ecx], esi \
60  __asm mov [ecx+4], edi \
61  __asm mov [ecx+8], ebx \
62  __asm mov [ecx+12], ebp \
63  __asm mov [ecx+16], esp \
64 } while (0)
65 
66 #define CheckState(OldState, NewState) do \
67 { \
68  /* TODO: MSVC uses esi and saves it before, so this is okay */ \
69  /*ok_eq_hex((OldState)->esi, (NewState)->esi);*/ \
70  ok_eq_hex((OldState)->edi, (NewState)->edi); \
71  ok_eq_hex((OldState)->ebx, (NewState)->ebx); \
72  ok_eq_hex((OldState)->ebp, (NewState)->ebp); \
73  ok_eq_hex((OldState)->esp, (NewState)->esp); \
74 } while (0)
75 
76 #elif defined(__GNUC__) && defined(_M_IX86)
77 #define SaveState(State) \
78  asm volatile( \
79  "movl\t%%esi, (%%ecx)\n\t" \
80  "movl\t%%edi, 4(%%ecx)\n\t" \
81  "movl\t%%ebx, 8(%%ecx)\n\t" \
82  "movl\t%%ebp, 12(%%ecx)\n\t" \
83  "movl\t%%esp, 16(%%ecx)" \
84  : : "c" (&State) : "memory" \
85  );
86 
87 #define CheckState(OldState, NewState) do \
88 { \
89  /* TODO: GCC 4.7 uses esi and saves it before, so this is okay */ \
90  /*ok_eq_hex((OldState)->esi, (NewState)->esi);*/ \
91  ok_eq_hex((OldState)->edi, (NewState)->edi); \
92  /* TODO: GCC 4.4 uses ebx and saves it before, so this is okay */ \
93  /*ok_eq_hex((OldState)->ebx, (NewState)->ebx);*/ \
94  ok_eq_hex((OldState)->ebp, (NewState)->ebp); \
95  ok_eq_hex((OldState)->esp, (NewState)->esp); \
96 } while (0)
97 #elif defined(__GNUC__) && defined(_M_AMD64)
98 #define SaveState(State) \
99  asm volatile( \
100  "mov\t%%rsi, (%%rcx)\n\t" \
101  "mov\t%%rdi, 8(%%rcx)\n\t" \
102  "mov\t%%rbx, 16(%%rcx)\n\t" \
103  "mov\t%%rbp, 24(%%rcx)\n\t" \
104  "mov\t%%rsp, 32(%%rcx)\n\t" \
105  "mov\t%%r12, 40(%%rcx)\n\t" \
106  "mov\t%%r13, 48(%%rcx)\n\t" \
107  "mov\t%%r14, 56(%%rcx)\n\t" \
108  "mov\t%%r15, 64(%%rcx)" \
109  : : "c" (&State) : "memory" \
110  );
111 
112 #define CheckState(OldState, NewState) do \
113 { \
114  ok_eq_hex((OldState)->rsi, (NewState)->rsi); \
115  ok_eq_hex((OldState)->rdi, (NewState)->rdi); \
116  ok_eq_hex((OldState)->rbx, (NewState)->rbx); \
117  ok_eq_hex((OldState)->rbp, (NewState)->rbp); \
118  ok_eq_hex((OldState)->rsp, (NewState)->rsp); \
119  ok_eq_hex((OldState)->r12, (NewState)->r12); \
120  ok_eq_hex((OldState)->r13, (NewState)->r13); \
121  ok_eq_hex((OldState)->r14, (NewState)->r14); \
122  ok_eq_hex((OldState)->r15, (NewState)->r15); \
123 } while (0)
124 #else
125 #define SaveState(State)
126 #define CheckState(OldState, NewState) do \
127 { \
128  (void)OldState; \
129  (void)NewState; \
130 } while (0)
131 #endif
132 
133 static
135 Large(
137 {
138  LARGE_INTEGER Ret;
139  Ret.QuadPart = Value;
140  return Ret;
141 }
142 
143 #define CheckInterlockedCmpXchg(Function, Type, Print, Val, Cmp, Xchg, \
144  ExpectedValue, ExpectedRet) do \
145 { \
146  Type Ret##Type = 0; \
147  Type Value##Type = Val; \
148  Status = STATUS_SUCCESS; \
149  _SEH2_TRY { \
150  SaveState(OldState); \
151  Ret##Type = Function(&Value##Type, Xchg, Cmp); \
152  SaveState(NewState); \
153  CheckState(&OldState, &NewState); \
154  } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) { \
155  Status = _SEH2_GetExceptionCode(); \
156  } _SEH2_END; \
157  ok_eq_hex(Status, STATUS_SUCCESS); \
158  ok_eq_print(Ret##Type, ExpectedRet, Print); \
159  ok_eq_print(Value##Type, ExpectedValue, Print); \
160 } while (0)
161 
162 #define CheckInterlockedCmpXchgI(Function, Type, Print, Val, Cmp, Xchg, \
163  ExpectedValue, ExpectedRet, ...) do \
164 { \
165  Type Ret##Type = 0; \
166  Type Value##Type = Val; \
167  Type Compare##Type = Cmp; \
168  Type Exchange##Type = Xchg; \
169  Status = STATUS_SUCCESS; \
170  _SEH2_TRY { \
171  SaveState(OldState); \
172  Ret##Type = Function(&Value##Type, &Exchange##Type, \
173  &Compare##Type, ##__VA_ARGS__); \
174  SaveState(NewState); \
175  CheckState(&OldState, &NewState); \
176  } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) { \
177  Status = _SEH2_GetExceptionCode(); \
178  } _SEH2_END; \
179  ok_eq_hex(Status, STATUS_SUCCESS); \
180  ok_eq_print(Ret##Type, ExpectedRet, Print); \
181  ok_eq_print(Value##Type, ExpectedValue, Print); \
182  ok_eq_print(Exchange##Type, Xchg, Print); \
183  ok_eq_print(Compare##Type, Cmp, Print); \
184 } while(0)
185 
186 #define CheckInterlockedOp(Function, Type, Print, Val, Op, \
187  ExpectedValue, ExpectedRet, ...) do \
188 { \
189  Type Ret##Type = 0; \
190  Type Value##Type = Val; \
191  Status = STATUS_SUCCESS; \
192  _SEH2_TRY { \
193  SaveState(OldState); \
194  Ret##Type = Function(&Value##Type, Op, ##__VA_ARGS__); \
195  SaveState(NewState); \
196  CheckState(&OldState, &NewState); \
197  } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) { \
198  Status = _SEH2_GetExceptionCode(); \
199  } _SEH2_END; \
200  ok_eq_hex(Status, STATUS_SUCCESS); \
201  ok_eq_print(Ret##Type, ExpectedRet, Print); \
202  ok_eq_print(Value##Type, ExpectedValue, Print); \
203 } while (0)
204 
205 #define CheckInterlockedOpNoArg(Function, Type, Print, Val, \
206  ExpectedValue, ExpectedRet, ...) do \
207 { \
208  Type Ret##Type = 0; \
209  Type Value##Type = Val; \
210  Status = STATUS_SUCCESS; \
211  _SEH2_TRY { \
212  SaveState(OldState); \
213  Ret##Type = Function(&Value##Type, ##__VA_ARGS__); \
214  SaveState(NewState); \
215  CheckState(&OldState, &NewState); \
216  } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) { \
217  Status = _SEH2_GetExceptionCode(); \
218  } _SEH2_END; \
219  ok_eq_hex(Status, STATUS_SUCCESS); \
220  ok_eq_print(Ret##Type, ExpectedRet, Print); \
221  ok_eq_print(Value##Type, ExpectedValue, Print); \
222 } while (0)
223 
224 #define CheckInterlockedOpLarge(Function, Type, Print, Val, Op, \
225  ExpectedValue, ExpectedRet, ...) do \
226 { \
227  Type Ret##Type = Large(0); \
228  Type Value##Type = Val; \
229  Status = STATUS_SUCCESS; \
230  _SEH2_TRY { \
231  SaveState(OldState); \
232  Ret##Type = Function(&Value##Type, Op, ##__VA_ARGS__); \
233  SaveState(NewState); \
234  CheckState(&OldState, &NewState); \
235  } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) { \
236  Status = _SEH2_GetExceptionCode(); \
237  } _SEH2_END; \
238  ok_eq_hex(Status, STATUS_SUCCESS); \
239  ok_eq_print(Ret##Type.QuadPart, ExpectedRet, Print); \
240  ok_eq_print(Value##Type.QuadPart, ExpectedValue, Print); \
241 } while (0)
242 
243 #define CheckInterlockedOpLargeNoRet(Function, Type, Print, Val, Op, \
244  ExpectedValue) do \
245 { \
246  Type Value##Type = Val; \
247  Status = STATUS_SUCCESS; \
248  _SEH2_TRY { \
249  SaveState(OldState); \
250  Function(&Value##Type, Op); \
251  SaveState(NewState); \
252  CheckState(&OldState, &NewState); \
253  } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) { \
254  Status = _SEH2_GetExceptionCode(); \
255  } _SEH2_END; \
256  ok_eq_hex(Status, STATUS_SUCCESS); \
257  ok_eq_print(Value##Type.QuadPart, ExpectedValue, Print); \
258 } while (0)
259 
260 static
261 VOID
263 {
265  PKSPIN_LOCK pSpinLock = &SpinLock;
266  PROCESSOR_STATE OldState, NewState;
267 
268  /* on x86, most of these are supported intrinsically and don't need a spinlock! */
269 #if defined _M_IX86 || defined _M_AMD64
270  pSpinLock = NULL;
271 #endif
272 
273  /* CompareExchange */
274  /* macro version */
277  /* these only exist as macros on x86 */
282  /* exported function */
283 #undef InterlockedCompareExchange
284 #ifdef _M_IX86
287 #endif
288  /* only exists as a macro */
291  /* macro version */
292  CheckInterlockedCmpXchgI(ExInterlockedCompareExchange64, LONGLONG, "%I64d", 17, 4LL, 20LL, 17LL, 17LL, pSpinLock);
293  CheckInterlockedCmpXchgI(ExInterlockedCompareExchange64, LONGLONG, "%I64d", 17, 17LL, 21LL, 21LL, 17LL, pSpinLock);
294 #ifdef _M_IX86
295  /* exported function */
296  CheckInterlockedCmpXchgI((ExInterlockedCompareExchange64), LONGLONG, "%I64d", 17, 4LL, 20LL, 17LL, 17LL, pSpinLock);
297  CheckInterlockedCmpXchgI((ExInterlockedCompareExchange64), LONGLONG, "%I64d", 17, 17LL, 21LL, 21LL, 17LL, pSpinLock);
298  /* fastcall version */
299  CheckInterlockedCmpXchgI(ExfInterlockedCompareExchange64, LONGLONG, "%I64d", 17, 4LL, 20LL, 17LL, 17LL);
300  CheckInterlockedCmpXchgI(ExfInterlockedCompareExchange64, LONGLONG, "%I64d", 17, 17LL, 21LL, 21LL, 17LL);
301 #endif
302 
303  /* Exchange */
304  CheckInterlockedOp(InterlockedExchange, LONG, "%ld", 5, 8, 8L, 5L);
306 #undef InterlockedExchange
307 #ifdef _M_IX86
308  CheckInterlockedOp(InterlockedExchange, LONG, "%ld", 5, 8, 8L, 5L);
309  CheckInterlockedOp(ExInterlockedExchangeUlong, ULONG, "%lu", 212, 121, 121LU, 212LU, pSpinLock);
310  CheckInterlockedOp((ExInterlockedExchangeUlong), ULONG, "%lu", 212, 121, 121LU, 212LU, pSpinLock);
311  CheckInterlockedOp(Exi386InterlockedExchangeUlong, ULONG, "%lu", 212, 121, 121LU, 212LU);
312  CheckInterlockedOp(Exfi386InterlockedExchangeUlong, ULONG, "%lu", 212, 121, 121LU, 212LU);
313 #endif
314 
315  /* ExchangeAdd */
316  /* TODO: ExInterlockedExchangeAddLargeInteger? */
317  CheckInterlockedOp(InterlockedExchangeAdd, LONG, "%ld", 312, 7, 319L, 312L);
318 #undef InterlockedExchangeAdd
319 #ifdef _M_IX86
320  CheckInterlockedOp(InterlockedExchangeAdd, LONG, "%ld", 312, 7, 319L, 312L);
321 #endif
322 
323  /* Add */
324  /* these DO need a valid spinlock even on x86 */
325  CheckInterlockedOpLarge(ExInterlockedAddLargeInteger, LARGE_INTEGER, "%I64d", Large(23), Large(7), 30LL, 23LL, &SpinLock);
327  CheckInterlockedOp(ExInterlockedAddUlong, ULONG, "%lu", 239, 44, 283LU, 239LU, &SpinLock);
328 #undef ExInterlockedAddUlong
329  CheckInterlockedOp(ExInterlockedAddUlong, ULONG, "%lu", 239, 44, 283LU, 239LU, &SpinLock);
330 
331  /* Increment */
332  CheckInterlockedOpNoArg(InterlockedIncrement, LONG, "%ld", 2341L, 2342L, 2342L);
336 #undef InterlockedIncrement
337 #ifdef _M_IX86
338  CheckInterlockedOpNoArg(InterlockedIncrement, LONG, "%ld", 2341L, 2342L, 2342L);
352 #endif
353 
354  /* Decrement */
355  CheckInterlockedOpNoArg(InterlockedDecrement, LONG, "%ld", 1745L, 1744L, 1744L);
359 #undef InterlockedDecrement
360 #ifdef _M_IX86
361  CheckInterlockedOpNoArg(InterlockedDecrement, LONG, "%ld", 1745L, 1744L, 1744L);
375 #endif
376 
377  /* And, Or, Xor */
378  CheckInterlockedOp(InterlockedAnd, LONG, "0x%lx", 0x1234L, 0x1111L, 0x1010L, 0x1234L);
379  CheckInterlockedOp(InterlockedOr, LONG, "0x%lx", 0x1234L, 0x1111L, 0x1335L, 0x1234L);
380  CheckInterlockedOp(InterlockedXor, LONG, "0x%lx", 0x1234L, 0x1111L, 0x0325L, 0x1234L);
381 #ifdef _WIN64
382  CheckInterlockedOp(InterlockedXor64, LONGLONG, "0x%I64x", 0x200001234LL, 0x100001111LL, 0x300000325LL, 0x200001234LL);
383 #endif
384 }
385 
386 START_TEST(ExInterlocked)
387 {
388  KIRQL Irql;
390 
391  /* functional testing */
395  KeLowerIrql(Irql);
396 }
START_TEST(ExInterlocked)
#define InterlockedAnd
Definition: interlocked.h:62
#define KeRaiseIrql(irql, oldIrql)
Definition: env_spec_w32.h:597
#define LL
Definition: tui.h:84
#define KeLowerIrql(oldIrql)
Definition: env_spec_w32.h:602
#define MAXLONG
Definition: umtypes.h:116
ecx edi ebx edx edi decl ecx esi eax jecxz decl eax andl eax esi movl edx movl TEMP incl eax andl eax ecx incl ebx eax jnz xchgl ecx incl TEMP esp ecx subl ebx pushl ecx ecx edx ecx ecx mm0 mm4 mm0 mm4 mm1 mm5 mm1 mm5 mm2 mm6 mm2 mm6 mm3 mm7 mm3 mm7 paddd mm0 paddd mm4 paddd mm0 paddd mm4 paddd mm0 paddd mm4 movq mm1 movq mm5 mm1 mm5 paddd mm0 paddd mm4 mm0 mm4 packssdw mm0 packssdw mm4 mm1 punpckldq mm0 pand mm1 pand mm0 por mm1 movq edi esi edx edi decl ecx jnz popl ecx ecx jecxz mm0 mm0 mm1 mm1 mm2 mm2 mm3 mm3 paddd mm0 paddd mm0 paddd mm0 movq mm1 mm1 paddd mm0 mm0 packssdw mm0 movd eax movw edi esi edx esi ecx mm0 mm4 mm0 mm4 mm1 mm5 mm1 mm5 mm2 mm6 mm2 mm6 mm3 mm7 mm3 mm7 paddd mm0 paddd mm4 paddd mm0 paddd mm4 paddd mm0 paddd mm4 movq mm1 movq mm5 mm1 mm5 paddd mm1 paddd mm5 mm1 mm5 packssdw mm1 packssdw mm5 psubd mm0 psubd mm4 psubsw mm0 psubsw mm4 mm1 punpckldq mm0 pand mm1 pand mm0 por mm1 movq edi esi edx edi decl ecx jnz mm0 mm0 mm1 mm1 mm2 mm2 mm3 mm3 paddd mm0 paddd mm0 paddd mm0 movq mm1 mm1 paddd mm1 mm1 packssdw mm1 psubd mm0 psubsw mm0 movd eax movw edi emms popl ebx popl esi popl edi mov ebp
Definition: synth_sse3d.h:248
#define CheckInterlockedCmpXchg(Function, Type, Print, Val, Cmp, Xchg, ExpectedValue, ExpectedRet)
ecx edi ebx edx edi decl ecx esi eax jecxz decl eax andl eax esi movl edx movl TEMP incl eax andl eax ecx incl ebx eax jnz xchgl ecx incl TEMP esi
Definition: synth_sse3d.h:103
#define __fastcall
Definition: sync.c:38
LONG NTSTATUS
Definition: precomp.h:26
INTERLOCKED_RESULT NTAPI ExInterlockedIncrementLong(IN PLONG Addend, IN PKSPIN_LOCK Lock)
Definition: interlocked.c:253
#define InterlockedIncrementRelease
Definition: interlocked.h:203
#define InterlockedCompareExchange
Definition: interlocked.h:104
#define CheckInterlockedOp(Function, Type, Print, Val, Op, ExpectedValue, ExpectedRet,...)
#define InterlockedCompareExchangeAcquire
Definition: interlocked.h:105
KSPIN_LOCK * PKSPIN_LOCK
Definition: env_spec_w32.h:73
static VOID TestInterlockedFunctional(VOID)
NTKERNELAPI VOID FASTCALL ExInterlockedAddLargeStatistic(IN PLARGE_INTEGER Addend, IN ULONG Increment)
Definition: interlocked.c:103
_Out_ PKIRQL Irql
Definition: csq.h:179
IN UCHAR Value
Definition: halp.h:394
_In_ PKSERVICE_ROUTINE _In_opt_ PVOID _In_opt_ PKSPIN_LOCK SpinLock
Definition: iofuncs.h:798
UCHAR KIRQL
Definition: env_spec_w32.h:591
NTKERNELAPI LONGLONG FASTCALL ExInterlockedCompareExchange64(IN OUT PLONGLONG Destination, IN PLONGLONG Exchange, IN PLONGLONG Comparand, IN PKSPIN_LOCK Lock)
Definition: interlocked.c:113
long LONG
Definition: pedump.c:60
#define InterlockedCompareExchangePointer
Definition: interlocked.h:129
FORCEINLINE VOID KeInitializeSpinLock(_Out_ PKSPIN_LOCK SpinLock)
Definition: kefuncs.h:238
smooth NULL
Definition: ftsmooth.c:416
#define InterlockedDecrementRelease
Definition: interlocked.h:136
#define CheckInterlockedOpLarge(Function, Type, Print, Val, Op, ExpectedValue, ExpectedRet,...)
#define InterlockedExchangeAdd
Definition: interlocked.h:181
#define InterlockedXor64
Definition: interlocked.h:291
int64_t LONGLONG
Definition: typedefs.h:67
LONG NTAPI Exi386InterlockedExchangeUlong(PLONG Target, LONG Exch, LONG Compare)
Definition: stubs.c:48
#define InterlockedExchangePointer(Target, Value)
Definition: dshow.h:45
ecx edi ebx edx edi decl ecx esi eax jecxz decl eax andl eax esi movl edx movl TEMP incl eax andl eax ecx incl ebx eax jnz xchgl ecx incl TEMP esp ecx subl ebx pushl ecx ecx edx ecx ecx mm0 mm4 mm0 mm4 mm1 mm5 mm1 mm5 mm2 mm6 mm2 mm6 mm3 mm7 mm3 mm7 paddd mm0 paddd mm4 paddd mm0 paddd mm4 paddd mm0 paddd mm4 movq mm1 movq mm5 mm1 mm5 paddd mm0 paddd mm4 mm0 mm4 packssdw mm0 packssdw mm4 mm1 punpckldq mm0 pand mm1 pand mm0 por mm1 movq edi esi edx edi decl ecx jnz popl ecx ecx jecxz mm0 mm0 mm1 mm1 mm2 mm2 mm3 mm3 paddd mm0 paddd mm0 paddd mm0 movq mm1 mm1 paddd mm0 mm0 packssdw mm0 movd eax movw edi esi edx edi
Definition: synth_sse3d.h:185
uint64_t ULONGLONG
Definition: typedefs.h:66
#define __stdcall
Definition: typedefs.h:25
ecx edi ebx edx edi decl ecx esi eax jecxz decl eax andl ebx
Definition: synth_sse3d.h:83
#define InterlockedDecrementAcquire
Definition: interlocked.h:135
static const WCHAR L[]
Definition: oid.c:1250
#define InterlockedDecrement
Definition: armddk.h:52
LONG NTAPI Exi386InterlockedDecrementLong(PLONG Addend)
Definition: stubs.c:38
#define MINLONG
Definition: umtypes.h:115
#define CheckInterlockedCmpXchgI(Function, Type, Print, Val, Cmp, Xchg, ExpectedValue, ExpectedRet,...)
#define InterlockedOr
Definition: interlocked.h:224
INTERLOCKED_RESULT NTAPI ExInterlockedDecrementLong(IN PLONG Addend, IN PKSPIN_LOCK Lock)
Definition: interlocked.c:267
#define InterlockedCompareExchangeRelease
Definition: interlocked.h:106
#define InterlockedExchange
Definition: armddk.h:54
Status
Definition: gdiplustypes.h:24
LONG NTAPI Exi386InterlockedIncrementLong(PLONG Addend)
Definition: stubs.c:43
#define HIGH_LEVEL
Definition: env_spec_w32.h:703
#define InterlockedIncrement
Definition: armddk.h:53
ULONG KSPIN_LOCK
Definition: env_spec_w32.h:72
LARGE_INTEGER NTAPI ExInterlockedAddLargeInteger(IN OUT PLARGE_INTEGER Addend, IN LARGE_INTEGER Increment, IN OUT PKSPIN_LOCK Lock)
Definition: interlocked.c:62
ULONG NTAPI ExInterlockedAddUlong(IN OUT PULONG Addend, IN ULONG Increment, IN OUT PKSPIN_LOCK Lock)
Definition: interlocked.c:88
#define CheckInterlockedOpNoArg(Function, Type, Print, Val, ExpectedValue, ExpectedRet,...)
unsigned int ULONG
Definition: retypes.h:1
#define CheckInterlockedOpLargeNoRet(Function, Type, Print, Val, Op, ExpectedValue)
__declspec(__declspec() long __fastcall InterlockedIncrement(long *) dllimport)
Definition: ExInterlocked.c:11
#define InterlockedIncrementAcquire
Definition: interlocked.h:202
ULONG NTAPI ExInterlockedExchangeUlong(IN PULONG Target, IN ULONG Value, IN PKSPIN_LOCK Lock)
Definition: interlocked.c:281
#define __int64
Definition: basetyps.h:16
LONGLONG QuadPart
Definition: typedefs.h:113
#define InterlockedXor
Definition: interlocked.h:266