From e431827c7cab81292e8cd4ec9d3a4a60b35a42f2 Mon Sep 17 00:00:00 2001 From: Christopher Faylor Date: Thu, 12 Feb 2004 03:01:58 +0000 Subject: Rename _threadinfo to _cygtls, throughout. * cygtls.h (_cygtls::call_signal_handler): Rename from call_signal_handler_now. (_cygtls::push): Make second argument mandatory. (_cygtls::fixup_after_fork): Declare new function. (_cygtls::lock): Ditto. * cygtls.cc (_cygtls::fixup_after_fork): Define new function. * dcrt0.cc (cygwin_finished_initializing): Define as bool. (alloc_stack): Use _tlstop rather than arbitrary variable in probably vain attempt to avoid strange fork problem on CTRL-C. (dll_crt0_0): Remove obsolete winpids::init call. * dll_init.cc (dll_dllcrt0): Detect forkee condition as equivalent to initializing. * winsup.h (cygwin_finished_initializing): Declare as bool. * exceptions.cc (handle_exceptions): Rely on cygwin_finished_initializing to determine how to handle exception during process startup. (_cygtls::call_signal_handler): Rename from call_signal_handler_now. (_cygtls::interrupt_now): Fill in second argument to push. (signal_fixup_after_fork): Eliminate. (setup_handler): Initialize locked to avoid potential inappropriate unlock. Resume thread if it has acquired the stack lock. (ctrl_c_handler): Just exit if ctrl-c is hit before cygiwn has finished initializing. * fork.cc (sync_with_child): Don't call abort since it can cause exit deadlocks. (sync_with_child): Change debugging output slightly. (fork_child): Set cygwin_finished_initializing here. Call _cygtls fork fixup and explicitly call sigproc_init. (fork_parent): Release malloc lock on fork failure. (vfork): Call signal handler via _my_tls. * sigproc.cc (sig_send): Ditto. * syscalls.cc (readv): Ditto. * termios.cc (tcsetattr): Ditto. * wait.cc (wait4): Ditto. * signal.cc (nanosleep): Ditto. (abort): Ditto. (kill_pgrp): Avoid killing self if exiting. * sync.cc (muto::acquire): Remove (temporarily?) ill-advised exiting_thread check. * gendef (_sigfe): Be more agressive in protecting stack pointer from other access by signal thread. (_cygtls::locked): Define new function. (_sigbe): Ditto. (_cygtls::pop): Protect edx. (_cygtls::lock): Use guaranteed method to set eax to 1. (longjmp): Aggressively protect signal stack. * miscfuncs.cc (low_priority_sleep): Reduce "sleep time" for secs == 0. * pinfo.cc (winpids::set): Counterintuitively use malloc's lock to protect simultaneous access to the pids list since there are pathological conditions which can cause malloc to call winpid. (winpids::init): Eliminate. * pinfo.h (winpids::cs): Eliminate declaration. * pinfo.h (winpids::init): Eliminate definition. --- winsup/cygwin/cygtls.cc | 48 ++++++++++++++++++++++++++++++++---------------- 1 file changed, 32 insertions(+), 16 deletions(-) (limited to 'winsup/cygwin/cygtls.cc') diff --git a/winsup/cygwin/cygtls.cc b/winsup/cygwin/cygtls.cc index d3ed824c8..89e21d473 100644 --- a/winsup/cygwin/cygtls.cc +++ b/winsup/cygwin/cygtls.cc @@ -20,6 +20,7 @@ details. */ #include "dtable.h" #include "cygheap.h" #include "cygthread.h" +#include "pinfo.h" #include "sigproc.h" class sentry @@ -32,7 +33,7 @@ public: sentry () {destroy = 0;} sentry (DWORD wait) {destroy = lock->acquire (wait);} ~sentry () {if (destroy) lock->release ();} - friend void _threadinfo::init (); + friend void _cygtls::init (); }; muto NO_COPY *sentry::lock; @@ -42,27 +43,27 @@ static size_t NO_COPY nthreads; #define THREADLIST_CHUNK 256 void -_threadinfo::init () +_cygtls::init () { if (cygheap->threadlist) memset (cygheap->threadlist, 0, cygheap->sthreads * sizeof (cygheap->threadlist[0])); else { cygheap->sthreads = THREADLIST_CHUNK; - cygheap->threadlist = (_threadinfo **) ccalloc (HEAP_TLS, cygheap->sthreads, + cygheap->threadlist = (_cygtls **) ccalloc (HEAP_TLS, cygheap->sthreads, sizeof (cygheap->threadlist[0])); } new_muto1 (sentry::lock, sentry_lock); } void -_threadinfo::set_state (bool is_exception) +_cygtls::set_state (bool is_exception) { initialized = CYGTLS_INITIALIZED + is_exception; } void -_threadinfo::reset_exception () +_cygtls::reset_exception () { if (initialized == CYGTLS_EXCEPTION) { @@ -75,14 +76,14 @@ _threadinfo::reset_exception () /* Two calls to get the stack right... */ void -_threadinfo::call (DWORD (*func) (void *, void *), void *arg) +_cygtls::call (DWORD (*func) (void *, void *), void *arg) { char buf[CYGTLS_PADSIZE]; call2 (func, arg, buf); } void -_threadinfo::call2 (DWORD (*func) (void *, void *), void *arg, void *buf) +_cygtls::call2 (DWORD (*func) (void *, void *), void *arg, void *buf) { exception_list except_entry; /* Initialize this thread's ability to respond to things like @@ -95,7 +96,7 @@ _threadinfo::call2 (DWORD (*func) (void *, void *), void *arg, void *buf) } void -_threadinfo::init_thread (void *x, DWORD (*func) (void *, void *)) +_cygtls::init_thread (void *x, DWORD (*func) (void *, void *)) { if (x) { @@ -125,7 +126,7 @@ _threadinfo::init_thread (void *x, DWORD (*func) (void *, void *)) sentry here (INFINITE); if (nthreads >= cygheap->sthreads) { - cygheap->threadlist = (_threadinfo **) + cygheap->threadlist = (_cygtls **) crealloc (cygheap->threadlist, (cygheap->sthreads += THREADLIST_CHUNK) * sizeof (cygheap->threadlist[0])); memset (cygheap->threadlist + nthreads, 0, THREADLIST_CHUNK * sizeof (cygheap->threadlist[0])); @@ -135,7 +136,22 @@ _threadinfo::init_thread (void *x, DWORD (*func) (void *, void *)) } void -_threadinfo::remove (DWORD wait) +_cygtls::fixup_after_fork () +{ + if (sig) + { + set_signal_mask (oldmask); + sig = 0; + } + stacklock = 0; + stackptr = stack + 1; // FIXME? +#ifdef DEBUGGING + memset (stackptr, 0, sizeof (stack) - sizeof (stack[0])); +#endif +} + +void +_cygtls::remove (DWORD wait) { debug_printf ("wait %p\n", wait); sentry here (wait); @@ -153,7 +169,7 @@ _threadinfo::remove (DWORD wait) } void -_threadinfo::push (__stack_t addr, bool exception) +_cygtls::push (__stack_t addr, bool exception) { if (exception) lock (); @@ -166,13 +182,13 @@ _threadinfo::push (__stack_t addr, bool exception) #define BAD_IX ((size_t) -1) static size_t NO_COPY threadlist_ix = BAD_IX; -_threadinfo * -_threadinfo::find_tls (int sig) +_cygtls * +_cygtls::find_tls (int sig) { debug_printf ("sig %d\n", sig); sentry here (INFINITE); __asm__ volatile (".equ _threadlist_exception_return,."); - _threadinfo *res = NULL; + _cygtls *res = NULL; for (threadlist_ix = 0; threadlist_ix < nthreads; threadlist_ix++) if (sigismember (&(cygheap->threadlist[threadlist_ix]->sigwait_mask), sig)) { @@ -184,7 +200,7 @@ _threadinfo::find_tls (int sig) } void -_threadinfo::set_siginfo (sigpacket *pack) +_cygtls::set_siginfo (sigpacket *pack) { infodata = pack->si; } @@ -222,7 +238,7 @@ handle_threadlist_exception (EXCEPTION_RECORD *e, void *frame, CONTEXT *, void * } void -_threadinfo::init_threadlist_exceptions (exception_list *el) +_cygtls::init_threadlist_exceptions (exception_list *el) { extern void init_exception_handler (exception_list *, exception_handler *); init_exception_handler (el, handle_threadlist_exception); -- cgit v1.2.3