From 962f9a2ccc6cd7f24a2d89d68bd8b59d43f8ac8a Mon Sep 17 00:00:00 2001 From: Christopher Faylor Date: Sat, 21 Jul 2012 22:58:20 +0000 Subject: * DevNotes: Add entry cgf-000013. * cygserver_ipc.h (ipc_set_proc_info): Use _cygtls::ipc_set_proc_info to set per-thread signal arrived value. * cygthread.cc (cygthread::detach): Use per-thread signal_arrived via set_thread_waiting. * fork.cc (_cygtls::fixup_after_fork): Clear signal_arrived. (_cygtls::remove): Close any signal_arrived handle when thread exists. (_cygtls::find_tls): Remove unneeded function. * cygtls.h: Update copyright. (class _cygtls): Reorganize to help avoid rebuilding newlib when structure changes. (_cygtls::event): Delete. (_cygtls::threadkill): Ditto. (_cygtls::signal_waiting): Declare new bool. (_cygtls::find_tls): Delete declaration. (_cygtls::set_threadkill): Ditto. (_cygtls::reset_threadkill): Ditto. (_cygtls::set_signal_arrived): Declare new function. (class set_thread_waiting): Declare new class. * cygwait.cc (cw_nowait_storage): Define. (cygwait): Set per-thread signal_arrived via set_thread_waiting. Don't special-case _main_tls. * cygwait.h (cw_nowait): Define. (cw_infinite): Ditto. (cygwait): Redefine pathological wait-only case. * dcrt0.cc (dll_crt0_0): Remove call to now-defunct events_init(). (dll_crt0_1): Remove call to now-defunct create_signal_arrived(). * exceptions.cc: Reflect set_signal_mask() argument reordering throughout. Remove signal mask synchronization throughout. (events_init): Delete definition. (mask_sync): Delete now-unneeded mask synchronization. (set_signal_mask): Reverse order of arguments to "standard" to, from layout. Rename "newmask" argument to "setmask". Remove debugging. (sig_handle_tty_stop): Use cancelable_wait rather than WFMO. (_cygtls::interrupt_setup): Don't treat "threadkill" events specially. Conditionally set signal_arrived depending on whether the thread has created it or not. (sigpacket::process): Reorganize to reflect thread-specific sending of signals which is more in line with the way it was actually supposed to work. * fhandler_socket.cc (get_inet_addr): Use cancelable_wait rather than IsEventSignalled to avoid potential race. (fhandler_socket::wait_for_events): Set signal_arrived event using set_thread_waiting(). (fhandler_socket::close): Use cygwait for the case of just waiting 10 ms for a signal. * fhandler_tape.cc (fhandler_dev_tape::_lock): Use cancelable_wait rather than WFMO. Redo switch/case tests accordingly. * fhandler_termios.cc (fhandler_termios::bg_check): Use cygwait for case of just waiting 0 ms for a potential signal. * fhandler_tty.cc (fhandler_pty_master::process_slave_output): Use cancelable_wait rather than WFSO. * fhandler_windows.cc (fhandler_windows::read): Set per-thread signal_arrived via set_thread_waiting(). * flock.cc (lf_setlock): Ditto. * select.cc (pselect): Ditto. Set per-thread signal_arrived using set_thread_waiting(). * gendef: Don't special case handling of _cygtls::sig for threads. * gentls_offsets: Use #pragma once in tlsoffsets.h. * ntdll.h: Use #pragma once. * poll.cc: Reflect set_signal_mask() argument reordering. * posix_ipc.cc (ipc_mutex_lock): Use cancelable_wait rather than WFMO. (ipc_cond_timedwait): Set perl-thread signal arrived using set_thread_waiting(). * security.h: Use #pragma once. * signal.cc (abort): Reflect set_signal_mask() argument reordering. (clock_nanosleep): Ditto. Change call to cancelable_wait to properly specify handling of cancel and interrupt. (sigwaitinfo): Remove handling of per-thread event in favor of per-thread signal_arrived. Use cancelable_wait rather than WFSO. * sigproc.cc (signal_arrived): Delete definition. (create_signal_arrived): Ditto. * sigproc.h (signal_arrived): Delete declaration. (set_signal_mask): Avoid defining as a "C" function. Don't conditionally declare. (create_signal_arrived): Delete declaration. * syscalls.cc (rename): Use cygwait() rather than WFSO. * thread.h (fast_mutex::lock): Use cw_infinite rather than LARGE_NULL. * wait.cc (wait4): Ditto. * thread.cc (pthread_mutex::lock): Ditto. (pthread::join): Ditto. (semaphore::_wait): Ditto. (pthread_kill): Remove set_threadkill() accommodation. * tlsoffsets.h: Regenerate. --- winsup/cygwin/exceptions.cc | 162 ++++++++++++-------------------------------- 1 file changed, 43 insertions(+), 119 deletions(-) (limited to 'winsup/cygwin/exceptions.cc') diff --git a/winsup/cygwin/exceptions.cc b/winsup/cygwin/exceptions.cc index 5ace52b5b..91517fd58 100644 --- a/winsup/cygwin/exceptions.cc +++ b/winsup/cygwin/exceptions.cc @@ -19,8 +19,8 @@ details. */ #include #include -#include "pinfo.h" #include "cygtls.h" +#include "pinfo.h" #include "sigproc.h" #include "shared_info.h" #include "perprocess.h" @@ -31,7 +31,6 @@ details. */ #include "child_info.h" #include "ntdll.h" #include "exception.h" -#include "cygwait.h" #define CALL_HANDLER_RETRY_OUTER 10 #define CALL_HANDLER_RETRY_INNER 10 @@ -47,7 +46,6 @@ static BOOL WINAPI ctrl_c_handler (DWORD); /* This is set to indicate that we have already exited. */ static NO_COPY int exit_already = 0; -static muto NO_COPY mask_sync; NO_COPY static struct { @@ -710,11 +708,11 @@ handle_sigsuspend (sigset_t tempmask) { sigset_t oldmask = _my_tls.sigmask; // Remember for restoration - set_signal_mask (tempmask, _my_tls.sigmask); + set_signal_mask (_my_tls.sigmask, tempmask); sigproc_printf ("oldmask %p, newmask %p", oldmask, tempmask); pthread_testcancel (); - cancelable_wait (signal_arrived, LARGE_NULL, cw_cancel | cw_cancel_self); + cancelable_wait (NULL, cw_infinite, cw_cancel | cw_cancel_self | cw_sig_eintr); set_sig_errno (EINTR); // Per POSIX @@ -747,8 +745,7 @@ sig_handle_tty_stop (int sig) sigproc_printf ("process %d stopped by signal %d", myself->pid, sig); HANDLE w4[2]; w4[0] = sigCONT; - w4[1] = signal_arrived; - switch (WaitForMultipleObjects (2, w4, TRUE, INFINITE)) + switch (cancelable_wait (sigCONT, cw_infinite, cw_sig_eintr)) { case WAIT_OBJECT_0: case WAIT_OBJECT_0 + 1: @@ -804,20 +801,11 @@ _cygtls::interrupt_setup (int sig, void *handler, struct sigaction& siga) this->sig = sig; // Should always be last thing set to avoid a race - if (!event) - threadkill = false; - else - { - HANDLE h = event; - event = NULL; - SetEvent (h); - } + if (signal_arrived) + SetEvent (signal_arrived); - /* Clear any waiting threads prior to dispatching to handler function */ - int res = SetEvent (signal_arrived); // For an EINTR case proc_subproc (PROC_CLEARWAIT, 1); - sigproc_printf ("armed signal_arrived %p, signal %d, res %d", signal_arrived, - sig, res); + sigproc_printf ("armed signal_arrived %p, signal %d", signal_arrived, sig); } extern "C" void __stdcall @@ -1021,7 +1009,7 @@ ctrl_c_handler (DWORD type) extern "C" void __stdcall set_process_mask (sigset_t newmask) { - set_signal_mask (newmask, _my_tls.sigmask); + set_signal_mask (_my_tls.sigmask, newmask); } extern "C" int @@ -1034,11 +1022,9 @@ sighold (int sig) syscall_printf ("signal %d out of range", sig); return -1; } - mask_sync.acquire (INFINITE); sigset_t mask = _my_tls.sigmask; sigaddset (&mask, sig); - set_signal_mask (mask, _my_tls.sigmask); - mask_sync.release (); + set_signal_mask (_my_tls.sigmask, mask); return 0; } @@ -1052,11 +1038,9 @@ sigrelse (int sig) syscall_printf ("signal %d out of range", sig); return -1; } - mask_sync.acquire (INFINITE); sigset_t mask = _my_tls.sigmask; sigdelset (&mask, sig); - set_signal_mask (mask, _my_tls.sigmask); - mask_sync.release (); + set_signal_mask (_my_tls.sigmask, mask); return 0; } @@ -1074,7 +1058,6 @@ sigset (int sig, _sig_func_ptr func) return (_sig_func_ptr) SIG_ERR; } - mask_sync.acquire (INFINITE); sigset_t mask = _my_tls.sigmask; /* If sig was in the signal mask return SIG_HOLD, otherwise return the previous disposition. */ @@ -1093,8 +1076,7 @@ sigset (int sig, _sig_func_ptr func) signal (sig, func); sigdelset (&mask, sig); } - set_signal_mask (mask, _my_tls.sigmask); - mask_sync.release (); + set_signal_mask (_my_tls.sigmask, mask); return prev; } @@ -1109,7 +1091,6 @@ sigignore (int sig) extern "C" sigset_t set_process_mask_delta () { - mask_sync.acquire (INFINITE); sigset_t newmask, oldmask; if (_my_tls.deltamask & SIG_NONMASKABLE) @@ -1120,28 +1101,22 @@ set_process_mask_delta () sigproc_printf ("oldmask %p, newmask %p, deltamask %p", oldmask, newmask, _my_tls.deltamask); _my_tls.sigmask = newmask; - mask_sync.release (); return oldmask; } /* Set the signal mask for this process. Note that some signals are unmaskable, as in UNIX. */ -extern "C" void __stdcall -set_signal_mask (sigset_t newmask, sigset_t& oldmask) + +void +set_signal_mask (sigset_t& setmask, sigset_t newmask) { -#ifdef CGF - if (&_my_tls == _sig_tls) - small_printf ("********* waiting in signal thread\n"); -#endif - mask_sync.acquire (INFINITE); newmask &= ~SIG_NONMASKABLE; - sigset_t mask_bits = oldmask & ~newmask; - sigproc_printf ("oldmask %p, newmask %p, mask_bits %p", oldmask, newmask, + sigset_t mask_bits = setmask & ~newmask; + sigproc_printf ("setmask %p, newmask %p, mask_bits %p", setmask, newmask, mask_bits); - oldmask = newmask; + setmask = newmask; if (mask_bits) sig_dispatch_pending (true); - mask_sync.release (); } int __stdcall @@ -1184,17 +1159,23 @@ sigpacket::process () myself->rusage_self.ru_nsignals++; - bool masked; - void *handler; - if (!have_execed || (void *) thissig.sa_handler == (void *) SIG_IGN) - handler = (void *) thissig.sa_handler; - else if (tls) - return 1; - else + void *handler = (void *) thissig.sa_handler; + if (handler == SIG_IGN) + { + sigproc_printf ("signal %d ignored", si.si_signo); + goto done; + } + + if (have_execed) handler = NULL; - _cygtls *use_tls = tls ?: _main_tls; - sigproc_printf ("tls %p, use_tls %p", tls, use_tls); + if (tls) + sigproc_printf ("using tls %p", tls); + else + { + tls = _main_tls; + sigproc_printf ("using main tls %p", _main_tls); + } if (si.si_signo == SIGKILL) goto exit_sig; @@ -1204,30 +1185,12 @@ sigpacket::process () goto stop; } - bool insigwait_mask; - if ((masked = ISSTATE (myself, PID_STOPPED))) - insigwait_mask = false; - else if (tls) - insigwait_mask = sigismember (&tls->sigwait_mask, si.si_signo); - else if (!(tls = _cygtls::find_tls (si.si_signo))) - insigwait_mask = false; - else + if (sigismember (&tls->sigwait_mask, si.si_signo)) { - use_tls = tls; - insigwait_mask = true; + tls->sigwait_mask = 0; + goto dosig; } - - if (insigwait_mask) - goto thread_specific; - - if (masked) - /* nothing to do */; - else if (sigismember (mask, si.si_signo)) - masked = true; - else if (tls) - masked = sigismember (&tls->sigmask, si.si_signo); - - if (masked) + if (sigismember (&tls->sigmask, si.si_signo) || ISSTATE (myself, PID_STOPPED)) { sigproc_printf ("signal %d blocked", si.si_signo); rc = -1; @@ -1240,14 +1203,12 @@ sigpacket::process () if (handler == (void *) SIG_DFL) { - if (insigwait_mask) - goto thread_specific; if (si.si_signo == SIGCHLD || si.si_signo == SIGIO || si.si_signo == SIGCONT || si.si_signo == SIGWINCH || si.si_signo == SIGURG) { sigproc_printf ("default signal %d ignored", si.si_signo); if (continue_now) - SetEvent (signal_arrived); + SetEvent (tls->signal_arrived); goto done; } @@ -1257,16 +1218,9 @@ sigpacket::process () goto exit_sig; } - if (handler == (void *) SIG_IGN) - { - sigproc_printf ("signal %d ignored", si.si_signo); - goto done; - } - if (handler == (void *) SIG_ERR) goto exit_sig; - use_tls->set_siginfo (this); goto dosig; stop: @@ -1277,33 +1231,19 @@ stop: thissig = dummy; dosig: + tls->set_siginfo (this); /* Dispatch to the appropriate function. */ - sigproc_printf ("signal %d, about to call %p", si.si_signo, handler); - rc = setup_handler (si.si_signo, handler, thissig, use_tls); + sigproc_printf ("signal %d, signal handler %p", si.si_signo, handler); + rc = setup_handler (si.si_signo, handler, thissig, tls); done: - tls = use_tls; if (continue_now) SetEvent (sigCONT); sigproc_printf ("returning %d", rc); return rc; -thread_specific: - use_tls->sig = si.si_signo; - use_tls->set_siginfo (this); - use_tls->func = NULL; - sigproc_printf ("releasing sigwait for thread"); - SetEvent (use_tls->event); - goto done; - exit_sig: - use_tls->signal_exit (si.si_signo); /* never returns */ -} - -void -events_init () -{ - mask_sync.init ("mask_sync"); + tls->signal_exit (si.si_signo); /* never returns */ } void @@ -1321,23 +1261,7 @@ _cygtls::call_signal_handler () lock (); if (sig) pop (); - else if (this != _main_tls) - { - _main_tls->lock (); - if (_main_tls->sig && _main_tls->incyg) - { - paranoid_printf ("Redirecting to main_tls signal %d", _main_tls->sig); - sig = _main_tls->sig; - sa_flags = _main_tls->sa_flags; - func = _main_tls->func; - infodata = _main_tls->infodata; - _main_tls->pop (); - _main_tls->sig = 0; - - } - _main_tls->unlock (); - } - if (!sig) + else break; debug_only_printf ("dealing with signal %d", sig); @@ -1364,7 +1288,7 @@ _cygtls::call_signal_handler () sigact (thissig, &thissi, NULL); } incyg = true; - set_signal_mask (this_oldmask, _my_tls.sigmask); + set_signal_mask (_my_tls.sigmask, this_oldmask); if (this_errno >= 0) set_errno (this_errno); } -- cgit v1.2.3