← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

  • Committer: Stewart Smith
  • Author(s): Marko Mäkelä
  • Date: 2010-12-20 03:21:44 UTC
  • mto: (2021.1.2 build)
  • mto: This revision was merged to the branch mainline in revision 2022.
  • Revision ID: stewart@flamingspork.com-20101220032144-7aqh2z403u7d7bdp
Merge Revision revid:marko.makela@oracle.com-20101104131215-pfxnpidlrzd4krg0 from MySQL InnoDB

Original revid:marko.makela@oracle.com-20101104131215-pfxnpidlrzd4krg0

Original Authors: Marko Mäkelä <marko.makela@oracle.com>
Original commit message:
row_ins_index_entry(): Note that only CREATE INDEX sets foreign=FALSE.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/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
 
36
Starts the InnoDB database server
 
37
 
 
38
Created 2/16/1996 Heikki Tuuri
 
39
*************************************************************************/
 
40
 
 
41
#include "ut0mem.h"
 
42
#include "mem0mem.h"
 
43
#include "data0data.h"
 
44
#include "data0type.h"
 
45
#include "dict0dict.h"
 
46
#include "buf0buf.h"
 
47
#include "os0file.h"
 
48
#include "os0thread.h"
 
49
#include "fil0fil.h"
 
50
#include "fsp0fsp.h"
 
51
#include "rem0rec.h"
 
52
#include "mtr0mtr.h"
 
53
#include "log0log.h"
 
54
#include "log0recv.h"
 
55
#include "page0page.h"
 
56
#include "page0cur.h"
 
57
#include "trx0trx.h"
 
58
#include "trx0sys.h"
 
59
#include "btr0btr.h"
 
60
#include "btr0cur.h"
 
61
#include "rem0rec.h"
 
62
#include "ibuf0ibuf.h"
 
63
#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
/** Log sequence number immediately after startup */
 
96
UNIV_INTERN ib_uint64_t srv_start_lsn;
 
97
/** Log sequence number at shutdown */
 
98
UNIV_INTERN ib_uint64_t srv_shutdown_lsn;
 
99
 
 
100
#ifdef HAVE_DARWIN_THREADS
 
101
# include <sys/utsname.h>
 
102
/** TRUE if the F_FULLFSYNC option is available */
 
103
UNIV_INTERN ibool       srv_have_fullfsync = FALSE;
 
104
#endif
 
105
 
 
106
/** TRUE if a raw partition is in use */
 
107
UNIV_INTERN ibool       srv_start_raw_disk_in_use = FALSE;
 
108
 
 
109
/** TRUE if the server is being started, before rolling back any
 
110
incomplete transactions */
 
111
UNIV_INTERN ibool       srv_startup_is_before_trx_rollback_phase = FALSE;
 
112
/** TRUE if the server is being started */
 
113
UNIV_INTERN ibool       srv_is_being_started = FALSE;
 
114
/** TRUE if the server was successfully started */
 
115
UNIV_INTERN ibool       srv_was_started = FALSE;
 
116
/** TRUE if innobase_start_or_create_for_mysql() has been called */
 
117
static ibool    srv_start_has_been_called = FALSE;
 
118
 
 
119
/** At a shutdown this value climbs from SRV_SHUTDOWN_NONE to
 
120
SRV_SHUTDOWN_CLEANUP and then to SRV_SHUTDOWN_LAST_PHASE, and so on */
 
121
UNIV_INTERN enum srv_shutdown_state     srv_shutdown_state = SRV_SHUTDOWN_NONE;
 
122
 
 
123
/** Files comprising the system tablespace */
 
124
static os_file_t        files[1000];
 
125
 
 
126
/** io_handler_thread parameters for thread identification */
 
127
static ulint            n[SRV_MAX_N_IO_THREADS + 6];
 
128
/** io_handler_thread identifiers */
 
129
static os_thread_id_t   thread_ids[SRV_MAX_N_IO_THREADS + 6];
 
130
 
 
131
/** We use this mutex to test the return value of pthread_mutex_trylock
 
132
   on successful locking. HP-UX does NOT return 0, though Linux et al do. */
 
133
static os_fast_mutex_t  srv_os_test_mutex;
 
134
 
 
135
/** Name of srv_monitor_file */
 
136
static char*    srv_monitor_file_name;
 
137
#endif /* !UNIV_HOTBACKUP */
 
138
 
 
139
/** */
 
140
#define SRV_N_PENDING_IOS_PER_THREAD    OS_AIO_N_PENDING_IOS_PER_THREAD
 
141
#define SRV_MAX_N_PENDING_SYNC_IOS      100
 
142
 
 
143
#ifdef UNIV_PFS_THREAD
 
144
/* Keys to register InnoDB threads with performance schema */
 
145
UNIV_INTERN mysql_pfs_key_t     io_handler_thread_key;
 
146
UNIV_INTERN mysql_pfs_key_t     srv_lock_timeout_thread_key;
 
147
UNIV_INTERN mysql_pfs_key_t     srv_error_monitor_thread_key;
 
148
UNIV_INTERN mysql_pfs_key_t     srv_monitor_thread_key;
 
149
UNIV_INTERN mysql_pfs_key_t     srv_master_thread_key;
 
150
#endif /* UNIV_PFS_THREAD */
 
151
 
 
152
/*********************************************************************//**
 
153
Convert a numeric string that optionally ends in G or M, to a number
 
154
containing megabytes.
 
155
@return next character in string */
 
156
static
 
157
char*
 
158
srv_parse_megabytes(
 
159
/*================*/
 
160
        char*   str,    /*!< in: string containing a quantity in bytes */
 
161
        ulint*  megs)   /*!< out: the number in megabytes */
 
162
{
 
163
        char*   endp;
 
164
        ulint   size;
 
165
 
 
166
        size = strtoul(str, &endp, 10);
 
167
 
 
168
        str = endp;
 
169
 
 
170
        switch (*str) {
 
171
        case 'G': case 'g':
 
172
                size *= 1024;
 
173
                /* fall through */
 
174
        case 'M': case 'm':
 
175
                str++;
 
176
                break;
 
177
        default:
 
178
                size /= 1024 * 1024;
 
179
                break;
 
180
        }
 
181
 
 
182
        *megs = size;
 
183
        return(str);
 
184
}
 
185
 
 
186
/*********************************************************************//**
 
187
Reads the data files and their sizes from a character string given in
 
188
the .cnf file.
 
189
@return TRUE if ok, FALSE on parse error */
 
190
UNIV_INTERN
 
191
ibool
 
192
srv_parse_data_file_paths_and_sizes(
 
193
/*================================*/
 
194
        char*   str)    /*!< in/out: the data file path string */
 
195
{
 
196
        char*   input_str;
 
197
        char*   path;
 
198
        ulint   size;
 
199
        ulint   i       = 0;
 
200
 
 
201
        srv_auto_extend_last_data_file = FALSE;
 
202
        srv_last_file_size_max = 0;
 
203
        srv_data_file_names = NULL;
 
204
        srv_data_file_sizes = NULL;
 
205
        srv_data_file_is_raw_partition = NULL;
 
206
 
 
207
        input_str = str;
 
208
 
 
209
        /* First calculate the number of data files and check syntax:
 
210
        path:size[M | G];path:size[M | G]... . Note that a Windows path may
 
211
        contain a drive name and a ':'. */
 
212
 
 
213
        while (*str != '\0') {
 
214
                path = str;
 
215
 
 
216
                while ((*str != ':' && *str != '\0')
 
217
                       || (*str == ':'
 
218
                           && (*(str + 1) == '\\' || *(str + 1) == '/'
 
219
                               || *(str + 1) == ':'))) {
 
220
                        str++;
 
221
                }
 
222
 
 
223
                if (*str == '\0') {
 
224
                        return(FALSE);
 
225
                }
 
226
 
 
227
                str++;
 
228
 
 
229
                str = srv_parse_megabytes(str, &size);
 
230
 
 
231
                if (0 == strncmp(str, ":autoextend",
 
232
                                 (sizeof ":autoextend") - 1)) {
 
233
 
 
234
                        str += (sizeof ":autoextend") - 1;
 
235
 
 
236
                        if (0 == strncmp(str, ":max:",
 
237
                                         (sizeof ":max:") - 1)) {
 
238
 
 
239
                                str += (sizeof ":max:") - 1;
 
240
 
 
241
                                str = srv_parse_megabytes(str, &size);
 
242
                        }
 
243
 
 
244
                        if (*str != '\0') {
 
245
 
 
246
                                return(FALSE);
 
247
                        }
 
248
                }
 
249
 
 
250
                if (strlen(str) >= 6
 
251
                    && *str == 'n'
 
252
                    && *(str + 1) == 'e'
 
253
                    && *(str + 2) == 'w') {
 
254
                        str += 3;
 
255
                }
 
256
 
 
257
                if (*str == 'r' && *(str + 1) == 'a' && *(str + 2) == 'w') {
 
258
                        str += 3;
 
259
                }
 
260
 
 
261
                if (size == 0) {
 
262
                        return(FALSE);
 
263
                }
 
264
 
 
265
                i++;
 
266
 
 
267
                if (*str == ';') {
 
268
                        str++;
 
269
                } else if (*str != '\0') {
 
270
 
 
271
                        return(FALSE);
 
272
                }
 
273
        }
 
274
 
 
275
        if (i == 0) {
 
276
                /* If innodb_data_file_path was defined it must contain
 
277
                at least one data file definition */
 
278
 
 
279
                return(FALSE);
 
280
        }
 
281
 
 
282
        srv_data_file_names = malloc(i * sizeof *srv_data_file_names);
 
283
        srv_data_file_sizes = malloc(i * sizeof *srv_data_file_sizes);
 
284
        srv_data_file_is_raw_partition = malloc(
 
285
                i * sizeof *srv_data_file_is_raw_partition);
 
286
 
 
287
        srv_n_data_files = i;
 
288
 
 
289
        /* Then store the actual values to our arrays */
 
290
 
 
291
        str = input_str;
 
292
        i = 0;
 
293
 
 
294
        while (*str != '\0') {
 
295
                path = str;
 
296
 
 
297
                /* Note that we must step over the ':' in a Windows path;
 
298
                a Windows path normally looks like C:\ibdata\ibdata1:1G, but
 
299
                a Windows raw partition may have a specification like
 
300
                \\.\C::1Gnewraw or \\.\PHYSICALDRIVE2:1Gnewraw */
 
301
 
 
302
                while ((*str != ':' && *str != '\0')
 
303
                       || (*str == ':'
 
304
                           && (*(str + 1) == '\\' || *(str + 1) == '/'
 
305
                               || *(str + 1) == ':'))) {
 
306
                        str++;
 
307
                }
 
308
 
 
309
                if (*str == ':') {
 
310
                        /* Make path a null-terminated string */
 
311
                        *str = '\0';
 
312
                        str++;
 
313
                }
 
314
 
 
315
                str = srv_parse_megabytes(str, &size);
 
316
 
 
317
                srv_data_file_names[i] = path;
 
318
                srv_data_file_sizes[i] = size;
 
319
 
 
320
                if (0 == strncmp(str, ":autoextend",
 
321
                                 (sizeof ":autoextend") - 1)) {
 
322
 
 
323
                        srv_auto_extend_last_data_file = TRUE;
 
324
 
 
325
                        str += (sizeof ":autoextend") - 1;
 
326
 
 
327
                        if (0 == strncmp(str, ":max:",
 
328
                                         (sizeof ":max:") - 1)) {
 
329
 
 
330
                                str += (sizeof ":max:") - 1;
 
331
 
 
332
                                str = srv_parse_megabytes(
 
333
                                        str, &srv_last_file_size_max);
 
334
                        }
 
335
 
 
336
                        if (*str != '\0') {
 
337
 
 
338
                                return(FALSE);
 
339
                        }
 
340
                }
 
341
 
 
342
                (srv_data_file_is_raw_partition)[i] = 0;
 
343
 
 
344
                if (strlen(str) >= 6
 
345
                    && *str == 'n'
 
346
                    && *(str + 1) == 'e'
 
347
                    && *(str + 2) == 'w') {
 
348
                        str += 3;
 
349
                        (srv_data_file_is_raw_partition)[i] = SRV_NEW_RAW;
 
350
                }
 
351
 
 
352
                if (*str == 'r' && *(str + 1) == 'a' && *(str + 2) == 'w') {
 
353
                        str += 3;
 
354
 
 
355
                        if ((srv_data_file_is_raw_partition)[i] == 0) {
 
356
                                (srv_data_file_is_raw_partition)[i] = SRV_OLD_RAW;
 
357
                        }
 
358
                }
 
359
 
 
360
                i++;
 
361
 
 
362
                if (*str == ';') {
 
363
                        str++;
 
364
                }
 
365
        }
 
366
 
 
367
        return(TRUE);
 
368
}
 
369
 
 
370
/*********************************************************************//**
 
371
Reads log group home directories from a character string given in
 
372
the .cnf file.
 
373
@return TRUE if ok, FALSE on parse error */
 
374
UNIV_INTERN
 
375
ibool
 
376
srv_parse_log_group_home_dirs(
 
377
/*==========================*/
 
378
        char*   str)    /*!< in/out: character string */
 
379
{
 
380
        char*   input_str;
 
381
        char*   path;
 
382
        ulint   i       = 0;
 
383
 
 
384
        srv_log_group_home_dirs = NULL;
 
385
 
 
386
        input_str = str;
 
387
 
 
388
        /* First calculate the number of directories and check syntax:
 
389
        path;path;... */
 
390
 
 
391
        while (*str != '\0') {
 
392
                path = str;
 
393
 
 
394
                while (*str != ';' && *str != '\0') {
 
395
                        str++;
 
396
                }
 
397
 
 
398
                i++;
 
399
 
 
400
                if (*str == ';') {
 
401
                        str++;
 
402
                } else if (*str != '\0') {
 
403
 
 
404
                        return(FALSE);
 
405
                }
 
406
        }
 
407
 
 
408
        if (i != 1) {
 
409
                /* If innodb_log_group_home_dir was defined it must
 
410
                contain exactly one path definition under current MySQL */
 
411
 
 
412
                return(FALSE);
 
413
        }
 
414
 
 
415
        srv_log_group_home_dirs = malloc(i * sizeof *srv_log_group_home_dirs);
 
416
 
 
417
        /* Then store the actual values to our array */
 
418
 
 
419
        str = input_str;
 
420
        i = 0;
 
421
 
 
422
        while (*str != '\0') {
 
423
                path = str;
 
424
 
 
425
                while (*str != ';' && *str != '\0') {
 
426
                        str++;
 
427
                }
 
428
 
 
429
                if (*str == ';') {
 
430
                        *str = '\0';
 
431
                        str++;
 
432
                }
 
433
 
 
434
                srv_log_group_home_dirs[i] = path;
 
435
 
 
436
                i++;
 
437
        }
 
438
 
 
439
        return(TRUE);
 
440
}
 
441
 
 
442
/*********************************************************************//**
 
443
Frees the memory allocated by srv_parse_data_file_paths_and_sizes()
 
444
and srv_parse_log_group_home_dirs(). */
 
445
UNIV_INTERN
 
446
void
 
447
srv_free_paths_and_sizes(void)
 
448
/*==========================*/
 
449
{
 
450
        free(srv_data_file_names);
 
451
        srv_data_file_names = NULL;
 
452
        free(srv_data_file_sizes);
 
453
        srv_data_file_sizes = NULL;
 
454
        free(srv_data_file_is_raw_partition);
 
455
        srv_data_file_is_raw_partition = NULL;
 
456
        free(srv_log_group_home_dirs);
 
457
        srv_log_group_home_dirs = NULL;
 
458
}
 
459
 
 
460
#ifndef UNIV_HOTBACKUP
 
461
/********************************************************************//**
 
462
I/o-handler thread function.
 
463
@return OS_THREAD_DUMMY_RETURN */
 
464
static
 
465
os_thread_ret_t
 
466
io_handler_thread(
 
467
/*==============*/
 
468
        void*   arg)    /*!< in: pointer to the number of the segment in
 
469
                        the aio array */
 
470
{
 
471
        ulint   segment;
 
472
 
 
473
        segment = *((ulint*)arg);
 
474
 
 
475
#ifdef UNIV_DEBUG_THREAD_CREATION
 
476
        fprintf(stderr, "Io handler thread %lu starts, id %lu\n", segment,
 
477
                os_thread_pf(os_thread_get_curr_id()));
 
478
#endif
 
479
 
 
480
#ifdef UNIV_PFS_THREAD
 
481
        pfs_register_thread(io_handler_thread_key);
 
482
#endif /* UNIV_PFS_THREAD */
 
483
 
 
484
        while (srv_shutdown_state != SRV_SHUTDOWN_EXIT_THREADS) {
 
485
                fil_aio_wait(segment);
 
486
        }
 
487
 
 
488
        /* We count the number of threads in os_thread_exit(). A created
 
489
        thread should always use that to exit and not use return() to exit.
 
490
        The thread actually never comes here because it is exited in an
 
491
        os_event_wait(). */
 
492
        return 0;
 
493
}
 
494
#endif /* !UNIV_HOTBACKUP */
 
495
 
 
496
#ifdef __WIN__
 
497
#define SRV_PATH_SEPARATOR      '\\'
 
498
#else
 
499
#define SRV_PATH_SEPARATOR      '/'
 
500
#endif
 
501
 
 
502
/*********************************************************************//**
 
503
Normalizes a directory path for Windows: converts slashes to backslashes. */
 
504
UNIV_INTERN
 
505
void
 
506
srv_normalize_path_for_win(
 
507
/*=======================*/
 
508
        char*   str __attribute__((unused)))    /*!< in/out: null-terminated
 
509
                                                character string */
 
510
{
 
511
#ifdef __WIN__
 
512
        for (; *str; str++) {
 
513
 
 
514
                if (*str == '/') {
 
515
                        *str = '\\';
 
516
                }
 
517
        }
 
518
#endif
 
519
}
 
520
 
 
521
#ifndef UNIV_HOTBACKUP
 
522
/*********************************************************************//**
 
523
Calculates the low 32 bits when a file size which is given as a number
 
524
database pages is converted to the number of bytes.
 
525
@return low 32 bytes of file size when expressed in bytes */
 
526
static
 
527
ulint
 
528
srv_calc_low32(
 
529
/*===========*/
 
530
        ulint   file_size)      /*!< in: file size in database pages */
 
531
{
 
532
        return(0xFFFFFFFFUL & (file_size << UNIV_PAGE_SIZE_SHIFT));
 
533
}
 
534
 
 
535
/*********************************************************************//**
 
536
Calculates the high 32 bits when a file size which is given as a number
 
537
database pages is converted to the number of bytes.
 
538
@return high 32 bytes of file size when expressed in bytes */
 
539
static
 
540
ulint
 
541
srv_calc_high32(
 
542
/*============*/
 
543
        ulint   file_size)      /*!< in: file size in database pages */
 
544
{
 
545
        return(file_size >> (32 - UNIV_PAGE_SIZE_SHIFT));
 
546
}
 
547
 
 
548
/*********************************************************************//**
 
549
Creates or opens the log files and closes them.
 
550
@return DB_SUCCESS or error code */
 
551
static
 
552
ulint
 
553
open_or_create_log_file(
 
554
/*====================*/
 
555
        ibool   create_new_db,          /*!< in: TRUE if we should create a
 
556
                                        new database */
 
557
        ibool*  log_file_created,       /*!< out: TRUE if new log file
 
558
                                        created */
 
559
        ibool   log_file_has_been_opened,/*!< in: TRUE if a log file has been
 
560
                                        opened before: then it is an error
 
561
                                        to try to create another log file */
 
562
        ulint   k,                      /*!< in: log group number */
 
563
        ulint   i)                      /*!< in: log file number in group */
 
564
{
 
565
        ibool   ret;
 
566
        ulint   size;
 
567
        ulint   size_high;
 
568
        char    name[10000];
 
569
        ulint   dirnamelen;
 
570
 
 
571
        UT_NOT_USED(create_new_db);
 
572
 
 
573
        *log_file_created = FALSE;
 
574
 
 
575
        srv_normalize_path_for_win(srv_log_group_home_dirs[k]);
 
576
 
 
577
        dirnamelen = strlen(srv_log_group_home_dirs[k]);
 
578
        ut_a(dirnamelen < (sizeof name) - 10 - sizeof "ib_logfile");
 
579
        memcpy(name, srv_log_group_home_dirs[k], dirnamelen);
 
580
 
 
581
        /* Add a path separator if needed. */
 
582
        if (dirnamelen && name[dirnamelen - 1] != SRV_PATH_SEPARATOR) {
 
583
                name[dirnamelen++] = SRV_PATH_SEPARATOR;
 
584
        }
 
585
 
 
586
        sprintf(name + dirnamelen, "%s%lu", "ib_logfile", (ulong) i);
 
587
 
 
588
        files[i] = os_file_create(innodb_file_log_key, name,
 
589
                                  OS_FILE_CREATE, OS_FILE_NORMAL,
 
590
                                  OS_LOG_FILE, &ret);
 
591
        if (ret == FALSE) {
 
592
                if (os_file_get_last_error(FALSE) != OS_FILE_ALREADY_EXISTS
 
593
#ifdef UNIV_AIX
 
594
                    /* AIX 5.1 after security patch ML7 may have errno set
 
595
                    to 0 here, which causes our function to return 100;
 
596
                    work around that AIX problem */
 
597
                    && os_file_get_last_error(FALSE) != 100
 
598
#endif
 
599
                    ) {
 
600
                        fprintf(stderr,
 
601
                                "InnoDB: Error in creating"
 
602
                                " or opening %s\n", name);
 
603
 
 
604
                        return(DB_ERROR);
 
605
                }
 
606
 
 
607
                files[i] = os_file_create(innodb_file_log_key, name,
 
608
                                          OS_FILE_OPEN, OS_FILE_AIO,
 
609
                                          OS_LOG_FILE, &ret);
 
610
                if (!ret) {
 
611
                        fprintf(stderr,
 
612
                                "InnoDB: Error in opening %s\n", name);
 
613
 
 
614
                        return(DB_ERROR);
 
615
                }
 
616
 
 
617
                ret = os_file_get_size(files[i], &size, &size_high);
 
618
                ut_a(ret);
 
619
 
 
620
                if (size != srv_calc_low32(srv_log_file_size)
 
621
                    || size_high != srv_calc_high32(srv_log_file_size)) {
 
622
 
 
623
                        fprintf(stderr,
 
624
                                "InnoDB: Error: log file %s is"
 
625
                                " of different size %lu %lu bytes\n"
 
626
                                "InnoDB: than specified in the .cnf"
 
627
                                " file %lu %lu bytes!\n",
 
628
                                name, (ulong) size_high, (ulong) size,
 
629
                                (ulong) srv_calc_high32(srv_log_file_size),
 
630
                                (ulong) srv_calc_low32(srv_log_file_size));
 
631
 
 
632
                        return(DB_ERROR);
 
633
                }
 
634
        } else {
 
635
                *log_file_created = TRUE;
 
636
 
 
637
                ut_print_timestamp(stderr);
 
638
 
 
639
                fprintf(stderr,
 
640
                        "  InnoDB: Log file %s did not exist:"
 
641
                        " new to be created\n",
 
642
                        name);
 
643
                if (log_file_has_been_opened) {
 
644
 
 
645
                        return(DB_ERROR);
 
646
                }
 
647
 
 
648
                fprintf(stderr, "InnoDB: Setting log file %s size to %lu MB\n",
 
649
                        name, (ulong) srv_log_file_size
 
650
                        >> (20 - UNIV_PAGE_SIZE_SHIFT));
 
651
 
 
652
                fprintf(stderr,
 
653
                        "InnoDB: Database physically writes the file"
 
654
                        " full: wait...\n");
 
655
 
 
656
                ret = os_file_set_size(name, files[i],
 
657
                                       srv_calc_low32(srv_log_file_size),
 
658
                                       srv_calc_high32(srv_log_file_size));
 
659
                if (!ret) {
 
660
                        fprintf(stderr,
 
661
                                "InnoDB: Error in creating %s:"
 
662
                                " probably out of disk space\n",
 
663
                                name);
 
664
 
 
665
                        return(DB_ERROR);
 
666
                }
 
667
        }
 
668
 
 
669
        ret = os_file_close(files[i]);
 
670
        ut_a(ret);
 
671
 
 
672
        if (i == 0) {
 
673
                /* Create in memory the file space object
 
674
                which is for this log group */
 
675
 
 
676
                fil_space_create(name,
 
677
                                 2 * k + SRV_LOG_SPACE_FIRST_ID, 0, FIL_LOG);
 
678
        }
 
679
 
 
680
        ut_a(fil_validate());
 
681
 
 
682
        fil_node_create(name, srv_log_file_size,
 
683
                        2 * k + SRV_LOG_SPACE_FIRST_ID, FALSE);
 
684
#ifdef UNIV_LOG_ARCHIVE
 
685
        /* If this is the first log group, create the file space object
 
686
        for archived logs.
 
687
        Under MySQL, no archiving ever done. */
 
688
 
 
689
        if (k == 0 && i == 0) {
 
690
                arch_space_id = 2 * k + 1 + SRV_LOG_SPACE_FIRST_ID;
 
691
 
 
692
                fil_space_create("arch_log_space", arch_space_id, 0, FIL_LOG);
 
693
        } else {
 
694
                arch_space_id = ULINT_UNDEFINED;
 
695
        }
 
696
#endif /* UNIV_LOG_ARCHIVE */
 
697
        if (i == 0) {
 
698
                log_group_init(k, srv_n_log_files,
 
699
                               srv_log_file_size * UNIV_PAGE_SIZE,
 
700
                               2 * k + SRV_LOG_SPACE_FIRST_ID,
 
701
                               SRV_LOG_SPACE_FIRST_ID + 1); /* dummy arch
 
702
                                                            space id */
 
703
        }
 
704
 
 
705
        return(DB_SUCCESS);
 
706
}
 
707
 
 
708
/*********************************************************************//**
 
709
Creates or opens database data files and closes them.
 
710
@return DB_SUCCESS or error code */
 
711
static
 
712
ulint
 
713
open_or_create_data_files(
 
714
/*======================*/
 
715
        ibool*          create_new_db,  /*!< out: TRUE if new database should be
 
716
                                        created */
 
717
#ifdef UNIV_LOG_ARCHIVE
 
718
        ulint*          min_arch_log_no,/*!< out: min of archived log
 
719
                                        numbers in data files */
 
720
        ulint*          max_arch_log_no,/*!< out: max of archived log
 
721
                                        numbers in data files */
 
722
#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
 
728
                                        new files added */
 
729
{
 
730
        ibool   ret;
 
731
        ulint   i;
 
732
        ibool   one_opened      = FALSE;
 
733
        ibool   one_created     = FALSE;
 
734
        ulint   size;
 
735
        ulint   size_high;
 
736
        ulint   rounded_size_pages;
 
737
        char    name[10000];
 
738
 
 
739
        if (srv_n_data_files >= 1000) {
 
740
                fprintf(stderr, "InnoDB: can only have < 1000 data files\n"
 
741
                        "InnoDB: you have defined %lu\n",
 
742
                        (ulong) srv_n_data_files);
 
743
                return(DB_ERROR);
 
744
        }
 
745
 
 
746
        *sum_of_new_sizes = 0;
 
747
 
 
748
        *create_new_db = FALSE;
 
749
 
 
750
        srv_normalize_path_for_win(srv_data_home);
 
751
 
 
752
        for (i = 0; i < srv_n_data_files; i++) {
 
753
                ulint   dirnamelen;
 
754
 
 
755
                srv_normalize_path_for_win(srv_data_file_names[i]);
 
756
                dirnamelen = strlen(srv_data_home);
 
757
 
 
758
                ut_a(dirnamelen + strlen(srv_data_file_names[i])
 
759
                     < (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]);
 
767
 
 
768
                if (srv_data_file_is_raw_partition[i] == 0) {
 
769
 
 
770
                        /* First we try to create the file: if it already
 
771
                        exists, ret will get value FALSE */
 
772
 
 
773
                        files[i] = os_file_create(innodb_file_data_key,
 
774
                                                  name, OS_FILE_CREATE,
 
775
                                                  OS_FILE_NORMAL,
 
776
                                                  OS_DATA_FILE, &ret);
 
777
 
 
778
                        if (ret == FALSE && os_file_get_last_error(FALSE)
 
779
                            != OS_FILE_ALREADY_EXISTS
 
780
#ifdef UNIV_AIX
 
781
                            /* AIX 5.1 after security patch ML7 may have
 
782
                            errno set to 0 here, which causes our function
 
783
                            to return 100; work around that AIX problem */
 
784
                            && os_file_get_last_error(FALSE) != 100
 
785
#endif
 
786
                            ) {
 
787
                                fprintf(stderr,
 
788
                                        "InnoDB: Error in creating"
 
789
                                        " or opening %s\n",
 
790
                                        name);
 
791
 
 
792
                                return(DB_ERROR);
 
793
                        }
 
794
                } else if (srv_data_file_is_raw_partition[i] == SRV_NEW_RAW) {
 
795
                        /* The partition is opened, not created; then it is
 
796
                        written over */
 
797
 
 
798
                        srv_start_raw_disk_in_use = TRUE;
 
799
                        srv_created_new_raw = TRUE;
 
800
 
 
801
                        files[i] = os_file_create(innodb_file_data_key,
 
802
                                                  name, OS_FILE_OPEN_RAW,
 
803
                                                  OS_FILE_NORMAL,
 
804
                                                  OS_DATA_FILE, &ret);
 
805
                        if (!ret) {
 
806
                                fprintf(stderr,
 
807
                                        "InnoDB: Error in opening %s\n", name);
 
808
 
 
809
                                return(DB_ERROR);
 
810
                        }
 
811
                } else if (srv_data_file_is_raw_partition[i] == SRV_OLD_RAW) {
 
812
                        srv_start_raw_disk_in_use = TRUE;
 
813
 
 
814
                        ret = FALSE;
 
815
                } else {
 
816
                        ut_a(0);
 
817
                }
 
818
 
 
819
                if (ret == FALSE) {
 
820
                        /* We open the data file */
 
821
 
 
822
                        if (one_created) {
 
823
                                fprintf(stderr,
 
824
                                        "InnoDB: Error: data files can only"
 
825
                                        " be added at the end\n");
 
826
                                fprintf(stderr,
 
827
                                        "InnoDB: of a tablespace, but"
 
828
                                        " data file %s existed beforehand.\n",
 
829
                                        name);
 
830
                                return(DB_ERROR);
 
831
                        }
 
832
 
 
833
                        if (srv_data_file_is_raw_partition[i] == SRV_OLD_RAW) {
 
834
                                files[i] = os_file_create(
 
835
                                        innodb_file_data_key,
 
836
                                        name, OS_FILE_OPEN_RAW,
 
837
                                        OS_FILE_NORMAL, OS_DATA_FILE, &ret);
 
838
                        } else if (i == 0) {
 
839
                                files[i] = os_file_create(
 
840
                                        innodb_file_data_key,
 
841
                                        name, OS_FILE_OPEN_RETRY,
 
842
                                        OS_FILE_NORMAL, OS_DATA_FILE, &ret);
 
843
                        } else {
 
844
                                files[i] = os_file_create(
 
845
                                        innodb_file_data_key,
 
846
                                        name, OS_FILE_OPEN, OS_FILE_NORMAL,
 
847
                                        OS_DATA_FILE, &ret);
 
848
                        }
 
849
 
 
850
                        if (!ret) {
 
851
                                fprintf(stderr,
 
852
                                        "InnoDB: Error in opening %s\n", name);
 
853
                                os_file_get_last_error(TRUE);
 
854
 
 
855
                                return(DB_ERROR);
 
856
                        }
 
857
 
 
858
                        if (srv_data_file_is_raw_partition[i] == SRV_OLD_RAW) {
 
859
 
 
860
                                goto skip_size_check;
 
861
                        }
 
862
 
 
863
                        ret = os_file_get_size(files[i], &size, &size_high);
 
864
                        ut_a(ret);
 
865
                        /* Round size downward to megabytes */
 
866
 
 
867
                        rounded_size_pages
 
868
                                = (size / (1024 * 1024) + 4096 * size_high)
 
869
                                        << (20 - UNIV_PAGE_SIZE_SHIFT);
 
870
 
 
871
                        if (i == srv_n_data_files - 1
 
872
                            && srv_auto_extend_last_data_file) {
 
873
 
 
874
                                if (srv_data_file_sizes[i] > rounded_size_pages
 
875
                                    || (srv_last_file_size_max > 0
 
876
                                        && srv_last_file_size_max
 
877
                                        < rounded_size_pages)) {
 
878
 
 
879
                                        fprintf(stderr,
 
880
                                                "InnoDB: Error: auto-extending"
 
881
                                                " data file %s is"
 
882
                                                " of a different size\n"
 
883
                                                "InnoDB: %lu pages (rounded"
 
884
                                                " down to MB) than specified"
 
885
                                                " in the .cnf file:\n"
 
886
                                                "InnoDB: initial %lu pages,"
 
887
                                                " max %lu (relevant if"
 
888
                                                " non-zero) pages!\n",
 
889
                                                name,
 
890
                                                (ulong) rounded_size_pages,
 
891
                                                (ulong) srv_data_file_sizes[i],
 
892
                                                (ulong)
 
893
                                                srv_last_file_size_max);
 
894
 
 
895
                                        return(DB_ERROR);
 
896
                                }
 
897
 
 
898
                                srv_data_file_sizes[i] = rounded_size_pages;
 
899
                        }
 
900
 
 
901
                        if (rounded_size_pages != srv_data_file_sizes[i]) {
 
902
 
 
903
                                fprintf(stderr,
 
904
                                        "InnoDB: Error: data file %s"
 
905
                                        " is of a different size\n"
 
906
                                        "InnoDB: %lu pages"
 
907
                                        " (rounded down to MB)\n"
 
908
                                        "InnoDB: than specified"
 
909
                                        " in the .cnf file %lu pages!\n",
 
910
                                        name,
 
911
                                        (ulong) rounded_size_pages,
 
912
                                        (ulong) srv_data_file_sizes[i]);
 
913
 
 
914
                                return(DB_ERROR);
 
915
                        }
 
916
skip_size_check:
 
917
                        fil_read_flushed_lsn_and_arch_log_no(
 
918
                                files[i], one_opened,
 
919
#ifdef UNIV_LOG_ARCHIVE
 
920
                                min_arch_log_no, max_arch_log_no,
 
921
#endif /* UNIV_LOG_ARCHIVE */
 
922
                                min_flushed_lsn, max_flushed_lsn);
 
923
                        one_opened = TRUE;
 
924
                } else {
 
925
                        /* We created the data file and now write it full of
 
926
                        zeros */
 
927
 
 
928
                        one_created = TRUE;
 
929
 
 
930
                        if (i > 0) {
 
931
                                ut_print_timestamp(stderr);
 
932
                                fprintf(stderr,
 
933
                                        "  InnoDB: Data file %s did not"
 
934
                                        " exist: new to be created\n",
 
935
                                        name);
 
936
                        } else {
 
937
                                fprintf(stderr,
 
938
                                        "InnoDB: The first specified"
 
939
                                        " data file %s did not exist:\n"
 
940
                                        "InnoDB: a new database"
 
941
                                        " to be created!\n", name);
 
942
                                *create_new_db = TRUE;
 
943
                        }
 
944
 
 
945
                        ut_print_timestamp(stderr);
 
946
                        fprintf(stderr,
 
947
                                "  InnoDB: Setting file %s size to %lu MB\n",
 
948
                                name,
 
949
                                (ulong) (srv_data_file_sizes[i]
 
950
                                         >> (20 - UNIV_PAGE_SIZE_SHIFT)));
 
951
 
 
952
                        fprintf(stderr,
 
953
                                "InnoDB: Database physically writes the"
 
954
                                " file full: wait...\n");
 
955
 
 
956
                        ret = os_file_set_size(
 
957
                                name, files[i],
 
958
                                srv_calc_low32(srv_data_file_sizes[i]),
 
959
                                srv_calc_high32(srv_data_file_sizes[i]));
 
960
 
 
961
                        if (!ret) {
 
962
                                fprintf(stderr,
 
963
                                        "InnoDB: Error in creating %s:"
 
964
                                        " probably out of disk space\n", name);
 
965
 
 
966
                                return(DB_ERROR);
 
967
                        }
 
968
 
 
969
                        *sum_of_new_sizes = *sum_of_new_sizes
 
970
                                + srv_data_file_sizes[i];
 
971
                }
 
972
 
 
973
                ret = os_file_close(files[i]);
 
974
                ut_a(ret);
 
975
 
 
976
                if (i == 0) {
 
977
                        fil_space_create(name, 0, 0, FIL_TABLESPACE);
 
978
                }
 
979
 
 
980
                ut_a(fil_validate());
 
981
 
 
982
                fil_node_create(name, srv_data_file_sizes[i], 0,
 
983
                                srv_data_file_is_raw_partition[i] != 0);
 
984
        }
 
985
 
 
986
        return(DB_SUCCESS);
 
987
}
 
988
 
 
989
/********************************************************************
 
990
Starts InnoDB and creates a new database if database files
 
991
are not found and the user wants.
 
992
@return DB_SUCCESS or error code */
 
993
UNIV_INTERN
 
994
int
 
995
innobase_start_or_create_for_mysql(void)
 
996
/*====================================*/
 
997
{
 
998
        ibool           create_new_db;
 
999
        ibool           log_file_created;
 
1000
        ibool           log_created     = FALSE;
 
1001
        ibool           log_opened      = FALSE;
 
1002
        ib_uint64_t     min_flushed_lsn;
 
1003
        ib_uint64_t     max_flushed_lsn;
 
1004
#ifdef UNIV_LOG_ARCHIVE
 
1005
        ulint           min_arch_log_no;
 
1006
        ulint           max_arch_log_no;
 
1007
#endif /* UNIV_LOG_ARCHIVE */
 
1008
        ulint           sum_of_new_sizes;
 
1009
        ulint           sum_of_data_file_sizes;
 
1010
        ulint           tablespace_size_in_header;
 
1011
        ulint           err;
 
1012
        ulint           i;
 
1013
        ulint           io_limit;
 
1014
        my_bool         srv_file_per_table_original_value
 
1015
                = srv_file_per_table;
 
1016
        mtr_t           mtr;
 
1017
#ifdef HAVE_DARWIN_THREADS
 
1018
# ifdef F_FULLFSYNC
 
1019
        /* This executable has been compiled on Mac OS X 10.3 or later.
 
1020
        Assume that F_FULLFSYNC is available at run-time. */
 
1021
        srv_have_fullfsync = TRUE;
 
1022
# else /* F_FULLFSYNC */
 
1023
        /* This executable has been compiled on Mac OS X 10.2
 
1024
        or earlier.  Determine if the executable is running
 
1025
        on Mac OS X 10.3 or later. */
 
1026
        struct utsname utsname;
 
1027
        if (uname(&utsname)) {
 
1028
                fputs("InnoDB: cannot determine Mac OS X version!\n", stderr);
 
1029
        } else {
 
1030
                srv_have_fullfsync = strcmp(utsname.release, "7.") >= 0;
 
1031
        }
 
1032
        if (!srv_have_fullfsync) {
 
1033
                fputs("InnoDB: On Mac OS X, fsync() may be"
 
1034
                      " broken on internal drives,\n"
 
1035
                      "InnoDB: making transactions unsafe!\n", stderr);
 
1036
        }
 
1037
# endif /* F_FULLFSYNC */
 
1038
#endif /* HAVE_DARWIN_THREADS */
 
1039
 
 
1040
        if (sizeof(ulint) != sizeof(void*)) {
 
1041
                fprintf(stderr,
 
1042
                        "InnoDB: Error: size of InnoDB's ulint is %lu,"
 
1043
                        " but size of void* is %lu.\n"
 
1044
                        "InnoDB: The sizes should be the same"
 
1045
                        " so that on a 64-bit platform you can\n"
 
1046
                        "InnoDB: allocate more than 4 GB of memory.",
 
1047
                        (ulong)sizeof(ulint), (ulong)sizeof(void*));
 
1048
        }
 
1049
 
 
1050
        /* System tables are created in tablespace 0.  Thus, we must
 
1051
        temporarily clear srv_file_per_table.  This is ok, because the
 
1052
        server will not accept connections (which could modify
 
1053
        innodb_file_per_table) until this function has returned. */
 
1054
        srv_file_per_table = FALSE;
 
1055
#ifdef UNIV_DEBUG
 
1056
        fprintf(stderr,
 
1057
                "InnoDB: !!!!!!!! UNIV_DEBUG switched on !!!!!!!!!\n");
 
1058
#endif
 
1059
 
 
1060
#ifdef UNIV_IBUF_DEBUG
 
1061
        fprintf(stderr,
 
1062
                "InnoDB: !!!!!!!! UNIV_IBUF_DEBUG switched on !!!!!!!!!\n"
 
1063
# ifdef UNIV_IBUF_COUNT_DEBUG
 
1064
                "InnoDB: !!!!!!!! UNIV_IBUF_COUNT_DEBUG switched on !!!!!!!!!\n"
 
1065
                "InnoDB: Crash recovery will fail with UNIV_IBUF_COUNT_DEBUG\n"
 
1066
# endif
 
1067
                );
 
1068
#endif
 
1069
 
 
1070
#ifdef UNIV_SYNC_DEBUG
 
1071
        fprintf(stderr,
 
1072
                "InnoDB: !!!!!!!! UNIV_SYNC_DEBUG switched on !!!!!!!!!\n");
 
1073
#endif
 
1074
 
 
1075
#ifdef UNIV_SEARCH_DEBUG
 
1076
        fprintf(stderr,
 
1077
                "InnoDB: !!!!!!!! UNIV_SEARCH_DEBUG switched on !!!!!!!!!\n");
 
1078
#endif
 
1079
 
 
1080
#ifdef UNIV_LOG_LSN_DEBUG
 
1081
        fprintf(stderr,
 
1082
                "InnoDB: !!!!!!!! UNIV_LOG_LSN_DEBUG switched on !!!!!!!!!\n");
 
1083
#endif /* UNIV_LOG_LSN_DEBUG */
 
1084
#ifdef UNIV_MEM_DEBUG
 
1085
        fprintf(stderr,
 
1086
                "InnoDB: !!!!!!!! UNIV_MEM_DEBUG switched on !!!!!!!!!\n");
 
1087
#endif
 
1088
 
 
1089
        if (UNIV_LIKELY(srv_use_sys_malloc)) {
 
1090
                fprintf(stderr,
 
1091
                        "InnoDB: The InnoDB memory heap is disabled\n");
 
1092
        }
 
1093
 
 
1094
        fputs("InnoDB: " IB_ATOMICS_STARTUP_MSG
 
1095
              "\nInnoDB: Compressed tables use zlib " ZLIB_VERSION
 
1096
#ifdef UNIV_ZIP_DEBUG
 
1097
              " with validation"
 
1098
#endif /* UNIV_ZIP_DEBUG */
 
1099
#ifdef UNIV_ZIP_COPY
 
1100
              " and extra copying"
 
1101
#endif /* UNIV_ZIP_COPY */
 
1102
              "\n" , stderr);
 
1103
 
 
1104
 
 
1105
        /* Since InnoDB does not currently clean up all its internal data
 
1106
        structures in MySQL Embedded Server Library server_end(), we
 
1107
        print an error message if someone tries to start up InnoDB a
 
1108
        second time during the process lifetime. */
 
1109
 
 
1110
        if (srv_start_has_been_called) {
 
1111
                fprintf(stderr,
 
1112
                        "InnoDB: Error: startup called second time"
 
1113
                        " during the process lifetime.\n"
 
1114
                        "InnoDB: In the MySQL Embedded Server Library"
 
1115
                        " you cannot call server_init()\n"
 
1116
                        "InnoDB: more than once during"
 
1117
                        " the process lifetime.\n");
 
1118
        }
 
1119
 
 
1120
        srv_start_has_been_called = TRUE;
 
1121
 
 
1122
#ifdef UNIV_DEBUG
 
1123
        log_do_write = TRUE;
 
1124
#endif /* UNIV_DEBUG */
 
1125
        /*      yydebug = TRUE; */
 
1126
 
 
1127
        srv_is_being_started = TRUE;
 
1128
        srv_startup_is_before_trx_rollback_phase = TRUE;
 
1129
 
 
1130
#ifdef __WIN__
 
1131
        switch (os_get_os_version()) {
 
1132
        case OS_WIN95:
 
1133
        case OS_WIN31:
 
1134
        case OS_WINNT:
 
1135
                /* On Win 95, 98, ME, Win32 subsystem for Windows 3.1,
 
1136
                and NT use simulated aio. In NT Windows provides async i/o,
 
1137
                but when run in conjunction with InnoDB Hot Backup, it seemed
 
1138
                to corrupt the data files. */
 
1139
 
 
1140
                srv_use_native_aio = FALSE;
 
1141
                break;
 
1142
 
 
1143
        case OS_WIN2000:
 
1144
        case OS_WINXP:
 
1145
                /* On 2000 and XP, async IO is available. */
 
1146
                srv_use_native_aio = TRUE;
 
1147
                break;
 
1148
 
 
1149
        default:
 
1150
                /* Vista and later have both async IO and condition variables */
 
1151
                srv_use_native_aio = TRUE;
 
1152
                srv_use_native_conditions = TRUE;
 
1153
                break;
 
1154
        }
 
1155
 
 
1156
#elif defined(LINUX_NATIVE_AIO)
 
1157
 
 
1158
        if (srv_use_native_aio) {
 
1159
                ut_print_timestamp(stderr);
 
1160
                fprintf(stderr,
 
1161
                        "  InnoDB: Using Linux native AIO\n");
 
1162
        }
 
1163
#else
 
1164
        /* Currently native AIO is supported only on windows and linux
 
1165
        and that also when the support is compiled in. In all other
 
1166
        cases, we ignore the setting of innodb_use_native_aio. */
 
1167
        srv_use_native_aio = FALSE;
 
1168
 
 
1169
#endif
 
1170
 
 
1171
        if (srv_file_flush_method_str == NULL) {
 
1172
                /* These are the default options */
 
1173
 
 
1174
                srv_unix_file_flush_method = SRV_UNIX_FSYNC;
 
1175
 
 
1176
                srv_win_file_flush_method = SRV_WIN_IO_UNBUFFERED;
 
1177
#ifndef __WIN__
 
1178
        } else if (0 == ut_strcmp(srv_file_flush_method_str, "fsync")) {
 
1179
                srv_unix_file_flush_method = SRV_UNIX_FSYNC;
 
1180
 
 
1181
        } else if (0 == ut_strcmp(srv_file_flush_method_str, "O_DSYNC")) {
 
1182
                srv_unix_file_flush_method = SRV_UNIX_O_DSYNC;
 
1183
 
 
1184
        } else if (0 == ut_strcmp(srv_file_flush_method_str, "O_DIRECT")) {
 
1185
                srv_unix_file_flush_method = SRV_UNIX_O_DIRECT;
 
1186
 
 
1187
        } else if (0 == ut_strcmp(srv_file_flush_method_str, "littlesync")) {
 
1188
                srv_unix_file_flush_method = SRV_UNIX_LITTLESYNC;
 
1189
 
 
1190
        } else if (0 == ut_strcmp(srv_file_flush_method_str, "nosync")) {
 
1191
                srv_unix_file_flush_method = SRV_UNIX_NOSYNC;
 
1192
#else
 
1193
        } else if (0 == ut_strcmp(srv_file_flush_method_str, "normal")) {
 
1194
                srv_win_file_flush_method = SRV_WIN_IO_NORMAL;
 
1195
                srv_use_native_aio = FALSE;
 
1196
 
 
1197
        } else if (0 == ut_strcmp(srv_file_flush_method_str, "unbuffered")) {
 
1198
                srv_win_file_flush_method = SRV_WIN_IO_UNBUFFERED;
 
1199
                srv_use_native_aio = FALSE;
 
1200
 
 
1201
        } else if (0 == ut_strcmp(srv_file_flush_method_str,
 
1202
                                  "async_unbuffered")) {
 
1203
                srv_win_file_flush_method = SRV_WIN_IO_UNBUFFERED;
 
1204
#endif
 
1205
        } else {
 
1206
                fprintf(stderr,
 
1207
                        "InnoDB: Unrecognized value %s for"
 
1208
                        " innodb_flush_method\n",
 
1209
                        srv_file_flush_method_str);
 
1210
                return(DB_ERROR);
 
1211
        }
 
1212
 
 
1213
        /* Note that the call srv_boot() also changes the values of
 
1214
        some variables to the units used by InnoDB internally */
 
1215
 
 
1216
        /* Set the maximum number of threads which can wait for a semaphore
 
1217
        inside InnoDB: this is the 'sync wait array' size, as well as the
 
1218
        maximum number of threads that can wait in the 'srv_conc array' for
 
1219
        their time to enter InnoDB. */
 
1220
 
 
1221
        if (srv_buf_pool_size >= 1000 * 1024 * 1024) {
 
1222
                /* If buffer pool is less than 1000 MB,
 
1223
                assume fewer threads. Also use only one
 
1224
                buffer pool instance */
 
1225
                srv_max_n_threads = 50000;
 
1226
 
 
1227
        } else if (srv_buf_pool_size >= 8 * 1024 * 1024) {
 
1228
 
 
1229
                srv_buf_pool_instances = 1;
 
1230
                srv_max_n_threads = 10000;
 
1231
        } else {
 
1232
                srv_buf_pool_instances = 1;
 
1233
                srv_max_n_threads = 1000;       /* saves several MB of memory,
 
1234
                                                especially in 64-bit
 
1235
                                                computers */
 
1236
        }
 
1237
 
 
1238
        err = srv_boot();
 
1239
 
 
1240
        if (err != DB_SUCCESS) {
 
1241
 
 
1242
                return((int) err);
 
1243
        }
 
1244
 
 
1245
        mutex_create(srv_monitor_file_mutex_key,
 
1246
                     &srv_monitor_file_mutex, SYNC_NO_ORDER_CHECK);
 
1247
 
 
1248
        if (srv_innodb_status) {
 
1249
                srv_monitor_file_name = mem_alloc(
 
1250
                        strlen(fil_path_to_mysql_datadir)
 
1251
                        + 20 + sizeof "/innodb_status.");
 
1252
                sprintf(srv_monitor_file_name, "%s/innodb_status.%lu",
 
1253
                        fil_path_to_mysql_datadir, os_proc_get_number());
 
1254
                srv_monitor_file = fopen(srv_monitor_file_name, "w+");
 
1255
                if (!srv_monitor_file) {
 
1256
                        fprintf(stderr, "InnoDB: unable to create %s: %s\n",
 
1257
                                srv_monitor_file_name, strerror(errno));
 
1258
                        return(DB_ERROR);
 
1259
                }
 
1260
        } else {
 
1261
                srv_monitor_file_name = NULL;
 
1262
                srv_monitor_file = os_file_create_tmpfile();
 
1263
                if (!srv_monitor_file) {
 
1264
                        return(DB_ERROR);
 
1265
                }
 
1266
        }
 
1267
 
 
1268
        mutex_create(srv_dict_tmpfile_mutex_key,
 
1269
                     &srv_dict_tmpfile_mutex, SYNC_DICT_OPERATION);
 
1270
 
 
1271
        srv_dict_tmpfile = os_file_create_tmpfile();
 
1272
        if (!srv_dict_tmpfile) {
 
1273
                return(DB_ERROR);
 
1274
        }
 
1275
 
 
1276
        mutex_create(srv_misc_tmpfile_mutex_key,
 
1277
                     &srv_misc_tmpfile_mutex, SYNC_ANY_LATCH);
 
1278
 
 
1279
        srv_misc_tmpfile = os_file_create_tmpfile();
 
1280
        if (!srv_misc_tmpfile) {
 
1281
                return(DB_ERROR);
 
1282
        }
 
1283
 
 
1284
        /* innodb_file_io_threads used to be user settable.
 
1285
           It is now just a combination of read_io_threads and
 
1286
           write_io_threads that is set by innodb internally. */
 
1287
 
 
1288
        /* Now overwrite the value on srv_n_file_io_threads */
 
1289
        srv_n_file_io_threads = 2 + srv_n_read_io_threads
 
1290
                                + srv_n_write_io_threads;
 
1291
 
 
1292
        ut_a(srv_n_file_io_threads <= SRV_MAX_N_IO_THREADS);
 
1293
 
 
1294
        /* TODO: Investigate if SRV_N_PENDING_IOS_PER_THREAD (32) limit
 
1295
        still applies to windows. */
 
1296
        if (!srv_use_native_aio) {
 
1297
                io_limit = 8 * SRV_N_PENDING_IOS_PER_THREAD;
 
1298
        } else {
 
1299
                io_limit = SRV_N_PENDING_IOS_PER_THREAD;
 
1300
        }
 
1301
 
 
1302
        os_aio_init(io_limit,
 
1303
                    srv_n_read_io_threads,
 
1304
                    srv_n_write_io_threads,
 
1305
                    SRV_MAX_N_PENDING_SYNC_IOS);
 
1306
 
 
1307
        fil_init(srv_file_per_table ? 50000 : 5000,
 
1308
                 srv_max_n_open_files);
 
1309
 
 
1310
        /* Print time to initialize the buffer pool */
 
1311
        ut_print_timestamp(stderr);
 
1312
        fprintf(stderr,
 
1313
                "  InnoDB: Initializing buffer pool, size =");
 
1314
 
 
1315
        if (srv_buf_pool_size >= 1024 * 1024 * 1024) {
 
1316
                fprintf(stderr,
 
1317
                        " %.1fG\n",
 
1318
                        ((double) srv_buf_pool_size) / (1024 * 1024 * 1024));
 
1319
        } else {
 
1320
                fprintf(stderr,
 
1321
                        " %.1fM\n",
 
1322
                        ((double) srv_buf_pool_size) / (1024 * 1024));
 
1323
        }
 
1324
 
 
1325
        err = buf_pool_init(srv_buf_pool_size, srv_buf_pool_instances);
 
1326
 
 
1327
        ut_print_timestamp(stderr);
 
1328
        fprintf(stderr,
 
1329
                "  InnoDB: Completed initialization of buffer pool\n");
 
1330
 
 
1331
        if (err != DB_SUCCESS) {
 
1332
                fprintf(stderr,
 
1333
                        "InnoDB: Fatal error: cannot allocate the memory"
 
1334
                        " for the buffer pool\n");
 
1335
 
 
1336
                return(DB_ERROR);
 
1337
        }
 
1338
 
 
1339
#ifdef UNIV_DEBUG
 
1340
        /* We have observed deadlocks with a 5MB buffer pool but
 
1341
        the actual lower limit could very well be a little higher. */
 
1342
 
 
1343
        if (srv_buf_pool_size <= 5 * 1024 * 1024) {
 
1344
 
 
1345
                fprintf(stderr, "InnoDB: Warning: Small buffer pool size "
 
1346
                        "(%luM), the flst_validate() debug function "
 
1347
                        "can cause a deadlock if the buffer pool fills up.\n",
 
1348
                        srv_buf_pool_size / 1024 / 1024);
 
1349
        }
 
1350
#endif
 
1351
 
 
1352
        fsp_init();
 
1353
        log_init();
 
1354
 
 
1355
        lock_sys_create(srv_lock_table_size);
 
1356
 
 
1357
        /* Create i/o-handler threads: */
 
1358
 
 
1359
        for (i = 0; i < srv_n_file_io_threads; i++) {
 
1360
                n[i] = i;
 
1361
 
 
1362
                os_thread_create(io_handler_thread, n + i, thread_ids + i);
 
1363
        }
 
1364
 
 
1365
#ifdef UNIV_LOG_ARCHIVE
 
1366
        if (0 != ut_strcmp(srv_log_group_home_dirs[0], srv_arch_dir)) {
 
1367
                fprintf(stderr,
 
1368
                        "InnoDB: Error: you must set the log group"
 
1369
                        " home dir in my.cnf the\n"
 
1370
                        "InnoDB: same as log arch dir.\n");
 
1371
 
 
1372
                return(DB_ERROR);
 
1373
        }
 
1374
#endif /* UNIV_LOG_ARCHIVE */
 
1375
 
 
1376
        if (srv_n_log_files * srv_log_file_size >= 262144) {
 
1377
                fprintf(stderr,
 
1378
                        "InnoDB: Error: combined size of log files"
 
1379
                        " must be < 4 GB\n");
 
1380
 
 
1381
                return(DB_ERROR);
 
1382
        }
 
1383
 
 
1384
        sum_of_new_sizes = 0;
 
1385
 
 
1386
        for (i = 0; i < srv_n_data_files; i++) {
 
1387
#ifndef __WIN__
 
1388
                if (sizeof(off_t) < 5 && srv_data_file_sizes[i] >= 262144) {
 
1389
                        fprintf(stderr,
 
1390
                                "InnoDB: Error: file size must be < 4 GB"
 
1391
                                " with this MySQL binary\n"
 
1392
                                "InnoDB: and operating system combination,"
 
1393
                                " in some OS's < 2 GB\n");
 
1394
 
 
1395
                        return(DB_ERROR);
 
1396
                }
 
1397
#endif
 
1398
                sum_of_new_sizes += srv_data_file_sizes[i];
 
1399
        }
 
1400
 
 
1401
        if (sum_of_new_sizes < 10485760 / UNIV_PAGE_SIZE) {
 
1402
                fprintf(stderr,
 
1403
                        "InnoDB: Error: tablespace size must be"
 
1404
                        " at least 10 MB\n");
 
1405
 
 
1406
                return(DB_ERROR);
 
1407
        }
 
1408
 
 
1409
        err = open_or_create_data_files(&create_new_db,
 
1410
#ifdef UNIV_LOG_ARCHIVE
 
1411
                                        &min_arch_log_no, &max_arch_log_no,
 
1412
#endif /* UNIV_LOG_ARCHIVE */
 
1413
                                        &min_flushed_lsn, &max_flushed_lsn,
 
1414
                                        &sum_of_new_sizes);
 
1415
        if (err != DB_SUCCESS) {
 
1416
                fprintf(stderr,
 
1417
                        "InnoDB: Could not open or create data files.\n"
 
1418
                        "InnoDB: If you tried to add new data files,"
 
1419
                        " and it failed here,\n"
 
1420
                        "InnoDB: you should now edit innodb_data_file_path"
 
1421
                        " in my.cnf back\n"
 
1422
                        "InnoDB: to what it was, and remove the"
 
1423
                        " new ibdata files InnoDB created\n"
 
1424
                        "InnoDB: in this failed attempt. InnoDB only wrote"
 
1425
                        " those files full of\n"
 
1426
                        "InnoDB: zeros, but did not yet use them in any way."
 
1427
                        " But be careful: do not\n"
 
1428
                        "InnoDB: remove old data files"
 
1429
                        " which contain your precious data!\n");
 
1430
 
 
1431
                return((int) err);
 
1432
        }
 
1433
 
 
1434
#ifdef UNIV_LOG_ARCHIVE
 
1435
        srv_normalize_path_for_win(srv_arch_dir);
 
1436
        srv_arch_dir = srv_add_path_separator_if_needed(srv_arch_dir);
 
1437
#endif /* UNIV_LOG_ARCHIVE */
 
1438
 
 
1439
        for (i = 0; i < srv_n_log_files; i++) {
 
1440
                err = open_or_create_log_file(create_new_db, &log_file_created,
 
1441
                                              log_opened, 0, i);
 
1442
                if (err != DB_SUCCESS) {
 
1443
 
 
1444
                        return((int) err);
 
1445
                }
 
1446
 
 
1447
                if (log_file_created) {
 
1448
                        log_created = TRUE;
 
1449
                } else {
 
1450
                        log_opened = TRUE;
 
1451
                }
 
1452
                if ((log_opened && create_new_db)
 
1453
                    || (log_opened && log_created)) {
 
1454
                        fprintf(stderr,
 
1455
                                "InnoDB: Error: all log files must be"
 
1456
                                " created at the same time.\n"
 
1457
                                "InnoDB: All log files must be"
 
1458
                                " created also in database creation.\n"
 
1459
                                "InnoDB: If you want bigger or smaller"
 
1460
                                " log files, shut down the\n"
 
1461
                                "InnoDB: database and make sure there"
 
1462
                                " were no errors in shutdown.\n"
 
1463
                                "InnoDB: Then delete the existing log files."
 
1464
                                " Edit the .cnf file\n"
 
1465
                                "InnoDB: and start the database again.\n");
 
1466
 
 
1467
                        return(DB_ERROR);
 
1468
                }
 
1469
        }
 
1470
 
 
1471
        /* Open all log files and data files in the system tablespace: we
 
1472
        keep them open until database shutdown */
 
1473
 
 
1474
        fil_open_log_and_system_tablespace_files();
 
1475
 
 
1476
        if (log_created && !create_new_db
 
1477
#ifdef UNIV_LOG_ARCHIVE
 
1478
            && !srv_archive_recovery
 
1479
#endif /* UNIV_LOG_ARCHIVE */
 
1480
            ) {
 
1481
                if (max_flushed_lsn != min_flushed_lsn
 
1482
#ifdef UNIV_LOG_ARCHIVE
 
1483
                    || max_arch_log_no != min_arch_log_no
 
1484
#endif /* UNIV_LOG_ARCHIVE */
 
1485
                    ) {
 
1486
                        fprintf(stderr,
 
1487
                                "InnoDB: Cannot initialize created"
 
1488
                                " log files because\n"
 
1489
                                "InnoDB: data files were not in sync"
 
1490
                                " with each other\n"
 
1491
                                "InnoDB: or the data files are corrupt.\n");
 
1492
 
 
1493
                        return(DB_ERROR);
 
1494
                }
 
1495
 
 
1496
                if (max_flushed_lsn < (ib_uint64_t) 1000) {
 
1497
                        fprintf(stderr,
 
1498
                                "InnoDB: Cannot initialize created"
 
1499
                                " log files because\n"
 
1500
                                "InnoDB: data files are corrupt,"
 
1501
                                " or new data files were\n"
 
1502
                                "InnoDB: created when the database"
 
1503
                                " was started previous\n"
 
1504
                                "InnoDB: time but the database"
 
1505
                                " was not shut down\n"
 
1506
                                "InnoDB: normally after that.\n");
 
1507
 
 
1508
                        return(DB_ERROR);
 
1509
                }
 
1510
 
 
1511
                mutex_enter(&(log_sys->mutex));
 
1512
 
 
1513
#ifdef UNIV_LOG_ARCHIVE
 
1514
                /* Do not + 1 arch_log_no because we do not use log
 
1515
                archiving */
 
1516
                recv_reset_logs(max_flushed_lsn, max_arch_log_no, TRUE);
 
1517
#else
 
1518
                recv_reset_logs(max_flushed_lsn, TRUE);
 
1519
#endif /* UNIV_LOG_ARCHIVE */
 
1520
 
 
1521
                mutex_exit(&(log_sys->mutex));
 
1522
        }
 
1523
 
 
1524
        trx_sys_file_format_init();
 
1525
 
 
1526
        if (create_new_db) {
 
1527
                mtr_start(&mtr);
 
1528
 
 
1529
                fsp_header_init(0, sum_of_new_sizes, &mtr);
 
1530
 
 
1531
                mtr_commit(&mtr);
 
1532
 
 
1533
                /* To maintain backward compatibility we create only
 
1534
                the first rollback segment before the double write buffer.
 
1535
                All the remaining rollback segments will be created later,
 
1536
                after the double write buffer has been created. */
 
1537
                trx_sys_create();
 
1538
 
 
1539
                dict_create();
 
1540
 
 
1541
                srv_startup_is_before_trx_rollback_phase = FALSE;
 
1542
 
 
1543
#ifdef UNIV_LOG_ARCHIVE
 
1544
        } else if (srv_archive_recovery) {
 
1545
                fprintf(stderr,
 
1546
                        "InnoDB: Starting archive"
 
1547
                        " recovery from a backup...\n");
 
1548
                err = recv_recovery_from_archive_start(
 
1549
                        min_flushed_lsn, srv_archive_recovery_limit_lsn,
 
1550
                        min_arch_log_no);
 
1551
                if (err != DB_SUCCESS) {
 
1552
 
 
1553
                        return(DB_ERROR);
 
1554
                }
 
1555
                /* Since ibuf init is in dict_boot, and ibuf is needed
 
1556
                in any disk i/o, first call dict_boot */
 
1557
 
 
1558
                dict_boot();
 
1559
 
 
1560
                trx_sys_init_at_db_start();
 
1561
 
 
1562
                srv_startup_is_before_trx_rollback_phase = FALSE;
 
1563
 
 
1564
                /* Initialize the fsp free limit global variable in the log
 
1565
                system */
 
1566
                fsp_header_get_free_limit();
 
1567
 
 
1568
                recv_recovery_from_archive_finish();
 
1569
#endif /* UNIV_LOG_ARCHIVE */
 
1570
        } else {
 
1571
 
 
1572
                /* Check if we support the max format that is stamped
 
1573
                on the system tablespace. 
 
1574
                Note:  We are NOT allowed to make any modifications to
 
1575
                the TRX_SYS_PAGE_NO page before recovery  because this
 
1576
                page also contains the max_trx_id etc. important system
 
1577
                variables that are required for recovery.  We need to
 
1578
                ensure that we return the system to a state where normal
 
1579
                recovery is guaranteed to work. We do this by
 
1580
                invalidating the buffer cache, this will force the
 
1581
                reread of the page and restoration to its last known
 
1582
                consistent state, this is REQUIRED for the recovery
 
1583
                process to work. */
 
1584
                err = trx_sys_file_format_max_check(
 
1585
                        srv_max_file_format_at_startup);
 
1586
 
 
1587
                if (err != DB_SUCCESS) {
 
1588
                        return(err);
 
1589
                }
 
1590
 
 
1591
                /* Invalidate the buffer pool to ensure that we reread
 
1592
                the page that we read above, during recovery.
 
1593
                Note that this is not as heavy weight as it seems. At
 
1594
                this point there will be only ONE page in the buf_LRU
 
1595
                and there must be no page in the buf_flush list. */
 
1596
                buf_pool_invalidate();
 
1597
 
 
1598
                /* We always try to do a recovery, even if the database had
 
1599
                been shut down normally: this is the normal startup path */
 
1600
 
 
1601
                err = recv_recovery_from_checkpoint_start(LOG_CHECKPOINT,
 
1602
                                                          IB_ULONGLONG_MAX,
 
1603
                                                          min_flushed_lsn,
 
1604
                                                          max_flushed_lsn);
 
1605
                if (err != DB_SUCCESS) {
 
1606
 
 
1607
                        return(DB_ERROR);
 
1608
                }
 
1609
 
 
1610
                /* Since the insert buffer init is in dict_boot, and the
 
1611
                insert buffer is needed in any disk i/o, first we call
 
1612
                dict_boot(). Note that trx_sys_init_at_db_start() only needs
 
1613
                to access space 0, and the insert buffer at this stage already
 
1614
                works for space 0. */
 
1615
 
 
1616
                dict_boot();
 
1617
                trx_sys_init_at_db_start();
 
1618
 
 
1619
                /* Initialize the fsp free limit global variable in the log
 
1620
                system */
 
1621
                fsp_header_get_free_limit();
 
1622
 
 
1623
                /* recv_recovery_from_checkpoint_finish needs trx lists which
 
1624
                are initialized in trx_sys_init_at_db_start(). */
 
1625
 
 
1626
                recv_recovery_from_checkpoint_finish();
 
1627
                if (srv_force_recovery < SRV_FORCE_NO_IBUF_MERGE) {
 
1628
                        /* The following call is necessary for the insert
 
1629
                        buffer to work with multiple tablespaces. We must
 
1630
                        know the mapping between space id's and .ibd file
 
1631
                        names.
 
1632
 
 
1633
                        In a crash recovery, we check that the info in data
 
1634
                        dictionary is consistent with what we already know
 
1635
                        about space id's from the call of
 
1636
                        fil_load_single_table_tablespaces().
 
1637
 
 
1638
                        In a normal startup, we create the space objects for
 
1639
                        every table in the InnoDB data dictionary that has
 
1640
                        an .ibd file.
 
1641
 
 
1642
                        We also determine the maximum tablespace id used. */
 
1643
 
 
1644
                        dict_check_tablespaces_and_store_max_id(
 
1645
                                recv_needed_recovery);
 
1646
                }
 
1647
 
 
1648
                srv_startup_is_before_trx_rollback_phase = FALSE;
 
1649
                recv_recovery_rollback_active();
 
1650
 
 
1651
                /* It is possible that file_format tag has never
 
1652
                been set. In this case we initialize it to minimum
 
1653
                value.  Important to note that we can do it ONLY after
 
1654
                we have finished the recovery process so that the
 
1655
                image of TRX_SYS_PAGE_NO is not stale. */
 
1656
                trx_sys_file_format_tag_init();
 
1657
        }
 
1658
 
 
1659
        if (!create_new_db && sum_of_new_sizes > 0) {
 
1660
                /* New data file(s) were added */
 
1661
                mtr_start(&mtr);
 
1662
 
 
1663
                fsp_header_inc_size(0, sum_of_new_sizes, &mtr);
 
1664
 
 
1665
                mtr_commit(&mtr);
 
1666
 
 
1667
                /* Immediately write the log record about increased tablespace
 
1668
                size to disk, so that it is durable even if mysqld would crash
 
1669
                quickly */
 
1670
 
 
1671
                log_buffer_flush_to_disk();
 
1672
        }
 
1673
 
 
1674
#ifdef UNIV_LOG_ARCHIVE
 
1675
        /* Archiving is always off under MySQL */
 
1676
        if (!srv_log_archive_on) {
 
1677
                ut_a(DB_SUCCESS == log_archive_noarchivelog());
 
1678
        } else {
 
1679
                mutex_enter(&(log_sys->mutex));
 
1680
 
 
1681
                start_archive = FALSE;
 
1682
 
 
1683
                if (log_sys->archiving_state == LOG_ARCH_OFF) {
 
1684
                        start_archive = TRUE;
 
1685
                }
 
1686
 
 
1687
                mutex_exit(&(log_sys->mutex));
 
1688
 
 
1689
                if (start_archive) {
 
1690
                        ut_a(DB_SUCCESS == log_archive_archivelog());
 
1691
                }
 
1692
        }
 
1693
#endif /* UNIV_LOG_ARCHIVE */
 
1694
 
 
1695
        /* fprintf(stderr, "Max allowed record size %lu\n",
 
1696
        page_get_free_space_of_empty() / 2); */
 
1697
 
 
1698
        if (trx_doublewrite == NULL) {
 
1699
                /* Create the doublewrite buffer to a new tablespace */
 
1700
 
 
1701
                trx_sys_create_doublewrite_buf();
 
1702
        }
 
1703
 
 
1704
        /* Here the double write buffer has already been created and so
 
1705
        any new rollback segments will be allocated after the double
 
1706
        write buffer. The default segment should already exist.
 
1707
        We create the new segments only if it's a new database or
 
1708
        the database was shutdown cleanly. */
 
1709
 
 
1710
        /* Note: When creating the extra rollback segments during an upgrade
 
1711
        we violate the latching order, even if the change buffer is empty.
 
1712
        We make an exception in sync0sync.c and check srv_is_being_started
 
1713
        for that violation. It cannot create a deadlock because we are still
 
1714
        running in single threaded mode essentially. Only the IO threads
 
1715
        should be running at this stage. */
 
1716
 
 
1717
        trx_sys_create_rsegs(TRX_SYS_N_RSEGS - 1);
 
1718
 
 
1719
        /* Create the thread which watches the timeouts for lock waits */
 
1720
        os_thread_create(&srv_lock_timeout_thread, NULL,
 
1721
                         thread_ids + 2 + SRV_MAX_N_IO_THREADS);
 
1722
 
 
1723
        /* Create the thread which warns of long semaphore waits */
 
1724
        os_thread_create(&srv_error_monitor_thread, NULL,
 
1725
                         thread_ids + 3 + SRV_MAX_N_IO_THREADS);
 
1726
 
 
1727
        /* Create the thread which prints InnoDB monitor info */
 
1728
        os_thread_create(&srv_monitor_thread, NULL,
 
1729
                         thread_ids + 4 + SRV_MAX_N_IO_THREADS);
 
1730
 
 
1731
        srv_is_being_started = FALSE;
 
1732
 
 
1733
        err = dict_create_or_check_foreign_constraint_tables();
 
1734
 
 
1735
        if (err != DB_SUCCESS) {
 
1736
                return((int)DB_ERROR);
 
1737
        }
 
1738
 
 
1739
        /* Create the master thread which does purge and other utility
 
1740
        operations */
 
1741
 
 
1742
        os_thread_create(&srv_master_thread, NULL, thread_ids
 
1743
                         + (1 + SRV_MAX_N_IO_THREADS));
 
1744
 
 
1745
        /* Currently we allow only a single purge thread. */
 
1746
        ut_a(srv_n_purge_threads == 0 || srv_n_purge_threads == 1);
 
1747
 
 
1748
        /* If the user has requested a separate purge thread then
 
1749
        start the purge thread. */
 
1750
        if (srv_n_purge_threads == 1) {
 
1751
                os_thread_create(&srv_purge_thread, NULL, NULL);
 
1752
        }
 
1753
 
 
1754
#ifdef UNIV_DEBUG
 
1755
        /* buf_debug_prints = TRUE; */
 
1756
#endif /* UNIV_DEBUG */
 
1757
        sum_of_data_file_sizes = 0;
 
1758
 
 
1759
        for (i = 0; i < srv_n_data_files; i++) {
 
1760
                sum_of_data_file_sizes += srv_data_file_sizes[i];
 
1761
        }
 
1762
 
 
1763
        tablespace_size_in_header = fsp_header_get_tablespace_size();
 
1764
 
 
1765
        if (!srv_auto_extend_last_data_file
 
1766
            && sum_of_data_file_sizes != tablespace_size_in_header) {
 
1767
 
 
1768
                fprintf(stderr,
 
1769
                        "InnoDB: Error: tablespace size"
 
1770
                        " stored in header is %lu pages, but\n"
 
1771
                        "InnoDB: the sum of data file sizes is %lu pages\n",
 
1772
                        (ulong) tablespace_size_in_header,
 
1773
                        (ulong) sum_of_data_file_sizes);
 
1774
 
 
1775
                if (srv_force_recovery == 0
 
1776
                    && sum_of_data_file_sizes < tablespace_size_in_header) {
 
1777
                        /* This is a fatal error, the tail of a tablespace is
 
1778
                        missing */
 
1779
 
 
1780
                        fprintf(stderr,
 
1781
                                "InnoDB: Cannot start InnoDB."
 
1782
                                " The tail of the system tablespace is\n"
 
1783
                                "InnoDB: missing. Have you edited"
 
1784
                                " innodb_data_file_path in my.cnf in an\n"
 
1785
                                "InnoDB: inappropriate way, removing"
 
1786
                                " ibdata files from there?\n"
 
1787
                                "InnoDB: You can set innodb_force_recovery=1"
 
1788
                                " in my.cnf to force\n"
 
1789
                                "InnoDB: a startup if you are trying"
 
1790
                                " to recover a badly corrupt database.\n");
 
1791
 
 
1792
                        return(DB_ERROR);
 
1793
                }
 
1794
        }
 
1795
 
 
1796
        if (srv_auto_extend_last_data_file
 
1797
            && sum_of_data_file_sizes < tablespace_size_in_header) {
 
1798
 
 
1799
                fprintf(stderr,
 
1800
                        "InnoDB: Error: tablespace size stored in header"
 
1801
                        " is %lu pages, but\n"
 
1802
                        "InnoDB: the sum of data file sizes"
 
1803
                        " is only %lu pages\n",
 
1804
                        (ulong) tablespace_size_in_header,
 
1805
                        (ulong) sum_of_data_file_sizes);
 
1806
 
 
1807
                if (srv_force_recovery == 0) {
 
1808
 
 
1809
                        fprintf(stderr,
 
1810
                                "InnoDB: Cannot start InnoDB. The tail of"
 
1811
                                " the system tablespace is\n"
 
1812
                                "InnoDB: missing. Have you edited"
 
1813
                                " innodb_data_file_path in my.cnf in an\n"
 
1814
                                "InnoDB: inappropriate way, removing"
 
1815
                                " ibdata files from there?\n"
 
1816
                                "InnoDB: You can set innodb_force_recovery=1"
 
1817
                                " in my.cnf to force\n"
 
1818
                                "InnoDB: a startup if you are trying to"
 
1819
                                " recover a badly corrupt database.\n");
 
1820
 
 
1821
                        return(DB_ERROR);
 
1822
                }
 
1823
        }
 
1824
 
 
1825
        /* Check that os_fast_mutexes work as expected */
 
1826
        os_fast_mutex_init(&srv_os_test_mutex);
 
1827
 
 
1828
        if (0 != os_fast_mutex_trylock(&srv_os_test_mutex)) {
 
1829
                fprintf(stderr,
 
1830
                        "InnoDB: Error: pthread_mutex_trylock returns"
 
1831
                        " an unexpected value on\n"
 
1832
                        "InnoDB: success! Cannot continue.\n");
 
1833
                exit(1);
 
1834
        }
 
1835
 
 
1836
        os_fast_mutex_unlock(&srv_os_test_mutex);
 
1837
 
 
1838
        os_fast_mutex_lock(&srv_os_test_mutex);
 
1839
 
 
1840
        os_fast_mutex_unlock(&srv_os_test_mutex);
 
1841
 
 
1842
        os_fast_mutex_free(&srv_os_test_mutex);
 
1843
 
 
1844
        if (srv_print_verbose_log) {
 
1845
                ut_print_timestamp(stderr);
 
1846
                fprintf(stderr,
 
1847
                        "  InnoDB %s started; "
 
1848
                        "log sequence number %"PRIu64"\n",
 
1849
                        INNODB_VERSION_STR, srv_start_lsn);
 
1850
        }
 
1851
 
 
1852
        if (srv_force_recovery > 0) {
 
1853
                fprintf(stderr,
 
1854
                        "InnoDB: !!! innodb_force_recovery"
 
1855
                        " is set to %lu !!!\n",
 
1856
                        (ulong) srv_force_recovery);
 
1857
        }
 
1858
 
 
1859
        fflush(stderr);
 
1860
 
 
1861
        if (trx_doublewrite_must_reset_space_ids) {
 
1862
                /* Actually, we did not change the undo log format between
 
1863
                4.0 and 4.1.1, and we would not need to run purge to
 
1864
                completion. Note also that the purge algorithm in 4.1.1
 
1865
                can process the the history list again even after a full
 
1866
                purge, because our algorithm does not cut the end of the
 
1867
                history list in all cases so that it would become empty
 
1868
                after a full purge. That mean that we may purge 4.0 type
 
1869
                undo log even after this phase.
 
1870
 
 
1871
                The insert buffer record format changed between 4.0 and
 
1872
                4.1.1. It is essential that the insert buffer is emptied
 
1873
                here! */
 
1874
 
 
1875
                fprintf(stderr,
 
1876
                        "InnoDB: You are upgrading to an"
 
1877
                        " InnoDB version which allows multiple\n"
 
1878
                        "InnoDB: tablespaces. Wait that purge"
 
1879
                        " and insert buffer merge run to\n"
 
1880
                        "InnoDB: completion...\n");
 
1881
                for (;;) {
 
1882
                        os_thread_sleep(1000000);
 
1883
 
 
1884
                        if (0 == strcmp(srv_main_thread_op_info,
 
1885
                                        "waiting for server activity")) {
 
1886
 
 
1887
                                ut_a(ibuf_is_empty());
 
1888
 
 
1889
                                break;
 
1890
                        }
 
1891
                }
 
1892
                fprintf(stderr,
 
1893
                        "InnoDB: Full purge and insert buffer merge"
 
1894
                        " completed.\n");
 
1895
 
 
1896
                trx_sys_mark_upgraded_to_multiple_tablespaces();
 
1897
 
 
1898
                fprintf(stderr,
 
1899
                        "InnoDB: You have now successfully upgraded"
 
1900
                        " to the multiple tablespaces\n"
 
1901
                        "InnoDB: format. You should NOT DOWNGRADE"
 
1902
                        " to an earlier version of\n"
 
1903
                        "InnoDB: InnoDB! But if you absolutely need to"
 
1904
                        " downgrade, see\n"
 
1905
                        "InnoDB: " REFMAN "multiple-tablespaces.html\n"
 
1906
                        "InnoDB: for instructions.\n");
 
1907
        }
 
1908
 
 
1909
        if (srv_force_recovery == 0) {
 
1910
                /* In the insert buffer we may have even bigger tablespace
 
1911
                id's, because we may have dropped those tablespaces, but
 
1912
                insert buffer merge has not had time to clean the records from
 
1913
                the ibuf tree. */
 
1914
 
 
1915
                ibuf_update_max_tablespace_id();
 
1916
        }
 
1917
 
 
1918
        srv_file_per_table = srv_file_per_table_original_value;
 
1919
 
 
1920
        srv_was_started = TRUE;
 
1921
 
 
1922
        return((int) DB_SUCCESS);
 
1923
}
 
1924
 
 
1925
/****************************************************************//**
 
1926
Shuts down the InnoDB database.
 
1927
@return DB_SUCCESS or error code */
 
1928
UNIV_INTERN
 
1929
int
 
1930
innobase_shutdown_for_mysql(void)
 
1931
/*=============================*/
 
1932
{
 
1933
        ulint   i;
 
1934
        if (!srv_was_started) {
 
1935
                if (srv_is_being_started) {
 
1936
                        ut_print_timestamp(stderr);
 
1937
                        fprintf(stderr,
 
1938
                                "  InnoDB: Warning: shutting down"
 
1939
                                " a not properly started\n"
 
1940
                                "InnoDB: or created database!\n");
 
1941
                }
 
1942
 
 
1943
                return(DB_SUCCESS);
 
1944
        }
 
1945
 
 
1946
        /* 1. Flush the buffer pool to disk, write the current lsn to
 
1947
        the tablespace header(s), and copy all log data to archive.
 
1948
        The step 1 is the real InnoDB shutdown. The remaining steps 2 - ...
 
1949
        just free data structures after the shutdown. */
 
1950
 
 
1951
 
 
1952
        if (srv_fast_shutdown == 2) {
 
1953
                ut_print_timestamp(stderr);
 
1954
                fprintf(stderr,
 
1955
                        "  InnoDB: MySQL has requested a very fast shutdown"
 
1956
                        " without flushing "
 
1957
                        "the InnoDB buffer pool to data files."
 
1958
                        " At the next mysqld startup "
 
1959
                        "InnoDB will do a crash recovery!\n");
 
1960
        }
 
1961
 
 
1962
        logs_empty_and_mark_files_at_shutdown();
 
1963
 
 
1964
        if (srv_conc_n_threads != 0) {
 
1965
                fprintf(stderr,
 
1966
                        "InnoDB: Warning: query counter shows %ld queries"
 
1967
                        " still\n"
 
1968
                        "InnoDB: inside InnoDB at shutdown\n",
 
1969
                        srv_conc_n_threads);
 
1970
        }
 
1971
 
 
1972
        /* 2. Make all threads created by InnoDB to exit */
 
1973
 
 
1974
        srv_shutdown_state = SRV_SHUTDOWN_EXIT_THREADS;
 
1975
 
 
1976
        /* In a 'very fast' shutdown, we do not need to wait for these threads
 
1977
        to die; all which counts is that we flushed the log; a 'very fast'
 
1978
        shutdown is essentially a crash. */
 
1979
 
 
1980
        if (srv_fast_shutdown == 2) {
 
1981
                return(DB_SUCCESS);
 
1982
        }
 
1983
 
 
1984
        /* All threads end up waiting for certain events. Put those events
 
1985
        to the signaled state. Then the threads will exit themselves in
 
1986
        os_thread_event_wait(). */
 
1987
 
 
1988
        for (i = 0; i < 1000; i++) {
 
1989
                /* NOTE: IF YOU CREATE THREADS IN INNODB, YOU MUST EXIT THEM
 
1990
                HERE OR EARLIER */
 
1991
 
 
1992
                /* a. Let the lock timeout thread exit */
 
1993
                os_event_set(srv_lock_timeout_thread_event);
 
1994
 
 
1995
                /* b. srv error monitor thread exits automatically, no need
 
1996
                to do anything here */
 
1997
 
 
1998
                /* c. We wake the master thread so that it exits */
 
1999
                srv_wake_master_thread();
 
2000
 
 
2001
                /* d. We wake the purge thread so that it exits */
 
2002
                srv_wake_purge_thread();
 
2003
 
 
2004
                /* e. Exit the i/o threads */
 
2005
 
 
2006
                os_aio_wake_all_threads_at_shutdown();
 
2007
 
 
2008
                os_mutex_enter(os_sync_mutex);
 
2009
 
 
2010
                if (os_thread_count == 0) {
 
2011
                        /* All the threads have exited or are just exiting;
 
2012
                        NOTE that the threads may not have completed their
 
2013
                        exit yet. Should we use pthread_join() to make sure
 
2014
                        they have exited? If we did, we would have to
 
2015
                        remove the pthread_detach() from
 
2016
                        os_thread_exit().  Now we just sleep 0.1
 
2017
                        seconds and hope that is enough! */
 
2018
 
 
2019
                        os_mutex_exit(os_sync_mutex);
 
2020
 
 
2021
                        os_thread_sleep(100000);
 
2022
 
 
2023
                        break;
 
2024
                }
 
2025
 
 
2026
                os_mutex_exit(os_sync_mutex);
 
2027
 
 
2028
                os_thread_sleep(100000);
 
2029
        }
 
2030
 
 
2031
        if (i == 1000) {
 
2032
                fprintf(stderr,
 
2033
                        "InnoDB: Warning: %lu threads created by InnoDB"
 
2034
                        " had not exited at shutdown!\n",
 
2035
                        (ulong) os_thread_count);
 
2036
        }
 
2037
 
 
2038
        if (srv_monitor_file) {
 
2039
                fclose(srv_monitor_file);
 
2040
                srv_monitor_file = 0;
 
2041
                if (srv_monitor_file_name) {
 
2042
                        unlink(srv_monitor_file_name);
 
2043
                        mem_free(srv_monitor_file_name);
 
2044
                }
 
2045
        }
 
2046
        if (srv_dict_tmpfile) {
 
2047
                fclose(srv_dict_tmpfile);
 
2048
                srv_dict_tmpfile = 0;
 
2049
        }
 
2050
 
 
2051
        if (srv_misc_tmpfile) {
 
2052
                fclose(srv_misc_tmpfile);
 
2053
                srv_misc_tmpfile = 0;
 
2054
        }
 
2055
 
 
2056
        /* This must be disabled before closing the buffer pool
 
2057
        and closing the data dictionary.  */
 
2058
        btr_search_disable();
 
2059
 
 
2060
        ibuf_close();
 
2061
        log_shutdown();
 
2062
        lock_sys_close();
 
2063
        thr_local_close();
 
2064
        trx_sys_file_format_close();
 
2065
        trx_sys_close();
 
2066
 
 
2067
        mutex_free(&srv_monitor_file_mutex);
 
2068
        mutex_free(&srv_dict_tmpfile_mutex);
 
2069
        mutex_free(&srv_misc_tmpfile_mutex);
 
2070
        dict_close();
 
2071
        btr_search_sys_free();
 
2072
 
 
2073
        /* 3. Free all InnoDB's own mutexes and the os_fast_mutexes inside
 
2074
        them */
 
2075
        os_aio_free();
 
2076
        sync_close();
 
2077
        srv_free();
 
2078
        fil_close();
 
2079
 
 
2080
        /* 4. Free the os_conc_mutex and all os_events and os_mutexes */
 
2081
 
 
2082
        os_sync_free();
 
2083
 
 
2084
        /* 5. Free all allocated memory */
 
2085
 
 
2086
        pars_lexer_close();
 
2087
        log_mem_free();
 
2088
        buf_pool_free(srv_buf_pool_instances);
 
2089
        mem_close();
 
2090
 
 
2091
        /* ut_free_all_mem() frees all allocated memory not freed yet
 
2092
        in shutdown, and it will also free the ut_list_mutex, so it
 
2093
        should be the last one for all operation */
 
2094
        ut_free_all_mem();
 
2095
 
 
2096
        if (os_thread_count != 0
 
2097
            || os_event_count != 0
 
2098
            || os_mutex_count != 0
 
2099
            || os_fast_mutex_count != 0) {
 
2100
                fprintf(stderr,
 
2101
                        "InnoDB: Warning: some resources were not"
 
2102
                        " cleaned up in shutdown:\n"
 
2103
                        "InnoDB: threads %lu, events %lu,"
 
2104
                        " os_mutexes %lu, os_fast_mutexes %lu\n",
 
2105
                        (ulong) os_thread_count, (ulong) os_event_count,
 
2106
                        (ulong) os_mutex_count, (ulong) os_fast_mutex_count);
 
2107
        }
 
2108
 
 
2109
        if (dict_foreign_err_file) {
 
2110
                fclose(dict_foreign_err_file);
 
2111
        }
 
2112
        if (lock_latest_err_file) {
 
2113
                fclose(lock_latest_err_file);
 
2114
        }
 
2115
 
 
2116
        if (srv_print_verbose_log) {
 
2117
                ut_print_timestamp(stderr);
 
2118
                fprintf(stderr,
 
2119
                        "  InnoDB: Shutdown completed;"
 
2120
                        " log sequence number %"PRIu64"\n",
 
2121
                        srv_shutdown_lsn);
 
2122
        }
 
2123
 
 
2124
        srv_was_started = FALSE;
 
2125
        srv_start_has_been_called = FALSE;
 
2126
 
 
2127
        return((int) DB_SUCCESS);
 
2128
}
 
2129
#endif /* !UNIV_HOTBACKUP */