← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/drizzled.cc

  • Committer: Padraig O'Sullivan
  • Date: 2009-08-08 04:22:33 UTC
  • mto: (1115.3.4 captain)
  • mto: This revision was merged to the branch mainline in revision 1117.
  • Revision ID: osullivan.padraig@gmail.com-20090808042233-q0z88zc490z3f3r7
Renamed the Command class to be Statement. Renamed the command directory to
statement and also the command header file to statement. Updated various
source files to reflect this renaming.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/drizzled.cc
17
17
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18
18
 */
19
19
 
20
 
#include "config.h"
 
20
 
 
21
#include <drizzled/server_includes.h>
21
22
#include <drizzled/configmake.h>
22
23
#include <drizzled/atomics.h>
23
24
 
24
25
#include <netdb.h>
25
 
#include <sys/types.h>
26
26
#include <netinet/tcp.h>
27
 
#include <netinet/in.h>
28
27
#include <signal.h>
29
 
#include <limits.h>
30
28
 
31
 
#include "drizzled/internal/my_sys.h"
32
 
#include "drizzled/internal/my_bit.h"
33
 
#include <drizzled/my_hash.h>
 
29
#include <mysys/my_bit.h>
 
30
#include <mysys/hash.h>
34
31
#include <drizzled/stacktrace.h>
 
32
#include <mysys/mysys_err.h>
35
33
#include <drizzled/error.h>
36
34
#include <drizzled/errmsg_print.h>
37
35
#include <drizzled/tztime.h>
40
38
#include <drizzled/sql_parse.h>
41
39
#include <drizzled/item/cmpfunc.h>
42
40
#include <drizzled/session.h>
 
41
#include <drizzled/db.h>
43
42
#include <drizzled/item/create.h>
 
43
#include <drizzled/errmsg.h>
44
44
#include <drizzled/unireg.h>
 
45
#include <drizzled/scheduling.h>
45
46
#include "drizzled/temporal_format.h" /* For init_temporal_formats() */
46
 
#include "drizzled/plugin/listen.h"
47
 
#include "drizzled/plugin/error_message.h"
48
 
#include "drizzled/plugin/client.h"
49
 
#include "drizzled/plugin/scheduler.h"
50
 
#include "drizzled/plugin/xa_resource_manager.h"
51
 
#include "drizzled/plugin/monitored_in_transaction.h"
52
 
#include "drizzled/probes.h"
53
 
#include "drizzled/session_list.h"
54
 
#include "drizzled/charset.h"
55
 
#include "plugin/myisam/myisam.h"
 
47
#include <drizzled/listen.h>
56
48
 
57
49
#include <google/protobuf/stubs/common.h>
58
50
 
67
59
# endif
68
60
#endif
69
61
 
 
62
#include <plugin/myisam/ha_myisam.h>
 
63
 
70
64
#ifdef HAVE_SYS_PRCTL_H
71
65
#include <sys/prctl.h>
72
66
#endif
73
 
#include <sys/socket.h>
74
67
 
75
68
#include <locale.h>
76
69
 
77
 
 
 
70
#define mysqld_charset &my_charset_utf8_general_ci
 
71
 
 
72
#ifdef HAVE_purify
 
73
#define IF_PURIFY(A,B) (A)
 
74
#else
 
75
#define IF_PURIFY(A,B) (B)
 
76
#endif
 
77
 
 
78
#define MAX_MEM_TABLE_SIZE SIZE_MAX
 
79
 
 
80
extern "C" {                                    // Because of SCO 3.2V4.2
78
81
#include <errno.h>
79
82
#include <sys/stat.h>
80
 
#include "drizzled/option.h"
 
83
#include <mysys/my_getopt.h>
81
84
#ifdef HAVE_SYSENT_H
82
85
#include <sysent.h>
83
86
#endif
 
87
#ifdef HAVE_PWD_H
84
88
#include <pwd.h>                                // For getpwent
 
89
#endif
 
90
#ifdef HAVE_GRP_H
85
91
#include <grp.h>
 
92
#endif
86
93
 
87
94
#include <sys/resource.h>
88
95
 
102
109
 
103
110
#if defined(__FreeBSD__) && defined(HAVE_IEEEFP_H)
104
111
#include <ieeefp.h>
 
112
#ifdef HAVE_FP_EXCEPT                           // Fix type conflict
 
113
typedef fp_except fp_except_t;
 
114
#endif
105
115
#endif /* __FreeBSD__ && HAVE_IEEEFP_H */
106
116
 
107
117
#ifdef HAVE_FPU_CONTROL_H
113
123
#include <sys/fpu.h>
114
124
#endif
115
125
 
116
 
#include "drizzled/internal/my_pthread.h"                       // For thr_setconcurency()
117
 
 
118
 
#include <drizzled/gettext.h>
119
 
 
120
 
 
121
 
#ifdef HAVE_purify
122
 
#define IF_PURIFY(A,B) (A)
123
 
#else
124
 
#define IF_PURIFY(A,B) (B)
125
 
#endif
126
 
 
127
 
#define MAX_MEM_TABLE_SIZE SIZE_MAX
128
 
 
129
 
using namespace std;
130
 
 
131
 
namespace drizzled
132
 
{
133
 
 
134
 
#define mysqld_charset &my_charset_utf8_general_ci
135
126
inline void setup_fpu()
136
127
{
137
128
#if defined(__FreeBSD__) && defined(HAVE_IEEEFP_H)
161
152
#endif /* __i386__ && HAVE_FPU_CONTROL_H && _FPU_DOUBLE */
162
153
}
163
154
 
 
155
} /* cplusplus */
 
156
 
 
157
#include <mysys/my_pthread.h>                   // For thr_setconcurency()
 
158
 
 
159
#include <drizzled/gettext.h>
 
160
 
164
161
#ifdef SOLARIS
165
162
extern "C" int gethostname(char *name, int namelen);
166
163
#endif
167
164
 
 
165
extern "C" void handle_segfault(int sig);
 
166
 
 
167
using namespace std;
 
168
 
168
169
/* Constants */
 
170
 
 
171
const char *show_comp_option_name[]= {"YES", "NO", "DISABLED"};
 
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
 
169
189
static const char *tc_heuristic_recover_names[]=
170
190
{
171
191
  "COMMIT", "ROLLBACK", NULL
177
197
};
178
198
 
179
199
const char *first_keyword= "first";
 
200
const char *binary_keyword= "BINARY";
180
201
const char * const DRIZZLE_CONFIG_NAME= "drizzled";
181
202
#define GET_HA_ROWS GET_ULL
182
203
 
183
 
const char *tx_isolation_names[] =
184
 
{ "READ-UNCOMMITTED", "READ-COMMITTED", "REPEATABLE-READ", "SERIALIZABLE",
185
 
  NULL};
186
 
 
187
 
TYPELIB tx_isolation_typelib= {array_elements(tx_isolation_names)-1,"",
188
 
                               tx_isolation_names, NULL};
189
 
 
190
204
/*
191
205
  Used with --help for detailed option
192
206
*/
193
207
static bool opt_help= false;
194
 
static bool opt_help_extended= false;
195
208
 
196
209
arg_cmp_func Arg_comparator::comparator_matrix[5][2] =
197
210
{{&Arg_comparator::compare_string,     &Arg_comparator::compare_e_string},
212
225
static const char *default_character_set_name;
213
226
static const char *character_set_filesystem_name;
214
227
static char *lc_time_names_name;
 
228
static char *my_bind_addr_str;
215
229
static char *default_collation_name;
216
230
static char *default_storage_engine_str;
217
231
static const char *compiled_default_collation_name= "utf8_general_ci";
218
232
 
219
233
/* Global variables */
220
234
 
 
235
bool opt_endinfo;
 
236
bool locked_in_memory;
221
237
bool volatile abort_loop;
222
238
bool volatile shutdown_in_progress;
223
239
uint32_t max_used_connections;
227
243
size_t my_thread_stack_size= 65536;
228
244
 
229
245
/*
230
 
  Legacy global plugin::StorageEngine. These will be removed (please do not add more).
 
246
  Legacy global StorageEngine. These will be removed (please do not add more).
231
247
*/
232
 
plugin::StorageEngine *heap_engine;
233
 
plugin::StorageEngine *myisam_engine;
 
248
StorageEngine *heap_engine;
 
249
StorageEngine *myisam_engine;
234
250
 
235
251
char* opt_secure_file_priv= 0;
236
252
 
 
253
#ifdef HAVE_INITGROUPS
237
254
static bool calling_initgroups= false; /**< Used in SIGSEGV handler. */
238
 
 
239
 
uint32_t drizzled_bind_timeout;
 
255
#endif
 
256
 
 
257
/*
 
258
  This needs to be a uint32_t and not a in_port_t because the config system
 
259
  requires a 4-byte integer.
 
260
*/
 
261
uint32_t drizzled_tcp_port;
 
262
 
 
263
uint32_t drizzled_port_timeout;
240
264
std::bitset<12> test_flags;
241
265
uint32_t dropping_tables, ha_open_options;
 
266
uint32_t delay_key_write_options;
242
267
uint32_t tc_heuristic_recover= 0;
243
268
uint64_t session_startup_options;
244
269
uint32_t back_log;
 
270
uint32_t connect_timeout;
245
271
uint32_t server_id;
246
272
uint64_t table_cache_size;
247
 
size_t table_def_size;
 
273
uint64_t table_def_size;
248
274
uint64_t aborted_threads;
249
275
uint64_t aborted_connects;
250
276
uint64_t max_connect_errors;
251
 
uint32_t global_thread_id= 1UL;
 
277
uint32_t thread_id=1L;
252
278
pid_t current_pid;
253
279
 
254
 
extern const double log_10[309];
255
 
 
256
280
const double log_10[] = {
257
281
  1e000, 1e001, 1e002, 1e003, 1e004, 1e005, 1e006, 1e007, 1e008, 1e009,
258
282
  1e010, 1e011, 1e012, 1e013, 1e014, 1e015, 1e016, 1e017, 1e018, 1e019,
304
328
char drizzle_data_home_buff[2], *drizzle_data_home=drizzle_real_data_home;
305
329
char *drizzle_tmpdir= NULL;
306
330
char *opt_drizzle_tmpdir= NULL;
 
331
const char *myisam_stats_method_str="nulls_unequal";
307
332
 
308
333
/** name of reference on left espression in rewritten IN subquery */
309
334
const char *in_left_expr_name= "<left expr>";
316
341
 
317
342
FILE *stderror_file=0;
318
343
 
 
344
vector<Session*> session_list;
 
345
 
319
346
struct system_variables global_system_variables;
320
347
struct system_variables max_system_variables;
321
348
struct system_status_var global_status_var;
347
374
/* Static variables */
348
375
 
349
376
static bool segfaulted;
 
377
#ifdef HAVE_STACK_TRACE_ON_SEGV
 
378
static bool opt_do_pstack;
 
379
#endif /* HAVE_STACK_TRACE_ON_SEGV */
350
380
int cleanup_done;
351
381
static char *drizzle_home_ptr, *pidfile_name_ptr;
352
382
static int defaults_argc;
360
390
  Number of currently active user connections. The variable is protected by
361
391
  LOCK_thread_count.
362
392
*/
363
 
atomic<uint32_t> connection_count;
 
393
drizzled::atomic<uint32_t> connection_count;
364
394
 
365
395
/** 
366
396
  Refresh value. We use to test this to find out if a refresh even has happened recently.
367
397
*/
368
 
uint64_t refresh_version;  /* Increments on each reload */
 
398
drizzled::atomic<uint32_t> refresh_version;  /* Increments on each reload */
369
399
 
370
400
/* Function declarations */
371
 
bool drizzle_rm_tmp_tables();
372
401
 
373
402
extern "C" pthread_handler_t signal_hand(void *arg);
374
403
static void drizzle_init_variables(void);
375
404
static void get_options(int *argc,char **argv);
376
 
int drizzled_get_one_option(int, const struct option *, char *);
 
405
extern "C" bool drizzled_get_one_option(int, const struct my_option *, char *);
377
406
static int init_thread_environment();
378
407
static const char *get_relative_path(const char *path);
379
 
static void fix_paths(string &progname);
 
408
static void fix_paths(void);
380
409
extern "C" pthread_handler_t handle_slave(void *arg);
381
410
static void clean_up(bool print_message);
382
411
 
383
412
static void usage(void);
384
413
static void clean_up_mutexes(void);
 
414
static void create_new_thread(Session *session);
 
415
extern "C" void end_thread_signal(int );
385
416
void close_connections(void);
 
417
extern "C" void print_signal_warning(int sig);
386
418
 
387
419
/****************************************************************************
388
420
** Code to end drizzled
391
423
void close_connections(void)
392
424
{
393
425
  /* Abort listening to new connections */
394
 
  plugin::Listen::shutdown();
 
426
  listen_abort();
395
427
 
396
428
  /* kill connection thread */
397
429
  (void) pthread_mutex_lock(&LOCK_thread_count);
419
451
  */
420
452
 
421
453
  Session *tmp;
 
454
  Scheduler &thread_scheduler= get_thread_scheduler();
422
455
 
423
456
  (void) pthread_mutex_lock(&LOCK_thread_count); // For unlink from list
424
457
 
425
 
  for( SessionList::iterator it= getSessionList().begin(); it != getSessionList().end(); ++it )
 
458
  for( vector<Session*>::iterator it= session_list.begin(); it != session_list.end(); ++it )
426
459
  {
427
460
    tmp= *it;
428
461
    tmp->killed= Session::KILL_CONNECTION;
429
 
    tmp->scheduler->killSession(tmp);
430
 
    DRIZZLE_CONNECTION_DONE(tmp->thread_id);
 
462
    thread_scheduler.post_kill_notification(tmp);
431
463
    if (tmp->mysys_var)
432
464
    {
433
465
      tmp->mysys_var->abort=1;
454
486
  for (;;)
455
487
  {
456
488
    (void) pthread_mutex_lock(&LOCK_thread_count); // For unlink from list
457
 
    if (getSessionList().empty())
 
489
    if (session_list.empty())
458
490
    {
459
491
      (void) pthread_mutex_unlock(&LOCK_thread_count);
460
492
      break;
461
493
    }
462
 
    tmp= getSessionList().front();
463
 
    /* Close before unlock, avoiding crash. See LP bug#436685 */
464
 
    tmp->client->close();
 
494
    tmp= session_list.front();
465
495
    (void) pthread_mutex_unlock(&LOCK_thread_count);
 
496
    tmp->protocol->forceClose();
466
497
  }
467
498
}
468
499
 
469
 
extern "C" void print_signal_warning(int sig);
470
500
 
471
 
extern "C" void print_signal_warning(int sig)
 
501
void print_signal_warning(int sig)
472
502
{
473
503
  if (global_system_variables.log_warnings)
474
 
    errmsg_printf(ERRMSG_LVL_WARN, _("Got signal %d from thread %"PRIu64),
475
 
                  sig, global_thread_id);
 
504
    errmsg_printf(ERRMSG_LVL_WARN, _("Got signal %d from thread %"PRIu64), sig,my_thread_id());
476
505
#ifndef HAVE_BSD_SIGNALS
477
506
  my_sigset(sig,print_signal_warning);          /* int. thread system calls */
478
507
#endif
493
522
void unireg_end(void)
494
523
{
495
524
  clean_up(1);
496
 
  internal::my_thread_end();
 
525
  my_thread_end();
497
526
#if defined(SIGNALS_DONT_BREAK_READ)
498
527
  exit(0);
499
528
#else
507
536
 
508
537
  if (exit_code)
509
538
    errmsg_printf(ERRMSG_LVL_ERROR, _("Aborting\n"));
510
 
  else if (opt_help || opt_help_extended)
 
539
  else if (opt_help)
511
540
    usage();
512
 
  clean_up(!opt_help && (exit_code));
 
541
  clean_up(!opt_help && (exit_code)); /* purecov: inspected */
513
542
  clean_up_mutexes();
514
 
  internal::my_end();
515
 
  exit(exit_code);
 
543
  my_end(opt_endinfo ? MY_CHECK_ERROR | MY_GIVE_INFO : 0);
 
544
  exit(exit_code); /* purecov: inspected */
516
545
}
517
546
 
518
547
 
519
548
static void clean_up(bool print_message)
520
549
{
521
550
  if (cleanup_done++)
522
 
    return;
 
551
    return; /* purecov: inspected */
523
552
 
524
553
  table_cache_free();
525
554
  TableShare::cacheStop();
526
555
  set_var_free();
527
556
  free_charsets();
528
 
  plugin::Registry &plugins= plugin::Registry::singleton();
529
 
  plugin_shutdown(plugins);
 
557
  plugin_shutdown();
 
558
  ha_end();
530
559
  xid_cache_free();
531
560
  free_status_vars();
532
561
  if (defaults_argv)
533
 
    internal::free_defaults(defaults_argv);
 
562
    free_defaults(defaults_argv);
534
563
  free(drizzle_tmpdir);
535
564
  if (opt_secure_file_priv)
536
565
    free(opt_secure_file_priv);
544
573
  (void) unlink(pidfile_name);  // This may not always exist
545
574
 
546
575
  if (print_message && server_start_time)
547
 
    errmsg_printf(ERRMSG_LVL_INFO, _(ER(ER_SHUTDOWN_COMPLETE)),internal::my_progname);
 
576
    errmsg_printf(ERRMSG_LVL_INFO, _(ER(ER_SHUTDOWN_COMPLETE)),my_progname);
 
577
  /* Returns NULL on globerrs, we don't want to try to free that */
 
578
  //void *freeme=
 
579
  (void *)my_error_unregister(ER_ERROR_FIRST, ER_ERROR_LAST);
 
580
  // TODO!!!! EPIC FAIL!!!! This sefaults if uncommented.
 
581
/*  if (freeme != NULL)
 
582
    free(freeme);  */
548
583
  (void) pthread_mutex_lock(&LOCK_thread_count);
549
584
  ready_to_exit=1;
550
585
  /* do the broadcast inside the lock to ensure that my_end() is not called */
574
609
}
575
610
 
576
611
 
 
612
/**
 
613
 * Setup default port value from (in order or precedence):
 
614
 * - Command line option
 
615
 * - DRIZZLE_TCP_PORT environment variable
 
616
 * - Compile options
 
617
 * - Lookup in /etc/services
 
618
 * - Default value
 
619
 */
 
620
static void set_default_port()
 
621
{
 
622
  struct servent *serv_ptr;
 
623
  char *env;
 
624
 
 
625
  if (drizzled_tcp_port == 0)
 
626
  {
 
627
    drizzled_tcp_port= DRIZZLE_TCP_PORT;
 
628
 
 
629
    if (DRIZZLE_TCP_PORT_DEFAULT == 0)
 
630
    {
 
631
      if ((serv_ptr= getservbyname("drizzle", "tcp")))
 
632
        drizzled_tcp_port= ntohs((u_short) serv_ptr->s_port);
 
633
    }
 
634
 
 
635
    if ((env = getenv("DRIZZLE_TCP_PORT")))
 
636
      drizzled_tcp_port= (uint32_t) atoi(env);
 
637
 
 
638
    assert(drizzled_tcp_port != 0);
 
639
  }
 
640
}
 
641
 
577
642
/* Change to run as another user if started with --user */
578
643
 
579
644
static struct passwd *check_user(const char *user)
587
652
    if (user)
588
653
    {
589
654
      /* Don't give a warning, if real user is same as given with --user */
 
655
      /* purecov: begin tested */
590
656
      tmp_user_info= getpwnam(user);
591
657
      if ((!tmp_user_info || user_id != tmp_user_info->pw_uid) &&
592
658
          global_system_variables.log_warnings)
593
659
            errmsg_printf(ERRMSG_LVL_WARN, _("One can only use the --user switch "
594
660
                            "if running as root\n"));
 
661
      /* purecov: end */
595
662
    }
596
663
    return NULL;
597
664
  }
601
668
                      "the manual to find out how to run drizzled as root!\n"));
602
669
    unireg_abort(1);
603
670
  }
 
671
  /* purecov: begin tested */
604
672
  if (!strcmp(user,"root"))
605
673
    return NULL;                        // Avoid problem with dynamic libraries
606
674
 
615
683
      goto err;
616
684
  }
617
685
  return tmp_user_info;
 
686
  /* purecov: end */
618
687
 
619
688
err:
620
689
  errmsg_printf(ERRMSG_LVL_ERROR, _("Fatal error: Can't change to run as user '%s' ;  "
638
707
 
639
708
static void set_user(const char *user, struct passwd *user_info_arg)
640
709
{
 
710
  /* purecov: begin tested */
641
711
  assert(user_info_arg != 0);
 
712
#ifdef HAVE_INITGROUPS
642
713
  /*
643
714
    We can get a SIGSEGV when calling initgroups() on some systems when NSS
644
715
    is configured to use LDAP and the server is statically linked.  We set
648
719
  calling_initgroups= true;
649
720
  initgroups((char*) user, user_info_arg->pw_gid);
650
721
  calling_initgroups= false;
 
722
#endif
651
723
  if (setgid(user_info_arg->pw_gid) == -1)
652
724
  {
653
725
    sql_perror("setgid");
658
730
    sql_perror("setuid");
659
731
    unireg_abort(1);
660
732
  }
 
733
  /* purecov: end */
 
734
}
 
735
 
 
736
 
 
737
static void set_effective_user(struct passwd *user_info_arg)
 
738
{
 
739
  assert(user_info_arg != 0);
 
740
  if (setregid((gid_t)-1, user_info_arg->pw_gid) == -1)
 
741
  {
 
742
    sql_perror("setregid");
 
743
    unireg_abort(1);
 
744
  }
 
745
  if (setreuid((uid_t)-1, user_info_arg->pw_uid) == -1)
 
746
  {
 
747
    sql_perror("setreuid");
 
748
    unireg_abort(1);
 
749
  }
661
750
}
662
751
 
663
752
 
671
760
  }
672
761
}
673
762
 
674
 
extern "C" void end_thread_signal(int );
675
763
 
676
764
/** Called when a thread is aborted. */
677
 
extern "C" void end_thread_signal(int )
 
765
void end_thread_signal(int )
678
766
{
679
767
  Session *session=current_session;
680
768
  if (session)
681
769
  {
682
770
    statistic_increment(killed_threads, &LOCK_status);
683
 
    session->scheduler->killSessionNow(session);
684
 
    DRIZZLE_CONNECTION_DONE(session->thread_id);
 
771
    Scheduler &thread_scheduler= get_thread_scheduler();
 
772
    (void)thread_scheduler.end_thread(session, 0);
685
773
  }
686
 
  return;
 
774
  return;                               /* purecov: deadcode */
687
775
}
688
776
 
689
777
 
691
779
  Unlink session from global list of available connections and free session
692
780
 
693
781
  SYNOPSIS
694
 
    Session::unlink()
 
782
    unlink_session()
695
783
    session              Thread handler
696
784
 
697
785
  NOTES
698
786
    LOCK_thread_count is locked and left locked
699
787
*/
700
788
 
701
 
void Session::unlink(Session *session)
 
789
void unlink_session(Session *session)
702
790
{
703
 
  connection_count.decrement();
 
791
  connection_count--;
704
792
 
705
793
  session->cleanup();
706
794
 
707
795
  (void) pthread_mutex_lock(&LOCK_thread_count);
708
796
  pthread_mutex_lock(&session->LOCK_delete);
709
797
 
710
 
  getSessionList().erase(remove(getSessionList().begin(),
711
 
                         getSessionList().end(),
712
 
                         session));
 
798
  session_list.erase(remove(session_list.begin(),
 
799
                     session_list.end(),
 
800
                     session));
713
801
 
714
802
  delete session;
715
803
  (void) pthread_mutex_unlock(&LOCK_thread_count);
720
808
 
721
809
#ifdef THREAD_SPECIFIC_SIGPIPE
722
810
/**
 
811
  Aborts a thread nicely. Comes here on SIGPIPE.
723
812
 
724
813
  @todo
725
814
    One should have to fix that thr_alarm know about this thread too.
741
830
}
742
831
#endif
743
832
 
744
 
extern "C" void handle_segfault(int sig);
745
833
 
746
834
extern "C" void handle_segfault(int sig)
747
835
{
770
858
  }
771
859
 
772
860
  localtime_r(&curr_time, &tm);
 
861
  Scheduler &thread_scheduler= get_thread_scheduler();
773
862
  
774
863
  fprintf(stderr,"%02d%02d%02d %2d:%02d:%02d - drizzled got signal %d;\n"
775
864
          "This could be because you hit a bug. It is also possible that "
787
876
          (uint32_t) dflt_key_cache->key_cache_mem_size);
788
877
  fprintf(stderr, "read_buffer_size=%ld\n", (long) global_system_variables.read_buff_size);
789
878
  fprintf(stderr, "max_used_connections=%u\n", max_used_connections);
 
879
  fprintf(stderr, "max_threads=%u\n", thread_scheduler.get_max_threads());
 
880
  fprintf(stderr, "thread_count=%u\n", thread_scheduler.count());
790
881
  fprintf(stderr, "connection_count=%u\n", uint32_t(connection_count));
791
882
  fprintf(stderr, _("It is possible that drizzled could use up to \n"
792
883
                    "key_buffer_size + (read_buffer_size + "
793
 
                    "sort_buffer_size)*thread_count\n"
 
884
                    "sort_buffer_size)*max_threads = %"PRIu64" K\n"
794
885
                    "bytes of memory\n"
795
886
                    "Hope that's ok; if not, decrease some variables in the "
796
 
                    "equation.\n\n"));
 
887
                    "equation.\n\n"),
 
888
          (uint64_t)(((uint32_t) dflt_key_cache->key_cache_mem_size +
 
889
                     (global_system_variables.read_buff_size +
 
890
                      global_system_variables.sortbuff_size) *
 
891
                     thread_scheduler.get_max_threads()) / 1024));
797
892
 
798
893
#ifdef HAVE_STACKTRACE
799
894
  Session *session= current_session;
832
927
    fprintf(stderr, _("Trying to get some variables.\n"
833
928
                      "Some pointers may be invalid and cause the "
834
929
                      "dump to abort...\n"));
835
 
    safe_print_str("session->query", session->query.c_str(), 1024);
 
930
    safe_print_str("session->query", session->query, 1024);
836
931
    fprintf(stderr, "session->thread_id=%"PRIu32"\n", (uint32_t) session->thread_id);
837
932
    fprintf(stderr, "session->killed=%s\n", kreason);
838
933
  }
839
934
  fflush(stderr);
840
935
#endif /* HAVE_STACKTRACE */
841
936
 
 
937
#ifdef HAVE_INITGROUPS
842
938
  if (calling_initgroups)
843
939
    fprintf(stderr, _("\nThis crash occurred while the server was calling "
844
940
                      "initgroups(). This is\n"
851
947
                      "later when used with nscd), disable LDAP in your "
852
948
                      "nsswitch.conf, or use a\n"
853
949
                      "drizzled that is not statically linked.\n"));
 
950
#endif
854
951
 
855
 
  if (internal::thd_lib_detected == THD_LIB_LT && !getenv("LD_ASSUME_KERNEL"))
 
952
  if (thd_lib_detected == THD_LIB_LT && !getenv("LD_ASSUME_KERNEL"))
856
953
    fprintf(stderr,
857
954
            _("\nYou are running a statically-linked LinuxThreads binary "
858
955
              "on an NPTL system.\n"
864
961
              "Please consult\n"
865
962
              "the documentation for your distribution on how to do that.\n"));
866
963
 
 
964
  if (locked_in_memory)
 
965
  {
 
966
    fprintf(stderr,
 
967
            _("\nThe '--memlock' argument, which was enabled, uses system "
 
968
              "calls that are\n"
 
969
              "unreliable and unstable on some operating systems and "
 
970
              "operating-system\n"
 
971
              "versions (notably, some versions of Linux).  "
 
972
              "This crash could be due to use\n"
 
973
              "of those buggy OS calls.  You should consider whether you "
 
974
              "really need the\n"
 
975
              "'--memlock' parameter and/or consult the OS "
 
976
              "distributor about 'mlockall'\n bugs.\n"));
 
977
  }
 
978
 
867
979
#ifdef HAVE_WRITE_CORE
868
980
  if (test_flags.test(TEST_CORE_ON_SIGNAL))
869
981
  {
883
995
#define SA_NODEFER 0
884
996
#endif
885
997
 
 
998
static void init_signals(void)
 
999
{
 
1000
  sigset_t set;
 
1001
  struct sigaction sa;
 
1002
 
 
1003
  if (!(test_flags.test(TEST_NO_STACKTRACE) || 
 
1004
        test_flags.test(TEST_CORE_ON_SIGNAL)))
 
1005
  {
 
1006
    sa.sa_flags = SA_RESETHAND | SA_NODEFER;
 
1007
    sigemptyset(&sa.sa_mask);
 
1008
    sigprocmask(SIG_SETMASK,&sa.sa_mask,NULL);
 
1009
 
 
1010
    init_stacktrace();
 
1011
    sa.sa_handler=handle_segfault;
 
1012
    sigaction(SIGSEGV, &sa, NULL);
 
1013
    sigaction(SIGABRT, &sa, NULL);
 
1014
#ifdef SIGBUS
 
1015
    sigaction(SIGBUS, &sa, NULL);
 
1016
#endif
 
1017
    sigaction(SIGILL, &sa, NULL);
 
1018
    sigaction(SIGFPE, &sa, NULL);
 
1019
  }
 
1020
 
 
1021
#ifdef HAVE_GETRLIMIT
 
1022
  if (test_flags.test(TEST_CORE_ON_SIGNAL))
 
1023
  {
 
1024
    /* Change limits so that we will get a core file */
 
1025
    struct rlimit rl;
 
1026
    rl.rlim_cur = rl.rlim_max = RLIM_INFINITY;
 
1027
    if (setrlimit(RLIMIT_CORE, &rl) && global_system_variables.log_warnings)
 
1028
        errmsg_printf(ERRMSG_LVL_WARN, _("setrlimit could not change the size of core files "
 
1029
                          "to 'infinity';  We may not be able to generate a "
 
1030
                          "core file on signals"));
 
1031
  }
 
1032
#endif
 
1033
  (void) sigemptyset(&set);
 
1034
  my_sigset(SIGPIPE,SIG_IGN);
 
1035
  sigaddset(&set,SIGPIPE);
 
1036
#ifndef IGNORE_SIGHUP_SIGQUIT
 
1037
  sigaddset(&set,SIGQUIT);
 
1038
  sigaddset(&set,SIGHUP);
 
1039
#endif
 
1040
  sigaddset(&set,SIGTERM);
 
1041
 
 
1042
  /* Fix signals if blocked by parents (can happen on Mac OS X) */
 
1043
  sigemptyset(&sa.sa_mask);
 
1044
  sa.sa_flags = 0;
 
1045
  sa.sa_handler = print_signal_warning;
 
1046
  sigaction(SIGTERM, &sa, (struct sigaction*) 0);
 
1047
  sa.sa_flags = 0;
 
1048
  sa.sa_handler = print_signal_warning;
 
1049
  sigaction(SIGHUP, &sa, (struct sigaction*) 0);
 
1050
#ifdef SIGTSTP
 
1051
  sigaddset(&set,SIGTSTP);
 
1052
#endif
 
1053
  if (test_flags.test(TEST_SIGINT))
 
1054
  {
 
1055
    my_sigset(thr_kill_signal, end_thread_signal);
 
1056
    // May be SIGINT
 
1057
    sigdelset(&set, thr_kill_signal);
 
1058
  }
 
1059
  else
 
1060
    sigaddset(&set,SIGINT);
 
1061
  sigprocmask(SIG_SETMASK,&set,NULL);
 
1062
  pthread_sigmask(SIG_SETMASK,&set,NULL);
 
1063
  return;;
 
1064
}
 
1065
 
 
1066
static void check_data_home(const char *)
 
1067
{}
 
1068
 
886
1069
 
887
1070
/**
888
1071
  All global error messages are sent here where the first one is stored
889
1072
  for the client.
890
1073
*/
891
 
static void my_message_sql(uint32_t error, const char *str, myf MyFlags)
 
1074
/* ARGSUSED */
 
1075
extern "C" void my_message_sql(uint32_t error, const char *str, myf MyFlags);
 
1076
 
 
1077
void my_message_sql(uint32_t error, const char *str, myf MyFlags)
892
1078
{
893
1079
  Session *session;
894
1080
  /*
937
1123
    }
938
1124
  }
939
1125
  if (!session || MyFlags & ME_NOREFRESH)
940
 
    errmsg_printf(ERRMSG_LVL_ERROR, "%s: %s",internal::my_progname,str);
 
1126
    errmsg_printf(ERRMSG_LVL_ERROR, "%s: %s",my_progname,str); /* purecov: inspected */
941
1127
}
942
1128
 
943
1129
 
944
1130
static const char *load_default_groups[]= {
945
1131
DRIZZLE_CONFIG_NAME, "server", 0, 0};
946
1132
 
947
 
static int show_starttime(drizzle_show_var *var, char *buff)
948
 
{
949
 
  var->type= SHOW_LONG;
950
 
  var->value= buff;
951
 
  *((long *)buff)= (long) (time(NULL) - server_start_time);
952
 
  return 0;
953
 
}
954
 
 
955
 
static int show_flushstatustime(drizzle_show_var *var, char *buff)
956
 
{
957
 
  var->type= SHOW_LONG;
958
 
  var->value= buff;
959
 
  *((long *)buff)= (long) (time(NULL) - flush_status_time);
960
 
  return 0;
961
 
}
962
 
 
963
 
static st_show_var_func_container show_starttime_cont= { &show_starttime };
964
 
 
965
 
static st_show_var_func_container show_flushstatustime_cont= { &show_flushstatustime };
966
 
 
967
 
/*
968
 
  Variables shown by SHOW STATUS in alphabetical order
969
 
*/
970
 
static drizzle_show_var com_status_vars[]= {
971
 
  {"admin_commands",       (char*) offsetof(system_status_var, com_other), SHOW_LONG_STATUS},
972
 
  {"alter_db",             (char*) offsetof(system_status_var, com_stat[(uint32_t) SQLCOM_ALTER_DB]), SHOW_LONG_STATUS},
973
 
  {"alter_table",          (char*) offsetof(system_status_var, com_stat[(uint32_t) SQLCOM_ALTER_TABLE]), SHOW_LONG_STATUS},
974
 
  {"analyze",              (char*) offsetof(system_status_var, com_stat[(uint32_t) SQLCOM_ANALYZE]), SHOW_LONG_STATUS},
975
 
  {"begin",                (char*) offsetof(system_status_var, com_stat[(uint32_t) SQLCOM_BEGIN]), SHOW_LONG_STATUS},
976
 
  {"change_db",            (char*) offsetof(system_status_var, com_stat[(uint32_t) SQLCOM_CHANGE_DB]), SHOW_LONG_STATUS},
977
 
  {"check",                (char*) offsetof(system_status_var, com_stat[(uint32_t) SQLCOM_CHECK]), SHOW_LONG_STATUS},
978
 
  {"checksum",             (char*) offsetof(system_status_var, com_stat[(uint32_t) SQLCOM_CHECKSUM]), SHOW_LONG_STATUS},
979
 
  {"commit",               (char*) offsetof(system_status_var, com_stat[(uint32_t) SQLCOM_COMMIT]), SHOW_LONG_STATUS},
980
 
  {"create_db",            (char*) offsetof(system_status_var, com_stat[(uint32_t) SQLCOM_CREATE_DB]), SHOW_LONG_STATUS},
981
 
  {"create_index",         (char*) offsetof(system_status_var, com_stat[(uint32_t) SQLCOM_CREATE_INDEX]), SHOW_LONG_STATUS},
982
 
  {"create_table",         (char*) offsetof(system_status_var, com_stat[(uint32_t) SQLCOM_CREATE_TABLE]), SHOW_LONG_STATUS},
983
 
  {"delete",               (char*) offsetof(system_status_var, com_stat[(uint32_t) SQLCOM_DELETE]), SHOW_LONG_STATUS},
984
 
  {"drop_db",              (char*) offsetof(system_status_var, com_stat[(uint32_t) SQLCOM_DROP_DB]), SHOW_LONG_STATUS},
985
 
  {"drop_index",           (char*) offsetof(system_status_var, com_stat[(uint32_t) SQLCOM_DROP_INDEX]), SHOW_LONG_STATUS},
986
 
  {"drop_table",           (char*) offsetof(system_status_var, com_stat[(uint32_t) SQLCOM_DROP_TABLE]), SHOW_LONG_STATUS},
987
 
  {"empty_query",          (char*) offsetof(system_status_var, com_stat[(uint32_t) SQLCOM_EMPTY_QUERY]), SHOW_LONG_STATUS},
988
 
  {"flush",                (char*) offsetof(system_status_var, com_stat[(uint32_t) SQLCOM_FLUSH]), SHOW_LONG_STATUS},
989
 
  {"insert",               (char*) offsetof(system_status_var, com_stat[(uint32_t) SQLCOM_INSERT]), SHOW_LONG_STATUS},
990
 
  {"insert_select",        (char*) offsetof(system_status_var, com_stat[(uint32_t) SQLCOM_INSERT_SELECT]), SHOW_LONG_STATUS},
991
 
  {"kill",                 (char*) offsetof(system_status_var, com_stat[(uint32_t) SQLCOM_KILL]), SHOW_LONG_STATUS},
992
 
  {"load",                 (char*) offsetof(system_status_var, com_stat[(uint32_t) SQLCOM_LOAD]), SHOW_LONG_STATUS},
993
 
  {"release_savepoint",    (char*) offsetof(system_status_var, com_stat[(uint32_t) SQLCOM_RELEASE_SAVEPOINT]), SHOW_LONG_STATUS},
994
 
  {"rename_table",         (char*) offsetof(system_status_var, com_stat[(uint32_t) SQLCOM_RENAME_TABLE]), SHOW_LONG_STATUS},
995
 
  {"replace",              (char*) offsetof(system_status_var, com_stat[(uint32_t) SQLCOM_REPLACE]), SHOW_LONG_STATUS},
996
 
  {"replace_select",       (char*) offsetof(system_status_var, com_stat[(uint32_t) SQLCOM_REPLACE_SELECT]), SHOW_LONG_STATUS},
997
 
  {"rollback",             (char*) offsetof(system_status_var, com_stat[(uint32_t) SQLCOM_ROLLBACK]), SHOW_LONG_STATUS},
998
 
  {"rollback_to_savepoint",(char*) offsetof(system_status_var, com_stat[(uint32_t) SQLCOM_ROLLBACK_TO_SAVEPOINT]), SHOW_LONG_STATUS},
999
 
  {"savepoint",            (char*) offsetof(system_status_var, com_stat[(uint32_t) SQLCOM_SAVEPOINT]), SHOW_LONG_STATUS},
1000
 
  {"select",               (char*) offsetof(system_status_var, com_stat[(uint32_t) SQLCOM_SELECT]), SHOW_LONG_STATUS},
1001
 
  {"set_option",           (char*) offsetof(system_status_var, com_stat[(uint32_t) SQLCOM_SET_OPTION]), SHOW_LONG_STATUS},
1002
 
  {"show_create_db",       (char*) offsetof(system_status_var, com_stat[(uint32_t) SQLCOM_SHOW_CREATE_DB]), SHOW_LONG_STATUS},
1003
 
  {"show_create_table",    (char*) offsetof(system_status_var, com_stat[(uint32_t) SQLCOM_SHOW_CREATE]), SHOW_LONG_STATUS},
1004
 
  {"show_errors",          (char*) offsetof(system_status_var, com_stat[(uint32_t) SQLCOM_SHOW_ERRORS]), SHOW_LONG_STATUS},
1005
 
  {"show_warnings",        (char*) offsetof(system_status_var, com_stat[(uint32_t) SQLCOM_SHOW_WARNS]), SHOW_LONG_STATUS},
1006
 
  {"truncate",             (char*) offsetof(system_status_var, com_stat[(uint32_t) SQLCOM_TRUNCATE]), SHOW_LONG_STATUS},
1007
 
  {"unlock_tables",        (char*) offsetof(system_status_var, com_stat[(uint32_t) SQLCOM_UNLOCK_TABLES]), SHOW_LONG_STATUS},
1008
 
  {"update",               (char*) offsetof(system_status_var, com_stat[(uint32_t) SQLCOM_UPDATE]), SHOW_LONG_STATUS},
1009
 
  {NULL, NULL, SHOW_LONGLONG}
1010
 
};
1011
 
 
1012
 
static drizzle_show_var status_vars[]= {
1013
 
  {"Aborted_clients",          (char*) &aborted_threads,        SHOW_LONGLONG},
1014
 
  {"Aborted_connects",         (char*) &aborted_connects,       SHOW_LONGLONG},
1015
 
  {"Bytes_received",           (char*) offsetof(system_status_var, bytes_received), SHOW_LONGLONG_STATUS},
1016
 
  {"Bytes_sent",               (char*) offsetof(system_status_var, bytes_sent), SHOW_LONGLONG_STATUS},
1017
 
  {"Connections",              (char*) &global_thread_id, SHOW_INT_NOFLUSH},
1018
 
  {"Created_tmp_disk_tables",  (char*) offsetof(system_status_var, created_tmp_disk_tables), SHOW_LONG_STATUS},
1019
 
  {"Created_tmp_tables",       (char*) offsetof(system_status_var, created_tmp_tables), SHOW_LONG_STATUS},
1020
 
  {"Flush_commands",           (char*) &refresh_version,    SHOW_INT_NOFLUSH},
1021
 
  {"Handler_commit",           (char*) offsetof(system_status_var, ha_commit_count), SHOW_LONG_STATUS},
1022
 
  {"Handler_delete",           (char*) offsetof(system_status_var, ha_delete_count), SHOW_LONG_STATUS},
1023
 
  {"Handler_prepare",          (char*) offsetof(system_status_var, ha_prepare_count),  SHOW_LONG_STATUS},
1024
 
  {"Handler_read_first",       (char*) offsetof(system_status_var, ha_read_first_count), SHOW_LONG_STATUS},
1025
 
  {"Handler_read_key",         (char*) offsetof(system_status_var, ha_read_key_count), SHOW_LONG_STATUS},
1026
 
  {"Handler_read_next",        (char*) offsetof(system_status_var, ha_read_next_count), SHOW_LONG_STATUS},
1027
 
  {"Handler_read_prev",        (char*) offsetof(system_status_var, ha_read_prev_count), SHOW_LONG_STATUS},
1028
 
  {"Handler_read_rnd",         (char*) offsetof(system_status_var, ha_read_rnd_count), SHOW_LONG_STATUS},
1029
 
  {"Handler_read_rnd_next",    (char*) offsetof(system_status_var, ha_read_rnd_next_count), SHOW_LONG_STATUS},
1030
 
  {"Handler_rollback",         (char*) offsetof(system_status_var, ha_rollback_count), SHOW_LONG_STATUS},
1031
 
  {"Handler_savepoint",        (char*) offsetof(system_status_var, ha_savepoint_count), SHOW_LONG_STATUS},
1032
 
  {"Handler_savepoint_rollback",(char*) offsetof(system_status_var, ha_savepoint_rollback_count), SHOW_LONG_STATUS},
1033
 
  {"Handler_update",           (char*) offsetof(system_status_var, ha_update_count), SHOW_LONG_STATUS},
1034
 
  {"Handler_write",            (char*) offsetof(system_status_var, ha_write_count), SHOW_LONG_STATUS},
1035
 
  {"Key_blocks_not_flushed",   (char*) offsetof(KEY_CACHE, global_blocks_changed), SHOW_KEY_CACHE_LONG},
1036
 
  {"Key_blocks_unused",        (char*) offsetof(KEY_CACHE, blocks_unused), SHOW_KEY_CACHE_LONG},
1037
 
  {"Key_blocks_used",          (char*) offsetof(KEY_CACHE, blocks_used), SHOW_KEY_CACHE_LONG},
1038
 
  {"Key_read_requests",        (char*) offsetof(KEY_CACHE, global_cache_r_requests), SHOW_KEY_CACHE_LONGLONG},
1039
 
  {"Key_reads",                (char*) offsetof(KEY_CACHE, global_cache_read), SHOW_KEY_CACHE_LONGLONG},
1040
 
  {"Key_write_requests",       (char*) offsetof(KEY_CACHE, global_cache_w_requests), SHOW_KEY_CACHE_LONGLONG},
1041
 
  {"Key_writes",               (char*) offsetof(KEY_CACHE, global_cache_write), SHOW_KEY_CACHE_LONGLONG},
1042
 
  {"Last_query_cost",          (char*) offsetof(system_status_var, last_query_cost), SHOW_DOUBLE_STATUS},
1043
 
  {"Max_used_connections",     (char*) &max_used_connections,  SHOW_INT},
1044
 
  {"Questions",                (char*) offsetof(system_status_var, questions), SHOW_LONG_STATUS},
1045
 
  {"Select_full_join",         (char*) offsetof(system_status_var, select_full_join_count), SHOW_LONG_STATUS},
1046
 
  {"Select_full_range_join",   (char*) offsetof(system_status_var, select_full_range_join_count), SHOW_LONG_STATUS},
1047
 
  {"Select_range",             (char*) offsetof(system_status_var, select_range_count), SHOW_LONG_STATUS},
1048
 
  {"Select_range_check",       (char*) offsetof(system_status_var, select_range_check_count), SHOW_LONG_STATUS},
1049
 
  {"Select_scan",              (char*) offsetof(system_status_var, select_scan_count), SHOW_LONG_STATUS},
1050
 
  {"Slow_queries",             (char*) offsetof(system_status_var, long_query_count), SHOW_LONG_STATUS},
1051
 
  {"Sort_merge_passes",        (char*) offsetof(system_status_var, filesort_merge_passes), SHOW_LONG_STATUS},
1052
 
  {"Sort_range",               (char*) offsetof(system_status_var, filesort_range_count), SHOW_LONG_STATUS},
1053
 
  {"Sort_rows",                (char*) offsetof(system_status_var, filesort_rows), SHOW_LONG_STATUS},
1054
 
  {"Sort_scan",                (char*) offsetof(system_status_var, filesort_scan_count), SHOW_LONG_STATUS},
1055
 
  {"Table_locks_immediate",    (char*) &locks_immediate,        SHOW_INT},
1056
 
  {"Table_locks_waited",       (char*) &locks_waited,           SHOW_INT},
1057
 
  {"Threads_connected",        (char*) &connection_count,       SHOW_INT},
1058
 
  {"Uptime",                   (char*) &show_starttime_cont,         SHOW_FUNC},
1059
 
  {"Uptime_since_flush_status",(char*) &show_flushstatustime_cont,   SHOW_FUNC},
 
1133
SHOW_VAR com_status_vars[]= {
 
1134
  {"admin_commands",       (char*) offsetof(STATUS_VAR, com_other), SHOW_LONG_STATUS},
 
1135
  {"alter_db",             (char*) offsetof(STATUS_VAR, com_stat[(uint32_t) SQLCOM_ALTER_DB]), SHOW_LONG_STATUS},
 
1136
  {"alter_table",          (char*) offsetof(STATUS_VAR, com_stat[(uint32_t) SQLCOM_ALTER_TABLE]), SHOW_LONG_STATUS},
 
1137
  {"analyze",              (char*) offsetof(STATUS_VAR, com_stat[(uint32_t) SQLCOM_ANALYZE]), SHOW_LONG_STATUS},
 
1138
  {"begin",                (char*) offsetof(STATUS_VAR, com_stat[(uint32_t) SQLCOM_BEGIN]), SHOW_LONG_STATUS},
 
1139
  {"change_db",            (char*) offsetof(STATUS_VAR, com_stat[(uint32_t) SQLCOM_CHANGE_DB]), SHOW_LONG_STATUS},
 
1140
  {"check",                (char*) offsetof(STATUS_VAR, com_stat[(uint32_t) SQLCOM_CHECK]), SHOW_LONG_STATUS},
 
1141
  {"checksum",             (char*) offsetof(STATUS_VAR, com_stat[(uint32_t) SQLCOM_CHECKSUM]), SHOW_LONG_STATUS},
 
1142
  {"commit",               (char*) offsetof(STATUS_VAR, com_stat[(uint32_t) SQLCOM_COMMIT]), SHOW_LONG_STATUS},
 
1143
  {"create_db",            (char*) offsetof(STATUS_VAR, com_stat[(uint32_t) SQLCOM_CREATE_DB]), SHOW_LONG_STATUS},
 
1144
  {"create_index",         (char*) offsetof(STATUS_VAR, com_stat[(uint32_t) SQLCOM_CREATE_INDEX]), SHOW_LONG_STATUS},
 
1145
  {"create_table",         (char*) offsetof(STATUS_VAR, com_stat[(uint32_t) SQLCOM_CREATE_TABLE]), SHOW_LONG_STATUS},
 
1146
  {"delete",               (char*) offsetof(STATUS_VAR, com_stat[(uint32_t) SQLCOM_DELETE]), SHOW_LONG_STATUS},
 
1147
  {"drop_db",              (char*) offsetof(STATUS_VAR, com_stat[(uint32_t) SQLCOM_DROP_DB]), SHOW_LONG_STATUS},
 
1148
  {"drop_index",           (char*) offsetof(STATUS_VAR, com_stat[(uint32_t) SQLCOM_DROP_INDEX]), SHOW_LONG_STATUS},
 
1149
  {"drop_table",           (char*) offsetof(STATUS_VAR, com_stat[(uint32_t) SQLCOM_DROP_TABLE]), SHOW_LONG_STATUS},
 
1150
  {"empty_query",          (char*) offsetof(STATUS_VAR, com_stat[(uint32_t) SQLCOM_EMPTY_QUERY]), SHOW_LONG_STATUS},
 
1151
  {"flush",                (char*) offsetof(STATUS_VAR, com_stat[(uint32_t) SQLCOM_FLUSH]), SHOW_LONG_STATUS},
 
1152
  {"insert",               (char*) offsetof(STATUS_VAR, com_stat[(uint32_t) SQLCOM_INSERT]), SHOW_LONG_STATUS},
 
1153
  {"insert_select",        (char*) offsetof(STATUS_VAR, com_stat[(uint32_t) SQLCOM_INSERT_SELECT]), SHOW_LONG_STATUS},
 
1154
  {"kill",                 (char*) offsetof(STATUS_VAR, com_stat[(uint32_t) SQLCOM_KILL]), SHOW_LONG_STATUS},
 
1155
  {"load",                 (char*) offsetof(STATUS_VAR, com_stat[(uint32_t) SQLCOM_LOAD]), SHOW_LONG_STATUS},
 
1156
  {"optimize",             (char*) offsetof(STATUS_VAR, com_stat[(uint32_t) SQLCOM_OPTIMIZE]), SHOW_LONG_STATUS},
 
1157
  {"release_savepoint",    (char*) offsetof(STATUS_VAR, com_stat[(uint32_t) SQLCOM_RELEASE_SAVEPOINT]), SHOW_LONG_STATUS},
 
1158
  {"rename_table",         (char*) offsetof(STATUS_VAR, com_stat[(uint32_t) SQLCOM_RENAME_TABLE]), SHOW_LONG_STATUS},
 
1159
  {"replace",              (char*) offsetof(STATUS_VAR, com_stat[(uint32_t) SQLCOM_REPLACE]), SHOW_LONG_STATUS},
 
1160
  {"replace_select",       (char*) offsetof(STATUS_VAR, com_stat[(uint32_t) SQLCOM_REPLACE_SELECT]), SHOW_LONG_STATUS},
 
1161
  {"rollback",             (char*) offsetof(STATUS_VAR, com_stat[(uint32_t) SQLCOM_ROLLBACK]), SHOW_LONG_STATUS},
 
1162
  {"rollback_to_savepoint",(char*) offsetof(STATUS_VAR, com_stat[(uint32_t) SQLCOM_ROLLBACK_TO_SAVEPOINT]), SHOW_LONG_STATUS},
 
1163
  {"savepoint",            (char*) offsetof(STATUS_VAR, com_stat[(uint32_t) SQLCOM_SAVEPOINT]), SHOW_LONG_STATUS},
 
1164
  {"select",               (char*) offsetof(STATUS_VAR, com_stat[(uint32_t) SQLCOM_SELECT]), SHOW_LONG_STATUS},
 
1165
  {"set_option",           (char*) offsetof(STATUS_VAR, com_stat[(uint32_t) SQLCOM_SET_OPTION]), SHOW_LONG_STATUS},
 
1166
  {"show_create_db",       (char*) offsetof(STATUS_VAR, com_stat[(uint32_t) SQLCOM_SHOW_CREATE_DB]), SHOW_LONG_STATUS},
 
1167
  {"show_create_table",    (char*) offsetof(STATUS_VAR, com_stat[(uint32_t) SQLCOM_SHOW_CREATE]), SHOW_LONG_STATUS},
 
1168
  {"show_databases",       (char*) offsetof(STATUS_VAR, com_stat[(uint32_t) SQLCOM_SHOW_DATABASES]), SHOW_LONG_STATUS},
 
1169
  {"show_engine_status",   (char*) offsetof(STATUS_VAR, com_stat[(uint32_t) SQLCOM_SHOW_ENGINE_STATUS]), SHOW_LONG_STATUS},
 
1170
  {"show_errors",          (char*) offsetof(STATUS_VAR, com_stat[(uint32_t) SQLCOM_SHOW_ERRORS]), SHOW_LONG_STATUS},
 
1171
  {"show_fields",          (char*) offsetof(STATUS_VAR, com_stat[(uint32_t) SQLCOM_SHOW_FIELDS]), SHOW_LONG_STATUS},
 
1172
  {"show_keys",            (char*) offsetof(STATUS_VAR, com_stat[(uint32_t) SQLCOM_SHOW_KEYS]), SHOW_LONG_STATUS},
 
1173
  {"show_open_tables",     (char*) offsetof(STATUS_VAR, com_stat[(uint32_t) SQLCOM_SHOW_OPEN_TABLES]), SHOW_LONG_STATUS},
 
1174
  {"show_processlist",     (char*) offsetof(STATUS_VAR, com_stat[(uint32_t) SQLCOM_SHOW_PROCESSLIST]), SHOW_LONG_STATUS},
 
1175
  {"show_status",          (char*) offsetof(STATUS_VAR, com_stat[(uint32_t) SQLCOM_SHOW_STATUS]), SHOW_LONG_STATUS},
 
1176
  {"show_table_status",    (char*) offsetof(STATUS_VAR, com_stat[(uint32_t) SQLCOM_SHOW_TABLE_STATUS]), SHOW_LONG_STATUS},
 
1177
  {"show_tables",          (char*) offsetof(STATUS_VAR, com_stat[(uint32_t) SQLCOM_SHOW_TABLES]), SHOW_LONG_STATUS},
 
1178
  {"show_variables",       (char*) offsetof(STATUS_VAR, com_stat[(uint32_t) SQLCOM_SHOW_VARIABLES]), SHOW_LONG_STATUS},
 
1179
  {"show_warnings",        (char*) offsetof(STATUS_VAR, com_stat[(uint32_t) SQLCOM_SHOW_WARNS]), SHOW_LONG_STATUS},
 
1180
  {"truncate",             (char*) offsetof(STATUS_VAR, com_stat[(uint32_t) SQLCOM_TRUNCATE]), SHOW_LONG_STATUS},
 
1181
  {"unlock_tables",        (char*) offsetof(STATUS_VAR, com_stat[(uint32_t) SQLCOM_UNLOCK_TABLES]), SHOW_LONG_STATUS},
 
1182
  {"update",               (char*) offsetof(STATUS_VAR, com_stat[(uint32_t) SQLCOM_UPDATE]), SHOW_LONG_STATUS},
1060
1183
  {NULL, NULL, SHOW_LONGLONG}
1061
1184
};
1062
1185
 
1064
1187
                                 char **argv, const char **groups)
1065
1188
{
1066
1189
  time_t curr_time;
1067
 
  umask(((~internal::my_umask) & 0666));
 
1190
  umask(((~my_umask) & 0666));
1068
1191
  my_decimal_set_zero(&decimal_zero); // set decimal_zero constant;
1069
1192
  tzset();                      // Set tzname
1070
1193
 
1085
1208
    strncpy(system_time_zone, tzname[tm_tmp.tm_isdst != 0 ? 1 : 0],
1086
1209
            sizeof(system_time_zone)-1);
1087
1210
 
1088
 
  }
 
1211
 }
1089
1212
  /*
1090
1213
    We set SYSTEM time zone as reasonable default and
1091
1214
    also for failure of my_tz_init() and bootstrap mode.
1097
1220
  if (gethostname(glob_hostname,sizeof(glob_hostname)) < 0)
1098
1221
  {
1099
1222
    strncpy(glob_hostname, STRING_WITH_LEN("localhost"));
1100
 
    errmsg_printf(ERRMSG_LVL_WARN, _("gethostname failed, using '%s' as hostname"),
1101
 
                  glob_hostname);
 
1223
      errmsg_printf(ERRMSG_LVL_WARN, _("gethostname failed, using '%s' as hostname"),
 
1224
                      glob_hostname);
1102
1225
    strncpy(pidfile_name, STRING_WITH_LEN("drizzle"));
1103
1226
  }
1104
1227
  else
1105
1228
    strncpy(pidfile_name, glob_hostname, sizeof(pidfile_name)-5);
1106
 
  strcpy(internal::fn_ext(pidfile_name),".pid");                // Add proper extension
 
1229
  strcpy(fn_ext(pidfile_name),".pid");          // Add proper extension
1107
1230
 
1108
1231
  /*
1109
1232
    Add server status variables to the dynamic list of
1110
1233
    status variables that is shown by SHOW STATUS.
1111
 
    Later, in plugin_init, new entries could be added to that list.
 
1234
    Later, in plugin_init, and mysql_install_plugin
 
1235
    new entries could be added to that list.
1112
1236
  */
1113
 
  if (add_com_status_vars(com_status_vars))
1114
 
    return 1; // an error was already reported
1115
 
 
1116
1237
  if (add_status_vars(status_vars))
1117
1238
    return 1; // an error was already reported
1118
1239
 
1119
 
  internal::load_defaults(conf_file_name, groups, &argc, &argv);
 
1240
  load_defaults(conf_file_name, groups, &argc, &argv);
1120
1241
  defaults_argv=argv;
1121
1242
  defaults_argc=argc;
1122
1243
  get_options(&defaults_argc, defaults_argv);
1123
1244
 
1124
 
  current_pid= getpid();                /* Save for later ref */
 
1245
  current_pid=(ulong) getpid();         /* Save for later ref */
1125
1246
  init_time();                          /* Init time-functions (read zone) */
1126
1247
 
 
1248
  if (init_errmessage())        /* Read error messages from file */
 
1249
    return 1;
1127
1250
  if (item_create_init())
1128
1251
    return 1;
1129
1252
  if (set_var_init())
1141
1264
  if (default_collation_name)
1142
1265
  {
1143
1266
    const CHARSET_INFO * const default_collation= get_charset_by_name(default_collation_name);
1144
 
    if (not default_collation)
 
1267
    if (!default_collation)
1145
1268
    {
1146
 
      errmsg_printf(ERRMSG_LVL_ERROR, _(ER(ER_UNKNOWN_COLLATION)), default_collation_name);
 
1269
          errmsg_printf(ERRMSG_LVL_ERROR, _(ER(ER_UNKNOWN_COLLATION)), default_collation_name);
1147
1270
      return 1;
1148
1271
    }
1149
 
    if (not my_charset_same(default_charset_info, default_collation))
 
1272
    if (!my_charset_same(default_charset_info, default_collation))
1150
1273
    {
1151
 
      errmsg_printf(ERRMSG_LVL_ERROR, _(ER(ER_COLLATION_CHARSET_MISMATCH)),
1152
 
                    default_collation_name,
1153
 
                    default_charset_info->csname);
 
1274
          errmsg_printf(ERRMSG_LVL_ERROR, _(ER(ER_COLLATION_CHARSET_MISMATCH)),
 
1275
                      default_collation_name,
 
1276
                      default_charset_info->csname);
1154
1277
      return 1;
1155
1278
    }
1156
1279
    default_charset_info= default_collation;
1158
1281
  /* Set collactions that depends on the default collation */
1159
1282
  global_system_variables.collation_server=      default_charset_info;
1160
1283
 
1161
 
  if (not (character_set_filesystem=
1162
 
           get_charset_by_csname(character_set_filesystem_name, MY_CS_PRIMARY)))
 
1284
  global_system_variables.optimizer_switch= 0;
 
1285
 
 
1286
  if (!(character_set_filesystem=
 
1287
        get_charset_by_csname(character_set_filesystem_name, MY_CS_PRIMARY)))
1163
1288
    return 1;
1164
1289
  global_system_variables.character_set_filesystem= character_set_filesystem;
1165
1290
 
1166
1291
  if (!(my_default_lc_time_names=
1167
1292
        my_locale_by_name(lc_time_names_name)))
1168
1293
  {
1169
 
    errmsg_printf(ERRMSG_LVL_ERROR, _("Unknown locale: '%s'"), lc_time_names_name);
 
1294
      errmsg_printf(ERRMSG_LVL_ERROR, _("Unknown locale: '%s'"), lc_time_names_name);
1170
1295
    return 1;
1171
1296
  }
1172
1297
  global_system_variables.lc_time_names= my_default_lc_time_names;
1180
1305
 
1181
1306
static int init_thread_environment()
1182
1307
{
1183
 
   pthread_mutexattr_t attr; 
1184
 
   pthread_mutexattr_init(&attr);
1185
 
 
1186
1308
  (void) pthread_mutex_init(&LOCK_create_db, NULL);
1187
1309
  (void) pthread_mutex_init(&LOCK_open, NULL);
1188
 
 
1189
 
  pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); 
1190
 
  (void) pthread_mutex_init(&LOCK_thread_count, &attr);
1191
 
  (void) pthread_mutex_init(&LOCK_global_system_variables, &attr);
1192
 
 
1193
 
  (void) pthread_mutex_init(&LOCK_status, MY_MUTEX_INIT_FAST);
 
1310
  (void) pthread_mutex_init(&LOCK_thread_count,MY_MUTEX_INIT_FAST);
 
1311
  (void) pthread_mutex_init(&LOCK_status,MY_MUTEX_INIT_FAST);
 
1312
  (void) pthread_mutex_init(&LOCK_global_system_variables, MY_MUTEX_INIT_FAST);
1194
1313
  (void) pthread_rwlock_init(&LOCK_system_variables_hash, NULL);
1195
1314
  (void) pthread_mutex_init(&LOCK_global_read_lock, MY_MUTEX_INIT_FAST);
1196
1315
  (void) pthread_cond_init(&COND_thread_count,NULL);
1198
1317
  (void) pthread_cond_init(&COND_refresh,NULL);
1199
1318
  (void) pthread_cond_init(&COND_global_read_lock,NULL);
1200
1319
 
1201
 
  pthread_mutexattr_destroy(&attr);
1202
 
 
1203
1320
  if (pthread_key_create(&THR_Session,NULL) ||
1204
1321
      pthread_key_create(&THR_Mem_root,NULL))
1205
1322
  {
1210
1327
}
1211
1328
 
1212
1329
 
1213
 
static int init_server_components(plugin::Registry &plugins)
 
1330
static int init_server_components()
1214
1331
{
1215
1332
  /*
1216
1333
    We need to call each of these following functions to ensure that
1218
1335
  */
1219
1336
  if (table_cache_init())
1220
1337
    unireg_abort(1);
1221
 
  TableShare::cacheStart();
 
1338
  if (TableShare::cacheStart())
 
1339
    unireg_abort(1);
1222
1340
 
1223
1341
  setup_fpu();
1224
1342
  init_thr_lock();
1232
1350
  }
1233
1351
 
1234
1352
  /* Allow storage engine to give real error messages */
1235
 
  ha_init_errors();
 
1353
  if (ha_init_errors())
 
1354
    return(1);
1236
1355
 
1237
 
  if (plugin_init(plugins, &defaults_argc, defaults_argv,
1238
 
                  ((opt_help) ? true : false)))
 
1356
  if (plugin_init(&defaults_argc, defaults_argv, (opt_help ? PLUGIN_INIT_SKIP_INITIALIZATION : 0)))
1239
1357
  {
1240
1358
    errmsg_printf(ERRMSG_LVL_ERROR, _("Failed to initialize plugins."));
1241
1359
    unireg_abort(1);
1242
1360
  }
1243
1361
 
1244
 
  if (opt_help || opt_help_extended)
 
1362
  if (opt_help)
1245
1363
    unireg_abort(0);
1246
1364
 
1247
1365
  /* we do want to exit if there are any other unknown options */
1249
1367
  {
1250
1368
    int ho_error;
1251
1369
    char **tmp_argv= defaults_argv;
1252
 
    struct option no_opts[]=
 
1370
    struct my_option no_opts[]=
1253
1371
    {
1254
1372
      {0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
1255
1373
    };
1257
1375
      We need to eat any 'loose' arguments first before we conclude
1258
1376
      that there are unprocessed options.
1259
1377
      But we need to preserve defaults_argv pointer intact for
1260
 
      internal::free_defaults() to work. Thus we use a copy here.
 
1378
      free_defaults() to work. Thus we use a copy here.
1261
1379
    */
1262
1380
    my_getopt_skip_unknown= 0;
1263
1381
 
1270
1388
      fprintf(stderr,
1271
1389
              _("%s: Too many arguments (first extra is '%s').\n"
1272
1390
                "Use --verbose --help to get a list of available options\n"),
1273
 
              internal::my_progname, *tmp_argv);
 
1391
              my_progname, *tmp_argv);
1274
1392
      unireg_abort(1);
1275
1393
    }
1276
1394
  }
1285
1403
    scheduler_name= opt_scheduler_default;
1286
1404
  }
1287
1405
 
1288
 
  if (plugin::Scheduler::setPlugin(scheduler_name))
 
1406
  if (set_scheduler_factory(scheduler_name))
1289
1407
  {
1290
1408
      errmsg_printf(ERRMSG_LVL_ERROR,
1291
1409
                   _("No scheduler found, cannot continue!\n"));
1292
1410
      unireg_abort(1);
1293
1411
  }
1294
1412
 
 
1413
  /* We have to initialize the storage engines before CSV logging */
 
1414
  if (ha_init())
 
1415
  {
 
1416
      errmsg_printf(ERRMSG_LVL_ERROR, _("Can't init databases"));
 
1417
    unireg_abort(1);
 
1418
  }
 
1419
 
1295
1420
  /*
1296
1421
    This is entirely for legacy. We will create a new "disk based" engine and a
1297
 
    "memory" engine which will be configurable longterm.
 
1422
    "memory" engine which will be configurable longterm. We should be able to
 
1423
    remove partition and myisammrg.
1298
1424
  */
1299
1425
  const std::string myisam_engine_name("MyISAM");
1300
1426
  const std::string heap_engine_name("MEMORY");
1301
 
  myisam_engine= plugin::StorageEngine::findByName(myisam_engine_name);
1302
 
  heap_engine= plugin::StorageEngine::findByName(heap_engine_name);
 
1427
  myisam_engine= ha_resolve_by_name(NULL, myisam_engine_name);
 
1428
  heap_engine= ha_resolve_by_name(NULL, heap_engine_name);
1303
1429
 
1304
1430
  /*
1305
1431
    Check that the default storage engine is actually available.
1307
1433
  if (default_storage_engine_str)
1308
1434
  {
1309
1435
    const std::string name(default_storage_engine_str);
1310
 
    plugin::StorageEngine *engine;
 
1436
    StorageEngine *engine;
1311
1437
 
1312
 
    engine= plugin::StorageEngine::findByName(name);
 
1438
    engine= ha_resolve_by_name(0, name);
1313
1439
    if (engine == NULL)
1314
1440
    {
1315
 
      errmsg_printf(ERRMSG_LVL_ERROR, _("Unknown/unsupported storage engine: %s"),
1316
 
                    default_storage_engine_str);
1317
 
      unireg_abort(1);
1318
 
    }
1319
 
    global_system_variables.storage_engine= engine;
 
1441
      errmsg_printf(ERRMSG_LVL_ERROR, _("Unknown/unsupported table type: %s"),
 
1442
                    default_storage_engine_str);
 
1443
      unireg_abort(1);
 
1444
    }
 
1445
    if (!engine->is_enabled())
 
1446
    {
 
1447
      errmsg_printf(ERRMSG_LVL_ERROR, _("Default storage engine (%s) is not available"),
 
1448
                    default_storage_engine_str);
 
1449
      unireg_abort(1);
 
1450
      //assert(global_system_variables.storage_engine);
 
1451
    }
 
1452
    else
 
1453
    {
 
1454
      /*
 
1455
        Need to unlock as global_system_variables.storage_engine
 
1456
        was acquired during plugin_init()
 
1457
      */
 
1458
      global_system_variables.storage_engine= engine;
 
1459
    }
1320
1460
  }
1321
1461
 
1322
 
  if (plugin::XaResourceManager::recoverAllXids(0))
 
1462
  if (ha_recover(0))
1323
1463
  {
1324
1464
    unireg_abort(1);
1325
1465
  }
1326
1466
 
 
1467
#if defined(HAVE_MLOCKALL) && defined(MCL_CURRENT)
 
1468
  if (locked_in_memory && !getuid())
 
1469
  {
 
1470
    if (setreuid((uid_t)-1, 0) == -1)
 
1471
    {                        // this should never happen
 
1472
      sql_perror("setreuid");
 
1473
      unireg_abort(1);
 
1474
    }
 
1475
    if (mlockall(MCL_CURRENT))
 
1476
    {
 
1477
      if (global_system_variables.log_warnings)
 
1478
            errmsg_printf(ERRMSG_LVL_WARN, _("Failed to lock memory. Errno: %d\n"),errno);
 
1479
      locked_in_memory= 0;
 
1480
    }
 
1481
    if (user_info)
 
1482
      set_user(drizzled_user, user_info);
 
1483
  }
 
1484
  else
 
1485
#endif
 
1486
    locked_in_memory=0;
 
1487
 
1327
1488
  init_update_queries();
1328
 
 
1329
1489
  return(0);
1330
1490
}
1331
1491
 
1332
1492
 
 
1493
int main(int argc, char **argv)
 
1494
{
 
1495
  ListenHandler listen_handler;
 
1496
  Protocol *protocol;
 
1497
  Session *session;
 
1498
 
 
1499
 
 
1500
#if defined(ENABLE_NLS)
 
1501
# if defined(HAVE_LOCALE_H)
 
1502
  setlocale(LC_ALL, "");
 
1503
# endif
 
1504
  bindtextdomain("drizzle", LOCALEDIR);
 
1505
  textdomain("drizzle");
 
1506
#endif
 
1507
 
 
1508
  MY_INIT(argv[0]);             // init my_sys library & pthreads
 
1509
  /* nothing should come before this line ^^^ */
 
1510
 
 
1511
  /* Set signal used to kill Drizzle */
 
1512
#if defined(SIGUSR2)
 
1513
  thr_kill_signal= thd_lib_detected == THD_LIB_LT ? SIGINT : SIGUSR2;
 
1514
#else
 
1515
  thr_kill_signal= SIGINT;
 
1516
#endif
 
1517
 
 
1518
  if (init_common_variables(DRIZZLE_CONFIG_NAME,
 
1519
                            argc, argv, load_default_groups))
 
1520
    unireg_abort(1);                            // Will do exit
 
1521
 
 
1522
  init_signals();
 
1523
 
 
1524
 
 
1525
  select_thread=pthread_self();
 
1526
  select_thread_in_use=1;
 
1527
 
 
1528
  check_data_home(drizzle_real_data_home);
 
1529
  if (chdir(drizzle_real_data_home) && !opt_help)
 
1530
    unireg_abort(1);                            /* purecov: inspected */
 
1531
  drizzle_data_home= drizzle_data_home_buff;
 
1532
  drizzle_data_home[0]=FN_CURLIB;               // all paths are relative from here
 
1533
  drizzle_data_home[1]=0;
 
1534
  drizzle_data_home_len= 2;
 
1535
 
 
1536
  if ((user_info= check_user(drizzled_user)))
 
1537
  {
 
1538
#if defined(HAVE_MLOCKALL) && defined(MCL_CURRENT)
 
1539
    if (locked_in_memory) // getuid() == 0 here
 
1540
      set_effective_user(user_info);
 
1541
    else
 
1542
#endif
 
1543
      set_user(drizzled_user, user_info);
 
1544
  }
 
1545
 
 
1546
  if (server_id == 0)
 
1547
  {
 
1548
    server_id= 1;
 
1549
  }
 
1550
 
 
1551
  if (init_server_components())
 
1552
    unireg_abort(1);
 
1553
 
 
1554
  set_default_port();
 
1555
 
 
1556
  if (listen_handler.bindAll(my_bind_addr_str, drizzled_port_timeout))
 
1557
    unireg_abort(1);
 
1558
 
 
1559
  /*
 
1560
    init signals & alarm
 
1561
    After this we can't quit by a simple unireg_abort
 
1562
  */
 
1563
  error_handler_hook= my_message_sql;
 
1564
 
 
1565
  if (drizzle_rm_tmp_tables(listen_handler) ||
 
1566
      my_tz_init((Session *)0, default_tz_name))
 
1567
  {
 
1568
    abort_loop= true;
 
1569
    select_thread_in_use=0;
 
1570
    (void) pthread_kill(signal_thread, SIGTERM);
 
1571
 
 
1572
    (void) unlink(pidfile_name);        // Not needed anymore
 
1573
 
 
1574
    exit(1);
 
1575
  }
 
1576
 
 
1577
  init_status_vars();
 
1578
 
 
1579
  errmsg_printf(ERRMSG_LVL_INFO, _(ER(ER_STARTUP)), my_progname, VERSION,
 
1580
                COMPILATION_COMMENT);
 
1581
 
 
1582
 
 
1583
  /* Listen for new connections and start new session for each connection
 
1584
     accepted. The listen.getProtocol() method will return NULL when the server
 
1585
     should be shutdown. */
 
1586
  while ((protocol= listen_handler.getProtocol()) != NULL)
 
1587
  {
 
1588
    if (!(session= new Session(protocol)))
 
1589
    {
 
1590
      delete protocol;
 
1591
      continue;
 
1592
    }
 
1593
 
 
1594
    create_new_thread(session);
 
1595
  }
 
1596
 
 
1597
  /* (void) pthread_attr_destroy(&connection_attrib); */
 
1598
 
 
1599
 
 
1600
  (void) pthread_mutex_lock(&LOCK_thread_count);
 
1601
  select_thread_in_use=0;                       // For close_connections
 
1602
  (void) pthread_mutex_unlock(&LOCK_thread_count);
 
1603
  (void) pthread_cond_broadcast(&COND_thread_count);
 
1604
 
 
1605
  /* Wait until cleanup is done */
 
1606
  (void) pthread_mutex_lock(&LOCK_thread_count);
 
1607
  while (!ready_to_exit)
 
1608
    pthread_cond_wait(&COND_server_end,&LOCK_thread_count);
 
1609
  (void) pthread_mutex_unlock(&LOCK_thread_count);
 
1610
 
 
1611
  clean_up(1);
 
1612
  clean_up_mutexes();
 
1613
  my_end(opt_endinfo ? MY_CHECK_ERROR | MY_GIVE_INFO : 0);
 
1614
  return 0;
 
1615
}
 
1616
 
 
1617
 
 
1618
/**
 
1619
  Create new thread to handle incoming connection.
 
1620
 
 
1621
    This function will create new thread to handle the incoming
 
1622
    connection.  If there are idle cached threads one will be used.
 
1623
    'session' will be pushed into 'threads'.
 
1624
 
 
1625
    In single-threaded mode (\#define ONE_THREAD) connection will be
 
1626
    handled inside this function.
 
1627
 
 
1628
  @param[in,out] session    Thread handle of future thread.
 
1629
*/
 
1630
 
 
1631
static void create_new_thread(Session *session)
 
1632
{
 
1633
  Scheduler &thread_scheduler= get_thread_scheduler();
 
1634
 
 
1635
  ++connection_count;
 
1636
 
 
1637
  if (connection_count > max_used_connections)
 
1638
    max_used_connections= connection_count;
 
1639
 
 
1640
  /*
 
1641
    The initialization of thread_id is done in create_embedded_session() for
 
1642
    the embedded library.
 
1643
    TODO: refactor this to avoid code duplication there
 
1644
  */
 
1645
  session->thread_id= session->variables.pseudo_thread_id= thread_id++;
 
1646
 
 
1647
  /* 
 
1648
    If we error on creation we drop the connection and delete the session.
 
1649
  */
 
1650
  pthread_mutex_lock(&LOCK_thread_count);
 
1651
  session_list.push_back(session);
 
1652
  pthread_mutex_unlock(&LOCK_thread_count);
 
1653
  if (thread_scheduler.add_connection(session))
 
1654
  {
 
1655
    char error_message_buff[DRIZZLE_ERRMSG_SIZE];
 
1656
 
 
1657
    session->killed= Session::KILL_CONNECTION;                        // Safety
 
1658
 
 
1659
    statistic_increment(aborted_connects, &LOCK_status);
 
1660
 
 
1661
    /* Can't use my_error() since store_globals has not been called. */
 
1662
    snprintf(error_message_buff, sizeof(error_message_buff), ER(ER_CANT_CREATE_THREAD), 1); /* TODO replace will better error message */
 
1663
    session->protocol->sendError(ER_CANT_CREATE_THREAD, error_message_buff);
 
1664
    unlink_session(session);
 
1665
  }
 
1666
}
 
1667
 
 
1668
 
1333
1669
/****************************************************************************
1334
1670
  Handle start options
1335
1671
******************************************************************************/
1337
1673
enum options_drizzled
1338
1674
{
1339
1675
  OPT_SOCKET=256,
1340
 
  OPT_BIND_ADDRESS,            
1341
 
  OPT_PID_FILE,
 
1676
  OPT_BIND_ADDRESS,            OPT_PID_FILE,
1342
1677
  OPT_STORAGE_ENGINE,          
1343
1678
  OPT_INIT_FILE,
 
1679
  OPT_DELAY_KEY_WRITE_ALL,
 
1680
  OPT_DELAY_KEY_WRITE,
1344
1681
  OPT_WANT_CORE,
1345
1682
  OPT_MEMLOCK,
1346
1683
  OPT_SERVER_ID,
1350
1687
  OPT_DO_PSTACK,
1351
1688
  OPT_LOCAL_INFILE,
1352
1689
  OPT_BACK_LOG,
 
1690
  OPT_CONNECT_TIMEOUT,
1353
1691
  OPT_JOIN_BUFF_SIZE,
1354
1692
  OPT_KEY_BUFFER_SIZE, OPT_KEY_CACHE_BLOCK_SIZE,
1355
1693
  OPT_KEY_CACHE_DIVISION_LIMIT, OPT_KEY_CACHE_AGE_THRESHOLD,
1365
1703
  OPT_MYISAM_BLOCK_SIZE, OPT_MYISAM_MAX_EXTRA_SORT_FILE_SIZE,
1366
1704
  OPT_MYISAM_MAX_SORT_FILE_SIZE, OPT_MYISAM_SORT_BUFFER_SIZE,
1367
1705
  OPT_MYISAM_USE_MMAP, OPT_MYISAM_REPAIR_THREADS,
1368
 
  OPT_NET_BUFFER_LENGTH,
 
1706
  OPT_MYISAM_STATS_METHOD,
 
1707
  OPT_NET_BUFFER_LENGTH, OPT_NET_RETRY_COUNT,
 
1708
  OPT_NET_READ_TIMEOUT, OPT_NET_WRITE_TIMEOUT,
1369
1709
  OPT_PRELOAD_BUFFER_SIZE,
1370
1710
  OPT_RECORD_BUFFER,
1371
1711
  OPT_RECORD_RND_BUFFER, OPT_DIV_PRECINCREMENT,
1391
1731
  OPT_ENABLE_LARGE_PAGES,
1392
1732
  OPT_TIMED_MUTEXES,
1393
1733
  OPT_TABLE_LOCK_WAIT_TIMEOUT,
1394
 
  OPT_PLUGIN_ADD,
1395
 
  OPT_PLUGIN_REMOVE,
1396
1734
  OPT_PLUGIN_LOAD,
1397
1735
  OPT_PLUGIN_DIR,
1398
1736
  OPT_PORT_OPEN_TIMEOUT,
1401
1739
};
1402
1740
 
1403
1741
 
1404
 
struct option my_long_options[] =
 
1742
#define LONG_TIMEOUT ((uint32_t) 3600L*24L*365L)
 
1743
 
 
1744
struct my_option my_long_options[] =
1405
1745
{
1406
1746
  {"help", '?', N_("Display this help and exit."),
1407
1747
   (char**) &opt_help, (char**) &opt_help, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
1408
1748
   0, 0},
1409
 
  {"help-extended", '?',
1410
 
   N_("Display this help and exit after initializing plugins."),
1411
 
   (char**) &opt_help_extended, (char**) &opt_help_extended,
1412
 
   0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
1413
1749
  {"auto-increment-increment", OPT_AUTO_INCREMENT,
1414
1750
   N_("Auto-increment columns are incremented by this"),
1415
1751
   (char**) &global_system_variables.auto_increment_increment,
1426
1762
      "relative to this."),
1427
1763
   (char**) &drizzle_home_ptr, (char**) &drizzle_home_ptr, 0, GET_STR, REQUIRED_ARG,
1428
1764
   0, 0, 0, 0, 0, 0},
 
1765
  {"bind-address", OPT_BIND_ADDRESS, N_("IP address to bind to."),
 
1766
   (char**) &my_bind_addr_str, (char**) &my_bind_addr_str, 0, GET_STR,
 
1767
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
1429
1768
  {"chroot", 'r',
1430
1769
   N_("Chroot drizzled daemon during startup."),
1431
1770
   (char**) &drizzled_chroot, (char**) &drizzled_chroot, 0, GET_STR, REQUIRED_ARG,
1455
1794
   N_("Set the default time zone."),
1456
1795
   (char**) &default_tz_name, (char**) &default_tz_name,
1457
1796
   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
 
1797
  {"delay-key-write", OPT_DELAY_KEY_WRITE,
 
1798
   N_("Type of DELAY_KEY_WRITE."),
 
1799
   0,0,0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
 
1800
#ifdef HAVE_STACK_TRACE_ON_SEGV
 
1801
  {"enable-pstack", OPT_DO_PSTACK,
 
1802
   N_("Print a symbolic stack trace on failure."),
 
1803
   (char**) &opt_do_pstack, (char**) &opt_do_pstack, 0, GET_BOOL, NO_ARG, 0, 0,
 
1804
   0, 0, 0, 0},
 
1805
#endif /* HAVE_STACK_TRACE_ON_SEGV */
1458
1806
  /* See how it's handled in get_one_option() */
1459
1807
  {"exit-info", 'T',
1460
1808
   N_("Used for debugging;  Use at your own risk!"),
1479
1827
   (char**) &global_system_variables.log_warnings,
1480
1828
   (char**) &max_system_variables.log_warnings, 0, GET_BOOL, OPT_ARG, 1, 0, 0,
1481
1829
   0, 0, 0},
 
1830
  {"memlock", OPT_MEMLOCK,
 
1831
   N_("Lock drizzled in memory."),
 
1832
   (char**) &locked_in_memory,
 
1833
   (char**) &locked_in_memory, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
1482
1834
  {"pid-file", OPT_PID_FILE,
1483
1835
   N_("Pid file used by safe_mysqld."),
1484
1836
   (char**) &pidfile_name_ptr, (char**) &pidfile_name_ptr, 0, GET_STR,
1485
1837
   REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
1838
  {"port", 'P',
 
1839
   N_("Port number to use for connection or 0 for default to, in "
 
1840
      "order of preference, drizzle.cnf, $DRIZZLE_TCP_PORT, "
 
1841
      "built-in default (" STRINGIFY_ARG(DRIZZLE_TCP_PORT) ")."),
 
1842
   (char**) &drizzled_tcp_port,
 
1843
   (char**) &drizzled_tcp_port, 0, GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
1486
1844
  {"port-open-timeout", OPT_PORT_OPEN_TIMEOUT,
1487
1845
   N_("Maximum time in seconds to wait for the port to become free. "
1488
1846
      "(Default: no wait)"),
1489
 
   (char**) &drizzled_bind_timeout,
1490
 
   (char**) &drizzled_bind_timeout, 0, GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
1847
   (char**) &drizzled_port_timeout,
 
1848
   (char**) &drizzled_port_timeout, 0, GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
1491
1849
  {"secure-file-priv", OPT_SECURE_FILE_PRIV,
1492
1850
   N_("Limit LOAD DATA, SELECT ... OUTFILE, and LOAD_FILE() to files "
1493
1851
      "within specified directory"),
1504
1862
   0, 0, 0, 0},
1505
1863
  {"symbolic-links", 's',
1506
1864
   N_("Enable symbolic link support."),
1507
 
   (char**) &internal::my_use_symdir, (char**) &internal::my_use_symdir, 0, GET_BOOL, NO_ARG,
 
1865
   (char**) &my_use_symdir, (char**) &my_use_symdir, 0, GET_BOOL, NO_ARG,
1508
1866
   /*
1509
1867
     The system call realpath() produces warnings under valgrind and
1510
1868
     purify. These are not suppressed: instead we disable symlinks
1514
1872
  {"timed_mutexes", OPT_TIMED_MUTEXES,
1515
1873
   N_("Specify whether to time mutexes (only InnoDB mutexes are currently "
1516
1874
      "supported)"),
1517
 
   (char**) &internal::timed_mutexes, (char**) &internal::timed_mutexes, 0, GET_BOOL, NO_ARG, 0,
 
1875
   (char**) &timed_mutexes, (char**) &timed_mutexes, 0, GET_BOOL, NO_ARG, 0,
1518
1876
    0, 0, 0, 0, 0},
1519
1877
  {"tmpdir", 't',
1520
1878
   N_("Path for temporary files."),
1544
1902
    (char**) &global_system_variables.bulk_insert_buff_size,
1545
1903
    (char**) &max_system_variables.bulk_insert_buff_size,
1546
1904
    0, GET_ULL, REQUIRED_ARG, 8192*1024, 0, ULONG_MAX, 0, 1, 0},
 
1905
  { "connect_timeout", OPT_CONNECT_TIMEOUT,
 
1906
    N_("The number of seconds the drizzled server is waiting for a connect "
 
1907
       "packet before responding with 'Bad handshake'."),
 
1908
    (char**) &connect_timeout, (char**) &connect_timeout,
 
1909
    0, GET_UINT32, REQUIRED_ARG, CONNECT_TIMEOUT, 2, LONG_TIMEOUT, 0, 1, 0 },
1547
1910
  { "div_precision_increment", OPT_DIV_PRECINCREMENT,
1548
1911
   N_("Precision of the result of '/' operator will be increased on that "
1549
1912
      "value."),
1561
1924
   (char**) &max_system_variables.join_buff_size, 0, GET_UINT64,
1562
1925
   REQUIRED_ARG, 128*1024L, IO_SIZE*2+MALLOC_OVERHEAD, ULONG_MAX,
1563
1926
   MALLOC_OVERHEAD, IO_SIZE, 0},
 
1927
  {"key_buffer_size", OPT_KEY_BUFFER_SIZE,
 
1928
   N_("The size of the buffer used for index blocks for MyISAM tables. "
 
1929
      "Increase this to get better index handling (for all reads and multiple "
 
1930
      "writes) to as much as you can afford;"),
 
1931
   (char**) &dflt_key_cache_var.param_buff_size,
 
1932
   (char**) 0,
 
1933
   0, (GET_ULL),
 
1934
   REQUIRED_ARG, KEY_CACHE_SIZE, MALLOC_OVERHEAD, SIZE_T_MAX, MALLOC_OVERHEAD,
 
1935
   IO_SIZE, 0},
 
1936
  {"key_cache_age_threshold", OPT_KEY_CACHE_AGE_THRESHOLD,
 
1937
   N_("This characterizes the number of hits a hot block has to be untouched "
 
1938
      "until it is considered aged enough to be downgraded to a warm block. "
 
1939
      "This specifies the percentage ratio of that number of hits to the "
 
1940
      "total number of blocks in key cache"),
 
1941
   (char**) &dflt_key_cache_var.param_age_threshold,
 
1942
   (char**) 0,
 
1943
   0, (GET_UINT32), REQUIRED_ARG,
 
1944
   300, 100, ULONG_MAX, 0, 100, 0},
 
1945
  {"key_cache_block_size", OPT_KEY_CACHE_BLOCK_SIZE,
 
1946
   N_("The default size of key cache blocks"),
 
1947
   (char**) &dflt_key_cache_var.param_block_size,
 
1948
   (char**) 0,
 
1949
   0, (GET_UINT32), REQUIRED_ARG,
 
1950
   KEY_CACHE_BLOCK_SIZE, 512, 1024 * 16, 0, 512, 0},
 
1951
  {"key_cache_division_limit", OPT_KEY_CACHE_DIVISION_LIMIT,
 
1952
   N_("The minimum percentage of warm blocks in key cache"),
 
1953
   (char**) &dflt_key_cache_var.param_division_limit,
 
1954
   (char**) 0,
 
1955
   0, (GET_UINT32) , REQUIRED_ARG, 100,
 
1956
   1, 100, 0, 1, 0},
1564
1957
  {"max_allowed_packet", OPT_MAX_ALLOWED_PACKET,
1565
1958
   N_("Max packetlength to send/receive from to server."),
1566
1959
   (char**) &global_system_variables.max_allowed_packet,
1615
2008
   (char**) &global_system_variables.min_examined_row_limit,
1616
2009
   (char**) &max_system_variables.min_examined_row_limit, 0, GET_ULL,
1617
2010
   REQUIRED_ARG, 0, 0, ULONG_MAX, 0, 1L, 0},
 
2011
  {"myisam_stats_method", OPT_MYISAM_STATS_METHOD,
 
2012
   N_("Specifies how MyISAM index statistics collection code should threat "
 
2013
      "NULLs. Possible values of name are 'nulls_unequal' "
 
2014
      "(default behavior), "
 
2015
      "'nulls_equal' (emulate MySQL 4.0 behavior), and 'nulls_ignored'."),
 
2016
   (char**) &myisam_stats_method_str, (char**) &myisam_stats_method_str, 0,
 
2017
    GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
2018
  {"net_buffer_length", OPT_NET_BUFFER_LENGTH,
 
2019
   N_("Buffer length for TCP/IP and socket communication."),
 
2020
   (char**) &global_system_variables.net_buffer_length,
 
2021
   (char**) &max_system_variables.net_buffer_length, 0, GET_UINT32,
 
2022
   REQUIRED_ARG, 16384, 1024, 1024*1024L, 0, 1024, 0},
 
2023
  {"net_read_timeout", OPT_NET_READ_TIMEOUT,
 
2024
   N_("Number of seconds to wait for more data from a connection before "
 
2025
      "aborting the read."),
 
2026
   (char**) &global_system_variables.net_read_timeout,
 
2027
   (char**) &max_system_variables.net_read_timeout, 0, GET_UINT32,
 
2028
   REQUIRED_ARG, NET_READ_TIMEOUT, 1, LONG_TIMEOUT, 0, 1, 0},
 
2029
  {"net_retry_count", OPT_NET_RETRY_COUNT,
 
2030
   N_("If a read on a communication port is interrupted, retry this many "
 
2031
      "times before giving up."),
 
2032
   (char**) &global_system_variables.net_retry_count,
 
2033
   (char**) &max_system_variables.net_retry_count,0,
 
2034
   GET_UINT32, REQUIRED_ARG, MYSQLD_NET_RETRY_COUNT, 1, ULONG_MAX, 0, 1, 0},
 
2035
  {"net_write_timeout", OPT_NET_WRITE_TIMEOUT,
 
2036
   N_("Number of seconds to wait for a block to be written to a connection "
 
2037
      "before aborting the write."),
 
2038
   (char**) &global_system_variables.net_write_timeout,
 
2039
   (char**) &max_system_variables.net_write_timeout, 0, GET_UINT32,
 
2040
   REQUIRED_ARG, NET_WRITE_TIMEOUT, 1, LONG_TIMEOUT, 0, 1, 0},
1618
2041
  {"optimizer_prune_level", OPT_OPTIMIZER_PRUNE_LEVEL,
1619
2042
    N_("Controls the heuristic(s) applied during query optimization to prune "
1620
2043
       "less-promising partial plans from the optimizer search space. Meaning: "
1634
2057
      "testing/comparison)."),
1635
2058
   (char**) &global_system_variables.optimizer_search_depth,
1636
2059
   (char**) &max_system_variables.optimizer_search_depth,
1637
 
   0, GET_UINT, OPT_ARG, 0, 0, MAX_TABLES+2, 0, 1, 0},
 
2060
   0, GET_UINT, OPT_ARG, MAX_TABLES+1, 0, MAX_TABLES+2, 0, 1, 0},
1638
2061
  {"plugin_dir", OPT_PLUGIN_DIR,
1639
2062
   N_("Directory for plugins."),
1640
2063
   (char**) &opt_plugin_dir_ptr, (char**) &opt_plugin_dir_ptr, 0,
1641
2064
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
1642
 
  {"plugin_add", OPT_PLUGIN_ADD,
1643
 
   N_("Optional comma separated list of plugins to load at startup in addition "
1644
 
      "to the default list of plugins. "
1645
 
      "[for example: --plugin_add=crc32,logger_gearman]"),
1646
 
   (char**) &opt_plugin_add, (char**) &opt_plugin_add, 0,
1647
 
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
1648
 
  {"plugin_remove", OPT_PLUGIN_ADD,
1649
 
   N_("Optional comma separated list of plugins to not load at startup. Effectively "
1650
 
      "removes a plugin from the list of plugins to be loaded. "
1651
 
      "[for example: --plugin_remove=crc32,logger_gearman]"),
1652
 
   (char**) &opt_plugin_remove, (char**) &opt_plugin_remove, 0,
1653
 
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
1654
2065
  {"plugin_load", OPT_PLUGIN_LOAD,
1655
 
   N_("Optional comma separated list of plugins to load at starup instead of "
1656
 
      "the default plugin load list. "
 
2066
   N_("Optional comma separated list of plugins to load at starup."
1657
2067
      "[for example: --plugin_load=crc32,logger_gearman]"),
1658
2068
   (char**) &opt_plugin_load, (char**) &opt_plugin_load, 0,
1659
2069
   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
1709
2119
  {"table_definition_cache", OPT_TABLE_DEF_CACHE,
1710
2120
   N_("The number of cached table definitions."),
1711
2121
   (char**) &table_def_size, (char**) &table_def_size,
1712
 
   0, GET_SIZE, REQUIRED_ARG, 128, 1, 512*1024L, 0, 1, 0},
 
2122
   0, GET_ULL, REQUIRED_ARG, 128, 1, 512*1024L, 0, 1, 0},
1713
2123
  {"table_open_cache", OPT_TABLE_OPEN_CACHE,
1714
2124
   N_("The number of cached open tables."),
1715
2125
   (char**) &table_cache_size, (char**) &table_cache_size, 0, GET_UINT64,
1716
 
   REQUIRED_ARG, TABLE_OPEN_CACHE_DEFAULT, TABLE_OPEN_CACHE_MIN, 512*1024L, 0, 1, 0},
 
2126
   REQUIRED_ARG, TABLE_OPEN_CACHE_DEFAULT, 1, 512*1024L, 0, 1, 0},
1717
2127
  {"table_lock_wait_timeout", OPT_TABLE_LOCK_WAIT_TIMEOUT,
1718
2128
   N_("Timeout in seconds to wait for a table level lock before returning an "
1719
2129
      "error. Used only if the connection has active cursors."),
1724
2134
   (char**) &my_thread_stack_size,
1725
2135
   (char**) &my_thread_stack_size, 0, GET_SIZE,
1726
2136
   REQUIRED_ARG,DEFAULT_THREAD_STACK,
1727
 
   UINT32_C(1024*512), SIZE_MAX, 0, 1024, 0},
 
2137
   UINT32_C(1024*128), SIZE_MAX, 0, 1024, 0},
1728
2138
  {"tmp_table_size", OPT_TMP_TABLE_SIZE,
1729
2139
   N_("If an internal in-memory temporary table exceeds this size, Drizzle will"
1730
2140
      " automatically convert it to an on-disk MyISAM table."),
1731
2141
   (char**) &global_system_variables.tmp_table_size,
1732
2142
   (char**) &max_system_variables.tmp_table_size, 0, GET_ULL,
1733
2143
   REQUIRED_ARG, 16*1024*1024L, 1024, MAX_MEM_TABLE_SIZE, 0, 1, 0},
 
2144
  {"transaction_alloc_block_size", OPT_TRANS_ALLOC_BLOCK_SIZE,
 
2145
   N_("Allocation block size for transactions to be stored in binary log"),
 
2146
   (char**) &global_system_variables.trans_alloc_block_size,
 
2147
   (char**) &max_system_variables.trans_alloc_block_size, 0, GET_UINT,
 
2148
   REQUIRED_ARG, QUERY_ALLOC_BLOCK_SIZE, 1024, ULONG_MAX, 0, 1024, 0},
 
2149
  {"transaction_prealloc_size", OPT_TRANS_PREALLOC_SIZE,
 
2150
   N_("Persistent buffer for transactions to be stored in binary log"),
 
2151
   (char**) &global_system_variables.trans_prealloc_size,
 
2152
   (char**) &max_system_variables.trans_prealloc_size, 0, GET_UINT,
 
2153
   REQUIRED_ARG, TRANS_ALLOC_PREALLOC_SIZE, 1024, ULONG_MAX, 0, 1024, 0},
 
2154
  {"wait_timeout", OPT_WAIT_TIMEOUT,
 
2155
   N_("The number of seconds the server waits for activity on a connection "
 
2156
      "before closing it."),
 
2157
   (char**) &global_system_variables.net_wait_timeout,
 
2158
   (char**) &max_system_variables.net_wait_timeout, 0, GET_UINT,
 
2159
   REQUIRED_ARG, NET_WAIT_TIMEOUT, 1, LONG_TIMEOUT,
 
2160
   0, 1, 0},
1734
2161
  {0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
1735
2162
};
1736
2163
 
 
2164
static int show_starttime(SHOW_VAR *var, char *buff)
 
2165
{
 
2166
  var->type= SHOW_LONG;
 
2167
  var->value= buff;
 
2168
  *((long *)buff)= (long) (time(NULL) - server_start_time);
 
2169
  return 0;
 
2170
}
 
2171
 
 
2172
static st_show_var_func_container
 
2173
show_starttime_cont= { &show_starttime };
 
2174
 
 
2175
static int show_flushstatustime(SHOW_VAR *var, char *buff)
 
2176
{
 
2177
  var->type= SHOW_LONG;
 
2178
  var->value= buff;
 
2179
  *((long *)buff)= (long) (time(NULL) - flush_status_time);
 
2180
  return 0;
 
2181
}
 
2182
 
 
2183
static st_show_var_func_container
 
2184
show_flushstatustime_cont= { &show_flushstatustime };
 
2185
 
 
2186
static int show_open_tables(SHOW_VAR *var, char *buff)
 
2187
{
 
2188
  var->type= SHOW_LONG;
 
2189
  var->value= buff;
 
2190
  *((long *)buff)= (long)cached_open_tables();
 
2191
  return 0;
 
2192
}
 
2193
 
 
2194
static int show_table_definitions(SHOW_VAR *var, char *buff)
 
2195
{
 
2196
  var->type= SHOW_LONG;
 
2197
  var->value= buff;
 
2198
  *((long *)buff)= (long)cached_table_definitions();
 
2199
  return 0;
 
2200
}
 
2201
 
 
2202
static st_show_var_func_container
 
2203
show_open_tables_cont= { &show_open_tables };
 
2204
static st_show_var_func_container
 
2205
show_table_definitions_cont= { &show_table_definitions };
 
2206
 
 
2207
/*
 
2208
  Variables shown by SHOW STATUS in alphabetical order
 
2209
*/
 
2210
 
 
2211
SHOW_VAR status_vars[]= {
 
2212
  {"Aborted_clients",          (char*) &aborted_threads,        SHOW_LONGLONG},
 
2213
  {"Aborted_connects",         (char*) &aborted_connects,       SHOW_LONGLONG},
 
2214
  {"Bytes_received",           (char*) offsetof(STATUS_VAR, bytes_received), SHOW_LONGLONG_STATUS},
 
2215
  {"Bytes_sent",               (char*) offsetof(STATUS_VAR, bytes_sent), SHOW_LONGLONG_STATUS},
 
2216
  {"Com",                      (char*) com_status_vars, SHOW_ARRAY},
 
2217
  {"Connections",              (char*) &thread_id,          SHOW_INT_NOFLUSH},
 
2218
  {"Created_tmp_disk_tables",  (char*) offsetof(STATUS_VAR, created_tmp_disk_tables), SHOW_LONG_STATUS},
 
2219
  {"Created_tmp_files",        (char*) &my_tmp_file_created,SHOW_INT},
 
2220
  {"Created_tmp_tables",       (char*) offsetof(STATUS_VAR, created_tmp_tables), SHOW_LONG_STATUS},
 
2221
  {"Flush_commands",           (char*) &refresh_version,    SHOW_INT_NOFLUSH},
 
2222
  {"Handler_commit",           (char*) offsetof(STATUS_VAR, ha_commit_count), SHOW_LONG_STATUS},
 
2223
  {"Handler_delete",           (char*) offsetof(STATUS_VAR, ha_delete_count), SHOW_LONG_STATUS},
 
2224
  {"Handler_prepare",          (char*) offsetof(STATUS_VAR, ha_prepare_count),  SHOW_LONG_STATUS},
 
2225
  {"Handler_read_first",       (char*) offsetof(STATUS_VAR, ha_read_first_count), SHOW_LONG_STATUS},
 
2226
  {"Handler_read_key",         (char*) offsetof(STATUS_VAR, ha_read_key_count), SHOW_LONG_STATUS},
 
2227
  {"Handler_read_next",        (char*) offsetof(STATUS_VAR, ha_read_next_count), SHOW_LONG_STATUS},
 
2228
  {"Handler_read_prev",        (char*) offsetof(STATUS_VAR, ha_read_prev_count), SHOW_LONG_STATUS},
 
2229
  {"Handler_read_rnd",         (char*) offsetof(STATUS_VAR, ha_read_rnd_count), SHOW_LONG_STATUS},
 
2230
  {"Handler_read_rnd_next",    (char*) offsetof(STATUS_VAR, ha_read_rnd_next_count), SHOW_LONG_STATUS},
 
2231
  {"Handler_rollback",         (char*) offsetof(STATUS_VAR, ha_rollback_count), SHOW_LONG_STATUS},
 
2232
  {"Handler_savepoint",        (char*) offsetof(STATUS_VAR, ha_savepoint_count), SHOW_LONG_STATUS},
 
2233
  {"Handler_savepoint_rollback",(char*) offsetof(STATUS_VAR, ha_savepoint_rollback_count), SHOW_LONG_STATUS},
 
2234
  {"Handler_update",           (char*) offsetof(STATUS_VAR, ha_update_count), SHOW_LONG_STATUS},
 
2235
  {"Handler_write",            (char*) offsetof(STATUS_VAR, ha_write_count), SHOW_LONG_STATUS},
 
2236
  {"Key_blocks_not_flushed",   (char*) offsetof(KEY_CACHE, global_blocks_changed), SHOW_KEY_CACHE_LONG},
 
2237
  {"Key_blocks_unused",        (char*) offsetof(KEY_CACHE, blocks_unused), SHOW_KEY_CACHE_LONG},
 
2238
  {"Key_blocks_used",          (char*) offsetof(KEY_CACHE, blocks_used), SHOW_KEY_CACHE_LONG},
 
2239
  {"Key_read_requests",        (char*) offsetof(KEY_CACHE, global_cache_r_requests), SHOW_KEY_CACHE_LONGLONG},
 
2240
  {"Key_reads",                (char*) offsetof(KEY_CACHE, global_cache_read), SHOW_KEY_CACHE_LONGLONG},
 
2241
  {"Key_write_requests",       (char*) offsetof(KEY_CACHE, global_cache_w_requests), SHOW_KEY_CACHE_LONGLONG},
 
2242
  {"Key_writes",               (char*) offsetof(KEY_CACHE, global_cache_write), SHOW_KEY_CACHE_LONGLONG},
 
2243
  {"Last_query_cost",          (char*) offsetof(STATUS_VAR, last_query_cost), SHOW_DOUBLE_STATUS},
 
2244
  {"Max_used_connections",     (char*) &max_used_connections,  SHOW_INT},
 
2245
  {"Open_files",               (char*) &my_file_opened,    SHOW_INT_NOFLUSH},
 
2246
  {"Open_streams",             (char*) &my_stream_opened,  SHOW_INT_NOFLUSH},
 
2247
  {"Open_table_definitions",   (char*) &show_table_definitions_cont, SHOW_FUNC},
 
2248
  {"Open_tables",              (char*) &show_open_tables_cont,       SHOW_FUNC},
 
2249
  {"Opened_files",             (char*) &my_file_total_opened, SHOW_INT_NOFLUSH},
 
2250
  {"Opened_tables",            (char*) offsetof(STATUS_VAR, opened_tables), SHOW_LONG_STATUS},
 
2251
  {"Opened_table_definitions", (char*) offsetof(STATUS_VAR, opened_shares), SHOW_LONG_STATUS},
 
2252
  {"Questions",                (char*) offsetof(STATUS_VAR, questions), SHOW_LONG_STATUS},
 
2253
  {"Select_full_join",         (char*) offsetof(STATUS_VAR, select_full_join_count), SHOW_LONG_STATUS},
 
2254
  {"Select_full_range_join",   (char*) offsetof(STATUS_VAR, select_full_range_join_count), SHOW_LONG_STATUS},
 
2255
  {"Select_range",             (char*) offsetof(STATUS_VAR, select_range_count), SHOW_LONG_STATUS},
 
2256
  {"Select_range_check",       (char*) offsetof(STATUS_VAR, select_range_check_count), SHOW_LONG_STATUS},
 
2257
  {"Select_scan",              (char*) offsetof(STATUS_VAR, select_scan_count), SHOW_LONG_STATUS},
 
2258
  {"Slow_queries",             (char*) offsetof(STATUS_VAR, long_query_count), SHOW_LONG_STATUS},
 
2259
  {"Sort_merge_passes",        (char*) offsetof(STATUS_VAR, filesort_merge_passes), SHOW_LONG_STATUS},
 
2260
  {"Sort_range",               (char*) offsetof(STATUS_VAR, filesort_range_count), SHOW_LONG_STATUS},
 
2261
  {"Sort_rows",                (char*) offsetof(STATUS_VAR, filesort_rows), SHOW_LONG_STATUS},
 
2262
  {"Sort_scan",                (char*) offsetof(STATUS_VAR, filesort_scan_count), SHOW_LONG_STATUS},
 
2263
  {"Table_locks_immediate",    (char*) &locks_immediate,        SHOW_INT},
 
2264
  {"Table_locks_waited",       (char*) &locks_waited,           SHOW_INT},
 
2265
  {"Threads_connected",        (char*) &connection_count,       SHOW_INT},
 
2266
  {"Uptime",                   (char*) &show_starttime_cont,         SHOW_FUNC},
 
2267
  {"Uptime_since_flush_status",(char*) &show_flushstatustime_cont,   SHOW_FUNC},
 
2268
  {NULL, NULL, SHOW_LONGLONG}
 
2269
};
 
2270
 
1737
2271
static void print_version(void)
1738
2272
{
1739
2273
  /*
1740
2274
    Note: the instance manager keys off the string 'Ver' so it can find the
1741
2275
    version from the output of 'drizzled --version', so don't change it!
1742
2276
  */
1743
 
  printf("%s  Ver %s for %s-%s on %s (%s)\n",internal::my_progname,
1744
 
         PANDORA_RELEASE_VERSION, HOST_VENDOR, HOST_OS, HOST_CPU,
1745
 
         COMPILATION_COMMENT);
 
2277
  printf("%s  Ver %s for %s-%s on %s (%s)\n",my_progname,
 
2278
         VERSION, HOST_VENDOR, HOST_OS, HOST_CPU, COMPILATION_COMMENT);
1746
2279
}
1747
2280
 
1748
2281
static void usage(void)
1759
2292
         "license\n\n"
1760
2293
         "Starts the Drizzle database server\n"));
1761
2294
 
1762
 
  printf(_("Usage: %s [OPTIONS]\n"), internal::my_progname);
 
2295
  printf(_("Usage: %s [OPTIONS]\n"), my_progname);
1763
2296
  {
1764
 
     internal::print_defaults(DRIZZLE_CONFIG_NAME,load_default_groups);
1765
 
     puts("");
1766
 
 
1767
 
     /* Print out all the options including plugin supplied options */
1768
 
     my_print_help_inc_plugins(my_long_options);
 
2297
#ifdef FOO
 
2298
  print_defaults(DRIZZLE_CONFIG_NAME,load_default_groups);
 
2299
  puts("");
 
2300
  set_default_port();
 
2301
#endif
 
2302
 
 
2303
  /* Print out all the options including plugin supplied options */
 
2304
  my_print_help_inc_plugins(my_long_options);
1769
2305
  }
1770
2306
}
1771
2307
 
1799
2335
  dropping_tables= ha_open_options=0;
1800
2336
  test_flags.reset();
1801
2337
  wake_thread=0;
 
2338
  opt_endinfo= false;
1802
2339
  abort_loop= select_thread_in_use= false;
1803
2340
  ready_to_exit= shutdown_in_progress= 0;
1804
2341
  aborted_threads= aborted_connects= 0;
1805
2342
  max_used_connections= 0;
1806
2343
  drizzled_user= drizzled_chroot= 0;
 
2344
  my_bind_addr_str= NULL;
1807
2345
  memset(&global_status_var, 0, sizeof(global_status_var));
1808
2346
  key_map_full.set();
1809
2347
 
1814
2352
  character_set_filesystem= &my_charset_bin;
1815
2353
 
1816
2354
  /* Things with default values that are not zero */
 
2355
  delay_key_write_options= (uint32_t) DELAY_KEY_WRITE_ON;
1817
2356
  drizzle_home_ptr= drizzle_home;
1818
2357
  pidfile_name_ptr= pidfile_name;
1819
2358
  language_ptr= language;
1820
2359
  drizzle_data_home= drizzle_real_data_home;
1821
2360
  session_startup_options= (OPTION_AUTO_IS_NULL | OPTION_SQL_NOTES);
1822
2361
  refresh_version= 1L;  /* Increments on each reload */
1823
 
  global_thread_id= 1UL;
1824
 
  getSessionList().clear();
 
2362
  thread_id= 1;
 
2363
  myisam_stats_method_str= "nulls_unequal";
 
2364
  session_list.clear();
1825
2365
 
1826
2366
  /* Set directory paths */
1827
2367
  strncpy(language, LANGUAGE, sizeof(language)-1);
1844
2384
  max_system_variables.select_limit=    (uint64_t) HA_POS_ERROR;
1845
2385
  global_system_variables.max_join_size= (uint64_t) HA_POS_ERROR;
1846
2386
  max_system_variables.max_join_size=   (uint64_t) HA_POS_ERROR;
 
2387
  /*
 
2388
    Default behavior for 4.1 and 5.0 is to treat NULL values as unequal
 
2389
    when collecting index statistics for MyISAM tables.
 
2390
  */
 
2391
  global_system_variables.myisam_stats_method= MI_STATS_METHOD_NULLS_NOT_EQUAL;
1847
2392
 
1848
2393
  /* Variables that depends on compile options */
1849
2394
#ifdef HAVE_BROKEN_REALPATH
1861
2406
}
1862
2407
 
1863
2408
 
1864
 
int drizzled_get_one_option(int optid, const struct option *opt,
1865
 
                             char *argument)
 
2409
bool
 
2410
drizzled_get_one_option(int optid, const struct my_option *opt,
 
2411
                        char *argument)
1866
2412
{
1867
2413
  switch(optid) {
 
2414
  case '#':
 
2415
    opt_endinfo=1;                              /* unireg: memory allocation */
 
2416
    break;
1868
2417
  case 'a':
1869
2418
    global_system_variables.tx_isolation= ISO_SERIALIZABLE;
1870
2419
    break;
1908
2457
    {
1909
2458
      test_flags.set((uint32_t) atoi(argument));
1910
2459
    }
 
2460
    opt_endinfo=1;
1911
2461
    break;
1912
2462
  case (int) OPT_WANT_CORE:
1913
2463
    test_flags.set(TEST_CORE_ON_SIGNAL);
1916
2466
    test_flags.set(TEST_NO_STACKTRACE);
1917
2467
    break;
1918
2468
  case (int) OPT_SKIP_SYMLINKS:
1919
 
    internal::my_use_symdir=0;
 
2469
    my_use_symdir=0;
1920
2470
    break;
1921
2471
  case (int) OPT_BIND_ADDRESS:
1922
2472
    {
1929
2479
      if (getaddrinfo(argument, NULL, &hints, &res_lst) != 0)
1930
2480
      {
1931
2481
          errmsg_printf(ERRMSG_LVL_ERROR, _("Can't start server: cannot resolve hostname!"));
1932
 
        return EXIT_ARGUMENT_INVALID;
 
2482
        exit(1);
1933
2483
      }
1934
2484
 
1935
2485
      if (res_lst->ai_next)
1936
2486
      {
1937
2487
          errmsg_printf(ERRMSG_LVL_ERROR, _("Can't start server: bind-address refers to "
1938
2488
                          "multiple interfaces!"));
1939
 
        return EXIT_ARGUMENT_INVALID;
 
2489
        exit(1);
1940
2490
      }
1941
2491
      freeaddrinfo(res_lst);
1942
2492
    }
1946
2496
    break;
1947
2497
  case OPT_SERVER_ID:
1948
2498
    break;
 
2499
  case OPT_DELAY_KEY_WRITE_ALL:
 
2500
    if (argument != disabled_my_option)
 
2501
      argument= (char*) "ALL";
 
2502
    /* Fall through */
 
2503
  case OPT_DELAY_KEY_WRITE:
 
2504
    if (argument == disabled_my_option)
 
2505
      delay_key_write_options= (uint32_t) DELAY_KEY_WRITE_NONE;
 
2506
    else if (! argument)
 
2507
      delay_key_write_options= (uint32_t) DELAY_KEY_WRITE_ON;
 
2508
    else
 
2509
    {
 
2510
      int type;
 
2511
      type= find_type_or_exit(argument, &delay_key_write_typelib, opt->name);
 
2512
      delay_key_write_options= (uint32_t) type-1;
 
2513
    }
 
2514
    break;
1949
2515
  case OPT_TX_ISOLATION:
1950
2516
    {
1951
2517
      int type;
1958
2524
                                            &tc_heuristic_recover_typelib,
1959
2525
                                            opt->name);
1960
2526
    break;
 
2527
  case OPT_MYISAM_STATS_METHOD:
 
2528
    {
 
2529
      uint32_t method_conv;
 
2530
      int method;
 
2531
 
 
2532
      myisam_stats_method_str= argument;
 
2533
      method= find_type_or_exit(argument, &myisam_stats_method_typelib,
 
2534
                                opt->name);
 
2535
      switch (method-1) {
 
2536
      case 2:
 
2537
        method_conv= MI_STATS_METHOD_IGNORE_NULLS;
 
2538
        break;
 
2539
      case 1:
 
2540
        method_conv= MI_STATS_METHOD_NULLS_EQUAL;
 
2541
        break;
 
2542
      case 0:
 
2543
      default:
 
2544
        method_conv= MI_STATS_METHOD_NULLS_NOT_EQUAL;
 
2545
        break;
 
2546
      }
 
2547
      global_system_variables.myisam_stats_method= method_conv;
 
2548
      break;
 
2549
    }
1961
2550
  }
1962
 
 
1963
2551
  return 0;
1964
2552
}
1965
2553
 
1966
 
static void option_error_reporter(enum loglevel level, const char *format, ...)
 
2554
 
 
2555
extern "C" void option_error_reporter(enum loglevel level, const char *format, ...);
 
2556
 
 
2557
void option_error_reporter(enum loglevel level, const char *format, ...)
1967
2558
{
1968
2559
  va_list args;
1969
2560
  va_start(args, format);
1971
2562
  /* Don't print warnings for --loose options during bootstrap */
1972
2563
  if (level == ERROR_LEVEL || global_system_variables.log_warnings)
1973
2564
  {
1974
 
    plugin::ErrorMessage::vprintf(current_session, ERROR_LEVEL, format, args);
 
2565
    errmsg_vprintf (current_session, ERROR_LEVEL, format, args);
1975
2566
  }
1976
2567
  va_end(args);
1977
2568
}
1979
2570
 
1980
2571
/**
1981
2572
  @todo
1982
 
  - FIXME add EXIT_TOO_MANY_ARGUMENTS to "drizzled/error.h" and return that code?
 
2573
  - FIXME add EXIT_TOO_MANY_ARGUMENTS to "mysys/mysys_err.h" and return that code?
1983
2574
*/
1984
2575
static void get_options(int *argc,char **argv)
1985
2576
{
1987
2578
 
1988
2579
  my_getopt_error_reporter= option_error_reporter;
1989
2580
 
1990
 
  string progname(argv[0]);
1991
 
 
1992
2581
  /* Skip unknown options so that they may be processed later by plugins */
1993
2582
  my_getopt_skip_unknown= true;
1994
2583
 
1999
2588
             /* no need to do this for argv as we are discarding it. */
2000
2589
 
2001
2590
#if defined(HAVE_BROKEN_REALPATH)
2002
 
  internal::my_use_symdir=0;
2003
 
  internal::my_disable_symlinks=1;
 
2591
  my_use_symdir=0;
 
2592
  my_disable_symlinks=1;
2004
2593
  have_symlink=SHOW_OPTION_NO;
2005
2594
#else
2006
 
  if (!internal::my_use_symdir)
 
2595
  if (!my_use_symdir)
2007
2596
  {
2008
 
    internal::my_disable_symlinks=1;
 
2597
    my_disable_symlinks=1;
2009
2598
    have_symlink=SHOW_OPTION_DISABLED;
2010
2599
  }
2011
2600
#endif
2016
2605
    test_flags.set(TEST_NO_STACKTRACE);
2017
2606
    test_flags.reset(TEST_CORE_ON_SIGNAL);
2018
2607
  }
 
2608
  /* Set global MyISAM variables from delay_key_write_options */
 
2609
  fix_delay_key_write((Session*) 0, OPT_GLOBAL);
2019
2610
 
2020
2611
  if (drizzled_chroot)
2021
2612
    set_root(drizzled_chroot);
2022
 
  fix_paths(progname);
 
2613
  fix_paths();
2023
2614
 
2024
2615
  /*
2025
2616
    Set some global variables from the global_system_variables
2026
2617
    In most cases the global variables will not be used
2027
2618
  */
2028
 
  internal::my_default_record_cache_size=global_system_variables.read_buff_size;
 
2619
  my_default_record_cache_size=global_system_variables.read_buff_size;
 
2620
  myisam_max_temp_length= INT32_MAX;
2029
2621
}
2030
2622
 
2031
2623
 
2032
2624
static const char *get_relative_path(const char *path)
2033
2625
{
2034
 
  if (internal::test_if_hard_path(path) &&
2035
 
      (strncmp(path, PREFIX, strlen(PREFIX)) == 0) &&
 
2626
  if (test_if_hard_path(path) &&
 
2627
      is_prefix(path,PREFIX) &&
2036
2628
      strcmp(PREFIX,FN_ROOTDIR))
2037
2629
  {
2038
2630
    if (strlen(PREFIX) < strlen(path))
2044
2636
}
2045
2637
 
2046
2638
 
2047
 
static void fix_paths(string &progname)
 
2639
static void fix_paths(void)
2048
2640
{
2049
2641
  char buff[FN_REFLEN],*pos,rp_buff[PATH_MAX];
2050
 
  internal::convert_dirname(drizzle_home,drizzle_home,NULL);
 
2642
  convert_dirname(drizzle_home,drizzle_home,NULL);
2051
2643
  /* Resolve symlinks to allow 'drizzle_home' to be a relative symlink */
2052
2644
#if defined(HAVE_BROKEN_REALPATH)
2053
 
   internal::my_load_path(drizzle_home, drizzle_home, NULL);
 
2645
   my_load_path(drizzle_home, drizzle_home, NULL);
2054
2646
#else
2055
2647
  if (!realpath(drizzle_home,rp_buff))
2056
 
    internal::my_load_path(rp_buff, drizzle_home, NULL);
 
2648
    my_load_path(rp_buff, drizzle_home, NULL);
2057
2649
  rp_buff[FN_REFLEN-1]= '\0';
2058
2650
  strcpy(drizzle_home,rp_buff);
2059
2651
  /* Ensure that drizzle_home ends in FN_LIBCHAR */
2064
2656
    pos[0]= FN_LIBCHAR;
2065
2657
    pos[1]= 0;
2066
2658
  }
2067
 
  internal::convert_dirname(drizzle_real_data_home,drizzle_real_data_home,NULL);
2068
 
  (void) internal::fn_format(buff, drizzle_real_data_home, "", "",
 
2659
  convert_dirname(drizzle_real_data_home,drizzle_real_data_home,NULL);
 
2660
  (void) fn_format(buff, drizzle_real_data_home, "", "",
2069
2661
                   (MY_RETURN_REAL_PATH|MY_RESOLVE_SYMLINKS));
2070
 
  (void) internal::unpack_dirname(drizzle_unpacked_real_data_home, buff);
2071
 
  internal::convert_dirname(language,language,NULL);
2072
 
  (void) internal::my_load_path(drizzle_home, drizzle_home,""); // Resolve current dir
2073
 
  (void) internal::my_load_path(drizzle_real_data_home, drizzle_real_data_home,drizzle_home);
2074
 
  (void) internal::my_load_path(pidfile_name, pidfile_name,drizzle_real_data_home);
2075
 
 
2076
 
  if (opt_plugin_dir_ptr == NULL)
2077
 
  {
2078
 
    /* No plugin dir has been specified. Figure out where the plugins are */
2079
 
    if (progname[0] != FN_LIBCHAR)
2080
 
    {
2081
 
      /* We have a relative path and need to find the absolute */
2082
 
      char working_dir[FN_REFLEN];
2083
 
      char *working_dir_ptr= working_dir;
2084
 
      working_dir_ptr= getcwd(working_dir_ptr, FN_REFLEN);
2085
 
      string new_path(working_dir);
2086
 
      if (*(new_path.end()-1) != '/')
2087
 
        new_path.push_back('/');
2088
 
      if (progname[0] == '.' && progname[1] == '/')
2089
 
        new_path.append(progname.substr(2));
2090
 
      else
2091
 
        new_path.append(progname);
2092
 
      progname.swap(new_path);
2093
 
    }
2094
 
 
2095
 
    /* Now, trim off the exe name */
2096
 
    string progdir(progname.substr(0, progname.rfind(FN_LIBCHAR)+1));
2097
 
    if (progdir.rfind(".libs/") != string::npos)
2098
 
    {
2099
 
      progdir.assign(progdir.substr(0, progdir.rfind(".libs/")));
2100
 
    }
2101
 
    string testfile(progdir);
2102
 
    testfile.append("drizzled.o");
2103
 
    struct stat testfile_stat;
2104
 
    if (stat(testfile.c_str(), &testfile_stat))
2105
 
    {
2106
 
      /* drizzled.o doesn't exist - we are not in a source dir.
2107
 
       * Go on as usual
2108
 
       */
2109
 
      (void) internal::my_load_path(opt_plugin_dir, get_relative_path(PKGPLUGINDIR),
2110
 
                                          drizzle_home);
2111
 
    }
2112
 
    else
2113
 
    {
2114
 
      /* We are in a source dir! Plugin dir is ../plugin/.libs */
2115
 
      size_t last_libchar_pos= progdir.rfind(FN_LIBCHAR,progdir.size()-2)+1;
2116
 
      string source_plugindir(progdir.substr(0,last_libchar_pos));
2117
 
      source_plugindir.append("plugin/.libs");
2118
 
      (void) internal::my_load_path(opt_plugin_dir, source_plugindir.c_str(), "");
2119
 
    }
2120
 
  }
2121
 
  else
2122
 
  {
2123
 
    (void) internal::my_load_path(opt_plugin_dir, opt_plugin_dir_ptr, drizzle_home);
2124
 
  }
 
2662
  (void) unpack_dirname(drizzle_unpacked_real_data_home, buff);
 
2663
  convert_dirname(language,language,NULL);
 
2664
  (void) my_load_path(drizzle_home, drizzle_home,""); // Resolve current dir
 
2665
  (void) my_load_path(drizzle_real_data_home, drizzle_real_data_home,drizzle_home);
 
2666
  (void) my_load_path(pidfile_name, pidfile_name,drizzle_real_data_home);
 
2667
  (void) my_load_path(opt_plugin_dir, opt_plugin_dir_ptr ? opt_plugin_dir_ptr :
 
2668
                                      get_relative_path(PKGPLUGINDIR),
 
2669
                                      drizzle_home);
2125
2670
  opt_plugin_dir_ptr= opt_plugin_dir;
2126
2671
 
2127
2672
  const char *sharedir= get_relative_path(PKGDATADIR);
2128
 
  if (internal::test_if_hard_path(sharedir))
2129
 
    strncpy(buff,sharedir,sizeof(buff)-1);
 
2673
  if (test_if_hard_path(sharedir))
 
2674
    strncpy(buff,sharedir,sizeof(buff)-1);              /* purecov: tested */
2130
2675
  else
2131
2676
  {
2132
2677
    strcpy(buff, drizzle_home);
2133
2678
    strncat(buff, sharedir, sizeof(buff)-strlen(drizzle_home)-1);
2134
2679
  }
2135
 
  internal::convert_dirname(buff,buff,NULL);
2136
 
  (void) internal::my_load_path(language,language,buff);
 
2680
  convert_dirname(buff,buff,NULL);
 
2681
  (void) my_load_path(language,language,buff);
2137
2682
 
2138
2683
  {
2139
2684
    char *tmp_string;
2162
2707
   */
2163
2708
  if (opt_secure_file_priv)
2164
2709
  {
2165
 
    internal::convert_dirname(buff, opt_secure_file_priv, NULL);
 
2710
    convert_dirname(buff, opt_secure_file_priv, NULL);
2166
2711
    free(opt_secure_file_priv);
2167
2712
    opt_secure_file_priv= strdup(buff);
2168
2713
    if (opt_secure_file_priv == NULL)
2170
2715
  }
2171
2716
}
2172
2717
 
2173
 
} /* namespace drizzled */
2174
 
 
2175
 
using namespace drizzled;
2176
 
 
2177
 
 
2178
 
static void init_signals(void)
2179
 
{
2180
 
  sigset_t set;
2181
 
  struct sigaction sa;
2182
 
 
2183
 
  if (!(test_flags.test(TEST_NO_STACKTRACE) || 
2184
 
        test_flags.test(TEST_CORE_ON_SIGNAL)))
2185
 
  {
2186
 
    sa.sa_flags = SA_RESETHAND | SA_NODEFER;
2187
 
    sigemptyset(&sa.sa_mask);
2188
 
    sigprocmask(SIG_SETMASK,&sa.sa_mask,NULL);
2189
 
 
2190
 
    init_stacktrace();
2191
 
    sa.sa_handler=handle_segfault;
2192
 
    sigaction(SIGSEGV, &sa, NULL);
2193
 
    sigaction(SIGABRT, &sa, NULL);
2194
 
#ifdef SIGBUS
2195
 
    sigaction(SIGBUS, &sa, NULL);
2196
 
#endif
2197
 
    sigaction(SIGILL, &sa, NULL);
2198
 
    sigaction(SIGFPE, &sa, NULL);
2199
 
  }
2200
 
 
2201
 
  if (test_flags.test(TEST_CORE_ON_SIGNAL))
2202
 
  {
2203
 
    /* Change limits so that we will get a core file */
2204
 
    struct rlimit rl;
2205
 
    rl.rlim_cur = rl.rlim_max = RLIM_INFINITY;
2206
 
    if (setrlimit(RLIMIT_CORE, &rl) && global_system_variables.log_warnings)
2207
 
        errmsg_printf(ERRMSG_LVL_WARN,
2208
 
                      _("setrlimit could not change the size of core files "
2209
 
                        "to 'infinity';  We may not be able to generate a "
2210
 
                        "core file on signals"));
2211
 
  }
2212
 
  (void) sigemptyset(&set);
2213
 
  my_sigset(SIGPIPE,SIG_IGN);
2214
 
  sigaddset(&set,SIGPIPE);
2215
 
#ifndef IGNORE_SIGHUP_SIGQUIT
2216
 
  sigaddset(&set,SIGQUIT);
2217
 
  sigaddset(&set,SIGHUP);
2218
 
#endif
2219
 
  sigaddset(&set,SIGTERM);
2220
 
 
2221
 
  /* Fix signals if blocked by parents (can happen on Mac OS X) */
2222
 
  sigemptyset(&sa.sa_mask);
2223
 
  sa.sa_flags = 0;
2224
 
  sa.sa_handler = print_signal_warning;
2225
 
  sigaction(SIGTERM, &sa, (struct sigaction*) 0);
2226
 
  sa.sa_flags = 0;
2227
 
  sa.sa_handler = print_signal_warning;
2228
 
  sigaction(SIGHUP, &sa, (struct sigaction*) 0);
2229
 
#ifdef SIGTSTP
2230
 
  sigaddset(&set,SIGTSTP);
2231
 
#endif
2232
 
  if (test_flags.test(TEST_SIGINT))
2233
 
  {
2234
 
    my_sigset(thr_kill_signal, end_thread_signal);
2235
 
    // May be SIGINT
2236
 
    sigdelset(&set, thr_kill_signal);
2237
 
  }
2238
 
  else
2239
 
    sigaddset(&set,SIGINT);
2240
 
  sigprocmask(SIG_SETMASK,&set,NULL);
2241
 
  pthread_sigmask(SIG_SETMASK,&set,NULL);
2242
 
  return;;
2243
 
}
2244
 
 
2245
 
int main(int argc, char **argv)
2246
 
{
2247
 
#if defined(ENABLE_NLS)
2248
 
# if defined(HAVE_LOCALE_H)
2249
 
  setlocale(LC_ALL, "");
2250
 
# endif
2251
 
  bindtextdomain("drizzle", LOCALEDIR);
2252
 
  textdomain("drizzle");
2253
 
#endif
2254
 
 
2255
 
  plugin::Registry &plugins= plugin::Registry::singleton();
2256
 
  plugin::Client *client;
2257
 
  Session *session;
2258
 
 
2259
 
  MY_INIT(argv[0]);             // init my_sys library & pthreads
2260
 
  /* nothing should come before this line ^^^ */
2261
 
 
2262
 
  /* Set signal used to kill Drizzle */
2263
 
#if defined(SIGUSR2)
2264
 
  thr_kill_signal= internal::thd_lib_detected == THD_LIB_LT ? SIGINT : SIGUSR2;
2265
 
#else
2266
 
  thr_kill_signal= SIGINT;
2267
 
#endif
2268
 
 
2269
 
  if (init_common_variables(DRIZZLE_CONFIG_NAME,
2270
 
                            argc, argv, load_default_groups))
2271
 
    unireg_abort(1);                            // Will do exit
2272
 
 
2273
 
  init_signals();
2274
 
 
2275
 
 
2276
 
  select_thread=pthread_self();
2277
 
  select_thread_in_use=1;
2278
 
 
2279
 
  if (chdir(drizzle_real_data_home) && !opt_help)
2280
 
  {
2281
 
    errmsg_printf(ERRMSG_LVL_ERROR, _("Data directory %s does not exist\n"), drizzle_real_data_home);
2282
 
    unireg_abort(1);
2283
 
  }
2284
 
  drizzle_data_home= drizzle_data_home_buff;
2285
 
  drizzle_data_home[0]=FN_CURLIB;               // all paths are relative from here
2286
 
  drizzle_data_home[1]=0;
2287
 
  drizzle_data_home_len= 2;
2288
 
 
2289
 
  if ((user_info= check_user(drizzled_user)))
2290
 
  {
2291
 
    set_user(drizzled_user, user_info);
2292
 
  }
2293
 
 
2294
 
  if (server_id == 0)
2295
 
  {
2296
 
    server_id= 1;
2297
 
  }
2298
 
 
2299
 
  if (init_server_components(plugins))
2300
 
    unireg_abort(1);
2301
 
 
2302
 
  if (plugin::Listen::setup())
2303
 
    unireg_abort(1);
2304
 
 
2305
 
  /*
2306
 
    init signals & alarm
2307
 
    After this we can't quit by a simple unireg_abort
2308
 
  */
2309
 
  error_handler_hook= my_message_sql;
2310
 
 
2311
 
  assert(plugin::num_trx_monitored_objects > 0);
2312
 
  if (drizzle_rm_tmp_tables() ||
2313
 
      my_tz_init((Session *)0, default_tz_name))
2314
 
  {
2315
 
    abort_loop= true;
2316
 
    select_thread_in_use=0;
2317
 
    (void) pthread_kill(signal_thread, SIGTERM);
2318
 
 
2319
 
    (void) unlink(pidfile_name);        // Not needed anymore
2320
 
 
2321
 
    exit(1);
2322
 
  }
2323
 
 
2324
 
  init_status_vars();
2325
 
 
2326
 
  errmsg_printf(ERRMSG_LVL_INFO, _(ER(ER_STARTUP)), internal::my_progname,
2327
 
                PANDORA_RELEASE_VERSION, COMPILATION_COMMENT);
2328
 
 
2329
 
 
2330
 
  /* Listen for new connections and start new session for each connection
2331
 
     accepted. The listen.getClient() method will return NULL when the server
2332
 
     should be shutdown. */
2333
 
  while ((client= plugin::Listen::getClient()) != NULL)
2334
 
  {
2335
 
    if (!(session= new Session(client)))
2336
 
    {
2337
 
      delete client;
2338
 
      continue;
2339
 
    }
2340
 
 
2341
 
    /* If we error on creation we drop the connection and delete the session. */
2342
 
    if (session->schedule())
2343
 
      Session::unlink(session);
2344
 
  }
2345
 
 
2346
 
  /* (void) pthread_attr_destroy(&connection_attrib); */
2347
 
 
2348
 
 
2349
 
  (void) pthread_mutex_lock(&LOCK_thread_count);
2350
 
  select_thread_in_use=0;                       // For close_connections
2351
 
  (void) pthread_mutex_unlock(&LOCK_thread_count);
2352
 
  (void) pthread_cond_broadcast(&COND_thread_count);
2353
 
 
2354
 
  /* Wait until cleanup is done */
2355
 
  (void) pthread_mutex_lock(&LOCK_thread_count);
2356
 
  while (!ready_to_exit)
2357
 
    pthread_cond_wait(&COND_server_end,&LOCK_thread_count);
2358
 
  (void) pthread_mutex_unlock(&LOCK_thread_count);
2359
 
 
2360
 
  clean_up(1);
2361
 
  plugin::Registry::shutdown();
2362
 
  clean_up_mutexes();
2363
 
  internal::my_end();
2364
 
  return 0;
2365
 
}
2366
 
 
 
2718
/*****************************************************************************
 
2719
  Instantiate templates
 
2720
*****************************************************************************/
 
2721
 
 
2722
#ifdef HAVE_EXPLICIT_TEMPLATE_INSTANTIATION
 
2723
/* Used templates */
 
2724
template class I_List<i_string>;
 
2725
template class I_List<i_string_pair>;
 
2726
template class I_List<Statement>;
 
2727
template class I_List_iterator<Statement>;
 
2728
#endif