|
1 |
|
2 /* Thread and interpreter state structures and their interfaces */ |
|
3 |
|
4 #include "Python.h" |
|
5 |
|
6 /* -------------------------------------------------------------------------- |
|
7 CAUTION |
|
8 |
|
9 Always use malloc() and free() directly in this file. A number of these |
|
10 functions are advertised as safe to call when the GIL isn't held, and in |
|
11 a debug build Python redirects (e.g.) PyMem_NEW (etc) to Python's debugging |
|
12 obmalloc functions. Those aren't thread-safe (they rely on the GIL to avoid |
|
13 the expense of doing their own locking). |
|
14 -------------------------------------------------------------------------- */ |
|
15 |
|
16 #ifdef HAVE_DLOPEN |
|
17 #ifdef HAVE_DLFCN_H |
|
18 #include <dlfcn.h> |
|
19 #endif |
|
20 #ifndef RTLD_LAZY |
|
21 #define RTLD_LAZY 1 |
|
22 #endif |
|
23 #endif |
|
24 |
|
25 |
|
26 #ifdef WITH_THREAD |
|
27 #include "pythread.h" |
|
28 static PyThread_type_lock head_mutex = NULL; /* Protects interp->tstate_head */ |
|
29 #define HEAD_INIT() (void)(head_mutex || (head_mutex = PyThread_allocate_lock())) |
|
30 #define HEAD_LOCK() PyThread_acquire_lock(head_mutex, WAIT_LOCK) |
|
31 #define HEAD_UNLOCK() PyThread_release_lock(head_mutex) |
|
32 |
|
33 #ifdef __cplusplus |
|
34 extern "C" { |
|
35 #endif |
|
36 |
|
37 /* The single PyInterpreterState used by this process' |
|
38 GILState implementation |
|
39 */ |
|
40 static PyInterpreterState *autoInterpreterState = NULL; |
|
41 static int autoTLSkey = 0; |
|
42 #else |
|
43 #define HEAD_INIT() /* Nothing */ |
|
44 #define HEAD_LOCK() /* Nothing */ |
|
45 #define HEAD_UNLOCK() /* Nothing */ |
|
46 #endif |
|
47 |
|
48 static PyInterpreterState *interp_head = NULL; |
|
49 |
|
50 PyThreadState *_PyThreadState_Current = NULL; |
|
51 PyThreadFrameGetter _PyThreadState_GetFrame = NULL; |
|
52 |
|
53 #ifdef WITH_THREAD |
|
54 static void _PyGILState_NoteThreadState(PyThreadState* tstate); |
|
55 #endif |
|
56 |
|
57 |
|
58 PyInterpreterState * |
|
59 PyInterpreterState_New(void) |
|
60 { |
|
61 PyInterpreterState *interp = (PyInterpreterState *) |
|
62 malloc(sizeof(PyInterpreterState)); |
|
63 |
|
64 if (interp != NULL) { |
|
65 HEAD_INIT(); |
|
66 #ifdef WITH_THREAD |
|
67 if (head_mutex == NULL) |
|
68 Py_FatalError("Can't initialize threads for interpreter"); |
|
69 #endif |
|
70 interp->modules = NULL; |
|
71 interp->modules_reloading = NULL; |
|
72 interp->sysdict = NULL; |
|
73 interp->builtins = NULL; |
|
74 interp->tstate_head = NULL; |
|
75 interp->codec_search_path = NULL; |
|
76 interp->codec_search_cache = NULL; |
|
77 interp->codec_error_registry = NULL; |
|
78 #ifdef HAVE_DLOPEN |
|
79 #ifdef RTLD_NOW |
|
80 interp->dlopenflags = RTLD_NOW; |
|
81 #else |
|
82 interp->dlopenflags = RTLD_LAZY; |
|
83 #endif |
|
84 #endif |
|
85 #ifdef WITH_TSC |
|
86 interp->tscdump = 0; |
|
87 #endif |
|
88 |
|
89 HEAD_LOCK(); |
|
90 interp->next = interp_head; |
|
91 interp_head = interp; |
|
92 HEAD_UNLOCK(); |
|
93 } |
|
94 |
|
95 return interp; |
|
96 } |
|
97 |
|
98 |
|
99 void |
|
100 PyInterpreterState_Clear(PyInterpreterState *interp) |
|
101 { |
|
102 PyThreadState *p; |
|
103 HEAD_LOCK(); |
|
104 for (p = interp->tstate_head; p != NULL; p = p->next) |
|
105 PyThreadState_Clear(p); |
|
106 HEAD_UNLOCK(); |
|
107 Py_CLEAR(interp->codec_search_path); |
|
108 Py_CLEAR(interp->codec_search_cache); |
|
109 Py_CLEAR(interp->codec_error_registry); |
|
110 Py_CLEAR(interp->modules); |
|
111 Py_CLEAR(interp->modules_reloading); |
|
112 Py_CLEAR(interp->sysdict); |
|
113 Py_CLEAR(interp->builtins); |
|
114 } |
|
115 |
|
116 |
|
117 static void |
|
118 zapthreads(PyInterpreterState *interp) |
|
119 { |
|
120 PyThreadState *p; |
|
121 /* No need to lock the mutex here because this should only happen |
|
122 when the threads are all really dead (XXX famous last words). */ |
|
123 while ((p = interp->tstate_head) != NULL) { |
|
124 PyThreadState_Delete(p); |
|
125 } |
|
126 } |
|
127 |
|
128 |
|
129 void |
|
130 PyInterpreterState_Delete(PyInterpreterState *interp) |
|
131 { |
|
132 PyInterpreterState **p; |
|
133 zapthreads(interp); |
|
134 HEAD_LOCK(); |
|
135 for (p = &interp_head; ; p = &(*p)->next) { |
|
136 if (*p == NULL) |
|
137 Py_FatalError( |
|
138 "PyInterpreterState_Delete: invalid interp"); |
|
139 if (*p == interp) |
|
140 break; |
|
141 } |
|
142 if (interp->tstate_head != NULL) |
|
143 Py_FatalError("PyInterpreterState_Delete: remaining threads"); |
|
144 *p = interp->next; |
|
145 HEAD_UNLOCK(); |
|
146 free(interp); |
|
147 } |
|
148 |
|
149 |
|
150 /* Default implementation for _PyThreadState_GetFrame */ |
|
151 static struct _frame * |
|
152 threadstate_getframe(PyThreadState *self) |
|
153 { |
|
154 return self->frame; |
|
155 } |
|
156 |
|
157 PyThreadState * |
|
158 PyThreadState_New(PyInterpreterState *interp) |
|
159 { |
|
160 PyThreadState *tstate = (PyThreadState *)malloc(sizeof(PyThreadState)); |
|
161 |
|
162 if (_PyThreadState_GetFrame == NULL) |
|
163 _PyThreadState_GetFrame = threadstate_getframe; |
|
164 |
|
165 if (tstate != NULL) { |
|
166 tstate->interp = interp; |
|
167 |
|
168 tstate->frame = NULL; |
|
169 tstate->recursion_depth = 0; |
|
170 tstate->tracing = 0; |
|
171 tstate->use_tracing = 0; |
|
172 tstate->tick_counter = 0; |
|
173 tstate->gilstate_counter = 0; |
|
174 tstate->async_exc = NULL; |
|
175 #ifdef WITH_THREAD |
|
176 tstate->thread_id = PyThread_get_thread_ident(); |
|
177 #else |
|
178 tstate->thread_id = 0; |
|
179 #endif |
|
180 |
|
181 tstate->dict = NULL; |
|
182 |
|
183 tstate->curexc_type = NULL; |
|
184 tstate->curexc_value = NULL; |
|
185 tstate->curexc_traceback = NULL; |
|
186 |
|
187 tstate->exc_type = NULL; |
|
188 tstate->exc_value = NULL; |
|
189 tstate->exc_traceback = NULL; |
|
190 |
|
191 tstate->c_profilefunc = NULL; |
|
192 tstate->c_tracefunc = NULL; |
|
193 tstate->c_profileobj = NULL; |
|
194 tstate->c_traceobj = NULL; |
|
195 |
|
196 #ifdef WITH_THREAD |
|
197 _PyGILState_NoteThreadState(tstate); |
|
198 #endif |
|
199 |
|
200 HEAD_LOCK(); |
|
201 tstate->next = interp->tstate_head; |
|
202 interp->tstate_head = tstate; |
|
203 HEAD_UNLOCK(); |
|
204 } |
|
205 |
|
206 return tstate; |
|
207 } |
|
208 |
|
209 |
|
210 void |
|
211 PyThreadState_Clear(PyThreadState *tstate) |
|
212 { |
|
213 if (Py_VerboseFlag && tstate->frame != NULL) |
|
214 fprintf(stderr, |
|
215 "PyThreadState_Clear: warning: thread still has a frame\n"); |
|
216 |
|
217 Py_CLEAR(tstate->frame); |
|
218 |
|
219 Py_CLEAR(tstate->dict); |
|
220 Py_CLEAR(tstate->async_exc); |
|
221 |
|
222 Py_CLEAR(tstate->curexc_type); |
|
223 Py_CLEAR(tstate->curexc_value); |
|
224 Py_CLEAR(tstate->curexc_traceback); |
|
225 |
|
226 Py_CLEAR(tstate->exc_type); |
|
227 Py_CLEAR(tstate->exc_value); |
|
228 Py_CLEAR(tstate->exc_traceback); |
|
229 |
|
230 tstate->c_profilefunc = NULL; |
|
231 tstate->c_tracefunc = NULL; |
|
232 Py_CLEAR(tstate->c_profileobj); |
|
233 Py_CLEAR(tstate->c_traceobj); |
|
234 } |
|
235 |
|
236 |
|
237 /* Common code for PyThreadState_Delete() and PyThreadState_DeleteCurrent() */ |
|
238 static void |
|
239 tstate_delete_common(PyThreadState *tstate) |
|
240 { |
|
241 PyInterpreterState *interp; |
|
242 PyThreadState **p; |
|
243 PyThreadState *prev_p = NULL; |
|
244 if (tstate == NULL) |
|
245 Py_FatalError("PyThreadState_Delete: NULL tstate"); |
|
246 interp = tstate->interp; |
|
247 if (interp == NULL) |
|
248 Py_FatalError("PyThreadState_Delete: NULL interp"); |
|
249 HEAD_LOCK(); |
|
250 for (p = &interp->tstate_head; ; p = &(*p)->next) { |
|
251 if (*p == NULL) |
|
252 Py_FatalError( |
|
253 "PyThreadState_Delete: invalid tstate"); |
|
254 if (*p == tstate) |
|
255 break; |
|
256 /* Sanity check. These states should never happen but if |
|
257 * they do we must abort. Otherwise we'll end up spinning in |
|
258 * in a tight loop with the lock held. A similar check is done |
|
259 * in thread.c find_key(). */ |
|
260 if (*p == prev_p) |
|
261 Py_FatalError( |
|
262 "PyThreadState_Delete: small circular list(!)" |
|
263 " and tstate not found."); |
|
264 prev_p = *p; |
|
265 if ((*p)->next == interp->tstate_head) |
|
266 Py_FatalError( |
|
267 "PyThreadState_Delete: circular list(!) and" |
|
268 " tstate not found."); |
|
269 } |
|
270 *p = tstate->next; |
|
271 HEAD_UNLOCK(); |
|
272 free(tstate); |
|
273 } |
|
274 |
|
275 |
|
276 void |
|
277 PyThreadState_Delete(PyThreadState *tstate) |
|
278 { |
|
279 if (tstate == _PyThreadState_Current) |
|
280 Py_FatalError("PyThreadState_Delete: tstate is still current"); |
|
281 tstate_delete_common(tstate); |
|
282 #ifdef WITH_THREAD |
|
283 if (autoTLSkey && PyThread_get_key_value(autoTLSkey) == tstate) |
|
284 PyThread_delete_key_value(autoTLSkey); |
|
285 #endif /* WITH_THREAD */ |
|
286 } |
|
287 |
|
288 |
|
289 #ifdef WITH_THREAD |
|
290 void |
|
291 PyThreadState_DeleteCurrent() |
|
292 { |
|
293 PyThreadState *tstate = _PyThreadState_Current; |
|
294 if (tstate == NULL) |
|
295 Py_FatalError( |
|
296 "PyThreadState_DeleteCurrent: no current tstate"); |
|
297 _PyThreadState_Current = NULL; |
|
298 tstate_delete_common(tstate); |
|
299 if (autoTLSkey && PyThread_get_key_value(autoTLSkey) == tstate) |
|
300 PyThread_delete_key_value(autoTLSkey); |
|
301 PyEval_ReleaseLock(); |
|
302 } |
|
303 #endif /* WITH_THREAD */ |
|
304 |
|
305 |
|
306 PyThreadState * |
|
307 PyThreadState_Get(void) |
|
308 { |
|
309 if (_PyThreadState_Current == NULL) |
|
310 Py_FatalError("PyThreadState_Get: no current thread"); |
|
311 |
|
312 return _PyThreadState_Current; |
|
313 } |
|
314 |
|
315 |
|
316 PyThreadState * |
|
317 PyThreadState_Swap(PyThreadState *newts) |
|
318 { |
|
319 PyThreadState *oldts = _PyThreadState_Current; |
|
320 |
|
321 _PyThreadState_Current = newts; |
|
322 /* It should not be possible for more than one thread state |
|
323 to be used for a thread. Check this the best we can in debug |
|
324 builds. |
|
325 */ |
|
326 #if defined(Py_DEBUG) && defined(WITH_THREAD) |
|
327 if (newts) { |
|
328 /* This can be called from PyEval_RestoreThread(). Similar |
|
329 to it, we need to ensure errno doesn't change. |
|
330 */ |
|
331 int err = errno; |
|
332 PyThreadState *check = PyGILState_GetThisThreadState(); |
|
333 if (check && check->interp == newts->interp && check != newts) |
|
334 Py_FatalError("Invalid thread state for this thread"); |
|
335 errno = err; |
|
336 } |
|
337 #endif |
|
338 return oldts; |
|
339 } |
|
340 |
|
341 /* An extension mechanism to store arbitrary additional per-thread state. |
|
342 PyThreadState_GetDict() returns a dictionary that can be used to hold such |
|
343 state; the caller should pick a unique key and store its state there. If |
|
344 PyThreadState_GetDict() returns NULL, an exception has *not* been raised |
|
345 and the caller should assume no per-thread state is available. */ |
|
346 |
|
347 PyObject * |
|
348 PyThreadState_GetDict(void) |
|
349 { |
|
350 if (_PyThreadState_Current == NULL) |
|
351 return NULL; |
|
352 |
|
353 if (_PyThreadState_Current->dict == NULL) { |
|
354 PyObject *d; |
|
355 _PyThreadState_Current->dict = d = PyDict_New(); |
|
356 if (d == NULL) |
|
357 PyErr_Clear(); |
|
358 } |
|
359 return _PyThreadState_Current->dict; |
|
360 } |
|
361 |
|
362 |
|
363 /* Asynchronously raise an exception in a thread. |
|
364 Requested by Just van Rossum and Alex Martelli. |
|
365 To prevent naive misuse, you must write your own extension |
|
366 to call this, or use ctypes. Must be called with the GIL held. |
|
367 Returns the number of tstates modified (normally 1, but 0 if `id` didn't |
|
368 match any known thread id). Can be called with exc=NULL to clear an |
|
369 existing async exception. This raises no exceptions. */ |
|
370 |
|
371 int |
|
372 PyThreadState_SetAsyncExc(long id, PyObject *exc) { |
|
373 PyThreadState *tstate = PyThreadState_GET(); |
|
374 PyInterpreterState *interp = tstate->interp; |
|
375 PyThreadState *p; |
|
376 |
|
377 /* Although the GIL is held, a few C API functions can be called |
|
378 * without the GIL held, and in particular some that create and |
|
379 * destroy thread and interpreter states. Those can mutate the |
|
380 * list of thread states we're traversing, so to prevent that we lock |
|
381 * head_mutex for the duration. |
|
382 */ |
|
383 HEAD_LOCK(); |
|
384 for (p = interp->tstate_head; p != NULL; p = p->next) { |
|
385 if (p->thread_id == id) { |
|
386 /* Tricky: we need to decref the current value |
|
387 * (if any) in p->async_exc, but that can in turn |
|
388 * allow arbitrary Python code to run, including |
|
389 * perhaps calls to this function. To prevent |
|
390 * deadlock, we need to release head_mutex before |
|
391 * the decref. |
|
392 */ |
|
393 PyObject *old_exc = p->async_exc; |
|
394 Py_XINCREF(exc); |
|
395 p->async_exc = exc; |
|
396 HEAD_UNLOCK(); |
|
397 Py_XDECREF(old_exc); |
|
398 return 1; |
|
399 } |
|
400 } |
|
401 HEAD_UNLOCK(); |
|
402 return 0; |
|
403 } |
|
404 |
|
405 |
|
406 /* Routines for advanced debuggers, requested by David Beazley. |
|
407 Don't use unless you know what you are doing! */ |
|
408 |
|
409 PyInterpreterState * |
|
410 PyInterpreterState_Head(void) |
|
411 { |
|
412 return interp_head; |
|
413 } |
|
414 |
|
415 PyInterpreterState * |
|
416 PyInterpreterState_Next(PyInterpreterState *interp) { |
|
417 return interp->next; |
|
418 } |
|
419 |
|
420 PyThreadState * |
|
421 PyInterpreterState_ThreadHead(PyInterpreterState *interp) { |
|
422 return interp->tstate_head; |
|
423 } |
|
424 |
|
425 PyThreadState * |
|
426 PyThreadState_Next(PyThreadState *tstate) { |
|
427 return tstate->next; |
|
428 } |
|
429 |
|
430 /* The implementation of sys._current_frames(). This is intended to be |
|
431 called with the GIL held, as it will be when called via |
|
432 sys._current_frames(). It's possible it would work fine even without |
|
433 the GIL held, but haven't thought enough about that. |
|
434 */ |
|
435 PyObject * |
|
436 _PyThread_CurrentFrames(void) |
|
437 { |
|
438 PyObject *result; |
|
439 PyInterpreterState *i; |
|
440 |
|
441 result = PyDict_New(); |
|
442 if (result == NULL) |
|
443 return NULL; |
|
444 |
|
445 /* for i in all interpreters: |
|
446 * for t in all of i's thread states: |
|
447 * if t's frame isn't NULL, map t's id to its frame |
|
448 * Because these lists can mutute even when the GIL is held, we |
|
449 * need to grab head_mutex for the duration. |
|
450 */ |
|
451 HEAD_LOCK(); |
|
452 for (i = interp_head; i != NULL; i = i->next) { |
|
453 PyThreadState *t; |
|
454 for (t = i->tstate_head; t != NULL; t = t->next) { |
|
455 PyObject *id; |
|
456 int stat; |
|
457 struct _frame *frame = t->frame; |
|
458 if (frame == NULL) |
|
459 continue; |
|
460 id = PyInt_FromLong(t->thread_id); |
|
461 if (id == NULL) |
|
462 goto Fail; |
|
463 stat = PyDict_SetItem(result, id, (PyObject *)frame); |
|
464 Py_DECREF(id); |
|
465 if (stat < 0) |
|
466 goto Fail; |
|
467 } |
|
468 } |
|
469 HEAD_UNLOCK(); |
|
470 return result; |
|
471 |
|
472 Fail: |
|
473 HEAD_UNLOCK(); |
|
474 Py_DECREF(result); |
|
475 return NULL; |
|
476 } |
|
477 |
|
478 /* Python "auto thread state" API. */ |
|
479 #ifdef WITH_THREAD |
|
480 |
|
481 /* Keep this as a static, as it is not reliable! It can only |
|
482 ever be compared to the state for the *current* thread. |
|
483 * If not equal, then it doesn't matter that the actual |
|
484 value may change immediately after comparison, as it can't |
|
485 possibly change to the current thread's state. |
|
486 * If equal, then the current thread holds the lock, so the value can't |
|
487 change until we yield the lock. |
|
488 */ |
|
489 static int |
|
490 PyThreadState_IsCurrent(PyThreadState *tstate) |
|
491 { |
|
492 /* Must be the tstate for this thread */ |
|
493 assert(PyGILState_GetThisThreadState()==tstate); |
|
494 /* On Windows at least, simple reads and writes to 32 bit values |
|
495 are atomic. |
|
496 */ |
|
497 return tstate == _PyThreadState_Current; |
|
498 } |
|
499 |
|
500 /* Internal initialization/finalization functions called by |
|
501 Py_Initialize/Py_Finalize |
|
502 */ |
|
503 void |
|
504 _PyGILState_Init(PyInterpreterState *i, PyThreadState *t) |
|
505 { |
|
506 assert(i && t); /* must init with valid states */ |
|
507 autoTLSkey = PyThread_create_key(); |
|
508 autoInterpreterState = i; |
|
509 assert(PyThread_get_key_value(autoTLSkey) == NULL); |
|
510 assert(t->gilstate_counter == 0); |
|
511 |
|
512 _PyGILState_NoteThreadState(t); |
|
513 } |
|
514 |
|
515 void |
|
516 _PyGILState_Fini(void) |
|
517 { |
|
518 PyThread_delete_key(autoTLSkey); |
|
519 autoTLSkey = 0; |
|
520 autoInterpreterState = NULL; |
|
521 } |
|
522 |
|
523 /* When a thread state is created for a thread by some mechanism other than |
|
524 PyGILState_Ensure, it's important that the GILState machinery knows about |
|
525 it so it doesn't try to create another thread state for the thread (this is |
|
526 a better fix for SF bug #1010677 than the first one attempted). |
|
527 */ |
|
528 static void |
|
529 _PyGILState_NoteThreadState(PyThreadState* tstate) |
|
530 { |
|
531 /* If autoTLSkey is 0, this must be the very first threadstate created |
|
532 in Py_Initialize(). Don't do anything for now (we'll be back here |
|
533 when _PyGILState_Init is called). */ |
|
534 if (!autoTLSkey) |
|
535 return; |
|
536 |
|
537 /* Stick the thread state for this thread in thread local storage. |
|
538 |
|
539 The only situation where you can legitimately have more than one |
|
540 thread state for an OS level thread is when there are multiple |
|
541 interpreters, when: |
|
542 |
|
543 a) You shouldn't really be using the PyGILState_ APIs anyway, |
|
544 and: |
|
545 |
|
546 b) The slightly odd way PyThread_set_key_value works (see |
|
547 comments by its implementation) means that the first thread |
|
548 state created for that given OS level thread will "win", |
|
549 which seems reasonable behaviour. |
|
550 */ |
|
551 if (PyThread_set_key_value(autoTLSkey, (void *)tstate) < 0) |
|
552 Py_FatalError("Couldn't create autoTLSkey mapping"); |
|
553 |
|
554 /* PyGILState_Release must not try to delete this thread state. */ |
|
555 tstate->gilstate_counter = 1; |
|
556 } |
|
557 |
|
558 /* The public functions */ |
|
559 PyThreadState * |
|
560 PyGILState_GetThisThreadState(void) |
|
561 { |
|
562 if (autoInterpreterState == NULL || autoTLSkey == 0) |
|
563 return NULL; |
|
564 return (PyThreadState *)PyThread_get_key_value(autoTLSkey); |
|
565 } |
|
566 |
|
567 PyGILState_STATE |
|
568 PyGILState_Ensure(void) |
|
569 { |
|
570 int current; |
|
571 PyThreadState *tcur; |
|
572 /* Note that we do not auto-init Python here - apart from |
|
573 potential races with 2 threads auto-initializing, pep-311 |
|
574 spells out other issues. Embedders are expected to have |
|
575 called Py_Initialize() and usually PyEval_InitThreads(). |
|
576 */ |
|
577 assert(autoInterpreterState); /* Py_Initialize() hasn't been called! */ |
|
578 tcur = (PyThreadState *)PyThread_get_key_value(autoTLSkey); |
|
579 if (tcur == NULL) { |
|
580 /* Create a new thread state for this thread */ |
|
581 tcur = PyThreadState_New(autoInterpreterState); |
|
582 if (tcur == NULL) |
|
583 Py_FatalError("Couldn't create thread-state for new thread"); |
|
584 /* This is our thread state! We'll need to delete it in the |
|
585 matching call to PyGILState_Release(). */ |
|
586 tcur->gilstate_counter = 0; |
|
587 current = 0; /* new thread state is never current */ |
|
588 } |
|
589 else |
|
590 current = PyThreadState_IsCurrent(tcur); |
|
591 if (current == 0) |
|
592 PyEval_RestoreThread(tcur); |
|
593 /* Update our counter in the thread-state - no need for locks: |
|
594 - tcur will remain valid as we hold the GIL. |
|
595 - the counter is safe as we are the only thread "allowed" |
|
596 to modify this value |
|
597 */ |
|
598 ++tcur->gilstate_counter; |
|
599 return current ? PyGILState_LOCKED : PyGILState_UNLOCKED; |
|
600 } |
|
601 |
|
602 void |
|
603 PyGILState_Release(PyGILState_STATE oldstate) |
|
604 { |
|
605 PyThreadState *tcur = (PyThreadState *)PyThread_get_key_value( |
|
606 autoTLSkey); |
|
607 if (tcur == NULL) |
|
608 Py_FatalError("auto-releasing thread-state, " |
|
609 "but no thread-state for this thread"); |
|
610 /* We must hold the GIL and have our thread state current */ |
|
611 /* XXX - remove the check - the assert should be fine, |
|
612 but while this is very new (April 2003), the extra check |
|
613 by release-only users can't hurt. |
|
614 */ |
|
615 if (! PyThreadState_IsCurrent(tcur)) |
|
616 Py_FatalError("This thread state must be current when releasing"); |
|
617 assert(PyThreadState_IsCurrent(tcur)); |
|
618 --tcur->gilstate_counter; |
|
619 assert(tcur->gilstate_counter >= 0); /* illegal counter value */ |
|
620 |
|
621 /* If we're going to destroy this thread-state, we must |
|
622 * clear it while the GIL is held, as destructors may run. |
|
623 */ |
|
624 if (tcur->gilstate_counter == 0) { |
|
625 /* can't have been locked when we created it */ |
|
626 assert(oldstate == PyGILState_UNLOCKED); |
|
627 PyThreadState_Clear(tcur); |
|
628 /* Delete the thread-state. Note this releases the GIL too! |
|
629 * It's vital that the GIL be held here, to avoid shutdown |
|
630 * races; see bugs 225673 and 1061968 (that nasty bug has a |
|
631 * habit of coming back). |
|
632 */ |
|
633 PyThreadState_DeleteCurrent(); |
|
634 } |
|
635 /* Release the lock if necessary */ |
|
636 else if (oldstate == PyGILState_UNLOCKED) |
|
637 PyEval_SaveThread(); |
|
638 } |
|
639 |
|
640 #ifdef __cplusplus |
|
641 } |
|
642 #endif |
|
643 |
|
644 #endif /* WITH_THREAD */ |
|
645 |
|
646 |