Do not restrict subprocess.

Author: ericsnowcurrently

Include/cpython/initconfig.h

@@ -245,14 +245,12 @@ PyAPI_FUNC(PyStatus) PyConfig_SetWideStringList(PyConfig *config,
 
 typedef struct {
     int allow_fork;
-    int allow_subprocess;
     int allow_threads;
 } _PyInterpreterConfig;
 
 #define _PyInterpreterConfig_LEGACY_INIT \
     { \
         .allow_fork = 1, \
-        .allow_subprocess = 1, \
         .allow_threads = 1, \
     }
 

Include/cpython/pystate.h

@@ -11,16 +11,11 @@ is available in a given context.  For example, forking the process
 might not be allowed in the current interpreter (i.e. os.fork() would fail).
 */
 
-// We leave the first 10 for less-specific features.
-
 /* Set if threads are allowed. */
-#define Py_RTFLAGS_THREADS      (1UL << 10)
+#define Py_RTFLAGS_THREADS (1UL << 10)
 
 /* Set if os.fork() is allowed. */
-#define Py_RTFLAGS_FORK         (1UL << 15)
-
-/* Set if subprocesses are allowed. */
-#define Py_RTFLAGS_SUBPROCESS   (1UL << 16)
+#define Py_RTFLAGS_FORK (1UL << 15)
 
 
 PyAPI_FUNC(int) _PyInterpreterState_HasFeature(PyInterpreterState *interp,

Lib/test/test_capi.py

@@ -1094,14 +1094,13 @@ def test_configured_settings(self):
 
         THREADS = 1<<10
         FORK = 1<<15
-        SUBPROCESS = 1<<16
 
         for config, expected in {
-            (True, True, True): THREADS | FORK | SUBPROCESS,
-            (False, False, False): 0,
-            (False, True, True): THREADS | SUBPROCESS,
+            (True, True): THREADS | FORK,
+            (False, False): 0,
+            (False, True): THREADS,
         }.items():
-            allow_fork, allow_subprocess, allow_threads = config
+            allow_fork, allow_threads = config
             expected = {
                 'feature_flags': expected,
             }
@@ -1116,7 +1115,6 @@ def test_configured_settings(self):
                                 json.dump(settings, stdin)
                             '''),
                         allow_fork=allow_fork,
-                        allow_subprocess=allow_subprocess,
                         allow_threads=allow_threads,
                     )
                     out = stdout.read()

Lib/test/test_embed.py

@@ -1650,10 +1650,9 @@ def test_init_use_frozen_modules(self):
     def test_init_main_interpreter_settings(self):
         THREADS = 1<<10
         FORK = 1<<15
-        SUBPROCESS = 1<<16
         expected = {
             # All optional features should be enabled.
-            'feature_flags': THREADS | FORK | SUBPROCESS,
+            'feature_flags': THREADS | FORK,
         }
         out, err = self.run_embedded_interpreter(
             'test_init_main_interpreter_settings',

Modules/_posixsubprocess.c

@@ -825,8 +825,8 @@ subprocess_fork_exec(PyObject *module, PyObject *args)
             &preexec_fn, &allow_vfork))
         return NULL;
 
-    if ((preexec_fn != Py_None) &&
-            (PyInterpreterState_Get() != PyInterpreterState_Main())) {
+    PyInterpreterState *interp = PyInterpreterState_Get();
+    if ((preexec_fn != Py_None) && (interp != PyInterpreterState_Main())) {
         PyErr_SetString(PyExc_RuntimeError,
                         "preexec_fn not supported within subinterpreters");
         return NULL;
@@ -841,13 +841,6 @@ subprocess_fork_exec(PyObject *module, PyObject *args)
         return NULL;
     }
 
-    PyInterpreterState *interp = PyInterpreterState_Get();
-    if (!_PyInterpreterState_HasFeature(interp, Py_RTFLAGS_SUBPROCESS)) {
-        PyErr_SetString(PyExc_RuntimeError,
-                        "subprocess not supported for isolated subinterpreters");
-        return NULL;
-    }
-
     /* We need to call gc.disable() when we'll be calling preexec_fn */
     if (preexec_fn != Py_None) {
         need_to_reenable_gc = PyGC_Disable();

Modules/_testcapimodule.c

@@ -3231,29 +3231,24 @@ run_in_subinterp_with_config(PyObject *self, PyObject *args, PyObject *kwargs)
 {
     const char *code;
     int allow_fork = -1;
-    int allow_subprocess = -1;
     int allow_threads = -1;
     int r;
     PyThreadState *substate, *mainstate;
     /* only initialise 'cflags.cf_flags' to test backwards compatibility */
     PyCompilerFlags cflags = {0};
 
     static char *kwlist[] = {"code",
-                             "allow_fork", "allow_subprocess", "allow_threads",
+                             "allow_fork", "allow_threads",
                              NULL};
     if (!PyArg_ParseTupleAndKeywords(args, kwargs,
-                    "s$ppp:run_in_subinterp_with_config", kwlist,
-                    &code, &allow_fork, &allow_subprocess, &allow_threads)) {
+                    "s$pp:run_in_subinterp_with_config", kwlist,
+                    &code, &allow_fork, &allow_threads)) {
         return NULL;
     }
     if (allow_fork < 0) {
         PyErr_SetString(PyExc_ValueError, "missing allow_fork");
         return NULL;
     }
-    if (allow_subprocess < 0) {
-        PyErr_SetString(PyExc_ValueError, "missing allow_subprocess");
-        return NULL;
-    }
     if (allow_threads < 0) {
         PyErr_SetString(PyExc_ValueError, "missing allow_threads");
         return NULL;
@@ -3265,7 +3260,6 @@ run_in_subinterp_with_config(PyObject *self, PyObject *args, PyObject *kwargs)
 
     _PyInterpreterConfig config = {
         .allow_fork = allow_fork,
-        .allow_subprocess = allow_subprocess,
         .allow_threads = allow_threads,
     };
     substate = _Py_NewInterpreterFromConfig(&config);

Modules/_winapi.c

@@ -1089,13 +1089,6 @@ _winapi_CreateProcess_impl(PyObject *module,
         return NULL;
     }
 
-    PyInterpreterState *interp = PyInterpreterState_Get();
-    if (!_PyInterpreterState_HasFeature(interp, Py_RTFLAGS_SUBPROCESS)) {
-        PyErr_SetString(PyExc_RuntimeError,
-                        "subprocess not supported for isolated subinterpreters");
-        return NULL;
-    }
-
     ZeroMemory(&si, sizeof(si));
     si.StartupInfo.cb = sizeof(si);
 

Python/pylifecycle.c

@@ -618,9 +618,6 @@ init_interp_settings(PyInterpreterState *interp, const _PyInterpreterConfig *con
     if (config->allow_fork) {
         interp->feature_flags |= Py_RTFLAGS_FORK;
     }
-    if (config->allow_subprocess) {
-        interp->feature_flags |= Py_RTFLAGS_SUBPROCESS;
-    }
     if (config->allow_threads) {
         interp->feature_flags |= Py_RTFLAGS_THREADS;
     }