AppPkg/Applications/Python/Python-2.7.2/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->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 static PyThreadState *
 158 new_threadstate(PyInterpreterState *interp, int init)
 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         if (init)
 197             _PyThreadState_Init(tstate);
 198
 199         HEAD_LOCK();
 200         tstate->next = interp->tstate_head;
 201         interp->tstate_head = tstate;
 202         HEAD_UNLOCK();
 203     }
 204
 205     return tstate;
 206 }
 207
 208 PyThreadState *
 209 PyThreadState_New(PyInterpreterState *interp)
 210 {
 211     return new_threadstate(interp, 1);
 212 }
 213
 214 PyThreadState *
 215 _PyThreadState_Prealloc(PyInterpreterState *interp)
 216 {
 217     return new_threadstate(interp, 0);
 218 }
 219
 220 void
 221 _PyThreadState_Init(PyThreadState *tstate)
 222 {
 223 #ifdef WITH_THREAD
 224     _PyGILState_NoteThreadState(tstate);
 225 #endif
 226 }
 227
 228 void
 229 PyThreadState_Clear(PyThreadState *tstate)
 230 {
 231     if (Py_VerboseFlag && tstate->frame != NULL)
 232         fprintf(stderr,
 233           "PyThreadState_Clear: warning: thread still has a frame\n");
 234
 235     Py_CLEAR(tstate->frame);
 236
 237     Py_CLEAR(tstate->dict);
 238     Py_CLEAR(tstate->async_exc);
 239
 240     Py_CLEAR(tstate->curexc_type);
 241     Py_CLEAR(tstate->curexc_value);
 242     Py_CLEAR(tstate->curexc_traceback);
 243
 244     Py_CLEAR(tstate->exc_type);
 245     Py_CLEAR(tstate->exc_value);
 246     Py_CLEAR(tstate->exc_traceback);
 247
 248     tstate->c_profilefunc = NULL;
 249     tstate->c_tracefunc = NULL;
 250     Py_CLEAR(tstate->c_profileobj);
 251     Py_CLEAR(tstate->c_traceobj);
 252 }
 253
 254
 255 /* Common code for PyThreadState_Delete() and PyThreadState_DeleteCurrent() */
 256 static void
 257 tstate_delete_common(PyThreadState *tstate)
 258 {
 259     PyInterpreterState *interp;
 260     PyThreadState **p;
 261     PyThreadState *prev_p = NULL;
 262     if (tstate == NULL)
 263         Py_FatalError("PyThreadState_Delete: NULL tstate");
 264     interp = tstate->interp;
 265     if (interp == NULL)
 266         Py_FatalError("PyThreadState_Delete: NULL interp");
 267     HEAD_LOCK();
 268     for (p = &interp->tstate_head; ; p = &(*p)->next) {
 269         if (*p == NULL)
 270             Py_FatalError(
 271                 "PyThreadState_Delete: invalid tstate");
 272         if (*p == tstate)
 273             break;
 274         /* Sanity check.  These states should never happen but if
 275          * they do we must abort.  Otherwise we'll end up spinning in
 276          * in a tight loop with the lock held.  A similar check is done
 277          * in thread.c find_key().  */
 278         if (*p == prev_p)
 279             Py_FatalError(
 280                 "PyThreadState_Delete: small circular list(!)"
 281                 " and tstate not found.");
 282         prev_p = *p;
 283         if ((*p)->next == interp->tstate_head)
 284             Py_FatalError(
 285                 "PyThreadState_Delete: circular list(!) and"
 286                 " tstate not found.");
 287     }
 288     *p = tstate->next;
 289     HEAD_UNLOCK();
 290     free(tstate);
 291 }
 292
 293
 294 void
 295 PyThreadState_Delete(PyThreadState *tstate)
 296 {
 297     if (tstate == _PyThreadState_Current)
 298         Py_FatalError("PyThreadState_Delete: tstate is still current");
 299     tstate_delete_common(tstate);
 300 #ifdef WITH_THREAD
 301     if (autoInterpreterState && PyThread_get_key_value(autoTLSkey) == tstate)
 302         PyThread_delete_key_value(autoTLSkey);
 303 #endif /* WITH_THREAD */
 304 }
 305
 306
 307 #ifdef WITH_THREAD
 308 void
 309 PyThreadState_DeleteCurrent()
 310 {
 311     PyThreadState *tstate = _PyThreadState_Current;
 312     if (tstate == NULL)
 313         Py_FatalError(
 314             "PyThreadState_DeleteCurrent: no current tstate");
 315     _PyThreadState_Current = NULL;
 316     tstate_delete_common(tstate);
 317     if (autoInterpreterState && PyThread_get_key_value(autoTLSkey) == tstate)
 318         PyThread_delete_key_value(autoTLSkey);
 319     PyEval_ReleaseLock();
 320 }
 321 #endif /* WITH_THREAD */
 322
 323
 324 PyThreadState *
 325 PyThreadState_Get(void)
 326 {
 327     if (_PyThreadState_Current == NULL)
 328         Py_FatalError("PyThreadState_Get: no current thread");
 329
 330     return _PyThreadState_Current;
 331 }
 332
 333
 334 PyThreadState *
 335 PyThreadState_Swap(PyThreadState *newts)
 336 {
 337     PyThreadState *oldts = _PyThreadState_Current;
 338
 339     _PyThreadState_Current = newts;
 340     /* It should not be possible for more than one thread state
 341        to be used for a thread.  Check this the best we can in debug
 342        builds.
 343     */
 344 #if defined(Py_DEBUG) && defined(WITH_THREAD)
 345     if (newts) {
 346         /* This can be called from PyEval_RestoreThread(). Similar
 347            to it, we need to ensure errno doesn't change.
 348         */
 349         int err = errno;
 350         PyThreadState *check = PyGILState_GetThisThreadState();
 351         if (check && check->interp == newts->interp && check != newts)
 352             Py_FatalError("Invalid thread state for this thread");
 353         errno = err;
 354     }
 355 #endif
 356     return oldts;
 357 }
 358
 359 /* An extension mechanism to store arbitrary additional per-thread state.
 360    PyThreadState_GetDict() returns a dictionary that can be used to hold such
 361    state; the caller should pick a unique key and store its state there.  If
 362    PyThreadState_GetDict() returns NULL, an exception has *not* been raised
 363    and the caller should assume no per-thread state is available. */
 364
 365 PyObject *
 366 PyThreadState_GetDict(void)
 367 {
 368     if (_PyThreadState_Current == NULL)
 369         return NULL;
 370
 371     if (_PyThreadState_Current->dict == NULL) {
 372         PyObject *d;
 373         _PyThreadState_Current->dict = d = PyDict_New();
 374         if (d == NULL)
 375             PyErr_Clear();
 376     }
 377     return _PyThreadState_Current->dict;
 378 }
 379
 380
 381 /* Asynchronously raise an exception in a thread.
 382    Requested by Just van Rossum and Alex Martelli.
 383    To prevent naive misuse, you must write your own extension
 384    to call this, or use ctypes.  Must be called with the GIL held.
 385    Returns the number of tstates modified (normally 1, but 0 if `id` didn't
 386    match any known thread id).  Can be called with exc=NULL to clear an
 387    existing async exception.  This raises no exceptions. */
 388
 389 int
 390 PyThreadState_SetAsyncExc(long id, PyObject *exc) {
 391     PyThreadState *tstate = PyThreadState_GET();
 392     PyInterpreterState *interp = tstate->interp;
 393     PyThreadState *p;
 394
 395     /* Although the GIL is held, a few C API functions can be called
 396      * without the GIL held, and in particular some that create and
 397      * destroy thread and interpreter states.  Those can mutate the
 398      * list of thread states we're traversing, so to prevent that we lock
 399      * head_mutex for the duration.
 400      */
 401     HEAD_LOCK();
 402     for (p = interp->tstate_head; p != NULL; p = p->next) {
 403         if (p->thread_id == id) {
 404             /* Tricky:  we need to decref the current value
 405              * (if any) in p->async_exc, but that can in turn
 406              * allow arbitrary Python code to run, including
 407              * perhaps calls to this function.  To prevent
 408              * deadlock, we need to release head_mutex before
 409              * the decref.
 410              */
 411             PyObject *old_exc = p->async_exc;
 412             Py_XINCREF(exc);
 413             p->async_exc = exc;
 414             HEAD_UNLOCK();
 415             Py_XDECREF(old_exc);
 416             return 1;
 417         }
 418     }
 419     HEAD_UNLOCK();
 420     return 0;
 421 }
 422
 423
 424 /* Routines for advanced debuggers, requested by David Beazley.
 425    Don't use unless you know what you are doing! */
 426
 427 PyInterpreterState *
 428 PyInterpreterState_Head(void)
 429 {
 430     return interp_head;
 431 }
 432
 433 PyInterpreterState *
 434 PyInterpreterState_Next(PyInterpreterState *interp) {
 435     return interp->next;
 436 }
 437
 438 PyThreadState *
 439 PyInterpreterState_ThreadHead(PyInterpreterState *interp) {
 440     return interp->tstate_head;
 441 }
 442
 443 PyThreadState *
 444 PyThreadState_Next(PyThreadState *tstate) {
 445     return tstate->next;
 446 }
 447
 448 /* The implementation of sys._current_frames().  This is intended to be
 449    called with the GIL held, as it will be when called via
 450    sys._current_frames().  It's possible it would work fine even without
 451    the GIL held, but haven't thought enough about that.
 452 */
 453 PyObject *
 454 _PyThread_CurrentFrames(void)
 455 {
 456     PyObject *result;
 457     PyInterpreterState *i;
 458
 459     result = PyDict_New();
 460     if (result == NULL)
 461         return NULL;
 462
 463     /* for i in all interpreters:
 464      *     for t in all of i's thread states:
 465      *          if t's frame isn't NULL, map t's id to its frame
 466      * Because these lists can mutate even when the GIL is held, we
 467      * need to grab head_mutex for the duration.
 468      */
 469     HEAD_LOCK();
 470     for (i = interp_head; i != NULL; i = i->next) {
 471         PyThreadState *t;
 472         for (t = i->tstate_head; t != NULL; t = t->next) {
 473             PyObject *id;
 474             int stat;
 475             struct _frame *frame = t->frame;
 476             if (frame == NULL)
 477                 continue;
 478             id = PyInt_FromLong(t->thread_id);
 479             if (id == NULL)
 480                 goto Fail;
 481             stat = PyDict_SetItem(result, id, (PyObject *)frame);
 482             Py_DECREF(id);
 483             if (stat < 0)
 484                 goto Fail;
 485         }
 486     }
 487     HEAD_UNLOCK();
 488     return result;
 489
 490  Fail:
 491     HEAD_UNLOCK();
 492     Py_DECREF(result);
 493     return NULL;
 494 }
 495
 496 /* Python "auto thread state" API. */
 497 #ifdef WITH_THREAD
 498
 499 /* Keep this as a static, as it is not reliable!  It can only
 500    ever be compared to the state for the *current* thread.
 501    * If not equal, then it doesn't matter that the actual
 502      value may change immediately after comparison, as it can't
 503      possibly change to the current thread's state.
 504    * If equal, then the current thread holds the lock, so the value can't
 505      change until we yield the lock.
 506 */
 507 static int
 508 PyThreadState_IsCurrent(PyThreadState *tstate)
 509 {
 510     /* Must be the tstate for this thread */
 511     assert(PyGILState_GetThisThreadState()==tstate);
 512     /* On Windows at least, simple reads and writes to 32 bit values
 513        are atomic.
 514     */
 515     return tstate == _PyThreadState_Current;
 516 }
 517
 518 /* Internal initialization/finalization functions called by
 519    Py_Initialize/Py_Finalize
 520 */
 521 void
 522 _PyGILState_Init(PyInterpreterState *i, PyThreadState *t)
 523 {
 524     assert(i && t); /* must init with valid states */
 525     autoTLSkey = PyThread_create_key();
 526     autoInterpreterState = i;
 527     assert(PyThread_get_key_value(autoTLSkey) == NULL);
 528     assert(t->gilstate_counter == 0);
 529
 530     _PyGILState_NoteThreadState(t);
 531 }
 532
 533 void
 534 _PyGILState_Fini(void)
 535 {
 536     PyThread_delete_key(autoTLSkey);
 537     autoInterpreterState = NULL;
 538 }
 539
 540 /* Reset the TLS key - called by PyOS_AfterFork.
 541  * This should not be necessary, but some - buggy - pthread implementations
 542  * don't flush TLS on fork, see issue #10517.
 543  */
 544 void
 545 _PyGILState_Reinit(void)
 546 {
 547     PyThreadState *tstate = PyGILState_GetThisThreadState();
 548     PyThread_delete_key(autoTLSkey);
 549     if ((autoTLSkey = PyThread_create_key()) == -1)
 550         Py_FatalError("Could not allocate TLS entry");
 551
 552     /* re-associate the current thread state with the new key */
 553     if (PyThread_set_key_value(autoTLSkey, (void *)tstate) < 0)
 554         Py_FatalError("Couldn't create autoTLSkey mapping");
 555 }
 556
 557 /* When a thread state is created for a thread by some mechanism other than
 558    PyGILState_Ensure, it's important that the GILState machinery knows about
 559    it so it doesn't try to create another thread state for the thread (this is
 560    a better fix for SF bug #1010677 than the first one attempted).
 561 */
 562 static void
 563 _PyGILState_NoteThreadState(PyThreadState* tstate)
 564 {
 565     /* If autoTLSkey isn't initialized, this must be the very first
 566        threadstate created in Py_Initialize().  Don't do anything for now
 567        (we'll be back here when _PyGILState_Init is called). */
 568     if (!autoInterpreterState)
 569         return;
 570
 571     /* Stick the thread state for this thread in thread local storage.
 572
 573        The only situation where you can legitimately have more than one
 574        thread state for an OS level thread is when there are multiple
 575        interpreters, when:
 576
 577            a) You shouldn't really be using the PyGILState_ APIs anyway,
 578           and:
 579
 580            b) The slightly odd way PyThread_set_key_value works (see
 581           comments by its implementation) means that the first thread
 582           state created for that given OS level thread will "win",
 583           which seems reasonable behaviour.
 584     */
 585     if (PyThread_set_key_value(autoTLSkey, (void *)tstate) < 0)
 586         Py_FatalError("Couldn't create autoTLSkey mapping");
 587
 588     /* PyGILState_Release must not try to delete this thread state. */
 589     tstate->gilstate_counter = 1;
 590 }
 591
 592 /* The public functions */
 593 PyThreadState *
 594 PyGILState_GetThisThreadState(void)
 595 {
 596     if (autoInterpreterState == NULL)
 597         return NULL;
 598     return (PyThreadState *)PyThread_get_key_value(autoTLSkey);
 599 }
 600
 601 PyGILState_STATE
 602 PyGILState_Ensure(void)
 603 {
 604     int current;
 605     PyThreadState *tcur;
 606     /* Note that we do not auto-init Python here - apart from
 607        potential races with 2 threads auto-initializing, pep-311
 608        spells out other issues.  Embedders are expected to have
 609        called Py_Initialize() and usually PyEval_InitThreads().
 610     */
 611     assert(autoInterpreterState); /* Py_Initialize() hasn't been called! */
 612     tcur = (PyThreadState *)PyThread_get_key_value(autoTLSkey);
 613     if (tcur == NULL) {
 614         /* Create a new thread state for this thread */
 615         tcur = PyThreadState_New(autoInterpreterState);
 616         if (tcur == NULL)
 617             Py_FatalError("Couldn't create thread-state for new thread");
 618         /* This is our thread state!  We'll need to delete it in the
 619            matching call to PyGILState_Release(). */
 620         tcur->gilstate_counter = 0;
 621         current = 0; /* new thread state is never current */
 622     }
 623     else
 624         current = PyThreadState_IsCurrent(tcur);
 625     if (current == 0)
 626         PyEval_RestoreThread(tcur);
 627     /* Update our counter in the thread-state - no need for locks:
 628        - tcur will remain valid as we hold the GIL.
 629        - the counter is safe as we are the only thread "allowed"
 630          to modify this value
 631     */
 632     ++tcur->gilstate_counter;
 633     return current ? PyGILState_LOCKED : PyGILState_UNLOCKED;
 634 }
 635
 636 void
 637 PyGILState_Release(PyGILState_STATE oldstate)
 638 {
 639     PyThreadState *tcur = (PyThreadState *)PyThread_get_key_value(
 640                                                             autoTLSkey);
 641     if (tcur == NULL)
 642         Py_FatalError("auto-releasing thread-state, "
 643                       "but no thread-state for this thread");
 644     /* We must hold the GIL and have our thread state current */
 645     /* XXX - remove the check - the assert should be fine,
 646        but while this is very new (April 2003), the extra check
 647        by release-only users can't hurt.
 648     */
 649     if (! PyThreadState_IsCurrent(tcur))
 650         Py_FatalError("This thread state must be current when releasing");
 651     assert(PyThreadState_IsCurrent(tcur));
 652     --tcur->gilstate_counter;
 653     assert(tcur->gilstate_counter >= 0); /* illegal counter value */
 654
 655     /* If we're going to destroy this thread-state, we must
 656      * clear it while the GIL is held, as destructors may run.
 657      */
 658     if (tcur->gilstate_counter == 0) {
 659         /* can't have been locked when we created it */
 660         assert(oldstate == PyGILState_UNLOCKED);
 661         PyThreadState_Clear(tcur);
 662         /* Delete the thread-state.  Note this releases the GIL too!
 663          * It's vital that the GIL be held here, to avoid shutdown
 664          * races; see bugs 225673 and 1061968 (that nasty bug has a
 665          * habit of coming back).
 666          */
 667         PyThreadState_DeleteCurrent();
 668     }
 669     /* Release the lock if necessary */
 670     else if (oldstate == PyGILState_UNLOCKED)
 671         PyEval_SaveThread();
 672 }
 673
 674 #ifdef __cplusplus
 675 }
 676 #endif
 677
 678 #endif /* WITH_THREAD */
 679
 680