← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/drizzled.cc

  • Committer: Monty Taylor
  • Date: 2008-10-10 23:04:21 UTC
  • mto: (509.1.1 codestyle)
  • mto: This revision was merged to the branch mainline in revision 511.
  • Revision ID: monty@inaugust.com-20081010230421-zohe1eppxievpw8d
Removed O_NOFOLLOW

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/drizzled.cc
1
 
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
 
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
 
 *
4
 
 *  Copyright (C) 2008 Sun Microsystems
5
 
 *
6
 
 *  This program is free software; you can redistribute it and/or modify
7
 
 *  it under the terms of the GNU General Public License as published by
8
 
 *  the Free Software Foundation; version 2 of the License.
9
 
 *
10
 
 *  This program is distributed in the hope that it will be useful,
11
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
 
 *  GNU General Public License for more details.
14
 
 *
15
 
 *  You should have received a copy of the GNU General Public License
16
 
 *  along with this program; if not, write to the Free Software
17
 
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18
 
 */
19
 
 
20
 
#include "config.h"
21
 
#include "drizzled/configmake.h"
22
 
#include "drizzled/atomics.h"
23
 
#include "drizzled/data_home.h"
24
 
 
25
 
#include <netdb.h>
26
 
#include <sys/types.h>
 
1
/* Copyright (C) 2000-2003 MySQL AB
 
2
 
 
3
   This program is free software; you can redistribute it and/or modify
 
4
   it under the terms of the GNU General Public License as published by
 
5
   the Free Software Foundation; version 2 of the License.
 
6
 
 
7
   This program is distributed in the hope that it will be useful,
 
8
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
9
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
10
   GNU General Public License for more details.
 
11
 
 
12
   You should have received a copy of the GNU General Public License
 
13
   along with this program; if not, write to the Free Software
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
15
 
 
16
#include <drizzled/server_includes.h>
 
17
#include <mysys/my_bit.h>
 
18
#include "slave.h"
 
19
#include "rpl_mi.h"
 
20
#include "sql_repl.h"
 
21
#include "rpl_filter.h"
 
22
#include "stacktrace.h"
 
23
#include <mysys/mysys_err.h>
 
24
#include <sys/poll.h>
27
25
#include <netinet/tcp.h>
28
 
#include <netinet/in.h>
29
 
#include <signal.h>
30
 
#include <limits.h>
31
 
#include <stdexcept>
32
 
 
33
 
#include <boost/program_options.hpp>
34
 
#include <boost/thread/recursive_mutex.hpp>
35
 
#include <boost/thread/mutex.hpp>
36
 
#include <boost/thread/condition_variable.hpp>
37
 
 
38
 
#include "drizzled/internal/my_sys.h"
39
 
#include "drizzled/internal/my_bit.h"
40
 
#include <drizzled/my_hash.h>
41
 
#include <drizzled/error.h>
42
 
#include <drizzled/errmsg_print.h>
43
 
#include <drizzled/tztime.h>
44
 
#include <drizzled/sql_base.h>
45
 
#include <drizzled/show.h>
46
 
#include <drizzled/sql_parse.h>
47
 
#include <drizzled/item/cmpfunc.h>
48
 
#include <drizzled/session.h>
49
 
#include <drizzled/item/create.h>
50
 
#include <drizzled/unireg.h>
51
 
#include "drizzled/temporal_format.h" /* For init_temporal_formats() */
52
 
#include "drizzled/plugin/listen.h"
53
 
#include "drizzled/plugin/error_message.h"
54
 
#include "drizzled/plugin/client.h"
55
 
#include "drizzled/plugin/scheduler.h"
56
 
#include "drizzled/plugin/xa_resource_manager.h"
57
 
#include "drizzled/plugin/monitored_in_transaction.h"
58
 
#include "drizzled/replication_services.h" /* For ReplicationServices::evaluateRegisteredPlugins() */
59
 
#include "drizzled/probes.h"
60
 
#include "drizzled/session_list.h"
61
 
#include "drizzled/charset.h"
62
 
#include "plugin/myisam/myisam.h"
63
 
#include "drizzled/drizzled.h"
64
 
#include "drizzled/module/registry.h"
65
 
#include "drizzled/module/load_list.h"
66
 
 
67
 
#include <google/protobuf/stubs/common.h>
 
26
#include <drizzled/drizzled_error_messages.h>
68
27
 
69
28
#if TIME_WITH_SYS_TIME
70
29
# include <sys/time.h>
77
36
# endif
78
37
#endif
79
38
 
 
39
#include <storage/myisam/ha_myisam.h>
 
40
 
80
41
#ifdef HAVE_SYS_PRCTL_H
81
42
#include <sys/prctl.h>
82
43
#endif
83
 
#include <sys/socket.h>
84
 
 
85
 
 
 
44
 
 
45
#ifndef DEFAULT_SKIP_THREAD_PRIORITY
 
46
#define DEFAULT_SKIP_THREAD_PRIORITY 0
 
47
#endif
 
48
 
 
49
#include <mysys/thr_alarm.h>
 
50
#include <libdrizzle/errmsg.h>
 
51
#include <locale.h>
 
52
 
 
53
#define mysqld_charset &my_charset_utf8_general_ci
 
54
 
 
55
#ifdef HAVE_purify
 
56
#define IF_PURIFY(A,B) (A)
 
57
#else
 
58
#define IF_PURIFY(A,B) (B)
 
59
#endif
 
60
 
 
61
#define MAX_MEM_TABLE_SIZE SIZE_MAX
 
62
 
 
63
/* We have HAVE_purify below as this speeds up the shutdown of MySQL */
 
64
 
 
65
#if defined(HAVE_DEC_3_2_THREADS) || defined(SIGNALS_DONT_BREAK_READ) || defined(HAVE_purify) && defined(__linux__)
 
66
#define HAVE_CLOSE_SERVER_SOCK 1
 
67
#endif
 
68
 
 
69
extern "C" {                                    // Because of SCO 3.2V4.2
86
70
#include <errno.h>
87
71
#include <sys/stat.h>
88
 
#include "drizzled/option.h"
 
72
#ifndef __GNU_LIBRARY__
 
73
#define __GNU_LIBRARY__                         // Skip warnings in getopt.h
 
74
#endif
 
75
#include <mysys/my_getopt.h>
89
76
#ifdef HAVE_SYSENT_H
90
77
#include <sysent.h>
91
78
#endif
 
79
#ifdef HAVE_PWD_H
92
80
#include <pwd.h>                                // For getpwent
 
81
#endif
 
82
#ifdef HAVE_GRP_H
93
83
#include <grp.h>
 
84
#endif
 
85
 
 
86
#include <sys/resource.h>
94
87
 
95
88
#ifdef HAVE_SELECT_H
96
89
#  include <select.h>
106
99
#include <sys/mman.h>
107
100
#endif
108
101
 
 
102
#define SIGNAL_FMT "signal %d"
 
103
 
 
104
 
109
105
#if defined(__FreeBSD__) && defined(HAVE_IEEEFP_H)
110
106
#include <ieeefp.h>
 
107
#ifdef HAVE_FP_EXCEPT                           // Fix type conflict
 
108
typedef fp_except fp_except_t;
 
109
#endif
111
110
#endif /* __FreeBSD__ && HAVE_IEEEFP_H */
112
111
 
113
112
#ifdef HAVE_FPU_CONTROL_H
119
118
#include <sys/fpu.h>
120
119
#endif
121
120
 
122
 
#include "drizzled/internal/my_pthread.h"                       // For thr_setconcurency()
123
 
 
124
 
#include <drizzled/gettext.h>
125
 
 
126
 
 
127
 
#ifdef HAVE_purify
128
 
#define IF_PURIFY(A,B) (A)
129
 
#else
130
 
#define IF_PURIFY(A,B) (B)
131
 
#endif
132
 
 
133
 
#define MAX_MEM_TABLE_SIZE SIZE_MAX
134
 
#include <iostream>
135
 
#include <fstream>
136
 
 
137
 
 
138
 
using namespace std;
139
 
namespace po=boost::program_options;
140
 
 
141
 
 
142
 
namespace drizzled
143
 
{
144
 
 
145
 
#define mysqld_charset &my_charset_utf8_general_ci
146
121
inline void setup_fpu()
147
122
{
148
123
#if defined(__FreeBSD__) && defined(HAVE_IEEEFP_H)
172
147
#endif /* __i386__ && HAVE_FPU_CONTROL_H && _FPU_DOUBLE */
173
148
}
174
149
 
 
150
} /* cplusplus */
 
151
 
 
152
#define DRIZZLE_KILL_SIGNAL SIGTERM
 
153
 
 
154
#include <mysys/my_pthread.h>                   // For thr_setconcurency()
 
155
 
 
156
#include <libdrizzle/gettext.h>
 
157
 
175
158
#ifdef SOLARIS
176
159
extern "C" int gethostname(char *name, int namelen);
177
160
#endif
178
161
 
179
 
const char *first_keyword= "first";
180
 
const char * const DRIZZLE_CONFIG_NAME= "drizzled";
181
 
 
 
162
extern "C" RETSIGTYPE handle_segfault(int sig);
 
163
 
 
164
/* Constants */
 
165
 
 
166
const char *show_comp_option_name[]= {"YES", "NO", "DISABLED"};
 
167
/*
 
168
  WARNING: When adding new SQL modes don't forget to update the
 
169
           tables definitions that stores it's value.
 
170
           (ie: mysql.event, mysql.proc)
 
171
*/
 
172
static const char *optimizer_switch_names[]=
 
173
{
 
174
  "no_materialization", "no_semijoin",
 
175
  NULL
 
176
};
 
177
 
 
178
/* Corresponding defines are named OPTIMIZER_SWITCH_XXX */
 
179
static const unsigned int optimizer_switch_names_len[]=
 
180
{
 
181
  /*no_materialization*/          19,
 
182
  /*no_semijoin*/                 11
 
183
};
 
184
 
 
185
TYPELIB optimizer_switch_typelib= { array_elements(optimizer_switch_names)-1,"",
 
186
                                    optimizer_switch_names,
 
187
                                    (unsigned int *)optimizer_switch_names_len };
 
188
 
 
189
static const char *tc_heuristic_recover_names[]=
 
190
{
 
191
  "COMMIT", "ROLLBACK", NULL
 
192
};
 
193
static TYPELIB tc_heuristic_recover_typelib=
 
194
{
 
195
  array_elements(tc_heuristic_recover_names)-1,"",
 
196
  tc_heuristic_recover_names, NULL
 
197
};
 
198
 
 
199
const char *first_keyword= "first", *binary_keyword= "BINARY";
 
200
const char *my_localhost= "localhost";
 
201
#if SIZEOF_OFF_T > 4 && defined(BIG_TABLES)
182
202
#define GET_HA_ROWS GET_ULL
183
 
 
184
 
const char *tx_isolation_names[] =
185
 
{ "READ-UNCOMMITTED", "READ-COMMITTED", "REPEATABLE-READ", "SERIALIZABLE",
186
 
  NULL};
187
 
 
188
 
TYPELIB tx_isolation_typelib= {array_elements(tx_isolation_names)-1,"",
189
 
                               tx_isolation_names, NULL};
 
203
#else
 
204
#define GET_HA_ROWS GET_ULONG
 
205
#endif
190
206
 
191
207
/*
192
208
  Used with --help for detailed option
193
209
*/
194
 
bool opt_help= false;
195
 
bool opt_help_extended= false;
 
210
static bool opt_help= false;
196
211
 
197
212
arg_cmp_func Arg_comparator::comparator_matrix[5][2] =
198
213
{{&Arg_comparator::compare_string,     &Arg_comparator::compare_e_string},
201
216
 {&Arg_comparator::compare_row,        &Arg_comparator::compare_e_row},
202
217
 {&Arg_comparator::compare_decimal,    &Arg_comparator::compare_e_decimal}};
203
218
 
 
219
const char *log_output_names[] = { "NONE", "FILE", NULL};
 
220
static const unsigned int log_output_names_len[]= { 4, 4, 0 };
 
221
TYPELIB log_output_typelib= {array_elements(log_output_names)-1,"",
 
222
                             log_output_names,
 
223
                             (unsigned int *) log_output_names_len};
 
224
 
204
225
/* static variables */
205
226
 
206
 
static bool opt_debugging= 0;
207
 
static uint32_t wake_thread;
208
 
static char *drizzled_chroot;
209
 
static char *language_ptr;
210
 
static const char *default_character_set_name;
211
 
static const char *character_set_filesystem_name;
 
227
/* the default log output is log tables */
 
228
static bool volatile select_thread_in_use, signal_thread_in_use;
 
229
static bool volatile ready_to_exit;
 
230
static bool opt_debugging= 0, opt_console= 0;
 
231
static uint32_t kill_cached_threads, wake_thread;
 
232
static uint32_t killed_threads, thread_created;
 
233
static uint32_t max_used_connections;
 
234
static volatile uint32_t cached_thread_count= 0;
 
235
static char *mysqld_user, *mysqld_chroot, *log_error_file_ptr;
 
236
static char *opt_init_slave, *language_ptr, *opt_init_connect;
 
237
static char *default_character_set_name;
 
238
static char *character_set_filesystem_name;
212
239
static char *lc_time_names_name;
 
240
static char *my_bind_addr_str;
213
241
static char *default_collation_name;
214
242
static char *default_storage_engine_str;
215
 
static const char *compiled_default_collation_name= "utf8_general_ci";
 
243
static char compiled_default_collation_name[]= DRIZZLE_DEFAULT_COLLATION_NAME;
 
244
static I_List<THD> thread_cache;
 
245
static double long_query_time;
 
246
 
 
247
static pthread_cond_t COND_thread_cache, COND_flush_thread_cache;
216
248
 
217
249
/* Global variables */
218
250
 
219
 
bool volatile ready_to_exit;
220
 
char *drizzled_user;
221
 
bool volatile select_thread_in_use;
 
251
bool opt_bin_log;
 
252
ulong log_output_options;
 
253
bool opt_log_queries_not_using_indexes= false;
 
254
bool opt_error_log= 0;
 
255
bool opt_skip_show_db= false;
 
256
bool opt_character_set_client_handshake= 1;
 
257
bool server_id_supplied = 0;
 
258
bool opt_endinfo, using_udf_functions;
 
259
bool locked_in_memory;
 
260
bool opt_using_transactions, using_update_log;
222
261
bool volatile abort_loop;
223
262
bool volatile shutdown_in_progress;
224
 
char *opt_scheduler_default;
225
 
char *opt_scheduler= NULL;
226
 
 
227
 
size_t my_thread_stack_size= 0;
 
263
bool opt_skip_slave_start = 0; ///< If set, slave is not autostarted
 
264
bool opt_reckless_slave = 0;
 
265
bool opt_enable_named_pipe= 0;
 
266
bool opt_local_infile;
 
267
bool opt_slave_compressed_protocol;
 
268
bool opt_safe_user_create = 0;
 
269
bool opt_show_slave_auth_info, opt_sql_bin_update = 0;
 
270
bool opt_log_slave_updates= 0;
 
271
static struct pollfd fds[UINT8_MAX];
 
272
static uint8_t pollfd_count= 0;
228
273
 
229
274
/*
230
 
  Legacy global plugin::StorageEngine. These will be removed (please do not add more).
 
275
  Legacy global handlerton. These will be removed (please do not add more).
231
276
*/
232
 
plugin::StorageEngine *heap_engine;
233
 
plugin::StorageEngine *myisam_engine;
 
277
handlerton *heap_hton;
 
278
handlerton *myisam_hton;
234
279
 
 
280
bool opt_readonly;
 
281
bool use_temp_pool;
 
282
bool relay_log_purge;
 
283
bool opt_secure_auth= false;
235
284
char* opt_secure_file_priv= 0;
236
 
 
237
 
bool calling_initgroups= false; /**< Used in SIGSEGV handler. */
238
 
 
239
 
uint32_t drizzled_bind_timeout;
240
 
std::bitset<12> test_flags;
241
 
uint32_t dropping_tables, ha_open_options;
 
285
bool opt_log_slow_admin_statements= 0;
 
286
bool opt_log_slow_slave_statements= 0;
 
287
bool opt_old_style_user_limits= 0;
 
288
bool trust_function_creators= 0;
 
289
/*
 
290
  True if there is at least one per-hour limit for some user, so we should
 
291
  check them before each query (and possibly reset counters when hour is
 
292
  changed). False otherwise.
 
293
*/
 
294
bool opt_noacl;
 
295
 
 
296
ulong opt_binlog_rows_event_max_size;
 
297
const char *binlog_format_names[]= {"MIXED", "STATEMENT", "ROW", NULL};
 
298
TYPELIB binlog_format_typelib=
 
299
  { array_elements(binlog_format_names) - 1, "",
 
300
    binlog_format_names, NULL };
 
301
uint32_t opt_binlog_format_id= (uint32_t) BINLOG_FORMAT_UNSPEC;
 
302
const char *opt_binlog_format= binlog_format_names[opt_binlog_format_id];
 
303
#ifdef HAVE_INITGROUPS
 
304
static bool calling_initgroups= false; /**< Used in SIGSEGV handler. */
 
305
#endif
 
306
uint32_t mysqld_port, test_flags, select_errors, dropping_tables, ha_open_options;
 
307
uint32_t mysqld_port_timeout;
 
308
uint32_t delay_key_write_options, protocol_version;
 
309
uint32_t lower_case_table_names= 1;
242
310
uint32_t tc_heuristic_recover= 0;
243
 
uint64_t session_startup_options;
244
 
uint32_t back_log;
245
 
uint32_t server_id;
246
 
uint64_t table_cache_size;
247
 
size_t table_def_size;
248
 
uint64_t max_connect_errors;
249
 
uint32_t global_thread_id= 1UL;
250
 
pid_t current_pid;
251
 
 
252
 
extern const double log_10[309];
 
311
uint32_t volatile thread_count, thread_running;
 
312
uint64_t thd_startup_options;
 
313
ulong back_log, connect_timeout, server_id;
 
314
ulong table_cache_size, table_def_size;
 
315
ulong what_to_log;
 
316
ulong slow_launch_time, slave_open_temp_tables;
 
317
ulong open_files_limit;
 
318
ulong max_binlog_size;
 
319
ulong max_relay_log_size;
 
320
ulong slave_net_timeout;
 
321
ulong slave_trans_retries;
 
322
bool slave_allow_batching;
 
323
ulong slave_exec_mode_options;
 
324
const char *slave_exec_mode_str= "STRICT";
 
325
ulong thread_cache_size= 0;
 
326
ulong thread_pool_size= 0;
 
327
ulong binlog_cache_size= 0;
 
328
ulong max_binlog_cache_size= 0;
 
329
uint32_t refresh_version;  /* Increments on each reload */
 
330
query_id_t global_query_id;
 
331
ulong aborted_threads;
 
332
ulong aborted_connects;
 
333
ulong specialflag= 0;
 
334
ulong binlog_cache_use= 0;
 
335
ulong binlog_cache_disk_use= 0;
 
336
ulong max_connections;
 
337
ulong max_connect_errors;
 
338
uint32_t  max_user_connections= 0;
 
339
ulong thread_id=1L;
 
340
ulong current_pid;
 
341
ulong slow_launch_threads = 0;
 
342
ulong sync_binlog_period;
 
343
ulong expire_logs_days = 0;
 
344
ulong rpl_recovery_rank=0;
 
345
const char *log_output_str= "FILE";
253
346
 
254
347
const double log_10[] = {
255
348
  1e000, 1e001, 1e002, 1e003, 1e004, 1e005, 1e006, 1e007, 1e008, 1e009,
285
378
  1e300, 1e301, 1e302, 1e303, 1e304, 1e305, 1e306, 1e307, 1e308
286
379
};
287
380
 
288
 
time_t server_start_time;
289
 
time_t flush_status_time;
 
381
time_t server_start_time, flush_status_time;
290
382
 
291
 
char drizzle_home[FN_REFLEN], pidfile_name[FN_REFLEN], system_time_zone[30];
 
383
char mysql_home[FN_REFLEN], pidfile_name[FN_REFLEN], system_time_zone[30];
292
384
char *default_tz_name;
293
 
char glob_hostname[FN_REFLEN];
294
 
 
295
 
char language[FN_REFLEN], 
296
 
     *opt_tc_log_file;
 
385
char log_error_file[FN_REFLEN], glob_hostname[FN_REFLEN];
 
386
char mysql_real_data_home[FN_REFLEN],
 
387
     language[FN_REFLEN], reg_ext[FN_EXTLEN], mysql_charsets_dir[FN_REFLEN],
 
388
     *opt_init_file, *opt_tc_log_file;
 
389
char mysql_unpacked_real_data_home[FN_REFLEN];
 
390
uint32_t reg_ext_length;
297
391
const key_map key_map_empty(0);
298
392
key_map key_map_full(0);                        // Will be initialized later
299
393
 
300
 
std::string drizzle_tmpdir;
301
 
char *opt_drizzle_tmpdir= NULL;
 
394
const char *opt_date_time_formats[3];
 
395
 
 
396
uint32_t mysql_data_home_len;
 
397
char mysql_data_home_buff[2], *mysql_data_home=mysql_real_data_home;
 
398
char server_version[SERVER_VERSION_LENGTH];
 
399
char *opt_mysql_tmpdir;
 
400
const char *myisam_recover_options_str="OFF";
 
401
const char *myisam_stats_method_str="nulls_unequal";
302
402
 
303
403
/** name of reference on left espression in rewritten IN subquery */
304
404
const char *in_left_expr_name= "<left expr>";
308
408
 
309
409
my_decimal decimal_zero;
310
410
/* classes for comparation parsing/processing */
 
411
Eq_creator eq_creator;
 
412
Ne_creator ne_creator;
 
413
Gt_creator gt_creator;
 
414
Lt_creator lt_creator;
 
415
Ge_creator ge_creator;
 
416
Le_creator le_creator;
311
417
 
312
418
FILE *stderror_file=0;
313
419
 
 
420
I_List<THD> threads;
 
421
I_List<NAMED_LIST> key_caches;
 
422
Rpl_filter* rpl_filter;
 
423
Rpl_filter* binlog_filter;
 
424
 
314
425
struct system_variables global_system_variables;
315
426
struct system_variables max_system_variables;
316
 
struct global_counters current_global_counters;
 
427
struct system_status_var global_status_var;
 
428
 
 
429
MY_TMPDIR mysql_tmpdir_list;
 
430
MY_BITMAP temp_pool;
317
431
 
318
432
const CHARSET_INFO *system_charset_info, *files_charset_info ;
319
 
const CHARSET_INFO *table_alias_charset;
 
433
const CHARSET_INFO *national_charset_info, *table_alias_charset;
320
434
const CHARSET_INFO *character_set_filesystem;
321
435
 
322
436
MY_LOCALE *my_default_lc_time_names;
323
437
 
324
438
SHOW_COMP_OPTION have_symlink;
 
439
SHOW_COMP_OPTION have_compress;
325
440
 
326
441
/* Thread specific variables */
327
442
 
328
 
boost::mutex LOCK_open;
329
 
boost::mutex LOCK_global_system_variables;
330
 
boost::mutex LOCK_thread_count;
 
443
pthread_key(MEM_ROOT**,THR_MALLOC);
 
444
pthread_key(THD*, THR_THD);
 
445
pthread_mutex_t LOCK_mysql_create_db, LOCK_open, LOCK_thread_count,
 
446
                LOCK_status, LOCK_global_read_lock,
 
447
                LOCK_error_log, LOCK_uuid_generator,
 
448
                LOCK_global_system_variables,
 
449
                LOCK_user_conn, LOCK_slave_list, LOCK_active_mi,
 
450
                LOCK_connection_count;
331
451
 
332
 
boost::condition_variable COND_refresh;
333
 
boost::condition_variable COND_thread_count;
 
452
rw_lock_t       LOCK_sys_init_connect, LOCK_sys_init_slave;
 
453
rw_lock_t       LOCK_system_variables_hash;
 
454
pthread_cond_t COND_refresh, COND_thread_count, COND_global_read_lock;
334
455
pthread_t signal_thread;
335
 
boost::condition_variable COND_server_end;
 
456
pthread_attr_t connection_attrib;
 
457
pthread_cond_t  COND_server_started;
 
458
 
 
459
/* replication parameters, if master_host is not NULL, we are a slave */
 
460
uint32_t report_port= DRIZZLE_PORT;
 
461
uint32_t master_retry_count= 0;
 
462
char *master_info_file;
 
463
char *relay_log_info_file, *report_user, *report_password, *report_host;
 
464
char *opt_relay_logname = 0, *opt_relaylog_index_name=0;
 
465
char *opt_logname;
336
466
 
337
467
/* Static variables */
338
468
 
339
 
int cleanup_done;
340
 
static char *drizzle_home_ptr, *pidfile_name_ptr;
341
 
 
342
 
passwd *user_info;
343
 
 
344
 
atomic<uint32_t> connection_count;
345
 
 
346
 
/** 
347
 
  Refresh value. We use to test this to find out if a refresh even has happened recently.
 
469
static bool kill_in_progress, segfaulted;
 
470
#ifdef HAVE_STACK_TRACE_ON_SEGV
 
471
static bool opt_do_pstack;
 
472
#endif /* HAVE_STACK_TRACE_ON_SEGV */
 
473
static int cleanup_done;
 
474
static uint32_t opt_myisam_block_size;
 
475
static char *opt_binlog_index_name;
 
476
static char *opt_tc_heuristic_recover;
 
477
static char *mysql_home_ptr, *pidfile_name_ptr;
 
478
static int defaults_argc;
 
479
static char **defaults_argv;
 
480
static char *opt_bin_logname;
 
481
 
 
482
struct rand_struct sql_rand; ///< used by sql_class.cc:THD::THD()
 
483
 
 
484
struct passwd *user_info;
 
485
static pthread_t select_thread;
 
486
static uint32_t thr_kill_signal;
 
487
 
 
488
/* OS specific variables */
 
489
 
 
490
bool mysqld_embedded=0;
 
491
 
 
492
scheduler_functions thread_scheduler;
 
493
 
 
494
/**
 
495
  Number of currently active user connections. The variable is protected by
 
496
  LOCK_connection_count.
348
497
*/
349
 
uint64_t refresh_version;  /* Increments on each reload */
 
498
uint32_t connection_count= 0;
350
499
 
351
500
/* Function declarations */
352
 
bool drizzle_rm_tmp_tables();
353
501
 
354
 
static void drizzle_init_variables(void);
355
 
static void get_options();
356
 
static const char *get_relative_path(const char *path);
357
 
static void fix_paths(string progname);
 
502
pthread_handler_t signal_hand(void *arg);
 
503
static void mysql_init_variables(void);
 
504
static void get_options(int *argc,char **argv);
 
505
extern "C" bool mysqld_get_one_option(int, const struct my_option *, char *);
 
506
static void set_server_version(void);
 
507
static int init_thread_environment();
 
508
static char *get_relative_path(const char *path);
 
509
static void fix_paths(void);
 
510
void handle_connections_sockets();
 
511
pthread_handler_t kill_server_thread(void *arg);
 
512
pthread_handler_t handle_slave(void *arg);
 
513
static uint32_t find_bit_type(const char *x, TYPELIB *bit_lib);
 
514
static uint32_t find_bit_type_or_exit(const char *x, TYPELIB *bit_lib,
 
515
                                   const char *option);
 
516
static void clean_up(bool print_message);
358
517
 
359
518
static void usage(void);
360
 
void close_connections(void);
361
 
 
362
 
po::options_description long_options("Kernel Options");
363
 
po::options_description plugin_options("Plugin Options");
364
 
vector<string> unknown_options;
365
 
vector<string> defaults_file_list;
366
 
po::variables_map vm;
367
 
char * data_dir_ptr;
368
 
 
369
 
po::variables_map &getVariablesMap()
370
 
{
371
 
  return vm;
372
 
}
373
 
 
374
 
std::string& getDataHome()
375
 
{
376
 
  static string data_home(LOCALSTATEDIR);
377
 
  return data_home;
378
 
}
379
 
 
380
 
std::string& getDataHomeCatalog()
381
 
{
382
 
  static string data_home_catalog(getDataHome());
383
 
  return data_home_catalog;
384
 
}
385
 
 
386
 
char *getDatadir()
387
 
{
388
 
  return data_dir_ptr;
389
 
}
390
 
 
391
 
char **getDatadirPtr()
392
 
{
393
 
  return &data_dir_ptr;
394
 
}
395
 
 
 
519
static void start_signal_handler(void);
 
520
static void close_server_sock();
 
521
static void clean_up_mutexes(void);
 
522
static void wait_for_signal_thread_to_end(void);
 
523
static void create_pid_file();
 
524
static void mysqld_exit(int exit_code) __attribute__((noreturn));
 
525
 
396
526
/****************************************************************************
397
 
** Code to end drizzled
 
527
** Code to end mysqld
398
528
****************************************************************************/
399
529
 
400
 
void close_connections(void)
 
530
static void close_connections(void)
401
531
{
 
532
#ifdef EXTRA_DEBUG
 
533
  int count=0;
 
534
#endif
 
535
 
 
536
  /* Clear thread cache */
 
537
  kill_cached_threads++;
 
538
  flush_thread_cache();
 
539
 
 
540
  /* kill connection thread */
 
541
  (void) pthread_mutex_lock(&LOCK_thread_count);
 
542
 
 
543
  while (select_thread_in_use)
 
544
  {
 
545
    struct timespec abstime;
 
546
    int error;
 
547
 
 
548
#ifndef DONT_USE_THR_ALARM
 
549
    if (pthread_kill(select_thread, thr_client_alarm))
 
550
      break;                                    // allready dead
 
551
#endif
 
552
    set_timespec(abstime, 2);
 
553
    for (uint32_t tmp=0 ; tmp < 10 && select_thread_in_use; tmp++)
 
554
    {
 
555
      error=pthread_cond_timedwait(&COND_thread_count,&LOCK_thread_count,
 
556
                                   &abstime);
 
557
      if (error != EINTR)
 
558
        break;
 
559
    }
 
560
#ifdef EXTRA_DEBUG
 
561
    if (error != 0 && !count++)
 
562
      sql_print_error(_("Got error %d from pthread_cond_timedwait"),error);
 
563
#endif
 
564
    close_server_sock();
 
565
  }
 
566
  (void) pthread_mutex_unlock(&LOCK_thread_count);
 
567
 
 
568
 
402
569
  /* Abort listening to new connections */
403
 
  plugin::Listen::shutdown();
404
 
 
405
 
  /* kill connection thread */
406
570
  {
407
 
    boost::mutex::scoped_lock scopedLock(LOCK_thread_count);
 
571
    int x;
408
572
 
409
 
    while (select_thread_in_use)
 
573
    for (x= 0; x < pollfd_count; x++)
410
574
    {
411
 
      boost::xtime xt; 
412
 
      xtime_get(&xt, boost::TIME_UTC); 
413
 
      xt.sec += 2; 
414
 
 
415
 
      for (uint32_t tmp=0 ; tmp < 10 && select_thread_in_use; tmp++)
 
575
      if (fds[x].fd != -1)
416
576
      {
417
 
        bool success= COND_thread_count.timed_wait(scopedLock, xt);
418
 
        if (not success)
419
 
          break;
 
577
        (void) shutdown(fds[x].fd, SHUT_RDWR);
 
578
        (void) close(fds[x].fd);
 
579
        fds[x].fd= -1;
420
580
      }
421
581
    }
422
582
  }
423
583
 
 
584
  end_thr_alarm(0);                      // Abort old alarms.
424
585
 
425
586
  /*
426
587
    First signal all threads that it's time to die
428
589
    statements and inform their clients that the server is about to die.
429
590
  */
430
591
 
431
 
  Session *tmp;
432
 
 
433
 
  LOCK_thread_count.lock(); // For unlink from list
434
 
 
435
 
  for( SessionList::iterator it= getSessionList().begin(); it != getSessionList().end(); ++it )
 
592
  THD *tmp;
 
593
  (void) pthread_mutex_lock(&LOCK_thread_count); // For unlink from list
 
594
 
 
595
  I_List_iterator<THD> it(threads);
 
596
  while ((tmp=it++))
436
597
  {
437
 
    tmp= *it;
438
 
    tmp->killed= Session::KILL_CONNECTION;
439
 
    tmp->scheduler->killSession(tmp);
440
 
    DRIZZLE_CONNECTION_DONE(tmp->thread_id);
441
 
    tmp->lockOnSys();
 
598
    /* We skip slave threads & scheduler on this first loop through. */
 
599
    if (tmp->slave_thread)
 
600
      continue;
 
601
 
 
602
    tmp->killed= THD::KILL_CONNECTION;
 
603
    thread_scheduler.post_kill_notification(tmp);
 
604
    if (tmp->mysys_var)
 
605
    {
 
606
      tmp->mysys_var->abort=1;
 
607
      pthread_mutex_lock(&tmp->mysys_var->mutex);
 
608
      if (tmp->mysys_var->current_cond)
 
609
      {
 
610
        pthread_mutex_lock(tmp->mysys_var->current_mutex);
 
611
        pthread_cond_broadcast(tmp->mysys_var->current_cond);
 
612
        pthread_mutex_unlock(tmp->mysys_var->current_mutex);
 
613
      }
 
614
      pthread_mutex_unlock(&tmp->mysys_var->mutex);
 
615
    }
442
616
  }
443
 
  LOCK_thread_count.unlock(); // For unlink from list
444
 
 
445
 
  if (connection_count)
446
 
    sleep(2);                                   // Give threads time to die
 
617
  (void) pthread_mutex_unlock(&LOCK_thread_count); // For unlink from list
 
618
 
 
619
  end_slave();
 
620
 
 
621
  if (thread_count)
 
622
    sleep(2);                                   // Give threads time to die
447
623
 
448
624
  /*
449
625
    Force remaining threads to die by closing the connection to the client
450
626
    This will ensure that threads that are waiting for a command from the
451
627
    client on a blocking read call are aborted.
452
628
  */
 
629
 
453
630
  for (;;)
454
631
  {
455
 
    LOCK_thread_count.lock(); // For unlink from list
456
 
    if (getSessionList().empty())
 
632
    (void) pthread_mutex_lock(&LOCK_thread_count); // For unlink from list
 
633
    if (!(tmp=threads.get()))
457
634
    {
458
 
      LOCK_thread_count.unlock();
 
635
      (void) pthread_mutex_unlock(&LOCK_thread_count);
459
636
      break;
460
637
    }
461
 
    tmp= getSessionList().front();
462
 
    /* Close before unlock, avoiding crash. See LP bug#436685 */
463
 
    tmp->client->close();
464
 
    LOCK_thread_count.unlock();
465
 
  }
 
638
    if (tmp->vio_ok())
 
639
    {
 
640
      if (global_system_variables.log_warnings)
 
641
        sql_print_warning(ER(ER_FORCING_CLOSE),my_progname,
 
642
                          tmp->thread_id,
 
643
                          (tmp->main_security_ctx.user ?
 
644
                           tmp->main_security_ctx.user : ""));
 
645
      close_connection(tmp,0,0);
 
646
    }
 
647
    (void) pthread_mutex_unlock(&LOCK_thread_count);
 
648
  }
 
649
  /* All threads has now been aborted */
 
650
  (void) pthread_mutex_lock(&LOCK_thread_count);
 
651
  while (thread_count)
 
652
  {
 
653
    (void) pthread_cond_wait(&COND_thread_count,&LOCK_thread_count);
 
654
  }
 
655
  (void) pthread_mutex_unlock(&LOCK_thread_count);
 
656
 
 
657
  return;;
 
658
}
 
659
 
 
660
 
 
661
static void close_server_sock()
 
662
{
 
663
#ifdef HAVE_CLOSE_SERVER_SOCK
 
664
  {
 
665
    int x;
 
666
 
 
667
    for (x= 0; x < pollfd_count; x++)
 
668
    {
 
669
      if (fds[x].fd != -1)
 
670
      {
 
671
        (void) shutdown(fds[x].fd, SHUT_RDWR);
 
672
        (void) close(fds[x].fd);
 
673
        fds[x].fd= -1;
 
674
      }
 
675
    }
 
676
  }
 
677
#endif
 
678
}
 
679
 
 
680
 
 
681
void kill_mysql(void)
 
682
{
 
683
 
 
684
#if defined(SIGNALS_DONT_BREAK_READ)
 
685
  abort_loop=1;                                 // Break connection loops
 
686
  close_server_sock();                          // Force accept to wake up
 
687
#endif
 
688
 
 
689
#if defined(HAVE_PTHREAD_KILL)
 
690
  pthread_kill(signal_thread, DRIZZLE_KILL_SIGNAL);
 
691
#elif !defined(SIGNALS_DONT_BREAK_READ)
 
692
  kill(current_pid, DRIZZLE_KILL_SIGNAL);
 
693
#endif
 
694
  shutdown_in_progress=1;                       // Safety if kill didn't work
 
695
#ifdef SIGNALS_DONT_BREAK_READ
 
696
  if (!kill_in_progress)
 
697
  {
 
698
    pthread_t tmp;
 
699
    abort_loop=1;
 
700
    if (pthread_create(&tmp,&connection_attrib, kill_server_thread,
 
701
                           (void*) 0))
 
702
      sql_print_error(_("Can't create thread to kill server"));
 
703
  }
 
704
#endif
 
705
  return;;
 
706
}
 
707
 
 
708
/**
 
709
  Force server down. Kill all connections and threads and exit.
 
710
 
 
711
  @param  sig_ptr       Signal number that caused kill_server to be called.
 
712
 
 
713
  @note
 
714
    A signal number of 0 mean that the function was not called
 
715
    from a signal handler and there is thus no signal to block
 
716
    or stop, we just want to kill the server.
 
717
*/
 
718
 
 
719
static void *kill_server(void *sig_ptr)
 
720
#define RETURN_FROM_KILL_SERVER return(0)
 
721
{
 
722
  int sig=(int) (long) sig_ptr;                 // This is passed a int
 
723
  // if there is a signal during the kill in progress, ignore the other
 
724
  if (kill_in_progress)                         // Safety
 
725
    RETURN_FROM_KILL_SERVER;
 
726
  kill_in_progress=true;
 
727
  abort_loop=1;                                 // This should be set
 
728
  if (sig != 0) // 0 is not a valid signal number
 
729
    my_sigset(sig, SIG_IGN);                    /* purify inspected */
 
730
  if (sig == DRIZZLE_KILL_SIGNAL || sig == 0)
 
731
    sql_print_information(_(ER(ER_NORMAL_SHUTDOWN)),my_progname);
 
732
  else
 
733
    sql_print_error(_(ER(ER_GOT_SIGNAL)),my_progname,sig); /* purecov: inspected */
 
734
 
 
735
  close_connections();
 
736
  if (sig != DRIZZLE_KILL_SIGNAL &&
 
737
      sig != 0)
 
738
    unireg_abort(1);                            /* purecov: inspected */
 
739
  else
 
740
    unireg_end();
 
741
 
 
742
  /* purecov: begin deadcode */
 
743
 
 
744
  my_thread_end();
 
745
  pthread_exit(0);
 
746
  /* purecov: end */
 
747
 
 
748
  RETURN_FROM_KILL_SERVER;
 
749
}
 
750
 
 
751
 
 
752
#if defined(USE_ONE_SIGNAL_HAND)
 
753
pthread_handler_t kill_server_thread(void *arg __attribute__((unused)))
 
754
{
 
755
  my_thread_init();                             // Initialize new thread
 
756
  kill_server(0);
 
757
  /* purecov: begin deadcode */
 
758
  my_thread_end();
 
759
  pthread_exit(0);
 
760
  return 0;
 
761
  /* purecov: end */
 
762
}
 
763
#endif
 
764
 
 
765
 
 
766
extern "C" RETSIGTYPE print_signal_warning(int sig)
 
767
{
 
768
  if (global_system_variables.log_warnings)
 
769
    sql_print_warning(_("Got signal %d from thread %lud"), sig,my_thread_id());
 
770
#ifndef HAVE_BSD_SIGNALS
 
771
  my_sigset(sig,print_signal_warning);          /* int. thread system calls */
 
772
#endif
 
773
  if (sig == SIGALRM)
 
774
    alarm(2);                                   /* reschedule alarm */
466
775
}
467
776
 
468
777
/**
469
778
  cleanup all memory and end program nicely.
470
779
 
471
780
    If SIGNALS_DONT_BREAK_READ is defined, this function is called
472
 
    by the main thread. To get Drizzle to shut down nicely in this case
 
781
    by the main thread. To get MySQL to shut down nicely in this case
473
782
    (Mac OS X) we have to call exit() instead if pthread_exit().
474
783
 
475
784
  @note
478
787
void unireg_end(void)
479
788
{
480
789
  clean_up(1);
481
 
  internal::my_thread_end();
 
790
  my_thread_end();
482
791
#if defined(SIGNALS_DONT_BREAK_READ)
483
792
  exit(0);
484
793
#else
487
796
}
488
797
 
489
798
 
490
 
void unireg_abort(int exit_code)
 
799
extern "C" void unireg_abort(int exit_code)
491
800
{
492
801
 
493
802
  if (exit_code)
494
 
    errmsg_printf(ERRMSG_LVL_ERROR, _("Aborting\n"));
495
 
  else if (opt_help || opt_help_extended)
 
803
    sql_print_error(_("Aborting\n"));
 
804
  else if (opt_help)
496
805
    usage();
497
 
  clean_up(!opt_help && (exit_code));
498
 
  internal::my_end();
499
 
  exit(exit_code);
 
806
  clean_up(!opt_help && (exit_code)); /* purecov: inspected */
 
807
  mysqld_exit(exit_code);
 
808
}
 
809
 
 
810
 
 
811
static void mysqld_exit(int exit_code)
 
812
{
 
813
  wait_for_signal_thread_to_end();
 
814
  clean_up_mutexes();
 
815
  my_end(opt_endinfo ? MY_CHECK_ERROR | MY_GIVE_INFO : 0);
 
816
  exit(exit_code); /* purecov: inspected */
500
817
}
501
818
 
502
819
 
503
820
void clean_up(bool print_message)
504
821
{
505
822
  if (cleanup_done++)
506
 
    return;
507
 
 
 
823
    return; /* purecov: inspected */
 
824
 
 
825
  logger.cleanup_base();
 
826
 
 
827
  mysql_bin_log.cleanup();
 
828
 
 
829
  if (use_slave_mask)
 
830
    bitmap_free(&slave_error_mask);
 
831
  my_database_names_free();
508
832
  table_cache_free();
 
833
  table_def_free();
 
834
  lex_free();                           /* Free some memory */
 
835
  item_create_cleanup();
509
836
  set_var_free();
510
837
  free_charsets();
511
 
  module::Registry &modules= module::Registry::singleton();
512
 
  modules.shutdownModules();
 
838
  udf_free();
 
839
  plugin_shutdown();
 
840
  ha_end();
 
841
  if (tc_log)
 
842
    tc_log->close();
513
843
  xid_cache_free();
 
844
  delete_elements(&key_caches, (void (*)(const char*, unsigned char*)) free_key_cache);
 
845
  multi_keycache_free();
 
846
  free_status_vars();
 
847
  end_thr_alarm(1);                     /* Free allocated memory */
 
848
  my_free_open_file_info();
 
849
  free((char*) global_system_variables.date_format);
 
850
  free((char*) global_system_variables.time_format);
 
851
  free((char*) global_system_variables.datetime_format);
 
852
  if (defaults_argv)
 
853
    free_defaults(defaults_argv);
 
854
  free(sys_init_connect.value);
 
855
  free(sys_init_slave.value);
 
856
  free_tmpdir(&mysql_tmpdir_list);
 
857
  free(slave_load_tmpdir);
 
858
  if (opt_bin_logname)
 
859
    free(opt_bin_logname);
 
860
  if (opt_relay_logname)
 
861
    free(opt_relay_logname);
514
862
  if (opt_secure_file_priv)
515
863
    free(opt_secure_file_priv);
516
 
 
517
 
  deinit_temporal_formats();
518
 
 
519
 
#if GOOGLE_PROTOBUF_VERSION >= 2001000
520
 
  google::protobuf::ShutdownProtobufLibrary();
521
 
#endif
522
 
 
523
 
  (void) unlink(pidfile_name);  // This may not always exist
 
864
  bitmap_free(&temp_pool);
 
865
  delete binlog_filter;
 
866
  delete rpl_filter;
 
867
 
 
868
  (void) my_delete(pidfile_name,MYF(0));        // This may not always exist
524
869
 
525
870
  if (print_message && server_start_time)
526
 
    errmsg_printf(ERRMSG_LVL_INFO, _(ER(ER_SHUTDOWN_COMPLETE)),internal::my_progname);
527
 
  LOCK_thread_count.lock();
 
871
    sql_print_information(_(ER(ER_SHUTDOWN_COMPLETE)),my_progname);
 
872
  thread_scheduler.end();
 
873
  /* Returns NULL on globerrs, we don't want to try to free that */
 
874
  //void *freeme=
 
875
  (void *)my_error_unregister(ER_ERROR_FIRST, ER_ERROR_LAST);
 
876
  // TODO!!!! EPIC FAIL!!!! This sefaults if uncommented.
 
877
/*  if (freeme != NULL)
 
878
    free(freeme);  */
 
879
  /* Tell main we are ready */
 
880
  logger.cleanup_end();
 
881
  (void) pthread_mutex_lock(&LOCK_thread_count);
528
882
  ready_to_exit=1;
529
883
  /* do the broadcast inside the lock to ensure that my_end() is not called */
530
 
  COND_server_end.notify_all();
531
 
  LOCK_thread_count.unlock();
 
884
  (void) pthread_cond_broadcast(&COND_thread_count);
 
885
  (void) pthread_mutex_unlock(&LOCK_thread_count);
532
886
 
533
 
  char **data_home_ptr= getDatadirPtr();
534
 
  delete[](*data_home_ptr);
535
887
  /*
536
888
    The following lines may never be executed as the main thread may have
537
889
    killed us
539
891
} /* clean_up */
540
892
 
541
893
 
 
894
/**
 
895
  This is mainly needed when running with purify, but it's still nice to
 
896
  know that all child threads have died when mysqld exits.
 
897
*/
 
898
static void wait_for_signal_thread_to_end()
 
899
{
 
900
  uint32_t i;
 
901
  /*
 
902
    Wait up to 10 seconds for signal thread to die. We use this mainly to
 
903
    avoid getting warnings that my_thread_end has not been called
 
904
  */
 
905
  for (i= 0 ; i < 100 && signal_thread_in_use; i++)
 
906
  {
 
907
    if (pthread_kill(signal_thread, DRIZZLE_KILL_SIGNAL) != ESRCH)
 
908
      break;
 
909
    my_sleep(100);                              // Give it time to die
 
910
  }
 
911
}
 
912
 
 
913
 
 
914
static void clean_up_mutexes()
 
915
{
 
916
  (void) pthread_mutex_destroy(&LOCK_mysql_create_db);
 
917
  (void) pthread_mutex_destroy(&LOCK_lock_db);
 
918
  (void) pthread_mutex_destroy(&LOCK_open);
 
919
  (void) pthread_mutex_destroy(&LOCK_thread_count);
 
920
  (void) pthread_mutex_destroy(&LOCK_status);
 
921
  (void) pthread_mutex_destroy(&LOCK_error_log);
 
922
  (void) pthread_mutex_destroy(&LOCK_user_conn);
 
923
  (void) pthread_mutex_destroy(&LOCK_connection_count);
 
924
  (void) pthread_mutex_destroy(&LOCK_active_mi);
 
925
  (void) rwlock_destroy(&LOCK_sys_init_connect);
 
926
  (void) rwlock_destroy(&LOCK_sys_init_slave);
 
927
  (void) pthread_mutex_destroy(&LOCK_global_system_variables);
 
928
  (void) rwlock_destroy(&LOCK_system_variables_hash);
 
929
  (void) pthread_mutex_destroy(&LOCK_global_read_lock);
 
930
  (void) pthread_mutex_destroy(&LOCK_uuid_generator);
 
931
  (void) pthread_cond_destroy(&COND_thread_count);
 
932
  (void) pthread_cond_destroy(&COND_refresh);
 
933
  (void) pthread_cond_destroy(&COND_global_read_lock);
 
934
  (void) pthread_cond_destroy(&COND_thread_cache);
 
935
  (void) pthread_cond_destroy(&COND_flush_thread_cache);
 
936
}
 
937
 
 
938
 
 
939
/****************************************************************************
 
940
** Init IP and UNIX socket
 
941
****************************************************************************/
 
942
 
 
943
static void set_ports()
 
944
{
 
945
  char  *env;
 
946
  if (!mysqld_port)
 
947
  {                                     // Get port if not from commandline
 
948
    mysqld_port= DRIZZLE_PORT;
 
949
 
 
950
    /*
 
951
      if builder specifically requested a default port, use that
 
952
      (even if it coincides with our factory default).
 
953
      only if they didn't do we check /etc/services (and, failing
 
954
      on that, fall back to the factory default of 4427).
 
955
      either default can be overridden by the environment variable
 
956
      DRIZZLE_TCP_PORT, which in turn can be overridden with command
 
957
      line options.
 
958
    */
 
959
 
 
960
    struct  servent *serv_ptr;
 
961
    if ((serv_ptr= getservbyname("drizzle", "tcp")))
 
962
      mysqld_port= ntohs((u_short) serv_ptr->s_port); /* purecov: inspected */
 
963
 
 
964
    if ((env = getenv("DRIZZLE_TCP_PORT")))
 
965
      mysqld_port= (uint) atoi(env);            /* purecov: inspected */
 
966
 
 
967
    assert(mysqld_port);
 
968
  }
 
969
}
 
970
 
542
971
/* Change to run as another user if started with --user */
543
972
 
544
 
passwd *check_user(const char *user)
 
973
static struct passwd *check_user(const char *user)
545
974
{
546
 
  passwd *tmp_user_info;
 
975
  struct passwd *tmp_user_info;
547
976
  uid_t user_id= geteuid();
548
977
 
549
978
  // Don't bother if we aren't superuser
552
981
    if (user)
553
982
    {
554
983
      /* Don't give a warning, if real user is same as given with --user */
 
984
      /* purecov: begin tested */
555
985
      tmp_user_info= getpwnam(user);
556
986
      if ((!tmp_user_info || user_id != tmp_user_info->pw_uid) &&
557
987
          global_system_variables.log_warnings)
558
 
            errmsg_printf(ERRMSG_LVL_WARN, _("One can only use the --user switch "
 
988
        sql_print_warning(_("One can only use the --user switch "
559
989
                            "if running as root\n"));
 
990
      /* purecov: end */
560
991
    }
561
992
    return NULL;
562
993
  }
563
994
  if (!user)
564
995
  {
565
 
      errmsg_printf(ERRMSG_LVL_ERROR, _("Fatal error: Please read \"Security\" section of "
566
 
                      "the manual to find out how to run drizzled as root!\n"));
 
996
    sql_print_error(_("Fatal error: Please read \"Security\" section of "
 
997
                      "the manual to find out how to run mysqld as root!\n"));
567
998
    unireg_abort(1);
 
999
 
 
1000
    return NULL;
568
1001
  }
 
1002
  /* purecov: begin tested */
569
1003
  if (!strcmp(user,"root"))
570
1004
    return NULL;                        // Avoid problem with dynamic libraries
571
1005
 
580
1014
      goto err;
581
1015
  }
582
1016
  return tmp_user_info;
 
1017
  /* purecov: end */
583
1018
 
584
1019
err:
585
 
  errmsg_printf(ERRMSG_LVL_ERROR, _("Fatal error: Can't change to run as user '%s' ;  "
 
1020
  sql_print_error(_("Fatal error: Can't change to run as user '%s' ;  "
586
1021
                    "Please check that the user exists!\n"),user);
587
1022
  unireg_abort(1);
588
1023
 
589
1024
#ifdef PR_SET_DUMPABLE
590
 
  if (test_flags.test(TEST_CORE_ON_SIGNAL))
 
1025
  if (test_flags & TEST_CORE_ON_SIGNAL)
591
1026
  {
592
1027
    /* inform kernel that process is dumpable */
593
1028
    (void) prctl(PR_SET_DUMPABLE, 1);
594
1029
  }
595
1030
#endif
596
1031
 
597
 
/* Sun Studio 5.10 doesn't like this line.  5.9 requires it */
598
 
#if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x590)
599
1032
  return NULL;
600
 
#endif
601
 
 
602
1033
}
603
1034
 
604
 
void set_user(const char *user, passwd *user_info_arg)
 
1035
static void set_user(const char *user, struct passwd *user_info_arg)
605
1036
{
 
1037
  /* purecov: begin tested */
606
1038
  assert(user_info_arg != 0);
 
1039
#ifdef HAVE_INITGROUPS
 
1040
  /*
 
1041
    We can get a SIGSEGV when calling initgroups() on some systems when NSS
 
1042
    is configured to use LDAP and the server is statically linked.  We set
 
1043
    calling_initgroups as a flag to the SIGSEGV handler that is then used to
 
1044
    output a specific message to help the user resolve this problem.
 
1045
  */
 
1046
  calling_initgroups= true;
607
1047
  initgroups((char*) user, user_info_arg->pw_gid);
 
1048
  calling_initgroups= false;
 
1049
#endif
608
1050
  if (setgid(user_info_arg->pw_gid) == -1)
609
1051
  {
610
 
    sql_perror(N_("Set process group ID failed"));
 
1052
    sql_perror("setgid");
611
1053
    unireg_abort(1);
612
1054
  }
613
1055
  if (setuid(user_info_arg->pw_uid) == -1)
614
1056
  {
615
 
    sql_perror(N_("Set process user ID failed"));
616
 
    unireg_abort(1);
617
 
  }
618
 
}
619
 
 
 
1057
    sql_perror("setuid");
 
1058
    unireg_abort(1);
 
1059
  }
 
1060
  /* purecov: end */
 
1061
}
 
1062
 
 
1063
 
 
1064
static void set_effective_user(struct passwd *user_info_arg)
 
1065
{
 
1066
  assert(user_info_arg != 0);
 
1067
  if (setregid((gid_t)-1, user_info_arg->pw_gid) == -1)
 
1068
  {
 
1069
    sql_perror("setregid");
 
1070
    unireg_abort(1);
 
1071
  }
 
1072
  if (setreuid((uid_t)-1, user_info_arg->pw_uid) == -1)
 
1073
  {
 
1074
    sql_perror("setreuid");
 
1075
    unireg_abort(1);
 
1076
  }
 
1077
}
620
1078
 
621
1079
 
622
1080
/** Change root user if started with @c --chroot . */
623
1081
static void set_root(const char *path)
624
1082
{
625
 
  if ((chroot(path) == -1) || !chdir("/"))
 
1083
  if (chroot(path) == -1)
626
1084
  {
627
 
    sql_perror(N_("Process chroot failed"));
 
1085
    sql_perror("chroot");
628
1086
    unireg_abort(1);
629
1087
  }
 
1088
  my_setwd("/", MYF(0));
 
1089
}
 
1090
 
 
1091
 
 
1092
static void network_init(void)
 
1093
{
 
1094
  int   ret;
 
1095
  uint32_t  waited;
 
1096
  uint32_t  this_wait;
 
1097
  uint32_t  retry;
 
1098
  char port_buf[NI_MAXSERV];
 
1099
  struct addrinfo *ai;
 
1100
  struct addrinfo *next;
 
1101
  struct addrinfo hints;
 
1102
  int error;
 
1103
 
 
1104
  if (thread_scheduler.init())
 
1105
    unireg_abort(1);                    /* purecov: inspected */
 
1106
 
 
1107
  set_ports();
 
1108
 
 
1109
  memset(fds, 0, sizeof(struct pollfd) * UINT8_MAX);
 
1110
  memset(&hints, 0, sizeof (hints));
 
1111
  hints.ai_flags= AI_PASSIVE;
 
1112
  hints.ai_socktype= SOCK_STREAM;
 
1113
 
 
1114
  snprintf(port_buf, NI_MAXSERV, "%d", mysqld_port);
 
1115
  error= getaddrinfo(my_bind_addr_str, port_buf, &hints, &ai);
 
1116
  if (error != 0)
 
1117
  {
 
1118
    sql_perror(ER(ER_IPSOCK_ERROR));            /* purecov: tested */
 
1119
    unireg_abort(1);                            /* purecov: tested */
 
1120
  }
 
1121
 
 
1122
  for (next= ai, pollfd_count= 0; next; next= next->ai_next, pollfd_count++)
 
1123
  {
 
1124
    int ip_sock;
 
1125
 
 
1126
    ip_sock= socket(next->ai_family, next->ai_socktype, next->ai_protocol);
 
1127
 
 
1128
    if (ip_sock == -1)
 
1129
    {
 
1130
      sql_perror(ER(ER_IPSOCK_ERROR));          /* purecov: tested */
 
1131
      unireg_abort(1);                          /* purecov: tested */
 
1132
    }
 
1133
 
 
1134
    fds[pollfd_count].fd= ip_sock;
 
1135
    fds[pollfd_count].events= POLLIN | POLLERR;
 
1136
 
 
1137
    /* Add options for our listening socket */
 
1138
    {
 
1139
      int error;
 
1140
      struct linger ling = {0, 0};
 
1141
      int flags =1;
 
1142
 
 
1143
#ifdef IPV6_V6ONLY
 
1144
      if (next->ai_family == AF_INET6) 
 
1145
      {
 
1146
        error= setsockopt(ip_sock, IPPROTO_IPV6, IPV6_V6ONLY, (char *) &flags, sizeof(flags));
 
1147
        if (error != 0)
 
1148
        {
 
1149
          perror("setsockopt");
 
1150
          assert(error == 0);
 
1151
        }
 
1152
      }
 
1153
#endif   
 
1154
      error= setsockopt(ip_sock, SOL_SOCKET, SO_REUSEADDR, (char*)&flags, sizeof(flags));
 
1155
      if (error != 0)
 
1156
      {
 
1157
        perror("setsockopt");
 
1158
        assert(error == 0);
 
1159
      }
 
1160
      error= setsockopt(ip_sock, SOL_SOCKET, SO_KEEPALIVE, (void *)&flags, sizeof(flags));
 
1161
      if (error != 0)
 
1162
      {
 
1163
        perror("setsockopt");
 
1164
        assert(error == 0);
 
1165
      }
 
1166
      error= setsockopt(ip_sock, SOL_SOCKET, SO_LINGER, (void *)&ling, sizeof(ling));
 
1167
      if (error != 0)
 
1168
      {
 
1169
        perror("setsockopt");
 
1170
        assert(error == 0);
 
1171
      }
 
1172
      error= setsockopt(ip_sock, IPPROTO_TCP, TCP_NODELAY, (void *)&flags, sizeof(flags));
 
1173
      if (error != 0)
 
1174
      {
 
1175
        perror("setsockopt");
 
1176
        assert(error == 0);
 
1177
      }
 
1178
    }
 
1179
 
 
1180
 
 
1181
    /*
 
1182
      Sometimes the port is not released fast enough when stopping and
 
1183
      restarting the server. This happens quite often with the test suite
 
1184
      on busy Linux systems. Retry to bind the address at these intervals:
 
1185
      Sleep intervals: 1, 2, 4,  6,  9, 13, 17, 22, ...
 
1186
      Retry at second: 1, 3, 7, 13, 22, 35, 52, 74, ...
 
1187
      Limit the sequence by mysqld_port_timeout (set --port-open-timeout=#).
 
1188
    */
 
1189
    for (waited= 0, retry= 1; ; retry++, waited+= this_wait)
 
1190
    {
 
1191
      if (((ret= bind(ip_sock, next->ai_addr, next->ai_addrlen)) >= 0 ) ||
 
1192
          (errno != EADDRINUSE) ||
 
1193
          (waited >= mysqld_port_timeout))
 
1194
        break;
 
1195
      sql_print_information(_("Retrying bind on TCP/IP port %u"), mysqld_port);
 
1196
      this_wait= retry * retry / 3 + 1;
 
1197
      sleep(this_wait);
 
1198
    }
 
1199
    if (ret < 0)
 
1200
    {
 
1201
      sql_perror(_("Can't start server: Bind on TCP/IP port"));
 
1202
      sql_print_error(_("Do you already have another drizzled server running "
 
1203
                        "on port: %d ?"),mysqld_port);
 
1204
      unireg_abort(1);
 
1205
    }
 
1206
    if (listen(ip_sock,(int) back_log) < 0)
 
1207
    {
 
1208
      sql_perror(_("Can't start server: listen() on TCP/IP port"));
 
1209
      sql_print_error(_("listen() on TCP/IP failed with error %d"),
 
1210
                      errno);
 
1211
      unireg_abort(1);
 
1212
    }
 
1213
  }
 
1214
 
 
1215
  freeaddrinfo(ai);
 
1216
  return;
 
1217
}
 
1218
 
 
1219
/**
 
1220
  Close a connection.
 
1221
 
 
1222
  @param thd            Thread handle
 
1223
  @param errcode        Error code to print to console
 
1224
  @param lock           1 if we have have to lock LOCK_thread_count
 
1225
 
 
1226
  @note
 
1227
    For the connection that is doing shutdown, this is called twice
 
1228
*/
 
1229
void close_connection(THD *thd, uint32_t errcode, bool lock)
 
1230
{
 
1231
  st_vio *vio;
 
1232
  if (lock)
 
1233
    (void) pthread_mutex_lock(&LOCK_thread_count);
 
1234
  thd->killed= THD::KILL_CONNECTION;
 
1235
  if ((vio= thd->net.vio) != 0)
 
1236
  {
 
1237
    if (errcode)
 
1238
      net_send_error(thd, errcode, ER(errcode)); /* purecov: inspected */
 
1239
    net_close(&(thd->net));             /* vio is freed in delete thd */
 
1240
  }
 
1241
  if (lock)
 
1242
    (void) pthread_mutex_unlock(&LOCK_thread_count);
 
1243
  return;;
 
1244
}
 
1245
 
 
1246
 
 
1247
/** Called when a thread is aborted. */
 
1248
/* ARGSUSED */
 
1249
extern "C" RETSIGTYPE end_thread_signal(int sig __attribute__((unused)))
 
1250
{
 
1251
  THD *thd=current_thd;
 
1252
  if (thd && ! thd->bootstrap)
 
1253
  {
 
1254
    statistic_increment(killed_threads, &LOCK_status);
 
1255
    thread_scheduler.end_thread(thd,0);         /* purecov: inspected */
 
1256
  }
 
1257
  return;;                              /* purecov: deadcode */
630
1258
}
631
1259
 
632
1260
 
633
1261
/*
634
 
  Unlink session from global list of available connections and free session
 
1262
  Unlink thd from global list of available connections and free thd
635
1263
 
636
1264
  SYNOPSIS
637
 
    Session::unlink()
638
 
    session              Thread handler
 
1265
    unlink_thd()
 
1266
    thd          Thread handler
639
1267
 
640
1268
  NOTES
641
1269
    LOCK_thread_count is locked and left locked
642
1270
*/
643
1271
 
644
 
void Session::unlink(Session *session)
645
 
{
646
 
  connection_count.decrement();
647
 
 
648
 
  session->cleanup();
649
 
 
650
 
  LOCK_thread_count.lock();
651
 
  session->lockForDelete();
652
 
 
653
 
  getSessionList().erase(remove(getSessionList().begin(),
654
 
                         getSessionList().end(),
655
 
                         session));
656
 
 
657
 
  delete session;
658
 
  LOCK_thread_count.unlock();
659
 
}
660
 
 
 
1272
void unlink_thd(THD *thd)
 
1273
{
 
1274
  thd->cleanup();
 
1275
 
 
1276
  pthread_mutex_lock(&LOCK_connection_count);
 
1277
  --connection_count;
 
1278
  pthread_mutex_unlock(&LOCK_connection_count);
 
1279
 
 
1280
  (void) pthread_mutex_lock(&LOCK_thread_count);
 
1281
  thread_count--;
 
1282
  delete thd;
 
1283
  return;;
 
1284
}
 
1285
 
 
1286
 
 
1287
/*
 
1288
  Store thread in cache for reuse by new connections
 
1289
 
 
1290
  SYNOPSIS
 
1291
    cache_thread()
 
1292
 
 
1293
  NOTES
 
1294
    LOCK_thread_count has to be locked
 
1295
 
 
1296
  RETURN
 
1297
    0  Thread was not put in cache
 
1298
    1  Thread is to be reused by new connection.
 
1299
       (ie, caller should return, not abort with pthread_exit())
 
1300
*/
 
1301
 
 
1302
 
 
1303
static bool cache_thread()
 
1304
{
 
1305
  safe_mutex_assert_owner(&LOCK_thread_count);
 
1306
  if (cached_thread_count < thread_cache_size &&
 
1307
      ! abort_loop && !kill_cached_threads)
 
1308
  {
 
1309
    /* Don't kill the thread, just put it in cache for reuse */
 
1310
    cached_thread_count++;
 
1311
    while (!abort_loop && ! wake_thread && ! kill_cached_threads)
 
1312
      (void) pthread_cond_wait(&COND_thread_cache, &LOCK_thread_count);
 
1313
    cached_thread_count--;
 
1314
    if (kill_cached_threads)
 
1315
      pthread_cond_signal(&COND_flush_thread_cache);
 
1316
    if (wake_thread)
 
1317
    {
 
1318
      THD *thd;
 
1319
      wake_thread--;
 
1320
      thd= thread_cache.get();
 
1321
      thd->thread_stack= (char*) &thd;          // For store_globals
 
1322
      (void) thd->store_globals();
 
1323
      /*
 
1324
        THD::mysys_var::abort is associated with physical thread rather
 
1325
        than with THD object. So we need to reset this flag before using
 
1326
        this thread for handling of new THD object/connection.
 
1327
      */
 
1328
      thd->mysys_var->abort= 0;
 
1329
      thd->thr_create_utime= my_micro_time();
 
1330
      threads.append(thd);
 
1331
      return(1);
 
1332
    }
 
1333
  }
 
1334
  return(0);
 
1335
}
 
1336
 
 
1337
 
 
1338
/*
 
1339
  End thread for the current connection
 
1340
 
 
1341
  SYNOPSIS
 
1342
    one_thread_per_connection_end()
 
1343
    thd           Thread handler
 
1344
    put_in_cache  Store thread in cache, if there is room in it
 
1345
                  Normally this is true in all cases except when we got
 
1346
                  out of resources initializing the current thread
 
1347
 
 
1348
  NOTES
 
1349
    If thread is cached, we will wait until thread is scheduled to be
 
1350
    reused and then we will return.
 
1351
    If thread is not cached, we end the thread.
 
1352
 
 
1353
  RETURN
 
1354
    0    Signal to handle_one_connection to reuse connection
 
1355
*/
 
1356
 
 
1357
bool one_thread_per_connection_end(THD *thd, bool put_in_cache)
 
1358
{
 
1359
  unlink_thd(thd);
 
1360
  if (put_in_cache)
 
1361
    put_in_cache= cache_thread();
 
1362
  pthread_mutex_unlock(&LOCK_thread_count);
 
1363
  if (put_in_cache)
 
1364
    return(0);                             // Thread is reused
 
1365
 
 
1366
  /* It's safe to broadcast outside a lock (COND... is not deleted here) */
 
1367
  my_thread_end();
 
1368
  (void) pthread_cond_broadcast(&COND_thread_count);
 
1369
 
 
1370
  pthread_exit(0);
 
1371
  return(0);                               // Impossible
 
1372
}
 
1373
 
 
1374
 
 
1375
void flush_thread_cache()
 
1376
{
 
1377
  (void) pthread_mutex_lock(&LOCK_thread_count);
 
1378
  kill_cached_threads++;
 
1379
  while (cached_thread_count)
 
1380
  {
 
1381
    pthread_cond_broadcast(&COND_thread_cache);
 
1382
    pthread_cond_wait(&COND_flush_thread_cache,&LOCK_thread_count);
 
1383
  }
 
1384
  kill_cached_threads--;
 
1385
  (void) pthread_mutex_unlock(&LOCK_thread_count);
 
1386
}
 
1387
 
 
1388
 
 
1389
#ifdef THREAD_SPECIFIC_SIGPIPE
 
1390
/**
 
1391
  Aborts a thread nicely. Comes here on SIGPIPE.
 
1392
 
 
1393
  @todo
 
1394
    One should have to fix that thr_alarm know about this thread too.
 
1395
*/
 
1396
extern "C" RETSIGTYPE abort_thread(int sig __attribute__((unused)))
 
1397
{
 
1398
  THD *thd=current_thd;
 
1399
  if (thd)
 
1400
    thd->killed= THD::KILL_CONNECTION;
 
1401
  return;;
 
1402
}
 
1403
#endif
 
1404
 
 
1405
#if BACKTRACE_DEMANGLE
 
1406
#include <cxxabi.h>
 
1407
extern "C" char *my_demangle(const char *mangled_name, int *status)
 
1408
{
 
1409
  return abi::__cxa_demangle(mangled_name, NULL, NULL, status);
 
1410
}
 
1411
#endif
 
1412
 
 
1413
 
 
1414
extern "C" RETSIGTYPE handle_segfault(int sig)
 
1415
{
 
1416
  time_t curr_time;
 
1417
  struct tm tm;
 
1418
 
 
1419
  /*
 
1420
    Strictly speaking, one needs a mutex here
 
1421
    but since we have got SIGSEGV already, things are a mess
 
1422
    so not having the mutex is not as bad as possibly using a buggy
 
1423
    mutex - so we keep things simple
 
1424
  */
 
1425
  if (segfaulted)
 
1426
  {
 
1427
    fprintf(stderr, _("Fatal " SIGNAL_FMT " while backtracing\n"), sig);
 
1428
    exit(1);
 
1429
  }
 
1430
 
 
1431
  segfaulted = 1;
 
1432
 
 
1433
  curr_time= my_time(0);
 
1434
  localtime_r(&curr_time, &tm);
 
1435
 
 
1436
  fprintf(stderr,"%02d%02d%02d %2d:%02d:%02d - mysqld got "
 
1437
          SIGNAL_FMT " ;\n"
 
1438
          "This could be because you hit a bug. It is also possible that "
 
1439
          "this binary\n or one of the libraries it was linked against is "
 
1440
          "corrupt, improperly built,\n or misconfigured. This error can "
 
1441
          "also be caused by malfunctioning hardware.\n",
 
1442
          tm.tm_year % 100, tm.tm_mon+1, tm.tm_mday,
 
1443
          tm.tm_hour, tm.tm_min, tm.tm_sec,
 
1444
          sig);
 
1445
  fprintf(stderr, _("We will try our best to scrape up some info that "
 
1446
                    "will hopefully help diagnose\n"
 
1447
                    "the problem, but since we have already crashed, "
 
1448
                    "something is definitely wrong\nand this may fail.\n\n"));
 
1449
  fprintf(stderr, "key_buffer_size=%u\n",
 
1450
          (uint32_t) dflt_key_cache->key_cache_mem_size);
 
1451
  fprintf(stderr, "read_buffer_size=%ld\n", (long) global_system_variables.read_buff_size);
 
1452
  fprintf(stderr, "max_used_connections=%u\n", max_used_connections);
 
1453
  fprintf(stderr, "max_threads=%u\n", thread_scheduler.max_threads);
 
1454
  fprintf(stderr, "thread_count=%u\n", thread_count);
 
1455
  fprintf(stderr, "connection_count=%u\n", connection_count);
 
1456
  fprintf(stderr, _("It is possible that mysqld could use up to \n"
 
1457
                    "key_buffer_size + (read_buffer_size + "
 
1458
                    "sort_buffer_size)*max_threads = %lu K\n"
 
1459
                    "bytes of memory\n"
 
1460
                    "Hope that's ok; if not, decrease some variables in the "
 
1461
                    "equation.\n\n"),
 
1462
                    ((uint32_t) dflt_key_cache->key_cache_mem_size +
 
1463
                     (global_system_variables.read_buff_size +
 
1464
                      global_system_variables.sortbuff_size) *
 
1465
                     thread_scheduler.max_threads +
 
1466
                     max_connections * sizeof(THD)) / 1024);
 
1467
 
 
1468
#ifdef HAVE_STACKTRACE
 
1469
  THD *thd= current_thd;
 
1470
 
 
1471
  if (!(test_flags & TEST_NO_STACKTRACE))
 
1472
  {
 
1473
    fprintf(stderr,"thd: 0x%lx\n",(long) thd);
 
1474
    fprintf(stderr,_("Attempting backtrace. You can use the following "
 
1475
                     "information to find out\n"
 
1476
                     "where mysqld died. If you see no messages after this, "
 
1477
                     "something went\n"
 
1478
                     "terribly wrong...\n"));
 
1479
    print_stacktrace(thd ? (unsigned char*) thd->thread_stack : (unsigned char*) 0,
 
1480
                     my_thread_stack_size);
 
1481
  }
 
1482
  if (thd)
 
1483
  {
 
1484
    const char *kreason= "UNKNOWN";
 
1485
    switch (thd->killed) {
 
1486
    case THD::NOT_KILLED:
 
1487
      kreason= "NOT_KILLED";
 
1488
      break;
 
1489
    case THD::KILL_BAD_DATA:
 
1490
      kreason= "KILL_BAD_DATA";
 
1491
      break;
 
1492
    case THD::KILL_CONNECTION:
 
1493
      kreason= "KILL_CONNECTION";
 
1494
      break;
 
1495
    case THD::KILL_QUERY:
 
1496
      kreason= "KILL_QUERY";
 
1497
      break;
 
1498
    case THD::KILLED_NO_VALUE:
 
1499
      kreason= "KILLED_NO_VALUE";
 
1500
      break;
 
1501
    }
 
1502
    fprintf(stderr, _("Trying to get some variables.\n"
 
1503
                      "Some pointers may be invalid and cause the "
 
1504
                      "dump to abort...\n"));
 
1505
    safe_print_str("thd->query", thd->query, 1024);
 
1506
    fprintf(stderr, "thd->thread_id=%"PRIu32"\n", (uint32_t) thd->thread_id);
 
1507
    fprintf(stderr, "thd->killed=%s\n", kreason);
 
1508
  }
 
1509
  fflush(stderr);
 
1510
#endif /* HAVE_STACKTRACE */
 
1511
 
 
1512
#ifdef HAVE_INITGROUPS
 
1513
  if (calling_initgroups)
 
1514
    fprintf(stderr, _("\nThis crash occured while the server was calling "
 
1515
                      "initgroups(). This is\n"
 
1516
                      "often due to the use of a drizzled that is statically "
 
1517
                      "linked against glibc\n"
 
1518
                      "and configured to use LDAP in /etc/nsswitch.conf. "
 
1519
                      "You will need to either\n"
 
1520
                      "upgrade to a version of glibc that does not have this "
 
1521
                      "problem (2.3.4 or\n"
 
1522
                      "later when used with nscd), disable LDAP in your "
 
1523
                      "nsswitch.conf, or use a\n"
 
1524
                      "drizzled that is not statically linked.\n"));
 
1525
#endif
 
1526
 
 
1527
  if (thd_lib_detected == THD_LIB_LT && !getenv("LD_ASSUME_KERNEL"))
 
1528
    fprintf(stderr,
 
1529
            _("\nYou are running a statically-linked LinuxThreads binary "
 
1530
              "on an NPTL system.\n"
 
1531
              "This can result in crashes on some distributions due "
 
1532
              "to LT/NPTL conflicts.\n"
 
1533
              "You should either build a dynamically-linked binary, or force "
 
1534
              "LinuxThreads\n"
 
1535
              "to be used with the LD_ASSUME_KERNEL environment variable. "
 
1536
              "Please consult\n"
 
1537
              "the documentation for your distribution on how to do that.\n"));
 
1538
 
 
1539
  if (locked_in_memory)
 
1540
  {
 
1541
    fprintf(stderr,
 
1542
            _("\nThe '--memlock' argument, which was enabled, uses system "
 
1543
              "calls that are\n"
 
1544
              "unreliable and unstable on some operating systems and "
 
1545
              "operating-system\n"
 
1546
              "versions (notably, some versions of Linux).  "
 
1547
              "This crash could be due to use\n"
 
1548
              "of those buggy OS calls.  You should consider whether you "
 
1549
              "really need the\n"
 
1550
              "'--memlock' parameter and/or consult the OS "
 
1551
              "distributor about 'mlockall'\n bugs.\n"));
 
1552
  }
 
1553
 
 
1554
#ifdef HAVE_WRITE_CORE
 
1555
  if (test_flags & TEST_CORE_ON_SIGNAL)
 
1556
  {
 
1557
    fprintf(stderr, _("Writing a core file\n"));
 
1558
    fflush(stderr);
 
1559
    write_core(sig);
 
1560
  }
 
1561
#endif
 
1562
 
 
1563
  exit(1);
 
1564
}
661
1565
 
662
1566
#ifndef SA_RESETHAND
663
1567
#define SA_RESETHAND 0
666
1570
#define SA_NODEFER 0
667
1571
#endif
668
1572
 
669
 
 
670
 
 
671
 
 
672
 
const char *load_default_groups[]= 
673
 
{
674
 
  DRIZZLE_CONFIG_NAME, "server", 0, 0
 
1573
static void init_signals(void)
 
1574
{
 
1575
  sigset_t set;
 
1576
  struct sigaction sa;
 
1577
 
 
1578
  my_sigset(THR_SERVER_ALARM,print_signal_warning); // Should never be called!
 
1579
 
 
1580
  if (!(test_flags & TEST_NO_STACKTRACE) || (test_flags & TEST_CORE_ON_SIGNAL))
 
1581
  {
 
1582
    sa.sa_flags = SA_RESETHAND | SA_NODEFER;
 
1583
    sigemptyset(&sa.sa_mask);
 
1584
    sigprocmask(SIG_SETMASK,&sa.sa_mask,NULL);
 
1585
 
 
1586
    init_stacktrace();
 
1587
    sa.sa_handler=handle_segfault;
 
1588
    sigaction(SIGSEGV, &sa, NULL);
 
1589
    sigaction(SIGABRT, &sa, NULL);
 
1590
#ifdef SIGBUS
 
1591
    sigaction(SIGBUS, &sa, NULL);
 
1592
#endif
 
1593
    sigaction(SIGILL, &sa, NULL);
 
1594
    sigaction(SIGFPE, &sa, NULL);
 
1595
  }
 
1596
 
 
1597
#ifdef HAVE_GETRLIMIT
 
1598
  if (test_flags & TEST_CORE_ON_SIGNAL)
 
1599
  {
 
1600
    /* Change limits so that we will get a core file */
 
1601
    STRUCT_RLIMIT rl;
 
1602
    rl.rlim_cur = rl.rlim_max = RLIM_INFINITY;
 
1603
    if (setrlimit(RLIMIT_CORE, &rl) && global_system_variables.log_warnings)
 
1604
      sql_print_warning(_("setrlimit could not change the size of core files "
 
1605
                          "to 'infinity';  We may not be able to generate a "
 
1606
                          "core file on signals"));
 
1607
  }
 
1608
#endif
 
1609
  (void) sigemptyset(&set);
 
1610
  my_sigset(SIGPIPE,SIG_IGN);
 
1611
  sigaddset(&set,SIGPIPE);
 
1612
#ifndef IGNORE_SIGHUP_SIGQUIT
 
1613
  sigaddset(&set,SIGQUIT);
 
1614
  sigaddset(&set,SIGHUP);
 
1615
#endif
 
1616
  sigaddset(&set,SIGTERM);
 
1617
 
 
1618
  /* Fix signals if blocked by parents (can happen on Mac OS X) */
 
1619
  sigemptyset(&sa.sa_mask);
 
1620
  sa.sa_flags = 0;
 
1621
  sa.sa_handler = print_signal_warning;
 
1622
  sigaction(SIGTERM, &sa, (struct sigaction*) 0);
 
1623
  sa.sa_flags = 0;
 
1624
  sa.sa_handler = print_signal_warning;
 
1625
  sigaction(SIGHUP, &sa, (struct sigaction*) 0);
 
1626
#ifdef SIGTSTP
 
1627
  sigaddset(&set,SIGTSTP);
 
1628
#endif
 
1629
  if (thd_lib_detected != THD_LIB_LT)
 
1630
    sigaddset(&set,THR_SERVER_ALARM);
 
1631
  if (test_flags & TEST_SIGINT)
 
1632
  {
 
1633
    my_sigset(thr_kill_signal, end_thread_signal);
 
1634
    // May be SIGINT
 
1635
    sigdelset(&set, thr_kill_signal);
 
1636
  }
 
1637
  else
 
1638
    sigaddset(&set,SIGINT);
 
1639
  sigprocmask(SIG_SETMASK,&set,NULL);
 
1640
  pthread_sigmask(SIG_SETMASK,&set,NULL);
 
1641
  return;;
 
1642
}
 
1643
 
 
1644
 
 
1645
static void start_signal_handler(void)
 
1646
{
 
1647
  int error;
 
1648
  pthread_attr_t thr_attr;
 
1649
 
 
1650
  (void) pthread_attr_init(&thr_attr);
 
1651
  pthread_attr_setscope(&thr_attr, PTHREAD_SCOPE_SYSTEM);
 
1652
  (void) pthread_attr_setdetachstate(&thr_attr, PTHREAD_CREATE_DETACHED);
 
1653
  {
 
1654
    struct sched_param tmp_sched_param;
 
1655
 
 
1656
    memset(&tmp_sched_param, 0, sizeof(tmp_sched_param));
 
1657
    tmp_sched_param.sched_priority= INTERRUPT_PRIOR;
 
1658
    (void)pthread_attr_setschedparam(&thr_attr, &tmp_sched_param);
 
1659
  }
 
1660
#if defined(__ia64__) || defined(__ia64)
 
1661
  /*
 
1662
    Peculiar things with ia64 platforms - it seems we only have half the
 
1663
    stack size in reality, so we have to double it here
 
1664
  */
 
1665
  pthread_attr_setstacksize(&thr_attr,my_thread_stack_size*2);
 
1666
#else
 
1667
  pthread_attr_setstacksize(&thr_attr,my_thread_stack_size);
 
1668
 
 
1669
  (void) pthread_mutex_lock(&LOCK_thread_count);
 
1670
  if ((error=pthread_create(&signal_thread,&thr_attr,signal_hand,0)))
 
1671
  {
 
1672
    sql_print_error(_("Can't create interrupt-thread (error %d, errno: %d)"),
 
1673
                    error,errno);
 
1674
    exit(1);
 
1675
  }
 
1676
  (void) pthread_cond_wait(&COND_thread_count,&LOCK_thread_count);
 
1677
  pthread_mutex_unlock(&LOCK_thread_count);
 
1678
 
 
1679
  (void) pthread_attr_destroy(&thr_attr);
 
1680
  return;;
 
1681
}
 
1682
 
 
1683
 
 
1684
/** This threads handles all signals and alarms. */
 
1685
/* ARGSUSED */
 
1686
pthread_handler_t signal_hand(void *arg __attribute__((unused)))
 
1687
{
 
1688
  sigset_t set;
 
1689
  int sig;
 
1690
  my_thread_init();                             // Init new thread
 
1691
  signal_thread_in_use= 1;
 
1692
 
 
1693
  /*
 
1694
    Setup alarm handler
 
1695
    This should actually be '+ max_number_of_slaves' instead of +10,
 
1696
    but the +10 should be quite safe.
 
1697
  */
 
1698
  init_thr_alarm(thread_scheduler.max_threads + 10);
 
1699
  if (thd_lib_detected != THD_LIB_LT && (test_flags & TEST_SIGINT))
 
1700
  {
 
1701
    (void) sigemptyset(&set);                   // Setup up SIGINT for debug
 
1702
    (void) sigaddset(&set,SIGINT);              // For debugging
 
1703
    (void) pthread_sigmask(SIG_UNBLOCK,&set,NULL);
 
1704
  }
 
1705
  (void) sigemptyset(&set);                     // Setup up SIGINT for debug
 
1706
#ifdef USE_ONE_SIGNAL_HAND
 
1707
  (void) sigaddset(&set,THR_SERVER_ALARM);      // For alarms
 
1708
#endif
 
1709
#ifndef IGNORE_SIGHUP_SIGQUIT
 
1710
  (void) sigaddset(&set,SIGQUIT);
 
1711
  (void) sigaddset(&set,SIGHUP);
 
1712
#endif
 
1713
  (void) sigaddset(&set,SIGTERM);
 
1714
  (void) sigaddset(&set,SIGTSTP);
 
1715
 
 
1716
  /* Save pid to this process (or thread on Linux) */
 
1717
  create_pid_file();
 
1718
 
 
1719
#ifdef HAVE_STACK_TRACE_ON_SEGV
 
1720
  if (opt_do_pstack)
 
1721
  {
 
1722
    sprintf(pstack_file_name,"mysqld-%lu-%%d-%%d.backtrace", (uint32_t)getpid());
 
1723
    pstack_install_segv_action(pstack_file_name);
 
1724
  }
 
1725
#endif /* HAVE_STACK_TRACE_ON_SEGV */
 
1726
 
 
1727
  /*
 
1728
    signal to start_signal_handler that we are ready
 
1729
    This works by waiting for start_signal_handler to free mutex,
 
1730
    after which we signal it that we are ready.
 
1731
    At this pointer there is no other threads running, so there
 
1732
    should not be any other pthread_cond_signal() calls.
 
1733
  */
 
1734
  (void) pthread_mutex_lock(&LOCK_thread_count);
 
1735
  (void) pthread_mutex_unlock(&LOCK_thread_count);
 
1736
  (void) pthread_cond_broadcast(&COND_thread_count);
 
1737
 
 
1738
  (void) pthread_sigmask(SIG_BLOCK,&set,NULL);
 
1739
  for (;;)
 
1740
  {
 
1741
    int error;                                  // Used when debugging
 
1742
    if (shutdown_in_progress && !abort_loop)
 
1743
    {
 
1744
      sig= SIGTERM;
 
1745
      error=0;
 
1746
    }
 
1747
    else
 
1748
      while ((error=my_sigwait(&set,&sig)) == EINTR) ;
 
1749
    if (cleanup_done)
 
1750
    {
 
1751
      my_thread_end();
 
1752
      signal_thread_in_use= 0;
 
1753
      pthread_exit(0);                          // Safety
 
1754
    }
 
1755
    switch (sig) {
 
1756
    case SIGTERM:
 
1757
    case SIGQUIT:
 
1758
    case SIGKILL:
 
1759
#ifdef EXTRA_DEBUG
 
1760
      sql_print_information(_("Got signal %d to shutdown mysqld"),sig);
 
1761
#endif
 
1762
      /* switch to the old log message processing */
 
1763
      if (!abort_loop)
 
1764
      {
 
1765
        abort_loop=1;                           // mark abort for threads
 
1766
#ifdef USE_ONE_SIGNAL_HAND
 
1767
        pthread_t tmp;
 
1768
        {
 
1769
          struct sched_param tmp_sched_param;
 
1770
 
 
1771
          memset(&tmp_sched_param, 0, sizeof(tmp_sched_param));
 
1772
          tmp_sched_param.sched_priority= INTERRUPT_PRIOR;
 
1773
          (void)pthread_attr_setschedparam(&connection_attrib, &tmp_sched_param);
 
1774
        }
 
1775
        if (pthread_create(&tmp,&connection_attrib, kill_server_thread,
 
1776
                           (void*) &sig))
 
1777
          sql_print_error(_("Can't create thread to kill server"));
 
1778
#else
 
1779
        kill_server((void*) sig);       // MIT THREAD has a alarm thread
 
1780
#endif
 
1781
      }
 
1782
      break;
 
1783
    case SIGHUP:
 
1784
      if (!abort_loop)
 
1785
      {
 
1786
        bool not_used;
 
1787
        reload_cache((THD*) 0,
 
1788
                     (REFRESH_LOG | REFRESH_TABLES | REFRESH_FAST |
 
1789
                      REFRESH_GRANT |
 
1790
                      REFRESH_THREADS | REFRESH_HOSTS),
 
1791
                     (TableList*) 0, &not_used); // Flush logs
 
1792
      }
 
1793
      break;
 
1794
#ifdef USE_ONE_SIGNAL_HAND
 
1795
    case THR_SERVER_ALARM:
 
1796
      process_alarm(sig);                       // Trigger alarms.
 
1797
      break;
 
1798
#endif
 
1799
    default:
 
1800
#ifdef EXTRA_DEBUG
 
1801
      sql_print_warning(_("Got signal: %d  error: %d"),sig,error); /* purecov: tested */
 
1802
#endif
 
1803
      break;                                    /* purecov: tested */
 
1804
    }
 
1805
  }
 
1806
  return(0);                                    /* purecov: deadcode */
 
1807
}
 
1808
 
 
1809
static void check_data_home(const char *path __attribute__((unused)))
 
1810
{}
 
1811
 
 
1812
#endif  /* __WIN__*/
 
1813
 
 
1814
 
 
1815
/**
 
1816
  All global error messages are sent here where the first one is stored
 
1817
  for the client.
 
1818
*/
 
1819
/* ARGSUSED */
 
1820
extern "C" void my_message_sql(uint32_t error, const char *str, myf MyFlags);
 
1821
 
 
1822
void my_message_sql(uint32_t error, const char *str, myf MyFlags)
 
1823
{
 
1824
  THD *thd;
 
1825
  /*
 
1826
    Put here following assertion when situation with EE_* error codes
 
1827
    will be fixed
 
1828
  */
 
1829
  if ((thd= current_thd))
 
1830
  {
 
1831
    if (MyFlags & ME_FATALERROR)
 
1832
      thd->is_fatal_error= 1;
 
1833
 
 
1834
    /*
 
1835
      TODO: There are two exceptions mechanism (THD and sp_rcontext),
 
1836
      this could be improved by having a common stack of handlers.
 
1837
    */
 
1838
    if (thd->handle_error(error, str,
 
1839
                          DRIZZLE_ERROR::WARN_LEVEL_ERROR))
 
1840
      return;;
 
1841
 
 
1842
    thd->is_slave_error=  1; // needed to catch query errors during replication
 
1843
 
 
1844
    /*
 
1845
      thd->lex->current_select == 0 if lex structure is not inited
 
1846
      (not query command (COM_QUERY))
 
1847
    */
 
1848
    if (! (thd->lex->current_select &&
 
1849
        thd->lex->current_select->no_error && !thd->is_fatal_error))
 
1850
    {
 
1851
      if (! thd->main_da.is_error())            // Return only first message
 
1852
      {
 
1853
        if (error == 0)
 
1854
          error= ER_UNKNOWN_ERROR;
 
1855
        if (str == NULL)
 
1856
          str= ER(error);
 
1857
        thd->main_da.set_error_status(thd, error, str);
 
1858
      }
 
1859
    }
 
1860
 
 
1861
    if (!thd->no_warnings_for_error && !thd->is_fatal_error)
 
1862
    {
 
1863
      /*
 
1864
        Suppress infinite recursion if there a memory allocation error
 
1865
        inside push_warning.
 
1866
      */
 
1867
      thd->no_warnings_for_error= true;
 
1868
      push_warning(thd, DRIZZLE_ERROR::WARN_LEVEL_ERROR, error, str);
 
1869
      thd->no_warnings_for_error= false;
 
1870
    }
 
1871
  }
 
1872
  if (!thd || MyFlags & ME_NOREFRESH)
 
1873
    sql_print_error("%s: %s",my_progname,str); /* purecov: inspected */
 
1874
  return;;
 
1875
}
 
1876
 
 
1877
 
 
1878
extern "C" void *my_str_malloc_mysqld(size_t size);
 
1879
extern "C" void my_str_free_mysqld(void *ptr);
 
1880
 
 
1881
void *my_str_malloc_mysqld(size_t size)
 
1882
{
 
1883
  return my_malloc(size, MYF(MY_FAE));
 
1884
}
 
1885
 
 
1886
 
 
1887
void my_str_free_mysqld(void *ptr)
 
1888
{
 
1889
  free((unsigned char*)ptr);
 
1890
}
 
1891
 
 
1892
 
 
1893
static const char *load_default_groups[]= {
 
1894
"mysqld","server", DRIZZLE_BASE_VERSION, 0, 0};
 
1895
 
 
1896
 
 
1897
/**
 
1898
  Initialize one of the global date/time format variables.
 
1899
 
 
1900
  @param format_type            What kind of format should be supported
 
1901
  @param var_ptr                Pointer to variable that should be updated
 
1902
 
 
1903
  @note
 
1904
    The default value is taken from either opt_date_time_formats[] or
 
1905
    the ISO format (ANSI SQL)
 
1906
 
 
1907
  @retval
 
1908
    0 ok
 
1909
  @retval
 
1910
    1 error
 
1911
*/
 
1912
 
 
1913
static bool init_global_datetime_format(enum enum_drizzle_timestamp_type format_type,
 
1914
                                        DATE_TIME_FORMAT **var_ptr)
 
1915
{
 
1916
  /* Get command line option */
 
1917
  const char *str= opt_date_time_formats[format_type];
 
1918
 
 
1919
  if (!str)                                     // No specified format
 
1920
  {
 
1921
    str= get_date_time_format_str(&known_date_time_formats[ISO_FORMAT],
 
1922
                                  format_type);
 
1923
    /*
 
1924
      Set the "command line" option to point to the generated string so
 
1925
      that we can set global formats back to default
 
1926
    */
 
1927
    opt_date_time_formats[format_type]= str;
 
1928
  }
 
1929
  if (!(*var_ptr= date_time_format_make(format_type, str, strlen(str))))
 
1930
  {
 
1931
    fprintf(stderr, _("Wrong date/time format specifier: %s\n"), str);
 
1932
    return 1;
 
1933
  }
 
1934
  return 0;
 
1935
}
 
1936
 
 
1937
SHOW_VAR com_status_vars[]= {
 
1938
  {"admin_commands",       (char*) offsetof(STATUS_VAR, com_other), SHOW_LONG_STATUS},
 
1939
  {"assign_to_keycache",   (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_ASSIGN_TO_KEYCACHE]), SHOW_LONG_STATUS},
 
1940
  {"alter_db",             (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_ALTER_DB]), SHOW_LONG_STATUS},
 
1941
  {"alter_table",          (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_ALTER_TABLE]), SHOW_LONG_STATUS},
 
1942
  {"analyze",              (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_ANALYZE]), SHOW_LONG_STATUS},
 
1943
  {"begin",                (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_BEGIN]), SHOW_LONG_STATUS},
 
1944
  {"binlog",               (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_BINLOG_BASE64_EVENT]), SHOW_LONG_STATUS},
 
1945
  {"change_db",            (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_CHANGE_DB]), SHOW_LONG_STATUS},
 
1946
  {"change_master",        (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_CHANGE_MASTER]), SHOW_LONG_STATUS},
 
1947
  {"check",                (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_CHECK]), SHOW_LONG_STATUS},
 
1948
  {"checksum",             (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_CHECKSUM]), SHOW_LONG_STATUS},
 
1949
  {"commit",               (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_COMMIT]), SHOW_LONG_STATUS},
 
1950
  {"create_db",            (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_CREATE_DB]), SHOW_LONG_STATUS},
 
1951
  {"create_index",         (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_CREATE_INDEX]), SHOW_LONG_STATUS},
 
1952
  {"create_table",         (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_CREATE_TABLE]), SHOW_LONG_STATUS},
 
1953
  {"delete",               (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_DELETE]), SHOW_LONG_STATUS},
 
1954
  {"delete_multi",         (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_DELETE_MULTI]), SHOW_LONG_STATUS},
 
1955
  {"drop_db",              (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_DROP_DB]), SHOW_LONG_STATUS},
 
1956
  {"drop_index",           (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_DROP_INDEX]), SHOW_LONG_STATUS},
 
1957
  {"drop_table",           (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_DROP_TABLE]), SHOW_LONG_STATUS},
 
1958
  {"empty_query",          (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_EMPTY_QUERY]), SHOW_LONG_STATUS},
 
1959
  {"flush",                (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_FLUSH]), SHOW_LONG_STATUS},
 
1960
  {"insert",               (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_INSERT]), SHOW_LONG_STATUS},
 
1961
  {"insert_select",        (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_INSERT_SELECT]), SHOW_LONG_STATUS},
 
1962
  {"kill",                 (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_KILL]), SHOW_LONG_STATUS},
 
1963
  {"load",                 (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_LOAD]), SHOW_LONG_STATUS},
 
1964
  {"lock_tables",          (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_LOCK_TABLES]), SHOW_LONG_STATUS},
 
1965
  {"optimize",             (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_OPTIMIZE]), SHOW_LONG_STATUS},
 
1966
  {"purge",                (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_PURGE]), SHOW_LONG_STATUS},
 
1967
  {"purge_before_date",    (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_PURGE_BEFORE]), SHOW_LONG_STATUS},
 
1968
  {"release_savepoint",    (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_RELEASE_SAVEPOINT]), SHOW_LONG_STATUS},
 
1969
  {"rename_table",         (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_RENAME_TABLE]), SHOW_LONG_STATUS},
 
1970
  {"repair",               (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_REPAIR]), SHOW_LONG_STATUS},
 
1971
  {"replace",              (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_REPLACE]), SHOW_LONG_STATUS},
 
1972
  {"replace_select",       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_REPLACE_SELECT]), SHOW_LONG_STATUS},
 
1973
  {"reset",                (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_RESET]), SHOW_LONG_STATUS},
 
1974
  {"rollback",             (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_ROLLBACK]), SHOW_LONG_STATUS},
 
1975
  {"rollback_to_savepoint",(char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_ROLLBACK_TO_SAVEPOINT]), SHOW_LONG_STATUS},
 
1976
  {"savepoint",            (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SAVEPOINT]), SHOW_LONG_STATUS},
 
1977
  {"select",               (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SELECT]), SHOW_LONG_STATUS},
 
1978
  {"set_option",           (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SET_OPTION]), SHOW_LONG_STATUS},
 
1979
  {"show_binlogs",         (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_BINLOGS]), SHOW_LONG_STATUS},
 
1980
  {"show_create_db",       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_CREATE_DB]), SHOW_LONG_STATUS},
 
1981
  {"show_create_table",    (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_CREATE]), SHOW_LONG_STATUS},
 
1982
  {"show_databases",       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_DATABASES]), SHOW_LONG_STATUS},
 
1983
  {"show_engine_status",   (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_ENGINE_STATUS]), SHOW_LONG_STATUS},
 
1984
  {"show_errors",          (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_ERRORS]), SHOW_LONG_STATUS},
 
1985
  {"show_fields",          (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_FIELDS]), SHOW_LONG_STATUS},
 
1986
  {"show_keys",            (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_KEYS]), SHOW_LONG_STATUS},
 
1987
  {"show_master_status",   (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_MASTER_STAT]), SHOW_LONG_STATUS},
 
1988
  {"show_open_tables",     (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_OPEN_TABLES]), SHOW_LONG_STATUS},
 
1989
  {"show_plugins",         (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_PLUGINS]), SHOW_LONG_STATUS},
 
1990
  {"show_processlist",     (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_PROCESSLIST]), SHOW_LONG_STATUS},
 
1991
  {"show_slave_status",    (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_SLAVE_STAT]), SHOW_LONG_STATUS},
 
1992
  {"show_status",          (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_STATUS]), SHOW_LONG_STATUS},
 
1993
  {"show_table_status",    (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_TABLE_STATUS]), SHOW_LONG_STATUS},
 
1994
  {"show_tables",          (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_TABLES]), SHOW_LONG_STATUS},
 
1995
  {"show_variables",       (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_VARIABLES]), SHOW_LONG_STATUS},
 
1996
  {"show_warnings",        (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SHOW_WARNS]), SHOW_LONG_STATUS},
 
1997
  {"slave_start",          (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SLAVE_START]), SHOW_LONG_STATUS},
 
1998
  {"slave_stop",           (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_SLAVE_STOP]), SHOW_LONG_STATUS},
 
1999
  {"truncate",             (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_TRUNCATE]), SHOW_LONG_STATUS},
 
2000
  {"unlock_tables",        (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_UNLOCK_TABLES]), SHOW_LONG_STATUS},
 
2001
  {"update",               (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_UPDATE]), SHOW_LONG_STATUS},
 
2002
  {"update_multi",         (char*) offsetof(STATUS_VAR, com_stat[(uint) SQLCOM_UPDATE_MULTI]), SHOW_LONG_STATUS},
 
2003
  {NULL, NULL, SHOW_LONG}
675
2004
};
676
2005
 
677
 
static void check_limits_aii(uint64_t in_auto_increment_increment)
678
 
{
679
 
  global_system_variables.auto_increment_increment= 1;
680
 
  if (in_auto_increment_increment < 1 || in_auto_increment_increment > UINT64_MAX)
681
 
  {
682
 
    cout << N_("Error: Invalid Value for auto_increment_increment");
683
 
    exit(-1);
684
 
  }
685
 
  global_system_variables.auto_increment_increment= in_auto_increment_increment;
686
 
}
687
 
 
688
 
static void check_limits_aio(uint64_t in_auto_increment_offset)
689
 
{
690
 
  global_system_variables.auto_increment_offset= 1;
691
 
  if (in_auto_increment_offset < 1 || in_auto_increment_offset > UINT64_MAX)
692
 
  {
693
 
    cout << N_("Error: Invalid Value for auto_increment_offset");
694
 
    exit(-1);
695
 
  }
696
 
  global_system_variables.auto_increment_offset= in_auto_increment_offset;
697
 
}
698
 
 
699
 
static void check_limits_completion_type(uint32_t in_completion_type)
700
 
{
701
 
  global_system_variables.completion_type= 0;
702
 
  if (in_completion_type > 2)
703
 
  {
704
 
    cout << N_("Error: Invalid Value for completion_type");
705
 
    exit(-1);
706
 
  }
707
 
  global_system_variables.completion_type= in_completion_type;
708
 
}
709
 
 
710
 
static void check_limits_back_log(uint32_t in_back_log)
711
 
{
712
 
  back_log= 50;
713
 
  if (in_back_log < 1 || in_back_log > 65535)
714
 
  {
715
 
    cout << N_("Error: Invalid Value for back_log");
716
 
    exit(-1);
717
 
  }
718
 
  back_log= in_back_log;
719
 
}
720
 
 
721
 
static void check_limits_dpi(uint32_t in_div_precincrement)
722
 
{
723
 
  global_system_variables.div_precincrement= 4;
724
 
  if (in_div_precincrement > DECIMAL_MAX_SCALE)
725
 
  {
726
 
    cout << N_("Error: Invalid Value for div-precision-increment");
727
 
    exit(-1);
728
 
  }
729
 
  global_system_variables.div_precincrement= in_div_precincrement;
730
 
}
731
 
 
732
 
static void check_limits_gcml(uint64_t in_group_concat_max_len)
733
 
{
734
 
  global_system_variables.group_concat_max_len= 1024;
735
 
  if (in_group_concat_max_len > ULONG_MAX || in_group_concat_max_len < 4)
736
 
  {
737
 
    cout << N_("Error: Invalid Value for group_concat_max_len");
738
 
    exit(-1);
739
 
  }
740
 
  global_system_variables.group_concat_max_len= in_group_concat_max_len;
741
 
}
742
 
 
743
 
static void check_limits_join_buffer_size(uint64_t in_join_buffer_size)
744
 
{
745
 
  global_system_variables.join_buff_size= (128*1024L);
746
 
  if (in_join_buffer_size < IO_SIZE*2 || in_join_buffer_size > ULONG_MAX)
747
 
  {
748
 
    cout << N_("Error: Invalid Value for join_buffer_size");
749
 
    exit(-1);
750
 
  }
751
 
  in_join_buffer_size-= in_join_buffer_size % IO_SIZE;
752
 
  global_system_variables.join_buff_size= in_join_buffer_size;
753
 
}
754
 
 
755
 
static void check_limits_map(uint32_t in_max_allowed_packet)
756
 
{
757
 
  global_system_variables.max_allowed_packet= (1024*1024L);
758
 
  if (in_max_allowed_packet < 1024 || in_max_allowed_packet > 1024*1024L*1024L)
759
 
  {
760
 
    cout << N_("Error: Invalid Value for max_allowed_packet");
761
 
    exit(-1);
762
 
  }
763
 
  in_max_allowed_packet-= in_max_allowed_packet % 1024;
764
 
  global_system_variables.max_allowed_packet= in_max_allowed_packet;
765
 
}
766
 
 
767
 
static void check_limits_mce(uint64_t in_max_connect_errors)
768
 
{
769
 
  max_connect_errors= MAX_CONNECT_ERRORS;
770
 
  if (in_max_connect_errors < 1 || in_max_connect_errors > ULONG_MAX)
771
 
  {
772
 
    cout << N_("Error: Invalid Value for max_connect_errors");
773
 
    exit(-1);
774
 
  }
775
 
  max_connect_errors= in_max_connect_errors;
776
 
}
777
 
 
778
 
static void check_limits_max_err_cnt(uint64_t in_max_error_count)
779
 
{
780
 
  global_system_variables.max_error_count= DEFAULT_ERROR_COUNT;
781
 
  if (in_max_error_count > 65535)
782
 
  {
783
 
    cout << N_("Error: Invalid Value for max_error_count");
784
 
    exit(-1);
785
 
  }
786
 
  global_system_variables.max_error_count= in_max_error_count;
787
 
}
788
 
 
789
 
static void check_limits_mhts(uint64_t in_max_heap_table_size)
790
 
{
791
 
  global_system_variables.max_heap_table_size= (16*1024*1024L);
792
 
  if (in_max_heap_table_size < 16384 || in_max_heap_table_size > MAX_MEM_TABLE_SIZE)
793
 
  {
794
 
    cout << N_("Error: Invalid Value for max_heap_table_size");
795
 
    exit(-1);
796
 
  }
797
 
  in_max_heap_table_size-= in_max_heap_table_size % 1024;
798
 
  global_system_variables.max_heap_table_size= in_max_heap_table_size;
799
 
}
800
 
 
801
 
static void check_limits_merl(uint64_t in_min_examined_row_limit)
802
 
{
803
 
  global_system_variables.min_examined_row_limit= 0;
804
 
  if (in_min_examined_row_limit > ULONG_MAX)
805
 
  {
806
 
    cout << N_("Error: Invalid Value for min_examined_row_limit");
807
 
    exit(-1);
808
 
  }
809
 
  global_system_variables.min_examined_row_limit= in_min_examined_row_limit;
810
 
}
811
 
 
812
 
static void check_limits_max_join_size(drizzled::ha_rows in_max_join_size)
813
 
{
814
 
  global_system_variables.max_join_size= INT32_MAX;
815
 
  if ((uint64_t)in_max_join_size < 1 || (uint64_t)in_max_join_size > INT32_MAX)
816
 
  {
817
 
    cout << N_("Error: Invalid Value for max_join_size");
818
 
    exit(-1);
819
 
  }
820
 
  global_system_variables.max_join_size= in_max_join_size;
821
 
}
822
 
 
823
 
static void check_limits_mlfsd(int64_t in_max_length_for_sort_data)
824
 
{
825
 
  global_system_variables.max_length_for_sort_data= 1024;
826
 
  if (in_max_length_for_sort_data < 4 || in_max_length_for_sort_data > 8192*1024L)
827
 
  {
828
 
    cout << N_("Error: Invalid Value for max_length_for_sort_data");
829
 
    exit(-1);
830
 
  }
831
 
  global_system_variables.max_length_for_sort_data= in_max_length_for_sort_data;
832
 
}
833
 
 
834
 
static void check_limits_msfk(uint64_t in_max_seeks_for_key)
835
 
{
836
 
  global_system_variables.max_seeks_for_key= ULONG_MAX;
837
 
  if (in_max_seeks_for_key < 1 || in_max_seeks_for_key > ULONG_MAX)
838
 
  {
839
 
    cout << N_("Error: Invalid Value for max_seeks_for_key");
840
 
    exit(-1);
841
 
  }
842
 
  global_system_variables.max_seeks_for_key= in_max_seeks_for_key;
843
 
}
844
 
 
845
 
static void check_limits_max_sort_length(size_t in_max_sort_length)
846
 
{
847
 
  global_system_variables.max_sort_length= 1024;
848
 
  if ((int64_t)in_max_sort_length < 4 || (int64_t)in_max_sort_length > 8192*1024L)
849
 
  {
850
 
    cout << N_("Error: Invalid Value for max_sort_length");
851
 
    exit(-1);
852
 
  }
853
 
  global_system_variables.max_sort_length= in_max_sort_length;
854
 
}
855
 
 
856
 
static void check_limits_mwlc(uint64_t in_min_examined_row_limit)
857
 
{
858
 
  global_system_variables.min_examined_row_limit= ULONG_MAX;
859
 
  if (in_min_examined_row_limit > ULONG_MAX)
860
 
  {
861
 
    cout << N_("Error: Invalid Value for min_examined_row_limit");
862
 
    exit(-1);
863
 
  }
864
 
  global_system_variables.min_examined_row_limit= in_min_examined_row_limit;
865
 
}
866
 
 
867
 
static void check_limits_osd(uint32_t in_optimizer_search_depth)
868
 
{
869
 
  global_system_variables.optimizer_search_depth= 0;
870
 
  if (in_optimizer_search_depth > MAX_TABLES + 2)
871
 
  {
872
 
    cout << N_("Error: Invalid Value for optimizer_search_depth");
873
 
    exit(-1);
874
 
  }
875
 
  global_system_variables.optimizer_search_depth= in_optimizer_search_depth;
876
 
}
877
 
 
878
 
static void check_limits_pbs(uint64_t in_preload_buff_size)
879
 
{
880
 
  global_system_variables.preload_buff_size= (32*1024L);
881
 
  if (in_preload_buff_size < 1024 || in_preload_buff_size > 1024*1024*1024L)
882
 
  {
883
 
    cout << N_("Error: Invalid Value for preload_buff_size");
884
 
    exit(-1);
885
 
  }
886
 
  global_system_variables.preload_buff_size= in_preload_buff_size;
887
 
}
888
 
 
889
 
static void check_limits_qabs(uint32_t in_query_alloc_block_size)
890
 
{
891
 
  global_system_variables.query_alloc_block_size= QUERY_ALLOC_BLOCK_SIZE;
892
 
  if (in_query_alloc_block_size < 1024)
893
 
  {
894
 
    cout << N_("Error: Invalid Value for query_alloc_block_size");
895
 
    exit(-1);
896
 
  }
897
 
  in_query_alloc_block_size-= in_query_alloc_block_size % 1024;
898
 
  global_system_variables.query_alloc_block_size= in_query_alloc_block_size;
899
 
}
900
 
 
901
 
static void check_limits_qps(uint32_t in_query_prealloc_size)
902
 
{
903
 
  global_system_variables.query_prealloc_size= QUERY_ALLOC_PREALLOC_SIZE;
904
 
  if (in_query_prealloc_size < QUERY_ALLOC_PREALLOC_SIZE)
905
 
  {
906
 
    cout << N_("Error: Invalid Value for query_prealloc_size");
907
 
    exit(-1);
908
 
  }
909
 
  in_query_prealloc_size-= in_query_prealloc_size % 1024;
910
 
  global_system_variables.query_prealloc_size= in_query_prealloc_size;
911
 
}
912
 
 
913
 
static void check_limits_rabs(size_t in_range_alloc_block_size)
914
 
{
915
 
  global_system_variables.range_alloc_block_size= RANGE_ALLOC_BLOCK_SIZE;
916
 
  if (in_range_alloc_block_size < RANGE_ALLOC_BLOCK_SIZE)
917
 
  {
918
 
    cout << N_("Error: Invalid Value for range_alloc_block_size");
919
 
    exit(-1);
920
 
  }
921
 
  in_range_alloc_block_size-= in_range_alloc_block_size % 1024;
922
 
  global_system_variables.range_alloc_block_size= in_range_alloc_block_size;
923
 
}
924
 
 
925
 
static void check_limits_read_buffer_size(int32_t in_read_buff_size)
926
 
{
927
 
  global_system_variables.read_buff_size= (128*1024L);
928
 
  if (in_read_buff_size < IO_SIZE*2 || in_read_buff_size > INT32_MAX)
929
 
  {
930
 
    cout << N_("Error: Invalid Value for read_buff_size");
931
 
    exit(-1);
932
 
  }
933
 
  in_read_buff_size-= in_read_buff_size % IO_SIZE;
934
 
  global_system_variables.read_buff_size= in_read_buff_size;
935
 
}
936
 
 
937
 
static void check_limits_read_rnd_buffer_size(uint32_t in_read_rnd_buff_size)
938
 
{
939
 
  global_system_variables.read_rnd_buff_size= (256*1024L);
940
 
  if (in_read_rnd_buff_size < 64 || in_read_rnd_buff_size > UINT32_MAX)
941
 
  {
942
 
    cout << N_("Error: Invalid Value for read_rnd_buff_size");
943
 
    exit(-1);
944
 
  }
945
 
  global_system_variables.read_rnd_buff_size= in_read_rnd_buff_size;
946
 
}
947
 
 
948
 
static void check_limits_sort_buffer_size(size_t in_sortbuff_size)
949
 
{
950
 
  global_system_variables.sortbuff_size= MAX_SORT_MEMORY;
951
 
  if ((uint32_t)in_sortbuff_size < MIN_SORT_MEMORY)
952
 
  {
953
 
    cout << N_("Error: Invalid Value for sort_buff_size");
954
 
    exit(-1);
955
 
  }
956
 
  global_system_variables.sortbuff_size= in_sortbuff_size;
957
 
}
958
 
 
959
 
static void check_limits_tdc(uint32_t in_table_def_size)
960
 
{
961
 
  table_def_size= 128;
962
 
  if (in_table_def_size < 1 || in_table_def_size > 512*1024L)
963
 
  {
964
 
    cout << N_("Error: Invalid Value for table_def_size");
965
 
    exit(-1);
966
 
  }
967
 
  table_def_size= in_table_def_size;
968
 
}
969
 
 
970
 
static void check_limits_toc(uint32_t in_table_cache_size)
971
 
{
972
 
  table_cache_size= TABLE_OPEN_CACHE_DEFAULT;
973
 
  if (in_table_cache_size < TABLE_OPEN_CACHE_MIN || in_table_cache_size > 512*1024L)
974
 
  {
975
 
    cout << N_("Error: Invalid Value for table_cache_size");
976
 
    exit(-1);
977
 
  }
978
 
  table_cache_size= in_table_cache_size;
979
 
}
980
 
 
981
 
static void check_limits_tlwt(uint64_t in_table_lock_wait_timeout)
982
 
{
983
 
  table_lock_wait_timeout= 50;
984
 
  if (in_table_lock_wait_timeout < 1 || in_table_lock_wait_timeout > 1024*1024*1024)
985
 
  {
986
 
    cout << N_("Error: Invalid Value for table_lock_wait_timeout");
987
 
    exit(-1);
988
 
  }
989
 
  table_lock_wait_timeout= in_table_lock_wait_timeout;
990
 
}
991
 
 
992
 
static void check_limits_thread_stack(uint32_t in_my_thread_stack_size)
993
 
{
994
 
  my_thread_stack_size= in_my_thread_stack_size - (in_my_thread_stack_size % 1024);
995
 
}
996
 
 
997
 
static void check_limits_tmp_table_size(uint64_t in_tmp_table_size)
998
 
{
999
 
  global_system_variables.tmp_table_size= 16*1024*1024L;
1000
 
  if (in_tmp_table_size < 1024 || in_tmp_table_size > MAX_MEM_TABLE_SIZE)
1001
 
  {
1002
 
    cout << N_("Error: Invalid Value for table_lock_wait_timeout");
1003
 
    exit(-1);
1004
 
  }
1005
 
  global_system_variables.tmp_table_size= in_tmp_table_size;
1006
 
}
1007
 
 
1008
 
static pair<string, string> parse_size_suffixes(string s)
1009
 
{
1010
 
  size_t equal_pos= s.find("=");
1011
 
  if (equal_pos != string::npos)
1012
 
  {
1013
 
    string arg_key(s.substr(0, equal_pos));
1014
 
    string arg_val(s.substr(equal_pos+1));
1015
 
 
1016
 
    try
1017
 
    {
1018
 
      size_t size_suffix_pos= arg_val.find_last_of("kmgKMG");
1019
 
      if (size_suffix_pos == arg_val.size()-1)
1020
 
      {
1021
 
        char suffix= arg_val[size_suffix_pos];
1022
 
        string size_val(arg_val.substr(0, size_suffix_pos));
1023
 
 
1024
 
        uint64_t base_size= boost::lexical_cast<uint64_t>(size_val);
1025
 
        uint64_t new_size= 0;
1026
 
 
1027
 
        switch (suffix)
1028
 
        {
1029
 
        case 'K':
1030
 
        case 'k':
1031
 
          new_size= base_size * 1024;
1032
 
          break;
1033
 
        case 'M':
1034
 
        case 'm':
1035
 
          new_size= base_size * 1024 * 1024;
1036
 
          break;
1037
 
        case 'G':
1038
 
        case 'g':
1039
 
          new_size= base_size * 1024 * 1024 * 1024;
1040
 
          break;
1041
 
        }
1042
 
        return make_pair(arg_key,
1043
 
                         boost::lexical_cast<string>(new_size));
1044
 
      }
1045
 
    }
1046
 
    catch (...)
1047
 
    {
1048
 
      /* Screw it, let the normal parser take over */
1049
 
    }
1050
 
  }
1051
 
 
1052
 
  return make_pair(string(""), string(""));
1053
 
}
1054
 
 
1055
 
static pair<string, string> parse_size_arg(string s)
1056
 
{
1057
 
  if (s.find("--") == 0)
1058
 
  {
1059
 
    return parse_size_suffixes(s.substr(2));
1060
 
  }
1061
 
  return make_pair(string(""), string(""));
1062
 
}
1063
 
 
1064
 
static void process_defaults_files()
1065
 
{
1066
 
  for (vector<string>::iterator iter= defaults_file_list.begin();
1067
 
       iter != defaults_file_list.end();
1068
 
       ++iter)
1069
 
  {
1070
 
    string file_location(vm["config-dir"].as<string>());
1071
 
    if ((*iter)[0] != '/')
1072
 
    {
1073
 
      /* Relative path - add config dir */
1074
 
      file_location.push_back('/');
1075
 
      file_location.append(*iter);
1076
 
    }
1077
 
    else
1078
 
    {
1079
 
      file_location= *iter;
1080
 
    }
1081
 
 
1082
 
    ifstream input_defaults_file(file_location.c_str());
1083
 
    
1084
 
    po::parsed_options file_parsed=
1085
 
      po::parse_config_file(input_defaults_file, long_options, true);
1086
 
    vector<string> file_unknown= 
1087
 
      po::collect_unrecognized(file_parsed.options, po::include_positional);
1088
 
 
1089
 
    for (vector<string>::iterator it= file_unknown.begin();
1090
 
         it != file_unknown.end();
1091
 
         ++it)
1092
 
    {
1093
 
      string new_unknown_opt("--");
1094
 
      new_unknown_opt.append(*it);
1095
 
      ++it;
1096
 
      if (it != file_unknown.end())
1097
 
      {
1098
 
        if ((*it) != "true")
1099
 
        {
1100
 
          new_unknown_opt.push_back('=');
1101
 
          new_unknown_opt.append(*it);
1102
 
        }
1103
 
      }
1104
 
      else
1105
 
      {
1106
 
        break;
1107
 
      }
1108
 
      unknown_options.push_back(new_unknown_opt);
1109
 
    }
1110
 
    store(file_parsed, vm);
1111
 
  }
1112
 
}
1113
 
 
1114
 
static void compose_defaults_file_list(vector<string> in_options)
1115
 
{
1116
 
  for (vector<string>::iterator it= in_options.begin();
1117
 
       it != in_options.end();
1118
 
       ++it)
1119
 
  {
1120
 
    defaults_file_list.push_back(*it);
1121
 
  }
1122
 
}
1123
 
 
1124
 
int init_common_variables(int argc, char **argv)
1125
 
{
1126
 
  time_t curr_time;
1127
 
  umask(((~internal::my_umask) & 0666));
 
2006
static int init_common_variables(const char *conf_file_name, int argc,
 
2007
                                 char **argv, const char **groups)
 
2008
{
 
2009
  umask(((~my_umask) & 0666));
1128
2010
  my_decimal_set_zero(&decimal_zero); // set decimal_zero constant;
1129
2011
  tzset();                      // Set tzname
1130
2012
 
1131
 
  curr_time= time(NULL);
1132
 
  if (curr_time == (time_t)-1)
1133
 
    return 1;
1134
 
 
1135
2013
  max_system_variables.pseudo_thread_id= UINT32_MAX;
1136
 
  server_start_time= flush_status_time= curr_time;
1137
 
 
1138
 
  drizzle_init_variables();
1139
 
 
 
2014
  server_start_time= flush_status_time= my_time(0);
 
2015
  rpl_filter= new Rpl_filter;
 
2016
  binlog_filter= new Rpl_filter;
 
2017
  if (!rpl_filter || !binlog_filter)
 
2018
  {
 
2019
    sql_perror("Could not allocate replication and binlog filters");
 
2020
    exit(1);
 
2021
  }
 
2022
 
 
2023
  if (init_thread_environment())
 
2024
    return 1;
 
2025
  mysql_init_variables();
 
2026
 
 
2027
#ifdef HAVE_TZNAME
1140
2028
  {
1141
2029
    struct tm tm_tmp;
1142
2030
    localtime_r(&server_start_time,&tm_tmp);
1143
 
    strncpy(system_time_zone, tzname[tm_tmp.tm_isdst != 0 ? 1 : 0],
 
2031
    strmake(system_time_zone, tzname[tm_tmp.tm_isdst != 0 ? 1 : 0],
1144
2032
            sizeof(system_time_zone)-1);
1145
2033
 
1146
 
  }
 
2034
 }
 
2035
#endif
1147
2036
  /*
1148
2037
    We set SYSTEM time zone as reasonable default and
1149
2038
    also for failure of my_tz_init() and bootstrap mode.
1152
2041
  */
1153
2042
  global_system_variables.time_zone= my_tz_SYSTEM;
1154
2043
 
 
2044
  /*
 
2045
    Init mutexes for the global DRIZZLE_BIN_LOG objects.
 
2046
    As safe_mutex depends on what MY_INIT() does, we can't init the mutexes of
 
2047
    global DRIZZLE_BIN_LOGs in their constructors, because then they would be
 
2048
    inited before MY_INIT(). So we do it here.
 
2049
  */
 
2050
  mysql_bin_log.init_pthread_objects();
 
2051
 
1155
2052
  if (gethostname(glob_hostname,sizeof(glob_hostname)) < 0)
1156
2053
  {
1157
 
    strncpy(glob_hostname, STRING_WITH_LEN("localhost"));
1158
 
    errmsg_printf(ERRMSG_LVL_WARN, _("gethostname failed, using '%s' as hostname"),
1159
 
                  glob_hostname);
1160
 
    strncpy(pidfile_name, STRING_WITH_LEN("drizzle"));
 
2054
    strmake(glob_hostname, STRING_WITH_LEN("localhost"));
 
2055
    sql_print_warning(_("gethostname failed, using '%s' as hostname"),
 
2056
                      glob_hostname);
 
2057
    strmake(pidfile_name, STRING_WITH_LEN("mysql"));
1161
2058
  }
1162
2059
  else
1163
 
    strncpy(pidfile_name, glob_hostname, sizeof(pidfile_name)-5);
1164
 
  strcpy(internal::fn_ext(pidfile_name),".pid");                // Add proper extension
1165
 
 
1166
 
  std::string system_config_dir_drizzle(SYSCONFDIR);
1167
 
  system_config_dir_drizzle.append("/drizzle");
1168
 
 
1169
 
  std::string system_config_file_drizzle("drizzled.cnf");
1170
 
 
1171
 
  long_options.add_options()
1172
 
  ("help-extended", po::value<bool>(&opt_help_extended)->default_value(false)->zero_tokens(),
1173
 
  N_("Display this help and exit after initializing plugins."))
1174
 
  ("help,?", po::value<bool>(&opt_help)->default_value(false)->zero_tokens(),
1175
 
  N_("Display this help and exit."))
1176
 
  ("auto-increment-increment", po::value<uint64_t>(&global_system_variables.auto_increment_increment)->default_value(1)->notifier(&check_limits_aii),
1177
 
  N_("Auto-increment columns are incremented by this"))
1178
 
  ("auto-increment-offset", po::value<uint64_t>(&global_system_variables.auto_increment_offset)->default_value(1)->notifier(&check_limits_aio),
1179
 
  N_("Offset added to Auto-increment columns. Used when auto-increment-increment != 1"))
1180
 
  ("basedir,b", po::value<string>(),
1181
 
  N_("Path to installation directory. All paths are usually resolved "
1182
 
     "relative to this."))
1183
 
  ("chroot,r", po::value<string>(),
1184
 
  N_("Chroot drizzled daemon during startup."))
1185
 
  ("collation-server", po::value<string>(),
1186
 
  N_("Set the default collation."))      
1187
 
  ("completion-type", po::value<uint32_t>(&global_system_variables.completion_type)->default_value(0)->notifier(&check_limits_completion_type),
1188
 
  N_("Default completion type."))
1189
 
  ("core-file",  N_("Write core on errors."))
1190
 
  ("datadir", po::value<string>(),
1191
 
  N_("Path to the database root."))
1192
 
  ("default-storage-engine", po::value<string>(),
1193
 
  N_("Set the default storage engine (table type) for tables."))
1194
 
  ("default-time-zone", po::value<string>(),
1195
 
  N_("Set the default time zone."))
1196
 
  ("exit-info,T", po::value<long>(),
1197
 
  N_("Used for debugging;  Use at your own risk!"))
1198
 
  ("gdb", po::value<bool>(&opt_debugging)->default_value(false)->zero_tokens(),
1199
 
  N_("Set up signals usable for debugging"))
1200
 
  ("language,L", po::value<string>(),
1201
 
  N_("(IGNORED)"))  
1202
 
  ("lc-time-name", po::value<string>(),
1203
 
  N_("Set the language used for the month names and the days of the week."))
1204
 
  ("log-warnings,W", po::value<string>(),
1205
 
  N_("Log some not critical warnings to the log file."))  
1206
 
  ("pid-file", po::value<string>(),
1207
 
  N_("Pid file used by drizzled."))
1208
 
  ("port-open-timeout", po::value<uint32_t>(&drizzled_bind_timeout)->default_value(0),
1209
 
  N_("Maximum time in seconds to wait for the port to become free. "
1210
 
     "(Default: no wait)"))
1211
 
  ("secure-file-priv", po::value<string>(),
1212
 
  N_("Limit LOAD DATA, SELECT ... OUTFILE, and LOAD_FILE() to files "
1213
 
     "within specified directory"))
1214
 
  ("server-id", po::value<uint32_t>(&server_id)->default_value(0),
1215
 
  N_("Uniquely identifies the server instance in the community of "
1216
 
     "replication partners."))
1217
 
  ("skip-stack-trace",  
1218
 
  N_("Don't print a stack trace on failure."))
1219
 
  ("symbolic-links,s", po::value<bool>(&internal::my_use_symdir)->default_value(IF_PURIFY(false,true))->zero_tokens(),
1220
 
  N_("Enable symbolic link support."))
1221
 
  ("timed-mutexes", po::value<bool>(&internal::timed_mutexes)->default_value(false)->zero_tokens(),
1222
 
  N_("Specify whether to time mutexes (only InnoDB mutexes are currently "
1223
 
     "supported)")) 
1224
 
  ("tmpdir,t", po::value<string>(),
1225
 
  N_("Path for temporary files."))
1226
 
  ("transaction-isolation", po::value<string>(),
1227
 
  N_("Default transaction isolation level."))
1228
 
  ("user,u", po::value<string>(),
1229
 
  N_("Run drizzled daemon as user."))  
1230
 
  ("version,V", 
1231
 
  N_("Output version information and exit."))
1232
 
  ("back-log", po::value<uint32_t>(&back_log)->default_value(50)->notifier(&check_limits_back_log),
1233
 
  N_("The number of outstanding connection requests Drizzle can have. This "
1234
 
     "comes into play when the main Drizzle thread gets very many connection "
1235
 
     "requests in a very short time."))
1236
 
  ("bulk-insert-buffer-size", 
1237
 
  po::value<uint64_t>(&global_system_variables.bulk_insert_buff_size)->default_value(8192*1024),
1238
 
  N_("Size of tree cache used in bulk insert optimization. Note that this is "
1239
 
     "a limit per thread!"))
1240
 
  ("div-precision-increment",  po::value<uint32_t>(&global_system_variables.div_precincrement)->default_value(4)->notifier(&check_limits_dpi),
1241
 
  N_("Precision of the result of '/' operator will be increased on that "
1242
 
     "value."))
1243
 
  ("group-concat-max-len", po::value<uint64_t>(&global_system_variables.group_concat_max_len)->default_value(1024)->notifier(&check_limits_gcml),
1244
 
  N_("The maximum length of the result of function  group_concat."))
1245
 
  ("join-buffer-size", po::value<uint64_t>(&global_system_variables.join_buff_size)->default_value(128*1024L)->notifier(&check_limits_join_buffer_size),
1246
 
  N_("The size of the buffer that is used for full joins."))
1247
 
  ("max-allowed-packet", po::value<uint32_t>(&global_system_variables.max_allowed_packet)->default_value(1024*1024L)->notifier(&check_limits_map),
1248
 
  N_("Max packetlength to send/receive from to server."))
1249
 
  ("max-connect-errors", po::value<uint64_t>(&max_connect_errors)->default_value(MAX_CONNECT_ERRORS)->notifier(&check_limits_mce),
1250
 
  N_("If there is more than this number of interrupted connections from a "
1251
 
     "host this host will be blocked from further connections."))
1252
 
  ("max-error-count", po::value<uint64_t>(&global_system_variables.max_error_count)->default_value(DEFAULT_ERROR_COUNT)->notifier(&check_limits_max_err_cnt),
1253
 
  N_("Max number of errors/warnings to store for a statement."))
1254
 
  ("max-heap-table-size", po::value<uint64_t>(&global_system_variables.max_heap_table_size)->default_value(16*1024*1024L)->notifier(&check_limits_mhts),
1255
 
  N_("Don't allow creation of heap tables bigger than this."))
1256
 
  ("max-join-size", po::value<drizzled::ha_rows>(&global_system_variables.max_join_size)->default_value(INT32_MAX)->notifier(&check_limits_max_join_size),
1257
 
  N_("Joins that are probably going to read more than max_join_size records "
1258
 
     "return an error."))
1259
 
  ("max-length-for-sort-data", po::value<uint64_t>(&global_system_variables.max_length_for_sort_data)->default_value(1024)->notifier(&check_limits_mlfsd),
1260
 
  N_("Max number of bytes in sorted records."))
1261
 
  ("max-seeks-for-key", po::value<uint64_t>(&global_system_variables.max_seeks_for_key)->default_value(ULONG_MAX)->notifier(&check_limits_msfk),
1262
 
  N_("Limit assumed max number of seeks when looking up rows based on a key"))
1263
 
  ("max-sort-length", po::value<size_t>(&global_system_variables.max_sort_length)->default_value(1024)->notifier(&check_limits_max_sort_length),  
1264
 
  N_("The number of bytes to use when sorting BLOB or TEXT values "
1265
 
     "(only the first max_sort_length bytes of each value are used; the "
1266
 
     "rest are ignored)."))
1267
 
  ("max-write-lock-count", po::value<uint64_t>(&max_write_lock_count)->default_value(ULONG_MAX)->notifier(&check_limits_mwlc),
1268
 
  N_("After this many write locks, allow some read locks to run in between."))
1269
 
  ("min-examined-row-limit", po::value<uint64_t>(&global_system_variables.min_examined_row_limit)->default_value(0)->notifier(&check_limits_merl),
1270
 
  N_("Don't log queries which examine less than min_examined_row_limit "
1271
 
     "rows to file."))
1272
 
  ("disable-optimizer-prune",
1273
 
  N_("Do not apply any heuristic(s) during query optimization to prune, "
1274
 
     "thus perform an exhaustive search from the optimizer search space."))
1275
 
  ("optimizer-search-depth", po::value<uint32_t>(&global_system_variables.optimizer_search_depth)->default_value(0)->notifier(&check_limits_osd),
1276
 
  N_("Maximum depth of search performed by the query optimizer. Values "
1277
 
     "larger than the number of relations in a query result in better query "
1278
 
     "plans, but take longer to compile a query. Smaller values than the "
1279
 
     "number of tables in a relation result in faster optimization, but may "
1280
 
     "produce very bad query plans. If set to 0, the system will "
1281
 
     "automatically pick a reasonable value; if set to MAX_TABLES+2, the "
1282
 
     "optimizer will switch to the original find_best (used for "
1283
 
     "testing/comparison)."))
1284
 
  ("plugin-dir", po::value<string>(),
1285
 
  N_("Directory for plugins."))
1286
 
  ("plugin-add", po::value<vector<string> >()->composing()->notifier(&compose_plugin_add),
1287
 
  N_("Optional comma separated list of plugins to load at startup in addition "
1288
 
     "to the default list of plugins. "
1289
 
     "[for example: --plugin_add=crc32,logger_gearman]"))    
1290
 
  ("plugin-remove", po::value<vector<string> >()->composing()->notifier(&compose_plugin_remove),
1291
 
  N_("Optional comma separated list of plugins to not load at startup. Effectively "
1292
 
     "removes a plugin from the list of plugins to be loaded. "
1293
 
     "[for example: --plugin_remove=crc32,logger_gearman]"))
1294
 
  ("plugin-load", po::value<string>()->notifier(&notify_plugin_load)->default_value(PANDORA_PLUGIN_LIST),
1295
 
  N_("Optional comma separated list of plugins to load at starup instead of "
1296
 
     "the default plugin load list. "
1297
 
     "[for example: --plugin_load=crc32,logger_gearman]"))  
1298
 
  ("preload-buffer-size", po::value<uint64_t>(&global_system_variables.preload_buff_size)->default_value(32*1024L)->notifier(&check_limits_pbs),
1299
 
  N_("The size of the buffer that is allocated when preloading indexes"))
1300
 
  ("query-alloc-block-size", 
1301
 
  po::value<uint32_t>(&global_system_variables.query_alloc_block_size)->default_value(QUERY_ALLOC_BLOCK_SIZE)->notifier(&check_limits_qabs),
1302
 
  N_("Allocation block size for query parsing and execution"))
1303
 
  ("query-prealloc-size",
1304
 
  po::value<uint32_t>(&global_system_variables.query_prealloc_size)->default_value(QUERY_ALLOC_PREALLOC_SIZE)->notifier(&check_limits_qps),
1305
 
  N_("Persistent buffer for query parsing and execution"))
1306
 
  ("range-alloc-block-size",
1307
 
  po::value<size_t>(&global_system_variables.range_alloc_block_size)->default_value(RANGE_ALLOC_BLOCK_SIZE)->notifier(&check_limits_rabs),
1308
 
  N_("Allocation block size for storing ranges during optimization"))
1309
 
  ("read-buffer-size",
1310
 
  po::value<uint32_t>(&global_system_variables.read_buff_size)->default_value(128*1024L)->notifier(&check_limits_read_buffer_size),
1311
 
  N_("Each thread that does a sequential scan allocates a buffer of this "
1312
 
      "size for each table it scans. If you do many sequential scans, you may "
1313
 
      "want to increase this value."))
1314
 
  ("read-rnd-buffer-size",
1315
 
  po::value<uint32_t>(&global_system_variables.read_rnd_buff_size)->default_value(256*1024L)->notifier(&check_limits_read_rnd_buffer_size),
1316
 
  N_("When reading rows in sorted order after a sort, the rows are read "
1317
 
     "through this buffer to avoid a disk seeks. If not set, then it's set "
1318
 
     "to the value of record_buffer."))
1319
 
  ("scheduler", po::value<string>(),
1320
 
  N_("Select scheduler to be used (by default multi-thread)."))
1321
 
  ("sort-buffer-size",
1322
 
  po::value<size_t>(&global_system_variables.sortbuff_size)->default_value(MAX_SORT_MEMORY)->notifier(&check_limits_sort_buffer_size),
1323
 
  N_("Each thread that needs to do a sort allocates a buffer of this size."))
1324
 
  ("table-definition-cache", po::value<size_t>(&table_def_size)->default_value(128)->notifier(&check_limits_tdc),
1325
 
  N_("The number of cached table definitions."))
1326
 
  ("table-open-cache", po::value<uint64_t>(&table_cache_size)->default_value(TABLE_OPEN_CACHE_DEFAULT)->notifier(&check_limits_toc),
1327
 
  N_("The number of cached open tables."))
1328
 
  ("table-lock-wait-timeout", po::value<uint64_t>(&table_lock_wait_timeout)->default_value(50)->notifier(&check_limits_tlwt),
1329
 
  N_("Timeout in seconds to wait for a table level lock before returning an "
1330
 
     "error. Used only if the connection has active cursors."))
1331
 
  ("thread-stack", po::value<size_t>(&my_thread_stack_size)->default_value(DEFAULT_THREAD_STACK)->notifier(&check_limits_thread_stack),
1332
 
  N_("The stack size for each thread."))
1333
 
  ("tmp-table-size", 
1334
 
  po::value<uint64_t>(&global_system_variables.tmp_table_size)->default_value(16*1024*1024L)->notifier(&check_limits_tmp_table_size),
1335
 
  N_("If an internal in-memory temporary table exceeds this size, Drizzle will"
1336
 
     " automatically convert it to an on-disk MyISAM table."))
1337
 
  ("no-defaults", po::value<bool>()->default_value(false)->zero_tokens(),
1338
 
  N_("Configuration file defaults are not used if no-defaults is set"))
1339
 
  ("defaults-file", po::value<vector<string> >()->composing()->notifier(&compose_defaults_file_list),
1340
 
   N_("Configuration file to use"))
1341
 
  ("config-dir", po::value<string>()->default_value(system_config_dir_drizzle),
1342
 
   N_("Base location for config files"))
1343
 
  ;
1344
 
 
1345
 
  // Disable allow_guessing
1346
 
  int style = po::command_line_style::default_style & ~po::command_line_style::allow_guessing;
1347
 
 
1348
 
  po::parsed_options parsed= po::command_line_parser(argc, argv).style(style).
1349
 
    options(long_options).allow_unregistered().extra_parser(parse_size_arg).run();
1350
 
  unknown_options=
1351
 
    po::collect_unrecognized(parsed.options, po::include_positional);
1352
 
 
1353
 
  try
1354
 
  {
1355
 
    po::store(parsed, vm);
1356
 
  }
1357
 
  catch (...)
1358
 
  {
1359
 
    errmsg_printf(ERRMSG_LVL_ERROR, _("Duplicate entry for command line option\n"));
1360
 
    unireg_abort(1);
1361
 
  }
1362
 
 
1363
 
  if (not vm["no-defaults"].as<bool>())
1364
 
  {
1365
 
    defaults_file_list.insert(defaults_file_list.begin(),
1366
 
                              system_config_file_drizzle);
1367
 
  }
1368
 
 
1369
 
  string config_conf_d_location(vm["config-dir"].as<string>());
1370
 
  config_conf_d_location.append("/conf.d");
1371
 
  CachedDirectory config_conf_d(config_conf_d_location);
1372
 
  if (not config_conf_d.fail())
1373
 
  {
1374
 
 
1375
 
    for (CachedDirectory::Entries::const_iterator iter= config_conf_d.getEntries().begin();
1376
 
         iter != config_conf_d.getEntries().end();
1377
 
         ++iter)
 
2060
  strmake(pidfile_name, glob_hostname, sizeof(pidfile_name)-5);
 
2061
  my_stpcpy(fn_ext(pidfile_name),".pid");               // Add proper extension
 
2062
 
 
2063
  /*
 
2064
    Add server status variables to the dynamic list of
 
2065
    status variables that is shown by SHOW STATUS.
 
2066
    Later, in plugin_init, and mysql_install_plugin
 
2067
    new entries could be added to that list.
 
2068
  */
 
2069
  if (add_status_vars(status_vars))
 
2070
    return 1; // an error was already reported
 
2071
 
 
2072
  load_defaults(conf_file_name, groups, &argc, &argv);
 
2073
  defaults_argv=argv;
 
2074
  defaults_argc=argc;
 
2075
  get_options(&defaults_argc, defaults_argv);
 
2076
  set_server_version();
 
2077
 
 
2078
 
 
2079
  /* connections and databases needs lots of files */
 
2080
  {
 
2081
    uint32_t files, wanted_files, max_open_files;
 
2082
 
 
2083
    /* MyISAM requires two file handles per table. */
 
2084
    wanted_files= 10+max_connections+table_cache_size*2;
 
2085
    /*
 
2086
      We are trying to allocate no less than max_connections*5 file
 
2087
      handles (i.e. we are trying to set the limit so that they will
 
2088
      be available).  In addition, we allocate no less than how much
 
2089
      was already allocated.  However below we report a warning and
 
2090
      recompute values only if we got less file handles than were
 
2091
      explicitly requested.  No warning and re-computation occur if we
 
2092
      can't get max_connections*5 but still got no less than was
 
2093
      requested (value of wanted_files).
 
2094
    */
 
2095
    max_open_files= cmax(cmax((uint32_t)wanted_files, max_connections*5),
 
2096
                         open_files_limit);
 
2097
    files= my_set_max_open_files(max_open_files);
 
2098
 
 
2099
    if (files < wanted_files)
1378
2100
    {
1379
 
      string file_entry((*iter)->filename);
1380
 
          
1381
 
      if (not file_entry.empty()
1382
 
          && file_entry != "."
1383
 
          && file_entry != "..")
 
2101
      if (!open_files_limit)
1384
2102
      {
1385
 
        string the_entry(config_conf_d_location);
1386
 
        the_entry.push_back('/');
1387
 
        the_entry.append(file_entry);
1388
 
        defaults_file_list.push_back(the_entry);
 
2103
        /*
 
2104
          If we have requested too much file handles than we bring
 
2105
          max_connections in supported bounds.
 
2106
        */
 
2107
        max_connections= (uint32_t) cmin((uint32_t)files-10-TABLE_OPEN_CACHE_MIN*2,
 
2108
                                     max_connections);
 
2109
        /*
 
2110
          Decrease table_cache_size according to max_connections, but
 
2111
          not below TABLE_OPEN_CACHE_MIN.  Outer cmin() ensures that we
 
2112
          never increase table_cache_size automatically (that could
 
2113
          happen if max_connections is decreased above).
 
2114
        */
 
2115
        table_cache_size= (uint32_t) cmin(cmax((files-10-max_connections)/2,
 
2116
                                          (uint32_t)TABLE_OPEN_CACHE_MIN),
 
2117
                                      table_cache_size);
 
2118
        if (global_system_variables.log_warnings)
 
2119
          sql_print_warning(_("Changed limits: max_open_files: %u  "
 
2120
                              "max_connections: %ld  table_cache: %ld"),
 
2121
                            files, max_connections, table_cache_size);
1389
2122
      }
1390
 
    }
1391
 
  }
1392
 
 
1393
 
  po::notify(vm);
1394
 
  process_defaults_files();
1395
 
  po::notify(vm);
1396
 
 
1397
 
  get_options();
1398
 
 
1399
 
  /* Inverted Booleans */
1400
 
 
1401
 
  global_system_variables.optimizer_prune_level=
1402
 
    vm.count("disable-optimizer-prune") ? false : true;
1403
 
 
1404
 
  if (vm.count("help") == 0 && vm.count("help-extended") == 0)
1405
 
  {
1406
 
    if ((user_info= check_user(drizzled_user)))
1407
 
    {
1408
 
      set_user(drizzled_user, user_info);
1409
 
    }
1410
 
  }
1411
 
 
1412
 
  fix_paths(argv[0]);
1413
 
 
1414
 
  current_pid= getpid();                /* Save for later ref */
1415
 
  init_time();                          /* Init time-functions (read zone) */
1416
 
 
 
2123
      else if (global_system_variables.log_warnings)
 
2124
        sql_print_warning(_("Could not increase number of max_open_files "
 
2125
                            "to more than %u (request: %u)"),
 
2126
                          files, wanted_files);
 
2127
    }
 
2128
    open_files_limit= files;
 
2129
  }
 
2130
  unireg_init(0); /* Set up extern variabels */
 
2131
  if (init_errmessage())        /* Read error messages from file */
 
2132
    return 1;
 
2133
  lex_init();
1417
2134
  if (item_create_init())
1418
2135
    return 1;
 
2136
  item_init();
1419
2137
  if (set_var_init())
1420
2138
    return 1;
1421
 
  /* Creates static regex matching for temporal values */
1422
 
  if (! init_temporal_formats())
 
2139
  if (init_replication_sys_vars())
1423
2140
    return 1;
1424
 
 
1425
 
  if (!(default_charset_info=
1426
 
        get_charset_by_csname(default_character_set_name, MY_CS_PRIMARY)))
 
2141
  /*
 
2142
    Process a comma-separated character set list and choose
 
2143
    the first available character set. This is mostly for
 
2144
    test purposes, to be able to start "mysqld" even if
 
2145
    the requested character set is not available (see bug#18743).
 
2146
  */
 
2147
  for (;;)
1427
2148
  {
1428
 
    errmsg_printf(ERRMSG_LVL_ERROR, _("Error getting default charset"));
1429
 
    return 1;                           // Eof of the list
 
2149
    char *next_character_set_name= strchr(default_character_set_name, ',');
 
2150
    if (next_character_set_name)
 
2151
      *next_character_set_name++= '\0';
 
2152
    if (!(default_charset_info=
 
2153
          get_charset_by_csname(default_character_set_name,
 
2154
                                MY_CS_PRIMARY, MYF(MY_WME))))
 
2155
    {
 
2156
      if (next_character_set_name)
 
2157
      {
 
2158
        default_character_set_name= next_character_set_name;
 
2159
        default_collation_name= 0;          // Ignore collation
 
2160
      }
 
2161
      else
 
2162
        return 1;                           // Eof of the list
 
2163
    }
 
2164
    else
 
2165
      break;
1430
2166
  }
1431
2167
 
1432
2168
  if (default_collation_name)
1433
2169
  {
1434
 
    const CHARSET_INFO * const default_collation= get_charset_by_name(default_collation_name);
1435
 
    if (not default_collation)
 
2170
    const CHARSET_INFO * const default_collation=
 
2171
      get_charset_by_name(default_collation_name, MYF(0));
 
2172
    if (!default_collation)
1436
2173
    {
1437
 
      errmsg_printf(ERRMSG_LVL_ERROR, _(ER(ER_UNKNOWN_COLLATION)), default_collation_name);
 
2174
      sql_print_error(_(ER(ER_UNKNOWN_COLLATION)), default_collation_name);
1438
2175
      return 1;
1439
2176
    }
1440
 
    if (not my_charset_same(default_charset_info, default_collation))
 
2177
    if (!my_charset_same(default_charset_info, default_collation))
1441
2178
    {
1442
 
      errmsg_printf(ERRMSG_LVL_ERROR, _(ER(ER_COLLATION_CHARSET_MISMATCH)),
1443
 
                    default_collation_name,
1444
 
                    default_charset_info->csname);
 
2179
      sql_print_error(_(ER(ER_COLLATION_CHARSET_MISMATCH)),
 
2180
                      default_collation_name,
 
2181
                      default_charset_info->csname);
1445
2182
      return 1;
1446
2183
    }
1447
2184
    default_charset_info= default_collation;
1448
2185
  }
1449
2186
  /* Set collactions that depends on the default collation */
1450
2187
  global_system_variables.collation_server=      default_charset_info;
1451
 
 
1452
 
  if (not (character_set_filesystem=
1453
 
           get_charset_by_csname(character_set_filesystem_name, MY_CS_PRIMARY)))
1454
 
  {
1455
 
    errmsg_printf(ERRMSG_LVL_ERROR, _("Error setting collation"));
 
2188
  global_system_variables.collation_database=    default_charset_info;
 
2189
  global_system_variables.collation_connection=  default_charset_info;
 
2190
  global_system_variables.character_set_results= default_charset_info;
 
2191
  global_system_variables.character_set_client= default_charset_info;
 
2192
 
 
2193
  global_system_variables.optimizer_use_mrr= 1;
 
2194
  global_system_variables.optimizer_switch= 0;
 
2195
 
 
2196
  if (!(character_set_filesystem=
 
2197
        get_charset_by_csname(character_set_filesystem_name,
 
2198
                              MY_CS_PRIMARY, MYF(MY_WME))))
1456
2199
    return 1;
1457
 
  }
1458
2200
  global_system_variables.character_set_filesystem= character_set_filesystem;
1459
2201
 
1460
2202
  if (!(my_default_lc_time_names=
1461
2203
        my_locale_by_name(lc_time_names_name)))
1462
2204
  {
1463
 
    errmsg_printf(ERRMSG_LVL_ERROR, _("Unknown locale: '%s'"), lc_time_names_name);
 
2205
    sql_print_error(_("Unknown locale: '%s'"), lc_time_names_name);
1464
2206
    return 1;
1465
2207
  }
1466
2208
  global_system_variables.lc_time_names= my_default_lc_time_names;
1467
2209
 
1468
 
  /* Reset table_alias_charset */
 
2210
  sys_init_connect.value_length= 0;
 
2211
  if ((sys_init_connect.value= opt_init_connect))
 
2212
    sys_init_connect.value_length= strlen(opt_init_connect);
 
2213
  else
 
2214
    sys_init_connect.value=my_strdup("",MYF(0));
 
2215
 
 
2216
  sys_init_slave.value_length= 0;
 
2217
  if ((sys_init_slave.value= opt_init_slave))
 
2218
    sys_init_slave.value_length= strlen(opt_init_slave);
 
2219
  else
 
2220
    sys_init_slave.value=my_strdup("",MYF(0));
 
2221
 
 
2222
  if (use_temp_pool && bitmap_init(&temp_pool,0,1024,1))
 
2223
    return 1;
 
2224
  if (my_database_names_init())
 
2225
    return 1;
 
2226
 
 
2227
 
 
2228
  /* Reset table_alias_charset, now that lower_case_table_names is set. */
 
2229
  lower_case_table_names= 1; /* This we need to look at */
1469
2230
  table_alias_charset= files_charset_info;
1470
2231
 
1471
2232
  return 0;
1472
2233
}
1473
2234
 
1474
2235
 
1475
 
int init_server_components(module::Registry &plugins)
 
2236
static int init_thread_environment()
 
2237
{
 
2238
  (void) pthread_mutex_init(&LOCK_mysql_create_db,MY_MUTEX_INIT_SLOW);
 
2239
  (void) pthread_mutex_init(&LOCK_lock_db,MY_MUTEX_INIT_SLOW);
 
2240
  (void) pthread_mutex_init(&LOCK_open, NULL);
 
2241
  (void) pthread_mutex_init(&LOCK_thread_count,MY_MUTEX_INIT_FAST);
 
2242
  (void) pthread_mutex_init(&LOCK_status,MY_MUTEX_INIT_FAST);
 
2243
  (void) pthread_mutex_init(&LOCK_error_log,MY_MUTEX_INIT_FAST);
 
2244
  (void) pthread_mutex_init(&LOCK_user_conn, MY_MUTEX_INIT_FAST);
 
2245
  (void) pthread_mutex_init(&LOCK_active_mi, MY_MUTEX_INIT_FAST);
 
2246
  (void) pthread_mutex_init(&LOCK_global_system_variables, MY_MUTEX_INIT_FAST);
 
2247
  (void) my_rwlock_init(&LOCK_system_variables_hash, NULL);
 
2248
  (void) pthread_mutex_init(&LOCK_global_read_lock, MY_MUTEX_INIT_FAST);
 
2249
  (void) pthread_mutex_init(&LOCK_uuid_generator, MY_MUTEX_INIT_FAST);
 
2250
  (void) pthread_mutex_init(&LOCK_connection_count, MY_MUTEX_INIT_FAST);
 
2251
  (void) my_rwlock_init(&LOCK_sys_init_connect, NULL);
 
2252
  (void) my_rwlock_init(&LOCK_sys_init_slave, NULL);
 
2253
  (void) pthread_cond_init(&COND_thread_count,NULL);
 
2254
  (void) pthread_cond_init(&COND_refresh,NULL);
 
2255
  (void) pthread_cond_init(&COND_global_read_lock,NULL);
 
2256
  (void) pthread_cond_init(&COND_thread_cache,NULL);
 
2257
  (void) pthread_cond_init(&COND_flush_thread_cache,NULL);
 
2258
 
 
2259
  /* Parameter for threads created for connections */
 
2260
  (void) pthread_attr_init(&connection_attrib);
 
2261
  (void) pthread_attr_setdetachstate(&connection_attrib,
 
2262
                                     PTHREAD_CREATE_DETACHED);
 
2263
  pthread_attr_setscope(&connection_attrib, PTHREAD_SCOPE_SYSTEM);
 
2264
  {
 
2265
    struct sched_param tmp_sched_param;
 
2266
 
 
2267
    memset(&tmp_sched_param, 0, sizeof(tmp_sched_param));
 
2268
    tmp_sched_param.sched_priority= WAIT_PRIOR;
 
2269
    (void)pthread_attr_setschedparam(&connection_attrib, &tmp_sched_param);
 
2270
  }
 
2271
 
 
2272
  if (pthread_key_create(&THR_THD,NULL) ||
 
2273
      pthread_key_create(&THR_MALLOC,NULL))
 
2274
  {
 
2275
    sql_print_error(_("Can't create thread-keys"));
 
2276
    return 1;
 
2277
  }
 
2278
  return 0;
 
2279
}
 
2280
 
 
2281
 
 
2282
static int init_server_components()
1476
2283
{
1477
2284
  /*
1478
2285
    We need to call each of these following functions to ensure that
1479
2286
    all things are initialized so that unireg_abort() doesn't fail
1480
2287
  */
1481
 
  if (table_cache_init())
1482
 
  {
1483
 
    errmsg_printf(ERRMSG_LVL_ERROR, _("Could not initialize table cache\n"));
 
2288
  if (table_cache_init() | table_def_init())
1484
2289
    unireg_abort(1);
1485
 
  }
1486
 
  TableShare::cacheStart();
1487
2290
 
 
2291
  randominit(&sql_rand,(uint32_t) server_start_time,(uint32_t) server_start_time/2);
1488
2292
  setup_fpu();
 
2293
  init_thr_lock();
1489
2294
 
1490
2295
  /* Setup logs */
1491
2296
 
 
2297
  /*
 
2298
    Enable old-fashioned error log, except when the user has requested
 
2299
    help information. Since the implementation of plugin server
 
2300
    variables the help output is now written much later.
 
2301
  */
 
2302
  if (opt_error_log && !opt_help)
 
2303
  {
 
2304
    if (!log_error_file_ptr[0])
 
2305
      fn_format(log_error_file, pidfile_name, mysql_data_home, ".err",
 
2306
                MY_REPLACE_EXT); /* replace '.<domain>' by '.err', bug#4997 */
 
2307
    else
 
2308
      fn_format(log_error_file, log_error_file_ptr, mysql_data_home, ".err",
 
2309
                MY_UNPACK_FILENAME | MY_SAFE_PATH);
 
2310
    if (!log_error_file[0])
 
2311
      opt_error_log= 1;                         // Too long file name
 
2312
    else
 
2313
    {
 
2314
      if (freopen(log_error_file, "a+", stdout))
 
2315
        freopen(log_error_file, "a+", stderr);
 
2316
    }
 
2317
  }
 
2318
 
1492
2319
  if (xid_cache_init())
1493
2320
  {
1494
 
    errmsg_printf(ERRMSG_LVL_ERROR, _("XA cache initialization failed: Out of memory\n"));
1495
 
    unireg_abort(1);
1496
 
  }
 
2321
    sql_print_error(_("Out of memory"));
 
2322
    unireg_abort(1);
 
2323
  }
 
2324
 
 
2325
  if (!opt_bin_log)
 
2326
    if (opt_binlog_format_id != BINLOG_FORMAT_UNSPEC)
 
2327
    {
 
2328
      sql_print_error(_("You need to use --log-bin to make "
 
2329
                        "--binlog-format work."));
 
2330
      unireg_abort(1);
 
2331
    }
 
2332
    else
 
2333
    {
 
2334
      global_system_variables.binlog_format= BINLOG_FORMAT_MIXED;
 
2335
    }
 
2336
  else
 
2337
    if (opt_binlog_format_id == BINLOG_FORMAT_UNSPEC)
 
2338
      global_system_variables.binlog_format= BINLOG_FORMAT_MIXED;
 
2339
    else
 
2340
    {
 
2341
      assert(global_system_variables.binlog_format != BINLOG_FORMAT_UNSPEC);
 
2342
    }
 
2343
 
 
2344
  /* Check that we have not let the format to unspecified at this point */
 
2345
  assert((uint)global_system_variables.binlog_format <=
 
2346
              array_elements(binlog_format_names)-1);
 
2347
 
 
2348
  if (opt_log_slave_updates && replicate_same_server_id)
 
2349
  {
 
2350
    sql_print_error(_("using --replicate-same-server-id in conjunction with "
 
2351
                      "--log-slave-updates is impossible, it would lead to "
 
2352
                      "infinite loops in this server."));
 
2353
    unireg_abort(1);
 
2354
  }
 
2355
 
 
2356
  if (opt_bin_log)
 
2357
  {
 
2358
    char buf[FN_REFLEN];
 
2359
    const char *ln;
 
2360
    ln= mysql_bin_log.generate_name(opt_bin_logname, "-bin", 1, buf);
 
2361
    if (!opt_bin_logname && !opt_binlog_index_name)
 
2362
    {
 
2363
      /*
 
2364
        User didn't give us info to name the binlog index file.
 
2365
        Picking `hostname`-bin.index like did in 4.x, causes replication to
 
2366
        fail if the hostname is changed later. So, we would like to instead
 
2367
        require a name. But as we don't want to break many existing setups, we
 
2368
        only give warning, not error.
 
2369
      */
 
2370
      sql_print_warning(_("No argument was provided to --log-bin, and "
 
2371
                          "--log-bin-index was not used; so replication "
 
2372
                          "may break when this Drizzle server acts as a "
 
2373
                          "master and has his hostname changed!! Please "
 
2374
                          "use '--log-bin=%s' to avoid this problem."), ln);
 
2375
    }
 
2376
    if (ln == buf)
 
2377
    {
 
2378
      free(opt_bin_logname);
 
2379
      opt_bin_logname=my_strdup(buf, MYF(0));
 
2380
    }
 
2381
    if (mysql_bin_log.open_index_file(opt_binlog_index_name, ln))
 
2382
    {
 
2383
      unireg_abort(1);
 
2384
    }
 
2385
 
 
2386
    /*
 
2387
      Used to specify which type of lock we need to use for queries of type
 
2388
      INSERT ... SELECT. This will change when we have row level logging.
 
2389
    */
 
2390
    using_update_log=1;
 
2391
  }
 
2392
 
 
2393
  /* call ha_init_key_cache() on all key caches to init them */
 
2394
  process_key_caches(&ha_init_key_cache);
1497
2395
 
1498
2396
  /* Allow storage engine to give real error messages */
1499
 
  ha_init_errors();
 
2397
  if (ha_init_errors())
 
2398
    return(1);
1500
2399
 
1501
 
  if (plugin_init(plugins, plugin_options))
 
2400
  if (plugin_init(&defaults_argc, defaults_argv,
 
2401
                  (opt_noacl ? PLUGIN_INIT_SKIP_PLUGIN_TABLE : 0) |
 
2402
                  (opt_help ? PLUGIN_INIT_SKIP_INITIALIZATION : 0)))
1502
2403
  {
1503
 
    errmsg_printf(ERRMSG_LVL_ERROR, _("Failed to initialize plugins\n"));
 
2404
    sql_print_error(_("Failed to initialize plugins."));
1504
2405
    unireg_abort(1);
1505
2406
  }
1506
2407
 
1507
 
 
1508
 
  if (opt_help || opt_help_extended)
 
2408
  if (opt_help)
1509
2409
    unireg_abort(0);
1510
2410
 
1511
 
  vector<string> final_unknown_options;
1512
 
  try
1513
 
  {
1514
 
    // Disable allow_guessing
1515
 
    int style = po::command_line_style::default_style & ~po::command_line_style::allow_guessing;
1516
 
    po::parsed_options parsed=
1517
 
      po::command_line_parser(unknown_options).style(style).
1518
 
      options(plugin_options).extra_parser(parse_size_arg).run();
1519
 
 
1520
 
    final_unknown_options=
1521
 
      po::collect_unrecognized(parsed.options, po::include_positional);
1522
 
 
1523
 
    po::store(parsed, vm);
1524
 
 
1525
 
  }
1526
 
  catch (po::invalid_command_line_syntax &err)
1527
 
  {
1528
 
    errmsg_printf(ERRMSG_LVL_ERROR,
1529
 
                  _("%s: %s.\n"
1530
 
                    "Use --help to get a list of available options\n"),
1531
 
                  internal::my_progname, err.what());
1532
 
    unireg_abort(1);
1533
 
  }
1534
 
  catch (po::unknown_option &err)
1535
 
  {
1536
 
    errmsg_printf(ERRMSG_LVL_ERROR,
1537
 
                  _("%s\nUse --help to get a list of available options\n"),
1538
 
                  err.what());
1539
 
    unireg_abort(1);
1540
 
  }
1541
 
 
1542
 
  po::notify(vm);
1543
 
 
1544
 
  plugin_finalize(plugins);
1545
 
 
1546
 
  string scheduler_name;
1547
 
  if (opt_scheduler)
1548
 
  {
1549
 
    scheduler_name= opt_scheduler;
1550
 
  }
1551
 
  else
1552
 
  {
1553
 
    scheduler_name= opt_scheduler_default;
1554
 
    opt_scheduler= opt_scheduler_default; 
1555
 
  }
1556
 
 
1557
 
  if (plugin::Scheduler::setPlugin(scheduler_name))
1558
 
  {
1559
 
      errmsg_printf(ERRMSG_LVL_ERROR,
1560
 
                   _("No scheduler found, cannot continue!\n"));
 
2411
  /* we do want to exit if there are any other unknown options */
 
2412
  if (defaults_argc > 1)
 
2413
  {
 
2414
    int ho_error;
 
2415
    char **tmp_argv= defaults_argv;
 
2416
    struct my_option no_opts[]=
 
2417
    {
 
2418
      {0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
 
2419
    };
 
2420
    /*
 
2421
      We need to eat any 'loose' arguments first before we conclude
 
2422
      that there are unprocessed options.
 
2423
      But we need to preserve defaults_argv pointer intact for
 
2424
      free_defaults() to work. Thus we use a copy here.
 
2425
    */
 
2426
    my_getopt_skip_unknown= 0;
 
2427
 
 
2428
    if ((ho_error= handle_options(&defaults_argc, &tmp_argv, no_opts,
 
2429
                                  mysqld_get_one_option)))
 
2430
      unireg_abort(ho_error);
 
2431
 
 
2432
    if (defaults_argc)
 
2433
    {
 
2434
      fprintf(stderr,
 
2435
              _("%s: Too many arguments (first extra is '%s').\n"
 
2436
                "Use --verbose --help to get a list of available options\n"),
 
2437
              my_progname, *tmp_argv);
1561
2438
      unireg_abort(1);
 
2439
    }
1562
2440
  }
1563
2441
 
1564
 
  /*
1565
 
    This is entirely for legacy. We will create a new "disk based" engine and a
1566
 
    "memory" engine which will be configurable longterm.
1567
 
  */
1568
 
  const std::string myisam_engine_name("MyISAM");
1569
 
  const std::string heap_engine_name("MEMORY");
1570
 
  myisam_engine= plugin::StorageEngine::findByName(myisam_engine_name);
1571
 
  heap_engine= plugin::StorageEngine::findByName(heap_engine_name);
 
2442
  /* We have to initialize the storage engines before CSV logging */
 
2443
  if (ha_init())
 
2444
  {
 
2445
    sql_print_error(_("Can't init databases"));
 
2446
    unireg_abort(1);
 
2447
  }
1572
2448
 
1573
2449
  /*
1574
2450
    Check that the default storage engine is actually available.
1575
2451
  */
1576
2452
  if (default_storage_engine_str)
1577
2453
  {
1578
 
    const std::string name(default_storage_engine_str);
1579
 
    plugin::StorageEngine *engine;
1580
 
 
1581
 
    engine= plugin::StorageEngine::findByName(name);
1582
 
    if (engine == NULL)
1583
 
    {
1584
 
      errmsg_printf(ERRMSG_LVL_ERROR, _("Unknown/unsupported storage engine: %s\n"),
1585
 
                    default_storage_engine_str);
1586
 
      unireg_abort(1);
1587
 
    }
1588
 
    global_system_variables.storage_engine= engine;
1589
 
  }
1590
 
 
1591
 
  if (plugin::XaResourceManager::recoverAllXids())
1592
 
  {
1593
 
    /* This function alredy generates error messages */
1594
 
    unireg_abort(1);
1595
 
  }
 
2454
    LEX_STRING name= { default_storage_engine_str,
 
2455
                       strlen(default_storage_engine_str) };
 
2456
    plugin_ref plugin;
 
2457
    handlerton *hton;
 
2458
 
 
2459
    if ((plugin= ha_resolve_by_name(0, &name)))
 
2460
    {
 
2461
      hton= plugin_data(plugin,handlerton *);
 
2462
    }
 
2463
    else
 
2464
    {
 
2465
      sql_print_error(_("Unknown/unsupported table type: %s"),
 
2466
                      default_storage_engine_str);
 
2467
      unireg_abort(1);
 
2468
    }
 
2469
    if (!ha_storage_engine_is_enabled(hton))
 
2470
    {
 
2471
      sql_print_error(_("Default storage engine (%s) is not available"),
 
2472
                      default_storage_engine_str);
 
2473
      unireg_abort(1);
 
2474
      assert(global_system_variables.table_plugin);
 
2475
    }
 
2476
    else
 
2477
    {
 
2478
      /*
 
2479
        Need to unlock as global_system_variables.table_plugin
 
2480
        was acquired during plugin_init()
 
2481
      */
 
2482
      plugin_unlock(0, global_system_variables.table_plugin);
 
2483
      global_system_variables.table_plugin= plugin;
 
2484
    }
 
2485
  }
 
2486
 
 
2487
  tc_log= (total_ha_2pc > 1 ? (opt_bin_log  ?
 
2488
                               (TC_LOG *) &mysql_bin_log :
 
2489
                               (TC_LOG *) &tc_log_mmap) :
 
2490
           (TC_LOG *) &tc_log_dummy);
 
2491
 
 
2492
  if (tc_log->open(opt_bin_log ? opt_bin_logname : opt_tc_log_file))
 
2493
  {
 
2494
    sql_print_error(_("Can't initialize tc_log"));
 
2495
    unireg_abort(1);
 
2496
  }
 
2497
 
 
2498
  if (ha_recover(0))
 
2499
  {
 
2500
    unireg_abort(1);
 
2501
  }
 
2502
 
 
2503
  if (opt_bin_log && mysql_bin_log.open(opt_bin_logname, LOG_BIN, 0,
 
2504
                                        WRITE_CACHE, 0, max_binlog_size, 0))
 
2505
    unireg_abort(1);
 
2506
 
 
2507
  if (opt_bin_log && expire_logs_days)
 
2508
  {
 
2509
    time_t purge_time= server_start_time - expire_logs_days*24*60*60;
 
2510
    if (purge_time >= 0)
 
2511
      mysql_bin_log.purge_logs_before_date(purge_time);
 
2512
  }
 
2513
 
 
2514
#if defined(HAVE_MLOCKALL) && defined(MCL_CURRENT)
 
2515
  if (locked_in_memory && !getuid())
 
2516
  {
 
2517
    if (setreuid((uid_t)-1, 0) == -1)
 
2518
    {                        // this should never happen
 
2519
      sql_perror("setreuid");
 
2520
      unireg_abort(1);
 
2521
    }
 
2522
    if (mlockall(MCL_CURRENT))
 
2523
    {
 
2524
      if (global_system_variables.log_warnings)
 
2525
        sql_print_warning(_("Failed to lock memory. Errno: %d\n"),errno);
 
2526
      locked_in_memory= 0;
 
2527
    }
 
2528
    if (user_info)
 
2529
      set_user(mysqld_user, user_info);
 
2530
  }
 
2531
  else
 
2532
#endif
 
2533
    locked_in_memory=0;
1596
2534
 
1597
2535
  init_update_queries();
1598
 
 
1599
2536
  return(0);
1600
2537
}
1601
2538
 
1602
2539
 
 
2540
int main(int argc, char **argv)
 
2541
{
 
2542
#if defined(ENABLE_NLS)
 
2543
# if defined(HAVE_LOCALE_H)
 
2544
  setlocale(LC_ALL, "");
 
2545
# endif
 
2546
  bindtextdomain("drizzle", LOCALEDIR);
 
2547
  textdomain("drizzle");
 
2548
#endif
 
2549
 
 
2550
  MY_INIT(argv[0]);             // init my_sys library & pthreads
 
2551
  /* nothing should come before this line ^^^ */
 
2552
 
 
2553
  /* Set signal used to kill MySQL */
 
2554
#if defined(SIGUSR2)
 
2555
  thr_kill_signal= thd_lib_detected == THD_LIB_LT ? SIGINT : SIGUSR2;
 
2556
#else
 
2557
  thr_kill_signal= SIGINT;
 
2558
#endif
 
2559
 
 
2560
  /*
 
2561
    Perform basic logger initialization logger. Should be called after
 
2562
    MY_INIT, as it initializes mutexes. Log tables are inited later.
 
2563
  */
 
2564
  logger.init_base();
 
2565
 
 
2566
#ifdef _CUSTOMSTARTUPCONFIG_
 
2567
  if (_cust_check_startup())
 
2568
  {
 
2569
    / * _cust_check_startup will report startup failure error * /
 
2570
    exit(1);
 
2571
  }
 
2572
#endif
 
2573
 
 
2574
  if (init_common_variables(DRIZZLE_CONFIG_NAME,
 
2575
                            argc, argv, load_default_groups))
 
2576
    unireg_abort(1);                            // Will do exit
 
2577
 
 
2578
  init_signals();
 
2579
 
 
2580
  pthread_attr_setstacksize(&connection_attrib,my_thread_stack_size);
 
2581
 
 
2582
#ifdef HAVE_PTHREAD_ATTR_GETSTACKSIZE
 
2583
  {
 
2584
    /* Retrieve used stack size;  Needed for checking stack overflows */
 
2585
    size_t stack_size= 0;
 
2586
    pthread_attr_getstacksize(&connection_attrib, &stack_size);
 
2587
    /* We must check if stack_size = 0 as Solaris 2.9 can return 0 here */
 
2588
    if (stack_size && stack_size < my_thread_stack_size)
 
2589
    {
 
2590
      if (global_system_variables.log_warnings)
 
2591
      {
 
2592
        /* %zu is not yet in C++ */
 
2593
        uint64_t size_tmp= (uint64_t)stack_size;
 
2594
        sql_print_warning(_("Asked for %u thread stack, but got %"PRIu64),
 
2595
                          my_thread_stack_size, size_tmp);
 
2596
      }
 
2597
      my_thread_stack_size= stack_size;
 
2598
    }
 
2599
  }
 
2600
#endif
 
2601
 
 
2602
  select_thread=pthread_self();
 
2603
  select_thread_in_use=1;
 
2604
 
 
2605
  /*
 
2606
    We have enough space for fiddling with the argv, continue
 
2607
  */
 
2608
  check_data_home(mysql_real_data_home);
 
2609
  if (my_setwd(mysql_real_data_home,MYF(MY_WME)) && !opt_help)
 
2610
    unireg_abort(1);                            /* purecov: inspected */
 
2611
  mysql_data_home= mysql_data_home_buff;
 
2612
  mysql_data_home[0]=FN_CURLIB;         // all paths are relative from here
 
2613
  mysql_data_home[1]=0;
 
2614
  mysql_data_home_len= 2;
 
2615
 
 
2616
  if ((user_info= check_user(mysqld_user)))
 
2617
  {
 
2618
#if defined(HAVE_MLOCKALL) && defined(MCL_CURRENT)
 
2619
    if (locked_in_memory) // getuid() == 0 here
 
2620
      set_effective_user(user_info);
 
2621
    else
 
2622
#endif
 
2623
      set_user(mysqld_user, user_info);
 
2624
  }
 
2625
 
 
2626
  if (opt_bin_log && !server_id)
 
2627
  {
 
2628
    server_id= 1;
 
2629
#ifdef EXTRA_DEBUG
 
2630
    sql_print_warning(_("You have enabled the binary log, but you haven't set "
 
2631
                        "server-id to a non-zero value: we force server id to "
 
2632
                        "1; updates will be logged to the binary log, but "
 
2633
                        "connections from slaves will not be accepted."));
 
2634
#endif
 
2635
  }
 
2636
 
 
2637
  if (init_server_components())
 
2638
    unireg_abort(1);
 
2639
 
 
2640
  network_init();
 
2641
 
 
2642
  /*
 
2643
   Initialize my_str_malloc() and my_str_free()
 
2644
  */
 
2645
  my_str_malloc= &my_str_malloc_mysqld;
 
2646
  my_str_free= &my_str_free_mysqld;
 
2647
 
 
2648
  /*
 
2649
    init signals & alarm
 
2650
    After this we can't quit by a simple unireg_abort
 
2651
  */
 
2652
  error_handler_hook= my_message_sql;
 
2653
  start_signal_handler();                               // Creates pidfile
 
2654
 
 
2655
  if (mysql_rm_tmp_tables() || my_tz_init((THD *)0, default_tz_name, false))
 
2656
  {
 
2657
    abort_loop=1;
 
2658
    select_thread_in_use=0;
 
2659
    (void) pthread_kill(signal_thread, DRIZZLE_KILL_SIGNAL);
 
2660
 
 
2661
    (void) my_delete(pidfile_name,MYF(MY_WME)); // Not needed anymore
 
2662
 
 
2663
    exit(1);
 
2664
  }
 
2665
 
 
2666
  init_status_vars();
 
2667
  /*
 
2668
    init_slave() must be called after the thread keys are created.
 
2669
    Some parts of the code (e.g. SHOW STATUS LIKE 'slave_running' and other
 
2670
    places) assume that active_mi != 0, so let's fail if it's 0 (out of
 
2671
    memory); a message has already been printed.
 
2672
  */
 
2673
  if (init_slave() && !active_mi)
 
2674
  {
 
2675
    unireg_abort(1);
 
2676
  }
 
2677
 
 
2678
  sql_print_information(_(ER(ER_STARTUP)),my_progname,server_version,
 
2679
                        "", mysqld_port, DRIZZLE_COMPILATION_COMMENT);
 
2680
 
 
2681
 
 
2682
  handle_connections_sockets();
 
2683
 
 
2684
  /* (void) pthread_attr_destroy(&connection_attrib); */
 
2685
 
 
2686
 
 
2687
#ifdef EXTRA_DEBUG2
 
2688
  sql_print_error(_("Before Lock_thread_count"));
 
2689
#endif
 
2690
  (void) pthread_mutex_lock(&LOCK_thread_count);
 
2691
  select_thread_in_use=0;                       // For close_connections
 
2692
  (void) pthread_mutex_unlock(&LOCK_thread_count);
 
2693
  (void) pthread_cond_broadcast(&COND_thread_count);
 
2694
#ifdef EXTRA_DEBUG2
 
2695
  sql_print_error(_("After lock_thread_count"));
 
2696
#endif
 
2697
 
 
2698
  /* Wait until cleanup is done */
 
2699
  (void) pthread_mutex_lock(&LOCK_thread_count);
 
2700
  while (!ready_to_exit)
 
2701
    pthread_cond_wait(&COND_thread_count,&LOCK_thread_count);
 
2702
  (void) pthread_mutex_unlock(&LOCK_thread_count);
 
2703
 
 
2704
  clean_up(1);
 
2705
  mysqld_exit(0);
 
2706
}
 
2707
 
 
2708
 
 
2709
/**
 
2710
  Create new thread to handle incoming connection.
 
2711
 
 
2712
    This function will create new thread to handle the incoming
 
2713
    connection.  If there are idle cached threads one will be used.
 
2714
    'thd' will be pushed into 'threads'.
 
2715
 
 
2716
    In single-threaded mode (\#define ONE_THREAD) connection will be
 
2717
    handled inside this function.
 
2718
 
 
2719
  @param[in,out] thd    Thread handle of future thread.
 
2720
*/
 
2721
 
 
2722
static void create_new_thread(THD *thd)
 
2723
{
 
2724
 
 
2725
  /*
 
2726
    Don't allow too many connections. We roughly check here that we allow
 
2727
    only (max_connections + 1) connections.
 
2728
  */
 
2729
 
 
2730
  pthread_mutex_lock(&LOCK_connection_count);
 
2731
 
 
2732
  if (connection_count >= max_connections + 1 || abort_loop)
 
2733
  {
 
2734
    pthread_mutex_unlock(&LOCK_connection_count);
 
2735
 
 
2736
    close_connection(thd, ER_CON_COUNT_ERROR, 1);
 
2737
    delete thd;
 
2738
    return;;
 
2739
  }
 
2740
 
 
2741
  ++connection_count;
 
2742
 
 
2743
  if (connection_count > max_used_connections)
 
2744
    max_used_connections= connection_count;
 
2745
 
 
2746
  pthread_mutex_unlock(&LOCK_connection_count);
 
2747
 
 
2748
  /* Start a new thread to handle connection. */
 
2749
 
 
2750
  pthread_mutex_lock(&LOCK_thread_count);
 
2751
 
 
2752
  /*
 
2753
    The initialization of thread_id is done in create_embedded_thd() for
 
2754
    the embedded library.
 
2755
    TODO: refactor this to avoid code duplication there
 
2756
  */
 
2757
  thd->thread_id= thd->variables.pseudo_thread_id= thread_id++;
 
2758
 
 
2759
  thread_count++;
 
2760
 
 
2761
  thread_scheduler.add_connection(thd);
 
2762
 
 
2763
  return;;
 
2764
}
 
2765
 
 
2766
 
 
2767
#ifdef SIGNALS_DONT_BREAK_READ
 
2768
inline void kill_broken_server()
 
2769
{
 
2770
  /* hack to get around signals ignored in syscalls for problem OS's */
 
2771
  if ((ip_sock == -1))
 
2772
  {
 
2773
    select_thread_in_use = 0;
 
2774
    /* The following call will never return */
 
2775
    kill_server((void*) DRIZZLE_KILL_SIGNAL);
 
2776
  }
 
2777
}
 
2778
#define MAYBE_BROKEN_SYSCALL kill_broken_server();
 
2779
#else
 
2780
#define MAYBE_BROKEN_SYSCALL
 
2781
#endif
 
2782
 
 
2783
        /* Handle new connections and spawn new process to handle them */
 
2784
 
 
2785
void handle_connections_sockets()
 
2786
{
 
2787
  int x;
 
2788
  int sock,new_sock;
 
2789
  uint32_t error_count=0;
 
2790
  THD *thd;
 
2791
  struct sockaddr_storage cAddr;
 
2792
 
 
2793
  MAYBE_BROKEN_SYSCALL;
 
2794
  while (!abort_loop)
 
2795
  {
 
2796
    int number_of;
 
2797
 
 
2798
    if ((number_of= poll(fds, pollfd_count, -1)) == -1)
 
2799
    {
 
2800
      if (errno != EINTR)
 
2801
      {
 
2802
        if (!select_errors++ && !abort_loop)    /* purecov: inspected */
 
2803
          sql_print_error(_("drizzled: Got error %d from select"),
 
2804
                          errno); /* purecov: inspected */
 
2805
      }
 
2806
      MAYBE_BROKEN_SYSCALL
 
2807
      continue;
 
2808
    }
 
2809
    if (number_of == 0)
 
2810
      continue;
 
2811
 
 
2812
#ifdef FIXME_IF_WE_WERE_KEEPING_THIS
 
2813
    assert(number_of > 1); /* Not handling this at the moment */
 
2814
#endif
 
2815
 
 
2816
    if (abort_loop)
 
2817
    {
 
2818
      MAYBE_BROKEN_SYSCALL;
 
2819
      break;
 
2820
    }
 
2821
 
 
2822
    for (x= 0, sock= -1; x < pollfd_count; x++)
 
2823
    {
 
2824
      if (fds[x].revents == POLLIN)
 
2825
      {
 
2826
        sock= fds[x].fd;
 
2827
        break;
 
2828
      }
 
2829
    }
 
2830
    assert(sock != -1);
 
2831
 
 
2832
    for (uint32_t retry=0; retry < MAX_ACCEPT_RETRY; retry++)
 
2833
    {
 
2834
      SOCKET_SIZE_TYPE length= sizeof(struct sockaddr_storage);
 
2835
      new_sock= accept(sock, (struct sockaddr *)(&cAddr),
 
2836
                       &length);
 
2837
      if (new_sock != -1 || (errno != EINTR && errno != EAGAIN))
 
2838
        break;
 
2839
    }
 
2840
 
 
2841
 
 
2842
    if (new_sock == -1)
 
2843
    {
 
2844
      if ((error_count++ & 255) == 0)           // This can happen often
 
2845
        sql_perror("Error in accept");
 
2846
      MAYBE_BROKEN_SYSCALL;
 
2847
      if (errno == ENFILE || errno == EMFILE)
 
2848
        sleep(1);                               // Give other threads some time
 
2849
      continue;
 
2850
    }
 
2851
 
 
2852
    {
 
2853
      SOCKET_SIZE_TYPE dummyLen;
 
2854
      struct sockaddr_storage dummy;
 
2855
      dummyLen = sizeof(dummy);
 
2856
      if (  getsockname(new_sock,(struct sockaddr *)&dummy,
 
2857
                        (socklen_t *)&dummyLen) < 0  )
 
2858
      {
 
2859
        sql_perror("Error on new connection socket");
 
2860
        (void) shutdown(new_sock, SHUT_RDWR);
 
2861
        (void) close(new_sock);
 
2862
        continue;
 
2863
      }
 
2864
      dummyLen = sizeof(dummy);
 
2865
      if ( getpeername(new_sock, (struct sockaddr *)&dummy,
 
2866
                       (socklen_t *)&dummyLen) < 0)
 
2867
      {
 
2868
        sql_perror("Error on new connection socket");
 
2869
        (void) shutdown(new_sock, SHUT_RDWR);
 
2870
        (void) close(new_sock);
 
2871
         continue;
 
2872
      }
 
2873
    }
 
2874
 
 
2875
    /*
 
2876
    ** Don't allow too many connections
 
2877
    */
 
2878
 
 
2879
    if (!(thd= new THD))
 
2880
    {
 
2881
      (void) shutdown(new_sock, SHUT_RDWR);
 
2882
      close(new_sock);
 
2883
      continue;
 
2884
    }
 
2885
    if (net_init_sock(&thd->net, new_sock, sock == 0))
 
2886
    {
 
2887
      delete thd;
 
2888
      continue;
 
2889
    }
 
2890
 
 
2891
    create_new_thread(thd);
 
2892
  }
 
2893
}
 
2894
 
 
2895
 
1603
2896
/****************************************************************************
1604
2897
  Handle start options
1605
2898
******************************************************************************/
1606
2899
 
1607
 
enum options_drizzled
 
2900
enum options_mysqld
1608
2901
{
1609
 
  OPT_SOCKET=256,
1610
 
  OPT_BIND_ADDRESS,            
1611
 
  OPT_PID_FILE,
1612
 
  OPT_STORAGE_ENGINE,          
1613
 
  OPT_INIT_FILE,
 
2902
  OPT_ISAM_LOG=256,            OPT_SKIP_NEW,
 
2903
  OPT_SKIP_GRANT,
 
2904
  OPT_ENABLE_LOCK,             OPT_USE_LOCKING,
 
2905
  OPT_SOCKET,                  OPT_UPDATE_LOG,
 
2906
  OPT_BIN_LOG,
 
2907
  OPT_BIN_LOG_INDEX,
 
2908
  OPT_BIND_ADDRESS,            OPT_PID_FILE,
 
2909
  OPT_SKIP_PRIOR,
 
2910
  OPT_STANDALONE,
 
2911
  OPT_CONSOLE,                 OPT_LOW_PRIORITY_UPDATES,
 
2912
  OPT_SHORT_LOG_FORMAT,
 
2913
  OPT_FLUSH,                   OPT_SAFE,
 
2914
  OPT_STORAGE_ENGINE,          OPT_INIT_FILE,
 
2915
  OPT_DELAY_KEY_WRITE_ALL,
 
2916
  OPT_DELAY_KEY_WRITE,         OPT_CHARSETS_DIR,
 
2917
  OPT_MASTER_INFO_FILE,
 
2918
  OPT_MASTER_RETRY_COUNT,      OPT_LOG_TC, OPT_LOG_TC_SIZE,
 
2919
  OPT_SQL_BIN_UPDATE_SAME,     OPT_REPLICATE_DO_DB,
 
2920
  OPT_REPLICATE_IGNORE_DB,     OPT_LOG_SLAVE_UPDATES,
 
2921
  OPT_BINLOG_DO_DB,            OPT_BINLOG_IGNORE_DB,
 
2922
  OPT_BINLOG_FORMAT,
 
2923
  OPT_BINLOG_ROWS_EVENT_MAX_SIZE,
1614
2924
  OPT_WANT_CORE,
1615
 
  OPT_MEMLOCK,
1616
 
  OPT_SERVER_ID,
1617
 
  OPT_TC_HEURISTIC_RECOVER,
 
2925
  OPT_MEMLOCK,                 OPT_MYISAM_RECOVER,
 
2926
  OPT_REPLICATE_REWRITE_DB,    OPT_SERVER_ID,
 
2927
  OPT_SKIP_SLAVE_START,
 
2928
  OPT_REPLICATE_DO_TABLE,
 
2929
  OPT_REPLICATE_IGNORE_TABLE,  OPT_REPLICATE_WILD_DO_TABLE,
 
2930
  OPT_REPLICATE_WILD_IGNORE_TABLE, OPT_REPLICATE_SAME_SERVER_ID,
 
2931
  OPT_DISCONNECT_SLAVE_EVENT_COUNT, OPT_TC_HEURISTIC_RECOVER,
 
2932
  OPT_ABORT_SLAVE_EVENT_COUNT,
 
2933
  OPT_ENGINE_CONDITION_PUSHDOWN,
1618
2934
  OPT_TEMP_POOL, OPT_TX_ISOLATION, OPT_COMPLETION_TYPE,
1619
2935
  OPT_SKIP_STACK_TRACE, OPT_SKIP_SYMLINKS,
1620
 
  OPT_DO_PSTACK,
1621
 
  OPT_LOCAL_INFILE,
1622
 
  OPT_BACK_LOG,
1623
 
  OPT_JOIN_BUFF_SIZE,
1624
 
  OPT_MAX_ALLOWED_PACKET,
1625
 
  OPT_MAX_CONNECT_ERRORS,
 
2936
  OPT_MAX_BINLOG_DUMP_EVENTS, OPT_SPORADIC_BINLOG_DUMP_FAIL,
 
2937
  OPT_SAFE_USER_CREATE,
 
2938
  OPT_DO_PSTACK, OPT_REPORT_HOST,
 
2939
  OPT_REPORT_USER, OPT_REPORT_PASSWORD, OPT_REPORT_PORT,
 
2940
  OPT_SHOW_SLAVE_AUTH_INFO,
 
2941
  OPT_SLAVE_LOAD_TMPDIR, OPT_NO_MIX_TYPE,
 
2942
  OPT_RPL_RECOVERY_RANK,
 
2943
  OPT_RELAY_LOG, OPT_RELAY_LOG_INDEX, OPT_RELAY_LOG_INFO_FILE,
 
2944
  OPT_SLAVE_SKIP_ERRORS, OPT_SLAVE_ALLOW_BATCHING, OPT_DES_KEY_FILE, OPT_LOCAL_INFILE,
 
2945
  OPT_SSL_SSL, OPT_SSL_KEY, OPT_SSL_CERT, OPT_SSL_CA,
 
2946
  OPT_SSL_CAPATH, OPT_SSL_CIPHER,
 
2947
  OPT_BACK_LOG, OPT_BINLOG_CACHE_SIZE,
 
2948
  OPT_CONNECT_TIMEOUT,
 
2949
  OPT_FLUSH_TIME,
 
2950
  OPT_INTERACTIVE_TIMEOUT, OPT_JOIN_BUFF_SIZE,
 
2951
  OPT_KEY_BUFFER_SIZE, OPT_KEY_CACHE_BLOCK_SIZE,
 
2952
  OPT_KEY_CACHE_DIVISION_LIMIT, OPT_KEY_CACHE_AGE_THRESHOLD,
 
2953
  OPT_LONG_QUERY_TIME,
 
2954
  OPT_LOWER_CASE_TABLE_NAMES, OPT_MAX_ALLOWED_PACKET,
 
2955
  OPT_MAX_BINLOG_CACHE_SIZE, OPT_MAX_BINLOG_SIZE,
 
2956
  OPT_MAX_CONNECTIONS, OPT_MAX_CONNECT_ERRORS,
1626
2957
  OPT_MAX_HEP_TABLE_SIZE,
1627
2958
  OPT_MAX_JOIN_SIZE,
1628
 
  OPT_MAX_SORT_LENGTH,
 
2959
  OPT_MAX_RELAY_LOG_SIZE, OPT_MAX_SORT_LENGTH,
1629
2960
  OPT_MAX_SEEKS_FOR_KEY, OPT_MAX_TMP_TABLES, OPT_MAX_USER_CONNECTIONS,
1630
2961
  OPT_MAX_LENGTH_FOR_SORT_DATA,
1631
2962
  OPT_MAX_WRITE_LOCK_COUNT, OPT_BULK_INSERT_BUFFER_SIZE,
1633
2964
  OPT_MYISAM_BLOCK_SIZE, OPT_MYISAM_MAX_EXTRA_SORT_FILE_SIZE,
1634
2965
  OPT_MYISAM_MAX_SORT_FILE_SIZE, OPT_MYISAM_SORT_BUFFER_SIZE,
1635
2966
  OPT_MYISAM_USE_MMAP, OPT_MYISAM_REPAIR_THREADS,
1636
 
  OPT_NET_BUFFER_LENGTH,
 
2967
  OPT_MYISAM_STATS_METHOD,
 
2968
  OPT_NET_BUFFER_LENGTH, OPT_NET_RETRY_COUNT,
 
2969
  OPT_NET_READ_TIMEOUT, OPT_NET_WRITE_TIMEOUT,
 
2970
  OPT_OPEN_FILES_LIMIT,
1637
2971
  OPT_PRELOAD_BUFFER_SIZE,
1638
2972
  OPT_RECORD_BUFFER,
1639
 
  OPT_RECORD_RND_BUFFER, OPT_DIV_PRECINCREMENT,
1640
 
  OPT_DEBUGGING,
 
2973
  OPT_RECORD_RND_BUFFER, OPT_DIV_PRECINCREMENT, OPT_RELAY_LOG_SPACE_LIMIT,
 
2974
  OPT_RELAY_LOG_PURGE,
 
2975
  OPT_SLAVE_NET_TIMEOUT, OPT_SLAVE_COMPRESSED_PROTOCOL, OPT_SLOW_LAUNCH_TIME,
 
2976
  OPT_SLAVE_TRANS_RETRIES, OPT_READONLY, OPT_DEBUGGING,
1641
2977
  OPT_SORT_BUFFER, OPT_TABLE_OPEN_CACHE, OPT_TABLE_DEF_CACHE,
 
2978
  OPT_THREAD_CONCURRENCY, OPT_THREAD_CACHE_SIZE,
1642
2979
  OPT_TMP_TABLE_SIZE, OPT_THREAD_STACK,
1643
2980
  OPT_WAIT_TIMEOUT,
 
2981
  OPT_ERROR_LOG_FILE,
 
2982
  OPT_DEFAULT_WEEK_FORMAT,
1644
2983
  OPT_RANGE_ALLOC_BLOCK_SIZE,
1645
2984
  OPT_QUERY_ALLOC_BLOCK_SIZE, OPT_QUERY_PREALLOC_SIZE,
1646
2985
  OPT_TRANS_ALLOC_BLOCK_SIZE, OPT_TRANS_PREALLOC_SIZE,
 
2986
  OPT_SYNC_FRM, OPT_SYNC_BINLOG,
 
2987
  OPT_SYNC_REPLICATION,
 
2988
  OPT_SYNC_REPLICATION_SLAVE_ID,
 
2989
  OPT_SYNC_REPLICATION_TIMEOUT,
 
2990
  OPT_ENABLE_SHARED_MEMORY,
 
2991
  OPT_SHARED_MEMORY_BASE_NAME,
1647
2992
  OPT_OLD_ALTER_TABLE,
 
2993
  OPT_EXPIRE_LOGS_DAYS,
1648
2994
  OPT_GROUP_CONCAT_MAX_LEN,
1649
2995
  OPT_DEFAULT_COLLATION,
 
2996
  OPT_CHARACTER_SET_CLIENT_HANDSHAKE,
1650
2997
  OPT_CHARACTER_SET_FILESYSTEM,
1651
2998
  OPT_LC_TIME_NAMES,
1652
2999
  OPT_INIT_CONNECT,
 
3000
  OPT_INIT_SLAVE,
 
3001
  OPT_SECURE_AUTH,
 
3002
  OPT_DATE_FORMAT,
 
3003
  OPT_TIME_FORMAT,
 
3004
  OPT_DATETIME_FORMAT,
1653
3005
  OPT_DEFAULT_TIME_ZONE,
 
3006
  OPT_SYSDATE_IS_NOW,
1654
3007
  OPT_OPTIMIZER_SEARCH_DEPTH,
1655
 
  OPT_SCHEDULER,
1656
 
  OPT_PROTOCOL,
1657
3008
  OPT_OPTIMIZER_PRUNE_LEVEL,
 
3009
  OPT_UPDATABLE_VIEWS_WITH_LIMIT,
1658
3010
  OPT_AUTO_INCREMENT, OPT_AUTO_INCREMENT_OFFSET,
1659
3011
  OPT_ENABLE_LARGE_PAGES,
1660
3012
  OPT_TIMED_MUTEXES,
 
3013
  OPT_OLD_STYLE_USER_LIMITS,
1661
3014
  OPT_TABLE_LOCK_WAIT_TIMEOUT,
1662
 
  OPT_PLUGIN_ADD,
1663
 
  OPT_PLUGIN_REMOVE,
1664
3015
  OPT_PLUGIN_LOAD,
1665
3016
  OPT_PLUGIN_DIR,
1666
3017
  OPT_PORT_OPEN_TIMEOUT,
 
3018
  OPT_PROFILING,
 
3019
  OPT_KEEP_FILES_ON_CREATE,
 
3020
  OPT_GENERAL_LOG,
 
3021
  OPT_THREAD_HANDLING,
 
3022
  OPT_INNODB_ROLLBACK_ON_TIMEOUT,
1667
3023
  OPT_SECURE_FILE_PRIV,
1668
3024
  OPT_MIN_EXAMINED_ROW_LIMIT,
1669
 
  OPT_PRINT_DEFAULTS
 
3025
  OPT_OLD_MODE,
 
3026
  OPT_POOL_OF_THREADS,
 
3027
  OPT_SLAVE_EXEC_MODE
1670
3028
};
1671
3029
 
1672
3030
 
1673
 
struct option my_long_options[] =
 
3031
#define LONG_TIMEOUT ((uint32_t) 3600L*24L*365L)
 
3032
 
 
3033
struct my_option my_long_options[] =
1674
3034
{
1675
 
 
1676
3035
  {"help", '?', N_("Display this help and exit."),
1677
3036
   (char**) &opt_help, (char**) &opt_help, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
1678
3037
   0, 0},
1679
 
  {"help-extended", '?',
1680
 
   N_("Display this help and exit after initializing plugins."),
1681
 
   (char**) &opt_help_extended, (char**) &opt_help_extended,
1682
 
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
3038
  {"abort-slave-event-count", OPT_ABORT_SLAVE_EVENT_COUNT,
 
3039
   N_("Option used by mysql-test for debugging and testing of replication."),
 
3040
   (char**) &abort_slave_event_count,  (char**) &abort_slave_event_count,
 
3041
   0, GET_INT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
1683
3042
  {"auto-increment-increment", OPT_AUTO_INCREMENT,
1684
3043
   N_("Auto-increment columns are incremented by this"),
1685
3044
   (char**) &global_system_variables.auto_increment_increment,
1686
 
   (char**) &max_system_variables.auto_increment_increment, 0, GET_ULL,
1687
 
   OPT_ARG, 1, 1, UINT64_MAX, 0, 1, 0 },
 
3045
   (char**) &max_system_variables.auto_increment_increment, 0, GET_ULONG,
 
3046
   OPT_ARG, 1, 1, 65535, 0, 1, 0 },
1688
3047
  {"auto-increment-offset", OPT_AUTO_INCREMENT_OFFSET,
1689
3048
   N_("Offset added to Auto-increment columns. Used when "
1690
3049
      "auto-increment-increment != 1"),
1691
3050
   (char**) &global_system_variables.auto_increment_offset,
1692
 
   (char**) &max_system_variables.auto_increment_offset, 0, GET_ULL, OPT_ARG,
1693
 
   1, 1, UINT64_MAX, 0, 1, 0 },
 
3051
   (char**) &max_system_variables.auto_increment_offset, 0, GET_ULONG, OPT_ARG,
 
3052
   1, 1, 65535, 0, 1, 0 },
1694
3053
  {"basedir", 'b',
1695
3054
   N_("Path to installation directory. All paths are usually resolved "
1696
3055
      "relative to this."),
1697
 
   (char**) &drizzle_home_ptr, (char**) &drizzle_home_ptr, 0, GET_STR, REQUIRED_ARG,
 
3056
   (char**) &mysql_home_ptr, (char**) &mysql_home_ptr, 0, GET_STR, REQUIRED_ARG,
1698
3057
   0, 0, 0, 0, 0, 0},
 
3058
  {"bind-address", OPT_BIND_ADDRESS, N_("IP address to bind to."),
 
3059
   (char**) &my_bind_addr_str, (char**) &my_bind_addr_str, 0, GET_STR,
 
3060
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3061
  {"binlog_format", OPT_BINLOG_FORMAT,
 
3062
   N_("Does not have any effect without '--log-bin'. "
 
3063
      "Tell the master the form of binary logging to use: either 'row' for "
 
3064
      "row-based binary logging, or 'statement' for statement-based binary "
 
3065
      "logging, or 'mixed'. 'mixed' is statement-based binary logging except "
 
3066
      "for those statements where only row-based is correct: those which "
 
3067
      "involve user-defined functions (i.e. UDFs) or the UUID() function; for "
 
3068
      "those, row-based binary logging is automatically used. ")
 
3069
   ,(char**) &opt_binlog_format, (char**) &opt_binlog_format,
 
3070
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3071
  {"binlog-do-db", OPT_BINLOG_DO_DB,
 
3072
   N_("Tells the master it should log updates for the specified database, and "
 
3073
      "exclude all others not explicitly mentioned."),
 
3074
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3075
  {"binlog-ignore-db", OPT_BINLOG_IGNORE_DB,
 
3076
   N_("Tells the master that updates to the given database should not "
 
3077
      "be logged tothe binary log."),
 
3078
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3079
  {"binlog-row-event-max-size", OPT_BINLOG_ROWS_EVENT_MAX_SIZE,
 
3080
   N_("The maximum size of a row-based binary log event in bytes. Rows will "
 
3081
      "be grouped into events smaller than this size if possible. "
 
3082
      "The value has to be a multiple of 256."),
 
3083
   (char**) &opt_binlog_rows_event_max_size,
 
3084
   (char**) &opt_binlog_rows_event_max_size, 0,
 
3085
   GET_ULONG, REQUIRED_ARG,
 
3086
   /* def_value */ 1024, /* min_value */  256, /* max_value */ ULONG_MAX,
 
3087
   /* sub_size */     0, /* block_size */ 256,
 
3088
   /* app_type */ 0
 
3089
  },
 
3090
  {"character-set-client-handshake", OPT_CHARACTER_SET_CLIENT_HANDSHAKE,
 
3091
   N_("Don't ignore client side character set value sent during handshake."),
 
3092
   (char**) &opt_character_set_client_handshake,
 
3093
   (char**) &opt_character_set_client_handshake,
 
3094
    0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0},
 
3095
  {"character-set-filesystem", OPT_CHARACTER_SET_FILESYSTEM,
 
3096
   N_("Set the filesystem character set."),
 
3097
   (char**) &character_set_filesystem_name,
 
3098
   (char**) &character_set_filesystem_name,
 
3099
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
 
3100
  {"character-set-server", 'C',
 
3101
   N_("Set the default character set."),
 
3102
   (char**) &default_character_set_name, (char**) &default_character_set_name,
 
3103
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
 
3104
  {"character-sets-dir", OPT_CHARSETS_DIR,
 
3105
   N_("Directory where character sets are."), (char**) &charsets_dir,
 
3106
   (char**) &charsets_dir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
1699
3107
  {"chroot", 'r',
1700
 
   N_("Chroot drizzled daemon during startup."),
1701
 
   (char**) &drizzled_chroot, (char**) &drizzled_chroot, 0, GET_STR, REQUIRED_ARG,
 
3108
   N_("Chroot mysqld daemon during startup."),
 
3109
   (char**) &mysqld_chroot, (char**) &mysqld_chroot, 0, GET_STR, REQUIRED_ARG,
1702
3110
   0, 0, 0, 0, 0, 0},
1703
3111
  {"collation-server", OPT_DEFAULT_COLLATION,
1704
3112
   N_("Set the default collation."),
1707
3115
  {"completion-type", OPT_COMPLETION_TYPE,
1708
3116
   N_("Default completion type."),
1709
3117
   (char**) &global_system_variables.completion_type,
1710
 
   (char**) &max_system_variables.completion_type, 0, GET_UINT,
 
3118
   (char**) &max_system_variables.completion_type, 0, GET_ULONG,
1711
3119
   REQUIRED_ARG, 0, 0, 2, 0, 1, 0},
 
3120
  {"console", OPT_CONSOLE,
 
3121
   N_("Write error output on screen."),
 
3122
   (char**) &opt_console, (char**) &opt_console, 0, GET_BOOL, NO_ARG, 0, 0, 0,
 
3123
   0, 0, 0},
1712
3124
  {"core-file", OPT_WANT_CORE,
1713
3125
   N_("Write core on errors."),
1714
3126
   0, 0, 0, GET_NO_ARG,
1715
3127
   NO_ARG, 0, 0, 0, 0, 0, 0},
1716
3128
  {"datadir", 'h',
1717
3129
   N_("Path to the database root."),
1718
 
   NULL, NULL, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3130
   (char**) &mysql_data_home,
 
3131
   (char**) &mysql_data_home, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
1719
3132
  {"default-storage-engine", OPT_STORAGE_ENGINE,
1720
3133
   N_("Set the default storage engine (table type) for tables."),
1721
3134
   (char**)&default_storage_engine_str, (char**)&default_storage_engine_str,
1724
3137
   N_("Set the default time zone."),
1725
3138
   (char**) &default_tz_name, (char**) &default_tz_name,
1726
3139
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
 
3140
  {"delay-key-write", OPT_DELAY_KEY_WRITE,
 
3141
   N_("Type of DELAY_KEY_WRITE."),
 
3142
   0,0,0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
 
3143
  {"disconnect-slave-event-count", OPT_DISCONNECT_SLAVE_EVENT_COUNT,
 
3144
   N_("Option used by mysql-test for debugging and testing of replication."),
 
3145
   (char**) &disconnect_slave_event_count,
 
3146
   (char**) &disconnect_slave_event_count, 0, GET_INT, REQUIRED_ARG, 0, 0, 0,
 
3147
   0, 0, 0},
 
3148
#ifdef HAVE_STACK_TRACE_ON_SEGV
 
3149
  {"enable-pstack", OPT_DO_PSTACK,
 
3150
   N_("Print a symbolic stack trace on failure."),
 
3151
   (char**) &opt_do_pstack, (char**) &opt_do_pstack, 0, GET_BOOL, NO_ARG, 0, 0,
 
3152
   0, 0, 0, 0},
 
3153
#endif /* HAVE_STACK_TRACE_ON_SEGV */
 
3154
  {"engine-condition-pushdown",
 
3155
   OPT_ENGINE_CONDITION_PUSHDOWN,
 
3156
   N_("Push supported query conditions to the storage engine."),
 
3157
   (char**) &global_system_variables.engine_condition_pushdown,
 
3158
   (char**) &global_system_variables.engine_condition_pushdown,
 
3159
   0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0},
1727
3160
  /* See how it's handled in get_one_option() */
1728
3161
  {"exit-info", 'T',
1729
3162
   N_("Used for debugging;  Use at your own risk!"),
1730
3163
   0, 0, 0, GET_LONG, OPT_ARG, 0, 0, 0, 0, 0, 0},
 
3164
  {"flush", OPT_FLUSH,
 
3165
   N_("Flush tables to disk between SQL commands."),
 
3166
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
1731
3167
  /* We must always support the next option to make scripts like mysqltest
1732
3168
     easier to do */
1733
3169
  {"gdb", OPT_DEBUGGING,
1734
3170
   N_("Set up signals usable for debugging"),
1735
3171
   (char**) &opt_debugging, (char**) &opt_debugging,
1736
3172
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
3173
  {"init-connect", OPT_INIT_CONNECT,
 
3174
   N_("Command(s) that are executed for each new connection"),
 
3175
   (char**) &opt_init_connect, (char**) &opt_init_connect, 0, GET_STR_ALLOC,
 
3176
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3177
  {"init-file", OPT_INIT_FILE,
 
3178
   N_("Read SQL commands from this file at startup."),
 
3179
   (char**) &opt_init_file, (char**) &opt_init_file, 0, GET_STR, REQUIRED_ARG,
 
3180
   0, 0, 0, 0, 0, 0},
 
3181
  {"init-slave", OPT_INIT_SLAVE,
 
3182
   N_("Command(s) that are executed when a slave connects to this master"),
 
3183
   (char**) &opt_init_slave, (char**) &opt_init_slave, 0, GET_STR_ALLOC,
 
3184
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
1737
3185
  {"language", 'L',
1738
3186
   N_("(IGNORED)"),
1739
3187
   (char**) &language_ptr, (char**) &language_ptr, 0, GET_STR, REQUIRED_ARG,
1743
3191
   (char**) &lc_time_names_name,
1744
3192
   (char**) &lc_time_names_name,
1745
3193
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
 
3194
  {"local-infile", OPT_LOCAL_INFILE,
 
3195
   N_("Enable/disable LOAD DATA LOCAL INFILE (takes values 1|0)."),
 
3196
   (char**) &opt_local_infile,
 
3197
   (char**) &opt_local_infile, 0, GET_BOOL, OPT_ARG,
 
3198
   1, 0, 0, 0, 0, 0},
 
3199
  {"log", 'l',
 
3200
   N_("Log connections and queries to file."),
 
3201
   (char**) &opt_logname,
 
3202
   (char**) &opt_logname, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
 
3203
  {"log-bin", OPT_BIN_LOG,
 
3204
   N_("Log update queries in binary format. Optional argument is the "
 
3205
      "location for the binary log files.(Strongly "
 
3206
      "recommended to avoid replication problems if server's hostname "
 
3207
      "changes)"),
 
3208
   (char**) &opt_bin_logname, (char**) &opt_bin_logname, 0, GET_STR_ALLOC,
 
3209
   OPT_ARG, 0, 0, 0, 0, 0, 0},
 
3210
  {"log-bin-index", OPT_BIN_LOG_INDEX,
 
3211
   N_("File that holds the names for last binary log files."),
 
3212
   (char**) &opt_binlog_index_name, (char**) &opt_binlog_index_name, 0, GET_STR,
 
3213
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3214
  {"log-error", OPT_ERROR_LOG_FILE,
 
3215
   N_("Error log file."),
 
3216
   (char**) &log_error_file_ptr, (char**) &log_error_file_ptr, 0, GET_STR,
 
3217
   OPT_ARG, 0, 0, 0, 0, 0, 0},
 
3218
  {"log-isam", OPT_ISAM_LOG,
 
3219
   N_("Log all MyISAM changes to file."),
 
3220
   (char**) &myisam_log_filename, (char**) &myisam_log_filename, 0, GET_STR,
 
3221
   OPT_ARG, 0, 0, 0, 0, 0, 0},
 
3222
  {"log-slave-updates", OPT_LOG_SLAVE_UPDATES,
 
3223
   N_("Tells the slave to log the updates from the slave thread to the binary "
 
3224
      "log. You will need to turn it on if you plan to "
 
3225
      "daisy-chain the slaves."),
 
3226
   (char**) &opt_log_slave_updates, (char**) &opt_log_slave_updates,
 
3227
   0, GET_BOOL,
 
3228
   NO_ARG, 0, 0, 0, 0, 0, 0},
 
3229
  {"log-tc", OPT_LOG_TC,
 
3230
   N_("Path to transaction coordinator log (used for transactions that affect "
 
3231
      "more than one storage engine, when binary log is disabled)"),
 
3232
   (char**) &opt_tc_log_file, (char**) &opt_tc_log_file, 0, GET_STR,
 
3233
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3234
#ifdef HAVE_MMAP
 
3235
  {"log-tc-size", OPT_LOG_TC_SIZE,
 
3236
   N_("Size of transaction coordinator log."),
 
3237
   (char**) &opt_tc_log_size, (char**) &opt_tc_log_size, 0, GET_ULONG,
 
3238
   REQUIRED_ARG, TC_LOG_MIN_SIZE, TC_LOG_MIN_SIZE, ULONG_MAX, 0,
 
3239
   TC_LOG_PAGE_SIZE, 0},
 
3240
#endif
1746
3241
  {"log-warnings", 'W',
1747
3242
   N_("Log some not critical warnings to the log file."),
1748
3243
   (char**) &global_system_variables.log_warnings,
1749
 
   (char**) &max_system_variables.log_warnings, 0, GET_BOOL, OPT_ARG, 1, 0, 0,
 
3244
   (char**) &max_system_variables.log_warnings, 0, GET_ULONG, OPT_ARG, 1, 0, 0,
1750
3245
   0, 0, 0},
 
3246
  {"low-priority-updates", OPT_LOW_PRIORITY_UPDATES,
 
3247
   N_("INSERT/DELETE/UPDATE has lower priority than selects."),
 
3248
   (char**) &global_system_variables.low_priority_updates,
 
3249
   (char**) &max_system_variables.low_priority_updates,
 
3250
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
3251
  {"master-info-file", OPT_MASTER_INFO_FILE,
 
3252
   N_("The location and name of the file that remembers the master and "
 
3253
      "where the I/O replication thread is in the master's binlogs."),
 
3254
   (char**) &master_info_file, (char**) &master_info_file, 0, GET_STR,
 
3255
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3256
  {"master-retry-count", OPT_MASTER_RETRY_COUNT,
 
3257
   N_("The number of tries the slave will make to connect to the master "
 
3258
      "before giving up."),
 
3259
   (char**) &master_retry_count, (char**) &master_retry_count, 0, GET_ULONG,
 
3260
   REQUIRED_ARG, 3600*24, 0, 0, 0, 0, 0},
 
3261
  {"max-binlog-dump-events", OPT_MAX_BINLOG_DUMP_EVENTS,
 
3262
   N_("Option used by mysql-test for debugging and testing of replication."),
 
3263
   (char**) &max_binlog_dump_events, (char**) &max_binlog_dump_events, 0,
 
3264
   GET_INT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3265
  {"memlock", OPT_MEMLOCK,
 
3266
   N_("Lock mysqld in memory."),
 
3267
   (char**) &locked_in_memory,
 
3268
   (char**) &locked_in_memory, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
3269
  {"myisam-recover", OPT_MYISAM_RECOVER,
 
3270
   N_("Syntax: myisam-recover[=option[,option...]], where option can be "
 
3271
      "DEFAULT, BACKUP, FORCE or QUICK."),
 
3272
   (char**) &myisam_recover_options_str, (char**) &myisam_recover_options_str, 0,
 
3273
   GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
 
3274
  {"new", 'n',
 
3275
   N_("Use very new possible 'unsafe' functions."),
 
3276
   (char**) &global_system_variables.new_mode,
 
3277
   (char**) &max_system_variables.new_mode,
 
3278
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
3279
  {"old-alter-table", OPT_OLD_ALTER_TABLE,
 
3280
   N_("Use old, non-optimized alter table."),
 
3281
   (char**) &global_system_variables.old_alter_table,
 
3282
   (char**) &max_system_variables.old_alter_table, 0, GET_BOOL, NO_ARG,
 
3283
   0, 0, 0, 0, 0, 0},
 
3284
  {"old-style-user-limits", OPT_OLD_STYLE_USER_LIMITS,
 
3285
   N_("Enable old-style user limits (before 5.0.3 user resources were counted "
 
3286
      "per each user+host vs. per account)"),
 
3287
   (char**) &opt_old_style_user_limits, (char**) &opt_old_style_user_limits,
 
3288
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
1751
3289
  {"pid-file", OPT_PID_FILE,
1752
 
   N_("Pid file used by drizzled."),
 
3290
   N_("Pid file used by safe_mysqld."),
1753
3291
   (char**) &pidfile_name_ptr, (char**) &pidfile_name_ptr, 0, GET_STR,
1754
3292
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3293
  {"port", 'P',
 
3294
   N_("Port number to use for connection or 0 for default to, in "
 
3295
      "order of preference, my.cnf, $DRIZZLE_TCP_PORT, "
 
3296
      "built-in default (" STRINGIFY_ARG(DRIZZLE_PORT) ")."),
 
3297
   (char**) &mysqld_port,
 
3298
   (char**) &mysqld_port, 0, GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
1755
3299
  {"port-open-timeout", OPT_PORT_OPEN_TIMEOUT,
1756
3300
   N_("Maximum time in seconds to wait for the port to become free. "
1757
3301
      "(Default: no wait)"),
1758
 
   (char**) &drizzled_bind_timeout,
1759
 
   (char**) &drizzled_bind_timeout, 0, GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3302
   (char**) &mysqld_port_timeout,
 
3303
   (char**) &mysqld_port_timeout, 0, GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3304
  {"relay-log", OPT_RELAY_LOG,
 
3305
   N_("The location and name to use for relay logs."),
 
3306
   (char**) &opt_relay_logname, (char**) &opt_relay_logname, 0,
 
3307
   GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3308
  {"relay-log-index", OPT_RELAY_LOG_INDEX,
 
3309
   N_("The location and name to use for the file that keeps a list of the "
 
3310
      "last relay logs."),
 
3311
   (char**) &opt_relaylog_index_name, (char**) &opt_relaylog_index_name, 0,
 
3312
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3313
  {"relay-log-info-file", OPT_RELAY_LOG_INFO_FILE,
 
3314
   N_("The location and name of the file that remembers where the SQL "
 
3315
      "replication thread is in the relay logs."),
 
3316
   (char**) &relay_log_info_file, (char**) &relay_log_info_file, 0, GET_STR,
 
3317
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3318
  {"replicate-do-db", OPT_REPLICATE_DO_DB,
 
3319
   N_("Tells the slave thread to restrict replication to the specified "
 
3320
      "database. To specify more than one database, use the directive "
 
3321
      "multiple times, once for each database. Note that this will only work "
 
3322
      "if you do not use cross-database queries such as UPDATE "
 
3323
      "some_db.some_table SET foo='bar' while having selected a different or "
 
3324
      "no database. If you need cross database updates to work, use "
 
3325
      "replicate-wild-do-table=db_name.%."),
 
3326
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3327
  {"replicate-do-table", OPT_REPLICATE_DO_TABLE,
 
3328
   N_("Tells the slave thread to restrict replication to the specified table. "
 
3329
      "To specify more than one table, use the directive multiple times, once "
 
3330
      "for each table. This will work for cross-database updates, in contrast "
 
3331
      "to replicate-do-db."),
 
3332
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3333
  {"replicate-ignore-db", OPT_REPLICATE_IGNORE_DB,
 
3334
   N_("Tells the slave thread to not replicate to the specified database. To "
 
3335
      "specify more than one database to ignore, use the directive multiple "
 
3336
      "times, once for each database. This option will not work if you use "
 
3337
      "cross database updates. If you need cross database updates to work, "
 
3338
      "use replicate-wild-ignore-table=db_name.%. "),
 
3339
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3340
  {"replicate-ignore-table", OPT_REPLICATE_IGNORE_TABLE,
 
3341
   N_("Tells the slave thread to not replicate to the specified table. To "
 
3342
      "specify more than one table to ignore, use the directive multiple "
 
3343
      "times, once for each table. This will work for cross-datbase updates, "
 
3344
      "in contrast to replicate-ignore-db."),
 
3345
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3346
  {"replicate-rewrite-db", OPT_REPLICATE_REWRITE_DB,
 
3347
   N_("Updates to a database with a different name than the original. "
 
3348
      "Example: replicate-rewrite-db=master_db_name->slave_db_name."),
 
3349
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3350
  {"replicate-same-server-id", OPT_REPLICATE_SAME_SERVER_ID,
 
3351
   N_("In replication, if set to 1, do not skip events having our server id. "
 
3352
      "Default value is 0 (to break infinite loops in circular replication). "
 
3353
      "Can't be set to 1 if --log-slave-updates is used."),
 
3354
   (char**) &replicate_same_server_id,
 
3355
   (char**) &replicate_same_server_id,
 
3356
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
 
3357
  {"replicate-wild-do-table", OPT_REPLICATE_WILD_DO_TABLE,
 
3358
   N_("Tells the slave thread to restrict replication to the tables that "
 
3359
      "match the specified wildcard pattern. To specify more than one table, "
 
3360
      "use the directive multiple times, once for each table. This will work "
 
3361
      "for cross-database updates. Example: replicate-wild-do-table=foo%.bar% "
 
3362
      "will replicate only updates to tables in all databases that start with "
 
3363
      "foo and whose table names start with bar."),
 
3364
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3365
  {"replicate-wild-ignore-table", OPT_REPLICATE_WILD_IGNORE_TABLE,
 
3366
   N_("Tells the slave thread to not replicate to the tables that match the "
 
3367
      "given wildcard pattern. To specify more than one table to ignore, use "
 
3368
      "the directive multiple times, once for each table. This will work for "
 
3369
      "cross-database updates. Example: replicate-wild-ignore-table=foo%.bar% "
 
3370
      "will not do updates to tables in databases that start with foo and "
 
3371
      "whose table names start with bar."),
 
3372
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3373
  // In replication, we may need to tell the other servers how to connect
 
3374
  {"report-host", OPT_REPORT_HOST,
 
3375
   N_("Hostname or IP of the slave to be reported to to the master during "
 
3376
      "slave registration. Will appear in the output of SHOW SLAVE HOSTS. "
 
3377
      "Leave unset if you do not want the slave to register itself with the "
 
3378
      "master. Note that it is not sufficient for the master to simply read "
 
3379
      "the IP of the slave off the socket once the slave connects. Due to NAT "
 
3380
      "and other routing issues, that IP may not be valid for connecting to "
 
3381
      "the slave from the master or other hosts."),
 
3382
   (char**) &report_host, (char**) &report_host, 0, GET_STR, REQUIRED_ARG, 0, 0,
 
3383
   0, 0, 0, 0},
 
3384
  {"report-password", OPT_REPORT_PASSWORD, "Undocumented.",
 
3385
   (char**) &report_password, (char**) &report_password, 0, GET_STR,
 
3386
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3387
  {"report-port", OPT_REPORT_PORT,
 
3388
   N_("Port for connecting to slave reported to the master during slave "
 
3389
      "registration. Set it only if the slave is listening on a non-default "
 
3390
      "port or if you have a special tunnel from the master or other clients "
 
3391
      "to the slave. If not sure, leave this option unset."),
 
3392
   (char**) &report_port, (char**) &report_port, 0, GET_UINT, REQUIRED_ARG,
 
3393
   DRIZZLE_PORT, 0, 0, 0, 0, 0},
 
3394
  {"safe-mode", OPT_SAFE,
 
3395
   N_("Skip some optimize stages (for testing)."),
 
3396
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
1760
3397
  {"secure-file-priv", OPT_SECURE_FILE_PRIV,
1761
3398
   N_("Limit LOAD DATA, SELECT ... OUTFILE, and LOAD_FILE() to files "
1762
3399
      "within specified directory"),
1765
3402
  {"server-id", OPT_SERVER_ID,
1766
3403
   N_("Uniquely identifies the server instance in the community of "
1767
3404
      "replication partners."),
1768
 
   (char**) &server_id, (char**) &server_id, 0, GET_UINT32, REQUIRED_ARG, 0, 0, 0,
 
3405
   (char**) &server_id, (char**) &server_id, 0, GET_ULONG, REQUIRED_ARG, 0, 0, 0,
1769
3406
   0, 0, 0},
 
3407
  {"skip-new", OPT_SKIP_NEW,
 
3408
   N_("Don't use new, possible wrong routines."),
 
3409
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
 
3410
  {"skip-slave-start", OPT_SKIP_SLAVE_START,
 
3411
   N_("If set, slave is not autostarted."),
 
3412
   (char**) &opt_skip_slave_start,
 
3413
   (char**) &opt_skip_slave_start, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
1770
3414
  {"skip-stack-trace", OPT_SKIP_STACK_TRACE,
1771
3415
   N_("Don't print a stack trace on failure."),
1772
3416
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0,
1773
3417
   0, 0, 0, 0},
 
3418
  {"skip-thread-priority", OPT_SKIP_PRIOR,
 
3419
   N_("Don't give threads different priorities."),
 
3420
   0, 0, 0, GET_NO_ARG, NO_ARG,
 
3421
   DEFAULT_SKIP_THREAD_PRIORITY, 0, 0, 0, 0, 0},
 
3422
  {"slave-load-tmpdir", OPT_SLAVE_LOAD_TMPDIR,
 
3423
   N_("The location where the slave should put its temporary files when "
 
3424
      "replicating a LOAD DATA INFILE command."),
 
3425
   (char**) &slave_load_tmpdir, (char**) &slave_load_tmpdir, 0, GET_STR_ALLOC,
 
3426
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3427
  {"slave-skip-errors", OPT_SLAVE_SKIP_ERRORS,
 
3428
   N_("Tells the slave thread to continue replication when a query event "
 
3429
      "returns an error from the provided list."),
 
3430
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3431
  {"slave-exec-mode", OPT_SLAVE_EXEC_MODE,
 
3432
   N_("Modes for how replication events should be executed.  Legal values are "
 
3433
      "STRICT (default) and IDEMPOTENT. In IDEMPOTENT mode, replication will "
 
3434
      "not stop for operations that are idempotent. In STRICT mode, "
 
3435
      "replication will stop on any unexpected difference between the master "
 
3436
      "and the slave."),
 
3437
   (char**) &slave_exec_mode_str, (char**) &slave_exec_mode_str,
 
3438
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3439
  {"sql-bin-update-same", OPT_SQL_BIN_UPDATE_SAME,
 
3440
   N_("(INGORED)"),
 
3441
   0, 0, 0, GET_DISABLED, NO_ARG, 0, 0, 0, 0, 0, 0},
1774
3442
  {"symbolic-links", 's',
1775
3443
   N_("Enable symbolic link support."),
1776
 
   (char**) &internal::my_use_symdir, (char**) &internal::my_use_symdir, 0, GET_BOOL, NO_ARG,
 
3444
   (char**) &my_use_symdir, (char**) &my_use_symdir, 0, GET_BOOL, NO_ARG,
1777
3445
   /*
1778
3446
     The system call realpath() produces warnings under valgrind and
1779
3447
     purify. These are not suppressed: instead we disable symlinks
1780
3448
     option if compiled with valgrind support.
1781
3449
   */
1782
3450
   IF_PURIFY(0,1), 0, 0, 0, 0, 0},
 
3451
  {"sysdate-is-now", OPT_SYSDATE_IS_NOW,
 
3452
   N_("Non-default option to alias SYSDATE() to NOW() to make it "
 
3453
      "safe-replicable."),
 
3454
   (char**) &global_system_variables.sysdate_is_now,
 
3455
   0, 0, GET_BOOL, NO_ARG, 0, 0, 1, 0, 1, 0},
 
3456
  {"tc-heuristic-recover", OPT_TC_HEURISTIC_RECOVER,
 
3457
   N_("Decision to use in heuristic recover process. Possible values are "
 
3458
      "COMMIT or ROLLBACK."),
 
3459
   (char**) &opt_tc_heuristic_recover, (char**) &opt_tc_heuristic_recover,
 
3460
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3461
  {"temp-pool", OPT_TEMP_POOL,
 
3462
   N_("Using this option will cause most temporary files created to use a "
 
3463
      "small set of names, rather than a unique name for each new file."),
 
3464
   (char**) &use_temp_pool, (char**) &use_temp_pool, 0, GET_BOOL, NO_ARG, 1,
 
3465
   0, 0, 0, 0, 0},
1783
3466
  {"timed_mutexes", OPT_TIMED_MUTEXES,
1784
3467
   N_("Specify whether to time mutexes (only InnoDB mutexes are currently "
1785
3468
      "supported)"),
1786
 
   (char**) &internal::timed_mutexes, (char**) &internal::timed_mutexes, 0, GET_BOOL, NO_ARG, 0,
 
3469
   (char**) &timed_mutexes, (char**) &timed_mutexes, 0, GET_BOOL, NO_ARG, 0,
1787
3470
    0, 0, 0, 0, 0},
1788
3471
  {"tmpdir", 't',
1789
 
   N_("Path for temporary files."),
1790
 
   (char**) &opt_drizzle_tmpdir,
1791
 
   (char**) &opt_drizzle_tmpdir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3472
   N_("Path for temporary files. Several paths may be specified, separated "
 
3473
      "by a colon (:)"
 
3474
      ", in this case they are used in a round-robin fashion."),
 
3475
   (char**) &opt_mysql_tmpdir,
 
3476
   (char**) &opt_mysql_tmpdir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
1792
3477
  {"transaction-isolation", OPT_TX_ISOLATION,
1793
3478
   N_("Default transaction isolation level."),
1794
3479
   0, 0, 0, GET_STR, REQUIRED_ARG, 0,
1795
3480
   0, 0, 0, 0, 0},
1796
3481
  {"user", 'u',
1797
 
   N_("Run drizzled daemon as user."),
 
3482
   N_("Run mysqld daemon as user."),
1798
3483
   0, 0, 0, GET_STR, REQUIRED_ARG,
1799
3484
   0, 0, 0, 0, 0, 0},
1800
3485
  {"version", 'V',
1802
3487
   0, 0, 0, GET_NO_ARG,
1803
3488
   NO_ARG, 0, 0, 0, 0, 0, 0},
1804
3489
  {"back_log", OPT_BACK_LOG,
1805
 
   N_("The number of outstanding connection requests Drizzle can have. This "
1806
 
      "comes into play when the main Drizzle thread gets very many connection "
 
3490
   N_("The number of outstanding connection requests MySQL can have. This "
 
3491
      "comes into play when the main MySQL thread gets very many connection "
1807
3492
      "requests in a very short time."),
1808
 
    (char**) &back_log, (char**) &back_log, 0, GET_UINT,
 
3493
    (char**) &back_log, (char**) &back_log, 0, GET_ULONG,
1809
3494
    REQUIRED_ARG, 50, 1, 65535, 0, 1, 0 },
 
3495
  { "binlog_cache_size", OPT_BINLOG_CACHE_SIZE,
 
3496
    N_("The size of the cache to hold the SQL statements for the binary log "
 
3497
       "during a transaction. If you often use big, multi-statement "
 
3498
       "transactions you can increase this to get more performance."),
 
3499
    (char**) &binlog_cache_size, (char**) &binlog_cache_size, 0, GET_ULONG,
 
3500
    REQUIRED_ARG, 32*1024L, IO_SIZE, ULONG_MAX, 0, IO_SIZE, 0},
1810
3501
  { "bulk_insert_buffer_size", OPT_BULK_INSERT_BUFFER_SIZE,
1811
 
    N_("Size of tree cache used in bulk insert optimization. Note that this is "
 
3502
    N_("Size of tree cache used in bulk insert optimisation. Note that this is "
1812
3503
       "a limit per thread!"),
1813
3504
    (char**) &global_system_variables.bulk_insert_buff_size,
1814
3505
    (char**) &max_system_variables.bulk_insert_buff_size,
1815
 
    0, GET_ULL, REQUIRED_ARG, 8192*1024, 0, ULONG_MAX, 0, 1, 0},
 
3506
    0, GET_ULONG, REQUIRED_ARG, 8192*1024, 0, ULONG_MAX, 0, 1, 0},
 
3507
  { "connect_timeout", OPT_CONNECT_TIMEOUT,
 
3508
    N_("The number of seconds the mysqld server is waiting for a connect "
 
3509
       "packet before responding with 'Bad handshake'."),
 
3510
    (char**) &connect_timeout, (char**) &connect_timeout,
 
3511
    0, GET_ULONG, REQUIRED_ARG, CONNECT_TIMEOUT, 2, LONG_TIMEOUT, 0, 1, 0 },
 
3512
  { "date_format", OPT_DATE_FORMAT,
 
3513
    N_("The DATE format (For future)."),
 
3514
    (char**) &opt_date_time_formats[DRIZZLE_TIMESTAMP_DATE],
 
3515
    (char**) &opt_date_time_formats[DRIZZLE_TIMESTAMP_DATE],
 
3516
    0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3517
  { "datetime_format", OPT_DATETIME_FORMAT,
 
3518
    N_("The DATETIME/TIMESTAMP format (for future)."),
 
3519
    (char**) &opt_date_time_formats[DRIZZLE_TIMESTAMP_DATETIME],
 
3520
    (char**) &opt_date_time_formats[DRIZZLE_TIMESTAMP_DATETIME],
 
3521
    0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3522
  { "default_week_format", OPT_DEFAULT_WEEK_FORMAT,
 
3523
    N_("The default week format used by WEEK() functions."),
 
3524
    (char**) &global_system_variables.default_week_format,
 
3525
    (char**) &max_system_variables.default_week_format,
 
3526
    0, GET_ULONG, REQUIRED_ARG, 0, 0, 7L, 0, 1, 0},
1816
3527
  { "div_precision_increment", OPT_DIV_PRECINCREMENT,
1817
3528
   N_("Precision of the result of '/' operator will be increased on that "
1818
3529
      "value."),
1819
3530
   (char**) &global_system_variables.div_precincrement,
1820
 
   (char**) &max_system_variables.div_precincrement, 0, GET_UINT,
 
3531
   (char**) &max_system_variables.div_precincrement, 0, GET_ULONG,
1821
3532
   REQUIRED_ARG, 4, 0, DECIMAL_MAX_SCALE, 0, 0, 0},
 
3533
  { "expire_logs_days", OPT_EXPIRE_LOGS_DAYS,
 
3534
    N_("If non-zero, binary logs will be purged after expire_logs_days "
 
3535
       "days; possible purges happen at startup and at binary log rotation."),
 
3536
    (char**) &expire_logs_days,
 
3537
    (char**) &expire_logs_days, 0, GET_ULONG,
 
3538
    REQUIRED_ARG, 0, 0, 99, 0, 1, 0},
1822
3539
  { "group_concat_max_len", OPT_GROUP_CONCAT_MAX_LEN,
1823
3540
    N_("The maximum length of the result of function  group_concat."),
1824
3541
    (char**) &global_system_variables.group_concat_max_len,
1825
 
    (char**) &max_system_variables.group_concat_max_len, 0, GET_UINT64,
 
3542
    (char**) &max_system_variables.group_concat_max_len, 0, GET_ULONG,
1826
3543
    REQUIRED_ARG, 1024, 4, ULONG_MAX, 0, 1, 0},
 
3544
  { "interactive_timeout", OPT_INTERACTIVE_TIMEOUT,
 
3545
    N_("The number of seconds the server waits for activity on an interactive "
 
3546
       "connection before closing it."),
 
3547
   (char**) &global_system_variables.net_interactive_timeout,
 
3548
   (char**) &max_system_variables.net_interactive_timeout, 0,
 
3549
   GET_ULONG, REQUIRED_ARG, NET_WAIT_TIMEOUT, 1, LONG_TIMEOUT, 0, 1, 0},
1827
3550
  { "join_buffer_size", OPT_JOIN_BUFF_SIZE,
1828
3551
    N_("The size of the buffer that is used for full joins."),
1829
3552
   (char**) &global_system_variables.join_buff_size,
1830
 
   (char**) &max_system_variables.join_buff_size, 0, GET_UINT64,
 
3553
   (char**) &max_system_variables.join_buff_size, 0, GET_ULONG,
1831
3554
   REQUIRED_ARG, 128*1024L, IO_SIZE*2+MALLOC_OVERHEAD, ULONG_MAX,
1832
3555
   MALLOC_OVERHEAD, IO_SIZE, 0},
 
3556
  {"keep_files_on_create", OPT_KEEP_FILES_ON_CREATE,
 
3557
   N_("Don't overwrite stale .MYD and .MYI even if no directory is specified."),
 
3558
   (char**) &global_system_variables.keep_files_on_create,
 
3559
   (char**) &max_system_variables.keep_files_on_create,
 
3560
   0, GET_BOOL, OPT_ARG, 0, 0, 0, 0, 0, 0},
 
3561
  {"key_buffer_size", OPT_KEY_BUFFER_SIZE,
 
3562
   N_("The size of the buffer used for index blocks for MyISAM tables. "
 
3563
      "Increase this to get better index handling (for all reads and multiple "
 
3564
      "writes) to as much as you can afford;"),
 
3565
   (char**) &dflt_key_cache_var.param_buff_size,
 
3566
   (char**) 0,
 
3567
   0, (GET_ULL | GET_ASK_ADDR),
 
3568
   REQUIRED_ARG, KEY_CACHE_SIZE, MALLOC_OVERHEAD, SIZE_T_MAX, MALLOC_OVERHEAD,
 
3569
   IO_SIZE, 0},
 
3570
  {"key_cache_age_threshold", OPT_KEY_CACHE_AGE_THRESHOLD,
 
3571
   N_("This characterizes the number of hits a hot block has to be untouched "
 
3572
      "until it is considered aged enough to be downgraded to a warm block. "
 
3573
      "This specifies the percentage ratio of that number of hits to the "
 
3574
      "total number of blocks in key cache"),
 
3575
   (char**) &dflt_key_cache_var.param_age_threshold,
 
3576
   (char**) 0,
 
3577
   0, (GET_ULONG | GET_ASK_ADDR), REQUIRED_ARG,
 
3578
   300, 100, ULONG_MAX, 0, 100, 0},
 
3579
  {"key_cache_block_size", OPT_KEY_CACHE_BLOCK_SIZE,
 
3580
   N_("The default size of key cache blocks"),
 
3581
   (char**) &dflt_key_cache_var.param_block_size,
 
3582
   (char**) 0,
 
3583
   0, (GET_ULONG | GET_ASK_ADDR), REQUIRED_ARG,
 
3584
   KEY_CACHE_BLOCK_SIZE, 512, 1024 * 16, 0, 512, 0},
 
3585
  {"key_cache_division_limit", OPT_KEY_CACHE_DIVISION_LIMIT,
 
3586
   N_("The minimum percentage of warm blocks in key cache"),
 
3587
   (char**) &dflt_key_cache_var.param_division_limit,
 
3588
   (char**) 0,
 
3589
   0, (GET_ULONG | GET_ASK_ADDR) , REQUIRED_ARG, 100,
 
3590
   1, 100, 0, 1, 0},
 
3591
  {"long_query_time", OPT_LONG_QUERY_TIME,
 
3592
   N_("Log all queries that have taken more than long_query_time seconds to "
 
3593
      "execute to file. The argument will be treated as a decimal value with "
 
3594
      "microsecond precission."),
 
3595
   (char**) &long_query_time, (char**) &long_query_time, 0, GET_DOUBLE,
 
3596
   REQUIRED_ARG, 10, 0, LONG_TIMEOUT, 0, 0, 0},
1833
3597
  {"max_allowed_packet", OPT_MAX_ALLOWED_PACKET,
1834
3598
   N_("Max packetlength to send/receive from to server."),
1835
3599
   (char**) &global_system_variables.max_allowed_packet,
1836
 
   (char**) &max_system_variables.max_allowed_packet, 0, GET_UINT32,
 
3600
   (char**) &max_system_variables.max_allowed_packet, 0, GET_ULONG,
1837
3601
   REQUIRED_ARG, 1024*1024L, 1024, 1024L*1024L*1024L, MALLOC_OVERHEAD, 1024, 0},
 
3602
  {"max_binlog_cache_size", OPT_MAX_BINLOG_CACHE_SIZE,
 
3603
   N_("Can be used to restrict the total size used to cache a "
 
3604
      "multi-transaction query."),
 
3605
   (char**) &max_binlog_cache_size, (char**) &max_binlog_cache_size, 0,
 
3606
   GET_ULONG, REQUIRED_ARG, ULONG_MAX, IO_SIZE, ULONG_MAX, 0, IO_SIZE, 0},
 
3607
  {"max_binlog_size", OPT_MAX_BINLOG_SIZE,
 
3608
   N_("Binary log will be rotated automatically when the size exceeds this "
 
3609
      "value. Will also apply to relay logs if max_relay_log_size is 0. "
 
3610
      "The minimum value for this variable is 4096."),
 
3611
   (char**) &max_binlog_size, (char**) &max_binlog_size, 0, GET_ULONG,
 
3612
   REQUIRED_ARG, 1024*1024L*1024L, IO_SIZE, 1024*1024L*1024L, 0, IO_SIZE, 0},
1838
3613
  {"max_connect_errors", OPT_MAX_CONNECT_ERRORS,
1839
3614
   N_("If there is more than this number of interrupted connections from a "
1840
3615
      "host this host will be blocked from further connections."),
1841
 
   (char**) &max_connect_errors, (char**) &max_connect_errors, 0, GET_UINT64,
 
3616
   (char**) &max_connect_errors, (char**) &max_connect_errors, 0, GET_ULONG,
1842
3617
   REQUIRED_ARG, MAX_CONNECT_ERRORS, 1, ULONG_MAX, 0, 1, 0},
 
3618
  // Default max_connections of 151 is larger than Apache's default max
 
3619
  // children, to avoid "too many connections" error in a common setup
 
3620
  {"max_connections", OPT_MAX_CONNECTIONS,
 
3621
   N_("The number of simultaneous clients allowed."),
 
3622
   (char**) &max_connections,
 
3623
   (char**) &max_connections, 0, GET_ULONG, REQUIRED_ARG, 151, 1, 100000, 0, 1,
 
3624
   0},
1843
3625
  {"max_error_count", OPT_MAX_ERROR_COUNT,
1844
3626
   N_("Max number of errors/warnings to store for a statement."),
1845
3627
   (char**) &global_system_variables.max_error_count,
1846
3628
   (char**) &max_system_variables.max_error_count,
1847
 
   0, GET_UINT64, REQUIRED_ARG, DEFAULT_ERROR_COUNT, 0, 65535, 0, 1, 0},
 
3629
   0, GET_ULONG, REQUIRED_ARG, DEFAULT_ERROR_COUNT, 0, 65535, 0, 1, 0},
1848
3630
  {"max_heap_table_size", OPT_MAX_HEP_TABLE_SIZE,
1849
3631
   N_("Don't allow creation of heap tables bigger than this."),
1850
3632
   (char**) &global_system_variables.max_heap_table_size,
1860
3642
  {"max_length_for_sort_data", OPT_MAX_LENGTH_FOR_SORT_DATA,
1861
3643
   N_("Max number of bytes in sorted records."),
1862
3644
   (char**) &global_system_variables.max_length_for_sort_data,
1863
 
   (char**) &max_system_variables.max_length_for_sort_data, 0, GET_ULL,
 
3645
   (char**) &max_system_variables.max_length_for_sort_data, 0, GET_ULONG,
1864
3646
   REQUIRED_ARG, 1024, 4, 8192*1024L, 0, 1, 0},
 
3647
  {"max_relay_log_size", OPT_MAX_RELAY_LOG_SIZE,
 
3648
   N_("If non-zero: relay log will be rotated automatically when the size "
 
3649
      "exceeds this value; if zero (the default): when the size exceeds "
 
3650
      "max_binlog_size. 0 excepted, the minimum value for this variable "
 
3651
      "is 4096."),
 
3652
   (char**) &max_relay_log_size, (char**) &max_relay_log_size, 0, GET_ULONG,
 
3653
   REQUIRED_ARG, 0L, 0L, 1024*1024L*1024L, 0, IO_SIZE, 0},
1865
3654
  { "max_seeks_for_key", OPT_MAX_SEEKS_FOR_KEY,
1866
3655
    N_("Limit assumed max number of seeks when looking up rows based on a key"),
1867
3656
    (char**) &global_system_variables.max_seeks_for_key,
1868
 
    (char**) &max_system_variables.max_seeks_for_key, 0, GET_UINT64,
 
3657
    (char**) &max_system_variables.max_seeks_for_key, 0, GET_ULONG,
1869
3658
    REQUIRED_ARG, ULONG_MAX, 1, ULONG_MAX, 0, 1, 0 },
1870
3659
  {"max_sort_length", OPT_MAX_SORT_LENGTH,
1871
3660
   N_("The number of bytes to use when sorting BLOB or TEXT values "
1872
3661
      "(only the first max_sort_length bytes of each value are used; the "
1873
3662
      "rest are ignored)."),
1874
3663
   (char**) &global_system_variables.max_sort_length,
1875
 
   (char**) &max_system_variables.max_sort_length, 0, GET_SIZE,
 
3664
   (char**) &max_system_variables.max_sort_length, 0, GET_ULONG,
1876
3665
   REQUIRED_ARG, 1024, 4, 8192*1024L, 0, 1, 0},
 
3666
  {"max_tmp_tables", OPT_MAX_TMP_TABLES,
 
3667
   N_("Maximum number of temporary tables a client can keep open at a time."),
 
3668
   (char**) &global_system_variables.max_tmp_tables,
 
3669
   (char**) &max_system_variables.max_tmp_tables, 0, GET_ULONG,
 
3670
   REQUIRED_ARG, 32, 1, ULONG_MAX, 0, 1, 0},
1877
3671
  {"max_write_lock_count", OPT_MAX_WRITE_LOCK_COUNT,
1878
3672
   N_("After this many write locks, allow some read locks to run in between."),
1879
 
   (char**) &max_write_lock_count, (char**) &max_write_lock_count, 0, GET_ULL,
 
3673
   (char**) &max_write_lock_count, (char**) &max_write_lock_count, 0, GET_ULONG,
1880
3674
   REQUIRED_ARG, ULONG_MAX, 1, ULONG_MAX, 0, 1, 0},
1881
3675
  {"min_examined_row_limit", OPT_MIN_EXAMINED_ROW_LIMIT,
1882
3676
   N_("Don't log queries which examine less than min_examined_row_limit "
1883
3677
      "rows to file."),
1884
3678
   (char**) &global_system_variables.min_examined_row_limit,
1885
 
   (char**) &max_system_variables.min_examined_row_limit, 0, GET_ULL,
 
3679
   (char**) &max_system_variables.min_examined_row_limit, 0, GET_ULONG,
1886
3680
   REQUIRED_ARG, 0, 0, ULONG_MAX, 0, 1L, 0},
 
3681
  {"myisam_block_size", OPT_MYISAM_BLOCK_SIZE,
 
3682
   N_("Block size to be used for MyISAM index pages."),
 
3683
   (char**) &opt_myisam_block_size,
 
3684
   (char**) &opt_myisam_block_size, 0, GET_ULONG, REQUIRED_ARG,
 
3685
   MI_KEY_BLOCK_LENGTH, MI_MIN_KEY_BLOCK_LENGTH, MI_MAX_KEY_BLOCK_LENGTH,
 
3686
   0, MI_MIN_KEY_BLOCK_LENGTH, 0},
 
3687
  {"myisam_data_pointer_size", OPT_MYISAM_DATA_POINTER_SIZE,
 
3688
   N_("Default pointer size to be used for MyISAM tables."),
 
3689
   (char**) &myisam_data_pointer_size,
 
3690
   (char**) &myisam_data_pointer_size, 0, GET_ULONG, REQUIRED_ARG,
 
3691
   6, 2, 7, 0, 1, 0},
 
3692
  {"myisam_max_sort_file_size", OPT_MYISAM_MAX_SORT_FILE_SIZE,
 
3693
   N_("Don't use the fast sort index method to created index if the "
 
3694
      "temporary file would get bigger than this."),
 
3695
   (char**) &global_system_variables.myisam_max_sort_file_size,
 
3696
   (char**) &max_system_variables.myisam_max_sort_file_size, 0,
 
3697
   GET_ULL, REQUIRED_ARG, (int64_t) LONG_MAX, 0, (uint64_t) MAX_FILE_SIZE,
 
3698
   0, 1024*1024, 0},
 
3699
  {"myisam_repair_threads", OPT_MYISAM_REPAIR_THREADS,
 
3700
   N_("Number of threads to use when repairing MyISAM tables. The value of "
 
3701
      "1 disables parallel repair."),
 
3702
   (char**) &global_system_variables.myisam_repair_threads,
 
3703
   (char**) &max_system_variables.myisam_repair_threads, 0,
 
3704
   GET_ULONG, REQUIRED_ARG, 1, 1, ULONG_MAX, 0, 1, 0},
 
3705
  {"myisam_sort_buffer_size", OPT_MYISAM_SORT_BUFFER_SIZE,
 
3706
   N_("The buffer that is allocated when sorting the index when doing a "
 
3707
      "REPAIR or when creating indexes with CREATE INDEX or ALTER TABLE."),
 
3708
   (char**) &global_system_variables.myisam_sort_buff_size,
 
3709
   (char**) &max_system_variables.myisam_sort_buff_size, 0,
 
3710
   GET_ULONG, REQUIRED_ARG, 8192*1024, 4, INT32_MAX, 0, 1, 0},
 
3711
  {"myisam_stats_method", OPT_MYISAM_STATS_METHOD,
 
3712
   N_("Specifies how MyISAM index statistics collection code should threat "
 
3713
      "NULLs. Possible values of name are 'nulls_unequal' "
 
3714
      "(default behavior), "
 
3715
      "'nulls_equal' (emulate MySQL 4.0 behavior), and 'nulls_ignored'."),
 
3716
   (char**) &myisam_stats_method_str, (char**) &myisam_stats_method_str, 0,
 
3717
    GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
3718
  {"net_buffer_length", OPT_NET_BUFFER_LENGTH,
 
3719
   N_("Buffer length for TCP/IP and socket communication."),
 
3720
   (char**) &global_system_variables.net_buffer_length,
 
3721
   (char**) &max_system_variables.net_buffer_length, 0, GET_ULONG,
 
3722
   REQUIRED_ARG, 16384, 1024, 1024*1024L, 0, 1024, 0},
 
3723
  {"net_read_timeout", OPT_NET_READ_TIMEOUT,
 
3724
   N_("Number of seconds to wait for more data from a connection before "
 
3725
      "aborting the read."),
 
3726
   (char**) &global_system_variables.net_read_timeout,
 
3727
   (char**) &max_system_variables.net_read_timeout, 0, GET_ULONG,
 
3728
   REQUIRED_ARG, NET_READ_TIMEOUT, 1, LONG_TIMEOUT, 0, 1, 0},
 
3729
  {"net_retry_count", OPT_NET_RETRY_COUNT,
 
3730
   N_("If a read on a communication port is interrupted, retry this many "
 
3731
      "times before giving up."),
 
3732
   (char**) &global_system_variables.net_retry_count,
 
3733
   (char**) &max_system_variables.net_retry_count,0,
 
3734
   GET_ULONG, REQUIRED_ARG, MYSQLD_NET_RETRY_COUNT, 1, ULONG_MAX, 0, 1, 0},
 
3735
  {"net_write_timeout", OPT_NET_WRITE_TIMEOUT,
 
3736
   N_("Number of seconds to wait for a block to be written to a connection "
 
3737
      "before aborting the write."),
 
3738
   (char**) &global_system_variables.net_write_timeout,
 
3739
   (char**) &max_system_variables.net_write_timeout, 0, GET_ULONG,
 
3740
   REQUIRED_ARG, NET_WRITE_TIMEOUT, 1, LONG_TIMEOUT, 0, 1, 0},
 
3741
  { "old", OPT_OLD_MODE,
 
3742
    N_("Use compatible behavior."),
 
3743
    (char**) &global_system_variables.old_mode,
 
3744
    (char**) &max_system_variables.old_mode, 0, GET_BOOL, NO_ARG,
 
3745
    0, 0, 0, 0, 0, 0},
 
3746
  {"open_files_limit", OPT_OPEN_FILES_LIMIT,
 
3747
   N_("If this is not 0, then mysqld will use this value to reserve file "
 
3748
      "descriptors to use with setrlimit(). If this value is 0 then mysqld "
 
3749
      "will reserve max_connections*5 or max_connections + table_cache*2 "
 
3750
      "(whichever is larger) number of files."),
 
3751
   (char**) &open_files_limit, (char**) &open_files_limit, 0, GET_ULONG,
 
3752
   REQUIRED_ARG, 0, 0, OS_FILE_LIMIT, 0, 1, 0},
1887
3753
  {"optimizer_prune_level", OPT_OPTIMIZER_PRUNE_LEVEL,
1888
 
    N_("Controls the heuristic(s) applied during query optimization to prune "
1889
 
       "less-promising partial plans from the optimizer search space. Meaning: "
1890
 
       "false - do not apply any heuristic, thus perform exhaustive search; "
1891
 
       "true - prune plans based on number of retrieved rows."),
1892
 
    (char**) &global_system_variables.optimizer_prune_level,
1893
 
    (char**) &max_system_variables.optimizer_prune_level,
1894
 
    0, GET_BOOL, OPT_ARG, 1, 0, 1, 0, 1, 0},
 
3754
   N_("Controls the heuristic(s) applied during query optimization to prune "
 
3755
      "less-promising partial plans from the optimizer search space. Meaning: "
 
3756
      "0 - do not apply any heuristic, thus perform exhaustive search; "
 
3757
      "1 - prune plans based on number of retrieved rows."),
 
3758
   (char**) &global_system_variables.optimizer_prune_level,
 
3759
   (char**) &max_system_variables.optimizer_prune_level,
 
3760
   0, GET_ULONG, OPT_ARG, 1, 0, 1, 0, 1, 0},
1895
3761
  {"optimizer_search_depth", OPT_OPTIMIZER_SEARCH_DEPTH,
1896
3762
   N_("Maximum depth of search performed by the query optimizer. Values "
1897
3763
      "larger than the number of relations in a query result in better query "
1903
3769
      "testing/comparison)."),
1904
3770
   (char**) &global_system_variables.optimizer_search_depth,
1905
3771
   (char**) &max_system_variables.optimizer_search_depth,
1906
 
   0, GET_UINT, OPT_ARG, 0, 0, MAX_TABLES+2, 0, 1, 0},
 
3772
   0, GET_ULONG, OPT_ARG, MAX_TABLES+1, 0, MAX_TABLES+2, 0, 1, 0},
1907
3773
  {"plugin_dir", OPT_PLUGIN_DIR,
1908
3774
   N_("Directory for plugins."),
1909
3775
   (char**) &opt_plugin_dir_ptr, (char**) &opt_plugin_dir_ptr, 0,
1910
3776
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
1911
 
  {"plugin_add", OPT_PLUGIN_ADD,
1912
 
   N_("Optional comma separated list of plugins to load at startup in addition "
1913
 
      "to the default list of plugins. "
1914
 
      "[for example: --plugin_add=crc32,logger_gearman]"),
1915
 
   NULL, NULL, 0,
1916
 
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
1917
 
  {"plugin_remove", OPT_PLUGIN_ADD,
1918
 
   N_("Optional comma separated list of plugins to not load at startup. Effectively "
1919
 
      "removes a plugin from the list of plugins to be loaded. "
1920
 
      "[for example: --plugin_remove=crc32,logger_gearman]"),
1921
 
   NULL, NULL, 0,
1922
 
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
1923
3777
  {"plugin_load", OPT_PLUGIN_LOAD,
1924
 
   N_("Optional comma separated list of plugins to load at starup instead of "
1925
 
      "the default plugin load list. "
1926
 
      "[for example: --plugin_load=crc32,logger_gearman]"),
1927
 
   NULL, NULL, 0,
 
3778
   N_("Optional comma separated list of plugins to load, where each plugin is "
 
3779
      "identified by the name of the shared library. "
 
3780
      "[for example: --plugin_load=libmd5udf.so]"),
 
3781
   (char**) &opt_plugin_load, (char**) &opt_plugin_load, 0,
1928
3782
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
1929
3783
  {"preload_buffer_size", OPT_PRELOAD_BUFFER_SIZE,
1930
3784
   N_("The size of the buffer that is allocated when preloading indexes"),
1931
3785
   (char**) &global_system_variables.preload_buff_size,
1932
 
   (char**) &max_system_variables.preload_buff_size, 0, GET_ULL,
 
3786
   (char**) &max_system_variables.preload_buff_size, 0, GET_ULONG,
1933
3787
   REQUIRED_ARG, 32*1024L, 1024, 1024*1024*1024L, 0, 1, 0},
1934
3788
  {"query_alloc_block_size", OPT_QUERY_ALLOC_BLOCK_SIZE,
1935
3789
   N_("Allocation block size for query parsing and execution"),
1936
3790
   (char**) &global_system_variables.query_alloc_block_size,
1937
 
   (char**) &max_system_variables.query_alloc_block_size, 0, GET_UINT,
 
3791
   (char**) &max_system_variables.query_alloc_block_size, 0, GET_ULONG,
1938
3792
   REQUIRED_ARG, QUERY_ALLOC_BLOCK_SIZE, 1024, ULONG_MAX, 0, 1024, 0},
1939
3793
  {"query_prealloc_size", OPT_QUERY_PREALLOC_SIZE,
1940
3794
   N_("Persistent buffer for query parsing and execution"),
1941
3795
   (char**) &global_system_variables.query_prealloc_size,
1942
 
   (char**) &max_system_variables.query_prealloc_size, 0, GET_UINT,
 
3796
   (char**) &max_system_variables.query_prealloc_size, 0, GET_ULONG,
1943
3797
   REQUIRED_ARG, QUERY_ALLOC_PREALLOC_SIZE, QUERY_ALLOC_PREALLOC_SIZE,
1944
3798
   ULONG_MAX, 0, 1024, 0},
1945
3799
  {"range_alloc_block_size", OPT_RANGE_ALLOC_BLOCK_SIZE,
1946
3800
   N_("Allocation block size for storing ranges during optimization"),
1947
3801
   (char**) &global_system_variables.range_alloc_block_size,
1948
 
   (char**) &max_system_variables.range_alloc_block_size, 0, GET_SIZE,
1949
 
   REQUIRED_ARG, RANGE_ALLOC_BLOCK_SIZE, RANGE_ALLOC_BLOCK_SIZE, SIZE_MAX,
 
3802
   (char**) &max_system_variables.range_alloc_block_size, 0, GET_ULONG,
 
3803
   REQUIRED_ARG, RANGE_ALLOC_BLOCK_SIZE, RANGE_ALLOC_BLOCK_SIZE, ULONG_MAX,
1950
3804
   0, 1024, 0},
1951
3805
  {"read_buffer_size", OPT_RECORD_BUFFER,
1952
 
    N_("Each thread that does a sequential scan allocates a buffer of this "
1953
 
       "size for each table it scans. If you do many sequential scans, you may "
1954
 
       "want to increase this value."),
1955
 
    (char**) &global_system_variables.read_buff_size,
1956
 
    (char**) &max_system_variables.read_buff_size,0, GET_UINT, REQUIRED_ARG,
1957
 
    128*1024L, IO_SIZE*2+MALLOC_OVERHEAD, INT32_MAX, MALLOC_OVERHEAD, IO_SIZE,
1958
 
    0},
 
3806
   N_("Each thread that does a sequential scan allocates a buffer of this "
 
3807
      "size for each table it scans. If you do many sequential scans, you may "
 
3808
      "want to increase this value."),
 
3809
   (char**) &global_system_variables.read_buff_size,
 
3810
   (char**) &max_system_variables.read_buff_size,0, GET_ULONG, REQUIRED_ARG,
 
3811
   128*1024L, IO_SIZE*2+MALLOC_OVERHEAD, INT32_MAX, MALLOC_OVERHEAD, IO_SIZE,
 
3812
   0},
 
3813
  {"read_only", OPT_READONLY,
 
3814
   N_("Make all non-temporary tables read-only, with the exception for "
 
3815
      "replication (slave) threads and users with the SUPER privilege"),
 
3816
   (char**) &opt_readonly,
 
3817
   (char**) &opt_readonly,
 
3818
   0, GET_BOOL, NO_ARG, 0, 0, 1, 0, 1, 0},
1959
3819
  {"read_rnd_buffer_size", OPT_RECORD_RND_BUFFER,
1960
3820
   N_("When reading rows in sorted order after a sort, the rows are read "
1961
3821
      "through this buffer to avoid a disk seeks. If not set, then it's set "
1962
3822
      "to the value of record_buffer."),
1963
3823
   (char**) &global_system_variables.read_rnd_buff_size,
1964
3824
   (char**) &max_system_variables.read_rnd_buff_size, 0,
1965
 
   GET_UINT, REQUIRED_ARG, 256*1024L, 64 /*IO_SIZE*2+MALLOC_OVERHEAD*/ ,
1966
 
   UINT32_MAX, MALLOC_OVERHEAD, 1 /* Small lower limit to be able to test MRR */, 0},
1967
 
  {"scheduler", OPT_SCHEDULER,
1968
 
   N_("Select scheduler to be used (by default multi-thread)."),
1969
 
   (char**)&opt_scheduler, (char**)&opt_scheduler,
1970
 
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
1971
 
  /* x8 compared to MySQL's x2. We have UTF8 to consider. */
 
3825
   GET_ULONG, REQUIRED_ARG, 256*1024L, 64 /*IO_SIZE*2+MALLOC_OVERHEAD*/ ,
 
3826
   INT32_MAX, MALLOC_OVERHEAD, 1 /* Small lower limit to be able to test MRR */, 0},
 
3827
  {"record_buffer", OPT_RECORD_BUFFER,
 
3828
   "Alias for read_buffer_size",
 
3829
   (char**) &global_system_variables.read_buff_size,
 
3830
   (char**) &max_system_variables.read_buff_size,0, GET_ULONG, REQUIRED_ARG,
 
3831
   128*1024L, IO_SIZE*2+MALLOC_OVERHEAD,
 
3832
   INT32_MAX, MALLOC_OVERHEAD, IO_SIZE, 0},
 
3833
  {"relay_log_purge", OPT_RELAY_LOG_PURGE,
 
3834
   N_("0 = do not purge relay logs. "
 
3835
      "1 = purge them as soon as they are no more needed."),
 
3836
   (char**) &relay_log_purge,
 
3837
   (char**) &relay_log_purge, 0, GET_BOOL, NO_ARG,
 
3838
   1, 0, 1, 0, 1, 0},
 
3839
  {"relay_log_space_limit", OPT_RELAY_LOG_SPACE_LIMIT,
 
3840
   N_("Maximum space to use for all relay logs."),
 
3841
   (char**) &relay_log_space_limit,
 
3842
   (char**) &relay_log_space_limit, 0, GET_ULL, REQUIRED_ARG, 0L, 0L,
 
3843
   (int64_t) ULONG_MAX, 0, 1, 0},
 
3844
  {"slave_compressed_protocol", OPT_SLAVE_COMPRESSED_PROTOCOL,
 
3845
   N_("Use compression on master/slave protocol."),
 
3846
   (char**) &opt_slave_compressed_protocol,
 
3847
   (char**) &opt_slave_compressed_protocol,
 
3848
   0, GET_BOOL, NO_ARG, 0, 0, 1, 0, 1, 0},
 
3849
  {"slave_net_timeout", OPT_SLAVE_NET_TIMEOUT,
 
3850
   N_("Number of seconds to wait for more data from a master/slave connection "
 
3851
      "before aborting the read."),
 
3852
   (char**) &slave_net_timeout, (char**) &slave_net_timeout, 0,
 
3853
   GET_ULONG, REQUIRED_ARG, SLAVE_NET_TIMEOUT, 1, LONG_TIMEOUT, 0, 1, 0},
 
3854
  {"slave_transaction_retries", OPT_SLAVE_TRANS_RETRIES,
 
3855
   N_("Number of times the slave SQL thread will retry a transaction in case "
 
3856
      "it failed with a deadlock or elapsed lock wait timeout, "
 
3857
      "before giving up and stopping."),
 
3858
   (char**) &slave_trans_retries, (char**) &slave_trans_retries, 0,
 
3859
   GET_ULONG, REQUIRED_ARG, 10L, 0L, (int64_t) ULONG_MAX, 0, 1, 0},
 
3860
  {"slave-allow-batching", OPT_SLAVE_ALLOW_BATCHING,
 
3861
   N_("Allow slave to batch requests."),
 
3862
   (char**) &slave_allow_batching, (char**) &slave_allow_batching,
 
3863
   0, GET_BOOL, NO_ARG, 0, 0, 1, 0, 1, 0},
 
3864
  {"slow_launch_time", OPT_SLOW_LAUNCH_TIME,
 
3865
   N_("If creating the thread takes longer than this value (in seconds), the "
 
3866
      "Slow_launch_threads counter will be incremented."),
 
3867
   (char**) &slow_launch_time, (char**) &slow_launch_time, 0, GET_ULONG,
 
3868
   REQUIRED_ARG, 2L, 0L, LONG_TIMEOUT, 0, 1, 0},
1972
3869
  {"sort_buffer_size", OPT_SORT_BUFFER,
1973
3870
   N_("Each thread that needs to do a sort allocates a buffer of this size."),
1974
3871
   (char**) &global_system_variables.sortbuff_size,
1975
 
   (char**) &max_system_variables.sortbuff_size, 0, GET_SIZE, REQUIRED_ARG,
1976
 
   MAX_SORT_MEMORY, MIN_SORT_MEMORY+MALLOC_OVERHEAD*8, SIZE_MAX,
 
3872
   (char**) &max_system_variables.sortbuff_size, 0, GET_ULONG, REQUIRED_ARG,
 
3873
   MAX_SORT_MEMORY, MIN_SORT_MEMORY+MALLOC_OVERHEAD*2, ULONG_MAX,
1977
3874
   MALLOC_OVERHEAD, 1, 0},
 
3875
  {"sync-binlog", OPT_SYNC_BINLOG,
 
3876
   N_("Synchronously flush binary log to disk after every #th event. "
 
3877
      "Use 0 (default) to disable synchronous flushing."),
 
3878
   (char**) &sync_binlog_period, (char**) &sync_binlog_period, 0, GET_ULONG,
 
3879
   REQUIRED_ARG, 0, 0, ULONG_MAX, 0, 1, 0},
1978
3880
  {"table_definition_cache", OPT_TABLE_DEF_CACHE,
1979
3881
   N_("The number of cached table definitions."),
1980
3882
   (char**) &table_def_size, (char**) &table_def_size,
1981
 
   0, GET_SIZE, REQUIRED_ARG, 128, 1, 512*1024L, 0, 1, 0},
 
3883
   0, GET_ULONG, REQUIRED_ARG, 128, 1, 512*1024L, 0, 1, 0},
1982
3884
  {"table_open_cache", OPT_TABLE_OPEN_CACHE,
1983
3885
   N_("The number of cached open tables."),
1984
 
   (char**) &table_cache_size, (char**) &table_cache_size, 0, GET_UINT64,
1985
 
   REQUIRED_ARG, TABLE_OPEN_CACHE_DEFAULT, TABLE_OPEN_CACHE_MIN, 512*1024L, 0, 1, 0},
 
3886
   (char**) &table_cache_size, (char**) &table_cache_size, 0, GET_ULONG,
 
3887
   REQUIRED_ARG, TABLE_OPEN_CACHE_DEFAULT, 1, 512*1024L, 0, 1, 0},
1986
3888
  {"table_lock_wait_timeout", OPT_TABLE_LOCK_WAIT_TIMEOUT,
1987
3889
   N_("Timeout in seconds to wait for a table level lock before returning an "
1988
3890
      "error. Used only if the connection has active cursors."),
1989
3891
   (char**) &table_lock_wait_timeout, (char**) &table_lock_wait_timeout,
1990
 
   0, GET_ULL, REQUIRED_ARG, 50, 1, 1024 * 1024 * 1024, 0, 1, 0},
 
3892
   0, GET_ULONG, REQUIRED_ARG, 50, 1, 1024 * 1024 * 1024, 0, 1, 0},
 
3893
  {"thread_cache_size", OPT_THREAD_CACHE_SIZE,
 
3894
   N_("How many threads we should keep in a cache for reuse."),
 
3895
   (char**) &thread_cache_size, (char**) &thread_cache_size, 0, GET_ULONG,
 
3896
   REQUIRED_ARG, 0, 0, 16384, 0, 1, 0},
 
3897
  {"thread_pool_size", OPT_THREAD_CACHE_SIZE,
 
3898
   N_("How many threads we should create to handle query requests in case of "
 
3899
      "'thread_handling=pool-of-threads'"),
 
3900
   (char**) &thread_pool_size, (char**) &thread_pool_size, 0, GET_ULONG,
 
3901
   REQUIRED_ARG, 20, 1, 16384, 0, 1, 0},
1991
3902
  {"thread_stack", OPT_THREAD_STACK,
1992
3903
   N_("The stack size for each thread."),
1993
3904
   (char**) &my_thread_stack_size,
1994
 
   (char**) &my_thread_stack_size, 0, GET_SIZE,
 
3905
   (char**) &my_thread_stack_size, 0, GET_ULONG,
1995
3906
   REQUIRED_ARG,DEFAULT_THREAD_STACK,
1996
 
   UINT32_C(1024*512), SIZE_MAX, 0, 1024, 0},
 
3907
   1024L*128L, ULONG_MAX, 0, 1024, 0},
 
3908
  { "time_format", OPT_TIME_FORMAT,
 
3909
    N_("The TIME format (for future)."),
 
3910
    (char**) &opt_date_time_formats[DRIZZLE_TIMESTAMP_TIME],
 
3911
    (char**) &opt_date_time_formats[DRIZZLE_TIMESTAMP_TIME],
 
3912
    0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
1997
3913
  {"tmp_table_size", OPT_TMP_TABLE_SIZE,
1998
 
   N_("If an internal in-memory temporary table exceeds this size, Drizzle will"
 
3914
   N_("If an internal in-memory temporary table exceeds this size, MySQL will"
1999
3915
      " automatically convert it to an on-disk MyISAM table."),
2000
3916
   (char**) &global_system_variables.tmp_table_size,
2001
3917
   (char**) &max_system_variables.tmp_table_size, 0, GET_ULL,
2002
3918
   REQUIRED_ARG, 16*1024*1024L, 1024, MAX_MEM_TABLE_SIZE, 0, 1, 0},
 
3919
  {"transaction_alloc_block_size", OPT_TRANS_ALLOC_BLOCK_SIZE,
 
3920
   N_("Allocation block size for transactions to be stored in binary log"),
 
3921
   (char**) &global_system_variables.trans_alloc_block_size,
 
3922
   (char**) &max_system_variables.trans_alloc_block_size, 0, GET_ULONG,
 
3923
   REQUIRED_ARG, QUERY_ALLOC_BLOCK_SIZE, 1024, ULONG_MAX, 0, 1024, 0},
 
3924
  {"transaction_prealloc_size", OPT_TRANS_PREALLOC_SIZE,
 
3925
   N_("Persistent buffer for transactions to be stored in binary log"),
 
3926
   (char**) &global_system_variables.trans_prealloc_size,
 
3927
   (char**) &max_system_variables.trans_prealloc_size, 0, GET_ULONG,
 
3928
   REQUIRED_ARG, TRANS_ALLOC_PREALLOC_SIZE, 1024, ULONG_MAX, 0, 1024, 0},
 
3929
  {"wait_timeout", OPT_WAIT_TIMEOUT,
 
3930
   N_("The number of seconds the server waits for activity on a connection "
 
3931
      "before closing it."),
 
3932
   (char**) &global_system_variables.net_wait_timeout,
 
3933
   (char**) &max_system_variables.net_wait_timeout, 0, GET_ULONG,
 
3934
   REQUIRED_ARG, NET_WAIT_TIMEOUT, 1, LONG_TIMEOUT,
 
3935
   0, 1, 0},
2003
3936
  {0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
2004
3937
};
2005
3938
 
 
3939
static int show_net_compression(THD *thd __attribute__((unused)),
 
3940
                                SHOW_VAR *var,
 
3941
                                char *buff __attribute__((unused)))
 
3942
{
 
3943
  var->type= SHOW_MY_BOOL;
 
3944
  var->value= (char *)&thd->net.compress;
 
3945
  return 0;
 
3946
}
 
3947
 
 
3948
static st_show_var_func_container
 
3949
show_net_compression_cont= { &show_net_compression };
 
3950
 
 
3951
static int show_starttime(THD *thd, SHOW_VAR *var, char *buff)
 
3952
{
 
3953
  var->type= SHOW_LONG;
 
3954
  var->value= buff;
 
3955
  *((long *)buff)= (long) (thd->query_start() - server_start_time);
 
3956
  return 0;
 
3957
}
 
3958
 
 
3959
static st_show_var_func_container
 
3960
show_starttime_cont= { &show_starttime };
 
3961
 
 
3962
static int show_flushstatustime(THD *thd, SHOW_VAR *var, char *buff)
 
3963
{
 
3964
  var->type= SHOW_LONG;
 
3965
  var->value= buff;
 
3966
  *((long *)buff)= (long) (thd->query_start() - flush_status_time);
 
3967
  return 0;
 
3968
}
 
3969
 
 
3970
static st_show_var_func_container
 
3971
show_flushstatustime_cont= { &show_flushstatustime };
 
3972
 
 
3973
static int show_slave_running(THD *thd __attribute__((unused)),
 
3974
                              SHOW_VAR *var, char *buff)
 
3975
{
 
3976
  var->type= SHOW_MY_BOOL;
 
3977
  pthread_mutex_lock(&LOCK_active_mi);
 
3978
  var->value= buff;
 
3979
  *((bool *)buff)= (bool) (active_mi && active_mi->slave_running &&
 
3980
                                 active_mi->rli.slave_running);
 
3981
  pthread_mutex_unlock(&LOCK_active_mi);
 
3982
  return 0;
 
3983
}
 
3984
 
 
3985
static st_show_var_func_container
 
3986
show_slave_running_cont= { &show_slave_running };
 
3987
 
 
3988
static int show_slave_retried_trans(THD *thd __attribute__((unused)),
 
3989
                                    SHOW_VAR *var, char *buff)
 
3990
{
 
3991
  /*
 
3992
    TODO: with multimaster, have one such counter per line in
 
3993
    SHOW SLAVE STATUS, and have the sum over all lines here.
 
3994
  */
 
3995
  pthread_mutex_lock(&LOCK_active_mi);
 
3996
  if (active_mi)
 
3997
  {
 
3998
    var->type= SHOW_LONG;
 
3999
    var->value= buff;
 
4000
    pthread_mutex_lock(&active_mi->rli.data_lock);
 
4001
    *((long *)buff)= (long)active_mi->rli.retried_trans;
 
4002
    pthread_mutex_unlock(&active_mi->rli.data_lock);
 
4003
  }
 
4004
  else
 
4005
    var->type= SHOW_UNDEF;
 
4006
  pthread_mutex_unlock(&LOCK_active_mi);
 
4007
  return 0;
 
4008
}
 
4009
 
 
4010
static st_show_var_func_container
 
4011
show_slave_retried_trans_cont= { &show_slave_retried_trans };
 
4012
 
 
4013
static int show_slave_received_heartbeats(THD *thd __attribute__((unused)),
 
4014
                                          SHOW_VAR *var, char *buff)
 
4015
{
 
4016
  pthread_mutex_lock(&LOCK_active_mi);
 
4017
  if (active_mi)
 
4018
  {
 
4019
    var->type= SHOW_LONGLONG;
 
4020
    var->value= buff;
 
4021
    pthread_mutex_lock(&active_mi->rli.data_lock);
 
4022
    *((int64_t *)buff)= active_mi->received_heartbeats;
 
4023
    pthread_mutex_unlock(&active_mi->rli.data_lock);
 
4024
  }
 
4025
  else
 
4026
    var->type= SHOW_UNDEF;
 
4027
  pthread_mutex_unlock(&LOCK_active_mi);
 
4028
  return 0;
 
4029
}
 
4030
 
 
4031
static st_show_var_func_container
 
4032
show_slave_received_heartbeats_cont= { &show_slave_received_heartbeats };
 
4033
 
 
4034
static int show_heartbeat_period(THD *thd __attribute__((unused)),
 
4035
                                 SHOW_VAR *var, char *buff)
 
4036
{
 
4037
  pthread_mutex_lock(&LOCK_active_mi);
 
4038
  if (active_mi)
 
4039
  {
 
4040
    var->type= SHOW_CHAR;
 
4041
    var->value= buff;
 
4042
    sprintf(buff, "%.3f",active_mi->heartbeat_period);
 
4043
  }
 
4044
  else
 
4045
    var->type= SHOW_UNDEF;
 
4046
  pthread_mutex_unlock(&LOCK_active_mi);
 
4047
  return 0;
 
4048
}
 
4049
 
 
4050
static st_show_var_func_container
 
4051
show_heartbeat_period_cont= { &show_heartbeat_period};
 
4052
 
 
4053
static int show_open_tables(THD *thd __attribute__((unused)),
 
4054
                            SHOW_VAR *var, char *buff)
 
4055
{
 
4056
  var->type= SHOW_LONG;
 
4057
  var->value= buff;
 
4058
  *((long *)buff)= (long)cached_open_tables();
 
4059
  return 0;
 
4060
}
 
4061
 
 
4062
static int show_table_definitions(THD *thd __attribute__((unused)),
 
4063
                                  SHOW_VAR *var, char *buff)
 
4064
{
 
4065
  var->type= SHOW_LONG;
 
4066
  var->value= buff;
 
4067
  *((long *)buff)= (long)cached_table_definitions();
 
4068
  return 0;
 
4069
}
 
4070
 
 
4071
static st_show_var_func_container
 
4072
show_open_tables_cont= { &show_open_tables };
 
4073
static st_show_var_func_container
 
4074
show_table_definitions_cont= { &show_table_definitions };
 
4075
 
 
4076
/*
 
4077
  Variables shown by SHOW STATUS in alphabetical order
 
4078
*/
 
4079
 
 
4080
SHOW_VAR status_vars[]= {
 
4081
  {"Aborted_clients",          (char*) &aborted_threads,        SHOW_LONG},
 
4082
  {"Aborted_connects",         (char*) &aborted_connects,       SHOW_LONG},
 
4083
  {"Binlog_cache_disk_use",    (char*) &binlog_cache_disk_use,  SHOW_LONG},
 
4084
  {"Binlog_cache_use",         (char*) &binlog_cache_use,       SHOW_LONG},
 
4085
  {"Bytes_received",           (char*) offsetof(STATUS_VAR, bytes_received), SHOW_LONGLONG_STATUS},
 
4086
  {"Bytes_sent",               (char*) offsetof(STATUS_VAR, bytes_sent), SHOW_LONGLONG_STATUS},
 
4087
  {"Com",                      (char*) com_status_vars, SHOW_ARRAY},
 
4088
  {"Compression",              (char*) &show_net_compression_cont, SHOW_FUNC},
 
4089
  {"Connections",              (char*) &thread_id,              SHOW_LONG_NOFLUSH},
 
4090
  {"Created_tmp_disk_tables",  (char*) offsetof(STATUS_VAR, created_tmp_disk_tables), SHOW_LONG_STATUS},
 
4091
  {"Created_tmp_files",        (char*) &my_tmp_file_created,    SHOW_LONG},
 
4092
  {"Created_tmp_tables",       (char*) offsetof(STATUS_VAR, created_tmp_tables), SHOW_LONG_STATUS},
 
4093
  {"Flush_commands",           (char*) &refresh_version,        SHOW_LONG_NOFLUSH},
 
4094
  {"Handler_commit",           (char*) offsetof(STATUS_VAR, ha_commit_count), SHOW_LONG_STATUS},
 
4095
  {"Handler_delete",           (char*) offsetof(STATUS_VAR, ha_delete_count), SHOW_LONG_STATUS},
 
4096
  {"Handler_discover",         (char*) offsetof(STATUS_VAR, ha_discover_count), SHOW_LONG_STATUS},
 
4097
  {"Handler_prepare",          (char*) offsetof(STATUS_VAR, ha_prepare_count),  SHOW_LONG_STATUS},
 
4098
  {"Handler_read_first",       (char*) offsetof(STATUS_VAR, ha_read_first_count), SHOW_LONG_STATUS},
 
4099
  {"Handler_read_key",         (char*) offsetof(STATUS_VAR, ha_read_key_count), SHOW_LONG_STATUS},
 
4100
  {"Handler_read_next",        (char*) offsetof(STATUS_VAR, ha_read_next_count), SHOW_LONG_STATUS},
 
4101
  {"Handler_read_prev",        (char*) offsetof(STATUS_VAR, ha_read_prev_count), SHOW_LONG_STATUS},
 
4102
  {"Handler_read_rnd",         (char*) offsetof(STATUS_VAR, ha_read_rnd_count), SHOW_LONG_STATUS},
 
4103
  {"Handler_read_rnd_next",    (char*) offsetof(STATUS_VAR, ha_read_rnd_next_count), SHOW_LONG_STATUS},
 
4104
  {"Handler_rollback",         (char*) offsetof(STATUS_VAR, ha_rollback_count), SHOW_LONG_STATUS},
 
4105
  {"Handler_savepoint",        (char*) offsetof(STATUS_VAR, ha_savepoint_count), SHOW_LONG_STATUS},
 
4106
  {"Handler_savepoint_rollback",(char*) offsetof(STATUS_VAR, ha_savepoint_rollback_count), SHOW_LONG_STATUS},
 
4107
  {"Handler_update",           (char*) offsetof(STATUS_VAR, ha_update_count), SHOW_LONG_STATUS},
 
4108
  {"Handler_write",            (char*) offsetof(STATUS_VAR, ha_write_count), SHOW_LONG_STATUS},
 
4109
  {"Key_blocks_not_flushed",   (char*) offsetof(KEY_CACHE, global_blocks_changed), SHOW_KEY_CACHE_LONG},
 
4110
  {"Key_blocks_unused",        (char*) offsetof(KEY_CACHE, blocks_unused), SHOW_KEY_CACHE_LONG},
 
4111
  {"Key_blocks_used",          (char*) offsetof(KEY_CACHE, blocks_used), SHOW_KEY_CACHE_LONG},
 
4112
  {"Key_read_requests",        (char*) offsetof(KEY_CACHE, global_cache_r_requests), SHOW_KEY_CACHE_LONGLONG},
 
4113
  {"Key_reads",                (char*) offsetof(KEY_CACHE, global_cache_read), SHOW_KEY_CACHE_LONGLONG},
 
4114
  {"Key_write_requests",       (char*) offsetof(KEY_CACHE, global_cache_w_requests), SHOW_KEY_CACHE_LONGLONG},
 
4115
  {"Key_writes",               (char*) offsetof(KEY_CACHE, global_cache_write), SHOW_KEY_CACHE_LONGLONG},
 
4116
  {"Last_query_cost",          (char*) offsetof(STATUS_VAR, last_query_cost), SHOW_DOUBLE_STATUS},
 
4117
  {"Max_used_connections",     (char*) &max_used_connections,  SHOW_LONG},
 
4118
  {"Open_files",               (char*) &my_file_opened,         SHOW_LONG_NOFLUSH},
 
4119
  {"Open_streams",             (char*) &my_stream_opened,       SHOW_LONG_NOFLUSH},
 
4120
  {"Open_table_definitions",   (char*) &show_table_definitions_cont, SHOW_FUNC},
 
4121
  {"Open_tables",              (char*) &show_open_tables_cont,       SHOW_FUNC},
 
4122
  {"Opened_files",             (char*) &my_file_total_opened, SHOW_LONG_NOFLUSH},
 
4123
  {"Opened_tables",            (char*) offsetof(STATUS_VAR, opened_tables), SHOW_LONG_STATUS},
 
4124
  {"Opened_table_definitions", (char*) offsetof(STATUS_VAR, opened_shares), SHOW_LONG_STATUS},
 
4125
  {"Questions",                (char*) offsetof(STATUS_VAR, questions), SHOW_LONG_STATUS},
 
4126
  {"Select_full_join",         (char*) offsetof(STATUS_VAR, select_full_join_count), SHOW_LONG_STATUS},
 
4127
  {"Select_full_range_join",   (char*) offsetof(STATUS_VAR, select_full_range_join_count), SHOW_LONG_STATUS},
 
4128
  {"Select_range",             (char*) offsetof(STATUS_VAR, select_range_count), SHOW_LONG_STATUS},
 
4129
  {"Select_range_check",       (char*) offsetof(STATUS_VAR, select_range_check_count), SHOW_LONG_STATUS},
 
4130
  {"Select_scan",              (char*) offsetof(STATUS_VAR, select_scan_count), SHOW_LONG_STATUS},
 
4131
  {"Slave_open_temp_tables",   (char*) &slave_open_temp_tables, SHOW_LONG},
 
4132
  {"Slave_retried_transactions",(char*) &show_slave_retried_trans_cont, SHOW_FUNC},
 
4133
  {"Slave_heartbeat_period",   (char*) &show_heartbeat_period_cont, SHOW_FUNC},
 
4134
  {"Slave_received_heartbeats",(char*) &show_slave_received_heartbeats_cont, SHOW_FUNC},
 
4135
  {"Slave_running",            (char*) &show_slave_running_cont,     SHOW_FUNC},
 
4136
  {"Slow_launch_threads",      (char*) &slow_launch_threads,    SHOW_LONG},
 
4137
  {"Slow_queries",             (char*) offsetof(STATUS_VAR, long_query_count), SHOW_LONG_STATUS},
 
4138
  {"Sort_merge_passes",        (char*) offsetof(STATUS_VAR, filesort_merge_passes), SHOW_LONG_STATUS},
 
4139
  {"Sort_range",               (char*) offsetof(STATUS_VAR, filesort_range_count), SHOW_LONG_STATUS},
 
4140
  {"Sort_rows",                (char*) offsetof(STATUS_VAR, filesort_rows), SHOW_LONG_STATUS},
 
4141
  {"Sort_scan",                (char*) offsetof(STATUS_VAR, filesort_scan_count), SHOW_LONG_STATUS},
 
4142
  {"Table_locks_immediate",    (char*) &locks_immediate,        SHOW_LONG},
 
4143
  {"Table_locks_waited",       (char*) &locks_waited,           SHOW_LONG},
 
4144
#ifdef HAVE_MMAP
 
4145
  {"Tc_log_max_pages_used",    (char*) &tc_log_max_pages_used,  SHOW_LONG},
 
4146
  {"Tc_log_page_size",         (char*) &tc_log_page_size,       SHOW_LONG},
 
4147
  {"Tc_log_page_waits",        (char*) &tc_log_page_waits,      SHOW_LONG},
 
4148
#endif
 
4149
  {"Threads_cached",           (char*) &cached_thread_count,    SHOW_LONG_NOFLUSH},
 
4150
  {"Threads_connected",        (char*) &connection_count,       SHOW_INT},
 
4151
  {"Threads_created",          (char*) &thread_created,         SHOW_LONG_NOFLUSH},
 
4152
  {"Threads_running",          (char*) &thread_running,         SHOW_INT},
 
4153
  {"Uptime",                   (char*) &show_starttime_cont,         SHOW_FUNC},
 
4154
  {"Uptime_since_flush_status",(char*) &show_flushstatustime_cont,   SHOW_FUNC},
 
4155
  {NULL, NULL, SHOW_LONG}
 
4156
};
 
4157
 
2006
4158
static void print_version(void)
2007
4159
{
 
4160
  set_server_version();
2008
4161
  /*
2009
4162
    Note: the instance manager keys off the string 'Ver' so it can find the
2010
 
    version from the output of 'drizzled --version', so don't change it!
 
4163
    version from the output of 'mysqld --version', so don't change it!
2011
4164
  */
2012
 
  printf("%s  Ver %s for %s-%s on %s (%s)\n",internal::my_progname,
2013
 
         PANDORA_RELEASE_VERSION, HOST_VENDOR, HOST_OS, HOST_CPU,
2014
 
         COMPILATION_COMMENT);
 
4165
  printf("%s  Ver %s for %s on %s (%s)\n",my_progname,
 
4166
         server_version,SYSTEM_TYPE,MACHINE_TYPE, DRIZZLE_COMPILATION_COMMENT);
2015
4167
}
2016
4168
 
2017
4169
static void usage(void)
2018
4170
{
2019
 
  if (!(default_charset_info= get_charset_by_csname(default_character_set_name, MY_CS_PRIMARY)))
 
4171
  if (!(default_charset_info= get_charset_by_csname(default_character_set_name,
 
4172
                                                   MY_CS_PRIMARY,
 
4173
                                                   MYF(MY_WME))))
2020
4174
    exit(1);
2021
4175
  if (!default_collation_name)
2022
4176
    default_collation_name= (char*) default_charset_info->name;
2023
4177
  print_version();
2024
 
  puts(_("Copyright (C) 2008 Sun Microsystems\n"
 
4178
  puts(_("Copyright (C) 2000 MySQL AB, by Monty and others\n"
2025
4179
         "This software comes with ABSOLUTELY NO WARRANTY. "
2026
4180
         "This is free software,\n"
2027
4181
         "and you are welcome to modify and redistribute it under the GPL "
2028
 
         "license\n\n"));
2029
 
 
2030
 
 
2031
 
  printf(_("Usage: %s [OPTIONS]\n"), internal::my_progname);
2032
 
 
2033
 
  po::options_description all_options("Drizzled Options");
2034
 
  all_options.add(long_options);
2035
 
  all_options.add(plugin_options);
2036
 
  cout << all_options << endl;
2037
 
 
 
4182
         "license\n\n"
 
4183
         "Starts the Drizzle database server\n"));
 
4184
 
 
4185
  printf(_("Usage: %s [OPTIONS]\n"), my_progname);
 
4186
  {
 
4187
#ifdef FOO
 
4188
  print_defaults(DRIZZLE_CONFIG_NAME,load_default_groups);
 
4189
  puts("");
 
4190
  set_ports();
 
4191
#endif
 
4192
 
 
4193
  /* Print out all the options including plugin supplied options */
 
4194
  my_print_help_inc_plugins(my_long_options, sizeof(my_long_options)/sizeof(my_option));
 
4195
 
 
4196
  puts(_("\nTo see what values a running Drizzle server is using, type\n"
 
4197
         "'drizzleadmin variables' instead of 'drizzled --help'."));
 
4198
  }
2038
4199
}
2039
4200
 
 
4201
 
2040
4202
/**
2041
 
  Initialize all Drizzle global variables to default values.
 
4203
  Initialize all MySQL global variables to default values.
2042
4204
 
2043
4205
  We don't need to set numeric variables refered to in my_long_options
2044
4206
  as these are initialized by my_getopt.
2053
4215
    as these are initialized by my_getopt.
2054
4216
*/
2055
4217
 
2056
 
static void drizzle_init_variables(void)
 
4218
static void mysql_init_variables(void)
2057
4219
{
2058
4220
  /* Things reset to zero */
2059
 
  drizzle_home[0]= pidfile_name[0]= 0;
 
4221
  opt_skip_slave_start= opt_reckless_slave = 0;
 
4222
  mysql_home[0]= pidfile_name[0]= log_error_file[0]= 0;
 
4223
  log_output_options= find_bit_type(log_output_str, &log_output_typelib);
 
4224
  opt_bin_log= 0;
 
4225
  opt_skip_show_db=0;
 
4226
  opt_logname= opt_binlog_index_name= 0;
2060
4227
  opt_tc_log_file= (char *)"tc.log";      // no hostname in tc_log file name !
 
4228
  opt_secure_auth= 0;
2061
4229
  opt_secure_file_priv= 0;
 
4230
  segfaulted= kill_in_progress= 0;
2062
4231
  cleanup_done= 0;
2063
 
  dropping_tables= ha_open_options=0;
2064
 
  test_flags.reset();
2065
 
  wake_thread=0;
2066
 
  abort_loop= select_thread_in_use= false;
 
4232
  defaults_argc= 0;
 
4233
  defaults_argv= 0;
 
4234
  server_id_supplied= 0;
 
4235
  test_flags= select_errors= dropping_tables= ha_open_options=0;
 
4236
  thread_count= thread_running= kill_cached_threads= wake_thread=0;
 
4237
  slave_open_temp_tables= 0;
 
4238
  cached_thread_count= 0;
 
4239
  opt_endinfo= using_udf_functions= 0;
 
4240
  opt_using_transactions= using_update_log= 0;
 
4241
  abort_loop= select_thread_in_use= signal_thread_in_use= 0;
2067
4242
  ready_to_exit= shutdown_in_progress= 0;
2068
 
  drizzled_user= drizzled_chroot= 0;
2069
 
  memset(&current_global_counters, 0, sizeof(current_global_counters));
2070
 
  key_map_full.set();
 
4243
  aborted_threads= aborted_connects= 0;
 
4244
  specialflag= 0;
 
4245
  binlog_cache_use=  binlog_cache_disk_use= 0;
 
4246
  max_used_connections= slow_launch_threads = 0;
 
4247
  mysqld_user= mysqld_chroot= opt_init_file= opt_bin_logname = 0;
 
4248
  opt_mysql_tmpdir= my_bind_addr_str= NULL;
 
4249
  memset(&mysql_tmpdir_list, 0, sizeof(mysql_tmpdir_list));
 
4250
  memset(&global_status_var, 0, sizeof(global_status_var));
 
4251
  key_map_full.set_all();
2071
4252
 
2072
4253
  /* Character sets */
2073
4254
  system_charset_info= &my_charset_utf8_general_ci;
2074
4255
  files_charset_info= &my_charset_utf8_general_ci;
 
4256
  national_charset_info= &my_charset_utf8_general_ci;
2075
4257
  table_alias_charset= &my_charset_bin;
2076
4258
  character_set_filesystem= &my_charset_bin;
2077
4259
 
 
4260
  opt_date_time_formats[0]= opt_date_time_formats[1]= opt_date_time_formats[2]= 0;
 
4261
 
2078
4262
  /* Things with default values that are not zero */
2079
 
  drizzle_home_ptr= drizzle_home;
 
4263
  delay_key_write_options= (uint) DELAY_KEY_WRITE_ON;
 
4264
  slave_exec_mode_options= 0;
 
4265
  slave_exec_mode_options= (uint)
 
4266
    find_bit_type_or_exit(slave_exec_mode_str, &slave_exec_mode_typelib, NULL);
 
4267
  mysql_home_ptr= mysql_home;
2080
4268
  pidfile_name_ptr= pidfile_name;
 
4269
  log_error_file_ptr= log_error_file;
2081
4270
  language_ptr= language;
2082
 
  session_startup_options= (OPTION_AUTO_IS_NULL | OPTION_SQL_NOTES);
 
4271
  mysql_data_home= mysql_real_data_home;
 
4272
  thd_startup_options= (OPTION_AUTO_IS_NULL | OPTION_BIN_LOG |
 
4273
                        OPTION_QUOTE_SHOW_CREATE | OPTION_SQL_NOTES);
 
4274
  protocol_version= PROTOCOL_VERSION;
 
4275
  what_to_log= ~ (1L << (uint) COM_TIME);
2083
4276
  refresh_version= 1L;  /* Increments on each reload */
2084
 
  global_thread_id= 1UL;
2085
 
  getSessionList().clear();
 
4277
  global_query_id= thread_id= 1L;
 
4278
  my_stpcpy(server_version, DRIZZLE_SERVER_VERSION);
 
4279
  myisam_recover_options_str= "OFF";
 
4280
  myisam_stats_method_str= "nulls_unequal";
 
4281
  threads.empty();
 
4282
  thread_cache.empty();
 
4283
  key_caches.empty();
 
4284
  if (!(dflt_key_cache= get_or_create_key_cache(default_key_cache_base.str,
 
4285
                                                default_key_cache_base.length)))
 
4286
    exit(1);
 
4287
  /* set key_cache_hash.default_value = dflt_key_cache */
 
4288
  multi_keycache_init();
2086
4289
 
2087
4290
  /* Set directory paths */
2088
 
  strncpy(language, LANGUAGE, sizeof(language)-1);
 
4291
  strmake(language, LANGUAGE, sizeof(language)-1);
 
4292
  strmake(mysql_real_data_home, get_relative_path(DATADIR),
 
4293
          sizeof(mysql_real_data_home)-1);
 
4294
  mysql_data_home_buff[0]=FN_CURLIB;    // all paths are relative from here
 
4295
  mysql_data_home_buff[1]=0;
 
4296
  mysql_data_home_len= 2;
 
4297
 
 
4298
  /* Replication parameters */
 
4299
  master_info_file= (char*) "master.info",
 
4300
    relay_log_info_file= (char*) "relay-log.info";
 
4301
  report_user= report_password = report_host= 0;        /* TO BE DELETED */
 
4302
  opt_relay_logname= opt_relaylog_index_name= 0;
2089
4303
 
2090
4304
  /* Variables in libraries */
2091
 
  default_character_set_name= "utf8";
2092
 
  default_collation_name= (char *)compiled_default_collation_name;
2093
 
  character_set_filesystem_name= "binary";
 
4305
  charsets_dir= 0;
 
4306
  default_character_set_name= (char*) DRIZZLE_DEFAULT_CHARSET_NAME;
 
4307
  default_collation_name= compiled_default_collation_name;
 
4308
  sys_charset_system.set((char*) system_charset_info->csname);
 
4309
  character_set_filesystem_name= (char*) "binary";
2094
4310
  lc_time_names_name= (char*) "en_US";
2095
4311
  /* Set default values for some option variables */
2096
4312
  default_storage_engine_str= (char*) "innodb";
2097
 
  global_system_variables.storage_engine= NULL;
 
4313
  global_system_variables.table_plugin= NULL;
2098
4314
  global_system_variables.tx_isolation= ISO_REPEATABLE_READ;
2099
4315
  global_system_variables.select_limit= (uint64_t) HA_POS_ERROR;
2100
4316
  max_system_variables.select_limit=    (uint64_t) HA_POS_ERROR;
2101
4317
  global_system_variables.max_join_size= (uint64_t) HA_POS_ERROR;
2102
4318
  max_system_variables.max_join_size=   (uint64_t) HA_POS_ERROR;
2103
 
  max_system_variables.auto_increment_increment= UINT64_MAX;
2104
 
  max_system_variables.auto_increment_offset= UINT64_MAX;
2105
 
  max_system_variables.completion_type= 2;
2106
 
  max_system_variables.log_warnings= 1;
2107
 
  max_system_variables.bulk_insert_buff_size= ULONG_MAX;
2108
 
  max_system_variables.div_precincrement= DECIMAL_MAX_SCALE;
2109
 
  max_system_variables.group_concat_max_len= ULONG_MAX;
2110
 
  max_system_variables.join_buff_size= ULONG_MAX;
2111
 
  max_system_variables.max_allowed_packet= 1024L*1024L*1024L;
2112
 
  max_system_variables.max_error_count= 65535;
2113
 
  max_system_variables.max_heap_table_size= MAX_MEM_TABLE_SIZE;
2114
 
  max_system_variables.max_join_size= INT32_MAX;
2115
 
  max_system_variables.max_length_for_sort_data= 8192*1024L;
2116
 
  max_system_variables.max_seeks_for_key= ULONG_MAX;
2117
 
  max_system_variables.max_sort_length= 8192*1024L;
2118
 
  max_system_variables.min_examined_row_limit= ULONG_MAX;
2119
 
  max_system_variables.optimizer_prune_level= 1;
2120
 
  max_system_variables.optimizer_search_depth= MAX_TABLES+2;
2121
 
  max_system_variables.preload_buff_size= 1024*1024*1024L;
2122
 
  max_system_variables.query_alloc_block_size= UINT32_MAX;
2123
 
  max_system_variables.query_prealloc_size= UINT32_MAX;
2124
 
  max_system_variables.range_alloc_block_size= SIZE_MAX;
2125
 
  max_system_variables.read_buff_size= INT32_MAX;
2126
 
  max_system_variables.read_rnd_buff_size= UINT32_MAX;
2127
 
  max_system_variables.sortbuff_size= SIZE_MAX;
2128
 
  max_system_variables.tmp_table_size= MAX_MEM_TABLE_SIZE;
2129
 
 
2130
 
  opt_scheduler_default= (char*) "multi_thread";
 
4319
  global_system_variables.old_alter_table= 0;
 
4320
  global_system_variables.binlog_format= BINLOG_FORMAT_UNSPEC;
 
4321
  /*
 
4322
    Default behavior for 4.1 and 5.0 is to treat NULL values as unequal
 
4323
    when collecting index statistics for MyISAM tables.
 
4324
  */
 
4325
  global_system_variables.myisam_stats_method= MI_STATS_METHOD_NULLS_NOT_EQUAL;
2131
4326
 
2132
4327
  /* Variables that depends on compile options */
 
4328
  opt_error_log= 0;
2133
4329
#ifdef HAVE_BROKEN_REALPATH
2134
4330
  have_symlink=SHOW_OPTION_NO;
2135
4331
#else
2136
4332
  have_symlink=SHOW_OPTION_YES;
2137
4333
#endif
 
4334
#ifdef HAVE_COMPRESS
 
4335
  have_compress= SHOW_OPTION_YES;
 
4336
#else
 
4337
  have_compress= SHOW_OPTION_NO;
 
4338
#endif
2138
4339
 
2139
4340
  const char *tmpenv;
2140
4341
  if (!(tmpenv = getenv("MY_BASEDIR_VERSION")))
2141
 
    tmpenv = PREFIX;
2142
 
  (void) strncpy(drizzle_home, tmpenv, sizeof(drizzle_home)-1);
2143
 
  
2144
 
  connection_count= 0;
 
4342
    tmpenv = DEFAULT_DRIZZLE_HOME;
 
4343
  (void) strmake(mysql_home, tmpenv, sizeof(mysql_home)-1);
2145
4344
}
2146
4345
 
2147
4346
 
2148
 
/**
2149
 
  @todo
2150
 
  - FIXME add EXIT_TOO_MANY_ARGUMENTS to "drizzled/error.h" and return that code?
2151
 
*/
2152
 
static void get_options()
 
4347
bool
 
4348
mysqld_get_one_option(int optid,
 
4349
                      const struct my_option *opt __attribute__((unused)),
 
4350
                      char *argument)
2153
4351
{
2154
 
 
2155
 
  if (vm.count("base-dir"))
2156
 
  {
2157
 
    strncpy(drizzle_home,vm["base-dir"].as<string>().c_str(),sizeof(drizzle_home)-1);
2158
 
  }
2159
 
 
2160
 
  if (vm.count("datadir"))
2161
 
  {
2162
 
    getDataHome()= vm["datadir"].as<string>();
2163
 
  }
2164
 
  string &data_home_catalog= getDataHomeCatalog();
2165
 
  data_home_catalog= getDataHome();
2166
 
  data_home_catalog.push_back('/');
2167
 
  data_home_catalog.append("local");
2168
 
 
2169
 
  if (vm.count("user"))
2170
 
  {
2171
 
    if (! drizzled_user || ! strcmp(drizzled_user, vm["user"].as<string>().c_str()))
2172
 
      drizzled_user= (char *)vm["user"].as<string>().c_str();
2173
 
 
 
4352
  switch(optid) {
 
4353
  case '#':
 
4354
    opt_endinfo=1;                              /* unireg: memory allocation */
 
4355
    break;
 
4356
  case 'a':
 
4357
    global_system_variables.tx_isolation= ISO_SERIALIZABLE;
 
4358
    break;
 
4359
  case 'b':
 
4360
    strmake(mysql_home,argument,sizeof(mysql_home)-1);
 
4361
    break;
 
4362
  case 'C':
 
4363
    if (default_collation_name == compiled_default_collation_name)
 
4364
      default_collation_name= 0;
 
4365
    break;
 
4366
  case 'h':
 
4367
    strmake(mysql_real_data_home,argument, sizeof(mysql_real_data_home)-1);
 
4368
    /* Correct pointer set by my_getopt (for embedded library) */
 
4369
    mysql_data_home= mysql_real_data_home;
 
4370
    mysql_data_home_len= strlen(mysql_data_home);
 
4371
    break;
 
4372
  case 'u':
 
4373
    if (!mysqld_user || !strcmp(mysqld_user, argument))
 
4374
      mysqld_user= argument;
2174
4375
    else
2175
 
      errmsg_printf(ERRMSG_LVL_WARN, _("Ignoring user change to '%s' because the user was "
2176
 
                                       "set to '%s' earlier on the command line\n"),
2177
 
                    vm["user"].as<string>().c_str(), drizzled_user);
2178
 
  }
2179
 
 
2180
 
  if (vm.count("language"))
2181
 
  {
2182
 
    strncpy(language, vm["language"].as<string>().c_str(), sizeof(language)-1);
2183
 
  }
2184
 
 
2185
 
  if (vm.count("version"))
2186
 
  {
 
4376
      sql_print_warning(_("Ignoring user change to '%s' because the user was "
 
4377
                          "set to '%s' earlier on the command line\n"),
 
4378
                        argument, mysqld_user);
 
4379
    break;
 
4380
  case 'L':
 
4381
    strmake(language, argument, sizeof(language)-1);
 
4382
    break;
 
4383
  case OPT_SLAVE_SKIP_ERRORS:
 
4384
    init_slave_skip_errors(argument);
 
4385
    break;
 
4386
  case OPT_SLAVE_EXEC_MODE:
 
4387
    slave_exec_mode_options= (uint)
 
4388
      find_bit_type_or_exit(argument, &slave_exec_mode_typelib, "");
 
4389
    break;
 
4390
  case 'V':
2187
4391
    print_version();
2188
4392
    exit(0);
2189
 
  }
2190
 
 
2191
 
  if (vm.count("log-warnings"))
2192
 
  {
2193
 
    if (vm["log-warnings"].as<string>().empty())
 
4393
  case 'W':
 
4394
    if (!argument)
2194
4395
      global_system_variables.log_warnings++;
2195
 
    else if (vm["log-warnings"].as<string>().compare("0"))
 
4396
    else if (argument == disabled_my_option)
2196
4397
      global_system_variables.log_warnings= 0L;
2197
4398
    else
2198
 
      global_system_variables.log_warnings= atoi(vm["log-warnings"].as<string>().c_str());
2199
 
  }
2200
 
 
2201
 
  if (vm.count("exit-info"))
2202
 
  {
2203
 
    if (vm["exit-info"].as<long>())
2204
 
    {
2205
 
      test_flags.set((uint32_t) vm["exit-info"].as<long>());
2206
 
    }
2207
 
  }
2208
 
 
2209
 
  if (vm.count("want-core"))
2210
 
  {
2211
 
    test_flags.set(TEST_CORE_ON_SIGNAL);
2212
 
  }
2213
 
 
2214
 
  if (vm.count("skip-stack-trace"))
2215
 
  {
2216
 
    test_flags.set(TEST_NO_STACKTRACE);
2217
 
  }
2218
 
 
2219
 
  if (vm.count("skip-symlinks"))
2220
 
  {
2221
 
    internal::my_use_symdir=0;
2222
 
  }
2223
 
 
2224
 
  if (vm.count("pid-file"))
2225
 
  {
2226
 
    strncpy(pidfile_name, vm["pid-file"].as<string>().c_str(), sizeof(pidfile_name)-1);
2227
 
  }
2228
 
 
2229
 
  if (vm.count("transaction-isolation"))
2230
 
  {
2231
 
    int type;
2232
 
    type= find_type_or_exit((char *)vm["transaction-isolation"].as<string>().c_str(), &tx_isolation_typelib, "transaction-isolation");
2233
 
    global_system_variables.tx_isolation= (type-1);
2234
 
  }
2235
 
 
2236
 
  /* @TODO Make this all strings */
2237
 
  if (vm.count("default-storage-engine"))
2238
 
  {
2239
 
    default_storage_engine_str= (char *)vm["default-storage-engine"].as<string>().c_str();
2240
 
  }
 
4399
      global_system_variables.log_warnings= atoi(argument);
 
4400
    break;
 
4401
  case 'T':
 
4402
    test_flags= argument ? (uint) atoi(argument) : 0;
 
4403
    opt_endinfo=1;
 
4404
    break;
 
4405
  case (int) OPT_BIN_LOG:
 
4406
    opt_bin_log= test(argument != disabled_my_option);
 
4407
    break;
 
4408
  case (int) OPT_ERROR_LOG_FILE:
 
4409
    opt_error_log= 1;
 
4410
    break;
 
4411
  case (int)OPT_REPLICATE_IGNORE_DB:
 
4412
    {
 
4413
      rpl_filter->add_ignore_db(argument);
 
4414
      break;
 
4415
    }
 
4416
  case (int)OPT_REPLICATE_DO_DB:
 
4417
    {
 
4418
      rpl_filter->add_do_db(argument);
 
4419
      break;
 
4420
    }
 
4421
  case (int)OPT_REPLICATE_REWRITE_DB:
 
4422
    {
 
4423
      char* key = argument,*p, *val;
 
4424
 
 
4425
      if (!(p= strstr(argument, "->")))
 
4426
      {
 
4427
        fprintf(stderr,
 
4428
                _("Bad syntax in replicate-rewrite-db - missing '->'!\n"));
 
4429
        exit(1);
 
4430
      }
 
4431
      val= p--;
 
4432
      while (my_isspace(mysqld_charset, *p) && p > argument)
 
4433
        *p-- = 0;
 
4434
      if (p == argument)
 
4435
      {
 
4436
        fprintf(stderr,
 
4437
                _("Bad syntax in replicate-rewrite-db - empty FROM db!\n"));
 
4438
        exit(1);
 
4439
      }
 
4440
      *val= 0;
 
4441
      val+= 2;
 
4442
      while (*val && my_isspace(mysqld_charset, *val))
 
4443
        *val++;
 
4444
      if (!*val)
 
4445
      {
 
4446
        fprintf(stderr,
 
4447
                _("Bad syntax in replicate-rewrite-db - empty TO db!\n"));
 
4448
        exit(1);
 
4449
      }
 
4450
 
 
4451
      rpl_filter->add_db_rewrite(key, val);
 
4452
      break;
 
4453
    }
 
4454
 
 
4455
  case (int)OPT_BINLOG_IGNORE_DB:
 
4456
    {
 
4457
      binlog_filter->add_ignore_db(argument);
 
4458
      break;
 
4459
    }
 
4460
  case OPT_BINLOG_FORMAT:
 
4461
    {
 
4462
      int id;
 
4463
      id= find_type_or_exit(argument, &binlog_format_typelib, opt->name);
 
4464
      global_system_variables.binlog_format= opt_binlog_format_id= id - 1;
 
4465
      break;
 
4466
    }
 
4467
  case (int)OPT_BINLOG_DO_DB:
 
4468
    {
 
4469
      binlog_filter->add_do_db(argument);
 
4470
      break;
 
4471
    }
 
4472
  case (int)OPT_REPLICATE_DO_TABLE:
 
4473
    {
 
4474
      if (rpl_filter->add_do_table(argument))
 
4475
      {
 
4476
        fprintf(stderr, _("Could not add do table rule '%s'!\n"), argument);
 
4477
        exit(1);
 
4478
      }
 
4479
      break;
 
4480
    }
 
4481
  case (int)OPT_REPLICATE_WILD_DO_TABLE:
 
4482
    {
 
4483
      if (rpl_filter->add_wild_do_table(argument))
 
4484
      {
 
4485
        fprintf(stderr, _("Could not add do table rule '%s'!\n"), argument);
 
4486
        exit(1);
 
4487
      }
 
4488
      break;
 
4489
    }
 
4490
  case (int)OPT_REPLICATE_WILD_IGNORE_TABLE:
 
4491
    {
 
4492
      if (rpl_filter->add_wild_ignore_table(argument))
 
4493
      {
 
4494
        fprintf(stderr, _("Could not add ignore table rule '%s'!\n"), argument);
 
4495
        exit(1);
 
4496
      }
 
4497
      break;
 
4498
    }
 
4499
  case (int)OPT_REPLICATE_IGNORE_TABLE:
 
4500
    {
 
4501
      if (rpl_filter->add_ignore_table(argument))
 
4502
      {
 
4503
        fprintf(stderr, _("Could not add ignore table rule '%s'!\n"), argument);
 
4504
        exit(1);
 
4505
      }
 
4506
      break;
 
4507
    }
 
4508
  case (int) OPT_WANT_CORE:
 
4509
    test_flags |= TEST_CORE_ON_SIGNAL;
 
4510
    break;
 
4511
  case (int) OPT_SKIP_STACK_TRACE:
 
4512
    test_flags|=TEST_NO_STACKTRACE;
 
4513
    break;
 
4514
  case (int) OPT_SKIP_SYMLINKS:
 
4515
    my_use_symdir=0;
 
4516
    break;
 
4517
  case (int) OPT_BIND_ADDRESS:
 
4518
    {
 
4519
      struct addrinfo *res_lst, hints;
 
4520
 
 
4521
      memset(&hints, 0, sizeof(struct addrinfo));
 
4522
      hints.ai_socktype= SOCK_STREAM;
 
4523
      hints.ai_protocol= IPPROTO_TCP;
 
4524
 
 
4525
      if (getaddrinfo(argument, NULL, &hints, &res_lst) != 0)
 
4526
      {
 
4527
        sql_print_error(_("Can't start server: cannot resolve hostname!"));
 
4528
        exit(1);
 
4529
      }
 
4530
 
 
4531
      if (res_lst->ai_next)
 
4532
      {
 
4533
        sql_print_error(_("Can't start server: bind-address refers to "
 
4534
                          "multiple interfaces!"));
 
4535
        exit(1);
 
4536
      }
 
4537
      freeaddrinfo(res_lst);
 
4538
    }
 
4539
    break;
 
4540
  case (int) OPT_PID_FILE:
 
4541
    strmake(pidfile_name, argument, sizeof(pidfile_name)-1);
 
4542
    break;
 
4543
  case OPT_CONSOLE:
 
4544
    if (opt_console)
 
4545
      opt_error_log= 0;                 // Force logs to stdout
 
4546
    break;
 
4547
  case OPT_LOW_PRIORITY_UPDATES:
 
4548
    thr_upgraded_concurrent_insert_lock= TL_WRITE_LOW_PRIORITY;
 
4549
    global_system_variables.low_priority_updates=1;
 
4550
    break;
 
4551
  case OPT_SERVER_ID:
 
4552
    server_id_supplied = 1;
 
4553
    break;
 
4554
  case OPT_DELAY_KEY_WRITE_ALL:
 
4555
    if (argument != disabled_my_option)
 
4556
      argument= (char*) "ALL";
 
4557
    /* Fall through */
 
4558
  case OPT_DELAY_KEY_WRITE:
 
4559
    if (argument == disabled_my_option)
 
4560
      delay_key_write_options= (uint) DELAY_KEY_WRITE_NONE;
 
4561
    else if (! argument)
 
4562
      delay_key_write_options= (uint) DELAY_KEY_WRITE_ON;
 
4563
    else
 
4564
    {
 
4565
      int type;
 
4566
      type= find_type_or_exit(argument, &delay_key_write_typelib, opt->name);
 
4567
      delay_key_write_options= (uint) type-1;
 
4568
    }
 
4569
    break;
 
4570
  case OPT_CHARSETS_DIR:
 
4571
    strmake(mysql_charsets_dir, argument, sizeof(mysql_charsets_dir)-1);
 
4572
    charsets_dir = mysql_charsets_dir;
 
4573
    break;
 
4574
  case OPT_TX_ISOLATION:
 
4575
    {
 
4576
      int type;
 
4577
      type= find_type_or_exit(argument, &tx_isolation_typelib, opt->name);
 
4578
      global_system_variables.tx_isolation= (type-1);
 
4579
      break;
 
4580
    }
 
4581
  case OPT_MYISAM_RECOVER:
 
4582
    {
 
4583
      if (!argument)
 
4584
      {
 
4585
        myisam_recover_options=    HA_RECOVER_DEFAULT;
 
4586
        myisam_recover_options_str= myisam_recover_typelib.type_names[0];
 
4587
      }
 
4588
      else if (!argument[0])
 
4589
      {
 
4590
        myisam_recover_options= HA_RECOVER_NONE;
 
4591
        myisam_recover_options_str= "OFF";
 
4592
      }
 
4593
      else
 
4594
      {
 
4595
        myisam_recover_options_str=argument;
 
4596
        myisam_recover_options=
 
4597
          find_bit_type_or_exit(argument, &myisam_recover_typelib, opt->name);
 
4598
      }
 
4599
      ha_open_options|=HA_OPEN_ABORT_IF_CRASHED;
 
4600
      break;
 
4601
    }
 
4602
  case OPT_TC_HEURISTIC_RECOVER:
 
4603
    tc_heuristic_recover= find_type_or_exit(argument,
 
4604
                                            &tc_heuristic_recover_typelib,
 
4605
                                            opt->name);
 
4606
    break;
 
4607
  case OPT_MYISAM_STATS_METHOD:
 
4608
    {
 
4609
      uint32_t method_conv;
 
4610
      int method;
 
4611
 
 
4612
      myisam_stats_method_str= argument;
 
4613
      method= find_type_or_exit(argument, &myisam_stats_method_typelib,
 
4614
                                opt->name);
 
4615
      switch (method-1) {
 
4616
      case 2:
 
4617
        method_conv= MI_STATS_METHOD_IGNORE_NULLS;
 
4618
        break;
 
4619
      case 1:
 
4620
        method_conv= MI_STATS_METHOD_NULLS_EQUAL;
 
4621
        break;
 
4622
      case 0:
 
4623
      default:
 
4624
        method_conv= MI_STATS_METHOD_NULLS_NOT_EQUAL;
 
4625
        break;
 
4626
      }
 
4627
      global_system_variables.myisam_stats_method= method_conv;
 
4628
      break;
 
4629
    }
 
4630
  }
 
4631
  return 0;
 
4632
}
 
4633
 
 
4634
 
 
4635
/** Handle arguments for multiple key caches. */
 
4636
 
 
4637
extern "C" char **mysql_getopt_value(const char *keyname, uint32_t key_length,
 
4638
                                      const struct my_option *option);
 
4639
 
 
4640
char**
 
4641
mysql_getopt_value(const char *keyname, uint32_t key_length,
 
4642
                   const struct my_option *option)
 
4643
{
 
4644
  switch (option->id) {
 
4645
  case OPT_KEY_BUFFER_SIZE:
 
4646
  case OPT_KEY_CACHE_BLOCK_SIZE:
 
4647
  case OPT_KEY_CACHE_DIVISION_LIMIT:
 
4648
  case OPT_KEY_CACHE_AGE_THRESHOLD:
 
4649
  {
 
4650
    KEY_CACHE *key_cache;
 
4651
    if (!(key_cache= get_or_create_key_cache(keyname, key_length)))
 
4652
      exit(1);
 
4653
    switch (option->id) {
 
4654
    case OPT_KEY_BUFFER_SIZE:
 
4655
      return (char**) &key_cache->param_buff_size;
 
4656
    case OPT_KEY_CACHE_BLOCK_SIZE:
 
4657
      return (char**) &key_cache->param_block_size;
 
4658
    case OPT_KEY_CACHE_DIVISION_LIMIT:
 
4659
      return (char**) &key_cache->param_division_limit;
 
4660
    case OPT_KEY_CACHE_AGE_THRESHOLD:
 
4661
      return (char**) &key_cache->param_age_threshold;
 
4662
    }
 
4663
  }
 
4664
  }
 
4665
  return (char **)option->value;
 
4666
}
 
4667
 
 
4668
 
 
4669
extern "C" void option_error_reporter(enum loglevel level, const char *format, ...);
 
4670
 
 
4671
void option_error_reporter(enum loglevel level, const char *format, ...)
 
4672
{
 
4673
  va_list args;
 
4674
  va_start(args, format);
 
4675
 
 
4676
  /* Don't print warnings for --loose options during bootstrap */
 
4677
  if (level == ERROR_LEVEL || global_system_variables.log_warnings)
 
4678
  {
 
4679
    vprint_msg_to_log(level, format, args);
 
4680
  }
 
4681
  va_end(args);
 
4682
}
 
4683
 
 
4684
 
 
4685
/**
 
4686
  @todo
 
4687
  - FIXME add EXIT_TOO_MANY_ARGUMENTS to "mysys_err.h" and return that code?
 
4688
*/
 
4689
static void get_options(int *argc,char **argv)
 
4690
{
 
4691
  int ho_error;
 
4692
 
 
4693
  my_getopt_register_get_addr(mysql_getopt_value);
 
4694
  my_getopt_error_reporter= option_error_reporter;
2241
4695
 
2242
4696
  /* Skip unknown options so that they may be processed later by plugins */
2243
4697
  my_getopt_skip_unknown= true;
2244
4698
 
 
4699
  if ((ho_error= handle_options(argc, &argv, my_long_options,
 
4700
                                mysqld_get_one_option)))
 
4701
    exit(ho_error);
 
4702
  (*argc)++; /* add back one for the progname handle_options removes */
 
4703
             /* no need to do this for argv as we are discarding it. */
2245
4704
 
2246
4705
#if defined(HAVE_BROKEN_REALPATH)
2247
 
  internal::my_use_symdir=0;
2248
 
  internal::my_disable_symlinks=1;
 
4706
  my_use_symdir=0;
 
4707
  my_disable_symlinks=1;
2249
4708
  have_symlink=SHOW_OPTION_NO;
2250
4709
#else
2251
 
  if (!internal::my_use_symdir)
 
4710
  if (!my_use_symdir)
2252
4711
  {
2253
 
    internal::my_disable_symlinks=1;
 
4712
    my_disable_symlinks=1;
2254
4713
    have_symlink=SHOW_OPTION_DISABLED;
2255
4714
  }
2256
4715
#endif
2257
4716
  if (opt_debugging)
2258
4717
  {
2259
4718
    /* Allow break with SIGINT, no core or stack trace */
2260
 
    test_flags.set(TEST_SIGINT);
2261
 
    test_flags.set(TEST_NO_STACKTRACE);
2262
 
    test_flags.reset(TEST_CORE_ON_SIGNAL);
 
4719
    test_flags|= TEST_SIGINT | TEST_NO_STACKTRACE;
 
4720
    test_flags&= ~TEST_CORE_ON_SIGNAL;
2263
4721
  }
 
4722
  /* Set global MyISAM variables from delay_key_write_options */
 
4723
  fix_delay_key_write((THD*) 0, OPT_GLOBAL);
 
4724
  /* Set global slave_exec_mode from its option */
 
4725
  fix_slave_exec_mode(OPT_GLOBAL);
2264
4726
 
2265
 
  if (drizzled_chroot)
2266
 
    set_root(drizzled_chroot);
 
4727
  if (mysqld_chroot)
 
4728
    set_root(mysqld_chroot);
 
4729
  fix_paths();
2267
4730
 
2268
4731
  /*
2269
4732
    Set some global variables from the global_system_variables
2270
4733
    In most cases the global variables will not be used
2271
4734
  */
2272
 
  internal::my_default_record_cache_size=global_system_variables.read_buff_size;
2273
 
}
2274
 
 
2275
 
 
2276
 
static const char *get_relative_path(const char *path)
2277
 
{
2278
 
  if (internal::test_if_hard_path(path) &&
2279
 
      (strncmp(path, PREFIX, strlen(PREFIX)) == 0) &&
2280
 
      strcmp(PREFIX,FN_ROOTDIR))
 
4735
  my_default_record_cache_size=global_system_variables.read_buff_size;
 
4736
  myisam_max_temp_length=
 
4737
    (my_off_t) global_system_variables.myisam_max_sort_file_size;
 
4738
 
 
4739
  /* Set global variables based on startup options */
 
4740
  myisam_block_size=(uint) 1 << my_bit_log2(opt_myisam_block_size);
 
4741
 
 
4742
  /* long_query_time is in microseconds */
 
4743
  global_system_variables.long_query_time= max_system_variables.long_query_time=
 
4744
    (int64_t) (long_query_time * 1000000.0);
 
4745
 
 
4746
  if (init_global_datetime_format(DRIZZLE_TIMESTAMP_DATE,
 
4747
                                  &global_system_variables.date_format) ||
 
4748
      init_global_datetime_format(DRIZZLE_TIMESTAMP_TIME,
 
4749
                                  &global_system_variables.time_format) ||
 
4750
      init_global_datetime_format(DRIZZLE_TIMESTAMP_DATETIME,
 
4751
                                  &global_system_variables.datetime_format))
 
4752
    exit(1);
 
4753
 
 
4754
  pool_of_threads_scheduler(&thread_scheduler);  /* purecov: tested */
 
4755
}
 
4756
 
 
4757
 
 
4758
/*
 
4759
  Create version name for running mysqld version
 
4760
  We automaticly add suffixes -debug, -embedded and -log to the version
 
4761
  name to make the version more descriptive.
 
4762
  (DRIZZLE_SERVER_SUFFIX is set by the compilation environment)
 
4763
*/
 
4764
 
 
4765
#ifdef DRIZZLE_SERVER_SUFFIX
 
4766
#define DRIZZLE_SERVER_SUFFIX_STR STRINGIFY_ARG(DRIZZLE_SERVER_SUFFIX)
 
4767
#else
 
4768
#define DRIZZLE_SERVER_SUFFIX_STR DRIZZLE_SERVER_SUFFIX_DEF
 
4769
#endif
 
4770
 
 
4771
static void set_server_version(void)
 
4772
{
 
4773
  char *end= strxmov(server_version, DRIZZLE_SERVER_VERSION,
 
4774
                     DRIZZLE_SERVER_SUFFIX_STR, NULL);
 
4775
  if (opt_bin_log)
 
4776
    my_stpcpy(end, "-log");                        // This may slow down system
 
4777
}
 
4778
 
 
4779
 
 
4780
static char *get_relative_path(const char *path)
 
4781
{
 
4782
  if (test_if_hard_path(path) &&
 
4783
      is_prefix(path,DEFAULT_DRIZZLE_HOME) &&
 
4784
      strcmp(DEFAULT_DRIZZLE_HOME,FN_ROOTDIR))
2281
4785
  {
2282
 
    if (strlen(PREFIX) < strlen(path))
2283
 
      path+=(size_t) strlen(PREFIX);
 
4786
    path+=(uint) strlen(DEFAULT_DRIZZLE_HOME);
2284
4787
    while (*path == FN_LIBCHAR)
2285
4788
      path++;
2286
4789
  }
2287
 
  return path;
2288
 
}
2289
 
 
2290
 
 
2291
 
static void fix_paths(string progname)
2292
 
{
2293
 
  char buff[FN_REFLEN],*pos,rp_buff[PATH_MAX];
2294
 
  internal::convert_dirname(drizzle_home,drizzle_home,NULL);
2295
 
  /* Resolve symlinks to allow 'drizzle_home' to be a relative symlink */
2296
 
#if defined(HAVE_BROKEN_REALPATH)
2297
 
   internal::my_load_path(drizzle_home, drizzle_home, NULL);
2298
 
#else
2299
 
  if (!realpath(drizzle_home,rp_buff))
2300
 
    internal::my_load_path(rp_buff, drizzle_home, NULL);
2301
 
  rp_buff[FN_REFLEN-1]= '\0';
2302
 
  strcpy(drizzle_home,rp_buff);
2303
 
  /* Ensure that drizzle_home ends in FN_LIBCHAR */
2304
 
  pos= strchr(drizzle_home, '\0');
2305
 
#endif
 
4790
  return (char*) path;
 
4791
}
 
4792
 
 
4793
 
 
4794
/**
 
4795
  Fix filename and replace extension where 'dir' is relative to
 
4796
  mysql_real_data_home.
 
4797
  @return
 
4798
    1 if len(path) > FN_REFLEN
 
4799
*/
 
4800
 
 
4801
bool
 
4802
fn_format_relative_to_data_home(char * to, const char *name,
 
4803
                                const char *dir, const char *extension)
 
4804
{
 
4805
  char tmp_path[FN_REFLEN];
 
4806
  if (!test_if_hard_path(dir))
 
4807
  {
 
4808
    strxnmov(tmp_path,sizeof(tmp_path)-1, mysql_real_data_home,
 
4809
             dir, NULL);
 
4810
    dir=tmp_path;
 
4811
  }
 
4812
  return !fn_format(to, name, dir, extension,
 
4813
                    MY_APPEND_EXT | MY_UNPACK_FILENAME | MY_SAFE_PATH);
 
4814
}
 
4815
 
 
4816
 
 
4817
static void fix_paths(void)
 
4818
{
 
4819
  char buff[FN_REFLEN],*pos;
 
4820
  convert_dirname(mysql_home,mysql_home,NULL);
 
4821
  /* Resolve symlinks to allow 'mysql_home' to be a relative symlink */
 
4822
  my_realpath(mysql_home,mysql_home,MYF(0));
 
4823
  /* Ensure that mysql_home ends in FN_LIBCHAR */
 
4824
  pos= strchr(mysql_home, '\0');
2306
4825
  if (pos[-1] != FN_LIBCHAR)
2307
4826
  {
2308
4827
    pos[0]= FN_LIBCHAR;
2309
4828
    pos[1]= 0;
2310
4829
  }
2311
 
  internal::convert_dirname(language,language,NULL);
2312
 
  (void) internal::my_load_path(drizzle_home, drizzle_home,""); // Resolve current dir
2313
 
  (void) internal::my_load_path(pidfile_name, pidfile_name,
2314
 
                                getDataHome().c_str());
2315
 
 
2316
 
  if (opt_plugin_dir_ptr == NULL)
2317
 
  {
2318
 
    /* No plugin dir has been specified. Figure out where the plugins are */
2319
 
    if (progname[0] != FN_LIBCHAR)
2320
 
    {
2321
 
      /* We have a relative path and need to find the absolute */
2322
 
      char working_dir[FN_REFLEN];
2323
 
      char *working_dir_ptr= working_dir;
2324
 
      working_dir_ptr= getcwd(working_dir_ptr, FN_REFLEN);
2325
 
      string new_path(working_dir);
2326
 
      if (*(new_path.end()-1) != '/')
2327
 
        new_path.push_back('/');
2328
 
      if (progname[0] == '.' && progname[1] == '/')
2329
 
        new_path.append(progname.substr(2));
2330
 
      else
2331
 
        new_path.append(progname);
2332
 
      progname.swap(new_path);
2333
 
    }
2334
 
 
2335
 
    /* Now, trim off the exe name */
2336
 
    string progdir(progname.substr(0, progname.rfind(FN_LIBCHAR)+1));
2337
 
    if (progdir.rfind(".libs/") != string::npos)
2338
 
    {
2339
 
      progdir.assign(progdir.substr(0, progdir.rfind(".libs/")));
2340
 
    }
2341
 
    string testlofile(progdir);
2342
 
    testlofile.append("drizzled.lo");
2343
 
    string testofile(progdir);
2344
 
    testofile.append("drizzled.o");
2345
 
    struct stat testfile_stat;
2346
 
    if (stat(testlofile.c_str(), &testfile_stat) && stat(testofile.c_str(), &testfile_stat))
2347
 
    {
2348
 
      /* neither drizzled.lo or drizzled.o exist - we are not in a source dir.
2349
 
       * Go on as usual
2350
 
       */
2351
 
      (void) internal::my_load_path(opt_plugin_dir, get_relative_path(PKGPLUGINDIR),
2352
 
                                          drizzle_home);
2353
 
    }
2354
 
    else
2355
 
    {
2356
 
      /* We are in a source dir! Plugin dir is ../plugin/.libs */
2357
 
      size_t last_libchar_pos= progdir.rfind(FN_LIBCHAR,progdir.size()-2)+1;
2358
 
      string source_plugindir(progdir.substr(0,last_libchar_pos));
2359
 
      source_plugindir.append("plugin/.libs");
2360
 
      (void) internal::my_load_path(opt_plugin_dir, source_plugindir.c_str(), "");
2361
 
    }
2362
 
  }
2363
 
  else
2364
 
  {
2365
 
    (void) internal::my_load_path(opt_plugin_dir, opt_plugin_dir_ptr, drizzle_home);
2366
 
  }
 
4830
  convert_dirname(mysql_real_data_home,mysql_real_data_home,NULL);
 
4831
  (void) fn_format(buff, mysql_real_data_home, "", "",
 
4832
                   (MY_RETURN_REAL_PATH|MY_RESOLVE_SYMLINKS));
 
4833
  (void) unpack_dirname(mysql_unpacked_real_data_home, buff);
 
4834
  convert_dirname(language,language,NULL);
 
4835
  (void) my_load_path(mysql_home,mysql_home,""); // Resolve current dir
 
4836
  (void) my_load_path(mysql_real_data_home,mysql_real_data_home,mysql_home);
 
4837
  (void) my_load_path(pidfile_name,pidfile_name,mysql_real_data_home);
 
4838
  (void) my_load_path(opt_plugin_dir, opt_plugin_dir_ptr ? opt_plugin_dir_ptr :
 
4839
                                      get_relative_path(PLUGINDIR), mysql_home);
2367
4840
  opt_plugin_dir_ptr= opt_plugin_dir;
2368
4841
 
2369
 
  const char *sharedir= get_relative_path(PKGDATADIR);
2370
 
  if (internal::test_if_hard_path(sharedir))
2371
 
    strncpy(buff,sharedir,sizeof(buff)-1);
 
4842
  char *sharedir=get_relative_path(SHAREDIR);
 
4843
  if (test_if_hard_path(sharedir))
 
4844
    strmake(buff,sharedir,sizeof(buff)-1);              /* purecov: tested */
2372
4845
  else
 
4846
    strxnmov(buff,sizeof(buff)-1,mysql_home,sharedir,NULL);
 
4847
  convert_dirname(buff,buff,NULL);
 
4848
  (void) my_load_path(language,language,buff);
 
4849
 
 
4850
  /* If --character-sets-dir isn't given, use shared library dir */
 
4851
  if (charsets_dir != mysql_charsets_dir)
2373
4852
  {
2374
 
    strcpy(buff, drizzle_home);
2375
 
    strncat(buff, sharedir, sizeof(buff)-strlen(drizzle_home)-1);
 
4853
    strxnmov(mysql_charsets_dir, sizeof(mysql_charsets_dir)-1, buff,
 
4854
             CHARSET_DIR, NULL);
2376
4855
  }
2377
 
  internal::convert_dirname(buff,buff,NULL);
2378
 
  (void) internal::my_load_path(language,language,buff);
 
4856
  (void) my_load_path(mysql_charsets_dir, mysql_charsets_dir, buff);
 
4857
  convert_dirname(mysql_charsets_dir, mysql_charsets_dir, NULL);
 
4858
  charsets_dir=mysql_charsets_dir;
2379
4859
 
2380
 
  if (not opt_help and not opt_help_extended)
 
4860
  if (init_tmpdir(&mysql_tmpdir_list, opt_mysql_tmpdir))
 
4861
    exit(1);
 
4862
  if (!slave_load_tmpdir)
2381
4863
  {
2382
 
    const char *tmp_string= getenv("TMPDIR") ? getenv("TMPDIR") : NULL;
2383
 
    struct stat buf;
2384
 
    drizzle_tmpdir.clear();
2385
 
 
2386
 
    if (vm.count("tmpdir"))
2387
 
    {
2388
 
      drizzle_tmpdir.append(vm["tmpdir"].as<string>());
2389
 
    }
2390
 
    else if (tmp_string == NULL)
2391
 
    {
2392
 
      drizzle_tmpdir.append(getDataHome());
2393
 
      drizzle_tmpdir.push_back(FN_LIBCHAR);
2394
 
      drizzle_tmpdir.append(GLOBAL_TEMPORARY_EXT);
2395
 
    }
2396
 
    else
2397
 
    {
2398
 
      drizzle_tmpdir.append(tmp_string);
2399
 
    }
2400
 
 
2401
 
    assert(drizzle_tmpdir.size());
2402
 
 
2403
 
    if (mkdir(drizzle_tmpdir.c_str(), 0777) == -1)
2404
 
    {
2405
 
      if (errno != EEXIST)
2406
 
      {
2407
 
        perror(drizzle_tmpdir.c_str());
2408
 
        exit(1);
2409
 
      }
2410
 
    }
2411
 
 
2412
 
    if (stat(drizzle_tmpdir.c_str(), &buf) || (S_ISDIR(buf.st_mode) == false))
2413
 
    {
2414
 
      perror(drizzle_tmpdir.c_str());
 
4864
    if (!(slave_load_tmpdir = (char*) my_strdup(mysql_tmpdir, MYF(MY_FAE))))
2415
4865
      exit(1);
2416
 
    }
2417
4866
  }
2418
 
 
2419
4867
  /*
2420
4868
    Convert the secure-file-priv option to system format, allowing
2421
4869
    a quick strcmp to check if read or write is in an allowed dir
2422
4870
   */
2423
 
  if (vm.count("secure-file-priv"))
 
4871
  if (opt_secure_file_priv)
2424
4872
  {
2425
 
    internal::convert_dirname(buff, vm["secure-file-priv"].as<string>().c_str(), NULL);
 
4873
    convert_dirname(buff, opt_secure_file_priv, NULL);
2426
4874
    free(opt_secure_file_priv);
2427
 
    opt_secure_file_priv= strdup(buff);
2428
 
    if (opt_secure_file_priv == NULL)
2429
 
      exit(1);
2430
 
  }
2431
 
}
2432
 
 
2433
 
} /* namespace drizzled */
2434
 
 
 
4875
    opt_secure_file_priv= my_strdup(buff, MYF(MY_FAE));
 
4876
  }
 
4877
}
 
4878
 
 
4879
 
 
4880
static uint32_t find_bit_type_or_exit(const char *x, TYPELIB *bit_lib,
 
4881
                                   const char *option)
 
4882
{
 
4883
  uint32_t res;
 
4884
 
 
4885
  const char **ptr;
 
4886
 
 
4887
  if ((res= find_bit_type(x, bit_lib)) == ~(uint32_t) 0)
 
4888
  {
 
4889
    ptr= bit_lib->type_names;
 
4890
    if (!*x)
 
4891
      fprintf(stderr, _("No option given to %s\n"), option);
 
4892
    else
 
4893
      fprintf(stderr, _("Wrong option to %s. Option(s) given: %s\n"),
 
4894
              option, x);
 
4895
    fprintf(stderr, _("Alternatives are: '%s'"), *ptr);
 
4896
    while (*++ptr)
 
4897
      fprintf(stderr, ",'%s'", *ptr);
 
4898
    fprintf(stderr, "\n");
 
4899
    exit(1);
 
4900
  }
 
4901
  return res;
 
4902
}
 
4903
 
 
4904
 
 
4905
/**
 
4906
  @return
 
4907
    a bitfield from a string of substrings separated by ','
 
4908
    or
 
4909
    ~(uint32_t) 0 on error.
 
4910
*/
 
4911
 
 
4912
static uint32_t find_bit_type(const char *x, TYPELIB *bit_lib)
 
4913
{
 
4914
  bool found_end;
 
4915
  int  found_count;
 
4916
  const char *end,*i,*j;
 
4917
  const char **array, *pos;
 
4918
  uint32_t found,found_int,bit;
 
4919
 
 
4920
  found=0;
 
4921
  found_end= 0;
 
4922
  pos=(char *) x;
 
4923
  while (*pos == ' ') pos++;
 
4924
  found_end= *pos == 0;
 
4925
  while (!found_end)
 
4926
  {
 
4927
    if ((end=strrchr(pos,',')) != NULL)         /* Let end point at fieldend */
 
4928
    {
 
4929
      while (end > pos && end[-1] == ' ')
 
4930
        end--;                                  /* Skip end-space */
 
4931
      found_end=1;
 
4932
    }
 
4933
    else
 
4934
    {
 
4935
        end=pos+strlen(pos);
 
4936
        found_end=1;
 
4937
    }
 
4938
    found_int=0; found_count=0;
 
4939
    for (array=bit_lib->type_names, bit=1 ; (i= *array++) ; bit<<=1)
 
4940
    {
 
4941
      j=pos;
 
4942
      while (j != end)
 
4943
      {
 
4944
        if (my_toupper(mysqld_charset,*i++) !=
 
4945
            my_toupper(mysqld_charset,*j++))
 
4946
          goto skip;
 
4947
      }
 
4948
      found_int=bit;
 
4949
      if (! *i)
 
4950
      {
 
4951
        found_count=1;
 
4952
        break;
 
4953
      }
 
4954
      else if (j != pos)                        // Half field found
 
4955
      {
 
4956
        found_count++;                          // Could be one of two values
 
4957
      }
 
4958
skip: ;
 
4959
    }
 
4960
    if (found_count != 1)
 
4961
      return(~(uint32_t) 0);                            // No unique value
 
4962
    found|=found_int;
 
4963
    pos=end+1;
 
4964
  }
 
4965
 
 
4966
  return(found);
 
4967
} /* find_bit_type */
 
4968
 
 
4969
 
 
4970
/**
 
4971
  Create file to store pid number.
 
4972
*/
 
4973
static void create_pid_file()
 
4974
{
 
4975
  File file;
 
4976
  if ((file = my_create(pidfile_name,0664,
 
4977
                        O_WRONLY | O_TRUNC, MYF(MY_WME))) >= 0)
 
4978
  {
 
4979
    char buff[21], *end;
 
4980
    end= int10_to_str((long) getpid(), buff, 10);
 
4981
    *end++= '\n';
 
4982
    if (!my_write(file, (unsigned char*) buff, (uint) (end-buff), MYF(MY_WME | MY_NABP)))
 
4983
    {
 
4984
      (void) my_close(file, MYF(0));
 
4985
      return;
 
4986
    }
 
4987
    (void) my_close(file, MYF(0));
 
4988
  }
 
4989
  sql_perror("Can't start server: can't create PID file");
 
4990
  exit(1);
 
4991
}
 
4992
 
 
4993
/** Clear most status variables. */
 
4994
void refresh_status(THD *thd)
 
4995
{
 
4996
  pthread_mutex_lock(&LOCK_status);
 
4997
 
 
4998
  /* Add thread's status variabes to global status */
 
4999
  add_to_status(&global_status_var, &thd->status_var);
 
5000
 
 
5001
  /* Reset thread's status variables */
 
5002
  memset(&thd->status_var, 0, sizeof(thd->status_var));
 
5003
 
 
5004
  /* Reset some global variables */
 
5005
  reset_status_vars();
 
5006
 
 
5007
  /* Reset the counters of all key caches (default and named). */
 
5008
  process_key_caches(reset_key_cache_counters);
 
5009
  flush_status_time= time((time_t*) 0);
 
5010
  pthread_mutex_unlock(&LOCK_status);
 
5011
 
 
5012
  /*
 
5013
    Set max_used_connections to the number of currently open
 
5014
    connections.  Lock LOCK_thread_count out of LOCK_status to avoid
 
5015
    deadlocks.  Status reset becomes not atomic, but status data is
 
5016
    not exact anyway.
 
5017
  */
 
5018
  pthread_mutex_lock(&LOCK_thread_count);
 
5019
  max_used_connections= thread_count;
 
5020
  pthread_mutex_unlock(&LOCK_thread_count);
 
5021
}
 
5022
 
 
5023
 
 
5024
/*****************************************************************************
 
5025
  Instantiate templates
 
5026
*****************************************************************************/
 
5027
 
 
5028
#ifdef HAVE_EXPLICIT_TEMPLATE_INSTANTIATION
 
5029
/* Used templates */
 
5030
template class I_List<THD>;
 
5031
template class I_List_iterator<THD>;
 
5032
template class I_List<i_string>;
 
5033
template class I_List<i_string_pair>;
 
5034
template class I_List<NAMED_LIST>;
 
5035
template class I_List<Statement>;
 
5036
template class I_List_iterator<Statement>;
 
5037
#endif