← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

  • Committer: Monty Taylor
  • Date: 2010-12-22 03:15:22 UTC
  • mto: (2023.1.1 build)
  • mto: This revision was merged to the branch mainline in revision 2024.
  • Revision ID: mordred@inaugust.com-20101222031522-bmi73y3y00f480qs
Fixed some valgrind warning suppressions which were getting fooled by a
different stack.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/srv/srv0start.c
92
92
#include <errno.h>
93
93
#include <unistd.h>
94
94
 
95
 
#include <drizzled/gettext.h> 
96
 
#include <drizzled/errmsg_print.h>
97
 
 
98
95
/** Log sequence number immediately after startup */
99
96
UNIV_INTERN ib_uint64_t srv_start_lsn;
100
97
/** Log sequence number at shutdown */
126
123
/** Files comprising the system tablespace */
127
124
static os_file_t        files[1000];
128
125
 
 
126
/** Mutex protecting the ios count */
 
127
static mutex_t          ios_mutex;
 
128
/** Count of I/O operations in io_handler_thread() */
 
129
static ulint            ios;
 
130
 
129
131
/** io_handler_thread parameters for thread identification */
130
132
static ulint            n[SRV_MAX_N_IO_THREADS + 6];
131
133
/** io_handler_thread identifiers */
152
154
UNIV_INTERN mysql_pfs_key_t     srv_master_thread_key;
153
155
#endif /* UNIV_PFS_THREAD */
154
156
 
 
157
#ifdef UNIV_PFS_MUTEX
 
158
/* Key to register ios_mutex_key with performance schema */
 
159
UNIV_INTERN mysql_pfs_key_t     ios_mutex_key;
 
160
#endif /* UNIV_PFS_MUTEX */
 
161
 
155
162
/*********************************************************************//**
156
163
Convert a numeric string that optionally ends in G or M, to a number
157
164
containing megabytes.
282
289
                return(FALSE);
283
290
        }
284
291
 
285
 
        srv_data_file_names = static_cast<char **>(malloc(i * sizeof *srv_data_file_names));
286
 
        srv_data_file_sizes = static_cast<ulint *>(malloc(i * sizeof *srv_data_file_sizes));
287
 
        srv_data_file_is_raw_partition = static_cast<ulint *>(malloc(
288
 
                                                                     i * sizeof *srv_data_file_is_raw_partition));
 
292
        srv_data_file_names = malloc(i * sizeof *srv_data_file_names);
 
293
        srv_data_file_sizes = malloc(i * sizeof *srv_data_file_sizes);
 
294
        srv_data_file_is_raw_partition = malloc(
 
295
                i * sizeof *srv_data_file_is_raw_partition);
289
296
 
290
297
        srv_n_data_files = i;
291
298
 
415
422
                return(FALSE);
416
423
        }
417
424
 
418
 
        srv_log_group_home_dirs = static_cast<char **>(malloc(i * sizeof *srv_log_group_home_dirs));
 
425
        srv_log_group_home_dirs = malloc(i * sizeof *srv_log_group_home_dirs);
419
426
 
420
427
        /* Then store the actual values to our array */
421
428
 
464
471
/********************************************************************//**
465
472
I/o-handler thread function.
466
473
@return OS_THREAD_DUMMY_RETURN */
467
 
extern "C"
468
 
os_thread_ret_t
469
 
io_handler_thread(void* arg);
470
 
 
471
 
extern "C"
 
474
static
472
475
os_thread_ret_t
473
476
io_handler_thread(
474
477
/*==============*/
490
493
 
491
494
        while (srv_shutdown_state != SRV_SHUTDOWN_EXIT_THREADS) {
492
495
                fil_aio_wait(segment);
 
496
 
 
497
                mutex_enter(&ios_mutex);
 
498
                ios++;
 
499
                mutex_exit(&ios_mutex);
493
500
        }
494
501
 
 
502
        thr_local_free(os_thread_get_curr_id());
 
503
 
495
504
        /* We count the number of threads in os_thread_exit(). A created
496
505
        thread should always use that to exit and not use return() to exit.
497
506
        The thread actually never comes here because it is exited in an
512
521
void
513
522
srv_normalize_path_for_win(
514
523
/*=======================*/
515
 
        char*   /*str __attribute__((unused))*/)        /*!< in/out: null-terminated
 
524
        char*   str __attribute__((unused)))    /*!< in/out: null-terminated
516
525
                                                character string */
517
526
{
518
527
#ifdef __WIN__
604
613
                    && os_file_get_last_error(FALSE) != 100
605
614
#endif
606
615
                    ) {
607
 
                  drizzled::errmsg_printf(drizzled::error::ERROR,
608
 
                                          "InnoDB: Error in creating or opening %s", name);
 
616
                        fprintf(stderr,
 
617
                                "InnoDB: Error in creating"
 
618
                                " or opening %s\n", name);
609
619
 
610
 
                  return(DB_ERROR);
 
620
                        return(DB_ERROR);
611
621
                }
612
622
 
613
623
                files[i] = os_file_create(innodb_file_log_key, name,
614
624
                                          OS_FILE_OPEN, OS_FILE_AIO,
615
625
                                          OS_LOG_FILE, &ret);
616
626
                if (!ret) {
617
 
                  drizzled::errmsg_printf(drizzled::error::ERROR,
618
 
                                          "InnoDB: Error in opening %s.", name);
 
627
                        fprintf(stderr,
 
628
                                "InnoDB: Error in opening %s\n", name);
619
629
 
620
630
                        return(DB_ERROR);
621
631
                }
626
636
                if (size != srv_calc_low32(srv_log_file_size)
627
637
                    || size_high != srv_calc_high32(srv_log_file_size)) {
628
638
 
629
 
                  drizzled::errmsg_printf(drizzled::error::ERROR,
630
 
                                          "InnoDB: Error: log file %s is of different size %lu %lu bytes than specified in the .cnf"
631
 
                                          " file %lu %lu bytes!",
632
 
                                          name, (ulong) size_high, (ulong) size,
633
 
                                          (ulong) srv_calc_high32(srv_log_file_size),
634
 
                                          (ulong) srv_calc_low32(srv_log_file_size));
 
639
                        fprintf(stderr,
 
640
                                "InnoDB: Error: log file %s is"
 
641
                                " of different size %lu %lu bytes\n"
 
642
                                "InnoDB: than specified in the .cnf"
 
643
                                " file %lu %lu bytes!\n",
 
644
                                name, (ulong) size_high, (ulong) size,
 
645
                                (ulong) srv_calc_high32(srv_log_file_size),
 
646
                                (ulong) srv_calc_low32(srv_log_file_size));
635
647
 
636
648
                        return(DB_ERROR);
637
649
                }
638
650
        } else {
639
651
                *log_file_created = TRUE;
640
652
 
641
 
                drizzled::errmsg_printf(drizzled::error::INFO,
642
 
                                        "InnoDB: Log file %s did not exist: new to be created",
643
 
                                        name);
 
653
                ut_print_timestamp(stderr);
 
654
 
 
655
                fprintf(stderr,
 
656
                        "  InnoDB: Log file %s did not exist:"
 
657
                        " new to be created\n",
 
658
                        name);
644
659
                if (log_file_has_been_opened) {
645
660
 
646
661
                        return(DB_ERROR);
647
662
                }
648
663
 
649
 
                drizzled::errmsg_printf(drizzled::error::INFO,
650
 
                                        "InnoDB: Setting log file %s size to %lu MB",
651
 
                                        name, (ulong) srv_log_file_size
652
 
                                        >> (20 - UNIV_PAGE_SIZE_SHIFT));
 
664
                fprintf(stderr, "InnoDB: Setting log file %s size to %lu MB\n",
 
665
                        name, (ulong) srv_log_file_size
 
666
                        >> (20 - UNIV_PAGE_SIZE_SHIFT));
653
667
 
654
 
                drizzled::errmsg_printf(drizzled::error::INFO,
655
 
                                        "InnoDB: Database physically writes the file full: wait...\n");
 
668
                fprintf(stderr,
 
669
                        "InnoDB: Database physically writes the file"
 
670
                        " full: wait...\n");
656
671
 
657
672
                ret = os_file_set_size(name, files[i],
658
673
                                       srv_calc_low32(srv_log_file_size),
659
674
                                       srv_calc_high32(srv_log_file_size));
660
675
                if (!ret) {
661
 
                  drizzled::errmsg_printf(drizzled::error::ERROR,
662
 
                                          "InnoDB: Error in creating %s: probably out of disk space",
663
 
                                          name);
 
676
                        fprintf(stderr,
 
677
                                "InnoDB: Error in creating %s:"
 
678
                                " probably out of disk space\n",
 
679
                                name);
664
680
 
665
681
                        return(DB_ERROR);
666
682
                }
737
753
        char    name[10000];
738
754
 
739
755
        if (srv_n_data_files >= 1000) {
740
 
          drizzled::errmsg_printf(drizzled::error::ERROR,
741
 
                                  "InnoDB: can only have < 1000 data files you have defined %lu",
742
 
                                  (ulong) srv_n_data_files);
 
756
                fprintf(stderr, "InnoDB: can only have < 1000 data files\n"
 
757
                        "InnoDB: you have defined %lu\n",
 
758
                        (ulong) srv_n_data_files);
743
759
                return(DB_ERROR);
744
760
        }
745
761
 
784
800
                            && os_file_get_last_error(FALSE) != 100
785
801
#endif
786
802
                            ) {
787
 
                          drizzled::errmsg_printf(drizzled::error::ERROR,
788
 
                                                  "InnoDB: Error in creating or opening %s",
789
 
                                                  name);
 
803
                                fprintf(stderr,
 
804
                                        "InnoDB: Error in creating"
 
805
                                        " or opening %s\n",
 
806
                                        name);
790
807
 
791
808
                                return(DB_ERROR);
792
809
                        }
802
819
                                                  OS_FILE_NORMAL,
803
820
                                                  OS_DATA_FILE, &ret);
804
821
                        if (!ret) {
805
 
                          drizzled::errmsg_printf(drizzled::error::ERROR,
806
 
                                                  "InnoDB: Error in opening %s", name);
 
822
                                fprintf(stderr,
 
823
                                        "InnoDB: Error in opening %s\n", name);
807
824
 
808
825
                                return(DB_ERROR);
809
826
                        }
819
836
                        /* We open the data file */
820
837
 
821
838
                        if (one_created) {
822
 
                          drizzled::errmsg_printf(drizzled::error::ERROR,
823
 
                                        "InnoDB: Error: data files can only be added at the end of a tablespace, but"
824
 
                                        " data file %s existed beforehand.",
825
 
                                        name);
 
839
                                fprintf(stderr,
 
840
                                        "InnoDB: Error: data files can only"
 
841
                                        " be added at the end\n");
 
842
                                fprintf(stderr,
 
843
                                        "InnoDB: of a tablespace, but"
 
844
                                        " data file %s existed beforehand.\n",
 
845
                                        name);
826
846
                                return(DB_ERROR);
827
847
                        }
828
848
 
844
864
                        }
845
865
 
846
866
                        if (!ret) {
847
 
                          drizzled::errmsg_printf(drizzled::error::ERROR,
848
 
                                                  "InnoDB: Error in opening %s", name);
 
867
                                fprintf(stderr,
 
868
                                        "InnoDB: Error in opening %s\n", name);
849
869
                                os_file_get_last_error(TRUE);
850
870
 
851
871
                                return(DB_ERROR);
872
892
                                        && srv_last_file_size_max
873
893
                                        < rounded_size_pages)) {
874
894
 
875
 
                                  drizzled::errmsg_printf(drizzled::error::ERROR,
876
 
                                                          "InnoDB: Error: auto-extending data file %s is of a different size. "
877
 
                                                          "%lu pages (rounded down to MB) than specified in the .cnf file: "
878
 
                                                          "initial %lu pages, max %lu (relevant if non-zero) pages!",
879
 
                                                          name,
880
 
                                                          (ulong) rounded_size_pages,
881
 
                                                          (ulong) srv_data_file_sizes[i],
882
 
                                                          (ulong)
883
 
                                                          srv_last_file_size_max);
 
895
                                        fprintf(stderr,
 
896
                                                "InnoDB: Error: auto-extending"
 
897
                                                " data file %s is"
 
898
                                                " of a different size\n"
 
899
                                                "InnoDB: %lu pages (rounded"
 
900
                                                " down to MB) than specified"
 
901
                                                " in the .cnf file:\n"
 
902
                                                "InnoDB: initial %lu pages,"
 
903
                                                " max %lu (relevant if"
 
904
                                                " non-zero) pages!\n",
 
905
                                                name,
 
906
                                                (ulong) rounded_size_pages,
 
907
                                                (ulong) srv_data_file_sizes[i],
 
908
                                                (ulong)
 
909
                                                srv_last_file_size_max);
884
910
 
885
911
                                        return(DB_ERROR);
886
912
                                }
890
916
 
891
917
                        if (rounded_size_pages != srv_data_file_sizes[i]) {
892
918
 
893
 
                          drizzled::errmsg_printf(drizzled::error::ERROR,
894
 
                                        "InnoDB: Error: data file %s is of a different size. "
895
 
                                        "%lu pages (rounded down to MB). "
896
 
                                        "Than specified in the .cnf file %lu pages!",
 
919
                                fprintf(stderr,
 
920
                                        "InnoDB: Error: data file %s"
 
921
                                        " is of a different size\n"
 
922
                                        "InnoDB: %lu pages"
 
923
                                        " (rounded down to MB)\n"
 
924
                                        "InnoDB: than specified"
 
925
                                        " in the .cnf file %lu pages!\n",
897
926
                                        name,
898
927
                                        (ulong) rounded_size_pages,
899
928
                                        (ulong) srv_data_file_sizes[i]);
915
944
                        one_created = TRUE;
916
945
 
917
946
                        if (i > 0) {
918
 
                                drizzled::errmsg_printf(drizzled::error::INFO,
919
 
                                        "  InnoDB: Data file %s did not exist: new to be created",
 
947
                                ut_print_timestamp(stderr);
 
948
                                fprintf(stderr,
 
949
                                        "  InnoDB: Data file %s did not"
 
950
                                        " exist: new to be created\n",
920
951
                                        name);
921
952
                        } else {
922
 
                          drizzled::errmsg_printf(drizzled::error::INFO,
923
 
                                        "InnoDB: The first specified data file %s did not exist. A new database to be created!", name);
 
953
                                fprintf(stderr,
 
954
                                        "InnoDB: The first specified"
 
955
                                        " data file %s did not exist:\n"
 
956
                                        "InnoDB: a new database"
 
957
                                        " to be created!\n", name);
924
958
                                *create_new_db = TRUE;
925
959
                        }
926
960
 
927
 
                        drizzled::errmsg_printf(drizzled::error::INFO,
928
 
                                                "  InnoDB: Setting file %s size to %lu MB",
929
 
                                                name, (ulong) (srv_data_file_sizes[i]
930
 
                                                         >> (20 - UNIV_PAGE_SIZE_SHIFT)));
 
961
                        ut_print_timestamp(stderr);
 
962
                        fprintf(stderr,
 
963
                                "  InnoDB: Setting file %s size to %lu MB\n",
 
964
                                name,
 
965
                                (ulong) (srv_data_file_sizes[i]
 
966
                                         >> (20 - UNIV_PAGE_SIZE_SHIFT)));
931
967
 
932
 
                        drizzled::errmsg_printf(drizzled::error::INFO,
933
 
                                "InnoDB: Database physically writes the file full: wait...");
 
968
                        fprintf(stderr,
 
969
                                "InnoDB: Database physically writes the"
 
970
                                " file full: wait...\n");
934
971
 
935
972
                        ret = os_file_set_size(
936
973
                                name, files[i],
938
975
                                srv_calc_high32(srv_data_file_sizes[i]));
939
976
 
940
977
                        if (!ret) {
941
 
                          drizzled::errmsg_printf(drizzled::error::ERROR,
942
 
                                                  "InnoDB: Error in creating %s: probably out of disk space", name);
 
978
                                fprintf(stderr,
 
979
                                        "InnoDB: Error in creating %s:"
 
980
                                        " probably out of disk space\n", name);
943
981
 
944
982
                                return(DB_ERROR);
945
983
                        }
961
999
                                srv_data_file_is_raw_partition[i] != 0);
962
1000
        }
963
1001
 
 
1002
        ios = 0;
 
1003
 
 
1004
        mutex_create(ios_mutex_key, &ios_mutex, SYNC_NO_ORDER_CHECK);
 
1005
 
964
1006
        return(DB_SUCCESS);
965
1007
}
966
1008
 
1003
1045
        on Mac OS X 10.3 or later. */
1004
1046
        struct utsname utsname;
1005
1047
        if (uname(&utsname)) {
1006
 
                fputs(_("InnoDB: cannot determine Mac OS X version!\n"), stderr);
 
1048
                fputs("InnoDB: cannot determine Mac OS X version!\n", stderr);
1007
1049
        } else {
1008
1050
                srv_have_fullfsync = strcmp(utsname.release, "7.") >= 0;
1009
1051
        }
1010
1052
        if (!srv_have_fullfsync) {
1011
 
                fputs(_("InnoDB: On Mac OS X, fsync() may be"
1012
 
                        " broken on internal drives,\n"
1013
 
                        "InnoDB: making transactions unsafe!\n"), stderr);
 
1053
                fputs("InnoDB: On Mac OS X, fsync() may be"
 
1054
                      " broken on internal drives,\n"
 
1055
                      "InnoDB: making transactions unsafe!\n", stderr);
1014
1056
        }
1015
1057
# endif /* F_FULLFSYNC */
1016
1058
#endif /* HAVE_DARWIN_THREADS */
1017
1059
 
1018
1060
        if (sizeof(ulint) != sizeof(void*)) {
1019
 
          drizzled::errmsg_printf(drizzled::error::WARN,
1020
 
                        _("InnoDB: Error: size of InnoDB's ulint is %lu, but size of void* is %lu. "
1021
 
                          "The sizes should be the same so that on a 64-bit platform you can. Allocate more than 4 GB of memory."),
 
1061
                fprintf(stderr,
 
1062
                        "InnoDB: Error: size of InnoDB's ulint is %lu,"
 
1063
                        " but size of void* is %lu.\n"
 
1064
                        "InnoDB: The sizes should be the same"
 
1065
                        " so that on a 64-bit platform you can\n"
 
1066
                        "InnoDB: allocate more than 4 GB of memory.",
1022
1067
                        (ulong)sizeof(ulint), (ulong)sizeof(void*));
1023
1068
        }
1024
1069
 
1028
1073
        innodb_file_per_table) until this function has returned. */
1029
1074
        srv_file_per_table = FALSE;
1030
1075
#ifdef UNIV_DEBUG
1031
 
        drizzled::errmsg_printf(drizzled::error::INFO,
1032
 
                                _("InnoDB: !!!!!!!! UNIV_DEBUG switched on !!!!!!!!!\n"));
 
1076
        fprintf(stderr,
 
1077
                "InnoDB: !!!!!!!! UNIV_DEBUG switched on !!!!!!!!!\n");
1033
1078
#endif
1034
1079
 
1035
1080
#ifdef UNIV_IBUF_DEBUG
1036
 
        drizzled::errmsg_printf(drizzled::error::INFO,
1037
 
                _("InnoDB: !!!!!!!! UNIV_IBUF_DEBUG switched on !!!!!!!!!\n"
 
1081
        fprintf(stderr,
 
1082
                "InnoDB: !!!!!!!! UNIV_IBUF_DEBUG switched on !!!!!!!!!\n"
1038
1083
# ifdef UNIV_IBUF_COUNT_DEBUG
1039
 
                  "InnoDB: !!!!!!!! UNIV_IBUF_COUNT_DEBUG switched on !!!!!!!!!\n"
1040
 
                  "InnoDB: Crash recovery will fail with UNIV_IBUF_COUNT_DEBUG\n"
 
1084
                "InnoDB: !!!!!!!! UNIV_IBUF_COUNT_DEBUG switched on !!!!!!!!!\n"
 
1085
                "InnoDB: Crash recovery will fail with UNIV_IBUF_COUNT_DEBUG\n"
1041
1086
# endif
1042
 
                ));
 
1087
                );
1043
1088
#endif
1044
1089
 
1045
1090
#ifdef UNIV_SYNC_DEBUG
1046
 
        drizzled::errmsg_printf(drizzled::error::INFO,
1047
 
                                _("InnoDB: !!!!!!!! UNIV_SYNC_DEBUG switched on !!!!!!!!!\n"));
 
1091
        fprintf(stderr,
 
1092
                "InnoDB: !!!!!!!! UNIV_SYNC_DEBUG switched on !!!!!!!!!\n");
1048
1093
#endif
1049
1094
 
1050
1095
#ifdef UNIV_SEARCH_DEBUG
1051
 
        drizzled::errmsg_printf(drizzled::error::INFO,
1052
 
                                _("InnoDB: !!!!!!!! UNIV_SEARCH_DEBUG switched on !!!!!!!!!\n"));
 
1096
        fprintf(stderr,
 
1097
                "InnoDB: !!!!!!!! UNIV_SEARCH_DEBUG switched on !!!!!!!!!\n");
1053
1098
#endif
1054
1099
 
1055
1100
#ifdef UNIV_LOG_LSN_DEBUG
1056
 
        drizzled::errmsg_printf(drizzled::error::INFO,
1057
 
                                _("InnoDB: !!!!!!!! UNIV_LOG_LSN_DEBUG switched on !!!!!!!!!\n"));
 
1101
        fprintf(stderr,
 
1102
                "InnoDB: !!!!!!!! UNIV_LOG_LSN_DEBUG switched on !!!!!!!!!\n");
1058
1103
#endif /* UNIV_LOG_LSN_DEBUG */
1059
1104
#ifdef UNIV_MEM_DEBUG
1060
 
        drizzled::errmsg_printf(drizzled::error::INFO,
1061
 
                                _("InnoDB: !!!!!!!! UNIV_MEM_DEBUG switched on !!!!!!!!!\n"));
 
1105
        fprintf(stderr,
 
1106
                "InnoDB: !!!!!!!! UNIV_MEM_DEBUG switched on !!!!!!!!!\n");
1062
1107
#endif
1063
1108
 
1064
 
        if (UNIV_LIKELY(srv_use_sys_malloc))
1065
 
        {
1066
 
          drizzled::errmsg_printf(drizzled::error::ERROR, _("InnoDB: The InnoDB memory heap is disabled\n"));
 
1109
        if (UNIV_LIKELY(srv_use_sys_malloc)) {
 
1110
                fprintf(stderr,
 
1111
                        "InnoDB: The InnoDB memory heap is disabled\n");
1067
1112
        }
1068
1113
 
1069
1114
        fputs("InnoDB: " IB_ATOMICS_STARTUP_MSG
1070
 
                "\nInnoDB: Compressed tables use zlib " ZLIB_VERSION
 
1115
              "\nInnoDB: Compressed tables use zlib " ZLIB_VERSION
1071
1116
#ifdef UNIV_ZIP_DEBUG
1072
1117
              " with validation"
1073
1118
#endif /* UNIV_ZIP_DEBUG */
1083
1128
        second time during the process lifetime. */
1084
1129
 
1085
1130
        if (srv_start_has_been_called) {
1086
 
          drizzled::errmsg_printf(drizzled::error::ERROR,
1087
 
                        "InnoDB: Error: startup called second time during the process lifetime.\n");
 
1131
                fprintf(stderr,
 
1132
                        "InnoDB: Error: startup called second time"
 
1133
                        " during the process lifetime.\n"
 
1134
                        "InnoDB: In the MySQL Embedded Server Library"
 
1135
                        " you cannot call server_init()\n"
 
1136
                        "InnoDB: more than once during"
 
1137
                        " the process lifetime.\n");
1088
1138
        }
1089
1139
 
1090
1140
        srv_start_has_been_called = TRUE;
1126
1176
#elif defined(LINUX_NATIVE_AIO)
1127
1177
 
1128
1178
        if (srv_use_native_aio) {
1129
 
                drizzled::errmsg_printf(drizzled::error::INFO,
1130
 
                                        _("InnoDB: Using Linux native AIO"));
 
1179
                ut_print_timestamp(stderr);
 
1180
                fprintf(stderr,
 
1181
                        "  InnoDB: Using Linux native AIO\n");
1131
1182
        }
1132
1183
#else
1133
1184
        /* Currently native AIO is supported only on windows and linux
1172
1223
                srv_win_file_flush_method = SRV_WIN_IO_UNBUFFERED;
1173
1224
#endif
1174
1225
        } else {
1175
 
          drizzled::errmsg_printf(drizzled::error::ERROR,
1176
 
                                  "InnoDB: Unrecognized value %s for innodb_flush_method",
1177
 
                                  srv_file_flush_method_str);
 
1226
                fprintf(stderr,
 
1227
                        "InnoDB: Unrecognized value %s for"
 
1228
                        " innodb_flush_method\n",
 
1229
                        srv_file_flush_method_str);
1178
1230
                return(DB_ERROR);
1179
1231
        }
1180
1232
 
1214
1266
                     &srv_monitor_file_mutex, SYNC_NO_ORDER_CHECK);
1215
1267
 
1216
1268
        if (srv_innodb_status) {
1217
 
          srv_monitor_file_name = static_cast<char *>(mem_alloc(
 
1269
                srv_monitor_file_name = mem_alloc(
1218
1270
                        strlen(fil_path_to_mysql_datadir)
1219
 
                        + 20 + sizeof "/innodb_status."));
 
1271
                        + 20 + sizeof "/innodb_status.");
1220
1272
                sprintf(srv_monitor_file_name, "%s/innodb_status.%lu",
1221
1273
                        fil_path_to_mysql_datadir, os_proc_get_number());
1222
1274
                srv_monitor_file = fopen(srv_monitor_file_name, "w+");
1223
1275
                if (!srv_monitor_file) {
1224
 
                  drizzled::errmsg_printf(drizzled::error::ERROR,
1225
 
                                          "InnoDB: unable to create %s: %s\n", srv_monitor_file_name, strerror(errno));
 
1276
                        fprintf(stderr, "InnoDB: unable to create %s: %s\n",
 
1277
                                srv_monitor_file_name, strerror(errno));
1226
1278
                        return(DB_ERROR);
1227
1279
                }
1228
1280
        } else {
1276
1328
                 srv_max_n_open_files);
1277
1329
 
1278
1330
        /* Print time to initialize the buffer pool */
 
1331
        ut_print_timestamp(stderr);
 
1332
        fprintf(stderr,
 
1333
                "  InnoDB: Initializing buffer pool, size =");
1279
1334
 
1280
1335
        if (srv_buf_pool_size >= 1024 * 1024 * 1024) {
1281
 
          drizzled::errmsg_printf(drizzled::error::INFO, "InnoDB: Initializing buffer pool, size = %.1fG",
1282
 
                                  ((double) srv_buf_pool_size) / (1024 * 1024 * 1024));
 
1336
                fprintf(stderr,
 
1337
                        " %.1fG\n",
 
1338
                        ((double) srv_buf_pool_size) / (1024 * 1024 * 1024));
1283
1339
        } else {
1284
 
          drizzled::errmsg_printf(drizzled::error::INFO, "InnoDB: Initializing buffer pool, size = %.1fM",
1285
 
                                  ((double) srv_buf_pool_size) / (1024 * 1024));
 
1340
                fprintf(stderr,
 
1341
                        " %.1fM\n",
 
1342
                        ((double) srv_buf_pool_size) / (1024 * 1024));
1286
1343
        }
1287
1344
 
1288
1345
        err = buf_pool_init(srv_buf_pool_size, srv_buf_pool_instances);
1289
1346
 
1290
 
        drizzled::errmsg_printf(drizzled::error::INFO, "InnoDB: Completed initialization of buffer pool");
 
1347
        ut_print_timestamp(stderr);
 
1348
        fprintf(stderr,
 
1349
                "  InnoDB: Completed initialization of buffer pool\n");
1291
1350
 
1292
1351
        if (err != DB_SUCCESS) {
1293
 
          drizzled::errmsg_printf(drizzled::error::ERROR, "InnoDB: Fatal error: cannot allocate the memory for the buffer pool");
 
1352
                fprintf(stderr,
 
1353
                        "InnoDB: Fatal error: cannot allocate the memory"
 
1354
                        " for the buffer pool\n");
1294
1355
 
1295
 
          return(DB_ERROR);
 
1356
                return(DB_ERROR);
1296
1357
        }
1297
1358
 
1298
1359
#ifdef UNIV_DEBUG
1301
1362
 
1302
1363
        if (srv_buf_pool_size <= 5 * 1024 * 1024) {
1303
1364
 
1304
 
          drizzled::errmsg_printf(drizzled::error::WARN, "InnoDB: Warning: Small buffer pool size "
1305
 
                                  "(%luM), the flst_validate() debug function "
1306
 
                                  "can cause a deadlock if the buffer pool fills up.\n",
1307
 
                                  srv_buf_pool_size / 1024 / 1024);
 
1365
                fprintf(stderr, "InnoDB: Warning: Small buffer pool size "
 
1366
                        "(%luM), the flst_validate() debug function "
 
1367
                        "can cause a deadlock if the buffer pool fills up.\n",
 
1368
                        srv_buf_pool_size / 1024 / 1024);
1308
1369
        }
1309
1370
#endif
1310
1371
 
1323
1384
 
1324
1385
#ifdef UNIV_LOG_ARCHIVE
1325
1386
        if (0 != ut_strcmp(srv_log_group_home_dirs[0], srv_arch_dir)) {
1326
 
          drizzled::errmsg_printf(drizzled::error::ERROR,
1327
 
                                  "InnoDB: Error: you must set the log group home dir in my.cnf the same as log arch dir.");
 
1387
                fprintf(stderr,
 
1388
                        "InnoDB: Error: you must set the log group"
 
1389
                        " home dir in my.cnf the\n"
 
1390
                        "InnoDB: same as log arch dir.\n");
1328
1391
 
1329
1392
                return(DB_ERROR);
1330
1393
        }
1331
1394
#endif /* UNIV_LOG_ARCHIVE */
1332
1395
 
1333
1396
        if (srv_n_log_files * srv_log_file_size >= 262144) {
1334
 
          drizzled::errmsg_printf(drizzled::error::ERROR,
1335
 
                                  "InnoDB: Error: combined size of log files must be < 4 GB");
 
1397
                fprintf(stderr,
 
1398
                        "InnoDB: Error: combined size of log files"
 
1399
                        " must be < 4 GB\n");
1336
1400
 
1337
1401
                return(DB_ERROR);
1338
1402
        }
1342
1406
        for (i = 0; i < srv_n_data_files; i++) {
1343
1407
#ifndef __WIN__
1344
1408
                if (sizeof(off_t) < 5 && srv_data_file_sizes[i] >= 262144) {
1345
 
                  drizzled::errmsg_printf(drizzled::error::ERROR,
1346
 
                                          "InnoDB: Error: file size must be < 4 GB with this MySQL binary and operating system combination,"
1347
 
                                          " in some OS's < 2 GB\n");
 
1409
                        fprintf(stderr,
 
1410
                                "InnoDB: Error: file size must be < 4 GB"
 
1411
                                " with this MySQL binary\n"
 
1412
                                "InnoDB: and operating system combination,"
 
1413
                                " in some OS's < 2 GB\n");
1348
1414
 
1349
1415
                        return(DB_ERROR);
1350
1416
                }
1353
1419
        }
1354
1420
 
1355
1421
        if (sum_of_new_sizes < 10485760 / UNIV_PAGE_SIZE) {
1356
 
          drizzled::errmsg_printf(drizzled::error::ERROR, "InnoDB: Error: tablespace size must be at least 10 MB");
 
1422
                fprintf(stderr,
 
1423
                        "InnoDB: Error: tablespace size must be"
 
1424
                        " at least 10 MB\n");
1357
1425
 
1358
1426
                return(DB_ERROR);
1359
1427
        }
1365
1433
                                        &min_flushed_lsn, &max_flushed_lsn,
1366
1434
                                        &sum_of_new_sizes);
1367
1435
        if (err != DB_SUCCESS) {
1368
 
          drizzled::errmsg_printf(drizzled::error::ERROR,
1369
 
                                  "InnoDB: Could not open or create data files.\n"
1370
 
                                  "InnoDB: If you tried to add new data files, and it failed here,\n"
1371
 
                                  "InnoDB: you should now edit innodb_data_file_path in my.cnf back\n"
1372
 
                                  "InnoDB: to what it was, and remove the new ibdata files InnoDB created\n"
1373
 
                                  "InnoDB: in this failed attempt. InnoDB only wrote those files full of\n"
1374
 
                                  "InnoDB: zeros, but did not yet use them in any way. But be careful: do not\n"
1375
 
                                  "InnoDB: remove old data files which contain your precious data!\n");
 
1436
                fprintf(stderr,
 
1437
                        "InnoDB: Could not open or create data files.\n"
 
1438
                        "InnoDB: If you tried to add new data files,"
 
1439
                        " and it failed here,\n"
 
1440
                        "InnoDB: you should now edit innodb_data_file_path"
 
1441
                        " in my.cnf back\n"
 
1442
                        "InnoDB: to what it was, and remove the"
 
1443
                        " new ibdata files InnoDB created\n"
 
1444
                        "InnoDB: in this failed attempt. InnoDB only wrote"
 
1445
                        " those files full of\n"
 
1446
                        "InnoDB: zeros, but did not yet use them in any way."
 
1447
                        " But be careful: do not\n"
 
1448
                        "InnoDB: remove old data files"
 
1449
                        " which contain your precious data!\n");
1376
1450
 
1377
1451
                return((int) err);
1378
1452
        }
1397
1471
                }
1398
1472
                if ((log_opened && create_new_db)
1399
1473
                    || (log_opened && log_created)) {
1400
 
                  drizzled::errmsg_printf(drizzled::error::ERROR,
1401
 
                                "InnoDB: Error: all log files must be created at the same time.\n"
1402
 
                                "InnoDB: All log files must be created also in database creation.\n"
1403
 
                                "InnoDB: If you want bigger or smaller log files, shut down the\n"
1404
 
                                "InnoDB: database and make sure there were no errors in shutdown.\n"
1405
 
                                "InnoDB: Then delete the existing log files. Edit the .cnf file\n"
 
1474
                        fprintf(stderr,
 
1475
                                "InnoDB: Error: all log files must be"
 
1476
                                " created at the same time.\n"
 
1477
                                "InnoDB: All log files must be"
 
1478
                                " created also in database creation.\n"
 
1479
                                "InnoDB: If you want bigger or smaller"
 
1480
                                " log files, shut down the\n"
 
1481
                                "InnoDB: database and make sure there"
 
1482
                                " were no errors in shutdown.\n"
 
1483
                                "InnoDB: Then delete the existing log files."
 
1484
                                " Edit the .cnf file\n"
1406
1485
                                "InnoDB: and start the database again.\n");
1407
1486
 
1408
1487
                        return(DB_ERROR);
1424
1503
                    || max_arch_log_no != min_arch_log_no
1425
1504
#endif /* UNIV_LOG_ARCHIVE */
1426
1505
                    ) {
1427
 
                  drizzled::errmsg_printf(drizzled::error::ERROR,
1428
 
                                "InnoDB: Cannot initialize created log files because\n"
1429
 
                                "InnoDB: data files were not in sync with each other\n"
 
1506
                        fprintf(stderr,
 
1507
                                "InnoDB: Cannot initialize created"
 
1508
                                " log files because\n"
 
1509
                                "InnoDB: data files were not in sync"
 
1510
                                " with each other\n"
1430
1511
                                "InnoDB: or the data files are corrupt.\n");
1431
1512
 
1432
1513
                        return(DB_ERROR);
1433
1514
                }
1434
1515
 
1435
1516
                if (max_flushed_lsn < (ib_uint64_t) 1000) {
1436
 
                  drizzled::errmsg_printf(drizzled::error::ERROR,
1437
 
                                "InnoDB: Cannot initialize created log files because\n"
1438
 
                                "InnoDB: data files are corrupt, or new data files were\n"
1439
 
                                "InnoDB: created when the database was started previous\n"
1440
 
                                "InnoDB: time but the database was not shut down\n"
1441
 
                                "InnoDB: normally after that.\n");
 
1517
                        fprintf(stderr,
 
1518
                                "InnoDB: Cannot initialize created"
 
1519
                                " log files because\n"
 
1520
                                "InnoDB: data files are corrupt,"
 
1521
                                " or new data files were\n"
 
1522
                                "InnoDB: created when the database"
 
1523
                                " was started previous\n"
 
1524
                                "InnoDB: time but the database"
 
1525
                                " was not shut down\n"
 
1526
                                "InnoDB: normally after that.\n");
1442
1527
 
1443
1528
                        return(DB_ERROR);
1444
1529
                }
1477
1562
 
1478
1563
#ifdef UNIV_LOG_ARCHIVE
1479
1564
        } else if (srv_archive_recovery) {
1480
 
          drizzled::errmsg_printf(drizzled::error::INFO,
1481
 
                                  "InnoDB: Starting archive recovery from a backup...");
 
1565
                fprintf(stderr,
 
1566
                        "InnoDB: Starting archive"
 
1567
                        " recovery from a backup...\n");
1482
1568
                err = recv_recovery_from_archive_start(
1483
1569
                        min_flushed_lsn, srv_archive_recovery_limit_lsn,
1484
1570
                        min_arch_log_no);
1699
1785
        if (!srv_auto_extend_last_data_file
1700
1786
            && sum_of_data_file_sizes != tablespace_size_in_header) {
1701
1787
 
1702
 
          drizzled::errmsg_printf(drizzled::error::ERROR,
1703
 
                                  "InnoDB: Error: tablespace size stored in header is %lu pages, but the sum of data file sizes is %lu pages.",
1704
 
                                  (ulong) tablespace_size_in_header,
1705
 
                                  (ulong) sum_of_data_file_sizes);
 
1788
                fprintf(stderr,
 
1789
                        "InnoDB: Error: tablespace size"
 
1790
                        " stored in header is %lu pages, but\n"
 
1791
                        "InnoDB: the sum of data file sizes is %lu pages\n",
 
1792
                        (ulong) tablespace_size_in_header,
 
1793
                        (ulong) sum_of_data_file_sizes);
1706
1794
 
1707
1795
                if (srv_force_recovery == 0
1708
1796
                    && sum_of_data_file_sizes < tablespace_size_in_header) {
1709
1797
                        /* This is a fatal error, the tail of a tablespace is
1710
1798
                        missing */
1711
1799
 
1712
 
                  drizzled::errmsg_printf(drizzled::error::ERROR,
1713
 
                                          "InnoDB: Cannot start InnoDB. The tail of the system tablespace is "
1714
 
                                          "missing. Have you edited innodb_data_file_path in my.cnf in an "
1715
 
                                          "inappropriate way, removing ibdata files from there? "
1716
 
                                          "You can set innodb_force_recovery=1 in my.cnf to force "
1717
 
                                          "a startup if you are trying to recover a badly corrupt database.");
 
1800
                        fprintf(stderr,
 
1801
                                "InnoDB: Cannot start InnoDB."
 
1802
                                " The tail of the system tablespace is\n"
 
1803
                                "InnoDB: missing. Have you edited"
 
1804
                                " innodb_data_file_path in my.cnf in an\n"
 
1805
                                "InnoDB: inappropriate way, removing"
 
1806
                                " ibdata files from there?\n"
 
1807
                                "InnoDB: You can set innodb_force_recovery=1"
 
1808
                                " in my.cnf to force\n"
 
1809
                                "InnoDB: a startup if you are trying"
 
1810
                                " to recover a badly corrupt database.\n");
1718
1811
 
1719
1812
                        return(DB_ERROR);
1720
1813
                }
1723
1816
        if (srv_auto_extend_last_data_file
1724
1817
            && sum_of_data_file_sizes < tablespace_size_in_header) {
1725
1818
 
1726
 
          drizzled::errmsg_printf(drizzled::error::ERROR,
1727
 
                                  "InnoDB: Error: tablespace size stored in header is %lu pages, but the sum of data file sizes"
1728
 
                                  " is only %lu pages\n",
1729
 
                                  (ulong) tablespace_size_in_header,
1730
 
                                  (ulong) sum_of_data_file_sizes);
 
1819
                fprintf(stderr,
 
1820
                        "InnoDB: Error: tablespace size stored in header"
 
1821
                        " is %lu pages, but\n"
 
1822
                        "InnoDB: the sum of data file sizes"
 
1823
                        " is only %lu pages\n",
 
1824
                        (ulong) tablespace_size_in_header,
 
1825
                        (ulong) sum_of_data_file_sizes);
1731
1826
 
1732
1827
                if (srv_force_recovery == 0) {
1733
1828
 
1734
 
                  drizzled::errmsg_printf(drizzled::error::ERROR,
1735
 
                                "InnoDB: Cannot start InnoDB. The tail of the system tablespace is "
1736
 
                                "missing. Have you edited innodb_data_file_path in my.cnf in an "
1737
 
                                "inappropriate way, removing ibdata files from there? "
1738
 
                                "You can set innodb_force_recovery=1 in my.cnf to force "
1739
 
                                "a startup if you are trying to recover a badly corrupt database.\n");
 
1829
                        fprintf(stderr,
 
1830
                                "InnoDB: Cannot start InnoDB. The tail of"
 
1831
                                " the system tablespace is\n"
 
1832
                                "InnoDB: missing. Have you edited"
 
1833
                                " innodb_data_file_path in my.cnf in an\n"
 
1834
                                "InnoDB: inappropriate way, removing"
 
1835
                                " ibdata files from there?\n"
 
1836
                                "InnoDB: You can set innodb_force_recovery=1"
 
1837
                                " in my.cnf to force\n"
 
1838
                                "InnoDB: a startup if you are trying to"
 
1839
                                " recover a badly corrupt database.\n");
1740
1840
 
1741
1841
                        return(DB_ERROR);
1742
1842
                }
1746
1846
        os_fast_mutex_init(&srv_os_test_mutex);
1747
1847
 
1748
1848
        if (0 != os_fast_mutex_trylock(&srv_os_test_mutex)) {
1749
 
          drizzled::errmsg_printf(drizzled::error::ERROR,
1750
 
                        "InnoDB: Error: pthread_mutex_trylock returns an unexpected value on success! Cannot continue.\n");
 
1849
                fprintf(stderr,
 
1850
                        "InnoDB: Error: pthread_mutex_trylock returns"
 
1851
                        " an unexpected value on\n"
 
1852
                        "InnoDB: success! Cannot continue.\n");
1751
1853
                exit(1);
1752
1854
        }
1753
1855
 
1760
1862
        os_fast_mutex_free(&srv_os_test_mutex);
1761
1863
 
1762
1864
        if (srv_print_verbose_log) {
1763
 
                drizzled::errmsg_printf(drizzled::error::ERROR,
1764
 
                                        "InnoDB %s started; log sequence number %"PRIu64"\n",
1765
 
                                        INNODB_VERSION_STR, srv_start_lsn);
 
1865
                ut_print_timestamp(stderr);
 
1866
                fprintf(stderr,
 
1867
                        "  InnoDB %s started; "
 
1868
                        "log sequence number %"PRIu64"\n",
 
1869
                        INNODB_VERSION_STR, srv_start_lsn);
1766
1870
        }
1767
1871
 
1768
1872
        if (srv_force_recovery > 0) {
1769
 
          drizzled::errmsg_printf(drizzled::error::ERROR,
1770
 
                                  "InnoDB: !!! innodb_force_recovery is set to %lu !!!\n",
1771
 
                                  (ulong) srv_force_recovery);
 
1873
                fprintf(stderr,
 
1874
                        "InnoDB: !!! innodb_force_recovery"
 
1875
                        " is set to %lu !!!\n",
 
1876
                        (ulong) srv_force_recovery);
1772
1877
        }
1773
1878
 
 
1879
        fflush(stderr);
 
1880
 
1774
1881
        if (trx_doublewrite_must_reset_space_ids) {
1775
1882
                /* Actually, we did not change the undo log format between
1776
1883
                4.0 and 4.1.1, and we would not need to run purge to
1785
1892
                4.1.1. It is essential that the insert buffer is emptied
1786
1893
                here! */
1787
1894
 
1788
 
          drizzled::errmsg_printf(drizzled::error::INFO,
1789
 
                                  "InnoDB: You are upgrading to an InnoDB version which allows multiple. "
1790
 
                                  "tablespaces. Wait that purge and insert buffer merge run to completion...");
 
1895
                fprintf(stderr,
 
1896
                        "InnoDB: You are upgrading to an"
 
1897
                        " InnoDB version which allows multiple\n"
 
1898
                        "InnoDB: tablespaces. Wait that purge"
 
1899
                        " and insert buffer merge run to\n"
 
1900
                        "InnoDB: completion...\n");
1791
1901
                for (;;) {
1792
1902
                        os_thread_sleep(1000000);
1793
1903
 
1799
1909
                                break;
1800
1910
                        }
1801
1911
                }
1802
 
                drizzled::errmsg_printf(drizzled::error::INFO,
1803
 
                                        "InnoDB: Full purge and insert buffer merge completed.");
 
1912
                fprintf(stderr,
 
1913
                        "InnoDB: Full purge and insert buffer merge"
 
1914
                        " completed.\n");
1804
1915
 
1805
1916
                trx_sys_mark_upgraded_to_multiple_tablespaces();
1806
1917
 
1807
 
                drizzled::errmsg_printf(drizzled::error::INFO,
1808
 
                                        "InnoDB: You have now successfully upgraded"
1809
 
                                        " to the multiple tablespaces\n"
1810
 
                                        "InnoDB: format. You should NOT DOWNGRADE"
1811
 
                                        " to an earlier version of\n"
1812
 
                                        "InnoDB: InnoDB! But if you absolutely need to"
1813
 
                                        " downgrade, see\n"
1814
 
                                        "InnoDB: " REFMAN "multiple-tablespaces.html\n"
1815
 
                                        "InnoDB: for instructions.\n");
 
1918
                fprintf(stderr,
 
1919
                        "InnoDB: You have now successfully upgraded"
 
1920
                        " to the multiple tablespaces\n"
 
1921
                        "InnoDB: format. You should NOT DOWNGRADE"
 
1922
                        " to an earlier version of\n"
 
1923
                        "InnoDB: InnoDB! But if you absolutely need to"
 
1924
                        " downgrade, see\n"
 
1925
                        "InnoDB: " REFMAN "multiple-tablespaces.html\n"
 
1926
                        "InnoDB: for instructions.\n");
1816
1927
        }
1817
1928
 
1818
1929
        if (srv_force_recovery == 0) {
1842
1953
        ulint   i;
1843
1954
        if (!srv_was_started) {
1844
1955
                if (srv_is_being_started) {
1845
 
                  drizzled::errmsg_printf(drizzled::error::ERROR,
1846
 
                                "InnoDB: Warning: shutting down a not properly started or created database!");
 
1956
                        ut_print_timestamp(stderr);
 
1957
                        fprintf(stderr,
 
1958
                                "  InnoDB: Warning: shutting down"
 
1959
                                " a not properly started\n"
 
1960
                                "InnoDB: or created database!\n");
1847
1961
                }
1848
1962
 
1849
1963
                return(DB_SUCCESS);
1856
1970
 
1857
1971
 
1858
1972
        if (srv_fast_shutdown == 2) {
1859
 
                drizzled::errmsg_printf(drizzled::error::INFO,
1860
 
                                        "InnoDB: MySQL has requested a very fast shutdown without flushing "
1861
 
                                        "the InnoDB buffer pool to data files. At the next mysqld startup "
1862
 
                                        "InnoDB will do a crash recovery!");
 
1973
                ut_print_timestamp(stderr);
 
1974
                fprintf(stderr,
 
1975
                        "  InnoDB: MySQL has requested a very fast shutdown"
 
1976
                        " without flushing "
 
1977
                        "the InnoDB buffer pool to data files."
 
1978
                        " At the next mysqld startup "
 
1979
                        "InnoDB will do a crash recovery!\n");
1863
1980
        }
1864
1981
 
1865
1982
        logs_empty_and_mark_files_at_shutdown();
1866
1983
 
1867
1984
        if (srv_conc_n_threads != 0) {
1868
 
          drizzled::errmsg_printf(drizzled::error::WARN,
1869
 
                                  "InnoDB: Warning: query counter shows %ld queries still InnoDB: inside InnoDB at shutdown.",
1870
 
                                  srv_conc_n_threads);
 
1985
                fprintf(stderr,
 
1986
                        "InnoDB: Warning: query counter shows %ld queries"
 
1987
                        " still\n"
 
1988
                        "InnoDB: inside InnoDB at shutdown\n",
 
1989
                        srv_conc_n_threads);
1871
1990
        }
1872
1991
 
1873
1992
        /* 2. Make all threads created by InnoDB to exit */
1930
2049
        }
1931
2050
 
1932
2051
        if (i == 1000) {
1933
 
          drizzled::errmsg_printf(drizzled::error::WARN,
1934
 
                        "InnoDB: Warning: %lu threads created by InnoDB had not exited at shutdown!",
 
2052
                fprintf(stderr,
 
2053
                        "InnoDB: Warning: %lu threads created by InnoDB"
 
2054
                        " had not exited at shutdown!\n",
1935
2055
                        (ulong) os_thread_count);
1936
2056
        }
1937
2057
 
1997
2117
            || os_event_count != 0
1998
2118
            || os_mutex_count != 0
1999
2119
            || os_fast_mutex_count != 0) {
2000
 
          drizzled::errmsg_printf(drizzled::error::WARN,
2001
 
                                  "InnoDB: Warning: some resources were not cleaned up in shutdown:\n"
2002
 
                                  "InnoDB: threads %lu, events %lu, os_mutexes %lu, os_fast_mutexes %lu\n",
2003
 
                                  (ulong) os_thread_count, (ulong) os_event_count,
2004
 
                                  (ulong) os_mutex_count, (ulong) os_fast_mutex_count);
 
2120
                fprintf(stderr,
 
2121
                        "InnoDB: Warning: some resources were not"
 
2122
                        " cleaned up in shutdown:\n"
 
2123
                        "InnoDB: threads %lu, events %lu,"
 
2124
                        " os_mutexes %lu, os_fast_mutexes %lu\n",
 
2125
                        (ulong) os_thread_count, (ulong) os_event_count,
 
2126
                        (ulong) os_mutex_count, (ulong) os_fast_mutex_count);
2005
2127
        }
2006
2128
 
2007
2129
        if (dict_foreign_err_file) {
2012
2134
        }
2013
2135
 
2014
2136
        if (srv_print_verbose_log) {
2015
 
                drizzled::errmsg_printf(drizzled::error::INFO,
2016
 
                                        "InnoDB: Shutdown completed log sequence number %"PRIu64,
2017
 
                                        srv_shutdown_lsn);
 
2137
                ut_print_timestamp(stderr);
 
2138
                fprintf(stderr,
 
2139
                        "  InnoDB: Shutdown completed;"
 
2140
                        " log sequence number %"PRIu64"\n",
 
2141
                        srv_shutdown_lsn);
2018
2142
        }
2019
2143
 
2020
2144
        srv_was_started = FALSE;