cxa_thread_atexit.c revision 304527
1/*- 2 * Copyright (c) 2016 Mahdi Mokhtari <mokhi64@gmail.com> 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 */ 26 27#include <sys/cdefs.h> 28__FBSDID("$FreeBSD: stable/10/lib/libc/stdlib/cxa_thread_atexit.c 304527 2016-08-20 12:26:44Z kib $"); 29 30#include <sys/queue.h> 31#include "namespace.h" 32#include <errno.h> 33#include <link.h> 34#include <pthread.h> 35#include <stddef.h> 36#include <stdlib.h> 37#include <stdio.h> 38#include "un-namespace.h" 39#include "libc_private.h" 40 41/* 42 * C++11 introduces the thread_local scope (like __thread with some 43 * additions). As a key-feature it should support non-trivial 44 * destructors, registered with __cxa_thread_atexit() to be executed 45 * at the thread termination. 46 * 47 * The implemention keeps a _Thread_local list of destructors per each 48 * thread, and calls __cxa_thread_call_dtors() on each thread's exit 49 * to do cleanup. For a thread calling exit(3), in particular, for 50 * the initial thread returning from main(), we call 51 * __cxa_thread_call_dtors() inside exit(). 52 * 53 * It could be possible that a dynamically loaded library, use 54 * thread_local variable but is dlclose()'d before thread exit. The 55 * destructor of this variable will then try to access the address, 56 * for calling it but it's unloaded, so it'll crash. We're using 57 * __elf_phdr_match_addr() to detect and prevent such cases and so 58 * prevent the crash. 59 */ 60 61#define CXA_DTORS_ITERATIONS 4 62 63struct cxa_thread_dtor { 64 void *obj; 65 void (*func)(void *); 66 void *dso; 67 LIST_ENTRY(cxa_thread_dtor) entry; 68}; 69static _Thread_local LIST_HEAD(dtor_list, cxa_thread_dtor) dtors = 70 LIST_HEAD_INITIALIZER(dtors); 71 72int 73__cxa_thread_atexit(void (*dtor_func)(void *), void *obj, void *dso_symbol) 74{ 75 struct cxa_thread_dtor *new_dtor; 76 77 new_dtor = malloc(sizeof(*new_dtor)); 78 if (new_dtor == NULL) { 79 errno = ENOMEM; /* forcibly override malloc(3) error */ 80 return (-1); 81 } 82 83 new_dtor->obj = obj; 84 new_dtor->func = dtor_func; 85 new_dtor->dso = dso_symbol; 86 LIST_INSERT_HEAD(&dtors, new_dtor, entry); 87 return (0); 88} 89 90static void 91walk_cb_call(struct cxa_thread_dtor *dtor) 92{ 93 struct dl_phdr_info phdr_info; 94 95 if (_rtld_addr_phdr(dtor->dso, &phdr_info) && 96 __elf_phdr_match_addr(&phdr_info, dtor->func)) 97 dtor->func(dtor->obj); 98 else 99 fprintf(stderr, "__cxa_thread_call_dtors: dtr %p from " 100 "unloaded dso, skipping\n", (void *)(dtor->func)); 101} 102 103static void 104walk_cb_nocall(struct cxa_thread_dtor *dtor __unused) 105{ 106} 107 108static void 109cxa_thread_walk(void (*cb)(struct cxa_thread_dtor *)) 110{ 111 struct cxa_thread_dtor *dtor, *tdtor; 112 113 LIST_FOREACH_SAFE(dtor, &dtors, entry, tdtor) { 114 LIST_REMOVE(dtor, entry); 115 cb(dtor); 116 free(dtor); 117 } 118} 119 120/* 121 * This is the callback function we use to call destructors, once for 122 * each thread. It is called in exit(3) in libc/stdlib/exit.c and 123 * before exit_thread() in libthr/thread/thr_exit.c. 124 */ 125void 126__cxa_thread_call_dtors(void) 127{ 128 int i; 129 130 for (i = 0; i < CXA_DTORS_ITERATIONS && !LIST_EMPTY(&dtors); i++) 131 cxa_thread_walk(walk_cb_call); 132 133 if (!LIST_EMPTY(&dtors)) { 134 fprintf(stderr, "Thread %p is exiting with more " 135 "thread-specific dtors created after %d iterations " 136 "of destructor calls\n", 137 _pthread_self(), i); 138 cxa_thread_walk(walk_cb_nocall); 139 } 140} 141