~drizzle-trunk/drizzle/development

#include "rpl_mi.h"

#include "sql_repl.h"

#include "rpl_filter.h"

#include "stacktrace.h"

#include <mysys/mysys_err.h>

#include <sys/poll.h>

#include <netinet/tcp.h>

#include <drizzled/drizzled_error_messages.h>

 

#include <storage/myisam/ha_myisam.h>

 

#ifdef HAVE_SYS_PRCTL_H

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

#endif

 

 

/* Constants */

 

static const char *optimizer_switch_names[]=

{

  "no_materialization", "no_semijoin",

};

 

/* Corresponding defines are named OPTIMIZER_SWITCH_XXX */

 

static const char *tc_heuristic_recover_names[]=

{

};

static TYPELIB tc_heuristic_recover_typelib=

{

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

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

 

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

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

                             log_output_names,

static bool volatile select_thread_in_use, signal_thread_in_use;

static bool volatile ready_to_exit;

static bool opt_debugging= 0, opt_console= 0;

static uint32_t killed_threads, thread_created;

static uint32_t max_used_connections;

static volatile uint32_t cached_thread_count= 0;

/* Global variables */

 

bool opt_bin_log;

ulong log_output_options;

bool opt_log_queries_not_using_indexes= false;

bool opt_error_log= 0;

bool opt_noacl;

 

ulong opt_binlog_rows_event_max_size;

TYPELIB binlog_format_typelib=

  { array_elements(binlog_format_names) - 1, "",

    binlog_format_names, NULL };

#ifdef HAVE_INITGROUPS

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

#endif

uint64_t thd_startup_options;

ulong back_log, connect_timeout, server_id;

ulong table_cache_size, table_def_size;

ulong binlog_cache_disk_use= 0;

ulong max_connections;

ulong max_connect_errors;

ulong thread_id=1L;

ulong current_pid;

ulong slow_launch_threads = 0;

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

const key_map key_map_empty(0);

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

 

const char *opt_date_time_formats[3];

 

char mysql_data_home_buff[2], *mysql_data_home=mysql_real_data_home;

char server_version[SERVER_VERSION_LENGTH];

char *opt_mysql_tmpdir;

pthread_cond_t  COND_server_started;

 

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

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

 

/* Static variables */

 

 

struct passwd *user_info;

static pthread_t select_thread;

 

/* OS specific variables */

 

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

  LOCK_connection_count.

*/

 

/* Function declarations */

 

      break;                                    // allready dead

#endif

    set_timespec(abstime, 2);

    {

      error=pthread_cond_timedwait(&COND_thread_count,&LOCK_thread_count,

                                   &abstime);

#endif

 

 

{

  if (global_system_variables.log_warnings)

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

#endif

  if (sig == SIGALRM)

  if (cleanup_done++)

    return; /* purecov: inspected */

 

  logger.cleanup_base();

 

  mysql_bin_log.cleanup();

  if (tc_log)

    tc_log->close();

  xid_cache_free();

  multi_keycache_free();

  free_status_vars();

  end_thr_alarm(1);                     /* Free allocated memory */

  my_free_open_file_info();

  if (defaults_argv)

    free_defaults(defaults_argv);

  free_tmpdir(&mysql_tmpdir_list);

  bitmap_free(&temp_pool);

  delete binlog_filter;

  delete rpl_filter;

 

  (void) my_delete(pidfile_name,MYF(0));        // This may not always exist

 

  (void *)my_error_unregister(ER_ERROR_FIRST, ER_ERROR_LAST);

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

/*  if (freeme != NULL)

  /* Tell main we are ready */

  logger.cleanup_end();

  (void) pthread_mutex_lock(&LOCK_thread_count);

*/

static void wait_for_signal_thread_to_end()

{

  /*

    Wait up to 10 seconds for signal thread to die. We use this mainly to

    avoid getting warnings that my_thread_end has not been called

  (void) pthread_mutex_destroy(&LOCK_error_log);

  (void) pthread_mutex_destroy(&LOCK_user_conn);

  (void) pthread_mutex_destroy(&LOCK_connection_count);

  (void) pthread_mutex_destroy(&LOCK_active_mi);

  (void) rwlock_destroy(&LOCK_sys_init_connect);

  (void) rwlock_destroy(&LOCK_sys_init_slave);

static void network_init(void)

{

  int   ret;

  char port_buf[NI_MAXSERV];

  struct addrinfo *ai;

  struct addrinfo *next;

    for (waited= 0, retry= 1; ; retry++, waited+= this_wait)

    {

      if (((ret= bind(ip_sock, next->ai_addr, next->ai_addrlen)) >= 0 ) ||

          (waited >= mysqld_port_timeout))

        break;

      sql_print_information(_("Retrying bind on TCP/IP port %u"), mysqld_port);

    {

      sql_perror(_("Can't start server: listen() on TCP/IP port"));

      sql_print_error(_("listen() on TCP/IP failed with error %d"),

      unireg_abort(1);

    }

  }

  @note

    For the connection that is doing shutdown, this is called twice

*/

{

  st_vio *vio;

  if (lock)

  {

    if (errcode)

      net_send_error(thd, errcode, ER(errcode)); /* purecov: inspected */

  }

  if (lock)

    (void) pthread_mutex_unlock(&LOCK_thread_count);

 

/** Called when a thread is aborted. */

/* ARGSUSED */

{

  THD *thd=current_thd;

  if (thd && ! thd->bootstrap)

  @todo

    One should have to fix that thr_alarm know about this thread too.

*/

{

  THD *thd=current_thd;

  if (thd)

#endif

 

 

{

  time_t curr_time;

  struct tm tm;

                     "where mysqld died. If you see no messages after this, "

                     "something went\n"

                     "terribly wrong...\n"));

                     my_thread_stack_size);

  }

  if (thd)

      sql_print_information(_("Got signal %d to shutdown mysqld"),sig);

#endif

      /* switch to the old log message processing */

      if (!abort_loop)

      {

        abort_loop=1;                           // mark abort for threads

                      REFRESH_THREADS | REFRESH_HOSTS),

                     (TableList*) 0, &not_used); // Flush logs

      }

      break;

#ifdef USE_ONE_SIGNAL_HAND

    case THR_SERVER_ALARM:

  for the client.

*/

/* ARGSUSED */

 

{

  THD *thd;

  /*

    if (MyFlags & ME_FATALERROR)

      thd->is_fatal_error= 1;

 

    /*

      TODO: There are two exceptions mechanism (THD and sp_rcontext),

      this could be improved by having a common stack of handlers.

 

void my_str_free_mysqld(void *ptr)

{

}

 

 

    1 error

*/

 

                                        DATE_TIME_FORMAT **var_ptr)

{

  /* Get command line option */

  {"show_open_tables",     (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_OPEN_TABLES]), SHOW_LONG_STATUS},

  {"show_plugins",         (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_PLUGINS]), SHOW_LONG_STATUS},

  {"show_processlist",     (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_PROCESSLIST]), SHOW_LONG_STATUS},

  {"show_slave_status",    (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_SLAVE_STAT]), SHOW_LONG_STATUS},

  {"show_status",          (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_STATUS]), SHOW_LONG_STATUS},

  {"show_table_status",    (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_TABLE_STATUS]), SHOW_LONG_STATUS},

  {"unlock_tables",        (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_UNLOCK_TABLES]), SHOW_LONG_STATUS},

  {"update",               (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_UPDATE]), SHOW_LONG_STATUS},

  {"update_multi",         (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_UPDATE_MULTI]), SHOW_LONG_STATUS},

};

 

static int init_common_variables(const char *conf_file_name, int argc,

                                 char **argv, const char **groups)

{

  umask(((~my_umask) & 0666));

  my_decimal_set_zero(&decimal_zero); // set decimal_zero constant;

  tzset();                      // Set tzname

  }

  else

  strmake(pidfile_name, glob_hostname, sizeof(pidfile_name)-5);

 

  /*

    Add server status variables to the dynamic list of

 

  /* connections and databases needs lots of files */

  {

 

    /* MyISAM requires two file handles per table. */

    wanted_files= 10+max_connections+table_cache_size*2;

      can't get max_connections*5 but still got no less than was

      requested (value of wanted_files).

    */

    files= my_set_max_open_files(max_open_files);

 

    if (files < wanted_files)

          If we have requested too much file handles than we bring

          max_connections in supported bounds.

        */

                                     max_connections);

        /*

          Decrease table_cache_size according to max_connections, but

          never increase table_cache_size automatically (that could

          happen if max_connections is decreased above).

        */

                                          (uint32_t)TABLE_OPEN_CACHE_MIN),

                                      table_cache_size);

        if (global_system_variables.log_warnings)

  else

    sys_init_slave.value=my_strdup("",MYF(0));

 

  if (use_temp_pool && bitmap_init(&temp_pool,0,1024,1))

    return 1;

  if (my_database_names_init())

  (void) pthread_cond_init(&COND_global_read_lock,NULL);

  (void) pthread_cond_init(&COND_thread_cache,NULL);

  (void) pthread_cond_init(&COND_flush_thread_cache,NULL);

 

  /* Parameter for threads created for connections */

  (void) pthread_attr_init(&connection_attrib);

  randominit(&sql_rand,(uint32_t) server_start_time,(uint32_t) server_start_time/2);

  setup_fpu();

  init_thr_lock();

 

  /* Setup logs */

 

    }

    if (ln == buf)

    {

      opt_bin_logname=my_strdup(buf, MYF(0));

    }

    if (mysql_bin_log.open_index_file(opt_binlog_index_name, ln))

    unireg_abort(1);

  }

 

  /*

    Check that the default storage engine is actually available.

  */

 

int main(int argc, char **argv)

{

#if defined(ENABLE_NLS)

# if defined(HAVE_LOCALE_H)

  setlocale(LC_ALL, "");

      if (global_system_variables.log_warnings)

      {

        /* %zu is not yet in C++ */

                          my_thread_stack_size, size_tmp);

      }

      my_thread_stack_size= stack_size;

{

  int x;

  int sock,new_sock;

  THD *thd;

  struct sockaddr_storage cAddr;

 

  MAYBE_BROKEN_SYSCALL;

  while (!abort_loop)

 

    if ((number_of= poll(fds, pollfd_count, -1)) == -1)

    {

      {

        if (!select_errors++ && !abort_loop)    /* purecov: inspected */

          sql_print_error(_("drizzled: Got error %d from select"),

      }

      MAYBE_BROKEN_SYSCALL

      continue;

    }

    assert(sock != -1);

 

    {

      new_sock= accept(sock, (struct sockaddr *)(&cAddr),

                       &length);

        break;

    }

 

      if ((error_count++ & 255) == 0)           // This can happen often

        sql_perror("Error in accept");

      MAYBE_BROKEN_SYSCALL;

        sleep(1);                               // Give other threads some time

      continue;

    }

 

    {

      struct sockaddr_storage dummy;

      dummyLen = sizeof(dummy);

      if (  getsockname(new_sock,(struct sockaddr *)&dummy,

    if (!(thd= new THD))

    {

      (void) shutdown(new_sock, SHUT_RDWR);

      continue;

    }

    {

      delete thd;

      continue;

    }

  OPT_SHORT_LOG_FORMAT,

  OPT_FLUSH,                   OPT_SAFE,

  OPT_STORAGE_ENGINE,          OPT_INIT_FILE,

  OPT_DELAY_KEY_WRITE,         OPT_CHARSETS_DIR,

  OPT_MASTER_INFO_FILE,

  OPT_MASTER_RETRY_COUNT,      OPT_LOG_TC, OPT_LOG_TC_SIZE,

  OPT_REPLICATE_WILD_IGNORE_TABLE, OPT_REPLICATE_SAME_SERVER_ID,

  OPT_DISCONNECT_SLAVE_EVENT_COUNT, OPT_TC_HEURISTIC_RECOVER,

  OPT_ABORT_SLAVE_EVENT_COUNT,

  OPT_ENGINE_CONDITION_PUSHDOWN,

  OPT_TEMP_POOL, OPT_TX_ISOLATION, OPT_COMPLETION_TYPE,

  OPT_SKIP_STACK_TRACE, OPT_SKIP_SYMLINKS,

  OPT_DATE_FORMAT,

  OPT_TIME_FORMAT,

  OPT_DATETIME_FORMAT,

  OPT_DEFAULT_TIME_ZONE,

  OPT_SYSDATE_IS_NOW,

  OPT_OPTIMIZER_SEARCH_DEPTH,

  OPT_ENABLE_LARGE_PAGES,

  OPT_TIMED_MUTEXES,

  OPT_OLD_STYLE_USER_LIMITS,

  OPT_TABLE_LOCK_WAIT_TIMEOUT,

  OPT_PLUGIN_LOAD,

  OPT_PLUGIN_DIR,

  OPT_PORT_OPEN_TIMEOUT,

  OPT_PROFILING,

  OPT_KEEP_FILES_ON_CREATE,

  OPT_GENERAL_LOG,

  OPT_THREAD_HANDLING,

  OPT_INNODB_ROLLBACK_ON_TIMEOUT,

  OPT_SECURE_FILE_PRIV,

  OPT_MIN_EXAMINED_ROW_LIMIT,

  OPT_OLD_MODE,

  OPT_POOL_OF_THREADS,

  OPT_SLAVE_EXEC_MODE

   N_("Path to the database root."),

   (char**) &mysql_data_home,

   (char**) &mysql_data_home, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

  {"default-storage-engine", OPT_STORAGE_ENGINE,

   N_("Set the default storage engine (table type) for tables."),

   (char**)&default_storage_engine_str, (char**)&default_storage_engine_str,

  {"delay-key-write", OPT_DELAY_KEY_WRITE,

   N_("Type of DELAY_KEY_WRITE."),

   0,0,0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},

  {"disconnect-slave-event-count", OPT_DISCONNECT_SLAVE_EVENT_COUNT,

   N_("Option used by mysql-test for debugging and testing of replication."),

   (char**) &disconnect_slave_event_count,

   N_("Set up signals usable for debugging"),

   (char**) &opt_debugging, (char**) &opt_debugging,

   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},

  {"init-connect", OPT_INIT_CONNECT,

   N_("Command(s) that are executed for each new connection"),

   (char**) &opt_init_connect, (char**) &opt_init_connect, 0, GET_STR_ALLOC,

   N_("File that holds the names for last binary log files."),

   (char**) &opt_binlog_index_name, (char**) &opt_binlog_index_name, 0, GET_STR,

   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

  {"log-error", OPT_ERROR_LOG_FILE,

   N_("Error log file."),

   (char**) &log_error_file_ptr, (char**) &log_error_file_ptr, 0, GET_STR,

   N_("Log all MyISAM changes to file."),

   (char**) &myisam_log_filename, (char**) &myisam_log_filename, 0, GET_STR,

   OPT_ARG, 0, 0, 0, 0, 0, 0},

  {"log-slave-updates", OPT_LOG_SLAVE_UPDATES,

   N_("Tells the slave to log the updates from the slave thread to the binary "

      "log. You will need to turn it on if you plan to "

   (char**) &opt_log_slave_updates, (char**) &opt_log_slave_updates,

   0, GET_BOOL,

   NO_ARG, 0, 0, 0, 0, 0, 0},

  {"log-tc", OPT_LOG_TC,

   N_("Path to transaction coordinator log (used for transactions that affect "

      "more than one storage engine, when binary log is disabled)"),

      "replication partners."),

   (char**) &server_id, (char**) &server_id, 0, GET_ULONG, REQUIRED_ARG, 0, 0, 0,

   0, 0, 0},

  {"skip-new", OPT_SKIP_NEW,

   N_("Don't use new, possible wrong routines."),

   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},

   N_("Don't print a stack trace on failure."),

   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0,

   0, 0, 0, 0},

  {"skip-thread-priority", OPT_SKIP_PRIOR,

   N_("Don't give threads different priorities."),

   0, 0, 0, GET_NO_ARG, NO_ARG,

      "and the slave."),

   (char**) &slave_exec_mode_str, (char**) &slave_exec_mode_str,

   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

  {"sql-bin-update-same", OPT_SQL_BIN_UPDATE_SAME,

   N_("(INGORED)"),

   0, 0, 0, GET_DISABLED, NO_ARG, 0, 0, 0, 0, 0, 0},

   N_("Default transaction isolation level."),

   0, 0, 0, GET_STR, REQUIRED_ARG, 0,

   0, 0, 0, 0, 0},

  {"user", 'u',

   N_("Run mysqld daemon as user."),

   0, 0, 0, GET_STR, REQUIRED_ARG,

   N_("Output version information and exit."),

   0, 0, 0, GET_NO_ARG,

   NO_ARG, 0, 0, 0, 0, 0, 0},

  {"back_log", OPT_BACK_LOG,

   N_("The number of outstanding connection requests MySQL can have. This "

      "comes into play when the main MySQL thread gets very many connection "

   (char**) &myisam_data_pointer_size,

   (char**) &myisam_data_pointer_size, 0, GET_ULONG, REQUIRED_ARG,

   6, 2, 7, 0, 1, 0},

  {"myisam_max_sort_file_size", OPT_MYISAM_MAX_SORT_FILE_SIZE,

   N_("Don't use the fast sort index method to created index if the "

      "temporary file would get bigger than this."),

      "Use 0 (default) to disable synchronous flushing."),

   (char**) &sync_binlog_period, (char**) &sync_binlog_period, 0, GET_ULONG,

   REQUIRED_ARG, 0, 0, ULONG_MAX, 0, 1, 0},

  {"table_definition_cache", OPT_TABLE_DEF_CACHE,

   N_("The number of cached table definitions."),

   (char**) &table_def_size, (char**) &table_def_size,

  {"Threads_running",          (char*) &thread_running,         SHOW_INT},

  {"Uptime",                   (char*) &show_starttime_cont,         SHOW_FUNC},

  {"Uptime_since_flush_status",(char*) &show_flushstatustime_cont,   SHOW_FUNC},

};

 

static void print_version(void)

  /* Things reset to zero */

  opt_skip_slave_start= opt_reckless_slave = 0;

  mysql_home[0]= pidfile_name[0]= log_error_file[0]= 0;

  log_output_options= find_bit_type(log_output_str, &log_output_typelib);

  opt_bin_log= 0;

  opt_skip_show_db=0;

  opt_tc_log_file= (char *)"tc.log";      // no hostname in tc_log file name !

  opt_secure_auth= 0;

  opt_secure_file_priv= 0;

  binlog_cache_use=  binlog_cache_disk_use= 0;

  max_used_connections= slow_launch_threads = 0;

  mysqld_user= mysqld_chroot= opt_init_file= opt_bin_logname = 0;

  memset(&mysql_tmpdir_list, 0, sizeof(mysql_tmpdir_list));

  memset(&global_status_var, 0, sizeof(global_status_var));

  key_map_full.set_all();

  what_to_log= ~ (1L << (uint) COM_TIME);

  refresh_version= 1L;  /* Increments on each reload */

  global_query_id= thread_id= 1L;

  myisam_recover_options_str= "OFF";

  myisam_stats_method_str= "nulls_unequal";

  threads.empty();

    if (default_collation_name == compiled_default_collation_name)

      default_collation_name= 0;

    break;

  case 'h':

    strmake(mysql_real_data_home,argument, sizeof(mysql_real_data_home)-1);

    /* Correct pointer set by my_getopt (for embedded library) */

      }

      break;

    }

  case (int) OPT_WANT_CORE:

    test_flags |= TEST_CORE_ON_SIGNAL;

    break;

 

/** Handle arguments for multiple key caches. */

 

                                      const struct my_option *option);

 

char**

                   const struct my_option *option)

{

  switch (option->id) {

  (*argc)++; /* add back one for the progname handle_options removes */

             /* no need to do this for argv as we are discarding it. */

 

#if defined(HAVE_BROKEN_REALPATH)

  my_use_symdir=0;

  my_disable_symlinks=1;

  (DRIZZLE_SERVER_SUFFIX is set by the compilation environment)

*/

 

static void set_server_version(void)

{

  char *end= strxmov(server_version, DRIZZLE_SERVER_VERSION,

}

 

 

  if (!test_if_hard_path(dir))

  {

    strxnmov(tmp_path,sizeof(tmp_path)-1, mysql_real_data_home,

    dir=tmp_path;

  }

  return !fn_format(to, name, dir, extension,

static void fix_paths(void)

{

  char buff[FN_REFLEN],*pos;

  /* Resolve symlinks to allow 'mysql_home' to be a relative symlink */

  my_realpath(mysql_home,mysql_home,MYF(0));

  /* Ensure that mysql_home ends in FN_LIBCHAR */

    pos[0]= FN_LIBCHAR;

    pos[1]= 0;

  }

  (void) fn_format(buff, mysql_real_data_home, "", "",

                   (MY_RETURN_REAL_PATH|MY_RESOLVE_SYMLINKS));

  (void) unpack_dirname(mysql_unpacked_real_data_home, buff);

  (void) my_load_path(mysql_home,mysql_home,""); // Resolve current dir

  (void) my_load_path(mysql_real_data_home,mysql_real_data_home,mysql_home);

  (void) my_load_path(pidfile_name,pidfile_name,mysql_real_data_home);

  if (test_if_hard_path(sharedir))

    strmake(buff,sharedir,sizeof(buff)-1);              /* purecov: tested */

  else

  (void) my_load_path(language,language,buff);

 

  /* If --character-sets-dir isn't given, use shared library dir */

  if (charsets_dir != mysql_charsets_dir)

  {

    strxnmov(mysql_charsets_dir, sizeof(mysql_charsets_dir)-1, buff,

  }

  (void) my_load_path(mysql_charsets_dir, mysql_charsets_dir, buff);

  charsets_dir=mysql_charsets_dir;

 

  if (init_tmpdir(&mysql_tmpdir_list, opt_mysql_tmpdir))

   */

  if (opt_secure_file_priv)

  {

    opt_secure_file_priv= my_strdup(buff, MYF(MY_FAE));

  }

}

    char buff[21], *end;

    end= int10_to_str((long) getpid(), buff, 10);

    *end++= '\n';

    {

      (void) my_close(file, MYF(0));

      return;