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

unknown's avatar
unknown committed
3 4
   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
unknown's avatar
unknown committed
5
   the Free Software Foundation; version 2 of the License.
6

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

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

29
#include "../storage/myisam/ha_myisam.h"
30

31 32
#include "rpl_injector.h"

33 34 35
#ifdef HAVE_SYS_PRCTL_H
#include <sys/prctl.h>
#endif
36

37
#ifdef WITH_NDBCLUSTER_STORAGE_ENGINE
unknown's avatar
Merge  
unknown committed
38 39
#if defined(NOT_ENOUGH_TESTED) \
  && defined(NDB_SHM_TRANSPORTER) && MYSQL_VERSION_ID >= 50000
40 41 42 43
#define OPT_NDB_SHM_DEFAULT 1
#else
#define OPT_NDB_SHM_DEFAULT 0
#endif
44 45
#endif

unknown's avatar
unknown committed
46 47 48 49
#ifndef DEFAULT_SKIP_THREAD_PRIORITY
#define DEFAULT_SKIP_THREAD_PRIORITY 0
#endif

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

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

58 59 60 61 62 63
#ifdef HAVE_purify
#define IF_PURIFY(A,B) (A)
#else
#define IF_PURIFY(A,B) (B)
#endif

64 65 66 67 68 69
#if SIZEOF_CHARP == 4
#define MAX_MEM_TABLE_SIZE ~(ulong) 0
#else
#define MAX_MEM_TABLE_SIZE ~(ulonglong) 0
#endif

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

77 78 79
/* 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
80
#define HAVE_CLOSE_SERVER_SOCK 1
81
#endif
unknown's avatar
unknown committed
82

unknown's avatar
unknown committed
83 84 85 86
extern "C" {					// Because of SCO 3.2V4.2
#include <errno.h>
#include <sys/stat.h>
#ifndef __GNU_LIBRARY__
87
#define __GNU_LIBRARY__				// Skip warnings in getopt.h
unknown's avatar
unknown committed
88
#endif
89
#include <my_getopt.h>
unknown's avatar
unknown committed
90 91 92 93 94 95 96 97 98
#ifdef HAVE_SYSENT_H
#include <sysent.h>
#endif
#ifdef HAVE_PWD_H
#include <pwd.h>				// For getpwent
#endif
#ifdef HAVE_GRP_H
#include <grp.h>
#endif
unknown's avatar
Merge  
unknown committed
99
#include <my_net.h>
unknown's avatar
unknown committed
100

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

118
#include <my_libwrap.h>
unknown's avatar
unknown committed
119

120 121 122 123
#ifdef HAVE_SYS_MMAN_H
#include <sys/mman.h>
#endif

unknown's avatar
Merge  
unknown committed
124
#ifdef __NETWARE__
unknown's avatar
unknown committed
125 126 127 128
#define zVOLSTATE_ACTIVE 6
#define zVOLSTATE_DEACTIVE 2
#define zVOLSTATE_MAINTENANCE 3

unknown's avatar
unknown committed
129 130 131 132 133 134 135
#undef __event_h__
#include <../include/event.h>
/*
  This #undef exists here because both libc of NetWare and MySQL have
  files named event.h which causes compilation errors.
*/

136
#include <nks/netware.h>
unknown's avatar
unknown committed
137 138 139
#include <nks/vm.h>
#include <library.h>
#include <monitor.h>
unknown's avatar
unknown committed
140 141 142 143 144 145
#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>

146 147 148
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
149 150
static event_handle_t eh;
static Report_t ref;
151
static void *refneb= NULL;
152
my_bool event_flag= FALSE;
153
static int volumeid= -1;
unknown's avatar
unknown committed
154 155 156

  /* NEB event callback */
unsigned long neb_event_callback(struct EventBlock *eblock);
157 158 159
static void registerwithneb();
static void getvolumename();
static void getvolumeID(BYTE *volumeName);
unknown's avatar
unknown committed
160
#endif /* __NETWARE__ */
161
  
unknown's avatar
unknown committed
162

unknown's avatar
unknown committed
163
#ifdef _AIX41
unknown's avatar
unknown committed
164
int initgroups(const char *,unsigned int);
unknown's avatar
unknown committed
165 166
#endif

unknown's avatar
unknown committed
167 168 169 170 171 172
#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
173
  /* We can't handle floating point exceptions with threads, so disable
unknown's avatar
unknown committed
174 175 176 177 178 179
     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
180 181 182
#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
183
#else
unknown's avatar
unknown committed
184 185 186
 fpsetmask(~(FP_X_INV |             FP_X_OFL | FP_X_UFL | FP_X_DZ |
	     FP_X_IMP));
#endif
unknown's avatar
unknown committed
187 188 189 190 191
}
#else
#define reset_floating_point_exceptions()
#endif /* __FreeBSD__ && HAVE_IEEEFP_H */

unknown's avatar
unknown committed
192 193
} /* cplusplus */

unknown's avatar
unknown committed
194
#define MYSQL_KILL_SIGNAL SIGTERM
unknown's avatar
unknown committed
195 196 197 198 199 200 201 202 203 204 205

#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

206

unknown's avatar
unknown committed
207
/* Constants */
208

unknown's avatar
unknown committed
209
const char *show_comp_option_name[]= {"YES", "NO", "DISABLED"};
210
static const char *sql_mode_names[]=
unknown's avatar
unknown committed
211 212
{
  "REAL_AS_FLOAT", "PIPES_AS_CONCAT", "ANSI_QUOTES", "IGNORE_SPACE",
213
  "?", "ONLY_FULL_GROUP_BY", "NO_UNSIGNED_SUBTRACTION",
unknown's avatar
unknown committed
214
  "NO_DIR_IN_CREATE",
215
  "POSTGRESQL", "ORACLE", "MSSQL", "DB2", "MAXDB", "NO_KEY_OPTIONS",
216
  "NO_TABLE_OPTIONS", "NO_FIELD_OPTIONS", "MYSQL323", "MYSQL40", "ANSI",
217 218 219 220
  "NO_AUTO_VALUE_ON_ZERO", "NO_BACKSLASH_ESCAPES", "STRICT_TRANS_TABLES",
  "STRICT_ALL_TABLES",
  "NO_ZERO_IN_DATE", "NO_ZERO_DATE", "ALLOW_INVALID_DATES",
  "ERROR_FOR_DIVISION_BY_ZERO",
unknown's avatar
Merge  
unknown committed
221
  "TRADITIONAL", "NO_AUTO_CREATE_USER", "HIGH_NOT_PRECEDENCE",
222
  "NO_ENGINE_SUBSTITUTION",
223
  "PAD_CHAR_TO_FULL_LENGTH",
unknown's avatar
Merge  
unknown committed
224
  NullS
unknown's avatar
unknown committed
225
};
226

227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258
static const unsigned int sql_mode_names_len[]=
{
  /*REAL_AS_FLOAT*/               13,
  /*PIPES_AS_CONCAT*/             15,
  /*ANSI_QUOTES*/                 11,
  /*IGNORE_SPACE*/                12,
  /*?*/                           1,
  /*ONLY_FULL_GROUP_BY*/          18,
  /*NO_UNSIGNED_SUBTRACTION*/     23,
  /*NO_DIR_IN_CREATE*/            16,
  /*POSTGRESQL*/                  10,
  /*ORACLE*/                      6,
  /*MSSQL*/                       5,
  /*DB2*/                         3,
  /*MAXDB*/                       5,
  /*NO_KEY_OPTIONS*/              14,
  /*NO_TABLE_OPTIONS*/            16,
  /*NO_FIELD_OPTIONS*/            16,
  /*MYSQL323*/                    8,
  /*MYSQL40*/                     7,
  /*ANSI*/                        4,
  /*NO_AUTO_VALUE_ON_ZERO*/       21,
  /*NO_BACKSLASH_ESCAPES*/        20,
  /*STRICT_TRANS_TABLES*/         19,
  /*STRICT_ALL_TABLES*/           17,
  /*NO_ZERO_IN_DATE*/             15,
  /*NO_ZERO_DATE*/                12,
  /*ALLOW_INVALID_DATES*/         19,
  /*ERROR_FOR_DIVISION_BY_ZERO*/  26,
  /*TRADITIONAL*/                 11,
  /*NO_AUTO_CREATE_USER*/         19,
  /*HIGH_NOT_PRECEDENCE*/         19,
259 260
  /*NO_ENGINE_SUBSTITUTION*/      22,
  /*PAD_CHAR_TO_FULL_LENGTH*/     23
261
};
262

unknown's avatar
unknown committed
263
TYPELIB sql_mode_typelib= { array_elements(sql_mode_names)-1,"",
264 265
			    sql_mode_names,
                            (unsigned int *)sql_mode_names_len };
unknown's avatar
unknown committed
266 267 268 269 270 271 272 273 274
static const char *tc_heuristic_recover_names[]=
{
  "COMMIT", "ROLLBACK", NullS
};
static TYPELIB tc_heuristic_recover_typelib=
{
  array_elements(tc_heuristic_recover_names)-1,"",
  tc_heuristic_recover_names, NULL
};
unknown's avatar
unknown committed
275 276

static const char *thread_handling_names[]=
unknown's avatar
unknown committed
277 278 279 280 281
{ "one-thread-per-connection", "no-threads",
#if HAVE_POOL_OF_THREADS == 1
  "pool-of-threads",
#endif
  NullS};
unknown's avatar
unknown committed
282 283 284 285 286 287 288

TYPELIB thread_handling_typelib=
{
  array_elements(thread_handling_names) - 1, "",
  thread_handling_names, NULL
};

unknown's avatar
unknown committed
289
const char *first_keyword= "first", *binary_keyword= "BINARY";
unknown's avatar
unknown committed
290
const char *my_localhost= "localhost", *delayed_user= "DELAYED";
291 292 293 294 295 296
#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
297
bool opt_large_files= sizeof(my_off_t) > 4;
298 299 300 301

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

unknown's avatar
Merge  
unknown committed
304
arg_cmp_func Arg_comparator::comparator_matrix[5][2] =
305 306 307
{{&Arg_comparator::compare_string,     &Arg_comparator::compare_e_string},
 {&Arg_comparator::compare_real,       &Arg_comparator::compare_e_real},
 {&Arg_comparator::compare_int_signed, &Arg_comparator::compare_e_int},
unknown's avatar
Merge  
unknown committed
308 309
 {&Arg_comparator::compare_row,        &Arg_comparator::compare_e_row},
 {&Arg_comparator::compare_decimal,    &Arg_comparator::compare_e_decimal}};
unknown's avatar
unknown committed
310

311 312
const char *log_output_names[] = { "NONE", "FILE", "TABLE", NullS};
static const unsigned int log_output_names_len[]= { 4, 4, 5, 0 };
313
TYPELIB log_output_typelib= {array_elements(log_output_names)-1,"",
314 315
                             log_output_names, 
                             (unsigned int *) log_output_names_len};
316

unknown's avatar
unknown committed
317 318
/* static variables */

319
/* the default log output is log tables */
unknown's avatar
unknown committed
320 321 322 323 324 325 326 327 328 329 330 331 332 333
static bool lower_case_table_names_used= 0;
static bool volatile select_thread_in_use, signal_thread_in_use;
static bool volatile ready_to_exit;
static my_bool opt_debugging= 0, opt_external_locking= 0, opt_console= 0;
static my_bool opt_short_log_format= 0;
static uint kill_cached_threads, wake_thread;
static ulong killed_threads, thread_created;
static ulong max_used_connections;
static ulong my_bind_addr;			/* the address we bind to */
static volatile ulong cached_thread_count= 0;
static const char *sql_mode_str= "OFF";
static char *mysqld_user, *mysqld_chroot, *log_error_file_ptr;
static char *opt_init_slave, *language_ptr, *opt_init_connect;
static char *default_character_set_name;
unknown's avatar
unknown committed
334
static char *character_set_filesystem_name;
335
static char *lc_time_names_name;
unknown's avatar
unknown committed
336
static char *my_bind_addr_str;
337 338
static char *default_collation_name; 
static char *default_storage_engine_str;
339
static char compiled_default_collation_name[]= MYSQL_DEFAULT_COLLATION_NAME;
unknown's avatar
unknown committed
340 341 342 343
static I_List<THD> thread_cache;

static pthread_cond_t COND_thread_cache, COND_flush_thread_cache;

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

346 347
bool opt_update_log, opt_bin_log;
my_bool opt_log, opt_slow_log;
unknown's avatar
unknown committed
348
ulong log_output_options;
349
my_bool opt_log_queries_not_using_indexes= 0;
350
bool opt_error_log= IF_WIN(1,0);
unknown's avatar
unknown committed
351
bool opt_disable_networking=0, opt_skip_show_db=0;
352
my_bool opt_character_set_client_handshake= 1;
unknown's avatar
unknown committed
353
bool server_id_supplied = 0;
354
bool opt_endinfo, using_udf_functions;
355
my_bool locked_in_memory;
unknown's avatar
unknown committed
356
bool opt_using_transactions, using_update_log;
unknown's avatar
unknown committed
357
bool volatile abort_loop;
358 359 360 361 362 363 364 365 366
bool volatile shutdown_in_progress;
/**
   @brief 'grant_option' is used to indicate if privileges needs
   to be checked, in which case the lock, LOCK_grant, is used
   to protect access to the grant table.
   @note This flag is dropped in 5.1 
   @see grant_init()
 */
bool volatile grant_option;
unknown's avatar
unknown committed
367 368 369

my_bool opt_skip_slave_start = 0; // If set, slave is not autostarted
my_bool opt_reckless_slave = 0;
unknown's avatar
unknown committed
370 371
my_bool opt_enable_named_pipe= 0;
my_bool opt_local_infile, opt_slave_compressed_protocol;
372 373
my_bool opt_safe_user_create = 0, opt_no_mix_types = 0;
my_bool opt_show_slave_auth_info, opt_sql_bin_update = 0;
374
my_bool opt_log_slave_updates= 0;
375
bool slave_warning_issued = false; 
376 377 378 379 380 381

/*
  Legacy global handlerton. These will be removed (please do not add more).
*/
handlerton *heap_hton;
handlerton *myisam_hton;
382
handlerton *partition_hton;
383

384
#ifdef WITH_NDBCLUSTER_STORAGE_ENGINE
385
const char *opt_ndbcluster_connectstring= 0;
unknown's avatar
Merge  
unknown committed
386
const char *opt_ndb_connectstring= 0;
387
char opt_ndb_constrbuf[1024]= {0};
unknown's avatar
Merge  
unknown committed
388
unsigned opt_ndb_constrbuf_len= 0;
389
my_bool	opt_ndb_shm, opt_ndb_optimized_node_selection;
unknown's avatar
Merge  
unknown committed
390 391 392
ulong opt_ndb_cache_check_time;
const char *opt_ndb_mgmd;
ulong opt_ndb_nodeid;
unknown's avatar
unknown committed
393 394 395 396 397
ulong ndb_extra_logging;
#ifdef HAVE_NDB_BINLOG
ulong ndb_report_thresh_binlog_epoch_slip;
ulong ndb_report_thresh_binlog_mem_usage;
#endif
398

399 400 401 402
extern const char *ndb_distribution_names[];
extern TYPELIB ndb_distribution_typelib;
extern const char *opt_ndb_distribution;
extern enum ndb_distribution opt_ndb_distribution_id;
403
#endif
unknown's avatar
unknown committed
404
my_bool opt_readonly, use_temp_pool, relay_log_purge;
unknown's avatar
unknown committed
405
my_bool opt_sync_frm, opt_allow_suspicious_udfs;
406
my_bool opt_secure_auth= 0;
407
char* opt_secure_file_priv= 0;
408
my_bool opt_log_slow_admin_statements= 0;
unknown's avatar
unknown committed
409
my_bool lower_case_file_system= 0;
unknown's avatar
Merge  
unknown committed
410
my_bool opt_large_pages= 0;
unknown's avatar
unknown committed
411
my_bool opt_myisam_use_mmap= 0;
unknown's avatar
Merge  
unknown committed
412
uint    opt_large_page_size= 0;
413
my_bool opt_old_style_user_limits= 0, trust_function_creators= 0;
unknown's avatar
Merge  
unknown committed
414 415 416 417 418
/*
  True if there is at least one per-hour limit for some user, so we should
  check them before each query (and possibly reset counters when hour is
  changed). False otherwise.
*/
unknown's avatar
unknown committed
419
volatile bool mqh_used = 0;
420
my_bool opt_noacl;
unknown's avatar
Merge  
unknown committed
421
my_bool sp_automatic_privileges= 1;
422

423
ulong opt_binlog_rows_event_max_size;
unknown's avatar
unknown committed
424
const char *binlog_format_names[]= {"MIXED", "STATEMENT", "ROW", NullS};
425
TYPELIB binlog_format_typelib=
426
  { array_elements(binlog_format_names) - 1, "",
427
    binlog_format_names, NULL };
428 429
ulong opt_binlog_format_id= (ulong) BINLOG_FORMAT_UNSPEC;
const char *opt_binlog_format= binlog_format_names[opt_binlog_format_id];
430 431 432
#ifdef HAVE_INITGROUPS
static bool calling_initgroups= FALSE; /* Used in SIGSEGV handler. */
#endif
433
uint mysqld_port, test_flags, select_errors, dropping_tables, ha_open_options;
434
uint mysqld_port_timeout;
unknown's avatar
unknown committed
435
uint delay_key_write_options, protocol_version;
unknown's avatar
unknown committed
436
uint lower_case_table_names;
unknown's avatar
Merge  
unknown committed
437
uint tc_heuristic_recover= 0;
unknown's avatar
unknown committed
438
uint volatile thread_count, thread_running;
439 440
ulonglong thd_startup_options;
ulong back_log, connect_timeout, concurrency, server_id;
unknown's avatar
unknown committed
441 442
ulong table_cache_size, table_def_size;
ulong thread_stack, what_to_log;
unknown's avatar
unknown committed
443
ulong query_buff_size, slow_launch_time, slave_open_temp_tables;
unknown's avatar
unknown committed
444
ulong open_files_limit, max_binlog_size, max_relay_log_size;
445
ulong slave_net_timeout, slave_trans_retries;
unknown's avatar
unknown committed
446 447
ulong thread_cache_size=0, thread_pool_size= 0;
ulong binlog_cache_size=0, max_binlog_cache_size=0;
448
ulong query_cache_size=0;
449
ulong refresh_version;  /* Increments on each reload */
450
query_id_t global_query_id;
unknown's avatar
unknown committed
451
ulong aborted_threads, aborted_connects;
unknown's avatar
unknown committed
452 453
ulong delayed_insert_timeout, delayed_insert_limit, delayed_queue_size;
ulong delayed_insert_threads, delayed_insert_writes, delayed_rows_in_use;
unknown's avatar
unknown committed
454
ulong delayed_insert_errors,flush_time;
unknown's avatar
Merge  
unknown committed
455
ulong specialflag=0;
456
ulong binlog_cache_use= 0, binlog_cache_disk_use= 0;
unknown's avatar
unknown committed
457
ulong max_connections, max_connect_errors;
unknown's avatar
Merge  
unknown committed
458
uint  max_user_connections= 0;
459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474
/*
  Limit of the total number of prepared statements in the server.
  Is necessary to protect the server against out-of-memory attacks.
*/
ulong max_prepared_stmt_count;
/*
  Current total number of prepared statements in the server. This number
  is exact, and therefore may not be equal to the difference between
  `com_stmt_prepare' and `com_stmt_close' (global status variables), as
  the latter ones account for all registered attempts to prepare
  a statement (including unsuccessful ones).  Prepared statements are
  currently connection-local: if the same SQL query text is prepared in
  two different connections, this counts as two distinct prepared
  statements.
*/
ulong prepared_stmt_count=0;
unknown's avatar
unknown committed
475
ulong thread_id=1L,current_pid;
476
ulong slow_launch_threads = 0, sync_binlog_period;
unknown's avatar
unknown committed
477
ulong expire_logs_days = 0;
unknown's avatar
unknown committed
478
ulong rpl_recovery_rank=0;
479
const char *log_output_str= "TABLE";
unknown's avatar
unknown committed
480

481
time_t server_start_time;
482

483 484
char mysql_home[FN_REFLEN], pidfile_name[FN_REFLEN], system_time_zone[30];
char *default_tz_name;
unknown's avatar
unknown committed
485
char log_error_file[FN_REFLEN], glob_hostname[FN_REFLEN];
unknown's avatar
unknown committed
486
char mysql_real_data_home[FN_REFLEN],
487
     language[FN_REFLEN], reg_ext[FN_EXTLEN], mysql_charsets_dir[FN_REFLEN],
unknown's avatar
unknown committed
488
     *opt_init_file, *opt_tc_log_file,
489
     def_ft_boolean_syntax[sizeof(ft_boolean_syntax)];
490
uint reg_ext_length;
491 492 493
const key_map key_map_empty(0);
key_map key_map_full(0);                        // Will be initialized later

494
const char *opt_date_time_formats[3];
495

496
uint mysql_data_home_len;
unknown's avatar
unknown committed
497
char mysql_data_home_buff[2], *mysql_data_home=mysql_real_data_home;
498
char server_version[SERVER_VERSION_LENGTH];
499
char *mysqld_unix_port, *opt_mysql_tmpdir;
unknown's avatar
unknown committed
500
const char **errmesg;			/* Error messages */
501
const char *myisam_recover_options_str="OFF";
502
const char *myisam_stats_method_str="nulls_unequal";
503

504 505
/* name of reference on left espression in rewritten IN subquery */
const char *in_left_expr_name= "<left expr>";
506 507
/* name of additional condition */
const char *in_additional_cond= "<IN COND>";
508 509
const char *in_having_cond= "<IN HAVING>";

unknown's avatar
Merge  
unknown committed
510
my_decimal decimal_zero;
unknown's avatar
unknown committed
511 512 513 514 515 516 517 518
/* 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;

unknown's avatar
unknown committed
519
FILE *bootstrap_file;
unknown's avatar
Merge  
unknown committed
520
int bootstrap_error;
521
FILE *stderror_file=0;
unknown's avatar
unknown committed
522

unknown's avatar
unknown committed
523
I_List<THD> threads;
524
I_List<NAMED_LIST> key_caches;
unknown's avatar
unknown committed
525 526
Rpl_filter* rpl_filter;
Rpl_filter* binlog_filter;
unknown's avatar
unknown committed
527

unknown's avatar
unknown committed
528 529
struct system_variables global_system_variables;
struct system_variables max_system_variables;
unknown's avatar
Merge  
unknown committed
530
struct system_status_var global_status_var;
unknown's avatar
unknown committed
531

unknown's avatar
unknown committed
532
MY_TMPDIR mysql_tmpdir_list;
533
MY_BITMAP temp_pool;
unknown's avatar
unknown committed
534

535 536
CHARSET_INFO *system_charset_info, *files_charset_info ;
CHARSET_INFO *national_charset_info, *table_alias_charset;
unknown's avatar
unknown committed
537
CHARSET_INFO *character_set_filesystem;
538

539 540
MY_LOCALE *my_default_lc_time_names;

541
SHOW_COMP_OPTION have_ssl, have_symlink, have_dlopen, have_query_cache;
542
SHOW_COMP_OPTION have_geometry, have_rtree_keys;
unknown's avatar
unknown committed
543 544 545
SHOW_COMP_OPTION have_crypt, have_compress;

/* Thread specific variables */
546

unknown's avatar
unknown committed
547
pthread_key(MEM_ROOT**,THR_MALLOC);
unknown's avatar
unknown committed
548 549
pthread_key(THD*, THR_THD);
pthread_mutex_t LOCK_mysql_create_db, LOCK_Acl, LOCK_open, LOCK_thread_count,
550
		LOCK_mapped_file, LOCK_status, LOCK_global_read_lock,
unknown's avatar
unknown committed
551
		LOCK_error_log, LOCK_uuid_generator,
unknown's avatar
unknown committed
552
		LOCK_delayed_insert, LOCK_delayed_status, LOCK_delayed_create,
553
		LOCK_crypt, LOCK_bytes_sent, LOCK_bytes_received,
554
	        LOCK_global_system_variables,
555
		LOCK_user_conn, LOCK_slave_list, LOCK_active_mi;
556 557 558 559 560 561 562 563
/*
  The below lock protects access to two global server variables:
  max_prepared_stmt_count and prepared_stmt_count. These variables
  set the limit and hold the current total number of prepared statements
  in the server, respectively. As PREPARE/DEALLOCATE rate in a loaded
  server may be fairly high, we need a dedicated lock.
*/
pthread_mutex_t LOCK_prepared_stmt_count;
564 565 566
#ifdef HAVE_OPENSSL
pthread_mutex_t LOCK_des_key_file;
#endif
unknown's avatar
unknown committed
567
rw_lock_t	LOCK_grant, LOCK_sys_init_connect, LOCK_sys_init_slave;
unknown's avatar
unknown committed
568
rw_lock_t	LOCK_system_variables_hash;
569
pthread_cond_t COND_refresh, COND_thread_count, COND_global_read_lock;
unknown's avatar
unknown committed
570 571
pthread_t signal_thread;
pthread_attr_t connection_attrib;
unknown's avatar
unknown committed
572 573 574 575
pthread_mutex_t  LOCK_server_started;
pthread_cond_t  COND_server_started;

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

577 578
File_parser_dummy_hook file_parser_dummy_hook;

unknown's avatar
unknown committed
579 580 581 582 583
/* 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
584
char *relay_log_info_file, *report_user, *report_password, *report_host;
unknown's avatar
unknown committed
585
char *opt_relay_logname = 0, *opt_relaylog_index_name=0;
unknown's avatar
unknown committed
586 587 588
my_bool master_ssl;
char *master_ssl_key, *master_ssl_cert;
char *master_ssl_ca, *master_ssl_capath, *master_ssl_cipher;
589
char *opt_logname, *opt_slow_logname;
unknown's avatar
unknown committed
590 591 592 593

/* Static variables */

static bool kill_in_progress, segfaulted;
594
static my_bool opt_do_pstack, opt_bootstrap, opt_myisam_log;
unknown's avatar
unknown committed
595 596
static int cleanup_done;
static ulong opt_specialflag, opt_myisam_block_size;
597 598
static char *opt_update_logname, *opt_binlog_index_name;
static char *opt_tc_heuristic_recover;
unknown's avatar
unknown committed
599
static char *mysql_home_ptr, *pidfile_name_ptr;
unknown's avatar
unknown committed
600
static int defaults_argc;
unknown's avatar
unknown committed
601 602 603 604 605 606
static char **defaults_argv;
static char *opt_bin_logname;

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

unknown's avatar
unknown committed
607 608 609
#ifndef EMBEDDED_LIBRARY
struct passwd *user_info;
static pthread_t select_thread;
unknown's avatar
unknown committed
610
static uint thr_kill_signal;
unknown's avatar
unknown committed
611 612
#endif

unknown's avatar
unknown committed
613 614
/* OS specific variables */

unknown's avatar
unknown committed
615 616 617
#ifdef __WIN__
#undef	 getpid
#include <process.h>
unknown's avatar
unknown committed
618 619 620 621 622 623 624

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
625
#if !defined(EMBEDDED_LIBRARY)
unknown's avatar
unknown committed
626
static HANDLE hEventShutdown;
627
static char shutdown_event_name[40];
unknown's avatar
unknown committed
628 629
#include "nt_servc.h"
static	 NTService  Service;	      // Service object for WinNT
unknown's avatar
unknown committed
630 631 632 633
#endif /* EMBEDDED_LIBRARY */
#endif /* __WIN__ */

#ifdef __NT__
634
static char pipe_name[512];
unknown's avatar
unknown committed
635 636 637
static SECURITY_ATTRIBUTES saPipeSecurity;
static SECURITY_DESCRIPTOR sdPipeDescriptor;
static HANDLE hPipe = INVALID_HANDLE_VALUE;
unknown's avatar
unknown committed
638
#endif
unknown's avatar
unknown committed
639

unknown's avatar
unknown committed
640
#ifndef EMBEDDED_LIBRARY
641
bool mysqld_embedded=0;
unknown's avatar
unknown committed
642
#else
643
bool mysqld_embedded=1;
unknown's avatar
unknown committed
644 645 646 647 648 649
#endif

#ifndef DBUG_OFF
static const char* default_dbug_option;
#endif
#ifdef HAVE_LIBWRAP
650
const char *libwrapName= NULL;
651 652
int allow_severity = LOG_INFO;
int deny_severity = LOG_WARNING;
unknown's avatar
unknown committed
653 654
#endif
#ifdef HAVE_QUERY_CACHE
unknown's avatar
unknown committed
655
static ulong query_cache_limit= 0;
unknown's avatar
unknown committed
656 657 658 659 660
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;
661
my_bool opt_enable_shared_memory;
662
HANDLE smem_event_connect_request= 0;
unknown's avatar
unknown committed
663 664
#endif

unknown's avatar
unknown committed
665 666
scheduler_functions thread_scheduler;

667
#define SSL_VARS_NOT_STATIC
unknown's avatar
unknown committed
668 669
#include "sslopt-vars.h"
#ifdef HAVE_OPENSSL
670
#include <openssl/crypto.h>
unknown's avatar
unknown committed
671
#ifndef HAVE_YASSL
672 673 674 675 676 677 678 679 680 681 682
typedef struct CRYPTO_dynlock_value
{
  rw_lock_t lock;
} openssl_lock_t;

static openssl_lock_t *openssl_stdlocks;
static openssl_lock_t *openssl_dynlock_create(const char *, int);
static void openssl_dynlock_destroy(openssl_lock_t *, const char *, int);
static void openssl_lock_function(int, int, const char *, int);
static void openssl_lock(int, openssl_lock_t *, const char *, int);
static unsigned long openssl_id_function();
unknown's avatar
unknown committed
683
#endif
unknown's avatar
unknown committed
684
char *des_key_file;
unknown's avatar
unknown committed
685
struct st_VioSSLFd *ssl_acceptor_fd;
unknown's avatar
unknown committed
686 687 688 689 690
#endif /* HAVE_OPENSSL */


/* Function declarations */

691
pthread_handler_t signal_hand(void *arg);
unknown's avatar
unknown committed
692
static void mysql_init_variables(void);
unknown's avatar
unknown committed
693 694
static void get_options(int *argc,char **argv);
static my_bool get_one_option(int, const struct my_option *, char *);
695
static void set_server_version(void);
696
static int init_thread_environment();
unknown's avatar
unknown committed
697 698
static char *get_relative_path(const char *path);
static void fix_paths(void);
699 700
pthread_handler_t handle_connections_sockets(void *arg);
pthread_handler_t kill_server_thread(void *arg);
unknown's avatar
Merge  
unknown committed
701
static void bootstrap(FILE *file);
unknown's avatar
unknown committed
702 703
static bool read_init_file(char *file_name);
#ifdef __NT__
704
pthread_handler_t handle_connections_namedpipes(void *arg);
unknown's avatar
unknown committed
705
#endif
706
#ifdef HAVE_SMEM
707
pthread_handler_t handle_connections_shared_memory(void *arg);
708
#endif
709
pthread_handler_t handle_slave(void *arg);
710
static ulong find_bit_type(const char *x, TYPELIB *bit_lib);
711 712
static ulong find_bit_type_or_exit(const char *x, TYPELIB *bit_lib,
                                   const char *option);
unknown's avatar
unknown committed
713
static void clean_up(bool print_message);
714 715 716
static int test_if_case_insensitive(const char *dir_name);

#ifndef EMBEDDED_LIBRARY
717
static void usage(void);
718 719
static void start_signal_handler(void);
static void close_server_sock();
unknown's avatar
unknown committed
720
static void clean_up_mutexes(void);
721
static void wait_for_signal_thread_to_end(void);
722
static void create_pid_file();
723
static void end_ssl();
724 725
#endif

726 727

#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743
/****************************************************************************
** 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 */
744 745
  (void) pthread_mutex_lock(&LOCK_manager);
  if (manager_thread_in_use)
unknown's avatar
unknown committed
746
  {
unknown's avatar
Merge  
unknown committed
747
    DBUG_PRINT("quit",("killing manager thread: 0x%lx",manager_thread));
748
   (void) pthread_cond_signal(&COND_manager);
unknown's avatar
unknown committed
749
  }
750
  (void) pthread_mutex_unlock(&LOCK_manager);
unknown's avatar
unknown committed
751 752

  /* kill connection thread */
753
#if !defined(__WIN__) && !defined(__NETWARE__)
unknown's avatar
Merge  
unknown committed
754
  DBUG_PRINT("quit",("waiting for select thread: 0x%lx",select_thread));
unknown's avatar
unknown committed
755 756 757 758 759 760 761
  (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
762
    DBUG_PRINT("info",("Waiting for select thread"));
763

unknown's avatar
unknown committed
764 765 766
#ifndef DONT_USE_THR_ALARM
      break;					// allready dead
#endif
767
    set_timespec(abstime, 2);
768
    for (uint tmp=0 ; tmp < 10 && select_thread_in_use; tmp++)
unknown's avatar
unknown committed
769 770 771 772 773 774 775 776 777 778
    {
      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
779
    close_server_sock();
unknown's avatar
unknown committed
780 781 782 783 784 785 786
  }
  (void) pthread_mutex_unlock(&LOCK_thread_count);
#endif /* __WIN__ */


  /* Abort listening to new connections */
  DBUG_PRINT("quit",("Closing sockets"));
unknown's avatar
Merge  
unknown committed
787
  if (!opt_disable_networking )
unknown's avatar
unknown committed
788 789 790
  {
    if (ip_sock != INVALID_SOCKET)
    {
791
      (void) shutdown(ip_sock, SHUT_RDWR);
unknown's avatar
unknown committed
792 793 794 795 796
      (void) closesocket(ip_sock);
      ip_sock= INVALID_SOCKET;
    }
  }
#ifdef __NT__
unknown's avatar
unknown committed
797
  if (hPipe != INVALID_HANDLE_VALUE && opt_enable_named_pipe)
unknown's avatar
unknown committed
798
  {
unknown's avatar
merge  
unknown committed
799
    HANDLE temp;
unknown's avatar
Merge  
unknown committed
800
    DBUG_PRINT("quit", ("Closing named pipes") );
801

unknown's avatar
merge  
unknown committed
802
    /* Create connection to the handle named pipe handler to break the loop */
803
    if ((temp = CreateFile(pipe_name,
unknown's avatar
merge  
unknown committed
804 805 806 807 808 809 810
			   GENERIC_READ | GENERIC_WRITE,
			   0,
			   NULL,
			   OPEN_EXISTING,
			   0,
			   NULL )) != INVALID_HANDLE_VALUE)
    {
811
      WaitNamedPipe(pipe_name, 1000);
unknown's avatar
merge  
unknown committed
812 813 814 815 816 817
      DWORD dwMode = PIPE_READMODE_BYTE | PIPE_WAIT;
      SetNamedPipeHandleState(temp, &dwMode, NULL, NULL);
      CancelIo(temp);
      DisconnectNamedPipe(temp);
      CloseHandle(temp);
    }
unknown's avatar
unknown committed
818 819 820 821 822
  }
#endif
#ifdef HAVE_SYS_UN_H
  if (unix_sock != INVALID_SOCKET)
  {
823
    (void) shutdown(unix_sock, SHUT_RDWR);
unknown's avatar
unknown committed
824
    (void) closesocket(unix_sock);
825
    (void) unlink(mysqld_unix_port);
unknown's avatar
unknown committed
826 827 828
    unix_sock= INVALID_SOCKET;
  }
#endif
829
  end_thr_alarm(0);			 // Abort old alarms.
unknown's avatar
unknown committed
830

831 832 833 834 835
  /*
    First signal all threads that it's time to die
    This will give the threads some time to gracefully abort their
    statements and inform their clients that the server is about to die.
  */
unknown's avatar
unknown committed
836 837 838 839 840 841 842 843 844

  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));
845
    /* We skip slave threads & scheduler on this first loop through. */
846
    if (tmp->slave_thread)
847
      continue;
848

unknown's avatar
unknown committed
849
    tmp->killed= THD::KILL_CONNECTION;
unknown's avatar
unknown committed
850
    thread_scheduler.post_kill_notification(tmp);
unknown's avatar
unknown committed
851 852 853
    if (tmp->mysys_var)
    {
      tmp->mysys_var->abort=1;
unknown's avatar
unknown committed
854 855
      pthread_mutex_lock(&tmp->mysys_var->mutex);
      if (tmp->mysys_var->current_cond)
unknown's avatar
unknown committed
856 857 858 859 860
      {
	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
861
      pthread_mutex_unlock(&tmp->mysys_var->mutex);
unknown's avatar
unknown committed
862 863 864 865
    }
  }
  (void) pthread_mutex_unlock(&LOCK_thread_count); // For unlink from list

866
  Events::deinit();
867 868
  end_slave();

unknown's avatar
unknown committed
869
  if (thread_count)
870
    sleep(2);					// Give threads time to die
unknown's avatar
unknown committed
871

872 873 874 875 876
  /*
    Force remaining threads to die by closing the connection to the client
    This will ensure that threads that are waiting for a command from the
    client on a blocking read call are aborted.
  */
unknown's avatar
unknown committed
877 878 879 880 881 882 883 884 885 886 887 888

  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
889
    if (tmp->vio_ok())
unknown's avatar
unknown committed
890
    {
891 892
      if (global_system_variables.log_warnings)
        sql_print_warning(ER(ER_FORCING_CLOSE),my_progname,
893
                          tmp->thread_id,
894 895
                          (tmp->main_security_ctx.user ?
                           tmp->main_security_ctx.user : ""));
896
      close_connection(tmp,0,0);
unknown's avatar
unknown committed
897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915
    }
#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;
}

916

917
static void close_server_sock()
unknown's avatar
unknown committed
918
{
919
#ifdef HAVE_CLOSE_SERVER_SOCK
unknown's avatar
unknown committed
920
  DBUG_ENTER("close_server_sock");
921 922 923
  my_socket tmp_sock;
  tmp_sock=ip_sock;
  if (tmp_sock != INVALID_SOCKET)
unknown's avatar
unknown committed
924 925
  {
    ip_sock=INVALID_SOCKET;
926
    DBUG_PRINT("info",("calling shutdown on TCP/IP socket"));
927
    VOID(shutdown(tmp_sock, SHUT_RDWR));
unknown's avatar
unknown committed
928
#if defined(__NETWARE__)
929
    /*
unknown's avatar
unknown committed
930 931
      The following code is disabled for normal systems as it causes MySQL
      to hang on AIX 4.3 during shutdown
932
    */
933
    DBUG_PRINT("info",("calling closesocket on TCP/IP socket"));
934
    VOID(closesocket(tmp_sock));
935
#endif
unknown's avatar
unknown committed
936
  }
937 938
  tmp_sock=unix_sock;
  if (tmp_sock != INVALID_SOCKET)
unknown's avatar
unknown committed
939
  {
940
    unix_sock=INVALID_SOCKET;
941
    DBUG_PRINT("info",("calling shutdown on unix socket"));
942
    VOID(shutdown(tmp_sock, SHUT_RDWR));
unknown's avatar
unknown committed
943
#if defined(__NETWARE__)
unknown's avatar
unknown committed
944
    /*
945 946
      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
947 948
    */
    DBUG_PRINT("info",("calling closesocket on unix/IP socket"));
949
    VOID(closesocket(tmp_sock));
unknown's avatar
unknown committed
950
#endif
951
    VOID(unlink(mysqld_unix_port));
unknown's avatar
unknown committed
952 953 954
  }
  DBUG_VOID_RETURN;
#endif
955
}
unknown's avatar
unknown committed
956

957 958
#endif /*EMBEDDED_LIBRARY*/

959

unknown's avatar
unknown committed
960 961 962 963
void kill_mysql(void)
{
  DBUG_ENTER("kill_mysql");

964
#if defined(SIGNALS_DONT_BREAK_READ) && !defined(EMBEDDED_LIBRARY)
965 966
  abort_loop=1;					// Break connection loops
  close_server_sock();				// Force accept to wake up
967
#endif
unknown's avatar
unknown committed
968

unknown's avatar
unknown committed
969
#if defined(__WIN__)
unknown's avatar
unknown committed
970
#if !defined(EMBEDDED_LIBRARY)
unknown's avatar
unknown committed
971 972 973 974 975
  {
    if (!SetEvent(hEventShutdown))
    {
      DBUG_PRINT("error",("Got error: %ld from SetEvent",GetLastError()));
    }
976 977 978 979 980 981
    /*
      or:
      HANDLE hEvent=OpenEvent(0, FALSE, "MySqlShutdown");
      SetEvent(hEventShutdown);
      CloseHandle(hEvent);
    */
unknown's avatar
unknown committed
982
  }
unknown's avatar
unknown committed
983
#endif
unknown's avatar
unknown committed
984
#elif defined(HAVE_PTHREAD_KILL)
985
  if (pthread_kill(signal_thread, MYSQL_KILL_SIGNAL))
unknown's avatar
unknown committed
986 987 988 989
  {
    DBUG_PRINT("error",("Got error %d from pthread_kill",errno)); /* purecov: inspected */
  }
#elif !defined(SIGNALS_DONT_BREAK_READ)
990
  kill(current_pid, MYSQL_KILL_SIGNAL);
unknown's avatar
unknown committed
991
#endif
unknown's avatar
unknown committed
992 993 994
  DBUG_PRINT("quit",("After pthread_kill"));
  shutdown_in_progress=1;			// Safety if kill didn't work
#ifdef SIGNALS_DONT_BREAK_READ
995
  if (!kill_in_progress)
unknown's avatar
unknown committed
996 997
  {
    pthread_t tmp;
unknown's avatar
unknown committed
998
    abort_loop=1;
unknown's avatar
unknown committed
999 1000
    if (pthread_create(&tmp,&connection_attrib, kill_server_thread,
			   (void*) 0))
1001
      sql_print_error("Can't create thread to kill server");
unknown's avatar
unknown committed
1002
  }
1003
#endif
unknown's avatar
unknown committed
1004
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
1005 1006
}

1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020
/*
  Force server down. Kill all connections and threads and exit

  SYNOPSIS
  kill_server

  sig_ptr       Signal number that caused kill_server to be called.

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

*/
unknown's avatar
unknown committed
1021

1022
#if defined(__NETWARE__)
unknown's avatar
unknown committed
1023
extern "C" void kill_server(int sig_ptr)
1024
#define RETURN_FROM_KILL_SERVER DBUG_VOID_RETURN
unknown's avatar
unknown committed
1025
#elif !defined(__WIN__)
unknown's avatar
unknown committed
1026
static void *kill_server(void *sig_ptr)
unknown's avatar
unknown committed
1027
#define RETURN_FROM_KILL_SERVER DBUG_RETURN(0)
unknown's avatar
unknown committed
1028 1029
#else
static void __cdecl kill_server(int sig_ptr)
unknown's avatar
unknown committed
1030
#define RETURN_FROM_KILL_SERVER DBUG_VOID_RETURN
unknown's avatar
unknown committed
1031 1032 1033
#endif
{
  DBUG_ENTER("kill_server");
1034
#ifndef EMBEDDED_LIBRARY
unknown's avatar
Merge  
unknown committed
1035
  int sig=(int) (long) sig_ptr;			// This is passed a int
1036
  // if there is a signal during the kill in progress, ignore the other
unknown's avatar
unknown committed
1037 1038 1039 1040
  if (kill_in_progress)				// Safety
    RETURN_FROM_KILL_SERVER;
  kill_in_progress=TRUE;
  abort_loop=1;					// This should be set
1041
  if (sig != 0) // 0 is not a valid signal number
1042
    my_sigset(sig, SIG_IGN);                    /* purify inspected */
unknown's avatar
unknown committed
1043
  if (sig == MYSQL_KILL_SIGNAL || sig == 0)
1044
    sql_print_information(ER(ER_NORMAL_SHUTDOWN),my_progname);
unknown's avatar
unknown committed
1045 1046 1047
  else
    sql_print_error(ER(ER_GOT_SIGNAL),my_progname,sig); /* purecov: inspected */

1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059
#if defined(HAVE_SMEM) && defined(__WIN__)    
  /*    
   Send event to smem_event_connect_request for aborting    
   */    
  if (!SetEvent(smem_event_connect_request))    
  {      
	  DBUG_PRINT("error",
		("Got error: %ld from SetEvent of smem_event_connect_request",
		 GetLastError()));    
  }
#endif  
  
unknown's avatar
unknown committed
1060
  close_connections();
1061 1062 1063 1064 1065
  if (sig != MYSQL_KILL_SIGNAL &&
#ifdef __WIN__
      sig != SIGINT &&				/* Bug#18235 */
#endif
      sig != 0)
unknown's avatar
unknown committed
1066 1067
    unireg_abort(1);				/* purecov: inspected */
  else
1068
    unireg_end();
unknown's avatar
Merge  
unknown committed
1069

1070
  /* purecov: begin deadcode */
unknown's avatar
unknown committed
1071
#ifdef __NETWARE__
unknown's avatar
unknown committed
1072
  if (!event_flag)
unknown's avatar
Merge  
unknown committed
1073
    pthread_join(select_thread, NULL);		// wait for main thread
unknown's avatar
unknown committed
1074
#endif /* __NETWARE__ */
1075

1076
  my_thread_end();
1077 1078
  pthread_exit(0);
  /* purecov: end */
unknown's avatar
unknown committed
1079

1080
#endif /* EMBEDDED_LIBRARY */
unknown's avatar
unknown committed
1081 1082 1083 1084
  RETURN_FROM_KILL_SERVER;
}


unknown's avatar
unknown committed
1085
#if defined(USE_ONE_SIGNAL_HAND) || (defined(__NETWARE__) && defined(SIGNALS_DONT_BREAK_READ))
1086
pthread_handler_t kill_server_thread(void *arg __attribute__((unused)))
unknown's avatar
unknown committed
1087 1088 1089
{
  my_thread_init();				// Initialize new thread
  kill_server(0);
1090 1091 1092
  /* purecov: begin deadcode */
  my_thread_end();
  pthread_exit(0);
unknown's avatar
unknown committed
1093
  return 0;
1094
  /* purecov: end */
unknown's avatar
unknown committed
1095 1096 1097
}
#endif

1098

1099
extern "C" sig_handler print_signal_warning(int sig)
unknown's avatar
unknown committed
1100
{
unknown's avatar
unknown committed
1101
  if (global_system_variables.log_warnings)
1102
    sql_print_warning("Got signal %d from thread %ld", sig,my_thread_id());
unknown's avatar
unknown committed
1103
#ifdef DONT_REMEMBER_SIGNAL
1104
  my_sigset(sig,print_signal_warning);		/* int. thread system calls */
unknown's avatar
unknown committed
1105
#endif
1106
#if !defined(__WIN__) && !defined(__NETWARE__)
unknown's avatar
unknown committed
1107 1108 1109 1110 1111
  if (sig == SIGALRM)
    alarm(2);					/* reschedule alarm */
#endif
}

1112 1113
/*
  cleanup all memory and end program nicely
unknown's avatar
unknown committed
1114

1115 1116 1117 1118 1119
  SYNOPSIS
    unireg_end()

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

1121 1122 1123 1124
    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
1125

1126
#ifndef EMBEDDED_LIBRARY
1127
void unireg_end(void)
unknown's avatar
unknown committed
1128
{
unknown's avatar
unknown committed
1129
  clean_up(1);
unknown's avatar
unknown committed
1130
  my_thread_end();
1131
#if defined(SIGNALS_DONT_BREAK_READ) && !defined(__NETWARE__)
1132 1133
  exit(0);
#else
unknown's avatar
unknown committed
1134
  pthread_exit(0);				// Exit is in main thread
1135
#endif
unknown's avatar
unknown committed
1136 1137
}

1138
extern "C" void unireg_abort(int exit_code)
unknown's avatar
unknown committed
1139
{
1140
  DBUG_ENTER("unireg_abort");
unknown's avatar
unknown committed
1141 1142
  if (exit_code)
    sql_print_error("Aborting\n");
1143 1144
  else if (opt_help)
    usage();
unknown's avatar
unknown committed
1145
  clean_up(exit_code || !opt_bootstrap); /* purecov: inspected */
1146
  DBUG_PRINT("quit",("done with cleanup in unireg_abort"));
1147
  wait_for_signal_thread_to_end();
unknown's avatar
unknown committed
1148 1149
  clean_up_mutexes();
  my_end(opt_endinfo ? MY_CHECK_ERROR | MY_GIVE_INFO : 0);
unknown's avatar
unknown committed
1150 1151
  exit(exit_code); /* purecov: inspected */
}
1152
#endif
unknown's avatar
unknown committed
1153

unknown's avatar
unknown committed
1154

1155
void clean_up(bool print_message)
unknown's avatar
unknown committed
1156 1157 1158 1159
{
  DBUG_PRINT("exit",("clean_up"));
  if (cleanup_done++)
    return; /* purecov: inspected */
unknown's avatar
unknown committed
1160

unknown's avatar
unknown committed
1161 1162 1163 1164 1165
  /*
    make sure that handlers finish up
    what they have that is dependent on the binlog
  */
  ha_binlog_end(current_thd);
unknown's avatar
unknown committed
1166 1167 1168

  logger.cleanup_base();

1169
  injector::free_instance();
unknown's avatar
unknown committed
1170 1171
  mysql_bin_log.cleanup();

unknown's avatar
SCRUM  
unknown committed
1172
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
1173 1174
  if (use_slave_mask)
    bitmap_free(&slave_error_mask);
1175
#endif
1176
  my_tz_free();
unknown's avatar
unknown committed
1177
  my_database_names_free();
unknown's avatar
unknown committed
1178
#ifndef NO_EMBEDDED_ACCESS_CHECKS
unknown's avatar
unknown committed
1179
  servers_free(1);
unknown's avatar
unknown committed
1180 1181
  acl_free(1);
  grant_free();
unknown's avatar
unknown committed
1182
#endif
unknown's avatar
unknown committed
1183
  query_cache_destroy();
unknown's avatar
unknown committed
1184
  table_cache_free();
unknown's avatar
unknown committed
1185
  table_def_free();
unknown's avatar
unknown committed
1186 1187 1188
  hostname_cache_free();
  item_user_lock_free();
  lex_free();				/* Free some memory */
1189
  item_create_cleanup();
unknown's avatar
unknown committed
1190
  set_var_free();
1191
  free_charsets();
unknown's avatar
unknown committed
1192
  if (!opt_noacl)
1193
  {
1194
#ifdef HAVE_DLOPEN
unknown's avatar
unknown committed
1195
    udf_free();
1196
#endif
1197
  }
1198
  plugin_shutdown();
1199
  ha_end();
unknown's avatar
Merge  
unknown committed
1200 1201
  if (tc_log)
    tc_log->close();
1202
  xid_cache_free();
1203
  delete_elements(&key_caches, (void (*)(const char*, uchar*)) free_key_cache);
1204
  multi_keycache_free();
1205
  free_status_vars();
1206
  end_thr_alarm(1);			/* Free allocated memory */
1207
  my_free_open_file_info();
1208 1209 1210 1211 1212 1213
  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
1214 1215
  if (defaults_argv)
    free_defaults(defaults_argv);
unknown's avatar
unknown committed
1216 1217
  my_free(sys_init_connect.value, MYF(MY_ALLOW_ZERO_PTR));
  my_free(sys_init_slave.value, MYF(MY_ALLOW_ZERO_PTR));
1218 1219
  my_free(sys_var_general_log_path.value, MYF(MY_ALLOW_ZERO_PTR));
  my_free(sys_var_slow_log_path.value, MYF(MY_ALLOW_ZERO_PTR));
unknown's avatar
unknown committed
1220
  free_tmpdir(&mysql_tmpdir_list);
unknown's avatar
SCRUM  
unknown committed
1221
#ifdef HAVE_REPLICATION
1222
  my_free(slave_load_tmpdir,MYF(MY_ALLOW_ZERO_PTR));
1223
#endif
1224
  x_free(opt_bin_logname);
1225
  x_free(opt_relay_logname);
1226
  x_free(opt_secure_file_priv);
unknown's avatar
unknown committed
1227
  bitmap_free(&temp_pool);
unknown's avatar
unknown committed
1228
  free_max_user_conn();
unknown's avatar
SCRUM  
unknown committed
1229
#ifdef HAVE_REPLICATION
1230
  end_slave_list();
1231
#endif
unknown's avatar
unknown committed
1232 1233
  delete binlog_filter;
  delete rpl_filter;
unknown's avatar
unknown committed
1234
#ifndef EMBEDDED_LIBRARY
1235
  end_ssl();
unknown's avatar
unknown committed
1236
#endif
1237
  vio_end();
unknown's avatar
unknown committed
1238
#ifdef USE_REGEX
unknown's avatar
unknown committed
1239
  my_regex_end();
unknown's avatar
unknown committed
1240
#endif
unknown's avatar
unknown committed
1241

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

unknown's avatar
unknown committed
1262 1263 1264 1265
  /*
    The following lines may never be executed as the main thread may have
    killed us
  */
1266
  DBUG_PRINT("quit", ("done with cleanup"));
unknown's avatar
unknown committed
1267 1268 1269
} /* clean_up */


1270 1271
#ifndef EMBEDDED_LIBRARY

1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294
/*
  This is mainly needed when running with purify, but it's still nice to
  know that all child threads have died when mysqld exits
*/

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


unknown's avatar
unknown committed
1295 1296 1297
static void clean_up_mutexes()
{
  (void) pthread_mutex_destroy(&LOCK_mysql_create_db);
unknown's avatar
unknown committed
1298
  (void) pthread_mutex_destroy(&LOCK_lock_db);
unknown's avatar
unknown committed
1299
  (void) pthread_mutex_destroy(&LOCK_Acl);
1300
  (void) rwlock_destroy(&LOCK_grant);
unknown's avatar
unknown committed
1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313
  (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);
1314
  Events::destroy_mutexes();
1315 1316
#ifdef HAVE_OPENSSL
  (void) pthread_mutex_destroy(&LOCK_des_key_file);
unknown's avatar
unknown committed
1317
#ifndef HAVE_YASSL
1318 1319 1320
  for (int i= 0; i < CRYPTO_num_locks(); ++i)
    (void) rwlock_destroy(&openssl_stdlocks[i].lock);
  OPENSSL_free(openssl_stdlocks);
1321 1322
#endif
#endif
1323
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
1324
  (void) pthread_mutex_destroy(&LOCK_rpl_status);
1325 1326
  (void) pthread_cond_destroy(&COND_rpl_status);
#endif
unknown's avatar
unknown committed
1327
  (void) pthread_mutex_destroy(&LOCK_active_mi);
unknown's avatar
unknown committed
1328 1329
  (void) rwlock_destroy(&LOCK_sys_init_connect);
  (void) rwlock_destroy(&LOCK_sys_init_slave);
unknown's avatar
unknown committed
1330
  (void) pthread_mutex_destroy(&LOCK_global_system_variables);
unknown's avatar
unknown committed
1331
  (void) rwlock_destroy(&LOCK_system_variables_hash);
1332
  (void) pthread_mutex_destroy(&LOCK_global_read_lock);
unknown's avatar
unknown committed
1333
  (void) pthread_mutex_destroy(&LOCK_uuid_generator);
1334
  (void) pthread_mutex_destroy(&LOCK_prepared_stmt_count);
unknown's avatar
unknown committed
1335 1336
  (void) pthread_cond_destroy(&COND_thread_count);
  (void) pthread_cond_destroy(&COND_refresh);
unknown's avatar
unknown committed
1337
  (void) pthread_cond_destroy(&COND_global_read_lock);
unknown's avatar
unknown committed
1338 1339 1340 1341
  (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
1342

1343 1344 1345
#endif /*EMBEDDED_LIBRARY*/


unknown's avatar
unknown committed
1346 1347 1348 1349
/****************************************************************************
** Init IP and UNIX socket
****************************************************************************/

unknown's avatar
unknown committed
1350
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
1351 1352 1353
static void set_ports()
{
  char	*env;
1354
  if (!mysqld_port && !opt_disable_networking)
unknown's avatar
unknown committed
1355 1356
  {					// Get port if not from commandline
    struct  servent *serv_ptr;
1357 1358 1359
    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
1360
    if ((env = getenv("MYSQL_TCP_PORT")))
1361
      mysqld_port= (uint) atoi(env);		/* purecov: inspected */
unknown's avatar
unknown committed
1362
  }
1363
  if (!mysqld_unix_port)
unknown's avatar
unknown committed
1364 1365
  {
#ifdef __WIN__
1366
    mysqld_unix_port= (char*) MYSQL_NAMEDPIPE;
unknown's avatar
unknown committed
1367
#else
1368
    mysqld_unix_port= (char*) MYSQL_UNIX_ADDR;
unknown's avatar
unknown committed
1369 1370
#endif
    if ((env = getenv("MYSQL_UNIX_PORT")))
1371
      mysqld_unix_port= env;			/* purecov: inspected */
unknown's avatar
unknown committed
1372 1373 1374 1375 1376
  }
}

/* Change to run as another user if started with --user */

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

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

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

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

#ifdef PR_SET_DUMPABLE
  if (test_flags & TEST_CORE_ON_SIGNAL)
  {
    /* inform kernel that process is dumpable */
    (void) prctl(PR_SET_DUMPABLE, 1);
  }
#endif

unknown's avatar
unknown committed
1437 1438
#endif
  return NULL;
1439 1440
}

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

unknown's avatar
unknown committed
1471

1472
static void set_effective_user(struct passwd *user_info_arg)
1473
{
1474
#if !defined(__WIN__) && !defined(__NETWARE__)
1475 1476
  DBUG_ASSERT(user_info_arg != 0);
  if (setregid((gid_t)-1, user_info_arg->pw_gid) == -1)
1477
  {
1478
    sql_perror("setregid");
1479
    unireg_abort(1);
unknown's avatar
unknown committed
1480
  }
1481
  if (setreuid((uid_t)-1, user_info_arg->pw_uid) == -1)
1482
  {
1483
    sql_perror("setreuid");
1484 1485 1486 1487 1488 1489
    unireg_abort(1);
  }
#endif
}


unknown's avatar
unknown committed
1490 1491 1492 1493
/* Change root user if started with  --chroot */

static void set_root(const char *path)
{
1494
#if !defined(__WIN__) && !defined(__NETWARE__)
unknown's avatar
unknown committed
1495 1496 1497 1498 1499
  if (chroot(path) == -1)
  {
    sql_perror("chroot");
    unireg_abort(1);
  }
1500
  my_setwd("/", MYF(0));
unknown's avatar
unknown committed
1501 1502 1503
#endif
}

unknown's avatar
unknown committed
1504
static void network_init(void)
unknown's avatar
unknown committed
1505 1506 1507 1508 1509 1510
{
  struct sockaddr_in	IPaddr;
#ifdef HAVE_SYS_UN_H
  struct sockaddr_un	UNIXaddr;
#endif
  int	arg=1;
1511 1512 1513 1514
  int   ret;
  uint  waited;
  uint  this_wait;
  uint  retry;
unknown's avatar
unknown committed
1515
  DBUG_ENTER("network_init");
1516
  LINT_INIT(ret);
unknown's avatar
unknown committed
1517

unknown's avatar
unknown committed
1518 1519 1520
  if (thread_scheduler.init())
    unireg_abort(1);			/* purecov: inspected */

unknown's avatar
unknown committed
1521 1522
  set_ports();

1523
  if (mysqld_port != 0 && !opt_disable_networking && !opt_bootstrap)
unknown's avatar
unknown committed
1524
  {
1525
    DBUG_PRINT("general",("IP Socket is %d",mysqld_port));
unknown's avatar
unknown committed
1526 1527 1528 1529 1530 1531 1532 1533 1534 1535
    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;
1536
    IPaddr.sin_port = (unsigned short) htons((unsigned short) mysqld_port);
1537 1538 1539 1540 1541 1542

#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
1543
    (void) setsockopt(ip_sock,SOL_SOCKET,SO_REUSEADDR,(char*)&arg,sizeof(arg));
unknown's avatar
unknown committed
1544
#endif /* __WIN__ */
1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556
    /*
      Sometimes the port is not released fast enough when stopping and
      restarting the server. This happens quite often with the test suite
      on busy Linux systems. Retry to bind the address at these intervals:
      Sleep intervals: 1, 2, 4,  6,  9, 13, 17, 22, ...
      Retry at second: 1, 3, 7, 13, 22, 35, 52, 74, ...
      Limit the sequence by mysqld_port_timeout (set --port-open-timeout=#).
    */
    for (waited= 0, retry= 1; ; retry++, waited+= this_wait)
    {
      if (((ret= bind(ip_sock, my_reinterpret_cast(struct sockaddr *) (&IPaddr),
                      sizeof(IPaddr))) >= 0) ||
1557
          (socket_errno != SOCKET_EADDRINUSE) ||
1558 1559 1560 1561 1562 1563 1564
          (waited >= mysqld_port_timeout))
        break;
      sql_print_information("Retrying bind on TCP/IP port %u", mysqld_port);
      this_wait= retry * retry / 3 + 1;
      sleep(this_wait);
    }
    if (ret < 0)
unknown's avatar
unknown committed
1565 1566
    {
      DBUG_PRINT("error",("Got error: %d from bind",socket_errno));
1567
      sql_perror("Can't start server: Bind on TCP/IP port");
1568
      sql_print_error("Do you already have another mysqld server running on port: %d ?",mysqld_port);
unknown's avatar
unknown committed
1569 1570
      unireg_abort(1);
    }
1571
    if (listen(ip_sock,(int) back_log) < 0)
unknown's avatar
unknown committed
1572
    {
1573
      sql_perror("Can't start server: listen() on TCP/IP port");
1574
      sql_print_error("listen() on TCP/IP failed with error %d",
unknown's avatar
unknown committed
1575
		      socket_errno);
unknown's avatar
unknown committed
1576 1577
      unireg_abort(1);
    }
unknown's avatar
unknown committed
1578
  }
1579

unknown's avatar
unknown committed
1580 1581
#ifdef __NT__
  /* create named pipe */
1582
  if (Service.IsNT() && mysqld_unix_port[0] && !opt_bootstrap &&
unknown's avatar
unknown committed
1583
      opt_enable_named_pipe)
unknown's avatar
unknown committed
1584
  {
1585 1586 1587
    
    pipe_name[sizeof(pipe_name)-1]= 0;		/* Safety if too long string */
    strxnmov(pipe_name, sizeof(pipe_name)-1, "\\\\.\\pipe\\",
1588
	     mysqld_unix_port, NullS);
1589 1590
    bzero((char*) &saPipeSecurity, sizeof(saPipeSecurity));
    bzero((char*) &sdPipeDescriptor, sizeof(sdPipeDescriptor));
1591
    if (!InitializeSecurityDescriptor(&sdPipeDescriptor,
1592
				      SECURITY_DESCRIPTOR_REVISION))
unknown's avatar
unknown committed
1593 1594 1595 1596 1597 1598 1599 1600 1601
    {
      sql_perror("Can't start server : Initialize security descriptor");
      unireg_abort(1);
    }
    if (!SetSecurityDescriptorDacl(&sdPipeDescriptor, TRUE, NULL, FALSE))
    {
      sql_perror("Can't start server : Set security descriptor");
      unireg_abort(1);
    }
unknown's avatar
Merge  
unknown committed
1602
    saPipeSecurity.nLength = sizeof(SECURITY_ATTRIBUTES);
unknown's avatar
unknown committed
1603 1604
    saPipeSecurity.lpSecurityDescriptor = &sdPipeDescriptor;
    saPipeSecurity.bInheritHandle = FALSE;
1605 1606 1607 1608 1609 1610 1611 1612 1613 1614
    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
1615 1616 1617 1618 1619 1620 1621
      {
	LPVOID lpMsgBuf;
	int error=GetLastError();
	FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
		      FORMAT_MESSAGE_FROM_SYSTEM,
		      NULL, error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
		      (LPTSTR) &lpMsgBuf, 0, NULL );
unknown's avatar
Merge  
unknown committed
1622 1623 1624
	MessageBox(NULL, (LPTSTR) lpMsgBuf, "Error from CreateNamedPipe",
		    MB_OK|MB_ICONINFORMATION);
	LocalFree(lpMsgBuf);
unknown's avatar
unknown committed
1625 1626 1627 1628 1629
	unireg_abort(1);
      }
  }
#endif

1630
#if defined(HAVE_SYS_UN_H)
unknown's avatar
unknown committed
1631 1632 1633
  /*
  ** Create the UNIX socket
  */
1634
  if (mysqld_unix_port[0] && !opt_bootstrap)
unknown's avatar
unknown committed
1635
  {
1636
    DBUG_PRINT("general",("UNIX Socket is %s",mysqld_unix_port));
unknown's avatar
unknown committed
1637

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

1676
#endif /*!EMBEDDED_LIBRARY*/
unknown's avatar
unknown committed
1677

1678

1679
#ifndef EMBEDDED_LIBRARY
1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692
/*
  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
*/

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

unknown's avatar
unknown committed
1716 1717 1718 1719

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

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


unknown's avatar
unknown committed
1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744
/*
  Unlink thd from global list of available connections and free thd

  SYNOPSIS
    unlink_thd()
    thd		 Thread handler

  NOTES
    LOCK_thread_count is locked and left locked
*/

void unlink_thd(THD *thd)
unknown's avatar
unknown committed
1745
{
unknown's avatar
unknown committed
1746 1747
  DBUG_ENTER("unlink_thd");
  DBUG_PRINT("enter", ("thd: 0x%lx", (long) thd));
unknown's avatar
unknown committed
1748
  thd->cleanup();
unknown's avatar
unknown committed
1749 1750 1751
  (void) pthread_mutex_lock(&LOCK_thread_count);
  thread_count--;
  delete thd;
unknown's avatar
unknown committed
1752 1753 1754
  DBUG_VOID_RETURN;
}

1755

unknown's avatar
unknown committed
1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775
/*
  Store thread in cache for reuse by new connections

  SYNOPSIS
    cache_thread()

  NOTES
    LOCK_thread_count has to be locked

  RETURN
    0  Thread was not put in cache
    1  Thread is to be reused by new connection.
       (ie, caller should return, not abort with pthread_exit())
*/


static bool cache_thread()
{
  safe_mutex_assert_owner(&LOCK_thread_count);
  if (cached_thread_count < thread_cache_size &&
1776
      ! abort_loop && !kill_cached_threads)
unknown's avatar
unknown committed
1777 1778
  {
    /* Don't kill the thread, just put it in cache for reuse */
unknown's avatar
unknown committed
1779
    DBUG_PRINT("info", ("Adding thread to cache"));
unknown's avatar
unknown committed
1780 1781 1782 1783 1784 1785 1786 1787
    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)
    {
unknown's avatar
unknown committed
1788
      THD *thd;
unknown's avatar
unknown committed
1789
      wake_thread--;
unknown's avatar
unknown committed
1790
      thd= thread_cache.get();
1791
      thd->thread_stack= (char*) &thd;          // For store_globals
unknown's avatar
unknown committed
1792
      (void) thd->store_globals();
1793 1794 1795 1796 1797 1798
      /*
        THD::mysys_var::abort is associated with physical thread rather
        than with THD object. So we need to reset this flag before using
        this thread for handling of new THD object/connection.
      */
      thd->mysys_var->abort= 0;
1799
      thd->thr_create_time= time(NULL);
1800
      threads.append(thd);
unknown's avatar
unknown committed
1801
      return(1);
unknown's avatar
unknown committed
1802 1803
    }
  }
unknown's avatar
unknown committed
1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835
  return(0);
}


/*
  End thread for the current connection

  SYNOPSIS
    one_thread_per_connection_end()
    thd		  Thread handler
    put_in_cache  Store thread in cache, if there is room in it
                  Normally this is true in all cases except when we got
                  out of resources initializing the current thread

  NOTES
    If thread is cached, we will wait until thread is scheduled to be
    reused and then we will return.
    If thread is not cached, we end the thread.

  RETURN
    0    Signal to handle_one_connection to reuse connection
*/

bool one_thread_per_connection_end(THD *thd, bool put_in_cache)
{
  DBUG_ENTER("one_thread_per_connection_end");
  unlink_thd(thd);
  if (put_in_cache)
    put_in_cache= cache_thread();
  pthread_mutex_unlock(&LOCK_thread_count);
  if (put_in_cache)
    DBUG_RETURN(0);                             // Thread is reused
unknown's avatar
unknown committed
1836

1837
  /* It's safe to broadcast outside a lock (COND... is not deleted here) */
unknown's avatar
unknown committed
1838
  DBUG_PRINT("signal", ("Broadcasting COND_thread_count"));
unknown's avatar
unknown committed
1839
  (void) pthread_cond_broadcast(&COND_thread_count);
unknown's avatar
unknown committed
1840 1841 1842 1843

  my_thread_end();
  pthread_exit(0);
  DBUG_RETURN(0);                               // Impossible
unknown's avatar
unknown committed
1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860
}


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


1861 1862 1863 1864 1865
/*
  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
1866 1867

#ifdef THREAD_SPECIFIC_SIGPIPE
1868
extern "C" sig_handler abort_thread(int sig __attribute__((unused)))
unknown's avatar
unknown committed
1869 1870 1871 1872
{
  THD *thd=current_thd;
  DBUG_ENTER("abort_thread");
  if (thd)
unknown's avatar
Merge  
unknown committed
1873
    thd->killed= THD::KILL_CONNECTION;
unknown's avatar
unknown committed
1874 1875 1876 1877
  DBUG_VOID_RETURN;
}
#endif

unknown's avatar
unknown committed
1878

unknown's avatar
unknown committed
1879
/******************************************************************************
1880 1881 1882
  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
1883 1884
******************************************************************************/

1885
#if defined(__WIN__)
unknown's avatar
unknown committed
1886 1887 1888 1889
static void init_signals(void)
{
  int signals[] = {SIGINT,SIGILL,SIGFPE,SIGSEGV,SIGTERM,SIGABRT } ;
  for (uint i=0 ; i < sizeof(signals)/sizeof(int) ; i++)
unknown's avatar
Merge  
unknown committed
1890
    signal(signals[i], kill_server) ;
unknown's avatar
unknown committed
1891
#if defined(__WIN__)
unknown's avatar
unknown committed
1892
  signal(SIGBREAK,SIG_IGN);	//ignore SIGBREAK for NT
unknown's avatar
unknown committed
1893 1894 1895
#else
  signal(SIGBREAK, kill_server);
#endif
unknown's avatar
unknown committed
1896 1897
}

unknown's avatar
unknown committed
1898

1899
static void start_signal_handler(void)
1900
{
1901
#ifndef EMBEDDED_LIBRARY
1902 1903 1904
  // Save vm id of this process
  if (!opt_bootstrap)
    create_pid_file();
1905
#endif /* EMBEDDED_LIBRARY */
1906
}
unknown's avatar
unknown committed
1907

unknown's avatar
unknown committed
1908

unknown's avatar
unknown committed
1909 1910
static void check_data_home(const char *path)
{}
1911

unknown's avatar
unknown committed
1912

unknown's avatar
unknown committed
1913 1914 1915 1916 1917
#elif defined(__NETWARE__)

// down server event callback
void mysql_down_server_cb(void *, void *)
{
unknown's avatar
Merge  
unknown committed
1918
  event_flag= TRUE;
unknown's avatar
unknown committed
1919 1920 1921
  kill_server(0);
}

unknown's avatar
unknown committed
1922

unknown's avatar
unknown committed
1923 1924
// destroy callback resources
void mysql_cb_destroy(void *)
unknown's avatar
Merge  
unknown committed
1925 1926
{
  UnRegisterEventNotification(eh);  // cleanup down event notification
unknown's avatar
unknown committed
1927
  NX_UNWRAP_INTERFACE(ref);
unknown's avatar
Merge  
unknown committed
1928 1929
  /* Deregister NSS volume deactivation event */
  NX_UNWRAP_INTERFACE(refneb);
unknown's avatar
unknown committed
1930
  if (neb_consumer_id)
1931
    UnRegisterConsumer(neb_consumer_id, NULL);
unknown's avatar
unknown committed
1932 1933
}

unknown's avatar
unknown committed
1934

unknown's avatar
unknown committed
1935 1936 1937 1938 1939
// initialize callbacks
void mysql_cb_init()
{
  // register for down server event
  void *handle = getnlmhandle();
unknown's avatar
unknown committed
1940 1941
  rtag_t rt= AllocateResourceTag(handle, "MySQL Down Server Callback",
                                 EventSignature);
unknown's avatar
unknown committed
1942
  NX_WRAP_INTERFACE((void *)mysql_down_server_cb, 2, (void **)&ref);
unknown's avatar
unknown committed
1943 1944 1945 1946 1947 1948 1949 1950
  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
  */
1951
  (void *) NX_WRAP_INTERFACE(neb_event_callback, 1, &refneb);
unknown's avatar
unknown committed
1952 1953
  registerwithneb();

unknown's avatar
unknown committed
1954 1955 1956
  NXVmRegisterExitHandler(mysql_cb_destroy, NULL);  // clean-up
}

unknown's avatar
unknown committed
1957

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

1960
static void getvolumename()
unknown's avatar
unknown committed
1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976
{
  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
*/

1977
static void registerwithneb()
unknown's avatar
unknown committed
1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028
{

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

unknown's avatar
unknown committed
2030 2031 2032
ulong neb_event_callback(struct EventBlock *eblock)
{
  EventChangeVolStateEnter_s *voldata;
2033 2034
  extern bool nw_panic;

unknown's avatar
unknown committed
2035 2036 2037
  voldata= (EventChangeVolStateEnter_s *)eblock->EBEventData;

  /* Deactivation of a volume */
unknown's avatar
unknown committed
2038 2039 2040
  if ((voldata->oldState == zVOLSTATE_ACTIVE &&
       voldata->newState == zVOLSTATE_DEACTIVE ||
       voldata->newState == zVOLSTATE_MAINTENANCE))
unknown's avatar
unknown committed
2041 2042 2043 2044 2045 2046 2047 2048
  {
    /*
      Ensure that we bring down MySQL server only for MySQL data
      volume deactivation
    */
    if (!memcmp(&voldata->volID, &datavolid, sizeof(VolumeID_t)))
    {
      consoleprintf("MySQL data volume is deactivated, shutting down MySQL Server \n");
unknown's avatar
unknown committed
2049
      event_flag= TRUE;
2050
      nw_panic = TRUE;
2051
      event_flag= TRUE;
unknown's avatar
unknown committed
2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064
      kill_server(0);
    }
  }
  return 0;
}


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

#define ADMIN_VOL_PATH					"_ADMIN:/Volumes/"

2065
static void getvolumeID(BYTE *volumeName)
unknown's avatar
unknown committed
2066 2067 2068 2069 2070 2071 2072
{
  char path[zMAX_FULL_NAME];
  Key_t rootKey= 0, fileKey= 0;
  QUAD getInfoMask;
  zInfo_s info;
  STATUS status;

2073
  /* Get the root key */
unknown's avatar
unknown committed
2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109
  if ((status= zRootKey(0, &rootKey)) != zOK)
  {
    consoleprintf("\nGetNSSVolumeProperties - Failed to get root key, status: %d\n.", (int) status);
    goto exit;
  }

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

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

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

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

unknown's avatar
unknown committed
2111 2112 2113 2114 2115 2116 2117 2118
exit:
  if (rootKey)
    zClose(rootKey);
  if (fileKey)
    zClose(fileKey);
}


unknown's avatar
unknown committed
2119 2120 2121 2122 2123 2124 2125 2126
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

2127
}
unknown's avatar
unknown committed
2128

2129

unknown's avatar
unknown committed
2130 2131 2132 2133
static void start_signal_handler(void)
{
  // Save vm id of this process
  if (!opt_bootstrap)
2134
    create_pid_file();
unknown's avatar
unknown committed
2135 2136 2137 2138
  // no signal handler
}


unknown's avatar
unknown committed
2139 2140 2141 2142 2143 2144
/*
  Warn if the data is on a Traditional volume

  NOTE
    Already done by mysqld_safe
*/
unknown's avatar
unknown committed
2145 2146

static void check_data_home(const char *path)
2147 2148 2149
{
}

2150
#else /* if ! __WIN__  */
unknown's avatar
unknown committed
2151

unknown's avatar
unknown committed
2152 2153
#ifdef HAVE_LINUXTHREADS
#define UNSAFE_DEFAULT_LINUX_THREADS 200
2154
#endif
2155

2156
extern "C" sig_handler handle_segfault(int sig)
2157
{
2158 2159
  time_t curr_time;
  struct tm tm;
unknown's avatar
unknown committed
2160
  THD *thd=current_thd;
2161

2162 2163 2164 2165 2166 2167
  /*
    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
  */
2168
  if (segfaulted)
unknown's avatar
unknown committed
2169 2170 2171 2172
  {
    fprintf(stderr, "Fatal signal %d while backtracing\n", sig);
    exit(1);
  }
2173

2174
  segfaulted = 1;
2175 2176 2177 2178

  curr_time= time(NULL);
  localtime_r(&curr_time, &tm);

2179
  fprintf(stderr,"\
2180
%02d%02d%02d %2d:%02d:%02d - mysqld got signal %d;\n\
unknown's avatar
unknown committed
2181
This could be because you hit a bug. It is also possible that this binary\n\
unknown's avatar
unknown committed
2182
or one of the libraries it was linked against is corrupt, improperly built,\n\
unknown's avatar
unknown committed
2183
or misconfigured. This error can also be caused by malfunctioning hardware.\n",
2184 2185
          tm.tm_year % 100, tm.tm_mon+1, tm.tm_mday,
          tm.tm_hour, tm.tm_min, tm.tm_sec,
unknown's avatar
unknown committed
2186 2187 2188 2189
	  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
2190
and this may fail.\n\n");
unknown's avatar
unknown committed
2191
  fprintf(stderr, "key_buffer_size=%lu\n", 
unknown's avatar
unknown committed
2192
          (ulong) dflt_key_cache->key_cache_mem_size);
unknown's avatar
unknown committed
2193 2194
  fprintf(stderr, "read_buffer_size=%ld\n", (long) global_system_variables.read_buff_size);
  fprintf(stderr, "max_used_connections=%lu\n", max_used_connections);
unknown's avatar
unknown committed
2195
  fprintf(stderr, "max_threads=%u\n", thread_scheduler.max_threads);
unknown's avatar
unknown committed
2196
  fprintf(stderr, "threads_connected=%u\n", thread_count);
unknown's avatar
unknown committed
2197
  fprintf(stderr, "It is possible that mysqld could use up to \n\
unknown's avatar
unknown committed
2198
key_buffer_size + (read_buffer_size + sort_buffer_size)*max_threads = %lu K\n\
unknown's avatar
unknown committed
2199
bytes of memory\n", ((ulong) dflt_key_cache->key_cache_mem_size +
2200
		     (global_system_variables.read_buff_size +
unknown's avatar
unknown committed
2201
		      global_system_variables.sortbuff_size) *
unknown's avatar
unknown committed
2202 2203
		     thread_scheduler.max_threads +
                     max_connections * sizeof(THD)) / 1024);
unknown's avatar
unknown committed
2204
  fprintf(stderr, "Hope that's ok; if not, decrease some variables in the equation.\n\n");
2205

2206
#if defined(HAVE_LINUXTHREADS)
unknown's avatar
unknown committed
2207 2208 2209 2210
  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
2211 2212
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
2213
the thread stack. Please read http://www.mysql.com/doc/en/Linux.html\n\n",
unknown's avatar
unknown committed
2214 2215 2216
	    thread_count);
  }
#endif /* HAVE_LINUXTHREADS */
unknown's avatar
unknown committed
2217

unknown's avatar
unknown committed
2218
#ifdef HAVE_STACKTRACE
2219
  if (!(test_flags & TEST_NO_STACKTRACE))
unknown's avatar
unknown committed
2220
  {
unknown's avatar
unknown committed
2221
    fprintf(stderr,"thd: 0x%lx\n",(long) thd);
2222
    print_stacktrace(thd ? (uchar*) thd->thread_stack : (uchar*) 0,
unknown's avatar
unknown committed
2223
		     thread_stack);
unknown's avatar
unknown committed
2224
  }
unknown's avatar
unknown committed
2225 2226 2227 2228 2229
  if (thd)
  {
    fprintf(stderr, "Trying to get some variables.\n\
Some pointers may be invalid and cause the dump to abort...\n");
    safe_print_str("thd->query", thd->query, 1024);
unknown's avatar
unknown committed
2230
    fprintf(stderr, "thd->thread_id=%lu\n", (ulong) thd->thread_id);
unknown's avatar
unknown committed
2231 2232
  }
  fprintf(stderr, "\
unknown's avatar
unknown committed
2233
The manual page at http://www.mysql.com/doc/en/Crashing.html contains\n\
unknown's avatar
unknown committed
2234
information that should help you find out what is causing the crash.\n");
2235
  fflush(stderr);
unknown's avatar
unknown committed
2236 2237
#endif /* HAVE_STACKTRACE */

2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248
#ifdef HAVE_INITGROUPS
  if (calling_initgroups)
    fprintf(stderr, "\n\
This crash occured while the server was calling initgroups(). This is\n\
often due to the use of a mysqld that is statically linked against glibc\n\
and configured to use LDAP in /etc/nsswitch.conf. You will need to either\n\
upgrade to a version of glibc that does not have this problem (2.3.4 or\n\
later when used with nscd), disable LDAP in your nsswitch.conf, or use a\n\
mysqld that is not statically linked.\n");
#endif

2249 2250 2251 2252 2253 2254 2255 2256 2257 2258
#ifdef HAVE_NPTL
  if (thd_lib_detected == THD_LIB_LT && !getenv("LD_ASSUME_KERNEL"))
    fprintf(stderr,"\n\
You are running a statically-linked LinuxThreads binary on an NPTL system.\n\
This can result in crashes on some distributions due to LT/NPTL conflicts.\n\
You should either build a dynamically-linked binary, or force LinuxThreads\n\
to be used with the LD_ASSUME_KERNEL environment variable. Please consult\n\
the documentation for your distribution on how to do that.\n");
#endif
  
2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276
  if (locked_in_memory)
  {
    fprintf(stderr, "\n\
The \"--memlock\" argument, which was enabled, uses system calls that are\n\
unreliable and unstable on some operating systems and operating-system\n\
versions (notably, some versions of Linux).  This crash could be due to use\n\
of those buggy OS calls.  You should consider whether you really need the\n\
\"--memlock\" parameter and/or consult the OS distributer about \"mlockall\"\n\
bugs.\n");
  }

  if (test_flags & TEST_CORE_ON_SIGNAL)
  {
    fprintf(stderr, "Writing a core file\n");
    fflush(stderr);
    write_core(sig);
  }
  exit(1);
2277 2278
}

unknown's avatar
unknown committed
2279 2280 2281 2282 2283 2284
#ifndef SA_RESETHAND
#define SA_RESETHAND 0
#endif
#ifndef SA_NODEFER
#define SA_NODEFER 0
#endif
2285

2286 2287
#ifndef EMBEDDED_LIBRARY

unknown's avatar
unknown committed
2288 2289 2290
static void init_signals(void)
{
  sigset_t set;
2291
  struct sigaction sa;
unknown's avatar
unknown committed
2292 2293
  DBUG_ENTER("init_signals");

2294
  if (test_flags & TEST_SIGINT)
2295 2296 2297
  {
    my_sigset(thr_kill_signal, end_thread_signal);
  }
2298
  my_sigset(THR_SERVER_ALARM,print_signal_warning); // Should never be called!
unknown's avatar
unknown committed
2299

unknown's avatar
unknown committed
2300
  if (!(test_flags & TEST_NO_STACKTRACE) || (test_flags & TEST_CORE_ON_SIGNAL))
unknown's avatar
unknown committed
2301
  {
unknown's avatar
unknown committed
2302 2303 2304 2305
    sa.sa_flags = SA_RESETHAND | SA_NODEFER;
    sigemptyset(&sa.sa_mask);
    sigprocmask(SIG_SETMASK,&sa.sa_mask,NULL);

unknown's avatar
unknown committed
2306
    init_stacktrace();
unknown's avatar
unknown committed
2307 2308 2309
#if defined(__amiga__)
    sa.sa_handler=(void(*)())handle_segfault;
#else
unknown's avatar
unknown committed
2310
    sa.sa_handler=handle_segfault;
unknown's avatar
unknown committed
2311
#endif
unknown's avatar
unknown committed
2312
    sigaction(SIGSEGV, &sa, NULL);
2313
    sigaction(SIGABRT, &sa, NULL);
unknown's avatar
unknown committed
2314
#ifdef SIGBUS
unknown's avatar
unknown committed
2315
    sigaction(SIGBUS, &sa, NULL);
unknown's avatar
unknown committed
2316
#endif
unknown's avatar
unknown committed
2317
    sigaction(SIGILL, &sa, NULL);
2318
    sigaction(SIGFPE, &sa, NULL);
unknown's avatar
unknown committed
2319
  }
2320 2321 2322 2323 2324

#ifdef HAVE_GETRLIMIT
  if (test_flags & TEST_CORE_ON_SIGNAL)
  {
    /* Change limits so that we will get a core file */
2325
    STRUCT_RLIMIT rl;
2326
    rl.rlim_cur = rl.rlim_max = RLIM_INFINITY;
unknown's avatar
unknown committed
2327
    if (setrlimit(RLIMIT_CORE, &rl) && global_system_variables.log_warnings)
2328
      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");
2329 2330
  }
#endif
unknown's avatar
unknown committed
2331
  (void) sigemptyset(&set);
2332
  my_sigset(SIGPIPE,SIG_IGN);
unknown's avatar
unknown committed
2333 2334
  sigaddset(&set,SIGPIPE);
  sigaddset(&set,SIGINT);
2335
#ifndef IGNORE_SIGHUP_SIGQUIT
unknown's avatar
unknown committed
2336 2337
  sigaddset(&set,SIGQUIT);
  sigaddset(&set,SIGHUP);
2338 2339
#endif
  sigaddset(&set,SIGTERM);
2340 2341

  /* Fix signals if blocked by parents (can happen on Mac OS X) */
unknown's avatar
unknown committed
2342
  sigemptyset(&sa.sa_mask);
2343 2344 2345 2346 2347 2348
  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
2349 2350 2351
#ifdef SIGTSTP
  sigaddset(&set,SIGTSTP);
#endif
2352
  if (thd_lib_detected != THD_LIB_LT)
unknown's avatar
unknown committed
2353
  sigaddset(&set,THR_SERVER_ALARM);
2354
  if (test_flags & TEST_SIGINT)
2355 2356 2357 2358
  {
    // May be SIGINT
    sigdelset(&set, thr_kill_signal);
  }
2359 2360
  sigprocmask(SIG_SETMASK,&set,NULL);
  pthread_sigmask(SIG_SETMASK,&set,NULL);
2361 2362 2363 2364 2365 2366 2367 2368 2369
  DBUG_VOID_RETURN;
}


static void start_signal_handler(void)
{
  int error;
  pthread_attr_t thr_attr;
  DBUG_ENTER("start_signal_handler");
unknown's avatar
unknown committed
2370 2371 2372 2373 2374 2375 2376

  (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);
2377
#if defined(__ia64__) || defined(__ia64)
2378 2379 2380 2381
  /*
    Peculiar things with ia64 platforms - it seems we only have half the
    stack size in reality, so we have to double it here
  */
2382 2383
  pthread_attr_setstacksize(&thr_attr,thread_stack*2);
#else
2384
  pthread_attr_setstacksize(&thr_attr,thread_stack);
2385
#endif
unknown's avatar
unknown committed
2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402
#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;
}


2403
/* This threads handles all signals and alarms */
unknown's avatar
unknown committed
2404 2405

/* ARGSUSED */
2406
pthread_handler_t signal_hand(void *arg __attribute__((unused)))
unknown's avatar
unknown committed
2407 2408 2409 2410 2411
{
  sigset_t set;
  int sig;
  my_thread_init();				// Init new thread
  DBUG_ENTER("signal_hand");
unknown's avatar
unknown committed
2412 2413
  signal_thread_in_use= 1;

unknown's avatar
unknown committed
2414 2415
  /*
    Setup alarm handler
2416 2417
    This should actually be '+ max_number_of_slaves' instead of +10,
    but the +10 should be quite safe.
unknown's avatar
unknown committed
2418
  */
unknown's avatar
unknown committed
2419
  init_thr_alarm(thread_scheduler.max_threads +
2420
		 global_system_variables.max_insert_delayed_threads + 10);
2421
  if (thd_lib_detected != THD_LIB_LT && (test_flags & TEST_SIGINT))
2422 2423 2424 2425 2426
  {
    (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
2427 2428 2429 2430
  (void) sigemptyset(&set);			// Setup up SIGINT for debug
#ifdef USE_ONE_SIGNAL_HAND
  (void) sigaddset(&set,THR_SERVER_ALARM);	// For alarms
#endif
2431
#ifndef IGNORE_SIGHUP_SIGQUIT
unknown's avatar
unknown committed
2432 2433
  (void) sigaddset(&set,SIGQUIT);
  (void) sigaddset(&set,SIGHUP);
2434 2435
#endif
  (void) sigaddset(&set,SIGTERM);
unknown's avatar
unknown committed
2436 2437 2438
  (void) sigaddset(&set,SIGTSTP);

  /* Save pid to this process (or thread on Linux) */
2439
  if (!opt_bootstrap)
2440 2441
    create_pid_file();

2442 2443 2444 2445 2446 2447 2448
#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
2449

2450 2451 2452 2453 2454 2455 2456
  /*
    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
2457 2458
  (void) pthread_mutex_lock(&LOCK_thread_count);
  (void) pthread_mutex_unlock(&LOCK_thread_count);
2459
  (void) pthread_cond_broadcast(&COND_thread_count);
unknown's avatar
unknown committed
2460

2461
  (void) pthread_sigmask(SIG_BLOCK,&set,NULL);
unknown's avatar
unknown committed
2462 2463 2464 2465 2466
  for (;;)
  {
    int error;					// Used when debugging
    if (shutdown_in_progress && !abort_loop)
    {
2467
      sig= SIGTERM;
unknown's avatar
unknown committed
2468 2469 2470 2471 2472
      error=0;
    }
    else
      while ((error=my_sigwait(&set,&sig)) == EINTR) ;
    if (cleanup_done)
2473
    {
2474
      DBUG_PRINT("quit",("signal_handler: calling my_thread_end()"));
2475
      my_thread_end();
unknown's avatar
unknown committed
2476
      signal_thread_in_use= 0;
unknown's avatar
unknown committed
2477
      pthread_exit(0);				// Safety
2478
    }
unknown's avatar
unknown committed
2479 2480 2481 2482 2483
    switch (sig) {
    case SIGTERM:
    case SIGQUIT:
    case SIGKILL:
#ifdef EXTRA_DEBUG
2484
      sql_print_information("Got signal %d to shutdown mysqld",sig);
unknown's avatar
unknown committed
2485
#endif
2486
      /* switch to the old log message processing */
2487 2488
      logger.set_handlers(LOG_FILE, opt_slow_log ? LOG_FILE:LOG_NONE,
                          opt_log ? LOG_FILE:LOG_NONE);
unknown's avatar
unknown committed
2489 2490 2491 2492 2493 2494 2495 2496 2497
      DBUG_PRINT("info",("Got signal: %d  abort_loop: %d",sig,abort_loop));
      if (!abort_loop)
      {
	abort_loop=1;				// mark abort for threads
#ifdef USE_ONE_SIGNAL_HAND
	pthread_t tmp;
	if (!(opt_specialflag & SPECIAL_NO_PRIOR))
	  my_pthread_attr_setprio(&connection_attrib,INTERRUPT_PRIOR);
	if (pthread_create(&tmp,&connection_attrib, kill_server_thread,
unknown's avatar
Merge  
unknown committed
2498
			   (void*) &sig))
2499
	  sql_print_error("Can't create thread to kill server");
unknown's avatar
unknown committed
2500
#else
unknown's avatar
unknown committed
2501
	kill_server((void*) sig);	// MIT THREAD has a alarm thread
unknown's avatar
unknown committed
2502 2503 2504 2505
#endif
      }
      break;
    case SIGHUP:
unknown's avatar
unknown committed
2506 2507
      if (!abort_loop)
      {
unknown's avatar
unknown committed
2508
        bool not_used;
unknown's avatar
Merge  
unknown committed
2509
	mysql_print_status();		// Print some debug info
unknown's avatar
unknown committed
2510 2511
	reload_acl_and_cache((THD*) 0,
			     (REFRESH_LOG | REFRESH_TABLES | REFRESH_FAST |
unknown's avatar
Merge  
unknown committed
2512
			      REFRESH_GRANT |
unknown's avatar
unknown committed
2513
			      REFRESH_THREADS | REFRESH_HOSTS),
unknown's avatar
unknown committed
2514
			     (TABLE_LIST*) 0, &not_used); // Flush logs
unknown's avatar
unknown committed
2515
      }
2516
      /* reenable logs after the options were reloaded */
2517 2518
      logger.set_handlers(LOG_FILE, opt_slow_log ? LOG_TABLE:LOG_NONE,
                          opt_log ? LOG_TABLE:LOG_NONE);
unknown's avatar
unknown committed
2519 2520 2521 2522 2523 2524 2525 2526
      break;
#ifdef USE_ONE_SIGNAL_HAND
    case THR_SERVER_ALARM:
      process_alarm(sig);			// Trigger alarms.
      break;
#endif
    default:
#ifdef EXTRA_DEBUG
2527
      sql_print_warning("Got signal: %d  error: %d",sig,error); /* purecov: tested */
unknown's avatar
unknown committed
2528 2529 2530 2531 2532 2533 2534
#endif
      break;					/* purecov: tested */
    }
  }
  return(0);					/* purecov: deadcode */
}

unknown's avatar
unknown committed
2535
static void check_data_home(const char *path)
unknown's avatar
unknown committed
2536
{}
unknown's avatar
unknown committed
2537

2538
#endif /*!EMBEDDED_LIBRARY*/
unknown's avatar
unknown committed
2539 2540 2541 2542
#endif	/* __WIN__*/


/*
unknown's avatar
Merge  
unknown committed
2543 2544
  All global error messages are sent here where the first one is stored
  for the client
unknown's avatar
unknown committed
2545 2546 2547 2548
*/


/* ARGSUSED */
unknown's avatar
unknown committed
2549
static int my_message_sql(uint error, const char *str, myf MyFlags)
unknown's avatar
unknown committed
2550
{
2551
  THD *thd;
unknown's avatar
unknown committed
2552
  DBUG_ENTER("my_message_sql");
unknown's avatar
Merge  
unknown committed
2553 2554 2555 2556 2557 2558
  DBUG_PRINT("error", ("error: %u  message: '%s'", error, str));
  /*
    Put here following assertion when situation with EE_* error codes
    will be fixed
    DBUG_ASSERT(error != 0);
  */
2559
  if ((thd= current_thd))
unknown's avatar
unknown committed
2560
  {
2561 2562 2563 2564 2565 2566 2567 2568
    /*
      TODO: There are two exceptions mechanism (THD and sp_rcontext),
      this could be improved by having a common stack of handlers.
    */
    if (thd->handle_error(error,
                          MYSQL_ERROR::WARN_LEVEL_ERROR))
      DBUG_RETURN(0);

unknown's avatar
Merge  
unknown committed
2569
    if (thd->spcont &&
2570
        thd->spcont->handle_error(error, MYSQL_ERROR::WARN_LEVEL_ERROR, thd))
unknown's avatar
Merge  
unknown committed
2571 2572 2573 2574 2575 2576 2577 2578
    {
      DBUG_RETURN(0);
    }

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

    if (!thd->no_warnings_for_error)
      push_warning(thd, MYSQL_ERROR::WARN_LEVEL_ERROR, error, str);
unknown's avatar
unknown committed
2579
    /*
2580
      thd->lex->current_select == 0 if lex structure is not inited
unknown's avatar
unknown committed
2581 2582
      (not query command (COM_QUERY))
    */
2583 2584
    if (thd->lex->current_select &&
	thd->lex->current_select->no_error && !thd->is_fatal_error)
unknown's avatar
unknown committed
2585
    {
2586 2587 2588 2589 2590 2591
      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));
2592 2593 2594 2595 2596
    }
    else
    {
      NET *net= &thd->net;
      net->report_error= 1;
unknown's avatar
Merge  
unknown committed
2597
      query_cache_abort(net);
2598 2599 2600 2601 2602
      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
2603 2604
    }
  }
unknown's avatar
unknown committed
2605
  if (!thd || MyFlags & ME_NOREFRESH)
unknown's avatar
unknown committed
2606 2607 2608 2609
    sql_print_error("%s: %s",my_progname,str); /* purecov: inspected */
  DBUG_RETURN(0);
}

2610

2611
#ifndef EMBEDDED_LIBRARY
2612 2613 2614 2615 2616 2617 2618 2619
static void *my_str_malloc_mysqld(size_t size)
{
  return my_malloc(size, MYF(MY_FAE));
}


static void my_str_free_mysqld(void *ptr)
{
2620
  my_free((uchar*)ptr, MYF(MY_FAE));
2621
}
2622
#endif /* EMBEDDED_LIBRARY */
2623 2624


unknown's avatar
unknown committed
2625 2626
#ifdef __WIN__

2627
pthread_handler_t handle_shutdown(void *arg)
unknown's avatar
unknown committed
2628 2629 2630 2631 2632 2633
{
  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
2634
#if !defined(EMBEDDED_LIBRARY)
unknown's avatar
unknown committed
2635
  if (WaitForSingleObject(hEventShutdown,INFINITE)==WAIT_OBJECT_0)
2636
#endif /* EMBEDDED_LIBRARY */
unknown's avatar
unknown committed
2637 2638 2639 2640
     kill_server(MYSQL_KILL_SIGNAL);
  return 0;
}

unknown's avatar
unknown committed
2641

unknown's avatar
unknown committed
2642
int STDCALL handle_kill(ulong ctrl_type)
unknown's avatar
unknown committed
2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653
{
  if (ctrl_type == CTRL_CLOSE_EVENT ||
      ctrl_type == CTRL_SHUTDOWN_EVENT)
  {
    kill_server(MYSQL_KILL_SIGNAL);
    return TRUE;
  }
  return FALSE;
}
#endif

unknown's avatar
unknown committed
2654
#if !defined(EMBEDDED_LIBRARY)
unknown's avatar
unknown committed
2655
static const char *load_default_groups[]= {
2656
#ifdef WITH_NDBCLUSTER_STORAGE_ENGINE
2657 2658
"mysql_cluster",
#endif
unknown's avatar
Merge  
unknown committed
2659 2660
"mysqld","server", MYSQL_BASE_VERSION, 0, 0};

unknown's avatar
unknown committed
2661
#if defined(__WIN__)
2662 2663
static const int load_default_groups_sz=
sizeof(load_default_groups)/sizeof(load_default_groups[0]);
unknown's avatar
Merge  
unknown committed
2664
#endif
unknown's avatar
unknown committed
2665
#endif /*!EMBEDDED_LIBRARY*/
unknown's avatar
unknown committed
2666

unknown's avatar
unknown committed
2667

2668 2669 2670 2671 2672 2673 2674
/*
  Initialize one of the global date/time format variables

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

2676 2677 2678 2679 2680 2681 2682 2683 2684
  NOTES
    The default value is taken from either opt_date_time_formats[] or
    the ISO format (ANSI SQL)

  RETURN
    0 ok
    1 error
*/

unknown's avatar
unknown committed
2685 2686
static bool init_global_datetime_format(timestamp_type format_type,
                                        DATE_TIME_FORMAT **var_ptr)
2687
{
2688 2689
  /* Get command line option */
  const char *str= opt_date_time_formats[format_type];
2690

2691
  if (!str)					// No specified format
2692
  {
2693 2694 2695 2696 2697 2698 2699
    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;
2700
  }
2701
  if (!(*var_ptr= date_time_format_make(format_type, str, strlen(str))))
2702
  {
2703 2704
    fprintf(stderr, "Wrong date/time format specifier: %s\n", str);
    return 1;
2705
  }
2706
  return 0;
2707 2708 2709
}


2710 2711
static int init_common_variables(const char *conf_file_name, int argc,
				 char **argv, const char **groups)
unknown's avatar
unknown committed
2712
{
unknown's avatar
unknown committed
2713
  char buff[FN_REFLEN], *s;
unknown's avatar
unknown committed
2714
  umask(((~my_umask) & 0666));
unknown's avatar
Merge  
unknown committed
2715
  my_decimal_set_zero(&decimal_zero); // set decimal_zero constant;
unknown's avatar
unknown committed
2716 2717
  tzset();			// Set tzname

unknown's avatar
SCRUM  
unknown committed
2718
  max_system_variables.pseudo_thread_id= (ulong)~0;
2719
  server_start_time= time((time_t*) 0);
2720 2721 2722 2723 2724 2725 2726 2727
  rpl_filter= new Rpl_filter;
  binlog_filter= new Rpl_filter;
  if (!rpl_filter || !binlog_filter) 
  {
    sql_perror("Could not allocate replication and binlog filters");
    exit(1);
  }

unknown's avatar
unknown committed
2728 2729
  if (init_thread_environment())
    return 1;
unknown's avatar
unknown committed
2730
  mysql_init_variables();
unknown's avatar
unknown committed
2731

unknown's avatar
unknown committed
2732 2733 2734
#ifdef HAVE_TZNAME
  {
    struct tm tm_tmp;
2735
    localtime_r(&server_start_time,&tm_tmp);
2736 2737 2738 2739
    strmake(system_time_zone, tzname[tm_tmp.tm_isdst != 0 ? 1 : 0],
            sizeof(system_time_zone)-1);

 }
unknown's avatar
unknown committed
2740
#endif
2741 2742 2743 2744 2745 2746 2747 2748
  /*
    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
2749
  /*
2750
    Init mutexes for the global MYSQL_BIN_LOG objects.
unknown's avatar
unknown committed
2751
    As safe_mutex depends on what MY_INIT() does, we can't init the mutexes of
2752 2753
    global MYSQL_BIN_LOGs in their constructors, because then they would be
    inited before MY_INIT(). So we do it here.
unknown's avatar
unknown committed
2754 2755
  */
  mysql_bin_log.init_pthread_objects();
2756

2757 2758 2759 2760 2761 2762 2763 2764
  if (gethostname(glob_hostname,sizeof(glob_hostname)) < 0)
  {
    strmake(glob_hostname, STRING_WITH_LEN("localhost"));
    sql_print_warning("gethostname failed, using '%s' as hostname",
                      glob_hostname);
    strmake(pidfile_name, STRING_WITH_LEN("mysql"));
  }
  else
unknown's avatar
unknown committed
2765
  strmake(pidfile_name, glob_hostname, sizeof(pidfile_name)-5);
2766
  strmov(fn_ext(pidfile_name),".pid");		// Add proper extension
unknown's avatar
unknown committed
2767

2768 2769 2770
  /*
    Add server status variables to the dynamic list of
    status variables that is shown by SHOW STATUS.
2771
    Later, in plugin_init, and mysql_install_plugin
2772 2773 2774 2775 2776
    new entries could be added to that list.
  */
  if (add_status_vars(status_vars))
    return 1; // an error was already reported

unknown's avatar
unknown committed
2777 2778
  load_defaults(conf_file_name, groups, &argc, &argv);
  defaults_argv=argv;
unknown's avatar
unknown committed
2779 2780
  defaults_argc=argc;
  get_options(&defaults_argc, defaults_argv);
2781 2782
  set_server_version();

unknown's avatar
unknown committed
2783 2784 2785
  DBUG_PRINT("info",("%s  Ver %s for %s on %s\n",my_progname,
		     server_version, SYSTEM_TYPE,MACHINE_TYPE));

unknown's avatar
Merge  
unknown committed
2786 2787 2788 2789 2790 2791 2792 2793 2794
#ifdef HAVE_LARGE_PAGES
  /* Initialize large page size */
  if (opt_large_pages && (opt_large_page_size= my_get_large_page_size()))
  {
      my_use_large_pages= 1;
      my_large_page_size= opt_large_page_size;
  }
#endif /* HAVE_LARGE_PAGES */

unknown's avatar
unknown committed
2795 2796
  /* connections and databases needs lots of files */
  {
2797
    uint files, wanted_files, max_open_files;
2798

2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813
    /* MyISAM requires two file handles per table. */
    wanted_files= 10+max_connections+table_cache_size*2;
    /*
      We are trying to allocate no less than max_connections*5 file
      handles (i.e. we are trying to set the limit so that they will
      be available).  In addition, we allocate no less than how much
      was already allocated.  However below we report a warning and
      recompute values only if we got less file handles than were
      explicitly requested.  No warning and re-computation occur if we
      can't get max_connections*5 but still got no less than was
      requested (value of wanted_files).
    */
    max_open_files= max(max(wanted_files, max_connections*5),
                        open_files_limit);
    files= my_set_max_open_files(max_open_files);
2814 2815

    if (files < wanted_files)
unknown's avatar
unknown committed
2816
    {
2817 2818
      if (!open_files_limit)
      {
2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833
        /*
          If we have requested too much file handles than we bring
          max_connections in supported bounds.
        */
        max_connections= (ulong) min(files-10-TABLE_OPEN_CACHE_MIN*2,
                                     max_connections);
        /*
          Decrease table_cache_size according to max_connections, but
          not below TABLE_OPEN_CACHE_MIN.  Outer min() ensures that we
          never increase table_cache_size automatically (that could
          happen if max_connections is decreased above).
        */
        table_cache_size= (ulong) min(max((files-10-max_connections)/2,
                                          TABLE_OPEN_CACHE_MIN),
                                      table_cache_size);    
2834 2835 2836
	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
2837
	if (global_system_variables.log_warnings)
2838
	  sql_print_warning("Changed limits: max_open_files: %u  max_connections: %ld  table_cache: %ld",
2839 2840
			files, max_connections, table_cache_size);
      }
unknown's avatar
unknown committed
2841
      else if (global_system_variables.log_warnings)
2842
	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
2843
    }
unknown's avatar
unknown committed
2844
    open_files_limit= files;
unknown's avatar
unknown committed
2845 2846
  }
  unireg_init(opt_specialflag); /* Set up extern variabels */
2847 2848
  if (init_errmessage())	/* Read error messages from file */
    return 1;
2849
  init_client_errs();
unknown's avatar
unknown committed
2850
  lex_init();
2851 2852
  if (item_create_init())
    return 1;
unknown's avatar
unknown committed
2853
  item_init();
unknown's avatar
unknown committed
2854 2855 2856 2857 2858 2859
  if (set_var_init())
    return 1;
#ifdef HAVE_REPLICATION
  if (init_replication_sys_vars())
    return 1;
#endif
unknown's avatar
unknown committed
2860 2861
  mysys_uses_curses=0;
#ifdef USE_REGEX
unknown's avatar
unknown committed
2862
  my_regex_init(&my_charset_latin1);
unknown's avatar
unknown committed
2863
#endif
2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890
  /*
    Process a comma-separated character set list and choose
    the first available character set. This is mostly for
    test purposes, to be able to start "mysqld" even if
    the requested character set is not available (see bug#18743).
  */
  for (;;)
  {
    char *next_character_set_name= strchr(default_character_set_name, ',');
    if (next_character_set_name)
      *next_character_set_name++= '\0';
    if (!(default_charset_info=
          get_charset_by_csname(default_character_set_name,
                                MY_CS_PRIMARY, MYF(MY_WME))))
    {
      if (next_character_set_name)
      {
        default_character_set_name= next_character_set_name;
        default_collation_name= 0;          // Ignore collation
      }
      else
        return 1;                           // Eof of the list
    }
    else
      break;
  }

2891 2892
  if (default_collation_name)
  {
unknown's avatar
unknown committed
2893 2894
    CHARSET_INFO *default_collation;
    default_collation= get_charset_by_name(default_collation_name, MYF(0));
unknown's avatar
unknown committed
2895 2896 2897 2898 2899 2900
    if (!default_collation)
    {
      sql_print_error(ER(ER_UNKNOWN_COLLATION), default_collation_name);
      return 1;
    }
    if (!my_charset_same(default_charset_info, default_collation))
2901 2902 2903 2904 2905 2906 2907 2908
    {
      sql_print_error(ER(ER_COLLATION_CHARSET_MISMATCH),
		      default_collation_name,
		      default_charset_info->csname);
      return 1;
    }
    default_charset_info= default_collation;
  }
2909 2910 2911 2912
  /* 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;
2913
  global_system_variables.character_set_results= default_charset_info;
2914
  global_system_variables.character_set_client= default_charset_info;
unknown's avatar
unknown committed
2915
  global_system_variables.collation_connection= default_charset_info;
2916

unknown's avatar
unknown committed
2917 2918 2919 2920 2921 2922
  if (!(character_set_filesystem= 
        get_charset_by_csname(character_set_filesystem_name,
                              MY_CS_PRIMARY, MYF(MY_WME))))
    return 1;
  global_system_variables.character_set_filesystem= character_set_filesystem;

2923 2924 2925
  if (!(my_default_lc_time_names=
        my_locale_by_name(lc_time_names_name)))
  {
unknown's avatar
unknown committed
2926
    sql_print_error("Unknown locale: '%s'", lc_time_names_name);
2927 2928 2929 2930
    return 1;
  }
  global_system_variables.lc_time_names= my_default_lc_time_names;
  
unknown's avatar
unknown committed
2931 2932 2933
  sys_init_connect.value_length= 0;
  if ((sys_init_connect.value= opt_init_connect))
    sys_init_connect.value_length= strlen(opt_init_connect);
2934 2935
  else
    sys_init_connect.value=my_strdup("",MYF(0));
unknown's avatar
unknown committed
2936 2937 2938 2939

  sys_init_slave.value_length= 0;
  if ((sys_init_slave.value= opt_init_slave))
    sys_init_slave.value_length= strlen(opt_init_slave);
2940 2941
  else
    sys_init_slave.value=my_strdup("",MYF(0));
2942

2943 2944 2945 2946 2947
  /* check log options and issue warnings if needed */
  if (opt_log && opt_logname && !(log_output_options & LOG_FILE) &&
      !(log_output_options & LOG_NONE))
    sql_print_warning("Although a path was specified for the "
                      "--log option, log tables are used. "
2948
                      "To enable logging to files use the --log-output option.");
2949 2950 2951 2952 2953

  if (opt_slow_log && opt_slow_logname && !(log_output_options & LOG_FILE)
      && !(log_output_options & LOG_NONE))
    sql_print_warning("Although a path was specified for the "
                      "--log-slow-queries option, log tables are used. "
2954
                      "To enable logging to files use the --log-output option.");
2955

unknown's avatar
unknown committed
2956 2957 2958
  s= opt_logname ? opt_logname : make_default_log_name(buff, ".log");
  sys_var_general_log_path.value= my_strdup(s, MYF(0));
  sys_var_general_log_path.value_length= strlen(s);
2959

unknown's avatar
unknown committed
2960 2961 2962
  s= opt_slow_logname ? opt_slow_logname : make_default_log_name(buff, "-slow.log");
  sys_var_slow_log_path.value= my_strdup(s, MYF(0));
  sys_var_slow_log_path.value_length= strlen(s);
2963

2964
  if (use_temp_pool && bitmap_init(&temp_pool,0,1024,1))
2965
    return 1;
unknown's avatar
unknown committed
2966
  if (my_database_names_init())
unknown's avatar
unknown committed
2967 2968
    return 1;

2969 2970 2971 2972 2973 2974
  /*
    Ensure that lower_case_table_names is set on system where we have case
    insensitive names.  If this is not done the users MyISAM tables will
    get corrupted if accesses with names of different case.
  */
  DBUG_PRINT("info", ("lower_case_table_names: %d", lower_case_table_names));
2975 2976
  lower_case_file_system= test_if_case_insensitive(mysql_real_data_home);
  if (!lower_case_table_names && lower_case_file_system == 1)
2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005
  {
    if (lower_case_table_names_used)
    {
      if (global_system_variables.log_warnings)
	sql_print_warning("\
You have forced lower_case_table_names to 0 through a command-line \
option, even though your file system '%s' is case insensitive.  This means \
that you can corrupt a MyISAM table by accessing it with different cases. \
You should consider changing lower_case_table_names to 1 or 2",
			mysql_real_data_home);
    }
    else
    {
      if (global_system_variables.log_warnings)
	sql_print_warning("Setting lower_case_table_names=2 because file system for %s is case insensitive", mysql_real_data_home);
      lower_case_table_names= 2;
    }
  }
  else if (lower_case_table_names == 2 &&
           !(lower_case_file_system=
             (test_if_case_insensitive(mysql_real_data_home) == 1)))
  {
    if (global_system_variables.log_warnings)
      sql_print_warning("lower_case_table_names was set to 2, even though your "
                        "the file system '%s' is case sensitive.  Now setting "
                        "lower_case_table_names to 0 to avoid future problems.",
			mysql_real_data_home);
    lower_case_table_names= 0;
  }
3006 3007 3008 3009 3010
  else
  {
    lower_case_file_system=
      (test_if_case_insensitive(mysql_real_data_home) == 1);
  }
3011 3012 3013 3014 3015 3016

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

unknown's avatar
unknown committed
3017 3018
  return 0;
}
unknown's avatar
unknown committed
3019

3020 3021

static int init_thread_environment()
unknown's avatar
unknown committed
3022
{
3023
  (void) pthread_mutex_init(&LOCK_mysql_create_db,MY_MUTEX_INIT_SLOW);
unknown's avatar
unknown committed
3024
  (void) pthread_mutex_init(&LOCK_lock_db,MY_MUTEX_INIT_SLOW);
3025
  (void) pthread_mutex_init(&LOCK_Acl,MY_MUTEX_INIT_SLOW);
unknown's avatar
unknown committed
3026
  (void) pthread_mutex_init(&LOCK_open, NULL);
3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038
  (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);
3039
  (void) pthread_mutex_init(&LOCK_active_mi, MY_MUTEX_INIT_FAST);
3040
  (void) pthread_mutex_init(&LOCK_global_system_variables, MY_MUTEX_INIT_FAST);
unknown's avatar
unknown committed
3041
  (void) my_rwlock_init(&LOCK_system_variables_hash, NULL);
3042
  (void) pthread_mutex_init(&LOCK_global_read_lock, MY_MUTEX_INIT_FAST);
3043
  (void) pthread_mutex_init(&LOCK_prepared_stmt_count, MY_MUTEX_INIT_FAST);
unknown's avatar
unknown committed
3044
  (void) pthread_mutex_init(&LOCK_uuid_generator, MY_MUTEX_INIT_FAST);
3045 3046
#ifdef HAVE_OPENSSL
  (void) pthread_mutex_init(&LOCK_des_key_file,MY_MUTEX_INIT_FAST);
unknown's avatar
unknown committed
3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057
#ifndef HAVE_YASSL
  openssl_stdlocks= (openssl_lock_t*) OPENSSL_malloc(CRYPTO_num_locks() *
                                                     sizeof(openssl_lock_t));
  for (int i= 0; i < CRYPTO_num_locks(); ++i)
    (void) my_rwlock_init(&openssl_stdlocks[i].lock, NULL); 
  CRYPTO_set_dynlock_create_callback(openssl_dynlock_create);
  CRYPTO_set_dynlock_destroy_callback(openssl_dynlock_destroy);
  CRYPTO_set_dynlock_lock_callback(openssl_lock);
  CRYPTO_set_locking_callback(openssl_lock_function);
  CRYPTO_set_id_callback(openssl_id_function);
#endif
3058
#endif
unknown's avatar
unknown committed
3059 3060
  (void) my_rwlock_init(&LOCK_sys_init_connect, NULL);
  (void) my_rwlock_init(&LOCK_sys_init_slave, NULL);
3061
  (void) my_rwlock_init(&LOCK_grant, NULL);
unknown's avatar
unknown committed
3062 3063
  (void) pthread_cond_init(&COND_thread_count,NULL);
  (void) pthread_cond_init(&COND_refresh,NULL);
unknown's avatar
unknown committed
3064
  (void) pthread_cond_init(&COND_global_read_lock,NULL);
unknown's avatar
unknown committed
3065 3066
  (void) pthread_cond_init(&COND_thread_cache,NULL);
  (void) pthread_cond_init(&COND_flush_thread_cache,NULL);
3067
  (void) pthread_cond_init(&COND_manager,NULL);
unknown's avatar
SCRUM  
unknown committed
3068
#ifdef HAVE_REPLICATION
3069
  (void) pthread_mutex_init(&LOCK_rpl_status, MY_MUTEX_INIT_FAST);
3070
  (void) pthread_cond_init(&COND_rpl_status, NULL);
3071
#endif
unknown's avatar
unknown committed
3072 3073
  (void) pthread_mutex_init(&LOCK_server_started, MY_MUTEX_INIT_FAST);
  (void) pthread_cond_init(&COND_server_started,NULL);
unknown's avatar
Merge  
unknown committed
3074
  sp_cache_init();
3075
  Events::init_mutexes();
unknown's avatar
unknown committed
3076 3077 3078 3079 3080
  /* 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);
3081 3082
  if (!(opt_specialflag & SPECIAL_NO_PRIOR))
    my_pthread_attr_setprio(&connection_attrib,WAIT_PRIOR);
unknown's avatar
unknown committed
3083

unknown's avatar
unknown committed
3084 3085 3086 3087 3088 3089 3090 3091 3092
  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;
}

3093

unknown's avatar
unknown committed
3094
#if defined(HAVE_OPENSSL) && !defined(HAVE_YASSL)
3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155
static unsigned long openssl_id_function()
{ 
  return (unsigned long) pthread_self();
} 


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


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


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


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

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


3163 3164
#ifndef EMBEDDED_LIBRARY

unknown's avatar
unknown committed
3165 3166
static void init_ssl()
{
unknown's avatar
unknown committed
3167 3168 3169
#ifdef HAVE_OPENSSL
  if (opt_use_ssl)
  {
3170 3171 3172 3173
    /* having ssl_acceptor_fd != 0 signals the use of SSL */
    ssl_acceptor_fd= new_VioSSLAcceptorFd(opt_ssl_key, opt_ssl_cert,
					  opt_ssl_ca, opt_ssl_capath,
					  opt_ssl_cipher);
unknown's avatar
Merge  
unknown committed
3174
    DBUG_PRINT("info",("ssl_acceptor_fd: 0x%lx", (long) ssl_acceptor_fd));
unknown's avatar
unknown committed
3175
    if (!ssl_acceptor_fd)
3176
    {
3177
      sql_print_warning("Failed to setup SSL");
unknown's avatar
unknown committed
3178
      opt_use_ssl = 0;
3179
      have_ssl= SHOW_OPTION_DISABLED;
3180 3181 3182 3183
    }
  }
  else
  {
3184
    have_ssl= SHOW_OPTION_DISABLED;
unknown's avatar
unknown committed
3185
  }
unknown's avatar
unknown committed
3186 3187
  if (des_key_file)
    load_des_key_file(des_key_file);
unknown's avatar
unknown committed
3188
#endif /* HAVE_OPENSSL */
unknown's avatar
unknown committed
3189
}
unknown's avatar
unknown committed
3190

3191

3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202
static void end_ssl()
{
#ifdef HAVE_OPENSSL
  if (ssl_acceptor_fd)
  {
    free_vio_ssl_acceptor_fd(ssl_acceptor_fd);
    ssl_acceptor_fd= 0;
  }
#endif /* HAVE_OPENSSL */
}

3203
#endif /* EMBEDDED_LIBRARY */
3204

3205

unknown's avatar
unknown committed
3206 3207
static int init_server_components()
{
3208
  DBUG_ENTER("init_server_components");
unknown's avatar
unknown committed
3209 3210 3211 3212 3213
  /*
    We need to call each of these following functions to ensure that
    all things are initialized so that unireg_abort() doesn't fail
  */
  if (table_cache_init() | table_def_init() | hostname_cache_init())
3214
    unireg_abort(1);
unknown's avatar
unknown committed
3215

unknown's avatar
unknown committed
3216
  query_cache_result_size_limit(query_cache_limit);
3217
  query_cache_set_min_res_unit(query_cache_min_res_unit);
unknown's avatar
unknown committed
3218
  query_cache_init();
unknown's avatar
unknown committed
3219
  query_cache_resize(query_cache_size);
3220
  randominit(&sql_rand,(ulong) server_start_time,(ulong) server_start_time/2);
unknown's avatar
unknown committed
3221 3222
  reset_floating_point_exceptions();
  init_thr_lock();
unknown's avatar
SCRUM  
unknown committed
3223
#ifdef HAVE_REPLICATION
3224
  init_slave_list();
3225
#endif
unknown's avatar
unknown committed
3226

3227 3228
  /* Setup logs */

3229 3230 3231 3232 3233 3234
  /*
    Enable old-fashioned error log, except when the user has requested
    help information. Since the implementation of plugin server
    variables the help output is now written much later.
  */
  if (opt_error_log && !opt_help)
3235 3236
  {
    if (!log_error_file_ptr[0])
3237
      fn_format(log_error_file, pidfile_name, mysql_data_home, ".err",
3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252
                MY_REPLACE_EXT); /* replace '.<domain>' by '.err', bug#4997 */
    else
      fn_format(log_error_file, log_error_file_ptr, mysql_data_home, ".err",
                MY_UNPACK_FILENAME | MY_SAFE_PATH);
    if (!log_error_file[0])
      opt_error_log= 1;				// Too long file name
    else
    {
#ifndef EMBEDDED_LIBRARY
      if (freopen(log_error_file, "a+", stdout))
#endif
        freopen(log_error_file, "a+", stderr);
    }
  }

unknown's avatar
unknown committed
3253 3254 3255 3256 3257 3258
  if (xid_cache_init())
  {
    sql_print_error("Out of memory");
    unireg_abort(1);
  }

unknown's avatar
unknown committed
3259
  /* need to configure logging before initializing storage engines */
unknown's avatar
unknown committed
3260
  if (opt_update_log)
unknown's avatar
unknown committed
3261
  {
unknown's avatar
Merge  
unknown committed
3262 3263 3264 3265
    /*
      Update log is removed since 5.0. But we still accept the option.
      The idea is if the user already uses the binlog and the update log,
      we completely ignore any option/variable related to the update log, like
unknown's avatar
unknown committed
3266 3267
      if the update log did not exist. But if the user uses only the update
      log, then we translate everything into binlog for him (with warnings).
unknown's avatar
Merge  
unknown committed
3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280
      Implementation of the above :
      - If mysqld is started with --log-update and --log-bin,
      ignore --log-update (print a warning), push a warning when SQL_LOG_UPDATE
      is used, and turn off --sql-bin-update-same.
      This will completely ignore SQL_LOG_UPDATE
      - If mysqld is started with --log-update only,
      change it to --log-bin (with the filename passed to log-update,
      plus '-bin') (print a warning), push a warning when SQL_LOG_UPDATE is
      used, and turn on --sql-bin-update-same.
      This will translate SQL_LOG_UPDATE to SQL_LOG_BIN.

      Note that we tell the user that --sql-bin-update-same is deprecated and
      does nothing, and we don't take into account if he used this option or
unknown's avatar
unknown committed
3281 3282
      not; but internally we give this variable a value to have the behaviour
      we want (i.e. have SQL_LOG_UPDATE influence SQL_LOG_BIN or not).
unknown's avatar
Merge  
unknown committed
3283
      As sql-bin-update-same, log-update and log-bin cannot be changed by the
unknown's avatar
unknown committed
3284 3285
      user after starting the server (they are not variables), the user will
      not later interfere with the settings we do here.
unknown's avatar
Merge  
unknown committed
3286 3287
    */
    if (opt_bin_log)
unknown's avatar
unknown committed
3288
    {
unknown's avatar
Merge  
unknown committed
3289 3290 3291 3292 3293 3294 3295 3296 3297 3298
      opt_sql_bin_update= 0;
      sql_print_error("The update log is no longer supported by MySQL in \
version 5.0 and above. It is replaced by the binary log.");
    }
    else
    {
      opt_sql_bin_update= 1;
      opt_bin_log= 1;
      if (opt_update_logname)
      {
unknown's avatar
unknown committed
3299
        /* as opt_bin_log==0, no need to free opt_bin_logname */
unknown's avatar
Merge  
unknown committed
3300 3301 3302 3303 3304 3305 3306 3307 3308 3309
        if (!(opt_bin_logname= my_strdup(opt_update_logname, MYF(MY_WME))))
          exit(EXIT_OUT_OF_MEMORY);
        sql_print_error("The update log is no longer supported by MySQL in \
version 5.0 and above. It is replaced by the binary log. Now starting MySQL \
with --log-bin='%s' instead.",opt_bin_logname);
      }
      else
        sql_print_error("The update log is no longer supported by MySQL in \
version 5.0 and above. It is replaced by the binary log. Now starting MySQL \
with --log-bin instead.");
unknown's avatar
unknown committed
3310
    }
3311
  }
unknown's avatar
Merge  
unknown committed
3312
  if (opt_log_slave_updates && !opt_bin_log)
unknown's avatar
unknown committed
3313
  {
3314 3315
    sql_print_error("You need to use --log-bin to make "
                    "--log-slave-updates work.");
3316 3317
    unireg_abort(1);
  }
3318 3319
  if (!opt_bin_log)
    if (opt_binlog_format_id != BINLOG_FORMAT_UNSPEC)
3320
  {
3321 3322
    sql_print_error("You need to use --log-bin to make "
                    "--binlog-format work.");
3323
    unireg_abort(1);
unknown's avatar
unknown committed
3324
  }
3325
    else
3326
  {
3327
      global_system_variables.binlog_format= BINLOG_FORMAT_MIXED;
3328 3329 3330
    }
  else
    if (opt_binlog_format_id == BINLOG_FORMAT_UNSPEC)
3331
      global_system_variables.binlog_format= BINLOG_FORMAT_MIXED;
3332 3333 3334
    else
    { 
      DBUG_ASSERT(global_system_variables.binlog_format != BINLOG_FORMAT_UNSPEC);
3335
  }
3336

3337
  /* Check that we have not let the format to unspecified at this point */
3338
  DBUG_ASSERT((uint)global_system_variables.binlog_format <=
3339
              array_elements(binlog_format_names)-1);
3340

unknown's avatar
unknown committed
3341
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
3342 3343 3344
  if (opt_log_slave_updates && replicate_same_server_id)
  {
    sql_print_error("\
3345
using --replicate-same-server-id in conjunction with \
unknown's avatar
unknown committed
3346 3347 3348 3349
--log-slave-updates is impossible, it would lead to infinite loops in this \
server.");
    unireg_abort(1);
  }
unknown's avatar
unknown committed
3350
#endif
3351

unknown's avatar
Merge  
unknown committed
3352
  if (opt_bin_log)
3353
  {
unknown's avatar
Merge  
unknown committed
3354 3355 3356 3357
    char buf[FN_REFLEN];
    const char *ln;
    ln= mysql_bin_log.generate_name(opt_bin_logname, "-bin", 1, buf);
    if (!opt_bin_logname && !opt_binlog_index_name)
3358 3359
    {
      /*
unknown's avatar
Merge  
unknown committed
3360 3361 3362 3363 3364
        User didn't give us info to name the binlog index file.
        Picking `hostname`-bin.index like did in 4.x, causes replication to
        fail if the hostname is changed later. So, we would like to instead
        require a name. But as we don't want to break many existing setups, we
        only give warning, not error.
3365
      */
unknown's avatar
Merge  
unknown committed
3366 3367 3368 3369 3370
      sql_print_warning("No argument was provided to --log-bin, and "
                        "--log-bin-index was not used; so replication "
                        "may break when this MySQL server acts as a "
                        "master and has his hostname changed!! Please "
                        "use '--log-bin=%s' to avoid this problem.", ln);
3371
    }
unknown's avatar
Merge  
unknown committed
3372
    if (ln == buf)
3373
    {
unknown's avatar
Merge  
unknown committed
3374 3375
      my_free(opt_bin_logname, MYF(MY_ALLOW_ZERO_PTR));
      opt_bin_logname=my_strdup(buf, MYF(0));
3376
    }
unknown's avatar
unknown committed
3377 3378 3379 3380 3381 3382 3383 3384 3385
    if (mysql_bin_log.open_index_file(opt_binlog_index_name, ln))
    {
      unireg_abort(1);
    }

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

unknown's avatar
unknown committed
3389
  if (plugin_init(&defaults_argc, defaults_argv,
unknown's avatar
unknown committed
3390 3391
                  (opt_noacl ? PLUGIN_INIT_SKIP_PLUGIN_TABLE : 0) |
                  (opt_help ? PLUGIN_INIT_SKIP_INITIALIZATION : 0)))
unknown's avatar
unknown committed
3392
  {
unknown's avatar
unknown committed
3393 3394
    sql_print_error("Failed to initialize plugins.");
    unireg_abort(1);
unknown's avatar
unknown committed
3395 3396
  }

unknown's avatar
unknown committed
3397 3398 3399 3400 3401 3402 3403
  if (opt_help)
    unireg_abort(0);

  /* we do want to exit if there are any other unknown options */
  if (defaults_argc > 1)
  {
    int ho_error;
unknown's avatar
unknown committed
3404 3405
    char **tmp_argv= defaults_argv;
    struct my_option no_opts[]=
unknown's avatar
unknown committed
3406 3407 3408 3409 3410
    {
      {0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
    };
    /*
      We need to eat any 'loose' arguments first before we conclude
unknown's avatar
unknown committed
3411 3412 3413
      that there are unprocessed options.
      But we need to preserve defaults_argv pointer intact for
      free_defaults() to work. Thus we use a copy here.
unknown's avatar
unknown committed
3414 3415
    */
    my_getopt_skip_unknown= 0;
unknown's avatar
unknown committed
3416 3417

    if ((ho_error= handle_options(&defaults_argc, &tmp_argv, no_opts,
unknown's avatar
unknown committed
3418 3419
                                  get_one_option)))
      unireg_abort(ho_error);
unknown's avatar
unknown committed
3420

unknown's avatar
unknown committed
3421 3422 3423
    if (defaults_argc)
    {
      fprintf(stderr, "%s: Too many arguments (first extra is '%s').\n"
unknown's avatar
unknown committed
3424 3425
              "Use --verbose --help to get a list of available options\n",
              my_progname, *tmp_argv);
unknown's avatar
unknown committed
3426 3427
      unireg_abort(1);
    }
unknown's avatar
unknown committed
3428 3429
  }

unknown's avatar
unknown committed
3430 3431 3432 3433
  /* if the errmsg.sys is not loaded, terminate to maintain behaviour */
  if (!errmesg[0][0])
    unireg_abort(1);

unknown's avatar
unknown committed
3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461
  /* We have to initialize the storage engines before CSV logging */
  if (ha_init())
  {
    sql_print_error("Can't init databases");
    unireg_abort(1);
  }

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

  if (log_output_options & LOG_NONE)
  {
    /*
      Issue a warining if there were specified additional options to the
      log-output along with NONE. Probably this wasn't what user wanted.
    */
    if ((log_output_options & LOG_NONE) && (log_output_options & ~LOG_NONE))
      sql_print_warning("There were other values specified to "
                        "log-output besides NONE. Disabling slow "
                        "and general logs anyway.");
    logger.set_handlers(LOG_FILE, LOG_NONE, LOG_NONE);
  }
  else
  {
    /* fall back to the log files if tables are not present */
unknown's avatar
unknown committed
3462 3463
    LEX_STRING csv_name={C_STRING_WITH_LEN("csv")};
    if (!plugin_is_ready(&csv_name, MYSQL_STORAGE_ENGINE_PLUGIN))
unknown's avatar
unknown committed
3464
    {
3465
      /* purecov: begin inspected */
unknown's avatar
unknown committed
3466 3467
      sql_print_error("CSV engine is not present, falling back to the "
                      "log files");
unknown's avatar
unknown committed
3468
      log_output_options= (log_output_options & ~LOG_TABLE) | LOG_FILE;
3469
      /* purecov: end */
unknown's avatar
unknown committed
3470 3471 3472 3473 3474 3475 3476 3477 3478 3479
    }

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

3480 3481 3482
  /*
    Check that the default storage engine is actually available.
  */
unknown's avatar
unknown committed
3483
  if (default_storage_engine_str)
3484
  {
unknown's avatar
unknown committed
3485 3486
    LEX_STRING name= { default_storage_engine_str,
                       strlen(default_storage_engine_str) };
unknown's avatar
unknown committed
3487 3488 3489 3490 3491 3492
    plugin_ref plugin;
    handlerton *hton;
    
    if ((plugin= ha_resolve_by_name(0, &name)))
      hton= plugin_data(plugin, handlerton*);
    else
3493
    {
unknown's avatar
unknown committed
3494 3495
      sql_print_error("Unknown/unsupported table type: %s",
                      default_storage_engine_str);
3496 3497
      unireg_abort(1);
    }
unknown's avatar
unknown committed
3498 3499 3500 3501 3502 3503 3504 3505
    if (!ha_storage_engine_is_enabled(hton))
    {
      if (!opt_bootstrap)
      {
        sql_print_error("Default storage engine (%s) is not available",
                        default_storage_engine_str);
        unireg_abort(1);
      }
unknown's avatar
unknown committed
3506 3507 3508 3509 3510 3511 3512 3513 3514 3515
      DBUG_ASSERT(global_system_variables.table_plugin);
    }
    else
    {
      /*
        Need to unlock as global_system_variables.table_plugin 
        was acquired during plugin_init()
      */
      plugin_unlock(0, global_system_variables.table_plugin);
      global_system_variables.table_plugin= plugin;
unknown's avatar
unknown committed
3516
    }
3517 3518
  }

unknown's avatar
unknown committed
3519 3520 3521 3522
  tc_log= (total_ha_2pc > 1 ? (opt_bin_log  ?
                               (TC_LOG *) &mysql_bin_log :
                               (TC_LOG *) &tc_log_mmap) :
           (TC_LOG *) &tc_log_dummy);
unknown's avatar
unknown committed
3523

unknown's avatar
unknown committed
3524
  if (tc_log->open(opt_bin_log ? opt_bin_logname : opt_tc_log_file))
unknown's avatar
Merge  
unknown committed
3525 3526 3527 3528 3529
  {
    sql_print_error("Can't init tc log");
    unireg_abort(1);
  }

unknown's avatar
unknown committed
3530 3531 3532 3533 3534
  if (ha_recover(0))
  {
    unireg_abort(1);
  }

unknown's avatar
Merge  
unknown committed
3535 3536
  if (opt_bin_log && mysql_bin_log.open(opt_bin_logname, LOG_BIN, 0,
                                        WRITE_CACHE, 0, max_binlog_size, 0))
unknown's avatar
unknown committed
3537
    unireg_abort(1);
unknown's avatar
Merge  
unknown committed
3538 3539 3540

#ifdef HAVE_REPLICATION
  if (opt_bin_log && expire_logs_days)
3541
  {
3542
    time_t purge_time= time(0) - expire_logs_days*24*60*60;
unknown's avatar
Merge  
unknown committed
3543 3544
    if (purge_time >= 0)
      mysql_bin_log.purge_logs_before_date(purge_time);
3545
  }
unknown's avatar
Merge  
unknown committed
3546
#endif
unknown's avatar
unknown committed
3547 3548 3549 3550
#ifdef __NETWARE__
  /* Increasing stacksize of threads on NetWare */
  pthread_attr_setstacksize(&connection_attrib, NW_THD_STACKSIZE);
#endif
unknown's avatar
Merge  
unknown committed
3551 3552 3553

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

3555 3556
  /* call ha_init_key_cache() on all key caches to init them */
  process_key_caches(&ha_init_key_cache);
unknown's avatar
unknown committed
3557

unknown's avatar
unknown committed
3558
#if defined(HAVE_MLOCKALL) && defined(MCL_CURRENT) && !defined(EMBEDDED_LIBRARY)
3559
  if (locked_in_memory && !getuid())
3560
  {
3561
    if (setreuid((uid_t)-1, 0) == -1)
3562
    {                        // this should never happen
3563
      sql_perror("setreuid");
3564 3565
      unireg_abort(1);
    }
3566 3567
    if (mlockall(MCL_CURRENT))
    {
3568
      if (global_system_variables.log_warnings)
3569
	sql_print_warning("Failed to lock memory. Errno: %d\n",errno);
unknown's avatar
unknown committed
3570
      locked_in_memory= 0;
3571
    }
3572 3573
    if (user_info)
      set_user(mysqld_user, user_info);
3574
  }
unknown's avatar
unknown committed
3575
  else
3576
#endif
unknown's avatar
unknown committed
3577
    locked_in_memory=0;
3578

3579
  ft_init_stopwords();
unknown's avatar
unknown committed
3580

unknown's avatar
unknown committed
3581
  init_max_user_conn();
3582
  init_update_queries();
3583
  DBUG_RETURN(0);
unknown's avatar
unknown committed
3584
}
unknown's avatar
unknown committed
3585

3586

3587
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
3588

unknown's avatar
unknown committed
3589 3590
static void create_maintenance_thread()
{
3591
  if (flush_time && flush_time != ~(ulong) 0L)
unknown's avatar
unknown committed
3592
  {
unknown's avatar
unknown committed
3593 3594
    pthread_t hThread;
    if (pthread_create(&hThread,&connection_attrib,handle_manager,0))
3595
      sql_print_warning("Can't create thread to manage maintenance");
unknown's avatar
unknown committed
3596
  }
unknown's avatar
unknown committed
3597 3598
}

3599

unknown's avatar
unknown committed
3600 3601 3602
static void create_shutdown_thread()
{
#ifdef __WIN__
3603 3604 3605
  hEventShutdown=CreateEvent(0, FALSE, FALSE, shutdown_event_name);
  pthread_t hThread;
  if (pthread_create(&hThread,&connection_attrib,handle_shutdown,0))
3606
    sql_print_warning("Can't create thread to handle shutdown requests");
unknown's avatar
unknown committed
3607

3608 3609
  // On "Stop Service" we have to do regular shutdown
  Service.SetShutdownEvent(hEventShutdown);
unknown's avatar
unknown committed
3610
#endif /* __WIN__ */
unknown's avatar
unknown committed
3611
}
unknown's avatar
unknown committed
3612

3613
#endif /* EMBEDDED_LIBRARY */
3614 3615


3616
#if (defined(__NT__) || defined(HAVE_SMEM)) && !defined(EMBEDDED_LIBRARY)
3617
static void handle_connections_methods()
unknown's avatar
unknown committed
3618
{
3619 3620 3621
  pthread_t hThread;
  DBUG_ENTER("handle_connections_methods");
#ifdef __NT__
unknown's avatar
unknown committed
3622
  if (hPipe == INVALID_HANDLE_VALUE &&
3623 3624
      (!have_tcpip || opt_disable_networking) &&
      !opt_enable_shared_memory)
unknown's avatar
unknown committed
3625
  {
unknown's avatar
unknown committed
3626
    sql_print_error("TCP/IP, --shared-memory, or --named-pipe should be configured on NT OS");
3627
    unireg_abort(1);				// Will not return
unknown's avatar
unknown committed
3628
  }
3629 3630 3631 3632 3633 3634 3635
#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
3636
  {
3637 3638 3639
    handler_count++;
    if (pthread_create(&hThread,&connection_attrib,
		       handle_connections_namedpipes, 0))
unknown's avatar
unknown committed
3640
    {
3641
      sql_print_warning("Can't create thread to handle named pipes");
3642 3643 3644 3645 3646 3647 3648 3649 3650 3651
      handler_count--;
    }
  }
#endif /* __NT__ */
  if (have_tcpip && !opt_disable_networking)
  {
    handler_count++;
    if (pthread_create(&hThread,&connection_attrib,
		       handle_connections_sockets, 0))
    {
3652
      sql_print_warning("Can't create thread to handle TCP/IP");
3653 3654 3655 3656 3657 3658 3659 3660 3661 3662
      handler_count--;
    }
  }
#ifdef HAVE_SMEM
  if (opt_enable_shared_memory)
  {
    handler_count++;
    if (pthread_create(&hThread,&connection_attrib,
		       handle_connections_shared_memory, 0))
    {
3663
      sql_print_warning("Can't create thread to handle shared memory");
3664
      handler_count--;
unknown's avatar
unknown committed
3665 3666
    }
  }
3667
#endif 
unknown's avatar
unknown committed
3668

3669 3670 3671 3672 3673
  while (handler_count > 0)
    pthread_cond_wait(&COND_handler_count,&LOCK_thread_count);
  pthread_mutex_unlock(&LOCK_thread_count);
  DBUG_VOID_RETURN;
}
3674 3675 3676 3677 3678 3679

void decrement_handler_count()
{
  pthread_mutex_lock(&LOCK_thread_count);
  handler_count--;
  pthread_cond_signal(&COND_handler_count);
3680 3681
  pthread_mutex_unlock(&LOCK_thread_count);  
  my_thread_end();
3682 3683 3684
}
#else
#define decrement_handler_count()
3685 3686 3687
#endif /* defined(__NT__) || defined(HAVE_SMEM) */


3688
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
3689 3690 3691 3692 3693 3694
#ifdef __WIN__
int win_main(int argc, char **argv)
#else
int main(int argc, char **argv)
#endif
{
3695 3696 3697
  MY_INIT(argv[0]);		// init my_sys library & pthreads
  /* nothing should come before this line ^^^ */

3698 3699 3700 3701 3702 3703 3704
  /* Set signal used to kill MySQL */
#if defined(SIGUSR2)
  thr_kill_signal= thd_lib_detected == THD_LIB_LT ? SIGINT : SIGUSR2;
#else
  thr_kill_signal= SIGINT;
#endif

3705 3706 3707 3708 3709 3710
  /*
    Perform basic logger initialization logger. Should be called after
    MY_INIT, as it initializes mutexes. Log tables are inited later.
  */
  logger.init_base();

unknown's avatar
unknown committed
3711
#ifdef _CUSTOMSTARTUPCONFIG_
unknown's avatar
unknown committed
3712 3713 3714
  if (_cust_check_startup())
  {
    / * _cust_check_startup will report startup failure error * /
unknown's avatar
Merge  
unknown committed
3715
    exit(1);
unknown's avatar
unknown committed
3716 3717
  }
#endif
unknown's avatar
unknown committed
3718

3719
#ifdef	__WIN__
unknown's avatar
unknown committed
3720 3721 3722 3723
  /*
    Before performing any socket operation (like retrieving hostname
    in init_common_variables we have to call WSAStartup
  */
3724 3725 3726 3727
  {
    WSADATA WsaData;
    if (SOCKET_ERROR == WSAStartup (0x0101, &WsaData))
    {
unknown's avatar
unknown committed
3728
      /* errors are not read yet, so we use english text here */
3729 3730 3731 3732 3733 3734
      my_message(ER_WSAS_FAILED, "WSAStartup Failed", MYF(0));
      unireg_abort(1);
    }
  }
#endif /* __WIN__ */

3735 3736 3737
  if (init_common_variables(MYSQL_CONFIG_NAME,
			    argc, argv, load_default_groups))
    unireg_abort(1);				// Will do exit
unknown's avatar
unknown committed
3738 3739 3740 3741

  init_signals();
  if (!(opt_specialflag & SPECIAL_NO_PRIOR))
    my_pthread_setprio(pthread_self(),CONNECT_PRIOR);
3742
#if defined(__ia64__) || defined(__ia64)
3743 3744 3745 3746
  /*
    Peculiar things with ia64 platforms - it seems we only have half the
    stack size in reality, so we have to double it here
  */
3747 3748
  pthread_attr_setstacksize(&connection_attrib,thread_stack*2);
#else
3749
  pthread_attr_setstacksize(&connection_attrib,thread_stack);
3750
#endif
3751 3752 3753 3754 3755
#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);
3756 3757 3758
#if defined(__ia64__) || defined(__ia64)
    stack_size/= 2;
#endif
3759 3760 3761 3762
    /* 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)
unknown's avatar
unknown committed
3763
	sql_print_warning("Asked for %lu thread stack, but got %ld",
3764
			  thread_stack, (long) stack_size);
3765 3766 3767
#if defined(__ia64__) || defined(__ia64)
      thread_stack= stack_size*2;
#else
3768
      thread_stack= stack_size;
3769
#endif
3770 3771 3772
    }
  }
#endif
3773 3774 3775 3776
#ifdef __NETWARE__
  /* Increasing stacksize of threads on NetWare */
  pthread_attr_setstacksize(&connection_attrib, NW_THD_STACKSIZE);
#endif
unknown's avatar
unknown committed
3777

3778
  (void) thr_setconcurrency(concurrency);	// 10 by default
unknown's avatar
unknown committed
3779

3780 3781
  select_thread=pthread_self();
  select_thread_in_use=1;
unknown's avatar
unknown committed
3782 3783 3784 3785 3786 3787 3788 3789 3790 3791
  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
3792
  check_data_home(mysql_real_data_home);
unknown's avatar
unknown committed
3793
  if (my_setwd(mysql_real_data_home,MYF(MY_WME)) && !opt_help)
unknown's avatar
unknown committed
3794 3795 3796 3797
    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;
3798
  mysql_data_home_len= 2;
unknown's avatar
unknown committed
3799 3800 3801 3802 3803 3804 3805 3806 3807 3808 3809

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

unknown's avatar
unknown committed
3810 3811 3812 3813
  if (opt_bin_log && !server_id)
  {
    server_id= !master_host ? 1 : 2;
#ifdef EXTRA_DEBUG
3814
    switch (server_id) {
unknown's avatar
unknown committed
3815
    case 1:
3816 3817
      sql_print_warning("\
You have enabled the binary log, but you haven't set server-id to \
3818 3819
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
3820 3821
      break;
    case 2:
3822 3823
      sql_print_warning("\
You should set server-id to a non-0 value if master_host is set; \
3824
we force server id to 2, but this MySQL server will not act as a slave.");
unknown's avatar
unknown committed
3825 3826
      break;
    }
3827
#endif
unknown's avatar
unknown committed
3828 3829 3830
  }

  if (init_server_components())
unknown's avatar
unknown committed
3831
    unireg_abort(1);
unknown's avatar
unknown committed
3832

unknown's avatar
unknown committed
3833 3834
  network_init();

unknown's avatar
unknown committed
3835 3836 3837
#ifdef __WIN__
  if (!opt_console)
  {
3838 3839
    freopen(log_error_file,"a+",stdout);
    freopen(log_error_file,"a+",stderr);
unknown's avatar
unknown committed
3840
    FreeConsole();				// Remove window
3841
  }
3842 3843 3844 3845 3846
  else
  {
    /* Don't show error dialog box when on foreground: it stops the server */ 
    SetErrorMode(SEM_NOOPENFILEERRORBOX | SEM_FAILCRITICALERRORS);
  }
unknown's avatar
unknown committed
3847 3848
#endif

3849 3850 3851 3852 3853 3854
  /*
   Initialize my_str_malloc() and my_str_free()
  */
  my_str_malloc= &my_str_malloc_mysqld;
  my_str_free= &my_str_free_mysqld;

unknown's avatar
unknown committed
3855 3856 3857 3858
  /*
    init signals & alarm
    After this we can't quit by a simple unireg_abort
  */
3859
  error_handler_hook= my_message_sql;
unknown's avatar
unknown committed
3860
  start_signal_handler();				// Creates pidfile
3861

3862
  if (mysql_rm_tmp_tables() || acl_init(opt_noacl) ||
3863
      my_tz_init((THD *)0, default_tz_name, opt_bootstrap))
unknown's avatar
unknown committed
3864 3865 3866
  {
    abort_loop=1;
    select_thread_in_use=0;
unknown's avatar
unknown committed
3867 3868 3869
#ifndef __NETWARE__
    (void) pthread_kill(signal_thread, MYSQL_KILL_SIGNAL);
#endif /* __NETWARE__ */
3870

unknown's avatar
unknown committed
3871 3872
    if (!opt_bootstrap)
      (void) my_delete(pidfile_name,MYF(MY_WME));	// Not needed anymore
3873

3874
    if (unix_sock != INVALID_SOCKET)
3875
      unlink(mysqld_unix_port);
unknown's avatar
unknown committed
3876 3877 3878
    exit(1);
  }
  if (!opt_noacl)
3879
    (void) grant_init();
unknown's avatar
unknown committed
3880

unknown's avatar
unknown committed
3881 3882 3883
  if (!opt_bootstrap)
    servers_init(0);

unknown's avatar
unknown committed
3884
  if (!opt_noacl)
3885 3886
  {
#ifdef HAVE_DLOPEN
unknown's avatar
unknown committed
3887 3888
    udf_init();
#endif
3889
  }
3890

3891
  init_status_vars();
unknown's avatar
unknown committed
3892 3893
  if (opt_bootstrap) /* If running with bootstrap, do not start replication. */
    opt_skip_slave_start= 1;
3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904
  /*
    init_slave() must be called after the thread keys are created.
    Some parts of the code (e.g. SHOW STATUS LIKE 'slave_running' and other
    places) assume that active_mi != 0, so let's fail if it's 0 (out of
    memory); a message has already been printed.
  */
  if (init_slave() && !active_mi)
  {
    end_thr_alarm(1);				// Don't allow alarms
    unireg_abort(1);
  }
3905

unknown's avatar
unknown committed
3906 3907
  if (opt_bootstrap)
  {
3908
    select_thread_in_use= 0;                    // Allow 'kill' to work
unknown's avatar
Merge  
unknown committed
3909
    bootstrap(stdin);
3910
    end_thr_alarm(1);				// Don't allow alarms
unknown's avatar
Merge  
unknown committed
3911
    unireg_abort(bootstrap_error ? 1 : 0);
unknown's avatar
unknown committed
3912 3913 3914 3915 3916
  }
  if (opt_init_file)
  {
    if (read_init_file(opt_init_file))
    {
3917
      end_thr_alarm(1);				// Don't allow alarms
unknown's avatar
unknown committed
3918 3919 3920
      unireg_abort(1);
    }
  }
3921
  execute_ddl_log_recovery();
unknown's avatar
unknown committed
3922

unknown's avatar
unknown committed
3923
  create_shutdown_thread();
unknown's avatar
unknown committed
3924 3925
  create_maintenance_thread();

3926 3927 3928
  if (Events::init(opt_noacl))
    unireg_abort(1);

3929
  sql_print_information(ER(ER_STARTUP),my_progname,server_version,
unknown's avatar
unknown committed
3930
                        ((unix_sock == INVALID_SOCKET) ? (char*) ""
unknown's avatar
Merge  
unknown committed
3931
                                                       : mysqld_unix_port),
unknown's avatar
unknown committed
3932
                         mysqld_port,
unknown's avatar
Merge  
unknown committed
3933
                         MYSQL_COMPILATION_COMMENT);
unknown's avatar
unknown committed
3934

unknown's avatar
unknown committed
3935 3936 3937 3938 3939 3940 3941

  /* Signal threads waiting for server to be started */
  pthread_mutex_lock(&LOCK_server_started);
  mysqld_server_started= 1;
  pthread_cond_signal(&COND_server_started);
  pthread_mutex_unlock(&LOCK_server_started);

3942 3943
#if defined(__NT__) || defined(HAVE_SMEM)
  handle_connections_methods();
unknown's avatar
unknown committed
3944
#else
unknown's avatar
unknown committed
3945
#ifdef __WIN__
unknown's avatar
Merge  
unknown committed
3946
  if (!have_tcpip || opt_disable_networking)
unknown's avatar
unknown committed
3947
  {
unknown's avatar
unknown committed
3948
    sql_print_error("TCP/IP unavailable or disabled with --skip-networking; no available interfaces");
unknown's avatar
unknown committed
3949 3950 3951
    unireg_abort(1);
  }
#endif
unknown's avatar
unknown committed
3952 3953 3954 3955
  handle_connections_sockets(0);
#endif /* __NT__ */

  /* (void) pthread_attr_destroy(&connection_attrib); */
3956
  
unknown's avatar
unknown committed
3957 3958 3959
  DBUG_PRINT("quit",("Exiting main thread"));

#ifndef __WIN__
unknown's avatar
unknown committed
3960
#ifdef EXTRA_DEBUG2
unknown's avatar
unknown committed
3961 3962 3963
  sql_print_error("Before Lock_thread_count");
#endif
  (void) pthread_mutex_lock(&LOCK_thread_count);
unknown's avatar
unknown committed
3964
  DBUG_PRINT("quit", ("Got thread_count mutex"));
unknown's avatar
unknown committed
3965 3966
  select_thread_in_use=0;			// For close_connections
  (void) pthread_mutex_unlock(&LOCK_thread_count);
3967
  (void) pthread_cond_broadcast(&COND_thread_count);
unknown's avatar
unknown committed
3968
#ifdef EXTRA_DEBUG2
unknown's avatar
unknown committed
3969 3970
  sql_print_error("After lock_thread_count");
#endif
unknown's avatar
merge  
unknown committed
3971
#endif /* __WIN__ */
3972

unknown's avatar
unknown committed
3973 3974 3975 3976 3977
  /* 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
3978

3979
  release_ddl_log();
unknown's avatar
merge  
unknown committed
3980
#if defined(__WIN__) && !defined(EMBEDDED_LIBRARY)
unknown's avatar
merge  
unknown committed
3981 3982 3983 3984
  if (Service.IsNT() && start_mode)
    Service.Stop();
  else
  {
unknown's avatar
unknown committed
3985
    Service.SetShutdownEvent(0);
unknown's avatar
merge  
unknown committed
3986 3987 3988
    if (hEventShutdown)
      CloseHandle(hEventShutdown);
  }
unknown's avatar
unknown committed
3989
#endif
unknown's avatar
unknown committed
3990
  clean_up(1);
3991
  wait_for_signal_thread_to_end();
unknown's avatar
unknown committed
3992
  clean_up_mutexes();
unknown's avatar
unknown committed
3993
  my_end(opt_endinfo ? MY_CHECK_ERROR | MY_GIVE_INFO : 0);
3994

unknown's avatar
unknown committed
3995 3996 3997 3998
  exit(0);
  return(0);					/* purecov: deadcode */
}

3999
#endif /* EMBEDDED_LIBRARY */
unknown's avatar
unknown committed
4000

unknown's avatar
SCRUM  
unknown committed
4001

4002 4003 4004 4005 4006
/****************************************************************************
  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
4007
#if defined(__WIN__) && !defined(EMBEDDED_LIBRARY)
unknown's avatar
unknown committed
4008 4009
int mysql_service(void *p)
{
4010 4011 4012 4013
  if (use_opt_args)
    win_main(opt_argc, opt_argv);
  else
    win_main(Service.my_argc, Service.my_argv);
unknown's avatar
unknown committed
4014 4015 4016
  return 0;
}

4017 4018 4019 4020 4021 4022 4023 4024

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

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

  if (!strchr(from, ' '))
unknown's avatar
unknown committed
4025 4026
    return strmake(to, from, length-1);
  return strxnmov(to, length-1, "\"", from, "\"", NullS);
4027 4028 4029
}


4030 4031 4032 4033 4034
/*
  Handle basic handling of services, like installation and removal

  SYNOPSIS
    default_service_handling()
4035
    argv		Pointer to argument list
4036 4037 4038
    servicename		Internal name of service
    displayname		Display name of service (in taskbar ?)
    file_path		Path to this program
4039
    startup_option	Startup option to mysqld
4040 4041 4042 4043 4044 4045

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

4046 4047 4048 4049 4050
static bool
default_service_handling(char **argv,
			 const char *servicename,
			 const char *displayname,
			 const char *file_path,
unknown's avatar
Merge  
unknown committed
4051 4052
			 const char *extra_opt,
			 const char *account_name)
4053
{
4054
  char path_and_service[FN_REFLEN+FN_REFLEN+32], *pos, *end;
4055
  end= path_and_service + sizeof(path_and_service)-3;
4056 4057 4058 4059 4060 4061 4062 4063 4064

  /* 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);
  }
4065 4066
  /* We must have servicename last */
  *pos++= ' ';
unknown's avatar
unknown committed
4067
  (void) add_quoted_string(pos, servicename, end);
4068

4069 4070
  if (Service.got_service_option(argv, "install"))
  {
unknown's avatar
Merge  
unknown committed
4071 4072
    Service.Install(1, servicename, displayname, path_and_service,
                    account_name);
4073 4074 4075 4076
    return 0;
  }
  if (Service.got_service_option(argv, "install-manual"))
  {
unknown's avatar
Merge  
unknown committed
4077 4078
    Service.Install(0, servicename, displayname, path_and_service,
                    account_name);
4079 4080 4081 4082 4083 4084 4085 4086 4087 4088 4089
    return 0;
  }
  if (Service.got_service_option(argv, "remove"))
  {
    Service.Remove(servicename);
    return 0;
  }
  return 1;
}


unknown's avatar
unknown committed
4090 4091
int main(int argc, char **argv)
{
unknown's avatar
unknown committed
4092 4093 4094 4095
  /*
    When several instances are running on the same machine, we
    need to have an  unique  named  hEventShudown  through the
    application PID e.g.: MySQLShutdown1890; MySQLShutdown2342
unknown's avatar
Merge  
unknown committed
4096
  */
4097
  int10_to_str((int) GetCurrentProcessId(),strmov(shutdown_event_name,
unknown's avatar
Merge  
unknown committed
4098 4099
                                                  "MySQLShutdown"), 10);

4100 4101 4102
  /* Must be initialized early for comparison of service name */
  system_charset_info= &my_charset_utf8_general_ci;

unknown's avatar
unknown committed
4103
  if (Service.GetOS())	/* true NT family */
unknown's avatar
unknown committed
4104
  {
unknown's avatar
unknown committed
4105
    char file_path[FN_REFLEN];
4106
    my_path(file_path, argv[0], "");		      /* Find name in path */
unknown's avatar
unknown committed
4107 4108
    fn_format(file_path,argv[0],file_path,"",
	      MY_REPLACE_DIR | MY_UNPACK_FILENAME | MY_RESOLVE_SYMLINKS);
unknown's avatar
unknown committed
4109

unknown's avatar
unknown committed
4110
    if (argc == 2)
4111
    {
4112
      if (!default_service_handling(argv, MYSQL_SERVICENAME, MYSQL_SERVICENAME,
unknown's avatar
Merge  
unknown committed
4113
				   file_path, "", NULL))
4114
	return 0;
unknown's avatar
unknown committed
4115
      if (Service.IsService(argv[1]))        /* Start an optional service */
unknown's avatar
unknown committed
4116
      {
unknown's avatar
unknown committed
4117 4118 4119 4120 4121 4122
	/*
	  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.
	*/
4123
	if (my_strcasecmp(system_charset_info, argv[1],"mysql"))
4124
	  load_default_groups[load_default_groups_sz-2]= argv[1];
unknown's avatar
unknown committed
4125
        start_mode= 1;
4126
        Service.Init(argv[1], mysql_service);
unknown's avatar
unknown committed
4127 4128 4129 4130
        return 0;
      }
    }
    else if (argc == 3) /* install or remove any optional service */
unknown's avatar
unknown committed
4131
    {
unknown's avatar
Merge  
unknown committed
4132 4133
      if (!default_service_handling(argv, argv[2], argv[2], file_path, "",
                                    NULL))
4134 4135
	return 0;
      if (Service.IsService(argv[2]))
unknown's avatar
unknown committed
4136
      {
4137 4138 4139 4140
	/*
	  mysqld was started as
	  mysqld --defaults-file=my_path\my.ini service-name
	*/
4141
	use_opt_args=1;
4142
	opt_argc= 2;				// Skip service-name
4143 4144
	opt_argv=argv;
	start_mode= 1;
4145
	if (my_strcasecmp(system_charset_info, argv[2],"mysql"))
4146
	  load_default_groups[load_default_groups_sz-2]= argv[2];
4147
	Service.Init(argv[2], mysql_service);
4148
	return 0;
unknown's avatar
unknown committed
4149 4150
      }
    }
unknown's avatar
Merge  
unknown committed
4151
    else if (argc == 4 || argc == 5)
4152 4153
    {
      /*
unknown's avatar
Merge  
unknown committed
4154 4155 4156 4157 4158
        This may seem strange, because we handle --local-service while
        preserving 4.1's behavior of allowing any one other argument that is
        passed to the service on startup. (The assumption is that this is
        --defaults-file=file, but that was not enforced in 4.1, so we don't
        enforce it here.)
4159
      */
unknown's avatar
Merge  
unknown committed
4160 4161 4162 4163 4164 4165 4166 4167 4168 4169 4170 4171 4172 4173 4174
      const char *extra_opt= NullS;
      const char *account_name = NullS;
      int index;
      for (index = 3; index < argc; index++)
      {
        if (!strcmp(argv[index], "--local-service"))
          account_name= "NT AUTHORITY\\LocalService";
        else
          extra_opt= argv[index];
      }

      if (argc == 4 || account_name)
        if (!default_service_handling(argv, argv[2], argv[2], file_path,
                                      extra_opt, account_name))
          return 0;
4175
    }
unknown's avatar
unknown committed
4176
    else if (argc == 1 && Service.IsService(MYSQL_SERVICENAME))
unknown's avatar
unknown committed
4177
    {
unknown's avatar
unknown committed
4178 4179 4180
      /* start the default service */
      start_mode= 1;
      Service.Init(MYSQL_SERVICENAME, mysql_service);
unknown's avatar
unknown committed
4181 4182 4183
      return 0;
    }
  }
unknown's avatar
unknown committed
4184
  /* Start as standalone server */
unknown's avatar
unknown committed
4185 4186 4187 4188 4189 4190 4191 4192
  Service.my_argc=argc;
  Service.my_argv=argv;
  mysql_service(NULL);
  return 0;
}
#endif


4193 4194 4195 4196
/*
  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.
*/
4197

unknown's avatar
Merge  
unknown committed
4198
static void bootstrap(FILE *file)
unknown's avatar
unknown committed
4199
{
4200
  DBUG_ENTER("bootstrap");
4201

4202
  THD *thd= new THD;
unknown's avatar
unknown committed
4203
  thd->bootstrap=1;
unknown's avatar
unknown committed
4204
  my_net_init(&thd->net,(st_vio*) 0);
unknown's avatar
unknown committed
4205
  thd->max_client_packet_length= thd->net.max_packet;
4206
  thd->security_ctx->master_access= ~(ulong)0;
unknown's avatar
unknown committed
4207
  thd->thread_id= thd->variables.pseudo_thread_id= thread_id++;
unknown's avatar
unknown committed
4208
  thread_count++;
4209 4210

  bootstrap_file=file;
unknown's avatar
unknown committed
4211
#ifndef EMBEDDED_LIBRARY			// TODO:  Enable this
4212 4213 4214
  if (pthread_create(&thd->real_id,&connection_attrib,handle_bootstrap,
		     (void*) thd))
  {
4215
    sql_print_warning("Can't create thread to handle bootstrap");
unknown's avatar
Merge  
unknown committed
4216 4217
    bootstrap_error=-1;
    DBUG_VOID_RETURN;
4218 4219 4220 4221 4222 4223 4224 4225 4226
  }
  /* 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
4227 4228 4229 4230 4231
#else
  thd->mysql= 0;
  handle_bootstrap((void *)thd);
#endif

unknown's avatar
Merge  
unknown committed
4232
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
4233 4234
}

4235

unknown's avatar
unknown committed
4236 4237 4238 4239 4240 4241 4242
static bool read_init_file(char *file_name)
{
  FILE *file;
  DBUG_ENTER("read_init_file");
  DBUG_PRINT("enter",("name: %s",file_name));
  if (!(file=my_fopen(file_name,O_RDONLY,MYF(MY_WME))))
    return(1);
unknown's avatar
Merge  
unknown committed
4243
  bootstrap(file);
unknown's avatar
unknown committed
4244 4245 4246 4247 4248
  (void) my_fclose(file,MYF(MY_WME));
  return 0;
}


4249
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
4250 4251 4252 4253 4254 4255 4256 4257 4258 4259 4260 4261 4262 4263 4264 4265 4266 4267 4268 4269 4270 4271 4272 4273 4274 4275 4276 4277 4278 4279 4280 4281 4282 4283 4284 4285 4286 4287 4288 4289 4290 4291 4292 4293 4294 4295 4296 4297 4298 4299 4300 4301 4302 4303 4304 4305 4306 4307 4308 4309 4310 4311 4312 4313 4314 4315 4316 4317

/*
   Simple scheduler that use the main thread to handle the request

   NOTES
     This is only used for debugging, when starting mysqld with
     --thread-handling=no-threads or --one-thread

     When we enter this function, LOCK_thread_count is hold!
*/
   
void handle_connection_in_main_thread(THD *thd)
{
  safe_mutex_assert_owner(&LOCK_thread_count);
  thread_cache_size=0;			// Safety
  threads.append(thd);
  (void) pthread_mutex_unlock(&LOCK_thread_count);
  handle_one_connection((void*) thd);
}


/*
  Scheduler that uses one thread per connection
*/

void create_thread_to_handle_connection(THD *thd)
{
  if (cached_thread_count > wake_thread)
  {
    /* Get thread from cache */
    thread_cache.append(thd);
    wake_thread++;
    pthread_cond_signal(&COND_thread_cache);
  }
  else
  {
    /* Create new thread to handle connection */
    int error;
    thread_created++;
    threads.append(thd);
    DBUG_PRINT("info",(("creating thread %lu"), thd->thread_id));
    thd->connect_time = time(NULL);
    if ((error=pthread_create(&thd->real_id,&connection_attrib,
                              handle_one_connection,
                              (void*) thd)))
    {
      /* purify: begin inspected */
      DBUG_PRINT("error",
                 ("Can't create thread to handle request (error %d)",
                  error));
      thread_count--;
      thd->killed= THD::KILL_CONNECTION;			// Safety
      (void) pthread_mutex_unlock(&LOCK_thread_count);
      statistic_increment(aborted_connects,&LOCK_status);
      net_printf_error(thd, ER_CANT_CREATE_THREAD, error);
      (void) pthread_mutex_lock(&LOCK_thread_count);
      close_connection(thd,0,0);
      delete thd;
      (void) pthread_mutex_unlock(&LOCK_thread_count);
      return;
      /* purecov: end */
    }
  }
  (void) pthread_mutex_unlock(&LOCK_thread_count);
  DBUG_PRINT("info",("Thread created"));
}


4318 4319 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329 4330 4331 4332 4333 4334 4335 4336
/*
  Create new thread to handle incoming connection.

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

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

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

  RETURN VALUE
    none
*/

unknown's avatar
unknown committed
4337 4338
static void create_new_thread(THD *thd)
{
4339
  NET *net=&thd->net;
unknown's avatar
unknown committed
4340 4341 4342 4343 4344 4345 4346 4347
  DBUG_ENTER("create_new_thread");

  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
4348
    DBUG_PRINT("error",("Too many connections"));
4349
    close_connection(thd, ER_CON_COUNT_ERROR, 1);
unknown's avatar
unknown committed
4350 4351 4352
    delete thd;
    DBUG_VOID_RETURN;
  }
4353
  pthread_mutex_lock(&LOCK_thread_count);
unknown's avatar
unknown committed
4354
  thd->thread_id= thd->variables.pseudo_thread_id= thread_id++;
unknown's avatar
unknown committed
4355 4356

  /* Start a new thread to handle connection */
4357 4358
  thread_count++;

unknown's avatar
unknown committed
4359 4360
  if (thread_count - delayed_insert_threads > max_used_connections)
    max_used_connections= thread_count - delayed_insert_threads;
4361

unknown's avatar
unknown committed
4362
  thread_scheduler.add_connection(thd);
unknown's avatar
unknown committed
4363 4364
  DBUG_VOID_RETURN;
}
4365 4366
#endif /* EMBEDDED_LIBRARY */

unknown's avatar
unknown committed
4367

unknown's avatar
unknown committed
4368 4369 4370 4371
#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
4372 4373 4374 4375
  if (
#if !defined(__NETWARE__)
      unix_sock == INVALID_SOCKET ||
#endif
4376
      (!opt_disable_networking && ip_sock == INVALID_SOCKET))
unknown's avatar
unknown committed
4377 4378
  {
    select_thread_in_use = 0;
unknown's avatar
unknown committed
4379 4380
    /* The following call will never return */
    kill_server(IF_NETWARE(MYSQL_KILL_SIGNAL, (void*) MYSQL_KILL_SIGNAL));
unknown's avatar
unknown committed
4381 4382 4383 4384 4385 4386
  }
}
#define MAYBE_BROKEN_SYSCALL kill_broken_server();
#else
#define MAYBE_BROKEN_SYSCALL
#endif
unknown's avatar
unknown committed
4387 4388 4389

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

4390
#ifndef EMBEDDED_LIBRARY
4391
pthread_handler_t handle_connections_sockets(void *arg __attribute__((unused)))
unknown's avatar
unknown committed
4392 4393 4394 4395 4396 4397 4398 4399
{
  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
4400
  st_vio *vio_tmp;
unknown's avatar
unknown committed
4401 4402 4403 4404 4405 4406 4407 4408 4409 4410 4411 4412 4413 4414 4415 4416
  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
4417
#ifdef HAVE_FCNTL
unknown's avatar
unknown committed
4418
  socket_flags=fcntl(unix_sock, F_GETFL, 0);
unknown's avatar
unknown committed
4419
#endif
unknown's avatar
unknown committed
4420 4421 4422
#endif

  DBUG_PRINT("general",("Waiting for connections."));
unknown's avatar
unknown committed
4423
  MAYBE_BROKEN_SYSCALL;
unknown's avatar
unknown committed
4424 4425 4426
  while (!abort_loop)
  {
    readFDs=clientFDs;
4427
#ifdef HPUX10
unknown's avatar
unknown committed
4428 4429 4430 4431 4432
    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
4433
      if (socket_errno != SOCKET_EINTR)
unknown's avatar
unknown committed
4434 4435
      {
	if (!select_errors++ && !abort_loop)	/* purecov: inspected */
unknown's avatar
unknown committed
4436
	  sql_print_error("mysqld: Got error %d from select",socket_errno); /* purecov: inspected */
unknown's avatar
unknown committed
4437
      }
unknown's avatar
unknown committed
4438
      MAYBE_BROKEN_SYSCALL
unknown's avatar
unknown committed
4439 4440
      continue;
    }
4441
#endif	/* HPUX10 */
unknown's avatar
unknown committed
4442
    if (abort_loop)
unknown's avatar
unknown committed
4443 4444
    {
      MAYBE_BROKEN_SYSCALL;
unknown's avatar
unknown committed
4445
      break;
unknown's avatar
unknown committed
4446
    }
unknown's avatar
unknown committed
4447

4448
    /* Is this a new connection request ? */
unknown's avatar
unknown committed
4449 4450 4451 4452 4453 4454 4455 4456 4457 4458 4459 4460 4461 4462 4463 4464 4465 4466 4467 4468 4469 4470 4471 4472 4473 4474 4475 4476
#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
4477 4478 4479 4480 4481 4482 4483
#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
4484 4485
      if (new_sock != INVALID_SOCKET ||
	  (socket_errno != SOCKET_EINTR && socket_errno != SOCKET_EAGAIN))
unknown's avatar
unknown committed
4486
	break;
unknown's avatar
unknown committed
4487
      MAYBE_BROKEN_SYSCALL;
unknown's avatar
unknown committed
4488 4489 4490 4491 4492 4493 4494 4495 4496 4497 4498 4499
#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
4500
    if (new_sock == INVALID_SOCKET)
unknown's avatar
unknown committed
4501 4502 4503
    {
      if ((error_count++ & 255) == 0)		// This can happen often
	sql_perror("Error in accept");
unknown's avatar
unknown committed
4504
      MAYBE_BROKEN_SYSCALL;
unknown's avatar
unknown committed
4505
      if (socket_errno == SOCKET_ENFILE || socket_errno == SOCKET_EMFILE)
unknown's avatar
unknown committed
4506 4507 4508 4509 4510 4511 4512 4513 4514 4515 4516
	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);
4517 4518
	my_fromhost(&req);
	if (!my_hosts_access(&req))
unknown's avatar
unknown committed
4519
	{
unknown's avatar
unknown committed
4520 4521 4522 4523 4524
	  /*
	    This may be stupid but refuse() includes an exit(0)
	    which we surely don't want...
	    clean_exit() - same stupid thing ...
	  */
4525
	  syslog(deny_severity, "refused connect from %s",
4526
		 my_eval_client(&req));
unknown's avatar
unknown committed
4527

unknown's avatar
unknown committed
4528 4529 4530 4531 4532 4533
	  /*
	    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
4534 4535 4536
	  if (req.sink)
	    ((void (*)(int))req.sink)(req.fd);

4537
	  (void) shutdown(new_sock, SHUT_RDWR);
unknown's avatar
unknown committed
4538 4539 4540 4541 4542 4543 4544 4545 4546 4547 4548 4549 4550 4551
	  (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");
4552
	(void) shutdown(new_sock, SHUT_RDWR);
unknown's avatar
unknown committed
4553 4554 4555 4556 4557 4558 4559 4560 4561 4562 4563
	(void) closesocket(new_sock);
	continue;
      }
    }

    /*
    ** Don't allow too many connections
    */

    if (!(thd= new THD))
    {
4564
      (void) shutdown(new_sock, SHUT_RDWR);
unknown's avatar
unknown committed
4565
      VOID(closesocket(new_sock));
unknown's avatar
unknown committed
4566 4567 4568
      continue;
    }
    if (!(vio_tmp=vio_new(new_sock,
4569
			  sock == unix_sock ? VIO_TYPE_SOCKET :
unknown's avatar
unknown committed
4570
			  VIO_TYPE_TCPIP,
4571
			  sock == unix_sock ? VIO_LOCALHOST: 0)) ||
unknown's avatar
unknown committed
4572 4573 4574 4575 4576 4577
	my_net_init(&thd->net,vio_tmp))
    {
      if (vio_tmp)
	vio_delete(vio_tmp);
      else
      {
4578
	(void) shutdown(new_sock, SHUT_RDWR);
unknown's avatar
unknown committed
4579 4580 4581 4582 4583 4584
	(void) closesocket(new_sock);
      }
      delete thd;
      continue;
    }
    if (sock == unix_sock)
4585
      thd->security_ctx->host=(char*) my_localhost;
4586

unknown's avatar
unknown committed
4587 4588 4589
    create_new_thread(thd);
  }

4590
  decrement_handler_count();
unknown's avatar
unknown committed
4591 4592 4593 4594 4595
  DBUG_RETURN(0);
}


#ifdef __NT__
4596
pthread_handler_t handle_connections_namedpipes(void *arg)
unknown's avatar
unknown committed
4597 4598 4599 4600 4601 4602 4603 4604 4605 4606 4607 4608
{
  HANDLE hConnectedPipe;
  BOOL fConnected;
  THD *thd;
  my_thread_init();
  DBUG_ENTER("handle_connections_namedpipes");
  (void) my_pthread_getprio(pthread_self());		// For debugging

  DBUG_PRINT("general",("Waiting for named pipe connections."));
  while (!abort_loop)
  {
    /* wait for named pipe connection */
unknown's avatar
Merge  
unknown committed
4609
    fConnected = ConnectNamedPipe(hPipe, NULL);
unknown's avatar
unknown committed
4610 4611
    if (abort_loop)
      break;
unknown's avatar
unknown committed
4612
    if (!fConnected)
unknown's avatar
unknown committed
4613
      fConnected = GetLastError() == ERROR_PIPE_CONNECTED;
unknown's avatar
unknown committed
4614
    if (!fConnected)
unknown's avatar
unknown committed
4615
    {
unknown's avatar
Merge  
unknown committed
4616 4617 4618 4619 4620 4621 4622 4623 4624 4625 4626 4627 4628 4629
      CloseHandle(hPipe);
      if ((hPipe= CreateNamedPipe(pipe_name,
                                  PIPE_ACCESS_DUPLEX,
                                  PIPE_TYPE_BYTE |
                                  PIPE_READMODE_BYTE |
                                  PIPE_WAIT,
                                  PIPE_UNLIMITED_INSTANCES,
                                  (int) global_system_variables.
                                  net_buffer_length,
                                  (int) global_system_variables.
                                  net_buffer_length,
                                  NMPWAIT_USE_DEFAULT_WAIT,
                                  &saPipeSecurity)) ==
	  INVALID_HANDLE_VALUE)
unknown's avatar
unknown committed
4630 4631 4632 4633 4634 4635 4636
      {
	sql_perror("Can't create new named pipe!");
	break;					// Abort
      }
    }
    hConnectedPipe = hPipe;
    /* create new pipe for new connection */
4637
    if ((hPipe = CreateNamedPipe(pipe_name,
unknown's avatar
unknown committed
4638 4639 4640 4641 4642
				 PIPE_ACCESS_DUPLEX,
				 PIPE_TYPE_BYTE |
				 PIPE_READMODE_BYTE |
				 PIPE_WAIT,
				 PIPE_UNLIMITED_INSTANCES,
4643 4644
				 (int) global_system_variables.net_buffer_length,
				 (int) global_system_variables.net_buffer_length,
unknown's avatar
unknown committed
4645 4646 4647 4648 4649 4650 4651 4652 4653
				 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
4654
    if (!(thd = new THD))
unknown's avatar
unknown committed
4655
    {
unknown's avatar
Merge  
unknown committed
4656 4657
      DisconnectNamedPipe(hConnectedPipe);
      CloseHandle(hConnectedPipe);
unknown's avatar
unknown committed
4658 4659 4660 4661 4662
      continue;
    }
    if (!(thd->net.vio = vio_new_win32pipe(hConnectedPipe)) ||
	my_net_init(&thd->net, thd->net.vio))
    {
4663
      close_connection(thd, ER_OUT_OF_RESOURCES, 1);
unknown's avatar
unknown committed
4664 4665 4666
      delete thd;
      continue;
    }
4667 4668
    /* Host is unknown */
    thd->security_ctx->host= my_strdup(my_localhost, MYF(0));
unknown's avatar
unknown committed
4669 4670 4671
    create_new_thread(thd);
  }

4672
  decrement_handler_count();
unknown's avatar
unknown committed
4673 4674 4675 4676
  DBUG_RETURN(0);
}
#endif /* __NT__ */

4677

4678
/*
4679 4680 4681
  Thread of shared memory's service

  SYNOPSIS
4682
    handle_connections_shared_memory()
4683 4684
    arg                              Arguments of thread
*/
4685

4686
#ifdef HAVE_SMEM
4687
pthread_handler_t handle_connections_shared_memory(void *arg)
4688
{
4689 4690
  /* file-mapping object, use for create shared memory */
  HANDLE handle_connect_file_map= 0;
4691
  char  *handle_connect_map= 0;                 // pointer on shared memory
4692 4693 4694
  HANDLE event_connect_answer= 0;
  ulong smem_buffer_length= shared_memory_buffer_length + 4;
  ulong connect_number= 1;
4695
  char *tmp= NULL;
4696 4697
  char *suffix_pos;
  char connect_number_char[22], *p;
4698
  const char *errmsg= 0;
4699
  SECURITY_ATTRIBUTES *sa_event= 0, *sa_mapping= 0;
4700 4701 4702 4703
  my_thread_init();
  DBUG_ENTER("handle_connections_shared_memorys");
  DBUG_PRINT("general",("Waiting for allocated shared memory."));

4704 4705 4706 4707 4708 4709
  /*
     get enough space base-name + '_' + longest suffix we might ever send
   */
  if (!(tmp= (char *)my_malloc(strlen(shared_memory_base_name) + 32L, MYF(MY_FAE))))
    goto error;

4710 4711 4712 4713 4714 4715 4716 4717
  if (my_security_attr_create(&sa_event, &errmsg,
                              GENERIC_ALL, SYNCHRONIZE | EVENT_MODIFY_STATE))
    goto error;

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

4718 4719 4720 4721 4722 4723 4724
  /*
    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)
  */
4725
  suffix_pos= strxmov(tmp,shared_memory_base_name,"_",NullS);
4726
  strmov(suffix_pos, "CONNECT_REQUEST");
4727 4728
  if ((smem_event_connect_request= CreateEvent(sa_event,
                                               FALSE, FALSE, tmp)) == 0)
4729
  {
4730
    errmsg= "Could not create request event";
4731 4732
    goto error;
  }
4733
  strmov(suffix_pos, "CONNECT_ANSWER");
4734
  if ((event_connect_answer= CreateEvent(sa_event, FALSE, FALSE, tmp)) == 0)
4735
  {
4736
    errmsg="Could not create answer event";
4737 4738
    goto error;
  }
4739
  strmov(suffix_pos, "CONNECT_DATA");
4740 4741 4742
  if ((handle_connect_file_map=
       CreateFileMapping(INVALID_HANDLE_VALUE, sa_mapping,
                         PAGE_READWRITE, 0, sizeof(connect_number), tmp)) == 0)
4743
  {
4744
    errmsg= "Could not create file mapping";
4745 4746
    goto error;
  }
4747 4748 4749
  if ((handle_connect_map= (char *)MapViewOfFile(handle_connect_file_map,
						  FILE_MAP_WRITE,0,0,
						  sizeof(DWORD))) == 0)
4750
  {
4751
    errmsg= "Could not create shared memory service";
4752 4753 4754 4755 4756
    goto error;
  }

  while (!abort_loop)
  {
4757
    /* Wait a request from client */
4758
    WaitForSingleObject(smem_event_connect_request,INFINITE);
4759

unknown's avatar
unknown committed
4760 4761 4762
    /*
       it can be after shutdown command
    */
unknown's avatar
Merge  
unknown committed
4763
    if (abort_loop)
unknown's avatar
unknown committed
4764
      goto error;
4765

4766 4767 4768 4769 4770 4771
    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
4772
    HANDLE event_conn_closed= 0;
4773
    THD *thd= 0;
4774

4775
    p= int10_to_str(connect_number, connect_number_char, 10);
4776 4777 4778 4779 4780 4781 4782 4783 4784 4785
    /*
      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);
4786
    strmov(suffix_pos, "DATA");
4787 4788 4789
    if ((handle_client_file_map=
         CreateFileMapping(INVALID_HANDLE_VALUE, sa_mapping,
                           PAGE_READWRITE, 0, smem_buffer_length, tmp)) == 0)
4790
    {
4791
      errmsg= "Could not create file mapping";
4792 4793
      goto errorconn;
    }
4794 4795 4796
    if ((handle_client_map= (char*)MapViewOfFile(handle_client_file_map,
						  FILE_MAP_WRITE,0,0,
						  smem_buffer_length)) == 0)
4797
    {
4798
      errmsg= "Could not create memory map";
4799 4800 4801
      goto errorconn;
    }
    strmov(suffix_pos, "CLIENT_WROTE");
4802
    if ((event_client_wrote= CreateEvent(sa_event, FALSE, FALSE, tmp)) == 0)
4803
    {
4804
      errmsg= "Could not create client write event";
4805 4806 4807
      goto errorconn;
    }
    strmov(suffix_pos, "CLIENT_READ");
4808
    if ((event_client_read= CreateEvent(sa_event, FALSE, FALSE, tmp)) == 0)
4809
    {
4810
      errmsg= "Could not create client read event";
4811 4812 4813
      goto errorconn;
    }
    strmov(suffix_pos, "SERVER_READ");
4814
    if ((event_server_read= CreateEvent(sa_event, FALSE, FALSE, tmp)) == 0)
4815
    {
4816
      errmsg= "Could not create server read event";
4817 4818 4819
      goto errorconn;
    }
    strmov(suffix_pos, "SERVER_WROTE");
4820 4821
    if ((event_server_wrote= CreateEvent(sa_event,
                                         FALSE, FALSE, tmp)) == 0)
4822
    {
4823
      errmsg= "Could not create server write event";
4824 4825
      goto errorconn;
    }
unknown's avatar
unknown committed
4826
    strmov(suffix_pos, "CONNECTION_CLOSED");
4827 4828
    if ((event_conn_closed= CreateEvent(sa_event,
                                        TRUE, FALSE, tmp)) == 0)
unknown's avatar
unknown committed
4829 4830 4831 4832
    {
      errmsg= "Could not create closed connection event";
      goto errorconn;
    }
4833
    if (abort_loop)
4834
      goto errorconn;
4835 4836 4837
    if (!(thd= new THD))
      goto errorconn;
    /* Send number of connection to client */
4838
    int4store(handle_connect_map, connect_number);
4839
    if (!SetEvent(event_connect_answer))
4840
    {
4841
      errmsg= "Could not send answer event";
4842 4843
      goto errorconn;
    }
4844
    /* Set event that client should receive data */
4845 4846
    if (!SetEvent(event_client_read))
    {
4847
      errmsg= "Could not set client to read mode";
4848 4849
      goto errorconn;
    }
4850
    if (!(thd->net.vio= vio_new_win32shared_memory(&thd->net,
unknown's avatar
unknown committed
4851 4852 4853 4854 4855 4856
                                                   handle_client_file_map,
                                                   handle_client_map,
                                                   event_client_wrote,
                                                   event_client_read,
                                                   event_server_wrote,
                                                   event_server_read,
unknown's avatar
unknown committed
4857
                                                   event_conn_closed)) ||
unknown's avatar
unknown committed
4858
                        my_net_init(&thd->net, thd->net.vio))
4859
    {
4860
      close_connection(thd, ER_OUT_OF_RESOURCES, 1);
4861 4862
      errmsg= 0;
      goto errorconn;
4863
    }
4864
    thd->security_ctx->host= my_strdup(my_localhost, MYF(0)); /* Host is unknown */
4865
    create_new_thread(thd);
4866 4867 4868 4869 4870 4871 4872 4873 4874 4875 4876 4877
    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
4878 4879 4880 4881 4882 4883 4884 4885 4886 4887 4888 4889 4890 4891
    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);
4892
    delete thd;
4893
  }
4894 4895

  /* End shared memory handling */
4896
error:
4897 4898 4899
  if (tmp)
    my_free(tmp, MYF(0));

4900 4901 4902 4903 4904 4905
  if (errmsg)
  {
    char buff[180];
    strxmov(buff, "Can't create shared memory service: ", errmsg, ".", NullS);
    sql_perror(buff);
  }
4906 4907
  my_security_attr_free(sa_event);
  my_security_attr_free(sa_mapping);
4908 4909 4910
  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);
4911
  if (smem_event_connect_request) CloseHandle(smem_event_connect_request);
4912 4913

  decrement_handler_count();
4914 4915 4916
  DBUG_RETURN(0);
}
#endif /* HAVE_SMEM */
4917
#endif /* EMBEDDED_LIBRARY */
unknown's avatar
unknown committed
4918

4919 4920 4921

/****************************************************************************
  Handle start options
unknown's avatar
unknown committed
4922 4923
******************************************************************************/

unknown's avatar
unknown committed
4924
enum options_mysqld
4925
{
4926 4927 4928
  OPT_ISAM_LOG=256,            OPT_SKIP_NEW, 
  OPT_SKIP_GRANT,              OPT_SKIP_LOCK, 
  OPT_ENABLE_LOCK,             OPT_USE_LOCKING,
4929 4930
  OPT_SOCKET,                  OPT_UPDATE_LOG,
  OPT_BIN_LOG,                 OPT_SKIP_RESOLVE,
4931 4932
  OPT_SKIP_NETWORKING,         OPT_BIN_LOG_INDEX,
  OPT_BIND_ADDRESS,            OPT_PID_FILE,
4933
  OPT_SKIP_PRIOR,              OPT_BIG_TABLES,
4934 4935
  OPT_STANDALONE,              OPT_ONE_THREAD,
  OPT_CONSOLE,                 OPT_LOW_PRIORITY_UPDATES,
4936
  OPT_SKIP_HOST_CACHE,         OPT_SHORT_LOG_FORMAT,
4937
  OPT_FLUSH,                   OPT_SAFE,
4938
  OPT_BOOTSTRAP,               OPT_SKIP_SHOW_DB,
unknown's avatar
unknown committed
4939
  OPT_STORAGE_ENGINE,          OPT_INIT_FILE,
4940
  OPT_DELAY_KEY_WRITE_ALL,     OPT_SLOW_QUERY_LOG,
4941
  OPT_DELAY_KEY_WRITE,	       OPT_CHARSETS_DIR,
4942 4943 4944
  OPT_MASTER_HOST,             OPT_MASTER_USER,
  OPT_MASTER_PASSWORD,         OPT_MASTER_PORT,
  OPT_MASTER_INFO_FILE,        OPT_MASTER_CONNECT_RETRY,
unknown's avatar
Merge  
unknown committed
4945
  OPT_MASTER_RETRY_COUNT,      OPT_LOG_TC, OPT_LOG_TC_SIZE,
unknown's avatar
unknown committed
4946 4947
  OPT_MASTER_SSL,              OPT_MASTER_SSL_KEY,
  OPT_MASTER_SSL_CERT,         OPT_MASTER_SSL_CAPATH,
unknown's avatar
unknown committed
4948
  OPT_MASTER_SSL_CIPHER,       OPT_MASTER_SSL_CA,
4949
  OPT_SQL_BIN_UPDATE_SAME,     OPT_REPLICATE_DO_DB,
4950 4951
  OPT_REPLICATE_IGNORE_DB,     OPT_LOG_SLAVE_UPDATES,
  OPT_BINLOG_DO_DB,            OPT_BINLOG_IGNORE_DB,
4952 4953 4954 4955 4956
  OPT_BINLOG_FORMAT,
#ifndef DBUG_OFF
  OPT_BINLOG_SHOW_XID,
#endif
  OPT_BINLOG_ROWS_EVENT_MAX_SIZE, 
4957 4958
  OPT_WANT_CORE,               OPT_CONCURRENT_INSERT,
  OPT_MEMLOCK,                 OPT_MYISAM_RECOVER,
4959
  OPT_REPLICATE_REWRITE_DB,    OPT_SERVER_ID,
unknown's avatar
unknown committed
4960
  OPT_SKIP_SLAVE_START,        OPT_SAFE_SHOW_DB, 
4961 4962
  OPT_SAFEMALLOC_MEM_LIMIT,    OPT_REPLICATE_DO_TABLE,
  OPT_REPLICATE_IGNORE_TABLE,  OPT_REPLICATE_WILD_DO_TABLE,
4963
  OPT_REPLICATE_WILD_IGNORE_TABLE, OPT_REPLICATE_SAME_SERVER_ID,
unknown's avatar
Merge  
unknown committed
4964
  OPT_DISCONNECT_SLAVE_EVENT_COUNT, OPT_TC_HEURISTIC_RECOVER,
4965
  OPT_ABORT_SLAVE_EVENT_COUNT,
4966
  OPT_LOG_BIN_TRUST_FUNCTION_CREATORS,
unknown's avatar
unknown committed
4967
  OPT_ENGINE_CONDITION_PUSHDOWN, OPT_NDB_CONNECTSTRING, 
unknown's avatar
unknown committed
4968
  OPT_NDB_USE_EXACT_COUNT, OPT_NDB_USE_TRANSACTIONS,
4969
  OPT_NDB_FORCE_SEND, OPT_NDB_AUTOINCREMENT_PREFETCH_SZ,
unknown's avatar
Merge  
unknown committed
4970 4971
  OPT_NDB_SHM, OPT_NDB_OPTIMIZED_NODE_SELECTION, OPT_NDB_CACHE_CHECK_TIME,
  OPT_NDB_MGMD, OPT_NDB_NODEID,
unknown's avatar
unknown committed
4972
  OPT_NDB_DISTRIBUTION,
4973
  OPT_NDB_INDEX_STAT_ENABLE,
unknown's avatar
unknown committed
4974 4975 4976
  OPT_NDB_EXTRA_LOGGING,
  OPT_NDB_REPORT_THRESH_BINLOG_EPOCH_SLIP,
  OPT_NDB_REPORT_THRESH_BINLOG_MEM_USAGE,
4977
  OPT_NDB_USE_COPYING_ALTER_TABLE,
4978
  OPT_SKIP_SAFEMALLOC,
unknown's avatar
Merge  
unknown committed
4979
  OPT_TEMP_POOL, OPT_TX_ISOLATION, OPT_COMPLETION_TYPE,
4980 4981 4982 4983
  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,
4984
  OPT_DO_PSTACK, OPT_EVENT_SCHEDULER, OPT_REPORT_HOST,
4985
  OPT_REPORT_USER, OPT_REPORT_PASSWORD, OPT_REPORT_PORT,
4986
  OPT_SHOW_SLAVE_AUTH_INFO,
4987 4988 4989 4990 4991 4992 4993 4994 4995
  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
4996
  OPT_FLUSH_TIME, OPT_FT_MIN_WORD_LEN, OPT_FT_BOOLEAN_SYNTAX,
4997
  OPT_FT_MAX_WORD_LEN, OPT_FT_QUERY_EXPANSION_LIMIT, OPT_FT_STOPWORD_FILE,
4998
  OPT_INTERACTIVE_TIMEOUT, OPT_JOIN_BUFF_SIZE,
4999 5000 5001
  OPT_KEY_BUFFER_SIZE, OPT_KEY_CACHE_BLOCK_SIZE,
  OPT_KEY_CACHE_DIVISION_LIMIT, OPT_KEY_CACHE_AGE_THRESHOLD,
  OPT_LONG_QUERY_TIME,
5002 5003 5004 5005
  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,
5006 5007
  OPT_MAX_JOIN_SIZE, OPT_MAX_PREPARED_STMT_COUNT,
  OPT_MAX_RELAY_LOG_SIZE, OPT_MAX_SORT_LENGTH,
5008
  OPT_MAX_SEEKS_FOR_KEY, OPT_MAX_TMP_TABLES, OPT_MAX_USER_CONNECTIONS,
unknown's avatar
unknown committed
5009
  OPT_MAX_LENGTH_FOR_SORT_DATA,
unknown's avatar
unknown committed
5010
  OPT_MAX_WRITE_LOCK_COUNT, OPT_BULK_INSERT_BUFFER_SIZE,
unknown's avatar
Merge  
unknown committed
5011
  OPT_MAX_ERROR_COUNT, OPT_MULTI_RANGE_COUNT, OPT_MYISAM_DATA_POINTER_SIZE,
5012 5013
  OPT_MYISAM_BLOCK_SIZE, OPT_MYISAM_MAX_EXTRA_SORT_FILE_SIZE,
  OPT_MYISAM_MAX_SORT_FILE_SIZE, OPT_MYISAM_SORT_BUFFER_SIZE,
unknown's avatar
unknown committed
5014
  OPT_MYISAM_USE_MMAP,
5015
  OPT_MYISAM_STATS_METHOD,
5016 5017
  OPT_NET_BUFFER_LENGTH, OPT_NET_RETRY_COUNT,
  OPT_NET_READ_TIMEOUT, OPT_NET_WRITE_TIMEOUT,
5018
  OPT_OPEN_FILES_LIMIT,
unknown's avatar
unknown committed
5019
  OPT_PRELOAD_BUFFER_SIZE,
5020
  OPT_QUERY_CACHE_LIMIT, OPT_QUERY_CACHE_MIN_RES_UNIT, OPT_QUERY_CACHE_SIZE,
5021
  OPT_QUERY_CACHE_TYPE, OPT_QUERY_CACHE_WLOCK_INVALIDATE, OPT_RECORD_BUFFER,
unknown's avatar
unknown committed
5022 5023
  OPT_RECORD_RND_BUFFER, OPT_DIV_PRECINCREMENT, OPT_RELAY_LOG_SPACE_LIMIT,
  OPT_RELAY_LOG_PURGE,
5024
  OPT_SLAVE_NET_TIMEOUT, OPT_SLAVE_COMPRESSED_PROTOCOL, OPT_SLOW_LAUNCH_TIME,
5025
  OPT_SLAVE_TRANS_RETRIES, OPT_READONLY, OPT_DEBUGGING,
unknown's avatar
unknown committed
5026
  OPT_SORT_BUFFER, OPT_TABLE_OPEN_CACHE, OPT_TABLE_DEF_CACHE,
5027 5028
  OPT_THREAD_CONCURRENCY, OPT_THREAD_CACHE_SIZE,
  OPT_TMP_TABLE_SIZE, OPT_THREAD_STACK,
5029
  OPT_WAIT_TIMEOUT, OPT_MYISAM_REPAIR_THREADS,
unknown's avatar
merge  
unknown committed
5030
  OPT_ERROR_LOG_FILE,
5031
  OPT_DEFAULT_WEEK_FORMAT,
5032
  OPT_RANGE_ALLOC_BLOCK_SIZE, OPT_ALLOW_SUSPICIOUS_UDFS,
5033
  OPT_QUERY_ALLOC_BLOCK_SIZE, OPT_QUERY_PREALLOC_SIZE,
5034
  OPT_TRANS_ALLOC_BLOCK_SIZE, OPT_TRANS_PREALLOC_SIZE,
5035 5036 5037 5038
  OPT_SYNC_FRM, OPT_SYNC_BINLOG,
  OPT_SYNC_REPLICATION,
  OPT_SYNC_REPLICATION_SLAVE_ID,
  OPT_SYNC_REPLICATION_TIMEOUT,
5039
  OPT_ENABLE_SHARED_MEMORY,
unknown's avatar
unknown committed
5040
  OPT_SHARED_MEMORY_BASE_NAME,
5041
  OPT_OLD_PASSWORDS,
unknown's avatar
unknown committed
5042
  OPT_OLD_ALTER_TABLE,
unknown's avatar
unknown committed
5043
  OPT_EXPIRE_LOGS_DAYS,
5044
  OPT_GROUP_CONCAT_MAX_LEN,
5045
  OPT_DEFAULT_COLLATION,
5046
  OPT_CHARACTER_SET_CLIENT_HANDSHAKE,
unknown's avatar
unknown committed
5047
  OPT_CHARACTER_SET_FILESYSTEM,
5048
  OPT_LC_TIME_NAMES,
unknown's avatar
unknown committed
5049
  OPT_INIT_CONNECT,
unknown's avatar
unknown committed
5050
  OPT_INIT_SLAVE,
5051
  OPT_SECURE_AUTH,
5052 5053
  OPT_DATE_FORMAT,
  OPT_TIME_FORMAT,
unknown's avatar
unknown committed
5054
  OPT_DATETIME_FORMAT,
5055
  OPT_LOG_QUERIES_NOT_USING_INDEXES,
unknown's avatar
Merge  
unknown committed
5056
  OPT_DEFAULT_TIME_ZONE,
5057
  OPT_SYSDATE_IS_NOW,
unknown's avatar
Merge  
unknown committed
5058 5059 5060 5061
  OPT_OPTIMIZER_SEARCH_DEPTH,
  OPT_OPTIMIZER_PRUNE_LEVEL,
  OPT_UPDATABLE_VIEWS_WITH_LIMIT,
  OPT_SP_AUTOMATIC_PRIVILEGES,
5062
  OPT_MAX_SP_RECURSION_DEPTH,
unknown's avatar
Merge  
unknown committed
5063 5064 5065
  OPT_AUTO_INCREMENT, OPT_AUTO_INCREMENT_OFFSET,
  OPT_ENABLE_LARGE_PAGES,
  OPT_TIMED_MUTEXES,
unknown's avatar
unknown committed
5066
  OPT_OLD_STYLE_USER_LIMITS,
5067
  OPT_LOG_SLOW_ADMIN_STATEMENTS,
5068
  OPT_TABLE_LOCK_WAIT_TIMEOUT,
unknown's avatar
unknown committed
5069
  OPT_PLUGIN_LOAD,
5070
  OPT_PLUGIN_DIR,
5071
  OPT_LOG_OUTPUT,
5072 5073
  OPT_PORT_OPEN_TIMEOUT,
  OPT_GENERAL_LOG,
5074
  OPT_SLOW_LOG,
unknown's avatar
unknown committed
5075
  OPT_THREAD_HANDLING,
5076
  OPT_INNODB_ROLLBACK_ON_TIMEOUT,
5077
  OPT_SECURE_FILE_PRIV,
5078
  OPT_OLD_MODE
unknown's avatar
unknown committed
5079
};
5080

5081 5082 5083

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

unknown's avatar
unknown committed
5084
struct my_option my_long_options[] =
5085
{
unknown's avatar
unknown committed
5086
  {"help", '?', "Display this help and exit.", 
5087
   (uchar**) &opt_help, (uchar**) &opt_help, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
unknown's avatar
unknown committed
5088 5089 5090 5091
   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.",
5092
   (uchar**) &abort_slave_event_count,  (uchar**) &abort_slave_event_count,
unknown's avatar
unknown committed
5093 5094
   0, GET_INT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
#endif /* HAVE_REPLICATION */
5095
  {"allow-suspicious-udfs", OPT_ALLOW_SUSPICIOUS_UDFS,
unknown's avatar
unknown committed
5096 5097
   "Allows use of UDFs consisting of only one symbol xxx() "
   "without corresponding xxx_init() or xxx_deinit(). That also means "
5098 5099
   "that one can load any function from any library, for example exit() "
   "from libc.so",
5100
   (uchar**) &opt_allow_suspicious_udfs, (uchar**) &opt_allow_suspicious_udfs,
5101
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5102 5103
  {"ansi", 'a', "Use ANSI SQL syntax instead of MySQL syntax. This mode will also set transaction isolation level 'serializable'.", 0, 0, 0,
   GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
Merge  
unknown committed
5104 5105
  {"auto-increment-increment", OPT_AUTO_INCREMENT,
   "Auto-increment columns are incremented by this",
5106 5107
   (uchar**) &global_system_variables.auto_increment_increment,
   (uchar**) &max_system_variables.auto_increment_increment, 0, GET_ULONG,
unknown's avatar
Merge  
unknown committed
5108 5109 5110
   OPT_ARG, 1, 1, 65535, 0, 1, 0 },
  {"auto-increment-offset", OPT_AUTO_INCREMENT_OFFSET,
   "Offset added to Auto-increment columns. Used when auto-increment-increment != 1",
5111 5112
   (uchar**) &global_system_variables.auto_increment_offset,
   (uchar**) &max_system_variables.auto_increment_offset, 0, GET_ULONG, OPT_ARG,
unknown's avatar
Merge  
unknown committed
5113 5114 5115
   1, 1, 65535, 0, 1, 0 },
  {"automatic-sp-privileges", OPT_SP_AUTOMATIC_PRIVILEGES,
   "Creating and dropping stored procedures alters ACLs. Disable with --skip-automatic-sp-privileges.",
5116
   (uchar**) &sp_automatic_privileges, (uchar**) &sp_automatic_privileges,
unknown's avatar
Merge  
unknown committed
5117
   0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0},
5118 5119
  {"basedir", 'b',
   "Path to installation directory. All paths are usually resolved relative to this.",
5120
   (uchar**) &mysql_home_ptr, (uchar**) &mysql_home_ptr, 0, GET_STR, REQUIRED_ARG,
5121
   0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5122
  {"big-tables", OPT_BIG_TABLES,
5123
   "Allow big result sets by saving all temporary sets on file (Solves most 'table full' errors).",
5124
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5125
  {"bind-address", OPT_BIND_ADDRESS, "IP address to bind to.",
5126
   (uchar**) &my_bind_addr_str, (uchar**) &my_bind_addr_str, 0, GET_STR,
unknown's avatar
unknown committed
5127
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
5128
  {"binlog_format", OPT_BINLOG_FORMAT,
5129
   "Does not have any effect without '--log-bin'. "
5130
   "Tell the master the form of binary logging to use: either 'row' for "
5131 5132 5133 5134 5135
   "row-based binary logging, or 'statement' for statement-based binary "
   "logging, or 'mixed'. 'mixed' is statement-based binary logging except "
   "for those statements where only row-based is correct: those which "
   "involve user-defined functions (i.e. UDFs) or the UUID() function; for "
   "those, row-based binary logging is automatically used. "
unknown's avatar
unknown committed
5136
#ifdef HAVE_NDB_BINLOG
5137 5138
   "If ndbcluster is enabled and binlog_format is `mixed', the format switches"
   " to 'row' and back implicitly per each query accessing a NDB table."
5139
#endif
5140
   ,(uchar**) &opt_binlog_format, (uchar**) &opt_binlog_format,
5141
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
5142 5143 5144
  {"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
5145
  {"binlog-ignore-db", OPT_BINLOG_IGNORE_DB,
5146
   "Tells the master that updates to the given database should not be logged tothe binary log.",
5147
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
5148 5149 5150 5151
  {"binlog-row-event-max-size", OPT_BINLOG_ROWS_EVENT_MAX_SIZE,
   "The maximum size of a row-based binary log event in bytes. Rows will be "
   "grouped into events smaller than this size if possible. "
   "The value has to be a multiple of 256.",
5152 5153
   (uchar**) &opt_binlog_rows_event_max_size, 
   (uchar**) &opt_binlog_rows_event_max_size, 0, 
5154 5155 5156 5157 5158
   GET_ULONG, REQUIRED_ARG, 
   /* def_value */ 1024, /* min_value */  256, /* max_value */ ULONG_MAX, 
   /* sub_size */     0, /* block_size */ 256, 
   /* app_type */ 0
  },
5159
#ifndef DISABLE_GRANT_OPTIONS
5160
  {"bootstrap", OPT_BOOTSTRAP, "Used by mysql installation scripts.", 0, 0, 0,
5161
   GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
5162
#endif
5163
  {"character-set-client-handshake", OPT_CHARACTER_SET_CLIENT_HANDSHAKE,
unknown's avatar
unknown committed
5164
   "Don't ignore client side character set value sent during handshake.",
5165 5166
   (uchar**) &opt_character_set_client_handshake,
   (uchar**) &opt_character_set_client_handshake,
5167
    0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5168 5169
  {"character-set-filesystem", OPT_CHARACTER_SET_FILESYSTEM,
   "Set the filesystem character set.",
5170 5171
   (uchar**) &character_set_filesystem_name,
   (uchar**) &character_set_filesystem_name,
unknown's avatar
unknown committed
5172
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
unknown's avatar
unknown committed
5173
  {"character-set-server", 'C', "Set the default character set.",
5174
   (uchar**) &default_character_set_name, (uchar**) &default_character_set_name,
unknown's avatar
unknown committed
5175
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
unknown's avatar
unknown committed
5176
  {"character-sets-dir", OPT_CHARSETS_DIR,
5177 5178
   "Directory where character sets are.", (uchar**) &charsets_dir,
   (uchar**) &charsets_dir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5179
  {"chroot", 'r', "Chroot mysqld daemon during startup.",
5180
   (uchar**) &mysqld_chroot, (uchar**) &mysqld_chroot, 0, GET_STR, REQUIRED_ARG,
unknown's avatar
unknown committed
5181 5182
   0, 0, 0, 0, 0, 0},
  {"collation-server", OPT_DEFAULT_COLLATION, "Set the default collation.",
5183
   (uchar**) &default_collation_name, (uchar**) &default_collation_name,
unknown's avatar
unknown committed
5184
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
unknown's avatar
Merge  
unknown committed
5185
  {"completion-type", OPT_COMPLETION_TYPE, "Default completion type.",
5186 5187
   (uchar**) &global_system_variables.completion_type,
   (uchar**) &max_system_variables.completion_type, 0, GET_ULONG,
unknown's avatar
Merge  
unknown committed
5188
   REQUIRED_ARG, 0, 0, 2, 0, 1, 0},
unknown's avatar
unknown committed
5189
  {"concurrent-insert", OPT_CONCURRENT_INSERT,
5190
   "Use concurrent insert with MyISAM. Disable with --concurrent-insert=0",
5191
   (uchar**) &myisam_concurrent_insert, (uchar**) &myisam_concurrent_insert,
5192
   0, GET_LONG, OPT_ARG, 1, 0, 2, 0, 0, 0},
5193
  {"console", OPT_CONSOLE, "Write error output on screen; Don't remove the console window on windows.",
5194
   (uchar**) &opt_console, (uchar**) &opt_console, 0, GET_BOOL, NO_ARG, 0, 0, 0,
5195
   0, 0, 0},
5196
  {"core-file", OPT_WANT_CORE, "Write core on errors.", 0, 0, 0, GET_NO_ARG,
5197
   NO_ARG, 0, 0, 0, 0, 0, 0},
5198 5199
  {"datadir", 'h', "Path to the database root.", (uchar**) &mysql_data_home,
   (uchar**) &mysql_data_home, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
5200
#ifndef DBUG_OFF
5201 5202
  {"debug", '#', "Debug log.", (uchar**) &default_dbug_option,
   (uchar**) &default_dbug_option, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
5203
#endif
unknown's avatar
unknown committed
5204
  {"default-character-set", 'C', "Set the default character set (deprecated option, use --character-set-server instead).",
5205
   (uchar**) &default_character_set_name, (uchar**) &default_character_set_name,
5206
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
unknown's avatar
unknown committed
5207
  {"default-collation", OPT_DEFAULT_COLLATION, "Set the default collation (deprecated option, use --collation-server instead).",
5208
   (uchar**) &default_collation_name, (uchar**) &default_collation_name,
5209
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
unknown's avatar
unknown committed
5210
  {"default-storage-engine", OPT_STORAGE_ENGINE,
unknown's avatar
unknown committed
5211
   "Set the default storage engine (table type) for tables.",
5212
   (uchar**)&default_storage_engine_str, (uchar**)&default_storage_engine_str,
unknown's avatar
unknown committed
5213 5214
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {"default-table-type", OPT_STORAGE_ENGINE,
unknown's avatar
unknown committed
5215
   "(deprecated) Use --default-storage-engine.",
5216
   (uchar**)&default_storage_engine_str, (uchar**)&default_storage_engine_str,
5217
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
5218
  {"default-time-zone", OPT_DEFAULT_TIME_ZONE, "Set the default time zone.",
5219
   (uchar**) &default_tz_name, (uchar**) &default_tz_name,
5220
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
5221
  {"delay-key-write", OPT_DELAY_KEY_WRITE, "Type of DELAY_KEY_WRITE.",
5222 5223
   0,0,0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
  {"delay-key-write-for-all-tables", OPT_DELAY_KEY_WRITE_ALL,
5224
   "Don't flush key buffers between writes for any MyISAM table (Deprecated option, use --delay-key-write=all instead).",
5225
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5226 5227 5228
#ifdef HAVE_OPENSSL
  {"des-key-file", OPT_DES_KEY_FILE,
   "Load keys for des_encrypt() and des_encrypt from given file.",
5229
   (uchar**) &des_key_file, (uchar**) &des_key_file, 0, GET_STR, REQUIRED_ARG,
unknown's avatar
unknown committed
5230 5231 5232 5233 5234
   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.",
5235 5236
   (uchar**) &disconnect_slave_event_count,
   (uchar**) &disconnect_slave_event_count, 0, GET_INT, REQUIRED_ARG, 0, 0, 0,
unknown's avatar
unknown committed
5237 5238
   0, 0, 0},
#endif /* HAVE_REPLICATION */
5239
  {"enable-locking", OPT_ENABLE_LOCK,
5240
   "Deprecated option, use --external-locking instead.",
5241
   (uchar**) &opt_external_locking, (uchar**) &opt_external_locking,
5242
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
5243
#ifdef __NT__
5244
  {"enable-named-pipe", OPT_HAVE_NAMED_PIPE, "Enable the named pipe (NT).",
5245
   (uchar**) &opt_enable_named_pipe, (uchar**) &opt_enable_named_pipe, 0, GET_BOOL,
5246 5247
   NO_ARG, 0, 0, 0, 0, 0, 0},
#endif
5248
  {"enable-pstack", OPT_DO_PSTACK, "Print a symbolic stack trace on failure.",
5249
   (uchar**) &opt_do_pstack, (uchar**) &opt_do_pstack, 0, GET_BOOL, NO_ARG, 0, 0,
5250
   0, 0, 0, 0},
unknown's avatar
Merge  
unknown committed
5251 5252 5253
  {"engine-condition-pushdown",
   OPT_ENGINE_CONDITION_PUSHDOWN,
   "Push supported query conditions to the storage engine.",
5254 5255
   (uchar**) &global_system_variables.engine_condition_pushdown,
   (uchar**) &global_system_variables.engine_condition_pushdown,
5256
   0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0},
5257
  /* See how it's handled in get_one_option() */
5258
  {"event-scheduler", OPT_EVENT_SCHEDULER, "Enable/disable the event scheduler.",
5259
   NULL,  NULL, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
5260 5261
  {"exit-info", 'T', "Used for debugging;  Use at your own risk!", 0, 0, 0,
   GET_LONG, OPT_ARG, 0, 0, 0, 0, 0, 0},
5262
  {"external-locking", OPT_USE_LOCKING, "Use system (external) locking (disabled by default).  With this option enabled you can run myisamchk to test (not repair) tables while the MySQL server is running. Disable with --skip-external-locking.",
5263
   (uchar**) &opt_external_locking, (uchar**) &opt_external_locking,
unknown's avatar
unknown committed
5264
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
5265
  {"flush", OPT_FLUSH, "Flush tables to disk between SQL commands.", 0, 0, 0,
5266 5267 5268
   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 */
5269 5270
  {"gdb", OPT_DEBUGGING,
   "Set up signals usable for debugging",
5271
   (uchar**) &opt_debugging, (uchar**) &opt_debugging,
5272
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
5273
  {"general-log", OPT_GENERAL_LOG,
5274 5275
   "Enable|disable general log", (uchar**) &opt_log,
   (uchar**) &opt_log, 0, GET_BOOL, OPT_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
Merge  
unknown committed
5276 5277 5278
#ifdef HAVE_LARGE_PAGES
  {"large-pages", OPT_ENABLE_LARGE_PAGES, "Enable support for large pages. \
Disable with --skip-large-pages.",
5279
   (uchar**) &opt_large_pages, (uchar**) &opt_large_pages, 0, GET_BOOL, NO_ARG, 0, 0, 0,
unknown's avatar
Merge  
unknown committed
5280 5281
   0, 0, 0},
#endif
unknown's avatar
unknown committed
5282
  {"init-connect", OPT_INIT_CONNECT, "Command(s) that are executed for each new connection",
5283
   (uchar**) &opt_init_connect, (uchar**) &opt_init_connect, 0, GET_STR_ALLOC,
unknown's avatar
unknown committed
5284
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
5285
#ifndef DISABLE_GRANT_OPTIONS
unknown's avatar
unknown committed
5286
  {"init-file", OPT_INIT_FILE, "Read SQL commands from this file at startup.",
5287
   (uchar**) &opt_init_file, (uchar**) &opt_init_file, 0, GET_STR, REQUIRED_ARG,
unknown's avatar
unknown committed
5288
   0, 0, 0, 0, 0, 0},
5289
#endif
5290
  {"init-rpl-role", OPT_INIT_RPL_ROLE, "Set the replication role.", 0, 0, 0,
5291
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5292
  {"init-slave", OPT_INIT_SLAVE, "Command(s) that are executed when a slave connects to this master",
5293
   (uchar**) &opt_init_slave, (uchar**) &opt_init_slave, 0, GET_STR_ALLOC,
unknown's avatar
unknown committed
5294
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
5295
  {"language", 'L',
5296
   "Client error messages in given language. May be given as a full path.",
5297
   (uchar**) &language_ptr, (uchar**) &language_ptr, 0, GET_STR, REQUIRED_ARG,
5298
   0, 0, 0, 0, 0, 0},
5299 5300
  {"lc-time-names", OPT_LC_TIME_NAMES,
   "Set the language used for the month names and the days of the week.",
5301 5302
   (uchar**) &lc_time_names_name,
   (uchar**) &lc_time_names_name,
5303
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
5304
  {"local-infile", OPT_LOCAL_INFILE,
5305
   "Enable/disable LOAD DATA LOCAL INFILE (takes values 1|0).",
5306 5307
   (uchar**) &opt_local_infile,
   (uchar**) &opt_local_infile, 0, GET_BOOL, OPT_ARG,
5308
   1, 0, 0, 0, 0, 0},
5309 5310
  {"log", 'l', "Log connections and queries to file.", (uchar**) &opt_logname,
   (uchar**) &opt_logname, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
5311
  {"log-bin", OPT_BIN_LOG,
unknown's avatar
Merge  
unknown committed
5312 5313 5314
   "Log update queries in binary format. Optional (but strongly recommended "
   "to avoid replication problems if server's hostname changes) argument "
   "should be the chosen location for the binary log files.",
5315
   (uchar**) &opt_bin_logname, (uchar**) &opt_bin_logname, 0, GET_STR_ALLOC,
unknown's avatar
unknown committed
5316
   OPT_ARG, 0, 0, 0, 0, 0, 0},
5317
  {"log-bin-index", OPT_BIN_LOG_INDEX,
5318
   "File that holds the names for last binary log files.",
5319
   (uchar**) &opt_binlog_index_name, (uchar**) &opt_binlog_index_name, 0, GET_STR,
5320
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
5321 5322 5323 5324 5325 5326 5327 5328 5329
#ifndef TO_BE_REMOVED_IN_5_1_OR_6_0
  /*
    In 5.0.6 we introduced the below option, then in 5.0.16 we renamed it to
    log-bin-trust-function-creators but kept also the old name for
    compatibility; the behaviour was also changed to apply only to functions
    (and triggers). In a future release this old name could be removed.
  */
  {"log-bin-trust-routine-creators", OPT_LOG_BIN_TRUST_FUNCTION_CREATORS,
   "(deprecated) Use log-bin-trust-function-creators.",
5330
   (uchar**) &trust_function_creators, (uchar**) &trust_function_creators, 0,
5331 5332
   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
#endif
5333 5334
  /*
    This option starts with "log-bin" to emphasize that it is specific of
5335
    binary logging.
5336
  */
5337
  {"log-bin-trust-function-creators", OPT_LOG_BIN_TRUST_FUNCTION_CREATORS,
5338
   "If equal to 0 (the default), then when --log-bin is used, creation of "
5339 5340
   "a stored function (or trigger) is allowed only to users having the SUPER privilege "
   "and only if this stored function (trigger) may not break binary logging."
5341 5342 5343
   "Note that if ALL connections to this server ALWAYS use row-based binary "
   "logging, the security issues do not exist and the binary logging cannot "
   "break, so you can safely set this to 1."
5344
   ,(uchar**) &trust_function_creators, (uchar**) &trust_function_creators, 0,
5345
   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
Merge  
unknown committed
5346
  {"log-error", OPT_ERROR_LOG_FILE, "Error log file.",
5347
   (uchar**) &log_error_file_ptr, (uchar**) &log_error_file_ptr, 0, GET_STR,
unknown's avatar
unknown committed
5348
   OPT_ARG, 0, 0, 0, 0, 0, 0},
5349
  {"log-isam", OPT_ISAM_LOG, "Log all MyISAM changes to file.",
5350
   (uchar**) &myisam_log_filename, (uchar**) &myisam_log_filename, 0, GET_STR,
5351
   OPT_ARG, 0, 0, 0, 0, 0, 0},
5352 5353 5354
  {"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},
5355 5356
#ifdef WITH_CSV_STORAGE_ENGINE
  {"log-output", OPT_LOG_OUTPUT,
5357
   "Syntax: log-output[=value[,value...]], where \"value\" could be TABLE, "
5358
   "FILE or NONE.",
5359
   (uchar**) &log_output_str, (uchar**) &log_output_str, 0,
5360 5361
   GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
#endif
5362
  {"log-queries-not-using-indexes", OPT_LOG_QUERIES_NOT_USING_INDEXES,
5363
   "Log queries that are executed without benefit of any index to the slow log if it is open.",
5364
   (uchar**) &opt_log_queries_not_using_indexes, (uchar**) &opt_log_queries_not_using_indexes,
5365
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5366 5367
  {"log-short-format", OPT_SHORT_LOG_FORMAT,
   "Don't log extra information to update and slow-query logs.",
5368
   (uchar**) &opt_short_log_format, (uchar**) &opt_short_log_format,
unknown's avatar
unknown committed
5369
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
5370
  {"log-slave-updates", OPT_LOG_SLAVE_UPDATES,
unknown's avatar
unknown committed
5371
   "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.",
5372
   (uchar**) &opt_log_slave_updates, (uchar**) &opt_log_slave_updates, 0, GET_BOOL,
5373
   NO_ARG, 0, 0, 0, 0, 0, 0},
5374 5375
  {"log-slow-admin-statements", OPT_LOG_SLOW_ADMIN_STATEMENTS,
   "Log slow OPTIMIZE, ANALYZE, ALTER and other administrative statements to the slow log if it is open.",
5376 5377
   (uchar**) &opt_log_slow_admin_statements,
   (uchar**) &opt_log_slow_admin_statements,
5378
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5379
  {"log-slow-queries", OPT_SLOW_QUERY_LOG,
5380
    "Log slow queries to this log file. Defaults logging to hostname-slow.log file. Must be enabled to activate other slow log options.",
5381
   (uchar**) &opt_slow_logname, (uchar**) &opt_slow_logname, 0, GET_STR, OPT_ARG,
unknown's avatar
unknown committed
5382
   0, 0, 0, 0, 0, 0},
unknown's avatar
Merge  
unknown committed
5383 5384 5385
  {"log-tc", OPT_LOG_TC,
   "Path to transaction coordinator log (used for transactions that affect "
   "more than one storage engine, when binary log is disabled)",
5386
   (uchar**) &opt_tc_log_file, (uchar**) &opt_tc_log_file, 0, GET_STR,
unknown's avatar
Merge  
unknown committed
5387
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
5388
#ifdef HAVE_MMAP
unknown's avatar
Merge  
unknown committed
5389
  {"log-tc-size", OPT_LOG_TC_SIZE, "Size of transaction coordinator log.",
5390
   (uchar**) &opt_tc_log_size, (uchar**) &opt_tc_log_size, 0, GET_ULONG,
unknown's avatar
Merge  
unknown committed
5391
   REQUIRED_ARG, TC_LOG_MIN_SIZE, TC_LOG_MIN_SIZE, ~0L, 0, TC_LOG_PAGE_SIZE, 0},
5392
#endif
unknown's avatar
unknown committed
5393
  {"log-update", OPT_UPDATE_LOG,
unknown's avatar
Merge  
unknown committed
5394 5395
   "The update log is deprecated since version 5.0, is replaced by the binary \
log and this option justs turns on --log-bin instead.",
5396
   (uchar**) &opt_update_logname, (uchar**) &opt_update_logname, 0, GET_STR,
unknown's avatar
unknown committed
5397
   OPT_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
Merge  
unknown committed
5398
  {"log-warnings", 'W', "Log some not critical warnings to the log file.",
5399 5400
   (uchar**) &global_system_variables.log_warnings,
   (uchar**) &max_system_variables.log_warnings, 0, GET_ULONG, OPT_ARG, 1, 0, 0,
unknown's avatar
unknown committed
5401
   0, 0, 0},
5402
  {"low-priority-updates", OPT_LOW_PRIORITY_UPDATES,
5403
   "INSERT/DELETE/UPDATE has lower priority than selects.",
5404 5405
   (uchar**) &global_system_variables.low_priority_updates,
   (uchar**) &max_system_variables.low_priority_updates,
unknown's avatar
unknown committed
5406
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5407 5408
  {"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.",
5409
   (uchar**) &master_connect_retry, (uchar**) &master_connect_retry, 0, GET_UINT,
unknown's avatar
unknown committed
5410
   REQUIRED_ARG, 60, 0, 0, 0, 0, 0},
5411
  {"master-host", OPT_MASTER_HOST,
5412
   "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.",
5413
   (uchar**) &master_host, (uchar**) &master_host, 0, GET_STR, REQUIRED_ARG, 0, 0,
5414
   0, 0, 0, 0},
unknown's avatar
unknown committed
5415 5416 5417
  {"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.",
5418
   (uchar**) &master_info_file, (uchar**) &master_info_file, 0, GET_STR,
unknown's avatar
unknown committed
5419
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
5420 5421
  {"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.",
5422
   (uchar**)&master_password, (uchar**)&master_password, 0,
unknown's avatar
unknown committed
5423
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
5424
  {"master-port", OPT_MASTER_PORT,
5425
   "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.",
5426
   (uchar**) &master_port, (uchar**) &master_port, 0, GET_UINT, REQUIRED_ARG,
5427 5428 5429
   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.",
5430
   (uchar**) &master_retry_count, (uchar**) &master_retry_count, 0, GET_ULONG,
5431
   REQUIRED_ARG, 3600*24, 0, 0, 0, 0, 0},
5432
  {"master-ssl", OPT_MASTER_SSL,
unknown's avatar
unknown committed
5433
   "Enable the slave to connect to the master using SSL.",
5434
   (uchar**) &master_ssl, (uchar**) &master_ssl, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
5435
   0, 0},
unknown's avatar
unknown committed
5436 5437
  {"master-ssl-ca", OPT_MASTER_SSL_CA,
   "Master SSL CA file. Only applies if you have enabled master-ssl.",
5438
   (uchar**) &master_ssl_ca, (uchar**) &master_ssl_ca, 0, GET_STR, OPT_ARG,
unknown's avatar
unknown committed
5439
   0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5440
  {"master-ssl-capath", OPT_MASTER_SSL_CAPATH,
unknown's avatar
unknown committed
5441
   "Master SSL CA path. Only applies if you have enabled master-ssl.",
5442
   (uchar**) &master_ssl_capath, (uchar**) &master_ssl_capath, 0, GET_STR, OPT_ARG,
unknown's avatar
unknown committed
5443
   0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5444 5445 5446
  {"master-ssl-cert", OPT_MASTER_SSL_CERT,
   "Master SSL certificate file name. Only applies if you have enabled \
master-ssl",
5447
   (uchar**) &master_ssl_cert, (uchar**) &master_ssl_cert, 0, GET_STR, OPT_ARG,
unknown's avatar
unknown committed
5448
   0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5449
  {"master-ssl-cipher", OPT_MASTER_SSL_CIPHER,
unknown's avatar
unknown committed
5450
   "Master SSL cipher. Only applies if you have enabled master-ssl.",
5451
   (uchar**) &master_ssl_cipher, (uchar**) &master_ssl_capath, 0, GET_STR, OPT_ARG,
5452
   0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5453 5454
  {"master-ssl-key", OPT_MASTER_SSL_KEY,
   "Master SSL keyfile name. Only applies if you have enabled master-ssl.",
5455
   (uchar**) &master_ssl_key, (uchar**) &master_ssl_key, 0, GET_STR, OPT_ARG,
unknown's avatar
unknown committed
5456 5457 5458
   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.",
5459
   (uchar**) &master_user, (uchar**) &master_user, 0, GET_STR, REQUIRED_ARG, 0, 0,
unknown's avatar
unknown committed
5460
   0, 0, 0, 0},
unknown's avatar
SCRUM  
unknown committed
5461
#ifdef HAVE_REPLICATION
5462
  {"max-binlog-dump-events", OPT_MAX_BINLOG_DUMP_EVENTS,
5463
   "Option used by mysql-test for debugging and testing of replication.",
5464
   (uchar**) &max_binlog_dump_events, (uchar**) &max_binlog_dump_events, 0,
5465
   GET_INT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
SCRUM  
unknown committed
5466
#endif /* HAVE_REPLICATION */
5467 5468
  {"memlock", OPT_MEMLOCK, "Lock mysqld in memory.", (uchar**) &locked_in_memory,
   (uchar**) &locked_in_memory, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5469 5470
  {"myisam-recover", OPT_MYISAM_RECOVER,
   "Syntax: myisam-recover[=option[,option...]], where option can be DEFAULT, BACKUP, FORCE or QUICK.",
5471
   (uchar**) &myisam_recover_options_str, (uchar**) &myisam_recover_options_str, 0,
unknown's avatar
unknown committed
5472
   GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
5473
#ifdef WITH_NDBCLUSTER_STORAGE_ENGINE
5474 5475
  {"ndb-connectstring", OPT_NDB_CONNECTSTRING,
   "Connect string for ndbcluster.",
5476 5477
   (uchar**) &opt_ndb_connectstring,
   (uchar**) &opt_ndb_connectstring,
unknown's avatar
Merge  
unknown committed
5478 5479 5480
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {"ndb-mgmd-host", OPT_NDB_MGMD,
   "Set host and port for ndb_mgmd. Syntax: hostname[:port]",
5481 5482
   (uchar**) &opt_ndb_mgmd,
   (uchar**) &opt_ndb_mgmd,
5483
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
Merge  
unknown committed
5484 5485
  {"ndb-nodeid", OPT_NDB_NODEID,
   "Nodeid for this mysqlserver in the cluster.",
5486 5487
   (uchar**) &opt_ndb_nodeid,
   (uchar**) &opt_ndb_nodeid,
unknown's avatar
Merge  
unknown committed
5488
   0, GET_INT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
5489 5490
  {"ndb-autoincrement-prefetch-sz", OPT_NDB_AUTOINCREMENT_PREFETCH_SZ,
   "Specify number of autoincrement values that are prefetched.",
5491 5492
   (uchar**) &global_system_variables.ndb_autoincrement_prefetch_sz,
   (uchar**) &global_system_variables.ndb_autoincrement_prefetch_sz,
5493
   0, GET_ULONG, REQUIRED_ARG, 32, 1, 256, 0, 0, 0},
unknown's avatar
unknown committed
5494
  {"ndb-distribution", OPT_NDB_DISTRIBUTION,
5495
   "Default distribution for new tables in ndb",
5496 5497
   (uchar**) &opt_ndb_distribution,
   (uchar**) &opt_ndb_distribution,
5498
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
5499 5500 5501
  {"ndb-force-send", OPT_NDB_FORCE_SEND,
   "Force send of buffers to ndb immediately without waiting for "
   "other threads.",
5502 5503
   (uchar**) &global_system_variables.ndb_force_send,
   (uchar**) &global_system_variables.ndb_force_send,
5504
   0, GET_BOOL, OPT_ARG, 1, 0, 0, 0, 0, 0},
5505
  {"ndb_force_send", OPT_NDB_FORCE_SEND,
5506
   "same as --ndb-force-send.",
5507 5508
   (uchar**) &global_system_variables.ndb_force_send,
   (uchar**) &global_system_variables.ndb_force_send,
5509
   0, GET_BOOL, OPT_ARG, 1, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5510 5511
  {"ndb-extra-logging", OPT_NDB_EXTRA_LOGGING,
   "Turn on more logging in the error log.",
5512 5513
   (uchar**) &ndb_extra_logging,
   (uchar**) &ndb_extra_logging,
unknown's avatar
unknown committed
5514 5515 5516 5517 5518 5519 5520
   0, GET_INT, OPT_ARG, 0, 0, 0, 0, 0, 0},
#ifdef HAVE_NDB_BINLOG
  {"ndb-report-thresh-binlog-epoch-slip", OPT_NDB_REPORT_THRESH_BINLOG_EPOCH_SLIP,
   "Threshold on number of epochs to be behind before reporting binlog status. "
   "E.g. 3 means that if the difference between what epoch has been received "
   "from the storage nodes and what has been applied to the binlog is 3 or more, "
   "a status message will be sent to the cluster log.",
5521 5522
   (uchar**) &ndb_report_thresh_binlog_epoch_slip,
   (uchar**) &ndb_report_thresh_binlog_epoch_slip,
unknown's avatar
unknown committed
5523 5524 5525 5526 5527 5528
   0, GET_ULONG, REQUIRED_ARG, 3, 0, 256, 0, 0, 0},
  {"ndb-report-thresh-binlog-mem-usage", OPT_NDB_REPORT_THRESH_BINLOG_MEM_USAGE,
   "Threshold on percentage of free memory before reporting binlog status. E.g. "
   "10 means that if amount of available memory for receiving binlog data from "
   "the storage nodes goes below 10%, "
   "a status message will be sent to the cluster log.",
5529 5530
   (uchar**) &ndb_report_thresh_binlog_mem_usage,
   (uchar**) &ndb_report_thresh_binlog_mem_usage,
unknown's avatar
unknown committed
5531 5532
   0, GET_ULONG, REQUIRED_ARG, 10, 0, 100, 0, 0, 0},
#endif
5533 5534 5535
  {"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.",
5536 5537
   (uchar**) &global_system_variables.ndb_use_exact_count,
   (uchar**) &global_system_variables.ndb_use_exact_count,
5538
   0, GET_BOOL, OPT_ARG, 1, 0, 0, 0, 0, 0},
5539
  {"ndb_use_exact_count", OPT_NDB_USE_EXACT_COUNT,
5540
   "same as --ndb-use-exact-count.",
5541 5542
   (uchar**) &global_system_variables.ndb_use_exact_count,
   (uchar**) &global_system_variables.ndb_use_exact_count,
5543
   0, GET_BOOL, OPT_ARG, 1, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5544 5545 5546
  {"ndb-use-transactions", OPT_NDB_USE_TRANSACTIONS,
   "Use transactions for large inserts, if enabled then large "
   "inserts will be split into several smaller transactions",
5547 5548
   (uchar**) &global_system_variables.ndb_use_transactions,
   (uchar**) &global_system_variables.ndb_use_transactions,
unknown's avatar
unknown committed
5549 5550 5551
   0, GET_BOOL, OPT_ARG, 1, 0, 0, 0, 0, 0},
  {"ndb_use_transactions", OPT_NDB_USE_TRANSACTIONS,
   "same as --ndb-use-transactions.",
5552 5553
   (uchar**) &global_system_variables.ndb_use_transactions,
   (uchar**) &global_system_variables.ndb_use_transactions,
unknown's avatar
unknown committed
5554
   0, GET_BOOL, OPT_ARG, 1, 0, 0, 0, 0, 0},
5555 5556
  {"ndb-shm", OPT_NDB_SHM,
   "Use shared memory connections when available.",
5557 5558
   (uchar**) &opt_ndb_shm,
   (uchar**) &opt_ndb_shm,
5559 5560 5561
   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.",
5562 5563
   (uchar**) &opt_ndb_optimized_node_selection,
   (uchar**) &opt_ndb_optimized_node_selection,
5564
   0, GET_BOOL, OPT_ARG, 1, 0, 0, 0, 0, 0},
unknown's avatar
Merge  
unknown committed
5565 5566
  { "ndb-cache-check-time", OPT_NDB_CACHE_CHECK_TIME,
    "A dedicated thread is created to, at the given millisecons interval, invalidate the query cache if another MySQL server in the cluster has changed the data in the database.",
5567
    (uchar**) &opt_ndb_cache_check_time, (uchar**) &opt_ndb_cache_check_time, 0, GET_ULONG, REQUIRED_ARG,
unknown's avatar
Merge  
unknown committed
5568
    0, 0, LONG_TIMEOUT, 0, 1, 0},
5569 5570
  {"ndb-index-stat-enable", OPT_NDB_INDEX_STAT_ENABLE,
   "Use ndb index statistics in query optimization.",
5571 5572
   (uchar**) &global_system_variables.ndb_index_stat_enable,
   (uchar**) &max_system_variables.ndb_index_stat_enable,
5573
   0, GET_BOOL, OPT_ARG, 0, 0, 1, 0, 0, 0},
5574
#endif
unknown's avatar
unknown committed
5575
  {"ndb-use-copying-alter-table",
5576
   OPT_NDB_USE_COPYING_ALTER_TABLE,
unknown's avatar
unknown committed
5577
   "Force ndbcluster to always copy tables at alter table (should only be used if on-line alter table fails).",
5578 5579
   (uchar**) &global_system_variables.ndb_use_copying_alter_table,
   (uchar**) &global_system_variables.ndb_use_copying_alter_table,
5580
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},  
5581
  {"new", 'n', "Use very new possible 'unsafe' functions.",
5582 5583
   (uchar**) &global_system_variables.new_mode,
   (uchar**) &max_system_variables.new_mode,
5584
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5585
#ifdef NOT_YET
5586
  {"no-mix-table-types", OPT_NO_MIX_TYPE, "Don't allow commands with uses two different table types.",
5587
   (uchar**) &opt_no_mix_types, (uchar**) &opt_no_mix_types, 0, GET_BOOL, NO_ARG,
5588 5589
   0, 0, 0, 0, 0, 0},
#endif
unknown's avatar
unknown committed
5590 5591
  {"old-alter-table", OPT_OLD_ALTER_TABLE,
   "Use old, non-optimized alter table.",
5592 5593
   (uchar**) &global_system_variables.old_alter_table,
   (uchar**) &max_system_variables.old_alter_table, 0, GET_BOOL, NO_ARG,
unknown's avatar
unknown committed
5594
   0, 0, 0, 0, 0, 0},
5595
  {"old-passwords", OPT_OLD_PASSWORDS, "Use old password encryption method (needed for 4.0 and older clients).",
5596 5597
   (uchar**) &global_system_variables.old_passwords,
   (uchar**) &max_system_variables.old_passwords, 0, GET_BOOL, NO_ARG,
5598
   0, 0, 0, 0, 0, 0},
5599
  {"one-thread", OPT_ONE_THREAD,
unknown's avatar
unknown committed
5600 5601
   "(deprecated): Only use one thread (for debugging under Linux). Use thread-handling=no-threads instead",
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
Merge  
unknown committed
5602 5603
  {"old-style-user-limits", OPT_OLD_STYLE_USER_LIMITS,
   "Enable old-style user limits (before 5.0.3 user resources were counted per each user+host vs. per account)",
5604
   (uchar**) &opt_old_style_user_limits, (uchar**) &opt_old_style_user_limits,
unknown's avatar
Merge  
unknown committed
5605
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
5606
  {"pid-file", OPT_PID_FILE, "Pid file used by safe_mysqld.",
5607
   (uchar**) &pidfile_name_ptr, (uchar**) &pidfile_name_ptr, 0, GET_STR,
5608
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
5609 5610
  {"port", 'P', "Port number to use for connection.", (uchar**) &mysqld_port,
   (uchar**) &mysqld_port, 0, GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
5611 5612
  {"port-open-timeout", OPT_PORT_OPEN_TIMEOUT,
   "Maximum time in seconds to wait for the port to become free. "
5613 5614
   "(Default: no wait)", (uchar**) &mysqld_port_timeout,
   (uchar**) &mysqld_port_timeout, 0, GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5615 5616
  {"relay-log", OPT_RELAY_LOG,
   "The location and name to use for relay logs.",
5617
   (uchar**) &opt_relay_logname, (uchar**) &opt_relay_logname, 0,
unknown's avatar
unknown committed
5618 5619 5620 5621
   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.",
5622
   (uchar**) &opt_relaylog_index_name, (uchar**) &opt_relaylog_index_name, 0,
unknown's avatar
unknown committed
5623 5624 5625 5626
   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.",
5627
   (uchar**) &relay_log_info_file, (uchar**) &relay_log_info_file, 0, GET_STR,
unknown's avatar
unknown committed
5628
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
5629 5630 5631 5632 5633 5634 5635 5636 5637 5638 5639 5640 5641
  {"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,
5642
   "Updates to a database with a different name than the original. Example: replicate-rewrite-db=master_db_name->slave_db_name.",
5643
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5644
#ifdef HAVE_REPLICATION
5645 5646 5647 5648
  {"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.",
5649 5650
   (uchar**) &replicate_same_server_id,
   (uchar**) &replicate_same_server_id,
5651
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5652
#endif
unknown's avatar
unknown committed
5653 5654 5655 5656 5657 5658
  {"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},
5659
  // In replication, we may need to tell the other servers how to connect
5660 5661
  {"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.",
5662
   (uchar**) &report_host, (uchar**) &report_host, 0, GET_STR, REQUIRED_ARG, 0, 0,
5663
   0, 0, 0, 0},
5664
  {"report-password", OPT_REPORT_PASSWORD, "Undocumented.",
5665
   (uchar**) &report_password, (uchar**) &report_password, 0, GET_STR,
5666 5667 5668
   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.",
5669
   (uchar**) &report_port, (uchar**) &report_port, 0, GET_UINT, REQUIRED_ARG,
5670
   MYSQL_PORT, 0, 0, 0, 0, 0},
5671 5672
  {"report-user", OPT_REPORT_USER, "Undocumented.", (uchar**) &report_user,
   (uchar**) &report_user, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
5673
  {"rpl-recovery-rank", OPT_RPL_RECOVERY_RANK, "Undocumented.",
5674
   (uchar**) &rpl_recovery_rank, (uchar**) &rpl_recovery_rank, 0, GET_ULONG,
5675 5676 5677
   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
5678
#ifndef TO_BE_DELETED
5679
  {"safe-show-database", OPT_SAFE_SHOW_DB,
unknown's avatar
unknown committed
5680
   "Deprecated option; use GRANT SHOW DATABASES instead...",
5681
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5682
#endif
5683
  {"safe-user-create", OPT_SAFE_USER_CREATE,
5684
   "Don't allow new user creation by the user who has no write privileges to the mysql.user table.",
5685
   (uchar**) &opt_safe_user_create, (uchar**) &opt_safe_user_create, 0, GET_BOOL,
5686
   NO_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5687 5688 5689
  {"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},
5690
  {"secure-auth", OPT_SECURE_AUTH, "Disallow authentication for accounts that have old (pre-4.1) passwords.",
5691
   (uchar**) &opt_secure_auth, (uchar**) &opt_secure_auth, 0, GET_BOOL, NO_ARG,
5692
   my_bool(0), 0, 0, 0, 0, 0},
5693 5694
  {"secure-file-priv", OPT_SECURE_FILE_PRIV,
   "Limit LOAD DATA, SELECT ... OUTFILE, and LOAD_FILE() to files within specified directory",
5695
   (uchar**) &opt_secure_file_priv, (uchar**) &opt_secure_file_priv, 0,
5696
   GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
5697
  {"server-id",	OPT_SERVER_ID,
5698
   "Uniquely identifies the server instance in the community of replication partners.",
5699
   (uchar**) &server_id, (uchar**) &server_id, 0, GET_ULONG, REQUIRED_ARG, 0, 0, 0,
5700 5701 5702 5703
   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},
5704
#ifdef HAVE_SMEM
unknown's avatar
unknown committed
5705
  {"shared-memory", OPT_ENABLE_SHARED_MEMORY,
5706
   "Enable the shared memory.",(uchar**) &opt_enable_shared_memory, (uchar**) &opt_enable_shared_memory,
unknown's avatar
unknown committed
5707 5708 5709 5710
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
#endif
#ifdef HAVE_SMEM
  {"shared-memory-base-name",OPT_SHARED_MEMORY_BASE_NAME,
5711
   "Base name of shared memory.", (uchar**) &shared_memory_base_name, (uchar**) &shared_memory_base_name,
5712 5713
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
#endif
unknown's avatar
unknown committed
5714
  {"show-slave-auth-info", OPT_SHOW_SLAVE_AUTH_INFO,
5715
   "Show user and password in SHOW SLAVE HOSTS on this master",
5716
   (uchar**) &opt_show_slave_auth_info, (uchar**) &opt_show_slave_auth_info, 0,
5717
   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
5718
#ifndef DISABLE_GRANT_OPTIONS
5719 5720
  {"skip-grant-tables", OPT_SKIP_GRANT,
   "Start without grant tables. This gives all users FULL ACCESS to all tables!",
5721
   (uchar**) &opt_noacl, (uchar**) &opt_noacl, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0,
5722
   0},
5723
#endif
unknown's avatar
unknown committed
5724 5725
  {"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},
5726
  {"skip-locking", OPT_SKIP_LOCK,
5727
   "Deprecated option, use --skip-external-locking instead.",
5728 5729
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  {"skip-name-resolve", OPT_SKIP_RESOLVE,
5730
   "Don't resolve hostnames. All hostnames are IP's or 'localhost'.",
5731 5732 5733 5734 5735 5736
   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
5737 5738 5739 5740 5741 5742 5743
#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
5744
  {"skip-show-database", OPT_SKIP_SHOW_DB,
5745
   "Don't allow 'SHOW DATABASE' commands.", 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0,
5746 5747
   0, 0, 0, 0},
  {"skip-slave-start", OPT_SKIP_SLAVE_START,
5748 5749
   "If set, slave is not autostarted.", (uchar**) &opt_skip_slave_start,
   (uchar**) &opt_skip_slave_start, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
5750
  {"skip-stack-trace", OPT_SKIP_STACK_TRACE,
5751
   "Don't print a stack trace on failure.", 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0,
5752
   0, 0, 0, 0},
unknown's avatar
unknown committed
5753
  {"skip-symlink", OPT_SKIP_SYMLINKS, "Don't allow symlinking of tables. Deprecated option.  Use --skip-symbolic-links instead.",
5754 5755
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  {"skip-thread-priority", OPT_SKIP_PRIOR,
unknown's avatar
unknown committed
5756 5757
   "Don't give threads different priorities.", 0, 0, 0, GET_NO_ARG, NO_ARG,
   DEFAULT_SKIP_THREAD_PRIORITY, 0, 0, 0, 0, 0},
unknown's avatar
SCRUM  
unknown committed
5758
#ifdef HAVE_REPLICATION
5759
  {"slave-load-tmpdir", OPT_SLAVE_LOAD_TMPDIR,
5760
   "The location where the slave should put its temporary files when \
5761
replicating a LOAD DATA INFILE command.",
5762
   (uchar**) &slave_load_tmpdir, (uchar**) &slave_load_tmpdir, 0, GET_STR_ALLOC,
5763 5764
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {"slave-skip-errors", OPT_SLAVE_SKIP_ERRORS,
5765
   "Tells the slave thread to continue replication when a query returns an error from the provided list.",
5766
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
5767
#endif
5768
  {"slow-query-log", OPT_SLOW_LOG,
5769 5770
   "Enable|disable slow query log", (uchar**) &opt_slow_log,
   (uchar**) &opt_slow_log, 0, GET_BOOL, OPT_ARG, 0, 0, 0, 0, 0, 0},
5771
  {"socket", OPT_SOCKET, "Socket file to use for connection.",
5772
   (uchar**) &mysqld_unix_port, (uchar**) &mysqld_unix_port, 0, GET_STR,
5773
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5774 5775 5776
#ifdef HAVE_REPLICATION
  {"sporadic-binlog-dump-fail", OPT_SPORADIC_BINLOG_DUMP_FAIL,
   "Option used by mysql-test for debugging and testing of replication.",
5777 5778
   (uchar**) &opt_sporadic_binlog_dump_fail,
   (uchar**) &opt_sporadic_binlog_dump_fail, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0,
unknown's avatar
unknown committed
5779 5780
   0},
#endif /* HAVE_REPLICATION */
5781
  {"sql-bin-update-same", OPT_SQL_BIN_UPDATE_SAME,
unknown's avatar
Merge  
unknown committed
5782 5783
   "The update log is deprecated since version 5.0, is replaced by the binary \
log and this option does nothing anymore.",
5784
   0, 0, 0, GET_DISABLED, NO_ARG, 0, 0, 0, 0, 0, 0},
5785
  {"sql-mode", OPT_SQL_MODE,
5786
   "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.",
5787
   (uchar**) &sql_mode_str, (uchar**) &sql_mode_str, 0, GET_STR, REQUIRED_ARG, 0,
5788
   0, 0, 0, 0, 0},
5789
#ifdef HAVE_OPENSSL
5790 5791
#include "sslopt-longopts.h"
#endif
unknown's avatar
unknown committed
5792 5793 5794 5795 5796 5797
#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.",
5798
   (uchar**) &my_use_symdir, (uchar**) &my_use_symdir, 0, GET_BOOL, NO_ARG,
5799 5800 5801 5802 5803
   /*
     The system call realpath() produces warnings under valgrind and
     purify. These are not suppressed: instead we disable symlinks
     option if compiled with valgrind support.
   */
5804
   IF_PURIFY(0,1), 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5805 5806
  {"sysdate-is-now", OPT_SYSDATE_IS_NOW,
   "Non-default option to alias SYSDATE() to NOW() to make it safe-replicable. Since 5.0, SYSDATE() returns a `dynamic' value different for different invocations, even within the same statement.",
5807
   (uchar**) &global_system_variables.sysdate_is_now,
unknown's avatar
unknown committed
5808
   0, 0, GET_BOOL, NO_ARG, 0, 0, 1, 0, 1, 0},
unknown's avatar
Merge  
unknown committed
5809
  {"tc-heuristic-recover", OPT_TC_HEURISTIC_RECOVER,
unknown's avatar
unknown committed
5810
   "Decision to use in heuristic recover process. Possible values are COMMIT or ROLLBACK.",
5811
   (uchar**) &opt_tc_heuristic_recover, (uchar**) &opt_tc_heuristic_recover,
unknown's avatar
Merge  
unknown committed
5812
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5813
  {"temp-pool", OPT_TEMP_POOL,
5814
   "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.",
5815
   (uchar**) &use_temp_pool, (uchar**) &use_temp_pool, 0, GET_BOOL, NO_ARG, 1,
unknown's avatar
unknown committed
5816
   0, 0, 0, 0, 0},
unknown's avatar
Merge  
unknown committed
5817 5818
  {"timed_mutexes", OPT_TIMED_MUTEXES,
   "Specify whether to time mutexes (only InnoDB mutexes are currently supported)",
5819
   (uchar**) &timed_mutexes, (uchar**) &timed_mutexes, 0, GET_BOOL, NO_ARG, 0, 
unknown's avatar
Merge  
unknown committed
5820
    0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5821 5822
  {"tmpdir", 't',
   "Path for temporary files. Several paths may be specified, separated by a "
5823
#if defined(__WIN__) || defined(__NETWARE__)
unknown's avatar
unknown committed
5824 5825 5826 5827 5828
   "semicolon (;)"
#else
   "colon (:)"
#endif
   ", in this case they are used in a round-robin fashion.",
5829 5830
   (uchar**) &opt_mysql_tmpdir,
   (uchar**) &opt_mysql_tmpdir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
5831
  {"transaction-isolation", OPT_TX_ISOLATION,
5832
   "Default transaction isolation level.", 0, 0, 0, GET_STR, REQUIRED_ARG, 0,
unknown's avatar
unknown committed
5833
   0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5834
  {"use-symbolic-links", 's', "Enable symbolic link support. Deprecated option; use --symbolic-links instead.",
5835
   (uchar**) &my_use_symdir, (uchar**) &my_use_symdir, 0, GET_BOOL, NO_ARG,
5836
   IF_PURIFY(0,1), 0, 0, 0, 0, 0},
5837
  {"user", 'u', "Run mysqld daemon as user.", 0, 0, 0, GET_STR, REQUIRED_ARG,
unknown's avatar
unknown committed
5838
   0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5839
  {"verbose", 'v', "Used with --help option for detailed help",
5840
   (uchar**) &opt_verbose, (uchar**) &opt_verbose, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
unknown's avatar
unknown committed
5841
   0, 0},
5842
  {"version", 'V', "Output version information and exit.", 0, 0, 0, GET_NO_ARG,
5843
   NO_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5844
  {"warnings", 'W', "Deprecated; use --log-warnings instead.",
5845 5846
   (uchar**) &global_system_variables.log_warnings,
   (uchar**) &max_system_variables.log_warnings, 0, GET_ULONG, OPT_ARG, 1, 0, ~0L,
5847 5848
   0, 0, 0},
  { "back_log", OPT_BACK_LOG,
5849
    "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.",
5850
    (uchar**) &back_log, (uchar**) &back_log, 0, GET_ULONG,
5851 5852 5853
    REQUIRED_ARG, 50, 1, 65535, 0, 1, 0 },
  {"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.",
5854
   (uchar**) &binlog_cache_size, (uchar**) &binlog_cache_size, 0, GET_ULONG,
5855
   REQUIRED_ARG, 32*1024L, IO_SIZE, ~0L, 0, IO_SIZE, 0},
unknown's avatar
unknown committed
5856 5857
  {"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!",
5858 5859
   (uchar**) &global_system_variables.bulk_insert_buff_size,
   (uchar**) &max_system_variables.bulk_insert_buff_size,
unknown's avatar
unknown committed
5860
   0, GET_ULONG, REQUIRED_ARG, 8192*1024, 0, ~0L, 0, 1, 0},
5861
  {"connect_timeout", OPT_CONNECT_TIMEOUT,
5862
   "The number of seconds the mysqld server is waiting for a connect packet before responding with 'Bad handshake'.",
5863
    (uchar**) &connect_timeout, (uchar**) &connect_timeout,
unknown's avatar
unknown committed
5864
   0, GET_ULONG, REQUIRED_ARG, CONNECT_TIMEOUT, 2, LONG_TIMEOUT, 0, 1, 0 },
unknown's avatar
unknown committed
5865 5866
  { "date_format", OPT_DATE_FORMAT,
    "The DATE format (For future).",
5867 5868
    (uchar**) &opt_date_time_formats[MYSQL_TIMESTAMP_DATE],
    (uchar**) &opt_date_time_formats[MYSQL_TIMESTAMP_DATE],
unknown's avatar
unknown committed
5869 5870 5871
    0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  { "datetime_format", OPT_DATETIME_FORMAT,
    "The DATETIME/TIMESTAMP format (for future).",
5872 5873
    (uchar**) &opt_date_time_formats[MYSQL_TIMESTAMP_DATETIME],
    (uchar**) &opt_date_time_formats[MYSQL_TIMESTAMP_DATETIME],
unknown's avatar
unknown committed
5874 5875 5876
    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.",
5877 5878
    (uchar**) &global_system_variables.default_week_format,
    (uchar**) &max_system_variables.default_week_format,
unknown's avatar
unknown committed
5879
    0, GET_ULONG, REQUIRED_ARG, 0, 0, 7L, 0, 1, 0},
5880 5881
  {"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.",
5882
    (uchar**) &delayed_insert_limit, (uchar**) &delayed_insert_limit, 0, GET_ULONG,
5883
    REQUIRED_ARG, DELAYED_LIMIT, 1, ~0L, 0, 1, 0},
unknown's avatar
unknown committed
5884 5885
  {"delayed_insert_timeout", OPT_DELAYED_INSERT_TIMEOUT,
   "How long a INSERT DELAYED thread should wait for INSERT statements before terminating.",
5886
   (uchar**) &delayed_insert_timeout, (uchar**) &delayed_insert_timeout, 0,
unknown's avatar
unknown committed
5887
   GET_ULONG, REQUIRED_ARG, DELAYED_WAIT_TIMEOUT, 1, LONG_TIMEOUT, 0, 1, 0},
5888 5889
  { "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.",
5890
    (uchar**) &delayed_queue_size, (uchar**) &delayed_queue_size, 0, GET_ULONG,
5891
    REQUIRED_ARG, DELAYED_QUEUE_SIZE, 1, ~0L, 0, 1, 0},
unknown's avatar
unknown committed
5892 5893
  {"div_precision_increment", OPT_DIV_PRECINCREMENT,
   "Precision of the result of '/' operator will be increased on that value.",
5894 5895
   (uchar**) &global_system_variables.div_precincrement,
   (uchar**) &max_system_variables.div_precincrement, 0, GET_ULONG,
unknown's avatar
unknown committed
5896
   REQUIRED_ARG, 4, 0, DECIMAL_MAX_SCALE, 0, 0, 0},
unknown's avatar
unknown committed
5897
  {"expire_logs_days", OPT_EXPIRE_LOGS_DAYS,
5898 5899
   "If non-zero, binary logs will be purged after expire_logs_days "
   "days; possible purges happen at startup and at binary log rotation.",
5900 5901
   (uchar**) &expire_logs_days,
   (uchar**) &expire_logs_days, 0, GET_ULONG,
unknown's avatar
unknown committed
5902
   REQUIRED_ARG, 0, 0, 99, 0, 1, 0},
5903 5904
  { "flush_time", OPT_FLUSH_TIME,
    "A dedicated thread is created to flush all tables at the given interval.",
5905
    (uchar**) &flush_time, (uchar**) &flush_time, 0, GET_ULONG, REQUIRED_ARG,
5906
    FLUSH_TIME, 0, LONG_TIMEOUT, 0, 1, 0},
unknown's avatar
unknown committed
5907 5908 5909 5910
  { "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},
5911 5912
  { "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.",
5913
    (uchar**) &ft_max_word_len, (uchar**) &ft_max_word_len, 0, GET_ULONG,
5914
    REQUIRED_ARG, HA_FT_MAXCHARLEN, 10, HA_FT_MAXCHARLEN, 0, 1, 0},
unknown's avatar
unknown committed
5915 5916
  { "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.",
5917
    (uchar**) &ft_min_word_len, (uchar**) &ft_min_word_len, 0, GET_ULONG,
unknown's avatar
unknown committed
5918
    REQUIRED_ARG, 4, 1, HA_FT_MAXCHARLEN, 0, 1, 0},
5919 5920
  { "ft_query_expansion_limit", OPT_FT_QUERY_EXPANSION_LIMIT,
    "Number of best matches to use for query expansion",
5921
    (uchar**) &ft_query_expansion_limit, (uchar**) &ft_query_expansion_limit, 0, GET_ULONG,
5922
    REQUIRED_ARG, 20, 0, 1000, 0, 1, 0},
5923 5924
  { "ft_stopword_file", OPT_FT_STOPWORD_FILE,
    "Use stopwords from this file instead of built-in list.",
5925
    (uchar**) &ft_stopword_file, (uchar**) &ft_stopword_file, 0, GET_STR,
5926
    REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
5927 5928
  { "group_concat_max_len", OPT_GROUP_CONCAT_MAX_LEN,
    "The maximum length of the result of function  group_concat.",
5929 5930
    (uchar**) &global_system_variables.group_concat_max_len,
    (uchar**) &max_system_variables.group_concat_max_len, 0, GET_ULONG,
unknown's avatar
unknown committed
5931
    REQUIRED_ARG, 1024, 4, (long) ~0, 0, 1, 0},
5932 5933
  {"interactive_timeout", OPT_INTERACTIVE_TIMEOUT,
   "The number of seconds the server waits for activity on an interactive connection before closing it.",
5934 5935
   (uchar**) &global_system_variables.net_interactive_timeout,
   (uchar**) &max_system_variables.net_interactive_timeout, 0,
5936 5937 5938
   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.",
5939 5940
   (uchar**) &global_system_variables.join_buff_size,
   (uchar**) &max_system_variables.join_buff_size, 0, GET_ULONG,
5941 5942 5943
   REQUIRED_ARG, 128*1024L, IO_SIZE*2+MALLOC_OVERHEAD, ~0L, MALLOC_OVERHEAD,
   IO_SIZE, 0},
  {"key_buffer_size", OPT_KEY_BUFFER_SIZE,
5944
   "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.",
5945 5946
   (uchar**) &dflt_key_cache_var.param_buff_size,
   (uchar**) 0,
unknown's avatar
unknown committed
5947
   0, (GET_ULL | GET_ASK_ADDR),
5948
   REQUIRED_ARG, KEY_CACHE_SIZE, MALLOC_OVERHEAD, ~(ulong) 0, MALLOC_OVERHEAD,
5949
   IO_SIZE, 0},
unknown's avatar
unknown committed
5950 5951
  {"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",
5952 5953
   (uchar**) &dflt_key_cache_var.param_age_threshold,
   (uchar**) 0,
unknown's avatar
unknown committed
5954 5955
   0, (GET_ULONG | GET_ASK_ADDR), REQUIRED_ARG, 
   300, 100, ~0L, 0, 100, 0},
unknown's avatar
unknown committed
5956 5957
  {"key_cache_block_size", OPT_KEY_CACHE_BLOCK_SIZE,
   "The default size of key cache blocks",
5958 5959
   (uchar**) &dflt_key_cache_var.param_block_size,
   (uchar**) 0,
unknown's avatar
unknown committed
5960
   0, (GET_ULONG | GET_ASK_ADDR), REQUIRED_ARG,
5961
   KEY_CACHE_BLOCK_SIZE, 512, 1024 * 16, 0, 512, 0},
5962 5963
  {"key_cache_division_limit", OPT_KEY_CACHE_DIVISION_LIMIT,
   "The minimum percentage of warm blocks in key cache",
5964 5965
   (uchar**) &dflt_key_cache_var.param_division_limit,
   (uchar**) 0,
unknown's avatar
unknown committed
5966
   0, (GET_ULONG | GET_ASK_ADDR) , REQUIRED_ARG, 100,
5967
   1, 100, 0, 1, 0},
5968 5969
  {"long_query_time", OPT_LONG_QUERY_TIME,
   "Log all queries that have taken more than long_query_time seconds to execute to file.",
5970 5971
   (uchar**) &global_system_variables.long_query_time,
   (uchar**) &max_system_variables.long_query_time, 0, GET_ULONG,
5972 5973
   REQUIRED_ARG, 10, 1, LONG_TIMEOUT, 0, 1, 0},
  {"lower_case_table_names", OPT_LOWER_CASE_TABLE_NAMES,
unknown's avatar
unknown committed
5974
   "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",
5975 5976
   (uchar**) &lower_case_table_names,
   (uchar**) &lower_case_table_names, 0, GET_UINT, OPT_ARG,
5977 5978 5979 5980 5981
#ifdef FN_NO_CASE_SENCE
    1
#else
    0
#endif
unknown's avatar
unknown committed
5982
   , 0, 2, 0, 1, 0},
5983 5984
  {"max_allowed_packet", OPT_MAX_ALLOWED_PACKET,
   "Max packetlength to send/receive from to server.",
5985 5986
   (uchar**) &global_system_variables.max_allowed_packet,
   (uchar**) &max_system_variables.max_allowed_packet, 0, GET_ULONG,
unknown's avatar
unknown committed
5987
   REQUIRED_ARG, 1024*1024L, 1024, 1024L*1024L*1024L, MALLOC_OVERHEAD, 1024, 0},
5988 5989
  {"max_binlog_cache_size", OPT_MAX_BINLOG_CACHE_SIZE,
   "Can be used to restrict the total size used to cache a multi-transaction query.",
5990
   (uchar**) &max_binlog_cache_size, (uchar**) &max_binlog_cache_size, 0,
5991 5992
   GET_ULONG, REQUIRED_ARG, ~0L, IO_SIZE, ~0L, 0, IO_SIZE, 0},
  {"max_binlog_size", OPT_MAX_BINLOG_SIZE,
5993 5994 5995
   "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.",
5996
   (uchar**) &max_binlog_size, (uchar**) &max_binlog_size, 0, GET_ULONG,
5997
   REQUIRED_ARG, 1024*1024L*1024L, IO_SIZE, 1024*1024L*1024L, 0, IO_SIZE, 0},
5998 5999
  {"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.",
6000
   (uchar**) &max_connect_errors, (uchar**) &max_connect_errors, 0, GET_ULONG,
6001
    REQUIRED_ARG, MAX_CONNECT_ERRORS, 1, ~0L, 0, 1, 0},
6002 6003
  // Default max_connections of 151 is larger than Apache's default max
  // children, to avoid "too many connections" error in a common setup
unknown's avatar
unknown committed
6004
  {"max_connections", OPT_MAX_CONNECTIONS,
6005 6006
   "The number of simultaneous clients allowed.", (uchar**) &max_connections,
   (uchar**) &max_connections, 0, GET_ULONG, REQUIRED_ARG, 151, 1, 100000, 0, 1,
unknown's avatar
unknown committed
6007
   0},
6008
  {"max_delayed_threads", OPT_MAX_DELAYED_THREADS,
6009
   "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.",
6010 6011
   (uchar**) &global_system_variables.max_insert_delayed_threads,
   (uchar**) &max_system_variables.max_insert_delayed_threads,
6012
   0, GET_ULONG, REQUIRED_ARG, 20, 0, 16384, 0, 1, 0},
6013
  {"max_error_count", OPT_MAX_ERROR_COUNT,
6014
   "Max number of errors/warnings to store for a statement.",
6015 6016
   (uchar**) &global_system_variables.max_error_count,
   (uchar**) &max_system_variables.max_error_count,
6017
   0, GET_ULONG, REQUIRED_ARG, DEFAULT_ERROR_COUNT, 0, 65535, 0, 1, 0},
6018 6019
  {"max_heap_table_size", OPT_MAX_HEP_TABLE_SIZE,
   "Don't allow creation of heap tables bigger than this.",
6020 6021
   (uchar**) &global_system_variables.max_heap_table_size,
   (uchar**) &max_system_variables.max_heap_table_size, 0, GET_ULL,
6022 6023
   REQUIRED_ARG, 16*1024*1024L, 16384, MAX_MEM_TABLE_SIZE,
   MALLOC_OVERHEAD, 1024, 0},
6024 6025
  {"max_join_size", OPT_MAX_JOIN_SIZE,
   "Joins that are probably going to read more than max_join_size records return an error.",
6026 6027
   (uchar**) &global_system_variables.max_join_size,
   (uchar**) &max_system_variables.max_join_size, 0, GET_HA_ROWS, REQUIRED_ARG,
6028
   ~0L, 1, ~0L, 0, 1, 0},
unknown's avatar
unknown committed
6029
   {"max_length_for_sort_data", OPT_MAX_LENGTH_FOR_SORT_DATA,
6030
    "Max number of bytes in sorted records.",
6031 6032
    (uchar**) &global_system_variables.max_length_for_sort_data,
    (uchar**) &max_system_variables.max_length_for_sort_data, 0, GET_ULONG,
unknown's avatar
unknown committed
6033
    REQUIRED_ARG, 1024, 4, 8192*1024L, 0, 1, 0},
6034
  {"max_prepared_stmt_count", OPT_MAX_PREPARED_STMT_COUNT,
unknown's avatar
unknown committed
6035
   "Maximum number of prepared statements in the server.",
6036
   (uchar**) &max_prepared_stmt_count, (uchar**) &max_prepared_stmt_count,
6037
   0, GET_ULONG, REQUIRED_ARG, 16382, 0, 1*1024*1024, 0, 1, 0},
6038
  {"max_relay_log_size", OPT_MAX_RELAY_LOG_SIZE,
6039
   "If non-zero: relay log will be rotated automatically when the size exceeds this value; if zero (the default): when the size exceeds max_binlog_size. 0 excepted, the minimum value for this variable is 4096.",
6040
   (uchar**) &max_relay_log_size, (uchar**) &max_relay_log_size, 0, GET_ULONG,
6041
   REQUIRED_ARG, 0L, 0L, 1024*1024L*1024L, 0, IO_SIZE, 0},
6042 6043
  { "max_seeks_for_key", OPT_MAX_SEEKS_FOR_KEY,
    "Limit assumed max number of seeks when looking up rows based on a key",
6044 6045
    (uchar**) &global_system_variables.max_seeks_for_key,
    (uchar**) &max_system_variables.max_seeks_for_key, 0, GET_ULONG,
6046
    REQUIRED_ARG, ~0L, 1, ~0L, 0, 1, 0 },
6047 6048
  {"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).",
6049 6050
   (uchar**) &global_system_variables.max_sort_length,
   (uchar**) &max_system_variables.max_sort_length, 0, GET_ULONG,
6051
   REQUIRED_ARG, 1024, 4, 8192*1024L, 0, 1, 0},
unknown's avatar
unknown committed
6052 6053
  {"max_sp_recursion_depth", OPT_MAX_SP_RECURSION_DEPTH,
   "Maximum stored procedure recursion depth. (discussed with docs).",
6054 6055
   (uchar**) &global_system_variables.max_sp_recursion_depth,
   (uchar**) &max_system_variables.max_sp_recursion_depth, 0, GET_ULONG,
unknown's avatar
unknown committed
6056
   OPT_ARG, 0, 0, 255, 0, 1, 0 },
6057 6058
  {"max_tmp_tables", OPT_MAX_TMP_TABLES,
   "Maximum number of temporary tables a client can keep open at a time.",
6059 6060
   (uchar**) &global_system_variables.max_tmp_tables,
   (uchar**) &max_system_variables.max_tmp_tables, 0, GET_ULONG,
6061 6062 6063
   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).",
6064
   (uchar**) &max_user_connections, (uchar**) &max_user_connections, 0, GET_UINT,
unknown's avatar
Merge  
unknown committed
6065
   REQUIRED_ARG, 0, 1, ~0, 0, 1, 0},
6066 6067
  {"max_write_lock_count", OPT_MAX_WRITE_LOCK_COUNT,
   "After this many write locks, allow some read locks to run in between.",
6068
   (uchar**) &max_write_lock_count, (uchar**) &max_write_lock_count, 0, GET_ULONG,
6069
   REQUIRED_ARG, ~0L, 1, ~0L, 0, 1, 0},
unknown's avatar
Merge  
unknown committed
6070 6071
  {"multi_range_count", OPT_MULTI_RANGE_COUNT,
   "Number of key ranges to request at once.",
6072 6073
   (uchar**) &global_system_variables.multi_range_count,
   (uchar**) &max_system_variables.multi_range_count, 0,
unknown's avatar
Merge  
unknown committed
6074
   GET_ULONG, REQUIRED_ARG, 256, 1, ~0L, 0, 1, 0},
6075
  {"myisam_block_size", OPT_MYISAM_BLOCK_SIZE,
6076
   "Block size to be used for MyISAM index pages.",
6077 6078
   (uchar**) &opt_myisam_block_size,
   (uchar**) &opt_myisam_block_size, 0, GET_ULONG, REQUIRED_ARG,
6079 6080
   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
6081 6082
  {"myisam_data_pointer_size", OPT_MYISAM_DATA_POINTER_SIZE,
   "Default pointer size to be used for MyISAM tables.",
6083 6084
   (uchar**) &myisam_data_pointer_size,
   (uchar**) &myisam_data_pointer_size, 0, GET_ULONG, REQUIRED_ARG,
unknown's avatar
unknown committed
6085
   6, 2, 7, 0, 1, 0},
6086
  {"myisam_max_extra_sort_file_size", OPT_MYISAM_MAX_EXTRA_SORT_FILE_SIZE,
unknown's avatar
unknown committed
6087
   "Deprecated option",
6088 6089
   (uchar**) &global_system_variables.myisam_max_extra_sort_file_size,
   (uchar**) &max_system_variables.myisam_max_extra_sort_file_size,
unknown's avatar
unknown committed
6090
   0, GET_ULL, REQUIRED_ARG, (ulonglong) MI_MAX_TEMP_LENGTH,
6091
   0, (ulonglong) MAX_FILE_SIZE, 0, 1, 0},
6092
  {"myisam_max_sort_file_size", OPT_MYISAM_MAX_SORT_FILE_SIZE,
6093
   "Don't use the fast sort index method to created index if the temporary file would get bigger than this.",
6094 6095
   (uchar**) &global_system_variables.myisam_max_sort_file_size,
   (uchar**) &max_system_variables.myisam_max_sort_file_size, 0,
6096 6097
   GET_ULL, REQUIRED_ARG, (longlong) LONG_MAX, 0, (ulonglong) MAX_FILE_SIZE,
   0, 1024*1024, 0},
6098 6099
  {"myisam_repair_threads", OPT_MYISAM_REPAIR_THREADS,
   "Number of threads to use when repairing MyISAM tables. The value of 1 disables parallel repair.",
6100 6101
   (uchar**) &global_system_variables.myisam_repair_threads,
   (uchar**) &max_system_variables.myisam_repair_threads, 0,
6102
   GET_ULONG, REQUIRED_ARG, 1, 1, ~0L, 0, 1, 0},
6103 6104
  {"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.",
6105 6106
   (uchar**) &global_system_variables.myisam_sort_buff_size,
   (uchar**) &max_system_variables.myisam_sort_buff_size, 0,
6107
   GET_ULONG, REQUIRED_ARG, 8192*1024, 4, ~0L, 0, 1, 0},
unknown's avatar
unknown committed
6108
  {"myisam_use_mmap", OPT_MYISAM_USE_MMAP,
unknown's avatar
unknown committed
6109
   "Use memory mapping for reading and writing MyISAM tables",
6110 6111
   (uchar**) &opt_myisam_use_mmap,
   (uchar**) &opt_myisam_use_mmap, 0, GET_BOOL, NO_ARG, 0, 
unknown's avatar
unknown committed
6112
    0, 0, 0, 0, 0},
6113 6114
  {"myisam_stats_method", OPT_MYISAM_STATS_METHOD,
   "Specifies how MyISAM index statistics collection code should threat NULLs. "
6115 6116
   "Possible values of name are \"nulls_unequal\" (default behavior for 4.1/5.0), "
   "\"nulls_equal\" (emulate 4.0 behavior), and \"nulls_ignored\".",
6117
   (uchar**) &myisam_stats_method_str, (uchar**) &myisam_stats_method_str, 0,
6118
    GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
6119
  {"net_buffer_length", OPT_NET_BUFFER_LENGTH,
6120
   "Buffer length for TCP/IP and socket communication.",
6121 6122
   (uchar**) &global_system_variables.net_buffer_length,
   (uchar**) &max_system_variables.net_buffer_length, 0, GET_ULONG,
unknown's avatar
unknown committed
6123
   REQUIRED_ARG, 16384, 1024, 1024*1024L, 0, 1024, 0},
6124 6125
  {"net_read_timeout", OPT_NET_READ_TIMEOUT,
   "Number of seconds to wait for more data from a connection before aborting the read.",
6126 6127
   (uchar**) &global_system_variables.net_read_timeout,
   (uchar**) &max_system_variables.net_read_timeout, 0, GET_ULONG,
6128
   REQUIRED_ARG, NET_READ_TIMEOUT, 1, LONG_TIMEOUT, 0, 1, 0},
unknown's avatar
unknown committed
6129 6130
  {"net_retry_count", OPT_NET_RETRY_COUNT,
   "If a read on a communication port is interrupted, retry this many times before giving up.",
6131 6132
   (uchar**) &global_system_variables.net_retry_count,
   (uchar**) &max_system_variables.net_retry_count,0,
unknown's avatar
unknown committed
6133
   GET_ULONG, REQUIRED_ARG, MYSQLD_NET_RETRY_COUNT, 1, ~0L, 0, 1, 0},
6134 6135
  {"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.",
6136 6137
   (uchar**) &global_system_variables.net_write_timeout,
   (uchar**) &max_system_variables.net_write_timeout, 0, GET_ULONG,
6138
   REQUIRED_ARG, NET_WRITE_TIMEOUT, 1, LONG_TIMEOUT, 0, 1, 0},
unknown's avatar
unknown committed
6139
  { "old", OPT_OLD_MODE, "Use compatible behavior.", 
6140 6141
    (uchar**) &global_system_variables.old_mode,
    (uchar**) &max_system_variables.old_mode, 0, GET_BOOL, NO_ARG, 
6142
    0, 0, 0, 0, 0, 0},
6143 6144
  {"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.",
6145
   (uchar**) &open_files_limit, (uchar**) &open_files_limit, 0, GET_ULONG,
6146
   REQUIRED_ARG, 0, 0, OS_FILE_LIMIT, 0, 1, 0},
unknown's avatar
Merge  
unknown committed
6147 6148
  {"optimizer_prune_level", OPT_OPTIMIZER_PRUNE_LEVEL,
   "Controls the heuristic(s) applied during query optimization to prune less-promising partial plans from the optimizer search space. Meaning: 0 - do not apply any heuristic, thus perform exhaustive search; 1 - prune plans based on number of retrieved rows.",
6149 6150
   (uchar**) &global_system_variables.optimizer_prune_level,
   (uchar**) &max_system_variables.optimizer_prune_level,
unknown's avatar
Merge  
unknown committed
6151 6152 6153
   0, GET_ULONG, OPT_ARG, 1, 0, 1, 0, 1, 0},
  {"optimizer_search_depth", OPT_OPTIMIZER_SEARCH_DEPTH,
   "Maximum depth of search performed by the query optimizer. Values larger than the number of relations in a query result in better query plans, but take longer to compile a query. Smaller values than the number of tables in a relation result in faster optimization, but may produce very bad query plans. If set to 0, the system will automatically pick a reasonable value; if set to MAX_TABLES+2, the optimizer will switch to the original find_best (used for testing/comparison).",
6154 6155
   (uchar**) &global_system_variables.optimizer_search_depth,
   (uchar**) &max_system_variables.optimizer_search_depth,
unknown's avatar
Merge  
unknown committed
6156
   0, GET_ULONG, OPT_ARG, MAX_TABLES+1, 0, MAX_TABLES+2, 0, 1, 0},
6157 6158
  {"plugin_dir", OPT_PLUGIN_DIR,
   "Directory for plugins.",
6159
   (uchar**) &opt_plugin_dir_ptr, (uchar**) &opt_plugin_dir_ptr, 0,
6160
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
unknown committed
6161 6162 6163
  {"plugin_load", OPT_PLUGIN_LOAD,
   "Optional colon separated list of plugins to load, where each plugin is "
   "identified by name and path to library seperated by an equals.",
6164
   (uchar**) &opt_plugin_load, (uchar**) &opt_plugin_load, 0,
unknown's avatar
unknown committed
6165
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
6166
  {"preload_buffer_size", OPT_PRELOAD_BUFFER_SIZE,
unknown's avatar
unknown committed
6167
    "The size of the buffer that is allocated when preloading indexes",
6168 6169
    (uchar**) &global_system_variables.preload_buff_size,
    (uchar**) &max_system_variables.preload_buff_size, 0, GET_ULONG,
unknown's avatar
unknown committed
6170
    REQUIRED_ARG, 32*1024L, 1024, 1024*1024*1024L, 0, 1, 0},
6171 6172
  {"query_alloc_block_size", OPT_QUERY_ALLOC_BLOCK_SIZE,
   "Allocation block size for query parsing and execution",
6173 6174
   (uchar**) &global_system_variables.query_alloc_block_size,
   (uchar**) &max_system_variables.query_alloc_block_size, 0, GET_ULONG,
6175
   REQUIRED_ARG, QUERY_ALLOC_BLOCK_SIZE, 1024, ~0L, 0, 1024, 0},
unknown's avatar
unknown committed
6176
#ifdef HAVE_QUERY_CACHE
6177 6178
  {"query_cache_limit", OPT_QUERY_CACHE_LIMIT,
   "Don't cache results that are bigger than this.",
6179
   (uchar**) &query_cache_limit, (uchar**) &query_cache_limit, 0, GET_ULONG,
6180
   REQUIRED_ARG, 1024*1024L, 0, (longlong) ULONG_MAX, 0, 1, 0},
6181 6182
  {"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.",
6183
   (uchar**) &query_cache_min_res_unit, (uchar**) &query_cache_min_res_unit,
6184 6185
   0, GET_ULONG, REQUIRED_ARG, QUERY_CACHE_MIN_RESULT_DATA_SIZE,
   0, (longlong) ULONG_MAX, 0, 1, 0},
6186
#endif /*HAVE_QUERY_CACHE*/
6187 6188
  {"query_cache_size", OPT_QUERY_CACHE_SIZE,
   "The memory allocated to store results from old queries.",
6189
   (uchar**) &query_cache_size, (uchar**) &query_cache_size, 0, GET_ULONG,
unknown's avatar
unknown committed
6190
   REQUIRED_ARG, 0, 0, (longlong) ULONG_MAX, 0, 1024, 0},
6191
#ifdef HAVE_QUERY_CACHE
unknown's avatar
unknown committed
6192
  {"query_cache_type", OPT_QUERY_CACHE_TYPE,
6193
   "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.",
6194 6195
   (uchar**) &global_system_variables.query_cache_type,
   (uchar**) &max_system_variables.query_cache_type,
unknown's avatar
unknown committed
6196
   0, GET_ULONG, REQUIRED_ARG, 1, 0, 2, 0, 1, 0},
6197 6198
  {"query_cache_wlock_invalidate", OPT_QUERY_CACHE_WLOCK_INVALIDATE,
   "Invalidate queries in query cache on LOCK for write",
6199 6200
   (uchar**) &global_system_variables.query_cache_wlock_invalidate,
   (uchar**) &max_system_variables.query_cache_wlock_invalidate,
6201 6202
   0, GET_BOOL, NO_ARG, 0, 0, 1, 0, 1, 0},
#endif /*HAVE_QUERY_CACHE*/
6203 6204
  {"query_prealloc_size", OPT_QUERY_PREALLOC_SIZE,
   "Persistent buffer for query parsing and execution",
6205 6206
   (uchar**) &global_system_variables.query_prealloc_size,
   (uchar**) &max_system_variables.query_prealloc_size, 0, GET_ULONG,
6207 6208
   REQUIRED_ARG, QUERY_ALLOC_PREALLOC_SIZE, QUERY_ALLOC_PREALLOC_SIZE,
   ~0L, 0, 1024, 0},
unknown's avatar
unknown committed
6209 6210
  {"range_alloc_block_size", OPT_RANGE_ALLOC_BLOCK_SIZE,
   "Allocation block size for storing ranges during optimization",
6211 6212
   (uchar**) &global_system_variables.range_alloc_block_size,
   (uchar**) &max_system_variables.range_alloc_block_size, 0, GET_ULONG,
6213
   REQUIRED_ARG, RANGE_ALLOC_BLOCK_SIZE, 4096, ~0L, 0, 1024, 0},
unknown's avatar
unknown committed
6214
  {"read_buffer_size", OPT_RECORD_BUFFER,
6215
   "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.",
6216 6217
   (uchar**) &global_system_variables.read_buff_size,
   (uchar**) &max_system_variables.read_buff_size,0, GET_ULONG, REQUIRED_ARG,
6218 6219
   128*1024L, IO_SIZE*2+MALLOC_OVERHEAD, SSIZE_MAX, MALLOC_OVERHEAD, IO_SIZE,
   0},
unknown's avatar
unknown committed
6220
  {"read_only", OPT_READONLY,
6221
   "Make all non-temporary tables read-only, with the exception for replication (slave) threads and users with the SUPER privilege",
6222 6223
   (uchar**) &opt_readonly,
   (uchar**) &opt_readonly,
unknown's avatar
unknown committed
6224
   0, GET_BOOL, NO_ARG, 0, 0, 1, 0, 1, 0},
unknown's avatar
unknown committed
6225
  {"read_rnd_buffer_size", OPT_RECORD_RND_BUFFER,
6226
   "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.",
6227 6228
   (uchar**) &global_system_variables.read_rnd_buff_size,
   (uchar**) &max_system_variables.read_rnd_buff_size, 0,
unknown's avatar
unknown committed
6229
   GET_ULONG, REQUIRED_ARG, 256*1024L, IO_SIZE*2+MALLOC_OVERHEAD,
6230
   SSIZE_MAX, MALLOC_OVERHEAD, IO_SIZE, 0},
unknown's avatar
unknown committed
6231 6232
  {"record_buffer", OPT_RECORD_BUFFER,
   "Alias for read_buffer_size",
6233 6234
   (uchar**) &global_system_variables.read_buff_size,
   (uchar**) &max_system_variables.read_buff_size,0, GET_ULONG, REQUIRED_ARG,
6235
   128*1024L, IO_SIZE*2+MALLOC_OVERHEAD, SSIZE_MAX, MALLOC_OVERHEAD, IO_SIZE, 0},
unknown's avatar
SCRUM  
unknown committed
6236
#ifdef HAVE_REPLICATION
6237 6238
  {"relay_log_purge", OPT_RELAY_LOG_PURGE,
   "0 = do not purge relay logs. 1 = purge them as soon as they are no more needed.",
6239 6240
   (uchar**) &relay_log_purge,
   (uchar**) &relay_log_purge, 0, GET_BOOL, NO_ARG,
6241
   1, 0, 1, 0, 1, 0},
6242
  {"relay_log_space_limit", OPT_RELAY_LOG_SPACE_LIMIT,
6243
   "Maximum space to use for all relay logs.",
6244 6245
   (uchar**) &relay_log_space_limit,
   (uchar**) &relay_log_space_limit, 0, GET_ULL, REQUIRED_ARG, 0L, 0L,
6246
   (longlong) ULONG_MAX, 0, 1, 0},
6247
  {"slave_compressed_protocol", OPT_SLAVE_COMPRESSED_PROTOCOL,
6248
   "Use compression on master/slave protocol.",
6249 6250
   (uchar**) &opt_slave_compressed_protocol,
   (uchar**) &opt_slave_compressed_protocol,
6251
   0, GET_BOOL, NO_ARG, 0, 0, 1, 0, 1, 0},
6252
  {"slave_net_timeout", OPT_SLAVE_NET_TIMEOUT,
unknown's avatar
unknown committed
6253
   "Number of seconds to wait for more data from a master/slave connection before aborting the read.",
6254
   (uchar**) &slave_net_timeout, (uchar**) &slave_net_timeout, 0,
6255
   GET_ULONG, REQUIRED_ARG, SLAVE_NET_TIMEOUT, 1, LONG_TIMEOUT, 0, 1, 0},
6256 6257 6258 6259
  {"slave_transaction_retries", OPT_SLAVE_TRANS_RETRIES,
   "Number of times the slave SQL thread will retry a transaction in case "
   "it failed with a deadlock or elapsed lock wait timeout, "
   "before giving up and stopping.",
6260
   (uchar**) &slave_trans_retries, (uchar**) &slave_trans_retries, 0,
6261
   GET_ULONG, REQUIRED_ARG, 10L, 0L, (longlong) ULONG_MAX, 0, 1, 0},
6262
#endif /* HAVE_REPLICATION */
6263 6264
  {"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.",
6265
   (uchar**) &slow_launch_time, (uchar**) &slow_launch_time, 0, GET_ULONG,
6266
   REQUIRED_ARG, 2L, 0L, LONG_TIMEOUT, 0, 1, 0},
unknown's avatar
unknown committed
6267
  {"sort_buffer_size", OPT_SORT_BUFFER,
6268
   "Each thread that needs to do a sort allocates a buffer of this size.",
6269 6270
   (uchar**) &global_system_variables.sortbuff_size,
   (uchar**) &max_system_variables.sortbuff_size, 0, GET_ULONG, REQUIRED_ARG,
6271 6272
   MAX_SORT_MEMORY, MIN_SORT_MEMORY+MALLOC_OVERHEAD*2, ~0L, MALLOC_OVERHEAD,
   1, 0},
6273
  {"sync-binlog", OPT_SYNC_BINLOG,
6274 6275
   "Synchronously flush binary log to disk after every #th event. "
   "Use 0 (default) to disable synchronous flushing.",
6276
   (uchar**) &sync_binlog_period, (uchar**) &sync_binlog_period, 0, GET_ULONG,
unknown's avatar
unknown committed
6277
   REQUIRED_ARG, 0, 0, ~0L, 0, 1, 0},
6278
  {"sync-frm", OPT_SYNC_FRM, "Sync .frm to disk on create. Enabled by default.",
6279
   (uchar**) &opt_sync_frm, (uchar**) &opt_sync_frm, 0, GET_BOOL, NO_ARG, 1, 0,
6280
   0, 0, 0, 0},
unknown's avatar
unknown committed
6281 6282
  {"table_cache", OPT_TABLE_OPEN_CACHE,
   "Deprecated; use --table_open_cache instead.",
6283
   (uchar**) &table_cache_size, (uchar**) &table_cache_size, 0, GET_ULONG,
6284
   REQUIRED_ARG, TABLE_OPEN_CACHE_DEFAULT, 1, 512*1024L, 0, 1, 0},
unknown's avatar
unknown committed
6285 6286
  {"table_definition_cache", OPT_TABLE_DEF_CACHE,
   "The number of cached table definitions.",
6287
   (uchar**) &table_def_size, (uchar**) &table_def_size,
unknown's avatar
unknown committed
6288 6289 6290
   0, GET_ULONG, REQUIRED_ARG, 128, 1, 512*1024L, 0, 1, 0},
  {"table_open_cache", OPT_TABLE_OPEN_CACHE,
   "The number of cached open tables.",
6291
   (uchar**) &table_cache_size, (uchar**) &table_cache_size, 0, GET_ULONG,
6292
   REQUIRED_ARG, TABLE_OPEN_CACHE_DEFAULT, 1, 512*1024L, 0, 1, 0},
unknown's avatar
unknown committed
6293 6294 6295
  {"table_lock_wait_timeout", OPT_TABLE_LOCK_WAIT_TIMEOUT,
   "Timeout in seconds to wait for a table level lock before returning an "
   "error. Used only if the connection has active cursors.",
6296
   (uchar**) &table_lock_wait_timeout, (uchar**) &table_lock_wait_timeout,
6297
   0, GET_ULONG, REQUIRED_ARG, 50, 1, 1024 * 1024 * 1024, 0, 1, 0},
6298 6299
  {"thread_cache_size", OPT_THREAD_CACHE_SIZE,
   "How many threads we should keep in a cache for reuse.",
6300
   (uchar**) &thread_cache_size, (uchar**) &thread_cache_size, 0, GET_ULONG,
6301
   REQUIRED_ARG, 0, 0, 16384, 0, 1, 0},
unknown's avatar
unknown committed
6302 6303
  {"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.",
6304
   (uchar**) &concurrency, (uchar**) &concurrency, 0, GET_ULONG, REQUIRED_ARG,
unknown's avatar
unknown committed
6305
   DEFAULT_CONCURRENCY, 1, 512, 0, 1, 0},
unknown's avatar
unknown committed
6306 6307 6308
#if HAVE_POOL_OF_THREADS == 1
  {"thread_pool_size", OPT_THREAD_CACHE_SIZE,
   "How many threads we should create to handle query requests in case of 'thread_handling=pool-of-threads'",
6309
   (uchar**) &thread_pool_size, (uchar**) &thread_pool_size, 0, GET_ULONG,
unknown's avatar
unknown committed
6310 6311
   REQUIRED_ARG, 20, 1, 16384, 0, 1, 0},
#endif
unknown's avatar
unknown committed
6312
  {"thread_stack", OPT_THREAD_STACK,
6313 6314
   "The stack size for each thread.", (uchar**) &thread_stack,
   (uchar**) &thread_stack, 0, GET_ULONG, REQUIRED_ARG,DEFAULT_THREAD_STACK,
unknown's avatar
unknown committed
6315 6316 6317
   1024L*128L, ~0L, 0, 1024, 0},
  { "time_format", OPT_TIME_FORMAT,
    "The TIME format (for future).",
6318 6319
    (uchar**) &opt_date_time_formats[MYSQL_TIMESTAMP_TIME],
    (uchar**) &opt_date_time_formats[MYSQL_TIMESTAMP_TIME],
unknown's avatar
unknown committed
6320
    0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
6321 6322
  {"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.",
6323 6324
   (uchar**) &global_system_variables.tmp_table_size,
   (uchar**) &max_system_variables.tmp_table_size, 0, GET_ULL,
unknown's avatar
unknown committed
6325
   REQUIRED_ARG, 16*1024*1024L, 1024, MAX_MEM_TABLE_SIZE, 0, 1, 0},
6326
  {"transaction_alloc_block_size", OPT_TRANS_ALLOC_BLOCK_SIZE,
6327
   "Allocation block size for various transaction-related structures",
6328 6329
   (uchar**) &global_system_variables.trans_alloc_block_size,
   (uchar**) &max_system_variables.trans_alloc_block_size, 0, GET_ULONG,
6330 6331
   REQUIRED_ARG, QUERY_ALLOC_BLOCK_SIZE, 1024, ~0L, 0, 1024, 0},
  {"transaction_prealloc_size", OPT_TRANS_PREALLOC_SIZE,
6332
   "Persistent buffer for various transaction-related structures",
6333 6334
   (uchar**) &global_system_variables.trans_prealloc_size,
   (uchar**) &max_system_variables.trans_prealloc_size, 0, GET_ULONG,
6335
   REQUIRED_ARG, TRANS_ALLOC_PREALLOC_SIZE, 1024, ~0L, 0, 1024, 0},
unknown's avatar
unknown committed
6336 6337 6338 6339
  {"thread_handling", OPT_THREAD_HANDLING,
   "Define threads usage for handling queries:  "
   "one-thread-per-connection or no-threads", 0, 0,
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
unknown's avatar
Merge  
unknown committed
6340 6341
  {"updatable_views_with_limit", OPT_UPDATABLE_VIEWS_WITH_LIMIT,
   "1 = YES = Don't issue an error message (warning only) if a VIEW without presence of a key of the underlying table is used in queries with a LIMIT clause for updating. 0 = NO = Prohibit update of a VIEW, which does not contain a key of the underlying table and the query uses a LIMIT clause (usually get from GUI tools).",
6342 6343
   (uchar**) &global_system_variables.updatable_views_with_limit,
   (uchar**) &max_system_variables.updatable_views_with_limit,
unknown's avatar
Merge  
unknown committed
6344
   0, GET_ULONG, REQUIRED_ARG, 1, 0, 1, 0, 1, 0},
6345
  {"wait_timeout", OPT_WAIT_TIMEOUT,
6346
   "The number of seconds the server waits for activity on a connection before closing it.",
6347 6348
   (uchar**) &global_system_variables.net_wait_timeout,
   (uchar**) &max_system_variables.net_wait_timeout, 0, GET_ULONG,
6349 6350
   REQUIRED_ARG, NET_WAIT_TIMEOUT, 1, IF_WIN(INT_MAX32/1000, LONG_TIMEOUT),
   0, 1, 0},
6351
  {0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
6352
};
unknown's avatar
unknown committed
6353

6354
static int show_question(THD *thd, SHOW_VAR *var, char *buff)
6355
{
6356
  var->type= SHOW_LONGLONG;
6357 6358 6359 6360
  var->value= (char *)&thd->query_id;
  return 0;
}

6361
static int show_net_compression(THD *thd, SHOW_VAR *var, char *buff)
6362
{
6363
  var->type= SHOW_MY_BOOL;
6364 6365 6366 6367
  var->value= (char *)&thd->net.compress;
  return 0;
}

6368
static int show_starttime(THD *thd, SHOW_VAR *var, char *buff)
6369
{
6370
  var->type= SHOW_LONG;
6371
  var->value= buff;
unknown's avatar
unknown committed
6372
  *((long *)buff)= (long) (thd->query_start() - server_start_time);
6373 6374 6375 6376
  return 0;
}

#ifdef HAVE_REPLICATION
6377
static int show_rpl_status(THD *thd, SHOW_VAR *var, char *buff)
6378
{
6379
  var->type= SHOW_CHAR;
6380 6381 6382 6383
  var->value= const_cast<char*>(rpl_status_type[(int)rpl_status]);
  return 0;
}

6384
static int show_slave_running(THD *thd, SHOW_VAR *var, char *buff)
6385
{
6386
  var->type= SHOW_MY_BOOL;
6387
  pthread_mutex_lock(&LOCK_active_mi);
6388 6389 6390
  var->value= buff;
  *((my_bool *)buff)= (my_bool) (active_mi && active_mi->slave_running &&
                                 active_mi->rli.slave_running);
6391 6392 6393 6394
  pthread_mutex_unlock(&LOCK_active_mi);
  return 0;
}

6395
static int show_slave_retried_trans(THD *thd, SHOW_VAR *var, char *buff)
6396 6397 6398 6399 6400 6401 6402 6403
{
  /*
    TODO: with multimaster, have one such counter per line in
    SHOW SLAVE STATUS, and have the sum over all lines here.
  */
  pthread_mutex_lock(&LOCK_active_mi);
  if (active_mi)
  {
6404
    var->type= SHOW_LONG;
6405 6406 6407 6408 6409 6410
    var->value= buff;
    pthread_mutex_lock(&active_mi->rli.data_lock);
    *((long *)buff)= (long)active_mi->rli.retried_trans;
    pthread_mutex_unlock(&active_mi->rli.data_lock);
  }
  else
6411
    var->type= SHOW_UNDEF;
6412 6413 6414 6415 6416
  pthread_mutex_unlock(&LOCK_active_mi);
  return 0;
}
#endif /* HAVE_REPLICATION */

6417
static int show_open_tables(THD *thd, SHOW_VAR *var, char *buff)
6418
{
6419
  var->type= SHOW_LONG;
6420 6421 6422 6423 6424
  var->value= buff;
  *((long *)buff)= (long)cached_open_tables();
  return 0;
}

unknown's avatar
unknown committed
6425 6426 6427 6428 6429 6430 6431 6432 6433 6434
static int show_prepared_stmt_count(THD *thd, SHOW_VAR *var, char *buff)
{
  var->type= SHOW_LONG;
  var->value= buff;
  pthread_mutex_lock(&LOCK_prepared_stmt_count);
  *((long *)buff)= (long)prepared_stmt_count;
  pthread_mutex_unlock(&LOCK_prepared_stmt_count);
  return 0;
}

6435
static int show_table_definitions(THD *thd, SHOW_VAR *var, char *buff)
6436
{
6437
  var->type= SHOW_LONG;
6438 6439 6440 6441 6442 6443 6444
  var->value= buff;
  *((long *)buff)= (long)cached_table_definitions();
  return 0;
}

#ifdef HAVE_OPENSSL
/* Functions relying on CTX */
6445
static int show_ssl_ctx_sess_accept(THD *thd, SHOW_VAR *var, char *buff)
6446
{
6447
  var->type= SHOW_LONG;
6448 6449 6450 6451 6452 6453
  var->value= buff;
  *((long *)buff)= (!ssl_acceptor_fd ? 0 :
                     SSL_CTX_sess_accept(ssl_acceptor_fd->ssl_context));
  return 0;
}

6454
static int show_ssl_ctx_sess_accept_good(THD *thd, SHOW_VAR *var, char *buff)
6455
{
6456
  var->type= SHOW_LONG;
6457 6458 6459 6460 6461 6462
  var->value= buff;
  *((long *)buff)= (!ssl_acceptor_fd ? 0 :
                     SSL_CTX_sess_accept_good(ssl_acceptor_fd->ssl_context));
  return 0;
}

6463
static int show_ssl_ctx_sess_connect_good(THD *thd, SHOW_VAR *var, char *buff)
6464
{
6465
  var->type= SHOW_LONG;
6466 6467 6468 6469 6470 6471
  var->value= buff;
  *((long *)buff)= (!ssl_acceptor_fd ? 0 :
                     SSL_CTX_sess_connect_good(ssl_acceptor_fd->ssl_context));
  return 0;
}

6472
static int show_ssl_ctx_sess_accept_renegotiate(THD *thd, SHOW_VAR *var, char *buff)
6473
{
6474
  var->type= SHOW_LONG;
6475 6476 6477 6478 6479 6480
  var->value= buff;
  *((long *)buff)= (!ssl_acceptor_fd ? 0 :
                     SSL_CTX_sess_accept_renegotiate(ssl_acceptor_fd->ssl_context));
  return 0;
}

6481
static int show_ssl_ctx_sess_connect_renegotiate(THD *thd, SHOW_VAR *var, char *buff)
6482
{
6483
  var->type= SHOW_LONG;
6484 6485 6486 6487 6488 6489
  var->value= buff;
  *((long *)buff)= (!ssl_acceptor_fd ? 0 :
                     SSL_CTX_sess_connect_renegotiate(ssl_acceptor_fd->ssl_context));
  return 0;
}

6490
static int show_ssl_ctx_sess_cb_hits(THD *thd, SHOW_VAR *var, char *buff)
6491
{
6492
  var->type= SHOW_LONG;
6493 6494 6495 6496 6497 6498
  var->value= buff;
  *((long *)buff)= (!ssl_acceptor_fd ? 0 :
                     SSL_CTX_sess_cb_hits(ssl_acceptor_fd->ssl_context));
  return 0;
}

6499
static int show_ssl_ctx_sess_hits(THD *thd, SHOW_VAR *var, char *buff)
6500
{
6501
  var->type= SHOW_LONG;
6502 6503 6504 6505 6506 6507
  var->value= buff;
  *((long *)buff)= (!ssl_acceptor_fd ? 0 :
                     SSL_CTX_sess_hits(ssl_acceptor_fd->ssl_context));
  return 0;
}

6508
static int show_ssl_ctx_sess_cache_full(THD *thd, SHOW_VAR *var, char *buff)
6509
{
6510
  var->type= SHOW_LONG;
6511 6512 6513 6514 6515 6516
  var->value= buff;
  *((long *)buff)= (!ssl_acceptor_fd ? 0 :
                     SSL_CTX_sess_cache_full(ssl_acceptor_fd->ssl_context));
  return 0;
}

6517
static int show_ssl_ctx_sess_misses(THD *thd, SHOW_VAR *var, char *buff)
6518
{
6519
  var->type= SHOW_LONG;
6520 6521 6522 6523 6524 6525
  var->value= buff;
  *((long *)buff)= (!ssl_acceptor_fd ? 0 :
                     SSL_CTX_sess_misses(ssl_acceptor_fd->ssl_context));
  return 0;
}

6526
static int show_ssl_ctx_sess_timeouts(THD *thd, SHOW_VAR *var, char *buff)
6527
{
6528
  var->type= SHOW_LONG;
6529 6530 6531 6532 6533 6534
  var->value= buff;
  *((long *)buff)= (!ssl_acceptor_fd ? 0 :
                     SSL_CTX_sess_timeouts(ssl_acceptor_fd->ssl_context));
  return 0;
}

6535
static int show_ssl_ctx_sess_number(THD *thd, SHOW_VAR *var, char *buff)
6536
{
6537
  var->type= SHOW_LONG;
6538 6539 6540 6541 6542 6543
  var->value= buff;
  *((long *)buff)= (!ssl_acceptor_fd ? 0 :
                     SSL_CTX_sess_number(ssl_acceptor_fd->ssl_context));
  return 0;
}

6544
static int show_ssl_ctx_sess_connect(THD *thd, SHOW_VAR *var, char *buff)
6545
{
6546
  var->type= SHOW_LONG;
6547 6548 6549 6550 6551 6552
  var->value= buff;
  *((long *)buff)= (!ssl_acceptor_fd ? 0 :
                     SSL_CTX_sess_connect(ssl_acceptor_fd->ssl_context));
  return 0;
}

6553
static int show_ssl_ctx_sess_get_cache_size(THD *thd, SHOW_VAR *var, char *buff)
6554
{
6555
  var->type= SHOW_LONG;
6556 6557 6558 6559 6560 6561
  var->value= buff;
  *((long *)buff)= (!ssl_acceptor_fd ? 0 :
                     SSL_CTX_sess_get_cache_size(ssl_acceptor_fd->ssl_context));
  return 0;
}

6562
static int show_ssl_ctx_get_verify_mode(THD *thd, SHOW_VAR *var, char *buff)
6563
{
6564
  var->type= SHOW_LONG;
6565 6566 6567 6568 6569 6570
  var->value= buff;
  *((long *)buff)= (!ssl_acceptor_fd ? 0 :
                     SSL_CTX_get_verify_mode(ssl_acceptor_fd->ssl_context));
  return 0;
}

6571
static int show_ssl_ctx_get_verify_depth(THD *thd, SHOW_VAR *var, char *buff)
6572
{
6573
  var->type= SHOW_LONG;
6574 6575 6576 6577 6578 6579
  var->value= buff;
  *((long *)buff)= (!ssl_acceptor_fd ? 0 :
                     SSL_CTX_get_verify_depth(ssl_acceptor_fd->ssl_context));
  return 0;
}

6580
static int show_ssl_ctx_get_session_cache_mode(THD *thd, SHOW_VAR *var, char *buff)
6581
{
6582
  var->type= SHOW_CHAR;
6583
  if (!ssl_acceptor_fd)
unknown's avatar
unknown committed
6584
    var->value= const_cast<char*>("NONE");
6585 6586 6587 6588
  else
    switch (SSL_CTX_get_session_cache_mode(ssl_acceptor_fd->ssl_context))
    {
    case SSL_SESS_CACHE_OFF:
unknown's avatar
unknown committed
6589
      var->value= const_cast<char*>("OFF"); break;
6590
    case SSL_SESS_CACHE_CLIENT:
unknown's avatar
unknown committed
6591
      var->value= const_cast<char*>("CLIENT"); break;
6592
    case SSL_SESS_CACHE_SERVER:
unknown's avatar
unknown committed
6593
      var->value= const_cast<char*>("SERVER"); break;
6594
    case SSL_SESS_CACHE_BOTH:
unknown's avatar
unknown committed
6595
      var->value= const_cast<char*>("BOTH"); break;
6596
    case SSL_SESS_CACHE_NO_AUTO_CLEAR:
unknown's avatar
unknown committed
6597
      var->value= const_cast<char*>("NO_AUTO_CLEAR"); break;
6598
    case SSL_SESS_CACHE_NO_INTERNAL_LOOKUP:
unknown's avatar
unknown committed
6599
      var->value= const_cast<char*>("NO_INTERNAL_LOOKUP"); break;
6600
    default:
unknown's avatar
unknown committed
6601
      var->value= const_cast<char*>("Unknown"); break;
6602 6603 6604 6605
    }
  return 0;
}

6606 6607 6608 6609 6610 6611 6612
/*
   Functions relying on SSL 
   Note: In the show_ssl_* functions, we need to check if we have a
         valid vio-object since this isn't always true, specifically
         when session_status or global_status is requested from
         inside an Event.
 */
6613
static int show_ssl_get_version(THD *thd, SHOW_VAR *var, char *buff)
6614
{
6615
  var->type= SHOW_CHAR;
6616 6617 6618
  if( thd->vio_ok() && thd->net.vio->ssl_arg )
    var->value= const_cast<char*>(SSL_get_version((SSL*) thd->net.vio->ssl_arg));
  else
6619
    var->value= (char *)"";
6620 6621 6622
  return 0;
}

6623
static int show_ssl_session_reused(THD *thd, SHOW_VAR *var, char *buff)
6624
{
6625
  var->type= SHOW_LONG;
6626
  var->value= buff;
6627 6628 6629 6630
  if( thd->vio_ok() && thd->net.vio->ssl_arg )
    *((long *)buff)= (long)SSL_session_reused((SSL*) thd->net.vio->ssl_arg);
  else
    *((long *)buff)= 0;
unknown's avatar
unknown committed
6631
  return 0;
6632 6633
}

6634
static int show_ssl_get_default_timeout(THD *thd, SHOW_VAR *var, char *buff)
6635
{
6636
  var->type= SHOW_LONG;
6637
  var->value= buff;
6638 6639 6640 6641
  if( thd->vio_ok() && thd->net.vio->ssl_arg )
    *((long *)buff)= (long)SSL_get_default_timeout((SSL*)thd->net.vio->ssl_arg);
  else
    *((long *)buff)= 0;
6642 6643 6644
  return 0;
}

6645
static int show_ssl_get_verify_mode(THD *thd, SHOW_VAR *var, char *buff)
6646
{
6647
  var->type= SHOW_LONG;
6648
  var->value= buff;
6649 6650 6651 6652
  if( thd->net.vio && thd->net.vio->ssl_arg )
    *((long *)buff)= (long)SSL_get_verify_mode((SSL*)thd->net.vio->ssl_arg);
  else
    *((long *)buff)= 0;
6653 6654 6655
  return 0;
}

6656
static int show_ssl_get_verify_depth(THD *thd, SHOW_VAR *var, char *buff)
6657
{
6658
  var->type= SHOW_LONG;
6659
  var->value= buff;
6660 6661 6662 6663
  if( thd->vio_ok() && thd->net.vio->ssl_arg )
    *((long *)buff)= (long)SSL_get_verify_depth((SSL*)thd->net.vio->ssl_arg);
  else
    *((long *)buff)= 0;
6664 6665 6666
  return 0;
}

6667
static int show_ssl_get_cipher(THD *thd, SHOW_VAR *var, char *buff)
6668
{
6669
  var->type= SHOW_CHAR;
6670 6671 6672
  if( thd->vio_ok() && thd->net.vio->ssl_arg )
    var->value= const_cast<char*>(SSL_get_cipher((SSL*) thd->net.vio->ssl_arg));
  else
6673
    var->value= (char *)"";
6674 6675 6676
  return 0;
}

6677
static int show_ssl_get_cipher_list(THD *thd, SHOW_VAR *var, char *buff)
6678
{
6679
  var->type= SHOW_CHAR;
6680
  var->value= buff;
6681
  if (thd->vio_ok() && thd->net.vio->ssl_arg)
6682 6683 6684
  {
    int i;
    const char *p;
6685 6686 6687
    char *end= buff + SHOW_VAR_FUNC_BUFF_SIZE;
    for (i=0; (p= SSL_get_cipher_list((SSL*) thd->net.vio->ssl_arg,i)) &&
               buff < end; i++)
6688
    {
6689
      buff= strnmov(buff, p, end-buff-1);
6690 6691 6692 6693 6694 6695 6696 6697 6698 6699 6700
      *buff++= ':';
    }
    if (i)
      buff--;
  }
  *buff=0;
  return 0;
}

#endif /* HAVE_OPENSSL */

6701

6702 6703 6704 6705
/*
  Variables shown by SHOW STATUS in alphabetical order
*/

6706
SHOW_VAR status_vars[]= {
6707 6708
  {"Aborted_clients",          (char*) &aborted_threads,        SHOW_LONG},
  {"Aborted_connects",         (char*) &aborted_connects,       SHOW_LONG},
6709 6710
  {"Binlog_cache_disk_use",    (char*) &binlog_cache_disk_use,  SHOW_LONG},
  {"Binlog_cache_use",         (char*) &binlog_cache_use,       SHOW_LONG},
6711 6712
  {"Bytes_received",           (char*) offsetof(STATUS_VAR, bytes_received), SHOW_LONGLONG_STATUS},
  {"Bytes_sent",               (char*) offsetof(STATUS_VAR, bytes_sent), SHOW_LONGLONG_STATUS},
unknown's avatar
Merge  
unknown committed
6713 6714
  {"Com_admin_commands",       (char*) offsetof(STATUS_VAR, com_other), SHOW_LONG_STATUS},
  {"Com_alter_db",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_ALTER_DB]), SHOW_LONG_STATUS},
6715
  {"Com_alter_event",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_ALTER_EVENT]), SHOW_LONG_STATUS},
unknown's avatar
Merge  
unknown committed
6716 6717 6718 6719
  {"Com_alter_table",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_ALTER_TABLE]), SHOW_LONG_STATUS},
  {"Com_analyze",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_ANALYZE]), SHOW_LONG_STATUS},
  {"Com_backup_table",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_BACKUP_TABLE]), SHOW_LONG_STATUS},
  {"Com_begin",		       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_BEGIN]), SHOW_LONG_STATUS},
6720
  {"Com_call_procedure",       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_CALL]), SHOW_LONG_STATUS},
unknown's avatar
Merge  
unknown committed
6721 6722 6723 6724 6725 6726
  {"Com_change_db",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_CHANGE_DB]), SHOW_LONG_STATUS},
  {"Com_change_master",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_CHANGE_MASTER]), SHOW_LONG_STATUS},
  {"Com_check",		       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_CHECK]), SHOW_LONG_STATUS},
  {"Com_checksum",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_CHECKSUM]), SHOW_LONG_STATUS},
  {"Com_commit",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_COMMIT]), SHOW_LONG_STATUS},
  {"Com_create_db",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_CREATE_DB]), SHOW_LONG_STATUS},
6727
  {"Com_create_event",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_CREATE_EVENT]), SHOW_LONG_STATUS},
unknown's avatar
Merge  
unknown committed
6728 6729 6730
  {"Com_create_function",      (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_CREATE_FUNCTION]), SHOW_LONG_STATUS},
  {"Com_create_index",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_CREATE_INDEX]), SHOW_LONG_STATUS},
  {"Com_create_table",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_CREATE_TABLE]), SHOW_LONG_STATUS},
6731
  {"Com_create_user",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_CREATE_USER]), SHOW_LONG_STATUS},
unknown's avatar
Merge  
unknown committed
6732 6733 6734 6735 6736
  {"Com_dealloc_sql",          (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_DEALLOCATE_PREPARE]), SHOW_LONG_STATUS},
  {"Com_delete",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_DELETE]), SHOW_LONG_STATUS},
  {"Com_delete_multi",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_DELETE_MULTI]), SHOW_LONG_STATUS},
  {"Com_do",                   (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_DO]), SHOW_LONG_STATUS},
  {"Com_drop_db",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_DROP_DB]), SHOW_LONG_STATUS},
6737
  {"Com_drop_event",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_DROP_EVENT]), SHOW_LONG_STATUS},
unknown's avatar
Merge  
unknown committed
6738 6739 6740 6741
  {"Com_drop_function",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_DROP_FUNCTION]), SHOW_LONG_STATUS},
  {"Com_drop_index",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_DROP_INDEX]), SHOW_LONG_STATUS},
  {"Com_drop_table",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_DROP_TABLE]), SHOW_LONG_STATUS},
  {"Com_drop_user",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_DROP_USER]), SHOW_LONG_STATUS},
6742
  {"Com_execute_sql",          (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_EXECUTE]), SHOW_LONG_STATUS},
unknown's avatar
Merge  
unknown committed
6743 6744 6745 6746 6747 6748 6749 6750 6751 6752 6753 6754 6755 6756 6757 6758 6759 6760 6761 6762 6763 6764 6765 6766 6767 6768 6769 6770 6771 6772 6773
  {"Com_flush",		       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_FLUSH]), SHOW_LONG_STATUS},
  {"Com_grant",		       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_GRANT]), SHOW_LONG_STATUS},
  {"Com_ha_close",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_HA_CLOSE]), SHOW_LONG_STATUS},
  {"Com_ha_open",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_HA_OPEN]), SHOW_LONG_STATUS},
  {"Com_ha_read",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_HA_READ]), SHOW_LONG_STATUS},
  {"Com_help",                 (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_HELP]), SHOW_LONG_STATUS},
  {"Com_insert",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_INSERT]), SHOW_LONG_STATUS},
  {"Com_insert_select",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_INSERT_SELECT]), SHOW_LONG_STATUS},
  {"Com_kill",		       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_KILL]), SHOW_LONG_STATUS},
  {"Com_load",		       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_LOAD]), SHOW_LONG_STATUS},
  {"Com_load_master_data",     (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_LOAD_MASTER_DATA]), SHOW_LONG_STATUS},
  {"Com_load_master_table",    (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_LOAD_MASTER_TABLE]), SHOW_LONG_STATUS},
  {"Com_lock_tables",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_LOCK_TABLES]), SHOW_LONG_STATUS},
  {"Com_optimize",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_OPTIMIZE]), SHOW_LONG_STATUS},
  {"Com_preload_keys",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_PRELOAD_KEYS]), SHOW_LONG_STATUS},
  {"Com_prepare_sql",          (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_PREPARE]), SHOW_LONG_STATUS},
  {"Com_purge",		       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_PURGE]), SHOW_LONG_STATUS},
  {"Com_purge_before_date",    (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_PURGE_BEFORE]), SHOW_LONG_STATUS},
  {"Com_rename_table",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_RENAME_TABLE]), SHOW_LONG_STATUS},
  {"Com_repair",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_REPAIR]), SHOW_LONG_STATUS},
  {"Com_replace",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_REPLACE]), SHOW_LONG_STATUS},
  {"Com_replace_select",       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_REPLACE_SELECT]), SHOW_LONG_STATUS},
  {"Com_reset",		       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_RESET]), SHOW_LONG_STATUS},
  {"Com_restore_table",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_RESTORE_TABLE]), SHOW_LONG_STATUS},
  {"Com_revoke",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_REVOKE]), SHOW_LONG_STATUS},
  {"Com_revoke_all",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_REVOKE_ALL]), SHOW_LONG_STATUS},
  {"Com_rollback",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_ROLLBACK]), SHOW_LONG_STATUS},
  {"Com_savepoint",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SAVEPOINT]), SHOW_LONG_STATUS},
  {"Com_select",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SELECT]), SHOW_LONG_STATUS},
  {"Com_set_option",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SET_OPTION]), SHOW_LONG_STATUS},
  {"Com_show_binlog_events",   (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_BINLOG_EVENTS]), SHOW_LONG_STATUS},
unknown's avatar
unknown committed
6774
  {"Com_show_binlogs",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_BINLOGS]), SHOW_LONG_STATUS},
unknown's avatar
Merge  
unknown committed
6775 6776 6777 6778
  {"Com_show_charsets",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_CHARSETS]), SHOW_LONG_STATUS},
  {"Com_show_collations",      (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_COLLATIONS]), SHOW_LONG_STATUS},
  {"Com_show_column_types",    (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_COLUMN_TYPES]), SHOW_LONG_STATUS},
  {"Com_show_create_db",       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_CREATE_DB]), SHOW_LONG_STATUS},
6779
  {"Com_show_create_event",    (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_CREATE_EVENT]), SHOW_LONG_STATUS},
unknown's avatar
unknown committed
6780
  {"Com_show_create_table",    (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_CREATE]), SHOW_LONG_STATUS},
unknown's avatar
Merge  
unknown committed
6781
  {"Com_show_databases",       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_DATABASES]), SHOW_LONG_STATUS},
6782 6783 6784
  {"Com_show_engine_logs",     (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_ENGINE_LOGS]), SHOW_LONG_STATUS},
  {"Com_show_engine_mutex",    (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_ENGINE_MUTEX]), SHOW_LONG_STATUS},
  {"Com_show_engine_status",   (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_ENGINE_STATUS]), SHOW_LONG_STATUS},
6785
  {"Com_show_events",          (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_EVENTS]), SHOW_LONG_STATUS},
unknown's avatar
Merge  
unknown committed
6786 6787 6788 6789 6790 6791 6792
  {"Com_show_errors",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_ERRORS]), SHOW_LONG_STATUS},
  {"Com_show_fields",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_FIELDS]), SHOW_LONG_STATUS},
  {"Com_show_grants",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_GRANTS]), SHOW_LONG_STATUS},
  {"Com_show_keys",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_KEYS]), SHOW_LONG_STATUS},
  {"Com_show_master_status",   (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_MASTER_STAT]), SHOW_LONG_STATUS},
  {"Com_show_new_master",      (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_NEW_MASTER]), SHOW_LONG_STATUS},
  {"Com_show_open_tables",     (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_OPEN_TABLES]), SHOW_LONG_STATUS},
unknown's avatar
unknown committed
6793
  {"Com_show_plugins",         (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_PLUGINS]), SHOW_LONG_STATUS},
unknown's avatar
Merge  
unknown committed
6794 6795 6796 6797 6798 6799 6800
  {"Com_show_privileges",      (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_PRIVILEGES]), SHOW_LONG_STATUS},
  {"Com_show_processlist",     (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_PROCESSLIST]), SHOW_LONG_STATUS},
  {"Com_show_slave_hosts",     (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_SLAVE_HOSTS]), SHOW_LONG_STATUS},
  {"Com_show_slave_status",    (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_SLAVE_STAT]), SHOW_LONG_STATUS},
  {"Com_show_status",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_STATUS]), SHOW_LONG_STATUS},
  {"Com_show_storage_engines", (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_STORAGE_ENGINES]), SHOW_LONG_STATUS},
  {"Com_show_tables",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_TABLES]), SHOW_LONG_STATUS},
6801
  {"Com_show_triggers",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_TRIGGERS]), SHOW_LONG_STATUS},
unknown's avatar
Merge  
unknown committed
6802 6803 6804 6805
  {"Com_show_variables",       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_VARIABLES]), SHOW_LONG_STATUS},
  {"Com_show_warnings",        (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_WARNS]), SHOW_LONG_STATUS},
  {"Com_slave_start",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SLAVE_START]), SHOW_LONG_STATUS},
  {"Com_slave_stop",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SLAVE_STOP]), SHOW_LONG_STATUS},
unknown's avatar
unknown committed
6806
  {"Com_stmt_close",           (char*) offsetof(STATUS_VAR, com_stmt_close), SHOW_LONG_STATUS},
unknown's avatar
unknown committed
6807 6808
  {"Com_stmt_execute",         (char*) offsetof(STATUS_VAR, com_stmt_execute), SHOW_LONG_STATUS},
  {"Com_stmt_fetch",           (char*) offsetof(STATUS_VAR, com_stmt_fetch), SHOW_LONG_STATUS},
unknown's avatar
unknown committed
6809
  {"Com_stmt_prepare",         (char*) offsetof(STATUS_VAR, com_stmt_prepare), SHOW_LONG_STATUS},
unknown's avatar
unknown committed
6810
  {"Com_stmt_reset",           (char*) offsetof(STATUS_VAR, com_stmt_reset), SHOW_LONG_STATUS},
unknown's avatar
unknown committed
6811
  {"Com_stmt_send_long_data",  (char*) offsetof(STATUS_VAR, com_stmt_send_long_data), SHOW_LONG_STATUS},
unknown's avatar
Merge  
unknown committed
6812 6813 6814 6815 6816 6817 6818 6819 6820 6821
  {"Com_truncate",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_TRUNCATE]), SHOW_LONG_STATUS},
  {"Com_unlock_tables",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_UNLOCK_TABLES]), SHOW_LONG_STATUS},
  {"Com_update",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_UPDATE]), SHOW_LONG_STATUS},
  {"Com_update_multi",	       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_UPDATE_MULTI]), SHOW_LONG_STATUS},
  {"Com_xa_commit",            (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_XA_COMMIT]),SHOW_LONG_STATUS},
  {"Com_xa_end",               (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_XA_END]),SHOW_LONG_STATUS},
  {"Com_xa_prepare",           (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_XA_PREPARE]),SHOW_LONG_STATUS},
  {"Com_xa_recover",           (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_XA_RECOVER]),SHOW_LONG_STATUS},
  {"Com_xa_rollback",          (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_XA_ROLLBACK]),SHOW_LONG_STATUS},
  {"Com_xa_start",             (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_XA_START]),SHOW_LONG_STATUS},
6822
  {"Compression",              (char*) &show_net_compression, SHOW_FUNC},
6823
  {"Connections",              (char*) &thread_id,              SHOW_LONG_NOFLUSH},
unknown's avatar
Merge  
unknown committed
6824
  {"Created_tmp_disk_tables",  (char*) offsetof(STATUS_VAR, created_tmp_disk_tables), SHOW_LONG_STATUS},
6825
  {"Created_tmp_files",	       (char*) &my_tmp_file_created,	SHOW_LONG},
unknown's avatar
Merge  
unknown committed
6826
  {"Created_tmp_tables",       (char*) offsetof(STATUS_VAR, created_tmp_tables), SHOW_LONG_STATUS},
6827
  {"Delayed_errors",           (char*) &delayed_insert_errors,  SHOW_LONG},
6828
  {"Delayed_insert_threads",   (char*) &delayed_insert_threads, SHOW_LONG_NOFLUSH},
6829
  {"Delayed_writes",           (char*) &delayed_insert_writes,  SHOW_LONG},
6830
  {"Flush_commands",           (char*) &refresh_version,        SHOW_LONG_NOFLUSH},
unknown's avatar
Merge  
unknown committed
6831 6832 6833 6834 6835 6836 6837 6838 6839 6840 6841 6842 6843 6844 6845
  {"Handler_commit",           (char*) offsetof(STATUS_VAR, ha_commit_count), SHOW_LONG_STATUS},
  {"Handler_delete",           (char*) offsetof(STATUS_VAR, ha_delete_count), SHOW_LONG_STATUS},
  {"Handler_discover",         (char*) offsetof(STATUS_VAR, ha_discover_count), SHOW_LONG_STATUS},
  {"Handler_prepare",          (char*) offsetof(STATUS_VAR, ha_prepare_count),  SHOW_LONG_STATUS},
  {"Handler_read_first",       (char*) offsetof(STATUS_VAR, ha_read_first_count), SHOW_LONG_STATUS},
  {"Handler_read_key",         (char*) offsetof(STATUS_VAR, ha_read_key_count), SHOW_LONG_STATUS},
  {"Handler_read_next",        (char*) offsetof(STATUS_VAR, ha_read_next_count), SHOW_LONG_STATUS},
  {"Handler_read_prev",        (char*) offsetof(STATUS_VAR, ha_read_prev_count), SHOW_LONG_STATUS},
  {"Handler_read_rnd",         (char*) offsetof(STATUS_VAR, ha_read_rnd_count), SHOW_LONG_STATUS},
  {"Handler_read_rnd_next",    (char*) offsetof(STATUS_VAR, ha_read_rnd_next_count), SHOW_LONG_STATUS},
  {"Handler_rollback",         (char*) offsetof(STATUS_VAR, ha_rollback_count), SHOW_LONG_STATUS},
  {"Handler_savepoint",        (char*) offsetof(STATUS_VAR, ha_savepoint_count), SHOW_LONG_STATUS},
  {"Handler_savepoint_rollback",(char*) offsetof(STATUS_VAR, ha_savepoint_rollback_count), SHOW_LONG_STATUS},
  {"Handler_update",           (char*) offsetof(STATUS_VAR, ha_update_count), SHOW_LONG_STATUS},
  {"Handler_write",            (char*) offsetof(STATUS_VAR, ha_write_count), SHOW_LONG_STATUS},
6846
  {"Key_blocks_not_flushed",   (char*) offsetof(KEY_CACHE, global_blocks_changed), SHOW_KEY_CACHE_LONG},
6847 6848
  {"Key_blocks_unused",        (char*) offsetof(KEY_CACHE, blocks_unused), SHOW_KEY_CACHE_LONG},
  {"Key_blocks_used",          (char*) offsetof(KEY_CACHE, blocks_used), SHOW_KEY_CACHE_LONG},
6849 6850 6851 6852
  {"Key_read_requests",        (char*) offsetof(KEY_CACHE, global_cache_r_requests), SHOW_KEY_CACHE_LONGLONG},
  {"Key_reads",                (char*) offsetof(KEY_CACHE, global_cache_read), SHOW_KEY_CACHE_LONGLONG},
  {"Key_write_requests",       (char*) offsetof(KEY_CACHE, global_cache_w_requests), SHOW_KEY_CACHE_LONGLONG},
  {"Key_writes",               (char*) offsetof(KEY_CACHE, global_cache_write), SHOW_KEY_CACHE_LONGLONG},
6853
  {"Last_query_cost",          (char*) offsetof(STATUS_VAR, last_query_cost), SHOW_DOUBLE_STATUS},
6854
  {"Max_used_connections",     (char*) &max_used_connections,  SHOW_LONG},
6855 6856 6857
  {"Not_flushed_delayed_rows", (char*) &delayed_rows_in_use,    SHOW_LONG_NOFLUSH},
  {"Open_files",               (char*) &my_file_opened,         SHOW_LONG_NOFLUSH},
  {"Open_streams",             (char*) &my_stream_opened,       SHOW_LONG_NOFLUSH},
6858 6859
  {"Open_table_definitions",   (char*) &show_table_definitions, SHOW_FUNC},
  {"Open_tables",              (char*) &show_open_tables,       SHOW_FUNC},
unknown's avatar
Merge  
unknown committed
6860
  {"Opened_tables",            (char*) offsetof(STATUS_VAR, opened_tables), SHOW_LONG_STATUS},
unknown's avatar
unknown committed
6861
  {"Prepared_stmt_count",      (char*) &show_prepared_stmt_count, SHOW_FUNC},
unknown's avatar
unknown committed
6862
#ifdef HAVE_QUERY_CACHE
6863 6864
  {"Qcache_free_blocks",       (char*) &query_cache.free_memory_blocks, SHOW_LONG_NOFLUSH},
  {"Qcache_free_memory",       (char*) &query_cache.free_memory, SHOW_LONG_NOFLUSH},
unknown's avatar
unknown committed
6865
  {"Qcache_hits",              (char*) &query_cache.hits,       SHOW_LONG},
6866
  {"Qcache_inserts",           (char*) &query_cache.inserts,    SHOW_LONG},
6867
  {"Qcache_lowmem_prunes",     (char*) &query_cache.lowmem_prunes, SHOW_LONG},
unknown's avatar
unknown committed
6868
  {"Qcache_not_cached",        (char*) &query_cache.refused,    SHOW_LONG},
6869 6870
  {"Qcache_queries_in_cache",  (char*) &query_cache.queries_in_cache, SHOW_LONG_NOFLUSH},
  {"Qcache_total_blocks",      (char*) &query_cache.total_blocks, SHOW_LONG_NOFLUSH},
unknown's avatar
unknown committed
6871
#endif /*HAVE_QUERY_CACHE*/
6872 6873 6874 6875
  {"Questions",                (char*) &show_question,            SHOW_FUNC},
#ifdef HAVE_REPLICATION
  {"Rpl_status",               (char*) &show_rpl_status,          SHOW_FUNC},
#endif
unknown's avatar
Merge  
unknown committed
6876 6877 6878 6879 6880
  {"Select_full_join",         (char*) offsetof(STATUS_VAR, select_full_join_count), SHOW_LONG_STATUS},
  {"Select_full_range_join",   (char*) offsetof(STATUS_VAR, select_full_range_join_count), SHOW_LONG_STATUS},
  {"Select_range",             (char*) offsetof(STATUS_VAR, select_range_count), SHOW_LONG_STATUS},
  {"Select_range_check",       (char*) offsetof(STATUS_VAR, select_range_check_count), SHOW_LONG_STATUS},
  {"Select_scan",	       (char*) offsetof(STATUS_VAR, select_scan_count), SHOW_LONG_STATUS},
6881
  {"Slave_open_temp_tables",   (char*) &slave_open_temp_tables, SHOW_LONG},
6882 6883 6884 6885
#ifdef HAVE_REPLICATION
  {"Slave_retried_transactions",(char*) &show_slave_retried_trans, SHOW_FUNC},
  {"Slave_running",            (char*) &show_slave_running,     SHOW_FUNC},
#endif
6886
  {"Slow_launch_threads",      (char*) &slow_launch_threads,    SHOW_LONG},
unknown's avatar
Merge  
unknown committed
6887 6888 6889 6890 6891
  {"Slow_queries",             (char*) offsetof(STATUS_VAR, long_query_count), SHOW_LONG_STATUS},
  {"Sort_merge_passes",	       (char*) offsetof(STATUS_VAR, filesort_merge_passes), SHOW_LONG_STATUS},
  {"Sort_range",	       (char*) offsetof(STATUS_VAR, filesort_range_count), SHOW_LONG_STATUS},
  {"Sort_rows",		       (char*) offsetof(STATUS_VAR, filesort_rows), SHOW_LONG_STATUS},
  {"Sort_scan",		       (char*) offsetof(STATUS_VAR, filesort_scan_count), SHOW_LONG_STATUS},
unknown's avatar
unknown committed
6892
#ifdef HAVE_OPENSSL
6893 6894 6895 6896 6897 6898 6899 6900 6901 6902 6903 6904 6905 6906 6907 6908 6909 6910 6911 6912 6913 6914 6915
  {"Ssl_accept_renegotiates",  (char*) &show_ssl_ctx_sess_accept_renegotiate, SHOW_FUNC},
  {"Ssl_accepts",              (char*) &show_ssl_ctx_sess_accept, SHOW_FUNC},
  {"Ssl_callback_cache_hits",  (char*) &show_ssl_ctx_sess_cb_hits, SHOW_FUNC},
  {"Ssl_cipher",               (char*) &show_ssl_get_cipher, SHOW_FUNC},
  {"Ssl_cipher_list",          (char*) &show_ssl_get_cipher_list, SHOW_FUNC},
  {"Ssl_client_connects",      (char*) &show_ssl_ctx_sess_connect, SHOW_FUNC},
  {"Ssl_connect_renegotiates", (char*) &show_ssl_ctx_sess_connect_renegotiate, SHOW_FUNC},
  {"Ssl_ctx_verify_depth",     (char*) &show_ssl_ctx_get_verify_depth, SHOW_FUNC},
  {"Ssl_ctx_verify_mode",      (char*) &show_ssl_ctx_get_verify_mode, SHOW_FUNC},
  {"Ssl_default_timeout",      (char*) &show_ssl_get_default_timeout, SHOW_FUNC},
  {"Ssl_finished_accepts",     (char*) &show_ssl_ctx_sess_accept_good, SHOW_FUNC},
  {"Ssl_finished_connects",    (char*) &show_ssl_ctx_sess_connect_good, SHOW_FUNC},
  {"Ssl_session_cache_hits",   (char*) &show_ssl_ctx_sess_hits, SHOW_FUNC},
  {"Ssl_session_cache_misses", (char*) &show_ssl_ctx_sess_misses, SHOW_FUNC},
  {"Ssl_session_cache_mode",   (char*) &show_ssl_ctx_get_session_cache_mode, SHOW_FUNC},
  {"Ssl_session_cache_overflows", (char*) &show_ssl_ctx_sess_cache_full, SHOW_FUNC},
  {"Ssl_session_cache_size",   (char*) &show_ssl_ctx_sess_get_cache_size, SHOW_FUNC},
  {"Ssl_session_cache_timeouts", (char*) &show_ssl_ctx_sess_timeouts, SHOW_FUNC},
  {"Ssl_sessions_reused",      (char*) &show_ssl_session_reused, SHOW_FUNC},
  {"Ssl_used_session_cache_entries",(char*) &show_ssl_ctx_sess_number, SHOW_FUNC},
  {"Ssl_verify_depth",         (char*) &show_ssl_get_verify_depth, SHOW_FUNC},
  {"Ssl_verify_mode",          (char*) &show_ssl_get_verify_mode, SHOW_FUNC},
  {"Ssl_version",              (char*) &show_ssl_get_version, SHOW_FUNC},
unknown's avatar
unknown committed
6916
#endif /* HAVE_OPENSSL */
unknown's avatar
unknown committed
6917 6918
  {"Table_locks_immediate",    (char*) &locks_immediate,        SHOW_LONG},
  {"Table_locks_waited",       (char*) &locks_waited,           SHOW_LONG},
6919
#ifdef HAVE_MMAP
unknown's avatar
Merge  
unknown committed
6920 6921 6922
  {"Tc_log_max_pages_used",    (char*) &tc_log_max_pages_used,  SHOW_LONG},
  {"Tc_log_page_size",         (char*) &tc_log_page_size,       SHOW_LONG},
  {"Tc_log_page_waits",        (char*) &tc_log_page_waits,      SHOW_LONG},
6923
#endif
6924 6925 6926 6927
  {"Threads_cached",           (char*) &cached_thread_count,    SHOW_LONG_NOFLUSH},
  {"Threads_connected",        (char*) &thread_count,           SHOW_INT},
  {"Threads_created",	       (char*) &thread_created,		SHOW_LONG_NOFLUSH},
  {"Threads_running",          (char*) &thread_running,         SHOW_INT},
6928
  {"Uptime",                   (char*) &show_starttime,         SHOW_FUNC},
6929
  {NullS, NullS, SHOW_LONG}
unknown's avatar
unknown committed
6930 6931 6932 6933
};

static void print_version(void)
{
6934
  set_server_version();
6935 6936 6937 6938
  /*
    Note: the instance manager keys off the string 'Ver' so it can find the
    version from the output of 'mysqld --version', so don't change it!
  */
6939 6940
  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
6941 6942
}

6943
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
6944 6945
static void usage(void)
{
6946
  if (!(default_charset_info= get_charset_by_csname(default_character_set_name,
unknown's avatar
unknown committed
6947 6948 6949 6950 6951
					           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
6952
  print_version();
unknown's avatar
unknown committed
6953 6954 6955
  puts("\
Copyright (C) 2000 MySQL AB, by Monty and others\n\
This software comes with ABSOLUTELY NO WARRANTY. This is free software,\n\
6956 6957
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
6958 6959

  printf("Usage: %s [OPTIONS]\n", my_progname);
6960 6961 6962 6963
  if (!opt_verbose)
    puts("\nFor more help options (several pages), use mysqld --verbose --help\n");
  else
  {
unknown's avatar
unknown committed
6964 6965
#ifdef __WIN__
  puts("NT and Win32 specific options:\n\
6966 6967
  --install                     Install the default service (NT)\n\
  --install-manual              Install the default service started manually (NT)\n\
unknown's avatar
unknown committed
6968 6969
  --install service_name        Install an optional service (NT)\n\
  --install-manual service_name Install an optional service started manually (NT)\n\
6970
  --remove                      Remove the default service from the service list (NT)\n\
unknown's avatar
unknown committed
6971 6972 6973
  --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
6974
");
6975
  puts("");
unknown's avatar
unknown committed
6976
#endif
6977
  print_defaults(MYSQL_CONFIG_NAME,load_default_groups);
unknown's avatar
unknown committed
6978 6979
  puts("");
  set_ports();
6980

unknown's avatar
unknown committed
6981 6982
  /* Print out all the options including plugin supplied options */
  my_print_help_inc_plugins(my_long_options, sizeof(my_long_options)/sizeof(my_option));
6983

unknown's avatar
unknown committed
6984
  puts("\n\
unknown's avatar
unknown committed
6985
To see what values a running MySQL server is using, type\n\
6986 6987
'mysqladmin variables' instead of 'mysqld --verbose --help'.\n");
  }
unknown's avatar
unknown committed
6988
}
6989
#endif /*!EMBEDDED_LIBRARY*/
unknown's avatar
unknown committed
6990 6991


unknown's avatar
unknown committed
6992 6993 6994 6995 6996 6997 6998 6999 7000 7001 7002
/*
  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
7003

unknown's avatar
unknown committed
7004 7005 7006
    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
7007

unknown's avatar
unknown committed
7008 7009 7010 7011 7012
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;
unknown's avatar
unknown committed
7013 7014
  opt_log= opt_slow_log= 0;
  opt_update_log= 0;
7015
  log_output_options= find_bit_type(log_output_str, &log_output_typelib);
7016
  opt_bin_log= 0;
unknown's avatar
unknown committed
7017
  opt_disable_networking= opt_skip_show_db=0;
unknown's avatar
Merge  
unknown committed
7018 7019
  opt_logname= opt_update_logname= opt_binlog_index_name= opt_slow_logname= 0;
  opt_tc_log_file= (char *)"tc.log";      // no hostname in tc_log file name !
7020
  opt_secure_auth= 0;
7021
  opt_secure_file_priv= 0;
7022
  opt_bootstrap= opt_myisam_log= 0;
unknown's avatar
unknown committed
7023 7024 7025
  mqh_used= 0;
  segfaulted= kill_in_progress= 0;
  cleanup_done= 0;
unknown's avatar
unknown committed
7026
  defaults_argc= 0;
unknown's avatar
unknown committed
7027 7028 7029 7030 7031 7032 7033 7034 7035 7036
  defaults_argv= 0;
  server_id_supplied= 0;
  test_flags= select_errors= dropping_tables= ha_open_options=0;
  thread_count= thread_running= kill_cached_threads= wake_thread=0;
  slave_open_temp_tables= 0;
  cached_thread_count= 0;
  opt_endinfo= using_udf_functions= 0;
  opt_using_transactions= using_update_log= 0;
  abort_loop= select_thread_in_use= signal_thread_in_use= 0;
  ready_to_exit= shutdown_in_progress= grant_option= 0;
unknown's avatar
Merge  
unknown committed
7037
  aborted_threads= aborted_connects= 0;
unknown's avatar
unknown committed
7038 7039
  delayed_insert_threads= delayed_insert_writes= delayed_rows_in_use= 0;
  delayed_insert_errors= thread_created= 0;
unknown's avatar
Merge  
unknown committed
7040
  specialflag= 0;
7041
  binlog_cache_use=  binlog_cache_disk_use= 0;
unknown's avatar
unknown committed
7042 7043
  max_used_connections= slow_launch_threads = 0;
  mysqld_user= mysqld_chroot= opt_init_file= opt_bin_logname = 0;
7044
  prepared_stmt_count= 0;
unknown's avatar
unknown committed
7045
  errmesg= 0;
7046
  mysqld_unix_port= opt_mysql_tmpdir= my_bind_addr_str= NullS;
7047
  bzero((uchar*) &mysql_tmpdir_list, sizeof(mysql_tmpdir_list));
unknown's avatar
Merge  
unknown committed
7048 7049
  bzero((char *) &global_status_var, sizeof(global_status_var));
  opt_large_pages= 0;
7050
  key_map_full.set_all();
unknown's avatar
unknown committed
7051

7052 7053 7054 7055 7056
  /* Character sets */
  system_charset_info= &my_charset_utf8_general_ci;
  files_charset_info= &my_charset_utf8_general_ci;
  national_charset_info= &my_charset_utf8_general_ci;
  table_alias_charset= &my_charset_bin;
unknown's avatar
unknown committed
7057
  character_set_filesystem= &my_charset_bin;
7058

7059 7060
  opt_date_time_formats[0]= opt_date_time_formats[1]= opt_date_time_formats[2]= 0;

unknown's avatar
unknown committed
7061 7062 7063 7064 7065 7066 7067 7068 7069
  /* 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;
7070 7071
  thd_startup_options= (OPTION_AUTO_IS_NULL | OPTION_BIN_LOG |
                        OPTION_QUOTE_SHOW_CREATE | OPTION_SQL_NOTES);
unknown's avatar
unknown committed
7072 7073
  protocol_version= PROTOCOL_VERSION;
  what_to_log= ~ (1L << (uint) COM_TIME);
7074
  refresh_version= 1L;	/* Increments on each reload */
7075
  global_query_id= thread_id= 1L;
unknown's avatar
unknown committed
7076 7077
  strmov(server_version, MYSQL_SERVER_VERSION);
  myisam_recover_options_str= sql_mode_str= "OFF";
7078
  myisam_stats_method_str= "nulls_unequal";
unknown's avatar
unknown committed
7079 7080 7081
  my_bind_addr = htonl(INADDR_ANY);
  threads.empty();
  thread_cache.empty();
7082
  key_caches.empty();
unknown's avatar
unknown committed
7083
  if (!(dflt_key_cache= get_or_create_key_cache(default_key_cache_base.str,
7084
					       default_key_cache_base.length)))
7085
    exit(1);
unknown's avatar
unknown committed
7086
  multi_keycache_init(); /* set key_cache_hash.default_value = dflt_key_cache */
unknown's avatar
unknown committed
7087 7088 7089 7090 7091 7092 7093

  /* 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;
7094
  mysql_data_home_len= 2;
unknown's avatar
unknown committed
7095 7096 7097 7098 7099

  /* Replication parameters */
  master_user= (char*) "test";
  master_password= master_host= 0;
  master_info_file= (char*) "master.info",
unknown's avatar
unknown committed
7100 7101 7102
    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
7103 7104 7105 7106 7107
  report_user= report_password = report_host= 0;	/* TO BE DELETED */
  opt_relay_logname= opt_relaylog_index_name= 0;

  /* Variables in libraries */
  charsets_dir= 0;
7108
  default_character_set_name= (char*) MYSQL_DEFAULT_CHARSET_NAME;
7109
  default_collation_name= compiled_default_collation_name;
7110
  sys_charset_system.value= (char*) system_charset_info->csname;
unknown's avatar
unknown committed
7111
  character_set_filesystem_name= (char*) "binary";
7112
  lc_time_names_name= (char*) "en_US";
unknown's avatar
unknown committed
7113
  /* Set default values for some option variables */
unknown's avatar
unknown committed
7114
  default_storage_engine_str= (char*) "MyISAM";
unknown's avatar
unknown committed
7115
  global_system_variables.table_plugin= NULL;
unknown's avatar
unknown committed
7116
  global_system_variables.tx_isolation= ISO_REPEATABLE_READ;
7117
  global_system_variables.select_limit= (ulonglong) HA_POS_ERROR;
unknown's avatar
unknown committed
7118
  max_system_variables.select_limit=    (ulonglong) HA_POS_ERROR;
7119
  global_system_variables.max_join_size= (ulonglong) HA_POS_ERROR;
unknown's avatar
unknown committed
7120
  max_system_variables.max_join_size=   (ulonglong) HA_POS_ERROR;
7121
  global_system_variables.old_passwords= 0;
unknown's avatar
unknown committed
7122
  global_system_variables.old_alter_table= 0;
7123
  global_system_variables.binlog_format= BINLOG_FORMAT_UNSPEC;
7124
  /*
7125
    Default behavior for 4.1 and 5.0 is to treat NULL values as unequal
7126 7127 7128
    when collecting index statistics for MyISAM tables.
  */
  global_system_variables.myisam_stats_method= MI_STATS_METHOD_NULLS_NOT_EQUAL;
unknown's avatar
unknown committed
7129

unknown's avatar
unknown committed
7130 7131 7132 7133 7134 7135
  /* 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);
7136
#ifdef WITH_NDBCLUSTER_STORAGE_ENGINE
7137
  global_system_variables.ndb_index_stat_enable=FALSE;
7138 7139 7140 7141 7142
  max_system_variables.ndb_index_stat_enable=TRUE;
  global_system_variables.ndb_index_stat_cache_entries=32;
  max_system_variables.ndb_index_stat_cache_entries=~0L;
  global_system_variables.ndb_index_stat_update_freq=20;
  max_system_variables.ndb_index_stat_update_freq=~0L;
unknown's avatar
unknown committed
7143
#endif
unknown's avatar
unknown committed
7144
#ifdef HAVE_OPENSSL
7145
  have_ssl=SHOW_OPTION_YES;
unknown's avatar
unknown committed
7146
#else
7147
  have_ssl=SHOW_OPTION_NO;
unknown's avatar
unknown committed
7148
#endif
unknown's avatar
unknown committed
7149
#ifdef HAVE_BROKEN_REALPATH
unknown's avatar
unknown committed
7150 7151 7152 7153
  have_symlink=SHOW_OPTION_NO;
#else
  have_symlink=SHOW_OPTION_YES;
#endif
7154 7155 7156 7157 7158
#ifdef HAVE_DLOPEN
  have_dlopen=SHOW_OPTION_YES;
#else
  have_dlopen=SHOW_OPTION_NO;
#endif
unknown's avatar
unknown committed
7159 7160 7161 7162 7163
#ifdef HAVE_QUERY_CACHE
  have_query_cache=SHOW_OPTION_YES;
#else
  have_query_cache=SHOW_OPTION_NO;
#endif
7164 7165 7166 7167 7168 7169 7170 7171 7172 7173
#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
7174 7175 7176 7177 7178 7179
#ifdef HAVE_CRYPT
  have_crypt=SHOW_OPTION_YES;
#else
  have_crypt=SHOW_OPTION_NO;
#endif
#ifdef HAVE_COMPRESS
7180
  have_compress= SHOW_OPTION_YES;
unknown's avatar
unknown committed
7181
#else
7182
  have_compress= SHOW_OPTION_NO;
unknown's avatar
unknown committed
7183 7184 7185 7186 7187 7188 7189 7190 7191 7192 7193 7194 7195 7196 7197
#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
7198 7199
#if defined(__WIN__) || defined(__NETWARE__)
  /* Allow Win32 and NetWare users to move MySQL anywhere */
unknown's avatar
unknown committed
7200 7201
  {
    char prg_dev[LIBLEN];
7202 7203 7204 7205 7206 7207 7208 7209 7210 7211 7212 7213
#if defined __WIN__
	char executing_path_name[LIBLEN];
	if (!test_if_hard_path(my_progname))
	{
		// we don't want to use GetModuleFileName inside of my_path since
		// my_path is a generic path dereferencing function and here we care
		// only about the executing binary.
		GetModuleFileName(NULL, executing_path_name, sizeof(executing_path_name));
		my_path(prg_dev, executing_path_name, NULL);
	}
	else
#endif
unknown's avatar
unknown committed
7214 7215 7216 7217 7218 7219
    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
7220
  if (!(tmpenv = getenv("MY_BASEDIR_VERSION")))
unknown's avatar
unknown committed
7221
    tmpenv = DEFAULT_MYSQL_HOME;
unknown's avatar
unknown committed
7222
  (void) strmake(mysql_home, tmpenv, sizeof(mysql_home)-1);
unknown's avatar
unknown committed
7223 7224 7225 7226
#endif
}


unknown's avatar
unknown committed
7227
static my_bool
7228 7229
get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
	       char *argument)
unknown's avatar
unknown committed
7230
{
7231 7232
  switch(optid) {
  case '#':
7233
#ifndef DBUG_OFF
unknown's avatar
unknown committed
7234
    DBUG_SET_INITIAL(argument ? argument : default_dbug_option);
7235 7236 7237 7238
#endif
    opt_endinfo=1;				/* unireg: memory allocation */
    break;
  case 'a':
7239
    global_system_variables.sql_mode= fix_sql_mode(MODE_ANSI);
unknown's avatar
unknown committed
7240
    global_system_variables.tx_isolation= ISO_SERIALIZABLE;
7241 7242 7243 7244
    break;
  case 'b':
    strmake(mysql_home,argument,sizeof(mysql_home)-1);
    break;
7245
  case 'C':
7246 7247
    if (default_collation_name == compiled_default_collation_name)
      default_collation_name= 0;
7248
    break;
7249 7250 7251 7252 7253
  case 'l':
    opt_log=1;
    break;
  case 'h':
    strmake(mysql_real_data_home,argument, sizeof(mysql_real_data_home)-1);
7254 7255
    /* Correct pointer set by my_getopt (for embedded library) */
    mysql_data_home= mysql_real_data_home;
7256
    mysql_data_home_len= strlen(mysql_data_home);
7257
    break;
7258
  case 'u':
7259
    if (!mysqld_user || !strcmp(mysqld_user, argument))
unknown's avatar
unknown committed
7260
      mysqld_user= argument;
7261
    else
7262
      sql_print_warning("Ignoring user change to '%s' because the user was set to '%s' earlier on the command line\n", argument, mysqld_user);
7263
    break;
7264 7265 7266
  case 'L':
    strmake(language, argument, sizeof(language)-1);
    break;
unknown's avatar
SCRUM  
unknown committed
7267
#ifdef HAVE_REPLICATION
7268 7269 7270
  case OPT_SLAVE_SKIP_ERRORS:
    init_slave_skip_errors(argument);
    break;
7271
#endif
7272
  case OPT_SAFEMALLOC_MEM_LIMIT:
7273
#if !defined(DBUG_OFF) && defined(SAFEMALLOC)
7274
    sf_malloc_mem_limit = atoi(argument);
7275
#endif
7276
    break;
7277
#include <sslopt-case.h>
7278 7279 7280
  case 'V':
    print_version();
    exit(0);
7281 7282 7283 7284 7285 7286 7287 7288
  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;
7289 7290 7291 7292 7293 7294 7295 7296 7297 7298 7299 7300 7301 7302
  case 'T':
    test_flags= argument ? (uint) atoi(argument) : 0;
    opt_endinfo=1;
    break;
  case (int) OPT_BIG_TABLES:
    thd_startup_options|=OPTION_BIG_TABLES;
    break;
  case (int) OPT_ISAM_LOG:
    opt_myisam_log=1;
    break;
  case (int) OPT_UPDATE_LOG:
    opt_update_log=1;
    break;
  case (int) OPT_BIN_LOG:
7303
    opt_bin_log= test(argument != disabled_my_option);
7304
    break;
7305 7306 7307
  case (int) OPT_ERROR_LOG_FILE:
    opt_error_log= 1;
    break;
unknown's avatar
SCRUM  
unknown committed
7308
#ifdef HAVE_REPLICATION
7309
  case (int) OPT_INIT_RPL_ROLE:
7310 7311
  {
    int role;
7312
    role= find_type_or_exit(argument, &rpl_role_typelib, opt->name);
7313 7314 7315
    rpl_status = (role == 1) ?  RPL_AUTH_MASTER : RPL_IDLE_SLAVE;
    break;
  }
7316
  case (int)OPT_REPLICATE_IGNORE_DB:
7317
  {
7318
    rpl_filter->add_ignore_db(argument);
7319 7320 7321 7322
    break;
  }
  case (int)OPT_REPLICATE_DO_DB:
  {
7323
    rpl_filter->add_do_db(argument);
7324 7325 7326 7327 7328
    break;
  }
  case (int)OPT_REPLICATE_REWRITE_DB:
  {
    char* key = argument,*p, *val;
7329

7330
    if (!(p= strstr(argument, "->")))
7331
    {
7332 7333 7334
      fprintf(stderr,
	      "Bad syntax in replicate-rewrite-db - missing '->'!\n");
      exit(1);
7335
    }
7336
    val= p--;
unknown's avatar
unknown committed
7337
    while (my_isspace(mysqld_charset, *p) && p > argument)
7338 7339
      *p-- = 0;
    if (p == argument)
7340
    {
7341 7342 7343
      fprintf(stderr,
	      "Bad syntax in replicate-rewrite-db - empty FROM db!\n");
      exit(1);
7344
    }
7345 7346
    *val= 0;
    val+= 2;
unknown's avatar
unknown committed
7347
    while (*val && my_isspace(mysqld_charset, *val))
7348 7349
      *val++;
    if (!*val)
7350
    {
7351 7352 7353
      fprintf(stderr,
	      "Bad syntax in replicate-rewrite-db - empty TO db!\n");
      exit(1);
7354 7355
    }

7356
    rpl_filter->add_db_rewrite(key, val);
7357 7358 7359
    break;
  }

7360
  case (int)OPT_BINLOG_IGNORE_DB:
7361
  {
7362
    binlog_filter->add_ignore_db(argument);
7363 7364
    break;
  }
7365 7366 7367
  case OPT_BINLOG_FORMAT:
  {
    int id;
7368
    id= find_type_or_exit(argument, &binlog_format_typelib, opt->name);
7369
    global_system_variables.binlog_format= opt_binlog_format_id= id - 1;
7370 7371
    break;
  }
7372
  case (int)OPT_BINLOG_DO_DB:
7373
  {
7374
    binlog_filter->add_do_db(argument);
7375 7376
    break;
  }
7377
  case (int)OPT_REPLICATE_DO_TABLE:
7378
  {
7379
    if (rpl_filter->add_do_table(argument))
7380
    {
7381 7382
      fprintf(stderr, "Could not add do table rule '%s'!\n", argument);
      exit(1);
7383
    }
7384 7385
    break;
  }
7386
  case (int)OPT_REPLICATE_WILD_DO_TABLE:
7387
  {
7388
    if (rpl_filter->add_wild_do_table(argument))
7389
    {
7390 7391
      fprintf(stderr, "Could not add do table rule '%s'!\n", argument);
      exit(1);
7392
    }
7393 7394
    break;
  }
7395
  case (int)OPT_REPLICATE_WILD_IGNORE_TABLE:
7396
  {
7397
    if (rpl_filter->add_wild_ignore_table(argument))
7398
    {
7399 7400
      fprintf(stderr, "Could not add ignore table rule '%s'!\n", argument);
      exit(1);
7401
    }
7402 7403
    break;
  }
7404
  case (int)OPT_REPLICATE_IGNORE_TABLE:
7405
  {
7406
    if (rpl_filter->add_ignore_table(argument))
7407
    {
7408 7409
      fprintf(stderr, "Could not add ignore table rule '%s'!\n", argument);
      exit(1);
7410
    }
7411 7412
    break;
  }
unknown's avatar
SCRUM  
unknown committed
7413
#endif /* HAVE_REPLICATION */
7414
  case (int) OPT_SLOW_QUERY_LOG:
7415
    opt_slow_log= 1;
7416
    break;
7417
#ifdef WITH_CSV_STORAGE_ENGINE
7418 7419 7420 7421 7422 7423 7424 7425 7426 7427
  case  OPT_LOG_OUTPUT:
  {
    if (!argument || !argument[0])
    {
      log_output_options= LOG_TABLE;
      log_output_str= log_output_typelib.type_names[1];
    }
    else
    {
      log_output_str= argument;
7428 7429 7430
      log_output_options=
        find_bit_type_or_exit(argument, &log_output_typelib, opt->name);
  }
7431
    break;
7432
  }
7433
#endif
7434
  case OPT_EVENT_SCHEDULER:
7435
    if (Events::set_opt_event_scheduler(argument))
7436
	exit(1);
7437
    break;
7438 7439
  case (int) OPT_SKIP_NEW:
    opt_specialflag|= SPECIAL_NO_NEW_FUNC;
7440
    delay_key_write_options= (uint) DELAY_KEY_WRITE_NONE;
7441 7442
    myisam_concurrent_insert=0;
    myisam_recover_options= HA_RECOVER_NONE;
unknown's avatar
Merge  
unknown committed
7443
    sp_automatic_privileges=0;
7444
    my_use_symdir=0;
7445
    ha_open_options&= ~(HA_OPEN_ABORT_IF_CRASHED | HA_OPEN_DELAY_KEY_WRITE);
unknown's avatar
unknown committed
7446
#ifdef HAVE_QUERY_CACHE
7447 7448 7449 7450 7451
    query_cache_size=0;
#endif
    break;
  case (int) OPT_SAFE:
    opt_specialflag|= SPECIAL_SAFE_MODE;
7452
    delay_key_write_options= (uint) DELAY_KEY_WRITE_NONE;
7453 7454
    myisam_recover_options= HA_RECOVER_DEFAULT;
    ha_open_options&= ~(HA_OPEN_DELAY_KEY_WRITE);
7455 7456 7457 7458 7459
    break;
  case (int) OPT_SKIP_PRIOR:
    opt_specialflag|= SPECIAL_NO_PRIOR;
    break;
  case (int) OPT_SKIP_LOCK:
7460
    opt_external_locking=0;
7461 7462 7463 7464 7465 7466 7467 7468
    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
7469 7470 7471
#if defined(__NETWARE__)
    sql_perror("Can't start server: skip-networking option is currently not supported on NetWare");
    exit(1);
7472
#endif
7473
    opt_disable_networking=1;
7474
    mysqld_port=0;
7475 7476 7477 7478 7479 7480 7481 7482 7483 7484 7485 7486 7487 7488 7489
    break;
  case (int) OPT_SKIP_SHOW_DB:
    opt_skip_show_db=1;
    opt_specialflag|=SPECIAL_SKIP_SHOW_DB;
    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
7490
    if ((my_bind_addr= (ulong) inet_addr(argument)) == INADDR_NONE)
7491 7492
    {
      struct hostent *ent;
unknown's avatar
unknown committed
7493
      if (argument[0])
7494
	ent=gethostbyname(argument);
unknown's avatar
unknown committed
7495 7496
      else
      {
7497 7498
	char myhostname[255];
	if (gethostname(myhostname,sizeof(myhostname)) < 0)
unknown's avatar
unknown committed
7499
	{
7500
	  sql_perror("Can't start server: cannot get my own hostname!");
unknown's avatar
unknown committed
7501 7502
	  exit(1);
	}
7503
	ent=gethostbyname(myhostname);
unknown's avatar
unknown committed
7504
      }
7505 7506 7507 7508 7509 7510 7511 7512 7513 7514 7515
      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
7516
#ifdef __WIN__
7517 7518
  case (int) OPT_STANDALONE:		/* Dummy option for NT */
    break;
unknown's avatar
unknown committed
7519
#endif
7520
  /*
7521 7522 7523 7524 7525 7526 7527 7528 7529 7530 7531 7532 7533 7534 7535 7536 7537 7538
    The following change issues a deprecation warning if the slave
    configuration is specified either in the my.cnf file or on
    the command-line. See BUG#21490.
  */
  case OPT_MASTER_HOST:
  case OPT_MASTER_USER:
  case OPT_MASTER_PASSWORD:
  case OPT_MASTER_PORT:
  case OPT_MASTER_CONNECT_RETRY:
  case OPT_MASTER_SSL:          
  case OPT_MASTER_SSL_KEY:
  case OPT_MASTER_SSL_CERT:       
  case OPT_MASTER_SSL_CAPATH:
  case OPT_MASTER_SSL_CIPHER:
  case OPT_MASTER_SSL_CA:
    if (!slave_warning_issued)                 //only show the warning once
    {
      slave_warning_issued = true;   
7539
      WARN_DEPRECATED(NULL, "5.2", "for replication startup options", 
7540 7541 7542
        "'CHANGE MASTER'");
    }
    break;
7543 7544 7545 7546
  case OPT_CONSOLE:
    if (opt_console)
      opt_error_log= 0;			// Force logs to stdout
    break;
7547 7548 7549 7550 7551 7552
  case (int) OPT_FLUSH:
    myisam_flush=1;
    flush_time=0;			// No auto flush
    break;
  case OPT_LOW_PRIORITY_UPDATES:
    thr_upgraded_concurrent_insert_lock= TL_WRITE_LOW_PRIORITY;
unknown's avatar
unknown committed
7553
    global_system_variables.low_priority_updates=1;
7554 7555 7556 7557 7558 7559 7560
    break;
  case OPT_BOOTSTRAP:
    opt_noacl=opt_bootstrap=1;
    break;
  case OPT_SERVER_ID:
    server_id_supplied = 1;
    break;
7561 7562 7563 7564
  case OPT_DELAY_KEY_WRITE_ALL:
    if (argument != disabled_my_option)
      argument= (char*) "ALL";
    /* Fall through */
7565
  case OPT_DELAY_KEY_WRITE:
7566 7567 7568 7569 7570 7571 7572
    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;
7573
      type= find_type_or_exit(argument, &delay_key_write_typelib, opt->name);
7574 7575
      delay_key_write_options= (uint) type-1;
    }
7576 7577 7578 7579 7580 7581
    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:
7582 7583
  {
    int type;
7584
    type= find_type_or_exit(argument, &tx_isolation_typelib, opt->name);
unknown's avatar
unknown committed
7585
    global_system_variables.tx_isolation= (type-1);
7586 7587
    break;
  }
7588
#ifdef WITH_NDBCLUSTER_STORAGE_ENGINE
unknown's avatar
Merge  
unknown committed
7589 7590 7591 7592 7593 7594 7595 7596 7597 7598 7599 7600 7601 7602 7603 7604 7605 7606 7607 7608 7609 7610 7611
  case OPT_NDB_MGMD:
  case OPT_NDB_NODEID:
  {
    int len= my_snprintf(opt_ndb_constrbuf+opt_ndb_constrbuf_len,
			 sizeof(opt_ndb_constrbuf)-opt_ndb_constrbuf_len,
			 "%s%s%s",opt_ndb_constrbuf_len > 0 ? ",":"",
			 optid == OPT_NDB_NODEID ? "nodeid=" : "",
			 argument);
    opt_ndb_constrbuf_len+= len;
  }
  /* fall through to add the connectstring to the end
   * and set opt_ndbcluster_connectstring
   */
  case OPT_NDB_CONNECTSTRING:
    if (opt_ndb_connectstring && opt_ndb_connectstring[0])
      my_snprintf(opt_ndb_constrbuf+opt_ndb_constrbuf_len,
		  sizeof(opt_ndb_constrbuf)-opt_ndb_constrbuf_len,
		  "%s%s", opt_ndb_constrbuf_len > 0 ? ",":"",
		  opt_ndb_connectstring);
    else
      opt_ndb_constrbuf[opt_ndb_constrbuf_len]= 0;
    opt_ndbcluster_connectstring= opt_ndb_constrbuf;
    break;
7612 7613
  case OPT_NDB_DISTRIBUTION:
    int id;
7614
    id= find_type_or_exit(argument, &ndb_distribution_typelib, opt->name);
7615 7616
    opt_ndb_distribution_id= (enum ndb_distribution)(id-1);
    break;
unknown's avatar
unknown committed
7617 7618 7619 7620 7621 7622 7623 7624
  case OPT_NDB_EXTRA_LOGGING:
    if (!argument)
      ndb_extra_logging++;
    else if (argument == disabled_my_option)
      ndb_extra_logging= 0L;
    else
      ndb_extra_logging= atoi(argument);
    break;
unknown's avatar
Merge  
unknown committed
7625
#endif
7626
  case OPT_MYISAM_RECOVER:
7627 7628
  {
    if (!argument || !argument[0])
7629
    {
7630 7631
      myisam_recover_options=    HA_RECOVER_DEFAULT;
      myisam_recover_options_str= myisam_recover_typelib.type_names[0];
7632
    }
7633
    else
7634
    {
7635
      myisam_recover_options_str=argument;
7636 7637
      myisam_recover_options=
        find_bit_type_or_exit(argument, &myisam_recover_typelib, opt->name);
7638
    }
7639 7640 7641
    ha_open_options|=HA_OPEN_ABORT_IF_CRASHED;
    break;
  }
7642 7643 7644 7645 7646 7647 7648
  case OPT_CONCURRENT_INSERT:
    /* The following code is mainly here to emulate old behavior */
    if (!argument)                      /* --concurrent-insert */
      myisam_concurrent_insert= 1;
    else if (argument == disabled_my_option)
      myisam_concurrent_insert= 0;      /* --skip-concurrent-insert */
    break;
unknown's avatar
Merge  
unknown committed
7649
  case OPT_TC_HEURISTIC_RECOVER:
7650 7651 7652 7653
    tc_heuristic_recover= find_type_or_exit(argument,
                                            &tc_heuristic_recover_typelib,
                                            opt->name);
    break;
7654 7655
  case OPT_MYISAM_STATS_METHOD:
  {
7656
    ulong method_conv;
7657
    int method;
unknown's avatar
unknown committed
7658 7659
    LINT_INIT(method_conv);

7660
    myisam_stats_method_str= argument;
7661 7662
    method= find_type_or_exit(argument, &myisam_stats_method_typelib,
                              opt->name);
7663
    switch (method-1) {
7664 7665
    case 2:
      method_conv= MI_STATS_METHOD_IGNORE_NULLS;
7666 7667
      break;
    case 1:
7668
      method_conv= MI_STATS_METHOD_NULLS_EQUAL;
7669
      break;
7670 7671
    case 0:
    default:
7672
      method_conv= MI_STATS_METHOD_NULLS_NOT_EQUAL;
7673 7674 7675
      break;
    }
    global_system_variables.myisam_stats_method= method_conv;
unknown's avatar
Merge  
unknown committed
7676 7677
    break;
  }
7678 7679
  case OPT_SQL_MODE:
  {
7680
    sql_mode_str= argument;
7681 7682
    global_system_variables.sql_mode=
      find_bit_type_or_exit(argument, &sql_mode_typelib, opt->name);
7683 7684
    global_system_variables.sql_mode= fix_sql_mode(global_system_variables.
						   sql_mode);
unknown's avatar
unknown committed
7685
    break;
7686
  }
unknown's avatar
unknown committed
7687 7688 7689 7690 7691
  case OPT_ONE_THREAD:
    global_system_variables.thread_handling= 2;
    break;
  case OPT_THREAD_HANDLING:
  {
unknown's avatar
unknown committed
7692 7693
    global_system_variables.thread_handling=
      find_type_or_exit(argument, &thread_handling_typelib, opt->name);
unknown's avatar
unknown committed
7694 7695
    break;
  }
unknown's avatar
unknown committed
7696
  case OPT_FT_BOOLEAN_SYNTAX:
7697
    if (ft_boolean_check_syntax_string((uchar*) argument))
unknown's avatar
unknown committed
7698 7699 7700 7701
    {
      fprintf(stderr, "Invalid ft-boolean-syntax string: %s\n", argument);
      exit(1);
    }
7702
    strmake(ft_boolean_syntax, argument, sizeof(ft_boolean_syntax)-1);
7703 7704
    break;
  case OPT_SKIP_SAFEMALLOC:
7705
#ifdef SAFEMALLOC
7706
    sf_malloc_quick=1;
7707
#endif
7708
    break;
unknown's avatar
unknown committed
7709 7710
  case OPT_LOWER_CASE_TABLE_NAMES:
    lower_case_table_names= argument ? atoi(argument) : 1;
7711
    lower_case_table_names_used= 1;
unknown's avatar
unknown committed
7712
    break;
unknown's avatar
unknown committed
7713
  }
7714 7715 7716
  return 0;
}
	/* Initiates DEBUG - but no debugging here ! */
7717

7718
static uchar* *
7719
mysql_getopt_value(const char *keyname, uint key_length,
7720 7721
		   const struct my_option *option)
{
7722 7723
  switch (option->id) {
  case OPT_KEY_BUFFER_SIZE:
unknown's avatar
unknown committed
7724
  case OPT_KEY_CACHE_BLOCK_SIZE:
7725 7726
  case OPT_KEY_CACHE_DIVISION_LIMIT:
  case OPT_KEY_CACHE_AGE_THRESHOLD:
7727
  {
unknown's avatar
unknown committed
7728
    KEY_CACHE *key_cache;
7729 7730
    if (!(key_cache= get_or_create_key_cache(keyname, key_length)))
      exit(1);
7731 7732
    switch (option->id) {
    case OPT_KEY_BUFFER_SIZE:
7733
      return (uchar**) &key_cache->param_buff_size;
7734
    case OPT_KEY_CACHE_BLOCK_SIZE:
7735
      return (uchar**) &key_cache->param_block_size;
7736
    case OPT_KEY_CACHE_DIVISION_LIMIT:
7737
      return (uchar**) &key_cache->param_division_limit;
7738
    case OPT_KEY_CACHE_AGE_THRESHOLD:
7739
      return (uchar**) &key_cache->param_age_threshold;
7740
    }
7741 7742
  }
  }
7743
 return option->value;
7744 7745
}

unknown's avatar
unknown committed
7746

unknown's avatar
unknown committed
7747
static void option_error_reporter(enum loglevel level, const char *format, ...)
unknown's avatar
unknown committed
7748
{
7749
  va_list args;
unknown's avatar
unknown committed
7750 7751 7752
  va_start(args, format);
  vprint_msg_to_log(level, format, args);
  va_end(args);
unknown's avatar
unknown committed
7753
}
7754

unknown's avatar
unknown committed
7755

unknown's avatar
unknown committed
7756
static void get_options(int *argc,char **argv)
7757 7758 7759
{
  int ho_error;

7760
  my_getopt_register_get_addr(mysql_getopt_value);
7761
  strmake(def_ft_boolean_syntax, ft_boolean_syntax,
unknown's avatar
unknown committed
7762
	  sizeof(ft_boolean_syntax)-1);
7763
  my_getopt_error_reporter= option_error_reporter;
unknown's avatar
unknown committed
7764 7765 7766 7767 7768

  /* Skip unknown options so that they may be processed later by plugins */
  my_getopt_skip_unknown= TRUE;

  if ((ho_error= handle_options(argc, &argv, my_long_options,
unknown's avatar
unknown committed
7769
                                get_one_option)))
7770
    exit(ho_error);
unknown's avatar
unknown committed
7771 7772
  (*argc)++; /* add back one for the progname handle_options removes */
             /* no need to do this for argv as we are discarding it. */
7773

7774 7775 7776
  if ((opt_log_slow_admin_statements || opt_log_queries_not_using_indexes) &&
      !opt_slow_log)
    sql_print_warning("options --log-slow-admin-statements and --log-queries-not-using-indexes have no effect if --log-slow-queries is not set");
7777

unknown's avatar
unknown committed
7778
#if defined(HAVE_BROKEN_REALPATH)
7779 7780 7781 7782 7783 7784 7785 7786 7787 7788
  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
7789 7790 7791 7792 7793 7794
  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;
  }
7795 7796 7797
  /* Set global MyISAM variables from delay_key_write_options */
  fix_delay_key_write((THD*) 0, OPT_GLOBAL);

7798
#ifndef EMBEDDED_LIBRARY
7799 7800
  if (mysqld_chroot)
    set_root(mysqld_chroot);
7801
#else
unknown's avatar
unknown committed
7802
  global_system_variables.thread_handling = SCHEDULER_NO_THREADS;
7803 7804
  max_allowed_packet= global_system_variables.max_allowed_packet;
  net_buffer_length= global_system_variables.net_buffer_length;
7805
#endif
unknown's avatar
unknown committed
7806
  fix_paths();
unknown's avatar
unknown committed
7807

unknown's avatar
unknown committed
7808 7809 7810 7811
  /*
    Set some global variables from the global_system_variables
    In most cases the global variables will not be used
  */
7812
  my_disable_locking= myisam_single_user= test(opt_external_locking == 0);
unknown's avatar
unknown committed
7813
  my_default_record_cache_size=global_system_variables.read_buff_size;
7814
  myisam_max_temp_length=
7815
    (my_off_t) global_system_variables.myisam_max_sort_file_size;
unknown's avatar
unknown committed
7816

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

7820 7821 7822 7823
  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;
7824

7825
  if (init_global_datetime_format(MYSQL_TIMESTAMP_DATE,
7826
				  &global_system_variables.date_format) ||
7827
      init_global_datetime_format(MYSQL_TIMESTAMP_TIME,
7828
				  &global_system_variables.time_format) ||
7829
      init_global_datetime_format(MYSQL_TIMESTAMP_DATETIME,
7830 7831
				  &global_system_variables.datetime_format))
    exit(1);
7832

unknown's avatar
unknown committed
7833 7834 7835 7836 7837 7838 7839 7840 7841 7842 7843
#ifdef EMBEDDED_LIBRARY
  one_thread_scheduler(&thread_scheduler);
#else
  if (global_system_variables.thread_handling <=
      SCHEDULER_ONE_THREAD_PER_CONNECTION)
    one_thread_per_connection_scheduler(&thread_scheduler);
  else if (global_system_variables.thread_handling == SCHEDULER_NO_THREADS)
    one_thread_scheduler(&thread_scheduler);
  else
    pool_of_threads_scheduler(&thread_scheduler);  /* purecov: tested */
#endif
unknown's avatar
unknown committed
7844 7845 7846
}


7847 7848 7849 7850 7851 7852 7853 7854 7855 7856
/*
  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,
7857
                     MYSQL_SERVER_SUFFIX_STR, NullS);
7858 7859 7860 7861
#ifdef EMBEDDED_LIBRARY
  end= strmov(end, "-embedded");
#endif
#ifndef DBUG_OFF
7862
  if (!strstr(MYSQL_SERVER_SUFFIX_STR, "-debug"))
7863 7864 7865 7866 7867 7868 7869
    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
7870 7871 7872
static char *get_relative_path(const char *path)
{
  if (test_if_hard_path(path) &&
7873
      is_prefix(path,DEFAULT_MYSQL_HOME) &&
unknown's avatar
unknown committed
7874 7875
      strcmp(DEFAULT_MYSQL_HOME,FN_ROOTDIR))
  {
unknown's avatar
unknown committed
7876
    path+=(uint) strlen(DEFAULT_MYSQL_HOME);
unknown's avatar
unknown committed
7877 7878 7879 7880 7881 7882 7883
    while (*path == FN_LIBCHAR)
      path++;
  }
  return (char*) path;
}


7884 7885 7886 7887 7888 7889 7890
/*
  Fix filename and replace extension where 'dir' is relative to
  mysql_real_data_home.
  Return 1 if len(path) > FN_REFLEN
*/

bool
7891
fn_format_relative_to_data_home(char * to, const char *name,
7892 7893 7894 7895 7896 7897 7898 7899 7900 7901
				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,
7902
		    MY_APPEND_EXT | MY_UNPACK_FILENAME | MY_SAFE_PATH);
7903 7904 7905
}


unknown's avatar
unknown committed
7906 7907
static void fix_paths(void)
{
7908
  char buff[FN_REFLEN],*pos;
7909
  convert_dirname(mysql_home,mysql_home,NullS);
7910
  /* Resolve symlinks to allow 'mysql_home' to be a relative symlink */
7911
  my_realpath(mysql_home,mysql_home,MYF(0));
7912 7913 7914 7915 7916 7917 7918
  /* Ensure that mysql_home ends in FN_LIBCHAR */
  pos=strend(mysql_home);
  if (pos[-1] != FN_LIBCHAR)
  {
    pos[0]= FN_LIBCHAR;
    pos[1]= 0;
  }
7919 7920
  convert_dirname(mysql_real_data_home,mysql_real_data_home,NullS);
  convert_dirname(language,language,NullS);
unknown's avatar
unknown committed
7921 7922 7923
  (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
7924 7925
  (void) my_load_path(opt_plugin_dir, opt_plugin_dir_ptr ? opt_plugin_dir_ptr :
                                      get_relative_path(LIBDIR), mysql_home);
7926
  opt_plugin_dir_ptr= opt_plugin_dir;
unknown's avatar
unknown committed
7927

unknown's avatar
unknown committed
7928
  char *sharedir=get_relative_path(SHAREDIR);
unknown's avatar
unknown committed
7929
  if (test_if_hard_path(sharedir))
unknown's avatar
unknown committed
7930
    strmake(buff,sharedir,sizeof(buff)-1);		/* purecov: tested */
unknown's avatar
unknown committed
7931
  else
unknown's avatar
unknown committed
7932
    strxnmov(buff,sizeof(buff)-1,mysql_home,sharedir,NullS);
7933
  convert_dirname(buff,buff,NullS);
unknown's avatar
unknown committed
7934 7935 7936 7937 7938
  (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
7939 7940
    strxnmov(mysql_charsets_dir, sizeof(mysql_charsets_dir)-1, buff,
	     CHARSET_DIR, NullS);
unknown's avatar
unknown committed
7941
  }
unknown's avatar
unknown committed
7942
  (void) my_load_path(mysql_charsets_dir, mysql_charsets_dir, buff);
7943
  convert_dirname(mysql_charsets_dir, mysql_charsets_dir, NullS);
unknown's avatar
unknown committed
7944
  charsets_dir=mysql_charsets_dir;
unknown's avatar
unknown committed
7945

unknown's avatar
unknown committed
7946
  if (init_tmpdir(&mysql_tmpdir_list, opt_mysql_tmpdir))
unknown's avatar
unknown committed
7947
    exit(1);
unknown's avatar
SCRUM  
unknown committed
7948
#ifdef HAVE_REPLICATION
7949 7950
  if (!slave_load_tmpdir)
  {
unknown's avatar
unknown committed
7951 7952
    if (!(slave_load_tmpdir = (char*) my_strdup(mysql_tmpdir, MYF(MY_FAE))))
      exit(1);
7953
  }
7954
#endif /* HAVE_REPLICATION */
7955 7956 7957 7958 7959 7960 7961 7962 7963 7964
  /*
    Convert the secure-file-priv option to system format, allowing
    a quick strcmp to check if read or write is in an allowed dir
   */
  if (opt_secure_file_priv)
  {
    convert_dirname(buff, opt_secure_file_priv, NullS);
    my_free(opt_secure_file_priv, MYF(0));
    opt_secure_file_priv= my_strdup(buff, MYF(MY_FAE));
  }
unknown's avatar
unknown committed
7965 7966 7967
}


7968 7969 7970 7971 7972 7973 7974 7975 7976 7977 7978 7979 7980 7981 7982 7983 7984 7985 7986 7987 7988 7989 7990 7991
static ulong find_bit_type_or_exit(const char *x, TYPELIB *bit_lib,
                                   const char *option)
{
  ulong res;

  const char **ptr;
  
  if ((res= find_bit_type(x, bit_lib)) == ~(ulong) 0)
  {
    ptr= bit_lib->type_names;
    if (!*x)
      fprintf(stderr, "No option given to %s\n", option);
    else
      fprintf(stderr, "Wrong option to %s. Option(s) given: %s\n", option, x);
    fprintf(stderr, "Alternatives are: '%s'", *ptr);
    while (*++ptr)
      fprintf(stderr, ",'%s'", *ptr);
    fprintf(stderr, "\n");
    exit(1);
  }
  return res;
}


7992 7993 7994 7995
/*
  Return a bitfield from a string of substrings separated by ','
  returns ~(ulong) 0 on error.
*/
7996 7997 7998 7999 8000 8001 8002 8003 8004 8005 8006 8007 8008

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

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


8053 8054 8055 8056 8057 8058 8059 8060 8061 8062 8063 8064 8065 8066 8067 8068 8069 8070 8071
/*
  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;
8072
  DBUG_ENTER("test_if_case_insensitive");
8073 8074 8075 8076 8077 8078 8079 8080

  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)
  {
8081
    sql_print_warning("Can't create test file %s", buff);
8082
    DBUG_RETURN(-1);
8083 8084 8085 8086 8087
  }
  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));
8088 8089
  DBUG_PRINT("exit", ("result: %d", result));
  DBUG_RETURN(result);
8090 8091 8092 8093 8094
}


/* Create file to store pid number */

8095 8096
#ifndef EMBEDDED_LIBRARY

8097 8098 8099 8100 8101 8102
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
8103
    char buff[21], *end;
8104
    end= int10_to_str((long) getpid(), buff, 10);
unknown's avatar
unknown committed
8105
    *end++= '\n';
8106
    if (!my_write(file, (uchar*) buff, (uint) (end-buff), MYF(MY_WME | MY_NABP)))
8107 8108 8109 8110
    {
      (void) my_close(file, MYF(0));
      return;
    }
8111 8112
    (void) my_close(file, MYF(0));
  }
8113
  sql_perror("Can't start server: can't create PID file");
unknown's avatar
foo1  
unknown committed
8114
  exit(1);
8115
}
8116
#endif /* EMBEDDED_LIBRARY */
8117

8118 8119 8120 8121 8122
/* Clear most status variables */
void refresh_status(THD *thd)
{
  pthread_mutex_lock(&LOCK_status);

8123
  /* Add thread's status variabes to global status */
8124
  add_to_status(&global_status_var, &thd->status_var);
8125 8126

  /* Reset thread's status variables */
8127 8128
  bzero((char*) &thd->status_var, sizeof(thd->status_var));

8129
  /* Reset some global variables */
unknown's avatar
unknown committed
8130
  reset_status_vars();
8131

8132 8133 8134 8135 8136 8137 8138 8139 8140 8141 8142 8143 8144
  /* Reset the counters of all key caches (default and named). */
  process_key_caches(reset_key_cache_counters);
  pthread_mutex_unlock(&LOCK_status);

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


8148
/*****************************************************************************
unknown's avatar
unknown committed
8149 8150
  Instantiate variables for missing storage engines
  This section should go away soon
8151 8152 8153 8154
*****************************************************************************/

#ifndef WITH_NDBCLUSTER_STORAGE_ENGINE
ulong ndb_cache_check_time;
unknown's avatar
unknown committed
8155
ulong ndb_extra_logging;
8156 8157
#endif

unknown's avatar
unknown committed
8158
/*****************************************************************************
8159
  Instantiate templates
unknown's avatar
unknown committed
8160 8161
*****************************************************************************/

8162
#ifdef HAVE_EXPLICIT_TEMPLATE_INSTANTIATION
unknown's avatar
unknown committed
8163 8164 8165 8166
/* Used templates */
template class I_List<THD>;
template class I_List_iterator<THD>;
template class I_List<i_string>;
8167
template class I_List<i_string_pair>;
8168
template class I_List<NAMED_LIST>;
8169 8170
template class I_List<Statement>;
template class I_List_iterator<Statement>;
unknown's avatar
unknown committed
8171
#endif