Changeset 1281 for python

Timestamp:

Dec 26, 2017, 10:43:44 PM (8 years ago)

Author:

dmik

Message:

python: Implement subprocess.Popen using LIBCx spawn2.

Closes #280.

Location:

python/trunk

Files:

• Lib/subprocess.py (modified) (8 diffs)
• Modules/posixmodule.c (modified) (4 diffs)

python/trunk/Lib/subprocess.py

@@ -659 +659 @@
                  preexec_fn=None, close_fds=False, shell=False,
                  cwd=None, env=None, universal_newlines=False,
-                 startupinfo=None, creationflags=0):
+                 startupinfo=None, creationflags=0,
+                 threadsafe=None):
         """Create new Popen instance."""
         _cleanup()
@@ -683 +684 @@
                 raise ValueError("creationflags is only supported on Windows "
                                  "platforms")
+        if os2:
+            if threadsafe is None:
+                threadsafe = False
+        else:
+            if threadsafe is not None:
+                raise ValueError("threadsafe is only supported on OS/2 "
+                                 "platforms")
 
         self.stdin = None
@@ -713 +721 @@
             self._execute_child(args, executable, preexec_fn, close_fds,
                                 cwd, env, universal_newlines,
-                                startupinfo, creationflags, shell, to_close,
+                                startupinfo, creationflags, threadsafe, shell, to_close,
                                 p2cread, p2cwrite,
                                 c2pread, c2pwrite,
@@ -912 +920 @@
         def _execute_child(self, args, executable, preexec_fn, close_fds,
                            cwd, env, universal_newlines,
-                           startupinfo, creationflags, shell, to_close,
+                           startupinfo, creationflags, threadsafe, shell, to_close,
                            p2cread, p2cwrite,
                            c2pread, c2pwrite,
@@ -1195 +1203 @@
         def _execute_child(self, args, executable, preexec_fn, close_fds,
                            cwd, env, universal_newlines,
-                           startupinfo, creationflags, shell, to_close,
+                           startupinfo, creationflags, threadsafe, shell, to_close,
                            p2cread, p2cwrite,
                            c2pread, c2pwrite,
@@ -1223 +1231 @@
                 # in the kernel).
                 mode = os.P_NOWAIT
-                oldcwd = None
-                dups = [ None, None, None ]
-                cloexec_fds = set()
-
-                try:
-                    # Change the directory if asked
-                    if cwd is not None:
-                        oldcwd = os.getcwd()
-                        os.chdir(cwd)
-
-                    # Duplicate stdio if needed
-                    if p2cread is not None:
-                        dups[0] = os.dup(0)
-                        os.dup2(p2cread, 0)
-                        self._set_cloexec_flag(dups[0])
-                    if c2pwrite is not None:
-                        dups[1] = os.dup(1)
-                        os.dup2(c2pwrite, 1)
-                        self._set_cloexec_flag(dups[1])
-                    if errwrite is not None:
-                        dups[2] = os.dup(2)
-                        os.dup2(errwrite, 2)
-                        self._set_cloexec_flag(dups[2])
-
-                    # Disable inheritance
-                    if close_fds:
-                        for i in xrange(3, MAXFD):
-                            try:
-                                f = fcntl.fcntl(i, fcntl.F_GETFD)
-                                if not (f & fcntl.FD_CLOEXEC):
-                                    cloexec_fds.add(i)
-                                    self._set_cloexec_flag(i)
-                            except:
-                                pass
-
-                    if env is None:
-                        pid = os.spawnvp(mode, executable, args)
-                    else:
-                        pid = os.spawnvpe(mode, executable, args, env)
-                finally:
-                    # Restore inheritance
-                    for i in cloexec_fds:
-                        self._set_cloexec_flag(i, False)
-
-                    # Restore the parent stdio
-                    for i, fd in enumerate(dups):
-                        if fd is not None:
-                            os.dup2(fd, i)
-                            os.close(fd)
-
-                    # Restore the current directory
-                    if oldcwd is not None:
-                        os.chdir(oldcwd)
+
+                if close_fds:
+                  mode |= os.P_2_NOINHERIT
+                if threadsafe:
+                  mode |= os.P_2_THREADSAFE
+                stdfds = [ p2cread, c2pwrite, errwrite ]
+
+                pid = os.spawn2(mode, executable, args, cwd, env, stdfds)
 
                 # Child is launched. Close the parent's copy of those pipe
@@ -1480 +1443 @@
                         data = _eintr_retry_call(file.read)
                         if data == "":
-                            file.close()
+                            try:
+                                file.close()
+                            except IOError as e:
+                                # kLIBC close may fail with EBADF or even Error 0,
+                                # ignore for now
+                                pass
                             break
                         buffer.append(data)
@@ -1504 +1472 @@
                     if input is not None:
                         try:
-                            self.stdin.write(input)
+                            _eintr_retry_call(self.stdin.write, input)
                         except IOError as e:
                             if e.errno != errno.EPIPE:
                                 raise
-                    self.stdin.close()
+                    try:
+                        self.stdin.close()
+                    except IOError as e:
+                        # kLIBC close may fail with EBADF or even Error 0,
+                        # ignore for now
+                        pass
 
                 if self.stdout:

python/trunk/Modules/posixmodule.c

@@ -38 +38 @@
 #if defined(__KLIBC__)
 #include <sys/socket.h>
+#include <libcx/spawn2.h>
 #endif
 
@@ -8804 +8805 @@
 }
 #endif
+
+#if defined(PYOS_OS2)
+PyDoc_STRVAR(os2_spawn2__doc__,
+"spawn2(mode, file, args, cwd, env, stdfds)\n\n\
+Execute the program 'name' in a new process,\n\
+search path to find the file.\n\
+\n\
+   mode: mode of process creation\n\
+   file: executable file name\n\
+   args: tuple or list of strings\n\
+   cwd: initial working directory for the new process\n\
+   env: dictionary of strings mapping to strings\n\
+   stdfds: tuple or list of 3 file descriptors for standard I/O");
+
+static PyObject *
+os2_spawn2(PyObject *self, PyObject *args)
+{
+    char *path, *cwd = NULL;
+    PyObject *argv, *env, *stdfds;
+    char **argvlist;
+    char **envlist;
+    PyObject *key, *val, *keys=NULL, *vals=NULL, *res=NULL;
+    int mode, i, pos, argc, envc, stdfdc;
+    Py_intptr_t spawnval;
+    PyObject *(*argv_getitem)(PyObject *, Py_ssize_t);
+    int lastarg = 0;
+    PyObject *(*stdfd_getitem)(PyObject *, Py_ssize_t);
+    int stdfdlist[3] = {0};
+
+    /* Note: no need in et and Py_FileSystemDefaultEncoding for path arguments
+     * as on OS/2 this is always the same as the default encoding. */
+    if (!PyArg_ParseTuple(args, "isOzOO:spawn2", &mode,
+                          &path, &argv, &cwd, &env, &stdfds))
+        return NULL;
+    if (PyList_Check(argv)) {
+        argc = PyList_Size(argv);
+        argv_getitem = PyList_GetItem;
+    }
+    else if (PyTuple_Check(argv)) {
+        argc = PyTuple_Size(argv);
+        argv_getitem = PyTuple_GetItem;
+    }
+    else {
+        PyErr_SetString(PyExc_TypeError,
+                        "spawn2() arg 3 must be a tuple or list");
+        goto fail_0;
+    }
+
+    if (env != Py_None && !PyMapping_Check(env)) {
+        PyErr_SetString(PyExc_TypeError,
+                        "spawn2() arg 5 must be a mapping object");
+        goto fail_0;
+    }
+
+    if (PyList_Check(stdfds)) {
+        stdfdc = PyList_Size(stdfds);
+        stdfd_getitem = PyList_GetItem;
+    }
+    else if (PyTuple_Check(stdfds)) {
+        stdfdc = PyTuple_Size(stdfds);
+        stdfd_getitem = PyTuple_GetItem;
+    }
+    else if (stdfds == Py_None) {
+        stdfdc = -1;
+    }
+    else {
+        PyErr_SetString(PyExc_TypeError,
+                        "spawn2() arg 6 must be a tuple or list or None");
+        goto fail_0;
+    }
+    if (stdfdc != -1 && stdfdc != 3) {
+        PyErr_SetString(PyExc_TypeError,
+                        "spawn2() arg 6 must contain 3 elements");
+        goto fail_0;
+    }
+
+    argvlist = PyMem_NEW(char *, argc+1);
+    if (argvlist == NULL) {
+        PyErr_NoMemory();
+        goto fail_0;
+    }
+
+    for (i = 0; i < argc; i++) {
+        if (!PyArg_Parse((*argv_getitem)(argv, i), "et",
+                         Py_FileSystemDefaultEncoding, &argvlist[i]))
+        {
+            PyErr_SetString(PyExc_TypeError,
+                            "spawn2() arg 3 must contain only strings");
+            lastarg = i;
+            goto fail_1;
+        }
+    }
+    lastarg = argc;
+    argvlist[argc] = NULL;
+
+    if (env == Py_None) {
+        envlist = NULL;
+        envc = -1;
+    } else {
+        i = PyMapping_Size(env);
+        if (i < 0)
+            goto fail_1;
+        envlist = PyMem_NEW(char *, i + 1);
+        if (envlist == NULL) {
+            PyErr_NoMemory();
+            goto fail_1;
+        }
+        envc = 0;
+        keys = PyMapping_Keys(env);
+        vals = PyMapping_Values(env);
+        if (!keys || !vals)
+            goto fail_2;
+        if (!PyList_Check(keys) || !PyList_Check(vals)) {
+            PyErr_SetString(PyExc_TypeError,
+                            "spawn2(): env.keys() or env.values() is not a list");
+            goto fail_2;
+        }
+
+        for (pos = 0; pos < i; pos++) {
+            char *p, *k, *v;
+            size_t len;
+
+            key = PyList_GetItem(keys, pos);
+            val = PyList_GetItem(vals, pos);
+            if (!key || !val)
+                goto fail_2;
+
+            if (!PyArg_Parse(key, "s", &k)) {
+                PyErr_SetString(PyExc_TypeError,
+                                "spawn2() arg 5 contains a non-string key");
+                goto fail_2;
+            }
+            if (!PyArg_Parse(val, "s", &v)) {
+                PyErr_SetString(PyExc_TypeError,
+                                "spawn2() arg 5 contains a non-string key");
+                goto fail_2;
+            }
+            len = PyString_Size(key) + PyString_Size(val) + 2;
+            p = PyMem_NEW(char, len);
+            if (p == NULL) {
+                PyErr_NoMemory();
+                goto fail_2;
+            }
+            PyOS_snprintf(p, len, "%s=%s", k, v);
+            envlist[envc++] = p;
+        }
+        envlist[envc] = 0;
+    }
+
+    if (stdfdc != -1) {
+        for (i = 0; i < stdfdc; i++) {
+            PyObject *elem = (*stdfd_getitem)(stdfds, i);
+            if (elem == Py_None) {
+                stdfdlist[i] = 0;
+            } else {
+                if (!PyArg_Parse(elem, "i", &stdfdlist[i])) {
+                    PyErr_SetString(PyExc_TypeError,
+                                    "spawn2() arg 6 must contain only integers");
+                    goto fail_2;
+                }
+            }
+        }
+    }
+
+    Py_BEGIN_ALLOW_THREADS
+
+    spawnval = spawn2(mode, path, (const char * const *)argvlist, cwd,
+                      (const char * const *)envlist,
+                      stdfdc == -1 ? NULL : stdfdlist);
+
+    Py_END_ALLOW_THREADS
+
+    if (spawnval == -1)
+        (void) posix_error();
+    else
+        res = Py_BuildValue("l", (long) spawnval);
+
+  fail_2:
+    if (envlist) {
+        while (--envc >= 0)
+            PyMem_DEL(envlist[envc]);
+        PyMem_DEL(envlist);
+    }
+  fail_1:
+    free_string_array(argvlist, lastarg);
+    Py_XDECREF(vals);
+    Py_XDECREF(keys);
+  fail_0:
+    return res;
+}
+#endif /* PYOS_OS2 */
 
 static PyMethodDef posix_methods[] = {
@@ -9127 +9319 @@
 #endif
     {"urandom",         posix_urandom,   METH_VARARGS, posix_urandom__doc__},
+#ifdef PYOS_OS2
+    {"spawn2",          os2_spawn2, METH_VARARGS, os2_spawn2__doc__},
+#endif
     {NULL,              NULL}            /* Sentinel */
 };
@@ -9395 +9590 @@
     if (ins(d, "P_UNRELATED", (long)P_UNRELATED)) return -1;
     if (ins(d, "P_DEBUGDESC", (long)P_DEBUGDESC)) return -1;
+    if (ins(d, "P_2_NOINHERIT", (long)P_2_NOINHERIT)) return -1;
+    if (ins(d, "P_2_THREADSAFE", (long)P_2_THREADSAFE)) return -1;
+    if (ins(d, "P_2_MODE_MASK", (long)P_2_MODE_MASK)) return -1;
 #else
     if (ins(d, "P_WAIT", (long)_P_WAIT)) return -1;