1
2 /* Posix threads interface */
3
4 #include <stdlib.h>
5 #include <string.h>
6 #if defined(__APPLE__) || defined(HAVE_PTHREAD_DESTRUCTOR)
7 #define destructor xxdestructor
8 #endif
9 #include <pthread.h>
10 #if defined(__APPLE__) || defined(HAVE_PTHREAD_DESTRUCTOR)
11 #undef destructor
12 #endif
13 #include <signal.h>
14
15 /* The POSIX spec requires that use of pthread_attr_setstacksize
16 be conditional on _POSIX_THREAD_ATTR_STACKSIZE being defined. */
17 #ifdef _POSIX_THREAD_ATTR_STACKSIZE
18 #ifndef THREAD_STACK_SIZE
19 #define THREAD_STACK_SIZE 0 /* use default stack size */
20 #endif
21
22 /* The default stack size for new threads on OSX and BSD is small enough that
23 * we'll get hard crashes instead of 'maximum recursion depth exceeded'
24 * exceptions.
25 *
26 * The default stack sizes below are the empirically determined minimal stack
27 * sizes where a simple recursive function doesn't cause a hard crash.
28 */
29 #if defined(__APPLE__) && defined(THREAD_STACK_SIZE) && THREAD_STACK_SIZE == 0
30 #undef THREAD_STACK_SIZE
31 #define THREAD_STACK_SIZE 0x500000
32 #endif
33 #if defined(__FreeBSD__) && defined(THREAD_STACK_SIZE) && THREAD_STACK_SIZE == 0
34 #undef THREAD_STACK_SIZE
35 #define THREAD_STACK_SIZE 0x400000
36 #endif
37 /* for safety, ensure a viable minimum stacksize */
38 #define THREAD_STACK_MIN 0x8000 /* 32kB */
39 #else /* !_POSIX_THREAD_ATTR_STACKSIZE */
40 #ifdef THREAD_STACK_SIZE
41 #error "THREAD_STACK_SIZE defined but _POSIX_THREAD_ATTR_STACKSIZE undefined"
42 #endif
43 #endif
44
45 /* The POSIX spec says that implementations supporting the sem_*
46 family of functions must indicate this by defining
47 _POSIX_SEMAPHORES. */
48 #ifdef _POSIX_SEMAPHORES
49 /* On FreeBSD 4.x, _POSIX_SEMAPHORES is defined empty, so
50 we need to add 0 to make it work there as well. */
51 #if (_POSIX_SEMAPHORES+0) == -1
52 #define HAVE_BROKEN_POSIX_SEMAPHORES
53 #else
54 #include <semaphore.h>
55 #include <errno.h>
56 #endif
57 #endif
58
59 /* Before FreeBSD 5.4, system scope threads was very limited resource
60 in default setting. So the process scope is preferred to get
61 enough number of threads to work. */
62 #ifdef __FreeBSD__
63 #include <osreldate.h>
64 #if __FreeBSD_version >= 500000 && __FreeBSD_version < 504101
65 #undef PTHREAD_SYSTEM_SCHED_SUPPORTED
66 #endif
67 #endif
68
69 #if !defined(pthread_attr_default)
70 # define pthread_attr_default ((pthread_attr_t *)NULL)
71 #endif
72 #if !defined(pthread_mutexattr_default)
73 # define pthread_mutexattr_default ((pthread_mutexattr_t *)NULL)
74 #endif
75 #if !defined(pthread_condattr_default)
76 # define pthread_condattr_default ((pthread_condattr_t *)NULL)
77 #endif
78
79
80 /* Whether or not to use semaphores directly rather than emulating them with
81 * mutexes and condition variables:
82 */
83 #if (defined(_POSIX_SEMAPHORES) && !defined(HAVE_BROKEN_POSIX_SEMAPHORES) && \
84 defined(HAVE_SEM_TIMEDWAIT))
85 # define USE_SEMAPHORES
86 #else
87 # undef USE_SEMAPHORES
88 #endif
89
90
91 /* On platforms that don't use standard POSIX threads pthread_sigmask()
92 * isn't present. DEC threads uses sigprocmask() instead as do most
93 * other UNIX International compliant systems that don't have the full
94 * pthread implementation.
95 */
96 #if defined(HAVE_PTHREAD_SIGMASK) && !defined(HAVE_BROKEN_PTHREAD_SIGMASK)
97 # define SET_THREAD_SIGMASK pthread_sigmask
98 #else
99 # define SET_THREAD_SIGMASK sigprocmask
100 #endif
101
102
103 /* We assume all modern POSIX systems have gettimeofday() */
104 #ifdef GETTIMEOFDAY_NO_TZ
105 #define GETTIMEOFDAY(ptv) gettimeofday(ptv)
106 #else
107 #define GETTIMEOFDAY(ptv) gettimeofday(ptv, (struct timezone *)NULL)
108 #endif
109
110 #define MICROSECONDS_TO_TIMESPEC(microseconds, ts) \
111 do { \
112 struct timeval tv; \
113 GETTIMEOFDAY(&tv); \
114 tv.tv_usec += microseconds % 1000000; \
115 tv.tv_sec += microseconds / 1000000; \
116 tv.tv_sec += tv.tv_usec / 1000000; \
117 tv.tv_usec %= 1000000; \
118 ts.tv_sec = tv.tv_sec; \
119 ts.tv_nsec = tv.tv_usec * 1000; \
120 } while(0)
121
122
123 /* A pthread mutex isn't sufficient to model the Python lock type
124 * because, according to Draft 5 of the docs (P1003.4a/D5), both of the
125 * following are undefined:
126 * -> a thread tries to lock a mutex it already has locked
127 * -> a thread tries to unlock a mutex locked by a different thread
128 * pthread mutexes are designed for serializing threads over short pieces
129 * of code anyway, so wouldn't be an appropriate implementation of
130 * Python's locks regardless.
131 *
132 * The pthread_lock struct implements a Python lock as a "locked?" bit
133 * and a <condition, mutex> pair. In general, if the bit can be acquired
134 * instantly, it is, else the pair is used to block the thread until the
135 * bit is cleared. 9 May 1994 tim@ksr.com
136 */
137
138 typedef struct {
139 char locked; /* 0=unlocked, 1=locked */
140 /* a <cond, mutex> pair to handle an acquire of a locked lock */
141 pthread_cond_t lock_released;
142 pthread_mutex_t mut;
143 } pthread_lock;
144
145 #define CHECK_STATUS(name) if (status != 0) { perror(name); error = 1; }
146
147 /*
148 * Initialization.
149 */
150
151 #if defined(_HAVE_BSDI)
152 static
_noop(void)153 void _noop(void)
154 {
155 }
156
157 static void
PyThread__init_thread(void)158 PyThread__init_thread(void)
159 {
160 /* DO AN INIT BY STARTING THE THREAD */
161 static int dummy = 0;
162 pthread_t thread1;
163 pthread_create(&thread1, NULL, (void *) _noop, &dummy);
164 pthread_join(thread1, NULL);
165 }
166
167 #else /* !_HAVE_BSDI */
168
169 static void
PyThread__init_thread(void)170 PyThread__init_thread(void)
171 {
172 #if defined(_AIX) && defined(__GNUC__)
173 extern void pthread_init(void);
174 pthread_init();
175 #endif
176 }
177
178 #endif /* !_HAVE_BSDI */
179
180 /*
181 * Thread support.
182 */
183
184
185 long
PyThread_start_new_thread(void (* func)(void *),void * arg)186 PyThread_start_new_thread(void (*func)(void *), void *arg)
187 {
188 pthread_t th;
189 int status;
190 #if defined(THREAD_STACK_SIZE) || defined(PTHREAD_SYSTEM_SCHED_SUPPORTED)
191 pthread_attr_t attrs;
192 #endif
193 #if defined(THREAD_STACK_SIZE)
194 size_t tss;
195 #endif
196
197 dprintf(("PyThread_start_new_thread called\n"));
198 if (!initialized)
199 PyThread_init_thread();
200
201 #if defined(THREAD_STACK_SIZE) || defined(PTHREAD_SYSTEM_SCHED_SUPPORTED)
202 if (pthread_attr_init(&attrs) != 0)
203 return -1;
204 #endif
205 #if defined(THREAD_STACK_SIZE)
206 tss = (_pythread_stacksize != 0) ? _pythread_stacksize
207 : THREAD_STACK_SIZE;
208 if (tss != 0) {
209 if (pthread_attr_setstacksize(&attrs, tss) != 0) {
210 pthread_attr_destroy(&attrs);
211 return -1;
212 }
213 }
214 #endif
215 #if defined(PTHREAD_SYSTEM_SCHED_SUPPORTED)
216 pthread_attr_setscope(&attrs, PTHREAD_SCOPE_SYSTEM);
217 #endif
218
219 status = pthread_create(&th,
220 #if defined(THREAD_STACK_SIZE) || defined(PTHREAD_SYSTEM_SCHED_SUPPORTED)
221 &attrs,
222 #else
223 (pthread_attr_t*)NULL,
224 #endif
225 (void* (*)(void *))func,
226 (void *)arg
227 );
228
229 #if defined(THREAD_STACK_SIZE) || defined(PTHREAD_SYSTEM_SCHED_SUPPORTED)
230 pthread_attr_destroy(&attrs);
231 #endif
232 if (status != 0)
233 return -1;
234
235 pthread_detach(th);
236
237 #if SIZEOF_PTHREAD_T <= SIZEOF_LONG
238 return (long) th;
239 #else
240 return (long) *(long *) &th;
241 #endif
242 }
243
244 /* XXX This implementation is considered (to quote Tim Peters) "inherently
245 hosed" because:
246 - It does not guarantee the promise that a non-zero integer is returned.
247 - The cast to long is inherently unsafe.
248 - It is not clear that the 'volatile' (for AIX?) are any longer necessary.
249 */
250 long
PyThread_get_thread_ident(void)251 PyThread_get_thread_ident(void)
252 {
253 volatile pthread_t threadid;
254 if (!initialized)
255 PyThread_init_thread();
256 threadid = pthread_self();
257 return (long) threadid;
258 }
259
260 void
PyThread_exit_thread(void)261 PyThread_exit_thread(void)
262 {
263 dprintf(("PyThread_exit_thread called\n"));
264 if (!initialized)
265 exit(0);
266 pthread_exit(0);
267 }
268
269 #ifdef USE_SEMAPHORES
270
271 /*
272 * Lock support.
273 */
274
275 PyThread_type_lock
PyThread_allocate_lock(void)276 PyThread_allocate_lock(void)
277 {
278 sem_t *lock;
279 int status, error = 0;
280
281 dprintf(("PyThread_allocate_lock called\n"));
282 if (!initialized)
283 PyThread_init_thread();
284
285 lock = (sem_t *)PyMem_RawMalloc(sizeof(sem_t));
286
287 if (lock) {
288 status = sem_init(lock,0,1);
289 CHECK_STATUS("sem_init");
290
291 if (error) {
292 PyMem_RawFree((void *)lock);
293 lock = NULL;
294 }
295 }
296
297 dprintf(("PyThread_allocate_lock() -> %p\n", lock));
298 return (PyThread_type_lock)lock;
299 }
300
301 void
PyThread_free_lock(PyThread_type_lock lock)302 PyThread_free_lock(PyThread_type_lock lock)
303 {
304 sem_t *thelock = (sem_t *)lock;
305 int status, error = 0;
306
307 (void) error; /* silence unused-but-set-variable warning */
308 dprintf(("PyThread_free_lock(%p) called\n", lock));
309
310 if (!thelock)
311 return;
312
313 status = sem_destroy(thelock);
314 CHECK_STATUS("sem_destroy");
315
316 PyMem_RawFree((void *)thelock);
317 }
318
319 /*
320 * As of February 2002, Cygwin thread implementations mistakenly report error
321 * codes in the return value of the sem_ calls (like the pthread_ functions).
322 * Correct implementations return -1 and put the code in errno. This supports
323 * either.
324 */
325 static int
fix_status(int status)326 fix_status(int status)
327 {
328 return (status == -1) ? errno : status;
329 }
330
331 PyLockStatus
PyThread_acquire_lock_timed(PyThread_type_lock lock,PY_TIMEOUT_T microseconds,int intr_flag)332 PyThread_acquire_lock_timed(PyThread_type_lock lock, PY_TIMEOUT_T microseconds,
333 int intr_flag)
334 {
335 PyLockStatus success;
336 sem_t *thelock = (sem_t *)lock;
337 int status, error = 0;
338 struct timespec ts;
339
340 (void) error; /* silence unused-but-set-variable warning */
341 dprintf(("PyThread_acquire_lock_timed(%p, %lld, %d) called\n",
342 lock, microseconds, intr_flag));
343
344 if (microseconds > 0)
345 MICROSECONDS_TO_TIMESPEC(microseconds, ts);
346 do {
347 if (microseconds > 0)
348 status = fix_status(sem_timedwait(thelock, &ts));
349 else if (microseconds == 0)
350 status = fix_status(sem_trywait(thelock));
351 else
352 status = fix_status(sem_wait(thelock));
353 /* Retry if interrupted by a signal, unless the caller wants to be
354 notified. */
355 } while (!intr_flag && status == EINTR);
356
357 /* Don't check the status if we're stopping because of an interrupt. */
358 if (!(intr_flag && status == EINTR)) {
359 if (microseconds > 0) {
360 if (status != ETIMEDOUT)
361 CHECK_STATUS("sem_timedwait");
362 }
363 else if (microseconds == 0) {
364 if (status != EAGAIN)
365 CHECK_STATUS("sem_trywait");
366 }
367 else {
368 CHECK_STATUS("sem_wait");
369 }
370 }
371
372 if (status == 0) {
373 success = PY_LOCK_ACQUIRED;
374 } else if (intr_flag && status == EINTR) {
375 success = PY_LOCK_INTR;
376 } else {
377 success = PY_LOCK_FAILURE;
378 }
379
380 dprintf(("PyThread_acquire_lock_timed(%p, %lld, %d) -> %d\n",
381 lock, microseconds, intr_flag, success));
382 return success;
383 }
384
385 void
PyThread_release_lock(PyThread_type_lock lock)386 PyThread_release_lock(PyThread_type_lock lock)
387 {
388 sem_t *thelock = (sem_t *)lock;
389 int status, error = 0;
390
391 (void) error; /* silence unused-but-set-variable warning */
392 dprintf(("PyThread_release_lock(%p) called\n", lock));
393
394 status = sem_post(thelock);
395 CHECK_STATUS("sem_post");
396 }
397
398 #else /* USE_SEMAPHORES */
399
400 /*
401 * Lock support.
402 */
403 PyThread_type_lock
PyThread_allocate_lock(void)404 PyThread_allocate_lock(void)
405 {
406 pthread_lock *lock;
407 int status, error = 0;
408
409 dprintf(("PyThread_allocate_lock called\n"));
410 if (!initialized)
411 PyThread_init_thread();
412
413 lock = (pthread_lock *) PyMem_RawMalloc(sizeof(pthread_lock));
414 if (lock) {
415 memset((void *)lock, '\0', sizeof(pthread_lock));
416 lock->locked = 0;
417
418 status = pthread_mutex_init(&lock->mut,
419 pthread_mutexattr_default);
420 CHECK_STATUS("pthread_mutex_init");
421 /* Mark the pthread mutex underlying a Python mutex as
422 pure happens-before. We can't simply mark the
423 Python-level mutex as a mutex because it can be
424 acquired and released in different threads, which
425 will cause errors. */
426 _Py_ANNOTATE_PURE_HAPPENS_BEFORE_MUTEX(&lock->mut);
427
428 status = pthread_cond_init(&lock->lock_released,
429 pthread_condattr_default);
430 CHECK_STATUS("pthread_cond_init");
431
432 if (error) {
433 PyMem_RawFree((void *)lock);
434 lock = 0;
435 }
436 }
437
438 dprintf(("PyThread_allocate_lock() -> %p\n", lock));
439 return (PyThread_type_lock) lock;
440 }
441
442 void
PyThread_free_lock(PyThread_type_lock lock)443 PyThread_free_lock(PyThread_type_lock lock)
444 {
445 pthread_lock *thelock = (pthread_lock *)lock;
446 int status, error = 0;
447
448 (void) error; /* silence unused-but-set-variable warning */
449 dprintf(("PyThread_free_lock(%p) called\n", lock));
450
451 /* some pthread-like implementations tie the mutex to the cond
452 * and must have the cond destroyed first.
453 */
454 status = pthread_cond_destroy( &thelock->lock_released );
455 CHECK_STATUS("pthread_cond_destroy");
456
457 status = pthread_mutex_destroy( &thelock->mut );
458 CHECK_STATUS("pthread_mutex_destroy");
459
460 PyMem_RawFree((void *)thelock);
461 }
462
463 PyLockStatus
PyThread_acquire_lock_timed(PyThread_type_lock lock,PY_TIMEOUT_T microseconds,int intr_flag)464 PyThread_acquire_lock_timed(PyThread_type_lock lock, PY_TIMEOUT_T microseconds,
465 int intr_flag)
466 {
467 PyLockStatus success;
468 pthread_lock *thelock = (pthread_lock *)lock;
469 int status, error = 0;
470
471 dprintf(("PyThread_acquire_lock_timed(%p, %lld, %d) called\n",
472 lock, microseconds, intr_flag));
473
474 status = pthread_mutex_lock( &thelock->mut );
475 CHECK_STATUS("pthread_mutex_lock[1]");
476
477 if (thelock->locked == 0) {
478 success = PY_LOCK_ACQUIRED;
479 } else if (microseconds == 0) {
480 success = PY_LOCK_FAILURE;
481 } else {
482 struct timespec ts;
483 if (microseconds > 0)
484 MICROSECONDS_TO_TIMESPEC(microseconds, ts);
485 /* continue trying until we get the lock */
486
487 /* mut must be locked by me -- part of the condition
488 * protocol */
489 success = PY_LOCK_FAILURE;
490 while (success == PY_LOCK_FAILURE) {
491 if (microseconds > 0) {
492 status = pthread_cond_timedwait(
493 &thelock->lock_released,
494 &thelock->mut, &ts);
495 if (status == ETIMEDOUT)
496 break;
497 CHECK_STATUS("pthread_cond_timed_wait");
498 }
499 else {
500 status = pthread_cond_wait(
501 &thelock->lock_released,
502 &thelock->mut);
503 CHECK_STATUS("pthread_cond_wait");
504 }
505
506 if (intr_flag && status == 0 && thelock->locked) {
507 /* We were woken up, but didn't get the lock. We probably received
508 * a signal. Return PY_LOCK_INTR to allow the caller to handle
509 * it and retry. */
510 success = PY_LOCK_INTR;
511 break;
512 } else if (status == 0 && !thelock->locked) {
513 success = PY_LOCK_ACQUIRED;
514 } else {
515 success = PY_LOCK_FAILURE;
516 }
517 }
518 }
519 if (success == PY_LOCK_ACQUIRED) thelock->locked = 1;
520 status = pthread_mutex_unlock( &thelock->mut );
521 CHECK_STATUS("pthread_mutex_unlock[1]");
522
523 if (error) success = PY_LOCK_FAILURE;
524 dprintf(("PyThread_acquire_lock_timed(%p, %lld, %d) -> %d\n",
525 lock, microseconds, intr_flag, success));
526 return success;
527 }
528
529 void
PyThread_release_lock(PyThread_type_lock lock)530 PyThread_release_lock(PyThread_type_lock lock)
531 {
532 pthread_lock *thelock = (pthread_lock *)lock;
533 int status, error = 0;
534
535 (void) error; /* silence unused-but-set-variable warning */
536 dprintf(("PyThread_release_lock(%p) called\n", lock));
537
538 status = pthread_mutex_lock( &thelock->mut );
539 CHECK_STATUS("pthread_mutex_lock[3]");
540
541 thelock->locked = 0;
542
543 /* wake up someone (anyone, if any) waiting on the lock */
544 status = pthread_cond_signal( &thelock->lock_released );
545 CHECK_STATUS("pthread_cond_signal");
546
547 status = pthread_mutex_unlock( &thelock->mut );
548 CHECK_STATUS("pthread_mutex_unlock[3]");
549 }
550
551 #endif /* USE_SEMAPHORES */
552
553 int
PyThread_acquire_lock(PyThread_type_lock lock,int waitflag)554 PyThread_acquire_lock(PyThread_type_lock lock, int waitflag)
555 {
556 return PyThread_acquire_lock_timed(lock, waitflag ? -1 : 0, /*intr_flag=*/0);
557 }
558
559 /* set the thread stack size.
560 * Return 0 if size is valid, -1 if size is invalid,
561 * -2 if setting stack size is not supported.
562 */
563 static int
_pythread_pthread_set_stacksize(size_t size)564 _pythread_pthread_set_stacksize(size_t size)
565 {
566 #if defined(THREAD_STACK_SIZE)
567 pthread_attr_t attrs;
568 size_t tss_min;
569 int rc = 0;
570 #endif
571
572 /* set to default */
573 if (size == 0) {
574 _pythread_stacksize = 0;
575 return 0;
576 }
577
578 #if defined(THREAD_STACK_SIZE)
579 #if defined(PTHREAD_STACK_MIN)
580 tss_min = PTHREAD_STACK_MIN > THREAD_STACK_MIN ? PTHREAD_STACK_MIN
581 : THREAD_STACK_MIN;
582 #else
583 tss_min = THREAD_STACK_MIN;
584 #endif
585 if (size >= tss_min) {
586 /* validate stack size by setting thread attribute */
587 if (pthread_attr_init(&attrs) == 0) {
588 rc = pthread_attr_setstacksize(&attrs, size);
589 pthread_attr_destroy(&attrs);
590 if (rc == 0) {
591 _pythread_stacksize = size;
592 return 0;
593 }
594 }
595 }
596 return -1;
597 #else
598 return -2;
599 #endif
600 }
601
602 #define THREAD_SET_STACKSIZE(x) _pythread_pthread_set_stacksize(x)
603
604 #define Py_HAVE_NATIVE_TLS
605
606 int
PyThread_create_key(void)607 PyThread_create_key(void)
608 {
609 pthread_key_t key;
610 int fail = pthread_key_create(&key, NULL);
611 if (fail)
612 return -1;
613 if (key > INT_MAX) {
614 /* Issue #22206: handle integer overflow */
615 pthread_key_delete(key);
616 errno = ENOMEM;
617 return -1;
618 }
619 return (int)key;
620 }
621
622 void
PyThread_delete_key(int key)623 PyThread_delete_key(int key)
624 {
625 pthread_key_delete(key);
626 }
627
628 void
PyThread_delete_key_value(int key)629 PyThread_delete_key_value(int key)
630 {
631 pthread_setspecific(key, NULL);
632 }
633
634 int
PyThread_set_key_value(int key,void * value)635 PyThread_set_key_value(int key, void *value)
636 {
637 int fail;
638 fail = pthread_setspecific(key, value);
639 return fail ? -1 : 0;
640 }
641
642 void *
PyThread_get_key_value(int key)643 PyThread_get_key_value(int key)
644 {
645 return pthread_getspecific(key);
646 }
647
648 void
PyThread_ReInitTLS(void)649 PyThread_ReInitTLS(void)
650 {}
651