← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

  • Committer: Monty Taylor
  • Date: 2008-08-16 21:06:22 UTC
  • Revision ID: monty@inaugust.com-20080816210622-zpnn13unyinqzn72
Updated po files.

Show diffs side-by-side

added added

removed removed

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