Jan 28, 2026 · Jan 18, 2026 · Jan 18, 2026 · Jan 18, 2026 · Jan 18, 2026 · Jan 18, 2026
diff --git a/Doc/library/subprocess.rst b/Doc/library/subprocess.rst

   ..note::

      When the ``timeout`` parameter is not ``None``, then (on POSIX) the
      function is implemented using a busy loop (non-blocking call and short
      sleeps). Use the:mod:`asyncio` module for an asynchronous wait: see
      When ``timeout`` is not ``None`` and the platform supports it, an
      efficient event-driven mechanism is used to wait for process termination:

      - Linux >= 5.3 uses:func:`os.pidfd_open` +:func:`select.poll`
      - macOS and other BSD variants use:func:`select.kqueue` +
        ``KQ_FILTER_PROC`` + ``KQ_NOTE_EXIT``
      - Windows uses ``WaitForSingleObject``

      If none of these mechanisms are available, the function falls back to a
      busy loop (non-blocking call and short sleeps).

   ..note::

      Use the:mod:`asyncio` module for an asynchronous wait: see
 :class:`asyncio.create_subprocess_exec`.

   ..versionchanged::3.3
      *timeout* was added.

   ..versionchanged::3.15
      if *timeout* is not ``None``, use efficient event-driven implementation
      on Linux >= 5.3 and macOS / BSD.

 ..method::Popen.communicate(input=None, timeout=None)

   Interact with process: Send data to stdin.  Read data from stdout and stderr,
diff --git a/Doc/whatsnew/3.15.rst b/Doc/whatsnew/3.15.rst

   (Contributed by Ron Frederick in :gh:`138252`.)

 subprocess
 ----------

 * :meth:`subprocess.Popen.wait`: when ``timeout`` is not ``None`` and the
  platform supports it, an efficient event-driven mechanism is used to wait for
  process termination:

  - Linux >= 5.3 uses :func:`os.pidfd_open` + :func:`select.poll`.
  - macOS and other BSD variants use :func:`select.kqueue` + ``KQ_FILTER_PROC`` + ``KQ_NOTE_EXIT``.
  - Windows keeps using ``WaitForSingleObject`` (unchanged).

  If none of these mechanisms are available, the function falls back to the
  traditional busy loop (non-blocking call and short sleeps).
  (Contributed by Giampaolo Rodola in :gh:`83069`).

 sys
 ---
diff --git a/Lib/subprocess.py b/Lib/subprocess.py
 returnFalse


 def_can_use_pidfd_open():
 # Availability: Linux >= 5.3
 ifnothasattr(os,"pidfd_open"):
 returnFalse
 try:
 pidfd=os.pidfd_open(os.getpid(),0)
 exceptOSErroraserr:
 iferr.errnoin {errno.EMFILE,errno.ENFILE}:
 # transitory 'too many open files'
 returnTrue
 # likely blocked by security policy like SECCOMP (EPERM,
 # EACCES, ENOSYS)
 returnFalse
 else:
 os.close(pidfd)
 returnTrue


 def_can_use_kqueue():
 # Availability: macOS, BSD
 names= (
 "kqueue",
 "KQ_EV_ADD",
 "KQ_EV_ONESHOT",
 "KQ_FILTER_PROC",
 "KQ_NOTE_EXIT",
    )
 ifnotall(hasattr(select,x)forxinnames):
 returnFalse
 kq=None
 try:
 kq=select.kqueue()
 kev=select.kevent(
 os.getpid(),
 filter=select.KQ_FILTER_PROC,
 flags=select.KQ_EV_ADD|select.KQ_EV_ONESHOT,
 fflags=select.KQ_NOTE_EXIT,
        )
 kq.control([kev],1,0)
 returnTrue
 exceptOSErroraserr:
 iferr.errnoin {errno.EMFILE,errno.ENFILE}:
 # transitory 'too many open files'
 returnTrue
 returnFalse
 finally:
 ifkqisnotNone:
 kq.close()


 _CAN_USE_PIDFD_OPEN=not_mswindowsand_can_use_pidfd_open()
 _CAN_USE_KQUEUE=not_mswindowsand_can_use_kqueue()


 # These are primarily fail-safe knobs for negatives. A True value does not
 # guarantee the given libc/syscall API will be used.
 _USE_POSIX_SPAWN=_use_posix_spawn()
 sts=0
 return (pid,sts)

 def_wait_pidfd(self,timeout):
 """Wait for PID to terminate using pidfd_open() + poll().
            Linux >= 5.3 only.
            """
 ifnot_CAN_USE_PIDFD_OPEN:
 returnFalse
 try:
 pidfd=os.pidfd_open(self.pid,0)
 exceptOSError:
 # May be:
 # - ESRCH: no such process
 # - EMFILE, ENFILE: too many open files (usually 1024)
 # - ENODEV: anonymous inode filesystem not supported
 # - EPERM, EACCES, ENOSYS: undocumented; may happen if
 #   blocked by security policy like SECCOMP
 returnFalse

 try:
 poller=select.poll()
 poller.register(pidfd,select.POLLIN)
 events=poller.poll(timeout*1000)
 ifnotevents:
 raiseTimeoutExpired(self.args,timeout)
 returnTrue
 finally:
 os.close(pidfd)

 def_wait_kqueue(self,timeout):
 """Wait for PID to terminate using kqueue(). macOS and BSD only."""
 ifnot_CAN_USE_KQUEUE:
 returnFalse
 try:
 kq=select.kqueue()
 exceptOSError:
 # likely EMFILE / ENFILE (too many open files)
 returnFalse

 try:
 kev=select.kevent(
 self.pid,
 filter=select.KQ_FILTER_PROC,
 flags=select.KQ_EV_ADD|select.KQ_EV_ONESHOT,
 fflags=select.KQ_NOTE_EXIT,
                )
 try:
 events=kq.control([kev],1,timeout)# wait
 exceptOSError:
 returnFalse
 else:
 ifnotevents:
 raiseTimeoutExpired(self.args,timeout)
 returnTrue
 finally:
 kq.close()

 def_wait(self,timeout):
 """Internal implementation of wait() on POSIX."""
 """Internal implementation of wait() on POSIX.

            Uses efficient pidfd_open() + poll() on Linux or kqueue()
            on macOS/BSD when available. Falls back to polling
            waitpid(WNOHANG) otherwise.
            """
 ifself.returncodeisnotNone:
 returnself.returncode

 iftimeoutisnotNone:
 endtime=_time()+timeout
 iftimeout<0:
 raiseTimeoutExpired(self.args,timeout)
 started=_time()
 endtime=started+timeout

 # Try efficient wait first.
 ifself._wait_pidfd(timeout)orself._wait_kqueue(timeout):
 # Process is gone. At this point os.waitpid(pid, 0)
 # will return immediately, but in very rare races
 # the PID may have been reused.
 # os.waitpid(pid, WNOHANG) ensures we attempt a
 # non-blocking reap without blocking indefinitely.
 withself._waitpid_lock:
 ifself.returncodeisnotNone:
 returnself.returncode# Another thread waited.
                        (pid,sts)=self._try_wait(os.WNOHANG)
 assertpid==self.pidorpid==0
 ifpid==self.pid:
 self._handle_exitstatus(sts)
 returnself.returncode
 # os.waitpid(pid, WNOHANG) returned 0 instead
 # of our PID, meaning PID has not yet exited,
 # even though poll() / kqueue() said so. Very
 # rare and mostly theoretical. Fallback to busy
 # polling.
 elapsed=_time()-started
 endtime-=elapsed

 # Enter a busy loop if we have a timeout.  This busy loop was
 # cribbed from Lib/threading.py in Thread.wait() at r71065.
 delay=0.0005# 500 us -> initial delay of 1 ms
 # http://bugs.python.org/issue14396.
 ifpid==self.pid:
 self._handle_exitstatus(sts)

 returnself.returncode


diff --git a/Lib/test/test_subprocess.py b/Lib/test/test_subprocess.py
 deftest_wait_timeout(self):
 p=subprocess.Popen([sys.executable,
 "-c","import time; time.sleep(0.3)"])
 withself.assertRaises(subprocess.TimeoutExpired)asc:
 p.wait(timeout=0)
 withself.assertRaises(subprocess.TimeoutExpired)asc:
 p.wait(timeout=0.0001)
 self.assertIn("0.0001",str(c.exception))# For coverage of __str__.
 self.assertTrue(proc.stdin.closed)



 classFastWaitTestCase(BaseTestCase):
 """Tests for efficient (pidfd_open() + poll() / kqueue()) process
    waiting in subprocess.Popen.wait().
    """
 CAN_USE_PIDFD_OPEN=subprocess._CAN_USE_PIDFD_OPEN
 CAN_USE_KQUEUE=subprocess._CAN_USE_KQUEUE
 COMMAND= [sys.executable,"-c","import time; time.sleep(0.3)"]
 WAIT_TIMEOUT=0.0001# 0.1 ms

 defassert_fast_waitpid_error(self,patch_point):
 # Emulate a case where pidfd_open() or kqueue() fails.
 # Busy-poll wait should be used as fallback.
 exc=OSError(errno.EMFILE,os.strerror(errno.EMFILE))
 withmock.patch(patch_point,side_effect=exc)asm:
 p=subprocess.Popen(self.COMMAND)
 withself.assertRaises(subprocess.TimeoutExpired):
 p.wait(self.WAIT_TIMEOUT)
 self.assertEqual(p.wait(timeout=support.SHORT_TIMEOUT),0)
 self.assertTrue(m.called)

 @unittest.skipIf(notCAN_USE_PIDFD_OPEN,reason="needs pidfd_open()")
 deftest_wait_pidfd_open_error(self):
 self.assert_fast_waitpid_error("os.pidfd_open")

 @unittest.skipIf(notCAN_USE_KQUEUE,reason="needs kqueue() for proc")
 deftest_wait_kqueue_error(self):
 self.assert_fast_waitpid_error("select.kqueue")

 @unittest.skipIf(notCAN_USE_KQUEUE,reason="needs kqueue() for proc")
 deftest_kqueue_control_error(self):
 # Emulate a case where kqueue.control() fails. Busy-poll wait
 # should be used as fallback.
 p=subprocess.Popen(self.COMMAND)
 kq_mock=mock.Mock()
 kq_mock.control.side_effect=OSError(
 errno.EPERM,os.strerror(errno.EPERM)
        )
 kq_mock.close=mock.Mock()

 withmock.patch("select.kqueue",return_value=kq_mock)asm:
 withself.assertRaises(subprocess.TimeoutExpired):
 p.wait(self.WAIT_TIMEOUT)
 self.assertEqual(p.wait(timeout=support.SHORT_TIMEOUT),0)
 self.assertTrue(m.called)

 defassert_wait_race_condition(self,patch_target,real_func):
 # Call pidfd_open() / kqueue(), then terminate the process.
 # Make sure that the wait call (poll() / kqueue.control())
 # still works for a terminated PID.
 p=subprocess.Popen(self.COMMAND)

 defwrapper(*args,**kwargs):
 ret=real_func(*args,**kwargs)
 try:
 os.kill(p.pid,signal.SIGTERM)
 os.waitpid(p.pid,0)
 exceptOSError:
 pass
 returnret

 withmock.patch(patch_target,side_effect=wrapper)asm:
 status=p.wait(timeout=support.SHORT_TIMEOUT)
 self.assertTrue(m.called)
 self.assertEqual(status,0)

 @unittest.skipIf(notCAN_USE_PIDFD_OPEN,reason="needs pidfd_open()")
 deftest_pidfd_open_race(self):
 self.assert_wait_race_condition("os.pidfd_open",os.pidfd_open)

 @unittest.skipIf(notCAN_USE_KQUEUE,reason="needs kqueue() for proc")
 deftest_kqueue_race(self):
 self.assert_wait_race_condition("select.kqueue",select.kqueue)

 defassert_notification_without_immediate_reap(self,patch_target):
 # Verify fallback to busy polling when poll() / kqueue()
 # succeeds, but waitpid(pid, WNOHANG) returns (0, 0).
 defwaitpid_wrapper(pid,flags):
 nonlocalncalls
 ncalls+=1
 ifncalls==1:
 return (0,0)
 returnreal_waitpid(pid,flags)

 ncalls=0
 real_waitpid=os.waitpid
 withmock.patch.object(subprocess.Popen,patch_target,return_value=True)asm1:
 withmock.patch("os.waitpid",side_effect=waitpid_wrapper)asm2:
 p=subprocess.Popen(self.COMMAND)
 withself.assertRaises(subprocess.TimeoutExpired):
 p.wait(self.WAIT_TIMEOUT)
 self.assertEqual(p.wait(timeout=support.SHORT_TIMEOUT),0)
 self.assertTrue(m1.called)
 self.assertTrue(m2.called)

 @unittest.skipIf(notCAN_USE_PIDFD_OPEN,reason="needs pidfd_open()")
 deftest_pidfd_open_notification_without_immediate_reap(self):
 self.assert_notification_without_immediate_reap("_wait_pidfd")

 @unittest.skipIf(notCAN_USE_KQUEUE,reason="needs kqueue() for proc")
 deftest_kqueue_notification_without_immediate_reap(self):
 self.assert_notification_without_immediate_reap("_wait_kqueue")

 @unittest.skipUnless(
 CAN_USE_PIDFD_OPENorCAN_USE_KQUEUE,
 "fast wait mechanism not available"
    )
 deftest_fast_path_avoid_busy_loop(self):
 # assert that the busy loop is not called as long as the fast
 # wait is available
 withmock.patch('time.sleep')asm:
 p=subprocess.Popen(self.COMMAND)
 withself.assertRaises(subprocess.TimeoutExpired):
 p.wait(self.WAIT_TIMEOUT)
 self.assertEqual(p.wait(timeout=support.LONG_TIMEOUT),0)
 self.assertFalse(m.called)

 if__name__=="__main__":
 unittest.main()
diff --git a/Misc/NEWS.d/next/Library/2026-01-19-16-45-16.gh-issue-83069.0TaeH9.rst b/Misc/NEWS.d/next/Library/2026-01-19-16-45-16.gh-issue-83069.0TaeH9.rst
 :meth:`subprocess.Popen.wait`: when ``timeout`` is not ``None``, an efficient
 event-driven mechanism now waits for process termination, if available. Linux
 >= 5.3 uses:func:`os.pidfd_open` +:func:`select.poll`. macOS and other BSD
 variants use:func:`select.kqueue` + ``KQ_FILTER_PROC`` + ``KQ_NOTE_EXIT``.
 Windows keeps using ``WaitForSingleObject`` (unchanged). If none of these
 mechanisms are available, the function falls back to the traditional busy loop
 (non-blocking call and short sleeps). Patch by Giampaolo Rodola.
Original file line number	Diff line number	Diff line change
Expand Up		@@ -803,14 +803,29 @@ Instances of the :class:`Popen` class have the following methods:

		..note::

		When the ``timeout`` parameter is not ``None``, then (on POSIX) the
		function is implemented using a busy loop (non-blocking call and short
		sleeps). Use the:mod:`asyncio` module for an asynchronous wait: see
		When ``timeout`` is not ``None`` and the platform supports it, an
		efficient event-driven mechanism is used to wait for process termination:

		- Linux >= 5.3 uses:func:`os.pidfd_open` +:func:`select.poll`
		- macOS and other BSD variants use:func:`select.kqueue` +
		``KQ_FILTER_PROC`` + ``KQ_NOTE_EXIT``
		- Windows uses ``WaitForSingleObject``

		If none of these mechanisms are available, the function falls back to a
		busy loop (non-blocking call and short sleeps).

		..note::

		Use the:mod:`asyncio` module for an asynchronous wait: see
		:class:`asyncio.create_subprocess_exec`.

		..versionchanged::3.3
		timeout was added.

		..versionchanged::3.15
		if timeout is not ``None``, use efficient event-driven implementation
		on Linux >= 5.3 and macOS / BSD.

		..method::Popen.communicate(input=None, timeout=None)

		Interact with process: Send data to stdin. Read data from stdout and stderr,
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -736,6 +736,20 @@ ssl

		(Contributed by Ron Frederick in :gh:`138252`.)

		subprocess
		----------

		* :meth:`subprocess.Popen.wait`: when ``timeout`` is not ``None`` and the
		platform supports it, an efficient event-driven mechanism is used to wait for
		process termination:

		- Linux >= 5.3 uses :func:`os.pidfd_open` + :func:`select.poll`.
		- macOS and other BSD variants use :func:`select.kqueue` + ``KQ_FILTER_PROC`` + ``KQ_NOTE_EXIT``.
		- Windows keeps using ``WaitForSingleObject`` (unchanged).

		If none of these mechanisms are available, the function falls back to the
		traditional busy loop (non-blocking call and short sleeps).
		(Contributed by Giampaolo Rodola in :gh:`83069`).

		sys
		---
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -748,6 +748,60 @@ def _use_posix_spawn():
		returnFalse


		def_can_use_pidfd_open():
		# Availability: Linux >= 5.3
		ifnothasattr(os,"pidfd_open"):
		returnFalse
		try:
		pidfd=os.pidfd_open(os.getpid(),0)
		exceptOSErroraserr:
		iferr.errnoin {errno.EMFILE,errno.ENFILE}:
		# transitory 'too many open files'
		returnTrue
		# likely blocked by security policy like SECCOMP (EPERM,
		# EACCES, ENOSYS)
		returnFalse
		else:
		os.close(pidfd)
		returnTrue


		def_can_use_kqueue():
		# Availability: macOS, BSD
		names= (
		"kqueue",
		"KQ_EV_ADD",
		"KQ_EV_ONESHOT",
		"KQ_FILTER_PROC",
		"KQ_NOTE_EXIT",
		)
		ifnotall(hasattr(select,x)forxinnames):
		returnFalse
		kq=None
		try:
		kq=select.kqueue()
		kev=select.kevent(
		os.getpid(),
		filter=select.KQ_FILTER_PROC,
		flags=select.KQ_EV_ADD\|select.KQ_EV_ONESHOT,
		fflags=select.KQ_NOTE_EXIT,
		)
		kq.control([kev],1,0)
		returnTrue
		exceptOSErroraserr:
		iferr.errnoin {errno.EMFILE,errno.ENFILE}:
		# transitory 'too many open files'
		returnTrue
		returnFalse
		finally:
		ifkqisnotNone:
		kq.close()


		_CAN_USE_PIDFD_OPEN=not_mswindowsand_can_use_pidfd_open()
		_CAN_USE_KQUEUE=not_mswindowsand_can_use_kqueue()


		# These are primarily fail-safe knobs for negatives. A True value does not
		# guarantee the given libc/syscall API will be used.
		_USE_POSIX_SPAWN=_use_posix_spawn()
Expand DownExpand Up		@@ -2046,14 +2100,100 @@ def _try_wait(self, wait_flags):
		sts=0
		return (pid,sts)

		def_wait_pidfd(self,timeout):
		"""Wait for PID to terminate using pidfd_open() + poll().
		Linux >= 5.3 only.
		"""
		ifnot_CAN_USE_PIDFD_OPEN:
		returnFalse
		try:
		pidfd=os.pidfd_open(self.pid,0)
		exceptOSError:
		# May be:
		# - ESRCH: no such process
		# - EMFILE, ENFILE: too many open files (usually 1024)
		# - ENODEV: anonymous inode filesystem not supported
		# - EPERM, EACCES, ENOSYS: undocumented; may happen if
		# blocked by security policy like SECCOMP
		returnFalse

		try:
		poller=select.poll()
		poller.register(pidfd,select.POLLIN)
		events=poller.poll(timeout*1000)
		ifnotevents:
		raiseTimeoutExpired(self.args,timeout)
		returnTrue
		finally:
		os.close(pidfd)

		def_wait_kqueue(self,timeout):
		"""Wait for PID to terminate using kqueue(). macOS and BSD only."""
		ifnot_CAN_USE_KQUEUE:
		returnFalse
		try:
		kq=select.kqueue()
		exceptOSError:
		# likely EMFILE / ENFILE (too many open files)
		returnFalse

		try:
		kev=select.kevent(
		self.pid,
		filter=select.KQ_FILTER_PROC,
		flags=select.KQ_EV_ADD\|select.KQ_EV_ONESHOT,
		fflags=select.KQ_NOTE_EXIT,
		)
		try:
		events=kq.control([kev],1,timeout)# wait
		exceptOSError:
		returnFalse
		else:
		ifnotevents:
		raiseTimeoutExpired(self.args,timeout)
		returnTrue
		finally:
		kq.close()

		def_wait(self,timeout):
		"""Internal implementation of wait() on POSIX."""
		"""Internal implementation of wait() on POSIX.

		Uses efficient pidfd_open() + poll() on Linux or kqueue()
		on macOS/BSD when available. Falls back to polling
		waitpid(WNOHANG) otherwise.
		"""
		ifself.returncodeisnotNone:
		returnself.returncode

		iftimeoutisnotNone:
		endtime=_time()+timeout
		iftimeout<0:
		raiseTimeoutExpired(self.args,timeout)
		started=_time()
		endtime=started+timeout

		# Try efficient wait first.
		ifself._wait_pidfd(timeout)orself._wait_kqueue(timeout):
		# Process is gone. At this point os.waitpid(pid, 0)
		# will return immediately, but in very rare races
		# the PID may have been reused.
		# os.waitpid(pid, WNOHANG) ensures we attempt a
		# non-blocking reap without blocking indefinitely.
		withself._waitpid_lock:
		ifself.returncodeisnotNone:
		returnself.returncode# Another thread waited.
		(pid,sts)=self._try_wait(os.WNOHANG)
		assertpid==self.pidorpid==0
		ifpid==self.pid:
		self._handle_exitstatus(sts)
		returnself.returncode
		# os.waitpid(pid, WNOHANG) returned 0 instead
		# of our PID, meaning PID has not yet exited,
		# even though poll() / kqueue() said so. Very
		# rare and mostly theoretical. Fallback to busy
		# polling.
		elapsed=_time()-started
		endtime-=elapsed

		# Enter a busy loop if we have a timeout. This busy loop was
		# cribbed from Lib/threading.py in Thread.wait() at r71065.
		delay=0.0005# 500 us -> initial delay of 1 ms
Expand DownExpand Up		@@ -2085,6 +2225,7 @@ def _wait(self, timeout):
		# http://bugs.python.org/issue14396.
		ifpid==self.pid:
		self._handle_exitstatus(sts)

		returnself.returncode


Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -1423,6 +1423,8 @@ def test_wait(self):
		deftest_wait_timeout(self):
		p=subprocess.Popen([sys.executable,
		"-c","import time; time.sleep(0.3)"])
		withself.assertRaises(subprocess.TimeoutExpired)asc:
		p.wait(timeout=0)
		withself.assertRaises(subprocess.TimeoutExpired)asc:
		p.wait(timeout=0.0001)
		self.assertIn("0.0001",str(c.exception))# For coverage of __str__.
Expand DownExpand Up		@@ -4094,5 +4096,122 @@ def test_broken_pipe_cleanup(self):
		self.assertTrue(proc.stdin.closed)



		classFastWaitTestCase(BaseTestCase):
		"""Tests for efficient (pidfd_open() + poll() / kqueue()) process
		waiting in subprocess.Popen.wait().
		"""
		CAN_USE_PIDFD_OPEN=subprocess._CAN_USE_PIDFD_OPEN
		CAN_USE_KQUEUE=subprocess._CAN_USE_KQUEUE
giampaolo marked this conversation as resolved. Show resolvedHide resolved
		COMMAND= [sys.executable,"-c","import time; time.sleep(0.3)"]
		WAIT_TIMEOUT=0.0001# 0.1 ms

		defassert_fast_waitpid_error(self,patch_point):
		# Emulate a case where pidfd_open() or kqueue() fails.
		# Busy-poll wait should be used as fallback.
		exc=OSError(errno.EMFILE,os.strerror(errno.EMFILE))
		withmock.patch(patch_point,side_effect=exc)asm:
		p=subprocess.Popen(self.COMMAND)
		withself.assertRaises(subprocess.TimeoutExpired):
		p.wait(self.WAIT_TIMEOUT)
		self.assertEqual(p.wait(timeout=support.SHORT_TIMEOUT),0)
		self.assertTrue(m.called)

		@unittest.skipIf(notCAN_USE_PIDFD_OPEN,reason="needs pidfd_open()")
		deftest_wait_pidfd_open_error(self):
		self.assert_fast_waitpid_error("os.pidfd_open")

		@unittest.skipIf(notCAN_USE_KQUEUE,reason="needs kqueue() for proc")
		deftest_wait_kqueue_error(self):
		self.assert_fast_waitpid_error("select.kqueue")

		@unittest.skipIf(notCAN_USE_KQUEUE,reason="needs kqueue() for proc")
		deftest_kqueue_control_error(self):
		# Emulate a case where kqueue.control() fails. Busy-poll wait
		# should be used as fallback.
		p=subprocess.Popen(self.COMMAND)
		kq_mock=mock.Mock()
		kq_mock.control.side_effect=OSError(
		errno.EPERM,os.strerror(errno.EPERM)
		)
		kq_mock.close=mock.Mock()

		withmock.patch("select.kqueue",return_value=kq_mock)asm:
		withself.assertRaises(subprocess.TimeoutExpired):
		p.wait(self.WAIT_TIMEOUT)
		self.assertEqual(p.wait(timeout=support.SHORT_TIMEOUT),0)
		self.assertTrue(m.called)

		defassert_wait_race_condition(self,patch_target,real_func):
		# Call pidfd_open() / kqueue(), then terminate the process.
		# Make sure that the wait call (poll() / kqueue.control())
		# still works for a terminated PID.
		p=subprocess.Popen(self.COMMAND)

		defwrapper(args,*kwargs):
		ret=real_func(args,*kwargs)
		try:
		os.kill(p.pid,signal.SIGTERM)
		os.waitpid(p.pid,0)
		exceptOSError:
		pass
		returnret

		withmock.patch(patch_target,side_effect=wrapper)asm:
		status=p.wait(timeout=support.SHORT_TIMEOUT)
		self.assertTrue(m.called)
		self.assertEqual(status,0)

		@unittest.skipIf(notCAN_USE_PIDFD_OPEN,reason="needs pidfd_open()")
		deftest_pidfd_open_race(self):
		self.assert_wait_race_condition("os.pidfd_open",os.pidfd_open)

		@unittest.skipIf(notCAN_USE_KQUEUE,reason="needs kqueue() for proc")
		deftest_kqueue_race(self):
		self.assert_wait_race_condition("select.kqueue",select.kqueue)

		defassert_notification_without_immediate_reap(self,patch_target):
		# Verify fallback to busy polling when poll() / kqueue()
		# succeeds, but waitpid(pid, WNOHANG) returns (0, 0).
		defwaitpid_wrapper(pid,flags):
		nonlocalncalls
		ncalls+=1
		ifncalls==1:
		return (0,0)
		returnreal_waitpid(pid,flags)

		ncalls=0
		real_waitpid=os.waitpid
		withmock.patch.object(subprocess.Popen,patch_target,return_value=True)asm1:
		withmock.patch("os.waitpid",side_effect=waitpid_wrapper)asm2:
		p=subprocess.Popen(self.COMMAND)
		withself.assertRaises(subprocess.TimeoutExpired):
		p.wait(self.WAIT_TIMEOUT)
		self.assertEqual(p.wait(timeout=support.SHORT_TIMEOUT),0)
		self.assertTrue(m1.called)
		self.assertTrue(m2.called)

		@unittest.skipIf(notCAN_USE_PIDFD_OPEN,reason="needs pidfd_open()")
		deftest_pidfd_open_notification_without_immediate_reap(self):
		self.assert_notification_without_immediate_reap("_wait_pidfd")

		@unittest.skipIf(notCAN_USE_KQUEUE,reason="needs kqueue() for proc")
		deftest_kqueue_notification_without_immediate_reap(self):
		self.assert_notification_without_immediate_reap("_wait_kqueue")

		@unittest.skipUnless(
		CAN_USE_PIDFD_OPENorCAN_USE_KQUEUE,
		"fast wait mechanism not available"
		)
		deftest_fast_path_avoid_busy_loop(self):
		# assert that the busy loop is not called as long as the fast
		# wait is available
		withmock.patch('time.sleep')asm:
		p=subprocess.Popen(self.COMMAND)
		withself.assertRaises(subprocess.TimeoutExpired):
		p.wait(self.WAIT_TIMEOUT)
		self.assertEqual(p.wait(timeout=support.LONG_TIMEOUT),0)
		self.assertFalse(m.called)

		if__name__=="__main__":
		unittest.main()
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,7 @@
		:meth:`subprocess.Popen.wait`: when ``timeout`` is not ``None``, an efficient
		event-driven mechanism now waits for process termination, if available. Linux
		>= 5.3 uses:func:`os.pidfd_open` +:func:`select.poll`. macOS and other BSD
		variants use:func:`select.kqueue` + ``KQ_FILTER_PROC`` + ``KQ_NOTE_EXIT``.
		Windows keeps using ``WaitForSingleObject`` (unchanged). If none of these
		mechanisms are available, the function falls back to the traditional busy loop
		(non-blocking call and short sleeps). Patch by Giampaolo Rodola.