Branch data Line data Source code
1 : :
2 : : /* Thread module */
3 : : /* Interface to Sjoerd's portable C thread library */
4 : :
5 : : #include "Python.h"
6 : : #include "pycore_interp.h" // _PyInterpreterState.threads.count
7 : : #include "pycore_moduleobject.h" // _PyModule_GetState()
8 : : #include "pycore_pylifecycle.h"
9 : : #include "pycore_pystate.h" // _PyThreadState_SetCurrent()
10 : : #include <stddef.h> // offsetof()
11 : : #include "structmember.h" // PyMemberDef
12 : :
13 : : #ifdef HAVE_SIGNAL_H
14 : : # include <signal.h> // SIGINT
15 : : #endif
16 : :
17 : : // ThreadError is just an alias to PyExc_RuntimeError
18 : : #define ThreadError PyExc_RuntimeError
19 : :
20 : :
21 : : // Forward declarations
22 : : static struct PyModuleDef thread_module;
23 : :
24 : :
25 : : typedef struct {
26 : : PyTypeObject *excepthook_type;
27 : : PyTypeObject *lock_type;
28 : : PyTypeObject *local_type;
29 : : PyTypeObject *local_dummy_type;
30 : : } thread_module_state;
31 : :
32 : : static inline thread_module_state*
33 : 791612 : get_thread_state(PyObject *module)
34 : : {
35 : 791612 : void *state = _PyModule_GetState(module);
36 : : assert(state != NULL);
37 : 791612 : return (thread_module_state *)state;
38 : : }
39 : :
40 : :
41 : : /* Lock objects */
42 : :
43 : : typedef struct {
44 : : PyObject_HEAD
45 : : PyThread_type_lock lock_lock;
46 : : PyObject *in_weakreflist;
47 : : char locked; /* for sanity checking */
48 : : } lockobject;
49 : :
50 : : static int
51 : 729747 : lock_traverse(lockobject *self, visitproc visit, void *arg)
52 : : {
53 [ + - - + ]: 729747 : Py_VISIT(Py_TYPE(self));
54 : 729747 : return 0;
55 : : }
56 : :
57 : : static void
58 : 684346 : lock_dealloc(lockobject *self)
59 : : {
60 [ + + ]: 684346 : if (self->in_weakreflist != NULL) {
61 : 1834 : PyObject_ClearWeakRefs((PyObject *) self);
62 : : }
63 [ + - ]: 684346 : if (self->lock_lock != NULL) {
64 : : /* Unlock the lock so it's safe to free it */
65 [ + + ]: 684346 : if (self->locked)
66 : 40661 : PyThread_release_lock(self->lock_lock);
67 : 684346 : PyThread_free_lock(self->lock_lock);
68 : : }
69 : 684346 : PyTypeObject *tp = Py_TYPE(self);
70 : 684346 : tp->tp_free((PyObject*)self);
71 : 684346 : Py_DECREF(tp);
72 : 684346 : }
73 : :
74 : : /* Helper to acquire an interruptible lock with a timeout. If the lock acquire
75 : : * is interrupted, signal handlers are run, and if they raise an exception,
76 : : * PY_LOCK_INTR is returned. Otherwise, PY_LOCK_ACQUIRED or PY_LOCK_FAILURE
77 : : * are returned, depending on whether the lock can be acquired within the
78 : : * timeout.
79 : : */
80 : : static PyLockStatus
81 : 1828888 : acquire_timed(PyThread_type_lock lock, _PyTime_t timeout)
82 : : {
83 : 1828888 : _PyTime_t endtime = 0;
84 [ + + ]: 1828888 : if (timeout > 0) {
85 : 16133 : endtime = _PyDeadline_Init(timeout);
86 : : }
87 : :
88 : : PyLockStatus r;
89 : : do {
90 : : _PyTime_t microseconds;
91 : 1828929 : microseconds = _PyTime_AsMicroseconds(timeout, _PyTime_ROUND_CEILING);
92 : :
93 : : /* first a simple non-blocking try without releasing the GIL */
94 : 1828929 : r = PyThread_acquire_lock_timed(lock, 0, 0);
95 [ + + + + ]: 1828929 : if (r == PY_LOCK_FAILURE && microseconds != 0) {
96 : 47393 : Py_BEGIN_ALLOW_THREADS
97 : 47393 : r = PyThread_acquire_lock_timed(lock, microseconds, 1);
98 : 47038 : Py_END_ALLOW_THREADS
99 : : }
100 : :
101 [ + + ]: 1828926 : if (r == PY_LOCK_INTR) {
102 : : /* Run signal handlers if we were interrupted. Propagate
103 : : * exceptions from signal handlers, such as KeyboardInterrupt, by
104 : : * passing up PY_LOCK_INTR. */
105 [ + + ]: 43 : if (Py_MakePendingCalls() < 0) {
106 : 2 : return PY_LOCK_INTR;
107 : : }
108 : :
109 : : /* If we're using a timeout, recompute the timeout after processing
110 : : * signals, since those can take time. */
111 [ + + ]: 41 : if (timeout > 0) {
112 : 24 : timeout = _PyDeadline_Get(endtime);
113 : :
114 : : /* Check for negative values, since those mean block forever.
115 : : */
116 [ - + ]: 24 : if (timeout < 0) {
117 : 0 : r = PY_LOCK_FAILURE;
118 : : }
119 : : }
120 : : }
121 [ + + ]: 1828924 : } while (r == PY_LOCK_INTR); /* Retry if we were interrupted. */
122 : :
123 : 1828883 : return r;
124 : : }
125 : :
126 : : static int
127 : 1833867 : lock_acquire_parse_args(PyObject *args, PyObject *kwds,
128 : : _PyTime_t *timeout)
129 : : {
130 : 1833867 : char *kwlist[] = {"blocking", "timeout", NULL};
131 : 1833867 : int blocking = 1;
132 : 1833867 : PyObject *timeout_obj = NULL;
133 : 1833867 : const _PyTime_t unset_timeout = _PyTime_FromSeconds(-1);
134 : :
135 : 1833867 : *timeout = unset_timeout ;
136 : :
137 [ - + ]: 1833867 : if (!PyArg_ParseTupleAndKeywords(args, kwds, "|iO:acquire", kwlist,
138 : : &blocking, &timeout_obj))
139 : 0 : return -1;
140 : :
141 [ + + ]: 1833867 : if (timeout_obj
142 [ + + ]: 21994 : && _PyTime_FromSecondsObject(timeout,
143 : : timeout_obj, _PyTime_ROUND_TIMEOUT) < 0)
144 : 10 : return -1;
145 : :
146 [ + + + + ]: 1833857 : if (!blocking && *timeout != unset_timeout ) {
147 : 5 : PyErr_SetString(PyExc_ValueError,
148 : : "can't specify a timeout for a non-blocking call");
149 : 5 : return -1;
150 : : }
151 [ + + + + ]: 1833852 : if (*timeout < 0 && *timeout != unset_timeout) {
152 : 5 : PyErr_SetString(PyExc_ValueError,
153 : : "timeout value must be positive");
154 : 5 : return -1;
155 : : }
156 [ + + ]: 1833847 : if (!blocking)
157 : 191760 : *timeout = 0;
158 [ + + ]: 1642087 : else if (*timeout != unset_timeout) {
159 : : _PyTime_t microseconds;
160 : :
161 : 16134 : microseconds = _PyTime_AsMicroseconds(*timeout, _PyTime_ROUND_TIMEOUT);
162 [ - + ]: 16134 : if (microseconds > PY_TIMEOUT_MAX) {
163 : 0 : PyErr_SetString(PyExc_OverflowError,
164 : : "timeout value is too large");
165 : 0 : return -1;
166 : : }
167 : : }
168 : 1833847 : return 0;
169 : : }
170 : :
171 : : static PyObject *
172 : 1735729 : lock_PyThread_acquire_lock(lockobject *self, PyObject *args, PyObject *kwds)
173 : : {
174 : : _PyTime_t timeout;
175 [ + + ]: 1735729 : if (lock_acquire_parse_args(args, kwds, &timeout) < 0)
176 : 12 : return NULL;
177 : :
178 : 1735717 : PyLockStatus r = acquire_timed(self->lock_lock, timeout);
179 [ + + ]: 1735714 : if (r == PY_LOCK_INTR) {
180 : 1 : return NULL;
181 : : }
182 : :
183 [ + + ]: 1735713 : if (r == PY_LOCK_ACQUIRED)
184 : 1600325 : self->locked = 1;
185 : 1735713 : return PyBool_FromLong(r == PY_LOCK_ACQUIRED);
186 : : }
187 : :
188 : : PyDoc_STRVAR(acquire_doc,
189 : : "acquire(blocking=True, timeout=-1) -> bool\n\
190 : : (acquire_lock() is an obsolete synonym)\n\
191 : : \n\
192 : : Lock the lock. Without argument, this blocks if the lock is already\n\
193 : : locked (even by the same thread), waiting for another thread to release\n\
194 : : the lock, and return True once the lock is acquired.\n\
195 : : With an argument, this will only block if the argument is true,\n\
196 : : and the return value reflects whether the lock is acquired.\n\
197 : : The blocking operation is interruptible.");
198 : :
199 : : static PyObject *
200 : 1552309 : lock_PyThread_release_lock(lockobject *self, PyObject *Py_UNUSED(ignored))
201 : : {
202 : : /* Sanity check: the lock must be locked */
203 [ + + ]: 1552309 : if (!self->locked) {
204 : 6 : PyErr_SetString(ThreadError, "release unlocked lock");
205 : 6 : return NULL;
206 : : }
207 : :
208 : 1552303 : PyThread_release_lock(self->lock_lock);
209 : 1552303 : self->locked = 0;
210 : 1552303 : Py_RETURN_NONE;
211 : : }
212 : :
213 : : PyDoc_STRVAR(release_doc,
214 : : "release()\n\
215 : : (release_lock() is an obsolete synonym)\n\
216 : : \n\
217 : : Release the lock, allowing another thread that is blocked waiting for\n\
218 : : the lock to acquire the lock. The lock must be in the locked state,\n\
219 : : but it needn't be locked by the same thread that unlocks it.");
220 : :
221 : : static PyObject *
222 : 39715 : lock_locked_lock(lockobject *self, PyObject *Py_UNUSED(ignored))
223 : : {
224 : 39715 : return PyBool_FromLong((long)self->locked);
225 : : }
226 : :
227 : : PyDoc_STRVAR(locked_doc,
228 : : "locked() -> bool\n\
229 : : (locked_lock() is an obsolete synonym)\n\
230 : : \n\
231 : : Return whether the lock is in the locked state.");
232 : :
233 : : static PyObject *
234 : 8 : lock_repr(lockobject *self)
235 : : {
236 : 8 : return PyUnicode_FromFormat("<%s %s object at %p>",
237 [ + + ]: 8 : self->locked ? "locked" : "unlocked", Py_TYPE(self)->tp_name, self);
238 : : }
239 : :
240 : : #ifdef HAVE_FORK
241 : : static PyObject *
242 : 16 : lock__at_fork_reinit(lockobject *self, PyObject *Py_UNUSED(args))
243 : : {
244 [ - + ]: 16 : if (_PyThread_at_fork_reinit(&self->lock_lock) < 0) {
245 : 0 : PyErr_SetString(ThreadError, "failed to reinitialize lock at fork");
246 : 0 : return NULL;
247 : : }
248 : :
249 : 16 : self->locked = 0;
250 : :
251 : 16 : Py_RETURN_NONE;
252 : : }
253 : : #endif /* HAVE_FORK */
254 : :
255 : :
256 : : static PyMethodDef lock_methods[] = {
257 : : {"acquire_lock", _PyCFunction_CAST(lock_PyThread_acquire_lock),
258 : : METH_VARARGS | METH_KEYWORDS, acquire_doc},
259 : : {"acquire", _PyCFunction_CAST(lock_PyThread_acquire_lock),
260 : : METH_VARARGS | METH_KEYWORDS, acquire_doc},
261 : : {"release_lock", (PyCFunction)lock_PyThread_release_lock,
262 : : METH_NOARGS, release_doc},
263 : : {"release", (PyCFunction)lock_PyThread_release_lock,
264 : : METH_NOARGS, release_doc},
265 : : {"locked_lock", (PyCFunction)lock_locked_lock,
266 : : METH_NOARGS, locked_doc},
267 : : {"locked", (PyCFunction)lock_locked_lock,
268 : : METH_NOARGS, locked_doc},
269 : : {"__enter__", _PyCFunction_CAST(lock_PyThread_acquire_lock),
270 : : METH_VARARGS | METH_KEYWORDS, acquire_doc},
271 : : {"__exit__", (PyCFunction)lock_PyThread_release_lock,
272 : : METH_VARARGS, release_doc},
273 : : #ifdef HAVE_FORK
274 : : {"_at_fork_reinit", (PyCFunction)lock__at_fork_reinit,
275 : : METH_NOARGS, NULL},
276 : : #endif
277 : : {NULL, NULL} /* sentinel */
278 : : };
279 : :
280 : : PyDoc_STRVAR(lock_doc,
281 : : "A lock object is a synchronization primitive. To create a lock,\n\
282 : : call threading.Lock(). Methods are:\n\
283 : : \n\
284 : : acquire() -- lock the lock, possibly blocking until it can be obtained\n\
285 : : release() -- unlock of the lock\n\
286 : : locked() -- test whether the lock is currently locked\n\
287 : : \n\
288 : : A lock is not owned by the thread that locked it; another thread may\n\
289 : : unlock it. A thread attempting to lock a lock that it has already locked\n\
290 : : will block until another thread unlocks it. Deadlocks may ensue.");
291 : :
292 : : static PyMemberDef lock_type_members[] = {
293 : : {"__weaklistoffset__", T_PYSSIZET, offsetof(lockobject, in_weakreflist), READONLY},
294 : : {NULL},
295 : : };
296 : :
297 : : static PyType_Slot lock_type_slots[] = {
298 : : {Py_tp_dealloc, (destructor)lock_dealloc},
299 : : {Py_tp_repr, (reprfunc)lock_repr},
300 : : {Py_tp_doc, (void *)lock_doc},
301 : : {Py_tp_methods, lock_methods},
302 : : {Py_tp_traverse, lock_traverse},
303 : : {Py_tp_members, lock_type_members},
304 : : {0, 0}
305 : : };
306 : :
307 : : static PyType_Spec lock_type_spec = {
308 : : .name = "_thread.lock",
309 : : .basicsize = sizeof(lockobject),
310 : : .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
311 : : Py_TPFLAGS_DISALLOW_INSTANTIATION | Py_TPFLAGS_IMMUTABLETYPE),
312 : : .slots = lock_type_slots,
313 : : };
314 : :
315 : : /* Recursive lock objects */
316 : :
317 : : typedef struct {
318 : : PyObject_HEAD
319 : : PyThread_type_lock rlock_lock;
320 : : unsigned long rlock_owner;
321 : : unsigned long rlock_count;
322 : : PyObject *in_weakreflist;
323 : : } rlockobject;
324 : :
325 : : static int
326 : 764365 : rlock_traverse(rlockobject *self, visitproc visit, void *arg)
327 : : {
328 [ + - - + ]: 764365 : Py_VISIT(Py_TYPE(self));
329 : 764365 : return 0;
330 : : }
331 : :
332 : :
333 : : static void
334 : 16077 : rlock_dealloc(rlockobject *self)
335 : : {
336 [ + + ]: 16077 : if (self->in_weakreflist != NULL)
337 : 2 : PyObject_ClearWeakRefs((PyObject *) self);
338 : : /* self->rlock_lock can be NULL if PyThread_allocate_lock() failed
339 : : in rlock_new() */
340 [ + - ]: 16077 : if (self->rlock_lock != NULL) {
341 : : /* Unlock the lock so it's safe to free it */
342 [ + + ]: 16077 : if (self->rlock_count > 0)
343 : 11 : PyThread_release_lock(self->rlock_lock);
344 : :
345 : 16077 : PyThread_free_lock(self->rlock_lock);
346 : : }
347 : 16077 : PyTypeObject *tp = Py_TYPE(self);
348 : 16077 : tp->tp_free(self);
349 : 16077 : Py_DECREF(tp);
350 : 16077 : }
351 : :
352 : : static PyObject *
353 : 98138 : rlock_acquire(rlockobject *self, PyObject *args, PyObject *kwds)
354 : : {
355 : : _PyTime_t timeout;
356 : : unsigned long tid;
357 : 98138 : PyLockStatus r = PY_LOCK_ACQUIRED;
358 : :
359 [ + + ]: 98138 : if (lock_acquire_parse_args(args, kwds, &timeout) < 0)
360 : 8 : return NULL;
361 : :
362 : 98130 : tid = PyThread_get_thread_ident();
363 [ + + + + ]: 98130 : if (self->rlock_count > 0 && tid == self->rlock_owner) {
364 : 4959 : unsigned long count = self->rlock_count + 1;
365 [ - + ]: 4959 : if (count <= self->rlock_count) {
366 : 0 : PyErr_SetString(PyExc_OverflowError,
367 : : "Internal lock count overflowed");
368 : 0 : return NULL;
369 : : }
370 : 4959 : self->rlock_count = count;
371 : 4959 : Py_RETURN_TRUE;
372 : : }
373 : 93171 : r = acquire_timed(self->rlock_lock, timeout);
374 [ + + ]: 93171 : if (r == PY_LOCK_ACQUIRED) {
375 : : assert(self->rlock_count == 0);
376 : 93164 : self->rlock_owner = tid;
377 : 93164 : self->rlock_count = 1;
378 : : }
379 [ + + ]: 7 : else if (r == PY_LOCK_INTR) {
380 : 1 : return NULL;
381 : : }
382 : :
383 : 93170 : return PyBool_FromLong(r == PY_LOCK_ACQUIRED);
384 : : }
385 : :
386 : : PyDoc_STRVAR(rlock_acquire_doc,
387 : : "acquire(blocking=True) -> bool\n\
388 : : \n\
389 : : Lock the lock. `blocking` indicates whether we should wait\n\
390 : : for the lock to be available or not. If `blocking` is False\n\
391 : : and another thread holds the lock, the method will return False\n\
392 : : immediately. If `blocking` is True and another thread holds\n\
393 : : the lock, the method will wait for the lock to be released,\n\
394 : : take it and then return True.\n\
395 : : (note: the blocking operation is interruptible.)\n\
396 : : \n\
397 : : In all other cases, the method will return True immediately.\n\
398 : : Precisely, if the current thread already holds the lock, its\n\
399 : : internal counter is simply incremented. If nobody holds the lock,\n\
400 : : the lock is taken and its internal counter initialized to 1.");
401 : :
402 : : static PyObject *
403 : 98122 : rlock_release(rlockobject *self, PyObject *Py_UNUSED(ignored))
404 : : {
405 : 98122 : unsigned long tid = PyThread_get_thread_ident();
406 : :
407 [ + + - + ]: 98122 : if (self->rlock_count == 0 || self->rlock_owner != tid) {
408 : 10 : PyErr_SetString(PyExc_RuntimeError,
409 : : "cannot release un-acquired lock");
410 : 10 : return NULL;
411 : : }
412 [ + + ]: 98112 : if (--self->rlock_count == 0) {
413 : 93153 : self->rlock_owner = 0;
414 : 93153 : PyThread_release_lock(self->rlock_lock);
415 : : }
416 : 98112 : Py_RETURN_NONE;
417 : : }
418 : :
419 : : PyDoc_STRVAR(rlock_release_doc,
420 : : "release()\n\
421 : : \n\
422 : : Release the lock, allowing another thread that is blocked waiting for\n\
423 : : the lock to acquire the lock. The lock must be in the locked state,\n\
424 : : and must be locked by the same thread that unlocks it; otherwise a\n\
425 : : `RuntimeError` is raised.\n\
426 : : \n\
427 : : Do note that if the lock was acquire()d several times in a row by the\n\
428 : : current thread, release() needs to be called as many times for the lock\n\
429 : : to be available for other threads.");
430 : :
431 : : static PyObject *
432 : 409 : rlock_acquire_restore(rlockobject *self, PyObject *args)
433 : : {
434 : : unsigned long owner;
435 : : unsigned long count;
436 : 409 : int r = 1;
437 : :
438 [ - + ]: 409 : if (!PyArg_ParseTuple(args, "(kk):_acquire_restore", &count, &owner))
439 : 0 : return NULL;
440 : :
441 [ + + ]: 409 : if (!PyThread_acquire_lock(self->rlock_lock, 0)) {
442 : 43 : Py_BEGIN_ALLOW_THREADS
443 : 43 : r = PyThread_acquire_lock(self->rlock_lock, 1);
444 : 43 : Py_END_ALLOW_THREADS
445 : : }
446 [ - + ]: 409 : if (!r) {
447 : 0 : PyErr_SetString(ThreadError, "couldn't acquire lock");
448 : 0 : return NULL;
449 : : }
450 : : assert(self->rlock_count == 0);
451 : 409 : self->rlock_owner = owner;
452 : 409 : self->rlock_count = count;
453 : 409 : Py_RETURN_NONE;
454 : : }
455 : :
456 : : PyDoc_STRVAR(rlock_acquire_restore_doc,
457 : : "_acquire_restore(state) -> None\n\
458 : : \n\
459 : : For internal use by `threading.Condition`.");
460 : :
461 : : static PyObject *
462 : 413 : rlock_release_save(rlockobject *self, PyObject *Py_UNUSED(ignored))
463 : : {
464 : : unsigned long owner;
465 : : unsigned long count;
466 : :
467 [ + + ]: 413 : if (self->rlock_count == 0) {
468 : 4 : PyErr_SetString(PyExc_RuntimeError,
469 : : "cannot release un-acquired lock");
470 : 4 : return NULL;
471 : : }
472 : :
473 : 409 : owner = self->rlock_owner;
474 : 409 : count = self->rlock_count;
475 : 409 : self->rlock_count = 0;
476 : 409 : self->rlock_owner = 0;
477 : 409 : PyThread_release_lock(self->rlock_lock);
478 : 409 : return Py_BuildValue("kk", count, owner);
479 : : }
480 : :
481 : : PyDoc_STRVAR(rlock_release_save_doc,
482 : : "_release_save() -> tuple\n\
483 : : \n\
484 : : For internal use by `threading.Condition`.");
485 : :
486 : :
487 : : static PyObject *
488 : 10221 : rlock_is_owned(rlockobject *self, PyObject *Py_UNUSED(ignored))
489 : : {
490 : 10221 : unsigned long tid = PyThread_get_thread_ident();
491 : :
492 [ + + + + ]: 10221 : if (self->rlock_count > 0 && self->rlock_owner == tid) {
493 : 10207 : Py_RETURN_TRUE;
494 : : }
495 : 14 : Py_RETURN_FALSE;
496 : : }
497 : :
498 : : PyDoc_STRVAR(rlock_is_owned_doc,
499 : : "_is_owned() -> bool\n\
500 : : \n\
501 : : For internal use by `threading.Condition`.");
502 : :
503 : : static PyObject *
504 : 16079 : rlock_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
505 : : {
506 : 16079 : rlockobject *self = (rlockobject *) type->tp_alloc(type, 0);
507 [ - + ]: 16079 : if (self == NULL) {
508 : 0 : return NULL;
509 : : }
510 : 16079 : self->in_weakreflist = NULL;
511 : 16079 : self->rlock_owner = 0;
512 : 16079 : self->rlock_count = 0;
513 : :
514 : 16079 : self->rlock_lock = PyThread_allocate_lock();
515 [ - + ]: 16079 : if (self->rlock_lock == NULL) {
516 : 0 : Py_DECREF(self);
517 : 0 : PyErr_SetString(ThreadError, "can't allocate lock");
518 : 0 : return NULL;
519 : : }
520 : 16079 : return (PyObject *) self;
521 : : }
522 : :
523 : : static PyObject *
524 : 4 : rlock_repr(rlockobject *self)
525 : : {
526 : 4 : return PyUnicode_FromFormat("<%s %s object owner=%ld count=%lu at %p>",
527 [ + + ]: 4 : self->rlock_count ? "locked" : "unlocked",
528 : 4 : Py_TYPE(self)->tp_name, self->rlock_owner,
529 : : self->rlock_count, self);
530 : : }
531 : :
532 : :
533 : : #ifdef HAVE_FORK
534 : : static PyObject *
535 : 0 : rlock__at_fork_reinit(rlockobject *self, PyObject *Py_UNUSED(args))
536 : : {
537 [ # # ]: 0 : if (_PyThread_at_fork_reinit(&self->rlock_lock) < 0) {
538 : 0 : PyErr_SetString(ThreadError, "failed to reinitialize lock at fork");
539 : 0 : return NULL;
540 : : }
541 : :
542 : 0 : self->rlock_owner = 0;
543 : 0 : self->rlock_count = 0;
544 : :
545 : 0 : Py_RETURN_NONE;
546 : : }
547 : : #endif /* HAVE_FORK */
548 : :
549 : :
550 : : static PyMethodDef rlock_methods[] = {
551 : : {"acquire", _PyCFunction_CAST(rlock_acquire),
552 : : METH_VARARGS | METH_KEYWORDS, rlock_acquire_doc},
553 : : {"release", (PyCFunction)rlock_release,
554 : : METH_NOARGS, rlock_release_doc},
555 : : {"_is_owned", (PyCFunction)rlock_is_owned,
556 : : METH_NOARGS, rlock_is_owned_doc},
557 : : {"_acquire_restore", (PyCFunction)rlock_acquire_restore,
558 : : METH_VARARGS, rlock_acquire_restore_doc},
559 : : {"_release_save", (PyCFunction)rlock_release_save,
560 : : METH_NOARGS, rlock_release_save_doc},
561 : : {"__enter__", _PyCFunction_CAST(rlock_acquire),
562 : : METH_VARARGS | METH_KEYWORDS, rlock_acquire_doc},
563 : : {"__exit__", (PyCFunction)rlock_release,
564 : : METH_VARARGS, rlock_release_doc},
565 : : #ifdef HAVE_FORK
566 : : {"_at_fork_reinit", (PyCFunction)rlock__at_fork_reinit,
567 : : METH_NOARGS, NULL},
568 : : #endif
569 : : {NULL, NULL} /* sentinel */
570 : : };
571 : :
572 : :
573 : : static PyMemberDef rlock_type_members[] = {
574 : : {"__weaklistoffset__", T_PYSSIZET, offsetof(rlockobject, in_weakreflist), READONLY},
575 : : {NULL},
576 : : };
577 : :
578 : : static PyType_Slot rlock_type_slots[] = {
579 : : {Py_tp_dealloc, (destructor)rlock_dealloc},
580 : : {Py_tp_repr, (reprfunc)rlock_repr},
581 : : {Py_tp_methods, rlock_methods},
582 : : {Py_tp_alloc, PyType_GenericAlloc},
583 : : {Py_tp_new, rlock_new},
584 : : {Py_tp_members, rlock_type_members},
585 : : {Py_tp_traverse, rlock_traverse},
586 : : {0, 0},
587 : : };
588 : :
589 : : static PyType_Spec rlock_type_spec = {
590 : : .name = "_thread.RLock",
591 : : .basicsize = sizeof(rlockobject),
592 : : .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE |
593 : : Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_IMMUTABLETYPE),
594 : : .slots = rlock_type_slots,
595 : : };
596 : :
597 : : static lockobject *
598 : 684761 : newlockobject(PyObject *module)
599 : : {
600 : 684761 : thread_module_state *state = get_thread_state(module);
601 : :
602 : 684761 : PyTypeObject *type = state->lock_type;
603 : 684761 : lockobject *self = (lockobject *)type->tp_alloc(type, 0);
604 [ - + ]: 684761 : if (self == NULL) {
605 : 0 : return NULL;
606 : : }
607 : :
608 : 684761 : self->lock_lock = PyThread_allocate_lock();
609 : 684761 : self->locked = 0;
610 : 684761 : self->in_weakreflist = NULL;
611 : :
612 [ - + ]: 684761 : if (self->lock_lock == NULL) {
613 : 0 : Py_DECREF(self);
614 : 0 : PyErr_SetString(ThreadError, "can't allocate lock");
615 : 0 : return NULL;
616 : : }
617 : 684761 : return self;
618 : : }
619 : :
620 : : /* Thread-local objects */
621 : :
622 : : /* Quick overview:
623 : :
624 : : We need to be able to reclaim reference cycles as soon as possible
625 : : (both when a thread is being terminated, or a thread-local object
626 : : becomes unreachable from user data). Constraints:
627 : : - it must not be possible for thread-state dicts to be involved in
628 : : reference cycles (otherwise the cyclic GC will refuse to consider
629 : : objects referenced from a reachable thread-state dict, even though
630 : : local_dealloc would clear them)
631 : : - the death of a thread-state dict must still imply destruction of the
632 : : corresponding local dicts in all thread-local objects.
633 : :
634 : : Our implementation uses small "localdummy" objects in order to break
635 : : the reference chain. These trivial objects are hashable (using the
636 : : default scheme of identity hashing) and weakrefable.
637 : : Each thread-state holds a separate localdummy for each local object
638 : : (as a /strong reference/),
639 : : and each thread-local object holds a dict mapping /weak references/
640 : : of localdummies to local dicts.
641 : :
642 : : Therefore:
643 : : - only the thread-state dict holds a strong reference to the dummies
644 : : - only the thread-local object holds a strong reference to the local dicts
645 : : - only outside objects (application- or library-level) hold strong
646 : : references to the thread-local objects
647 : : - as soon as a thread-state dict is destroyed, the weakref callbacks of all
648 : : dummies attached to that thread are called, and destroy the corresponding
649 : : local dicts from thread-local objects
650 : : - as soon as a thread-local object is destroyed, its local dicts are
651 : : destroyed and its dummies are manually removed from all thread states
652 : : - the GC can do its work correctly when a thread-local object is dangling,
653 : : without any interference from the thread-state dicts
654 : :
655 : : As an additional optimization, each localdummy holds a borrowed reference
656 : : to the corresponding localdict. This borrowed reference is only used
657 : : by the thread-local object which has created the localdummy, which should
658 : : guarantee that the localdict still exists when accessed.
659 : : */
660 : :
661 : : typedef struct {
662 : : PyObject_HEAD
663 : : PyObject *localdict; /* Borrowed reference! */
664 : : PyObject *weakreflist; /* List of weak references to self */
665 : : } localdummyobject;
666 : :
667 : : static void
668 : 1668 : localdummy_dealloc(localdummyobject *self)
669 : : {
670 [ + + ]: 1668 : if (self->weakreflist != NULL)
671 : 259 : PyObject_ClearWeakRefs((PyObject *) self);
672 : 1668 : PyTypeObject *tp = Py_TYPE(self);
673 : 1668 : tp->tp_free((PyObject*)self);
674 : 1668 : Py_DECREF(tp);
675 : 1668 : }
676 : :
677 : : static PyMemberDef local_dummy_type_members[] = {
678 : : {"__weaklistoffset__", T_PYSSIZET, offsetof(localdummyobject, weakreflist), READONLY},
679 : : {NULL},
680 : : };
681 : :
682 : : static PyType_Slot local_dummy_type_slots[] = {
683 : : {Py_tp_dealloc, (destructor)localdummy_dealloc},
684 : : {Py_tp_doc, "Thread-local dummy"},
685 : : {Py_tp_members, local_dummy_type_members},
686 : : {0, 0}
687 : : };
688 : :
689 : : static PyType_Spec local_dummy_type_spec = {
690 : : .name = "_thread._localdummy",
691 : : .basicsize = sizeof(localdummyobject),
692 : : .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION |
693 : : Py_TPFLAGS_IMMUTABLETYPE),
694 : : .slots = local_dummy_type_slots,
695 : : };
696 : :
697 : :
698 : : typedef struct {
699 : : PyObject_HEAD
700 : : PyObject *key;
701 : : PyObject *args;
702 : : PyObject *kw;
703 : : PyObject *weakreflist; /* List of weak references to self */
704 : : /* A {localdummy weakref -> localdict} dict */
705 : : PyObject *dummies;
706 : : /* The callback for weakrefs to localdummies */
707 : : PyObject *wr_callback;
708 : : } localobject;
709 : :
710 : : /* Forward declaration */
711 : : static PyObject *_ldict(localobject *self, thread_module_state *state);
712 : : static PyObject *_localdummy_destroyed(PyObject *meth_self, PyObject *dummyweakref);
713 : :
714 : : /* Create and register the dummy for the current thread.
715 : : Returns a borrowed reference of the corresponding local dict */
716 : : static PyObject *
717 : 1668 : _local_create_dummy(localobject *self, thread_module_state *state)
718 : : {
719 : 1668 : PyObject *ldict = NULL, *wr = NULL;
720 : 1668 : localdummyobject *dummy = NULL;
721 : 1668 : PyTypeObject *type = state->local_dummy_type;
722 : :
723 : 1668 : PyObject *tdict = PyThreadState_GetDict();
724 [ - + ]: 1668 : if (tdict == NULL) {
725 : 0 : PyErr_SetString(PyExc_SystemError,
726 : : "Couldn't get thread-state dictionary");
727 : 0 : goto err;
728 : : }
729 : :
730 : 1668 : ldict = PyDict_New();
731 [ - + ]: 1668 : if (ldict == NULL) {
732 : 0 : goto err;
733 : : }
734 : 1668 : dummy = (localdummyobject *) type->tp_alloc(type, 0);
735 [ - + ]: 1668 : if (dummy == NULL) {
736 : 0 : goto err;
737 : : }
738 : 1668 : dummy->localdict = ldict;
739 : 1668 : wr = PyWeakref_NewRef((PyObject *) dummy, self->wr_callback);
740 [ - + ]: 1668 : if (wr == NULL) {
741 : 0 : goto err;
742 : : }
743 : :
744 : : /* As a side-effect, this will cache the weakref's hash before the
745 : : dummy gets deleted */
746 : 1668 : int r = PyDict_SetItem(self->dummies, wr, ldict);
747 [ - + ]: 1668 : if (r < 0) {
748 : 0 : goto err;
749 : : }
750 [ + - ]: 1668 : Py_CLEAR(wr);
751 : 1668 : r = PyDict_SetItem(tdict, self->key, (PyObject *) dummy);
752 [ - + ]: 1668 : if (r < 0) {
753 : 0 : goto err;
754 : : }
755 [ + - ]: 1668 : Py_CLEAR(dummy);
756 : :
757 : 1668 : Py_DECREF(ldict);
758 : 1668 : return ldict;
759 : :
760 : 0 : err:
761 : 0 : Py_XDECREF(ldict);
762 : 0 : Py_XDECREF(wr);
763 : 0 : Py_XDECREF(dummy);
764 : 0 : return NULL;
765 : : }
766 : :
767 : : static PyObject *
768 : 1418 : local_new(PyTypeObject *type, PyObject *args, PyObject *kw)
769 : : {
770 : : static PyMethodDef wr_callback_def = {
771 : : "_localdummy_destroyed", (PyCFunction) _localdummy_destroyed, METH_O
772 : : };
773 : :
774 [ + + ]: 1418 : if (type->tp_init == PyBaseObject_Type.tp_init) {
775 : 1217 : int rc = 0;
776 [ + - ]: 1217 : if (args != NULL)
777 : 1217 : rc = PyObject_IsTrue(args);
778 [ + + + + ]: 1217 : if (rc == 0 && kw != NULL)
779 : 1 : rc = PyObject_IsTrue(kw);
780 [ + + ]: 1217 : if (rc != 0) {
781 [ + - ]: 2 : if (rc > 0) {
782 : 2 : PyErr_SetString(PyExc_TypeError,
783 : : "Initialization arguments are not supported");
784 : : }
785 : 2 : return NULL;
786 : : }
787 : : }
788 : :
789 : 1416 : PyObject *module = PyType_GetModuleByDef(type, &thread_module);
790 : 1416 : thread_module_state *state = get_thread_state(module);
791 : :
792 : 1416 : localobject *self = (localobject *)type->tp_alloc(type, 0);
793 [ - + ]: 1416 : if (self == NULL) {
794 : 0 : return NULL;
795 : : }
796 : :
797 : 1416 : self->args = Py_XNewRef(args);
798 : 1416 : self->kw = Py_XNewRef(kw);
799 : 1416 : self->key = PyUnicode_FromFormat("thread.local.%p", self);
800 [ - + ]: 1416 : if (self->key == NULL) {
801 : 0 : goto err;
802 : : }
803 : :
804 : 1416 : self->dummies = PyDict_New();
805 [ - + ]: 1416 : if (self->dummies == NULL) {
806 : 0 : goto err;
807 : : }
808 : :
809 : : /* We use a weak reference to self in the callback closure
810 : : in order to avoid spurious reference cycles */
811 : 1416 : PyObject *wr = PyWeakref_NewRef((PyObject *) self, NULL);
812 [ - + ]: 1416 : if (wr == NULL) {
813 : 0 : goto err;
814 : : }
815 : 1416 : self->wr_callback = PyCFunction_NewEx(&wr_callback_def, wr, NULL);
816 : 1416 : Py_DECREF(wr);
817 [ - + ]: 1416 : if (self->wr_callback == NULL) {
818 : 0 : goto err;
819 : : }
820 [ - + ]: 1416 : if (_local_create_dummy(self, state) == NULL) {
821 : 0 : goto err;
822 : : }
823 : 1416 : return (PyObject *)self;
824 : :
825 : 0 : err:
826 : 0 : Py_DECREF(self);
827 : 0 : return NULL;
828 : : }
829 : :
830 : : static int
831 : 30232 : local_traverse(localobject *self, visitproc visit, void *arg)
832 : : {
833 [ + - - + ]: 30232 : Py_VISIT(Py_TYPE(self));
834 [ + - - + ]: 30232 : Py_VISIT(self->args);
835 [ + + - + ]: 30232 : Py_VISIT(self->kw);
836 [ + - - + ]: 30232 : Py_VISIT(self->dummies);
837 : 30232 : return 0;
838 : : }
839 : :
840 : : static int
841 : 1414 : local_clear(localobject *self)
842 : : {
843 [ + + ]: 1414 : Py_CLEAR(self->args);
844 [ + + ]: 1414 : Py_CLEAR(self->kw);
845 [ + + ]: 1414 : Py_CLEAR(self->dummies);
846 [ + + ]: 1414 : Py_CLEAR(self->wr_callback);
847 : : /* Remove all strong references to dummies from the thread states */
848 [ + - ]: 1414 : if (self->key) {
849 : 1414 : PyInterpreterState *interp = _PyInterpreterState_GET();
850 : 1414 : PyThreadState *tstate = PyInterpreterState_ThreadHead(interp);
851 [ + + ]: 2837 : for(; tstate; tstate = PyThreadState_Next(tstate)) {
852 [ + + ]: 1423 : if (tstate->dict == NULL) {
853 : 4 : continue;
854 : : }
855 : 1419 : PyObject *v = _PyDict_Pop(tstate->dict, self->key, Py_None);
856 [ + - ]: 1419 : if (v != NULL) {
857 : 1419 : Py_DECREF(v);
858 : : }
859 : : else {
860 : 0 : PyErr_Clear();
861 : : }
862 : : }
863 : : }
864 : 1414 : return 0;
865 : : }
866 : :
867 : : static void
868 : 1412 : local_dealloc(localobject *self)
869 : : {
870 : : /* Weakrefs must be invalidated right now, otherwise they can be used
871 : : from code called below, which is very dangerous since Py_REFCNT(self) == 0 */
872 [ + + ]: 1412 : if (self->weakreflist != NULL) {
873 : 850 : PyObject_ClearWeakRefs((PyObject *) self);
874 : : }
875 : :
876 : 1412 : PyObject_GC_UnTrack(self);
877 : :
878 : 1412 : local_clear(self);
879 : 1412 : Py_XDECREF(self->key);
880 : :
881 : 1412 : PyTypeObject *tp = Py_TYPE(self);
882 : 1412 : tp->tp_free((PyObject*)self);
883 : 1412 : Py_DECREF(tp);
884 : 1412 : }
885 : :
886 : : /* Returns a borrowed reference to the local dict, creating it if necessary */
887 : : static PyObject *
888 : 37026 : _ldict(localobject *self, thread_module_state *state)
889 : : {
890 : 37026 : PyObject *tdict = PyThreadState_GetDict();
891 [ - + ]: 37026 : if (tdict == NULL) {
892 : 0 : PyErr_SetString(PyExc_SystemError,
893 : : "Couldn't get thread-state dictionary");
894 : 0 : return NULL;
895 : : }
896 : :
897 : : PyObject *ldict;
898 : 37026 : PyObject *dummy = PyDict_GetItemWithError(tdict, self->key);
899 [ + + ]: 37026 : if (dummy == NULL) {
900 [ - + ]: 252 : if (PyErr_Occurred()) {
901 : 0 : return NULL;
902 : : }
903 : 252 : ldict = _local_create_dummy(self, state);
904 [ - + ]: 252 : if (ldict == NULL)
905 : 0 : return NULL;
906 : :
907 [ + + - + ]: 297 : if (Py_TYPE(self)->tp_init != PyBaseObject_Type.tp_init &&
908 : 45 : Py_TYPE(self)->tp_init((PyObject*)self,
909 : : self->args, self->kw) < 0) {
910 : : /* we need to get rid of ldict from thread so
911 : : we create a new one the next time we do an attr
912 : : access */
913 : 0 : PyDict_DelItem(tdict, self->key);
914 : 0 : return NULL;
915 : : }
916 : : }
917 : : else {
918 : : assert(Py_IS_TYPE(dummy, state->local_dummy_type));
919 : 36774 : ldict = ((localdummyobject *) dummy)->localdict;
920 : : }
921 : :
922 : 37026 : return ldict;
923 : : }
924 : :
925 : : static int
926 : 14855 : local_setattro(localobject *self, PyObject *name, PyObject *v)
927 : : {
928 : 14855 : PyObject *module = PyType_GetModuleByDef(Py_TYPE(self), &thread_module);
929 : 14855 : thread_module_state *state = get_thread_state(module);
930 : :
931 : 14855 : PyObject *ldict = _ldict(self, state);
932 [ - + ]: 14855 : if (ldict == NULL) {
933 : 0 : return -1;
934 : : }
935 : :
936 : 14855 : int r = PyObject_RichCompareBool(name, &_Py_ID(__dict__), Py_EQ);
937 [ - + ]: 14855 : if (r == -1) {
938 : 0 : return -1;
939 : : }
940 [ + + ]: 14855 : if (r == 1) {
941 : 4 : PyErr_Format(PyExc_AttributeError,
942 : : "'%.50s' object attribute '%U' is read-only",
943 : 4 : Py_TYPE(self)->tp_name, name);
944 : 4 : return -1;
945 : : }
946 : :
947 : 14851 : return _PyObject_GenericSetAttrWithDict((PyObject *)self, name, v, ldict);
948 : : }
949 : :
950 : : static PyObject *local_getattro(localobject *, PyObject *);
951 : :
952 : : static PyMemberDef local_type_members[] = {
953 : : {"__weaklistoffset__", T_PYSSIZET, offsetof(localobject, weakreflist), READONLY},
954 : : {NULL},
955 : : };
956 : :
957 : : static PyType_Slot local_type_slots[] = {
958 : : {Py_tp_dealloc, (destructor)local_dealloc},
959 : : {Py_tp_getattro, (getattrofunc)local_getattro},
960 : : {Py_tp_setattro, (setattrofunc)local_setattro},
961 : : {Py_tp_doc, "Thread-local data"},
962 : : {Py_tp_traverse, (traverseproc)local_traverse},
963 : : {Py_tp_clear, (inquiry)local_clear},
964 : : {Py_tp_new, local_new},
965 : : {Py_tp_members, local_type_members},
966 : : {0, 0}
967 : : };
968 : :
969 : : static PyType_Spec local_type_spec = {
970 : : .name = "_thread._local",
971 : : .basicsize = sizeof(localobject),
972 : : .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC |
973 : : Py_TPFLAGS_IMMUTABLETYPE),
974 : : .slots = local_type_slots,
975 : : };
976 : :
977 : : static PyObject *
978 : 22171 : local_getattro(localobject *self, PyObject *name)
979 : : {
980 : 22171 : PyObject *module = PyType_GetModuleByDef(Py_TYPE(self), &thread_module);
981 : 22171 : thread_module_state *state = get_thread_state(module);
982 : :
983 : 22171 : PyObject *ldict = _ldict(self, state);
984 [ - + ]: 22171 : if (ldict == NULL)
985 : 0 : return NULL;
986 : :
987 : 22171 : int r = PyObject_RichCompareBool(name, &_Py_ID(__dict__), Py_EQ);
988 [ + + ]: 22171 : if (r == 1) {
989 : 2 : return Py_NewRef(ldict);
990 : : }
991 [ - + ]: 22169 : if (r == -1) {
992 : 0 : return NULL;
993 : : }
994 : :
995 [ + + ]: 22169 : if (!Py_IS_TYPE(self, state->local_type)) {
996 : : /* use generic lookup for subtypes */
997 : 10699 : return _PyObject_GenericGetAttrWithDict((PyObject *)self, name,
998 : : ldict, 0);
999 : : }
1000 : :
1001 : : /* Optimization: just look in dict ourselves */
1002 : 11470 : PyObject *value = PyDict_GetItemWithError(ldict, name);
1003 [ + + ]: 11470 : if (value != NULL) {
1004 : 11400 : return Py_NewRef(value);
1005 : : }
1006 [ - + ]: 70 : if (PyErr_Occurred()) {
1007 : 0 : return NULL;
1008 : : }
1009 : :
1010 : : /* Fall back on generic to get __class__ and __dict__ */
1011 : 70 : return _PyObject_GenericGetAttrWithDict(
1012 : : (PyObject *)self, name, ldict, 0);
1013 : : }
1014 : :
1015 : : /* Called when a dummy is destroyed. */
1016 : : static PyObject *
1017 : 259 : _localdummy_destroyed(PyObject *localweakref, PyObject *dummyweakref)
1018 : : {
1019 : : assert(PyWeakref_CheckRef(localweakref));
1020 : 259 : PyObject *obj = PyWeakref_GET_OBJECT(localweakref);
1021 [ - + ]: 259 : if (obj == Py_None) {
1022 : 0 : Py_RETURN_NONE;
1023 : : }
1024 : :
1025 : : /* If the thread-local object is still alive and not being cleared,
1026 : : remove the corresponding local dict */
1027 : 259 : localobject *self = (localobject *)Py_NewRef(obj);
1028 [ + - ]: 259 : if (self->dummies != NULL) {
1029 : : PyObject *ldict;
1030 : 259 : ldict = PyDict_GetItemWithError(self->dummies, dummyweakref);
1031 [ + - ]: 259 : if (ldict != NULL) {
1032 : 259 : PyDict_DelItem(self->dummies, dummyweakref);
1033 : : }
1034 [ - + ]: 259 : if (PyErr_Occurred())
1035 : 0 : PyErr_WriteUnraisable(obj);
1036 : : }
1037 : 259 : Py_DECREF(obj);
1038 : 259 : Py_RETURN_NONE;
1039 : : }
1040 : :
1041 : : /* Module functions */
1042 : :
1043 : : struct bootstate {
1044 : : PyInterpreterState *interp;
1045 : : PyObject *func;
1046 : : PyObject *args;
1047 : : PyObject *kwargs;
1048 : : PyThreadState *tstate;
1049 : : _PyRuntimeState *runtime;
1050 : : };
1051 : :
1052 : :
1053 : : static void
1054 : 8643 : thread_bootstate_free(struct bootstate *boot)
1055 : : {
1056 : 8643 : Py_DECREF(boot->func);
1057 : 8643 : Py_DECREF(boot->args);
1058 : 8643 : Py_XDECREF(boot->kwargs);
1059 : 8643 : PyMem_Free(boot);
1060 : 8643 : }
1061 : :
1062 : :
1063 : : static void
1064 : 8772 : thread_run(void *boot_raw)
1065 : : {
1066 : 8772 : struct bootstate *boot = (struct bootstate *) boot_raw;
1067 : : PyThreadState *tstate;
1068 : :
1069 : 8772 : tstate = boot->tstate;
1070 : 8772 : tstate->thread_id = PyThread_get_thread_ident();
1071 : : #ifdef PY_HAVE_THREAD_NATIVE_ID
1072 : 8773 : tstate->native_thread_id = PyThread_get_thread_native_id();
1073 : : #else
1074 : : tstate->native_thread_id = 0;
1075 : : #endif
1076 : 8773 : _PyThreadState_SetCurrent(tstate);
1077 : 8773 : PyEval_AcquireThread(tstate);
1078 : 8773 : tstate->interp->threads.count++;
1079 : :
1080 : 8773 : PyObject *res = PyObject_Call(boot->func, boot->args, boot->kwargs);
1081 [ + + ]: 8643 : if (res == NULL) {
1082 [ + + ]: 493 : if (PyErr_ExceptionMatches(PyExc_SystemExit))
1083 : : /* SystemExit is ignored silently */
1084 : 492 : PyErr_Clear();
1085 : : else {
1086 : 1 : _PyErr_WriteUnraisableMsg("in thread started by", boot->func);
1087 : : }
1088 : : }
1089 : : else {
1090 : 8150 : Py_DECREF(res);
1091 : : }
1092 : :
1093 : 8643 : thread_bootstate_free(boot);
1094 : 8643 : tstate->interp->threads.count--;
1095 : 8643 : PyThreadState_Clear(tstate);
1096 : 8643 : _PyThreadState_DeleteCurrent(tstate);
1097 : :
1098 : : // bpo-44434: Don't call explicitly PyThread_exit_thread(). On Linux with
1099 : : // the glibc, pthread_exit() can abort the whole process if dlopen() fails
1100 : : // to open the libgcc_s.so library (ex: EMFILE error).
1101 : 8643 : }
1102 : :
1103 : : static PyObject *
1104 : 8773 : thread_PyThread_start_new_thread(PyObject *self, PyObject *fargs)
1105 : : {
1106 : 8773 : _PyRuntimeState *runtime = &_PyRuntime;
1107 : 8773 : PyObject *func, *args, *kwargs = NULL;
1108 : :
1109 [ - + ]: 8773 : if (!PyArg_UnpackTuple(fargs, "start_new_thread", 2, 3,
1110 : : &func, &args, &kwargs))
1111 : 0 : return NULL;
1112 [ - + ]: 8773 : if (!PyCallable_Check(func)) {
1113 : 0 : PyErr_SetString(PyExc_TypeError,
1114 : : "first arg must be callable");
1115 : 0 : return NULL;
1116 : : }
1117 [ - + ]: 8773 : if (!PyTuple_Check(args)) {
1118 : 0 : PyErr_SetString(PyExc_TypeError,
1119 : : "2nd arg must be a tuple");
1120 : 0 : return NULL;
1121 : : }
1122 [ - + - - ]: 8773 : if (kwargs != NULL && !PyDict_Check(kwargs)) {
1123 : 0 : PyErr_SetString(PyExc_TypeError,
1124 : : "optional 3rd arg must be a dictionary");
1125 : 0 : return NULL;
1126 : : }
1127 : :
1128 : 8773 : PyInterpreterState *interp = _PyInterpreterState_GET();
1129 [ - + ]: 8773 : if (interp->config._isolated_interpreter) {
1130 : 0 : PyErr_SetString(PyExc_RuntimeError,
1131 : : "thread is not supported for isolated subinterpreters");
1132 : 0 : return NULL;
1133 : : }
1134 : :
1135 : 8773 : struct bootstate *boot = PyMem_NEW(struct bootstate, 1);
1136 [ - + ]: 8773 : if (boot == NULL) {
1137 : : return PyErr_NoMemory();
1138 : : }
1139 : 8773 : boot->interp = _PyInterpreterState_GET();
1140 : 8773 : boot->tstate = _PyThreadState_Prealloc(boot->interp);
1141 [ - + ]: 8773 : if (boot->tstate == NULL) {
1142 : 0 : PyMem_Free(boot);
1143 : : return PyErr_NoMemory();
1144 : : }
1145 : 8773 : boot->runtime = runtime;
1146 : 8773 : boot->func = Py_NewRef(func);
1147 : 8773 : boot->args = Py_NewRef(args);
1148 : 8773 : boot->kwargs = Py_XNewRef(kwargs);
1149 : :
1150 : 8773 : unsigned long ident = PyThread_start_new_thread(thread_run, (void*) boot);
1151 [ - + ]: 8773 : if (ident == PYTHREAD_INVALID_THREAD_ID) {
1152 : 0 : PyErr_SetString(ThreadError, "can't start new thread");
1153 : 0 : PyThreadState_Clear(boot->tstate);
1154 : 0 : thread_bootstate_free(boot);
1155 : 0 : return NULL;
1156 : : }
1157 : 8773 : return PyLong_FromUnsignedLong(ident);
1158 : : }
1159 : :
1160 : : PyDoc_STRVAR(start_new_doc,
1161 : : "start_new_thread(function, args[, kwargs])\n\
1162 : : (start_new() is an obsolete synonym)\n\
1163 : : \n\
1164 : : Start a new thread and return its identifier. The thread will call the\n\
1165 : : function with positional arguments from the tuple args and keyword arguments\n\
1166 : : taken from the optional dictionary kwargs. The thread exits when the\n\
1167 : : function returns; the return value is ignored. The thread will also exit\n\
1168 : : when the function raises an unhandled exception; a stack trace will be\n\
1169 : : printed unless the exception is SystemExit.\n");
1170 : :
1171 : : static PyObject *
1172 : 492 : thread_PyThread_exit_thread(PyObject *self, PyObject *Py_UNUSED(ignored))
1173 : : {
1174 : 492 : PyErr_SetNone(PyExc_SystemExit);
1175 : 492 : return NULL;
1176 : : }
1177 : :
1178 : : PyDoc_STRVAR(exit_doc,
1179 : : "exit()\n\
1180 : : (exit_thread() is an obsolete synonym)\n\
1181 : : \n\
1182 : : This is synonymous to ``raise SystemExit''. It will cause the current\n\
1183 : : thread to exit silently unless the exception is caught.");
1184 : :
1185 : : static PyObject *
1186 : 14 : thread_PyThread_interrupt_main(PyObject *self, PyObject *args)
1187 : : {
1188 : 14 : int signum = SIGINT;
1189 [ - + ]: 14 : if (!PyArg_ParseTuple(args, "|i:signum", &signum)) {
1190 : 0 : return NULL;
1191 : : }
1192 : :
1193 [ + + ]: 14 : if (PyErr_SetInterruptEx(signum)) {
1194 : 3 : PyErr_SetString(PyExc_ValueError, "signal number out of range");
1195 : 3 : return NULL;
1196 : : }
1197 : 11 : Py_RETURN_NONE;
1198 : : }
1199 : :
1200 : : PyDoc_STRVAR(interrupt_doc,
1201 : : "interrupt_main(signum=signal.SIGINT, /)\n\
1202 : : \n\
1203 : : Simulate the arrival of the given signal in the main thread,\n\
1204 : : where the corresponding signal handler will be executed.\n\
1205 : : If *signum* is omitted, SIGINT is assumed.\n\
1206 : : A subthread can use this function to interrupt the main thread.\n\
1207 : : \n\
1208 : : Note: the default signal handler for SIGINT raises ``KeyboardInterrupt``."
1209 : : );
1210 : :
1211 : : static lockobject *newlockobject(PyObject *module);
1212 : :
1213 : : static PyObject *
1214 : 675577 : thread_PyThread_allocate_lock(PyObject *module, PyObject *Py_UNUSED(ignored))
1215 : : {
1216 : 675577 : return (PyObject *) newlockobject(module);
1217 : : }
1218 : :
1219 : : PyDoc_STRVAR(allocate_doc,
1220 : : "allocate_lock() -> lock object\n\
1221 : : (allocate() is an obsolete synonym)\n\
1222 : : \n\
1223 : : Create a new lock object. See help(type(threading.Lock())) for\n\
1224 : : information about locks.");
1225 : :
1226 : : static PyObject *
1227 : 821053 : thread_get_ident(PyObject *self, PyObject *Py_UNUSED(ignored))
1228 : : {
1229 : 821053 : unsigned long ident = PyThread_get_thread_ident();
1230 [ - + ]: 821053 : if (ident == PYTHREAD_INVALID_THREAD_ID) {
1231 : 0 : PyErr_SetString(ThreadError, "no current thread ident");
1232 : 0 : return NULL;
1233 : : }
1234 : 821053 : return PyLong_FromUnsignedLong(ident);
1235 : : }
1236 : :
1237 : : PyDoc_STRVAR(get_ident_doc,
1238 : : "get_ident() -> integer\n\
1239 : : \n\
1240 : : Return a non-zero integer that uniquely identifies the current thread\n\
1241 : : amongst other threads that exist simultaneously.\n\
1242 : : This may be used to identify per-thread resources.\n\
1243 : : Even though on some platforms threads identities may appear to be\n\
1244 : : allocated consecutive numbers starting at 1, this behavior should not\n\
1245 : : be relied upon, and the number should be seen purely as a magic cookie.\n\
1246 : : A thread's identity may be reused for another thread after it exits.");
1247 : :
1248 : : #ifdef PY_HAVE_THREAD_NATIVE_ID
1249 : : static PyObject *
1250 : 9635 : thread_get_native_id(PyObject *self, PyObject *Py_UNUSED(ignored))
1251 : : {
1252 : 9635 : unsigned long native_id = PyThread_get_thread_native_id();
1253 : 9635 : return PyLong_FromUnsignedLong(native_id);
1254 : : }
1255 : :
1256 : : PyDoc_STRVAR(get_native_id_doc,
1257 : : "get_native_id() -> integer\n\
1258 : : \n\
1259 : : Return a non-negative integer identifying the thread as reported\n\
1260 : : by the OS (kernel). This may be used to uniquely identify a\n\
1261 : : particular thread within a system.");
1262 : : #endif
1263 : :
1264 : : static PyObject *
1265 : 6873 : thread__count(PyObject *self, PyObject *Py_UNUSED(ignored))
1266 : : {
1267 : 6873 : PyInterpreterState *interp = _PyInterpreterState_GET();
1268 : 6873 : return PyLong_FromLong(interp->threads.count);
1269 : : }
1270 : :
1271 : : PyDoc_STRVAR(_count_doc,
1272 : : "_count() -> integer\n\
1273 : : \n\
1274 : : \
1275 : : Return the number of currently running Python threads, excluding\n\
1276 : : the main thread. The returned number comprises all threads created\n\
1277 : : through `start_new_thread()` as well as `threading.Thread`, and not\n\
1278 : : yet finished.\n\
1279 : : \n\
1280 : : This function is meant for internal and specialized purposes only.\n\
1281 : : In most applications `threading.enumerate()` should be used instead.");
1282 : :
1283 : : static void
1284 : 9184 : release_sentinel(void *wr_raw)
1285 : : {
1286 : 9184 : PyObject *wr = _PyObject_CAST(wr_raw);
1287 : : /* Tricky: this function is called when the current thread state
1288 : : is being deleted. Therefore, only simple C code can safely
1289 : : execute here. */
1290 : 9184 : PyObject *obj = PyWeakref_GET_OBJECT(wr);
1291 : : lockobject *lock;
1292 [ + + ]: 9184 : if (obj != Py_None) {
1293 : 7354 : lock = (lockobject *) obj;
1294 [ + - ]: 7354 : if (lock->locked) {
1295 : 7354 : PyThread_release_lock(lock->lock_lock);
1296 : 7354 : lock->locked = 0;
1297 : : }
1298 : : }
1299 : : /* Deallocating a weakref with a NULL callback only calls
1300 : : PyObject_GC_Del(), which can't call any Python code. */
1301 : 9184 : Py_DECREF(wr);
1302 : 9184 : }
1303 : :
1304 : : static PyObject *
1305 : 9184 : thread__set_sentinel(PyObject *module, PyObject *Py_UNUSED(ignored))
1306 : : {
1307 : : PyObject *wr;
1308 : 9184 : PyThreadState *tstate = _PyThreadState_GET();
1309 : : lockobject *lock;
1310 : :
1311 [ - + ]: 9184 : if (tstate->on_delete_data != NULL) {
1312 : : /* We must support the re-creation of the lock from a
1313 : : fork()ed child. */
1314 : : assert(tstate->on_delete == &release_sentinel);
1315 : 0 : wr = (PyObject *) tstate->on_delete_data;
1316 : 0 : tstate->on_delete = NULL;
1317 : 0 : tstate->on_delete_data = NULL;
1318 : 0 : Py_DECREF(wr);
1319 : : }
1320 : 9184 : lock = newlockobject(module);
1321 [ - + ]: 9184 : if (lock == NULL)
1322 : 0 : return NULL;
1323 : : /* The lock is owned by whoever called _set_sentinel(), but the weakref
1324 : : hangs to the thread state. */
1325 : 9184 : wr = PyWeakref_NewRef((PyObject *) lock, NULL);
1326 [ - + ]: 9184 : if (wr == NULL) {
1327 : 0 : Py_DECREF(lock);
1328 : 0 : return NULL;
1329 : : }
1330 : 9184 : tstate->on_delete_data = (void *) wr;
1331 : 9184 : tstate->on_delete = &release_sentinel;
1332 : 9184 : return (PyObject *) lock;
1333 : : }
1334 : :
1335 : : PyDoc_STRVAR(_set_sentinel_doc,
1336 : : "_set_sentinel() -> lock\n\
1337 : : \n\
1338 : : Set a sentinel lock that will be released when the current thread\n\
1339 : : state is finalized (after it is untied from the interpreter).\n\
1340 : : \n\
1341 : : This is a private API for the threading module.");
1342 : :
1343 : : static PyObject *
1344 : 15 : thread_stack_size(PyObject *self, PyObject *args)
1345 : : {
1346 : : size_t old_size;
1347 : 15 : Py_ssize_t new_size = 0;
1348 : : int rc;
1349 : :
1350 [ - + ]: 15 : if (!PyArg_ParseTuple(args, "|n:stack_size", &new_size))
1351 : 0 : return NULL;
1352 : :
1353 [ - + ]: 15 : if (new_size < 0) {
1354 : 0 : PyErr_SetString(PyExc_ValueError,
1355 : : "size must be 0 or a positive value");
1356 : 0 : return NULL;
1357 : : }
1358 : :
1359 : 15 : old_size = PyThread_get_stacksize();
1360 : :
1361 : 15 : rc = PyThread_set_stacksize((size_t) new_size);
1362 [ + + ]: 15 : if (rc == -1) {
1363 : 1 : PyErr_Format(PyExc_ValueError,
1364 : : "size not valid: %zd bytes",
1365 : : new_size);
1366 : 1 : return NULL;
1367 : : }
1368 [ - + ]: 14 : if (rc == -2) {
1369 : 0 : PyErr_SetString(ThreadError,
1370 : : "setting stack size not supported");
1371 : 0 : return NULL;
1372 : : }
1373 : :
1374 : 14 : return PyLong_FromSsize_t((Py_ssize_t) old_size);
1375 : : }
1376 : :
1377 : : PyDoc_STRVAR(stack_size_doc,
1378 : : "stack_size([size]) -> size\n\
1379 : : \n\
1380 : : Return the thread stack size used when creating new threads. The\n\
1381 : : optional size argument specifies the stack size (in bytes) to be used\n\
1382 : : for subsequently created threads, and must be 0 (use platform or\n\
1383 : : configured default) or a positive integer value of at least 32,768 (32k).\n\
1384 : : If changing the thread stack size is unsupported, a ThreadError\n\
1385 : : exception is raised. If the specified size is invalid, a ValueError\n\
1386 : : exception is raised, and the stack size is unmodified. 32k bytes\n\
1387 : : currently the minimum supported stack size value to guarantee\n\
1388 : : sufficient stack space for the interpreter itself.\n\
1389 : : \n\
1390 : : Note that some platforms may have particular restrictions on values for\n\
1391 : : the stack size, such as requiring a minimum stack size larger than 32 KiB or\n\
1392 : : requiring allocation in multiples of the system memory page size\n\
1393 : : - platform documentation should be referred to for more information\n\
1394 : : (4 KiB pages are common; using multiples of 4096 for the stack size is\n\
1395 : : the suggested approach in the absence of more specific information).");
1396 : :
1397 : : static int
1398 : 7 : thread_excepthook_file(PyObject *file, PyObject *exc_type, PyObject *exc_value,
1399 : : PyObject *exc_traceback, PyObject *thread)
1400 : : {
1401 : : /* print(f"Exception in thread {thread.name}:", file=file) */
1402 [ - + ]: 7 : if (PyFile_WriteString("Exception in thread ", file) < 0) {
1403 : 0 : return -1;
1404 : : }
1405 : :
1406 : 7 : PyObject *name = NULL;
1407 [ + + ]: 7 : if (thread != Py_None) {
1408 [ - + ]: 6 : if (_PyObject_LookupAttr(thread, &_Py_ID(name), &name) < 0) {
1409 : 0 : return -1;
1410 : : }
1411 : : }
1412 [ + + ]: 7 : if (name != NULL) {
1413 [ - + ]: 6 : if (PyFile_WriteObject(name, file, Py_PRINT_RAW) < 0) {
1414 : 0 : Py_DECREF(name);
1415 : 0 : return -1;
1416 : : }
1417 : 6 : Py_DECREF(name);
1418 : : }
1419 : : else {
1420 : 1 : unsigned long ident = PyThread_get_thread_ident();
1421 : 1 : PyObject *str = PyUnicode_FromFormat("%lu", ident);
1422 [ + - ]: 1 : if (str != NULL) {
1423 [ - + ]: 1 : if (PyFile_WriteObject(str, file, Py_PRINT_RAW) < 0) {
1424 : 0 : Py_DECREF(str);
1425 : 0 : return -1;
1426 : : }
1427 : 1 : Py_DECREF(str);
1428 : : }
1429 : : else {
1430 : 0 : PyErr_Clear();
1431 : :
1432 [ # # ]: 0 : if (PyFile_WriteString("<failed to get thread name>", file) < 0) {
1433 : 0 : return -1;
1434 : : }
1435 : : }
1436 : : }
1437 : :
1438 [ - + ]: 7 : if (PyFile_WriteString(":\n", file) < 0) {
1439 : 0 : return -1;
1440 : : }
1441 : :
1442 : : /* Display the traceback */
1443 : 7 : _PyErr_Display(file, exc_type, exc_value, exc_traceback);
1444 : :
1445 : : /* Call file.flush() */
1446 : 7 : PyObject *res = PyObject_CallMethodNoArgs(file, &_Py_ID(flush));
1447 [ - + ]: 7 : if (!res) {
1448 : 0 : return -1;
1449 : : }
1450 : 7 : Py_DECREF(res);
1451 : :
1452 : 7 : return 0;
1453 : : }
1454 : :
1455 : :
1456 : : PyDoc_STRVAR(ExceptHookArgs__doc__,
1457 : : "ExceptHookArgs\n\
1458 : : \n\
1459 : : Type used to pass arguments to threading.excepthook.");
1460 : :
1461 : : static PyStructSequence_Field ExceptHookArgs_fields[] = {
1462 : : {"exc_type", "Exception type"},
1463 : : {"exc_value", "Exception value"},
1464 : : {"exc_traceback", "Exception traceback"},
1465 : : {"thread", "Thread"},
1466 : : {0}
1467 : : };
1468 : :
1469 : : static PyStructSequence_Desc ExceptHookArgs_desc = {
1470 : : .name = "_thread._ExceptHookArgs",
1471 : : .doc = ExceptHookArgs__doc__,
1472 : : .fields = ExceptHookArgs_fields,
1473 : : .n_in_sequence = 4
1474 : : };
1475 : :
1476 : :
1477 : : static PyObject *
1478 : 11 : thread_excepthook(PyObject *module, PyObject *args)
1479 : : {
1480 : 11 : thread_module_state *state = get_thread_state(module);
1481 : :
1482 [ - + ]: 11 : if (!Py_IS_TYPE(args, state->excepthook_type)) {
1483 : 0 : PyErr_SetString(PyExc_TypeError,
1484 : : "_thread.excepthook argument type "
1485 : : "must be ExceptHookArgs");
1486 : 0 : return NULL;
1487 : : }
1488 : :
1489 : : /* Borrowed reference */
1490 : 11 : PyObject *exc_type = PyStructSequence_GET_ITEM(args, 0);
1491 [ + + ]: 11 : if (exc_type == PyExc_SystemExit) {
1492 : : /* silently ignore SystemExit */
1493 : 3 : Py_RETURN_NONE;
1494 : : }
1495 : :
1496 : : /* Borrowed references */
1497 : 8 : PyObject *exc_value = PyStructSequence_GET_ITEM(args, 1);
1498 : 8 : PyObject *exc_tb = PyStructSequence_GET_ITEM(args, 2);
1499 : 8 : PyObject *thread = PyStructSequence_GET_ITEM(args, 3);
1500 : :
1501 : 8 : PyThreadState *tstate = _PyThreadState_GET();
1502 : 8 : PyObject *file = _PySys_GetAttr(tstate, &_Py_ID(stderr));
1503 [ + - + + ]: 8 : if (file == NULL || file == Py_None) {
1504 [ - + ]: 2 : if (thread == Py_None) {
1505 : : /* do nothing if sys.stderr is None and thread is None */
1506 : 0 : Py_RETURN_NONE;
1507 : : }
1508 : :
1509 : 2 : file = PyObject_GetAttrString(thread, "_stderr");
1510 [ - + ]: 2 : if (file == NULL) {
1511 : 0 : return NULL;
1512 : : }
1513 [ + + ]: 2 : if (file == Py_None) {
1514 : 1 : Py_DECREF(file);
1515 : : /* do nothing if sys.stderr is None and sys.stderr was None
1516 : : when the thread was created */
1517 : 1 : Py_RETURN_NONE;
1518 : : }
1519 : : }
1520 : : else {
1521 : 6 : Py_INCREF(file);
1522 : : }
1523 : :
1524 : 7 : int res = thread_excepthook_file(file, exc_type, exc_value, exc_tb,
1525 : : thread);
1526 : 7 : Py_DECREF(file);
1527 [ - + ]: 7 : if (res < 0) {
1528 : 0 : return NULL;
1529 : : }
1530 : :
1531 : 7 : Py_RETURN_NONE;
1532 : : }
1533 : :
1534 : : PyDoc_STRVAR(excepthook_doc,
1535 : : "excepthook(exc_type, exc_value, exc_traceback, thread)\n\
1536 : : \n\
1537 : : Handle uncaught Thread.run() exception.");
1538 : :
1539 : : static PyMethodDef thread_methods[] = {
1540 : : {"start_new_thread", (PyCFunction)thread_PyThread_start_new_thread,
1541 : : METH_VARARGS, start_new_doc},
1542 : : {"start_new", (PyCFunction)thread_PyThread_start_new_thread,
1543 : : METH_VARARGS, start_new_doc},
1544 : : {"allocate_lock", thread_PyThread_allocate_lock,
1545 : : METH_NOARGS, allocate_doc},
1546 : : {"allocate", thread_PyThread_allocate_lock,
1547 : : METH_NOARGS, allocate_doc},
1548 : : {"exit_thread", thread_PyThread_exit_thread,
1549 : : METH_NOARGS, exit_doc},
1550 : : {"exit", thread_PyThread_exit_thread,
1551 : : METH_NOARGS, exit_doc},
1552 : : {"interrupt_main", (PyCFunction)thread_PyThread_interrupt_main,
1553 : : METH_VARARGS, interrupt_doc},
1554 : : {"get_ident", thread_get_ident,
1555 : : METH_NOARGS, get_ident_doc},
1556 : : #ifdef PY_HAVE_THREAD_NATIVE_ID
1557 : : {"get_native_id", thread_get_native_id,
1558 : : METH_NOARGS, get_native_id_doc},
1559 : : #endif
1560 : : {"_count", thread__count,
1561 : : METH_NOARGS, _count_doc},
1562 : : {"stack_size", (PyCFunction)thread_stack_size,
1563 : : METH_VARARGS, stack_size_doc},
1564 : : {"_set_sentinel", thread__set_sentinel,
1565 : : METH_NOARGS, _set_sentinel_doc},
1566 : : {"_excepthook", thread_excepthook,
1567 : : METH_O, excepthook_doc},
1568 : : {NULL, NULL} /* sentinel */
1569 : : };
1570 : :
1571 : :
1572 : : /* Initialization function */
1573 : :
1574 : : static int
1575 : 3135 : thread_module_exec(PyObject *module)
1576 : : {
1577 : 3135 : thread_module_state *state = get_thread_state(module);
1578 : 3135 : PyObject *d = PyModule_GetDict(module);
1579 : :
1580 : : // Initialize the C thread library
1581 : 3135 : PyThread_init_thread();
1582 : :
1583 : : // Lock
1584 : 3135 : state->lock_type = (PyTypeObject *)PyType_FromSpec(&lock_type_spec);
1585 [ - + ]: 3135 : if (state->lock_type == NULL) {
1586 : 0 : return -1;
1587 : : }
1588 [ - + ]: 3135 : if (PyDict_SetItemString(d, "LockType", (PyObject *)state->lock_type) < 0) {
1589 : 0 : return -1;
1590 : : }
1591 : :
1592 : : // RLock
1593 : 3135 : PyTypeObject *rlock_type = (PyTypeObject *)PyType_FromSpec(&rlock_type_spec);
1594 [ - + ]: 3135 : if (rlock_type == NULL) {
1595 : 0 : return -1;
1596 : : }
1597 [ - + ]: 3135 : if (PyModule_AddType(module, rlock_type) < 0) {
1598 : 0 : Py_DECREF(rlock_type);
1599 : 0 : return -1;
1600 : : }
1601 : 3135 : Py_DECREF(rlock_type);
1602 : :
1603 : : // Local dummy
1604 : 3135 : state->local_dummy_type = (PyTypeObject *)PyType_FromSpec(&local_dummy_type_spec);
1605 [ - + ]: 3135 : if (state->local_dummy_type == NULL) {
1606 : 0 : return -1;
1607 : : }
1608 : :
1609 : : // Local
1610 : 3135 : state->local_type = (PyTypeObject *)PyType_FromModuleAndSpec(module, &local_type_spec, NULL);
1611 [ - + ]: 3135 : if (state->local_type == NULL) {
1612 : 0 : return -1;
1613 : : }
1614 [ - + ]: 3135 : if (PyModule_AddType(module, state->local_type) < 0) {
1615 : 0 : return -1;
1616 : : }
1617 : :
1618 : : // Add module attributes
1619 [ - + ]: 3135 : if (PyDict_SetItemString(d, "error", ThreadError) < 0) {
1620 : 0 : return -1;
1621 : : }
1622 : :
1623 : : // _ExceptHookArgs type
1624 : 3135 : state->excepthook_type = PyStructSequence_NewType(&ExceptHookArgs_desc);
1625 [ - + ]: 3135 : if (state->excepthook_type == NULL) {
1626 : 0 : return -1;
1627 : : }
1628 [ - + ]: 3135 : if (PyModule_AddType(module, state->excepthook_type) < 0) {
1629 : 0 : return -1;
1630 : : }
1631 : :
1632 : : // TIMEOUT_MAX
1633 : 3135 : double timeout_max = (double)PY_TIMEOUT_MAX * 1e-6;
1634 : 3135 : double time_max = _PyTime_AsSecondsDouble(_PyTime_MAX);
1635 [ - + ]: 3135 : timeout_max = Py_MIN(timeout_max, time_max);
1636 : : // Round towards minus infinity
1637 : 3135 : timeout_max = floor(timeout_max);
1638 : :
1639 [ - + ]: 3135 : if (PyModule_AddObject(module, "TIMEOUT_MAX",
1640 : : PyFloat_FromDouble(timeout_max)) < 0) {
1641 : 0 : return -1;
1642 : : }
1643 : :
1644 : 3135 : return 0;
1645 : : }
1646 : :
1647 : :
1648 : : static int
1649 : 59768 : thread_module_traverse(PyObject *module, visitproc visit, void *arg)
1650 : : {
1651 : 59768 : thread_module_state *state = get_thread_state(module);
1652 [ + - - + ]: 59768 : Py_VISIT(state->excepthook_type);
1653 [ + - - + ]: 59768 : Py_VISIT(state->lock_type);
1654 [ + - - + ]: 59768 : Py_VISIT(state->local_type);
1655 [ + - - + ]: 59768 : Py_VISIT(state->local_dummy_type);
1656 : 59768 : return 0;
1657 : : }
1658 : :
1659 : : static int
1660 : 5495 : thread_module_clear(PyObject *module)
1661 : : {
1662 : 5495 : thread_module_state *state = get_thread_state(module);
1663 [ + + ]: 5495 : Py_CLEAR(state->excepthook_type);
1664 [ + + ]: 5495 : Py_CLEAR(state->lock_type);
1665 [ + + ]: 5495 : Py_CLEAR(state->local_type);
1666 [ + + ]: 5495 : Py_CLEAR(state->local_dummy_type);
1667 : 5495 : return 0;
1668 : : }
1669 : :
1670 : : static void
1671 : 3074 : thread_module_free(void *module)
1672 : : {
1673 : 3074 : thread_module_clear((PyObject *)module);
1674 : 3074 : }
1675 : :
1676 : :
1677 : :
1678 : : PyDoc_STRVAR(thread_doc,
1679 : : "This module provides primitive operations to write multi-threaded programs.\n\
1680 : : The 'threading' module provides a more convenient interface.");
1681 : :
1682 : : static PyModuleDef_Slot thread_module_slots[] = {
1683 : : {Py_mod_exec, thread_module_exec},
1684 : : {0, NULL}
1685 : : };
1686 : :
1687 : : static struct PyModuleDef thread_module = {
1688 : : PyModuleDef_HEAD_INIT,
1689 : : .m_name = "_thread",
1690 : : .m_doc = thread_doc,
1691 : : .m_size = sizeof(thread_module_state),
1692 : : .m_methods = thread_methods,
1693 : : .m_traverse = thread_module_traverse,
1694 : : .m_clear = thread_module_clear,
1695 : : .m_free = thread_module_free,
1696 : : .m_slots = thread_module_slots,
1697 : : };
1698 : :
1699 : : PyMODINIT_FUNC
1700 : 3135 : PyInit__thread(void)
1701 : : {
1702 : 3135 : return PyModuleDef_Init(&thread_module);
1703 : : }
|
