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