Merge lp:~jan-kneschke/mysql-proxy/threaded-io into lp:mysql-proxy

[Jan Kneschke]

[Jan Kneschke (jan-kneschke)]

merge the initial threaded-io code into trunk for the 0.8 work

[Jan Kneschke (jan-kneschke)]

* rebased to the 0.7.1 changes
* make check passes

review: Approve

=== modified file 'src/Makefile.am'
--- src/Makefile.am	2009-05-12 19:20:06 +0000
+++ src/Makefile.am	2009-05-25 08:57:34 +0000
@@ -67,14 +67,15 @@
 	chassis-plugin.c \
 	chassis-log.c \
 	chassis-mainloop.c \
+	chassis-event-thread.c \
 	chassis-keyfile.c \
 	chassis-path.c \
 	chassis-stats.c
 
 
 libmysql_chassis_la_LDFLAGS  = -export-dynamic -no-undefined -dynamic
-libmysql_chassis_la_CPPFLAGS = $(MYSQL_CFLAGS) $(EVENT_CFLAGS) $(GLIB_CFLAGS) $(LUA_CFLAGS) $(GMODULE_CFLAGS)
-libmysql_chassis_la_LIBADD   = $(EVENT_LIBS)   $(GLIB_LIBS)   $(LUA_LIBS) $(GMODULE_LIBS)
+libmysql_chassis_la_CPPFLAGS = $(MYSQL_CFLAGS) $(EVENT_CFLAGS) $(GLIB_CFLAGS) $(LUA_CFLAGS) $(GMODULE_CFLAGS) $(GTHREAD_CFLAGS)
+libmysql_chassis_la_LIBADD   = $(EVENT_LIBS)   $(GLIB_LIBS)   $(LUA_LIBS) $(GMODULE_LIBS) $(GTHREAD_LIBS)
 
 
 noinst_HEADERS=\
@@ -96,6 +97,7 @@
 	chassis-keyfile.h \
 	chassis-mainloop.h \
 	chassis-path.h \
+	chassis-event-thread.h \
 	glib-ext.h \
 	lua-load-factory.h \
 	lua-scope.h \
 
=== added file 'src/chassis-event-thread.c'
--- src/chassis-event-thread.c	1970-01-01 00:00:00 +0000
+++ src/chassis-event-thread.c	2009-05-25 08:57:34 +0000
@@ -0,0 +1,287 @@
+/* $%BEGINLICENSE%$
+ Copyright (C) 2007-2008 MySQL AB, 2008 Sun Microsystems, Inc
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; version 2 of the License.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+ $%ENDLICENSE%$ */
+
+#include <glib.h>
+#include <errno.h>
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h> /* for write() */
+#endif
+
+#include "chassis-event-thread.h"
+
+#define C(x) x, sizeof(x) - 1
+
+chassis_event_op_t *chassis_event_op_new() {
+	chassis_event_op_t *e;
+
+	e = g_new0(chassis_event_op_t, 1);
+
+	return e;
+}
+
+void chassis_event_op_free(chassis_event_op_t *e) {
+	if (!e) return;
+
+	g_free(e);
+}
+
+/**
+ * execute a event-op on a event-base
+ *
+ * @see: chassis_event_add_local(), chassis_threaded_event_op()
+ */
+void chassis_event_op_apply(chassis_event_op_t *op, struct event_base *event_base) {
+	switch (op->type) {
+	case CHASSIS_EVENT_OP_ADD:
+		event_base_set(event_base, op->ev);
+		event_add(op->ev, NULL);
+		break;
+	case CHASSIS_EVENT_OP_UNSET:
+		g_assert_not_reached();
+		break;
+	}
+}
+
+/**
+ * add a event asynchronously
+ *
+ * the event is added to the global event-queue and a fd-notification is sent allowing any
+ * of the event-threads to handle it
+ *
+ * @see network_mysqld_con_handle()
+ */
+void chassis_event_add(chassis *chas, struct event *ev) {
+	chassis_event_op_t *op = chassis_event_op_new();
+
+	op->type = CHASSIS_EVENT_OP_ADD;
+	op->ev   = ev;
+	g_async_queue_push(chas->threads->event_queue, op);
+
+	write(chas->threads->event_notify_fds[1], C(".")); /* ping the event handler */
+}
+
+GPrivate *tls_event_base_key = NULL;
+
+/**
+ * add a event to the current thread 
+ *
+ * needs event-base stored in the thread local storage
+ *
+ * @see network_connection_pool_lua_add_connection()
+ */
+void chassis_event_add_local(chassis G_GNUC_UNUSED *chas, struct event *ev) {
+	struct event_base *event_base = ev->ev_base;
+	chassis_event_op_t *op;
+
+	if (!event_base) event_base = g_private_get(tls_event_base_key);
+
+	g_assert(event_base); /* the thread-local event-base has to be initialized */
+
+	op = chassis_event_op_new();
+
+	op->type = CHASSIS_EVENT_OP_ADD;
+	op->ev   = ev;
+
+	chassis_event_op_apply(op, event_base);
+	
+	chassis_event_op_free(op);
+}
+
+/**
+ * handled events sent through the global event-queue 
+ *
+ * each event-thread has its own listener on the event-queue and 
+ * calls chassis_event_handle() with its own event-base
+ *
+ * @see chassis_event_add()
+ */
+void chassis_event_handle(int G_GNUC_UNUSED event_fd, short G_GNUC_UNUSED events, void *user_data) {
+	chassis_event_thread_t *event_thread = user_data;
+	struct event_base *event_base = event_thread->event_base;
+	chassis *chas = event_thread->chas;
+	chassis_event_op_t *op;
+	char ping[1024];
+
+	/* flush the pipe */
+	while (read(event_thread->notify_fd, ping, sizeof(ping)) > 0);
+
+	while ((op = g_async_queue_try_pop(chas->threads->event_queue))) {
+		chassis_event_op_apply(op, event_base);
+
+		chassis_event_op_free(op);
+	}
+}
+
+chassis_event_thread_t *chassis_event_thread_new() {
+	chassis_event_thread_t *event_thread;
+
+	event_thread = g_new0(chassis_event_thread_t, 1);
+
+	return event_thread;
+}
+
+void chassis_event_thread_free(chassis_event_thread_t *event_thread) {
+	gboolean is_thread = (event_thread->thr != NULL);
+
+	if (!event_thread) return;
+
+	if (event_thread->thr) g_thread_join(event_thread->thr);
+
+	if (event_thread->notify_fd != -1) {
+		event_del(&(event_thread->notify_fd_event));
+		close(event_thread->notify_fd);
+	}
+
+	/* we don't want to free the global event-base */
+	if (is_thread && event_thread->event_base) event_base_free(event_thread->event_base);
+
+	g_free(event_thread);
+}
+
+/**
+ * set the event-based for the current event-thread
+ *
+ * @see chassis_event_add_local()
+ */
+void chassis_event_thread_set_event_base(chassis_event_thread_t G_GNUC_UNUSED *e, struct event_base *event_base) {
+	tls_event_base_key = g_private_new(NULL);
+
+	g_private_set(tls_event_base_key, event_base);
+}
+
+chassis_event_threads_t *chassis_event_threads_new() {
+	chassis_event_threads_t *threads;
+
+	threads = g_new0(chassis_event_threads_t, 1);
+
+	/* create the ping-fds
+	 *
+	 * the event-thread write a byte to the ping-pipe to trigger a fd-event when
+	 * something is available in the event-async-queues
+	 */
+	if (0 != pipe(threads->event_notify_fds)) {
+		g_error("%s: pipe() failed: %s (%d)", 
+				G_STRLOC,
+				g_strerror(errno),
+				errno);
+	}
+
+	threads->event_threads = g_ptr_array_new();
+	threads->event_queue = g_async_queue_new();
+
+	return threads;
+}
+
+void chassis_event_threads_free(chassis_event_threads_t *threads) {
+	guint i;
+
+	if (!threads) return;
+
+	/* all threads are running, now wait until they are down again */
+	for (i = 0; i < threads->event_threads->len; i++) {
+		chassis_event_thread_t *event_thread = threads->event_threads->pdata[i];
+
+		chassis_event_thread_free(event_thread);
+	}
+
+	g_ptr_array_free(threads->event_threads, TRUE);
+	g_async_queue_unref(threads->event_queue);
+
+	g_free(threads);
+}
+
+void chassis_event_threads_add(chassis_event_threads_t *threads, chassis_event_thread_t *thread) {
+	g_ptr_array_add(threads->event_threads, thread);
+}
+
+
+/**
+ * setup the notification-fd of a event-thread
+ *
+ * all event-threads listen on the same notification pipe
+ *
+ * @see chassis_event_handle()
+ */ 
+int chassis_event_threads_init_thread(chassis_event_threads_t *threads, chassis_event_thread_t *event_thread, chassis *chas) {
+	event_thread->event_base = event_base_new();
+	event_thread->chas = chas;
+
+	event_thread->notify_fd = dup(threads->event_notify_fds[0]);
+
+	evutil_make_socket_nonblocking(event_thread->notify_fd);
+
+	event_set(&(event_thread->notify_fd_event), event_thread->notify_fd, EV_READ | EV_PERSIST, chassis_event_handle, event_thread);
+	event_base_set(event_thread->event_base, &(event_thread->notify_fd_event));
+	event_add(&(event_thread->notify_fd_event), NULL);
+
+	return 0;
+}
+
+/**
+ * event-handler thread
+ *
+ */
+void *chassis_event_thread_loop(chassis_event_thread_t *event_thread) {
+	chassis_event_thread_set_event_base(event_thread, event_thread->event_base);
+
+	/**
+	 * check once a second if we shall shutdown the proxy
+	 */
+	while (!chassis_is_shutdown()) {
+		struct timeval timeout;
+		int r;
+
+		timeout.tv_sec = 1;
+		timeout.tv_usec = 0;
+
+		g_assert(event_base_loopexit(event_thread->event_base, &timeout) == 0);
+
+		r = event_base_dispatch(event_thread->event_base);
+
+		if (r == -1) {
+			if (errno == EINTR) continue;
+
+			break;
+		}
+	}
+
+	return NULL;
+}
+
+void chassis_event_threads_start(chassis_event_threads_t *threads) {
+	guint i;
+
+	for (i = 1; i < threads->event_threads->len; i++) { /* the 1st is the main-thread and already set up */
+		chassis_event_thread_t *event_thread = threads->event_threads->pdata[i];
+		GError *gerr = NULL;
+
+		event_thread->thr = g_thread_create((GThreadFunc)chassis_event_thread_loop, event_thread, TRUE, &gerr);
+
+		if (gerr) {
+			g_error_free(gerr);
+			gerr = NULL;
+		}
+	}
+}
+
+
 
=== added file 'src/chassis-event-thread.h'
--- src/chassis-event-thread.h	1970-01-01 00:00:00 +0000
+++ src/chassis-event-thread.h	2009-05-25 08:57:34 +0000
@@ -0,0 +1,81 @@
+/* $%BEGINLICENSE%$
+ Copyright (C) 2007-2008 MySQL AB, 2008 Sun Microsystems, Inc
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; version 2 of the License.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+ $%ENDLICENSE%$ */
+ 
+
+#ifndef _CHASSIS_EVENT_THREAD_H_
+#define _CHASSIS_EVENT_THREAD_H_
+
+#include <glib.h>    /* GPtrArray */
+
+#include "chassis-exports.h"
+#include "chassis-mainloop.h"
+
+/**
+ * event operations
+ *
+ * event-ops are sent through the async-queues
+ */
+
+typedef struct {
+	enum {
+		CHASSIS_EVENT_OP_UNSET,
+		CHASSIS_EVENT_OP_ADD
+	} type;
+
+	struct event *ev;
+} chassis_event_op_t;
+
+CHASSIS_API chassis_event_op_t *chassis_event_op_new();
+CHASSIS_API void chassis_event_op_free(chassis_event_op_t *e);
+CHASSIS_API void chassis_event_add(chassis *chas, struct event *ev);
+CHASSIS_API void chassis_event_add_local(chassis *chas, struct event *ev);
+
+/**
+ * a event-thread
+ */
+typedef struct {
+	chassis *chas;
+
+	int notify_fd;
+	struct event notify_fd_event;
+
+	GThread *thr;
+
+	struct event_base *event_base;
+} chassis_event_thread_t;
+
+CHASSIS_API chassis_event_thread_t *chassis_event_thread_new();
+CHASSIS_API void chassis_event_thread_free(chassis_event_thread_t *e);
+CHASSIS_API void chassis_event_handle(int event_fd, short events, void *user_data);
+CHASSIS_API void chassis_event_thread_set_event_base(chassis_event_thread_t *e, struct event_base *event_base);
+CHASSIS_API void *chassis_event_thread_loop(chassis_event_thread_t *);
+
+struct chassis_event_threads_t {
+ 	GPtrArray *event_threads;
+
+	GAsyncQueue *event_queue;
+	int event_notify_fds[2];
+};
+
+CHASSIS_API chassis_event_threads_t *chassis_event_threads_new();
+CHASSIS_API void chassis_event_threads_free(chassis_event_threads_t *threads);
+CHASSIS_API int chassis_event_threads_init_thread(chassis_event_threads_t *threads, chassis_event_thread_t *event_thread, chassis *chas);
+CHASSIS_API void chassis_event_threads_add(chassis_event_threads_t *threads, chassis_event_thread_t *thread);
+CHASSIS_API void chassis_event_threads_start(chassis_event_threads_t *threads);
+
+#endif
 
=== modified file 'src/chassis-mainloop.c'
--- src/chassis-mainloop.c	2009-02-23 23:13:09 +0000
+++ src/chassis-mainloop.c	2009-05-25 08:57:34 +0000
@@ -42,6 +42,7 @@
 #include <glib.h>
 #include "chassis-plugin.h"
 #include "chassis-mainloop.h"
+#include "chassis-event-thread.h"
 #include "chassis-log.h"
 #include "chassis-stats.h"
 
@@ -68,6 +69,8 @@
 	
 	chas->stats = chassis_stats_new();
 
+	chas->threads = chassis_event_threads_new();
+
 	return chas;
 }
 
@@ -120,6 +123,8 @@
 	
 	if (chas->stats) chassis_stats_free(chas->stats);
 
+	if (chas->threads) chassis_event_threads_free(chas->threads);
+
 	g_free(chas);
 }
 
@@ -192,23 +197,12 @@
 	g_log(G_LOG_DOMAIN, glib_log_level, "(libevent) %s", msg);
 }
 
-/**
- * init libevent
- *
- * kqueue has to be called after the fork() of daemonize
- *
- * @param m      global context
- */
-static void chassis_init_libevent(chassis *chas) {
-	chas->event_base  = event_init();
-
-	event_set_log_callback(event_log_use_glib);
-}
 
 int chassis_mainloop(void *_chas) {
 	chassis *chas = _chas;
 	guint i;
 	struct event ev_sigterm, ev_sigint, ev_sighup;
+	chassis_event_thread_t *mainloop_thread;
 
 #ifdef _WIN32
 	WORD wVersionRequested;
@@ -224,8 +218,19 @@
 		return err;	/* err is positive */
 	}
 #endif
-	/* init the event-handlers */
-	chassis_init_libevent(chas);
+	/* redirect logging from libevent to glib */
+	event_set_log_callback(event_log_use_glib);
+
+
+	/* add a event-handler for the "main" events */
+	mainloop_thread = chassis_event_thread_new();
+	chassis_event_threads_init_thread(chas->threads, mainloop_thread, chas);
+	chassis_event_threads_add(chas->threads, mainloop_thread);
+
+	chas->event_base = mainloop_thread->event_base; /* all global events go to the 1st thread */
+
+	g_assert(chas->event_base);
+
 
 	/* setup all plugins all plugins */
 	for (i = 0; i < chas->modules->len; i++) {
@@ -293,28 +298,32 @@
 	}
 #endif
 
+	if (chas->event_thread_count < 1) chas->event_thread_count = 0;
+
+	/* create the event-threads
+	 *
+	 * - dup the async-queue-ping-fds
+	 * - setup the events notification
+	 * */
+	for (i = 0; i < chas->event_thread_count; i++) {
+		chassis_event_thread_t *event_thread;
+	
+		event_thread = chassis_event_thread_new();
+		chassis_event_threads_init_thread(chas->threads, event_thread, chas);
+		chassis_event_threads_add(chas->threads, event_thread);
+	}
+
+	/* start the event threads */
+	if (chas->event_thread_count > 0) {
+		chassis_event_threads_start(chas->threads);
+	}
+
 	/**
-	 * check once a second if we shall shutdown the proxy
+	 * handle signals and all basic events into the main-thread
+	 *
+	 * block until we are asked to shutdown
 	 */
-	while (!chassis_is_shutdown()) {
-		struct timeval timeout;
-		int r;
-
-		timeout.tv_sec = 1;
-		timeout.tv_usec = 0;
-
-		g_assert(event_base_loopexit(chas->event_base, &timeout) == 0);
-
-		r = event_base_dispatch(chas->event_base);
-
-		if (r == -1) {
-			if (errno == EINTR) continue;
-
-			g_critical("%s: event_base_dispatch() failed: %s (%d)", 
-					G_STRLOC, g_strerror(errno), errno);
-			break;
-		}
-	}
+	chassis_event_thread_loop(mainloop_thread);
 
 	signal_del(&ev_sigterm);
 	signal_del(&ev_sigint);
 
=== modified file 'src/chassis-mainloop.h'
--- src/chassis-mainloop.h	2009-02-23 23:13:09 +0000
+++ src/chassis-mainloop.h	2009-05-25 08:57:34 +0000
@@ -43,6 +43,7 @@
 
 typedef struct chassis_private chassis_private;
 typedef struct chassis chassis;
+typedef struct chassis_event_threads_t chassis_event_threads_t;
 
 struct chassis {
 	struct event_base *event_base;
@@ -59,6 +60,11 @@
 	chassis_log *log;
 	
 	chassis_stats_t *stats;			/**< the overall chassis stats, includes lua and glib allocation stats */
+
+	/* network-io threads */
+	gint event_thread_count;
+
+	chassis_event_threads_t *threads;
 };
 
 CHASSIS_API chassis *chassis_init(void) G_GNUC_DEPRECATED;
 
=== modified file 'src/chassis.c'
--- src/chassis.c	2009-05-15 14:23:58 +0000
+++ src/chassis.c	2009-05-25 08:57:34 +0000
@@ -395,6 +395,7 @@
 	guint invoke_dbg_on_crash = 0;
 	guint auto_restart = 0;
 	guint max_files_number = 8192;
+	gint event_thread_count = 0;
 #ifndef _WIN32
 	struct rlimit max_files_rlimit;
 #endif
@@ -431,6 +432,7 @@
 		{ "log-backtrace-on-crash",   0, 0, G_OPTION_ARG_NONE, NULL, "try to invoke debugger on crash", NULL },
 		{ "keepalive",                0, 0, G_OPTION_ARG_NONE, NULL, "try to restart the proxy if it crashed", NULL },
 		{ "max-open-files",           0, 0, G_OPTION_ARG_INT, NULL, "maximum number of open files (ulimit -n)", NULL},
+		{ "event-threads",            0, 0, G_OPTION_ARG_INT, NULL, "number of event-handling threads", NULL},
 		
 		{ NULL,                       0, 0, G_OPTION_ARG_NONE,   NULL, NULL, NULL }
 	};
@@ -501,6 +503,7 @@
 	main_entries[i++].arg_data  = &(invoke_dbg_on_crash);
 	main_entries[i++].arg_data  = &(auto_restart);
 	main_entries[i++].arg_data  = &(max_files_number);
+	main_entries[i++].arg_data  = &(srv->event_thread_count);
 
 	option_ctx = g_option_context_new("- MySQL App Shell");
 	g_option_context_add_main_entries(option_ctx, base_main_entries, GETTEXT_PACKAGE);
@@ -888,6 +891,16 @@
 		exit_code = EXIT_FAILURE;
 		goto exit_nicely;
 	}
+
+	/* make sure that he max-thread-count isn't negative */
+	if (event_thread_count < 0) {
+		g_critical("unknown option: %s", argv[1]);
+
+		exit_code = EXIT_FAILURE;
+		goto exit_nicely;
+	}
+
+	srv->event_thread_count = event_thread_count;
 	
 #ifndef _WIN32	
 	signal(SIGPIPE, SIG_IGN);
@@ -988,7 +1001,6 @@
 		}
 	}
 #endif
-
 	if (chassis_mainloop(srv)) {
 		/* looks like we failed */
 
 
=== modified file 'src/network-conn-pool-lua.c'
--- src/network-conn-pool-lua.c	2009-02-24 00:20:29 +0000
+++ src/network-conn-pool-lua.c	2009-05-25 08:57:34 +0000
@@ -43,6 +43,7 @@
 
 #include "network-mysqld.h"
 #include "network-mysqld-packet.h"
+#include "chassis-event-thread.h"
 #include "network-mysqld-lua.h"
 
 #include "network-conn-pool.h"
@@ -201,7 +202,6 @@
  * proxy from its backend 
  */
 int network_connection_pool_lua_add_connection(network_mysqld_con *con) {
-	chassis *srv = con->srv;
 	network_connection_pool_entry *pool_entry = NULL;
 	network_mysqld_con_lua_t *st = con->plugin_con_state;
 
@@ -215,8 +215,7 @@
 	pool_entry = network_connection_pool_add(st->backend->pool, con->server);
 
 	event_set(&(con->server->event), con->server->fd, EV_READ, network_mysqld_con_idle_handle, pool_entry);
-	event_base_set(srv->event_base, &(con->server->event));
-	event_add(&(con->server->event), NULL);
+	chassis_event_add_local(con->srv, &(con->server->event)); /* add a event, but stay in the same thread */
 	
 	st->backend->connected_clients--;
 	st->backend = NULL;
 
=== modified file 'src/network-mysqld.c'
--- src/network-mysqld.c	2009-02-21 14:09:48 +0000
+++ src/network-mysqld.c	2009-05-25 08:57:34 +0000
@@ -179,6 +179,7 @@
 #include "network-mysqld-packet.h"
 #include "network-conn-pool.h"
 #include "chassis-mainloop.h"
+#include "chassis-event-thread.h"
 #include "lua-scope.h"
 #include "glib-ext.h"
 
@@ -761,8 +762,7 @@
 
 #define WAIT_FOR_EVENT(ev_struct, ev_type, timeout) \
 	event_set(&(ev_struct->event), ev_struct->fd, ev_type, network_mysqld_con_handle, user_data); \
-	event_base_set(srv->event_base, &(ev_struct->event));\
-	event_add(&(ev_struct->event), timeout);
+	chassis_event_add(srv, &(ev_struct->event));
 
 	/**
 	 * loop on the same connection as long as we don't end up in a stable state
 
=== modified file 'tests/unit/Makefile.am'
--- tests/unit/Makefile.am	2009-04-02 22:10:21 +0000
+++ tests/unit/Makefile.am	2009-05-25 08:57:34 +0000
@@ -74,10 +74,11 @@
 	check_chassis_path.c \
 	$(top_srcdir)/src/chassis-log.c \
 	$(top_srcdir)/src/chassis-mainloop.c \
+	$(top_srcdir)/src/chassis-event-thread.c \
 	$(top_srcdir)/src/chassis-plugin.c \
 	$(top_srcdir)/src/chassis-stats.c
 check_chassis_path_CPPFLAGS = -I$(top_srcdir)/src $(GLIB_CFLAGS) $(MYSQL_CFLAGS) $(GMODULE_CFLAGS)
-check_chassis_path_LDADD    = $(GLIB_LIBS) $(GMODULE_LIBS) $(EVENT_LIBS)
+check_chassis_path_LDADD    = $(GLIB_LIBS) $(GMODULE_LIBS) $(EVENT_LIBS) $(GTHREAD_LIBS)
 
 t_network_backend_SOURCES  = \
 	t_network_backend.c \
 
=== modified file 'tests/unit/check_chassis_path.c'
--- tests/unit/check_chassis_path.c	2009-02-23 23:13:09 +0000
+++ tests/unit/check_chassis_path.c	2009-05-25 08:57:34 +0000
@@ -95,6 +95,8 @@
 /*@}*/
 
 int main(int argc, char **argv) {
+	g_thread_init(NULL);
+
 	g_test_init(&argc, &argv, NULL);
 	g_test_bug_base("http://bugs.mysql.com/");