drace.ini

; DRace, a dynamic data race detector
; 
; Copyright (c) Siemens AG, 2018
; 
; Authors:
;   Felix Moessbauer <felix.moessbauer@siemens.com>
; 
; This work is licensed under the terms of the MIT license.  See
; the LICENSE file in the top-level directory.
; 

; function names for windows
[sync]
; exclusive mutex lock

; Winbase.h;
acquire_excl=GlobalLock ; Lock on a memory location, TODO: Validate
release_excl=GlobalUnlock

; Internal implementation of C++ Mutexes on windows
; TODO: Validate
acquire_excl=_Mtx_lock
acquire_excl_try=_Mtx_trylock
release_excl=_Mtx_unlock

; Synchapi.h 
wait_for_single_object=waitForSingleObject
wait_for_single_object=waitForSingleObjectEx
wait_for_multiple_objects=waitForMultipleObjects
wait_for_multiple_objects=waitForMultipleObjectsEx

; The Msg variants currently deadlock
wait_for_multiple_objects=MsgWaitForMultipleObjects
wait_for_multiple_objects=MsgWaitForMultipleObjectsEx
release_excl=ReleaseMutex

acquire_rec=EnterCriticalSection
acquire_rec_try=TryEnterCriticalSection
release_rec=LeaveCriticalSection

acquire_excl=AcquireSRWLockExclusive ; Slim Reader/Writer Locks Exclusive Mode
acquire_excl_try=TryAcquireSRWLockShared
release_excl=ReleaseSRWLockExclusive ; exclusive mutex unlock
acquire_shared=AcquireSRWLockShared  ; Reader/Writer lock
acquire_shared_try=TryAcquireSRWLockExclusive
release_shared=ReleaseSRWLockShared  ; Reader/Writer lock

; drace_annotation.h
happens_before=__drace_happens_before
happens_after=__drace_happens_after

[stdsync]
acquire_excl=std::mutex::lock
acquire_excl_try=std::mutex::try_lock
release_excl=std::mutex::unlock

acquire_excl=WaitOne
release_excl=ReleaseMutex

[qtsync]
; Qt Mutexes
;acquire_excl=QMutex::lock
;acquire_excl_try=QMutex::tryLock
;acquire_excl_try=QMutex::try_lock
;acquire_excl_try=QMutex::try_lock_for
;acquire_excl_try=QMutex::try_lock_until
;
;; RW locks in W Mode
;acquire_excl=QReadWriteLock::lockForWrite
;acquire_excl_try=QReadWriteLock::tryLockForWrite
;
;acquire_shared=QReadWriteLock::lockForRead
;acquire_shared_try=QReadWriteLock::tryLockForRead
;
;
;release_excl=QMutex::unlock
;release_excl=QReadWriteLock::unlock


[functions]
allocators=HeapAlloc
reallocators=HeapReAlloc
deallocators=HeapFree

; This function return is synchronized with the begin of a new tread
; \ref Multicore Software, p.230
; TODO: Lookup item in C++ std
thread_starters=std::thread::thread<*>
thread_starters_sys=CreateThread

; annotated excludes
exclude_enter=__drace_enter_exclude
exclude_leave=__drace_leave_exclude

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;; QT STUFF ;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

; exclude all QT mutexes as they are more "high-level" than native mutexes
; This means that no races inside the mutex functions are reported.
; The mutex events itself are not affected
;exclude=QMutex::*
;exclude=QReadWriteLock::*
;
;; Locking between processes, assume implementation is race-free
;exclude=QLockFile::*
;
;exclude=QSemaphore* ; Assume that this is well-tested and race-free
;exclude=QCoreApplication::postEvent ; Qt Events
;exclude=QElapsedTimer ; Qt timer
;
;;exclude=RTNGStopTimer ; Do not exclude this, as it might break timer
;exclude=Allocator::alloc              ; Custom allocator TODO: Add support for custom alloc
;exclude=Allocator::dealloc            ; Custom allocator TODO: Add support for custom alloc
;exclude=SimpleStorage::resizeStorage  ; Custom allocator
;exclude=SimpleStorage::clearStorage   ; Custom allocator
;
;exclude=*Var::clone ; Cloning of variables, TODO: validate @Matous

[dotnetsync_monitor]
; coreclr 2.0
monitor_enter=JIT_MonEnterWorker_InlineGetThread
monitor_exit=JIT_MonExit

; coreclr >= 2.1
; Monitor
monitor_enter=JIT_MonReliableEnter_Portable
monitor_exit=JIT_MonExit_Portable
; MethodImplOptions.Synchronized
monitor_enter=JIT_MonEnterWorker_Portable
monitor_exit=JIT_MonExitWorker_Portable

[dotnetsync_rwlock]

acquire_excl=System.Threading.ReaderWriterLock*.EnterWriteLock*
acquire_excl_try=System.Threading.ReaderWriterLock*.TryEnterWriteLock(TimeoutTracker)*
acquire_shared=System.Threading.ReaderWriterLock*.EnterReadLock*
acquire_shared_try=System.Threading.ReaderWriterLock*.TryEnterReadLock(TimeoutTracker)*
acquire_upgrade=System.Threading.ReaderWriterLock*.EnterUpgradeableReadLock*
acquire_upgrade_try=System.Threading.ReaderWriterLock*.TryEnterUpgradeableReadLock(TimeoutTracker)*

release_excl=System.Threading.ReaderWriterLock*.ExitWriteLock*
release_shared=System.Threading.ReaderWriterLock*.ExitReadLock*
release_shared=System.Threading.ReaderWriterLock*.ExitUpgradeableReadLock*

[dotnetsync_barrier]

wait_blocking=System.Threading.Barrier.SignalAndWait()*
wait_nonblocking=System.Threading.Barrier.SignalAndWait*

[dotnetexclude]
exclude=System.Console.Write* ; Console is synchronized
exclude=System.Threading.WaitHandle.WaitOne*
;exclude=MetaDataGetDispenser
;exclude=DestroyThread
;exclude=GetCurrentThreadTypeNT5
;exclude=ThreadSuspend::UnlockThreadStore
;exclude=SString::Resize
;exclude=TableFreeSingleHandleToCache
;
;; locks are propagated to system, only disable analysis in these functions
;exclude=DeadlockAwareLock::TryBeginEnterLock
;exclude=ListLockEntry::FinishDeadlockAwareEnter

[modules]
exclude_mods=ucrtbase.dll
exclude_mods=tmmon64.dll
exclude_mods=ntdll.dll
exclude_mods=MSVCP140.dll
exclude_mods=TmUmEvt64.dll
exclude_mods=KERNELBASE.dll
exclude_mods=ADVAPI32.dll
exclude_mods=msvcrt.dll
exclude_mods=compbase.dll

; .NET
exclude_mods=CLRJIT.dll
exclude_mods=System.Private.CoreLib.dll
exclude_mods=System.Console.dll
exclude_mods=System.Threading.Thread.dll

; temporary excludes
exclude_mods=libWCCILmanager.dll ; ManagerTimedFunction::isStoping
exclude_mods=RTNGFoundation.dll ; Timer stuff that cannot be excluded otherwise
exclude_mods=clr.dll
exclude_mods=coreclr.dll
exclude_mods=CLRJIT.dll
exclude_mods=hostpolicy.dll
exclude_mods=hostfxr.dll

exclude_path=c:\windows\system32
exclude_path=c:\windows\microsoft.net
exclude_path=c:\windows\winsxs