From: Jonathan Pryor Date: Mon, 4 Feb 2008 13:59:28 +0000 (-0000) Subject: * signal.c: Provide support functions for Mono.Unix.UnixSignal, which X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=commitdiff_plain;h=e6832b669b239509bb752eb679473ae13608e7d3;p=mono.git * 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 3ea48ffbf6e..0d65badbf8c 100644 --- a/support/ChangeLog +++ b/support/ChangeLog @@ -1,3 +1,9 @@ +2008-01-28 Jonathan Pryor + + * 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 * 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 ec9ee9521c9..c8fc8ece817 100644 --- 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 6f7305ade0f..89509aa06e0 100644 --- 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 +#ifndef PLATFORM_WIN32 +#include +#include +#include +#include +#include +#include +#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 */