Issue #23285: PEP 475 -- Retry system calls failing with EINTR.

Author: cf-natali

Doc/whatsnew/3.5.rst

@@ -111,6 +111,16 @@ Please read on for a comprehensive list of user-facing changes.
        PEP written by Carl Meyer
 
 
+PEP 475: Retry system calls failing with EINTR
+----------------------------------------------
+
+:pep:`475` adds support for automatic retry of system calls failing with EINTR:
+this means that user code doesn't have to deal with EINTR or InterruptedError
+manually, and should make it more robust against asynchronous signal reception.
+
+.. seealso::
+
+   :pep:`475` -- Retry system calls failing with EINTR
 
 
 Other Language Changes

Lib/_pyio.py

@@ -1012,10 +1012,7 @@ def _read_unlocked(self, n=None):
             current_size = 0
             while True:
                 # Read until EOF or until read() would block.
-                try:
-                    chunk = self.raw.read()
-                except InterruptedError:
-                    continue
+                chunk = self.raw.read()
                 if chunk in empty_values:
                     nodata_val = chunk
                     break
@@ -1034,10 +1031,7 @@ def _read_unlocked(self, n=None):
         chunks = [buf[pos:]]
         wanted = max(self.buffer_size, n)
         while avail < n:
-            try:
-                chunk = self.raw.read(wanted)
-            except InterruptedError:
-                continue
+            chunk = self.raw.read(wanted)
             if chunk in empty_values:
                 nodata_val = chunk
                 break
@@ -1066,12 +1060,7 @@ def _peek_unlocked(self, n=0):
         have = len(self._read_buf) - self._read_pos
         if have < want or have <= 0:
             to_read = self.buffer_size - have
-            while True:
-                try:
-                    current = self.raw.read(to_read)
-                except InterruptedError:
-                    continue
-                break
+            current = self.raw.read(to_read)
             if current:
                 self._read_buf = self._read_buf[self._read_pos:] + current
                 self._read_pos = 0
@@ -1220,8 +1209,6 @@ def _flush_unlocked(self):
         while self._write_buf:
             try:
                 n = self.raw.write(self._write_buf)
-            except InterruptedError:
-                continue
             except BlockingIOError:
                 raise RuntimeError("self.raw should implement RawIOBase: it "
                                    "should not raise BlockingIOError")

Lib/distutils/spawn.py

@@ -137,9 +137,6 @@ def _spawn_posix(cmd, search_path=1, verbose=0, dry_run=0):
             try:
                 pid, status = os.waitpid(pid, 0)
             except OSError as exc:
-                import errno
-                if exc.errno == errno.EINTR:
-                    continue
                 if not DEBUG:
                     cmd = executable
                 raise DistutilsExecError(

Lib/multiprocessing/connection.py

@@ -365,10 +365,7 @@ def _close(self, _close=os.close):
     def _send(self, buf, write=_write):
         remaining = len(buf)
         while True:
-            try:
-                n = write(self._handle, buf)
-            except InterruptedError:
-                continue
+            n = write(self._handle, buf)
             remaining -= n
             if remaining == 0:
                 break
@@ -379,10 +376,7 @@ def _recv(self, size, read=_read):
         handle = self._handle
         remaining = size
         while remaining > 0:
-            try:
-                chunk = read(handle, remaining)
-            except InterruptedError:
-                continue
+            chunk = read(handle, remaining)
             n = len(chunk)
             if n == 0:
                 if remaining == size:
@@ -595,13 +589,7 @@ def __init__(self, address, family, backlog=1):
             self._unlink = None
 
     def accept(self):
-        while True:
-            try:
-                s, self._last_accepted = self._socket.accept()
-            except InterruptedError:
-                pass
-            else:
-                break
+        s, self._last_accepted = self._socket.accept()
         s.setblocking(True)
         return Connection(s.detach())
 

Lib/multiprocessing/forkserver.py

@@ -188,8 +188,6 @@ def main(listener_fd, alive_r, preload, main_path=None, sys_path=None):
                         finally:
                             os._exit(code)
 
-            except InterruptedError:
-                pass
             except OSError as e:
                 if e.errno != errno.ECONNABORTED:
                     raise
@@ -230,13 +228,7 @@ def read_unsigned(fd):
     data = b''
     length = UNSIGNED_STRUCT.size
     while len(data) < length:
-        while True:
-            try:
-                s = os.read(fd, length - len(data))
-            except InterruptedError:
-                pass
-            else:
-                break
+        s = os.read(fd, length - len(data))
         if not s:
             raise EOFError('unexpected EOF')
         data += s
@@ -245,13 +237,7 @@ def read_unsigned(fd):
 def write_unsigned(fd, n):
     msg = UNSIGNED_STRUCT.pack(n)
     while msg:
-        while True:
-            try:
-                nbytes = os.write(fd, msg)
-            except InterruptedError:
-                pass
-            else:
-                break
+        nbytes = os.write(fd, msg)
         if nbytes == 0:
             raise RuntimeError('should not get here')
         msg = msg[nbytes:]

Lib/multiprocessing/popen_fork.py

@@ -1,7 +1,6 @@
 import os
 import sys
 import signal
-import errno
 
 from . import util
 
@@ -29,8 +28,6 @@ def poll(self, flag=os.WNOHANG):
                 try:
                     pid, sts = os.waitpid(self.pid, flag)
                 except OSError as e:
-                    if e.errno == errno.EINTR:
-                        continue
                     # Child process not yet created. See #1731717
                     # e.errno == errno.ECHILD == 10
                     return None

Lib/socket.py

@@ -572,8 +572,6 @@ def readinto(self, b):
             except timeout:
                 self._timeout_occurred = True
                 raise
-            except InterruptedError:
-                continue
             except error as e:
                 if e.args[0] in _blocking_errnos:
                     return None

Lib/socketserver.py

@@ -553,8 +553,6 @@ def collect_children(self):
             try:
                 pid, _ = os.waitpid(-1, 0)
                 self.active_children.discard(pid)
-            except InterruptedError:
-                pass
             except ChildProcessError:
                 # we don't have any children, we're done
                 self.active_children.clear()

Lib/subprocess.py

@@ -489,14 +489,6 @@ def _cleanup():
 DEVNULL = -3
 
 
-def _eintr_retry_call(func, *args):
-    while True:
-        try:
-            return func(*args)
-        except InterruptedError:
-            continue
-
-
 # XXX This function is only used by multiprocessing and the test suite,
 # but it's here so that it can be imported when Python is compiled without
 # threads.
@@ -963,10 +955,10 @@ def communicate(self, input=None, timeout=None):
             if self.stdin:
                 self._stdin_write(input)
             elif self.stdout:
-                stdout = _eintr_retry_call(self.stdout.read)
+                stdout = self.stdout.read()
                 self.stdout.close()
             elif self.stderr:
-                stderr = _eintr_retry_call(self.stderr.read)
+                stderr = self.stderr.read()
                 self.stderr.close()
             self.wait()
         else:
@@ -1410,7 +1402,7 @@ def _execute_child(self, args, executable, preexec_fn, close_fds,
                 # exception (limited in size)
                 errpipe_data = bytearray()
                 while True:
-                    part = _eintr_retry_call(os.read, errpipe_read, 50000)
+                    part = os.read(errpipe_read, 50000)
                     errpipe_data += part
                     if not part or len(errpipe_data) > 50000:
                         break
@@ -1420,7 +1412,7 @@ def _execute_child(self, args, executable, preexec_fn, close_fds,
 
             if errpipe_data:
                 try:
-                    _eintr_retry_call(os.waitpid, self.pid, 0)
+                    os.waitpid(self.pid, 0)
                 except ChildProcessError:
                     pass
                 try:
@@ -1505,7 +1497,7 @@ def _internal_poll(self, _deadstate=None, _waitpid=os.waitpid,
         def _try_wait(self, wait_flags):
             """All callers to this function MUST hold self._waitpid_lock."""
             try:
-                (pid, sts) = _eintr_retry_call(os.waitpid, self.pid, wait_flags)
+                (pid, sts) = os.waitpid(self.pid, wait_flags)
             except ChildProcessError:
                 # This happens if SIGCLD is set to be ignored or waiting
                 # for child processes has otherwise been disabled for our