add tests

Author: kumaraditya303

Lib/test/test_ctypes/test_free_threading.py

@@ -0,0 +1,95 @@
+from test.support import threading_helper
+import unittest
+import ctypes
+import threading
+
+threading_helper.requires_working_threading(module=True)
+
+
+class FreeThreadingTests(unittest.TestCase):
+
+    def test_PyCFuncPtr_new_race(self):
+        # See https://github.com/python/cpython/issues/128567
+
+        def raw_func(x):
+            pass
+
+        def race():
+            barrier.wait()
+            def lookup():
+                prototype = ctypes.CFUNCTYPE(None, ctypes.c_void_p)
+                return prototype(raw_func)
+
+            ctypes_args = ()
+            func = lookup()
+            packed_args = (ctypes.c_void_p * len(ctypes_args))()
+            for argNum in range(len(ctypes_args)):
+                packed_args[argNum] = ctypes.cast(ctypes_args[argNum], ctypes.c_void_p)
+            func(packed_args)
+
+        num_workers = 20
+
+        barrier = threading.Barrier(num_workers)
+
+        threads = []
+        for _ in range(num_workers):
+            t = threading.Thread(target=race)
+            threads.append(t)
+
+        with threading_helper.start_threads(threads):
+            pass
+
+    def test_Structure_creation_race(self):
+        class POINT(ctypes.Structure):
+            _fields_ = [("x", ctypes.c_int), ("y", ctypes.c_int)]
+
+        def race():
+            barrier.wait()
+            return POINT(1, 2)
+
+        num_workers = 20
+
+        barrier = threading.Barrier(num_workers)
+
+        threads = []
+        for _ in range(num_workers):
+            t = threading.Thread(target=race)
+            threads.append(t)
+
+        with threading_helper.start_threads(threads):
+            pass
+
+    def test_stginfo_update_race(self):
+        # See https://github.com/python/cpython/issues/128570
+        def make_nd_memref_descriptor(rank, dtype):
+            class MemRefDescriptor(ctypes.Structure):
+                _fields_ = [
+                    ("aligned", ctypes.POINTER(dtype)),
+                ]
+
+            return MemRefDescriptor
+
+
+        class F32(ctypes.Structure):
+            _fields_ = [("f32", ctypes.c_float)]
+
+
+        def race():
+            barrier.wait()
+            ctp = F32
+            ctypes.pointer(
+                ctypes.pointer(make_nd_memref_descriptor(1, ctp)())
+            )
+
+
+        num_workers = 20
+
+        barrier = threading.Barrier(num_workers)
+
+        threads = []
+        for _ in range(num_workers):
+            t = threading.Thread(target=race)
+            threads.append(t)
+
+        with threading_helper.start_threads(threads):
+            pass

Modules/_ctypes/_ctypes.c

@@ -716,7 +716,7 @@ StructUnionType_init(PyObject *self, PyObject *args, PyObject *kwds, int isStruc
         /* copy base info */
         ret = PyCStgInfo_clone(info, baseinfo);
         if (ret >= 0) {
-            stginfo_set_dict_final(info);
+            assert(stginfo_get_dict_final(info) == 0);
             stginfo_set_dict_final(baseinfo);
         }
         STGINFO_UNLOCK2();
@@ -2152,18 +2152,7 @@ static PyObject *CreateSwappedType(ctypes_state *st, PyTypeObject *type,
     if (!swapped_args)
         return NULL;
 
-    if (st->swapped_suffix == NULL) {
-#ifdef WORDS_BIGENDIAN
-        st->swapped_suffix = PyUnicode_InternFromString("_le");
-#else
-        st->swapped_suffix = PyUnicode_InternFromString("_be");
-#endif
-    }
-    if (st->swapped_suffix == NULL) {
-        Py_DECREF(swapped_args);
-        return NULL;
-    }
-
+    assert(st->swapped_suffix != NULL);
     newname = PyUnicode_Concat(name, st->swapped_suffix);
     if (newname == NULL) {
         Py_DECREF(swapped_args);
@@ -3137,6 +3126,7 @@ PyCData_MallocBuffer(CDataObject *obj, StgInfo *info)
      * access.
      */
    assert (Py_REFCNT(obj) == 1);
+   assert(stginfo_get_dict_final(info) == 1);
 
     if ((size_t)info->size <= sizeof(obj->b_value)) {
         /* No need to call malloc, can use the default buffer */
@@ -3186,7 +3176,13 @@ PyCData_FromBaseObj(ctypes_state *st,
     if (cmem == NULL) {
         return NULL;
     }
-    STGINFO_LOCK(info);
+
+    if (stginfo_get_dict_final(info) != 1) {
+        STGINFO_LOCK(info);
+        stginfo_set_dict_final(info);
+        STGINFO_UNLOCK();
+    }
+
     assert(CDataObject_Check(st, cmem));
     cmem->b_length = info->length;
     cmem->b_size = info->size;
@@ -3198,15 +3194,12 @@ PyCData_FromBaseObj(ctypes_state *st,
         cmem->b_index = index;
     } else { /* copy contents of adr */
         if (-1 == PyCData_MallocBuffer(cmem, info)) {
-            Py_CLEAR(cmem);
-            goto exit;
+            Py_DECREF(cmem);
+            return NULL;
         }
         memcpy(cmem->b_ptr, adr, info->size);
         cmem->b_index = index;
     }
-exit:;
-    stginfo_set_dict_final(info);
-    STGINFO_UNLOCK();
     return (PyObject *)cmem;
 }
 
@@ -5126,12 +5119,8 @@ PyCArrayType_from_ctype(ctypes_state *st, PyObject *itemtype, Py_ssize_t length)
     char name[256];
     PyObject *len;
 
-    if (st->array_cache == NULL) {
-        st->array_cache = PyDict_New();
-        if (st->array_cache == NULL) {
-            return NULL;
-        }
-    }
+    assert(st->array_cache != NULL);
+
     len = PyLong_FromSsize_t(length);
     if (len == NULL)
         return NULL;
@@ -6112,6 +6101,20 @@ _ctypes_mod_exec(PyObject *mod)
         return -1;
     }
 
+    st->array_cache = PyDict_New();
+    if (st->array_cache == NULL) {
+        return -1;
+    }
+
+#ifdef WORDS_BIGENDIAN
+        st->swapped_suffix = PyUnicode_InternFromString("_le");
+#else
+        st->swapped_suffix = PyUnicode_InternFromString("_be");
+#endif
+    if (st->swapped_suffix == NULL) {
+        return -1;
+    }
+
     if (_ctypes_add_types(mod) < 0) {
         return -1;
     }

Modules/_ctypes/stgdict.c

@@ -23,6 +23,8 @@
 int
 PyCStgInfo_clone(StgInfo *dst_info, StgInfo *src_info)
 {
+    _Py_CRITICAL_SECTION_ASSERT_MUTEX_LOCKED(&src_info->mutex);
+    _Py_CRITICAL_SECTION_ASSERT_MUTEX_LOCKED(&dst_info->mutex);
     Py_ssize_t size;
 
     ctype_clear_stginfo(dst_info);
@@ -248,17 +250,17 @@ PyCStructUnionType_update_stginfo(PyObject *type, PyObject *fields, int isStruct
     ctypes_state *st = get_module_state_by_def(Py_TYPE(type));
     StgInfo *stginfo;
     if (PyStgInfo_FromType(st, type, &stginfo) < 0) {
-        goto error;
+        return -1;
     }
     if (!stginfo) {
         PyErr_SetString(PyExc_TypeError,
                         "ctypes state is not initialized");
-        goto error;
+        return -1;
     }
     PyObject *base = (PyObject *)((PyTypeObject *)type)->tp_base;
     StgInfo *baseinfo;
     if (PyStgInfo_FromType(st, base, &baseinfo) < 0) {
-        goto error;
+        return -1;
     }
 
     /* If this structure/union is already marked final we cannot assign
@@ -267,7 +269,7 @@ PyCStructUnionType_update_stginfo(PyObject *type, PyObject *fields, int isStruct
     if (stginfo_get_dict_final(stginfo) == 1) {/* is final ? */
         PyErr_SetString(PyExc_AttributeError,
                         "_fields_ is final");
-        goto error;
+        return -1;
     }
     STGINFO_LOCK(stginfo);
     // check again after locking