← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

  • Committer: Brian Aker
  • Date: 2010-12-27 20:04:50 UTC
  • mto: (2060.2.1 clean)
  • mto: This revision was merged to the branch mainline in revision 2063.
  • Revision ID: brian@tangent.org-20101227200450-dmxpemwyfmlinlnm
Merge in first pass.

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 */
282
279
                return(FALSE);
283
280
        }
284
281
 
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));
 
282
        srv_data_file_names = malloc(i * sizeof *srv_data_file_names);
 
283
        srv_data_file_sizes = malloc(i * sizeof *srv_data_file_sizes);
 
284
        srv_data_file_is_raw_partition = malloc(
 
285
                i * sizeof *srv_data_file_is_raw_partition);
289
286
 
290
287
        srv_n_data_files = i;
291
288
 
415
412
                return(FALSE);
416
413
        }
417
414
 
418
 
        srv_log_group_home_dirs = static_cast<char **>(malloc(i * sizeof *srv_log_group_home_dirs));
 
415
        srv_log_group_home_dirs = malloc(i * sizeof *srv_log_group_home_dirs);
419
416
 
420
417
        /* Then store the actual values to our array */
421
418
 
464
461
/********************************************************************//**
465
462
I/o-handler thread function.
466
463
@return OS_THREAD_DUMMY_RETURN */
467
 
extern "C"
468
 
os_thread_ret_t
469
 
io_handler_thread(void* arg);
470
 
 
471
 
extern "C"
 
464
static
472
465
os_thread_ret_t
473
466
io_handler_thread(
474
467
/*==============*/
512
505
void
513
506
srv_normalize_path_for_win(
514
507
/*=======================*/
515
 
        char*   /*str __attribute__((unused))*/)        /*!< in/out: null-terminated
 
508
        char*   str __attribute__((unused)))    /*!< in/out: null-terminated
516
509
                                                character string */
517
510
{
518
511
#ifdef __WIN__
604
597
                    && os_file_get_last_error(FALSE) != 100
605
598
#endif
606
599
                    ) {
607
 
                  drizzled::errmsg_printf(drizzled::error::ERROR,
608
 
                                          "InnoDB: Error in creating or opening %s", name);
 
600
                        fprintf(stderr,
 
601
                                "InnoDB: Error in creating"
 
602
                                " or opening %s\n", name);
609
603
 
610
 
                  return(DB_ERROR);
 
604
                        return(DB_ERROR);
611
605
                }
612
606
 
613
607
                files[i] = os_file_create(innodb_file_log_key, name,
614
608
                                          OS_FILE_OPEN, OS_FILE_AIO,
615
609
                                          OS_LOG_FILE, &ret);
616
610
                if (!ret) {
617
 
                  drizzled::errmsg_printf(drizzled::error::ERROR,
618
 
                                          "InnoDB: Error in opening %s.", name);
 
611
                        fprintf(stderr,
 
612
                                "InnoDB: Error in opening %s\n", name);
619
613
 
620
614
                        return(DB_ERROR);
621
615
                }
626
620
                if (size != srv_calc_low32(srv_log_file_size)
627
621
                    || size_high != srv_calc_high32(srv_log_file_size)) {
628
622
 
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));
 
623
                        fprintf(stderr,
 
624
                                "InnoDB: Error: log file %s is"
 
625
                                " of different size %lu %lu bytes\n"
 
626
                                "InnoDB: than specified in the .cnf"
 
627
                                " file %lu %lu bytes!\n",
 
628
                                name, (ulong) size_high, (ulong) size,
 
629
                                (ulong) srv_calc_high32(srv_log_file_size),
 
630
                                (ulong) srv_calc_low32(srv_log_file_size));
635
631
 
636
632
                        return(DB_ERROR);
637
633
                }
638
634
        } else {
639
635
                *log_file_created = TRUE;
640
636
 
641
 
                drizzled::errmsg_printf(drizzled::error::INFO,
642
 
                                        "InnoDB: Log file %s did not exist: new to be created",
643
 
                                        name);
 
637
                ut_print_timestamp(stderr);
 
638
 
 
639
                fprintf(stderr,
 
640
                        "  InnoDB: Log file %s did not exist:"
 
641
                        " new to be created\n",
 
642
                        name);
644
643
                if (log_file_has_been_opened) {
645
644
 
646
645
                        return(DB_ERROR);
647
646
                }
648
647
 
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));
 
648
                fprintf(stderr, "InnoDB: Setting log file %s size to %lu MB\n",
 
649
                        name, (ulong) srv_log_file_size
 
650
                        >> (20 - UNIV_PAGE_SIZE_SHIFT));
653
651
 
654
 
                drizzled::errmsg_printf(drizzled::error::INFO,
655
 
                                        "InnoDB: Database physically writes the file full: wait...\n");
 
652
                fprintf(stderr,
 
653
                        "InnoDB: Database physically writes the file"
 
654
                        " full: wait...\n");
656
655
 
657
656
                ret = os_file_set_size(name, files[i],
658
657
                                       srv_calc_low32(srv_log_file_size),
659
658
                                       srv_calc_high32(srv_log_file_size));
660
659
                if (!ret) {
661
 
                  drizzled::errmsg_printf(drizzled::error::ERROR,
662
 
                                          "InnoDB: Error in creating %s: probably out of disk space",
663
 
                                          name);
 
660
                        fprintf(stderr,
 
661
                                "InnoDB: Error in creating %s:"
 
662
                                " probably out of disk space\n",
 
663
                                name);
664
664
 
665
665
                        return(DB_ERROR);
666
666
                }
737
737
        char    name[10000];
738
738
 
739
739
        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);
 
740
                fprintf(stderr, "InnoDB: can only have < 1000 data files\n"
 
741
                        "InnoDB: you have defined %lu\n",
 
742
                        (ulong) srv_n_data_files);
743
743
                return(DB_ERROR);
744
744
        }
745
745
 
784
784
                            && os_file_get_last_error(FALSE) != 100
785
785
#endif
786
786
                            ) {
787
 
                          drizzled::errmsg_printf(drizzled::error::ERROR,
788
 
                                                  "InnoDB: Error in creating or opening %s",
789
 
                                                  name);
 
787
                                fprintf(stderr,
 
788
                                        "InnoDB: Error in creating"
 
789
                                        " or opening %s\n",
 
790
                                        name);
790
791
 
791
792
                                return(DB_ERROR);
792
793
                        }
802
803
                                                  OS_FILE_NORMAL,
803
804
                                                  OS_DATA_FILE, &ret);
804
805
                        if (!ret) {
805
 
                          drizzled::errmsg_printf(drizzled::error::ERROR,
806
 
                                                  "InnoDB: Error in opening %s", name);
 
806
                                fprintf(stderr,
 
807
                                        "InnoDB: Error in opening %s\n", name);
807
808
 
808
809
                                return(DB_ERROR);
809
810
                        }
819
820
                        /* We open the data file */
820
821
 
821
822
                        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);
 
823
                                fprintf(stderr,
 
824
                                        "InnoDB: Error: data files can only"
 
825
                                        " be added at the end\n");
 
826
                                fprintf(stderr,
 
827
                                        "InnoDB: of a tablespace, but"
 
828
                                        " data file %s existed beforehand.\n",
 
829
                                        name);
826
830
                                return(DB_ERROR);
827
831
                        }
828
832
 
844
848
                        }
845
849
 
846
850
                        if (!ret) {
847
 
                          drizzled::errmsg_printf(drizzled::error::ERROR,
848
 
                                                  "InnoDB: Error in opening %s", name);
 
851
                                fprintf(stderr,
 
852
                                        "InnoDB: Error in opening %s\n", name);
849
853
                                os_file_get_last_error(TRUE);
850
854
 
851
855
                                return(DB_ERROR);
872
876
                                        && srv_last_file_size_max
873
877
                                        < rounded_size_pages)) {
874
878
 
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);
 
879
                                        fprintf(stderr,
 
880
                                                "InnoDB: Error: auto-extending"
 
881
                                                " data file %s is"
 
882
                                                " of a different size\n"
 
883
                                                "InnoDB: %lu pages (rounded"
 
884
                                                " down to MB) than specified"
 
885
                                                " in the .cnf file:\n"
 
886
                                                "InnoDB: initial %lu pages,"
 
887
                                                " max %lu (relevant if"
 
888
                                                " non-zero) pages!\n",
 
889
                                                name,
 
890
                                                (ulong) rounded_size_pages,
 
891
                                                (ulong) srv_data_file_sizes[i],
 
892
                                                (ulong)
 
893
                                                srv_last_file_size_max);
884
894
 
885
895
                                        return(DB_ERROR);
886
896
                                }
890
900
 
891
901
                        if (rounded_size_pages != srv_data_file_sizes[i]) {
892
902
 
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!",
 
903
                                fprintf(stderr,
 
904
                                        "InnoDB: Error: data file %s"
 
905
                                        " is of a different size\n"
 
906
                                        "InnoDB: %lu pages"
 
907
                                        " (rounded down to MB)\n"
 
908
                                        "InnoDB: than specified"
 
909
                                        " in the .cnf file %lu pages!\n",
897
910
                                        name,
898
911
                                        (ulong) rounded_size_pages,
899
912
                                        (ulong) srv_data_file_sizes[i]);
915
928
                        one_created = TRUE;
916
929
 
917
930
                        if (i > 0) {
918
 
                                drizzled::errmsg_printf(drizzled::error::INFO,
919
 
                                        "  InnoDB: Data file %s did not exist: new to be created",
 
931
                                ut_print_timestamp(stderr);
 
932
                                fprintf(stderr,
 
933
                                        "  InnoDB: Data file %s did not"
 
934
                                        " exist: new to be created\n",
920
935
                                        name);
921
936
                        } 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);
 
937
                                fprintf(stderr,
 
938
                                        "InnoDB: The first specified"
 
939
                                        " data file %s did not exist:\n"
 
940
                                        "InnoDB: a new database"
 
941
                                        " to be created!\n", name);
924
942
                                *create_new_db = TRUE;
925
943
                        }
926
944
 
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)));
 
945
                        ut_print_timestamp(stderr);
 
946
                        fprintf(stderr,
 
947
                                "  InnoDB: Setting file %s size to %lu MB\n",
 
948
                                name,
 
949
                                (ulong) (srv_data_file_sizes[i]
 
950
                                         >> (20 - UNIV_PAGE_SIZE_SHIFT)));
931
951
 
932
 
                        drizzled::errmsg_printf(drizzled::error::INFO,
933
 
                                "InnoDB: Database physically writes the file full: wait...");
 
952
                        fprintf(stderr,
 
953
                                "InnoDB: Database physically writes the"
 
954
                                " file full: wait...\n");
934
955
 
935
956
                        ret = os_file_set_size(
936
957
                                name, files[i],
938
959
                                srv_calc_high32(srv_data_file_sizes[i]));
939
960
 
940
961
                        if (!ret) {
941
 
                          drizzled::errmsg_printf(drizzled::error::ERROR,
942
 
                                                  "InnoDB: Error in creating %s: probably out of disk space", name);
 
962
                                fprintf(stderr,
 
963
                                        "InnoDB: Error in creating %s:"
 
964
                                        " probably out of disk space\n", name);
943
965
 
944
966
                                return(DB_ERROR);
945
967
                        }
1003
1025
        on Mac OS X 10.3 or later. */
1004
1026
        struct utsname utsname;
1005
1027
        if (uname(&utsname)) {
1006
 
                fputs(_("InnoDB: cannot determine Mac OS X version!\n"), stderr);
 
1028
                fputs("InnoDB: cannot determine Mac OS X version!\n", stderr);
1007
1029
        } else {
1008
1030
                srv_have_fullfsync = strcmp(utsname.release, "7.") >= 0;
1009
1031
        }
1010
1032
        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);
 
1033
                fputs("InnoDB: On Mac OS X, fsync() may be"
 
1034
                      " broken on internal drives,\n"
 
1035
                      "InnoDB: making transactions unsafe!\n", stderr);
1014
1036
        }
1015
1037
# endif /* F_FULLFSYNC */
1016
1038
#endif /* HAVE_DARWIN_THREADS */
1017
1039
 
1018
1040
        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."),
 
1041
                fprintf(stderr,
 
1042
                        "InnoDB: Error: size of InnoDB's ulint is %lu,"
 
1043
                        " but size of void* is %lu.\n"
 
1044
                        "InnoDB: The sizes should be the same"
 
1045
                        " so that on a 64-bit platform you can\n"
 
1046
                        "InnoDB: allocate more than 4 GB of memory.",
1022
1047
                        (ulong)sizeof(ulint), (ulong)sizeof(void*));
1023
1048
        }
1024
1049
 
1028
1053
        innodb_file_per_table) until this function has returned. */
1029
1054
        srv_file_per_table = FALSE;
1030
1055
#ifdef UNIV_DEBUG
1031
 
        drizzled::errmsg_printf(drizzled::error::INFO,
1032
 
                                _("InnoDB: !!!!!!!! UNIV_DEBUG switched on !!!!!!!!!\n"));
 
1056
        fprintf(stderr,
 
1057
                "InnoDB: !!!!!!!! UNIV_DEBUG switched on !!!!!!!!!\n");
1033
1058
#endif
1034
1059
 
1035
1060
#ifdef UNIV_IBUF_DEBUG
1036
 
        drizzled::errmsg_printf(drizzled::error::INFO,
1037
 
                _("InnoDB: !!!!!!!! UNIV_IBUF_DEBUG switched on !!!!!!!!!\n"
 
1061
        fprintf(stderr,
 
1062
                "InnoDB: !!!!!!!! UNIV_IBUF_DEBUG switched on !!!!!!!!!\n"
1038
1063
# 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"
 
1064
                "InnoDB: !!!!!!!! UNIV_IBUF_COUNT_DEBUG switched on !!!!!!!!!\n"
 
1065
                "InnoDB: Crash recovery will fail with UNIV_IBUF_COUNT_DEBUG\n"
1041
1066
# endif
1042
 
                ));
 
1067
                );
1043
1068
#endif
1044
1069
 
1045
1070
#ifdef UNIV_SYNC_DEBUG
1046
 
        drizzled::errmsg_printf(drizzled::error::INFO,
1047
 
                                _("InnoDB: !!!!!!!! UNIV_SYNC_DEBUG switched on !!!!!!!!!\n"));
 
1071
        fprintf(stderr,
 
1072
                "InnoDB: !!!!!!!! UNIV_SYNC_DEBUG switched on !!!!!!!!!\n");
1048
1073
#endif
1049
1074
 
1050
1075
#ifdef UNIV_SEARCH_DEBUG
1051
 
        drizzled::errmsg_printf(drizzled::error::INFO,
1052
 
                                _("InnoDB: !!!!!!!! UNIV_SEARCH_DEBUG switched on !!!!!!!!!\n"));
 
1076
        fprintf(stderr,
 
1077
                "InnoDB: !!!!!!!! UNIV_SEARCH_DEBUG switched on !!!!!!!!!\n");
1053
1078
#endif
1054
1079
 
1055
1080
#ifdef UNIV_LOG_LSN_DEBUG
1056
 
        drizzled::errmsg_printf(drizzled::error::INFO,
1057
 
                                _("InnoDB: !!!!!!!! UNIV_LOG_LSN_DEBUG switched on !!!!!!!!!\n"));
 
1081
        fprintf(stderr,
 
1082
                "InnoDB: !!!!!!!! UNIV_LOG_LSN_DEBUG switched on !!!!!!!!!\n");
1058
1083
#endif /* UNIV_LOG_LSN_DEBUG */
1059
1084
#ifdef UNIV_MEM_DEBUG
1060
 
        drizzled::errmsg_printf(drizzled::error::INFO,
1061
 
                                _("InnoDB: !!!!!!!! UNIV_MEM_DEBUG switched on !!!!!!!!!\n"));
 
1085
        fprintf(stderr,
 
1086
                "InnoDB: !!!!!!!! UNIV_MEM_DEBUG switched on !!!!!!!!!\n");
1062
1087
#endif
1063
1088
 
1064
 
        if (UNIV_LIKELY(srv_use_sys_malloc))
1065
 
        {
1066
 
          drizzled::errmsg_printf(drizzled::error::INFO, _("InnoDB: The InnoDB memory heap is disabled\n"));
 
1089
        if (UNIV_LIKELY(srv_use_sys_malloc)) {
 
1090
                fprintf(stderr,
 
1091
                        "InnoDB: The InnoDB memory heap is disabled\n");
1067
1092
        }
1068
1093
 
1069
 
        drizzled::errmsg_printf(drizzled::error::INFO, "InnoDB: " IB_ATOMICS_STARTUP_MSG
1070
 
                "\nInnoDB: Compressed tables use zlib " ZLIB_VERSION
 
1094
        fputs("InnoDB: " IB_ATOMICS_STARTUP_MSG
 
1095
              "\nInnoDB: Compressed tables use zlib " ZLIB_VERSION
1071
1096
#ifdef UNIV_ZIP_DEBUG
1072
1097
              " with validation"
1073
1098
#endif /* UNIV_ZIP_DEBUG */
1074
1099
#ifdef UNIV_ZIP_COPY
1075
1100
              " and extra copying"
1076
1101
#endif /* UNIV_ZIP_COPY */
1077
 
              " ");
 
1102
              "\n" , stderr);
1078
1103
 
1079
1104
 
1080
1105
        /* Since InnoDB does not currently clean up all its internal data
1083
1108
        second time during the process lifetime. */
1084
1109
 
1085
1110
        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");
 
1111
                fprintf(stderr,
 
1112
                        "InnoDB: Error: startup called second time"
 
1113
                        " during the process lifetime.\n"
 
1114
                        "InnoDB: In the MySQL Embedded Server Library"
 
1115
                        " you cannot call server_init()\n"
 
1116
                        "InnoDB: more than once during"
 
1117
                        " the process lifetime.\n");
1088
1118
        }
1089
1119
 
1090
1120
        srv_start_has_been_called = TRUE;
1126
1156
#elif defined(LINUX_NATIVE_AIO)
1127
1157
 
1128
1158
        if (srv_use_native_aio) {
1129
 
                drizzled::errmsg_printf(drizzled::error::INFO,
1130
 
                                        _("InnoDB: Using Linux native AIO"));
 
1159
                ut_print_timestamp(stderr);
 
1160
                fprintf(stderr,
 
1161
                        "  InnoDB: Using Linux native AIO\n");
1131
1162
        }
1132
1163
#else
1133
1164
        /* Currently native AIO is supported only on windows and linux
1172
1203
                srv_win_file_flush_method = SRV_WIN_IO_UNBUFFERED;
1173
1204
#endif
1174
1205
        } else {
1175
 
          drizzled::errmsg_printf(drizzled::error::ERROR,
1176
 
                                  "InnoDB: Unrecognized value %s for innodb_flush_method",
1177
 
                                  srv_file_flush_method_str);
 
1206
                fprintf(stderr,
 
1207
                        "InnoDB: Unrecognized value %s for"
 
1208
                        " innodb_flush_method\n",
 
1209
                        srv_file_flush_method_str);
1178
1210
                return(DB_ERROR);
1179
1211
        }
1180
1212
 
1214
1246
                     &srv_monitor_file_mutex, SYNC_NO_ORDER_CHECK);
1215
1247
 
1216
1248
        if (srv_innodb_status) {
1217
 
          srv_monitor_file_name = static_cast<char *>(mem_alloc(
 
1249
                srv_monitor_file_name = mem_alloc(
1218
1250
                        strlen(fil_path_to_mysql_datadir)
1219
 
                        + 20 + sizeof "/innodb_status."));
 
1251
                        + 20 + sizeof "/innodb_status.");
1220
1252
                sprintf(srv_monitor_file_name, "%s/innodb_status.%lu",
1221
1253
                        fil_path_to_mysql_datadir, os_proc_get_number());
1222
1254
                srv_monitor_file = fopen(srv_monitor_file_name, "w+");
1223
1255
                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));
 
1256
                        fprintf(stderr, "InnoDB: unable to create %s: %s\n",
 
1257
                                srv_monitor_file_name, strerror(errno));
1226
1258
                        return(DB_ERROR);
1227
1259
                }
1228
1260
        } else {
1276
1308
                 srv_max_n_open_files);
1277
1309
 
1278
1310
        /* Print time to initialize the buffer pool */
 
1311
        ut_print_timestamp(stderr);
 
1312
        fprintf(stderr,
 
1313
                "  InnoDB: Initializing buffer pool, size =");
1279
1314
 
1280
1315
        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));
 
1316
                fprintf(stderr,
 
1317
                        " %.1fG\n",
 
1318
                        ((double) srv_buf_pool_size) / (1024 * 1024 * 1024));
1283
1319
        } else {
1284
 
          drizzled::errmsg_printf(drizzled::error::INFO, "InnoDB: Initializing buffer pool, size = %.1fM",
1285
 
                                  ((double) srv_buf_pool_size) / (1024 * 1024));
 
1320
                fprintf(stderr,
 
1321
                        " %.1fM\n",
 
1322
                        ((double) srv_buf_pool_size) / (1024 * 1024));
1286
1323
        }
1287
1324
 
1288
1325
        err = buf_pool_init(srv_buf_pool_size, srv_buf_pool_instances);
1289
1326
 
1290
 
        drizzled::errmsg_printf(drizzled::error::INFO, "InnoDB: Completed initialization of buffer pool");
 
1327
        ut_print_timestamp(stderr);
 
1328
        fprintf(stderr,
 
1329
                "  InnoDB: Completed initialization of buffer pool\n");
1291
1330
 
1292
1331
        if (err != DB_SUCCESS) {
1293
 
          drizzled::errmsg_printf(drizzled::error::ERROR, "InnoDB: Fatal error: cannot allocate the memory for the buffer pool");
 
1332
                fprintf(stderr,
 
1333
                        "InnoDB: Fatal error: cannot allocate the memory"
 
1334
                        " for the buffer pool\n");
1294
1335
 
1295
 
          return(DB_ERROR);
 
1336
                return(DB_ERROR);
1296
1337
        }
1297
1338
 
1298
1339
#ifdef UNIV_DEBUG
1301
1342
 
1302
1343
        if (srv_buf_pool_size <= 5 * 1024 * 1024) {
1303
1344
 
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);
 
1345
                fprintf(stderr, "InnoDB: Warning: Small buffer pool size "
 
1346
                        "(%luM), the flst_validate() debug function "
 
1347
                        "can cause a deadlock if the buffer pool fills up.\n",
 
1348
                        srv_buf_pool_size / 1024 / 1024);
1308
1349
        }
1309
1350
#endif
1310
1351
 
1323
1364
 
1324
1365
#ifdef UNIV_LOG_ARCHIVE
1325
1366
        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.");
 
1367
                fprintf(stderr,
 
1368
                        "InnoDB: Error: you must set the log group"
 
1369
                        " home dir in my.cnf the\n"
 
1370
                        "InnoDB: same as log arch dir.\n");
1328
1371
 
1329
1372
                return(DB_ERROR);
1330
1373
        }
1331
1374
#endif /* UNIV_LOG_ARCHIVE */
1332
1375
 
1333
1376
        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");
 
1377
                fprintf(stderr,
 
1378
                        "InnoDB: Error: combined size of log files"
 
1379
                        " must be < 4 GB\n");
1336
1380
 
1337
1381
                return(DB_ERROR);
1338
1382
        }
1342
1386
        for (i = 0; i < srv_n_data_files; i++) {
1343
1387
#ifndef __WIN__
1344
1388
                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");
 
1389
                        fprintf(stderr,
 
1390
                                "InnoDB: Error: file size must be < 4 GB"
 
1391
                                " with this MySQL binary\n"
 
1392
                                "InnoDB: and operating system combination,"
 
1393
                                " in some OS's < 2 GB\n");
1348
1394
 
1349
1395
                        return(DB_ERROR);
1350
1396
                }
1353
1399
        }
1354
1400
 
1355
1401
        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");
 
1402
                fprintf(stderr,
 
1403
                        "InnoDB: Error: tablespace size must be"
 
1404
                        " at least 10 MB\n");
1357
1405
 
1358
1406
                return(DB_ERROR);
1359
1407
        }
1365
1413
                                        &min_flushed_lsn, &max_flushed_lsn,
1366
1414
                                        &sum_of_new_sizes);
1367
1415
        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");
 
1416
                fprintf(stderr,
 
1417
                        "InnoDB: Could not open or create data files.\n"
 
1418
                        "InnoDB: If you tried to add new data files,"
 
1419
                        " and it failed here,\n"
 
1420
                        "InnoDB: you should now edit innodb_data_file_path"
 
1421
                        " in my.cnf back\n"
 
1422
                        "InnoDB: to what it was, and remove the"
 
1423
                        " new ibdata files InnoDB created\n"
 
1424
                        "InnoDB: in this failed attempt. InnoDB only wrote"
 
1425
                        " those files full of\n"
 
1426
                        "InnoDB: zeros, but did not yet use them in any way."
 
1427
                        " But be careful: do not\n"
 
1428
                        "InnoDB: remove old data files"
 
1429
                        " which contain your precious data!\n");
1376
1430
 
1377
1431
                return((int) err);
1378
1432
        }
1397
1451
                }
1398
1452
                if ((log_opened && create_new_db)
1399
1453
                    || (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"
 
1454
                        fprintf(stderr,
 
1455
                                "InnoDB: Error: all log files must be"
 
1456
                                " created at the same time.\n"
 
1457
                                "InnoDB: All log files must be"
 
1458
                                " created also in database creation.\n"
 
1459
                                "InnoDB: If you want bigger or smaller"
 
1460
                                " log files, shut down the\n"
 
1461
                                "InnoDB: database and make sure there"
 
1462
                                " were no errors in shutdown.\n"
 
1463
                                "InnoDB: Then delete the existing log files."
 
1464
                                " Edit the .cnf file\n"
1406
1465
                                "InnoDB: and start the database again.\n");
1407
1466
 
1408
1467
                        return(DB_ERROR);
1424
1483
                    || max_arch_log_no != min_arch_log_no
1425
1484
#endif /* UNIV_LOG_ARCHIVE */
1426
1485
                    ) {
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"
 
1486
                        fprintf(stderr,
 
1487
                                "InnoDB: Cannot initialize created"
 
1488
                                " log files because\n"
 
1489
                                "InnoDB: data files were not in sync"
 
1490
                                " with each other\n"
1430
1491
                                "InnoDB: or the data files are corrupt.\n");
1431
1492
 
1432
1493
                        return(DB_ERROR);
1433
1494
                }
1434
1495
 
1435
1496
                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");
 
1497
                        fprintf(stderr,
 
1498
                                "InnoDB: Cannot initialize created"
 
1499
                                " log files because\n"
 
1500
                                "InnoDB: data files are corrupt,"
 
1501
                                " or new data files were\n"
 
1502
                                "InnoDB: created when the database"
 
1503
                                " was started previous\n"
 
1504
                                "InnoDB: time but the database"
 
1505
                                " was not shut down\n"
 
1506
                                "InnoDB: normally after that.\n");
1442
1507
 
1443
1508
                        return(DB_ERROR);
1444
1509
                }
1477
1542
 
1478
1543
#ifdef UNIV_LOG_ARCHIVE
1479
1544
        } else if (srv_archive_recovery) {
1480
 
          drizzled::errmsg_printf(drizzled::error::INFO,
1481
 
                                  "InnoDB: Starting archive recovery from a backup...");
 
1545
                fprintf(stderr,
 
1546
                        "InnoDB: Starting archive"
 
1547
                        " recovery from a backup...\n");
1482
1548
                err = recv_recovery_from_archive_start(
1483
1549
                        min_flushed_lsn, srv_archive_recovery_limit_lsn,
1484
1550
                        min_arch_log_no);
1699
1765
        if (!srv_auto_extend_last_data_file
1700
1766
            && sum_of_data_file_sizes != tablespace_size_in_header) {
1701
1767
 
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);
 
1768
                fprintf(stderr,
 
1769
                        "InnoDB: Error: tablespace size"
 
1770
                        " stored in header is %lu pages, but\n"
 
1771
                        "InnoDB: the sum of data file sizes is %lu pages\n",
 
1772
                        (ulong) tablespace_size_in_header,
 
1773
                        (ulong) sum_of_data_file_sizes);
1706
1774
 
1707
1775
                if (srv_force_recovery == 0
1708
1776
                    && sum_of_data_file_sizes < tablespace_size_in_header) {
1709
1777
                        /* This is a fatal error, the tail of a tablespace is
1710
1778
                        missing */
1711
1779
 
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.");
 
1780
                        fprintf(stderr,
 
1781
                                "InnoDB: Cannot start InnoDB."
 
1782
                                " The tail of the system tablespace is\n"
 
1783
                                "InnoDB: missing. Have you edited"
 
1784
                                " innodb_data_file_path in my.cnf in an\n"
 
1785
                                "InnoDB: inappropriate way, removing"
 
1786
                                " ibdata files from there?\n"
 
1787
                                "InnoDB: You can set innodb_force_recovery=1"
 
1788
                                " in my.cnf to force\n"
 
1789
                                "InnoDB: a startup if you are trying"
 
1790
                                " to recover a badly corrupt database.\n");
1718
1791
 
1719
1792
                        return(DB_ERROR);
1720
1793
                }
1723
1796
        if (srv_auto_extend_last_data_file
1724
1797
            && sum_of_data_file_sizes < tablespace_size_in_header) {
1725
1798
 
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);
 
1799
                fprintf(stderr,
 
1800
                        "InnoDB: Error: tablespace size stored in header"
 
1801
                        " is %lu pages, but\n"
 
1802
                        "InnoDB: the sum of data file sizes"
 
1803
                        " is only %lu pages\n",
 
1804
                        (ulong) tablespace_size_in_header,
 
1805
                        (ulong) sum_of_data_file_sizes);
1731
1806
 
1732
1807
                if (srv_force_recovery == 0) {
1733
1808
 
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");
 
1809
                        fprintf(stderr,
 
1810
                                "InnoDB: Cannot start InnoDB. The tail of"
 
1811
                                " the system tablespace is\n"
 
1812
                                "InnoDB: missing. Have you edited"
 
1813
                                " innodb_data_file_path in my.cnf in an\n"
 
1814
                                "InnoDB: inappropriate way, removing"
 
1815
                                " ibdata files from there?\n"
 
1816
                                "InnoDB: You can set innodb_force_recovery=1"
 
1817
                                " in my.cnf to force\n"
 
1818
                                "InnoDB: a startup if you are trying to"
 
1819
                                " recover a badly corrupt database.\n");
1740
1820
 
1741
1821
                        return(DB_ERROR);
1742
1822
                }
1746
1826
        os_fast_mutex_init(&srv_os_test_mutex);
1747
1827
 
1748
1828
        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");
 
1829
                fprintf(stderr,
 
1830
                        "InnoDB: Error: pthread_mutex_trylock returns"
 
1831
                        " an unexpected value on\n"
 
1832
                        "InnoDB: success! Cannot continue.\n");
1751
1833
                exit(1);
1752
1834
        }
1753
1835
 
1760
1842
        os_fast_mutex_free(&srv_os_test_mutex);
1761
1843
 
1762
1844
        if (srv_print_verbose_log) {
1763
 
                drizzled::errmsg_printf(drizzled::error::INFO,
1764
 
                                        "InnoDB %s started; log sequence number %"PRIu64"\n",
1765
 
                                        INNODB_VERSION_STR, srv_start_lsn);
 
1845
                ut_print_timestamp(stderr);
 
1846
                fprintf(stderr,
 
1847
                        "  InnoDB %s started; "
 
1848
                        "log sequence number %"PRIu64"\n",
 
1849
                        INNODB_VERSION_STR, srv_start_lsn);
1766
1850
        }
1767
1851
 
1768
1852
        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);
 
1853
                fprintf(stderr,
 
1854
                        "InnoDB: !!! innodb_force_recovery"
 
1855
                        " is set to %lu !!!\n",
 
1856
                        (ulong) srv_force_recovery);
1772
1857
        }
1773
1858
 
 
1859
        fflush(stderr);
 
1860
 
1774
1861
        if (trx_doublewrite_must_reset_space_ids) {
1775
1862
                /* Actually, we did not change the undo log format between
1776
1863
                4.0 and 4.1.1, and we would not need to run purge to
1785
1872
                4.1.1. It is essential that the insert buffer is emptied
1786
1873
                here! */
1787
1874
 
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...");
 
1875
                fprintf(stderr,
 
1876
                        "InnoDB: You are upgrading to an"
 
1877
                        " InnoDB version which allows multiple\n"
 
1878
                        "InnoDB: tablespaces. Wait that purge"
 
1879
                        " and insert buffer merge run to\n"
 
1880
                        "InnoDB: completion...\n");
1791
1881
                for (;;) {
1792
1882
                        os_thread_sleep(1000000);
1793
1883
 
1799
1889
                                break;
1800
1890
                        }
1801
1891
                }
1802
 
                drizzled::errmsg_printf(drizzled::error::INFO,
1803
 
                                        "InnoDB: Full purge and insert buffer merge completed.");
 
1892
                fprintf(stderr,
 
1893
                        "InnoDB: Full purge and insert buffer merge"
 
1894
                        " completed.\n");
1804
1895
 
1805
1896
                trx_sys_mark_upgraded_to_multiple_tablespaces();
1806
1897
 
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");
 
1898
                fprintf(stderr,
 
1899
                        "InnoDB: You have now successfully upgraded"
 
1900
                        " to the multiple tablespaces\n"
 
1901
                        "InnoDB: format. You should NOT DOWNGRADE"
 
1902
                        " to an earlier version of\n"
 
1903
                        "InnoDB: InnoDB! But if you absolutely need to"
 
1904
                        " downgrade, see\n"
 
1905
                        "InnoDB: " REFMAN "multiple-tablespaces.html\n"
 
1906
                        "InnoDB: for instructions.\n");
1816
1907
        }
1817
1908
 
1818
1909
        if (srv_force_recovery == 0) {
1842
1933
        ulint   i;
1843
1934
        if (!srv_was_started) {
1844
1935
                if (srv_is_being_started) {
1845
 
                  drizzled::errmsg_printf(drizzled::error::ERROR,
1846
 
                                "InnoDB: Warning: shutting down a not properly started or created database!");
 
1936
                        ut_print_timestamp(stderr);
 
1937
                        fprintf(stderr,
 
1938
                                "  InnoDB: Warning: shutting down"
 
1939
                                " a not properly started\n"
 
1940
                                "InnoDB: or created database!\n");
1847
1941
                }
1848
1942
 
1849
1943
                return(DB_SUCCESS);
1856
1950
 
1857
1951
 
1858
1952
        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!");
 
1953
                ut_print_timestamp(stderr);
 
1954
                fprintf(stderr,
 
1955
                        "  InnoDB: MySQL has requested a very fast shutdown"
 
1956
                        " without flushing "
 
1957
                        "the InnoDB buffer pool to data files."
 
1958
                        " At the next mysqld startup "
 
1959
                        "InnoDB will do a crash recovery!\n");
1863
1960
        }
1864
1961
 
1865
1962
        logs_empty_and_mark_files_at_shutdown();
1866
1963
 
1867
1964
        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);
 
1965
                fprintf(stderr,
 
1966
                        "InnoDB: Warning: query counter shows %ld queries"
 
1967
                        " still\n"
 
1968
                        "InnoDB: inside InnoDB at shutdown\n",
 
1969
                        srv_conc_n_threads);
1871
1970
        }
1872
1971
 
1873
1972
        /* 2. Make all threads created by InnoDB to exit */
1930
2029
        }
1931
2030
 
1932
2031
        if (i == 1000) {
1933
 
          drizzled::errmsg_printf(drizzled::error::WARN,
1934
 
                        "InnoDB: Warning: %lu threads created by InnoDB had not exited at shutdown!",
 
2032
                fprintf(stderr,
 
2033
                        "InnoDB: Warning: %lu threads created by InnoDB"
 
2034
                        " had not exited at shutdown!\n",
1935
2035
                        (ulong) os_thread_count);
1936
2036
        }
1937
2037
 
1997
2097
            || os_event_count != 0
1998
2098
            || os_mutex_count != 0
1999
2099
            || 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);
 
2100
                fprintf(stderr,
 
2101
                        "InnoDB: Warning: some resources were not"
 
2102
                        " cleaned up in shutdown:\n"
 
2103
                        "InnoDB: threads %lu, events %lu,"
 
2104
                        " os_mutexes %lu, os_fast_mutexes %lu\n",
 
2105
                        (ulong) os_thread_count, (ulong) os_event_count,
 
2106
                        (ulong) os_mutex_count, (ulong) os_fast_mutex_count);
2005
2107
        }
2006
2108
 
2007
2109
        if (dict_foreign_err_file) {
2012
2114
        }
2013
2115
 
2014
2116
        if (srv_print_verbose_log) {
2015
 
                drizzled::errmsg_printf(drizzled::error::INFO,
2016
 
                                        "InnoDB: Shutdown completed log sequence number %"PRIu64,
2017
 
                                        srv_shutdown_lsn);
 
2117
                ut_print_timestamp(stderr);
 
2118
                fprintf(stderr,
 
2119
                        "  InnoDB: Shutdown completed;"
 
2120
                        " log sequence number %"PRIu64"\n",
 
2121
                        srv_shutdown_lsn);
2018
2122
        }
2019
2123
 
2020
2124
        srv_was_started = FALSE;