: _self(p), stack_state(initial_stack)

{

assert(p->pimpl == nullptr);

p->pimpl = this;

{

// 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();

{

#ifdef SLP_BEFORE_RESTORE_STATE

SLP_BEFORE_RESTORE_STATE();

#endif

this->stack_state.copy_heap_to_stack(

this->thread_state()->borrow_current()->stack_state);

{

// 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);

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();

{

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;

{

// 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;

current->expose_frames();

}

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);

{

// 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\n\tCurrent: %R\n\tExpected: %R",

current_main_greenlet, main_greenlet);

}

{

using greenlet::PythonStateContext;

OwnedObject result;

if (this->is_currently_running_in_some_thread()) {

/* Currently running greenlet: context is stored in the thread state,

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;

{

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,

OwnedObject octx = OwnedObject::consuming(PythonStateContext::context(tstate));

PythonStateContext::context(tstate, context.relinquish_ownership());

}

else {

/* Greenlet is not running: just set context. Note that the

this->python_state.context() = context;

}

{

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();

{

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;

}

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())

);

{

if (this->active()) {

assert(!this->is_currently_running_in_some_thread());

this->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);

{

if (!this->thread_state() // not running anywhere, or thread

// exited

|| !thread_state) { // same, or there is no thread state.

return false;

}

return true;

{

/* Cannot raise an exception to kill the greenlet if

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 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;

{

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;