#include "Python.h"

#include "pycore_ceval.h" // _Py_simple_func

#include "pycore_crossinterp.h" // _PyXIData_t

#include "pycore_initconfig.h" // _PyStatus_OK()

#include "pycore_namespace.h" //_PyNamespace_New()

#include "pycore_pyerrors.h" // _PyErr_Clear()

typedef struct xi_exceptions exceptions_t;

static int init_static_exctypes(exceptions_t *, PyInterpreterState *);

static void fini_static_exctypes(exceptions_t *, PyInterpreterState *);

static int init_heap_exctypes(exceptions_t *);

static void fini_heap_exctypes(exceptions_t *);

#include "crossinterp_exceptions.h"

_Py_CallInInterpreter(PyInterpreterState *interp,

_Py_simple_func func, void *arg)

{

if (interp == PyInterpreterState_Get()) {

return func(arg);

}

// XXX Emit a warning if this fails?

_PyEval_AddPendingCall(interp, (_Py_pending_call_func)func, arg, 0);

return 0;

}

_Py_CallInInterpreterAndRawFree(PyInterpreterState *interp,

_Py_simple_func func, void *arg)

{

if (interp == PyInterpreterState_Get()) {

int res = func(arg);

PyMem_RawFree(arg);

return res;

}

// XXX Emit a warning if this fails?

_PyEval_AddPendingCall(interp, func, arg, _Py_PENDING_RAWFREE);

return 0;

}

static void xid_lookup_init(_PyXIData_lookup_t *);

static void xid_lookup_fini(_PyXIData_lookup_t *);

static xidatafunc lookup_getdata(_PyXIData_lookup_context_t *, PyObject *);

#include "crossinterp_data_lookup.h"

_PyXIData_t *

_PyXIData_New(void)

{

_PyXIData_t *xid = PyMem_RawMalloc(sizeof(_PyXIData_t));

if (xid == NULL) {

PyErr_NoMemory();

}

return xid;

}

_PyXIData_Free(_PyXIData_t *xid)

{

PyInterpreterState *interp = PyInterpreterState_Get();

_PyXIData_Clear(interp, xid);

PyMem_RawFree(xid);

}

static inline void

_xidata_init(_PyXIData_t *data)

{

// If the value is being reused

// then _xidata_clear() should have been called already.

assert(data->data == NULL);

assert(data->obj == NULL);

*data = (_PyXIData_t){0};

_PyXIData_INTERPID(data) = -1;

}

static inline void

_xidata_clear(_PyXIData_t *data)

{

// _PyXIData_t only has two members that need to be

// cleaned up, if set: "data" must be freed and "obj" must be decref'ed.

// In both cases the original (owning) interpreter must be used,

// which is the caller's responsibility to ensure.

if (data->data != NULL) {

if (data->free != NULL) {

data->free(data->data);

}

data->data = NULL;

}

Py_CLEAR(data->obj);

}

_PyXIData_Init(_PyXIData_t *data,

PyInterpreterState *interp,

void *shared, PyObject *obj,

xid_newobjfunc new_object)

{

assert(data != NULL);

assert(new_object != NULL);

_xidata_init(data);

data->data = shared;

if (obj != NULL) {

assert(interp != NULL);

// released in _PyXIData_Clear()

data->obj = Py_NewRef(obj);

}

// Ideally every object would know its owning interpreter.

// Until then, we have to rely on the caller to identify it

// (but we don't need it in all cases).

_PyXIData_INTERPID(data) = (interp != NULL)

? PyInterpreterState_GetID(interp)

: -1;

data->new_object = new_object;

}

_PyXIData_InitWithSize(_PyXIData_t *data,

PyInterpreterState *interp,

const size_t size, PyObject *obj,

xid_newobjfunc new_object)

{

assert(size > 0);

// For now we always free the shared data in the same interpreter

// where it was allocated, so the interpreter is required.

assert(interp != NULL);

_PyXIData_Init(data, interp, NULL, obj, new_object);

data->data = PyMem_RawMalloc(size);

if (data->data == NULL) {

return -1;

}

data->free = PyMem_RawFree;

return 0;

}

_PyXIData_Clear(PyInterpreterState *interp, _PyXIData_t *data)

{

assert(data != NULL);

// This must be called in the owning interpreter.

assert(interp == NULL

|| _PyXIData_INTERPID(data) == -1

|| _PyXIData_INTERPID(data) == PyInterpreterState_GetID(interp));

_xidata_clear(data);

}

static int

_check_xidata(PyThreadState *tstate, _PyXIData_t *data)

{

// data->data can be anything, including NULL, so we don't check it.

// data->obj may be NULL, so we don't check it.

if (_PyXIData_INTERPID(data) < 0) {

PyErr_SetString(PyExc_SystemError, "missing interp");

return -1;

}

if (data->new_object == NULL) {

PyErr_SetString(PyExc_SystemError, "missing new_object func");

return -1;

}

// data->free may be NULL, so we don't check it.

return 0;

}

static inline void

_set_xid_lookup_failure(dlcontext_t *ctx, PyObject *obj, const char *msg)

{

PyObject *exctype = ctx->PyExc_NotShareableError;

assert(exctype != NULL);

if (msg != NULL) {

assert(obj == NULL);

PyErr_SetString(exctype, msg);

}

else if (obj == NULL) {

PyErr_SetString(exctype,

"object does not support cross-interpreter data");

}

else {

PyErr_Format(exctype,

"%S does not support cross-interpreter data", obj);

}

}

_PyObject_CheckXIData(_PyXIData_lookup_context_t *ctx, PyObject *obj)

{

xidatafunc getdata = lookup_getdata(ctx, obj);

if (getdata == NULL) {

if (!PyErr_Occurred()) {

_set_xid_lookup_failure(ctx, obj, NULL);

}

return -1;

}

return 0;

}

_PyObject_GetXIData(_PyXIData_lookup_context_t *ctx,

PyObject *obj, _PyXIData_t *data)

{

PyThreadState *tstate = PyThreadState_Get();

PyInterpreterState *interp = tstate->interp;

// Reset data before re-populating.

*data = (_PyXIData_t){0};

_PyXIData_INTERPID(data) = -1;

// Call the "getdata" func for the object.

Py_INCREF(obj);

xidatafunc getdata = lookup_getdata(ctx, obj);

if (getdata == NULL) {

Py_DECREF(obj);

if (!PyErr_Occurred()) {

_set_xid_lookup_failure(ctx, obj, NULL);

}

return -1;

}

int res = getdata(tstate, obj, data);

Py_DECREF(obj);

if (res != 0) {

return -1;

}

// Fill in the blanks and validate the result.

_PyXIData_INTERPID(data) = PyInterpreterState_GetID(interp);

if (_check_xidata(tstate, data) != 0) {

(void)_PyXIData_Release(data);

return -1;

}

return 0;

}

PyObject *

_PyXIData_NewObject(_PyXIData_t *data)

{

return data->new_object(data);

}

static int

_call_clear_xidata(void *data)

{

_xidata_clear((_PyXIData_t *)data);

return 0;

}

static int

_xidata_release(_PyXIData_t *data, int rawfree)

{

if ((data->data == NULL || data->free == NULL) && data->obj == NULL) {

// Nothing to release!

if (rawfree) {

PyMem_RawFree(data);

}

else {

data->data = NULL;

}

return 0;

}

// Switch to the original interpreter.

PyInterpreterState *interp = _PyInterpreterState_LookUpID(

_PyXIData_INTERPID(data));

if (interp == NULL) {

// The interpreter was already destroyed.

// This function shouldn't have been called.

// XXX Someone leaked some memory...

assert(PyErr_Occurred());

if (rawfree) {

PyMem_RawFree(data);

}

return -1;

}

// "Release" the data and/or the object.

if (rawfree) {

return _Py_CallInInterpreterAndRawFree(interp, _call_clear_xidata, data);

}

else {

return _Py_CallInInterpreter(interp, _call_clear_xidata, data);

}

}

_PyXIData_Release(_PyXIData_t *data)

{

return _xidata_release(data, 0);

}

_PyXIData_ReleaseAndRawFree(_PyXIData_t *data)

{

return _xidata_release(data, 1);

}

static const char *

_copy_string_obj_raw(PyObject *strobj, Py_ssize_t *p_size)

{

Py_ssize_t size = -1;

const char *str = PyUnicode_AsUTF8AndSize(strobj, &size);

if (str == NULL) {

return NULL;

}

if (size != (Py_ssize_t)strlen(str)) {

PyErr_SetString(PyExc_ValueError, "found embedded NULL character");

return NULL;

}

char *copied = PyMem_RawMalloc(size+1);

if (copied == NULL) {

PyErr_NoMemory();

return NULL;

}

strcpy(copied, str);

if (p_size != NULL) {

*p_size = size;

}

return copied;

}

static int

_convert_exc_to_TracebackException(PyObject *exc, PyObject **p_tbexc)

{

PyObject *args = NULL;

PyObject *kwargs = NULL;

PyObject *create = NULL;

// This is inspired by _PyErr_Display().

PyObject *tbmod = PyImport_ImportModule("traceback");

if (tbmod == NULL) {

return -1;

}

PyObject *tbexc_type = PyObject_GetAttrString(tbmod, "TracebackException");

Py_DECREF(tbmod);

if (tbexc_type == NULL) {

return -1;

}

create = PyObject_GetAttrString(tbexc_type, "from_exception");

Py_DECREF(tbexc_type);

if (create == NULL) {

return -1;

}

args = PyTuple_Pack(1, exc);

if (args == NULL) {

goto error;

}

kwargs = PyDict_New();

if (kwargs == NULL) {

goto error;

}

if (PyDict_SetItemString(kwargs, "save_exc_type", Py_False) < 0) {

goto error;

}

if (PyDict_SetItemString(kwargs, "lookup_lines", Py_False) < 0) {

goto error;

}

PyObject *tbexc = PyObject_Call(create, args, kwargs);

Py_DECREF(args);

Py_DECREF(kwargs);

Py_DECREF(create);

if (tbexc == NULL) {

goto error;

}

*p_tbexc = tbexc;

return 0;

error:

Py_XDECREF(args);

Py_XDECREF(kwargs);

Py_XDECREF(create);

return -1;

}

#ifndef _Py_EMPTY_STR

# define _Py_EMPTY_STR &_Py_STR(empty)

static const char *

_format_TracebackException(PyObject *tbexc)

{

PyObject *lines = PyObject_CallMethod(tbexc, "format", NULL);

if (lines == NULL) {

return NULL;

}

assert(_Py_EMPTY_STR != NULL);

PyObject *formatted_obj = PyUnicode_Join(_Py_EMPTY_STR, lines);

Py_DECREF(lines);

if (formatted_obj == NULL) {

return NULL;

}

Py_ssize_t size = -1;

const char *formatted = _copy_string_obj_raw(formatted_obj, &size);

Py_DECREF(formatted_obj);

// We remove trailing the newline added by TracebackException.format().

assert(formatted[size-1] == '\n');

((char *)formatted)[size-1] = '\0';

return formatted;

}

static int

_release_xid_data(_PyXIData_t *data, int rawfree)

{

PyObject *exc = PyErr_GetRaisedException();

int res = rawfree

? _PyXIData_Release(data)

: _PyXIData_ReleaseAndRawFree(data);

if (res < 0) {

/* The owning interpreter is already destroyed. */

_PyXIData_Clear(NULL, data);

// XXX Emit a warning?

PyErr_Clear();

}

PyErr_SetRaisedException(exc);

return res;

}

static int

_excinfo_init_type_from_exception(struct _excinfo_type *info, PyObject *exc)

{

/* Note that this copies directly rather than into an intermediate

PyObject *strobj = NULL;

PyTypeObject *type = Py_TYPE(exc);

if (type->tp_flags & _Py_TPFLAGS_STATIC_BUILTIN) {

assert(_Py_IsImmortal((PyObject *)type));

info->builtin = type;

}

else {

// Only builtin types are preserved.

info->builtin = NULL;

}

// __name__

strobj = PyType_GetName(type);

if (strobj == NULL) {

return -1;

}

info->name = _copy_string_obj_raw(strobj, NULL);

Py_DECREF(strobj);

if (info->name == NULL) {

return -1;

}

// __qualname__

strobj = PyType_GetQualName(type);

if (strobj == NULL) {

return -1;

}

info->qualname = _copy_string_obj_raw(strobj, NULL);

Py_DECREF(strobj);

if (info->qualname == NULL) {

return -1;

}

// __module__

strobj = PyType_GetModuleName(type);

if (strobj == NULL) {

return -1;

}

info->module = _copy_string_obj_raw(strobj, NULL);

Py_DECREF(strobj);

if (info->module == NULL) {

return -1;

}

return 0;

}

static int

_excinfo_init_type_from_object(struct _excinfo_type *info, PyObject *exctype)

{

PyObject *strobj = NULL;

// __name__

strobj = PyObject_GetAttrString(exctype, "__name__");

if (strobj == NULL) {

return -1;

}

info->name = _copy_string_obj_raw(strobj, NULL);

Py_DECREF(strobj);

if (info->name == NULL) {

return -1;

}

// __qualname__

strobj = PyObject_GetAttrString(exctype, "__qualname__");

if (strobj == NULL) {

return -1;

}

info->qualname = _copy_string_obj_raw(strobj, NULL);

Py_DECREF(strobj);

if (info->qualname == NULL) {

return -1;

}

// __module__

strobj = PyObject_GetAttrString(exctype, "__module__");

if (strobj == NULL) {

return -1;

}

info->module = _copy_string_obj_raw(strobj, NULL);

Py_DECREF(strobj);

if (info->module == NULL) {

return -1;

}

return 0;

}

static void

_excinfo_clear_type(struct _excinfo_type *info)

{

if (info->builtin != NULL) {

assert(info->builtin->tp_flags & _Py_TPFLAGS_STATIC_BUILTIN);

assert(_Py_IsImmortal((PyObject *)info->builtin));

}

if (info->name != NULL) {

PyMem_RawFree((void *)info->name);

}

if (info->qualname != NULL) {

PyMem_RawFree((void *)info->qualname);

}

if (info->module != NULL) {

PyMem_RawFree((void *)info->module);

}

*info = (struct _excinfo_type){NULL};

}

static void

_excinfo_normalize_type(struct _excinfo_type *info,

const char **p_module, const char **p_qualname)

{

if (info->name == NULL) {

assert(info->builtin == NULL);

assert(info->qualname == NULL);

assert(info->module == NULL);

// This is inspired by TracebackException.format_exception_only().

*p_module = NULL;

*p_qualname = NULL;

return;

}

const char *module = info->module;

const char *qualname = info->qualname;

if (qualname == NULL) {

qualname = info->name;

}

assert(module != NULL);

if (strcmp(module, "builtins") == 0) {

module = NULL;

}

else if (strcmp(module, "__main__") == 0) {

module = NULL;

}

*p_qualname = qualname;

*p_module = module;

}

static void

_PyXI_excinfo_Clear(_PyXI_excinfo *info)

{

_excinfo_clear_type(&info->type);

if (info->msg != NULL) {

PyMem_RawFree((void *)info->msg);

}

if (info->errdisplay != NULL) {

PyMem_RawFree((void *)info->errdisplay);

}

*info = (_PyXI_excinfo){{NULL}};

}

PyObject *

_PyXI_excinfo_format(_PyXI_excinfo *info)

{

const char *module, *qualname;

_excinfo_normalize_type(&info->type, &module, &qualname);

if (qualname != NULL) {

if (module != NULL) {

if (info->msg != NULL) {

return PyUnicode_FromFormat("%s.%s: %s",

module, qualname, info->msg);

}

else {

return PyUnicode_FromFormat("%s.%s", module, qualname);

}

}

else {

if (info->msg != NULL) {

return PyUnicode_FromFormat("%s: %s", qualname, info->msg);

}

else {

return PyUnicode_FromString(qualname);

}

}

}

else if (info->msg != NULL) {

return PyUnicode_FromString(info->msg);

}

else {

Py_RETURN_NONE;

}

}

static const char *

_PyXI_excinfo_InitFromException(_PyXI_excinfo *info, PyObject *exc)

{

assert(exc != NULL);

if (PyErr_GivenExceptionMatches(exc, PyExc_MemoryError)) {

_PyXI_excinfo_Clear(info);

return NULL;

}

const char *failure = NULL;

if (_excinfo_init_type_from_exception(&info->type, exc) < 0) {

failure = "error while initializing exception type snapshot";

goto error;

}

// Extract the exception message.

PyObject *msgobj = PyObject_Str(exc);

if (msgobj == NULL) {

failure = "error while formatting exception";

goto error;

}

info->msg = _copy_string_obj_raw(msgobj, NULL);

Py_DECREF(msgobj);

if (info->msg == NULL) {

failure = "error while copying exception message";

goto error;

}

// Pickle a traceback.TracebackException.

PyObject *tbexc = NULL;

if (_convert_exc_to_TracebackException(exc, &tbexc) < 0) {

#ifdef Py_DEBUG

PyErr_FormatUnraisable("Exception ignored while creating TracebackException");

PyErr_Clear();

}

else {

info->errdisplay = _format_TracebackException(tbexc);

Py_DECREF(tbexc);

if (info->errdisplay == NULL) {

#ifdef Py_DEBUG

PyErr_FormatUnraisable("Exception ignored while formatting TracebackException");

PyErr_Clear();

}

}

return NULL;

error:

assert(failure != NULL);

_PyXI_excinfo_Clear(info);

return failure;

}

static const char *

_PyXI_excinfo_InitFromObject(_PyXI_excinfo *info, PyObject *obj)

{

const char *failure = NULL;

PyObject *exctype = PyObject_GetAttrString(obj, "type");

if (exctype == NULL) {

failure = "exception snapshot missing 'type' attribute";

goto error;

}

int res = _excinfo_init_type_from_object(&info->type, exctype);

Py_DECREF(exctype);

if (res < 0) {

failure = "error while initializing exception type snapshot";

goto error;

}

// Extract the exception message.

PyObject *msgobj = PyObject_GetAttrString(obj, "msg");

if (msgobj == NULL) {

failure = "exception snapshot missing 'msg' attribute";

goto error;

}

info->msg = _copy_string_obj_raw(msgobj, NULL);

Py_DECREF(msgobj);

if (info->msg == NULL) {

failure = "error while copying exception message";

goto error;

}

// Pickle a traceback.TracebackException.

PyObject *errdisplay = PyObject_GetAttrString(obj, "errdisplay");

if (errdisplay == NULL) {

failure = "exception snapshot missing 'errdisplay' attribute";

goto error;

}

info->errdisplay = _copy_string_obj_raw(errdisplay, NULL);

Py_DECREF(errdisplay);

if (info->errdisplay == NULL) {

failure = "error while copying exception error display";

goto error;

}

return NULL;

error:

assert(failure != NULL);

_PyXI_excinfo_Clear(info);

return failure;

}

static void

_PyXI_excinfo_Apply(_PyXI_excinfo *info, PyObject *exctype)

{

PyObject *tbexc = NULL;

if (info->errdisplay != NULL) {

tbexc = PyUnicode_FromString(info->errdisplay);

if (tbexc == NULL) {

PyErr_Clear();

}

}

PyObject *formatted = _PyXI_excinfo_format(info);

PyErr_SetObject(exctype, formatted);

Py_DECREF(formatted);

if (tbexc != NULL) {

PyObject *exc = PyErr_GetRaisedException();

if (PyObject_SetAttrString(exc, "_errdisplay", tbexc) < 0) {

#ifdef Py_DEBUG

PyErr_FormatUnraisable("Exception ignored when setting _errdisplay");

PyErr_Clear();

}

Py_DECREF(tbexc);

PyErr_SetRaisedException(exc);

}

}

static PyObject *

_PyXI_excinfo_TypeAsObject(_PyXI_excinfo *info)

{

PyObject *ns = _PyNamespace_New(NULL);

if (ns == NULL) {

return NULL;

}

int empty = 1;

if (info->type.name != NULL) {

PyObject *name = PyUnicode_FromString(info->type.name);

if (name == NULL) {

goto error;

}

int res = PyObject_SetAttrString(ns, "__name__", name);

Py_DECREF(name);

if (res < 0) {

goto error;

}

empty = 0;

}

if (info->type.qualname != NULL) {

PyObject *qualname = PyUnicode_FromString(info->type.qualname);

if (qualname == NULL) {

goto error;

}

int res = PyObject_SetAttrString(ns, "__qualname__", qualname);

Py_DECREF(qualname);

if (res < 0) {

goto error;

}

empty = 0;

}

if (info->type.module != NULL) {

PyObject *module = PyUnicode_FromString(info->type.module);

if (module == NULL) {

goto error;

}

int res = PyObject_SetAttrString(ns, "__module__", module);

Py_DECREF(module);

if (res < 0) {

goto error;

}

empty = 0;

}

if (empty) {

Py_CLEAR(ns);

}

return ns;

error:

Py_DECREF(ns);

return NULL;

}

static PyObject *

_PyXI_excinfo_AsObject(_PyXI_excinfo *info)

{

PyObject *ns = _PyNamespace_New(NULL);

if (ns == NULL) {

return NULL;

}

int res;

PyObject *type = _PyXI_excinfo_TypeAsObject(info);

if (type == NULL) {

if (PyErr_Occurred()) {

goto error;

}

type = Py_NewRef(Py_None);

}

res = PyObject_SetAttrString(ns, "type", type);

Py_DECREF(type);

if (res < 0) {

goto error;

}

PyObject *msg = info->msg != NULL

? PyUnicode_FromString(info->msg)

: Py_NewRef(Py_None);

if (msg == NULL) {

goto error;

}

res = PyObject_SetAttrString(ns, "msg", msg);

Py_DECREF(msg);

if (res < 0) {

goto error;

}

PyObject *formatted = _PyXI_excinfo_format(info);

if (formatted == NULL) {

goto error;

}

res = PyObject_SetAttrString(ns, "formatted", formatted);

Py_DECREF(formatted);

if (res < 0) {

goto error;

}

if (info->errdisplay != NULL) {

PyObject *tbexc = PyUnicode_FromString(info->errdisplay);

if (tbexc == NULL) {

PyErr_Clear();

}

else {

res = PyObject_SetAttrString(ns, "errdisplay", tbexc);

Py_DECREF(tbexc);

if (res < 0) {

goto error;

}

}

}

return ns;

error:

Py_DECREF(ns);

return NULL;

}

_PyXI_InitExcInfo(_PyXI_excinfo *info, PyObject *exc)

{

assert(!PyErr_Occurred());

if (exc == NULL || exc == Py_None) {

PyErr_SetString(PyExc_ValueError, "missing exc");

return -1;

}

const char *failure;

if (PyExceptionInstance_Check(exc) || PyExceptionClass_Check(exc)) {

failure = _PyXI_excinfo_InitFromException(info, exc);

}

else {

failure = _PyXI_excinfo_InitFromObject(info, exc);

}

if (failure != NULL) {

PyErr_SetString(PyExc_Exception, failure);

return -1;

}

return 0;

}

PyObject *

_PyXI_FormatExcInfo(_PyXI_excinfo *info)

{

return _PyXI_excinfo_format(info);

}

PyObject *

_PyXI_ExcInfoAsObject(_PyXI_excinfo *info)

{

return _PyXI_excinfo_AsObject(info);

}

_PyXI_ClearExcInfo(_PyXI_excinfo *info)

{

_PyXI_excinfo_Clear(info);

}

static int

_PyXI_ApplyErrorCode(_PyXI_errcode code, PyInterpreterState *interp)

{

dlcontext_t ctx;

assert(!PyErr_Occurred());

switch (code) {

case _PyXI_ERR_NO_ERROR: _Py_FALLTHROUGH;

case _PyXI_ERR_UNCAUGHT_EXCEPTION:

// There is nothing to apply.

#ifdef Py_DEBUG

Py_UNREACHABLE();

return 0;

case _PyXI_ERR_OTHER:

// XXX msg?

PyErr_SetNone(PyExc_InterpreterError);

break;

case _PyXI_ERR_NO_MEMORY:

PyErr_NoMemory();

break;

case _PyXI_ERR_ALREADY_RUNNING:

assert(interp != NULL);

_PyErr_SetInterpreterAlreadyRunning();

break;

case _PyXI_ERR_MAIN_NS_FAILURE:

PyErr_SetString(PyExc_InterpreterError,

"failed to get __main__ namespace");

break;

case _PyXI_ERR_APPLY_NS_FAILURE:

PyErr_SetString(PyExc_InterpreterError,

"failed to apply namespace to __main__");

break;