* signal.c: Provide support functions for Mono.Unix.UnixSignal, which

	  supports both polling and waiting on signal emission.
	* map.h: Flush (adds UnixSignal-related prototypes).

svn path=/trunk/mono/; revision=94743

diff --git a/support/ChangeLog b/support/ChangeLog
index 3ea48ffbf6ea4d2b3acf92b3ec584f8675a69037..0d65badbf8ceb96c63968b2fc4803cf765081b07 100644 (file)
--- a/support/ChangeLog
+++ b/support/ChangeLog
@@ -1,3 +1,9 @@
+2008-01-28  Jonathan Pryor  <jpryor@novell.com>
+
+       * signal.c: Provide support functions for Mono.Unix.UnixSignal, which 
+         supports both polling and waiting on signal emission.
+       * map.h: Flush (adds UnixSignal-related prototypes).
+
 2008-01-05  Jonathan Pryor  <jpryor@novell.com>
 
        * map.h, map.c: Flush; add new ST_NOEXEC, ST_REMOUNT, and ST_BIND MountFlags 

diff --git a/support/map.h b/support/map.h
index ec9ee9521c9226da52f66280c2edc0e0ca54fac7..c8fc8ece8173f5868bd329d7fadf44e44f4fcad2 100644 (file)
--- a/support/map.h
+++ b/support/map.h
@@ -1382,6 +1382,7 @@ struct Mono_Posix_Syscall__Utsname;
 struct Mono_Posix_Timeval;
 struct Mono_Posix_Timezone;
 struct Mono_Posix_Utimbuf;
+struct Mono_Unix_UnixSignal_SignalInfo;
 
 /*
  * Inferred Structure Declarations
@@ -1541,6 +1542,15 @@ int
 Mono_Posix_ToUtimbuf (struct utimbuf *from, struct Mono_Posix_Utimbuf* to);
 
 
+struct Mono_Unix_UnixSignal_SignalInfo {
+       int   signum;
+       int   count;
+       int   read_fd;
+       int   write_fd;
+       int   have_handler;
+       void* handler;
+};
+
 
 /*
  * Functions
@@ -1706,6 +1716,9 @@ gint64 Mono_Posix_Syscall_write (int fd, void* buf, guint64 count);
 int Mono_Posix_Syscall_WSTOPSIG (int status);
 int Mono_Posix_Syscall_WTERMSIG (int status);
 int Mono_Posix_ToStatvfs (void* source, struct Mono_Posix_Statvfs* destination);
+void* Mono_Unix_UnixSignal_install (int signum);
+int Mono_Unix_UnixSignal_uninstall (void* info);
+int Mono_Unix_UnixSignal_WaitAny (void** infos, int count, int timeout);
 int wexitstatus (int status);
 int wifexited (int status);
 int wifsignaled (int status);

diff --git a/support/signal.c b/support/signal.c
index 6f7305ade0fe8867a3d715f905e9f17fef9d84a5..89509aa06e001b216fe42502f5d248b6086b8806 100644 (file)
--- a/support/signal.c
+++ b/support/signal.c
@@ -3,18 +3,30 @@
  *
  * Authors:
  *   Jonathan Pryor (jonpryor@vt.edu)
+ *   Jonathan Pryor (jpryor@novell.com)
  *
  * Copyright (C) 2004-2005 Jonathan Pryor
+ * Copyright (C) 2008 Novell, Inc.
  */
 
 #include <signal.h>
 
+#ifndef PLATFORM_WIN32
+#include <sys/time.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <pthread.h>
+#endif
+
 #include "map.h"
 #include "mph.h"
 
 G_BEGIN_DECLS
 
 typedef void (*mph_sighandler_t)(int);
+typedef struct Mono_Unix_UnixSignal_SignalInfo signal_info;
 
 void*
 Mono_Posix_Stdlib_SIG_DFL (void)
@@ -42,6 +54,7 @@ Mono_Posix_Stdlib_InvokeSignalHandler (int signum, void *handler)
 }
 
 #ifndef PLATFORM_WIN32
+
 int
 Mono_Posix_Syscall_psignal (int sig, const char* s)
 {
@@ -49,6 +62,220 @@ Mono_Posix_Syscall_psignal (int sig, const char* s)
        psignal (sig, s);
        return errno == 0 ? 0 : -1;
 }
+
+#define NUM_SIGNALS 64
+static signal_info signals[NUM_SIGNALS];
+
+static void
+default_handler (int signum)
+{
+       int i;
+       for (i = 0; i < NUM_SIGNALS; ++i) {
+               signal_info* h = &signals [i];
+               if (h->signum != signum)
+                       continue;
+               ++h->count;
+               if (h->write_fd > 0) {
+                       char c = signum;
+                       write (h->write_fd, &c, 1);
+               }
+       }
+}
+
+static pthread_mutex_t signals_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+void*
+Mono_Unix_UnixSignal_install (int sig)
+{
+       int i, mr;
+       signal_info* h = NULL; 
+       int have_handler = 0;
+       void* handler;
+
+       mr = pthread_mutex_lock (&signals_mutex);
+       if (mr != 0) {
+               errno = mr;
+               return NULL;
+       }
+
+       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->signum       = sig;
+                               h->count        = 0;
+                               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;
+       }
+
+       pthread_mutex_unlock (&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 mr, r = -1;
+
+       mr = pthread_mutex_lock (&signals_mutex);
+       if (mr != 0) {
+               errno = mr;
+               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;
+       }
+
+       pthread_mutex_unlock (&signals_mutex);
+
+       return r;
+}
+
+static int
+setup_pipes (signal_info** signals, int count, fd_set *read_fds, int *max_fd)
+{
+       int i, r;
+       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);
+       }
+       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 (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 max_fd, fd_set* read_fds, int timeout)
+{
+       int r;
+       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 = select (max_fd + 1, read_fds, NULL, NULL, ptv);
+       } while (r == -1 && errno == EINTR);
+
+       if (r > 0) {
+               int i;
+               for (i = 0; i < count; ++i) {
+                       signal_info* h = signals [i];
+                       if (FD_ISSET (h->read_fd, read_fds)) {
+                               char c;
+                               read (h->read_fd, &c, 1); /* ignore error */
+                       }
+               }
+       }
+
+       return r;
+}
+
+/*
+ * returns: -1 on error:
+ *           0 on timeout
+ *         > 0 on success
+ */
+int
+Mono_Unix_UnixSignal_WaitAny (void** _signals, int count, int timeout /* milliseconds */)
+{
+       fd_set read_fds;
+       int mr, r;
+       int max_fd = 0;
+
+       signal_info** signals = (signal_info**) _signals;
+
+       mr = pthread_mutex_lock (&signals_mutex);
+       if (mr != 0) {
+               errno = mr;
+               return -1;
+       }
+
+       FD_ZERO (&read_fds);
+
+       r = setup_pipes (signals, count, &read_fds, &max_fd);
+       if (r == 0) {
+               r = wait_for_any (signals, count, max_fd, &read_fds, timeout);
+       }
+       teardown_pipes (signals, count);
+
+       pthread_mutex_unlock (&signals_mutex);
+
+       return r;
+}
+
 #endif /* ndef PLATFORM_WIN32 */