_atexit.c 9.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358
  1. /* Copyright (C) 1995,1996 Robert de Bath <rdebath@cix.compulink.co.uk>
  2. * This file is part of the Linux-8086 C library and is distributed
  3. * under the GNU Library General Public License.
  4. */
  5. /*
  6. * Dec 2000 Manuel Novoa III
  7. *
  8. * Made atexit handling conform to standards... i.e. no args.
  9. * Removed on_exit since it did not match gnu libc definition.
  10. * Combined atexit and __do_exit into one object file.
  11. *
  12. * Feb 2001 Manuel Novoa III
  13. *
  14. * Reworked file after addition of __uClibc_main.
  15. * Changed name of __do_exit to atexit_handler.
  16. * Changed name of __cleanup to __uClibc_cleanup.
  17. * Moved declaration of __uClibc_cleanup to __uClibc_main
  18. * where it is initialized with (possibly weak alias)
  19. * _stdio_term.
  20. *
  21. * Jul 2001 Steve Thayer
  22. *
  23. * Added an on_exit implementation (that now matches gnu libc definition.)
  24. * Pulled atexit_handler out of the atexit object since it is now required by
  25. * on_exit as well. Renamed it to __exit_handler.
  26. * Fixed a problem where exit functions stop getting called if one of
  27. * them calls exit().
  28. * As a side effect of these changes, abort() no longer calls the exit
  29. * functions (it now matches the gnu libc definition).
  30. *
  31. * August 2002 Erik Andersen
  32. * Added locking so atexit and friends can be thread safe
  33. *
  34. * August 2005 Stephen Warren
  35. * Added __cxa_atexit and __cxa_finalize support
  36. *
  37. */
  38. #include <features.h>
  39. #include <unistd.h>
  40. #include <stdlib.h>
  41. #include <stdio.h>
  42. #include <errno.h>
  43. #include <atomic.h>
  44. #include <bits/uClibc_mutex.h>
  45. __UCLIBC_MUTEX_EXTERN(__atexit_lock) attribute_hidden;
  46. typedef void (*aefuncp)(void); /* atexit function pointer */
  47. typedef void (*oefuncp)(int, void *); /* on_exit function pointer */
  48. typedef void (*cxaefuncp)(void *); /* __cxa_atexit function pointer */
  49. typedef enum {
  50. ef_free,
  51. ef_in_use,
  52. ef_on_exit,
  53. ef_cxa_atexit
  54. } ef_type; /* exit function types */
  55. /* this is in the L_exit object */
  56. extern void (*__exit_cleanup)(int) attribute_hidden;
  57. /* these are in the L___do_exit object */
  58. extern int __exit_slots attribute_hidden;
  59. extern int __exit_count attribute_hidden;
  60. extern void __exit_handler(int) attribute_hidden;
  61. struct exit_function {
  62. /*
  63. * 'type' should be of type of the 'enum ef_type' above but since we
  64. * need this element in an atomic operation we have to use 'long int'.
  65. */
  66. long int type; /* enum ef_type */
  67. union {
  68. struct {
  69. oefuncp func;
  70. void *arg;
  71. } on_exit;
  72. struct {
  73. cxaefuncp func;
  74. void *arg;
  75. void* dso_handle;
  76. } cxa_atexit;
  77. } funcs;
  78. };
  79. #ifdef __UCLIBC_DYNAMIC_ATEXIT__
  80. extern struct exit_function *__exit_function_table attribute_hidden;
  81. #else
  82. extern struct exit_function __exit_function_table[__UCLIBC_MAX_ATEXIT] attribute_hidden;
  83. #endif
  84. extern struct exit_function *__new_exitfn(void) attribute_hidden;
  85. /* this is in the L___cxa_atexit object */
  86. extern int __cxa_atexit(cxaefuncp, void *arg, void *dso_handle);
  87. /* remove old_atexit after 0.9.29 */
  88. #if defined(L_atexit) || defined(L_old_atexit)
  89. extern void *__dso_handle __attribute__ ((__weak__));
  90. /*
  91. * register a function to be called at normal program termination
  92. * (the registered function takes no arguments)
  93. */
  94. #ifdef L_atexit
  95. int attribute_hidden atexit(aefuncp func)
  96. #else
  97. int old_atexit(aefuncp func);
  98. int old_atexit(aefuncp func)
  99. #endif
  100. {
  101. /*
  102. * glibc casts aefuncp to cxaefuncp.
  103. * This seems dodgy, but I guess calling a function with more
  104. * parameters than it needs will work everywhere?
  105. */
  106. return __cxa_atexit((cxaefuncp)func, NULL,
  107. &__dso_handle == NULL ? NULL : __dso_handle);
  108. }
  109. #ifndef L_atexit
  110. weak_alias(old_atexit,atexit)
  111. #endif
  112. #endif
  113. #ifdef L_on_exit
  114. /*
  115. * register a function to be called at normal program termination
  116. * the registered function takes two arguments:
  117. * status - the exit status that was passed to the exit() function
  118. * arg - generic argument
  119. */
  120. int on_exit(oefuncp func, void *arg)
  121. {
  122. struct exit_function *efp;
  123. if (func == NULL) {
  124. return 0;
  125. }
  126. efp = __new_exitfn();
  127. if (efp == NULL) {
  128. return -1;
  129. }
  130. efp->funcs.on_exit.func = func;
  131. efp->funcs.on_exit.arg = arg;
  132. /* assign last for thread safety, since we're now unlocked */
  133. efp->type = ef_on_exit;
  134. return 0;
  135. }
  136. #endif
  137. #ifdef L___cxa_atexit
  138. libc_hidden_proto(__cxa_atexit)
  139. int __cxa_atexit(cxaefuncp func, void *arg, void *dso_handle)
  140. {
  141. struct exit_function *efp;
  142. if (func == NULL) {
  143. return 0;
  144. }
  145. efp = __new_exitfn();
  146. if (efp == NULL) {
  147. return -1;
  148. }
  149. efp->funcs.cxa_atexit.func = func;
  150. efp->funcs.cxa_atexit.arg = arg;
  151. efp->funcs.cxa_atexit.dso_handle = dso_handle;
  152. /* assign last for thread safety, since we're now unlocked */
  153. efp->type = ef_cxa_atexit;
  154. return 0;
  155. }
  156. libc_hidden_def(__cxa_atexit)
  157. #endif
  158. #ifdef L___cxa_finalize
  159. /*
  160. * If D is non-NULL, call all functions registered with `__cxa_atexit'
  161. * with the same dso handle. Otherwise, if D is NULL, call all of the
  162. * registered handlers.
  163. */
  164. void __cxa_finalize(void *dso_handle);
  165. void __cxa_finalize(void *dso_handle)
  166. {
  167. struct exit_function *efp;
  168. int exit_count_snapshot = __exit_count;
  169. /* In reverse order */
  170. while (exit_count_snapshot) {
  171. efp = &__exit_function_table[--exit_count_snapshot];
  172. /*
  173. * We check dso_handle match before we verify the type of the union entry.
  174. * However, the atomic_exchange will validate that we were really "allowed"
  175. * to read dso_handle...
  176. */
  177. if ((dso_handle == NULL || dso_handle == efp->funcs.cxa_atexit.dso_handle)
  178. /* We don't want to run this cleanup more than once. */
  179. && !atomic_compare_and_exchange_bool_acq(&efp->type, ef_free, ef_cxa_atexit)
  180. ) {
  181. /* glibc passes status (0) too, but that's not in the prototype */
  182. (*efp->funcs.cxa_atexit.func)(efp->funcs.cxa_atexit.arg);
  183. }
  184. }
  185. #if 0 /* haven't looked into this yet... */
  186. /*
  187. * Remove the registered fork handlers. We do not have to
  188. * unregister anything if the program is going to terminate anyway.
  189. */
  190. #ifdef UNREGISTER_ATFORK
  191. if (d != NULL) {
  192. UNREGISTER_ATFORK(d);
  193. }
  194. #endif
  195. #endif
  196. }
  197. #endif
  198. #ifdef L___exit_handler
  199. int __exit_count = 0; /* Number of registered exit functions */
  200. #ifdef __UCLIBC_DYNAMIC_ATEXIT__
  201. struct exit_function *__exit_function_table = NULL;
  202. int __exit_slots = 0; /* Size of __exit_function_table */
  203. #else
  204. struct exit_function __exit_function_table[__UCLIBC_MAX_ATEXIT];
  205. #endif
  206. /*
  207. * Find and return a new exit_function pointer, for atexit,
  208. * onexit and __cxa_atexit to initialize
  209. */
  210. struct exit_function attribute_hidden *__new_exitfn(void)
  211. {
  212. struct exit_function *efp;
  213. __UCLIBC_MUTEX_LOCK(__atexit_lock);
  214. /*
  215. * Reuse free slots at the end of the list.
  216. * This avoids eating memory when dlopen and dlclose modules multiple times.
  217. */
  218. while (__exit_count > 0) {
  219. if (__exit_function_table[__exit_count-1].type == ef_free) {
  220. --__exit_count;
  221. } else break;
  222. }
  223. #ifdef __UCLIBC_DYNAMIC_ATEXIT__
  224. /* If we are out of function table slots, make some more */
  225. if (__exit_slots < __exit_count+1) {
  226. efp = realloc(__exit_function_table,
  227. (__exit_slots+20)*sizeof(struct exit_function));
  228. if (efp == NULL) {
  229. /* __set_errno(ENOMEM); */
  230. goto DONE;
  231. }
  232. __exit_function_table = efp;
  233. __exit_slots += 20;
  234. }
  235. #else
  236. if (__exit_count >= __UCLIBC_MAX_ATEXIT) {
  237. __set_errno(ENOMEM);
  238. efp = NULL;
  239. goto DONE;
  240. }
  241. #endif
  242. __exit_cleanup = __exit_handler; /* enable cleanup */
  243. efp = &__exit_function_table[__exit_count++];
  244. efp->type = ef_in_use;
  245. DONE:
  246. __UCLIBC_MUTEX_UNLOCK(__atexit_lock);
  247. return efp;
  248. }
  249. /*
  250. * Handle the work of executing the registered exit functions
  251. * This is called while we are locked, so no additional locking
  252. * is needed...
  253. */
  254. void __exit_handler(int status)
  255. {
  256. struct exit_function *efp;
  257. /* In reverse order */
  258. while (__exit_count) {
  259. efp = &__exit_function_table[--__exit_count];
  260. switch (efp->type) {
  261. case ef_on_exit:
  262. if (efp->funcs.on_exit.func) {
  263. (efp->funcs.on_exit.func)(status, efp->funcs.on_exit.arg);
  264. }
  265. break;
  266. case ef_cxa_atexit:
  267. if (efp->funcs.cxa_atexit.func) {
  268. /* glibc passes status too, but that's not in the prototype */
  269. (efp->funcs.cxa_atexit.func)(efp->funcs.cxa_atexit.arg);
  270. }
  271. break;
  272. }
  273. }
  274. #ifdef __UCLIBC_DYNAMIC_ATEXIT__
  275. /* Free up memory used by the __exit_function_table structure */
  276. free(__exit_function_table);
  277. #endif
  278. }
  279. #endif
  280. #ifdef L_exit
  281. /* Defeat compiler optimization which assumes function addresses are never NULL */
  282. static __always_inline int not_null_ptr(const void *p)
  283. {
  284. const void *q;
  285. __asm__ (""
  286. : "=r" (q) /* output */
  287. : "0" (p) /* input */
  288. );
  289. return q != 0;
  290. }
  291. extern void weak_function _stdio_term(void) attribute_hidden;
  292. attribute_hidden void (*__exit_cleanup)(int) = 0;
  293. __UCLIBC_MUTEX_INIT(__atexit_lock, PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP);
  294. extern void __uClibc_fini(void) attribute_hidden;
  295. /*
  296. * Normal program termination
  297. */
  298. void exit(int rv)
  299. {
  300. /* Perform exit-specific cleanup (atexit and on_exit) */
  301. __UCLIBC_MUTEX_LOCK(__atexit_lock);
  302. if (not_null_ptr(__exit_cleanup)) {
  303. __exit_cleanup(rv);
  304. }
  305. __UCLIBC_MUTEX_UNLOCK(__atexit_lock);
  306. __uClibc_fini();
  307. /* If we are using stdio, try to shut it down. At the very least,
  308. * this will attempt to commit all buffered writes. It may also
  309. * unbuffer all writable files, or close them outright.
  310. * Check the stdio routines for details. */
  311. if (not_null_ptr(_stdio_term))
  312. _stdio_term();
  313. _exit(rv);
  314. }
  315. libc_hidden_def(exit)
  316. #endif