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$"); 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 63 struct cxa_thread_dtor { 64 void *obj; 65 void (*func)(void *); 66 void *dso; 67 LIST_ENTRY(cxa_thread_dtor) entry; 68 }; 69 static _Thread_local LIST_HEAD(dtor_list, cxa_thread_dtor) dtors = 70 LIST_HEAD_INITIALIZER(dtors); 71 72 int 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 90 static void 91 walk_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 103 static void 104 walk_cb_nocall(struct cxa_thread_dtor *dtor __unused) 105 { 106 } 107 108 static void 109 cxa_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 */ 125 void 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