This is the mail archive of the
cygwin-patches
mailing list for the Cygwin project.
Re: [PATCH] clock_nanosleep(2)
On Wed, 2011-08-03 at 09:45 +0200, Corinna Vinschen wrote:
> On Aug 3 01:20, Yaakov (Cygwin/X) wrote:
> > On Tue, 2011-08-02 at 17:42 +0200, Corinna Vinschen wrote:
> > > Does that mean the return value from NtQueryTimer is unreliable?
> > > In what way is it wrong?
> >
> > I'm not sure. When I run an STC (attached), it works as expected. In
> > cancelable_wait(), however, it returns the negative system uptime. Is
> > Cygwin doing something to make this occur?
>
> That sounds weird. How should Cygwin influence what an independent OS
> function returns? And you sure it's the system uptime? Wow.
Never mind, I figured it out. The difference is the timeout to
WaitFor*Object*(); my STC doesn't allow the timer to finish, but
cancelable_wait() does with the INFINITE timeout. If there is time
remaining, as in the STC, then TIMER_BASIC_INFORMATION.TimeRemaining
contains just that (as a positive). If the timer has signalled, then
instead of zero, it appears to provide when it was signalled (system
uptime, as a negative).
With that figured out, here's a revised patch. Once this is in, then
adding clock_nanosleep() should be relatively easy.
Yaakov
2011-08-03 Yaakov Selkowitz <yselkowitz@...>
* cygtls.h (struct _local_storage): Add cw_timer member.
* cygtls.cc (_cygtls::init_thread): Initialize locals.cw_timer.
(_cygtls::fixup_after_fork): Ditto.
* tlsoffsets.h: Regenerate.
* ntdll.h (enum _TIMER_INFORMATION_CLASS): Define.
(struct _TIMER_BASIC_INFORMATION): Define.
(NtQueryTimer): Declare function.
* thread.h (cancelable_wait): Change timeout argument to
PLARGE_INTEGER and provide NULL default.
(fast_mutex::lock): Adjust accordingly.
(pthread_cond::wait): Change timeout argument to PLARGE_INTEGER
and default to NULL.
* thread.cc (cancelable_wait): Change timeout argument to
PLARGE_INTEGER. Initialize _cygtls.locals.cw_timer if needed.
Use NT waitable timers for handling timeout. Return remaining time
to timeout argument if timeout was relative.
(pthread_cond::wait): Change timeout argument to PLARGE_INTEGER.
Adjust to change in cancelable_wait.
(pthread_mutex::lock): Adjust to change in cancelable_wait.
(pthread_spinlock::lock): Ditto.
(pthread::join): Ditto.
(__pthread_cond_dowait): Change waitlength argument to PLARGE_INTEGER.
Adjust to changes in cancelable_wait and pthread_cond::wait.
(pthread_cond_timedwait): Adjust to change in __pthread_cond_dowait.
(pthread_cond_wait): Ditto.
(semaphore::_timedwait): Adjust to change in cancelable_wait.
(semaphore::_wait): Ditto.
* exceptions.cc (handle_sigsuspend): Ditto.
* signal.cc (nanosleep): Ditto.
* wait.cc (wait4): Ditto.
* times.cc (FACTOR, NSPERSEC): Move from here...
* hires.h (FACTOR, NSPERSEC): ...to here.
Index: cygtls.cc
===================================================================
RCS file: /cvs/src/src/winsup/cygwin/cygtls.cc,v
retrieving revision 1.76
diff -u -p -r1.76 cygtls.cc
--- cygtls.cc 21 Apr 2011 08:10:28 -0000 1.76
+++ cygtls.cc 29 Jul 2011 05:56:31 -0000
@@ -98,6 +98,7 @@ _cygtls::init_thread (void *x, DWORD (*f
thread_id = GetCurrentThreadId ();
initialized = CYGTLS_INITIALIZED;
errno_addr = &(local_clib._errno);
+ locals.cw_timer = NULL;
if ((void *) func == (void *) cygthread::stub
|| (void *) func == (void *) cygthread::simplestub)
@@ -127,6 +128,7 @@ _cygtls::fixup_after_fork ()
}
stacklock = spinning = 0;
locals.select.sockevt = NULL;
+ locals.cw_timer = NULL;
wq.thread_ev = NULL;
}
Index: cygtls.h
===================================================================
RCS file: /cvs/src/src/winsup/cygwin/cygtls.h,v
retrieving revision 1.72
diff -u -p -r1.72 cygtls.h
--- cygtls.h 28 May 2011 18:17:08 -0000 1.72
+++ cygtls.h 29 Jul 2011 05:56:31 -0000
@@ -131,6 +131,9 @@ struct _local_storage
int setmode_file;
int setmode_mode;
+ /* thread.cc */
+ HANDLE cw_timer;
+
/* All functions requiring temporary path buffers. */
tls_pathbuf pathbufs;
char ttybuf[32];
Index: exceptions.cc
===================================================================
RCS file: /cvs/src/src/winsup/cygwin/exceptions.cc,v
retrieving revision 1.359
diff -u -p -r1.359 exceptions.cc
--- exceptions.cc 13 Jul 2011 17:53:21 -0000 1.359
+++ exceptions.cc 29 Jul 2011 05:56:32 -0000
@@ -719,7 +719,7 @@ handle_sigsuspend (sigset_t tempmask)
sigproc_printf ("oldmask %p, newmask %p", oldmask, tempmask);
pthread_testcancel ();
- cancelable_wait (signal_arrived, INFINITE);
+ cancelable_wait (signal_arrived);
set_sig_errno (EINTR); // Per POSIX
Index: hires.h
===================================================================
RCS file: /cvs/src/src/winsup/cygwin/hires.h,v
retrieving revision 1.19
diff -u -p -r1.19 hires.h
--- hires.h 17 May 2011 17:08:09 -0000 1.19
+++ hires.h 29 Jul 2011 05:56:32 -0000
@@ -29,6 +29,11 @@ details. */
and rounding won't exceed HIRES_DELAY_MAX */
#define HIRES_DELAY_MAX ((((UINT_MAX - 10000) / 1000) * 1000) + 10)
+/* 100ns difference between Windows and UNIX timebase. */
+#define FACTOR (0x19db1ded53e8000LL)
+/* # of 100ns intervals per second. */
+#define NSPERSEC 10000000LL
+
class hires_base
{
protected:
Index: ntdll.h
===================================================================
RCS file: /cvs/src/src/winsup/cygwin/ntdll.h,v
retrieving revision 1.125
diff -u -p -r1.125 ntdll.h
--- ntdll.h 26 Jul 2011 09:54:11 -0000 1.125
+++ ntdll.h 29 Jul 2011 05:56:32 -0000
@@ -986,6 +986,15 @@ typedef struct _THREAD_BASIC_INFORMATION
KPRIORITY BasePriority;
} THREAD_BASIC_INFORMATION, *PTHREAD_BASIC_INFORMATION;
+typedef enum _TIMER_INFORMATION_CLASS {
+ TimerBasicInformation = 0
+} TIMER_INFORMATION_CLASS, *PTIMER_INFORMATION_CLASS;
+
+typedef struct _TIMER_BASIC_INFORMATION {
+ LARGE_INTEGER TimeRemaining;
+ BOOLEAN SignalState;
+} TIMER_BASIC_INFORMATION, *PTIMER_BASIC_INFORMATION;
+
#define RTL_QUERY_REGISTRY_SUBKEY 0x01
#define RTL_QUERY_REGISTRY_TOPKEY 0x02
#define RTL_QUERY_REGISTRY_REQUIRED 0x04
@@ -1155,6 +1164,8 @@ extern "C"
NTSTATUS NTAPI NtQuerySecurityObject (HANDLE, SECURITY_INFORMATION,
PSECURITY_DESCRIPTOR, ULONG, PULONG);
NTSTATUS NTAPI NtQuerySymbolicLinkObject (HANDLE, PUNICODE_STRING, PULONG);
+ NTSTATUS NTAPI NtQueryTimer (HANDLE, TIMER_INFORMATION_CLASS, PVOID,
+ ULONG, PULONG);
NTSTATUS NTAPI NtQueryTimerResolution (PULONG, PULONG, PULONG);
NTSTATUS NTAPI NtQueryValueKey (HANDLE, PUNICODE_STRING,
KEY_VALUE_INFORMATION_CLASS, PVOID, ULONG,
Index: signal.cc
===================================================================
RCS file: /cvs/src/src/winsup/cygwin/signal.cc,v
retrieving revision 1.98
diff -u -p -r1.98 signal.cc
--- signal.cc 10 Jul 2011 00:01:33 -0000 1.98
+++ signal.cc 29 Jul 2011 05:56:32 -0000
@@ -92,61 +92,31 @@ nanosleep (const struct timespec *rqtp,
set_errno (EINVAL);
return -1;
}
- unsigned int sec = rqtp->tv_sec;
- DWORD resolution = gtod.resolution ();
- bool done = false;
- DWORD req;
- DWORD rem;
-
- while (!done)
- {
- /* Divide user's input into transactions no larger than 49.7
- days at a time. */
- if (sec > HIRES_DELAY_MAX / 1000)
- {
- req = ((HIRES_DELAY_MAX + resolution - 1)
- / resolution * resolution);
- sec -= HIRES_DELAY_MAX / 1000;
- }
- else
- {
- req = ((sec * 1000 + (rqtp->tv_nsec + 999999) / 1000000
- + resolution - 1) / resolution) * resolution;
- sec = 0;
- done = true;
- }
+ LARGE_INTEGER timeout;
- DWORD end_time = gtod.dmsecs () + req;
- syscall_printf ("nanosleep (%ld)", req);
+ timeout.QuadPart = (LONGLONG) rqtp->tv_sec * NSPERSEC
+ + ((LONGLONG) rqtp->tv_nsec + 99LL) / 100LL;
+ timeout.QuadPart *= -1LL;
- int rc = cancelable_wait (signal_arrived, req);
- if ((rem = end_time - gtod.dmsecs ()) > HIRES_DELAY_MAX)
- rem = 0;
- if (rc == WAIT_OBJECT_0)
- {
- _my_tls.call_signal_handler ();
- set_errno (EINTR);
- res = -1;
- break;
- }
+ syscall_printf ("nanosleep (%ld.%09ld)", rqtp->tv_sec, rqtp->tv_nsec);
+
+ int rc = cancelable_wait (signal_arrived, &timeout);
+ if (rc == WAIT_OBJECT_0)
+ {
+ _my_tls.call_signal_handler ();
+ set_errno (EINTR);
+ res = -1;
}
if (rmtp)
{
- rmtp->tv_sec = sec + rem / 1000;
- rmtp->tv_nsec = (rem % 1000) * 1000000;
- if (sec)
- {
- rmtp->tv_nsec += rqtp->tv_nsec;
- if (rmtp->tv_nsec >= 1000000000)
- {
- rmtp->tv_nsec -= 1000000000;
- rmtp->tv_sec++;
- }
- }
+ rmtp->tv_sec = (time_t) (timeout.QuadPart / NSPERSEC);
+ rmtp->tv_nsec = (long) ((timeout.QuadPart % NSPERSEC) * 100LL);
}
- syscall_printf ("%d = nanosleep (%ld, %ld)", res, req, rem);
+ syscall_printf ("%d = nanosleep (%ld.%09ld, %ld.%09.ld)", res, rqtp->tv_sec,
+ rqtp->tv_nsec, rmtp ? rmtp->tv_sec : 0,
+ rmtp ? rmtp->tv_nsec : 0);
return res;
}
Index: thread.cc
===================================================================
RCS file: /cvs/src/src/winsup/cygwin/thread.cc,v
retrieving revision 1.244
diff -u -p -r1.244 thread.cc
--- thread.cc 21 Jul 2011 09:39:21 -0000 1.244
+++ thread.cc 29 Jul 2011 05:56:32 -0000
@@ -906,13 +906,13 @@ pthread::static_cancel_self ()
}
DWORD
-cancelable_wait (HANDLE object, DWORD timeout,
+cancelable_wait (HANDLE object, PLARGE_INTEGER timeout,
const cw_cancel_action cancel_action,
const enum cw_sig_wait sig_wait)
{
DWORD res;
DWORD num = 0;
- HANDLE wait_objects[3];
+ HANDLE wait_objects[4];
pthread_t thread = pthread::self ();
/* Do not change the wait order.
@@ -939,15 +939,30 @@ cancelable_wait (HANDLE object, DWORD ti
wait_objects[sig_n] = signal_arrived;
}
+ DWORD timeout_n;
+ if (!timeout)
+ timeout_n = WAIT_TIMEOUT + 1;
+ else
+ {
+ timeout_n = WAIT_OBJECT_0 + num++;
+ if (!_my_tls.locals.cw_timer)
+ NtCreateTimer (&_my_tls.locals.cw_timer, TIMER_ALL_ACCESS, NULL,
+ NotificationTimer);
+ NtSetTimer (_my_tls.locals.cw_timer, timeout, NULL, NULL, FALSE, 0, NULL);
+ wait_objects[timeout_n] = _my_tls.locals.cw_timer;
+ }
+
while (1)
{
- res = WaitForMultipleObjects (num, wait_objects, FALSE, timeout);
+ res = WaitForMultipleObjects (num, wait_objects, FALSE, INFINITE);
if (res == cancel_n)
{
if (cancel_action == cw_cancel_self)
pthread::static_cancel_self ();
res = WAIT_CANCELED;
}
+ else if (res == timeout_n)
+ res = WAIT_TIMEOUT;
else if (res != sig_n)
/* all set */;
else if (sig_wait == cw_sig_eintr)
@@ -959,6 +974,21 @@ cancelable_wait (HANDLE object, DWORD ti
}
break;
}
+
+ if (timeout)
+ {
+ const size_t sizeof_tbi = sizeof (TIMER_BASIC_INFORMATION);
+ PTIMER_BASIC_INFORMATION tbi = (PTIMER_BASIC_INFORMATION) malloc (sizeof_tbi);
+
+ NtQueryTimer (_my_tls.locals.cw_timer, TimerBasicInformation, tbi,
+ sizeof_tbi, NULL);
+ /* if timer expired, TimeRemaining is negative and represents the
+ system uptime when signalled */
+ if (timeout->QuadPart < 0LL)
+ timeout->QuadPart = tbi->SignalState ? 0LL : tbi->TimeRemaining.QuadPart;
+ NtCancelTimer (_my_tls.locals.cw_timer, NULL);
+ }
+
return res;
}
@@ -1228,7 +1257,7 @@ pthread_cond::unblock (const bool all)
}
int
-pthread_cond::wait (pthread_mutex_t mutex, DWORD dwMilliseconds)
+pthread_cond::wait (pthread_mutex_t mutex, PLARGE_INTEGER timeout)
{
DWORD rv;
@@ -1249,7 +1278,7 @@ pthread_cond::wait (pthread_mutex_t mute
++mutex->condwaits;
mutex->unlock ();
- rv = cancelable_wait (sem_wait, dwMilliseconds, cw_no_cancel_self, cw_sig_eintr);
+ rv = cancelable_wait (sem_wait, timeout, cw_no_cancel_self, cw_sig_eintr);
mtx_out.lock ();
@@ -1764,7 +1793,7 @@ pthread_mutex::lock ()
else if (type == PTHREAD_MUTEX_NORMAL /* potentially causes deadlock */
|| !pthread::equal (owner, self))
{
- cancelable_wait (win32_obj_id, INFINITE, cw_no_cancel, cw_sig_resume);
+ cancelable_wait (win32_obj_id, NULL, cw_no_cancel, cw_sig_resume);
set_owner (self);
}
else
@@ -1899,8 +1928,13 @@ pthread_spinlock::lock ()
}
else if (pthread::equal (owner, self))
result = EDEADLK;
- else /* Minimal timeout to minimize CPU usage while still spinning. */
- cancelable_wait (win32_obj_id, 1L, cw_no_cancel, cw_sig_resume);
+ else
+ {
+ /* Minimal timeout to minimize CPU usage while still spinning. */
+ LARGE_INTEGER timeout;
+ timeout.QuadPart = -10000LL;
+ cancelable_wait (win32_obj_id, &timeout, cw_no_cancel, cw_sig_resume);
+ }
}
while (result == -1);
pthread_printf ("spinlock %p, self %p, owner %p", this, self, owner);
@@ -2377,7 +2411,7 @@ pthread::join (pthread_t *thread, void *
(*thread)->attr.joinable = PTHREAD_CREATE_DETACHED;
(*thread)->mutex.unlock ();
- switch (cancelable_wait ((*thread)->win32_obj_id, INFINITE, cw_no_cancel_self, cw_sig_resume))
+ switch (cancelable_wait ((*thread)->win32_obj_id, NULL, cw_no_cancel_self, cw_sig_resume))
{
case WAIT_OBJECT_0:
if (return_val)
@@ -2702,7 +2736,7 @@ pthread_cond_signal (pthread_cond_t *con
static int
__pthread_cond_dowait (pthread_cond_t *cond, pthread_mutex_t *mutex,
- DWORD waitlength)
+ PLARGE_INTEGER waitlength)
{
if (!pthread_mutex::is_good_object (mutex))
return EINVAL;
@@ -2722,7 +2756,7 @@ pthread_cond_timedwait (pthread_cond_t *
const struct timespec *abstime)
{
struct timespec tp;
- DWORD waitlength;
+ LARGE_INTEGER timeout;
myfault efault;
if (efault.faulted ())
@@ -2738,17 +2772,27 @@ pthread_cond_timedwait (pthread_cond_t *
clock_gettime ((*cond)->clock_id, &tp);
- /* Check for immediate timeout before converting to microseconds, since
- the resulting value can easily overflow long. This also allows to
- evaluate microseconds directly in DWORD. */
+ /* Check for immediate timeout before converting */
if (tp.tv_sec > abstime->tv_sec
|| (tp.tv_sec == abstime->tv_sec
&& tp.tv_nsec > abstime->tv_nsec))
return ETIMEDOUT;
- waitlength = (abstime->tv_sec - tp.tv_sec) * 1000;
- waitlength += (abstime->tv_nsec - tp.tv_nsec) / 1000000;
- return __pthread_cond_dowait (cond, mutex, waitlength);
+ timeout.QuadPart = abstime->tv_sec * NSPERSEC
+ + (abstime->tv_nsec + 99LL) / 100LL;
+
+ switch ((*cond)->clock_id)
+ {
+ case CLOCK_REALTIME:
+ timeout.QuadPart += FACTOR;
+ break;
+ default:
+ /* other clocks must be handled as relative timeout */
+ timeout.QuadPart -= tp.tv_sec * NSPERSEC + tp.tv_nsec / 100LL;
+ timeout.QuadPart *= -1LL;
+ break;
+ }
+ return __pthread_cond_dowait (cond, mutex, &timeout);
}
extern "C" int
@@ -2756,7 +2799,7 @@ pthread_cond_wait (pthread_cond_t *cond,
{
pthread_testcancel ();
- return __pthread_cond_dowait (cond, mutex, INFINITE);
+ return __pthread_cond_dowait (cond, mutex, NULL);
}
extern "C" int
@@ -3439,8 +3482,7 @@ semaphore::_trywait ()
int
semaphore::_timedwait (const struct timespec *abstime)
{
- struct timeval tv;
- long waitlength;
+ LARGE_INTEGER timeout;
myfault efault;
if (efault.faulted ())
@@ -3453,12 +3495,10 @@ semaphore::_timedwait (const struct time
return -1;
}
- gettimeofday (&tv, NULL);
- waitlength = abstime->tv_sec * 1000 + abstime->tv_nsec / (1000 * 1000);
- waitlength -= tv.tv_sec * 1000 + tv.tv_usec / 1000;
- if (waitlength < 0)
- waitlength = 0;
- switch (cancelable_wait (win32_obj_id, waitlength, cw_cancel_self, cw_sig_eintr))
+ timeout.QuadPart = abstime->tv_sec * NSPERSEC
+ + (abstime->tv_nsec + 99) / 100 + FACTOR;
+
+ switch (cancelable_wait (win32_obj_id, &timeout, cw_cancel_self, cw_sig_eintr))
{
case WAIT_OBJECT_0:
currentvalue--;
@@ -3480,7 +3520,7 @@ semaphore::_timedwait (const struct time
int
semaphore::_wait ()
{
- switch (cancelable_wait (win32_obj_id, INFINITE, cw_cancel_self, cw_sig_eintr))
+ switch (cancelable_wait (win32_obj_id, NULL, cw_cancel_self, cw_sig_eintr))
{
case WAIT_OBJECT_0:
currentvalue--;
Index: thread.h
===================================================================
RCS file: /cvs/src/src/winsup/cygwin/thread.h,v
retrieving revision 1.122
diff -u -p -r1.122 thread.h
--- thread.h 21 Jul 2011 09:39:22 -0000 1.122
+++ thread.h 29 Jul 2011 05:56:32 -0000
@@ -37,7 +37,8 @@ enum cw_cancel_action
cw_no_cancel
};
-DWORD cancelable_wait (HANDLE, DWORD, const cw_cancel_action = cw_cancel_self,
+DWORD cancelable_wait (HANDLE, PLARGE_INTEGER timeout = NULL,
+ const cw_cancel_action = cw_cancel_self,
const enum cw_sig_wait = cw_sig_nosig)
__attribute__ ((regparm (3)));
@@ -70,7 +71,7 @@ public:
void lock ()
{
if (InterlockedIncrement ((long *) &lock_counter) != 1)
- cancelable_wait (win32_obj_id, INFINITE, cw_no_cancel, cw_sig_resume);
+ cancelable_wait (win32_obj_id, NULL, cw_no_cancel, cw_sig_resume);
}
void unlock ()
@@ -517,7 +518,7 @@ public:
pthread_mutex_t mtx_cond;
void unblock (const bool all);
- int wait (pthread_mutex_t mutex, DWORD dwMilliseconds = INFINITE);
+ int wait (pthread_mutex_t mutex, PLARGE_INTEGER timeout = NULL);
pthread_cond (pthread_condattr *);
~pthread_cond ();
Index: times.cc
===================================================================
RCS file: /cvs/src/src/winsup/cygwin/times.cc,v
retrieving revision 1.110
diff -u -p -r1.110 times.cc
--- times.cc 6 Jun 2011 05:02:13 -0000 1.110
+++ times.cc 29 Jul 2011 05:56:32 -0000
@@ -27,10 +27,6 @@ details. */
#include "cygtls.h"
#include "ntdll.h"
-/* 100ns difference between WIndows and UNIX timebase. */
-#define FACTOR (0x19db1ded53e8000LL)
-/* # of 100ns intervals per second. */
-#define NSPERSEC 10000000LL
/* Max allowed diversion in 100ns of internal timer from system time. If
this difference is exceeded, the internal timer gets re-primed. */
#define JITTER (40 * 10000LL)
@@ -737,7 +733,7 @@ hires_ms::resolution ()
status = NtQueryTimerResolution (&coarsest, &finest, &actual);
if (NT_SUCCESS (status))
- minperiod = (DWORD) actual / 10000L;
+ minperiod = (DWORD) actual;
else
{
/* Try to empirically determine current timer resolution */
@@ -757,13 +753,9 @@ hires_ms::resolution ()
period += now - then;
}
SetThreadPriority (GetCurrentThread (), priority);
- period /= 40000L;
+ period /= 4L;
minperiod = (DWORD) period;
}
- /* The resolution can be as low as 5000 100ns intervals on recent OSes.
- We have to make sure that the resolution in ms is never 0. */
- if (!minperiod)
- minperiod = 1L;
}
return minperiod;
}
@@ -786,8 +778,8 @@ clock_getres (clockid_t clk_id, struct t
case CLOCK_REALTIME:
{
DWORD period = gtod.resolution ();
- tp->tv_sec = period / 1000;
- tp->tv_nsec = (period % 1000) * 1000000;
+ tp->tv_sec = period / NSPERSEC;
+ tp->tv_nsec = (period % NSPERSEC) * 100;
break;
}
@@ -838,7 +830,7 @@ clock_setres (clockid_t clk_id, struct t
}
if (period_set
- && NT_SUCCESS (NtSetTimerResolution (minperiod * 10000L, FALSE, &actual)))
+ && NT_SUCCESS (NtSetTimerResolution (minperiod, FALSE, &actual)))
period_set = false;
status = NtSetTimerResolution (period, TRUE, &actual);
@@ -847,11 +839,7 @@ clock_setres (clockid_t clk_id, struct t
__seterrno_from_nt_status (status);
return -1;
}
- minperiod = actual / 10000L;
- /* The resolution can be as low as 5000 100ns intervals on recent OSes.
- We have to make sure that the resolution in ms is never 0. */
- if (!minperiod)
- minperiod = 1L;
+ minperiod = actual;
period_set = true;
return 0;
}
Index: tlsoffsets.h
===================================================================
RCS file: /cvs/src/src/winsup/cygwin/tlsoffsets.h,v
retrieving revision 1.47
diff -u -p -r1.47 tlsoffsets.h
--- tlsoffsets.h 28 May 2011 18:17:09 -0000 1.47
+++ tlsoffsets.h 29 Jul 2011 05:56:32 -0000
@@ -1,6 +1,6 @@
//;# autogenerated: Do not edit.
-//; $tls::sizeof__cygtls = 4044;
+//; $tls::sizeof__cygtls = 4048;
//; $tls::func = -12700;
//; $tls::pfunc = 0;
//; $tls::saved_errno = -12696;
@@ -37,26 +37,26 @@
//; $tls::p__dontuse = 412;
//; $tls::locals = -11200;
//; $tls::plocals = 1500;
-//; $tls::_ctinfo = -9740;
-//; $tls::p_ctinfo = 2960;
-//; $tls::andreas = -9736;
-//; $tls::pandreas = 2964;
-//; $tls::wq = -9732;
-//; $tls::pwq = 2968;
-//; $tls::sig = -9704;
-//; $tls::psig = 2996;
-//; $tls::incyg = -9700;
-//; $tls::pincyg = 3000;
-//; $tls::spinning = -9696;
-//; $tls::pspinning = 3004;
-//; $tls::stacklock = -9692;
-//; $tls::pstacklock = 3008;
-//; $tls::stackptr = -9688;
-//; $tls::pstackptr = 3012;
-//; $tls::stack = -9684;
-//; $tls::pstack = 3016;
-//; $tls::initialized = -8660;
-//; $tls::pinitialized = 4040;
+//; $tls::_ctinfo = -9736;
+//; $tls::p_ctinfo = 2964;
+//; $tls::andreas = -9732;
+//; $tls::pandreas = 2968;
+//; $tls::wq = -9728;
+//; $tls::pwq = 2972;
+//; $tls::sig = -9700;
+//; $tls::psig = 3000;
+//; $tls::incyg = -9696;
+//; $tls::pincyg = 3004;
+//; $tls::spinning = -9692;
+//; $tls::pspinning = 3008;
+//; $tls::stacklock = -9688;
+//; $tls::pstacklock = 3012;
+//; $tls::stackptr = -9684;
+//; $tls::pstackptr = 3016;
+//; $tls::stack = -9680;
+//; $tls::pstack = 3020;
+//; $tls::initialized = -8656;
+//; $tls::pinitialized = 4044;
//; __DATA__
#define tls_func (-12700)
@@ -95,23 +95,23 @@
#define tls_p__dontuse (412)
#define tls_locals (-11200)
#define tls_plocals (1500)
-#define tls__ctinfo (-9740)
-#define tls_p_ctinfo (2960)
-#define tls_andreas (-9736)
-#define tls_pandreas (2964)
-#define tls_wq (-9732)
-#define tls_pwq (2968)
-#define tls_sig (-9704)
-#define tls_psig (2996)
-#define tls_incyg (-9700)
-#define tls_pincyg (3000)
-#define tls_spinning (-9696)
-#define tls_pspinning (3004)
-#define tls_stacklock (-9692)
-#define tls_pstacklock (3008)
-#define tls_stackptr (-9688)
-#define tls_pstackptr (3012)
-#define tls_stack (-9684)
-#define tls_pstack (3016)
-#define tls_initialized (-8660)
-#define tls_pinitialized (4040)
+#define tls__ctinfo (-9736)
+#define tls_p_ctinfo (2964)
+#define tls_andreas (-9732)
+#define tls_pandreas (2968)
+#define tls_wq (-9728)
+#define tls_pwq (2972)
+#define tls_sig (-9700)
+#define tls_psig (3000)
+#define tls_incyg (-9696)
+#define tls_pincyg (3004)
+#define tls_spinning (-9692)
+#define tls_pspinning (3008)
+#define tls_stacklock (-9688)
+#define tls_pstacklock (3012)
+#define tls_stackptr (-9684)
+#define tls_pstackptr (3016)
+#define tls_stack (-9680)
+#define tls_pstack (3020)
+#define tls_initialized (-8656)
+#define tls_pinitialized (4044)
Index: wait.cc
===================================================================
RCS file: /cvs/src/src/winsup/cygwin/wait.cc,v
retrieving revision 1.37
diff -u -p -r1.37 wait.cc
--- wait.cc 18 Jul 2009 20:25:07 -0000 1.37
+++ wait.cc 29 Jul 2011 05:56:32 -0000
@@ -78,7 +78,7 @@ wait4 (int intpid, int *status, int opti
if ((waitfor = w->ev) == NULL)
goto nochildren;
- res = cancelable_wait (waitfor, INFINITE);
+ res = cancelable_wait (waitfor);
sigproc_printf ("%d = WaitForSingleObject (...)", res);