2009-01-31 10:33:39 -08:00
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
# include <config.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include <stdio.h>
|
2003-09-23 01:09:32 -07:00
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/wait.h>
|
|
|
|
#include <signal.h>
|
|
|
|
#include <unistd.h>
|
2004-04-04 12:53:19 -07:00
|
|
|
#include <assert.h>
|
2009-01-31 10:33:39 -08:00
|
|
|
|
2006-01-06 05:56:47 -08:00
|
|
|
#include "Ecore.h"
|
2009-12-22 13:15:12 -08:00
|
|
|
#include "ecore_private.h"
|
2003-09-23 01:09:32 -07:00
|
|
|
|
2005-01-08 21:17:24 -08:00
|
|
|
/* make mono happy - this is evil though... */
|
|
|
|
#undef SIGPWR
|
2005-02-08 18:18:02 -08:00
|
|
|
/* valgrind in some versions/setups uses SIGRT's... hmmm */
|
2005-01-08 21:17:24 -08:00
|
|
|
|
2004-04-04 12:53:19 -07:00
|
|
|
typedef void (*Signal_Handler)(int sig, siginfo_t *si, void *foo);
|
2003-09-23 01:09:32 -07:00
|
|
|
|
2011-10-20 22:40:39 -07:00
|
|
|
static void _ecore_signal_callback_set(int sig,
|
|
|
|
Signal_Handler func);
|
|
|
|
static void _ecore_signal_callback_ignore(int sig,
|
|
|
|
siginfo_t *si,
|
|
|
|
void *foo);
|
|
|
|
static void _ecore_signal_callback_sigchld(int sig,
|
|
|
|
siginfo_t *si,
|
|
|
|
void *foo);
|
|
|
|
static void _ecore_signal_callback_sigusr1(int sig,
|
|
|
|
siginfo_t *si,
|
|
|
|
void *foo);
|
|
|
|
static void _ecore_signal_callback_sigusr2(int sig,
|
|
|
|
siginfo_t *si,
|
|
|
|
void *foo);
|
|
|
|
static void _ecore_signal_callback_sighup(int sig,
|
|
|
|
siginfo_t *si,
|
|
|
|
void *foo);
|
|
|
|
static void _ecore_signal_callback_sigquit(int sig,
|
|
|
|
siginfo_t *si,
|
|
|
|
void *foo);
|
|
|
|
static void _ecore_signal_callback_sigint(int sig,
|
|
|
|
siginfo_t *si,
|
|
|
|
void *foo);
|
|
|
|
static void _ecore_signal_callback_sigterm(int sig,
|
|
|
|
siginfo_t *si,
|
|
|
|
void *foo);
|
2011-02-01 02:21:22 -08:00
|
|
|
#ifdef SIGPWR
|
2011-10-20 22:40:39 -07:00
|
|
|
static void _ecore_signal_callback_sigpwr(int sig,
|
|
|
|
siginfo_t *si,
|
|
|
|
void *foo);
|
2011-02-01 02:21:22 -08:00
|
|
|
#endif
|
2004-04-04 12:53:19 -07:00
|
|
|
|
2010-06-24 09:15:56 -07:00
|
|
|
static Eina_Bool _ecore_signal_exe_exit_delay(void *data);
|
2005-12-30 11:17:21 -08:00
|
|
|
|
2008-05-03 01:15:16 -07:00
|
|
|
//#define MAXSIGQ 256 // 32k
|
|
|
|
#define MAXSIGQ 64 // 8k
|
|
|
|
|
2004-04-04 12:53:19 -07:00
|
|
|
static volatile sig_atomic_t sig_count = 0;
|
2004-04-04 05:17:32 -07:00
|
|
|
static volatile sig_atomic_t sigchld_count = 0;
|
|
|
|
static volatile sig_atomic_t sigusr1_count = 0;
|
|
|
|
static volatile sig_atomic_t sigusr2_count = 0;
|
|
|
|
static volatile sig_atomic_t sighup_count = 0;
|
|
|
|
static volatile sig_atomic_t sigquit_count = 0;
|
|
|
|
static volatile sig_atomic_t sigint_count = 0;
|
|
|
|
static volatile sig_atomic_t sigterm_count = 0;
|
2004-04-04 12:53:19 -07:00
|
|
|
#ifdef SIGPWR
|
2004-04-04 05:17:32 -07:00
|
|
|
static volatile sig_atomic_t sigpwr_count = 0;
|
2004-04-04 12:53:19 -07:00
|
|
|
#endif
|
2008-05-03 01:15:16 -07:00
|
|
|
|
|
|
|
static volatile siginfo_t sigchld_info[MAXSIGQ];
|
|
|
|
static volatile siginfo_t sigusr1_info[MAXSIGQ];
|
|
|
|
static volatile siginfo_t sigusr2_info[MAXSIGQ];
|
|
|
|
static volatile siginfo_t sighup_info[MAXSIGQ];
|
|
|
|
static volatile siginfo_t sigquit_info[MAXSIGQ];
|
|
|
|
static volatile siginfo_t sigint_info[MAXSIGQ];
|
|
|
|
static volatile siginfo_t sigterm_info[MAXSIGQ];
|
|
|
|
#ifdef SIGPWR
|
|
|
|
static volatile siginfo_t sigpwr_info[MAXSIGQ];
|
|
|
|
#endif
|
2003-09-23 01:09:32 -07:00
|
|
|
|
|
|
|
void
|
|
|
|
_ecore_signal_shutdown(void)
|
|
|
|
{
|
2011-10-20 22:40:39 -07:00
|
|
|
_ecore_signal_callback_set(SIGPIPE, (Signal_Handler)SIG_DFL);
|
|
|
|
_ecore_signal_callback_set(SIGALRM, (Signal_Handler)SIG_DFL);
|
|
|
|
_ecore_signal_callback_set(SIGCHLD, (Signal_Handler)SIG_DFL);
|
|
|
|
_ecore_signal_callback_set(SIGUSR1, (Signal_Handler)SIG_DFL);
|
|
|
|
_ecore_signal_callback_set(SIGUSR2, (Signal_Handler)SIG_DFL);
|
|
|
|
_ecore_signal_callback_set(SIGHUP, (Signal_Handler)SIG_DFL);
|
|
|
|
_ecore_signal_callback_set(SIGQUIT, (Signal_Handler)SIG_DFL);
|
|
|
|
_ecore_signal_callback_set(SIGINT, (Signal_Handler)SIG_DFL);
|
|
|
|
_ecore_signal_callback_set(SIGTERM, (Signal_Handler)SIG_DFL);
|
2004-04-04 12:53:19 -07:00
|
|
|
#ifdef SIGPWR
|
2011-10-20 22:40:39 -07:00
|
|
|
_ecore_signal_callback_set(SIGPWR, (Signal_Handler)SIG_DFL);
|
2004-04-06 20:42:55 -07:00
|
|
|
sigpwr_count = 0;
|
2004-04-04 12:53:19 -07:00
|
|
|
#endif
|
2003-09-23 01:09:32 -07:00
|
|
|
sigchld_count = 0;
|
|
|
|
sigusr1_count = 0;
|
|
|
|
sigusr2_count = 0;
|
|
|
|
sighup_count = 0;
|
|
|
|
sigquit_count = 0;
|
|
|
|
sigint_count = 0;
|
|
|
|
sigterm_count = 0;
|
|
|
|
sig_count = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
_ecore_signal_init(void)
|
|
|
|
{
|
|
|
|
_ecore_signal_callback_set(SIGPIPE, _ecore_signal_callback_ignore);
|
|
|
|
_ecore_signal_callback_set(SIGALRM, _ecore_signal_callback_ignore);
|
2011-02-01 02:21:22 -08:00
|
|
|
_ecore_signal_callback_set(SIGCHLD, _ecore_signal_callback_sigchld);
|
|
|
|
_ecore_signal_callback_set(SIGUSR1, _ecore_signal_callback_sigusr1);
|
|
|
|
_ecore_signal_callback_set(SIGUSR2, _ecore_signal_callback_sigusr2);
|
2011-10-20 22:40:39 -07:00
|
|
|
_ecore_signal_callback_set(SIGHUP, _ecore_signal_callback_sighup);
|
2011-02-01 02:21:22 -08:00
|
|
|
_ecore_signal_callback_set(SIGQUIT, _ecore_signal_callback_sigquit);
|
2011-10-20 22:40:39 -07:00
|
|
|
_ecore_signal_callback_set(SIGINT, _ecore_signal_callback_sigint);
|
2011-02-01 02:21:22 -08:00
|
|
|
_ecore_signal_callback_set(SIGTERM, _ecore_signal_callback_sigterm);
|
2004-04-04 12:53:19 -07:00
|
|
|
#ifdef SIGPWR
|
2011-10-20 22:40:39 -07:00
|
|
|
_ecore_signal_callback_set(SIGPWR, _ecore_signal_callback_sigpwr);
|
2004-04-04 12:53:19 -07:00
|
|
|
#endif
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
|
2011-09-01 20:29:11 -07:00
|
|
|
void
|
|
|
|
_ecore_signal_received_process(void)
|
|
|
|
{
|
|
|
|
while (_ecore_signal_count_get()) _ecore_signal_call();
|
|
|
|
}
|
|
|
|
|
2003-09-23 01:09:32 -07:00
|
|
|
int
|
|
|
|
_ecore_signal_count_get(void)
|
|
|
|
{
|
|
|
|
return sig_count;
|
|
|
|
}
|
|
|
|
|
2012-04-13 08:44:02 -07:00
|
|
|
static void
|
2012-11-25 01:55:32 -08:00
|
|
|
_ecore_signal_generic_free(void *data EINA_UNUSED,
|
2012-04-13 08:44:02 -07:00
|
|
|
void *event)
|
|
|
|
{
|
|
|
|
free(event);
|
|
|
|
}
|
|
|
|
|
2003-09-23 01:09:32 -07:00
|
|
|
void
|
|
|
|
_ecore_signal_call(void)
|
|
|
|
{
|
2008-05-03 01:15:16 -07:00
|
|
|
volatile sig_atomic_t n;
|
|
|
|
sigset_t oldset, newset;
|
2012-05-31 06:32:09 -07:00
|
|
|
int tot;
|
2008-11-29 03:23:17 -08:00
|
|
|
|
2008-05-03 01:15:16 -07:00
|
|
|
if (sig_count == 0) return;
|
|
|
|
sigemptyset(&newset);
|
|
|
|
sigaddset(&newset, SIGPIPE);
|
|
|
|
sigaddset(&newset, SIGALRM);
|
|
|
|
sigaddset(&newset, SIGCHLD);
|
|
|
|
sigaddset(&newset, SIGUSR1);
|
|
|
|
sigaddset(&newset, SIGUSR2);
|
|
|
|
sigaddset(&newset, SIGHUP);
|
|
|
|
sigaddset(&newset, SIGQUIT);
|
|
|
|
sigaddset(&newset, SIGINT);
|
|
|
|
sigaddset(&newset, SIGTERM);
|
|
|
|
#ifdef SIGPWR
|
|
|
|
sigaddset(&newset, SIGPWR);
|
2008-11-29 03:23:17 -08:00
|
|
|
#endif
|
2008-05-03 01:15:16 -07:00
|
|
|
sigprocmask(SIG_BLOCK, &newset, &oldset);
|
|
|
|
if (sigchld_count > MAXSIGQ)
|
2014-05-30 05:02:36 -07:00
|
|
|
#ifdef __FreeBSD__
|
|
|
|
WRN("%ld SIGCHLD in queue. max queue size %i. losing "
|
|
|
|
"siginfo for extra signals.", sigchld_count, MAXSIGQ);
|
|
|
|
#else
|
2009-12-21 09:32:19 -08:00
|
|
|
WRN("%i SIGCHLD in queue. max queue size %i. losing "
|
2011-10-20 22:40:39 -07:00
|
|
|
"siginfo for extra signals.", sigchld_count, MAXSIGQ);
|
2014-05-30 05:02:36 -07:00
|
|
|
#endif
|
2012-05-31 06:32:09 -07:00
|
|
|
tot = sigchld_count + sigusr1_count + sigusr2_count +
|
|
|
|
sighup_count + sigquit_count + sigint_count + sigterm_count
|
|
|
|
#ifdef SIGPWR
|
|
|
|
+ sigpwr_count
|
|
|
|
#endif
|
|
|
|
;
|
|
|
|
|
|
|
|
if (sig_count != tot)
|
|
|
|
{
|
2014-05-30 05:02:36 -07:00
|
|
|
#ifdef __FreeBSD__
|
|
|
|
ERR("sig_count (%ld) != actual totals (%i) ", sig_count, tot);
|
|
|
|
#else
|
2012-05-31 06:32:09 -07:00
|
|
|
ERR("sig_count (%i) != actual totals (%i) ", sig_count, tot);
|
2014-05-30 05:02:36 -07:00
|
|
|
#endif
|
2012-05-31 06:32:09 -07:00
|
|
|
sig_count = tot;
|
|
|
|
}
|
|
|
|
|
2008-05-03 01:15:16 -07:00
|
|
|
for (n = 0; n < sigchld_count; n++)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
2010-09-29 23:09:20 -07:00
|
|
|
pid_t pid;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
while ((pid = waitpid(-1, &status, WNOHANG)) > 0)
|
|
|
|
{
|
|
|
|
Ecore_Exe_Event_Del *e;
|
|
|
|
|
|
|
|
/* FIXME: If this process is set respawn, respawn with a suitable backoff
|
|
|
|
* period for those that need too much respawning.
|
|
|
|
*/
|
|
|
|
e = _ecore_exe_event_del_new();
|
|
|
|
if (e)
|
|
|
|
{
|
|
|
|
if (WIFEXITED(status))
|
|
|
|
{
|
|
|
|
e->exit_code = WEXITSTATUS(status);
|
|
|
|
e->exited = 1;
|
|
|
|
}
|
|
|
|
else if (WIFSIGNALED(status))
|
|
|
|
{
|
|
|
|
e->exit_signal = WTERMSIG(status);
|
|
|
|
e->signalled = 1;
|
|
|
|
}
|
|
|
|
e->pid = pid;
|
|
|
|
e->exe = _ecore_exe_find(pid);
|
|
|
|
|
|
|
|
if ((n < MAXSIGQ) && (sigchld_info[n].si_signo))
|
2011-10-20 22:40:39 -07:00
|
|
|
e->data = sigchld_info[n]; /* No need to clone this. */
|
2007-08-26 04:17:21 -07:00
|
|
|
|
2010-01-03 13:55:50 -08:00
|
|
|
if ((e->exe) && (ecore_exe_flags_get(e->exe) & (ECORE_EXE_PIPE_READ | ECORE_EXE_PIPE_ERROR)))
|
2011-10-20 22:40:39 -07:00
|
|
|
{
|
|
|
|
/* We want to report the Last Words of the exe, so delay this event.
|
|
|
|
* This is twice as relevant for stderr.
|
|
|
|
* There are three possibilities here -
|
|
|
|
* 1 There are no Last Words.
|
|
|
|
* 2 There are Last Words, they are not ready to be read.
|
|
|
|
* 3 There are Last Words, they are ready to be read.
|
|
|
|
*
|
|
|
|
* For 1 we don't want to delay, for 3 we want to delay.
|
|
|
|
* 2 is the problem. If we check for data now and there
|
|
|
|
* is none, then there is no way to differentiate 1 and 2.
|
|
|
|
* If we don't delay, we may loose data, but if we do delay,
|
|
|
|
* there may not be data and the exit event never gets sent.
|
|
|
|
*
|
|
|
|
* Any way you look at it, there has to be some time passed
|
|
|
|
* before the exit event gets sent. So the strategy here is
|
|
|
|
* to setup a timer event that will send the exit event after
|
|
|
|
* an arbitrary, but brief, time.
|
|
|
|
*
|
|
|
|
* This is probably paranoid, for the less paraniod, we could
|
|
|
|
* check to see for Last Words, and only delay if there are any.
|
|
|
|
* This has it's own set of problems.
|
|
|
|
*/
|
|
|
|
Ecore_Timer *doomsday_clock;
|
|
|
|
|
|
|
|
doomsday_clock = _ecore_exe_doomsday_clock_get(e->exe);
|
|
|
|
IF_FN_DEL(ecore_timer_del, doomsday_clock);
|
|
|
|
_ecore_unlock();
|
|
|
|
doomsday_clock = ecore_timer_add
|
|
|
|
(0.1, _ecore_signal_exe_exit_delay, e);
|
|
|
|
_ecore_lock();
|
|
|
|
_ecore_exe_doomsday_clock_set(e->exe, doomsday_clock);
|
|
|
|
}
|
2010-09-29 23:09:20 -07:00
|
|
|
else
|
|
|
|
{
|
|
|
|
_ecore_event_add(ECORE_EXE_EVENT_DEL, e,
|
2011-10-20 22:40:39 -07:00
|
|
|
_ecore_exe_event_del_free, NULL);
|
2010-09-29 23:09:20 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
sig_count--;
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
2008-05-03 01:15:16 -07:00
|
|
|
sigchld_count = 0;
|
2008-11-29 03:23:17 -08:00
|
|
|
|
2008-05-03 01:15:16 -07:00
|
|
|
if (sigusr1_count > MAXSIGQ)
|
2014-05-30 05:02:36 -07:00
|
|
|
#ifdef __FreeBSD__
|
|
|
|
WRN("%ld SIGUSR1 in queue. max queue size %i. losing "
|
|
|
|
"siginfo for extra signals.", sigusr1_count, MAXSIGQ);
|
|
|
|
#else
|
2009-12-21 09:32:19 -08:00
|
|
|
WRN("%i SIGUSR1 in queue. max queue size %i. losing "
|
2010-09-29 23:09:20 -07:00
|
|
|
"siginfo for extra signals.", sigusr1_count, MAXSIGQ);
|
2014-05-30 05:02:36 -07:00
|
|
|
#endif
|
2008-05-03 01:15:16 -07:00
|
|
|
for (n = 0; n < sigusr1_count; n++)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
2010-09-29 23:09:20 -07:00
|
|
|
Ecore_Event_Signal_User *e;
|
2007-08-26 04:17:21 -07:00
|
|
|
|
2010-09-29 23:09:20 -07:00
|
|
|
e = _ecore_event_signal_user_new();
|
|
|
|
if (e)
|
|
|
|
{
|
|
|
|
e->number = 1;
|
2004-04-05 09:32:53 -07:00
|
|
|
|
2010-09-29 23:09:20 -07:00
|
|
|
if ((n < MAXSIGQ) && (sigusr1_info[n].si_signo))
|
|
|
|
e->data = sigusr1_info[n];
|
2007-08-26 04:17:21 -07:00
|
|
|
|
2012-04-13 08:44:02 -07:00
|
|
|
_ecore_event_add(ECORE_EVENT_SIGNAL_USER, e,
|
|
|
|
_ecore_signal_generic_free, NULL);
|
2010-09-29 23:09:20 -07:00
|
|
|
}
|
|
|
|
sig_count--;
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
2008-05-03 01:15:16 -07:00
|
|
|
sigusr1_count = 0;
|
2008-11-29 03:23:17 -08:00
|
|
|
|
2008-05-03 01:15:16 -07:00
|
|
|
if (sigusr2_count > MAXSIGQ)
|
2014-05-30 05:02:36 -07:00
|
|
|
#ifdef __FreeBSD__
|
|
|
|
WRN("%ld SIGUSR2 in queue. max queue size %i. losing "
|
|
|
|
"siginfo for extra signals.", sigusr2_count, MAXSIGQ);
|
|
|
|
#else
|
2009-12-21 09:32:19 -08:00
|
|
|
WRN("%i SIGUSR2 in queue. max queue size %i. losing "
|
2010-09-29 23:09:20 -07:00
|
|
|
"siginfo for extra signals.", sigusr2_count, MAXSIGQ);
|
2014-05-30 05:02:36 -07:00
|
|
|
#endif
|
2008-05-03 01:15:16 -07:00
|
|
|
for (n = 0; n < sigusr2_count; n++)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
2010-09-29 23:09:20 -07:00
|
|
|
Ecore_Event_Signal_User *e;
|
2007-08-26 04:17:21 -07:00
|
|
|
|
2010-09-29 23:09:20 -07:00
|
|
|
e = _ecore_event_signal_user_new();
|
|
|
|
if (e)
|
|
|
|
{
|
|
|
|
e->number = 2;
|
2007-08-26 04:17:21 -07:00
|
|
|
|
2010-09-29 23:09:20 -07:00
|
|
|
if ((n < MAXSIGQ) && (sigusr2_info[n].si_signo))
|
|
|
|
e->data = sigusr2_info[n];
|
2007-08-26 04:17:21 -07:00
|
|
|
|
2012-04-13 08:44:02 -07:00
|
|
|
_ecore_event_add(ECORE_EVENT_SIGNAL_USER, e,
|
|
|
|
_ecore_signal_generic_free, NULL);
|
2010-09-29 23:09:20 -07:00
|
|
|
}
|
|
|
|
sig_count--;
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
2008-05-03 01:15:16 -07:00
|
|
|
sigusr2_count = 0;
|
2008-11-29 03:23:17 -08:00
|
|
|
|
2008-05-03 01:15:16 -07:00
|
|
|
if (sighup_count > MAXSIGQ)
|
2014-05-30 05:02:36 -07:00
|
|
|
#ifdef __FreeBSD__
|
|
|
|
WRN("%ld SIGHUP in queue. max queue size %i. losing "
|
|
|
|
"siginfo for extra signals.", sighup_count, MAXSIGQ);
|
|
|
|
#else
|
2009-12-21 09:32:19 -08:00
|
|
|
WRN("%i SIGHUP in queue. max queue size %i. losing "
|
2010-09-29 23:09:20 -07:00
|
|
|
"siginfo for extra signals.", sighup_count, MAXSIGQ);
|
2014-05-30 05:02:36 -07:00
|
|
|
#endif
|
2008-05-03 01:15:16 -07:00
|
|
|
for (n = 0; n < sighup_count; n++)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
2010-09-29 23:09:20 -07:00
|
|
|
Ecore_Event_Signal_Hup *e;
|
2007-08-26 04:17:21 -07:00
|
|
|
|
2010-09-29 23:09:20 -07:00
|
|
|
e = _ecore_event_signal_hup_new();
|
|
|
|
if (e)
|
|
|
|
{
|
|
|
|
if ((n < MAXSIGQ) && (sighup_info[n].si_signo))
|
|
|
|
e->data = sighup_info[n];
|
2007-08-26 04:17:21 -07:00
|
|
|
|
2012-04-13 08:44:02 -07:00
|
|
|
_ecore_event_add(ECORE_EVENT_SIGNAL_HUP, e,
|
|
|
|
_ecore_signal_generic_free, NULL);
|
2010-09-29 23:09:20 -07:00
|
|
|
}
|
|
|
|
sig_count--;
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
2008-05-03 01:15:16 -07:00
|
|
|
sighup_count = 0;
|
2008-11-29 03:23:17 -08:00
|
|
|
|
2008-05-03 01:15:16 -07:00
|
|
|
if (sigquit_count > MAXSIGQ)
|
2014-05-30 05:02:36 -07:00
|
|
|
#ifdef __FreeBSD__
|
|
|
|
WRN("%ld SIGQUIT in queue. max queue size %i. losing "
|
|
|
|
"siginfo for extra signals.", sigquit_count, MAXSIGQ);
|
|
|
|
#else
|
2009-12-21 09:32:19 -08:00
|
|
|
WRN("%i SIGQUIT in queue. max queue size %i. losing "
|
2010-09-29 23:09:20 -07:00
|
|
|
"siginfo for extra signals.", sigquit_count, MAXSIGQ);
|
2014-05-30 05:02:36 -07:00
|
|
|
#endif
|
2008-05-03 01:15:16 -07:00
|
|
|
for (n = 0; n < sigquit_count; n++)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
2010-09-29 23:09:20 -07:00
|
|
|
Ecore_Event_Signal_Exit *e;
|
2007-08-26 04:17:21 -07:00
|
|
|
|
2010-09-29 23:09:20 -07:00
|
|
|
e = _ecore_event_signal_exit_new();
|
|
|
|
if (e)
|
|
|
|
{
|
|
|
|
e->quit = 1;
|
2004-04-05 09:32:53 -07:00
|
|
|
|
2010-09-29 23:09:20 -07:00
|
|
|
if ((n < MAXSIGQ) && (sigquit_info[n].si_signo))
|
|
|
|
e->data = sigquit_info[n];
|
2007-08-26 04:17:21 -07:00
|
|
|
|
2012-04-13 08:44:02 -07:00
|
|
|
_ecore_event_add(ECORE_EVENT_SIGNAL_EXIT, e,
|
|
|
|
_ecore_signal_generic_free, NULL);
|
2010-09-29 23:09:20 -07:00
|
|
|
}
|
|
|
|
sig_count--;
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
2008-05-03 01:15:16 -07:00
|
|
|
sigquit_count = 0;
|
|
|
|
|
|
|
|
if (sigint_count > MAXSIGQ)
|
2014-05-30 05:02:36 -07:00
|
|
|
#ifdef __FreeBSD__
|
|
|
|
WRN("%ld SIGINT in queue. max queue size %i. losing "
|
|
|
|
"siginfo for extra signals.", sigint_count, MAXSIGQ);
|
|
|
|
#else
|
2009-12-21 09:32:19 -08:00
|
|
|
WRN("%i SIGINT in queue. max queue size %i. losing "
|
2010-09-29 23:09:20 -07:00
|
|
|
"siginfo for extra signals.", sigint_count, MAXSIGQ);
|
2014-05-30 05:02:36 -07:00
|
|
|
#endif
|
2008-05-03 01:15:16 -07:00
|
|
|
for (n = 0; n < sigint_count; n++)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
2010-09-29 23:09:20 -07:00
|
|
|
Ecore_Event_Signal_Exit *e;
|
2007-08-26 04:17:21 -07:00
|
|
|
|
2010-09-29 23:09:20 -07:00
|
|
|
e = _ecore_event_signal_exit_new();
|
|
|
|
if (e)
|
|
|
|
{
|
|
|
|
e->interrupt = 1;
|
2007-08-26 04:17:21 -07:00
|
|
|
|
2010-09-29 23:09:20 -07:00
|
|
|
if ((n < MAXSIGQ) && (sigint_info[n].si_signo))
|
|
|
|
e->data = sigint_info[n];
|
2007-08-26 04:17:21 -07:00
|
|
|
|
2012-04-13 08:44:02 -07:00
|
|
|
_ecore_event_add(ECORE_EVENT_SIGNAL_EXIT, e,
|
|
|
|
_ecore_signal_generic_free, NULL);
|
2010-09-29 23:09:20 -07:00
|
|
|
}
|
|
|
|
sig_count--;
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
2008-05-03 01:15:16 -07:00
|
|
|
sigint_count = 0;
|
2008-11-29 03:23:17 -08:00
|
|
|
|
2008-05-03 01:15:16 -07:00
|
|
|
if (sigterm_count > MAXSIGQ)
|
2014-05-30 05:02:36 -07:00
|
|
|
#ifdef __FreeBSD__
|
|
|
|
WRN("%ld SIGTERM in queue. max queue size %i. losing "
|
|
|
|
"siginfo for extra signals.", sigterm_count, MAXSIGQ);
|
|
|
|
#else
|
2009-12-21 09:32:19 -08:00
|
|
|
WRN("%i SIGTERM in queue. max queue size %i. losing "
|
2010-09-29 23:09:20 -07:00
|
|
|
"siginfo for extra signals.", sigterm_count, MAXSIGQ);
|
2014-05-30 05:02:36 -07:00
|
|
|
#endif
|
2008-05-03 01:15:16 -07:00
|
|
|
for (n = 0; n < sigterm_count; n++)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
2010-09-29 23:09:20 -07:00
|
|
|
Ecore_Event_Signal_Exit *e;
|
2007-08-26 04:17:21 -07:00
|
|
|
|
2010-09-29 23:09:20 -07:00
|
|
|
e = _ecore_event_signal_exit_new();
|
|
|
|
if (e)
|
|
|
|
{
|
|
|
|
e->terminate = 1;
|
2007-08-26 04:17:21 -07:00
|
|
|
|
2010-09-29 23:09:20 -07:00
|
|
|
if ((n < MAXSIGQ) && (sigterm_info[n].si_signo))
|
|
|
|
e->data = sigterm_info[n];
|
2007-08-26 04:17:21 -07:00
|
|
|
|
2012-04-13 08:44:02 -07:00
|
|
|
_ecore_event_add(ECORE_EVENT_SIGNAL_EXIT, e,
|
|
|
|
_ecore_signal_generic_free, NULL);
|
2010-09-29 23:09:20 -07:00
|
|
|
}
|
|
|
|
sig_count--;
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
2008-05-03 01:15:16 -07:00
|
|
|
sigterm_count = 0;
|
2008-11-29 03:23:17 -08:00
|
|
|
|
2004-04-04 12:53:19 -07:00
|
|
|
#ifdef SIGPWR
|
2008-05-03 01:15:16 -07:00
|
|
|
if (sigpwr_count > MAXSIGQ)
|
2014-05-30 05:02:36 -07:00
|
|
|
#ifdef __FreeBSD__
|
|
|
|
WRN("%ld SIGPWR in queue. max queue size %i. losing "
|
|
|
|
"siginfo for extra signals.", sigpwr_count, MAXSIGQ);
|
|
|
|
#else
|
2009-12-21 09:32:19 -08:00
|
|
|
WRN("%i SIGPWR in queue. max queue size %i. losing "
|
2010-09-29 23:09:20 -07:00
|
|
|
"siginfo for extra signals.", sigpwr_count, MAXSIGQ);
|
2014-05-30 05:02:36 -07:00
|
|
|
#endif
|
2008-05-03 01:15:16 -07:00
|
|
|
for (n = 0; n < sigpwr_count; n++)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
2010-09-29 23:09:20 -07:00
|
|
|
Ecore_Event_Signal_Power *e;
|
2007-08-26 04:17:21 -07:00
|
|
|
|
2010-09-29 23:09:20 -07:00
|
|
|
e = _ecore_event_signal_power_new();
|
|
|
|
if (e)
|
|
|
|
{
|
|
|
|
if ((n < MAXSIGQ) && (sigpwr_info[n].si_signo))
|
|
|
|
e->data = sigpwr_info[n];
|
2007-08-26 04:17:21 -07:00
|
|
|
|
2012-04-13 08:44:02 -07:00
|
|
|
_ecore_event_add(ECORE_EVENT_SIGNAL_POWER, e,
|
|
|
|
_ecore_signal_generic_free, NULL);
|
2010-09-29 23:09:20 -07:00
|
|
|
}
|
|
|
|
sig_count--;
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
2008-05-03 01:15:16 -07:00
|
|
|
sigpwr_count = 0;
|
2004-04-04 12:53:19 -07:00
|
|
|
#endif
|
2012-05-31 06:32:09 -07:00
|
|
|
sig_count = 0;
|
|
|
|
|
2008-05-03 01:15:16 -07:00
|
|
|
sigprocmask(SIG_SETMASK, &oldset, NULL);
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2011-10-20 22:40:39 -07:00
|
|
|
_ecore_signal_callback_set(int sig,
|
|
|
|
Signal_Handler func)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
2011-10-20 22:40:39 -07:00
|
|
|
struct sigaction sa;
|
2003-09-23 01:09:32 -07:00
|
|
|
|
2004-04-04 12:53:19 -07:00
|
|
|
sa.sa_sigaction = func;
|
|
|
|
sa.sa_flags = SA_RESTART | SA_SIGINFO;
|
2003-09-23 01:09:32 -07:00
|
|
|
sigemptyset(&sa.sa_mask);
|
2007-08-26 04:17:21 -07:00
|
|
|
sigaction(sig, &sa, NULL);
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
|
|
|
|
2011-02-01 02:21:22 -08:00
|
|
|
static void
|
2012-11-25 01:55:32 -08:00
|
|
|
_ecore_signal_callback_ignore(int sig EINA_UNUSED,
|
|
|
|
siginfo_t *si EINA_UNUSED,
|
|
|
|
void *foo EINA_UNUSED)
|
2011-02-01 02:21:22 -08:00
|
|
|
{
|
|
|
|
}
|
2003-09-23 01:09:32 -07:00
|
|
|
|
|
|
|
static void
|
2012-11-25 01:55:32 -08:00
|
|
|
_ecore_signal_callback_sigchld(int sig EINA_UNUSED,
|
2011-10-20 22:40:39 -07:00
|
|
|
siginfo_t *si,
|
2012-11-25 01:55:32 -08:00
|
|
|
void *foo EINA_UNUSED)
|
2003-09-23 01:09:32 -07:00
|
|
|
{
|
2011-02-01 02:21:22 -08:00
|
|
|
volatile sig_atomic_t n;
|
|
|
|
n = sigchld_count;
|
|
|
|
if (n < MAXSIGQ)
|
|
|
|
{
|
|
|
|
if (si)
|
|
|
|
sigchld_info[n] = *si;
|
|
|
|
else
|
|
|
|
sigchld_info[n].si_signo = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
sigchld_count++;
|
|
|
|
sig_count++;
|
|
|
|
}
|
2003-09-23 01:09:32 -07:00
|
|
|
|
2011-02-01 02:21:22 -08:00
|
|
|
static void
|
2012-11-25 01:55:32 -08:00
|
|
|
_ecore_signal_callback_sigusr1(int sig EINA_UNUSED,
|
2011-10-20 22:40:39 -07:00
|
|
|
siginfo_t *si,
|
2012-11-25 01:55:32 -08:00
|
|
|
void *foo EINA_UNUSED)
|
2011-02-01 02:21:22 -08:00
|
|
|
{
|
|
|
|
volatile sig_atomic_t n;
|
|
|
|
n = sigusr1_count;
|
|
|
|
if (n < MAXSIGQ)
|
|
|
|
{
|
|
|
|
if (si)
|
|
|
|
sigusr1_info[n] = *si;
|
|
|
|
else
|
|
|
|
sigusr1_info[n].si_signo = 0;
|
|
|
|
}
|
|
|
|
sigusr1_count++;
|
|
|
|
sig_count++;
|
|
|
|
}
|
2003-09-23 01:09:32 -07:00
|
|
|
|
2011-02-01 02:21:22 -08:00
|
|
|
static void
|
2012-11-25 01:55:32 -08:00
|
|
|
_ecore_signal_callback_sigusr2(int sig EINA_UNUSED,
|
2011-10-20 22:40:39 -07:00
|
|
|
siginfo_t *si,
|
2012-11-25 01:55:32 -08:00
|
|
|
void *foo EINA_UNUSED)
|
2011-02-01 02:21:22 -08:00
|
|
|
{
|
|
|
|
volatile sig_atomic_t n;
|
|
|
|
n = sigusr2_count;
|
|
|
|
if (n < MAXSIGQ)
|
2008-05-03 01:15:16 -07:00
|
|
|
{
|
2011-02-01 02:21:22 -08:00
|
|
|
if (si)
|
|
|
|
sigusr2_info[n] = *si;
|
|
|
|
else
|
|
|
|
sigusr2_info[n].si_signo = 0;
|
2008-05-03 01:15:16 -07:00
|
|
|
}
|
2011-02-01 02:21:22 -08:00
|
|
|
sigusr2_count++;
|
|
|
|
sig_count++;
|
2003-09-23 01:09:32 -07:00
|
|
|
}
|
2004-04-04 12:53:19 -07:00
|
|
|
|
|
|
|
static void
|
2012-11-25 01:55:32 -08:00
|
|
|
_ecore_signal_callback_sighup(int sig EINA_UNUSED,
|
2011-10-20 22:40:39 -07:00
|
|
|
siginfo_t *si,
|
2012-11-25 01:55:32 -08:00
|
|
|
void *foo EINA_UNUSED)
|
2011-02-01 02:21:22 -08:00
|
|
|
{
|
|
|
|
volatile sig_atomic_t n;
|
|
|
|
n = sighup_count;
|
|
|
|
if (n < MAXSIGQ)
|
|
|
|
{
|
|
|
|
if (si)
|
|
|
|
sighup_info[n] = *si;
|
|
|
|
else
|
|
|
|
sighup_info[n].si_signo = 0;
|
|
|
|
}
|
|
|
|
sighup_count++;
|
|
|
|
sig_count++;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-11-25 01:55:32 -08:00
|
|
|
_ecore_signal_callback_sigquit(int sig EINA_UNUSED,
|
2011-10-20 22:40:39 -07:00
|
|
|
siginfo_t *si,
|
2012-11-25 01:55:32 -08:00
|
|
|
void *foo EINA_UNUSED)
|
2011-02-01 02:21:22 -08:00
|
|
|
{
|
|
|
|
volatile sig_atomic_t n;
|
|
|
|
n = sigquit_count;
|
|
|
|
if (n < MAXSIGQ)
|
|
|
|
{
|
|
|
|
if (si)
|
|
|
|
sigquit_info[n] = *si;
|
|
|
|
else
|
|
|
|
sigquit_info[n].si_signo = 0;
|
|
|
|
}
|
|
|
|
sigquit_count++;
|
|
|
|
sig_count++;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-11-25 01:55:32 -08:00
|
|
|
_ecore_signal_callback_sigint(int sig EINA_UNUSED,
|
2011-10-20 22:40:39 -07:00
|
|
|
siginfo_t *si,
|
2012-11-25 01:55:32 -08:00
|
|
|
void *foo EINA_UNUSED)
|
2011-02-01 02:21:22 -08:00
|
|
|
{
|
|
|
|
volatile sig_atomic_t n;
|
|
|
|
n = sigint_count;
|
|
|
|
if (n < MAXSIGQ)
|
|
|
|
{
|
|
|
|
if (si)
|
|
|
|
sigint_info[n] = *si;
|
|
|
|
else
|
|
|
|
sigint_info[n].si_signo = 0;
|
|
|
|
}
|
|
|
|
sigint_count++;
|
|
|
|
sig_count++;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-11-25 01:55:32 -08:00
|
|
|
_ecore_signal_callback_sigterm(int sig EINA_UNUSED,
|
2011-10-20 22:40:39 -07:00
|
|
|
siginfo_t *si,
|
2012-11-25 01:55:32 -08:00
|
|
|
void *foo EINA_UNUSED)
|
2011-02-01 02:21:22 -08:00
|
|
|
{
|
|
|
|
volatile sig_atomic_t n;
|
|
|
|
n = sigterm_count;
|
|
|
|
if (n < MAXSIGQ)
|
|
|
|
{
|
|
|
|
if (si)
|
|
|
|
sigterm_info[n] = *si;
|
|
|
|
else
|
|
|
|
sigterm_info[n].si_signo = 0;
|
|
|
|
}
|
|
|
|
sigterm_count++;
|
|
|
|
sig_count++;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef SIGPWR
|
|
|
|
static void
|
2012-11-25 01:55:32 -08:00
|
|
|
_ecore_signal_callback_sigpwr(int sig EINA_UNUSED,
|
2011-10-20 22:40:39 -07:00
|
|
|
siginfo_t *si,
|
2012-11-25 01:55:32 -08:00
|
|
|
void *foo EINA_UNUSED)
|
2011-02-01 02:21:22 -08:00
|
|
|
{
|
|
|
|
volatile sig_atomic_t n;
|
|
|
|
n = sigpwr_count;
|
|
|
|
if (n < MAXSIGQ)
|
|
|
|
{
|
|
|
|
if (si)
|
|
|
|
sigpwr_info[n] = *si;
|
|
|
|
else
|
|
|
|
sigpwr_info[n].si_signo = 0;
|
|
|
|
}
|
|
|
|
sigpwr_count++;
|
|
|
|
sig_count++;
|
|
|
|
}
|
2011-10-20 22:40:39 -07:00
|
|
|
|
2011-02-01 02:21:22 -08:00
|
|
|
#endif
|
|
|
|
|
2010-06-24 09:15:56 -07:00
|
|
|
static Eina_Bool
|
2005-12-30 11:17:21 -08:00
|
|
|
_ecore_signal_exe_exit_delay(void *data)
|
|
|
|
{
|
2006-01-15 03:27:19 -08:00
|
|
|
Ecore_Exe_Event_Del *e;
|
2007-08-26 04:17:21 -07:00
|
|
|
|
2005-12-30 11:17:21 -08:00
|
|
|
e = data;
|
|
|
|
if (e)
|
2006-01-07 23:15:27 -08:00
|
|
|
{
|
2010-09-29 23:09:20 -07:00
|
|
|
_ecore_exe_doomsday_clock_set(e->exe, NULL);
|
|
|
|
_ecore_event_add(ECORE_EXE_EVENT_DEL, e,
|
|
|
|
_ecore_exe_event_del_free, NULL);
|
2006-01-07 23:15:27 -08:00
|
|
|
}
|
2010-06-24 09:15:56 -07:00
|
|
|
return ECORE_CALLBACK_CANCEL;
|
2005-12-30 11:17:21 -08:00
|
|
|
}
|
2011-10-20 22:40:39 -07:00
|
|
|
|