← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

  • Committer: Monty Taylor
  • Date: 2008-12-18 07:24:54 UTC
  • mto: This revision was merged to the branch mainline in revision 714.
  • Revision ID: monty@bitters-20081218072454-8pnep622damjgqli
Fixed one more my_time thing.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/srv/srv0start.c
1
 
/*****************************************************************************
2
 
 
3
 
Copyright (C) 1996, 2010, Innobase Oy. All Rights Reserved.
4
 
Copyright (C) 2008, Google Inc.
5
 
Copyright (C) 2009, Percona Inc.
6
 
 
7
 
Portions of this file contain modifications contributed and copyrighted by
8
 
Google, Inc. Those modifications are gratefully acknowledged and are described
9
 
briefly in the InnoDB documentation. The contributions by Google are
10
 
incorporated with their permission, and subject to the conditions contained in
11
 
the file COPYING.Google.
12
 
 
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
 
This program is free software; you can redistribute it and/or modify it under
21
 
the terms of the GNU General Public License as published by the Free Software
22
 
Foundation; version 2 of the License.
23
 
 
24
 
This program is distributed in the hope that it will be useful, but WITHOUT
25
 
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
26
 
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
27
 
 
28
 
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
31
 
 
32
 
*****************************************************************************/
33
 
 
34
 
/********************************************************************//**
35
 
@file srv/srv0start.c
 
1
/************************************************************************
36
2
Starts the InnoDB database server
37
3
 
 
4
(c) 1996-2000 Innobase Oy
 
5
 
38
6
Created 2/16/1996 Heikki Tuuri
39
7
*************************************************************************/
40
8
 
 
9
#include "os0proc.h"
 
10
#include "sync0sync.h"
41
11
#include "ut0mem.h"
42
12
#include "mem0mem.h"
 
13
#include "mem0pool.h"
43
14
#include "data0data.h"
44
15
#include "data0type.h"
45
16
#include "dict0dict.h"
46
17
#include "buf0buf.h"
 
18
#include "buf0flu.h"
 
19
#include "buf0rea.h"
47
20
#include "os0file.h"
48
21
#include "os0thread.h"
49
22
#include "fil0fil.h"
50
23
#include "fsp0fsp.h"
51
24
#include "rem0rec.h"
 
25
#include "rem0cmp.h"
52
26
#include "mtr0mtr.h"
53
27
#include "log0log.h"
54
28
#include "log0recv.h"
55
29
#include "page0page.h"
56
30
#include "page0cur.h"
57
31
#include "trx0trx.h"
 
32
#include "dict0boot.h"
 
33
#include "dict0load.h"
58
34
#include "trx0sys.h"
 
35
#include "dict0crea.h"
59
36
#include "btr0btr.h"
 
37
#include "btr0pcur.h"
60
38
#include "btr0cur.h"
 
39
#include "btr0sea.h"
61
40
#include "rem0rec.h"
 
41
#include "srv0srv.h"
 
42
#include "que0que.h"
 
43
#include "usr0sess.h"
 
44
#include "lock0lock.h"
 
45
#include "trx0roll.h"
 
46
#include "trx0purge.h"
 
47
#include "row0ins.h"
 
48
#include "row0sel.h"
 
49
#include "row0upd.h"
 
50
#include "row0row.h"
 
51
#include "row0mysql.h"
 
52
#include "lock0lock.h"
62
53
#include "ibuf0ibuf.h"
 
54
#include "pars0pars.h"
 
55
#include "btr0sea.h"
63
56
#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 */
 
57
#include "que0que.h"
 
58
 
 
59
/* Log sequence number immediately after startup */
99
60
UNIV_INTERN ib_uint64_t srv_start_lsn;
100
 
/** Log sequence number at shutdown */
 
61
/* Log sequence number at shutdown */
101
62
UNIV_INTERN ib_uint64_t srv_shutdown_lsn;
102
63
 
103
64
#ifdef HAVE_DARWIN_THREADS
104
65
# include <sys/utsname.h>
105
 
/** TRUE if the F_FULLFSYNC option is available */
106
66
UNIV_INTERN ibool       srv_have_fullfsync = FALSE;
107
67
#endif
108
68
 
109
 
/** TRUE if a raw partition is in use */
110
69
UNIV_INTERN ibool       srv_start_raw_disk_in_use = FALSE;
111
70
 
112
 
/** TRUE if the server is being started, before rolling back any
113
 
incomplete transactions */
114
71
UNIV_INTERN ibool       srv_startup_is_before_trx_rollback_phase = FALSE;
115
 
/** TRUE if the server is being started */
116
72
UNIV_INTERN ibool       srv_is_being_started = FALSE;
117
 
/** TRUE if the server was successfully started */
118
73
UNIV_INTERN ibool       srv_was_started = FALSE;
119
 
/** TRUE if innobase_start_or_create_for_mysql() has been called */
 
74
#ifndef UNIV_HOTBACKUP
120
75
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 */
 
76
#endif /* !UNIV_HOTBACKUP */
 
77
 
 
78
/* At a shutdown the value first climbs to SRV_SHUTDOWN_CLEANUP
 
79
and then to SRV_SHUTDOWN_LAST_PHASE */
 
80
UNIV_INTERN ulint               srv_shutdown_state = 0;
 
81
 
 
82
#ifndef UNIV_HOTBACKUP
127
83
static os_file_t        files[1000];
128
84
 
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
 
85
static mutex_t          ios_mutex;
 
86
static ulint            ios;
 
87
 
 
88
static ulint            n[SRV_MAX_N_IO_THREADS + 5];
 
89
static os_thread_id_t   thread_ids[SRV_MAX_N_IO_THREADS + 5];
 
90
 
 
91
/* We use this mutex to test the return value of pthread_mutex_trylock
135
92
   on successful locking. HP-UX does NOT return 0, though Linux et al do. */
136
93
static os_fast_mutex_t  srv_os_test_mutex;
137
94
 
138
 
/** Name of srv_monitor_file */
 
95
/* Name of srv_monitor_file */
139
96
static char*    srv_monitor_file_name;
140
97
#endif /* !UNIV_HOTBACKUP */
141
98
 
142
 
/** */
143
99
#define SRV_N_PENDING_IOS_PER_THREAD    OS_AIO_N_PENDING_IOS_PER_THREAD
144
100
#define SRV_MAX_N_PENDING_SYNC_IOS      100
145
101
 
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
 
 
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 */
 
102
 
 
103
/* Avoid warnings when using purify */
 
104
 
 
105
#ifdef HAVE_purify
 
106
static int inno_bcmp(register const char *s1, register const char *s2,
 
107
        register uint len)
 
108
{
 
109
        while ((len-- != 0) && (*s1++ == *s2++))
 
110
                ;
 
111
 
 
112
        return(len + 1);
 
113
}
 
114
#define memcmp(A,B,C) inno_bcmp((A),(B),(C))
 
115
#endif
 
116
 
159
117
static
160
118
char*
161
119
srv_parse_megabytes(
162
120
/*================*/
163
 
        char*   str,    /*!< in: string containing a quantity in bytes */
164
 
        ulint*  megs)   /*!< out: the number in megabytes */
 
121
                        /* out: next character in string */
 
122
        char*   str,    /* in: string containing a quantity in bytes */
 
123
        ulint*  megs)   /* out: the number in megabytes */
165
124
{
166
125
        char*   endp;
167
126
        ulint   size;
186
145
        return(str);
187
146
}
188
147
 
189
 
/*********************************************************************//**
 
148
/*************************************************************************
190
149
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 */
 
150
the .cnf file. */
193
151
UNIV_INTERN
194
152
ibool
195
153
srv_parse_data_file_paths_and_sizes(
196
154
/*================================*/
197
 
        char*   str)    /*!< in/out: the data file path string */
 
155
                                        /* out: TRUE if ok, FALSE if parsing
 
156
                                        error */
 
157
        char*   str,                    /* in: the data file path string */
 
158
        char*** data_file_names,        /* out, own: array of data file
 
159
                                        names */
 
160
        ulint** data_file_sizes,        /* out, own: array of data file sizes
 
161
                                        in megabytes */
 
162
        ulint** data_file_is_raw_partition,/* out, own: array of flags
 
163
                                        showing which data files are raw
 
164
                                        partitions */
 
165
        ulint*  n_data_files,           /* out: number of data files */
 
166
        ibool*  is_auto_extending,      /* out: TRUE if the last data file is
 
167
                                        auto-extending */
 
168
        ulint*  max_auto_extend_size)   /* out: max auto extend size for the
 
169
                                        last file if specified, 0 if not */
198
170
{
199
171
        char*   input_str;
200
172
        char*   path;
201
173
        ulint   size;
202
174
        ulint   i       = 0;
203
175
 
204
 
        srv_auto_extend_last_data_file = FALSE;
205
 
        srv_last_file_size_max = 0;
206
 
        srv_data_file_names = NULL;
207
 
        srv_data_file_sizes = NULL;
208
 
        srv_data_file_is_raw_partition = NULL;
 
176
        *is_auto_extending = FALSE;
 
177
        *max_auto_extend_size = 0;
209
178
 
210
179
        input_str = str;
211
180
 
282
251
                return(FALSE);
283
252
        }
284
253
 
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));
 
254
        *data_file_names = (char**)ut_malloc(i * sizeof(void*));
 
255
        *data_file_sizes = (ulint*)ut_malloc(i * sizeof(ulint));
 
256
        *data_file_is_raw_partition = (ulint*)ut_malloc(i * sizeof(ulint));
289
257
 
290
 
        srv_n_data_files = i;
 
258
        *n_data_files = i;
291
259
 
292
260
        /* Then store the actual values to our arrays */
293
261
 
317
285
 
318
286
                str = srv_parse_megabytes(str, &size);
319
287
 
320
 
                srv_data_file_names[i] = path;
321
 
                srv_data_file_sizes[i] = size;
 
288
                (*data_file_names)[i] = path;
 
289
                (*data_file_sizes)[i] = size;
322
290
 
323
291
                if (0 == strncmp(str, ":autoextend",
324
292
                                 (sizeof ":autoextend") - 1)) {
325
293
 
326
 
                        srv_auto_extend_last_data_file = TRUE;
 
294
                        *is_auto_extending = TRUE;
327
295
 
328
296
                        str += (sizeof ":autoextend") - 1;
329
297
 
333
301
                                str += (sizeof ":max:") - 1;
334
302
 
335
303
                                str = srv_parse_megabytes(
336
 
                                        str, &srv_last_file_size_max);
 
304
                                        str, max_auto_extend_size);
337
305
                        }
338
306
 
339
307
                        if (*str != '\0') {
342
310
                        }
343
311
                }
344
312
 
345
 
                (srv_data_file_is_raw_partition)[i] = 0;
 
313
                (*data_file_is_raw_partition)[i] = 0;
346
314
 
347
315
                if (strlen(str) >= 6
348
316
                    && *str == 'n'
349
317
                    && *(str + 1) == 'e'
350
318
                    && *(str + 2) == 'w') {
351
319
                        str += 3;
352
 
                        (srv_data_file_is_raw_partition)[i] = SRV_NEW_RAW;
 
320
                        (*data_file_is_raw_partition)[i] = SRV_NEW_RAW;
353
321
                }
354
322
 
355
323
                if (*str == 'r' && *(str + 1) == 'a' && *(str + 2) == 'w') {
356
324
                        str += 3;
357
325
 
358
 
                        if ((srv_data_file_is_raw_partition)[i] == 0) {
359
 
                                (srv_data_file_is_raw_partition)[i] = SRV_OLD_RAW;
 
326
                        if ((*data_file_is_raw_partition)[i] == 0) {
 
327
                                (*data_file_is_raw_partition)[i] = SRV_OLD_RAW;
360
328
                        }
361
329
                }
362
330
 
370
338
        return(TRUE);
371
339
}
372
340
 
373
 
/*********************************************************************//**
 
341
/*************************************************************************
374
342
Reads log group home directories from a character string given in
375
 
the .cnf file.
376
 
@return TRUE if ok, FALSE on parse error */
 
343
the .cnf file. */
377
344
UNIV_INTERN
378
345
ibool
379
346
srv_parse_log_group_home_dirs(
380
347
/*==========================*/
381
 
        char*   str)    /*!< in/out: character string */
 
348
                                        /* out: TRUE if ok, FALSE if parsing
 
349
                                        error */
 
350
        char*   str,                    /* in: character string */
 
351
        char*** log_group_home_dirs)    /* out, own: log group home dirs */
382
352
{
383
353
        char*   input_str;
384
354
        char*   path;
385
355
        ulint   i       = 0;
386
356
 
387
 
        srv_log_group_home_dirs = NULL;
388
 
 
389
357
        input_str = str;
390
358
 
391
359
        /* First calculate the number of directories and check syntax:
415
383
                return(FALSE);
416
384
        }
417
385
 
418
 
        srv_log_group_home_dirs = static_cast<char **>(malloc(i * sizeof *srv_log_group_home_dirs));
 
386
        *log_group_home_dirs = (char**) ut_malloc(i * sizeof(void*));
419
387
 
420
388
        /* Then store the actual values to our array */
421
389
 
434
402
                        str++;
435
403
                }
436
404
 
437
 
                srv_log_group_home_dirs[i] = path;
 
405
                (*log_group_home_dirs)[i] = path;
438
406
 
439
407
                i++;
440
408
        }
442
410
        return(TRUE);
443
411
}
444
412
 
445
 
/*********************************************************************//**
446
 
Frees the memory allocated by srv_parse_data_file_paths_and_sizes()
447
 
and srv_parse_log_group_home_dirs(). */
448
 
UNIV_INTERN
449
 
void
450
 
srv_free_paths_and_sizes(void)
451
 
/*==========================*/
452
 
{
453
 
        free(srv_data_file_names);
454
 
        srv_data_file_names = NULL;
455
 
        free(srv_data_file_sizes);
456
 
        srv_data_file_sizes = NULL;
457
 
        free(srv_data_file_is_raw_partition);
458
 
        srv_data_file_is_raw_partition = NULL;
459
 
        free(srv_log_group_home_dirs);
460
 
        srv_log_group_home_dirs = NULL;
461
 
}
462
 
 
463
413
#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);
 
414
/************************************************************************
 
415
I/o-handler thread function. */
 
416
static
470
417
 
471
 
extern "C"
472
418
os_thread_ret_t
473
419
io_handler_thread(
474
420
/*==============*/
475
 
        void*   arg)    /*!< in: pointer to the number of the segment in
476
 
                        the aio array */
 
421
        void*   arg)
477
422
{
478
423
        ulint   segment;
 
424
        ulint   i;
479
425
 
480
426
        segment = *((ulint*)arg);
481
427
 
483
429
        fprintf(stderr, "Io handler thread %lu starts, id %lu\n", segment,
484
430
                os_thread_pf(os_thread_get_curr_id()));
485
431
#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) {
 
432
        for (i = 0;; i++) {
492
433
                fil_aio_wait(segment);
 
434
 
 
435
                mutex_enter(&ios_mutex);
 
436
                ios++;
 
437
                mutex_exit(&ios_mutex);
493
438
        }
494
439
 
495
440
        /* We count the number of threads in os_thread_exit(). A created
496
441
        thread should always use that to exit and not use return() to exit.
497
442
        The thread actually never comes here because it is exited in an
498
443
        os_event_wait(). */
499
 
        return 0;
 
444
 
 
445
        os_thread_exit(NULL);
 
446
 
 
447
        OS_THREAD_DUMMY_RETURN;
500
448
}
501
449
#endif /* !UNIV_HOTBACKUP */
502
450
 
506
454
#define SRV_PATH_SEPARATOR      '/'
507
455
#endif
508
456
 
509
 
/*********************************************************************//**
 
457
/*************************************************************************
510
458
Normalizes a directory path for Windows: converts slashes to backslashes. */
511
459
UNIV_INTERN
512
460
void
513
461
srv_normalize_path_for_win(
514
462
/*=======================*/
515
 
        char*   /*str __attribute__((unused))*/)        /*!< in/out: null-terminated
 
463
        char*   str __attribute__((unused)))    /* in/out: null-terminated
516
464
                                                character string */
517
465
{
518
466
#ifdef __WIN__
525
473
#endif
526
474
}
527
475
 
 
476
/*************************************************************************
 
477
Adds a slash or a backslash to the end of a string if it is missing
 
478
and the string is not empty. */
 
479
UNIV_INTERN
 
480
char*
 
481
srv_add_path_separator_if_needed(
 
482
/*=============================*/
 
483
                        /* out: string which has the separator if the
 
484
                        string is not empty */
 
485
        char*   str)    /* in: null-terminated character string */
 
486
{
 
487
        char*   out_str;
 
488
        ulint   len     = ut_strlen(str);
 
489
 
 
490
        if (len == 0 || str[len - 1] == SRV_PATH_SEPARATOR) {
 
491
 
 
492
                return(str);
 
493
        }
 
494
 
 
495
        out_str = ut_malloc(len + 2);
 
496
        memcpy(out_str, str, len);
 
497
        out_str[len] = SRV_PATH_SEPARATOR;
 
498
        out_str[len + 1] = 0;
 
499
 
 
500
        return(out_str);
 
501
}
 
502
 
528
503
#ifndef UNIV_HOTBACKUP
529
 
/*********************************************************************//**
 
504
/*************************************************************************
530
505
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 */
 
506
database pages is converted to the number of bytes. */
533
507
static
534
508
ulint
535
509
srv_calc_low32(
536
510
/*===========*/
537
 
        ulint   file_size)      /*!< in: file size in database pages */
 
511
                                /* out: low 32 bytes of file size when
 
512
                                expressed in bytes */
 
513
        ulint   file_size)      /* in: file size in database pages */
538
514
{
539
515
        return(0xFFFFFFFFUL & (file_size << UNIV_PAGE_SIZE_SHIFT));
540
516
}
541
517
 
542
 
/*********************************************************************//**
 
518
/*************************************************************************
543
519
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 */
 
520
database pages is converted to the number of bytes. */
546
521
static
547
522
ulint
548
523
srv_calc_high32(
549
524
/*============*/
550
 
        ulint   file_size)      /*!< in: file size in database pages */
 
525
                                /* out: high 32 bytes of file size when
 
526
                                expressed in bytes */
 
527
        ulint   file_size)      /* in: file size in database pages */
551
528
{
552
529
        return(file_size >> (32 - UNIV_PAGE_SIZE_SHIFT));
553
530
}
554
531
 
555
 
/*********************************************************************//**
556
 
Creates or opens the log files and closes them.
557
 
@return DB_SUCCESS or error code */
 
532
/*************************************************************************
 
533
Creates or opens the log files and closes them. */
558
534
static
559
535
ulint
560
536
open_or_create_log_file(
561
537
/*====================*/
562
 
        ibool   create_new_db,          /*!< in: TRUE if we should create a
 
538
                                        /* out: DB_SUCCESS or error code */
 
539
        ibool   create_new_db,          /* in: TRUE if we should create a
563
540
                                        new database */
564
 
        ibool*  log_file_created,       /*!< out: TRUE if new log file
 
541
        ibool*  log_file_created,       /* out: TRUE if new log file
565
542
                                        created */
566
 
        ibool   log_file_has_been_opened,/*!< in: TRUE if a log file has been
 
543
        ibool   log_file_has_been_opened,/* in: TRUE if a log file has been
567
544
                                        opened before: then it is an error
568
545
                                        to try to create another log file */
569
 
        ulint   k,                      /*!< in: log group number */
570
 
        ulint   i)                      /*!< in: log file number in group */
 
546
        ulint   k,                      /* in: log group number */
 
547
        ulint   i)                      /* in: log file number in group */
571
548
{
572
549
        ibool   ret;
573
550
        ulint   size;
574
551
        ulint   size_high;
575
552
        char    name[10000];
576
 
        ulint   dirnamelen;
577
553
 
578
554
        UT_NOT_USED(create_new_db);
579
555
 
580
556
        *log_file_created = FALSE;
581
557
 
582
558
        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,
 
559
        srv_log_group_home_dirs[k] = srv_add_path_separator_if_needed(
 
560
                srv_log_group_home_dirs[k]);
 
561
 
 
562
        ut_a(strlen(srv_log_group_home_dirs[k])
 
563
             < (sizeof name) - 10 - sizeof "ib_logfile");
 
564
        sprintf(name, "%s%s%lu", srv_log_group_home_dirs[k],
 
565
                "ib_logfile", (ulong) i);
 
566
 
 
567
        files[i] = os_file_create(name, OS_FILE_CREATE, OS_FILE_NORMAL,
597
568
                                  OS_LOG_FILE, &ret);
598
569
        if (ret == FALSE) {
599
570
                if (os_file_get_last_error(FALSE) != OS_FILE_ALREADY_EXISTS
604
575
                    && os_file_get_last_error(FALSE) != 100
605
576
#endif
606
577
                    ) {
607
 
                  drizzled::errmsg_printf(drizzled::error::ERROR,
608
 
                                          "InnoDB: Error in creating or opening %s", name);
 
578
                        fprintf(stderr,
 
579
                                "InnoDB: Error in creating"
 
580
                                " or opening %s\n", name);
609
581
 
610
 
                  return(DB_ERROR);
 
582
                        return(DB_ERROR);
611
583
                }
612
584
 
613
 
                files[i] = os_file_create(innodb_file_log_key, name,
614
 
                                          OS_FILE_OPEN, OS_FILE_AIO,
 
585
                files[i] = os_file_create(name, OS_FILE_OPEN, OS_FILE_AIO,
615
586
                                          OS_LOG_FILE, &ret);
616
587
                if (!ret) {
617
 
                  drizzled::errmsg_printf(drizzled::error::ERROR,
618
 
                                          "InnoDB: Error in opening %s.", name);
 
588
                        fprintf(stderr,
 
589
                                "InnoDB: Error in opening %s\n", name);
619
590
 
620
591
                        return(DB_ERROR);
621
592
                }
626
597
                if (size != srv_calc_low32(srv_log_file_size)
627
598
                    || size_high != srv_calc_high32(srv_log_file_size)) {
628
599
 
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));
 
600
                        fprintf(stderr,
 
601
                                "InnoDB: Error: log file %s is"
 
602
                                " of different size %lu %lu bytes\n"
 
603
                                "InnoDB: than specified in the .cnf"
 
604
                                " file %lu %lu bytes!\n",
 
605
                                name, (ulong) size_high, (ulong) size,
 
606
                                (ulong) srv_calc_high32(srv_log_file_size),
 
607
                                (ulong) srv_calc_low32(srv_log_file_size));
635
608
 
636
609
                        return(DB_ERROR);
637
610
                }
638
611
        } else {
639
612
                *log_file_created = TRUE;
640
613
 
641
 
                drizzled::errmsg_printf(drizzled::error::INFO,
642
 
                                        "InnoDB: Log file %s did not exist: new to be created",
643
 
                                        name);
 
614
                ut_print_timestamp(stderr);
 
615
 
 
616
                fprintf(stderr,
 
617
                        "  InnoDB: Log file %s did not exist:"
 
618
                        " new to be created\n",
 
619
                        name);
644
620
                if (log_file_has_been_opened) {
645
621
 
646
622
                        return(DB_ERROR);
647
623
                }
648
624
 
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));
 
625
                fprintf(stderr, "InnoDB: Setting log file %s size to %lu MB\n",
 
626
                        name, (ulong) srv_log_file_size
 
627
                        >> (20 - UNIV_PAGE_SIZE_SHIFT));
653
628
 
654
 
                drizzled::errmsg_printf(drizzled::error::INFO,
655
 
                                        "InnoDB: Database physically writes the file full: wait...\n");
 
629
                fprintf(stderr,
 
630
                        "InnoDB: Database physically writes the file"
 
631
                        " full: wait...\n");
656
632
 
657
633
                ret = os_file_set_size(name, files[i],
658
634
                                       srv_calc_low32(srv_log_file_size),
659
635
                                       srv_calc_high32(srv_log_file_size));
660
636
                if (!ret) {
661
 
                  drizzled::errmsg_printf(drizzled::error::ERROR,
662
 
                                          "InnoDB: Error in creating %s: probably out of disk space",
663
 
                                          name);
 
637
                        fprintf(stderr,
 
638
                                "InnoDB: Error in creating %s:"
 
639
                                " probably out of disk space\n",
 
640
                                name);
664
641
 
665
642
                        return(DB_ERROR);
666
643
                }
705
682
        return(DB_SUCCESS);
706
683
}
707
684
 
708
 
/*********************************************************************//**
709
 
Creates or opens database data files and closes them.
710
 
@return DB_SUCCESS or error code */
 
685
/*************************************************************************
 
686
Creates or opens database data files and closes them. */
711
687
static
712
688
ulint
713
689
open_or_create_data_files(
714
690
/*======================*/
715
 
        ibool*          create_new_db,  /*!< out: TRUE if new database should be
 
691
                                        /* out: DB_SUCCESS or error code */
 
692
        ibool*          create_new_db,  /* out: TRUE if new database should be
716
693
                                        created */
717
694
#ifdef UNIV_LOG_ARCHIVE
718
 
        ulint*          min_arch_log_no,/*!< out: min of archived log
 
695
        ulint*          min_arch_log_no,/* out: min of archived log
719
696
                                        numbers in data files */
720
 
        ulint*          max_arch_log_no,/*!< out: max of archived log
 
697
        ulint*          max_arch_log_no,/* out: max of archived log
721
698
                                        numbers in data files */
722
699
#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
 
700
        ib_uint64_t*    min_flushed_lsn,/* out: min of flushed lsn
 
701
                                        values in data files */
 
702
        ib_uint64_t*    max_flushed_lsn,/* out: max of flushed lsn
 
703
                                        values in data files */
 
704
        ulint*          sum_of_new_sizes)/* out: sum of sizes of the
728
705
                                        new files added */
729
706
{
730
707
        ibool   ret;
737
714
        char    name[10000];
738
715
 
739
716
        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);
 
717
                fprintf(stderr, "InnoDB: can only have < 1000 data files\n"
 
718
                        "InnoDB: you have defined %lu\n",
 
719
                        (ulong) srv_n_data_files);
743
720
                return(DB_ERROR);
744
721
        }
745
722
 
748
725
        *create_new_db = FALSE;
749
726
 
750
727
        srv_normalize_path_for_win(srv_data_home);
 
728
        srv_data_home = srv_add_path_separator_if_needed(srv_data_home);
751
729
 
752
730
        for (i = 0; i < srv_n_data_files; i++) {
753
 
                ulint   dirnamelen;
754
 
 
755
731
                srv_normalize_path_for_win(srv_data_file_names[i]);
756
 
                dirnamelen = strlen(srv_data_home);
757
732
 
758
 
                ut_a(dirnamelen + strlen(srv_data_file_names[i])
 
733
                ut_a(strlen(srv_data_home) + strlen(srv_data_file_names[i])
759
734
                     < (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]);
 
735
                sprintf(name, "%s%s", srv_data_home, srv_data_file_names[i]);
767
736
 
768
737
                if (srv_data_file_is_raw_partition[i] == 0) {
769
738
 
770
739
                        /* First we try to create the file: if it already
771
740
                        exists, ret will get value FALSE */
772
741
 
773
 
                        files[i] = os_file_create(innodb_file_data_key,
774
 
                                                  name, OS_FILE_CREATE,
 
742
                        files[i] = os_file_create(name, OS_FILE_CREATE,
775
743
                                                  OS_FILE_NORMAL,
776
744
                                                  OS_DATA_FILE, &ret);
777
745
 
784
752
                            && os_file_get_last_error(FALSE) != 100
785
753
#endif
786
754
                            ) {
787
 
                          drizzled::errmsg_printf(drizzled::error::ERROR,
788
 
                                                  "InnoDB: Error in creating or opening %s",
789
 
                                                  name);
 
755
                                fprintf(stderr,
 
756
                                        "InnoDB: Error in creating"
 
757
                                        " or opening %s\n",
 
758
                                        name);
790
759
 
791
760
                                return(DB_ERROR);
792
761
                        }
797
766
                        srv_start_raw_disk_in_use = TRUE;
798
767
                        srv_created_new_raw = TRUE;
799
768
 
800
 
                        files[i] = os_file_create(innodb_file_data_key,
801
 
                                                  name, OS_FILE_OPEN_RAW,
 
769
                        files[i] = os_file_create(name, OS_FILE_OPEN_RAW,
802
770
                                                  OS_FILE_NORMAL,
803
771
                                                  OS_DATA_FILE, &ret);
804
772
                        if (!ret) {
805
 
                          drizzled::errmsg_printf(drizzled::error::ERROR,
806
 
                                                  "InnoDB: Error in opening %s", name);
 
773
                                fprintf(stderr,
 
774
                                        "InnoDB: Error in opening %s\n", name);
807
775
 
808
776
                                return(DB_ERROR);
809
777
                        }
819
787
                        /* We open the data file */
820
788
 
821
789
                        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);
 
790
                                fprintf(stderr,
 
791
                                        "InnoDB: Error: data files can only"
 
792
                                        " be added at the end\n");
 
793
                                fprintf(stderr,
 
794
                                        "InnoDB: of a tablespace, but"
 
795
                                        " data file %s existed beforehand.\n",
 
796
                                        name);
826
797
                                return(DB_ERROR);
827
798
                        }
828
799
 
829
800
                        if (srv_data_file_is_raw_partition[i] == SRV_OLD_RAW) {
830
801
                                files[i] = os_file_create(
831
 
                                        innodb_file_data_key,
832
802
                                        name, OS_FILE_OPEN_RAW,
833
803
                                        OS_FILE_NORMAL, OS_DATA_FILE, &ret);
834
804
                        } else if (i == 0) {
835
805
                                files[i] = os_file_create(
836
 
                                        innodb_file_data_key,
837
806
                                        name, OS_FILE_OPEN_RETRY,
838
807
                                        OS_FILE_NORMAL, OS_DATA_FILE, &ret);
839
808
                        } else {
840
809
                                files[i] = os_file_create(
841
 
                                        innodb_file_data_key,
842
810
                                        name, OS_FILE_OPEN, OS_FILE_NORMAL,
843
811
                                        OS_DATA_FILE, &ret);
844
812
                        }
845
813
 
846
814
                        if (!ret) {
847
 
                          drizzled::errmsg_printf(drizzled::error::ERROR,
848
 
                                                  "InnoDB: Error in opening %s", name);
 
815
                                fprintf(stderr,
 
816
                                        "InnoDB: Error in opening %s\n", name);
849
817
                                os_file_get_last_error(TRUE);
850
818
 
851
819
                                return(DB_ERROR);
872
840
                                        && srv_last_file_size_max
873
841
                                        < rounded_size_pages)) {
874
842
 
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);
 
843
                                        fprintf(stderr,
 
844
                                                "InnoDB: Error: auto-extending"
 
845
                                                " data file %s is"
 
846
                                                " of a different size\n"
 
847
                                                "InnoDB: %lu pages (rounded"
 
848
                                                " down to MB) than specified"
 
849
                                                " in the .cnf file:\n"
 
850
                                                "InnoDB: initial %lu pages,"
 
851
                                                " max %lu (relevant if"
 
852
                                                " non-zero) pages!\n",
 
853
                                                name,
 
854
                                                (ulong) rounded_size_pages,
 
855
                                                (ulong) srv_data_file_sizes[i],
 
856
                                                (ulong)
 
857
                                                srv_last_file_size_max);
884
858
 
885
859
                                        return(DB_ERROR);
886
860
                                }
890
864
 
891
865
                        if (rounded_size_pages != srv_data_file_sizes[i]) {
892
866
 
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!",
 
867
                                fprintf(stderr,
 
868
                                        "InnoDB: Error: data file %s"
 
869
                                        " is of a different size\n"
 
870
                                        "InnoDB: %lu pages"
 
871
                                        " (rounded down to MB)\n"
 
872
                                        "InnoDB: than specified"
 
873
                                        " in the .cnf file %lu pages!\n",
897
874
                                        name,
898
875
                                        (ulong) rounded_size_pages,
899
876
                                        (ulong) srv_data_file_sizes[i]);
915
892
                        one_created = TRUE;
916
893
 
917
894
                        if (i > 0) {
918
 
                                drizzled::errmsg_printf(drizzled::error::INFO,
919
 
                                        "  InnoDB: Data file %s did not exist: new to be created",
 
895
                                ut_print_timestamp(stderr);
 
896
                                fprintf(stderr,
 
897
                                        "  InnoDB: Data file %s did not"
 
898
                                        " exist: new to be created\n",
920
899
                                        name);
921
900
                        } 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);
 
901
                                fprintf(stderr,
 
902
                                        "InnoDB: The first specified"
 
903
                                        " data file %s did not exist:\n"
 
904
                                        "InnoDB: a new database"
 
905
                                        " to be created!\n", name);
924
906
                                *create_new_db = TRUE;
925
907
                        }
926
908
 
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)));
 
909
                        ut_print_timestamp(stderr);
 
910
                        fprintf(stderr,
 
911
                                "  InnoDB: Setting file %s size to %lu MB\n",
 
912
                                name,
 
913
                                (ulong) (srv_data_file_sizes[i]
 
914
                                         >> (20 - UNIV_PAGE_SIZE_SHIFT)));
931
915
 
932
 
                        drizzled::errmsg_printf(drizzled::error::INFO,
933
 
                                "InnoDB: Database physically writes the file full: wait...");
 
916
                        fprintf(stderr,
 
917
                                "InnoDB: Database physically writes the"
 
918
                                " file full: wait...\n");
934
919
 
935
920
                        ret = os_file_set_size(
936
921
                                name, files[i],
938
923
                                srv_calc_high32(srv_data_file_sizes[i]));
939
924
 
940
925
                        if (!ret) {
941
 
                          drizzled::errmsg_printf(drizzled::error::ERROR,
942
 
                                                  "InnoDB: Error in creating %s: probably out of disk space", name);
 
926
                                fprintf(stderr,
 
927
                                        "InnoDB: Error in creating %s:"
 
928
                                        " probably out of disk space\n", name);
943
929
 
944
930
                                return(DB_ERROR);
945
931
                        }
961
947
                                srv_data_file_is_raw_partition[i] != 0);
962
948
        }
963
949
 
 
950
        ios = 0;
 
951
 
 
952
        mutex_create(&ios_mutex, SYNC_NO_ORDER_CHECK);
 
953
 
964
954
        return(DB_SUCCESS);
965
955
}
966
956
 
967
957
/********************************************************************
968
958
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 */
 
959
are not found and the user wants. Server parameters are
 
960
read from a file of name "srv_init" in the ib_home directory. */
971
961
UNIV_INTERN
972
962
int
973
963
innobase_start_or_create_for_mysql(void)
974
964
/*====================================*/
 
965
                                /* out: DB_SUCCESS or error code */
975
966
{
 
967
        buf_pool_t*     ret;
976
968
        ibool           create_new_db;
977
969
        ibool           log_file_created;
978
970
        ibool           log_created     = FALSE;
988
980
        ulint           tablespace_size_in_header;
989
981
        ulint           err;
990
982
        ulint           i;
991
 
        ulint           io_limit;
992
983
        my_bool         srv_file_per_table_original_value
993
984
                = srv_file_per_table;
994
985
        mtr_t           mtr;
1003
994
        on Mac OS X 10.3 or later. */
1004
995
        struct utsname utsname;
1005
996
        if (uname(&utsname)) {
1006
 
                fputs(_("InnoDB: cannot determine Mac OS X version!\n"), stderr);
 
997
                fputs("InnoDB: cannot determine Mac OS X version!\n", stderr);
1007
998
        } else {
1008
999
                srv_have_fullfsync = strcmp(utsname.release, "7.") >= 0;
1009
1000
        }
1010
1001
        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);
 
1002
                fputs("InnoDB: On Mac OS X, fsync() may be"
 
1003
                      " broken on internal drives,\n"
 
1004
                      "InnoDB: making transactions unsafe!\n", stderr);
1014
1005
        }
1015
1006
# endif /* F_FULLFSYNC */
1016
1007
#endif /* HAVE_DARWIN_THREADS */
1017
1008
 
1018
1009
        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."),
 
1010
                fprintf(stderr,
 
1011
                        "InnoDB: Error: size of InnoDB's ulint is %lu,"
 
1012
                        " but size of void* is %lu.\n"
 
1013
                        "InnoDB: The sizes should be the same"
 
1014
                        " so that on a 64-bit platform you can\n"
 
1015
                        "InnoDB: allocate more than 4 GB of memory.",
1022
1016
                        (ulong)sizeof(ulint), (ulong)sizeof(void*));
1023
1017
        }
1024
1018
 
1028
1022
        innodb_file_per_table) until this function has returned. */
1029
1023
        srv_file_per_table = FALSE;
1030
1024
#ifdef UNIV_DEBUG
1031
 
        drizzled::errmsg_printf(drizzled::error::INFO,
1032
 
                                _("InnoDB: !!!!!!!! UNIV_DEBUG switched on !!!!!!!!!\n"));
 
1025
        fprintf(stderr,
 
1026
                "InnoDB: !!!!!!!! UNIV_DEBUG switched on !!!!!!!!!\n");
1033
1027
#endif
1034
1028
 
1035
1029
#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
 
                ));
 
1030
        fprintf(stderr,
 
1031
                "InnoDB: !!!!!!!! UNIV_IBUF_DEBUG switched on !!!!!!!!!\n"
 
1032
                "InnoDB: Crash recovery will fail with UNIV_IBUF_DEBUG\n");
1043
1033
#endif
1044
1034
 
1045
1035
#ifdef UNIV_SYNC_DEBUG
1046
 
        drizzled::errmsg_printf(drizzled::error::INFO,
1047
 
                                _("InnoDB: !!!!!!!! UNIV_SYNC_DEBUG switched on !!!!!!!!!\n"));
 
1036
        fprintf(stderr,
 
1037
                "InnoDB: !!!!!!!! UNIV_SYNC_DEBUG switched on !!!!!!!!!\n");
1048
1038
#endif
1049
1039
 
1050
1040
#ifdef UNIV_SEARCH_DEBUG
1051
 
        drizzled::errmsg_printf(drizzled::error::INFO,
1052
 
                                _("InnoDB: !!!!!!!! UNIV_SEARCH_DEBUG switched on !!!!!!!!!\n"));
 
1041
        fprintf(stderr,
 
1042
                "InnoDB: !!!!!!!! UNIV_SEARCH_DEBUG switched on !!!!!!!!!\n");
1053
1043
#endif
1054
1044
 
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
1045
#ifdef UNIV_MEM_DEBUG
1060
 
        drizzled::errmsg_printf(drizzled::error::INFO,
1061
 
                                _("InnoDB: !!!!!!!! UNIV_MEM_DEBUG switched on !!!!!!!!!\n"));
 
1046
        fprintf(stderr,
 
1047
                "InnoDB: !!!!!!!! UNIV_MEM_DEBUG switched on !!!!!!!!!\n");
1062
1048
#endif
1063
1049
 
1064
 
        if (UNIV_LIKELY(srv_use_sys_malloc))
1065
 
        {
1066
 
          drizzled::errmsg_printf(drizzled::error::ERROR, _("InnoDB: The InnoDB memory heap is disabled\n"));
1067
 
        }
1068
 
 
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
 
 
1079
 
 
1080
1050
        /* Since InnoDB does not currently clean up all its internal data
1081
1051
        structures in MySQL Embedded Server Library server_end(), we
1082
1052
        print an error message if someone tries to start up InnoDB a
1083
1053
        second time during the process lifetime. */
1084
1054
 
1085
1055
        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");
 
1056
                fprintf(stderr,
 
1057
                        "InnoDB: Error:startup called second time"
 
1058
                        " during the process lifetime.\n"
 
1059
                        "InnoDB: In the MySQL Embedded Server Library"
 
1060
                        " you cannot call server_init()\n"
 
1061
                        "InnoDB: more than once during"
 
1062
                        " the process lifetime.\n");
1088
1063
        }
1089
1064
 
1090
1065
        srv_start_has_been_called = TRUE;
1096
1071
 
1097
1072
        srv_is_being_started = TRUE;
1098
1073
        srv_startup_is_before_trx_rollback_phase = TRUE;
 
1074
        os_aio_use_native_aio = FALSE;
1099
1075
 
1100
1076
#ifdef __WIN__
1101
 
        switch (os_get_os_version()) {
1102
 
        case OS_WIN95:
1103
 
        case OS_WIN31:
1104
 
        case OS_WINNT:
 
1077
        if (os_get_os_version() == OS_WIN95
 
1078
            || os_get_os_version() == OS_WIN31
 
1079
            || os_get_os_version() == OS_WINNT) {
 
1080
 
1105
1081
                /* On Win 95, 98, ME, Win32 subsystem for Windows 3.1,
1106
1082
                and NT use simulated aio. In NT Windows provides async i/o,
1107
1083
                but when run in conjunction with InnoDB Hot Backup, it seemed
1108
1084
                to corrupt the data files. */
1109
1085
 
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
 
 
 
1086
                os_aio_use_native_aio = FALSE;
 
1087
        } else {
 
1088
                /* On Win 2000 and XP use async i/o */
 
1089
                os_aio_use_native_aio = TRUE;
 
1090
        }
1138
1091
#endif
1139
 
 
1140
1092
        if (srv_file_flush_method_str == NULL) {
1141
1093
                /* These are the default options */
1142
1094
 
1161
1113
#else
1162
1114
        } else if (0 == ut_strcmp(srv_file_flush_method_str, "normal")) {
1163
1115
                srv_win_file_flush_method = SRV_WIN_IO_NORMAL;
1164
 
                srv_use_native_aio = FALSE;
 
1116
                os_aio_use_native_aio = FALSE;
1165
1117
 
1166
1118
        } else if (0 == ut_strcmp(srv_file_flush_method_str, "unbuffered")) {
1167
1119
                srv_win_file_flush_method = SRV_WIN_IO_UNBUFFERED;
1168
 
                srv_use_native_aio = FALSE;
 
1120
                os_aio_use_native_aio = FALSE;
1169
1121
 
1170
1122
        } else if (0 == ut_strcmp(srv_file_flush_method_str,
1171
1123
                                  "async_unbuffered")) {
1172
1124
                srv_win_file_flush_method = SRV_WIN_IO_UNBUFFERED;
1173
1125
#endif
1174
1126
        } else {
1175
 
          drizzled::errmsg_printf(drizzled::error::ERROR,
1176
 
                                  "InnoDB: Unrecognized value %s for innodb_flush_method",
1177
 
                                  srv_file_flush_method_str);
 
1127
                fprintf(stderr,
 
1128
                        "InnoDB: Unrecognized value %s for"
 
1129
                        " innodb_flush_method\n",
 
1130
                        srv_file_flush_method_str);
1178
1131
                return(DB_ERROR);
1179
1132
        }
1180
1133
 
1186
1139
        maximum number of threads that can wait in the 'srv_conc array' for
1187
1140
        their time to enter InnoDB. */
1188
1141
 
 
1142
#if defined(__NETWARE__)
 
1143
 
 
1144
        /* Create less event semaphores because Win 98/ME had
 
1145
        difficulty creating 40000 event semaphores.  Comment from
 
1146
        Novell, Inc.: also, these just take a lot of memory on
 
1147
        NetWare. */
 
1148
        srv_max_n_threads = 1000;
 
1149
#else
1189
1150
        if (srv_buf_pool_size >= 1000 * 1024 * 1024) {
1190
1151
                /* If buffer pool is less than 1000 MB,
1191
 
                assume fewer threads. Also use only one
1192
 
                buffer pool instance */
 
1152
                assume fewer threads. */
1193
1153
                srv_max_n_threads = 50000;
1194
1154
 
1195
1155
        } else if (srv_buf_pool_size >= 8 * 1024 * 1024) {
1196
1156
 
1197
 
                srv_buf_pool_instances = 1;
1198
1157
                srv_max_n_threads = 10000;
1199
1158
        } else {
1200
 
                srv_buf_pool_instances = 1;
1201
1159
                srv_max_n_threads = 1000;       /* saves several MB of memory,
1202
1160
                                                especially in 64-bit
1203
1161
                                                computers */
1204
1162
        }
1205
 
 
 
1163
#endif
1206
1164
        err = srv_boot();
1207
1165
 
1208
1166
        if (err != DB_SUCCESS) {
1210
1168
                return((int) err);
1211
1169
        }
1212
1170
 
1213
 
        mutex_create(srv_monitor_file_mutex_key,
1214
 
                     &srv_monitor_file_mutex, SYNC_NO_ORDER_CHECK);
 
1171
        mutex_create(&srv_monitor_file_mutex, SYNC_NO_ORDER_CHECK);
1215
1172
 
1216
1173
        if (srv_innodb_status) {
1217
 
          srv_monitor_file_name = static_cast<char *>(mem_alloc(
 
1174
                srv_monitor_file_name = mem_alloc(
1218
1175
                        strlen(fil_path_to_mysql_datadir)
1219
 
                        + 20 + sizeof "/innodb_status."));
 
1176
                        + 20 + sizeof "/innodb_status.");
1220
1177
                sprintf(srv_monitor_file_name, "%s/innodb_status.%lu",
1221
1178
                        fil_path_to_mysql_datadir, os_proc_get_number());
1222
1179
                srv_monitor_file = fopen(srv_monitor_file_name, "w+");
1223
1180
                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));
 
1181
                        fprintf(stderr, "InnoDB: unable to create %s: %s\n",
 
1182
                                srv_monitor_file_name, strerror(errno));
1226
1183
                        return(DB_ERROR);
1227
1184
                }
1228
1185
        } else {
1233
1190
                }
1234
1191
        }
1235
1192
 
1236
 
        mutex_create(srv_dict_tmpfile_mutex_key,
1237
 
                     &srv_dict_tmpfile_mutex, SYNC_DICT_OPERATION);
 
1193
        mutex_create(&srv_dict_tmpfile_mutex, SYNC_DICT_OPERATION);
1238
1194
 
1239
1195
        srv_dict_tmpfile = os_file_create_tmpfile();
1240
1196
        if (!srv_dict_tmpfile) {
1241
1197
                return(DB_ERROR);
1242
1198
        }
1243
1199
 
1244
 
        mutex_create(srv_misc_tmpfile_mutex_key,
1245
 
                     &srv_misc_tmpfile_mutex, SYNC_ANY_LATCH);
 
1200
        mutex_create(&srv_misc_tmpfile_mutex, SYNC_ANY_LATCH);
1246
1201
 
1247
1202
        srv_misc_tmpfile = os_file_create_tmpfile();
1248
1203
        if (!srv_misc_tmpfile) {
1249
1204
                return(DB_ERROR);
1250
1205
        }
1251
1206
 
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);
 
1207
        /* Restrict the maximum number of file i/o threads */
 
1208
        if (srv_n_file_io_threads > SRV_MAX_N_IO_THREADS) {
 
1209
 
 
1210
                srv_n_file_io_threads = SRV_MAX_N_IO_THREADS;
 
1211
        }
 
1212
 
 
1213
        if (!os_aio_use_native_aio) {
 
1214
                /* In simulated aio we currently have use only for 4 threads */
 
1215
                srv_n_file_io_threads = 4;
 
1216
 
 
1217
                os_aio_init(8 * SRV_N_PENDING_IOS_PER_THREAD
 
1218
                            * srv_n_file_io_threads,
 
1219
                            srv_n_file_io_threads,
 
1220
                            SRV_MAX_N_PENDING_SYNC_IOS);
 
1221
        } else {
 
1222
                os_aio_init(SRV_N_PENDING_IOS_PER_THREAD
 
1223
                            * srv_n_file_io_threads,
 
1224
                            srv_n_file_io_threads,
 
1225
                            SRV_MAX_N_PENDING_SYNC_IOS);
 
1226
        }
 
1227
 
 
1228
        fil_init(srv_max_n_open_files);
 
1229
 
 
1230
        ret = buf_pool_init();
 
1231
 
 
1232
        if (ret == NULL) {
 
1233
                fprintf(stderr,
 
1234
                        "InnoDB: Fatal error: cannot allocate the memory"
 
1235
                        " for the buffer pool\n");
 
1236
 
 
1237
                return(DB_ERROR);
1296
1238
        }
1297
1239
 
1298
1240
#ifdef UNIV_DEBUG
1301
1243
 
1302
1244
        if (srv_buf_pool_size <= 5 * 1024 * 1024) {
1303
1245
 
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);
 
1246
                fprintf(stderr, "InnoDB: Warning: Small buffer pool size "
 
1247
                        "(%luM), the flst_validate() debug function "
 
1248
                        "can cause a deadlock if the buffer pool fills up.\n",
 
1249
                        srv_buf_pool_size / 1024 / 1024);
1308
1250
        }
1309
1251
#endif
1310
1252
 
1323
1265
 
1324
1266
#ifdef UNIV_LOG_ARCHIVE
1325
1267
        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.");
 
1268
                fprintf(stderr,
 
1269
                        "InnoDB: Error: you must set the log group"
 
1270
                        " home dir in my.cnf the\n"
 
1271
                        "InnoDB: same as log arch dir.\n");
1328
1272
 
1329
1273
                return(DB_ERROR);
1330
1274
        }
1331
1275
#endif /* UNIV_LOG_ARCHIVE */
1332
1276
 
1333
1277
        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");
 
1278
                fprintf(stderr,
 
1279
                        "InnoDB: Error: combined size of log files"
 
1280
                        " must be < 4 GB\n");
1336
1281
 
1337
1282
                return(DB_ERROR);
1338
1283
        }
1342
1287
        for (i = 0; i < srv_n_data_files; i++) {
1343
1288
#ifndef __WIN__
1344
1289
                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");
 
1290
                        fprintf(stderr,
 
1291
                                "InnoDB: Error: file size must be < 4 GB"
 
1292
                                " with this MySQL binary\n"
 
1293
                                "InnoDB: and operating system combination,"
 
1294
                                " in some OS's < 2 GB\n");
1348
1295
 
1349
1296
                        return(DB_ERROR);
1350
1297
                }
1352
1299
                sum_of_new_sizes += srv_data_file_sizes[i];
1353
1300
        }
1354
1301
 
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");
 
1302
        if (sum_of_new_sizes < 640) {
 
1303
                fprintf(stderr,
 
1304
                        "InnoDB: Error: tablespace size must be"
 
1305
                        " at least 10 MB\n");
1357
1306
 
1358
1307
                return(DB_ERROR);
1359
1308
        }
1365
1314
                                        &min_flushed_lsn, &max_flushed_lsn,
1366
1315
                                        &sum_of_new_sizes);
1367
1316
        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");
 
1317
                fprintf(stderr,
 
1318
                        "InnoDB: Could not open or create data files.\n"
 
1319
                        "InnoDB: If you tried to add new data files,"
 
1320
                        " and it failed here,\n"
 
1321
                        "InnoDB: you should now edit innodb_data_file_path"
 
1322
                        " in my.cnf back\n"
 
1323
                        "InnoDB: to what it was, and remove the"
 
1324
                        " new ibdata files InnoDB created\n"
 
1325
                        "InnoDB: in this failed attempt. InnoDB only wrote"
 
1326
                        " those files full of\n"
 
1327
                        "InnoDB: zeros, but did not yet use them in any way."
 
1328
                        " But be careful: do not\n"
 
1329
                        "InnoDB: remove old data files"
 
1330
                        " which contain your precious data!\n");
1376
1331
 
1377
1332
                return((int) err);
1378
1333
        }
1397
1352
                }
1398
1353
                if ((log_opened && create_new_db)
1399
1354
                    || (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"
 
1355
                        fprintf(stderr,
 
1356
                                "InnoDB: Error: all log files must be"
 
1357
                                " created at the same time.\n"
 
1358
                                "InnoDB: All log files must be"
 
1359
                                " created also in database creation.\n"
 
1360
                                "InnoDB: If you want bigger or smaller"
 
1361
                                " log files, shut down the\n"
 
1362
                                "InnoDB: database and make sure there"
 
1363
                                " were no errors in shutdown.\n"
 
1364
                                "InnoDB: Then delete the existing log files."
 
1365
                                " Edit the .cnf file\n"
1406
1366
                                "InnoDB: and start the database again.\n");
1407
1367
 
1408
1368
                        return(DB_ERROR);
1424
1384
                    || max_arch_log_no != min_arch_log_no
1425
1385
#endif /* UNIV_LOG_ARCHIVE */
1426
1386
                    ) {
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"
 
1387
                        fprintf(stderr,
 
1388
                                "InnoDB: Cannot initialize created"
 
1389
                                " log files because\n"
 
1390
                                "InnoDB: data files were not in sync"
 
1391
                                " with each other\n"
1430
1392
                                "InnoDB: or the data files are corrupt.\n");
1431
1393
 
1432
1394
                        return(DB_ERROR);
1433
1395
                }
1434
1396
 
1435
1397
                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");
 
1398
                        fprintf(stderr,
 
1399
                                "InnoDB: Cannot initialize created"
 
1400
                                " log files because\n"
 
1401
                                "InnoDB: data files are corrupt,"
 
1402
                                " or new data files were\n"
 
1403
                                "InnoDB: created when the database"
 
1404
                                " was started previous\n"
 
1405
                                "InnoDB: time but the database"
 
1406
                                " was not shut down\n"
 
1407
                                "InnoDB: normally after that.\n");
1442
1408
 
1443
1409
                        return(DB_ERROR);
1444
1410
                }
1460
1426
 
1461
1427
        if (create_new_db) {
1462
1428
                mtr_start(&mtr);
1463
 
 
1464
1429
                fsp_header_init(0, sum_of_new_sizes, &mtr);
1465
1430
 
1466
1431
                mtr_commit(&mtr);
1467
1432
 
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
1433
                trx_sys_create();
1473
 
 
1474
1434
                dict_create();
1475
 
 
1476
1435
                srv_startup_is_before_trx_rollback_phase = FALSE;
1477
1436
 
1478
1437
#ifdef UNIV_LOG_ARCHIVE
1479
1438
        } else if (srv_archive_recovery) {
1480
 
          drizzled::errmsg_printf(drizzled::error::INFO,
1481
 
                                  "InnoDB: Starting archive recovery from a backup...");
 
1439
                fprintf(stderr,
 
1440
                        "InnoDB: Starting archive"
 
1441
                        " recovery from a backup...\n");
1482
1442
                err = recv_recovery_from_archive_start(
1483
1443
                        min_flushed_lsn, srv_archive_recovery_limit_lsn,
1484
1444
                        min_arch_log_no);
1490
1450
                in any disk i/o, first call dict_boot */
1491
1451
 
1492
1452
                dict_boot();
1493
 
 
1494
1453
                trx_sys_init_at_db_start();
1495
 
 
1496
1454
                srv_startup_is_before_trx_rollback_phase = FALSE;
1497
1455
 
1498
1456
                /* Initialize the fsp free limit global variable in the log
1516
1474
                consistent state, this is REQUIRED for the recovery
1517
1475
                process to work. */
1518
1476
                err = trx_sys_file_format_max_check(
1519
 
                        srv_max_file_format_at_startup);
 
1477
                        srv_check_file_format_at_startup);
1520
1478
 
1521
1479
                if (err != DB_SUCCESS) {
1522
1480
                        return(err);
1550
1508
                dict_boot();
1551
1509
                trx_sys_init_at_db_start();
1552
1510
 
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
1511
                if (srv_force_recovery < SRV_FORCE_NO_IBUF_MERGE) {
1562
1512
                        /* The following call is necessary for the insert
1563
1513
                        buffer to work with multiple tablespaces. We must
1573
1523
                        every table in the InnoDB data dictionary that has
1574
1524
                        an .ibd file.
1575
1525
 
1576
 
                        We also determine the maximum tablespace id used. */
 
1526
                        We also determine the maximum tablespace id used.
 
1527
 
 
1528
                        TODO: We may have incomplete transactions in the
 
1529
                        data dictionary tables. Does that harm the scanning of
 
1530
                        the data dictionary below? */
1577
1531
 
1578
1532
                        dict_check_tablespaces_and_store_max_id(
1579
1533
                                recv_needed_recovery);
1580
1534
                }
1581
1535
 
1582
1536
                srv_startup_is_before_trx_rollback_phase = FALSE;
1583
 
                recv_recovery_rollback_active();
 
1537
 
 
1538
                /* Initialize the fsp free limit global variable in the log
 
1539
                system */
 
1540
                fsp_header_get_free_limit();
 
1541
 
 
1542
                /* recv_recovery_from_checkpoint_finish needs trx lists which
 
1543
                are initialized in trx_sys_init_at_db_start(). */
 
1544
 
 
1545
                recv_recovery_from_checkpoint_finish();
1584
1546
 
1585
1547
                /* It is possible that file_format tag has never
1586
1548
                been set. In this case we initialize it to minimum
1629
1591
        /* fprintf(stderr, "Max allowed record size %lu\n",
1630
1592
        page_get_free_space_of_empty() / 2); */
1631
1593
 
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,
 
1594
        /* Create the thread which watches the timeouts for lock waits
 
1595
        and prints InnoDB monitor info */
 
1596
 
 
1597
        os_thread_create(&srv_lock_timeout_and_monitor_thread, NULL,
1655
1598
                         thread_ids + 2 + SRV_MAX_N_IO_THREADS);
1656
1599
 
1657
1600
        /* Create the thread which warns of long semaphore waits */
1658
1601
        os_thread_create(&srv_error_monitor_thread, NULL,
1659
1602
                         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
1603
        srv_is_being_started = FALSE;
1666
1604
 
 
1605
        if (trx_doublewrite == NULL) {
 
1606
                /* Create the doublewrite buffer to a new tablespace */
 
1607
 
 
1608
                trx_sys_create_doublewrite_buf();
 
1609
        }
 
1610
 
1667
1611
        err = dict_create_or_check_foreign_constraint_tables();
1668
1612
 
1669
1613
        if (err != DB_SUCCESS) {
1675
1619
 
1676
1620
        os_thread_create(&srv_master_thread, NULL, thread_ids
1677
1621
                         + (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
1622
#ifdef UNIV_DEBUG
1689
1623
        /* buf_debug_prints = TRUE; */
1690
1624
#endif /* UNIV_DEBUG */
1699
1633
        if (!srv_auto_extend_last_data_file
1700
1634
            && sum_of_data_file_sizes != tablespace_size_in_header) {
1701
1635
 
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);
 
1636
                fprintf(stderr,
 
1637
                        "InnoDB: Error: tablespace size"
 
1638
                        " stored in header is %lu pages, but\n"
 
1639
                        "InnoDB: the sum of data file sizes is %lu pages\n",
 
1640
                        (ulong) tablespace_size_in_header,
 
1641
                        (ulong) sum_of_data_file_sizes);
1706
1642
 
1707
1643
                if (srv_force_recovery == 0
1708
1644
                    && sum_of_data_file_sizes < tablespace_size_in_header) {
1709
1645
                        /* This is a fatal error, the tail of a tablespace is
1710
1646
                        missing */
1711
1647
 
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.");
 
1648
                        fprintf(stderr,
 
1649
                                "InnoDB: Cannot start InnoDB."
 
1650
                                " The tail of the system tablespace is\n"
 
1651
                                "InnoDB: missing. Have you edited"
 
1652
                                " innodb_data_file_path in my.cnf in an\n"
 
1653
                                "InnoDB: inappropriate way, removing"
 
1654
                                " ibdata files from there?\n"
 
1655
                                "InnoDB: You can set innodb_force_recovery=1"
 
1656
                                " in my.cnf to force\n"
 
1657
                                "InnoDB: a startup if you are trying"
 
1658
                                " to recover a badly corrupt database.\n");
1718
1659
 
1719
1660
                        return(DB_ERROR);
1720
1661
                }
1723
1664
        if (srv_auto_extend_last_data_file
1724
1665
            && sum_of_data_file_sizes < tablespace_size_in_header) {
1725
1666
 
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);
 
1667
                fprintf(stderr,
 
1668
                        "InnoDB: Error: tablespace size stored in header"
 
1669
                        " is %lu pages, but\n"
 
1670
                        "InnoDB: the sum of data file sizes"
 
1671
                        " is only %lu pages\n",
 
1672
                        (ulong) tablespace_size_in_header,
 
1673
                        (ulong) sum_of_data_file_sizes);
1731
1674
 
1732
1675
                if (srv_force_recovery == 0) {
1733
1676
 
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");
 
1677
                        fprintf(stderr,
 
1678
                                "InnoDB: Cannot start InnoDB. The tail of"
 
1679
                                " the system tablespace is\n"
 
1680
                                "InnoDB: missing. Have you edited"
 
1681
                                " innodb_data_file_path in my.cnf in an\n"
 
1682
                                "InnoDB: inappropriate way, removing"
 
1683
                                " ibdata files from there?\n"
 
1684
                                "InnoDB: You can set innodb_force_recovery=1"
 
1685
                                " in my.cnf to force\n"
 
1686
                                "InnoDB: a startup if you are trying to"
 
1687
                                " recover a badly corrupt database.\n");
1740
1688
 
1741
1689
                        return(DB_ERROR);
1742
1690
                }
1746
1694
        os_fast_mutex_init(&srv_os_test_mutex);
1747
1695
 
1748
1696
        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");
 
1697
                fprintf(stderr,
 
1698
                        "InnoDB: Error: pthread_mutex_trylock returns"
 
1699
                        " an unexpected value on\n"
 
1700
                        "InnoDB: success! Cannot continue.\n");
1751
1701
                exit(1);
1752
1702
        }
1753
1703
 
1760
1710
        os_fast_mutex_free(&srv_os_test_mutex);
1761
1711
 
1762
1712
        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);
 
1713
                ut_print_timestamp(stderr);
 
1714
                fprintf(stderr,
 
1715
                        " InnoDB Plugin %s started; "
 
1716
                        "log sequence number %"PRIu64"\n",
 
1717
                        INNODB_VERSION_STR, srv_start_lsn);
1766
1718
        }
1767
1719
 
1768
1720
        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);
 
1721
                fprintf(stderr,
 
1722
                        "InnoDB: !!! innodb_force_recovery"
 
1723
                        " is set to %lu !!!\n",
 
1724
                        (ulong) srv_force_recovery);
1772
1725
        }
1773
1726
 
 
1727
        fflush(stderr);
 
1728
 
1774
1729
        if (trx_doublewrite_must_reset_space_ids) {
1775
1730
                /* Actually, we did not change the undo log format between
1776
1731
                4.0 and 4.1.1, and we would not need to run purge to
1785
1740
                4.1.1. It is essential that the insert buffer is emptied
1786
1741
                here! */
1787
1742
 
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...");
 
1743
                fprintf(stderr,
 
1744
                        "InnoDB: You are upgrading to an"
 
1745
                        " InnoDB version which allows multiple\n"
 
1746
                        "InnoDB: tablespaces. Wait that purge"
 
1747
                        " and insert buffer merge run to\n"
 
1748
                        "InnoDB: completion...\n");
1791
1749
                for (;;) {
1792
1750
                        os_thread_sleep(1000000);
1793
1751
 
1799
1757
                                break;
1800
1758
                        }
1801
1759
                }
1802
 
                drizzled::errmsg_printf(drizzled::error::INFO,
1803
 
                                        "InnoDB: Full purge and insert buffer merge completed.");
 
1760
                fprintf(stderr,
 
1761
                        "InnoDB: Full purge and insert buffer merge"
 
1762
                        " completed.\n");
1804
1763
 
1805
1764
                trx_sys_mark_upgraded_to_multiple_tablespaces();
1806
1765
 
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");
 
1766
                fprintf(stderr,
 
1767
                        "InnoDB: You have now successfully upgraded"
 
1768
                        " to the multiple tablespaces\n"
 
1769
                        "InnoDB: format. You should NOT DOWNGRADE"
 
1770
                        " to an earlier version of\n"
 
1771
                        "InnoDB: InnoDB! But if you absolutely need to"
 
1772
                        " downgrade, see\n"
 
1773
                        "InnoDB: http://dev.mysql.com/doc/refman/5.1/en/"
 
1774
                        "multiple-tablespaces.html\n"
 
1775
                        "InnoDB: for instructions.\n");
1816
1776
        }
1817
1777
 
1818
1778
        if (srv_force_recovery == 0) {
1831
1791
        return((int) DB_SUCCESS);
1832
1792
}
1833
1793
 
1834
 
/****************************************************************//**
1835
 
Shuts down the InnoDB database.
1836
 
@return DB_SUCCESS or error code */
 
1794
/********************************************************************
 
1795
Shuts down the InnoDB database. */
1837
1796
UNIV_INTERN
1838
1797
int
1839
1798
innobase_shutdown_for_mysql(void)
1840
1799
/*=============================*/
 
1800
                                /* out: DB_SUCCESS or error code */
1841
1801
{
1842
1802
        ulint   i;
 
1803
#ifdef __NETWARE__
 
1804
        extern ibool panic_shutdown;
 
1805
#endif
1843
1806
        if (!srv_was_started) {
1844
1807
                if (srv_is_being_started) {
1845
 
                  drizzled::errmsg_printf(drizzled::error::ERROR,
1846
 
                                "InnoDB: Warning: shutting down a not properly started or created database!");
 
1808
                        ut_print_timestamp(stderr);
 
1809
                        fprintf(stderr,
 
1810
                                "  InnoDB: Warning: shutting down"
 
1811
                                " a not properly started\n"
 
1812
                                "InnoDB: or created database!\n");
1847
1813
                }
1848
1814
 
1849
1815
                return(DB_SUCCESS);
1856
1822
 
1857
1823
 
1858
1824
        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!");
 
1825
                ut_print_timestamp(stderr);
 
1826
                fprintf(stderr,
 
1827
                        "  InnoDB: MySQL has requested a very fast shutdown"
 
1828
                        " without flushing "
 
1829
                        "the InnoDB buffer pool to data files."
 
1830
                        " At the next mysqld startup "
 
1831
                        "InnoDB will do a crash recovery!\n");
1863
1832
        }
1864
1833
 
1865
 
        logs_empty_and_mark_files_at_shutdown();
 
1834
#ifdef __NETWARE__
 
1835
        if(!panic_shutdown)
 
1836
#endif
 
1837
                logs_empty_and_mark_files_at_shutdown();
1866
1838
 
1867
1839
        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);
 
1840
                fprintf(stderr,
 
1841
                        "InnoDB: Warning: query counter shows %ld queries"
 
1842
                        " still\n"
 
1843
                        "InnoDB: inside InnoDB at shutdown\n",
 
1844
                        srv_conc_n_threads);
1871
1845
        }
1872
1846
 
1873
1847
        /* 2. Make all threads created by InnoDB to exit */
1899
1873
                /* c. We wake the master thread so that it exits */
1900
1874
                srv_wake_master_thread();
1901
1875
 
1902
 
                /* d. We wake the purge thread so that it exits */
1903
 
                srv_wake_purge_thread();
1904
 
 
1905
 
                /* e. Exit the i/o threads */
 
1876
                /* d. Exit the i/o threads */
1906
1877
 
1907
1878
                os_aio_wake_all_threads_at_shutdown();
1908
1879
 
1912
1883
                        /* All the threads have exited or are just exiting;
1913
1884
                        NOTE that the threads may not have completed their
1914
1885
                        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! */
 
1886
                        they have exited? Now we just sleep 0.1 seconds and
 
1887
                        hope that is enough! */
1919
1888
 
1920
1889
                        os_mutex_exit(os_sync_mutex);
1921
1890
 
1930
1899
        }
1931
1900
 
1932
1901
        if (i == 1000) {
1933
 
          drizzled::errmsg_printf(drizzled::error::WARN,
1934
 
                        "InnoDB: Warning: %lu threads created by InnoDB had not exited at shutdown!",
 
1902
                fprintf(stderr,
 
1903
                        "InnoDB: Warning: %lu threads created by InnoDB"
 
1904
                        " had not exited at shutdown!\n",
1935
1905
                        (ulong) os_thread_count);
1936
1906
        }
1937
1907
 
1953
1923
                srv_misc_tmpfile = 0;
1954
1924
        }
1955
1925
 
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
1926
        trx_sys_file_format_close();
1965
 
        trx_sys_close();
1966
1927
 
1967
1928
        mutex_free(&srv_monitor_file_mutex);
1968
1929
        mutex_free(&srv_dict_tmpfile_mutex);
1969
1930
        mutex_free(&srv_misc_tmpfile_mutex);
1970
 
        dict_close();
1971
 
        btr_search_sys_free();
1972
1931
 
1973
1932
        /* 3. Free all InnoDB's own mutexes and the os_fast_mutexes inside
1974
1933
        them */
1975
 
        os_aio_free();
1976
1934
        sync_close();
 
1935
 
 
1936
        /* 4. Free the os_conc_mutex and all os_events and os_mutexes */
 
1937
 
1977
1938
        srv_free();
1978
 
        fil_close();
1979
 
 
1980
 
        /* 4. Free the os_conc_mutex and all os_events and os_mutexes */
1981
 
 
1982
1939
        os_sync_free();
1983
1940
 
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 */
 
1941
        /* Check that all read views are closed except read view owned
 
1942
        by a purge. */
 
1943
 
 
1944
        if (UT_LIST_GET_LEN(trx_sys->view_list) > 1) {
 
1945
                fprintf(stderr,
 
1946
                        "InnoDB: Error: all read views were not closed"
 
1947
                        " before shutdown:\n"
 
1948
                        "InnoDB: %lu read views open \n",
 
1949
                        UT_LIST_GET_LEN(trx_sys->view_list) - 1);
 
1950
        }
 
1951
 
 
1952
        /* 5. Free all allocated memory and the os_fast_mutex created in
 
1953
        ut0mem.c */
 
1954
 
 
1955
        buf_pool_free();
1994
1956
        ut_free_all_mem();
1995
1957
 
1996
1958
        if (os_thread_count != 0
1997
1959
            || os_event_count != 0
1998
1960
            || os_mutex_count != 0
1999
1961
            || 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);
 
1962
                fprintf(stderr,
 
1963
                        "InnoDB: Warning: some resources were not"
 
1964
                        " cleaned up in shutdown:\n"
 
1965
                        "InnoDB: threads %lu, events %lu,"
 
1966
                        " os_mutexes %lu, os_fast_mutexes %lu\n",
 
1967
                        (ulong) os_thread_count, (ulong) os_event_count,
 
1968
                        (ulong) os_mutex_count, (ulong) os_fast_mutex_count);
2005
1969
        }
2006
1970
 
2007
1971
        if (dict_foreign_err_file) {
2012
1976
        }
2013
1977
 
2014
1978
        if (srv_print_verbose_log) {
2015
 
                drizzled::errmsg_printf(drizzled::error::INFO,
2016
 
                                        "InnoDB: Shutdown completed log sequence number %"PRIu64,
2017
 
                                        srv_shutdown_lsn);
 
1979
                ut_print_timestamp(stderr);
 
1980
                fprintf(stderr,
 
1981
                        "  InnoDB: Shutdown completed;"
 
1982
                        " log sequence number %"PRIu64"\n",
 
1983
                        srv_shutdown_lsn);
2018
1984
        }
2019
1985
 
2020
1986
        srv_was_started = FALSE;
2021
 
        srv_start_has_been_called = FALSE;
2022
1987
 
2023
1988
        return((int) DB_SUCCESS);
2024
1989
}
 
1990
 
 
1991
#ifdef __NETWARE__
 
1992
void set_panic_flag_for_netware()
 
1993
{
 
1994
        extern ibool panic_shutdown;
 
1995
        panic_shutdown = TRUE;
 
1996
}
 
1997
#endif /* __NETWARE__ */
2025
1998
#endif /* !UNIV_HOTBACKUP */