~drizzle-trunk/drizzle/development

#include <mysys/mysys_err.h>

#include <sys/poll.h>

#include <netinet/tcp.h>

 

#include <storage/myisam/ha_myisam.h>

 

 

#include <mysys/thr_alarm.h>

#include <libdrizzle/errmsg.h>

 

#define mysqld_charset &my_charset_latin1

 

#endif

 

#define SIGNAL_FMT "signal %d"

 

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

#include <ieeefp.h>

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

 

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

    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\

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

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

  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,

 

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,

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

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

   "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.",

  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((uchar*) &mysql_tmpdir_list, 0, sizeof(mysql_tmpdir_list));

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

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

  ulong res;

 

  const char **ptr;

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

  {

    ptr= bit_lib->type_names;