1 files changed, 114 insertions, 23 deletions

diff --git a/libc/stdlib/atexit.c b/libc/stdlib/atexit.c
index 45ecefe9c..d7be35fbd 100644
--- a/libc/stdlib/atexit.c
+++ b/libc/stdlib/atexit.c
@@ -10,7 +10,7 @@
  *   Removed on_exit since it did not match gnu libc definition.
  *   Combined atexit and __do_exit into one object file.
  *
- * Feb 2000          Manuel Novoa III
+ * Feb 2001          Manuel Novoa III
  *
  *   Reworked file after addition of __uClibc_main.
  *   Changed name of __do_exit to atexit_handler.
@@ -18,58 +18,149 @@
  *   Moved declaration of __uClibc_cleanup to __uClibc_main
  *      where it is initialized with (possibly weak alias)
  *      __stdio_close_all.
+ *
+ * Jul 2001          Steve Thayer
+ * 
+ *   Added an on_exit implementation (that now matches gnu libc definition.)
+ *   Pulled atexit_handler out of the atexit object since it is now required by
+ *   on_exit as well.  Renamed it to __exit_handler.
+ *   Fixed a problem where exit functions stop getting called if one of
+ *   them calls exit().
+ *   As a side effect of these changes, abort() no longer calls the exit
+ *   functions (it now matches the gnu libc definition).
+ *
  */
 
 #include <unistd.h>
 #include <stdlib.h>
 #include <errno.h>
 
-typedef void (*vfuncp) (void);
-extern vfuncp __uClibc_cleanup;
+#define __MAX_EXIT __UCLIBC_MAX_ATEXIT
+
+typedef void (*aefuncp) (void);         /* atexit function pointer */
+typedef void (*oefuncp) (int, void *);  /* on_exit function pointer */
+typedef enum {
+	ef_atexit,
+	ef_on_exit
+} ef_type; /* exit function types */
 
-#ifdef L_atexit
 extern void __stdio_close_all(void);
 
-static vfuncp __atexit_table[__UCLIBC_MAX_ATEXIT];
-static int __atexit_count = 0;
+/* this is in the L_exit object */
+extern void (*__exit_cleanup) (int);
 
-static void atexit_handler(void)
-{
-	int count;
+/* these are in the L___do_exit object */
+extern int __exit_count;
+extern void __exit_handler(int);
+extern struct exit_function {
+	ef_type type;	/* ef_atexit or ef_on_exit */
+	union {
+		aefuncp atexit;
+		struct {
+			oefuncp func;
+			void *arg;
+		} on_exit;
+	} funcs;
+} __exit_function_table[__MAX_EXIT];
 
+#ifdef L_atexit
 	/*
-	 * Guard against more functions being added and againt being reinvoked.
+ * register a function to be called at normal program termination
+ * (the registered function takes no arguments)
 	 */
-	__uClibc_cleanup = 0;
+int atexit(aefuncp func)
+{
+	struct exit_function *efp;
 
-	/* In reverse order */
-	for (count = __atexit_count ; count-- ; ) {
-		(*__atexit_table[count])();
+	if (__exit_count >= __MAX_EXIT) {
+		__set_errno(ENOMEM);
+		return -1;
 	}
-	if (__stdio_close_all)
-	  __stdio_close_all();
+	if (func) {
+		__exit_cleanup = __exit_handler; /* enable cleanup */
+		efp = &__exit_function_table[__exit_count++];
+		efp->type = ef_atexit;
+		efp->funcs.atexit = func;
+	}
+	return 0;
 }
+#endif
 
-int atexit(vfuncp ptr)
+#ifdef L_on_exit
+/*
+ * register a function to be called at normal program termination
+ * the registered function takes two arguments:
+ *     status - the exit status that was passed to the exit() function
+ *     arg - generic argument
+ */
+int on_exit(oefuncp func, void *arg)
 {
-	if ((__uClibc_cleanup == 0) || (__atexit_count >= __UCLIBC_MAX_ATEXIT)) {
+	struct exit_function *efp;
+
+	if (__exit_count >= __MAX_EXIT) {
 		__set_errno(ENOMEM);
 		return -1;
 	}
-	if (ptr) {
-		__uClibc_cleanup = atexit_handler;
-		__atexit_table[__atexit_count++] = ptr;
+	if (func) {
+		__exit_cleanup = __exit_handler; /* enable cleanup */
+		efp = &__exit_function_table[__exit_count++];
+		efp->type = ef_on_exit;
+		efp->funcs.on_exit.func = func;
+		efp->funcs.on_exit.arg = arg;
 	}
 	return 0;
 }
 #endif
 
+#ifdef L___exit_handler
+struct exit_function __exit_function_table[__MAX_EXIT];
+int __exit_count = 0; /* Number of registered exit functions */
+
+/*
+ * Handle the work of executing the registered exit functions
+ */
+void __exit_handler(int status)
+{
+	struct exit_function *efp;
+
+	/* In reverse order */
+	for ( ; __exit_count-- ; ) {
+		efp = &__exit_function_table[__exit_count];
+		switch (efp->type) {
+		case ef_on_exit:
+			if (efp->funcs.on_exit.func) {
+				(efp->funcs.on_exit.func) (status, efp->funcs.on_exit.arg);
+			}
+			break;
+		case ef_atexit:
+			if (efp->funcs.atexit) {
+				(efp->funcs.atexit) ();
+			}
+			break;
+		}
+	}
+	if (__stdio_close_all)
+	  __stdio_close_all();
+}
+#endif
+
 #ifdef L_exit
+extern void (*__uClibc_cleanup) (void);
+void (*__exit_cleanup) (int) = 0;
+
+/*
+ * Normal program termination
+ */
 void exit(int rv)
 {
-	if (__uClibc_cleanup) {		/* Not already executing __uClibc_cleanup. */
-		__uClibc_cleanup();
+	/* Perform exit-specific cleanup (atexit and on_exit) */
+	if (__exit_cleanup) {
+		__exit_cleanup(rv);
 	}
+
+	/* Clean up everything else */
+	__uClibc_cleanup();
+
 	_exit(rv);
 }
 #endif