~drizzle-trunk/drizzle/development

/* Copyright (C) 2000-2003 MySQL AB

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

#include "mysql_priv.h"

#include <m_ctype.h>

#include <my_dir.h>

#include <my_bit.h>

#include "slave.h"

#include "rpl_mi.h"

#include "sql_repl.h"

#include "rpl_filter.h"

#include "repl_failsafe.h"

#include "stacktrace.h"

#include "mysqld_suffix.h"

#include "mysys_err.h"

#include "../storage/myisam/ha_myisam.h"

#ifdef HAVE_SYS_PRCTL_H

#include <sys/prctl.h>

#endif

#ifndef DEFAULT_SKIP_THREAD_PRIORITY

#define DEFAULT_SKIP_THREAD_PRIORITY 0

#endif

#include <thr_alarm.h>

#include <errmsg.h>

#define mysqld_charset &my_charset_latin1

#ifdef HAVE_purify

#define IF_PURIFY(A,B) (A)

#else

#define IF_PURIFY(A,B) (B)

#endif

#if SIZEOF_CHARP == 4

#define MAX_MEM_TABLE_SIZE ~(ulong) 0

#else

#define MAX_MEM_TABLE_SIZE ~(ulonglong) 0

#endif

/* We have HAVE_purify below as this speeds up the shutdown of MySQL */

#if defined(HAVE_DEC_3_2_THREADS) || defined(SIGNALS_DONT_BREAK_READ) || defined(HAVE_purify) && defined(__linux__)

#define HAVE_CLOSE_SERVER_SOCK 1

#endif

extern "C" {					// Because of SCO 3.2V4.2

#include <errno.h>

#include <sys/stat.h>

#ifndef __GNU_LIBRARY__

#define __GNU_LIBRARY__				// Skip warnings in getopt.h

#endif

#include <my_getopt.h>

#ifdef HAVE_SYSENT_H

#include <sysent.h>

#endif

#ifdef HAVE_PWD_H

#include <pwd.h>				// For getpwent

#endif

#ifdef HAVE_GRP_H

#include <grp.h>

#endif

#include <my_net.h>

#include <sys/resource.h>

#ifdef HAVE_SELECT_H

#  include <select.h>

#endif

#ifdef HAVE_SYS_SELECT_H

#include <sys/select.h>

#endif

#include <sys/utsname.h>

#ifdef HAVE_SYS_MMAN_H

#include <sys/mman.h>

#endif

#define SIGNAL_FMT "signal %d"

#if defined(__FreeBSD__) && defined(HAVE_IEEEFP_H)

#include <ieeefp.h>

#ifdef HAVE_FP_EXCEPT				// Fix type conflict

typedef fp_except fp_except_t;

#endif

#endif /* __FreeBSD__ && HAVE_IEEEFP_H */

#ifdef HAVE_FPU_CONTROL_H

#include <fpu_control.h>

#endif

#ifdef HAVE_SYS_FPU_H

/* for IRIX to use set_fpc_csr() */

#include <sys/fpu.h>

#endif

inline void setup_fpu()

{

#if defined(__FreeBSD__) && defined(HAVE_IEEEFP_H)

  /*

     We can't handle floating point exceptions with threads, so disable

     this on freebsd.

     Don't fall for overflow, underflow,divide-by-zero or loss of precision

  */

#if defined(__i386__)

  fpsetmask(~(FP_X_INV | FP_X_DNML | FP_X_OFL | FP_X_UFL | FP_X_DZ |

	      FP_X_IMP));

#else

  fpsetmask(~(FP_X_INV |             FP_X_OFL | FP_X_UFL | FP_X_DZ |

              FP_X_IMP));

#endif /* __i386__ */

#endif /* __FreeBSD__ && HAVE_IEEEFP_H */

  /*

    x86 (32-bit) requires FPU precision to be explicitly set to 64 bit for

    portable results of floating point operations

  */

#if defined(__i386__) && defined(HAVE_FPU_CONTROL_H) && defined(_FPU_DOUBLE)

  fpu_control_t cw;

  _FPU_GETCW(cw);

  cw= (cw & ~_FPU_EXTENDED) | _FPU_DOUBLE;

  _FPU_SETCW(cw);

#endif /* __i386__ && HAVE_FPU_CONTROL_H && _FPU_DOUBLE */

}

} /* cplusplus */

#define MYSQL_KILL_SIGNAL SIGTERM

#include <my_pthread.h>			// For thr_setconcurency()

#ifdef SOLARIS

extern "C" int gethostname(char *name, int namelen);

#endif

extern "C" sig_handler handle_segfault(int sig);

/* Constants */

const char *show_comp_option_name[]= {"YES", "NO", "DISABLED"};

/*

  WARNING: When adding new SQL modes don't forget to update the

           tables definitions that stores it's value.

           (ie: mysql.event, mysql.proc)

*/

static const char *optimizer_switch_names[]=

{

  "no_materialization", "no_semijoin",

  NullS

};

/* Corresponding defines are named OPTIMIZER_SWITCH_XXX */

static const unsigned int optimizer_switch_names_len[]=

{

  /*no_materialization*/          19,

  /*no_semijoin*/                 11

};

TYPELIB optimizer_switch_typelib= { array_elements(optimizer_switch_names)-1,"",

                                    optimizer_switch_names,

                                    (unsigned int *)optimizer_switch_names_len };

static const char *tc_heuristic_recover_names[]=

{

  "COMMIT", "ROLLBACK", NullS

};

static TYPELIB tc_heuristic_recover_typelib=

{

  array_elements(tc_heuristic_recover_names)-1,"",

  tc_heuristic_recover_names, NULL

};

const char *first_keyword= "first", *binary_keyword= "BINARY";

const char *my_localhost= "localhost";

#if SIZEOF_OFF_T > 4 && defined(BIG_TABLES)

#define GET_HA_ROWS GET_ULL

#else

#define GET_HA_ROWS GET_ULONG

#endif

/*

  Used with --help for detailed option

*/

static my_bool opt_help= 0, opt_verbose= 0;

arg_cmp_func Arg_comparator::comparator_matrix[5][2] =

{{&Arg_comparator::compare_string,     &Arg_comparator::compare_e_string},

 {&Arg_comparator::compare_real,       &Arg_comparator::compare_e_real},

 {&Arg_comparator::compare_int_signed, &Arg_comparator::compare_e_int},

 {&Arg_comparator::compare_row,        &Arg_comparator::compare_e_row},

 {&Arg_comparator::compare_decimal,    &Arg_comparator::compare_e_decimal}};

const char *log_output_names[] = { "NONE", "FILE", "TABLE", NullS};

static const unsigned int log_output_names_len[]= { 4, 4, 5, 0 };

TYPELIB log_output_typelib= {array_elements(log_output_names)-1,"",

                             log_output_names, 

                             (unsigned int *) log_output_names_len};

/* static variables */

/* the default log output is log tables */

static bool lower_case_table_names_used= 0;

static bool volatile select_thread_in_use, signal_thread_in_use;

static bool volatile ready_to_exit;

static my_bool opt_debugging= 0, opt_external_locking= 0, opt_console= 0;

static my_bool opt_short_log_format= 0;

static uint kill_cached_threads, wake_thread;

static ulong killed_threads, thread_created;

static ulong max_used_connections;

static volatile ulong cached_thread_count= 0;

static char *mysqld_user, *mysqld_chroot, *log_error_file_ptr;

static char *opt_init_slave, *language_ptr, *opt_init_connect;

static char *default_character_set_name;

static char *character_set_filesystem_name;

static char *lc_time_names_name;

static char *my_bind_addr_str;

static char *default_collation_name; 

static char *default_storage_engine_str;

static char compiled_default_collation_name[]= MYSQL_DEFAULT_COLLATION_NAME;

static I_List<THD> thread_cache;

static double long_query_time;

static pthread_cond_t COND_thread_cache, COND_flush_thread_cache;

/* Global variables */

bool opt_update_log, opt_bin_log;

my_bool opt_log, opt_slow_log;

ulong log_output_options;

my_bool opt_log_queries_not_using_indexes= 0;

bool opt_error_log= IF_WIN(1,0);

bool opt_disable_networking=0, opt_skip_show_db=0;

my_bool opt_character_set_client_handshake= 1;

bool server_id_supplied = 0;

bool opt_endinfo, using_udf_functions;

my_bool locked_in_memory;

bool opt_using_transactions, using_update_log;

bool volatile abort_loop;

bool volatile shutdown_in_progress;

my_bool opt_skip_slave_start = 0; ///< If set, slave is not autostarted

my_bool opt_reckless_slave = 0;

my_bool opt_enable_named_pipe= 0;

my_bool opt_local_infile, opt_slave_compressed_protocol;

my_bool opt_safe_user_create = 0;

my_bool opt_show_slave_auth_info, opt_sql_bin_update = 0;

my_bool opt_log_slave_updates= 0;

/*

  Legacy global handlerton. These will be removed (please do not add more).

*/

handlerton *heap_hton;

handlerton *myisam_hton;

my_bool opt_readonly, use_temp_pool, relay_log_purge;

my_bool opt_sync_frm, opt_allow_suspicious_udfs;

my_bool opt_secure_auth= 0;

char* opt_secure_file_priv= 0;

my_bool opt_log_slow_admin_statements= 0;

my_bool opt_log_slow_slave_statements= 0;

my_bool lower_case_file_system= 0;

my_bool opt_old_style_user_limits= 0, trust_function_creators= 0;

/*

  True if there is at least one per-hour limit for some user, so we should

  check them before each query (and possibly reset counters when hour is

  changed). False otherwise.

*/

volatile bool mqh_used = 0;

my_bool opt_noacl;

ulong opt_binlog_rows_event_max_size;

const char *binlog_format_names[]= {"MIXED", "STATEMENT", "ROW", NullS};

TYPELIB binlog_format_typelib=

  { array_elements(binlog_format_names) - 1, "",

    binlog_format_names, NULL };

ulong opt_binlog_format_id= (ulong) BINLOG_FORMAT_UNSPEC;

const char *opt_binlog_format= binlog_format_names[opt_binlog_format_id];

#ifdef HAVE_INITGROUPS

static bool calling_initgroups= FALSE; /**< Used in SIGSEGV handler. */

#endif

uint mysqld_port, test_flags, select_errors, dropping_tables, ha_open_options;

uint mysqld_port_timeout;

uint delay_key_write_options, protocol_version;

uint lower_case_table_names;

uint tc_heuristic_recover= 0;

uint volatile thread_count, thread_running;

ulonglong thd_startup_options;

ulong back_log, connect_timeout, server_id;

ulong table_cache_size, table_def_size;

ulong what_to_log;

ulong query_buff_size, slow_launch_time, slave_open_temp_tables;

ulong open_files_limit, max_binlog_size, max_relay_log_size;

ulong slave_net_timeout, slave_trans_retries;

my_bool slave_allow_batching;

ulong slave_exec_mode_options;

const char *slave_exec_mode_str= "STRICT";

ulong thread_cache_size=0, thread_pool_size= 0;

ulong binlog_cache_size=0, max_binlog_cache_size=0;

ulong refresh_version;  /* Increments on each reload */

query_id_t global_query_id;

ulong aborted_threads, aborted_connects;

ulong flush_time;

ulong specialflag=0;

ulong binlog_cache_use= 0, binlog_cache_disk_use= 0;

ulong max_connections, max_connect_errors;

uint  max_user_connections= 0;

ulong thread_id=1L,current_pid;

ulong slow_launch_threads = 0, sync_binlog_period;

ulong expire_logs_days = 0;

ulong rpl_recovery_rank=0;

const char *log_output_str= "FILE";

const double log_10[] = {

  1e000, 1e001, 1e002, 1e003, 1e004, 1e005, 1e006, 1e007, 1e008, 1e009,

  1e010, 1e011, 1e012, 1e013, 1e014, 1e015, 1e016, 1e017, 1e018, 1e019,

  1e020, 1e021, 1e022, 1e023, 1e024, 1e025, 1e026, 1e027, 1e028, 1e029,

  1e030, 1e031, 1e032, 1e033, 1e034, 1e035, 1e036, 1e037, 1e038, 1e039,

  1e040, 1e041, 1e042, 1e043, 1e044, 1e045, 1e046, 1e047, 1e048, 1e049,

  1e050, 1e051, 1e052, 1e053, 1e054, 1e055, 1e056, 1e057, 1e058, 1e059,

  1e060, 1e061, 1e062, 1e063, 1e064, 1e065, 1e066, 1e067, 1e068, 1e069,

  1e070, 1e071, 1e072, 1e073, 1e074, 1e075, 1e076, 1e077, 1e078, 1e079,

  1e080, 1e081, 1e082, 1e083, 1e084, 1e085, 1e086, 1e087, 1e088, 1e089,

  1e090, 1e091, 1e092, 1e093, 1e094, 1e095, 1e096, 1e097, 1e098, 1e099,

  1e100, 1e101, 1e102, 1e103, 1e104, 1e105, 1e106, 1e107, 1e108, 1e109,

  1e110, 1e111, 1e112, 1e113, 1e114, 1e115, 1e116, 1e117, 1e118, 1e119,

  1e120, 1e121, 1e122, 1e123, 1e124, 1e125, 1e126, 1e127, 1e128, 1e129,

  1e130, 1e131, 1e132, 1e133, 1e134, 1e135, 1e136, 1e137, 1e138, 1e139,

  1e140, 1e141, 1e142, 1e143, 1e144, 1e145, 1e146, 1e147, 1e148, 1e149,

  1e150, 1e151, 1e152, 1e153, 1e154, 1e155, 1e156, 1e157, 1e158, 1e159,

  1e160, 1e161, 1e162, 1e163, 1e164, 1e165, 1e166, 1e167, 1e168, 1e169,

  1e170, 1e171, 1e172, 1e173, 1e174, 1e175, 1e176, 1e177, 1e178, 1e179,

  1e180, 1e181, 1e182, 1e183, 1e184, 1e185, 1e186, 1e187, 1e188, 1e189,

  1e190, 1e191, 1e192, 1e193, 1e194, 1e195, 1e196, 1e197, 1e198, 1e199,

  1e200, 1e201, 1e202, 1e203, 1e204, 1e205, 1e206, 1e207, 1e208, 1e209,

  1e210, 1e211, 1e212, 1e213, 1e214, 1e215, 1e216, 1e217, 1e218, 1e219,

  1e220, 1e221, 1e222, 1e223, 1e224, 1e225, 1e226, 1e227, 1e228, 1e229,

  1e230, 1e231, 1e232, 1e233, 1e234, 1e235, 1e236, 1e237, 1e238, 1e239,

  1e240, 1e241, 1e242, 1e243, 1e244, 1e245, 1e246, 1e247, 1e248, 1e249,

  1e250, 1e251, 1e252, 1e253, 1e254, 1e255, 1e256, 1e257, 1e258, 1e259,

  1e260, 1e261, 1e262, 1e263, 1e264, 1e265, 1e266, 1e267, 1e268, 1e269,

  1e270, 1e271, 1e272, 1e273, 1e274, 1e275, 1e276, 1e277, 1e278, 1e279,

  1e280, 1e281, 1e282, 1e283, 1e284, 1e285, 1e286, 1e287, 1e288, 1e289,

  1e290, 1e291, 1e292, 1e293, 1e294, 1e295, 1e296, 1e297, 1e298, 1e299,

  1e300, 1e301, 1e302, 1e303, 1e304, 1e305, 1e306, 1e307, 1e308

};

time_t server_start_time, flush_status_time;

char mysql_home[FN_REFLEN], pidfile_name[FN_REFLEN], system_time_zone[30];

char *default_tz_name;

char log_error_file[FN_REFLEN], glob_hostname[FN_REFLEN];

char mysql_real_data_home[FN_REFLEN],

     language[FN_REFLEN], reg_ext[FN_EXTLEN], mysql_charsets_dir[FN_REFLEN],

     *opt_init_file, *opt_tc_log_file;

char mysql_unpacked_real_data_home[FN_REFLEN];

uint reg_ext_length;

const key_map key_map_empty(0);

key_map key_map_full(0);                        // Will be initialized later

const char *opt_date_time_formats[3];

uint mysql_data_home_len;

char mysql_data_home_buff[2], *mysql_data_home=mysql_real_data_home;

char server_version[SERVER_VERSION_LENGTH];

char *opt_mysql_tmpdir;

const char **errmesg;			/**< Error messages */

const char *myisam_recover_options_str="OFF";

const char *myisam_stats_method_str="nulls_unequal";

/** name of reference on left espression in rewritten IN subquery */

const char *in_left_expr_name= "<left expr>";

/** name of additional condition */

const char *in_additional_cond= "<IN COND>";

const char *in_having_cond= "<IN HAVING>";

my_decimal decimal_zero;

/* classes for comparation parsing/processing */

Eq_creator eq_creator;

Ne_creator ne_creator;

Gt_creator gt_creator;

Lt_creator lt_creator;

Ge_creator ge_creator;

Le_creator le_creator;

FILE *bootstrap_file;

int bootstrap_error;

FILE *stderror_file=0;

I_List<THD> threads;

I_List<NAMED_LIST> key_caches;

Rpl_filter* rpl_filter;

Rpl_filter* binlog_filter;

struct system_variables global_system_variables;

struct system_variables max_system_variables;

struct system_status_var global_status_var;

MY_TMPDIR mysql_tmpdir_list;

MY_BITMAP temp_pool;

CHARSET_INFO *system_charset_info, *files_charset_info ;

CHARSET_INFO *national_charset_info, *table_alias_charset;

CHARSET_INFO *character_set_filesystem;

MY_LOCALE *my_default_lc_time_names;

SHOW_COMP_OPTION have_symlink, have_dlopen;

SHOW_COMP_OPTION have_crypt, have_compress;

/* Thread specific variables */

pthread_key(MEM_ROOT**,THR_MALLOC);

pthread_key(THD*, THR_THD);

pthread_mutex_t LOCK_mysql_create_db, LOCK_open, LOCK_thread_count,

		LOCK_mapped_file, LOCK_status, LOCK_global_read_lock,

		LOCK_error_log, LOCK_uuid_generator,

		LOCK_crypt,

	        LOCK_global_system_variables,

		LOCK_user_conn, LOCK_slave_list, LOCK_active_mi,

                LOCK_connection_count;

rw_lock_t	LOCK_sys_init_connect, LOCK_sys_init_slave;

rw_lock_t	LOCK_system_variables_hash;

pthread_cond_t COND_refresh, COND_thread_count, COND_global_read_lock;

pthread_t signal_thread;

pthread_attr_t connection_attrib;

pthread_cond_t  COND_server_started;

/* replication parameters, if master_host is not NULL, we are a slave */

uint report_port= MYSQL_PORT;

ulong master_retry_count=0;

char *master_info_file;

char *relay_log_info_file, *report_user, *report_password, *report_host;

char *opt_relay_logname = 0, *opt_relaylog_index_name=0;

char *opt_logname, *opt_slow_logname;

/* Static variables */

static bool kill_in_progress, segfaulted;

#ifdef HAVE_STACK_TRACE_ON_SEGV

static my_bool opt_do_pstack;

#endif /* HAVE_STACK_TRACE_ON_SEGV */

static my_bool opt_bootstrap, opt_myisam_log;

static int cleanup_done;

static ulong opt_specialflag, opt_myisam_block_size;

static char *opt_update_logname, *opt_binlog_index_name;

static char *opt_tc_heuristic_recover;

static char *mysql_home_ptr, *pidfile_name_ptr;

static int defaults_argc;

static char **defaults_argv;

static char *opt_bin_logname;

static my_socket ip_sock;

struct rand_struct sql_rand; ///< used by sql_class.cc:THD::THD()

struct passwd *user_info;

static pthread_t select_thread;

static uint thr_kill_signal;

/* OS specific variables */

bool mysqld_embedded=0;

#ifndef DBUG_OFF

static const char* default_dbug_option;

#endif

scheduler_functions thread_scheduler;

/**

  Number of currently active user connections. The variable is protected by

  LOCK_connection_count.

*/

uint connection_count= 0;

/* Function declarations */

pthread_handler_t signal_hand(void *arg);

static void mysql_init_variables(void);

static void get_options(int *argc,char **argv);

extern "C" my_bool mysqld_get_one_option(int, const struct my_option *, char *);

static void set_server_version(void);

static int init_thread_environment();

static char *get_relative_path(const char *path);

static void fix_paths(void);

void handle_connections_sockets();

pthread_handler_t kill_server_thread(void *arg);

static void bootstrap(FILE *file);

static bool read_init_file(char *file_name);

pthread_handler_t handle_slave(void *arg);

static ulong find_bit_type(const char *x, TYPELIB *bit_lib);

static ulong find_bit_type_or_exit(const char *x, TYPELIB *bit_lib,

                                   const char *option);

static void clean_up(bool print_message);

static int test_if_case_insensitive(const char *dir_name);

static void usage(void);

static void start_signal_handler(void);

static void close_server_sock();

static void clean_up_mutexes(void);

static void wait_for_signal_thread_to_end(void);

static void create_pid_file();

static void mysqld_exit(int exit_code) __attribute__((noreturn));

/****************************************************************************

** Code to end mysqld

****************************************************************************/

static void close_connections(void)

{

#ifdef EXTRA_DEBUG

  int count=0;

#endif

  DBUG_ENTER("close_connections");

  /* Clear thread cache */

  kill_cached_threads++;

  flush_thread_cache();

  /* kill flush thread */

  (void) pthread_mutex_lock(&LOCK_manager);

  if (manager_thread_in_use)

  {

    DBUG_PRINT("quit", ("killing manager thread: 0x%lx",

                        (ulong)manager_thread));

   (void) pthread_cond_signal(&COND_manager);

  }

  (void) pthread_mutex_unlock(&LOCK_manager);

  /* kill connection thread */

  DBUG_PRINT("quit", ("waiting for select thread: 0x%lx",

                      (ulong) select_thread));

  (void) pthread_mutex_lock(&LOCK_thread_count);

  while (select_thread_in_use)

  {

    struct timespec abstime;

    int error;

    DBUG_PRINT("info",("Waiting for select thread"));

#ifndef DONT_USE_THR_ALARM

    if (pthread_kill(select_thread, thr_client_alarm))

      break;					// allready dead

#endif

    set_timespec(abstime, 2);

    for (uint tmp=0 ; tmp < 10 && select_thread_in_use; tmp++)

    {

      error=pthread_cond_timedwait(&COND_thread_count,&LOCK_thread_count,

				   &abstime);

      if (error != EINTR)

	break;

    }

#ifdef EXTRA_DEBUG

    if (error != 0 && !count++)

      sql_print_error("Got error %d from pthread_cond_timedwait",error);

#endif

    close_server_sock();

  }

  (void) pthread_mutex_unlock(&LOCK_thread_count);

  /* Abort listening to new connections */

  DBUG_PRINT("quit",("Closing sockets"));

  if (!opt_disable_networking )

  {

    if (ip_sock != INVALID_SOCKET)

    {

      (void) shutdown(ip_sock, SHUT_RDWR);

      (void) closesocket(ip_sock);

      ip_sock= INVALID_SOCKET;

    }

  }

  end_thr_alarm(0);			 // Abort old alarms.

  /*

    First signal all threads that it's time to die

    This will give the threads some time to gracefully abort their

    statements and inform their clients that the server is about to die.

  */

  THD *tmp;

  (void) pthread_mutex_lock(&LOCK_thread_count); // For unlink from list

  I_List_iterator<THD> it(threads);

  while ((tmp=it++))

  {

    DBUG_PRINT("quit",("Informing thread %ld that it's time to die",

		       tmp->thread_id));

    /* We skip slave threads & scheduler on this first loop through. */

    if (tmp->slave_thread)

      continue;

    tmp->killed= THD::KILL_CONNECTION;

    thread_scheduler.post_kill_notification(tmp);

    if (tmp->mysys_var)

    {

      tmp->mysys_var->abort=1;

      pthread_mutex_lock(&tmp->mysys_var->mutex);

      if (tmp->mysys_var->current_cond)

      {

	pthread_mutex_lock(tmp->mysys_var->current_mutex);

	pthread_cond_broadcast(tmp->mysys_var->current_cond);

	pthread_mutex_unlock(tmp->mysys_var->current_mutex);

      }

      pthread_mutex_unlock(&tmp->mysys_var->mutex);

    }

  }

  (void) pthread_mutex_unlock(&LOCK_thread_count); // For unlink from list

  end_slave();

  if (thread_count)

    sleep(2);					// Give threads time to die

  /*

    Force remaining threads to die by closing the connection to the client

    This will ensure that threads that are waiting for a command from the

    client on a blocking read call are aborted.

  */

  for (;;)

  {

    DBUG_PRINT("quit",("Locking LOCK_thread_count"));

    (void) pthread_mutex_lock(&LOCK_thread_count); // For unlink from list

    if (!(tmp=threads.get()))

    {

      DBUG_PRINT("quit",("Unlocking LOCK_thread_count"));

      (void) pthread_mutex_unlock(&LOCK_thread_count);

      break;

    }

    if (tmp->vio_ok())

    {

      if (global_system_variables.log_warnings)

        sql_print_warning(ER(ER_FORCING_CLOSE),my_progname,

                          tmp->thread_id,

                          (tmp->main_security_ctx.user ?

                           tmp->main_security_ctx.user : ""));

      close_connection(tmp,0,0);

    }

    DBUG_PRINT("quit",("Unlocking LOCK_thread_count"));

    (void) pthread_mutex_unlock(&LOCK_thread_count);

  }

  /* All threads has now been aborted */

  DBUG_PRINT("quit",("Waiting for threads to die (count=%u)",thread_count));

  (void) pthread_mutex_lock(&LOCK_thread_count);

  while (thread_count)

  {

    (void) pthread_cond_wait(&COND_thread_count,&LOCK_thread_count);

    DBUG_PRINT("quit",("One thread died (count=%u)",thread_count));

  }

  (void) pthread_mutex_unlock(&LOCK_thread_count);

  DBUG_PRINT("quit",("close_connections thread"));

  DBUG_VOID_RETURN;

}

static void close_server_sock()

{

#ifdef HAVE_CLOSE_SERVER_SOCK

  DBUG_ENTER("close_server_sock");

  my_socket tmp_sock;

  tmp_sock=ip_sock;

  if (tmp_sock != INVALID_SOCKET)

  {

    ip_sock=INVALID_SOCKET;

    DBUG_PRINT("info",("calling shutdown on TCP/IP socket"));

    VOID(shutdown(tmp_sock, SHUT_RDWR));

  }

  DBUG_VOID_RETURN;

#endif

}

void kill_mysql(void)

{

  DBUG_ENTER("kill_mysql");

#if defined(SIGNALS_DONT_BREAK_READ)

  abort_loop=1;					// Break connection loops

  close_server_sock();				// Force accept to wake up

#endif

#if defined(HAVE_PTHREAD_KILL)

  if (pthread_kill(signal_thread, MYSQL_KILL_SIGNAL))

  {

    DBUG_PRINT("error",("Got error %d from pthread_kill",errno)); /* purecov: inspected */

  }

#elif !defined(SIGNALS_DONT_BREAK_READ)

  kill(current_pid, MYSQL_KILL_SIGNAL);

#endif

  DBUG_PRINT("quit",("After pthread_kill"));

  shutdown_in_progress=1;			// Safety if kill didn't work

#ifdef SIGNALS_DONT_BREAK_READ

  if (!kill_in_progress)

  {

    pthread_t tmp;

    abort_loop=1;

    if (pthread_create(&tmp,&connection_attrib, kill_server_thread,

			   (void*) 0))

      sql_print_error("Can't create thread to kill server");

  }

#endif

  DBUG_VOID_RETURN;

}

/**

  Force server down. Kill all connections and threads and exit.

  @param  sig_ptr       Signal number that caused kill_server to be called.

  @note

    A signal number of 0 mean that the function was not called

    from a signal handler and there is thus no signal to block

    or stop, we just want to kill the server.

*/

static void *kill_server(void *sig_ptr)

#define RETURN_FROM_KILL_SERVER DBUG_RETURN(0)

{

  DBUG_ENTER("kill_server");

  int sig=(int) (long) sig_ptr;			// This is passed a int

  // if there is a signal during the kill in progress, ignore the other

  if (kill_in_progress)				// Safety

    RETURN_FROM_KILL_SERVER;

  kill_in_progress=TRUE;

  abort_loop=1;					// This should be set

  if (sig != 0) // 0 is not a valid signal number

    my_sigset(sig, SIG_IGN);                    /* purify inspected */

  if (sig == MYSQL_KILL_SIGNAL || sig == 0)

    sql_print_information(ER(ER_NORMAL_SHUTDOWN),my_progname);

  else

    sql_print_error(ER(ER_GOT_SIGNAL),my_progname,sig); /* purecov: inspected */

  close_connections();

  if (sig != MYSQL_KILL_SIGNAL &&

      sig != 0)

    unireg_abort(1);				/* purecov: inspected */

  else

    unireg_end();

  /* purecov: begin deadcode */

  my_thread_end();

  pthread_exit(0);

  /* purecov: end */

  RETURN_FROM_KILL_SERVER;

}

#if defined(USE_ONE_SIGNAL_HAND)

pthread_handler_t kill_server_thread(void *arg __attribute__((unused)))

{

  my_thread_init();				// Initialize new thread

  kill_server(0);

  /* purecov: begin deadcode */

  my_thread_end();

  pthread_exit(0);

  return 0;

  /* purecov: end */