/* -*- indent-tabs-mode: nil; tab-width: 4; -*- */ /** * Implementation of greenlet::Greenlet. * * Format with: * clang-format -i --style=file src/greenlet/greenlet.c * * * Fix missing braces with: * clang-tidy src/greenlet/greenlet.c -fix -checks="readability-braces-around-statements" */ #include "greenlet_internal.hpp" #include "greenlet_greenlet.hpp" #include "greenlet_thread_state.hpp" #include "TGreenletGlobals.cpp" #include "TThreadStateDestroy.cpp" namespace greenlet { Greenlet::Greenlet(PyGreenlet* p) { p ->pimpl = this; } Greenlet::~Greenlet() { // XXX: Can't do this. tp_clear is a virtual function, and by the // time we're here, we've sliced off our child classes. //this->tp_clear(); } Greenlet::Greenlet(PyGreenlet* p, const StackState& initial_stack) : stack_state(initial_stack) { // can't use a delegating constructor because of // MSVC for Python 2.7 p->pimpl = this; } bool Greenlet::force_slp_switch_error() const noexcept { return false; } void Greenlet::release_args() { this->switch_args.CLEAR(); } /** * CAUTION: This will allocate memory and may trigger garbage * collection and arbitrary Python code. */ OwnedObject Greenlet::throw_GreenletExit_during_dealloc(const ThreadState& UNUSED(current_thread_state)) { // If we're killed because we lost all references in the // middle of a switch, that's ok. Don't reset the args/kwargs, // we still want to pass them to the parent. PyErr_SetString(mod_globs->PyExc_GreenletExit, "Killing the greenlet because all references have vanished."); // To get here it had to have run before return this->g_switch(); } inline void Greenlet::slp_restore_state() noexcept { #ifdef SLP_BEFORE_RESTORE_STATE SLP_BEFORE_RESTORE_STATE(); #endif this->stack_state.copy_heap_to_stack( this->thread_state()->borrow_current()->stack_state); } inline int Greenlet::slp_save_state(char *const stackref) noexcept { // XXX: This used to happen in the middle, before saving, but // after finding the next owner. Does that matter? This is // only defined for Sparc/GCC where it flushes register // windows to the stack (I think) #ifdef SLP_BEFORE_SAVE_STATE SLP_BEFORE_SAVE_STATE(); #endif return this->stack_state.copy_stack_to_heap(stackref, this->thread_state()->borrow_current()->stack_state); } /** * CAUTION: This will allocate memory and may trigger garbage * collection and arbitrary Python code. */ OwnedObject Greenlet::on_switchstack_or_initialstub_failure( Greenlet* target, const Greenlet::switchstack_result_t& err, const bool target_was_me, const bool was_initial_stub) { // If we get here, either g_initialstub() // failed, or g_switchstack() failed. Either one of those // cases SHOULD leave us in the original greenlet with a valid stack. if (!PyErr_Occurred()) { PyErr_SetString( PyExc_SystemError, was_initial_stub ? "Failed to switch stacks into a greenlet for the first time." : "Failed to switch stacks into a running greenlet."); } this->release_args(); if (target && !target_was_me) { target->murder_in_place(); } assert(!err.the_new_current_greenlet); assert(!err.origin_greenlet); return OwnedObject(); } OwnedGreenlet Greenlet::g_switchstack_success() noexcept { PyThreadState* tstate = PyThreadState_GET(); // restore the saved state this->python_state >> tstate; this->exception_state >> tstate; // The thread state hasn't been changed yet. ThreadState* thread_state = this->thread_state(); OwnedGreenlet result(thread_state->get_current()); thread_state->set_current(this->self()); //assert(thread_state->borrow_current().borrow() == this->_self); return result; } Greenlet::switchstack_result_t Greenlet::g_switchstack(void) { // if any of these assertions fail, it's likely because we // switched away and tried to switch back to us. Early stages of // switching are not reentrant because we re-use ``this->args()``. // Switching away would happen if we trigger a garbage collection // (by just using some Python APIs that happen to allocate Python // objects) and some garbage had weakref callbacks or __del__ that // switches (people don't write code like that by hand, but with // gevent it's possible without realizing it) assert(this->args() || PyErr_Occurred()); { /* save state */ if (this->thread_state()->is_current(this->self())) { // Hmm, nothing to do. // TODO: Does this bypass trace events that are // important? return switchstack_result_t(0, this, this->thread_state()->borrow_current()); } BorrowedGreenlet current = this->thread_state()->borrow_current(); PyThreadState* tstate = PyThreadState_GET(); current->python_state << tstate; current->exception_state << tstate; this->python_state.will_switch_from(tstate); switching_thread_state = this; } assert(this->args() || PyErr_Occurred()); // If this is the first switch into a greenlet, this will // return twice, once with 1 in the new greenlet, once with 0 // in the origin. int err; if (this->force_slp_switch_error()) { err = -1; } else { err = slp_switch(); } if (err < 0) { /* error */ // Tested by // test_greenlet.TestBrokenGreenlets.test_failed_to_slp_switch_into_running // // It's not clear if it's worth trying to clean up and // continue here. Failing to switch stacks is a big deal which // may not be recoverable (who knows what state the stack is in). // Also, we've stolen references in preparation for calling // ``g_switchstack_success()`` and we don't have a clean // mechanism for backing that all out. Py_FatalError("greenlet: Failed low-level slp_switch(). The stack is probably corrupt."); } // No stack-based variables are valid anymore. // But the global is volatile so we can reload it without the // compiler caching it from earlier. Greenlet* greenlet_that_switched_in = switching_thread_state; // aka this switching_thread_state = nullptr; // except that no stack variables are valid, we would: // assert(this == greenlet_that_switched_in); // switchstack success is where we restore the exception state, // etc. It returns the origin greenlet because its convenient. OwnedGreenlet origin = greenlet_that_switched_in->g_switchstack_success(); assert(greenlet_that_switched_in->args() || PyErr_Occurred()); return switchstack_result_t(err, greenlet_that_switched_in, origin); } inline void Greenlet::check_switch_allowed() const { // TODO: Make this take a parameter of the current greenlet, // or current main greenlet, to make the check for // cross-thread switching cheaper. Surely somewhere up the // call stack we've already accessed the thread local variable. // We expect to always have a main greenlet now; accessing the thread state // created it. However, if we get here and cleanup has already // begun because we're a greenlet that was running in a // (now dead) thread, these invariants will not hold true. In // fact, accessing `this->thread_state` may not even be possible. // If the thread this greenlet was running in is dead, // we'll still have a reference to a main greenlet, but the // thread state pointer we have is bogus. // TODO: Give the objects an API to determine if they belong // to a dead thread. const BorrowedMainGreenlet main_greenlet = this->find_main_greenlet_in_lineage(); if (!main_greenlet) { throw PyErrOccurred(mod_globs->PyExc_GreenletError, "cannot switch to a garbage collected greenlet"); } if (!main_greenlet->thread_state()) { throw PyErrOccurred(mod_globs->PyExc_GreenletError, "cannot switch to a different thread (which happens to have exited)"); } // The main greenlet we found was from the .parent lineage. // That may or may not have any relationship to the main // greenlet of the running thread. We can't actually access // our this->thread_state members to try to check that, // because it could be in the process of getting destroyed, // but setting the main_greenlet->thread_state member to NULL // may not be visible yet. So we need to check against the // current thread state (once the cheaper checks are out of // the way) const BorrowedMainGreenlet current_main_greenlet = GET_THREAD_STATE().state().borrow_main_greenlet(); if ( // lineage main greenlet is not this thread's greenlet current_main_greenlet != main_greenlet || ( // atteched to some thread this->main_greenlet() // XXX: Same condition as above. Was this supposed to be // this->main_greenlet()? && current_main_greenlet != main_greenlet) // switching into a known dead thread (XXX: which, if we get here, // is bad, because we just accessed the thread state, which is // gone!) || (!current_main_greenlet->thread_state())) { // CAUTION: This may trigger memory allocations, gc, and // arbitrary Python code. throw PyErrOccurred(mod_globs->PyExc_GreenletError, "cannot switch to a different thread"); } } const OwnedObject Greenlet::context() const { using greenlet::PythonStateContext; OwnedObject result; if (this->is_currently_running_in_some_thread()) { /* Currently running greenlet: context is stored in the thread state, not the greenlet object. */ if (GET_THREAD_STATE().state().is_current(this->self())) { result = PythonStateContext::context(PyThreadState_GET()); } else { throw ValueError( "cannot get context of a " "greenlet that is running in a different thread"); } } else { /* Greenlet is not running: just return context. */ result = this->python_state.context(); } if (!result) { result = OwnedObject::None(); } return result; } void Greenlet::context(BorrowedObject given) { using greenlet::PythonStateContext; if (!given) { throw AttributeError("can't delete context attribute"); } if (given.is_None()) { /* "Empty context" is stored as NULL, not None. */ given = nullptr; } //checks type, incrs refcnt greenlet::refs::OwnedContext context(given); PyThreadState* tstate = PyThreadState_GET(); if (this->is_currently_running_in_some_thread()) { if (!GET_THREAD_STATE().state().is_current(this->self())) { throw ValueError("cannot set context of a greenlet" " that is running in a different thread"); } /* Currently running greenlet: context is stored in the thread state, not the greenlet object. */ OwnedObject octx = OwnedObject::consuming(PythonStateContext::context(tstate)); PythonStateContext::context(tstate, context.relinquish_ownership()); } else { /* Greenlet is not running: just set context. Note that the greenlet may be dead.*/ this->python_state.context() = context; } } /** * CAUTION: May invoke arbitrary Python code. * * Figure out what the result of ``greenlet.switch(arg, kwargs)`` * should be and transfers ownership of it to the left-hand-side. * * If switch() was just passed an arg tuple, then we'll just return that. * If only keyword arguments were passed, then we'll pass the keyword * argument dict. Otherwise, we'll create a tuple of (args, kwargs) and * return both. * * CAUTION: This may allocate a new tuple object, which may * cause the Python garbage collector to run, which in turn may * run arbitrary Python code that switches. */ OwnedObject& operator<<=(OwnedObject& lhs, greenlet::SwitchingArgs& rhs) noexcept { // Because this may invoke arbitrary Python code, which could // result in switching back to us, we need to get the // arguments locally on the stack. assert(rhs); OwnedObject args = rhs.args(); OwnedObject kwargs = rhs.kwargs(); rhs.CLEAR(); // We shouldn't be called twice for the same switch. assert(args || kwargs); assert(!rhs); if (!kwargs) { lhs = args; } else if (!PyDict_Size(kwargs.borrow())) { lhs = args; } else if (!PySequence_Length(args.borrow())) { lhs = kwargs; } else { // PyTuple_Pack allocates memory, may GC, may run arbitrary // Python code. lhs = OwnedObject::consuming(PyTuple_Pack(2, args.borrow(), kwargs.borrow())); } return lhs; } static OwnedObject g_handle_exit(const OwnedObject& greenlet_result) { if (!greenlet_result && mod_globs->PyExc_GreenletExit.PyExceptionMatches()) { /* catch and ignore GreenletExit */ PyErrFetchParam val; PyErr_Fetch(PyErrFetchParam(), val, PyErrFetchParam()); if (!val) { return OwnedObject::None(); } return OwnedObject(val); } if (greenlet_result) { // package the result into a 1-tuple // PyTuple_Pack increments the reference of its arguments, // so we always need to decref the greenlet result; // the owner will do that. return OwnedObject::consuming(PyTuple_Pack(1, greenlet_result.borrow())); } return OwnedObject(); } /** * May run arbitrary Python code. */ OwnedObject Greenlet::g_switch_finish(const switchstack_result_t& err) { assert(err.the_new_current_greenlet == this); ThreadState& state = *this->thread_state(); // Because calling the trace function could do arbitrary things, // including switching away from this greenlet and then maybe // switching back, we need to capture the arguments now so that // they don't change. OwnedObject result; if (this->args()) { result <<= this->args(); } else { assert(PyErr_Occurred()); } assert(!this->args()); try { // Our only caller handles the bad error case assert(err.status >= 0); assert(state.borrow_current() == this->self()); if (OwnedObject tracefunc = state.get_tracefunc()) { assert(result || PyErr_Occurred()); g_calltrace(tracefunc, result ? mod_globs->event_switch : mod_globs->event_throw, err.origin_greenlet, this->self()); } // The above could have invoked arbitrary Python code, but // it couldn't switch back to this object and *also* // throw an exception, so the args won't have changed. if (PyErr_Occurred()) { // We get here if we fell of the end of the run() function // raising an exception. The switch itself was // successful, but the function raised. // valgrind reports that memory allocated here can still // be reached after a test run. throw PyErrOccurred::from_current(); } return result; } catch (const PyErrOccurred&) { /* Turn switch errors into switch throws */ /* Turn trace errors into switch throws */ this->release_args(); throw; } } void Greenlet::g_calltrace(const OwnedObject& tracefunc, const greenlet::refs::ImmortalEventName& event, const BorrowedGreenlet& origin, const BorrowedGreenlet& target) { PyErrPieces saved_exc; try { TracingGuard tracing_guard; // TODO: We have saved the active exception (if any) that's // about to be raised. In the 'throw' case, we could provide // the exception to the tracefunction, which seems very helpful. tracing_guard.CallTraceFunction(tracefunc, event, origin, target); } catch (const PyErrOccurred&) { // In case of exceptions trace function is removed, // and any existing exception is replaced with the tracing // exception. GET_THREAD_STATE().state().set_tracefunc(Py_None); throw; } saved_exc.PyErrRestore(); assert( (event == mod_globs->event_throw && PyErr_Occurred()) || (event == mod_globs->event_switch && !PyErr_Occurred()) ); } void Greenlet::murder_in_place() { if (this->active()) { assert(!this->is_currently_running_in_some_thread()); this->deactivate_and_free(); } } inline void Greenlet::deactivate_and_free() { if (!this->active()) { return; } // Throw away any saved stack. this->stack_state = StackState(); assert(!this->stack_state.active()); // Throw away any Python references. // We're holding a borrowed reference to the last // frame we executed. Since we borrowed it, the // normal traversal, clear, and dealloc functions // ignore it, meaning it leaks. (The thread state // object can't find it to clear it when that's // deallocated either, because by definition if we // got an object on this list, it wasn't // running and the thread state doesn't have // this frame.) // So here, we *do* clear it. this->python_state.tp_clear(true); } bool Greenlet::belongs_to_thread(const ThreadState* thread_state) const { if (!this->thread_state() // not running anywhere, or thread // exited || !thread_state) { // same, or there is no thread state. return false; } return true; } void Greenlet::deallocing_greenlet_in_thread(const ThreadState* current_thread_state) { /* Cannot raise an exception to kill the greenlet if it is not running in the same thread! */ if (this->belongs_to_thread(current_thread_state)) { assert(current_thread_state); // To get here it had to have run before /* Send the greenlet a GreenletExit exception. */ // We don't care about the return value, only whether an // exception happened. this->throw_GreenletExit_during_dealloc(*current_thread_state); return; } // Not the same thread! Temporarily save the greenlet // into its thread's deleteme list, *if* it exists. // If that thread has already exited, and processed its pending // cleanup, we'll never be able to clean everything up: we won't // be able to raise an exception. // That's mostly OK! Since we can't add it to a list, our refcount // won't increase, and we'll go ahead with the DECREFs later. ThreadState *const thread_state = this->thread_state(); if (thread_state) { thread_state->delete_when_thread_running(this->self()); } else { // The thread is dead, we can't raise an exception. // We need to make it look non-active, though, so that dealloc // finishes killing it. this->deactivate_and_free(); } return; } int Greenlet::tp_traverse(visitproc visit, void* arg) { int result; if ((result = this->exception_state.tp_traverse(visit, arg)) != 0) { return result; } //XXX: This is ugly. But so is handling everything having to do //with the top frame. bool visit_top_frame = this->was_running_in_dead_thread(); // When true, the thread is dead. Our implicit weak reference to the // frame is now all that's left; we consider ourselves to // strongly own it now. if ((result = this->python_state.tp_traverse(visit, arg, visit_top_frame)) != 0) { return result; } return 0; } int Greenlet::tp_clear() { bool own_top_frame = this->was_running_in_dead_thread(); this->exception_state.tp_clear(); this->python_state.tp_clear(own_top_frame); return 0; } bool Greenlet::is_currently_running_in_some_thread() const { return this->stack_state.active() && !this->python_state.top_frame(); } }; // namespace greenlet