FreeRDP
Loading...
Searching...
No Matches
include/winpr/synch.h
1
22#ifndef WINPR_SYNCH_H
23#define WINPR_SYNCH_H
24
25#include <stdio.h>
26#include <stdlib.h>
27#include <string.h>
28
29#include <winpr/platform.h>
30#include <winpr/winpr.h>
31#include <winpr/wtypes.h>
32#include <winpr/error.h>
33#include <winpr/handle.h>
34
35#include <winpr/nt.h>
36
37#ifdef __cplusplus
38extern "C"
39{
40#endif
41
42#ifndef _WIN32
43
44/* Mutex */
45#define CREATE_MUTEX_INITIAL_OWNER 0x00000001
46
47 WINPR_ATTR_MALLOC(CloseHandle, 1)
48 WINPR_ATTR_NODISCARD
49 WINPR_API HANDLE CreateMutexA(LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInitialOwner,
50 LPCSTR lpName);
51
52 WINPR_ATTR_MALLOC(CloseHandle, 1)
53 WINPR_ATTR_NODISCARD
54 WINPR_API HANDLE CreateMutexW(LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInitialOwner,
55 LPCWSTR lpName);
56
57 WINPR_ATTR_MALLOC(CloseHandle, 1)
58 WINPR_ATTR_NODISCARD
59 WINPR_API HANDLE CreateMutexExA(LPSECURITY_ATTRIBUTES lpMutexAttributes, LPCSTR lpName,
60 DWORD dwFlags, DWORD dwDesiredAccess);
61
62 WINPR_ATTR_MALLOC(CloseHandle, 1)
63 WINPR_ATTR_NODISCARD
64 WINPR_API HANDLE CreateMutexExW(LPSECURITY_ATTRIBUTES lpMutexAttributes, LPCWSTR lpName,
65 DWORD dwFlags, DWORD dwDesiredAccess);
66
67 WINPR_ATTR_MALLOC(CloseHandle, 1)
68 WINPR_ATTR_NODISCARD
69 WINPR_API HANDLE OpenMutexA(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpName);
70
71 WINPR_ATTR_MALLOC(CloseHandle, 1)
72 WINPR_ATTR_NODISCARD
73 WINPR_API HANDLE OpenMutexW(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpName);
74
75 WINPR_API BOOL ReleaseMutex(HANDLE hMutex);
76
77#ifdef UNICODE
78#define CreateMutex CreateMutexW
79#define CreateMutexEx CreateMutexExW
80#define OpenMutex OpenMutexW
81#else
82#define CreateMutex CreateMutexA
83#define CreateMutexEx CreateMutexExA
84#define OpenMutex OpenMutexA
85#endif
86
87 /* Semaphore */
88
89 WINPR_ATTR_MALLOC(CloseHandle, 1)
90 WINPR_ATTR_NODISCARD
91 WINPR_API HANDLE CreateSemaphoreA(LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,
92 LONG lInitialCount, LONG lMaximumCount, LPCSTR lpName);
93
94 WINPR_ATTR_MALLOC(CloseHandle, 1)
95 WINPR_ATTR_NODISCARD
96 WINPR_API HANDLE CreateSemaphoreW(LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,
97 LONG lInitialCount, LONG lMaximumCount, LPCWSTR lpName);
98
99 WINPR_ATTR_MALLOC(CloseHandle, 1)
100 WINPR_ATTR_NODISCARD
101 WINPR_API HANDLE OpenSemaphoreA(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpName);
102
103 WINPR_ATTR_MALLOC(CloseHandle, 1)
104 WINPR_ATTR_NODISCARD
105 WINPR_API HANDLE OpenSemaphoreW(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpName);
106
107#ifdef UNICODE
108#define CreateSemaphore CreateSemaphoreW
109#define OpenSemaphore OpenSemaphoreW
110#else
111#define CreateSemaphore CreateSemaphoreA
112#define OpenSemaphore OpenSemaphoreA
113#endif
114
115 WINPR_API BOOL ReleaseSemaphore(HANDLE hSemaphore, LONG lReleaseCount, LPLONG lpPreviousCount);
116
117/* Event */
118#define CREATE_EVENT_MANUAL_RESET 0x00000001
119#define CREATE_EVENT_INITIAL_SET 0x00000002
120
121 WINPR_ATTR_MALLOC(CloseHandle, 1)
122 WINPR_ATTR_NODISCARD
123 WINPR_API HANDLE CreateEventA(LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset,
124 BOOL bInitialState, LPCSTR lpName);
125
126 WINPR_ATTR_MALLOC(CloseHandle, 1)
127 WINPR_ATTR_NODISCARD
128 WINPR_API HANDLE CreateEventW(LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset,
129 BOOL bInitialState, LPCWSTR lpName);
130
131 WINPR_ATTR_MALLOC(CloseHandle, 1)
132 WINPR_ATTR_NODISCARD
133 WINPR_API HANDLE CreateEventExA(LPSECURITY_ATTRIBUTES lpEventAttributes, LPCSTR lpName,
134 DWORD dwFlags, DWORD dwDesiredAccess);
135
136 WINPR_ATTR_MALLOC(CloseHandle, 1)
137 WINPR_ATTR_NODISCARD
138 WINPR_API HANDLE CreateEventExW(LPSECURITY_ATTRIBUTES lpEventAttributes, LPCWSTR lpName,
139 DWORD dwFlags, DWORD dwDesiredAccess);
140
141 WINPR_ATTR_MALLOC(CloseHandle, 1)
142 WINPR_ATTR_NODISCARD
143 WINPR_API HANDLE OpenEventA(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpName);
144
145 WINPR_ATTR_MALLOC(CloseHandle, 1)
146 WINPR_ATTR_NODISCARD
147 WINPR_API HANDLE OpenEventW(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpName);
148
149 WINPR_API BOOL SetEvent(HANDLE hEvent);
150 WINPR_API BOOL ResetEvent(HANDLE hEvent);
151
152#if defined(WITH_DEBUG_EVENTS)
153#define DumpEventHandles() DumpEventHandles_(__func__, __FILE__, __LINE__)
154 WINPR_API void DumpEventHandles_(const char* fkt, const char* file, size_t line);
155#endif
156#ifdef UNICODE
157#define CreateEvent CreateEventW
158#define CreateEventEx CreateEventExW
159#define OpenEvent OpenEventW
160#else
161#define CreateEvent CreateEventA
162#define CreateEventEx CreateEventExA
163#define OpenEvent OpenEventA
164#endif
165
166 /* Condition Variable */
167
168 typedef PVOID RTL_CONDITION_VARIABLE;
169 typedef RTL_CONDITION_VARIABLE CONDITION_VARIABLE, *PCONDITION_VARIABLE;
170
171 /* Critical Section */
172
173 typedef struct
174 {
175 PVOID DebugInfo;
176 LONG LockCount;
177 LONG RecursionCount;
178 HANDLE OwningThread;
179 HANDLE LockSemaphore;
180 ULONG_PTR SpinCount;
181 } RTL_CRITICAL_SECTION, *PRTL_CRITICAL_SECTION;
182
183 typedef RTL_CRITICAL_SECTION CRITICAL_SECTION;
184 typedef PRTL_CRITICAL_SECTION PCRITICAL_SECTION;
185 typedef PRTL_CRITICAL_SECTION LPCRITICAL_SECTION;
186
187 WINPR_API VOID InitializeCriticalSection(LPCRITICAL_SECTION lpCriticalSection);
188 WINPR_API BOOL InitializeCriticalSectionEx(LPCRITICAL_SECTION lpCriticalSection,
189 DWORD dwSpinCount, DWORD Flags);
190 WINPR_API BOOL InitializeCriticalSectionAndSpinCount(LPCRITICAL_SECTION lpCriticalSection,
191 DWORD dwSpinCount);
192
193 WINPR_API DWORD SetCriticalSectionSpinCount(LPCRITICAL_SECTION lpCriticalSection,
194 DWORD dwSpinCount);
195
196 WINPR_API VOID EnterCriticalSection(LPCRITICAL_SECTION lpCriticalSection);
197 WINPR_API BOOL TryEnterCriticalSection(LPCRITICAL_SECTION lpCriticalSection);
198
199 WINPR_API VOID LeaveCriticalSection(LPCRITICAL_SECTION lpCriticalSection);
200
201 WINPR_API VOID DeleteCriticalSection(LPCRITICAL_SECTION lpCriticalSection);
202
203 /* Sleep */
204
205 WINPR_API VOID Sleep(DWORD dwMilliseconds);
206 WINPR_API DWORD SleepEx(DWORD dwMilliseconds, BOOL bAlertable);
207
208 /* Address */
209
210 WINPR_API VOID WakeByAddressAll(PVOID Address);
211 WINPR_API VOID WakeByAddressSingle(PVOID Address);
212
213 WINPR_API BOOL WaitOnAddress(VOID volatile* Address, PVOID CompareAddress, size_t AddressSize,
214 DWORD dwMilliseconds);
215
216 /* Wait */
217
218#define INFINITE 0xFFFFFFFFUL
219
220#define WAIT_OBJECT_0 0x00000000UL
221#define WAIT_ABANDONED 0x00000080UL
222#define WAIT_IO_COMPLETION 0x000000C0UL
223
224#ifndef WAIT_TIMEOUT
225#define WAIT_TIMEOUT 0x00000102UL
226#endif
227
228#define WAIT_FAILED 0xFFFFFFFFUL
229
230#define MAXIMUM_WAIT_OBJECTS 64
231
232 WINPR_API DWORD WaitForSingleObject(HANDLE hHandle, DWORD dwMilliseconds);
233 WINPR_API DWORD WaitForSingleObjectEx(HANDLE hHandle, DWORD dwMilliseconds, BOOL bAlertable);
234 WINPR_API DWORD WaitForMultipleObjects(DWORD nCount, const HANDLE* lpHandles, BOOL bWaitAll,
235 DWORD dwMilliseconds);
236 WINPR_API DWORD WaitForMultipleObjectsEx(DWORD nCount, const HANDLE* lpHandles, BOOL bWaitAll,
237 DWORD dwMilliseconds, BOOL bAlertable);
238
239 WINPR_API DWORD SignalObjectAndWait(HANDLE hObjectToSignal, HANDLE hObjectToWaitOn,
240 DWORD dwMilliseconds, BOOL bAlertable);
241
242 /* Waitable Timer */
243
244#define CREATE_WAITABLE_TIMER_MANUAL_RESET 0x00000001
245
246 typedef struct
247 {
248 ULONG Version;
249 DWORD Flags;
250
251 union
252 {
253 struct
254 {
255 HMODULE LocalizedReasonModule;
256 ULONG LocalizedReasonId;
257 ULONG ReasonStringCount;
258 LPWSTR* ReasonStrings;
259 } Detailed;
260
261 LPWSTR SimpleReasonString;
262 } Reason;
263 } REASON_CONTEXT, *PREASON_CONTEXT;
264
265 typedef VOID (*PTIMERAPCROUTINE)(LPVOID lpArgToCompletionRoutine, DWORD dwTimerLowValue,
266 DWORD dwTimerHighValue);
267
268 WINPR_ATTR_MALLOC(CloseHandle, 1)
269 WINPR_ATTR_NODISCARD
270 WINPR_API HANDLE CreateWaitableTimerA(LPSECURITY_ATTRIBUTES lpTimerAttributes,
271 BOOL bManualReset, LPCSTR lpTimerName);
272
273 WINPR_ATTR_MALLOC(CloseHandle, 1)
274 WINPR_ATTR_NODISCARD
275 WINPR_API HANDLE CreateWaitableTimerW(LPSECURITY_ATTRIBUTES lpTimerAttributes,
276 BOOL bManualReset, LPCWSTR lpTimerName);
277
278 WINPR_ATTR_MALLOC(CloseHandle, 1)
279 WINPR_ATTR_NODISCARD
280 WINPR_API HANDLE CreateWaitableTimerExA(LPSECURITY_ATTRIBUTES lpTimerAttributes,
281 LPCSTR lpTimerName, DWORD dwFlags,
282 DWORD dwDesiredAccess);
283
284 WINPR_ATTR_MALLOC(CloseHandle, 1)
285 WINPR_ATTR_NODISCARD
286 WINPR_API HANDLE CreateWaitableTimerExW(LPSECURITY_ATTRIBUTES lpTimerAttributes,
287 LPCWSTR lpTimerName, DWORD dwFlags,
288 DWORD dwDesiredAccess);
289
290 WINPR_API BOOL SetWaitableTimer(HANDLE hTimer, const LARGE_INTEGER* lpDueTime, LONG lPeriod,
291 PTIMERAPCROUTINE pfnCompletionRoutine,
292 LPVOID lpArgToCompletionRoutine, BOOL fResume);
293
294 WINPR_API BOOL SetWaitableTimerEx(HANDLE hTimer, const LARGE_INTEGER* lpDueTime, LONG lPeriod,
295 PTIMERAPCROUTINE pfnCompletionRoutine,
296 LPVOID lpArgToCompletionRoutine, PREASON_CONTEXT WakeContext,
297 ULONG TolerableDelay);
298
299 WINPR_ATTR_MALLOC(CloseHandle, 1)
300 WINPR_ATTR_NODISCARD
301 WINPR_API HANDLE OpenWaitableTimerA(DWORD dwDesiredAccess, BOOL bInheritHandle,
302 LPCSTR lpTimerName);
303
304 WINPR_ATTR_MALLOC(CloseHandle, 1)
305 WINPR_ATTR_NODISCARD
306 WINPR_API HANDLE OpenWaitableTimerW(DWORD dwDesiredAccess, BOOL bInheritHandle,
307 LPCWSTR lpTimerName);
308
309 WINPR_API BOOL CancelWaitableTimer(HANDLE hTimer);
310
311#ifdef UNICODE
312#define CreateWaitableTimer CreateWaitableTimerW
313#define CreateWaitableTimerEx CreateWaitableTimerExW
314#define OpenWaitableTimer OpenWaitableTimerW
315#else
316#define CreateWaitableTimer CreateWaitableTimerA
317#define CreateWaitableTimerEx CreateWaitableTimerExA
318#define OpenWaitableTimer OpenWaitableTimerA
319#endif
320
321 WINPR_API int GetTimerFileDescriptor(HANDLE hTimer);
322
327#define WT_EXECUTEDEFAULT 0x00000000
328#define WT_EXECUTEINIOTHREAD 0x00000001
329#define WT_EXECUTEINUITHREAD 0x00000002
330#define WT_EXECUTEINWAITTHREAD 0x00000004
331#define WT_EXECUTEONLYONCE 0x00000008
332#define WT_EXECUTELONGFUNCTION 0x00000010
333#define WT_EXECUTEINTIMERTHREAD 0x00000020
334#define WT_EXECUTEINPERSISTENTIOTHREAD 0x00000040
335#define WT_EXECUTEINPERSISTENTTHREAD 0x00000080
336#define WT_TRANSFER_IMPERSONATION 0x00000100
337
338 typedef VOID (*WAITORTIMERCALLBACK)(PVOID lpParameter, BOOLEAN TimerOrWaitFired);
339
340 WINPR_ATTR_MALLOC(CloseHandle, 1)
341 WINPR_ATTR_NODISCARD
342 WINPR_API HANDLE CreateTimerQueue(void);
343
344 WINPR_API BOOL DeleteTimerQueue(HANDLE TimerQueue);
345 WINPR_API BOOL DeleteTimerQueueEx(HANDLE TimerQueue, HANDLE CompletionEvent);
346
347 WINPR_API BOOL CreateTimerQueueTimer(HANDLE* phNewTimer, HANDLE TimerQueue,
348 WAITORTIMERCALLBACK Callback, void* Parameter,
349 DWORD DueTime, DWORD Period, ULONG Flags);
350 WINPR_API BOOL ChangeTimerQueueTimer(HANDLE TimerQueue, HANDLE Timer, ULONG DueTime,
351 ULONG Period);
352 WINPR_API BOOL DeleteTimerQueueTimer(HANDLE TimerQueue, HANDLE Timer, HANDLE CompletionEvent);
353
354#endif
355
356#if (defined(_WIN32) && (_WIN32_WINNT < 0x0600))
357#define InitializeCriticalSectionEx(lpCriticalSection, dwSpinCount, Flags) \
358 InitializeCriticalSectionAndSpinCount(lpCriticalSection, dwSpinCount)
359#endif
360
361 WINPR_PRAGMA_DIAG_PUSH
362 WINPR_PRAGMA_DIAG_IGNORED_RESERVED_ID_MACRO
363
364#ifndef _RTL_RUN_ONCE_DEF
365// NOLINTNEXTLINE(bugprone-reserved-identifier,cert-dcl37-c,cert-dcl51-cpp)
366#define _RTL_RUN_ONCE_DEF
367
368 WINPR_PRAGMA_DIAG_POP
369
370#define RTL_RUN_ONCE_INIT \
371 { \
372 0 \
373 }
374
375#define RTL_RUN_ONCE_CHECK_ONLY 0x00000001
376#define RTL_RUN_ONCE_ASYNC 0x00000002
377#define RTL_RUN_ONCE_INIT_FAILED 0x00000004
378
379#define RTL_RUN_ONCE_CTX_RESERVED_BITS 2
380
381 typedef struct
382 {
383 PVOID Ptr;
384 } RTL_RUN_ONCE, *PRTL_RUN_ONCE;
385
386 typedef ULONG CALLBACK RTL_RUN_ONCE_INIT_FN(PRTL_RUN_ONCE RunOnce, PVOID Parameter,
387 PVOID* Context);
388 typedef RTL_RUN_ONCE_INIT_FN* PRTL_RUN_ONCE_INIT_FN;
389
390#endif
391
392#if (!defined(_WIN32)) || (defined(_WIN32) && (_WIN32_WINNT < 0x0600))
393
394 /* One-Time Initialization */
395
396#define INIT_ONCE_STATIC_INIT RTL_RUN_ONCE_INIT
397
398 typedef RTL_RUN_ONCE INIT_ONCE;
399 typedef PRTL_RUN_ONCE PINIT_ONCE;
400 typedef PRTL_RUN_ONCE LPINIT_ONCE;
401 typedef BOOL(CALLBACK* PINIT_ONCE_FN)(PINIT_ONCE InitOnce, PVOID Parameter, PVOID* Context);
402
403 WINPR_API BOOL winpr_InitOnceBeginInitialize(LPINIT_ONCE lpInitOnce, DWORD dwFlags,
404 PBOOL fPending, LPVOID* lpContext);
405 WINPR_API BOOL winpr_InitOnceComplete(LPINIT_ONCE lpInitOnce, DWORD dwFlags, LPVOID lpContext);
406 WINPR_API BOOL winpr_InitOnceExecuteOnce(PINIT_ONCE InitOnce, PINIT_ONCE_FN InitFn,
407 PVOID Parameter, LPVOID* Context);
408 WINPR_API VOID winpr_InitOnceInitialize(PINIT_ONCE InitOnce);
409
410#define InitOnceBeginInitialize winpr_InitOnceBeginInitialize
411#define InitOnceComplete winpr_InitOnceComplete
412#define InitOnceExecuteOnce winpr_InitOnceExecuteOnce
413#define InitOnceInitialize winpr_InitOnceInitialize
414#endif
415
416 /* Synchronization Barrier */
417
418#if (!defined(_WIN32)) || (defined(_WIN32) && (_WIN32_WINNT < 0x0602) && !defined(_SYNCHAPI_H_))
419#define WINPR_SYNCHRONIZATION_BARRIER 1
420#endif
421
422#ifdef WINPR_SYNCHRONIZATION_BARRIER
423
424 typedef struct
425 {
426 DWORD Reserved1;
427 DWORD Reserved2;
428 ULONG_PTR Reserved3[2];
429 DWORD Reserved4;
430 DWORD Reserved5;
431 } RTL_BARRIER, *PRTL_BARRIER;
432
433 typedef RTL_BARRIER SYNCHRONIZATION_BARRIER;
434 typedef PRTL_BARRIER PSYNCHRONIZATION_BARRIER;
435 typedef PRTL_BARRIER LPSYNCHRONIZATION_BARRIER;
436
437#define SYNCHRONIZATION_BARRIER_FLAGS_SPIN_ONLY 0x01
438#define SYNCHRONIZATION_BARRIER_FLAGS_BLOCK_ONLY 0x02
439#define SYNCHRONIZATION_BARRIER_FLAGS_NO_DELETE 0x04
440
441 WINPR_API BOOL WINAPI winpr_InitializeSynchronizationBarrier(
442 LPSYNCHRONIZATION_BARRIER lpBarrier, LONG lTotalThreads, LONG lSpinCount);
443 WINPR_API BOOL WINAPI winpr_EnterSynchronizationBarrier(LPSYNCHRONIZATION_BARRIER lpBarrier,
444 DWORD dwFlags);
445 WINPR_API BOOL WINAPI winpr_DeleteSynchronizationBarrier(LPSYNCHRONIZATION_BARRIER lpBarrier);
446
447#define InitializeSynchronizationBarrier winpr_InitializeSynchronizationBarrier
448#define EnterSynchronizationBarrier winpr_EnterSynchronizationBarrier
449#define DeleteSynchronizationBarrier winpr_DeleteSynchronizationBarrier
450
451#endif
452
453 /* Extended API */
454
455 WINPR_API VOID USleep(DWORD dwMicroseconds);
456
457 WINPR_ATTR_MALLOC(CloseHandle, 1)
458 WINPR_ATTR_NODISCARD
459 WINPR_API HANDLE CreateFileDescriptorEventW(LPSECURITY_ATTRIBUTES lpEventAttributes,
460 BOOL bManualReset, BOOL bInitialState,
461 int FileDescriptor, ULONG mode);
462
463 WINPR_ATTR_MALLOC(CloseHandle, 1)
464 WINPR_ATTR_NODISCARD
465 WINPR_API HANDLE CreateFileDescriptorEventA(LPSECURITY_ATTRIBUTES lpEventAttributes,
466 BOOL bManualReset, BOOL bInitialState,
467 int FileDescriptor, ULONG mode);
468
469 WINPR_ATTR_MALLOC(CloseHandle, 1)
470 WINPR_ATTR_NODISCARD
471 WINPR_API HANDLE CreateWaitObjectEvent(LPSECURITY_ATTRIBUTES lpEventAttributes,
472 BOOL bManualReset, BOOL bInitialState, void* pObject);
473
474#ifdef UNICODE
475#define CreateFileDescriptorEvent CreateFileDescriptorEventW
476#else
477#define CreateFileDescriptorEvent CreateFileDescriptorEventA
478#endif
479
480 WINPR_API int GetEventFileDescriptor(HANDLE hEvent);
481 WINPR_API int SetEventFileDescriptor(HANDLE hEvent, int FileDescriptor, ULONG mode);
482
483 WINPR_API void* GetEventWaitObject(HANDLE hEvent);
484
485#ifdef __cplusplus
486}
487#endif
488
489#endif /* WINPR_SYNCH_H */
REASON_CONTEXT
Definition include/winpr/synch.h:247
RTL_BARRIER
Definition include/winpr/synch.h:425
RTL_CRITICAL_SECTION
Definition include/winpr/synch.h:174
RTL_RUN_ONCE
Definition include/winpr/synch.h:382
LARGE_INTEGER
Definition wtypes.h:309