2000-10-10 Ross Johnson <rpj@setup1.ise.canberra.edu.au>

        * misc.c (pthread_self): Restore Win32 "last error"
        cleared by TlsGetValue() call in
        pthread_getspecific()
        - "Steven Reddie" <smr@essemer.com.au>

2000-09-20  Ross Johnson  <rpj@setup1.ise.canberra.edu.au>

        * mutex.c (pthread_mutex_lock): Record the owner
        of the mutex. This requires also keeping count of
        recursive locks ourselves rather than leaving it
        to Win32 since we need to know when to NULL the
        thread owner when the mutex is unlocked.
        (pthread_mutex_trylock): Likewise.
        (pthread_mutex_unlock): Check that the calling
        thread owns the mutex, decrement the recursive
        lock count, and NULL the owner if zero. Return
        EPERM if the mutex is owned by another thread.
        * implement.h (pthread_mutex_t_): Add ownerThread
        and lockCount members.
        - reported by Arthur Kantor <akantor@bexusa.com>

1 files changed, 74 insertions, 2 deletions

diff --git a/signal.c b/signal.c
index ba0edeb..75bec84 100644
--- a/signal.c
+++ b/signal.c
@@ -23,13 +23,68 @@
  * MA 02111-1307, USA
  */
 
-/* errno.h or a replacement file is included by pthread.h */
-//#include <errno.h>
+/*
+ * Strategy for implementing pthread_kill()
+ * ========================================
+ *
+ * Win32 does not implement signals.
+ * Signals are simply software interrupts.
+ * pthread_kill() asks the system to deliver a specified
+ * signal (interrupt) to a specified thread in the same
+ * process.
+ * Signals are always asynchronous (no deferred signals).
+ * Pthread-win32 has an async cancelation mechanism.
+ * A similar system can be written to deliver signals
+ * within the same process (on ix86 processors at least).
+ *
+ * Each thread maintains information about which
+ * signals it will respond to. Handler routines
+ * are set on a per-process basis - not per-thread.
+ * When signalled, a thread will check it's sigmask
+ * and, if the signal is not being ignored, call the
+ * handler routine associated with the signal. The
+ * thread must then (except for some signals) return to
+ * the point where it was interrupted.
+ *
+ * Ideally the system itself would check the target thread's
+ * mask before possibly needlessly bothering the thread
+ * itself. This could be done by pthread_kill(), that is,
+ * in the signaling thread since it has access to
+ * all pthread_t structures. It could also retrieve
+ * the handler routine address to minimise the target
+ * threads response overhead. This may also simplify
+ * serialisation of the access to the per-thread signal
+ * structures.
+ *
+ * pthread_kill() eventually calls a routine similar to
+ * ptw32_cancel_thread() which manipulates the target
+ * threads processor context to cause the thread to
+ * run the handler launcher routine. pthread_kill() must
+ * save the target threads current context so that the
+ * handler launcher routine can restore the context after
+ * the signal handler has returned. Some handlers will not
+ * return, eg. the default SIGKILL handler may simply
+ * call pthread_exit().
+ *
+ * The current context is saved in the target threads
+ * pthread_t structure.
+ */
 
 #include "pthread.h"
 #include "implement.h"
 
 #if HAVE_SIGSET_T
+
+static void
+ptw32_signal_thread()
+{
+}
+
+static void
+ptw32_signal_callhandler()
+{
+}
+
 int
 pthread_sigmask(int how, sigset_t const *set, sigset_t *oset)
 {
@@ -97,4 +152,21 @@ pthread_sigmask(int how, sigset_t const *set, sigset_t *oset)
 
   return 0;
 }
+
+int pthread_kill(pthread_t thread,
+		 int signo)
+{
+}
+
+int sigwait(const sigset_t *set,
+	    int *sig)
+{
+}
+
+int sigaction(int signum,
+	      const  struct  sigaction  *act,
+	      struct sigaction *oldact)
+{
+}
+
 #endif /* HAVE_SIGSET_T */