X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=support%2Fsignal.c;h=993e2e216618b3c0aa0a9773707f48eef836873d;hb=01df432af43ed3dd9a225b13e0ebcce9a8a34a5a;hp=d995fa970d318612b800ca76430ee0aa767f8b8b;hpb=a9be24c5cdb9e0f6a48dc634ffcf3ad70954fe3e;p=mono.git diff --git a/support/signal.c b/support/signal.c index d995fa970d3..993e2e21661 100644 --- a/support/signal.c +++ b/support/signal.c @@ -4,6 +4,7 @@ * 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. @@ -14,13 +15,20 @@ #include "map.h" #include "mph.h" -#ifndef PLATFORM_WIN32 +#ifndef HOST_WIN32 #include #include +#if defined(HAVE_POLL_H) +#include +#elif defined(HAVE_SYS_POLL_H) +#include +#endif #include #include #include #include +#include +#include #endif G_BEGIN_DECLS @@ -28,6 +36,10 @@ G_BEGIN_DECLS typedef void (*mph_sighandler_t)(int); typedef struct Mono_Unix_UnixSignal_SignalInfo signal_info; +#ifndef HOST_WIN32 +static int count_handlers (int signum); +#endif + void* Mono_Posix_Stdlib_SIG_DFL (void) { @@ -53,8 +65,73 @@ Mono_Posix_Stdlib_InvokeSignalHandler (int signum, void *handler) _h (signum); } -#ifndef PLATFORM_WIN32 +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 + +// Atomicity rules: Fields of signal_info read or written by the signal handler +// (see UnixSignal.cs) should be read and written using atomic functions. +// (For simplicity, we're protecting some things we don't strictly need to.) + +// Because we are in MonoPosixHelper, we are banned from linking mono. +// We can still use atomic.h because that's all inline functions-- +// unless WAPI_NO_ATOMIC_ASM is defined, in which case atomic.h calls linked functions. +#ifndef WAPI_NO_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,n) InterlockedExchange ((p), (n)) + // Pointer, original, new + #define mph_int_test_and_set(p,o,n) (o == InterlockedCompareExchange ((p), (n), (o))) +#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,n) g_atomic_int_set ((p),(n)) + #define mph_int_test_and_set(p,o,n) g_atomic_int_compare_and_exchange ((p), (o), (n)) +#else + #error "GLIB 2.4 required because building without ASM atomics" +#endif +#if HAVE_PSIGNAL int Mono_Posix_Syscall_psignal (int sig, const char* s) { @@ -62,10 +139,122 @@ Mono_Posix_Syscall_psignal (int sig, const char* s) psignal (sig, s); return errno == 0 ? 0 : -1; } +#endif /* def HAVE_PSIGNAL */ #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 inline int +keep_trying (int r) +{ + return r == -1 && errno == EINTR; +} + +// This tiny ad-hoc read/write lock is needed because of the very specific +// synchronization needed between default_handler and teardown_pipes: +// - Many default_handlers can be running at once +// - The signals_mutex already ensures only one teardown_pipes runs at once +// - If teardown_pipes starts while a default_handler is ongoing, it must block +// - If default_handler starts while a teardown_pipes is ongoing, it must *not* block +// Locks are implemented as ints. + +// The lock is split into a teardown bit and a handler count (sign bit unused). +// There is a teardown running or waiting to run if the teardown bit is set. +// There is a handler running if the handler count is nonzero. +#define PIPELOCK_TEARDOWN_BIT ( (int)0x40000000 ) +#define PIPELOCK_COUNT_MASK (~((int)0xC0000000)) +#define PIPELOCK_GET_COUNT(x) ((x) & PIPELOCK_COUNT_MASK) +#define PIPELOCK_INCR_COUNT(x, by) (((x) & PIPELOCK_TEARDOWN_BIT) | (PIPELOCK_GET_COUNT (PIPELOCK_GET_COUNT (x) + (by)))) + +static inline void +acquire_pipelock_teardown (int *lock) +{ + int lockvalue_draining; + // First mark that a teardown is occurring, so handlers will stop entering the lock. + while (1) { + int lockvalue = mph_int_get (lock); + lockvalue_draining = lockvalue | PIPELOCK_TEARDOWN_BIT; + if (mph_int_test_and_set (lock, lockvalue, lockvalue_draining)) + break; + } + // Now wait for all handlers to complete. + while (1) { + if (0 == PIPELOCK_GET_COUNT (lockvalue_draining)) + break; // We now hold the lock. + // Handler is still running, spin until it completes. + sched_yield (); // We can call this because !defined(HOST_WIN32) + lockvalue_draining = mph_int_get (lock); + } +} + +static inline void +release_pipelock_teardown (int *lock) +{ + while (1) { + int lockvalue = mph_int_get (lock); + int lockvalue_new = lockvalue & ~PIPELOCK_TEARDOWN_BIT; + // Technically this can't fail, because we hold both the pipelock and the mutex, but + if (mph_int_test_and_set (lock, lockvalue, lockvalue_new)) + return; + } +} + +// Return 1 for success +static inline int +acquire_pipelock_handler (int *lock) +{ + while (1) { + int lockvalue = mph_int_get (lock); + if (lockvalue & PIPELOCK_TEARDOWN_BIT) // Final lock is being torn down + return 0; + int lockvalue_new = PIPELOCK_INCR_COUNT (lockvalue, 1); + if (mph_int_test_and_set (lock, lockvalue, lockvalue_new)) + return 1; + } +} + +static inline void +release_pipelock_handler (int *lock) +{ + while (1) { + int lockvalue = mph_int_get (lock); + int lockvalue_new = PIPELOCK_INCR_COUNT (lockvalue, -1); + if (mph_int_test_and_set (lock, lockvalue, lockvalue_new)) + return; + } +} + +// This handler is registered once for each UnixSignal object. A pipe is maintained +// for each one; Wait users read at one end of this pipe, and default_handler sends +// a write on the pipe for each signal received while the Wait is ongoing. +// +// Notice a fairly unlikely race condition exists here: Because we synchronize with +// pipe teardown, but not install/uninstall (in other words, we are only trying to +// protect against writing on a closed pipe) it is technically possible a full +// uninstall and then an install could complete after signum is checked but before +// the remaining instructions execute. In this unlikely case count could be +// incremented or a byte written on the wrong signal handler. static void default_handler (int signum) { @@ -73,35 +262,61 @@ default_handler (int signum) for (i = 0; i < NUM_SIGNALS; ++i) { int fd; signal_info* h = &signals [i]; - if (g_atomic_int_get (&h->signum) != signum) + if (mph_int_get (&h->signum) != signum) continue; - g_atomic_int_inc (&h->count); - fd = g_atomic_int_get (&h->write_fd); - if (fd > 0) { - char c = signum; - write (fd, &c, 1); + + mph_int_inc (&h->count); + + if (!acquire_pipelock_handler (&h->pipelock)) + continue; // Teardown is occurring on this object, no one to send to. + + fd = mph_int_get (&h->write_fd); + if (fd > 0) { // If any listener exists to write to + int j,pipecounter; + char c = signum; // (Value is meaningless) + pipecounter = mph_int_get (&h->pipecnt); // Write one byte per pipe listener + for (j = 0; j < pipecounter; ++j) { + int r; + do { r = write (fd, &c, 1); } while (keep_trying (r)); + } } + release_pipelock_handler (&h->pipelock); } } static pthread_mutex_t signals_mutex = PTHREAD_MUTEX_INITIALIZER; +// A UnixSignal object is being constructed void* Mono_Unix_UnixSignal_install (int sig) { - int i, mr; - signal_info* h = NULL; - int have_handler = 0; - void* handler; +#if defined(HAVE_SIGNAL) + int i; + signal_info* h = NULL; // signals[] slot to install to + int have_handler = 0; // Candidates for signal_info handler fields + void* handler = NULL; - mr = pthread_mutex_lock (&signals_mutex); - if (mr != 0) { - errno = mr; + 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; // This is an rt signal with an existing handler. Bail out. + } } +#endif /*defined (SIGRTMIN) && defined (SIGRTMAX)*/ + // Scan through signals list looking for (1) an unused spot (2) a usable value for handler for (i = 0; i < NUM_SIGNALS; ++i) { - if (h == NULL && signals [i].signum == 0) { + int just_installed = 0; + // We're still looking for a signal_info spot, and this one is available: + if (h == NULL && mph_int_get (&signals [i].signum) == 0) { h = &signals [i]; h->handler = signal (sig, default_handler); if (h->handler == SIG_ERR) { @@ -110,31 +325,41 @@ Mono_Unix_UnixSignal_install (int sig) break; } else { - h->have_handler = 1; + just_installed = 1; } } - if (!have_handler && signals [i].signum == sig && + // Check if this slot has a "usable" (not installed by this file) handler-to-restore-later: + // (On the first signal to be installed, signals [i] will be == h when this happens.) + if (!have_handler && (just_installed || mph_int_get (&signals [i].signum) == sig) && signals [i].handler != default_handler) { have_handler = 1; handler = signals [i].handler; } - if (h && have_handler) + if (h && have_handler) // We have everything we need break; } - if (h && have_handler) { + if (h) { + // If we reached here without have_handler, this means that default_handler + // was set as the signal handler before the first UnixSignal object was installed. + g_assert (have_handler); + + // Overwrite the tenative handler we set a moment ago with a known-usable one + h->handler = handler; h->have_handler = 1; - h->handler = handler; - } - if (h) { - g_atomic_int_set (&h->count, 0); - g_atomic_int_set (&h->signum, sig); + mph_int_set (&h->count, 0); + mph_int_set (&h->pipecnt, 0); + mph_int_set (&h->signum, sig); } - pthread_mutex_unlock (&signals_mutex); + release_mutex (&signals_mutex); return h; +#else + g_error ("signal() is not supported by this platform"); + return 0; +#endif } static int @@ -143,23 +368,22 @@ count_handlers (int signum) int i; int count = 0; for (i = 0; i < NUM_SIGNALS; ++i) { - if (signals [i].signum == signum) + if (mph_int_get (&signals [i].signum) == signum) ++count; } return count; } +// A UnixSignal object is being Disposed int Mono_Unix_UnixSignal_uninstall (void* info) { +#if defined(HAVE_SIGNAL) signal_info* h; - int mr, r = -1; + int r = -1; - mr = pthread_mutex_lock (&signals_mutex); - if (mr != 0) { - errno = mr; + if (acquire_mutex (&signals_mutex) == -1) return -1; - } h = info; @@ -167,61 +391,83 @@ Mono_Unix_UnixSignal_uninstall (void* info) 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); + int signum = mph_int_get (&h->signum); + if (h->have_handler && count_handlers (signum) == 1) { + mph_sighandler_t p = signal (signum, h->handler); if (p != SIG_ERR) r = 0; h->handler = NULL; h->have_handler = 0; } - h->signum = 0; + mph_int_set (&h->signum, 0); } - pthread_mutex_unlock (&signals_mutex); + release_mutex (&signals_mutex); return r; +#else + g_error ("signal() is not supported by this platform"); + return 0; +#endif } +// Set up a signal_info to begin waiting for signal static int -setup_pipes (signal_info** signals, int count, fd_set *read_fds, int *max_fd) +setup_pipes (signal_info** signals, int count, struct pollfd *fd_structs, int *currfd) { - int i, r; + int i; + int r = 0; for (i = 0; i < count; ++i) { signal_info* h; int filedes[2]; - if ((r = pipe (filedes)) != 0) { - break; - } h = signals [i]; - h->read_fd = filedes [0]; - h->write_fd = filedes [1]; - if (h->read_fd > *max_fd) - *max_fd = h->read_fd; - FD_SET (h->read_fd, read_fds); + + if (mph_int_get (&h->pipecnt) == 0) { // First listener for this signal_info + if ((r = pipe (filedes)) != 0) { + break; + } + mph_int_set (&h->read_fd, filedes [0]); + mph_int_set (&h->write_fd, filedes [1]); + } + mph_int_inc (&h->pipecnt); + fd_structs[*currfd].fd = mph_int_get (&h->read_fd); + fd_structs[*currfd].events = POLLIN; + ++(*currfd); // count is verified less than NUM_SIGNALS by caller } return r; } +// Cleanup a signal_info after waiting for signal static void teardown_pipes (signal_info** signals, int count) { int i; for (i = 0; i < count; ++i) { signal_info* h = signals [i]; - 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; + + if (mph_int_dec_test (&h->pipecnt)) { // Final listener for this signal_info + acquire_pipelock_teardown (&h->pipelock); + int read_fd = mph_int_get (&h->read_fd); + int write_fd = mph_int_get (&h->write_fd); + if (read_fd != 0) + close (read_fd); + if (write_fd != 0) + close (write_fd); + mph_int_set (&h->read_fd, 0); + mph_int_set (&h->write_fd, 0); + release_pipelock_teardown (&h->pipelock); + } } } +// Given pipes set up, wait for a byte to arrive on one of them static int -wait_for_any (signal_info** signals, int count, int max_fd, fd_set* read_fds, int timeout) +wait_for_any (signal_info** signals, int count, int *currfd, struct pollfd* fd_structs, int timeout, Mono_Posix_RuntimeIsShuttingDown shutting_down) { - int r; + int r, idx; + // Poll until one of this signal_info's pipes is ready to read. + // Once a second, stop to check if the VM is shutting down. do { struct timeval tv; struct timeval *ptv = NULL; @@ -230,58 +476,70 @@ wait_for_any (signal_info** signals, int count, int max_fd, fd_set* read_fds, in tv.tv_usec = (timeout % 1000)*1000; ptv = &tv; } + r = poll (fd_structs, count, timeout); + } while (keep_trying (r) && !shutting_down ()); - r = select (max_fd + 1, read_fds, NULL, NULL, ptv); - } while (r == -1 && errno == EINTR); - - if (r > 0) { + idx = -1; + if (r == 0) + idx = timeout; + else if (r > 0) { // The pipe[s] are ready to read. int i; for (i = 0; i < count; ++i) { signal_info* h = signals [i]; - if (FD_ISSET (h->read_fd, read_fds)) { + if (fd_structs[i].revents & POLLIN) { + int r; char c; - read (h->read_fd, &c, 1); /* ignore error */ + do { + r = read (mph_int_get (&h->read_fd), &c, 1); + } while (keep_trying (r) && !shutting_down ()); + if (idx == -1) + idx = i; } } } - return r; + return idx; } /* * returns: -1 on error: - * 0 on timeout - * > 0 on success + * 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 */) +Mono_Unix_UnixSignal_WaitAny (void** _signals, int count, int timeout /* milliseconds */, Mono_Posix_RuntimeIsShuttingDown shutting_down) { - fd_set read_fds; - int mr, r; - int max_fd = 0; + int r; + int currfd = 0; + struct pollfd fd_structs[NUM_SIGNALS]; signal_info** signals = (signal_info**) _signals; - mr = pthread_mutex_lock (&signals_mutex); - if (mr != 0) { - errno = mr; + if (count > NUM_SIGNALS) return -1; - } - FD_ZERO (&read_fds); + if (acquire_mutex (&signals_mutex) == -1) + return -1; + + r = setup_pipes (signals, count, &fd_structs[0], &currfd); + + release_mutex (&signals_mutex); - r = setup_pipes (signals, count, &read_fds, &max_fd); if (r == 0) { - r = wait_for_any (signals, count, max_fd, &read_fds, timeout); + r = wait_for_any (signals, count, &currfd, &fd_structs[0], timeout, shutting_down); } + + if (acquire_mutex (&signals_mutex) == -1) + return -1; + teardown_pipes (signals, count); - pthread_mutex_unlock (&signals_mutex); + release_mutex (&signals_mutex); return r; } -#endif /* ndef PLATFORM_WIN32 */ +#endif /* ndef HOST_WIN32 */ G_END_DECLS