← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/innobase/srv/srv0start.c

  • Committer: Jay Pipes
  • Date: 2009-04-10 17:06:58 UTC
  • mto: (971.1.47 mordred)
  • mto: This revision was merged to the branch mainline in revision 990.
  • Revision ID: jpipes@serialcoder-20090410170658-d3azdnas1fn8v68l
Removal of log.cc (binlog), added Applier plugin and fixed up Replicator
plugin.  New transaction_services.cc class implementation of the API for
converting between internal formats and GPB Command Messages.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/srv/srv0start.c
1
1
/*****************************************************************************
2
2
 
3
 
Copyright (C) 1996, 2010, Innobase Oy. All Rights Reserved.
4
 
Copyright (C) 2008, Google Inc.
5
 
Copyright (C) 2009, Percona Inc.
 
3
Copyright (c) 1996, 2009, Innobase Oy. All Rights Reserved.
 
4
Copyright (c) 2008, Google Inc.
6
5
 
7
6
Portions of this file contain modifications contributed and copyrighted by
8
7
Google, Inc. Those modifications are gratefully acknowledged and are described
10
9
incorporated with their permission, and subject to the conditions contained in
11
10
the file COPYING.Google.
12
11
 
13
 
Portions of this file contain modifications contributed and copyrighted
14
 
by Percona Inc.. Those modifications are
15
 
gratefully acknowledged and are described briefly in the InnoDB
16
 
documentation. The contributions by Percona Inc. are incorporated with
17
 
their permission, and subject to the conditions contained in the file
18
 
COPYING.Percona.
19
 
 
20
12
This program is free software; you can redistribute it and/or modify it under
21
13
the terms of the GNU General Public License as published by the Free Software
22
14
Foundation; version 2 of the License.
26
18
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
27
19
 
28
20
You should have received a copy of the GNU General Public License along with
29
 
this program; if not, write to the Free Software Foundation, Inc., 51 Franklin
30
 
St, Fifth Floor, Boston, MA 02110-1301 USA
 
21
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
 
22
Place, Suite 330, Boston, MA 02111-1307 USA
31
23
 
32
24
*****************************************************************************/
33
25
 
34
 
/********************************************************************//**
35
 
@file srv/srv0start.c
 
26
/************************************************************************
36
27
Starts the InnoDB database server
37
28
 
38
29
Created 2/16/1996 Heikki Tuuri
39
30
*************************************************************************/
40
31
 
 
32
#include "os0proc.h"
 
33
#include "sync0sync.h"
41
34
#include "ut0mem.h"
42
35
#include "mem0mem.h"
43
36
#include "data0data.h"
44
37
#include "data0type.h"
45
38
#include "dict0dict.h"
46
39
#include "buf0buf.h"
 
40
#include "buf0flu.h"
 
41
#include "buf0rea.h"
47
42
#include "os0file.h"
48
43
#include "os0thread.h"
49
44
#include "fil0fil.h"
50
45
#include "fsp0fsp.h"
51
46
#include "rem0rec.h"
 
47
#include "rem0cmp.h"
52
48
#include "mtr0mtr.h"
53
49
#include "log0log.h"
54
50
#include "log0recv.h"
55
51
#include "page0page.h"
56
52
#include "page0cur.h"
57
53
#include "trx0trx.h"
 
54
#include "dict0boot.h"
 
55
#include "dict0load.h"
58
56
#include "trx0sys.h"
 
57
#include "dict0crea.h"
59
58
#include "btr0btr.h"
 
59
#include "btr0pcur.h"
60
60
#include "btr0cur.h"
 
61
#include "btr0sea.h"
61
62
#include "rem0rec.h"
 
63
#include "srv0srv.h"
 
64
#include "que0que.h"
 
65
#include "usr0sess.h"
 
66
#include "lock0lock.h"
 
67
#include "trx0roll.h"
 
68
#include "trx0purge.h"
 
69
#include "row0ins.h"
 
70
#include "row0sel.h"
 
71
#include "row0upd.h"
 
72
#include "row0row.h"
 
73
#include "row0mysql.h"
 
74
#include "lock0lock.h"
62
75
#include "ibuf0ibuf.h"
 
76
#include "pars0pars.h"
 
77
#include "btr0sea.h"
63
78
#include "srv0start.h"
64
 
#include "srv0srv.h"
65
 
#ifndef UNIV_HOTBACKUP
66
 
# include "os0proc.h"
67
 
# include "sync0sync.h"
68
 
# include "buf0flu.h"
69
 
# include "buf0rea.h"
70
 
# include "dict0boot.h"
71
 
# include "dict0load.h"
72
 
# include "que0que.h"
73
 
# include "usr0sess.h"
74
 
# include "lock0lock.h"
75
 
# include "trx0roll.h"
76
 
# include "trx0purge.h"
77
 
# include "lock0lock.h"
78
 
# include "pars0pars.h"
79
 
# include "btr0sea.h"
80
 
# include "rem0cmp.h"
81
 
# include "dict0crea.h"
82
 
# include "row0ins.h"
83
 
# include "row0sel.h"
84
 
# include "row0upd.h"
85
 
# include "row0row.h"
86
 
# include "row0mysql.h"
87
 
# include "btr0pcur.h"
88
 
# include "thr0loc.h"
89
 
# include "os0sync.h" /* for INNODB_RW_LOCKS_USE_ATOMICS */
90
 
# include "zlib.h" /* for ZLIB_VERSION */
91
 
 
92
 
#include <errno.h>
93
 
#include <unistd.h>
94
 
 
95
 
#include <drizzled/gettext.h> 
96
 
#include <drizzled/errmsg_print.h>
97
 
 
98
 
/** Log sequence number immediately after startup */
 
79
#include "que0que.h"
 
80
 
 
81
/* Log sequence number immediately after startup */
99
82
UNIV_INTERN ib_uint64_t srv_start_lsn;
100
 
/** Log sequence number at shutdown */
 
83
/* Log sequence number at shutdown */
101
84
UNIV_INTERN ib_uint64_t srv_shutdown_lsn;
102
85
 
103
86
#ifdef HAVE_DARWIN_THREADS
104
87
# include <sys/utsname.h>
105
 
/** TRUE if the F_FULLFSYNC option is available */
106
88
UNIV_INTERN ibool       srv_have_fullfsync = FALSE;
107
89
#endif
108
90
 
109
 
/** TRUE if a raw partition is in use */
110
91
UNIV_INTERN ibool       srv_start_raw_disk_in_use = FALSE;
111
92
 
112
 
/** TRUE if the server is being started, before rolling back any
113
 
incomplete transactions */
114
93
UNIV_INTERN ibool       srv_startup_is_before_trx_rollback_phase = FALSE;
115
 
/** TRUE if the server is being started */
116
94
UNIV_INTERN ibool       srv_is_being_started = FALSE;
117
 
/** TRUE if the server was successfully started */
118
95
UNIV_INTERN ibool       srv_was_started = FALSE;
119
 
/** TRUE if innobase_start_or_create_for_mysql() has been called */
 
96
#ifndef UNIV_HOTBACKUP
120
97
static ibool    srv_start_has_been_called = FALSE;
121
 
 
122
 
/** At a shutdown this value climbs from SRV_SHUTDOWN_NONE to
123
 
SRV_SHUTDOWN_CLEANUP and then to SRV_SHUTDOWN_LAST_PHASE, and so on */
124
 
UNIV_INTERN enum srv_shutdown_state     srv_shutdown_state = SRV_SHUTDOWN_NONE;
125
 
 
126
 
/** Files comprising the system tablespace */
 
98
#endif /* !UNIV_HOTBACKUP */
 
99
 
 
100
/* At a shutdown the value first climbs to SRV_SHUTDOWN_CLEANUP
 
101
and then to SRV_SHUTDOWN_LAST_PHASE */
 
102
UNIV_INTERN ulint               srv_shutdown_state = 0;
 
103
 
 
104
#ifndef UNIV_HOTBACKUP
127
105
static os_file_t        files[1000];
128
106
 
129
 
/** io_handler_thread parameters for thread identification */
130
 
static ulint            n[SRV_MAX_N_IO_THREADS + 6];
131
 
/** io_handler_thread identifiers */
132
 
static os_thread_id_t   thread_ids[SRV_MAX_N_IO_THREADS + 6];
133
 
 
134
 
/** We use this mutex to test the return value of pthread_mutex_trylock
 
107
static mutex_t          ios_mutex;
 
108
static ulint            ios;
 
109
 
 
110
static ulint            n[SRV_MAX_N_IO_THREADS + 5];
 
111
static os_thread_id_t   thread_ids[SRV_MAX_N_IO_THREADS + 5];
 
112
 
 
113
/* We use this mutex to test the return value of pthread_mutex_trylock
135
114
   on successful locking. HP-UX does NOT return 0, though Linux et al do. */
136
115
static os_fast_mutex_t  srv_os_test_mutex;
137
116
 
138
 
/** Name of srv_monitor_file */
 
117
/* Name of srv_monitor_file */
139
118
static char*    srv_monitor_file_name;
140
119
#endif /* !UNIV_HOTBACKUP */
141
120
 
142
 
/** */
143
121
#define SRV_N_PENDING_IOS_PER_THREAD    OS_AIO_N_PENDING_IOS_PER_THREAD
144
122
#define SRV_MAX_N_PENDING_SYNC_IOS      100
145
123
 
146
 
#ifdef UNIV_PFS_THREAD
147
 
/* Keys to register InnoDB threads with performance schema */
148
 
UNIV_INTERN mysql_pfs_key_t     io_handler_thread_key;
149
 
UNIV_INTERN mysql_pfs_key_t     srv_lock_timeout_thread_key;
150
 
UNIV_INTERN mysql_pfs_key_t     srv_error_monitor_thread_key;
151
 
UNIV_INTERN mysql_pfs_key_t     srv_monitor_thread_key;
152
 
UNIV_INTERN mysql_pfs_key_t     srv_master_thread_key;
153
 
#endif /* UNIV_PFS_THREAD */
154
124
 
155
 
/*********************************************************************//**
156
 
Convert a numeric string that optionally ends in G or M, to a number
157
 
containing megabytes.
158
 
@return next character in string */
159
125
static
160
126
char*
161
127
srv_parse_megabytes(
162
128
/*================*/
163
 
        char*   str,    /*!< in: string containing a quantity in bytes */
164
 
        ulint*  megs)   /*!< out: the number in megabytes */
 
129
                        /* out: next character in string */
 
130
        char*   str,    /* in: string containing a quantity in bytes */
 
131
        ulint*  megs)   /* out: the number in megabytes */
165
132
{
166
133
        char*   endp;
167
134
        ulint   size;
186
153
        return(str);
187
154
}
188
155
 
189
 
/*********************************************************************//**
 
156
/*************************************************************************
190
157
Reads the data files and their sizes from a character string given in
191
 
the .cnf file.
192
 
@return TRUE if ok, FALSE on parse error */
 
158
the .cnf file. */
193
159
UNIV_INTERN
194
160
ibool
195
161
srv_parse_data_file_paths_and_sizes(
196
162
/*================================*/
197
 
        char*   str)    /*!< in/out: the data file path string */
 
163
                        /* out: TRUE if ok, FALSE on parse error */
 
164
        char*   str)    /* in/out: the data file path string */
198
165
{
199
166
        char*   input_str;
200
167
        char*   path;
282
249
                return(FALSE);
283
250
        }
284
251
 
285
 
        srv_data_file_names = static_cast<char **>(malloc(i * sizeof *srv_data_file_names));
286
 
        srv_data_file_sizes = static_cast<ulint *>(malloc(i * sizeof *srv_data_file_sizes));
287
 
        srv_data_file_is_raw_partition = static_cast<ulint *>(malloc(
288
 
                                                                     i * sizeof *srv_data_file_is_raw_partition));
 
252
        srv_data_file_names = malloc(i * sizeof *srv_data_file_names);
 
253
        srv_data_file_sizes = malloc(i * sizeof *srv_data_file_sizes);
 
254
        srv_data_file_is_raw_partition = malloc(
 
255
                i * sizeof *srv_data_file_is_raw_partition);
289
256
 
290
257
        srv_n_data_files = i;
291
258
 
370
337
        return(TRUE);
371
338
}
372
339
 
373
 
/*********************************************************************//**
 
340
/*************************************************************************
374
341
Reads log group home directories from a character string given in
375
 
the .cnf file.
376
 
@return TRUE if ok, FALSE on parse error */
 
342
the .cnf file. */
377
343
UNIV_INTERN
378
344
ibool
379
345
srv_parse_log_group_home_dirs(
380
346
/*==========================*/
381
 
        char*   str)    /*!< in/out: character string */
 
347
                        /* out: TRUE if ok, FALSE on parse error */
 
348
        char*   str)    /* in/out: character string */
382
349
{
383
350
        char*   input_str;
384
351
        char*   path;
415
382
                return(FALSE);
416
383
        }
417
384
 
418
 
        srv_log_group_home_dirs = static_cast<char **>(malloc(i * sizeof *srv_log_group_home_dirs));
 
385
        srv_log_group_home_dirs = malloc(i * sizeof *srv_log_group_home_dirs);
419
386
 
420
387
        /* Then store the actual values to our array */
421
388
 
442
409
        return(TRUE);
443
410
}
444
411
 
445
 
/*********************************************************************//**
 
412
/*************************************************************************
446
413
Frees the memory allocated by srv_parse_data_file_paths_and_sizes()
447
414
and srv_parse_log_group_home_dirs(). */
448
415
UNIV_INTERN
461
428
}
462
429
 
463
430
#ifndef UNIV_HOTBACKUP
464
 
/********************************************************************//**
465
 
I/o-handler thread function.
466
 
@return OS_THREAD_DUMMY_RETURN */
467
 
extern "C"
468
 
os_thread_ret_t
469
 
io_handler_thread(void* arg);
 
431
/************************************************************************
 
432
I/o-handler thread function. */
 
433
static
470
434
 
471
 
extern "C"
472
435
os_thread_ret_t
473
436
io_handler_thread(
474
437
/*==============*/
475
 
        void*   arg)    /*!< in: pointer to the number of the segment in
476
 
                        the aio array */
 
438
        void*   arg)
477
439
{
478
440
        ulint   segment;
 
441
        ulint   i;
479
442
 
480
443
        segment = *((ulint*)arg);
481
444
 
483
446
        fprintf(stderr, "Io handler thread %lu starts, id %lu\n", segment,
484
447
                os_thread_pf(os_thread_get_curr_id()));
485
448
#endif
486
 
 
487
 
#ifdef UNIV_PFS_THREAD
488
 
        pfs_register_thread(io_handler_thread_key);
489
 
#endif /* UNIV_PFS_THREAD */
490
 
 
491
 
        while (srv_shutdown_state != SRV_SHUTDOWN_EXIT_THREADS) {
 
449
        for (i = 0;; i++) {
492
450
                fil_aio_wait(segment);
 
451
 
 
452
                mutex_enter(&ios_mutex);
 
453
                ios++;
 
454
                mutex_exit(&ios_mutex);
493
455
        }
494
456
 
495
457
        /* We count the number of threads in os_thread_exit(). A created
496
458
        thread should always use that to exit and not use return() to exit.
497
459
        The thread actually never comes here because it is exited in an
498
460
        os_event_wait(). */
 
461
#ifndef UNIV_SOLARIS
499
462
        return 0;
 
463
#endif
500
464
}
501
465
#endif /* !UNIV_HOTBACKUP */
502
466
 
506
470
#define SRV_PATH_SEPARATOR      '/'
507
471
#endif
508
472
 
509
 
/*********************************************************************//**
 
473
/*************************************************************************
510
474
Normalizes a directory path for Windows: converts slashes to backslashes. */
511
475
UNIV_INTERN
512
476
void
513
477
srv_normalize_path_for_win(
514
478
/*=======================*/
515
 
        char*   /*str __attribute__((unused))*/)        /*!< in/out: null-terminated
 
479
        char*   str __attribute__((unused)))    /* in/out: null-terminated
516
480
                                                character string */
517
481
{
518
482
#ifdef __WIN__
525
489
#endif
526
490
}
527
491
 
 
492
/*************************************************************************
 
493
Adds a slash or a backslash to the end of a string if it is missing
 
494
and the string is not empty. */
 
495
UNIV_INTERN
 
496
char*
 
497
srv_add_path_separator_if_needed(
 
498
/*=============================*/
 
499
                        /* out: string which has the separator if the
 
500
                        string is not empty */
 
501
        char*   str)    /* in: null-terminated character string */
 
502
{
 
503
        char*   out_str;
 
504
        ulint   len     = ut_strlen(str);
 
505
 
 
506
        if (len == 0 || str[len - 1] == SRV_PATH_SEPARATOR) {
 
507
 
 
508
                return(str);
 
509
        }
 
510
 
 
511
        out_str = ut_malloc(len + 2);
 
512
        memcpy(out_str, str, len);
 
513
        out_str[len] = SRV_PATH_SEPARATOR;
 
514
        out_str[len + 1] = 0;
 
515
 
 
516
        return(out_str);
 
517
}
 
518
 
528
519
#ifndef UNIV_HOTBACKUP
529
 
/*********************************************************************//**
 
520
/*************************************************************************
530
521
Calculates the low 32 bits when a file size which is given as a number
531
 
database pages is converted to the number of bytes.
532
 
@return low 32 bytes of file size when expressed in bytes */
 
522
database pages is converted to the number of bytes. */
533
523
static
534
524
ulint
535
525
srv_calc_low32(
536
526
/*===========*/
537
 
        ulint   file_size)      /*!< in: file size in database pages */
 
527
                                /* out: low 32 bytes of file size when
 
528
                                expressed in bytes */
 
529
        ulint   file_size)      /* in: file size in database pages */
538
530
{
539
531
        return(0xFFFFFFFFUL & (file_size << UNIV_PAGE_SIZE_SHIFT));
540
532
}
541
533
 
542
 
/*********************************************************************//**
 
534
/*************************************************************************
543
535
Calculates the high 32 bits when a file size which is given as a number
544
 
database pages is converted to the number of bytes.
545
 
@return high 32 bytes of file size when expressed in bytes */
 
536
database pages is converted to the number of bytes. */
546
537
static
547
538
ulint
548
539
srv_calc_high32(
549
540
/*============*/
550
 
        ulint   file_size)      /*!< in: file size in database pages */
 
541
                                /* out: high 32 bytes of file size when
 
542
                                expressed in bytes */
 
543
        ulint   file_size)      /* in: file size in database pages */
551
544
{
552
545
        return(file_size >> (32 - UNIV_PAGE_SIZE_SHIFT));
553
546
}
554
547
 
555
 
/*********************************************************************//**
556
 
Creates or opens the log files and closes them.
557
 
@return DB_SUCCESS or error code */
 
548
/*************************************************************************
 
549
Creates or opens the log files and closes them. */
558
550
static
559
551
ulint
560
552
open_or_create_log_file(
561
553
/*====================*/
562
 
        ibool   create_new_db,          /*!< in: TRUE if we should create a
 
554
                                        /* out: DB_SUCCESS or error code */
 
555
        ibool   create_new_db,          /* in: TRUE if we should create a
563
556
                                        new database */
564
 
        ibool*  log_file_created,       /*!< out: TRUE if new log file
 
557
        ibool*  log_file_created,       /* out: TRUE if new log file
565
558
                                        created */
566
 
        ibool   log_file_has_been_opened,/*!< in: TRUE if a log file has been
 
559
        ibool   log_file_has_been_opened,/* in: TRUE if a log file has been
567
560
                                        opened before: then it is an error
568
561
                                        to try to create another log file */
569
 
        ulint   k,                      /*!< in: log group number */
570
 
        ulint   i)                      /*!< in: log file number in group */
 
562
        ulint   k,                      /* in: log group number */
 
563
        ulint   i)                      /* in: log file number in group */
571
564
{
572
565
        ibool   ret;
573
566
        ulint   size;
574
567
        ulint   size_high;
575
568
        char    name[10000];
576
 
        ulint   dirnamelen;
577
569
 
578
570
        UT_NOT_USED(create_new_db);
579
571
 
580
572
        *log_file_created = FALSE;
581
573
 
582
574
        srv_normalize_path_for_win(srv_log_group_home_dirs[k]);
583
 
 
584
 
        dirnamelen = strlen(srv_log_group_home_dirs[k]);
585
 
        ut_a(dirnamelen < (sizeof name) - 10 - sizeof "ib_logfile");
586
 
        memcpy(name, srv_log_group_home_dirs[k], dirnamelen);
587
 
 
588
 
        /* Add a path separator if needed. */
589
 
        if (dirnamelen && name[dirnamelen - 1] != SRV_PATH_SEPARATOR) {
590
 
                name[dirnamelen++] = SRV_PATH_SEPARATOR;
591
 
        }
592
 
 
593
 
        sprintf(name + dirnamelen, "%s%lu", "ib_logfile", (ulong) i);
594
 
 
595
 
        files[i] = os_file_create(innodb_file_log_key, name,
596
 
                                  OS_FILE_CREATE, OS_FILE_NORMAL,
 
575
        srv_log_group_home_dirs[k] = srv_add_path_separator_if_needed(
 
576
                srv_log_group_home_dirs[k]);
 
577
 
 
578
        ut_a(strlen(srv_log_group_home_dirs[k])
 
579
             < (sizeof name) - 10 - sizeof "ib_logfile");
 
580
        sprintf(name, "%s%s%lu", srv_log_group_home_dirs[k],
 
581
                "ib_logfile", (ulong) i);
 
582
 
 
583
        files[i] = os_file_create(name, OS_FILE_CREATE, OS_FILE_NORMAL,
597
584
                                  OS_LOG_FILE, &ret);
598
585
        if (ret == FALSE) {
599
586
                if (os_file_get_last_error(FALSE) != OS_FILE_ALREADY_EXISTS
604
591
                    && os_file_get_last_error(FALSE) != 100
605
592
#endif
606
593
                    ) {
607
 
                  drizzled::errmsg_printf(drizzled::error::ERROR,
608
 
                                          "InnoDB: Error in creating or opening %s", name);
 
594
                        fprintf(stderr,
 
595
                                "InnoDB: Error in creating"
 
596
                                " or opening %s\n", name);
609
597
 
610
 
                  return(DB_ERROR);
 
598
                        return(DB_ERROR);
611
599
                }
612
600
 
613
 
                files[i] = os_file_create(innodb_file_log_key, name,
614
 
                                          OS_FILE_OPEN, OS_FILE_AIO,
 
601
                files[i] = os_file_create(name, OS_FILE_OPEN, OS_FILE_AIO,
615
602
                                          OS_LOG_FILE, &ret);
616
603
                if (!ret) {
617
 
                  drizzled::errmsg_printf(drizzled::error::ERROR,
618
 
                                          "InnoDB: Error in opening %s.", name);
 
604
                        fprintf(stderr,
 
605
                                "InnoDB: Error in opening %s\n", name);
619
606
 
620
607
                        return(DB_ERROR);
621
608
                }
626
613
                if (size != srv_calc_low32(srv_log_file_size)
627
614
                    || size_high != srv_calc_high32(srv_log_file_size)) {
628
615
 
629
 
                  drizzled::errmsg_printf(drizzled::error::ERROR,
630
 
                                          "InnoDB: Error: log file %s is of different size %lu %lu bytes than specified in the .cnf"
631
 
                                          " file %lu %lu bytes!",
632
 
                                          name, (ulong) size_high, (ulong) size,
633
 
                                          (ulong) srv_calc_high32(srv_log_file_size),
634
 
                                          (ulong) srv_calc_low32(srv_log_file_size));
 
616
                        fprintf(stderr,
 
617
                                "InnoDB: Error: log file %s is"
 
618
                                " of different size %lu %lu bytes\n"
 
619
                                "InnoDB: than specified in the .cnf"
 
620
                                " file %lu %lu bytes!\n",
 
621
                                name, (ulong) size_high, (ulong) size,
 
622
                                (ulong) srv_calc_high32(srv_log_file_size),
 
623
                                (ulong) srv_calc_low32(srv_log_file_size));
635
624
 
636
625
                        return(DB_ERROR);
637
626
                }
638
627
        } else {
639
628
                *log_file_created = TRUE;
640
629
 
641
 
                drizzled::errmsg_printf(drizzled::error::INFO,
642
 
                                        "InnoDB: Log file %s did not exist: new to be created",
643
 
                                        name);
 
630
                ut_print_timestamp(stderr);
 
631
 
 
632
                fprintf(stderr,
 
633
                        "  InnoDB: Log file %s did not exist:"
 
634
                        " new to be created\n",
 
635
                        name);
644
636
                if (log_file_has_been_opened) {
645
637
 
646
638
                        return(DB_ERROR);
647
639
                }
648
640
 
649
 
                drizzled::errmsg_printf(drizzled::error::INFO,
650
 
                                        "InnoDB: Setting log file %s size to %lu MB",
651
 
                                        name, (ulong) srv_log_file_size
652
 
                                        >> (20 - UNIV_PAGE_SIZE_SHIFT));
 
641
                fprintf(stderr, "InnoDB: Setting log file %s size to %lu MB\n",
 
642
                        name, (ulong) srv_log_file_size
 
643
                        >> (20 - UNIV_PAGE_SIZE_SHIFT));
653
644
 
654
 
                drizzled::errmsg_printf(drizzled::error::INFO,
655
 
                                        "InnoDB: Database physically writes the file full: wait...\n");
 
645
                fprintf(stderr,
 
646
                        "InnoDB: Database physically writes the file"
 
647
                        " full: wait...\n");
656
648
 
657
649
                ret = os_file_set_size(name, files[i],
658
650
                                       srv_calc_low32(srv_log_file_size),
659
651
                                       srv_calc_high32(srv_log_file_size));
660
652
                if (!ret) {
661
 
                  drizzled::errmsg_printf(drizzled::error::ERROR,
662
 
                                          "InnoDB: Error in creating %s: probably out of disk space",
663
 
                                          name);
 
653
                        fprintf(stderr,
 
654
                                "InnoDB: Error in creating %s:"
 
655
                                " probably out of disk space\n",
 
656
                                name);
664
657
 
665
658
                        return(DB_ERROR);
666
659
                }
705
698
        return(DB_SUCCESS);
706
699
}
707
700
 
708
 
/*********************************************************************//**
709
 
Creates or opens database data files and closes them.
710
 
@return DB_SUCCESS or error code */
 
701
/*************************************************************************
 
702
Creates or opens database data files and closes them. */
711
703
static
712
704
ulint
713
705
open_or_create_data_files(
714
706
/*======================*/
715
 
        ibool*          create_new_db,  /*!< out: TRUE if new database should be
 
707
                                        /* out: DB_SUCCESS or error code */
 
708
        ibool*          create_new_db,  /* out: TRUE if new database should be
716
709
                                        created */
717
710
#ifdef UNIV_LOG_ARCHIVE
718
 
        ulint*          min_arch_log_no,/*!< out: min of archived log
 
711
        ulint*          min_arch_log_no,/* out: min of archived log
719
712
                                        numbers in data files */
720
 
        ulint*          max_arch_log_no,/*!< out: max of archived log
 
713
        ulint*          max_arch_log_no,/* out: max of archived log
721
714
                                        numbers in data files */
722
715
#endif /* UNIV_LOG_ARCHIVE */
723
 
        ib_uint64_t*    min_flushed_lsn,/*!< out: min of flushed lsn
724
 
                                        values in data files */
725
 
        ib_uint64_t*    max_flushed_lsn,/*!< out: max of flushed lsn
726
 
                                        values in data files */
727
 
        ulint*          sum_of_new_sizes)/*!< out: sum of sizes of the
 
716
        ib_uint64_t*    min_flushed_lsn,/* out: min of flushed lsn
 
717
                                        values in data files */
 
718
        ib_uint64_t*    max_flushed_lsn,/* out: max of flushed lsn
 
719
                                        values in data files */
 
720
        ulint*          sum_of_new_sizes)/* out: sum of sizes of the
728
721
                                        new files added */
729
722
{
730
723
        ibool   ret;
737
730
        char    name[10000];
738
731
 
739
732
        if (srv_n_data_files >= 1000) {
740
 
          drizzled::errmsg_printf(drizzled::error::ERROR,
741
 
                                  "InnoDB: can only have < 1000 data files you have defined %lu",
742
 
                                  (ulong) srv_n_data_files);
 
733
                fprintf(stderr, "InnoDB: can only have < 1000 data files\n"
 
734
                        "InnoDB: you have defined %lu\n",
 
735
                        (ulong) srv_n_data_files);
743
736
                return(DB_ERROR);
744
737
        }
745
738
 
748
741
        *create_new_db = FALSE;
749
742
 
750
743
        srv_normalize_path_for_win(srv_data_home);
 
744
        srv_data_home = srv_add_path_separator_if_needed(srv_data_home);
751
745
 
752
746
        for (i = 0; i < srv_n_data_files; i++) {
753
 
                ulint   dirnamelen;
754
 
 
755
747
                srv_normalize_path_for_win(srv_data_file_names[i]);
756
 
                dirnamelen = strlen(srv_data_home);
757
748
 
758
 
                ut_a(dirnamelen + strlen(srv_data_file_names[i])
 
749
                ut_a(strlen(srv_data_home) + strlen(srv_data_file_names[i])
759
750
                     < (sizeof name) - 1);
760
 
                memcpy(name, srv_data_home, dirnamelen);
761
 
                /* Add a path separator if needed. */
762
 
                if (dirnamelen && name[dirnamelen - 1] != SRV_PATH_SEPARATOR) {
763
 
                        name[dirnamelen++] = SRV_PATH_SEPARATOR;
764
 
                }
765
 
 
766
 
                strcpy(name + dirnamelen, srv_data_file_names[i]);
 
751
                sprintf(name, "%s%s", srv_data_home, srv_data_file_names[i]);
767
752
 
768
753
                if (srv_data_file_is_raw_partition[i] == 0) {
769
754
 
770
755
                        /* First we try to create the file: if it already
771
756
                        exists, ret will get value FALSE */
772
757
 
773
 
                        files[i] = os_file_create(innodb_file_data_key,
774
 
                                                  name, OS_FILE_CREATE,
 
758
                        files[i] = os_file_create(name, OS_FILE_CREATE,
775
759
                                                  OS_FILE_NORMAL,
776
760
                                                  OS_DATA_FILE, &ret);
777
761
 
784
768
                            && os_file_get_last_error(FALSE) != 100
785
769
#endif
786
770
                            ) {
787
 
                          drizzled::errmsg_printf(drizzled::error::ERROR,
788
 
                                                  "InnoDB: Error in creating or opening %s",
789
 
                                                  name);
 
771
                                fprintf(stderr,
 
772
                                        "InnoDB: Error in creating"
 
773
                                        " or opening %s\n",
 
774
                                        name);
790
775
 
791
776
                                return(DB_ERROR);
792
777
                        }
797
782
                        srv_start_raw_disk_in_use = TRUE;
798
783
                        srv_created_new_raw = TRUE;
799
784
 
800
 
                        files[i] = os_file_create(innodb_file_data_key,
801
 
                                                  name, OS_FILE_OPEN_RAW,
 
785
                        files[i] = os_file_create(name, OS_FILE_OPEN_RAW,
802
786
                                                  OS_FILE_NORMAL,
803
787
                                                  OS_DATA_FILE, &ret);
804
788
                        if (!ret) {
805
 
                          drizzled::errmsg_printf(drizzled::error::ERROR,
806
 
                                                  "InnoDB: Error in opening %s", name);
 
789
                                fprintf(stderr,
 
790
                                        "InnoDB: Error in opening %s\n", name);
807
791
 
808
792
                                return(DB_ERROR);
809
793
                        }
819
803
                        /* We open the data file */
820
804
 
821
805
                        if (one_created) {
822
 
                          drizzled::errmsg_printf(drizzled::error::ERROR,
823
 
                                        "InnoDB: Error: data files can only be added at the end of a tablespace, but"
824
 
                                        " data file %s existed beforehand.",
825
 
                                        name);
 
806
                                fprintf(stderr,
 
807
                                        "InnoDB: Error: data files can only"
 
808
                                        " be added at the end\n");
 
809
                                fprintf(stderr,
 
810
                                        "InnoDB: of a tablespace, but"
 
811
                                        " data file %s existed beforehand.\n",
 
812
                                        name);
826
813
                                return(DB_ERROR);
827
814
                        }
828
815
 
829
816
                        if (srv_data_file_is_raw_partition[i] == SRV_OLD_RAW) {
830
817
                                files[i] = os_file_create(
831
 
                                        innodb_file_data_key,
832
818
                                        name, OS_FILE_OPEN_RAW,
833
819
                                        OS_FILE_NORMAL, OS_DATA_FILE, &ret);
834
820
                        } else if (i == 0) {
835
821
                                files[i] = os_file_create(
836
 
                                        innodb_file_data_key,
837
822
                                        name, OS_FILE_OPEN_RETRY,
838
823
                                        OS_FILE_NORMAL, OS_DATA_FILE, &ret);
839
824
                        } else {
840
825
                                files[i] = os_file_create(
841
 
                                        innodb_file_data_key,
842
826
                                        name, OS_FILE_OPEN, OS_FILE_NORMAL,
843
827
                                        OS_DATA_FILE, &ret);
844
828
                        }
845
829
 
846
830
                        if (!ret) {
847
 
                          drizzled::errmsg_printf(drizzled::error::ERROR,
848
 
                                                  "InnoDB: Error in opening %s", name);
 
831
                                fprintf(stderr,
 
832
                                        "InnoDB: Error in opening %s\n", name);
849
833
                                os_file_get_last_error(TRUE);
850
834
 
851
835
                                return(DB_ERROR);
872
856
                                        && srv_last_file_size_max
873
857
                                        < rounded_size_pages)) {
874
858
 
875
 
                                  drizzled::errmsg_printf(drizzled::error::ERROR,
876
 
                                                          "InnoDB: Error: auto-extending data file %s is of a different size. "
877
 
                                                          "%lu pages (rounded down to MB) than specified in the .cnf file: "
878
 
                                                          "initial %lu pages, max %lu (relevant if non-zero) pages!",
879
 
                                                          name,
880
 
                                                          (ulong) rounded_size_pages,
881
 
                                                          (ulong) srv_data_file_sizes[i],
882
 
                                                          (ulong)
883
 
                                                          srv_last_file_size_max);
 
859
                                        fprintf(stderr,
 
860
                                                "InnoDB: Error: auto-extending"
 
861
                                                " data file %s is"
 
862
                                                " of a different size\n"
 
863
                                                "InnoDB: %lu pages (rounded"
 
864
                                                " down to MB) than specified"
 
865
                                                " in the .cnf file:\n"
 
866
                                                "InnoDB: initial %lu pages,"
 
867
                                                " max %lu (relevant if"
 
868
                                                " non-zero) pages!\n",
 
869
                                                name,
 
870
                                                (ulong) rounded_size_pages,
 
871
                                                (ulong) srv_data_file_sizes[i],
 
872
                                                (ulong)
 
873
                                                srv_last_file_size_max);
884
874
 
885
875
                                        return(DB_ERROR);
886
876
                                }
890
880
 
891
881
                        if (rounded_size_pages != srv_data_file_sizes[i]) {
892
882
 
893
 
                          drizzled::errmsg_printf(drizzled::error::ERROR,
894
 
                                        "InnoDB: Error: data file %s is of a different size. "
895
 
                                        "%lu pages (rounded down to MB). "
896
 
                                        "Than specified in the .cnf file %lu pages!",
 
883
                                fprintf(stderr,
 
884
                                        "InnoDB: Error: data file %s"
 
885
                                        " is of a different size\n"
 
886
                                        "InnoDB: %lu pages"
 
887
                                        " (rounded down to MB)\n"
 
888
                                        "InnoDB: than specified"
 
889
                                        " in the .cnf file %lu pages!\n",
897
890
                                        name,
898
891
                                        (ulong) rounded_size_pages,
899
892
                                        (ulong) srv_data_file_sizes[i]);
915
908
                        one_created = TRUE;
916
909
 
917
910
                        if (i > 0) {
918
 
                                drizzled::errmsg_printf(drizzled::error::INFO,
919
 
                                        "  InnoDB: Data file %s did not exist: new to be created",
 
911
                                ut_print_timestamp(stderr);
 
912
                                fprintf(stderr,
 
913
                                        "  InnoDB: Data file %s did not"
 
914
                                        " exist: new to be created\n",
920
915
                                        name);
921
916
                        } else {
922
 
                          drizzled::errmsg_printf(drizzled::error::INFO,
923
 
                                        "InnoDB: The first specified data file %s did not exist. A new database to be created!", name);
 
917
                                fprintf(stderr,
 
918
                                        "InnoDB: The first specified"
 
919
                                        " data file %s did not exist:\n"
 
920
                                        "InnoDB: a new database"
 
921
                                        " to be created!\n", name);
924
922
                                *create_new_db = TRUE;
925
923
                        }
926
924
 
927
 
                        drizzled::errmsg_printf(drizzled::error::INFO,
928
 
                                                "  InnoDB: Setting file %s size to %lu MB",
929
 
                                                name, (ulong) (srv_data_file_sizes[i]
930
 
                                                         >> (20 - UNIV_PAGE_SIZE_SHIFT)));
 
925
                        ut_print_timestamp(stderr);
 
926
                        fprintf(stderr,
 
927
                                "  InnoDB: Setting file %s size to %lu MB\n",
 
928
                                name,
 
929
                                (ulong) (srv_data_file_sizes[i]
 
930
                                         >> (20 - UNIV_PAGE_SIZE_SHIFT)));
931
931
 
932
 
                        drizzled::errmsg_printf(drizzled::error::INFO,
933
 
                                "InnoDB: Database physically writes the file full: wait...");
 
932
                        fprintf(stderr,
 
933
                                "InnoDB: Database physically writes the"
 
934
                                " file full: wait...\n");
934
935
 
935
936
                        ret = os_file_set_size(
936
937
                                name, files[i],
938
939
                                srv_calc_high32(srv_data_file_sizes[i]));
939
940
 
940
941
                        if (!ret) {
941
 
                          drizzled::errmsg_printf(drizzled::error::ERROR,
942
 
                                                  "InnoDB: Error in creating %s: probably out of disk space", name);
 
942
                                fprintf(stderr,
 
943
                                        "InnoDB: Error in creating %s:"
 
944
                                        " probably out of disk space\n", name);
943
945
 
944
946
                                return(DB_ERROR);
945
947
                        }
961
963
                                srv_data_file_is_raw_partition[i] != 0);
962
964
        }
963
965
 
 
966
        ios = 0;
 
967
 
 
968
        mutex_create(&ios_mutex, SYNC_NO_ORDER_CHECK);
 
969
 
964
970
        return(DB_SUCCESS);
965
971
}
966
972
 
967
973
/********************************************************************
968
974
Starts InnoDB and creates a new database if database files
969
 
are not found and the user wants.
970
 
@return DB_SUCCESS or error code */
 
975
are not found and the user wants. */
971
976
UNIV_INTERN
972
977
int
973
978
innobase_start_or_create_for_mysql(void)
974
979
/*====================================*/
 
980
                                /* out: DB_SUCCESS or error code */
975
981
{
 
982
        buf_pool_t*     ret;
976
983
        ibool           create_new_db;
977
984
        ibool           log_file_created;
978
985
        ibool           log_created     = FALSE;
988
995
        ulint           tablespace_size_in_header;
989
996
        ulint           err;
990
997
        ulint           i;
991
 
        ulint           io_limit;
992
998
        my_bool         srv_file_per_table_original_value
993
999
                = srv_file_per_table;
994
1000
        mtr_t           mtr;
1003
1009
        on Mac OS X 10.3 or later. */
1004
1010
        struct utsname utsname;
1005
1011
        if (uname(&utsname)) {
1006
 
                fputs(_("InnoDB: cannot determine Mac OS X version!\n"), stderr);
 
1012
                fputs("InnoDB: cannot determine Mac OS X version!\n", stderr);
1007
1013
        } else {
1008
1014
                srv_have_fullfsync = strcmp(utsname.release, "7.") >= 0;
1009
1015
        }
1010
1016
        if (!srv_have_fullfsync) {
1011
 
                fputs(_("InnoDB: On Mac OS X, fsync() may be"
1012
 
                        " broken on internal drives,\n"
1013
 
                        "InnoDB: making transactions unsafe!\n"), stderr);
 
1017
                fputs("InnoDB: On Mac OS X, fsync() may be"
 
1018
                      " broken on internal drives,\n"
 
1019
                      "InnoDB: making transactions unsafe!\n", stderr);
1014
1020
        }
1015
1021
# endif /* F_FULLFSYNC */
1016
1022
#endif /* HAVE_DARWIN_THREADS */
1017
1023
 
1018
1024
        if (sizeof(ulint) != sizeof(void*)) {
1019
 
          drizzled::errmsg_printf(drizzled::error::WARN,
1020
 
                        _("InnoDB: Error: size of InnoDB's ulint is %lu, but size of void* is %lu. "
1021
 
                          "The sizes should be the same so that on a 64-bit platform you can. Allocate more than 4 GB of memory."),
 
1025
                fprintf(stderr,
 
1026
                        "InnoDB: Error: size of InnoDB's ulint is %lu,"
 
1027
                        " but size of void* is %lu.\n"
 
1028
                        "InnoDB: The sizes should be the same"
 
1029
                        " so that on a 64-bit platform you can\n"
 
1030
                        "InnoDB: allocate more than 4 GB of memory.",
1022
1031
                        (ulong)sizeof(ulint), (ulong)sizeof(void*));
1023
1032
        }
1024
1033
 
1028
1037
        innodb_file_per_table) until this function has returned. */
1029
1038
        srv_file_per_table = FALSE;
1030
1039
#ifdef UNIV_DEBUG
1031
 
        drizzled::errmsg_printf(drizzled::error::INFO,
1032
 
                                _("InnoDB: !!!!!!!! UNIV_DEBUG switched on !!!!!!!!!\n"));
 
1040
        fprintf(stderr,
 
1041
                "InnoDB: !!!!!!!! UNIV_DEBUG switched on !!!!!!!!!\n");
1033
1042
#endif
1034
1043
 
1035
1044
#ifdef UNIV_IBUF_DEBUG
1036
 
        drizzled::errmsg_printf(drizzled::error::INFO,
1037
 
                _("InnoDB: !!!!!!!! UNIV_IBUF_DEBUG switched on !!!!!!!!!\n"
1038
 
# ifdef UNIV_IBUF_COUNT_DEBUG
1039
 
                  "InnoDB: !!!!!!!! UNIV_IBUF_COUNT_DEBUG switched on !!!!!!!!!\n"
1040
 
                  "InnoDB: Crash recovery will fail with UNIV_IBUF_COUNT_DEBUG\n"
1041
 
# endif
1042
 
                ));
 
1045
        fprintf(stderr,
 
1046
                "InnoDB: !!!!!!!! UNIV_IBUF_DEBUG switched on !!!!!!!!!\n"
 
1047
                "InnoDB: Crash recovery will fail with UNIV_IBUF_DEBUG\n");
1043
1048
#endif
1044
1049
 
1045
1050
#ifdef UNIV_SYNC_DEBUG
1046
 
        drizzled::errmsg_printf(drizzled::error::INFO,
1047
 
                                _("InnoDB: !!!!!!!! UNIV_SYNC_DEBUG switched on !!!!!!!!!\n"));
 
1051
        fprintf(stderr,
 
1052
                "InnoDB: !!!!!!!! UNIV_SYNC_DEBUG switched on !!!!!!!!!\n");
1048
1053
#endif
1049
1054
 
1050
1055
#ifdef UNIV_SEARCH_DEBUG
1051
 
        drizzled::errmsg_printf(drizzled::error::INFO,
1052
 
                                _("InnoDB: !!!!!!!! UNIV_SEARCH_DEBUG switched on !!!!!!!!!\n"));
 
1056
        fprintf(stderr,
 
1057
                "InnoDB: !!!!!!!! UNIV_SEARCH_DEBUG switched on !!!!!!!!!\n");
1053
1058
#endif
1054
1059
 
1055
 
#ifdef UNIV_LOG_LSN_DEBUG
1056
 
        drizzled::errmsg_printf(drizzled::error::INFO,
1057
 
                                _("InnoDB: !!!!!!!! UNIV_LOG_LSN_DEBUG switched on !!!!!!!!!\n"));
1058
 
#endif /* UNIV_LOG_LSN_DEBUG */
1059
1060
#ifdef UNIV_MEM_DEBUG
1060
 
        drizzled::errmsg_printf(drizzled::error::INFO,
1061
 
                                _("InnoDB: !!!!!!!! UNIV_MEM_DEBUG switched on !!!!!!!!!\n"));
 
1061
        fprintf(stderr,
 
1062
                "InnoDB: !!!!!!!! UNIV_MEM_DEBUG switched on !!!!!!!!!\n");
1062
1063
#endif
1063
1064
 
1064
 
        if (UNIV_LIKELY(srv_use_sys_malloc))
1065
 
        {
1066
 
          drizzled::errmsg_printf(drizzled::error::ERROR, _("InnoDB: The InnoDB memory heap is disabled\n"));
 
1065
        if (UNIV_LIKELY(srv_use_sys_malloc)) {
 
1066
                fprintf(stderr,
 
1067
                        "InnoDB: The InnoDB memory heap is disabled\n");
1067
1068
        }
1068
1069
 
1069
 
        fputs("InnoDB: " IB_ATOMICS_STARTUP_MSG
1070
 
                "\nInnoDB: Compressed tables use zlib " ZLIB_VERSION
1071
 
#ifdef UNIV_ZIP_DEBUG
1072
 
              " with validation"
1073
 
#endif /* UNIV_ZIP_DEBUG */
1074
 
#ifdef UNIV_ZIP_COPY
1075
 
              " and extra copying"
1076
 
#endif /* UNIV_ZIP_COPY */
1077
 
              "\n" , stderr);
1078
 
 
 
1070
#ifdef HAVE_GCC_ATOMIC_BUILTINS
 
1071
#ifdef INNODB_RW_LOCKS_USE_ATOMICS
 
1072
        fprintf(stderr,
 
1073
                "InnoDB: Mutexes and rw_locks use GCC atomic builtins.\n");
 
1074
#else /* INNODB_RW_LOCKS_USE_ATOMICS */
 
1075
        fprintf(stderr,
 
1076
                "InnoDB: Mutexes use GCC atomic builtins, rw_locks do not.\n");
 
1077
#endif /* INNODB_RW_LOCKS_USE_ATOMICS */
 
1078
#else /* HAVE_GCC_ATOMIC_BUILTINS */
 
1079
        fprintf(stderr,
 
1080
                "InnoDB: Neither mutexes nor rw_locks use GCC atomic builtins.\n");
 
1081
#endif /* HAVE_GCC_ATOMIC_BUILTINS */
1079
1082
 
1080
1083
        /* Since InnoDB does not currently clean up all its internal data
1081
1084
        structures in MySQL Embedded Server Library server_end(), we
1083
1086
        second time during the process lifetime. */
1084
1087
 
1085
1088
        if (srv_start_has_been_called) {
1086
 
          drizzled::errmsg_printf(drizzled::error::ERROR,
1087
 
                        "InnoDB: Error: startup called second time during the process lifetime.\n");
 
1089
                fprintf(stderr,
 
1090
                        "InnoDB: Error:startup called second time"
 
1091
                        " during the process lifetime.\n"
 
1092
                        "InnoDB: In the MySQL Embedded Server Library"
 
1093
                        " you cannot call server_init()\n"
 
1094
                        "InnoDB: more than once during"
 
1095
                        " the process lifetime.\n");
1088
1096
        }
1089
1097
 
1090
1098
        srv_start_has_been_called = TRUE;
1096
1104
 
1097
1105
        srv_is_being_started = TRUE;
1098
1106
        srv_startup_is_before_trx_rollback_phase = TRUE;
 
1107
        os_aio_use_native_aio = FALSE;
1099
1108
 
1100
1109
#ifdef __WIN__
1101
 
        switch (os_get_os_version()) {
1102
 
        case OS_WIN95:
1103
 
        case OS_WIN31:
1104
 
        case OS_WINNT:
 
1110
        if (os_get_os_version() == OS_WIN95
 
1111
            || os_get_os_version() == OS_WIN31
 
1112
            || os_get_os_version() == OS_WINNT) {
 
1113
 
1105
1114
                /* On Win 95, 98, ME, Win32 subsystem for Windows 3.1,
1106
1115
                and NT use simulated aio. In NT Windows provides async i/o,
1107
1116
                but when run in conjunction with InnoDB Hot Backup, it seemed
1108
1117
                to corrupt the data files. */
1109
1118
 
1110
 
                srv_use_native_aio = FALSE;
1111
 
                break;
1112
 
 
1113
 
        case OS_WIN2000:
1114
 
        case OS_WINXP:
1115
 
                /* On 2000 and XP, async IO is available. */
1116
 
                srv_use_native_aio = TRUE;
1117
 
                break;
1118
 
 
1119
 
        default:
1120
 
                /* Vista and later have both async IO and condition variables */
1121
 
                srv_use_native_aio = TRUE;
1122
 
                srv_use_native_conditions = TRUE;
1123
 
                break;
1124
 
        }
1125
 
 
1126
 
#elif defined(LINUX_NATIVE_AIO)
1127
 
 
1128
 
        if (srv_use_native_aio) {
1129
 
                drizzled::errmsg_printf(drizzled::error::INFO,
1130
 
                                        _("InnoDB: Using Linux native AIO"));
1131
 
        }
1132
 
#else
1133
 
        /* Currently native AIO is supported only on windows and linux
1134
 
        and that also when the support is compiled in. In all other
1135
 
        cases, we ignore the setting of innodb_use_native_aio. */
1136
 
        srv_use_native_aio = FALSE;
1137
 
 
 
1119
                os_aio_use_native_aio = FALSE;
 
1120
        } else {
 
1121
                /* On Win 2000 and XP use async i/o */
 
1122
                os_aio_use_native_aio = TRUE;
 
1123
        }
1138
1124
#endif
1139
 
 
1140
1125
        if (srv_file_flush_method_str == NULL) {
1141
1126
                /* These are the default options */
1142
1127
 
1161
1146
#else
1162
1147
        } else if (0 == ut_strcmp(srv_file_flush_method_str, "normal")) {
1163
1148
                srv_win_file_flush_method = SRV_WIN_IO_NORMAL;
1164
 
                srv_use_native_aio = FALSE;
 
1149
                os_aio_use_native_aio = FALSE;
1165
1150
 
1166
1151
        } else if (0 == ut_strcmp(srv_file_flush_method_str, "unbuffered")) {
1167
1152
                srv_win_file_flush_method = SRV_WIN_IO_UNBUFFERED;
1168
 
                srv_use_native_aio = FALSE;
 
1153
                os_aio_use_native_aio = FALSE;
1169
1154
 
1170
1155
        } else if (0 == ut_strcmp(srv_file_flush_method_str,
1171
1156
                                  "async_unbuffered")) {
1172
1157
                srv_win_file_flush_method = SRV_WIN_IO_UNBUFFERED;
1173
1158
#endif
1174
1159
        } else {
1175
 
          drizzled::errmsg_printf(drizzled::error::ERROR,
1176
 
                                  "InnoDB: Unrecognized value %s for innodb_flush_method",
1177
 
                                  srv_file_flush_method_str);
 
1160
                fprintf(stderr,
 
1161
                        "InnoDB: Unrecognized value %s for"
 
1162
                        " innodb_flush_method\n",
 
1163
                        srv_file_flush_method_str);
1178
1164
                return(DB_ERROR);
1179
1165
        }
1180
1166
 
1186
1172
        maximum number of threads that can wait in the 'srv_conc array' for
1187
1173
        their time to enter InnoDB. */
1188
1174
 
 
1175
#if defined(__NETWARE__)
 
1176
 
 
1177
        /* Create less event semaphores because Win 98/ME had
 
1178
        difficulty creating 40000 event semaphores.  Comment from
 
1179
        Novell, Inc.: also, these just take a lot of memory on
 
1180
        NetWare. */
 
1181
        srv_max_n_threads = 1000;
 
1182
#else
1189
1183
        if (srv_buf_pool_size >= 1000 * 1024 * 1024) {
1190
1184
                /* If buffer pool is less than 1000 MB,
1191
 
                assume fewer threads. Also use only one
1192
 
                buffer pool instance */
 
1185
                assume fewer threads. */
1193
1186
                srv_max_n_threads = 50000;
1194
1187
 
1195
1188
        } else if (srv_buf_pool_size >= 8 * 1024 * 1024) {
1196
1189
 
1197
 
                srv_buf_pool_instances = 1;
1198
1190
                srv_max_n_threads = 10000;
1199
1191
        } else {
1200
 
                srv_buf_pool_instances = 1;
1201
1192
                srv_max_n_threads = 1000;       /* saves several MB of memory,
1202
1193
                                                especially in 64-bit
1203
1194
                                                computers */
1204
1195
        }
1205
 
 
 
1196
#endif
1206
1197
        err = srv_boot();
1207
1198
 
1208
1199
        if (err != DB_SUCCESS) {
1210
1201
                return((int) err);
1211
1202
        }
1212
1203
 
1213
 
        mutex_create(srv_monitor_file_mutex_key,
1214
 
                     &srv_monitor_file_mutex, SYNC_NO_ORDER_CHECK);
 
1204
        mutex_create(&srv_monitor_file_mutex, SYNC_NO_ORDER_CHECK);
1215
1205
 
1216
1206
        if (srv_innodb_status) {
1217
 
          srv_monitor_file_name = static_cast<char *>(mem_alloc(
 
1207
                srv_monitor_file_name = mem_alloc(
1218
1208
                        strlen(fil_path_to_mysql_datadir)
1219
 
                        + 20 + sizeof "/innodb_status."));
 
1209
                        + 20 + sizeof "/innodb_status.");
1220
1210
                sprintf(srv_monitor_file_name, "%s/innodb_status.%lu",
1221
1211
                        fil_path_to_mysql_datadir, os_proc_get_number());
1222
1212
                srv_monitor_file = fopen(srv_monitor_file_name, "w+");
1223
1213
                if (!srv_monitor_file) {
1224
 
                  drizzled::errmsg_printf(drizzled::error::ERROR,
1225
 
                                          "InnoDB: unable to create %s: %s\n", srv_monitor_file_name, strerror(errno));
 
1214
                        fprintf(stderr, "InnoDB: unable to create %s: %s\n",
 
1215
                                srv_monitor_file_name, strerror(errno));
1226
1216
                        return(DB_ERROR);
1227
1217
                }
1228
1218
        } else {
1233
1223
                }
1234
1224
        }
1235
1225
 
1236
 
        mutex_create(srv_dict_tmpfile_mutex_key,
1237
 
                     &srv_dict_tmpfile_mutex, SYNC_DICT_OPERATION);
 
1226
        mutex_create(&srv_dict_tmpfile_mutex, SYNC_DICT_OPERATION);
1238
1227
 
1239
1228
        srv_dict_tmpfile = os_file_create_tmpfile();
1240
1229
        if (!srv_dict_tmpfile) {
1241
1230
                return(DB_ERROR);
1242
1231
        }
1243
1232
 
1244
 
        mutex_create(srv_misc_tmpfile_mutex_key,
1245
 
                     &srv_misc_tmpfile_mutex, SYNC_ANY_LATCH);
 
1233
        mutex_create(&srv_misc_tmpfile_mutex, SYNC_ANY_LATCH);
1246
1234
 
1247
1235
        srv_misc_tmpfile = os_file_create_tmpfile();
1248
1236
        if (!srv_misc_tmpfile) {
1249
1237
                return(DB_ERROR);
1250
1238
        }
1251
1239
 
1252
 
        /* innodb_file_io_threads used to be user settable.
1253
 
           It is now just a combination of read_io_threads and
1254
 
           write_io_threads that is set by innodb internally. */
1255
 
 
1256
 
        /* Now overwrite the value on srv_n_file_io_threads */
1257
 
        srv_n_file_io_threads = 2 + srv_n_read_io_threads
1258
 
                                + srv_n_write_io_threads;
1259
 
 
1260
 
        ut_a(srv_n_file_io_threads <= SRV_MAX_N_IO_THREADS);
1261
 
 
1262
 
        /* TODO: Investigate if SRV_N_PENDING_IOS_PER_THREAD (32) limit
1263
 
        still applies to windows. */
1264
 
        if (!srv_use_native_aio) {
1265
 
                io_limit = 8 * SRV_N_PENDING_IOS_PER_THREAD;
1266
 
        } else {
1267
 
                io_limit = SRV_N_PENDING_IOS_PER_THREAD;
1268
 
        }
1269
 
 
1270
 
        os_aio_init(io_limit,
1271
 
                    srv_n_read_io_threads,
1272
 
                    srv_n_write_io_threads,
1273
 
                    SRV_MAX_N_PENDING_SYNC_IOS);
1274
 
 
1275
 
        fil_init(srv_file_per_table ? 50000 : 5000,
1276
 
                 srv_max_n_open_files);
1277
 
 
1278
 
        /* Print time to initialize the buffer pool */
1279
 
 
1280
 
        if (srv_buf_pool_size >= 1024 * 1024 * 1024) {
1281
 
          drizzled::errmsg_printf(drizzled::error::INFO, "InnoDB: Initializing buffer pool, size = %.1fG",
1282
 
                                  ((double) srv_buf_pool_size) / (1024 * 1024 * 1024));
1283
 
        } else {
1284
 
          drizzled::errmsg_printf(drizzled::error::INFO, "InnoDB: Initializing buffer pool, size = %.1fM",
1285
 
                                  ((double) srv_buf_pool_size) / (1024 * 1024));
1286
 
        }
1287
 
 
1288
 
        err = buf_pool_init(srv_buf_pool_size, srv_buf_pool_instances);
1289
 
 
1290
 
        drizzled::errmsg_printf(drizzled::error::INFO, "InnoDB: Completed initialization of buffer pool");
1291
 
 
1292
 
        if (err != DB_SUCCESS) {
1293
 
          drizzled::errmsg_printf(drizzled::error::ERROR, "InnoDB: Fatal error: cannot allocate the memory for the buffer pool");
1294
 
 
1295
 
          return(DB_ERROR);
 
1240
        /* Restrict the maximum number of file i/o threads */
 
1241
        if (srv_n_file_io_threads > SRV_MAX_N_IO_THREADS) {
 
1242
 
 
1243
                srv_n_file_io_threads = SRV_MAX_N_IO_THREADS;
 
1244
        }
 
1245
 
 
1246
        if (!os_aio_use_native_aio) {
 
1247
                /* In simulated aio we currently have use only for 4 threads */
 
1248
                srv_n_file_io_threads = 4;
 
1249
 
 
1250
                os_aio_init(8 * SRV_N_PENDING_IOS_PER_THREAD
 
1251
                            * srv_n_file_io_threads,
 
1252
                            srv_n_file_io_threads,
 
1253
                            SRV_MAX_N_PENDING_SYNC_IOS);
 
1254
        } else {
 
1255
                os_aio_init(SRV_N_PENDING_IOS_PER_THREAD
 
1256
                            * srv_n_file_io_threads,
 
1257
                            srv_n_file_io_threads,
 
1258
                            SRV_MAX_N_PENDING_SYNC_IOS);
 
1259
        }
 
1260
 
 
1261
        fil_init(srv_max_n_open_files);
 
1262
 
 
1263
        ret = buf_pool_init();
 
1264
 
 
1265
        if (ret == NULL) {
 
1266
                fprintf(stderr,
 
1267
                        "InnoDB: Fatal error: cannot allocate the memory"
 
1268
                        " for the buffer pool\n");
 
1269
 
 
1270
                return(DB_ERROR);
1296
1271
        }
1297
1272
 
1298
1273
#ifdef UNIV_DEBUG
1301
1276
 
1302
1277
        if (srv_buf_pool_size <= 5 * 1024 * 1024) {
1303
1278
 
1304
 
          drizzled::errmsg_printf(drizzled::error::WARN, "InnoDB: Warning: Small buffer pool size "
1305
 
                                  "(%luM), the flst_validate() debug function "
1306
 
                                  "can cause a deadlock if the buffer pool fills up.\n",
1307
 
                                  srv_buf_pool_size / 1024 / 1024);
 
1279
                fprintf(stderr, "InnoDB: Warning: Small buffer pool size "
 
1280
                        "(%luM), the flst_validate() debug function "
 
1281
                        "can cause a deadlock if the buffer pool fills up.\n",
 
1282
                        srv_buf_pool_size / 1024 / 1024);
1308
1283
        }
1309
1284
#endif
1310
1285
 
1323
1298
 
1324
1299
#ifdef UNIV_LOG_ARCHIVE
1325
1300
        if (0 != ut_strcmp(srv_log_group_home_dirs[0], srv_arch_dir)) {
1326
 
          drizzled::errmsg_printf(drizzled::error::ERROR,
1327
 
                                  "InnoDB: Error: you must set the log group home dir in my.cnf the same as log arch dir.");
 
1301
                fprintf(stderr,
 
1302
                        "InnoDB: Error: you must set the log group"
 
1303
                        " home dir in my.cnf the\n"
 
1304
                        "InnoDB: same as log arch dir.\n");
1328
1305
 
1329
1306
                return(DB_ERROR);
1330
1307
        }
1331
1308
#endif /* UNIV_LOG_ARCHIVE */
1332
1309
 
1333
1310
        if (srv_n_log_files * srv_log_file_size >= 262144) {
1334
 
          drizzled::errmsg_printf(drizzled::error::ERROR,
1335
 
                                  "InnoDB: Error: combined size of log files must be < 4 GB");
 
1311
                fprintf(stderr,
 
1312
                        "InnoDB: Error: combined size of log files"
 
1313
                        " must be < 4 GB\n");
1336
1314
 
1337
1315
                return(DB_ERROR);
1338
1316
        }
1342
1320
        for (i = 0; i < srv_n_data_files; i++) {
1343
1321
#ifndef __WIN__
1344
1322
                if (sizeof(off_t) < 5 && srv_data_file_sizes[i] >= 262144) {
1345
 
                  drizzled::errmsg_printf(drizzled::error::ERROR,
1346
 
                                          "InnoDB: Error: file size must be < 4 GB with this MySQL binary and operating system combination,"
1347
 
                                          " in some OS's < 2 GB\n");
 
1323
                        fprintf(stderr,
 
1324
                                "InnoDB: Error: file size must be < 4 GB"
 
1325
                                " with this MySQL binary\n"
 
1326
                                "InnoDB: and operating system combination,"
 
1327
                                " in some OS's < 2 GB\n");
1348
1328
 
1349
1329
                        return(DB_ERROR);
1350
1330
                }
1352
1332
                sum_of_new_sizes += srv_data_file_sizes[i];
1353
1333
        }
1354
1334
 
1355
 
        if (sum_of_new_sizes < 10485760 / UNIV_PAGE_SIZE) {
1356
 
          drizzled::errmsg_printf(drizzled::error::ERROR, "InnoDB: Error: tablespace size must be at least 10 MB");
 
1335
        if (sum_of_new_sizes < 640) {
 
1336
                fprintf(stderr,
 
1337
                        "InnoDB: Error: tablespace size must be"
 
1338
                        " at least 10 MB\n");
1357
1339
 
1358
1340
                return(DB_ERROR);
1359
1341
        }
1365
1347
                                        &min_flushed_lsn, &max_flushed_lsn,
1366
1348
                                        &sum_of_new_sizes);
1367
1349
        if (err != DB_SUCCESS) {
1368
 
          drizzled::errmsg_printf(drizzled::error::ERROR,
1369
 
                                  "InnoDB: Could not open or create data files.\n"
1370
 
                                  "InnoDB: If you tried to add new data files, and it failed here,\n"
1371
 
                                  "InnoDB: you should now edit innodb_data_file_path in my.cnf back\n"
1372
 
                                  "InnoDB: to what it was, and remove the new ibdata files InnoDB created\n"
1373
 
                                  "InnoDB: in this failed attempt. InnoDB only wrote those files full of\n"
1374
 
                                  "InnoDB: zeros, but did not yet use them in any way. But be careful: do not\n"
1375
 
                                  "InnoDB: remove old data files which contain your precious data!\n");
 
1350
                fprintf(stderr,
 
1351
                        "InnoDB: Could not open or create data files.\n"
 
1352
                        "InnoDB: If you tried to add new data files,"
 
1353
                        " and it failed here,\n"
 
1354
                        "InnoDB: you should now edit innodb_data_file_path"
 
1355
                        " in my.cnf back\n"
 
1356
                        "InnoDB: to what it was, and remove the"
 
1357
                        " new ibdata files InnoDB created\n"
 
1358
                        "InnoDB: in this failed attempt. InnoDB only wrote"
 
1359
                        " those files full of\n"
 
1360
                        "InnoDB: zeros, but did not yet use them in any way."
 
1361
                        " But be careful: do not\n"
 
1362
                        "InnoDB: remove old data files"
 
1363
                        " which contain your precious data!\n");
1376
1364
 
1377
1365
                return((int) err);
1378
1366
        }
1397
1385
                }
1398
1386
                if ((log_opened && create_new_db)
1399
1387
                    || (log_opened && log_created)) {
1400
 
                  drizzled::errmsg_printf(drizzled::error::ERROR,
1401
 
                                "InnoDB: Error: all log files must be created at the same time.\n"
1402
 
                                "InnoDB: All log files must be created also in database creation.\n"
1403
 
                                "InnoDB: If you want bigger or smaller log files, shut down the\n"
1404
 
                                "InnoDB: database and make sure there were no errors in shutdown.\n"
1405
 
                                "InnoDB: Then delete the existing log files. Edit the .cnf file\n"
 
1388
                        fprintf(stderr,
 
1389
                                "InnoDB: Error: all log files must be"
 
1390
                                " created at the same time.\n"
 
1391
                                "InnoDB: All log files must be"
 
1392
                                " created also in database creation.\n"
 
1393
                                "InnoDB: If you want bigger or smaller"
 
1394
                                " log files, shut down the\n"
 
1395
                                "InnoDB: database and make sure there"
 
1396
                                " were no errors in shutdown.\n"
 
1397
                                "InnoDB: Then delete the existing log files."
 
1398
                                " Edit the .cnf file\n"
1406
1399
                                "InnoDB: and start the database again.\n");
1407
1400
 
1408
1401
                        return(DB_ERROR);
1424
1417
                    || max_arch_log_no != min_arch_log_no
1425
1418
#endif /* UNIV_LOG_ARCHIVE */
1426
1419
                    ) {
1427
 
                  drizzled::errmsg_printf(drizzled::error::ERROR,
1428
 
                                "InnoDB: Cannot initialize created log files because\n"
1429
 
                                "InnoDB: data files were not in sync with each other\n"
 
1420
                        fprintf(stderr,
 
1421
                                "InnoDB: Cannot initialize created"
 
1422
                                " log files because\n"
 
1423
                                "InnoDB: data files were not in sync"
 
1424
                                " with each other\n"
1430
1425
                                "InnoDB: or the data files are corrupt.\n");
1431
1426
 
1432
1427
                        return(DB_ERROR);
1433
1428
                }
1434
1429
 
1435
1430
                if (max_flushed_lsn < (ib_uint64_t) 1000) {
1436
 
                  drizzled::errmsg_printf(drizzled::error::ERROR,
1437
 
                                "InnoDB: Cannot initialize created log files because\n"
1438
 
                                "InnoDB: data files are corrupt, or new data files were\n"
1439
 
                                "InnoDB: created when the database was started previous\n"
1440
 
                                "InnoDB: time but the database was not shut down\n"
1441
 
                                "InnoDB: normally after that.\n");
 
1431
                        fprintf(stderr,
 
1432
                                "InnoDB: Cannot initialize created"
 
1433
                                " log files because\n"
 
1434
                                "InnoDB: data files are corrupt,"
 
1435
                                " or new data files were\n"
 
1436
                                "InnoDB: created when the database"
 
1437
                                " was started previous\n"
 
1438
                                "InnoDB: time but the database"
 
1439
                                " was not shut down\n"
 
1440
                                "InnoDB: normally after that.\n");
1442
1441
 
1443
1442
                        return(DB_ERROR);
1444
1443
                }
1460
1459
 
1461
1460
        if (create_new_db) {
1462
1461
                mtr_start(&mtr);
1463
 
 
1464
1462
                fsp_header_init(0, sum_of_new_sizes, &mtr);
1465
1463
 
1466
1464
                mtr_commit(&mtr);
1467
1465
 
1468
 
                /* To maintain backward compatibility we create only
1469
 
                the first rollback segment before the double write buffer.
1470
 
                All the remaining rollback segments will be created later,
1471
 
                after the double write buffer has been created. */
1472
1466
                trx_sys_create();
1473
 
 
1474
1467
                dict_create();
1475
 
 
1476
1468
                srv_startup_is_before_trx_rollback_phase = FALSE;
1477
1469
 
1478
1470
#ifdef UNIV_LOG_ARCHIVE
1479
1471
        } else if (srv_archive_recovery) {
1480
 
          drizzled::errmsg_printf(drizzled::error::INFO,
1481
 
                                  "InnoDB: Starting archive recovery from a backup...");
 
1472
                fprintf(stderr,
 
1473
                        "InnoDB: Starting archive"
 
1474
                        " recovery from a backup...\n");
1482
1475
                err = recv_recovery_from_archive_start(
1483
1476
                        min_flushed_lsn, srv_archive_recovery_limit_lsn,
1484
1477
                        min_arch_log_no);
1490
1483
                in any disk i/o, first call dict_boot */
1491
1484
 
1492
1485
                dict_boot();
1493
 
 
1494
1486
                trx_sys_init_at_db_start();
1495
 
 
1496
1487
                srv_startup_is_before_trx_rollback_phase = FALSE;
1497
1488
 
1498
1489
                /* Initialize the fsp free limit global variable in the log
1516
1507
                consistent state, this is REQUIRED for the recovery
1517
1508
                process to work. */
1518
1509
                err = trx_sys_file_format_max_check(
1519
 
                        srv_max_file_format_at_startup);
 
1510
                        srv_check_file_format_at_startup);
1520
1511
 
1521
1512
                if (err != DB_SUCCESS) {
1522
1513
                        return(err);
1550
1541
                dict_boot();
1551
1542
                trx_sys_init_at_db_start();
1552
1543
 
1553
 
                /* Initialize the fsp free limit global variable in the log
1554
 
                system */
1555
 
                fsp_header_get_free_limit();
1556
 
 
1557
 
                /* recv_recovery_from_checkpoint_finish needs trx lists which
1558
 
                are initialized in trx_sys_init_at_db_start(). */
1559
 
 
1560
 
                recv_recovery_from_checkpoint_finish();
1561
1544
                if (srv_force_recovery < SRV_FORCE_NO_IBUF_MERGE) {
1562
1545
                        /* The following call is necessary for the insert
1563
1546
                        buffer to work with multiple tablespaces. We must
1573
1556
                        every table in the InnoDB data dictionary that has
1574
1557
                        an .ibd file.
1575
1558
 
1576
 
                        We also determine the maximum tablespace id used. */
 
1559
                        We also determine the maximum tablespace id used.
 
1560
 
 
1561
                        TODO: We may have incomplete transactions in the
 
1562
                        data dictionary tables. Does that harm the scanning of
 
1563
                        the data dictionary below? */
1577
1564
 
1578
1565
                        dict_check_tablespaces_and_store_max_id(
1579
1566
                                recv_needed_recovery);
1580
1567
                }
1581
1568
 
1582
1569
                srv_startup_is_before_trx_rollback_phase = FALSE;
1583
 
                recv_recovery_rollback_active();
 
1570
 
 
1571
                /* Initialize the fsp free limit global variable in the log
 
1572
                system */
 
1573
                fsp_header_get_free_limit();
 
1574
 
 
1575
                /* recv_recovery_from_checkpoint_finish needs trx lists which
 
1576
                are initialized in trx_sys_init_at_db_start(). */
 
1577
 
 
1578
                recv_recovery_from_checkpoint_finish();
1584
1579
 
1585
1580
                /* It is possible that file_format tag has never
1586
1581
                been set. In this case we initialize it to minimum
1629
1624
        /* fprintf(stderr, "Max allowed record size %lu\n",
1630
1625
        page_get_free_space_of_empty() / 2); */
1631
1626
 
1632
 
        if (trx_doublewrite == NULL) {
1633
 
                /* Create the doublewrite buffer to a new tablespace */
1634
 
 
1635
 
                trx_sys_create_doublewrite_buf();
1636
 
        }
1637
 
 
1638
 
        /* Here the double write buffer has already been created and so
1639
 
        any new rollback segments will be allocated after the double
1640
 
        write buffer. The default segment should already exist.
1641
 
        We create the new segments only if it's a new database or
1642
 
        the database was shutdown cleanly. */
1643
 
 
1644
 
        /* Note: When creating the extra rollback segments during an upgrade
1645
 
        we violate the latching order, even if the change buffer is empty.
1646
 
        We make an exception in sync0sync.c and check srv_is_being_started
1647
 
        for that violation. It cannot create a deadlock because we are still
1648
 
        running in single threaded mode essentially. Only the IO threads
1649
 
        should be running at this stage. */
1650
 
 
1651
 
        trx_sys_create_rsegs(TRX_SYS_N_RSEGS - 1);
1652
 
 
1653
 
        /* Create the thread which watches the timeouts for lock waits */
1654
 
        os_thread_create(&srv_lock_timeout_thread, NULL,
 
1627
        /* Create the thread which watches the timeouts for lock waits
 
1628
        and prints InnoDB monitor info */
 
1629
 
 
1630
        os_thread_create(&srv_lock_timeout_and_monitor_thread, NULL,
1655
1631
                         thread_ids + 2 + SRV_MAX_N_IO_THREADS);
1656
1632
 
1657
1633
        /* Create the thread which warns of long semaphore waits */
1658
1634
        os_thread_create(&srv_error_monitor_thread, NULL,
1659
1635
                         thread_ids + 3 + SRV_MAX_N_IO_THREADS);
1660
 
 
1661
 
        /* Create the thread which prints InnoDB monitor info */
1662
 
        os_thread_create(&srv_monitor_thread, NULL,
1663
 
                         thread_ids + 4 + SRV_MAX_N_IO_THREADS);
1664
 
 
1665
1636
        srv_is_being_started = FALSE;
1666
1637
 
 
1638
        if (trx_doublewrite == NULL) {
 
1639
                /* Create the doublewrite buffer to a new tablespace */
 
1640
 
 
1641
                trx_sys_create_doublewrite_buf();
 
1642
        }
 
1643
 
1667
1644
        err = dict_create_or_check_foreign_constraint_tables();
1668
1645
 
1669
1646
        if (err != DB_SUCCESS) {
1675
1652
 
1676
1653
        os_thread_create(&srv_master_thread, NULL, thread_ids
1677
1654
                         + (1 + SRV_MAX_N_IO_THREADS));
1678
 
 
1679
 
        /* Currently we allow only a single purge thread. */
1680
 
        ut_a(srv_n_purge_threads == 0 || srv_n_purge_threads == 1);
1681
 
 
1682
 
        /* If the user has requested a separate purge thread then
1683
 
        start the purge thread. */
1684
 
        if (srv_n_purge_threads == 1) {
1685
 
                os_thread_create(&srv_purge_thread, NULL, NULL);
1686
 
        }
1687
 
 
1688
1655
#ifdef UNIV_DEBUG
1689
1656
        /* buf_debug_prints = TRUE; */
1690
1657
#endif /* UNIV_DEBUG */
1699
1666
        if (!srv_auto_extend_last_data_file
1700
1667
            && sum_of_data_file_sizes != tablespace_size_in_header) {
1701
1668
 
1702
 
          drizzled::errmsg_printf(drizzled::error::ERROR,
1703
 
                                  "InnoDB: Error: tablespace size stored in header is %lu pages, but the sum of data file sizes is %lu pages.",
1704
 
                                  (ulong) tablespace_size_in_header,
1705
 
                                  (ulong) sum_of_data_file_sizes);
 
1669
                fprintf(stderr,
 
1670
                        "InnoDB: Error: tablespace size"
 
1671
                        " stored in header is %lu pages, but\n"
 
1672
                        "InnoDB: the sum of data file sizes is %lu pages\n",
 
1673
                        (ulong) tablespace_size_in_header,
 
1674
                        (ulong) sum_of_data_file_sizes);
1706
1675
 
1707
1676
                if (srv_force_recovery == 0
1708
1677
                    && sum_of_data_file_sizes < tablespace_size_in_header) {
1709
1678
                        /* This is a fatal error, the tail of a tablespace is
1710
1679
                        missing */
1711
1680
 
1712
 
                  drizzled::errmsg_printf(drizzled::error::ERROR,
1713
 
                                          "InnoDB: Cannot start InnoDB. The tail of the system tablespace is "
1714
 
                                          "missing. Have you edited innodb_data_file_path in my.cnf in an "
1715
 
                                          "inappropriate way, removing ibdata files from there? "
1716
 
                                          "You can set innodb_force_recovery=1 in my.cnf to force "
1717
 
                                          "a startup if you are trying to recover a badly corrupt database.");
 
1681
                        fprintf(stderr,
 
1682
                                "InnoDB: Cannot start InnoDB."
 
1683
                                " The tail of the system tablespace is\n"
 
1684
                                "InnoDB: missing. Have you edited"
 
1685
                                " innodb_data_file_path in my.cnf in an\n"
 
1686
                                "InnoDB: inappropriate way, removing"
 
1687
                                " ibdata files from there?\n"
 
1688
                                "InnoDB: You can set innodb_force_recovery=1"
 
1689
                                " in my.cnf to force\n"
 
1690
                                "InnoDB: a startup if you are trying"
 
1691
                                " to recover a badly corrupt database.\n");
1718
1692
 
1719
1693
                        return(DB_ERROR);
1720
1694
                }
1723
1697
        if (srv_auto_extend_last_data_file
1724
1698
            && sum_of_data_file_sizes < tablespace_size_in_header) {
1725
1699
 
1726
 
          drizzled::errmsg_printf(drizzled::error::ERROR,
1727
 
                                  "InnoDB: Error: tablespace size stored in header is %lu pages, but the sum of data file sizes"
1728
 
                                  " is only %lu pages\n",
1729
 
                                  (ulong) tablespace_size_in_header,
1730
 
                                  (ulong) sum_of_data_file_sizes);
 
1700
                fprintf(stderr,
 
1701
                        "InnoDB: Error: tablespace size stored in header"
 
1702
                        " is %lu pages, but\n"
 
1703
                        "InnoDB: the sum of data file sizes"
 
1704
                        " is only %lu pages\n",
 
1705
                        (ulong) tablespace_size_in_header,
 
1706
                        (ulong) sum_of_data_file_sizes);
1731
1707
 
1732
1708
                if (srv_force_recovery == 0) {
1733
1709
 
1734
 
                  drizzled::errmsg_printf(drizzled::error::ERROR,
1735
 
                                "InnoDB: Cannot start InnoDB. The tail of the system tablespace is "
1736
 
                                "missing. Have you edited innodb_data_file_path in my.cnf in an "
1737
 
                                "inappropriate way, removing ibdata files from there? "
1738
 
                                "You can set innodb_force_recovery=1 in my.cnf to force "
1739
 
                                "a startup if you are trying to recover a badly corrupt database.\n");
 
1710
                        fprintf(stderr,
 
1711
                                "InnoDB: Cannot start InnoDB. The tail of"
 
1712
                                " the system tablespace is\n"
 
1713
                                "InnoDB: missing. Have you edited"
 
1714
                                " innodb_data_file_path in my.cnf in an\n"
 
1715
                                "InnoDB: inappropriate way, removing"
 
1716
                                " ibdata files from there?\n"
 
1717
                                "InnoDB: You can set innodb_force_recovery=1"
 
1718
                                " in my.cnf to force\n"
 
1719
                                "InnoDB: a startup if you are trying to"
 
1720
                                " recover a badly corrupt database.\n");
1740
1721
 
1741
1722
                        return(DB_ERROR);
1742
1723
                }
1746
1727
        os_fast_mutex_init(&srv_os_test_mutex);
1747
1728
 
1748
1729
        if (0 != os_fast_mutex_trylock(&srv_os_test_mutex)) {
1749
 
          drizzled::errmsg_printf(drizzled::error::ERROR,
1750
 
                        "InnoDB: Error: pthread_mutex_trylock returns an unexpected value on success! Cannot continue.\n");
 
1730
                fprintf(stderr,
 
1731
                        "InnoDB: Error: pthread_mutex_trylock returns"
 
1732
                        " an unexpected value on\n"
 
1733
                        "InnoDB: success! Cannot continue.\n");
1751
1734
                exit(1);
1752
1735
        }
1753
1736
 
1760
1743
        os_fast_mutex_free(&srv_os_test_mutex);
1761
1744
 
1762
1745
        if (srv_print_verbose_log) {
1763
 
                drizzled::errmsg_printf(drizzled::error::ERROR,
1764
 
                                        "InnoDB %s started; log sequence number %"PRIu64"\n",
1765
 
                                        INNODB_VERSION_STR, srv_start_lsn);
 
1746
                ut_print_timestamp(stderr);
 
1747
                fprintf(stderr,
 
1748
                        " InnoDB Plugin %s started; "
 
1749
                        "log sequence number %"PRIu64"\n",
 
1750
                        INNODB_VERSION_STR, srv_start_lsn);
1766
1751
        }
1767
1752
 
1768
1753
        if (srv_force_recovery > 0) {
1769
 
          drizzled::errmsg_printf(drizzled::error::ERROR,
1770
 
                                  "InnoDB: !!! innodb_force_recovery is set to %lu !!!\n",
1771
 
                                  (ulong) srv_force_recovery);
 
1754
                fprintf(stderr,
 
1755
                        "InnoDB: !!! innodb_force_recovery"
 
1756
                        " is set to %lu !!!\n",
 
1757
                        (ulong) srv_force_recovery);
1772
1758
        }
1773
1759
 
 
1760
        fflush(stderr);
 
1761
 
1774
1762
        if (trx_doublewrite_must_reset_space_ids) {
1775
1763
                /* Actually, we did not change the undo log format between
1776
1764
                4.0 and 4.1.1, and we would not need to run purge to
1785
1773
                4.1.1. It is essential that the insert buffer is emptied
1786
1774
                here! */
1787
1775
 
1788
 
          drizzled::errmsg_printf(drizzled::error::INFO,
1789
 
                                  "InnoDB: You are upgrading to an InnoDB version which allows multiple. "
1790
 
                                  "tablespaces. Wait that purge and insert buffer merge run to completion...");
 
1776
                fprintf(stderr,
 
1777
                        "InnoDB: You are upgrading to an"
 
1778
                        " InnoDB version which allows multiple\n"
 
1779
                        "InnoDB: tablespaces. Wait that purge"
 
1780
                        " and insert buffer merge run to\n"
 
1781
                        "InnoDB: completion...\n");
1791
1782
                for (;;) {
1792
1783
                        os_thread_sleep(1000000);
1793
1784
 
1799
1790
                                break;
1800
1791
                        }
1801
1792
                }
1802
 
                drizzled::errmsg_printf(drizzled::error::INFO,
1803
 
                                        "InnoDB: Full purge and insert buffer merge completed.");
 
1793
                fprintf(stderr,
 
1794
                        "InnoDB: Full purge and insert buffer merge"
 
1795
                        " completed.\n");
1804
1796
 
1805
1797
                trx_sys_mark_upgraded_to_multiple_tablespaces();
1806
1798
 
1807
 
                drizzled::errmsg_printf(drizzled::error::INFO,
1808
 
                                        "InnoDB: You have now successfully upgraded"
1809
 
                                        " to the multiple tablespaces\n"
1810
 
                                        "InnoDB: format. You should NOT DOWNGRADE"
1811
 
                                        " to an earlier version of\n"
1812
 
                                        "InnoDB: InnoDB! But if you absolutely need to"
1813
 
                                        " downgrade, see\n"
1814
 
                                        "InnoDB: " REFMAN "multiple-tablespaces.html\n"
1815
 
                                        "InnoDB: for instructions.\n");
 
1799
                fprintf(stderr,
 
1800
                        "InnoDB: You have now successfully upgraded"
 
1801
                        " to the multiple tablespaces\n"
 
1802
                        "InnoDB: format. You should NOT DOWNGRADE"
 
1803
                        " to an earlier version of\n"
 
1804
                        "InnoDB: InnoDB! But if you absolutely need to"
 
1805
                        " downgrade, see\n"
 
1806
                        "InnoDB: http://dev.mysql.com/doc/refman/5.1/en/"
 
1807
                        "multiple-tablespaces.html\n"
 
1808
                        "InnoDB: for instructions.\n");
1816
1809
        }
1817
1810
 
1818
1811
        if (srv_force_recovery == 0) {
1831
1824
        return((int) DB_SUCCESS);
1832
1825
}
1833
1826
 
1834
 
/****************************************************************//**
1835
 
Shuts down the InnoDB database.
1836
 
@return DB_SUCCESS or error code */
 
1827
/********************************************************************
 
1828
Shuts down the InnoDB database. */
1837
1829
UNIV_INTERN
1838
1830
int
1839
1831
innobase_shutdown_for_mysql(void)
1840
1832
/*=============================*/
 
1833
                                /* out: DB_SUCCESS or error code */
1841
1834
{
1842
1835
        ulint   i;
 
1836
#ifdef __NETWARE__
 
1837
        extern ibool panic_shutdown;
 
1838
#endif
1843
1839
        if (!srv_was_started) {
1844
1840
                if (srv_is_being_started) {
1845
 
                  drizzled::errmsg_printf(drizzled::error::ERROR,
1846
 
                                "InnoDB: Warning: shutting down a not properly started or created database!");
 
1841
                        ut_print_timestamp(stderr);
 
1842
                        fprintf(stderr,
 
1843
                                "  InnoDB: Warning: shutting down"
 
1844
                                " a not properly started\n"
 
1845
                                "InnoDB: or created database!\n");
1847
1846
                }
1848
1847
 
1849
1848
                return(DB_SUCCESS);
1856
1855
 
1857
1856
 
1858
1857
        if (srv_fast_shutdown == 2) {
1859
 
                drizzled::errmsg_printf(drizzled::error::INFO,
1860
 
                                        "InnoDB: MySQL has requested a very fast shutdown without flushing "
1861
 
                                        "the InnoDB buffer pool to data files. At the next mysqld startup "
1862
 
                                        "InnoDB will do a crash recovery!");
 
1858
                ut_print_timestamp(stderr);
 
1859
                fprintf(stderr,
 
1860
                        "  InnoDB: MySQL has requested a very fast shutdown"
 
1861
                        " without flushing "
 
1862
                        "the InnoDB buffer pool to data files."
 
1863
                        " At the next mysqld startup "
 
1864
                        "InnoDB will do a crash recovery!\n");
1863
1865
        }
1864
1866
 
1865
 
        logs_empty_and_mark_files_at_shutdown();
 
1867
#ifdef __NETWARE__
 
1868
        if(!panic_shutdown)
 
1869
#endif
 
1870
                logs_empty_and_mark_files_at_shutdown();
1866
1871
 
1867
1872
        if (srv_conc_n_threads != 0) {
1868
 
          drizzled::errmsg_printf(drizzled::error::WARN,
1869
 
                                  "InnoDB: Warning: query counter shows %ld queries still InnoDB: inside InnoDB at shutdown.",
1870
 
                                  srv_conc_n_threads);
 
1873
                fprintf(stderr,
 
1874
                        "InnoDB: Warning: query counter shows %ld queries"
 
1875
                        " still\n"
 
1876
                        "InnoDB: inside InnoDB at shutdown\n",
 
1877
                        srv_conc_n_threads);
1871
1878
        }
1872
1879
 
1873
1880
        /* 2. Make all threads created by InnoDB to exit */
1899
1906
                /* c. We wake the master thread so that it exits */
1900
1907
                srv_wake_master_thread();
1901
1908
 
1902
 
                /* d. We wake the purge thread so that it exits */
1903
 
                srv_wake_purge_thread();
1904
 
 
1905
 
                /* e. Exit the i/o threads */
 
1909
                /* d. Exit the i/o threads */
1906
1910
 
1907
1911
                os_aio_wake_all_threads_at_shutdown();
1908
1912
 
1912
1916
                        /* All the threads have exited or are just exiting;
1913
1917
                        NOTE that the threads may not have completed their
1914
1918
                        exit yet. Should we use pthread_join() to make sure
1915
 
                        they have exited? If we did, we would have to
1916
 
                        remove the pthread_detach() from
1917
 
                        os_thread_exit().  Now we just sleep 0.1
1918
 
                        seconds and hope that is enough! */
 
1919
                        they have exited? Now we just sleep 0.1 seconds and
 
1920
                        hope that is enough! */
1919
1921
 
1920
1922
                        os_mutex_exit(os_sync_mutex);
1921
1923
 
1930
1932
        }
1931
1933
 
1932
1934
        if (i == 1000) {
1933
 
          drizzled::errmsg_printf(drizzled::error::WARN,
1934
 
                        "InnoDB: Warning: %lu threads created by InnoDB had not exited at shutdown!",
 
1935
                fprintf(stderr,
 
1936
                        "InnoDB: Warning: %lu threads created by InnoDB"
 
1937
                        " had not exited at shutdown!\n",
1935
1938
                        (ulong) os_thread_count);
1936
1939
        }
1937
1940
 
1953
1956
                srv_misc_tmpfile = 0;
1954
1957
        }
1955
1958
 
1956
 
        /* This must be disabled before closing the buffer pool
1957
 
        and closing the data dictionary.  */
1958
 
        btr_search_disable();
1959
 
 
1960
 
        ibuf_close();
1961
 
        log_shutdown();
1962
 
        lock_sys_close();
1963
 
        thr_local_close();
1964
1959
        trx_sys_file_format_close();
1965
 
        trx_sys_close();
1966
1960
 
1967
1961
        mutex_free(&srv_monitor_file_mutex);
1968
1962
        mutex_free(&srv_dict_tmpfile_mutex);
1969
1963
        mutex_free(&srv_misc_tmpfile_mutex);
1970
 
        dict_close();
1971
 
        btr_search_sys_free();
1972
1964
 
1973
1965
        /* 3. Free all InnoDB's own mutexes and the os_fast_mutexes inside
1974
1966
        them */
1975
 
        os_aio_free();
1976
1967
        sync_close();
 
1968
 
 
1969
        /* 4. Free the os_conc_mutex and all os_events and os_mutexes */
 
1970
 
1977
1971
        srv_free();
1978
 
        fil_close();
1979
 
 
1980
 
        /* 4. Free the os_conc_mutex and all os_events and os_mutexes */
1981
 
 
1982
1972
        os_sync_free();
1983
1973
 
1984
 
        /* 5. Free all allocated memory */
1985
 
 
1986
 
        pars_lexer_close();
1987
 
        log_mem_free();
1988
 
        buf_pool_free(srv_buf_pool_instances);
1989
 
        mem_close();
1990
 
 
1991
 
        /* ut_free_all_mem() frees all allocated memory not freed yet
1992
 
        in shutdown, and it will also free the ut_list_mutex, so it
1993
 
        should be the last one for all operation */
 
1974
        /* Check that all read views are closed except read view owned
 
1975
        by a purge. */
 
1976
 
 
1977
        if (UT_LIST_GET_LEN(trx_sys->view_list) > 1) {
 
1978
                fprintf(stderr,
 
1979
                        "InnoDB: Error: all read views were not closed"
 
1980
                        " before shutdown:\n"
 
1981
                        "InnoDB: %lu read views open \n",
 
1982
                        UT_LIST_GET_LEN(trx_sys->view_list) - 1);
 
1983
        }
 
1984
 
 
1985
        /* 5. Free all allocated memory and the os_fast_mutex created in
 
1986
        ut0mem.c */
 
1987
 
 
1988
        buf_pool_free();
1994
1989
        ut_free_all_mem();
1995
1990
 
1996
1991
        if (os_thread_count != 0
1997
1992
            || os_event_count != 0
1998
1993
            || os_mutex_count != 0
1999
1994
            || os_fast_mutex_count != 0) {
2000
 
          drizzled::errmsg_printf(drizzled::error::WARN,
2001
 
                                  "InnoDB: Warning: some resources were not cleaned up in shutdown:\n"
2002
 
                                  "InnoDB: threads %lu, events %lu, os_mutexes %lu, os_fast_mutexes %lu\n",
2003
 
                                  (ulong) os_thread_count, (ulong) os_event_count,
2004
 
                                  (ulong) os_mutex_count, (ulong) os_fast_mutex_count);
 
1995
                fprintf(stderr,
 
1996
                        "InnoDB: Warning: some resources were not"
 
1997
                        " cleaned up in shutdown:\n"
 
1998
                        "InnoDB: threads %lu, events %lu,"
 
1999
                        " os_mutexes %lu, os_fast_mutexes %lu\n",
 
2000
                        (ulong) os_thread_count, (ulong) os_event_count,
 
2001
                        (ulong) os_mutex_count, (ulong) os_fast_mutex_count);
2005
2002
        }
2006
2003
 
2007
2004
        if (dict_foreign_err_file) {
2012
2009
        }
2013
2010
 
2014
2011
        if (srv_print_verbose_log) {
2015
 
                drizzled::errmsg_printf(drizzled::error::INFO,
2016
 
                                        "InnoDB: Shutdown completed log sequence number %"PRIu64,
2017
 
                                        srv_shutdown_lsn);
 
2012
                ut_print_timestamp(stderr);
 
2013
                fprintf(stderr,
 
2014
                        "  InnoDB: Shutdown completed;"
 
2015
                        " log sequence number %"PRIu64"\n",
 
2016
                        srv_shutdown_lsn);
2018
2017
        }
2019
2018
 
2020
2019
        srv_was_started = FALSE;
2021
 
        srv_start_has_been_called = FALSE;
2022
2020
 
2023
2021
        return((int) DB_SUCCESS);
2024
2022
}
 
2023
 
 
2024
#ifdef __NETWARE__
 
2025
void set_panic_flag_for_netware()
 
2026
{
 
2027
        extern ibool panic_shutdown;
 
2028
        panic_shutdown = TRUE;
 
2029
}
 
2030
#endif /* __NETWARE__ */
2025
2031
#endif /* !UNIV_HOTBACKUP */