void qmonSIGINT(int dummy) {
qmon_shutdown = 1;
if (sigint_id != 0) {
XtNoticeSignal(sigint_id);
}
}
void
DtTermSubprocReap(pid_t pid, int *stat_loc)
{
/*
* This procedure has special constraints, since it may be invoked
* inside a signal handler. That means it (and anything it calls)
* can only use POSIX async-signal safe library routines. A notable
* omission from the list of reentrant routines is pthread_mutex_lock(),
* which means we cannot call XtProcessLock() or XtAppLock().
*
* That makes it challenging to transfer the pid and stat_loc
* information out of the signal handler to a routine where it is
* safe to invoke callbacks. Storing them in static globals will not
* work, because overlapping signals may arrive. The approach used
* here is imperfect, but the best I could contrive. We block signals
* and then search the global data structures without using any locks.
* The routines that update the subprocHead list try not to leave it
* in a transient inconsistent state, but that cannot be guaranteed.
*/
subprocInfo *subprocTmp;
sigset_t new_sigs;
sigset_t old_sigs;
/*
* Block additional SIGCHLD signals temporarily. This is not
* necessary if the handler was installed with sigaction(), but we
* may be called from an application's signal handler, and it may
* have been installed with signal().
*/
(void) sigemptyset(&new_sigs);
(void) sigaddset(&new_sigs, SIGCHLD);
(void) sigprocmask(SIG_BLOCK, &new_sigs, &old_sigs);
if (pid > 0) {
/* find the subprocInfo structure for this subprocess... */
for (subprocTmp = subprocHead->next;
subprocTmp;
subprocTmp = subprocTmp->next) {
if (subprocTmp->pid == pid) {
if (subprocTmp->w && !subprocTmp->w->core.being_destroyed) {
subprocTmp->stat_loc = *stat_loc;
XtNoticeSignal(subprocTmp->signal_id);
}
break;
}
}
}
/* Restore SIGCHLD handling to its original state. */
(void) sigprocmask(SIG_SETMASK, &old_sigs, NULL);
}
