mysqld.cc 297 KB
Newer Older
unknown's avatar
unknown committed
1
/* Copyright (C) 2000-2003 MySQL AB
2

unknown's avatar
unknown committed
3 4 5 6
   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.
7

unknown's avatar
unknown committed
8 9 10 11
   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.
12

unknown's avatar
unknown committed
13 14 15 16 17 18
   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 <m_ctype.h>
19
#include <my_dir.h>
20
#include "slave.h"
21
#include "sql_repl.h"
unknown's avatar
unknown committed
22
#include "rpl_filter.h"
23
#include "repl_failsafe.h"
unknown's avatar
unknown committed
24
#include "stacktrace.h"
25
#include "mysqld_suffix.h"
unknown's avatar
Merge  
unknown committed
26
#include "mysys_err.h"
27
#include "event.h"
28

unknown's avatar
unknown committed
29
#include "ha_myisam.h"
30

31
#ifdef WITH_INNOBASE_STORAGE_ENGINE
32 33 34 35 36
#define OPT_INNODB_DEFAULT 1
#else
#define OPT_INNODB_DEFAULT 0
#endif
#define OPT_BDB_DEFAULT 0
37
#ifdef WITH_NDBCLUSTER_STORAGE_ENGINE
38
#define OPT_NDBCLUSTER_DEFAULT 0
unknown's avatar
Merge  
unknown committed
39 40
#if defined(NOT_ENOUGH_TESTED) \
  && defined(NDB_SHM_TRANSPORTER) && MYSQL_VERSION_ID >= 50000
41 42 43 44
#define OPT_NDB_SHM_DEFAULT 1
#else
#define OPT_NDB_SHM_DEFAULT 0
#endif
45 46 47 48
#else
#define OPT_NDBCLUSTER_DEFAULT 0
#endif

unknown's avatar
unknown committed
49 50
#include <thr_alarm.h>
#include <ft_global.h>
51
#include <errmsg.h>
unknown's avatar
Merge  
unknown committed
52 53
#include "sp_rcontext.h"
#include "sp_cache.h"
unknown's avatar
unknown committed
54

unknown's avatar
unknown committed
55
#define mysqld_charset &my_charset_latin1
unknown's avatar
unknown committed
56

57 58 59 60
#ifndef DBUG_OFF
#define ONE_THREAD
#endif

unknown's avatar
unknown committed
61
#ifdef HAVE_purify
62 63 64 65 66
#define IF_PURIFY(A,B) (A)
#else
#define IF_PURIFY(A,B) (B)
#endif

67
/* stack traces are only supported on linux intel */
68 69 70 71 72 73
#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__ */

74 75 76
/* We have HAVE_purify below as this speeds up the shutdown of MySQL */

#if defined(HAVE_DEC_3_2_THREADS) || defined(SIGNALS_DONT_BREAK_READ) || defined(HAVE_purify) && defined(__linux__)
unknown's avatar
unknown committed
77
#define HAVE_CLOSE_SERVER_SOCK 1
78
#endif
unknown's avatar
unknown committed
79

unknown's avatar
unknown committed
80 81 82 83
extern "C" {					// Because of SCO 3.2V4.2
#include <errno.h>
#include <sys/stat.h>
#ifndef __GNU_LIBRARY__
84
#define __GNU_LIBRARY__				// Skip warnings in getopt.h
unknown's avatar
unknown committed
85
#endif
86
#include <my_getopt.h>
unknown's avatar
unknown committed
87 88 89 90 91 92 93 94 95
#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
unknown's avatar
Merge  
unknown committed
96
#include <my_net.h>
unknown's avatar
unknown committed
97

98
#if !defined(__WIN__)
unknown's avatar
unknown committed
99
#  ifndef __NETWARE__
unknown's avatar
unknown committed
100
#include <sys/resource.h>
unknown's avatar
unknown committed
101
#  endif /* __NETWARE__ */
unknown's avatar
unknown committed
102 103 104 105 106 107 108 109 110 111 112
#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>
unknown's avatar
unknown committed
113
#endif /* __WIN__ */
unknown's avatar
unknown committed
114 115 116 117 118 119 120 121 122

#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;
123

unknown's avatar
unknown committed
124 125
#endif /* HAVE_LIBWRAP */

126 127 128 129
#ifdef HAVE_SYS_MMAN_H
#include <sys/mman.h>
#endif

unknown's avatar
Merge  
unknown committed
130
#ifdef __NETWARE__
unknown's avatar
unknown committed
131 132 133 134
#define zVOLSTATE_ACTIVE 6
#define zVOLSTATE_DEACTIVE 2
#define zVOLSTATE_MAINTENANCE 3

unknown's avatar
unknown committed
135 136 137 138 139 140 141
#undef __event_h__
#include <../include/event.h>
/*
  This #undef exists here because both libc of NetWare and MySQL have
  files named event.h which causes compilation errors.
*/

142
#include <nks/netware.h>
unknown's avatar
unknown committed
143 144 145
#include <nks/vm.h>
#include <library.h>
#include <monitor.h>
unknown's avatar
unknown committed
146 147 148 149 150 151
#include <zOmni.h>                              //For NEB
#include <neb.h>                                //For NEB
#include <nebpub.h>                             //For NEB
#include <zEvent.h>                             //For NSS event structures
#include <zPublics.h>

152 153 154
static void *neb_consumer_id= NULL;             //For storing NEB consumer id
static char datavolname[256]= {0};
static VolumeID_t datavolid;
unknown's avatar
unknown committed
155 156
static event_handle_t eh;
static Report_t ref;
157
static void *refneb= NULL;
158
my_bool event_flag= FALSE;
159
static int volumeid= -1;
unknown's avatar
unknown committed
160 161 162

  /* NEB event callback */
unsigned long neb_event_callback(struct EventBlock *eblock);
163 164 165
static void registerwithneb();
static void getvolumename();
static void getvolumeID(BYTE *volumeName);
unknown's avatar
unknown committed
166
#endif /* __NETWARE__ */
167
  
unknown's avatar
unknown committed
168

unknown's avatar
unknown committed
169
#ifdef _AIX41
unknown's avatar
unknown committed
170
int initgroups(const char *,unsigned int);
unknown's avatar
unknown committed
171 172
#endif

unknown's avatar
unknown committed
173 174 175 176 177 178
#if defined(__FreeBSD__) && defined(HAVE_IEEEFP_H)
#include <ieeefp.h>
#ifdef HAVE_FP_EXCEPT				// Fix type conflict
typedef fp_except fp_except_t;
#endif

unknown's avatar
unknown committed
179
  /* We can't handle floating point exceptions with threads, so disable
unknown's avatar
unknown committed
180 181 182 183 184 185
     this on freebsd
  */

inline void reset_floating_point_exceptions()
{
  /* Don't fall for overflow, underflow,divide-by-zero or loss of precision */
unknown's avatar
unknown committed
186 187 188
#if defined(__i386__)
  fpsetmask(~(FP_X_INV | FP_X_DNML | FP_X_OFL | FP_X_UFL | FP_X_DZ |
	      FP_X_IMP));
unknown's avatar
unknown committed
189
#else
unknown's avatar
unknown committed
190 191 192
 fpsetmask(~(FP_X_INV |             FP_X_OFL | FP_X_UFL | FP_X_DZ |
	     FP_X_IMP));
#endif
unknown's avatar
unknown committed
193 194 195 196 197
}
#else
#define reset_floating_point_exceptions()
#endif /* __FreeBSD__ && HAVE_IEEEFP_H */

unknown's avatar
unknown committed
198 199
} /* cplusplus */

unknown's avatar
unknown committed
200 201 202 203 204 205

#if defined(HAVE_LINUXTHREADS)
#define THR_KILL_SIGNAL SIGINT
#else
#define THR_KILL_SIGNAL SIGUSR2		// Can't use this with LinuxThreads
#endif
unknown's avatar
unknown committed
206
#define MYSQL_KILL_SIGNAL SIGTERM
unknown's avatar
unknown committed
207 208 209 210 211 212 213 214 215 216 217

#ifdef HAVE_GLIBC2_STYLE_GETHOSTBYNAME_R
#include <sys/types.h>
#else
#include <my_pthread.h>			// For thr_setconcurency()
#endif

#ifdef SOLARIS
extern "C" int gethostname(char *name, int namelen);
#endif

218

unknown's avatar
unknown committed
219
/* Constants */
220

unknown's avatar
unknown committed
221
const char *show_comp_option_name[]= {"YES", "NO", "DISABLED"};
222
static const char *sql_mode_names[]=
unknown's avatar
unknown committed
223 224
{
  "REAL_AS_FLOAT", "PIPES_AS_CONCAT", "ANSI_QUOTES", "IGNORE_SPACE",
225
  "?", "ONLY_FULL_GROUP_BY", "NO_UNSIGNED_SUBTRACTION",
unknown's avatar
unknown committed
226
  "NO_DIR_IN_CREATE",
227
  "POSTGRESQL", "ORACLE", "MSSQL", "DB2", "MAXDB", "NO_KEY_OPTIONS",
228
  "NO_TABLE_OPTIONS", "NO_FIELD_OPTIONS", "MYSQL323", "MYSQL40", "ANSI",
229 230 231 232
  "NO_AUTO_VALUE_ON_ZERO", "NO_BACKSLASH_ESCAPES", "STRICT_TRANS_TABLES",
  "STRICT_ALL_TABLES",
  "NO_ZERO_IN_DATE", "NO_ZERO_DATE", "ALLOW_INVALID_DATES",
  "ERROR_FOR_DIVISION_BY_ZERO",
unknown's avatar
Merge  
unknown committed
233
  "TRADITIONAL", "NO_AUTO_CREATE_USER", "HIGH_NOT_PRECEDENCE",
234
  "NO_ENGINE_SUBSTITUTION",
unknown's avatar
Merge  
unknown committed
235
  NullS
unknown's avatar
unknown committed
236
};
237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270
static const unsigned int sql_mode_names_len[]=
{
  /*REAL_AS_FLOAT*/               13,
  /*PIPES_AS_CONCAT*/             15,
  /*ANSI_QUOTES*/                 11,
  /*IGNORE_SPACE*/                12,
  /*?*/                           1,
  /*ONLY_FULL_GROUP_BY*/          18,
  /*NO_UNSIGNED_SUBTRACTION*/     23,
  /*NO_DIR_IN_CREATE*/            16,
  /*POSTGRESQL*/                  10,
  /*ORACLE*/                      6,
  /*MSSQL*/                       5,
  /*DB2*/                         3,
  /*MAXDB*/                       5,
  /*NO_KEY_OPTIONS*/              14,
  /*NO_TABLE_OPTIONS*/            16,
  /*NO_FIELD_OPTIONS*/            16,
  /*MYSQL323*/                    8,
  /*MYSQL40*/                     7,
  /*ANSI*/                        4,
  /*NO_AUTO_VALUE_ON_ZERO*/       21,
  /*NO_BACKSLASH_ESCAPES*/        20,
  /*STRICT_TRANS_TABLES*/         19,
  /*STRICT_ALL_TABLES*/           17,
  /*NO_ZERO_IN_DATE*/             15,
  /*NO_ZERO_DATE*/                12,
  /*ALLOW_INVALID_DATES*/         19,
  /*ERROR_FOR_DIVISION_BY_ZERO*/  26,
  /*TRADITIONAL*/                 11,
  /*NO_AUTO_CREATE_USER*/         19,
  /*HIGH_NOT_PRECEDENCE*/         19,
  /*NO_ENGINE_SUBSTITUTION*/      22
};
unknown's avatar
unknown committed
271
TYPELIB sql_mode_typelib= { array_elements(sql_mode_names)-1,"",
272 273
			    sql_mode_names,
                            (unsigned int *)sql_mode_names_len };
unknown's avatar
unknown committed
274 275 276 277 278 279 280 281 282
static const char *tc_heuristic_recover_names[]=
{
  "COMMIT", "ROLLBACK", NullS
};
static TYPELIB tc_heuristic_recover_typelib=
{
  array_elements(tc_heuristic_recover_names)-1,"",
  tc_heuristic_recover_names, NULL
};
unknown's avatar
unknown committed
283
const char *first_keyword= "first", *binary_keyword= "BINARY";
unknown's avatar
unknown committed
284
const char *my_localhost= "localhost", *delayed_user= "DELAYED";
285 286 287 288 289 290
#if SIZEOF_OFF_T > 4 && defined(BIG_TABLES)
#define GET_HA_ROWS GET_ULL
#else
#define GET_HA_ROWS GET_ULONG
#endif

unknown's avatar
unknown committed
291
bool opt_large_files= sizeof(my_off_t) > 4;
292 293 294 295

/*
  Used with --help for detailed option
*/
296
static my_bool opt_help= 0, opt_verbose= 0;
297

unknown's avatar
Merge  
unknown committed
298
arg_cmp_func Arg_comparator::comparator_matrix[5][2] =
299 300 301
{{&Arg_comparator::compare_string,     &Arg_comparator::compare_e_string},
 {&Arg_comparator::compare_real,       &Arg_comparator::compare_e_real},
 {&Arg_comparator::compare_int_signed, &Arg_comparator::compare_e_int},
unknown's avatar
Merge  
unknown committed
302 303
 {&Arg_comparator::compare_row,        &Arg_comparator::compare_e_row},
 {&Arg_comparator::compare_decimal,    &Arg_comparator::compare_e_decimal}};
unknown's avatar
unknown committed
304

305 306 307 308 309
const char *log_output_names[] =
{ "NONE", "FILE", "TABLE", NullS};
TYPELIB log_output_typelib= {array_elements(log_output_names)-1,"",
				 log_output_names, NULL};

unknown's avatar
unknown committed
310 311
/* static variables */

312 313 314
/* the default log output is log tables */
static const char *log_output_str= "TABLE";
static ulong log_output_options= LOG_TABLE;
unknown's avatar
unknown committed
315 316 317 318 319 320 321 322 323 324 325 326 327 328 329
static bool lower_case_table_names_used= 0;
static bool volatile select_thread_in_use, signal_thread_in_use;
static bool volatile ready_to_exit;
static my_bool opt_debugging= 0, opt_external_locking= 0, opt_console= 0;
static my_bool opt_bdb, opt_isam, opt_ndbcluster;
static my_bool opt_short_log_format= 0;
static uint kill_cached_threads, wake_thread;
static ulong killed_threads, thread_created;
static ulong max_used_connections;
static ulong my_bind_addr;			/* the address we bind to */
static volatile ulong cached_thread_count= 0;
static const char *sql_mode_str= "OFF";
static char *mysqld_user, *mysqld_chroot, *log_error_file_ptr;
static char *opt_init_slave, *language_ptr, *opt_init_connect;
static char *default_character_set_name;
unknown's avatar
unknown committed
330
static char *character_set_filesystem_name;
unknown's avatar
unknown committed
331
static char *my_bind_addr_str;
unknown's avatar
unknown committed
332
static char *default_collation_name, *default_storage_engine_str;
unknown's avatar
unknown committed
333 334 335 336 337 338
static char mysql_data_home_buff[2];
static struct passwd *user_info;
static I_List<THD> thread_cache;

static pthread_cond_t COND_thread_cache, COND_flush_thread_cache;

339
#ifdef WITH_BERKELEY_STORAGE_ENGINE
unknown's avatar
unknown committed
340 341
static my_bool opt_sync_bdb_logs;
#endif
unknown's avatar
unknown committed
342

unknown's avatar
unknown committed
343
/* Global variables */
unknown's avatar
unknown committed
344 345

bool opt_log, opt_update_log, opt_bin_log, opt_slow_log;
346
my_bool opt_log_queries_not_using_indexes= 0;
347
bool opt_error_log= IF_WIN(1,0);
unknown's avatar
unknown committed
348
bool opt_disable_networking=0, opt_skip_show_db=0;
349
my_bool opt_character_set_client_handshake= 1;
unknown's avatar
unknown committed
350
bool server_id_supplied = 0;
351 352
bool opt_endinfo,using_udf_functions;
my_bool locked_in_memory;
unknown's avatar
unknown committed
353
bool opt_using_transactions, using_update_log;
unknown's avatar
unknown committed
354 355
bool volatile abort_loop;
bool volatile shutdown_in_progress, grant_option;
unknown's avatar
unknown committed
356 357 358

my_bool opt_skip_slave_start = 0; // If set, slave is not autostarted
my_bool opt_reckless_slave = 0;
unknown's avatar
unknown committed
359 360
my_bool opt_enable_named_pipe= 0;
my_bool opt_local_infile, opt_slave_compressed_protocol;
361 362
my_bool opt_safe_user_create = 0, opt_no_mix_types = 0;
my_bool opt_show_slave_auth_info, opt_sql_bin_update = 0;
363
my_bool opt_log_slave_updates= 0;
unknown's avatar
unknown committed
364
my_bool	opt_innodb;
365
#ifdef WITH_INNOBASE_STORAGE_ENGINE
366
extern SHOW_VAR innodb_status_variables[];
367 368 369 370 371 372 373
extern uint innobase_init_flags, innobase_lock_type;
extern uint innobase_flush_log_at_trx_commit;
extern ulong innobase_cache_size, innobase_fast_shutdown;
extern ulong innobase_large_page_size;
extern char *innobase_home, *innobase_tmpdir, *innobase_logdir;
extern long innobase_lock_scan_time;
extern long innobase_mirrored_log_groups, innobase_log_files_in_group;
unknown's avatar
unknown committed
374 375 376 377
extern longlong innobase_log_file_size;
extern long innobase_log_buffer_size;
extern longlong innobase_buffer_pool_size;
extern long innobase_additional_mem_pool_size;
378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409
extern long innobase_buffer_pool_awe_mem_mb;
extern long innobase_file_io_threads, innobase_lock_wait_timeout;
extern long innobase_force_recovery;
extern long innobase_open_files;
extern char *innobase_data_home_dir, *innobase_data_file_path;
extern char *innobase_log_group_home_dir, *innobase_log_arch_dir;
extern char *innobase_unix_file_flush_method;
/* The following variables have to be my_bool for SHOW VARIABLES to work */
extern my_bool innobase_log_archive,
               innobase_use_doublewrite,
               innobase_use_checksums,
               innobase_use_large_pages,
               innobase_use_native_aio,
               innobase_file_per_table, innobase_locks_unsafe_for_binlog,
               innobase_create_status_file;
extern my_bool innobase_very_fast_shutdown; /* set this to 1 just before
                                            calling innobase_end() if you want
                                            InnoDB to shut down without
                                            flushing the buffer pool: this
                                            is equivalent to a 'crash' */
extern "C" {
extern ulong srv_max_buf_pool_modified_pct;
extern ulong srv_max_purge_lag;
extern ulong srv_auto_extend_increment;
extern ulong srv_n_spin_wait_rounds;
extern ulong srv_n_free_tickets_to_enter;
extern ulong srv_thread_sleep_delay;
extern ulong srv_thread_concurrency;
extern ulong srv_commit_concurrency;
}
#endif
#ifdef WITH_BERKELEY_STORAGE_ENGINE
410 411 412
#ifndef HAVE_U_INT32_T
typedef unsigned int  u_int32_t;
#endif
413 414
extern const u_int32_t bdb_DB_TXN_NOSYNC, bdb_DB_RECOVER, bdb_DB_PRIVATE,
                       bdb_DB_DIRECT_DB, bdb_DB_DIRECT_LOG;
415 416 417
extern bool berkeley_shared_data;
extern u_int32_t berkeley_init_flags,berkeley_env_flags, berkeley_lock_type,
                 berkeley_lock_types[];
418 419 420
extern ulong berkeley_max_lock, berkeley_log_buffer_size;
extern ulonglong berkeley_cache_size;
extern ulong berkeley_region_size, berkeley_cache_parts;
421 422 423 424
extern char *berkeley_home, *berkeley_tmpdir, *berkeley_logdir;
extern long berkeley_lock_scan_time;
extern TYPELIB berkeley_lock_typelib;
#endif
425

426
#ifdef WITH_NDBCLUSTER_STORAGE_ENGINE
427
const char *opt_ndbcluster_connectstring= 0;
unknown's avatar
Merge  
unknown committed
428 429 430
const char *opt_ndb_connectstring= 0;
char opt_ndb_constrbuf[1024];
unsigned opt_ndb_constrbuf_len= 0;
431
my_bool	opt_ndb_shm, opt_ndb_optimized_node_selection;
unknown's avatar
Merge  
unknown committed
432 433 434
ulong opt_ndb_cache_check_time;
const char *opt_ndb_mgmd;
ulong opt_ndb_nodeid;
unknown's avatar
unknown committed
435 436 437 438 439
ulong ndb_extra_logging;
#ifdef HAVE_NDB_BINLOG
ulong ndb_report_thresh_binlog_epoch_slip;
ulong ndb_report_thresh_binlog_mem_usage;
#endif
440

441
extern SHOW_VAR ndb_status_variables[];
442 443 444 445
extern const char *ndb_distribution_names[];
extern TYPELIB ndb_distribution_typelib;
extern const char *opt_ndb_distribution;
extern enum ndb_distribution opt_ndb_distribution_id;
446
#endif
unknown's avatar
unknown committed
447
my_bool opt_readonly, use_temp_pool, relay_log_purge;
unknown's avatar
unknown committed
448
my_bool opt_sync_frm, opt_allow_suspicious_udfs;
449
my_bool opt_secure_auth= 0;
450
my_bool opt_log_slow_admin_statements= 0;
unknown's avatar
unknown committed
451
my_bool lower_case_file_system= 0;
unknown's avatar
Merge  
unknown committed
452
my_bool opt_large_pages= 0;
unknown's avatar
unknown committed
453
my_bool opt_myisam_use_mmap= 0;
unknown's avatar
Merge  
unknown committed
454
uint    opt_large_page_size= 0;
455
my_bool opt_old_style_user_limits= 0, trust_function_creators= 0;
unknown's avatar
Merge  
unknown committed
456 457 458 459 460
/*
  True if there is at least one per-hour limit for some user, so we should
  check them before each query (and possibly reset counters when hour is
  changed). False otherwise.
*/
unknown's avatar
unknown committed
461
volatile bool mqh_used = 0;
462
my_bool opt_noacl;
unknown's avatar
Merge  
unknown committed
463
my_bool sp_automatic_privileges= 1;
464

465 466
#ifdef HAVE_ROW_BASED_REPLICATION
ulong opt_binlog_rows_event_max_size;
467
const char *binlog_format_names[]= {"STATEMENT", "ROW", "MIXED", NullS};
468 469 470 471 472 473 474
#else
const char *binlog_format_names[]= {"STATEMENT", NullS};
#endif
TYPELIB binlog_format_typelib=
  { array_elements(binlog_format_names)-1,"",
    binlog_format_names, NULL };

475 476 477
#ifdef HAVE_INITGROUPS
static bool calling_initgroups= FALSE; /* Used in SIGSEGV handler. */
#endif
478
uint mysqld_port, test_flags, select_errors, dropping_tables, ha_open_options;
479
uint mysqld_port_timeout;
unknown's avatar
unknown committed
480
uint delay_key_write_options, protocol_version;
unknown's avatar
unknown committed
481
uint lower_case_table_names;
unknown's avatar
Merge  
unknown committed
482
uint tc_heuristic_recover= 0;
unknown's avatar
unknown committed
483
uint volatile thread_count, thread_running;
484 485
ulonglong thd_startup_options;
ulong back_log, connect_timeout, concurrency, server_id;
unknown's avatar
unknown committed
486 487
ulong table_cache_size, table_def_size;
ulong thread_stack, what_to_log;
unknown's avatar
unknown committed
488
ulong query_buff_size, slow_launch_time, slave_open_temp_tables;
unknown's avatar
unknown committed
489
ulong open_files_limit, max_binlog_size, max_relay_log_size;
490
ulong slave_net_timeout, slave_trans_retries;
491
ulong thread_cache_size=0, binlog_cache_size=0, max_binlog_cache_size=0;
492
ulong query_cache_size=0;
unknown's avatar
unknown committed
493
ulong refresh_version, flush_version;	/* Increments on each reload */
unknown's avatar
Merge  
unknown committed
494
query_id_t query_id;
unknown's avatar
unknown committed
495
ulong aborted_threads, aborted_connects;
unknown's avatar
unknown committed
496 497
ulong delayed_insert_timeout, delayed_insert_limit, delayed_queue_size;
ulong delayed_insert_threads, delayed_insert_writes, delayed_rows_in_use;
unknown's avatar
unknown committed
498
ulong delayed_insert_errors,flush_time;
unknown's avatar
Merge  
unknown committed
499
ulong specialflag=0;
500
ulong binlog_cache_use= 0, binlog_cache_disk_use= 0;
unknown's avatar
unknown committed
501
ulong max_connections, max_connect_errors;
unknown's avatar
Merge  
unknown committed
502
uint  max_user_connections= 0;
503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518
/*
  Limit of the total number of prepared statements in the server.
  Is necessary to protect the server against out-of-memory attacks.
*/
ulong max_prepared_stmt_count;
/*
  Current total number of prepared statements in the server. This number
  is exact, and therefore may not be equal to the difference between
  `com_stmt_prepare' and `com_stmt_close' (global status variables), as
  the latter ones account for all registered attempts to prepare
  a statement (including unsuccessful ones).  Prepared statements are
  currently connection-local: if the same SQL query text is prepared in
  two different connections, this counts as two distinct prepared
  statements.
*/
ulong prepared_stmt_count=0;
unknown's avatar
unknown committed
519
ulong thread_id=1L,current_pid;
520
ulong slow_launch_threads = 0, sync_binlog_period;
unknown's avatar
unknown committed
521
ulong expire_logs_days = 0;
unknown's avatar
unknown committed
522 523 524 525
ulong rpl_recovery_rank=0;

double log_10[32];			/* 10 potences */
time_t start_time;
526

527 528
char mysql_home[FN_REFLEN], pidfile_name[FN_REFLEN], system_time_zone[30];
char *default_tz_name;
unknown's avatar
unknown committed
529
char log_error_file[FN_REFLEN], glob_hostname[FN_REFLEN];
unknown's avatar
unknown committed
530
char mysql_real_data_home[FN_REFLEN],
531
     language[FN_REFLEN], reg_ext[FN_EXTLEN], mysql_charsets_dir[FN_REFLEN],
unknown's avatar
unknown committed
532
     *opt_init_file, *opt_tc_log_file,
533
     def_ft_boolean_syntax[sizeof(ft_boolean_syntax)];
534
uint reg_ext_length;
535 536 537
const key_map key_map_empty(0);
key_map key_map_full(0);                        // Will be initialized later

538
const char *opt_date_time_formats[3];
539

unknown's avatar
unknown committed
540
char *mysql_data_home= mysql_real_data_home;
541
char server_version[SERVER_VERSION_LENGTH];
542
char *mysqld_unix_port, *opt_mysql_tmpdir;
unknown's avatar
unknown committed
543
const char **errmesg;			/* Error messages */
544
const char *myisam_recover_options_str="OFF";
545
const char *myisam_stats_method_str="nulls_unequal";
546 547
/* name of reference on left espression in rewritten IN subquery */
const char *in_left_expr_name= "<left expr>";
548 549
/* name of additional condition */
const char *in_additional_cond= "<IN COND>";
unknown's avatar
Merge  
unknown committed
550
my_decimal decimal_zero;
unknown's avatar
unknown committed
551 552 553 554 555 556 557 558
/* classes for comparation parsing/processing */
Eq_creator eq_creator;
Ne_creator ne_creator;
Gt_creator gt_creator;
Lt_creator lt_creator;
Ge_creator ge_creator;
Le_creator le_creator;

559

unknown's avatar
unknown committed
560
FILE *bootstrap_file;
unknown's avatar
Merge  
unknown committed
561
int bootstrap_error;
562
FILE *stderror_file=0;
unknown's avatar
unknown committed
563

unknown's avatar
unknown committed
564
I_List<THD> threads;
565
I_List<NAMED_LIST> key_caches;
unknown's avatar
unknown committed
566 567
Rpl_filter* rpl_filter;
Rpl_filter* binlog_filter;
unknown's avatar
unknown committed
568

unknown's avatar
unknown committed
569 570
struct system_variables global_system_variables;
struct system_variables max_system_variables;
unknown's avatar
Merge  
unknown committed
571
struct system_status_var global_status_var;
unknown's avatar
unknown committed
572

unknown's avatar
unknown committed
573
MY_TMPDIR mysql_tmpdir_list;
574
MY_BITMAP temp_pool;
unknown's avatar
unknown committed
575

576 577
CHARSET_INFO *system_charset_info, *files_charset_info ;
CHARSET_INFO *national_charset_info, *table_alias_charset;
unknown's avatar
unknown committed
578
CHARSET_INFO *character_set_filesystem;
579

580
SHOW_COMP_OPTION have_row_based_replication;
581
SHOW_COMP_OPTION have_openssl, have_symlink, have_dlopen, have_query_cache;
582
SHOW_COMP_OPTION have_geometry, have_rtree_keys;
unknown's avatar
unknown committed
583 584 585
SHOW_COMP_OPTION have_crypt, have_compress;

/* Thread specific variables */
586

unknown's avatar
unknown committed
587
pthread_key(MEM_ROOT**,THR_MALLOC);
unknown's avatar
unknown committed
588 589
pthread_key(THD*, THR_THD);
pthread_mutex_t LOCK_mysql_create_db, LOCK_Acl, LOCK_open, LOCK_thread_count,
590
		LOCK_mapped_file, LOCK_status, LOCK_global_read_lock,
unknown's avatar
unknown committed
591
		LOCK_error_log, LOCK_uuid_generator,
unknown's avatar
unknown committed
592
		LOCK_delayed_insert, LOCK_delayed_status, LOCK_delayed_create,
593
		LOCK_crypt, LOCK_bytes_sent, LOCK_bytes_received,
594
	        LOCK_global_system_variables,
595
		LOCK_user_conn, LOCK_slave_list, LOCK_active_mi;
596 597 598 599 600 601 602 603
/*
  The below lock protects access to two global server variables:
  max_prepared_stmt_count and prepared_stmt_count. These variables
  set the limit and hold the current total number of prepared statements
  in the server, respectively. As PREPARE/DEALLOCATE rate in a loaded
  server may be fairly high, we need a dedicated lock.
*/
pthread_mutex_t LOCK_prepared_stmt_count;
604 605 606
#ifdef HAVE_OPENSSL
pthread_mutex_t LOCK_des_key_file;
#endif
unknown's avatar
unknown committed
607
rw_lock_t	LOCK_grant, LOCK_sys_init_connect, LOCK_sys_init_slave;
608
pthread_cond_t COND_refresh, COND_thread_count, COND_global_read_lock;
unknown's avatar
unknown committed
609 610
pthread_t signal_thread;
pthread_attr_t connection_attrib;
unknown's avatar
unknown committed
611 612 613 614
pthread_mutex_t  LOCK_server_started;
pthread_cond_t  COND_server_started;

int mysqld_server_started= 0;
unknown's avatar
unknown committed
615

616 617
File_parser_dummy_hook file_parser_dummy_hook;

unknown's avatar
unknown committed
618 619 620 621 622
/* replication parameters, if master_host is not NULL, we are a slave */
uint master_port= MYSQL_PORT, master_connect_retry = 60;
uint report_port= MYSQL_PORT;
ulong master_retry_count=0;
char *master_user, *master_password, *master_host, *master_info_file;
unknown's avatar
unknown committed
623
char *relay_log_info_file, *report_user, *report_password, *report_host;
unknown's avatar
unknown committed
624
char *opt_relay_logname = 0, *opt_relaylog_index_name=0;
unknown's avatar
unknown committed
625 626 627
my_bool master_ssl;
char *master_ssl_key, *master_ssl_cert;
char *master_ssl_ca, *master_ssl_capath, *master_ssl_cipher;
628
char *opt_logname, *opt_slow_logname;
unknown's avatar
unknown committed
629 630 631 632

/* Static variables */

static bool kill_in_progress, segfaulted;
633
static my_bool opt_do_pstack, opt_bootstrap, opt_myisam_log;
unknown's avatar
unknown committed
634 635
static int cleanup_done;
static ulong opt_specialflag, opt_myisam_block_size;
636 637
static char *opt_update_logname, *opt_binlog_index_name;
static char *opt_tc_heuristic_recover;
unknown's avatar
unknown committed
638 639 640 641 642 643 644 645 646 647
static char *mysql_home_ptr, *pidfile_name_ptr;
static char **defaults_argv;
static char *opt_bin_logname;

static my_socket unix_sock,ip_sock;
static pthread_t select_thread;
struct rand_struct sql_rand; // used by sql_class.cc:THD::THD()

/* OS specific variables */

unknown's avatar
unknown committed
648 649 650
#ifdef __WIN__
#undef	 getpid
#include <process.h>
unknown's avatar
unknown committed
651 652 653 654 655 656 657

static pthread_cond_t COND_handler_count;
static uint handler_count;
static bool start_mode=0, use_opt_args;
static int opt_argc;
static char **opt_argv;

unknown's avatar
unknown committed
658
#if !defined(EMBEDDED_LIBRARY)
unknown's avatar
unknown committed
659
static HANDLE hEventShutdown;
660
static char shutdown_event_name[40];
unknown's avatar
unknown committed
661 662
#include "nt_servc.h"
static	 NTService  Service;	      // Service object for WinNT
unknown's avatar
unknown committed
663 664 665 666
#endif /* EMBEDDED_LIBRARY */
#endif /* __WIN__ */

#ifdef __NT__
667
static char pipe_name[512];
unknown's avatar
unknown committed
668 669 670
static SECURITY_ATTRIBUTES saPipeSecurity;
static SECURITY_DESCRIPTOR sdPipeDescriptor;
static HANDLE hPipe = INVALID_HANDLE_VALUE;
unknown's avatar
unknown committed
671
#endif
unknown's avatar
unknown committed
672

unknown's avatar
unknown committed
673
#ifndef EMBEDDED_LIBRARY
674
bool mysqld_embedded=0;
unknown's avatar
unknown committed
675
#else
676
bool mysqld_embedded=1;
unknown's avatar
unknown committed
677 678 679 680 681 682
#endif

#ifndef DBUG_OFF
static const char* default_dbug_option;
#endif
#ifdef HAVE_LIBWRAP
683
const char *libwrapName= NULL;
unknown's avatar
unknown committed
684 685
#endif
#ifdef HAVE_QUERY_CACHE
unknown's avatar
unknown committed
686
static ulong query_cache_limit= 0;
unknown's avatar
unknown committed
687 688 689 690 691
ulong query_cache_min_res_unit= QUERY_CACHE_MIN_RESULT_DATA_SIZE;
Query_cache query_cache;
#endif
#ifdef HAVE_SMEM
char *shared_memory_base_name= default_shared_memory_base_name;
692
my_bool opt_enable_shared_memory;
693
HANDLE smem_event_connect_request= 0;
unknown's avatar
unknown committed
694 695
#endif

696
#define SSL_VARS_NOT_STATIC
unknown's avatar
unknown committed
697 698
#include "sslopt-vars.h"
#ifdef HAVE_OPENSSL
699
#include <openssl/crypto.h>
unknown's avatar
unknown committed
700
#ifndef HAVE_YASSL
701 702 703 704 705 706 707 708 709 710 711
typedef struct CRYPTO_dynlock_value
{
  rw_lock_t lock;
} openssl_lock_t;

static openssl_lock_t *openssl_stdlocks;
static openssl_lock_t *openssl_dynlock_create(const char *, int);
static void openssl_dynlock_destroy(openssl_lock_t *, const char *, int);
static void openssl_lock_function(int, int, const char *, int);
static void openssl_lock(int, openssl_lock_t *, const char *, int);
static unsigned long openssl_id_function();
unknown's avatar
unknown committed
712
#endif
unknown's avatar
unknown committed
713
char *des_key_file;
unknown's avatar
unknown committed
714
struct st_VioSSLFd *ssl_acceptor_fd;
unknown's avatar
unknown committed
715 716 717 718 719
#endif /* HAVE_OPENSSL */


/* Function declarations */

720
static void start_signal_handler(void);
721
pthread_handler_t signal_hand(void *arg);
unknown's avatar
unknown committed
722
static void mysql_init_variables(void);
unknown's avatar
unknown committed
723
static void get_options(int argc,char **argv);
724
static void set_server_version(void);
725
static int init_thread_environment();
unknown's avatar
unknown committed
726 727
static char *get_relative_path(const char *path);
static void fix_paths(void);
728 729
pthread_handler_t handle_connections_sockets(void *arg);
pthread_handler_t kill_server_thread(void *arg);
unknown's avatar
Merge  
unknown committed
730
static void bootstrap(FILE *file);
731
static void close_server_sock();
unknown's avatar
unknown committed
732 733
static bool read_init_file(char *file_name);
#ifdef __NT__
734
pthread_handler_t handle_connections_namedpipes(void *arg);
unknown's avatar
unknown committed
735
#endif
736
#ifdef HAVE_SMEM
737
pthread_handler_t handle_connections_shared_memory(void *arg);
738
#endif
739
pthread_handler_t handle_slave(void *arg);
740
static ulong find_bit_type(const char *x, TYPELIB *bit_lib);
unknown's avatar
unknown committed
741
static void clean_up(bool print_message);
unknown's avatar
unknown committed
742
static void clean_up_mutexes(void);
743
static void wait_for_signal_thread_to_end(void);
744 745
static int test_if_case_insensitive(const char *dir_name);
static void create_pid_file();
746
static void end_ssl();
747 748

#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764
/****************************************************************************
** Code to end mysqld
****************************************************************************/

static void close_connections(void)
{
#ifdef EXTRA_DEBUG
  int count=0;
#endif
  DBUG_ENTER("close_connections");

  /* Clear thread cache */
  kill_cached_threads++;
  flush_thread_cache();

  /* kill flush thread */
765 766
  (void) pthread_mutex_lock(&LOCK_manager);
  if (manager_thread_in_use)
unknown's avatar
unknown committed
767
  {
unknown's avatar
Merge  
unknown committed
768
    DBUG_PRINT("quit",("killing manager thread: 0x%lx",manager_thread));
769
   (void) pthread_cond_signal(&COND_manager);
unknown's avatar
unknown committed
770
  }
771
  (void) pthread_mutex_unlock(&LOCK_manager);
unknown's avatar
unknown committed
772 773

  /* kill connection thread */
774
#if !defined(__WIN__) && !defined(__NETWARE__)
unknown's avatar
Merge  
unknown committed
775
  DBUG_PRINT("quit",("waiting for select thread: 0x%lx",select_thread));
unknown's avatar
unknown committed
776 777 778 779 780 781 782
  (void) pthread_mutex_lock(&LOCK_thread_count);

  while (select_thread_in_use)
  {
    struct timespec abstime;
    int error;
    LINT_INIT(error);
unknown's avatar
unknown committed
783
    DBUG_PRINT("info",("Waiting for select thread"));
784

unknown's avatar
unknown committed
785 786 787 788
#ifndef DONT_USE_THR_ALARM
    if (pthread_kill(select_thread,THR_CLIENT_ALARM))
      break;					// allready dead
#endif
789
    set_timespec(abstime, 2);
790
    for (uint tmp=0 ; tmp < 10 && select_thread_in_use; tmp++)
unknown's avatar
unknown committed
791 792 793 794 795 796 797 798 799 800
    {
      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
unknown's avatar
unknown committed
801
    close_server_sock();
unknown's avatar
unknown committed
802 803 804 805 806 807 808
  }
  (void) pthread_mutex_unlock(&LOCK_thread_count);
#endif /* __WIN__ */


  /* Abort listening to new connections */
  DBUG_PRINT("quit",("Closing sockets"));
unknown's avatar
Merge  
unknown committed
809
  if (!opt_disable_networking )
unknown's avatar
unknown committed
810 811 812 813 814 815 816 817 818
  {
    if (ip_sock != INVALID_SOCKET)
    {
      (void) shutdown(ip_sock,2);
      (void) closesocket(ip_sock);
      ip_sock= INVALID_SOCKET;
    }
  }
#ifdef __NT__
unknown's avatar
unknown committed
819
  if (hPipe != INVALID_HANDLE_VALUE && opt_enable_named_pipe)
unknown's avatar
unknown committed
820
  {
unknown's avatar
merge  
unknown committed
821
    HANDLE temp;
unknown's avatar
Merge  
unknown committed
822
    DBUG_PRINT("quit", ("Closing named pipes") );
823

unknown's avatar
merge  
unknown committed
824
    /* Create connection to the handle named pipe handler to break the loop */
825
    if ((temp = CreateFile(pipe_name,
unknown's avatar
merge  
unknown committed
826 827 828 829 830 831 832
			   GENERIC_READ | GENERIC_WRITE,
			   0,
			   NULL,
			   OPEN_EXISTING,
			   0,
			   NULL )) != INVALID_HANDLE_VALUE)
    {
833
      WaitNamedPipe(pipe_name, 1000);
unknown's avatar
merge  
unknown committed
834 835 836 837 838 839
      DWORD dwMode = PIPE_READMODE_BYTE | PIPE_WAIT;
      SetNamedPipeHandleState(temp, &dwMode, NULL, NULL);
      CancelIo(temp);
      DisconnectNamedPipe(temp);
      CloseHandle(temp);
    }
unknown's avatar
unknown committed
840 841 842 843 844 845 846
  }
#endif
#ifdef HAVE_SYS_UN_H
  if (unix_sock != INVALID_SOCKET)
  {
    (void) shutdown(unix_sock,2);
    (void) closesocket(unix_sock);
847
    (void) unlink(mysqld_unix_port);
unknown's avatar
unknown committed
848 849 850
    unix_sock= INVALID_SOCKET;
  }
#endif
851
  end_thr_alarm(0);			 // Abort old alarms.
unknown's avatar
unknown committed
852

853 854 855 856 857
  /*
    First signal all threads that it's time to die
    This will give the threads some time to gracefully abort their
    statements and inform their clients that the server is about to die.
  */
unknown's avatar
unknown committed
858 859 860 861 862 863 864 865 866

  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));
867 868
    /* We skip slave threads & scheduler on this first loop through. */
    if (tmp->slave_thread || tmp->system_thread == SYSTEM_THREAD_EVENT_SCHEDULER)
869
      continue;
870

unknown's avatar
unknown committed
871
    tmp->killed= THD::KILL_CONNECTION;
unknown's avatar
unknown committed
872 873 874
    if (tmp->mysys_var)
    {
      tmp->mysys_var->abort=1;
unknown's avatar
unknown committed
875 876
      pthread_mutex_lock(&tmp->mysys_var->mutex);
      if (tmp->mysys_var->current_cond)
unknown's avatar
unknown committed
877 878 879 880 881
      {
	pthread_mutex_lock(tmp->mysys_var->current_mutex);
	pthread_cond_broadcast(tmp->mysys_var->current_cond);
	pthread_mutex_unlock(tmp->mysys_var->current_mutex);
      }
unknown's avatar
unknown committed
882
      pthread_mutex_unlock(&tmp->mysys_var->mutex);
unknown's avatar
unknown committed
883 884 885 886
    }
  }
  (void) pthread_mutex_unlock(&LOCK_thread_count); // For unlink from list

887
  Events::shutdown();
888 889
  end_slave();

unknown's avatar
unknown committed
890
  if (thread_count)
891
    sleep(2);					// Give threads time to die
unknown's avatar
unknown committed
892

893 894 895 896 897
  /*
    Force remaining threads to die by closing the connection to the client
    This will ensure that threads that are waiting for a command from the
    client on a blocking read call are aborted.
  */
unknown's avatar
unknown committed
898 899 900 901 902 903 904 905 906 907 908 909

  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
910
    if (tmp->vio_ok())
unknown's avatar
unknown committed
911
    {
912 913
      if (global_system_variables.log_warnings)
        sql_print_warning(ER(ER_FORCING_CLOSE),my_progname,
914
                          tmp->thread_id,
915 916
                          (tmp->main_security_ctx.user ?
                           tmp->main_security_ctx.user : ""));
917
      close_connection(tmp,0,0);
unknown's avatar
unknown committed
918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935
    }
#endif
    DBUG_PRINT("quit",("Unlocking LOCK_thread_count"));
    (void) pthread_mutex_unlock(&LOCK_thread_count);
  }
  /* 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);

  DBUG_PRINT("quit",("close_connections thread"));
  DBUG_VOID_RETURN;
}
936
#endif /*EMBEDDED_LIBRARY*/
unknown's avatar
unknown committed
937

938

939
static void close_server_sock()
unknown's avatar
unknown committed
940
{
941
#ifdef HAVE_CLOSE_SERVER_SOCK
unknown's avatar
unknown committed
942
  DBUG_ENTER("close_server_sock");
943 944 945
  my_socket tmp_sock;
  tmp_sock=ip_sock;
  if (tmp_sock != INVALID_SOCKET)
unknown's avatar
unknown committed
946 947
  {
    ip_sock=INVALID_SOCKET;
948
    DBUG_PRINT("info",("calling shutdown on TCP/IP socket"));
949
    VOID(shutdown(tmp_sock,2));
unknown's avatar
unknown committed
950
#if defined(__NETWARE__)
951
    /*
unknown's avatar
unknown committed
952 953
      The following code is disabled for normal systems as it causes MySQL
      to hang on AIX 4.3 during shutdown
954
    */
955
    DBUG_PRINT("info",("calling closesocket on TCP/IP socket"));
956
    VOID(closesocket(tmp_sock));
957
#endif
unknown's avatar
unknown committed
958
  }
959 960
  tmp_sock=unix_sock;
  if (tmp_sock != INVALID_SOCKET)
unknown's avatar
unknown committed
961
  {
962
    unix_sock=INVALID_SOCKET;
963
    DBUG_PRINT("info",("calling shutdown on unix socket"));
964
    VOID(shutdown(tmp_sock,2));
unknown's avatar
unknown committed
965
#if defined(__NETWARE__)
unknown's avatar
unknown committed
966
    /*
967 968
      The following code is disabled for normal systems as it may cause MySQL
      to hang on AIX 4.3 during shutdown
unknown's avatar
unknown committed
969 970
    */
    DBUG_PRINT("info",("calling closesocket on unix/IP socket"));
971
    VOID(closesocket(tmp_sock));
unknown's avatar
unknown committed
972
#endif
973
    VOID(unlink(mysqld_unix_port));
unknown's avatar
unknown committed
974 975 976
  }
  DBUG_VOID_RETURN;
#endif
977
}
unknown's avatar
unknown committed
978

979

unknown's avatar
unknown committed
980 981 982 983
void kill_mysql(void)
{
  DBUG_ENTER("kill_mysql");

unknown's avatar
unknown committed
984
#ifdef SIGNALS_DONT_BREAK_READ
985 986
  abort_loop=1;					// Break connection loops
  close_server_sock();				// Force accept to wake up
987
#endif
unknown's avatar
unknown committed
988

unknown's avatar
unknown committed
989
#if defined(__WIN__)
unknown's avatar
unknown committed
990
#if !defined(EMBEDDED_LIBRARY)
unknown's avatar
unknown committed
991 992 993 994 995
  {
    if (!SetEvent(hEventShutdown))
    {
      DBUG_PRINT("error",("Got error: %ld from SetEvent",GetLastError()));
    }
996 997 998 999 1000 1001
    /*
      or:
      HANDLE hEvent=OpenEvent(0, FALSE, "MySqlShutdown");
      SetEvent(hEventShutdown);
      CloseHandle(hEvent);
    */
unknown's avatar
unknown committed
1002
  }
unknown's avatar
unknown committed
1003
#endif
unknown's avatar
unknown committed
1004
#elif defined(HAVE_PTHREAD_KILL)
1005
  if (pthread_kill(signal_thread, MYSQL_KILL_SIGNAL))
unknown's avatar
unknown committed
1006 1007 1008 1009
  {
    DBUG_PRINT("error",("Got error %d from pthread_kill",errno)); /* purecov: inspected */
  }
#elif !defined(SIGNALS_DONT_BREAK_READ)
1010
  kill(current_pid, MYSQL_KILL_SIGNAL);
unknown's avatar
unknown committed
1011
#endif
unknown's avatar
unknown committed
1012 1013 1014
  DBUG_PRINT("quit",("After pthread_kill"));
  shutdown_in_progress=1;			// Safety if kill didn't work
#ifdef SIGNALS_DONT_BREAK_READ
1015
  if (!kill_in_progress)
unknown's avatar
unknown committed
1016 1017
  {
    pthread_t tmp;
unknown's avatar
unknown committed
1018
    abort_loop=1;
unknown's avatar
unknown committed
1019 1020
    if (pthread_create(&tmp,&connection_attrib, kill_server_thread,
			   (void*) 0))
1021
      sql_print_error("Can't create thread to kill server");
unknown's avatar
unknown committed
1022
  }
1023
#endif
unknown's avatar
unknown committed
1024
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
1025 1026
}

1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040
/*
  Force server down. Kill all connections and threads and exit

  SYNOPSIS
  kill_server

  sig_ptr       Signal number that caused kill_server to be called.

  NOTE!
    A signal number of 0 mean that the function was not called
    from a signal handler and there is thus no signal to block
    or stop, we just want to kill the server.

*/
unknown's avatar
unknown committed
1041

1042
#if defined(__NETWARE__)
unknown's avatar
unknown committed
1043
extern "C" void kill_server(int sig_ptr)
1044
#define RETURN_FROM_KILL_SERVER DBUG_VOID_RETURN
unknown's avatar
unknown committed
1045
#elif !defined(__WIN__)
unknown's avatar
unknown committed
1046
static void *kill_server(void *sig_ptr)
unknown's avatar
unknown committed
1047
#define RETURN_FROM_KILL_SERVER DBUG_RETURN(0)
unknown's avatar
unknown committed
1048 1049
#else
static void __cdecl kill_server(int sig_ptr)
unknown's avatar
unknown committed
1050
#define RETURN_FROM_KILL_SERVER DBUG_VOID_RETURN
unknown's avatar
unknown committed
1051 1052 1053
#endif
{
  DBUG_ENTER("kill_server");
1054
#ifndef EMBEDDED_LIBRARY
unknown's avatar
Merge  
unknown committed
1055
  int sig=(int) (long) sig_ptr;			// This is passed a int
1056
  // if there is a signal during the kill in progress, ignore the other
unknown's avatar
unknown committed
1057 1058 1059 1060
  if (kill_in_progress)				// Safety
    RETURN_FROM_KILL_SERVER;
  kill_in_progress=TRUE;
  abort_loop=1;					// This should be set
1061 1062
  if (sig != 0) // 0 is not a valid signal number
    my_sigset(sig,SIG_IGN);
unknown's avatar
unknown committed
1063
  if (sig == MYSQL_KILL_SIGNAL || sig == 0)
1064
    sql_print_information(ER(ER_NORMAL_SHUTDOWN),my_progname);
unknown's avatar
unknown committed
1065 1066 1067
  else
    sql_print_error(ER(ER_GOT_SIGNAL),my_progname,sig); /* purecov: inspected */

1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079
#if defined(HAVE_SMEM) && defined(__WIN__)    
  /*    
   Send event to smem_event_connect_request for aborting    
   */    
  if (!SetEvent(smem_event_connect_request))    
  {      
	  DBUG_PRINT("error",
		("Got error: %ld from SetEvent of smem_event_connect_request",
		 GetLastError()));    
  }
#endif  
  
1080
#if defined(__NETWARE__) || (defined(USE_ONE_SIGNAL_HAND) && !defined(__WIN__))
unknown's avatar
unknown committed
1081 1082 1083
  my_thread_init();				// If this is a new thread
#endif
  close_connections();
1084 1085 1086 1087 1088
  if (sig != MYSQL_KILL_SIGNAL &&
#ifdef __WIN__
      sig != SIGINT &&				/* Bug#18235 */
#endif
      sig != 0)
unknown's avatar
unknown committed
1089 1090
    unireg_abort(1);				/* purecov: inspected */
  else
1091
    unireg_end();
unknown's avatar
Merge  
unknown committed
1092

unknown's avatar
unknown committed
1093
#ifdef __NETWARE__
unknown's avatar
unknown committed
1094
  if (!event_flag)
unknown's avatar
Merge  
unknown committed
1095
    pthread_join(select_thread, NULL);		// wait for main thread
unknown's avatar
unknown committed
1096
#endif /* __NETWARE__ */
1097

1098 1099 1100 1101
#if defined(__NETWARE__) || (defined(USE_ONE_SIGNAL_HAND) && !defined(__WIN__) && !defined(OS2))
  my_thread_end();
#endif

1102
  pthread_exit(0);				/* purecov: deadcode */
unknown's avatar
unknown committed
1103

1104
#endif /* EMBEDDED_LIBRARY */
unknown's avatar
unknown committed
1105 1106 1107 1108
  RETURN_FROM_KILL_SERVER;
}


unknown's avatar
unknown committed
1109
#if defined(USE_ONE_SIGNAL_HAND) || (defined(__NETWARE__) && defined(SIGNALS_DONT_BREAK_READ))
1110
pthread_handler_t kill_server_thread(void *arg __attribute__((unused)))
unknown's avatar
unknown committed
1111 1112 1113 1114 1115 1116 1117 1118
{
  my_thread_init();				// Initialize new thread
  kill_server(0);
  my_thread_end();				// Normally never reached
  return 0;
}
#endif

1119
extern "C" sig_handler print_signal_warning(int sig)
unknown's avatar
unknown committed
1120
{
unknown's avatar
unknown committed
1121 1122
  if (global_system_variables.log_warnings)
    sql_print_warning("Got signal %d from thread %d", sig,my_thread_id());
unknown's avatar
unknown committed
1123
#ifdef DONT_REMEMBER_SIGNAL
1124
  my_sigset(sig,print_signal_warning);		/* int. thread system calls */
unknown's avatar
unknown committed
1125
#endif
1126
#if !defined(__WIN__) && !defined(__NETWARE__)
unknown's avatar
unknown committed
1127 1128 1129 1130 1131
  if (sig == SIGALRM)
    alarm(2);					/* reschedule alarm */
#endif
}

1132 1133
/*
  cleanup all memory and end program nicely
unknown's avatar
unknown committed
1134

1135 1136 1137 1138 1139
  SYNOPSIS
    unireg_end()

  NOTES
    This function never returns.
unknown's avatar
unknown committed
1140

1141 1142 1143 1144
    If SIGNALS_DONT_BREAK_READ is defined, this function is called
    by the main thread. To get MySQL to shut down nicely in this case
    (Mac OS X) we have to call exit() instead if pthread_exit().
*/
unknown's avatar
unknown committed
1145

1146
#ifndef EMBEDDED_LIBRARY
1147
void unireg_end(void)
unknown's avatar
unknown committed
1148
{
unknown's avatar
unknown committed
1149
  clean_up(1);
unknown's avatar
unknown committed
1150
  my_thread_end();
1151
#if defined(SIGNALS_DONT_BREAK_READ) && !defined(__NETWARE__)
1152 1153
  exit(0);
#else
unknown's avatar
unknown committed
1154
  pthread_exit(0);				// Exit is in main thread
1155
#endif
unknown's avatar
unknown committed
1156 1157
}

1158
extern "C" void unireg_abort(int exit_code)
unknown's avatar
unknown committed
1159
{
1160
  DBUG_ENTER("unireg_abort");
unknown's avatar
unknown committed
1161 1162
  if (exit_code)
    sql_print_error("Aborting\n");
unknown's avatar
unknown committed
1163
  clean_up(exit_code || !opt_bootstrap); /* purecov: inspected */
1164
  DBUG_PRINT("quit",("done with cleanup in unireg_abort"));
1165
  wait_for_signal_thread_to_end();
unknown's avatar
unknown committed
1166 1167
  clean_up_mutexes();
  my_end(opt_endinfo ? MY_CHECK_ERROR | MY_GIVE_INFO : 0);
unknown's avatar
unknown committed
1168 1169
  exit(exit_code); /* purecov: inspected */
}
1170
#endif
unknown's avatar
unknown committed
1171

unknown's avatar
unknown committed
1172

1173
void clean_up(bool print_message)
unknown's avatar
unknown committed
1174 1175 1176 1177
{
  DBUG_PRINT("exit",("clean_up"));
  if (cleanup_done++)
    return; /* purecov: inspected */
unknown's avatar
unknown committed
1178

unknown's avatar
unknown committed
1179 1180
  logger.cleanup_base();

unknown's avatar
unknown committed
1181 1182 1183 1184 1185
  /*
    make sure that handlers finish up
    what they have that is dependent on the binlog
  */
  ha_binlog_end(current_thd);
unknown's avatar
unknown committed
1186 1187
  mysql_bin_log.cleanup();

unknown's avatar
SCRUM  
unknown committed
1188
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
1189 1190
  if (use_slave_mask)
    bitmap_free(&slave_error_mask);
1191
#endif
1192
  my_tz_free();
unknown's avatar
unknown committed
1193
  my_database_names_free();
unknown's avatar
unknown committed
1194
#ifndef NO_EMBEDDED_ACCESS_CHECKS
unknown's avatar
unknown committed
1195 1196
  acl_free(1);
  grant_free();
unknown's avatar
unknown committed
1197
#endif
unknown's avatar
unknown committed
1198
  query_cache_destroy();
unknown's avatar
unknown committed
1199
  table_cache_free();
unknown's avatar
unknown committed
1200
  table_def_free();
unknown's avatar
unknown committed
1201 1202 1203
  hostname_cache_free();
  item_user_lock_free();
  lex_free();				/* Free some memory */
unknown's avatar
unknown committed
1204
  set_var_free();
1205
  free_charsets();
1206
  (void) ha_panic(HA_PANIC_CLOSE);	/* close all tables and logs */
unknown's avatar
unknown committed
1207
  if (!opt_noacl)
1208
  {
1209
#ifdef HAVE_DLOPEN
unknown's avatar
unknown committed
1210
    udf_free();
1211
#endif
1212
  }
unknown's avatar
unknown committed
1213
  plugin_free();
unknown's avatar
Merge  
unknown committed
1214 1215
  if (tc_log)
    tc_log->close();
1216
  xid_cache_free();
1217 1218
  delete_elements(&key_caches, (void (*)(const char*, gptr)) free_key_cache);
  multi_keycache_free();
1219
  free_status_vars();
1220
  end_thr_alarm(1);			/* Free allocated memory */
1221
  my_free_open_file_info();
1222 1223 1224 1225 1226 1227
  my_free((char*) global_system_variables.date_format,
	  MYF(MY_ALLOW_ZERO_PTR));
  my_free((char*) global_system_variables.time_format,
	  MYF(MY_ALLOW_ZERO_PTR));
  my_free((char*) global_system_variables.datetime_format,
	  MYF(MY_ALLOW_ZERO_PTR));
unknown's avatar
unknown committed
1228 1229
  if (defaults_argv)
    free_defaults(defaults_argv);
unknown's avatar
unknown committed
1230 1231
  my_free(sys_init_connect.value, MYF(MY_ALLOW_ZERO_PTR));
  my_free(sys_init_slave.value, MYF(MY_ALLOW_ZERO_PTR));
unknown's avatar
unknown committed
1232
  free_tmpdir(&mysql_tmpdir_list);
unknown's avatar
SCRUM  
unknown committed
1233
#ifdef HAVE_REPLICATION
1234
  my_free(slave_load_tmpdir,MYF(MY_ALLOW_ZERO_PTR));
1235
#endif
1236
  x_free(opt_bin_logname);
1237
  x_free(opt_relay_logname);
unknown's avatar
unknown committed
1238
  bitmap_free(&temp_pool);
unknown's avatar
unknown committed
1239
  free_max_user_conn();
unknown's avatar
SCRUM  
unknown committed
1240
#ifdef HAVE_REPLICATION
1241
  end_slave_list();
1242
#endif
unknown's avatar
unknown committed
1243 1244
  delete binlog_filter;
  delete rpl_filter;
1245
  end_ssl();
1246
  vio_end();
unknown's avatar
unknown committed
1247
#ifdef USE_REGEX
unknown's avatar
unknown committed
1248
  my_regex_end();
unknown's avatar
unknown committed
1249
#endif
unknown's avatar
unknown committed
1250

unknown's avatar
unknown committed
1251
  if (print_message && errmesg)
1252
    sql_print_information(ER(ER_SHUTDOWN_COMPLETE),my_progname);
1253
#if !defined(EMBEDDED_LIBRARY)
1254 1255
  if (!opt_bootstrap)
    (void) my_delete(pidfile_name,MYF(0));	// This may not always exist
unknown's avatar
unknown committed
1256
#endif
unknown's avatar
Merge  
unknown committed
1257
  finish_client_errs();
1258 1259
  my_free((gptr) my_error_unregister(ER_ERROR_FIRST, ER_ERROR_LAST),
          MYF(MY_WME | MY_FAE | MY_ALLOW_ZERO_PTR));
1260
  DBUG_PRINT("quit", ("Error messages freed"));
unknown's avatar
unknown committed
1261 1262
  /* Tell main we are ready */
  (void) pthread_mutex_lock(&LOCK_thread_count);
1263
  DBUG_PRINT("quit", ("got thread count lock"));
unknown's avatar
unknown committed
1264
  ready_to_exit=1;
unknown's avatar
unknown committed
1265
  /* do the broadcast inside the lock to ensure that my_end() is not called */
unknown's avatar
unknown committed
1266 1267
  (void) pthread_cond_broadcast(&COND_thread_count);
  (void) pthread_mutex_unlock(&LOCK_thread_count);
unknown's avatar
unknown committed
1268 1269
  logger.cleanup_end();

unknown's avatar
unknown committed
1270 1271 1272 1273
  /*
    The following lines may never be executed as the main thread may have
    killed us
  */
1274
  DBUG_PRINT("quit", ("done with cleanup"));
unknown's avatar
unknown committed
1275 1276 1277
} /* clean_up */


1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300
/*
  This is mainly needed when running with purify, but it's still nice to
  know that all child threads have died when mysqld exits
*/

static void wait_for_signal_thread_to_end()
{
#ifndef __NETWARE__
  uint i;
  /*
    Wait up to 10 seconds for signal thread to die. We use this mainly to
    avoid getting warnings that my_thread_end has not been called
  */
  for (i= 0 ; i < 100 && signal_thread_in_use; i++)
  {
    if (pthread_kill(signal_thread, MYSQL_KILL_SIGNAL))
      break;
    my_sleep(100);				// Give it time to die
  }
#endif
}


unknown's avatar
unknown committed
1301 1302 1303
static void clean_up_mutexes()
{
  (void) pthread_mutex_destroy(&LOCK_mysql_create_db);
unknown's avatar
unknown committed
1304
  (void) pthread_mutex_destroy(&LOCK_lock_db);
unknown's avatar
unknown committed
1305
  (void) pthread_mutex_destroy(&LOCK_Acl);
1306
  (void) rwlock_destroy(&LOCK_grant);
unknown's avatar
unknown committed
1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319
  (void) pthread_mutex_destroy(&LOCK_open);
  (void) pthread_mutex_destroy(&LOCK_thread_count);
  (void) pthread_mutex_destroy(&LOCK_mapped_file);
  (void) pthread_mutex_destroy(&LOCK_status);
  (void) pthread_mutex_destroy(&LOCK_error_log);
  (void) pthread_mutex_destroy(&LOCK_delayed_insert);
  (void) pthread_mutex_destroy(&LOCK_delayed_status);
  (void) pthread_mutex_destroy(&LOCK_delayed_create);
  (void) pthread_mutex_destroy(&LOCK_manager);
  (void) pthread_mutex_destroy(&LOCK_crypt);
  (void) pthread_mutex_destroy(&LOCK_bytes_sent);
  (void) pthread_mutex_destroy(&LOCK_bytes_received);
  (void) pthread_mutex_destroy(&LOCK_user_conn);
1320
  Events::destroy_mutexes();
1321 1322
#ifdef HAVE_OPENSSL
  (void) pthread_mutex_destroy(&LOCK_des_key_file);
unknown's avatar
unknown committed
1323
#ifndef HAVE_YASSL
1324 1325 1326
  for (int i= 0; i < CRYPTO_num_locks(); ++i)
    (void) rwlock_destroy(&openssl_stdlocks[i].lock);
  OPENSSL_free(openssl_stdlocks);
1327 1328
#endif
#endif
1329
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
1330
  (void) pthread_mutex_destroy(&LOCK_rpl_status);
1331 1332
  (void) pthread_cond_destroy(&COND_rpl_status);
#endif
unknown's avatar
unknown committed
1333
  (void) pthread_mutex_destroy(&LOCK_active_mi);
unknown's avatar
unknown committed
1334 1335
  (void) rwlock_destroy(&LOCK_sys_init_connect);
  (void) rwlock_destroy(&LOCK_sys_init_slave);
unknown's avatar
unknown committed
1336
  (void) pthread_mutex_destroy(&LOCK_global_system_variables);
1337
  (void) pthread_mutex_destroy(&LOCK_global_read_lock);
unknown's avatar
unknown committed
1338
  (void) pthread_mutex_destroy(&LOCK_uuid_generator);
1339
  (void) pthread_mutex_destroy(&LOCK_prepared_stmt_count);
unknown's avatar
unknown committed
1340 1341
  (void) pthread_cond_destroy(&COND_thread_count);
  (void) pthread_cond_destroy(&COND_refresh);
unknown's avatar
unknown committed
1342
  (void) pthread_cond_destroy(&COND_global_read_lock);
unknown's avatar
unknown committed
1343 1344 1345 1346
  (void) pthread_cond_destroy(&COND_thread_cache);
  (void) pthread_cond_destroy(&COND_flush_thread_cache);
  (void) pthread_cond_destroy(&COND_manager);
}
unknown's avatar
unknown committed
1347 1348 1349 1350 1351 1352 1353 1354

/****************************************************************************
** Init IP and UNIX socket
****************************************************************************/

static void set_ports()
{
  char	*env;
1355
  if (!mysqld_port && !opt_disable_networking)
unknown's avatar
unknown committed
1356 1357
  {					// Get port if not from commandline
    struct  servent *serv_ptr;
1358 1359 1360
    mysqld_port= MYSQL_PORT;
    if ((serv_ptr= getservbyname("mysql", "tcp")))
      mysqld_port= ntohs((u_short) serv_ptr->s_port); /* purecov: inspected */
unknown's avatar
unknown committed
1361
    if ((env = getenv("MYSQL_TCP_PORT")))
1362
      mysqld_port= (uint) atoi(env);		/* purecov: inspected */
unknown's avatar
unknown committed
1363
  }
1364
  if (!mysqld_unix_port)
unknown's avatar
unknown committed
1365 1366
  {
#ifdef __WIN__
1367
    mysqld_unix_port= (char*) MYSQL_NAMEDPIPE;
unknown's avatar
unknown committed
1368
#else
1369
    mysqld_unix_port= (char*) MYSQL_UNIX_ADDR;
unknown's avatar
unknown committed
1370 1371
#endif
    if ((env = getenv("MYSQL_UNIX_PORT")))
1372
      mysqld_unix_port= env;			/* purecov: inspected */
unknown's avatar
unknown committed
1373 1374 1375
  }
}

1376
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
1377 1378
/* Change to run as another user if started with --user */

1379
static struct passwd *check_user(const char *user)
unknown's avatar
unknown committed
1380
{
1381
#if !defined(__WIN__) && !defined(__NETWARE__)
1382
  struct passwd *user_info;
1383
  uid_t user_id= geteuid();
unknown's avatar
unknown committed
1384

1385
  // Don't bother if we aren't superuser
1386
  if (user_id)
unknown's avatar
unknown committed
1387 1388
  {
    if (user)
1389
    {
1390 1391
      // Don't give a warning, if real user is same as given with --user
      user_info= getpwnam(user);
1392 1393
      if ((!user_info || user_id != user_info->pw_uid) &&
	  global_system_variables.log_warnings)
1394 1395
        sql_print_warning(
                    "One can only use the --user switch if running as root\n");
1396
    }
1397
    return NULL;
unknown's avatar
unknown committed
1398
  }
1399
  if (!user)
unknown's avatar
unknown committed
1400 1401 1402
  {
    if (!opt_bootstrap)
    {
unknown's avatar
unknown committed
1403
      sql_print_error("Fatal error: Please read \"Security\" section of the manual to find out how to run mysqld as root!\n");
unknown's avatar
unknown committed
1404 1405
      unireg_abort(1);
    }
1406
    return NULL;
unknown's avatar
unknown committed
1407 1408
  }
  if (!strcmp(user,"root"))
unknown's avatar
unknown committed
1409
    return NULL;                        // Avoid problem with dynamic libraries
unknown's avatar
unknown committed
1410

1411
  if (!(user_info= getpwnam(user)))
unknown's avatar
unknown committed
1412
  {
1413
    // Allow a numeric uid to be used
unknown's avatar
unknown committed
1414
    const char *pos;
unknown's avatar
unknown committed
1415 1416
    for (pos= user; my_isdigit(mysqld_charset,*pos); pos++) ;
    if (*pos)                                   // Not numeric id
1417 1418 1419 1420 1421
      goto err;
    if (!(user_info= getpwuid(atoi(user))))
      goto err;
    else
      return user_info;
unknown's avatar
unknown committed
1422
  }
unknown's avatar
unknown committed
1423
  else
1424 1425 1426
    return user_info;

err:
unknown's avatar
unknown committed
1427
  sql_print_error("Fatal error: Can't change to run as user '%s' ;  Please check that the user exists!\n",user);
1428
  unireg_abort(1);
unknown's avatar
unknown committed
1429 1430
#endif
  return NULL;
1431 1432 1433 1434
}

static void set_user(const char *user, struct passwd *user_info)
{
1435
#if !defined(__WIN__) && !defined(__NETWARE__)
unknown's avatar
Merge  
unknown committed
1436
  DBUG_ASSERT(user_info != 0);
unknown's avatar
unknown committed
1437
#ifdef HAVE_INITGROUPS
1438 1439 1440 1441 1442 1443 1444
  /*
    We can get a SIGSEGV when calling initgroups() on some systems when NSS
    is configured to use LDAP and the server is statically linked.  We set
    calling_initgroups as a flag to the SIGSEGV handler that is then used to
    output a specific message to help the user resolve this problem.
  */
  calling_initgroups= TRUE;
1445
  initgroups((char*) user, user_info->pw_gid);
1446
  calling_initgroups= FALSE;
unknown's avatar
unknown committed
1447
#endif
1448 1449 1450 1451
  if (setgid(user_info->pw_gid) == -1)
  {
    sql_perror("setgid");
    unireg_abort(1);
unknown's avatar
unknown committed
1452
  }
1453
  if (setuid(user_info->pw_uid) == -1)
unknown's avatar
unknown committed
1454 1455 1456 1457 1458 1459 1460
  {
    sql_perror("setuid");
    unireg_abort(1);
  }
#endif
}

unknown's avatar
unknown committed
1461

1462 1463
static void set_effective_user(struct passwd *user_info)
{
1464
#if !defined(__WIN__) && !defined(__NETWARE__)
unknown's avatar
Merge  
unknown committed
1465
  DBUG_ASSERT(user_info != 0);
1466
  if (setregid((gid_t)-1, user_info->pw_gid) == -1)
1467
  {
1468
    sql_perror("setregid");
1469
    unireg_abort(1);
unknown's avatar
unknown committed
1470
  }
1471
  if (setreuid((uid_t)-1, user_info->pw_uid) == -1)
1472
  {
1473
    sql_perror("setreuid");
1474 1475 1476 1477 1478 1479
    unireg_abort(1);
  }
#endif
}


unknown's avatar
unknown committed
1480 1481 1482 1483
/* Change root user if started with  --chroot */

static void set_root(const char *path)
{
1484
#if !defined(__WIN__) && !defined(__NETWARE__)
unknown's avatar
unknown committed
1485 1486 1487 1488 1489
  if (chroot(path) == -1)
  {
    sql_perror("chroot");
    unireg_abort(1);
  }
1490
  my_setwd("/", MYF(0));
unknown's avatar
unknown committed
1491 1492 1493
#endif
}

unknown's avatar
unknown committed
1494
static void network_init(void)
unknown's avatar
unknown committed
1495 1496 1497 1498 1499 1500
{
  struct sockaddr_in	IPaddr;
#ifdef HAVE_SYS_UN_H
  struct sockaddr_un	UNIXaddr;
#endif
  int	arg=1;
1501 1502 1503 1504
  int   ret;
  uint  waited;
  uint  this_wait;
  uint  retry;
unknown's avatar
unknown committed
1505
  DBUG_ENTER("network_init");
1506
  LINT_INIT(ret);
unknown's avatar
unknown committed
1507 1508 1509

  set_ports();

1510
  if (mysqld_port != 0 && !opt_disable_networking && !opt_bootstrap)
unknown's avatar
unknown committed
1511
  {
1512
    DBUG_PRINT("general",("IP Socket is %d",mysqld_port));
unknown's avatar
unknown committed
1513 1514 1515 1516 1517 1518 1519 1520 1521 1522
    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;
1523
    IPaddr.sin_port = (unsigned short) htons((unsigned short) mysqld_port);
1524 1525 1526 1527 1528 1529

#ifndef __WIN__
    /*
      We should not use SO_REUSEADDR on windows as this would enable a
      user to open two mysqld servers with the same TCP/IP port.
    */
unknown's avatar
unknown committed
1530
    (void) setsockopt(ip_sock,SOL_SOCKET,SO_REUSEADDR,(char*)&arg,sizeof(arg));
unknown's avatar
unknown committed
1531
#endif /* __WIN__ */
1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543
    /*
      Sometimes the port is not released fast enough when stopping and
      restarting the server. This happens quite often with the test suite
      on busy Linux systems. Retry to bind the address at these intervals:
      Sleep intervals: 1, 2, 4,  6,  9, 13, 17, 22, ...
      Retry at second: 1, 3, 7, 13, 22, 35, 52, 74, ...
      Limit the sequence by mysqld_port_timeout (set --port-open-timeout=#).
    */
    for (waited= 0, retry= 1; ; retry++, waited+= this_wait)
    {
      if (((ret= bind(ip_sock, my_reinterpret_cast(struct sockaddr *) (&IPaddr),
                      sizeof(IPaddr))) >= 0) ||
1544
          (socket_errno != SOCKET_EADDRINUSE) ||
1545 1546 1547 1548 1549 1550 1551
          (waited >= mysqld_port_timeout))
        break;
      sql_print_information("Retrying bind on TCP/IP port %u", mysqld_port);
      this_wait= retry * retry / 3 + 1;
      sleep(this_wait);
    }
    if (ret < 0)
unknown's avatar
unknown committed
1552 1553
    {
      DBUG_PRINT("error",("Got error: %d from bind",socket_errno));
1554
      sql_perror("Can't start server: Bind on TCP/IP port");
1555
      sql_print_error("Do you already have another mysqld server running on port: %d ?",mysqld_port);
unknown's avatar
unknown committed
1556 1557
      unireg_abort(1);
    }
1558
    if (listen(ip_sock,(int) back_log) < 0)
unknown's avatar
unknown committed
1559
    {
1560
      sql_perror("Can't start server: listen() on TCP/IP port");
1561
      sql_print_error("listen() on TCP/IP failed with error %d",
unknown's avatar
unknown committed
1562
		      socket_errno);
unknown's avatar
unknown committed
1563 1564
      unireg_abort(1);
    }
unknown's avatar
unknown committed
1565
  }
1566

unknown's avatar
unknown committed
1567 1568
#ifdef __NT__
  /* create named pipe */
1569
  if (Service.IsNT() && mysqld_unix_port[0] && !opt_bootstrap &&
unknown's avatar
unknown committed
1570
      opt_enable_named_pipe)
unknown's avatar
unknown committed
1571
  {
1572 1573 1574
    
    pipe_name[sizeof(pipe_name)-1]= 0;		/* Safety if too long string */
    strxnmov(pipe_name, sizeof(pipe_name)-1, "\\\\.\\pipe\\",
1575
	     mysqld_unix_port, NullS);
1576 1577
    bzero((char*) &saPipeSecurity, sizeof(saPipeSecurity));
    bzero((char*) &sdPipeDescriptor, sizeof(sdPipeDescriptor));
1578
    if (!InitializeSecurityDescriptor(&sdPipeDescriptor,
1579
				      SECURITY_DESCRIPTOR_REVISION))
unknown's avatar
unknown committed
1580 1581 1582 1583 1584 1585 1586 1587 1588
    {
      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);
    }
unknown's avatar
Merge  
unknown committed
1589
    saPipeSecurity.nLength = sizeof(SECURITY_ATTRIBUTES);
unknown's avatar
unknown committed
1590 1591
    saPipeSecurity.lpSecurityDescriptor = &sdPipeDescriptor;
    saPipeSecurity.bInheritHandle = FALSE;
1592 1593 1594 1595 1596 1597 1598 1599 1600 1601
    if ((hPipe= CreateNamedPipe(pipe_name,
				PIPE_ACCESS_DUPLEX,
				PIPE_TYPE_BYTE |
				PIPE_READMODE_BYTE |
				PIPE_WAIT,
				PIPE_UNLIMITED_INSTANCES,
				(int) global_system_variables.net_buffer_length,
				(int) global_system_variables.net_buffer_length,
				NMPWAIT_USE_DEFAULT_WAIT,
				&saPipeSecurity)) == INVALID_HANDLE_VALUE)
unknown's avatar
unknown committed
1602 1603 1604 1605 1606 1607 1608
      {
	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 );
unknown's avatar
Merge  
unknown committed
1609 1610 1611
	MessageBox(NULL, (LPTSTR) lpMsgBuf, "Error from CreateNamedPipe",
		    MB_OK|MB_ICONINFORMATION);
	LocalFree(lpMsgBuf);
unknown's avatar
unknown committed
1612 1613 1614 1615 1616
	unireg_abort(1);
      }
  }
#endif

1617
#if defined(HAVE_SYS_UN_H)
unknown's avatar
unknown committed
1618 1619 1620
  /*
  ** Create the UNIX socket
  */
1621
  if (mysqld_unix_port[0] && !opt_bootstrap)
unknown's avatar
unknown committed
1622
  {
1623
    DBUG_PRINT("general",("UNIX Socket is %s",mysqld_unix_port));
unknown's avatar
unknown committed
1624

unknown's avatar
unknown committed
1625 1626 1627 1628 1629 1630
    if (strlen(mysqld_unix_port) > (sizeof(UNIXaddr.sun_path) - 1))
    {
      sql_print_error("The socket file path is too long (> %d): %s",
                    sizeof(UNIXaddr.sun_path) - 1, mysqld_unix_port);
      unireg_abort(1);
    }
1631
    if ((unix_sock= socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
unknown's avatar
unknown committed
1632 1633 1634 1635 1636 1637
    {
      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;
1638 1639
    strmov(UNIXaddr.sun_path, mysqld_unix_port);
    (void) unlink(mysqld_unix_port);
unknown's avatar
unknown committed
1640 1641 1642 1643 1644 1645 1646
    (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 */
1647
      sql_print_error("Do you already have another mysqld server running on socket: %s ?",mysqld_unix_port);
unknown's avatar
unknown committed
1648 1649 1650 1651
      unireg_abort(1);					/* purecov: tested */
    }
    umask(((~my_umask) & 0666));
#if defined(S_IFSOCK) && defined(SECURE_SOCKETS)
1652
    (void) chmod(mysqld_unix_port,S_IFSOCK);	/* Fix solaris 2.6 bug */
unknown's avatar
unknown committed
1653
#endif
1654
    if (listen(unix_sock,(int) back_log) < 0)
1655
      sql_print_warning("listen() on Unix socket failed with error %d",
unknown's avatar
unknown committed
1656
		      socket_errno);
unknown's avatar
unknown committed
1657 1658 1659 1660 1661 1662
  }
#endif
  DBUG_PRINT("info",("server started"));
  DBUG_VOID_RETURN;
}

1663
#endif /*!EMBEDDED_LIBRARY*/
unknown's avatar
unknown committed
1664

1665
void MYSQLerror(const char *s)
unknown's avatar
unknown committed
1666
{
1667
  THD *thd=current_thd;
1668
  char *yytext= (char*) thd->lex->tok_start;
1669 1670
  /* "parse error" changed into "syntax error" between bison 1.75 and 1.875 */
  if (strcmp(s,"parse error") == 0 || strcmp(s,"syntax error") == 0)
unknown's avatar
unknown committed
1671
    s=ER(ER_SYNTAX_ERROR);
unknown's avatar
Merge  
unknown committed
1672 1673 1674
  my_printf_error(ER_PARSE_ERROR,  ER(ER_PARSE_ERROR), MYF(0), s,
                  (yytext ? (char*) yytext : ""),
                  thd->lex->yylineno);
unknown's avatar
unknown committed
1675 1676
}

1677

1678
#ifndef EMBEDDED_LIBRARY
1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691
/*
  Close a connection

  SYNOPSIS
    close_connection()
    thd		Thread handle
    errcode	Error code to print to console
    lock	1 if we have have to lock LOCK_thread_count

  NOTES
    For the connection that is doing shutdown, this is called twice
*/

1692
void close_connection(THD *thd, uint errcode, bool lock)
unknown's avatar
unknown committed
1693
{
1694
  st_vio *vio;
unknown's avatar
unknown committed
1695 1696
  DBUG_ENTER("close_connection");
  DBUG_PRINT("enter",("fd: %s  error: '%s'",
1697 1698 1699
		      thd->net.vio ? vio_description(thd->net.vio) :
		      "(not connected)",
		      errcode ? ER(errcode) : ""));
unknown's avatar
unknown committed
1700 1701
  if (lock)
    (void) pthread_mutex_lock(&LOCK_thread_count);
unknown's avatar
unknown committed
1702 1703
  thd->killed= THD::KILL_CONNECTION;
  if ((vio= thd->net.vio) != 0)
unknown's avatar
unknown committed
1704 1705
  {
    if (errcode)
unknown's avatar
Merge  
unknown committed
1706
      net_send_error(thd, errcode, ER(errcode)); /* purecov: inspected */
unknown's avatar
unknown committed
1707 1708 1709 1710 1711 1712
    vio_close(vio);			/* vio is freed in delete thd */
  }
  if (lock)
    (void) pthread_mutex_unlock(&LOCK_thread_count);
  DBUG_VOID_RETURN;
}
1713 1714
#endif /* EMBEDDED_LIBRARY */

unknown's avatar
unknown committed
1715 1716 1717 1718

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

1719
extern "C" sig_handler end_thread_signal(int sig __attribute__((unused)))
unknown's avatar
unknown committed
1720 1721 1722
{
  THD *thd=current_thd;
  DBUG_ENTER("end_thread_signal");
1723
  if (thd && ! thd->bootstrap)
1724 1725
  {
    statistic_increment(killed_threads, &LOCK_status);
unknown's avatar
unknown committed
1726
    end_thread(thd,0);
1727
  }
unknown's avatar
unknown committed
1728 1729 1730 1731 1732 1733 1734
  DBUG_VOID_RETURN;				/* purecov: deadcode */
}


void end_thread(THD *thd, bool put_in_cache)
{
  DBUG_ENTER("end_thread");
unknown's avatar
unknown committed
1735
  thd->cleanup();
unknown's avatar
unknown committed
1736 1737 1738
  (void) pthread_mutex_lock(&LOCK_thread_count);
  thread_count--;
  delete thd;
1739

1740 1741
  if (put_in_cache && cached_thread_count < thread_cache_size &&
      ! abort_loop && !kill_cached_threads)
unknown's avatar
unknown committed
1742 1743
  {
    /* Don't kill the thread, just put it in cache for reuse */
unknown's avatar
unknown committed
1744
    DBUG_PRINT("info", ("Adding thread to cache"));
unknown's avatar
unknown committed
1745 1746 1747 1748 1749 1750 1751 1752 1753 1754
    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();
1755
      thd->real_id=pthread_self();
1756
      thd->thread_stack= (char*) &thd;          // For store_globals
unknown's avatar
unknown committed
1757
      (void) thd->store_globals();
1758
      thd->thr_create_time= time(NULL);
1759
      threads.append(thd);
unknown's avatar
unknown committed
1760 1761 1762 1763 1764 1765 1766
      pthread_mutex_unlock(&LOCK_thread_count);
      DBUG_VOID_RETURN;
    }
  }

  /* Tell main we are ready */
  (void) pthread_mutex_unlock(&LOCK_thread_count);
1767
  /* It's safe to broadcast outside a lock (COND... is not deleted here) */
unknown's avatar
unknown committed
1768
  DBUG_PRINT("signal", ("Broadcasting COND_thread_count"));
unknown's avatar
unknown committed
1769
  (void) pthread_cond_broadcast(&COND_thread_count);
1770
#ifdef ONE_THREAD
unknown's avatar
unknown committed
1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794
  if (!(test_flags & TEST_NO_THREADS))	// For debugging under Linux
#endif
  {
    my_thread_end();
    pthread_exit(0);
  }
  DBUG_VOID_RETURN;
}


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


1795 1796 1797 1798 1799
/*
  Aborts a thread nicely. Commes here on SIGPIPE
  TODO: One should have to fix that thr_alarm know about this
  thread too.
*/
unknown's avatar
unknown committed
1800 1801

#ifdef THREAD_SPECIFIC_SIGPIPE
1802
extern "C" sig_handler abort_thread(int sig __attribute__((unused)))
unknown's avatar
unknown committed
1803 1804 1805 1806
{
  THD *thd=current_thd;
  DBUG_ENTER("abort_thread");
  if (thd)
unknown's avatar
Merge  
unknown committed
1807
    thd->killed= THD::KILL_CONNECTION;
unknown's avatar
unknown committed
1808 1809 1810 1811 1812
  DBUG_VOID_RETURN;
}
#endif

/******************************************************************************
1813 1814 1815
  Setup a signal thread with handles all signals.
  Because Linux doesn't support schemas use a mutex to check that
  the signal thread is ready before continuing
unknown's avatar
unknown committed
1816 1817
******************************************************************************/

1818
#if defined(__WIN__)
unknown's avatar
unknown committed
1819 1820 1821 1822
static void init_signals(void)
{
  int signals[] = {SIGINT,SIGILL,SIGFPE,SIGSEGV,SIGTERM,SIGABRT } ;
  for (uint i=0 ; i < sizeof(signals)/sizeof(int) ; i++)
unknown's avatar
Merge  
unknown committed
1823
    signal(signals[i], kill_server) ;
unknown's avatar
unknown committed
1824
#if defined(__WIN__)
unknown's avatar
unknown committed
1825
  signal(SIGBREAK,SIG_IGN);	//ignore SIGBREAK for NT
unknown's avatar
unknown committed
1826 1827 1828
#else
  signal(SIGBREAK, kill_server);
#endif
unknown's avatar
unknown committed
1829 1830
}

1831
static void start_signal_handler(void)
1832 1833 1834 1835 1836
{
  // Save vm id of this process
  if (!opt_bootstrap)
    create_pid_file();
}
unknown's avatar
unknown committed
1837 1838 1839

static void check_data_home(const char *path)
{}
1840

unknown's avatar
unknown committed
1841

unknown's avatar
unknown committed
1842 1843 1844 1845 1846
#elif defined(__NETWARE__)

// down server event callback
void mysql_down_server_cb(void *, void *)
{
unknown's avatar
Merge  
unknown committed
1847
  event_flag= TRUE;
unknown's avatar
unknown committed
1848 1849 1850
  kill_server(0);
}

unknown's avatar
unknown committed
1851

unknown's avatar
unknown committed
1852 1853
// destroy callback resources
void mysql_cb_destroy(void *)
unknown's avatar
Merge  
unknown committed
1854 1855
{
  UnRegisterEventNotification(eh);  // cleanup down event notification
unknown's avatar
unknown committed
1856
  NX_UNWRAP_INTERFACE(ref);
unknown's avatar
Merge  
unknown committed
1857 1858
  /* Deregister NSS volume deactivation event */
  NX_UNWRAP_INTERFACE(refneb);
unknown's avatar
unknown committed
1859
  if (neb_consumer_id)
1860
    UnRegisterConsumer(neb_consumer_id, NULL);
unknown's avatar
unknown committed
1861 1862
}

unknown's avatar
unknown committed
1863

unknown's avatar
unknown committed
1864 1865 1866 1867 1868
// initialize callbacks
void mysql_cb_init()
{
  // register for down server event
  void *handle = getnlmhandle();
unknown's avatar
unknown committed
1869 1870
  rtag_t rt= AllocateResourceTag(handle, "MySQL Down Server Callback",
                                 EventSignature);
unknown's avatar
unknown committed
1871
  NX_WRAP_INTERFACE((void *)mysql_down_server_cb, 2, (void **)&ref);
unknown's avatar
unknown committed
1872 1873 1874 1875 1876 1877 1878 1879
  eh= RegisterForEventNotification(rt, EVENT_PRE_DOWN_SERVER,
                                   EVENT_PRIORITY_APPLICATION,
                                   NULL, ref, NULL);

  /*
    Register for volume deactivation event
    Wrap the callback function, as it is called by non-LibC thread
  */
1880
  (void *) NX_WRAP_INTERFACE(neb_event_callback, 1, &refneb);
unknown's avatar
unknown committed
1881 1882
  registerwithneb();

unknown's avatar
unknown committed
1883 1884 1885
  NXVmRegisterExitHandler(mysql_cb_destroy, NULL);  // clean-up
}

unknown's avatar
unknown committed
1886

1887
/* To get the name of the NetWare volume having MySQL data folder */
unknown's avatar
unknown committed
1888

1889
static void getvolumename()
unknown's avatar
unknown committed
1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905
{
  char *p;
  /*
    We assume that data path is already set.
    If not it won't come here. Terminate after volume name
  */
  if ((p= strchr(mysql_real_data_home, ':')))
    strmake(datavolname, mysql_real_data_home,
            (uint) (p - mysql_real_data_home));
}


/*
  Registering with NEB for NSS Volume Deactivation event
*/

1906
static void registerwithneb()
unknown's avatar
unknown committed
1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957
{

  ConsumerRegistrationInfo reg_info;
    
  /* Clear NEB registration structure */
  bzero((char*) &reg_info, sizeof(struct ConsumerRegistrationInfo));

  /* Fill the NEB consumer information structure */
  reg_info.CRIVersion= 1;  	            // NEB version
  /* NEB Consumer name */
  reg_info.CRIConsumerName= (BYTE *) "MySQL Database Server";
  /* Event of interest */
  reg_info.CRIEventName= (BYTE *) "NSS.ChangeVolState.Enter";
  reg_info.CRIUserParameter= NULL;	    // Consumer Info
  reg_info.CRIEventFlags= 0;	            // Event flags
  /* Consumer NLM handle */
  reg_info.CRIOwnerID= (LoadDefinitionStructure *)getnlmhandle();
  reg_info.CRIConsumerESR= NULL;	    // No consumer ESR required
  reg_info.CRISecurityToken= 0;	            // No security token for the event
  reg_info.CRIConsumerFlags= 0;             // SMP_ENABLED_BIT;	
  reg_info.CRIFilterName= 0;	            // No event filtering
  reg_info.CRIFilterDataLength= 0;          // No filtering data
  reg_info.CRIFilterData= 0;	            // No filtering data
  /* Callback function for the event */
  (void *)reg_info.CRIConsumerCallback= (void *) refneb;
  reg_info.CRIOrder= 0;	                    // Event callback order
  reg_info.CRIConsumerType= CHECK_CONSUMER; // Consumer type

  /* Register for the event with NEB */
  if (RegisterConsumer(&reg_info))
  {
    consoleprintf("Failed to register for NSS Volume Deactivation event \n");
    return;
  }
  /* This ID is required for deregistration */
  neb_consumer_id= reg_info.CRIConsumerID;

  /* Get MySQL data volume name, stored in global variable datavolname */
  getvolumename();

  /*
    Get the NSS volume ID of the MySQL Data volume.
    Volume ID is stored in a global variable
  */
  getvolumeID((BYTE*) datavolname);	
}


/*
  Callback for NSS Volume Deactivation event
*/
1958

unknown's avatar
unknown committed
1959 1960 1961
ulong neb_event_callback(struct EventBlock *eblock)
{
  EventChangeVolStateEnter_s *voldata;
1962 1963
  extern bool nw_panic;

unknown's avatar
unknown committed
1964 1965 1966
  voldata= (EventChangeVolStateEnter_s *)eblock->EBEventData;

  /* Deactivation of a volume */
unknown's avatar
unknown committed
1967 1968 1969
  if ((voldata->oldState == zVOLSTATE_ACTIVE &&
       voldata->newState == zVOLSTATE_DEACTIVE ||
       voldata->newState == zVOLSTATE_MAINTENANCE))
unknown's avatar
unknown committed
1970 1971 1972 1973 1974 1975 1976 1977
  {
    /*
      Ensure that we bring down MySQL server only for MySQL data
      volume deactivation
    */
    if (!memcmp(&voldata->volID, &datavolid, sizeof(VolumeID_t)))
    {
      consoleprintf("MySQL data volume is deactivated, shutting down MySQL Server \n");
unknown's avatar
unknown committed
1978
      event_flag= TRUE;
1979
      nw_panic = TRUE;
1980
      event_flag= TRUE;
unknown's avatar
unknown committed
1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993
      kill_server(0);
    }
  }
  return 0;
}


/*
  Function to get NSS volume ID of the MySQL data
*/

#define ADMIN_VOL_PATH					"_ADMIN:/Volumes/"

1994
static void getvolumeID(BYTE *volumeName)
unknown's avatar
unknown committed
1995 1996 1997 1998 1999 2000 2001
{
  char path[zMAX_FULL_NAME];
  Key_t rootKey= 0, fileKey= 0;
  QUAD getInfoMask;
  zInfo_s info;
  STATUS status;

2002
  /* Get the root key */
unknown's avatar
unknown committed
2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038
  if ((status= zRootKey(0, &rootKey)) != zOK)
  {
    consoleprintf("\nGetNSSVolumeProperties - Failed to get root key, status: %d\n.", (int) status);
    goto exit;
  }

  /*
    Get the file key. This is the key to the volume object in the
    NSS admin volumes directory.
  */

  strxmov(path, (const char *) ADMIN_VOL_PATH, (const char *) volumeName,
          NullS);
  if ((status= zOpen(rootKey, zNSS_TASK, zNSPACE_LONG|zMODE_UTF8, 
                     (BYTE *) path, zRR_READ_ACCESS, &fileKey)) != zOK)
  {
    consoleprintf("\nGetNSSVolumeProperties - Failed to get file, status: %d\n.", (int) status);
    goto exit;
  }

  getInfoMask= zGET_IDS | zGET_VOLUME_INFO ;
  if ((status= zGetInfo(fileKey, getInfoMask, sizeof(info), 
                        zINFO_VERSION_A, &info)) != zOK)
  {
    consoleprintf("\nGetNSSVolumeProperties - Failed in zGetInfo, status: %d\n.", (int) status);
    goto exit;
  }

  /* Copy the data to global variable */
  datavolid.timeLow= info.vol.volumeID.timeLow;
  datavolid.timeMid= info.vol.volumeID.timeMid;
  datavolid.timeHighAndVersion= info.vol.volumeID.timeHighAndVersion;
  datavolid.clockSeqHighAndReserved= info.vol.volumeID.clockSeqHighAndReserved;
  datavolid.clockSeqLow= info.vol.volumeID.clockSeqLow;
  /* This is guranteed to be 6-byte length (but sizeof() would be better) */
  memcpy(datavolid.node, info.vol.volumeID.node, (unsigned int) 6);
unknown's avatar
Merge  
unknown committed
2039

unknown's avatar
unknown committed
2040 2041 2042 2043 2044 2045 2046 2047
exit:
  if (rootKey)
    zClose(rootKey);
  if (fileKey)
    zClose(fileKey);
}


unknown's avatar
unknown committed
2048 2049 2050 2051 2052 2053 2054 2055
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);
  mysql_cb_init();  // initialize callbacks

2056
}
unknown's avatar
unknown committed
2057

unknown's avatar
unknown committed
2058 2059 2060 2061
static void start_signal_handler(void)
{
  // Save vm id of this process
  if (!opt_bootstrap)
2062
    create_pid_file();
unknown's avatar
unknown committed
2063 2064 2065 2066
  // no signal handler
}


unknown's avatar
unknown committed
2067 2068 2069 2070 2071 2072
/*
  Warn if the data is on a Traditional volume

  NOTE
    Already done by mysqld_safe
*/
unknown's avatar
unknown committed
2073 2074

static void check_data_home(const char *path)
2075 2076 2077
{
}

2078
#else /* if ! __WIN__  */
unknown's avatar
unknown committed
2079

unknown's avatar
unknown committed
2080 2081
#ifdef HAVE_LINUXTHREADS
#define UNSAFE_DEFAULT_LINUX_THREADS 200
2082
#endif
2083

2084
extern "C" sig_handler handle_segfault(int sig)
2085
{
unknown's avatar
unknown committed
2086
  THD *thd=current_thd;
2087 2088 2089 2090 2091 2092
  /*
    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
  */
2093
  if (segfaulted)
unknown's avatar
unknown committed
2094 2095 2096 2097
  {
    fprintf(stderr, "Fatal signal %d while backtracing\n", sig);
    exit(1);
  }
2098

2099
  segfaulted = 1;
2100
  fprintf(stderr,"\
2101
mysqld got signal %d;\n\
unknown's avatar
unknown committed
2102
This could be because you hit a bug. It is also possible that this binary\n\
unknown's avatar
unknown committed
2103
or one of the libraries it was linked against is corrupt, improperly built,\n\
unknown's avatar
unknown committed
2104 2105 2106 2107 2108
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\
unknown's avatar
unknown committed
2109
and this may fail.\n\n");
unknown's avatar
unknown committed
2110
  fprintf(stderr, "key_buffer_size=%lu\n", 
unknown's avatar
unknown committed
2111
          (ulong) dflt_key_cache->key_cache_mem_size);
unknown's avatar
unknown committed
2112 2113 2114 2115
  fprintf(stderr, "read_buffer_size=%ld\n", (long) global_system_variables.read_buff_size);
  fprintf(stderr, "max_used_connections=%lu\n", max_used_connections);
  fprintf(stderr, "max_connections=%lu\n", max_connections);
  fprintf(stderr, "threads_connected=%u\n", thread_count);
unknown's avatar
unknown committed
2116
  fprintf(stderr, "It is possible that mysqld could use up to \n\
unknown's avatar
unknown committed
2117
key_buffer_size + (read_buffer_size + sort_buffer_size)*max_connections = %lu K\n\
unknown's avatar
unknown committed
2118
bytes of memory\n", ((ulong) dflt_key_cache->key_cache_mem_size +
2119
		     (global_system_variables.read_buff_size +
unknown's avatar
unknown committed
2120
		      global_system_variables.sortbuff_size) *
2121
		     max_connections)/ 1024);
unknown's avatar
unknown committed
2122
  fprintf(stderr, "Hope that's ok; if not, decrease some variables in the equation.\n\n");
2123

2124
#if defined(HAVE_LINUXTHREADS)
unknown's avatar
unknown committed
2125 2126 2127 2128
  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\
unknown's avatar
unknown committed
2129 2130
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\
unknown's avatar
unknown committed
2131
the thread stack. Please read http://www.mysql.com/doc/en/Linux.html\n\n",
unknown's avatar
unknown committed
2132 2133 2134
	    thread_count);
  }
#endif /* HAVE_LINUXTHREADS */
unknown's avatar
unknown committed
2135

unknown's avatar
unknown committed
2136
#ifdef HAVE_STACKTRACE
2137
  if (!(test_flags & TEST_NO_STACKTRACE))
unknown's avatar
unknown committed
2138
  {
2139
    fprintf(stderr,"thd=%p\n",thd);
unknown's avatar
unknown committed
2140 2141
    print_stacktrace(thd ? (gptr) thd->thread_stack : (gptr) 0,
		     thread_stack);
unknown's avatar
unknown committed
2142
  }
unknown's avatar
unknown committed
2143 2144 2145 2146 2147
  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);
unknown's avatar
unknown committed
2148
    fprintf(stderr, "thd->thread_id=%lu\n", (ulong) thd->thread_id);
unknown's avatar
unknown committed
2149 2150
  }
  fprintf(stderr, "\
unknown's avatar
unknown committed
2151
The manual page at http://www.mysql.com/doc/en/Crashing.html contains\n\
unknown's avatar
unknown committed
2152
information that should help you find out what is causing the crash.\n");
2153
  fflush(stderr);
unknown's avatar
unknown committed
2154 2155
#endif /* HAVE_STACKTRACE */

2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166
#ifdef HAVE_INITGROUPS
  if (calling_initgroups)
    fprintf(stderr, "\n\
This crash occured while the server was calling initgroups(). This is\n\
often due to the use of a mysqld that is statically linked against glibc\n\
and configured to use LDAP in /etc/nsswitch.conf. You will need to either\n\
upgrade to a version of glibc that does not have this problem (2.3.4 or\n\
later when used with nscd), disable LDAP in your nsswitch.conf, or use a\n\
mysqld that is not statically linked.\n");
#endif

2167
 if (test_flags & TEST_CORE_ON_SIGNAL)
unknown's avatar
unknown committed
2168 2169 2170
 {
   fprintf(stderr, "Writing a core file\n");
   fflush(stderr);
2171
   write_core(sig);
unknown's avatar
unknown committed
2172
 }
2173
 exit(1);
2174 2175
}

unknown's avatar
unknown committed
2176 2177 2178 2179 2180 2181
#ifndef SA_RESETHAND
#define SA_RESETHAND 0
#endif
#ifndef SA_NODEFER
#define SA_NODEFER 0
#endif
2182

unknown's avatar
unknown committed
2183 2184 2185
static void init_signals(void)
{
  sigset_t set;
2186
  struct sigaction sa;
unknown's avatar
unknown committed
2187 2188
  DBUG_ENTER("init_signals");

2189
  if (test_flags & TEST_SIGINT)
2190 2191
    my_sigset(THR_KILL_SIGNAL,end_thread_signal);
  my_sigset(THR_SERVER_ALARM,print_signal_warning); // Should never be called!
unknown's avatar
unknown committed
2192

unknown's avatar
unknown committed
2193
  if (!(test_flags & TEST_NO_STACKTRACE) || (test_flags & TEST_CORE_ON_SIGNAL))
unknown's avatar
unknown committed
2194
  {
unknown's avatar
unknown committed
2195 2196 2197 2198
    sa.sa_flags = SA_RESETHAND | SA_NODEFER;
    sigemptyset(&sa.sa_mask);
    sigprocmask(SIG_SETMASK,&sa.sa_mask,NULL);

unknown's avatar
unknown committed
2199
    init_stacktrace();
unknown's avatar
unknown committed
2200 2201 2202
#if defined(__amiga__)
    sa.sa_handler=(void(*)())handle_segfault;
#else
unknown's avatar
unknown committed
2203
    sa.sa_handler=handle_segfault;
unknown's avatar
unknown committed
2204
#endif
unknown's avatar
unknown committed
2205
    sigaction(SIGSEGV, &sa, NULL);
2206
    sigaction(SIGABRT, &sa, NULL);
unknown's avatar
unknown committed
2207
#ifdef SIGBUS
unknown's avatar
unknown committed
2208
    sigaction(SIGBUS, &sa, NULL);
unknown's avatar
unknown committed
2209
#endif
unknown's avatar
unknown committed
2210
    sigaction(SIGILL, &sa, NULL);
2211
    sigaction(SIGFPE, &sa, NULL);
unknown's avatar
unknown committed
2212
  }
2213 2214 2215 2216 2217

#ifdef HAVE_GETRLIMIT
  if (test_flags & TEST_CORE_ON_SIGNAL)
  {
    /* Change limits so that we will get a core file */
2218
    STRUCT_RLIMIT rl;
2219
    rl.rlim_cur = rl.rlim_max = RLIM_INFINITY;
unknown's avatar
unknown committed
2220
    if (setrlimit(RLIMIT_CORE, &rl) && global_system_variables.log_warnings)
2221
      sql_print_warning("setrlimit could not change the size of core files to 'infinity';  We may not be able to generate a core file on signals");
2222 2223
  }
#endif
unknown's avatar
unknown committed
2224
  (void) sigemptyset(&set);
2225
  my_sigset(SIGPIPE,SIG_IGN);
unknown's avatar
unknown committed
2226 2227
  sigaddset(&set,SIGPIPE);
  sigaddset(&set,SIGINT);
2228
#ifndef IGNORE_SIGHUP_SIGQUIT
unknown's avatar
unknown committed
2229 2230
  sigaddset(&set,SIGQUIT);
  sigaddset(&set,SIGHUP);
2231 2232
#endif
  sigaddset(&set,SIGTERM);
2233 2234

  /* Fix signals if blocked by parents (can happen on Mac OS X) */
unknown's avatar
unknown committed
2235
  sigemptyset(&sa.sa_mask);
2236 2237 2238 2239 2240 2241
  sa.sa_flags = 0;
  sa.sa_handler = print_signal_warning;
  sigaction(SIGTERM, &sa, (struct sigaction*) 0);
  sa.sa_flags = 0;
  sa.sa_handler = print_signal_warning;
  sigaction(SIGHUP, &sa, (struct sigaction*) 0);
unknown's avatar
unknown committed
2242 2243 2244 2245
#ifdef SIGTSTP
  sigaddset(&set,SIGTSTP);
#endif
  sigaddset(&set,THR_SERVER_ALARM);
2246 2247
  if (test_flags & TEST_SIGINT)
    sigdelset(&set,THR_KILL_SIGNAL);		// May be SIGINT
unknown's avatar
unknown committed
2248
  sigdelset(&set,THR_CLIENT_ALARM);		// For alarms
2249 2250
  sigprocmask(SIG_SETMASK,&set,NULL);
  pthread_sigmask(SIG_SETMASK,&set,NULL);
2251 2252 2253 2254
  DBUG_VOID_RETURN;
}


unknown's avatar
unknown committed
2255
#ifndef EMBEDDED_LIBRARY
2256 2257 2258 2259 2260
static void start_signal_handler(void)
{
  int error;
  pthread_attr_t thr_attr;
  DBUG_ENTER("start_signal_handler");
unknown's avatar
unknown committed
2261 2262 2263 2264 2265 2266 2267

  (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);
2268
#if defined(__ia64__) || defined(__ia64)
2269 2270 2271 2272
  /*
    Peculiar things with ia64 platforms - it seems we only have half the
    stack size in reality, so we have to double it here
  */
2273 2274
  pthread_attr_setstacksize(&thr_attr,thread_stack*2);
#else
2275
  pthread_attr_setstacksize(&thr_attr,thread_stack);
2276
#endif
unknown's avatar
unknown committed
2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293
#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;
}


2294
/* This threads handles all signals and alarms */
unknown's avatar
unknown committed
2295 2296

/* ARGSUSED */
2297
pthread_handler_t signal_hand(void *arg __attribute__((unused)))
unknown's avatar
unknown committed
2298 2299 2300 2301 2302
{
  sigset_t set;
  int sig;
  my_thread_init();				// Init new thread
  DBUG_ENTER("signal_hand");
unknown's avatar
unknown committed
2303 2304
  signal_thread_in_use= 1;

unknown's avatar
unknown committed
2305 2306
  /*
    Setup alarm handler
2307 2308
    This should actually be '+ max_number_of_slaves' instead of +10,
    but the +10 should be quite safe.
unknown's avatar
unknown committed
2309
  */
2310 2311
  init_thr_alarm(max_connections +
		 global_system_variables.max_insert_delayed_threads + 10);
unknown's avatar
unknown committed
2312
#if SIGINT != THR_KILL_SIGNAL
2313 2314 2315 2316 2317 2318
  if (test_flags & TEST_SIGINT)
  {
    (void) sigemptyset(&set);			// Setup up SIGINT for debug
    (void) sigaddset(&set,SIGINT);		// For debugging
    (void) pthread_sigmask(SIG_UNBLOCK,&set,NULL);
  }
unknown's avatar
unknown committed
2319 2320 2321 2322 2323
#endif
  (void) sigemptyset(&set);			// Setup up SIGINT for debug
#ifdef USE_ONE_SIGNAL_HAND
  (void) sigaddset(&set,THR_SERVER_ALARM);	// For alarms
#endif
2324
#ifndef IGNORE_SIGHUP_SIGQUIT
unknown's avatar
unknown committed
2325 2326 2327 2328
  (void) sigaddset(&set,SIGQUIT);
#if THR_CLIENT_ALARM != SIGHUP
  (void) sigaddset(&set,SIGHUP);
#endif
2329 2330
#endif
  (void) sigaddset(&set,SIGTERM);
unknown's avatar
unknown committed
2331 2332 2333
  (void) sigaddset(&set,SIGTSTP);

  /* Save pid to this process (or thread on Linux) */
2334
  if (!opt_bootstrap)
2335 2336
    create_pid_file();

2337 2338 2339 2340 2341 2342 2343
#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 */
unknown's avatar
unknown committed
2344

2345 2346 2347 2348 2349 2350 2351
  /*
    signal to start_signal_handler that we are ready
    This works by waiting for start_signal_handler to free mutex,
    after which we signal it that we are ready.
    At this pointer there is no other threads running, so there
    should not be any other pthread_cond_signal() calls.
  */
unknown's avatar
unknown committed
2352 2353
  (void) pthread_mutex_lock(&LOCK_thread_count);
  (void) pthread_mutex_unlock(&LOCK_thread_count);
2354
  (void) pthread_cond_broadcast(&COND_thread_count);
unknown's avatar
unknown committed
2355

2356
  (void) pthread_sigmask(SIG_BLOCK,&set,NULL);
unknown's avatar
unknown committed
2357 2358 2359 2360 2361
  for (;;)
  {
    int error;					// Used when debugging
    if (shutdown_in_progress && !abort_loop)
    {
2362
      sig= SIGTERM;
unknown's avatar
unknown committed
2363 2364 2365 2366 2367
      error=0;
    }
    else
      while ((error=my_sigwait(&set,&sig)) == EINTR) ;
    if (cleanup_done)
2368
    {
2369
      DBUG_PRINT("quit",("signal_handler: calling my_thread_end()"));
2370
      my_thread_end();
unknown's avatar
unknown committed
2371
      signal_thread_in_use= 0;
unknown's avatar
unknown committed
2372
      pthread_exit(0);				// Safety
2373
    }
unknown's avatar
unknown committed
2374 2375 2376 2377 2378
    switch (sig) {
    case SIGTERM:
    case SIGQUIT:
    case SIGKILL:
#ifdef EXTRA_DEBUG
2379
      sql_print_information("Got signal %d to shutdown mysqld",sig);
unknown's avatar
unknown committed
2380
#endif
2381
      /* switch to the old log message processing */
2382 2383
      logger.set_handlers(LOG_FILE, opt_slow_log ? LOG_FILE:LOG_NONE,
                          opt_log ? LOG_FILE:LOG_NONE);
unknown's avatar
unknown committed
2384 2385 2386 2387 2388 2389 2390 2391 2392
      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,
unknown's avatar
Merge  
unknown committed
2393
			   (void*) &sig))
2394
	  sql_print_error("Can't create thread to kill server");
unknown's avatar
unknown committed
2395
#else
unknown's avatar
unknown committed
2396
	kill_server((void*) sig);	// MIT THREAD has a alarm thread
unknown's avatar
unknown committed
2397 2398 2399 2400
#endif
      }
      break;
    case SIGHUP:
unknown's avatar
unknown committed
2401 2402
      if (!abort_loop)
      {
unknown's avatar
unknown committed
2403
        bool not_used;
unknown's avatar
Merge  
unknown committed
2404
	mysql_print_status();		// Print some debug info
unknown's avatar
unknown committed
2405 2406
	reload_acl_and_cache((THD*) 0,
			     (REFRESH_LOG | REFRESH_TABLES | REFRESH_FAST |
unknown's avatar
Merge  
unknown committed
2407
			      REFRESH_GRANT |
unknown's avatar
unknown committed
2408
			      REFRESH_THREADS | REFRESH_HOSTS),
unknown's avatar
unknown committed
2409
			     (TABLE_LIST*) 0, &not_used); // Flush logs
unknown's avatar
unknown committed
2410
      }
2411
      /* reenable logs after the options were reloaded */
2412 2413
      logger.set_handlers(LOG_FILE, opt_slow_log ? LOG_TABLE:LOG_NONE,
                          opt_log ? LOG_TABLE:LOG_NONE);
unknown's avatar
unknown committed
2414 2415 2416 2417 2418 2419 2420 2421
      break;
#ifdef USE_ONE_SIGNAL_HAND
    case THR_SERVER_ALARM:
      process_alarm(sig);			// Trigger alarms.
      break;
#endif
    default:
#ifdef EXTRA_DEBUG
2422
      sql_print_warning("Got signal: %d  error: %d",sig,error); /* purecov: tested */
unknown's avatar
unknown committed
2423 2424 2425 2426 2427 2428
#endif
      break;					/* purecov: tested */
    }
  }
  return(0);					/* purecov: deadcode */
}
unknown's avatar
unknown committed
2429
#endif /*!EMBEDDED_LIBRARY*/
unknown's avatar
unknown committed
2430

unknown's avatar
unknown committed
2431
static void check_data_home(const char *path)
unknown's avatar
unknown committed
2432
{}
unknown's avatar
unknown committed
2433

unknown's avatar
unknown committed
2434 2435 2436 2437
#endif	/* __WIN__*/


/*
unknown's avatar
Merge  
unknown committed
2438 2439
  All global error messages are sent here where the first one is stored
  for the client
unknown's avatar
unknown committed
2440 2441 2442 2443
*/


/* ARGSUSED */
unknown's avatar
unknown committed
2444
static int my_message_sql(uint error, const char *str, myf MyFlags)
unknown's avatar
unknown committed
2445
{
2446
  THD *thd;
unknown's avatar
unknown committed
2447
  DBUG_ENTER("my_message_sql");
unknown's avatar
Merge  
unknown committed
2448 2449 2450 2451 2452 2453
  DBUG_PRINT("error", ("error: %u  message: '%s'", error, str));
  /*
    Put here following assertion when situation with EE_* error codes
    will be fixed
    DBUG_ASSERT(error != 0);
  */
2454
  if ((thd= current_thd))
unknown's avatar
unknown committed
2455
  {
unknown's avatar
Merge  
unknown committed
2456 2457 2458
    if (thd->spcont &&
        thd->spcont->find_handler(error, MYSQL_ERROR::WARN_LEVEL_ERROR))
    {
2459 2460
      if (! thd->spcont->found_handler_here())
        thd->net.report_error= 1; /* Make "select" abort correctly */ 
unknown's avatar
Merge  
unknown committed
2461 2462 2463 2464 2465 2466 2467
      DBUG_RETURN(0);
    }

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

    if (!thd->no_warnings_for_error)
      push_warning(thd, MYSQL_ERROR::WARN_LEVEL_ERROR, error, str);
unknown's avatar
unknown committed
2468
    /*
2469
      thd->lex->current_select == 0 if lex structure is not inited
unknown's avatar
unknown committed
2470 2471
      (not query command (COM_QUERY))
    */
2472 2473
    if (thd->lex->current_select &&
	thd->lex->current_select->no_error && !thd->is_fatal_error)
unknown's avatar
unknown committed
2474
    {
2475 2476 2477 2478 2479 2480
      DBUG_PRINT("error",
                 ("Error converted to warning: current_select: no_error %d  "
                  "fatal_error: %d",
                  (thd->lex->current_select ?
                   thd->lex->current_select->no_error : 0),
                  (int) thd->is_fatal_error));
2481 2482 2483 2484 2485
    }
    else
    {
      NET *net= &thd->net;
      net->report_error= 1;
unknown's avatar
Merge  
unknown committed
2486
      query_cache_abort(net);
2487 2488 2489 2490 2491
      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;
      }
unknown's avatar
unknown committed
2492 2493
    }
  }
unknown's avatar
unknown committed
2494
  if (!thd || MyFlags & ME_NOREFRESH)
unknown's avatar
unknown committed
2495 2496 2497 2498
    sql_print_error("%s: %s",my_progname,str); /* purecov: inspected */
  DBUG_RETURN(0);
}

2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511

static void *my_str_malloc_mysqld(size_t size)
{
  return my_malloc(size, MYF(MY_FAE));
}


static void my_str_free_mysqld(void *ptr)
{
  my_free((gptr)ptr, MYF(MY_FAE));
}


unknown's avatar
unknown committed
2512 2513 2514 2515 2516 2517 2518
#ifdef __WIN__

struct utsname
{
  char nodename[FN_REFLEN];
};

unknown's avatar
unknown committed
2519

unknown's avatar
unknown committed
2520 2521 2522 2523 2524 2525
int uname(struct utsname *a)
{
  return -1;
}


2526
pthread_handler_t handle_shutdown(void *arg)
unknown's avatar
unknown committed
2527 2528 2529 2530 2531 2532
{
  MSG msg;
  my_thread_init();

  /* this call should create the message queue for this thread */
  PeekMessage(&msg, NULL, 1, 65534,PM_NOREMOVE);
unknown's avatar
unknown committed
2533
#if !defined(EMBEDDED_LIBRARY)
unknown's avatar
unknown committed
2534
  if (WaitForSingleObject(hEventShutdown,INFINITE)==WAIT_OBJECT_0)
2535
#endif /* EMBEDDED_LIBRARY */
unknown's avatar
unknown committed
2536 2537 2538 2539
     kill_server(MYSQL_KILL_SIGNAL);
  return 0;
}

unknown's avatar
unknown committed
2540

unknown's avatar
unknown committed
2541
int STDCALL handle_kill(ulong ctrl_type)
unknown's avatar
unknown committed
2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552
{
  if (ctrl_type == CTRL_CLOSE_EVENT ||
      ctrl_type == CTRL_SHUTDOWN_EVENT)
  {
    kill_server(MYSQL_KILL_SIGNAL);
    return TRUE;
  }
  return FALSE;
}
#endif

unknown's avatar
unknown committed
2553
static const char *load_default_groups[]= {
2554
#ifdef WITH_NDBCLUSTER_STORAGE_ENGINE
2555 2556
"mysql_cluster",
#endif
unknown's avatar
Merge  
unknown committed
2557 2558 2559
"mysqld","server", MYSQL_BASE_VERSION, 0, 0};

#if defined(__WIN__) && !defined(EMBEDDED_LIBRARY)
2560 2561
static const int load_default_groups_sz=
sizeof(load_default_groups)/sizeof(load_default_groups[0]);
unknown's avatar
Merge  
unknown committed
2562
#endif
unknown's avatar
unknown committed
2563

unknown's avatar
unknown committed
2564

2565 2566 2567 2568 2569 2570 2571
/*
  Initialize one of the global date/time format variables

  SYNOPSIS
    init_global_datetime_format()
    format_type		What kind of format should be supported
    var_ptr		Pointer to variable that should be updated
unknown's avatar
Merge  
unknown committed
2572

2573 2574 2575 2576 2577 2578 2579 2580 2581
  NOTES
    The default value is taken from either opt_date_time_formats[] or
    the ISO format (ANSI SQL)

  RETURN
    0 ok
    1 error
*/

unknown's avatar
unknown committed
2582 2583
static bool init_global_datetime_format(timestamp_type format_type,
                                        DATE_TIME_FORMAT **var_ptr)
2584
{
2585 2586
  /* Get command line option */
  const char *str= opt_date_time_formats[format_type];
2587

2588
  if (!str)					// No specified format
2589
  {
2590 2591 2592 2593 2594 2595 2596
    str= get_date_time_format_str(&known_date_time_formats[ISO_FORMAT],
				  format_type);
    /*
      Set the "command line" option to point to the generated string so
      that we can set global formats back to default
    */
    opt_date_time_formats[format_type]= str;
2597
  }
2598
  if (!(*var_ptr= date_time_format_make(format_type, str, strlen(str))))
2599
  {
2600 2601
    fprintf(stderr, "Wrong date/time format specifier: %s\n", str);
    return 1;
2602
  }
2603
  return 0;
2604 2605 2606
}


2607 2608
static int init_common_variables(const char *conf_file_name, int argc,
				 char **argv, const char **groups)
unknown's avatar
unknown committed
2609
{
unknown's avatar
unknown committed
2610
  umask(((~my_umask) & 0666));
unknown's avatar
Merge  
unknown committed
2611
  my_decimal_set_zero(&decimal_zero); // set decimal_zero constant;
unknown's avatar
unknown committed
2612 2613
  tzset();			// Set tzname

unknown's avatar
SCRUM  
unknown committed
2614
  max_system_variables.pseudo_thread_id= (ulong)~0;
unknown's avatar
unknown committed
2615
  start_time=time((time_t*) 0);
unknown's avatar
unknown committed
2616 2617
  if (init_thread_environment())
    return 1;
unknown's avatar
unknown committed
2618
  mysql_init_variables();
unknown's avatar
unknown committed
2619

unknown's avatar
unknown committed
2620 2621 2622 2623
#ifdef HAVE_TZNAME
  {
    struct tm tm_tmp;
    localtime_r(&start_time,&tm_tmp);
2624 2625 2626 2627
    strmake(system_time_zone, tzname[tm_tmp.tm_isdst != 0 ? 1 : 0],
            sizeof(system_time_zone)-1);

 }
unknown's avatar
unknown committed
2628
#endif
2629 2630 2631 2632 2633 2634 2635 2636
  /*
    We set SYSTEM time zone as reasonable default and 
    also for failure of my_tz_init() and bootstrap mode.
    If user explicitly set time zone with --default-time-zone
    option we will change this value in my_tz_init().
  */
  global_system_variables.time_zone= my_tz_SYSTEM;
  
unknown's avatar
unknown committed
2637
  /*
2638
    Init mutexes for the global MYSQL_BIN_LOG objects.
unknown's avatar
unknown committed
2639
    As safe_mutex depends on what MY_INIT() does, we can't init the mutexes of
2640 2641
    global MYSQL_BIN_LOGs in their constructors, because then they would be
    inited before MY_INIT(). So we do it here.
unknown's avatar
unknown committed
2642 2643
  */
  mysql_bin_log.init_pthread_objects();
2644

unknown's avatar
unknown committed
2645 2646
  if (gethostname(glob_hostname,sizeof(glob_hostname)-4) < 0)
    strmov(glob_hostname,"mysql");
unknown's avatar
unknown committed
2647
  strmake(pidfile_name, glob_hostname, sizeof(pidfile_name)-5);
2648
  strmov(fn_ext(pidfile_name),".pid");		// Add proper extension
unknown's avatar
unknown committed
2649

2650 2651 2652 2653 2654 2655 2656 2657 2658
  /*
    Add server status variables to the dynamic list of
    status variables that is shown by SHOW STATUS.
    Later, in plugin_init, plugin_load, and mysql_install_plugin
    new entries could be added to that list.
  */
  if (add_status_vars(status_vars))
    return 1; // an error was already reported

unknown's avatar
unknown committed
2659 2660
  load_defaults(conf_file_name, groups, &argc, &argv);
  defaults_argv=argv;
unknown's avatar
unknown committed
2661
  get_options(argc,argv);
2662 2663
  set_server_version();

unknown's avatar
unknown committed
2664 2665 2666
  DBUG_PRINT("info",("%s  Ver %s for %s on %s\n",my_progname,
		     server_version, SYSTEM_TYPE,MACHINE_TYPE));

unknown's avatar
Merge  
unknown committed
2667 2668 2669 2670 2671 2672
#ifdef HAVE_LARGE_PAGES
  /* Initialize large page size */
  if (opt_large_pages && (opt_large_page_size= my_get_large_page_size()))
  {
      my_use_large_pages= 1;
      my_large_page_size= opt_large_page_size;
2673
#ifdef WITH_INNOBASE_STORAGE_ENGINE
unknown's avatar
Merge  
unknown committed
2674 2675 2676 2677 2678 2679
      innobase_use_large_pages= 1;
      innobase_large_page_size= opt_large_page_size;
#endif
  }
#endif /* HAVE_LARGE_PAGES */

unknown's avatar
unknown committed
2680 2681
  /* connections and databases needs lots of files */
  {
2682 2683 2684 2685
    uint files, wanted_files;

    wanted_files= 10+(uint) max(max_connections*5,
				 max_connections+table_cache_size*2);
unknown's avatar
unknown committed
2686
    set_if_bigger(wanted_files, open_files_limit);
2687 2688 2689
    files= my_set_max_open_files(wanted_files);

    if (files < wanted_files)
unknown's avatar
unknown committed
2690
    {
2691 2692 2693 2694 2695 2696 2697
      if (!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_open_files: %u  max_connections: %ld  table_cache: %ld",
		    files, max_connections, table_cache_size));
unknown's avatar
unknown committed
2698
	if (global_system_variables.log_warnings)
2699
	  sql_print_warning("Changed limits: max_open_files: %u  max_connections: %ld  table_cache: %ld",
2700 2701
			files, max_connections, table_cache_size);
      }
unknown's avatar
unknown committed
2702
      else if (global_system_variables.log_warnings)
2703
	sql_print_warning("Could not increase number of max_open_files to more than %u (request: %u)", files, wanted_files);
unknown's avatar
unknown committed
2704
    }
unknown's avatar
unknown committed
2705
    open_files_limit= files;
unknown's avatar
unknown committed
2706 2707
  }
  unireg_init(opt_specialflag); /* Set up extern variabels */
2708 2709
  if (init_errmessage())	/* Read error messages from file */
    return 1;
2710
  init_client_errs();
unknown's avatar
unknown committed
2711 2712 2713 2714 2715
  lex_init();
  item_init();
  set_var_init();
  mysys_uses_curses=0;
#ifdef USE_REGEX
unknown's avatar
unknown committed
2716
  my_regex_init(&my_charset_latin1);
unknown's avatar
unknown committed
2717
#endif
2718
  if (!(default_charset_info= get_charset_by_csname(default_character_set_name,
2719 2720
						    MY_CS_PRIMARY,
						    MYF(MY_WME))))
unknown's avatar
unknown committed
2721
    return 1;
2722 2723
  if (default_collation_name)
  {
unknown's avatar
unknown committed
2724 2725
    CHARSET_INFO *default_collation;
    default_collation= get_charset_by_name(default_collation_name, MYF(0));
unknown's avatar
unknown committed
2726 2727 2728 2729 2730 2731
    if (!default_collation)
    {
      sql_print_error(ER(ER_UNKNOWN_COLLATION), default_collation_name);
      return 1;
    }
    if (!my_charset_same(default_charset_info, default_collation))
2732 2733 2734 2735 2736 2737 2738 2739
    {
      sql_print_error(ER(ER_COLLATION_CHARSET_MISMATCH),
		      default_collation_name,
		      default_charset_info->csname);
      return 1;
    }
    default_charset_info= default_collation;
  }
2740 2741 2742 2743
  /* Set collactions that depends on the default collation */
  global_system_variables.collation_server=	 default_charset_info;
  global_system_variables.collation_database=	 default_charset_info;
  global_system_variables.collation_connection=  default_charset_info;
2744
  global_system_variables.character_set_results= default_charset_info;
2745
  global_system_variables.character_set_client= default_charset_info;
unknown's avatar
unknown committed
2746
  global_system_variables.collation_connection= default_charset_info;
2747

unknown's avatar
unknown committed
2748 2749 2750 2751 2752 2753
  if (!(character_set_filesystem= 
        get_charset_by_csname(character_set_filesystem_name,
                              MY_CS_PRIMARY, MYF(MY_WME))))
    return 1;
  global_system_variables.character_set_filesystem= character_set_filesystem;

unknown's avatar
unknown committed
2754 2755 2756
  sys_init_connect.value_length= 0;
  if ((sys_init_connect.value= opt_init_connect))
    sys_init_connect.value_length= strlen(opt_init_connect);
2757 2758
  else
    sys_init_connect.value=my_strdup("",MYF(0));
unknown's avatar
unknown committed
2759 2760 2761 2762

  sys_init_slave.value_length= 0;
  if ((sys_init_slave.value= opt_init_slave))
    sys_init_slave.value_length= strlen(opt_init_slave);
2763 2764
  else
    sys_init_slave.value=my_strdup("",MYF(0));
2765

2766
  if (use_temp_pool && bitmap_init(&temp_pool,0,1024,1))
2767
    return 1;
unknown's avatar
unknown committed
2768
  if (my_database_names_init())
unknown's avatar
unknown committed
2769 2770
    return 1;

2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814
  /*
    Ensure that lower_case_table_names is set on system where we have case
    insensitive names.  If this is not done the users MyISAM tables will
    get corrupted if accesses with names of different case.
  */
  DBUG_PRINT("info", ("lower_case_table_names: %d", lower_case_table_names));
  if (!lower_case_table_names &&
      (lower_case_file_system=
       (test_if_case_insensitive(mysql_real_data_home) == 1)))
  {
    if (lower_case_table_names_used)
    {
      if (global_system_variables.log_warnings)
	sql_print_warning("\
You have forced lower_case_table_names to 0 through a command-line \
option, even though your file system '%s' is case insensitive.  This means \
that you can corrupt a MyISAM table by accessing it with different cases. \
You should consider changing lower_case_table_names to 1 or 2",
			mysql_real_data_home);
    }
    else
    {
      if (global_system_variables.log_warnings)
	sql_print_warning("Setting lower_case_table_names=2 because file system for %s is case insensitive", mysql_real_data_home);
      lower_case_table_names= 2;
    }
  }
  else if (lower_case_table_names == 2 &&
           !(lower_case_file_system=
             (test_if_case_insensitive(mysql_real_data_home) == 1)))
  {
    if (global_system_variables.log_warnings)
      sql_print_warning("lower_case_table_names was set to 2, even though your "
                        "the file system '%s' is case sensitive.  Now setting "
                        "lower_case_table_names to 0 to avoid future problems.",
			mysql_real_data_home);
    lower_case_table_names= 0;
  }

  /* Reset table_alias_charset, now that lower_case_table_names is set. */
  table_alias_charset= (lower_case_table_names ?
			files_charset_info :
			&my_charset_bin);

unknown's avatar
unknown committed
2815 2816
  return 0;
}
unknown's avatar
unknown committed
2817

2818 2819

static int init_thread_environment()
unknown's avatar
unknown committed
2820
{
2821
  (void) pthread_mutex_init(&LOCK_mysql_create_db,MY_MUTEX_INIT_SLOW);
unknown's avatar
unknown committed
2822
  (void) pthread_mutex_init(&LOCK_lock_db,MY_MUTEX_INIT_SLOW);
2823
  (void) pthread_mutex_init(&LOCK_Acl,MY_MUTEX_INIT_SLOW);
unknown's avatar
unknown committed
2824
  (void) pthread_mutex_init(&LOCK_open, NULL);
2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836
  (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_user_conn, MY_MUTEX_INIT_FAST);
2837
  (void) pthread_mutex_init(&LOCK_active_mi, MY_MUTEX_INIT_FAST);
2838
  (void) pthread_mutex_init(&LOCK_global_system_variables, MY_MUTEX_INIT_FAST);
2839
  (void) pthread_mutex_init(&LOCK_global_read_lock, MY_MUTEX_INIT_FAST);
2840
  (void) pthread_mutex_init(&LOCK_prepared_stmt_count, MY_MUTEX_INIT_FAST);
unknown's avatar
unknown committed
2841
  (void) pthread_mutex_init(&LOCK_uuid_generator, MY_MUTEX_INIT_FAST);
2842 2843
#ifdef HAVE_OPENSSL
  (void) pthread_mutex_init(&LOCK_des_key_file,MY_MUTEX_INIT_FAST);
unknown's avatar
unknown committed
2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854
#ifndef HAVE_YASSL
  openssl_stdlocks= (openssl_lock_t*) OPENSSL_malloc(CRYPTO_num_locks() *
                                                     sizeof(openssl_lock_t));
  for (int i= 0; i < CRYPTO_num_locks(); ++i)
    (void) my_rwlock_init(&openssl_stdlocks[i].lock, NULL); 
  CRYPTO_set_dynlock_create_callback(openssl_dynlock_create);
  CRYPTO_set_dynlock_destroy_callback(openssl_dynlock_destroy);
  CRYPTO_set_dynlock_lock_callback(openssl_lock);
  CRYPTO_set_locking_callback(openssl_lock_function);
  CRYPTO_set_id_callback(openssl_id_function);
#endif
2855
#endif
unknown's avatar
unknown committed
2856 2857
  (void) my_rwlock_init(&LOCK_sys_init_connect, NULL);
  (void) my_rwlock_init(&LOCK_sys_init_slave, NULL);
2858
  (void) my_rwlock_init(&LOCK_grant, NULL);
unknown's avatar
unknown committed
2859 2860
  (void) pthread_cond_init(&COND_thread_count,NULL);
  (void) pthread_cond_init(&COND_refresh,NULL);
unknown's avatar
unknown committed
2861
  (void) pthread_cond_init(&COND_global_read_lock,NULL);
unknown's avatar
unknown committed
2862 2863
  (void) pthread_cond_init(&COND_thread_cache,NULL);
  (void) pthread_cond_init(&COND_flush_thread_cache,NULL);
2864
  (void) pthread_cond_init(&COND_manager,NULL);
unknown's avatar
SCRUM  
unknown committed
2865
#ifdef HAVE_REPLICATION
2866
  (void) pthread_mutex_init(&LOCK_rpl_status, MY_MUTEX_INIT_FAST);
2867
  (void) pthread_cond_init(&COND_rpl_status, NULL);
2868
#endif
unknown's avatar
unknown committed
2869 2870
  (void) pthread_mutex_init(&LOCK_server_started, MY_MUTEX_INIT_FAST);
  (void) pthread_cond_init(&COND_server_started,NULL);
unknown's avatar
Merge  
unknown committed
2871
  sp_cache_init();
2872
  Events::init_mutexes();
unknown's avatar
unknown committed
2873 2874 2875 2876 2877
  /* Parameter for threads created for connections */
  (void) pthread_attr_init(&connection_attrib);
  (void) pthread_attr_setdetachstate(&connection_attrib,
				     PTHREAD_CREATE_DETACHED);
  pthread_attr_setscope(&connection_attrib, PTHREAD_SCOPE_SYSTEM);
2878 2879
  if (!(opt_specialflag & SPECIAL_NO_PRIOR))
    my_pthread_attr_setprio(&connection_attrib,WAIT_PRIOR);
unknown's avatar
unknown committed
2880

unknown's avatar
unknown committed
2881 2882 2883 2884 2885 2886 2887 2888 2889
  if (pthread_key_create(&THR_THD,NULL) ||
      pthread_key_create(&THR_MALLOC,NULL))
  {
    sql_print_error("Can't create thread-keys");
    return 1;
  }
  return 0;
}

2890

unknown's avatar
unknown committed
2891
#if defined(HAVE_OPENSSL) && !defined(HAVE_YASSL)
2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959
static unsigned long openssl_id_function()
{ 
  return (unsigned long) pthread_self();
} 


static openssl_lock_t *openssl_dynlock_create(const char *file, int line)
{ 
  openssl_lock_t *lock= new openssl_lock_t;
  my_rwlock_init(&lock->lock, NULL);
  return lock;
}


static void openssl_dynlock_destroy(openssl_lock_t *lock, const char *file, 
				    int line)
{
  rwlock_destroy(&lock->lock);
  delete lock;
}


static void openssl_lock_function(int mode, int n, const char *file, int line)
{
  if (n < 0 || n > CRYPTO_num_locks())
  {
    /* Lock number out of bounds. */
    sql_print_error("Fatal: OpenSSL interface problem (n = %d)", n);
    abort();
  }
  openssl_lock(mode, &openssl_stdlocks[n], file, line);
}


static void openssl_lock(int mode, openssl_lock_t *lock, const char *file, 
			 int line)
{
  int err;
  char const *what;

  switch (mode) {
  case CRYPTO_LOCK|CRYPTO_READ:
    what = "read lock";
    err = rw_rdlock(&lock->lock);
    break;
  case CRYPTO_LOCK|CRYPTO_WRITE:
    what = "write lock";
    err = rw_wrlock(&lock->lock);
    break;
  case CRYPTO_UNLOCK|CRYPTO_READ:
  case CRYPTO_UNLOCK|CRYPTO_WRITE:
    what = "unlock";
    err = rw_unlock(&lock->lock);
    break;
  default:
    /* Unknown locking mode. */
    sql_print_error("Fatal: OpenSSL interface problem (mode=0x%x)", mode);
    abort();
  }
  if (err) 
  {
    sql_print_error("Fatal: can't %s OpenSSL %s lock", what);
    abort();
  }
}
#endif /* HAVE_OPENSSL */


unknown's avatar
unknown committed
2960 2961
static void init_ssl()
{
unknown's avatar
unknown committed
2962 2963 2964
#ifdef HAVE_OPENSSL
  if (opt_use_ssl)
  {
2965 2966 2967 2968
    /* having ssl_acceptor_fd != 0 signals the use of SSL */
    ssl_acceptor_fd= new_VioSSLAcceptorFd(opt_ssl_key, opt_ssl_cert,
					  opt_ssl_ca, opt_ssl_capath,
					  opt_ssl_cipher);
unknown's avatar
Merge  
unknown committed
2969
    DBUG_PRINT("info",("ssl_acceptor_fd: 0x%lx", (long) ssl_acceptor_fd));
unknown's avatar
unknown committed
2970
    if (!ssl_acceptor_fd)
2971
    {
unknown's avatar
unknown committed
2972
      opt_use_ssl = 0;
2973 2974 2975 2976 2977 2978
      have_openssl= SHOW_OPTION_DISABLED;
    }
  }
  else
  {
    have_openssl= SHOW_OPTION_DISABLED;
unknown's avatar
unknown committed
2979
  }
unknown's avatar
unknown committed
2980 2981
  if (des_key_file)
    load_des_key_file(des_key_file);
unknown's avatar
unknown committed
2982
#endif /* HAVE_OPENSSL */
unknown's avatar
unknown committed
2983
}
unknown's avatar
unknown committed
2984

2985

2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997
static void end_ssl()
{
#ifdef HAVE_OPENSSL
  if (ssl_acceptor_fd)
  {
    free_vio_ssl_acceptor_fd(ssl_acceptor_fd);
    ssl_acceptor_fd= 0;
  }
#endif /* HAVE_OPENSSL */
}


unknown's avatar
unknown committed
2998 2999
static int init_server_components()
{
3000
  DBUG_ENTER("init_server_components");
unknown's avatar
unknown committed
3001 3002 3003 3004 3005
  /*
    We need to call each of these following functions to ensure that
    all things are initialized so that unireg_abort() doesn't fail
  */
  if (table_cache_init() | table_def_init() | hostname_cache_init())
3006
    unireg_abort(1);
unknown's avatar
unknown committed
3007

unknown's avatar
unknown committed
3008
  query_cache_result_size_limit(query_cache_limit);
3009
  query_cache_set_min_res_unit(query_cache_min_res_unit);
unknown's avatar
unknown committed
3010
  query_cache_init();
unknown's avatar
unknown committed
3011
  query_cache_resize(query_cache_size);
unknown's avatar
unknown committed
3012 3013 3014
  randominit(&sql_rand,(ulong) start_time,(ulong) start_time/2);
  reset_floating_point_exceptions();
  init_thr_lock();
unknown's avatar
SCRUM  
unknown committed
3015
#ifdef HAVE_REPLICATION
3016
  init_slave_list();
3017
#endif
unknown's avatar
unknown committed
3018

3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040
  /* Setup logs */

  /* enable old-fashioned error log */
  if (opt_error_log)
  {
    if (!log_error_file_ptr[0])
      fn_format(log_error_file, glob_hostname, mysql_data_home, ".err",
                MY_REPLACE_EXT); /* replace '.<domain>' by '.err', bug#4997 */
    else
      fn_format(log_error_file, log_error_file_ptr, mysql_data_home, ".err",
                MY_UNPACK_FILENAME | MY_SAFE_PATH);
    if (!log_error_file[0])
      opt_error_log= 1;				// Too long file name
    else
    {
#ifndef EMBEDDED_LIBRARY
      if (freopen(log_error_file, "a+", stdout))
#endif
        freopen(log_error_file, "a+", stderr);
    }
  }

unknown's avatar
unknown committed
3041 3042 3043 3044 3045 3046
  if (xid_cache_init())
  {
    sql_print_error("Out of memory");
    unireg_abort(1);
  }

unknown's avatar
unknown committed
3047
  /* need to configure logging before initializing storage engines */
unknown's avatar
unknown committed
3048
  if (opt_update_log)
unknown's avatar
unknown committed
3049
  {
unknown's avatar
Merge  
unknown committed
3050 3051 3052 3053
    /*
      Update log is removed since 5.0. But we still accept the option.
      The idea is if the user already uses the binlog and the update log,
      we completely ignore any option/variable related to the update log, like
unknown's avatar
unknown committed
3054 3055
      if the update log did not exist. But if the user uses only the update
      log, then we translate everything into binlog for him (with warnings).
unknown's avatar
Merge  
unknown committed
3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068
      Implementation of the above :
      - If mysqld is started with --log-update and --log-bin,
      ignore --log-update (print a warning), push a warning when SQL_LOG_UPDATE
      is used, and turn off --sql-bin-update-same.
      This will completely ignore SQL_LOG_UPDATE
      - If mysqld is started with --log-update only,
      change it to --log-bin (with the filename passed to log-update,
      plus '-bin') (print a warning), push a warning when SQL_LOG_UPDATE is
      used, and turn on --sql-bin-update-same.
      This will translate SQL_LOG_UPDATE to SQL_LOG_BIN.

      Note that we tell the user that --sql-bin-update-same is deprecated and
      does nothing, and we don't take into account if he used this option or
unknown's avatar
unknown committed
3069 3070
      not; but internally we give this variable a value to have the behaviour
      we want (i.e. have SQL_LOG_UPDATE influence SQL_LOG_BIN or not).
unknown's avatar
Merge  
unknown committed
3071
      As sql-bin-update-same, log-update and log-bin cannot be changed by the
unknown's avatar
unknown committed
3072 3073
      user after starting the server (they are not variables), the user will
      not later interfere with the settings we do here.
unknown's avatar
Merge  
unknown committed
3074 3075
    */
    if (opt_bin_log)
unknown's avatar
unknown committed
3076
    {
unknown's avatar
Merge  
unknown committed
3077 3078 3079 3080 3081 3082 3083 3084 3085 3086
      opt_sql_bin_update= 0;
      sql_print_error("The update log is no longer supported by MySQL in \
version 5.0 and above. It is replaced by the binary log.");
    }
    else
    {
      opt_sql_bin_update= 1;
      opt_bin_log= 1;
      if (opt_update_logname)
      {
unknown's avatar
unknown committed
3087
        /* as opt_bin_log==0, no need to free opt_bin_logname */
unknown's avatar
Merge  
unknown committed
3088 3089 3090 3091 3092 3093 3094 3095 3096 3097
        if (!(opt_bin_logname= my_strdup(opt_update_logname, MYF(MY_WME))))
          exit(EXIT_OUT_OF_MEMORY);
        sql_print_error("The update log is no longer supported by MySQL in \
version 5.0 and above. It is replaced by the binary log. Now starting MySQL \
with --log-bin='%s' instead.",opt_bin_logname);
      }
      else
        sql_print_error("The update log is no longer supported by MySQL in \
version 5.0 and above. It is replaced by the binary log. Now starting MySQL \
with --log-bin instead.");
unknown's avatar
unknown committed
3098
    }
3099
  }
unknown's avatar
Merge  
unknown committed
3100
  if (opt_log_slave_updates && !opt_bin_log)
unknown's avatar
unknown committed
3101
  {
unknown's avatar
unknown committed
3102 3103
    sql_print_warning("You need to use --log-bin to make "
                      "--log-slave-updates work.");
3104 3105 3106
    unireg_abort(1);
  }

3107
 if (!opt_bin_log && (global_system_variables.binlog_format != BINLOG_FORMAT_UNSPEC))
3108 3109 3110 3111
  {
    sql_print_warning("You need to use --log-bin to make "
                      "--binlog-format work.");
    unireg_abort(1);
unknown's avatar
unknown committed
3112
  }
3113
  if (global_system_variables.binlog_format == BINLOG_FORMAT_UNSPEC)
3114
  {
3115
#if defined(HAVE_NDB_BINLOG) && defined(HAVE_ROW_BASED_REPLICATION)
3116
    if (opt_bin_log && have_ndbcluster == SHOW_OPTION_YES)
3117
      global_system_variables.binlog_format= BINLOG_FORMAT_ROW;
unknown's avatar
unknown committed
3118 3119
    else
#endif
3120
      global_system_variables.binlog_format= BINLOG_FORMAT_STMT;
3121
  }
3122

3123
  /* Check that we have not let the format to unspecified at this point */
3124
  DBUG_ASSERT((uint)global_system_variables.binlog_format <=
3125
              array_elements(binlog_format_names)-1);
3126

unknown's avatar
unknown committed
3127
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
3128 3129 3130
  if (opt_log_slave_updates && replicate_same_server_id)
  {
    sql_print_error("\
3131
using --replicate-same-server-id in conjunction with \
unknown's avatar
unknown committed
3132 3133 3134 3135
--log-slave-updates is impossible, it would lead to infinite loops in this \
server.");
    unireg_abort(1);
  }
unknown's avatar
unknown committed
3136
#endif
3137

unknown's avatar
Merge  
unknown committed
3138
  if (opt_bin_log)
3139
  {
unknown's avatar
Merge  
unknown committed
3140 3141 3142 3143
    char buf[FN_REFLEN];
    const char *ln;
    ln= mysql_bin_log.generate_name(opt_bin_logname, "-bin", 1, buf);
    if (!opt_bin_logname && !opt_binlog_index_name)
3144 3145
    {
      /*
unknown's avatar
Merge  
unknown committed
3146 3147 3148 3149 3150
        User didn't give us info to name the binlog index file.
        Picking `hostname`-bin.index like did in 4.x, causes replication to
        fail if the hostname is changed later. So, we would like to instead
        require a name. But as we don't want to break many existing setups, we
        only give warning, not error.
3151
      */
unknown's avatar
Merge  
unknown committed
3152 3153 3154 3155 3156
      sql_print_warning("No argument was provided to --log-bin, and "
                        "--log-bin-index was not used; so replication "
                        "may break when this MySQL server acts as a "
                        "master and has his hostname changed!! Please "
                        "use '--log-bin=%s' to avoid this problem.", ln);
3157
    }
unknown's avatar
Merge  
unknown committed
3158
    if (ln == buf)
3159
    {
unknown's avatar
Merge  
unknown committed
3160 3161
      my_free(opt_bin_logname, MYF(MY_ALLOW_ZERO_PTR));
      opt_bin_logname=my_strdup(buf, MYF(0));
3162
    }
unknown's avatar
unknown committed
3163 3164 3165 3166 3167 3168 3169 3170 3171
    if (mysql_bin_log.open_index_file(opt_binlog_index_name, ln))
    {
      unireg_abort(1);
    }

    /*
      Used to specify which type of lock we need to use for queries of type
      INSERT ... SELECT. This will change when we have row level logging.
    */
unknown's avatar
Merge  
unknown committed
3172
    using_update_log=1;
3173 3174
  }

unknown's avatar
unknown committed
3175 3176 3177 3178 3179 3180
  if (plugin_init())
  {
    sql_print_error("Failed to init plugins.");
    return 1;
  }

unknown's avatar
unknown committed
3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223
  /* We have to initialize the storage engines before CSV logging */
  if (ha_init())
  {
    sql_print_error("Can't init databases");
    unireg_abort(1);
  }

#ifdef WITH_CSV_STORAGE_ENGINE
  if (opt_bootstrap)
    log_output_options= LOG_FILE;
  else
    logger.init_log_tables();

  if (log_output_options & LOG_NONE)
  {
    /*
      Issue a warining if there were specified additional options to the
      log-output along with NONE. Probably this wasn't what user wanted.
    */
    if ((log_output_options & LOG_NONE) && (log_output_options & ~LOG_NONE))
      sql_print_warning("There were other values specified to "
                        "log-output besides NONE. Disabling slow "
                        "and general logs anyway.");
    logger.set_handlers(LOG_FILE, LOG_NONE, LOG_NONE);
  }
  else
  {
    /* fall back to the log files if tables are not present */
    if (have_csv_db == SHOW_OPTION_NO)
    {
      sql_print_error("CSV engine is not present, falling back to the "
                      "log files");
      log_output_options= log_output_options & ~LOG_TABLE | LOG_FILE;
    }

    logger.set_handlers(LOG_FILE, opt_slow_log ? log_output_options:LOG_NONE,
                        opt_log ? log_output_options:LOG_NONE);
  }
#else
  logger.set_handlers(LOG_FILE, opt_slow_log ? LOG_FILE:LOG_NONE,
                      opt_log ? LOG_FILE:LOG_NONE);
#endif

3224 3225 3226 3227
  /*
    Check that the default storage engine is actually available.
  */
  {
unknown's avatar
unknown committed
3228 3229 3230 3231
    LEX_STRING name= { default_storage_engine_str,
                       strlen(default_storage_engine_str) };
    handlerton *hton= ha_resolve_by_name(0, &name);
    if (hton == NULL)
3232
    {
unknown's avatar
unknown committed
3233 3234
      sql_print_error("Unknown/unsupported table type: %s",
                      default_storage_engine_str);
3235 3236
      unireg_abort(1);
    }
unknown's avatar
unknown committed
3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247
    if (!ha_storage_engine_is_enabled(hton))
    {
      if (!opt_bootstrap)
      {
        sql_print_error("Default storage engine (%s) is not available",
                        default_storage_engine_str);
        unireg_abort(1);
      }
      hton= &myisam_hton;
    }
    global_system_variables.table_type= hton;
3248 3249
  }

unknown's avatar
unknown committed
3250 3251 3252 3253
  tc_log= (total_ha_2pc > 1 ? (opt_bin_log  ?
                               (TC_LOG *) &mysql_bin_log :
                               (TC_LOG *) &tc_log_mmap) :
           (TC_LOG *) &tc_log_dummy);
unknown's avatar
unknown committed
3254

unknown's avatar
Merge  
unknown committed
3255 3256 3257 3258 3259 3260
  if (tc_log->open(opt_bin_logname))
  {
    sql_print_error("Can't init tc log");
    unireg_abort(1);
  }

unknown's avatar
unknown committed
3261 3262 3263 3264 3265
  if (ha_recover(0))
  {
    unireg_abort(1);
  }

unknown's avatar
Merge  
unknown committed
3266 3267
  if (opt_bin_log && mysql_bin_log.open(opt_bin_logname, LOG_BIN, 0,
                                        WRITE_CACHE, 0, max_binlog_size, 0))
unknown's avatar
unknown committed
3268
    unireg_abort(1);
unknown's avatar
Merge  
unknown committed
3269 3270 3271

#ifdef HAVE_REPLICATION
  if (opt_bin_log && expire_logs_days)
3272
  {
unknown's avatar
Merge  
unknown committed
3273 3274 3275
    long purge_time= time(0) - expire_logs_days*24*60*60;
    if (purge_time >= 0)
      mysql_bin_log.purge_logs_before_date(purge_time);
3276
  }
unknown's avatar
Merge  
unknown committed
3277
#endif
unknown's avatar
unknown committed
3278 3279 3280 3281
#ifdef __NETWARE__
  /* Increasing stacksize of threads on NetWare */
  pthread_attr_setstacksize(&connection_attrib, NW_THD_STACKSIZE);
#endif
unknown's avatar
Merge  
unknown committed
3282 3283 3284

  if (opt_myisam_log)
    (void) mi_log(1);
unknown's avatar
unknown committed
3285

3286 3287
  /* call ha_init_key_cache() on all key caches to init them */
  process_key_caches(&ha_init_key_cache);
unknown's avatar
unknown committed
3288

unknown's avatar
unknown committed
3289
#if defined(HAVE_MLOCKALL) && defined(MCL_CURRENT) && !defined(EMBEDDED_LIBRARY)
3290
  if (locked_in_memory && !getuid())
3291
  {
3292
    if (setreuid((uid_t)-1, 0) == -1)
3293
    {                        // this should never happen
3294
      sql_perror("setreuid");
3295 3296
      unireg_abort(1);
    }
3297 3298
    if (mlockall(MCL_CURRENT))
    {
3299
      if (global_system_variables.log_warnings)
3300
	sql_print_warning("Failed to lock memory. Errno: %d\n",errno);
unknown's avatar
unknown committed
3301
      locked_in_memory= 0;
3302
    }
3303 3304
    if (user_info)
      set_user(mysqld_user, user_info);
3305
  }
unknown's avatar
unknown committed
3306
  else
3307
#endif
unknown's avatar
unknown committed
3308
    locked_in_memory=0;
3309

3310
  ft_init_stopwords();
unknown's avatar
unknown committed
3311

unknown's avatar
unknown committed
3312
  init_max_user_conn();
3313
  init_update_queries();
3314
  DBUG_RETURN(0);
unknown's avatar
unknown committed
3315
}
unknown's avatar
unknown committed
3316

3317

unknown's avatar
unknown committed
3318 3319 3320
static void create_maintenance_thread()
{
  if (
3321
#ifdef WITH_BERKELEY_STORAGE_ENGINE
3322
      (have_berkeley_db == SHOW_OPTION_YES) ||
unknown's avatar
unknown committed
3323 3324
#endif
      (flush_time && flush_time != ~(ulong) 0L))
unknown's avatar
unknown committed
3325
  {
unknown's avatar
unknown committed
3326 3327
    pthread_t hThread;
    if (pthread_create(&hThread,&connection_attrib,handle_manager,0))
3328
      sql_print_warning("Can't create thread to manage maintenance");
unknown's avatar
unknown committed
3329
  }
unknown's avatar
unknown committed
3330 3331
}

3332

unknown's avatar
unknown committed
3333 3334
static void create_shutdown_thread()
{
3335
#if !defined(EMBEDDED_LIBRARY)
unknown's avatar
unknown committed
3336
#ifdef __WIN__
3337 3338 3339
  hEventShutdown=CreateEvent(0, FALSE, FALSE, shutdown_event_name);
  pthread_t hThread;
  if (pthread_create(&hThread,&connection_attrib,handle_shutdown,0))
3340
    sql_print_warning("Can't create thread to handle shutdown requests");
unknown's avatar
unknown committed
3341

3342 3343
  // On "Stop Service" we have to do regular shutdown
  Service.SetShutdownEvent(hEventShutdown);
unknown's avatar
unknown committed
3344
#endif
3345
#endif // EMBEDDED_LIBRARY 
unknown's avatar
unknown committed
3346
}
unknown's avatar
unknown committed
3347

3348

3349
#if (defined(__NT__) || defined(HAVE_SMEM)) && !defined(EMBEDDED_LIBRARY)
3350
static void handle_connections_methods()
unknown's avatar
unknown committed
3351
{
3352 3353 3354
  pthread_t hThread;
  DBUG_ENTER("handle_connections_methods");
#ifdef __NT__
unknown's avatar
unknown committed
3355
  if (hPipe == INVALID_HANDLE_VALUE &&
3356 3357
      (!have_tcpip || opt_disable_networking) &&
      !opt_enable_shared_memory)
unknown's avatar
unknown committed
3358
  {
unknown's avatar
unknown committed
3359
    sql_print_error("TCP/IP, --shared-memory, or --named-pipe should be configured on NT OS");
3360
    unireg_abort(1);				// Will not return
unknown's avatar
unknown committed
3361
  }
3362 3363 3364 3365 3366 3367 3368
#endif

  pthread_mutex_lock(&LOCK_thread_count);
  (void) pthread_cond_init(&COND_handler_count,NULL);
  handler_count=0;
#ifdef __NT__
  if (hPipe != INVALID_HANDLE_VALUE)
unknown's avatar
unknown committed
3369
  {
3370 3371 3372
    handler_count++;
    if (pthread_create(&hThread,&connection_attrib,
		       handle_connections_namedpipes, 0))
unknown's avatar
unknown committed
3373
    {
3374
      sql_print_warning("Can't create thread to handle named pipes");
3375 3376 3377 3378 3379 3380 3381 3382 3383 3384
      handler_count--;
    }
  }
#endif /* __NT__ */
  if (have_tcpip && !opt_disable_networking)
  {
    handler_count++;
    if (pthread_create(&hThread,&connection_attrib,
		       handle_connections_sockets, 0))
    {
3385
      sql_print_warning("Can't create thread to handle TCP/IP");
3386 3387 3388 3389 3390 3391 3392 3393 3394 3395
      handler_count--;
    }
  }
#ifdef HAVE_SMEM
  if (opt_enable_shared_memory)
  {
    handler_count++;
    if (pthread_create(&hThread,&connection_attrib,
		       handle_connections_shared_memory, 0))
    {
3396
      sql_print_warning("Can't create thread to handle shared memory");
3397
      handler_count--;
unknown's avatar
unknown committed
3398 3399
    }
  }
3400
#endif 
unknown's avatar
unknown committed
3401

3402 3403 3404 3405 3406
  while (handler_count > 0)
    pthread_cond_wait(&COND_handler_count,&LOCK_thread_count);
  pthread_mutex_unlock(&LOCK_thread_count);
  DBUG_VOID_RETURN;
}
3407 3408 3409 3410 3411 3412 3413 3414 3415 3416

void decrement_handler_count()
{
  pthread_mutex_lock(&LOCK_thread_count);
  handler_count--;
  pthread_mutex_unlock(&LOCK_thread_count);
  pthread_cond_signal(&COND_handler_count);
}
#else
#define decrement_handler_count()
3417 3418 3419
#endif /* defined(__NT__) || defined(HAVE_SMEM) */


3420
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
3421 3422 3423 3424 3425 3426
#ifdef __WIN__
int win_main(int argc, char **argv)
#else
int main(int argc, char **argv)
#endif
{
unknown's avatar
unknown committed
3427 3428
  rpl_filter= new Rpl_filter;
  binlog_filter= new Rpl_filter;
3429 3430 3431 3432 3433 3434
  if (!rpl_filter || !binlog_filter) 
  {
    sql_perror("Could not allocate replication and binlog filters");
    exit(1);
  }

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

3437 3438 3439 3440 3441 3442
  /*
    Perform basic logger initialization logger. Should be called after
    MY_INIT, as it initializes mutexes. Log tables are inited later.
  */
  logger.init_base();

unknown's avatar
unknown committed
3443
#ifdef _CUSTOMSTARTUPCONFIG_
unknown's avatar
unknown committed
3444 3445 3446
  if (_cust_check_startup())
  {
    / * _cust_check_startup will report startup failure error * /
unknown's avatar
Merge  
unknown committed
3447
    exit(1);
unknown's avatar
unknown committed
3448 3449
  }
#endif
unknown's avatar
unknown committed
3450

3451
#ifdef	__WIN__
unknown's avatar
unknown committed
3452 3453 3454 3455
  /*
    Before performing any socket operation (like retrieving hostname
    in init_common_variables we have to call WSAStartup
  */
3456 3457 3458 3459
  {
    WSADATA WsaData;
    if (SOCKET_ERROR == WSAStartup (0x0101, &WsaData))
    {
unknown's avatar
unknown committed
3460
      /* errors are not read yet, so we use english text here */
3461 3462 3463 3464 3465 3466
      my_message(ER_WSAS_FAILED, "WSAStartup Failed", MYF(0));
      unireg_abort(1);
    }
  }
#endif /* __WIN__ */

3467 3468 3469
  if (init_common_variables(MYSQL_CONFIG_NAME,
			    argc, argv, load_default_groups))
    unireg_abort(1);				// Will do exit
unknown's avatar
unknown committed
3470 3471 3472 3473

  init_signals();
  if (!(opt_specialflag & SPECIAL_NO_PRIOR))
    my_pthread_setprio(pthread_self(),CONNECT_PRIOR);
3474
#if defined(__ia64__) || defined(__ia64)
3475 3476 3477 3478
  /*
    Peculiar things with ia64 platforms - it seems we only have half the
    stack size in reality, so we have to double it here
  */
3479 3480
  pthread_attr_setstacksize(&connection_attrib,thread_stack*2);
#else
3481
  pthread_attr_setstacksize(&connection_attrib,thread_stack);
3482
#endif
3483 3484 3485 3486 3487
#ifdef HAVE_PTHREAD_ATTR_GETSTACKSIZE
  {
    /* Retrieve used stack size;  Needed for checking stack overflows */
    size_t stack_size= 0;
    pthread_attr_getstacksize(&connection_attrib, &stack_size);
3488 3489 3490
#if defined(__ia64__) || defined(__ia64)
    stack_size/= 2;
#endif
3491 3492 3493 3494
    /* We must check if stack_size = 0 as Solaris 2.9 can return 0 here */
    if (stack_size && stack_size < thread_stack)
    {
      if (global_system_variables.log_warnings)
3495
	sql_print_warning("Asked for %ld thread stack, but got %ld",
3496 3497 3498 3499
			  thread_stack, stack_size);
#if defined(__ia64__) || defined(__ia64)
      thread_stack= stack_size*2;
#else
3500
      thread_stack= stack_size;
3501
#endif
3502 3503 3504
    }
  }
#endif
3505 3506 3507 3508
#ifdef __NETWARE__
  /* Increasing stacksize of threads on NetWare */
  pthread_attr_setstacksize(&connection_attrib, NW_THD_STACKSIZE);
#endif
unknown's avatar
unknown committed
3509

3510
  (void) thr_setconcurrency(concurrency);	// 10 by default
unknown's avatar
unknown committed
3511

3512 3513
  select_thread=pthread_self();
  select_thread_in_use=1;
unknown's avatar
unknown committed
3514 3515 3516 3517 3518 3519 3520 3521 3522 3523
  init_ssl();

#ifdef HAVE_LIBWRAP
  libwrapName= my_progname+dirname_length(my_progname);
  openlog(libwrapName, LOG_PID, LOG_AUTH);
#endif

  /*
    We have enough space for fiddling with the argv, continue
  */
unknown's avatar
unknown committed
3524
  check_data_home(mysql_real_data_home);
unknown's avatar
unknown committed
3525 3526 3527 3528 3529
  if (my_setwd(mysql_real_data_home,MYF(MY_WME)))
    unireg_abort(1);				/* purecov: inspected */
  mysql_data_home= mysql_data_home_buff;
  mysql_data_home[0]=FN_CURLIB;		// all paths are relative from here
  mysql_data_home[1]=0;
unknown's avatar
unknown committed
3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540

  if ((user_info= check_user(mysqld_user)))
  {
#if defined(HAVE_MLOCKALL) && defined(MCL_CURRENT)
    if (locked_in_memory) // getuid() == 0 here
      set_effective_user(user_info);
    else
#endif
      set_user(mysqld_user, user_info);
  }

unknown's avatar
unknown committed
3541 3542 3543 3544
  if (opt_bin_log && !server_id)
  {
    server_id= !master_host ? 1 : 2;
#ifdef EXTRA_DEBUG
3545
    switch (server_id) {
unknown's avatar
unknown committed
3546
    case 1:
3547 3548
      sql_print_warning("\
You have enabled the binary log, but you haven't set server-id to \
3549 3550
a non-zero value: we force server id to 1; updates will be logged to the \
binary log, but connections from slaves will not be accepted.");
unknown's avatar
unknown committed
3551 3552
      break;
    case 2:
3553 3554
      sql_print_warning("\
You should set server-id to a non-0 value if master_host is set; \
3555
we force server id to 2, but this MySQL server will not act as a slave.");
unknown's avatar
unknown committed
3556 3557
      break;
    }
3558
#endif
unknown's avatar
unknown committed
3559 3560 3561
  }

  if (init_server_components())
unknown's avatar
unknown committed
3562
    unireg_abort(1);
unknown's avatar
unknown committed
3563

unknown's avatar
unknown committed
3564 3565
  network_init();

unknown's avatar
unknown committed
3566 3567 3568
#ifdef __WIN__
  if (!opt_console)
  {
3569 3570
    freopen(log_error_file,"a+",stdout);
    freopen(log_error_file,"a+",stderr);
unknown's avatar
unknown committed
3571
    FreeConsole();				// Remove window
3572
  }
unknown's avatar
unknown committed
3573 3574
#endif

3575 3576 3577 3578 3579 3580
  /*
   Initialize my_str_malloc() and my_str_free()
  */
  my_str_malloc= &my_str_malloc_mysqld;
  my_str_free= &my_str_free_mysqld;

unknown's avatar
unknown committed
3581 3582 3583 3584
  /*
    init signals & alarm
    After this we can't quit by a simple unireg_abort
  */
3585
  error_handler_hook= my_message_sql;
unknown's avatar
unknown committed
3586
  start_signal_handler();				// Creates pidfile
3587

3588
  if (acl_init(opt_noacl) ||
3589
      my_tz_init((THD *)0, default_tz_name, opt_bootstrap))
unknown's avatar
unknown committed
3590 3591 3592
  {
    abort_loop=1;
    select_thread_in_use=0;
unknown's avatar
unknown committed
3593 3594 3595
#ifndef __NETWARE__
    (void) pthread_kill(signal_thread, MYSQL_KILL_SIGNAL);
#endif /* __NETWARE__ */
3596

unknown's avatar
unknown committed
3597 3598
    if (!opt_bootstrap)
      (void) my_delete(pidfile_name,MYF(MY_WME));	// Not needed anymore
3599

3600
    if (unix_sock != INVALID_SOCKET)
3601
      unlink(mysqld_unix_port);
unknown's avatar
unknown committed
3602 3603 3604
    exit(1);
  }
  if (!opt_noacl)
3605
    (void) grant_init();
unknown's avatar
unknown committed
3606 3607

  if (!opt_noacl)
3608
  {
unknown's avatar
unknown committed
3609
    plugin_load();
3610
#ifdef HAVE_DLOPEN
unknown's avatar
unknown committed
3611 3612
    udf_init();
#endif
3613
  }
3614
  init_status_vars();
unknown's avatar
unknown committed
3615 3616
  if (opt_bootstrap) /* If running with bootstrap, do not start replication. */
    opt_skip_slave_start= 1;
3617 3618 3619 3620 3621 3622 3623 3624 3625 3626 3627
  /*
    init_slave() must be called after the thread keys are created.
    Some parts of the code (e.g. SHOW STATUS LIKE 'slave_running' and other
    places) assume that active_mi != 0, so let's fail if it's 0 (out of
    memory); a message has already been printed.
  */
  if (init_slave() && !active_mi)
  {
    end_thr_alarm(1);				// Don't allow alarms
    unireg_abort(1);
  }
3628

unknown's avatar
unknown committed
3629 3630
  if (opt_bootstrap)
  {
3631
    select_thread_in_use= 0;                    // Allow 'kill' to work
unknown's avatar
Merge  
unknown committed
3632
    bootstrap(stdin);
3633
    end_thr_alarm(1);				// Don't allow alarms
unknown's avatar
Merge  
unknown committed
3634
    unireg_abort(bootstrap_error ? 1 : 0);
unknown's avatar
unknown committed
3635 3636 3637 3638 3639
  }
  if (opt_init_file)
  {
    if (read_init_file(opt_init_file))
    {
3640
      end_thr_alarm(1);				// Don't allow alarms
unknown's avatar
unknown committed
3641 3642 3643
      unireg_abort(1);
    }
  }
3644
  execute_ddl_log_recovery();
unknown's avatar
unknown committed
3645

unknown's avatar
unknown committed
3646
  create_shutdown_thread();
unknown's avatar
unknown committed
3647 3648
  create_maintenance_thread();

3649
  sql_print_information(ER(ER_STARTUP),my_progname,server_version,
unknown's avatar
unknown committed
3650
                        ((unix_sock == INVALID_SOCKET) ? (char*) ""
unknown's avatar
Merge  
unknown committed
3651
                                                       : mysqld_unix_port),
unknown's avatar
unknown committed
3652
                         mysqld_port,
unknown's avatar
Merge  
unknown committed
3653
                         MYSQL_COMPILATION_COMMENT);
unknown's avatar
unknown committed
3654

unknown's avatar
unknown committed
3655 3656 3657 3658
  // Signal threads waiting for server to be started
  mysqld_server_started= 1;
  pthread_cond_signal(&COND_server_started);

3659 3660 3661 3662
  if (!opt_noacl)
  {
    Events::init();
  }
3663 3664
#if defined(__NT__) || defined(HAVE_SMEM)
  handle_connections_methods();
unknown's avatar
unknown committed
3665
#else
unknown's avatar
unknown committed
3666
#ifdef __WIN__
unknown's avatar
Merge  
unknown committed
3667
  if (!have_tcpip || opt_disable_networking)
unknown's avatar
unknown committed
3668
  {
unknown's avatar
unknown committed
3669
    sql_print_error("TCP/IP unavailable or disabled with --skip-networking; no available interfaces");
unknown's avatar
unknown committed
3670 3671 3672
    unireg_abort(1);
  }
#endif
unknown's avatar
unknown committed
3673 3674 3675 3676
  handle_connections_sockets(0);
#endif /* __NT__ */

  /* (void) pthread_attr_destroy(&connection_attrib); */
3677
  
unknown's avatar
unknown committed
3678 3679 3680
  DBUG_PRINT("quit",("Exiting main thread"));

#ifndef __WIN__
unknown's avatar
unknown committed
3681
#ifdef EXTRA_DEBUG2
unknown's avatar
unknown committed
3682 3683 3684
  sql_print_error("Before Lock_thread_count");
#endif
  (void) pthread_mutex_lock(&LOCK_thread_count);
unknown's avatar
unknown committed
3685
  DBUG_PRINT("quit", ("Got thread_count mutex"));
unknown's avatar
unknown committed
3686 3687
  select_thread_in_use=0;			// For close_connections
  (void) pthread_mutex_unlock(&LOCK_thread_count);
3688
  (void) pthread_cond_broadcast(&COND_thread_count);
unknown's avatar
unknown committed
3689
#ifdef EXTRA_DEBUG2
unknown's avatar
unknown committed
3690 3691
  sql_print_error("After lock_thread_count");
#endif
unknown's avatar
merge  
unknown committed
3692
#endif /* __WIN__ */
3693

unknown's avatar
unknown committed
3694 3695 3696 3697 3698
  /* 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);
unknown's avatar
merge  
unknown committed
3699

3700
  release_ddl_log();
unknown's avatar
merge  
unknown committed
3701
#if defined(__WIN__) && !defined(EMBEDDED_LIBRARY)
unknown's avatar
merge  
unknown committed
3702 3703 3704 3705
  if (Service.IsNT() && start_mode)
    Service.Stop();
  else
  {
unknown's avatar
unknown committed
3706
    Service.SetShutdownEvent(0);
unknown's avatar
merge  
unknown committed
3707 3708 3709
    if (hEventShutdown)
      CloseHandle(hEventShutdown);
  }
unknown's avatar
unknown committed
3710
#endif
unknown's avatar
unknown committed
3711
  clean_up(1);
3712
  wait_for_signal_thread_to_end();
unknown's avatar
unknown committed
3713
  clean_up_mutexes();
unknown's avatar
unknown committed
3714
  my_end(opt_endinfo ? MY_CHECK_ERROR | MY_GIVE_INFO : 0);
3715

unknown's avatar
unknown committed
3716 3717 3718 3719
  exit(0);
  return(0);					/* purecov: deadcode */
}

3720
#endif /* EMBEDDED_LIBRARY */
unknown's avatar
unknown committed
3721

unknown's avatar
SCRUM  
unknown committed
3722

3723 3724 3725 3726 3727
/****************************************************************************
  Main and thread entry function for Win32
  (all this is needed only to run mysqld as a service on WinNT)
****************************************************************************/

unknown's avatar
unknown committed
3728
#if defined(__WIN__) && !defined(EMBEDDED_LIBRARY)
unknown's avatar
unknown committed
3729 3730
int mysql_service(void *p)
{
3731 3732 3733 3734
  if (use_opt_args)
    win_main(opt_argc, opt_argv);
  else
    win_main(Service.my_argc, Service.my_argv);
unknown's avatar
unknown committed
3735 3736 3737
  return 0;
}

3738 3739 3740 3741 3742 3743 3744 3745

/* Quote string if it contains space, else copy */

static char *add_quoted_string(char *to, const char *from, char *to_end)
{
  uint length= (uint) (to_end-to);

  if (!strchr(from, ' '))
unknown's avatar
unknown committed
3746 3747
    return strmake(to, from, length-1);
  return strxnmov(to, length-1, "\"", from, "\"", NullS);
3748 3749 3750
}


3751 3752 3753 3754 3755
/*
  Handle basic handling of services, like installation and removal

  SYNOPSIS
    default_service_handling()
3756
    argv		Pointer to argument list
3757 3758 3759
    servicename		Internal name of service
    displayname		Display name of service (in taskbar ?)
    file_path		Path to this program
3760
    startup_option	Startup option to mysqld
3761 3762 3763 3764 3765 3766

  RETURN VALUES
    0		option handled
    1		Could not handle option
 */

3767 3768 3769 3770 3771
static bool
default_service_handling(char **argv,
			 const char *servicename,
			 const char *displayname,
			 const char *file_path,
unknown's avatar
Merge  
unknown committed
3772 3773
			 const char *extra_opt,
			 const char *account_name)
3774
{
3775
  char path_and_service[FN_REFLEN+FN_REFLEN+32], *pos, *end;
3776
  end= path_and_service + sizeof(path_and_service)-3;
3777 3778 3779 3780 3781 3782 3783 3784 3785

  /* We have to quote filename if it contains spaces */
  pos= add_quoted_string(path_and_service, file_path, end);
  if (*extra_opt)
  {
    /* Add (possible quoted) option after file_path */
    *pos++= ' ';
    pos= add_quoted_string(pos, extra_opt, end);
  }
3786 3787
  /* We must have servicename last */
  *pos++= ' ';
unknown's avatar
unknown committed
3788
  (void) add_quoted_string(pos, servicename, end);
3789

3790 3791
  if (Service.got_service_option(argv, "install"))
  {
unknown's avatar
Merge  
unknown committed
3792 3793
    Service.Install(1, servicename, displayname, path_and_service,
                    account_name);
3794 3795 3796 3797
    return 0;
  }
  if (Service.got_service_option(argv, "install-manual"))
  {
unknown's avatar
Merge  
unknown committed
3798 3799
    Service.Install(0, servicename, displayname, path_and_service,
                    account_name);
3800 3801 3802 3803 3804 3805 3806 3807 3808 3809 3810
    return 0;
  }
  if (Service.got_service_option(argv, "remove"))
  {
    Service.Remove(servicename);
    return 0;
  }
  return 1;
}


unknown's avatar
unknown committed
3811 3812
int main(int argc, char **argv)
{
unknown's avatar
unknown committed
3813 3814 3815 3816
  /*
    When several instances are running on the same machine, we
    need to have an  unique  named  hEventShudown  through the
    application PID e.g.: MySQLShutdown1890; MySQLShutdown2342
unknown's avatar
Merge  
unknown committed
3817
  */
3818
  int10_to_str((int) GetCurrentProcessId(),strmov(shutdown_event_name,
unknown's avatar
Merge  
unknown committed
3819 3820
                                                  "MySQLShutdown"), 10);

3821 3822 3823
  /* Must be initialized early for comparison of service name */
  system_charset_info= &my_charset_utf8_general_ci;

unknown's avatar
unknown committed
3824
  if (Service.GetOS())	/* true NT family */
unknown's avatar
unknown committed
3825
  {
unknown's avatar
unknown committed
3826
    char file_path[FN_REFLEN];
3827
    my_path(file_path, argv[0], "");		      /* Find name in path */
unknown's avatar
unknown committed
3828 3829
    fn_format(file_path,argv[0],file_path,"",
	      MY_REPLACE_DIR | MY_UNPACK_FILENAME | MY_RESOLVE_SYMLINKS);
unknown's avatar
unknown committed
3830

unknown's avatar
unknown committed
3831
    if (argc == 2)
3832
    {
3833
      if (!default_service_handling(argv, MYSQL_SERVICENAME, MYSQL_SERVICENAME,
unknown's avatar
Merge  
unknown committed
3834
				   file_path, "", NULL))
3835
	return 0;
unknown's avatar
unknown committed
3836
      if (Service.IsService(argv[1]))        /* Start an optional service */
unknown's avatar
unknown committed
3837
      {
unknown's avatar
unknown committed
3838 3839 3840 3841 3842 3843
	/*
	  Only add the service name to the groups read from the config file
	  if it's not "MySQL". (The default service name should be 'mysqld'
	  but we started a bad tradition by calling it MySQL from the start
	  and we are now stuck with it.
	*/
3844
	if (my_strcasecmp(system_charset_info, argv[1],"mysql"))
3845
	  load_default_groups[load_default_groups_sz-2]= argv[1];
unknown's avatar
unknown committed
3846
        start_mode= 1;
3847
        Service.Init(argv[1], mysql_service);
unknown's avatar
unknown committed
3848 3849 3850 3851
        return 0;
      }
    }
    else if (argc == 3) /* install or remove any optional service */
unknown's avatar
unknown committed
3852
    {
unknown's avatar
Merge  
unknown committed
3853 3854
      if (!default_service_handling(argv, argv[2], argv[2], file_path, "",
                                    NULL))
3855 3856
	return 0;
      if (Service.IsService(argv[2]))
unknown's avatar
unknown committed
3857
      {
3858 3859 3860 3861
	/*
	  mysqld was started as
	  mysqld --defaults-file=my_path\my.ini service-name
	*/
3862
	use_opt_args=1;
3863
	opt_argc= 2;				// Skip service-name
3864 3865
	opt_argv=argv;
	start_mode= 1;
3866
	if (my_strcasecmp(system_charset_info, argv[2],"mysql"))
3867
	  load_default_groups[load_default_groups_sz-2]= argv[2];
3868
	Service.Init(argv[2], mysql_service);
3869
	return 0;
unknown's avatar
unknown committed
3870 3871
      }
    }
unknown's avatar
Merge  
unknown committed
3872
    else if (argc == 4 || argc == 5)
3873 3874
    {
      /*
unknown's avatar
Merge  
unknown committed
3875 3876 3877 3878 3879
        This may seem strange, because we handle --local-service while
        preserving 4.1's behavior of allowing any one other argument that is
        passed to the service on startup. (The assumption is that this is
        --defaults-file=file, but that was not enforced in 4.1, so we don't
        enforce it here.)
3880
      */
unknown's avatar
Merge  
unknown committed
3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 3893 3894 3895
      const char *extra_opt= NullS;
      const char *account_name = NullS;
      int index;
      for (index = 3; index < argc; index++)
      {
        if (!strcmp(argv[index], "--local-service"))
          account_name= "NT AUTHORITY\\LocalService";
        else
          extra_opt= argv[index];
      }

      if (argc == 4 || account_name)
        if (!default_service_handling(argv, argv[2], argv[2], file_path,
                                      extra_opt, account_name))
          return 0;
3896
    }
unknown's avatar
unknown committed
3897
    else if (argc == 1 && Service.IsService(MYSQL_SERVICENAME))
unknown's avatar
unknown committed
3898
    {
unknown's avatar
unknown committed
3899 3900 3901
      /* start the default service */
      start_mode= 1;
      Service.Init(MYSQL_SERVICENAME, mysql_service);
unknown's avatar
unknown committed
3902 3903 3904
      return 0;
    }
  }
unknown's avatar
unknown committed
3905
  /* Start as standalone server */
unknown's avatar
unknown committed
3906 3907 3908 3909 3910 3911 3912 3913
  Service.my_argc=argc;
  Service.my_argv=argv;
  mysql_service(NULL);
  return 0;
}
#endif


3914 3915 3916 3917
/*
  Execute all commands from a file. Used by the mysql_install_db script to
  create MySQL privilege tables without having to start a full MySQL server.
*/
3918

unknown's avatar
Merge  
unknown committed
3919
static void bootstrap(FILE *file)
unknown's avatar
unknown committed
3920
{
3921
  DBUG_ENTER("bootstrap");
3922

3923
  THD *thd= new THD;
unknown's avatar
unknown committed
3924
  thd->bootstrap=1;
unknown's avatar
unknown committed
3925
  my_net_init(&thd->net,(st_vio*) 0);
unknown's avatar
unknown committed
3926
  thd->max_client_packet_length= thd->net.max_packet;
3927
  thd->security_ctx->master_access= ~(ulong)0;
3928
  thd->thread_id=thread_id++;
unknown's avatar
unknown committed
3929
  thread_count++;
3930 3931

  bootstrap_file=file;
unknown's avatar
unknown committed
3932
#ifndef EMBEDDED_LIBRARY			// TODO:  Enable this
3933 3934 3935
  if (pthread_create(&thd->real_id,&connection_attrib,handle_bootstrap,
		     (void*) thd))
  {
3936
    sql_print_warning("Can't create thread to handle bootstrap");
unknown's avatar
Merge  
unknown committed
3937 3938
    bootstrap_error=-1;
    DBUG_VOID_RETURN;
3939 3940 3941 3942 3943 3944 3945 3946 3947
  }
  /* 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);
unknown's avatar
unknown committed
3948 3949 3950 3951 3952
#else
  thd->mysql= 0;
  handle_bootstrap((void *)thd);
#endif

unknown's avatar
Merge  
unknown committed
3953
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
3954 3955
}

3956

unknown's avatar
unknown committed
3957 3958 3959 3960 3961 3962 3963
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);
unknown's avatar
Merge  
unknown committed
3964
  bootstrap(file);
unknown's avatar
unknown committed
3965 3966 3967 3968 3969
  (void) my_fclose(file,MYF(MY_WME));
  return 0;
}


3970
#ifndef EMBEDDED_LIBRARY
3971 3972 3973 3974 3975 3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987 3988 3989
/*
  Create new thread to handle incoming connection.

  SYNOPSIS
    create_new_thread()
      thd in/out    Thread handle of future thread.

  DESCRIPTION
    This function will create new thread to handle the incoming
    connection.  If there are idle cached threads one will be used.
    'thd' will be pushed into 'threads'.

    In single-threaded mode (#define ONE_THREAD) connection will be
    handled inside this function.

  RETURN VALUE
    none
*/

unknown's avatar
unknown committed
3990 3991 3992 3993 3994
static void create_new_thread(THD *thd)
{
  DBUG_ENTER("create_new_thread");

  NET *net=&thd->net;				// For easy ref
unknown's avatar
unknown committed
3995
  net->read_timeout = (uint) connect_timeout;
unknown's avatar
unknown committed
3996 3997 3998 3999 4000 4001
  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)
  {
unknown's avatar
unknown committed
4002
    DBUG_PRINT("error",("Too many connections"));
4003
    close_connection(thd, ER_CON_COUNT_ERROR, 1);
unknown's avatar
unknown committed
4004 4005 4006
    delete thd;
    DBUG_VOID_RETURN;
  }
4007
  pthread_mutex_lock(&LOCK_thread_count);
unknown's avatar
unknown committed
4008
  thd->thread_id=thread_id++;
4009

unknown's avatar
unknown committed
4010 4011 4012
  thd->real_id=pthread_self();			// Keep purify happy

  /* Start a new thread to handle connection */
4013 4014
  thread_count++;

4015
#ifdef ONE_THREAD
unknown's avatar
unknown committed
4016 4017 4018 4019 4020 4021 4022 4023 4024 4025 4026
  if (test_flags & TEST_NO_THREADS)		// For debugging under Linux
  {
    thread_cache_size=0;			// Safety
    threads.append(thd);
    thd->real_id=pthread_self();
    (void) pthread_mutex_unlock(&LOCK_thread_count);
    handle_one_connection((void*) thd);
  }
  else
#endif
  {
4027 4028 4029
    if (thread_count-delayed_insert_threads > max_used_connections)
      max_used_connections=thread_count-delayed_insert_threads;

unknown's avatar
unknown committed
4030 4031
    if (cached_thread_count > wake_thread)
    {
4032 4033 4034
      thread_cache.append(thd);
      wake_thread++;
      pthread_cond_signal(&COND_thread_cache);
unknown's avatar
unknown committed
4035 4036 4037 4038
    }
    else
    {
      int error;
4039
      thread_created++;
unknown's avatar
unknown committed
4040 4041 4042 4043 4044 4045 4046 4047 4048 4049 4050
      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--;
unknown's avatar
Merge  
unknown committed
4051
	thd->killed= THD::KILL_CONNECTION;			// Safety
unknown's avatar
unknown committed
4052
	(void) pthread_mutex_unlock(&LOCK_thread_count);
4053
	statistic_increment(aborted_connects,&LOCK_status);
unknown's avatar
Merge  
unknown committed
4054
	net_printf_error(thd, ER_CANT_CREATE_THREAD, error);
unknown's avatar
unknown committed
4055
	(void) pthread_mutex_lock(&LOCK_thread_count);
4056
	close_connection(thd,0,0);
unknown's avatar
unknown committed
4057 4058 4059 4060 4061
	delete thd;
	(void) pthread_mutex_unlock(&LOCK_thread_count);
	DBUG_VOID_RETURN;
      }
    }
4062 4063
    (void) pthread_mutex_unlock(&LOCK_thread_count);

unknown's avatar
unknown committed
4064
  }
4065
  DBUG_PRINT("info",("Thread created"));
unknown's avatar
unknown committed
4066 4067
  DBUG_VOID_RETURN;
}
4068 4069
#endif /* EMBEDDED_LIBRARY */

unknown's avatar
unknown committed
4070

unknown's avatar
unknown committed
4071 4072 4073 4074
#ifdef SIGNALS_DONT_BREAK_READ
inline void kill_broken_server()
{
  /* hack to get around signals ignored in syscalls for problem OS's */
unknown's avatar
unknown committed
4075 4076 4077 4078
  if (
#if !defined(__NETWARE__)
      unix_sock == INVALID_SOCKET ||
#endif
4079
      (!opt_disable_networking && ip_sock == INVALID_SOCKET))
unknown's avatar
unknown committed
4080 4081
  {
    select_thread_in_use = 0;
unknown's avatar
unknown committed
4082 4083
    /* The following call will never return */
    kill_server(IF_NETWARE(MYSQL_KILL_SIGNAL, (void*) MYSQL_KILL_SIGNAL));
unknown's avatar
unknown committed
4084 4085 4086 4087 4088 4089
  }
}
#define MAYBE_BROKEN_SYSCALL kill_broken_server();
#else
#define MAYBE_BROKEN_SYSCALL
#endif
unknown's avatar
unknown committed
4090 4091 4092

	/* Handle new connections and spawn new process to handle them */

4093
#ifndef EMBEDDED_LIBRARY
4094
pthread_handler_t handle_connections_sockets(void *arg __attribute__((unused)))
unknown's avatar
unknown committed
4095 4096 4097 4098 4099 4100 4101 4102
{
  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;
unknown's avatar
unknown committed
4103
  st_vio *vio_tmp;
unknown's avatar
unknown committed
4104 4105 4106 4107 4108 4109 4110 4111 4112 4113 4114 4115 4116 4117 4118 4119
  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);
unknown's avatar
unknown committed
4120
#ifdef HAVE_FCNTL
unknown's avatar
unknown committed
4121
  socket_flags=fcntl(unix_sock, F_GETFL, 0);
unknown's avatar
unknown committed
4122
#endif
unknown's avatar
unknown committed
4123 4124 4125
#endif

  DBUG_PRINT("general",("Waiting for connections."));
unknown's avatar
unknown committed
4126
  MAYBE_BROKEN_SYSCALL;
unknown's avatar
unknown committed
4127 4128 4129
  while (!abort_loop)
  {
    readFDs=clientFDs;
4130
#ifdef HPUX10
unknown's avatar
unknown committed
4131 4132 4133 4134 4135
    if (select(max_used_connection,(int*) &readFDs,0,0,0) < 0)
      continue;
#else
    if (select((int) max_used_connection,&readFDs,0,0,0) < 0)
    {
unknown's avatar
unknown committed
4136
      if (socket_errno != SOCKET_EINTR)
unknown's avatar
unknown committed
4137 4138
      {
	if (!select_errors++ && !abort_loop)	/* purecov: inspected */
unknown's avatar
unknown committed
4139
	  sql_print_error("mysqld: Got error %d from select",socket_errno); /* purecov: inspected */
unknown's avatar
unknown committed
4140
      }
unknown's avatar
unknown committed
4141
      MAYBE_BROKEN_SYSCALL
unknown's avatar
unknown committed
4142 4143
      continue;
    }
4144
#endif	/* HPUX10 */
unknown's avatar
unknown committed
4145
    if (abort_loop)
unknown's avatar
unknown committed
4146 4147
    {
      MAYBE_BROKEN_SYSCALL;
unknown's avatar
unknown committed
4148
      break;
unknown's avatar
unknown committed
4149
    }
unknown's avatar
unknown committed
4150

4151
    /* Is this a new connection request ? */
unknown's avatar
unknown committed
4152 4153 4154 4155 4156 4157 4158 4159 4160 4161 4162 4163 4164 4165 4166 4167 4168 4169 4170 4171 4172 4173 4174 4175 4176 4177 4178 4179
#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);
unknown's avatar
unknown committed
4180 4181 4182 4183 4184 4185 4186
#ifdef __NETWARE__ 
      // TODO: temporary fix, waiting for TCP/IP fix - DEFECT000303149
      if ((new_sock == INVALID_SOCKET) && (socket_errno == EINVAL))
      {
        kill_server(SIGTERM);
      }
#endif
unknown's avatar
unknown committed
4187 4188
      if (new_sock != INVALID_SOCKET ||
	  (socket_errno != SOCKET_EINTR && socket_errno != SOCKET_EAGAIN))
unknown's avatar
unknown committed
4189
	break;
unknown's avatar
unknown committed
4190
      MAYBE_BROKEN_SYSCALL;
unknown's avatar
unknown committed
4191 4192 4193 4194 4195 4196 4197 4198 4199 4200 4201 4202
#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
unknown's avatar
unknown committed
4203
    if (new_sock == INVALID_SOCKET)
unknown's avatar
unknown committed
4204 4205 4206
    {
      if ((error_count++ & 255) == 0)		// This can happen often
	sql_perror("Error in accept");
unknown's avatar
unknown committed
4207
      MAYBE_BROKEN_SYSCALL;
unknown's avatar
unknown committed
4208
      if (socket_errno == SOCKET_ENFILE || socket_errno == SOCKET_EMFILE)
unknown's avatar
unknown committed
4209 4210 4211 4212 4213 4214 4215 4216 4217 4218 4219
	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);
4220 4221
	fromhost(&req);
	if (!hosts_access(&req))
unknown's avatar
unknown committed
4222
	{
unknown's avatar
unknown committed
4223 4224 4225 4226 4227
	  /*
	    This may be stupid but refuse() includes an exit(0)
	    which we surely don't want...
	    clean_exit() - same stupid thing ...
	  */
4228
	  syslog(deny_severity, "refused connect from %s",
4229
		 eval_client(&req));
unknown's avatar
unknown committed
4230

unknown's avatar
unknown committed
4231 4232 4233 4234 4235 4236
	  /*
	    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...
	  */
unknown's avatar
unknown committed
4237 4238 4239
	  if (req.sink)
	    ((void (*)(int))req.sink)(req.fd);

4240
	  (void) shutdown(new_sock,2);
unknown's avatar
unknown committed
4241 4242 4243 4244 4245 4246 4247 4248 4249 4250 4251 4252 4253 4254 4255 4256 4257 4258 4259 4260 4261 4262 4263 4264 4265 4266
	  (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))
    {
unknown's avatar
unknown committed
4267 4268
      (void) shutdown(new_sock,2);
      VOID(closesocket(new_sock));
unknown's avatar
unknown committed
4269 4270 4271
      continue;
    }
    if (!(vio_tmp=vio_new(new_sock,
4272
			  sock == unix_sock ? VIO_TYPE_SOCKET :
unknown's avatar
unknown committed
4273
			  VIO_TYPE_TCPIP,
4274
			  sock == unix_sock ? VIO_LOCALHOST: 0)) ||
unknown's avatar
unknown committed
4275 4276 4277 4278 4279 4280 4281 4282 4283 4284 4285 4286 4287
	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)
4288
      thd->security_ctx->host=(char*) my_localhost;
4289 4290 4291 4292 4293 4294
#ifdef __WIN__
    /* Set default wait_timeout */
    ulong wait_timeout= global_system_variables.net_wait_timeout * 1000;
    (void) setsockopt(new_sock, SOL_SOCKET, SO_RCVTIMEO, (char*)&wait_timeout,
                    sizeof(wait_timeout));
#endif
unknown's avatar
unknown committed
4295 4296 4297
    create_new_thread(thd);
  }

4298
  decrement_handler_count();
unknown's avatar
unknown committed
4299 4300 4301 4302 4303
  DBUG_RETURN(0);
}


#ifdef __NT__
4304
pthread_handler_t handle_connections_namedpipes(void *arg)
unknown's avatar
unknown committed
4305 4306 4307 4308 4309 4310 4311 4312 4313 4314 4315 4316
{
  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 */
unknown's avatar
Merge  
unknown committed
4317
    fConnected = ConnectNamedPipe(hPipe, NULL);
unknown's avatar
unknown committed
4318 4319
    if (abort_loop)
      break;
unknown's avatar
unknown committed
4320
    if (!fConnected)
unknown's avatar
unknown committed
4321
      fConnected = GetLastError() == ERROR_PIPE_CONNECTED;
unknown's avatar
unknown committed
4322
    if (!fConnected)
unknown's avatar
unknown committed
4323
    {
unknown's avatar
Merge  
unknown committed
4324 4325 4326 4327 4328 4329 4330 4331 4332 4333 4334 4335 4336 4337
      CloseHandle(hPipe);
      if ((hPipe= CreateNamedPipe(pipe_name,
                                  PIPE_ACCESS_DUPLEX,
                                  PIPE_TYPE_BYTE |
                                  PIPE_READMODE_BYTE |
                                  PIPE_WAIT,
                                  PIPE_UNLIMITED_INSTANCES,
                                  (int) global_system_variables.
                                  net_buffer_length,
                                  (int) global_system_variables.
                                  net_buffer_length,
                                  NMPWAIT_USE_DEFAULT_WAIT,
                                  &saPipeSecurity)) ==
	  INVALID_HANDLE_VALUE)
unknown's avatar
unknown committed
4338 4339 4340 4341 4342 4343 4344
      {
	sql_perror("Can't create new named pipe!");
	break;					// Abort
      }
    }
    hConnectedPipe = hPipe;
    /* create new pipe for new connection */
4345
    if ((hPipe = CreateNamedPipe(pipe_name,
unknown's avatar
unknown committed
4346 4347 4348 4349 4350
				 PIPE_ACCESS_DUPLEX,
				 PIPE_TYPE_BYTE |
				 PIPE_READMODE_BYTE |
				 PIPE_WAIT,
				 PIPE_UNLIMITED_INSTANCES,
4351 4352
				 (int) global_system_variables.net_buffer_length,
				 (int) global_system_variables.net_buffer_length,
unknown's avatar
unknown committed
4353 4354 4355 4356 4357 4358 4359 4360 4361
				 NMPWAIT_USE_DEFAULT_WAIT,
				 &saPipeSecurity)) ==
	INVALID_HANDLE_VALUE)
    {
      sql_perror("Can't create new named pipe!");
      hPipe=hConnectedPipe;
      continue;					// We have to try again
    }

unknown's avatar
unknown committed
4362
    if (!(thd = new THD))
unknown's avatar
unknown committed
4363
    {
unknown's avatar
Merge  
unknown committed
4364 4365
      DisconnectNamedPipe(hConnectedPipe);
      CloseHandle(hConnectedPipe);
unknown's avatar
unknown committed
4366 4367 4368 4369 4370
      continue;
    }
    if (!(thd->net.vio = vio_new_win32pipe(hConnectedPipe)) ||
	my_net_init(&thd->net, thd->net.vio))
    {
4371
      close_connection(thd, ER_OUT_OF_RESOURCES, 1);
unknown's avatar
unknown committed
4372 4373 4374
      delete thd;
      continue;
    }
4375 4376
    /* Host is unknown */
    thd->security_ctx->host= my_strdup(my_localhost, MYF(0));
unknown's avatar
unknown committed
4377 4378 4379
    create_new_thread(thd);
  }

4380
  decrement_handler_count();
unknown's avatar
unknown committed
4381 4382 4383 4384
  DBUG_RETURN(0);
}
#endif /* __NT__ */

4385

4386
/*
4387 4388 4389
  Thread of shared memory's service

  SYNOPSIS
4390
    handle_connections_shared_memory()
4391 4392
    arg                              Arguments of thread
*/
4393

4394
#ifdef HAVE_SMEM
4395
pthread_handler_t handle_connections_shared_memory(void *arg)
4396
{
4397 4398
  /* file-mapping object, use for create shared memory */
  HANDLE handle_connect_file_map= 0;
4399
  char  *handle_connect_map= 0;                 // pointer on shared memory
4400 4401 4402
  HANDLE event_connect_answer= 0;
  ulong smem_buffer_length= shared_memory_buffer_length + 4;
  ulong connect_number= 1;
4403 4404 4405
  char tmp[63];
  char *suffix_pos;
  char connect_number_char[22], *p;
4406
  const char *errmsg= 0;
4407
  SECURITY_ATTRIBUTES *sa_event= 0, *sa_mapping= 0;
4408 4409 4410 4411
  my_thread_init();
  DBUG_ENTER("handle_connections_shared_memorys");
  DBUG_PRINT("general",("Waiting for allocated shared memory."));

4412 4413 4414 4415 4416 4417 4418 4419
  if (my_security_attr_create(&sa_event, &errmsg,
                              GENERIC_ALL, SYNCHRONIZE | EVENT_MODIFY_STATE))
    goto error;

  if (my_security_attr_create(&sa_mapping, &errmsg,
                             GENERIC_ALL, FILE_MAP_READ | FILE_MAP_WRITE))
    goto error;

4420 4421 4422 4423 4424 4425 4426
  /*
    The name of event and file-mapping events create agree next rule:
      shared_memory_base_name+unique_part
    Where:
      shared_memory_base_name is unique value for each server
      unique_part is unique value for each object (events and file-mapping)
  */
4427
  suffix_pos= strxmov(tmp,shared_memory_base_name,"_",NullS);
4428
  strmov(suffix_pos, "CONNECT_REQUEST");
4429 4430
  if ((smem_event_connect_request= CreateEvent(sa_event,
                                               FALSE, FALSE, tmp)) == 0)
4431
  {
4432
    errmsg= "Could not create request event";
4433 4434
    goto error;
  }
4435
  strmov(suffix_pos, "CONNECT_ANSWER");
4436
  if ((event_connect_answer= CreateEvent(sa_event, FALSE, FALSE, tmp)) == 0)
4437
  {
4438
    errmsg="Could not create answer event";
4439 4440
    goto error;
  }
4441
  strmov(suffix_pos, "CONNECT_DATA");
4442 4443 4444
  if ((handle_connect_file_map=
       CreateFileMapping(INVALID_HANDLE_VALUE, sa_mapping,
                         PAGE_READWRITE, 0, sizeof(connect_number), tmp)) == 0)
4445
  {
4446
    errmsg= "Could not create file mapping";
4447 4448
    goto error;
  }
4449 4450 4451
  if ((handle_connect_map= (char *)MapViewOfFile(handle_connect_file_map,
						  FILE_MAP_WRITE,0,0,
						  sizeof(DWORD))) == 0)
4452
  {
4453
    errmsg= "Could not create shared memory service";
4454 4455 4456 4457 4458
    goto error;
  }

  while (!abort_loop)
  {
4459
    /* Wait a request from client */
4460
    WaitForSingleObject(smem_event_connect_request,INFINITE);
4461

unknown's avatar
unknown committed
4462 4463 4464
    /*
       it can be after shutdown command
    */
unknown's avatar
Merge  
unknown committed
4465
    if (abort_loop)
unknown's avatar
unknown committed
4466
      goto error;
4467

4468 4469 4470 4471 4472 4473
    HANDLE handle_client_file_map= 0;
    char  *handle_client_map= 0;
    HANDLE event_client_wrote= 0;
    HANDLE event_client_read= 0;    // for transfer data server <-> client
    HANDLE event_server_wrote= 0;
    HANDLE event_server_read= 0;
unknown's avatar
unknown committed
4474
    HANDLE event_conn_closed= 0;
4475
    THD *thd= 0;
4476

4477
    p= int10_to_str(connect_number, connect_number_char, 10);
4478 4479 4480 4481 4482 4483 4484 4485 4486 4487
    /*
      The name of event and file-mapping events create agree next rule:
        shared_memory_base_name+unique_part+number_of_connection
        Where:
	  shared_memory_base_name is uniquel value for each server
	  unique_part is unique value for each object (events and file-mapping)
	  number_of_connection is connection-number between server and client
    */
    suffix_pos= strxmov(tmp,shared_memory_base_name,"_",connect_number_char,
			 "_",NullS);
4488
    strmov(suffix_pos, "DATA");
4489 4490 4491
    if ((handle_client_file_map=
         CreateFileMapping(INVALID_HANDLE_VALUE, sa_mapping,
                           PAGE_READWRITE, 0, smem_buffer_length, tmp)) == 0)
4492
    {
4493
      errmsg= "Could not create file mapping";
4494 4495
      goto errorconn;
    }
4496 4497 4498
    if ((handle_client_map= (char*)MapViewOfFile(handle_client_file_map,
						  FILE_MAP_WRITE,0,0,
						  smem_buffer_length)) == 0)
4499
    {
4500
      errmsg= "Could not create memory map";
4501 4502 4503
      goto errorconn;
    }
    strmov(suffix_pos, "CLIENT_WROTE");
4504
    if ((event_client_wrote= CreateEvent(sa_event, FALSE, FALSE, tmp)) == 0)
4505
    {
4506
      errmsg= "Could not create client write event";
4507 4508 4509
      goto errorconn;
    }
    strmov(suffix_pos, "CLIENT_READ");
4510
    if ((event_client_read= CreateEvent(sa_event, FALSE, FALSE, tmp)) == 0)
4511
    {
4512
      errmsg= "Could not create client read event";
4513 4514 4515
      goto errorconn;
    }
    strmov(suffix_pos, "SERVER_READ");
4516
    if ((event_server_read= CreateEvent(sa_event, FALSE, FALSE, tmp)) == 0)
4517
    {
4518
      errmsg= "Could not create server read event";
4519 4520 4521
      goto errorconn;
    }
    strmov(suffix_pos, "SERVER_WROTE");
4522 4523
    if ((event_server_wrote= CreateEvent(sa_event,
                                         FALSE, FALSE, tmp)) == 0)
4524
    {
4525
      errmsg= "Could not create server write event";
4526 4527
      goto errorconn;
    }
unknown's avatar
unknown committed
4528
    strmov(suffix_pos, "CONNECTION_CLOSED");
4529 4530
    if ((event_conn_closed= CreateEvent(sa_event,
                                        TRUE, FALSE, tmp)) == 0)
unknown's avatar
unknown committed
4531 4532 4533 4534
    {
      errmsg= "Could not create closed connection event";
      goto errorconn;
    }
4535
    if (abort_loop)
4536
      goto errorconn;
4537 4538 4539
    if (!(thd= new THD))
      goto errorconn;
    /* Send number of connection to client */
4540
    int4store(handle_connect_map, connect_number);
4541
    if (!SetEvent(event_connect_answer))
4542
    {
4543
      errmsg= "Could not send answer event";
4544 4545
      goto errorconn;
    }
4546
    /* Set event that client should receive data */
4547 4548
    if (!SetEvent(event_client_read))
    {
4549
      errmsg= "Could not set client to read mode";
4550 4551
      goto errorconn;
    }
4552
    if (!(thd->net.vio= vio_new_win32shared_memory(&thd->net,
unknown's avatar
unknown committed
4553 4554 4555 4556 4557 4558
                                                   handle_client_file_map,
                                                   handle_client_map,
                                                   event_client_wrote,
                                                   event_client_read,
                                                   event_server_wrote,
                                                   event_server_read,
unknown's avatar
unknown committed
4559
                                                   event_conn_closed)) ||
unknown's avatar
unknown committed
4560
                        my_net_init(&thd->net, thd->net.vio))
4561
    {
4562
      close_connection(thd, ER_OUT_OF_RESOURCES, 1);
4563 4564
      errmsg= 0;
      goto errorconn;
4565
    }
4566
    thd->security_ctx->host= my_strdup(my_localhost, MYF(0)); /* Host is unknown */
4567
    create_new_thread(thd);
4568 4569 4570 4571 4572 4573 4574 4575 4576 4577 4578 4579
    connect_number++;
    continue;

errorconn:
    /* Could not form connection;  Free used handlers/memort and retry */
    if (errmsg)
    {
      char buff[180];
      strxmov(buff, "Can't create shared memory connection: ", errmsg, ".",
	      NullS);
      sql_perror(buff);
    }
unknown's avatar
unknown committed
4580 4581 4582 4583 4584 4585 4586 4587 4588 4589 4590 4591 4592 4593
    if (handle_client_file_map) 
      CloseHandle(handle_client_file_map);
    if (handle_client_map)
      UnmapViewOfFile(handle_client_map);
    if (event_server_wrote)
      CloseHandle(event_server_wrote);
    if (event_server_read)
      CloseHandle(event_server_read);
    if (event_client_wrote)
      CloseHandle(event_client_wrote);
    if (event_client_read)
      CloseHandle(event_client_read);
    if (event_conn_closed)
      CloseHandle(event_conn_closed);
4594
    delete thd;
4595
  }
4596 4597

  /* End shared memory handling */
4598
error:
4599 4600 4601 4602 4603 4604
  if (errmsg)
  {
    char buff[180];
    strxmov(buff, "Can't create shared memory service: ", errmsg, ".", NullS);
    sql_perror(buff);
  }
4605 4606
  my_security_attr_free(sa_event);
  my_security_attr_free(sa_mapping);
4607 4608 4609
  if (handle_connect_map)	UnmapViewOfFile(handle_connect_map);
  if (handle_connect_file_map)	CloseHandle(handle_connect_file_map);
  if (event_connect_answer)	CloseHandle(event_connect_answer);
4610
  if (smem_event_connect_request) CloseHandle(smem_event_connect_request);
4611 4612

  decrement_handler_count();
4613 4614 4615
  DBUG_RETURN(0);
}
#endif /* HAVE_SMEM */
4616
#endif /* EMBEDDED_LIBRARY */
unknown's avatar
unknown committed
4617

4618 4619 4620

/****************************************************************************
  Handle start options
unknown's avatar
unknown committed
4621 4622
******************************************************************************/

unknown's avatar
unknown committed
4623
enum options_mysqld
4624
{
4625 4626 4627
  OPT_ISAM_LOG=256,            OPT_SKIP_NEW, 
  OPT_SKIP_GRANT,              OPT_SKIP_LOCK, 
  OPT_ENABLE_LOCK,             OPT_USE_LOCKING,
4628 4629
  OPT_SOCKET,                  OPT_UPDATE_LOG,
  OPT_BIN_LOG,                 OPT_SKIP_RESOLVE,
4630 4631
  OPT_SKIP_NETWORKING,         OPT_BIN_LOG_INDEX,
  OPT_BIND_ADDRESS,            OPT_PID_FILE,
4632
  OPT_SKIP_PRIOR,              OPT_BIG_TABLES,
4633 4634
  OPT_STANDALONE,              OPT_ONE_THREAD,
  OPT_CONSOLE,                 OPT_LOW_PRIORITY_UPDATES,
4635
  OPT_SKIP_HOST_CACHE,         OPT_SHORT_LOG_FORMAT,
4636
  OPT_FLUSH,                   OPT_SAFE,
4637
  OPT_BOOTSTRAP,               OPT_SKIP_SHOW_DB,
unknown's avatar
unknown committed
4638
  OPT_STORAGE_ENGINE,          OPT_INIT_FILE,
4639
  OPT_DELAY_KEY_WRITE_ALL,     OPT_SLOW_QUERY_LOG,
4640
  OPT_DELAY_KEY_WRITE,	       OPT_CHARSETS_DIR,
4641
  OPT_BDB_HOME,                OPT_BDB_LOG,
4642
  OPT_BDB_TMP,                 OPT_BDB_SYNC,
4643
  OPT_BDB_LOCK,                OPT_BDB,
4644 4645
  OPT_BDB_NO_RECOVER,          OPT_BDB_SHARED,
  OPT_BDB_DATA_DIRECT,         OPT_BDB_LOG_DIRECT,
4646 4647 4648
  OPT_MASTER_HOST,             OPT_MASTER_USER,
  OPT_MASTER_PASSWORD,         OPT_MASTER_PORT,
  OPT_MASTER_INFO_FILE,        OPT_MASTER_CONNECT_RETRY,
unknown's avatar
Merge  
unknown committed
4649
  OPT_MASTER_RETRY_COUNT,      OPT_LOG_TC, OPT_LOG_TC_SIZE,
unknown's avatar
unknown committed
4650 4651
  OPT_MASTER_SSL,              OPT_MASTER_SSL_KEY,
  OPT_MASTER_SSL_CERT,         OPT_MASTER_SSL_CAPATH,
unknown's avatar
unknown committed
4652
  OPT_MASTER_SSL_CIPHER,       OPT_MASTER_SSL_CA,
4653
  OPT_SQL_BIN_UPDATE_SAME,     OPT_REPLICATE_DO_DB,
4654 4655
  OPT_REPLICATE_IGNORE_DB,     OPT_LOG_SLAVE_UPDATES,
  OPT_BINLOG_DO_DB,            OPT_BINLOG_IGNORE_DB,
4656 4657 4658 4659 4660 4661 4662
  OPT_BINLOG_FORMAT,
#ifndef DBUG_OFF
  OPT_BINLOG_SHOW_XID,
#endif
#ifdef HAVE_ROW_BASED_REPLICATION
  OPT_BINLOG_ROWS_EVENT_MAX_SIZE, 
#endif
4663 4664
  OPT_WANT_CORE,               OPT_CONCURRENT_INSERT,
  OPT_MEMLOCK,                 OPT_MYISAM_RECOVER,
4665
  OPT_REPLICATE_REWRITE_DB,    OPT_SERVER_ID,
4666
  OPT_SKIP_SLAVE_START,        OPT_SKIP_INNOBASE,
4667 4668
  OPT_SAFEMALLOC_MEM_LIMIT,    OPT_REPLICATE_DO_TABLE,
  OPT_REPLICATE_IGNORE_TABLE,  OPT_REPLICATE_WILD_DO_TABLE,
4669
  OPT_REPLICATE_WILD_IGNORE_TABLE, OPT_REPLICATE_SAME_SERVER_ID,
unknown's avatar
Merge  
unknown committed
4670
  OPT_DISCONNECT_SLAVE_EVENT_COUNT, OPT_TC_HEURISTIC_RECOVER,
4671
  OPT_ABORT_SLAVE_EVENT_COUNT,
4672 4673
  OPT_INNODB_DATA_HOME_DIR,
  OPT_INNODB_DATA_FILE_PATH,
4674 4675 4676 4677 4678
  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,
unknown's avatar
Merge  
unknown committed
4679 4680
  OPT_INNODB_DOUBLEWRITE,
  OPT_INNODB_CHECKSUMS,
4681
  OPT_INNODB_FAST_SHUTDOWN,
unknown's avatar
unknown committed
4682
  OPT_INNODB_FILE_PER_TABLE, OPT_CRASH_BINLOG_INNODB,
4683
  OPT_INNODB_LOCKS_UNSAFE_FOR_BINLOG,
4684
  OPT_LOG_BIN_TRUST_FUNCTION_CREATORS,
unknown's avatar
unknown committed
4685
  OPT_SAFE_SHOW_DB, OPT_INNODB_SAFE_BINLOG,
4686
  OPT_INNODB, OPT_ISAM,
unknown's avatar
Merge  
unknown committed
4687
  OPT_ENGINE_CONDITION_PUSHDOWN,
4688 4689
  OPT_NDBCLUSTER, OPT_NDB_CONNECTSTRING, OPT_NDB_USE_EXACT_COUNT,
  OPT_NDB_FORCE_SEND, OPT_NDB_AUTOINCREMENT_PREFETCH_SZ,
unknown's avatar
Merge  
unknown committed
4690 4691
  OPT_NDB_SHM, OPT_NDB_OPTIMIZED_NODE_SELECTION, OPT_NDB_CACHE_CHECK_TIME,
  OPT_NDB_MGMD, OPT_NDB_NODEID,
unknown's avatar
unknown committed
4692
  OPT_NDB_DISTRIBUTION,
4693 4694
  OPT_NDB_INDEX_STAT_ENABLE,
  OPT_NDB_INDEX_STAT_CACHE_ENTRIES, OPT_NDB_INDEX_STAT_UPDATE_FREQ,
unknown's avatar
unknown committed
4695 4696 4697
  OPT_NDB_EXTRA_LOGGING,
  OPT_NDB_REPORT_THRESH_BINLOG_EPOCH_SLIP,
  OPT_NDB_REPORT_THRESH_BINLOG_MEM_USAGE,
4698
  OPT_NDB_USE_COPYING_ALTER_TABLE,
4699
  OPT_SKIP_SAFEMALLOC,
unknown's avatar
Merge  
unknown committed
4700
  OPT_TEMP_POOL, OPT_TX_ISOLATION, OPT_COMPLETION_TYPE,
4701 4702 4703 4704
  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,
4705
  OPT_DO_PSTACK, OPT_EVENT_SCHEDULER, OPT_REPORT_HOST,
4706
  OPT_REPORT_USER, OPT_REPORT_PASSWORD, OPT_REPORT_PORT,
4707
  OPT_SHOW_SLAVE_AUTH_INFO,
4708 4709 4710 4711 4712 4713 4714 4715 4716
  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,
  OPT_BACK_LOG, OPT_BINLOG_CACHE_SIZE,
  OPT_CONNECT_TIMEOUT, OPT_DELAYED_INSERT_TIMEOUT,
  OPT_DELAYED_INSERT_LIMIT, OPT_DELAYED_QUEUE_SIZE,
unknown's avatar
unknown committed
4717
  OPT_FLUSH_TIME, OPT_FT_MIN_WORD_LEN, OPT_FT_BOOLEAN_SYNTAX,
4718
  OPT_FT_MAX_WORD_LEN, OPT_FT_QUERY_EXPANSION_LIMIT, OPT_FT_STOPWORD_FILE,
4719
  OPT_INTERACTIVE_TIMEOUT, OPT_JOIN_BUFF_SIZE,
4720 4721 4722
  OPT_KEY_BUFFER_SIZE, OPT_KEY_CACHE_BLOCK_SIZE,
  OPT_KEY_CACHE_DIVISION_LIMIT, OPT_KEY_CACHE_AGE_THRESHOLD,
  OPT_LONG_QUERY_TIME,
4723 4724 4725 4726
  OPT_LOWER_CASE_TABLE_NAMES, OPT_MAX_ALLOWED_PACKET,
  OPT_MAX_BINLOG_CACHE_SIZE, OPT_MAX_BINLOG_SIZE,
  OPT_MAX_CONNECTIONS, OPT_MAX_CONNECT_ERRORS,
  OPT_MAX_DELAYED_THREADS, OPT_MAX_HEP_TABLE_SIZE,
4727 4728
  OPT_MAX_JOIN_SIZE, OPT_MAX_PREPARED_STMT_COUNT,
  OPT_MAX_RELAY_LOG_SIZE, OPT_MAX_SORT_LENGTH,
4729
  OPT_MAX_SEEKS_FOR_KEY, OPT_MAX_TMP_TABLES, OPT_MAX_USER_CONNECTIONS,
unknown's avatar
unknown committed
4730
  OPT_MAX_LENGTH_FOR_SORT_DATA,
unknown's avatar
unknown committed
4731
  OPT_MAX_WRITE_LOCK_COUNT, OPT_BULK_INSERT_BUFFER_SIZE,
unknown's avatar
Merge  
unknown committed
4732
  OPT_MAX_ERROR_COUNT, OPT_MULTI_RANGE_COUNT, OPT_MYISAM_DATA_POINTER_SIZE,
4733 4734
  OPT_MYISAM_BLOCK_SIZE, OPT_MYISAM_MAX_EXTRA_SORT_FILE_SIZE,
  OPT_MYISAM_MAX_SORT_FILE_SIZE, OPT_MYISAM_SORT_BUFFER_SIZE,
unknown's avatar
unknown committed
4735
  OPT_MYISAM_USE_MMAP,
4736
  OPT_MYISAM_STATS_METHOD,
4737 4738
  OPT_NET_BUFFER_LENGTH, OPT_NET_RETRY_COUNT,
  OPT_NET_READ_TIMEOUT, OPT_NET_WRITE_TIMEOUT,
4739
  OPT_OPEN_FILES_LIMIT,
unknown's avatar
unknown committed
4740
  OPT_PRELOAD_BUFFER_SIZE,
4741
  OPT_QUERY_CACHE_LIMIT, OPT_QUERY_CACHE_MIN_RES_UNIT, OPT_QUERY_CACHE_SIZE,
4742
  OPT_QUERY_CACHE_TYPE, OPT_QUERY_CACHE_WLOCK_INVALIDATE, OPT_RECORD_BUFFER,
unknown's avatar
unknown committed
4743 4744
  OPT_RECORD_RND_BUFFER, OPT_DIV_PRECINCREMENT, OPT_RELAY_LOG_SPACE_LIMIT,
  OPT_RELAY_LOG_PURGE,
4745
  OPT_SLAVE_NET_TIMEOUT, OPT_SLAVE_COMPRESSED_PROTOCOL, OPT_SLOW_LAUNCH_TIME,
4746
  OPT_SLAVE_TRANS_RETRIES, OPT_READONLY, OPT_DEBUGGING,
unknown's avatar
unknown committed
4747
  OPT_SORT_BUFFER, OPT_TABLE_OPEN_CACHE, OPT_TABLE_DEF_CACHE,
4748 4749
  OPT_THREAD_CONCURRENCY, OPT_THREAD_CACHE_SIZE,
  OPT_TMP_TABLE_SIZE, OPT_THREAD_STACK,
4750
  OPT_WAIT_TIMEOUT, OPT_MYISAM_REPAIR_THREADS,
4751 4752 4753 4754 4755
  OPT_INNODB_MIRRORED_LOG_GROUPS,
  OPT_INNODB_LOG_FILES_IN_GROUP,
  OPT_INNODB_LOG_FILE_SIZE,
  OPT_INNODB_LOG_BUFFER_SIZE,
  OPT_INNODB_BUFFER_POOL_SIZE,
unknown's avatar
unknown committed
4756
  OPT_INNODB_BUFFER_POOL_AWE_MEM_MB,
4757
  OPT_INNODB_ADDITIONAL_MEM_POOL_SIZE,
4758
  OPT_INNODB_MAX_PURGE_LAG,
4759 4760 4761
  OPT_INNODB_FILE_IO_THREADS,
  OPT_INNODB_LOCK_WAIT_TIMEOUT,
  OPT_INNODB_THREAD_CONCURRENCY,
4762
  OPT_INNODB_COMMIT_CONCURRENCY,
4763
  OPT_INNODB_FORCE_RECOVERY,
4764
  OPT_INNODB_STATUS_FILE,
4765
  OPT_INNODB_MAX_DIRTY_PAGES_PCT,
4766
  OPT_INNODB_TABLE_LOCKS,
4767
  OPT_INNODB_SUPPORT_XA,
unknown's avatar
unknown committed
4768
  OPT_INNODB_OPEN_FILES,
4769
  OPT_INNODB_AUTOEXTEND_INCREMENT,
unknown's avatar
Merge  
unknown committed
4770 4771 4772
  OPT_INNODB_SYNC_SPIN_LOOPS,
  OPT_INNODB_CONCURRENCY_TICKETS,
  OPT_INNODB_THREAD_SLEEP_DELAY,
4773
  OPT_BDB_CACHE_SIZE,
4774
  OPT_BDB_CACHE_PARTS,
4775
  OPT_BDB_LOG_BUFFER_SIZE,
4776
  OPT_BDB_MAX_LOCK,
4777
  OPT_BDB_REGION_SIZE,
unknown's avatar
merge  
unknown committed
4778
  OPT_ERROR_LOG_FILE,
4779
  OPT_DEFAULT_WEEK_FORMAT,
4780
  OPT_RANGE_ALLOC_BLOCK_SIZE, OPT_ALLOW_SUSPICIOUS_UDFS,
4781
  OPT_QUERY_ALLOC_BLOCK_SIZE, OPT_QUERY_PREALLOC_SIZE,
4782
  OPT_TRANS_ALLOC_BLOCK_SIZE, OPT_TRANS_PREALLOC_SIZE,
4783 4784 4785 4786 4787
  OPT_SYNC_FRM, OPT_SYNC_BINLOG,
  OPT_SYNC_REPLICATION,
  OPT_SYNC_REPLICATION_SLAVE_ID,
  OPT_SYNC_REPLICATION_TIMEOUT,
  OPT_BDB_NOSYNC,
4788
  OPT_ENABLE_SHARED_MEMORY,
unknown's avatar
unknown committed
4789
  OPT_SHARED_MEMORY_BASE_NAME,
4790
  OPT_OLD_PASSWORDS,
unknown's avatar
unknown committed
4791
  OPT_OLD_ALTER_TABLE,
unknown's avatar
unknown committed
4792
  OPT_EXPIRE_LOGS_DAYS,
4793
  OPT_GROUP_CONCAT_MAX_LEN,
4794
  OPT_DEFAULT_COLLATION,
4795
  OPT_CHARACTER_SET_CLIENT_HANDSHAKE,
unknown's avatar
unknown committed
4796
  OPT_CHARACTER_SET_FILESYSTEM,
unknown's avatar
unknown committed
4797
  OPT_INIT_CONNECT,
unknown's avatar
unknown committed
4798
  OPT_INIT_SLAVE,
4799
  OPT_SECURE_AUTH,
4800 4801
  OPT_DATE_FORMAT,
  OPT_TIME_FORMAT,
unknown's avatar
unknown committed
4802
  OPT_DATETIME_FORMAT,
4803
  OPT_LOG_QUERIES_NOT_USING_INDEXES,
unknown's avatar
Merge  
unknown committed
4804
  OPT_DEFAULT_TIME_ZONE,
4805
  OPT_SYSDATE_IS_NOW,
unknown's avatar
Merge  
unknown committed
4806 4807 4808 4809
  OPT_OPTIMIZER_SEARCH_DEPTH,
  OPT_OPTIMIZER_PRUNE_LEVEL,
  OPT_UPDATABLE_VIEWS_WITH_LIMIT,
  OPT_SP_AUTOMATIC_PRIVILEGES,
4810
  OPT_MAX_SP_RECURSION_DEPTH,
unknown's avatar
Merge  
unknown committed
4811 4812 4813
  OPT_AUTO_INCREMENT, OPT_AUTO_INCREMENT_OFFSET,
  OPT_ENABLE_LARGE_PAGES,
  OPT_TIMED_MUTEXES,
unknown's avatar
unknown committed
4814
  OPT_OLD_STYLE_USER_LIMITS,
4815
  OPT_LOG_SLOW_ADMIN_STATEMENTS,
4816
  OPT_TABLE_LOCK_WAIT_TIMEOUT,
4817
  OPT_PLUGIN_DIR,
4818
  OPT_LOG_OUTPUT,
4819
  OPT_PORT_OPEN_TIMEOUT
unknown's avatar
unknown committed
4820
};
4821

4822 4823 4824

#define LONG_TIMEOUT ((ulong) 3600L*24L*365L)

unknown's avatar
unknown committed
4825
struct my_option my_long_options[] =
4826
{
unknown's avatar
unknown committed
4827 4828 4829 4830 4831 4832 4833 4834 4835
  {"help", '?', "Display this help and exit.", 
   (gptr*) &opt_help, (gptr*) &opt_help, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
   0, 0},
#ifdef HAVE_REPLICATION
  {"abort-slave-event-count", OPT_ABORT_SLAVE_EVENT_COUNT,
   "Option used by mysql-test for debugging and testing of replication.",
   (gptr*) &abort_slave_event_count,  (gptr*) &abort_slave_event_count,
   0, GET_INT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
#endif /* HAVE_REPLICATION */
4836
  {"allow-suspicious-udfs", OPT_ALLOW_SUSPICIOUS_UDFS,
unknown's avatar
unknown committed
4837 4838
   "Allows use of UDFs consisting of only one symbol xxx() "
   "without corresponding xxx_init() or xxx_deinit(). That also means "
4839 4840 4841 4842
   "that one can load any function from any library, for example exit() "
   "from libc.so",
   (gptr*) &opt_allow_suspicious_udfs, (gptr*) &opt_allow_suspicious_udfs,
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
4843 4844
  {"ansi", 'a', "Use ANSI SQL syntax instead of MySQL syntax. This mode will also set transaction isolation level 'serializable'.", 0, 0, 0,
   GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
Merge  
unknown committed
4845 4846 4847 4848 4849 4850 4851 4852 4853 4854 4855 4856 4857 4858
  {"auto-increment-increment", OPT_AUTO_INCREMENT,
   "Auto-increment columns are incremented by this",
   (gptr*) &global_system_variables.auto_increment_increment,
   (gptr*) &max_system_variables.auto_increment_increment, 0, GET_ULONG,
   OPT_ARG, 1, 1, 65535, 0, 1, 0 },
  {"auto-increment-offset", OPT_AUTO_INCREMENT_OFFSET,
   "Offset added to Auto-increment columns. Used when auto-increment-increment != 1",
   (gptr*) &global_system_variables.auto_increment_offset,
   (gptr*) &max_system_variables.auto_increment_offset, 0, GET_ULONG, OPT_ARG,
   1, 1, 65535, 0, 1, 0 },
  {"automatic-sp-privileges", OPT_SP_AUTOMATIC_PRIVILEGES,
   "Creating and dropping stored procedures alters ACLs. Disable with --skip-automatic-sp-privileges.",
   (gptr*) &sp_automatic_privileges, (gptr*) &sp_automatic_privileges,
   0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0},
4859 4860 4861 4862
  {"basedir", 'b',
   "Path to installation directory. All paths are usually resolved relative to this.",
   (gptr*) &mysql_home_ptr, (gptr*) &mysql_home_ptr, 0, GET_STR, REQUIRED_ARG,
   0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
4863 4864
  {"bdb", OPT_BDB, "Enable Berkeley DB (if this version of MySQL supports it). \
Disable with --skip-bdb (will save memory).",
4865
   (gptr*) &opt_bdb, (gptr*) &opt_bdb, 0, GET_BOOL, NO_ARG, OPT_BDB_DEFAULT, 0, 0,
unknown's avatar
unknown committed
4866
   0, 0, 0},
4867
#ifdef WITH_BERKELEY_STORAGE_ENGINE
4868 4869 4870
  {"bdb-data-direct", OPT_BDB_DATA_DIRECT,
   "Turn off system buffering of BDB database files to avoid double caching.",
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
4871
  {"bdb-home", OPT_BDB_HOME, "Berkeley home directory.", (gptr*) &berkeley_home,
4872 4873
   (gptr*) &berkeley_home, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {"bdb-lock-detect", OPT_BDB_LOCK,
4874
   "Berkeley lock detect (DEFAULT, OLDEST, RANDOM or YOUNGEST, # sec).",
4875
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
4876 4877 4878
  {"bdb-log-direct", OPT_BDB_LOG_DIRECT,
   "Turn off system buffering of BDB log files to avoid double caching.",
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
4879 4880 4881
  {"bdb-logdir", OPT_BDB_LOG, "Berkeley DB log file directory.",
   (gptr*) &berkeley_logdir, (gptr*) &berkeley_logdir, 0, GET_STR,
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
4882
  {"bdb-no-recover", OPT_BDB_NO_RECOVER,
4883
   "Don't try to recover Berkeley DB tables on start.", 0, 0, 0, GET_NO_ARG,
4884
   NO_ARG, 0, 0, 0, 0, 0, 0},
4885
  {"bdb-no-sync", OPT_BDB_NOSYNC,
4886
   "This option is deprecated, use --skip-sync-bdb-logs instead",
4887
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
4888
  {"bdb-shared-data", OPT_BDB_SHARED,
4889
   "Start Berkeley DB in multi-process mode.", 0, 0, 0, GET_NO_ARG, NO_ARG, 0,
4890
   0, 0, 0, 0, 0},
4891
  {"bdb-tmpdir", OPT_BDB_TMP, "Berkeley DB tempfile name.",
4892 4893
   (gptr*) &berkeley_tmpdir, (gptr*) &berkeley_tmpdir, 0, GET_STR,
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
4894
#endif /* WITH_BERKELEY_STORAGE_ENGINE */
unknown's avatar
unknown committed
4895
  {"big-tables", OPT_BIG_TABLES,
4896
   "Allow big result sets by saving all temporary sets on file (Solves most 'table full' errors).",
4897
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
4898 4899 4900
  {"bind-address", OPT_BIND_ADDRESS, "IP address to bind to.",
   (gptr*) &my_bind_addr_str, (gptr*) &my_bind_addr_str, 0, GET_STR,
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
4901
  {"binlog_format", OPT_BINLOG_FORMAT,
4902 4903
#ifdef HAVE_ROW_BASED_REPLICATION
   "Tell the master the form of binary logging to use: either 'row' for "
4904 4905 4906 4907 4908
   "row-based binary logging, or 'statement' for statement-based binary "
   "logging, or 'mixed'. 'mixed' is statement-based binary logging except "
   "for those statements where only row-based is correct: those which "
   "involve user-defined functions (i.e. UDFs) or the UUID() function; for "
   "those, row-based binary logging is automatically used. "
unknown's avatar
unknown committed
4909
#ifdef HAVE_NDB_BINLOG
4910
   "If ndbcluster is enabled, the default is 'row'."
unknown's avatar
unknown committed
4911
#endif
4912
#else
4913
   "Tell the master the form of binary logging to use: this build "
4914
   "supports only statement-based binary logging, so only 'statement' is "
4915
   "a legal value."
4916
#endif
4917
   , 0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
4918 4919 4920
  {"binlog-do-db", OPT_BINLOG_DO_DB,
   "Tells the master it should log updates for the specified database, and exclude all others not explicitly mentioned.",
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
4921
  {"binlog-ignore-db", OPT_BINLOG_IGNORE_DB,
4922
   "Tells the master that updates to the given database should not be logged tothe binary log.",
4923
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
4924 4925 4926 4927 4928 4929 4930 4931 4932 4933 4934 4935 4936
#ifdef HAVE_ROW_BASED_REPLICATION
  {"binlog-row-event-max-size", OPT_BINLOG_ROWS_EVENT_MAX_SIZE,
   "The maximum size of a row-based binary log event in bytes. Rows will be "
   "grouped into events smaller than this size if possible. "
   "The value has to be a multiple of 256.",
   (gptr*) &opt_binlog_rows_event_max_size, 
   (gptr*) &opt_binlog_rows_event_max_size, 0, 
   GET_ULONG, REQUIRED_ARG, 
   /* def_value */ 1024, /* min_value */  256, /* max_value */ ULONG_MAX, 
   /* sub_size */     0, /* block_size */ 256, 
   /* app_type */ 0
  },
#endif
4937
  {"bootstrap", OPT_BOOTSTRAP, "Used by mysql installation scripts.", 0, 0, 0,
4938
   GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
4939
  {"character-set-client-handshake", OPT_CHARACTER_SET_CLIENT_HANDSHAKE,
unknown's avatar
unknown committed
4940
   "Don't ignore client side character set value sent during handshake.",
4941 4942 4943
   (gptr*) &opt_character_set_client_handshake,
   (gptr*) &opt_character_set_client_handshake,
    0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
4944 4945 4946 4947 4948
  {"character-set-filesystem", OPT_CHARACTER_SET_FILESYSTEM,
   "Set the filesystem character set.",
   (gptr*) &character_set_filesystem_name,
   (gptr*) &character_set_filesystem_name,
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
unknown's avatar
unknown committed
4949
  {"character-set-server", 'C', "Set the default character set.",
unknown's avatar
unknown committed
4950 4951
   (gptr*) &default_character_set_name, (gptr*) &default_character_set_name,
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
unknown's avatar
unknown committed
4952 4953 4954 4955 4956 4957 4958
  {"character-sets-dir", OPT_CHARSETS_DIR,
   "Directory where character sets are.", (gptr*) &charsets_dir,
   (gptr*) &charsets_dir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {"chroot", 'r', "Chroot mysqld daemon during startup.",
   (gptr*) &mysqld_chroot, (gptr*) &mysqld_chroot, 0, GET_STR, REQUIRED_ARG,
   0, 0, 0, 0, 0, 0},
  {"collation-server", OPT_DEFAULT_COLLATION, "Set the default collation.",
unknown's avatar
unknown committed
4959 4960
   (gptr*) &default_collation_name, (gptr*) &default_collation_name,
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
unknown's avatar
Merge  
unknown committed
4961 4962 4963 4964
  {"completion-type", OPT_COMPLETION_TYPE, "Default completion type.",
   (gptr*) &global_system_variables.completion_type,
   (gptr*) &max_system_variables.completion_type, 0, GET_ULONG,
   REQUIRED_ARG, 0, 0, 2, 0, 1, 0},
unknown's avatar
unknown committed
4965
  {"concurrent-insert", OPT_CONCURRENT_INSERT,
4966
   "Use concurrent insert with MyISAM. Disable with --concurrent-insert=0",
unknown's avatar
unknown committed
4967
   (gptr*) &myisam_concurrent_insert, (gptr*) &myisam_concurrent_insert,
4968
   0, GET_LONG, OPT_ARG, 1, 0, 2, 0, 0, 0},
4969
  {"console", OPT_CONSOLE, "Write error output on screen; Don't remove the console window on windows.",
4970 4971
   (gptr*) &opt_console, (gptr*) &opt_console, 0, GET_BOOL, NO_ARG, 0, 0, 0,
   0, 0, 0},
4972
  {"core-file", OPT_WANT_CORE, "Write core on errors.", 0, 0, 0, GET_NO_ARG,
4973
   NO_ARG, 0, 0, 0, 0, 0, 0},
4974
  {"datadir", 'h', "Path to the database root.", (gptr*) &mysql_data_home,
4975 4976 4977 4978 4979
   (gptr*) &mysql_data_home, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
#ifndef DBUG_OFF
  {"debug", '#', "Debug log.", (gptr*) &default_dbug_option,
   (gptr*) &default_dbug_option, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
#endif
unknown's avatar
unknown committed
4980
  {"default-character-set", 'C', "Set the default character set (deprecated option, use --character-set-server instead).",
4981
   (gptr*) &default_character_set_name, (gptr*) &default_character_set_name,
4982
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
unknown's avatar
unknown committed
4983
  {"default-collation", OPT_DEFAULT_COLLATION, "Set the default collation (deprecated option, use --collation-server instead).",
4984 4985
   (gptr*) &default_collation_name, (gptr*) &default_collation_name,
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
unknown's avatar
unknown committed
4986
  {"default-storage-engine", OPT_STORAGE_ENGINE,
unknown's avatar
unknown committed
4987 4988
   "Set the default storage engine (table type) for tables.",
   (gptr*)&default_storage_engine_str, (gptr*)&default_storage_engine_str,
unknown's avatar
unknown committed
4989 4990
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {"default-table-type", OPT_STORAGE_ENGINE,
unknown's avatar
unknown committed
4991
   "(deprecated) Use --default-storage-engine.",
unknown's avatar
unknown committed
4992
   (gptr*)&default_storage_engine_str, (gptr*)&default_storage_engine_str,
4993
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
4994 4995 4996
  {"default-time-zone", OPT_DEFAULT_TIME_ZONE, "Set the default time zone.",
   (gptr*) &default_tz_name, (gptr*) &default_tz_name,
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
4997
  {"delay-key-write", OPT_DELAY_KEY_WRITE, "Type of DELAY_KEY_WRITE.",
4998 4999
   0,0,0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
  {"delay-key-write-for-all-tables", OPT_DELAY_KEY_WRITE_ALL,
5000
   "Don't flush key buffers between writes for any MyISAM table (Deprecated option, use --delay-key-write=all instead).",
5001
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5002 5003 5004 5005 5006 5007 5008 5009 5010 5011 5012 5013 5014
#ifdef HAVE_OPENSSL
  {"des-key-file", OPT_DES_KEY_FILE,
   "Load keys for des_encrypt() and des_encrypt from given file.",
   (gptr*) &des_key_file, (gptr*) &des_key_file, 0, GET_STR, REQUIRED_ARG,
   0, 0, 0, 0, 0, 0},
#endif /* HAVE_OPENSSL */
#ifdef HAVE_REPLICATION
  {"disconnect-slave-event-count", OPT_DISCONNECT_SLAVE_EVENT_COUNT,
   "Option used by mysql-test for debugging and testing of replication.",
   (gptr*) &disconnect_slave_event_count,
   (gptr*) &disconnect_slave_event_count, 0, GET_INT, REQUIRED_ARG, 0, 0, 0,
   0, 0, 0},
#endif /* HAVE_REPLICATION */
5015
  {"enable-locking", OPT_ENABLE_LOCK,
5016
   "Deprecated option, use --external-locking instead.",
5017 5018
   (gptr*) &opt_external_locking, (gptr*) &opt_external_locking,
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
5019
#ifdef __NT__
5020
  {"enable-named-pipe", OPT_HAVE_NAMED_PIPE, "Enable the named pipe (NT).",
5021 5022 5023
   (gptr*) &opt_enable_named_pipe, (gptr*) &opt_enable_named_pipe, 0, GET_BOOL,
   NO_ARG, 0, 0, 0, 0, 0, 0},
#endif
5024
  {"enable-pstack", OPT_DO_PSTACK, "Print a symbolic stack trace on failure.",
5025 5026
   (gptr*) &opt_do_pstack, (gptr*) &opt_do_pstack, 0, GET_BOOL, NO_ARG, 0, 0,
   0, 0, 0, 0},
unknown's avatar
Merge  
unknown committed
5027 5028 5029 5030 5031 5032
  {"engine-condition-pushdown",
   OPT_ENGINE_CONDITION_PUSHDOWN,
   "Push supported query conditions to the storage engine.",
   (gptr*) &global_system_variables.engine_condition_pushdown,
   (gptr*) &global_system_variables.engine_condition_pushdown,
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
5033
  {"event-scheduler", OPT_EVENT_SCHEDULER, "Enable/disable the event scheduler.",
5034
   (gptr*) &Events::opt_event_scheduler, (gptr*) &Events::opt_event_scheduler, 0, GET_ULONG,
5035
    REQUIRED_ARG, 2/*default*/, 0/*min-value*/, 2/*max-value*/, 0, 0, 0},
5036 5037
  {"exit-info", 'T', "Used for debugging;  Use at your own risk!", 0, 0, 0,
   GET_LONG, OPT_ARG, 0, 0, 0, 0, 0, 0},
5038
  {"external-locking", OPT_USE_LOCKING, "Use system (external) locking (disabled by default).  With this option enabled you can run myisamchk to test (not repair) tables while the MySQL server is running. Disable with --skip-external-locking.",
unknown's avatar
unknown committed
5039 5040
   (gptr*) &opt_external_locking, (gptr*) &opt_external_locking,
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
5041
  {"flush", OPT_FLUSH, "Flush tables to disk between SQL commands.", 0, 0, 0,
5042 5043 5044
   GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  /* We must always support the next option to make scripts like mysqltest
     easier to do */
5045 5046 5047 5048
  {"gdb", OPT_DEBUGGING,
   "Set up signals usable for debugging",
   (gptr*) &opt_debugging, (gptr*) &opt_debugging,
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
Merge  
unknown committed
5049 5050 5051 5052 5053 5054
#ifdef HAVE_LARGE_PAGES
  {"large-pages", OPT_ENABLE_LARGE_PAGES, "Enable support for large pages. \
Disable with --skip-large-pages.",
   (gptr*) &opt_large_pages, (gptr*) &opt_large_pages, 0, GET_BOOL, NO_ARG, 0, 0, 0,
   0, 0, 0},
#endif
unknown's avatar
unknown committed
5055 5056 5057 5058 5059 5060
  {"init-connect", OPT_INIT_CONNECT, "Command(s) that are executed for each new connection",
   (gptr*) &opt_init_connect, (gptr*) &opt_init_connect, 0, GET_STR_ALLOC,
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {"init-file", OPT_INIT_FILE, "Read SQL commands from this file at startup.",
   (gptr*) &opt_init_file, (gptr*) &opt_init_file, 0, GET_STR, REQUIRED_ARG,
   0, 0, 0, 0, 0, 0},
5061
  {"init-rpl-role", OPT_INIT_RPL_ROLE, "Set the replication role.", 0, 0, 0,
5062
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5063 5064 5065 5066 5067
  {"init-slave", OPT_INIT_SLAVE, "Command(s) that are executed when a slave connects to this master",
   (gptr*) &opt_init_slave, (gptr*) &opt_init_slave, 0, GET_STR_ALLOC,
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {"innodb", OPT_INNODB, "Enable InnoDB (if this version of MySQL supports it). \
Disable with --skip-innodb (will save memory).",
5068
   (gptr*) &opt_innodb, (gptr*) &opt_innodb, 0, GET_BOOL, NO_ARG, OPT_INNODB_DEFAULT, 0, 0,
unknown's avatar
unknown committed
5069
   0, 0, 0},
5070
#ifdef WITH_INNOBASE_STORAGE_ENGINE
unknown's avatar
Merge  
unknown committed
5071 5072 5073
  {"innodb_checksums", OPT_INNODB_CHECKSUMS, "Enable InnoDB checksums validation (enabled by default). \
Disable with --skip-innodb-checksums.", (gptr*) &innobase_use_checksums,
   (gptr*) &innobase_use_checksums, 0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5074
#endif
5075
  {"innodb_data_file_path", OPT_INNODB_DATA_FILE_PATH,
5076
   "Path to individual files and their sizes.",
5077
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
5078
#ifdef WITH_INNOBASE_STORAGE_ENGINE
5079
  {"innodb_data_home_dir", OPT_INNODB_DATA_HOME_DIR,
unknown's avatar
unknown committed
5080
   "The common part for InnoDB table spaces.", (gptr*) &innobase_data_home_dir,
5081 5082
   (gptr*) &innobase_data_home_dir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0,
   0},
unknown's avatar
Merge  
unknown committed
5083 5084 5085
  {"innodb_doublewrite", OPT_INNODB_DOUBLEWRITE, "Enable InnoDB doublewrite buffer (enabled by default). \
Disable with --skip-innodb-doublewrite.", (gptr*) &innobase_use_doublewrite,
   (gptr*) &innobase_use_doublewrite, 0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5086
  {"innodb_fast_shutdown", OPT_INNODB_FAST_SHUTDOWN,
5087 5088 5089 5090 5091 5092 5093 5094 5095 5096 5097 5098
   "Speeds up the shutdown process of the InnoDB storage engine. Possible "
   "values are 0, 1 (faster)"
   /*
     NetWare can't close unclosed files, can't automatically kill remaining
     threads, etc, so on this OS we disable the crash-like InnoDB shutdown.
   */
#ifndef __NETWARE__
   " or 2 (fastest - crash-like)"
#endif
   ".",
   (gptr*) &innobase_fast_shutdown,
   (gptr*) &innobase_fast_shutdown, 0, GET_ULONG, OPT_ARG, 1, 0,
unknown's avatar
unknown committed
5099
   IF_NETWARE(1,2), 0, 0, 0},
unknown's avatar
unknown committed
5100 5101 5102 5103
  {"innodb_file_per_table", OPT_INNODB_FILE_PER_TABLE,
   "Stores each InnoDB table to an .ibd file in the database dir.",
   (gptr*) &innobase_file_per_table,
   (gptr*) &innobase_file_per_table, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
5104
  {"innodb_flush_log_at_trx_commit", OPT_INNODB_FLUSH_LOG_AT_TRX_COMMIT,
5105
   "Set to 0 (write and flush once per second), 1 (write and flush at each commit) or 2 (write at commit, flush once per second).",
5106 5107
   (gptr*) &innobase_flush_log_at_trx_commit,
   (gptr*) &innobase_flush_log_at_trx_commit,
5108
   0, GET_ULONG, OPT_ARG,  1, 0, 2, 0, 0, 0},
5109
  {"innodb_flush_method", OPT_INNODB_FLUSH_METHOD,
5110
   "With which method to flush data.", (gptr*) &innobase_unix_file_flush_method,
5111 5112
   (gptr*) &innobase_unix_file_flush_method, 0, GET_STR, REQUIRED_ARG, 0, 0, 0,
   0, 0, 0},
5113
  {"innodb_locks_unsafe_for_binlog", OPT_INNODB_LOCKS_UNSAFE_FOR_BINLOG,
5114
   "Force InnoDB to not use next-key locking, to use only row-level locking.",
5115 5116
   (gptr*) &innobase_locks_unsafe_for_binlog,
   (gptr*) &innobase_locks_unsafe_for_binlog, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5117 5118 5119 5120 5121
  {"innodb_log_arch_dir", OPT_INNODB_LOG_ARCH_DIR,
   "Where full logs should be archived.", (gptr*) &innobase_log_arch_dir,
   (gptr*) &innobase_log_arch_dir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {"innodb_log_archive", OPT_INNODB_LOG_ARCHIVE,
   "Set to 1 if you want to have logs archived.", 0, 0, 0, GET_LONG, OPT_ARG,
5122
   0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5123 5124 5125 5126 5127 5128 5129
  {"innodb_log_group_home_dir", OPT_INNODB_LOG_GROUP_HOME_DIR,
   "Path to InnoDB log files.", (gptr*) &innobase_log_group_home_dir,
   (gptr*) &innobase_log_group_home_dir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0,
   0, 0},
  {"innodb_max_dirty_pages_pct", OPT_INNODB_MAX_DIRTY_PAGES_PCT,
   "Percentage of dirty pages allowed in bufferpool.", (gptr*) &srv_max_buf_pool_modified_pct,
   (gptr*) &srv_max_buf_pool_modified_pct, 0, GET_ULONG, REQUIRED_ARG, 90, 0, 100, 0, 0, 0},
5130
  {"innodb_max_purge_lag", OPT_INNODB_MAX_PURGE_LAG,
unknown's avatar
unknown committed
5131
   "Desired maximum length of the purge queue (0 = no limit)",
5132 5133 5134
   (gptr*) &srv_max_purge_lag,
   (gptr*) &srv_max_purge_lag, 0, GET_LONG, REQUIRED_ARG, 0, 0, ~0L,
   0, 1L, 0},
5135 5136 5137 5138
  {"innodb_status_file", OPT_INNODB_STATUS_FILE,
   "Enable SHOW INNODB STATUS output in the innodb_status.<pid> file",
   (gptr*) &innobase_create_status_file, (gptr*) &innobase_create_status_file,
   0, GET_BOOL, OPT_ARG, 0, 0, 0, 0, 0, 0},
5139 5140 5141 5142 5143
  {"innodb_support_xa", OPT_INNODB_SUPPORT_XA,
   "Enable InnoDB support for the XA two-phase commit",
   (gptr*) &global_system_variables.innodb_support_xa,
   (gptr*) &global_system_variables.innodb_support_xa,
   0, GET_BOOL, OPT_ARG, 1, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5144 5145 5146 5147 5148
  {"innodb_table_locks", OPT_INNODB_TABLE_LOCKS,
   "Enable InnoDB locking in LOCK TABLES",
   (gptr*) &global_system_variables.innodb_table_locks,
   (gptr*) &global_system_variables.innodb_table_locks,
   0, GET_BOOL, OPT_ARG, 1, 0, 0, 0, 0, 0},
5149
#endif /* End WITH_INNOBASE_STORAGE_ENGINE */
5150 5151
  {"isam", OPT_ISAM, "Obsolete. ISAM storage engine is no longer supported.",
   (gptr*) &opt_isam, (gptr*) &opt_isam, 0, GET_BOOL, NO_ARG, 0, 0, 0,
unknown's avatar
unknown committed
5152
   0, 0, 0},
unknown's avatar
unknown committed
5153
   {"language", 'L',
5154
   "Client error messages in given language. May be given as a full path.",
5155 5156 5157
   (gptr*) &language_ptr, (gptr*) &language_ptr, 0, GET_STR, REQUIRED_ARG,
   0, 0, 0, 0, 0, 0},
  {"local-infile", OPT_LOCAL_INFILE,
5158
   "Enable/disable LOAD DATA LOCAL INFILE (takes values 1|0).",
unknown's avatar
unknown committed
5159 5160
   (gptr*) &opt_local_infile,
   (gptr*) &opt_local_infile, 0, GET_BOOL, OPT_ARG,
5161
   1, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5162 5163
  {"log", 'l', "Log connections and queries to file.", (gptr*) &opt_logname,
   (gptr*) &opt_logname, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
5164
  {"log-bin", OPT_BIN_LOG,
unknown's avatar
Merge  
unknown committed
5165 5166 5167
   "Log update queries in binary format. Optional (but strongly recommended "
   "to avoid replication problems if server's hostname changes) argument "
   "should be the chosen location for the binary log files.",
5168
   (gptr*) &opt_bin_logname, (gptr*) &opt_bin_logname, 0, GET_STR_ALLOC,
unknown's avatar
unknown committed
5169
   OPT_ARG, 0, 0, 0, 0, 0, 0},
5170
  {"log-bin-index", OPT_BIN_LOG_INDEX,
5171
   "File that holds the names for last binary log files.",
5172 5173
   (gptr*) &opt_binlog_index_name, (gptr*) &opt_binlog_index_name, 0, GET_STR,
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
5174 5175 5176 5177 5178 5179 5180 5181 5182 5183 5184 5185
#ifndef TO_BE_REMOVED_IN_5_1_OR_6_0
  /*
    In 5.0.6 we introduced the below option, then in 5.0.16 we renamed it to
    log-bin-trust-function-creators but kept also the old name for
    compatibility; the behaviour was also changed to apply only to functions
    (and triggers). In a future release this old name could be removed.
  */
  {"log-bin-trust-routine-creators", OPT_LOG_BIN_TRUST_FUNCTION_CREATORS,
   "(deprecated) Use log-bin-trust-function-creators.",
   (gptr*) &trust_function_creators, (gptr*) &trust_function_creators, 0,
   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
#endif
5186 5187
  /*
    This option starts with "log-bin" to emphasize that it is specific of
5188
    binary logging.
5189
  */
5190
  {"log-bin-trust-function-creators", OPT_LOG_BIN_TRUST_FUNCTION_CREATORS,
5191
   "If equal to 0 (the default), then when --log-bin is used, creation of "
5192 5193
   "a stored function (or trigger) is allowed only to users having the SUPER privilege "
   "and only if this stored function (trigger) may not break binary logging."
5194
#ifdef HAVE_ROW_BASED_REPLICATION
5195 5196 5197
   "Note that if ALL connections to this server ALWAYS use row-based binary "
   "logging, the security issues do not exist and the binary logging cannot "
   "break, so you can safely set this to 1."
5198 5199
#endif
   ,(gptr*) &trust_function_creators, (gptr*) &trust_function_creators, 0,
5200
   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
Merge  
unknown committed
5201
  {"log-error", OPT_ERROR_LOG_FILE, "Error log file.",
unknown's avatar
unknown committed
5202 5203
   (gptr*) &log_error_file_ptr, (gptr*) &log_error_file_ptr, 0, GET_STR,
   OPT_ARG, 0, 0, 0, 0, 0, 0},
5204
  {"log-isam", OPT_ISAM_LOG, "Log all MyISAM changes to file.",
5205 5206
   (gptr*) &myisam_log_filename, (gptr*) &myisam_log_filename, 0, GET_STR,
   OPT_ARG, 0, 0, 0, 0, 0, 0},
5207 5208 5209
  {"log-long-format", '0',
   "Log some extra information to update log. Please note that this option is deprecated; see --log-short-format option.", 
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
5210 5211
#ifdef WITH_CSV_STORAGE_ENGINE
  {"log-output", OPT_LOG_OUTPUT,
5212
   "Syntax: log-output[=value[,value...]], where \"value\" could be TABLE, "
5213 5214 5215 5216
   "FILE or NONE.",
   (gptr*) &log_output_str, (gptr*) &log_output_str, 0,
   GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
#endif
5217
  {"log-queries-not-using-indexes", OPT_LOG_QUERIES_NOT_USING_INDEXES,
5218
   "Log queries that are executed without benefit of any index to the slow log if it is open.",
5219 5220
   (gptr*) &opt_log_queries_not_using_indexes, (gptr*) &opt_log_queries_not_using_indexes,
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5221 5222 5223 5224
  {"log-short-format", OPT_SHORT_LOG_FORMAT,
   "Don't log extra information to update and slow-query logs.",
   (gptr*) &opt_short_log_format, (gptr*) &opt_short_log_format,
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
5225
  {"log-slave-updates", OPT_LOG_SLAVE_UPDATES,
unknown's avatar
unknown committed
5226
   "Tells the slave to log the updates from the slave thread to the binary log. You will need to turn it on if you plan to daisy-chain the slaves.",
5227 5228
   (gptr*) &opt_log_slave_updates, (gptr*) &opt_log_slave_updates, 0, GET_BOOL,
   NO_ARG, 0, 0, 0, 0, 0, 0},
5229 5230 5231 5232 5233
  {"log-slow-admin-statements", OPT_LOG_SLOW_ADMIN_STATEMENTS,
   "Log slow OPTIMIZE, ANALYZE, ALTER and other administrative statements to the slow log if it is open.",
   (gptr*) &opt_log_slow_admin_statements,
   (gptr*) &opt_log_slow_admin_statements,
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5234
  {"log-slow-queries", OPT_SLOW_QUERY_LOG,
5235
    "Log slow queries to this log file. Defaults logging to hostname-slow.log file. Must be enabled to activate other slow log options.",
unknown's avatar
unknown committed
5236 5237
   (gptr*) &opt_slow_logname, (gptr*) &opt_slow_logname, 0, GET_STR, OPT_ARG,
   0, 0, 0, 0, 0, 0},
unknown's avatar
Merge  
unknown committed
5238 5239 5240 5241 5242
  {"log-tc", OPT_LOG_TC,
   "Path to transaction coordinator log (used for transactions that affect "
   "more than one storage engine, when binary log is disabled)",
   (gptr*) &opt_tc_log_file, (gptr*) &opt_tc_log_file, 0, GET_STR,
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
5243
#ifdef HAVE_MMAP
unknown's avatar
Merge  
unknown committed
5244 5245 5246
  {"log-tc-size", OPT_LOG_TC_SIZE, "Size of transaction coordinator log.",
   (gptr*) &opt_tc_log_size, (gptr*) &opt_tc_log_size, 0, GET_ULONG,
   REQUIRED_ARG, TC_LOG_MIN_SIZE, TC_LOG_MIN_SIZE, ~0L, 0, TC_LOG_PAGE_SIZE, 0},
5247
#endif
unknown's avatar
unknown committed
5248
  {"log-update", OPT_UPDATE_LOG,
unknown's avatar
Merge  
unknown committed
5249 5250
   "The update log is deprecated since version 5.0, is replaced by the binary \
log and this option justs turns on --log-bin instead.",
unknown's avatar
unknown committed
5251 5252
   (gptr*) &opt_update_logname, (gptr*) &opt_update_logname, 0, GET_STR,
   OPT_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
Merge  
unknown committed
5253
  {"log-warnings", 'W', "Log some not critical warnings to the log file.",
unknown's avatar
unknown committed
5254
   (gptr*) &global_system_variables.log_warnings,
unknown's avatar
Merge  
unknown committed
5255
   (gptr*) &max_system_variables.log_warnings, 0, GET_ULONG, OPT_ARG, 1, 0, 0,
unknown's avatar
unknown committed
5256
   0, 0, 0},
5257
  {"low-priority-updates", OPT_LOW_PRIORITY_UPDATES,
5258
   "INSERT/DELETE/UPDATE has lower priority than selects.",
unknown's avatar
unknown committed
5259 5260 5261
   (gptr*) &global_system_variables.low_priority_updates,
   (gptr*) &max_system_variables.low_priority_updates,
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5262 5263 5264 5265
  {"master-connect-retry", OPT_MASTER_CONNECT_RETRY,
   "The number of seconds the slave thread will sleep before retrying to connect to the master in case the master goes down or the connection is lost.",
   (gptr*) &master_connect_retry, (gptr*) &master_connect_retry, 0, GET_UINT,
   REQUIRED_ARG, 60, 0, 0, 0, 0, 0},
5266
  {"master-host", OPT_MASTER_HOST,
5267 5268 5269
   "Master hostname or IP address for replication. If not set, the slave thread will not be started. Note that the setting of master-host will be ignored if there exists a valid master.info file.",
   (gptr*) &master_host, (gptr*) &master_host, 0, GET_STR, REQUIRED_ARG, 0, 0,
   0, 0, 0, 0},
unknown's avatar
unknown committed
5270 5271 5272 5273 5274
  {"master-info-file", OPT_MASTER_INFO_FILE,
   "The location and name of the file that remembers the master and where the I/O replication \
thread is in the master's binlogs.",
   (gptr*) &master_info_file, (gptr*) &master_info_file, 0, GET_STR,
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
5275 5276
  {"master-password", OPT_MASTER_PASSWORD,
   "The password the slave thread will authenticate with when connecting to the master. If not set, an empty password is assumed.The value in master.info will take precedence if it can be read.",
unknown's avatar
unknown committed
5277 5278
   (gptr*)&master_password, (gptr*)&master_password, 0,
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
5279
  {"master-port", OPT_MASTER_PORT,
5280
   "The port the master is listening on. If not set, the compiled setting of MYSQL_PORT is assumed. If you have not tinkered with configure options, this should be 3306. The value in master.info will take precedence if it can be read.",
5281 5282 5283 5284 5285
   (gptr*) &master_port, (gptr*) &master_port, 0, GET_UINT, REQUIRED_ARG,
   MYSQL_PORT, 0, 0, 0, 0, 0},
  {"master-retry-count", OPT_MASTER_RETRY_COUNT,
   "The number of tries the slave will make to connect to the master before giving up.",
   (gptr*) &master_retry_count, (gptr*) &master_retry_count, 0, GET_ULONG,
5286
   REQUIRED_ARG, 3600*24, 0, 0, 0, 0, 0},
5287
  {"master-ssl", OPT_MASTER_SSL,
unknown's avatar
unknown committed
5288
   "Enable the slave to connect to the master using SSL.",
5289 5290
   (gptr*) &master_ssl, (gptr*) &master_ssl, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
   0, 0},
unknown's avatar
unknown committed
5291 5292 5293 5294
  {"master-ssl-ca", OPT_MASTER_SSL_CA,
   "Master SSL CA file. Only applies if you have enabled master-ssl.",
   (gptr*) &master_ssl_ca, (gptr*) &master_ssl_ca, 0, GET_STR, OPT_ARG,
   0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5295
  {"master-ssl-capath", OPT_MASTER_SSL_CAPATH,
unknown's avatar
unknown committed
5296
   "Master SSL CA path. Only applies if you have enabled master-ssl.",
unknown's avatar
unknown committed
5297 5298
   (gptr*) &master_ssl_capath, (gptr*) &master_ssl_capath, 0, GET_STR, OPT_ARG,
   0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5299 5300 5301 5302 5303
  {"master-ssl-cert", OPT_MASTER_SSL_CERT,
   "Master SSL certificate file name. Only applies if you have enabled \
master-ssl",
   (gptr*) &master_ssl_cert, (gptr*) &master_ssl_cert, 0, GET_STR, OPT_ARG,
   0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5304
  {"master-ssl-cipher", OPT_MASTER_SSL_CIPHER,
unknown's avatar
unknown committed
5305
   "Master SSL cipher. Only applies if you have enabled master-ssl.",
unknown's avatar
unknown committed
5306
   (gptr*) &master_ssl_cipher, (gptr*) &master_ssl_capath, 0, GET_STR, OPT_ARG,
5307
   0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5308 5309 5310 5311 5312 5313 5314 5315
  {"master-ssl-key", OPT_MASTER_SSL_KEY,
   "Master SSL keyfile name. Only applies if you have enabled master-ssl.",
   (gptr*) &master_ssl_key, (gptr*) &master_ssl_key, 0, GET_STR, OPT_ARG,
   0, 0, 0, 0, 0, 0},
  {"master-user", OPT_MASTER_USER,
   "The username the slave thread will use for authentication when connecting to the master. The user must have FILE privilege. If the master user is not set, user test is assumed. The value in master.info will take precedence if it can be read.",
   (gptr*) &master_user, (gptr*) &master_user, 0, GET_STR, REQUIRED_ARG, 0, 0,
   0, 0, 0, 0},
unknown's avatar
SCRUM  
unknown committed
5316
#ifdef HAVE_REPLICATION
5317
  {"max-binlog-dump-events", OPT_MAX_BINLOG_DUMP_EVENTS,
5318
   "Option used by mysql-test for debugging and testing of replication.",
5319 5320
   (gptr*) &max_binlog_dump_events, (gptr*) &max_binlog_dump_events, 0,
   GET_INT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
SCRUM  
unknown committed
5321
#endif /* HAVE_REPLICATION */
unknown's avatar
unknown committed
5322 5323 5324 5325 5326 5327 5328 5329
  {"memlock", OPT_MEMLOCK, "Lock mysqld in memory.", (gptr*) &locked_in_memory,
   (gptr*) &locked_in_memory, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
  {"myisam-recover", OPT_MYISAM_RECOVER,
   "Syntax: myisam-recover[=option[,option...]], where option can be DEFAULT, BACKUP, FORCE or QUICK.",
   (gptr*) &myisam_recover_options_str, (gptr*) &myisam_recover_options_str, 0,
   GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
  {"ndbcluster", OPT_NDBCLUSTER, "Enable NDB Cluster (if this version of MySQL supports it). \
Disable with --skip-ndbcluster (will save memory).",
5330 5331
   (gptr*) &opt_ndbcluster, (gptr*) &opt_ndbcluster, 0, GET_BOOL, NO_ARG,
   OPT_NDBCLUSTER_DEFAULT, 0, 0, 0, 0, 0},
5332
#ifdef WITH_NDBCLUSTER_STORAGE_ENGINE
5333 5334
  {"ndb-connectstring", OPT_NDB_CONNECTSTRING,
   "Connect string for ndbcluster.",
unknown's avatar
Merge  
unknown committed
5335 5336 5337 5338 5339 5340 5341
   (gptr*) &opt_ndb_connectstring,
   (gptr*) &opt_ndb_connectstring,
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {"ndb-mgmd-host", OPT_NDB_MGMD,
   "Set host and port for ndb_mgmd. Syntax: hostname[:port]",
   (gptr*) &opt_ndb_mgmd,
   (gptr*) &opt_ndb_mgmd,
5342
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
Merge  
unknown committed
5343 5344 5345 5346 5347
  {"ndb-nodeid", OPT_NDB_NODEID,
   "Nodeid for this mysqlserver in the cluster.",
   (gptr*) &opt_ndb_nodeid,
   (gptr*) &opt_ndb_nodeid,
   0, GET_INT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
5348 5349
  {"ndb-autoincrement-prefetch-sz", OPT_NDB_AUTOINCREMENT_PREFETCH_SZ,
   "Specify number of autoincrement values that are prefetched.",
5350 5351
   (gptr*) &global_system_variables.ndb_autoincrement_prefetch_sz,
   (gptr*) &global_system_variables.ndb_autoincrement_prefetch_sz,
5352
   0, GET_ULONG, REQUIRED_ARG, 32, 1, 256, 0, 0, 0},
unknown's avatar
unknown committed
5353
  {"ndb-distribution", OPT_NDB_DISTRIBUTION,
5354 5355 5356 5357
   "Default distribution for new tables in ndb",
   (gptr*) &opt_ndb_distribution,
   (gptr*) &opt_ndb_distribution,
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
5358 5359 5360 5361 5362 5363
  {"ndb-force-send", OPT_NDB_FORCE_SEND,
   "Force send of buffers to ndb immediately without waiting for "
   "other threads.",
   (gptr*) &global_system_variables.ndb_force_send,
   (gptr*) &global_system_variables.ndb_force_send,
   0, GET_BOOL, OPT_ARG, 1, 0, 0, 0, 0, 0},
5364
  {"ndb_force_send", OPT_NDB_FORCE_SEND,
5365
   "same as --ndb-force-send.",
5366 5367 5368
   (gptr*) &global_system_variables.ndb_force_send,
   (gptr*) &global_system_variables.ndb_force_send,
   0, GET_BOOL, OPT_ARG, 1, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5369 5370 5371 5372 5373 5374 5375 5376 5377 5378 5379 5380 5381 5382 5383 5384 5385 5386 5387 5388 5389 5390 5391
  {"ndb-extra-logging", OPT_NDB_EXTRA_LOGGING,
   "Turn on more logging in the error log.",
   (gptr*) &ndb_extra_logging,
   (gptr*) &ndb_extra_logging,
   0, GET_INT, OPT_ARG, 0, 0, 0, 0, 0, 0},
#ifdef HAVE_NDB_BINLOG
  {"ndb-report-thresh-binlog-epoch-slip", OPT_NDB_REPORT_THRESH_BINLOG_EPOCH_SLIP,
   "Threshold on number of epochs to be behind before reporting binlog status. "
   "E.g. 3 means that if the difference between what epoch has been received "
   "from the storage nodes and what has been applied to the binlog is 3 or more, "
   "a status message will be sent to the cluster log.",
   (gptr*) &ndb_report_thresh_binlog_epoch_slip,
   (gptr*) &ndb_report_thresh_binlog_epoch_slip,
   0, GET_ULONG, REQUIRED_ARG, 3, 0, 256, 0, 0, 0},
  {"ndb-report-thresh-binlog-mem-usage", OPT_NDB_REPORT_THRESH_BINLOG_MEM_USAGE,
   "Threshold on percentage of free memory before reporting binlog status. E.g. "
   "10 means that if amount of available memory for receiving binlog data from "
   "the storage nodes goes below 10%, "
   "a status message will be sent to the cluster log.",
   (gptr*) &ndb_report_thresh_binlog_mem_usage,
   (gptr*) &ndb_report_thresh_binlog_mem_usage,
   0, GET_ULONG, REQUIRED_ARG, 10, 0, 100, 0, 0, 0},
#endif
5392 5393 5394 5395 5396 5397
  {"ndb-use-exact-count", OPT_NDB_USE_EXACT_COUNT,
   "Use exact records count during query planning and for fast "
   "select count(*), disable for faster queries.",
   (gptr*) &global_system_variables.ndb_use_exact_count,
   (gptr*) &global_system_variables.ndb_use_exact_count,
   0, GET_BOOL, OPT_ARG, 1, 0, 0, 0, 0, 0},
5398
  {"ndb_use_exact_count", OPT_NDB_USE_EXACT_COUNT,
5399
   "same as --ndb-use-exact-count.",
5400 5401 5402
   (gptr*) &global_system_variables.ndb_use_exact_count,
   (gptr*) &global_system_variables.ndb_use_exact_count,
   0, GET_BOOL, OPT_ARG, 1, 0, 0, 0, 0, 0},
5403 5404 5405 5406 5407 5408 5409 5410 5411 5412
  {"ndb-shm", OPT_NDB_SHM,
   "Use shared memory connections when available.",
   (gptr*) &opt_ndb_shm,
   (gptr*) &opt_ndb_shm,
   0, GET_BOOL, OPT_ARG, OPT_NDB_SHM_DEFAULT, 0, 0, 0, 0, 0},
  {"ndb-optimized-node-selection", OPT_NDB_OPTIMIZED_NODE_SELECTION,
   "Select nodes for transactions in a more optimal way.",
   (gptr*) &opt_ndb_optimized_node_selection,
   (gptr*) &opt_ndb_optimized_node_selection,
   0, GET_BOOL, OPT_ARG, 1, 0, 0, 0, 0, 0},
unknown's avatar
Merge  
unknown committed
5413 5414 5415 5416
  { "ndb-cache-check-time", OPT_NDB_CACHE_CHECK_TIME,
    "A dedicated thread is created to, at the given millisecons interval, invalidate the query cache if another MySQL server in the cluster has changed the data in the database.",
    (gptr*) &opt_ndb_cache_check_time, (gptr*) &opt_ndb_cache_check_time, 0, GET_ULONG, REQUIRED_ARG,
    0, 0, LONG_TIMEOUT, 0, 1, 0},
5417 5418 5419 5420 5421 5422 5423 5424 5425 5426 5427 5428 5429 5430 5431 5432 5433
  {"ndb-index-stat-enable", OPT_NDB_INDEX_STAT_ENABLE,
   "Use ndb index statistics in query optimization.",
   (gptr*) &global_system_variables.ndb_index_stat_enable,
   (gptr*) &max_system_variables.ndb_index_stat_enable,
   0, GET_BOOL, OPT_ARG, 1, 0, 1, 0, 0, 0},
  {"ndb-index-stat-cache-entries", OPT_NDB_INDEX_STAT_CACHE_ENTRIES,
   "Number of start/end keys to store in statistics memory cache."
    " Zero means no cache and forces query of db nodes always.",
   (gptr*) &global_system_variables.ndb_index_stat_cache_entries,
   (gptr*) &max_system_variables.ndb_index_stat_cache_entries,
   0, GET_ULONG, OPT_ARG, 32, 0, ~0L, 0, 0, 0},
  {"ndb-index-stat-update-freq", OPT_NDB_INDEX_STAT_UPDATE_FREQ,
   "How often, in the long run, to query db nodes instead of statistics cache."
   " For example 20 means every 20th time.",
   (gptr*) &global_system_variables.ndb_index_stat_update_freq,
   (gptr*) &max_system_variables.ndb_index_stat_update_freq,
   0, GET_ULONG, OPT_ARG, 20, 0, ~0L, 0, 0, 0},
5434
#endif
unknown's avatar
unknown committed
5435
  {"ndb-use-copying-alter-table",
5436
   OPT_NDB_USE_COPYING_ALTER_TABLE,
unknown's avatar
unknown committed
5437
   "Force ndbcluster to always copy tables at alter table (should only be used if on-line alter table fails).",
5438 5439 5440
   (gptr*) &global_system_variables.ndb_use_copying_alter_table,
   (gptr*) &global_system_variables.ndb_use_copying_alter_table,
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},  
5441
  {"new", 'n', "Use very new possible 'unsafe' functions.",
5442 5443 5444
   (gptr*) &global_system_variables.new_mode,
   (gptr*) &max_system_variables.new_mode,
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5445
#ifdef NOT_YET
5446
  {"no-mix-table-types", OPT_NO_MIX_TYPE, "Don't allow commands with uses two different table types.",
5447 5448 5449
   (gptr*) &opt_no_mix_types, (gptr*) &opt_no_mix_types, 0, GET_BOOL, NO_ARG,
   0, 0, 0, 0, 0, 0},
#endif
unknown's avatar
unknown committed
5450 5451 5452 5453 5454
  {"old-alter-table", OPT_OLD_ALTER_TABLE,
   "Use old, non-optimized alter table.",
   (gptr*) &global_system_variables.old_alter_table,
   (gptr*) &max_system_variables.old_alter_table, 0, GET_BOOL, NO_ARG,
   0, 0, 0, 0, 0, 0},
5455 5456 5457 5458
  {"old-passwords", OPT_OLD_PASSWORDS, "Use old password encryption method (needed for 4.0 and older clients).",
   (gptr*) &global_system_variables.old_passwords,
   (gptr*) &max_system_variables.old_passwords, 0, GET_BOOL, NO_ARG,
   0, 0, 0, 0, 0, 0},
5459
#ifdef ONE_THREAD
5460
  {"one-thread", OPT_ONE_THREAD,
5461
   "Only use one thread (for debugging under Linux).", 0, 0, 0, GET_NO_ARG,
5462 5463
   NO_ARG, 0, 0, 0, 0, 0, 0},
#endif
unknown's avatar
Merge  
unknown committed
5464 5465 5466 5467
  {"old-style-user-limits", OPT_OLD_STYLE_USER_LIMITS,
   "Enable old-style user limits (before 5.0.3 user resources were counted per each user+host vs. per account)",
   (gptr*) &opt_old_style_user_limits, (gptr*) &opt_old_style_user_limits,
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
5468
  {"pid-file", OPT_PID_FILE, "Pid file used by safe_mysqld.",
5469 5470
   (gptr*) &pidfile_name_ptr, (gptr*) &pidfile_name_ptr, 0, GET_STR,
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
5471 5472
  {"port", 'P', "Port number to use for connection.", (gptr*) &mysqld_port,
   (gptr*) &mysqld_port, 0, GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
5473 5474 5475 5476
  {"port-open-timeout", OPT_PORT_OPEN_TIMEOUT,
   "Maximum time in seconds to wait for the port to become free. "
   "(Default: no wait)", (gptr*) &mysqld_port_timeout,
   (gptr*) &mysqld_port_timeout, 0, GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5477 5478 5479 5480 5481 5482 5483 5484 5485 5486 5487 5488 5489 5490
  {"relay-log", OPT_RELAY_LOG,
   "The location and name to use for relay logs.",
   (gptr*) &opt_relay_logname, (gptr*) &opt_relay_logname, 0,
   GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {"relay-log-index", OPT_RELAY_LOG_INDEX,
   "The location and name to use for the file that keeps a list of the last \
relay logs.",
   (gptr*) &opt_relaylog_index_name, (gptr*) &opt_relaylog_index_name, 0,
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {"relay-log-info-file", OPT_RELAY_LOG_INFO_FILE,
   "The location and name of the file that remembers where the SQL replication \
thread is in the relay logs.",
   (gptr*) &relay_log_info_file, (gptr*) &relay_log_info_file, 0, GET_STR,
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
5491 5492 5493 5494 5495 5496 5497 5498 5499 5500 5501 5502 5503
  {"replicate-do-db", OPT_REPLICATE_DO_DB,
   "Tells the slave thread to restrict replication to the specified database. To specify more than one database, use the directive multiple times, once for each database. Note that this will only work if you do not use cross-database queries such as UPDATE some_db.some_table SET foo='bar' while having selected a different or no database. If you need cross database updates to work, make sure you have 3.23.28 or later, and use replicate-wild-do-table=db_name.%.",
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {"replicate-do-table", OPT_REPLICATE_DO_TABLE,
   "Tells the slave thread to restrict replication to the specified table. To specify more than one table, use the directive multiple times, once for each table. This will work for cross-database updates, in contrast to replicate-do-db.",
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {"replicate-ignore-db", OPT_REPLICATE_IGNORE_DB,
   "Tells the slave thread to not replicate to the specified database. To specify more than one database to ignore, use the directive multiple times, once for each database. This option will not work if you use cross database updates. If you need cross database updates to work, make sure you have 3.23.28 or later, and use replicate-wild-ignore-table=db_name.%. ",
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {"replicate-ignore-table", OPT_REPLICATE_IGNORE_TABLE,
   "Tells the slave thread to not replicate to the specified table. To specify more than one table to ignore, use the directive multiple times, once for each table. This will work for cross-datbase updates, in contrast to replicate-ignore-db.",
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {"replicate-rewrite-db", OPT_REPLICATE_REWRITE_DB,
5504
   "Updates to a database with a different name than the original. Example: replicate-rewrite-db=master_db_name->slave_db_name.",
5505
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5506
#ifdef HAVE_REPLICATION
5507 5508 5509 5510 5511 5512 5513
  {"replicate-same-server-id", OPT_REPLICATE_SAME_SERVER_ID,
   "In replication, if set to 1, do not skip events having our server id. \
Default value is 0 (to break infinite loops in circular replication). \
Can't be set to 1 if --log-slave-updates is used.",
   (gptr*) &replicate_same_server_id,
   (gptr*) &replicate_same_server_id,
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5514
#endif
unknown's avatar
unknown committed
5515 5516 5517 5518 5519 5520
  {"replicate-wild-do-table", OPT_REPLICATE_WILD_DO_TABLE,
   "Tells the slave thread to restrict replication to the tables that match the specified wildcard pattern. To specify more than one table, use the directive multiple times, once for each table. This will work for cross-database updates. Example: replicate-wild-do-table=foo%.bar% will replicate only updates to tables in all databases that start with foo and whose table names start with bar.",
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {"replicate-wild-ignore-table", OPT_REPLICATE_WILD_IGNORE_TABLE,
   "Tells the slave thread to not replicate to the tables that match the given wildcard pattern. To specify more than one table to ignore, use the directive multiple times, once for each table. This will work for cross-database updates. Example: replicate-wild-ignore-table=foo%.bar% will not do updates to tables in databases that start with foo and whose table names start with bar.",
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
5521
  // In replication, we may need to tell the other servers how to connect
5522 5523 5524 5525
  {"report-host", OPT_REPORT_HOST,
   "Hostname or IP of the slave to be reported to to the master during slave registration. Will appear in the output of SHOW SLAVE HOSTS. Leave unset if you do not want the slave to register itself with the master. Note that it is not sufficient for the master to simply read the IP of the slave off the socket once the slave connects. Due to NAT and other routing issues, that IP may not be valid for connecting to the slave from the master or other hosts.",
   (gptr*) &report_host, (gptr*) &report_host, 0, GET_STR, REQUIRED_ARG, 0, 0,
   0, 0, 0, 0},
5526
  {"report-password", OPT_REPORT_PASSWORD, "Undocumented.",
5527 5528 5529 5530 5531 5532
   (gptr*) &report_password, (gptr*) &report_password, 0, GET_STR,
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {"report-port", OPT_REPORT_PORT,
   "Port for connecting to slave reported to the master during slave registration. Set it only if the slave is listening on a non-default port or if you have a special tunnel from the master or other clients to the slave. If not sure, leave this option unset.",
   (gptr*) &report_port, (gptr*) &report_port, 0, GET_UINT, REQUIRED_ARG,
   MYSQL_PORT, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5533 5534
  {"report-user", OPT_REPORT_USER, "Undocumented.", (gptr*) &report_user,
   (gptr*) &report_user, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
5535
  {"rpl-recovery-rank", OPT_RPL_RECOVERY_RANK, "Undocumented.",
5536
   (gptr*) &rpl_recovery_rank, (gptr*) &rpl_recovery_rank, 0, GET_ULONG,
5537 5538 5539
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {"safe-mode", OPT_SAFE, "Skip some optimize stages (for testing).",
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5540
#ifndef TO_BE_DELETED
5541
  {"safe-show-database", OPT_SAFE_SHOW_DB,
unknown's avatar
unknown committed
5542
   "Deprecated option; use GRANT SHOW DATABASES instead...",
5543
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5544
#endif
5545
  {"safe-user-create", OPT_SAFE_USER_CREATE,
5546
   "Don't allow new user creation by the user who has no write privileges to the mysql.user table.",
5547 5548
   (gptr*) &opt_safe_user_create, (gptr*) &opt_safe_user_create, 0, GET_BOOL,
   NO_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5549 5550 5551
  {"safemalloc-mem-limit", OPT_SAFEMALLOC_MEM_LIMIT,
   "Simulate memory shortage when compiled with the --with-debug=full option.",
   0, 0, 0, GET_ULL, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
5552 5553 5554
  {"secure-auth", OPT_SECURE_AUTH, "Disallow authentication for accounts that have old (pre-4.1) passwords.",
   (gptr*) &opt_secure_auth, (gptr*) &opt_secure_auth, 0, GET_BOOL, NO_ARG,
   my_bool(0), 0, 0, 0, 0, 0},
5555
  {"server-id",	OPT_SERVER_ID,
5556
   "Uniquely identifies the server instance in the community of replication partners.",
unknown's avatar
unknown committed
5557
   (gptr*) &server_id, (gptr*) &server_id, 0, GET_ULONG, REQUIRED_ARG, 0, 0, 0,
5558 5559 5560 5561
   0, 0, 0},
  {"set-variable", 'O',
   "Change the value of a variable. Please note that this option is deprecated;you can set variables directly with --variable-name=value.",
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
5562
#ifdef HAVE_SMEM
unknown's avatar
unknown committed
5563 5564 5565 5566 5567 5568
  {"shared-memory", OPT_ENABLE_SHARED_MEMORY,
   "Enable the shared memory.",(gptr*) &opt_enable_shared_memory, (gptr*) &opt_enable_shared_memory,
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
#endif
#ifdef HAVE_SMEM
  {"shared-memory-base-name",OPT_SHARED_MEMORY_BASE_NAME,
5569
   "Base name of shared memory.", (gptr*) &shared_memory_base_name, (gptr*) &shared_memory_base_name,
5570 5571
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
#endif
unknown's avatar
unknown committed
5572
  {"show-slave-auth-info", OPT_SHOW_SLAVE_AUTH_INFO,
5573
   "Show user and password in SHOW SLAVE HOSTS on this master",
5574 5575 5576 5577 5578 5579
   (gptr*) &opt_show_slave_auth_info, (gptr*) &opt_show_slave_auth_info, 0,
   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
  {"skip-grant-tables", OPT_SKIP_GRANT,
   "Start without grant tables. This gives all users FULL ACCESS to all tables!",
   (gptr*) &opt_noacl, (gptr*) &opt_noacl, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0,
   0},
unknown's avatar
unknown committed
5580 5581
  {"skip-host-cache", OPT_SKIP_HOST_CACHE, "Don't cache host names.", 0, 0, 0,
   GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
5582
  {"skip-locking", OPT_SKIP_LOCK,
5583
   "Deprecated option, use --skip-external-locking instead.",
5584 5585
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  {"skip-name-resolve", OPT_SKIP_RESOLVE,
5586
   "Don't resolve hostnames. All hostnames are IP's or 'localhost'.",
5587 5588 5589 5590 5591 5592
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  {"skip-networking", OPT_SKIP_NETWORKING,
   "Don't allow connection with TCP/IP.", 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0,
   0, 0, 0},
  {"skip-new", OPT_SKIP_NEW, "Don't use new, possible wrong routines.",
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5593 5594 5595 5596 5597 5598 5599
#ifndef DBUG_OFF
#ifdef SAFEMALLOC
  {"skip-safemalloc", OPT_SKIP_SAFEMALLOC,
   "Don't use the memory allocation checking.", 0, 0, 0, GET_NO_ARG, NO_ARG,
   0, 0, 0, 0, 0, 0},
#endif
#endif
5600
  {"skip-show-database", OPT_SKIP_SHOW_DB,
5601
   "Don't allow 'SHOW DATABASE' commands.", 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0,
5602 5603 5604 5605 5606
   0, 0, 0, 0},
  {"skip-slave-start", OPT_SKIP_SLAVE_START,
   "If set, slave is not autostarted.", (gptr*) &opt_skip_slave_start,
   (gptr*) &opt_skip_slave_start, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
  {"skip-stack-trace", OPT_SKIP_STACK_TRACE,
5607
   "Don't print a stack trace on failure.", 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0,
5608
   0, 0, 0, 0},
unknown's avatar
unknown committed
5609
  {"skip-symlink", OPT_SKIP_SYMLINKS, "Don't allow symlinking of tables. Deprecated option.  Use --skip-symbolic-links instead.",
5610 5611 5612 5613
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  {"skip-thread-priority", OPT_SKIP_PRIOR,
   "Don't give threads different priorities.", 0, 0, 0, GET_NO_ARG, NO_ARG, 0,
   0, 0, 0, 0, 0},
unknown's avatar
SCRUM  
unknown committed
5614
#ifdef HAVE_REPLICATION
5615
  {"slave-load-tmpdir", OPT_SLAVE_LOAD_TMPDIR,
5616
   "The location where the slave should put its temporary files when \
5617
replicating a LOAD DATA INFILE command.",
5618
   (gptr*) &slave_load_tmpdir, (gptr*) &slave_load_tmpdir, 0, GET_STR_ALLOC,
5619 5620
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {"slave-skip-errors", OPT_SLAVE_SKIP_ERRORS,
5621
   "Tells the slave thread to continue replication when a query returns an error from the provided list.",
5622
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
5623
#endif
5624
  {"socket", OPT_SOCKET, "Socket file to use for connection.",
5625
   (gptr*) &mysqld_unix_port, (gptr*) &mysqld_unix_port, 0, GET_STR,
5626
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5627 5628 5629 5630 5631 5632 5633
#ifdef HAVE_REPLICATION
  {"sporadic-binlog-dump-fail", OPT_SPORADIC_BINLOG_DUMP_FAIL,
   "Option used by mysql-test for debugging and testing of replication.",
   (gptr*) &opt_sporadic_binlog_dump_fail,
   (gptr*) &opt_sporadic_binlog_dump_fail, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0,
   0},
#endif /* HAVE_REPLICATION */
5634
  {"sql-bin-update-same", OPT_SQL_BIN_UPDATE_SAME,
unknown's avatar
Merge  
unknown committed
5635 5636
   "The update log is deprecated since version 5.0, is replaced by the binary \
log and this option does nothing anymore.",
5637
   0, 0, 0, GET_DISABLED, NO_ARG, 0, 0, 0, 0, 0, 0},
5638
  {"sql-mode", OPT_SQL_MODE,
5639
   "Syntax: sql-mode=option[,option[,option...]] where option can be one of: REAL_AS_FLOAT, PIPES_AS_CONCAT, ANSI_QUOTES, IGNORE_SPACE, ONLY_FULL_GROUP_BY, NO_UNSIGNED_SUBTRACTION.",
5640 5641
   (gptr*) &sql_mode_str, (gptr*) &sql_mode_str, 0, GET_STR, REQUIRED_ARG, 0,
   0, 0, 0, 0, 0},
5642
#ifdef HAVE_OPENSSL
5643 5644
#include "sslopt-longopts.h"
#endif
unknown's avatar
unknown committed
5645 5646 5647 5648 5649 5650 5651 5652
#ifdef __WIN__
  {"standalone", OPT_STANDALONE,
  "Dummy option to start as a standalone program (NT).", 0, 0, 0, GET_NO_ARG,
   NO_ARG, 0, 0, 0, 0, 0, 0},
#endif
  {"symbolic-links", 's', "Enable symbolic link support.",
   (gptr*) &my_use_symdir, (gptr*) &my_use_symdir, 0, GET_BOOL, NO_ARG,
   IF_PURIFY(0,1), 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5653 5654 5655 5656
  {"sysdate-is-now", OPT_SYSDATE_IS_NOW,
   "Non-default option to alias SYSDATE() to NOW() to make it safe-replicable. Since 5.0, SYSDATE() returns a `dynamic' value different for different invocations, even within the same statement.",
   (gptr*) &global_system_variables.sysdate_is_now,
   0, 0, GET_BOOL, NO_ARG, 0, 0, 1, 0, 1, 0},
unknown's avatar
Merge  
unknown committed
5657
  {"tc-heuristic-recover", OPT_TC_HEURISTIC_RECOVER,
unknown's avatar
unknown committed
5658
   "Decision to use in heuristic recover process. Possible values are COMMIT or ROLLBACK.",
unknown's avatar
Merge  
unknown committed
5659 5660
   (gptr*) &opt_tc_heuristic_recover, (gptr*) &opt_tc_heuristic_recover,
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5661
  {"temp-pool", OPT_TEMP_POOL,
5662
   "Using this option will cause most temporary files created to use a small set of names, rather than a unique name for each new file.",
unknown's avatar
unknown committed
5663 5664
   (gptr*) &use_temp_pool, (gptr*) &use_temp_pool, 0, GET_BOOL, NO_ARG, 1,
   0, 0, 0, 0, 0},
unknown's avatar
Merge  
unknown committed
5665 5666 5667 5668
  {"timed_mutexes", OPT_TIMED_MUTEXES,
   "Specify whether to time mutexes (only InnoDB mutexes are currently supported)",
   (gptr*) &timed_mutexes, (gptr*) &timed_mutexes, 0, GET_BOOL, NO_ARG, 0, 
    0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5669 5670
  {"tmpdir", 't',
   "Path for temporary files. Several paths may be specified, separated by a "
5671
#if defined(__WIN__) || defined(__NETWARE__)
unknown's avatar
unknown committed
5672 5673 5674 5675 5676 5677
   "semicolon (;)"
#else
   "colon (:)"
#endif
   ", in this case they are used in a round-robin fashion.",
   (gptr*) &opt_mysql_tmpdir,
unknown's avatar
unknown committed
5678
   (gptr*) &opt_mysql_tmpdir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
5679
  {"transaction-isolation", OPT_TX_ISOLATION,
5680
   "Default transaction isolation level.", 0, 0, 0, GET_STR, REQUIRED_ARG, 0,
unknown's avatar
unknown committed
5681
   0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5682
  {"use-symbolic-links", 's', "Enable symbolic link support. Deprecated option; use --symbolic-links instead.",
5683
   (gptr*) &my_use_symdir, (gptr*) &my_use_symdir, 0, GET_BOOL, NO_ARG,
unknown's avatar
unknown committed
5684
   IF_PURIFY(0,1), 0, 0, 0, 0, 0},
5685
  {"user", 'u', "Run mysqld daemon as user.", 0, 0, 0, GET_STR, REQUIRED_ARG,
unknown's avatar
unknown committed
5686
   0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5687 5688 5689
  {"verbose", 'v', "Used with --help option for detailed help",
   (gptr*) &opt_verbose, (gptr*) &opt_verbose, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
   0, 0},
5690
  {"version", 'V', "Output version information and exit.", 0, 0, 0, GET_NO_ARG,
5691
   NO_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5692
  {"warnings", 'W', "Deprecated; use --log-warnings instead.",
unknown's avatar
unknown committed
5693
   (gptr*) &global_system_variables.log_warnings,
5694
   (gptr*) &max_system_variables.log_warnings, 0, GET_ULONG, OPT_ARG, 1, 0, ~0L,
5695 5696
   0, 0, 0},
  { "back_log", OPT_BACK_LOG,
5697 5698
    "The number of outstanding connection requests MySQL can have. This comes into play when the main MySQL thread gets very many connection requests in a very short time.",
    (gptr*) &back_log, (gptr*) &back_log, 0, GET_ULONG,
5699
    REQUIRED_ARG, 50, 1, 65535, 0, 1, 0 },
5700
#ifdef WITH_BERKELEY_STORAGE_ENGINE
5701 5702 5703 5704
  { "bdb_cache_parts", OPT_BDB_CACHE_PARTS,
    "Number of parts to use for BDB cache.",
    (gptr*) &berkeley_cache_parts, (gptr*) &berkeley_cache_parts, 0, GET_ULONG,
    REQUIRED_ARG, 1, 1, 1024, 0, 1, 0},
5705
  { "bdb_cache_size", OPT_BDB_CACHE_SIZE,
5706
    "The buffer that is allocated to cache index and rows for BDB tables.",
5707 5708
    (gptr*) &berkeley_cache_size, (gptr*) &berkeley_cache_size, 0, GET_ULL,
    REQUIRED_ARG, KEY_CACHE_SIZE, 20*1024, (ulonglong) ~0, 0, IO_SIZE, 0},
unknown's avatar
unknown committed
5709 5710 5711
  {"bdb_lock_max", OPT_BDB_MAX_LOCK, "Synonym for bdb_max_lock.",
   (gptr*) &berkeley_max_lock, (gptr*) &berkeley_max_lock, 0, GET_ULONG,
   REQUIRED_ARG, 10000, 0, (long) ~0, 0, 1, 0},
5712 5713 5714 5715 5716 5717 5718 5719
  {"bdb_log_buffer_size", OPT_BDB_LOG_BUFFER_SIZE,
   "The buffer that is allocated to cache index and rows for BDB tables.",
   (gptr*) &berkeley_log_buffer_size, (gptr*) &berkeley_log_buffer_size, 0,
   GET_ULONG, REQUIRED_ARG, 0, 256*1024L, ~0L, 0, 1024, 0},
  {"bdb_max_lock", OPT_BDB_MAX_LOCK,
   "The maximum number of locks you can have active on a BDB table.",
   (gptr*) &berkeley_max_lock, (gptr*) &berkeley_max_lock, 0, GET_ULONG,
   REQUIRED_ARG, 10000, 0, (long) ~0, 0, 1, 0},
5720 5721 5722 5723
  {"bdb_region_size", OPT_BDB_REGION_SIZE,
    "The size of the underlying logging area of the Berkeley DB environment.",
    (gptr*) &berkeley_region_size, (gptr*) &berkeley_region_size, 0, GET_ULONG,
    OPT_ARG, 60*1024L, 60*1024L, (long) ~0, 0, 1, 0},
5724
#endif /* WITH_BERKELEY_STORAGE_ENGINE */
5725 5726 5727 5728
  {"binlog_cache_size", OPT_BINLOG_CACHE_SIZE,
   "The size of the cache to hold the SQL statements for the binary log during a transaction. If you often use big, multi-statement transactions you can increase this to get more performance.",
   (gptr*) &binlog_cache_size, (gptr*) &binlog_cache_size, 0, GET_ULONG,
   REQUIRED_ARG, 32*1024L, IO_SIZE, ~0L, 0, IO_SIZE, 0},
unknown's avatar
unknown committed
5729 5730 5731 5732 5733
  {"bulk_insert_buffer_size", OPT_BULK_INSERT_BUFFER_SIZE,
   "Size of tree cache used in bulk insert optimisation. Note that this is a limit per thread!",
   (gptr*) &global_system_variables.bulk_insert_buff_size,
   (gptr*) &max_system_variables.bulk_insert_buff_size,
   0, GET_ULONG, REQUIRED_ARG, 8192*1024, 0, ~0L, 0, 1, 0},
5734
  {"connect_timeout", OPT_CONNECT_TIMEOUT,
5735
   "The number of seconds the mysqld server is waiting for a connect packet before responding with 'Bad handshake'.",
unknown's avatar
unknown committed
5736 5737
    (gptr*) &connect_timeout, (gptr*) &connect_timeout,
   0, GET_ULONG, REQUIRED_ARG, CONNECT_TIMEOUT, 2, LONG_TIMEOUT, 0, 1, 0 },
unknown's avatar
unknown committed
5738 5739 5740 5741 5742 5743 5744 5745 5746 5747 5748 5749 5750 5751 5752
  { "date_format", OPT_DATE_FORMAT,
    "The DATE format (For future).",
    (gptr*) &opt_date_time_formats[MYSQL_TIMESTAMP_DATE],
    (gptr*) &opt_date_time_formats[MYSQL_TIMESTAMP_DATE],
    0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  { "datetime_format", OPT_DATETIME_FORMAT,
    "The DATETIME/TIMESTAMP format (for future).",
    (gptr*) &opt_date_time_formats[MYSQL_TIMESTAMP_DATETIME],
    (gptr*) &opt_date_time_formats[MYSQL_TIMESTAMP_DATETIME],
    0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  { "default_week_format", OPT_DEFAULT_WEEK_FORMAT,
    "The default week format used by WEEK() functions.",
    (gptr*) &global_system_variables.default_week_format,
    (gptr*) &max_system_variables.default_week_format,
    0, GET_ULONG, REQUIRED_ARG, 0, 0, 7L, 0, 1, 0},
5753 5754 5755 5756
  {"delayed_insert_limit", OPT_DELAYED_INSERT_LIMIT,
   "After inserting delayed_insert_limit rows, the INSERT DELAYED handler will check if there are any SELECT statements pending. If so, it allows these to execute before continuing.",
    (gptr*) &delayed_insert_limit, (gptr*) &delayed_insert_limit, 0, GET_ULONG,
    REQUIRED_ARG, DELAYED_LIMIT, 1, ~0L, 0, 1, 0},
unknown's avatar
unknown committed
5757 5758 5759 5760
  {"delayed_insert_timeout", OPT_DELAYED_INSERT_TIMEOUT,
   "How long a INSERT DELAYED thread should wait for INSERT statements before terminating.",
   (gptr*) &delayed_insert_timeout, (gptr*) &delayed_insert_timeout, 0,
   GET_ULONG, REQUIRED_ARG, DELAYED_WAIT_TIMEOUT, 1, LONG_TIMEOUT, 0, 1, 0},
5761 5762 5763 5764
  { "delayed_queue_size", OPT_DELAYED_QUEUE_SIZE,
    "What size queue (in rows) should be allocated for handling INSERT DELAYED. If the queue becomes full, any client that does INSERT DELAYED will wait until there is room in the queue again.",
    (gptr*) &delayed_queue_size, (gptr*) &delayed_queue_size, 0, GET_ULONG,
    REQUIRED_ARG, DELAYED_QUEUE_SIZE, 1, ~0L, 0, 1, 0},
unknown's avatar
unknown committed
5765 5766 5767 5768 5769
  {"div_precision_increment", OPT_DIV_PRECINCREMENT,
   "Precision of the result of '/' operator will be increased on that value.",
   (gptr*) &global_system_variables.div_precincrement,
   (gptr*) &max_system_variables.div_precincrement, 0, GET_ULONG,
   REQUIRED_ARG, 4, 0, DECIMAL_MAX_SCALE, 0, 0, 0},
unknown's avatar
unknown committed
5770
  {"expire_logs_days", OPT_EXPIRE_LOGS_DAYS,
5771 5772
   "If non-zero, binary logs will be purged after expire_logs_days "
   "days; possible purges happen at startup and at binary log rotation.",
unknown's avatar
unknown committed
5773 5774 5775
   (gptr*) &expire_logs_days,
   (gptr*) &expire_logs_days, 0, GET_ULONG,
   REQUIRED_ARG, 0, 0, 99, 0, 1, 0},
5776 5777 5778 5779
  { "flush_time", OPT_FLUSH_TIME,
    "A dedicated thread is created to flush all tables at the given interval.",
    (gptr*) &flush_time, (gptr*) &flush_time, 0, GET_ULONG, REQUIRED_ARG,
    FLUSH_TIME, 0, LONG_TIMEOUT, 0, 1, 0},
unknown's avatar
unknown committed
5780 5781 5782 5783
  { "ft_boolean_syntax", OPT_FT_BOOLEAN_SYNTAX,
    "List of operators for MATCH ... AGAINST ( ... IN BOOLEAN MODE)",
    0, 0, 0, GET_STR,
    REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
5784 5785 5786
  { "ft_max_word_len", OPT_FT_MAX_WORD_LEN,
    "The maximum length of the word to be included in a FULLTEXT index. Note: FULLTEXT indexes must be rebuilt after changing this variable.",
    (gptr*) &ft_max_word_len, (gptr*) &ft_max_word_len, 0, GET_ULONG,
5787
    REQUIRED_ARG, HA_FT_MAXCHARLEN, 10, HA_FT_MAXCHARLEN, 0, 1, 0},
unknown's avatar
unknown committed
5788 5789 5790 5791
  { "ft_min_word_len", OPT_FT_MIN_WORD_LEN,
    "The minimum length of the word to be included in a FULLTEXT index. Note: FULLTEXT indexes must be rebuilt after changing this variable.",
    (gptr*) &ft_min_word_len, (gptr*) &ft_min_word_len, 0, GET_ULONG,
    REQUIRED_ARG, 4, 1, HA_FT_MAXCHARLEN, 0, 1, 0},
5792 5793 5794 5795
  { "ft_query_expansion_limit", OPT_FT_QUERY_EXPANSION_LIMIT,
    "Number of best matches to use for query expansion",
    (gptr*) &ft_query_expansion_limit, (gptr*) &ft_query_expansion_limit, 0, GET_ULONG,
    REQUIRED_ARG, 20, 0, 1000, 0, 1, 0},
5796 5797 5798 5799
  { "ft_stopword_file", OPT_FT_STOPWORD_FILE,
    "Use stopwords from this file instead of built-in list.",
    (gptr*) &ft_stopword_file, (gptr*) &ft_stopword_file, 0, GET_STR,
    REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5800 5801 5802 5803 5804
  { "group_concat_max_len", OPT_GROUP_CONCAT_MAX_LEN,
    "The maximum length of the result of function  group_concat.",
    (gptr*) &global_system_variables.group_concat_max_len,
    (gptr*) &max_system_variables.group_concat_max_len, 0, GET_ULONG,
    REQUIRED_ARG, 1024, 4, (long) ~0, 0, 1, 0},
5805
#ifdef WITH_INNOBASE_STORAGE_ENGINE
5806 5807 5808 5809 5810
  {"innodb_additional_mem_pool_size", OPT_INNODB_ADDITIONAL_MEM_POOL_SIZE,
   "Size of a memory pool InnoDB uses to store data dictionary information and other internal data structures.",
   (gptr*) &innobase_additional_mem_pool_size,
   (gptr*) &innobase_additional_mem_pool_size, 0, GET_LONG, REQUIRED_ARG,
   1*1024*1024L, 512*1024L, ~0L, 0, 1024, 0},
5811 5812 5813 5814
  {"innodb_autoextend_increment", OPT_INNODB_AUTOEXTEND_INCREMENT,
   "Data file autoextend increment in megabytes",
   (gptr*) &srv_auto_extend_increment,
   (gptr*) &srv_auto_extend_increment,
unknown's avatar
unknown committed
5815
   0, GET_LONG, REQUIRED_ARG, 8L, 1L, 1000L, 0, 1L, 0},
unknown's avatar
unknown committed
5816 5817 5818 5819 5820 5821 5822
  {"innodb_buffer_pool_awe_mem_mb", OPT_INNODB_BUFFER_POOL_AWE_MEM_MB,
   "If Windows AWE is used, the size of InnoDB buffer pool allocated from the AWE memory.",
   (gptr*) &innobase_buffer_pool_awe_mem_mb, (gptr*) &innobase_buffer_pool_awe_mem_mb, 0,
   GET_LONG, REQUIRED_ARG, 0, 0, 63000, 0, 1, 0},
  {"innodb_buffer_pool_size", OPT_INNODB_BUFFER_POOL_SIZE,
   "The size of the memory buffer InnoDB uses to cache data and indexes of its tables.",
   (gptr*) &innobase_buffer_pool_size, (gptr*) &innobase_buffer_pool_size, 0,
5823 5824
   GET_LL, REQUIRED_ARG, 8*1024*1024L, 1024*1024L, LONGLONG_MAX, 0,
   1024*1024L, 0},
5825
  {"innodb_commit_concurrency", OPT_INNODB_COMMIT_CONCURRENCY,
unknown's avatar
unknown committed
5826 5827 5828
   "Helps in performance tuning in heavily concurrent environments.",
   (gptr*) &srv_commit_concurrency, (gptr*) &srv_commit_concurrency,
   0, GET_LONG, REQUIRED_ARG, 0, 0, 1000, 0, 1, 0},
unknown's avatar
Merge  
unknown committed
5829 5830 5831 5832 5833 5834
  {"innodb_concurrency_tickets", OPT_INNODB_CONCURRENCY_TICKETS,
   "Number of times a thread is allowed to enter InnoDB within the same \
    SQL query after it has once got the ticket",
   (gptr*) &srv_n_free_tickets_to_enter,
   (gptr*) &srv_n_free_tickets_to_enter,
   0, GET_LONG, REQUIRED_ARG, 500L, 1L, ~0L, 0, 1L, 0},
5835 5836 5837 5838
  {"innodb_file_io_threads", OPT_INNODB_FILE_IO_THREADS,
   "Number of file I/O threads in InnoDB.", (gptr*) &innobase_file_io_threads,
   (gptr*) &innobase_file_io_threads, 0, GET_LONG, REQUIRED_ARG, 4, 4, 64, 0,
   1, 0},
unknown's avatar
unknown committed
5839 5840 5841 5842
  {"innodb_force_recovery", OPT_INNODB_FORCE_RECOVERY,
   "Helps to save your data in case the disk image of the database becomes corrupt.",
   (gptr*) &innobase_force_recovery, (gptr*) &innobase_force_recovery, 0,
   GET_LONG, REQUIRED_ARG, 0, 0, 6, 0, 1, 0},
5843 5844 5845 5846
  {"innodb_lock_wait_timeout", OPT_INNODB_LOCK_WAIT_TIMEOUT,
   "Timeout in seconds an InnoDB transaction may wait for a lock before being rolled back.",
   (gptr*) &innobase_lock_wait_timeout, (gptr*) &innobase_lock_wait_timeout,
   0, GET_LONG, REQUIRED_ARG, 50, 1, 1024 * 1024 * 1024, 0, 1, 0},
unknown's avatar
unknown committed
5847 5848 5849 5850 5851
  {"innodb_log_buffer_size", OPT_INNODB_LOG_BUFFER_SIZE,
   "The size of the buffer which InnoDB uses to write log to the log files on disk.",
   (gptr*) &innobase_log_buffer_size, (gptr*) &innobase_log_buffer_size, 0,
   GET_LONG, REQUIRED_ARG, 1024*1024L, 256*1024L, ~0L, 0, 1024, 0},
  {"innodb_log_file_size", OPT_INNODB_LOG_FILE_SIZE,
5852
   "Size of each log file in a log group.",
unknown's avatar
unknown committed
5853
   (gptr*) &innobase_log_file_size, (gptr*) &innobase_log_file_size, 0,
5854 5855
   GET_LL, REQUIRED_ARG, 5*1024*1024L, 1*1024*1024L, LONGLONG_MAX, 0,
   1024*1024L, 0},
unknown's avatar
unknown committed
5856 5857 5858 5859 5860 5861 5862 5863 5864 5865 5866 5867 5868
  {"innodb_log_files_in_group", OPT_INNODB_LOG_FILES_IN_GROUP,
   "Number of log files in the log group. InnoDB writes to the files in a circular fashion. Value 3 is recommended here.",
   (gptr*) &innobase_log_files_in_group, (gptr*) &innobase_log_files_in_group,
   0, GET_LONG, REQUIRED_ARG, 2, 2, 100, 0, 1, 0},
  {"innodb_mirrored_log_groups", OPT_INNODB_MIRRORED_LOG_GROUPS,
   "Number of identical copies of log groups we keep for the database. Currently this should be set to 1.",
   (gptr*) &innobase_mirrored_log_groups,
   (gptr*) &innobase_mirrored_log_groups, 0, GET_LONG, REQUIRED_ARG, 1, 1, 10,
   0, 1, 0},
  {"innodb_open_files", OPT_INNODB_OPEN_FILES,
   "How many files at the maximum InnoDB keeps open at the same time.",
   (gptr*) &innobase_open_files, (gptr*) &innobase_open_files, 0,
   GET_LONG, REQUIRED_ARG, 300L, 10L, ~0L, 0, 1L, 0},
unknown's avatar
Merge  
unknown committed
5869 5870 5871 5872 5873
  {"innodb_sync_spin_loops", OPT_INNODB_SYNC_SPIN_LOOPS,
   "Count of spin-loop rounds in InnoDB mutexes",
   (gptr*) &srv_n_spin_wait_rounds,
   (gptr*) &srv_n_spin_wait_rounds,
   0, GET_LONG, REQUIRED_ARG, 20L, 0L, ~0L, 0, 1L, 0},
5874 5875
  {"innodb_thread_concurrency", OPT_INNODB_THREAD_CONCURRENCY,
   "Helps in performance tuning in heavily concurrent environments.",
unknown's avatar
Merge  
unknown committed
5876
   (gptr*) &srv_thread_concurrency, (gptr*) &srv_thread_concurrency,
unknown's avatar
unknown committed
5877
   0, GET_LONG, REQUIRED_ARG, 8, 1, 1000, 0, 1, 0},
unknown's avatar
Merge  
unknown committed
5878 5879 5880 5881 5882 5883
  {"innodb_thread_sleep_delay", OPT_INNODB_THREAD_SLEEP_DELAY,
   "Time of innodb thread sleeping before joining InnoDB queue (usec). Value 0"
    " disable a sleep",
   (gptr*) &srv_thread_sleep_delay,
   (gptr*) &srv_thread_sleep_delay,
   0, GET_LONG, REQUIRED_ARG, 10000L, 0L, ~0L, 0, 1L, 0},
5884
#endif /* WITH_INNOBASE_STORAGE_ENGINE */
5885 5886
  {"interactive_timeout", OPT_INTERACTIVE_TIMEOUT,
   "The number of seconds the server waits for activity on an interactive connection before closing it.",
5887 5888
   (gptr*) &global_system_variables.net_interactive_timeout,
   (gptr*) &max_system_variables.net_interactive_timeout, 0,
5889 5890 5891
   GET_ULONG, REQUIRED_ARG, NET_WAIT_TIMEOUT, 1, LONG_TIMEOUT, 0, 1, 0},
  {"join_buffer_size", OPT_JOIN_BUFF_SIZE,
   "The size of the buffer that is used for full joins.",
5892 5893
   (gptr*) &global_system_variables.join_buff_size,
   (gptr*) &max_system_variables.join_buff_size, 0, GET_ULONG,
5894 5895 5896
   REQUIRED_ARG, 128*1024L, IO_SIZE*2+MALLOC_OVERHEAD, ~0L, MALLOC_OVERHEAD,
   IO_SIZE, 0},
  {"key_buffer_size", OPT_KEY_BUFFER_SIZE,
5897
   "The size of the buffer used for index blocks for MyISAM tables. Increase this to get better index handling (for all reads and multiple writes) to as much as you can afford; 64M on a 256M machine that mainly runs MySQL is quite common.",
unknown's avatar
unknown committed
5898
   (gptr*) &dflt_key_cache_var.param_buff_size,
5899
   (gptr*) 0,
unknown's avatar
unknown committed
5900
   0, (GET_ULL | GET_ASK_ADDR),
5901
   REQUIRED_ARG, KEY_CACHE_SIZE, MALLOC_OVERHEAD, ~(ulong) 0, MALLOC_OVERHEAD,
5902
   IO_SIZE, 0},
unknown's avatar
unknown committed
5903 5904 5905 5906 5907 5908
  {"key_cache_age_threshold", OPT_KEY_CACHE_AGE_THRESHOLD,
   "This characterizes the number of hits a hot block has to be untouched until it is considered aged enough to be downgraded to a warm block. This specifies the percentage ratio of that number of hits to the total number of blocks in key cache",
   (gptr*) &dflt_key_cache_var.param_age_threshold,
   (gptr*) 0,
   0, (GET_ULONG | GET_ASK_ADDR), REQUIRED_ARG, 
   300, 100, ~0L, 0, 100, 0},
unknown's avatar
unknown committed
5909 5910
  {"key_cache_block_size", OPT_KEY_CACHE_BLOCK_SIZE,
   "The default size of key cache blocks",
unknown's avatar
unknown committed
5911
   (gptr*) &dflt_key_cache_var.param_block_size,
5912
   (gptr*) 0,
unknown's avatar
unknown committed
5913
   0, (GET_ULONG | GET_ASK_ADDR), REQUIRED_ARG,
5914
   KEY_CACHE_BLOCK_SIZE , 512, 1024*16, MALLOC_OVERHEAD, 512, 0},
5915 5916
  {"key_cache_division_limit", OPT_KEY_CACHE_DIVISION_LIMIT,
   "The minimum percentage of warm blocks in key cache",
unknown's avatar
unknown committed
5917
   (gptr*) &dflt_key_cache_var.param_division_limit,
5918
   (gptr*) 0,
unknown's avatar
unknown committed
5919
   0, (GET_ULONG | GET_ASK_ADDR) , REQUIRED_ARG, 100,
5920
   1, 100, 0, 1, 0},
5921 5922
  {"long_query_time", OPT_LONG_QUERY_TIME,
   "Log all queries that have taken more than long_query_time seconds to execute to file.",
5923 5924
   (gptr*) &global_system_variables.long_query_time,
   (gptr*) &max_system_variables.long_query_time, 0, GET_ULONG,
5925 5926
   REQUIRED_ARG, 10, 1, LONG_TIMEOUT, 0, 1, 0},
  {"lower_case_table_names", OPT_LOWER_CASE_TABLE_NAMES,
unknown's avatar
unknown committed
5927
   "If set to 1 table names are stored in lowercase on disk and table names will be case-insensitive.  Should be set to 2 if you are using a case insensitive file system",
5928
   (gptr*) &lower_case_table_names,
unknown's avatar
unknown committed
5929
   (gptr*) &lower_case_table_names, 0, GET_UINT, OPT_ARG,
5930 5931 5932 5933 5934
#ifdef FN_NO_CASE_SENCE
    1
#else
    0
#endif
unknown's avatar
unknown committed
5935
   , 0, 2, 0, 1, 0},
5936 5937
  {"max_allowed_packet", OPT_MAX_ALLOWED_PACKET,
   "Max packetlength to send/receive from to server.",
unknown's avatar
unknown committed
5938 5939
   (gptr*) &global_system_variables.max_allowed_packet,
   (gptr*) &max_system_variables.max_allowed_packet, 0, GET_ULONG,
unknown's avatar
unknown committed
5940
   REQUIRED_ARG, 1024*1024L, 1024, 1024L*1024L*1024L, MALLOC_OVERHEAD, 1024, 0},
5941 5942 5943 5944 5945
  {"max_binlog_cache_size", OPT_MAX_BINLOG_CACHE_SIZE,
   "Can be used to restrict the total size used to cache a multi-transaction query.",
   (gptr*) &max_binlog_cache_size, (gptr*) &max_binlog_cache_size, 0,
   GET_ULONG, REQUIRED_ARG, ~0L, IO_SIZE, ~0L, 0, IO_SIZE, 0},
  {"max_binlog_size", OPT_MAX_BINLOG_SIZE,
5946 5947 5948
   "Binary log will be rotated automatically when the size exceeds this \
value. Will also apply to relay logs if max_relay_log_size is 0. \
The minimum value for this variable is 4096.",
5949
   (gptr*) &max_binlog_size, (gptr*) &max_binlog_size, 0, GET_ULONG,
5950
   REQUIRED_ARG, 1024*1024L*1024L, IO_SIZE, 1024*1024L*1024L, 0, IO_SIZE, 0},
5951 5952 5953 5954
  {"max_connect_errors", OPT_MAX_CONNECT_ERRORS,
   "If there is more than this number of interrupted connections from a host this host will be blocked from further connections.",
   (gptr*) &max_connect_errors, (gptr*) &max_connect_errors, 0, GET_ULONG,
    REQUIRED_ARG, MAX_CONNECT_ERRORS, 1, ~0L, 0, 1, 0},
unknown's avatar
unknown committed
5955 5956 5957 5958
  {"max_connections", OPT_MAX_CONNECTIONS,
   "The number of simultaneous clients allowed.", (gptr*) &max_connections,
   (gptr*) &max_connections, 0, GET_ULONG, REQUIRED_ARG, 100, 1, 16384, 0, 1,
   0},
5959
  {"max_delayed_threads", OPT_MAX_DELAYED_THREADS,
5960
   "Don't start more than this number of threads to handle INSERT DELAYED statements. If set to zero, which means INSERT DELAYED is not used.",
5961 5962
   (gptr*) &global_system_variables.max_insert_delayed_threads,
   (gptr*) &max_system_variables.max_insert_delayed_threads,
5963
   0, GET_ULONG, REQUIRED_ARG, 20, 0, 16384, 0, 1, 0},
5964
  {"max_error_count", OPT_MAX_ERROR_COUNT,
5965
   "Max number of errors/warnings to store for a statement.",
5966 5967
   (gptr*) &global_system_variables.max_error_count,
   (gptr*) &max_system_variables.max_error_count,
5968
   0, GET_ULONG, REQUIRED_ARG, DEFAULT_ERROR_COUNT, 0, 65535, 0, 1, 0},
5969 5970
  {"max_heap_table_size", OPT_MAX_HEP_TABLE_SIZE,
   "Don't allow creation of heap tables bigger than this.",
5971 5972
   (gptr*) &global_system_variables.max_heap_table_size,
   (gptr*) &max_system_variables.max_heap_table_size, 0, GET_ULONG,
5973 5974 5975
   REQUIRED_ARG, 16*1024*1024L, 16384, ~0L, MALLOC_OVERHEAD, 1024, 0},
  {"max_join_size", OPT_MAX_JOIN_SIZE,
   "Joins that are probably going to read more than max_join_size records return an error.",
5976
   (gptr*) &global_system_variables.max_join_size,
5977
   (gptr*) &max_system_variables.max_join_size, 0, GET_HA_ROWS, REQUIRED_ARG,
5978
   ~0L, 1, ~0L, 0, 1, 0},
unknown's avatar
unknown committed
5979
   {"max_length_for_sort_data", OPT_MAX_LENGTH_FOR_SORT_DATA,
5980
    "Max number of bytes in sorted records.",
unknown's avatar
unknown committed
5981 5982 5983
    (gptr*) &global_system_variables.max_length_for_sort_data,
    (gptr*) &max_system_variables.max_length_for_sort_data, 0, GET_ULONG,
    REQUIRED_ARG, 1024, 4, 8192*1024L, 0, 1, 0},
5984
  {"max_prepared_stmt_count", OPT_MAX_PREPARED_STMT_COUNT,
unknown's avatar
unknown committed
5985
   "Maximum number of prepared statements in the server.",
5986 5987
   (gptr*) &max_prepared_stmt_count, (gptr*) &max_prepared_stmt_count,
   0, GET_ULONG, REQUIRED_ARG, 16382, 0, 1*1024*1024, 0, 1, 0},
5988
  {"max_relay_log_size", OPT_MAX_RELAY_LOG_SIZE,
5989
   "If non-zero: relay log will be rotated automatically when the size exceeds this value; if zero (the default): when the size exceeds max_binlog_size. 0 excepted, the minimum value for this variable is 4096.",
5990 5991
   (gptr*) &max_relay_log_size, (gptr*) &max_relay_log_size, 0, GET_ULONG,
   REQUIRED_ARG, 0L, 0L, 1024*1024L*1024L, 0, IO_SIZE, 0},
5992 5993 5994 5995 5996
  { "max_seeks_for_key", OPT_MAX_SEEKS_FOR_KEY,
    "Limit assumed max number of seeks when looking up rows based on a key",
    (gptr*) &global_system_variables.max_seeks_for_key,
    (gptr*) &max_system_variables.max_seeks_for_key, 0, GET_ULONG,
    REQUIRED_ARG, ~0L, 1, ~0L, 0, 1, 0 },
5997 5998
  {"max_sort_length", OPT_MAX_SORT_LENGTH,
   "The number of bytes to use when sorting BLOB or TEXT values (only the first max_sort_length bytes of each value are used; the rest are ignored).",
unknown's avatar
unknown committed
5999 6000
   (gptr*) &global_system_variables.max_sort_length,
   (gptr*) &max_system_variables.max_sort_length, 0, GET_ULONG,
6001
   REQUIRED_ARG, 1024, 4, 8192*1024L, 0, 1, 0},
unknown's avatar
unknown committed
6002 6003 6004 6005 6006
  {"max_sp_recursion_depth", OPT_MAX_SP_RECURSION_DEPTH,
   "Maximum stored procedure recursion depth. (discussed with docs).",
   (gptr*) &global_system_variables.max_sp_recursion_depth,
   (gptr*) &max_system_variables.max_sp_recursion_depth, 0, GET_ULONG,
   OPT_ARG, 0, 0, 255, 0, 1, 0 },
6007 6008
  {"max_tmp_tables", OPT_MAX_TMP_TABLES,
   "Maximum number of temporary tables a client can keep open at a time.",
6009 6010
   (gptr*) &global_system_variables.max_tmp_tables,
   (gptr*) &max_system_variables.max_tmp_tables, 0, GET_ULONG,
6011 6012 6013
   REQUIRED_ARG, 32, 1, ~0L, 0, 1, 0},
  {"max_user_connections", OPT_MAX_USER_CONNECTIONS,
   "The maximum number of active connections for a single user (0 = no limit).",
unknown's avatar
Merge  
unknown committed
6014 6015
   (gptr*) &max_user_connections, (gptr*) &max_user_connections, 0, GET_UINT,
   REQUIRED_ARG, 0, 1, ~0, 0, 1, 0},
6016 6017 6018 6019
  {"max_write_lock_count", OPT_MAX_WRITE_LOCK_COUNT,
   "After this many write locks, allow some read locks to run in between.",
   (gptr*) &max_write_lock_count, (gptr*) &max_write_lock_count, 0, GET_ULONG,
   REQUIRED_ARG, ~0L, 1, ~0L, 0, 1, 0},
unknown's avatar
Merge  
unknown committed
6020 6021 6022 6023 6024
  {"multi_range_count", OPT_MULTI_RANGE_COUNT,
   "Number of key ranges to request at once.",
   (gptr*) &global_system_variables.multi_range_count,
   (gptr*) &max_system_variables.multi_range_count, 0,
   GET_ULONG, REQUIRED_ARG, 256, 1, ~0L, 0, 1, 0},
6025
  {"myisam_block_size", OPT_MYISAM_BLOCK_SIZE,
6026
   "Block size to be used for MyISAM index pages.",
unknown's avatar
unknown committed
6027
   (gptr*) &opt_myisam_block_size,
6028 6029 6030
   (gptr*) &opt_myisam_block_size, 0, GET_ULONG, REQUIRED_ARG,
   MI_KEY_BLOCK_LENGTH, MI_MIN_KEY_BLOCK_LENGTH, MI_MAX_KEY_BLOCK_LENGTH,
   0, MI_MIN_KEY_BLOCK_LENGTH, 0},
unknown's avatar
unknown committed
6031 6032 6033 6034
  {"myisam_data_pointer_size", OPT_MYISAM_DATA_POINTER_SIZE,
   "Default pointer size to be used for MyISAM tables.",
   (gptr*) &myisam_data_pointer_size,
   (gptr*) &myisam_data_pointer_size, 0, GET_ULONG, REQUIRED_ARG,
unknown's avatar
unknown committed
6035
   6, 2, 7, 0, 1, 0},
6036
  {"myisam_max_extra_sort_file_size", OPT_MYISAM_MAX_EXTRA_SORT_FILE_SIZE,
unknown's avatar
unknown committed
6037
   "Deprecated option",
6038 6039
   (gptr*) &global_system_variables.myisam_max_extra_sort_file_size,
   (gptr*) &max_system_variables.myisam_max_extra_sort_file_size,
unknown's avatar
unknown committed
6040
   0, GET_ULL, REQUIRED_ARG, (ulonglong) MI_MAX_TEMP_LENGTH,
6041
   0, (ulonglong) MAX_FILE_SIZE, 0, 1, 0},
6042
  {"myisam_max_sort_file_size", OPT_MYISAM_MAX_SORT_FILE_SIZE,
6043
   "Don't use the fast sort index method to created index if the temporary file would get bigger than this.",
6044 6045
   (gptr*) &global_system_variables.myisam_max_sort_file_size,
   (gptr*) &max_system_variables.myisam_max_sort_file_size, 0,
6046 6047
   GET_ULL, REQUIRED_ARG, (longlong) LONG_MAX, 0, (ulonglong) MAX_FILE_SIZE,
   0, 1024*1024, 0},
6048 6049 6050 6051 6052
  {"myisam_repair_threads", OPT_MYISAM_REPAIR_THREADS,
   "Number of threads to use when repairing MyISAM tables. The value of 1 disables parallel repair.",
   (gptr*) &global_system_variables.myisam_repair_threads,
   (gptr*) &max_system_variables.myisam_repair_threads, 0,
   GET_ULONG, REQUIRED_ARG, 1, 1, ~0L, 0, 1, 0},
6053 6054
  {"myisam_sort_buffer_size", OPT_MYISAM_SORT_BUFFER_SIZE,
   "The buffer that is allocated when sorting the index when doing a REPAIR or when creating indexes with CREATE INDEX or ALTER TABLE.",
unknown's avatar
unknown committed
6055 6056
   (gptr*) &global_system_variables.myisam_sort_buff_size,
   (gptr*) &max_system_variables.myisam_sort_buff_size, 0,
6057
   GET_ULONG, REQUIRED_ARG, 8192*1024, 4, ~0L, 0, 1, 0},
unknown's avatar
unknown committed
6058
  {"myisam_use_mmap", OPT_MYISAM_USE_MMAP,
unknown's avatar
unknown committed
6059
   "Use memory mapping for reading and writing MyISAM tables",
unknown's avatar
unknown committed
6060 6061 6062
   (gptr*) &opt_myisam_use_mmap,
   (gptr*) &opt_myisam_use_mmap, 0, GET_BOOL, NO_ARG, 0, 
    0, 0, 0, 0, 0},
6063 6064
  {"myisam_stats_method", OPT_MYISAM_STATS_METHOD,
   "Specifies how MyISAM index statistics collection code should threat NULLs. "
6065 6066
   "Possible values of name are \"nulls_unequal\" (default behavior for 4.1/5.0), "
   "\"nulls_equal\" (emulate 4.0 behavior), and \"nulls_ignored\".",
6067 6068
   (gptr*) &myisam_stats_method_str, (gptr*) &myisam_stats_method_str, 0,
    GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
6069
  {"net_buffer_length", OPT_NET_BUFFER_LENGTH,
6070
   "Buffer length for TCP/IP and socket communication.",
unknown's avatar
unknown committed
6071 6072 6073
   (gptr*) &global_system_variables.net_buffer_length,
   (gptr*) &max_system_variables.net_buffer_length, 0, GET_ULONG,
   REQUIRED_ARG, 16384, 1024, 1024*1024L, 0, 1024, 0},
6074 6075
  {"net_read_timeout", OPT_NET_READ_TIMEOUT,
   "Number of seconds to wait for more data from a connection before aborting the read.",
unknown's avatar
unknown committed
6076 6077
   (gptr*) &global_system_variables.net_read_timeout,
   (gptr*) &max_system_variables.net_read_timeout, 0, GET_ULONG,
6078
   REQUIRED_ARG, NET_READ_TIMEOUT, 1, LONG_TIMEOUT, 0, 1, 0},
unknown's avatar
unknown committed
6079 6080 6081 6082 6083
  {"net_retry_count", OPT_NET_RETRY_COUNT,
   "If a read on a communication port is interrupted, retry this many times before giving up.",
   (gptr*) &global_system_variables.net_retry_count,
   (gptr*) &max_system_variables.net_retry_count,0,
   GET_ULONG, REQUIRED_ARG, MYSQLD_NET_RETRY_COUNT, 1, ~0L, 0, 1, 0},
6084 6085
  {"net_write_timeout", OPT_NET_WRITE_TIMEOUT,
   "Number of seconds to wait for a block to be written to a connection  before aborting the write.",
unknown's avatar
unknown committed
6086 6087
   (gptr*) &global_system_variables.net_write_timeout,
   (gptr*) &max_system_variables.net_write_timeout, 0, GET_ULONG,
6088 6089 6090 6091
   REQUIRED_ARG, NET_WRITE_TIMEOUT, 1, LONG_TIMEOUT, 0, 1, 0},
  {"open_files_limit", OPT_OPEN_FILES_LIMIT,
   "If this is not 0, then mysqld will use this value to reserve file descriptors to use with setrlimit(). If this value is 0 then mysqld will reserve max_connections*5 or max_connections + table_cache*2 (whichever is larger) number of files.",
   (gptr*) &open_files_limit, (gptr*) &open_files_limit, 0, GET_ULONG,
6092
   REQUIRED_ARG, 0, 0, OS_FILE_LIMIT, 0, 1, 0},
unknown's avatar
Merge  
unknown committed
6093 6094 6095 6096 6097 6098 6099 6100 6101 6102
  {"optimizer_prune_level", OPT_OPTIMIZER_PRUNE_LEVEL,
   "Controls the heuristic(s) applied during query optimization to prune less-promising partial plans from the optimizer search space. Meaning: 0 - do not apply any heuristic, thus perform exhaustive search; 1 - prune plans based on number of retrieved rows.",
   (gptr*) &global_system_variables.optimizer_prune_level,
   (gptr*) &max_system_variables.optimizer_prune_level,
   0, GET_ULONG, OPT_ARG, 1, 0, 1, 0, 1, 0},
  {"optimizer_search_depth", OPT_OPTIMIZER_SEARCH_DEPTH,
   "Maximum depth of search performed by the query optimizer. Values larger than the number of relations in a query result in better query plans, but take longer to compile a query. Smaller values than the number of tables in a relation result in faster optimization, but may produce very bad query plans. If set to 0, the system will automatically pick a reasonable value; if set to MAX_TABLES+2, the optimizer will switch to the original find_best (used for testing/comparison).",
   (gptr*) &global_system_variables.optimizer_search_depth,
   (gptr*) &max_system_variables.optimizer_search_depth,
   0, GET_ULONG, OPT_ARG, MAX_TABLES+1, 0, MAX_TABLES+2, 0, 1, 0},
6103 6104 6105 6106
  {"plugin_dir", OPT_PLUGIN_DIR,
   "Directory for plugins.",
   (gptr*) &opt_plugin_dir_ptr, (gptr*) &opt_plugin_dir_ptr, 0,
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
6107 6108 6109 6110 6111
   {"preload_buffer_size", OPT_PRELOAD_BUFFER_SIZE,
    "The size of the buffer that is allocated when preloading indexes",
    (gptr*) &global_system_variables.preload_buff_size,
    (gptr*) &max_system_variables.preload_buff_size, 0, GET_ULONG,
    REQUIRED_ARG, 32*1024L, 1024, 1024*1024*1024L, 0, 1, 0},
6112 6113 6114 6115 6116
  {"query_alloc_block_size", OPT_QUERY_ALLOC_BLOCK_SIZE,
   "Allocation block size for query parsing and execution",
   (gptr*) &global_system_variables.query_alloc_block_size,
   (gptr*) &max_system_variables.query_alloc_block_size, 0, GET_ULONG,
   REQUIRED_ARG, QUERY_ALLOC_BLOCK_SIZE, 1024, ~0L, 0, 1024, 0},
unknown's avatar
unknown committed
6117
#ifdef HAVE_QUERY_CACHE
6118 6119 6120
  {"query_cache_limit", OPT_QUERY_CACHE_LIMIT,
   "Don't cache results that are bigger than this.",
   (gptr*) &query_cache_limit, (gptr*) &query_cache_limit, 0, GET_ULONG,
6121
   REQUIRED_ARG, 1024*1024L, 0, (longlong) ULONG_MAX, 0, 1, 0},
6122 6123 6124 6125 6126
  {"query_cache_min_res_unit", OPT_QUERY_CACHE_MIN_RES_UNIT,
   "minimal size of unit in wich space for results is allocated (last unit will be trimed after writing all result data.",
   (gptr*) &query_cache_min_res_unit, (gptr*) &query_cache_min_res_unit,
   0, GET_ULONG, REQUIRED_ARG, QUERY_CACHE_MIN_RESULT_DATA_SIZE,
   0, (longlong) ULONG_MAX, 0, 1, 0},
6127
#endif /*HAVE_QUERY_CACHE*/
6128 6129 6130
  {"query_cache_size", OPT_QUERY_CACHE_SIZE,
   "The memory allocated to store results from old queries.",
   (gptr*) &query_cache_size, (gptr*) &query_cache_size, 0, GET_ULONG,
unknown's avatar
unknown committed
6131
   REQUIRED_ARG, 0, 0, (longlong) ULONG_MAX, 0, 1024, 0},
6132
#ifdef HAVE_QUERY_CACHE
unknown's avatar
unknown committed
6133
  {"query_cache_type", OPT_QUERY_CACHE_TYPE,
6134
   "0 = OFF = Don't cache or retrieve results. 1 = ON = Cache all results except SELECT SQL_NO_CACHE ... queries. 2 = DEMAND = Cache only SELECT SQL_CACHE ... queries.",
unknown's avatar
unknown committed
6135 6136 6137
   (gptr*) &global_system_variables.query_cache_type,
   (gptr*) &max_system_variables.query_cache_type,
   0, GET_ULONG, REQUIRED_ARG, 1, 0, 2, 0, 1, 0},
6138 6139 6140 6141 6142 6143
  {"query_cache_wlock_invalidate", OPT_QUERY_CACHE_WLOCK_INVALIDATE,
   "Invalidate queries in query cache on LOCK for write",
   (gptr*) &global_system_variables.query_cache_wlock_invalidate,
   (gptr*) &max_system_variables.query_cache_wlock_invalidate,
   0, GET_BOOL, NO_ARG, 0, 0, 1, 0, 1, 0},
#endif /*HAVE_QUERY_CACHE*/
6144 6145 6146 6147
  {"query_prealloc_size", OPT_QUERY_PREALLOC_SIZE,
   "Persistent buffer for query parsing and execution",
   (gptr*) &global_system_variables.query_prealloc_size,
   (gptr*) &max_system_variables.query_prealloc_size, 0, GET_ULONG,
6148 6149
   REQUIRED_ARG, QUERY_ALLOC_PREALLOC_SIZE, QUERY_ALLOC_PREALLOC_SIZE,
   ~0L, 0, 1024, 0},
unknown's avatar
unknown committed
6150 6151 6152 6153
  {"range_alloc_block_size", OPT_RANGE_ALLOC_BLOCK_SIZE,
   "Allocation block size for storing ranges during optimization",
   (gptr*) &global_system_variables.range_alloc_block_size,
   (gptr*) &max_system_variables.range_alloc_block_size, 0, GET_ULONG,
6154
   REQUIRED_ARG, RANGE_ALLOC_BLOCK_SIZE, 4096, ~0L, 0, 1024, 0},
unknown's avatar
unknown committed
6155
  {"read_buffer_size", OPT_RECORD_BUFFER,
6156
   "Each thread that does a sequential scan allocates a buffer of this size for each table it scans. If you do many sequential scans, you may want to increase this value.",
unknown's avatar
unknown committed
6157 6158
   (gptr*) &global_system_variables.read_buff_size,
   (gptr*) &max_system_variables.read_buff_size,0, GET_ULONG, REQUIRED_ARG,
6159
   128*1024L, IO_SIZE*2+MALLOC_OVERHEAD, ~0L, MALLOC_OVERHEAD, IO_SIZE, 0},
unknown's avatar
unknown committed
6160
  {"read_only", OPT_READONLY,
6161
   "Make all non-temporary tables read-only, with the exception for replication (slave) threads and users with the SUPER privilege",
unknown's avatar
unknown committed
6162 6163 6164
   (gptr*) &opt_readonly,
   (gptr*) &opt_readonly,
   0, GET_BOOL, NO_ARG, 0, 0, 1, 0, 1, 0},
unknown's avatar
unknown committed
6165
  {"read_rnd_buffer_size", OPT_RECORD_RND_BUFFER,
6166
   "When reading rows in sorted order after a sort, the rows are read through this buffer to avoid a disk seeks. If not set, then it's set to the value of record_buffer.",
unknown's avatar
unknown committed
6167 6168 6169
   (gptr*) &global_system_variables.read_rnd_buff_size,
   (gptr*) &max_system_variables.read_rnd_buff_size, 0,
   GET_ULONG, REQUIRED_ARG, 256*1024L, IO_SIZE*2+MALLOC_OVERHEAD,
6170
   ~0L, MALLOC_OVERHEAD, IO_SIZE, 0},
unknown's avatar
unknown committed
6171 6172 6173 6174 6175
  {"record_buffer", OPT_RECORD_BUFFER,
   "Alias for read_buffer_size",
   (gptr*) &global_system_variables.read_buff_size,
   (gptr*) &max_system_variables.read_buff_size,0, GET_ULONG, REQUIRED_ARG,
   128*1024L, IO_SIZE*2+MALLOC_OVERHEAD, ~0L, MALLOC_OVERHEAD, IO_SIZE, 0},
unknown's avatar
SCRUM  
unknown committed
6176
#ifdef HAVE_REPLICATION
6177 6178 6179 6180 6181
  {"relay_log_purge", OPT_RELAY_LOG_PURGE,
   "0 = do not purge relay logs. 1 = purge them as soon as they are no more needed.",
   (gptr*) &relay_log_purge,
   (gptr*) &relay_log_purge, 0, GET_BOOL, NO_ARG,
   1, 0, 1, 0, 1, 0},
6182
  {"relay_log_space_limit", OPT_RELAY_LOG_SPACE_LIMIT,
6183
   "Maximum space to use for all relay logs.",
6184 6185
   (gptr*) &relay_log_space_limit,
   (gptr*) &relay_log_space_limit, 0, GET_ULL, REQUIRED_ARG, 0L, 0L,
6186
   (longlong) ULONG_MAX, 0, 1, 0},
6187
  {"slave_compressed_protocol", OPT_SLAVE_COMPRESSED_PROTOCOL,
6188
   "Use compression on master/slave protocol.",
6189 6190
   (gptr*) &opt_slave_compressed_protocol,
   (gptr*) &opt_slave_compressed_protocol,
6191
   0, GET_BOOL, NO_ARG, 0, 0, 1, 0, 1, 0},
6192
  {"slave_net_timeout", OPT_SLAVE_NET_TIMEOUT,
unknown's avatar
unknown committed
6193 6194
   "Number of seconds to wait for more data from a master/slave connection before aborting the read.",
   (gptr*) &slave_net_timeout, (gptr*) &slave_net_timeout, 0,
6195
   GET_ULONG, REQUIRED_ARG, SLAVE_NET_TIMEOUT, 1, LONG_TIMEOUT, 0, 1, 0},
6196 6197 6198 6199 6200
  {"slave_transaction_retries", OPT_SLAVE_TRANS_RETRIES,
   "Number of times the slave SQL thread will retry a transaction in case "
   "it failed with a deadlock or elapsed lock wait timeout, "
   "before giving up and stopping.",
   (gptr*) &slave_trans_retries, (gptr*) &slave_trans_retries, 0,
6201
   GET_ULONG, REQUIRED_ARG, 10L, 0L, (longlong) ULONG_MAX, 0, 1, 0},
6202
#endif /* HAVE_REPLICATION */
6203 6204 6205 6206
  {"slow_launch_time", OPT_SLOW_LAUNCH_TIME,
   "If creating the thread takes longer than this value (in seconds), the Slow_launch_threads counter will be incremented.",
   (gptr*) &slow_launch_time, (gptr*) &slow_launch_time, 0, GET_ULONG,
   REQUIRED_ARG, 2L, 0L, LONG_TIMEOUT, 0, 1, 0},
unknown's avatar
unknown committed
6207
  {"sort_buffer_size", OPT_SORT_BUFFER,
6208
   "Each thread that needs to do a sort allocates a buffer of this size.",
6209 6210
   (gptr*) &global_system_variables.sortbuff_size,
   (gptr*) &max_system_variables.sortbuff_size, 0, GET_ULONG, REQUIRED_ARG,
6211 6212
   MAX_SORT_MEMORY, MIN_SORT_MEMORY+MALLOC_OVERHEAD*2, ~0L, MALLOC_OVERHEAD,
   1, 0},
6213
#ifdef WITH_BERKELEY_STORAGE_ENGINE
unknown's avatar
unknown committed
6214
  {"sync-bdb-logs", OPT_BDB_SYNC,
6215
   "Synchronously flush Berkeley DB logs. Enabled by default",
unknown's avatar
unknown committed
6216 6217
   (gptr*) &opt_sync_bdb_logs, (gptr*) &opt_sync_bdb_logs, 0, GET_BOOL,
   NO_ARG, 1, 0, 0, 0, 0, 0},
6218
#endif /* WITH_BERKELEY_STORAGE_ENGINE */
6219
  {"sync-binlog", OPT_SYNC_BINLOG,
6220 6221 6222
   "Synchronously flush binary log to disk after every #th event. "
   "Use 0 (default) to disable synchronous flushing.",
   (gptr*) &sync_binlog_period, (gptr*) &sync_binlog_period, 0, GET_ULONG,
unknown's avatar
unknown committed
6223
   REQUIRED_ARG, 0, 0, ~0L, 0, 1, 0},
6224 6225 6226
  {"sync-frm", OPT_SYNC_FRM, "Sync .frm to disk on create. Enabled by default.",
   (gptr*) &opt_sync_frm, (gptr*) &opt_sync_frm, 0, GET_BOOL, NO_ARG, 1, 0,
   0, 0, 0, 0},
unknown's avatar
unknown committed
6227 6228 6229 6230 6231 6232 6233 6234 6235 6236 6237 6238 6239 6240 6241
  {"table_cache", OPT_TABLE_OPEN_CACHE,
   "Deprecated; use --table_open_cache instead.",
   (gptr*) &table_cache_size, (gptr*) &table_cache_size, 0, GET_ULONG,
   REQUIRED_ARG, 64, 1, 512*1024L, 0, 1, 0},
  {"table_definition_cache", OPT_TABLE_DEF_CACHE,
   "The number of cached table definitions.",
   (gptr*) &table_def_size, (gptr*) &table_def_size,
   0, GET_ULONG, REQUIRED_ARG, 128, 1, 512*1024L, 0, 1, 0},
  {"table_open_cache", OPT_TABLE_OPEN_CACHE,
   "The number of cached open tables.",
   (gptr*) &table_cache_size, (gptr*) &table_cache_size,
   0, GET_ULONG, REQUIRED_ARG, 64, 1, 512*1024L, 0, 1, 0},
  {"table_lock_wait_timeout", OPT_TABLE_LOCK_WAIT_TIMEOUT,
   "Timeout in seconds to wait for a table level lock before returning an "
   "error. Used only if the connection has active cursors.",
6242 6243
   (gptr*) &table_lock_wait_timeout, (gptr*) &table_lock_wait_timeout,
   0, GET_ULONG, REQUIRED_ARG, 50, 1, 1024 * 1024 * 1024, 0, 1, 0},
6244 6245 6246 6247
  {"thread_cache_size", OPT_THREAD_CACHE_SIZE,
   "How many threads we should keep in a cache for reuse.",
   (gptr*) &thread_cache_size, (gptr*) &thread_cache_size, 0, GET_ULONG,
   REQUIRED_ARG, 0, 0, 16384, 0, 1, 0},
unknown's avatar
unknown committed
6248 6249 6250 6251 6252 6253 6254 6255 6256 6257 6258 6259 6260
  {"thread_concurrency", OPT_THREAD_CONCURRENCY,
   "Permits the application to give the threads system a hint for the desired number of threads that should be run at the same time.",
   (gptr*) &concurrency, (gptr*) &concurrency, 0, GET_ULONG, REQUIRED_ARG,
   DEFAULT_CONCURRENCY, 1, 512, 0, 1, 0},
  {"thread_stack", OPT_THREAD_STACK,
   "The stack size for each thread.", (gptr*) &thread_stack,
   (gptr*) &thread_stack, 0, GET_ULONG, REQUIRED_ARG,DEFAULT_THREAD_STACK,
   1024L*128L, ~0L, 0, 1024, 0},
  { "time_format", OPT_TIME_FORMAT,
    "The TIME format (for future).",
    (gptr*) &opt_date_time_formats[MYSQL_TIMESTAMP_TIME],
    (gptr*) &opt_date_time_formats[MYSQL_TIMESTAMP_TIME],
    0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
6261 6262
  {"tmp_table_size", OPT_TMP_TABLE_SIZE,
   "If an in-memory temporary table exceeds this size, MySQL will automatically convert it to an on-disk MyISAM table.",
6263 6264
   (gptr*) &global_system_variables.tmp_table_size,
   (gptr*) &max_system_variables.tmp_table_size, 0, GET_ULONG,
6265
   REQUIRED_ARG, 32*1024*1024L, 1024, ~0L, 0, 1, 0},
6266 6267 6268 6269 6270 6271 6272 6273 6274 6275
  {"transaction_alloc_block_size", OPT_TRANS_ALLOC_BLOCK_SIZE,
   "Allocation block size for transactions to be stored in binary log",
   (gptr*) &global_system_variables.trans_alloc_block_size,
   (gptr*) &max_system_variables.trans_alloc_block_size, 0, GET_ULONG,
   REQUIRED_ARG, QUERY_ALLOC_BLOCK_SIZE, 1024, ~0L, 0, 1024, 0},
  {"transaction_prealloc_size", OPT_TRANS_PREALLOC_SIZE,
   "Persistent buffer for transactions to be stored in binary log",
   (gptr*) &global_system_variables.trans_prealloc_size,
   (gptr*) &max_system_variables.trans_prealloc_size, 0, GET_ULONG,
   REQUIRED_ARG, TRANS_ALLOC_PREALLOC_SIZE, 1024, ~0L, 0, 1024, 0},
unknown's avatar
Merge  
unknown committed
6276 6277 6278 6279 6280
  {"updatable_views_with_limit", OPT_UPDATABLE_VIEWS_WITH_LIMIT,
   "1 = YES = Don't issue an error message (warning only) if a VIEW without presence of a key of the underlying table is used in queries with a LIMIT clause for updating. 0 = NO = Prohibit update of a VIEW, which does not contain a key of the underlying table and the query uses a LIMIT clause (usually get from GUI tools).",
   (gptr*) &global_system_variables.updatable_views_with_limit,
   (gptr*) &max_system_variables.updatable_views_with_limit,
   0, GET_ULONG, REQUIRED_ARG, 1, 0, 1, 0, 1, 0},
6281
  {"wait_timeout", OPT_WAIT_TIMEOUT,
6282
   "The number of seconds the server waits for activity on a connection before closing it.",
6283 6284
   (gptr*) &global_system_variables.net_wait_timeout,
   (gptr*) &max_system_variables.net_wait_timeout, 0, GET_ULONG,
6285 6286
   REQUIRED_ARG, NET_WAIT_TIMEOUT, 1, IF_WIN(INT_MAX32/1000, LONG_TIMEOUT),
   0, 1, 0},
6287
  {0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
6288
};
unknown's avatar
unknown committed
6289

6290
static int show_question(THD *thd, SHOW_VAR *var, char *buff)
6291
{
6292
  var->type= SHOW_LONGLONG;
6293 6294 6295 6296
  var->value= (char *)&thd->query_id;
  return 0;
}

6297
static int show_net_compression(THD *thd, SHOW_VAR *var, char *buff)
6298
{
6299
  var->type= SHOW_MY_BOOL;
6300 6301 6302 6303
  var->value= (char *)&thd->net.compress;
  return 0;
}

6304
static int show_starttime(THD *thd, SHOW_VAR *var, char *buff)
6305
{
6306
  var->type= SHOW_LONG;
6307 6308 6309 6310 6311 6312
  var->value= buff;
  *((long *)buff)= (long) (thd->query_start() - start_time);
  return 0;
}

#ifdef HAVE_REPLICATION
6313
static int show_rpl_status(THD *thd, SHOW_VAR *var, char *buff)
6314
{
6315
  var->type= SHOW_CHAR;
6316 6317 6318 6319
  var->value= const_cast<char*>(rpl_status_type[(int)rpl_status]);
  return 0;
}

6320
static int show_slave_running(THD *thd, SHOW_VAR *var, char *buff)
6321
{
6322
  var->type= SHOW_CHAR;
6323 6324 6325 6326 6327 6328 6329
  pthread_mutex_lock(&LOCK_active_mi);
  var->value= const_cast<char*>((active_mi && active_mi->slave_running &&
               active_mi->rli.slave_running) ? "ON" : "OFF");
  pthread_mutex_unlock(&LOCK_active_mi);
  return 0;
}

6330
static int show_slave_retried_trans(THD *thd, SHOW_VAR *var, char *buff)
6331 6332 6333 6334 6335 6336 6337 6338
{
  /*
    TODO: with multimaster, have one such counter per line in
    SHOW SLAVE STATUS, and have the sum over all lines here.
  */
  pthread_mutex_lock(&LOCK_active_mi);
  if (active_mi)
  {
6339
    var->type= SHOW_LONG;
6340 6341 6342 6343 6344 6345
    var->value= buff;
    pthread_mutex_lock(&active_mi->rli.data_lock);
    *((long *)buff)= (long)active_mi->rli.retried_trans;
    pthread_mutex_unlock(&active_mi->rli.data_lock);
  }
  else
6346
    var->type= SHOW_UNDEF;
6347 6348 6349 6350 6351
  pthread_mutex_unlock(&LOCK_active_mi);
  return 0;
}
#endif /* HAVE_REPLICATION */

6352
static int show_open_tables(THD *thd, SHOW_VAR *var, char *buff)
6353
{
6354
  var->type= SHOW_LONG;
6355 6356 6357 6358 6359
  var->value= buff;
  *((long *)buff)= (long)cached_open_tables();
  return 0;
}

6360
static int show_table_definitions(THD *thd, SHOW_VAR *var, char *buff)
6361
{
6362
  var->type= SHOW_LONG;
6363 6364 6365 6366 6367 6368 6369
  var->value= buff;
  *((long *)buff)= (long)cached_table_definitions();
  return 0;
}

#ifdef HAVE_OPENSSL
/* Functions relying on CTX */
6370
static int show_ssl_ctx_sess_accept(THD *thd, SHOW_VAR *var, char *buff)
6371
{
6372
  var->type= SHOW_LONG;
6373 6374 6375 6376 6377 6378
  var->value= buff;
  *((long *)buff)= (!ssl_acceptor_fd ? 0 :
                     SSL_CTX_sess_accept(ssl_acceptor_fd->ssl_context));
  return 0;
}

6379
static int show_ssl_ctx_sess_accept_good(THD *thd, SHOW_VAR *var, char *buff)
6380
{
6381
  var->type= SHOW_LONG;
6382 6383 6384 6385 6386 6387
  var->value= buff;
  *((long *)buff)= (!ssl_acceptor_fd ? 0 :
                     SSL_CTX_sess_accept_good(ssl_acceptor_fd->ssl_context));
  return 0;
}

6388
static int show_ssl_ctx_sess_connect_good(THD *thd, SHOW_VAR *var, char *buff)
6389
{
6390
  var->type= SHOW_LONG;
6391 6392 6393 6394 6395 6396
  var->value= buff;
  *((long *)buff)= (!ssl_acceptor_fd ? 0 :
                     SSL_CTX_sess_connect_good(ssl_acceptor_fd->ssl_context));
  return 0;
}

6397
static int show_ssl_ctx_sess_accept_renegotiate(THD *thd, SHOW_VAR *var, char *buff)
6398
{
6399
  var->type= SHOW_LONG;
6400 6401 6402 6403 6404 6405
  var->value= buff;
  *((long *)buff)= (!ssl_acceptor_fd ? 0 :
                     SSL_CTX_sess_accept_renegotiate(ssl_acceptor_fd->ssl_context));
  return 0;
}

6406
static int show_ssl_ctx_sess_connect_renegotiate(THD *thd, SHOW_VAR *var, char *buff)
6407
{
6408
  var->type= SHOW_LONG;
6409 6410 6411 6412 6413 6414
  var->value= buff;
  *((long *)buff)= (!ssl_acceptor_fd ? 0 :
                     SSL_CTX_sess_connect_renegotiate(ssl_acceptor_fd->ssl_context));
  return 0;
}

6415
static int show_ssl_ctx_sess_cb_hits(THD *thd, SHOW_VAR *var, char *buff)
6416
{
6417
  var->type= SHOW_LONG;
6418 6419 6420 6421 6422 6423
  var->value= buff;
  *((long *)buff)= (!ssl_acceptor_fd ? 0 :
                     SSL_CTX_sess_cb_hits(ssl_acceptor_fd->ssl_context));
  return 0;
}

6424
static int show_ssl_ctx_sess_hits(THD *thd, SHOW_VAR *var, char *buff)
6425
{
6426
  var->type= SHOW_LONG;
6427 6428 6429 6430 6431 6432
  var->value= buff;
  *((long *)buff)= (!ssl_acceptor_fd ? 0 :
                     SSL_CTX_sess_hits(ssl_acceptor_fd->ssl_context));
  return 0;
}

6433
static int show_ssl_ctx_sess_cache_full(THD *thd, SHOW_VAR *var, char *buff)
6434
{
6435
  var->type= SHOW_LONG;
6436 6437 6438 6439 6440 6441
  var->value= buff;
  *((long *)buff)= (!ssl_acceptor_fd ? 0 :
                     SSL_CTX_sess_cache_full(ssl_acceptor_fd->ssl_context));
  return 0;
}

6442
static int show_ssl_ctx_sess_misses(THD *thd, SHOW_VAR *var, char *buff)
6443
{
6444
  var->type= SHOW_LONG;
6445 6446 6447 6448 6449 6450
  var->value= buff;
  *((long *)buff)= (!ssl_acceptor_fd ? 0 :
                     SSL_CTX_sess_misses(ssl_acceptor_fd->ssl_context));
  return 0;
}

6451
static int show_ssl_ctx_sess_timeouts(THD *thd, SHOW_VAR *var, char *buff)
6452
{
6453
  var->type= SHOW_LONG;
6454 6455 6456 6457 6458 6459
  var->value= buff;
  *((long *)buff)= (!ssl_acceptor_fd ? 0 :
                     SSL_CTX_sess_timeouts(ssl_acceptor_fd->ssl_context));
  return 0;
}

6460
static int show_ssl_ctx_sess_number(THD *thd, SHOW_VAR *var, char *buff)
6461
{
6462
  var->type= SHOW_LONG;
6463 6464 6465 6466 6467 6468
  var->value= buff;
  *((long *)buff)= (!ssl_acceptor_fd ? 0 :
                     SSL_CTX_sess_number(ssl_acceptor_fd->ssl_context));
  return 0;
}

6469
static int show_ssl_ctx_sess_connect(THD *thd, SHOW_VAR *var, char *buff)
6470
{
6471
  var->type= SHOW_LONG;
6472 6473 6474 6475 6476 6477
  var->value= buff;
  *((long *)buff)= (!ssl_acceptor_fd ? 0 :
                     SSL_CTX_sess_connect(ssl_acceptor_fd->ssl_context));
  return 0;
}

6478
static int show_ssl_ctx_sess_get_cache_size(THD *thd, SHOW_VAR *var, char *buff)
6479
{
6480
  var->type= SHOW_LONG;
6481 6482 6483 6484 6485 6486
  var->value= buff;
  *((long *)buff)= (!ssl_acceptor_fd ? 0 :
                     SSL_CTX_sess_get_cache_size(ssl_acceptor_fd->ssl_context));
  return 0;
}

6487
static int show_ssl_ctx_get_verify_mode(THD *thd, SHOW_VAR *var, char *buff)
6488
{
6489
  var->type= SHOW_LONG;
6490 6491 6492 6493 6494 6495
  var->value= buff;
  *((long *)buff)= (!ssl_acceptor_fd ? 0 :
                     SSL_CTX_get_verify_mode(ssl_acceptor_fd->ssl_context));
  return 0;
}

6496
static int show_ssl_ctx_get_verify_depth(THD *thd, SHOW_VAR *var, char *buff)
6497
{
6498
  var->type= SHOW_LONG;
6499 6500 6501 6502 6503 6504
  var->value= buff;
  *((long *)buff)= (!ssl_acceptor_fd ? 0 :
                     SSL_CTX_get_verify_depth(ssl_acceptor_fd->ssl_context));
  return 0;
}

6505
static int show_ssl_ctx_get_session_cache_mode(THD *thd, SHOW_VAR *var, char *buff)
6506
{
6507
  var->type= SHOW_CHAR;
6508
  if (!ssl_acceptor_fd)
unknown's avatar
unknown committed
6509
    var->value= const_cast<char*>("NONE");
6510 6511 6512 6513
  else
    switch (SSL_CTX_get_session_cache_mode(ssl_acceptor_fd->ssl_context))
    {
    case SSL_SESS_CACHE_OFF:
unknown's avatar
unknown committed
6514
      var->value= const_cast<char*>("OFF"); break;
6515
    case SSL_SESS_CACHE_CLIENT:
unknown's avatar
unknown committed
6516
      var->value= const_cast<char*>("CLIENT"); break;
6517
    case SSL_SESS_CACHE_SERVER:
unknown's avatar
unknown committed
6518
      var->value= const_cast<char*>("SERVER"); break;
6519
    case SSL_SESS_CACHE_BOTH:
unknown's avatar
unknown committed
6520
      var->value= const_cast<char*>("BOTH"); break;
6521
    case SSL_SESS_CACHE_NO_AUTO_CLEAR:
unknown's avatar
unknown committed
6522
      var->value= const_cast<char*>("NO_AUTO_CLEAR"); break;
6523
    case SSL_SESS_CACHE_NO_INTERNAL_LOOKUP:
unknown's avatar
unknown committed
6524
      var->value= const_cast<char*>("NO_INTERNAL_LOOKUP"); break;
6525
    default:
unknown's avatar
unknown committed
6526
      var->value= const_cast<char*>("Unknown"); break;
6527 6528 6529 6530 6531
    }
  return 0;
}

/* Functions relying on SSL */
6532
static int show_ssl_get_version(THD *thd, SHOW_VAR *var, char *buff)
6533
{
6534
  var->type= SHOW_CHAR;
6535 6536 6537 6538 6539
  var->value= const_cast<char*>(thd->net.vio->ssl_arg ?
        SSL_get_version((SSL*) thd->net.vio->ssl_arg) : "");
  return 0;
}

6540
static int show_ssl_session_reused(THD *thd, SHOW_VAR *var, char *buff)
6541
{
6542
  var->type= SHOW_LONG;
6543 6544 6545 6546
  var->value= buff;
  *((long *)buff)= (long)thd->net.vio->ssl_arg ?
                         SSL_session_reused((SSL*) thd->net.vio->ssl_arg) :
                         0;
unknown's avatar
unknown committed
6547
  return 0;
6548 6549
}

6550
static int show_ssl_get_default_timeout(THD *thd, SHOW_VAR *var, char *buff)
6551
{
6552
  var->type= SHOW_LONG;
6553 6554 6555 6556 6557 6558 6559
  var->value= buff;
  *((long *)buff)= (long)thd->net.vio->ssl_arg ?
                         SSL_get_default_timeout((SSL*)thd->net.vio->ssl_arg) :
                         0;
  return 0;
}

6560
static int show_ssl_get_verify_mode(THD *thd, SHOW_VAR *var, char *buff)
6561
{
6562
  var->type= SHOW_LONG;
6563 6564 6565 6566 6567 6568 6569
  var->value= buff;
  *((long *)buff)= (long)thd->net.vio->ssl_arg ?
                         SSL_get_verify_mode((SSL*)thd->net.vio->ssl_arg) :
                         0;
  return 0;
}

6570
static int show_ssl_get_verify_depth(THD *thd, SHOW_VAR *var, char *buff)
6571
{
6572
  var->type= SHOW_LONG;
6573 6574 6575 6576 6577 6578 6579
  var->value= buff;
  *((long *)buff)= (long)thd->net.vio->ssl_arg ?
                         SSL_get_verify_depth((SSL*)thd->net.vio->ssl_arg) :
                         0;
  return 0;
}

6580
static int show_ssl_get_cipher(THD *thd, SHOW_VAR *var, char *buff)
6581
{
6582
  var->type= SHOW_CHAR;
6583 6584 6585 6586 6587
  var->value= const_cast<char*>(thd->net.vio->ssl_arg ?
              SSL_get_cipher((SSL*) thd->net.vio->ssl_arg) : "");
  return 0;
}

6588
static int show_ssl_get_cipher_list(THD *thd, SHOW_VAR *var, char *buff)
6589
{
6590
  var->type= SHOW_CHAR;
6591 6592 6593 6594 6595
  var->value= buff;
  if (thd->net.vio->ssl_arg)
  {
    int i;
    const char *p;
6596 6597 6598
    char *end= buff + SHOW_VAR_FUNC_BUFF_SIZE;
    for (i=0; (p= SSL_get_cipher_list((SSL*) thd->net.vio->ssl_arg,i)) &&
               buff < end; i++)
6599
    {
6600
      buff= strnmov(buff, p, end-buff-1);
6601 6602 6603 6604 6605 6606 6607 6608 6609 6610 6611 6612 6613
      *buff++= ':';
    }
    if (i)
      buff--;
  }
  *buff=0;
  return 0;
}

#endif /* HAVE_OPENSSL */

#ifdef WITH_INNOBASE_STORAGE_ENGINE
int innodb_export_status(void);
6614
static int show_innodb_vars(THD *thd, SHOW_VAR *var, char *buff)
6615 6616 6617 6618 6619 6620 6621
{
  innodb_export_status();
  var->type= SHOW_ARRAY;
  var->value= (char *) &innodb_status_variables;
  return 0;
}
#endif
6622

6623
SHOW_VAR status_vars[]= {
6624 6625
  {"Aborted_clients",          (char*) &aborted_threads,        SHOW_LONG},
  {"Aborted_connects",         (char*) &aborted_connects,       SHOW_LONG},
6626 6627
  {"Binlog_cache_disk_use",    (char*) &binlog_cache_disk_use,  SHOW_LONG},
  {"Binlog_cache_use",         (char*) &binlog_cache_use,       SHOW_LONG},
unknown's avatar
Merge  
unknown committed
6628 6629 6630 6631
  {"Bytes_received",           (char*) offsetof(STATUS_VAR, bytes_received), SHOW_LONG_STATUS},
  {"Bytes_sent",               (char*) offsetof(STATUS_VAR, bytes_sent), SHOW_LONG_STATUS},
  {"Com_admin_commands",       (char*) offsetof(STATUS_VAR, com_other), SHOW_LONG_STATUS},
  {"Com_alter_db",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_ALTER_DB]), SHOW_LONG_STATUS},
6632
  {"Com_alter_event",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_ALTER_EVENT]), SHOW_LONG_STATUS},
unknown's avatar
Merge  
unknown committed
6633 6634 6635 6636 6637 6638 6639 6640 6641 6642
  {"Com_alter_table",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_ALTER_TABLE]), SHOW_LONG_STATUS},
  {"Com_analyze",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_ANALYZE]), SHOW_LONG_STATUS},
  {"Com_backup_table",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_BACKUP_TABLE]), SHOW_LONG_STATUS},
  {"Com_begin",		       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_BEGIN]), SHOW_LONG_STATUS},
  {"Com_change_db",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_CHANGE_DB]), SHOW_LONG_STATUS},
  {"Com_change_master",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_CHANGE_MASTER]), SHOW_LONG_STATUS},
  {"Com_check",		       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_CHECK]), SHOW_LONG_STATUS},
  {"Com_checksum",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_CHECKSUM]), SHOW_LONG_STATUS},
  {"Com_commit",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_COMMIT]), SHOW_LONG_STATUS},
  {"Com_create_db",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_CREATE_DB]), SHOW_LONG_STATUS},
6643
  {"Com_create_event",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_CREATE_EVENT]), SHOW_LONG_STATUS},
unknown's avatar
Merge  
unknown committed
6644 6645 6646 6647 6648 6649 6650 6651
  {"Com_create_function",      (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_CREATE_FUNCTION]), SHOW_LONG_STATUS},
  {"Com_create_index",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_CREATE_INDEX]), SHOW_LONG_STATUS},
  {"Com_create_table",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_CREATE_TABLE]), SHOW_LONG_STATUS},
  {"Com_dealloc_sql",          (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_DEALLOCATE_PREPARE]), SHOW_LONG_STATUS},
  {"Com_delete",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_DELETE]), SHOW_LONG_STATUS},
  {"Com_delete_multi",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_DELETE_MULTI]), SHOW_LONG_STATUS},
  {"Com_do",                   (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_DO]), SHOW_LONG_STATUS},
  {"Com_drop_db",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_DROP_DB]), SHOW_LONG_STATUS},
6652
  {"Com_drop_event",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_DROP_EVENT]), SHOW_LONG_STATUS},
unknown's avatar
Merge  
unknown committed
6653 6654 6655 6656
  {"Com_drop_function",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_DROP_FUNCTION]), SHOW_LONG_STATUS},
  {"Com_drop_index",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_DROP_INDEX]), SHOW_LONG_STATUS},
  {"Com_drop_table",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_DROP_TABLE]), SHOW_LONG_STATUS},
  {"Com_drop_user",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_DROP_USER]), SHOW_LONG_STATUS},
6657
  {"Com_execute_sql",          (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_EXECUTE]), SHOW_LONG_STATUS},
unknown's avatar
Merge  
unknown committed
6658 6659 6660 6661 6662 6663 6664 6665 6666 6667 6668 6669 6670 6671 6672 6673 6674 6675 6676 6677 6678 6679 6680 6681 6682 6683 6684 6685 6686 6687 6688
  {"Com_flush",		       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_FLUSH]), SHOW_LONG_STATUS},
  {"Com_grant",		       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_GRANT]), SHOW_LONG_STATUS},
  {"Com_ha_close",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_HA_CLOSE]), SHOW_LONG_STATUS},
  {"Com_ha_open",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_HA_OPEN]), SHOW_LONG_STATUS},
  {"Com_ha_read",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_HA_READ]), SHOW_LONG_STATUS},
  {"Com_help",                 (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_HELP]), SHOW_LONG_STATUS},
  {"Com_insert",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_INSERT]), SHOW_LONG_STATUS},
  {"Com_insert_select",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_INSERT_SELECT]), SHOW_LONG_STATUS},
  {"Com_kill",		       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_KILL]), SHOW_LONG_STATUS},
  {"Com_load",		       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_LOAD]), SHOW_LONG_STATUS},
  {"Com_load_master_data",     (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_LOAD_MASTER_DATA]), SHOW_LONG_STATUS},
  {"Com_load_master_table",    (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_LOAD_MASTER_TABLE]), SHOW_LONG_STATUS},
  {"Com_lock_tables",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_LOCK_TABLES]), SHOW_LONG_STATUS},
  {"Com_optimize",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_OPTIMIZE]), SHOW_LONG_STATUS},
  {"Com_preload_keys",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_PRELOAD_KEYS]), SHOW_LONG_STATUS},
  {"Com_prepare_sql",          (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_PREPARE]), SHOW_LONG_STATUS},
  {"Com_purge",		       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_PURGE]), SHOW_LONG_STATUS},
  {"Com_purge_before_date",    (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_PURGE_BEFORE]), SHOW_LONG_STATUS},
  {"Com_rename_table",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_RENAME_TABLE]), SHOW_LONG_STATUS},
  {"Com_repair",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_REPAIR]), SHOW_LONG_STATUS},
  {"Com_replace",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_REPLACE]), SHOW_LONG_STATUS},
  {"Com_replace_select",       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_REPLACE_SELECT]), SHOW_LONG_STATUS},
  {"Com_reset",		       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_RESET]), SHOW_LONG_STATUS},
  {"Com_restore_table",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_RESTORE_TABLE]), SHOW_LONG_STATUS},
  {"Com_revoke",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_REVOKE]), SHOW_LONG_STATUS},
  {"Com_revoke_all",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_REVOKE_ALL]), SHOW_LONG_STATUS},
  {"Com_rollback",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_ROLLBACK]), SHOW_LONG_STATUS},
  {"Com_savepoint",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SAVEPOINT]), SHOW_LONG_STATUS},
  {"Com_select",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SELECT]), SHOW_LONG_STATUS},
  {"Com_set_option",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SET_OPTION]), SHOW_LONG_STATUS},
  {"Com_show_binlog_events",   (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_BINLOG_EVENTS]), SHOW_LONG_STATUS},
unknown's avatar
unknown committed
6689
  {"Com_show_binlogs",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_BINLOGS]), SHOW_LONG_STATUS},
unknown's avatar
Merge  
unknown committed
6690 6691 6692 6693
  {"Com_show_charsets",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_CHARSETS]), SHOW_LONG_STATUS},
  {"Com_show_collations",      (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_COLLATIONS]), SHOW_LONG_STATUS},
  {"Com_show_column_types",    (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_COLUMN_TYPES]), SHOW_LONG_STATUS},
  {"Com_show_create_db",       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_CREATE_DB]), SHOW_LONG_STATUS},
6694
  {"Com_show_create_event",    (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_CREATE_EVENT]), SHOW_LONG_STATUS},
unknown's avatar
unknown committed
6695
  {"Com_show_create_table",    (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_CREATE]), SHOW_LONG_STATUS},
unknown's avatar
Merge  
unknown committed
6696
  {"Com_show_databases",       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_DATABASES]), SHOW_LONG_STATUS},
6697 6698 6699
  {"Com_show_engine_logs",     (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_ENGINE_LOGS]), SHOW_LONG_STATUS},
  {"Com_show_engine_mutex",    (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_ENGINE_MUTEX]), SHOW_LONG_STATUS},
  {"Com_show_engine_status",   (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_ENGINE_STATUS]), SHOW_LONG_STATUS},
6700
  {"Com_show_events",          (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_EVENTS]), SHOW_LONG_STATUS},
unknown's avatar
Merge  
unknown committed
6701 6702 6703 6704 6705 6706 6707
  {"Com_show_errors",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_ERRORS]), SHOW_LONG_STATUS},
  {"Com_show_fields",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_FIELDS]), SHOW_LONG_STATUS},
  {"Com_show_grants",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_GRANTS]), SHOW_LONG_STATUS},
  {"Com_show_keys",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_KEYS]), SHOW_LONG_STATUS},
  {"Com_show_master_status",   (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_MASTER_STAT]), SHOW_LONG_STATUS},
  {"Com_show_new_master",      (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_NEW_MASTER]), SHOW_LONG_STATUS},
  {"Com_show_open_tables",     (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_OPEN_TABLES]), SHOW_LONG_STATUS},
unknown's avatar
unknown committed
6708
  {"Com_show_plugins",         (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_PLUGINS]), SHOW_LONG_STATUS},
unknown's avatar
Merge  
unknown committed
6709 6710 6711 6712 6713 6714 6715
  {"Com_show_privileges",      (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_PRIVILEGES]), SHOW_LONG_STATUS},
  {"Com_show_processlist",     (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_PROCESSLIST]), SHOW_LONG_STATUS},
  {"Com_show_slave_hosts",     (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_SLAVE_HOSTS]), SHOW_LONG_STATUS},
  {"Com_show_slave_status",    (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_SLAVE_STAT]), SHOW_LONG_STATUS},
  {"Com_show_status",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_STATUS]), SHOW_LONG_STATUS},
  {"Com_show_storage_engines", (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_STORAGE_ENGINES]), SHOW_LONG_STATUS},
  {"Com_show_tables",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_TABLES]), SHOW_LONG_STATUS},
6716
  {"Com_show_triggers",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_TRIGGERS]), SHOW_LONG_STATUS},
unknown's avatar
Merge  
unknown committed
6717 6718 6719 6720
  {"Com_show_variables",       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_VARIABLES]), SHOW_LONG_STATUS},
  {"Com_show_warnings",        (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_WARNS]), SHOW_LONG_STATUS},
  {"Com_slave_start",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SLAVE_START]), SHOW_LONG_STATUS},
  {"Com_slave_stop",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SLAVE_STOP]), SHOW_LONG_STATUS},
unknown's avatar
unknown committed
6721
  {"Com_stmt_close",           (char*) offsetof(STATUS_VAR, com_stmt_close), SHOW_LONG_STATUS},
unknown's avatar
unknown committed
6722 6723
  {"Com_stmt_execute",         (char*) offsetof(STATUS_VAR, com_stmt_execute), SHOW_LONG_STATUS},
  {"Com_stmt_fetch",           (char*) offsetof(STATUS_VAR, com_stmt_fetch), SHOW_LONG_STATUS},
unknown's avatar
unknown committed
6724
  {"Com_stmt_prepare",         (char*) offsetof(STATUS_VAR, com_stmt_prepare), SHOW_LONG_STATUS},
unknown's avatar
unknown committed
6725
  {"Com_stmt_reset",           (char*) offsetof(STATUS_VAR, com_stmt_reset), SHOW_LONG_STATUS},
unknown's avatar
unknown committed
6726
  {"Com_stmt_send_long_data",  (char*) offsetof(STATUS_VAR, com_stmt_send_long_data), SHOW_LONG_STATUS},
unknown's avatar
Merge  
unknown committed
6727 6728 6729 6730 6731 6732 6733 6734 6735 6736
  {"Com_truncate",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_TRUNCATE]), SHOW_LONG_STATUS},
  {"Com_unlock_tables",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_UNLOCK_TABLES]), SHOW_LONG_STATUS},
  {"Com_update",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_UPDATE]), SHOW_LONG_STATUS},
  {"Com_update_multi",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_UPDATE_MULTI]), SHOW_LONG_STATUS},
  {"Com_xa_commit",            (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_XA_COMMIT]),SHOW_LONG_STATUS},
  {"Com_xa_end",               (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_XA_END]),SHOW_LONG_STATUS},
  {"Com_xa_prepare",           (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_XA_PREPARE]),SHOW_LONG_STATUS},
  {"Com_xa_recover",           (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_XA_RECOVER]),SHOW_LONG_STATUS},
  {"Com_xa_rollback",          (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_XA_ROLLBACK]),SHOW_LONG_STATUS},
  {"Com_xa_start",             (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_XA_START]),SHOW_LONG_STATUS},
6737
  {"Compression",              (char*) &show_net_compression, SHOW_FUNC},
6738
  {"Connections",              (char*) &thread_id,              SHOW_LONG_NOFLUSH},
unknown's avatar
Merge  
unknown committed
6739
  {"Created_tmp_disk_tables",  (char*) offsetof(STATUS_VAR, created_tmp_disk_tables), SHOW_LONG_STATUS},
6740
  {"Created_tmp_files",	       (char*) &my_tmp_file_created,	SHOW_LONG},
unknown's avatar
Merge  
unknown committed
6741
  {"Created_tmp_tables",       (char*) offsetof(STATUS_VAR, created_tmp_tables), SHOW_LONG_STATUS},
6742
  {"Delayed_errors",           (char*) &delayed_insert_errors,  SHOW_LONG},
6743
  {"Delayed_insert_threads",   (char*) &delayed_insert_threads, SHOW_LONG_NOFLUSH},
6744
  {"Delayed_writes",           (char*) &delayed_insert_writes,  SHOW_LONG},
6745
  {"Flush_commands",           (char*) &refresh_version,        SHOW_LONG_NOFLUSH},
unknown's avatar
Merge  
unknown committed
6746 6747 6748 6749 6750 6751 6752 6753 6754 6755 6756 6757 6758 6759 6760
  {"Handler_commit",           (char*) offsetof(STATUS_VAR, ha_commit_count), SHOW_LONG_STATUS},
  {"Handler_delete",           (char*) offsetof(STATUS_VAR, ha_delete_count), SHOW_LONG_STATUS},
  {"Handler_discover",         (char*) offsetof(STATUS_VAR, ha_discover_count), SHOW_LONG_STATUS},
  {"Handler_prepare",          (char*) offsetof(STATUS_VAR, ha_prepare_count),  SHOW_LONG_STATUS},
  {"Handler_read_first",       (char*) offsetof(STATUS_VAR, ha_read_first_count), SHOW_LONG_STATUS},
  {"Handler_read_key",         (char*) offsetof(STATUS_VAR, ha_read_key_count), SHOW_LONG_STATUS},
  {"Handler_read_next",        (char*) offsetof(STATUS_VAR, ha_read_next_count), SHOW_LONG_STATUS},
  {"Handler_read_prev",        (char*) offsetof(STATUS_VAR, ha_read_prev_count), SHOW_LONG_STATUS},
  {"Handler_read_rnd",         (char*) offsetof(STATUS_VAR, ha_read_rnd_count), SHOW_LONG_STATUS},
  {"Handler_read_rnd_next",    (char*) offsetof(STATUS_VAR, ha_read_rnd_next_count), SHOW_LONG_STATUS},
  {"Handler_rollback",         (char*) offsetof(STATUS_VAR, ha_rollback_count), SHOW_LONG_STATUS},
  {"Handler_savepoint",        (char*) offsetof(STATUS_VAR, ha_savepoint_count), SHOW_LONG_STATUS},
  {"Handler_savepoint_rollback",(char*) offsetof(STATUS_VAR, ha_savepoint_rollback_count), SHOW_LONG_STATUS},
  {"Handler_update",           (char*) offsetof(STATUS_VAR, ha_update_count), SHOW_LONG_STATUS},
  {"Handler_write",            (char*) offsetof(STATUS_VAR, ha_write_count), SHOW_LONG_STATUS},
6761
#ifdef WITH_INNOBASE_STORAGE_ENGINE
6762
  {"Innodb",                   (char*) &show_innodb_vars, SHOW_FUNC},
6763
#endif /* WITH_INNOBASE_STORAGE_ENGINE */
6764
  {"Key_blocks_not_flushed",   (char*) offsetof(KEY_CACHE, global_blocks_changed), SHOW_KEY_CACHE_LONG},
6765 6766
  {"Key_blocks_unused",        (char*) offsetof(KEY_CACHE, blocks_unused), SHOW_KEY_CACHE_LONG},
  {"Key_blocks_used",          (char*) offsetof(KEY_CACHE, blocks_used), SHOW_KEY_CACHE_LONG},
6767 6768 6769 6770
  {"Key_read_requests",        (char*) offsetof(KEY_CACHE, global_cache_r_requests), SHOW_KEY_CACHE_LONGLONG},
  {"Key_reads",                (char*) offsetof(KEY_CACHE, global_cache_read), SHOW_KEY_CACHE_LONGLONG},
  {"Key_write_requests",       (char*) offsetof(KEY_CACHE, global_cache_w_requests), SHOW_KEY_CACHE_LONGLONG},
  {"Key_writes",               (char*) offsetof(KEY_CACHE, global_cache_write), SHOW_KEY_CACHE_LONGLONG},
6771
  {"Last_query_cost",          (char*) offsetof(STATUS_VAR, last_query_cost), SHOW_DOUBLE_STATUS},
6772
  {"Max_used_connections",     (char*) &max_used_connections,  SHOW_LONG},
6773
#ifdef WITH_NDBCLUSTER_STORAGE_ENGINE
6774
  {"Ndb",                      (char*) &ndb_status_variables,   SHOW_ARRAY},
6775
#endif /* WITH_NDBCLUSTER_STORAGE_ENGINE */
6776 6777 6778
  {"Not_flushed_delayed_rows", (char*) &delayed_rows_in_use,    SHOW_LONG_NOFLUSH},
  {"Open_files",               (char*) &my_file_opened,         SHOW_LONG_NOFLUSH},
  {"Open_streams",             (char*) &my_stream_opened,       SHOW_LONG_NOFLUSH},
6779 6780
  {"Open_table_definitions",   (char*) &show_table_definitions, SHOW_FUNC},
  {"Open_tables",              (char*) &show_open_tables,       SHOW_FUNC},
unknown's avatar
Merge  
unknown committed
6781
  {"Opened_tables",            (char*) offsetof(STATUS_VAR, opened_tables), SHOW_LONG_STATUS},
unknown's avatar
unknown committed
6782
#ifdef HAVE_QUERY_CACHE
6783 6784
  {"Qcache_free_blocks",       (char*) &query_cache.free_memory_blocks, SHOW_LONG_NOFLUSH},
  {"Qcache_free_memory",       (char*) &query_cache.free_memory, SHOW_LONG_NOFLUSH},
unknown's avatar
unknown committed
6785
  {"Qcache_hits",              (char*) &query_cache.hits,       SHOW_LONG},
6786
  {"Qcache_inserts",           (char*) &query_cache.inserts,    SHOW_LONG},
6787
  {"Qcache_lowmem_prunes",     (char*) &query_cache.lowmem_prunes, SHOW_LONG},
unknown's avatar
unknown committed
6788
  {"Qcache_not_cached",        (char*) &query_cache.refused,    SHOW_LONG},
6789 6790
  {"Qcache_queries_in_cache",  (char*) &query_cache.queries_in_cache, SHOW_LONG_NOFLUSH},
  {"Qcache_total_blocks",      (char*) &query_cache.total_blocks, SHOW_LONG_NOFLUSH},
unknown's avatar
unknown committed
6791
#endif /*HAVE_QUERY_CACHE*/
6792 6793 6794 6795
  {"Questions",                (char*) &show_question,            SHOW_FUNC},
#ifdef HAVE_REPLICATION
  {"Rpl_status",               (char*) &show_rpl_status,          SHOW_FUNC},
#endif
unknown's avatar
Merge  
unknown committed
6796 6797 6798 6799 6800
  {"Select_full_join",         (char*) offsetof(STATUS_VAR, select_full_join_count), SHOW_LONG_STATUS},
  {"Select_full_range_join",   (char*) offsetof(STATUS_VAR, select_full_range_join_count), SHOW_LONG_STATUS},
  {"Select_range",             (char*) offsetof(STATUS_VAR, select_range_count), SHOW_LONG_STATUS},
  {"Select_range_check",       (char*) offsetof(STATUS_VAR, select_range_check_count), SHOW_LONG_STATUS},
  {"Select_scan",	       (char*) offsetof(STATUS_VAR, select_scan_count), SHOW_LONG_STATUS},
6801
  {"Slave_open_temp_tables",   (char*) &slave_open_temp_tables, SHOW_LONG},
6802 6803 6804 6805
#ifdef HAVE_REPLICATION
  {"Slave_retried_transactions",(char*) &show_slave_retried_trans, SHOW_FUNC},
  {"Slave_running",            (char*) &show_slave_running,     SHOW_FUNC},
#endif
6806
  {"Slow_launch_threads",      (char*) &slow_launch_threads,    SHOW_LONG},
unknown's avatar
Merge  
unknown committed
6807 6808 6809 6810 6811
  {"Slow_queries",             (char*) offsetof(STATUS_VAR, long_query_count), SHOW_LONG_STATUS},
  {"Sort_merge_passes",	       (char*) offsetof(STATUS_VAR, filesort_merge_passes), SHOW_LONG_STATUS},
  {"Sort_range",	       (char*) offsetof(STATUS_VAR, filesort_range_count), SHOW_LONG_STATUS},
  {"Sort_rows",		       (char*) offsetof(STATUS_VAR, filesort_rows), SHOW_LONG_STATUS},
  {"Sort_scan",		       (char*) offsetof(STATUS_VAR, filesort_scan_count), SHOW_LONG_STATUS},
unknown's avatar
unknown committed
6812
#ifdef HAVE_OPENSSL
6813 6814 6815 6816 6817 6818 6819 6820 6821 6822 6823 6824 6825 6826 6827 6828 6829 6830 6831 6832 6833 6834 6835
  {"Ssl_accept_renegotiates",  (char*) &show_ssl_ctx_sess_accept_renegotiate, SHOW_FUNC},
  {"Ssl_accepts",              (char*) &show_ssl_ctx_sess_accept, SHOW_FUNC},
  {"Ssl_callback_cache_hits",  (char*) &show_ssl_ctx_sess_cb_hits, SHOW_FUNC},
  {"Ssl_cipher",               (char*) &show_ssl_get_cipher, SHOW_FUNC},
  {"Ssl_cipher_list",          (char*) &show_ssl_get_cipher_list, SHOW_FUNC},
  {"Ssl_client_connects",      (char*) &show_ssl_ctx_sess_connect, SHOW_FUNC},
  {"Ssl_connect_renegotiates", (char*) &show_ssl_ctx_sess_connect_renegotiate, SHOW_FUNC},
  {"Ssl_ctx_verify_depth",     (char*) &show_ssl_ctx_get_verify_depth, SHOW_FUNC},
  {"Ssl_ctx_verify_mode",      (char*) &show_ssl_ctx_get_verify_mode, SHOW_FUNC},
  {"Ssl_default_timeout",      (char*) &show_ssl_get_default_timeout, SHOW_FUNC},
  {"Ssl_finished_accepts",     (char*) &show_ssl_ctx_sess_accept_good, SHOW_FUNC},
  {"Ssl_finished_connects",    (char*) &show_ssl_ctx_sess_connect_good, SHOW_FUNC},
  {"Ssl_session_cache_hits",   (char*) &show_ssl_ctx_sess_hits, SHOW_FUNC},
  {"Ssl_session_cache_misses", (char*) &show_ssl_ctx_sess_misses, SHOW_FUNC},
  {"Ssl_session_cache_mode",   (char*) &show_ssl_ctx_get_session_cache_mode, SHOW_FUNC},
  {"Ssl_session_cache_overflows", (char*) &show_ssl_ctx_sess_cache_full, SHOW_FUNC},
  {"Ssl_session_cache_size",   (char*) &show_ssl_ctx_sess_get_cache_size, SHOW_FUNC},
  {"Ssl_session_cache_timeouts", (char*) &show_ssl_ctx_sess_timeouts, SHOW_FUNC},
  {"Ssl_sessions_reused",      (char*) &show_ssl_session_reused, SHOW_FUNC},
  {"Ssl_used_session_cache_entries",(char*) &show_ssl_ctx_sess_number, SHOW_FUNC},
  {"Ssl_verify_depth",         (char*) &show_ssl_get_verify_depth, SHOW_FUNC},
  {"Ssl_verify_mode",          (char*) &show_ssl_get_verify_mode, SHOW_FUNC},
  {"Ssl_version",              (char*) &show_ssl_get_version, SHOW_FUNC},
unknown's avatar
unknown committed
6836
#endif /* HAVE_OPENSSL */
unknown's avatar
unknown committed
6837 6838
  {"Table_locks_immediate",    (char*) &locks_immediate,        SHOW_LONG},
  {"Table_locks_waited",       (char*) &locks_waited,           SHOW_LONG},
6839
#ifdef HAVE_MMAP
unknown's avatar
Merge  
unknown committed
6840 6841 6842
  {"Tc_log_max_pages_used",    (char*) &tc_log_max_pages_used,  SHOW_LONG},
  {"Tc_log_page_size",         (char*) &tc_log_page_size,       SHOW_LONG},
  {"Tc_log_page_waits",        (char*) &tc_log_page_waits,      SHOW_LONG},
6843
#endif
6844 6845 6846 6847
  {"Threads_cached",           (char*) &cached_thread_count,    SHOW_LONG_NOFLUSH},
  {"Threads_connected",        (char*) &thread_count,           SHOW_INT},
  {"Threads_created",	       (char*) &thread_created,		SHOW_LONG_NOFLUSH},
  {"Threads_running",          (char*) &thread_running,         SHOW_INT},
6848
  {"Uptime",                   (char*) &show_starttime,         SHOW_FUNC},
6849
  {NullS, NullS, SHOW_LONG}
unknown's avatar
unknown committed
6850 6851 6852 6853
};

static void print_version(void)
{
6854
  set_server_version();
6855 6856 6857 6858
  /*
    Note: the instance manager keys off the string 'Ver' so it can find the
    version from the output of 'mysqld --version', so don't change it!
  */
6859 6860
  printf("%s  Ver %s for %s on %s (%s)\n",my_progname,
	 server_version,SYSTEM_TYPE,MACHINE_TYPE, MYSQL_COMPILATION_COMMENT);
unknown's avatar
unknown committed
6861 6862 6863 6864
}

static void usage(void)
{
6865
  if (!(default_charset_info= get_charset_by_csname(default_character_set_name,
unknown's avatar
unknown committed
6866 6867 6868 6869 6870
					           MY_CS_PRIMARY,
						   MYF(MY_WME))))
    exit(1);
  if (!default_collation_name)
    default_collation_name= (char*) default_charset_info->name;
unknown's avatar
unknown committed
6871
  print_version();
unknown's avatar
unknown committed
6872 6873 6874
  puts("\
Copyright (C) 2000 MySQL AB, by Monty and others\n\
This software comes with ABSOLUTELY NO WARRANTY. This is free software,\n\
6875 6876
and you are welcome to modify and redistribute it under the GPL license\n\n\
Starts the MySQL database server\n");
unknown's avatar
unknown committed
6877 6878

  printf("Usage: %s [OPTIONS]\n", my_progname);
6879 6880 6881 6882
  if (!opt_verbose)
    puts("\nFor more help options (several pages), use mysqld --verbose --help\n");
  else
  {
unknown's avatar
unknown committed
6883 6884
#ifdef __WIN__
  puts("NT and Win32 specific options:\n\
6885 6886
  --install                     Install the default service (NT)\n\
  --install-manual              Install the default service started manually (NT)\n\
unknown's avatar
unknown committed
6887 6888
  --install service_name        Install an optional service (NT)\n\
  --install-manual service_name Install an optional service started manually (NT)\n\
6889
  --remove                      Remove the default service from the service list (NT)\n\
unknown's avatar
unknown committed
6890 6891 6892
  --remove service_name         Remove the service_name from the service list (NT)\n\
  --enable-named-pipe           Only to be used for the	default server (NT)\n\
  --standalone                  Dummy option to start as a standalone server (NT)\
unknown's avatar
unknown committed
6893
");
6894
  puts("");
unknown's avatar
unknown committed
6895
#endif
6896
  print_defaults(MYSQL_CONFIG_NAME,load_default_groups);
unknown's avatar
unknown committed
6897 6898 6899
  puts("");
  fix_paths();
  set_ports();
6900 6901 6902 6903

  my_print_help(my_long_options);
  my_print_variables(my_long_options);

unknown's avatar
unknown committed
6904
  puts("\n\
unknown's avatar
unknown committed
6905
To see what values a running MySQL server is using, type\n\
6906 6907
'mysqladmin variables' instead of 'mysqld --verbose --help'.\n");
  }
unknown's avatar
unknown committed
6908 6909 6910
}


unknown's avatar
unknown committed
6911 6912 6913 6914 6915 6916 6917 6918 6919 6920 6921
/*
  Initialize all MySQL global variables to default values

  SYNOPSIS
    mysql_init_variables()

  NOTES
    The reason to set a lot of global variables to zero is to allow one to
    restart the embedded server with a clean environment
    It's also needed on some exotic platforms where global variables are
    not set to 0 when a program starts.
unknown's avatar
unknown committed
6922

unknown's avatar
unknown committed
6923 6924 6925
    We don't need to set numeric variables refered to in my_long_options
    as these are initialized by my_getopt.
*/
unknown's avatar
unknown committed
6926

unknown's avatar
unknown committed
6927 6928 6929 6930 6931
static void mysql_init_variables(void)
{
  /* Things reset to zero */
  opt_skip_slave_start= opt_reckless_slave = 0;
  mysql_home[0]= pidfile_name[0]= log_error_file[0]= 0;
6932
  opt_log= opt_update_log= opt_slow_log= 0;
6933
  opt_bin_log= 0;
unknown's avatar
unknown committed
6934
  opt_disable_networking= opt_skip_show_db=0;
unknown's avatar
Merge  
unknown committed
6935 6936
  opt_logname= opt_update_logname= opt_binlog_index_name= opt_slow_logname= 0;
  opt_tc_log_file= (char *)"tc.log";      // no hostname in tc_log file name !
6937 6938
  opt_secure_auth= 0;
  opt_bootstrap= opt_myisam_log= 0;
unknown's avatar
unknown committed
6939 6940 6941 6942 6943 6944 6945 6946 6947 6948 6949 6950 6951
  mqh_used= 0;
  segfaulted= kill_in_progress= 0;
  cleanup_done= 0;
  defaults_argv= 0;
  server_id_supplied= 0;
  test_flags= select_errors= dropping_tables= ha_open_options=0;
  thread_count= thread_running= kill_cached_threads= wake_thread=0;
  slave_open_temp_tables= 0;
  cached_thread_count= 0;
  opt_endinfo= using_udf_functions= 0;
  opt_using_transactions= using_update_log= 0;
  abort_loop= select_thread_in_use= signal_thread_in_use= 0;
  ready_to_exit= shutdown_in_progress= grant_option= 0;
unknown's avatar
Merge  
unknown committed
6952
  aborted_threads= aborted_connects= 0;
unknown's avatar
unknown committed
6953 6954
  delayed_insert_threads= delayed_insert_writes= delayed_rows_in_use= 0;
  delayed_insert_errors= thread_created= 0;
unknown's avatar
Merge  
unknown committed
6955
  specialflag= 0;
6956
  binlog_cache_use=  binlog_cache_disk_use= 0;
unknown's avatar
unknown committed
6957 6958 6959
  max_used_connections= slow_launch_threads = 0;
  mysqld_user= mysqld_chroot= opt_init_file= opt_bin_logname = 0;
  errmesg= 0;
6960
  mysqld_unix_port= opt_mysql_tmpdir= my_bind_addr_str= NullS;
unknown's avatar
unknown committed
6961
  bzero((gptr) &mysql_tmpdir_list, sizeof(mysql_tmpdir_list));
unknown's avatar
Merge  
unknown committed
6962 6963
  bzero((char *) &global_status_var, sizeof(global_status_var));
  opt_large_pages= 0;
6964
  key_map_full.set_all();
unknown's avatar
unknown committed
6965

6966 6967 6968 6969 6970
  /* Character sets */
  system_charset_info= &my_charset_utf8_general_ci;
  files_charset_info= &my_charset_utf8_general_ci;
  national_charset_info= &my_charset_utf8_general_ci;
  table_alias_charset= &my_charset_bin;
unknown's avatar
unknown committed
6971
  character_set_filesystem= &my_charset_bin;
6972

6973 6974
  opt_date_time_formats[0]= opt_date_time_formats[1]= opt_date_time_formats[2]= 0;

unknown's avatar
unknown committed
6975 6976 6977 6978 6979 6980 6981 6982 6983
  /* Things with default values that are not zero */
  delay_key_write_options= (uint) DELAY_KEY_WRITE_ON;
  opt_specialflag= SPECIAL_ENGLISH;
  unix_sock= ip_sock= INVALID_SOCKET;
  mysql_home_ptr= mysql_home;
  pidfile_name_ptr= pidfile_name;
  log_error_file_ptr= log_error_file;
  language_ptr= language;
  mysql_data_home= mysql_real_data_home;
6984 6985
  thd_startup_options= (OPTION_AUTO_IS_NULL | OPTION_BIN_LOG |
                        OPTION_QUOTE_SHOW_CREATE | OPTION_SQL_NOTES);
unknown's avatar
unknown committed
6986 6987 6988
  protocol_version= PROTOCOL_VERSION;
  what_to_log= ~ (1L << (uint) COM_TIME);
  refresh_version= flush_version= 1L;	/* Increments on each reload */
unknown's avatar
unknown committed
6989
  query_id= thread_id= 1L;
unknown's avatar
unknown committed
6990 6991
  strmov(server_version, MYSQL_SERVER_VERSION);
  myisam_recover_options_str= sql_mode_str= "OFF";
6992
  myisam_stats_method_str= "nulls_unequal";
unknown's avatar
unknown committed
6993 6994 6995
  my_bind_addr = htonl(INADDR_ANY);
  threads.empty();
  thread_cache.empty();
6996
  key_caches.empty();
unknown's avatar
unknown committed
6997
  if (!(dflt_key_cache= get_or_create_key_cache(default_key_cache_base.str,
6998
					       default_key_cache_base.length)))
6999
    exit(1);
unknown's avatar
unknown committed
7000
  multi_keycache_init(); /* set key_cache_hash.default_value = dflt_key_cache */
unknown's avatar
unknown committed
7001 7002 7003 7004 7005 7006 7007 7008 7009 7010 7011 7012

  /* Set directory paths */
  strmake(language, LANGUAGE, sizeof(language)-1);
  strmake(mysql_real_data_home, get_relative_path(DATADIR),
	  sizeof(mysql_real_data_home)-1);
  mysql_data_home_buff[0]=FN_CURLIB;	// all paths are relative from here
  mysql_data_home_buff[1]=0;

  /* Replication parameters */
  master_user= (char*) "test";
  master_password= master_host= 0;
  master_info_file= (char*) "master.info",
unknown's avatar
unknown committed
7013 7014 7015
    relay_log_info_file= (char*) "relay-log.info";
  master_ssl_key= master_ssl_cert= master_ssl_ca= 
    master_ssl_capath= master_ssl_cipher= 0;
unknown's avatar
unknown committed
7016 7017 7018 7019 7020
  report_user= report_password = report_host= 0;	/* TO BE DELETED */
  opt_relay_logname= opt_relaylog_index_name= 0;

  /* Variables in libraries */
  charsets_dir= 0;
7021 7022
  default_character_set_name= (char*) MYSQL_DEFAULT_CHARSET_NAME;
  default_collation_name= (char*) MYSQL_DEFAULT_COLLATION_NAME;
7023
  sys_charset_system.value= (char*) system_charset_info->csname;
unknown's avatar
unknown committed
7024
  character_set_filesystem_name= (char*) "binary";
unknown's avatar
unknown committed
7025

unknown's avatar
unknown committed
7026
  /* Set default values for some option variables */
unknown's avatar
unknown committed
7027
  default_storage_engine_str= (char*) "MyISAM";
unknown's avatar
unknown committed
7028
  global_system_variables.table_type= &myisam_hton;
unknown's avatar
unknown committed
7029
  global_system_variables.tx_isolation= ISO_REPEATABLE_READ;
7030
  global_system_variables.select_limit= (ulonglong) HA_POS_ERROR;
unknown's avatar
unknown committed
7031
  max_system_variables.select_limit=    (ulonglong) HA_POS_ERROR;
7032
  global_system_variables.max_join_size= (ulonglong) HA_POS_ERROR;
unknown's avatar
unknown committed
7033
  max_system_variables.max_join_size=   (ulonglong) HA_POS_ERROR;
7034
  global_system_variables.old_passwords= 0;
unknown's avatar
unknown committed
7035
  global_system_variables.old_alter_table= 0;
7036
  global_system_variables.binlog_format= BINLOG_FORMAT_UNSPEC;
7037
  /*
7038
    Default behavior for 4.1 and 5.0 is to treat NULL values as unequal
7039 7040 7041
    when collecting index statistics for MyISAM tables.
  */
  global_system_variables.myisam_stats_method= MI_STATS_METHOD_NULLS_NOT_EQUAL;
unknown's avatar
unknown committed
7042

unknown's avatar
unknown committed
7043 7044 7045 7046 7047 7048
  /* Variables that depends on compile options */
#ifndef DBUG_OFF
  default_dbug_option=IF_WIN("d:t:i:O,\\mysqld.trace",
			     "d:t:i:o,/tmp/mysqld.trace");
#endif
  opt_error_log= IF_WIN(1,0);
7049 7050 7051 7052 7053
#ifdef HAVE_ROW_BASED_REPLICATION
  have_row_based_replication= SHOW_OPTION_YES;
#else
  have_row_based_replication= SHOW_OPTION_NO;
#endif
7054
#ifdef WITH_NDBCLUSTER_STORAGE_ENGINE
unknown's avatar
unknown committed
7055
  have_ndbcluster=SHOW_OPTION_DISABLED;
7056 7057 7058 7059 7060 7061
  global_system_variables.ndb_index_stat_enable=TRUE;
  max_system_variables.ndb_index_stat_enable=TRUE;
  global_system_variables.ndb_index_stat_cache_entries=32;
  max_system_variables.ndb_index_stat_cache_entries=~0L;
  global_system_variables.ndb_index_stat_update_freq=20;
  max_system_variables.ndb_index_stat_update_freq=~0L;
unknown's avatar
unknown committed
7062 7063 7064
#else
  have_ndbcluster=SHOW_OPTION_NO;
#endif
unknown's avatar
unknown committed
7065 7066 7067 7068 7069
#ifdef HAVE_OPENSSL
  have_openssl=SHOW_OPTION_YES;
#else
  have_openssl=SHOW_OPTION_NO;
#endif
unknown's avatar
unknown committed
7070
#ifdef HAVE_BROKEN_REALPATH
unknown's avatar
unknown committed
7071 7072 7073 7074
  have_symlink=SHOW_OPTION_NO;
#else
  have_symlink=SHOW_OPTION_YES;
#endif
7075 7076 7077 7078 7079
#ifdef HAVE_DLOPEN
  have_dlopen=SHOW_OPTION_YES;
#else
  have_dlopen=SHOW_OPTION_NO;
#endif
unknown's avatar
unknown committed
7080 7081 7082 7083 7084
#ifdef HAVE_QUERY_CACHE
  have_query_cache=SHOW_OPTION_YES;
#else
  have_query_cache=SHOW_OPTION_NO;
#endif
7085 7086 7087 7088 7089 7090 7091 7092 7093 7094
#ifdef HAVE_SPATIAL
  have_geometry=SHOW_OPTION_YES;
#else
  have_geometry=SHOW_OPTION_NO;
#endif
#ifdef HAVE_RTREE_KEYS
  have_rtree_keys=SHOW_OPTION_YES;
#else
  have_rtree_keys=SHOW_OPTION_NO;
#endif
unknown's avatar
unknown committed
7095 7096 7097 7098 7099 7100
#ifdef HAVE_CRYPT
  have_crypt=SHOW_OPTION_YES;
#else
  have_crypt=SHOW_OPTION_NO;
#endif
#ifdef HAVE_COMPRESS
7101
  have_compress= SHOW_OPTION_YES;
unknown's avatar
unknown committed
7102
#else
7103
  have_compress= SHOW_OPTION_NO;
unknown's avatar
unknown committed
7104 7105 7106 7107 7108 7109 7110 7111 7112 7113 7114 7115 7116 7117 7118
#endif
#ifdef HAVE_LIBWRAP
  libwrapName= NullS;
#endif
#ifdef HAVE_OPENSSL
  des_key_file = 0;
  ssl_acceptor_fd= 0;
#endif
#ifdef HAVE_SMEM
  shared_memory_base_name= default_shared_memory_base_name;
#endif
#if !defined(my_pthread_setprio) && !defined(HAVE_PTHREAD_SETSCHEDPARAM)
  opt_specialflag |= SPECIAL_NO_PRIOR;
#endif

unknown's avatar
unknown committed
7119 7120
#if defined(__WIN__) || defined(__NETWARE__)
  /* Allow Win32 and NetWare users to move MySQL anywhere */
unknown's avatar
unknown committed
7121 7122 7123 7124 7125 7126 7127 7128
  {
    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;
unknown's avatar
unknown committed
7129
  if (!(tmpenv = getenv("MY_BASEDIR_VERSION")))
unknown's avatar
unknown committed
7130
    tmpenv = DEFAULT_MYSQL_HOME;
unknown's avatar
unknown committed
7131
  (void) strmake(mysql_home, tmpenv, sizeof(mysql_home)-1);
unknown's avatar
unknown committed
7132 7133 7134 7135
#endif
}


unknown's avatar
unknown committed
7136
static my_bool
7137 7138
get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
	       char *argument)
unknown's avatar
unknown committed
7139
{
7140 7141
  switch(optid) {
  case '#':
7142
#ifndef DBUG_OFF
unknown's avatar
unknown committed
7143 7144
    DBUG_SET(argument ? argument : default_dbug_option);
    DBUG_SET_INITIAL(argument ? argument : default_dbug_option);
7145 7146 7147 7148
#endif
    opt_endinfo=1;				/* unireg: memory allocation */
    break;
  case 'a':
7149
    global_system_variables.sql_mode= fix_sql_mode(MODE_ANSI);
unknown's avatar
unknown committed
7150
    global_system_variables.tx_isolation= ISO_SERIALIZABLE;
7151 7152 7153 7154
    break;
  case 'b':
    strmake(mysql_home,argument,sizeof(mysql_home)-1);
    break;
7155
  case 'C':
unknown's avatar
unknown committed
7156
    default_collation_name= 0;
7157
    break;
7158 7159 7160 7161 7162
  case 'l':
    opt_log=1;
    break;
  case 'h':
    strmake(mysql_real_data_home,argument, sizeof(mysql_real_data_home)-1);
7163 7164
    /* Correct pointer set by my_getopt (for embedded library) */
    mysql_data_home= mysql_real_data_home;
7165
    break;
7166
  case 'u':
7167
    if (!mysqld_user || !strcmp(mysqld_user, argument))
unknown's avatar
unknown committed
7168
      mysqld_user= argument;
7169
    else
7170
      sql_print_warning("Ignoring user change to '%s' because the user was set to '%s' earlier on the command line\n", argument, mysqld_user);
7171
    break;
7172 7173 7174
  case 'L':
    strmake(language, argument, sizeof(language)-1);
    break;
unknown's avatar
SCRUM  
unknown committed
7175
#ifdef HAVE_REPLICATION
7176 7177 7178
  case OPT_SLAVE_SKIP_ERRORS:
    init_slave_skip_errors(argument);
    break;
7179
#endif
7180
  case OPT_SAFEMALLOC_MEM_LIMIT:
7181
#if !defined(DBUG_OFF) && defined(SAFEMALLOC)
7182
    sf_malloc_mem_limit = atoi(argument);
7183
#endif
7184
    break;
7185
#include <sslopt-case.h>
7186 7187 7188
  case 'V':
    print_version();
    exit(0);
7189 7190 7191 7192 7193 7194 7195 7196
  case 'W':
    if (!argument)
      global_system_variables.log_warnings++;
    else if (argument == disabled_my_option)
      global_system_variables.log_warnings= 0L;
    else
      global_system_variables.log_warnings= atoi(argument);
    break;
7197 7198
  case 'T':
    test_flags= argument ? (uint) atoi(argument) : 0;
7199
    test_flags&= ~TEST_NO_THREADS;
7200 7201 7202 7203 7204 7205 7206 7207 7208 7209 7210 7211
    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;
    break;
  case (int) OPT_UPDATE_LOG:
    opt_update_log=1;
    break;
  case (int) OPT_BIN_LOG:
7212
    opt_bin_log= test(argument != disabled_my_option);
7213
    break;
7214 7215 7216
  case (int) OPT_ERROR_LOG_FILE:
    opt_error_log= 1;
    break;
unknown's avatar
SCRUM  
unknown committed
7217
#ifdef HAVE_REPLICATION
7218
  case (int) OPT_INIT_RPL_ROLE:
7219 7220 7221
  {
    int role;
    if ((role=find_type(argument, &rpl_role_typelib, 2)) <= 0)
7222
    {
7223 7224
      fprintf(stderr, "Unknown replication role: %s\n", argument);
      exit(1);
7225
    }
7226 7227 7228
    rpl_status = (role == 1) ?  RPL_AUTH_MASTER : RPL_IDLE_SLAVE;
    break;
  }
7229
  case (int)OPT_REPLICATE_IGNORE_DB:
7230
  {
7231
    rpl_filter->add_ignore_db(argument);
7232 7233 7234 7235
    break;
  }
  case (int)OPT_REPLICATE_DO_DB:
  {
7236
    rpl_filter->add_do_db(argument);
7237 7238 7239 7240 7241
    break;
  }
  case (int)OPT_REPLICATE_REWRITE_DB:
  {
    char* key = argument,*p, *val;
7242

7243
    if (!(p= strstr(argument, "->")))
7244
    {
7245 7246 7247
      fprintf(stderr,
	      "Bad syntax in replicate-rewrite-db - missing '->'!\n");
      exit(1);
7248
    }
7249
    val= p--;
unknown's avatar
unknown committed
7250
    while (my_isspace(mysqld_charset, *p) && p > argument)
7251 7252
      *p-- = 0;
    if (p == argument)
7253
    {
7254 7255 7256
      fprintf(stderr,
	      "Bad syntax in replicate-rewrite-db - empty FROM db!\n");
      exit(1);
7257
    }
7258 7259
    *val= 0;
    val+= 2;
unknown's avatar
unknown committed
7260
    while (*val && my_isspace(mysqld_charset, *val))
7261 7262
      *val++;
    if (!*val)
7263
    {
7264 7265 7266
      fprintf(stderr,
	      "Bad syntax in replicate-rewrite-db - empty TO db!\n");
      exit(1);
7267 7268
    }

7269
    rpl_filter->add_db_rewrite(key, val);
7270 7271 7272
    break;
  }

7273
  case (int)OPT_BINLOG_IGNORE_DB:
7274
  {
7275
    binlog_filter->add_ignore_db(argument);
7276 7277
    break;
  }
7278 7279 7280 7281 7282 7283 7284 7285
  case OPT_BINLOG_FORMAT:
  {
    int id;
    if ((id= find_type(argument, &binlog_format_typelib, 2)) <= 0)
    {
#ifdef HAVE_ROW_BASED_REPLICATION
      fprintf(stderr, 
	      "Unknown binary log format: '%s' "
7286
	      "(should be one of '%s', '%s', '%s')\n", 
7287
	      argument,
7288 7289 7290
              binlog_format_names[BINLOG_FORMAT_STMT],
              binlog_format_names[BINLOG_FORMAT_ROW],
              binlog_format_names[BINLOG_FORMAT_MIXED]);
7291 7292 7293
#else
      fprintf(stderr, 
	      "Unknown binary log format: '%s' (only legal value is '%s')\n", 
7294
	      argument, binlog_format_names[BINLOG_FORMAT_STMT]);
7295 7296 7297
#endif
      exit(1);
    }
7298
    global_system_variables.binlog_format= id-1;
7299 7300
    break;
  }
7301
  case (int)OPT_BINLOG_DO_DB:
7302
  {
7303
    binlog_filter->add_do_db(argument);
7304 7305
    break;
  }
7306
  case (int)OPT_REPLICATE_DO_TABLE:
7307
  {
7308
    if (rpl_filter->add_do_table(argument))
7309
    {
7310 7311
      fprintf(stderr, "Could not add do table rule '%s'!\n", argument);
      exit(1);
7312
    }
7313 7314
    break;
  }
7315
  case (int)OPT_REPLICATE_WILD_DO_TABLE:
7316
  {
7317
    if (rpl_filter->add_wild_do_table(argument))
7318
    {
7319 7320
      fprintf(stderr, "Could not add do table rule '%s'!\n", argument);
      exit(1);
7321
    }
7322 7323
    break;
  }
7324
  case (int)OPT_REPLICATE_WILD_IGNORE_TABLE:
7325
  {
7326
    if (rpl_filter->add_wild_ignore_table(argument))
7327
    {
7328 7329
      fprintf(stderr, "Could not add ignore table rule '%s'!\n", argument);
      exit(1);
7330
    }
7331 7332
    break;
  }
7333
  case (int)OPT_REPLICATE_IGNORE_TABLE:
7334
  {
7335
    if (rpl_filter->add_ignore_table(argument))
7336
    {
7337 7338
      fprintf(stderr, "Could not add ignore table rule '%s'!\n", argument);
      exit(1);
7339
    }
7340 7341
    break;
  }
unknown's avatar
SCRUM  
unknown committed
7342
#endif /* HAVE_REPLICATION */
7343
  case (int) OPT_SLOW_QUERY_LOG:
7344
    opt_slow_log= 1;
7345
    break;
7346
#ifdef WITH_CSV_STORAGE_ENGINE
7347 7348 7349 7350 7351 7352 7353 7354 7355 7356 7357
  case  OPT_LOG_OUTPUT:
  {
    if (!argument || !argument[0])
    {
      log_output_options= LOG_TABLE;
      log_output_str= log_output_typelib.type_names[1];
    }
    else
    {
      log_output_str= argument;
      if ((log_output_options=
7358
           find_bit_type(argument, &log_output_typelib)) == ~(ulong) 0)
7359
      {
7360 7361
        fprintf(stderr, "Unknown option to log-output: %s\n", argument);
        exit(1);
7362 7363
      }
    }
7364
    break;
7365
  }
7366
#endif
7367 7368 7369 7370 7371 7372 7373 7374 7375 7376 7377 7378 7379 7380 7381 7382 7383 7384
  case OPT_EVENT_SCHEDULER:
    if (!argument)
      Events::opt_event_scheduler= 2;
    else
    {
      int type;
      if ((type=find_type(argument, &Events::opt_typelib, 1)) <= 0)
      {
	fprintf(stderr,"Unknown option to event-scheduler: %s\n",argument);
	exit(1);
      }
      /* 
        type=  1     2      3   4     5    6
             (OFF |  0) - (ON | 1) - (2 | SUSPEND)
      */
      Events::opt_event_scheduler= (type-1) / 2;
    }
    break;
7385 7386
  case (int) OPT_SKIP_NEW:
    opt_specialflag|= SPECIAL_NO_NEW_FUNC;
7387
    delay_key_write_options= (uint) DELAY_KEY_WRITE_NONE;
7388 7389
    myisam_concurrent_insert=0;
    myisam_recover_options= HA_RECOVER_NONE;
unknown's avatar
Merge  
unknown committed
7390
    sp_automatic_privileges=0;
7391
    my_use_symdir=0;
7392
    ha_open_options&= ~(HA_OPEN_ABORT_IF_CRASHED | HA_OPEN_DELAY_KEY_WRITE);
unknown's avatar
unknown committed
7393
#ifdef HAVE_QUERY_CACHE
7394 7395 7396 7397 7398
    query_cache_size=0;
#endif
    break;
  case (int) OPT_SAFE:
    opt_specialflag|= SPECIAL_SAFE_MODE;
7399
    delay_key_write_options= (uint) DELAY_KEY_WRITE_NONE;
7400 7401
    myisam_recover_options= HA_RECOVER_DEFAULT;
    ha_open_options&= ~(HA_OPEN_DELAY_KEY_WRITE);
7402 7403 7404 7405 7406
    break;
  case (int) OPT_SKIP_PRIOR:
    opt_specialflag|= SPECIAL_NO_PRIOR;
    break;
  case (int) OPT_SKIP_LOCK:
7407
    opt_external_locking=0;
7408 7409 7410 7411 7412 7413 7414 7415
    break;
  case (int) OPT_SKIP_HOST_CACHE:
    opt_specialflag|= SPECIAL_NO_HOST_CACHE;
    break;
  case (int) OPT_SKIP_RESOLVE:
    opt_specialflag|=SPECIAL_NO_RESOLVE;
    break;
  case (int) OPT_SKIP_NETWORKING:
unknown's avatar
unknown committed
7416 7417 7418
#if defined(__NETWARE__)
    sql_perror("Can't start server: skip-networking option is currently not supported on NetWare");
    exit(1);
7419
#endif
7420
    opt_disable_networking=1;
7421
    mysqld_port=0;
7422 7423 7424 7425 7426
    break;
  case (int) OPT_SKIP_SHOW_DB:
    opt_skip_show_db=1;
    opt_specialflag|=SPECIAL_SKIP_SHOW_DB;
    break;
7427
#ifdef ONE_THREAD
7428 7429
  case (int) OPT_ONE_THREAD:
    test_flags |= TEST_NO_THREADS;
7430
#endif
7431 7432 7433 7434 7435 7436 7437 7438 7439 7440 7441
    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_use_symdir=0;
    break;
  case (int) OPT_BIND_ADDRESS:
unknown's avatar
unknown committed
7442
    if ((my_bind_addr= (ulong) inet_addr(argument)) == INADDR_NONE)
7443 7444
    {
      struct hostent *ent;
unknown's avatar
unknown committed
7445
      if (argument[0])
7446
	ent=gethostbyname(argument);
unknown's avatar
unknown committed
7447 7448
      else
      {
7449 7450
	char myhostname[255];
	if (gethostname(myhostname,sizeof(myhostname)) < 0)
unknown's avatar
unknown committed
7451
	{
7452
	  sql_perror("Can't start server: cannot get my own hostname!");
unknown's avatar
unknown committed
7453 7454
	  exit(1);
	}
7455
	ent=gethostbyname(myhostname);
unknown's avatar
unknown committed
7456
      }
7457 7458 7459 7460 7461 7462 7463 7464 7465 7466 7467
      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, argument, sizeof(pidfile_name)-1);
    break;
unknown's avatar
unknown committed
7468
#ifdef __WIN__
7469 7470
  case (int) OPT_STANDALONE:		/* Dummy option for NT */
    break;
unknown's avatar
unknown committed
7471
#endif
7472 7473 7474 7475
  case OPT_CONSOLE:
    if (opt_console)
      opt_error_log= 0;			// Force logs to stdout
    break;
7476 7477 7478 7479 7480 7481
  case (int) OPT_FLUSH:
    myisam_flush=1;
    flush_time=0;			// No auto flush
    break;
  case OPT_LOW_PRIORITY_UPDATES:
    thr_upgraded_concurrent_insert_lock= TL_WRITE_LOW_PRIORITY;
unknown's avatar
unknown committed
7482
    global_system_variables.low_priority_updates=1;
7483 7484 7485 7486 7487 7488 7489
    break;
  case OPT_BOOTSTRAP:
    opt_noacl=opt_bootstrap=1;
    break;
  case OPT_SERVER_ID:
    server_id_supplied = 1;
    break;
7490 7491 7492 7493
  case OPT_DELAY_KEY_WRITE_ALL:
    if (argument != disabled_my_option)
      argument= (char*) "ALL";
    /* Fall through */
7494
  case OPT_DELAY_KEY_WRITE:
7495 7496 7497 7498 7499 7500 7501 7502 7503 7504 7505 7506 7507 7508
    if (argument == disabled_my_option)
      delay_key_write_options= (uint) DELAY_KEY_WRITE_NONE;
    else if (! argument)
      delay_key_write_options= (uint) DELAY_KEY_WRITE_ON;
    else
    {
      int type;
      if ((type=find_type(argument, &delay_key_write_typelib, 2)) <= 0)
      {
	fprintf(stderr,"Unknown delay_key_write type: %s\n",argument);
	exit(1);
      }
      delay_key_write_options= (uint) type-1;
    }
7509 7510 7511 7512 7513 7514
    break;
  case OPT_CHARSETS_DIR:
    strmake(mysql_charsets_dir, argument, sizeof(mysql_charsets_dir)-1);
    charsets_dir = mysql_charsets_dir;
    break;
  case OPT_TX_ISOLATION:
7515 7516 7517
  {
    int type;
    if ((type=find_type(argument, &tx_isolation_typelib, 2)) <= 0)
unknown's avatar
unknown committed
7518
    {
7519 7520
      fprintf(stderr,"Unknown transaction isolation type: %s\n",argument);
      exit(1);
unknown's avatar
unknown committed
7521
    }
unknown's avatar
unknown committed
7522
    global_system_variables.tx_isolation= (type-1);
7523 7524
    break;
  }
7525
#ifdef WITH_BERKELEY_STORAGE_ENGINE
7526
  case OPT_BDB_NOSYNC:
7527 7528 7529 7530 7531
    /* Deprecated option */
    opt_sync_bdb_logs= 0;
    /* Fall through */
  case OPT_BDB_SYNC:
    if (!opt_sync_bdb_logs)
7532
      berkeley_env_flags|= bdb_DB_TXN_NOSYNC;
7533
    else
7534
      berkeley_env_flags&= ~bdb_DB_TXN_NOSYNC;
7535
    break;
7536 7537 7538 7539 7540 7541
  case OPT_BDB_LOG_DIRECT:
    berkeley_env_flags|= bdb_DB_DIRECT_DB;
    break;
  case OPT_BDB_DATA_DIRECT:
    berkeley_env_flags|= bdb_DB_DIRECT_LOG;
    break;
7542
  case OPT_BDB_NO_RECOVER:
7543
    berkeley_init_flags&= ~(bdb_DB_RECOVER);
7544 7545
    break;
  case OPT_BDB_LOCK:
7546 7547 7548 7549 7550
  {
    int type;
    if ((type=find_type(argument, &berkeley_lock_typelib, 2)) > 0)
      berkeley_lock_type=berkeley_lock_types[type-1];
    else
unknown's avatar
unknown committed
7551
    {
7552
      int err;
7553 7554
      char *end;
      uint length= strlen(argument);
unknown's avatar
unknown committed
7555
      long value= my_strntol(&my_charset_latin1, argument, length, 10, &end, &err);
unknown's avatar
Merge  
unknown committed
7556
      if (end == argument+length)
7557
	berkeley_lock_scan_time= value;
unknown's avatar
unknown committed
7558 7559
      else
      {
7560 7561
	fprintf(stderr,"Unknown lock type: %s\n",argument);
	exit(1);
unknown's avatar
unknown committed
7562 7563
      }
    }
7564 7565
    break;
  }
7566
  case OPT_BDB_SHARED:
7567
    berkeley_init_flags&= ~(bdb_DB_PRIVATE);
unknown's avatar
unknown committed
7568
    berkeley_shared_data= 1;
7569
    break;
7570
#endif /* WITH_BERKELEY_STORAGE_ENGINE */
7571
  case OPT_BDB:
7572
#ifdef WITH_BERKELEY_STORAGE_ENGINE
7573
    if (opt_bdb)
unknown's avatar
unknown committed
7574
      have_berkeley_db= SHOW_OPTION_YES;
7575
    else
unknown's avatar
unknown committed
7576
      have_berkeley_db= SHOW_OPTION_DISABLED;
unknown's avatar
unknown committed
7577 7578 7579
#endif
    break;
  case OPT_NDBCLUSTER:
7580
#ifdef WITH_NDBCLUSTER_STORAGE_ENGINE
unknown's avatar
unknown committed
7581
    if (opt_ndbcluster)
unknown's avatar
unknown committed
7582
      have_ndbcluster= SHOW_OPTION_YES;
unknown's avatar
unknown committed
7583
    else
unknown's avatar
unknown committed
7584
      have_ndbcluster= SHOW_OPTION_DISABLED;
7585 7586
#endif
    break;
7587
#ifdef WITH_NDBCLUSTER_STORAGE_ENGINE
unknown's avatar
Merge  
unknown committed
7588 7589 7590 7591 7592 7593 7594 7595 7596 7597 7598 7599 7600 7601 7602 7603 7604 7605 7606 7607 7608 7609 7610
  case OPT_NDB_MGMD:
  case OPT_NDB_NODEID:
  {
    int len= my_snprintf(opt_ndb_constrbuf+opt_ndb_constrbuf_len,
			 sizeof(opt_ndb_constrbuf)-opt_ndb_constrbuf_len,
			 "%s%s%s",opt_ndb_constrbuf_len > 0 ? ",":"",
			 optid == OPT_NDB_NODEID ? "nodeid=" : "",
			 argument);
    opt_ndb_constrbuf_len+= len;
  }
  /* fall through to add the connectstring to the end
   * and set opt_ndbcluster_connectstring
   */
  case OPT_NDB_CONNECTSTRING:
    if (opt_ndb_connectstring && opt_ndb_connectstring[0])
      my_snprintf(opt_ndb_constrbuf+opt_ndb_constrbuf_len,
		  sizeof(opt_ndb_constrbuf)-opt_ndb_constrbuf_len,
		  "%s%s", opt_ndb_constrbuf_len > 0 ? ",":"",
		  opt_ndb_connectstring);
    else
      opt_ndb_constrbuf[opt_ndb_constrbuf_len]= 0;
    opt_ndbcluster_connectstring= opt_ndb_constrbuf;
    break;
7611 7612 7613 7614 7615 7616 7617 7618 7619 7620 7621 7622 7623 7624
  case OPT_NDB_DISTRIBUTION:
    int id;
    if ((id= find_type(argument, &ndb_distribution_typelib, 2)) <= 0)
    {
      fprintf(stderr, 
	      "Unknown ndb distribution type: '%s' "
	      "(should be '%s' or '%s')\n", 
	      argument,
              ndb_distribution_names[ND_KEYHASH],
              ndb_distribution_names[ND_LINHASH]);
      exit(1);
    }
    opt_ndb_distribution_id= (enum ndb_distribution)(id-1);
    break;
unknown's avatar
unknown committed
7625 7626 7627 7628 7629 7630 7631 7632
  case OPT_NDB_EXTRA_LOGGING:
    if (!argument)
      ndb_extra_logging++;
    else if (argument == disabled_my_option)
      ndb_extra_logging= 0L;
    else
      ndb_extra_logging= atoi(argument);
    break;
unknown's avatar
Merge  
unknown committed
7633
#endif
7634
  case OPT_INNODB:
7635
#ifdef WITH_INNOBASE_STORAGE_ENGINE
7636
    if (opt_innodb)
unknown's avatar
unknown committed
7637
      have_innodb= SHOW_OPTION_YES;
7638
    else
unknown's avatar
unknown committed
7639
      have_innodb= SHOW_OPTION_DISABLED;
unknown's avatar
unknown committed
7640
#endif
7641 7642
    break;
  case OPT_INNODB_DATA_FILE_PATH:
7643
#ifdef WITH_INNOBASE_STORAGE_ENGINE
unknown's avatar
unknown committed
7644
    innobase_data_file_path= argument;
7645
#endif
7646
    break;
7647
#ifdef WITH_INNOBASE_STORAGE_ENGINE
7648 7649 7650
  case OPT_INNODB_LOG_ARCHIVE:
    innobase_log_archive= argument ? test(atoi(argument)) : 1;
    break;
7651
#endif /* WITH_INNOBASE_STORAGE_ENGINE */
7652
  case OPT_MYISAM_RECOVER:
7653 7654
  {
    if (!argument || !argument[0])
7655
    {
7656 7657
      myisam_recover_options=    HA_RECOVER_DEFAULT;
      myisam_recover_options_str= myisam_recover_typelib.type_names[0];
7658
    }
7659
    else
7660
    {
7661 7662 7663
      myisam_recover_options_str=argument;
      if ((myisam_recover_options=
	   find_bit_type(argument, &myisam_recover_typelib)) == ~(ulong) 0)
7664
      {
7665
	fprintf(stderr, "Unknown option to myisam-recover: %s\n",argument);
7666 7667 7668
	exit(1);
      }
    }
7669 7670 7671
    ha_open_options|=HA_OPEN_ABORT_IF_CRASHED;
    break;
  }
7672 7673 7674 7675 7676 7677 7678
  case OPT_CONCURRENT_INSERT:
    /* The following code is mainly here to emulate old behavior */
    if (!argument)                      /* --concurrent-insert */
      myisam_concurrent_insert= 1;
    else if (argument == disabled_my_option)
      myisam_concurrent_insert= 0;      /* --skip-concurrent-insert */
    break;
unknown's avatar
Merge  
unknown committed
7679 7680 7681 7682 7683 7684 7685 7686
  case OPT_TC_HEURISTIC_RECOVER:
  {
    if ((tc_heuristic_recover=find_type(argument,
                                        &tc_heuristic_recover_typelib, 2)) <=0)
    {
      fprintf(stderr, "Unknown option to tc-heuristic-recover: %s\n",argument);
      exit(1);
    }
unknown's avatar
unknown committed
7687
  }
7688 7689
  case OPT_MYISAM_STATS_METHOD:
  {
7690
    ulong method_conv;
7691
    int method;
unknown's avatar
unknown committed
7692 7693
    LINT_INIT(method_conv);

7694 7695 7696 7697 7698 7699
    myisam_stats_method_str= argument;
    if ((method=find_type(argument, &myisam_stats_method_typelib, 2)) <= 0)
    {
      fprintf(stderr, "Invalid value of myisam_stats_method: %s.\n", argument);
      exit(1);
    }
7700 7701 7702 7703 7704 7705 7706 7707 7708 7709 7710 7711
    switch (method-1) {
    case 0: 
      method_conv= MI_STATS_METHOD_NULLS_EQUAL;
      break;
    case 1:
      method_conv= MI_STATS_METHOD_NULLS_NOT_EQUAL;
      break;
    case 2:
      method_conv= MI_STATS_METHOD_IGNORE_NULLS;
      break;
    }
    global_system_variables.myisam_stats_method= method_conv;
unknown's avatar
Merge  
unknown committed
7712 7713
    break;
  }
7714 7715
  case OPT_SQL_MODE:
  {
7716 7717 7718
    sql_mode_str= argument;
    if ((global_system_variables.sql_mode=
         find_bit_type(argument, &sql_mode_typelib)) == ~(ulong) 0)
7719 7720 7721 7722
    {
      fprintf(stderr, "Unknown option to sql-mode: %s\n", argument);
      exit(1);
    }
7723 7724
    global_system_variables.sql_mode= fix_sql_mode(global_system_variables.
						   sql_mode);
unknown's avatar
unknown committed
7725
    break;
7726
  }
unknown's avatar
unknown committed
7727
  case OPT_FT_BOOLEAN_SYNTAX:
7728
    if (ft_boolean_check_syntax_string((byte*) argument))
unknown's avatar
unknown committed
7729 7730 7731 7732
    {
      fprintf(stderr, "Invalid ft-boolean-syntax string: %s\n", argument);
      exit(1);
    }
7733
    strmake(ft_boolean_syntax, argument, sizeof(ft_boolean_syntax)-1);
7734 7735
    break;
  case OPT_SKIP_SAFEMALLOC:
7736
#ifdef SAFEMALLOC
7737
    sf_malloc_quick=1;
7738
#endif
7739
    break;
unknown's avatar
unknown committed
7740 7741
  case OPT_LOWER_CASE_TABLE_NAMES:
    lower_case_table_names= argument ? atoi(argument) : 1;
7742
    lower_case_table_names_used= 1;
unknown's avatar
unknown committed
7743
    break;
unknown's avatar
unknown committed
7744
  }
7745 7746 7747
  return 0;
}
	/* Initiates DEBUG - but no debugging here ! */
7748

unknown's avatar
unknown committed
7749
static gptr *
7750
mysql_getopt_value(const char *keyname, uint key_length,
7751 7752
		   const struct my_option *option)
{
7753 7754
  switch (option->id) {
  case OPT_KEY_BUFFER_SIZE:
unknown's avatar
unknown committed
7755
  case OPT_KEY_CACHE_BLOCK_SIZE:
7756 7757
  case OPT_KEY_CACHE_DIVISION_LIMIT:
  case OPT_KEY_CACHE_AGE_THRESHOLD:
7758
  {
unknown's avatar
unknown committed
7759
    KEY_CACHE *key_cache;
7760 7761
    if (!(key_cache= get_or_create_key_cache(keyname, key_length)))
      exit(1);
7762 7763
    switch (option->id) {
    case OPT_KEY_BUFFER_SIZE:
unknown's avatar
unknown committed
7764
      return (gptr*) &key_cache->param_buff_size;
7765
    case OPT_KEY_CACHE_BLOCK_SIZE:
unknown's avatar
unknown committed
7766
      return (gptr*) &key_cache->param_block_size;
7767
    case OPT_KEY_CACHE_DIVISION_LIMIT:
unknown's avatar
unknown committed
7768
      return (gptr*) &key_cache->param_division_limit;
7769
    case OPT_KEY_CACHE_AGE_THRESHOLD:
unknown's avatar
unknown committed
7770
      return (gptr*) &key_cache->param_age_threshold;
7771
    }
7772 7773
  }
  }
7774
 return option->value;
7775 7776
}

unknown's avatar
unknown committed
7777

unknown's avatar
unknown committed
7778
static void option_error_reporter(enum loglevel level, const char *format, ...)
unknown's avatar
unknown committed
7779
{
7780
  va_list args;
unknown's avatar
unknown committed
7781 7782 7783
  va_start(args, format);
  vprint_msg_to_log(level, format, args);
  va_end(args);
unknown's avatar
unknown committed
7784
}
7785

unknown's avatar
unknown committed
7786

7787 7788 7789 7790
static void get_options(int argc,char **argv)
{
  int ho_error;

7791
  my_getopt_register_get_addr(mysql_getopt_value);
7792
  strmake(def_ft_boolean_syntax, ft_boolean_syntax,
unknown's avatar
unknown committed
7793
	  sizeof(ft_boolean_syntax)-1);
7794
  my_getopt_error_reporter= option_error_reporter;
unknown's avatar
unknown committed
7795 7796
  if ((ho_error= handle_options(&argc, &argv, my_long_options,
                                get_one_option)))
7797
    exit(ho_error);
7798

7799
#ifndef WITH_NDBCLUSTER_STORAGE_ENGINE
7800 7801 7802
  if (opt_ndbcluster)
    sql_print_warning("this binary does not contain NDBCLUSTER storage engine");
#endif
7803
#ifndef WITH_INNOBASE_STORAGE_ENGINE
7804 7805 7806
  if (opt_innodb)
    sql_print_warning("this binary does not contain INNODB storage engine");
#endif
7807
#ifndef WITH_ISAM_STORAGE_ENGINE
7808 7809 7810
  if (opt_isam)
    sql_print_warning("this binary does not contain ISAM storage engine");
#endif
7811
#ifndef WITH_BERKELEY_STORAGE_ENGINE
7812 7813 7814
  if (opt_bdb)
    sql_print_warning("this binary does not contain BDB storage engine");
#endif
7815 7816 7817
  if ((opt_log_slow_admin_statements || opt_log_queries_not_using_indexes) &&
      !opt_slow_log)
    sql_print_warning("options --log-slow-admin-statements and --log-queries-not-using-indexes have no effect if --log-slow-queries is not set");
7818

7819 7820
  if (argc > 0)
  {
7821
    fprintf(stderr, "%s: Too many arguments (first extra is '%s').\nUse --help to get a list of available options\n", my_progname, *argv);
unknown's avatar
unknown committed
7822 7823
    /* FIXME add EXIT_TOO_MANY_ARGUMENTS to "mysys_err.h" and return that code? */
    exit(1);
7824
  }
7825

7826
  if (opt_help)
7827 7828 7829 7830
  {
    usage();
    exit(0);
  }
unknown's avatar
unknown committed
7831
#if defined(HAVE_BROKEN_REALPATH)
7832 7833 7834 7835 7836 7837 7838 7839 7840 7841
  my_use_symdir=0;
  my_disable_symlinks=1;
  have_symlink=SHOW_OPTION_NO;
#else
  if (!my_use_symdir)
  {
    my_disable_symlinks=1;
    have_symlink=SHOW_OPTION_DISABLED;
  }
#endif
7842 7843 7844 7845 7846 7847
  if (opt_debugging)
  {
    /* Allow break with SIGINT, no core or stack trace */
    test_flags|= TEST_SIGINT | TEST_NO_STACKTRACE;
    test_flags&= ~TEST_CORE_ON_SIGNAL;
  }
7848 7849 7850
  /* Set global MyISAM variables from delay_key_write_options */
  fix_delay_key_write((THD*) 0, OPT_GLOBAL);

7851
#ifndef EMBEDDED_LIBRARY
7852 7853
  if (mysqld_chroot)
    set_root(mysqld_chroot);
7854 7855 7856
#else
  max_allowed_packet= global_system_variables.max_allowed_packet;
  net_buffer_length= global_system_variables.net_buffer_length;
7857
#endif
unknown's avatar
unknown committed
7858
  fix_paths();
unknown's avatar
unknown committed
7859

unknown's avatar
unknown committed
7860 7861 7862 7863
  /*
    Set some global variables from the global_system_variables
    In most cases the global variables will not be used
  */
7864
  my_disable_locking= myisam_single_user= test(opt_external_locking == 0);
unknown's avatar
unknown committed
7865
  my_default_record_cache_size=global_system_variables.read_buff_size;
7866
  myisam_max_temp_length=
7867
    (my_off_t) global_system_variables.myisam_max_sort_file_size;
unknown's avatar
unknown committed
7868

unknown's avatar
unknown committed
7869
  /* Set global variables based on startup options */
unknown's avatar
unknown committed
7870
  myisam_block_size=(uint) 1 << my_bit_log2(opt_myisam_block_size);
unknown's avatar
unknown committed
7871

7872 7873 7874 7875
  if (opt_short_log_format)
    opt_specialflag|= SPECIAL_SHORT_LOG_FORMAT;
  if (opt_log_queries_not_using_indexes)
    opt_specialflag|= SPECIAL_LOG_QUERIES_NOT_USING_INDEXES;
7876

7877
  if (init_global_datetime_format(MYSQL_TIMESTAMP_DATE,
7878
				  &global_system_variables.date_format) ||
7879
      init_global_datetime_format(MYSQL_TIMESTAMP_TIME,
7880
				  &global_system_variables.time_format) ||
7881
      init_global_datetime_format(MYSQL_TIMESTAMP_DATETIME,
7882 7883
				  &global_system_variables.datetime_format))
    exit(1);
7884

unknown's avatar
unknown committed
7885 7886 7887
}


7888 7889 7890 7891 7892 7893 7894 7895 7896 7897
/*
  Create version name for running mysqld version
  We automaticly add suffixes -debug, -embedded and -log to the version
  name to make the version more descriptive.
  (MYSQL_SERVER_SUFFIX is set by the compilation environment)
*/

static void set_server_version(void)
{
  char *end= strxmov(server_version, MYSQL_SERVER_VERSION,
7898
                     MYSQL_SERVER_SUFFIX_STR, NullS);
7899 7900 7901 7902
#ifdef EMBEDDED_LIBRARY
  end= strmov(end, "-embedded");
#endif
#ifndef DBUG_OFF
7903
  if (!strstr(MYSQL_SERVER_SUFFIX_STR, "-debug"))
7904 7905 7906 7907 7908 7909 7910
    end= strmov(end, "-debug");
#endif
  if (opt_log || opt_update_log || opt_slow_log || opt_bin_log)
    strmov(end, "-log");                        // This may slow down system
}


unknown's avatar
unknown committed
7911 7912 7913
static char *get_relative_path(const char *path)
{
  if (test_if_hard_path(path) &&
7914
      is_prefix(path,DEFAULT_MYSQL_HOME) &&
unknown's avatar
unknown committed
7915 7916
      strcmp(DEFAULT_MYSQL_HOME,FN_ROOTDIR))
  {
unknown's avatar
unknown committed
7917
    path+=(uint) strlen(DEFAULT_MYSQL_HOME);
unknown's avatar
unknown committed
7918 7919 7920 7921 7922 7923 7924
    while (*path == FN_LIBCHAR)
      path++;
  }
  return (char*) path;
}


7925 7926 7927 7928 7929 7930 7931 7932 7933 7934 7935 7936 7937 7938 7939 7940 7941 7942
/*
  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,
7943
		    MY_APPEND_EXT | MY_UNPACK_FILENAME | MY_SAFE_PATH);
7944 7945 7946
}


unknown's avatar
unknown committed
7947 7948
static void fix_paths(void)
{
7949
  char buff[FN_REFLEN],*pos;
7950
  convert_dirname(mysql_home,mysql_home,NullS);
7951
  /* Resolve symlinks to allow 'mysql_home' to be a relative symlink */
7952
  my_realpath(mysql_home,mysql_home,MYF(0));
7953 7954 7955 7956 7957 7958 7959
  /* Ensure that mysql_home ends in FN_LIBCHAR */
  pos=strend(mysql_home);
  if (pos[-1] != FN_LIBCHAR)
  {
    pos[0]= FN_LIBCHAR;
    pos[1]= 0;
  }
7960 7961
  convert_dirname(mysql_real_data_home,mysql_real_data_home,NullS);
  convert_dirname(language,language,NullS);
unknown's avatar
unknown committed
7962 7963 7964
  (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);
unknown's avatar
unknown committed
7965 7966
  (void) my_load_path(opt_plugin_dir, opt_plugin_dir_ptr ? opt_plugin_dir_ptr :
                                      get_relative_path(LIBDIR), mysql_home);
7967
  opt_plugin_dir_ptr= opt_plugin_dir;
unknown's avatar
unknown committed
7968

unknown's avatar
unknown committed
7969
  char *sharedir=get_relative_path(SHAREDIR);
unknown's avatar
unknown committed
7970
  if (test_if_hard_path(sharedir))
unknown's avatar
unknown committed
7971
    strmake(buff,sharedir,sizeof(buff)-1);		/* purecov: tested */
unknown's avatar
unknown committed
7972
  else
unknown's avatar
unknown committed
7973
    strxnmov(buff,sizeof(buff)-1,mysql_home,sharedir,NullS);
7974
  convert_dirname(buff,buff,NullS);
unknown's avatar
unknown committed
7975 7976 7977 7978 7979
  (void) my_load_path(language,language,buff);

  /* If --character-sets-dir isn't given, use shared library dir */
  if (charsets_dir != mysql_charsets_dir)
  {
unknown's avatar
unknown committed
7980 7981
    strxnmov(mysql_charsets_dir, sizeof(mysql_charsets_dir)-1, buff,
	     CHARSET_DIR, NullS);
unknown's avatar
unknown committed
7982
  }
unknown's avatar
unknown committed
7983
  (void) my_load_path(mysql_charsets_dir, mysql_charsets_dir, buff);
7984
  convert_dirname(mysql_charsets_dir, mysql_charsets_dir, NullS);
unknown's avatar
unknown committed
7985
  charsets_dir=mysql_charsets_dir;
unknown's avatar
unknown committed
7986

unknown's avatar
unknown committed
7987
  if (init_tmpdir(&mysql_tmpdir_list, opt_mysql_tmpdir))
unknown's avatar
unknown committed
7988
    exit(1);
unknown's avatar
SCRUM  
unknown committed
7989
#ifdef HAVE_REPLICATION
7990 7991
  if (!slave_load_tmpdir)
  {
unknown's avatar
unknown committed
7992 7993
    if (!(slave_load_tmpdir = (char*) my_strdup(mysql_tmpdir, MYF(MY_FAE))))
      exit(1);
7994
  }
7995
#endif /* HAVE_REPLICATION */
unknown's avatar
unknown committed
7996 7997 7998
}


7999 8000 8001 8002
/*
  Return a bitfield from a string of substrings separated by ','
  returns ~(ulong) 0 on error.
*/
8003 8004 8005 8006 8007 8008 8009 8010 8011 8012 8013 8014 8015 8016

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;
8017 8018 8019
  while (*pos == ' ') pos++;
  found_end= *pos == 0;
  while (!found_end)
8020 8021 8022 8023
  {
    if (!*(end=strcend(pos,',')))		/* Let end point at fieldend */
    {
      while (end > pos && end[-1] == ' ')
unknown's avatar
unknown committed
8024
	end--;					/* Skip end-space */
8025 8026 8027 8028 8029 8030 8031 8032
      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)
      {
unknown's avatar
unknown committed
8033 8034
	if (my_toupper(mysqld_charset,*i++) !=
            my_toupper(mysqld_charset,*j++))
8035
	  goto skip;
8036 8037 8038 8039 8040 8041 8042 8043 8044 8045 8046
      }
      found_int=bit;
      if (! *i)
      {
	found_count=1;
	break;
      }
      else if (j != pos)			// Half field found
      {
	found_count++;				// Could be one of two values
      }
8047
skip: ;
8048 8049 8050 8051 8052
    }
    if (found_count != 1)
      DBUG_RETURN(~(ulong) 0);				// No unique value
    found|=found_int;
    pos=end+1;
8053
  }
8054 8055 8056 8057 8058 8059

  DBUG_PRINT("exit",("bit-field: %ld",(ulong) found));
  DBUG_RETURN(found);
} /* find_bit_type */


8060 8061 8062 8063 8064 8065 8066 8067 8068 8069 8070 8071 8072 8073 8074 8075 8076 8077 8078
/*
  Check if file system used for databases is case insensitive

  SYNOPSIS
    test_if_case_sensitive()
    dir_name			Directory to test

  RETURN
    -1  Don't know (Test failed)
    0   File system is case sensitive
    1   File system is case insensitive
*/

static int test_if_case_insensitive(const char *dir_name)
{
  int result= 0;
  File file;
  char buff[FN_REFLEN], buff2[FN_REFLEN];
  MY_STAT stat_info;
8079
  DBUG_ENTER("test_if_case_insensitive");
8080 8081 8082 8083 8084 8085 8086 8087

  fn_format(buff, glob_hostname, dir_name, ".lower-test",
	    MY_UNPACK_FILENAME | MY_REPLACE_EXT | MY_REPLACE_DIR);
  fn_format(buff2, glob_hostname, dir_name, ".LOWER-TEST",
	    MY_UNPACK_FILENAME | MY_REPLACE_EXT | MY_REPLACE_DIR);
  (void) my_delete(buff2, MYF(0));
  if ((file= my_create(buff, 0666, O_RDWR, MYF(0))) < 0)
  {
8088
    sql_print_warning("Can't create test file %s", buff);
8089
    DBUG_RETURN(-1);
8090 8091 8092 8093 8094
  }
  my_close(file, MYF(0));
  if (my_stat(buff2, &stat_info, MYF(0)))
    result= 1;					// Can access file
  (void) my_delete(buff, MYF(MY_WME));
8095 8096
  DBUG_PRINT("exit", ("result: %d", result));
  DBUG_RETURN(result);
8097 8098 8099 8100 8101 8102 8103 8104 8105 8106 8107
}


/* Create file to store pid number */

static void create_pid_file()
{
  File file;
  if ((file = my_create(pidfile_name,0664,
			O_WRONLY | O_TRUNC, MYF(MY_WME))) >= 0)
  {
unknown's avatar
unknown committed
8108
    char buff[21], *end;
8109
    end= int10_to_str((long) getpid(), buff, 10);
unknown's avatar
unknown committed
8110
    *end++= '\n';
8111 8112 8113 8114 8115
    if (!my_write(file, (byte*) buff, (uint) (end-buff), MYF(MY_WME | MY_NABP)))
    {
      (void) my_close(file, MYF(0));
      return;
    }
8116 8117
    (void) my_close(file, MYF(0));
  }
8118
  sql_perror("Can't start server: can't create PID file");
unknown's avatar
foo1  
unknown committed
8119
  exit(1);
8120 8121 8122
}


8123 8124 8125 8126 8127 8128 8129 8130 8131
/* Clear most status variables */
void refresh_status(THD *thd)
{
  pthread_mutex_lock(&LOCK_status);

  /* We must update the global status before cleaning up the thread */
  add_to_status(&global_status_var, &thd->status_var);
  bzero((char*) &thd->status_var, sizeof(thd->status_var));

unknown's avatar
unknown committed
8132
  for (SHOW_VAR *ptr= status_vars; ptr->name; ptr++)
8133
  {
unknown's avatar
unknown committed
8134
    /* Note that SHOW_LONG_NOFLUSH variables are not reset */
8135 8136 8137 8138 8139 8140 8141 8142 8143 8144 8145 8146 8147 8148 8149 8150
    if (ptr->type == SHOW_LONG)
      *(ulong*) ptr->value= 0;
  }
  /* Reset the counters of all key caches (default and named). */
  process_key_caches(reset_key_cache_counters);
  pthread_mutex_unlock(&LOCK_status);

  /*
    Set max_used_connections to the number of currently open
    connections.  Lock LOCK_thread_count out of LOCK_status to avoid
    deadlocks.  Status reset becomes not atomic, but status data is
    not exact anyway.
  */
  pthread_mutex_lock(&LOCK_thread_count);
  max_used_connections= thread_count-delayed_insert_threads;
  pthread_mutex_unlock(&LOCK_thread_count);
8151 8152 8153
}


8154 8155 8156 8157 8158 8159 8160 8161 8162 8163 8164 8165 8166 8167 8168 8169 8170 8171 8172 8173 8174 8175 8176 8177 8178
/*****************************************************************************
  Instantiate have_xyx for missing storage engines
*****************************************************************************/
#undef have_berkeley_db
#undef have_innodb
#undef have_ndbcluster
#undef have_example_db
#undef have_archive_db
#undef have_csv_db
#undef have_federated_db
#undef have_partition_db
#undef have_blackhole_db

SHOW_COMP_OPTION have_berkeley_db= SHOW_OPTION_NO;
SHOW_COMP_OPTION have_innodb= SHOW_OPTION_NO;
SHOW_COMP_OPTION have_ndbcluster= SHOW_OPTION_NO;
SHOW_COMP_OPTION have_example_db= SHOW_OPTION_NO;
SHOW_COMP_OPTION have_archive_db= SHOW_OPTION_NO;
SHOW_COMP_OPTION have_csv_db= SHOW_OPTION_NO;
SHOW_COMP_OPTION have_federated_db= SHOW_OPTION_NO;
SHOW_COMP_OPTION have_partition_db= SHOW_OPTION_NO;
SHOW_COMP_OPTION have_blackhole_db= SHOW_OPTION_NO;

#ifndef WITH_BERKELEY_STORAGE_ENGINE
bool berkeley_shared_data;
8179
ulong berkeley_max_lock, berkeley_log_buffer_size;
8180
ulonglong berkeley_cache_size;
8181
ulong berkeley_region_size, berkeley_cache_parts;
8182 8183 8184 8185 8186 8187 8188
char *berkeley_home, *berkeley_tmpdir, *berkeley_logdir;
#endif

#ifndef WITH_INNOBASE_STORAGE_ENGINE
uint innobase_flush_log_at_trx_commit;
ulong innobase_fast_shutdown;
long innobase_mirrored_log_groups, innobase_log_files_in_group;
unknown's avatar
unknown committed
8189 8190 8191 8192
longlong innobase_log_file_size;
long innobase_log_buffer_size;
longlong innobase_buffer_pool_size;
long innobase_additional_mem_pool_size;
8193 8194 8195 8196 8197 8198 8199 8200 8201 8202 8203 8204 8205
long innobase_buffer_pool_awe_mem_mb;
long innobase_file_io_threads, innobase_lock_wait_timeout;
long innobase_force_recovery;
long innobase_open_files;
char *innobase_data_home_dir, *innobase_data_file_path;
char *innobase_log_group_home_dir, *innobase_log_arch_dir;
char *innobase_unix_file_flush_method;
my_bool innobase_log_archive,
        innobase_use_doublewrite,
        innobase_use_checksums,
        innobase_file_per_table,
        innobase_locks_unsafe_for_binlog;

8206
extern "C" {
8207 8208 8209 8210 8211 8212 8213 8214
ulong srv_max_buf_pool_modified_pct;
ulong srv_max_purge_lag;
ulong srv_auto_extend_increment;
ulong srv_n_spin_wait_rounds;
ulong srv_n_free_tickets_to_enter;
ulong srv_thread_sleep_delay;
ulong srv_thread_concurrency;
ulong srv_commit_concurrency;
8215 8216
}

8217 8218 8219 8220
#endif

#ifndef WITH_NDBCLUSTER_STORAGE_ENGINE
ulong ndb_cache_check_time;
unknown's avatar
unknown committed
8221
ulong ndb_extra_logging;
8222 8223
#endif

unknown's avatar
unknown committed
8224
/*****************************************************************************
8225
  Instantiate templates
unknown's avatar
unknown committed
8226 8227
*****************************************************************************/

8228
#ifdef HAVE_EXPLICIT_TEMPLATE_INSTANTIATION
unknown's avatar
unknown committed
8229 8230 8231 8232
/* Used templates */
template class I_List<THD>;
template class I_List_iterator<THD>;
template class I_List<i_string>;
8233
template class I_List<i_string_pair>;
8234
template class I_List<NAMED_LIST>;
8235 8236
template class I_List<Statement>;
template class I_List_iterator<Statement>;
unknown's avatar
unknown committed
8237
#endif
8238 8239