make instance creation thread safe

Author: kumaraditya303

Include/internal/pycore_pyatomic_ft_wrappers.h

@@ -20,6 +20,8 @@ extern "C" {
 #endif
 
 #ifdef Py_GIL_DISABLED
+#define FT_ATOMIC_LOAD_INT(value) _Py_atomic_load_int(&value)
+#define FT_ATOMIC_STORE_INT(value, new_value) _Py_atomic_store_int(&value, new_value)
 #define FT_ATOMIC_LOAD_PTR(value) _Py_atomic_load_ptr(&value)
 #define FT_ATOMIC_STORE_PTR(value, new_value) _Py_atomic_store_ptr(&value, new_value)
 #define FT_ATOMIC_LOAD_SSIZE(value) _Py_atomic_load_ssize(&value)
@@ -111,6 +113,8 @@ extern "C" {
     _Py_atomic_load_ullong_relaxed(&value)
 
 #else
+#define FT_ATOMIC_LOAD_INT(value) value
+#define FT_ATOMIC_STORE_INT(value, new_value) value = new_value
 #define FT_ATOMIC_LOAD_PTR(value) value
 #define FT_ATOMIC_STORE_PTR(value, new_value) value = new_value
 #define FT_ATOMIC_LOAD_SSIZE(value) value

Modules/_ctypes/_ctypes.c

@@ -109,6 +109,7 @@ bytes(cdata)
 #include "pycore_call.h"          // _PyObject_CallNoArgs()
 #include "pycore_ceval.h"         // _Py_EnterRecursiveCall()
 #include "pycore_unicodeobject.h" // _PyUnicode_EqualToASCIIString()
+#include "pycore_pyatomic_ft_wrappers.h"
 #ifdef MS_WIN32
 #  include "pycore_modsupport.h"  // _PyArg_NoKeywords()
 #endif
@@ -710,13 +711,16 @@ StructUnionType_init(PyObject *self, PyObject *args, PyObject *kwds, int isStruc
         if (baseinfo == NULL) {
             return 0;
         }
-
+        int ret = 0;
+        STGINFO_LOCK2(info, baseinfo);
         /* copy base info */
-        if (PyCStgInfo_clone(info, baseinfo) < 0) {
-            return -1;
+        ret = PyCStgInfo_clone(info, baseinfo);
+        if (ret >= 0) {
+            stginfo_set_dict_final(info);
+            stginfo_set_dict_final(baseinfo);
         }
-        info->flags &= ~DICTFLAG_FINAL; /* clear the 'final' flag in the subclass info */
-        baseinfo->flags |= DICTFLAG_FINAL; /* set the 'final' flag in the baseclass info */
+        STGINFO_UNLOCK2();
+        return ret;
     }
     return 0;
 }
@@ -3178,11 +3182,11 @@ PyCData_FromBaseObj(ctypes_state *st,
         return NULL;
     }
 
-    info->flags |= DICTFLAG_FINAL;
     cmem = (CDataObject *)((PyTypeObject *)type)->tp_alloc((PyTypeObject *)type, 0);
     if (cmem == NULL) {
         return NULL;
     }
+    STGINFO_LOCK(info);
     assert(CDataObject_Check(st, cmem));
     cmem->b_length = info->length;
     cmem->b_size = info->size;
@@ -3194,12 +3198,15 @@ PyCData_FromBaseObj(ctypes_state *st,
         cmem->b_index = index;
     } else { /* copy contents of adr */
         if (-1 == PyCData_MallocBuffer(cmem, info)) {
-            Py_DECREF(cmem);
-            return NULL;
+            Py_CLEAR(cmem);
+            goto exit;
         }
         memcpy(cmem->b_ptr, adr, info->size);
         cmem->b_index = index;
     }
+exit:;
+    stginfo_set_dict_final(info);
+    STGINFO_UNLOCK();
     return (PyObject *)cmem;
 }
 
@@ -3226,8 +3233,11 @@ PyCData_AtAddress(ctypes_state *st, PyObject *type, void *buf)
                         "abstract class");
         return NULL;
     }
-
-    info->flags |= DICTFLAG_FINAL;
+    if (stginfo_get_dict_final(info) != 1) {
+        STGINFO_LOCK(info);
+        stginfo_set_dict_final(info);
+        STGINFO_UNLOCK();
+    }
 
     pd = (CDataObject *)((PyTypeObject *)type)->tp_alloc((PyTypeObject *)type, 0);
     if (!pd) {
@@ -3461,8 +3471,11 @@ generic_pycdata_new(ctypes_state *st,
                         "abstract class");
         return NULL;
     }
-
-    info->flags |= DICTFLAG_FINAL;
+    if (stginfo_get_dict_final(info) != 1) {
+        STGINFO_LOCK(info);
+        stginfo_set_dict_final(info);
+        STGINFO_UNLOCK();
+    }
 
     obj = (CDataObject *)type->tp_alloc(type, 0);
     if (!obj)

Modules/_ctypes/ctypes.h

@@ -6,6 +6,8 @@
 
 #include "pycore_moduleobject.h"  // _PyModule_GetState()
 #include "pycore_typeobject.h"    // _PyType_GetModuleState()
+#include "pycore_critical_section.h"
+#include "pycore_pyatomic_ft_wrappers.h"
 
 // Do we support C99 complex types in ffi?
 // For Apple's libffi, this must be determined at runtime (see gh-128156).
@@ -373,6 +375,9 @@ typedef struct CFieldObject {
 *****************************************************************/
 
 typedef struct {
+#ifdef Py_GIL_DISABLED
+    PyMutex mutex;
+#endif
     int initialized;
     Py_ssize_t size;            /* number of bytes */
     Py_ssize_t align;           /* alignment requirements */
@@ -390,6 +395,7 @@ typedef struct {
     PyObject *checker;
     PyObject *module;
     int flags;                  /* calling convention and such */
+    int dict_final;
 
     /* pep3118 fields, pointers need PyMem_Free */
     char *format;
@@ -399,6 +405,26 @@ typedef struct {
 /*      Py_ssize_t *suboffsets; */ /* unused in ctypes */
 } StgInfo;
 
+
+#define STGINFO_LOCK(stginfo)   Py_BEGIN_CRITICAL_SECTION_MUT(&(stginfo)->mutex)
+#define STGINFO_LOCK2(stginfo1, stginfo2)   Py_BEGIN_CRITICAL_SECTION2_MUT(&(stginfo1)->mutex, &(stginfo2)->mutex)
+#define STGINFO_UNLOCK()        Py_END_CRITICAL_SECTION()
+#define STGINFO_UNLOCK2()       Py_END_CRITICAL_SECTION2()
+
+static inline void
+stginfo_set_dict_final(StgInfo *info)
+{
+    _Py_CRITICAL_SECTION_ASSERT_MUTEX_LOCKED(&info->mutex);
+    FT_ATOMIC_STORE_INT(info->dict_final, 1);
+}
+
+static inline int
+stginfo_get_dict_final(StgInfo *info)
+{
+    return FT_ATOMIC_LOAD_INT(info->dict_final);
+}
+
+
 extern int PyCStgInfo_clone(StgInfo *dst_info, StgInfo *src_info);
 extern void ctype_clear_stginfo(StgInfo *info);
 
@@ -427,8 +453,6 @@ PyObject *_ctypes_callproc(ctypes_state *st,
 #define TYPEFLAG_ISPOINTER 0x100
 #define TYPEFLAG_HASPOINTER 0x200
 
-#define DICTFLAG_FINAL 0x1000
-
 struct tagPyCArgObject {
     PyObject_HEAD
     ffi_type *pffi_type;

Modules/_ctypes/stgdict.c

@@ -264,7 +264,14 @@ PyCStructUnionType_update_stginfo(PyObject *type, PyObject *fields, int isStruct
     /* If this structure/union is already marked final we cannot assign
        _fields_ anymore. */
 
-    if (stginfo->flags & DICTFLAG_FINAL) {/* is final ? */
+    if (stginfo_get_dict_final(stginfo) == 1) {/* is final ? */
+        PyErr_SetString(PyExc_AttributeError,
+                        "_fields_ is final");
+        goto error;
+    }
+    STGINFO_LOCK(stginfo);
+    // check again after locking
+    if (stginfo_get_dict_final(stginfo) == 1) {/* is final ? */
         PyErr_SetString(PyExc_AttributeError,
                         "_fields_ is final");
         goto error;
@@ -422,12 +429,13 @@ PyCStructUnionType_update_stginfo(PyObject *type, PyObject *fields, int isStruct
             goto error;
         }
         assert(info);
-
+        STGINFO_LOCK(info);
         stginfo->ffi_type_pointer.elements[ffi_ofs + i] = &info->ffi_type_pointer;
         if (info->flags & (TYPEFLAG_ISPOINTER | TYPEFLAG_HASPOINTER))
             stginfo->flags |= TYPEFLAG_HASPOINTER;
-        info->flags |= DICTFLAG_FINAL; /* mark field type final */
 
+        stginfo_set_dict_final(info); /* mark field type final */
+        STGINFO_UNLOCK();
         if (-1 == PyObject_SetAttr(type, prop->name, prop_obj)) {
             goto error;
         }
@@ -461,15 +469,15 @@ PyCStructUnionType_update_stginfo(PyObject *type, PyObject *fields, int isStruct
 
     /* We did check that this flag was NOT set above, it must not
        have been set until now. */
-    if (stginfo->flags & DICTFLAG_FINAL) {
+    if (stginfo_get_dict_final(stginfo) == 1) {
         PyErr_SetString(PyExc_AttributeError,
                         "Structure or union cannot contain itself");
         goto error;
     }
-    stginfo->flags |= DICTFLAG_FINAL;
+    stginfo_set_dict_final(stginfo);
 
     retval = MakeAnonFields(type);
-error:
+error:;
     Py_XDECREF(layout_func);
     Py_XDECREF(kwnames);
     Py_XDECREF(align_obj);
@@ -478,6 +486,7 @@ PyCStructUnionType_update_stginfo(PyObject *type, PyObject *fields, int isStruct
     Py_XDECREF(layout_fields);
     Py_XDECREF(layout);
     Py_XDECREF(format_spec_obj);
+    STGINFO_UNLOCK();
     return retval;
 }