mysqld.cc 231 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"
22
#include "repl_failsafe.h"
unknown's avatar
unknown committed
23
#include "stacktrace.h"
24
#include "mysqld_suffix.h"
unknown's avatar
unknown committed
25 26 27
#ifdef HAVE_BERKELEY_DB
#include "ha_berkeley.h"
#endif
28
#ifdef HAVE_INNOBASE_DB
29
#include "ha_innodb.h"
30
#endif
unknown's avatar
unknown committed
31
#include "ha_myisam.h"
32 33 34
#ifdef HAVE_ISAM
#include "ha_isam.h"
#endif
unknown's avatar
unknown committed
35 36 37
#ifdef HAVE_NDBCLUSTER_DB
#include "ha_ndbcluster.h"
#endif
38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55

#ifdef HAVE_INNOBASE_DB
#define OPT_INNODB_DEFAULT 1
#else
#define OPT_INNODB_DEFAULT 0
#endif
#ifdef HAVE_BERKLEY_DB
#define OPT_BDB_DEFAULT 1
#else
#define OPT_BDB_DEFAULT 0
#endif
#ifdef HAVE_ISAM_DB
#define OPT_ISAM_DEFAULT 1
#else
#define OPT_ISAM_DEFAULT 0
#endif
#ifdef HAVE_NDBCLUSTER_DB
#define OPT_NDBCLUSTER_DEFAULT 0
56
#if defined(NDB_SHM_TRANSPORTER) && MYSQL_VERSION_ID >= 50000
57 58 59 60
#define OPT_NDB_SHM_DEFAULT 1
#else
#define OPT_NDB_SHM_DEFAULT 0
#endif
61 62 63 64
#else
#define OPT_NDBCLUSTER_DEFAULT 0
#endif

unknown's avatar
unknown committed
65 66 67
#include <nisam.h>
#include <thr_alarm.h>
#include <ft_global.h>
68
#include <errmsg.h>
unknown's avatar
unknown committed
69

unknown's avatar
unknown committed
70
#define mysqld_charset &my_charset_latin1
unknown's avatar
unknown committed
71

72 73 74 75
#ifndef DBUG_OFF
#define ONE_THREAD
#endif

unknown's avatar
unknown committed
76
#ifdef HAVE_purify
77 78 79 80 81
#define IF_PURIFY(A,B) (A)
#else
#define IF_PURIFY(A,B) (B)
#endif

unknown's avatar
unknown committed
82 83 84 85
#ifndef INADDR_NONE
#define INADDR_NONE -1				// Error value from inet_addr
#endif

86
/* stack traces are only supported on linux intel */
87 88 89 90 91 92
#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__ */

93 94 95
/* 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
96
#define HAVE_CLOSE_SERVER_SOCK 1
97
#endif
unknown's avatar
unknown committed
98

unknown's avatar
unknown committed
99 100 101 102
extern "C" {					// Because of SCO 3.2V4.2
#include <errno.h>
#include <sys/stat.h>
#ifndef __GNU_LIBRARY__
103
#define __GNU_LIBRARY__				// Skip warnings in getopt.h
unknown's avatar
unknown committed
104
#endif
105
#include <my_getopt.h>
unknown's avatar
unknown committed
106 107 108 109 110 111 112 113 114 115
#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
unknown committed
116 117 118
#if defined(OS2)
#  include <sys/un.h>
#elif !defined( __WIN__)
unknown's avatar
unknown committed
119
#  ifndef __NETWARE__
unknown's avatar
unknown committed
120
#include <sys/resource.h>
unknown's avatar
unknown committed
121
#  endif /* __NETWARE__ */
unknown's avatar
unknown committed
122 123 124 125 126 127 128 129 130 131 132
#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
133
#endif /* __WIN__ */
unknown's avatar
unknown committed
134 135 136 137 138 139 140 141 142

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

unknown's avatar
unknown committed
144 145
#endif /* HAVE_LIBWRAP */

146 147 148 149
#ifdef HAVE_SYS_MMAN_H
#include <sys/mman.h>
#endif

unknown's avatar
unknown committed
150 151 152 153
#ifdef __NETWARE__
#include <nks/vm.h>
#include <library.h>
#include <monitor.h>
unknown's avatar
unknown committed
154 155 156 157 158 159
#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>

160 161 162
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
163 164
static event_handle_t eh;
static Report_t ref;
165
static void *refneb= NULL;
166
my_bool event_flag= FALSE;
167
static int volumeid= -1;
unknown's avatar
unknown committed
168 169 170

  /* NEB event callback */
unsigned long neb_event_callback(struct EventBlock *eblock);
171 172 173
static void registerwithneb();
static void getvolumename();
static void getvolumeID(BYTE *volumeName);
unknown's avatar
unknown committed
174
#endif /* __NETWARE__ */
175
  
unknown's avatar
unknown committed
176

unknown's avatar
unknown committed
177
#ifdef _AIX41
unknown's avatar
unknown committed
178
int initgroups(const char *,unsigned int);
unknown's avatar
unknown committed
179 180
#endif

unknown's avatar
unknown committed
181 182 183 184 185 186
#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
187
  /* We can't handle floating point exceptions with threads, so disable
unknown's avatar
unknown committed
188 189 190 191 192 193
     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
194 195 196
#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
197
#else
unknown's avatar
unknown committed
198 199 200
 fpsetmask(~(FP_X_INV |             FP_X_OFL | FP_X_UFL | FP_X_DZ |
	     FP_X_IMP));
#endif
unknown's avatar
unknown committed
201 202 203 204 205
}
#else
#define reset_floating_point_exceptions()
#endif /* __FreeBSD__ && HAVE_IEEEFP_H */

unknown's avatar
unknown committed
206 207
} /* cplusplus */

unknown's avatar
unknown committed
208 209 210 211 212 213

#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
214
#define MYSQL_KILL_SIGNAL SIGTERM
unknown's avatar
unknown committed
215 216 217 218 219 220 221 222 223 224 225

#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

226

unknown's avatar
unknown committed
227
/* Constants */
228

unknown's avatar
unknown committed
229 230 231 232
const char *show_comp_option_name[]= {"YES", "NO", "DISABLED"};
const char *sql_mode_names[] =
{
  "REAL_AS_FLOAT", "PIPES_AS_CONCAT", "ANSI_QUOTES", "IGNORE_SPACE",
233
  "?", "ONLY_FULL_GROUP_BY", "NO_UNSIGNED_SUBTRACTION",
unknown's avatar
unknown committed
234
  "NO_DIR_IN_CREATE",
235
  "POSTGRESQL", "ORACLE", "MSSQL", "DB2", "MAXDB", "NO_KEY_OPTIONS",
236
  "NO_TABLE_OPTIONS", "NO_FIELD_OPTIONS", "MYSQL323", "MYSQL40", "ANSI",
237
  "NO_AUTO_VALUE_ON_ZERO", NullS
unknown's avatar
unknown committed
238 239
};
TYPELIB sql_mode_typelib= { array_elements(sql_mode_names)-1,"",
240
			    sql_mode_names, NULL };
unknown's avatar
unknown committed
241
const char *first_keyword= "first", *binary_keyword= "BINARY";
unknown's avatar
unknown committed
242
const char *my_localhost= "localhost", *delayed_user= "DELAYED";
243 244 245 246 247 248
#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
249
bool opt_large_files= sizeof(my_off_t) > 4;
250 251 252 253

/*
  Used with --help for detailed option
*/
254
bool opt_help= 0;
255 256
bool opt_verbose= 0;

unknown's avatar
unknown committed
257
arg_cmp_func Arg_comparator::comparator_matrix[4][2] =
258 259 260 261
{{&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},
 {&Arg_comparator::compare_row,        &Arg_comparator::compare_e_row}};
unknown's avatar
unknown committed
262

unknown's avatar
unknown committed
263

unknown's avatar
unknown committed
264
/* Global variables */
unknown's avatar
unknown committed
265 266

bool opt_log, opt_update_log, opt_bin_log, opt_slow_log;
267
bool opt_error_log= IF_WIN(1,0);
unknown's avatar
unknown committed
268
bool opt_disable_networking=0, opt_skip_show_db=0;
269
bool lower_case_table_names_used= 0;
unknown's avatar
unknown committed
270 271 272 273 274 275 276 277
bool server_id_supplied = 0;
bool opt_endinfo,using_udf_functions, locked_in_memory;
bool opt_using_transactions, using_update_log;
bool volatile abort_loop, select_thread_in_use, signal_thread_in_use;
bool volatile ready_to_exit, shutdown_in_progress, grant_option;

my_bool opt_skip_slave_start = 0; // If set, slave is not autostarted
my_bool opt_reckless_slave = 0;
278
my_bool opt_enable_named_pipe= 0, opt_debugging= 0;
279
my_bool opt_local_infile, opt_external_locking, opt_slave_compressed_protocol;
280 281
my_bool opt_safe_user_create = 0, opt_no_mix_types = 0;
my_bool opt_show_slave_auth_info, opt_sql_bin_update = 0;
282
my_bool opt_log_slave_updates= 0;
unknown's avatar
unknown committed
283
my_bool	opt_console= 0, opt_bdb, opt_innodb, opt_isam, opt_ndbcluster;
284 285 286 287
#ifdef HAVE_NDBCLUSTER_DB
const char *opt_ndbcluster_connectstring= 0;
my_bool	opt_ndb_shm, opt_ndb_optimized_node_selection;
#endif
unknown's avatar
unknown committed
288
my_bool opt_readonly, use_temp_pool, relay_log_purge;
unknown's avatar
unknown committed
289
my_bool opt_sync_bdb_logs, opt_sync_frm;
290
my_bool opt_secure_auth= 0;
291 292
my_bool opt_short_log_format= 0;
my_bool opt_log_queries_not_using_indexes= 0;
unknown's avatar
unknown committed
293
my_bool lower_case_file_system= 0;
294
my_bool opt_innodb_safe_binlog= 0;
unknown's avatar
unknown committed
295
volatile bool mqh_used = 0;
296

297
uint mysqld_port, test_flags, select_errors, dropping_tables, ha_open_options;
unknown's avatar
unknown committed
298
uint delay_key_write_options, protocol_version;
unknown's avatar
unknown committed
299
uint lower_case_table_names;
unknown's avatar
unknown committed
300
uint opt_crash_binlog_innodb;
unknown's avatar
unknown committed
301
uint volatile thread_count, thread_running, kill_cached_threads, wake_thread;
unknown's avatar
unknown committed
302

unknown's avatar
unknown committed
303 304 305 306
ulong back_log, connect_timeout, concurrency;
ulong server_id, thd_startup_options;
ulong table_cache_size, thread_stack, thread_stack_min, what_to_log;
ulong query_buff_size, slow_launch_time, slave_open_temp_tables;
unknown's avatar
unknown committed
307
ulong open_files_limit, max_binlog_size, max_relay_log_size;
unknown's avatar
unknown committed
308
ulong slave_net_timeout;
309
ulong thread_cache_size=0, binlog_cache_size=0, max_binlog_cache_size=0;
310
ulong query_cache_size=0;
unknown's avatar
unknown committed
311
ulong com_stat[(uint) SQLCOM_END], com_other;
unknown's avatar
unknown committed
312
ulong bytes_sent, bytes_received, net_big_packet_count;
unknown's avatar
unknown committed
313 314 315
ulong refresh_version, flush_version;	/* Increments on each reload */
ulong query_id, long_query_count;
ulong aborted_threads, killed_threads, aborted_connects;
unknown's avatar
unknown committed
316 317 318
ulong delayed_insert_timeout, delayed_insert_limit, delayed_queue_size;
ulong delayed_insert_threads, delayed_insert_writes, delayed_rows_in_use;
ulong delayed_insert_errors,flush_time, thread_created;
319
ulong filesort_rows, filesort_range_count, filesort_scan_count;
320
ulong filesort_merge_passes;
321 322
ulong select_range_check_count, select_range_count, select_scan_count;
ulong select_full_range_join_count,select_full_join_count;
323 324
ulong specialflag=0,opened_tables=0,created_tmp_tables=0,
      created_tmp_disk_tables=0;
325
ulong binlog_cache_use= 0, binlog_cache_disk_use= 0;
unknown's avatar
unknown committed
326
ulong max_connections,max_used_connections,
unknown's avatar
unknown committed
327
      max_connect_errors, max_user_connections = 0;
unknown's avatar
unknown committed
328
ulong thread_id=1L,current_pid;
329
ulong slow_launch_threads = 0, sync_binlog_period;
unknown's avatar
unknown committed
330
ulong expire_logs_days = 0;
unknown's avatar
unknown committed
331 332 333 334 335 336
ulong rpl_recovery_rank=0;
ulong my_bind_addr;			/* the address we bind to */
volatile ulong cached_thread_count= 0;

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

338 339
char mysql_home[FN_REFLEN], pidfile_name[FN_REFLEN], system_time_zone[30];
char *default_tz_name;
unknown's avatar
unknown committed
340 341
char log_error_file[FN_REFLEN], glob_hostname[FN_REFLEN];
char* log_error_file_ptr= log_error_file;
unknown's avatar
unknown committed
342
char mysql_real_data_home[FN_REFLEN],
unknown's avatar
merge  
unknown committed
343
     language[LIBLEN],reg_ext[FN_EXTLEN], mysql_charsets_dir[FN_REFLEN],
344
     *mysqld_user,*mysqld_chroot, *opt_init_file,
unknown's avatar
unknown committed
345
     *opt_init_connect, *opt_init_slave,
346
     def_ft_boolean_syntax[sizeof(ft_boolean_syntax)];
347

348
const char *opt_date_time_formats[3];
349

350
char *language_ptr, *default_collation_name, *default_character_set_name;
unknown's avatar
unknown committed
351
char mysql_data_home_buff[2], *mysql_data_home=mysql_real_data_home;
352
struct passwd *user_info;
353
char server_version[SERVER_VERSION_LENGTH];
354
char *mysqld_unix_port, *opt_mysql_tmpdir;
unknown's avatar
unknown committed
355
char *my_bind_addr_str;
unknown's avatar
unknown committed
356
const char **errmesg;			/* Error messages */
357
const char *myisam_recover_options_str="OFF";
358
const char *sql_mode_str="OFF";
359 360
/* name of reference on left espression in rewritten IN subquery */
const char *in_left_expr_name= "<left expr>";
361 362
/* name of additional condition */
const char *in_additional_cond= "<IN COND>";
unknown's avatar
unknown committed
363 364 365 366 367 368 369 370
/* 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;

371

unknown's avatar
unknown committed
372 373
FILE *bootstrap_file;

374
I_List<i_string_pair> replicate_rewrite_db;
unknown's avatar
unknown committed
375 376 377
I_List<i_string> replicate_do_db, replicate_ignore_db;
// allow the user to tell us which db to replicate and which to ignore
I_List<i_string> binlog_do_db, binlog_ignore_db;
unknown's avatar
unknown committed
378
I_List<THD> threads,thread_cache;
379
I_List<NAMED_LIST> key_caches;
unknown's avatar
unknown committed
380

unknown's avatar
unknown committed
381 382
struct system_variables global_system_variables;
struct system_variables max_system_variables;
unknown's avatar
unknown committed
383

unknown's avatar
unknown committed
384
MY_TMPDIR mysql_tmpdir_list;
385
MY_BITMAP temp_pool;
unknown's avatar
unknown committed
386

387 388 389
CHARSET_INFO *system_charset_info, *files_charset_info ;
CHARSET_INFO *national_charset_info, *table_alias_charset;

unknown's avatar
unknown committed
390
SHOW_COMP_OPTION have_berkeley_db, have_innodb, have_isam, have_ndbcluster, 
391
  have_example_db, have_archive_db, have_csv_db;
unknown's avatar
unknown committed
392
SHOW_COMP_OPTION have_raid, have_openssl, have_symlink, have_query_cache;
393
SHOW_COMP_OPTION have_geometry, have_rtree_keys;
unknown's avatar
unknown committed
394 395 396
SHOW_COMP_OPTION have_crypt, have_compress;

/* Thread specific variables */
397

unknown's avatar
unknown committed
398
pthread_key(MEM_ROOT**,THR_MALLOC);
unknown's avatar
unknown committed
399 400
pthread_key(THD*, THR_THD);
pthread_mutex_t LOCK_mysql_create_db, LOCK_Acl, LOCK_open, LOCK_thread_count,
401
		LOCK_mapped_file, LOCK_status,
unknown's avatar
unknown committed
402
		LOCK_error_log, LOCK_uuid_generator,
unknown's avatar
unknown committed
403
		LOCK_delayed_insert, LOCK_delayed_status, LOCK_delayed_create,
404
		LOCK_crypt, LOCK_bytes_sent, LOCK_bytes_received,
405
	        LOCK_global_system_variables,
406
		LOCK_user_conn, LOCK_slave_list, LOCK_active_mi;
unknown's avatar
unknown committed
407
rw_lock_t	LOCK_grant, LOCK_sys_init_connect, LOCK_sys_init_slave;
unknown's avatar
unknown committed
408 409
pthread_cond_t COND_refresh,COND_thread_count, COND_slave_stopped,
	       COND_slave_start;
unknown's avatar
unknown committed
410 411 412 413
pthread_cond_t COND_thread_cache,COND_flush_thread_cache;
pthread_t signal_thread;
pthread_attr_t connection_attrib;

unknown's avatar
unknown committed
414 415 416 417 418
/* 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
419
char *relay_log_info_file, *report_user, *report_password, *report_host;
unknown's avatar
unknown committed
420
char *opt_relay_logname = 0, *opt_relaylog_index_name=0;
unknown's avatar
unknown committed
421 422 423
my_bool master_ssl;
char *master_ssl_key, *master_ssl_cert;
char *master_ssl_ca, *master_ssl_capath, *master_ssl_cipher;
unknown's avatar
unknown committed
424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442

/* Static variables */

static bool kill_in_progress, segfaulted;
static my_bool opt_do_pstack, opt_noacl, opt_bootstrap, opt_myisam_log;
static int cleanup_done;
static ulong opt_specialflag, opt_myisam_block_size;
static char *opt_logname, *opt_update_logname, *opt_binlog_index_name;
static char *opt_slow_logname;
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
443 444 445
#ifdef __WIN__
#undef	 getpid
#include <process.h>
unknown's avatar
unknown committed
446 447 448 449 450 451 452

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
453
#if !defined(EMBEDDED_LIBRARY)
unknown's avatar
unknown committed
454
static HANDLE hEventShutdown;
455
static char shutdown_event_name[40];
unknown's avatar
unknown committed
456 457
#include "nt_servc.h"
static	 NTService  Service;	      // Service object for WinNT
unknown's avatar
unknown committed
458 459 460 461
#endif /* EMBEDDED_LIBRARY */
#endif /* __WIN__ */

#ifdef __NT__
462
static char pipe_name[512];
unknown's avatar
unknown committed
463 464 465
static SECURITY_ATTRIBUTES saPipeSecurity;
static SECURITY_DESCRIPTOR sdPipeDescriptor;
static HANDLE hPipe = INVALID_HANDLE_VALUE;
unknown's avatar
unknown committed
466
#endif
unknown's avatar
unknown committed
467

unknown's avatar
unknown committed
468 469 470 471
#ifdef OS2
pthread_cond_t eventShutdown;
#endif

unknown's avatar
unknown committed
472
#ifndef EMBEDDED_LIBRARY
473
bool mysqld_embedded=0;
unknown's avatar
unknown committed
474
#else
475
bool mysqld_embedded=1;
unknown's avatar
unknown committed
476 477 478 479 480 481 482 483 484 485 486 487 488 489 490
#endif

#ifndef DBUG_OFF
static const char* default_dbug_option;
#endif
#ifdef HAVE_LIBWRAP
char *libwrapName= NULL;
#endif
#ifdef HAVE_QUERY_CACHE
ulong query_cache_limit= 0;
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;
491
bool opt_enable_shared_memory;
492
HANDLE smem_event_connect_request= 0;
unknown's avatar
unknown committed
493 494 495 496 497 498 499 500 501 502 503
#endif

#include "sslopt-vars.h"
#ifdef HAVE_OPENSSL
char *des_key_file;
struct st_VioSSLAcceptorFd *ssl_acceptor_fd;
#endif /* HAVE_OPENSSL */


/* Function declarations */

504
static void start_signal_handler(void);
505
extern "C" pthread_handler_decl(signal_hand, arg);
unknown's avatar
unknown committed
506
static void mysql_init_variables(void);
unknown's avatar
unknown committed
507
static void get_options(int argc,char **argv);
508
static void set_server_version(void);
509
static int init_thread_environment();
unknown's avatar
unknown committed
510 511
static char *get_relative_path(const char *path);
static void fix_paths(void);
512 513
extern "C" pthread_handler_decl(handle_connections_sockets,arg);
extern "C" pthread_handler_decl(kill_server_thread,arg);
unknown's avatar
unknown committed
514
static int bootstrap(FILE *file);
515
static void close_server_sock();
unknown's avatar
unknown committed
516 517
static bool read_init_file(char *file_name);
#ifdef __NT__
518
extern "C" pthread_handler_decl(handle_connections_namedpipes,arg);
unknown's avatar
unknown committed
519
#endif
520 521 522
#ifdef HAVE_SMEM
static pthread_handler_decl(handle_connections_shared_memory,arg);
#endif
523
extern "C" pthread_handler_decl(handle_slave,arg);
524
static ulong find_bit_type(const char *x, TYPELIB *bit_lib);
unknown's avatar
unknown committed
525
static void clean_up(bool print_message);
unknown's avatar
unknown committed
526
static void clean_up_mutexes(void);
527 528
static int test_if_case_insensitive(const char *dir_name);
static void create_pid_file();
529 530

#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546
/****************************************************************************
** 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 */
547 548
  (void) pthread_mutex_lock(&LOCK_manager);
  if (manager_thread_in_use)
unknown's avatar
unknown committed
549
  {
550 551
    DBUG_PRINT("quit",("killing manager thread: %lx",manager_thread));
   (void) pthread_cond_signal(&COND_manager);
unknown's avatar
unknown committed
552
  }
553
  (void) pthread_mutex_unlock(&LOCK_manager);
unknown's avatar
unknown committed
554 555

  /* kill connection thread */
unknown's avatar
unknown committed
556
#if !defined(__WIN__) && !defined(__EMX__) && !defined(OS2) && !defined(__NETWARE__)
unknown's avatar
unknown committed
557 558 559 560 561 562 563 564
  DBUG_PRINT("quit",("waiting for select thread: %lx",select_thread));
  (void) pthread_mutex_lock(&LOCK_thread_count);

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

unknown's avatar
unknown committed
567 568 569 570
#ifndef DONT_USE_THR_ALARM
    if (pthread_kill(select_thread,THR_CLIENT_ALARM))
      break;					// allready dead
#endif
571
    set_timespec(abstime, 2);
572
    for (uint tmp=0 ; tmp < 10 && select_thread_in_use; tmp++)
unknown's avatar
unknown committed
573 574 575 576 577 578 579 580 581 582
    {
      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
583
    close_server_sock();
unknown's avatar
unknown committed
584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600
  }
  (void) pthread_mutex_unlock(&LOCK_thread_count);
#endif /* __WIN__ */


  /* Abort listening to new connections */
  DBUG_PRINT("quit",("Closing sockets"));
  if ( !opt_disable_networking )
  {
    if (ip_sock != INVALID_SOCKET)
    {
      (void) shutdown(ip_sock,2);
      (void) closesocket(ip_sock);
      ip_sock= INVALID_SOCKET;
    }
  }
#ifdef __NT__
unknown's avatar
unknown committed
601
  if (hPipe != INVALID_HANDLE_VALUE && opt_enable_named_pipe)
unknown's avatar
unknown committed
602
  {
unknown's avatar
merge  
unknown committed
603
    HANDLE temp;
unknown's avatar
unknown committed
604
    DBUG_PRINT( "quit", ("Closing named pipes") );
605

unknown's avatar
merge  
unknown committed
606
    /* Create connection to the handle named pipe handler to break the loop */
607
    if ((temp = CreateFile(pipe_name,
unknown's avatar
merge  
unknown committed
608 609 610 611 612 613 614
			   GENERIC_READ | GENERIC_WRITE,
			   0,
			   NULL,
			   OPEN_EXISTING,
			   0,
			   NULL )) != INVALID_HANDLE_VALUE)
    {
615
      WaitNamedPipe(pipe_name, 1000);
unknown's avatar
merge  
unknown committed
616 617 618 619 620 621
      DWORD dwMode = PIPE_READMODE_BYTE | PIPE_WAIT;
      SetNamedPipeHandleState(temp, &dwMode, NULL, NULL);
      CancelIo(temp);
      DisconnectNamedPipe(temp);
      CloseHandle(temp);
    }
unknown's avatar
unknown committed
622 623 624 625 626 627 628
  }
#endif
#ifdef HAVE_SYS_UN_H
  if (unix_sock != INVALID_SOCKET)
  {
    (void) shutdown(unix_sock,2);
    (void) closesocket(unix_sock);
629
    (void) unlink(mysqld_unix_port);
unknown's avatar
unknown committed
630 631 632
    unix_sock= INVALID_SOCKET;
  }
#endif
633
  end_thr_alarm(0);			 // Abort old alarms.
634
  end_slave();
unknown's avatar
unknown committed
635 636 637 638 639 640 641 642 643 644 645 646 647 648 649

  /* First signal all threads that it's time to die */

  THD *tmp;
  (void) pthread_mutex_lock(&LOCK_thread_count); // For unlink from list

  I_List_iterator<THD> it(threads);
  while ((tmp=it++))
  {
    DBUG_PRINT("quit",("Informing thread %ld that it's time to die",
		       tmp->thread_id));
    tmp->killed=1;
    if (tmp->mysys_var)
    {
      tmp->mysys_var->abort=1;
unknown's avatar
unknown committed
650 651
      pthread_mutex_lock(&tmp->mysys_var->mutex);
      if (tmp->mysys_var->current_cond)
unknown's avatar
unknown committed
652 653 654 655 656
      {
	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
657
      pthread_mutex_unlock(&tmp->mysys_var->mutex);
unknown's avatar
unknown committed
658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677
    }
  }
  (void) pthread_mutex_unlock(&LOCK_thread_count); // For unlink from list

  if (thread_count)
    sleep(1);					// Give threads time to die

  /* Force remaining threads to die by closing the connection to the client */

  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
678
    if (tmp->vio_ok())
unknown's avatar
unknown committed
679 680 681
    {
      sql_print_error(ER(ER_FORCING_CLOSE),my_progname,
		      tmp->thread_id,tmp->user ? tmp->user : "");
682
      close_connection(tmp,0,0);
unknown's avatar
unknown committed
683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700
    }
#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;
}
701
#endif /*EMBEDDED_LIBRARY*/
unknown's avatar
unknown committed
702

703

704
static void close_server_sock()
unknown's avatar
unknown committed
705
{
706
#ifdef HAVE_CLOSE_SERVER_SOCK
unknown's avatar
unknown committed
707
  DBUG_ENTER("close_server_sock");
708 709 710
  my_socket tmp_sock;
  tmp_sock=ip_sock;
  if (tmp_sock != INVALID_SOCKET)
unknown's avatar
unknown committed
711 712
  {
    ip_sock=INVALID_SOCKET;
713
    DBUG_PRINT("info",("calling shutdown on TCP/IP socket"));
714
    VOID(shutdown(tmp_sock,2));
unknown's avatar
unknown committed
715
#if defined(__NETWARE__)
716
    /*
unknown's avatar
unknown committed
717 718
      The following code is disabled for normal systems as it causes MySQL
      to hang on AIX 4.3 during shutdown
719
    */
720
    DBUG_PRINT("info",("calling closesocket on TCP/IP socket"));
721
    VOID(closesocket(tmp_sock));
722
#endif
unknown's avatar
unknown committed
723
  }
724 725
  tmp_sock=unix_sock;
  if (tmp_sock != INVALID_SOCKET)
unknown's avatar
unknown committed
726
  {
727
    unix_sock=INVALID_SOCKET;
728
    DBUG_PRINT("info",("calling shutdown on unix socket"));
729
    VOID(shutdown(tmp_sock,2));
unknown's avatar
unknown committed
730
#if defined(__NETWARE__)
unknown's avatar
unknown committed
731
    /*
732 733
      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
734 735
    */
    DBUG_PRINT("info",("calling closesocket on unix/IP socket"));
736
    VOID(closesocket(tmp_sock));
unknown's avatar
unknown committed
737
#endif
738
    VOID(unlink(mysqld_unix_port));
unknown's avatar
unknown committed
739 740 741
  }
  DBUG_VOID_RETURN;
#endif
742
}
unknown's avatar
unknown committed
743

744

unknown's avatar
unknown committed
745 746 747 748
void kill_mysql(void)
{
  DBUG_ENTER("kill_mysql");

unknown's avatar
unknown committed
749
#ifdef SIGNALS_DONT_BREAK_READ
750 751
  abort_loop=1;					// Break connection loops
  close_server_sock();				// Force accept to wake up
752
#endif
unknown's avatar
unknown committed
753

unknown's avatar
unknown committed
754
#if defined(__WIN__)
unknown's avatar
unknown committed
755
#if !defined(EMBEDDED_LIBRARY)
unknown's avatar
unknown committed
756 757 758 759 760
  {
    if (!SetEvent(hEventShutdown))
    {
      DBUG_PRINT("error",("Got error: %ld from SetEvent",GetLastError()));
    }
761 762 763 764 765 766
    /*
      or:
      HANDLE hEvent=OpenEvent(0, FALSE, "MySqlShutdown");
      SetEvent(hEventShutdown);
      CloseHandle(hEvent);
    */
unknown's avatar
unknown committed
767
  }
unknown's avatar
unknown committed
768 769
#ifdef HAVE_SMEM
    /*
770
     Send event to smem_event_connect_request for aborting
unknown's avatar
unknown committed
771
    */
772
    if (!SetEvent(smem_event_connect_request))
unknown's avatar
unknown committed
773
    {
774
      DBUG_PRINT("error",("Got error: %ld from SetEvent of smem_event_connect_request",GetLastError()));
unknown's avatar
unknown committed
775 776
    }
#endif  
unknown's avatar
unknown committed
777
#endif
unknown's avatar
unknown committed
778 779
#elif defined(OS2)
  pthread_cond_signal( &eventShutdown);		// post semaphore
unknown's avatar
unknown committed
780
#elif defined(HAVE_PTHREAD_KILL)
781
  if (pthread_kill(signal_thread, MYSQL_KILL_SIGNAL))
unknown's avatar
unknown committed
782 783 784 785
  {
    DBUG_PRINT("error",("Got error %d from pthread_kill",errno)); /* purecov: inspected */
  }
#elif !defined(SIGNALS_DONT_BREAK_READ)
786
  kill(current_pid, MYSQL_KILL_SIGNAL);
unknown's avatar
unknown committed
787
#endif
unknown's avatar
unknown committed
788 789 790
  DBUG_PRINT("quit",("After pthread_kill"));
  shutdown_in_progress=1;			// Safety if kill didn't work
#ifdef SIGNALS_DONT_BREAK_READ
791
  if (!kill_in_progress)
unknown's avatar
unknown committed
792 793
  {
    pthread_t tmp;
unknown's avatar
unknown committed
794
    abort_loop=1;
unknown's avatar
unknown committed
795 796
    if (pthread_create(&tmp,&connection_attrib, kill_server_thread,
			   (void*) 0))
797
      sql_print_error("Can't create thread to kill server");
unknown's avatar
unknown committed
798
  }
799
#endif
unknown's avatar
unknown committed
800
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
801 802 803 804
}

	/* Force server down. kill all connections and threads and exit */

unknown's avatar
unknown committed
805
#if defined(OS2) || defined(__NETWARE__)
unknown's avatar
unknown committed
806
extern "C" void kill_server(int sig_ptr)
807
#define RETURN_FROM_KILL_SERVER DBUG_VOID_RETURN
unknown's avatar
unknown committed
808
#elif !defined(__WIN__)
unknown's avatar
unknown committed
809
static void *kill_server(void *sig_ptr)
unknown's avatar
unknown committed
810
#define RETURN_FROM_KILL_SERVER DBUG_RETURN(0)
unknown's avatar
unknown committed
811 812
#else
static void __cdecl kill_server(int sig_ptr)
unknown's avatar
unknown committed
813
#define RETURN_FROM_KILL_SERVER DBUG_VOID_RETURN
unknown's avatar
unknown committed
814 815 816 817
#endif
{
  int sig=(int) (long) sig_ptr;			// This is passed a int
  DBUG_ENTER("kill_server");
818
#ifndef EMBEDDED_LIBRARY
819
  // if there is a signal during the kill in progress, ignore the other
unknown's avatar
unknown committed
820 821 822 823 824 825
  if (kill_in_progress)				// Safety
    RETURN_FROM_KILL_SERVER;
  kill_in_progress=TRUE;
  abort_loop=1;					// This should be set
  signal(sig,SIG_IGN);
  if (sig == MYSQL_KILL_SIGNAL || sig == 0)
826
    sql_print_information(ER(ER_NORMAL_SHUTDOWN),my_progname);
unknown's avatar
unknown committed
827 828 829
  else
    sql_print_error(ER(ER_GOT_SIGNAL),my_progname,sig); /* purecov: inspected */

unknown's avatar
unknown committed
830
#if defined(__NETWARE__) || (defined(USE_ONE_SIGNAL_HAND) && !defined(__WIN__) && !defined(OS2))
unknown's avatar
unknown committed
831 832 833 834 835 836
  my_thread_init();				// If this is a new thread
#endif
  close_connections();
  if (sig != MYSQL_KILL_SIGNAL && sig != 0)
    unireg_abort(1);				/* purecov: inspected */
  else
837
    unireg_end();
unknown's avatar
unknown committed
838
#ifdef __NETWARE__
839 840
  if (!event_flag)
      pthread_join(select_thread, NULL);	// wait for main thread
unknown's avatar
unknown committed
841
#endif /* __NETWARE__ */
842

843
  pthread_exit(0);				/* purecov: deadcode */
unknown's avatar
unknown committed
844

845
#endif /* EMBEDDED_LIBRARY */
unknown's avatar
unknown committed
846 847 848 849
  RETURN_FROM_KILL_SERVER;
}


unknown's avatar
unknown committed
850
#if defined(USE_ONE_SIGNAL_HAND) || (defined(__NETWARE__) && defined(SIGNALS_DONT_BREAK_READ))
851
extern "C" pthread_handler_decl(kill_server_thread,arg __attribute__((unused)))
unknown's avatar
unknown committed
852 853 854 855 856 857 858 859
{
  my_thread_init();				// Initialize new thread
  kill_server(0);
  my_thread_end();				// Normally never reached
  return 0;
}
#endif

unknown's avatar
unknown committed
860 861 862 863 864
#if defined(__amiga__)
#undef sigset
#define sigset signal
#endif

865
extern "C" sig_handler print_signal_warning(int sig)
unknown's avatar
unknown committed
866
{
867 868 869
  if (!DBUG_IN_USE)
  {
    if (global_system_variables.log_warnings)
870
      sql_print_warning("Got signal %d from thread %d",
871 872
		      sig,my_thread_id());
  }
unknown's avatar
unknown committed
873 874 875
#ifdef DONT_REMEMBER_SIGNAL
  sigset(sig,print_signal_warning);		/* int. thread system calls */
#endif
unknown's avatar
unknown committed
876
#if !defined(__WIN__) && !defined(OS2) && !defined(__NETWARE__)
unknown's avatar
unknown committed
877 878 879 880 881
  if (sig == SIGALRM)
    alarm(2);					/* reschedule alarm */
#endif
}

882 883
/*
  cleanup all memory and end program nicely
unknown's avatar
unknown committed
884

885 886 887 888 889
  SYNOPSIS
    unireg_end()

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

891 892 893 894
    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
895

896
#ifndef EMBEDDED_LIBRARY
897
void unireg_end(void)
unknown's avatar
unknown committed
898
{
unknown's avatar
unknown committed
899
  clean_up(1);
unknown's avatar
unknown committed
900
  my_thread_end();
901
#if defined(SIGNALS_DONT_BREAK_READ) && !defined(__NETWARE__)
902 903
  exit(0);
#else
unknown's avatar
unknown committed
904
  pthread_exit(0);				// Exit is in main thread
905
#endif
unknown's avatar
unknown committed
906 907
}

908
extern "C" void unireg_abort(int exit_code)
unknown's avatar
unknown committed
909
{
910
  DBUG_ENTER("unireg_abort");
unknown's avatar
unknown committed
911 912
  if (exit_code)
    sql_print_error("Aborting\n");
unknown's avatar
unknown committed
913
  clean_up(exit_code || !opt_bootstrap); /* purecov: inspected */
914
  DBUG_PRINT("quit",("done with cleanup in unireg_abort"));
unknown's avatar
unknown committed
915 916
  clean_up_mutexes();
  my_end(opt_endinfo ? MY_CHECK_ERROR | MY_GIVE_INFO : 0);
unknown's avatar
unknown committed
917 918
  exit(exit_code); /* purecov: inspected */
}
919
#endif
unknown's avatar
unknown committed
920

unknown's avatar
unknown committed
921

922
void clean_up(bool print_message)
unknown's avatar
unknown committed
923 924 925 926
{
  DBUG_PRINT("exit",("clean_up"));
  if (cleanup_done++)
    return; /* purecov: inspected */
unknown's avatar
unknown committed
927 928 929 930 931 932

  mysql_log.cleanup();
  mysql_slow_log.cleanup();
  mysql_update_log.cleanup();
  mysql_bin_log.cleanup();

unknown's avatar
SCRUM  
unknown committed
933
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
934 935
  if (use_slave_mask)
    bitmap_free(&slave_error_mask);
936
#endif
937
  my_tz_free();
938
  my_dbopt_free();
unknown's avatar
unknown committed
939
#ifndef NO_EMBEDDED_ACCESS_CHECKS
unknown's avatar
unknown committed
940 941
  acl_free(1);
  grant_free();
unknown's avatar
unknown committed
942
#endif
unknown's avatar
unknown committed
943
  query_cache_destroy();
unknown's avatar
unknown committed
944 945 946 947
  table_cache_free();
  hostname_cache_free();
  item_user_lock_free();
  lex_free();				/* Free some memory */
unknown's avatar
unknown committed
948
  set_var_free();
unknown's avatar
unknown committed
949 950 951 952
#ifdef HAVE_DLOPEN
  if (!opt_noacl)
    udf_free();
#endif
953
  (void) ha_panic(HA_PANIC_CLOSE);	/* close all tables and logs */
954 955
  delete_elements(&key_caches, (void (*)(const char*, gptr)) free_key_cache);
  multi_keycache_free();
956
  end_thr_alarm(1);			/* Free allocated memory */
unknown's avatar
unknown committed
957 958 959
#ifdef USE_RAID
  end_raid();
#endif
960
  my_free_open_file_info();
961 962 963 964 965 966
  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
967 968
  if (defaults_argv)
    free_defaults(defaults_argv);
unknown's avatar
unknown committed
969 970
  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
971
  free_tmpdir(&mysql_tmpdir_list);
unknown's avatar
SCRUM  
unknown committed
972
#ifdef HAVE_REPLICATION
973
  my_free(slave_load_tmpdir,MYF(MY_ALLOW_ZERO_PTR));
974
#endif
975
  x_free(opt_bin_logname);
976
  x_free(opt_relay_logname);
unknown's avatar
unknown committed
977
  bitmap_free(&temp_pool);
unknown's avatar
unknown committed
978
  free_max_user_conn();
unknown's avatar
SCRUM  
unknown committed
979
#ifdef HAVE_REPLICATION
980
  end_slave_list();
981 982 983 984 985
  free_list(&replicate_do_db);
  free_list(&replicate_ignore_db);
  free_list(&binlog_do_db);
  free_list(&binlog_ignore_db);
  free_list(&replicate_rewrite_db);
986
#endif
unknown's avatar
unknown committed
987
#ifdef HAVE_OPENSSL
unknown's avatar
unknown committed
988 989
  if (ssl_acceptor_fd)
    my_free((gptr) ssl_acceptor_fd, MYF(MY_ALLOW_ZERO_PTR));
unknown's avatar
unknown committed
990 991
  free_des_key_file();
#endif /* HAVE_OPENSSL */
unknown's avatar
unknown committed
992 993 994
#ifdef USE_REGEX
  regex_end();
#endif
unknown's avatar
unknown committed
995

unknown's avatar
unknown committed
996
  if (print_message && errmesg)
997
    sql_print_information(ER(ER_SHUTDOWN_COMPLETE),my_progname);
998
#if !defined(EMBEDDED_LIBRARY)
999 1000
  if (!opt_bootstrap)
    (void) my_delete(pidfile_name,MYF(0));	// This may not always exist
unknown's avatar
unknown committed
1001
#endif
1002
  x_free((gptr) my_errmsg[ERRMAPP]);	/* Free messages */
1003
  DBUG_PRINT("quit", ("Error messages freed"));
unknown's avatar
unknown committed
1004 1005
  /* Tell main we are ready */
  (void) pthread_mutex_lock(&LOCK_thread_count);
1006
  DBUG_PRINT("quit", ("got thread count lock"));
unknown's avatar
unknown committed
1007
  ready_to_exit=1;
unknown's avatar
unknown committed
1008
  /* do the broadcast inside the lock to ensure that my_end() is not called */
unknown's avatar
unknown committed
1009 1010
  (void) pthread_cond_broadcast(&COND_thread_count);
  (void) pthread_mutex_unlock(&LOCK_thread_count);
unknown's avatar
unknown committed
1011 1012 1013 1014
  /*
    The following lines may never be executed as the main thread may have
    killed us
  */
1015
  DBUG_PRINT("quit", ("done with cleanup"));
unknown's avatar
unknown committed
1016 1017 1018
} /* clean_up */


unknown's avatar
unknown committed
1019 1020 1021 1022
static void clean_up_mutexes()
{
  (void) pthread_mutex_destroy(&LOCK_mysql_create_db);
  (void) pthread_mutex_destroy(&LOCK_Acl);
1023
  (void) rwlock_destroy(&LOCK_grant);
unknown's avatar
unknown committed
1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036
  (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);
1037
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
1038
  (void) pthread_mutex_destroy(&LOCK_rpl_status);
1039 1040
  (void) pthread_cond_destroy(&COND_rpl_status);
#endif
unknown's avatar
unknown committed
1041
  (void) pthread_mutex_destroy(&LOCK_active_mi);
unknown's avatar
unknown committed
1042 1043
  (void) rwlock_destroy(&LOCK_sys_init_connect);
  (void) rwlock_destroy(&LOCK_sys_init_slave);
unknown's avatar
unknown committed
1044 1045 1046 1047 1048 1049 1050
  (void) pthread_mutex_destroy(&LOCK_global_system_variables);
  (void) pthread_cond_destroy(&COND_thread_count);
  (void) pthread_cond_destroy(&COND_refresh);
  (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
1051 1052 1053 1054 1055 1056 1057 1058

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

static void set_ports()
{
  char	*env;
1059
  if (!mysqld_port && !opt_disable_networking)
unknown's avatar
unknown committed
1060 1061
  {					// Get port if not from commandline
    struct  servent *serv_ptr;
1062 1063 1064
    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
1065
    if ((env = getenv("MYSQL_TCP_PORT")))
1066
      mysqld_port= (uint) atoi(env);		/* purecov: inspected */
unknown's avatar
unknown committed
1067
  }
1068
  if (!mysqld_unix_port)
unknown's avatar
unknown committed
1069 1070
  {
#ifdef __WIN__
1071
    mysqld_unix_port= (char*) MYSQL_NAMEDPIPE;
unknown's avatar
unknown committed
1072
#else
1073
    mysqld_unix_port= (char*) MYSQL_UNIX_ADDR;
unknown's avatar
unknown committed
1074 1075
#endif
    if ((env = getenv("MYSQL_UNIX_PORT")))
1076
      mysqld_unix_port= env;			/* purecov: inspected */
unknown's avatar
unknown committed
1077 1078 1079
  }
}

1080
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
1081 1082
/* Change to run as another user if started with --user */

1083
static struct passwd *check_user(const char *user)
unknown's avatar
unknown committed
1084
{
unknown's avatar
unknown committed
1085
#if !defined(__WIN__) && !defined(OS2) && !defined(__NETWARE__)
1086
  struct passwd *user_info;
1087
  uid_t user_id= geteuid();
unknown's avatar
unknown committed
1088

1089
  // Don't bother if we aren't superuser
1090
  if (user_id)
unknown's avatar
unknown committed
1091 1092
  {
    if (user)
1093
    {
1094 1095
      // Don't give a warning, if real user is same as given with --user
      user_info= getpwnam(user);
1096 1097
      if ((!user_info || user_id != user_info->pw_uid) &&
	  global_system_variables.log_warnings)
1098 1099
        sql_print_warning(
                    "One can only use the --user switch if running as root\n");
1100
    }
1101
    return NULL;
unknown's avatar
unknown committed
1102
  }
1103
  if (!user)
unknown's avatar
unknown committed
1104 1105 1106
  {
    if (!opt_bootstrap)
    {
unknown's avatar
unknown committed
1107
      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
1108 1109
      unireg_abort(1);
    }
1110
    return NULL;
unknown's avatar
unknown committed
1111 1112
  }
  if (!strcmp(user,"root"))
unknown's avatar
unknown committed
1113
    return NULL;                        // Avoid problem with dynamic libraries
unknown's avatar
unknown committed
1114

1115
  if (!(user_info= getpwnam(user)))
unknown's avatar
unknown committed
1116
  {
1117
    // Allow a numeric uid to be used
unknown's avatar
unknown committed
1118
    const char *pos;
unknown's avatar
unknown committed
1119 1120
    for (pos= user; my_isdigit(mysqld_charset,*pos); pos++) ;
    if (*pos)                                   // Not numeric id
1121 1122 1123 1124 1125
      goto err;
    if (!(user_info= getpwuid(atoi(user))))
      goto err;
    else
      return user_info;
unknown's avatar
unknown committed
1126
  }
unknown's avatar
unknown committed
1127
  else
1128 1129 1130
    return user_info;

err:
unknown's avatar
unknown committed
1131 1132 1133
  sql_print_error("Fatal error: Can't change to run as user '%s' ;  Please check that the user exists!\n",user);
#endif
  return NULL;
1134 1135 1136 1137 1138 1139
}

static void set_user(const char *user, struct passwd *user_info)
{
#if !defined(__WIN__) && !defined(OS2) && !defined(__NETWARE__)
  DBUG_ASSERT(user_info);
unknown's avatar
unknown committed
1140
#ifdef HAVE_INITGROUPS
unknown's avatar
unknown committed
1141
  initgroups((char*) user,user_info->pw_gid);
unknown's avatar
unknown committed
1142
#endif
1143 1144 1145 1146
  if (setgid(user_info->pw_gid) == -1)
  {
    sql_perror("setgid");
    unireg_abort(1);
unknown's avatar
unknown committed
1147
  }
1148
  if (setuid(user_info->pw_uid) == -1)
unknown's avatar
unknown committed
1149 1150 1151 1152 1153 1154 1155
  {
    sql_perror("setuid");
    unireg_abort(1);
  }
#endif
}

unknown's avatar
unknown committed
1156

1157 1158 1159 1160
static void set_effective_user(struct passwd *user_info)
{
#if !defined(__WIN__) && !defined(OS2) && !defined(__NETWARE__)
  DBUG_ASSERT(user_info);
1161
  if (setregid((gid_t)-1, user_info->pw_gid) == -1)
1162
  {
1163
    sql_perror("setregid");
1164
    unireg_abort(1);
unknown's avatar
unknown committed
1165
  }
1166
  if (setreuid((uid_t)-1, user_info->pw_uid) == -1)
1167
  {
1168
    sql_perror("setreuid");
1169 1170 1171 1172 1173 1174
    unireg_abort(1);
  }
#endif
}


unknown's avatar
unknown committed
1175 1176 1177 1178
/* Change root user if started with  --chroot */

static void set_root(const char *path)
{
unknown's avatar
unknown committed
1179
#if !defined(__WIN__) && !defined(__EMX__) && !defined(OS2) && !defined(__NETWARE__)
unknown's avatar
unknown committed
1180 1181 1182 1183 1184
  if (chroot(path) == -1)
  {
    sql_perror("chroot");
    unireg_abort(1);
  }
1185
  my_setwd("/", MYF(0));
unknown's avatar
unknown committed
1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211
#endif
}

static void server_init(void)
{
  struct sockaddr_in	IPaddr;
#ifdef HAVE_SYS_UN_H
  struct sockaddr_un	UNIXaddr;
#endif
  int	arg=1;
  DBUG_ENTER("server_init");

#ifdef	__WIN__
  if ( !opt_disable_networking )
  {
    WSADATA WsaData;
    if (SOCKET_ERROR == WSAStartup (0x0101, &WsaData))
    {
      my_message(0,"WSAStartup Failed\n",MYF(0));
      unireg_abort(1);
    }
  }
#endif /* __WIN__ */

  set_ports();

1212
  if (mysqld_port != 0 && !opt_disable_networking && !opt_bootstrap)
unknown's avatar
unknown committed
1213
  {
1214
    DBUG_PRINT("general",("IP Socket is %d",mysqld_port));
unknown's avatar
unknown committed
1215 1216 1217 1218 1219 1220 1221 1222 1223 1224
    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;
1225
    IPaddr.sin_port = (unsigned short) htons((unsigned short) mysqld_port);
1226 1227 1228 1229 1230 1231

#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
1232
    (void) setsockopt(ip_sock,SOL_SOCKET,SO_REUSEADDR,(char*)&arg,sizeof(arg));
unknown's avatar
unknown committed
1233
#endif /* __WIN__ */
1234 1235
    if (bind(ip_sock, my_reinterpret_cast(struct sockaddr *) (&IPaddr),
	     sizeof(IPaddr)) < 0)
unknown's avatar
unknown committed
1236 1237
    {
      DBUG_PRINT("error",("Got error: %d from bind",socket_errno));
1238
      sql_perror("Can't start server: Bind on TCP/IP port");
1239
      sql_print_error("Do you already have another mysqld server running on port: %d ?",mysqld_port);
unknown's avatar
unknown committed
1240 1241
      unireg_abort(1);
    }
1242
    if (listen(ip_sock,(int) back_log) < 0)
unknown's avatar
unknown committed
1243
    {
1244
      sql_perror("Can't start server: listen() on TCP/IP port");
1245
      sql_print_error("listen() on TCP/IP failed with error %d",
unknown's avatar
unknown committed
1246
		      socket_errno);
unknown's avatar
unknown committed
1247 1248
      unireg_abort(1);
    }
unknown's avatar
unknown committed
1249
  }
1250 1251 1252 1253

  if ((user_info= check_user(mysqld_user)))
  {
#if defined(HAVE_MLOCKALL) && defined(MCL_CURRENT)
unknown's avatar
unknown committed
1254
    if (locked_in_memory) // getuid() == 0 here
1255 1256 1257
      set_effective_user(user_info);
    else
#endif
unknown's avatar
unknown committed
1258
      set_user(mysqld_user, user_info);
1259
  }
unknown's avatar
unknown committed
1260 1261 1262

#ifdef __NT__
  /* create named pipe */
1263
  if (Service.IsNT() && mysqld_unix_port[0] && !opt_bootstrap &&
unknown's avatar
unknown committed
1264
      opt_enable_named_pipe)
unknown's avatar
unknown committed
1265
  {
1266 1267 1268
    
    pipe_name[sizeof(pipe_name)-1]= 0;		/* Safety if too long string */
    strxnmov(pipe_name, sizeof(pipe_name)-1, "\\\\.\\pipe\\",
1269
	     mysqld_unix_port, NullS);
1270 1271
    bzero((char*) &saPipeSecurity, sizeof(saPipeSecurity));
    bzero((char*) &sdPipeDescriptor, sizeof(sdPipeDescriptor));
1272
    if (!InitializeSecurityDescriptor(&sdPipeDescriptor,
1273
				      SECURITY_DESCRIPTOR_REVISION))
unknown's avatar
unknown committed
1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285
    {
      sql_perror("Can't start server : Initialize security descriptor");
      unireg_abort(1);
    }
    if (!SetSecurityDescriptorDacl(&sdPipeDescriptor, TRUE, NULL, FALSE))
    {
      sql_perror("Can't start server : Set security descriptor");
      unireg_abort(1);
    }
    saPipeSecurity.nLength = sizeof( SECURITY_ATTRIBUTES );
    saPipeSecurity.lpSecurityDescriptor = &sdPipeDescriptor;
    saPipeSecurity.bInheritHandle = FALSE;
1286 1287 1288 1289 1290 1291 1292 1293 1294 1295
    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
1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310
      {
	LPVOID lpMsgBuf;
	int error=GetLastError();
	FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
		      FORMAT_MESSAGE_FROM_SYSTEM,
		      NULL, error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
		      (LPTSTR) &lpMsgBuf, 0, NULL );
	MessageBox( NULL, (LPTSTR) lpMsgBuf, "Error from CreateNamedPipe",
		    MB_OK|MB_ICONINFORMATION );
	LocalFree( lpMsgBuf );
	unireg_abort(1);
      }
  }
#endif

1311
#if defined(HAVE_SYS_UN_H)
unknown's avatar
unknown committed
1312 1313 1314
  /*
  ** Create the UNIX socket
  */
1315
  if (mysqld_unix_port[0] && !opt_bootstrap)
unknown's avatar
unknown committed
1316
  {
1317
    DBUG_PRINT("general",("UNIX Socket is %s",mysqld_unix_port));
unknown's avatar
unknown committed
1318

unknown's avatar
unknown committed
1319 1320 1321 1322 1323 1324
    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);
    }
1325
    if ((unix_sock= socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
unknown's avatar
unknown committed
1326 1327 1328 1329 1330 1331
    {
      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;
1332 1333
    strmov(UNIXaddr.sun_path, mysqld_unix_port);
    (void) unlink(mysqld_unix_port);
unknown's avatar
unknown committed
1334 1335 1336 1337 1338 1339 1340
    (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 */
1341
      sql_print_error("Do you already have another mysqld server running on socket: %s ?",mysqld_unix_port);
unknown's avatar
unknown committed
1342 1343 1344 1345
      unireg_abort(1);					/* purecov: tested */
    }
    umask(((~my_umask) & 0666));
#if defined(S_IFSOCK) && defined(SECURE_SOCKETS)
1346
    (void) chmod(mysqld_unix_port,S_IFSOCK);	/* Fix solaris 2.6 bug */
unknown's avatar
unknown committed
1347
#endif
1348
    if (listen(unix_sock,(int) back_log) < 0)
1349
      sql_print_warning("listen() on Unix socket failed with error %d",
unknown's avatar
unknown committed
1350
		      socket_errno);
unknown's avatar
unknown committed
1351 1352 1353 1354 1355 1356
  }
#endif
  DBUG_PRINT("info",("server started"));
  DBUG_VOID_RETURN;
}

1357
#endif /*!EMBEDDED_LIBRARY*/
unknown's avatar
unknown committed
1358 1359 1360

void yyerror(const char *s)
{
1361
  THD *thd=current_thd;
1362
  char *yytext= (char*) thd->lex->tok_start;
1363 1364
  /* "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
1365
    s=ER(ER_SYNTAX_ERROR);
1366
  net_printf(thd,ER_PARSE_ERROR, s, yytext ? (char*) yytext : "",
1367
	     thd->lex->yylineno);
unknown's avatar
unknown committed
1368 1369
}

1370

1371
#ifndef EMBEDDED_LIBRARY
1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384
/*
  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
*/

1385
void close_connection(THD *thd, uint errcode, bool lock)
unknown's avatar
unknown committed
1386
{
1387
  st_vio *vio;
unknown's avatar
unknown committed
1388 1389
  DBUG_ENTER("close_connection");
  DBUG_PRINT("enter",("fd: %s  error: '%s'",
1390 1391 1392
		      thd->net.vio ? vio_description(thd->net.vio) :
		      "(not connected)",
		      errcode ? ER(errcode) : ""));
unknown's avatar
unknown committed
1393 1394
  if (lock)
    (void) pthread_mutex_lock(&LOCK_thread_count);
1395
  if ((vio=thd->net.vio) != 0)
unknown's avatar
unknown committed
1396 1397
  {
    if (errcode)
1398
      send_error(thd, errcode, ER(errcode));	/* purecov: inspected */
unknown's avatar
unknown committed
1399 1400 1401 1402 1403 1404
    vio_close(vio);			/* vio is freed in delete thd */
  }
  if (lock)
    (void) pthread_mutex_unlock(&LOCK_thread_count);
  DBUG_VOID_RETURN;
}
1405 1406
#endif /* EMBEDDED_LIBRARY */

unknown's avatar
unknown committed
1407 1408 1409 1410

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

1411
extern "C" sig_handler end_thread_signal(int sig __attribute__((unused)))
unknown's avatar
unknown committed
1412 1413 1414
{
  THD *thd=current_thd;
  DBUG_ENTER("end_thread_signal");
1415
  if (thd && ! thd->bootstrap)
1416 1417
  {
    statistic_increment(killed_threads, &LOCK_status);
unknown's avatar
unknown committed
1418
    end_thread(thd,0);
1419
  }
unknown's avatar
unknown committed
1420 1421 1422 1423 1424 1425 1426
  DBUG_VOID_RETURN;				/* purecov: deadcode */
}


void end_thread(THD *thd, bool put_in_cache)
{
  DBUG_ENTER("end_thread");
unknown's avatar
unknown committed
1427
  thd->cleanup();
unknown's avatar
unknown committed
1428 1429 1430
  (void) pthread_mutex_lock(&LOCK_thread_count);
  thread_count--;
  delete thd;
1431

1432 1433
  if (put_in_cache && cached_thread_count < thread_cache_size &&
      ! abort_loop && !kill_cached_threads)
unknown's avatar
unknown committed
1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446
  {
    /* Don't kill the thread, just put it in cache for reuse */
    DBUG_PRINT("info", ("Adding thread to cache"))
    cached_thread_count++;
    while (!abort_loop && ! wake_thread && ! kill_cached_threads)
      (void) pthread_cond_wait(&COND_thread_cache, &LOCK_thread_count);
    cached_thread_count--;
    if (kill_cached_threads)
      pthread_cond_signal(&COND_flush_thread_cache);
    if (wake_thread)
    {
      wake_thread--;
      thd=thread_cache.get();
1447
      thd->real_id=pthread_self();
unknown's avatar
unknown committed
1448
      (void) thd->store_globals();
1449
      threads.append(thd);
unknown's avatar
unknown committed
1450 1451 1452 1453 1454 1455 1456 1457 1458
      pthread_mutex_unlock(&LOCK_thread_count);
      DBUG_VOID_RETURN;
    }
  }

  DBUG_PRINT("info", ("sending a broadcast"))

  /* Tell main we are ready */
  (void) pthread_mutex_unlock(&LOCK_thread_count);
1459
  /* It's safe to broadcast outside a lock (COND... is not deleted here) */
unknown's avatar
unknown committed
1460
  (void) pthread_cond_broadcast(&COND_thread_count);
unknown's avatar
unknown committed
1461
  DBUG_PRINT("info", ("unlocked thread_count mutex"))
1462
#ifdef ONE_THREAD
unknown's avatar
unknown committed
1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497
  if (!(test_flags & TEST_NO_THREADS))	// For debugging under Linux
#endif
  {
    my_thread_end();
    pthread_exit(0);
  }
  DBUG_VOID_RETURN;
}


/* Start a cached thread. LOCK_thread_count is locked on entry */

static void start_cached_thread(THD *thd)
{
  thread_cache.append(thd);
  wake_thread++;
  thread_count++;
  pthread_cond_signal(&COND_thread_cache);
}


void flush_thread_cache()
{
  (void) pthread_mutex_lock(&LOCK_thread_count);
  kill_cached_threads++;
  while (cached_thread_count)
  {
    pthread_cond_broadcast(&COND_thread_cache);
    pthread_cond_wait(&COND_flush_thread_cache,&LOCK_thread_count);
  }
  kill_cached_threads--;
  (void) pthread_mutex_unlock(&LOCK_thread_count);
}


1498 1499 1500 1501 1502
/*
  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
1503 1504

#ifdef THREAD_SPECIFIC_SIGPIPE
1505
extern "C" sig_handler abort_thread(int sig __attribute__((unused)))
unknown's avatar
unknown committed
1506 1507 1508 1509 1510 1511 1512 1513 1514 1515
{
  THD *thd=current_thd;
  DBUG_ENTER("abort_thread");
  if (thd)
    thd->killed=1;
  DBUG_VOID_RETURN;
}
#endif

/******************************************************************************
1516 1517 1518
  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
1519 1520
******************************************************************************/

unknown's avatar
unknown committed
1521
#if defined(__WIN__) || defined(OS2)
unknown's avatar
unknown committed
1522 1523 1524 1525 1526
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) ;
unknown's avatar
unknown committed
1527
#if defined(__WIN__)
unknown's avatar
unknown committed
1528
  signal(SIGBREAK,SIG_IGN);	//ignore SIGBREAK for NT
unknown's avatar
unknown committed
1529 1530 1531
#else
  signal(SIGBREAK, kill_server);
#endif
unknown's avatar
unknown committed
1532 1533
}

1534
static void start_signal_handler(void)
1535 1536 1537 1538 1539
{
  // Save vm id of this process
  if (!opt_bootstrap)
    create_pid_file();
}
unknown's avatar
unknown committed
1540 1541 1542

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

unknown's avatar
unknown committed
1544

unknown's avatar
unknown committed
1545 1546 1547 1548 1549
#elif defined(__NETWARE__)

// down server event callback
void mysql_down_server_cb(void *, void *)
{
1550
  event_flag = TRUE;  
unknown's avatar
unknown committed
1551 1552 1553
  kill_server(0);
}

unknown's avatar
unknown committed
1554

unknown's avatar
unknown committed
1555 1556
// destroy callback resources
void mysql_cb_destroy(void *)
1557 1558
{  
  UnRegisterEventNotification(eh);  // cleanup down event notification    	  
unknown's avatar
unknown committed
1559
  NX_UNWRAP_INTERFACE(ref);
1560 1561
  /* Deregister NSS volume deactivation event */  
  NX_UNWRAP_INTERFACE(refneb);  	
unknown's avatar
unknown committed
1562
  if (neb_consumer_id)
1563
    UnRegisterConsumer(neb_consumer_id, NULL);
unknown's avatar
unknown committed
1564 1565
}

unknown's avatar
unknown committed
1566

unknown's avatar
unknown committed
1567 1568 1569 1570 1571
// initialize callbacks
void mysql_cb_init()
{
  // register for down server event
  void *handle = getnlmhandle();
unknown's avatar
unknown committed
1572 1573
  rtag_t rt= AllocateResourceTag(handle, "MySQL Down Server Callback",
                                 EventSignature);
unknown's avatar
unknown committed
1574
  NX_WRAP_INTERFACE((void *)mysql_down_server_cb, 2, (void **)&ref);
unknown's avatar
unknown committed
1575 1576 1577 1578 1579 1580 1581 1582
  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
  */
1583
  (void *) NX_WRAP_INTERFACE(neb_event_callback, 1, &refneb);
unknown's avatar
unknown committed
1584 1585
  registerwithneb();

unknown's avatar
unknown committed
1586 1587 1588
  NXVmRegisterExitHandler(mysql_cb_destroy, NULL);  // clean-up
}

unknown's avatar
unknown committed
1589

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

1592
static void getvolumename()
unknown's avatar
unknown committed
1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608
{
  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
*/

1609
static void registerwithneb()
unknown's avatar
unknown committed
1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660
{

  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
*/
1661

unknown's avatar
unknown committed
1662 1663 1664
ulong neb_event_callback(struct EventBlock *eblock)
{
  EventChangeVolStateEnter_s *voldata;
1665 1666
  extern bool nw_panic;

unknown's avatar
unknown committed
1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678
  voldata= (EventChangeVolStateEnter_s *)eblock->EBEventData;

  /* Deactivation of a volume */
  if ((voldata->oldState == 6 && voldata->newState == 2))
  {
    /*
      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");
1679
      nw_panic = TRUE;
1680
      event_flag= TRUE;
unknown's avatar
unknown committed
1681
      kill_server(0);
1682
 
unknown's avatar
unknown committed
1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694
    }
  }
  return 0;
}


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

#define ADMIN_VOL_PATH					"_ADMIN:/Volumes/"

1695
static void getvolumeID(BYTE *volumeName)
unknown's avatar
unknown committed
1696 1697 1698 1699 1700 1701 1702
{
  char path[zMAX_FULL_NAME];
  Key_t rootKey= 0, fileKey= 0;
  QUAD getInfoMask;
  zInfo_s info;
  STATUS status;

1703
  /* Get the root key */
unknown's avatar
unknown committed
1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748
  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);
		
exit:
  if (rootKey)
    zClose(rootKey);
  if (fileKey)
    zClose(fileKey);
}


unknown's avatar
unknown committed
1749 1750 1751 1752 1753 1754 1755 1756
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

1757
}
unknown's avatar
unknown committed
1758

unknown's avatar
unknown committed
1759 1760 1761 1762
static void start_signal_handler(void)
{
  // Save vm id of this process
  if (!opt_bootstrap)
1763
    create_pid_file();
unknown's avatar
unknown committed
1764 1765 1766 1767
  // no signal handler
}


unknown's avatar
unknown committed
1768 1769 1770 1771 1772 1773
/*
  Warn if the data is on a Traditional volume

  NOTE
    Already done by mysqld_safe
*/
unknown's avatar
unknown committed
1774 1775

static void check_data_home(const char *path)
1776 1777 1778
{
}

unknown's avatar
unknown committed
1779 1780 1781
#elif defined(__EMX__)
static void sig_reload(int signo)
{
1782
 // Flush everything
1783
  reload_acl_and_cache((THD*) 0,REFRESH_LOG, (TABLE_LIST*) 0, NULL);
unknown's avatar
unknown committed
1784 1785 1786 1787 1788
  signal(signo, SIG_ACK);
}

static void sig_kill(int signo)
{
1789
  if (!kill_in_progress)
unknown's avatar
unknown committed
1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807
  {
    abort_loop=1;				// mark abort for threads
    kill_server((void*) signo);
  }
  signal(signo, SIG_ACK);
}

static void init_signals(void)
{
  signal(SIGQUIT, sig_kill);
  signal(SIGKILL, sig_kill);
  signal(SIGTERM, sig_kill);
  signal(SIGINT,  sig_kill);
  signal(SIGHUP,  sig_reload);	// Flush everything
  signal(SIGALRM, SIG_IGN);
  signal(SIGBREAK,SIG_IGN);
  signal_thread = pthread_self();
}
1808 1809

static void start_signal_handler(void)
unknown's avatar
unknown committed
1810
{}
1811

unknown's avatar
unknown committed
1812
static void check_data_home(const char *path)
unknown's avatar
unknown committed
1813
{}
1814

unknown's avatar
unknown committed
1815
#else /* if ! __WIN__ && ! __EMX__ */
unknown's avatar
unknown committed
1816

unknown's avatar
unknown committed
1817 1818
#ifdef HAVE_LINUXTHREADS
#define UNSAFE_DEFAULT_LINUX_THREADS 200
1819
#endif
1820

1821
extern "C" sig_handler handle_segfault(int sig)
1822
{
unknown's avatar
unknown committed
1823
  THD *thd=current_thd;
1824 1825 1826 1827 1828 1829
  /*
    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
  */
1830
  if (segfaulted)
unknown's avatar
unknown committed
1831 1832 1833 1834
  {
    fprintf(stderr, "Fatal signal %d while backtracing\n", sig);
    exit(1);
  }
1835

1836
  segfaulted = 1;
1837
  fprintf(stderr,"\
1838
mysqld got signal %d;\n\
unknown's avatar
unknown committed
1839
This could be because you hit a bug. It is also possible that this binary\n\
unknown's avatar
unknown committed
1840
or one of the libraries it was linked against is corrupt, improperly built,\n\
unknown's avatar
unknown committed
1841 1842 1843 1844 1845
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
1846
and this may fail.\n\n");
unknown's avatar
unknown committed
1847
  fprintf(stderr, "key_buffer_size=%lu\n", 
unknown's avatar
unknown committed
1848
          (ulong) dflt_key_cache->key_cache_mem_size);
unknown's avatar
unknown committed
1849
  fprintf(stderr, "read_buffer_size=%ld\n", global_system_variables.read_buff_size);
unknown's avatar
unknown committed
1850 1851 1852 1853
  fprintf(stderr, "max_used_connections=%ld\n", max_used_connections);
  fprintf(stderr, "max_connections=%ld\n", max_connections);
  fprintf(stderr, "threads_connected=%d\n", thread_count);
  fprintf(stderr, "It is possible that mysqld could use up to \n\
unknown's avatar
unknown committed
1854
key_buffer_size + (read_buffer_size + sort_buffer_size)*max_connections = %ld K\n\
unknown's avatar
unknown committed
1855
bytes of memory\n", ((ulong) dflt_key_cache->key_cache_mem_size +
1856
		     (global_system_variables.read_buff_size +
unknown's avatar
unknown committed
1857
		      global_system_variables.sortbuff_size) *
1858
		     max_connections)/ 1024);
unknown's avatar
unknown committed
1859
  fprintf(stderr, "Hope that's ok; if not, decrease some variables in the equation.\n\n");
1860

1861
#if defined(HAVE_LINUXTHREADS)
unknown's avatar
unknown committed
1862 1863 1864 1865
  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
1866 1867
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
1868
the thread stack. Please read http://www.mysql.com/doc/en/Linux.html\n\n",
unknown's avatar
unknown committed
1869 1870 1871
	    thread_count);
  }
#endif /* HAVE_LINUXTHREADS */
unknown's avatar
unknown committed
1872

unknown's avatar
unknown committed
1873
#ifdef HAVE_STACKTRACE
1874
  if (!(test_flags & TEST_NO_STACKTRACE))
unknown's avatar
unknown committed
1875
  {
1876
    fprintf(stderr,"thd=%p\n",thd);
unknown's avatar
unknown committed
1877 1878
    print_stacktrace(thd ? (gptr) thd->thread_stack : (gptr) 0,
		     thread_stack);
unknown's avatar
unknown committed
1879
  }
unknown's avatar
unknown committed
1880 1881 1882 1883 1884 1885 1886 1887
  if (thd)
  {
    fprintf(stderr, "Trying to get some variables.\n\
Some pointers may be invalid and cause the dump to abort...\n");
    safe_print_str("thd->query", thd->query, 1024);
    fprintf(stderr, "thd->thread_id=%ld\n", thd->thread_id);
  }
  fprintf(stderr, "\
unknown's avatar
unknown committed
1888
The manual page at http://www.mysql.com/doc/en/Crashing.html contains\n\
unknown's avatar
unknown committed
1889
information that should help you find out what is causing the crash.\n");
1890
  fflush(stderr);
unknown's avatar
unknown committed
1891 1892
#endif /* HAVE_STACKTRACE */

1893
 if (test_flags & TEST_CORE_ON_SIGNAL)
unknown's avatar
unknown committed
1894 1895 1896
 {
   fprintf(stderr, "Writing a core file\n");
   fflush(stderr);
1897
   write_core(sig);
unknown's avatar
unknown committed
1898
 }
1899
 exit(1);
1900 1901
}

unknown's avatar
unknown committed
1902 1903 1904 1905 1906 1907
#ifndef SA_RESETHAND
#define SA_RESETHAND 0
#endif
#ifndef SA_NODEFER
#define SA_NODEFER 0
#endif
1908

unknown's avatar
unknown committed
1909 1910 1911
static void init_signals(void)
{
  sigset_t set;
1912
  struct sigaction sa;
unknown's avatar
unknown committed
1913 1914
  DBUG_ENTER("init_signals");

1915 1916
  if (test_flags & TEST_SIGINT)
    sigset(THR_KILL_SIGNAL,end_thread_signal);
unknown's avatar
unknown committed
1917
  sigset(THR_SERVER_ALARM,print_signal_warning); // Should never be called!
unknown's avatar
unknown committed
1918

unknown's avatar
unknown committed
1919
  if (!(test_flags & TEST_NO_STACKTRACE) || (test_flags & TEST_CORE_ON_SIGNAL))
unknown's avatar
unknown committed
1920
  {
unknown's avatar
unknown committed
1921 1922 1923 1924
    sa.sa_flags = SA_RESETHAND | SA_NODEFER;
    sigemptyset(&sa.sa_mask);
    sigprocmask(SIG_SETMASK,&sa.sa_mask,NULL);

unknown's avatar
unknown committed
1925
    init_stacktrace();
unknown's avatar
unknown committed
1926 1927 1928
#if defined(__amiga__)
    sa.sa_handler=(void(*)())handle_segfault;
#else
unknown's avatar
unknown committed
1929
    sa.sa_handler=handle_segfault;
unknown's avatar
unknown committed
1930
#endif
unknown's avatar
unknown committed
1931
    sigaction(SIGSEGV, &sa, NULL);
1932
    sigaction(SIGABRT, &sa, NULL);
unknown's avatar
unknown committed
1933
#ifdef SIGBUS
unknown's avatar
unknown committed
1934
    sigaction(SIGBUS, &sa, NULL);
unknown's avatar
unknown committed
1935
#endif
unknown's avatar
unknown committed
1936
    sigaction(SIGILL, &sa, NULL);
1937
    sigaction(SIGFPE, &sa, NULL);
unknown's avatar
unknown committed
1938
  }
1939 1940 1941 1942 1943 1944 1945

#ifdef HAVE_GETRLIMIT
  if (test_flags & TEST_CORE_ON_SIGNAL)
  {
    /* Change limits so that we will get a core file */
    struct rlimit rl;
    rl.rlim_cur = rl.rlim_max = RLIM_INFINITY;
unknown's avatar
unknown committed
1946
    if (setrlimit(RLIMIT_CORE, &rl) && global_system_variables.log_warnings)
1947
      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");
1948 1949
  }
#endif
unknown's avatar
unknown committed
1950 1951 1952 1953 1954 1955 1956 1957 1958
  (void) sigemptyset(&set);
#ifdef THREAD_SPECIFIC_SIGPIPE
  sigset(SIGPIPE,abort_thread);
  sigaddset(&set,SIGPIPE);
#else
  (void) signal(SIGPIPE,SIG_IGN);		// Can't know which thread
  sigaddset(&set,SIGPIPE);
#endif
  sigaddset(&set,SIGINT);
1959
#ifndef IGNORE_SIGHUP_SIGQUIT
unknown's avatar
unknown committed
1960 1961
  sigaddset(&set,SIGQUIT);
  sigaddset(&set,SIGHUP);
1962 1963
#endif
  sigaddset(&set,SIGTERM);
1964 1965

  /* Fix signals if blocked by parents (can happen on Mac OS X) */
unknown's avatar
unknown committed
1966
  sigemptyset(&sa.sa_mask);
1967 1968 1969 1970 1971 1972
  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
1973 1974 1975 1976
#ifdef SIGTSTP
  sigaddset(&set,SIGTSTP);
#endif
  sigaddset(&set,THR_SERVER_ALARM);
1977 1978
  if (test_flags & TEST_SIGINT)
    sigdelset(&set,THR_KILL_SIGNAL);		// May be SIGINT
unknown's avatar
unknown committed
1979
  sigdelset(&set,THR_CLIENT_ALARM);		// For alarms
1980 1981
  sigprocmask(SIG_SETMASK,&set,NULL);
  pthread_sigmask(SIG_SETMASK,&set,NULL);
1982 1983 1984 1985
  DBUG_VOID_RETURN;
}


unknown's avatar
unknown committed
1986
#ifndef EMBEDDED_LIBRARY
1987 1988 1989 1990 1991
static void start_signal_handler(void)
{
  int error;
  pthread_attr_t thr_attr;
  DBUG_ENTER("start_signal_handler");
unknown's avatar
unknown committed
1992 1993 1994 1995 1996 1997 1998

  (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);
1999
  pthread_attr_setstacksize(&thr_attr,thread_stack);
unknown's avatar
unknown committed
2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016
#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;
}


2017
/* This threads handles all signals and alarms */
unknown's avatar
unknown committed
2018 2019

/* ARGSUSED */
2020
extern "C" void *signal_hand(void *arg __attribute__((unused)))
unknown's avatar
unknown committed
2021 2022 2023 2024 2025
{
  sigset_t set;
  int sig;
  my_thread_init();				// Init new thread
  DBUG_ENTER("signal_hand");
unknown's avatar
unknown committed
2026 2027
  signal_thread_in_use= 1;

unknown's avatar
unknown committed
2028 2029
  /*
    Setup alarm handler
2030 2031
    This should actually be '+ max_number_of_slaves' instead of +10,
    but the +10 should be quite safe.
unknown's avatar
unknown committed
2032
  */
2033 2034
  init_thr_alarm(max_connections +
		 global_system_variables.max_insert_delayed_threads + 10);
unknown's avatar
unknown committed
2035
#if SIGINT != THR_KILL_SIGNAL
2036 2037 2038 2039 2040 2041
  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
2042 2043 2044 2045 2046
#endif
  (void) sigemptyset(&set);			// Setup up SIGINT for debug
#ifdef USE_ONE_SIGNAL_HAND
  (void) sigaddset(&set,THR_SERVER_ALARM);	// For alarms
#endif
2047
#ifndef IGNORE_SIGHUP_SIGQUIT
unknown's avatar
unknown committed
2048 2049 2050 2051
  (void) sigaddset(&set,SIGQUIT);
#if THR_CLIENT_ALARM != SIGHUP
  (void) sigaddset(&set,SIGHUP);
#endif
2052 2053
#endif
  (void) sigaddset(&set,SIGTERM);
unknown's avatar
unknown committed
2054 2055 2056
  (void) sigaddset(&set,SIGTSTP);

  /* Save pid to this process (or thread on Linux) */
2057
  if (!opt_bootstrap)
2058 2059
    create_pid_file();

2060 2061 2062 2063 2064 2065 2066
#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
2067

2068 2069 2070 2071 2072 2073 2074
  /*
    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
2075 2076
  (void) pthread_mutex_lock(&LOCK_thread_count);
  (void) pthread_mutex_unlock(&LOCK_thread_count);
2077
  (void) pthread_cond_broadcast(&COND_thread_count);
unknown's avatar
unknown committed
2078

2079
  (void) pthread_sigmask(SIG_BLOCK,&set,NULL);
unknown's avatar
unknown committed
2080 2081 2082 2083 2084
  for (;;)
  {
    int error;					// Used when debugging
    if (shutdown_in_progress && !abort_loop)
    {
2085
      sig= SIGTERM;
unknown's avatar
unknown committed
2086 2087 2088 2089 2090
      error=0;
    }
    else
      while ((error=my_sigwait(&set,&sig)) == EINTR) ;
    if (cleanup_done)
2091 2092
    {
      my_thread_end();
unknown's avatar
unknown committed
2093
      signal_thread_in_use= 0;
unknown's avatar
unknown committed
2094
      pthread_exit(0);				// Safety
2095
    }
unknown's avatar
unknown committed
2096 2097 2098 2099 2100
    switch (sig) {
    case SIGTERM:
    case SIGQUIT:
    case SIGKILL:
#ifdef EXTRA_DEBUG
2101
      sql_print_information("Got signal %d to shutdown mysqld",sig);
unknown's avatar
unknown committed
2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112
#endif
      DBUG_PRINT("info",("Got signal: %d  abort_loop: %d",sig,abort_loop));
      if (!abort_loop)
      {
	abort_loop=1;				// mark abort for threads
#ifdef USE_ONE_SIGNAL_HAND
	pthread_t tmp;
	if (!(opt_specialflag & SPECIAL_NO_PRIOR))
	  my_pthread_attr_setprio(&connection_attrib,INTERRUPT_PRIOR);
	if (pthread_create(&tmp,&connection_attrib, kill_server_thread,
			   (void*) sig))
2113
	  sql_print_error("Can't create thread to kill server");
unknown's avatar
unknown committed
2114
#else
unknown's avatar
unknown committed
2115
	kill_server((void*) sig);	// MIT THREAD has a alarm thread
unknown's avatar
unknown committed
2116 2117 2118 2119
#endif
      }
      break;
    case SIGHUP:
unknown's avatar
unknown committed
2120 2121
      if (!abort_loop)
      {
unknown's avatar
unknown committed
2122
	mysql_print_status((THD*) 0);		// Print some debug info
unknown's avatar
unknown committed
2123 2124 2125 2126
	reload_acl_and_cache((THD*) 0,
			     (REFRESH_LOG | REFRESH_TABLES | REFRESH_FAST |
			      REFRESH_STATUS | REFRESH_GRANT |
			      REFRESH_THREADS | REFRESH_HOSTS),
2127
			     (TABLE_LIST*) 0, NULL); // Flush logs
unknown's avatar
unknown committed
2128
      }
unknown's avatar
unknown committed
2129 2130 2131 2132 2133 2134 2135 2136
      break;
#ifdef USE_ONE_SIGNAL_HAND
    case THR_SERVER_ALARM:
      process_alarm(sig);			// Trigger alarms.
      break;
#endif
    default:
#ifdef EXTRA_DEBUG
2137
      sql_print_warning("Got signal: %d  error: %d",sig,error); /* purecov: tested */
unknown's avatar
unknown committed
2138 2139 2140 2141 2142 2143
#endif
      break;					/* purecov: tested */
    }
  }
  return(0);					/* purecov: deadcode */
}
unknown's avatar
unknown committed
2144
#endif /*!EMBEDDED_LIBRARY*/
unknown's avatar
unknown committed
2145

unknown's avatar
unknown committed
2146
static void check_data_home(const char *path)
unknown's avatar
unknown committed
2147
{}
unknown's avatar
unknown committed
2148

unknown's avatar
unknown committed
2149 2150 2151 2152
#endif	/* __WIN__*/


/*
2153 2154
  All global error messages are sent here where the first one is stored for
  the client
unknown's avatar
unknown committed
2155 2156 2157 2158
*/


/* ARGSUSED */
unknown's avatar
unknown committed
2159
extern "C" int my_message_sql(uint error, const char *str, myf MyFlags)
unknown's avatar
unknown committed
2160
{
2161
  THD *thd;
unknown's avatar
unknown committed
2162
  DBUG_ENTER("my_message_sql");
2163 2164
  DBUG_PRINT("error", ("Message: '%s'", str));
  if ((thd= current_thd))
unknown's avatar
unknown committed
2165
  {
unknown's avatar
unknown committed
2166
    /*
2167
      thd->lex->current_select == 0 if lex structure is not inited
unknown's avatar
unknown committed
2168 2169
      (not query command (COM_QUERY))
    */
2170 2171
    if (thd->lex->current_select &&
	thd->lex->current_select->no_error && !thd->is_fatal_error)
unknown's avatar
unknown committed
2172
    {
unknown's avatar
unknown committed
2173 2174 2175 2176 2177
      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));
                           
2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188
      push_warning(thd, MYSQL_ERROR::WARN_LEVEL_ERROR, error, str);
    }
    else
    {
      NET *net= &thd->net;
      net->report_error= 1;
      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
2189 2190
    }
  }
unknown's avatar
unknown committed
2191
  if (!thd || MyFlags & ME_NOREFRESH)
unknown's avatar
unknown committed
2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202
    sql_print_error("%s: %s",my_progname,str); /* purecov: inspected */
  DBUG_RETURN(0);
}

#ifdef __WIN__

struct utsname
{
  char nodename[FN_REFLEN];
};

unknown's avatar
unknown committed
2203

unknown's avatar
unknown committed
2204 2205 2206 2207 2208 2209
int uname(struct utsname *a)
{
  return -1;
}


2210
extern "C" pthread_handler_decl(handle_shutdown,arg)
unknown's avatar
unknown committed
2211 2212 2213 2214 2215 2216
{
  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
2217
#if !defined(EMBEDDED_LIBRARY)
unknown's avatar
unknown committed
2218
  if (WaitForSingleObject(hEventShutdown,INFINITE)==WAIT_OBJECT_0)
2219
#endif /* EMBEDDED_LIBRARY */
unknown's avatar
unknown committed
2220 2221 2222 2223
     kill_server(MYSQL_KILL_SIGNAL);
  return 0;
}

unknown's avatar
unknown committed
2224

unknown's avatar
unknown committed
2225
int STDCALL handle_kill(ulong ctrl_type)
unknown's avatar
unknown committed
2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236
{
  if (ctrl_type == CTRL_CLOSE_EVENT ||
      ctrl_type == CTRL_SHUTDOWN_EVENT)
  {
    kill_server(MYSQL_KILL_SIGNAL);
    return TRUE;
  }
  return FALSE;
}
#endif

2237

unknown's avatar
unknown committed
2238
#ifdef OS2
2239
extern "C" pthread_handler_decl(handle_shutdown,arg)
unknown's avatar
unknown committed
2240 2241 2242 2243 2244 2245 2246 2247 2248
{
  my_thread_init();

  // wait semaphore
  pthread_cond_wait( &eventShutdown, NULL);

  // close semaphore and kill server
  pthread_cond_destroy( &eventShutdown);

2249 2250 2251 2252
  /*
    Exit main loop on main thread, so kill will be done from
    main thread (this is thread 2)
  */
unknown's avatar
unknown committed
2253 2254 2255
  abort_loop = 1;

  // unblock select()
2256 2257
  so_cancel(ip_sock);
  so_cancel(unix_sock);
unknown's avatar
unknown committed
2258 2259 2260 2261 2262

  return 0;
}
#endif

2263

2264 2265 2266 2267 2268 2269 2270
const char *load_default_groups[]= { 
#ifdef HAVE_NDBCLUSTER_DB
"mysql_cluster",
#endif
"mysqld","server",MYSQL_BASE_VERSION,0,0};
static const int load_default_groups_sz=
sizeof(load_default_groups)/sizeof(load_default_groups[0]);
unknown's avatar
unknown committed
2271

2272 2273 2274 2275
bool open_log(MYSQL_LOG *log, const char *hostname,
	      const char *opt_name, const char *extension,
	      const char *index_file_name,
	      enum_log_type type, bool read_append,
2276
	      bool no_auto_events, ulong max_size)
unknown's avatar
unknown committed
2277 2278 2279 2280
{
  char tmp[FN_REFLEN];
  if (!opt_name || !opt_name[0])
  {
2281 2282 2283
    /*
      TODO: The following should be using fn_format();  We just need to
      first change fn_format() to cut the file name if it's too long.
unknown's avatar
unknown committed
2284 2285
    */
    strmake(tmp,hostname,FN_REFLEN-5);
2286
    strmov(fn_ext(tmp),extension);
unknown's avatar
unknown committed
2287 2288
    opt_name=tmp;
  }
2289
  // get rid of extension if the log is binary to avoid problems
2290 2291
  if (type == LOG_BIN)
  {
unknown's avatar
unknown committed
2292
    char *p = fn_ext(opt_name);
unknown's avatar
unknown committed
2293 2294 2295
    uint length=(uint) (p-opt_name);
    strmake(tmp,opt_name,min(length,FN_REFLEN));
    opt_name=tmp;
2296
  }
2297 2298
  return log->open(opt_name, type, 0, index_file_name,
		   (read_append) ? SEQ_READ_APPEND : WRITE_CACHE,
2299
		   no_auto_events, max_size);
unknown's avatar
unknown committed
2300 2301 2302
}


2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321
/*
  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
  
  NOTES
    The default value is taken from either opt_date_time_formats[] or
    the ISO format (ANSI SQL)

  RETURN
    0 ok
    1 error
*/

bool init_global_datetime_format(timestamp_type format_type,
				 DATE_TIME_FORMAT **var_ptr)
2322
{
2323 2324
  /* Get command line option */
  const char *str= opt_date_time_formats[format_type];
2325

2326
  if (!str)					// No specified format
2327
  {
2328 2329 2330 2331 2332 2333 2334
    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;
2335
  }
2336
  if (!(*var_ptr= date_time_format_make(format_type, str, strlen(str))))
2337
  {
2338 2339
    fprintf(stderr, "Wrong date/time format specifier: %s\n", str);
    return 1;
2340
  }
2341
  return 0;
2342 2343 2344
}


2345 2346
static int init_common_variables(const char *conf_file_name, int argc,
				 char **argv, const char **groups)
unknown's avatar
unknown committed
2347
{
unknown's avatar
unknown committed
2348
  umask(((~my_umask) & 0666));
unknown's avatar
unknown committed
2349 2350
  tzset();			// Set tzname

unknown's avatar
SCRUM  
unknown committed
2351
  max_system_variables.pseudo_thread_id= (ulong)~0;
unknown's avatar
unknown committed
2352
  start_time=time((time_t*) 0);
unknown's avatar
unknown committed
2353 2354
  if (init_thread_environment())
    return 1;
unknown's avatar
unknown committed
2355
  mysql_init_variables();
unknown's avatar
unknown committed
2356

unknown's avatar
unknown committed
2357 2358 2359 2360 2361 2362 2363 2364
#ifdef OS2
  {
    // fix timezone for daylight saving
    struct tm *ts = localtime(&start_time);
    if (ts->tm_isdst > 0)
      _timezone -= 3600;
  }
#endif
unknown's avatar
unknown committed
2365 2366 2367 2368
#ifdef HAVE_TZNAME
  {
    struct tm tm_tmp;
    localtime_r(&start_time,&tm_tmp);
2369
    strmov(system_time_zone, tzname[tm_tmp.tm_isdst != 0 ? 1 : 0]);
unknown's avatar
unknown committed
2370 2371
  }
#endif
2372 2373 2374 2375 2376 2377 2378 2379
  /*
    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
2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390
  /*
    Init mutexes for the global MYSQL_LOG objects.
    As safe_mutex depends on what MY_INIT() does, we can't init the mutexes of
    global MYSQL_LOGs in their constructors, because then they would be inited
    before MY_INIT(). So we do it here.
  */
  mysql_log.init_pthread_objects();
  mysql_update_log.init_pthread_objects();
  mysql_slow_log.init_pthread_objects();
  mysql_bin_log.init_pthread_objects();
  
unknown's avatar
unknown committed
2391 2392
  if (gethostname(glob_hostname,sizeof(glob_hostname)-4) < 0)
    strmov(glob_hostname,"mysql");
unknown's avatar
unknown committed
2393
  strmake(pidfile_name, glob_hostname, sizeof(pidfile_name)-5);
2394
  strmov(fn_ext(pidfile_name),".pid");		// Add proper extension
unknown's avatar
unknown committed
2395

unknown's avatar
unknown committed
2396 2397
  load_defaults(conf_file_name, groups, &argc, &argv);
  defaults_argv=argv;
unknown's avatar
unknown committed
2398
  get_options(argc,argv);
2399 2400
  set_server_version();

unknown's avatar
unknown committed
2401 2402 2403
  DBUG_PRINT("info",("%s  Ver %s for %s on %s\n",my_progname,
		     server_version, SYSTEM_TYPE,MACHINE_TYPE));

unknown's avatar
unknown committed
2404 2405
  /* connections and databases needs lots of files */
  {
2406 2407 2408 2409
    uint files, wanted_files;

    wanted_files= 10+(uint) max(max_connections*5,
				 max_connections+table_cache_size*2);
unknown's avatar
unknown committed
2410
    set_if_bigger(wanted_files, open_files_limit);
2411 2412 2413
    files= my_set_max_open_files(wanted_files);

    if (files < wanted_files)
unknown's avatar
unknown committed
2414
    {
2415 2416 2417 2418 2419 2420 2421
      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
2422
	if (global_system_variables.log_warnings)
2423
	  sql_print_warning("Changed limits: max_open_files: %u  max_connections: %ld  table_cache: %ld",
2424 2425
			files, max_connections, table_cache_size);
      }
unknown's avatar
unknown committed
2426
      else if (global_system_variables.log_warnings)
2427
	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
2428
    }
unknown's avatar
unknown committed
2429
    open_files_limit= files;
unknown's avatar
unknown committed
2430 2431
  }
  unireg_init(opt_specialflag); /* Set up extern variabels */
2432 2433
  if (init_errmessage())	/* Read error messages from file */
    return 1;
2434
  init_client_errs();
unknown's avatar
unknown committed
2435 2436 2437 2438 2439
  lex_init();
  item_init();
  set_var_init();
  mysys_uses_curses=0;
#ifdef USE_REGEX
unknown's avatar
unknown committed
2440
  regex_init(&my_charset_latin1);
unknown's avatar
unknown committed
2441
#endif
2442
  if (!(default_charset_info= get_charset_by_csname(default_character_set_name,
2443 2444
						    MY_CS_PRIMARY,
						    MYF(MY_WME))))
unknown's avatar
unknown committed
2445
    return 1;
2446 2447
  if (default_collation_name)
  {
unknown's avatar
unknown committed
2448 2449
    CHARSET_INFO *default_collation;
    default_collation= get_charset_by_name(default_collation_name, MYF(0));
unknown's avatar
unknown committed
2450 2451 2452 2453 2454 2455
    if (!default_collation)
    {
      sql_print_error(ER(ER_UNKNOWN_COLLATION), default_collation_name);
      return 1;
    }
    if (!my_charset_same(default_charset_info, default_collation))
2456 2457 2458 2459 2460 2461 2462 2463
    {
      sql_print_error(ER(ER_COLLATION_CHARSET_MISMATCH),
		      default_collation_name,
		      default_charset_info->csname);
      return 1;
    }
    default_charset_info= default_collation;
  }
2464 2465 2466 2467
  /* 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;
2468
  global_system_variables.character_set_results= default_charset_info;
2469
  global_system_variables.character_set_client= default_charset_info;
unknown's avatar
unknown committed
2470
  global_system_variables.collation_connection= default_charset_info;
2471

unknown's avatar
unknown committed
2472 2473 2474
  sys_init_connect.value_length= 0;
  if ((sys_init_connect.value= opt_init_connect))
    sys_init_connect.value_length= strlen(opt_init_connect);
2475 2476
  else
    sys_init_connect.value=my_strdup("",MYF(0));
unknown's avatar
unknown committed
2477 2478 2479 2480

  sys_init_slave.value_length= 0;
  if ((sys_init_slave.value= opt_init_slave))
    sys_init_slave.value_length= strlen(opt_init_slave);
2481 2482
  else
    sys_init_slave.value=my_strdup("",MYF(0));
2483

2484
  if (use_temp_pool && bitmap_init(&temp_pool,0,1024,1))
2485
    return 1;
unknown's avatar
unknown committed
2486 2487 2488
  if (my_dbopt_init())
    return 1;

unknown's avatar
unknown committed
2489 2490
  return 0;
}
unknown's avatar
unknown committed
2491

2492 2493

static int init_thread_environment()
unknown's avatar
unknown committed
2494
{
2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509
  (void) pthread_mutex_init(&LOCK_mysql_create_db,MY_MUTEX_INIT_SLOW);
  (void) pthread_mutex_init(&LOCK_Acl,MY_MUTEX_INIT_SLOW);
  (void) pthread_mutex_init(&LOCK_open,MY_MUTEX_INIT_FAST);
  (void) pthread_mutex_init(&LOCK_thread_count,MY_MUTEX_INIT_FAST);
  (void) pthread_mutex_init(&LOCK_mapped_file,MY_MUTEX_INIT_SLOW);
  (void) pthread_mutex_init(&LOCK_status,MY_MUTEX_INIT_FAST);
  (void) pthread_mutex_init(&LOCK_error_log,MY_MUTEX_INIT_FAST);
  (void) pthread_mutex_init(&LOCK_delayed_insert,MY_MUTEX_INIT_FAST);
  (void) pthread_mutex_init(&LOCK_delayed_status,MY_MUTEX_INIT_FAST);
  (void) pthread_mutex_init(&LOCK_delayed_create,MY_MUTEX_INIT_SLOW);
  (void) pthread_mutex_init(&LOCK_manager,MY_MUTEX_INIT_FAST);
  (void) pthread_mutex_init(&LOCK_crypt,MY_MUTEX_INIT_FAST);
  (void) pthread_mutex_init(&LOCK_bytes_sent,MY_MUTEX_INIT_FAST);
  (void) pthread_mutex_init(&LOCK_bytes_received,MY_MUTEX_INIT_FAST);
  (void) pthread_mutex_init(&LOCK_user_conn, MY_MUTEX_INIT_FAST);
2510
  (void) pthread_mutex_init(&LOCK_active_mi, MY_MUTEX_INIT_FAST);
2511
  (void) pthread_mutex_init(&LOCK_global_system_variables, MY_MUTEX_INIT_FAST);
unknown's avatar
unknown committed
2512
  (void) pthread_mutex_init(&LOCK_uuid_generator, MY_MUTEX_INIT_FAST);
unknown's avatar
unknown committed
2513 2514
  (void) my_rwlock_init(&LOCK_sys_init_connect, NULL);
  (void) my_rwlock_init(&LOCK_sys_init_slave, NULL);
2515
  (void) my_rwlock_init(&LOCK_grant, NULL);
unknown's avatar
unknown committed
2516 2517 2518 2519
  (void) pthread_cond_init(&COND_thread_count,NULL);
  (void) pthread_cond_init(&COND_refresh,NULL);
  (void) pthread_cond_init(&COND_thread_cache,NULL);
  (void) pthread_cond_init(&COND_flush_thread_cache,NULL);
2520
  (void) pthread_cond_init(&COND_manager,NULL);
unknown's avatar
SCRUM  
unknown committed
2521
#ifdef HAVE_REPLICATION
2522
  (void) pthread_mutex_init(&LOCK_rpl_status, MY_MUTEX_INIT_FAST);
2523
  (void) pthread_cond_init(&COND_rpl_status, NULL);
2524
#endif
unknown's avatar
unknown committed
2525 2526 2527 2528 2529
  /* 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);
2530 2531
  if (!(opt_specialflag & SPECIAL_NO_PRIOR))
    my_pthread_attr_setprio(&connection_attrib,WAIT_PRIOR);
unknown's avatar
unknown committed
2532

unknown's avatar
unknown committed
2533 2534 2535 2536 2537 2538 2539 2540 2541
  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;
}

2542

unknown's avatar
unknown committed
2543 2544
static void init_ssl()
{
unknown's avatar
unknown committed
2545 2546 2547
#ifdef HAVE_OPENSSL
  if (opt_use_ssl)
  {
2548 2549 2550 2551
    /* 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
unknown committed
2552
    DBUG_PRINT("info",("ssl_acceptor_fd: %lx", (long) ssl_acceptor_fd));
unknown's avatar
unknown committed
2553
    if (!ssl_acceptor_fd)
unknown's avatar
unknown committed
2554
      opt_use_ssl = 0;
unknown's avatar
unknown committed
2555
  }
unknown's avatar
unknown committed
2556 2557
  if (des_key_file)
    load_des_key_file(des_key_file);
unknown's avatar
unknown committed
2558
#endif /* HAVE_OPENSSL */
unknown's avatar
unknown committed
2559
}
unknown's avatar
unknown committed
2560

2561

unknown's avatar
unknown committed
2562 2563
static int init_server_components()
{
2564
  DBUG_ENTER("init_server_components");
2565 2566
  if (table_cache_init() || hostname_cache_init())
    unireg_abort(1);
unknown's avatar
unknown committed
2567

unknown's avatar
unknown committed
2568
  query_cache_result_size_limit(query_cache_limit);
2569
  query_cache_set_min_res_unit(query_cache_min_res_unit);
unknown's avatar
unknown committed
2570
  query_cache_resize(query_cache_size);
unknown's avatar
unknown committed
2571 2572 2573
  randominit(&sql_rand,(ulong) start_time,(ulong) start_time/2);
  reset_floating_point_exceptions();
  init_thr_lock();
unknown's avatar
SCRUM  
unknown committed
2574
#ifdef HAVE_REPLICATION
2575
  init_slave_list();
2576
#endif
unknown's avatar
unknown committed
2577 2578
  /* Setup log files */
  if (opt_log)
2579
    open_log(&mysql_log, glob_hostname, opt_logname, ".log", NullS,
2580
	     LOG_NORMAL, 0, 0, 0);
unknown's avatar
unknown committed
2581
  if (opt_update_log)
unknown's avatar
unknown committed
2582
  {
unknown's avatar
unknown committed
2583
    open_log(&mysql_update_log, glob_hostname, opt_update_logname, "",
unknown's avatar
unknown committed
2584
	     NullS, LOG_NEW, 0, 0, 0);
unknown's avatar
unknown committed
2585 2586
    using_update_log=1;
  }
unknown's avatar
unknown committed
2587
  if (opt_slow_log)
unknown's avatar
unknown committed
2588
    open_log(&mysql_slow_log, glob_hostname, opt_slow_logname, "-slow.log",
unknown's avatar
unknown committed
2589
 	     NullS, LOG_NORMAL, 0, 0, 0);
2590 2591 2592

  if (opt_bin_log)
  {
2593 2594 2595 2596
    /* If we fail to open binlog, it's going to hinder our recovery, so die */
    if (open_log(&mysql_bin_log, glob_hostname, opt_bin_logname, "-bin",
		 opt_binlog_index_name, LOG_BIN, 0, 0, max_binlog_size))
      unireg_abort(1);
2597
    using_update_log=1;
unknown's avatar
unknown committed
2598
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
2599 2600 2601 2602
    if (expire_logs_days)
    {
      long purge_time= time(0) - expire_logs_days*24*60*60;
      if (purge_time >= 0)
2603
	mysql_bin_log.purge_logs_before_date(purge_time);
unknown's avatar
unknown committed
2604
    }
unknown's avatar
unknown committed
2605
#endif
2606
  }
unknown's avatar
unknown committed
2607 2608
  else if (opt_log_slave_updates)
  {
2609 2610
      sql_print_warning("\
you need to use --log-bin to make --log-slave-updates work. \
unknown's avatar
unknown committed
2611 2612
Now disabling --log-slave-updates.");
  }
2613

unknown's avatar
unknown committed
2614
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
2615 2616 2617
  if (opt_log_slave_updates && replicate_same_server_id)
  {
    sql_print_error("\
2618
using --replicate-same-server-id in conjunction with \
unknown's avatar
unknown committed
2619 2620 2621 2622
--log-slave-updates is impossible, it would lead to infinite loops in this \
server.");
    unireg_abort(1);
  }
unknown's avatar
unknown committed
2623
#endif
2624 2625

  if (opt_error_log)
2626
  {
2627
    if (!log_error_file_ptr[0])
2628 2629
      fn_format(log_error_file, glob_hostname, mysql_data_home, ".err",
                MY_REPLACE_EXT); /* replace '.<domain>' by '.err', bug#4997 */
2630 2631 2632 2633 2634
    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
unknown's avatar
unknown committed
2635 2636
    else
    {
unknown's avatar
unknown committed
2637
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
2638
      if (freopen(log_error_file, "a+", stdout))
unknown's avatar
unknown committed
2639
#endif
2640 2641
	freopen(log_error_file, "a+", stderr);
    }
2642
  }
unknown's avatar
unknown committed
2643

2644 2645
  if (opt_innodb_safe_binlog)
  {
2646
    if (have_innodb != SHOW_OPTION_YES)
2647
      sql_print_warning("--innodb-safe-binlog is meaningful only if "
2648
                      "the InnoDB storage engine is enabled in the server.");
unknown's avatar
unknown committed
2649
#ifdef HAVE_INNOBASE_DB
2650 2651
    if (innobase_flush_log_at_trx_commit != 1)
    {
2652
      sql_print_warning("--innodb-safe-binlog is meaningful only if "
2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663
                      "innodb_flush_log_at_trx_commit is 1; now setting it "
                      "to 1.");
      innobase_flush_log_at_trx_commit= 1;
    }
    if (innobase_unix_file_flush_method)
    {
      /*
        This option has so many values that it's hard to know which value is
        good (especially "littlesync", and on Windows... see
        srv/srv0start.c).
      */
2664
      sql_print_warning("--innodb-safe-binlog requires that "
2665 2666 2667 2668 2669 2670
                      "the innodb_flush_method actually synchronizes the "
                      "InnoDB log to disk; it is your responsibility "
                      "to verify that the method you chose does it.");
    }
    if (sync_binlog_period != 1)
    {
2671
      sql_print_warning("--innodb-safe-binlog is meaningful only if "
2672 2673 2674 2675
                      "the global sync_binlog variable is 1; now setting it "
                      "to 1.");
      sync_binlog_period= 1;
    }
unknown's avatar
unknown committed
2676
#endif
2677 2678
  }

unknown's avatar
unknown committed
2679 2680 2681
  if (ha_init())
  {
    sql_print_error("Can't init databases");
unknown's avatar
unknown committed
2682
    unireg_abort(1);
unknown's avatar
unknown committed
2683
  }
2684 2685
  if (opt_myisam_log)
    (void) mi_log(1);
unknown's avatar
unknown committed
2686

unknown's avatar
unknown committed
2687 2688 2689 2690 2691 2692
  /*
    Now that InnoDB is initialized, we can know the last good binlog position
    and cut the binlog if needed. This function does nothing if there was no
    crash recovery by InnoDB.
  */
  if (opt_innodb_safe_binlog)
2693
  {
unknown's avatar
unknown committed
2694 2695
    /* not fatal if fails (but print errors) */
    mysql_bin_log.cut_spurious_tail();
2696
  }
unknown's avatar
unknown committed
2697 2698
  mysql_bin_log.report_pos_in_innodb();

2699 2700
  /* call ha_init_key_cache() on all key caches to init them */
  process_key_caches(&ha_init_key_cache);
unknown's avatar
unknown committed
2701

unknown's avatar
unknown committed
2702
#if defined(HAVE_MLOCKALL) && defined(MCL_CURRENT) && !defined(EMBEDDED_LIBRARY)
2703
  if (locked_in_memory && !getuid())
2704
  {
2705
    if (setreuid((uid_t)-1, 0) == -1)
2706
    {                        // this should never happen
2707
      sql_perror("setreuid");
2708 2709
      unireg_abort(1);
    }
2710 2711
    if (mlockall(MCL_CURRENT))
    {
2712
      if (global_system_variables.log_warnings)
2713
	sql_print_warning("Failed to lock memory. Errno: %d\n",errno);
unknown's avatar
unknown committed
2714
      locked_in_memory= 0;
2715
    }
2716 2717
    if (user_info)
      set_user(mysqld_user, user_info);
2718
  }
unknown's avatar
unknown committed
2719
  else
2720
#endif
unknown's avatar
unknown committed
2721
    locked_in_memory=0;
2722

2723
  ft_init_stopwords();
unknown's avatar
unknown committed
2724

unknown's avatar
unknown committed
2725
  init_max_user_conn();
2726
  init_update_queries();
2727
  DBUG_RETURN(0);
unknown's avatar
unknown committed
2728
}
unknown's avatar
unknown committed
2729

2730

unknown's avatar
unknown committed
2731 2732 2733 2734
static void create_maintenance_thread()
{
  if (
#ifdef HAVE_BERKELEY_DB
2735
      (have_berkeley_db == SHOW_OPTION_YES) ||
unknown's avatar
unknown committed
2736 2737
#endif
      (flush_time && flush_time != ~(ulong) 0L))
unknown's avatar
unknown committed
2738
  {
unknown's avatar
unknown committed
2739 2740
    pthread_t hThread;
    if (pthread_create(&hThread,&connection_attrib,handle_manager,0))
2741
      sql_print_warning("Can't create thread to manage maintenance");
unknown's avatar
unknown committed
2742
  }
unknown's avatar
unknown committed
2743 2744
}

2745

unknown's avatar
unknown committed
2746 2747
static void create_shutdown_thread()
{
2748
#if !defined(EMBEDDED_LIBRARY)
unknown's avatar
unknown committed
2749
#ifdef __WIN__
2750 2751 2752
  hEventShutdown=CreateEvent(0, FALSE, FALSE, shutdown_event_name);
  pthread_t hThread;
  if (pthread_create(&hThread,&connection_attrib,handle_shutdown,0))
2753
    sql_print_warning("Can't create thread to handle shutdown requests");
unknown's avatar
unknown committed
2754

2755 2756
  // On "Stop Service" we have to do regular shutdown
  Service.SetShutdownEvent(hEventShutdown);
unknown's avatar
unknown committed
2757
#endif
unknown's avatar
unknown committed
2758
#ifdef OS2
2759 2760 2761
  pthread_cond_init(&eventShutdown, NULL);
  pthread_t hThread;
  if (pthread_create(&hThread,&connection_attrib,handle_shutdown,0))
2762
    sql_print_warning("Can't create thread to handle shutdown requests");
unknown's avatar
unknown committed
2763
#endif
2764
#endif // EMBEDDED_LIBRARY 
unknown's avatar
unknown committed
2765
}
unknown's avatar
unknown committed
2766

2767 2768 2769

#if defined(__NT__) || defined(HAVE_SMEM)
static void handle_connections_methods()
unknown's avatar
unknown committed
2770
{
2771 2772 2773
  pthread_t hThread;
  DBUG_ENTER("handle_connections_methods");
#ifdef __NT__
unknown's avatar
unknown committed
2774
  if (hPipe == INVALID_HANDLE_VALUE &&
2775 2776
      (!have_tcpip || opt_disable_networking) &&
      !opt_enable_shared_memory)
unknown's avatar
unknown committed
2777
  {
unknown's avatar
unknown committed
2778
    sql_print_error("TCP/IP, --shared-memory, or --named-pipe should be configured on NT OS");
2779
    unireg_abort(1);				// Will not return
unknown's avatar
unknown committed
2780
  }
2781 2782 2783 2784 2785 2786 2787
#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
2788
  {
2789 2790 2791
    handler_count++;
    if (pthread_create(&hThread,&connection_attrib,
		       handle_connections_namedpipes, 0))
unknown's avatar
unknown committed
2792
    {
2793
      sql_print_warning("Can't create thread to handle named pipes");
2794 2795 2796 2797 2798 2799 2800 2801 2802 2803
      handler_count--;
    }
  }
#endif /* __NT__ */
  if (have_tcpip && !opt_disable_networking)
  {
    handler_count++;
    if (pthread_create(&hThread,&connection_attrib,
		       handle_connections_sockets, 0))
    {
2804
      sql_print_warning("Can't create thread to handle TCP/IP");
2805 2806 2807 2808 2809 2810 2811 2812 2813 2814
      handler_count--;
    }
  }
#ifdef HAVE_SMEM
  if (opt_enable_shared_memory)
  {
    handler_count++;
    if (pthread_create(&hThread,&connection_attrib,
		       handle_connections_shared_memory, 0))
    {
2815
      sql_print_warning("Can't create thread to handle shared memory");
2816
      handler_count--;
unknown's avatar
unknown committed
2817 2818
    }
  }
2819
#endif 
unknown's avatar
unknown committed
2820

2821 2822 2823 2824 2825
  while (handler_count > 0)
    pthread_cond_wait(&COND_handler_count,&LOCK_thread_count);
  pthread_mutex_unlock(&LOCK_thread_count);
  DBUG_VOID_RETURN;
}
2826 2827 2828 2829 2830 2831 2832 2833 2834 2835

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()
2836 2837 2838
#endif /* defined(__NT__) || defined(HAVE_SMEM) */


2839
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
2840 2841 2842 2843 2844 2845
#ifdef __WIN__
int win_main(int argc, char **argv)
#else
int main(int argc, char **argv)
#endif
{
2846

unknown's avatar
unknown committed
2847 2848
  DEBUGGER_OFF;

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

unknown's avatar
unknown committed
2851
#ifdef _CUSTOMSTARTUPCONFIG_
unknown's avatar
unknown committed
2852 2853 2854 2855 2856 2857
  if (_cust_check_startup())
  {
    / * _cust_check_startup will report startup failure error * /
    exit( 1 );
  }
#endif
unknown's avatar
unknown committed
2858

2859 2860 2861
  if (init_common_variables(MYSQL_CONFIG_NAME,
			    argc, argv, load_default_groups))
    unireg_abort(1);				// Will do exit
unknown's avatar
unknown committed
2862 2863 2864 2865

  init_signals();
  if (!(opt_specialflag & SPECIAL_NO_PRIOR))
    my_pthread_setprio(pthread_self(),CONNECT_PRIOR);
2866
  pthread_attr_setstacksize(&connection_attrib,thread_stack);
2867 2868 2869 2870 2871 2872 2873 2874 2875
#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);
    /* 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)
2876
	sql_print_warning("Asked for %ld thread stack, but got %ld",
2877 2878 2879 2880 2881
			thread_stack, stack_size);
      thread_stack= stack_size;
    }
  }
#endif
unknown's avatar
unknown committed
2882 2883
  thread_stack_min=thread_stack - STACK_MIN_SIZE;

2884
  (void) thr_setconcurrency(concurrency);	// 10 by default
unknown's avatar
unknown committed
2885

unknown's avatar
unknown committed
2886 2887 2888 2889 2890
  /*
    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.
  */
unknown's avatar
unknown committed
2891
  DBUG_PRINT("info", ("lower_case_table_names: %d", lower_case_table_names));
unknown's avatar
unknown committed
2892
  if (!lower_case_table_names &&
unknown's avatar
unknown committed
2893 2894
      (lower_case_file_system=
       (test_if_case_insensitive(mysql_real_data_home) == 1)))
unknown's avatar
unknown committed
2895
  {
unknown's avatar
unknown committed
2896 2897 2898
    if (lower_case_table_names_used)
    {
      if (global_system_variables.log_warnings)
2899 2900
	sql_print_warning("\
You have forced lower_case_table_names to 0 through a command-line \
unknown's avatar
unknown committed
2901 2902 2903 2904 2905 2906 2907 2908
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)
2909
	sql_print_warning("Setting lower_case_table_names=2 because file system for %s is case insensitive", mysql_real_data_home);
unknown's avatar
unknown committed
2910 2911
      lower_case_table_names= 2;
    }
unknown's avatar
unknown committed
2912
  }
2913
  else if (lower_case_table_names == 2 &&
2914 2915
           !(lower_case_file_system=
             (test_if_case_insensitive(mysql_real_data_home) == 1)))
2916 2917
  {
    if (global_system_variables.log_warnings)
unknown's avatar
unknown committed
2918 2919 2920
      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.",
2921
			mysql_real_data_home);
unknown's avatar
unknown committed
2922
    lower_case_table_names= 0;
2923
  }
unknown's avatar
unknown committed
2924

2925 2926
  select_thread=pthread_self();
  select_thread_in_use=1;
unknown's avatar
unknown committed
2927 2928 2929 2930 2931 2932 2933 2934 2935 2936
  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
2937
  check_data_home(mysql_real_data_home);
unknown's avatar
unknown committed
2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950
  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;
  server_init();

  if (opt_bin_log && !server_id)
  {
    server_id= !master_host ? 1 : 2;
#ifdef EXTRA_DEBUG
2951
    switch (server_id) {
unknown's avatar
unknown committed
2952
    case 1:
2953 2954
      sql_print_warning("\
You have enabled the binary log, but you haven't set server-id to \
2955 2956
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
2957 2958
      break;
    case 2:
2959 2960
      sql_print_warning("\
You should set server-id to a non-0 value if master_host is set; \
2961
we force server id to 2, but this MySQL server will not act as a slave.");
unknown's avatar
unknown committed
2962 2963
      break;
    }
2964
#endif
unknown's avatar
unknown committed
2965 2966 2967 2968 2969 2970 2971 2972
  }

  if (init_server_components())
    exit(1);

#ifdef __WIN__
  if (!opt_console)
  {
2973 2974
    freopen(log_error_file,"a+",stdout);
    freopen(log_error_file,"a+",stderr);
unknown's avatar
unknown committed
2975
    FreeConsole();				// Remove window
2976
  }
unknown's avatar
unknown committed
2977 2978 2979 2980 2981 2982 2983 2984
#endif

  /*
    init signals & alarm
    After this we can't quit by a simple unireg_abort
  */
  error_handler_hook = my_message_sql;
  start_signal_handler();				// Creates pidfile
2985 2986
  if (acl_init((THD *)0, opt_noacl) || 
      my_tz_init((THD *)0, default_tz_name, opt_bootstrap))
unknown's avatar
unknown committed
2987 2988 2989
  {
    abort_loop=1;
    select_thread_in_use=0;
unknown's avatar
unknown committed
2990 2991 2992
#ifndef __NETWARE__
    (void) pthread_kill(signal_thread, MYSQL_KILL_SIGNAL);
#endif /* __NETWARE__ */
2993
    
unknown's avatar
unknown committed
2994 2995
    if (!opt_bootstrap)
      (void) my_delete(pidfile_name,MYF(MY_WME));	// Not needed anymore
2996

2997
    if (unix_sock != INVALID_SOCKET)
2998
      unlink(mysqld_unix_port);
unknown's avatar
unknown committed
2999 3000 3001
    exit(1);
  }
  if (!opt_noacl)
unknown's avatar
unknown committed
3002
    (void) grant_init((THD *)0);
unknown's avatar
unknown committed
3003 3004 3005 3006 3007

#ifdef HAVE_DLOPEN
  if (!opt_noacl)
    udf_init();
#endif
unknown's avatar
unknown committed
3008 3009
  if (opt_bootstrap) /* If running with bootstrap, do not start replication. */
    opt_skip_slave_start= 1;
unknown's avatar
unknown committed
3010 3011
  /* init_slave() must be called after the thread keys are created */
  init_slave();
3012

unknown's avatar
unknown committed
3013 3014 3015
  if (opt_bootstrap)
  {
    int error=bootstrap(stdin);
3016
    end_thr_alarm(1);				// Don't allow alarms
unknown's avatar
unknown committed
3017 3018 3019 3020 3021 3022
    unireg_abort(error ? 1 : 0);
  }
  if (opt_init_file)
  {
    if (read_init_file(opt_init_file))
    {
3023
      end_thr_alarm(1);				// Don't allow alarms
unknown's avatar
unknown committed
3024 3025 3026
      unireg_abort(1);
    }
  }
unknown's avatar
unknown committed
3027

unknown's avatar
unknown committed
3028
  create_shutdown_thread();
unknown's avatar
unknown committed
3029 3030
  create_maintenance_thread();

3031
  printf(ER(ER_READY),my_progname,server_version,
3032 3033
	 ((unix_sock == INVALID_SOCKET) ? (char*) "" : mysqld_unix_port),
	 mysqld_port);
3034 3035 3036
  if (MYSQL_COMPILATION_COMMENT[0] != '\0')
    fputs("  " MYSQL_COMPILATION_COMMENT, stdout);
  putchar('\n');
unknown's avatar
unknown committed
3037 3038
  fflush(stdout);

3039 3040
#if defined(__NT__) || defined(HAVE_SMEM)
  handle_connections_methods();
unknown's avatar
unknown committed
3041
#else
unknown's avatar
unknown committed
3042 3043 3044
#ifdef __WIN__
  if ( !have_tcpip || opt_disable_networking)
  {
unknown's avatar
unknown committed
3045
    sql_print_error("TCP/IP unavailable or disabled with --skip-networking; no available interfaces");
unknown's avatar
unknown committed
3046 3047 3048
    unireg_abort(1);
  }
#endif
unknown's avatar
unknown committed
3049 3050 3051 3052
  handle_connections_sockets(0);
#endif /* __NT__ */

  /* (void) pthread_attr_destroy(&connection_attrib); */
3053
  
unknown's avatar
unknown committed
3054 3055 3056
  DBUG_PRINT("quit",("Exiting main thread"));

#ifndef __WIN__
unknown's avatar
unknown committed
3057
#ifdef EXTRA_DEBUG2
unknown's avatar
unknown committed
3058 3059 3060
  sql_print_error("Before Lock_thread_count");
#endif
  (void) pthread_mutex_lock(&LOCK_thread_count);
unknown's avatar
unknown committed
3061
  DBUG_PRINT("quit", ("Got thread_count mutex"));
unknown's avatar
unknown committed
3062 3063
  select_thread_in_use=0;			// For close_connections
  (void) pthread_mutex_unlock(&LOCK_thread_count);
3064
  (void) pthread_cond_broadcast(&COND_thread_count);
unknown's avatar
unknown committed
3065
#ifdef EXTRA_DEBUG2
unknown's avatar
unknown committed
3066 3067
  sql_print_error("After lock_thread_count");
#endif
unknown's avatar
merge  
unknown committed
3068
#endif /* __WIN__ */
3069

unknown's avatar
unknown committed
3070 3071 3072 3073 3074
  /* 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
3075 3076

#if defined(__WIN__) && !defined(EMBEDDED_LIBRARY)
unknown's avatar
merge  
unknown committed
3077 3078 3079 3080
  if (Service.IsNT() && start_mode)
    Service.Stop();
  else
  {
unknown's avatar
unknown committed
3081
    Service.SetShutdownEvent(0);
unknown's avatar
merge  
unknown committed
3082 3083 3084
    if (hEventShutdown)
      CloseHandle(hEventShutdown);
  }
unknown's avatar
unknown committed
3085
#endif
unknown's avatar
unknown committed
3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101
#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
  clean_up_mutexes();
unknown's avatar
unknown committed
3102
  my_end(opt_endinfo ? MY_CHECK_ERROR | MY_GIVE_INFO : 0);
3103
 
unknown's avatar
unknown committed
3104 3105 3106 3107
  exit(0);
  return(0);					/* purecov: deadcode */
}

3108
#endif /* EMBEDDED_LIBRARY */
unknown's avatar
unknown committed
3109

unknown's avatar
SCRUM  
unknown committed
3110

3111 3112 3113 3114 3115
/****************************************************************************
  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
3116
#if defined(__WIN__) && !defined(EMBEDDED_LIBRARY)
unknown's avatar
unknown committed
3117 3118
int mysql_service(void *p)
{
3119 3120 3121 3122
  if (use_opt_args)
    win_main(opt_argc, opt_argv);
  else
    win_main(Service.my_argc, Service.my_argv);
unknown's avatar
unknown committed
3123 3124 3125
  return 0;
}

3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138

/* 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, ' '))
    return strnmov(to, from, length);
  return strxnmov(to, length, "\"", from, "\"", NullS);
}


3139 3140 3141 3142 3143
/*
  Handle basic handling of services, like installation and removal

  SYNOPSIS
    default_service_handling()
3144
    argv		Pointer to argument list
3145 3146 3147
    servicename		Internal name of service
    displayname		Display name of service (in taskbar ?)
    file_path		Path to this program
3148
    startup_option	Startup option to mysqld
3149 3150 3151 3152 3153 3154

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

3155 3156 3157 3158 3159 3160
static bool
default_service_handling(char **argv,
			 const char *servicename,
			 const char *displayname,
			 const char *file_path,
			 const char *extra_opt)
3161
{
3162
  char path_and_service[FN_REFLEN+FN_REFLEN+32], *pos, *end;
3163
  end= path_and_service + sizeof(path_and_service)-3;
3164 3165 3166 3167 3168 3169 3170 3171 3172

  /* 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);
  }
3173 3174
  /* We must have servicename last */
  *pos++= ' ';
unknown's avatar
unknown committed
3175
  (void) add_quoted_string(pos, servicename, end);
3176

3177 3178
  if (Service.got_service_option(argv, "install"))
  {
3179
    Service.Install(1, servicename, displayname, path_and_service);
3180 3181 3182 3183
    return 0;
  }
  if (Service.got_service_option(argv, "install-manual"))
  {
3184
    Service.Install(0, servicename, displayname, path_and_service);
3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195
    return 0;
  }
  if (Service.got_service_option(argv, "remove"))
  {
    Service.Remove(servicename);
    return 0;
  }
  return 1;
}


unknown's avatar
unknown committed
3196 3197
int main(int argc, char **argv)
{
3198 3199 3200 3201 3202

  /* 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
  */ 
3203
  int10_to_str((int) GetCurrentProcessId(),strmov(shutdown_event_name,
3204 3205
          "MySQLShutdown"), 10);
  
3206 3207 3208
  /* Must be initialized early for comparison of service name */
  system_charset_info= &my_charset_utf8_general_ci;

unknown's avatar
unknown committed
3209
  if (Service.GetOS())	/* true NT family */
unknown's avatar
unknown committed
3210
  {
unknown's avatar
unknown committed
3211
    char file_path[FN_REFLEN];
3212
    my_path(file_path, argv[0], "");		      /* Find name in path */
unknown's avatar
unknown committed
3213 3214
    fn_format(file_path,argv[0],file_path,"",
	      MY_REPLACE_DIR | MY_UNPACK_FILENAME | MY_RESOLVE_SYMLINKS);
unknown's avatar
unknown committed
3215

unknown's avatar
unknown committed
3216
    if (argc == 2)
3217
    {
3218 3219
      if (!default_service_handling(argv, MYSQL_SERVICENAME, MYSQL_SERVICENAME,
				   file_path, ""))
3220
	return 0;
unknown's avatar
unknown committed
3221
      if (Service.IsService(argv[1]))        /* Start an optional service */
unknown's avatar
unknown committed
3222
      {
unknown's avatar
unknown committed
3223 3224 3225 3226 3227 3228
	/*
	  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.
	*/
3229
	if (my_strcasecmp(system_charset_info, argv[1],"mysql"))
3230
	  load_default_groups[load_default_groups_sz-2]= argv[1];
unknown's avatar
unknown committed
3231
        start_mode= 1;
3232
        Service.Init(argv[1], mysql_service);
unknown's avatar
unknown committed
3233 3234 3235 3236
        return 0;
      }
    }
    else if (argc == 3) /* install or remove any optional service */
unknown's avatar
unknown committed
3237
    {
3238
      if (!default_service_handling(argv, argv[2], argv[2], file_path, ""))
3239 3240
	return 0;
      if (Service.IsService(argv[2]))
unknown's avatar
unknown committed
3241
      {
3242 3243 3244 3245
	/*
	  mysqld was started as
	  mysqld --defaults-file=my_path\my.ini service-name
	*/
3246
	use_opt_args=1;
3247
	opt_argc= 2;				// Skip service-name
3248 3249
	opt_argv=argv;
	start_mode= 1;
3250
	if (my_strcasecmp(system_charset_info, argv[2],"mysql"))
3251
	  load_default_groups[load_default_groups_sz-2]= argv[2];
3252
	Service.Init(argv[2], mysql_service);
3253
	return 0;
unknown's avatar
unknown committed
3254 3255
      }
    }
3256 3257 3258 3259 3260 3261
    else if (argc == 4)
    {
      /*
	Install an optional service with optional config file
	mysqld --install-manual mysqldopt --defaults-file=c:\miguel\my.ini
      */
3262 3263
      if (!default_service_handling(argv, argv[2], argv[2], file_path,
				    argv[3]))
3264 3265
	return 0;
    }
unknown's avatar
unknown committed
3266
    else if (argc == 1 && Service.IsService(MYSQL_SERVICENAME))
unknown's avatar
unknown committed
3267
    {
unknown's avatar
unknown committed
3268 3269 3270
      /* start the default service */
      start_mode= 1;
      Service.Init(MYSQL_SERVICENAME, mysql_service);
unknown's avatar
unknown committed
3271 3272 3273
      return 0;
    }
  }
unknown's avatar
unknown committed
3274
  /* Start as standalone server */
unknown's avatar
unknown committed
3275 3276 3277 3278 3279 3280 3281 3282
  Service.my_argc=argc;
  Service.my_argv=argv;
  mysql_service(NULL);
  return 0;
}
#endif


3283 3284 3285 3286
/*
  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.
*/
3287

unknown's avatar
unknown committed
3288 3289
static int bootstrap(FILE *file)
{
3290
  int error= 0;
3291
  DBUG_ENTER("bootstrap");
3292

3293
  THD *thd= new THD;
unknown's avatar
unknown committed
3294 3295
  thd->bootstrap=1;
  thd->client_capabilities=0;
unknown's avatar
unknown committed
3296
  my_net_init(&thd->net,(st_vio*) 0);
unknown's avatar
unknown committed
3297
  thd->max_client_packet_length= thd->net.max_packet;
unknown's avatar
unknown committed
3298
  thd->master_access= ~0;
3299
  thd->thread_id=thread_id++;
unknown's avatar
unknown committed
3300
  thread_count++;
3301 3302

  bootstrap_file=file;
unknown's avatar
unknown committed
3303
#ifndef EMBEDDED_LIBRARY			// TODO:  Enable this
3304 3305 3306
  if (pthread_create(&thd->real_id,&connection_attrib,handle_bootstrap,
		     (void*) thd))
  {
3307
    sql_print_warning("Can't create thread to handle bootstrap");
3308
    DBUG_RETURN(-1);
3309 3310 3311 3312 3313 3314 3315 3316 3317
  }
  /* 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
3318 3319 3320 3321 3322
#else
  thd->mysql= 0;
  handle_bootstrap((void *)thd);
#endif

3323
  error= thd->is_fatal_error;
unknown's avatar
unknown committed
3324
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
3325
  net_end(&thd->net);
unknown's avatar
unknown committed
3326
#endif
unknown's avatar
unknown committed
3327
  thd->cleanup();
unknown's avatar
unknown committed
3328
  delete thd;
3329
  DBUG_RETURN(error);
unknown's avatar
unknown committed
3330 3331
}

3332

unknown's avatar
unknown committed
3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345
static bool read_init_file(char *file_name)
{
  FILE *file;
  DBUG_ENTER("read_init_file");
  DBUG_PRINT("enter",("name: %s",file_name));
  if (!(file=my_fopen(file_name,O_RDONLY,MYF(MY_WME))))
    return(1);
  bootstrap(file);				/* Ignore errors from this */
  (void) my_fclose(file,MYF(MY_WME));
  return 0;
}


3346
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
3347 3348 3349 3350 3351
static void create_new_thread(THD *thd)
{
  DBUG_ENTER("create_new_thread");

  NET *net=&thd->net;				// For easy ref
unknown's avatar
unknown committed
3352
  net->read_timeout = (uint) connect_timeout;
unknown's avatar
unknown committed
3353 3354 3355 3356 3357 3358
  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
3359
    DBUG_PRINT("error",("Too many connections"));
3360
    close_connection(thd, ER_CON_COUNT_ERROR, 1);
unknown's avatar
unknown committed
3361 3362 3363
    delete thd;
    DBUG_VOID_RETURN;
  }
3364
  pthread_mutex_lock(&LOCK_thread_count);
unknown's avatar
unknown committed
3365
  thd->thread_id=thread_id++;
3366

unknown's avatar
unknown committed
3367 3368 3369
  thd->real_id=pthread_self();			// Keep purify happy

  /* Start a new thread to handle connection */
3370
#ifdef ONE_THREAD
unknown's avatar
unknown committed
3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390
  if (test_flags & TEST_NO_THREADS)		// For debugging under Linux
  {
    thread_cache_size=0;			// Safety
    thread_count++;
    threads.append(thd);
    thd->real_id=pthread_self();
    (void) pthread_mutex_unlock(&LOCK_thread_count);
    handle_one_connection((void*) thd);
  }
  else
#endif
  {
    if (cached_thread_count > wake_thread)
    {
      start_cached_thread(thd);
    }
    else
    {
      int error;
      thread_count++;
3391
      thread_created++;
unknown's avatar
unknown committed
3392
      threads.append(thd);
3393 3394
      if (thread_count-delayed_insert_threads > max_used_connections)
        max_used_connections=thread_count-delayed_insert_threads;
unknown's avatar
unknown committed
3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406
      DBUG_PRINT("info",(("creating thread %d"), thd->thread_id));
      thd->connect_time = time(NULL);
      if ((error=pthread_create(&thd->real_id,&connection_attrib,
				handle_one_connection,
				(void*) thd)))
      {
	DBUG_PRINT("error",
		   ("Can't create thread to handle request (error %d)",
		    error));
	thread_count--;
	thd->killed=1;				// Safety
	(void) pthread_mutex_unlock(&LOCK_thread_count);
3407
	statistic_increment(aborted_connects,&LOCK_status);
3408
	net_printf(thd,ER_CANT_CREATE_THREAD,error);
unknown's avatar
unknown committed
3409
	(void) pthread_mutex_lock(&LOCK_thread_count);
3410
	close_connection(thd,0,0);
unknown's avatar
unknown committed
3411 3412 3413 3414 3415
	delete thd;
	(void) pthread_mutex_unlock(&LOCK_thread_count);
	DBUG_VOID_RETURN;
      }
    }
3416 3417
    (void) pthread_mutex_unlock(&LOCK_thread_count);

unknown's avatar
unknown committed
3418
  }
3419
  DBUG_PRINT("info",("Thread created"));
unknown's avatar
unknown committed
3420 3421
  DBUG_VOID_RETURN;
}
3422 3423
#endif /* EMBEDDED_LIBRARY */

unknown's avatar
unknown committed
3424

unknown's avatar
unknown committed
3425 3426 3427 3428
#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
3429 3430 3431 3432
  if (
#if !defined(__NETWARE__)
      unix_sock == INVALID_SOCKET ||
#endif
3433
      (!opt_disable_networking && ip_sock == INVALID_SOCKET))
unknown's avatar
unknown committed
3434 3435
  {
    select_thread_in_use = 0;
3436 3437 3438
#ifdef __NETWARE__
    kill_server(MYSQL_KILL_SIGNAL); /* never returns */
#else
unknown's avatar
unknown committed
3439
    kill_server((void*)MYSQL_KILL_SIGNAL); /* never returns */
3440
#endif /* __NETWARE__ */
unknown's avatar
unknown committed
3441 3442 3443 3444 3445 3446
  }
}
#define MAYBE_BROKEN_SYSCALL kill_broken_server();
#else
#define MAYBE_BROKEN_SYSCALL
#endif
unknown's avatar
unknown committed
3447 3448 3449

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

3450 3451 3452
#ifndef EMBEDDED_LIBRARY
extern "C" pthread_handler_decl(handle_connections_sockets,
				arg __attribute__((unused)))
unknown's avatar
unknown committed
3453 3454 3455 3456 3457 3458 3459 3460
{
  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
3461
  st_vio *vio_tmp;
unknown's avatar
unknown committed
3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477
  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
3478
#ifdef HAVE_FCNTL
unknown's avatar
unknown committed
3479
  socket_flags=fcntl(unix_sock, F_GETFL, 0);
unknown's avatar
unknown committed
3480
#endif
unknown's avatar
unknown committed
3481 3482 3483
#endif

  DBUG_PRINT("general",("Waiting for connections."));
unknown's avatar
unknown committed
3484
  MAYBE_BROKEN_SYSCALL;
unknown's avatar
unknown committed
3485 3486 3487
  while (!abort_loop)
  {
    readFDs=clientFDs;
3488
#ifdef HPUX10
unknown's avatar
unknown committed
3489 3490 3491 3492 3493
    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
3494
      if (socket_errno != SOCKET_EINTR)
unknown's avatar
unknown committed
3495 3496
      {
	if (!select_errors++ && !abort_loop)	/* purecov: inspected */
unknown's avatar
unknown committed
3497
	  sql_print_error("mysqld: Got error %d from select",socket_errno); /* purecov: inspected */
unknown's avatar
unknown committed
3498
      }
unknown's avatar
unknown committed
3499
      MAYBE_BROKEN_SYSCALL
unknown's avatar
unknown committed
3500 3501
      continue;
    }
3502
#endif	/* HPUX10 */
unknown's avatar
unknown committed
3503
    if (abort_loop)
unknown's avatar
unknown committed
3504 3505
    {
      MAYBE_BROKEN_SYSCALL;
unknown's avatar
unknown committed
3506
      break;
unknown's avatar
unknown committed
3507
    }
unknown's avatar
unknown committed
3508

3509
    /* Is this a new connection request ? */
unknown's avatar
unknown committed
3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537
#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
3538 3539 3540 3541 3542 3543 3544
#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
3545 3546
      if (new_sock != INVALID_SOCKET ||
	  (socket_errno != SOCKET_EINTR && socket_errno != SOCKET_EAGAIN))
unknown's avatar
unknown committed
3547
	break;
unknown's avatar
unknown committed
3548
      MAYBE_BROKEN_SYSCALL;
unknown's avatar
unknown committed
3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559 3560
#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
3561
    if (new_sock == INVALID_SOCKET)
unknown's avatar
unknown committed
3562 3563 3564
    {
      if ((error_count++ & 255) == 0)		// This can happen often
	sql_perror("Error in accept");
unknown's avatar
unknown committed
3565
      MAYBE_BROKEN_SYSCALL;
unknown's avatar
unknown committed
3566
      if (socket_errno == SOCKET_ENFILE || socket_errno == SOCKET_EMFILE)
unknown's avatar
unknown committed
3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577
	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);
3578 3579
	fromhost(&req);
	if (!hosts_access(&req))
unknown's avatar
unknown committed
3580
	{
unknown's avatar
unknown committed
3581 3582 3583 3584 3585
	  /*
	    This may be stupid but refuse() includes an exit(0)
	    which we surely don't want...
	    clean_exit() - same stupid thing ...
	  */
3586
	  syslog(deny_severity, "refused connect from %s",
3587
		 eval_client(&req));
unknown's avatar
unknown committed
3588

unknown's avatar
unknown committed
3589 3590 3591 3592 3593 3594
	  /*
	    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
3595 3596 3597
	  if (req.sink)
	    ((void (*)(int))req.sink)(req.fd);

3598
	  (void) shutdown(new_sock,2);
unknown's avatar
unknown committed
3599 3600 3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624
	  (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
3625 3626
      (void) shutdown(new_sock,2);
      VOID(closesocket(new_sock));
unknown's avatar
unknown committed
3627 3628 3629
      continue;
    }
    if (!(vio_tmp=vio_new(new_sock,
3630
			  sock == unix_sock ? VIO_TYPE_SOCKET :
unknown's avatar
unknown committed
3631
			  VIO_TYPE_TCPIP,
3632
			  sock == unix_sock)) ||
unknown's avatar
unknown committed
3633 3634 3635 3636 3637 3638 3639 3640 3641 3642 3643 3644 3645
	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)
unknown's avatar
unknown committed
3646
      thd->host=(char*) my_localhost;
3647 3648 3649 3650 3651 3652
#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
3653 3654 3655
    create_new_thread(thd);
  }

unknown's avatar
unknown committed
3656 3657 3658 3659
#ifdef OS2
  // kill server must be invoked from thread 1!
  kill_server(MYSQL_KILL_SIGNAL);
#endif
3660
  decrement_handler_count();
unknown's avatar
unknown committed
3661 3662 3663 3664 3665
  DBUG_RETURN(0);
}


#ifdef __NT__
3666
extern "C" pthread_handler_decl(handle_connections_namedpipes,arg)
unknown's avatar
unknown committed
3667 3668 3669 3670 3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681
{
  HANDLE hConnectedPipe;
  BOOL fConnected;
  THD *thd;
  my_thread_init();
  DBUG_ENTER("handle_connections_namedpipes");
  (void) my_pthread_getprio(pthread_self());		// For debugging

  DBUG_PRINT("general",("Waiting for named pipe connections."));
  while (!abort_loop)
  {
    /* wait for named pipe connection */
    fConnected = ConnectNamedPipe( hPipe, NULL );
    if (abort_loop)
      break;
unknown's avatar
unknown committed
3682
    if (!fConnected)
unknown's avatar
unknown committed
3683
      fConnected = GetLastError() == ERROR_PIPE_CONNECTED;
unknown's avatar
unknown committed
3684
    if (!fConnected)
unknown's avatar
unknown committed
3685 3686
    {
      CloseHandle( hPipe );
3687
      if ((hPipe = CreateNamedPipe(pipe_name,
unknown's avatar
unknown committed
3688 3689 3690 3691 3692
				   PIPE_ACCESS_DUPLEX,
				   PIPE_TYPE_BYTE |
				   PIPE_READMODE_BYTE |
				   PIPE_WAIT,
				   PIPE_UNLIMITED_INSTANCES,
3693
				   (int) global_system_variables.net_buffer_length,
unknown's avatar
unknown committed
3694
				   (int) global_system_variables.net_buffer_length,
unknown's avatar
unknown committed
3695 3696 3697 3698 3699 3700 3701 3702 3703 3704
				   NMPWAIT_USE_DEFAULT_WAIT,
				   &saPipeSecurity )) ==
	  INVALID_HANDLE_VALUE )
      {
	sql_perror("Can't create new named pipe!");
	break;					// Abort
      }
    }
    hConnectedPipe = hPipe;
    /* create new pipe for new connection */
3705
    if ((hPipe = CreateNamedPipe(pipe_name,
unknown's avatar
unknown committed
3706 3707 3708 3709 3710
				 PIPE_ACCESS_DUPLEX,
				 PIPE_TYPE_BYTE |
				 PIPE_READMODE_BYTE |
				 PIPE_WAIT,
				 PIPE_UNLIMITED_INSTANCES,
3711 3712
				 (int) global_system_variables.net_buffer_length,
				 (int) global_system_variables.net_buffer_length,
unknown's avatar
unknown committed
3713 3714 3715 3716 3717 3718 3719 3720 3721
				 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
3722
    if (!(thd = new THD))
unknown's avatar
unknown committed
3723 3724 3725 3726 3727 3728 3729 3730
    {
      DisconnectNamedPipe( hConnectedPipe );
      CloseHandle( hConnectedPipe );
      continue;
    }
    if (!(thd->net.vio = vio_new_win32pipe(hConnectedPipe)) ||
	my_net_init(&thd->net, thd->net.vio))
    {
3731
      close_connection(thd, ER_OUT_OF_RESOURCES, 1);
unknown's avatar
unknown committed
3732 3733 3734 3735
      delete thd;
      continue;
    }
    /* host name is unknown */
unknown's avatar
unknown committed
3736
    thd->host = my_strdup(my_localhost,MYF(0)); /* Host is unknown */
unknown's avatar
unknown committed
3737 3738 3739
    create_new_thread(thd);
  }

3740
  decrement_handler_count();
unknown's avatar
unknown committed
3741 3742 3743 3744
  DBUG_RETURN(0);
}
#endif /* __NT__ */

3745

3746
/*
3747 3748 3749 3750 3751 3752 3753
  Thread of shared memory's service

  SYNOPSIS
    pthread_handler_decl()
    handle_connections_shared_memory Thread handle
    arg                              Arguments of thread
*/
3754

3755 3756 3757
#ifdef HAVE_SMEM
pthread_handler_decl(handle_connections_shared_memory,arg)
{
3758 3759 3760 3761 3762 3763
  /* file-mapping object, use for create shared memory */
  HANDLE handle_connect_file_map= 0;
  char  *handle_connect_map= 0;  		// pointer on shared memory
  HANDLE event_connect_answer= 0;
  ulong smem_buffer_length= shared_memory_buffer_length + 4;
  ulong connect_number= 1;
3764 3765 3766
  char tmp[63];
  char *suffix_pos;
  char connect_number_char[22], *p;
3767
  const char *errmsg= 0;
3768 3769 3770 3771
  my_thread_init();
  DBUG_ENTER("handle_connections_shared_memorys");
  DBUG_PRINT("general",("Waiting for allocated shared memory."));

3772 3773 3774 3775 3776 3777 3778
  /*
    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)
  */
3779
  suffix_pos= strxmov(tmp,shared_memory_base_name,"_",NullS);
3780
  strmov(suffix_pos, "CONNECT_REQUEST");
3781
  if ((smem_event_connect_request= CreateEvent(0,FALSE,FALSE,tmp)) == 0)
3782
  {
3783
    errmsg= "Could not create request event";
3784 3785
    goto error;
  }
3786
  strmov(suffix_pos, "CONNECT_ANSWER");
3787
  if ((event_connect_answer= CreateEvent(0,FALSE,FALSE,tmp)) == 0)
3788
  {
3789
    errmsg="Could not create answer event";
3790 3791
    goto error;
  }
3792
  strmov(suffix_pos, "CONNECT_DATA");
3793 3794 3795 3796
  if ((handle_connect_file_map= CreateFileMapping(INVALID_HANDLE_VALUE,0,
						   PAGE_READWRITE,
						   0,sizeof(connect_number),
						   tmp)) == 0)
3797
  {
3798
    errmsg= "Could not create file mapping";
3799 3800
    goto error;
  }
3801 3802 3803
  if ((handle_connect_map= (char *)MapViewOfFile(handle_connect_file_map,
						  FILE_MAP_WRITE,0,0,
						  sizeof(DWORD))) == 0)
3804
  {
3805
    errmsg= "Could not create shared memory service";
3806 3807 3808 3809 3810
    goto error;
  }

  while (!abort_loop)
  {
3811
    /* Wait a request from client */
3812
    WaitForSingleObject(smem_event_connect_request,INFINITE);
3813

unknown's avatar
unknown committed
3814 3815 3816 3817 3818
    /*
       it can be after shutdown command
    */
    if (abort_loop) 
      goto error;
3819

3820 3821 3822 3823 3824 3825
    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
3826
    HANDLE event_conn_closed= 0;
3827
    THD *thd= 0;
3828

3829
    p= int10_to_str(connect_number, connect_number_char, 10);
3830 3831 3832 3833 3834 3835 3836 3837 3838 3839
    /*
      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);
3840
    strmov(suffix_pos, "DATA");
3841 3842 3843 3844
    if ((handle_client_file_map= CreateFileMapping(INVALID_HANDLE_VALUE,0,
						    PAGE_READWRITE,0,
						    smem_buffer_length,
						    tmp)) == 0)
3845
    {
3846
      errmsg= "Could not create file mapping";
3847 3848
      goto errorconn;
    }
3849 3850 3851
    if ((handle_client_map= (char*)MapViewOfFile(handle_client_file_map,
						  FILE_MAP_WRITE,0,0,
						  smem_buffer_length)) == 0)
3852
    {
3853
      errmsg= "Could not create memory map";
3854 3855 3856
      goto errorconn;
    }
    strmov(suffix_pos, "CLIENT_WROTE");
unknown's avatar
unknown committed
3857
    if ((event_client_wrote= CreateEvent(0, FALSE, FALSE, tmp)) == 0)
3858
    {
3859
      errmsg= "Could not create client write event";
3860 3861 3862
      goto errorconn;
    }
    strmov(suffix_pos, "CLIENT_READ");
unknown's avatar
unknown committed
3863
    if ((event_client_read= CreateEvent(0, FALSE, FALSE, tmp)) == 0)
3864
    {
3865
      errmsg= "Could not create client read event";
3866 3867 3868
      goto errorconn;
    }
    strmov(suffix_pos, "SERVER_READ");
unknown's avatar
unknown committed
3869
    if ((event_server_read= CreateEvent(0, FALSE, FALSE, tmp)) == 0)
3870
    {
3871
      errmsg= "Could not create server read event";
3872 3873 3874
      goto errorconn;
    }
    strmov(suffix_pos, "SERVER_WROTE");
unknown's avatar
unknown committed
3875
    if ((event_server_wrote= CreateEvent(0, FALSE, FALSE, tmp)) == 0)
3876
    {
3877
      errmsg= "Could not create server write event";
3878 3879
      goto errorconn;
    }
unknown's avatar
unknown committed
3880
    strmov(suffix_pos, "CONNECTION_CLOSED");
unknown's avatar
unknown committed
3881
    if ((event_conn_closed= CreateEvent(0, TRUE , FALSE, tmp)) == 0)
unknown's avatar
unknown committed
3882 3883 3884 3885
    {
      errmsg= "Could not create closed connection event";
      goto errorconn;
    }
3886
    if (abort_loop)
3887
      goto errorconn;
3888 3889 3890
    if (!(thd= new THD))
      goto errorconn;
    /* Send number of connection to client */
3891
    int4store(handle_connect_map, connect_number);
3892
    if (!SetEvent(event_connect_answer))
3893
    {
3894
      errmsg= "Could not send answer event";
3895 3896
      goto errorconn;
    }
3897
    /* Set event that client should receive data */
3898 3899
    if (!SetEvent(event_client_read))
    {
3900
      errmsg= "Could not set client to read mode";
3901 3902
      goto errorconn;
    }
3903
    if (!(thd->net.vio= vio_new_win32shared_memory(&thd->net,
unknown's avatar
unknown committed
3904 3905 3906 3907 3908 3909
                                                   handle_client_file_map,
                                                   handle_client_map,
                                                   event_client_wrote,
                                                   event_client_read,
                                                   event_server_wrote,
                                                   event_server_read,
unknown's avatar
unknown committed
3910
                                                   event_conn_closed)) ||
unknown's avatar
unknown committed
3911
                        my_net_init(&thd->net, thd->net.vio))
3912
    {
3913
      close_connection(thd, ER_OUT_OF_RESOURCES, 1);
3914 3915
      errmsg= 0;
      goto errorconn;
3916
    }
3917
    thd->host= my_strdup(my_localhost,MYF(0)); /* Host is unknown */
3918
    create_new_thread(thd);
3919 3920 3921 3922 3923 3924 3925 3926 3927 3928 3929 3930
    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
3931 3932 3933 3934 3935 3936 3937 3938 3939 3940 3941 3942 3943 3944
    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);
3945
    delete thd;
3946
  }
3947 3948

  /* End shared memory handling */
3949
error:
3950 3951 3952 3953 3954 3955 3956 3957 3958
  if (errmsg)
  {
    char buff[180];
    strxmov(buff, "Can't create shared memory service: ", errmsg, ".", NullS);
    sql_perror(buff);
  }
  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);
3959
  if (smem_event_connect_request) CloseHandle(smem_event_connect_request);
3960 3961

  decrement_handler_count();
3962 3963 3964
  DBUG_RETURN(0);
}
#endif /* HAVE_SMEM */
3965
#endif /* EMBEDDED_LIBRARY */
unknown's avatar
unknown committed
3966

3967 3968 3969

/****************************************************************************
  Handle start options
unknown's avatar
unknown committed
3970 3971
******************************************************************************/

unknown's avatar
unknown committed
3972
enum options_mysqld
3973
{
3974 3975 3976
  OPT_ISAM_LOG=256,            OPT_SKIP_NEW, 
  OPT_SKIP_GRANT,              OPT_SKIP_LOCK, 
  OPT_ENABLE_LOCK,             OPT_USE_LOCKING,
3977 3978
  OPT_SOCKET,                  OPT_UPDATE_LOG,
  OPT_BIN_LOG,                 OPT_SKIP_RESOLVE,
3979 3980
  OPT_SKIP_NETWORKING,         OPT_BIN_LOG_INDEX,
  OPT_BIND_ADDRESS,            OPT_PID_FILE,
3981
  OPT_SKIP_PRIOR,              OPT_BIG_TABLES,
3982 3983
  OPT_STANDALONE,              OPT_ONE_THREAD,
  OPT_CONSOLE,                 OPT_LOW_PRIORITY_UPDATES,
3984
  OPT_SKIP_HOST_CACHE,         OPT_SHORT_LOG_FORMAT,
3985
  OPT_FLUSH,                   OPT_SAFE,
3986
  OPT_BOOTSTRAP,               OPT_SKIP_SHOW_DB,
unknown's avatar
unknown committed
3987
  OPT_STORAGE_ENGINE,          OPT_INIT_FILE,
3988
  OPT_DELAY_KEY_WRITE_ALL,     OPT_SLOW_QUERY_LOG,
3989
  OPT_DELAY_KEY_WRITE,	       OPT_CHARSETS_DIR,
3990
  OPT_BDB_HOME,                OPT_BDB_LOG,
3991
  OPT_BDB_TMP,                 OPT_BDB_SYNC,
3992
  OPT_BDB_LOCK,                OPT_BDB,
3993 3994 3995 3996 3997
  OPT_BDB_NO_RECOVER,	    OPT_BDB_SHARED,
  OPT_MASTER_HOST,             OPT_MASTER_USER,
  OPT_MASTER_PASSWORD,         OPT_MASTER_PORT,
  OPT_MASTER_INFO_FILE,        OPT_MASTER_CONNECT_RETRY,
  OPT_MASTER_RETRY_COUNT,
unknown's avatar
unknown committed
3998 3999
  OPT_MASTER_SSL,              OPT_MASTER_SSL_KEY,
  OPT_MASTER_SSL_CERT,         OPT_MASTER_SSL_CAPATH,
unknown's avatar
unknown committed
4000
  OPT_MASTER_SSL_CIPHER,       OPT_MASTER_SSL_CA,
4001
  OPT_SQL_BIN_UPDATE_SAME,     OPT_REPLICATE_DO_DB,
4002 4003 4004 4005
  OPT_REPLICATE_IGNORE_DB,     OPT_LOG_SLAVE_UPDATES,
  OPT_BINLOG_DO_DB,            OPT_BINLOG_IGNORE_DB,
  OPT_WANT_CORE,               OPT_CONCURRENT_INSERT,
  OPT_MEMLOCK,                 OPT_MYISAM_RECOVER,
4006
  OPT_REPLICATE_REWRITE_DB,    OPT_SERVER_ID,
4007
  OPT_SKIP_SLAVE_START,        OPT_SKIP_INNOBASE,
4008 4009
  OPT_SAFEMALLOC_MEM_LIMIT,    OPT_REPLICATE_DO_TABLE,
  OPT_REPLICATE_IGNORE_TABLE,  OPT_REPLICATE_WILD_DO_TABLE,
4010
  OPT_REPLICATE_WILD_IGNORE_TABLE, OPT_REPLICATE_SAME_SERVER_ID,
4011
  OPT_DISCONNECT_SLAVE_EVENT_COUNT,
4012 4013 4014
  OPT_ABORT_SLAVE_EVENT_COUNT,
  OPT_INNODB_DATA_HOME_DIR,
  OPT_INNODB_DATA_FILE_PATH,
4015 4016 4017 4018 4019 4020
  OPT_INNODB_LOG_GROUP_HOME_DIR,
  OPT_INNODB_LOG_ARCH_DIR,
  OPT_INNODB_LOG_ARCHIVE,
  OPT_INNODB_FLUSH_LOG_AT_TRX_COMMIT,
  OPT_INNODB_FLUSH_METHOD,
  OPT_INNODB_FAST_SHUTDOWN,
unknown's avatar
unknown committed
4021
  OPT_INNODB_FILE_PER_TABLE, OPT_CRASH_BINLOG_INNODB,
4022
  OPT_INNODB_LOCKS_UNSAFE_FOR_BINLOG,
unknown's avatar
unknown committed
4023
  OPT_SAFE_SHOW_DB, OPT_INNODB_SAFE_BINLOG,
4024 4025 4026
  OPT_INNODB, OPT_ISAM,
  OPT_NDBCLUSTER, OPT_NDB_CONNECTSTRING, OPT_NDB_USE_EXACT_COUNT,
  OPT_NDB_FORCE_SEND, OPT_NDB_AUTOINCREMENT_PREFETCH_SZ,
4027
  OPT_NDB_SHM, OPT_NDB_OPTIMIZED_NODE_SELECTION,
4028
  OPT_SKIP_SAFEMALLOC,
4029 4030 4031 4032 4033 4034 4035
  OPT_TEMP_POOL, OPT_TX_ISOLATION,
  OPT_SKIP_STACK_TRACE, OPT_SKIP_SYMLINKS,
  OPT_MAX_BINLOG_DUMP_EVENTS, OPT_SPORADIC_BINLOG_DUMP_FAIL,
  OPT_SAFE_USER_CREATE, OPT_SQL_MODE,
  OPT_HAVE_NAMED_PIPE,
  OPT_DO_PSTACK, OPT_REPORT_HOST,
  OPT_REPORT_USER, OPT_REPORT_PASSWORD, OPT_REPORT_PORT,
4036
  OPT_SHOW_SLAVE_AUTH_INFO,
4037 4038 4039 4040 4041 4042 4043 4044 4045
  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
4046
  OPT_FLUSH_TIME, OPT_FT_MIN_WORD_LEN, OPT_FT_BOOLEAN_SYNTAX,
4047
  OPT_FT_MAX_WORD_LEN, OPT_FT_QUERY_EXPANSION_LIMIT, OPT_FT_STOPWORD_FILE,
4048
  OPT_INTERACTIVE_TIMEOUT, OPT_JOIN_BUFF_SIZE,
4049 4050 4051
  OPT_KEY_BUFFER_SIZE, OPT_KEY_CACHE_BLOCK_SIZE,
  OPT_KEY_CACHE_DIVISION_LIMIT, OPT_KEY_CACHE_AGE_THRESHOLD,
  OPT_LONG_QUERY_TIME,
4052 4053 4054 4055
  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,
4056 4057
  OPT_MAX_JOIN_SIZE, OPT_MAX_RELAY_LOG_SIZE, OPT_MAX_SORT_LENGTH, 
  OPT_MAX_SEEKS_FOR_KEY, OPT_MAX_TMP_TABLES, OPT_MAX_USER_CONNECTIONS,
unknown's avatar
unknown committed
4058
  OPT_MAX_LENGTH_FOR_SORT_DATA,
unknown's avatar
unknown committed
4059
  OPT_MAX_WRITE_LOCK_COUNT, OPT_BULK_INSERT_BUFFER_SIZE,
unknown's avatar
unknown committed
4060
  OPT_MAX_ERROR_COUNT, OPT_MYISAM_DATA_POINTER_SIZE,
4061 4062 4063 4064
  OPT_MYISAM_BLOCK_SIZE, OPT_MYISAM_MAX_EXTRA_SORT_FILE_SIZE,
  OPT_MYISAM_MAX_SORT_FILE_SIZE, OPT_MYISAM_SORT_BUFFER_SIZE,
  OPT_NET_BUFFER_LENGTH, OPT_NET_RETRY_COUNT,
  OPT_NET_READ_TIMEOUT, OPT_NET_WRITE_TIMEOUT,
4065
  OPT_OPEN_FILES_LIMIT,
unknown's avatar
unknown committed
4066
  OPT_PRELOAD_BUFFER_SIZE,
4067
  OPT_QUERY_CACHE_LIMIT, OPT_QUERY_CACHE_MIN_RES_UNIT, OPT_QUERY_CACHE_SIZE,
4068
  OPT_QUERY_CACHE_TYPE, OPT_QUERY_CACHE_WLOCK_INVALIDATE, OPT_RECORD_BUFFER,
4069
  OPT_RECORD_RND_BUFFER, OPT_RELAY_LOG_SPACE_LIMIT, OPT_RELAY_LOG_PURGE,
4070
  OPT_SLAVE_NET_TIMEOUT, OPT_SLAVE_COMPRESSED_PROTOCOL, OPT_SLOW_LAUNCH_TIME,
4071
  OPT_READONLY, OPT_DEBUGGING,
4072 4073 4074
  OPT_SORT_BUFFER, OPT_TABLE_CACHE,
  OPT_THREAD_CONCURRENCY, OPT_THREAD_CACHE_SIZE,
  OPT_TMP_TABLE_SIZE, OPT_THREAD_STACK,
4075
  OPT_WAIT_TIMEOUT, OPT_MYISAM_REPAIR_THREADS,
4076 4077 4078 4079 4080
  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
4081
  OPT_INNODB_BUFFER_POOL_AWE_MEM_MB,
4082
  OPT_INNODB_ADDITIONAL_MEM_POOL_SIZE,
4083
  OPT_INNODB_MAX_PURGE_LAG,
4084 4085 4086 4087
  OPT_INNODB_FILE_IO_THREADS,
  OPT_INNODB_LOCK_WAIT_TIMEOUT,
  OPT_INNODB_THREAD_CONCURRENCY,
  OPT_INNODB_FORCE_RECOVERY,
4088
  OPT_INNODB_STATUS_FILE,
4089
  OPT_INNODB_MAX_DIRTY_PAGES_PCT,
4090
  OPT_INNODB_TABLE_LOCKS,
unknown's avatar
unknown committed
4091
  OPT_INNODB_OPEN_FILES,
4092
  OPT_INNODB_AUTOEXTEND_INCREMENT,
4093 4094
  OPT_BDB_CACHE_SIZE,
  OPT_BDB_LOG_BUFFER_SIZE,
4095
  OPT_BDB_MAX_LOCK,
unknown's avatar
merge  
unknown committed
4096
  OPT_ERROR_LOG_FILE,
4097 4098 4099
  OPT_DEFAULT_WEEK_FORMAT,
  OPT_RANGE_ALLOC_BLOCK_SIZE,
  OPT_QUERY_ALLOC_BLOCK_SIZE, OPT_QUERY_PREALLOC_SIZE,
4100
  OPT_TRANS_ALLOC_BLOCK_SIZE, OPT_TRANS_PREALLOC_SIZE,
4101
  OPT_SYNC_FRM, OPT_SYNC_BINLOG, OPT_BDB_NOSYNC,
4102
  OPT_ENABLE_SHARED_MEMORY,
unknown's avatar
unknown committed
4103
  OPT_SHARED_MEMORY_BASE_NAME,
4104
  OPT_OLD_PASSWORDS,
unknown's avatar
unknown committed
4105
  OPT_EXPIRE_LOGS_DAYS,
4106
  OPT_GROUP_CONCAT_MAX_LEN,
4107
  OPT_DEFAULT_COLLATION,
unknown's avatar
unknown committed
4108
  OPT_INIT_CONNECT,
unknown's avatar
unknown committed
4109
  OPT_INIT_SLAVE,
4110
  OPT_SECURE_AUTH,
4111 4112
  OPT_DATE_FORMAT,
  OPT_TIME_FORMAT,
unknown's avatar
unknown committed
4113
  OPT_DATETIME_FORMAT,
4114 4115
  OPT_LOG_QUERIES_NOT_USING_INDEXES,
  OPT_DEFAULT_TIME_ZONE
unknown's avatar
unknown committed
4116
};
4117

4118 4119 4120

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

unknown's avatar
unknown committed
4121
struct my_option my_long_options[] =
4122
{
unknown's avatar
unknown committed
4123 4124 4125 4126 4127 4128 4129 4130 4131
  {"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 */
4132
  {"ansi", 'a', "Use ANSI SQL syntax instead of MySQL syntax.", 0, 0, 0,
4133 4134 4135 4136 4137
   GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  {"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
4138 4139
  {"bdb", OPT_BDB, "Enable Berkeley DB (if this version of MySQL supports it). \
Disable with --skip-bdb (will save memory).",
4140
   (gptr*) &opt_bdb, (gptr*) &opt_bdb, 0, GET_BOOL, NO_ARG, OPT_BDB_DEFAULT, 0, 0,
unknown's avatar
unknown committed
4141
   0, 0, 0},
unknown's avatar
unknown committed
4142
#ifdef HAVE_BERKELEY_DB
4143
  {"bdb-home", OPT_BDB_HOME, "Berkeley home directory.", (gptr*) &berkeley_home,
4144 4145
   (gptr*) &berkeley_home, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {"bdb-lock-detect", OPT_BDB_LOCK,
4146
   "Berkeley lock detect (DEFAULT, OLDEST, RANDOM or YOUNGEST, # sec).",
4147
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
4148
  {"bdb-logdir", OPT_BDB_LOG, "Berkeley DB log file directory.",
4149 4150 4151
   (gptr*) &berkeley_logdir, (gptr*) &berkeley_logdir, 0, GET_STR,
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {"bdb-no-recover", OPT_BDB_NO_RECOVER,
4152
   "Don't try to recover Berkeley DB tables on start.", 0, 0, 0, GET_NO_ARG,
4153
   NO_ARG, 0, 0, 0, 0, 0, 0},
4154 4155 4156 4157
  {"bdb-no-sync", OPT_BDB_NOSYNC,
   "Disable synchronously flushing logs. This option is deprecated, use --skip-sync-bdb-logs or sync-bdb-logs=0 instead",
   //   (gptr*) &opt_sync_bdb_logs, (gptr*) &opt_sync_bdb_logs, 0, GET_BOOL,
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
4158
  {"bdb-shared-data", OPT_BDB_SHARED,
4159
   "Start Berkeley DB in multi-process mode.", 0, 0, 0, GET_NO_ARG, NO_ARG, 0,
4160
   0, 0, 0, 0, 0},
4161
  {"bdb-tmpdir", OPT_BDB_TMP, "Berkeley DB tempfile name.",
4162 4163 4164
   (gptr*) &berkeley_tmpdir, (gptr*) &berkeley_tmpdir, 0, GET_STR,
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
#endif /* HAVE_BERKELEY_DB */
unknown's avatar
unknown committed
4165
  {"big-tables", OPT_BIG_TABLES,
4166
   "Allow big result sets by saving all temporary sets on file (Solves most 'table full' errors).",
4167
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
4168 4169 4170
  {"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},
4171 4172 4173
  {"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
4174
  {"binlog-ignore-db", OPT_BINLOG_IGNORE_DB,
4175
   "Tells the master that updates to the given database should not be logged tothe binary log.",
4176
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
4177
  {"bootstrap", OPT_BOOTSTRAP, "Used by mysql installation scripts.", 0, 0, 0,
4178
   GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
4179
  {"character-set-server", 'C', "Set the default character set.",
unknown's avatar
unknown committed
4180 4181
   (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
4182 4183 4184 4185 4186 4187 4188
  {"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
4189 4190
   (gptr*) &default_collation_name, (gptr*) &default_collation_name,
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
unknown's avatar
unknown committed
4191 4192 4193 4194
  {"concurrent-insert", OPT_CONCURRENT_INSERT,
   "Use concurrent insert with MyISAM. Disable with --skip-concurrent-insert.",
   (gptr*) &myisam_concurrent_insert, (gptr*) &myisam_concurrent_insert,
   0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0},
4195
  {"console", OPT_CONSOLE, "Write error output on screen; Don't remove the console window on windows.",
4196 4197
   (gptr*) &opt_console, (gptr*) &opt_console, 0, GET_BOOL, NO_ARG, 0, 0, 0,
   0, 0, 0},
4198
  {"core-file", OPT_WANT_CORE, "Write core on errors.", 0, 0, 0, GET_NO_ARG,
4199
   NO_ARG, 0, 0, 0, 0, 0, 0},
4200
  {"datadir", 'h', "Path to the database root.", (gptr*) &mysql_data_home,
4201 4202 4203 4204 4205
   (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
4206
  {"default-character-set", 'C', "Set the default character set (deprecated option, use --character-set-server instead).",
4207
   (gptr*) &default_character_set_name, (gptr*) &default_character_set_name,
4208
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
unknown's avatar
unknown committed
4209
  {"default-collation", OPT_DEFAULT_COLLATION, "Set the default collation (deprecated option, use --collation-server instead).",
4210 4211
   (gptr*) &default_collation_name, (gptr*) &default_collation_name,
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
unknown's avatar
unknown committed
4212 4213 4214 4215
  {"default-storage-engine", OPT_STORAGE_ENGINE,
   "Set the default storage engine (table tyoe) for tables.", 0, 0,
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {"default-table-type", OPT_STORAGE_ENGINE,
unknown's avatar
unknown committed
4216
   "(deprecated) Use --default-storage-engine.", 0, 0,
4217
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
4218 4219 4220
  {"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 },
4221
  {"delay-key-write", OPT_DELAY_KEY_WRITE, "Type of DELAY_KEY_WRITE.",
4222 4223
   0,0,0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
  {"delay-key-write-for-all-tables", OPT_DELAY_KEY_WRITE_ALL,
4224
   "Don't flush key buffers between writes for any MyISAM table (Deprecated option, use --delay-key-write=all instead).",
4225
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
4226 4227 4228 4229 4230 4231 4232 4233 4234 4235 4236 4237 4238
#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 */
4239
  {"enable-locking", OPT_ENABLE_LOCK,
4240
   "Deprecated option, use --external-locking instead.",
4241 4242
   (gptr*) &opt_external_locking, (gptr*) &opt_external_locking,
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
4243
#ifdef __NT__
4244
  {"enable-named-pipe", OPT_HAVE_NAMED_PIPE, "Enable the named pipe (NT).",
4245 4246 4247
   (gptr*) &opt_enable_named_pipe, (gptr*) &opt_enable_named_pipe, 0, GET_BOOL,
   NO_ARG, 0, 0, 0, 0, 0, 0},
#endif
4248
  {"enable-pstack", OPT_DO_PSTACK, "Print a symbolic stack trace on failure.",
4249 4250 4251 4252
   (gptr*) &opt_do_pstack, (gptr*) &opt_do_pstack, 0, GET_BOOL, NO_ARG, 0, 0,
   0, 0, 0, 0},
  {"exit-info", 'T', "Used for debugging;  Use at your own risk!", 0, 0, 0,
   GET_LONG, OPT_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
4253 4254 4255
  {"external-locking", OPT_USE_LOCKING, "Use system (external) locking.  With this option enabled you can run myisamchk to test (not repair) tables while the MySQL server is running.",
   (gptr*) &opt_external_locking, (gptr*) &opt_external_locking,
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
4256
  {"flush", OPT_FLUSH, "Flush tables to disk between SQL commands.", 0, 0, 0,
4257 4258 4259
   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 */
4260 4261 4262 4263
  {"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
unknown committed
4264 4265 4266 4267 4268 4269
  {"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},
4270
  {"init-rpl-role", OPT_INIT_RPL_ROLE, "Set the replication role.", 0, 0, 0,
4271
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
4272 4273 4274 4275 4276
  {"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).",
4277
   (gptr*) &opt_innodb, (gptr*) &opt_innodb, 0, GET_BOOL, NO_ARG, OPT_INNODB_DEFAULT, 0, 0,
unknown's avatar
unknown committed
4278
   0, 0, 0},
4279
  {"innodb_data_file_path", OPT_INNODB_DATA_FILE_PATH,
4280
   "Path to individual files and their sizes.",
4281
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
4282
#ifdef HAVE_INNOBASE_DB
4283
  {"innodb_data_home_dir", OPT_INNODB_DATA_HOME_DIR,
unknown's avatar
unknown committed
4284
   "The common part for InnoDB table spaces.", (gptr*) &innobase_data_home_dir,
4285 4286
   (gptr*) &innobase_data_home_dir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0,
   0},
unknown's avatar
unknown committed
4287 4288 4289 4290 4291 4292 4293
  {"innodb_fast_shutdown", OPT_INNODB_FAST_SHUTDOWN,
   "Speeds up server shutdown process.", (gptr*) &innobase_fast_shutdown,
   (gptr*) &innobase_fast_shutdown, 0, GET_BOOL, OPT_ARG, 1, 0, 0, 0, 0, 0},
  {"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},
4294
  {"innodb_flush_log_at_trx_commit", OPT_INNODB_FLUSH_LOG_AT_TRX_COMMIT,
4295
   "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).",
4296 4297
   (gptr*) &innobase_flush_log_at_trx_commit,
   (gptr*) &innobase_flush_log_at_trx_commit,
unknown's avatar
unknown committed
4298
   0, GET_UINT, OPT_ARG,  1, 0, 2, 0, 0, 0},
4299
  {"innodb_flush_method", OPT_INNODB_FLUSH_METHOD,
4300
   "With which method to flush data.", (gptr*) &innobase_unix_file_flush_method,
4301 4302
   (gptr*) &innobase_unix_file_flush_method, 0, GET_STR, REQUIRED_ARG, 0, 0, 0,
   0, 0, 0},
4303
  {"innodb_locks_unsafe_for_binlog", OPT_INNODB_LOCKS_UNSAFE_FOR_BINLOG,
unknown's avatar
unknown committed
4304
   "Force InnoDB not to use next-key locking. Instead use only row-level locking",
4305 4306
   (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
4307 4308 4309 4310 4311
  {"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,
4312
   0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
4313 4314 4315 4316 4317 4318 4319
  {"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},
4320
  {"innodb_max_purge_lag", OPT_INNODB_MAX_PURGE_LAG,
unknown's avatar
unknown committed
4321
   "Desired maximum length of the purge queue (0 = no limit)",
4322 4323 4324
   (gptr*) &srv_max_purge_lag,
   (gptr*) &srv_max_purge_lag, 0, GET_LONG, REQUIRED_ARG, 0, 0, ~0L,
   0, 1L, 0},
4325 4326 4327 4328
  {"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},
4329
  {"innodb_table_locks", OPT_INNODB_TABLE_LOCKS,
unknown's avatar
unknown committed
4330
   "Enable InnoDB locking in LOCK TABLES",
4331 4332
   (gptr*) &global_system_variables.innodb_table_locks,
   (gptr*) &global_system_variables.innodb_table_locks,
unknown's avatar
unknown committed
4333
   0, GET_BOOL, OPT_ARG, 1, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
4334 4335 4336
#endif /* End HAVE_INNOBASE_DB */
  {"isam", OPT_ISAM, "Enable ISAM (if this version of MySQL supports it). \
Disable with --skip-isam.",
4337
   (gptr*) &opt_isam, (gptr*) &opt_isam, 0, GET_BOOL, NO_ARG, OPT_ISAM_DEFAULT, 0, 0,
unknown's avatar
unknown committed
4338
   0, 0, 0},
4339
  {"language", 'L',
4340
   "Client error messages in given language. May be given as a full path.",
4341 4342 4343
   (gptr*) &language_ptr, (gptr*) &language_ptr, 0, GET_STR, REQUIRED_ARG,
   0, 0, 0, 0, 0, 0},
  {"local-infile", OPT_LOCAL_INFILE,
4344
   "Enable/disable LOAD DATA LOCAL INFILE (takes values 1|0).",
unknown's avatar
unknown committed
4345 4346
   (gptr*) &opt_local_infile,
   (gptr*) &opt_local_infile, 0, GET_BOOL, OPT_ARG,
4347
   1, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
4348 4349
  {"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},
4350
  {"log-bin", OPT_BIN_LOG,
4351
   "Log update queries in binary format.",
4352
   (gptr*) &opt_bin_logname, (gptr*) &opt_bin_logname, 0, GET_STR_ALLOC,
unknown's avatar
unknown committed
4353
   OPT_ARG, 0, 0, 0, 0, 0, 0},
4354
  {"log-bin-index", OPT_BIN_LOG_INDEX,
4355
   "File that holds the names for last binary log files.",
4356 4357
   (gptr*) &opt_binlog_index_name, (gptr*) &opt_binlog_index_name, 0, GET_STR,
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
4358 4359 4360
  {"log-error", OPT_ERROR_LOG_FILE, "Log error file.",
   (gptr*) &log_error_file_ptr, (gptr*) &log_error_file_ptr, 0, GET_STR,
   OPT_ARG, 0, 0, 0, 0, 0, 0},
4361
  {"log-isam", OPT_ISAM_LOG, "Log all MyISAM changes to file.",
4362 4363
   (gptr*) &myisam_log_filename, (gptr*) &myisam_log_filename, 0, GET_STR,
   OPT_ARG, 0, 0, 0, 0, 0, 0},
4364 4365 4366 4367 4368 4369 4370
  {"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},
  {"log-queries-not-using-indexes", OPT_LOG_QUERIES_NOT_USING_INDEXES,
   "Log queries that are executed without benefit of any index.",
   (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
4371 4372 4373 4374
  {"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},
4375
  {"log-slave-updates", OPT_LOG_SLAVE_UPDATES,
unknown's avatar
unknown committed
4376
   "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.",
4377 4378
   (gptr*) &opt_log_slave_updates, (gptr*) &opt_log_slave_updates, 0, GET_BOOL,
   NO_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
4379 4380 4381 4382 4383 4384 4385 4386
  {"log-slow-queries", OPT_SLOW_QUERY_LOG,
   "Log slow queries to this log file. Defaults logging to hostname-slow.log file.",
   (gptr*) &opt_slow_logname, (gptr*) &opt_slow_logname, 0, GET_STR, OPT_ARG,
   0, 0, 0, 0, 0, 0},
  {"log-update", OPT_UPDATE_LOG,
   "Log updates to file.# where # is a unique number if not given.",
   (gptr*) &opt_update_logname, (gptr*) &opt_update_logname, 0, GET_STR,
   OPT_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
4387
  {"log-warnings", 'W', "Log some non-critical warnings to the error log file. Use this option twice or --log-warnings=2 if you also want 'Aborted connections' warnings.",
unknown's avatar
unknown committed
4388
   (gptr*) &global_system_variables.log_warnings,
unknown's avatar
unknown committed
4389
   (gptr*) &max_system_variables.log_warnings, 0, GET_ULONG, OPT_ARG, 1, 0, ~0L,
unknown's avatar
unknown committed
4390
   0, 0, 0},
4391
  {"low-priority-updates", OPT_LOW_PRIORITY_UPDATES,
4392
   "INSERT/DELETE/UPDATE has lower priority than selects.",
unknown's avatar
unknown committed
4393 4394 4395
   (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
4396 4397 4398 4399
  {"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},
4400
  {"master-host", OPT_MASTER_HOST,
4401 4402 4403
   "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
4404 4405 4406 4407 4408
  {"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},
4409 4410
  {"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
4411 4412
   (gptr*)&master_password, (gptr*)&master_password, 0,
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
4413
  {"master-port", OPT_MASTER_PORT,
4414
   "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.",
4415 4416 4417 4418 4419
   (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,
4420
   REQUIRED_ARG, 3600*24, 0, 0, 0, 0, 0},
4421
  {"master-ssl", OPT_MASTER_SSL,
unknown's avatar
unknown committed
4422
   "Enable the slave to connect to the master using SSL.",
4423 4424
   (gptr*) &master_ssl, (gptr*) &master_ssl, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
   0, 0},
unknown's avatar
unknown committed
4425 4426 4427 4428
  {"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
4429
  {"master-ssl-capath", OPT_MASTER_SSL_CAPATH,
unknown's avatar
unknown committed
4430
   "Master SSL CA path. Only applies if you have enabled master-ssl.",
unknown's avatar
unknown committed
4431 4432
   (gptr*) &master_ssl_capath, (gptr*) &master_ssl_capath, 0, GET_STR, OPT_ARG,
   0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
4433 4434 4435 4436 4437
  {"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
4438
  {"master-ssl-cipher", OPT_MASTER_SSL_CIPHER,
unknown's avatar
unknown committed
4439
   "Master SSL cipher. Only applies if you have enabled master-ssl.",
unknown's avatar
unknown committed
4440
   (gptr*) &master_ssl_cipher, (gptr*) &master_ssl_capath, 0, GET_STR, OPT_ARG,
4441
   0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
4442 4443 4444 4445 4446 4447 4448 4449
  {"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
4450
#ifdef HAVE_REPLICATION
4451
  {"max-binlog-dump-events", OPT_MAX_BINLOG_DUMP_EVENTS,
4452
   "Option used by mysql-test for debugging and testing of replication.",
4453 4454
   (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
4455
#endif /* HAVE_REPLICATION */
unknown's avatar
unknown committed
4456 4457 4458 4459 4460 4461 4462 4463
  {"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).",
4464 4465
   (gptr*) &opt_ndbcluster, (gptr*) &opt_ndbcluster, 0, GET_BOOL, NO_ARG,
   OPT_NDBCLUSTER_DEFAULT, 0, 0, 0, 0, 0},
4466
#ifdef HAVE_NDBCLUSTER_DB
4467 4468
  {"ndb-connectstring", OPT_NDB_CONNECTSTRING,
   "Connect string for ndbcluster.",
4469 4470
   (gptr*) &opt_ndbcluster_connectstring,
   (gptr*) &opt_ndbcluster_connectstring,
4471
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
4472 4473
  {"ndb-autoincrement-prefetch-sz", OPT_NDB_AUTOINCREMENT_PREFETCH_SZ,
   "Specify number of autoincrement values that are prefetched.",
4474 4475 4476
   (gptr*) &global_system_variables.ndb_autoincrement_prefetch_sz,
   (gptr*) &global_system_variables.ndb_autoincrement_prefetch_sz,
   0, GET_INT, REQUIRED_ARG, 32, 1, 256, 0, 0, 0},
4477 4478 4479 4480 4481 4482
  {"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},
4483
  {"ndb_force_send", OPT_NDB_FORCE_SEND,
4484
   "same as --ndb-force-send.",
4485 4486 4487
   (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},
4488 4489 4490 4491 4492 4493
  {"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},
4494
  {"ndb_use_exact_count", OPT_NDB_USE_EXACT_COUNT,
4495
   "same as --ndb-use-exact-count.",
4496 4497 4498
   (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},
4499 4500 4501 4502 4503 4504 4505 4506 4507 4508
  {"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},
4509
#endif
4510
  {"new", 'n', "Use very new possible 'unsafe' functions.",
4511 4512 4513
   (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
4514
#ifdef NOT_YET
4515
  {"no-mix-table-types", OPT_NO_MIX_TYPE, "Don't allow commands with uses two different table types.",
4516 4517 4518
   (gptr*) &opt_no_mix_types, (gptr*) &opt_no_mix_types, 0, GET_BOOL, NO_ARG,
   0, 0, 0, 0, 0, 0},
#endif
4519 4520 4521 4522
  {"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},
4523
#ifdef ONE_THREAD
4524
  {"one-thread", OPT_ONE_THREAD,
4525
   "Only use one thread (for debugging under Linux).", 0, 0, 0, GET_NO_ARG,
4526 4527
   NO_ARG, 0, 0, 0, 0, 0, 0},
#endif
4528
  {"pid-file", OPT_PID_FILE, "Pid file used by safe_mysqld.",
4529 4530
   (gptr*) &pidfile_name_ptr, (gptr*) &pidfile_name_ptr, 0, GET_STR,
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
4531 4532
  {"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},
unknown's avatar
unknown committed
4533 4534 4535 4536 4537 4538 4539 4540 4541 4542 4543 4544 4545 4546
  {"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},
4547 4548 4549 4550 4551 4552 4553 4554 4555 4556 4557 4558 4559
  {"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,
4560
   "Updates to a database with a different name than the original. Example: replicate-rewrite-db=master_db_name->slave_db_name.",
4561
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
4562 4563 4564 4565 4566 4567
  {"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},
unknown's avatar
unknown committed
4568
#ifdef HAVE_REPLICATION
4569 4570 4571 4572 4573 4574 4575
  {"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
4576
#endif
4577
  // In replication, we may need to tell the other servers how to connect
4578 4579 4580 4581
  {"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},
4582
  {"report-password", OPT_REPORT_PASSWORD, "Undocumented.",
4583 4584 4585 4586 4587 4588
   (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
4589 4590
  {"report-user", OPT_REPORT_USER, "Undocumented.", (gptr*) &report_user,
   (gptr*) &report_user, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
4591
  {"rpl-recovery-rank", OPT_RPL_RECOVERY_RANK, "Undocumented.",
4592
   (gptr*) &rpl_recovery_rank, (gptr*) &rpl_recovery_rank, 0, GET_ULONG,
4593 4594 4595
   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
4596
#ifndef TO_BE_DELETED
4597
  {"safe-show-database", OPT_SAFE_SHOW_DB,
unknown's avatar
unknown committed
4598
   "Deprecated option; use GRANT SHOW DATABASES instead...",
4599
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
4600
#endif
4601
  {"safe-user-create", OPT_SAFE_USER_CREATE,
4602
   "Don't allow new user creation by the user who has no write privileges to the mysql.user table.",
4603 4604
   (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
4605 4606 4607
  {"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},
4608 4609 4610
  {"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},
4611
  {"server-id",	OPT_SERVER_ID,
4612
   "Uniquely identifies the server instance in the community of replication partners.",
unknown's avatar
unknown committed
4613
   (gptr*) &server_id, (gptr*) &server_id, 0, GET_ULONG, REQUIRED_ARG, 0, 0, 0,
4614 4615 4616 4617
   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},
4618
#ifdef HAVE_SMEM
unknown's avatar
unknown committed
4619 4620 4621 4622 4623 4624
  {"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,
4625
   "Base name of shared memory.", (gptr*) &shared_memory_base_name, (gptr*) &shared_memory_base_name,
4626 4627
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
#endif
unknown's avatar
unknown committed
4628
  {"show-slave-auth-info", OPT_SHOW_SLAVE_AUTH_INFO,
4629
   "Show user and password in SHOW SLAVE HOSTS on this master",
4630 4631 4632 4633 4634 4635
   (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
4636 4637
  {"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},
4638
  {"skip-locking", OPT_SKIP_LOCK,
4639
   "Deprecated option, use --skip-external-locking instead.",
4640 4641
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  {"skip-name-resolve", OPT_SKIP_RESOLVE,
4642
   "Don't resolve hostnames. All hostnames are IP's or 'localhost'.",
4643 4644 4645 4646 4647 4648
   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
4649 4650 4651 4652 4653 4654 4655
#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
4656
  {"skip-show-database", OPT_SKIP_SHOW_DB,
4657
   "Don't allow 'SHOW DATABASE' commands.", 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0,
4658 4659 4660 4661 4662
   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,
4663
   "Don't print a stack trace on failure.", 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0,
4664
   0, 0, 0, 0},
unknown's avatar
unknown committed
4665
  {"skip-symlink", OPT_SKIP_SYMLINKS, "Don't allow symlinking of tables. Deprecated option.  Use --skip-symbolic-links instead.",
4666 4667 4668 4669
   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
4670
#ifdef HAVE_REPLICATION
4671
  {"slave-load-tmpdir", OPT_SLAVE_LOAD_TMPDIR,
4672
   "The location where the slave should put its temporary files when \
4673
replicating a LOAD DATA INFILE command.",
4674
   (gptr*) &slave_load_tmpdir, (gptr*) &slave_load_tmpdir, 0, GET_STR_ALLOC,
4675 4676
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {"slave-skip-errors", OPT_SLAVE_SKIP_ERRORS,
4677
   "Tells the slave thread to continue replication when a query returns an error from the provided list.",
4678
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
4679
#endif
4680
  {"socket", OPT_SOCKET, "Socket file to use for connection.",
4681
   (gptr*) &mysqld_unix_port, (gptr*) &mysqld_unix_port, 0, GET_STR,
4682
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
4683 4684 4685 4686 4687 4688 4689
#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 */
4690 4691 4692 4693 4694
  {"sql-bin-update-same", OPT_SQL_BIN_UPDATE_SAME,
   "If set, setting SQL_LOG_BIN to a value will automatically set SQL_LOG_UPDATE to the same value and vice versa.",
   (gptr*) &opt_sql_bin_update, (gptr*) &opt_sql_bin_update, 0, GET_BOOL,
   NO_ARG, 0, 0, 0, 0, 0, 0},
  {"sql-mode", OPT_SQL_MODE,
4695
   "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.",
4696 4697
   (gptr*) &sql_mode_str, (gptr*) &sql_mode_str, 0, GET_STR, REQUIRED_ARG, 0,
   0, 0, 0, 0, 0},
4698
#ifdef HAVE_OPENSSL
4699 4700
#include "sslopt-longopts.h"
#endif
unknown's avatar
unknown committed
4701 4702 4703 4704 4705 4706 4707 4708
#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
4709
  {"temp-pool", OPT_TEMP_POOL,
4710
   "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
4711 4712
   (gptr*) &use_temp_pool, (gptr*) &use_temp_pool, 0, GET_BOOL, NO_ARG, 1,
   0, 0, 0, 0, 0},
unknown's avatar
unknown committed
4713 4714
  {"tmpdir", 't',
   "Path for temporary files. Several paths may be specified, separated by a "
4715
#if defined( __WIN__) || defined(OS2) || defined(__NETWARE__)
unknown's avatar
unknown committed
4716 4717 4718 4719 4720 4721
   "semicolon (;)"
#else
   "colon (:)"
#endif
   ", in this case they are used in a round-robin fashion.",
   (gptr*) &opt_mysql_tmpdir,
unknown's avatar
unknown committed
4722
   (gptr*) &opt_mysql_tmpdir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
4723
  {"transaction-isolation", OPT_TX_ISOLATION,
4724
   "Default transaction isolation level.", 0, 0, 0, GET_STR, REQUIRED_ARG, 0,
unknown's avatar
unknown committed
4725
   0, 0, 0, 0, 0},
unknown's avatar
unknown committed
4726
  {"use-symbolic-links", 's', "Enable symbolic link support. Deprecated option; use --symbolic-links instead.",
4727
   (gptr*) &my_use_symdir, (gptr*) &my_use_symdir, 0, GET_BOOL, NO_ARG,
unknown's avatar
unknown committed
4728
   IF_PURIFY(0,1), 0, 0, 0, 0, 0},
4729
  {"user", 'u', "Run mysqld daemon as user.", 0, 0, 0, GET_STR, REQUIRED_ARG,
unknown's avatar
unknown committed
4730
   0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
4731 4732 4733
  {"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},
4734
  {"version", 'V', "Output version information and exit.", 0, 0, 0, GET_NO_ARG,
4735
   NO_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
4736
  {"warnings", 'W', "Deprecated; use --log-warnings instead.",
unknown's avatar
unknown committed
4737
   (gptr*) &global_system_variables.log_warnings,
4738
   (gptr*) &max_system_variables.log_warnings, 0, GET_ULONG, OPT_ARG, 1, 0, ~0L,
4739 4740
   0, 0, 0},
  { "back_log", OPT_BACK_LOG,
4741 4742
    "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,
4743
    REQUIRED_ARG, 50, 1, 65535, 0, 1, 0 },
unknown's avatar
unknown committed
4744
#ifdef HAVE_BERKELEY_DB
4745
  { "bdb_cache_size", OPT_BDB_CACHE_SIZE,
4746
    "The buffer that is allocated to cache index and rows for BDB tables.",
4747 4748
    (gptr*) &berkeley_cache_size, (gptr*) &berkeley_cache_size, 0, GET_ULONG,
    REQUIRED_ARG, KEY_CACHE_SIZE, 20*1024, (long) ~0, 0, IO_SIZE, 0},
unknown's avatar
unknown committed
4749 4750 4751 4752
  /* QQ: The following should be removed soon! (bdb_max_lock preferred) */
  {"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},
4753 4754 4755 4756 4757 4758 4759 4760 4761 4762 4763 4764 4765
  {"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},
#endif /* HAVE_BERKELEY_DB */
  {"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
4766 4767 4768 4769 4770
  {"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},
4771
  {"connect_timeout", OPT_CONNECT_TIMEOUT,
4772
   "The number of seconds the mysqld server is waiting for a connect packet before responding with 'Bad handshake'.",
unknown's avatar
unknown committed
4773 4774
    (gptr*) &connect_timeout, (gptr*) &connect_timeout,
   0, GET_ULONG, REQUIRED_ARG, CONNECT_TIMEOUT, 2, LONG_TIMEOUT, 0, 1, 0 },
unknown's avatar
unknown committed
4775 4776 4777 4778 4779 4780
#ifdef HAVE_REPLICATION
  {"crash_binlog_innodb", OPT_CRASH_BINLOG_INNODB,
   "Used only for testing, to crash when writing Nth event to binlog.",
   (gptr*) &opt_crash_binlog_innodb, (gptr*) &opt_crash_binlog_innodb,
   0, GET_UINT, REQUIRED_ARG, 0, 0, ~(uint)0, 0, 1, 0},
#endif
unknown's avatar
unknown committed
4781 4782 4783 4784 4785 4786 4787 4788 4789 4790 4791 4792 4793 4794 4795
  { "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},
4796 4797 4798 4799
  {"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
4800 4801 4802 4803
  {"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},
4804 4805 4806 4807
  { "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
4808
  {"expire_logs_days", OPT_EXPIRE_LOGS_DAYS,
4809 4810
   "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
4811 4812 4813
   (gptr*) &expire_logs_days,
   (gptr*) &expire_logs_days, 0, GET_ULONG,
   REQUIRED_ARG, 0, 0, 99, 0, 1, 0},
4814 4815 4816 4817
  { "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
4818 4819 4820 4821
  { "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},
4822 4823 4824
  { "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,
4825
    REQUIRED_ARG, HA_FT_MAXCHARLEN, 10, HA_FT_MAXCHARLEN, 0, 1, 0},
unknown's avatar
unknown committed
4826 4827 4828 4829
  { "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},
4830 4831 4832 4833
  { "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},
4834 4835 4836 4837
  { "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
4838 4839 4840 4841 4842
  { "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},
unknown's avatar
unknown committed
4843
#ifdef HAVE_INNOBASE_DB
4844 4845 4846 4847 4848
  {"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},
4849 4850 4851 4852
  {"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
4853
   0, GET_LONG, REQUIRED_ARG, 8L, 1L, 1000L, 0, 1L, 0},
unknown's avatar
unknown committed
4854 4855 4856 4857 4858 4859 4860 4861
  {"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,
   GET_LONG, REQUIRED_ARG, 8*1024*1024L, 1024*1024L, ~0L, 0, 1024*1024L, 0},
4862 4863 4864 4865
  {"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
4866 4867 4868 4869
  {"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},
4870 4871 4872 4873
  {"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
4874 4875 4876 4877 4878 4879 4880 4881 4882 4883 4884 4885 4886 4887 4888 4889 4890 4891 4892 4893 4894
  {"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,
   "Size of each log file in a log group in megabytes.",
   (gptr*) &innobase_log_file_size, (gptr*) &innobase_log_file_size, 0,
   GET_LONG, REQUIRED_ARG, 5*1024*1024L, 1*1024*1024L, ~0L, 0, 1024*1024L, 0},
  {"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
unknown committed
4895
#ifdef HAVE_REPLICATION
4896 4897 4898 4899 4900
  /*
    Disabled for the 4.1.3 release. Disabling just this paragraph of code is
    enough, as then user can't set it to 1 so it will always be ignored in the
    rest of code.
  */
4901
#if MYSQL_VERSION_ID >= 40103
unknown's avatar
unknown committed
4902 4903 4904 4905 4906 4907 4908
  /*
    innodb_safe_binlog is not a variable, just an option. Does not make
    sense to make it a variable, as it is only used at startup (and so the
    value would be lost at next startup, so setting it on the fly would have no
    effect).
  */
  {"innodb_safe_binlog", OPT_INNODB_SAFE_BINLOG,
4909 4910
   "After a crash recovery by InnoDB, truncate the binary log after the last "
   "not-rolled-back statement/transaction.",
unknown's avatar
unknown committed
4911 4912
   (gptr*) &opt_innodb_safe_binlog, (gptr*) &opt_innodb_safe_binlog,
   0, GET_BOOL, NO_ARG, 0, 0, 1, 0, 1, 0},
4913
#endif
unknown's avatar
unknown committed
4914
#endif
4915 4916 4917 4918 4919 4920 4921
  {"innodb_thread_concurrency", OPT_INNODB_THREAD_CONCURRENCY,
   "Helps in performance tuning in heavily concurrent environments.",
   (gptr*) &innobase_thread_concurrency, (gptr*) &innobase_thread_concurrency,
   0, GET_LONG, REQUIRED_ARG, 8, 1, 1000, 0, 1, 0},
#endif /* HAVE_INNOBASE_DB */
  {"interactive_timeout", OPT_INTERACTIVE_TIMEOUT,
   "The number of seconds the server waits for activity on an interactive connection before closing it.",
4922 4923
   (gptr*) &global_system_variables.net_interactive_timeout,
   (gptr*) &max_system_variables.net_interactive_timeout, 0,
4924 4925 4926
   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.",
4927 4928
   (gptr*) &global_system_variables.join_buff_size,
   (gptr*) &max_system_variables.join_buff_size, 0, GET_ULONG,
4929 4930 4931
   REQUIRED_ARG, 128*1024L, IO_SIZE*2+MALLOC_OVERHEAD, ~0L, MALLOC_OVERHEAD,
   IO_SIZE, 0},
  {"key_buffer_size", OPT_KEY_BUFFER_SIZE,
4932
   "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
4933
   (gptr*) &dflt_key_cache_var.param_buff_size,
4934
   (gptr*) 0,
unknown's avatar
unknown committed
4935
   0, (GET_ULL | GET_ASK_ADDR),
unknown's avatar
unknown committed
4936
   REQUIRED_ARG, KEY_CACHE_SIZE, MALLOC_OVERHEAD, UINT_MAX32, MALLOC_OVERHEAD,
4937
   IO_SIZE, 0},
unknown's avatar
unknown committed
4938 4939 4940 4941 4942 4943
  {"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
4944 4945
  {"key_cache_block_size", OPT_KEY_CACHE_BLOCK_SIZE,
   "The default size of key cache blocks",
unknown's avatar
unknown committed
4946
   (gptr*) &dflt_key_cache_var.param_block_size,
4947
   (gptr*) 0,
unknown's avatar
unknown committed
4948
   0, (GET_ULONG | GET_ASK_ADDR), REQUIRED_ARG,
4949
   KEY_CACHE_BLOCK_SIZE , 512, 1024*16, MALLOC_OVERHEAD, 512, 0},
4950 4951
  {"key_cache_division_limit", OPT_KEY_CACHE_DIVISION_LIMIT,
   "The minimum percentage of warm blocks in key cache",
unknown's avatar
unknown committed
4952
   (gptr*) &dflt_key_cache_var.param_division_limit,
4953
   (gptr*) 0,
unknown's avatar
unknown committed
4954
   0, (GET_ULONG | GET_ASK_ADDR) , REQUIRED_ARG, 100,
4955
   1, 100, 0, 1, 0},
4956 4957
  {"long_query_time", OPT_LONG_QUERY_TIME,
   "Log all queries that have taken more than long_query_time seconds to execute to file.",
4958 4959
   (gptr*) &global_system_variables.long_query_time,
   (gptr*) &max_system_variables.long_query_time, 0, GET_ULONG,
4960 4961
   REQUIRED_ARG, 10, 1, LONG_TIMEOUT, 0, 1, 0},
  {"lower_case_table_names", OPT_LOWER_CASE_TABLE_NAMES,
unknown's avatar
unknown committed
4962
   "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",
4963
   (gptr*) &lower_case_table_names,
unknown's avatar
unknown committed
4964
   (gptr*) &lower_case_table_names, 0, GET_UINT, OPT_ARG,
4965 4966 4967 4968 4969
#ifdef FN_NO_CASE_SENCE
    1
#else
    0
#endif
unknown's avatar
unknown committed
4970
   , 0, 2, 0, 1, 0},
4971 4972
  {"max_allowed_packet", OPT_MAX_ALLOWED_PACKET,
   "Max packetlength to send/receive from to server.",
unknown's avatar
unknown committed
4973 4974
   (gptr*) &global_system_variables.max_allowed_packet,
   (gptr*) &max_system_variables.max_allowed_packet, 0, GET_ULONG,
unknown's avatar
unknown committed
4975
   REQUIRED_ARG, 1024*1024L, 1024, 1024L*1024L*1024L, MALLOC_OVERHEAD, 1024, 0},
4976 4977 4978 4979 4980
  {"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,
4981 4982 4983
   "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.",
4984
   (gptr*) &max_binlog_size, (gptr*) &max_binlog_size, 0, GET_ULONG,
4985
   REQUIRED_ARG, 1024*1024L*1024L, IO_SIZE, 1024*1024L*1024L, 0, IO_SIZE, 0},
4986 4987 4988 4989
  {"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
4990 4991 4992 4993
  {"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},
4994
  {"max_delayed_threads", OPT_MAX_DELAYED_THREADS,
4995
   "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.",
4996 4997
   (gptr*) &global_system_variables.max_insert_delayed_threads,
   (gptr*) &max_system_variables.max_insert_delayed_threads,
4998
   0, GET_ULONG, REQUIRED_ARG, 20, 0, 16384, 0, 1, 0},
4999
  {"max_error_count", OPT_MAX_ERROR_COUNT,
5000
   "Max number of errors/warnings to store for a statement.",
5001 5002 5003
   (gptr*) &global_system_variables.max_error_count,
   (gptr*) &max_system_variables.max_error_count,
   0, GET_ULONG, REQUIRED_ARG, DEFAULT_ERROR_COUNT, 1, 65535, 0, 1, 0},
5004 5005
  {"max_heap_table_size", OPT_MAX_HEP_TABLE_SIZE,
   "Don't allow creation of heap tables bigger than this.",
5006 5007
   (gptr*) &global_system_variables.max_heap_table_size,
   (gptr*) &max_system_variables.max_heap_table_size, 0, GET_ULONG,
5008 5009 5010
   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.",
5011
   (gptr*) &global_system_variables.max_join_size,
5012
   (gptr*) &max_system_variables.max_join_size, 0, GET_HA_ROWS, REQUIRED_ARG,
5013
   ~0L, 1, ~0L, 0, 1, 0},
unknown's avatar
unknown committed
5014
   {"max_length_for_sort_data", OPT_MAX_LENGTH_FOR_SORT_DATA,
5015
    "Max number of bytes in sorted records.",
unknown's avatar
unknown committed
5016 5017 5018
    (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},
5019
  {"max_relay_log_size", OPT_MAX_RELAY_LOG_SIZE,
unknown's avatar
unknown committed
5020
   "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 expected, the minimum value for this variable is 4096.",
5021 5022
   (gptr*) &max_relay_log_size, (gptr*) &max_relay_log_size, 0, GET_ULONG,
   REQUIRED_ARG, 0L, 0L, 1024*1024L*1024L, 0, IO_SIZE, 0},
5023 5024 5025 5026 5027
  { "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 },
5028 5029
  {"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
5030 5031
   (gptr*) &global_system_variables.max_sort_length,
   (gptr*) &max_system_variables.max_sort_length, 0, GET_ULONG,
5032 5033 5034
   REQUIRED_ARG, 1024, 4, 8192*1024L, 0, 1, 0},
  {"max_tmp_tables", OPT_MAX_TMP_TABLES,
   "Maximum number of temporary tables a client can keep open at a time.",
5035 5036
   (gptr*) &global_system_variables.max_tmp_tables,
   (gptr*) &max_system_variables.max_tmp_tables, 0, GET_ULONG,
5037 5038 5039 5040 5041 5042 5043 5044 5045 5046
   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).",
   (gptr*) &max_user_connections, (gptr*) &max_user_connections, 0, GET_ULONG,
   REQUIRED_ARG, 0, 1, ~0L, 0, 1, 0},
  {"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},
  {"myisam_block_size", OPT_MYISAM_BLOCK_SIZE,
5047
   "Block size to be used for MyISAM index pages.",
unknown's avatar
unknown committed
5048
   (gptr*) &opt_myisam_block_size,
5049 5050 5051
   (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
5052 5053 5054 5055
  {"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,
5056
   4, 2, 8, 0, 1, 0},
5057
  {"myisam_max_extra_sort_file_size", OPT_MYISAM_MAX_EXTRA_SORT_FILE_SIZE,
5058
   "Used to help MySQL to decide when to use the slow but safe key cache index create method.",
5059 5060
   (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
5061
   0, GET_ULL, REQUIRED_ARG, (ulonglong) MI_MAX_TEMP_LENGTH,
5062
   0, (ulonglong) MAX_FILE_SIZE, 0, 1, 0},
5063
  {"myisam_max_sort_file_size", OPT_MYISAM_MAX_SORT_FILE_SIZE,
5064
   "Don't use the fast sort index method to created index if the temporary file would get bigger than this.",
5065 5066
   (gptr*) &global_system_variables.myisam_max_sort_file_size,
   (gptr*) &max_system_variables.myisam_max_sort_file_size, 0,
5067 5068
   GET_ULL, REQUIRED_ARG, (longlong) LONG_MAX, 0, (ulonglong) MAX_FILE_SIZE,
   0, 1024*1024, 0},
5069 5070 5071 5072 5073
  {"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},
5074 5075
  {"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
5076 5077
   (gptr*) &global_system_variables.myisam_sort_buff_size,
   (gptr*) &max_system_variables.myisam_sort_buff_size, 0,
5078 5079
   GET_ULONG, REQUIRED_ARG, 8192*1024, 4, ~0L, 0, 1, 0},
  {"net_buffer_length", OPT_NET_BUFFER_LENGTH,
5080
   "Buffer length for TCP/IP and socket communication.",
unknown's avatar
unknown committed
5081 5082 5083
   (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},
5084 5085
  {"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
5086 5087
   (gptr*) &global_system_variables.net_read_timeout,
   (gptr*) &max_system_variables.net_read_timeout, 0, GET_ULONG,
5088
   REQUIRED_ARG, NET_READ_TIMEOUT, 1, LONG_TIMEOUT, 0, 1, 0},
unknown's avatar
unknown committed
5089 5090 5091 5092 5093
  {"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},
5094 5095
  {"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
5096 5097
   (gptr*) &global_system_variables.net_write_timeout,
   (gptr*) &max_system_variables.net_write_timeout, 0, GET_ULONG,
5098 5099 5100 5101
   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,
5102
   REQUIRED_ARG, 0, 0, OS_FILE_LIMIT, 0, 1, 0},
unknown's avatar
unknown committed
5103 5104 5105 5106 5107
   {"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},
5108 5109 5110 5111 5112
  {"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
5113
#ifdef HAVE_QUERY_CACHE
5114 5115 5116
  {"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,
5117
   REQUIRED_ARG, 1024*1024L, 0, (longlong) ULONG_MAX, 0, 1, 0},
5118 5119 5120 5121 5122
  {"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},
5123
#endif /*HAVE_QUERY_CACHE*/
5124 5125 5126
  {"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
5127
   REQUIRED_ARG, 0, 0, (longlong) ULONG_MAX, 0, 1024, 0},
5128
#ifdef HAVE_QUERY_CACHE
unknown's avatar
unknown committed
5129
  {"query_cache_type", OPT_QUERY_CACHE_TYPE,
5130
   "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
5131 5132 5133
   (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},
5134 5135 5136 5137 5138 5139
  {"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*/
5140 5141 5142 5143
  {"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,
5144
   REQUIRED_ARG, QUERY_ALLOC_PREALLOC_SIZE, 16384, ~0L, 0, 1024, 0},
unknown's avatar
unknown committed
5145 5146 5147 5148
  {"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,
5149
   REQUIRED_ARG, RANGE_ALLOC_BLOCK_SIZE, 4096, ~0L, 0, 1024, 0},
unknown's avatar
unknown committed
5150
  {"read_buffer_size", OPT_RECORD_BUFFER,
5151
   "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
5152 5153
   (gptr*) &global_system_variables.read_buff_size,
   (gptr*) &max_system_variables.read_buff_size,0, GET_ULONG, REQUIRED_ARG,
5154
   128*1024L, IO_SIZE*2+MALLOC_OVERHEAD, ~0L, MALLOC_OVERHEAD, IO_SIZE, 0},
unknown's avatar
unknown committed
5155 5156 5157 5158 5159
  {"read_only", OPT_READONLY,
   "Make all tables readonly, with the exception for replication (slave) threads and users with the SUPER privilege",
   (gptr*) &opt_readonly,
   (gptr*) &opt_readonly,
   0, GET_BOOL, NO_ARG, 0, 0, 1, 0, 1, 0},
unknown's avatar
unknown committed
5160
  {"read_rnd_buffer_size", OPT_RECORD_RND_BUFFER,
5161
   "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
5162 5163 5164
   (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,
5165
   ~0L, MALLOC_OVERHEAD, IO_SIZE, 0},
unknown's avatar
unknown committed
5166 5167 5168 5169 5170
  {"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
5171
#ifdef HAVE_REPLICATION
5172 5173 5174 5175 5176
  {"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},
5177
  {"relay_log_space_limit", OPT_RELAY_LOG_SPACE_LIMIT,
5178
   "Maximum space to use for all relay logs.",
5179 5180
   (gptr*) &relay_log_space_limit,
   (gptr*) &relay_log_space_limit, 0, GET_ULL, REQUIRED_ARG, 0L, 0L,
5181
   (longlong) ULONG_MAX, 0, 1, 0},
5182
  {"slave_compressed_protocol", OPT_SLAVE_COMPRESSED_PROTOCOL,
5183
   "Use compression on master/slave protocol.",
5184 5185
   (gptr*) &opt_slave_compressed_protocol,
   (gptr*) &opt_slave_compressed_protocol,
5186
   0, GET_BOOL, NO_ARG, 0, 0, 1, 0, 1, 0},
5187
  {"slave_net_timeout", OPT_SLAVE_NET_TIMEOUT,
unknown's avatar
unknown committed
5188 5189
   "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,
5190
   GET_ULONG, REQUIRED_ARG, SLAVE_NET_TIMEOUT, 1, LONG_TIMEOUT, 0, 1, 0},
5191
#endif /* HAVE_REPLICATION */
5192 5193 5194 5195
  {"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
5196
  {"sort_buffer_size", OPT_SORT_BUFFER,
5197
   "Each thread that needs to do a sort allocates a buffer of this size.",
5198 5199
   (gptr*) &global_system_variables.sortbuff_size,
   (gptr*) &max_system_variables.sortbuff_size, 0, GET_ULONG, REQUIRED_ARG,
5200 5201
   MAX_SORT_MEMORY, MIN_SORT_MEMORY+MALLOC_OVERHEAD*2, ~0L, MALLOC_OVERHEAD,
   1, 0},
unknown's avatar
unknown committed
5202 5203 5204 5205 5206 5207
#ifdef HAVE_BERKELEY_DB
  {"sync-bdb-logs", OPT_BDB_SYNC,
   "Synchronously flush logs. Enabled by default",
   (gptr*) &opt_sync_bdb_logs, (gptr*) &opt_sync_bdb_logs, 0, GET_BOOL,
   NO_ARG, 1, 0, 0, 0, 0, 0},
#endif /* HAVE_BERKELEY_DB */
5208 5209 5210 5211 5212 5213
  {"sync-binlog", OPT_SYNC_BINLOG,
   "Sync the binlog to disk after every #th event. \
#=0 (the default) does no sync. Syncing slows MySQL down",
   (gptr*) &sync_binlog_period,
   (gptr*) &sync_binlog_period, 0, GET_ULONG, REQUIRED_ARG, 0, 0, ~0L, 0, 1,
   0},
unknown's avatar
unknown committed
5214 5215 5216
  {"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},
5217 5218
  {"table_cache", OPT_TABLE_CACHE,
   "The number of open tables for all threads.", (gptr*) &table_cache_size,
5219 5220
   (gptr*) &table_cache_size, 0, GET_ULONG, REQUIRED_ARG, 64, 1, 512*1024L,
   0, 1, 0},
5221 5222 5223 5224
  {"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
5225 5226 5227 5228 5229 5230 5231 5232 5233 5234 5235 5236 5237
  {"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},
5238 5239
  {"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.",
5240 5241
   (gptr*) &global_system_variables.tmp_table_size,
   (gptr*) &max_system_variables.tmp_table_size, 0, GET_ULONG,
5242
   REQUIRED_ARG, 32*1024*1024L, 1024, ~0L, 0, 1, 0},
5243 5244 5245 5246 5247 5248 5249 5250 5251 5252
  {"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},
5253
  {"wait_timeout", OPT_WAIT_TIMEOUT,
5254
   "The number of seconds the server waits for activity on a connection before closing it.",
5255 5256
   (gptr*) &global_system_variables.net_wait_timeout,
   (gptr*) &max_system_variables.net_wait_timeout, 0, GET_ULONG,
5257 5258
   REQUIRED_ARG, NET_WAIT_TIMEOUT, 1, IF_WIN(INT_MAX32/1000, LONG_TIMEOUT),
   0, 1, 0},
5259
  {0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
5260
};
unknown's avatar
unknown committed
5261

5262

unknown's avatar
unknown committed
5263
struct show_var_st status_vars[]= {
5264 5265
  {"Aborted_clients",          (char*) &aborted_threads,        SHOW_LONG},
  {"Aborted_connects",         (char*) &aborted_connects,       SHOW_LONG},
5266 5267
  {"Binlog_cache_disk_use",    (char*) &binlog_cache_disk_use,  SHOW_LONG},
  {"Binlog_cache_use",         (char*) &binlog_cache_use,       SHOW_LONG},
5268 5269
  {"Bytes_received",           (char*) &bytes_received,         SHOW_LONG},
  {"Bytes_sent",               (char*) &bytes_sent,             SHOW_LONG},
5270
  {"Com_admin_commands",       (char*) &com_other,		SHOW_LONG},
5271
  {"Com_alter_db",	       (char*) (com_stat+(uint) SQLCOM_ALTER_DB),SHOW_LONG},
5272
  {"Com_alter_table",	       (char*) (com_stat+(uint) SQLCOM_ALTER_TABLE),SHOW_LONG},
5273 5274 5275 5276 5277 5278
  {"Com_analyze",	       (char*) (com_stat+(uint) SQLCOM_ANALYZE),SHOW_LONG},
  {"Com_backup_table",	       (char*) (com_stat+(uint) SQLCOM_BACKUP_TABLE),SHOW_LONG},
  {"Com_begin",		       (char*) (com_stat+(uint) SQLCOM_BEGIN),SHOW_LONG},
  {"Com_change_db",	       (char*) (com_stat+(uint) SQLCOM_CHANGE_DB),SHOW_LONG},
  {"Com_change_master",	       (char*) (com_stat+(uint) SQLCOM_CHANGE_MASTER),SHOW_LONG},
  {"Com_check",		       (char*) (com_stat+(uint) SQLCOM_CHECK),SHOW_LONG},
5279
  {"Com_checksum",	       (char*) (com_stat+(uint) SQLCOM_CHECKSUM),SHOW_LONG},
5280 5281 5282 5283 5284
  {"Com_commit",	       (char*) (com_stat+(uint) SQLCOM_COMMIT),SHOW_LONG},
  {"Com_create_db",	       (char*) (com_stat+(uint) SQLCOM_CREATE_DB),SHOW_LONG},
  {"Com_create_function",      (char*) (com_stat+(uint) SQLCOM_CREATE_FUNCTION),SHOW_LONG},
  {"Com_create_index",	       (char*) (com_stat+(uint) SQLCOM_CREATE_INDEX),SHOW_LONG},
  {"Com_create_table",	       (char*) (com_stat+(uint) SQLCOM_CREATE_TABLE),SHOW_LONG},
unknown's avatar
unknown committed
5285 5286
  {"Com_dealloc_sql",          (char*) (com_stat+(uint) 
                                        SQLCOM_DEALLOCATE_PREPARE), SHOW_LONG},
5287
  {"Com_delete",	       (char*) (com_stat+(uint) SQLCOM_DELETE),SHOW_LONG},
5288
  {"Com_delete_multi",	       (char*) (com_stat+(uint) SQLCOM_DELETE_MULTI),SHOW_LONG},
5289
  {"Com_do",                   (char*) (com_stat+(uint) SQLCOM_DO),SHOW_LONG},
5290 5291 5292 5293
  {"Com_drop_db",	       (char*) (com_stat+(uint) SQLCOM_DROP_DB),SHOW_LONG},
  {"Com_drop_function",	       (char*) (com_stat+(uint) SQLCOM_DROP_FUNCTION),SHOW_LONG},
  {"Com_drop_index",	       (char*) (com_stat+(uint) SQLCOM_DROP_INDEX),SHOW_LONG},
  {"Com_drop_table",	       (char*) (com_stat+(uint) SQLCOM_DROP_TABLE),SHOW_LONG},
5294
  {"Com_drop_user",	       (char*) (com_stat+(uint) SQLCOM_DROP_USER),SHOW_LONG},
unknown's avatar
unknown committed
5295 5296
  {"Com_execute_sql",          (char*) (com_stat+(uint) SQLCOM_EXECUTE), 
   SHOW_LONG},
5297 5298
  {"Com_flush",		       (char*) (com_stat+(uint) SQLCOM_FLUSH),SHOW_LONG},
  {"Com_grant",		       (char*) (com_stat+(uint) SQLCOM_GRANT),SHOW_LONG},
unknown's avatar
unknown committed
5299
  {"Com_ha_close",	       (char*) (com_stat+(uint) SQLCOM_HA_CLOSE),SHOW_LONG},
5300 5301
  {"Com_ha_open",	       (char*) (com_stat+(uint) SQLCOM_HA_OPEN),SHOW_LONG},
  {"Com_ha_read",	       (char*) (com_stat+(uint) SQLCOM_HA_READ),SHOW_LONG},
5302
  {"Com_help",                 (char*) (com_stat+(uint) SQLCOM_HELP),SHOW_LONG},
5303 5304 5305 5306
  {"Com_insert",	       (char*) (com_stat+(uint) SQLCOM_INSERT),SHOW_LONG},
  {"Com_insert_select",	       (char*) (com_stat+(uint) SQLCOM_INSERT_SELECT),SHOW_LONG},
  {"Com_kill",		       (char*) (com_stat+(uint) SQLCOM_KILL),SHOW_LONG},
  {"Com_load",		       (char*) (com_stat+(uint) SQLCOM_LOAD),SHOW_LONG},
5307
  {"Com_load_master_data",     (char*) (com_stat+(uint) SQLCOM_LOAD_MASTER_DATA),SHOW_LONG},
5308 5309 5310
  {"Com_load_master_table",    (char*) (com_stat+(uint) SQLCOM_LOAD_MASTER_TABLE),SHOW_LONG},
  {"Com_lock_tables",	       (char*) (com_stat+(uint) SQLCOM_LOCK_TABLES),SHOW_LONG},
  {"Com_optimize",	       (char*) (com_stat+(uint) SQLCOM_OPTIMIZE),SHOW_LONG},
5311
  {"Com_preload_keys",	       (char*) (com_stat+(uint) SQLCOM_PRELOAD_KEYS),SHOW_LONG},
unknown's avatar
unknown committed
5312 5313
  {"Com_prepare_sql",          (char*) (com_stat+(uint) SQLCOM_PREPARE),
   SHOW_LONG}, 
5314
  {"Com_purge",		       (char*) (com_stat+(uint) SQLCOM_PURGE),SHOW_LONG},
5315
  {"Com_purge_before_date",    (char*) (com_stat+(uint) SQLCOM_PURGE_BEFORE),SHOW_LONG},
5316 5317 5318 5319 5320 5321 5322
  {"Com_rename_table",	       (char*) (com_stat+(uint) SQLCOM_RENAME_TABLE),SHOW_LONG},
  {"Com_repair",	       (char*) (com_stat+(uint) SQLCOM_REPAIR),SHOW_LONG},
  {"Com_replace",	       (char*) (com_stat+(uint) SQLCOM_REPLACE),SHOW_LONG},
  {"Com_replace_select",       (char*) (com_stat+(uint) SQLCOM_REPLACE_SELECT),SHOW_LONG},
  {"Com_reset",		       (char*) (com_stat+(uint) SQLCOM_RESET),SHOW_LONG},
  {"Com_restore_table",	       (char*) (com_stat+(uint) SQLCOM_RESTORE_TABLE),SHOW_LONG},
  {"Com_revoke",	       (char*) (com_stat+(uint) SQLCOM_REVOKE),SHOW_LONG},
5323
  {"Com_revoke_all",	       (char*) (com_stat+(uint) SQLCOM_REVOKE_ALL),SHOW_LONG},
5324
  {"Com_rollback",	       (char*) (com_stat+(uint) SQLCOM_ROLLBACK),SHOW_LONG},
5325
  {"Com_savepoint",	       (char*) (com_stat+(uint) SQLCOM_SAVEPOINT),SHOW_LONG},
5326 5327
  {"Com_select",	       (char*) (com_stat+(uint) SQLCOM_SELECT),SHOW_LONG},
  {"Com_set_option",	       (char*) (com_stat+(uint) SQLCOM_SET_OPTION),SHOW_LONG},
5328
  {"Com_show_binlog_events",   (char*) (com_stat+(uint) SQLCOM_SHOW_BINLOG_EVENTS),SHOW_LONG},
5329
  {"Com_show_binlogs",	       (char*) (com_stat+(uint) SQLCOM_SHOW_BINLOGS),SHOW_LONG},
5330
  {"Com_show_charsets",	       (char*) (com_stat+(uint) SQLCOM_SHOW_CHARSETS),SHOW_LONG},
5331
  {"Com_show_collations",      (char*) (com_stat+(uint) SQLCOM_SHOW_COLLATIONS),SHOW_LONG},
5332 5333
  {"Com_show_column_types",    (char*) (com_stat+(uint) SQLCOM_SHOW_COLUMN_TYPES),SHOW_LONG},
  {"Com_show_create_db",       (char*) (com_stat+(uint) SQLCOM_SHOW_CREATE_DB),SHOW_LONG},
5334
  {"Com_show_create_table",    (char*) (com_stat+(uint) SQLCOM_SHOW_CREATE),SHOW_LONG},
5335
  {"Com_show_databases",       (char*) (com_stat+(uint) SQLCOM_SHOW_DATABASES),SHOW_LONG},
5336
  {"Com_show_errors",	       (char*) (com_stat+(uint) SQLCOM_SHOW_ERRORS),SHOW_LONG},
5337 5338
  {"Com_show_fields",	       (char*) (com_stat+(uint) SQLCOM_SHOW_FIELDS),SHOW_LONG},
  {"Com_show_grants",	       (char*) (com_stat+(uint) SQLCOM_SHOW_GRANTS),SHOW_LONG},
5339
  {"Com_show_innodb_status",   (char*) (com_stat+(uint) SQLCOM_SHOW_INNODB_STATUS),SHOW_LONG},
5340 5341
  {"Com_show_keys",	       (char*) (com_stat+(uint) SQLCOM_SHOW_KEYS),SHOW_LONG},
  {"Com_show_logs",	       (char*) (com_stat+(uint) SQLCOM_SHOW_LOGS),SHOW_LONG},
5342
  {"Com_show_master_status",   (char*) (com_stat+(uint) SQLCOM_SHOW_MASTER_STAT),SHOW_LONG},
5343
  {"Com_show_new_master",      (char*) (com_stat+(uint) SQLCOM_SHOW_NEW_MASTER),SHOW_LONG},
5344
  {"Com_show_open_tables",     (char*) (com_stat+(uint) SQLCOM_SHOW_OPEN_TABLES),SHOW_LONG},
5345
  {"Com_show_privileges",      (char*) (com_stat+(uint) SQLCOM_SHOW_PRIVILEGES),SHOW_LONG},
5346
  {"Com_show_processlist",     (char*) (com_stat+(uint) SQLCOM_SHOW_PROCESSLIST),SHOW_LONG},
5347
  {"Com_show_slave_hosts",     (char*) (com_stat+(uint) SQLCOM_SHOW_SLAVE_HOSTS),SHOW_LONG},
5348
  {"Com_show_slave_status",    (char*) (com_stat+(uint) SQLCOM_SHOW_SLAVE_STAT),SHOW_LONG},
5349
  {"Com_show_status",	       (char*) (com_stat+(uint) SQLCOM_SHOW_STATUS),SHOW_LONG},
unknown's avatar
unknown committed
5350
  {"Com_show_storage_engines", (char*) (com_stat+(uint) SQLCOM_SHOW_STORAGE_ENGINES),SHOW_LONG},
5351 5352
  {"Com_show_tables",	       (char*) (com_stat+(uint) SQLCOM_SHOW_TABLES),SHOW_LONG},
  {"Com_show_variables",       (char*) (com_stat+(uint) SQLCOM_SHOW_VARIABLES),SHOW_LONG},
5353
  {"Com_show_warnings",        (char*) (com_stat+(uint) SQLCOM_SHOW_WARNS),SHOW_LONG},
5354 5355 5356 5357 5358
  {"Com_slave_start",	       (char*) (com_stat+(uint) SQLCOM_SLAVE_START),SHOW_LONG},
  {"Com_slave_stop",	       (char*) (com_stat+(uint) SQLCOM_SLAVE_STOP),SHOW_LONG},
  {"Com_truncate",	       (char*) (com_stat+(uint) SQLCOM_TRUNCATE),SHOW_LONG},
  {"Com_unlock_tables",	       (char*) (com_stat+(uint) SQLCOM_UNLOCK_TABLES),SHOW_LONG},
  {"Com_update",	       (char*) (com_stat+(uint) SQLCOM_UPDATE),SHOW_LONG},
5359
  {"Com_update_multi",	       (char*) (com_stat+(uint) SQLCOM_UPDATE_MULTI),SHOW_LONG},
5360
  {"Connections",              (char*) &thread_id,              SHOW_LONG_CONST},
5361
  {"Created_tmp_disk_tables",  (char*) &created_tmp_disk_tables,SHOW_LONG},
5362
  {"Created_tmp_files",	       (char*) &my_tmp_file_created,	SHOW_LONG},
5363 5364
  {"Created_tmp_tables",       (char*) &created_tmp_tables,     SHOW_LONG},
  {"Delayed_errors",           (char*) &delayed_insert_errors,  SHOW_LONG},
5365
  {"Delayed_insert_threads",   (char*) &delayed_insert_threads, SHOW_LONG_CONST},
5366 5367
  {"Delayed_writes",           (char*) &delayed_insert_writes,  SHOW_LONG},
  {"Flush_commands",           (char*) &refresh_version,        SHOW_LONG_CONST},
5368
  {"Handler_commit",           (char*) &ha_commit_count,        SHOW_LONG},
5369
  {"Handler_delete",           (char*) &ha_delete_count,        SHOW_LONG},
unknown's avatar
unknown committed
5370
  {"Handler_discover",         (char*) &ha_discover_count,      SHOW_LONG},
5371 5372 5373 5374 5375 5376
  {"Handler_read_first",       (char*) &ha_read_first_count,    SHOW_LONG},
  {"Handler_read_key",         (char*) &ha_read_key_count,      SHOW_LONG},
  {"Handler_read_next",        (char*) &ha_read_next_count,     SHOW_LONG},
  {"Handler_read_prev",        (char*) &ha_read_prev_count,     SHOW_LONG},
  {"Handler_read_rnd",         (char*) &ha_read_rnd_count,      SHOW_LONG},
  {"Handler_read_rnd_next",    (char*) &ha_read_rnd_next_count, SHOW_LONG},
5377
  {"Handler_rollback",         (char*) &ha_rollback_count,      SHOW_LONG},
5378 5379
  {"Handler_update",           (char*) &ha_update_count,        SHOW_LONG},
  {"Handler_write",            (char*) &ha_write_count,         SHOW_LONG},
unknown's avatar
unknown committed
5380
  {"Key_blocks_not_flushed",   (char*) &dflt_key_cache_var.global_blocks_changed,
5381
   SHOW_KEY_CACHE_LONG},
5382 5383
  {"Key_blocks_unused",        (char*) &dflt_key_cache_var.blocks_unused,
   SHOW_KEY_CACHE_CONST_LONG},
unknown's avatar
unknown committed
5384 5385
  {"Key_blocks_used",          (char*) &dflt_key_cache_var.blocks_used,
   SHOW_KEY_CACHE_CONST_LONG},
unknown's avatar
unknown committed
5386
  {"Key_read_requests",        (char*) &dflt_key_cache_var.global_cache_r_requests,
5387
   SHOW_KEY_CACHE_LONG},
unknown's avatar
unknown committed
5388
  {"Key_reads",                (char*) &dflt_key_cache_var.global_cache_read,
5389
   SHOW_KEY_CACHE_LONG},
unknown's avatar
unknown committed
5390
  {"Key_write_requests",       (char*) &dflt_key_cache_var.global_cache_w_requests,
5391
   SHOW_KEY_CACHE_LONG},
unknown's avatar
unknown committed
5392
  {"Key_writes",               (char*) &dflt_key_cache_var.global_cache_write,
5393
   SHOW_KEY_CACHE_LONG},
5394
  {"Max_used_connections",     (char*) &max_used_connections,  SHOW_LONG},
5395
  {"Not_flushed_delayed_rows", (char*) &delayed_rows_in_use,    SHOW_LONG_CONST},
unknown's avatar
unknown committed
5396 5397
  {"Open_files",               (char*) &my_file_opened,         SHOW_LONG_CONST},
  {"Open_streams",             (char*) &my_stream_opened,       SHOW_LONG_CONST},
5398
  {"Open_tables",              (char*) 0,                       SHOW_OPENTABLES},
5399
  {"Opened_tables",            (char*) &opened_tables,          SHOW_LONG},
unknown's avatar
unknown committed
5400
#ifdef HAVE_QUERY_CACHE
5401 5402 5403 5404
  {"Qcache_free_blocks",       (char*) &query_cache.free_memory_blocks,
   SHOW_LONG_CONST},
  {"Qcache_free_memory",       (char*) &query_cache.free_memory,
   SHOW_LONG_CONST},
unknown's avatar
unknown committed
5405
  {"Qcache_hits",              (char*) &query_cache.hits,       SHOW_LONG},
5406
  {"Qcache_inserts",           (char*) &query_cache.inserts,    SHOW_LONG},
5407
  {"Qcache_lowmem_prunes",     (char*) &query_cache.lowmem_prunes, SHOW_LONG},
unknown's avatar
unknown committed
5408
  {"Qcache_not_cached",        (char*) &query_cache.refused,    SHOW_LONG},
5409
  {"Qcache_queries_in_cache",  (char*) &query_cache.queries_in_cache, SHOW_LONG_CONST},
unknown's avatar
unknown committed
5410 5411
  {"Qcache_total_blocks",      (char*) &query_cache.total_blocks,
   SHOW_LONG_CONST},
unknown's avatar
unknown committed
5412
#endif /*HAVE_QUERY_CACHE*/
5413
  {"Questions",                (char*) 0,                       SHOW_QUESTION},
unknown's avatar
unknown committed
5414
  {"Rpl_status",               (char*) 0,                 SHOW_RPL_STATUS},
5415 5416 5417 5418 5419
  {"Select_full_join",         (char*) &select_full_join_count, SHOW_LONG},
  {"Select_full_range_join",   (char*) &select_full_range_join_count, SHOW_LONG},
  {"Select_range",             (char*) &select_range_count, 	SHOW_LONG},
  {"Select_range_check",       (char*) &select_range_check_count, SHOW_LONG},
  {"Select_scan",	       (char*) &select_scan_count,	SHOW_LONG},
5420
  {"Slave_open_temp_tables",   (char*) &slave_open_temp_tables, SHOW_LONG},
5421
  {"Slave_running",            (char*) 0, SHOW_SLAVE_RUNNING},
5422 5423
  {"Slow_launch_threads",      (char*) &slow_launch_threads,    SHOW_LONG},
  {"Slow_queries",             (char*) &long_query_count,       SHOW_LONG},
5424
  {"Sort_merge_passes",	       (char*) &filesort_merge_passes,  SHOW_LONG},
5425 5426 5427
  {"Sort_range",	       (char*) &filesort_range_count,   SHOW_LONG},
  {"Sort_rows",		       (char*) &filesort_rows,	        SHOW_LONG},
  {"Sort_scan",		       (char*) &filesort_scan_count,    SHOW_LONG},
unknown's avatar
unknown committed
5428
#ifdef HAVE_OPENSSL
5429
  {"Ssl_accept_renegotiates",  (char*) 0, 	SHOW_SSL_CTX_SESS_ACCEPT_RENEGOTIATE},
5430
  {"Ssl_accepts",              (char*) 0,  	SHOW_SSL_CTX_SESS_ACCEPT},
5431 5432 5433 5434 5435 5436 5437 5438
  {"Ssl_callback_cache_hits",  (char*) 0,	SHOW_SSL_CTX_SESS_CB_HITS},
  {"Ssl_cipher",               (char*) 0,  	SHOW_SSL_GET_CIPHER},
  {"Ssl_cipher_list",          (char*) 0,  	SHOW_SSL_GET_CIPHER_LIST},
  {"Ssl_client_connects",      (char*) 0,	SHOW_SSL_CTX_SESS_CONNECT},
  {"Ssl_connect_renegotiates", (char*) 0, 	SHOW_SSL_CTX_SESS_CONNECT_RENEGOTIATE},
  {"Ssl_ctx_verify_depth",     (char*) 0,	SHOW_SSL_CTX_GET_VERIFY_DEPTH},
  {"Ssl_ctx_verify_mode",      (char*) 0,	SHOW_SSL_CTX_GET_VERIFY_MODE},
  {"Ssl_default_timeout",      (char*) 0,  	SHOW_SSL_GET_DEFAULT_TIMEOUT},
5439 5440 5441 5442
  {"Ssl_finished_accepts",     (char*) 0,  	SHOW_SSL_CTX_SESS_ACCEPT_GOOD},
  {"Ssl_finished_connects",    (char*) 0,  	SHOW_SSL_CTX_SESS_CONNECT_GOOD},
  {"Ssl_session_cache_hits",   (char*) 0,	SHOW_SSL_CTX_SESS_HITS},
  {"Ssl_session_cache_misses", (char*) 0,	SHOW_SSL_CTX_SESS_MISSES},
5443
  {"Ssl_session_cache_mode",   (char*) 0,	SHOW_SSL_CTX_GET_SESSION_CACHE_MODE},
5444 5445
  {"Ssl_session_cache_overflows", (char*) 0,	SHOW_SSL_CTX_SESS_CACHE_FULL},
  {"Ssl_session_cache_size",   (char*) 0,	SHOW_SSL_CTX_SESS_GET_CACHE_SIZE},
5446
  {"Ssl_session_cache_timeouts", (char*) 0,	SHOW_SSL_CTX_SESS_TIMEOUTS},
5447
  {"Ssl_sessions_reused",      (char*) 0,	SHOW_SSL_SESSION_REUSED},
5448
  {"Ssl_used_session_cache_entries",(char*) 0,	SHOW_SSL_CTX_SESS_NUMBER},
5449
  {"Ssl_verify_depth",         (char*) 0,	SHOW_SSL_GET_VERIFY_DEPTH},
5450
  {"Ssl_verify_mode",          (char*) 0,	SHOW_SSL_GET_VERIFY_MODE},
5451
  {"Ssl_version",   	       (char*) 0,  	SHOW_SSL_GET_VERSION},
unknown's avatar
unknown committed
5452
#endif /* HAVE_OPENSSL */
unknown's avatar
unknown committed
5453 5454
  {"Table_locks_immediate",    (char*) &locks_immediate,        SHOW_LONG},
  {"Table_locks_waited",       (char*) &locks_waited,           SHOW_LONG},
5455 5456
  {"Threads_cached",           (char*) &cached_thread_count,    SHOW_LONG_CONST},
  {"Threads_connected",        (char*) &thread_count,           SHOW_INT_CONST},
5457
  {"Threads_created",	       (char*) &thread_created,		SHOW_LONG_CONST},
5458 5459 5460
  {"Threads_running",          (char*) &thread_running,         SHOW_INT_CONST},
  {"Uptime",                   (char*) 0,                       SHOW_STARTTIME},
  {NullS, NullS, SHOW_LONG}
unknown's avatar
unknown committed
5461 5462 5463 5464
};

static void print_version(void)
{
5465
  set_server_version();
5466 5467
  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
5468 5469
}

unknown's avatar
unknown committed
5470 5471 5472
static void use_help(void)
{
  print_version();
5473
  printf("Use '--help' or '--no-defaults --help' for a list of available options\n");
unknown's avatar
unknown committed
5474
}
unknown's avatar
unknown committed
5475

unknown's avatar
unknown committed
5476 5477
static void usage(void)
{
5478
  if (!(default_charset_info= get_charset_by_csname(default_character_set_name,
unknown's avatar
unknown committed
5479 5480 5481 5482 5483
					           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
5484
  print_version();
unknown's avatar
unknown committed
5485 5486 5487
  puts("\
Copyright (C) 2000 MySQL AB, by Monty and others\n\
This software comes with ABSOLUTELY NO WARRANTY. This is free software,\n\
5488 5489
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
5490 5491

  printf("Usage: %s [OPTIONS]\n", my_progname);
5492 5493 5494 5495
  if (!opt_verbose)
    puts("\nFor more help options (several pages), use mysqld --verbose --help\n");
  else
  {
unknown's avatar
unknown committed
5496 5497
#ifdef __WIN__
  puts("NT and Win32 specific options:\n\
5498 5499
  --install                     Install the default service (NT)\n\
  --install-manual              Install the default service started manually (NT)\n\
unknown's avatar
unknown committed
5500 5501
  --install service_name        Install an optional service (NT)\n\
  --install-manual service_name Install an optional service started manually (NT)\n\
5502
  --remove                      Remove the default service from the service list (NT)\n\
unknown's avatar
unknown committed
5503 5504 5505
  --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
5506
");
5507
  puts("");
unknown's avatar
unknown committed
5508
#endif
5509
  print_defaults(MYSQL_CONFIG_NAME,load_default_groups);
unknown's avatar
unknown committed
5510 5511 5512
  puts("");
  fix_paths();
  set_ports();
5513 5514 5515 5516

  my_print_help(my_long_options);
  my_print_variables(my_long_options);

unknown's avatar
unknown committed
5517
  puts("\n\
unknown's avatar
unknown committed
5518
To see what values a running MySQL server is using, type\n\
5519 5520
'mysqladmin variables' instead of 'mysqld --verbose --help'.\n");
  }
unknown's avatar
unknown committed
5521 5522 5523
}


unknown's avatar
unknown committed
5524 5525 5526 5527 5528 5529 5530 5531 5532 5533 5534
/*
  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
5535

unknown's avatar
unknown committed
5536 5537 5538
    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
5539

unknown's avatar
unknown committed
5540 5541 5542 5543 5544 5545 5546 5547
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;
  opt_log= opt_update_log= opt_bin_log= opt_slow_log= 0;
  opt_disable_networking= opt_skip_show_db=0;
  opt_logname= opt_update_logname= opt_binlog_index_name= opt_slow_logname=0;
5548 5549
  opt_secure_auth= 0;
  opt_bootstrap= opt_myisam_log= 0;
unknown's avatar
unknown committed
5550 5551 5552 5553 5554 5555 5556 5557 5558 5559 5560 5561 5562 5563 5564 5565 5566 5567 5568 5569 5570 5571
  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;
  com_other= 0;
  cached_thread_count= 0;
  bytes_sent= bytes_received= 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;
  long_query_count= aborted_threads= aborted_connects= 0;
  delayed_insert_threads= delayed_insert_writes= delayed_rows_in_use= 0;
  delayed_insert_errors= thread_created= 0;
  filesort_rows= filesort_range_count= filesort_scan_count= 0;
  filesort_merge_passes= select_range_check_count= select_range_count= 0;
  select_scan_count= select_full_range_join_count= select_full_join_count= 0;
  specialflag= opened_tables= created_tmp_tables= created_tmp_disk_tables= 0;
5572
  binlog_cache_use=  binlog_cache_disk_use= 0;
unknown's avatar
unknown committed
5573 5574 5575
  max_used_connections= slow_launch_threads = 0;
  mysqld_user= mysqld_chroot= opt_init_file= opt_bin_logname = 0;
  errmesg= 0;
5576
  mysqld_unix_port= opt_mysql_tmpdir= my_bind_addr_str= NullS;
unknown's avatar
unknown committed
5577 5578 5579
  bzero((gptr) &mysql_tmpdir_list, sizeof(mysql_tmpdir_list));
  bzero((gptr) &com_stat, sizeof(com_stat));

5580 5581 5582 5583 5584 5585
  /* 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;

5586 5587
  opt_date_time_formats[0]= opt_date_time_formats[1]= opt_date_time_formats[2]= 0;

unknown's avatar
unknown committed
5588 5589 5590 5591 5592 5593 5594 5595 5596 5597 5598 5599 5600 5601
  /* 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;
  thd_startup_options= (OPTION_UPDATE_LOG | OPTION_AUTO_IS_NULL |
			OPTION_BIN_LOG | OPTION_QUOTE_SHOW_CREATE);
  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
5602
  query_id= thread_id= 1L;
unknown's avatar
unknown committed
5603 5604 5605 5606 5607
  strmov(server_version, MYSQL_SERVER_VERSION);
  myisam_recover_options_str= sql_mode_str= "OFF";
  my_bind_addr = htonl(INADDR_ANY);
  threads.empty();
  thread_cache.empty();
5608
  key_caches.empty();
unknown's avatar
unknown committed
5609
  if (!(dflt_key_cache= get_or_create_key_cache(default_key_cache_base.str,
5610
					       default_key_cache_base.length)))
5611
    exit(1);
unknown's avatar
unknown committed
5612
  multi_keycache_init(); /* set key_cache_hash.default_value = dflt_key_cache */
unknown's avatar
unknown committed
5613 5614 5615 5616 5617 5618 5619 5620 5621 5622 5623 5624 5625 5626 5627 5628 5629 5630 5631

  /* Initialize structures that is used when processing options */
  replicate_rewrite_db.empty();
  replicate_do_db.empty();
  replicate_ignore_db.empty();
  binlog_do_db.empty();
  binlog_ignore_db.empty();

  /* 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
5632 5633 5634
    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
5635 5636 5637 5638 5639
  report_user= report_password = report_host= 0;	/* TO BE DELETED */
  opt_relay_logname= opt_relaylog_index_name= 0;

  /* Variables in libraries */
  charsets_dir= 0;
5640 5641
  default_character_set_name= (char*) MYSQL_DEFAULT_CHARSET_NAME;
  default_collation_name= (char*) MYSQL_DEFAULT_COLLATION_NAME;
5642
  sys_charset_system.value= (char*) system_charset_info->csname;
unknown's avatar
unknown committed
5643

5644

unknown's avatar
unknown committed
5645
  /* Set default values for some option variables */
unknown's avatar
unknown committed
5646 5647
  global_system_variables.table_type=   DB_TYPE_MYISAM;
  global_system_variables.tx_isolation= ISO_REPEATABLE_READ;
5648
  global_system_variables.select_limit= (ulonglong) HA_POS_ERROR;
unknown's avatar
unknown committed
5649
  max_system_variables.select_limit=    (ulonglong) HA_POS_ERROR;
5650
  global_system_variables.max_join_size= (ulonglong) HA_POS_ERROR;
unknown's avatar
unknown committed
5651
  max_system_variables.max_join_size=   (ulonglong) HA_POS_ERROR;
5652
  global_system_variables.old_passwords= 0;
unknown's avatar
unknown committed
5653

unknown's avatar
unknown committed
5654 5655 5656 5657 5658 5659 5660 5661 5662 5663 5664 5665 5666 5667 5668 5669 5670 5671 5672 5673 5674
  /* 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);
#ifdef HAVE_BERKELEY_DB
  have_berkeley_db= SHOW_OPTION_YES;
#else
  have_berkeley_db= SHOW_OPTION_NO;
#endif
#ifdef HAVE_INNOBASE_DB
  have_innodb=SHOW_OPTION_YES;
#else
  have_innodb=SHOW_OPTION_NO;
#endif
#ifdef HAVE_ISAM
  have_isam=SHOW_OPTION_YES;
#else
  have_isam=SHOW_OPTION_NO;
#endif
5675 5676 5677 5678 5679
#ifdef HAVE_EXAMPLE_DB
  have_example_db= SHOW_OPTION_YES;
#else
  have_example_db= SHOW_OPTION_NO;
#endif
5680 5681 5682 5683 5684
#ifdef HAVE_ARCHIVE_DB
  have_archive_db= SHOW_OPTION_YES;
#else
  have_archive_db= SHOW_OPTION_NO;
#endif
5685 5686 5687 5688 5689
#ifdef HAVE_CSV_DB
  have_csv_db= SHOW_OPTION_YES;
#else
  have_csv_db= SHOW_OPTION_NO;
#endif
unknown's avatar
unknown committed
5690
#ifdef HAVE_NDBCLUSTER_DB
unknown's avatar
unknown committed
5691
  have_ndbcluster=SHOW_OPTION_DISABLED;
unknown's avatar
unknown committed
5692 5693 5694
#else
  have_ndbcluster=SHOW_OPTION_NO;
#endif
unknown's avatar
unknown committed
5695 5696 5697 5698 5699 5700 5701 5702 5703 5704 5705 5706 5707 5708 5709 5710 5711 5712 5713 5714
#ifdef USE_RAID
  have_raid=SHOW_OPTION_YES;
#else
  have_raid=SHOW_OPTION_NO;
#endif
#ifdef HAVE_OPENSSL
  have_openssl=SHOW_OPTION_YES;
#else
  have_openssl=SHOW_OPTION_NO;
#endif
#ifdef HAVE_BROKEN_REALPATH
  have_symlink=SHOW_OPTION_NO;
#else
  have_symlink=SHOW_OPTION_YES;
#endif
#ifdef HAVE_QUERY_CACHE
  have_query_cache=SHOW_OPTION_YES;
#else
  have_query_cache=SHOW_OPTION_NO;
#endif
5715 5716 5717 5718 5719 5720 5721 5722 5723 5724
#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
5725 5726 5727 5728 5729 5730
#ifdef HAVE_CRYPT
  have_crypt=SHOW_OPTION_YES;
#else
  have_crypt=SHOW_OPTION_NO;
#endif
#ifdef HAVE_COMPRESS
5731
  have_compress= SHOW_OPTION_YES;
unknown's avatar
unknown committed
5732
#else
5733
  have_compress= SHOW_OPTION_NO;
unknown's avatar
unknown committed
5734 5735 5736 5737 5738 5739 5740 5741 5742 5743 5744 5745 5746 5747 5748
#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
5749 5750
#if defined(__WIN__) || defined(__NETWARE__)
  /* Allow Win32 and NetWare users to move MySQL anywhere */
unknown's avatar
unknown committed
5751 5752 5753 5754 5755 5756 5757 5758
  {
    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
5759
  if (!(tmpenv = getenv("MY_BASEDIR_VERSION")))
unknown's avatar
unknown committed
5760
    tmpenv = DEFAULT_MYSQL_HOME;
unknown's avatar
unknown committed
5761
  (void) strmake(mysql_home, tmpenv, sizeof(mysql_home)-1);
unknown's avatar
unknown committed
5762 5763 5764 5765
#endif
}


5766
extern "C" my_bool
5767 5768
get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
	       char *argument)
unknown's avatar
unknown committed
5769
{
5770 5771
  switch(optid) {
  case '#':
5772
#ifndef DBUG_OFF
5773 5774 5775 5776 5777
    DBUG_PUSH(argument ? argument : default_dbug_option);
#endif
    opt_endinfo=1;				/* unireg: memory allocation */
    break;
  case 'a':
5778
    global_system_variables.sql_mode= fix_sql_mode(MODE_ANSI);
unknown's avatar
unknown committed
5779
    global_system_variables.tx_isolation= ISO_SERIALIZABLE;
5780 5781 5782 5783
    break;
  case 'b':
    strmake(mysql_home,argument,sizeof(mysql_home)-1);
    break;
5784
  case 'C':
unknown's avatar
unknown committed
5785
    default_collation_name= 0;
5786
    break;
5787 5788 5789 5790 5791
  case 'l':
    opt_log=1;
    break;
  case 'h':
    strmake(mysql_real_data_home,argument, sizeof(mysql_real_data_home)-1);
5792 5793
    /* Correct pointer set by my_getopt (for embedded library) */
    mysql_data_home= mysql_real_data_home;
5794
    break;
5795
  case 'u':
5796
    if (!mysqld_user || !strcmp(mysqld_user, argument))
unknown's avatar
unknown committed
5797
      mysqld_user= argument;
5798
    else
5799
      sql_print_warning("Ignoring user change to '%s' because the user was set to '%s' earlier on the command line\n", argument, mysqld_user);
5800
    break;
5801 5802 5803
  case 'L':
    strmake(language, argument, sizeof(language)-1);
    break;
unknown's avatar
SCRUM  
unknown committed
5804
#ifdef HAVE_REPLICATION
5805 5806 5807
  case OPT_SLAVE_SKIP_ERRORS:
    init_slave_skip_errors(argument);
    break;
5808
#endif
5809
  case OPT_SAFEMALLOC_MEM_LIMIT:
5810
#if !defined(DBUG_OFF) && defined(SAFEMALLOC)
5811
    sf_malloc_mem_limit = atoi(argument);
5812
#endif
5813
    break;
5814 5815 5816
#ifdef EMBEDDED_LIBRARY
  case OPT_MAX_ALLOWED_PACKET:
    max_allowed_packet= atoi(argument);
5817
    global_system_variables.max_allowed_packet= max_allowed_packet;
5818 5819 5820
    break;
  case OPT_NET_BUFFER_LENGTH:
    net_buffer_length=  atoi(argument);
5821
    global_system_variables.net_buffer_length= net_buffer_length;
5822 5823
    break;
#endif
5824
#include <sslopt-case.h>
5825 5826 5827
  case 'V':
    print_version();
    exit(0);
5828 5829 5830 5831 5832 5833 5834 5835
  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;
5836 5837
  case 'T':
    test_flags= argument ? (uint) atoi(argument) : 0;
5838
    test_flags&= ~TEST_NO_THREADS;
5839 5840 5841 5842 5843 5844 5845 5846 5847 5848 5849 5850 5851 5852
    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:
    opt_bin_log=1;
    break;
5853 5854 5855
  case (int) OPT_ERROR_LOG_FILE:
    opt_error_log= 1;
    break;
unknown's avatar
SCRUM  
unknown committed
5856
#ifdef HAVE_REPLICATION
5857
  case (int) OPT_INIT_RPL_ROLE:
5858 5859 5860
  {
    int role;
    if ((role=find_type(argument, &rpl_role_typelib, 2)) <= 0)
5861
    {
5862 5863
      fprintf(stderr, "Unknown replication role: %s\n", argument);
      exit(1);
5864
    }
5865 5866 5867
    rpl_status = (role == 1) ?  RPL_AUTH_MASTER : RPL_IDLE_SLAVE;
    break;
  }
5868
  case (int)OPT_REPLICATE_IGNORE_DB:
5869 5870 5871 5872 5873 5874 5875 5876 5877 5878 5879 5880 5881 5882
  {
    i_string *db = new i_string(argument);
    replicate_ignore_db.push_back(db);
    break;
  }
  case (int)OPT_REPLICATE_DO_DB:
  {
    i_string *db = new i_string(argument);
    replicate_do_db.push_back(db);
    break;
  }
  case (int)OPT_REPLICATE_REWRITE_DB:
  {
    char* key = argument,*p, *val;
5883

5884
    if (!(p= strstr(argument, "->")))
5885
    {
5886 5887 5888
      fprintf(stderr,
	      "Bad syntax in replicate-rewrite-db - missing '->'!\n");
      exit(1);
5889
    }
5890
    val= p--;
unknown's avatar
unknown committed
5891
    while (my_isspace(mysqld_charset, *p) && p > argument)
5892 5893
      *p-- = 0;
    if (p == argument)
5894
    {
5895 5896 5897
      fprintf(stderr,
	      "Bad syntax in replicate-rewrite-db - empty FROM db!\n");
      exit(1);
5898
    }
5899 5900
    *val= 0;
    val+= 2;
unknown's avatar
unknown committed
5901
    while (*val && my_isspace(mysqld_charset, *val))
5902 5903
      *val++;
    if (!*val)
5904
    {
5905 5906 5907
      fprintf(stderr,
	      "Bad syntax in replicate-rewrite-db - empty TO db!\n");
      exit(1);
5908 5909
    }

5910 5911 5912 5913 5914
    i_string_pair *db_pair = new i_string_pair(key, val);
    replicate_rewrite_db.push_back(db_pair);
    break;
  }

5915
  case (int)OPT_BINLOG_IGNORE_DB:
5916 5917 5918 5919 5920
  {
    i_string *db = new i_string(argument);
    binlog_ignore_db.push_back(db);
    break;
  }
5921
  case (int)OPT_BINLOG_DO_DB:
5922 5923 5924 5925 5926
  {
    i_string *db = new i_string(argument);
    binlog_do_db.push_back(db);
    break;
  }
5927
  case (int)OPT_REPLICATE_DO_TABLE:
5928 5929 5930 5931
  {
    if (!do_table_inited)
      init_table_rule_hash(&replicate_do_table, &do_table_inited);
    if (add_table_rule(&replicate_do_table, argument))
5932
    {
5933 5934
      fprintf(stderr, "Could not add do table rule '%s'!\n", argument);
      exit(1);
5935
    }
5936 5937 5938
    table_rules_on = 1;
    break;
  }
5939
  case (int)OPT_REPLICATE_WILD_DO_TABLE:
5940 5941 5942 5943 5944
  {
    if (!wild_do_table_inited)
      init_table_rule_array(&replicate_wild_do_table,
			    &wild_do_table_inited);
    if (add_wild_table_rule(&replicate_wild_do_table, argument))
5945
    {
5946 5947
      fprintf(stderr, "Could not add do table rule '%s'!\n", argument);
      exit(1);
5948
    }
5949 5950 5951
    table_rules_on = 1;
    break;
  }
5952
  case (int)OPT_REPLICATE_WILD_IGNORE_TABLE:
5953 5954 5955 5956 5957
  {
    if (!wild_ignore_table_inited)
      init_table_rule_array(&replicate_wild_ignore_table,
			    &wild_ignore_table_inited);
    if (add_wild_table_rule(&replicate_wild_ignore_table, argument))
5958
    {
5959 5960
      fprintf(stderr, "Could not add ignore table rule '%s'!\n", argument);
      exit(1);
5961
    }
5962 5963 5964
    table_rules_on = 1;
    break;
  }
5965
  case (int)OPT_REPLICATE_IGNORE_TABLE:
5966 5967 5968 5969
  {
    if (!ignore_table_inited)
      init_table_rule_hash(&replicate_ignore_table, &ignore_table_inited);
    if (add_table_rule(&replicate_ignore_table, argument))
5970
    {
5971 5972
      fprintf(stderr, "Could not add ignore table rule '%s'!\n", argument);
      exit(1);
5973
    }
5974 5975 5976
    table_rules_on = 1;
    break;
  }
unknown's avatar
SCRUM  
unknown committed
5977
#endif /* HAVE_REPLICATION */
5978 5979 5980
  case (int) OPT_SLOW_QUERY_LOG:
    opt_slow_log=1;
    break;
5981 5982
  case (int) OPT_SKIP_NEW:
    opt_specialflag|= SPECIAL_NO_NEW_FUNC;
5983
    delay_key_write_options= (uint) DELAY_KEY_WRITE_NONE;
5984 5985 5986
    myisam_concurrent_insert=0;
    myisam_recover_options= HA_RECOVER_NONE;
    my_use_symdir=0;
5987
    ha_open_options&= ~(HA_OPEN_ABORT_IF_CRASHED | HA_OPEN_DELAY_KEY_WRITE);
unknown's avatar
unknown committed
5988
#ifdef HAVE_QUERY_CACHE
5989 5990 5991 5992 5993
    query_cache_size=0;
#endif
    break;
  case (int) OPT_SAFE:
    opt_specialflag|= SPECIAL_SAFE_MODE;
5994
    delay_key_write_options= (uint) DELAY_KEY_WRITE_NONE;
5995 5996
    myisam_recover_options= HA_RECOVER_DEFAULT;
    ha_open_options&= ~(HA_OPEN_DELAY_KEY_WRITE);
5997 5998 5999 6000 6001
    break;
  case (int) OPT_SKIP_PRIOR:
    opt_specialflag|= SPECIAL_NO_PRIOR;
    break;
  case (int) OPT_SKIP_LOCK:
6002
    opt_external_locking=0;
6003 6004 6005 6006 6007 6008 6009 6010
    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
6011 6012 6013
#if defined(__NETWARE__)
    sql_perror("Can't start server: skip-networking option is currently not supported on NetWare");
    exit(1);
6014
#endif
6015
    opt_disable_networking=1;
6016
    mysqld_port=0;
6017 6018 6019 6020 6021
    break;
  case (int) OPT_SKIP_SHOW_DB:
    opt_skip_show_db=1;
    opt_specialflag|=SPECIAL_SKIP_SHOW_DB;
    break;
6022
#ifdef ONE_THREAD
6023 6024
  case (int) OPT_ONE_THREAD:
    test_flags |= TEST_NO_THREADS;
6025
#endif
6026 6027 6028 6029 6030 6031 6032 6033 6034 6035 6036
    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
6037
    if ((my_bind_addr= (ulong) inet_addr(argument)) == INADDR_NONE)
6038 6039
    {
      struct hostent *ent;
unknown's avatar
unknown committed
6040
      if (argument[0])
6041
	ent=gethostbyname(argument);
unknown's avatar
unknown committed
6042 6043
      else
      {
6044 6045
	char myhostname[255];
	if (gethostname(myhostname,sizeof(myhostname)) < 0)
unknown's avatar
unknown committed
6046
	{
6047
	  sql_perror("Can't start server: cannot get my own hostname!");
unknown's avatar
unknown committed
6048 6049
	  exit(1);
	}
6050
	ent=gethostbyname(myhostname);
unknown's avatar
unknown committed
6051
      }
6052 6053 6054 6055 6056 6057 6058 6059 6060 6061 6062
      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
6063
#ifdef __WIN__
6064 6065
  case (int) OPT_STANDALONE:		/* Dummy option for NT */
    break;
unknown's avatar
unknown committed
6066
#endif
6067 6068 6069 6070
  case OPT_CONSOLE:
    if (opt_console)
      opt_error_log= 0;			// Force logs to stdout
    break;
6071
  case (int) OPT_FLUSH:
6072
#ifdef HAVE_ISAM
6073 6074 6075 6076 6077 6078 6079
    nisam_flush=1;
#endif
    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
6080
    global_system_variables.low_priority_updates=1;
6081 6082 6083 6084
    break;
  case OPT_BOOTSTRAP:
    opt_noacl=opt_bootstrap=1;
    break;
unknown's avatar
unknown committed
6085
  case OPT_STORAGE_ENGINE:
6086
  {
unknown's avatar
unknown committed
6087 6088
    if ((enum db_type)((global_system_variables.table_type=
	  ha_resolve_by_name(argument, strlen(argument)))) == DB_TYPE_UNKNOWN)
unknown's avatar
unknown committed
6089
    {
6090 6091
      fprintf(stderr,"Unknown table type: %s\n",argument);
      exit(1);
unknown's avatar
unknown committed
6092
    }
6093 6094
    break;
  }
6095 6096 6097
  case OPT_SERVER_ID:
    server_id_supplied = 1;
    break;
6098 6099 6100 6101
  case OPT_DELAY_KEY_WRITE_ALL:
    if (argument != disabled_my_option)
      argument= (char*) "ALL";
    /* Fall through */
6102
  case OPT_DELAY_KEY_WRITE:
6103 6104 6105 6106 6107 6108 6109 6110 6111 6112 6113 6114 6115 6116
    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;
    }
6117 6118 6119 6120 6121 6122
    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:
6123 6124 6125
  {
    int type;
    if ((type=find_type(argument, &tx_isolation_typelib, 2)) <= 0)
unknown's avatar
unknown committed
6126
    {
6127 6128
      fprintf(stderr,"Unknown transaction isolation type: %s\n",argument);
      exit(1);
unknown's avatar
unknown committed
6129
    }
unknown's avatar
unknown committed
6130
    global_system_variables.tx_isolation= (type-1);
6131 6132
    break;
  }
unknown's avatar
unknown committed
6133
#ifdef HAVE_BERKELEY_DB
6134
  case OPT_BDB_NOSYNC:
6135 6136 6137 6138 6139 6140 6141 6142
    /* Deprecated option */
    opt_sync_bdb_logs= 0;
    /* Fall through */
  case OPT_BDB_SYNC:
    if (!opt_sync_bdb_logs)
      berkeley_env_flags|= DB_TXN_NOSYNC;
    else
      berkeley_env_flags&= ~DB_TXN_NOSYNC;
6143 6144 6145 6146 6147
    break;
  case OPT_BDB_NO_RECOVER:
    berkeley_init_flags&= ~(DB_RECOVER);
    break;
  case OPT_BDB_LOCK:
6148 6149 6150 6151 6152
  {
    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
6153
    {
6154
      int err;
6155 6156
      char *end;
      uint length= strlen(argument);
unknown's avatar
unknown committed
6157 6158
      long value= my_strntol(&my_charset_latin1, argument, length, 10, &end, &err);
      if (test_if_int(argument,(uint) length, end, &my_charset_latin1))
6159
	berkeley_lock_scan_time= value;
unknown's avatar
unknown committed
6160 6161
      else
      {
6162 6163
	fprintf(stderr,"Unknown lock type: %s\n",argument);
	exit(1);
unknown's avatar
unknown committed
6164 6165
      }
    }
6166 6167
    break;
  }
6168 6169
  case OPT_BDB_SHARED:
    berkeley_init_flags&= ~(DB_PRIVATE);
unknown's avatar
unknown committed
6170
    berkeley_shared_data= 1;
6171
    break;
6172
#endif /* HAVE_BERKELEY_DB */
6173
  case OPT_BDB:
6174
#ifdef HAVE_BERKELEY_DB
6175
    if (opt_bdb)
unknown's avatar
unknown committed
6176
      have_berkeley_db= SHOW_OPTION_YES;
6177
    else
unknown's avatar
unknown committed
6178
      have_berkeley_db= SHOW_OPTION_DISABLED;
6179 6180 6181 6182 6183
#endif
    break;
  case OPT_ISAM:
#ifdef HAVE_ISAM
    if (opt_isam)
6184
      have_isam= SHOW_OPTION_YES;
6185
    else
6186
      have_isam= SHOW_OPTION_DISABLED;
unknown's avatar
unknown committed
6187 6188 6189 6190 6191
#endif
    break;
  case OPT_NDBCLUSTER:
#ifdef HAVE_NDBCLUSTER_DB
    if (opt_ndbcluster)
unknown's avatar
unknown committed
6192
      have_ndbcluster= SHOW_OPTION_YES;
unknown's avatar
unknown committed
6193
    else
unknown's avatar
unknown committed
6194
      have_ndbcluster= SHOW_OPTION_DISABLED;
6195 6196
#endif
    break;
6197
  case OPT_INNODB:
6198
#ifdef HAVE_INNOBASE_DB
6199
    if (opt_innodb)
unknown's avatar
unknown committed
6200
      have_innodb= SHOW_OPTION_YES;
6201
    else
unknown's avatar
unknown committed
6202
      have_innodb= SHOW_OPTION_DISABLED;
unknown's avatar
unknown committed
6203
#endif
6204 6205
    break;
  case OPT_INNODB_DATA_FILE_PATH:
unknown's avatar
unknown committed
6206
#ifdef HAVE_INNOBASE_DB
unknown's avatar
unknown committed
6207
    innobase_data_file_path= argument;
6208
#endif
6209
    break;
6210
#ifdef HAVE_INNOBASE_DB
6211 6212 6213 6214 6215 6216
  case OPT_INNODB_LOG_ARCHIVE:
    innobase_log_archive= argument ? test(atoi(argument)) : 1;
    break;
  case OPT_INNODB_FAST_SHUTDOWN:
    innobase_fast_shutdown= argument ? test(atoi(argument)) : 1;
    break;
6217
#endif /* HAVE_INNOBASE_DB */
6218
  case OPT_MYISAM_RECOVER:
6219 6220
  {
    if (!argument || !argument[0])
6221
    {
6222 6223
      myisam_recover_options=    HA_RECOVER_DEFAULT;
      myisam_recover_options_str= myisam_recover_typelib.type_names[0];
6224
    }
6225
    else
6226
    {
6227 6228 6229
      myisam_recover_options_str=argument;
      if ((myisam_recover_options=
	   find_bit_type(argument, &myisam_recover_typelib)) == ~(ulong) 0)
6230
      {
6231
	fprintf(stderr, "Unknown option to myisam-recover: %s\n",argument);
6232 6233 6234
	exit(1);
      }
    }
6235 6236 6237 6238 6239
    ha_open_options|=HA_OPEN_ABORT_IF_CRASHED;
    break;
  }
  case OPT_SQL_MODE:
  {
6240 6241 6242
    sql_mode_str= argument;
    if ((global_system_variables.sql_mode=
         find_bit_type(argument, &sql_mode_typelib)) == ~(ulong) 0)
6243 6244 6245 6246
    {
      fprintf(stderr, "Unknown option to sql-mode: %s\n", argument);
      exit(1);
    }
6247 6248
    global_system_variables.sql_mode= fix_sql_mode(global_system_variables.
						   sql_mode);
unknown's avatar
unknown committed
6249
    break;
6250
  }
unknown's avatar
unknown committed
6251
  case OPT_FT_BOOLEAN_SYNTAX:
6252
    if (ft_boolean_check_syntax_string((byte*) argument))
unknown's avatar
unknown committed
6253 6254 6255 6256
    {
      fprintf(stderr, "Invalid ft-boolean-syntax string: %s\n", argument);
      exit(1);
    }
6257
    strmake(ft_boolean_syntax, argument, sizeof(ft_boolean_syntax)-1);
6258 6259
    break;
  case OPT_SKIP_SAFEMALLOC:
6260
#ifdef SAFEMALLOC
6261
    sf_malloc_quick=1;
6262
#endif
6263
    break;
unknown's avatar
unknown committed
6264 6265
  case OPT_LOWER_CASE_TABLE_NAMES:
    lower_case_table_names= argument ? atoi(argument) : 1;
6266
    lower_case_table_names_used= 1;
unknown's avatar
unknown committed
6267
    break;
unknown's avatar
unknown committed
6268
  }
6269 6270 6271
  return 0;
}
	/* Initiates DEBUG - but no debugging here ! */
6272 6273

extern "C" gptr *
6274
mysql_getopt_value(const char *keyname, uint key_length,
6275 6276
		   const struct my_option *option)
{
6277 6278
  switch (option->id) {
  case OPT_KEY_BUFFER_SIZE:
unknown's avatar
unknown committed
6279
  case OPT_KEY_CACHE_BLOCK_SIZE:
6280 6281
  case OPT_KEY_CACHE_DIVISION_LIMIT:
  case OPT_KEY_CACHE_AGE_THRESHOLD:
6282
  {
unknown's avatar
unknown committed
6283
    KEY_CACHE *key_cache;
6284 6285
    if (!(key_cache= get_or_create_key_cache(keyname, key_length)))
      exit(1);
6286 6287
    switch (option->id) {
    case OPT_KEY_BUFFER_SIZE:
unknown's avatar
unknown committed
6288
      return (gptr*) &key_cache->param_buff_size;
6289
    case OPT_KEY_CACHE_BLOCK_SIZE:
unknown's avatar
unknown committed
6290
      return (gptr*) &key_cache->param_block_size;
6291
    case OPT_KEY_CACHE_DIVISION_LIMIT:
unknown's avatar
unknown committed
6292
      return (gptr*) &key_cache->param_division_limit;
6293
    case OPT_KEY_CACHE_AGE_THRESHOLD:
unknown's avatar
unknown committed
6294
      return (gptr*) &key_cache->param_age_threshold;
6295
    }
6296 6297
  }
  }
6298
 return option->value;
6299 6300
}

unknown's avatar
unknown committed
6301 6302

void option_error_reporter(enum loglevel level, const char *format, ...)
unknown's avatar
unknown committed
6303
{
6304
  va_list args;
unknown's avatar
unknown committed
6305 6306 6307
  va_start(args, format);
  vprint_msg_to_log(level, format, args);
  va_end(args);
unknown's avatar
unknown committed
6308
}
6309

unknown's avatar
unknown committed
6310

6311 6312 6313 6314
static void get_options(int argc,char **argv)
{
  int ho_error;

6315
  my_getopt_register_get_addr(mysql_getopt_value);
6316
  strmake(def_ft_boolean_syntax, ft_boolean_syntax,
unknown's avatar
unknown committed
6317
	  sizeof(ft_boolean_syntax)-1);
6318
  my_getopt_error_reporter= option_error_reporter;
unknown's avatar
unknown committed
6319 6320
  if ((ho_error= handle_options(&argc, &argv, my_long_options,
                                get_one_option)))
6321
    exit(ho_error);
6322 6323 6324 6325 6326 6327 6328 6329 6330 6331 6332 6333 6334 6335 6336 6337 6338 6339

#ifndef HAVE_NDBCLUSTER_DB
  if (opt_ndbcluster)
    sql_print_warning("this binary does not contain NDBCLUSTER storage engine");
#endif
#ifndef HAVE_INNOBASE_DB
  if (opt_innodb)
    sql_print_warning("this binary does not contain INNODB storage engine");
#endif
#ifndef HAVE_ISAM
  if (opt_isam)
    sql_print_warning("this binary does not contain ISAM storage engine");
#endif
#ifndef HAVE_BERKELEY_DB
  if (opt_bdb)
    sql_print_warning("this binary does not contain BDB storage engine");
#endif

6340 6341
  if (argc > 0)
  {
6342
    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
6343 6344
    /* FIXME add EXIT_TOO_MANY_ARGUMENTS to "mysys_err.h" and return that code? */
    exit(1);
6345
  }
6346

6347
  if (opt_help)
6348 6349 6350 6351
  {
    usage();
    exit(0);
  }
unknown's avatar
unknown committed
6352
#if defined(HAVE_BROKEN_REALPATH)
6353 6354 6355 6356 6357 6358 6359 6360 6361 6362
  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
6363 6364 6365 6366 6367 6368
  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;
  }
6369 6370 6371
  /* Set global MyISAM variables from delay_key_write_options */
  fix_delay_key_write((THD*) 0, OPT_GLOBAL);

6372
#ifndef EMBEDDED_LIBRARY
6373 6374
  if (mysqld_chroot)
    set_root(mysqld_chroot);
6375
#endif
unknown's avatar
unknown committed
6376
  fix_paths();
unknown's avatar
unknown committed
6377

unknown's avatar
unknown committed
6378 6379 6380 6381
  /*
    Set some global variables from the global_system_variables
    In most cases the global variables will not be used
  */
6382
  my_disable_locking= myisam_single_user= test(opt_external_locking == 0);
unknown's avatar
unknown committed
6383
  my_default_record_cache_size=global_system_variables.read_buff_size;
6384
  myisam_max_temp_length=
6385
    (my_off_t) global_system_variables.myisam_max_sort_file_size;
6386
  myisam_max_extra_temp_length=
6387
    (my_off_t) global_system_variables.myisam_max_extra_sort_file_size;
unknown's avatar
unknown committed
6388

unknown's avatar
unknown committed
6389
  /* Set global variables based on startup options */
unknown's avatar
unknown committed
6390
  myisam_block_size=(uint) 1 << my_bit_log2(opt_myisam_block_size);
6391 6392 6393
  table_alias_charset= (lower_case_table_names ?
			files_charset_info :
			&my_charset_bin);
unknown's avatar
unknown committed
6394

6395 6396 6397 6398
  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;
6399

6400
  if (init_global_datetime_format(MYSQL_TIMESTAMP_DATE,
6401
				  &global_system_variables.date_format) ||
6402
      init_global_datetime_format(MYSQL_TIMESTAMP_TIME,
6403
				  &global_system_variables.time_format) ||
6404
      init_global_datetime_format(MYSQL_TIMESTAMP_DATETIME,
6405 6406
				  &global_system_variables.datetime_format))
    exit(1);
unknown's avatar
unknown committed
6407 6408 6409
}


6410 6411 6412 6413 6414 6415 6416 6417 6418 6419
/*
  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,
6420
                     MYSQL_SERVER_SUFFIX_STR, NullS);
6421 6422 6423 6424
#ifdef EMBEDDED_LIBRARY
  end= strmov(end, "-embedded");
#endif
#ifndef DBUG_OFF
6425
  if (!strstr(MYSQL_SERVER_SUFFIX_STR, "-debug"))
6426 6427 6428 6429 6430 6431 6432
    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
6433 6434 6435
static char *get_relative_path(const char *path)
{
  if (test_if_hard_path(path) &&
6436
      is_prefix(path,DEFAULT_MYSQL_HOME) &&
unknown's avatar
unknown committed
6437 6438
      strcmp(DEFAULT_MYSQL_HOME,FN_ROOTDIR))
  {
unknown's avatar
unknown committed
6439
    path+=(uint) strlen(DEFAULT_MYSQL_HOME);
unknown's avatar
unknown committed
6440 6441 6442 6443 6444 6445 6446
    while (*path == FN_LIBCHAR)
      path++;
  }
  return (char*) path;
}


6447 6448 6449 6450 6451 6452 6453 6454 6455 6456 6457 6458 6459 6460 6461 6462 6463 6464 6465 6466 6467 6468
/*
  Fix filename and replace extension where 'dir' is relative to
  mysql_real_data_home.
  Return 1 if len(path) > FN_REFLEN
*/

bool
fn_format_relative_to_data_home(my_string to, const char *name,
				const char *dir, const char *extension)
{
  char tmp_path[FN_REFLEN];
  if (!test_if_hard_path(dir))
  {
    strxnmov(tmp_path,sizeof(tmp_path)-1, mysql_real_data_home,
	     dir, NullS);
    dir=tmp_path;
  }
  return !fn_format(to, name, dir, extension,
		    MY_REPLACE_EXT | MY_UNPACK_FILENAME | MY_SAFE_PATH);
}


unknown's avatar
unknown committed
6469 6470
static void fix_paths(void)
{
6471
  char buff[FN_REFLEN],*pos;
6472
  convert_dirname(mysql_home,mysql_home,NullS);
6473
  /* Resolve symlinks to allow 'mysql_home' to be a relative symlink */
6474
  my_realpath(mysql_home,mysql_home,MYF(0));
6475 6476 6477 6478 6479 6480 6481
  /* Ensure that mysql_home ends in FN_LIBCHAR */
  pos=strend(mysql_home);
  if (pos[-1] != FN_LIBCHAR)
  {
    pos[0]= FN_LIBCHAR;
    pos[1]= 0;
  }
6482 6483
  convert_dirname(mysql_real_data_home,mysql_real_data_home,NullS);
  convert_dirname(language,language,NullS);
unknown's avatar
unknown committed
6484 6485 6486 6487
  (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
6488
  char *sharedir=get_relative_path(SHAREDIR);
unknown's avatar
unknown committed
6489
  if (test_if_hard_path(sharedir))
unknown's avatar
unknown committed
6490
    strmake(buff,sharedir,sizeof(buff)-1);		/* purecov: tested */
unknown's avatar
unknown committed
6491
  else
unknown's avatar
unknown committed
6492
    strxnmov(buff,sizeof(buff)-1,mysql_home,sharedir,NullS);
6493
  convert_dirname(buff,buff,NullS);
unknown's avatar
unknown committed
6494 6495 6496 6497 6498
  (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
6499 6500
    strxnmov(mysql_charsets_dir, sizeof(mysql_charsets_dir)-1, buff,
	     CHARSET_DIR, NullS);
unknown's avatar
unknown committed
6501
  }
unknown's avatar
unknown committed
6502 6503
  (void) my_load_path(mysql_charsets_dir, mysql_charsets_dir, buff);
  charsets_dir=mysql_charsets_dir;
unknown's avatar
unknown committed
6504

unknown's avatar
unknown committed
6505
  if (init_tmpdir(&mysql_tmpdir_list, opt_mysql_tmpdir))
unknown's avatar
unknown committed
6506
    exit(1);
unknown's avatar
SCRUM  
unknown committed
6507
#ifdef HAVE_REPLICATION
6508 6509
  if (!slave_load_tmpdir)
  {
unknown's avatar
unknown committed
6510 6511
    if (!(slave_load_tmpdir = (char*) my_strdup(mysql_tmpdir, MYF(MY_FAE))))
      exit(1);
6512
  }
6513
#endif /* HAVE_REPLICATION */
unknown's avatar
unknown committed
6514 6515 6516
}


6517 6518 6519 6520
/*
  Return a bitfield from a string of substrings separated by ','
  returns ~(ulong) 0 on error.
*/
6521 6522 6523 6524 6525 6526 6527 6528 6529 6530 6531 6532 6533 6534

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;
6535 6536 6537
  while (*pos == ' ') pos++;
  found_end= *pos == 0;
  while (!found_end)
6538 6539 6540 6541
  {
    if (!*(end=strcend(pos,',')))		/* Let end point at fieldend */
    {
      while (end > pos && end[-1] == ' ')
unknown's avatar
unknown committed
6542
	end--;					/* Skip end-space */
6543 6544 6545 6546 6547 6548 6549 6550
      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
6551 6552
	if (my_toupper(mysqld_charset,*i++) !=
            my_toupper(mysqld_charset,*j++))
6553
	  goto skip;
6554 6555 6556 6557 6558 6559 6560 6561 6562 6563 6564
      }
      found_int=bit;
      if (! *i)
      {
	found_count=1;
	break;
      }
      else if (j != pos)			// Half field found
      {
	found_count++;				// Could be one of two values
      }
6565
skip: ;
6566 6567 6568 6569 6570
    }
    if (found_count != 1)
      DBUG_RETURN(~(ulong) 0);				// No unique value
    found|=found_int;
    pos=end+1;
6571
  }
6572 6573 6574 6575 6576 6577

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


6578 6579 6580 6581 6582 6583 6584 6585 6586 6587 6588 6589 6590 6591 6592 6593 6594 6595 6596
/*
  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;
6597
  DBUG_ENTER("test_if_case_insensitive");
6598 6599 6600 6601 6602 6603 6604 6605

  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)
  {
6606
    sql_print_warning("Can't create test file %s", buff);
6607
    DBUG_RETURN(-1);
6608 6609 6610 6611 6612
  }
  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));
6613 6614
  DBUG_PRINT("exit", ("result: %d", result));
  DBUG_RETURN(result);
6615 6616 6617 6618 6619 6620 6621 6622 6623 6624 6625
}


/* 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
6626
    char buff[21], *end;
6627
    end= int10_to_str((long) getpid(), buff, 10);
unknown's avatar
unknown committed
6628 6629
    *end++= '\n';
    (void) my_write(file, (byte*) buff, (uint) (end-buff),MYF(MY_WME));
6630 6631 6632 6633 6634
    (void) my_close(file, MYF(0));
  }
}


unknown's avatar
unknown committed
6635
/*****************************************************************************
6636
  Instantiate templates
unknown's avatar
unknown committed
6637 6638 6639 6640 6641 6642 6643
*****************************************************************************/

#ifdef __GNUC__
/* Used templates */
template class I_List<THD>;
template class I_List_iterator<THD>;
template class I_List<i_string>;
6644
template class I_List<i_string_pair>;
6645
template class I_List<NAMED_LIST>;
unknown's avatar
unknown committed
6646
FIX_GCC_LINKING_PROBLEM
unknown's avatar
unknown committed
6647
#endif