| // Licensed under the Apache License, Version 2.0 |
| // <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license |
| // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option. |
| // All files in the project carrying such notice may not be copied, modified, or distributed |
| // except according to those terms. |
| //! ApiSet Contract for api-ms-win-core-synch-l1 |
| use shared::basetsd::SIZE_T; |
| use shared::minwindef::{BOOL, DWORD, LPLONG, LPVOID, PBOOL, ULONG}; |
| use um::minwinbase::{ |
| LPCRITICAL_SECTION, LPSECURITY_ATTRIBUTES, PCRITICAL_SECTION, PREASON_CONTEXT, |
| }; |
| use um::winnt::{ |
| BOOLEAN, HANDLE, LARGE_INTEGER, LONG, LPCSTR, LPCWSTR, PRTL_BARRIER, PRTL_RUN_ONCE, |
| PVOID, RTL_BARRIER, RTL_CONDITION_VARIABLE, RTL_CONDITION_VARIABLE_INIT, |
| RTL_RUN_ONCE, RTL_SRWLOCK, RTL_SRWLOCK_INIT, VOID |
| }; |
| pub const SRWLOCK_INIT: SRWLOCK = RTL_SRWLOCK_INIT; |
| pub type SRWLOCK = RTL_SRWLOCK; |
| pub type PSRWLOCK = *mut RTL_SRWLOCK; |
| extern "system" { |
| pub fn InitializeSRWLock( |
| SRWLock: PSRWLOCK, |
| ); |
| pub fn ReleaseSRWLockExclusive( |
| SRWLock: PSRWLOCK, |
| ); |
| pub fn ReleaseSRWLockShared( |
| SRWLock: PSRWLOCK, |
| ); |
| pub fn AcquireSRWLockExclusive( |
| SRWLock: PSRWLOCK, |
| ); |
| pub fn AcquireSRWLockShared( |
| SRWLock: PSRWLOCK, |
| ); |
| pub fn TryAcquireSRWLockExclusive( |
| SRWLock: PSRWLOCK, |
| ) -> BOOLEAN; |
| pub fn TryAcquireSRWLockShared( |
| SRWLock: PSRWLOCK, |
| ) -> BOOLEAN; |
| pub fn InitializeCriticalSection( |
| lpCriticalSection: LPCRITICAL_SECTION, |
| ); |
| pub fn EnterCriticalSection( |
| lpCriticalSection: LPCRITICAL_SECTION, |
| ); |
| pub fn LeaveCriticalSection( |
| lpCriticalSection: LPCRITICAL_SECTION, |
| ); |
| pub fn InitializeCriticalSectionAndSpinCount( |
| lpCriticalSection: LPCRITICAL_SECTION, |
| dwSpinCount: DWORD, |
| ) -> BOOL; |
| pub fn InitializeCriticalSectionEx( |
| lpCriticalSection: LPCRITICAL_SECTION, |
| dwSpinCount: DWORD, |
| Flags: DWORD, |
| ) -> BOOL; |
| pub fn SetCriticalSectionSpinCount( |
| lpCriticalSection: LPCRITICAL_SECTION, |
| dwSpinCount: DWORD, |
| ) -> DWORD; |
| pub fn TryEnterCriticalSection( |
| lpCriticalSection: LPCRITICAL_SECTION, |
| ) -> BOOL; |
| pub fn DeleteCriticalSection( |
| lpCriticalSection: LPCRITICAL_SECTION, |
| ); |
| } |
| pub type INIT_ONCE = RTL_RUN_ONCE; |
| pub type PINIT_ONCE = PRTL_RUN_ONCE; |
| pub type LPINIT_ONCE = PRTL_RUN_ONCE; |
| //pub const INIT_ONCE_STATIC_INIT: INIT_ONCE = RTL_RUN_ONCE_INIT; |
| //pub const INIT_ONCE_CHECK_ONLY: ULONG = RTL_RUN_ONCE_CHECK_ONLY; |
| //pub const INIT_ONCE_ASYNC: ULONG = RTL_RUN_ONCE_ASYNC; |
| //pub const INIT_ONCE_INIT_FAILED: ULONG = RTL_RUN_ONCE_INIT_FAILED; |
| //pub const INIT_ONCE_CTX_RESERVED_BITS: usize = RTL_RUN_ONCE_CTX_RESERVED_BITS; |
| FN!{stdcall PINIT_ONCE_FN( |
| InitOnce: PINIT_ONCE, |
| Parameter: PVOID, |
| Context: *mut PVOID, |
| ) -> BOOL} |
| extern "system" { |
| pub fn InitOnceInitialize( |
| InitOnce: PINIT_ONCE, |
| ); |
| pub fn InitOnceExecuteOnce( |
| InitOnce: PINIT_ONCE, |
| InitFn: PINIT_ONCE_FN, |
| Parameter: PVOID, |
| Context: *mut LPVOID, |
| ) -> BOOL; |
| pub fn InitOnceBeginInitialize( |
| lpInitOnce: LPINIT_ONCE, |
| dwFlags: DWORD, |
| fPending: PBOOL, |
| lpContext: *mut LPVOID, |
| ) -> BOOL; |
| pub fn InitOnceComplete( |
| lpInitOnce: LPINIT_ONCE, |
| dwFlags: DWORD, |
| lpContext: LPVOID, |
| ) -> BOOL; |
| } |
| pub type CONDITION_VARIABLE = RTL_CONDITION_VARIABLE; |
| pub type PCONDITION_VARIABLE = *mut CONDITION_VARIABLE; |
| pub const CONDITION_VARIABLE_INIT: CONDITION_VARIABLE = RTL_CONDITION_VARIABLE_INIT; |
| //pub const CONDITION_VARIABLE_LOCKMODE_SHARED: ULONG = RTL_CONDITION_VARIABLE_LOCKMODE_SHARED; |
| extern "system" { |
| pub fn InitializeConditionVariable( |
| ConditionVariable: PCONDITION_VARIABLE, |
| ); |
| pub fn WakeConditionVariable( |
| ConditionVariable: PCONDITION_VARIABLE, |
| ); |
| pub fn WakeAllConditionVariable( |
| ConditionVariable: PCONDITION_VARIABLE, |
| ); |
| pub fn SleepConditionVariableCS( |
| ConditionVariable: PCONDITION_VARIABLE, |
| CriticalSection: PCRITICAL_SECTION, |
| dwMilliseconds: DWORD, |
| ) -> BOOL; |
| pub fn SleepConditionVariableSRW( |
| ConditionVariable: PCONDITION_VARIABLE, |
| SRWLock: PSRWLOCK, |
| dwMilliseconds: DWORD, |
| Flags: ULONG, |
| ) -> BOOL; |
| pub fn SetEvent( |
| hEvent: HANDLE, |
| ) -> BOOL; |
| pub fn ResetEvent( |
| hEvent: HANDLE, |
| ) -> BOOL; |
| pub fn ReleaseSemaphore( |
| hSemaphore: HANDLE, |
| lReleaseCount: LONG, |
| lpPreviousCount: LPLONG, |
| ) -> BOOL; |
| pub fn ReleaseMutex( |
| hMutex: HANDLE, |
| ) -> BOOL; |
| pub fn WaitForSingleObject( |
| hHandle: HANDLE, |
| dwMilliseconds: DWORD, |
| ) -> DWORD; |
| pub fn SleepEx( |
| dwMilliseconds: DWORD, |
| bAlertable: BOOL, |
| ) -> DWORD; |
| pub fn WaitForSingleObjectEx( |
| hHandle: HANDLE, |
| dwMilliseconds: DWORD, |
| bAlertable: BOOL, |
| ) -> DWORD; |
| pub fn WaitForMultipleObjectsEx( |
| nCount: DWORD, |
| lpHandles: *const HANDLE, |
| bWaitAll: BOOL, |
| dwMilliseconds: DWORD, |
| bAlertable: BOOL, |
| ) -> DWORD; |
| } |
| //pub const MUTEX_MODIFY_STATE: DWORD = MUTANT_QUERY_STATE; |
| //pub const MUTEX_ALL_ACCESS: DWORD = MUTANT_ALL_ACCESS; |
| extern "system" { |
| pub fn CreateMutexA( |
| lpMutexAttributes: LPSECURITY_ATTRIBUTES, |
| bInitialOwner: BOOL, |
| lpName: LPCSTR, |
| ) -> HANDLE; |
| pub fn CreateMutexW( |
| lpMutexAttributes: LPSECURITY_ATTRIBUTES, |
| bInitialOwner: BOOL, |
| lpName: LPCWSTR, |
| ) -> HANDLE; |
| pub fn OpenMutexW( |
| dwDesiredAccess: DWORD, |
| bInheritHandle: BOOL, |
| lpName: LPCWSTR, |
| ) -> HANDLE; |
| pub fn CreateEventA( |
| lpEventAttributes: LPSECURITY_ATTRIBUTES, |
| bManualReset: BOOL, |
| bInitialState: BOOL, |
| lpName: LPCSTR, |
| ) -> HANDLE; |
| pub fn CreateEventW( |
| lpEventAttributes: LPSECURITY_ATTRIBUTES, |
| bManualReset: BOOL, |
| bInitialState: BOOL, |
| lpName: LPCWSTR, |
| ) -> HANDLE; |
| pub fn OpenEventA( |
| dwDesiredAccess: DWORD, |
| bInheritHandle: BOOL, |
| lpName: LPCSTR, |
| ) -> HANDLE; |
| pub fn OpenEventW( |
| dwDesiredAccess: DWORD, |
| bInheritHandle: BOOL, |
| lpName: LPCWSTR, |
| ) -> HANDLE; |
| pub fn OpenSemaphoreW( |
| dwDesiredAccess: DWORD, |
| bInheritHandle: BOOL, |
| lpName: LPCWSTR, |
| ) -> HANDLE; |
| } |
| FN!{stdcall PTIMERAPCROUTINE( |
| lpArgToCompletionRoutine: LPVOID, |
| dwTimerLowValue: DWORD, |
| dwTimerHighValue: DWORD, |
| ) -> ()} |
| extern "system" { |
| pub fn OpenWaitableTimerW( |
| dwDesiredAccess: DWORD, |
| bInheritHandle: BOOL, |
| lpTimerName: LPCWSTR, |
| ) -> HANDLE; |
| pub fn SetWaitableTimerEx( |
| hTimer: HANDLE, |
| lpDueTime: *const LARGE_INTEGER, |
| lPeriod: LONG, |
| pfnCompletionRoutine: PTIMERAPCROUTINE, |
| lpArgToCompletionRoutine: LPVOID, |
| WakeContext: PREASON_CONTEXT, |
| TolerableDelay: ULONG, |
| ) -> BOOL; |
| pub fn SetWaitableTimer( |
| hTimer: HANDLE, |
| lpDueTime: *const LARGE_INTEGER, |
| lPeriod: LONG, |
| pfnCompletionRoutine: PTIMERAPCROUTINE, |
| lpArgToCompletionRoutine: LPVOID, |
| fResume: BOOL, |
| ) -> BOOL; |
| pub fn CancelWaitableTimer( |
| hTimer: HANDLE, |
| ) -> BOOL; |
| } |
| pub const CREATE_MUTEX_INITIAL_OWNER: DWORD = 0x00000001; |
| extern "system" { |
| pub fn CreateMutexExA( |
| lpMutexAttributes: LPSECURITY_ATTRIBUTES, |
| lpName: LPCSTR, |
| dwFlags: DWORD, |
| dwDesiredAccess: DWORD, |
| ) -> HANDLE; |
| pub fn CreateMutexExW( |
| lpMutexAttributes: LPSECURITY_ATTRIBUTES, |
| lpName: LPCWSTR, |
| dwFlags: DWORD, |
| dwDesiredAccess: DWORD, |
| ) -> HANDLE; |
| } |
| pub const CREATE_EVENT_MANUAL_RESET: DWORD = 0x00000001; |
| pub const CREATE_EVENT_INITIAL_SET: DWORD = 0x00000002; |
| extern "system" { |
| pub fn CreateEventExA( |
| lpEventAttributes: LPSECURITY_ATTRIBUTES, |
| lpName: LPCSTR, |
| dwFlags: DWORD, |
| dwDesiredAccess: DWORD, |
| ) -> HANDLE; |
| pub fn CreateEventExW( |
| lpEventAttributes: LPSECURITY_ATTRIBUTES, |
| lpName: LPCWSTR, |
| dwFlags: DWORD, |
| dwDesiredAccess: DWORD, |
| ) -> HANDLE; |
| pub fn CreateSemaphoreExW( |
| lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES, |
| lInitialCount: LONG, |
| lMaximumCount: LONG, |
| lpName: LPCWSTR, |
| dwFlags: DWORD, |
| dwDesiredAccess: DWORD, |
| ) -> HANDLE; |
| } |
| pub const CREATE_WAITABLE_TIMER_MANUAL_RESET: DWORD = 0x00000001; |
| extern "system" { |
| pub fn CreateWaitableTimerExW( |
| lpTimerAttributes: LPSECURITY_ATTRIBUTES, |
| lpTimerName: LPCWSTR, |
| dwFlags: DWORD, |
| dwDesiredAccess: DWORD, |
| ) -> HANDLE; |
| } |
| pub type SYNCHRONIZATION_BARRIER = RTL_BARRIER; |
| pub type PSYNCHRONIZATION_BARRIER = PRTL_BARRIER; |
| pub type LPSYNCHRONIZATION_BARRIER = PRTL_BARRIER; |
| pub const SYNCHRONIZATION_BARRIER_FLAGS_SPIN_ONLY: DWORD = 0x01; |
| pub const SYNCHRONIZATION_BARRIER_FLAGS_BLOCK_ONLY: DWORD = 0x02; |
| pub const SYNCHRONIZATION_BARRIER_FLAGS_NO_DELETE: DWORD = 0x04; |
| extern "system" { |
| pub fn EnterSynchronizationBarrier( |
| lpBarrier: LPSYNCHRONIZATION_BARRIER, |
| dwFlags: DWORD, |
| ) -> BOOL; |
| pub fn InitializeSynchronizationBarrier( |
| lpBarrier: LPSYNCHRONIZATION_BARRIER, |
| lTotalThreads: LONG, |
| lSpinCount: LONG, |
| ) -> BOOL; |
| pub fn DeleteSynchronizationBarrier( |
| lpBarrier: LPSYNCHRONIZATION_BARRIER, |
| ) -> BOOL; |
| pub fn Sleep( |
| dwMilliseconds: DWORD, |
| ); |
| pub fn WaitOnAddress( |
| Address: *mut VOID, |
| CompareAddress: PVOID, |
| AddressSize: SIZE_T, |
| dwMilliseconds: DWORD, |
| ) -> BOOL; |
| pub fn WakeByAddressSingle( |
| Address: PVOID, |
| ); |
| pub fn WakeByAddressAll( |
| Address: PVOID, |
| ); |
| pub fn SignalObjectAndWait( |
| hObjectToSignal: HANDLE, |
| hObjectToWaitOn: HANDLE, |
| dwMilliseconds: DWORD, |
| bAlertable: BOOL, |
| ) -> DWORD; |
| pub fn WaitForMultipleObjects( |
| nCount: DWORD, |
| lpHandles: *const HANDLE, |
| bWaitAll: BOOL, |
| dwMilliseconds: DWORD, |
| ) -> DWORD; |
| pub fn CreateSemaphoreW( |
| lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES, |
| lInitialCount: LONG, |
| lMaximumCount: LONG, |
| lpName: LPCWSTR, |
| ) -> HANDLE; |
| pub fn CreateWaitableTimerW( |
| lpTimerAttributes: LPSECURITY_ATTRIBUTES, |
| bManualReset: BOOL, |
| lpTimerName: LPCWSTR, |
| ) -> HANDLE; |
| } |
