/*

 * Soft:        Keepalived is a failover program for the LVS project

 *              <www.linuxvirtualserver.org>. It monitor & manipulate

 *              a loadbalanced server pool using multi-layer checks.

 *

 * Part:        Scheduling framework. This code is highly inspired from

 *              the thread management routine (thread.c) present in the

 *              very nice zebra project (http://www.zebra.org).

 *

 * Author:      Alexandre Cassen, <acassen@linux-vs.org>

 *

 *              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.

 *

 *              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; either version

 *              2 of the License, or (at your option) any later version.

 *

 * Copyright (C) 2001-2017 Alexandre Cassen, <acassen@gmail.com>

 */

#include "config.h"

/* SNMP should be included first: it redefines "FREE" */

#ifdef _WITH_SNMP_

#include <net-snmp/net-snmp-config.h>

#include <net-snmp/net-snmp-includes.h>

#include <net-snmp/agent/net-snmp-agent-includes.h>

#undef FREE

#endif

#ifndef _DEBUG_

#define NDEBUG

#endif

#include <assert.h>

#include <errno.h>

#include <sys/wait.h>

#include <sys/timerfd.h>

#include <sys/epoll.h>

#include <unistd.h>

#ifdef HAVE_SIGNALFD

#include <sys/signalfd.h>

#endif

#include <sys/utsname.h>

#include <linux/version.h>

#include "scheduler.h"

#include "memory.h"

#include "rbtree.h"

#include "utils.h"

#include "signals.h"

#include "logger.h"

#include "bitops.h"

#include "git-commit.h"

#include "timer.h"

#if !HAVE_EPOLL_CREATE1 || !defined TFD_NONBLOCK

#include "old_socket.h"

#endif

#ifdef THREAD_DUMP

typedef struct _func_det {

	const char *name;

	int (*func)(thread_t *);

	rb_node_t n;

} func_det_t;

#endif

/* global vars */

thread_master_t *master = NULL;

#ifndef _DEBUG_

prog_type_t prog_type;		/* Parent/VRRP/Checker process */

#endif

#ifdef _WITH_SNMP_

bool snmp_running;		/* True if this process is running SNMP */

#endif

/* local variables */

static bool shutting_down;

static int sav_argc;

static char **sav_argv;

#ifdef _EPOLL_DEBUG_

bool do_epoll_debug;

#endif

#ifdef _EPOLL_THREAD_DUMP_

bool do_epoll_thread_dump;

#endif

#ifdef THREAD_DUMP

static rb_root_t funcs = RB_ROOT;

#endif

#ifdef _VRRP_FD_DEBUG_

static void (*extra_threads_debug)(void);

#endif

/* Function that returns prog_name if pid is a known child */

static char const * (*child_finder_name)(pid_t);

#ifdef THREAD_DUMP

static const char *

get_thread_type_str(thread_type_t id)

{

	if (id == THREAD_READ) return "READ";

	if (id == THREAD_WRITE) return "WRITE";

	if (id == THREAD_TIMER) return "TIMER";

	if (id == THREAD_TIMER_SHUTDOWN) return "TIMER_SHUTDOWN";

	if (id == THREAD_EVENT) return "EVENT";

	if (id == THREAD_CHILD) return "CHILD";

	if (id == THREAD_READY) return "READY";

	if (id == THREAD_UNUSED) return "UNUSED";

	if (id == THREAD_WRITE_TIMEOUT) return "WRITE_TIMEOUT";

	if (id == THREAD_READ_TIMEOUT) return "READ_TIMEOUT";

	if (id == THREAD_CHILD_TIMEOUT) return "CHILD_TIMEOUT";

	if (id == THREAD_CHILD_TERMINATED) return "CHILD_TERMINATED";

	if (id == THREAD_TERMINATE_START) return "TERMINATE_START";

	if (id == THREAD_TERMINATE) return "TERMINATE";

	if (id == THREAD_READY_FD) return "READY_FD";

	if (id == THREAD_READ_ERROR) return "READ_ERROR";

	if (id == THREAD_WRITE_ERROR) return "WRITE_ERROR";

#ifdef USE_SIGNAL_THREADS

	if (id == THREAD_SIGNAL) return "SIGNAL";

#endif

	return "unknown";

}

static inline int

function_cmp(const func_det_t *func1, const func_det_t *func2)

{

	if (func1->func < func2->func)

		return -1;

	if (func1->func > func2->func)

		return 1;

	return 0;

}

static const char *

get_function_name(int (*func)(thread_t *))

{

	func_det_t func_det = { .func = func };

	func_det_t *match;

	static char address[19];

	if (!RB_EMPTY_ROOT(&funcs)) {

		match = rb_search(&funcs, &func_det, n, function_cmp);

		if (match)

			return match->name;

	}

	snprintf(address, sizeof address, "%p", func);

	return address;

}

const char *

get_signal_function_name(void (*func)(void *, int))

{

	/* The cast should really be (int (*)(thread_t *))func, but gcc 8.1 produces

	 * a warning with -Wcast-function-type, that the cast is to an incompatible

	 * function type. Since we don't actually call the function, but merely use

	 * it to compare function addresses, what we cast it do doesn't really matter */

	return get_function_name((void *)func);

}

void

register_thread_address(const char *func_name, int (*func)(thread_t *))

{

	func_det_t *func_det;

	func_det = (func_det_t *) MALLOC(sizeof(func_det_t));

	if (!func_det)

		return;

	func_det->name = func_name;

	func_det->func = func;

	rb_insert_sort(&funcs, func_det, n, function_cmp);

}

void

register_signal_handler_address(const char *func_name, void (*func)(void *, int))

{

	/* See comment in get_signal_function_name() above */

	register_thread_address(func_name, (void *)func);

}

void

deregister_thread_addresses(void)

{

	func_det_t *func_det, *func_det_tmp;

	if (RB_EMPTY_ROOT(&funcs))

		return;

	rb_for_each_entry_safe(func_det, func_det_tmp, &funcs, n) {

		rb_erase(&func_det->n, &funcs);

		FREE(func_det);

	}

}

#endif

#ifdef _VRRP_FD_DEBUG_

void

set_extra_threads_debug(void (*func)(void))

{

	extra_threads_debug = func;

}

#endif

/* Move ready thread into ready queue */

static int

thread_move_ready(thread_master_t *m, rb_root_cached_t *root, thread_t *thread, int type)

{

	rb_erase_cached(&thread->n, root);

	INIT_LIST_HEAD(&thread->next);

	list_add_tail(&thread->next, &m->ready);

	if (thread->type != THREAD_TIMER_SHUTDOWN)

		thread->type = type;

	return 0;

}

/* Move ready thread into ready queue */

static void

thread_rb_move_ready(thread_master_t *m, rb_root_cached_t *root, int type)

{

	thread_t *thread, *thread_tmp;

	rb_for_each_entry_safe_cached(thread, thread_tmp, root, n) {

		if (thread->sands.tv_sec == TIMER_DISABLED || timercmp(&time_now, &thread->sands, <))

			break;

		if (type == THREAD_READ_TIMEOUT)

			thread->event->read = NULL;

		else if (type == THREAD_WRITE_TIMEOUT)

			thread->event->write = NULL;

		thread_move_ready(m, root, thread, type);

	}

}

/* Update timer value */

static void

thread_update_timer(rb_root_cached_t *root, timeval_t *timer_min)

{

	thread_t *first;

	if (!root->rb_root.rb_node)

		return;

	first = rb_entry(rb_first_cached(root), thread_t, n);

	if (!first)

		return;

	if (first->sands.tv_sec == TIMER_DISABLED)

		return;

	if (!timerisset(timer_min) ||

	    timercmp(&first->sands, timer_min, <=))

		*timer_min = first->sands;

}

/* Compute the wait timer. Take care of timeouted fd */

static void

thread_set_timer(thread_master_t *m)

{

	timeval_t timer_wait;

	struct itimerspec its;

	/* Prepare timer */

	timerclear(&timer_wait);

	thread_update_timer(&m->timer, &timer_wait);

	thread_update_timer(&m->write, &timer_wait);

	thread_update_timer(&m->read, &timer_wait);

	thread_update_timer(&m->child, &timer_wait);

	if (timerisset(&timer_wait)) {

		/* Re-read the current time to get the maximum accuracy */

		set_time_now();

		/* Take care about monotonic clock */

		timersub(&timer_wait, &time_now, &timer_wait);

		if (timer_wait.tv_sec < 0) {

			/* This will disable the timerfd */

			timerclear(&timer_wait);

		}

	} else {

		/* set timer to a VERY long time */

		timer_wait.tv_sec = LONG_MAX;

		timer_wait.tv_usec = 0;

	}

	its.it_value.tv_sec = timer_wait.tv_sec;

	if (!timerisset(&timer_wait)) {

		/* We could try to avoid doing the epoll_wait since

		 * testing shows it takes about 4 microseconds

		 * for the timer to expire. */

		its.it_value.tv_nsec = 1;

	}

	else

		its.it_value.tv_nsec = timer_wait.tv_usec * 1000;

	/* We don't want periodic timer expiry */

	its.it_interval.tv_sec = its.it_interval.tv_nsec = 0;

	timerfd_settime(m->timer_fd, 0, &its, NULL);

#ifdef _EPOLL_DEBUG_

	if (do_epoll_debug)

		log_message(LOG_INFO, "Setting timer_fd %lu.%9.9ld", its.it_value.tv_sec, its.it_value.tv_nsec);

#endif

}

static int

thread_timerfd_handler(thread_t *thread)

{

	thread_master_t *m = thread->master;

	uint64_t expired;

	ssize_t len;

	len = read(m->timer_fd, &expired, sizeof(expired));

	if (len < 0)

		log_message(LOG_ERR, "scheduler: Error reading on timerfd fd:%d (%m)", m->timer_fd);

	/* Read, Write, Timer, Child thread. */

	thread_rb_move_ready(m, &m->read, THREAD_READ_TIMEOUT);

	thread_rb_move_ready(m, &m->write, THREAD_WRITE_TIMEOUT);

	thread_rb_move_ready(m, &m->timer, THREAD_READY);

	thread_rb_move_ready(m, &m->child, THREAD_CHILD_TIMEOUT);

	/* Register next timerfd thread */

	m->timer_thread = thread_add_read(m, thread_timerfd_handler, NULL, m->timer_fd, TIMER_NEVER);

	return 0;

}

/* Child PID cmp helper */

static inline int

thread_child_pid_cmp(thread_t *t1, thread_t *t2)

{

	return t1->u.c.pid - t2->u.c.pid;

}

void

set_child_finder_name(char const * (*func)(pid_t))

{

	child_finder_name = func;

}

void

save_cmd_line_options(int argc, char **argv)

{

	sav_argc = argc;

	sav_argv = argv;

}

#ifndef _DEBUG_

static const char *

get_end(const char *str, size_t max_len)

{

	size_t len = strlen(str);

	const char *end;

	if (len <= max_len)

		return str + len;

	end = str + max_len;

	if (*end == ' ')

		return end;

	while (end > str && *--end != ' ');

	if (end > str)

		return end;

	return str + max_len;

}

static void

log_options(const char *option, const char *option_str, unsigned indent)

{

	const char *p = option_str;

	size_t opt_len = strlen(option);

	const char *end;

	bool first_line = true;

	while (*p) {

		/* Skip leading spaces */

		while (*p == ' ')

			p++;

		end = get_end(p, 100 - opt_len);

		if (first_line) {

			log_message(LOG_INFO, "%*s%s: %.*s", indent, "", option, (int)(end - p), p);

			first_line = false;

		}

		else

			log_message(LOG_INFO, "%*s%.*s", (int)(indent + opt_len + 2), "", (int)(end - p), p);

		p = end;

	}

}

void

log_command_line(unsigned indent)

{

	size_t len = 0;

	char *log_str;

	char *p;

	int i;

	if (!sav_argv)

		return;

	for (i = 0; i < sav_argc; i++)

		len += strlen(sav_argv[i]) + 3;	/* Add opening and closing 's, and following space or '\0' */

	log_str = MALLOC(len);

	for (i = 0, p = log_str; i < sav_argc; i++)

		p += sprintf(p, "%s'%s'", i ? " " : "", sav_argv[i]);

	log_options("Command line", log_str, indent);

	FREE(log_str);

}

/* report_child_status returns true if the exit is a hard error, so unable to continue */

bool

report_child_status(int status, pid_t pid, char const *prog_name)

{

	char const *prog_id = NULL;

	char pid_buf[12];	/* "pid 4194303" + '\0' - see definition of PID_MAX_LIMIT in include/linux/threads.h */

	int exit_status ;

	if (prog_name)

		prog_id = prog_name;

	else if (child_finder_name)

		prog_id = child_finder_name(pid);

	if (!prog_id) {

		snprintf(pid_buf, sizeof(pid_buf), "pid %d", pid);

		prog_id = pid_buf;

	}

	if (WIFEXITED(status)) {

		exit_status = WEXITSTATUS(status);

		/* Handle exit codes of vrrp or checker child */

		if (exit_status == KEEPALIVED_EXIT_FATAL ||

		    exit_status == KEEPALIVED_EXIT_CONFIG) {

			log_message(LOG_INFO, "%s exited with permanent error %s. Terminating", prog_id, exit_status == KEEPALIVED_EXIT_CONFIG ? "CONFIG" : "FATAL" );

			return true;

		}

		if (exit_status != EXIT_SUCCESS)

			log_message(LOG_INFO, "%s exited with status %d", prog_id, exit_status);

	} else if (WIFSIGNALED(status)) {

		if (WTERMSIG(status) == SIGSEGV) {

			struct utsname uname_buf;

			log_message(LOG_INFO, "%s exited due to segmentation fault (SIGSEGV).", prog_id);

			log_message(LOG_INFO, "  %s", "Please report a bug at https://github.com/acassen/keepalived/issues");

			log_message(LOG_INFO, "  %s", "and include this log from when keepalived started, a description");

			log_message(LOG_INFO, "  %s", "of what happened before the crash, your configuration file and the details below.");

			log_message(LOG_INFO, "  %s", "Also provide the output of keepalived -v, what Linux distro and version");

			log_message(LOG_INFO, "  %s", "you are running on, and whether keepalived is being run in a container or VM.");

			log_message(LOG_INFO, "  %s", "A failure to provide all this information may mean the crash cannot be investigated.");

			log_message(LOG_INFO, "  %s", "If you are able to provide a stack backtrace with gdb that would really help.");

			log_message(LOG_INFO, "  Source version %s %s%s", PACKAGE_VERSION,

#ifdef GIT_COMMIT

									   ", git commit ", GIT_COMMIT

#else

									   "", ""

#endif

				   );

			log_message(LOG_INFO, "  Built with kernel headers for Linux %d.%d.%d",

						(LINUX_VERSION_CODE >> 16) & 0xff,

						(LINUX_VERSION_CODE >>  8) & 0xff,

						(LINUX_VERSION_CODE      ) & 0xff);

			uname(&uname_buf);

			log_message(LOG_INFO, "  Running on %s %s %s", uname_buf.sysname, uname_buf.release, uname_buf.version);

			log_command_line(2);

			log_options("configure options", KEEPALIVED_CONFIGURE_OPTIONS, 2);

			log_options("Config options", CONFIGURATION_OPTIONS, 2);

			log_options("System options", SYSTEM_OPTIONS, 2);

//			if (__test_bit(DONT_RESPAWN_BIT, &debug))

//				segv_termination = true;

		}

		else

			log_message(LOG_INFO, "%s exited due to signal %d", prog_id, WTERMSIG(status));

	}

	return false;

}

#endif

/* epoll related */

static int

thread_events_resize(thread_master_t *m, int delta)

{

	unsigned int new_size;

	m->epoll_count += delta;

	if (m->epoll_count < m->epoll_size)

		return 0;

	new_size = ((m->epoll_count / THREAD_EPOLL_REALLOC_THRESH) + 1);

	new_size *= THREAD_EPOLL_REALLOC_THRESH;

	if (m->epoll_events)

		FREE(m->epoll_events);

	m->epoll_events = MALLOC(new_size * sizeof(struct epoll_event));

	if (!m->epoll_events) {

		m->epoll_size = 0;

		return -1;

	}

	m->epoll_size = new_size;

	return 0;

}

static inline int

thread_event_cmp(const thread_event_t *event1, const thread_event_t *event2)

{

	if (event1->fd < event2->fd)

		return -1;

	if (event1->fd > event2->fd)

		return 1;

	return 0;

}

static thread_event_t *

thread_event_new(thread_master_t *m, int fd)

{

	thread_event_t *event;

	event = (thread_event_t *) MALLOC(sizeof(thread_event_t));

	if (!event)

		return NULL;

	if (thread_events_resize(m, 1) < 0) {

		FREE(event);

		return NULL;

	}

	event->fd = fd;

	rb_insert_sort(&m->io_events, event, n, thread_event_cmp);

	return event;

}

static thread_event_t *

thread_event_get(thread_master_t *m, int fd)

{

	thread_event_t event = { .fd = fd };

	return rb_search(&m->io_events, &event, n, thread_event_cmp);

}

static int

thread_event_set(thread_t *thread)

{

	thread_event_t *event = thread->event;

	thread_master_t *m = thread->master;

	struct epoll_event ev;

	int op;

	memset(&ev, 0, sizeof(struct epoll_event));

	ev.data.ptr = event;

	if (__test_bit(THREAD_FL_READ_BIT, &event->flags))

		ev.events |= EPOLLIN;

	if (__test_bit(THREAD_FL_WRITE_BIT, &event->flags))

		ev.events |= EPOLLOUT;

	if (__test_bit(THREAD_FL_EPOLL_BIT, &event->flags))

		op = EPOLL_CTL_MOD;

	else

		op = EPOLL_CTL_ADD;

	if (epoll_ctl(m->epoll_fd, op, event->fd, &ev) < 0) {

		log_message(LOG_INFO, "scheduler: Error performing control on EPOLL instance (%m)");

		return -1;

	}

	__set_bit(THREAD_FL_EPOLL_BIT, &event->flags);

	return 0;

}

static int

thread_event_cancel(thread_t *thread)

{

	thread_event_t *event = thread->event;

	thread_master_t *m = thread->master;

	if (!event) {

		log_message(LOG_INFO, "scheduler: Error performing epoll_ctl DEL op no event linked?!");

		return -1;

	}

	if (m->epoll_fd != -1 &&

	    epoll_ctl(m->epoll_fd, EPOLL_CTL_DEL, event->fd, NULL) < 0 &&

	    errno != EBADF) {

		log_message(LOG_INFO, "scheduler: Error performing epoll_ctl DEL op for fd:%d (%m)", event->fd);

		return -1;

	}

	rb_erase(&event->n, &m->io_events);

	if (event == m->current_event)

		m->current_event = NULL;

	FREE(thread->event);

	return 0;

}

static int

thread_event_del(thread_t *thread, unsigned flag)

{

	thread_event_t *event = thread->event;

	if (!__test_bit(flag, &event->flags))

		return 0;

	if (flag == THREAD_FL_EPOLL_READ_BIT) {

		__clear_bit(THREAD_FL_READ_BIT, &event->flags);

		if (!__test_bit(THREAD_FL_EPOLL_WRITE_BIT, &event->flags))

			return thread_event_cancel(thread);

		event->read = NULL;

	}

	else if (flag == THREAD_FL_EPOLL_WRITE_BIT) {

		__clear_bit(THREAD_FL_WRITE_BIT, &event->flags);

		if (!__test_bit(THREAD_FL_EPOLL_READ_BIT, &event->flags))

			return thread_event_cancel(thread);

		event->write = NULL;

	}

	if (thread_event_set(thread) < 0)

		return -1;

	__clear_bit(flag, &event->flags);

	return 0;

}

/* Make thread master. */

thread_master_t *

thread_make_master(void)

{

	thread_master_t *new;

	new = (thread_master_t *) MALLOC(sizeof (thread_master_t));

#if HAVE_EPOLL_CREATE1

	new->epoll_fd = epoll_create1(EPOLL_CLOEXEC);

#else

	new->epoll_fd = epoll_create(1);

#endif

	if (new->epoll_fd < 0) {

		log_message(LOG_INFO, "scheduler: Error creating EPOLL instance (%m)");

		FREE(new);

		return NULL;

	}

#if !HAVE_EPOLL_CREATE1

	if (set_sock_flags(new->epoll_fd, F_SETFD, FD_CLOEXEC))

		log_message(LOG_INFO, "Unable to set CLOEXEC on epoll_fd - %s (%d)", strerror(errno), errno);

#endif

	new->read = RB_ROOT_CACHED;

	new->write = RB_ROOT_CACHED;

	new->timer = RB_ROOT_CACHED;

	new->child = RB_ROOT_CACHED;

	new->io_events = RB_ROOT;

	new->child_pid = RB_ROOT;

	INIT_LIST_HEAD(&new->event);

#ifdef USE_SIGNAL_THREADS

	INIT_LIST_HEAD(&new->signal);

#endif

	INIT_LIST_HEAD(&new->ready);

	INIT_LIST_HEAD(&new->unuse);

	/* Register timerfd thread */

	new->timer_fd = timerfd_create(CLOCK_MONOTONIC,

#ifdef TFD_NONBLOCK				/* Since Linux 2.6.27 */

						        TFD_NONBLOCK | TFD_CLOEXEC

#else

							0

#endif

										  );

	if (new->timer_fd < 0) {

		log_message(LOG_ERR, "scheduler: Cant create timerfd (%m)");

		FREE(new);

		return NULL;

	}

#ifndef TFD_NONBLOCK

	if (set_sock_flags(new->timer_fd, F_SETFL, O_NONBLOCK))

		log_message(LOG_INFO, "Unable to set NONBLOCK on timer_fd - %s (%d)", strerror(errno), errno);

	if (set_sock_flags(new->timer_fd, F_SETFD, FD_CLOEXEC))

		log_message(LOG_INFO, "Unable to set CLOEXEC on timer_fd - %s (%d)", strerror(errno), errno);

#endif

	new->signal_fd = signal_handler_init();

	new->timer_thread = thread_add_read(new, thread_timerfd_handler, NULL, new->timer_fd, TIMER_NEVER);

	add_signal_read_thread(new);

	return new;

}

#ifdef THREAD_DUMP

static char *

timer_delay(timeval_t sands)

{

	static char str[42];

	if (sands.tv_sec == TIMER_DISABLED)

		return "NEVER";

	if (sands.tv_sec == 0 && sands.tv_usec == 0)

		return "UNSET";

	if (timercmp(&sands, &time_now, >=)) {

		sands = timer_sub_now(sands);

		snprintf(str, sizeof str, "%lu.%6.6ld", sands.tv_sec, sands.tv_usec);

	} else {

		timersub(&time_now, &sands, &sands);

		snprintf(str, sizeof str, "-%lu.%6.6ld", sands.tv_sec, sands.tv_usec);

	}

	return str;

}

/* Dump rbtree */

static void

thread_rb_dump(rb_root_cached_t *root, const char *tree, FILE *fp)

{

	thread_t *thread;

	int i = 1;

	conf_write(fp, "----[ Begin rb_dump %s ]----", tree);

	rb_for_each_entry_cached(thread, root, n)

		conf_write(fp, "#%.2d Thread type %s, event_fd %d, val/fd/pid %d, timer: %s, func %s(), id %ld", i++, get_thread_type_str(thread->type), thread->event ? thread->event->fd: -2, thread->u.val, timer_delay(thread->sands), get_function_name(thread->func), thread->id);

	conf_write(fp, "----[ End rb_dump ]----");

}

static void

thread_list_dump(list_head_t *l, const char *list, FILE *fp)

{

	thread_t *thread;

	int i = 1;

	conf_write(fp, "----[ Begin list_dump %s ]----", list);

	list_for_each_entry(thread, l, next)

		conf_write(fp, "#%.2d Thread:%p type %s func %s() id %ld",

				i++, thread, get_thread_type_str(thread->type), get_function_name(thread->func), thread->id);

	conf_write(fp, "----[ End list_dump ]----");

}

static void

event_rb_dump(rb_root_t *root, const char *tree, FILE *fp)

{

	thread_event_t *event;

	int i = 1;

	conf_write(fp, "----[ Begin rb_dump %s ]----", tree);

	rb_for_each_entry(event, root, n)

		conf_write(fp, "#%.2d event %p fd %d, flags: 0x%lx, read %p, write %p", i++, event, event->fd, event->flags, event->read, event->write);

	conf_write(fp, "----[ End rb_dump ]----");

}

void

dump_thread_data(thread_master_t *m, FILE *fp)

{

	thread_rb_dump(&m->read, "read", fp);

	thread_rb_dump(&m->write, "write", fp);

	thread_rb_dump(&m->child, "child", fp);

	thread_rb_dump(&m->timer, "timer", fp);

	thread_list_dump(&m->event, "event", fp);

	thread_list_dump(&m->ready, "ready", fp);

#ifdef USE_SIGNAL_THREADS

	thread_list_dump(&m->signal, "signal", fp);

#endif

	thread_list_dump(&m->unuse, "unuse", fp);

	event_rb_dump(&m->io_events, "io_events", fp);

}

#endif

/* declare thread_timer_cmp() for rbtree compares */

RB_TIMER_CMP(thread);

/* Free all unused thread. */

static void

thread_clean_unuse(thread_master_t * m)

{

	thread_t *thread, *thread_tmp;

	list_head_t *l = &m->unuse;

	list_for_each_entry_safe(thread, thread_tmp, l, next) {

		list_head_del(&thread->next);

		/* free the thread */

		FREE(thread);

		m->alloc--;

	}

	INIT_LIST_HEAD(l);

}

/* Move thread to unuse list. */

static void

thread_add_unuse(thread_master_t *m, thread_t *thread)

{

	assert(m != NULL);

	thread->type = THREAD_UNUSED;

	thread->event = NULL;

	INIT_LIST_HEAD(&thread->next);

	list_add_tail(&thread->next, &m->unuse);

}

/* Move list element to unuse queue */

static void

thread_destroy_list(thread_master_t *m, list_head_t *l)

{

	thread_t *thread, *thread_tmp;

	list_for_each_entry_safe(thread, thread_tmp, l, next) {

		if (thread->event) {

			thread_del_read(thread);

			thread_del_write(thread);

		}

		list_head_del(&thread->next);

		thread_add_unuse(m, thread);

	}

}

static void

thread_destroy_rb(thread_master_t *m, rb_root_cached_t *root)

{

	thread_t *thread, *thread_tmp;

	rb_for_each_entry_safe_cached(thread, thread_tmp, root, n) {

		rb_erase_cached(&thread->n, root);

		/* Do we have a thread_event, and does it need deleting? */

		if (thread->type == THREAD_READ)

			thread_del_read(thread);

		else if (thread->type == THREAD_WRITE)

			thread_del_write(thread);

		thread_add_unuse(m, thread);

	}

}

/* Cleanup master */

void

thread_cleanup_master(thread_master_t * m)

{

	/* Unuse current thread lists */

	thread_destroy_rb(m, &m->read);

	thread_destroy_rb(m, &m->write);

	thread_destroy_rb(m, &m->timer);

	thread_destroy_rb(m, &m->child);

	thread_destroy_list(m, &m->event);

#ifdef USE_SIGNAL_THREADS

	thread_destroy_list(m, &m->signal);

#endif

	thread_destroy_list(m, &m->ready);

	m->child_pid = RB_ROOT;

	/* Clean garbage */

	thread_clean_unuse(m);