diff options
| -rw-r--r-- | milter_api.gpr | 7 | ||||
| -rw-r--r-- | thread_wrapper/build_thread_wrapper.gpr | 20 | ||||
| -rw-r--r-- | thread_wrapper/pthread_create_locator.c | 22 | ||||
| -rw-r--r-- | thread_wrapper/pthread_create_locator.h | 12 | ||||
| -rw-r--r-- | thread_wrapper/thread_wrapper.c | 159 |
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); + } +} |