#include "Python.h"

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

#include "pycore_lock.h"

#include "pycore_moduleobject.h" // _PyModule_GetState()

#include "pycore_modsupport.h" // _PyArg_NoKeywords()

#include "pycore_pylifecycle.h"

#include "pycore_pystate.h" // _PyThreadState_SetCurrent()

#include "pycore_sysmodule.h" // _PySys_GetAttr()

#include "pycore_time.h" // _PyTime_FromSeconds()

#include "pycore_weakref.h" // _PyWeakref_GET_REF()

#include <stddef.h> // offsetof()

#ifdef HAVE_SIGNAL_H

# include <signal.h> // SIGINT

#include "clinic/_threadmodule.c.h"

#define ThreadError PyExc_RuntimeError

static struct PyModuleDef thread_module;

typedef struct {

PyTypeObject *excepthook_type;

PyTypeObject *lock_type;

PyTypeObject *local_type;

PyTypeObject *local_dummy_type;

PyTypeObject *thread_handle_type;

// Linked list of handles to all non-daemon threads created by the

// threading module. We wait for these to finish at shutdown.

struct llist_node shutdown_handles;

} thread_module_state;

static inline thread_module_state*

get_thread_state(PyObject *module)

{

void *state = _PyModule_GetState(module);

assert(state != NULL);

return (thread_module_state *)state;

}

typedef enum {

THREAD_HANDLE_NOT_STARTED = 1,

THREAD_HANDLE_STARTING = 2,

THREAD_HANDLE_RUNNING = 3,

THREAD_HANDLE_DONE = 4,

} ThreadHandleState;

typedef struct {

struct llist_node node; // linked list node (see _pythread_runtime_state)

// linked list node (see thread_module_state)

struct llist_node shutdown_node;

// The `ident`, `os_handle`, `has_os_handle`, and `state` fields are

// protected by `mutex`.

PyThread_ident_t ident;

PyThread_handle_t os_handle;

int has_os_handle;

// Holds a value from the `ThreadHandleState` enum.

int state;

PyMutex mutex;

// Set immediately before `thread_run` returns to indicate that the OS

// thread is about to exit. This is used to avoid false positives when

// detecting self-join attempts. See the comment in `ThreadHandle_join()`

// for a more detailed explanation.

PyEvent thread_is_exiting;

// Serializes calls to `join` and `set_done`.

_PyOnceFlag once;

Py_ssize_t refcount;

} ThreadHandle;

static inline int

get_thread_handle_state(ThreadHandle *handle)

{

PyMutex_Lock(&handle->mutex);

int state = handle->state;

PyMutex_Unlock(&handle->mutex);

return state;

}

static inline void

set_thread_handle_state(ThreadHandle *handle, ThreadHandleState state)

{

PyMutex_Lock(&handle->mutex);

handle->state = state;

PyMutex_Unlock(&handle->mutex);

}

static PyThread_ident_t

ThreadHandle_ident(ThreadHandle *handle)

{

PyMutex_Lock(&handle->mutex);

PyThread_ident_t ident = handle->ident;

PyMutex_Unlock(&handle->mutex);

return ident;

}

static int

ThreadHandle_get_os_handle(ThreadHandle *handle, PyThread_handle_t *os_handle)

{

PyMutex_Lock(&handle->mutex);

int has_os_handle = handle->has_os_handle;

if (has_os_handle) {

*os_handle = handle->os_handle;

}

PyMutex_Unlock(&handle->mutex);

return has_os_handle;

}

static void

add_to_shutdown_handles(thread_module_state *state, ThreadHandle *handle)

{

HEAD_LOCK(&_PyRuntime);

llist_insert_tail(&state->shutdown_handles, &handle->shutdown_node);

HEAD_UNLOCK(&_PyRuntime);

}

static void

clear_shutdown_handles(thread_module_state *state)

{

HEAD_LOCK(&_PyRuntime);

struct llist_node *node;

llist_for_each_safe(node, &state->shutdown_handles) {

llist_remove(node);

}

HEAD_UNLOCK(&_PyRuntime);

}

static void

remove_from_shutdown_handles(ThreadHandle *handle)

{

HEAD_LOCK(&_PyRuntime);

if (handle->shutdown_node.next != NULL) {

llist_remove(&handle->shutdown_node);

}

HEAD_UNLOCK(&_PyRuntime);

}

static ThreadHandle *

ThreadHandle_new(void)

{

ThreadHandle *self =

(ThreadHandle *)PyMem_RawCalloc(1, sizeof(ThreadHandle));

if (self == NULL) {

PyErr_NoMemory();

return NULL;

}

self->ident = 0;

self->os_handle = 0;

self->has_os_handle = 0;

self->thread_is_exiting = (PyEvent){0};

self->mutex = (PyMutex){_Py_UNLOCKED};

self->once = (_PyOnceFlag){0};

self->state = THREAD_HANDLE_NOT_STARTED;

self->refcount = 1;

HEAD_LOCK(&_PyRuntime);

llist_insert_tail(&_PyRuntime.threads.handles, &self->node);

HEAD_UNLOCK(&_PyRuntime);

return self;

}

static void

ThreadHandle_incref(ThreadHandle *self)

{

_Py_atomic_add_ssize(&self->refcount, 1);

}

static int

detach_thread(ThreadHandle *self)

{

if (!self->has_os_handle) {

return 0;

}

// This is typically short so no need to release the GIL

if (PyThread_detach_thread(self->os_handle)) {

fprintf(stderr, "detach_thread: failed detaching thread\n");

return -1;

}

return 0;

}

static void

ThreadHandle_decref(ThreadHandle *self)

{

if (_Py_atomic_add_ssize(&self->refcount, -1) > 1) {

return;

}

// Remove ourself from the global list of handles

HEAD_LOCK(&_PyRuntime);

if (self->node.next != NULL) {

llist_remove(&self->node);

}

HEAD_UNLOCK(&_PyRuntime);

assert(self->shutdown_node.next == NULL);

// It's safe to access state non-atomically:

// 1. This is the destructor; nothing else holds a reference.

// 2. The refcount going to zero is a "synchronizes-with" event; all

// changes from other threads are visible.

if (self->state == THREAD_HANDLE_RUNNING && !detach_thread(self)) {

self->state = THREAD_HANDLE_DONE;

}

PyMem_RawFree(self);

}

_PyThread_AfterFork(struct _pythread_runtime_state *state)

{

// gh-115035: We mark ThreadHandles as not joinable early in the child's

// after-fork handler. We do this before calling any Python code to ensure

// that it happens before any ThreadHandles are deallocated, such as by a

// GC cycle.

PyThread_ident_t current = PyThread_get_thread_ident_ex();

struct llist_node *node;

llist_for_each_safe(node, &state->handles) {

ThreadHandle *handle = llist_data(node, ThreadHandle, node);

if (handle->ident == current) {

continue;

}

// Mark all threads as done. Any attempts to join or detach the

// underlying OS thread (if any) could crash. We are the only thread;

// it's safe to set this non-atomically.

handle->state = THREAD_HANDLE_DONE;

handle->once = (_PyOnceFlag){_Py_ONCE_INITIALIZED};

handle->mutex = (PyMutex){_Py_UNLOCKED};

_PyEvent_Notify(&handle->thread_is_exiting);

llist_remove(node);

remove_from_shutdown_handles(handle);

}

}

struct bootstate {

};

static void

thread_bootstate_free(struct bootstate *boot, int decref)

{

if (decref) {

Py_DECREF(boot->func);

Py_DECREF(boot->args);

Py_XDECREF(boot->kwargs);

}

ThreadHandle_decref(boot->handle);

PyMem_RawFree(boot);

}

static void

thread_run(void *boot_raw)

{

struct bootstate *boot = (struct bootstate *) boot_raw;

PyThreadState *tstate = boot->tstate;

// Wait until the handle is marked as running

PyEvent_Wait(&boot->handle_ready);

// `handle` needs to be manipulated after bootstate has been freed

ThreadHandle *handle = boot->handle;

ThreadHandle_incref(handle);

// gh-108987: If _thread.start_new_thread() is called before or while

// Python is being finalized, thread_run() can called *after*.

// _PyRuntimeState_SetFinalizing() is called. At this point, all Python

// threads must exit, except of the thread calling Py_Finalize() which

// holds the GIL and must not exit.

//

// At this stage, tstate can be a dangling pointer (point to freed memory),

// it's ok to call _PyThreadState_MustExit() with a dangling pointer.

if (_PyThreadState_MustExit(tstate)) {

// Don't call PyThreadState_Clear() nor _PyThreadState_DeleteCurrent().

// These functions are called on tstate indirectly by Py_Finalize()

// which calls _PyInterpreterState_Clear().

//

// Py_DECREF() cannot be called because the GIL is not held: leak

// references on purpose. Python is being finalized anyway.

thread_bootstate_free(boot, 0);

goto exit;

}

_PyThreadState_Bind(tstate);

PyEval_AcquireThread(tstate);

_Py_atomic_add_ssize(&tstate->interp->threads.count, 1);

PyObject *res = PyObject_Call(boot->func, boot->args, boot->kwargs);

if (res == NULL) {

if (PyErr_ExceptionMatches(PyExc_SystemExit))

/* SystemExit is ignored silently */

PyErr_Clear();

else {

PyErr_FormatUnraisable(

"Exception ignored in thread started by %R", boot->func);

}

}

else {

Py_DECREF(res);

}

thread_bootstate_free(boot, 1);

_Py_atomic_add_ssize(&tstate->interp->threads.count, -1);

PyThreadState_Clear(tstate);

_PyThreadState_DeleteCurrent(tstate);

exit:

// Don't need to wait for this thread anymore

remove_from_shutdown_handles(handle);

_PyEvent_Notify(&handle->thread_is_exiting);

ThreadHandle_decref(handle);

// bpo-44434: Don't call explicitly PyThread_exit_thread(). On Linux with

// the glibc, pthread_exit() can abort the whole process if dlopen() fails

// to open the libgcc_s.so library (ex: EMFILE error).

return;

}

static int

force_done(ThreadHandle *handle)

{

assert(get_thread_handle_state(handle) == THREAD_HANDLE_STARTING);

_PyEvent_Notify(&handle->thread_is_exiting);

set_thread_handle_state(handle, THREAD_HANDLE_DONE);

return 0;

}

static int

ThreadHandle_start(ThreadHandle *self, PyObject *func, PyObject *args,

PyObject *kwargs)

{

// Mark the handle as starting to prevent any other threads from doing so

PyMutex_Lock(&self->mutex);

if (self->state != THREAD_HANDLE_NOT_STARTED) {

PyMutex_Unlock(&self->mutex);

PyErr_SetString(ThreadError, "thread already started");

return -1;

}

self->state = THREAD_HANDLE_STARTING;

PyMutex_Unlock(&self->mutex);

// Do all the heavy lifting outside of the mutex. All other operations on

// the handle should fail since the handle is in the starting state.

// gh-109795: Use PyMem_RawMalloc() instead of PyMem_Malloc(),

// because it should be possible to call thread_bootstate_free()

// without holding the GIL.

struct bootstate *boot = PyMem_RawMalloc(sizeof(struct bootstate));

if (boot == NULL) {

PyErr_NoMemory();

goto start_failed;

}

PyInterpreterState *interp = _PyInterpreterState_GET();

boot->tstate = _PyThreadState_New(interp, _PyThreadState_WHENCE_THREADING);

if (boot->tstate == NULL) {

PyMem_RawFree(boot);

if (!PyErr_Occurred()) {

PyErr_NoMemory();

}

goto start_failed;

}

boot->func = Py_NewRef(func);

boot->args = Py_NewRef(args);

boot->kwargs = Py_XNewRef(kwargs);

boot->handle = self;

ThreadHandle_incref(self);

boot->handle_ready = (PyEvent){0};

PyThread_ident_t ident;

PyThread_handle_t os_handle;

if (PyThread_start_joinable_thread(thread_run, boot, &ident, &os_handle)) {

PyThreadState_Clear(boot->tstate);

PyThreadState_Delete(boot->tstate);

thread_bootstate_free(boot, 1);

PyErr_SetString(ThreadError, "can't start new thread");

goto start_failed;

}

// Mark the handle running

PyMutex_Lock(&self->mutex);

assert(self->state == THREAD_HANDLE_STARTING);

self->ident = ident;

self->has_os_handle = 1;

self->os_handle = os_handle;

self->state = THREAD_HANDLE_RUNNING;

PyMutex_Unlock(&self->mutex);

// Unblock the thread

_PyEvent_Notify(&boot->handle_ready);

return 0;

start_failed:

_PyOnceFlag_CallOnce(&self->once, (_Py_once_fn_t *)force_done, self);

return -1;

}

static int

join_thread(ThreadHandle *handle)

{

assert(get_thread_handle_state(handle) == THREAD_HANDLE_RUNNING);

PyThread_handle_t os_handle;

if (ThreadHandle_get_os_handle(handle, &os_handle)) {

int err = 0;

Py_BEGIN_ALLOW_THREADS

err = PyThread_join_thread(os_handle);

Py_END_ALLOW_THREADS

if (err) {

PyErr_SetString(ThreadError, "Failed joining thread");

return -1;

}

}

set_thread_handle_state(handle, THREAD_HANDLE_DONE);

return 0;

}

static int

check_started(ThreadHandle *self)

{

ThreadHandleState state = get_thread_handle_state(self);

if (state < THREAD_HANDLE_RUNNING) {

PyErr_SetString(ThreadError, "thread not started");

return -1;

}

return 0;

}

static int

ThreadHandle_join(ThreadHandle *self, PyTime_t timeout_ns)

{

if (check_started(self) < 0) {

return -1;

}

// We want to perform this check outside of the `_PyOnceFlag` to prevent

// deadlock in the scenario where another thread joins us and we then

// attempt to join ourselves. However, it's not safe to check thread

// identity once the handle's os thread has finished. We may end up reusing

// the identity stored in the handle and erroneously think we are

// attempting to join ourselves.

//

// To work around this, we set `thread_is_exiting` immediately before

// `thread_run` returns. We can be sure that we are not attempting to join

// ourselves if the handle's thread is about to exit.

if (!_PyEvent_IsSet(&self->thread_is_exiting) &&

ThreadHandle_ident(self) == PyThread_get_thread_ident_ex()) {

// PyThread_join_thread() would deadlock or error out.

PyErr_SetString(ThreadError, "Cannot join current thread");

return -1;

}

// Wait until the deadline for the thread to exit.

PyTime_t deadline = timeout_ns != -1 ? _PyDeadline_Init(timeout_ns) : 0;

int detach = 1;

while (!PyEvent_WaitTimed(&self->thread_is_exiting, timeout_ns, detach)) {

if (deadline) {

// _PyDeadline_Get will return a negative value if the deadline has

// been exceeded.

timeout_ns = Py_MAX(_PyDeadline_Get(deadline), 0);

}

if (timeout_ns) {

// Interrupted

if (Py_MakePendingCalls() < 0) {

return -1;

}

}

else {

// Timed out

return 0;

}

}

if (_PyOnceFlag_CallOnce(&self->once, (_Py_once_fn_t *)join_thread,

self) == -1) {

return -1;

}

assert(get_thread_handle_state(self) == THREAD_HANDLE_DONE);

return 0;

}

static int

set_done(ThreadHandle *handle)

{

assert(get_thread_handle_state(handle) == THREAD_HANDLE_RUNNING);

if (detach_thread(handle) < 0) {

PyErr_SetString(ThreadError, "failed detaching handle");

return -1;

}

_PyEvent_Notify(&handle->thread_is_exiting);

set_thread_handle_state(handle, THREAD_HANDLE_DONE);

return 0;

}

static int

ThreadHandle_set_done(ThreadHandle *self)

{

if (check_started(self) < 0) {

return -1;

}

if (_PyOnceFlag_CallOnce(&self->once, (_Py_once_fn_t *)set_done, self) ==

-1) {

return -1;

}

assert(get_thread_handle_state(self) == THREAD_HANDLE_DONE);

return 0;

}

typedef struct {

PyObject_HEAD

ThreadHandle *handle;

} PyThreadHandleObject;

static PyThreadHandleObject *

PyThreadHandleObject_new(PyTypeObject *type)

{

ThreadHandle *handle = ThreadHandle_new();

if (handle == NULL) {

return NULL;

}

PyThreadHandleObject *self =

(PyThreadHandleObject *)type->tp_alloc(type, 0);

if (self == NULL) {

ThreadHandle_decref(handle);

return NULL;

}

self->handle = handle;

return self;

}

static PyObject *

PyThreadHandleObject_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwds)

{

return (PyObject *)PyThreadHandleObject_new(type);

}

static int

PyThreadHandleObject_traverse(PyThreadHandleObject *self, visitproc visit,

void *arg)

{

Py_VISIT(Py_TYPE(self));

return 0;

}

static void

PyThreadHandleObject_dealloc(PyObject *op)

{

PyThreadHandleObject *self = (PyThreadHandleObject*)op;

PyObject_GC_UnTrack(self);

PyTypeObject *tp = Py_TYPE(self);

ThreadHandle_decref(self->handle);

tp->tp_free(self);

Py_DECREF(tp);

}

static PyObject *

PyThreadHandleObject_repr(PyObject *op)

{

PyThreadHandleObject *self = (PyThreadHandleObject*)op;

PyThread_ident_t ident = ThreadHandle_ident(self->handle);

return PyUnicode_FromFormat("<%s object: ident=%" PY_FORMAT_THREAD_IDENT_T ">",

Py_TYPE(self)->tp_name, ident);

}

static PyObject *

PyThreadHandleObject_get_ident(PyObject *op, void *Py_UNUSED(ignored))

{

PyThreadHandleObject *self = (PyThreadHandleObject*)op;

return PyLong_FromUnsignedLongLong(ThreadHandle_ident(self->handle));

}

static PyObject *

PyThreadHandleObject_join(PyObject *op, PyObject *args)

{

PyThreadHandleObject *self = (PyThreadHandleObject*)op;

PyObject *timeout_obj = NULL;

if (!PyArg_ParseTuple(args, "|O:join", &timeout_obj)) {

return NULL;

}

PyTime_t timeout_ns = -1;

if (timeout_obj != NULL && timeout_obj != Py_None) {

if (_PyTime_FromSecondsObject(&timeout_ns, timeout_obj,

_PyTime_ROUND_TIMEOUT) < 0) {

return NULL;

}

}

if (ThreadHandle_join(self->handle, timeout_ns) < 0) {

return NULL;

}

Py_RETURN_NONE;

}

static PyObject *

PyThreadHandleObject_is_done(PyObject *op, PyObject *Py_UNUSED(ignored))

{

PyThreadHandleObject *self = (PyThreadHandleObject*)op;

if (_PyEvent_IsSet(&self->handle->thread_is_exiting)) {

Py_RETURN_TRUE;

}

else {

Py_RETURN_FALSE;

}

}

static PyObject *

PyThreadHandleObject_set_done(PyObject *op, PyObject *Py_UNUSED(ignored))

{

PyThreadHandleObject *self = (PyThreadHandleObject*)op;

if (ThreadHandle_set_done(self->handle) < 0) {

return NULL;

}

Py_RETURN_NONE;

}

static PyGetSetDef ThreadHandle_getsetlist[] = {

{"ident", PyThreadHandleObject_get_ident, NULL, NULL},

{0},

};

static PyMethodDef ThreadHandle_methods[] = {

{"join", PyThreadHandleObject_join, METH_VARARGS, NULL},

{"_set_done", PyThreadHandleObject_set_done, METH_NOARGS, NULL},

{"is_done", PyThreadHandleObject_is_done, METH_NOARGS, NULL},

{0, 0}

};

static PyType_Slot ThreadHandle_Type_slots[] = {

{Py_tp_dealloc, PyThreadHandleObject_dealloc},

{Py_tp_repr, PyThreadHandleObject_repr},

{Py_tp_getset, ThreadHandle_getsetlist},

{Py_tp_traverse, PyThreadHandleObject_traverse},

{Py_tp_methods, ThreadHandle_methods},

{Py_tp_new, PyThreadHandleObject_tp_new},

{0, 0}

};

static PyType_Spec ThreadHandle_Type_spec = {

"_thread._ThreadHandle",

sizeof(PyThreadHandleObject),

0,

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_HAVE_GC,

ThreadHandle_Type_slots,

};

typedef struct {

PyObject_HEAD

PyMutex lock;

} lockobject;

static int

lock_traverse(PyObject *self, visitproc visit, void *arg)

{

Py_VISIT(Py_TYPE(self));

return 0;

}

static void

lock_dealloc(PyObject *op)

{

lockobject *self = (lockobject*)op;

PyObject_GC_UnTrack(self);

PyObject_ClearWeakRefs((PyObject *) self);

PyTypeObject *tp = Py_TYPE(self);

tp->tp_free((PyObject*)self);

Py_DECREF(tp);

}

static int

lock_acquire_parse_args(PyObject *args, PyObject *kwds,

PyTime_t *timeout)

{

char *kwlist[] = {"blocking", "timeout", NULL};

int blocking = 1;

PyObject *timeout_obj = NULL;

if (!PyArg_ParseTupleAndKeywords(args, kwds, "|pO:acquire", kwlist,

&blocking, &timeout_obj))

return -1;

// XXX Use PyThread_ParseTimeoutArg().

const PyTime_t unset_timeout = _PyTime_FromSeconds(-1);

*timeout = unset_timeout;

if (timeout_obj

&& _PyTime_FromSecondsObject(timeout,

timeout_obj, _PyTime_ROUND_TIMEOUT) < 0)

return -1;

if (!blocking && *timeout != unset_timeout ) {

PyErr_SetString(PyExc_ValueError,

"can't specify a timeout for a non-blocking call");

return -1;

}

if (*timeout < 0 && *timeout != unset_timeout) {

PyErr_SetString(PyExc_ValueError,

"timeout value must be a non-negative number");

return -1;

}

if (!blocking)

*timeout = 0;

else if (*timeout != unset_timeout) {

PyTime_t microseconds;

microseconds = _PyTime_AsMicroseconds(*timeout, _PyTime_ROUND_TIMEOUT);

if (microseconds > PY_TIMEOUT_MAX) {

PyErr_SetString(PyExc_OverflowError,

"timeout value is too large");

return -1;

}

}

return 0;

}

static PyObject *

lock_PyThread_acquire_lock(PyObject *op, PyObject *args, PyObject *kwds)

{

lockobject *self = (lockobject*)op;

PyTime_t timeout;

if (lock_acquire_parse_args(args, kwds, &timeout) < 0) {

return NULL;

}

PyLockStatus r = _PyMutex_LockTimed(&self->lock, timeout,

_PY_LOCK_HANDLE_SIGNALS | _PY_LOCK_DETACH);

if (r == PY_LOCK_INTR) {

return NULL;

}

return PyBool_FromLong(r == PY_LOCK_ACQUIRED);

}

PyDoc_STRVAR(acquire_doc,

The blocking operation is interruptible.");

PyDoc_STRVAR(acquire_lock_doc,

An obsolete synonym of acquire().");

PyDoc_STRVAR(enter_doc,

Lock the lock.");

static PyObject *

lock_PyThread_release_lock(PyObject *op, PyObject *Py_UNUSED(ignored))

{

lockobject *self = (lockobject*)op;

/* Sanity check: the lock must be locked */

if (_PyMutex_TryUnlock(&self->lock) < 0) {

PyErr_SetString(ThreadError, "release unlocked lock");

return NULL;

}

Py_RETURN_NONE;

}

PyDoc_STRVAR(release_doc,

but it needn't be locked by the same thread that unlocks it.");

PyDoc_STRVAR(release_lock_doc,

An obsolete synonym of release().");

PyDoc_STRVAR(lock_exit_doc,

Release the lock.");

static PyObject *

lock_locked_lock(PyObject *op, PyObject *Py_UNUSED(ignored))

{

lockobject *self = (lockobject*)op;

return PyBool_FromLong(PyMutex_IsLocked(&self->lock));

}

PyDoc_STRVAR(locked_doc,

Return whether the lock is in the locked state.");

PyDoc_STRVAR(locked_lock_doc,

An obsolete synonym of locked().");

static PyObject *

lock_repr(PyObject *op)

{

lockobject *self = (lockobject*)op;

return PyUnicode_FromFormat("<%s %s object at %p>",

PyMutex_IsLocked(&self->lock) ? "locked" : "unlocked", Py_TYPE(self)->tp_name, self);

}

#ifdef HAVE_FORK

static PyObject *

lock__at_fork_reinit(PyObject *op, PyObject *Py_UNUSED(args))

{

lockobject *self = (lockobject *)op;

_PyMutex_at_fork_reinit(&self->lock);

Py_RETURN_NONE;

}

#endif /* HAVE_FORK */

static lockobject *newlockobject(PyObject *module);

static PyObject *

lock_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)

{

// convert to AC?

if (!_PyArg_NoKeywords("lock", kwargs)) {

goto error;

}

if (!_PyArg_CheckPositional("lock", PyTuple_GET_SIZE(args), 0, 0)) {

goto error;

}

PyObject *module = PyType_GetModuleByDef(type, &thread_module);

assert(module != NULL);

return (PyObject *)newlockobject(module);

error:

return NULL;

}

static PyMethodDef lock_methods[] = {

{"acquire_lock", _PyCFunction_CAST(lock_PyThread_acquire_lock),

METH_VARARGS | METH_KEYWORDS, acquire_lock_doc},

{"acquire", _PyCFunction_CAST(lock_PyThread_acquire_lock),

METH_VARARGS | METH_KEYWORDS, acquire_doc},

{"release_lock", lock_PyThread_release_lock,

METH_NOARGS, release_lock_doc},

{"release", lock_PyThread_release_lock,

METH_NOARGS, release_doc},

{"locked_lock", lock_locked_lock,

METH_NOARGS, locked_lock_doc},

{"locked", lock_locked_lock,

METH_NOARGS, locked_doc},

{"__enter__", _PyCFunction_CAST(lock_PyThread_acquire_lock),

METH_VARARGS | METH_KEYWORDS, enter_doc},

{"__exit__", lock_PyThread_release_lock,

METH_VARARGS, lock_exit_doc},

#ifdef HAVE_FORK

{"_at_fork_reinit", lock__at_fork_reinit,

METH_NOARGS, NULL},

{NULL, NULL} /* sentinel */

};

PyDoc_STRVAR(lock_doc,

will block until another thread unlocks it. Deadlocks may ensue.");

static PyType_Slot lock_type_slots[] = {

{Py_tp_dealloc, lock_dealloc},

{Py_tp_repr, lock_repr},

{Py_tp_doc, (void *)lock_doc},

{Py_tp_methods, lock_methods},

{Py_tp_traverse, lock_traverse},

{Py_tp_new, lock_new},

{0, 0}

};

static PyType_Spec lock_type_spec = {

.name = "_thread.lock",

.basicsize = sizeof(lockobject),

.flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |

Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_MANAGED_WEAKREF),

.slots = lock_type_slots,

};

typedef struct {

PyObject_HEAD

_PyRecursiveMutex lock;

} rlockobject;

static int

rlock_traverse(rlockobject *self, visitproc visit, void *arg)

{

Py_VISIT(Py_TYPE(self));

return 0;

}

static void

rlock_dealloc(PyObject *op)

{

rlockobject *self = (rlockobject*)op;

PyObject_GC_UnTrack(self);

PyObject_ClearWeakRefs((PyObject *) self);

PyTypeObject *tp = Py_TYPE(self);

tp->tp_free(self);

Py_DECREF(tp);