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.
;
; SPDX-License-Identifier: MIT
;
; NOTE: exclude modules are given as regex, therefore escape a . with [.], if you don't
; want to match any character

; 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

[linuxsync]
acquire_excl=pthread_mutex_lock
acquire_excl_try=pthread_mutex_trylock
release_excl=pthread_mutex_unlock


; shared mutexes
;acquire_excl=pthread_rwlock_wrlock
;acquire_excl_try=pthread_rwlock_trywrlock
;release_excl=pthread_rwlock_unlock

;acquire_shared=pthread_rwlock_rdlock
;acquire_shared_try=pthread_rwlock_tryrdlock


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

threadstart=CreateThread
threadstart=_beginthread
threadstart=_beginthreadex

; annotated excludes
exclude_enter=__drace_enter_exclude
exclude_leave=__drace_leave_exclude


exclude=_chkstk
exclude=o__initialize_onexit_table
# initialization of static members, see
# https://www.variadic.xyz/2017/06/20/cpp11-threadsafe-statics/
exclude=_Init_thread_header
exclude=_Init_thread_footer

# exclude the addr of the first argument
exclude_argaddr=__drace_exclude_addr

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;; 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 modules must be given as regexes, to escape . write [.]
; otherwise . means any character -> "any.expression" matches also "anyxexpression"
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

; Linux
; exclude_mods=libc.*

; .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