Skip to content

Commit 2f9baf3

Browse files
compnerdcompnerd
committed
RunLoop: replace CFLock_t with CRITICAL_SECTION
Replace CFLock_t with CRITICAL_SECTION on Windows for the RunLoops. The runloops require a recursive mutex which cannot be fulfilled with SRWLOCKs, so we need to replace the locks on Windows. Ideally, we would create a CFRecusiveLock_t.
1 parent 3b515c7 commit 2f9baf3

File tree

2 files changed

+85
-8
lines changed

2 files changed

+85
-8
lines changed

‎CoreFoundation/Base.subproj/CFInternal.h

Lines changed: 0 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -136,9 +136,6 @@ typedef struct os_log_s *os_log_t;
136136
#ifndef PTHREAD_ERRORCHECK_MUTEX_INITIALIZER
137137
#define PTHREAD_ERRORCHECK_MUTEX_INITIALIZER {_PTHREAD_ERRORCHECK_MUTEX_SIG_init, {0}}
138138
#endif
139-
#ifndef PTHREAD_RECURSIVE_MUTEX_INITIALIZER
140-
#define PTHREAD_RECURSIVE_MUTEX_INITIALIZER {_PTHREAD_RECURSIVE_MUTEX_SIG_init, {0}}
141-
#endif
142139
#endif
143140

144141
#if defined(__BIG_ENDIAN__)

‎CoreFoundation/RunLoop.subproj/CFRunLoop.c

Lines changed: 85 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -670,7 +670,11 @@ typedef struct __CFRunLoopMode *CFRunLoopModeRef;
670670

671671
struct __CFRunLoopMode {
672672
CFRuntimeBase _base;
673+
#if DEPLOYMENT_TARGET_WINDOWS
674+
CRITICAL_SECTION _lock;
675+
#else
673676
CFLock_t _lock; /* must have the run loop locked before locking this */
677+
#endif
674678
CFStringRef _name;
675679
Boolean _stopped;
676680
char _padding[3];
@@ -700,13 +704,21 @@ struct __CFRunLoopMode {
700704
};
701705

702706
CF_INLINE void __CFRunLoopModeLock(CFRunLoopModeRef rlm) {
707+
#if DEPLOYMENT_TARGET_WINDOWS
708+
EnterCriticalSection(&(rlm->_lock));
709+
#else
703710
__CFLock(&(rlm->_lock));
711+
#endif
704712
//CFLog(6, CFSTR("__CFRunLoopModeLock locked %p"), rlm);
705713
}
706714

707715
CF_INLINE void __CFRunLoopModeUnlock(CFRunLoopModeRef rlm) {
708716
//CFLog(6, CFSTR("__CFRunLoopModeLock unlocking %p"), rlm);
717+
#if DEPLOYMENT_TARGET_WINDOWS
718+
LeaveCriticalSection(&(rlm->_lock));
719+
#else
709720
__CFUnlock(&(rlm->_lock));
721+
#endif
710722
}
711723

712724
static Boolean __CFRunLoopModeEqual(CFTypeRef cf1, CFTypeRef cf2) {
@@ -740,6 +752,16 @@ static CFStringRef __CFRunLoopModeCopyDescription(CFTypeRef cf) {
740752
return result;
741753
}
742754

755+
#if DEPLOYMENT_TARGET_WINDOWS
756+
CF_INLINE void __CFRunLoopLockDestroy(LPCRITICAL_SECTION lpCS) {
757+
DeleteCritialSection(lpCS);
758+
}
759+
#else
760+
CF_INLINE void __CFRunLoopLockDestroy(CFLock_t *lock) {
761+
pthread_mutex_destroy(lock);
762+
}
763+
#endif
764+
743765
static void __CFRunLoopModeDeallocate(CFTypeRef cf) {
744766
CFRunLoopModeRef rlm = (CFRunLoopModeRef)cf;
745767
if (NULL != rlm->_sources0) CFRelease(rlm->_sources0);
@@ -761,7 +783,7 @@ static void __CFRunLoopModeDeallocate(CFTypeRef cf) {
761783
#if USE_MK_TIMER_TOO
762784
if (MACH_PORT_NULL != rlm->_timerPort) mk_timer_destroy(rlm->_timerPort);
763785
#endif
764-
pthread_mutex_destroy(&rlm->_lock);
786+
__CFRunLoopLockDestroy(&rlm->_lock);
765787
memset((char *)cf + sizeof(CFRuntimeBase), 0x7C, sizeof(struct __CFRunLoopMode) - sizeof(CFRuntimeBase));
766788
}
767789

@@ -783,7 +805,11 @@ typedef struct _per_run_data {
783805

784806
struct __CFRunLoop {
785807
CFRuntimeBase _base;
808+
#if DEPLOYMENT_TARGET_WINDOWS
809+
CRITICAL_SECTION _lock;
810+
#else
786811
CFLock_t _lock; /* locked for accessing mode list */
812+
#endif
787813
__CFPort _wakeUpPort; // used for CFRunLoopWakeUp
788814
Boolean _unused;
789815
volatile _per_run_data *_perRunData; // reset for runs of the run loop
@@ -866,13 +892,21 @@ CF_INLINE void __CFRunLoopSetDeallocating(CFRunLoopRef rl) {
866892
}
867893

868894
CF_INLINE void __CFRunLoopLock(CFRunLoopRef rl) {
895+
#if DEPLOYMENT_TARGET_WINDOWS
896+
EnterCriticalSection(&(rl->_lock));
897+
#else
869898
__CFLock(&(((CFRunLoopRef)rl)->_lock));
899+
#endif
870900
// CFLog(6, CFSTR("__CFRunLoopLock locked %p"), rl);
871901
}
872902

873903
CF_INLINE void __CFRunLoopUnlock(CFRunLoopRef rl) {
874904
// CFLog(6, CFSTR("__CFRunLoopLock unlocking %p"), rl);
905+
#if DEPLOYMENT_TARGET_WINDOWS
906+
LeaveCriticalSection(&(rl->_lock));
907+
#else
875908
__CFUnlock(&(((CFRunLoopRef)rl)->_lock));
909+
#endif
876910
}
877911

878912
static CFStringRef __CFRunLoopCopyDescription(CFTypeRef cf) {
@@ -894,6 +928,11 @@ CF_PRIVATE void __CFRunLoopDump() { // __private_extern__ to keep the compiler f
894928
CFRelease(desc);
895929
}
896930

931+
#if DEPLOYMENT_TARGET_WINDOWS
932+
CF_INLINE void __CFRunLoopLockInit(LPCRITICAL_SECTION lpCS) {
933+
InitializeCriticalSection(lpCS);
934+
}
935+
#else
897936
CF_INLINE void __CFRunLoopLockInit(CFLock_t *lock) {
898937
pthread_mutexattr_t mattr;
899938
pthread_mutexattr_init(&mattr);
@@ -903,6 +942,7 @@ CF_INLINE void __CFRunLoopLockInit(CFLock_t *lock) {
903942
if (0 != mret) {
904943
}
905944
}
945+
#endif
906946

907947
/* call with rl locked, returns mode locked */
908948
static CFRunLoopModeRef __CFRunLoopFindMode(CFRunLoopRef rl, CFStringRef modeName, Boolean create) {
@@ -1101,7 +1141,11 @@ CF_INLINE void __CFUnsetValid(void *cf) {
11011141

11021142
struct __CFRunLoopSource {
11031143
CFRuntimeBase _base;
1144+
#if DEPLOYMENT_TARGET_WINDOWS
1145+
CRITICAL_SECTION _lock;
1146+
#else
11041147
CFLock_t _lock;
1148+
#endif
11051149
CFIndex _order; /* immutable */
11061150
CFMutableBagRef _runLoops;
11071151
union {
@@ -1124,20 +1168,32 @@ CF_INLINE void __CFRunLoopSourceUnsetSignaled(CFRunLoopSourceRef rls) {
11241168
}
11251169

11261170
CF_INLINE void __CFRunLoopSourceLock(CFRunLoopSourceRef rls) {
1171+
#if DEPLOYMENT_TARGET_WINDOWS
1172+
EnterCriticalSection(&(rls->_lock));
1173+
#else
11271174
__CFLock(&(rls->_lock));
1175+
#endif
11281176
// CFLog(6, CFSTR("__CFRunLoopSourceLock locked %p"), rls);
11291177
}
11301178

11311179
CF_INLINE void __CFRunLoopSourceUnlock(CFRunLoopSourceRef rls) {
11321180
// CFLog(6, CFSTR("__CFRunLoopSourceLock unlocking %p"), rls);
1181+
#if DEPLOYMENT_TARGET_WINDOWS
1182+
LeaveCriticalSection(&(rls->_lock));
1183+
#else
11331184
__CFUnlock(&(rls->_lock));
1185+
#endif
11341186
}
11351187

11361188
#pragma mark Observers
11371189

11381190
struct __CFRunLoopObserver {
11391191
CFRuntimeBase _base;
1192+
#if DEPLOYMENT_TARGET_WINDOWS
1193+
CRITICAL_SECTION _lock;
1194+
#else
11401195
CFLock_t _lock;
1196+
#endif
11411197
CFRunLoopRef _runLoop;
11421198
CFIndex _rlCount;
11431199
CFOptionFlags _activities; /* immutable */
@@ -1174,13 +1230,21 @@ CF_INLINE void __CFRunLoopObserverUnsetRepeats(CFRunLoopObserverRef rlo) {
11741230
}
11751231

11761232
CF_INLINE void __CFRunLoopObserverLock(CFRunLoopObserverRef rlo) {
1233+
#if DEPLOYMENT_TARGET_WINDOWS
1234+
EnterCriticalSection(&(rlo->_lock));
1235+
#else
11771236
__CFLock(&(rlo->_lock));
1237+
#endif
11781238
// CFLog(6, CFSTR("__CFRunLoopObserverLock locked %p"), rlo);
11791239
}
11801240

11811241
CF_INLINE void __CFRunLoopObserverUnlock(CFRunLoopObserverRef rlo) {
11821242
// CFLog(6, CFSTR("__CFRunLoopObserverLock unlocking %p"), rlo);
1243+
#if DEPLOYMENT_TARGET_WINDOWS
1244+
LeaveCriticalSection(&(rlo->_lock));
1245+
#else
11831246
__CFUnlock(&(rlo->_lock));
1247+
#endif
11841248
}
11851249

11861250
static void __CFRunLoopObserverSchedule(CFRunLoopObserverRef rlo, CFRunLoopRef rl, CFRunLoopModeRef rlm) {
@@ -1206,7 +1270,11 @@ static void __CFRunLoopObserverCancel(CFRunLoopObserverRef rlo, CFRunLoopRef rl,
12061270
struct __CFRunLoopTimer {
12071271
CFRuntimeBase _base;
12081272
uint16_t _bits;
1273+
#if DEPLOYMENT_TARGET_WINDOWS
1274+
CRITICAL_SECTION _lock;
1275+
#else
12091276
CFLock_t _lock;
1277+
#endif
12101278
CFRunLoopRef _runLoop;
12111279
CFMutableSetRef _rlModes;
12121280
CFAbsoluteTime _nextFireDate;
@@ -1243,13 +1311,21 @@ CF_INLINE void __CFRunLoopTimerSetDeallocating(CFRunLoopTimerRef rlt) {
12431311
}
12441312

12451313
CF_INLINE void __CFRunLoopTimerLock(CFRunLoopTimerRef rlt) {
1314+
#if DEPLOYMENT_TARGET_WINDOWS
1315+
EnterCriticalSection(&(rlt->_lock));
1316+
#else
12461317
__CFLock(&(rlt->_lock));
1318+
#endif
12471319
// CFLog(6, CFSTR("__CFRunLoopTimerLock locked %p"), rlt);
12481320
}
12491321

12501322
CF_INLINE void __CFRunLoopTimerUnlock(CFRunLoopTimerRef rlt) {
12511323
// CFLog(6, CFSTR("__CFRunLoopTimerLock unlocking %p"), rlt);
1324+
#if DEPLOYMENT_TARGET_WINDOWS
1325+
LeaveCriticalSection(&(rlt->_lock));
1326+
#else
12521327
__CFUnlock(&(rlt->_lock));
1328+
#endif
12531329
}
12541330

12551331

@@ -1427,7 +1503,7 @@ static void __CFRunLoopDeallocate(CFTypeRef cf) {
14271503
rl->_wakeUpPort = CFPORT_NULL;
14281504
__CFRunLoopPopPerRunData(rl, NULL);
14291505
__CFRunLoopUnlock(rl);
1430-
pthread_mutex_destroy(&rl->_lock);
1506+
__CFRunLoopLockDestroy(&rl->_lock);
14311507
memset((char *)cf + sizeof(CFRuntimeBase), 0x8C, sizeof(struct __CFRunLoop) - sizeof(CFRuntimeBase));
14321508
}
14331509

@@ -1570,7 +1646,11 @@ CF_EXPORT CFRunLoopRef _CFRunLoopGet0(_CFThreadRef t) {
15701646
if (pthread_equal(t, pthread_self())) {
15711647
_CFSetTSD(__CFTSDKeyRunLoop, (void *)loop, NULL);
15721648
if (0 == _CFGetTSD(__CFTSDKeyRunLoopCntr)) {
1649+
#if _POSIX_THREADS
15731650
_CFSetTSD(__CFTSDKeyRunLoopCntr, (void *)(PTHREAD_DESTRUCTOR_ITERATIONS-1), (void (*)(void *))__CFFinalizeRunLoop);
1651+
#elif DEPLOYMENT_TARGET_WINDOWS
1652+
_CFSetTSD(__CFTSDKeyRunLoopCntr, (void *)0, (void (*)(void *))__CFFinalizeRunLoop);
1653+
#endif
15741654
}
15751655
}
15761656
return loop;
@@ -3748,7 +3828,7 @@ static void __CFRunLoopSourceDeallocate(CFTypeRef cf) { /* DOES CALLOUT */
37483828
if (rls->_context.version0.release) {
37493829
rls->_context.version0.release(rls->_context.version0.info);
37503830
}
3751-
pthread_mutex_destroy(&rls->_lock);
3831+
__CFRunLoopLockDestroy(&rls->_lock);
37523832
memset((char *)cf + sizeof(CFRuntimeBase), 0, sizeof(struct __CFRunLoopSource) - sizeof(CFRuntimeBase));
37533833
}
37543834

@@ -3939,7 +4019,7 @@ static CFStringRef __CFRunLoopObserverCopyDescription(CFTypeRef cf) { /* DOES CA
39394019
static void __CFRunLoopObserverDeallocate(CFTypeRef cf) { /* DOES CALLOUT */
39404020
CFRunLoopObserverRef rlo = (CFRunLoopObserverRef)cf;
39414021
CFRunLoopObserverInvalidate(rlo);
3942-
pthread_mutex_destroy(&rlo->_lock);
4022+
__CFRunLoopLockDestroy(&rlo->_lock);
39434023
}
39444024

39454025
const CFRuntimeClass __CFRunLoopObserverClass = {
@@ -4130,7 +4210,7 @@ static void __CFRunLoopTimerDeallocate(CFTypeRef cf) { /* DOES CALLOUT */
41304210
CFRunLoopTimerInvalidate(rlt); /* DOES CALLOUT */
41314211
CFRelease(rlt->_rlModes);
41324212
rlt->_rlModes = NULL;
4133-
pthread_mutex_destroy(&rlt->_lock);
4213+
__CFRunLoopLockDestroy(&rlt->_lock);
41344214
}
41354215

41364216
const CFRuntimeClass __CFRunLoopTimerClass = {

0 commit comments

Comments
 (0)