Skip to content

gh-111178: Fix function signatures in _threadmodule.c#124964

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
vstinner merged 1 commit into from
Oct 4, 2024
Merged

gh-111178: Fix function signatures in _threadmodule.c #124964

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
119 changes: 70 additions & 49 deletions Modules/_threadmodule.c
View file
Open in desktop
Original file line numberDiff line numberDiff line change
Expand Up@@ -599,8 +599,9 @@ PyThreadHandleObject_traverse(PyThreadHandleObject *self, visitproc visit,
}

static void
PyThreadHandleObject_dealloc(PyThreadHandleObject *self)
PyThreadHandleObject_dealloc(PyObject *op)
{
PyThreadHandleObject *self = (PyThreadHandleObject*)op;
PyObject_GC_UnTrack(self);
PyTypeObject *tp = Py_TYPE(self);
ThreadHandle_decref(self->handle);
Expand All@@ -609,23 +610,26 @@ PyThreadHandleObject_dealloc(PyThreadHandleObject *self)
}

static PyObject *
PyThreadHandleObject_repr(PyThreadHandleObject *self)
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(PyThreadHandleObject *self,
PyObject *Py_UNUSED(ignored))
PyThreadHandleObject_get_ident(PyObject *op, void *Py_UNUSED(ignored))
{
PyThreadHandleObject *self = (PyThreadHandleObject*)op;
return PyLong_FromUnsignedLongLong(ThreadHandle_ident(self->handle));
}

static PyObject *
PyThreadHandleObject_join(PyThreadHandleObject *self, PyObject *args)
PyThreadHandleObject_join(PyObject *op, PyObject *args)
{
PyThreadHandleObject *self = (PyThreadHandleObject*)op;

PyObject *timeout_obj = NULL;
if (!PyArg_ParseTuple(args, "|O:join", &timeout_obj)) {
return NULL;
Expand All@@ -646,9 +650,9 @@ PyThreadHandleObject_join(PyThreadHandleObject *self, PyObject *args)
}

static PyObject *
PyThreadHandleObject_is_done(PyThreadHandleObject *self,
PyObject *Py_UNUSED(ignored))
PyThreadHandleObject_is_done(PyObject *op, PyObject *Py_UNUSED(ignored))
{
PyThreadHandleObject *self = (PyThreadHandleObject*)op;
if (_PyEvent_IsSet(&self->handle->thread_is_exiting)) {
Py_RETURN_TRUE;
}
Expand All@@ -658,30 +662,30 @@ PyThreadHandleObject_is_done(PyThreadHandleObject *self,
}

static PyObject *
PyThreadHandleObject_set_done(PyThreadHandleObject *self,
PyObject *Py_UNUSED(ignored))
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", (getter)PyThreadHandleObject_get_ident, NULL, NULL},
{"ident", PyThreadHandleObject_get_ident, NULL, NULL},
{0},
};

static PyMethodDef ThreadHandle_methods[] = {
{"join", (PyCFunction)PyThreadHandleObject_join, METH_VARARGS, NULL},
{"_set_done", (PyCFunction)PyThreadHandleObject_set_done, METH_NOARGS, NULL},
{"is_done", (PyCFunction)PyThreadHandleObject_is_done, METH_NOARGS, NULL},
{"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, (destructor)PyThreadHandleObject_dealloc},
{Py_tp_repr, (reprfunc)PyThreadHandleObject_repr},
{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},
Expand All@@ -707,15 +711,16 @@ typedef struct {
} lockobject;

static int
lock_traverse(lockobject *self, visitproc visit, void *arg)
lock_traverse(PyObject *self, visitproc visit, void *arg)
{
Py_VISIT(Py_TYPE(self));
return 0;
}

static void
lock_dealloc(lockobject *self)
lock_dealloc(PyObject *op)
{
lockobject *self = (lockobject*)op;
PyObject_GC_UnTrack(self);
if (self->in_weakreflist != NULL) {
PyObject_ClearWeakRefs((PyObject *) self);
Expand DownExpand Up@@ -784,11 +789,14 @@ lock_acquire_parse_args(PyObject *args, PyObject *kwds,
}

static PyObject *
lock_PyThread_acquire_lock(lockobject *self, PyObject *args, PyObject *kwds)
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)
if (lock_acquire_parse_args(args, kwds, &timeout) < 0) {
return NULL;
}

PyLockStatus r = acquire_timed(self->lock_lock, timeout);
if (r == PY_LOCK_INTR) {
Expand DownExpand Up@@ -824,8 +832,9 @@ PyDoc_STRVAR(enter_doc,
Lock the lock.");

static PyObject *
lock_PyThread_release_lock(lockobject *self, PyObject *Py_UNUSED(ignored))
lock_PyThread_release_lock(PyObject *op, PyObject *Py_UNUSED(ignored))
{
lockobject *self = (lockobject*)op;
/* Sanity check: the lock must be locked */
if (!self->locked) {
PyErr_SetString(ThreadError, "release unlocked lock");
Expand DownExpand Up@@ -858,8 +867,9 @@ PyDoc_STRVAR(lock_exit_doc,
Release the lock.");

static PyObject *
lock_locked_lock(lockobject *self, PyObject *Py_UNUSED(ignored))
lock_locked_lock(PyObject *op, PyObject *Py_UNUSED(ignored))
{
lockobject *self = (lockobject*)op;
return PyBool_FromLong((long)self->locked);
}

Expand All@@ -876,16 +886,18 @@ PyDoc_STRVAR(locked_lock_doc,
An obsolete synonym of locked().");

static PyObject *
lock_repr(lockobject *self)
lock_repr(PyObject *op)
{
lockobject *self = (lockobject*)op;
return PyUnicode_FromFormat("<%s %s object at %p>",
self->locked ? "locked" : "unlocked", Py_TYPE(self)->tp_name, self);
}

#ifdef HAVE_FORK
static PyObject *
lock__at_fork_reinit(lockobject *self, PyObject *Py_UNUSED(args))
lock__at_fork_reinit(PyObject *op, PyObject *Py_UNUSED(args))
{
lockobject *self = (lockobject*)op;
if (_PyThread_at_fork_reinit(&self->lock_lock) < 0) {
PyErr_SetString(ThreadError, "failed to reinitialize lock at fork");
return NULL;
Expand DownExpand Up@@ -924,20 +936,20 @@ static PyMethodDef lock_methods[] = {
METH_VARARGS | METH_KEYWORDS, acquire_lock_doc},
{"acquire", _PyCFunction_CAST(lock_PyThread_acquire_lock),
METH_VARARGS | METH_KEYWORDS, acquire_doc},
{"release_lock", (PyCFunction)lock_PyThread_release_lock,
{"release_lock", lock_PyThread_release_lock,
METH_NOARGS, release_lock_doc},
{"release", (PyCFunction)lock_PyThread_release_lock,
{"release", lock_PyThread_release_lock,
METH_NOARGS, release_doc},
{"locked_lock", (PyCFunction)lock_locked_lock,
{"locked_lock", lock_locked_lock,
METH_NOARGS, locked_lock_doc},
{"locked", (PyCFunction)lock_locked_lock,
{"locked", lock_locked_lock,
METH_NOARGS, locked_doc},
{"__enter__", _PyCFunction_CAST(lock_PyThread_acquire_lock),
METH_VARARGS | METH_KEYWORDS, enter_doc},
{"__exit__", (PyCFunction)lock_PyThread_release_lock,
{"__exit__", lock_PyThread_release_lock,
METH_VARARGS, lock_exit_doc},
#ifdef HAVE_FORK
{"_at_fork_reinit", (PyCFunction)lock__at_fork_reinit,
{"_at_fork_reinit", lock__at_fork_reinit,
METH_NOARGS, NULL},
#endif
{NULL, NULL} /* sentinel */
Expand All@@ -964,8 +976,8 @@ static PyMemberDef lock_type_members[] = {
};

static PyType_Slot lock_type_slots[] = {
{Py_tp_dealloc, (destructor)lock_dealloc},
{Py_tp_repr, (reprfunc)lock_repr},
{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},
Expand DownExpand Up@@ -1001,8 +1013,9 @@ rlock_traverse(rlockobject *self, visitproc visit, void *arg)


static void
rlock_dealloc(rlockobject *self)
rlock_dealloc(PyObject *op)
{
rlockobject *self = (rlockobject*)op;
PyObject_GC_UnTrack(self);
if (self->in_weakreflist != NULL)
PyObject_ClearWeakRefs((PyObject *) self);
Expand All@@ -1029,8 +1042,9 @@ rlock_is_owned_by(rlockobject *self, PyThread_ident_t tid)
}

static PyObject *
rlock_acquire(rlockobject *self, PyObject *args, PyObject *kwds)
rlock_acquire(PyObject *op, PyObject *args, PyObject *kwds)
{
rlockobject *self = (rlockobject*)op;
PyTime_t timeout;
PyThread_ident_t tid;
PyLockStatus r = PY_LOCK_ACQUIRED;
Expand DownExpand Up@@ -1086,8 +1100,9 @@ PyDoc_STRVAR(rlock_enter_doc,
Lock the lock.");

static PyObject *
rlock_release(rlockobject *self, PyObject *Py_UNUSED(ignored))
rlock_release(PyObject *op, PyObject *Py_UNUSED(ignored))
{
rlockobject *self = (rlockobject*)op;
PyThread_ident_t tid = PyThread_get_thread_ident_ex();

if (!rlock_is_owned_by(self, tid)) {
Expand DownExpand Up@@ -1122,8 +1137,9 @@ PyDoc_STRVAR(rlock_exit_doc,
Release the lock.");

static PyObject *
rlock_acquire_restore(rlockobject *self, PyObject *args)
rlock_acquire_restore(PyObject *op, PyObject *args)
{
rlockobject *self = (rlockobject*)op;
PyThread_ident_t owner;
unsigned long count;
int r = 1;
Expand DownExpand Up@@ -1154,8 +1170,9 @@ PyDoc_STRVAR(rlock_acquire_restore_doc,
For internal use by `threading.Condition`.");

static PyObject *
rlock_release_save(rlockobject *self, PyObject *Py_UNUSED(ignored))
rlock_release_save(PyObject *op, PyObject *Py_UNUSED(ignored))
{
rlockobject *self = (rlockobject*)op;
PyThread_ident_t owner;
unsigned long count;

Expand All@@ -1180,8 +1197,9 @@ PyDoc_STRVAR(rlock_release_save_doc,
For internal use by `threading.Condition`.");

static PyObject *
rlock_recursion_count(rlockobject *self, PyObject *Py_UNUSED(ignored))
rlock_recursion_count(PyObject *op, PyObject *Py_UNUSED(ignored))
{
rlockobject *self = (rlockobject*)op;
PyThread_ident_t tid = PyThread_get_thread_ident_ex();
PyThread_ident_t owner =
_Py_atomic_load_ullong_relaxed(&self->rlock_owner);
Expand All@@ -1195,8 +1213,9 @@ PyDoc_STRVAR(rlock_recursion_count_doc,
For internal use by reentrancy checks.");

static PyObject *
rlock_is_owned(rlockobject *self, PyObject *Py_UNUSED(ignored))
rlock_is_owned(PyObject *op, PyObject *Py_UNUSED(ignored))
{
rlockobject *self = (rlockobject*)op;
PyThread_ident_t tid = PyThread_get_thread_ident_ex();

if (rlock_is_owned_by(self, tid)) {
Expand DownExpand Up@@ -1232,8 +1251,9 @@ rlock_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
}

static PyObject *
rlock_repr(rlockobject *self)
rlock_repr(PyObject *op)
{
rlockobject *self = (rlockobject*)op;
PyThread_ident_t owner =
_Py_atomic_load_ullong_relaxed(&self->rlock_owner);
return PyUnicode_FromFormat(
Expand DownExpand Up@@ -1264,19 +1284,19 @@ rlock__at_fork_reinit(rlockobject *self, PyObject *Py_UNUSED(args))
static PyMethodDef rlock_methods[] = {
{"acquire", _PyCFunction_CAST(rlock_acquire),
METH_VARARGS | METH_KEYWORDS, rlock_acquire_doc},
{"release", (PyCFunction)rlock_release,
{"release", rlock_release,
METH_NOARGS, rlock_release_doc},
{"_is_owned", (PyCFunction)rlock_is_owned,
{"_is_owned", rlock_is_owned,
METH_NOARGS, rlock_is_owned_doc},
{"_acquire_restore", (PyCFunction)rlock_acquire_restore,
{"_acquire_restore", rlock_acquire_restore,
METH_VARARGS, rlock_acquire_restore_doc},
{"_release_save", (PyCFunction)rlock_release_save,
{"_release_save", rlock_release_save,
METH_NOARGS, rlock_release_save_doc},
{"_recursion_count", (PyCFunction)rlock_recursion_count,
{"_recursion_count", rlock_recursion_count,
METH_NOARGS, rlock_recursion_count_doc},
{"__enter__", _PyCFunction_CAST(rlock_acquire),
METH_VARARGS | METH_KEYWORDS, rlock_enter_doc},
{"__exit__", (PyCFunction)rlock_release,
{"__exit__", rlock_release,
METH_VARARGS, rlock_exit_doc},
#ifdef HAVE_FORK
{"_at_fork_reinit", (PyCFunction)rlock__at_fork_reinit,
Expand All@@ -1292,8 +1312,8 @@ static PyMemberDef rlock_type_members[] = {
};

static PyType_Slot rlock_type_slots[] = {
{Py_tp_dealloc, (destructor)rlock_dealloc},
{Py_tp_repr, (reprfunc)rlock_repr},
{Py_tp_dealloc, rlock_dealloc},
{Py_tp_repr, rlock_repr},
{Py_tp_methods, rlock_methods},
{Py_tp_alloc, PyType_GenericAlloc},
{Py_tp_new, rlock_new},
Expand DownExpand Up@@ -1392,8 +1412,9 @@ typedef struct {
} localdummyobject;

static void
localdummy_dealloc(localdummyobject *self)
localdummy_dealloc(PyObject *op)
{
localdummyobject *self = (localdummyobject*)op;
if (self->weakreflist != NULL)
PyObject_ClearWeakRefs((PyObject *) self);
PyTypeObject *tp = Py_TYPE(self);
Expand All@@ -1407,7 +1428,7 @@ static PyMemberDef local_dummy_type_members[] = {
};

static PyType_Slot local_dummy_type_slots[] = {
{Py_tp_dealloc, (destructor)localdummy_dealloc},
{Py_tp_dealloc, localdummy_dealloc},
{Py_tp_doc, "Thread-local dummy"},
{Py_tp_members, local_dummy_type_members},
{0, 0}
Expand Down