#include <dlfcn.h>
#include <stdbool.h>
#include <stdlib.h>
+#include <string.h>
/* This file works around two different problems.
The first problem is that there is no __cxa_atexit on Mac OS versions
- before 10.4. It fixes this by providing one, and having it called from
- a destructor. This is not quite as good as having a real __cxa_atexit,
- but it's good enough to imitate the behaviour that you'd get if
- you didn't have one.
+ before 10.4. It fixes this by providing a complete atexit and
+ __cxa_atexit emulation called from the regular atexit.
- The second problem is that on 10.4 Mac OS versions, __cxa_finalize
- doesn't work right: it doesn't run routines that were registered
- while other atexit routines are running. This is worked around by
- installing our own handler so that it runs last, and repeatedly
- running __cxa_finalize until no new calls to __cxa_atexit are made. */
+ The second problem is that on all shipping versions of Mac OS,
+ __cxa_finalize and exit() don't work right: they don't run routines
+ that were registered while other atexit routines are running. This
+ is worked around by wrapping each atexit/__cxa_atexit routine with
+ our own routine which ensures that any __cxa_atexit calls while it
+ is running are honoured.
-typedef int (*cxa_atexit_p)(void (*func) (void*), void* arg, void* dso);
+ There are still problems which this does not solve. Before 10.4,
+ shared objects linked with previous compilers won't have their
+ atexit calls properly interleaved with code compiled with newer
+ compilers. Also, atexit routines registered from shared objects
+ linked with previous compilers won't get the bug fix. */
+
+typedef int (*cxa_atexit_p)(void (*func) (void*), void* arg, const void* dso);
+typedef void (*cxa_finalize_p)(const void *dso);
+typedef int (*atexit_p)(void (*func)(void));
+
+/* These are from "keymgr.h". */
+extern void *_keymgr_get_and_lock_processwide_ptr (unsigned key);
+extern int _keymgr_get_and_lock_processwide_ptr_2 (unsigned, void **);
+extern int _keymgr_set_and_unlock_processwide_ptr (unsigned key, void *ptr);
+
+extern void *__keymgr_global[];
+typedef struct _Sinfo_Node {
+ unsigned int size ; /*size of this node*/
+ unsigned short major_version ; /*API major version.*/
+ unsigned short minor_version ; /*API minor version.*/
+ } _Tinfo_Node ;
#ifdef __ppc__
-void __cxa_finalize (void* dso) __attribute__((weak));
+#define CHECK_KEYMGR_ERROR(e) \
+ (((_Tinfo_Node *)__keymgr_global[2])->major_version >= 4 ? (e) : 0)
#else
-void __cxa_finalize (void* dso);
+#define CHECK_KEYMGR_ERROR(e) (e)
#endif
-/* new_atexit_routines is set if __cxa_finalize exists in the system C
- library and our copy of __cxa_atexit has been called. */
+/* Our globals are stored under this keymgr index. */
+#define KEYMGR_ATEXIT_LIST 14
-static bool new_atexit_routines;
+/* The different kinds of callback routines. */
+typedef void (*atexit_callback)(void);
+typedef void (*cxa_atexit_callback)(void *);
-/* first_atexit_handler is called after all other atexit routines
- that were registered before __cxa_finalize is called.
- It may be called more than once, but is not re-entered. */
+/* This structure holds a routine to call. There may be extra fields
+ at the end of the structure that this code doesn't know about. */
+struct one_atexit_routine
+{
+ union {
+ atexit_callback ac;
+ cxa_atexit_callback cac;
+ } callback;
+ /* has_arg is 0/2/4 if 'ac' is live, 1/3/5 if 'cac' is live.
+ Higher numbers indicate a later version of the structure that this
+ code doesn't understand and will ignore. */
+ int has_arg;
+ void * arg;
+};
-static void
-first_atexit_handler(void* dso)
-{
- /* Keep running __cxa_finalize until no new atexit routines are
- registered.
- Note that this means __cxa_finalize will be called at least twice,
- even if the first call didn't register any new routines. */
- while (new_atexit_routines) {
- new_atexit_routines = false;
- __cxa_finalize (dso);
- };
+struct atexit_routine_list
+{
+ struct atexit_routine_list * next;
+ struct one_atexit_routine r;
+};
+
+/* The various possibilities for status of atexit(). */
+enum atexit_status {
+ atexit_status_unknown = 0,
+ atexit_status_missing = 1,
+ atexit_status_broken = 2,
+ atexit_status_working = 16
+};
+
+struct keymgr_atexit_list
+{
+ /* Version of this list. This code knows only about version 0.
+ If the version is higher than 0, this code may add new atexit routines
+ but should not attempt to run the list. */
+ short version;
+ /* 1 if an atexit routine is currently being run by this code, 0
+ otherwise. */
+ char running_routines;
+ /* Holds a value from 'enum atexit_status'. */
+ unsigned char atexit_status;
+ /* The list of atexit and cxa_atexit routines registered. If
+ atexit_status_missing it contains all routines registered while
+ linked with this code. If atexit_status_broken it contains all
+ routines registered during cxa_finalize while linked with this
+ code. */
+ struct atexit_routine_list *l;
+ /* &__cxa_atexit; set if atexit_status >= atexit_status_broken. */
+ cxa_atexit_p cxa_atexit_f;
+ /* &__cxa_finalize; set if atexit_status >= atexit_status_broken. */
+ cxa_finalize_p cxa_finalize_f;
+ /* &atexit; set if atexit_status >= atexit_status_working
+ or atexit_status == atexit_status_missing. */
+ atexit_p atexit_f;
+};
+
+/* Return 0 if __cxa_atexit has the bug it has in Mac OS 10.4: it
+ fails to call routines registered while an atexit routine is
+ running. Return 1 if it works properly, and -1 if an error occurred. */
+
+struct atexit_data
+{
+ int result;
+ cxa_atexit_p cxa_atexit;
+};
+
+static void cxa_atexit_check_2 (void *arg)
+{
+ ((struct atexit_data *)arg)->result = 1;
}
-/* This is our wrapper around __cxa_atexit that's called if __cxa_finalize
- exists in the system library. All it does is, on its first call,
- install first_atexit_handler; and on every call, set new_atexit_routines
- and pass control to the system __cxa_atexit.
- This proves to be somewhat more complicated than you might expect,
- because it may be called in a multithreaded environment. Fortunately
- it turns out to be possible to do what's needed without resorting
- to locking. */
+static void cxa_atexit_check_1 (void *arg)
+{
+ struct atexit_data * aed = arg;
+ if (aed->cxa_atexit (cxa_atexit_check_2, arg, arg) != 0)
+ aed->result = -1;
+}
static int
-cxa_atexit_wrapper (void (*func) (void*), void* arg, void* dso)
+check_cxa_atexit (cxa_atexit_p cxa_atexit, cxa_finalize_p cxa_finalize)
{
- static volatile cxa_atexit_p real_cxa_atexit;
- cxa_atexit_p auto_cxa_atexit = real_cxa_atexit;
- if (! auto_cxa_atexit)
+ struct atexit_data aed = { 0, cxa_atexit };
+
+ /* We re-use &aed as the 'dso' parameter, since it's a unique address. */
+ if (cxa_atexit (cxa_atexit_check_1, &aed, &aed) != 0)
+ return -1;
+ cxa_finalize (&aed);
+ if (aed.result == 0)
{
- void* handle = dlopen ("/usr/lib/libSystem.B.dylib", RTLD_NOLOAD);
- if (! handle)
- return -1;
-
- auto_cxa_atexit = (cxa_atexit_p)dlsym (handle, "__cxa_atexit");
- if (! auto_cxa_atexit)
- return -1;
+ /* Call __cxa_finalize again to make sure that cxa_atexit_check_2
+ is removed from the list before AED goes out of scope. */
+ cxa_finalize (&aed);
+ aed.result = 0;
}
- /* At this point, auto_cxa_atexit contains the address of
- the system __cxa_atexit. */
- if (! real_cxa_atexit)
+ return aed.result;
+}
+
+#ifdef __ppc__
+/* This comes from Csu. It works only before 10.4. The prototype has
+ been altered a bit to avoid casting. */
+extern int _dyld_func_lookup(const char *dyld_func_name,
+ void *address) __attribute__((visibility("hidden")));
+
+static void our_atexit (void);
+
+/* We're running on 10.3.9. Find the address of the system atexit()
+ function. So easy to say, so hard to do. */
+static atexit_p
+find_atexit_10_3 (void)
+{
+ unsigned int (*dyld_image_count_fn)(void);
+ const char *(*dyld_get_image_name_fn)(unsigned int image_index);
+ const void *(*dyld_get_image_header_fn)(unsigned int image_index);
+ const void *(*NSLookupSymbolInImage_fn)(const void *image,
+ const char *symbolName,
+ unsigned int options);
+ void *(*NSAddressOfSymbol_fn)(const void *symbol);
+ unsigned i, count;
+
+ /* Find some dyld functions. */
+ _dyld_func_lookup("__dyld_image_count", &dyld_image_count_fn);
+ _dyld_func_lookup("__dyld_get_image_name", &dyld_get_image_name_fn);
+ _dyld_func_lookup("__dyld_get_image_header", &dyld_get_image_header_fn);
+ _dyld_func_lookup("__dyld_NSLookupSymbolInImage", &NSLookupSymbolInImage_fn);
+ _dyld_func_lookup("__dyld_NSAddressOfSymbol", &NSAddressOfSymbol_fn);
+
+ /* If any of these don't exist, that's an error. */
+ if (! dyld_image_count_fn || ! dyld_get_image_name_fn
+ || ! dyld_get_image_header_fn || ! NSLookupSymbolInImage_fn
+ || ! NSAddressOfSymbol_fn)
+ return NULL;
+
+ count = dyld_image_count_fn ();
+ for (i = 0; i < count; i++)
{
- /* Install our handler above before any other handlers
- for this image, so it will be called last. */
- int result = (*auto_cxa_atexit)(first_atexit_handler, dso, dso);
- if (result != 0)
- return result;
- /* Now set the global real_cxa_atexit to prevent further
- installations of first_atexit_handler. Do this after
- the installation so that if another thread sees it is set,
- it can be sure that first_atexit_handler really has been
- installed. */
- real_cxa_atexit = auto_cxa_atexit;
+ const char * path = dyld_get_image_name_fn (i);
+ const void * image;
+ const void * symbol;
+
+ if (strcmp (path, "/usr/lib/libSystem.B.dylib") != 0)
+ continue;
+ image = dyld_get_image_header_fn (i);
+ if (! image)
+ return NULL;
+ /* '4' is NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR. */
+ symbol = NSLookupSymbolInImage_fn (image, "_atexit", 4);
+ if (! symbol)
+ return NULL;
+ return NSAddressOfSymbol_fn (symbol);
}
- /* At this point, we know that first_atexit_handler has been
- installed at least once, and real_cxa_atexit is not NULL. */
- /* It's not necessary to mark new_atexit_routines as volatile, so long
- as this write eventually happens before this shared object is
- unloaded. */
- new_atexit_routines = true;
- /* Call the original __cxa_atexit for this function. */
- return (*auto_cxa_atexit)(func, arg, dso);
+ return NULL;
}
-\f
-#ifdef __ppc__
-/* This code is used while running on 10.3.9, when __cxa_atexit doesn't
- exist in the system library. 10.3.9 only supported regular PowerPC,
- so this code isn't necessary on x86 or ppc64. */
+#endif
-/* This structure holds a routine to call. */
-struct atexit_routine
+/* Create (if necessary), find, lock, fill in, and return our globals.
+ Return NULL on error, in which case the globals will not be locked.
+ The caller should call keymgr_set_and_unlock. */
+static struct keymgr_atexit_list *
+get_globals (void)
{
- struct atexit_routine * next;
- void (*func)(void *);
- void * arg;
-};
+ struct keymgr_atexit_list * r;
+
+#ifdef __ppc__
+ /* 10.3.9 doesn't have _keymgr_get_and_lock_processwide_ptr_2 so the
+ PPC side can't use it. On 10.4 this just means the error gets
+ reported a little later when
+ _keymgr_set_and_unlock_processwide_ptr finds that the key was
+ never locked. */
+ r = _keymgr_get_and_lock_processwide_ptr (KEYMGR_ATEXIT_LIST);
+#else
+ void * rr;
+ if (_keymgr_get_and_lock_processwide_ptr_2 (KEYMGR_ATEXIT_LIST, &rr))
+ return NULL;
+ r = rr;
+#endif
+
+ if (r == NULL)
+ {
+ r = calloc (sizeof (struct keymgr_atexit_list), 1);
+ if (! r)
+ return NULL;
+ }
+
+ if (r->atexit_status == atexit_status_unknown)
+ {
+ void *handle;
+
+ handle = dlopen ("/usr/lib/libSystem.B.dylib", RTLD_NOLOAD);
+ if (!handle)
+ {
+#ifdef __ppc__
+ r->atexit_status = atexit_status_missing;
+ r->atexit_f = find_atexit_10_3 ();
+ if (! r->atexit_f)
+ goto error;
+ if (r->atexit_f (our_atexit))
+ goto error;
+#else
+ goto error;
+#endif
+ }
+ else
+ {
+ int chk_result;
+
+ r->cxa_atexit_f = (cxa_atexit_p)dlsym (handle, "__cxa_atexit");
+ r->cxa_finalize_f = (cxa_finalize_p)dlsym (handle, "__cxa_finalize");
+ if (! r->cxa_atexit_f || ! r->cxa_finalize_f)
+ goto error;
-static struct atexit_routine * volatile atexit_routines_list;
+ chk_result = check_cxa_atexit (r->cxa_atexit_f, r->cxa_finalize_f);
+ if (chk_result == -1)
+ goto error;
+ else if (chk_result == 0)
+ r->atexit_status = atexit_status_broken;
+ else
+ {
+ r->atexit_f = (atexit_p)dlsym (handle, "atexit");
+ if (! r->atexit_f)
+ goto error;
+ r->atexit_status = atexit_status_working;
+ }
+ }
+ }
-/* If __cxa_atexit doesn't exist at all in the system library, this
- routine is used; it completely emulates __cxa_atexit.
+ return r;
+
+ error:
+ _keymgr_set_and_unlock_processwide_ptr (KEYMGR_ATEXIT_LIST, r);
+ return NULL;
+}
- This routine has to be thread-safe, but fortunately this just means
- that it has to do atomic list insertion. */
+/* Add TO_ADD to ATEXIT_LIST. ATEXIT_LIST may be NULL but is
+ always the result of calling _keymgr_get_and_lock_processwide_ptr and
+ so KEYMGR_ATEXIT_LIST is known to be locked; this routine is responsible
+ for unlocking it. */
static int
-cxa_atexit_substitute (void (*func) (void*), void* arg,
- /* The 'dso' value will always be equal to this
- object's __dso_handle. */
- void* dso __attribute__((unused)))
+add_routine (struct keymgr_atexit_list * g,
+ const struct one_atexit_routine * to_add)
{
- struct atexit_routine * s = malloc (sizeof (struct atexit_routine));
- struct atexit_routine * next, * old_next;
+ struct atexit_routine_list * s
+ = malloc (sizeof (struct atexit_routine_list));
+ int result;
+
if (!s)
- return -1;
- s->func = func;
- s->arg = arg;
- next = atexit_routines_list;
- do {
- s->next = old_next = next;
- next = __sync_val_compare_and_swap (&atexit_routines_list, old_next, s);
- } while (next != old_next);
- return 0;
+ {
+ _keymgr_set_and_unlock_processwide_ptr (KEYMGR_ATEXIT_LIST, g);
+ return -1;
+ }
+ s->r = *to_add;
+ s->next = g->l;
+ g->l = s;
+ result = _keymgr_set_and_unlock_processwide_ptr (KEYMGR_ATEXIT_LIST, g);
+ return CHECK_KEYMGR_ERROR (result) == 0 ? 0 : -1;
}
-/* The routines added in cxa_atexit_substitute get run here, in a destructor.
- This routine doesn't have to be thread-safe. */
+/* This runs the routines in G->L up to STOP. */
+static struct keymgr_atexit_list *
+run_routines (struct keymgr_atexit_list *g,
+ struct atexit_routine_list *stop)
+{
+ for (;;)
+ {
+ struct atexit_routine_list * cur = g->l;
+ if (! cur || cur == stop)
+ break;
+ g->l = cur->next;
+ _keymgr_set_and_unlock_processwide_ptr (KEYMGR_ATEXIT_LIST, g);
+
+ switch (cur->r.has_arg) {
+ case 0: case 2: case 4:
+ cur->r.callback.ac ();
+ break;
+ case 1: case 3: case 5:
+ cur->r.callback.cac (cur->r.arg);
+ break;
+ default:
+ /* Don't understand, so don't call it. */
+ break;
+ }
+ free (cur);
+
+ g = _keymgr_get_and_lock_processwide_ptr (KEYMGR_ATEXIT_LIST);
+ if (! g)
+ break;
+ }
+ return g;
+}
+
+/* Call the routine described by ROUTINE_PARAM and then call any
+ routines added to KEYMGR_ATEXIT_LIST while that routine was
+ running, all with in_cxa_finalize set. */
-static void cxa_dtor (void) __attribute__((destructor));
static void
-cxa_dtor (void)
+cxa_atexit_wrapper (void* routine_param)
{
- while (atexit_routines_list)
+ struct one_atexit_routine * routine = routine_param;
+ struct keymgr_atexit_list *g;
+ struct atexit_routine_list * base = NULL;
+ char prev_running = 0;
+
+ g = _keymgr_get_and_lock_processwide_ptr (KEYMGR_ATEXIT_LIST);
+ if (g)
{
- struct atexit_routine * working_list = atexit_routines_list;
- atexit_routines_list = NULL;
- while (working_list)
+ prev_running = g->running_routines;
+ g->running_routines = 1;
+ base = g->l;
+ _keymgr_set_and_unlock_processwide_ptr (KEYMGR_ATEXIT_LIST, g);
+ }
+
+ if (routine->has_arg)
+ routine->callback.cac (routine->arg);
+ else
+ routine->callback.ac ();
+
+ if (g)
+ g = _keymgr_get_and_lock_processwide_ptr (KEYMGR_ATEXIT_LIST);
+ if (g)
+ g = run_routines (g, base);
+ if (g)
+ {
+ g->running_routines = prev_running;
+ _keymgr_set_and_unlock_processwide_ptr (KEYMGR_ATEXIT_LIST, g);
+ }
+}
+
+#ifdef __ppc__
+/* This code is used while running on 10.3.9, when __cxa_atexit doesn't
+ exist in the system library. 10.3.9 only supported regular PowerPC,
+ so this code isn't necessary on x86 or ppc64. */
+
+/* This routine is called from the system atexit(); it runs everything
+ registered on the KEYMGR_ATEXIT_LIST. */
+
+static void
+our_atexit (void)
+{
+ struct keymgr_atexit_list *g;
+ char prev_running;
+
+ g = _keymgr_get_and_lock_processwide_ptr (KEYMGR_ATEXIT_LIST);
+ if (! g || g->version != 0 || g->atexit_status != atexit_status_missing)
+ return;
+
+ prev_running = g->running_routines;
+ g->running_routines = 1;
+ g = run_routines (g, NULL);
+ if (! g)
+ return;
+ g->running_routines = prev_running;
+ _keymgr_set_and_unlock_processwide_ptr (KEYMGR_ATEXIT_LIST, g);
+}
+#endif
+
+/* This is our wrapper around atexit and __cxa_atexit. It will return
+ nonzero if an error occurs, and otherwise:
+ - if in_cxa_finalize is set, or running on 10.3.9, add R to
+ KEYMGR_ATEXIT_LIST; or
+ - call the system __cxa_atexit to add cxa_atexit_wrapper with an argument
+ that indicates how cxa_atexit_wrapper should call R. */
+
+static int
+atexit_common (const struct one_atexit_routine *r, const void *dso)
+{
+ struct keymgr_atexit_list *g = get_globals ();
+
+ if (! g)
+ return -1;
+
+ if (g->running_routines || g->atexit_status == atexit_status_missing)
+ return add_routine (g, r);
+
+ if (g->atexit_status >= atexit_status_working)
+ {
+ int result;
+ if (r->has_arg)
{
- struct atexit_routine * called_routine = working_list;
- working_list->func (working_list->arg);
- working_list = working_list->next;
- free (called_routine);
+ cxa_atexit_p cxa_atexit = g->cxa_atexit_f;
+ result = _keymgr_set_and_unlock_processwide_ptr (KEYMGR_ATEXIT_LIST,
+ g);
+ if (CHECK_KEYMGR_ERROR (result))
+ return -1;
+ return cxa_atexit (r->callback.cac, r->arg, dso);
}
+ else
+ {
+ atexit_p atexit_f = g->atexit_f;
+ result = _keymgr_set_and_unlock_processwide_ptr (KEYMGR_ATEXIT_LIST,
+ g);
+ if (CHECK_KEYMGR_ERROR (result))
+ return -1;
+ return atexit_f (r->callback.ac);
+ }
+ }
+ else
+ {
+ cxa_atexit_p cxa_atexit = g->cxa_atexit_f;
+ struct one_atexit_routine *alloced;
+ int result;
+
+ result = _keymgr_set_and_unlock_processwide_ptr (KEYMGR_ATEXIT_LIST, g);
+ if (CHECK_KEYMGR_ERROR (result))
+ return -1;
+
+ alloced = malloc (sizeof (struct one_atexit_routine));
+ if (! alloced)
+ return -1;
+ *alloced = *r;
+ return cxa_atexit (cxa_atexit_wrapper, alloced, dso);
}
}
-#endif
-int __cxa_atexit (void (*func) (void*), void* arg,
- void* dso) __attribute__((visibility("hidden")));
+/* These are the actual replacement routines; they just funnel into
+ atexit_common. */
+
+int __cxa_atexit (cxa_atexit_callback func, void* arg,
+ const void* dso) __attribute__((visibility("hidden")));
+
int
-__cxa_atexit (void (*func) (void*), void* arg, void* dso)
+__cxa_atexit (cxa_atexit_callback func, void* arg, const void* dso)
{
-#ifdef __ppc__
- if (! __cxa_finalize)
- return cxa_atexit_substitute (func, arg, dso);
-#endif
- return cxa_atexit_wrapper (func, arg, dso);
+ struct one_atexit_routine r;
+ r.callback.cac = func;
+ r.has_arg = 1;
+ r.arg = arg;
+ return atexit_common (&r, dso);
+}
+
+int atexit (atexit_callback func) __attribute__((visibility("hidden")));
+
+int
+atexit (atexit_callback func)
+{
+ struct one_atexit_routine r;
+ r.callback.ac = func;
+ r.has_arg = 0;
+ return atexit_common (&r, NULL);
}
OSDN Git Service
