Rombobjörn

summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--milter_api.gpr7
-rw-r--r--thread_wrapper/build_thread_wrapper.gpr20
-rw-r--r--thread_wrapper/pthread_create_locator.c22
-rw-r--r--thread_wrapper/pthread_create_locator.h12
-rw-r--r--thread_wrapper/thread_wrapper.c159
5 files changed, 219 insertions, 1 deletions
diff --git a/milter_api.gpr b/milter_api.gpr
index b3b47cc..741cfe4 100644
--- a/milter_api.gpr
+++ b/milter_api.gpr
@@ -1,5 +1,5 @@
-- Projects that use the Ada Milter API should import this file.
--- Copyright 2009 - 2012 B. Persson, Bjorn@Rombobeorn.se
+-- Copyright 2009 - 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
@@ -12,4 +12,9 @@ project Milter_API is
for Library_Dir use Directories.Libdir;
for Library_ALI_Dir use Directories.Libdir & "/adamilter";
for Externally_Built use "true";
+
+ package Linker is
+ for Linker_Options use ("-ladamilter_thread_wrapper", "-ldl");
+ end Linker;
+
end Milter_API;
diff --git a/thread_wrapper/build_thread_wrapper.gpr b/thread_wrapper/build_thread_wrapper.gpr
new file mode 100644
index 0000000..78325b4
--- /dev/null
+++ b/thread_wrapper/build_thread_wrapper.gpr
@@ -0,0 +1,20 @@
+-- Use this project file to compile the thread wrapper into a static library.
+-- Copyright 2013 B. Persson, Bjorn@Rombobeorn.se
+--
+-- This project file 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.
+
+
+with "directories";
+
+library project Build_Thread_Wrapper is
+
+ Destdir := external("DESTDIR", "");
+
+ for Library_Name use "adamilter_thread_wrapper";
+ for Library_Kind use "static";
+ for Library_Dir use Destdir & Directories.Libdir;
+ for Languages use ("C");
+
+end Build_Thread_Wrapper;
diff --git a/thread_wrapper/pthread_create_locator.c b/thread_wrapper/pthread_create_locator.c
new file mode 100644
index 0000000..df5eef7
--- /dev/null
+++ b/thread_wrapper/pthread_create_locator.c
@@ -0,0 +1,22 @@
+// 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.
+
+
+// _GNU_SOURCE must be defined to make RTLD_NEXT available. Keeping this in a
+// separate file avoids any surprising effects that _GNU_SOURCE might have on
+// other header files that thread_wrapper.c includes.
+
+
+#include "pthread_create_locator.h"
+
+#define _GNU_SOURCE
+#include <dlfcn.h>
+
+
+void* dlsym_next_pthread_create() {
+ return dlsym(RTLD_NEXT, "pthread_create");
+}
diff --git a/thread_wrapper/pthread_create_locator.h b/thread_wrapper/pthread_create_locator.h
new file mode 100644
index 0000000..04a1567
--- /dev/null
+++ b/thread_wrapper/pthread_create_locator.h
@@ -0,0 +1,12 @@
+// 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.
+
+
+void* dlsym_next_pthread_create();
+// dlsym_next_pthread_create returns the address of the next symbol named
+// "pthread_create" in the library search order - that is the first one in a
+// dynamic library as this code must be in the main executable.
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);
+ }
+}