+#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)
+{
+ 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);
+
+ 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)
+{
+#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;
+
+ 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) {
+ 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) {
+ h->handler = NULL;
+ h = NULL;
+ break;
+ }
+ else {
+ just_installed = 1;
+ }
+ }
+ // 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) // We have everything we need
+ break;
+ }
+
+ 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;
+
+ mph_int_set (&h->count, 0);
+ mph_int_set (&h->pipecnt, 0);
+ mph_int_set (&h->signum, sig);
+ }
+
+ release_mutex (&signals_mutex);
+
+ return h;
+#else
+ g_error ("signal() is not supported by this platform");
+ return 0;
+#endif
+}
+
+static int
+count_handlers (int signum)
+{
+ int i;
+ int count = 0;
+ for (i = 0; i < NUM_SIGNALS; ++i) {
+ 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 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 */
+ 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;
+ }
+ mph_int_set (&h->signum, 0);
+ }
+
+ 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, 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) { // 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 (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 *currfd, struct pollfd* fd_structs, int timeout, Mono_Posix_RuntimeIsShuttingDown shutting_down)
+{
+ 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;
+ if (timeout != -1) {
+ tv.tv_sec = timeout / 1000;
+ tv.tv_usec = (timeout % 1000)*1000;
+ ptv = &tv;
+ }
+ r = poll (fd_structs, count, timeout);
+ } while (keep_trying (r) && !shutting_down ());
+
+ 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_structs[i].revents & POLLIN) {
+ int r;
+ char c;
+ do {
+ r = read (mph_int_get (&h->read_fd), &c, 1);
+ } while (keep_trying (r) && !shutting_down ());
+ 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 */, Mono_Posix_RuntimeIsShuttingDown shutting_down)
+{
+ 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, shutting_down);
+ }
+
+ if (acquire_mutex (&signals_mutex) == -1)
+ return -1;
+
+ teardown_pipes (signals, count);
+
+ release_mutex (&signals_mutex);
+
+ return r;
+}
+
+#endif /* ndef HOST_WIN32 */