mirror of
https://github.com/MariaDB/server.git
synced 2025-01-17 20:42:30 +01:00
fdc446d0c6
BitKeeper/etc/ignore: auto-union BitKeeper/etc/logging_ok: auto-union BUILD/FINISH.sh: Auto merged BUILD/SETUP.sh: Auto merged BUILD/compile-pentium-debug: Auto merged acconfig.h: Auto merged client/mysql.cc: Auto merged client/mysqldump.c: Auto merged client/mysqltest.c: Auto merged heap/hp_rfirst.c: Auto merged heap/hp_rnext.c: Auto merged include/my_sys.h: Auto merged include/myisam.h: Auto merged libmysql/Makefile.shared: Auto merged myisam/mi_write.c: Auto merged mysql-test/mysql-test-run.sh: Auto merged mysql-test/r/heap.result: Auto merged mysql-test/r/select_found.result: Auto merged mysql-test/r/union.result: Auto merged mysql-test/t/heap.test: Auto merged mysql-test/t/select_found.test: Auto merged mysql-test/t/union.test: Auto merged mysys/mf_iocache2.c: Auto merged mysys/my_vsnprintf.c: Auto merged sql/convert.cc: Auto merged sql/field.cc: Auto merged sql/field.h: Auto merged sql/filesort.cc: Auto merged sql/ha_myisam.cc: Auto merged sql/item.cc: Auto merged sql/item.h: Auto merged sql/item_cmpfunc.cc: Auto merged sql/item_func.cc: Auto merged sql/item_func.h: Auto merged sql/item_strfunc.cc: Auto merged sql/item_timefunc.cc: Auto merged sql/lex.h: Auto merged sql/log.cc: Auto merged sql/mysql_priv.h: Auto merged sql/mysqld.cc: Auto merged sql/opt_range.cc: Auto merged sql/opt_range.h: Auto merged sql/opt_sum.cc: Auto merged sql/slave.cc: Auto merged sql/sql_base.cc: Auto merged sql/sql_cache.cc: Auto merged sql/sql_class.cc: Auto merged sql/sql_db.cc: Auto merged sql/sql_handler.cc: Auto merged sql/sql_lex.cc: Auto merged sql/sql_lex.h: Auto merged sql/sql_parse.cc: Auto merged sql/sql_show.cc: Auto merged sql/sql_table.cc: Auto merged sql/sql_union.cc: Auto merged sql/sql_yacc.yy: Auto merged sql/structs.h: Auto merged sql/table.cc: Auto merged sql/table.h: Auto merged strings/Makefile.am: Auto merged
4564 lines
150 KiB
C++
4564 lines
150 KiB
C++
/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult 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; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
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 <mysql.h>
|
|
#include <m_ctype.h>
|
|
#include <my_dir.h>
|
|
#include "sql_acl.h"
|
|
#include "slave.h"
|
|
#include "sql_repl.h"
|
|
#include "repl_failsafe.h"
|
|
#include "stacktrace.h"
|
|
#ifdef HAVE_BERKELEY_DB
|
|
#include "ha_berkeley.h"
|
|
#endif
|
|
#ifdef HAVE_INNOBASE_DB
|
|
#include "ha_innodb.h"
|
|
#endif
|
|
#include "ha_myisam.h"
|
|
#include <nisam.h>
|
|
#include <thr_alarm.h>
|
|
#include <ft_global.h>
|
|
|
|
#ifndef DBUG_OFF
|
|
#define ONE_THREAD
|
|
#endif
|
|
|
|
#ifdef SAFEMALLOC
|
|
#define SHUTDOWN_THD shutdown_th=pthread_self();
|
|
#define MAIN_THD main_th=pthread_self();
|
|
#define SIGNAL_THD signal_th=pthread_self();
|
|
#else
|
|
#define SHUTDOWN_THD
|
|
#define MAIN_THD
|
|
#define SIGNAL_THD
|
|
#endif
|
|
|
|
/* stack traces are only supported on linux intel */
|
|
#if defined(__linux__) && defined(__i386__) && defined(USE_PSTACK)
|
|
#define HAVE_STACK_TRACE_ON_SEGV
|
|
#include "../pstack/pstack.h"
|
|
char pstack_file_name[80];
|
|
#endif /* __linux__ */
|
|
|
|
#if defined(HAVE_DEC_3_2_THREADS) || defined(SIGNALS_DONT_BREAK_READ)
|
|
#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 <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
|
|
|
|
#if defined(OS2)
|
|
# include <sys/un.h>
|
|
#elif !defined( __WIN__)
|
|
#include <sys/resource.h>
|
|
#ifdef HAVE_SYS_UN_H
|
|
# include <sys/un.h>
|
|
#endif
|
|
#include <netdb.h>
|
|
#ifdef HAVE_SELECT_H
|
|
# include <select.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_SELECT_H
|
|
#include <sys/select.h>
|
|
#endif
|
|
#include <sys/utsname.h>
|
|
#endif /* __WIN__ */
|
|
|
|
#ifdef HAVE_LIBWRAP
|
|
#include <tcpd.h>
|
|
#include <syslog.h>
|
|
#ifdef NEED_SYS_SYSLOG_H
|
|
#include <sys/syslog.h>
|
|
#endif /* NEED_SYS_SYSLOG_H */
|
|
int allow_severity = LOG_INFO;
|
|
int deny_severity = LOG_WARNING;
|
|
#endif /* HAVE_LIBWRAP */
|
|
|
|
#ifdef HAVE_SYS_MMAN_H
|
|
#include <sys/mman.h>
|
|
#endif
|
|
|
|
#ifdef _AIX41
|
|
int initgroups(const char *,unsigned int);
|
|
#endif
|
|
|
|
#if defined(__FreeBSD__) && defined(HAVE_IEEEFP_H)
|
|
#include <ieeefp.h>
|
|
#ifdef HAVE_FP_EXCEPT // Fix type conflict
|
|
typedef fp_except fp_except_t;
|
|
#endif
|
|
|
|
/* We can't handle floating point expections with threads, so disable
|
|
this on freebsd
|
|
*/
|
|
|
|
inline void reset_floating_point_exceptions()
|
|
{
|
|
/* 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
|
|
}
|
|
#else
|
|
#define reset_floating_point_exceptions()
|
|
#endif /* __FreeBSD__ && HAVE_IEEEFP_H */
|
|
|
|
} /* cplusplus */
|
|
|
|
|
|
#if defined(HAVE_LINUXTHREADS)
|
|
#define THR_KILL_SIGNAL SIGINT
|
|
#else
|
|
#define THR_KILL_SIGNAL SIGUSR2 // Can't use this with LinuxThreads
|
|
#endif
|
|
|
|
#ifdef HAVE_GLIBC2_STYLE_GETHOSTBYNAME_R
|
|
#include <sys/types.h>
|
|
#else
|
|
#include <my_pthread.h> // For thr_setconcurency()
|
|
#endif
|
|
#if defined(HAVE_GETRLIMIT) && defined(RLIMIT_NOFILE) && !defined(HAVE_mit_thread)
|
|
#define SET_RLIMIT_NOFILE
|
|
#endif
|
|
|
|
#ifdef SOLARIS
|
|
extern "C" int gethostname(char *name, int namelen);
|
|
#endif
|
|
|
|
#define MYSQL_KILL_SIGNAL SIGTERM
|
|
|
|
#ifndef DBUG_OFF
|
|
static const char* default_dbug_option=IF_WIN("d:t:i:O,\\mysqld.trace",
|
|
"d:t:i:o,/tmp/mysqld.trace");
|
|
#endif
|
|
|
|
#ifdef __NT__
|
|
static char szPipeName [ 257 ];
|
|
static SECURITY_ATTRIBUTES saPipeSecurity;
|
|
static SECURITY_DESCRIPTOR sdPipeDescriptor;
|
|
static HANDLE hPipe = INVALID_HANDLE_VALUE;
|
|
static pthread_cond_t COND_handler_count;
|
|
static uint handler_count;
|
|
static bool opt_enable_named_pipe = 0;
|
|
#endif
|
|
#ifdef __WIN__
|
|
static bool opt_console=0,start_mode=0;
|
|
#endif
|
|
|
|
/* Set prefix for windows binary */
|
|
#ifdef __WIN__
|
|
#undef MYSQL_SERVER_SUFFIX
|
|
#ifdef __NT__
|
|
#if defined(HAVE_INNOBASE_DB) || defined(HAVE_BERKELEY_DB)
|
|
#define MYSQL_SERVER_SUFFIX "-max-nt"
|
|
#else
|
|
#define MYSQL_SERVER_SUFFIX "-nt"
|
|
#endif /* ...DB */
|
|
#elif defined(HAVE_INNOBASE_DB) || defined(HAVE_BERKELEY_DB)
|
|
#define MYSQL_SERVER_SUFFIX "-max"
|
|
#else
|
|
#define MYSQL_SERVER_SUFFIX ""
|
|
#endif /* __NT__ */
|
|
#endif
|
|
|
|
#ifdef HAVE_BERKELEY_DB
|
|
SHOW_COMP_OPTION have_berkeley_db=SHOW_OPTION_YES;
|
|
#else
|
|
SHOW_COMP_OPTION have_berkeley_db=SHOW_OPTION_NO;
|
|
#endif
|
|
#ifdef HAVE_INNOBASE_DB
|
|
SHOW_COMP_OPTION have_innodb=SHOW_OPTION_YES;
|
|
#else
|
|
SHOW_COMP_OPTION have_innodb=SHOW_OPTION_NO;
|
|
#endif
|
|
#ifdef HAVE_ISAM
|
|
SHOW_COMP_OPTION have_isam=SHOW_OPTION_YES;
|
|
#else
|
|
SHOW_COMP_OPTION have_isam=SHOW_OPTION_NO;
|
|
#endif
|
|
#ifdef USE_RAID
|
|
SHOW_COMP_OPTION have_raid=SHOW_OPTION_YES;
|
|
#else
|
|
SHOW_COMP_OPTION have_raid=SHOW_OPTION_NO;
|
|
#endif
|
|
#ifdef HAVE_OPENSSL
|
|
SHOW_COMP_OPTION have_openssl=SHOW_OPTION_YES;
|
|
#else
|
|
SHOW_COMP_OPTION have_openssl=SHOW_OPTION_NO;
|
|
#endif
|
|
SHOW_COMP_OPTION have_symlink=SHOW_OPTION_YES;
|
|
#ifdef HAVE_QUERY_CACHE
|
|
SHOW_COMP_OPTION have_query_cache=SHOW_OPTION_YES;
|
|
#else
|
|
SHOW_COMP_OPTION have_query_cache=SHOW_OPTION_NO;
|
|
#endif
|
|
|
|
bool opt_skip_slave_start = 0; // If set, slave is not autostarted
|
|
static bool opt_do_pstack = 0;
|
|
static ulong opt_specialflag=SPECIAL_ENGLISH;
|
|
static ulong back_log,connect_timeout,concurrency;
|
|
static ulong opt_myisam_block_size;
|
|
static my_socket unix_sock= INVALID_SOCKET,ip_sock= INVALID_SOCKET;
|
|
static my_string opt_logname=0,opt_update_logname=0,
|
|
opt_binlog_index_name = 0,opt_slow_logname=0;
|
|
static char mysql_home[FN_REFLEN],pidfile_name[FN_REFLEN];
|
|
static pthread_t select_thread;
|
|
static bool opt_log,opt_update_log,opt_bin_log,opt_slow_log,opt_noacl,
|
|
opt_disable_networking=0, opt_bootstrap=0,opt_skip_show_db=0,
|
|
opt_myisam_log=0,
|
|
opt_large_files=sizeof(my_off_t) > 4;
|
|
bool opt_sql_bin_update = 0, opt_log_slave_updates = 0, opt_safe_show_db=0,
|
|
opt_show_slave_auth_info = 0, opt_old_rpl_compat = 0,
|
|
opt_safe_user_create = 0, opt_no_mix_types = 0;
|
|
volatile bool mqh_used = 0;
|
|
FILE *bootstrap_file=0;
|
|
int segfaulted = 0; // ensure we do not enter SIGSEGV handler twice
|
|
|
|
/*
|
|
If sql_bin_update is true, SQL_LOG_UPDATE and SQL_LOG_BIN are kept in sync,
|
|
and are treated as aliases for each other
|
|
*/
|
|
|
|
static bool kill_in_progress=FALSE;
|
|
static struct rand_struct sql_rand;
|
|
static int cleanup_done;
|
|
static char **defaults_argv,time_zone[30];
|
|
static const char *default_table_type_name;
|
|
char glob_hostname[FN_REFLEN];
|
|
|
|
#include "sslopt-vars.h"
|
|
#ifdef HAVE_OPENSSL
|
|
char *des_key_file = 0;
|
|
struct st_VioSSLAcceptorFd * ssl_acceptor_fd = 0;
|
|
#endif /* HAVE_OPENSSL */
|
|
|
|
I_List <i_string_pair> replicate_rewrite_db;
|
|
I_List<i_string> replicate_do_db, replicate_ignore_db;
|
|
// allow the user to tell us which db to replicate and which to ignore
|
|
I_List<i_string> binlog_do_db, binlog_ignore_db;
|
|
|
|
/* if we guessed server_id , we need to know about it */
|
|
uint32 server_id = 0;
|
|
bool server_id_supplied = 0;
|
|
|
|
uint mysql_port;
|
|
uint test_flags = 0, select_errors=0, dropping_tables=0,ha_open_options=0;
|
|
uint volatile thread_count=0, thread_running=0, kill_cached_threads=0,
|
|
wake_thread=0;
|
|
ulong thd_startup_options=(OPTION_UPDATE_LOG | OPTION_AUTO_IS_NULL |
|
|
OPTION_BIN_LOG | OPTION_QUOTE_SHOW_CREATE );
|
|
uint protocol_version=PROTOCOL_VERSION;
|
|
ulong keybuff_size,sortbuff_size,max_item_sort_length,table_cache_size,
|
|
max_join_size,join_buff_size,tmp_table_size,thread_stack,
|
|
thread_stack_min,net_wait_timeout,what_to_log= ~ (1L << (uint) COM_TIME),
|
|
query_buff_size, lower_case_table_names, mysqld_net_retry_count,
|
|
net_interactive_timeout, slow_launch_time = 2L,
|
|
net_read_timeout,net_write_timeout,slave_open_temp_tables=0,
|
|
open_files_limit=0, max_binlog_size, record_rnd_cache_size;
|
|
ulong com_stat[(uint) SQLCOM_END], com_other;
|
|
ulong slave_net_timeout;
|
|
ulong thread_cache_size=0, binlog_cache_size=0, max_binlog_cache_size=0;
|
|
#ifdef HAVE_QUERY_CACHE
|
|
ulong query_cache_size=0, query_cache_limit=0, query_cache_startup_type=1;
|
|
Query_cache query_cache;
|
|
#endif
|
|
|
|
volatile ulong cached_thread_count=0;
|
|
|
|
// replication parameters, if master_host is not NULL, we are a slave
|
|
my_string master_user = (char*) "test", master_password = 0, master_host=0,
|
|
master_info_file = (char*) "master.info",
|
|
relay_log_info_file = (char*) "relay-log.info",
|
|
master_ssl_key=0, master_ssl_cert=0;
|
|
my_string report_user = 0, report_password = 0, report_host=0;
|
|
|
|
const char *localhost=LOCAL_HOST;
|
|
const char *delayed_user="DELAYED";
|
|
uint master_port = MYSQL_PORT, master_connect_retry = 60;
|
|
uint report_port = MYSQL_PORT;
|
|
bool master_ssl = 0;
|
|
|
|
ulong max_tmp_tables,max_heap_table_size,master_retry_count=0;
|
|
ulong bytes_sent = 0L, bytes_received = 0L;
|
|
|
|
bool opt_endinfo,using_udf_functions,low_priority_updates, locked_in_memory;
|
|
bool opt_using_transactions, using_update_log, opt_warnings=0;
|
|
bool opt_local_infile=1;
|
|
bool volatile abort_loop,select_thread_in_use,grant_option;
|
|
bool volatile ready_to_exit,shutdown_in_progress;
|
|
ulong refresh_version=1L,flush_version=1L; /* Increments on each reload */
|
|
ulong query_id=1L,long_query_count,long_query_time,aborted_threads,
|
|
aborted_connects,delayed_insert_timeout,delayed_insert_limit,
|
|
delayed_queue_size,delayed_insert_threads,delayed_insert_writes,
|
|
delayed_rows_in_use,delayed_insert_errors,flush_time, thread_created;
|
|
ulong filesort_rows, filesort_range_count, filesort_scan_count;
|
|
ulong filesort_merge_passes;
|
|
ulong select_range_check_count, select_range_count, select_scan_count;
|
|
ulong select_full_range_join_count,select_full_join_count;
|
|
ulong specialflag=0,opened_tables=0,created_tmp_tables=0,
|
|
created_tmp_disk_tables=0;
|
|
ulong max_connections,max_insert_delayed_threads,max_used_connections,
|
|
max_connect_errors, max_user_connections = 0;
|
|
ulong thread_id=1L,current_pid;
|
|
ulong slow_launch_threads = 0;
|
|
ulong myisam_max_sort_file_size, myisam_max_extra_sort_file_size;
|
|
|
|
char mysql_real_data_home[FN_REFLEN],
|
|
language[LIBLEN],reg_ext[FN_EXTLEN],
|
|
default_charset[LIBLEN],mysql_charsets_dir[FN_REFLEN], *charsets_list,
|
|
blob_newline,f_fyllchar,max_sort_char,*mysqld_user,*mysqld_chroot,
|
|
*opt_init_file;
|
|
#ifndef EMBEDDED_LIBRARY
|
|
char mysql_data_home_buff[2], *mysql_data_home=mysql_data_home_buff;
|
|
bool mysql_embedded=0;
|
|
#else
|
|
char *mysql_data_home=mysql_real_data_home;
|
|
bool mysql_embedded=1;
|
|
#endif
|
|
|
|
char *opt_bin_logname = 0; // this one needs to be seen in sql_parse.cc
|
|
char *opt_relay_logname = 0, *opt_relaylog_index_name=0;
|
|
char server_version[SERVER_VERSION_LENGTH]=MYSQL_SERVER_VERSION;
|
|
const char *first_keyword="first";
|
|
const char **errmesg; /* Error messages */
|
|
const char *myisam_recover_options_str="OFF";
|
|
const char *sql_mode_str="OFF";
|
|
const char *default_tx_isolation_name;
|
|
enum_tx_isolation default_tx_isolation=ISO_READ_COMMITTED;
|
|
|
|
uint rpl_recovery_rank=0;
|
|
|
|
my_string mysql_unix_port=NULL, mysql_tmpdir=NULL, allocated_mysql_tmpdir=NULL;
|
|
ulong my_bind_addr; /* the address we bind to */
|
|
DATE_FORMAT dayord;
|
|
double log_10[32]; /* 10 potences */
|
|
I_List<THD> threads,thread_cache;
|
|
time_t start_time;
|
|
|
|
ulong opt_sql_mode = 0L;
|
|
const char *sql_mode_names[] =
|
|
{ "REAL_AS_FLOAT", "PIPES_AS_CONCAT", "ANSI_QUOTES", "IGNORE_SPACE",
|
|
"SERIALIZE","ONLY_FULL_GROUP_BY", "NO_UNSIGNED_SUBTRACTION",NullS };
|
|
TYPELIB sql_mode_typelib= {array_elements(sql_mode_names)-1,"",
|
|
sql_mode_names};
|
|
|
|
MY_BITMAP temp_pool;
|
|
bool use_temp_pool=0;
|
|
|
|
pthread_key(MEM_ROOT*,THR_MALLOC);
|
|
pthread_key(THD*, THR_THD);
|
|
pthread_key(NET*, THR_NET);
|
|
pthread_mutex_t LOCK_mysql_create_db, LOCK_Acl, LOCK_open, LOCK_thread_count,
|
|
LOCK_mapped_file, LOCK_status, LOCK_grant,
|
|
LOCK_error_log,
|
|
LOCK_delayed_insert, LOCK_delayed_status, LOCK_delayed_create,
|
|
LOCK_crypt, LOCK_bytes_sent, LOCK_bytes_received,
|
|
LOCK_server_id,
|
|
LOCK_user_conn, LOCK_slave_list, LOCK_active_mi;
|
|
|
|
pthread_cond_t COND_refresh,COND_thread_count,COND_binlog_update,
|
|
COND_slave_stopped, COND_slave_start;
|
|
pthread_cond_t COND_thread_cache,COND_flush_thread_cache;
|
|
pthread_t signal_thread;
|
|
pthread_attr_t connection_attrib;
|
|
enum db_type default_table_type=DB_TYPE_MYISAM;
|
|
|
|
#ifdef __WIN__
|
|
#undef getpid
|
|
#include <process.h>
|
|
#if !defined(EMBEDDED_LIBRARY)
|
|
HANDLE hEventShutdown;
|
|
#include "nt_servc.h"
|
|
static NTService Service; // Service object for WinNT
|
|
#endif
|
|
#endif
|
|
|
|
#ifdef OS2
|
|
pthread_cond_t eventShutdown;
|
|
#endif
|
|
|
|
static void start_signal_handler(void);
|
|
static void *signal_hand(void *arg);
|
|
static void set_options(void);
|
|
static void get_options(int argc,char **argv);
|
|
static char *get_relative_path(const char *path);
|
|
static void fix_paths(void);
|
|
static pthread_handler_decl(handle_connections_sockets,arg);
|
|
static pthread_handler_decl(kill_server_thread,arg);
|
|
static int bootstrap(FILE *file);
|
|
static void close_server_sock();
|
|
static bool read_init_file(char *file_name);
|
|
#ifdef __NT__
|
|
static pthread_handler_decl(handle_connections_namedpipes,arg);
|
|
#endif
|
|
extern pthread_handler_decl(handle_slave,arg);
|
|
#ifdef SET_RLIMIT_NOFILE
|
|
static uint set_maximum_open_files(uint max_file_limit);
|
|
#endif
|
|
static ulong find_bit_type(const char *x, TYPELIB *bit_lib);
|
|
|
|
/****************************************************************************
|
|
** Code to end mysqld
|
|
****************************************************************************/
|
|
|
|
static void close_connections(void)
|
|
{
|
|
#ifdef EXTRA_DEBUG
|
|
int count=0;
|
|
#endif
|
|
NET net;
|
|
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: %lx",manager_thread));
|
|
(void) pthread_cond_signal(&COND_manager);
|
|
}
|
|
(void) pthread_mutex_unlock(&LOCK_manager);
|
|
|
|
/* kill connection thread */
|
|
#if !defined(__WIN__) && !defined(__EMX__) && !defined(OS2)
|
|
DBUG_PRINT("quit",("waiting for select thread: %lx",select_thread));
|
|
(void) pthread_mutex_lock(&LOCK_thread_count);
|
|
|
|
while (select_thread_in_use)
|
|
{
|
|
struct timespec abstime;
|
|
int error;
|
|
LINT_INIT(error);
|
|
#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 ; 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);
|
|
#endif /* __WIN__ */
|
|
|
|
|
|
/* Abort listening to new connections */
|
|
DBUG_PRINT("quit",("Closing sockets"));
|
|
if ( !opt_disable_networking )
|
|
{
|
|
if (ip_sock != INVALID_SOCKET)
|
|
{
|
|
(void) shutdown(ip_sock,2);
|
|
(void) closesocket(ip_sock);
|
|
ip_sock= INVALID_SOCKET;
|
|
}
|
|
}
|
|
#ifdef __NT__
|
|
if (hPipe != INVALID_HANDLE_VALUE && opt_enable_named_pipe)
|
|
{
|
|
HANDLE temp;
|
|
DBUG_PRINT( "quit", ("Closing named pipes") );
|
|
|
|
/* Create connection to the handle named pipe handler to break the loop */
|
|
if ((temp = CreateFile(szPipeName,
|
|
GENERIC_READ | GENERIC_WRITE,
|
|
0,
|
|
NULL,
|
|
OPEN_EXISTING,
|
|
0,
|
|
NULL )) != INVALID_HANDLE_VALUE)
|
|
{
|
|
WaitNamedPipe(szPipeName, 1000);
|
|
DWORD dwMode = PIPE_READMODE_BYTE | PIPE_WAIT;
|
|
SetNamedPipeHandleState(temp, &dwMode, NULL, NULL);
|
|
CancelIo(temp);
|
|
DisconnectNamedPipe(temp);
|
|
CloseHandle(temp);
|
|
}
|
|
}
|
|
#endif
|
|
#ifdef HAVE_SYS_UN_H
|
|
if (unix_sock != INVALID_SOCKET)
|
|
{
|
|
(void) shutdown(unix_sock,2);
|
|
(void) closesocket(unix_sock);
|
|
(void) unlink(mysql_unix_port);
|
|
unix_sock= INVALID_SOCKET;
|
|
}
|
|
#endif
|
|
end_thr_alarm(); // Don't allow alarms
|
|
end_slave();
|
|
|
|
/* First signal all threads that it's time 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));
|
|
tmp->killed=1;
|
|
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
|
|
|
|
if (thread_count)
|
|
{
|
|
sleep(1); // Give threads time to die
|
|
}
|
|
|
|
/* Force remaining threads to die by closing the connection to the client */
|
|
|
|
(void) my_net_init(&net, (st_vio*) 0);
|
|
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;
|
|
}
|
|
#ifndef __bsdi__ // Bug in BSDI kernel
|
|
if ((net.vio=tmp->net.vio) != 0)
|
|
{
|
|
sql_print_error(ER(ER_FORCING_CLOSE),my_progname,
|
|
tmp->thread_id,tmp->user ? tmp->user : "");
|
|
close_connection(&net,0,0);
|
|
}
|
|
#endif
|
|
DBUG_PRINT("quit",("Unlocking LOCK_thread_count"));
|
|
(void) pthread_mutex_unlock(&LOCK_thread_count);
|
|
}
|
|
net_end(&net);
|
|
/* 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);
|
|
|
|
mysql_log.close(1);
|
|
mysql_slow_log.close(1);
|
|
mysql_update_log.close(1);
|
|
mysql_bin_log.close(1);
|
|
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",("closing TCP/IP socket"));
|
|
VOID(shutdown(tmp_sock,2));
|
|
VOID(closesocket(tmp_sock));
|
|
}
|
|
tmp_sock=unix_sock;
|
|
if (tmp_sock != INVALID_SOCKET)
|
|
{
|
|
unix_sock=INVALID_SOCKET;
|
|
DBUG_PRINT("info",("closing Unix socket"));
|
|
VOID(shutdown(tmp_sock,2));
|
|
VOID(closesocket(tmp_sock));
|
|
VOID(unlink(mysql_unix_port));
|
|
}
|
|
DBUG_VOID_RETURN;
|
|
#endif
|
|
}
|
|
|
|
void kill_mysql(void)
|
|
{
|
|
DBUG_ENTER("kill_mysql");
|
|
|
|
#ifdef SIGNALS_DONT_BREAK_READ
|
|
close_server_sock(); /* force accept to wake up */
|
|
#endif
|
|
|
|
#if defined(__WIN__)
|
|
#if !defined(EMBEDDED_LIBRARY)
|
|
{
|
|
if (!SetEvent(hEventShutdown))
|
|
{
|
|
DBUG_PRINT("error",("Got error: %ld from SetEvent",GetLastError()));
|
|
}
|
|
/*
|
|
or:
|
|
HANDLE hEvent=OpenEvent(0, FALSE, "MySqlShutdown");
|
|
SetEvent(hEventShutdown);
|
|
CloseHandle(hEvent);
|
|
*/
|
|
}
|
|
#endif
|
|
#elif defined(OS2)
|
|
pthread_cond_signal( &eventShutdown); // post semaphore
|
|
#elif defined(HAVE_PTHREAD_KILL)
|
|
if (pthread_kill(signal_thread,SIGTERM)) /* End everything nicely */
|
|
{
|
|
DBUG_PRINT("error",("Got error %d from pthread_kill",errno)); /* purecov: inspected */
|
|
}
|
|
#elif !defined(SIGNALS_DONT_BREAK_READ)
|
|
kill(current_pid,SIGTERM);
|
|
#endif
|
|
DBUG_PRINT("quit",("After pthread_kill"));
|
|
shutdown_in_progress=1; // Safety if kill didn't work
|
|
#ifdef SIGNALS_DONT_BREAK_READ
|
|
if (!abort_loop)
|
|
{
|
|
pthread_t tmp;
|
|
abort_loop=1;
|
|
if (pthread_create(&tmp,&connection_attrib, kill_server_thread,
|
|
(void*) 0))
|
|
sql_print_error("Error: Can't create thread to kill server");
|
|
}
|
|
#endif
|
|
DBUG_VOID_RETURN;
|
|
}
|
|
|
|
|
|
/* Force server down. kill all connections and threads and exit */
|
|
|
|
#if defined(OS2)
|
|
extern "C" void kill_server(int sig_ptr)
|
|
#define RETURN_FROM_KILL_SERVER return
|
|
#elif !defined(__WIN__)
|
|
static void *kill_server(void *sig_ptr)
|
|
#define RETURN_FROM_KILL_SERVER return 0
|
|
#else
|
|
static void __cdecl kill_server(int sig_ptr)
|
|
#define RETURN_FROM_KILL_SERVER return
|
|
#endif
|
|
{
|
|
int sig=(int) (long) sig_ptr; // This is passed a int
|
|
DBUG_ENTER("kill_server");
|
|
|
|
// 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
|
|
signal(sig,SIG_IGN);
|
|
if (sig == MYSQL_KILL_SIGNAL || sig == 0)
|
|
sql_print_error(ER(ER_NORMAL_SHUTDOWN),my_progname);
|
|
else
|
|
sql_print_error(ER(ER_GOT_SIGNAL),my_progname,sig); /* purecov: inspected */
|
|
|
|
#if defined(USE_ONE_SIGNAL_HAND) && !defined(__WIN__) && !defined(OS2)
|
|
SHUTDOWN_THD;
|
|
my_thread_init(); // If this is a new thread
|
|
#endif
|
|
close_connections();
|
|
if (sig != MYSQL_KILL_SIGNAL && sig != 0)
|
|
unireg_abort(1); /* purecov: inspected */
|
|
else
|
|
unireg_end(0);
|
|
pthread_exit(0); /* purecov: deadcode */
|
|
RETURN_FROM_KILL_SERVER;
|
|
}
|
|
|
|
|
|
#ifdef USE_ONE_SIGNAL_HAND
|
|
static pthread_handler_decl(kill_server_thread,arg __attribute__((unused)))
|
|
{
|
|
SHUTDOWN_THD;
|
|
my_thread_init(); // Initialize new thread
|
|
kill_server(0);
|
|
my_thread_end(); // Normally never reached
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
#if defined(__amiga__)
|
|
#undef sigset
|
|
#define sigset signal
|
|
#endif
|
|
|
|
static sig_handler print_signal_warning(int sig)
|
|
{
|
|
if (opt_warnings)
|
|
sql_print_error("Warning: Got signal %d from thread %d",
|
|
sig,my_thread_id());
|
|
#ifdef DONT_REMEMBER_SIGNAL
|
|
sigset(sig,print_signal_warning); /* int. thread system calls */
|
|
#endif
|
|
#if !defined(__WIN__) && !defined(OS2)
|
|
if (sig == SIGALRM)
|
|
alarm(2); /* reschedule alarm */
|
|
#endif
|
|
}
|
|
|
|
|
|
void unireg_end(int signal_number __attribute__((unused)))
|
|
{
|
|
clean_up();
|
|
my_thread_end();
|
|
pthread_exit(0); // Exit is in main thread
|
|
}
|
|
|
|
|
|
void unireg_abort(int exit_code)
|
|
{
|
|
DBUG_ENTER("unireg_abort");
|
|
if (exit_code)
|
|
sql_print_error("Aborting\n");
|
|
clean_up(); /* purecov: inspected */
|
|
DBUG_PRINT("quit",("done with cleanup in unireg_abort"));
|
|
my_thread_end();
|
|
exit(exit_code); /* purecov: inspected */
|
|
}
|
|
|
|
|
|
void clean_up(bool print_message)
|
|
{
|
|
DBUG_PRINT("exit",("clean_up"));
|
|
if (cleanup_done++)
|
|
return; /* purecov: inspected */
|
|
if (use_slave_mask)
|
|
bitmap_free(&slave_error_mask);
|
|
acl_free(1);
|
|
grant_free();
|
|
query_cache_destroy();
|
|
table_cache_free();
|
|
hostname_cache_free();
|
|
item_user_lock_free();
|
|
lex_free(); /* Free some memory */
|
|
#ifdef HAVE_DLOPEN
|
|
if (!opt_noacl)
|
|
udf_free();
|
|
#endif
|
|
(void) ha_panic(HA_PANIC_CLOSE); /* close all tables and logs */
|
|
end_key_cache();
|
|
#ifdef USE_RAID
|
|
end_raid();
|
|
#endif
|
|
#ifdef HAVE_OPENSSL
|
|
my_free(opt_ssl_key,MYF(MY_ALLOW_ZERO_PTR));
|
|
my_free(opt_ssl_cert,MYF(MY_ALLOW_ZERO_PTR));
|
|
my_free(opt_ssl_ca,MYF(MY_ALLOW_ZERO_PTR));
|
|
my_free(opt_ssl_capath,MYF(MY_ALLOW_ZERO_PTR));
|
|
my_free(opt_ssl_cipher,MYF(MY_ALLOW_ZERO_PTR));
|
|
my_free((gptr) ssl_acceptor_fd, MYF(MY_ALLOW_ZERO_PTR));
|
|
opt_ssl_key=opt_ssl_cert=opt_ssl_ca=opt_ssl_capath=0;
|
|
#endif /* HAVE_OPENSSL */
|
|
|
|
free_defaults(defaults_argv);
|
|
my_free(charsets_list, MYF(MY_ALLOW_ZERO_PTR));
|
|
my_free(allocated_mysql_tmpdir,MYF(MY_ALLOW_ZERO_PTR));
|
|
my_free(slave_load_tmpdir,MYF(MY_ALLOW_ZERO_PTR));
|
|
x_free(opt_bin_logname);
|
|
x_free(opt_relay_logname);
|
|
bitmap_free(&temp_pool);
|
|
free_max_user_conn();
|
|
end_slave_list();
|
|
|
|
#if !defined(__WIN__) && !defined(EMBEDDED_LIBRARY)
|
|
if (!opt_bootstrap)
|
|
(void) my_delete(pidfile_name,MYF(0)); // This may not always exist
|
|
#endif
|
|
if (print_message && errmesg)
|
|
sql_print_error(ER(ER_SHUTDOWN_COMPLETE),my_progname);
|
|
x_free((gptr) my_errmsg[ERRMAPP]); /* Free messages */
|
|
DBUG_PRINT("quit", ("Error messages freed"));
|
|
/* Tell main we are ready */
|
|
(void) pthread_mutex_lock(&LOCK_thread_count);
|
|
DBUG_PRINT("quit", ("got thread count lock"));
|
|
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);
|
|
DBUG_PRINT("quit", ("done with cleanup"));
|
|
} /* clean_up */
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
** Init IP and UNIX socket
|
|
****************************************************************************/
|
|
|
|
static void set_ports()
|
|
{
|
|
char *env;
|
|
if (!mysql_port && !opt_disable_networking)
|
|
{ // Get port if not from commandline
|
|
struct servent *serv_ptr;
|
|
mysql_port = MYSQL_PORT;
|
|
if ((serv_ptr = getservbyname("mysql", "tcp")))
|
|
mysql_port = ntohs((u_short) serv_ptr->s_port); /* purecov: inspected */
|
|
if ((env = getenv("MYSQL_TCP_PORT")))
|
|
mysql_port = (uint) atoi(env); /* purecov: inspected */
|
|
}
|
|
if (!mysql_unix_port)
|
|
{
|
|
#ifdef __WIN__
|
|
mysql_unix_port = (char*) MYSQL_NAMEDPIPE;
|
|
#else
|
|
mysql_unix_port = (char*) MYSQL_UNIX_ADDR;
|
|
#endif
|
|
if ((env = getenv("MYSQL_UNIX_PORT")))
|
|
mysql_unix_port = env; /* purecov: inspected */
|
|
}
|
|
}
|
|
|
|
/* Change to run as another user if started with --user */
|
|
|
|
static void set_user(const char *user)
|
|
{
|
|
#if !defined(__WIN__) && !defined(OS2)
|
|
struct passwd *ent;
|
|
|
|
// don't bother if we aren't superuser
|
|
if (geteuid())
|
|
{
|
|
if (user)
|
|
fprintf(stderr,
|
|
"Warning: One can only use the --user switch if running as root\n");
|
|
return;
|
|
}
|
|
else if (!user)
|
|
{
|
|
if (!opt_bootstrap)
|
|
{
|
|
fprintf(stderr,"Fatal error: Please read \"Security\" section of the manual to find out how to run mysqld as root!\n");
|
|
unireg_abort(1);
|
|
}
|
|
return;
|
|
}
|
|
if (!strcmp(user,"root"))
|
|
return; // Avoid problem with dynamic libraries
|
|
|
|
uid_t uid;
|
|
if (!(ent = getpwnam(user)))
|
|
{
|
|
// allow a numeric uid to be used
|
|
const char *pos;
|
|
for (pos=user; my_isdigit(system_charset_info,*pos); pos++) ;
|
|
if (*pos) // Not numeric id
|
|
{
|
|
fprintf(stderr,"Fatal error: Can't change to run as user '%s' ; Please check that the user exists!\n",user);
|
|
unireg_abort(1);
|
|
}
|
|
uid=atoi(user); // Use numberic uid
|
|
}
|
|
else
|
|
{
|
|
#ifdef HAVE_INITGROUPS
|
|
initgroups((char*) user,ent->pw_gid);
|
|
#endif
|
|
if (setgid(ent->pw_gid) == -1)
|
|
{
|
|
sql_perror("setgid");
|
|
unireg_abort(1);
|
|
}
|
|
uid=ent->pw_uid;
|
|
}
|
|
|
|
if (setuid(uid) == -1)
|
|
{
|
|
sql_perror("setuid");
|
|
unireg_abort(1);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
/* Change root user if started with --chroot */
|
|
|
|
static void set_root(const char *path)
|
|
{
|
|
#if !defined(__WIN__) && !defined(__EMX__) && !defined(OS2)
|
|
if (chroot(path) == -1)
|
|
{
|
|
sql_perror("chroot");
|
|
unireg_abort(1);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
static void server_init(void)
|
|
{
|
|
struct sockaddr_in IPaddr;
|
|
#ifdef HAVE_SYS_UN_H
|
|
struct sockaddr_un UNIXaddr;
|
|
#endif
|
|
int arg=1;
|
|
DBUG_ENTER("server_init");
|
|
|
|
#ifdef __WIN__
|
|
if ( !opt_disable_networking )
|
|
{
|
|
WSADATA WsaData;
|
|
if (SOCKET_ERROR == WSAStartup (0x0101, &WsaData))
|
|
{
|
|
my_message(0,"WSAStartup Failed\n",MYF(0));
|
|
unireg_abort(1);
|
|
}
|
|
}
|
|
#endif /* __WIN__ */
|
|
|
|
set_ports();
|
|
|
|
if (mysql_port != 0 && !opt_disable_networking && !opt_bootstrap)
|
|
{
|
|
DBUG_PRINT("general",("IP Socket is %d",mysql_port));
|
|
ip_sock = socket(AF_INET, SOCK_STREAM, 0);
|
|
if (ip_sock == INVALID_SOCKET)
|
|
{
|
|
DBUG_PRINT("error",("Got error: %d from socket()",socket_errno));
|
|
sql_perror(ER(ER_IPSOCK_ERROR)); /* purecov: tested */
|
|
unireg_abort(1); /* purecov: tested */
|
|
}
|
|
bzero((char*) &IPaddr, sizeof(IPaddr));
|
|
IPaddr.sin_family = AF_INET;
|
|
IPaddr.sin_addr.s_addr = my_bind_addr;
|
|
IPaddr.sin_port = (unsigned short) htons((unsigned short) mysql_port);
|
|
(void) setsockopt(ip_sock,SOL_SOCKET,SO_REUSEADDR,(char*)&arg,sizeof(arg));
|
|
for(;;)
|
|
{
|
|
if (bind(ip_sock, my_reinterpret_cast(struct sockaddr *) (&IPaddr),
|
|
sizeof(IPaddr)) >= 0)
|
|
break;
|
|
DBUG_PRINT("error",("Got error: %d from bind",socket_errno));
|
|
sql_perror("Can't start server: Bind on TCP/IP port");/* Had a loop here */
|
|
sql_print_error("Do you already have another mysqld server running on port: %d ?",mysql_port);
|
|
unireg_abort(1);
|
|
}
|
|
if (listen(ip_sock,(int) back_log) < 0)
|
|
{
|
|
sql_print_error("Error: listen() on TCP/IP failed with error %d",
|
|
socket_errno);
|
|
unireg_abort(1);
|
|
}
|
|
}
|
|
|
|
if (mysqld_chroot)
|
|
set_root(mysqld_chroot);
|
|
set_user(mysqld_user); // Works also with mysqld_user==NULL
|
|
|
|
#ifdef __NT__
|
|
/* create named pipe */
|
|
if (Service.IsNT() && mysql_unix_port[0] && !opt_bootstrap &&
|
|
opt_enable_named_pipe)
|
|
{
|
|
sprintf( szPipeName, "\\\\.\\pipe\\%s", mysql_unix_port );
|
|
ZeroMemory( &saPipeSecurity, sizeof(saPipeSecurity) );
|
|
ZeroMemory( &sdPipeDescriptor, sizeof(sdPipeDescriptor) );
|
|
if ( !InitializeSecurityDescriptor(&sdPipeDescriptor,
|
|
SECURITY_DESCRIPTOR_REVISION) )
|
|
{
|
|
sql_perror("Can't start server : Initialize security descriptor");
|
|
unireg_abort(1);
|
|
}
|
|
if (!SetSecurityDescriptorDacl(&sdPipeDescriptor, TRUE, NULL, FALSE))
|
|
{
|
|
sql_perror("Can't start server : Set security descriptor");
|
|
unireg_abort(1);
|
|
}
|
|
saPipeSecurity.nLength = sizeof( SECURITY_ATTRIBUTES );
|
|
saPipeSecurity.lpSecurityDescriptor = &sdPipeDescriptor;
|
|
saPipeSecurity.bInheritHandle = FALSE;
|
|
if ((hPipe = CreateNamedPipe(szPipeName,
|
|
PIPE_ACCESS_DUPLEX,
|
|
PIPE_TYPE_BYTE |
|
|
PIPE_READMODE_BYTE |
|
|
PIPE_WAIT,
|
|
PIPE_UNLIMITED_INSTANCES,
|
|
(int) net_buffer_length,
|
|
(int) net_buffer_length,
|
|
NMPWAIT_USE_DEFAULT_WAIT,
|
|
&saPipeSecurity )) == INVALID_HANDLE_VALUE)
|
|
{
|
|
LPVOID lpMsgBuf;
|
|
int error=GetLastError();
|
|
FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
|
|
FORMAT_MESSAGE_FROM_SYSTEM,
|
|
NULL, error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
|
|
(LPTSTR) &lpMsgBuf, 0, NULL );
|
|
MessageBox( NULL, (LPTSTR) lpMsgBuf, "Error from CreateNamedPipe",
|
|
MB_OK|MB_ICONINFORMATION );
|
|
LocalFree( lpMsgBuf );
|
|
unireg_abort(1);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#if defined(HAVE_SYS_UN_H)
|
|
/*
|
|
** Create the UNIX socket
|
|
*/
|
|
if (mysql_unix_port[0] && !opt_bootstrap)
|
|
{
|
|
DBUG_PRINT("general",("UNIX Socket is %s",mysql_unix_port));
|
|
|
|
if ((unix_sock = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
|
|
{
|
|
sql_perror("Can't start server : UNIX Socket "); /* purecov: inspected */
|
|
unireg_abort(1); /* purecov: inspected */
|
|
}
|
|
bzero((char*) &UNIXaddr, sizeof(UNIXaddr));
|
|
UNIXaddr.sun_family = AF_UNIX;
|
|
strmov(UNIXaddr.sun_path, mysql_unix_port);
|
|
(void) unlink(mysql_unix_port);
|
|
(void) setsockopt(unix_sock,SOL_SOCKET,SO_REUSEADDR,(char*)&arg,
|
|
sizeof(arg));
|
|
umask(0);
|
|
if (bind(unix_sock, my_reinterpret_cast(struct sockaddr *) (&UNIXaddr),
|
|
sizeof(UNIXaddr)) < 0)
|
|
{
|
|
sql_perror("Can't start server : Bind on unix socket"); /* purecov: tested */
|
|
sql_print_error("Do you already have another mysqld server running on socket: %s ?",mysql_unix_port);
|
|
unireg_abort(1); /* purecov: tested */
|
|
}
|
|
umask(((~my_umask) & 0666));
|
|
#if defined(S_IFSOCK) && defined(SECURE_SOCKETS)
|
|
(void) chmod(mysql_unix_port,S_IFSOCK); /* Fix solaris 2.6 bug */
|
|
#endif
|
|
if (listen(unix_sock,(int) back_log) < 0)
|
|
sql_print_error("Warning: listen() on Unix socket failed with error %d",
|
|
socket_errno);
|
|
}
|
|
#endif
|
|
DBUG_PRINT("info",("server started"));
|
|
DBUG_VOID_RETURN;
|
|
}
|
|
|
|
|
|
void yyerror(const char *s)
|
|
{
|
|
NET *net=my_pthread_getspecific_ptr(NET*,THR_NET);
|
|
char *yytext=(char*) current_lex->tok_start;
|
|
if (!strcmp(s,"parse error"))
|
|
s=ER(ER_SYNTAX_ERROR);
|
|
net_printf(net,ER_PARSE_ERROR, s, yytext ? (char*) yytext : "",
|
|
current_lex->yylineno);
|
|
}
|
|
|
|
|
|
void close_connection(NET *net,uint errcode,bool lock)
|
|
{
|
|
st_vio* vio;
|
|
DBUG_ENTER("close_connection");
|
|
DBUG_PRINT("enter",("fd: %s error: '%s'",
|
|
net->vio? vio_description(net->vio):"(not connected)",
|
|
errcode ? ER(errcode) : ""));
|
|
if (lock)
|
|
(void) pthread_mutex_lock(&LOCK_thread_count);
|
|
if ((vio=net->vio) != 0)
|
|
{
|
|
if (errcode)
|
|
send_error(net,errcode,ER(errcode)); /* purecov: inspected */
|
|
vio_close(vio); /* vio is freed in delete thd */
|
|
}
|
|
if (lock)
|
|
(void) pthread_mutex_unlock(&LOCK_thread_count);
|
|
DBUG_VOID_RETURN;
|
|
}
|
|
|
|
/* Called when a thread is aborted */
|
|
/* ARGSUSED */
|
|
|
|
sig_handler end_thread_signal(int sig __attribute__((unused)))
|
|
{
|
|
THD *thd=current_thd;
|
|
DBUG_ENTER("end_thread_signal");
|
|
if (thd)
|
|
end_thread(thd,0);
|
|
DBUG_VOID_RETURN; /* purecov: deadcode */
|
|
}
|
|
|
|
|
|
void end_thread(THD *thd, bool put_in_cache)
|
|
{
|
|
DBUG_ENTER("end_thread");
|
|
thd->cleanup();
|
|
(void) pthread_mutex_lock(&LOCK_thread_count);
|
|
thread_count--;
|
|
delete thd;
|
|
|
|
if (put_in_cache && cached_thread_count < thread_cache_size &&
|
|
! abort_loop && !kill_cached_threads)
|
|
{
|
|
/* Don't kill the thread, just put it in cache for reuse */
|
|
DBUG_PRINT("info", ("Adding thread to cache"))
|
|
cached_thread_count++;
|
|
while (!abort_loop && ! wake_thread && ! kill_cached_threads)
|
|
(void) pthread_cond_wait(&COND_thread_cache, &LOCK_thread_count);
|
|
cached_thread_count--;
|
|
if (kill_cached_threads)
|
|
pthread_cond_signal(&COND_flush_thread_cache);
|
|
if (wake_thread)
|
|
{
|
|
wake_thread--;
|
|
thd=thread_cache.get();
|
|
thd->real_id=pthread_self();
|
|
(void) thd->store_globals();
|
|
threads.append(thd);
|
|
pthread_mutex_unlock(&LOCK_thread_count);
|
|
DBUG_VOID_RETURN;
|
|
}
|
|
}
|
|
|
|
DBUG_PRINT("info", ("sending a broadcast"))
|
|
|
|
/* Tell main we are ready */
|
|
// TODO: explain why we broadcast outside of the lock or
|
|
// fix the bug - Sasha
|
|
(void) pthread_mutex_unlock(&LOCK_thread_count);
|
|
(void) pthread_cond_broadcast(&COND_thread_count);
|
|
DBUG_PRINT("info", ("unlocked thread_count mutex"))
|
|
#ifdef ONE_THREAD
|
|
if (!(test_flags & TEST_NO_THREADS)) // For debugging under Linux
|
|
#endif
|
|
{
|
|
my_thread_end();
|
|
pthread_exit(0);
|
|
}
|
|
DBUG_VOID_RETURN;
|
|
}
|
|
|
|
|
|
/* Start a cached thread. LOCK_thread_count is locked on entry */
|
|
|
|
static void start_cached_thread(THD *thd)
|
|
{
|
|
thread_cache.append(thd);
|
|
wake_thread++;
|
|
thread_count++;
|
|
pthread_cond_signal(&COND_thread_cache);
|
|
}
|
|
|
|
|
|
void flush_thread_cache()
|
|
{
|
|
(void) pthread_mutex_lock(&LOCK_thread_count);
|
|
kill_cached_threads++;
|
|
while (cached_thread_count)
|
|
{
|
|
pthread_cond_broadcast(&COND_thread_cache);
|
|
pthread_cond_wait(&COND_flush_thread_cache,&LOCK_thread_count);
|
|
}
|
|
kill_cached_threads--;
|
|
(void) pthread_mutex_unlock(&LOCK_thread_count);
|
|
}
|
|
|
|
|
|
/*
|
|
** Aborts a thread nicely. Commes here on SIGPIPE
|
|
** TODO: One should have to fix that thr_alarm know about this
|
|
** thread too
|
|
*/
|
|
|
|
#ifdef THREAD_SPECIFIC_SIGPIPE
|
|
static sig_handler abort_thread(int sig __attribute__((unused)))
|
|
{
|
|
THD *thd=current_thd;
|
|
DBUG_ENTER("abort_thread");
|
|
if (thd)
|
|
thd->killed=1;
|
|
DBUG_VOID_RETURN;
|
|
}
|
|
#endif
|
|
|
|
/******************************************************************************
|
|
** Setup a signal thread with handles all signals
|
|
** Because linux doesn't support scemas use a mutex to check that
|
|
** the signal thread is ready before continuing
|
|
******************************************************************************/
|
|
|
|
#if defined(__WIN__) || defined(OS2)
|
|
static void init_signals(void)
|
|
{
|
|
int signals[] = {SIGINT,SIGILL,SIGFPE,SIGSEGV,SIGTERM,SIGABRT } ;
|
|
for (uint i=0 ; i < sizeof(signals)/sizeof(int) ; i++)
|
|
signal( signals[i], kill_server) ;
|
|
#if defined(__WIN__)
|
|
signal(SIGBREAK,SIG_IGN); //ignore SIGBREAK for NT
|
|
#else
|
|
signal(SIGBREAK, kill_server);
|
|
#endif
|
|
}
|
|
|
|
static void start_signal_handler(void)
|
|
{
|
|
}
|
|
|
|
#elif defined(__EMX__)
|
|
static void sig_reload(int signo)
|
|
{
|
|
reload_acl_and_cache((THD*) 0,REFRESH_LOG, (TABLE_LIST*) 0); // Flush everything
|
|
signal(signo, SIG_ACK);
|
|
}
|
|
|
|
static void sig_kill(int signo)
|
|
{
|
|
if (!abort_loop)
|
|
{
|
|
abort_loop=1; // mark abort for threads
|
|
kill_server((void*) signo);
|
|
}
|
|
signal(signo, SIG_ACK);
|
|
}
|
|
|
|
static void init_signals(void)
|
|
{
|
|
signal(SIGQUIT, sig_kill);
|
|
signal(SIGKILL, sig_kill);
|
|
signal(SIGTERM, sig_kill);
|
|
signal(SIGINT, sig_kill);
|
|
signal(SIGHUP, sig_reload); // Flush everything
|
|
signal(SIGALRM, SIG_IGN);
|
|
signal(SIGBREAK,SIG_IGN);
|
|
signal_thread = pthread_self();
|
|
SIGNAL_THD;
|
|
}
|
|
|
|
static void start_signal_handler(void)
|
|
{
|
|
}
|
|
|
|
#else /* if ! __WIN__ && ! __EMX__ */
|
|
|
|
#ifdef HAVE_LINUXTHREADS
|
|
#define UNSAFE_DEFAULT_LINUX_THREADS 200
|
|
#endif
|
|
|
|
static sig_handler handle_segfault(int sig)
|
|
{
|
|
THD *thd=current_thd;
|
|
/*
|
|
Strictly speaking, one needs a mutex here
|
|
but since we have got SIGSEGV already, things are a mess
|
|
so not having the mutex is not as bad as possibly using a buggy
|
|
mutex - so we keep things simple
|
|
*/
|
|
if (segfaulted)
|
|
{
|
|
fprintf(stderr, "Fatal signal %d while backtracing\n", sig);
|
|
exit(1);
|
|
}
|
|
|
|
segfaulted = 1;
|
|
fprintf(stderr,"\
|
|
mysqld got signal %d;\n\
|
|
This could be because you hit a bug. It is also possible that this binary\n\
|
|
or one of the libraries it was linked against is corrupt, improperly built,\n\
|
|
or misconfigured. This error can also be caused by malfunctioning hardware.\n",
|
|
sig);
|
|
fprintf(stderr, "\
|
|
We will try our best to scrape up some info that will hopefully help diagnose\n\
|
|
the problem, but since we have already crashed, something is definitely wrong\n\
|
|
and this may fail.\n\n");
|
|
fprintf(stderr, "key_buffer_size=%ld\n", keybuff_size);
|
|
fprintf(stderr, "record_buffer=%ld\n", my_default_record_cache_size);
|
|
fprintf(stderr, "sort_buffer=%ld\n", sortbuff_size);
|
|
fprintf(stderr, "max_used_connections=%ld\n", max_used_connections);
|
|
fprintf(stderr, "max_connections=%ld\n", max_connections);
|
|
fprintf(stderr, "threads_connected=%d\n", thread_count);
|
|
fprintf(stderr, "It is possible that mysqld could use up to \n\
|
|
key_buffer_size + (record_buffer + sort_buffer)*max_connections = %ld K\n\
|
|
bytes of memory\n", (keybuff_size + (my_default_record_cache_size +
|
|
sortbuff_size) * max_connections)/ 1024);
|
|
fprintf(stderr, "Hope that's ok; if not, decrease some variables in the equation.\n\n");
|
|
|
|
#if defined(HAVE_LINUXTHREADS)
|
|
if (sizeof(char*) == 4 && thread_count > UNSAFE_DEFAULT_LINUX_THREADS)
|
|
{
|
|
fprintf(stderr, "\
|
|
You seem to be running 32-bit Linux and have %d concurrent connections.\n\
|
|
If you have not changed STACK_SIZE in LinuxThreads and built the binary \n\
|
|
yourself, LinuxThreads is quite likely to steal a part of the global heap for\n\
|
|
the thread stack. Please read http://www.mysql.com/doc/L/i/Linux.html\n\n",
|
|
thread_count);
|
|
}
|
|
#endif /* HAVE_LINUXTHREADS */
|
|
|
|
#ifdef HAVE_STACKTRACE
|
|
if(!(test_flags & TEST_NO_STACKTRACE))
|
|
{
|
|
fprintf(stderr,"thd=%p\n",thd);
|
|
print_stacktrace(thd ? (gptr) thd->thread_stack : (gptr) 0,
|
|
thread_stack);
|
|
}
|
|
if (thd)
|
|
{
|
|
fprintf(stderr, "Trying to get some variables.\n\
|
|
Some pointers may be invalid and cause the dump to abort...\n");
|
|
safe_print_str("thd->query", thd->query, 1024);
|
|
fprintf(stderr, "thd->thread_id=%ld\n", thd->thread_id);
|
|
fprintf(stderr, "\n\
|
|
Successfully dumped variables, if you ran with --log, take a look at the\n\
|
|
details of what thread %ld did to cause the crash. In some cases of really\n\
|
|
bad corruption, the values shown above may be invalid.\n\n",
|
|
thd->thread_id);
|
|
}
|
|
fprintf(stderr, "\
|
|
The manual page at http://www.mysql.com/doc/C/r/Crashing.html contains\n\
|
|
information that should help you find out what is causing the crash.\n");
|
|
fflush(stderr);
|
|
#endif /* HAVE_STACKTRACE */
|
|
|
|
if (test_flags & TEST_CORE_ON_SIGNAL)
|
|
write_core(sig);
|
|
exit(1);
|
|
}
|
|
|
|
#ifndef SA_RESETHAND
|
|
#define SA_RESETHAND 0
|
|
#endif
|
|
#ifndef SA_NODEFER
|
|
#define SA_NODEFER 0
|
|
#endif
|
|
|
|
static void init_signals(void)
|
|
{
|
|
sigset_t set;
|
|
DBUG_ENTER("init_signals");
|
|
|
|
sigset(THR_KILL_SIGNAL,end_thread_signal);
|
|
sigset(THR_SERVER_ALARM,print_signal_warning); // Should never be called!
|
|
|
|
if (!(test_flags & TEST_NO_STACKTRACE) || (test_flags & TEST_CORE_ON_SIGNAL))
|
|
{
|
|
struct sigaction sa;
|
|
sa.sa_flags = SA_RESETHAND | SA_NODEFER;
|
|
sigemptyset(&sa.sa_mask);
|
|
sigprocmask(SIG_SETMASK,&sa.sa_mask,NULL);
|
|
|
|
init_stacktrace();
|
|
#if defined(__amiga__)
|
|
sa.sa_handler=(void(*)())handle_segfault;
|
|
#else
|
|
sa.sa_handler=handle_segfault;
|
|
#endif
|
|
sigaction(SIGSEGV, &sa, NULL);
|
|
#ifdef SIGBUS
|
|
sigaction(SIGBUS, &sa, NULL);
|
|
#endif
|
|
sigaction(SIGILL, &sa, NULL);
|
|
sigaction(SIGFPE, &sa, NULL);
|
|
}
|
|
(void) sigemptyset(&set);
|
|
#ifdef THREAD_SPECIFIC_SIGPIPE
|
|
sigset(SIGPIPE,abort_thread);
|
|
sigaddset(&set,SIGPIPE);
|
|
#else
|
|
(void) signal(SIGPIPE,SIG_IGN); // Can't know which thread
|
|
sigaddset(&set,SIGPIPE);
|
|
#endif
|
|
sigaddset(&set,SIGINT);
|
|
sigaddset(&set,SIGQUIT);
|
|
sigaddset(&set,SIGTERM);
|
|
sigaddset(&set,SIGHUP);
|
|
signal(SIGTERM,SIG_DFL); // If it's blocked by parent
|
|
signal(SIGHUP,SIG_DFL); // If it's blocked by parent
|
|
#ifdef SIGTSTP
|
|
sigaddset(&set,SIGTSTP);
|
|
#endif
|
|
sigaddset(&set,THR_SERVER_ALARM);
|
|
sigdelset(&set,THR_KILL_SIGNAL); // May be SIGINT
|
|
sigdelset(&set,THR_CLIENT_ALARM); // For alarms
|
|
(void) pthread_sigmask(SIG_SETMASK,&set,NULL);
|
|
DBUG_VOID_RETURN;
|
|
}
|
|
|
|
|
|
static void start_signal_handler(void)
|
|
{
|
|
int error;
|
|
pthread_attr_t thr_attr;
|
|
DBUG_ENTER("start_signal_handler");
|
|
|
|
(void) pthread_attr_init(&thr_attr);
|
|
#if !defined(HAVE_DEC_3_2_THREADS)
|
|
pthread_attr_setscope(&thr_attr,PTHREAD_SCOPE_SYSTEM);
|
|
(void) pthread_attr_setdetachstate(&thr_attr,PTHREAD_CREATE_DETACHED);
|
|
if (!(opt_specialflag & SPECIAL_NO_PRIOR))
|
|
my_pthread_attr_setprio(&thr_attr,INTERRUPT_PRIOR);
|
|
pthread_attr_setstacksize(&thr_attr,32768);
|
|
#endif
|
|
|
|
(void) pthread_mutex_lock(&LOCK_thread_count);
|
|
if ((error=pthread_create(&signal_thread,&thr_attr,signal_hand,0)))
|
|
{
|
|
sql_print_error("Can't create interrupt-thread (error %d, errno: %d)",
|
|
error,errno);
|
|
exit(1);
|
|
}
|
|
(void) pthread_cond_wait(&COND_thread_count,&LOCK_thread_count);
|
|
pthread_mutex_unlock(&LOCK_thread_count);
|
|
|
|
(void) pthread_attr_destroy(&thr_attr);
|
|
DBUG_VOID_RETURN;
|
|
}
|
|
|
|
|
|
/*
|
|
** This threads handles all signals and alarms
|
|
*/
|
|
|
|
/* ARGSUSED */
|
|
static void *signal_hand(void *arg __attribute__((unused)))
|
|
{
|
|
sigset_t set;
|
|
int sig;
|
|
my_thread_init(); // Init new thread
|
|
DBUG_ENTER("signal_hand");
|
|
SIGNAL_THD;
|
|
/* Setup alarm handler */
|
|
init_thr_alarm(max_connections+max_insert_delayed_threads);
|
|
#if SIGINT != THR_KILL_SIGNAL
|
|
(void) sigemptyset(&set); // Setup up SIGINT for debug
|
|
(void) sigaddset(&set,SIGINT); // For debugging
|
|
(void) pthread_sigmask(SIG_UNBLOCK,&set,NULL);
|
|
#endif
|
|
(void) sigemptyset(&set); // Setup up SIGINT for debug
|
|
#ifdef USE_ONE_SIGNAL_HAND
|
|
(void) sigaddset(&set,THR_SERVER_ALARM); // For alarms
|
|
#endif
|
|
(void) sigaddset(&set,SIGQUIT);
|
|
(void) sigaddset(&set,SIGTERM);
|
|
#if THR_CLIENT_ALARM != SIGHUP
|
|
(void) sigaddset(&set,SIGHUP);
|
|
#endif
|
|
(void) sigaddset(&set,SIGTSTP);
|
|
|
|
/* Save pid to this process (or thread on Linux) */
|
|
if (!opt_bootstrap)
|
|
{
|
|
File pidFile;
|
|
if ((pidFile = my_create(pidfile_name,0664, O_WRONLY, MYF(MY_WME))) >= 0)
|
|
{
|
|
char buff[21];
|
|
sprintf(buff,"%lu",(ulong) getpid());
|
|
(void) my_write(pidFile, buff,strlen(buff),MYF(MY_WME));
|
|
(void) my_close(pidFile,MYF(0));
|
|
}
|
|
}
|
|
#ifdef HAVE_STACK_TRACE_ON_SEGV
|
|
if (opt_do_pstack)
|
|
{
|
|
sprintf(pstack_file_name,"mysqld-%lu-%%d-%%d.backtrace", (ulong)getpid());
|
|
pstack_install_segv_action(pstack_file_name);
|
|
}
|
|
#endif /* HAVE_STACK_TRACE_ON_SEGV */
|
|
|
|
// signal to start_signal_handler that we are ready
|
|
(void) pthread_mutex_lock(&LOCK_thread_count);
|
|
(void) pthread_cond_signal(&COND_thread_count);
|
|
(void) pthread_mutex_unlock(&LOCK_thread_count);
|
|
|
|
for (;;)
|
|
{
|
|
int error; // Used when debugging
|
|
if (shutdown_in_progress && !abort_loop)
|
|
{
|
|
sig=SIGTERM;
|
|
error=0;
|
|
}
|
|
else
|
|
while ((error=my_sigwait(&set,&sig)) == EINTR) ;
|
|
if (cleanup_done)
|
|
{
|
|
my_thread_end();
|
|
pthread_exit(0); // Safety
|
|
}
|
|
switch (sig) {
|
|
case SIGTERM:
|
|
case SIGQUIT:
|
|
case SIGKILL:
|
|
#ifdef EXTRA_DEBUG
|
|
sql_print_error("Got signal %d to shutdown mysqld",sig);
|
|
#endif
|
|
DBUG_PRINT("info",("Got signal: %d abort_loop: %d",sig,abort_loop));
|
|
if (!abort_loop)
|
|
{
|
|
abort_loop=1; // mark abort for threads
|
|
#ifdef USE_ONE_SIGNAL_HAND
|
|
pthread_t tmp;
|
|
if (!(opt_specialflag & SPECIAL_NO_PRIOR))
|
|
my_pthread_attr_setprio(&connection_attrib,INTERRUPT_PRIOR);
|
|
if (pthread_create(&tmp,&connection_attrib, kill_server_thread,
|
|
(void*) sig))
|
|
sql_print_error("Error: Can't create thread to kill server");
|
|
#else
|
|
kill_server((void*) sig); // MIT THREAD has a alarm thread
|
|
#endif
|
|
}
|
|
break;
|
|
case SIGHUP:
|
|
reload_acl_and_cache((THD*) 0,
|
|
(REFRESH_LOG | REFRESH_TABLES | REFRESH_FAST |
|
|
REFRESH_STATUS | REFRESH_GRANT | REFRESH_THREADS |
|
|
REFRESH_HOSTS),
|
|
(TABLE_LIST*) 0); // Flush logs
|
|
mysql_print_status((THD*) 0); // Send debug some info
|
|
break;
|
|
#ifdef USE_ONE_SIGNAL_HAND
|
|
case THR_SERVER_ALARM:
|
|
process_alarm(sig); // Trigger alarms.
|
|
break;
|
|
#endif
|
|
default:
|
|
#ifdef EXTRA_DEBUG
|
|
sql_print_error("Warning: Got signal: %d, error: %d",sig,error); /* purecov: tested */
|
|
#endif
|
|
break; /* purecov: tested */
|
|
}
|
|
}
|
|
return(0); /* purecov: deadcode */
|
|
}
|
|
|
|
#endif /* __WIN__*/
|
|
|
|
|
|
/*
|
|
** All global error messages are sent here where the first one is stored for
|
|
** the client
|
|
*/
|
|
|
|
|
|
/* ARGSUSED */
|
|
static int my_message_sql(uint error, const char *str,
|
|
myf MyFlags __attribute__((unused)))
|
|
{
|
|
NET *net;
|
|
DBUG_ENTER("my_message_sql");
|
|
DBUG_PRINT("error",("Message: '%s'",str));
|
|
if ((net=my_pthread_getspecific_ptr(NET*,THR_NET)))
|
|
{
|
|
if (!net->last_error[0]) // Return only first message
|
|
{
|
|
strmake(net->last_error,str,sizeof(net->last_error)-1);
|
|
net->last_errno=error ? error : ER_UNKNOWN_ERROR;
|
|
}
|
|
}
|
|
else
|
|
sql_print_error("%s: %s",my_progname,str); /* purecov: inspected */
|
|
DBUG_RETURN(0);
|
|
}
|
|
|
|
#ifdef __WIN__
|
|
|
|
struct utsname
|
|
{
|
|
char nodename[FN_REFLEN];
|
|
};
|
|
|
|
int uname(struct utsname *a)
|
|
{
|
|
return -1;
|
|
}
|
|
#endif
|
|
|
|
|
|
#ifdef __WIN__
|
|
pthread_handler_decl(handle_shutdown,arg)
|
|
{
|
|
MSG msg;
|
|
SHUTDOWN_THD;
|
|
my_thread_init();
|
|
|
|
/* this call should create the message queue for this thread */
|
|
PeekMessage(&msg, NULL, 1, 65534,PM_NOREMOVE);
|
|
#if !defined(EMBEDDED_LIBRARY)
|
|
if (WaitForSingleObject(hEventShutdown,INFINITE)==WAIT_OBJECT_0)
|
|
#endif
|
|
kill_server(MYSQL_KILL_SIGNAL);
|
|
return 0;
|
|
}
|
|
|
|
int __stdcall handle_kill(ulong ctrl_type)
|
|
{
|
|
if (ctrl_type == CTRL_CLOSE_EVENT ||
|
|
ctrl_type == CTRL_SHUTDOWN_EVENT)
|
|
{
|
|
kill_server(MYSQL_KILL_SIGNAL);
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
#endif
|
|
|
|
#ifdef OS2
|
|
pthread_handler_decl(handle_shutdown,arg)
|
|
{
|
|
SHUTDOWN_THD;
|
|
my_thread_init();
|
|
|
|
// wait semaphore
|
|
pthread_cond_wait( &eventShutdown, NULL);
|
|
|
|
// close semaphore and kill server
|
|
pthread_cond_destroy( &eventShutdown);
|
|
|
|
/*
|
|
Exit main loop on main thread, so kill will be done from
|
|
main thread (this is thread 2)
|
|
*/
|
|
abort_loop = 1;
|
|
|
|
// unblock select()
|
|
so_cancel( ip_sock);
|
|
so_cancel( unix_sock);
|
|
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
const char *load_default_groups[]= { "mysqld","server",0 };
|
|
|
|
#ifdef HAVE_LIBWRAP
|
|
char *libwrapName=NULL;
|
|
#endif
|
|
|
|
void open_log(MYSQL_LOG *log, const char *hostname,
|
|
const char *opt_name, const char *extension,
|
|
enum_log_type type, bool read_append,
|
|
bool no_auto_events)
|
|
{
|
|
char tmp[FN_REFLEN];
|
|
if (!opt_name || !opt_name[0])
|
|
{
|
|
/*
|
|
TODO: The following should be using fn_format(); We just need to
|
|
first change fn_format() to cut the file name if it's too long.
|
|
*/
|
|
strmake(tmp,hostname,FN_REFLEN-5);
|
|
strmov(strcend(tmp,'.'),extension);
|
|
opt_name=tmp;
|
|
}
|
|
// get rid of extention if the log is binary to avoid problems
|
|
if (type == LOG_BIN)
|
|
{
|
|
char *p = fn_ext(opt_name);
|
|
if (p)
|
|
{
|
|
uint length=(uint) (p-opt_name);
|
|
strmake(tmp,opt_name,min(length,FN_REFLEN));
|
|
opt_name=tmp;
|
|
}
|
|
}
|
|
log->open(opt_name,type,0,(read_append) ? SEQ_READ_APPEND : WRITE_CACHE,
|
|
no_auto_events);
|
|
}
|
|
|
|
|
|
|
|
#ifdef __WIN__
|
|
int win_main(int argc, char **argv)
|
|
#else
|
|
int main(int argc, char **argv)
|
|
#endif
|
|
{
|
|
DEBUGGER_OFF;
|
|
|
|
my_umask=0660; // Default umask for new files
|
|
my_umask_dir=0700; // Default umask for new directories
|
|
MAIN_THD;
|
|
/* initialize signal_th and shutdown_th to main_th for default value
|
|
as we need to initialize them to something safe. They are used
|
|
when compiled with safemalloc
|
|
*/
|
|
SIGNAL_THD;
|
|
SHUTDOWN_THD;
|
|
MY_INIT(argv[0]); // init my_sys library & pthreads
|
|
tzset(); // Set tzname
|
|
|
|
start_time=time((time_t*) 0);
|
|
#ifdef OS2
|
|
{
|
|
// fix timezone for daylight saving
|
|
struct tm *ts = localtime(&start_time);
|
|
if (ts->tm_isdst > 0)
|
|
_timezone -= 3600;
|
|
}
|
|
#endif
|
|
#ifdef HAVE_TZNAME
|
|
#if defined(HAVE_LOCALTIME_R) && defined(_REENTRANT)
|
|
{
|
|
struct tm tm_tmp;
|
|
localtime_r(&start_time,&tm_tmp);
|
|
strmov(time_zone,tzname[tm_tmp.tm_isdst != 0 ? 1 : 0]);
|
|
}
|
|
#else
|
|
{
|
|
struct tm *start_tm;
|
|
start_tm=localtime(&start_time);
|
|
strmov(time_zone,tzname[start_tm->tm_isdst != 0 ? 1 : 0]);
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
if (gethostname(glob_hostname,sizeof(glob_hostname)-4) < 0)
|
|
strmov(glob_hostname,"mysql");
|
|
strmake(pidfile_name, glob_hostname, sizeof(pidfile_name)-5);
|
|
strmov(strcend(pidfile_name,'.'),".pid"); // Add extension
|
|
#ifndef DBUG_OFF
|
|
strxmov(strend(server_version),MYSQL_SERVER_SUFFIX,"-debug",NullS);
|
|
#else
|
|
strmov(strend(server_version),MYSQL_SERVER_SUFFIX);
|
|
#endif
|
|
#ifdef _CUSTOMSTARTUPCONFIG_
|
|
if (_cust_check_startup())
|
|
{
|
|
/* _cust_check_startup will report startup failure error */
|
|
exit( 1 );
|
|
}
|
|
#endif
|
|
load_defaults("my",load_default_groups,&argc,&argv);
|
|
defaults_argv=argv;
|
|
mysql_tmpdir=getenv("TMPDIR"); /* Use this if possible */
|
|
#if defined( __WIN__) || defined(OS2)
|
|
if (!mysql_tmpdir)
|
|
mysql_tmpdir=getenv("TEMP");
|
|
if (!mysql_tmpdir)
|
|
mysql_tmpdir=getenv("TMP");
|
|
#endif
|
|
if (!mysql_tmpdir || !mysql_tmpdir[0])
|
|
mysql_tmpdir=(char*) P_tmpdir; /* purecov: inspected */
|
|
|
|
set_options();
|
|
get_options(argc,argv);
|
|
if (opt_log || opt_update_log || opt_slow_log || opt_bin_log)
|
|
strcat(server_version,"-log");
|
|
DBUG_PRINT("info",("%s Ver %s for %s on %s\n",my_progname,
|
|
server_version, SYSTEM_TYPE,MACHINE_TYPE));
|
|
|
|
/* These must be set early */
|
|
|
|
(void) pthread_mutex_init(&LOCK_mysql_create_db,MY_MUTEX_INIT_SLOW);
|
|
(void) pthread_mutex_init(&LOCK_Acl,MY_MUTEX_INIT_SLOW);
|
|
(void) pthread_mutex_init(&LOCK_grant,MY_MUTEX_INIT_FAST);
|
|
(void) pthread_mutex_init(&LOCK_open,MY_MUTEX_INIT_FAST);
|
|
(void) pthread_mutex_init(&LOCK_thread_count,MY_MUTEX_INIT_FAST);
|
|
(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_delayed_insert,MY_MUTEX_INIT_FAST);
|
|
(void) pthread_mutex_init(&LOCK_delayed_status,MY_MUTEX_INIT_FAST);
|
|
(void) pthread_mutex_init(&LOCK_delayed_create,MY_MUTEX_INIT_SLOW);
|
|
(void) pthread_mutex_init(&LOCK_manager,MY_MUTEX_INIT_FAST);
|
|
(void) pthread_mutex_init(&LOCK_crypt,MY_MUTEX_INIT_FAST);
|
|
(void) pthread_mutex_init(&LOCK_bytes_sent,MY_MUTEX_INIT_FAST);
|
|
(void) pthread_mutex_init(&LOCK_bytes_received,MY_MUTEX_INIT_FAST);
|
|
(void) pthread_mutex_init(&LOCK_timezone,MY_MUTEX_INIT_FAST);
|
|
(void) pthread_mutex_init(&LOCK_server_id, MY_MUTEX_INIT_FAST);
|
|
(void) pthread_mutex_init(&LOCK_user_conn, MY_MUTEX_INIT_FAST);
|
|
(void) pthread_mutex_init(&LOCK_rpl_status, MY_MUTEX_INIT_FAST);
|
|
(void) pthread_mutex_init(&LOCK_active_mi, MY_MUTEX_INIT_FAST);
|
|
(void) pthread_cond_init(&COND_thread_count,NULL);
|
|
(void) pthread_cond_init(&COND_refresh,NULL);
|
|
(void) pthread_cond_init(&COND_thread_cache,NULL);
|
|
(void) pthread_cond_init(&COND_flush_thread_cache,NULL);
|
|
(void) pthread_cond_init(&COND_manager,NULL);
|
|
(void) pthread_cond_init(&COND_rpl_status, NULL);
|
|
init_signals();
|
|
|
|
if (set_default_charset_by_name(default_charset, MYF(MY_WME)))
|
|
exit( 1 );
|
|
charsets_list = list_charsets(MYF(MY_COMPILED_SETS|MY_CONFIG_SETS));
|
|
|
|
#ifdef HAVE_OPENSSL
|
|
if (opt_use_ssl)
|
|
{
|
|
ssl_acceptor_fd = new_VioSSLAcceptorFd(opt_ssl_key, opt_ssl_cert,
|
|
opt_ssl_ca, opt_ssl_capath,
|
|
opt_ssl_cipher);
|
|
DBUG_PRINT("info",("ssl_acceptor_fd: %p",ssl_acceptor_fd));
|
|
if (!ssl_acceptor_fd)
|
|
opt_use_ssl = 0;
|
|
/* having ssl_acceptor_fd != 0 signals the use of SSL */
|
|
}
|
|
if (des_key_file)
|
|
load_des_key_file(des_key_file);
|
|
#endif /* HAVE_OPENSSL */
|
|
|
|
#ifdef HAVE_LIBWRAP
|
|
libwrapName= my_progname+dirname_length(my_progname);
|
|
openlog(libwrapName, LOG_PID, LOG_AUTH);
|
|
#endif
|
|
|
|
if (!(opt_specialflag & SPECIAL_NO_PRIOR))
|
|
my_pthread_setprio(pthread_self(),CONNECT_PRIOR);
|
|
/* Parameter for threads created for connections */
|
|
(void) pthread_attr_init(&connection_attrib);
|
|
(void) pthread_attr_setdetachstate(&connection_attrib,
|
|
PTHREAD_CREATE_DETACHED);
|
|
pthread_attr_setstacksize(&connection_attrib,thread_stack);
|
|
|
|
if (!(opt_specialflag & SPECIAL_NO_PRIOR))
|
|
my_pthread_attr_setprio(&connection_attrib,WAIT_PRIOR);
|
|
pthread_attr_setscope(&connection_attrib, PTHREAD_SCOPE_SYSTEM);
|
|
|
|
#if defined( SET_RLIMIT_NOFILE) || defined( OS2)
|
|
/* connections and databases needs lots of files */
|
|
{
|
|
uint wanted_files=10+(uint) max(max_connections*5,
|
|
max_connections+table_cache_size*2);
|
|
set_if_bigger(wanted_files, open_files_limit);
|
|
// Note that some system returns 0 if we succeed here:
|
|
uint files=set_maximum_open_files(wanted_files);
|
|
if (files && files < wanted_files && ! open_files_limit)
|
|
{
|
|
max_connections= (ulong) min((files-10),max_connections);
|
|
table_cache_size= (ulong) max((files-10-max_connections)/2,64);
|
|
DBUG_PRINT("warning",
|
|
("Changed limits: max_connections: %ld table_cache: %ld",
|
|
max_connections,table_cache_size));
|
|
sql_print_error("Warning: Changed limits: max_connections: %ld table_cache: %ld",max_connections,table_cache_size);
|
|
}
|
|
}
|
|
#endif
|
|
unireg_init(opt_specialflag); /* Set up extern variabels */
|
|
init_errmessage(); /* Read error messages from file */
|
|
lex_init();
|
|
item_init();
|
|
mysys_uses_curses=0;
|
|
#ifdef USE_REGEX
|
|
regex_init();
|
|
#endif
|
|
select_thread=pthread_self();
|
|
select_thread_in_use=1;
|
|
if (use_temp_pool && bitmap_init(&temp_pool,1024,1))
|
|
unireg_abort(1);
|
|
|
|
/*
|
|
** We have enough space for fiddling with the argv, continue
|
|
*/
|
|
umask(((~my_umask) & 0666));
|
|
if (my_setwd(mysql_real_data_home,MYF(MY_WME)))
|
|
{
|
|
unireg_abort(1); /* purecov: inspected */
|
|
}
|
|
mysql_data_home[0]=FN_CURLIB; // all paths are relative from here
|
|
mysql_data_home[1]=0;
|
|
server_init();
|
|
table_cache_init();
|
|
hostname_cache_init();
|
|
query_cache_result_size_limit(query_cache_limit);
|
|
query_cache_resize(query_cache_size);
|
|
randominit(&sql_rand,(ulong) start_time,(ulong) start_time/2);
|
|
reset_floating_point_exceptions();
|
|
init_thr_lock();
|
|
init_slave_list();
|
|
|
|
/* Setup log files */
|
|
if (opt_log)
|
|
open_log(&mysql_log, glob_hostname, opt_logname, ".log", LOG_NORMAL);
|
|
if (opt_update_log)
|
|
{
|
|
open_log(&mysql_update_log, glob_hostname, opt_update_logname, "",
|
|
LOG_NEW);
|
|
using_update_log=1;
|
|
}
|
|
|
|
if (opt_slow_log)
|
|
open_log(&mysql_slow_log, glob_hostname, opt_slow_logname, "-slow.log",
|
|
LOG_NORMAL);
|
|
#ifdef __WIN__
|
|
#define MYSQL_ERR_FILE "mysql.err"
|
|
if (!opt_console)
|
|
{
|
|
freopen(MYSQL_ERR_FILE,"a+",stdout);
|
|
freopen(MYSQL_ERR_FILE,"a+",stderr);
|
|
}
|
|
#endif
|
|
if (ha_init())
|
|
{
|
|
sql_print_error("Can't init databases");
|
|
exit(1);
|
|
}
|
|
ha_key_cache();
|
|
#if defined(HAVE_MLOCKALL) && defined(MCL_CURRENT)
|
|
if (locked_in_memory && !geteuid())
|
|
{
|
|
if (mlockall(MCL_CURRENT))
|
|
{
|
|
sql_print_error("Warning: Failed to lock memory. Errno: %d\n",errno);
|
|
}
|
|
else
|
|
locked_in_memory=1;
|
|
}
|
|
#else
|
|
locked_in_memory=0;
|
|
#endif
|
|
|
|
if (opt_myisam_log)
|
|
(void) mi_log( 1 );
|
|
ft_init_stopwords(ft_precompiled_stopwords);
|
|
|
|
#ifdef __WIN__
|
|
if (!opt_console)
|
|
FreeConsole(); // Remove window
|
|
#endif
|
|
|
|
/*
|
|
init signals & alarm
|
|
After this we can't quit by a simple unireg_abort
|
|
*/
|
|
error_handler_hook = my_message_sql;
|
|
if (pthread_key_create(&THR_THD,NULL) || pthread_key_create(&THR_NET,NULL) ||
|
|
pthread_key_create(&THR_MALLOC,NULL))
|
|
{
|
|
sql_print_error("Can't create thread-keys");
|
|
exit(1);
|
|
}
|
|
start_signal_handler(); // Creates pidfile
|
|
if (acl_init(opt_noacl))
|
|
{
|
|
select_thread_in_use=0;
|
|
(void) pthread_kill(signal_thread,MYSQL_KILL_SIGNAL);
|
|
#ifndef __WIN__
|
|
if (!opt_bootstrap)
|
|
(void) my_delete(pidfile_name,MYF(MY_WME)); // Not needed anymore
|
|
#endif
|
|
exit(1);
|
|
}
|
|
if (!opt_noacl)
|
|
(void) grant_init();
|
|
init_max_user_conn();
|
|
|
|
#ifdef HAVE_DLOPEN
|
|
if (!opt_noacl)
|
|
udf_init();
|
|
#endif
|
|
/* init_slave() must be called after the thread keys are created */
|
|
init_slave();
|
|
|
|
if (opt_bin_log && !server_id)
|
|
{
|
|
server_id= !master_host ? 1 : 2;
|
|
switch (server_id) {
|
|
#ifdef EXTRA_DEBUG
|
|
case 1:
|
|
sql_print_error("\
|
|
Warning: You have enabled the binary log, but you haven't set server-id:\n\
|
|
Updates will be logged to the binary log, but connections to slaves will\n\
|
|
not be accepted.");
|
|
break;
|
|
#endif
|
|
case 2:
|
|
sql_print_error("\
|
|
Warning: You should set server-id to a non-0 value if master_host is set.\n\
|
|
The server will not act as a slave.");
|
|
break;
|
|
}
|
|
}
|
|
if (opt_bin_log)
|
|
{
|
|
if (!opt_bin_logname)
|
|
{
|
|
char tmp[FN_REFLEN];
|
|
/* TODO: The following should be using fn_format(); We just need to
|
|
first change fn_format() to cut the file name if it's too long.
|
|
*/
|
|
strmake(tmp,glob_hostname,FN_REFLEN-5);
|
|
strmov(strcend(tmp,'.'),"-bin");
|
|
opt_bin_logname=my_strdup(tmp,MYF(MY_WME));
|
|
}
|
|
mysql_bin_log.set_index_file_name(opt_binlog_index_name);
|
|
open_log(&mysql_bin_log, glob_hostname, opt_bin_logname, "-bin",
|
|
LOG_BIN);
|
|
using_update_log=1;
|
|
}
|
|
|
|
|
|
if (opt_bootstrap)
|
|
{
|
|
int error=bootstrap(stdin);
|
|
end_thr_alarm(); // Don't allow alarms
|
|
unireg_abort(error ? 1 : 0);
|
|
}
|
|
if (opt_init_file)
|
|
{
|
|
if (read_init_file(opt_init_file))
|
|
{
|
|
end_thr_alarm(); // Don't allow alarms
|
|
unireg_abort(1);
|
|
}
|
|
}
|
|
(void) thr_setconcurrency(concurrency); // 10 by default
|
|
#if defined(__WIN__) && !defined(EMBEDDED_LIBRARY) //IRENA
|
|
{
|
|
hEventShutdown=CreateEvent(0, FALSE, FALSE, "MySqlShutdown");
|
|
pthread_t hThread;
|
|
if (pthread_create(&hThread,&connection_attrib,handle_shutdown,0))
|
|
sql_print_error("Warning: Can't create thread to handle shutdown requests");
|
|
|
|
// On "Stop Service" we have to do regular shutdown
|
|
Service.SetShutdownEvent(hEventShutdown);
|
|
}
|
|
#endif
|
|
#ifdef OS2
|
|
{
|
|
pthread_cond_init( &eventShutdown, NULL);
|
|
pthread_t hThread;
|
|
if (pthread_create(&hThread,&connection_attrib,handle_shutdown,0))
|
|
sql_print_error("Warning: Can't create thread to handle shutdown requests");
|
|
}
|
|
#endif
|
|
|
|
if (
|
|
#ifdef HAVE_BERKELEY_DB
|
|
!berkeley_skip ||
|
|
#endif
|
|
(flush_time && flush_time != ~(ulong) 0L))
|
|
{
|
|
pthread_t hThread;
|
|
if (pthread_create(&hThread,&connection_attrib,handle_manager,0))
|
|
sql_print_error("Warning: Can't create thread to manage maintenance");
|
|
}
|
|
|
|
printf(ER(ER_READY),my_progname,server_version,"");
|
|
fflush(stdout);
|
|
|
|
#ifdef __NT__
|
|
if (hPipe == INVALID_HANDLE_VALUE &&
|
|
(!have_tcpip || opt_disable_networking))
|
|
{
|
|
sql_print_error("TCP/IP or --enable-named-pipe should be configured on NT OS");
|
|
unireg_abort(1);
|
|
}
|
|
else
|
|
{
|
|
pthread_mutex_lock(&LOCK_thread_count);
|
|
(void) pthread_cond_init(&COND_handler_count,NULL);
|
|
{
|
|
pthread_t hThread;
|
|
handler_count=0;
|
|
if (hPipe != INVALID_HANDLE_VALUE && opt_enable_named_pipe)
|
|
{
|
|
handler_count++;
|
|
if (pthread_create(&hThread,&connection_attrib,
|
|
handle_connections_namedpipes, 0))
|
|
{
|
|
sql_print_error("Warning: Can't create thread to handle named pipes");
|
|
handler_count--;
|
|
}
|
|
}
|
|
if (have_tcpip && !opt_disable_networking)
|
|
{
|
|
handler_count++;
|
|
if (pthread_create(&hThread,&connection_attrib,
|
|
handle_connections_sockets, 0))
|
|
{
|
|
sql_print_error("Warning: Can't create thread to handle named pipes");
|
|
handler_count--;
|
|
}
|
|
}
|
|
while (handler_count > 0)
|
|
{
|
|
pthread_cond_wait(&COND_handler_count,&LOCK_thread_count);
|
|
}
|
|
}
|
|
pthread_mutex_unlock(&LOCK_thread_count);
|
|
}
|
|
#else
|
|
handle_connections_sockets(0);
|
|
#ifdef EXTRA_DEBUG2
|
|
sql_print_error("Exiting main thread");
|
|
#endif
|
|
#endif /* __NT__ */
|
|
|
|
/* (void) pthread_attr_destroy(&connection_attrib); */
|
|
|
|
DBUG_PRINT("quit",("Exiting main thread"));
|
|
|
|
#ifndef __WIN__
|
|
#ifdef EXTRA_DEBUG2
|
|
sql_print_error("Before Lock_thread_count");
|
|
#endif
|
|
(void) pthread_mutex_lock(&LOCK_thread_count);
|
|
DBUG_PRINT("quit", ("Got thread_count mutex"));
|
|
select_thread_in_use=0; // For close_connections
|
|
(void) pthread_cond_broadcast(&COND_thread_count);
|
|
(void) pthread_mutex_unlock(&LOCK_thread_count);
|
|
#ifdef EXTRA_DEBUG2
|
|
sql_print_error("After lock_thread_count");
|
|
#endif
|
|
#endif /* __WIN__ */
|
|
|
|
/* Wait until cleanup is done */
|
|
(void) pthread_mutex_lock(&LOCK_thread_count);
|
|
while (!ready_to_exit)
|
|
{
|
|
pthread_cond_wait(&COND_thread_count,&LOCK_thread_count);
|
|
}
|
|
(void) pthread_mutex_unlock(&LOCK_thread_count);
|
|
|
|
#if defined(__WIN__) && !defined(EMBEDDED_LIBRARY)
|
|
if (Service.IsNT() && start_mode)
|
|
Service.Stop();
|
|
else
|
|
{
|
|
Service.SetShutdownEvent(0);
|
|
if (hEventShutdown)
|
|
CloseHandle(hEventShutdown);
|
|
}
|
|
#endif
|
|
my_end(opt_endinfo ? MY_CHECK_ERROR | MY_GIVE_INFO : 0);
|
|
exit(0);
|
|
return(0); /* purecov: deadcode */
|
|
}
|
|
|
|
|
|
#if defined(__WIN__) && !defined(EMBEDDED_LIBRARY)
|
|
/* ------------------------------------------------------------------------
|
|
main and thread entry function for Win32
|
|
(all this is needed only to run mysqld as a service on WinNT)
|
|
-------------------------------------------------------------------------- */
|
|
int mysql_service(void *p)
|
|
{
|
|
win_main(Service.my_argc, Service.my_argv);
|
|
return 0;
|
|
}
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
// check environment variable OS
|
|
if (Service.GetOS()) // "OS" defined; Should be NT
|
|
{
|
|
if (argc == 2)
|
|
{
|
|
char path[FN_REFLEN];
|
|
my_path(path, argv[0], ""); // Find name in path
|
|
fn_format(path,argv[0],path,"",1+4+16); // Force use of full path
|
|
|
|
if (!strcmp(argv[1],"-install") || !strcmp(argv[1],"--install"))
|
|
{
|
|
Service.Install(1,MYSQL_SERVICENAME,MYSQL_SERVICENAME,path);
|
|
return 0;
|
|
}
|
|
else if (!strcmp(argv[1],"-install-manual") || !strcmp(argv[1],"--install-manual"))
|
|
{
|
|
Service.Install(0,MYSQL_SERVICENAME,MYSQL_SERVICENAME,path);
|
|
return 0;
|
|
}
|
|
else if (!strcmp(argv[1],"-remove") || !strcmp(argv[1],"--remove"))
|
|
{
|
|
Service.Remove(MYSQL_SERVICENAME);
|
|
return 0;
|
|
}
|
|
}
|
|
else if (argc == 1) // No arguments; start as a service
|
|
{
|
|
// init service
|
|
start_mode = 1;
|
|
long tmp=Service.Init(MYSQL_SERVICENAME,mysql_service);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/*
|
|
This is a WIN95 machine or a start of mysqld as a standalone program
|
|
we have to pass the arguments, in case of NT-service this will be done
|
|
by ServiceMain()
|
|
*/
|
|
|
|
Service.my_argc=argc;
|
|
Service.my_argv=argv;
|
|
mysql_service(NULL);
|
|
return 0;
|
|
}
|
|
/* ------------------------------------------------------------------------ */
|
|
#endif
|
|
|
|
|
|
static int bootstrap(FILE *file)
|
|
{
|
|
THD *thd= new THD;
|
|
int error;
|
|
thd->bootstrap=1;
|
|
thd->client_capabilities=0;
|
|
my_net_init(&thd->net,(st_vio*) 0);
|
|
thd->max_packet_length=thd->net.max_packet;
|
|
thd->master_access= ~0;
|
|
thd->thread_id=thread_id++;
|
|
thread_count++;
|
|
|
|
bootstrap_file=file;
|
|
if (pthread_create(&thd->real_id,&connection_attrib,handle_bootstrap,
|
|
(void*) thd))
|
|
{
|
|
sql_print_error("Warning: Can't create thread to handle bootstrap");
|
|
return -1;
|
|
}
|
|
/* Wait for thread to die */
|
|
(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);
|
|
error= thd->fatal_error;
|
|
net_end(&thd->net);
|
|
thd->cleanup();
|
|
delete thd;
|
|
return error;
|
|
}
|
|
|
|
static bool read_init_file(char *file_name)
|
|
{
|
|
FILE *file;
|
|
DBUG_ENTER("read_init_file");
|
|
DBUG_PRINT("enter",("name: %s",file_name));
|
|
if (!(file=my_fopen(file_name,O_RDONLY,MYF(MY_WME))))
|
|
return(1);
|
|
bootstrap(file); /* Ignore errors from this */
|
|
(void) my_fclose(file,MYF(MY_WME));
|
|
return 0;
|
|
}
|
|
|
|
|
|
static void create_new_thread(THD *thd)
|
|
{
|
|
DBUG_ENTER("create_new_thread");
|
|
|
|
NET *net=&thd->net; // For easy ref
|
|
net->timeout = (uint) connect_timeout; // Timeout for read
|
|
if (protocol_version > 9)
|
|
net->return_errno=1;
|
|
|
|
/* don't allow too many connections */
|
|
if (thread_count - delayed_insert_threads >= max_connections+1 || abort_loop)
|
|
{
|
|
DBUG_PRINT("error",("Too many connections"));
|
|
close_connection(net,ER_CON_COUNT_ERROR);
|
|
delete thd;
|
|
DBUG_VOID_RETURN;
|
|
}
|
|
if (pthread_mutex_lock(&LOCK_thread_count))
|
|
{
|
|
DBUG_PRINT("error",("Can't lock LOCK_thread_count"));
|
|
close_connection(net,ER_OUT_OF_RESOURCES);
|
|
delete thd;
|
|
DBUG_VOID_RETURN;
|
|
}
|
|
if (thread_count-delayed_insert_threads > max_used_connections)
|
|
max_used_connections=thread_count-delayed_insert_threads;
|
|
thd->thread_id=thread_id++;
|
|
for (uint i=0; i < 8 ; i++) // Generate password teststring
|
|
thd->scramble[i]= (char) (rnd(&sql_rand)*94+33);
|
|
thd->scramble[8]=0;
|
|
thd->rand=sql_rand;
|
|
thd->real_id=pthread_self(); // Keep purify happy
|
|
|
|
/* Start a new thread to handle connection */
|
|
#ifdef ONE_THREAD
|
|
if (test_flags & TEST_NO_THREADS) // For debugging under Linux
|
|
{
|
|
thread_cache_size=0; // Safety
|
|
thread_count++;
|
|
threads.append(thd);
|
|
thd->real_id=pthread_self();
|
|
(void) pthread_mutex_unlock(&LOCK_thread_count);
|
|
handle_one_connection((void*) thd);
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
if (cached_thread_count > wake_thread)
|
|
{
|
|
start_cached_thread(thd);
|
|
(void) pthread_mutex_unlock(&LOCK_thread_count);
|
|
}
|
|
else
|
|
{
|
|
int error;
|
|
thread_count++;
|
|
thread_created++;
|
|
threads.append(thd);
|
|
DBUG_PRINT("info",(("creating thread %d"), thd->thread_id));
|
|
thd->connect_time = time(NULL);
|
|
if ((error=pthread_create(&thd->real_id,&connection_attrib,
|
|
handle_one_connection,
|
|
(void*) thd)))
|
|
{
|
|
DBUG_PRINT("error",
|
|
("Can't create thread to handle request (error %d)",
|
|
error));
|
|
thread_count--;
|
|
thd->killed=1; // Safety
|
|
(void) pthread_mutex_unlock(&LOCK_thread_count);
|
|
net_printf(net,ER_CANT_CREATE_THREAD,error);
|
|
(void) pthread_mutex_lock(&LOCK_thread_count);
|
|
close_connection(net,0,0);
|
|
delete thd;
|
|
(void) pthread_mutex_unlock(&LOCK_thread_count);
|
|
DBUG_VOID_RETURN;
|
|
}
|
|
|
|
(void) pthread_mutex_unlock(&LOCK_thread_count);
|
|
}
|
|
}
|
|
DBUG_PRINT("info",("Thread created"));
|
|
DBUG_VOID_RETURN;
|
|
}
|
|
|
|
#ifdef SIGNALS_DONT_BREAK_READ
|
|
inline void kill_broken_server()
|
|
{
|
|
/* hack to get around signals ignored in syscalls for problem OS's */
|
|
if (unix_sock == INVALID_SOCKET || ip_sock ==INVALID_SOCKET)
|
|
{
|
|
select_thread_in_use = 0;
|
|
kill_server((void*)MYSQL_KILL_SIGNAL); /* never returns */
|
|
}
|
|
}
|
|
#define MAYBE_BROKEN_SYSCALL kill_broken_server();
|
|
#else
|
|
#define MAYBE_BROKEN_SYSCALL
|
|
#endif
|
|
|
|
/* Handle new connections and spawn new process to handle them */
|
|
|
|
pthread_handler_decl(handle_connections_sockets,arg __attribute__((unused)))
|
|
{
|
|
my_socket sock,new_sock;
|
|
uint error_count=0;
|
|
uint max_used_connection= (uint) (max(ip_sock,unix_sock)+1);
|
|
fd_set readFDs,clientFDs;
|
|
THD *thd;
|
|
struct sockaddr_in cAddr;
|
|
int ip_flags=0,socket_flags=0,flags;
|
|
st_vio *vio_tmp;
|
|
DBUG_ENTER("handle_connections_sockets");
|
|
|
|
LINT_INIT(new_sock);
|
|
|
|
(void) my_pthread_getprio(pthread_self()); // For debugging
|
|
|
|
FD_ZERO(&clientFDs);
|
|
if (ip_sock != INVALID_SOCKET)
|
|
{
|
|
FD_SET(ip_sock,&clientFDs);
|
|
#ifdef HAVE_FCNTL
|
|
ip_flags = fcntl(ip_sock, F_GETFL, 0);
|
|
#endif
|
|
}
|
|
#ifdef HAVE_SYS_UN_H
|
|
FD_SET(unix_sock,&clientFDs);
|
|
#ifdef HAVE_FCNTL
|
|
socket_flags=fcntl(unix_sock, F_GETFL, 0);
|
|
#endif
|
|
#endif
|
|
|
|
DBUG_PRINT("general",("Waiting for connections."));
|
|
MAYBE_BROKEN_SYSCALL;
|
|
while (!abort_loop)
|
|
{
|
|
readFDs=clientFDs;
|
|
#ifdef HPUX
|
|
if (select(max_used_connection,(int*) &readFDs,0,0,0) < 0)
|
|
continue;
|
|
#else
|
|
if (select((int) max_used_connection,&readFDs,0,0,0) < 0)
|
|
{
|
|
if (socket_errno != SOCKET_EINTR)
|
|
{
|
|
if (!select_errors++ && !abort_loop) /* purecov: inspected */
|
|
sql_print_error("mysqld: Got error %d from select",socket_errno); /* purecov: inspected */
|
|
}
|
|
MAYBE_BROKEN_SYSCALL
|
|
continue;
|
|
}
|
|
#endif /* HPUX */
|
|
if (abort_loop)
|
|
{
|
|
MAYBE_BROKEN_SYSCALL;
|
|
break;
|
|
}
|
|
/*
|
|
** Is this a new connection request
|
|
*/
|
|
|
|
#ifdef HAVE_SYS_UN_H
|
|
if (FD_ISSET(unix_sock,&readFDs))
|
|
{
|
|
sock = unix_sock;
|
|
flags= socket_flags;
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
sock = ip_sock;
|
|
flags= ip_flags;
|
|
}
|
|
|
|
#if !defined(NO_FCNTL_NONBLOCK)
|
|
if (!(test_flags & TEST_BLOCKING))
|
|
{
|
|
#if defined(O_NONBLOCK)
|
|
fcntl(sock, F_SETFL, flags | O_NONBLOCK);
|
|
#elif defined(O_NDELAY)
|
|
fcntl(sock, F_SETFL, flags | O_NDELAY);
|
|
#endif
|
|
}
|
|
#endif /* NO_FCNTL_NONBLOCK */
|
|
for (uint retry=0; retry < MAX_ACCEPT_RETRY; retry++)
|
|
{
|
|
size_socket length=sizeof(struct sockaddr_in);
|
|
new_sock = accept(sock, my_reinterpret_cast(struct sockaddr *) (&cAddr),
|
|
&length);
|
|
if (new_sock != INVALID_SOCKET ||
|
|
(socket_errno != SOCKET_EINTR && socket_errno != SOCKET_EAGAIN))
|
|
break;
|
|
MAYBE_BROKEN_SYSCALL;
|
|
#if !defined(NO_FCNTL_NONBLOCK)
|
|
if (!(test_flags & TEST_BLOCKING))
|
|
{
|
|
if (retry == MAX_ACCEPT_RETRY - 1)
|
|
fcntl(sock, F_SETFL, flags); // Try without O_NONBLOCK
|
|
}
|
|
#endif
|
|
}
|
|
#if !defined(NO_FCNTL_NONBLOCK)
|
|
if (!(test_flags & TEST_BLOCKING))
|
|
fcntl(sock, F_SETFL, flags);
|
|
#endif
|
|
if (new_sock == INVALID_SOCKET)
|
|
{
|
|
if ((error_count++ & 255) == 0) // This can happen often
|
|
sql_perror("Error in accept");
|
|
MAYBE_BROKEN_SYSCALL;
|
|
if (socket_errno == SOCKET_ENFILE || socket_errno == SOCKET_EMFILE)
|
|
sleep(1); // Give other threads some time
|
|
continue;
|
|
}
|
|
|
|
#ifdef HAVE_LIBWRAP
|
|
{
|
|
if (sock == ip_sock)
|
|
{
|
|
struct request_info req;
|
|
signal(SIGCHLD, SIG_DFL);
|
|
request_init(&req, RQ_DAEMON, libwrapName, RQ_FILE, new_sock, NULL);
|
|
#ifndef __linux__
|
|
fromhost(&req);
|
|
if (!hosts_access(&req))
|
|
{
|
|
/*
|
|
This may be stupid but refuse() includes an exit(0)
|
|
which we surely don't want...
|
|
clean_exit() - same stupid thing ...
|
|
*/
|
|
syslog(deny_severity, "refused connect from %s", eval_client(&req));
|
|
#else
|
|
fromhost();
|
|
if (!hosts_access())
|
|
{
|
|
syslog(deny_severity, "refused connect from %s", eval_client());
|
|
#endif
|
|
if (req.sink)
|
|
((void (*)(int))req.sink)(req.fd);
|
|
|
|
/*
|
|
C++ sucks (the gibberish in front just translates the supplied
|
|
sink function pointer in the req structure from a void (*sink)();
|
|
to a void(*sink)(int) if you omit the cast, the C++ compiler
|
|
will cry...
|
|
*/
|
|
(void) shutdown(new_sock,2); // This looks fine to me...
|
|
(void) closesocket(new_sock);
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
#endif /* HAVE_LIBWRAP */
|
|
|
|
{
|
|
size_socket dummyLen;
|
|
struct sockaddr dummy;
|
|
dummyLen = sizeof(struct sockaddr);
|
|
if (getsockname(new_sock,&dummy, &dummyLen) < 0)
|
|
{
|
|
sql_perror("Error on new connection socket");
|
|
(void) shutdown(new_sock,2);
|
|
(void) closesocket(new_sock);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Don't allow too many connections
|
|
*/
|
|
|
|
if (!(thd= new THD))
|
|
{
|
|
(void) shutdown(new_sock,2);
|
|
VOID(closesocket(new_sock));
|
|
continue;
|
|
}
|
|
if (!(vio_tmp=vio_new(new_sock,
|
|
sock == unix_sock ? VIO_TYPE_SOCKET :
|
|
VIO_TYPE_TCPIP,
|
|
sock == unix_sock)) ||
|
|
my_net_init(&thd->net,vio_tmp))
|
|
{
|
|
if (vio_tmp)
|
|
vio_delete(vio_tmp);
|
|
else
|
|
{
|
|
(void) shutdown(new_sock,2);
|
|
(void) closesocket(new_sock);
|
|
}
|
|
delete thd;
|
|
continue;
|
|
}
|
|
if (sock == unix_sock)
|
|
thd->host=(char*) localhost;
|
|
create_new_thread(thd);
|
|
}
|
|
|
|
#ifdef OS2
|
|
// kill server must be invoked from thread 1!
|
|
kill_server(MYSQL_KILL_SIGNAL);
|
|
#endif
|
|
|
|
#ifdef __NT__
|
|
pthread_mutex_lock(&LOCK_thread_count);
|
|
handler_count--;
|
|
pthread_mutex_unlock(&LOCK_thread_count);
|
|
pthread_cond_signal(&COND_handler_count);
|
|
#endif
|
|
DBUG_RETURN(0);
|
|
}
|
|
|
|
|
|
#ifdef __NT__
|
|
pthread_handler_decl(handle_connections_namedpipes,arg)
|
|
{
|
|
HANDLE hConnectedPipe;
|
|
BOOL fConnected;
|
|
THD *thd;
|
|
my_thread_init();
|
|
DBUG_ENTER("handle_connections_namedpipes");
|
|
(void) my_pthread_getprio(pthread_self()); // For debugging
|
|
|
|
DBUG_PRINT("general",("Waiting for named pipe connections."));
|
|
while (!abort_loop)
|
|
{
|
|
/* wait for named pipe connection */
|
|
fConnected = ConnectNamedPipe( hPipe, NULL );
|
|
if (abort_loop)
|
|
break;
|
|
if (!fConnected)
|
|
fConnected = GetLastError() == ERROR_PIPE_CONNECTED;
|
|
if (!fConnected)
|
|
{
|
|
CloseHandle( hPipe );
|
|
if ((hPipe = CreateNamedPipe(szPipeName,
|
|
PIPE_ACCESS_DUPLEX,
|
|
PIPE_TYPE_BYTE |
|
|
PIPE_READMODE_BYTE |
|
|
PIPE_WAIT,
|
|
PIPE_UNLIMITED_INSTANCES,
|
|
(int) net_buffer_length,
|
|
(int) net_buffer_length,
|
|
NMPWAIT_USE_DEFAULT_WAIT,
|
|
&saPipeSecurity )) ==
|
|
INVALID_HANDLE_VALUE )
|
|
{
|
|
sql_perror("Can't create new named pipe!");
|
|
break; // Abort
|
|
}
|
|
}
|
|
hConnectedPipe = hPipe;
|
|
/* create new pipe for new connection */
|
|
if ((hPipe = CreateNamedPipe(szPipeName,
|
|
PIPE_ACCESS_DUPLEX,
|
|
PIPE_TYPE_BYTE |
|
|
PIPE_READMODE_BYTE |
|
|
PIPE_WAIT,
|
|
PIPE_UNLIMITED_INSTANCES,
|
|
(int) net_buffer_length,
|
|
(int) net_buffer_length,
|
|
NMPWAIT_USE_DEFAULT_WAIT,
|
|
&saPipeSecurity)) ==
|
|
INVALID_HANDLE_VALUE)
|
|
{
|
|
sql_perror("Can't create new named pipe!");
|
|
hPipe=hConnectedPipe;
|
|
continue; // We have to try again
|
|
}
|
|
|
|
if (!(thd = new THD))
|
|
{
|
|
DisconnectNamedPipe( hConnectedPipe );
|
|
CloseHandle( hConnectedPipe );
|
|
continue;
|
|
}
|
|
if (!(thd->net.vio = vio_new_win32pipe(hConnectedPipe)) ||
|
|
my_net_init(&thd->net, thd->net.vio))
|
|
{
|
|
close_connection(&thd->net,ER_OUT_OF_RESOURCES);
|
|
delete thd;
|
|
continue;
|
|
}
|
|
/* host name is unknown */
|
|
thd->host = my_strdup(localhost,MYF(0)); /* Host is unknown */
|
|
create_new_thread(thd);
|
|
}
|
|
|
|
pthread_mutex_lock(&LOCK_thread_count);
|
|
handler_count--;
|
|
pthread_cond_signal(&COND_handler_count);
|
|
pthread_mutex_unlock(&LOCK_thread_count);
|
|
DBUG_RETURN(0);
|
|
}
|
|
#endif /* __NT__ */
|
|
|
|
|
|
/******************************************************************************
|
|
** handle start options
|
|
******************************************************************************/
|
|
|
|
enum options {
|
|
OPT_ISAM_LOG=256, OPT_SKIP_NEW,
|
|
OPT_SKIP_GRANT, OPT_SKIP_LOCK,
|
|
OPT_ENABLE_LOCK, OPT_USE_LOCKING,
|
|
OPT_SOCKET, OPT_UPDATE_LOG,
|
|
OPT_BIN_LOG, OPT_SKIP_RESOLVE,
|
|
OPT_SKIP_NETWORKING, OPT_BIN_LOG_INDEX,
|
|
OPT_BIND_ADDRESS, OPT_PID_FILE,
|
|
OPT_SKIP_PRIOR, OPT_BIG_TABLES,
|
|
OPT_STANDALONE, OPT_ONE_THREAD,
|
|
OPT_CONSOLE, OPT_LOW_PRIORITY_UPDATES,
|
|
OPT_SKIP_HOST_CACHE, OPT_LONG_FORMAT,
|
|
OPT_FLUSH, OPT_SAFE,
|
|
OPT_BOOTSTRAP, OPT_SKIP_SHOW_DB,
|
|
OPT_TABLE_TYPE, OPT_INIT_FILE,
|
|
OPT_DELAY_KEY_WRITE, OPT_SLOW_QUERY_LOG,
|
|
OPT_SKIP_DELAY_KEY_WRITE, OPT_CHARSETS_DIR,
|
|
OPT_BDB_HOME, OPT_BDB_LOG,
|
|
OPT_BDB_TMP, OPT_BDB_NOSYNC,
|
|
OPT_BDB_LOCK, OPT_BDB_SKIP,
|
|
OPT_BDB_NO_RECOVER, OPT_BDB_SHARED,
|
|
OPT_MASTER_HOST, OPT_MASTER_USER,
|
|
OPT_MASTER_PASSWORD, OPT_MASTER_PORT,
|
|
OPT_MASTER_INFO_FILE, OPT_MASTER_CONNECT_RETRY,
|
|
OPT_MASTER_RETRY_COUNT,
|
|
OPT_MASTER_SSL, OPT_MASTER_SSL_KEY,
|
|
OPT_MASTER_SSL_CERT,
|
|
OPT_SQL_BIN_UPDATE_SAME, OPT_REPLICATE_DO_DB,
|
|
OPT_REPLICATE_IGNORE_DB, OPT_LOG_SLAVE_UPDATES,
|
|
OPT_BINLOG_DO_DB, OPT_BINLOG_IGNORE_DB,
|
|
OPT_WANT_CORE, OPT_SKIP_CONCURRENT_INSERT,
|
|
OPT_MEMLOCK, OPT_MYISAM_RECOVER,
|
|
OPT_REPLICATE_REWRITE_DB, OPT_SERVER_ID,
|
|
OPT_SKIP_SLAVE_START, OPT_SKIP_INNOBASE,
|
|
OPT_SAFEMALLOC_MEM_LIMIT, OPT_REPLICATE_DO_TABLE,
|
|
OPT_REPLICATE_IGNORE_TABLE, OPT_REPLICATE_WILD_DO_TABLE,
|
|
OPT_REPLICATE_WILD_IGNORE_TABLE,
|
|
OPT_DISCONNECT_SLAVE_EVENT_COUNT,
|
|
OPT_ABORT_SLAVE_EVENT_COUNT,
|
|
OPT_INNODB_DATA_HOME_DIR,
|
|
OPT_INNODB_DATA_FILE_PATH,
|
|
OPT_INNODB_LOG_GROUP_HOME_DIR,
|
|
OPT_INNODB_LOG_ARCH_DIR,
|
|
OPT_INNODB_LOG_ARCHIVE,
|
|
OPT_INNODB_FLUSH_LOG_AT_TRX_COMMIT,
|
|
OPT_INNODB_FLUSH_METHOD,
|
|
OPT_INNODB_FAST_SHUTDOWN,
|
|
OPT_SAFE_SHOW_DB,
|
|
OPT_INNODB_SKIP, OPT_SKIP_SAFEMALLOC,
|
|
OPT_TEMP_POOL, OPT_TX_ISOLATION,
|
|
OPT_SKIP_STACK_TRACE, OPT_SKIP_SYMLINKS,
|
|
OPT_MAX_BINLOG_DUMP_EVENTS, OPT_SPORADIC_BINLOG_DUMP_FAIL,
|
|
OPT_SAFE_USER_CREATE, OPT_SQL_MODE,
|
|
OPT_HAVE_NAMED_PIPE,
|
|
OPT_DO_PSTACK, OPT_REPORT_HOST,
|
|
OPT_REPORT_USER, OPT_REPORT_PASSWORD, OPT_REPORT_PORT,
|
|
OPT_SHOW_SLAVE_AUTH_INFO, OPT_OLD_RPL_COMPAT,
|
|
OPT_SLAVE_LOAD_TMPDIR, OPT_NO_MIX_TYPE,
|
|
OPT_RPL_RECOVERY_RANK,OPT_INIT_RPL_ROLE,
|
|
OPT_RELAY_LOG, OPT_RELAY_LOG_INDEX, OPT_RELAY_LOG_INFO_FILE,
|
|
OPT_SLAVE_SKIP_ERRORS, OPT_DES_KEY_FILE, OPT_LOCAL_INFILE,
|
|
OPT_SSL_SSL, OPT_SSL_KEY, OPT_SSL_CERT, OPT_SSL_CA,
|
|
OPT_SSL_CAPATH, OPT_SSL_CIPHER
|
|
};
|
|
|
|
static struct option long_options[] = {
|
|
{"ansi", no_argument, 0, 'a'},
|
|
{"basedir", required_argument, 0, 'b'},
|
|
#ifdef HAVE_BERKELEY_DB
|
|
{"bdb-home", required_argument, 0, (int) OPT_BDB_HOME},
|
|
{"bdb-lock-detect", required_argument, 0, (int) OPT_BDB_LOCK},
|
|
{"bdb-logdir", required_argument, 0, (int) OPT_BDB_LOG},
|
|
{"bdb-no-recover", no_argument, 0, (int) OPT_BDB_NO_RECOVER},
|
|
{"bdb-no-sync", no_argument, 0, (int) OPT_BDB_NOSYNC},
|
|
{"bdb-shared-data", no_argument, 0, (int) OPT_BDB_SHARED},
|
|
{"bdb-tmpdir", required_argument, 0, (int) OPT_BDB_TMP},
|
|
#endif
|
|
{"big-tables", no_argument, 0, (int) OPT_BIG_TABLES},
|
|
{"binlog-do-db", required_argument, 0, (int) OPT_BINLOG_DO_DB},
|
|
{"binlog-ignore-db", required_argument, 0, (int) OPT_BINLOG_IGNORE_DB},
|
|
{"bind-address", required_argument, 0, (int) OPT_BIND_ADDRESS},
|
|
{"bootstrap", no_argument, 0, (int) OPT_BOOTSTRAP},
|
|
#ifdef __WIN__
|
|
{"console", no_argument, 0, (int) OPT_CONSOLE},
|
|
#endif
|
|
{"core-file", no_argument, 0, (int) OPT_WANT_CORE},
|
|
{"chroot", required_argument, 0, 'r'},
|
|
{"character-sets-dir", required_argument, 0, (int) OPT_CHARSETS_DIR},
|
|
{"datadir", required_argument, 0, 'h'},
|
|
{"debug", optional_argument, 0, '#'},
|
|
{"des-key-file", required_argument, 0, (int) OPT_DES_KEY_FILE},
|
|
{"default-character-set", required_argument, 0, 'C'},
|
|
{"default-table-type", required_argument, 0, (int) OPT_TABLE_TYPE},
|
|
{"delay-key-write-for-all-tables",
|
|
no_argument, 0, (int) OPT_DELAY_KEY_WRITE},
|
|
{"enable-locking", no_argument, 0, (int) OPT_ENABLE_LOCK},
|
|
{"enable-named-pipe", no_argument, 0, (int) OPT_HAVE_NAMED_PIPE},
|
|
{"enable-pstack", no_argument, 0, (int) OPT_DO_PSTACK},
|
|
{"exit-info", optional_argument, 0, 'T'},
|
|
{"flush", no_argument, 0, (int) OPT_FLUSH},
|
|
{"init-rpl-role", required_argument, 0, (int) OPT_INIT_RPL_ROLE},
|
|
/* We must always support this option to make scripts like mysqltest easier
|
|
to do */
|
|
{"innodb_data_file_path", required_argument, 0,
|
|
OPT_INNODB_DATA_FILE_PATH},
|
|
#ifdef HAVE_INNOBASE_DB
|
|
{"innodb_data_home_dir", required_argument, 0,
|
|
OPT_INNODB_DATA_HOME_DIR},
|
|
{"innodb_log_group_home_dir", required_argument, 0,
|
|
OPT_INNODB_LOG_GROUP_HOME_DIR},
|
|
{"innodb_log_arch_dir", required_argument, 0,
|
|
OPT_INNODB_LOG_ARCH_DIR},
|
|
{"innodb_log_archive", optional_argument, 0,
|
|
OPT_INNODB_LOG_ARCHIVE},
|
|
{"innodb_flush_log_at_trx_commit", optional_argument, 0,
|
|
OPT_INNODB_FLUSH_LOG_AT_TRX_COMMIT},
|
|
{"innodb_fast_shutdown", optional_argument, 0,
|
|
OPT_INNODB_FAST_SHUTDOWN},
|
|
{"innodb_flush_method", required_argument, 0,
|
|
OPT_INNODB_FLUSH_METHOD},
|
|
#endif
|
|
{"help", no_argument, 0, '?'},
|
|
{"init-file", required_argument, 0, (int) OPT_INIT_FILE},
|
|
{"log", optional_argument, 0, 'l'},
|
|
{"language", required_argument, 0, 'L'},
|
|
{"local-infile", optional_argument, 0, (int) OPT_LOCAL_INFILE},
|
|
{"log-bin", optional_argument, 0, (int) OPT_BIN_LOG},
|
|
{"log-bin-index", required_argument, 0, (int) OPT_BIN_LOG_INDEX},
|
|
{"log-isam", optional_argument, 0, (int) OPT_ISAM_LOG},
|
|
{"log-update", optional_argument, 0, (int) OPT_UPDATE_LOG},
|
|
{"log-slow-queries", optional_argument, 0, (int) OPT_SLOW_QUERY_LOG},
|
|
{"log-long-format", no_argument, 0, (int) OPT_LONG_FORMAT},
|
|
{"log-slave-updates", no_argument, 0, (int) OPT_LOG_SLAVE_UPDATES},
|
|
{"low-priority-updates", no_argument, 0, (int) OPT_LOW_PRIORITY_UPDATES},
|
|
{"master-host", required_argument, 0, (int) OPT_MASTER_HOST},
|
|
{"master-user", required_argument, 0, (int) OPT_MASTER_USER},
|
|
{"master-password", required_argument, 0, (int) OPT_MASTER_PASSWORD},
|
|
{"master-port", required_argument, 0, (int) OPT_MASTER_PORT},
|
|
{"master-connect-retry", required_argument, 0, (int) OPT_MASTER_CONNECT_RETRY},
|
|
{"master-retry-count", required_argument, 0, (int) OPT_MASTER_RETRY_COUNT},
|
|
{"master-info-file", required_argument, 0, (int) OPT_MASTER_INFO_FILE},
|
|
{"master-ssl", optional_argument, 0, (int) OPT_MASTER_SSL},
|
|
{"master-ssl-key", optional_argument, 0, (int) OPT_MASTER_SSL_KEY},
|
|
{"master-ssl-cert", optional_argument, 0, (int) OPT_MASTER_SSL_CERT},
|
|
{"myisam-recover", optional_argument, 0, (int) OPT_MYISAM_RECOVER},
|
|
{"memlock", no_argument, 0, (int) OPT_MEMLOCK},
|
|
/*
|
|
Option needs to be available for the test case to pass in non-debugging
|
|
mode. is a no-op.
|
|
*/
|
|
{"disconnect-slave-event-count", required_argument, 0,
|
|
(int) OPT_DISCONNECT_SLAVE_EVENT_COUNT},
|
|
{"abort-slave-event-count", required_argument, 0,
|
|
(int) OPT_ABORT_SLAVE_EVENT_COUNT},
|
|
{"max-binlog-dump-events", required_argument, 0,
|
|
(int) OPT_MAX_BINLOG_DUMP_EVENTS},
|
|
{"sporadic-binlog-dump-fail", no_argument, 0,
|
|
(int) OPT_SPORADIC_BINLOG_DUMP_FAIL},
|
|
{"safemalloc-mem-limit", required_argument, 0, (int)
|
|
OPT_SAFEMALLOC_MEM_LIMIT},
|
|
{"new", no_argument, 0, 'n'},
|
|
#ifdef NOT_YET
|
|
{"no-mix-table-types", no_argument, 0, (int) OPT_NO_MIX_TYPE},
|
|
#endif
|
|
{"old-protocol", no_argument, 0, 'o'},
|
|
{"old-rpl-compat", no_argument, 0, (int) OPT_OLD_RPL_COMPAT},
|
|
#ifdef ONE_THREAD
|
|
{"one-thread", no_argument, 0, (int) OPT_ONE_THREAD},
|
|
#endif
|
|
{"pid-file", required_argument, 0, (int) OPT_PID_FILE},
|
|
{"port", required_argument, 0, 'P'},
|
|
{"replicate-do-db", required_argument, 0, (int) OPT_REPLICATE_DO_DB},
|
|
{"replicate-do-table", required_argument, 0,
|
|
(int) OPT_REPLICATE_DO_TABLE},
|
|
{"replicate-wild-do-table", required_argument, 0,
|
|
(int) OPT_REPLICATE_WILD_DO_TABLE},
|
|
{"replicate-ignore-db", required_argument, 0,
|
|
(int) OPT_REPLICATE_IGNORE_DB},
|
|
{"replicate-ignore-table", required_argument, 0,
|
|
(int) OPT_REPLICATE_IGNORE_TABLE},
|
|
{"replicate-wild-ignore-table", required_argument, 0,
|
|
(int) OPT_REPLICATE_WILD_IGNORE_TABLE},
|
|
{"replicate-rewrite-db", required_argument, 0,
|
|
(int) OPT_REPLICATE_REWRITE_DB},
|
|
// In replication, we may need to tell the other servers how to connect
|
|
{"report-host", required_argument, 0, (int) OPT_REPORT_HOST},
|
|
{"report-user", required_argument, 0, (int) OPT_REPORT_USER},
|
|
{"report-password", required_argument, 0, (int) OPT_REPORT_PASSWORD},
|
|
{"report-port", required_argument, 0, (int) OPT_REPORT_PORT},
|
|
{"rpl-recovery-rank", required_argument, 0, (int) OPT_RPL_RECOVERY_RANK},
|
|
{"relay-log", required_argument, 0, (int) OPT_RELAY_LOG},
|
|
{"relay-log-index", required_argument, 0, (int) OPT_RELAY_LOG_INDEX},
|
|
{"safe-mode", no_argument, 0, (int) OPT_SAFE},
|
|
{"safe-show-database", no_argument, 0, (int) OPT_SAFE_SHOW_DB},
|
|
{"safe-user-create", no_argument, 0, (int) OPT_SAFE_USER_CREATE},
|
|
{"server-id", required_argument, 0, (int) OPT_SERVER_ID},
|
|
{"set-variable", required_argument, 0, 'O'},
|
|
{"show-slave-auth-info", no_argument, 0,
|
|
(int) OPT_SHOW_SLAVE_AUTH_INFO},
|
|
{"skip-bdb", no_argument, 0, (int) OPT_BDB_SKIP},
|
|
{"skip-innodb", no_argument, 0, (int) OPT_INNODB_SKIP},
|
|
{"skip-concurrent-insert", no_argument, 0, (int) OPT_SKIP_CONCURRENT_INSERT},
|
|
{"skip-delay-key-write", no_argument, 0, (int) OPT_SKIP_DELAY_KEY_WRITE},
|
|
{"skip-grant-tables", no_argument, 0, (int) OPT_SKIP_GRANT},
|
|
{"skip-locking", no_argument, 0, (int) OPT_SKIP_LOCK},
|
|
{"skip-host-cache", no_argument, 0, (int) OPT_SKIP_HOST_CACHE},
|
|
{"skip-name-resolve", no_argument, 0, (int) OPT_SKIP_RESOLVE},
|
|
{"skip-networking", no_argument, 0, (int) OPT_SKIP_NETWORKING},
|
|
{"skip-new", no_argument, 0, (int) OPT_SKIP_NEW},
|
|
{"skip-safemalloc", no_argument, 0, (int) OPT_SKIP_SAFEMALLOC},
|
|
{"skip-show-database", no_argument, 0, (int) OPT_SKIP_SHOW_DB},
|
|
{"skip-slave-start", no_argument, 0, (int) OPT_SKIP_SLAVE_START},
|
|
{"skip-stack-trace", no_argument, 0, (int) OPT_SKIP_STACK_TRACE},
|
|
{"skip-symlink", no_argument, 0, (int) OPT_SKIP_SYMLINKS},
|
|
{"skip-thread-priority", no_argument, 0, (int) OPT_SKIP_PRIOR},
|
|
{"relay-log-info-file", required_argument, 0,
|
|
(int) OPT_RELAY_LOG_INFO_FILE},
|
|
{"slave-load-tmpdir", required_argument, 0, (int) OPT_SLAVE_LOAD_TMPDIR},
|
|
{"slave-skip-errors", required_argument, 0,
|
|
(int) OPT_SLAVE_SKIP_ERRORS},
|
|
{"socket", required_argument, 0, (int) OPT_SOCKET},
|
|
{"sql-bin-update-same", no_argument, 0, (int) OPT_SQL_BIN_UPDATE_SAME},
|
|
{"sql-mode", required_argument, 0, (int) OPT_SQL_MODE},
|
|
#ifdef HAVE_OPENSSL
|
|
{"ssl", no_argument, 0, OPT_SSL_SSL},
|
|
{"ssl-key", required_argument, 0, OPT_SSL_KEY},
|
|
{"ssl-cert", required_argument, 0, OPT_SSL_CERT},
|
|
{"ssl-ca", required_argument, 0, OPT_SSL_CA},
|
|
{"ssl-capath", required_argument, 0, OPT_SSL_CAPATH},
|
|
{"ssl-cipher", required_argument, 0, OPT_SSL_CIPHER},
|
|
#endif
|
|
#ifdef __WIN__
|
|
{"standalone", no_argument, 0, (int) OPT_STANDALONE},
|
|
#endif
|
|
{"transaction-isolation", required_argument, 0, (int) OPT_TX_ISOLATION},
|
|
{"temp-pool", no_argument, 0, (int) OPT_TEMP_POOL},
|
|
{"tmpdir", required_argument, 0, 't'},
|
|
{"use-locking", no_argument, 0, (int) OPT_USE_LOCKING},
|
|
#ifdef USE_SYMDIR
|
|
{"use-symbolic-links", no_argument, 0, 's'},
|
|
#endif
|
|
{"user", required_argument, 0, 'u'},
|
|
{"version", no_argument, 0, 'V'},
|
|
{"warnings", no_argument, 0, 'W'},
|
|
{0, 0, 0, 0}
|
|
};
|
|
|
|
#define LONG_TIMEOUT ((ulong) 3600L*24L*365L)
|
|
|
|
CHANGEABLE_VAR changeable_vars[] = {
|
|
{ "back_log", (long*) &back_log,
|
|
50, 1, 65535, 0, 1 },
|
|
#ifdef HAVE_BERKELEY_DB
|
|
{ "bdb_cache_size", (long*) &berkeley_cache_size,
|
|
KEY_CACHE_SIZE, 20*1024, (long) ~0, 0, IO_SIZE },
|
|
{"bdb_log_buffer_size", (long*) &berkeley_log_buffer_size, 0, 256*1024L,
|
|
~0L, 0, 1024},
|
|
{ "bdb_max_lock", (long*) &berkeley_max_lock,
|
|
10000, 0, (long) ~0, 0, 1 },
|
|
/* QQ: The following should be removed soon! */
|
|
{ "bdb_lock_max", (long*) &berkeley_max_lock,
|
|
10000, 0, (long) ~0, 0, 1 },
|
|
#endif
|
|
{ "binlog_cache_size", (long*) &binlog_cache_size,
|
|
32*1024L, IO_SIZE, ~0L, 0, IO_SIZE },
|
|
{ "connect_timeout", (long*) &connect_timeout,
|
|
CONNECT_TIMEOUT, 2, LONG_TIMEOUT, 0, 1 },
|
|
{ "delayed_insert_timeout", (long*) &delayed_insert_timeout,
|
|
DELAYED_WAIT_TIMEOUT, 1, LONG_TIMEOUT, 0, 1 },
|
|
{ "delayed_insert_limit", (long*) &delayed_insert_limit,
|
|
DELAYED_LIMIT, 1, ~0L, 0, 1 },
|
|
{ "delayed_queue_size", (long*) &delayed_queue_size,
|
|
DELAYED_QUEUE_SIZE, 1, ~0L, 0, 1 },
|
|
{ "flush_time", (long*) &flush_time,
|
|
FLUSH_TIME, 0, LONG_TIMEOUT, 0, 1 },
|
|
{ "ft_min_word_len", (long*) &ft_min_word_len,
|
|
4, 1, HA_FT_MAXLEN, 0, 1 },
|
|
{ "ft_max_word_len", (long*) &ft_max_word_len,
|
|
HA_FT_MAXLEN, 10, HA_FT_MAXLEN, 0, 1 },
|
|
{ "ft_max_word_len_for_sort",(long*) &ft_max_word_len_for_sort,
|
|
20, 4, HA_FT_MAXLEN, 0, 1 },
|
|
#ifdef HAVE_INNOBASE_DB
|
|
{"innodb_mirrored_log_groups",
|
|
(long*) &innobase_mirrored_log_groups, 1, 1, 10, 0, 1},
|
|
{"innodb_log_files_in_group",
|
|
(long*) &innobase_log_files_in_group, 2, 2, 100, 0, 1},
|
|
{"innodb_log_file_size",
|
|
(long*) &innobase_log_file_size, 5*1024*1024L, 1*1024*1024L,
|
|
~0L, 0, 1024*1024L},
|
|
{"innodb_log_buffer_size",
|
|
(long*) &innobase_log_buffer_size, 1024*1024L, 256*1024L,
|
|
~0L, 0, 1024},
|
|
{"innodb_buffer_pool_size",
|
|
(long*) &innobase_buffer_pool_size, 8*1024*1024L, 1024*1024L,
|
|
~0L, 0, 1024*1024L},
|
|
{"innodb_additional_mem_pool_size",
|
|
(long*) &innobase_additional_mem_pool_size, 1*1024*1024L, 512*1024L,
|
|
~0L, 0, 1024},
|
|
{"innodb_file_io_threads",
|
|
(long*) &innobase_file_io_threads, 4, 4, 64, 0, 1},
|
|
{"innodb_lock_wait_timeout",
|
|
(long*) &innobase_lock_wait_timeout, 50, 1,
|
|
1024 * 1024 * 1024, 0, 1},
|
|
{"innodb_thread_concurrency",
|
|
(long*) &innobase_thread_concurrency, 8, 1, 1000, 0, 1},
|
|
{"innodb_force_recovery",
|
|
(long*) &innobase_force_recovery, 0, 0, 6, 0, 1},
|
|
#endif
|
|
{ "interactive_timeout", (long*) &net_interactive_timeout,
|
|
NET_WAIT_TIMEOUT, 1, LONG_TIMEOUT, 0, 1 },
|
|
{ "join_buffer_size", (long*) &join_buff_size,
|
|
128*1024L, IO_SIZE*2+MALLOC_OVERHEAD, ~0L, MALLOC_OVERHEAD, IO_SIZE },
|
|
{ "key_buffer_size", (long*) &keybuff_size,
|
|
KEY_CACHE_SIZE, MALLOC_OVERHEAD, (long) ~0, MALLOC_OVERHEAD, IO_SIZE },
|
|
{ "long_query_time", (long*) &long_query_time,
|
|
10, 1, LONG_TIMEOUT, 0, 1 },
|
|
{ "lower_case_table_names", (long*) &lower_case_table_names,
|
|
IF_WIN(1,0), 0, 1, 0, 1 },
|
|
{ "max_allowed_packet", (long*) &max_allowed_packet,
|
|
1024*1024L, 80, 64*1024*1024L, MALLOC_OVERHEAD, 1024 },
|
|
{ "max_binlog_cache_size", (long*) &max_binlog_cache_size,
|
|
~0L, IO_SIZE, ~0L, 0, IO_SIZE },
|
|
{ "max_binlog_size", (long*) &max_binlog_size,
|
|
1024*1024L*1024L, 1024, 1024*1024L*1024L, 0, 1 },
|
|
{ "max_connections", (long*) &max_connections,
|
|
100, 1, 16384, 0, 1 },
|
|
{ "max_connect_errors", (long*) &max_connect_errors,
|
|
MAX_CONNECT_ERRORS, 1, ~0L, 0, 1 },
|
|
{ "max_delayed_threads", (long*) &max_insert_delayed_threads,
|
|
20, 1, 16384, 0, 1 },
|
|
{ "max_heap_table_size", (long*) &max_heap_table_size,
|
|
16*1024*1024L, 16384, ~0L, MALLOC_OVERHEAD, 1024 },
|
|
{ "max_join_size", (long*) &max_join_size,
|
|
~0L, 1, ~0L, 0, 1 },
|
|
{ "max_sort_length", (long*) &max_item_sort_length,
|
|
1024, 4, 8192*1024L, 0, 1 },
|
|
{ "max_tmp_tables", (long*) &max_tmp_tables,
|
|
32, 1, ~0L, 0, 1 },
|
|
{ "max_user_connections", (long*) &max_user_connections,
|
|
0, 1, ~0L, 0, 1 },
|
|
{ "max_write_lock_count", (long*) &max_write_lock_count,
|
|
~0L, 1, ~0L, 0, 1 },
|
|
{ "myisam_bulk_insert_tree_size", (long*) &myisam_bulk_insert_tree_size,
|
|
8192*1024, 0, ~0L, 0, 1 },
|
|
{ "myisam_block_size", (long*) &opt_myisam_block_size,
|
|
MI_KEY_BLOCK_LENGTH, MI_MIN_KEY_BLOCK_LENGTH, MI_MAX_KEY_BLOCK_LENGTH,
|
|
0, MI_MIN_KEY_BLOCK_LENGTH },
|
|
{ "myisam_max_extra_sort_file_size",
|
|
(long*) &myisam_max_extra_sort_file_size,
|
|
(long) (MI_MAX_TEMP_LENGTH/(1024L*1024L)), 0, ~0L, 0, 1 },
|
|
{ "myisam_max_sort_file_size", (long*) &myisam_max_sort_file_size,
|
|
(long) (LONG_MAX/(1024L*1024L)), 0, ~0L, 0, 1 },
|
|
{ "myisam_sort_buffer_size", (long*) &myisam_sort_buffer_size,
|
|
8192*1024, 4, ~0L, 0, 1 },
|
|
{ "net_buffer_length", (long*) &net_buffer_length,
|
|
16384, 1024, 1024*1024L, MALLOC_OVERHEAD, 1024 },
|
|
{ "net_retry_count", (long*) &mysqld_net_retry_count,
|
|
MYSQLD_NET_RETRY_COUNT, 1, ~0L, 0, 1 },
|
|
{ "net_read_timeout", (long*) &net_read_timeout,
|
|
NET_READ_TIMEOUT, 1, LONG_TIMEOUT, 0, 1 },
|
|
{ "net_write_timeout", (long*) &net_write_timeout,
|
|
NET_WRITE_TIMEOUT, 1, LONG_TIMEOUT, 0, 1 },
|
|
{ "open_files_limit", (long*) &open_files_limit,
|
|
0, 0, 65535, 0, 1},
|
|
{ "query_buffer_size", (long*) &query_buff_size,
|
|
0, MALLOC_OVERHEAD, (long) ~0, MALLOC_OVERHEAD, IO_SIZE },
|
|
#ifdef HAVE_QUERY_CACHE
|
|
{ "query_cache_limit", (long*) &query_cache_limit,
|
|
1024*1024L, 0, ULONG_MAX, 0, 1},
|
|
{ "query_cache_size", (long*) &query_cache_size,
|
|
0, 0, ULONG_MAX, 0, 1},
|
|
{ "query_cache_startup_type",(long*) &query_cache_startup_type,
|
|
1, 0, 2, 0, 1},
|
|
#endif /*HAVE_QUERY_CACHE*/
|
|
{ "record_buffer", (long*) &my_default_record_cache_size,
|
|
128*1024L, IO_SIZE*2+MALLOC_OVERHEAD, ~0L, MALLOC_OVERHEAD, IO_SIZE },
|
|
{ "record_rnd_buffer", (long*) &record_rnd_cache_size,
|
|
0, IO_SIZE*2+MALLOC_OVERHEAD, ~0L, MALLOC_OVERHEAD, IO_SIZE },
|
|
{ "relay_log_space_limit", (long*) &relay_log_space_limit, 0L, 0L,ULONG_MAX,
|
|
0, 1},
|
|
{ "slave_net_timeout", (long*) &slave_net_timeout,
|
|
SLAVE_NET_TIMEOUT, 1, LONG_TIMEOUT, 0, 1 },
|
|
{ "slow_launch_time", (long*) &slow_launch_time,
|
|
2L, 0L, LONG_TIMEOUT, 0, 1 },
|
|
{ "sort_buffer", (long*) &sortbuff_size,
|
|
MAX_SORT_MEMORY, MIN_SORT_MEMORY+MALLOC_OVERHEAD*2, ~0L, MALLOC_OVERHEAD, 1 },
|
|
{ "table_cache", (long*) &table_cache_size,
|
|
64, 1, 16384, 0, 1 },
|
|
{ "thread_concurrency", (long*) &concurrency,
|
|
DEFAULT_CONCURRENCY, 1, 512, 0, 1 },
|
|
{ "thread_cache_size", (long*) &thread_cache_size,
|
|
0, 0, 16384, 0, 1 },
|
|
{ "tmp_table_size", (long*) &tmp_table_size,
|
|
32*1024*1024L, 1024, ~0L, 0, 1 },
|
|
{ "thread_stack", (long*) &thread_stack,
|
|
DEFAULT_THREAD_STACK, 1024*32, ~0L, 0, 1024 },
|
|
{ "wait_timeout", (long*) &net_wait_timeout,
|
|
NET_WAIT_TIMEOUT, 1, LONG_TIMEOUT, 0, 1 },
|
|
{ NullS, (long*) 0, 0, 0, 0, 0, 0}
|
|
};
|
|
|
|
|
|
struct show_var_st init_vars[]= {
|
|
{"back_log", (char*) &back_log, SHOW_LONG},
|
|
{"basedir", mysql_home, SHOW_CHAR},
|
|
#ifdef HAVE_BERKELEY_DB
|
|
{"bdb_cache_size", (char*) &berkeley_cache_size, SHOW_LONG},
|
|
{"bdb_log_buffer_size", (char*) &berkeley_log_buffer_size, SHOW_LONG},
|
|
{"bdb_home", (char*) &berkeley_home, SHOW_CHAR_PTR},
|
|
{"bdb_max_lock", (char*) &berkeley_max_lock, SHOW_LONG},
|
|
{"bdb_logdir", (char*) &berkeley_logdir, SHOW_CHAR_PTR},
|
|
{"bdb_shared_data", (char*) &berkeley_shared_data, SHOW_BOOL},
|
|
{"bdb_tmpdir", (char*) &berkeley_tmpdir, SHOW_CHAR_PTR},
|
|
{"bdb_version", (char*) DB_VERSION_STRING, SHOW_CHAR},
|
|
#endif
|
|
{"binlog_cache_size", (char*) &binlog_cache_size, SHOW_LONG},
|
|
{"character_set", default_charset, SHOW_CHAR},
|
|
{"character_sets", (char*) &charsets_list, SHOW_CHAR_PTR},
|
|
{"concurrent_insert", (char*) &myisam_concurrent_insert, SHOW_MY_BOOL},
|
|
{"connect_timeout", (char*) &connect_timeout, SHOW_LONG},
|
|
{"datadir", mysql_real_data_home, SHOW_CHAR},
|
|
{"delay_key_write", (char*) &myisam_delay_key_write, SHOW_MY_BOOL},
|
|
{"delayed_insert_limit", (char*) &delayed_insert_limit, SHOW_LONG},
|
|
{"delayed_insert_timeout", (char*) &delayed_insert_timeout, SHOW_LONG},
|
|
{"delayed_queue_size", (char*) &delayed_queue_size, SHOW_LONG},
|
|
{"flush", (char*) &myisam_flush, SHOW_MY_BOOL},
|
|
{"flush_time", (char*) &flush_time, SHOW_LONG},
|
|
{"ft_min_word_len", (char*) &ft_min_word_len, SHOW_LONG},
|
|
{"ft_max_word_len", (char*) &ft_max_word_len, SHOW_LONG},
|
|
{"ft_max_word_len_for_sort",(char*) &ft_max_word_len_for_sort, SHOW_LONG},
|
|
{"ft_boolean_syntax", (char*) ft_boolean_syntax, SHOW_CHAR},
|
|
{"have_bdb", (char*) &have_berkeley_db, SHOW_HAVE},
|
|
{"have_innodb", (char*) &have_innodb, SHOW_HAVE},
|
|
{"have_isam", (char*) &have_isam, SHOW_HAVE},
|
|
{"have_raid", (char*) &have_raid, SHOW_HAVE},
|
|
{"have_symlink", (char*) &have_symlink, SHOW_HAVE},
|
|
{"have_openssl", (char*) &have_openssl, SHOW_HAVE},
|
|
{"have_query_cache", (char*) &have_query_cache, SHOW_HAVE},
|
|
{"init_file", (char*) &opt_init_file, SHOW_CHAR_PTR},
|
|
#ifdef HAVE_INNOBASE_DB
|
|
{"innodb_additional_mem_pool_size", (char*) &innobase_additional_mem_pool_size, SHOW_LONG },
|
|
{"innodb_buffer_pool_size", (char*) &innobase_buffer_pool_size, SHOW_LONG },
|
|
{"innodb_data_file_path", (char*) &innobase_data_file_path, SHOW_CHAR_PTR},
|
|
{"innodb_data_home_dir", (char*) &innobase_data_home_dir, SHOW_CHAR_PTR},
|
|
{"innodb_file_io_threads", (char*) &innobase_file_io_threads, SHOW_LONG },
|
|
{"innodb_force_recovery", (char*) &innobase_force_recovery, SHOW_LONG },
|
|
{"innodb_thread_concurrency", (char*) &innobase_thread_concurrency, SHOW_LONG },
|
|
{"innodb_flush_log_at_trx_commit", (char*) &innobase_flush_log_at_trx_commit, SHOW_MY_BOOL},
|
|
{"innodb_fast_shutdown", (char*) &innobase_fast_shutdown, SHOW_MY_BOOL},
|
|
{"innodb_flush_method", (char*) &innobase_unix_file_flush_method, SHOW_CHAR_PTR},
|
|
{"innodb_lock_wait_timeout", (char*) &innobase_lock_wait_timeout, SHOW_LONG },
|
|
{"innodb_log_arch_dir", (char*) &innobase_log_arch_dir, SHOW_CHAR_PTR},
|
|
{"innodb_log_archive", (char*) &innobase_log_archive, SHOW_MY_BOOL},
|
|
{"innodb_log_buffer_size", (char*) &innobase_log_buffer_size, SHOW_LONG },
|
|
{"innodb_log_file_size", (char*) &innobase_log_file_size, SHOW_LONG},
|
|
{"innodb_log_files_in_group", (char*) &innobase_log_files_in_group, SHOW_LONG},
|
|
{"innodb_log_group_home_dir", (char*) &innobase_log_group_home_dir, SHOW_CHAR_PTR},
|
|
{"innodb_mirrored_log_groups", (char*) &innobase_mirrored_log_groups, SHOW_LONG},
|
|
#endif
|
|
{"interactive_timeout", (char*) &net_interactive_timeout, SHOW_LONG},
|
|
{"join_buffer_size", (char*) &join_buff_size, SHOW_LONG},
|
|
{"key_buffer_size", (char*) &keybuff_size, SHOW_LONG},
|
|
{"language", language, SHOW_CHAR},
|
|
{"large_files_support", (char*) &opt_large_files, SHOW_BOOL},
|
|
#ifdef HAVE_MLOCKALL
|
|
{"locked_in_memory", (char*) &locked_in_memory, SHOW_BOOL},
|
|
#endif
|
|
{"log", (char*) &opt_log, SHOW_BOOL},
|
|
{"log_update", (char*) &opt_update_log, SHOW_BOOL},
|
|
{"log_bin", (char*) &opt_bin_log, SHOW_BOOL},
|
|
{"log_slave_updates", (char*) &opt_log_slave_updates, SHOW_BOOL},
|
|
{"log_slow_queries", (char*) &opt_slow_log, SHOW_BOOL},
|
|
{"long_query_time", (char*) &long_query_time, SHOW_LONG},
|
|
{"low_priority_updates", (char*) &low_priority_updates, SHOW_BOOL},
|
|
{"lower_case_table_names", (char*) &lower_case_table_names, SHOW_LONG},
|
|
{"max_allowed_packet", (char*) &max_allowed_packet, SHOW_LONG},
|
|
{"max_binlog_cache_size", (char*) &max_binlog_cache_size, SHOW_LONG},
|
|
{"max_binlog_size", (char*) &max_binlog_size, SHOW_LONG},
|
|
{"max_connections", (char*) &max_connections, SHOW_LONG},
|
|
{"max_connect_errors", (char*) &max_connect_errors, SHOW_LONG},
|
|
{"max_delayed_threads", (char*) &max_insert_delayed_threads, SHOW_LONG},
|
|
{"max_heap_table_size", (char*) &max_heap_table_size, SHOW_LONG},
|
|
{"max_join_size", (char*) &max_join_size, SHOW_LONG},
|
|
{"max_sort_length", (char*) &max_item_sort_length, SHOW_LONG},
|
|
{"max_user_connections", (char*) &max_user_connections, SHOW_LONG},
|
|
{"max_tmp_tables", (char*) &max_tmp_tables, SHOW_LONG},
|
|
{"max_write_lock_count", (char*) &max_write_lock_count, SHOW_LONG},
|
|
{"myisam_bulk_insert_tree_size", (char*) &myisam_bulk_insert_tree_size, SHOW_INT},
|
|
{"myisam_max_extra_sort_file_size", (char*) &myisam_max_extra_sort_file_size,
|
|
SHOW_LONG},
|
|
{"myisam_max_sort_file_size",(char*) &myisam_max_sort_file_size, SHOW_LONG},
|
|
{"myisam_recover_options", (char*) &myisam_recover_options_str, SHOW_CHAR_PTR},
|
|
{"myisam_sort_buffer_size", (char*) &myisam_sort_buffer_size, SHOW_LONG},
|
|
#ifdef __NT__
|
|
{"named_pipe", (char*) &opt_enable_named_pipe, SHOW_BOOL},
|
|
#endif
|
|
{"net_buffer_length", (char*) &net_buffer_length, SHOW_LONG},
|
|
{"net_read_timeout", (char*) &net_read_timeout, SHOW_LONG},
|
|
{"net_retry_count", (char*) &mysqld_net_retry_count, SHOW_LONG},
|
|
{"net_write_timeout", (char*) &net_write_timeout, SHOW_LONG},
|
|
{"open_files_limit", (char*) &open_files_limit, SHOW_LONG},
|
|
{"pid_file", (char*) pidfile_name, SHOW_CHAR},
|
|
{"port", (char*) &mysql_port, SHOW_INT},
|
|
{"protocol_version", (char*) &protocol_version, SHOW_INT},
|
|
{"record_buffer", (char*) &my_default_record_cache_size,SHOW_LONG},
|
|
{"record_rnd_buffer", (char*) &record_rnd_cache_size, SHOW_LONG},
|
|
{"rpl_recovery_rank", (char*) &rpl_recovery_rank, SHOW_LONG},
|
|
{"query_buffer_size", (char*) &query_buff_size, SHOW_LONG},
|
|
#ifdef HAVE_QUERY_CACHE
|
|
{"query_cache_limit", (char*) &query_cache.query_cache_limit, SHOW_LONG},
|
|
{"query_cache_size", (char*) &query_cache.query_cache_size, SHOW_LONG},
|
|
{"query_cache_startup_type",(char*) &query_cache_startup_type, SHOW_LONG},
|
|
#endif /*HAVE_QUERY_CACHE*/
|
|
{"safe_show_database", (char*) &opt_safe_show_db, SHOW_BOOL},
|
|
{"server_id", (char*) &server_id, SHOW_LONG},
|
|
{"slave_net_timeout", (char*) &slave_net_timeout, SHOW_LONG},
|
|
{"skip_locking", (char*) &my_disable_locking, SHOW_MY_BOOL},
|
|
{"skip_networking", (char*) &opt_disable_networking, SHOW_BOOL},
|
|
{"skip_show_database", (char*) &opt_skip_show_db, SHOW_BOOL},
|
|
{"slow_launch_time", (char*) &slow_launch_time, SHOW_LONG},
|
|
{"socket", (char*) &mysql_unix_port, SHOW_CHAR_PTR},
|
|
{"sort_buffer", (char*) &sortbuff_size, SHOW_LONG},
|
|
{"sql_mode", (char*) &opt_sql_mode, SHOW_LONG},
|
|
{"table_cache", (char*) &table_cache_size, SHOW_LONG},
|
|
{"table_type", (char*) &default_table_type_name, SHOW_CHAR_PTR},
|
|
{"thread_cache_size", (char*) &thread_cache_size, SHOW_LONG},
|
|
#ifdef HAVE_THR_SETCONCURRENCY
|
|
{"thread_concurrency", (char*) &concurrency, SHOW_LONG},
|
|
#endif
|
|
{"thread_stack", (char*) &thread_stack, SHOW_LONG},
|
|
{"transaction_isolation", (char*) &default_tx_isolation_name, SHOW_CHAR_PTR},
|
|
#ifdef HAVE_TZNAME
|
|
{"timezone", time_zone, SHOW_CHAR},
|
|
#endif
|
|
{"tmp_table_size", (char*) &tmp_table_size, SHOW_LONG},
|
|
{"tmpdir", (char*) &mysql_tmpdir, SHOW_CHAR_PTR},
|
|
{"version", server_version, SHOW_CHAR},
|
|
{"wait_timeout", (char*) &net_wait_timeout, SHOW_LONG},
|
|
{NullS, NullS, SHOW_LONG}
|
|
};
|
|
|
|
struct show_var_st status_vars[]= {
|
|
{"Aborted_clients", (char*) &aborted_threads, SHOW_LONG},
|
|
{"Aborted_connects", (char*) &aborted_connects, SHOW_LONG},
|
|
{"Bytes_received", (char*) &bytes_received, SHOW_LONG},
|
|
{"Bytes_sent", (char*) &bytes_sent, SHOW_LONG},
|
|
{"Com_admin_commands", (char*) &com_other, SHOW_LONG},
|
|
{"Com_alter_table", (char*) (com_stat+(uint) SQLCOM_ALTER_TABLE),SHOW_LONG},
|
|
{"Com_analyze", (char*) (com_stat+(uint) SQLCOM_ANALYZE),SHOW_LONG},
|
|
{"Com_backup_table", (char*) (com_stat+(uint) SQLCOM_BACKUP_TABLE),SHOW_LONG},
|
|
{"Com_begin", (char*) (com_stat+(uint) SQLCOM_BEGIN),SHOW_LONG},
|
|
{"Com_change_db", (char*) (com_stat+(uint) SQLCOM_CHANGE_DB),SHOW_LONG},
|
|
{"Com_change_master", (char*) (com_stat+(uint) SQLCOM_CHANGE_MASTER),SHOW_LONG},
|
|
{"Com_check", (char*) (com_stat+(uint) SQLCOM_CHECK),SHOW_LONG},
|
|
{"Com_commit", (char*) (com_stat+(uint) SQLCOM_COMMIT),SHOW_LONG},
|
|
{"Com_create_db", (char*) (com_stat+(uint) SQLCOM_CREATE_DB),SHOW_LONG},
|
|
{"Com_create_function", (char*) (com_stat+(uint) SQLCOM_CREATE_FUNCTION),SHOW_LONG},
|
|
{"Com_create_index", (char*) (com_stat+(uint) SQLCOM_CREATE_INDEX),SHOW_LONG},
|
|
{"Com_create_table", (char*) (com_stat+(uint) SQLCOM_CREATE_TABLE),SHOW_LONG},
|
|
{"Com_delete", (char*) (com_stat+(uint) SQLCOM_DELETE),SHOW_LONG},
|
|
{"Com_delete_multi", (char*) (com_stat+(uint) SQLCOM_DELETE_MULTI),SHOW_LONG},
|
|
{"Com_drop_db", (char*) (com_stat+(uint) SQLCOM_DROP_DB),SHOW_LONG},
|
|
{"Com_drop_function", (char*) (com_stat+(uint) SQLCOM_DROP_FUNCTION),SHOW_LONG},
|
|
{"Com_drop_index", (char*) (com_stat+(uint) SQLCOM_DROP_INDEX),SHOW_LONG},
|
|
{"Com_drop_table", (char*) (com_stat+(uint) SQLCOM_DROP_TABLE),SHOW_LONG},
|
|
{"Com_flush", (char*) (com_stat+(uint) SQLCOM_FLUSH),SHOW_LONG},
|
|
{"Com_grant", (char*) (com_stat+(uint) SQLCOM_GRANT),SHOW_LONG},
|
|
{"Com_ha_close", (char*) (com_stat+(uint) SQLCOM_HA_CLOSE),SHOW_LONG},
|
|
{"Com_ha_open", (char*) (com_stat+(uint) SQLCOM_HA_OPEN),SHOW_LONG},
|
|
{"Com_ha_read", (char*) (com_stat+(uint) SQLCOM_HA_READ),SHOW_LONG},
|
|
{"Com_insert", (char*) (com_stat+(uint) SQLCOM_INSERT),SHOW_LONG},
|
|
{"Com_insert_select", (char*) (com_stat+(uint) SQLCOM_INSERT_SELECT),SHOW_LONG},
|
|
{"Com_kill", (char*) (com_stat+(uint) SQLCOM_KILL),SHOW_LONG},
|
|
{"Com_load", (char*) (com_stat+(uint) SQLCOM_LOAD),SHOW_LONG},
|
|
{"Com_load_master_data", (char*) (com_stat+(uint) SQLCOM_LOAD_MASTER_DATA),SHOW_LONG},
|
|
{"Com_load_master_table", (char*) (com_stat+(uint) SQLCOM_LOAD_MASTER_TABLE),SHOW_LONG},
|
|
{"Com_lock_tables", (char*) (com_stat+(uint) SQLCOM_LOCK_TABLES),SHOW_LONG},
|
|
{"Com_optimize", (char*) (com_stat+(uint) SQLCOM_OPTIMIZE),SHOW_LONG},
|
|
{"Com_purge", (char*) (com_stat+(uint) SQLCOM_PURGE),SHOW_LONG},
|
|
{"Com_rename_table", (char*) (com_stat+(uint) SQLCOM_RENAME_TABLE),SHOW_LONG},
|
|
{"Com_repair", (char*) (com_stat+(uint) SQLCOM_REPAIR),SHOW_LONG},
|
|
{"Com_replace", (char*) (com_stat+(uint) SQLCOM_REPLACE),SHOW_LONG},
|
|
{"Com_replace_select", (char*) (com_stat+(uint) SQLCOM_REPLACE_SELECT),SHOW_LONG},
|
|
{"Com_reset", (char*) (com_stat+(uint) SQLCOM_RESET),SHOW_LONG},
|
|
{"Com_restore_table", (char*) (com_stat+(uint) SQLCOM_RESTORE_TABLE),SHOW_LONG},
|
|
{"Com_revoke", (char*) (com_stat+(uint) SQLCOM_REVOKE),SHOW_LONG},
|
|
{"Com_rollback", (char*) (com_stat+(uint) SQLCOM_ROLLBACK),SHOW_LONG},
|
|
{"Com_select", (char*) (com_stat+(uint) SQLCOM_SELECT),SHOW_LONG},
|
|
{"Com_set_option", (char*) (com_stat+(uint) SQLCOM_SET_OPTION),SHOW_LONG},
|
|
{"Com_show_binlog_events", (char*) (com_stat+(uint) SQLCOM_SHOW_BINLOG_EVENTS),SHOW_LONG},
|
|
{"Com_show_binlogs", (char*) (com_stat+(uint) SQLCOM_SHOW_BINLOGS),SHOW_LONG},
|
|
{"Com_show_create", (char*) (com_stat+(uint) SQLCOM_SHOW_CREATE),SHOW_LONG},
|
|
{"Com_show_databases", (char*) (com_stat+(uint) SQLCOM_SHOW_DATABASES),SHOW_LONG},
|
|
{"Com_show_fields", (char*) (com_stat+(uint) SQLCOM_SHOW_FIELDS),SHOW_LONG},
|
|
{"Com_show_grants", (char*) (com_stat+(uint) SQLCOM_SHOW_GRANTS),SHOW_LONG},
|
|
{"Com_show_keys", (char*) (com_stat+(uint) SQLCOM_SHOW_KEYS),SHOW_LONG},
|
|
{"Com_show_logs", (char*) (com_stat+(uint) SQLCOM_SHOW_LOGS),SHOW_LONG},
|
|
{"Com_show_master_stat", (char*) (com_stat+(uint) SQLCOM_SHOW_MASTER_STAT),SHOW_LONG},
|
|
{"Com_show_new_master", (char*) (com_stat+(uint) SQLCOM_SHOW_NEW_MASTER),SHOW_LONG},
|
|
{"Com_show_open_tables", (char*) (com_stat+(uint) SQLCOM_SHOW_OPEN_TABLES),SHOW_LONG},
|
|
{"Com_show_processlist", (char*) (com_stat+(uint) SQLCOM_SHOW_PROCESSLIST),SHOW_LONG},
|
|
{"Com_show_slave_hosts", (char*) (com_stat+(uint) SQLCOM_SHOW_SLAVE_HOSTS),SHOW_LONG},
|
|
{"Com_show_slave_stat", (char*) (com_stat+(uint) SQLCOM_SHOW_SLAVE_STAT),SHOW_LONG},
|
|
{"Com_show_status", (char*) (com_stat+(uint) SQLCOM_SHOW_STATUS),SHOW_LONG},
|
|
{"Com_show_tables", (char*) (com_stat+(uint) SQLCOM_SHOW_TABLES),SHOW_LONG},
|
|
{"Com_show_variables", (char*) (com_stat+(uint) SQLCOM_SHOW_VARIABLES),SHOW_LONG},
|
|
{"Com_slave_start", (char*) (com_stat+(uint) SQLCOM_SLAVE_START),SHOW_LONG},
|
|
{"Com_slave_stop", (char*) (com_stat+(uint) SQLCOM_SLAVE_STOP),SHOW_LONG},
|
|
{"Com_truncate", (char*) (com_stat+(uint) SQLCOM_TRUNCATE),SHOW_LONG},
|
|
{"Com_unlock_tables", (char*) (com_stat+(uint) SQLCOM_UNLOCK_TABLES),SHOW_LONG},
|
|
{"Com_update", (char*) (com_stat+(uint) SQLCOM_UPDATE),SHOW_LONG},
|
|
{"Connections", (char*) &thread_id, SHOW_LONG_CONST},
|
|
{"Created_tmp_disk_tables", (char*) &created_tmp_disk_tables,SHOW_LONG},
|
|
{"Created_tmp_tables", (char*) &created_tmp_tables, SHOW_LONG},
|
|
{"Created_tmp_files", (char*) &my_tmp_file_created, SHOW_LONG},
|
|
{"Delayed_insert_threads", (char*) &delayed_insert_threads, SHOW_LONG},
|
|
{"Delayed_writes", (char*) &delayed_insert_writes, SHOW_LONG},
|
|
{"Delayed_errors", (char*) &delayed_insert_errors, SHOW_LONG},
|
|
{"Flush_commands", (char*) &refresh_version, SHOW_LONG_CONST},
|
|
{"Handler_commit", (char*) &ha_commit_count, SHOW_LONG},
|
|
{"Handler_delete", (char*) &ha_delete_count, SHOW_LONG},
|
|
{"Handler_read_first", (char*) &ha_read_first_count, SHOW_LONG},
|
|
{"Handler_read_key", (char*) &ha_read_key_count, SHOW_LONG},
|
|
{"Handler_read_next", (char*) &ha_read_next_count, SHOW_LONG},
|
|
{"Handler_read_prev", (char*) &ha_read_prev_count, SHOW_LONG},
|
|
{"Handler_read_rnd", (char*) &ha_read_rnd_count, SHOW_LONG},
|
|
{"Handler_read_rnd_next", (char*) &ha_read_rnd_next_count, SHOW_LONG},
|
|
{"Handler_rollback", (char*) &ha_rollback_count, SHOW_LONG},
|
|
{"Handler_update", (char*) &ha_update_count, SHOW_LONG},
|
|
{"Handler_write", (char*) &ha_write_count, SHOW_LONG},
|
|
{"Key_blocks_used", (char*) &_my_blocks_used, SHOW_LONG_CONST},
|
|
{"Key_read_requests", (char*) &_my_cache_r_requests, SHOW_LONG},
|
|
{"Key_reads", (char*) &_my_cache_read, SHOW_LONG},
|
|
{"Key_write_requests", (char*) &_my_cache_w_requests, SHOW_LONG},
|
|
{"Key_writes", (char*) &_my_cache_write, SHOW_LONG},
|
|
{"Max_used_connections", (char*) &max_used_connections, SHOW_LONG},
|
|
{"Not_flushed_key_blocks", (char*) &_my_blocks_changed, SHOW_LONG_CONST},
|
|
{"Not_flushed_delayed_rows", (char*) &delayed_rows_in_use, SHOW_LONG_CONST},
|
|
{"Open_tables", (char*) 0, SHOW_OPENTABLES},
|
|
{"Open_files", (char*) &my_file_opened, SHOW_INT_CONST},
|
|
{"Open_streams", (char*) &my_stream_opened, SHOW_INT_CONST},
|
|
{"Opened_tables", (char*) &opened_tables, SHOW_LONG},
|
|
{"Questions", (char*) 0, SHOW_QUESTION},
|
|
#ifdef HAVE_QUERY_CACHE
|
|
{"Qcache_queries_in_cache", (char*) &query_cache.queries_in_cache, SHOW_LONG_CONST},
|
|
{"Qcache_inserts", (char*) &query_cache.inserts, SHOW_LONG},
|
|
{"Qcache_hits", (char*) &query_cache.hits, SHOW_LONG},
|
|
{"Qcache_not_cached", (char*) &query_cache.refused, SHOW_LONG},
|
|
{"Qcache_free_memory", (char*) &query_cache.free_memory,
|
|
SHOW_LONG_CONST},
|
|
{"Qcache_free_blocks", (char*) &query_cache.free_memory_blocks,
|
|
SHOW_LONG_CONST},
|
|
{"Qcache_total_blocks", (char*) &query_cache.total_blocks,
|
|
SHOW_LONG_CONST},
|
|
#endif /*HAVE_QUERY_CACHE*/
|
|
{"Rpl_status", (char*) 0, SHOW_RPL_STATUS},
|
|
{"Select_full_join", (char*) &select_full_join_count, SHOW_LONG},
|
|
{"Select_full_range_join", (char*) &select_full_range_join_count, SHOW_LONG},
|
|
{"Select_range", (char*) &select_range_count, SHOW_LONG},
|
|
{"Select_range_check", (char*) &select_range_check_count, SHOW_LONG},
|
|
{"Select_scan", (char*) &select_scan_count, SHOW_LONG},
|
|
{"Slave_open_temp_tables", (char*) &slave_open_temp_tables, SHOW_LONG},
|
|
{"Slave_running", (char*) 0, SHOW_SLAVE_RUNNING},
|
|
{"Slow_launch_threads", (char*) &slow_launch_threads, SHOW_LONG},
|
|
{"Slow_queries", (char*) &long_query_count, SHOW_LONG},
|
|
{"Sort_merge_passes", (char*) &filesort_merge_passes, SHOW_LONG},
|
|
{"Sort_range", (char*) &filesort_range_count, SHOW_LONG},
|
|
{"Sort_rows", (char*) &filesort_rows, SHOW_LONG},
|
|
{"Sort_scan", (char*) &filesort_scan_count, SHOW_LONG},
|
|
#ifdef HAVE_OPENSSL
|
|
{"ssl_accepts", (char*) 0, SHOW_SSL_CTX_SESS_ACCEPT},
|
|
{"ssl_finished_accepts", (char*) 0, SHOW_SSL_CTX_SESS_ACCEPT_GOOD},
|
|
{"ssl_finished_connects", (char*) 0, SHOW_SSL_CTX_SESS_CONNECT_GOOD},
|
|
{"ssl_accept_renegotiates", (char*) 0, SHOW_SSL_CTX_SESS_ACCEPT_RENEGOTIATE},
|
|
{"ssl_connect_renegotiates", (char*) 0, SHOW_SSL_CTX_SESS_CONNECT_RENEGOTIATE},
|
|
{"ssl_callback_cache_hits", (char*) 0, SHOW_SSL_CTX_SESS_CB_HITS},
|
|
{"ssl_session_cache_hits", (char*) 0, SHOW_SSL_CTX_SESS_HITS},
|
|
{"ssl_session_cache_misses", (char*) 0, SHOW_SSL_CTX_SESS_MISSES},
|
|
{"ssl_session_cache_timeouts", (char*) 0, SHOW_SSL_CTX_SESS_TIMEOUTS},
|
|
{"ssl_used_session_cache_entries",(char*) 0, SHOW_SSL_CTX_SESS_NUMBER},
|
|
{"ssl_client_connects", (char*) 0, SHOW_SSL_CTX_SESS_CONNECT},
|
|
{"ssl_session_cache_overflows", (char*) 0, SHOW_SSL_CTX_SESS_CACHE_FULL},
|
|
{"ssl_session_cache_size", (char*) 0, SHOW_SSL_CTX_SESS_GET_CACHE_SIZE},
|
|
{"ssl_session_cache_mode", (char*) 0, SHOW_SSL_CTX_GET_SESSION_CACHE_MODE},
|
|
{"ssl_sessions_reused", (char*) 0, SHOW_SSL_SESSION_REUSED},
|
|
{"ssl_ctx_verify_mode", (char*) 0, SHOW_SSL_CTX_GET_VERIFY_MODE},
|
|
{"ssl_ctx_verify_depth", (char*) 0, SHOW_SSL_CTX_GET_VERIFY_DEPTH},
|
|
{"ssl_verify_mode", (char*) 0, SHOW_SSL_GET_VERIFY_MODE},
|
|
{"ssl_verify_depth", (char*) 0, SHOW_SSL_GET_VERIFY_DEPTH},
|
|
{"ssl_version", (char*) 0, SHOW_SSL_GET_VERSION},
|
|
{"ssl_cipher", (char*) 0, SHOW_SSL_GET_CIPHER},
|
|
{"ssl_cipher_list", (char*) 0, SHOW_SSL_GET_CIPHER_LIST},
|
|
{"ssl_default_timeout", (char*) 0, SHOW_SSL_GET_DEFAULT_TIMEOUT},
|
|
#endif /* HAVE_OPENSSL */
|
|
{"Table_locks_immediate", (char*) &locks_immediate, SHOW_LONG},
|
|
{"Table_locks_waited", (char*) &locks_waited, SHOW_LONG},
|
|
{"Threads_cached", (char*) &cached_thread_count, SHOW_LONG_CONST},
|
|
{"Threads_created", (char*) &thread_created, SHOW_LONG_CONST},
|
|
{"Threads_connected", (char*) &thread_count, SHOW_INT_CONST},
|
|
{"Threads_running", (char*) &thread_running, SHOW_INT_CONST},
|
|
{"Uptime", (char*) 0, SHOW_STARTTIME},
|
|
{NullS, NullS, SHOW_LONG}
|
|
};
|
|
|
|
static void print_version(void)
|
|
{
|
|
printf("%s Ver %s for %s on %s\n",my_progname,
|
|
server_version,SYSTEM_TYPE,MACHINE_TYPE);
|
|
}
|
|
|
|
static void use_help(void)
|
|
{
|
|
print_version();
|
|
printf("Use '--help' or '--no-defaults --help' for a list of available options\n");
|
|
}
|
|
|
|
static void usage(void)
|
|
{
|
|
print_version();
|
|
puts("\
|
|
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\
|
|
Starts the MySQL server\n");
|
|
|
|
printf("Usage: %s [OPTIONS]\n", my_progname);
|
|
puts("\n\
|
|
--ansi Use ANSI SQL syntax instead of MySQL syntax\n\
|
|
-b, --basedir=path Path to installation directory. All paths are\n\
|
|
usually resolved relative to this\n\
|
|
--big-tables Allow big result sets by saving all temporary sets\n\
|
|
on file (Solves most 'table full' errors)\n\
|
|
--bind-address=IP Ip address to bind to\n\
|
|
--bootstrap Used by mysql installation scripts\n\
|
|
--character-sets-dir=...\n\
|
|
Directory where character sets are\n\
|
|
--chroot=path Chroot mysqld daemon during startup\n\
|
|
--core-file Write core on errors\n\
|
|
-h, --datadir=path Path to the database root");
|
|
#ifndef DBUG_OFF
|
|
printf("\
|
|
-#, --debug[=...] Debug log. Default is '%s'\n",default_dbug_option);
|
|
#ifdef SAFEMALLOC
|
|
puts("\
|
|
--skip-safemalloc Don't use the memory allocation checking");
|
|
#endif
|
|
#endif
|
|
puts("\
|
|
--default-character-set=charset\n\
|
|
Set the default character set\n\
|
|
--default-table-type=type\n\
|
|
Set the default table type for tables\n\
|
|
--delay-key-write-for-all-tables\n\
|
|
Don't flush key buffers between writes for any MyISAM\n\
|
|
table\n");
|
|
#ifdef HAVE_OPENSSL
|
|
puts("\
|
|
--des-key-file Load keys for des_encrypt() and des_encrypt\n\
|
|
from given file");
|
|
#endif /* HAVE_OPENSSL */
|
|
puts("\
|
|
--enable-locking Enable system locking\n\
|
|
--enable-pstack Print a symbolic stack trace on failure\n\
|
|
-T, --exit-info Used for debugging; Use at your own risk!\n\
|
|
--flush Flush tables to disk between SQL commands\n\
|
|
-?, --help Display this help and exit\n\
|
|
--init-file=file Read SQL commands from this file at startup\n\
|
|
-L, --language=... Client error messages in given language. May be\n\
|
|
given as a full path\n\
|
|
--local-infile=[1|0] Enable/disable LOAD DATA LOCAL INFILE\n\
|
|
-l, --log[=file] Log connections and queries to file\n\
|
|
--log-bin[=file] Log queries in new binary format (for replication)\n\
|
|
--log-bin-index=file File that holds the names for last binary log files\n\
|
|
--log-update[=file] Log updates to file.# where # is a unique number\n\
|
|
if not given.\n\
|
|
--log-isam[=file] Log all MyISAM changes to file\n\
|
|
--log-long-format Log some extra information to update log\n\
|
|
--low-priority-updates INSERT/DELETE/UPDATE has lower priority than selects\n\
|
|
--log-slow-queries=[file]\n\
|
|
Log slow queries to this log file. Defaults logging\n\
|
|
to hostname-slow.log\n\
|
|
--pid-file=path Pid file used by safe_mysqld\n\
|
|
--myisam-recover[=option[,option...]] where options is one of DEAULT,\n\
|
|
BACKUP or FORCE.\n\
|
|
--memlock Lock mysqld in memory\n\
|
|
-n, --new Use very new possible 'unsafe' functions\n\
|
|
-o, --old-protocol Use the old (3.20) protocol\n\
|
|
-P, --port=... Port number to use for connection\n");
|
|
#ifdef ONE_THREAD
|
|
puts("\
|
|
--one-thread Only use one thread (for debugging under Linux)\n");
|
|
#endif
|
|
puts("\
|
|
-O, --set-variable var=option\n\
|
|
Give a variable an value. --help lists variables\n\
|
|
--safe-mode Skip some optimize stages (for testing)\n\
|
|
--safe-show-database Don't show databases for which the user has no\n\
|
|
privileges\n\
|
|
--safe-user-create Don't allow new user creation by the user who has\n\
|
|
no write privileges to the mysql.user table\n\
|
|
--skip-concurrent-insert\n\
|
|
Don't use concurrent insert with MyISAM\n\
|
|
--skip-delay-key-write\n\
|
|
Ignore the delay_key_write option for all tables\n\
|
|
--skip-grant-tables Start without grant tables. This gives all users\n\
|
|
FULL ACCESS to all tables!\n\
|
|
--skip-host-cache Don't cache host names\n\
|
|
--skip-locking Don't use system locking. To use isamchk one has\n\
|
|
to shut down the server.\n\
|
|
--skip-name-resolve Don't resolve hostnames.\n\
|
|
All hostnames are IP's or 'localhost'\n\
|
|
--skip-networking Don't allow connection with TCP/IP.\n\
|
|
--skip-new Don't use new, possible wrong routines.\n");
|
|
/* We have to break the string here because of VC++ limits */
|
|
puts("\
|
|
--skip-stack-trace Don't print a stack trace on failure\n\
|
|
--skip-symlink Don't allow symlinking of tables\n\
|
|
--skip-show-database Don't allow 'SHOW DATABASE' commands\n\
|
|
--skip-thread-priority\n\
|
|
Don't give threads different priorities.\n\
|
|
--socket=... Socket file to use for connection\n\
|
|
-t, --tmpdir=path Path for temporary files\n\
|
|
--sql-mode=option[,option[,option...]] where option can be one of:\n\
|
|
REAL_AS_FLOAT, PIPES_AS_CONCAT, ANSI_QUOTES,\n\
|
|
IGNORE_SPACE, SERIALIZE, ONLY_FULL_GROUP_BY,\n\
|
|
NO_UNSIGNED_SUBTRACTION.\n\
|
|
--transaction-isolation\n\
|
|
Default transaction isolation level\n\
|
|
--temp-pool Use a pool of temporary files\n\
|
|
-u, --user=user_name Run mysqld daemon as user\n\
|
|
-V, --version output version information and exit\n\
|
|
-W, --warnings Log some not critical warnings to the log file\n");
|
|
#ifdef __WIN__
|
|
puts("NT and Win32 specific options:\n\
|
|
--console Don't remove the console window\n\
|
|
--install Install the default service (NT)\n\
|
|
--install-manual Install the default service started manually (NT)\n\
|
|
--remove Remove the default service from the service list (NT)\n\
|
|
--enable-named-pipe Enable the named pipe (NT)\n\
|
|
--standalone Dummy option to start as a standalone program (NT)\
|
|
");
|
|
#ifdef USE_SYMDIR
|
|
puts("--use-symbolic-links Enable symbolic link support");
|
|
#endif
|
|
puts("");
|
|
#endif
|
|
#ifdef HAVE_BERKELEY_DB
|
|
puts("\
|
|
--bdb-home= directory Berkeley home direcory\n\
|
|
--bdb-lock-detect=# Berkeley lock detect\n\
|
|
(DEFAULT, OLDEST, RANDOM or YOUNGEST, # sec)\n\
|
|
--bdb-logdir=directory Berkeley DB log file directory\n\
|
|
--bdb-no-sync Don't synchronously flush logs\n\
|
|
--bdb-no-recover Don't try to recover Berkeley DB tables on start\n\
|
|
--bdb-shared-data Start Berkeley DB in multi-process mode\n\
|
|
--bdb-tmpdir=directory Berkeley DB tempfile name\n\
|
|
--skip-bdb Don't use berkeley db (will save memory)\n\
|
|
");
|
|
#endif /* HAVE_BERKELEY_DB */
|
|
#ifdef HAVE_INNOBASE_DB
|
|
puts("\
|
|
--innodb_data_home_dir=dir The common part for Innodb table spaces\n\
|
|
--innodb_data_file_path=dir Path to individual files and their sizes\n\
|
|
--innodb_flush_method=# With which method to flush data\n\
|
|
--innodb_flush_log_at_trx_commit[=#]\n\
|
|
Set to 0 if you don't want to flush logs\n\
|
|
--innodb_log_arch_dir=dir Where full logs should be archived\n\
|
|
--innodb_log_archive[=#] Set to 1 if you want to have logs archived\n\
|
|
--innodb_log_group_home_dir=dir Path to innodb log files.\n\
|
|
--skip-innodb Don't use Innodb (will save memory)\n\
|
|
");
|
|
#endif /* HAVE_INNOBASE_DB */
|
|
print_defaults("my",load_default_groups);
|
|
puts("");
|
|
|
|
#ifdef HAVE_OPENSSL
|
|
puts("\
|
|
--ssl Use SSL for connection (automatically set with other flags\n\
|
|
--ssl-key X509 key in PEM format (implies --ssl)\n\
|
|
--ssl-cert X509 cert in PEM format (implies --ssl)\n\
|
|
--ssl-ca CA file in PEM format (check OpenSSL docs, implies --ssl)\n\
|
|
--ssl-capath CA directory (check OpenSSL docs, implies --ssl)\n\
|
|
--ssl-cipher SSL cipher to use (implies --ssl)");
|
|
#endif
|
|
|
|
fix_paths();
|
|
set_ports();
|
|
printf("\
|
|
To see what values a running MySQL server is using, type\n\
|
|
'mysqladmin variables' instead of 'mysqld --help'.\n\
|
|
The default values (after parsing the command line arguments) are:\n\n");
|
|
|
|
printf("basedir: %s\n",mysql_home);
|
|
printf("datadir: %s\n",mysql_real_data_home);
|
|
printf("tmpdir: %s\n",mysql_tmpdir);
|
|
printf("language: %s\n",language);
|
|
#ifndef __WIN__
|
|
printf("pid file: %s\n",pidfile_name);
|
|
#endif
|
|
if (opt_logname)
|
|
printf("logfile: %s\n",opt_logname);
|
|
if (opt_update_logname)
|
|
printf("update log: %s\n",opt_update_logname);
|
|
if (opt_bin_log)
|
|
{
|
|
printf("binary log: %s\n",opt_bin_logname ? opt_bin_logname : "");
|
|
printf("binary log index: %s\n",
|
|
opt_binlog_index_name ? opt_binlog_index_name : "");
|
|
}
|
|
if (opt_slow_logname)
|
|
printf("update log: %s\n",opt_slow_logname);
|
|
printf("TCP port: %d\n",mysql_port);
|
|
#if defined(HAVE_SYS_UN_H)
|
|
printf("Unix socket: %s\n",mysql_unix_port);
|
|
#endif
|
|
if (my_disable_locking)
|
|
puts("\nsystem locking is not in use");
|
|
if (opt_noacl)
|
|
puts("\nGrant tables are not used. All users have full access rights");
|
|
printf("\nPossible variables for option --set-variable (-O) are:\n");
|
|
for (uint i=0 ; changeable_vars[i].name ; i++)
|
|
printf("%-20s current value: %lu\n",
|
|
changeable_vars[i].name,
|
|
(ulong) *changeable_vars[i].varptr);
|
|
}
|
|
|
|
|
|
static void set_options(void)
|
|
{
|
|
set_all_changeable_vars( changeable_vars );
|
|
#if !defined( my_pthread_setprio ) && !defined( HAVE_PTHREAD_SETSCHEDPARAM )
|
|
opt_specialflag |= SPECIAL_NO_PRIOR;
|
|
#endif
|
|
|
|
(void) strmake(default_charset, MYSQL_CHARSET, sizeof(default_charset)-1);
|
|
(void) strmake(language, LANGUAGE, sizeof(language)-1);
|
|
(void) strmake(mysql_real_data_home, get_relative_path(DATADIR),
|
|
sizeof(mysql_real_data_home-1));
|
|
#ifdef __WIN__
|
|
/* Allow Win32 users to move MySQL anywhere */
|
|
{
|
|
char prg_dev[LIBLEN];
|
|
my_path(prg_dev,my_progname,"mysql/bin");
|
|
strcat(prg_dev,"/../"); // Remove 'bin' to get base dir
|
|
cleanup_dirname(mysql_home,prg_dev);
|
|
}
|
|
#else
|
|
const char *tmpenv;
|
|
if (!(tmpenv = getenv("MY_BASEDIR_VERSION")))
|
|
tmpenv = DEFAULT_MYSQL_HOME;
|
|
(void) strmake(mysql_home, tmpenv, sizeof(mysql_home)-1);
|
|
#endif
|
|
|
|
#if defined( HAVE_mit_thread ) || defined( __WIN__ ) || defined( HAVE_LINUXTHREADS )
|
|
my_disable_locking=myisam_single_user= 1;
|
|
#endif
|
|
my_bind_addr = htonl( INADDR_ANY );
|
|
}
|
|
|
|
/* Initiates DEBUG - but no debugging here ! */
|
|
|
|
static void get_options(int argc,char **argv)
|
|
{
|
|
int c,option_index=0;
|
|
|
|
myisam_delay_key_write=1; // Allow use of this
|
|
#ifndef HAVE_purify
|
|
my_use_symdir=1; // Use internal symbolic links
|
|
#else
|
|
/* Symlinks gives too many warnings with purify */
|
|
my_disable_symlinks=1;
|
|
my_use_symdir=0;
|
|
have_symlink=SHOW_OPTION_DISABLED;
|
|
#endif
|
|
|
|
optind = 0; // setup in case getopt() was called previously
|
|
while ((c=getopt_long(argc,argv,"ab:C:h:#::T::?l::L:O:P:sS::t:u:noVvWI?",
|
|
long_options, &option_index)) != EOF)
|
|
{
|
|
switch(c) {
|
|
case '#':
|
|
#ifndef DBUG_OFF
|
|
DBUG_PUSH(optarg ? optarg : default_dbug_option);
|
|
#endif
|
|
opt_endinfo=1; /* unireg: memory allocation */
|
|
break;
|
|
case 'W':
|
|
opt_warnings=1;
|
|
break;
|
|
case 'a':
|
|
opt_sql_mode = (MODE_REAL_AS_FLOAT | MODE_PIPES_AS_CONCAT |
|
|
MODE_ANSI_QUOTES | MODE_IGNORE_SPACE | MODE_SERIALIZABLE
|
|
| MODE_ONLY_FULL_GROUP_BY);
|
|
default_tx_isolation= ISO_SERIALIZABLE;
|
|
break;
|
|
case 'b':
|
|
strmake(mysql_home,optarg,sizeof(mysql_home)-1);
|
|
break;
|
|
case 'l':
|
|
opt_log=1;
|
|
opt_logname=optarg; // Use hostname.log if null
|
|
break;
|
|
case 'h':
|
|
strmake(mysql_real_data_home,optarg, sizeof(mysql_real_data_home)-1);
|
|
break;
|
|
case 'L':
|
|
strmake(language, optarg, sizeof(language)-1);
|
|
break;
|
|
case 'n':
|
|
opt_specialflag|= SPECIAL_NEW_FUNC;
|
|
break;
|
|
case 'o':
|
|
protocol_version=PROTOCOL_VERSION-1;
|
|
break;
|
|
case 'O':
|
|
if (set_changeable_var(optarg, changeable_vars))
|
|
{
|
|
use_help();
|
|
exit(1);
|
|
}
|
|
break;
|
|
case 'P':
|
|
mysql_port= (unsigned int) atoi(optarg);
|
|
break;
|
|
case OPT_LOCAL_INFILE:
|
|
opt_local_infile= test(!optarg || atoi(optarg) != 0);
|
|
break;
|
|
case OPT_SLAVE_SKIP_ERRORS:
|
|
init_slave_skip_errors(optarg);
|
|
break;
|
|
case OPT_SAFEMALLOC_MEM_LIMIT:
|
|
#if !defined(DBUG_OFF) && defined(SAFEMALLOC)
|
|
safemalloc_mem_limit = atoi(optarg);
|
|
#endif
|
|
break;
|
|
case OPT_RPL_RECOVERY_RANK:
|
|
rpl_recovery_rank=atoi(optarg);
|
|
break;
|
|
case OPT_SLAVE_LOAD_TMPDIR:
|
|
slave_load_tmpdir = my_strdup(optarg, MYF(MY_FAE));
|
|
break;
|
|
case OPT_OLD_RPL_COMPAT:
|
|
opt_old_rpl_compat = 1;
|
|
break;
|
|
case OPT_SHOW_SLAVE_AUTH_INFO:
|
|
opt_show_slave_auth_info = 1;
|
|
break;
|
|
case OPT_SOCKET:
|
|
mysql_unix_port= optarg;
|
|
break;
|
|
case 'r':
|
|
mysqld_chroot=optarg;
|
|
break;
|
|
#ifdef USE_SYMDIR
|
|
case 's':
|
|
my_use_symdir=1; /* Use internal symbolic links */
|
|
break;
|
|
#endif
|
|
case 't':
|
|
mysql_tmpdir=optarg;
|
|
break;
|
|
case OPT_TEMP_POOL:
|
|
use_temp_pool=1;
|
|
break;
|
|
case 'u':
|
|
mysqld_user=optarg;
|
|
break;
|
|
case 'v':
|
|
case 'V':
|
|
print_version();
|
|
exit(0);
|
|
case 'I':
|
|
case '?':
|
|
usage();
|
|
exit(0);
|
|
case 'T':
|
|
test_flags= optarg ? (uint) atoi(optarg) : 0;
|
|
opt_endinfo=1;
|
|
break;
|
|
case (int) OPT_BIG_TABLES:
|
|
thd_startup_options|=OPTION_BIG_TABLES;
|
|
break;
|
|
case (int) OPT_ISAM_LOG:
|
|
opt_myisam_log=1;
|
|
if (optarg)
|
|
myisam_log_filename=optarg;
|
|
break;
|
|
case (int) OPT_UPDATE_LOG:
|
|
opt_update_log=1;
|
|
opt_update_logname=optarg; // Use hostname.# if null
|
|
break;
|
|
case (int) OPT_RELAY_LOG_INDEX:
|
|
opt_relaylog_index_name = optarg;
|
|
break;
|
|
case (int) OPT_RELAY_LOG:
|
|
x_free(opt_relay_logname);
|
|
if (optarg && optarg[0])
|
|
opt_relay_logname=my_strdup(optarg,MYF(0));
|
|
break;
|
|
case (int) OPT_BIN_LOG_INDEX:
|
|
opt_binlog_index_name = optarg;
|
|
break;
|
|
case (int) OPT_BIN_LOG:
|
|
opt_bin_log=1;
|
|
x_free(opt_bin_logname);
|
|
if (optarg && optarg[0])
|
|
opt_bin_logname=my_strdup(optarg,MYF(0));
|
|
break;
|
|
// needs to be handled (as no-op) in non-debugging mode for test suite
|
|
case (int)OPT_DISCONNECT_SLAVE_EVENT_COUNT:
|
|
#ifndef DBUG_OFF
|
|
disconnect_slave_event_count = atoi(optarg);
|
|
#endif
|
|
break;
|
|
case (int)OPT_ABORT_SLAVE_EVENT_COUNT:
|
|
#ifndef DBUG_OFF
|
|
abort_slave_event_count = atoi(optarg);
|
|
#endif
|
|
break;
|
|
case (int)OPT_SPORADIC_BINLOG_DUMP_FAIL:
|
|
#ifndef DBUG_OFF
|
|
opt_sporadic_binlog_dump_fail = 1;
|
|
#endif
|
|
break;
|
|
case (int)OPT_MAX_BINLOG_DUMP_EVENTS:
|
|
#ifndef DBUG_OFF
|
|
max_binlog_dump_events = atoi(optarg);
|
|
#endif
|
|
break;
|
|
|
|
case (int) OPT_LOG_SLAVE_UPDATES:
|
|
opt_log_slave_updates = 1;
|
|
break;
|
|
|
|
case (int) OPT_INIT_RPL_ROLE:
|
|
{
|
|
int role;
|
|
if ((role=find_type(optarg, &rpl_role_typelib, 2)) <= 0)
|
|
{
|
|
fprintf(stderr, "Unknown replication role: %s\n", optarg);
|
|
exit(1);
|
|
}
|
|
rpl_status = (role == 1) ? RPL_AUTH_MASTER : RPL_IDLE_SLAVE;
|
|
break;
|
|
}
|
|
case (int)OPT_REPLICATE_IGNORE_DB:
|
|
{
|
|
i_string *db = new i_string(optarg);
|
|
replicate_ignore_db.push_back(db);
|
|
break;
|
|
}
|
|
case (int)OPT_REPLICATE_DO_DB:
|
|
{
|
|
i_string *db = new i_string(optarg);
|
|
replicate_do_db.push_back(db);
|
|
break;
|
|
}
|
|
case (int)OPT_REPLICATE_REWRITE_DB:
|
|
{
|
|
char* key = optarg,*p, *val;
|
|
p = strstr(optarg, "->");
|
|
if (!p)
|
|
{
|
|
fprintf(stderr,
|
|
"Bad syntax in replicate-rewrite-db - missing '->'!\n");
|
|
exit(1);
|
|
}
|
|
val = p--;
|
|
while(my_isspace(system_charset_info,*p) && p > optarg) *p-- = 0;
|
|
if(p == optarg)
|
|
{
|
|
fprintf(stderr,
|
|
"Bad syntax in replicate-rewrite-db - empty FROM db!\n");
|
|
exit(1);
|
|
}
|
|
*val = 0;
|
|
val += 2;
|
|
while(*val && my_isspace(system_charset_info,*val)) *val++;
|
|
if (!*val)
|
|
{
|
|
fprintf(stderr,
|
|
"Bad syntax in replicate-rewrite-db - empty TO db!\n");
|
|
exit(1);
|
|
}
|
|
|
|
i_string_pair* db_pair = new i_string_pair(key, val);
|
|
replicate_rewrite_db.push_back(db_pair);
|
|
break;
|
|
}
|
|
|
|
case (int)OPT_BINLOG_IGNORE_DB:
|
|
{
|
|
i_string *db = new i_string(optarg);
|
|
binlog_ignore_db.push_back(db);
|
|
break;
|
|
}
|
|
case (int)OPT_BINLOG_DO_DB:
|
|
{
|
|
i_string *db = new i_string(optarg);
|
|
binlog_do_db.push_back(db);
|
|
break;
|
|
}
|
|
case (int)OPT_REPLICATE_DO_TABLE:
|
|
{
|
|
if (!do_table_inited)
|
|
init_table_rule_hash(&replicate_do_table, &do_table_inited);
|
|
if(add_table_rule(&replicate_do_table, optarg))
|
|
{
|
|
fprintf(stderr, "Could not add do table rule '%s'!\n", optarg);
|
|
exit(1);
|
|
}
|
|
table_rules_on = 1;
|
|
break;
|
|
}
|
|
case (int)OPT_REPLICATE_WILD_DO_TABLE:
|
|
{
|
|
if (!wild_do_table_inited)
|
|
init_table_rule_array(&replicate_wild_do_table,
|
|
&wild_do_table_inited);
|
|
if(add_wild_table_rule(&replicate_wild_do_table, optarg))
|
|
{
|
|
fprintf(stderr, "Could not add do table rule '%s'!\n", optarg);
|
|
exit(1);
|
|
}
|
|
table_rules_on = 1;
|
|
break;
|
|
}
|
|
case (int)OPT_REPLICATE_WILD_IGNORE_TABLE:
|
|
{
|
|
if (!wild_ignore_table_inited)
|
|
init_table_rule_array(&replicate_wild_ignore_table,
|
|
&wild_ignore_table_inited);
|
|
if(add_wild_table_rule(&replicate_wild_ignore_table, optarg))
|
|
{
|
|
fprintf(stderr, "Could not add ignore table rule '%s'!\n", optarg);
|
|
exit(1);
|
|
}
|
|
table_rules_on = 1;
|
|
break;
|
|
}
|
|
case (int)OPT_REPLICATE_IGNORE_TABLE:
|
|
{
|
|
if (!ignore_table_inited)
|
|
init_table_rule_hash(&replicate_ignore_table, &ignore_table_inited);
|
|
if(add_table_rule(&replicate_ignore_table, optarg))
|
|
{
|
|
fprintf(stderr, "Could not add ignore table rule '%s'!\n", optarg);
|
|
exit(1);
|
|
}
|
|
table_rules_on = 1;
|
|
break;
|
|
}
|
|
case (int) OPT_SQL_BIN_UPDATE_SAME:
|
|
opt_sql_bin_update = 1;
|
|
break;
|
|
case (int) OPT_SLOW_QUERY_LOG:
|
|
opt_slow_log=1;
|
|
opt_slow_logname=optarg;
|
|
break;
|
|
case (int)OPT_SKIP_SLAVE_START:
|
|
opt_skip_slave_start = 1;
|
|
break;
|
|
case (int) OPT_SKIP_NEW:
|
|
opt_specialflag|= SPECIAL_NO_NEW_FUNC;
|
|
myisam_delay_key_write=0;
|
|
myisam_concurrent_insert=0;
|
|
myisam_recover_options= HA_RECOVER_NONE;
|
|
my_disable_symlinks=1;
|
|
my_use_symdir=0;
|
|
have_symlink=SHOW_OPTION_DISABLED;
|
|
ha_open_options&= ~HA_OPEN_ABORT_IF_CRASHED;
|
|
#ifdef HAVE_QUERY_CACHE
|
|
query_cache_size=0;
|
|
#endif
|
|
break;
|
|
case (int) OPT_SAFE:
|
|
opt_specialflag|= SPECIAL_SAFE_MODE;
|
|
myisam_delay_key_write=0;
|
|
myisam_recover_options= HA_RECOVER_NONE; // To be changed
|
|
ha_open_options&= ~HA_OPEN_ABORT_IF_CRASHED;
|
|
break;
|
|
case (int) OPT_SKIP_CONCURRENT_INSERT:
|
|
myisam_concurrent_insert=0;
|
|
break;
|
|
case (int) OPT_SKIP_PRIOR:
|
|
opt_specialflag|= SPECIAL_NO_PRIOR;
|
|
break;
|
|
case (int) OPT_SKIP_GRANT:
|
|
opt_noacl=1;
|
|
break;
|
|
case (int) OPT_SKIP_LOCK:
|
|
my_disable_locking=myisam_single_user= 1;
|
|
break;
|
|
case (int) OPT_SKIP_HOST_CACHE:
|
|
opt_specialflag|= SPECIAL_NO_HOST_CACHE;
|
|
break;
|
|
case (int) OPT_ENABLE_LOCK:
|
|
my_disable_locking=myisam_single_user=0;
|
|
break;
|
|
case (int) OPT_USE_LOCKING:
|
|
my_disable_locking=0;
|
|
break;
|
|
case (int) OPT_SKIP_RESOLVE:
|
|
opt_specialflag|=SPECIAL_NO_RESOLVE;
|
|
break;
|
|
case (int) OPT_LONG_FORMAT:
|
|
opt_specialflag|=SPECIAL_LONG_LOG_FORMAT;
|
|
break;
|
|
case (int) OPT_NO_MIX_TYPE:
|
|
opt_no_mix_types = 1;
|
|
break;
|
|
case (int) OPT_SKIP_NETWORKING:
|
|
opt_disable_networking=1;
|
|
mysql_port=0;
|
|
break;
|
|
case (int) OPT_SKIP_SHOW_DB:
|
|
opt_skip_show_db=1;
|
|
opt_specialflag|=SPECIAL_SKIP_SHOW_DB;
|
|
mysql_port=0;
|
|
break;
|
|
case (int) OPT_MEMLOCK:
|
|
locked_in_memory=1;
|
|
break;
|
|
case (int) OPT_ONE_THREAD:
|
|
test_flags |= TEST_NO_THREADS;
|
|
break;
|
|
case (int) OPT_WANT_CORE:
|
|
test_flags |= TEST_CORE_ON_SIGNAL;
|
|
break;
|
|
case (int) OPT_SKIP_STACK_TRACE:
|
|
test_flags|=TEST_NO_STACKTRACE;
|
|
break;
|
|
case (int) OPT_SKIP_SYMLINKS:
|
|
my_disable_symlinks=1;
|
|
my_use_symdir=0;
|
|
have_symlink=SHOW_OPTION_DISABLED;
|
|
break;
|
|
case (int) OPT_BIND_ADDRESS:
|
|
if (optarg && my_isdigit(system_charset_info,optarg[0]))
|
|
{
|
|
my_bind_addr = (ulong) inet_addr(optarg);
|
|
}
|
|
else
|
|
{
|
|
struct hostent *ent;
|
|
if (!optarg || !optarg[0])
|
|
ent=gethostbyname(optarg);
|
|
else
|
|
{
|
|
char myhostname[255];
|
|
if (gethostname(myhostname,sizeof(myhostname)) < 0)
|
|
{
|
|
sql_perror("Can't start server: cannot get my own hostname!");
|
|
exit(1);
|
|
}
|
|
ent=gethostbyname(myhostname);
|
|
}
|
|
if (!ent)
|
|
{
|
|
sql_perror("Can't start server: cannot resolve hostname!");
|
|
exit(1);
|
|
}
|
|
my_bind_addr = (ulong) ((in_addr*)ent->h_addr_list[0])->s_addr;
|
|
}
|
|
break;
|
|
case (int) OPT_PID_FILE:
|
|
strmake(pidfile_name, optarg, sizeof(pidfile_name)-1);
|
|
break;
|
|
case (int) OPT_INIT_FILE:
|
|
opt_init_file=optarg;
|
|
break;
|
|
case (int) OPT_HAVE_NAMED_PIPE:
|
|
#if __NT__
|
|
opt_enable_named_pipe=1;
|
|
#endif
|
|
break;
|
|
#ifdef __WIN__
|
|
case (int) OPT_STANDALONE: /* Dummy option for NT */
|
|
break;
|
|
case (int) OPT_CONSOLE:
|
|
opt_console=1;
|
|
break;
|
|
#endif
|
|
case (int) OPT_FLUSH:
|
|
#ifdef HAVE_ISAM
|
|
nisam_flush=1;
|
|
#endif
|
|
myisam_flush=1;
|
|
flush_time=0; // No auto flush
|
|
break;
|
|
case OPT_LOW_PRIORITY_UPDATES:
|
|
thd_startup_options|=OPTION_LOW_PRIORITY_UPDATES;
|
|
thr_upgraded_concurrent_insert_lock= TL_WRITE_LOW_PRIORITY;
|
|
low_priority_updates=1;
|
|
break;
|
|
case OPT_BOOTSTRAP:
|
|
opt_noacl=opt_bootstrap=1;
|
|
break;
|
|
case OPT_TABLE_TYPE:
|
|
{
|
|
int type;
|
|
if ((type=find_type(optarg, &ha_table_typelib, 2)) <= 0)
|
|
{
|
|
fprintf(stderr,"Unknown table type: %s\n",optarg);
|
|
exit(1);
|
|
}
|
|
default_table_type= (enum db_type) type;
|
|
break;
|
|
}
|
|
case OPT_SERVER_ID:
|
|
server_id = atoi(optarg);
|
|
server_id_supplied = 1;
|
|
break;
|
|
case OPT_DELAY_KEY_WRITE:
|
|
ha_open_options|=HA_OPEN_DELAY_KEY_WRITE;
|
|
myisam_delay_key_write=1;
|
|
break;
|
|
case OPT_SKIP_DELAY_KEY_WRITE:
|
|
myisam_delay_key_write=0;
|
|
break;
|
|
case 'C':
|
|
strmake(default_charset, optarg, sizeof(default_charset)-1);
|
|
break;
|
|
case OPT_CHARSETS_DIR:
|
|
strmake(mysql_charsets_dir, optarg, sizeof(mysql_charsets_dir)-1);
|
|
charsets_dir = mysql_charsets_dir;
|
|
break;
|
|
#ifdef HAVE_OPENSSL
|
|
case OPT_SSL_SSL:
|
|
opt_use_ssl = 1; /* true */
|
|
break;
|
|
case OPT_SSL_KEY:
|
|
opt_use_ssl = 1; /* true */
|
|
my_free(opt_ssl_key, MYF(MY_ALLOW_ZERO_PTR));
|
|
opt_ssl_key = my_strdup(optarg, MYF(0));
|
|
break;
|
|
case OPT_SSL_CERT:
|
|
opt_use_ssl = 1; /* true */
|
|
my_free(opt_ssl_cert, MYF(MY_ALLOW_ZERO_PTR));
|
|
opt_ssl_cert = my_strdup(optarg, MYF(0));
|
|
break;
|
|
case OPT_SSL_CA:
|
|
opt_use_ssl = 1; /* true */
|
|
my_free(opt_ssl_ca, MYF(MY_ALLOW_ZERO_PTR));
|
|
opt_ssl_ca = my_strdup(optarg, MYF(0));
|
|
break;
|
|
case OPT_SSL_CAPATH:
|
|
opt_use_ssl = 1; /* true */
|
|
my_free(opt_ssl_capath, MYF(MY_ALLOW_ZERO_PTR));
|
|
opt_ssl_capath = my_strdup(optarg, MYF(0));
|
|
break;
|
|
case OPT_SSL_CIPHER:
|
|
opt_use_ssl = 1; /* true */
|
|
my_free(opt_ssl_cipher, MYF(MY_ALLOW_ZERO_PTR));
|
|
opt_ssl_cipher = my_strdup(optarg, MYF(0));
|
|
break;
|
|
#endif
|
|
case OPT_DES_KEY_FILE:
|
|
#ifdef HAVE_OPENSSL
|
|
des_key_file=optarg;
|
|
#endif
|
|
break;
|
|
case OPT_TX_ISOLATION:
|
|
{
|
|
int type;
|
|
if ((type=find_type(optarg, &tx_isolation_typelib, 2)) <= 0)
|
|
{
|
|
fprintf(stderr,"Unknown transaction isolation type: %s\n",optarg);
|
|
exit(1);
|
|
}
|
|
default_tx_isolation= (enum_tx_isolation) (type-1);
|
|
break;
|
|
}
|
|
#ifdef HAVE_BERKELEY_DB
|
|
case OPT_BDB_LOG:
|
|
berkeley_logdir=optarg;
|
|
break;
|
|
case OPT_BDB_HOME:
|
|
berkeley_home=optarg;
|
|
break;
|
|
case OPT_BDB_NOSYNC:
|
|
berkeley_env_flags|=DB_TXN_NOSYNC;
|
|
break;
|
|
case OPT_BDB_NO_RECOVER:
|
|
berkeley_init_flags&= ~(DB_RECOVER);
|
|
break;
|
|
case OPT_BDB_TMP:
|
|
berkeley_tmpdir=optarg;
|
|
break;
|
|
case OPT_BDB_LOCK:
|
|
{
|
|
int type;
|
|
if ((type=find_type(optarg, &berkeley_lock_typelib, 2)) > 0)
|
|
berkeley_lock_type=berkeley_lock_types[type-1];
|
|
else
|
|
{
|
|
if (test_if_int(optarg,(uint) strlen(optarg)))
|
|
berkeley_lock_scan_time=atoi(optarg);
|
|
else
|
|
{
|
|
fprintf(stderr,"Unknown lock type: %s\n",optarg);
|
|
exit(1);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case OPT_BDB_SHARED:
|
|
berkeley_init_flags&= ~(DB_PRIVATE);
|
|
berkeley_shared_data=1;
|
|
break;
|
|
#endif /* HAVE_BERKELEY_DB */
|
|
case OPT_BDB_SKIP:
|
|
#ifdef HAVE_BERKELEY_DB
|
|
berkeley_skip=1;
|
|
have_berkeley_db=SHOW_OPTION_DISABLED;
|
|
#endif
|
|
break;
|
|
case OPT_INNODB_SKIP:
|
|
#ifdef HAVE_INNOBASE_DB
|
|
innodb_skip=1;
|
|
have_innodb=SHOW_OPTION_DISABLED;
|
|
#endif
|
|
break;
|
|
case OPT_INNODB_DATA_FILE_PATH:
|
|
#ifdef HAVE_INNOBASE_DB
|
|
innobase_data_file_path=optarg;
|
|
#endif
|
|
break;
|
|
#ifdef HAVE_INNOBASE_DB
|
|
case OPT_INNODB_DATA_HOME_DIR:
|
|
innobase_data_home_dir=optarg;
|
|
break;
|
|
case OPT_INNODB_LOG_GROUP_HOME_DIR:
|
|
innobase_log_group_home_dir=optarg;
|
|
break;
|
|
case OPT_INNODB_LOG_ARCH_DIR:
|
|
innobase_log_arch_dir=optarg;
|
|
break;
|
|
case OPT_INNODB_LOG_ARCHIVE:
|
|
innobase_log_archive= optarg ? test(atoi(optarg)) : 1;
|
|
break;
|
|
case OPT_INNODB_FLUSH_LOG_AT_TRX_COMMIT:
|
|
innobase_flush_log_at_trx_commit= optarg ? test(atoi(optarg)) : 1;
|
|
break;
|
|
case OPT_INNODB_FAST_SHUTDOWN:
|
|
innobase_fast_shutdown= optarg ? test(atoi(optarg)) : 1;
|
|
break;
|
|
case OPT_INNODB_FLUSH_METHOD:
|
|
innobase_unix_file_flush_method=optarg;
|
|
break;
|
|
#endif /* HAVE_INNOBASE_DB */
|
|
case OPT_DO_PSTACK:
|
|
opt_do_pstack = 1;
|
|
break;
|
|
case OPT_MYISAM_RECOVER:
|
|
{
|
|
if (!optarg || !optarg[0])
|
|
{
|
|
myisam_recover_options= HA_RECOVER_DEFAULT;
|
|
myisam_recover_options_str= myisam_recover_typelib.type_names[0];
|
|
}
|
|
else
|
|
{
|
|
myisam_recover_options_str=optarg;
|
|
if ((myisam_recover_options=
|
|
find_bit_type(optarg, &myisam_recover_typelib)) == ~(ulong) 0)
|
|
{
|
|
fprintf(stderr, "Unknown option to myisam-recover: %s\n",optarg);
|
|
exit(1);
|
|
}
|
|
}
|
|
ha_open_options|=HA_OPEN_ABORT_IF_CRASHED;
|
|
break;
|
|
}
|
|
case OPT_SQL_MODE:
|
|
{
|
|
sql_mode_str = optarg;
|
|
if ((opt_sql_mode =
|
|
find_bit_type(optarg, &sql_mode_typelib)) == ~(ulong) 0)
|
|
{
|
|
fprintf(stderr, "Unknown option to sql-mode: %s\n", optarg);
|
|
exit(1);
|
|
}
|
|
default_tx_isolation= ((opt_sql_mode & MODE_SERIALIZABLE) ?
|
|
ISO_SERIALIZABLE :
|
|
ISO_READ_COMMITTED);
|
|
break;
|
|
}
|
|
case OPT_MASTER_HOST:
|
|
master_host=optarg;
|
|
break;
|
|
case OPT_MASTER_USER:
|
|
master_user=optarg;
|
|
break;
|
|
case OPT_MASTER_PASSWORD:
|
|
master_password=optarg;
|
|
break;
|
|
case OPT_MASTER_INFO_FILE:
|
|
master_info_file=optarg;
|
|
break;
|
|
case OPT_RELAY_LOG_INFO_FILE:
|
|
relay_log_info_file=optarg;
|
|
break;
|
|
case OPT_MASTER_PORT:
|
|
master_port= atoi(optarg);
|
|
break;
|
|
case OPT_MASTER_SSL:
|
|
master_ssl=atoi(optarg);
|
|
break;
|
|
case OPT_MASTER_SSL_KEY:
|
|
master_ssl_key=optarg;
|
|
break;
|
|
case OPT_MASTER_SSL_CERT:
|
|
master_ssl_cert=optarg;
|
|
break;
|
|
case OPT_REPORT_HOST:
|
|
report_host=optarg;
|
|
break;
|
|
case OPT_REPORT_USER:
|
|
report_user=optarg;
|
|
break;
|
|
case OPT_REPORT_PASSWORD:
|
|
report_password=optarg;
|
|
break;
|
|
case OPT_REPORT_PORT:
|
|
report_port= atoi(optarg);
|
|
break;
|
|
case OPT_MASTER_CONNECT_RETRY:
|
|
master_connect_retry= atoi(optarg);
|
|
break;
|
|
case OPT_MASTER_RETRY_COUNT:
|
|
master_retry_count= atoi(optarg);
|
|
break;
|
|
case OPT_SAFE_SHOW_DB:
|
|
opt_safe_show_db=1;
|
|
break;
|
|
case OPT_SAFE_USER_CREATE:
|
|
opt_safe_user_create=1;
|
|
break;
|
|
case OPT_SKIP_SAFEMALLOC:
|
|
#ifdef SAFEMALLOC
|
|
sf_malloc_quick=1;
|
|
#endif
|
|
break;
|
|
default:
|
|
fprintf(stderr,"%s: Unrecognized option: %c\n",my_progname,c);
|
|
use_help();
|
|
exit(1);
|
|
}
|
|
}
|
|
// Skip empty arguments (from shell)
|
|
while (argc != optind && !argv[optind][0])
|
|
optind++;
|
|
if (argc != optind)
|
|
{
|
|
fprintf(stderr,"%s: Too many parameters\n",my_progname);
|
|
use_help();
|
|
exit(1);
|
|
}
|
|
optind = 0; // setup so that getopt_long() can be called again
|
|
fix_paths();
|
|
default_table_type_name=ha_table_typelib.type_names[default_table_type-1];
|
|
default_tx_isolation_name=tx_isolation_typelib.type_names[default_tx_isolation];
|
|
/* To be deleted in MySQL 4.0 */
|
|
if (!record_rnd_cache_size)
|
|
record_rnd_cache_size=my_default_record_cache_size;
|
|
|
|
/* Fix variables that are base 1024*1024 */
|
|
myisam_max_temp_length= (my_off_t) min(((ulonglong) myisam_max_sort_file_size)*1024*1024, (ulonglong) MAX_FILE_SIZE);
|
|
myisam_max_extra_temp_length= (my_off_t) min(((ulonglong) myisam_max_extra_sort_file_size)*1024*1024, (ulonglong) MAX_FILE_SIZE);
|
|
|
|
myisam_block_size=(uint) 1 << my_bit_log2(opt_myisam_block_size);
|
|
}
|
|
|
|
|
|
static char *get_relative_path(const char *path)
|
|
{
|
|
if (test_if_hard_path(path) &&
|
|
is_prefix(path,DEFAULT_MYSQL_HOME) &&
|
|
strcmp(DEFAULT_MYSQL_HOME,FN_ROOTDIR))
|
|
{
|
|
path+=(uint) strlen(DEFAULT_MYSQL_HOME);
|
|
while (*path == FN_LIBCHAR)
|
|
path++;
|
|
}
|
|
return (char*) path;
|
|
}
|
|
|
|
|
|
/*
|
|
Fix filename and replace extension where 'dir' is relative to
|
|
mysql_real_data_home.
|
|
Return 1 if len(path) > FN_REFLEN
|
|
*/
|
|
|
|
bool
|
|
fn_format_relative_to_data_home(my_string to, const char *name,
|
|
const char *dir, const char *extension)
|
|
{
|
|
char tmp_path[FN_REFLEN];
|
|
if (!test_if_hard_path(dir))
|
|
{
|
|
strxnmov(tmp_path,sizeof(tmp_path)-1, mysql_real_data_home,
|
|
dir, NullS);
|
|
dir=tmp_path;
|
|
}
|
|
return !fn_format(to, name, dir, extension,
|
|
MY_REPLACE_EXT | MY_UNPACK_FILENAME | MY_SAFE_PATH);
|
|
}
|
|
|
|
|
|
static void fix_paths(void)
|
|
{
|
|
(void) fn_format(mysql_home,mysql_home,"","",16); // Remove symlinks
|
|
convert_dirname(mysql_home,mysql_home,NullS);
|
|
convert_dirname(mysql_real_data_home,mysql_real_data_home,NullS);
|
|
convert_dirname(language,language,NullS);
|
|
(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);
|
|
|
|
char buff[FN_REFLEN],*sharedir=get_relative_path(SHAREDIR);
|
|
if (test_if_hard_path(sharedir))
|
|
strmake(buff,sharedir,sizeof(buff)-1); /* purecov: tested */
|
|
else
|
|
strxnmov(buff,sizeof(buff)-1,mysql_home,sharedir,NullS);
|
|
convert_dirname(buff,buff,NullS);
|
|
(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,
|
|
CHARSET_DIR, NullS);
|
|
charsets_dir=mysql_charsets_dir;
|
|
}
|
|
|
|
/* Add '/' to TMPDIR if needed */
|
|
char *tmp= (char*) my_malloc(FN_REFLEN,MYF(MY_FAE));
|
|
if (tmp)
|
|
{
|
|
char *end=convert_dirname(tmp, mysql_tmpdir, NullS);
|
|
|
|
mysql_tmpdir=(char*) my_realloc(tmp,(uint) (end-tmp)+1,
|
|
MYF(MY_HOLD_ON_ERROR));
|
|
allocated_mysql_tmpdir=mysql_tmpdir;
|
|
}
|
|
if (!slave_load_tmpdir)
|
|
{
|
|
// no need to check return value, if we fail, my_malloc() never returns
|
|
slave_load_tmpdir = (char*) my_strdup(mysql_tmpdir, MYF(MY_FAE));
|
|
}
|
|
}
|
|
|
|
|
|
#ifdef SET_RLIMIT_NOFILE
|
|
static uint set_maximum_open_files(uint max_file_limit)
|
|
{
|
|
struct rlimit rlimit;
|
|
ulong old_cur;
|
|
|
|
if (!getrlimit(RLIMIT_NOFILE,&rlimit))
|
|
{
|
|
old_cur=rlimit.rlim_cur;
|
|
if (rlimit.rlim_cur >= max_file_limit) // Nothing to do
|
|
return rlimit.rlim_cur; /* purecov: inspected */
|
|
rlimit.rlim_cur=rlimit.rlim_max=max_file_limit;
|
|
if (setrlimit(RLIMIT_NOFILE,&rlimit))
|
|
{
|
|
sql_print_error("Warning: setrlimit couldn't increase number of open files to more than %lu (request: %u)",
|
|
old_cur, max_file_limit); /* purecov: inspected */
|
|
max_file_limit=old_cur;
|
|
}
|
|
else
|
|
{
|
|
(void) getrlimit(RLIMIT_NOFILE,&rlimit);
|
|
if ((uint) rlimit.rlim_cur != max_file_limit)
|
|
sql_print_error("Warning: setrlimit returned ok, but didn't change limits. Max open files is %ld (request: %u)",
|
|
(ulong) rlimit.rlim_cur,
|
|
max_file_limit); /* purecov: inspected */
|
|
max_file_limit=rlimit.rlim_cur;
|
|
}
|
|
}
|
|
return max_file_limit;
|
|
}
|
|
#endif
|
|
|
|
#ifdef OS2
|
|
static uint set_maximum_open_files(uint max_file_limit)
|
|
{
|
|
LONG cbReqCount;
|
|
ULONG cbCurMaxFH, cbCurMaxFH0;
|
|
APIRET ulrc;
|
|
|
|
// get current limit
|
|
cbReqCount = 0;
|
|
DosSetRelMaxFH( &cbReqCount, &cbCurMaxFH0);
|
|
|
|
// set new limit
|
|
cbReqCount = max_file_limit - cbCurMaxFH0;
|
|
ulrc = DosSetRelMaxFH( &cbReqCount, &cbCurMaxFH);
|
|
if (ulrc) {
|
|
sql_print_error("Warning: DosSetRelMaxFH couldn't increase number of open files to more than %d",
|
|
cbCurMaxFH0);
|
|
cbCurMaxFH = cbCurMaxFH0;
|
|
}
|
|
|
|
return cbCurMaxFH;
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
Return a bitfield from a string of substrings separated by ','
|
|
returns ~(ulong) 0 on error.
|
|
*/
|
|
|
|
static ulong find_bit_type(const char *x, TYPELIB *bit_lib)
|
|
{
|
|
bool found_end;
|
|
int found_count;
|
|
const char *end,*i,*j;
|
|
const char **array, *pos;
|
|
ulong found,found_int,bit;
|
|
DBUG_ENTER("find_bit_type");
|
|
DBUG_PRINT("enter",("x: '%s'",x));
|
|
|
|
found=0;
|
|
found_end= 0;
|
|
pos=(my_string) x;
|
|
while (*pos == ' ') pos++;
|
|
found_end= *pos == 0;
|
|
while (!found_end)
|
|
{
|
|
if (!*(end=strcend(pos,','))) /* Let end point at fieldend */
|
|
{
|
|
while (end > pos && end[-1] == ' ')
|
|
end--; /* Skip end-space */
|
|
found_end=1;
|
|
}
|
|
found_int=0; found_count=0;
|
|
for (array=bit_lib->type_names, bit=1 ; (i= *array++) ; bit<<=1)
|
|
{
|
|
j=pos;
|
|
while (j != end)
|
|
{
|
|
if (my_toupper(system_charset_info,*i++) !=
|
|
my_toupper(system_charset_info,*j++))
|
|
goto skipp;
|
|
}
|
|
found_int=bit;
|
|
if (! *i)
|
|
{
|
|
found_count=1;
|
|
break;
|
|
}
|
|
else if (j != pos) // Half field found
|
|
{
|
|
found_count++; // Could be one of two values
|
|
}
|
|
skipp: ;
|
|
}
|
|
if (found_count != 1)
|
|
DBUG_RETURN(~(ulong) 0); // No unique value
|
|
found|=found_int;
|
|
pos=end+1;
|
|
}
|
|
|
|
DBUG_PRINT("exit",("bit-field: %ld",(ulong) found));
|
|
DBUG_RETURN(found);
|
|
} /* find_bit_type */
|
|
|
|
|
|
/*****************************************************************************
|
|
** Instantiate templates
|
|
*****************************************************************************/
|
|
|
|
#ifdef __GNUC__
|
|
/* Used templates */
|
|
template class I_List<THD>;
|
|
template class I_List_iterator<THD>;
|
|
template class I_List<i_string>;
|
|
template class I_List<i_string_pair>;
|
|
#endif
|