Python/pystate.c

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