#include "pycore_code.h" // CO_FAST_FREE
#include "pycore_dict.h" // _PyDict_KeysSize()
#include "pycore_frame.h" // _PyInterpreterFrame
+#include "pycore_lock.h" // _PySeqLock_*
#include "pycore_long.h" // _PyLong_IsNegative()
#include "pycore_memoryobject.h" // _PyMemoryView_FromBufferProc()
#include "pycore_modsupport.h" // _PyArg_NoKwnames()
#define NEXT_VERSION_TAG(interp) \
(interp)->types.next_version_tag
+#ifdef Py_GIL_DISABLED
+
+// There's a global lock for mutation of types. This avoids having to take
+// additonal locks while doing various subclass processing which may result
+// in odd behaviors w.r.t. running with the GIL as the outer type lock could
+// be released and reacquired during a subclass update if there's contention
+// on the subclass lock.
+#define BEGIN_TYPE_LOCK() \
+ { \
+ _PyCriticalSection _cs; \
+ _PyCriticalSection_Begin(&_cs, &_PyRuntime.types.type_mutex); \
+
+#define END_TYPE_LOCK() \
+ _PyCriticalSection_End(&_cs); \
+ }
+
+#define ASSERT_TYPE_LOCK_HELD() \
+ _Py_CRITICAL_SECTION_ASSERT_MUTEX_LOCKED(&_PyRuntime.types.type_mutex)
+
+#else
+
+#define BEGIN_TYPE_LOCK()
+#define END_TYPE_LOCK()
+#define ASSERT_TYPE_LOCK_HELD()
+
+#endif
+
+
typedef struct PySlot_Offset {
short subslot_offset;
short slot_offset;
PyObject *
_PyType_GetBases(PyTypeObject *self)
{
- /* It returns a borrowed reference. */
- return lookup_tp_bases(self);
+ PyObject *res;
+
+ BEGIN_TYPE_LOCK();
+ res = lookup_tp_bases(self);
+ Py_INCREF(res);
+ END_TYPE_LOCK()
+
+ return res;
}
static inline void
static inline PyObject *
lookup_tp_mro(PyTypeObject *self)
{
+ ASSERT_TYPE_LOCK_HELD();
return self->tp_mro;
}
PyObject *
_PyType_GetMRO(PyTypeObject *self)
{
- /* It returns a borrowed reference. */
- return lookup_tp_mro(self);
+ PyObject *mro;
+ BEGIN_TYPE_LOCK();
+ mro = lookup_tp_mro(self);
+ Py_INCREF(mro);
+ END_TYPE_LOCK()
+ return mro;
}
static inline void
{
for (Py_ssize_t i = 0; i < (1 << MCACHE_SIZE_EXP); i++) {
struct type_cache_entry *entry = &cache->hashtable[i];
+#ifdef Py_GIL_DISABLED
+ _PySeqLock_LockWrite(&entry->sequence);
+#endif
entry->version = 0;
Py_XSETREF(entry->name, _Py_XNewRef(value));
entry->value = NULL;
+#ifdef Py_GIL_DISABLED
+ _PySeqLock_UnlockWrite(&entry->sequence);
+#endif
}
}
return -1;
}
// ensure we will get a callback on the next modification
+ BEGIN_TYPE_LOCK()
assign_version_tag(interp, type);
type->tp_watched |= (1 << watcher_id);
+ END_TYPE_LOCK()
return 0;
}
return 0;
}
-void
-PyType_Modified(PyTypeObject *type)
+static void
+type_modified_unlocked(PyTypeObject *type)
{
/* Invalidate any cached data for the specified type and all
subclasses. This function is called after the base
}
}
+void
+PyType_Modified(PyTypeObject *type)
+{
+ // Quick check without the lock held
+ if (!_PyType_HasFeature(type, Py_TPFLAGS_VALID_VERSION_TAG)) {
+ return;
+ }
+
+ BEGIN_TYPE_LOCK()
+ type_modified_unlocked(type);
+ END_TYPE_LOCK()
+}
+
+static int
+is_subtype_unlocked(PyTypeObject *a, PyTypeObject *b);
+
static void
type_mro_modified(PyTypeObject *type, PyObject *bases) {
/*
int custom = !Py_IS_TYPE(type, &PyType_Type);
int unbound;
+ ASSERT_TYPE_LOCK_HELD();
if (custom) {
PyObject *mro_meth, *type_mro_meth;
mro_meth = lookup_maybe_method(
PyObject *b = PyTuple_GET_ITEM(bases, i);
PyTypeObject *cls = _PyType_CAST(b);
- if (!PyType_IsSubtype(type, cls)) {
+ if (!is_subtype_unlocked(type, cls)) {
goto clear;
}
}
static int
assign_version_tag(PyInterpreterState *interp, PyTypeObject *type)
{
+ ASSERT_TYPE_LOCK_HELD();
+
/* Ensure that the tp_version_tag is valid and set
Py_TPFLAGS_VALID_VERSION_TAG. To respect the invariant, this
must first be done on all super classes. Return 0 if this
int PyUnstable_Type_AssignVersionTag(PyTypeObject *type)
{
PyInterpreterState *interp = _PyInterpreterState_GET();
- return assign_version_tag(interp, type);
+ int assigned;
+ BEGIN_TYPE_LOCK()
+ assigned = assign_version_tag(interp, type);
+ END_TYPE_LOCK()
+ return assigned;
}
static PyObject *
type_get_bases(PyTypeObject *type, void *context)
{
- PyObject *bases = lookup_tp_bases(type);
+ PyObject *bases = _PyType_GetBases(type);
if (bases == NULL) {
Py_RETURN_NONE;
}
- return Py_NewRef(bases);
+ return bases;
}
static PyObject *
type_get_mro(PyTypeObject *type, void *context)
{
- PyObject *mro = lookup_tp_mro(type);
+ PyObject *mro;
+
+ BEGIN_TYPE_LOCK()
+ mro = lookup_tp_mro(type);
if (mro == NULL) {
- Py_RETURN_NONE;
+ mro = Py_None;
+ } else {
+ Py_INCREF(mro);
}
- return Py_NewRef(mro);
+
+ END_TYPE_LOCK()
+ return mro;
}
static PyTypeObject *best_base(PyObject *);
static int
mro_hierarchy(PyTypeObject *type, PyObject *temp)
{
+ ASSERT_TYPE_LOCK_HELD();
+
PyObject *old_mro;
int res = mro_internal(type, &old_mro);
if (res <= 0) {
}
static int
-type_set_bases(PyTypeObject *type, PyObject *new_bases, void *context)
+type_set_bases_unlocked(PyTypeObject *type, PyObject *new_bases, void *context)
{
// Check arguments
if (!check_set_special_type_attr(type, new_bases, "__bases__")) {
}
PyTypeObject *base = (PyTypeObject*)ob;
- if (PyType_IsSubtype(base, type) ||
+ if (is_subtype_unlocked(base, type) ||
/* In case of reentering here again through a custom mro()
the above check is not enough since it relies on
base->tp_mro which would gonna be updated inside
return -1;
}
+static int
+type_set_bases(PyTypeObject *type, PyObject *new_bases, void *context)
+{
+ int res;
+ BEGIN_TYPE_LOCK();
+ res = type_set_bases_unlocked(type, new_bases, context);
+ END_TYPE_LOCK();
+ return res;
+}
+
static PyObject *
type_dict(PyTypeObject *type, void *context)
{
return (b == &PyBaseObject_Type);
}
-int
-PyType_IsSubtype(PyTypeObject *a, PyTypeObject *b)
+static int
+is_subtype_unlocked(PyTypeObject *a, PyTypeObject *b)
{
PyObject *mro;
+ ASSERT_TYPE_LOCK_HELD();
mro = lookup_tp_mro(a);
if (mro != NULL) {
/* Deal with multiple inheritance without recursion
return type_is_subtype_base_chain(a, b);
}
+int
+PyType_IsSubtype(PyTypeObject *a, PyTypeObject *b)
+{
+ int res;
+ BEGIN_TYPE_LOCK();
+ res = is_subtype_unlocked(a, b);
+ END_TYPE_LOCK()
+ return res;
+}
+
/* Routines to do a method lookup in the type without looking in the
instance dictionary (so we can't use PyObject_GetAttr) but still
binding it to the instance.
}
static PyObject *
-mro_implementation(PyTypeObject *type)
+mro_implementation_unlocked(PyTypeObject *type)
{
+ ASSERT_TYPE_LOCK_HELD();
+
if (!_PyType_IsReady(type)) {
if (PyType_Ready(type) < 0)
return NULL;
return result;
}
+static PyObject *
+mro_implementation(PyTypeObject *type)
+{
+ PyObject *mro;
+ BEGIN_TYPE_LOCK()
+ mro = mro_implementation_unlocked(type);
+ END_TYPE_LOCK()
+ return mro;
+}
+
/*[clinic input]
type.mro
}
PyTypeObject *base = (PyTypeObject*)obj;
- if (!PyType_IsSubtype(solid, solid_base(base))) {
+ if (!is_subtype_unlocked(solid, solid_base(base))) {
PyErr_Format(
PyExc_TypeError,
"mro() returned base with unsuitable layout ('%.500s')",
{
PyObject *mro_result;
PyObject *new_mro;
+
+ ASSERT_TYPE_LOCK_HELD();
+
const int custom = !Py_IS_TYPE(type, &PyType_Type);
if (custom) {
Py_DECREF(mro_meth);
}
else {
- mro_result = mro_implementation(type);
+ mro_result = mro_implementation_unlocked(type);
}
if (mro_result == NULL)
return NULL;
- Returns -1 in case of an error.
*/
static int
-mro_internal(PyTypeObject *type, PyObject **p_old_mro)
+mro_internal_unlocked(PyTypeObject *type, PyObject **p_old_mro)
{
+ ASSERT_TYPE_LOCK_HELD();
+
PyObject *new_mro, *old_mro;
int reent;
return 1;
}
+static int
+mro_internal(PyTypeObject *type, PyObject **p_old_mro)
+{
+ int res;
+ BEGIN_TYPE_LOCK()
+ res = mro_internal_unlocked(type, p_old_mro);
+ END_TYPE_LOCK()
+ return res;
+}
+
/* Calculate the best base amongst multiple base classes.
This is the first one that's on the path to the "solid base". */
{
assert(PyType_Check(type));
+ PyObject *res = NULL;
+ BEGIN_TYPE_LOCK()
+
PyObject *mro = lookup_tp_mro(type);
// The type must be ready
assert(mro != NULL);
PyHeapTypeObject *ht = (PyHeapTypeObject*)super;
PyObject *module = ht->ht_module;
if (module && _PyModule_GetDef(module) == def) {
- return module;
+ res = module;
+ break;
}
}
+ END_TYPE_LOCK()
- PyErr_Format(
- PyExc_TypeError,
- "PyType_GetModuleByDef: No superclass of '%s' has the given module",
- type->tp_name);
- return NULL;
+ if (res == NULL) {
+ PyErr_Format(
+ PyExc_TypeError,
+ "PyType_GetModuleByDef: No superclass of '%s' has the given module",
+ type->tp_name);
+ }
+ return res;
}
void *
static PyObject *
find_name_in_mro(PyTypeObject *type, PyObject *name, int *error)
{
+ ASSERT_TYPE_LOCK_HELD();
+
Py_hash_t hash;
if (!PyUnicode_CheckExact(name) ||
(hash = _PyASCIIObject_CAST(name)->hash) == -1)
return 0;
}
+static void
+update_cache(struct type_cache_entry *entry, PyObject *name, unsigned int version_tag, PyObject *value)
+{
+ entry->version = version_tag;
+ entry->value = value; /* borrowed */
+ assert(_PyASCIIObject_CAST(name)->hash != -1);
+ OBJECT_STAT_INC_COND(type_cache_collisions, entry->name != Py_None && entry->name != name);
+ // We're releasing this under the lock for simplicity sake because it's always a
+ // exact unicode object or Py_None so it's safe to do so.
+ Py_SETREF(entry->name, Py_NewRef(name));
+}
+
+#if Py_GIL_DISABLED
+
+#define TYPE_CACHE_IS_UPDATING(sequence) (sequence & 0x01)
+
+static void
+update_cache_gil_disabled(struct type_cache_entry *entry, PyObject *name,
+ unsigned int version_tag, PyObject *value)
+{
+ _PySeqLock_LockWrite(&entry->sequence);
+
+ // update the entry
+ if (entry->name == name &&
+ entry->value == value &&
+ entry->version == version_tag) {
+ // We raced with another update, bail and restore previous sequence.
+ _PySeqLock_AbandonWrite(&entry->sequence);
+ return;
+ }
+
+ update_cache(entry, name, version_tag, value);
+
+ // Then update sequence to the next valid value
+ _PySeqLock_UnlockWrite(&entry->sequence);
+}
+
+#endif
+
+void
+_PyTypes_AfterFork()
+{
+#ifdef Py_GIL_DISABLED
+ struct type_cache *cache = get_type_cache();
+ for (Py_ssize_t i = 0; i < (1 << MCACHE_SIZE_EXP); i++) {
+ struct type_cache_entry *entry = &cache->hashtable[i];
+ if (_PySeqLock_AfterFork(&entry->sequence)) {
+ // Entry was in the process of updating while forking, clear it...
+ entry->value = NULL;
+ Py_SETREF(entry->name, Py_None);
+ entry->version = 0;
+ }
+ }
+#endif
+}
+
/* Internal API to look for a name through the MRO.
This returns a borrowed reference, and doesn't set an exception! */
PyObject *
unsigned int h = MCACHE_HASH_METHOD(type, name);
struct type_cache *cache = get_type_cache();
struct type_cache_entry *entry = &cache->hashtable[h];
+#ifdef Py_GIL_DISABLED
+ // synchronize-with other writing threads by doing an acquire load on the sequence
+ while (1) {
+ int sequence = _PySeqLock_BeginRead(&entry->sequence);
+ if (_Py_atomic_load_uint32_relaxed(&entry->version) == type->tp_version_tag &&
+ _Py_atomic_load_ptr_relaxed(&entry->name) == name) {
+ assert(_PyType_HasFeature(type, Py_TPFLAGS_VALID_VERSION_TAG));
+ OBJECT_STAT_INC_COND(type_cache_hits, !is_dunder_name(name));
+ OBJECT_STAT_INC_COND(type_cache_dunder_hits, is_dunder_name(name));
+ PyObject *value = _Py_atomic_load_ptr_relaxed(&entry->value);
+
+ // If the sequence is still valid then we're done
+ if (_PySeqLock_EndRead(&entry->sequence, sequence)) {
+ return value;
+ }
+ } else {
+ // cache miss
+ break;
+ }
+ }
+#else
if (entry->version == type->tp_version_tag &&
entry->name == name) {
assert(_PyType_HasFeature(type, Py_TPFLAGS_VALID_VERSION_TAG));
OBJECT_STAT_INC_COND(type_cache_dunder_hits, is_dunder_name(name));
return entry->value;
}
+#endif
OBJECT_STAT_INC_COND(type_cache_misses, !is_dunder_name(name));
OBJECT_STAT_INC_COND(type_cache_dunder_misses, is_dunder_name(name));
/* We may end up clearing live exceptions below, so make sure it's ours. */
assert(!PyErr_Occurred());
+ // We need to atomically do the lookup and capture the version before
+ // anyone else can modify our mro or mutate the type.
+
+ int has_version = 0;
+ int version = 0;
+ BEGIN_TYPE_LOCK()
res = find_name_in_mro(type, name, &error);
+ if (MCACHE_CACHEABLE_NAME(name)) {
+ has_version = assign_version_tag(interp, type);
+ version = type->tp_version_tag;
+ assert(!has_version || _PyType_HasFeature(type, Py_TPFLAGS_VALID_VERSION_TAG));
+ }
+ END_TYPE_LOCK()
+
/* Only put NULL results into cache if there was no error. */
if (error) {
/* It's not ideal to clear the error condition,
return NULL;
}
- if (MCACHE_CACHEABLE_NAME(name) && assign_version_tag(interp, type)) {
- h = MCACHE_HASH_METHOD(type, name);
- struct type_cache_entry *entry = &cache->hashtable[h];
- entry->version = type->tp_version_tag;
- entry->value = res; /* borrowed */
- assert(_PyASCIIObject_CAST(name)->hash != -1);
- OBJECT_STAT_INC_COND(type_cache_collisions, entry->name != Py_None && entry->name != name);
- assert(_PyType_HasFeature(type, Py_TPFLAGS_VALID_VERSION_TAG));
- Py_SETREF(entry->name, Py_NewRef(name));
+ if (has_version) {
+#if Py_GIL_DISABLED
+ update_cache_gil_disabled(entry, name, version, res);
+#else
+ update_cache(entry, name, version, res);
+#endif
}
return res;
}
/* Will fail in _PyObject_GenericSetAttrWithDict. */
Py_INCREF(name);
}
+
+ BEGIN_TYPE_LOCK()
res = _PyObject_GenericSetAttrWithDict((PyObject *)type, name, value, NULL);
if (res == 0) {
/* Clear the VALID_VERSION flag of 'type' and all its
update_subclasses() recursion in update_slot(), but carefully:
they each have their own conditions on which to stop
recursing into subclasses. */
- PyType_Modified(type);
+ type_modified_unlocked(type);
if (is_dunder_name(name)) {
res = update_slot(type, name);
}
assert(_PyType_CheckConsistency(type));
}
+ END_TYPE_LOCK()
+
Py_DECREF(name);
return res;
}
#undef COPYVAL
/* Setup fast subclass flags */
- if (PyType_IsSubtype(base, (PyTypeObject*)PyExc_BaseException)) {
+ if (is_subtype_unlocked(base, (PyTypeObject*)PyExc_BaseException)) {
type->tp_flags |= Py_TPFLAGS_BASE_EXC_SUBCLASS;
}
- else if (PyType_IsSubtype(base, &PyType_Type)) {
+ else if (is_subtype_unlocked(base, &PyType_Type)) {
type->tp_flags |= Py_TPFLAGS_TYPE_SUBCLASS;
}
- else if (PyType_IsSubtype(base, &PyLong_Type)) {
+ else if (is_subtype_unlocked(base, &PyLong_Type)) {
type->tp_flags |= Py_TPFLAGS_LONG_SUBCLASS;
}
- else if (PyType_IsSubtype(base, &PyBytes_Type)) {
+ else if (is_subtype_unlocked(base, &PyBytes_Type)) {
type->tp_flags |= Py_TPFLAGS_BYTES_SUBCLASS;
}
- else if (PyType_IsSubtype(base, &PyUnicode_Type)) {
+ else if (is_subtype_unlocked(base, &PyUnicode_Type)) {
type->tp_flags |= Py_TPFLAGS_UNICODE_SUBCLASS;
}
- else if (PyType_IsSubtype(base, &PyTuple_Type)) {
+ else if (is_subtype_unlocked(base, &PyTuple_Type)) {
type->tp_flags |= Py_TPFLAGS_TUPLE_SUBCLASS;
}
- else if (PyType_IsSubtype(base, &PyList_Type)) {
+ else if (is_subtype_unlocked(base, &PyList_Type)) {
type->tp_flags |= Py_TPFLAGS_LIST_SUBCLASS;
}
- else if (PyType_IsSubtype(base, &PyDict_Type)) {
+ else if (is_subtype_unlocked(base, &PyDict_Type)) {
type->tp_flags |= Py_TPFLAGS_DICT_SUBCLASS;
}
static int
type_ready_mro(PyTypeObject *type)
{
+ ASSERT_TYPE_LOCK_HELD();
+
if (type->tp_flags & _Py_TPFLAGS_STATIC_BUILTIN) {
if (!_Py_IsMainInterpreter(_PyInterpreterState_GET())) {
assert(lookup_tp_mro(type) != NULL);
}
/* Calculate method resolution order */
- if (mro_internal(type, NULL) < 0) {
+ if (mro_internal_unlocked(type, NULL) < 0) {
return -1;
}
PyObject *mro = lookup_tp_mro(type);
static int
type_ready_inherit(PyTypeObject *type)
{
+ ASSERT_TYPE_LOCK_HELD();
+
/* Inherit special flags from dominant base */
PyTypeObject *base = type->tp_base;
if (base != NULL) {
static int
type_ready(PyTypeObject *type, int rerunbuiltin)
{
+ ASSERT_TYPE_LOCK_HELD();
+
_PyObject_ASSERT((PyObject *)type, !is_readying(type));
start_readying(type);
type->tp_flags |= Py_TPFLAGS_IMMUTABLETYPE;
}
- return type_ready(type, 0);
+ int res;
+ BEGIN_TYPE_LOCK()
+ if (!(type->tp_flags & Py_TPFLAGS_READY)) {
+ res = type_ready(type, 0);
+ } else {
+ res = 0;
+ assert(_PyType_CheckConsistency(type));
+ }
+ END_TYPE_LOCK()
+ return res;
}
int
static_builtin_state_init(interp, self);
- int res = type_ready(self, !ismain);
+ int res;
+ BEGIN_TYPE_LOCK();
+ res = type_ready(self, !ismain);
+ END_TYPE_LOCK()
if (res < 0) {
static_builtin_state_clear(interp, self);
}
https://mail.python.org/pipermail/python-dev/2003-April/034535.html
*/
static int
-hackcheck(PyObject *self, setattrofunc func, const char *what)
+hackcheck_unlocked(PyObject *self, setattrofunc func, const char *what)
{
PyTypeObject *type = Py_TYPE(self);
+
+ ASSERT_TYPE_LOCK_HELD();
+
PyObject *mro = lookup_tp_mro(type);
if (!mro) {
/* Probably ok not to check the call in this case. */
return 1;
}
+static int
+hackcheck(PyObject *self, setattrofunc func, const char *what)
+{
+ if (!PyType_Check(self)) {
+ return 1;
+ }
+
+ int res;
+ BEGIN_TYPE_LOCK();
+ res = hackcheck_unlocked(self, func, what);
+ END_TYPE_LOCK()
+ return res;
+}
+
static PyObject *
wrap_setattr(PyObject *self, PyObject *args, void *wrapped)
{
return -1;
}
-static int
-releasebuffer_maybe_call_super(PyObject *self, Py_buffer *buffer)
+static releasebufferproc
+releasebuffer_maybe_call_super_unlocked(PyObject *self, Py_buffer *buffer)
{
PyTypeObject *self_type = Py_TYPE(self);
PyObject *mro = lookup_tp_mro(self_type);
if (mro == NULL) {
- return -1;
+ return NULL;
}
assert(PyTuple_Check(mro));
}
i++; /* skip self_type */
if (i >= n)
- return -1;
+ return NULL;
- releasebufferproc base_releasebuffer = NULL;
for (; i < n; i++) {
PyObject *obj = PyTuple_GET_ITEM(mro, i);
if (!PyType_Check(obj)) {
if (base_type->tp_as_buffer != NULL
&& base_type->tp_as_buffer->bf_releasebuffer != NULL
&& base_type->tp_as_buffer->bf_releasebuffer != slot_bf_releasebuffer) {
- base_releasebuffer = base_type->tp_as_buffer->bf_releasebuffer;
- break;
+ return base_type->tp_as_buffer->bf_releasebuffer;
}
}
+ return NULL;
+}
+
+static void
+releasebuffer_maybe_call_super(PyObject *self, Py_buffer *buffer)
+{
+ releasebufferproc base_releasebuffer;
+
+ BEGIN_TYPE_LOCK();
+ base_releasebuffer = releasebuffer_maybe_call_super_unlocked(self, buffer);
+ END_TYPE_LOCK();
+
if (base_releasebuffer != NULL) {
base_releasebuffer(self, buffer);
}
- return 0;
}
static void
slot_bf_releasebuffer(PyObject *self, Py_buffer *buffer)
{
releasebuffer_call_python(self, buffer);
- if (releasebuffer_maybe_call_super(self, buffer) < 0) {
- if (PyErr_Occurred()) {
- PyErr_WriteUnraisable(self);
- }
- }
+ releasebuffer_maybe_call_super(self, buffer);
}
static PyObject *
static pytype_slotdef *
update_one_slot(PyTypeObject *type, pytype_slotdef *p)
{
+ ASSERT_TYPE_LOCK_HELD();
+
PyObject *descr;
PyWrapperDescrObject *d;
d = (PyWrapperDescrObject *)descr;
if ((specific == NULL || specific == d->d_wrapped) &&
d->d_base->wrapper == p->wrapper &&
- PyType_IsSubtype(type, PyDescr_TYPE(d)))
+ is_subtype_unlocked(type, PyDescr_TYPE(d)))
{
specific = d->d_wrapped;
}
static int
update_slots_callback(PyTypeObject *type, void *data)
{
+ ASSERT_TYPE_LOCK_HELD();
+
pytype_slotdef **pp = (pytype_slotdef **)data;
for (; *pp; pp++) {
update_one_slot(type, *pp);
pytype_slotdef **pp;
int offset;
+ ASSERT_TYPE_LOCK_HELD();
assert(PyUnicode_CheckExact(name));
assert(PyUnicode_CHECK_INTERNED(name));
static void
fixup_slot_dispatchers(PyTypeObject *type)
{
+ // This lock isn't strictly necessary because the type has not been
+ // exposed to anyone else yet, but update_ont_slot calls find_name_in_mro
+ // where we'd like to assert that the tyep is locked.
+ BEGIN_TYPE_LOCK()
+
assert(!PyErr_Occurred());
for (pytype_slotdef *p = slotdefs; p->name; ) {
p = update_one_slot(type, p);
}
+
+ END_TYPE_LOCK()
}
static void
{
pytype_slotdef *p;
+ ASSERT_TYPE_LOCK_HELD();
+
/* Clear the VALID_VERSION flag of 'type' and all its subclasses. */
PyType_Modified(type);
PyObject *mro, *res;
Py_ssize_t i, n;
+ BEGIN_TYPE_LOCK();
mro = lookup_tp_mro(su_obj_type);
+ /* keep a strong reference to mro because su_obj_type->tp_mro can be
+ replaced during PyDict_GetItemRef(dict, name, &res) and because
+ another thread can modify it after we end the critical section
+ below */
+ Py_XINCREF(mro);
+ END_TYPE_LOCK()
+
if (mro == NULL)
return NULL;
break;
}
i++; /* skip su->type (if any) */
- if (i >= n)
+ if (i >= n) {
+ Py_DECREF(mro);
return NULL;
+ }
- /* keep a strong reference to mro because su_obj_type->tp_mro can be
- replaced during PyDict_GetItemRef(dict, name, &res) */
- Py_INCREF(mro);
do {
PyObject *obj = PyTuple_GET_ITEM(mro, i);
PyObject *dict = lookup_tp_dict(_PyType_CAST(obj));
projects / thirdparty / Python / cpython.git / commitdiff
