1 // Copyright © 2015-2017 winapi-rs developers 2 // Licensed under the Apache License, Version 2.0 3 // <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license 4 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option. 5 // All files in the project carrying such notice may not be copied, modified, or distributed 6 // except according to those terms. 7 //! ApiSet Contract for api-ms-win-core-synch-l1 8 use shared::basetsd::SIZE_T; 9 use shared::minwindef::{BOOL, DWORD, LPLONG, LPVOID, PBOOL, ULONG}; 10 use um::minwinbase::{ 11 LPCRITICAL_SECTION, LPSECURITY_ATTRIBUTES, PCRITICAL_SECTION, PREASON_CONTEXT, 12 }; 13 use um::winnt::{ 14 BOOLEAN, HANDLE, LARGE_INTEGER, LONG, LPCSTR, LPCWSTR, PRTL_BARRIER, PRTL_RUN_ONCE, 15 PVOID, RTL_BARRIER, RTL_CONDITION_VARIABLE, RTL_CONDITION_VARIABLE_INIT, 16 RTL_RUN_ONCE, RTL_SRWLOCK, RTL_SRWLOCK_INIT, VOID 17 }; 18 pub const SRWLOCK_INIT: SRWLOCK = RTL_SRWLOCK_INIT; 19 pub type SRWLOCK = RTL_SRWLOCK; 20 pub type PSRWLOCK = *mut RTL_SRWLOCK; 21 extern "system" { InitializeSRWLock( SRWLock: PSRWLOCK, )22 pub fn InitializeSRWLock( 23 SRWLock: PSRWLOCK, 24 ); ReleaseSRWLockExclusive( SRWLock: PSRWLOCK, )25 pub fn ReleaseSRWLockExclusive( 26 SRWLock: PSRWLOCK, 27 ); ReleaseSRWLockShared( SRWLock: PSRWLOCK, )28 pub fn ReleaseSRWLockShared( 29 SRWLock: PSRWLOCK, 30 ); AcquireSRWLockExclusive( SRWLock: PSRWLOCK, )31 pub fn AcquireSRWLockExclusive( 32 SRWLock: PSRWLOCK, 33 ); AcquireSRWLockShared( SRWLock: PSRWLOCK, )34 pub fn AcquireSRWLockShared( 35 SRWLock: PSRWLOCK, 36 ); TryAcquireSRWLockExclusive( SRWLock: PSRWLOCK, ) -> BOOLEAN37 pub fn TryAcquireSRWLockExclusive( 38 SRWLock: PSRWLOCK, 39 ) -> BOOLEAN; TryAcquireSRWLockShared( SRWLock: PSRWLOCK, ) -> BOOLEAN40 pub fn TryAcquireSRWLockShared( 41 SRWLock: PSRWLOCK, 42 ) -> BOOLEAN; InitializeCriticalSection( lpCriticalSection: LPCRITICAL_SECTION, )43 pub fn InitializeCriticalSection( 44 lpCriticalSection: LPCRITICAL_SECTION, 45 ); EnterCriticalSection( lpCriticalSection: LPCRITICAL_SECTION, )46 pub fn EnterCriticalSection( 47 lpCriticalSection: LPCRITICAL_SECTION, 48 ); LeaveCriticalSection( lpCriticalSection: LPCRITICAL_SECTION, )49 pub fn LeaveCriticalSection( 50 lpCriticalSection: LPCRITICAL_SECTION, 51 ); InitializeCriticalSectionAndSpinCount( lpCriticalSection: LPCRITICAL_SECTION, dwSpinCount: DWORD, ) -> BOOL52 pub fn InitializeCriticalSectionAndSpinCount( 53 lpCriticalSection: LPCRITICAL_SECTION, 54 dwSpinCount: DWORD, 55 ) -> BOOL; InitializeCriticalSectionEx( lpCriticalSection: LPCRITICAL_SECTION, dwSpinCount: DWORD, Flags: DWORD, ) -> BOOL56 pub fn InitializeCriticalSectionEx( 57 lpCriticalSection: LPCRITICAL_SECTION, 58 dwSpinCount: DWORD, 59 Flags: DWORD, 60 ) -> BOOL; SetCriticalSectionSpinCount( lpCriticalSection: LPCRITICAL_SECTION, dwSpinCount: DWORD, ) -> DWORD61 pub fn SetCriticalSectionSpinCount( 62 lpCriticalSection: LPCRITICAL_SECTION, 63 dwSpinCount: DWORD, 64 ) -> DWORD; TryEnterCriticalSection( lpCriticalSection: LPCRITICAL_SECTION, ) -> BOOL65 pub fn TryEnterCriticalSection( 66 lpCriticalSection: LPCRITICAL_SECTION, 67 ) -> BOOL; DeleteCriticalSection( lpCriticalSection: LPCRITICAL_SECTION, )68 pub fn DeleteCriticalSection( 69 lpCriticalSection: LPCRITICAL_SECTION, 70 ); 71 } 72 pub type INIT_ONCE = RTL_RUN_ONCE; 73 pub type PINIT_ONCE = PRTL_RUN_ONCE; 74 pub type LPINIT_ONCE = PRTL_RUN_ONCE; 75 //pub const INIT_ONCE_STATIC_INIT: INIT_ONCE = RTL_RUN_ONCE_INIT; 76 //pub const INIT_ONCE_CHECK_ONLY: ULONG = RTL_RUN_ONCE_CHECK_ONLY; 77 //pub const INIT_ONCE_ASYNC: ULONG = RTL_RUN_ONCE_ASYNC; 78 //pub const INIT_ONCE_INIT_FAILED: ULONG = RTL_RUN_ONCE_INIT_FAILED; 79 //pub const INIT_ONCE_CTX_RESERVED_BITS: usize = RTL_RUN_ONCE_CTX_RESERVED_BITS; 80 FN!{stdcall PINIT_ONCE_FN( 81 InitOnce: PINIT_ONCE, 82 Parameter: PVOID, 83 Context: *mut PVOID, 84 ) -> BOOL} 85 extern "system" { InitOnceInitialize( InitOnce: PINIT_ONCE, )86 pub fn InitOnceInitialize( 87 InitOnce: PINIT_ONCE, 88 ); InitOnceExecuteOnce( InitOnce: PINIT_ONCE, InitFn: PINIT_ONCE_FN, Parameter: PVOID, Context: *mut LPVOID, ) -> BOOL89 pub fn InitOnceExecuteOnce( 90 InitOnce: PINIT_ONCE, 91 InitFn: PINIT_ONCE_FN, 92 Parameter: PVOID, 93 Context: *mut LPVOID, 94 ) -> BOOL; InitOnceBeginInitialize( lpInitOnce: LPINIT_ONCE, dwFlags: DWORD, fPending: PBOOL, lpContext: *mut LPVOID, ) -> BOOL95 pub fn InitOnceBeginInitialize( 96 lpInitOnce: LPINIT_ONCE, 97 dwFlags: DWORD, 98 fPending: PBOOL, 99 lpContext: *mut LPVOID, 100 ) -> BOOL; InitOnceComplete( lpInitOnce: LPINIT_ONCE, dwFlags: DWORD, lpContext: LPVOID, ) -> BOOL101 pub fn InitOnceComplete( 102 lpInitOnce: LPINIT_ONCE, 103 dwFlags: DWORD, 104 lpContext: LPVOID, 105 ) -> BOOL; 106 } 107 pub type CONDITION_VARIABLE = RTL_CONDITION_VARIABLE; 108 pub type PCONDITION_VARIABLE = *mut CONDITION_VARIABLE; 109 pub const CONDITION_VARIABLE_INIT: CONDITION_VARIABLE = RTL_CONDITION_VARIABLE_INIT; 110 //pub const CONDITION_VARIABLE_LOCKMODE_SHARED: ULONG = RTL_CONDITION_VARIABLE_LOCKMODE_SHARED; 111 extern "system" { InitializeConditionVariable( ConditionVariable: PCONDITION_VARIABLE, )112 pub fn InitializeConditionVariable( 113 ConditionVariable: PCONDITION_VARIABLE, 114 ); WakeConditionVariable( ConditionVariable: PCONDITION_VARIABLE, )115 pub fn WakeConditionVariable( 116 ConditionVariable: PCONDITION_VARIABLE, 117 ); WakeAllConditionVariable( ConditionVariable: PCONDITION_VARIABLE, )118 pub fn WakeAllConditionVariable( 119 ConditionVariable: PCONDITION_VARIABLE, 120 ); SleepConditionVariableCS( ConditionVariable: PCONDITION_VARIABLE, CriticalSection: PCRITICAL_SECTION, dwMilliseconds: DWORD, ) -> BOOL121 pub fn SleepConditionVariableCS( 122 ConditionVariable: PCONDITION_VARIABLE, 123 CriticalSection: PCRITICAL_SECTION, 124 dwMilliseconds: DWORD, 125 ) -> BOOL; SleepConditionVariableSRW( ConditionVariable: PCONDITION_VARIABLE, SRWLock: PSRWLOCK, dwMilliseconds: DWORD, Flags: ULONG, ) -> BOOL126 pub fn SleepConditionVariableSRW( 127 ConditionVariable: PCONDITION_VARIABLE, 128 SRWLock: PSRWLOCK, 129 dwMilliseconds: DWORD, 130 Flags: ULONG, 131 ) -> BOOL; SetEvent( hEvent: HANDLE, ) -> BOOL132 pub fn SetEvent( 133 hEvent: HANDLE, 134 ) -> BOOL; ResetEvent( hEvent: HANDLE, ) -> BOOL135 pub fn ResetEvent( 136 hEvent: HANDLE, 137 ) -> BOOL; ReleaseSemaphore( hSemaphore: HANDLE, lReleaseCount: LONG, lpPreviousCount: LPLONG, ) -> BOOL138 pub fn ReleaseSemaphore( 139 hSemaphore: HANDLE, 140 lReleaseCount: LONG, 141 lpPreviousCount: LPLONG, 142 ) -> BOOL; ReleaseMutex( hMutex: HANDLE, ) -> BOOL143 pub fn ReleaseMutex( 144 hMutex: HANDLE, 145 ) -> BOOL; WaitForSingleObject( hHandle: HANDLE, dwMilliseconds: DWORD, ) -> DWORD146 pub fn WaitForSingleObject( 147 hHandle: HANDLE, 148 dwMilliseconds: DWORD, 149 ) -> DWORD; SleepEx( dwMilliseconds: DWORD, bAlertable: BOOL, ) -> DWORD150 pub fn SleepEx( 151 dwMilliseconds: DWORD, 152 bAlertable: BOOL, 153 ) -> DWORD; WaitForSingleObjectEx( hHandle: HANDLE, dwMilliseconds: DWORD, bAlertable: BOOL, ) -> DWORD154 pub fn WaitForSingleObjectEx( 155 hHandle: HANDLE, 156 dwMilliseconds: DWORD, 157 bAlertable: BOOL, 158 ) -> DWORD; WaitForMultipleObjectsEx( nCount: DWORD, lpHandles: *const HANDLE, bWaitAll: BOOL, dwMilliseconds: DWORD, bAlertable: BOOL, ) -> DWORD159 pub fn WaitForMultipleObjectsEx( 160 nCount: DWORD, 161 lpHandles: *const HANDLE, 162 bWaitAll: BOOL, 163 dwMilliseconds: DWORD, 164 bAlertable: BOOL, 165 ) -> DWORD; 166 } 167 //pub const MUTEX_MODIFY_STATE: DWORD = MUTANT_QUERY_STATE; 168 //pub const MUTEX_ALL_ACCESS: DWORD = MUTANT_ALL_ACCESS; 169 extern "system" { CreateMutexA( lpMutexAttributes: LPSECURITY_ATTRIBUTES, bInitialOwner: BOOL, lpName: LPCSTR, ) -> HANDLE170 pub fn CreateMutexA( 171 lpMutexAttributes: LPSECURITY_ATTRIBUTES, 172 bInitialOwner: BOOL, 173 lpName: LPCSTR, 174 ) -> HANDLE; CreateMutexW( lpMutexAttributes: LPSECURITY_ATTRIBUTES, bInitialOwner: BOOL, lpName: LPCWSTR, ) -> HANDLE175 pub fn CreateMutexW( 176 lpMutexAttributes: LPSECURITY_ATTRIBUTES, 177 bInitialOwner: BOOL, 178 lpName: LPCWSTR, 179 ) -> HANDLE; OpenMutexW( dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCWSTR, ) -> HANDLE180 pub fn OpenMutexW( 181 dwDesiredAccess: DWORD, 182 bInheritHandle: BOOL, 183 lpName: LPCWSTR, 184 ) -> HANDLE; CreateEventA( lpEventAttributes: LPSECURITY_ATTRIBUTES, bManualReset: BOOL, bInitialState: BOOL, lpName: LPCSTR, ) -> HANDLE185 pub fn CreateEventA( 186 lpEventAttributes: LPSECURITY_ATTRIBUTES, 187 bManualReset: BOOL, 188 bInitialState: BOOL, 189 lpName: LPCSTR, 190 ) -> HANDLE; CreateEventW( lpEventAttributes: LPSECURITY_ATTRIBUTES, bManualReset: BOOL, bInitialState: BOOL, lpName: LPCWSTR, ) -> HANDLE191 pub fn CreateEventW( 192 lpEventAttributes: LPSECURITY_ATTRIBUTES, 193 bManualReset: BOOL, 194 bInitialState: BOOL, 195 lpName: LPCWSTR, 196 ) -> HANDLE; OpenEventA( dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCSTR, ) -> HANDLE197 pub fn OpenEventA( 198 dwDesiredAccess: DWORD, 199 bInheritHandle: BOOL, 200 lpName: LPCSTR, 201 ) -> HANDLE; OpenEventW( dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCWSTR, ) -> HANDLE202 pub fn OpenEventW( 203 dwDesiredAccess: DWORD, 204 bInheritHandle: BOOL, 205 lpName: LPCWSTR, 206 ) -> HANDLE; OpenSemaphoreW( dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCWSTR, ) -> HANDLE207 pub fn OpenSemaphoreW( 208 dwDesiredAccess: DWORD, 209 bInheritHandle: BOOL, 210 lpName: LPCWSTR, 211 ) -> HANDLE; 212 } 213 FN!{stdcall PTIMERAPCROUTINE( 214 lpArgToCompletionRoutine: LPVOID, 215 dwTimerLowValue: DWORD, 216 dwTimerHighValue: DWORD, 217 ) -> ()} 218 extern "system" { OpenWaitableTimerW( dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpTimerName: LPCWSTR, ) -> HANDLE219 pub fn OpenWaitableTimerW( 220 dwDesiredAccess: DWORD, 221 bInheritHandle: BOOL, 222 lpTimerName: LPCWSTR, 223 ) -> HANDLE; SetWaitableTimerEx( hTimer: HANDLE, lpDueTime: *const LARGE_INTEGER, lPeriod: LONG, pfnCompletionRoutine: PTIMERAPCROUTINE, lpArgToCompletionRoutine: LPVOID, WakeContext: PREASON_CONTEXT, TolerableDelay: ULONG, ) -> BOOL224 pub fn SetWaitableTimerEx( 225 hTimer: HANDLE, 226 lpDueTime: *const LARGE_INTEGER, 227 lPeriod: LONG, 228 pfnCompletionRoutine: PTIMERAPCROUTINE, 229 lpArgToCompletionRoutine: LPVOID, 230 WakeContext: PREASON_CONTEXT, 231 TolerableDelay: ULONG, 232 ) -> BOOL; SetWaitableTimer( hTimer: HANDLE, lpDueTime: *const LARGE_INTEGER, lPeriod: LONG, pfnCompletionRoutine: PTIMERAPCROUTINE, lpArgToCompletionRoutine: LPVOID, fResume: BOOL, ) -> BOOL233 pub fn SetWaitableTimer( 234 hTimer: HANDLE, 235 lpDueTime: *const LARGE_INTEGER, 236 lPeriod: LONG, 237 pfnCompletionRoutine: PTIMERAPCROUTINE, 238 lpArgToCompletionRoutine: LPVOID, 239 fResume: BOOL, 240 ) -> BOOL; CancelWaitableTimer( hTimer: HANDLE ) -> BOOL241 pub fn CancelWaitableTimer( 242 hTimer: HANDLE 243 ) -> BOOL; 244 } 245 pub const CREATE_MUTEX_INITIAL_OWNER: DWORD = 0x00000001; 246 extern "system" { CreateMutexExA( lpMutexAttributes: LPSECURITY_ATTRIBUTES, lpName: LPCSTR, dwFlags: DWORD, dwDesiredAccess: DWORD, ) -> HANDLE247 pub fn CreateMutexExA( 248 lpMutexAttributes: LPSECURITY_ATTRIBUTES, 249 lpName: LPCSTR, 250 dwFlags: DWORD, 251 dwDesiredAccess: DWORD, 252 ) -> HANDLE; CreateMutexExW( lpMutexAttributes: LPSECURITY_ATTRIBUTES, lpName: LPCWSTR, dwFlags: DWORD, dwDesiredAccess: DWORD, ) -> HANDLE253 pub fn CreateMutexExW( 254 lpMutexAttributes: LPSECURITY_ATTRIBUTES, 255 lpName: LPCWSTR, 256 dwFlags: DWORD, 257 dwDesiredAccess: DWORD, 258 ) -> HANDLE; 259 } 260 pub const CREATE_EVENT_MANUAL_RESET: DWORD = 0x00000001; 261 pub const CREATE_EVENT_INITIAL_SET: DWORD = 0x00000002; 262 extern "system" { CreateEventExA( lpEventAttributes: LPSECURITY_ATTRIBUTES, lpName: LPCSTR, dwFlags: DWORD, dwDesiredAccess: DWORD, ) -> HANDLE263 pub fn CreateEventExA( 264 lpEventAttributes: LPSECURITY_ATTRIBUTES, 265 lpName: LPCSTR, 266 dwFlags: DWORD, 267 dwDesiredAccess: DWORD, 268 ) -> HANDLE; CreateEventExW( lpEventAttributes: LPSECURITY_ATTRIBUTES, lpName: LPCWSTR, dwFlags: DWORD, dwDesiredAccess: DWORD, ) -> HANDLE269 pub fn CreateEventExW( 270 lpEventAttributes: LPSECURITY_ATTRIBUTES, 271 lpName: LPCWSTR, 272 dwFlags: DWORD, 273 dwDesiredAccess: DWORD, 274 ) -> HANDLE; CreateSemaphoreExW( lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES, lInitialCount: LONG, lMaximumCount: LONG, lpName: LPCWSTR, dwFlags: DWORD, dwDesiredAccess: DWORD, ) -> HANDLE275 pub fn CreateSemaphoreExW( 276 lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES, 277 lInitialCount: LONG, 278 lMaximumCount: LONG, 279 lpName: LPCWSTR, 280 dwFlags: DWORD, 281 dwDesiredAccess: DWORD, 282 ) -> HANDLE; 283 } 284 pub const CREATE_WAITABLE_TIMER_MANUAL_RESET: DWORD = 0x00000001; 285 extern "system" { CreateWaitableTimerExW( lpTimerAttributes: LPSECURITY_ATTRIBUTES, lpTimerName: LPCWSTR, dwFlags: DWORD, dwDesiredAccess: DWORD, ) -> HANDLE286 pub fn CreateWaitableTimerExW( 287 lpTimerAttributes: LPSECURITY_ATTRIBUTES, 288 lpTimerName: LPCWSTR, 289 dwFlags: DWORD, 290 dwDesiredAccess: DWORD, 291 ) -> HANDLE; 292 } 293 pub type SYNCHRONIZATION_BARRIER = RTL_BARRIER; 294 pub type PSYNCHRONIZATION_BARRIER = PRTL_BARRIER; 295 pub type LPSYNCHRONIZATION_BARRIER = PRTL_BARRIER; 296 pub const SYNCHRONIZATION_BARRIER_FLAGS_SPIN_ONLY: DWORD = 0x01; 297 pub const SYNCHRONIZATION_BARRIER_FLAGS_BLOCK_ONLY: DWORD = 0x02; 298 pub const SYNCHRONIZATION_BARRIER_FLAGS_NO_DELETE: DWORD = 0x04; 299 extern "system" { EnterSynchronizationBarrier( lpBarrier: LPSYNCHRONIZATION_BARRIER, dwFlags: DWORD, ) -> BOOL300 pub fn EnterSynchronizationBarrier( 301 lpBarrier: LPSYNCHRONIZATION_BARRIER, 302 dwFlags: DWORD, 303 ) -> BOOL; InitializeSynchronizationBarrier( lpBarrier: LPSYNCHRONIZATION_BARRIER, lTotalThreads: LONG, lSpinCount: LONG, ) -> BOOL304 pub fn InitializeSynchronizationBarrier( 305 lpBarrier: LPSYNCHRONIZATION_BARRIER, 306 lTotalThreads: LONG, 307 lSpinCount: LONG, 308 ) -> BOOL; DeleteSynchronizationBarrier( lpBarrier: LPSYNCHRONIZATION_BARRIER, ) -> BOOL309 pub fn DeleteSynchronizationBarrier( 310 lpBarrier: LPSYNCHRONIZATION_BARRIER, 311 ) -> BOOL; Sleep( dwMilliseconds: DWORD, )312 pub fn Sleep( 313 dwMilliseconds: DWORD, 314 ); WaitOnAddress( Address: *mut VOID, CompareAddress: PVOID, AddressSize: SIZE_T, dwMilliseconds: DWORD, ) -> BOOL315 pub fn WaitOnAddress( 316 Address: *mut VOID, 317 CompareAddress: PVOID, 318 AddressSize: SIZE_T, 319 dwMilliseconds: DWORD, 320 ) -> BOOL; WakeByAddressSingle( Address: PVOID, )321 pub fn WakeByAddressSingle( 322 Address: PVOID, 323 ); WakeByAddressAll( Address: PVOID, )324 pub fn WakeByAddressAll( 325 Address: PVOID, 326 ); SignalObjectAndWait( hObjectToSignal: HANDLE, hObjectToWaitOn: HANDLE, dwMilliseconds: DWORD, bAlertable: BOOL, ) -> DWORD327 pub fn SignalObjectAndWait( 328 hObjectToSignal: HANDLE, 329 hObjectToWaitOn: HANDLE, 330 dwMilliseconds: DWORD, 331 bAlertable: BOOL, 332 ) -> DWORD; WaitForMultipleObjects( nCount: DWORD, lpHandles: *const HANDLE, bWaitAll: BOOL, dwMilliseconds: DWORD, ) -> DWORD333 pub fn WaitForMultipleObjects( 334 nCount: DWORD, 335 lpHandles: *const HANDLE, 336 bWaitAll: BOOL, 337 dwMilliseconds: DWORD, 338 ) -> DWORD; CreateSemaphoreW( lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES, lInitialCount: LONG, lMaximumCount: LONG, lpName: LPCWSTR, ) -> HANDLE339 pub fn CreateSemaphoreW( 340 lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES, 341 lInitialCount: LONG, 342 lMaximumCount: LONG, 343 lpName: LPCWSTR, 344 ) -> HANDLE; CreateWaitableTimerW( lpTimerAttributes: LPSECURITY_ATTRIBUTES, bManualReset: BOOL, lpTimerName: LPCWSTR, ) -> HANDLE345 pub fn CreateWaitableTimerW( 346 lpTimerAttributes: LPSECURITY_ATTRIBUTES, 347 bManualReset: BOOL, 348 lpTimerName: LPCWSTR, 349 ) -> HANDLE; 350 } 351