drew
/
acadia-newlib
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

* pinfo.h (pinfo::operator ==): Add a way to check for _pinfo types. 

* sigproc.cc (proc_subproc): Ensure that zombie is removed when SIGCHLD ==
SIG_IGN but still allow wait()ing threads to wake up.
This commit is contained in:
Christopher Faylor 2003-12-17 22:47:32 +00:00
parent 1ed95be609
commit 1f8331ae8b
5 changed files with 20 additions and 8 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
winsup/cygwin/ChangeLog
View File

@ -1,3 +1,9 @@
2003-12-17 Christopher Faylor <cgf@redhat.com>
* pinfo.h (pinfo::operator ==): Add a way to check for _pinfo types.
* sigproc.cc (proc_subproc): Ensure that zombie is removed when SIGCHLD
== SIG_IGN but still allow wait()ing threads to wake up.
2003-12-16 Christopher Faylor <cgf@redhat.com>
* exceptions.cc (set_signal_mask): Report on input argument rather than

2
winsup/cygwin/exceptions.cc
View File

@ -792,7 +792,7 @@ signal_fixup_after_fork ()
extern "C" void __stdcall
set_sig_errno (int e)
{
set_errno (e);
*_my_tls.errno_addr = e;
_my_tls.saved_errno = e;
// sigproc_printf ("errno %d", e);
}

1
winsup/cygwin/pinfo.h
View File

@ -144,6 +144,7 @@ public:
_pinfo *operator -> () const {return procinfo;}
int operator == (pinfo *x) const {return x->procinfo == procinfo;}
int operator == (pinfo &x) const {return x.procinfo == procinfo;}
int operator == (_pinfo *x) const {return x == procinfo;}
int operator == (void *x) const {return procinfo == x;}
int operator == (int x) const {return (int) procinfo == (int) x;}
int operator == (char *x) const {return (char *) procinfo == x;}

17
winsup/cygwin/sigproc.cc
View File

@ -304,6 +304,8 @@ proc_subproc (DWORD what, DWORD val)
_pinfo *child;
int clearing;
waitq *w;
int thiszombie;
_pinfo *zombie_proc = NULL;
#define wval ((waitq *) val)
@ -375,9 +377,8 @@ proc_subproc (DWORD what, DWORD val)
sigproc_printf ("pid %d[%d] terminated, handle %p, nchildren %d, nzombies %d",
pchildren[val]->pid, val, hchildren[val], nchildren, nzombies);
int thiszombie;
thiszombie = nzombies;
zombies[nzombies] = pchildren[val]; // Add to zombie array
zombie_proc = zombies[nzombies] = pchildren[val]; // Add to zombie array
zombies[nzombies++]->process_state = PID_ZOMBIE;// Walking dead
sigproc_printf ("zombifying [%d], pid %d, handle %p, nchildren %d",
@ -391,11 +392,11 @@ proc_subproc (DWORD what, DWORD val)
/* See if we should care about the this terminated process. If we've
filled up our table or if we're ignoring SIGCHLD, then we immediately
remove the process and move on. Otherwise, this process becomes a zombie
which must be reaped by a wait() call. */
if (nzombies >= NZOMBIES
|| global_sigs[SIGCHLD].sa_handler == (void *) SIG_IGN)
which must be reaped by a wait() call. FIXME: This is a very inelegant
way to deal with this and could lead to process hangs. */
if (nzombies >= NZOMBIES)
{
sigproc_printf ("automatically removing zombie %d", thiszombie);
sigproc_printf ("zombie table overflow %d", thiszombie);
remove_zombie (thiszombie);
}
@ -477,6 +478,10 @@ proc_subproc (DWORD what, DWORD val)
sigproc_printf ("finished processing terminated/stopped child");
else
{
if (zombie_proc && zombies[thiszombie]
&& zombies[thiszombie] == zombie_proc
&& global_sigs[SIGCHLD].sa_handler == (void *) SIG_IGN)
remove_zombie (thiszombie);
waitq_head.next = NULL;
sigproc_printf ("finished clearing");
}

2
winsup/cygwin/wait.cc
View File

@ -98,8 +98,8 @@ wait4 (int intpid, int *status, int options, struct rusage *r)
if (w->status == -1)
{
call_signal_handler_now ();
set_sig_errno (EINTR);
call_signal_handler_now ();
sawsig = true;
res = -1;
}