Thanks to visit codestin.com
Credit goes to github.com

Skip to content

Commit 850a18e

Browse files
vstinnervstinner
authored
bpo-30768: Recompute timeout on interrupted lock (pythonGH-4103)
Fix the pthread+semaphore implementation of PyThread_acquire_lock_timed() when called with timeout > 0 and intr_flag=0: recompute the timeout if sem_timedwait() is interrupted by a signal (EINTR). See also the PEP 475. The pthread implementation of PyThread_acquire_lock() now fails with a fatal error if the timeout is larger than PY_TIMEOUT_MAX, as done in the Windows implementation. The check prevents any risk of overflow in PyThread_acquire_lock(). Add also PY_DWORD_MAX constant.
1 parent 3557b05 commit 850a18e

File tree

9 files changed

+86
-31
lines changed

9 files changed

+86
-31
lines changed

‎Include/pyport.h

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -787,6 +787,9 @@ extern _invalid_parameter_handler _Py_silent_invalid_parameter_handler;
787787
#include <android/api-level.h>
788788
#endif
789789

790+
/* Maximum value of the Windows DWORD type */
791+
#define PY_DWORD_MAX 4294967295U
792+
790793
/* This macro used to tell whether Python was built with multithreading
791794
* enabled. Now multithreading is always enabled, but keep the macro
792795
* for compatibility.

‎Include/pythread.h

Lines changed: 14 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -42,16 +42,23 @@ PyAPI_FUNC(int) PyThread_acquire_lock(PyThread_type_lock, int);
4242
and floating-point numbers allowed.
4343
*/
4444
#define PY_TIMEOUT_T long long
45-
#define PY_TIMEOUT_MAX PY_LLONG_MAX
4645

47-
/* In the NT API, the timeout is a DWORD and is expressed in milliseconds */
48-
#if defined (NT_THREADS)
49-
#if 0xFFFFFFFFLL * 1000 < PY_TIMEOUT_MAX
50-
#undef PY_TIMEOUT_MAX
51-
#define PY_TIMEOUT_MAX (0xFFFFFFFFLL * 1000)
52-
#endif
46+
#if defined(_POSIX_THREADS)
47+
/* PyThread_acquire_lock_timed() uses _PyTime_FromNanoseconds(us * 1000),
48+
convert microseconds to nanoseconds. */
49+
# define PY_TIMEOUT_MAX (PY_LLONG_MAX / 1000)
50+
#elif defined (NT_THREADS)
51+
/* In the NT API, the timeout is a DWORD and is expressed in milliseconds */
52+
# if 0xFFFFFFFFLL * 1000 < PY_LLONG_MAX
53+
# define PY_TIMEOUT_MAX (0xFFFFFFFFLL * 1000)
54+
# else
55+
# define PY_TIMEOUT_MAX PY_LLONG_MAX
56+
# endif
57+
#else
58+
# define PY_TIMEOUT_MAX PY_LLONG_MAX
5359
#endif
5460

61+
5562
/* If microseconds == 0, the call is non-blocking: it returns immediately
5663
even when the lock can't be acquired.
5764
If microseconds > 0, the call waits up to the specified duration.

‎Misc/NEWS.d/next/Library/2017-10-24-12-00-16.bpo-30768.Om8Yj_.rst

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,3 @@
1+
Fix the pthread+semaphore implementation of PyThread_acquire_lock_timed() when
2+
called with timeout > 0 and intr_flag=0: recompute the timeout if
3+
sem_timedwait() is interrupted by a signal (EINTR). See also the :pep:`475`.

‎Modules/_threadmodule.c

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1363,9 +1363,11 @@ PyInit__thread(void)
13631363
if (m == NULL)
13641364
return NULL;
13651365

1366-
timeout_max = PY_TIMEOUT_MAX / 1000000;
1367-
time_max = floor(_PyTime_AsSecondsDouble(_PyTime_MAX));
1366+
timeout_max = (double)PY_TIMEOUT_MAX * 1e-6;
1367+
time_max = _PyTime_AsSecondsDouble(_PyTime_MAX);
13681368
timeout_max = Py_MIN(timeout_max, time_max);
1369+
/* Round towards minus infinity */
1370+
timeout_max = floor(timeout_max);
13691371

13701372
v = PyFloat_FromDouble(timeout_max);
13711373
if (!v)

‎Modules/_winapi.c

Lines changed: 4 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -61,8 +61,6 @@
6161

6262
#define T_HANDLE T_POINTER
6363

64-
#define DWORD_MAX 4294967295U
65-
6664
/* Grab CancelIoEx dynamically from kernel32 */
6765
static int has_CancelIoEx = -1;
6866
static BOOL (CALLBACK *Py_CancelIoEx)(HANDLE, LPOVERLAPPED);
@@ -184,11 +182,11 @@ class DWORD_return_converter(CReturnConverter):
184182
185183
def render(self, function, data):
186184
self.declare(data)
187-
self.err_occurred_if("_return_value == DWORD_MAX", data)
185+
self.err_occurred_if("_return_value == PY_DWORD_MAX", data)
188186
data.return_conversion.append(
189187
'return_value = Py_BuildValue("k", _return_value);\n')
190188
[python start generated code]*/
191-
/*[python end generated code: output=da39a3ee5e6b4b0d input=94819e72d2c6d558]*/
189+
/*[python end generated code: output=da39a3ee5e6b4b0d input=4527052fe06e5823]*/
192190

193191
#include "clinic/_winapi.c.h"
194192

@@ -1009,7 +1007,7 @@ _winapi_GetExitCodeProcess_impl(PyObject *module, HANDLE process)
10091007

10101008
if (! result) {
10111009
PyErr_SetFromWindowsErr(GetLastError());
1012-
exit_code = DWORD_MAX;
1010+
exit_code = PY_DWORD_MAX;
10131011
}
10141012

10151013
return exit_code;
@@ -1466,7 +1464,7 @@ _winapi_WriteFile_impl(PyObject *module, HANDLE handle, PyObject *buffer,
14661464
}
14671465

14681466
Py_BEGIN_ALLOW_THREADS
1469-
len = (DWORD)Py_MIN(buf->len, DWORD_MAX);
1467+
len = (DWORD)Py_MIN(buf->len, PY_DWORD_MAX);
14701468
ret = WriteFile(handle, buf->buf, len, &written,
14711469
overlapped ? &overlapped->overlapped : NULL);
14721470
Py_END_ALLOW_THREADS

‎Modules/clinic/_winapi.c.h

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -460,7 +460,7 @@ _winapi_GetExitCodeProcess(PyObject *module, PyObject *arg)
460460
goto exit;
461461
}
462462
_return_value = _winapi_GetExitCodeProcess_impl(module, process);
463-
if ((_return_value == DWORD_MAX) && PyErr_Occurred()) {
463+
if ((_return_value == PY_DWORD_MAX) && PyErr_Occurred()) {
464464
goto exit;
465465
}
466466
return_value = Py_BuildValue("k", _return_value);
@@ -487,7 +487,7 @@ _winapi_GetLastError(PyObject *module, PyObject *Py_UNUSED(ignored))
487487
DWORD _return_value;
488488

489489
_return_value = _winapi_GetLastError_impl(module);
490-
if ((_return_value == DWORD_MAX) && PyErr_Occurred()) {
490+
if ((_return_value == PY_DWORD_MAX) && PyErr_Occurred()) {
491491
goto exit;
492492
}
493493
return_value = Py_BuildValue("k", _return_value);
@@ -889,4 +889,4 @@ _winapi_WriteFile(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject
889889
exit:
890890
return return_value;
891891
}
892-
/*[clinic end generated code: output=afa6bd61eb0f18d2 input=a9049054013a1b77]*/
892+
/*[clinic end generated code: output=fba2ad7bf1a87e4a input=a9049054013a1b77]*/

‎Modules/posixmodule.c

Lines changed: 1 addition & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -390,8 +390,6 @@ static int win32_can_symlink = 0;
390390
#endif
391391
#endif
392392

393-
#define DWORD_MAX 4294967295U
394-
395393
#ifdef MS_WINDOWS
396394
#define INITFUNC PyInit_nt
397395
#define MODNAME "nt"
@@ -3817,7 +3815,7 @@ os__getvolumepathname_impl(PyObject *module, PyObject *path)
38173815
/* Volume path should be shorter than entire path */
38183816
buflen = Py_MAX(buflen, MAX_PATH);
38193817

3820-
if (buflen > DWORD_MAX) {
3818+
if (buflen > PY_DWORD_MAX) {
38213819
PyErr_SetString(PyExc_OverflowError, "path too long");
38223820
return NULL;
38233821
}

‎Python/thread_nt.h

Lines changed: 5 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -283,12 +283,13 @@ PyThread_acquire_lock_timed(PyThread_type_lock aLock,
283283
milliseconds = microseconds / 1000;
284284
if (microseconds % 1000 > 0)
285285
++milliseconds;
286-
if ((DWORD) milliseconds != milliseconds)
287-
Py_FatalError("Timeout too large for a DWORD, "
288-
"please check PY_TIMEOUT_MAX");
286+
if (milliseconds > PY_DWORD_MAX) {
287+
Py_FatalError("Timeout larger than PY_TIMEOUT_MAX");
288+
}
289289
}
290-
else
290+
else {
291291
milliseconds = INFINITE;
292+
}
292293

293294
dprintf(("%lu: PyThread_acquire_lock_timed(%p, %lld) called\n",
294295
PyThread_get_thread_ident(), aLock, microseconds));

‎Python/thread_pthread.h

Lines changed: 49 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -318,23 +318,66 @@ PyThread_acquire_lock_timed(PyThread_type_lock lock, PY_TIMEOUT_T microseconds,
318318
sem_t *thelock = (sem_t *)lock;
319319
int status, error = 0;
320320
struct timespec ts;
321+
_PyTime_t deadline = 0;
321322

322323
(void) error; /* silence unused-but-set-variable warning */
323324
dprintf(("PyThread_acquire_lock_timed(%p, %lld, %d) called\n",
324325
lock, microseconds, intr_flag));
325326

326-
if (microseconds > 0)
327+
if (microseconds > PY_TIMEOUT_MAX) {
328+
Py_FatalError("Timeout larger than PY_TIMEOUT_MAX");
329+
}
330+
331+
if (microseconds > 0) {
327332
MICROSECONDS_TO_TIMESPEC(microseconds, ts);
328-
do {
329-
if (microseconds > 0)
333+
334+
if (!intr_flag) {
335+
/* cannot overflow thanks to (microseconds > PY_TIMEOUT_MAX)
336+
check done above */
337+
_PyTime_t timeout = _PyTime_FromNanoseconds(microseconds * 1000);
338+
deadline = _PyTime_GetMonotonicClock() + timeout;
339+
}
340+
}
341+
342+
while (1) {
343+
if (microseconds > 0) {
330344
status = fix_status(sem_timedwait(thelock, &ts));
331-
else if (microseconds == 0)
345+
}
346+
else if (microseconds == 0) {
332347
status = fix_status(sem_trywait(thelock));
333-
else
348+
}
349+
else {
334350
status = fix_status(sem_wait(thelock));
351+
}
352+
335353
/* Retry if interrupted by a signal, unless the caller wants to be
336354
notified. */
337-
} while (!intr_flag && status == EINTR);
355+
if (intr_flag || status != EINTR) {
356+
break;
357+
}
358+
359+
if (microseconds > 0) {
360+
/* wait interrupted by a signal (EINTR): recompute the timeout */
361+
_PyTime_t dt = deadline - _PyTime_GetMonotonicClock();
362+
if (dt < 0) {
363+
status = ETIMEDOUT;
364+
break;
365+
}
366+
else if (dt > 0) {
367+
_PyTime_t realtime_deadline = _PyTime_GetSystemClock() + dt;
368+
if (_PyTime_AsTimespec(realtime_deadline, &ts) < 0) {
369+
/* Cannot occur thanks to (microseconds > PY_TIMEOUT_MAX)
370+
check done above */
371+
Py_UNREACHABLE();
372+
}
373+
/* no need to update microseconds value, the code only care
374+
if (microseconds > 0 or (microseconds == 0). */
375+
}
376+
else {
377+
microseconds = 0;
378+
}
379+
}
380+
}
338381

339382
/* Don't check the status if we're stopping because of an interrupt. */
340383
if (!(intr_flag && status == EINTR)) {

0 commit comments

Comments
 (0)