X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=support%2Fsignal.c;h=66f5c0ecb9045804f3283bb1b19d0adfd5947c63;hb=cac75b7d290e610827a0958f763afe9b11af3d56;hp=91d693d9d7b1c397d8d0c0fb442490cbadc91b66;hpb=0a052c2683666936c2b0c23d22078e5d628fa86c;p=mono.git diff --git a/support/signal.c b/support/signal.c index 91d693d9d7b..66f5c0ecb90 100644 --- a/support/signal.c +++ b/support/signal.c @@ -1,37 +1,408 @@ /* * wrapper functions. + * + * Authors: + * Jonathan Pryor (jonpryor@vt.edu) + * Jonathan Pryor (jpryor@novell.com) + * Tim Jenks (tim.jenks@realtimeworlds.com) + * + * Copyright (C) 2004-2005 Jonathan Pryor + * Copyright (C) 2008 Novell, Inc. */ #include +#include "map.h" #include "mph.h" +#ifndef HOST_WIN32 +#include +#include +#include +#include +#include +#include +#include +#include +#endif + G_BEGIN_DECLS -sighandler_t -Mono_Posix_Stdlib_SIG_DFL () +typedef void (*mph_sighandler_t)(int); +typedef struct Mono_Unix_UnixSignal_SignalInfo signal_info; + +static int count_handlers (int signum); + +void* +Mono_Posix_Stdlib_SIG_DFL (void) { return SIG_DFL; } -sighandler_t -Mono_Posix_Stdlib_SIG_ERR () +void* +Mono_Posix_Stdlib_SIG_ERR (void) { return SIG_ERR; } -sighandler_t -Mono_Posix_Stdlib_SIG_IGN () +void* +Mono_Posix_Stdlib_SIG_IGN (void) { return SIG_IGN; } void -Mono_Posix_Stdlib_InvokeSignalHandler (int signum, sighandler_t handler) +Mono_Posix_Stdlib_InvokeSignalHandler (int signum, void *handler) +{ + mph_sighandler_t _h = (mph_sighandler_t) handler; + _h (signum); +} + +int Mono_Posix_SIGRTMIN (void) +{ +#ifdef SIGRTMIN + return SIGRTMIN; +#else /* def SIGRTMIN */ + return -1; +#endif /* ndef SIGRTMIN */ +} + +int Mono_Posix_SIGRTMAX (void) +{ +#ifdef SIGRTMAX + return SIGRTMAX; +#else /* def SIGRTMAX */ + return -1; +#endif /* ndef SIGRTMAX */ +} + +int Mono_Posix_FromRealTimeSignum (int offset, int *r) +{ + if (NULL == r) { + errno = EINVAL; + return -1; + } + *r = 0; +#if defined (SIGRTMIN) && defined (SIGRTMAX) + if ((offset < 0) || (SIGRTMIN > SIGRTMAX - offset)) { + errno = EINVAL; + return -1; + } + *r = SIGRTMIN+offset; + return 0; +#else /* defined (SIGRTMIN) && defined (SIGRTMAX) */ +# ifdef ENOSYS + errno = ENOSYS; +# endif /* ENOSYS */ + return -1; +#endif /* defined (SIGRTMIN) && defined (SIGRTMAX) */ +} + +#ifndef HOST_WIN32 + +#ifdef WAPI_ATOMIC_ASM + #define mph_int_get(p) InterlockedExchangeAdd ((p), 0) + #define mph_int_inc(p) InterlockedIncrement ((p)) + #define mph_int_dec_test(p) (InterlockedDecrement ((p)) == 0) + #define mph_int_set(p,o,n) InterlockedExchange ((p), (n)) +#elif GLIB_CHECK_VERSION(2,4,0) + #define mph_int_get(p) g_atomic_int_get ((p)) + #define mph_int_inc(p) do {g_atomic_int_inc ((p));} while (0) + #define mph_int_dec_test(p) g_atomic_int_dec_and_test ((p)) + #define mph_int_set(p,o,n) do { \ + while (!g_atomic_int_compare_and_exchange ((p), (o), (n))) {} \ + } while (0) +#else + #define mph_int_get(p) (*(p)) + #define mph_int_inc(p) do { (*(p))++; } while (0) + #define mph_int_dec_test(p) (--(*(p)) == 0) + #define mph_int_set(p,o,n) do { *(p) = n; } while (0) +#endif + +int +Mono_Posix_Syscall_psignal (int sig, const char* s) +{ + errno = 0; + psignal (sig, s); + return errno == 0 ? 0 : -1; +} + +#define NUM_SIGNALS 64 +static signal_info signals[NUM_SIGNALS]; + +static int acquire_mutex (pthread_mutex_t *mutex) +{ + int mr; + while ((mr = pthread_mutex_lock (mutex)) == EAGAIN) { + /* try to acquire again */ + } + if ((mr != 0) && (mr != EDEADLK)) { + errno = mr; + return -1; + } + return 0; +} + +static void release_mutex (pthread_mutex_t *mutex) +{ + int mr; + while ((mr = pthread_mutex_unlock (mutex)) == EAGAIN) { + /* try to release mutex again */ + } +} + +static void +default_handler (int signum) +{ + int i; + for (i = 0; i < NUM_SIGNALS; ++i) { + int fd; + signal_info* h = &signals [i]; + if (mph_int_get (&h->signum) != signum) + continue; + mph_int_inc (&h->count); + fd = mph_int_get (&h->write_fd); + if (fd > 0) { + int j,pipecounter; + char c = signum; + pipecounter = mph_int_get (&h->pipecnt); + for (j = 0; j < pipecounter; ++j) { + int r; + do { r = write (fd, &c, 1); } while (r == -1 && errno == EINTR); + fsync (fd); /* force */ + } + } + } +} + +static pthread_mutex_t signals_mutex = PTHREAD_MUTEX_INITIALIZER; + +void* +Mono_Unix_UnixSignal_install (int sig) +{ + int i; + signal_info* h = NULL; + int have_handler = 0; + void* handler = NULL; + + if (acquire_mutex (&signals_mutex) == -1) + return NULL; + +#if defined (SIGRTMIN) && defined (SIGRTMAX) + /*The runtime uses some rt signals for itself so it's important to not override them.*/ + if (sig >= SIGRTMIN && sig <= SIGRTMAX && count_handlers (sig) == 0) { + struct sigaction sinfo; + sigaction (sig, NULL, &sinfo); + if (sinfo.sa_handler != SIG_DFL || (void*)sinfo.sa_sigaction != (void*)SIG_DFL) { + pthread_mutex_unlock (&signals_mutex); + errno = EADDRINUSE; + return NULL; + } + } +#endif /*defined (SIGRTMIN) && defined (SIGRTMAX)*/ + + for (i = 0; i < NUM_SIGNALS; ++i) { + if (h == NULL && signals [i].signum == 0) { + h = &signals [i]; + h->handler = signal (sig, default_handler); + if (h->handler == SIG_ERR) { + h->handler = NULL; + h = NULL; + break; + } + else { + h->have_handler = 1; + } + } + if (!have_handler && signals [i].signum == sig && + signals [i].handler != default_handler) { + have_handler = 1; + handler = signals [i].handler; + } + if (h && have_handler) + break; + } + + if (h && have_handler) { + h->have_handler = 1; + h->handler = handler; + } + + if (h) { + mph_int_set (&h->count, h->count, 0); + mph_int_set (&h->signum, h->signum, sig); + mph_int_set (&h->pipecnt, h->pipecnt, 0); + } + + release_mutex (&signals_mutex); + + return h; +} + +static int +count_handlers (int signum) +{ + int i; + int count = 0; + for (i = 0; i < NUM_SIGNALS; ++i) { + if (signals [i].signum == signum) + ++count; + } + return count; +} + +int +Mono_Unix_UnixSignal_uninstall (void* info) +{ + signal_info* h; + int r = -1; + + if (acquire_mutex (&signals_mutex) == -1) + return -1; + + h = info; + + if (h == NULL || h < signals || h > &signals [NUM_SIGNALS]) + errno = EINVAL; + else { + /* last UnixSignal -- we can unregister */ + if (h->have_handler && count_handlers (h->signum) == 1) { + mph_sighandler_t p = signal (h->signum, h->handler); + if (p != SIG_ERR) + r = 0; + h->handler = NULL; + h->have_handler = 0; + } + h->signum = 0; + } + + release_mutex (&signals_mutex); + + return r; +} + +static int +setup_pipes (signal_info** signals, int count, struct pollfd *fd_structs, int *currfd) +{ + int i; + int r = 0; + for (i = 0; i < count; ++i) { + signal_info* h; + int filedes[2]; + + h = signals [i]; + + if (mph_int_get (&h->pipecnt) == 0) { + if ((r = pipe (filedes)) != 0) { + break; + } + h->read_fd = filedes [0]; + h->write_fd = filedes [1]; + } + mph_int_inc (&h->pipecnt); + fd_structs[*currfd].fd = h->read_fd; + fd_structs[*currfd].events = POLLIN; + ++(*currfd); + } + return r; +} + +static void +teardown_pipes (signal_info** signals, int count) +{ + int i; + for (i = 0; i < count; ++i) { + signal_info* h = signals [i]; + + if (mph_int_dec_test (&h->pipecnt)) { + if (h->read_fd != 0) + close (h->read_fd); + if (h->write_fd != 0) + close (h->write_fd); + h->read_fd = 0; + h->write_fd = 0; + } + } +} + +static int +wait_for_any (signal_info** signals, int count, int *currfd, struct pollfd* fd_structs, int timeout) +{ + int r, idx; + do { + struct timeval tv; + struct timeval *ptv = NULL; + if (timeout != -1) { + tv.tv_sec = timeout / 1000; + tv.tv_usec = (timeout % 1000)*1000; + ptv = &tv; + } + r = poll (fd_structs, count, timeout); + } while (r == -1 && errno == EINTR); + + idx = -1; + if (r == 0) + idx = timeout; + else if (r > 0) { + int i; + for (i = 0; i < count; ++i) { + signal_info* h = signals [i]; + if (fd_structs[i].revents & POLLIN) { + int r; + char c; + do { + r = read (h->read_fd, &c, 1); + } while (r == -1 && errno == EINTR); + if (idx == -1) + idx = i; + } + } + } + + return idx; +} + +/* + * returns: -1 on error: + * timeout on timeout + * index into _signals array of signal that was generated on success + */ +int +Mono_Unix_UnixSignal_WaitAny (void** _signals, int count, int timeout /* milliseconds */) { - handler (signum); + int r; + int currfd = 0; + struct pollfd fd_structs[NUM_SIGNALS]; + + signal_info** signals = (signal_info**) _signals; + + if (count > NUM_SIGNALS) + return -1; + + if (acquire_mutex (&signals_mutex) == -1) + return -1; + + r = setup_pipes (signals, count, &fd_structs[0], &currfd); + + release_mutex (&signals_mutex); + + if (r == 0) { + r = wait_for_any (signals, count, &currfd, &fd_structs[0], timeout); + } + + if (acquire_mutex (&signals_mutex) == -1) + return -1; + + teardown_pipes (signals, count); + + release_mutex (&signals_mutex); + + return r; } +#endif /* ndef HOST_WIN32 */ + + G_END_DECLS /*