Skip to content

Commit 6456773

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 406d3d5 commit 6456773

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
@@ -668,7 +668,11 @@ typedef struct __CFRunLoopMode *CFRunLoopModeRef;
668668

669669
struct __CFRunLoopMode {
670670
CFRuntimeBase _base;
671+
#if DEPLOYMENT_TARGET_WINDOWS
672+
CRITICAL_SECTION _lock;
673+
#else
671674
CFLock_t _lock; /* must have the run loop locked before locking this */
675+
#endif
672676
CFStringRef _name;
673677
Boolean _stopped;
674678
char _padding[3];
@@ -698,13 +702,21 @@ struct __CFRunLoopMode {
698702
};
699703

700704
CF_INLINE void __CFRunLoopModeLock(CFRunLoopModeRef rlm) {
705+
#if DEPLOYMENT_TARGET_WINDOWS
706+
EnterCriticalSection(&(rlm->_lock));
707+
#else
701708
__CFLock(&(rlm->_lock));
709+
#endif
702710
//CFLog(6, CFSTR("__CFRunLoopModeLock locked %p"), rlm);
703711
}
704712

705713
CF_INLINE void __CFRunLoopModeUnlock(CFRunLoopModeRef rlm) {
706714
//CFLog(6, CFSTR("__CFRunLoopModeLock unlocking %p"), rlm);
715+
#if DEPLOYMENT_TARGET_WINDOWS
716+
LeaveCriticalSection(&(rlm->_lock));
717+
#else
707718
__CFUnlock(&(rlm->_lock));
719+
#endif
708720
}
709721

710722
static Boolean __CFRunLoopModeEqual(CFTypeRef cf1, CFTypeRef cf2) {
@@ -738,6 +750,16 @@ static CFStringRef __CFRunLoopModeCopyDescription(CFTypeRef cf) {
738750
return result;
739751
}
740752

753+
#if DEPLOYMENT_TARGET_WINDOWS
754+
CF_INLINE void __CFRunLoopLockDestroy(LPCRITICAL_SECTION lpCS) {
755+
DeleteCritialSection(lpCS);
756+
}
757+
#else
758+
CF_INLINE void __CFRunLoopLockDestroy(CFLock_t *lock) {
759+
pthread_mutex_destroy(lock);
760+
}
761+
#endif
762+
741763
static void __CFRunLoopModeDeallocate(CFTypeRef cf) {
742764
CFRunLoopModeRef rlm = (CFRunLoopModeRef)cf;
743765
if (NULL != rlm->_sources0) CFRelease(rlm->_sources0);
@@ -759,7 +781,7 @@ static void __CFRunLoopModeDeallocate(CFTypeRef cf) {
759781
#if USE_MK_TIMER_TOO
760782
if (MACH_PORT_NULL != rlm->_timerPort) mk_timer_destroy(rlm->_timerPort);
761783
#endif
762-
pthread_mutex_destroy(&rlm->_lock);
784+
__CFRunLoopLockDestroy(&rlm->_lock);
763785
memset((char *)cf + sizeof(CFRuntimeBase), 0x7C, sizeof(struct __CFRunLoopMode) - sizeof(CFRuntimeBase));
764786
}
765787

@@ -781,7 +803,11 @@ typedef struct _per_run_data {
781803

782804
struct __CFRunLoop {
783805
CFRuntimeBase _base;
806+
#if DEPLOYMENT_TARGET_WINDOWS
807+
CRITICAL_SECTION _lock;
808+
#else
784809
CFLock_t _lock; /* locked for accessing mode list */
810+
#endif
785811
__CFPort _wakeUpPort; // used for CFRunLoopWakeUp
786812
Boolean _unused;
787813
volatile _per_run_data *_perRunData; // reset for runs of the run loop
@@ -864,13 +890,21 @@ CF_INLINE void __CFRunLoopSetDeallocating(CFRunLoopRef rl) {
864890
}
865891

866892
CF_INLINE void __CFRunLoopLock(CFRunLoopRef rl) {
893+
#if DEPLOYMENT_TARGET_WINDOWS
894+
EnterCriticalSection(&(rl->_lock));
895+
#else
867896
__CFLock(&(((CFRunLoopRef)rl)->_lock));
897+
#endif
868898
// CFLog(6, CFSTR("__CFRunLoopLock locked %p"), rl);
869899
}
870900

871901
CF_INLINE void __CFRunLoopUnlock(CFRunLoopRef rl) {
872902
// CFLog(6, CFSTR("__CFRunLoopLock unlocking %p"), rl);
903+
#if DEPLOYMENT_TARGET_WINDOWS
904+
LeaveCriticalSection(&(rl->_lock));
905+
#else
873906
__CFUnlock(&(((CFRunLoopRef)rl)->_lock));
907+
#endif
874908
}
875909

876910
static CFStringRef __CFRunLoopCopyDescription(CFTypeRef cf) {
@@ -892,6 +926,11 @@ CF_PRIVATE void __CFRunLoopDump() { // __private_extern__ to keep the compiler f
892926
CFRelease(desc);
893927
}
894928

929+
#if DEPLOYMENT_TARGET_WINDOWS
930+
CF_INLINE void __CFRunLoopLockInit(LPCRITICAL_SECTION lpCS) {
931+
InitializeCriticalSection(lpCS);
932+
}
933+
#else
895934
CF_INLINE void __CFRunLoopLockInit(CFLock_t *lock) {
896935
pthread_mutexattr_t mattr;
897936
pthread_mutexattr_init(&mattr);
@@ -901,6 +940,7 @@ CF_INLINE void __CFRunLoopLockInit(CFLock_t *lock) {
901940
if (0 != mret) {
902941
}
903942
}
943+
#endif
904944

905945
/* call with rl locked, returns mode locked */
906946
static CFRunLoopModeRef __CFRunLoopFindMode(CFRunLoopRef rl, CFStringRef modeName, Boolean create) {
@@ -1099,7 +1139,11 @@ CF_INLINE void __CFUnsetValid(void *cf) {
10991139

11001140
struct __CFRunLoopSource {
11011141
CFRuntimeBase _base;
1142+
#if DEPLOYMENT_TARGET_WINDOWS
1143+
CRITICAL_SECTION _lock;
1144+
#else
11021145
CFLock_t _lock;
1146+
#endif
11031147
CFIndex _order; /* immutable */
11041148
CFMutableBagRef _runLoops;
11051149
union {
@@ -1122,20 +1166,32 @@ CF_INLINE void __CFRunLoopSourceUnsetSignaled(CFRunLoopSourceRef rls) {
11221166
}
11231167

11241168
CF_INLINE void __CFRunLoopSourceLock(CFRunLoopSourceRef rls) {
1169+
#if DEPLOYMENT_TARGET_WINDOWS
1170+
EnterCriticalSection(&(rls->_lock));
1171+
#else
11251172
__CFLock(&(rls->_lock));
1173+
#endif
11261174
// CFLog(6, CFSTR("__CFRunLoopSourceLock locked %p"), rls);
11271175
}
11281176

11291177
CF_INLINE void __CFRunLoopSourceUnlock(CFRunLoopSourceRef rls) {
11301178
// CFLog(6, CFSTR("__CFRunLoopSourceLock unlocking %p"), rls);
1179+
#if DEPLOYMENT_TARGET_WINDOWS
1180+
LeaveCriticalSection(&(rls->_lock));
1181+
#else
11311182
__CFUnlock(&(rls->_lock));
1183+
#endif
11321184
}
11331185

11341186
#pragma mark Observers
11351187

11361188
struct __CFRunLoopObserver {
11371189
CFRuntimeBase _base;
1190+
#if DEPLOYMENT_TARGET_WINDOWS
1191+
CRITICAL_SECTION _lock;
1192+
#else
11381193
CFLock_t _lock;
1194+
#endif
11391195
CFRunLoopRef _runLoop;
11401196
CFIndex _rlCount;
11411197
CFOptionFlags _activities; /* immutable */
@@ -1172,13 +1228,21 @@ CF_INLINE void __CFRunLoopObserverUnsetRepeats(CFRunLoopObserverRef rlo) {
11721228
}
11731229

11741230
CF_INLINE void __CFRunLoopObserverLock(CFRunLoopObserverRef rlo) {
1231+
#if DEPLOYMENT_TARGET_WINDOWS
1232+
EnterCriticalSection(&(rlo->_lock));
1233+
#else
11751234
__CFLock(&(rlo->_lock));
1235+
#endif
11761236
// CFLog(6, CFSTR("__CFRunLoopObserverLock locked %p"), rlo);
11771237
}
11781238

11791239
CF_INLINE void __CFRunLoopObserverUnlock(CFRunLoopObserverRef rlo) {
11801240
// CFLog(6, CFSTR("__CFRunLoopObserverLock unlocking %p"), rlo);
1241+
#if DEPLOYMENT_TARGET_WINDOWS
1242+
LeaveCriticalSection(&(rlo->_lock));
1243+
#else
11811244
__CFUnlock(&(rlo->_lock));
1245+
#endif
11821246
}
11831247

11841248
static void __CFRunLoopObserverSchedule(CFRunLoopObserverRef rlo, CFRunLoopRef rl, CFRunLoopModeRef rlm) {
@@ -1204,7 +1268,11 @@ static void __CFRunLoopObserverCancel(CFRunLoopObserverRef rlo, CFRunLoopRef rl,
12041268
struct __CFRunLoopTimer {
12051269
CFRuntimeBase _base;
12061270
uint16_t _bits;
1271+
#if DEPLOYMENT_TARGET_WINDOWS
1272+
CRITICAL_SECTION _lock;
1273+
#else
12071274
CFLock_t _lock;
1275+
#endif
12081276
CFRunLoopRef _runLoop;
12091277
CFMutableSetRef _rlModes;
12101278
CFAbsoluteTime _nextFireDate;
@@ -1241,13 +1309,21 @@ CF_INLINE void __CFRunLoopTimerSetDeallocating(CFRunLoopTimerRef rlt) {
12411309
}
12421310

12431311
CF_INLINE void __CFRunLoopTimerLock(CFRunLoopTimerRef rlt) {
1312+
#if DEPLOYMENT_TARGET_WINDOWS
1313+
EnterCriticalSection(&(rlt->_lock));
1314+
#else
12441315
__CFLock(&(rlt->_lock));
1316+
#endif
12451317
// CFLog(6, CFSTR("__CFRunLoopTimerLock locked %p"), rlt);
12461318
}
12471319

12481320
CF_INLINE void __CFRunLoopTimerUnlock(CFRunLoopTimerRef rlt) {
12491321
// CFLog(6, CFSTR("__CFRunLoopTimerLock unlocking %p"), rlt);
1322+
#if DEPLOYMENT_TARGET_WINDOWS
1323+
LeaveCriticalSection(&(rlt->_lock));
1324+
#else
12501325
__CFUnlock(&(rlt->_lock));
1326+
#endif
12511327
}
12521328

12531329

@@ -1425,7 +1501,7 @@ static void __CFRunLoopDeallocate(CFTypeRef cf) {
14251501
rl->_wakeUpPort = CFPORT_NULL;
14261502
__CFRunLoopPopPerRunData(rl, NULL);
14271503
__CFRunLoopUnlock(rl);
1428-
pthread_mutex_destroy(&rl->_lock);
1504+
__CFRunLoopLockDestroy(&rl->_lock);
14291505
memset((char *)cf + sizeof(CFRuntimeBase), 0x8C, sizeof(struct __CFRunLoop) - sizeof(CFRuntimeBase));
14301506
}
14311507

@@ -1568,7 +1644,11 @@ CF_EXPORT CFRunLoopRef _CFRunLoopGet0(_CFThreadRef t) {
15681644
if (pthread_equal(t, pthread_self())) {
15691645
_CFSetTSD(__CFTSDKeyRunLoop, (void *)loop, NULL);
15701646
if (0 == _CFGetTSD(__CFTSDKeyRunLoopCntr)) {
1647+
#if _POSIX_THREADS
15711648
_CFSetTSD(__CFTSDKeyRunLoopCntr, (void *)(PTHREAD_DESTRUCTOR_ITERATIONS-1), (void (*)(void *))__CFFinalizeRunLoop);
1649+
#elif DEPLOYMENT_TARGET_WINDOWS
1650+
_CFSetTSD(__CFTSDKeyRunLoopCntr, (void *)0, (void (*)(void *))__CFFinalizeRunLoop);
1651+
#endif
15721652
}
15731653
}
15741654
return loop;
@@ -3746,7 +3826,7 @@ static void __CFRunLoopSourceDeallocate(CFTypeRef cf) { /* DOES CALLOUT */
37463826
if (rls->_context.version0.release) {
37473827
rls->_context.version0.release(rls->_context.version0.info);
37483828
}
3749-
pthread_mutex_destroy(&rls->_lock);
3829+
__CFRunLoopLockDestroy(&rls->_lock);
37503830
memset((char *)cf + sizeof(CFRuntimeBase), 0, sizeof(struct __CFRunLoopSource) - sizeof(CFRuntimeBase));
37513831
}
37523832

@@ -3937,7 +4017,7 @@ static CFStringRef __CFRunLoopObserverCopyDescription(CFTypeRef cf) { /* DOES CA
39374017
static void __CFRunLoopObserverDeallocate(CFTypeRef cf) { /* DOES CALLOUT */
39384018
CFRunLoopObserverRef rlo = (CFRunLoopObserverRef)cf;
39394019
CFRunLoopObserverInvalidate(rlo);
3940-
pthread_mutex_destroy(&rlo->_lock);
4020+
__CFRunLoopLockDestroy(&rlo->_lock);
39414021
}
39424022

39434023
const CFRuntimeClass __CFRunLoopObserverClass = {
@@ -4128,7 +4208,7 @@ static void __CFRunLoopTimerDeallocate(CFTypeRef cf) { /* DOES CALLOUT */
41284208
CFRunLoopTimerInvalidate(rlt); /* DOES CALLOUT */
41294209
CFRelease(rlt->_rlModes);
41304210
rlt->_rlModes = NULL;
4131-
pthread_mutex_destroy(&rlt->_lock);
4211+
__CFRunLoopLockDestroy(&rlt->_lock);
41324212
}
41334213

41344214
const CFRuntimeClass __CFRunLoopTimerClass = {

0 commit comments

Comments
 (0)