~drizzle-trunk/drizzle/development

/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-

 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:

 *

 *  Copyright (C) 2008 Sun Microsystems

 *

 *  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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

 */

#include <drizzled/configmake.h>

#include <drizzled/server_includes.h>

#include <netdb.h>

#include <sys/poll.h>

#include <netinet/tcp.h>

#include <signal.h>

#include <mysys/my_bit.h>

#include <libdrizzleclient/libdrizzle.h>

#include <mysys/hash.h>

#include <drizzled/stacktrace.h>

#include <mysys/mysys_err.h>

#include <drizzled/error.h>

#include <drizzled/errmsg_print.h>

#include <drizzled/tztime.h>

#include <drizzled/sql_base.h>

#include <drizzled/show.h>

#include <drizzled/sql_parse.h>

#include <drizzled/item/cmpfunc.h>

#include <drizzled/session.h>

#include <drizzled/db.h>

#include <drizzled/item/create.h>

#include <drizzled/errmsg.h>

#include <drizzled/unireg.h>

#include <drizzled/plugin_scheduling.h>

#include "drizzled/temporal_format.h" /* For init_temporal_formats() */

#if TIME_WITH_SYS_TIME

# include <sys/time.h>

# include <time.h>

#else

# if HAVE_SYS_TIME_H

#  include <sys/time.h>

# else

#  include <time.h>

# endif

#endif

#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 <libdrizzleclient/errmsg.h>

#include <locale.h>

#define mysqld_charset &my_charset_utf8_general_ci

#ifdef HAVE_purify

#define IF_PURIFY(A,B) (A)

#else

#define IF_PURIFY(A,B) (B)

#endif

#define MAX_MEM_TABLE_SIZE SIZE_MAX

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

#include <errno.h>

#include <sys/stat.h>

#include <mysys/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 <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 */

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

#include <drizzled/gettext.h>

#ifdef SOLARIS

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

#endif

extern "C" void handle_segfault(int sig);

using namespace std;

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

  NULL

};

/* 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", NULL

};

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";

const char * const DRIZZLE_CONFIG_NAME= "drizzled";

#define GET_HA_ROWS GET_ULL

/*

  Used with --help for detailed option

*/

static bool opt_help= false;

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}};

/* static variables */

/* the default log output is log tables */

static bool volatile select_thread_in_use;

static bool volatile ready_to_exit;

static bool opt_debugging= 0;

static uint32_t wake_thread;

static uint32_t killed_threads, thread_created;

static char *drizzled_user, *drizzled_chroot;

static char *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[]= DRIZZLE_DEFAULT_COLLATION_NAME;

static struct pollfd fds[UINT8_MAX];

static uint8_t pollfd_count= 0;

/* Global variables */

bool opt_bin_log;

bool opt_log_queries_not_using_indexes= false;

bool opt_skip_show_db= false;

bool server_id_supplied = 0;

bool opt_endinfo, using_udf_functions;

bool locked_in_memory;

bool opt_using_transactions;

bool volatile abort_loop;

bool volatile shutdown_in_progress;

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

bool opt_reckless_slave = 0;

bool opt_enable_named_pipe= 0;

bool opt_local_infile;

bool opt_safe_user_create = 0;

bool opt_show_slave_auth_info, opt_sql_bin_update = 0;

bool opt_log_slave_updates= 0;

uint32_t max_used_connections;

const char *opt_scheduler= "pool_of_threads";

size_t my_thread_stack_size= 65536;

/*

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

*/

handlerton *heap_hton;

handlerton *myisam_hton;

bool use_temp_pool;

char* opt_secure_file_priv= 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.

*/

bool opt_noacl;

#ifdef HAVE_INITGROUPS

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

#endif

uint32_t drizzled_port, test_flags, select_errors, dropping_tables, ha_open_options;

uint32_t drizzled_port_timeout;

uint32_t delay_key_write_options, protocol_version= PROTOCOL_VERSION;

uint32_t lower_case_table_names= 1;

uint32_t tc_heuristic_recover= 0;

uint32_t volatile thread_count, thread_running;

uint64_t session_startup_options;

uint32_t back_log;

uint32_t connect_timeout;

uint32_t server_id;

uint64_t table_cache_size;

uint64_t table_def_size;

uint64_t slow_launch_time;

uint64_t slave_open_temp_tables;

uint32_t refresh_version;  /* Increments on each reload */

uint64_t aborted_threads;

uint64_t aborted_connects;

uint64_t max_connect_errors;

ulong thread_id=1L;

pid_t current_pid;

uint64_t slow_launch_threads= 0;

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;

time_t flush_status_time;

/* FRM Junk */

const char *reg_ext= ".frm";

uint32_t reg_ext_length= 4;

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

char *default_tz_name;

char glob_hostname[FN_REFLEN];

char drizzle_real_data_home[FN_REFLEN],

     language[FN_REFLEN], 

     *opt_init_file, 

     *opt_tc_log_file;

char drizzle_unpacked_real_data_home[FN_REFLEN];

const key_map key_map_empty(0);

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

uint32_t drizzle_data_home_len;

char drizzle_data_home_buff[2], *drizzle_data_home=drizzle_real_data_home;

char server_version[SERVER_VERSION_LENGTH];

char *drizzle_tmpdir= NULL;

char *opt_drizzle_tmpdir= NULL;

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

FILE *stderror_file=0;

I_List<Session> threads;

I_List<NAMED_LIST> key_caches;

struct system_variables global_system_variables;

struct system_variables max_system_variables;

struct system_status_var global_status_var;

MY_BITMAP temp_pool;

const CHARSET_INFO *system_charset_info, *files_charset_info ;

const CHARSET_INFO *national_charset_info, *table_alias_charset;

const CHARSET_INFO *character_set_filesystem;

MY_LOCALE *my_default_lc_time_names;

SHOW_COMP_OPTION have_symlink;

/* Thread specific variables */

pthread_key_t THR_Mem_root;

pthread_key_t THR_Session;

pthread_mutex_t LOCK_drizzleclient_create_db, 

                LOCK_open, 

                LOCK_thread_count,

                LOCK_status,

                LOCK_global_read_lock,

                LOCK_global_system_variables;

pthread_rwlock_t	LOCK_sys_init_connect;

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

uint32_t report_port= DRIZZLE_PORT;

uint32_t master_retry_count= 0;

char *master_info_file;

char *report_host;

char *opt_logname;

/* Static variables */

static bool segfaulted;

#ifdef HAVE_STACK_TRACE_ON_SEGV

static bool opt_do_pstack;

#endif /* HAVE_STACK_TRACE_ON_SEGV */

int cleanup_done;

static char *drizzle_home_ptr, *pidfile_name_ptr;

static int defaults_argc;

static char **defaults_argv;

static char *opt_bin_logname;

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

struct passwd *user_info;

static pthread_t select_thread;

static uint32_t thr_kill_signal;

extern scheduling_st thread_scheduler;

/**

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

  LOCK_thread_count.

*/

uint32_t connection_count= 0;

/* Function declarations */

extern "C" pthread_handler_t signal_hand(void *arg);

static void drizzle_init_variables(void);

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

extern "C" bool drizzled_get_one_option(int, const struct my_option *, char *);

static void set_server_version(void);

static int init_thread_environment();

static const char *get_relative_path(const char *path);

static void fix_paths(void);

void handle_connections_sockets();

extern "C" pthread_handler_t handle_slave(void *arg);

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

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

                                   const char *option);

static void clean_up(bool print_message);

static void usage(void);

static void clean_up_mutexes(void);

extern "C" bool safe_read_error_impl(NET *net);

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

** Code to end drizzled

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

void close_connections(void)

{

  int x;

  /* Abort listening to new connections */

  for (x= 0; x < pollfd_count; x++)

  {

    if (fds[x].fd != -1)

    {

      (void) shutdown(fds[x].fd, SHUT_RDWR);

      (void) close(fds[x].fd);

      fds[x].fd= -1;

    }

  }

  /* kill connection thread */

  (void) pthread_mutex_lock(&LOCK_thread_count);

  while (select_thread_in_use)

  {

    struct timespec abstime;

    int error;

    set_timespec(abstime, 2);

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

    {

      error=pthread_cond_timedwait(&COND_thread_count,&LOCK_thread_count, &abstime);

      if (error != EINTR)

        break;

    }

  }

  (void) pthread_mutex_unlock(&LOCK_thread_count);

  /*

    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.

  */

  Session *tmp;

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

  I_List_iterator<Session> it(threads);

  while ((tmp=it++))

  {

    tmp->killed= Session::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

  /* TODO This is a crappy way to handle this. Fix for proper shutdown. */

  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 (;;)

  {

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

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

    {

      (void) pthread_mutex_unlock(&LOCK_thread_count);

      break;

    }

    if (tmp->drizzleclient_vio_ok())

    {

      if (global_system_variables.log_warnings)

            errmsg_printf(ERRMSG_LVL_WARN, ER(ER_FORCING_CLOSE),my_progname,

                          tmp->thread_id,

                          (tmp->security_ctx.user.c_str() ?

                           tmp->security_ctx.user.c_str() : ""));

      tmp->close_connection(0,0);

    }

    (void) pthread_mutex_unlock(&LOCK_thread_count);

  }

  /* All threads has now been aborted */

  (void) pthread_mutex_lock(&LOCK_thread_count);

  while (thread_count)

  {

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

  }

  (void) pthread_mutex_unlock(&LOCK_thread_count);

}

extern "C" void print_signal_warning(int sig)

{

  if (global_system_variables.log_warnings)

    errmsg_printf(ERRMSG_LVL_WARN, _("Got signal %d from thread %"PRIu64), sig,my_thread_id());

#ifndef HAVE_BSD_SIGNALS

  my_sigset(sig,print_signal_warning);		/* int. thread system calls */

#endif

  if (sig == SIGALRM)

    alarm(2);					/* reschedule alarm */

}

/**

  cleanup all memory and end program nicely.

    If SIGNALS_DONT_BREAK_READ is defined, this function is called

    by the main thread. To get Drizzle to shut down nicely in this case

    (Mac OS X) we have to call exit() instead if pthread_exit().

  @note

    This function never returns.

*/

extern "C" void unireg_end(void)

{

  clean_up(1);

  my_thread_end();

#if defined(SIGNALS_DONT_BREAK_READ)

  exit(0);

#else

  pthread_exit(0);				// Exit is in main thread

#endif

}

extern "C" void unireg_abort(int exit_code)

{

  if (exit_code)

    errmsg_printf(ERRMSG_LVL_ERROR, _("Aborting\n"));

  else if (opt_help)

    usage();

  clean_up(!opt_help && (exit_code)); /* purecov: inspected */

  clean_up_mutexes();

  my_end(opt_endinfo ? MY_CHECK_ERROR | MY_GIVE_INFO : 0);

  exit(exit_code); /* purecov: inspected */

}

static void clean_up(bool print_message)

{

  if (cleanup_done++)

    return; /* purecov: inspected */

  table_cache_free();

  table_def_free();

  set_var_free();

  free_charsets();

  udf_free();

  plugin_shutdown();

  ha_end();

  xid_cache_free();

  delete_elements(&key_caches, (void (*)(const char*, unsigned char*)) free_key_cache);

  multi_keycache_free();

  free_status_vars();

  my_free_open_file_info();

  if (defaults_argv)

    free_defaults(defaults_argv);

  free(sys_init_connect.value);

  free(drizzle_tmpdir);

  if (opt_bin_logname)

    free(opt_bin_logname);

  if (opt_secure_file_priv)

    free(opt_secure_file_priv);

  bitmap_free(&temp_pool);

  (void) unlink(pidfile_name);	// This may not always exist

  if (print_message && server_start_time)

    errmsg_printf(ERRMSG_LVL_INFO, _(ER(ER_SHUTDOWN_COMPLETE)),my_progname);

  /* Returns NULL on globerrs, we don't want to try to free that */

  //void *freeme=

  (void *)my_error_unregister(ER_ERROR_FIRST, ER_ERROR_LAST);

  // TODO!!!! EPIC FAIL!!!! This sefaults if uncommented.

/*  if (freeme != NULL)

    free(freeme);  */

  (void) pthread_mutex_lock(&LOCK_thread_count);

  ready_to_exit=1;

  /* do the broadcast inside the lock to ensure that my_end() is not called */

  (void) pthread_cond_broadcast(&COND_thread_count);

  (void) pthread_mutex_unlock(&LOCK_thread_count);

  /*

    The following lines may never be executed as the main thread may have

    killed us

  */

} /* clean_up */

static void clean_up_mutexes()

{

  (void) pthread_mutex_destroy(&LOCK_drizzleclient_create_db);

  (void) pthread_mutex_destroy(&LOCK_lock_db);

  (void) pthread_mutex_destroy(&LOCK_open);

  (void) pthread_mutex_destroy(&LOCK_thread_count);

  (void) pthread_mutex_destroy(&LOCK_status);

  (void) pthread_rwlock_destroy(&LOCK_sys_init_connect);