Many files:

  Exit all threads created by innoDB at shutdown


innobase/os/os0file.c:
  Exit all threads created by innoDB at shutdown
innobase/os/os0sync.c:
  Exit all threads created by innoDB at shutdown
innobase/os/os0thread.c:
  Exit all threads created by innoDB at shutdown
innobase/include/os0file.h:
  Exit all threads created by innoDB at shutdown
innobase/include/os0sync.h:
  Exit all threads created by innoDB at shutdown
innobase/include/os0thread.h:
  Exit all threads created by innoDB at shutdown
innobase/log/log0log.c:
  Exit all threads created by innoDB at shutdown
innobase/srv/srv0srv.c:
  Exit all threads created by innoDB at shutdown
innobase/srv/srv0start.c:
  Exit all threads created by innoDB at shutdown

3 files changed, 97 insertions, 5 deletions

diff --git a/innobase/os/os0file.c b/innobase/os/os0file.c
index c7f95d79104..640ffec122f 100644
--- a/innobase/os/os0file.c
+++ b/innobase/os/os0file.c
@@ -1295,7 +1295,6 @@ os_aio_array_create(
 #endif	
 	ut_a(n > 0);
 	ut_a(n_segments > 0);
-	ut_a(n % n_segments == 0);
 
 	array = ut_malloc(sizeof(os_aio_array_t));
 
@@ -1404,6 +1403,50 @@ os_aio_init(
 	pthread_sigmask(SIG_BLOCK, &sigset, NULL); */
 #endif
 }
+
+#ifdef WIN_ASYNC_IO
+/****************************************************************************
+Wakes up all async i/o threads in the array in Windows async i/o at
+shutdown. */
+static
+void
+os_aio_array_wake_win_aio_at_shutdown(
+/*==================================*/
+	os_aio_array_t*	array)	/* in: aio array */
+{
+	ulint	i;
+
+	for (i = 0; i < array->n_slots; i++) {
+
+	        os_event_set(*(array->events + i));
+	}
+}
+#endif
+
+/****************************************************************************
+Wakes up all async i/o threads so that they know to exit themselves in
+shutdown. */
+
+void
+os_aio_wake_all_threads_at_shutdown(void)
+/*=====================================*/
+{
+	ulint	i;
+
+#ifdef WIN_ASYNC_IO
+        /* This code wakes up all ai/o threads in Windows native aio */
+	os_aio_array_wake_win_aio_at_shutdown(os_aio_read_array);
+	os_aio_array_wake_win_aio_at_shutdown(os_aio_write_array);
+	os_aio_array_wake_win_aio_at_shutdown(os_aio_ibuf_array);
+	os_aio_array_wake_win_aio_at_shutdown(os_aio_log_array);
+#endif
+	/* This loop wakes up all simulated ai/o threads */
+
+	for (i = 0; i < os_aio_n_segments; i++) {
+	    	
+		os_event_set(os_aio_segment_wait_events[i]);
+	}	
+}
 				
 /****************************************************************************
 Waits until there are no pending writes in os_aio_write_array. There can
diff --git a/innobase/os/os0sync.c b/innobase/os/os0sync.c
index 407b280f805..abcfa254710 100644
--- a/innobase/os/os0sync.c
+++ b/innobase/os/os0sync.c
@@ -17,6 +17,7 @@ Created 9/6/1995 Heikki Tuuri
 #endif
 
 #include "ut0mem.h"
+#include "srv0start.h"
 
 /* Type definition for an operating system mutex struct */
 struct os_mutex_struct{ 
@@ -26,9 +27,16 @@ struct os_mutex_struct{
 				recursively lock the mutex: we
 				do not assume that the OS mutex
 				supports recursive locking, though
-				NT seems to do that */				
+				NT seems to do that */
 };
 
+/* Mutex protecting the thread count */
+os_mutex_t			os_thread_count_mutex;
+
+/* This is incremented by 1 in os_thread_create and decremented by 1 in
+os_thread_exit */
+ulint				os_thread_count		= 0;
+
 /*************************************************************
 Creates an event semaphore, i.e., a semaphore which may
 just have two states: signaled and nonsignaled.
@@ -190,7 +198,10 @@ os_event_free(
 }
 
 /**************************************************************
-Waits for an event object until it is in the signaled state. */
+Waits for an event object until it is in the signaled state. If
+srv_shutdown_state == SRV_SHUTDOWN_EXIT_THREADS this also exits the
+waiting thread when the event becomes signaled (or immediately if the
+event is already in the signaled state). */
 
 void
 os_event_wait(
@@ -206,12 +217,20 @@ os_event_wait(
 	err = WaitForSingleObject(event, INFINITE);
 
 	ut_a(err == WAIT_OBJECT_0);
+
+	if (srv_shutdown_state == SRV_SHUTDOWN_EXIT_THREADS) {
+	        os_thread_exit(NULL);
+	}
 #else
 	os_fast_mutex_lock(&(event->os_mutex));
 loop:
 	if (event->is_set == TRUE) {
 		os_fast_mutex_unlock(&(event->os_mutex));
 
+		if (srv_shutdown_state == SRV_SHUTDOWN_EXIT_THREADS) {
+
+		        os_thread_exit(NULL);
+		}
 		/* Ok, we may return */
 
 		return;
@@ -299,6 +318,10 @@ os_event_wait_multiple(
 	ut_a(index >= WAIT_OBJECT_0);
 	ut_a(index < WAIT_OBJECT_0 + n);
 
+	if (srv_shutdown_state == SRV_SHUTDOWN_EXIT_THREADS) {
+	        os_thread_exit(NULL);
+	}
+
 	return(index - WAIT_OBJECT_0);
 #else
 	ut_a(n == 0);
diff --git a/innobase/os/os0thread.c b/innobase/os/os0thread.c
index b0076921e43..a68f6a3b8bc 100644
--- a/innobase/os/os0thread.c
+++ b/innobase/os/os0thread.c
@@ -1,6 +1,5 @@
 /******************************************************
-The interface to the operating system
-process and thread control primitives
+The interface to the operating system thread control primitives
 
 (c) 1995 Innobase Oy
 
@@ -102,6 +101,10 @@ os_thread_create(
 	os_thread_t	thread;
 	ulint           win_thread_id;
 
+	os_mutex_enter(os_thread_count_mutex);
+	os_thread_count++;
+	os_mutex_exit(os_thread_count_mutex);
+
 	thread = CreateThread(NULL,	/* no security attributes */
 				0,	/* default size stack */
 				(LPTHREAD_START_ROUTINE)start_f,
@@ -144,6 +147,9 @@ os_thread_create(
 		 exit(1);
 	}
 #endif
+	os_mutex_enter(os_thread_count_mutex);
+	os_thread_count++;
+	os_mutex_exit(os_thread_count_mutex);
 
 #if defined(UNIV_HOTBACKUP) && defined(UNIV_HPUX10)
 	ret = pthread_create(&pthread, pthread_attr_default, start_f, arg);
@@ -171,6 +177,26 @@ os_thread_create(
 }
 
 /*********************************************************************
+Exits the current thread. */
+
+void
+os_thread_exit(
+/*===========*/
+	void*	exit_value)	/* in: exit value; in Windows this void*
+				is cast as a DWORD */
+{
+	os_mutex_enter(os_thread_count_mutex);
+	os_thread_count--;
+	os_mutex_exit(os_thread_count_mutex);
+
+#ifdef __WIN__
+        ExitThread((DWORD)exit_value);
+#else
+	pthread_exit(exit_value);
+#endif
+}
+
+/*********************************************************************
 Returns handle to the current thread. */
 
 os_thread_t