~drizzle-trunk/drizzle/development

   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */

 

#include "mysql_priv.h"

#include <mysys/my_bit.h>

#include "slave.h"

#include "rpl_mi.h"

#include <mysys/mysys_err.h>

#include <sys/poll.h>

#include <netinet/tcp.h>

 

#include <storage/myisam/ha_myisam.h>

 

#endif

 

#include <mysys/thr_alarm.h>

 

#define mysqld_charset &my_charset_latin1

 

#endif

 

#define SIGNAL_FMT "signal %d"

 

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

#include <ieeefp.h>

/*

  Used with --help for detailed option

*/

 

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

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

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

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

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

                             (unsigned int *) log_output_names_len};

 

/* static variables */

static char *character_set_filesystem_name;

static char *lc_time_names_name;

static char *my_bind_addr_str;

static char *default_storage_engine_str;

static char compiled_default_collation_name[]= MYSQL_DEFAULT_COLLATION_NAME;

static I_List<THD> thread_cache;

/* Global variables */

 

bool opt_bin_log;

bool opt_slow_log;

ulong log_output_options;

bool opt_log_queries_not_using_indexes= false;

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 *myisam_recover_options_str="OFF";

const char *myisam_stats_method_str="nulls_unequal";

 

MY_LOCALE *my_default_lc_time_names;

 

SHOW_COMP_OPTION have_symlink;

SHOW_COMP_OPTION have_compress;

 

/* Thread specific variables */

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_global_system_variables,

                LOCK_user_conn, LOCK_slave_list, LOCK_active_mi,

                LOCK_connection_count;

  /* Abort listening to new connections */

  {

    int x;

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

    {

      if (fds[x].fd != INVALID_SOCKET)

#ifdef HAVE_CLOSE_SERVER_SOCK

  {

    int x;

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

    {

      if (fds[x].fd != INVALID_SOCKET)

    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)

 

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

 

    sql_print_information(ER(ER_SHUTDOWN_COMPLETE),my_progname);

  thread_scheduler.end();

  finish_client_errs();

  /* Tell main we are ready */

  logger.cleanup_end();

  (void) pthread_mutex_lock(&LOCK_thread_count);

  (void) pthread_mutex_destroy(&LOCK_mapped_file);

  (void) pthread_mutex_destroy(&LOCK_status);

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

    fprintf(stderr,"\

Attempting backtrace. You can use the following information to find out\n\

where mysqld died. If you see no messages after this, something went\n\

    print_stacktrace(thd ? (uchar*) thd->thread_stack : (uchar*) 0,

                     my_thread_stack_size);

  }

You should either build a dynamically-linked binary, or force LinuxThreads\n\

to be used with the LD_ASSUME_KERNEL environment variable. Please consult\n\

the documentation for your distribution on how to do that.\n");

  if (locked_in_memory)

  {

    fprintf(stderr, "\n\

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

    */

    if (thd->handle_error(error, str,

      return;;

 

    thd->is_slave_error=  1; // needed to catch query errors during replication

        inside push_warning.

      */

      thd->no_warnings_for_error= true;

      thd->no_warnings_for_error= false;

    }

  }

  {"admin_commands",       (char*) offsetof(STATUS_VAR, com_other), SHOW_LONG_STATUS},

  {"assign_to_keycache",   (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_ASSIGN_TO_KEYCACHE]), SHOW_LONG_STATUS},

  {"alter_db",             (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_ALTER_DB]), SHOW_LONG_STATUS},

  {"alter_table",          (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_ALTER_TABLE]), SHOW_LONG_STATUS},

  {"analyze",              (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_ANALYZE]), SHOW_LONG_STATUS},

  {"begin",                (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_BEGIN]), SHOW_LONG_STATUS},

  server_start_time= flush_status_time= my_time(0);

  rpl_filter= new Rpl_filter;

  binlog_filter= new Rpl_filter;

  {

    sql_perror("Could not allocate replication and binlog filters");

    exit(1);

  global_system_variables.optimizer_use_mrr= 1;

  global_system_variables.optimizer_switch= 0;

 

        get_charset_by_csname(character_set_filesystem_name,

                              MY_CS_PRIMARY, MYF(MY_WME))))

    return 1;

    return 1;

  }

  global_system_variables.lc_time_names= my_default_lc_time_names;

  sys_init_connect.value_length= 0;

  if ((sys_init_connect.value= opt_init_connect))

    sys_init_connect.value_length= strlen(opt_init_connect);

  (void) pthread_mutex_init(&LOCK_mapped_file,MY_MUTEX_INIT_SLOW);

  (void) pthread_mutex_init(&LOCK_status,MY_MUTEX_INIT_FAST);

  (void) pthread_mutex_init(&LOCK_error_log,MY_MUTEX_INIT_FAST);

  (void) pthread_mutex_init(&LOCK_user_conn, MY_MUTEX_INIT_FAST);

  (void) pthread_mutex_init(&LOCK_active_mi, MY_MUTEX_INIT_FAST);

  (void) pthread_mutex_init(&LOCK_global_system_variables, MY_MUTEX_INIT_FAST);

    if (opt_binlog_format_id == BINLOG_FORMAT_UNSPEC)

      global_system_variables.binlog_format= BINLOG_FORMAT_MIXED;

    else

      assert(global_system_variables.binlog_format != BINLOG_FORMAT_UNSPEC);

    }

 

    }

  }

 

  /* We have to initialize the storage engines before CSV logging */

  if (ha_init())

  {

                       strlen(default_storage_engine_str) };

    plugin_ref plugin;

    handlerton *hton;

    if ((plugin= ha_resolve_by_name(0, &name)))

    else

    {

      sql_print_error("Unknown/unsupported table type: %s",

    else

    {

      /*

        was acquired during plugin_init()

      */

      plugin_unlock(0, global_system_variables.table_plugin);

 

int main(int argc, char **argv)

{

  MY_INIT(argv[0]);             // init my_sys library & pthreads

  /* nothing should come before this line ^^^ */

 

  handle_connections_sockets();

 

  /* (void) pthread_attr_destroy(&connection_attrib); */

 

#ifdef EXTRA_DEBUG2

  sql_print_error("Before Lock_thread_count");

    }

    if (number_of == 0)

      continue;

#ifdef FIXME_IF_WE_WERE_KEEPING_THIS

    assert(number_of > 1); /* Not handling this at the moment */

#endif

      size_socket dummyLen;

      struct sockaddr_storage dummy;

      dummyLen = sizeof(dummy);

                  (socklen_t *)&dummyLen) < 0  )

      {

        sql_perror("Error on new connection socket");

 

enum options_mysqld

{

  OPT_ENABLE_LOCK,             OPT_USE_LOCKING,

  OPT_SOCKET,                  OPT_UPDATE_LOG,

  OPT_BIN_LOG_INDEX,

  OPT_BIND_ADDRESS,            OPT_PID_FILE,

  OPT_STANDALONE,

  OPT_CONSOLE,                 OPT_LOW_PRIORITY_UPDATES,

  OPT_SHORT_LOG_FORMAT,

  OPT_FLUSH,                   OPT_SAFE,

  OPT_STORAGE_ENGINE,          OPT_INIT_FILE,

  OPT_DELAY_KEY_WRITE_ALL,     OPT_SLOW_QUERY_LOG,

  OPT_DELAY_KEY_WRITE,         OPT_CHARSETS_DIR,

  OPT_REPLICATE_IGNORE_DB,     OPT_LOG_SLAVE_UPDATES,

  OPT_BINLOG_DO_DB,            OPT_BINLOG_IGNORE_DB,

  OPT_BINLOG_FORMAT,

  OPT_WANT_CORE,

  OPT_MEMLOCK,                 OPT_MYISAM_RECOVER,

  OPT_REPLICATE_REWRITE_DB,    OPT_SERVER_ID,

  OPT_DISCONNECT_SLAVE_EVENT_COUNT, OPT_TC_HEURISTIC_RECOVER,

  OPT_ABORT_SLAVE_EVENT_COUNT,

  OPT_LOG_BIN_TRUST_FUNCTION_CREATORS,

  OPT_TEMP_POOL, OPT_TX_ISOLATION, OPT_COMPLETION_TYPE,

  OPT_SKIP_STACK_TRACE, OPT_SKIP_SYMLINKS,

  OPT_MAX_BINLOG_DUMP_EVENTS, OPT_SPORADIC_BINLOG_DUMP_FAIL,

  OPT_MAX_BINLOG_CACHE_SIZE, OPT_MAX_BINLOG_SIZE,

  OPT_MAX_CONNECTIONS, OPT_MAX_CONNECT_ERRORS,

  OPT_MAX_HEP_TABLE_SIZE,

  OPT_MAX_RELAY_LOG_SIZE, OPT_MAX_SORT_LENGTH,

  OPT_MAX_SEEKS_FOR_KEY, OPT_MAX_TMP_TABLES, OPT_MAX_USER_CONNECTIONS,

  OPT_MAX_LENGTH_FOR_SORT_DATA,

  OPT_NET_READ_TIMEOUT, OPT_NET_WRITE_TIMEOUT,

  OPT_OPEN_FILES_LIMIT,

  OPT_PRELOAD_BUFFER_SIZE,

  OPT_RECORD_RND_BUFFER, OPT_DIV_PRECINCREMENT, OPT_RELAY_LOG_SPACE_LIMIT,

  OPT_RELAY_LOG_PURGE,

  OPT_SLAVE_NET_TIMEOUT, OPT_SLAVE_COMPRESSED_PROTOCOL, OPT_SLOW_LAUNCH_TIME,

 

struct my_option my_long_options[] =

{

   (char**) &opt_help, (char**) &opt_help, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,

   0, 0},

  {"abort-slave-event-count", OPT_ABORT_SLAVE_EVENT_COUNT,

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

   (char**) &abort_slave_event_count,  (char**) &abort_slave_event_count,

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

  {"auto-increment-increment", OPT_AUTO_INCREMENT,

   "Auto-increment columns are incremented by this",

   (char**) &global_system_variables.auto_increment_increment,

   "Path to installation directory. All paths are usually resolved relative to this.",

   (char**) &mysql_home_ptr, (char**) &mysql_home_ptr, 0, GET_STR, REQUIRED_ARG,

   0, 0, 0, 0, 0, 0},

  {"bind-address", OPT_BIND_ADDRESS, "IP address to bind to.",

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

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

   "The maximum size of a row-based binary log event in bytes. Rows will be "

   "grouped into events smaller than this size if possible. "

   "The value has to be a multiple of 256.",

   /* app_type */ 0

  },

  {"character-set-client-handshake", OPT_CHARACTER_SET_CLIENT_HANDSHAKE,

   "Don't ignore client side character set value sent during handshake.",

   (char**) &opt_character_set_client_handshake,

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

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

  {"language", 'L',

   (char**) &language_ptr, (char**) &language_ptr, 0, GET_STR, REQUIRED_ARG,

   0, 0, 0, 0, 0, 0},

  {"lc-time-names", OPT_LC_TIME_NAMES,

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

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

  {"log-long-format", '0',

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

#ifdef WITH_CSV_STORAGE_ENGINE

  {"log-output", OPT_LOG_OUTPUT,

   0, 0, 0, 0, 0},

  {"timed_mutexes", OPT_TIMED_MUTEXES,

   "Specify whether to time mutexes (only InnoDB mutexes are currently supported)",

    0, 0, 0, 0, 0},

  {"tmpdir", 't',

   "Path for temporary files. Several paths may be specified, separated by a "

   IF_PURIFY(0,1), 0, 0, 0, 0, 0},

  {"user", 'u', "Run mysqld daemon as user.", 0, 0, 0, GET_STR, REQUIRED_ARG,

   0, 0, 0, 0, 0, 0},

  {"version", 'V', "Output version information and exit.", 0, 0, 0, GET_NO_ARG,

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

  {"warnings", 'W', "Deprecated; use --log-warnings instead.",

   0, GET_ULONG, REQUIRED_ARG, CONNECT_TIMEOUT, 2, LONG_TIMEOUT, 0, 1, 0 },

  { "date_format", OPT_DATE_FORMAT,

    "The DATE format (For future).",

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

  { "datetime_format", OPT_DATETIME_FORMAT,

    "The DATETIME/TIMESTAMP format (for future).",

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

  { "default_week_format", OPT_DEFAULT_WEEK_FORMAT,

    "The default week format used by WEEK() functions.",

   "This characterizes the number of hits a hot block has to be untouched until it is considered aged enough to be downgraded to a warm block. This specifies the percentage ratio of that number of hits to the total number of blocks in key cache",

   (char**) &dflt_key_cache_var.param_age_threshold,

   (char**) 0,

   300, 100, ULONG_MAX, 0, 100, 0},

  {"key_cache_block_size", OPT_KEY_CACHE_BLOCK_SIZE,

   "The default size of key cache blocks",

   (char**) &global_system_variables.net_write_timeout,

   (char**) &max_system_variables.net_write_timeout, 0, GET_ULONG,

   REQUIRED_ARG, NET_WRITE_TIMEOUT, 1, LONG_TIMEOUT, 0, 1, 0},

    (char**) &global_system_variables.old_mode,

    0, 0, 0, 0, 0, 0},

  {"open_files_limit", OPT_OPEN_FILES_LIMIT,

   "If this is not 0, then mysqld will use this value to reserve file descriptors to use with setrlimit(). If this value is 0 then mysqld will reserve max_connections*5 or max_connections + table_cache*2 (whichever is larger) number of files.",

   1024L*128L, ULONG_MAX, 0, 1024, 0},

  { "time_format", OPT_TIME_FORMAT,

    "The TIME format (for future).",

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

  {"tmp_table_size", OPT_TMP_TABLE_SIZE,

   "If an internal in-memory temporary table exceeds this size, MySQL will"

Copyright (C) 2000 MySQL AB, by Monty and others\n\

This software comes with ABSOLUTELY NO WARRANTY. This is free software,\n\

and you are welcome to modify and redistribute it under the GPL license\n\n\

 

  printf("Usage: %s [OPTIONS]\n", my_progname);

  {

  print_defaults(MYSQL_CONFIG_NAME,load_default_groups);

  puts("");

  set_ports();

 

  /* Print out all the options including plugin supplied options */

  my_print_help_inc_plugins(my_long_options, sizeof(my_long_options)/sizeof(my_option));

 

  puts("\n\

  }

}

 

  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;

  opt_mysql_tmpdir= my_bind_addr_str= NullS;

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

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

#else

  have_symlink=SHOW_OPTION_YES;

#endif

#ifdef HAVE_COMPRESS

  have_compress= SHOW_OPTION_YES;

#else

    test_flags= argument ? (uint) atoi(argument) : 0;

    opt_endinfo=1;

    break;

  case (int) OPT_ISAM_LOG:

    opt_myisam_log=1;

    break;

      break;

    }

#endif

  case (int) OPT_SKIP_PRIOR:

    opt_specialflag|= SPECIAL_NO_PRIOR;

    break;

  case (int) OPT_WANT_CORE:

    test_flags |= TEST_CORE_ON_SIGNAL;

    break;

    break;

  case (int) OPT_BIND_ADDRESS:

    {

 

      memset(&hints, 0, sizeof(struct addrinfo));

      hints.ai_socktype= SOCK_STREAM;

      hints.ai_protocol= IPPROTO_TCP;

 

      {

        sql_print_error("Can't start server: cannot resolve hostname!");

        exit(1);

  if (opt_short_log_format)

    opt_specialflag|= SPECIAL_SHORT_LOG_FORMAT;

 

                                  &global_system_variables.date_format) ||

                                  &global_system_variables.time_format) ||

                                  &global_system_variables.datetime_format))

    exit(1);

 

  ulong res;

 

  const char **ptr;

  if ((res= find_bit_type(x, bit_lib)) == ~(ulong) 0)

  {

    ptr= bit_lib->type_names;