← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

Moved the last of the libdrizzleclient calls into Protocol.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/srv/srv0start.c
22
22
Place, Suite 330, Boston, MA 02111-1307 USA
23
23
 
24
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
 
25
 
 
26
/************************************************************************
54
27
Starts the InnoDB database server
55
28
 
56
29
Created 2/16/1996 Heikki Tuuri
57
30
*************************************************************************/
58
31
 
 
32
#include "os0proc.h"
 
33
#include "sync0sync.h"
59
34
#include "ut0mem.h"
60
35
#include "mem0mem.h"
61
36
#include "data0data.h"
62
37
#include "data0type.h"
63
38
#include "dict0dict.h"
64
39
#include "buf0buf.h"
 
40
#include "buf0flu.h"
 
41
#include "buf0rea.h"
65
42
#include "os0file.h"
66
43
#include "os0thread.h"
67
44
#include "fil0fil.h"
68
45
#include "fsp0fsp.h"
69
46
#include "rem0rec.h"
 
47
#include "rem0cmp.h"
70
48
#include "mtr0mtr.h"
71
49
#include "log0log.h"
72
50
#include "log0recv.h"
73
51
#include "page0page.h"
74
52
#include "page0cur.h"
75
53
#include "trx0trx.h"
 
54
#include "dict0boot.h"
 
55
#include "dict0load.h"
76
56
#include "trx0sys.h"
 
57
#include "dict0crea.h"
77
58
#include "btr0btr.h"
 
59
#include "btr0pcur.h"
78
60
#include "btr0cur.h"
 
61
#include "btr0sea.h"
79
62
#include "rem0rec.h"
 
63
#include "srv0srv.h"
 
64
#include "que0que.h"
 
65
#include "usr0sess.h"
 
66
#include "lock0lock.h"
 
67
#include "trx0roll.h"
 
68
#include "trx0purge.h"
 
69
#include "row0ins.h"
 
70
#include "row0sel.h"
 
71
#include "row0upd.h"
 
72
#include "row0row.h"
 
73
#include "row0mysql.h"
 
74
#include "lock0lock.h"
80
75
#include "ibuf0ibuf.h"
 
76
#include "pars0pars.h"
 
77
#include "btr0sea.h"
81
78
#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
 
#include <errno.h>
108
 
#include <unistd.h>
109
 
 
110
 
/** Log sequence number immediately after startup */
 
79
#include "que0que.h"
 
80
 
 
81
/* Log sequence number immediately after startup */
111
82
UNIV_INTERN ib_uint64_t srv_start_lsn;
112
 
/** Log sequence number at shutdown */
 
83
/* Log sequence number at shutdown */
113
84
UNIV_INTERN ib_uint64_t srv_shutdown_lsn;
114
85
 
115
86
#ifdef HAVE_DARWIN_THREADS
116
87
# include <sys/utsname.h>
117
 
/** TRUE if the F_FULLFSYNC option is available */
118
88
UNIV_INTERN ibool       srv_have_fullfsync = FALSE;
119
89
#endif
120
90
 
121
 
/** TRUE if a raw partition is in use */
122
91
UNIV_INTERN ibool       srv_start_raw_disk_in_use = FALSE;
123
92
 
124
 
/** TRUE if the server is being started, before rolling back any
125
 
incomplete transactions */
126
93
UNIV_INTERN ibool       srv_startup_is_before_trx_rollback_phase = FALSE;
127
 
/** TRUE if the server is being started */
128
94
UNIV_INTERN ibool       srv_is_being_started = FALSE;
129
 
/** TRUE if the server was successfully started */
130
95
UNIV_INTERN ibool       srv_was_started = FALSE;
131
 
/** TRUE if innobase_start_or_create_for_mysql() has been called */
 
96
#ifndef UNIV_HOTBACKUP
132
97
static ibool    srv_start_has_been_called = FALSE;
133
 
 
134
 
/** At a shutdown this value climbs from SRV_SHUTDOWN_NONE to
135
 
SRV_SHUTDOWN_CLEANUP and then to SRV_SHUTDOWN_LAST_PHASE, and so on */
136
 
UNIV_INTERN enum srv_shutdown_state     srv_shutdown_state = SRV_SHUTDOWN_NONE;
137
 
 
138
 
/** Files comprising the system tablespace */
 
98
#endif /* !UNIV_HOTBACKUP */
 
99
 
 
100
/* At a shutdown the value first climbs to SRV_SHUTDOWN_CLEANUP
 
101
and then to SRV_SHUTDOWN_LAST_PHASE */
 
102
UNIV_INTERN ulint               srv_shutdown_state = 0;
 
103
 
 
104
#ifndef UNIV_HOTBACKUP
139
105
static os_file_t        files[1000];
140
106
 
141
 
/** Mutex protecting the ios count */
142
107
static mutex_t          ios_mutex;
143
 
/** Count of I/O operations in io_handler_thread() */
144
108
static ulint            ios;
145
109
 
146
 
/** io_handler_thread parameters for thread identification */
147
110
static ulint            n[SRV_MAX_N_IO_THREADS + 5];
148
 
/** io_handler_thread identifiers */
149
111
static os_thread_id_t   thread_ids[SRV_MAX_N_IO_THREADS + 5];
150
112
 
151
 
/** We use this mutex to test the return value of pthread_mutex_trylock
 
113
/* We use this mutex to test the return value of pthread_mutex_trylock
152
114
   on successful locking. HP-UX does NOT return 0, though Linux et al do. */
153
115
static os_fast_mutex_t  srv_os_test_mutex;
154
116
 
155
 
/** Name of srv_monitor_file */
 
117
/* Name of srv_monitor_file */
156
118
static char*    srv_monitor_file_name;
157
119
#endif /* !UNIV_HOTBACKUP */
158
120
 
159
 
/** */
160
121
#define SRV_N_PENDING_IOS_PER_THREAD    OS_AIO_N_PENDING_IOS_PER_THREAD
161
122
#define SRV_MAX_N_PENDING_SYNC_IOS      100
162
123
 
163
124
 
164
 
/*********************************************************************//**
165
 
Convert a numeric string that optionally ends in G or M, to a number
166
 
containing megabytes.
167
 
@return next character in string */
168
125
static
169
126
char*
170
127
srv_parse_megabytes(
171
128
/*================*/
172
 
        char*   str,    /*!< in: string containing a quantity in bytes */
173
 
        ulint*  megs)   /*!< out: the number in megabytes */
 
129
                        /* out: next character in string */
 
130
        char*   str,    /* in: string containing a quantity in bytes */
 
131
        ulint*  megs)   /* out: the number in megabytes */
174
132
{
175
133
        char*   endp;
176
134
        ulint   size;
195
153
        return(str);
196
154
}
197
155
 
198
 
/*********************************************************************//**
 
156
/*************************************************************************
199
157
Reads the data files and their sizes from a character string given in
200
 
the .cnf file.
201
 
@return TRUE if ok, FALSE on parse error */
 
158
the .cnf file. */
202
159
UNIV_INTERN
203
160
ibool
204
161
srv_parse_data_file_paths_and_sizes(
205
162
/*================================*/
206
 
        char*   str)    /*!< in/out: the data file path string */
 
163
                        /* out: TRUE if ok, FALSE on parse error */
 
164
        char*   str)    /* in/out: the data file path string */
207
165
{
208
166
        char*   input_str;
209
167
        char*   path;
379
337
        return(TRUE);
380
338
}
381
339
 
382
 
/*********************************************************************//**
 
340
/*************************************************************************
383
341
Reads log group home directories from a character string given in
384
 
the .cnf file.
385
 
@return TRUE if ok, FALSE on parse error */
 
342
the .cnf file. */
386
343
UNIV_INTERN
387
344
ibool
388
345
srv_parse_log_group_home_dirs(
389
346
/*==========================*/
390
 
        char*   str)    /*!< in/out: character string */
 
347
                        /* out: TRUE if ok, FALSE on parse error */
 
348
        char*   str)    /* in/out: character string */
391
349
{
392
350
        char*   input_str;
393
351
        char*   path;
451
409
        return(TRUE);
452
410
}
453
411
 
454
 
/*********************************************************************//**
 
412
/*************************************************************************
455
413
Frees the memory allocated by srv_parse_data_file_paths_and_sizes()
456
414
and srv_parse_log_group_home_dirs(). */
457
415
UNIV_INTERN
470
428
}
471
429
 
472
430
#ifndef UNIV_HOTBACKUP
473
 
/********************************************************************//**
474
 
I/o-handler thread function.
475
 
@return OS_THREAD_DUMMY_RETURN */
 
431
/************************************************************************
 
432
I/o-handler thread function. */
476
433
static
 
434
 
477
435
os_thread_ret_t
478
436
io_handler_thread(
479
437
/*==============*/
480
 
        void*   arg)    /*!< in: pointer to the number of the segment in
481
 
                        the aio array */
 
438
        void*   arg)
482
439
{
483
440
        ulint   segment;
484
441
        ulint   i;
501
458
        thread should always use that to exit and not use return() to exit.
502
459
        The thread actually never comes here because it is exited in an
503
460
        os_event_wait(). */
504
 
#if (!defined(__SUNPRO_C) && !defined(__SUNPRO_CC))
 
461
#ifndef UNIV_SOLARIS
505
462
        return 0;
506
463
#endif
507
464
}
513
470
#define SRV_PATH_SEPARATOR      '/'
514
471
#endif
515
472
 
516
 
/*********************************************************************//**
 
473
/*************************************************************************
517
474
Normalizes a directory path for Windows: converts slashes to backslashes. */
518
475
UNIV_INTERN
519
476
void
520
477
srv_normalize_path_for_win(
521
478
/*=======================*/
522
 
        char*   str __attribute__((unused)))    /*!< in/out: null-terminated
 
479
        char*   str __attribute__((unused)))    /* in/out: null-terminated
523
480
                                                character string */
524
481
{
525
482
#ifdef __WIN__
532
489
#endif
533
490
}
534
491
 
535
 
/*********************************************************************//**
 
492
/*************************************************************************
536
493
Adds a slash or a backslash to the end of a string if it is missing
537
 
and the string is not empty.
538
 
@return string which has the separator if the string is not empty */
 
494
and the string is not empty. */
539
495
UNIV_INTERN
540
496
char*
541
497
srv_add_path_separator_if_needed(
542
498
/*=============================*/
543
 
        char*   str)    /*!< in: null-terminated character string */
 
499
                        /* out: string which has the separator if the
 
500
                        string is not empty */
 
501
        char*   str)    /* in: null-terminated character string */
544
502
{
545
503
        char*   out_str;
546
504
        ulint   len     = ut_strlen(str);
559
517
}
560
518
 
561
519
#ifndef UNIV_HOTBACKUP
562
 
/*********************************************************************//**
 
520
/*************************************************************************
563
521
Calculates the low 32 bits when a file size which is given as a number
564
 
database pages is converted to the number of bytes.
565
 
@return low 32 bytes of file size when expressed in bytes */
 
522
database pages is converted to the number of bytes. */
566
523
static
567
524
ulint
568
525
srv_calc_low32(
569
526
/*===========*/
570
 
        ulint   file_size)      /*!< in: file size in database pages */
 
527
                                /* out: low 32 bytes of file size when
 
528
                                expressed in bytes */
 
529
        ulint   file_size)      /* in: file size in database pages */
571
530
{
572
531
        return(0xFFFFFFFFUL & (file_size << UNIV_PAGE_SIZE_SHIFT));
573
532
}
574
533
 
575
 
/*********************************************************************//**
 
534
/*************************************************************************
576
535
Calculates the high 32 bits when a file size which is given as a number
577
 
database pages is converted to the number of bytes.
578
 
@return high 32 bytes of file size when expressed in bytes */
 
536
database pages is converted to the number of bytes. */
579
537
static
580
538
ulint
581
539
srv_calc_high32(
582
540
/*============*/
583
 
        ulint   file_size)      /*!< in: file size in database pages */
 
541
                                /* out: high 32 bytes of file size when
 
542
                                expressed in bytes */
 
543
        ulint   file_size)      /* in: file size in database pages */
584
544
{
585
545
        return(file_size >> (32 - UNIV_PAGE_SIZE_SHIFT));
586
546
}
587
547
 
588
 
/*********************************************************************//**
589
 
Creates or opens the log files and closes them.
590
 
@return DB_SUCCESS or error code */
 
548
/*************************************************************************
 
549
Creates or opens the log files and closes them. */
591
550
static
592
551
ulint
593
552
open_or_create_log_file(
594
553
/*====================*/
595
 
        ibool   create_new_db,          /*!< in: TRUE if we should create a
 
554
                                        /* out: DB_SUCCESS or error code */
 
555
        ibool   create_new_db,          /* in: TRUE if we should create a
596
556
                                        new database */
597
 
        ibool*  log_file_created,       /*!< out: TRUE if new log file
 
557
        ibool*  log_file_created,       /* out: TRUE if new log file
598
558
                                        created */
599
 
        ibool   log_file_has_been_opened,/*!< in: TRUE if a log file has been
 
559
        ibool   log_file_has_been_opened,/* in: TRUE if a log file has been
600
560
                                        opened before: then it is an error
601
561
                                        to try to create another log file */
602
 
        ulint   k,                      /*!< in: log group number */
603
 
        ulint   i)                      /*!< in: log file number in group */
 
562
        ulint   k,                      /* in: log group number */
 
563
        ulint   i)                      /* in: log file number in group */
604
564
{
605
565
        ibool   ret;
606
566
        ulint   size;
738
698
        return(DB_SUCCESS);
739
699
}
740
700
 
741
 
/*********************************************************************//**
742
 
Creates or opens database data files and closes them.
743
 
@return DB_SUCCESS or error code */
 
701
/*************************************************************************
 
702
Creates or opens database data files and closes them. */
744
703
static
745
704
ulint
746
705
open_or_create_data_files(
747
706
/*======================*/
748
 
        ibool*          create_new_db,  /*!< out: TRUE if new database should be
 
707
                                        /* out: DB_SUCCESS or error code */
 
708
        ibool*          create_new_db,  /* out: TRUE if new database should be
749
709
                                        created */
750
710
#ifdef UNIV_LOG_ARCHIVE
751
 
        ulint*          min_arch_log_no,/*!< out: min of archived log
 
711
        ulint*          min_arch_log_no,/* out: min of archived log
752
712
                                        numbers in data files */
753
 
        ulint*          max_arch_log_no,/*!< out: max of archived log
 
713
        ulint*          max_arch_log_no,/* out: max of archived log
754
714
                                        numbers in data files */
755
715
#endif /* UNIV_LOG_ARCHIVE */
756
 
        ib_uint64_t*    min_flushed_lsn,/*!< out: min of flushed lsn
757
 
                                        values in data files */
758
 
        ib_uint64_t*    max_flushed_lsn,/*!< out: max of flushed lsn
759
 
                                        values in data files */
760
 
        ulint*          sum_of_new_sizes)/*!< out: sum of sizes of the
 
716
        ib_uint64_t*    min_flushed_lsn,/* out: min of flushed lsn
 
717
                                        values in data files */
 
718
        ib_uint64_t*    max_flushed_lsn,/* out: max of flushed lsn
 
719
                                        values in data files */
 
720
        ulint*          sum_of_new_sizes)/* out: sum of sizes of the
761
721
                                        new files added */
762
722
{
763
723
        ibool   ret;
1010
970
        return(DB_SUCCESS);
1011
971
}
1012
972
 
1013
 
/****************************************************************//**
 
973
/********************************************************************
1014
974
Starts InnoDB and creates a new database if database files
1015
 
are not found and the user wants.
1016
 
@return DB_SUCCESS or error code */
 
975
are not found and the user wants. */
1017
976
UNIV_INTERN
1018
977
int
1019
978
innobase_start_or_create_for_mysql(void)
1020
979
/*====================================*/
 
980
                                /* out: DB_SUCCESS or error code */
1021
981
{
1022
982
        buf_pool_t*     ret;
1023
983
        ibool           create_new_db;
1035
995
        ulint           tablespace_size_in_header;
1036
996
        ulint           err;
1037
997
        ulint           i;
1038
 
        ulint           io_limit;
1039
998
        my_bool         srv_file_per_table_original_value
1040
999
                = srv_file_per_table;
1041
1000
        mtr_t           mtr;
1109
1068
        }
1110
1069
 
1111
1070
#ifdef HAVE_GCC_ATOMIC_BUILTINS
1112
 
# ifdef INNODB_RW_LOCKS_USE_ATOMICS
 
1071
#ifdef INNODB_RW_LOCKS_USE_ATOMICS
1113
1072
        fprintf(stderr,
1114
1073
                "InnoDB: Mutexes and rw_locks use GCC atomic builtins.\n");
1115
 
# else /* INNODB_RW_LOCKS_USE_ATOMICS */
 
1074
#else /* INNODB_RW_LOCKS_USE_ATOMICS */
1116
1075
        fprintf(stderr,
1117
1076
                "InnoDB: Mutexes use GCC atomic builtins, rw_locks do not.\n");
1118
 
# endif /* INNODB_RW_LOCKS_USE_ATOMICS */
1119
 
#elif defined(HAVE_SOLARIS_ATOMICS)
1120
 
# ifdef INNODB_RW_LOCKS_USE_ATOMICS
1121
 
        fprintf(stderr,
1122
 
                "InnoDB: Mutexes and rw_locks use Solaris atomic functions.\n");
1123
 
# else
1124
 
        fprintf(stderr,
1125
 
                "InnoDB: Mutexes use Solaris atomic functions.\n");
1126
 
# endif /* INNODB_RW_LOCKS_USE_ATOMICS */
1127
 
#elif defined(HAVE_WINDOWS_ATOMICS)
1128
 
# ifdef INNODB_RW_LOCKS_USE_ATOMICS
1129
 
        fprintf(stderr,
1130
 
                "InnoDB: Mutexes and rw_locks use Windows interlocked functions.\n");
1131
 
# else
1132
 
        fprintf(stderr,
1133
 
                "InnoDB: Mutexes use Windows interlocked functions.\n");
1134
 
# endif /* INNODB_RW_LOCKS_USE_ATOMICS */
 
1077
#endif /* INNODB_RW_LOCKS_USE_ATOMICS */
1135
1078
#else /* HAVE_GCC_ATOMIC_BUILTINS */
1136
1079
        fprintf(stderr,
1137
1080
                "InnoDB: Neither mutexes nor rw_locks use GCC atomic builtins.\n");
1164
1107
        os_aio_use_native_aio = FALSE;
1165
1108
 
1166
1109
#ifdef __WIN__
1167
 
        switch (os_get_os_version()) {
1168
 
        case OS_WIN95:
1169
 
        case OS_WIN31:
1170
 
        case OS_WINNT:
 
1110
        if (os_get_os_version() == OS_WIN95
 
1111
            || os_get_os_version() == OS_WIN31
 
1112
            || os_get_os_version() == OS_WINNT) {
 
1113
 
1171
1114
                /* On Win 95, 98, ME, Win32 subsystem for Windows 3.1,
1172
1115
                and NT use simulated aio. In NT Windows provides async i/o,
1173
1116
                but when run in conjunction with InnoDB Hot Backup, it seemed
1174
1117
                to corrupt the data files. */
1175
1118
 
1176
1119
                os_aio_use_native_aio = FALSE;
1177
 
                break;
1178
 
        default:
 
1120
        } else {
1179
1121
                /* On Win 2000 and XP use async i/o */
1180
1122
                os_aio_use_native_aio = TRUE;
1181
 
                break;
1182
1123
        }
1183
1124
#endif
1184
1125
        if (srv_file_flush_method_str == NULL) {
1296
1237
                return(DB_ERROR);
1297
1238
        }
1298
1239
 
1299
 
        /* If user has set the value of innodb_file_io_threads then
1300
 
        we'll emit a message telling the user that this parameter
1301
 
        is now deprecated. */
1302
 
        if (srv_n_file_io_threads != 4) {
1303
 
                fprintf(stderr, "InnoDB: Warning:"
1304
 
                        " innodb_file_io_threads is deprecated."
1305
 
                        " Please use innodb_read_io_threads and"
1306
 
                        " innodb_write_io_threads instead\n");
 
1240
        /* Restrict the maximum number of file i/o threads */
 
1241
        if (srv_n_file_io_threads > SRV_MAX_N_IO_THREADS) {
 
1242
 
 
1243
                srv_n_file_io_threads = SRV_MAX_N_IO_THREADS;
1307
1244
        }
1308
1245
 
1309
 
        /* Now overwrite the value on srv_n_file_io_threads */
1310
 
        srv_n_file_io_threads = 2 + srv_n_read_io_threads
1311
 
                                + srv_n_write_io_threads;
1312
 
 
1313
 
        ut_a(srv_n_file_io_threads <= SRV_MAX_N_IO_THREADS);
1314
 
 
1315
 
        /* TODO: Investigate if SRV_N_PENDING_IOS_PER_THREAD (32) limit
1316
 
        still applies to windows. */
1317
1246
        if (!os_aio_use_native_aio) {
1318
 
                io_limit = 8 * SRV_N_PENDING_IOS_PER_THREAD;
 
1247
                /* In simulated aio we currently have use only for 4 threads */
 
1248
                srv_n_file_io_threads = 4;
 
1249
 
 
1250
                os_aio_init(8 * SRV_N_PENDING_IOS_PER_THREAD
 
1251
                            * srv_n_file_io_threads,
 
1252
                            srv_n_file_io_threads,
 
1253
                            SRV_MAX_N_PENDING_SYNC_IOS);
1319
1254
        } else {
1320
 
                io_limit = SRV_N_PENDING_IOS_PER_THREAD;
 
1255
                os_aio_init(SRV_N_PENDING_IOS_PER_THREAD
 
1256
                            * srv_n_file_io_threads,
 
1257
                            srv_n_file_io_threads,
 
1258
                            SRV_MAX_N_PENDING_SYNC_IOS);
1321
1259
        }
1322
1260
 
1323
 
        os_aio_init(io_limit,
1324
 
                    srv_n_read_io_threads,
1325
 
                    srv_n_write_io_threads,
1326
 
                    SRV_MAX_N_PENDING_SYNC_IOS);
1327
 
 
1328
 
        fil_init(srv_file_per_table ? 50000 : 5000,
1329
 
                 srv_max_n_open_files);
 
1261
        fil_init(srv_max_n_open_files);
1330
1262
 
1331
1263
        ret = buf_pool_init();
1332
1264
 
1871
1803
                        " to an earlier version of\n"
1872
1804
                        "InnoDB: InnoDB! But if you absolutely need to"
1873
1805
                        " downgrade, see\n"
1874
 
                        "InnoDB: " REFMAN "multiple-tablespaces.html\n"
 
1806
                        "InnoDB: http://dev.mysql.com/doc/refman/5.1/en/"
 
1807
                        "multiple-tablespaces.html\n"
1875
1808
                        "InnoDB: for instructions.\n");
1876
1809
        }
1877
1810
 
1891
1824
        return((int) DB_SUCCESS);
1892
1825
}
1893
1826
 
1894
 
/****************************************************************//**
1895
 
Shuts down the InnoDB database.
1896
 
@return DB_SUCCESS or error code */
 
1827
/********************************************************************
 
1828
Shuts down the InnoDB database. */
1897
1829
UNIV_INTERN
1898
1830
int
1899
1831
innobase_shutdown_for_mysql(void)
1900
1832
/*=============================*/
 
1833
                                /* out: DB_SUCCESS or error code */
1901
1834
{
1902
1835
        ulint   i;
1903
1836
#ifdef __NETWARE__
1932
1865
        }
1933
1866
 
1934
1867
#ifdef __NETWARE__
1935
 
        if (!panic_shutdown)
 
1868
        if(!panic_shutdown)
1936
1869
#endif
1937
1870
                logs_empty_and_mark_files_at_shutdown();
1938
1871