The "Parallel cache failure" test failure

this had two root causes, both related to Python 3.14's new default
multiprocessing start method (forkserver, via PEP 741):

Root Cause 1: `spawning_platform()` didn't recognize `forkserver`

salt/utils/platform.py only checked for "spawn", not "forkserver". This
caused AttributeError: 'Process' object has no attribute
'_args_for_getstate' because Process.__new__ didn't set up pickling
support for forkserver-spawned children.  Fix: Changed
spawning_platform() to return True for both "spawn" and "forkserver".

Root Cause 2: Circular import when `extmods/utils/platform.py` shadows
stdlib

In Python 3.14, the forkserver itself is a fresh Python process (spawned
via exec). When it creates child processes:
1. It sets sys.path from the parent salt-call process via
   preparation_data
2. The parent's sys.path had extmods/utils/ at index 0 (inserted by
   insert_system_path)
3. In the fresh child, import platform found extmods/utils/platform.py
   (salt's platform util) before stdlib's platform.py
4. extmods/utils/platform.py does from salt.utils.decorators import
   memoize which creates a circular import: • salt.utils.decorators →
   salt.utils.versions → salt.version → import platform → (itself) →
   salt.utils.decorators ♻️

Fix 1 (targeted): Replaced from salt.utils.decorators import memoize as
real_memoize in salt/utils/platform.py with
functools.lru_cache(maxsize=None) — a stdlib-only alternative that
breaks the circular dependency.  Fix 2 (defensive): Changed
insert_system_path() in salt/config/__init__.py from sys.path.insert(0,
...) to sys.path.append(...), so extension module directories never
appear before stdlib paths.

Author: dwoz

salt/config/__init__.py

@@ -2352,14 +2352,22 @@ def prepend_root_dir(opts, path_options):
 def insert_system_path(opts, paths):
     """
     Inserts path into python path taking into consideration 'root_dir' option.
+
+    Paths are appended rather than prepended so that stdlib modules are never
+    shadowed by extension module directories (e.g. extmods/utils/).  In Python
+    3.14+ the ``forkserver`` start method spawns child processes with a fresh
+    interpreter and passes the parent's ``sys.path`` via preparation_data.  If
+    an extmods directory sits before the stdlib entries it can accidentally
+    shadow stdlib modules (e.g. ``platform``, ``functools``), triggering
+    circular imports that crash the child.
     """
     if isinstance(paths, str):
         paths = [paths]
     for path in paths:
         path_options = {"path": path, "root_dir": opts["root_dir"]}
         prepend_root_dir(path_options, path_options)
         if os.path.isdir(path_options["path"]) and path_options["path"] not in sys.path:
-            sys.path.insert(0, path_options["path"])
+            sys.path.append(path_options["path"])
 
 
 def minion_config(

salt/utils/platform.py

@@ -3,6 +3,7 @@
 """
 
 import contextlib
+import functools
 import multiprocessing
 import os
 import platform
@@ -11,7 +12,16 @@
 
 import distro
 
-from salt.utils.decorators import memoize as real_memoize
+# Use functools.lru_cache rather than importing from salt.utils.decorators.
+# This module is synced to the remote's extmods/utils/platform.py, and in
+# Python 3.14+ (forkserver default start method) it can be accidentally
+# imported as the stdlib ``platform`` module when extmods/utils/ sits at
+# sys.path[0].  Importing from salt.utils.decorators in that context
+# creates a circular import:
+#   salt.utils.decorators → salt.utils.versions → salt.version
+#   → import platform (ourselves!) → salt.utils.decorators  (cycle)
+# functools is part of the stdlib and has no such dependency.
+real_memoize = functools.cache
 
 
 def linux_distribution(full_distribution_name=True):
@@ -237,12 +247,20 @@ def is_aarch64():
 
 def spawning_platform():
     """
-    Returns True if multiprocessing.get_start_method(allow_none=False) returns "spawn"
+    Returns True if the multiprocessing start method requires pickling to transfer
+    process state to the child.  This is the case for both "spawn" and "forkserver".
 
-    This is the default for Windows Python >= 3.4 and macOS on Python >= 3.8.
-    Salt, however, will force macOS to spawning by default on all python versions
+    "spawn" is the default on Windows (Python >= 3.4) and macOS (Python >= 3.8).
+    Salt forces macOS to spawning by default on all Python versions.
+
+    "forkserver" became the Linux default in Python 3.14 (via PEP 741).  Like
+    "spawn", it transfers the Process object to the child via pickle rather than
+    inheriting it through a plain fork of the parent process.  Salt must therefore
+    treat it identically: capture *args/**kwargs in __new__ so that __getstate__
+    can reconstruct the object on the other side, and skip parent-inherited
+    logging teardown since the child starts with a clean file-descriptor table.
     """
-    return multiprocessing.get_start_method(allow_none=False) == "spawn"
+    return multiprocessing.get_start_method(allow_none=False) in ("spawn", "forkserver")
 
 
 def get_machine_identifier():

tests/pytests/unit/utils/test_platform.py

@@ -1,3 +1,4 @@
+import multiprocessing
 import subprocess
 
 import salt.utils.platform
@@ -45,3 +46,33 @@ def test_linux_distribution():
                 distro_version,
                 distro_codename,
             )
+
+
+def test_spawning_platform_spawn():
+    """
+    spawning_platform() must return True when the multiprocessing start method
+    is "spawn" (Windows default, macOS default on Python >= 3.8).
+    """
+    with patch.object(multiprocessing, "get_start_method", return_value="spawn"):
+        assert salt.utils.platform.spawning_platform() is True
+
+
+def test_spawning_platform_forkserver():
+    """
+    spawning_platform() must return True when the multiprocessing start method
+    is "forkserver".  Like "spawn", forkserver transfers the Process object to
+    the child via pickle, so Salt must prepare __getstate__/__setstate__ for it.
+    This is the Linux default starting with Python 3.14.
+    """
+    with patch.object(multiprocessing, "get_start_method", return_value="forkserver"):
+        assert salt.utils.platform.spawning_platform() is True
+
+
+def test_spawning_platform_fork():
+    """
+    spawning_platform() must return False when the multiprocessing start method
+    is "fork" (Linux default on Python < 3.14).  Fork inherits process state
+    directly, so pickling is not required.
+    """
+    with patch.object(multiprocessing, "get_start_method", return_value="fork"):
+        assert salt.utils.platform.spawning_platform() is False