Added the thread wrapper module.

1 files changed, 159 insertions, 0 deletions

diff --git a/thread_wrapper/thread_wrapper.c b/thread_wrapper/thread_wrapper.c
new file mode 100644
index 0000000..86eaa3b
--- /dev/null
+++ b/thread_wrapper/thread_wrapper.c
@@ -0,0 +1,159 @@
+// Ada Milter API thread wrapper
+// Copyright 2013 B. Persson, Bjorn@Rombobeorn.se
+//
+// This library is free software: you can redistribute it and/or modify it
+// under the terms of the GNU General Public License version 3, as published
+// by the Free Software Foundation.
+
+
+// This module wraps any threads that are started from anywhere in the program,
+// making them call GNAT.Threads.Register_Thread when they start and
+// GNAT.Threads.Unregister_Thread when they terminate. Although Libgnat
+// registers foreign threads automatically on GNU/Linux, it leaks memory when
+// the threads terminate. Calling Unregister_Thread plugs the leak.
+//
+// Initially nothing special is done to threads, so that Ada tasks such as
+// Libgnat's Interrupt_Manager task can be started during elaboration, even
+// before Libgnat is ready to handle calls to Register_Thread. The wrapping
+// begins after start_wrapping_threads is called.
+//
+// To make the wrapping of threads possible this module contains a function
+// named pthread_create which will be called instead of the one in the Pthreads
+// library. This function in turn calls the real pthread_create, but instructs
+// it to have the thread run the thread start routine wrap_thread instead of
+// its normal start routine. wrap_thread calls Register_Thread, arranges for
+// Unregister_Thread to be called when the thread terminates, and then calls
+// the normal start routine.
+//
+// For this to work the Pthreads library must be linked in dynamically, but
+// this module must be statically linked into the main executable to ensure
+// that this pthread_create is found before the one in the Pthreads library.
+
+
+#include "pthread_create_locator.h"
+
+#include <dlfcn.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <syslog.h>
+#include <errno.h>
+
+// declarations copied from g-thread.ads:
+
+extern void *__gnat_register_thread();
+
+extern void __gnat_unregister_thread();
+
+
+typedef struct thread_data {
+   void* (*start_routine)(void*);
+   void* arg;
+} thread_data;
+// A thread_data object holds a thread start routine and an argument to be
+// passed to it.
+
+static int (*real_pthread_create)(pthread_t*, const pthread_attr_t*,
+                                  void* (*)(void*), void*) = NULL;
+
+static bool wrap_threads = false;
+
+
+void start_wrapping_threads()
+   // start_wrapping_threads shall be called before any threads that need
+   // wrapping are started, but after tasking packages have been elaborated so
+   // that Libgnat is ready to handle calls to Register_Thread.
+{
+   wrap_threads = true;
+}
+
+
+static void cleanup_handler(void* const dummy  __attribute__ ((unused)))
+   // cleanup_handler is a wrapper around Unregister_Thread. It exists because
+   // clean-up handlers are specified to take a void pointer argument and
+   // Unregister_Thread doesn't expect one.
+{
+   __gnat_unregister_thread();
+}
+
+
+static void* wrap_thread(void* const wrapped_thread_data)
+   // wrap_thread is the thread start routine of all wrapped threads. It
+   // performs the wrapping and calls the routine that wrapped_thread_data
+   // holds.
+{
+   // Copy the argument to a local variable and deallocate it so that it won't
+   // leak regardless of how the thread terminates.
+   const thread_data wrapped = *(thread_data*)wrapped_thread_data;
+   void*             output;
+
+   free(wrapped_thread_data);
+   // Register the thread and set up a clean-up handler to unregister it. The
+   // clean-up handler will be called regardless of how the thread terminates,
+   // except if the thread sets its cancelability type to asynchronous, which
+   // would be quite wrong for a thread that doesn't have intimate knowledge of
+   // all the code it executes.
+   __gnat_register_thread();
+   pthread_cleanup_push(cleanup_handler, NULL);
+      // Execute the wrapped thread.
+      output = wrapped.start_routine(wrapped.arg);
+   pthread_cleanup_pop(true);
+   return output;
+}
+
+
+int pthread_create(pthread_t* const thread, const pthread_attr_t* const attr,
+                   void* (* const start_routine)(void*), void* const arg)
+{
+   if(real_pthread_create == NULL) {
+      // This is the first call to this function, so the real pthread_create
+      // needs to be located. This also means that there are no other threads
+      // yet, so there's no need for synchronization.
+
+      const char* error;
+
+      // Ensure that there's no undetected error left from other calls to the
+      // dynamic loader. Complain if there is one.
+      error = dlerror();
+      if(error != NULL) {
+         syslog(LOG_ERR,
+                "pthread_create wrapper: "
+                "somebody neglected this error from the dynamic loader: %s",
+                error);
+      }
+
+      // Look up the real pthread_create.
+      *(const void**)(&real_pthread_create) = dlsym_next_pthread_create();
+      // According to the Linux man page for dlsym, which cites POSIX.1-2003,
+      // the cast from a function pointer pointer to a void pointer pointer is
+      // necessary because C99 leaves casting from a void pointer to a function
+      // pointer undefined.
+      error = dlerror();
+      if(error != NULL) {
+         syslog(LOG_ERR, "pthread_create wrapper: dlsym failed: %s", error);
+         return ELIBACC;  // "Cannot access a needed shared library"
+      } else if(real_pthread_create == NULL) {
+         syslog(LOG_ERR,
+                "pthread_create wrapper: pthread_create could not be found.");
+         return ELIBACC;
+      }
+   }
+   if(wrap_threads) {
+      // Tell the real pthread_create to start the thread with wrap_thread and
+      // pass start_routine and its argument as the argument to wrap_thread.
+      thread_data* const wrapped = malloc(sizeof(thread_data));
+      if(wrapped == NULL) {
+         // malloc failed. Return EAGAIN, which is the documented code for
+         // insufficient resources to create another thread.
+         return EAGAIN;
+      }
+      wrapped->start_routine = start_routine;
+      wrapped->arg = arg;
+      return real_pthread_create(thread, attr, wrap_thread, wrapped);
+   } else {
+      // Wrapping hasn't been enabled yet. Pass the arguments unmodified to the
+      // real pthread_create.
+      return real_pthread_create(thread, attr, start_routine, arg);
+   }
+}