gh-152298: Protect pending lazy owner bindings

Author: 1sgtpepper

Include/internal/pycore_lazyimportobject.h

@@ -19,25 +19,34 @@ typedef struct {
     PyObject *lz_builtins;
     PyObject *lz_from;
     PyObject *lz_attr;
-    // Protected by the import lock. The owner fields remember the first
-    // globals/key pair until resolution succeeds or the proxy is cleared.
+    // Protected by the import lock. lz_owner_* records the first module
+    // global that resolve() may replace. Pending owners are being stored;
+    // finalized owners cannot be claimed again.
     PyObject *lz_owner_globals;
     PyObject *lz_owner_key;
     PyObject *lz_resolved;
     // Frame information for the original import location.
     PyCodeObject *lz_code;     // Code object where the lazy import was created.
+    int lz_owner_pending;
+    int lz_owner_finalized;
     int lz_instr_offset;       // Instruction offset where the lazy import was created.
 } PyLazyImportObject;
 
 
 PyAPI_FUNC(PyObject *) _PyLazyImport_GetName(PyObject *lazy_import);
 PyAPI_FUNC(PyObject *) _PyLazyImport_New(
     struct _PyInterpreterFrame *frame, PyObject *import_func, PyObject *from, PyObject *attr);
-PyAPI_FUNC(void) _PyLazyImport_BindGlobal(
+PyAPI_FUNC(int) _PyLazyImport_BindGlobal(
     PyThreadState *tstate,
     PyObject *lazy_import,
     PyObject *globals,
     PyObject *name);
+PyAPI_FUNC(void) _PyLazyImport_FinishGlobalBinding(
+    PyThreadState *tstate,
+    PyObject *lazy_import,
+    PyObject *globals,
+    PyObject *name,
+    int stored);
 PyAPI_FUNC(int) _PyLazyImport_CommitIfCurrent(
     PyThreadState *tstate,
     PyObject *lazy_import,

Lib/test/test_lazy_import/__init__.py

@@ -585,11 +585,6 @@ def test_module_attr_dynamic_equal_name_clears_owner(self):
             module = sys.modules[__name__]
 
             lazy import target_module as target
-            proxy = globals()["target"]
-            stored_name = next(name for name in globals() if name == "target")
-            dynamic_name = bytearray(b"target").decode()
-            assert dynamic_name == stored_name
-            assert dynamic_name is not stored_name
 
             def custom_import(name, globals=None, locals=None, fromlist=None,
                               level=0):
@@ -599,8 +594,14 @@ def custom_import(name, globals=None, locals=None, fromlist=None,
                     return resolved
                 return real_import(name, globals, locals, fromlist, level)
 
-            builtins.__import__ = custom_import
-            try:
+            def check():
+                proxy = globals()["target"]
+                stored_name = next(name for name in globals()
+                                   if name == "target")
+                dynamic_name = bytearray(b"target").decode()
+                assert dynamic_name == stored_name
+                assert dynamic_name is not stored_name
+
                 resolved = getattr(module, dynamic_name)
                 assert resolved.VALUE == "resolved"
                 assert module.__dict__["target"] is resolved
@@ -609,6 +610,10 @@ def custom_import(name, globals=None, locals=None, fromlist=None,
                 again = proxy.resolve()
                 assert again is resolved
                 assert module.__dict__["target"] is proxy
+
+            builtins.__import__ = custom_import
+            try:
+                check()
             finally:
                 builtins.__import__ = real_import
         """)
@@ -624,7 +629,6 @@ def test_rebound_back_to_same_proxy_after_stale_resolve_does_not_replace(self):
             calls = []
 
             lazy import target_module as target
-            proxy = globals()["target"]
 
             def custom_import(name, globals=None, locals=None, fromlist=None,
                               level=0):
@@ -635,8 +639,8 @@ def custom_import(name, globals=None, locals=None, fromlist=None,
                     return resolved
                 return real_import(name, globals, locals, fromlist, level)
 
-            builtins.__import__ = custom_import
-            try:
+            def check():
+                proxy = globals()["target"]
                 sentinel = object()
                 globals()["target"] = sentinel
                 resolved = proxy.resolve()
@@ -646,6 +650,10 @@ def custom_import(name, globals=None, locals=None, fromlist=None,
                 again = proxy.resolve()
                 assert again is resolved
                 assert globals()["target"] is proxy
+
+            builtins.__import__ = custom_import
+            try:
+                check()
                 assert len(calls) == 1, calls
             finally:
                 builtins.__import__ = real_import
@@ -661,7 +669,6 @@ def test_resolve_replaces_unaliased_import_global(self):
             real_import = builtins.__import__
 
             lazy import target_module
-            proxy = globals()["target_module"]
 
             def custom_import(name, globals=None, locals=None, fromlist=None,
                               level=0):
@@ -671,11 +678,15 @@ def custom_import(name, globals=None, locals=None, fromlist=None,
                     return resolved
                 return real_import(name, globals, locals, fromlist, level)
 
-            builtins.__import__ = custom_import
-            try:
+            def check():
+                proxy = globals()["target_module"]
                 resolved = proxy.resolve()
                 assert resolved.VALUE == "resolved"
                 assert globals()["target_module"] is resolved
+
+            builtins.__import__ = custom_import
+            try:
+                check()
             finally:
                 builtins.__import__ = real_import
         """)
@@ -687,13 +698,16 @@ def test_resolve_replaces_unaliased_dotted_import_binding(self):
             import types
 
             lazy import test.test_lazy_import.data.pkg.bar
-            proxy = globals()["test"]
 
-            resolved = proxy.resolve()
-            assert isinstance(resolved, types.ModuleType)
-            assert resolved.__name__ == "test"
-            assert globals()["test"] is resolved
-            assert "test.test_lazy_import.data.pkg" not in globals()
+            def check():
+                proxy = globals()["test"]
+                resolved = proxy.resolve()
+                assert isinstance(resolved, types.ModuleType)
+                assert resolved.__name__ == "test"
+                assert globals()["test"] is resolved
+                assert "test.test_lazy_import.data.pkg" not in globals()
+
+            check()
         """)
         assert_python_ok("-c", code)
 
@@ -707,8 +721,6 @@ def test_copying_lazy_proxy_to_second_global_keeps_first_owner(self):
             calls = []
 
             lazy import target_module as primary
-            secondary = globals()["primary"]
-            proxy = globals()["primary"]
 
             def custom_import(name, globals=None, locals=None, fromlist=None,
                               level=0):
@@ -719,15 +731,21 @@ def custom_import(name, globals=None, locals=None, fromlist=None,
                     return resolved
                 return real_import(name, globals, locals, fromlist, level)
 
-            builtins.__import__ = custom_import
-            try:
+            def check():
+                proxy = globals()["primary"]
+                globals()["secondary"] = proxy
+
                 resolved = proxy.resolve()
                 assert globals()["primary"] is resolved
                 assert globals()["secondary"] is proxy
 
                 again = globals()["secondary"].resolve()
                 assert again is resolved
                 assert globals()["secondary"] is proxy
+
+            builtins.__import__ = custom_import
+            try:
+                check()
                 assert len(calls) == 1, calls
             finally:
                 builtins.__import__ = real_import