← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

  • Committer: Brian Aker
  • Date: 2008-08-16 15:41:14 UTC
  • mto: This revision was merged to the branch mainline in revision 346.
  • Revision ID: brian@tangent.org-20080816154114-eufmwf31p6ie1nd6
Cleaned up depend in Proto utils. Modified int to bool. Put TmpTable class
into play.

Show diffs side-by-side

added added

removed removed

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