#include "pycore_interp.h" // _PyInterpreterState.threads.stacksize

#include <stdlib.h>

#include <string.h>

#if defined(__APPLE__) || defined(HAVE_PTHREAD_DESTRUCTOR)

#define destructor xxdestructor

#include <pthread.h>

#if defined(__APPLE__) || defined(HAVE_PTHREAD_DESTRUCTOR)

#undef destructor

#include <signal.h>

#if defined(__linux__)

# include <sys/syscall.h> /* syscall(SYS_gettid) */

#elif defined(__FreeBSD__)

# include <pthread_np.h> /* pthread_getthreadid_np() */

#elif defined(__OpenBSD__)

# include <unistd.h> /* getthrid() */

#elif defined(_AIX)

# include <sys/thread.h> /* thread_self() */

#elif defined(__NetBSD__)

# include <lwp.h> /* _lwp_self() */

#elif defined(__DragonFly__)

# include <sys/lwp.h> /* lwp_gettid() */

#ifdef _POSIX_THREAD_ATTR_STACKSIZE

#ifndef THREAD_STACK_SIZE

#define THREAD_STACK_SIZE 0 /* use default stack size */

#if defined(__FreeBSD__) && defined(THREAD_STACK_SIZE) && THREAD_STACK_SIZE == 0

#undef THREAD_STACK_SIZE

#define THREAD_STACK_SIZE 0x400000

#if defined(_AIX) && defined(THREAD_STACK_SIZE) && THREAD_STACK_SIZE == 0

#undef THREAD_STACK_SIZE

#define THREAD_STACK_SIZE 0x200000

#if defined(__ANDROID__) && defined(THREAD_STACK_SIZE) && THREAD_STACK_SIZE == 0

# ifdef Py_DEBUG

# undef THREAD_STACK_SIZE

# define THREAD_STACK_SIZE 0x800000

#if defined(__VXWORKS__) && defined(THREAD_STACK_SIZE) && THREAD_STACK_SIZE == 0

#undef THREAD_STACK_SIZE

#define THREAD_STACK_SIZE 0x100000

#define THREAD_STACK_MIN 0x8000 /* 32 KiB */

#else /* !_POSIX_THREAD_ATTR_STACKSIZE */

#ifdef THREAD_STACK_SIZE

#error "THREAD_STACK_SIZE defined but _POSIX_THREAD_ATTR_STACKSIZE undefined"

#ifdef _POSIX_SEMAPHORES

#if (_POSIX_SEMAPHORES+0) == -1

#define HAVE_BROKEN_POSIX_SEMAPHORES

#include <semaphore.h>

#include <errno.h>

#if (defined(_POSIX_SEMAPHORES) && !defined(HAVE_BROKEN_POSIX_SEMAPHORES) && \

(defined(HAVE_SEM_TIMEDWAIT) || defined(HAVE_SEM_CLOCKWAIT)))

# define USE_SEMAPHORES

# undef USE_SEMAPHORES

#if defined(HAVE_PTHREAD_SIGMASK) && !defined(HAVE_BROKEN_PTHREAD_SIGMASK)

# define SET_THREAD_SIGMASK pthread_sigmask

# define SET_THREAD_SIGMASK sigprocmask

#define MICROSECONDS_TO_TIMESPEC(microseconds, ts) \

do { \

struct timeval tv; \

gettimeofday(&tv, NULL); \

tv.tv_usec += microseconds % 1000000; \

tv.tv_sec += microseconds / 1000000; \

tv.tv_sec += tv.tv_usec / 1000000; \

tv.tv_usec %= 1000000; \

ts.tv_sec = tv.tv_sec; \

ts.tv_nsec = tv.tv_usec * 1000; \

} while(0)

#if defined(HAVE_PTHREAD_CONDATTR_SETCLOCK) && defined(HAVE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC)

#define CONDATTR_MONOTONIC

static pthread_condattr_t *condattr_monotonic = NULL;

static void

init_condattr(void)

{

#ifdef CONDATTR_MONOTONIC

static pthread_condattr_t ca;

pthread_condattr_init(&ca);

if (pthread_condattr_setclock(&ca, CLOCK_MONOTONIC) == 0) {

condattr_monotonic = &ca; // Use monotonic clock

}

}

_PyThread_cond_init(PyCOND_T *cond)

{

return pthread_cond_init(cond, condattr_monotonic);

}

_PyThread_cond_after(long long us, struct timespec *abs)

{

#ifdef CONDATTR_MONOTONIC

if (condattr_monotonic) {

clock_gettime(CLOCK_MONOTONIC, abs);

abs->tv_sec += us / 1000000;

abs->tv_nsec += (us % 1000000) * 1000;

abs->tv_sec += abs->tv_nsec / 1000000000;

abs->tv_nsec %= 1000000000;

return;

}

struct timespec ts;

MICROSECONDS_TO_TIMESPEC(us, ts);

*abs = ts;

}

typedef struct {

char locked; /* 0=unlocked, 1=locked */

/* a <cond, mutex> pair to handle an acquire of a locked lock */

pthread_cond_t lock_released;

pthread_mutex_t mut;

} pthread_lock;

#define CHECK_STATUS(name) if (status != 0) { perror(name); error = 1; }

#define CHECK_STATUS_PTHREAD(name) if (status != 0) { fprintf(stderr, \

"%s: %s\n", name, strerror(status)); error = 1; }

static void

PyThread__init_thread(void)

{

#if defined(_AIX) && defined(__GNUC__)

extern void pthread_init(void);

pthread_init();

init_condattr();

}

typedef struct {

void (*func) (void *);

void *arg;

} pythread_callback;

static void *

pythread_wrapper(void *arg)

{

/* copy func and func_arg and free the temporary structure */

pythread_callback *callback = arg;

void (*func)(void *) = callback->func;

void *func_arg = callback->arg;

PyMem_RawFree(arg);

func(func_arg);

return NULL;

}

PyThread_start_new_thread(void (*func)(void *), void *arg)

{

pthread_t th;

int status;

#if defined(THREAD_STACK_SIZE) || defined(PTHREAD_SYSTEM_SCHED_SUPPORTED)

pthread_attr_t attrs;

#if defined(THREAD_STACK_SIZE)

size_t tss;

if (!initialized)

PyThread_init_thread();

#if defined(THREAD_STACK_SIZE) || defined(PTHREAD_SYSTEM_SCHED_SUPPORTED)

if (pthread_attr_init(&attrs) != 0)

return PYTHREAD_INVALID_THREAD_ID;

#if defined(THREAD_STACK_SIZE)

PyThreadState *tstate = _PyThreadState_GET();

size_t stacksize = tstate ? tstate->interp->threads.stacksize : 0;

tss = (stacksize != 0) ? stacksize : THREAD_STACK_SIZE;

if (tss != 0) {

if (pthread_attr_setstacksize(&attrs, tss) != 0) {

pthread_attr_destroy(&attrs);

return PYTHREAD_INVALID_THREAD_ID;

}

}

#if defined(PTHREAD_SYSTEM_SCHED_SUPPORTED)

pthread_attr_setscope(&attrs, PTHREAD_SCOPE_SYSTEM);

pythread_callback *callback = PyMem_RawMalloc(sizeof(pythread_callback));

if (callback == NULL) {

return PYTHREAD_INVALID_THREAD_ID;

}

callback->func = func;

callback->arg = arg;

status = pthread_create(&th,

#if defined(THREAD_STACK_SIZE) || defined(PTHREAD_SYSTEM_SCHED_SUPPORTED)

&attrs,

(pthread_attr_t*)NULL,

pythread_wrapper, callback);

#if defined(THREAD_STACK_SIZE) || defined(PTHREAD_SYSTEM_SCHED_SUPPORTED)

pthread_attr_destroy(&attrs);

if (status != 0) {

PyMem_RawFree(callback);

return PYTHREAD_INVALID_THREAD_ID;

}

pthread_detach(th);

#if SIZEOF_PTHREAD_T <= SIZEOF_LONG

return (unsigned long) th;

return (unsigned long) *(unsigned long *) &th;

}

PyThread_get_thread_ident(void)

{

volatile pthread_t threadid;

if (!initialized)

PyThread_init_thread();

threadid = pthread_self();

return (unsigned long) threadid;

}

#ifdef PY_HAVE_THREAD_NATIVE_ID

PyThread_get_thread_native_id(void)

{

if (!initialized)

PyThread_init_thread();

#ifdef __APPLE__

uint64_t native_id;

(void) pthread_threadid_np(NULL, &native_id);

#elif defined(__linux__)

pid_t native_id;

native_id = syscall(SYS_gettid);

#elif defined(__FreeBSD__)

int native_id;

native_id = pthread_getthreadid_np();

#elif defined(__OpenBSD__)

pid_t native_id;

native_id = getthrid();

#elif defined(_AIX)

tid_t native_id;

native_id = thread_self();

#elif defined(__NetBSD__)

lwpid_t native_id;

native_id = _lwp_self();

#elif defined(__DragonFly__)

lwpid_t native_id;

native_id = lwp_gettid();

return (unsigned long) native_id;

}

void _Py_NO_RETURN

PyThread_exit_thread(void)

{

if (!initialized)

exit(0);

pthread_exit(0);

}

#ifdef USE_SEMAPHORES

PyThread_allocate_lock(void)

{

sem_t *lock;

int status, error = 0;

if (!initialized)

PyThread_init_thread();

lock = (sem_t *)PyMem_RawMalloc(sizeof(sem_t));

if (lock) {

status = sem_init(lock,0,1);

CHECK_STATUS("sem_init");

if (error) {

PyMem_RawFree((void *)lock);

lock = NULL;

}

}

return (PyThread_type_lock)lock;

}

PyThread_free_lock(PyThread_type_lock lock)

{

sem_t *thelock = (sem_t *)lock;

int status, error = 0;

(void) error; /* silence unused-but-set-variable warning */

if (!thelock)

return;

status = sem_destroy(thelock);

CHECK_STATUS("sem_destroy");

PyMem_RawFree((void *)thelock);

}

static int

fix_status(int status)

{

return (status == -1) ? errno : status;

}

PyThread_acquire_lock_timed(PyThread_type_lock lock, PY_TIMEOUT_T microseconds,

int intr_flag)

{

PyLockStatus success;

sem_t *thelock = (sem_t *)lock;

int status, error = 0;

(void) error; /* silence unused-but-set-variable warning */

_PyTime_t timeout; // relative timeout

if (microseconds >= 0) {

_PyTime_t ns;

if (microseconds <= _PyTime_MAX / 1000) {

ns = microseconds * 1000;

}

else {

// bpo-41710: PyThread_acquire_lock_timed() cannot report timeout

// overflow to the caller, so clamp the timeout to

// [_PyTime_MIN, _PyTime_MAX].

//

// _PyTime_MAX nanoseconds is around 292.3 years.

//

// _thread.Lock.acquire() and _thread.RLock.acquire() raise an

// OverflowError if microseconds is greater than PY_TIMEOUT_MAX.

ns = _PyTime_MAX;

}

timeout = _PyTime_FromNanoseconds(ns);

}

else {

timeout = _PyTime_FromNanoseconds(-1);

}

#ifdef HAVE_SEM_CLOCKWAIT

struct timespec abs_timeout;

// Local scope for deadline

{

_PyTime_t deadline = _PyTime_Add(_PyTime_GetMonotonicClock(), timeout);

_PyTime_AsTimespec_clamp(deadline, &abs_timeout);

}

_PyTime_t deadline = 0;

if (timeout > 0 && !intr_flag) {

deadline = _PyDeadline_Init(timeout);

}

while (1) {

if (timeout > 0) {

#ifdef HAVE_SEM_CLOCKWAIT

status = fix_status(sem_clockwait(thelock, CLOCK_MONOTONIC,

&abs_timeout));

_PyTime_t abs_time = _PyTime_Add(_PyTime_GetSystemClock(),

timeout);

struct timespec ts;

_PyTime_AsTimespec_clamp(abs_time, &ts);

status = fix_status(sem_timedwait(thelock, &ts));

}

else if (timeout == 0) {

status = fix_status(sem_trywait(thelock));

}

else {

status = fix_status(sem_wait(thelock));

}

/* Retry if interrupted by a signal, unless the caller wants to be

if (intr_flag || status != EINTR) {

break;

}

// sem_clockwait() uses an absolute timeout, there is no need

// to recompute the relative timeout.

#ifndef HAVE_SEM_CLOCKWAIT

if (timeout > 0) {

/* wait interrupted by a signal (EINTR): recompute the timeout */

_PyTime_t timeout = _PyDeadline_Get(deadline);

if (timeout < 0) {

status = ETIMEDOUT;

break;

}

}

}

/* Don't check the status if we're stopping because of an interrupt. */

if (!(intr_flag && status == EINTR)) {

if (timeout > 0) {

if (status != ETIMEDOUT) {

#ifdef HAVE_SEM_CLOCKWAIT

CHECK_STATUS("sem_clockwait");

CHECK_STATUS("sem_timedwait");

}

}

else if (timeout == 0) {

if (status != EAGAIN) {

CHECK_STATUS("sem_trywait");

}

}

else {

CHECK_STATUS("sem_wait");

}

}

if (status == 0) {

success = PY_LOCK_ACQUIRED;

} else if (intr_flag && status == EINTR) {

success = PY_LOCK_INTR;

} else {

success = PY_LOCK_FAILURE;

}

return success;

}

PyThread_release_lock(PyThread_type_lock lock)

{

sem_t *thelock = (sem_t *)lock;

int status, error = 0;

(void) error; /* silence unused-but-set-variable warning */

status = sem_post(thelock);

CHECK_STATUS("sem_post");

}

#else /* USE_SEMAPHORES */

PyThread_allocate_lock(void)

{

pthread_lock *lock;

int status, error = 0;

if (!initialized)

PyThread_init_thread();

lock = (pthread_lock *) PyMem_RawCalloc(1, sizeof(pthread_lock));

if (lock) {

lock->locked = 0;

status = pthread_mutex_init(&lock->mut, NULL);

CHECK_STATUS_PTHREAD("pthread_mutex_init");

/* Mark the pthread mutex underlying a Python mutex as

_Py_ANNOTATE_PURE_HAPPENS_BEFORE_MUTEX(&lock->mut);

status = _PyThread_cond_init(&lock->lock_released);

CHECK_STATUS_PTHREAD("pthread_cond_init");

if (error) {

PyMem_RawFree((void *)lock);

lock = 0;

}

}

return (PyThread_type_lock) lock;

}

PyThread_free_lock(PyThread_type_lock lock)

{

pthread_lock *thelock = (pthread_lock *)lock;

int status, error = 0;

(void) error; /* silence unused-but-set-variable warning */

/* some pthread-like implementations tie the mutex to the cond

status = pthread_cond_destroy( &thelock->lock_released );

CHECK_STATUS_PTHREAD("pthread_cond_destroy");

status = pthread_mutex_destroy( &thelock->mut );

CHECK_STATUS_PTHREAD("pthread_mutex_destroy");

PyMem_RawFree((void *)thelock);

}

PyThread_acquire_lock_timed(PyThread_type_lock lock, PY_TIMEOUT_T microseconds,

int intr_flag)

{

PyLockStatus success = PY_LOCK_FAILURE;

pthread_lock *thelock = (pthread_lock *)lock;

int status, error = 0;

if (microseconds == 0) {

status = pthread_mutex_trylock( &thelock->mut );

if (status != EBUSY)

CHECK_STATUS_PTHREAD("pthread_mutex_trylock[1]");

}

else {

status = pthread_mutex_lock( &thelock->mut );

CHECK_STATUS_PTHREAD("pthread_mutex_lock[1]");

}

if (status == 0) {

if (thelock->locked == 0) {

success = PY_LOCK_ACQUIRED;

}

else if (microseconds != 0) {

struct timespec abs;

if (microseconds > 0) {

_PyThread_cond_after(microseconds, &abs);

}

/* continue trying until we get the lock */

/* mut must be locked by me -- part of the condition

while (success == PY_LOCK_FAILURE) {

if (microseconds > 0) {

status = pthread_cond_timedwait(

&thelock->lock_released,

&thelock->mut, &abs);

if (status == 1) {

break;

}

if (status == ETIMEDOUT)

break;

CHECK_STATUS_PTHREAD("pthread_cond_timedwait");

}

else {

status = pthread_cond_wait(

&thelock->lock_released,

&thelock->mut);

CHECK_STATUS_PTHREAD("pthread_cond_wait");

}

if (intr_flag && status == 0 && thelock->locked) {

/* We were woken up, but didn't get the lock. We probably received

success = PY_LOCK_INTR;

break;

}

else if (status == 0 && !thelock->locked) {

success = PY_LOCK_ACQUIRED;

}

}

}

if (success == PY_LOCK_ACQUIRED) thelock->locked = 1;

status = pthread_mutex_unlock( &thelock->mut );

CHECK_STATUS_PTHREAD("pthread_mutex_unlock[1]");

}

if (error) success = PY_LOCK_FAILURE;

return success;

}

PyThread_release_lock(PyThread_type_lock lock)

{

pthread_lock *thelock = (pthread_lock *)lock;

int status, error = 0;

(void) error; /* silence unused-but-set-variable warning */

status = pthread_mutex_lock( &thelock->mut );

CHECK_STATUS_PTHREAD("pthread_mutex_lock[3]");

thelock->locked = 0;

/* wake up someone (anyone, if any) waiting on the lock */

status = pthread_cond_signal( &thelock->lock_released );

CHECK_STATUS_PTHREAD("pthread_cond_signal");

status = pthread_mutex_unlock( &thelock->mut );

CHECK_STATUS_PTHREAD("pthread_mutex_unlock[3]");

}

#endif /* USE_SEMAPHORES */

_PyThread_at_fork_reinit(PyThread_type_lock *lock)

{

PyThread_type_lock new_lock = PyThread_allocate_lock();

if (new_lock == NULL) {

return -1;

}

/* bpo-6721, bpo-40089: The old lock can be in an inconsistent state.

*lock = new_lock;

return 0;

}

PyThread_acquire_lock(PyThread_type_lock lock, int waitflag)

{

return PyThread_acquire_lock_timed(lock, waitflag ? -1 : 0, /*intr_flag=*/0);

}

static int

_pythread_pthread_set_stacksize(size_t size)

{

#if defined(THREAD_STACK_SIZE)

pthread_attr_t attrs;

size_t tss_min;

int rc = 0;

/* set to default */

if (size == 0) {

_PyInterpreterState_GET()->threads.stacksize = 0;

return 0;

}

#if defined(THREAD_STACK_SIZE)

#if defined(PTHREAD_STACK_MIN)

tss_min = PTHREAD_STACK_MIN > THREAD_STACK_MIN ? PTHREAD_STACK_MIN

: THREAD_STACK_MIN;

tss_min = THREAD_STACK_MIN;

if (size >= tss_min) {

/* validate stack size by setting thread attribute */

if (pthread_attr_init(&attrs) == 0) {

rc = pthread_attr_setstacksize(&attrs, size);

pthread_attr_destroy(&attrs);

if (rc == 0) {

_PyInterpreterState_GET()->threads.stacksize = size;

return 0;

}

}

}

return -1;

return -2;

}

#define THREAD_SET_STACKSIZE(x) _pythread_pthread_set_stacksize(x)

PyThread_create_key(void)

{

#ifdef PTHREAD_KEY_T_IS_COMPATIBLE_WITH_INT

pthread_key_t key;

int fail = pthread_key_create(&key, NULL);

if (fail)

return -1;

if (key > INT_MAX) {

/* Issue #22206: handle integer overflow */

pthread_key_delete(key);

errno = ENOMEM;

return -1;

}

return (int)key;

return -1; /* never return valid key value. */

}

PyThread_delete_key(int key)

{

#ifdef PTHREAD_KEY_T_IS_COMPATIBLE_WITH_INT

pthread_key_delete(key);

}

PyThread_delete_key_value(int key)

{

#ifdef PTHREAD_KEY_T_IS_COMPATIBLE_WITH_INT

pthread_setspecific(key, NULL);

}

PyThread_set_key_value(int key, void *value)

{

#ifdef PTHREAD_KEY_T_IS_COMPATIBLE_WITH_INT

int fail = pthread_setspecific(key, value);

return fail ? -1 : 0;

return -1;

}

void *

PyThread_get_key_value(int key)

{

#ifdef PTHREAD_KEY_T_IS_COMPATIBLE_WITH_INT

return pthread_getspecific(key);

return NULL;

}

PyThread_ReInitTLS(void)

{

}

PyThread_tss_create(Py_tss_t *key)

{

assert(key != NULL);

/* If the key has been created, function is silently skipped. */

if (key->_is_initialized) {

return 0;

}

int fail = pthread_key_create(&(key->_key), NULL);

if (fail) {

return -1;

}

key->_is_initialized = 1;

return 0;

}

PyThread_tss_delete(Py_tss_t *key)

{

assert(key != NULL);

/* If the key has not been created, function is silently skipped. */

if (!key->_is_initialized) {

return;

}

pthread_key_delete(key->_key);

/* pthread has not provided the defined invalid value for the key. */

key->_is_initialized = 0;

}

PyThread_tss_set(Py_tss_t *key, void *value)

{

assert(key != NULL);

int fail = pthread_setspecific(key->_key, value);

return fail ? -1 : 0;

}

void *

PyThread_tss_get(Py_tss_t *key)

{

assert(key != NULL);

return pthread_getspecific(key->_key);

}