Fix Shutdown crash

amos402 · amos402 · commit 958a8eb33761 · 2021-02-19T23:30:02.000+08:00
diff --git a/pythonnet/__init__.py b/pythonnet/__init__.py
@@ -63,7 +63,7 @@ def unload():
     global _RUNTIME
     if _LOADER_ASSEMBLY is not None:
         func = _LOADER_ASSEMBLY["Python.Runtime.Loader.Shutdown"]
-        if func(b"") != 0:
+        if func(b"full_shutdown") != 0:
             raise RuntimeError("Failed to call Python.NET shutdown")
 
     if _RUNTIME is not None:
diff --git a/src/runtime/classbase.cs b/src/runtime/classbase.cs
@@ -356,17 +356,16 @@ public static void tp_dealloc(IntPtr ob)
             {
                 Runtime.PyObject_ClearWeakRefs(ob);
             }
-            tp_clear(ob);
+            RemoveObjectDict(ob);
+            Runtime.Py_CLEAR(ref self.tpHandle);
             Runtime.PyObject_GC_UnTrack(ob);
             Runtime.PyObject_GC_Del(ob);
             self.FreeGCHandle();
         }
 
         public static int tp_clear(IntPtr ob)
         {
-            ManagedType self = GetManagedObject(ob);
             ClearObjectDict(ob);
-            Runtime.Py_CLEAR(ref self.tpHandle);
             return 0;
         }
 
diff --git a/src/runtime/classmanager.cs b/src/runtime/classmanager.cs
@@ -5,6 +5,7 @@
 using System.Runtime.InteropServices;
 using System.Security;
 using System.Linq;
+using System.Diagnostics;
 
 namespace Python.Runtime
 {
@@ -270,7 +271,7 @@ private static void InitClassBase(Type type, ClassBase impl)
 
             // Finally, initialize the class __dict__ and return the object.
             var dict = new BorrowedReference(Marshal.ReadIntPtr(tp, TypeOffset.tp_dict));
-
+            Debug.Assert(!dict.IsNull);
 
             if (impl.dotNetMembers == null)
             {
diff --git a/src/runtime/extensiontype.cs b/src/runtime/extensiontype.cs
@@ -55,7 +55,7 @@ void SetupGc ()
         /// </summary>
         public static void FinalizeObject(ManagedType self)
         {
-            ClearObjectDict(self.pyHandle);
+            RemoveObjectDict(self.pyHandle);
             Runtime.PyObject_GC_Del(self.pyHandle);
             // Not necessary for decref of `tpHandle`.
             self.FreeGCHandle();
diff --git a/src/runtime/managedtype.cs b/src/runtime/managedtype.cs
@@ -225,6 +225,16 @@ protected virtual void OnSave(InterDomainContext context) { }
         protected virtual void OnLoad(InterDomainContext context) { }
 
         protected static void ClearObjectDict(IntPtr ob)
+        {
+            IntPtr dict = GetObjectDict(ob);
+            if (dict == IntPtr.Zero)
+            {
+                return;
+            }
+            Runtime.PyDict_Clear(dict);
+        }
+
+        protected static void RemoveObjectDict(IntPtr ob)
         {
             IntPtr dict = GetObjectDict(ob);
             if (dict == IntPtr.Zero)
diff --git a/src/runtime/metatype.cs b/src/runtime/metatype.cs
@@ -296,9 +296,7 @@ public static void tp_dealloc(IntPtr tp)
 
         public static int tp_clear(IntPtr ob)
         {
-            IntPtr type = Runtime.PyObject_TYPE(ob);
-            int dictOffset = ObjectOffset.TypeDictOffset(type);
-            Runtime.Py_SETREF(ob, dictOffset, IntPtr.Zero);
+            ClearObjectDict(ob);
             return 0;
         }
 
diff --git a/src/runtime/methodobject.cs b/src/runtime/methodobject.cs
@@ -217,7 +217,7 @@ public static IntPtr tp_repr(IntPtr ob)
         {
             var self = (MethodObject)GetManagedObject(ob);
             self.ClearMembers();
-            ClearObjectDict(ob);
+            RemoveObjectDict(ob);
             self.Dealloc();
         }
 
diff --git a/src/runtime/runtime.cs b/src/runtime/runtime.cs
@@ -503,15 +503,19 @@ private static void PyDictTryDelItem(BorrowedReference dict, string key)
         private static void MoveClrInstancesOnwershipToPython()
         {
             var objs = ManagedType.GetManagedObjects();
-            var copyObjs = objs.ToArray();
-            foreach (var entry in copyObjs)
+            var copyObjs = new KeyValuePair<ManagedType, ManagedType.TrackTypes>[objs.Count];
             {
-                ManagedType obj = entry.Key;
-                if (!objs.ContainsKey(obj))
+                int i = 0;
+                foreach (var entry in objs)
                 {
-                    System.Diagnostics.Debug.Assert(obj.gcHandle == default);
-                    continue;
+                    ManagedType obj = entry.Key;
+                    XIncref(obj.pyHandle);
+                    copyObjs[i++] = entry;
                 }
+            }
+            foreach (var entry in copyObjs)
+            {
+                ManagedType obj = entry.Key;
                 if (entry.Value == ManagedType.TrackTypes.Extension)
                 {
                     obj.CallTypeClear();
@@ -522,8 +526,21 @@ private static void MoveClrInstancesOnwershipToPython()
                         PyObject_GC_Track(obj.pyHandle);
                     }
                 }
-                obj.FreeGCHandle();
-                Marshal.WriteIntPtr(obj.pyHandle, ObjectOffset.magic(obj.tpHandle), IntPtr.Zero);
+            }
+            foreach (var entry in copyObjs)
+            {
+                ManagedType obj = entry.Key;
+                if (!objs.ContainsKey(obj))
+                {
+                    System.Diagnostics.Debug.Assert(obj.gcHandle == default);
+                    continue;
+                }
+                if (obj.RefCount > 1)
+                {
+                    obj.FreeGCHandle();
+                    Marshal.WriteIntPtr(obj.pyHandle, ObjectOffset.magic(obj.tpHandle), IntPtr.Zero);
+                }
+                XDecref(obj.pyHandle);
             }
             ManagedType.ClearTrackedObjects();
         }

Original file line number	Diff line number	Diff line change
`@@ -356,17 +356,16 @@ public static void tp_dealloc(IntPtr ob)`
`356`	`356`	`{`
`357`	`357`	`Runtime.PyObject_ClearWeakRefs(ob);`
`358`	`358`	`}`
`359`		`- tp_clear(ob);`
	`359`	`+ RemoveObjectDict(ob);`
	`360`	`+ Runtime.Py_CLEAR(ref self.tpHandle);`
`360`	`361`	`Runtime.PyObject_GC_UnTrack(ob);`
`361`	`362`	`Runtime.PyObject_GC_Del(ob);`
`362`	`363`	`self.FreeGCHandle();`
`363`	`364`	`}`
`364`	`365`
`365`	`366`	`public static int tp_clear(IntPtr ob)`
`366`	`367`	`{`
`367`		`- ManagedType self = GetManagedObject(ob);`
`368`	`368`	`ClearObjectDict(ob);`
`369`		`- Runtime.Py_CLEAR(ref self.tpHandle);`
`370`	`369`	`return 0;`
`371`	`370`	`}`
`372`	`371`
Original file line number	Diff line number	Diff line change
`@@ -5,6 +5,7 @@`
`5`	`5`	`using System.Runtime.InteropServices;`
`6`	`6`	`using System.Security;`
`7`	`7`	`using System.Linq;`
	`8`	`+using System.Diagnostics;`
`8`	`9`
`9`	`10`	`namespace Python.Runtime`
`10`	`11`	`{`
`@@ -270,7 +271,7 @@ private static void InitClassBase(Type type, ClassBase impl)`
`270`	`271`
`271`	`272`	`// Finally, initialize the class __dict__ and return the object.`
`272`	`273`	`var dict = new BorrowedReference(Marshal.ReadIntPtr(tp, TypeOffset.tp_dict));`
`273`		`-`
	`274`	`+ Debug.Assert(!dict.IsNull);`
`274`	`275`
`275`	`276`	`if (impl.dotNetMembers == null)`
`276`	`277`	`{`
Original file line number	Diff line number	Diff line change
`@@ -55,7 +55,7 @@ void SetupGc ()`
`55`	`55`	`/// </summary>`
`56`	`56`	`public static void FinalizeObject(ManagedType self)`
`57`	`57`	`{`
`58`		`- ClearObjectDict(self.pyHandle);`
	`58`	`+ RemoveObjectDict(self.pyHandle);`
`59`	`59`	`Runtime.PyObject_GC_Del(self.pyHandle);`
`60`	`60`	// Not necessary for decref of `tpHandle`.
`61`	`61`	`self.FreeGCHandle();`
Original file line number	Diff line number	Diff line change
`@@ -296,9 +296,7 @@ public static void tp_dealloc(IntPtr tp)`
`296`	`296`
`297`	`297`	`public static int tp_clear(IntPtr ob)`
`298`	`298`	`{`
`299`		`- IntPtr type = Runtime.PyObject_TYPE(ob);`
`300`		`- int dictOffset = ObjectOffset.TypeDictOffset(type);`
`301`		`- Runtime.Py_SETREF(ob, dictOffset, IntPtr.Zero);`
	`299`	`+ ClearObjectDict(ob);`
`302`	`300`	`return 0;`
`303`	`301`	`}`
`304`	`302`
Original file line number	Diff line number	Diff line change
`@@ -217,7 +217,7 @@ public static IntPtr tp_repr(IntPtr ob)`
`217`	`217`	`{`
`218`	`218`	`var self = (MethodObject)GetManagedObject(ob);`
`219`	`219`	`self.ClearMembers();`
`220`		`- ClearObjectDict(ob);`
	`220`	`+ RemoveObjectDict(ob);`
`221`	`221`	`self.Dealloc();`
`222`	`222`	`}`
`223`	`223`
Original file line number	Diff line number	Diff line change
`@@ -503,15 +503,19 @@ private static void PyDictTryDelItem(BorrowedReference dict, string key)`
`503`	`503`	`private static void MoveClrInstancesOnwershipToPython()`
`504`	`504`	`{`
`505`	`505`	`var objs = ManagedType.GetManagedObjects();`
`506`		`- var copyObjs = objs.ToArray();`
`507`		`- foreach (var entry in copyObjs)`
	`506`	`+ var copyObjs = new KeyValuePair<ManagedType, ManagedType.TrackTypes>[objs.Count];`
`508`	`507`	`{`
`509`		`- ManagedType obj = entry.Key;`
`510`		`- if (!objs.ContainsKey(obj))`
	`508`	`+ int i = 0;`
	`509`	`+ foreach (var entry in objs)`
`511`	`510`	`{`
`512`		`- System.Diagnostics.Debug.Assert(obj.gcHandle == default);`
`513`		`- continue;`
	`511`	`+ ManagedType obj = entry.Key;`
	`512`	`+ XIncref(obj.pyHandle);`
	`513`	`+ copyObjs[i++] = entry;`
`514`	`514`	`}`
	`515`	`+ }`
	`516`	`+ foreach (var entry in copyObjs)`
	`517`	`+ {`
	`518`	`+ ManagedType obj = entry.Key;`
`515`	`519`	`if (entry.Value == ManagedType.TrackTypes.Extension)`
`516`	`520`	`{`
`517`	`521`	`obj.CallTypeClear();`
`@@ -522,8 +526,21 @@ private static void MoveClrInstancesOnwershipToPython()`
`522`	`526`	`PyObject_GC_Track(obj.pyHandle);`
`523`	`527`	`}`
`524`	`528`	`}`
`525`		`- obj.FreeGCHandle();`
`526`		`- Marshal.WriteIntPtr(obj.pyHandle, ObjectOffset.magic(obj.tpHandle), IntPtr.Zero);`
	`529`	`+ }`
	`530`	`+ foreach (var entry in copyObjs)`
	`531`	`+ {`
	`532`	`+ ManagedType obj = entry.Key;`
	`533`	`+ if (!objs.ContainsKey(obj))`
	`534`	`+ {`
	`535`	`+ System.Diagnostics.Debug.Assert(obj.gcHandle == default);`
	`536`	`+ continue;`
	`537`	`+ }`
	`538`	`+ if (obj.RefCount > 1)`
	`539`	`+ {`
	`540`	`+ obj.FreeGCHandle();`
	`541`	`+ Marshal.WriteIntPtr(obj.pyHandle, ObjectOffset.magic(obj.tpHandle), IntPtr.Zero);`
	`542`	`+ }`
	`543`	`+ XDecref(obj.pyHandle);`
`527`	`544`	`}`
`528`	`545`	`ManagedType.ClearTrackedObjects();`
`529`	`546`	`}`