/***************************************************************************** Copyright (c) 1996, 2017, Oracle and/or its affiliates. All rights reserved. Copyright (c) 2008, Google Inc. Copyright (c) 2009, Percona Inc. Copyright (c) 2013, 2019, MariaDB Corporation. Portions of this file contain modifications contributed and copyrighted by Google, Inc. Those modifications are gratefully acknowledged and are described briefly in the InnoDB documentation. The contributions by Google are incorporated with their permission, and subject to the conditions contained in the file COPYING.Google. Portions of this file contain modifications contributed and copyrighted by Percona Inc.. Those modifications are gratefully acknowledged and are described briefly in the InnoDB documentation. The contributions by Percona Inc. are incorporated with their permission, and subject to the conditions contained in the file COPYING.Percona. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; version 2 of the License. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA *****************************************************************************/ /********************************************************************//** @file srv/srv0start.cc Starts the InnoDB database server Created 2/16/1996 Heikki Tuuri *************************************************************************/ #include "mysqld.h" #include "pars0pars.h" #include "row0ftsort.h" #include "ut0mem.h" #include "mem0mem.h" #include "data0data.h" #include "data0type.h" #include "dict0dict.h" #include "buf0buf.h" #include "buf0dump.h" #include "os0file.h" #include "os0thread.h" #include "fil0fil.h" #include "fil0crypt.h" #include "fsp0fsp.h" #include "rem0rec.h" #include "mtr0mtr.h" #include "log0log.h" #include "log0online.h" #include "log0recv.h" #include "page0page.h" #include "page0cur.h" #include "trx0trx.h" #include "trx0sys.h" #include "btr0btr.h" #include "btr0cur.h" #include "rem0rec.h" #include "ibuf0ibuf.h" #include "srv0start.h" #include "srv0srv.h" #include "buf0flu.h" #include "btr0defragment.h" #include "btr0scrub.h" #include "mysql/service_wsrep.h" /* wsrep_recovery */ #ifndef UNIV_HOTBACKUP # include "trx0rseg.h" # include "os0proc.h" # include "sync0sync.h" # include "buf0flu.h" # include "buf0mtflu.h" # include "buf0rea.h" # include "dict0boot.h" # include "dict0load.h" # include "dict0stats_bg.h" # include "que0que.h" # include "usr0sess.h" # include "lock0lock.h" # include "trx0roll.h" # include "trx0purge.h" # include "lock0lock.h" # include "pars0pars.h" # include "btr0sea.h" # include "rem0cmp.h" # include "dict0crea.h" # include "row0ins.h" # include "row0sel.h" # include "row0upd.h" # include "row0row.h" # include "row0mysql.h" # include "btr0pcur.h" # include "os0sync.h" # include "zlib.h" # include "ut0crc32.h" # include "os0stacktrace.h" /** Log sequence number immediately after startup */ UNIV_INTERN lsn_t srv_start_lsn; /** Log sequence number at shutdown */ UNIV_INTERN lsn_t srv_shutdown_lsn; #ifdef HAVE_DARWIN_THREADS # include /** TRUE if the F_FULLFSYNC option is available */ UNIV_INTERN ibool srv_have_fullfsync = FALSE; #endif /** TRUE if a raw partition is in use */ UNIV_INTERN ibool srv_start_raw_disk_in_use = FALSE; /** UNDO tablespaces starts with space id. */ ulint srv_undo_space_id_start; /** TRUE if the server is being started, before rolling back any incomplete transactions */ UNIV_INTERN ibool srv_startup_is_before_trx_rollback_phase = FALSE; /** TRUE if the server is being started */ UNIV_INTERN ibool srv_is_being_started = FALSE; /** TRUE if the server was successfully started */ UNIV_INTERN ibool srv_was_started = FALSE; /** TRUE if innobase_start_or_create_for_mysql() has been called */ static ibool srv_start_has_been_called; /** Whether any undo log records can be generated */ UNIV_INTERN bool srv_undo_sources; #ifdef UNIV_DEBUG /** InnoDB system tablespace to set during recovery */ UNIV_INTERN uint srv_sys_space_size_debug; #endif /* UNIV_DEBUG */ /** At a shutdown this value climbs from SRV_SHUTDOWN_NONE to SRV_SHUTDOWN_CLEANUP and then to SRV_SHUTDOWN_LAST_PHASE, and so on */ UNIV_INTERN enum srv_shutdown_state srv_shutdown_state = SRV_SHUTDOWN_NONE; /** Files comprising the system tablespace. Also used by Mariabackup. */ UNIV_INTERN pfs_os_file_t files[1000]; /** io_handler_thread parameters for thread identification */ static ulint n[SRV_MAX_N_IO_THREADS]; /** io_handler_thread identifiers, 32 is the maximum number of purge threads. The extra elements at the end are allocated as follows: SRV_MAX_N_IO_THREADS + 1: srv_master_thread SRV_MAX_N_IO_THREADS + 2: lock_wait_timeout_thread SRV_MAX_N_IO_THREADS + 3: srv_error_monitor_thread SRV_MAX_N_IO_THREADS + 4: srv_monitor_thread SRV_MAX_N_IO_THREADS + 5: srv_redo_log_follow_thread SRV_MAX_N_IO_THREADS + 6: srv_purge_coordinator_thread SRV_MAX_N_IO_THREADS + 7: srv_worker_thread ... SRV_MAX_N_IO_THREADS + 7 + srv_n_purge_threads - 1: srv_worker_thread */ static os_thread_id_t thread_ids[SRV_MAX_N_IO_THREADS + 7 + SRV_MAX_N_PURGE_THREADS + MTFLUSH_MAX_WORKER]; /* Thread contex data for multi-threaded flush */ void *mtflush_ctx=NULL; /** Thead handles */ static os_thread_t thread_handles[SRV_MAX_N_IO_THREADS + 7 + SRV_MAX_N_PURGE_THREADS]; static os_thread_t buf_flush_page_cleaner_thread_handle; static os_thread_t buf_dump_thread_handle; static os_thread_t dict_stats_thread_handle; static os_thread_t buf_flush_lru_manager_thread_handle; static os_thread_t srv_redo_log_follow_thread_handle; /** Status variables, is thread started ?*/ static bool thread_started[SRV_MAX_N_IO_THREADS + 7 + SRV_MAX_N_PURGE_THREADS] = {false}; static bool buf_flush_page_cleaner_thread_started = false; static bool buf_dump_thread_started = false; static bool dict_stats_thread_started = false; static bool buf_flush_lru_manager_thread_started = false; static bool srv_redo_log_follow_thread_started = false; /** We use this mutex to test the return value of pthread_mutex_trylock on successful locking. HP-UX does NOT return 0, though Linux et al do. */ static os_fast_mutex_t srv_os_test_mutex; /** Name of srv_monitor_file */ static char* srv_monitor_file_name; #endif /* !UNIV_HOTBACKUP */ /** Default undo tablespace size in UNIV_PAGEs count (10MB). */ static const ulint SRV_UNDO_TABLESPACE_SIZE_IN_PAGES = ((1024 * 1024) * 10) / UNIV_PAGE_SIZE_DEF; /** */ #define SRV_N_PENDING_IOS_PER_THREAD OS_AIO_N_PENDING_IOS_PER_THREAD #define SRV_MAX_N_PENDING_SYNC_IOS 100 #ifdef UNIV_PFS_THREAD /* Keys to register InnoDB threads with performance schema */ UNIV_INTERN mysql_pfs_key_t io_handler_thread_key; UNIV_INTERN mysql_pfs_key_t srv_lock_timeout_thread_key; UNIV_INTERN mysql_pfs_key_t srv_error_monitor_thread_key; UNIV_INTERN mysql_pfs_key_t srv_monitor_thread_key; UNIV_INTERN mysql_pfs_key_t srv_master_thread_key; UNIV_INTERN mysql_pfs_key_t srv_purge_thread_key; UNIV_INTERN mysql_pfs_key_t srv_log_tracking_thread_key; #endif /* UNIV_PFS_THREAD */ /** Innobase start-up aborted. Perform cleanup actions. @param[in] create_new_db TRUE if new db is being created @param[in] file File name @param[in] line Line number @param[in] err Reason for aborting InnoDB startup @return DB_SUCCESS or error code. */ static dberr_t srv_init_abort( bool create_new_db, const char* file, ulint line, dberr_t err) { if (create_new_db) { ib_logf(IB_LOG_LEVEL_ERROR, "Database creation was aborted" " at %s [" ULINTPF "]" " with error %s. You may need" " to delete the ibdata1 file before trying to start" " up again.", file, line, ut_strerr(err)); } else { ib_logf(IB_LOG_LEVEL_ERROR, "Plugin initialization aborted" " at %s [" ULINTPF "]" " with error %s.", file, line, ut_strerr(err)); } return(err); } /*********************************************************************//** Convert a numeric string that optionally ends in G or M or K, to a number containing megabytes. @return next character in string */ static char* srv_parse_megabytes( /*================*/ char* str, /*!< in: string containing a quantity in bytes */ ulint* megs) /*!< out: the number in megabytes */ { char* endp; ulint size; size = strtoul(str, &endp, 10); str = endp; switch (*str) { case 'G': case 'g': size *= 1024; /* fall through */ case 'M': case 'm': str++; break; case 'K': case 'k': size /= 1024; str++; break; default: size /= 1024 * 1024; break; } *megs = size; return(str); } /*********************************************************************//** Check if a file can be opened in read-write mode. @return true if it doesn't exist or can be opened in rw mode. */ static bool srv_file_check_mode( /*================*/ const char* name) /*!< in: filename to check */ { os_file_stat_t stat; memset(&stat, 0x0, sizeof(stat)); dberr_t err = os_file_get_status(name, &stat, true); if (err == DB_FAIL) { ib_logf(IB_LOG_LEVEL_ERROR, "os_file_get_status() failed on '%s'. Can't determine " "file permissions", name); return(false); } else if (err == DB_SUCCESS) { /* Note: stat.rw_perm is only valid of files */ if (stat.type == OS_FILE_TYPE_FILE) { if (!stat.rw_perm) { ib_logf(IB_LOG_LEVEL_ERROR, "%s can't be opened in %s mode", name, srv_read_only_mode ? "read" : "read-write"); return(false); } } else { /* Not a regular file, bail out. */ ib_logf(IB_LOG_LEVEL_ERROR, "'%s' not a regular file.", name); return(false); } } else { /* This is OK. If the file create fails on RO media, there is nothing we can do. */ ut_a(err == DB_NOT_FOUND); } return(true); } /*********************************************************************//** Reads the data files and their sizes from a character string given in the .cnf file. @return TRUE if ok, FALSE on parse error */ UNIV_INTERN ibool srv_parse_data_file_paths_and_sizes( /*================================*/ char* str) /*!< in/out: the data file path string */ { char* input_str; char* path; ulint size; ulint i = 0; srv_auto_extend_last_data_file = FALSE; srv_last_file_size_max = 0; srv_data_file_names = NULL; srv_data_file_sizes = NULL; srv_data_file_is_raw_partition = NULL; input_str = str; /* First calculate the number of data files and check syntax: path:size[M | G];path:size[M | G]... . Note that a Windows path may contain a drive name and a ':'. */ while (*str != '\0') { path = str; while ((*str != ':' && *str != '\0') || (*str == ':' && (*(str + 1) == '\\' || *(str + 1) == '/' || *(str + 1) == ':'))) { str++; } if (*str == '\0') { return(FALSE); } str++; str = srv_parse_megabytes(str, &size); if (0 == strncmp(str, ":autoextend", (sizeof ":autoextend") - 1)) { str += (sizeof ":autoextend") - 1; if (0 == strncmp(str, ":max:", (sizeof ":max:") - 1)) { str += (sizeof ":max:") - 1; str = srv_parse_megabytes(str, &size); } if (*str != '\0') { return(FALSE); } } if (strlen(str) >= 6 && *str == 'n' && *(str + 1) == 'e' && *(str + 2) == 'w') { str += 3; } if (*str == 'r' && *(str + 1) == 'a' && *(str + 2) == 'w') { str += 3; } if (size == 0) { return(FALSE); } i++; if (*str == ';') { str++; } else if (*str != '\0') { return(FALSE); } } if (i == 0) { /* If innodb_data_file_path was defined it must contain at least one data file definition */ return(FALSE); } srv_data_file_names = static_cast( malloc(i * sizeof *srv_data_file_names)); srv_data_file_sizes = static_cast( malloc(i * sizeof *srv_data_file_sizes)); srv_data_file_is_raw_partition = static_cast( malloc(i * sizeof *srv_data_file_is_raw_partition)); srv_n_data_files = i; /* Then store the actual values to our arrays */ str = input_str; i = 0; while (*str != '\0') { path = str; /* Note that we must step over the ':' in a Windows path; a Windows path normally looks like C:\ibdata\ibdata1:1G, but a Windows raw partition may have a specification like \\.\C::1Gnewraw or \\.\PHYSICALDRIVE2:1Gnewraw */ while ((*str != ':' && *str != '\0') || (*str == ':' && (*(str + 1) == '\\' || *(str + 1) == '/' || *(str + 1) == ':'))) { str++; } if (*str == ':') { /* Make path a null-terminated string */ *str = '\0'; str++; } str = srv_parse_megabytes(str, &size); srv_data_file_names[i] = path; srv_data_file_sizes[i] = size; if (0 == strncmp(str, ":autoextend", (sizeof ":autoextend") - 1)) { srv_auto_extend_last_data_file = TRUE; str += (sizeof ":autoextend") - 1; if (0 == strncmp(str, ":max:", (sizeof ":max:") - 1)) { str += (sizeof ":max:") - 1; str = srv_parse_megabytes( str, &srv_last_file_size_max); } if (*str != '\0') { return(FALSE); } } (srv_data_file_is_raw_partition)[i] = 0; if (strlen(str) >= 6 && *str == 'n' && *(str + 1) == 'e' && *(str + 2) == 'w') { str += 3; /* Initialize new raw device only during bootstrap */ (srv_data_file_is_raw_partition)[i] = opt_bootstrap ? SRV_NEW_RAW : SRV_OLD_RAW; } if (*str == 'r' && *(str + 1) == 'a' && *(str + 2) == 'w') { str += 3; /* Initialize new raw device only during bootstrap */ if ((srv_data_file_is_raw_partition)[i] == 0) { (srv_data_file_is_raw_partition)[i] = opt_bootstrap ? SRV_NEW_RAW : SRV_OLD_RAW; } } i++; if (*str == ';') { str++; } } return(TRUE); } /*********************************************************************//** Frees the memory allocated by srv_parse_data_file_paths_and_sizes() and srv_parse_log_group_home_dirs(). */ UNIV_INTERN void srv_free_paths_and_sizes(void) /*==========================*/ { free(srv_data_file_names); srv_data_file_names = NULL; free(srv_data_file_sizes); srv_data_file_sizes = NULL; free(srv_data_file_is_raw_partition); srv_data_file_is_raw_partition = NULL; } #ifndef UNIV_HOTBACKUP static ulint io_tid_i = 0; /********************************************************************//** I/o-handler thread function. @return OS_THREAD_DUMMY_RETURN */ extern "C" UNIV_INTERN os_thread_ret_t DECLARE_THREAD(io_handler_thread)( /*==============================*/ void* arg) /*!< in: pointer to the number of the segment in the aio array */ { ulint segment; ulint tid_i = os_atomic_increment_ulint(&io_tid_i, 1) - 1; ut_ad(tid_i < srv_n_file_io_threads); segment = *((ulint*) arg); srv_io_tids[tid_i] = os_thread_get_tid(); os_thread_set_priority(srv_io_tids[tid_i], srv_sched_priority_io); #ifdef UNIV_DEBUG_THREAD_CREATION ib_logf(IB_LOG_LEVEL_INFO, "Io handler thread %lu starts, id %lu\n", segment, os_thread_pf(os_thread_get_curr_id())); #endif #ifdef UNIV_PFS_THREAD pfs_register_thread(io_handler_thread_key); #endif /* UNIV_PFS_THREAD */ while (srv_shutdown_state != SRV_SHUTDOWN_EXIT_THREADS) { srv_current_thread_priority = srv_io_thread_priority; fil_aio_wait(segment); } /* We count the number of threads in os_thread_exit(). A created thread should always use that to exit and not use return() to exit. The thread actually never comes here because it is exited in an os_event_wait(). */ os_thread_exit(NULL); OS_THREAD_DUMMY_RETURN; } #endif /* !UNIV_HOTBACKUP */ /*********************************************************************//** Normalizes a directory path for Windows: converts slashes to backslashes. */ UNIV_INTERN void srv_normalize_path_for_win( /*=======================*/ char* str MY_ATTRIBUTE((unused))) /*!< in/out: null-terminated character string */ { #ifdef __WIN__ for (; *str; str++) { if (*str == '/') { *str = '\\'; } } #endif } #ifndef UNIV_HOTBACKUP /*********************************************************************//** Creates a log file. @return DB_SUCCESS or error code */ static MY_ATTRIBUTE((nonnull, warn_unused_result)) dberr_t create_log_file( /*============*/ pfs_os_file_t* file, /*!< out: file handle */ const char* name) /*!< in: log file name */ { ibool ret; *file = os_file_create( innodb_file_log_key, name, OS_FILE_CREATE|OS_FILE_ON_ERROR_NO_EXIT, OS_FILE_NORMAL, OS_LOG_FILE, &ret, FALSE); if (!ret) { ib_logf(IB_LOG_LEVEL_ERROR, "Cannot create %s", name); return(DB_ERROR); } ib_logf(IB_LOG_LEVEL_INFO, "Setting log file %s size to %lu MB", name, (ulong) srv_log_file_size >> (20 - UNIV_PAGE_SIZE_SHIFT)); ret = os_file_set_size(name, *file, (os_offset_t) srv_log_file_size << UNIV_PAGE_SIZE_SHIFT); if (!ret) { ib_logf(IB_LOG_LEVEL_ERROR, "Cannot set log file" " %s to size %lu MB", name, (ulong) srv_log_file_size >> (20 - UNIV_PAGE_SIZE_SHIFT)); return(DB_ERROR); } ret = os_file_close(*file); ut_a(ret); return(DB_SUCCESS); } /** Initial number of the first redo log file */ #define INIT_LOG_FILE0 (SRV_N_LOG_FILES_MAX + 1) /*********************************************************************//** Creates all log files. @return DB_SUCCESS or error code */ static dberr_t create_log_files( /*=============*/ bool create_new_db, /*!< in: TRUE if new database is being created */ char* logfilename, /*!< in/out: buffer for log file name */ size_t dirnamelen, /*!< in: length of the directory path */ lsn_t lsn, /*!< in: FIL_PAGE_FILE_FLUSH_LSN value */ char*& logfile0) /*!< out: name of the first log file */ { if (srv_read_only_mode) { ib_logf(IB_LOG_LEVEL_ERROR, "Cannot create log files in read-only mode"); return(DB_READ_ONLY); } /* We prevent system tablespace creation with existing files in data directory. So we do not delete log files when creating new system tablespace */ if (!create_new_db) { /* Remove any old log files. */ for (unsigned i = 0; i <= INIT_LOG_FILE0; i++) { sprintf(logfilename + dirnamelen, "ib_logfile%u", i); /* Ignore errors about non-existent files or files that cannot be removed. The create_log_file() will return an error when the file exists. */ #ifdef __WIN__ DeleteFile((LPCTSTR) logfilename); #else unlink(logfilename); #endif /* Crashing after deleting the first file should be recoverable. The buffer pool was clean, and we can simply create all log files from the scratch. */ DBUG_EXECUTE_IF("innodb_log_abort_6", return(DB_ERROR);); } } ut_ad(!buf_pool_check_no_pending_io()); DBUG_EXECUTE_IF("innodb_log_abort_7", return(DB_ERROR);); for (unsigned i = 0; i < srv_n_log_files; i++) { sprintf(logfilename + dirnamelen, "ib_logfile%u", i ? i : INIT_LOG_FILE0); dberr_t err = create_log_file(&files[i], logfilename); if (err != DB_SUCCESS) { return(err); } } DBUG_EXECUTE_IF("innodb_log_abort_8", return(DB_ERROR);); /* We did not create the first log file initially as ib_logfile0, so that crash recovery cannot find it until it has been completed and renamed. */ sprintf(logfilename + dirnamelen, "ib_logfile%u", INIT_LOG_FILE0); fil_space_create( logfilename, SRV_LOG_SPACE_FIRST_ID, 0, FIL_LOG, NULL /* no encryption yet */, true /* this is create */); ut_a(fil_validate()); logfile0 = fil_node_create( logfilename, (ulint) srv_log_file_size, SRV_LOG_SPACE_FIRST_ID, FALSE); ut_a(logfile0); for (unsigned i = 1; i < srv_n_log_files; i++) { sprintf(logfilename + dirnamelen, "ib_logfile%u", i); if (!fil_node_create( logfilename, (ulint) srv_log_file_size, SRV_LOG_SPACE_FIRST_ID, FALSE)) { ut_error; } } #ifdef UNIV_LOG_ARCHIVE /* Create the file space object for archived logs. */ fil_space_create("arch_log_space", SRV_LOG_SPACE_FIRST_ID + 1, 0, FIL_LOG, NULL /* no encryption yet */, true /* create */); #endif log_group_init(0, srv_n_log_files, srv_log_file_size * UNIV_PAGE_SIZE, SRV_LOG_SPACE_FIRST_ID, SRV_LOG_SPACE_FIRST_ID + 1); fil_open_log_and_system_tablespace_files(); /* Create a log checkpoint. */ mutex_enter(&log_sys->mutex); ut_d(recv_no_log_write = srv_apply_log_only); recv_reset_logs( #ifdef UNIV_LOG_ARCHIVE UT_LIST_GET_FIRST(log_sys->log_groups)->archived_file_no, TRUE, #endif lsn); mutex_exit(&log_sys->mutex); return(DB_SUCCESS); } /** Rename the first redo log file. @param[in,out] logfilename buffer for the log file name @param[in] dirnamelen length of the directory path @param[in] lsn FIL_PAGE_FILE_FLUSH_LSN value @param[in,out] logfile0 name of the first log file @return error code @retval DB_SUCCESS on successful operation */ MY_ATTRIBUTE((warn_unused_result, nonnull)) static dberr_t create_log_files_rename( /*====================*/ char* logfilename, /*!< in/out: buffer for log file name */ size_t dirnamelen, /*!< in: length of the directory path */ lsn_t lsn, /*!< in: FIL_PAGE_FILE_FLUSH_LSN value */ char* logfile0) /*!< in/out: name of the first log file */ { /* If innodb_flush_method=O_DSYNC, we need to explicitly flush the log buffers. */ fil_flush(SRV_LOG_SPACE_FIRST_ID); DBUG_EXECUTE_IF("innodb_log_abort_9", return(DB_ERROR);); /* Close the log files, so that we can rename the first one. */ fil_close_log_files(false); /* Rename the first log file, now that a log checkpoint has been created. */ sprintf(logfilename + dirnamelen, "ib_logfile%u", 0); ib_logf(IB_LOG_LEVEL_INFO, "Renaming log file %s to %s", logfile0, logfilename); mutex_enter(&log_sys->mutex); ut_ad(strlen(logfile0) == 2 + strlen(logfilename)); dberr_t err = os_file_rename( innodb_file_log_key, logfile0, logfilename) ? DB_SUCCESS : DB_ERROR; /* Replace the first file with ib_logfile0. */ strcpy(logfile0, logfilename); mutex_exit(&log_sys->mutex); DBUG_EXECUTE_IF("innodb_log_abort_10", err = DB_ERROR;); if (err == DB_SUCCESS) { fil_open_log_and_system_tablespace_files(); ib_logf(IB_LOG_LEVEL_WARN, "New log files created, LSN=" LSN_PF, lsn); } return(err); } /*********************************************************************//** Opens a log file. @return DB_SUCCESS or error code */ static MY_ATTRIBUTE((nonnull, warn_unused_result)) dberr_t open_log_file( /*==========*/ pfs_os_file_t* file, /*!< out: file handle */ const char* name, /*!< in: log file name */ os_offset_t* size) /*!< out: file size */ { ibool ret; *file = os_file_create(innodb_file_log_key, name, OS_FILE_OPEN, OS_FILE_AIO, OS_LOG_FILE, &ret, FALSE); if (!ret) { ib_logf(IB_LOG_LEVEL_ERROR, "Unable to open '%s'", name); return(DB_ERROR); } *size = os_file_get_size(*file); ret = os_file_close(*file); ut_a(ret); return(DB_SUCCESS); } /** Creates or opens database data files and closes them. @param[out] create_new_db true = create new database @param[out] min_arch_log_no min of archived log numbers in data files @param[out] max_arch_log_no max of archived log numbers in data files @param[out] flushed_lsn flushed lsn in fist datafile @param[out] sum_of_new_sizes sum of sizes of the new files added @return DB_SUCCESS or error code */ MY_ATTRIBUTE((nonnull, warn_unused_result)) dberr_t open_or_create_data_files( bool* create_new_db, #ifdef UNIV_LOG_ARCHIVE lsn_t* min_arch_log_no, lsn_t* max_arch_log_no, #endif /* UNIV_LOG_ARCHIVE */ lsn_t* flushed_lsn, ulint* sum_of_new_sizes) { ibool ret; ulint i; bool one_opened = false; bool one_created = false; os_offset_t size; ulint flags; ulint space = 0; ulint rounded_size_pages; char name[10000]; fil_space_crypt_t* crypt_data=NULL; if (srv_n_data_files >= 1000) { ib_logf(IB_LOG_LEVEL_ERROR, "Can only have < 1000 data files, you have " "defined %lu", (ulong) srv_n_data_files); return(DB_ERROR); } *sum_of_new_sizes = 0; *create_new_db = false; srv_normalize_path_for_win(srv_data_home); for (i = 0; i < srv_n_data_files; i++) { ulint dirnamelen; srv_normalize_path_for_win(srv_data_file_names[i]); dirnamelen = strlen(srv_data_home); ut_a(dirnamelen + strlen(srv_data_file_names[i]) < (sizeof name) - 1); memcpy(name, srv_data_home, dirnamelen); /* Add a path separator if needed. */ if (dirnamelen && name[dirnamelen - 1] != SRV_PATH_SEPARATOR) { name[dirnamelen++] = SRV_PATH_SEPARATOR; } strcpy(name + dirnamelen, srv_data_file_names[i]); /* Note: It will return true if the file doesn' exist. */ if (!srv_file_check_mode(name)) { return(DB_FAIL); } else if (srv_data_file_is_raw_partition[i] == 0) { /* First we try to create the file: if it already exists, ret will get value FALSE */ files[i] = os_file_create( innodb_file_data_key, name, OS_FILE_CREATE, OS_FILE_NORMAL, OS_DATA_FILE, &ret, FALSE); if (srv_read_only_mode) { if (ret) { goto size_check; } ib_logf(IB_LOG_LEVEL_ERROR, "Opening %s failed!", name); return(DB_ERROR); } else if (!ret && os_file_get_last_error(false) != OS_FILE_ALREADY_EXISTS #ifdef UNIV_AIX /* AIX 5.1 after security patch ML7 may have errno set to 0 here, which causes our function to return 100; work around that AIX problem */ && os_file_get_last_error(false) != 100 #endif /* UNIV_AIX */ ) { ib_logf(IB_LOG_LEVEL_ERROR, "Creating or opening %s failed!", name); return(DB_ERROR); } } else if (srv_data_file_is_raw_partition[i] == SRV_NEW_RAW) { ut_a(!srv_read_only_mode); /* The partition is opened, not created; then it is written over */ srv_start_raw_disk_in_use = TRUE; srv_created_new_raw = TRUE; files[i] = os_file_create( innodb_file_data_key, name, OS_FILE_OPEN_RAW, OS_FILE_NORMAL, OS_DATA_FILE, &ret, FALSE); if (!ret) { ib_logf(IB_LOG_LEVEL_ERROR, "Error in opening %s", name); return(DB_ERROR); } const char* check_msg; check_msg = fil_read_first_page( files[i], FALSE, &flags, &space, flushed_lsn, NULL); /* If first page is valid, don't overwrite DB. It prevents overwriting DB when mysql_install_db starts mysqld multiple times during bootstrap. */ if (check_msg == NULL) { srv_created_new_raw = FALSE; ret = FALSE; } } else if (srv_data_file_is_raw_partition[i] == SRV_OLD_RAW) { srv_start_raw_disk_in_use = TRUE; ret = FALSE; } else { ut_a(0); } if (ret == FALSE) { const char* check_msg; /* We open the data file */ if (one_created) { ib_logf(IB_LOG_LEVEL_ERROR, "Data files can only be added at " "the end of a tablespace, but " "data file %s existed beforehand.", name); return(DB_ERROR); } if (srv_data_file_is_raw_partition[i] == SRV_OLD_RAW) { ut_a(!srv_read_only_mode); files[i] = os_file_create( innodb_file_data_key, name, OS_FILE_OPEN_RAW, OS_FILE_NORMAL, OS_DATA_FILE, &ret, FALSE); } else if (i == 0) { files[i] = os_file_create( innodb_file_data_key, name, OS_FILE_OPEN_RETRY, OS_FILE_NORMAL, OS_DATA_FILE, &ret, FALSE); } else { files[i] = os_file_create( innodb_file_data_key, name, OS_FILE_OPEN, OS_FILE_NORMAL, OS_DATA_FILE, &ret, FALSE); } if (!ret) { os_file_get_last_error(true); ib_logf(IB_LOG_LEVEL_ERROR, "Can't open '%s'", name); return(DB_ERROR); } if (srv_data_file_is_raw_partition[i] == SRV_OLD_RAW) { goto skip_size_check; } size_check: size = os_file_get_size(files[i]); ut_a(size != (os_offset_t) -1); /* If InnoDB encountered an error or was killed while extending the data file, the last page could be incomplete. */ rounded_size_pages = static_cast( size >> UNIV_PAGE_SIZE_SHIFT); if (i == srv_n_data_files - 1 && srv_auto_extend_last_data_file) { if (srv_data_file_sizes[i] > rounded_size_pages || (srv_last_file_size_max > 0 && srv_last_file_size_max < rounded_size_pages)) { ib_logf(IB_LOG_LEVEL_ERROR, "auto-extending " "data file %s is " "of a different size " ULINTPF " pages (rounded " "down to MB) than specified " "in the .cnf file: " "initial " ULINTPF " pages, " "max " ULINTPF " (relevant if " "non-zero) pages!", name, rounded_size_pages, srv_data_file_sizes[i], srv_last_file_size_max); return(DB_ERROR); } srv_data_file_sizes[i] = rounded_size_pages; } if (rounded_size_pages != srv_data_file_sizes[i]) { ib_logf(IB_LOG_LEVEL_ERROR, "Data file %s is of a different " "size " ULINTPF " pages (rounded down to MB) " "than specified in the .cnf file " ULINTPF " pages!", name, rounded_size_pages, srv_data_file_sizes[i]); return(DB_ERROR); } skip_size_check: /* This is the earliest location where we can load the double write buffer. */ if (i == 0) { /* XtraBackup never loads corrupted pages from the doublewrite buffer */ buf_dblwr_init_or_load_pages( files[i], srv_data_file_names[i], !IS_XTRABACKUP()); } bool retry = true; check_first_page: check_msg = fil_read_first_page( files[i], one_opened, &flags, &space, flushed_lsn, &crypt_data); if (check_msg) { if (retry) { fsp_open_info fsp; const ulint page_no = 0; retry = false; fsp.id = 0; fsp.filepath = srv_data_file_names[i]; fsp.file = files[i]; if (fil_user_tablespace_restore_page( &fsp, page_no)) { goto check_first_page; } } ib_logf(IB_LOG_LEVEL_ERROR, "%s in data file %s", check_msg, name); return(DB_ERROR); } /* The first file of the system tablespace must have space ID = TRX_SYS_SPACE. The FSP_SPACE_ID field in files greater than ibdata1 are unreliable. */ ut_a(one_opened || space == TRX_SYS_SPACE); /* Check the flags for the first system tablespace file only. */ if (!one_opened && UNIV_PAGE_SIZE != fsp_flags_get_page_size(flags)) { ib_logf(IB_LOG_LEVEL_ERROR, "Data file \"%s\" uses page size " ULINTPF " ," "but the start-up parameter " "is --innodb-page-size=" ULINTPF " .", name, fsp_flags_get_page_size(flags), UNIV_PAGE_SIZE); return(DB_ERROR); } one_opened = TRUE; } else if (!srv_read_only_mode) { /* We created the data file and now write it full of zeros */ one_created = TRUE; if (i > 0) { ib_logf(IB_LOG_LEVEL_INFO, "Data file %s did not" " exist: new to be created", name); } else { ib_logf(IB_LOG_LEVEL_INFO, "The first specified " "data file %s did not exist: " "a new database to be created!", name); *create_new_db = TRUE; } ib_logf(IB_LOG_LEVEL_INFO, "Setting file %s size to " ULINTPF " MB", name, (srv_data_file_sizes[i] >> (20 - UNIV_PAGE_SIZE_SHIFT))); ret = os_file_set_size( name, files[i], (os_offset_t) srv_data_file_sizes[i] << UNIV_PAGE_SIZE_SHIFT /* TODO: enable page_compression on the system tablespace and add , FSP_FLAGS_HAS_PAGE_COMPRESSION(flags)*/); if (!ret) { ib_logf(IB_LOG_LEVEL_ERROR, "Error in creating %s: " "probably out of disk space", name); return(DB_ERROR); } *sum_of_new_sizes += srv_data_file_sizes[i]; } ret = os_file_close(files[i]); ut_a(ret); if (i == 0) { flags = FSP_FLAGS_PAGE_SSIZE(); fil_space_create(name, 0, flags, FIL_TABLESPACE, crypt_data, (*create_new_db) == true); } ut_a(fil_validate()); if (!fil_node_create(name, srv_data_file_sizes[i], 0, srv_data_file_is_raw_partition[i] != 0)) { return(DB_ERROR); } } return(DB_SUCCESS); } /*********************************************************************//** Create undo tablespace. @return DB_SUCCESS or error code */ static dberr_t srv_undo_tablespace_create( /*=======================*/ const char* name, /*!< in: tablespace name */ ulint size) /*!< in: tablespace size in pages */ { pfs_os_file_t fh; ibool ret; dberr_t err = DB_SUCCESS; os_file_create_subdirs_if_needed(name); fh = os_file_create( innodb_file_data_key, name, srv_read_only_mode ? OS_FILE_OPEN : OS_FILE_CREATE, OS_FILE_NORMAL, OS_DATA_FILE, &ret, FALSE); if (srv_read_only_mode && ret) { ib_logf(IB_LOG_LEVEL_INFO, "%s opened in read-only mode", name); } else if (ret == FALSE) { if (os_file_get_last_error(false) != OS_FILE_ALREADY_EXISTS #ifdef UNIV_AIX /* AIX 5.1 after security patch ML7 may have errno set to 0 here, which causes our function to return 100; work around that AIX problem */ && os_file_get_last_error(false) != 100 #endif /* UNIV_AIX */ ) { ib_logf(IB_LOG_LEVEL_ERROR, "Can't create UNDO tablespace %s", name); } else { ib_logf(IB_LOG_LEVEL_ERROR, "Creating system tablespace with" " existing undo tablespaces is not" " supported. Please delete all undo" " tablespaces before creating new" " system tablespace."); } err = DB_ERROR; } else { ut_a(!srv_read_only_mode); /* We created the data file and now write it full of zeros */ ib_logf(IB_LOG_LEVEL_INFO, "Data file %s did not exist: new to be created", name); ib_logf(IB_LOG_LEVEL_INFO, "Setting file %s size to %lu MB", name, size >> (20 - UNIV_PAGE_SIZE_SHIFT)); ret = os_file_set_size(name, fh, size << UNIV_PAGE_SIZE_SHIFT /* TODO: enable page_compression on the system tablespace and add FSP_FLAGS_HAS_PAGE_COMPRESSION(flags) */); if (!ret) { ib_logf(IB_LOG_LEVEL_INFO, "Error in creating %s: probably out of " "disk space", name); err = DB_ERROR; } os_file_close(fh); } return(err); } /*********************************************************************//** Open an undo tablespace. @return DB_SUCCESS or error code */ static dberr_t srv_undo_tablespace_open( /*=====================*/ const char* name, /*!< in: tablespace name */ ulint space) /*!< in: tablespace id */ { pfs_os_file_t fh; dberr_t err = DB_ERROR; ibool ret; ulint flags; if (!srv_file_check_mode(name)) { ib_logf(IB_LOG_LEVEL_ERROR, "UNDO tablespaces must be %s!", srv_read_only_mode ? "writable" : "readable"); return(DB_ERROR); } fh = os_file_create( innodb_file_data_key, name, OS_FILE_OPEN_RETRY | OS_FILE_ON_ERROR_NO_EXIT | OS_FILE_ON_ERROR_SILENT, OS_FILE_NORMAL, OS_DATA_FILE, &ret, FALSE); /* If the file open was successful then load the tablespace. */ if (ret) { os_offset_t size; size = os_file_get_size(fh); ut_a(size != (os_offset_t) -1); /* Load the tablespace into InnoDB's internal data structures. */ const char* check_msg; fil_space_crypt_t* crypt_data = NULL; /* Set the compressed page size to 0 (non-compressed) */ flags = FSP_FLAGS_PAGE_SSIZE(); /* Read first page to find out does the crypt_info exists on undo tablespace. */ check_msg = fil_read_first_page( fh, FALSE, &flags, &space, NULL, &crypt_data, false); ret = os_file_close(fh); ut_a(ret); if (check_msg) { ib_logf(IB_LOG_LEVEL_ERROR, "%s in data file %s", check_msg, name); return (err); } /* We set the biggest space id to the undo tablespace because InnoDB hasn't opened any other tablespace apart from the system tablespace. */ fil_set_max_space_id_if_bigger(space); fil_space_create(name, space, flags, FIL_TABLESPACE, crypt_data, true /* create */); ut_a(fil_validate()); os_offset_t n_pages = size / UNIV_PAGE_SIZE; /* On 64 bit Windows ulint can be 32 bit and os_offset_t is 64 bit. It is OK to cast the n_pages to ulint because the unit has been scaled to pages and they are always 32 bit. */ if (fil_node_create(name, (ulint) n_pages, space, FALSE)) { err = DB_SUCCESS; } } return(err); } /******************************************************************** Opens the configured number of undo tablespaces. @return DB_SUCCESS or error code */ dberr_t srv_undo_tablespaces_init( /*======================*/ ibool create_new_db, /*!< in: TRUE if new db being created */ ibool backup_mode, /*!< in: TRUE disables reading the system tablespace (used in XtraBackup), FALSE is passed on recovery. */ const ulint n_conf_tablespaces, /*!< in: configured undo tablespaces */ ulint* n_opened) /*!< out: number of UNDO tablespaces successfully discovered and opened */ { ulint i; dberr_t err = DB_SUCCESS; ulint prev_space_id = 0; ulint n_undo_tablespaces; ulint undo_tablespace_ids[TRX_SYS_N_RSEGS + 1]; *n_opened = 0; ut_a(n_conf_tablespaces <= TRX_SYS_N_RSEGS); memset(undo_tablespace_ids, 0x0, sizeof(undo_tablespace_ids)); /* Create the undo spaces only if we are creating a new instance. We don't allow creating of new undo tablespaces in an existing instance (yet). This restriction exists because we check in several places for SYSTEM tablespaces to be less than the min of user defined tablespace ids. Once we implement saving the location of the undo tablespaces and their space ids this restriction will/should be lifted. */ for (i = 0; create_new_db && i < n_conf_tablespaces; ++i) { char name[OS_FILE_MAX_PATH]; ulint space_id = i + 1; DBUG_EXECUTE_IF("innodb_undo_upgrade", space_id = i + 3;); ut_snprintf( name, sizeof(name), "%s%cundo%03lu", srv_undo_dir, SRV_PATH_SEPARATOR, space_id); if (i == 0) { srv_undo_space_id_start = space_id; prev_space_id = srv_undo_space_id_start - 1; } undo_tablespace_ids[i] = space_id; err = srv_undo_tablespace_create( name, SRV_UNDO_TABLESPACE_SIZE_IN_PAGES); if (err != DB_SUCCESS) { ib_logf(IB_LOG_LEVEL_ERROR, "Could not create undo tablespace '%s'.", name); return(err); } } /* Get the tablespace ids of all the undo segments excluding the system tablespace (0). If we are creating a new instance then we build the undo_tablespace_ids ourselves since they don't already exist. */ if (!create_new_db && !backup_mode) { n_undo_tablespaces = trx_rseg_get_n_undo_tablespaces( undo_tablespace_ids); if (n_undo_tablespaces != 0) { srv_undo_space_id_start = undo_tablespace_ids[0]; prev_space_id = srv_undo_space_id_start - 1; } } else { n_undo_tablespaces = n_conf_tablespaces; undo_tablespace_ids[n_conf_tablespaces] = ULINT_UNDEFINED; if (backup_mode) { ut_ad(!create_new_db); for (i = 0; i < n_undo_tablespaces; i++) { undo_tablespace_ids[i] = i + srv_undo_space_id_start; } prev_space_id = srv_undo_space_id_start - 1; } } /* Open all the undo tablespaces that are currently in use. If we fail to open any of these it is a fatal error. The tablespace ids should be contiguous. It is a fatal error because they are required for recovery and are referenced by the UNDO logs (a.k.a RBS). */ for (i = 0; i < n_undo_tablespaces; ++i) { char name[OS_FILE_MAX_PATH]; ut_snprintf( name, sizeof(name), "%s%cundo%03lu", srv_undo_dir, SRV_PATH_SEPARATOR, undo_tablespace_ids[i]); /* Should be no gaps in undo tablespace ids. */ ut_a(prev_space_id + 1 == undo_tablespace_ids[i]); /* The system space id should not be in this array. */ ut_a(undo_tablespace_ids[i] != 0); ut_a(undo_tablespace_ids[i] != ULINT_UNDEFINED); err = srv_undo_tablespace_open(name, undo_tablespace_ids[i]); if (err != DB_SUCCESS) { ib_logf(IB_LOG_LEVEL_ERROR, "Unable to open undo tablespace '%s'.", name); return(err); } prev_space_id = undo_tablespace_ids[i]; ++*n_opened; } /* Open any extra unused undo tablespaces. These must be contiguous. We stop at the first failure. These are undo tablespaces that are not in use and therefore not required by recovery. We only check that there are no gaps. */ for (i = prev_space_id + 1; i < TRX_SYS_N_RSEGS; ++i) { char name[OS_FILE_MAX_PATH]; ut_snprintf( name, sizeof(name), "%s%cundo%03lu", srv_undo_dir, SRV_PATH_SEPARATOR, i); /* Undo space ids start from 1. */ err = srv_undo_tablespace_open(name, i); if (err != DB_SUCCESS) { break; } /** Note the first undo tablespace id in case of no active undo tablespace. */ if (n_undo_tablespaces == 0) { srv_undo_space_id_start = i; } ++n_undo_tablespaces; ++*n_opened; } /** Explictly specify the srv_undo_space_id_start as zero when there are no undo tablespaces. */ if (n_undo_tablespaces == 0) { srv_undo_space_id_start = 0; } /* If the user says that there are fewer than what we find we tolerate that discrepancy but not the inverse. Because there could be unused undo tablespaces for future use. */ if (n_conf_tablespaces > n_undo_tablespaces) { ut_print_timestamp(stderr); fprintf(stderr, " InnoDB: Expected to open %lu undo " "tablespaces but was able\n", n_conf_tablespaces); ut_print_timestamp(stderr); fprintf(stderr, " InnoDB: to find only %lu undo " "tablespaces.\n", n_undo_tablespaces); ut_print_timestamp(stderr); fprintf(stderr, " InnoDB: Set the " "innodb_undo_tablespaces parameter to " "the\n"); ut_print_timestamp(stderr); fprintf(stderr, " InnoDB: correct value and retry. Suggested " "value is %lu\n", n_undo_tablespaces); return(err != DB_SUCCESS ? err : DB_ERROR); } else if (n_undo_tablespaces > 0) { ib_logf(IB_LOG_LEVEL_INFO, "Opened %lu undo tablespaces", n_undo_tablespaces); if (n_conf_tablespaces == 0) { ib_logf(IB_LOG_LEVEL_WARN, "Using the system tablespace for all UNDO " "logging because innodb_undo_tablespaces=0"); } } if (create_new_db) { mtr_t mtr; mtr_start(&mtr); /* The undo log tablespace */ for (i = 0; i < n_undo_tablespaces; ++i) { fsp_header_init( undo_tablespace_ids[i], SRV_UNDO_TABLESPACE_SIZE_IN_PAGES, &mtr); } mtr_commit(&mtr); } return(DB_SUCCESS); } /******************************************************************** Wait for the purge thread(s) to start up. */ static void srv_start_wait_for_purge_to_start() /*===============================*/ { /* Wait for the purge coordinator and master thread to startup. */ purge_state_t state = trx_purge_state(); ut_a(state != PURGE_STATE_DISABLED); while (srv_shutdown_state == SRV_SHUTDOWN_NONE && srv_force_recovery < SRV_FORCE_NO_BACKGROUND && state == PURGE_STATE_INIT) { switch (state = trx_purge_state()) { case PURGE_STATE_RUN: case PURGE_STATE_STOP: break; case PURGE_STATE_INIT: ib_logf(IB_LOG_LEVEL_INFO, "Waiting for purge to start"); os_thread_sleep(50000); break; case PURGE_STATE_EXIT: case PURGE_STATE_DISABLED: ut_error; } } } /*********************************************************************//** Initializes the log tracking subsystem and starts its thread. */ static void init_log_online(void) /*=================*/ { if (UNIV_UNLIKELY(srv_force_recovery > 0 || srv_read_only_mode)) { srv_track_changed_pages = FALSE; return; } if (srv_track_changed_pages) { log_online_read_init(); /* Create the thread that follows the redo log to output the changed page bitmap */ srv_redo_log_follow_thread_handle = os_thread_create(&srv_redo_log_follow_thread, NULL, thread_ids + 5 + SRV_MAX_N_IO_THREADS); srv_redo_log_follow_thread_started = true; } } /******************************************************************** Starts InnoDB and creates a new database if database files are not found and the user wants. @return DB_SUCCESS or error code */ UNIV_INTERN dberr_t innobase_start_or_create_for_mysql() { bool create_new_db; lsn_t flushed_lsn; #ifdef UNIV_LOG_ARCHIVE lsn_t min_arch_log_no = LSN_MAX; lsn_t max_arch_log_no = LSN_MAX; #endif /* UNIV_LOG_ARCHIVE */ ulint sum_of_new_sizes; dberr_t err; unsigned i; ulint srv_n_log_files_found = srv_n_log_files; ulint io_limit; mtr_t mtr; ib_bh_t* ib_bh; ulint n_recovered_trx; char logfilename[10000]; char* logfile0 = NULL; size_t dirnamelen; bool sys_datafiles_created = false; /* Check that os_fast_mutexes work as expected */ os_fast_mutex_init(PFS_NOT_INSTRUMENTED, &srv_os_test_mutex); ut_a(0 == os_fast_mutex_trylock(&srv_os_test_mutex)); os_fast_mutex_unlock(&srv_os_test_mutex); os_fast_mutex_lock(&srv_os_test_mutex); os_fast_mutex_unlock(&srv_os_test_mutex); os_fast_mutex_free(&srv_os_test_mutex); if (srv_force_recovery == SRV_FORCE_NO_LOG_REDO) { srv_read_only_mode = 1; } high_level_read_only = srv_read_only_mode || srv_force_recovery > SRV_FORCE_NO_TRX_UNDO; if (srv_read_only_mode) { ib_logf(IB_LOG_LEVEL_INFO, "Started in read only mode"); } #ifdef HAVE_DARWIN_THREADS # ifdef F_FULLFSYNC /* This executable has been compiled on Mac OS X 10.3 or later. Assume that F_FULLFSYNC is available at run-time. */ srv_have_fullfsync = TRUE; # else /* F_FULLFSYNC */ /* This executable has been compiled on Mac OS X 10.2 or earlier. Determine if the executable is running on Mac OS X 10.3 or later. */ struct utsname utsname; if (uname(&utsname)) { ut_print_timestamp(stderr); fputs(" InnoDB: cannot determine Mac OS X version!\n", stderr); } else { srv_have_fullfsync = strcmp(utsname.release, "7.") >= 0; } if (!srv_have_fullfsync) { ut_print_timestamp(stderr); fputs(" InnoDB: On Mac OS X, fsync() may be " "broken on internal drives,\n", stderr); ut_print_timestamp(stderr); fputs(" InnoDB: making transactions unsafe!\n", stderr); } # endif /* F_FULLFSYNC */ #endif /* HAVE_DARWIN_THREADS */ ib_logf(IB_LOG_LEVEL_INFO, "Using %s to ref count buffer pool pages", #ifdef PAGE_ATOMIC_REF_COUNT "atomics" #else "mutexes" #endif /* PAGE_ATOMIC_REF_COUNT */ ); compile_time_assert(sizeof(ulint) == sizeof(void*)); /* If stacktrace is used we set up signal handler for SIGUSR2 signal here. If signal handler set fails we report that and disable stacktrace feature. */ if (srv_use_stacktrace) { #if defined (__linux__) && HAVE_BACKTRACE && HAVE_BACKTRACE_SYMBOLS struct sigaction sigact; sigact.sa_sigaction = os_stacktrace_print; sigact.sa_flags = SA_RESTART | SA_SIGINFO; if (sigaction(SIGUSR2, &sigact, (struct sigaction *)NULL) != 0) { fprintf(stderr, " InnoDB:error setting signal handler for %d (%s)\n", SIGUSR2, strsignal(SIGUSR2)); srv_use_stacktrace = FALSE; } #endif /* defined (__linux__) && HAVE_BACKTRACE && HAVE_BACKTRACE_SYMBOLS */ } #ifdef UNIV_DEBUG ib_logf(IB_LOG_LEVEL_INFO, " InnoDB: !!!!!!!! UNIV_DEBUG switched on !!!!!!!!!"); #endif #ifdef UNIV_IBUF_DEBUG ib_logf(IB_LOG_LEVEL_INFO, " InnoDB: !!!!!!!! UNIV_IBUF_DEBUG switched on !!!!!!!!!"); # ifdef UNIV_IBUF_COUNT_DEBUG ib_logf(IB_LOG_LEVEL_INFO, " InnoDB: !!!!!!!! UNIV_IBUF_COUNT_DEBUG switched on " "!!!!!!!!!"); ib_logf(IB_LOG_LEVEL_INFO, " InnoDB: Crash recovery will fail with UNIV_IBUF_COUNT_DEBUG"); # endif #endif #ifdef UNIV_BLOB_DEBUG ib_logf(IB_LOG_LEVEL_INFO, "InnoDB: !!!!!!!! UNIV_BLOB_DEBUG switched on !!!!!!!!!\n" "InnoDB: Server restart may fail with UNIV_BLOB_DEBUG"); #endif /* UNIV_BLOB_DEBUG */ #ifdef UNIV_SYNC_DEBUG ib_logf(IB_LOG_LEVEL_INFO, " InnoDB: !!!!!!!! UNIV_SYNC_DEBUG switched on !!!!!!!!!"); #endif #ifdef UNIV_SEARCH_DEBUG ib_logf(IB_LOG_LEVEL_INFO, " InnoDB: !!!!!!!! UNIV_SEARCH_DEBUG switched on !!!!!!!!!"); #endif #ifdef UNIV_LOG_LSN_DEBUG ib_logf(IB_LOG_LEVEL_INFO, " InnoDB: !!!!!!!! UNIV_LOG_LSN_DEBUG switched on !!!!!!!!!"); #endif /* UNIV_LOG_LSN_DEBUG */ #ifdef UNIV_MEM_DEBUG ib_logf(IB_LOG_LEVEL_INFO, " InnoDB: !!!!!!!! UNIV_MEM_DEBUG switched on !!!!!!!!!"); #endif if (srv_use_sys_malloc) { ib_logf(IB_LOG_LEVEL_INFO, "The InnoDB memory heap is disabled"); } #if defined(COMPILER_HINTS_ENABLED) ib_logf(IB_LOG_LEVEL_INFO, " InnoDB: Compiler hints enabled."); #endif /* defined(COMPILER_HINTS_ENABLED) */ ib_logf(IB_LOG_LEVEL_INFO, "" IB_ATOMICS_STARTUP_MSG ""); ib_logf(IB_LOG_LEVEL_INFO, "" IB_MEMORY_BARRIER_STARTUP_MSG ""); #ifndef HAVE_MEMORY_BARRIER #if defined __i386__ || defined __x86_64__ || defined _M_IX86 || defined _M_X64 || defined __WIN__ #else ib_logf(IB_LOG_LEVEL_WARN, "MySQL was built without a memory barrier capability on this" " architecture, which might allow a mutex/rw_lock violation" " under high thread concurrency. This may cause a hang."); #endif /* IA32 or AMD64 */ #endif /* HAVE_MEMORY_BARRIER */ ib_logf(IB_LOG_LEVEL_INFO, "Compressed tables use zlib " ZLIB_VERSION #ifdef UNIV_ZIP_DEBUG " with validation" #endif /* UNIV_ZIP_DEBUG */ ); #ifdef UNIV_ZIP_COPY ib_logf(IB_LOG_LEVEL_INFO, "and extra copying"); #endif /* UNIV_ZIP_COPY */ /* Since InnoDB does not currently clean up all its internal data structures in MySQL Embedded Server Library server_end(), we print an error message if someone tries to start up InnoDB a second time during the process lifetime. */ if (srv_start_has_been_called) { ut_print_timestamp(stderr); fprintf(stderr, " InnoDB: Error: startup called second time " "during the process\n"); ut_print_timestamp(stderr); fprintf(stderr, " InnoDB: lifetime. In the MySQL Embedded " "Server Library you\n"); ut_print_timestamp(stderr); fprintf(stderr, " InnoDB: cannot call server_init() more " "than once during the\n"); ut_print_timestamp(stderr); fprintf(stderr, " InnoDB: process lifetime.\n"); } srv_start_has_been_called = TRUE; #ifdef UNIV_DEBUG log_do_write = TRUE; #endif /* UNIV_DEBUG */ /* yydebug = TRUE; */ srv_is_being_started = TRUE; srv_startup_is_before_trx_rollback_phase = TRUE; #ifdef __WIN__ srv_use_native_aio = TRUE; #elif defined(LINUX_NATIVE_AIO) if (srv_use_native_aio) { ib_logf(IB_LOG_LEVEL_INFO, "Using Linux native AIO"); } #else /* Currently native AIO is supported only on windows and linux and that also when the support is compiled in. In all other cases, we ignore the setting of innodb_use_native_aio. */ srv_use_native_aio = FALSE; #endif /* __WIN__ */ if (srv_file_flush_method_str == NULL) { /* These are the default options */ srv_unix_file_flush_method = SRV_UNIX_FSYNC; srv_win_file_flush_method = SRV_WIN_IO_UNBUFFERED; } else if (0 == ut_strcmp(srv_file_flush_method_str, "fsync")) { srv_unix_file_flush_method = SRV_UNIX_FSYNC; } else if (0 == ut_strcmp(srv_file_flush_method_str, "O_DSYNC")) { srv_unix_file_flush_method = SRV_UNIX_O_DSYNC; } else if (0 == ut_strcmp(srv_file_flush_method_str, "O_DIRECT")) { srv_unix_file_flush_method = SRV_UNIX_O_DIRECT; } else if (0 == ut_strcmp(srv_file_flush_method_str, "ALL_O_DIRECT")) { srv_unix_file_flush_method = SRV_UNIX_ALL_O_DIRECT; } else if (0 == ut_strcmp(srv_file_flush_method_str, "O_DIRECT_NO_FSYNC")) { srv_unix_file_flush_method = SRV_UNIX_O_DIRECT_NO_FSYNC; } else if (0 == ut_strcmp(srv_file_flush_method_str, "littlesync")) { srv_unix_file_flush_method = SRV_UNIX_LITTLESYNC; } else if (0 == ut_strcmp(srv_file_flush_method_str, "nosync")) { srv_unix_file_flush_method = SRV_UNIX_NOSYNC; #ifdef _WIN32 } else if (0 == ut_strcmp(srv_file_flush_method_str, "normal")) { srv_win_file_flush_method = SRV_WIN_IO_NORMAL; srv_use_native_aio = FALSE; } else if (0 == ut_strcmp(srv_file_flush_method_str, "unbuffered")) { srv_win_file_flush_method = SRV_WIN_IO_UNBUFFERED; srv_use_native_aio = FALSE; } else if (0 == ut_strcmp(srv_file_flush_method_str, "async_unbuffered")) { srv_win_file_flush_method = SRV_WIN_IO_UNBUFFERED; srv_use_native_aio = TRUE; #endif /* __WIN__ */ } else { ib_logf(IB_LOG_LEVEL_ERROR, "Unrecognized value %s for innodb_flush_method", srv_file_flush_method_str); return(DB_ERROR); } /* Note that the call srv_boot() also changes the values of some variables to the units used by InnoDB internally */ /* Set the maximum number of threads which can wait for a semaphore inside InnoDB: this is the 'sync wait array' size, as well as the maximum number of threads that can wait in the 'srv_conc array' for their time to enter InnoDB. */ #define BUF_POOL_SIZE_THRESHOLD (1024 * 1024 * 1024) srv_max_n_threads = 1 /* io_ibuf_thread */ + 1 /* io_log_thread */ + 1 /* lock_wait_timeout_thread */ + 1 /* srv_error_monitor_thread */ + 1 /* srv_monitor_thread */ + 1 /* srv_master_thread */ + 1 /* srv_redo_log_follow_thread */ + 1 /* srv_purge_coordinator_thread */ + 1 /* buf_dump_thread */ + 1 /* dict_stats_thread */ + 1 /* fts_optimize_thread */ + 1 /* recv_writer_thread */ + 1 /* buf_flush_page_cleaner_thread */ + 1 /* trx_rollback_or_clean_all_recovered */ + 128 /* added as margin, for use of InnoDB Memcached etc. */ + max_connections + srv_n_read_io_threads + srv_n_write_io_threads + srv_n_purge_threads /* FTS Parallel Sort */ + fts_sort_pll_degree * FTS_NUM_AUX_INDEX * max_connections; if (srv_buf_pool_size < BUF_POOL_SIZE_THRESHOLD) { /* If buffer pool is less than 1 GB, use only one buffer pool instance */ srv_buf_pool_instances = 1; } srv_boot(); ib_logf(IB_LOG_LEVEL_INFO, ut_crc32_implementation); if (!srv_read_only_mode) { mutex_create(srv_monitor_file_mutex_key, &srv_monitor_file_mutex, SYNC_NO_ORDER_CHECK); if (srv_innodb_status) { srv_monitor_file_name = static_cast( mem_alloc( strlen(fil_path_to_mysql_datadir) + 20 + sizeof "/innodb_status.")); sprintf(srv_monitor_file_name, "%s/innodb_status.%lu", fil_path_to_mysql_datadir, os_proc_get_number()); srv_monitor_file = fopen(srv_monitor_file_name, "w+"); if (!srv_monitor_file) { ib_logf(IB_LOG_LEVEL_ERROR, "Unable to create %s: %s", srv_monitor_file_name, strerror(errno)); return(DB_ERROR); } } else { srv_monitor_file_name = NULL; srv_monitor_file = os_file_create_tmpfile(NULL); if (!srv_monitor_file) { return(DB_ERROR); } } mutex_create(srv_dict_tmpfile_mutex_key, &srv_dict_tmpfile_mutex, SYNC_DICT_OPERATION); srv_dict_tmpfile = os_file_create_tmpfile(NULL); if (!srv_dict_tmpfile) { return(DB_ERROR); } mutex_create(srv_misc_tmpfile_mutex_key, &srv_misc_tmpfile_mutex, SYNC_ANY_LATCH); srv_misc_tmpfile = os_file_create_tmpfile(NULL); if (!srv_misc_tmpfile) { return(DB_ERROR); } } /* If user has set the value of innodb_file_io_threads then we'll emit a message telling the user that this parameter is now deprecated. */ if (srv_n_file_io_threads != 4) { ib_logf(IB_LOG_LEVEL_WARN, "innodb_file_io_threads is deprecated. Please use " "innodb_read_io_threads and innodb_write_io_threads " "instead"); } /* Now overwrite the value on srv_n_file_io_threads */ srv_n_file_io_threads = srv_n_read_io_threads; if (!srv_read_only_mode) { /* Add the log and ibuf IO threads. */ srv_n_file_io_threads += 2; srv_n_file_io_threads += srv_n_write_io_threads; } else { ib_logf(IB_LOG_LEVEL_INFO, "Disabling background IO write threads."); srv_n_write_io_threads = 0; } ut_a(srv_n_file_io_threads <= SRV_MAX_N_IO_THREADS); io_limit = 8 * SRV_N_PENDING_IOS_PER_THREAD; /* On Windows when using native aio the number of aio requests that a thread can handle at a given time is limited to 32 i.e.: SRV_N_PENDING_IOS_PER_THREAD */ # ifdef __WIN__ if (srv_use_native_aio) { io_limit = SRV_N_PENDING_IOS_PER_THREAD; } # endif /* __WIN__ */ if (!os_aio_init(io_limit, srv_n_read_io_threads, srv_n_write_io_threads, SRV_MAX_N_PENDING_SYNC_IOS)) { ib_logf(IB_LOG_LEVEL_ERROR, "Fatal : Cannot initialize AIO sub-system"); #if defined(LINUX_NATIVE_AIO) ib_logf(IB_LOG_LEVEL_INFO, "You can try increasing system fs.aio-max-nr to 1048576 " "or larger or setting innodb_use_native_aio = 0 in my.cnf"); #endif return(DB_ERROR); } fil_init(srv_file_per_table ? 50000 : 5000, srv_max_n_open_files); double size; char unit; if (srv_buf_pool_size >= 1024 * 1024 * 1024) { size = ((double) srv_buf_pool_size) / (1024 * 1024 * 1024); unit = 'G'; } else { size = ((double) srv_buf_pool_size) / (1024 * 1024); unit = 'M'; } /* Print time to initialize the buffer pool */ ib_logf(IB_LOG_LEVEL_INFO, "Initializing buffer pool, size = %.1f%c", size, unit); err = buf_pool_init(srv_buf_pool_size, static_cast(srv_numa_interleave), srv_buf_pool_instances); if (err != DB_SUCCESS) { ib_logf(IB_LOG_LEVEL_ERROR, "Cannot allocate memory for the buffer pool"); return(DB_ERROR); } ib_logf(IB_LOG_LEVEL_INFO, "Completed initialization of buffer pool"); #ifdef UNIV_DEBUG /* We have observed deadlocks with a 5MB buffer pool but the actual lower limit could very well be a little higher. */ if (srv_buf_pool_size <= 5 * 1024 * 1024) { ib_logf(IB_LOG_LEVEL_INFO, "Small buffer pool size (%luM), the flst_validate() " "debug function can cause a deadlock if the " "buffer pool fills up.", srv_buf_pool_size / 1024 / 1024); } #endif /* UNIV_DEBUG */ fsp_init(); log_init(); log_online_init(); lock_sys_create(srv_lock_table_size); /* Create i/o-handler threads: */ for (i = 0; i < srv_n_file_io_threads; ++i) { n[i] = i; thread_handles[i] = os_thread_create(io_handler_thread, n + i, thread_ids + i); thread_started[i] = true; } if (srv_n_log_files * srv_log_file_size * UNIV_PAGE_SIZE >= 512ULL * 1024ULL * 1024ULL * 1024ULL) { /* log_block_convert_lsn_to_no() limits the returned block number to 1G and given that OS_FILE_LOG_BLOCK_SIZE is 512 bytes, then we have a limit of 512 GB. If that limit is to be raised, then log_block_convert_lsn_to_no() must be modified. */ ib_logf(IB_LOG_LEVEL_ERROR, "Combined size of log files must be < 512 GB"); return(DB_ERROR); } if (srv_n_log_files * srv_log_file_size >= ULINT_MAX) { /* fil_io() takes ulint as an argument and we are passing (next_offset / UNIV_PAGE_SIZE) to it in log_group_write_buf(). So (next_offset / UNIV_PAGE_SIZE) must be less than ULINT_MAX. So next_offset must be < ULINT_MAX * UNIV_PAGE_SIZE. This means that we are limited to ULINT_MAX * UNIV_PAGE_SIZE which is 64 TB on 32 bit systems. */ fprintf(stderr, " InnoDB: Error: combined size of log files" " must be < %lu GB\n", ULINT_MAX / 1073741824 * UNIV_PAGE_SIZE); return(DB_ERROR); } sum_of_new_sizes = 0; for (i = 0; i < srv_n_data_files; i++) { #ifndef __WIN__ if (sizeof(off_t) < 5 && srv_data_file_sizes[i] >= (ulint) (1 << (32 - UNIV_PAGE_SIZE_SHIFT))) { ut_print_timestamp(stderr); fprintf(stderr, " InnoDB: Error: file size must be < 4 GB" " with this MySQL binary\n"); ut_print_timestamp(stderr); fprintf(stderr, " InnoDB: and operating system combination," " in some OS's < 2 GB\n"); return(DB_ERROR); } #endif sum_of_new_sizes += srv_data_file_sizes[i]; } if (!srv_auto_extend_last_data_file && sum_of_new_sizes < 640) { ib_logf(IB_LOG_LEVEL_ERROR, "Combined size in innodb_data_file_path" " must be at least %u MiB", 640 >> (20 - UNIV_PAGE_SIZE_SHIFT)); return(DB_ERROR); } recv_sys_create(); recv_sys_init(buf_pool_get_curr_size()); err = open_or_create_data_files(&create_new_db, #ifdef UNIV_LOG_ARCHIVE &min_arch_log_no, &max_arch_log_no, #endif /* UNIV_LOG_ARCHIVE */ &flushed_lsn, &sum_of_new_sizes); if (err == DB_FAIL) { ib_logf(IB_LOG_LEVEL_ERROR, "The system tablespace must be writable!"); return(DB_ERROR); } else if (err != DB_SUCCESS) { ib_logf(IB_LOG_LEVEL_ERROR, "Could not open or create the system tablespace. If " "you tried to add new data files to the system " "tablespace, and it failed here, you should now " "edit innodb_data_file_path in my.cnf back to what " "it was, and remove the new ibdata files InnoDB " "created in this failed attempt. InnoDB only wrote " "those files full of zeros, but did not yet use " "them in any way. But be careful: do not remove " "old data files which contain your precious data!"); return(err); } #ifdef UNIV_LOG_ARCHIVE srv_normalize_path_for_win(srv_arch_dir); #endif /* UNIV_LOG_ARCHIVE */ dirnamelen = strlen(srv_log_group_home_dir); ut_a(dirnamelen < (sizeof logfilename) - 10 - sizeof "ib_logfile"); memcpy(logfilename, srv_log_group_home_dir, dirnamelen); /* Add a path separator if needed. */ if (dirnamelen && logfilename[dirnamelen - 1] != SRV_PATH_SEPARATOR) { logfilename[dirnamelen++] = SRV_PATH_SEPARATOR; } srv_log_file_size_requested = srv_log_file_size; if (create_new_db) { bool success = buf_flush_list(ULINT_MAX, LSN_MAX, NULL); ut_a(success); flushed_lsn = log_get_lsn(); buf_flush_wait_batch_end(NULL, BUF_FLUSH_LIST); err = create_log_files(create_new_db, logfilename, dirnamelen, flushed_lsn, logfile0); if (err != DB_SUCCESS) { return(err); } } else { ut_d(fil_space_get(0)->recv_size = srv_sys_space_size_debug); for (i = 0; i < SRV_N_LOG_FILES_MAX; i++) { os_offset_t size; os_file_stat_t stat_info; sprintf(logfilename + dirnamelen, "ib_logfile%u", i); err = os_file_get_status( logfilename, &stat_info, false); if (err == DB_NOT_FOUND) { if (i == 0) { if (flushed_lsn < (lsn_t) 1000) { ib_logf(IB_LOG_LEVEL_ERROR, "Cannot create" " log files because" " data files are" " corrupt or the" " database was not" " shut down cleanly" " after creating" " the data files."); return(DB_ERROR); } err = create_log_files( create_new_db, logfilename, dirnamelen, flushed_lsn, logfile0); if (err == DB_SUCCESS) { err = create_log_files_rename( logfilename, dirnamelen, flushed_lsn, logfile0); } if (err != DB_SUCCESS) { return(err); } /* Suppress the message about crash recovery. */ flushed_lsn = log_get_lsn(); goto files_checked; } else if (i < 2 && !IS_XTRABACKUP()) { /* must have at least 2 log files */ ib_logf(IB_LOG_LEVEL_ERROR, "Only one log file found."); return(err); } /* opened all files */ break; } if (stat_info.type != OS_FILE_TYPE_FILE) { break; } if (!srv_file_check_mode(logfilename)) { return(DB_ERROR); } err = open_log_file(&files[i], logfilename, &size); if (err != DB_SUCCESS) { return(err); } ut_a(size != (os_offset_t) -1); if (size & ((1 << UNIV_PAGE_SIZE_SHIFT) - 1)) { ib_logf(IB_LOG_LEVEL_ERROR, "Log file %s size " UINT64PF " is not a multiple of" " innodb_page_size", logfilename, size); return(DB_ERROR); } size >>= UNIV_PAGE_SIZE_SHIFT; if (i == 0) { srv_log_file_size = size; } else if (size != srv_log_file_size) { ib_logf(IB_LOG_LEVEL_ERROR, "Log file %s is" " of different size " UINT64PF " bytes" " than other log" " files " UINT64PF " bytes!", logfilename, size << UNIV_PAGE_SIZE_SHIFT, (os_offset_t) srv_log_file_size << UNIV_PAGE_SIZE_SHIFT); return(DB_ERROR); } } srv_n_log_files_found = i; /* Create the in-memory file space objects. */ sprintf(logfilename + dirnamelen, "ib_logfile%u", 0); fil_space_create(logfilename, SRV_LOG_SPACE_FIRST_ID, 0, FIL_LOG, NULL /* no encryption yet */, true /* create */); ut_a(fil_validate()); /* srv_log_file_size is measured in pages; if page size is 16KB, then we have a limit of 64TB on 32 bit systems */ ut_a(srv_log_file_size <= ULINT_MAX); for (unsigned j = 0; j < i; j++) { sprintf(logfilename + dirnamelen, "ib_logfile%u", j); if (!fil_node_create(logfilename, (ulint) srv_log_file_size, SRV_LOG_SPACE_FIRST_ID, FALSE)) { return(DB_ERROR); } } #ifdef UNIV_LOG_ARCHIVE /* Create the file space object for archived logs. Under MySQL, no archiving ever done. */ fil_space_create("arch_log_space", SRV_LOG_SPACE_FIRST_ID + 1, 0, FIL_LOG, NULL /* no encryption yet */, true /* create */); #endif /* UNIV_LOG_ARCHIVE */ log_group_init(0, i, srv_log_file_size * UNIV_PAGE_SIZE, SRV_LOG_SPACE_FIRST_ID, SRV_LOG_SPACE_FIRST_ID + 1); } files_checked: /* Open all log files and data files in the system tablespace: we keep them open until database shutdown */ fil_open_log_and_system_tablespace_files(); err = srv_undo_tablespaces_init( create_new_db, FALSE, srv_undo_tablespaces, &srv_undo_tablespaces_open); /* If the force recovery is set very high then we carry on regardless of all errors. Basically this is fingers crossed mode. */ if (err != DB_SUCCESS && srv_force_recovery < SRV_FORCE_NO_UNDO_LOG_SCAN) { return(err); } /* Initialize objects used by dict stats gathering thread, which can also be used by recovery if it tries to drop some table */ if (!srv_read_only_mode) { dict_stats_thread_init(); } trx_sys_file_format_init(); trx_sys_create(); if (create_new_db) { ut_a(!srv_read_only_mode); init_log_online(); mtr_start(&mtr); fsp_header_init(0, sum_of_new_sizes, &mtr); compile_time_assert(TRX_SYS_SPACE == 0); compile_time_assert(IBUF_SPACE_ID == 0); ulint ibuf_root = btr_create( DICT_CLUSTERED | DICT_UNIVERSAL | DICT_IBUF, 0, 0, DICT_IBUF_ID_MIN, dict_ind_redundant, &mtr); mtr_commit(&mtr); if (ibuf_root == FIL_NULL) { return(srv_init_abort(true, __FILE__, __LINE__, DB_ERROR)); } ut_ad(ibuf_root == IBUF_TREE_ROOT_PAGE_NO); /* To maintain backward compatibility we create only the first rollback segment before the double write buffer. All the remaining rollback segments will be created later, after the double write buffer has been created. */ trx_sys_create_sys_pages(); ib_bh = trx_sys_init_at_db_start(); n_recovered_trx = UT_LIST_GET_LEN(trx_sys->rw_trx_list); /* The purge system needs to create the purge view and therefore requires that the trx_sys is inited. */ trx_purge_sys_create(srv_n_purge_threads, ib_bh); err = dict_create(); if (err != DB_SUCCESS) { return(err); } srv_startup_is_before_trx_rollback_phase = FALSE; bool success = buf_flush_list(ULINT_MAX, LSN_MAX, NULL); ut_a(success); flushed_lsn = log_get_lsn(); buf_flush_wait_batch_end(NULL, BUF_FLUSH_LIST); /* Stamp the LSN to the data files. */ err = fil_write_flushed_lsn(flushed_lsn); if (err != DB_SUCCESS) { return(err); } err = create_log_files_rename(logfilename, dirnamelen, flushed_lsn, logfile0); if (err != DB_SUCCESS) { return(err); } } else { /* Check if we support the max format that is stamped on the system tablespace. Note: We are NOT allowed to make any modifications to the TRX_SYS_PAGE_NO page before recovery because this page also contains the max_trx_id etc. important system variables that are required for recovery. We need to ensure that we return the system to a state where normal recovery is guaranteed to work. We do this by invalidating the buffer cache, this will force the reread of the page and restoration to its last known consistent state, this is REQUIRED for the recovery process to work. */ err = trx_sys_file_format_max_check( srv_max_file_format_at_startup); if (err != DB_SUCCESS) { return(err); } /* Invalidate the buffer pool to ensure that we reread the page that we read above, during recovery. Note that this is not as heavy weight as it seems. At this point there will be only ONE page in the buf_LRU and there must be no page in the buf_flush list. */ buf_pool_invalidate(); /* Start monitor thread early enough so that e.g. crash recovery failing to find free pages in the buffer pool is diagnosed. */ if (!srv_read_only_mode) { /* Create the thread which prints InnoDB monitor info */ srv_monitor_active = true; thread_handles[4 + SRV_MAX_N_IO_THREADS] = os_thread_create( srv_monitor_thread, NULL, thread_ids + 4 + SRV_MAX_N_IO_THREADS); thread_started[4 + SRV_MAX_N_IO_THREADS] = true; } /* We always try to do a recovery, even if the database had been shut down normally: this is the normal startup path */ err = recv_recovery_from_checkpoint_start( LOG_CHECKPOINT, LSN_MAX, flushed_lsn); if (err != DB_SUCCESS) { return(err); } init_log_online(); /* Initialize the change buffer. */ err = dict_boot(); if (err != DB_SUCCESS) { return(err); } /* This must precede recv_apply_hashed_log_recs(true). */ ib_bh = trx_sys_init_at_db_start(); if (srv_force_recovery < SRV_FORCE_NO_LOG_REDO) { /* Apply the hashed log records to the respective file pages, for the last batch of recv_group_scan_log_recs(). */ recv_apply_hashed_log_recs(true); if (recv_sys->found_corrupt_log) { return (DB_CORRUPTION); } DBUG_PRINT("ib_log", ("apply completed")); } if (!srv_read_only_mode) { const ulint flags = FSP_FLAGS_PAGE_SSIZE(); for (ulint id = 0; id <= srv_undo_tablespaces; id++) { if (fil_space_get(id)) { fsp_flags_try_adjust(id, flags); } } if (sum_of_new_sizes > 0) { /* New data file(s) were added */ mtr_start(&mtr); fsp_header_inc_size(0, sum_of_new_sizes, &mtr); mtr_commit(&mtr); /* Immediately write the log record about increased tablespace size to disk, so that it is durable even if mysqld would crash quickly */ log_buffer_flush_to_disk(); } } const ulint tablespace_size_in_header = fsp_header_get_tablespace_size(); #ifdef UNIV_DEBUG /* buf_debug_prints = TRUE; */ #endif /* UNIV_DEBUG */ ulint sum_of_data_file_sizes = 0; for (ulint d = 0; d < srv_n_data_files; d++) { sum_of_data_file_sizes += srv_data_file_sizes[d]; } /* Compare the system tablespace file size to what is stored in FSP_SIZE. In open_or_create_data_files() we already checked that the file sizes match the innodb_data_file_path specification. */ if (srv_read_only_mode || sum_of_data_file_sizes == tablespace_size_in_header) { /* Do not complain about the size. */ } else if (!srv_auto_extend_last_data_file || sum_of_data_file_sizes < tablespace_size_in_header) { ib_logf(IB_LOG_LEVEL_ERROR, "Tablespace size stored in header is " ULINTPF " pages, but the sum of data file sizes is " ULINTPF " pages", tablespace_size_in_header, sum_of_data_file_sizes); if (srv_force_recovery == 0 && sum_of_data_file_sizes < tablespace_size_in_header) { ib_logf(IB_LOG_LEVEL_ERROR, "Cannot start InnoDB. The tail of" " the system tablespace is" " missing. Have you edited" " innodb_data_file_path in my.cnf" " in an inappropriate way, removing" " data files from there?" " You can set innodb_force_recovery=1" " in my.cnf to force" " a startup if you are trying to" " recover a badly corrupt database."); return(DB_ERROR); } } n_recovered_trx = UT_LIST_GET_LEN(trx_sys->rw_trx_list); /* The purge system needs to create the purge view and therefore requires that the trx_sys is inited. */ trx_purge_sys_create(srv_n_purge_threads, ib_bh); /* recv_recovery_from_checkpoint_finish needs trx lists which are initialized in trx_sys_init_at_db_start(). */ recv_recovery_from_checkpoint_finish(); if (srv_apply_log_only) { ut_ad(IS_XTRABACKUP()); goto skip_processes; } if (srv_force_recovery < SRV_FORCE_NO_IBUF_MERGE) { /* The following call is necessary for the insert buffer to work with multiple tablespaces. We must know the mapping between space id's and .ibd file names. In a crash recovery, we check that the info in data dictionary is consistent with what we already know about space id's from the call of fil_load_single_table_tablespaces(). In a normal startup, we create the space objects for every table in the InnoDB data dictionary that has an .ibd file. We also determine the maximum tablespace id used. */ dict_check_t dict_check; if (recv_needed_recovery) { dict_check = DICT_CHECK_ALL_LOADED; } else if (n_recovered_trx) { dict_check = DICT_CHECK_SOME_LOADED; } else { dict_check = DICT_CHECK_NONE_LOADED; } /* Create the SYS_TABLESPACES and SYS_DATAFILES system table */ err = dict_create_or_check_sys_tablespace(); if (err != DB_SUCCESS) { return(err); } sys_datafiles_created = true; /* This function assumes that SYS_DATAFILES exists */ dict_check_tablespaces_and_store_max_id(dict_check); } if (IS_XTRABACKUP() && !srv_backup_mode && srv_read_only_mode && srv_log_file_size_requested != srv_log_file_size) { ib_logf(IB_LOG_LEVEL_WARN, "Log files size mismatch, ignored in readonly mode"); srv_log_file_size_requested = srv_log_file_size; } if (!srv_force_recovery && !recv_sys->found_corrupt_log && (srv_log_file_size_requested != srv_log_file_size || srv_n_log_files_found != srv_n_log_files)) { /* Prepare to replace the redo log files. */ if (srv_read_only_mode) { ib_logf(IB_LOG_LEVEL_ERROR, "Cannot resize log files " "in read-only mode."); return(DB_READ_ONLY); } /* Clean the buffer pool. */ bool success = buf_flush_list( ULINT_MAX, LSN_MAX, NULL); ut_a(success); DBUG_EXECUTE_IF("innodb_log_abort_1", return(DB_ERROR);); flushed_lsn = log_get_lsn(); ib_logf(IB_LOG_LEVEL_WARN, "Resizing redo log from %u*%u to %u*%u pages" ", LSN=" LSN_PF, (unsigned) i, (unsigned) srv_log_file_size, (unsigned) srv_n_log_files, (unsigned) srv_log_file_size_requested, flushed_lsn); buf_flush_wait_batch_end(NULL, BUF_FLUSH_LIST); /* Flush the old log files. */ log_buffer_flush_to_disk(); /* If innodb_flush_method=O_DSYNC, we need to explicitly flush the log buffers. */ fil_flush(SRV_LOG_SPACE_FIRST_ID); ut_ad(flushed_lsn == log_get_lsn()); /* Prohibit redo log writes from any other threads until creating a log checkpoint at the end of create_log_files(). */ ut_d(recv_no_log_write = TRUE); ut_ad(!buf_pool_check_no_pending_io()); DBUG_EXECUTE_IF("innodb_log_abort_3", return(DB_ERROR);); /* Stamp the LSN to the data files. */ err = fil_write_flushed_lsn(flushed_lsn); DBUG_EXECUTE_IF("innodb_log_abort_4", err = DB_ERROR;); if (err != DB_SUCCESS) { return(err); } /* Close and free the redo log files, so that we can replace them. */ fil_close_log_files(true); DBUG_EXECUTE_IF("innodb_log_abort_5", return(DB_ERROR);); /* Free the old log file space. */ log_group_close_all(); ib_logf(IB_LOG_LEVEL_WARN, "Starting to delete and rewrite log files."); srv_log_file_size = srv_log_file_size_requested; err = create_log_files(create_new_db, logfilename, dirnamelen, flushed_lsn, logfile0); if (err != DB_SUCCESS) { return(err); } err = create_log_files_rename(logfilename, dirnamelen, log_get_lsn(), logfile0); if (err != DB_SUCCESS) { return(err); } } recv_recovery_rollback_active(); srv_startup_is_before_trx_rollback_phase = FALSE; /* It is possible that file_format tag has never been set. In this case we initialize it to minimum value. Important to note that we can do it ONLY after we have finished the recovery process so that the image of TRX_SYS_PAGE_NO is not stale. */ trx_sys_file_format_tag_init(); } ut_ad(err == DB_SUCCESS); ut_a(sum_of_new_sizes != ULINT_UNDEFINED); #ifdef UNIV_LOG_ARCHIVE if (!srv_read_only_mode) { if (!srv_log_archive_on) { ut_a(DB_SUCCESS == log_archive_noarchivelog()); } else { bool start_archive; mutex_enter(&(log_sys->mutex)); start_archive = false; if (log_sys->archiving_state == LOG_ARCH_OFF) { start_archive = true; } mutex_exit(&(log_sys->mutex)); if (start_archive) { ut_a(DB_SUCCESS == log_archive_archivelog()); } } } #endif /* UNIV_LOG_ARCHIVE */ /* fprintf(stderr, "Max allowed record size %lu\n", page_get_free_space_of_empty() / 2); */ if (!buf_dblwr_create()) { return(srv_init_abort(create_new_db, __FILE__, __LINE__, DB_ERROR)); } /* Here the double write buffer has already been created and so any new rollback segments will be allocated after the double write buffer. The default segment should already exist. We create the new segments only if it's a new database or the database was shutdown cleanly. */ /* Note: When creating the extra rollback segments during an upgrade we violate the latching order, even if the change buffer is empty. We make an exception in sync0sync.cc and check srv_is_being_started for that violation. It cannot create a deadlock because we are still running in single threaded mode essentially. Only the IO threads should be running at this stage. */ ut_a(srv_undo_logs > 0); ut_a(srv_undo_logs <= TRX_SYS_N_RSEGS); /* The number of rsegs that exist in InnoDB is given by status variable srv_available_undo_logs. The number of rsegs to use can be set using the dynamic global variable srv_undo_logs. */ srv_available_undo_logs = trx_sys_create_rsegs( srv_undo_tablespaces, srv_undo_logs); if (srv_available_undo_logs == ULINT_UNDEFINED) { /* Can only happen if server is read only. */ ut_a(srv_read_only_mode); srv_undo_logs = ULONG_UNDEFINED; } else if (srv_available_undo_logs < srv_undo_logs) { /* Should due to out of file space. */ return (srv_init_abort(create_new_db, __FILE__, __LINE__, DB_ERROR)); } if (!srv_read_only_mode) { /* Create the thread which watches the timeouts for lock waits */ thread_handles[2 + SRV_MAX_N_IO_THREADS] = os_thread_create( lock_wait_timeout_thread, NULL, thread_ids + 2 + SRV_MAX_N_IO_THREADS); thread_started[2 + SRV_MAX_N_IO_THREADS] = true; lock_sys->timeout_thread_active = true; /* Create the thread which warns of long semaphore waits */ srv_error_monitor_active = true; thread_handles[3 + SRV_MAX_N_IO_THREADS] = os_thread_create( srv_error_monitor_thread, NULL, thread_ids + 3 + SRV_MAX_N_IO_THREADS); thread_started[3 + SRV_MAX_N_IO_THREADS] = true; /* Create the thread which prints InnoDB monitor info */ if (!thread_started[4 + SRV_MAX_N_IO_THREADS]) { /* srv_monitor_thread not yet started */ srv_monitor_active = true; thread_handles[4 + SRV_MAX_N_IO_THREADS] = os_thread_create( srv_monitor_thread, NULL, thread_ids + 4 + SRV_MAX_N_IO_THREADS); thread_started[4 + SRV_MAX_N_IO_THREADS] = true; } } /* Create the SYS_FOREIGN and SYS_FOREIGN_COLS system tables */ err = dict_create_or_check_foreign_constraint_tables(); if (err != DB_SUCCESS) { return(err); } /* Create the SYS_TABLESPACES and SYS_DATAFILES system tables if we have not done that already on crash recovery. */ if (sys_datafiles_created == false) { err = dict_create_or_check_sys_tablespace(); if (err != DB_SUCCESS) { return(err); } } srv_is_being_started = FALSE; ut_a(trx_purge_state() == PURGE_STATE_INIT); /* Create the master thread which does purge and other utility operations */ if (!srv_read_only_mode) { thread_handles[1 + SRV_MAX_N_IO_THREADS] = os_thread_create( srv_master_thread, NULL, thread_ids + (1 + SRV_MAX_N_IO_THREADS)); thread_started[1 + SRV_MAX_N_IO_THREADS] = true; srv_undo_sources = true; /* Create the dict stats gathering thread */ srv_dict_stats_thread_active = true; dict_stats_thread_handle = os_thread_create( dict_stats_thread, NULL, NULL); dict_stats_thread_started = true; /* Create the thread that will optimize the FTS sub-system. */ fts_optimize_init(); } if (!srv_read_only_mode && srv_force_recovery < SRV_FORCE_NO_BACKGROUND) { thread_handles[6 + SRV_MAX_N_IO_THREADS] = os_thread_create( srv_purge_coordinator_thread, NULL, thread_ids + 6 + SRV_MAX_N_IO_THREADS); thread_started[6 + SRV_MAX_N_IO_THREADS] = true; ut_a(UT_ARR_SIZE(thread_ids) > 6 + srv_n_purge_threads + SRV_MAX_N_IO_THREADS); /* We've already created the purge coordinator thread above. */ for (i = 1; i < srv_n_purge_threads; ++i) { thread_handles[6 + i + SRV_MAX_N_IO_THREADS] = os_thread_create( srv_worker_thread, NULL, thread_ids + 6 + i + SRV_MAX_N_IO_THREADS); thread_started[6 + i + SRV_MAX_N_IO_THREADS] = true; } srv_start_wait_for_purge_to_start(); } else { purge_sys->state = PURGE_STATE_DISABLED; } if (!srv_read_only_mode) { if (srv_use_mtflush) { /* Start multi-threaded flush threads */ mtflush_ctx = buf_mtflu_handler_init( srv_mtflush_threads, srv_buf_pool_instances); /* Set up the thread ids */ buf_mtflu_set_thread_ids( srv_mtflush_threads, mtflush_ctx, (thread_ids + 6 + SRV_MAX_N_PURGE_THREADS)); } buf_page_cleaner_is_active = true; buf_flush_page_cleaner_thread_handle = os_thread_create( buf_flush_page_cleaner_thread, NULL, NULL); buf_flush_page_cleaner_thread_started = true; buf_lru_manager_is_active = true; buf_flush_lru_manager_thread_handle = os_thread_create( buf_flush_lru_manager_thread, NULL, NULL); buf_flush_lru_manager_thread_started = true; } if (!srv_file_per_table && srv_pass_corrupt_table) { fprintf(stderr, "InnoDB: Warning:" " The option innodb_file_per_table is disabled," " so using the option innodb_pass_corrupt_table doesn't make sense.\n"); } if (srv_print_verbose_log) { ib_logf(IB_LOG_LEVEL_INFO, " Percona XtraDB (http://www.percona.com) %s started; " "log sequence number " LSN_PF "", INNODB_VERSION_STR, srv_start_lsn); } if (srv_force_recovery > 0) { ib_logf(IB_LOG_LEVEL_INFO, "!!! innodb_force_recovery is set to %lu !!!", (ulong) srv_force_recovery); } if (!srv_read_only_mode) { /* Create a checkpoint before logging anything new, so that the current encryption key in use is definitely logged before any log blocks encrypted with that key. */ log_make_checkpoint_at(LSN_MAX, TRUE); } if (srv_force_recovery == 0) { /* In the insert buffer we may have even bigger tablespace id's, because we may have dropped those tablespaces, but insert buffer merge has not had time to clean the records from the ibuf tree. */ ibuf_update_max_tablespace_id(); } if (!srv_read_only_mode) { #ifdef WITH_WSREP /* Create the dump/load thread only when not running with --wsrep-recover. */ if (!wsrep_recovery) { #endif /* WITH_WSREP */ /* Create the buffer pool dump/load thread */ srv_buf_dump_thread_active = true; buf_dump_thread_handle= os_thread_create(buf_dump_thread, NULL, NULL); buf_dump_thread_started = true; #ifdef WITH_WSREP } else { ib_logf(IB_LOG_LEVEL_WARN, "Skipping buffer pool dump/restore during " "wsrep recovery."); } #endif /* WITH_WSREP */ /* Create thread(s) that handles key rotation */ fil_system_enter(); btr_scrub_init(); fil_crypt_threads_init(); fil_system_exit(); /* Initialize online defragmentation. */ btr_defragment_init(); btr_defragment_thread_active = true; os_thread_create(btr_defragment_thread, NULL, NULL); } skip_processes: srv_was_started = TRUE; return(DB_SUCCESS); } #if 0 /******************************************************************** Sync all FTS cache before shutdown */ static void srv_fts_close(void) /*===============*/ { dict_table_t* table; for (table = UT_LIST_GET_FIRST(dict_sys->table_LRU); table; table = UT_LIST_GET_NEXT(table_LRU, table)) { fts_t* fts = table->fts; if (fts != NULL) { fts_sync_table(table); } } for (table = UT_LIST_GET_FIRST(dict_sys->table_non_LRU); table; table = UT_LIST_GET_NEXT(table_LRU, table)) { fts_t* fts = table->fts; if (fts != NULL) { fts_sync_table(table); } } } #endif /** Shut down InnoDB. */ UNIV_INTERN void innodb_shutdown() { ulint i; if (!srv_was_started) { if (srv_is_being_started) { ib_logf(IB_LOG_LEVEL_WARN, "Shutting down an improperly started, " "or created database!"); } } if (srv_undo_sources) { ut_ad(!srv_read_only_mode); /* Shutdown the FTS optimize sub system. */ fts_optimize_start_shutdown(); fts_optimize_end(); dict_stats_shutdown(); while (row_get_background_drop_list_len_low()) { srv_wake_master_thread(); os_thread_yield(); } srv_undo_sources = false; } /* 1. Flush the buffer pool to disk, write the current lsn to the tablespace header(s), and copy all log data to archive. The step 1 is the real InnoDB shutdown. The remaining steps 2 - ... just free data structures after the shutdown. */ logs_empty_and_mark_files_at_shutdown(); if (srv_conc_get_active_threads() != 0) { ib_logf(IB_LOG_LEVEL_WARN, "Query counter shows %ld queries still " "inside InnoDB at shutdown", srv_conc_get_active_threads()); } /* 2. Make all threads created by InnoDB to exit */ srv_shutdown_state = SRV_SHUTDOWN_EXIT_THREADS; /* All threads end up waiting for certain events. Put those events to the signaled state. Then the threads will exit themselves after os_event_wait(). */ for (i = 0; i < 1000; i++) { /* NOTE: IF YOU CREATE THREADS IN INNODB, YOU MUST EXIT THEM HERE OR EARLIER */ if (!srv_read_only_mode) { /* a. Let the lock timeout thread exit */ os_event_set(lock_sys->timeout_event); /* b. srv error monitor thread exits automatically, no need to do anything here */ /* c. We wake the master thread so that it exits */ srv_wake_master_thread(); /* d. Wakeup purge threads. */ srv_purge_wakeup(); } /* e. Exit the i/o threads */ os_aio_wake_all_threads_at_shutdown(); /* f. dict_stats_thread is signaled from logs_empty_and_mark_files_at_shutdown() and should have already quit or is quitting right now. */ if (srv_use_mtflush) { /* g. Exit the multi threaded flush threads */ buf_mtflu_io_thread_exit(); } os_rmb; if (os_thread_count == 0) { /* All the threads have exited or are just exiting; NOTE that the threads may not have completed their exit yet. Should we use pthread_join() to make sure they have exited? If we did, we would have to remove the pthread_detach() from os_thread_exit(). Now we just sleep 0.1 seconds and hope that is enough! */ os_thread_sleep(100000); break; } os_thread_sleep(100000); } if (i == 1000) { ib_logf(IB_LOG_LEVEL_WARN, "%lu threads created by InnoDB" " had not exited at shutdown!", (ulong) os_thread_count); } if (srv_monitor_file) { fclose(srv_monitor_file); srv_monitor_file = 0; if (srv_monitor_file_name) { unlink(srv_monitor_file_name); mem_free(srv_monitor_file_name); } } if (srv_dict_tmpfile) { fclose(srv_dict_tmpfile); srv_dict_tmpfile = 0; } if (srv_misc_tmpfile) { fclose(srv_misc_tmpfile); srv_misc_tmpfile = 0; } if (!srv_read_only_mode && !srv_apply_log_only) { dict_stats_thread_deinit(); fil_crypt_threads_cleanup(); btr_scrub_cleanup(); btr_defragment_shutdown(); } #ifdef __WIN__ /* MDEV-361: ha_innodb.dll leaks handles on Windows MDEV-7403: should not pass recv_writer_thread_handle to CloseHandle(). On Windows we should call CloseHandle() for all open thread handles. */ if (os_thread_count == 0) { for (i = 0; i < SRV_MAX_N_IO_THREADS + 6 + 32; ++i) { if (thread_started[i]) { CloseHandle(thread_handles[i]); } } if (buf_flush_page_cleaner_thread_started) { CloseHandle(buf_flush_page_cleaner_thread_handle); } if (buf_dump_thread_started) { CloseHandle(buf_dump_thread_handle); } if (dict_stats_thread_started) { CloseHandle(dict_stats_thread_handle); } if (buf_flush_lru_manager_thread_started) { CloseHandle(buf_flush_lru_manager_thread_handle); } if (srv_redo_log_follow_thread_started) { CloseHandle(srv_redo_log_follow_thread_handle); } } #endif /* __WIN __ */ /* This must be disabled before closing the buffer pool and closing the data dictionary. */ btr_search_disable(); ibuf_close(); log_online_shutdown(); log_shutdown(); trx_sys_file_format_close(); trx_sys_close(); lock_sys_close(); /* We don't create these mutexes in RO mode because we don't create the temp files that the cover. */ if (!srv_read_only_mode) { mutex_free(&srv_monitor_file_mutex); mutex_free(&srv_dict_tmpfile_mutex); mutex_free(&srv_misc_tmpfile_mutex); } dict_close(); btr_search_sys_free(); /* 3. Free all InnoDB's own mutexes and the os_fast_mutexes inside them */ os_aio_free(); que_close(); row_mysql_close(); srv_mon_free(); srv_free(); fil_close(); /* 4. Free all allocated memory */ pars_lexer_close(); log_mem_free(); buf_pool_free(srv_buf_pool_instances); mem_close(); sync_close(); /* ut_free_all_mem() frees all allocated memory not freed yet in shutdown, and it will also free the ut_list_mutex, so it should be the last one for all operation */ ut_free_all_mem(); os_rmb; if (os_thread_count != 0 || os_event_count != 0 || os_mutex_count != 0 || os_fast_mutex_count != 0) { ib_logf(IB_LOG_LEVEL_WARN, "Some resources were not cleaned up in shutdown: " "threads %lu, events %lu, os_mutexes %lu, " "os_fast_mutexes %lu", (ulong) os_thread_count, (ulong) os_event_count, (ulong) os_mutex_count, (ulong) os_fast_mutex_count); } if (dict_foreign_err_file) { fclose(dict_foreign_err_file); } if (srv_print_verbose_log) { ib_logf(IB_LOG_LEVEL_INFO, "Shutdown completed; log sequence number " LSN_PF "", srv_shutdown_lsn); } srv_was_started = FALSE; srv_start_has_been_called = FALSE; /* reset io_tid_i, in case current process does second innodb start (xtrabackup might do that).*/ io_tid_i = 0; } #endif /* !UNIV_HOTBACKUP */ /*****************************************************************//** Get the meta-data filename from the table name. */ UNIV_INTERN void srv_get_meta_data_filename( /*=======================*/ dict_table_t* table, /*!< in: table */ char* filename, /*!< out: filename */ ulint max_len) /*!< in: filename max length */ { ulint len; char* path; char* suffix; static const ulint suffix_len = strlen(".cfg"); if (DICT_TF_HAS_DATA_DIR(table->flags)) { dict_get_and_save_data_dir_path(table, false); ut_a(table->data_dir_path); path = os_file_make_remote_pathname( table->data_dir_path, table->name, "cfg"); } else { path = fil_make_ibd_name(table->name, false); } ut_a(path); len = ut_strlen(path); ut_a(max_len >= len); suffix = path + (len - suffix_len); if (strncmp(suffix, ".cfg", suffix_len) == 0) { strcpy(filename, path); } else { ut_ad(!strcmp(suffix, ".ibd")); memcpy(filename, path, len - suffix_len); suffix = filename + (len - suffix_len); strcpy(suffix, ".cfg"); } mem_free(path); srv_normalize_path_for_win(filename); }