函数innobase_start_or_create_for_mysql

/********************************************************************
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
int
innobase_start_or_create_for_mysql(void)
/*====================================*/
{
    ibool        create_new_db;
    ibool        log_file_created;
    ibool        log_created    = FALSE;
    ibool        log_opened    = FALSE;
    ib_uint64_t    min_flushed_lsn;
    ib_uint64_t    max_flushed_lsn;
#ifdef UNIV_LOG_ARCHIVE
    ulint        min_arch_log_no;
    ulint        max_arch_log_no;
#endif /* UNIV_LOG_ARCHIVE */
    ulint        sum_of_new_sizes;
    ulint        sum_of_data_file_sizes;
    ulint        tablespace_size_in_header;
    ulint        err;
    ulint        i;
    ulint        io_limit;
    my_bool        srv_file_per_table_original_value
        = srv_file_per_table;
    mtr_t        mtr;
#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 */

    if (sizeof(ulint) != sizeof(void*)) {
        ut_print_timestamp(stderr);
        fprintf(stderr,
            " InnoDB: Error: size of InnoDB‘s ulint is %lu, "
            "but size of void*\n", (ulong) sizeof(ulint));
        ut_print_timestamp(stderr);
        fprintf(stderr,
            " InnoDB: is %lu. The sizes should be the same "
            "so that on a 64-bit\n",
            (ulong) sizeof(void*));
        ut_print_timestamp(stderr);
        fprintf(stderr,
            " InnoDB: platforms you can allocate more than 4 GB "
            "of memory.\n");
    }

    /* System tables are created in tablespace 0.  Thus, we must
    temporarily clear srv_file_per_table.  This is ok, because the
    server will not accept connections (which could modify
    innodb_file_per_table) until this function has returned. */
    srv_file_per_table = FALSE;
#ifdef UNIV_DEBUG
    ut_print_timestamp(stderr);
    fprintf(stderr,
        " InnoDB: !!!!!!!! UNIV_DEBUG switched on !!!!!!!!!\n");
#endif

#ifdef UNIV_IBUF_DEBUG
    ut_print_timestamp(stderr);
    fprintf(stderr,
        " InnoDB: !!!!!!!! UNIV_IBUF_DEBUG switched on !!!!!!!!!\n");
# ifdef UNIV_IBUF_COUNT_DEBUG
    ut_print_timestamp(stderr);
    fprintf(stderr,
        " InnoDB: !!!!!!!! UNIV_IBUF_COUNT_DEBUG switched on "
        "!!!!!!!!!\n");
    ut_print_timestamp(stderr);
    fprintf(stderr,
        " InnoDB: Crash recovery will fail with UNIV_IBUF_COUNT_DEBUG\n");
# endif
#endif

#ifdef UNIV_BLOB_DEBUG
    fprintf(stderr,
        "InnoDB: !!!!!!!! UNIV_BLOB_DEBUG switched on !!!!!!!!!\n"
        "InnoDB: Server restart may fail with UNIV_BLOB_DEBUG\n");
#endif /* UNIV_BLOB_DEBUG */

#ifdef UNIV_SYNC_DEBUG
    ut_print_timestamp(stderr);
    fprintf(stderr,
        " InnoDB: !!!!!!!! UNIV_SYNC_DEBUG switched on !!!!!!!!!\n");
#endif

#ifdef UNIV_SEARCH_DEBUG
    ut_print_timestamp(stderr);
    fprintf(stderr,
        " InnoDB: !!!!!!!! UNIV_SEARCH_DEBUG switched on !!!!!!!!!\n");
#endif

#ifdef UNIV_LOG_LSN_DEBUG
    ut_print_timestamp(stderr);
    fprintf(stderr,
        " InnoDB: !!!!!!!! UNIV_LOG_LSN_DEBUG switched on !!!!!!!!!\n");
#endif /* UNIV_LOG_LSN_DEBUG */
#ifdef UNIV_MEM_DEBUG
    ut_print_timestamp(stderr);
    fprintf(stderr,
        " InnoDB: !!!!!!!! UNIV_MEM_DEBUG switched on !!!!!!!!!\n");
#endif

    if (UNIV_LIKELY(srv_use_sys_malloc)) {
        ut_print_timestamp(stderr);
        fprintf(stderr,
            " InnoDB: The InnoDB memory heap is disabled\n");
    }

    ut_print_timestamp(stderr);
    fputs(" InnoDB: " IB_ATOMICS_STARTUP_MSG "\n", stderr);

    ut_print_timestamp(stderr);
    fputs(" InnoDB: Compressed tables use zlib " ZLIB_VERSION
#ifdef UNIV_ZIP_DEBUG
          " with validation"
#endif /* UNIV_ZIP_DEBUG */
          "\n" , stderr);
#ifdef UNIV_ZIP_COPY
    ut_print_timestamp(stderr);
    fputs(" InnoDB: and extra copying\n", stderr);
#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__
    switch (os_get_os_version()) {
    case OS_WIN95:
    case OS_WIN31:
    case OS_WINNT:
        /* On Win 95, 98, ME, Win32 subsystem for Windows 3.1,
        and NT use simulated aio. In NT Windows provides async i/o,
        but when run in conjunction with InnoDB Hot Backup, it seemed
        to corrupt the data files. */

        srv_use_native_aio = FALSE;
        break;

    case OS_WIN2000:
    case OS_WINXP:
        /* On 2000 and XP, async IO is available. */
        srv_use_native_aio = TRUE;
        break;

    default:
        /* Vista and later have both async IO and condition variables */
        srv_use_native_aio = TRUE;
        srv_use_native_conditions = TRUE;
        break;
    }

#elif defined(LINUX_NATIVE_AIO)

    if (srv_use_native_aio) {
        ut_print_timestamp(stderr);
        fprintf(stderr,
            " InnoDB: Using Linux native AIO\n");
    }
#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

    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;
#ifndef __WIN__
    } 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, "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;
#else
    } 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;
#endif
    } else {
        ut_print_timestamp(stderr);
        fprintf(stderr,
            " InnoDB: Unrecognized value %s for"
            " innodb_flush_method\n",
            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. */

    if (srv_buf_pool_size >= 1000 * 1024 * 1024) {
        /* If buffer pool is less than 1000 MB,
        assume fewer threads. Also use only one
        buffer pool instance */
        srv_max_n_threads = 50000;

    } else if (srv_buf_pool_size >= 8 * 1024 * 1024) {

        srv_buf_pool_instances = 1;
        srv_max_n_threads = 10000;
    } else {
        srv_buf_pool_instances = 1;
        srv_max_n_threads = 1000;    /* saves several MB of memory,
                        especially in 64-bit
                        computers */
    }

    err = srv_boot();

    if (err != DB_SUCCESS) {

        return((int) err);
    }

    mutex_create(srv_monitor_file_mutex_key,
             &srv_monitor_file_mutex, SYNC_NO_ORDER_CHECK);

    if (srv_innodb_status) {
        srv_monitor_file_name = 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) {
            fprintf(stderr, "InnoDB: unable to create %s: %s\n",
                srv_monitor_file_name, strerror(errno));
            return(DB_ERROR);
        }
    } else {
        srv_monitor_file_name = NULL;
        srv_monitor_file = os_file_create_tmpfile();
        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();
    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();
    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) {
        ut_print_timestamp(stderr);
        fprintf(stderr, " InnoDB: Warning:"
            " innodb_file_io_threads is deprecated."
            " Please use innodb_read_io_threads and"
            " innodb_write_io_threads instead\n");
    }

    /* Now overwrite the value on srv_n_file_io_threads */
    srv_n_file_io_threads = 2 + srv_n_read_io_threads
                + srv_n_write_io_threads;

    ut_a(srv_n_file_io_threads <= SRV_MAX_N_IO_THREADS);

    io_limit = 8 * SRV_N_PENDING_IOS_PER_THREAD;

    


    if (!os_aio_init(io_limit,
             srv_n_read_io_threads,
             srv_n_write_io_threads,
             SRV_MAX_N_PENDING_SYNC_IOS)) {

        ut_print_timestamp(stderr);
        fprintf(stderr,
            " InnoDB: Fatal error: cannot initialize AIO"
            " sub-system\n");

        return(DB_ERROR);
    }

    fil_init(srv_file_per_table ? 50000 : 5000,srv_max_n_open_files);



    /**
     *UNIV_INTERN ulint srv_buf_pool_size = ULINT_MAX;
     *#define ULINT_MAX ((ulint)(-2))
     *如果是32位的无符号长整型的话，其内存值应该是0xFFFFFFFE 值为4294967294 约4G内存
     *unsight long int
     *
     *UNIV_INTERN ulint srv_buf_pool_instances = 1;//requested number of buffer pool instances 

     */
    err = buf_pool_init(srv_buf_pool_size, srv_buf_pool_instances); //buf_pool_init 初始化 详见
    fprintf(stderr," InnoDB: Completed initialization of buffer pool\n");

    if (err != DB_SUCCESS) {
        fprintf(stderr," InnoDB: Fatal error: cannot allocate memory" " for the buffer pool\n");
        return(DB_ERROR);
    }

    fsp_init();
    log_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;

        os_thread_create(io_handler_thread, n + i, thread_ids + i);
    }


    if (srv_n_log_files * srv_log_file_size >= 262144) {
        ut_print_timestamp(stderr);
        fprintf(stderr,
            " InnoDB: Error: combined size of log files"
            " must be < 4 GB\n");

        return(DB_ERROR);
    }

    sum_of_new_sizes = 0;


    if (sum_of_new_sizes < 10485760 / UNIV_PAGE_SIZE) {
        ut_print_timestamp(stderr);
        fprintf(stderr,
            " InnoDB: Error: tablespace size must be"
            " at least 10 MB\n");

        return(DB_ERROR);
    }

    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 */
                    &min_flushed_lsn, &max_flushed_lsn,
                    &sum_of_new_sizes);
    if (err != DB_SUCCESS) {
        ut_print_timestamp(stderr);
        fprintf(stderr,
            " InnoDB: Could not open or create data files.\n");
        ut_print_timestamp(stderr);
        fprintf(stderr,
            " InnoDB: If you tried to add new data files,"
            " and it failed here,\n");
        ut_print_timestamp(stderr);
        fprintf(stderr,
            " InnoDB: you should now edit innodb_data_file_path"
            " in my.cnf back\n");
        ut_print_timestamp(stderr);
        fprintf(stderr,
            " InnoDB: to what it was, and remove the"
            " new ibdata files InnoDB created\n");
        ut_print_timestamp(stderr);
        fprintf(stderr,
            " InnoDB: in this failed attempt. InnoDB only wrote"
            " those files full of\n");
        ut_print_timestamp(stderr);
        fprintf(stderr,
            " InnoDB: zeros, but did not yet use them in any way."
            " But be careful: do not\n");
        ut_print_timestamp(stderr);
        fprintf(stderr,
            " InnoDB: remove old data files"
            " which contain your precious data!\n");

        return((int) err);
    }



    for (i = 0; i < srv_n_log_files; i++) {
        err = open_or_create_log_file(create_new_db, &log_file_created,
                          log_opened, 0, i);
        if (err != DB_SUCCESS) {

            return((int) err);
        }

        if (log_file_created) {
            log_created = TRUE;
        } else {
            log_opened = TRUE;
        }
        if ((log_opened && create_new_db)
            || (log_opened && log_created)) {
            ut_print_timestamp(stderr);
            fprintf(stderr,
                " InnoDB: Error: all log files must be"
                " created at the same time.\n");
            ut_print_timestamp(stderr);
            fprintf(stderr,
                " InnoDB: All log files must be"
                " created also in database creation.\n");
            ut_print_timestamp(stderr);
            fprintf(stderr,
                " InnoDB: If you want bigger or smaller"
                " log files, shut down the\n");
            ut_print_timestamp(stderr);
            fprintf(stderr,
                " InnoDB: database and make sure there"
                " were no errors in shutdown.\n");
            ut_print_timestamp(stderr);
            fprintf(stderr,
                " InnoDB: Then delete the existing log files."
                " Edit the .cnf file\n");
            ut_print_timestamp(stderr);
            fprintf(stderr,
                " InnoDB: and start the database again.\n");

            return(DB_ERROR);
        }
    }

    /* 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();

    if (log_created && !create_new_db
#ifdef UNIV_LOG_ARCHIVE
        && !srv_archive_recovery
#endif /* UNIV_LOG_ARCHIVE */
        ) {
        if (max_flushed_lsn != min_flushed_lsn
#ifdef UNIV_LOG_ARCHIVE
            || max_arch_log_no != min_arch_log_no
#endif /* UNIV_LOG_ARCHIVE */
            ) {
            ut_print_timestamp(stderr);
            fprintf(stderr,
                " InnoDB: Cannot initialize created"
                " log files because\n");
            ut_print_timestamp(stderr);
            fprintf(stderr,
                " InnoDB: data files were not in sync"
                " with each other\n");
            ut_print_timestamp(stderr);
            fprintf(stderr,
                " InnoDB: or the data files are corrupt.\n");

            return(DB_ERROR);
        }

        if (max_flushed_lsn < (ib_uint64_t) 1000) {
            ut_print_timestamp(stderr);
            fprintf(stderr,
                " InnoDB: Cannot initialize created"
                " log files because\n");
            ut_print_timestamp(stderr);
            fprintf(stderr,
                " InnoDB: data files are corrupt,"
                " or new data files were\n");
            ut_print_timestamp(stderr);
            fprintf(stderr,
                " InnoDB: created when the database"
                " was started previous\n");
            ut_print_timestamp(stderr);
            fprintf(stderr,
                " InnoDB: time but the database"
                " was not shut down\n");
            ut_print_timestamp(stderr);
            fprintf(stderr,
                " InnoDB: normally after that.\n");

            return(DB_ERROR);
        }

        mutex_enter(&(log_sys->mutex));

#ifdef UNIV_LOG_ARCHIVE
        /* Do not + 1 arch_log_no because we do not use log
        archiving */
        recv_reset_logs(max_flushed_lsn, max_arch_log_no, TRUE);
#else
        recv_reset_logs(max_flushed_lsn, TRUE);
#endif /* UNIV_LOG_ARCHIVE */

        mutex_exit(&(log_sys->mutex));
    }

    trx_sys_file_format_init();

    if (create_new_db) {
        mtr_start(&mtr);

        fsp_header_init(0, sum_of_new_sizes, &mtr);

        mtr_commit(&mtr);

        /* 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();

        dict_create();

        srv_startup_is_before_trx_rollback_phase = FALSE;

#ifdef UNIV_LOG_ARCHIVE
    } else if (srv_archive_recovery) {
        ut_print_timestamp(stderr);
        fprintf(stderr,
            " InnoDB: Starting archive"
            " recovery from a backup...\n");
        err = recv_recovery_from_archive_start(
            min_flushed_lsn, srv_archive_recovery_limit_lsn,
            min_arch_log_no);
        if (err != DB_SUCCESS) {

            return(DB_ERROR);
        }
        /* Since ibuf init is in dict_boot, and ibuf is needed
        in any disk i/o, first call dict_boot */

        dict_boot();

        trx_sys_init_at_db_start();

        srv_startup_is_before_trx_rollback_phase = FALSE;

        /* Initialize the fsp free limit global variable in the log
        system */
        fsp_header_get_free_limit();

        recv_recovery_from_archive_finish();
#endif /* UNIV_LOG_ARCHIVE */
    } 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();

        /* 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,
                              IB_ULONGLONG_MAX,
                              min_flushed_lsn,
                              max_flushed_lsn);
        if (err != DB_SUCCESS) {

            return(DB_ERROR);
        }

        /* Since the insert buffer init is in dict_boot, and the
        insert buffer is needed in any disk i/o, first we call
        dict_boot(). Note that trx_sys_init_at_db_start() only needs
        to access space 0, and the insert buffer at this stage already
        works for space 0. */

        dict_boot();
        trx_sys_init_at_db_start();

        /* Initialize the fsp free limit global variable in the log
        system */
        fsp_header_get_free_limit();

        /* 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_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_tablespaces_and_store_max_id(
                recv_needed_recovery);
        }

        srv_startup_is_before_trx_rollback_phase = FALSE;
        recv_recovery_rollback_active();

        /* 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();
    }

    if (!create_new_db && 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();
    }

#ifdef UNIV_LOG_ARCHIVE
    /* Archiving is always off under MySQL */
    if (!srv_log_archive_on) {
        ut_a(DB_SUCCESS == log_archive_noarchivelog());
    } else {
        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 (trx_doublewrite == NULL) {
        /* Create the doublewrite buffer to a new tablespace */

        trx_sys_create_doublewrite_buf();
    }

    /* 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.c 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. */

    trx_sys_create_rsegs(TRX_SYS_N_RSEGS - 1);

    /* Create the thread which watches the timeouts for lock waits */
    os_thread_create(&srv_lock_timeout_thread, NULL,
             thread_ids + 2 + SRV_MAX_N_IO_THREADS);

    /* Create the thread which warns of long semaphore waits */
    os_thread_create(&srv_error_monitor_thread, NULL,
             thread_ids + 3 + SRV_MAX_N_IO_THREADS);

    /* Create the thread which prints InnoDB monitor info */
    os_thread_create(&srv_monitor_thread, NULL,
             thread_ids + 4 + SRV_MAX_N_IO_THREADS);

    srv_is_being_started = FALSE;

    err = dict_create_or_check_foreign_constraint_tables();

    if (err != DB_SUCCESS) {
        return((int)DB_ERROR);
    }

    /* Create the master thread which does purge and other utility
    operations */

    os_thread_create(&srv_master_thread, NULL, thread_ids
             + (1 + SRV_MAX_N_IO_THREADS));

    /* Currently we allow only a single purge thread. */
    ut_a(srv_n_purge_threads == 0 || srv_n_purge_threads == 1);

    /* If the user has requested a separate purge thread then
    start the purge thread. */
    if (srv_n_purge_threads == 1) {
        os_thread_create(&srv_purge_thread, NULL, NULL);
    }

    /* Wait for the purge and master thread to startup. */

    while (srv_shutdown_state == SRV_SHUTDOWN_NONE) {
        if (srv_thread_has_reserved_slot(SRV_MASTER) == ULINT_UNDEFINED
            || (srv_n_purge_threads == 1
            && srv_thread_has_reserved_slot(SRV_WORKER)
            == ULINT_UNDEFINED)) {

            ut_print_timestamp(stderr);
            fprintf(stderr, "  InnoDB: "
                "Waiting for the background threads to "
                "start\n");
            os_thread_sleep(1000000);
        } else {
            break;
        }
    }

#ifdef UNIV_DEBUG
    /* buf_debug_prints = TRUE; */
#endif /* UNIV_DEBUG */
    sum_of_data_file_sizes = 0;

    for (i = 0; i < srv_n_data_files; i++) {
        sum_of_data_file_sizes += srv_data_file_sizes[i];
    }

    tablespace_size_in_header = fsp_header_get_tablespace_size();

    if (!srv_auto_extend_last_data_file
        && sum_of_data_file_sizes != tablespace_size_in_header) {

        ut_print_timestamp(stderr);
        fprintf(stderr,
            " InnoDB: Error: tablespace size"
            " stored in header is %lu pages, but\n",
            (ulong) tablespace_size_in_header);
        ut_print_timestamp(stderr);
        fprintf(stderr,
            "InnoDB: the sum of data file sizes is %lu pages\n",
            (ulong) sum_of_data_file_sizes);

        if (srv_force_recovery == 0
            && sum_of_data_file_sizes < tablespace_size_in_header) {
            /* This is a fatal error, the tail of a tablespace is
            missing */

            ut_print_timestamp(stderr);
            fprintf(stderr,
                " InnoDB: Cannot start InnoDB."
                " The tail of the system tablespace is\n");
            ut_print_timestamp(stderr);
            fprintf(stderr,
                " InnoDB: missing. Have you edited"
                " innodb_data_file_path in my.cnf in an\n");
            ut_print_timestamp(stderr);
            fprintf(stderr,
                " InnoDB: inappropriate way, removing"
                " ibdata files from there?\n");
            ut_print_timestamp(stderr);
            fprintf(stderr,
                " InnoDB: You can set innodb_force_recovery=1"
                " in my.cnf to force\n");
            ut_print_timestamp(stderr);
            fprintf(stderr,
                " InnoDB: a startup if you are trying"
                " to recover a badly corrupt database.\n");

            return(DB_ERROR);
        }
    }

    if (srv_auto_extend_last_data_file
        && sum_of_data_file_sizes < tablespace_size_in_header) {

        ut_print_timestamp(stderr);
        fprintf(stderr,
            " InnoDB: Error: tablespace size stored in header"
            " is %lu pages, but\n",
            (ulong) tablespace_size_in_header);
        ut_print_timestamp(stderr);
        fprintf(stderr,
            " InnoDB: the sum of data file sizes"
            " is only %lu pages\n",
            (ulong) sum_of_data_file_sizes);

        if (srv_force_recovery == 0) {

            ut_print_timestamp(stderr);
            fprintf(stderr,
                " InnoDB: Cannot start InnoDB. The tail of"
                " the system tablespace is\n");
            ut_print_timestamp(stderr);
            fprintf(stderr,
                " InnoDB: missing. Have you edited"
                " innodb_data_file_path in my.cnf in an\n");
            ut_print_timestamp(stderr);
            fprintf(stderr,
                " InnoDB: inappropriate way, removing"
                " ibdata files from there?\n");
            ut_print_timestamp(stderr);
            fprintf(stderr,
                " InnoDB: You can set innodb_force_recovery=1"
                " in my.cnf to force\n");
            ut_print_timestamp(stderr);
            fprintf(stderr,
                " InnoDB: a startup if you are trying to"
                " recover a badly corrupt database.\n");

            return(DB_ERROR);
        }
    }

    /* Check that os_fast_mutexes work as expected */
    os_fast_mutex_init(&srv_os_test_mutex);

    if (0 != os_fast_mutex_trylock(&srv_os_test_mutex)) {
        ut_print_timestamp(stderr);
        fprintf(stderr,
            " InnoDB: Error: pthread_mutex_trylock returns"
            " an unexpected value on\n");
        ut_print_timestamp(stderr);
        fprintf(stderr,
            " InnoDB: success! Cannot continue.\n");
        exit(1);
    }

    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_print_verbose_log) {
        ut_print_timestamp(stderr);
        fprintf(stderr,
            " InnoDB: %s started; "
            "log sequence number %llu\n",
            INNODB_VERSION_STR, srv_start_lsn);
    }

    if (srv_force_recovery > 0) {
        ut_print_timestamp(stderr);
        fprintf(stderr,
            " InnoDB: !!! innodb_force_recovery"
            " is set to %lu !!!\n",
            (ulong) srv_force_recovery);
    }

    fflush(stderr);

    if (trx_doublewrite_must_reset_space_ids) {
        /* Actually, we did not change the undo log format between
        4.0 and 4.1.1, and we would not need to run purge to
        completion. Note also that the purge algorithm in 4.1.1
        can process the history list again even after a full
        purge, because our algorithm does not cut the end of the
        history list in all cases so that it would become empty
        after a full purge. That mean that we may purge 4.0 type
        undo log even after this phase.

        The insert buffer record format changed between 4.0 and
        4.1.1. It is essential that the insert buffer is emptied
        here! */

        ut_print_timestamp(stderr);
        fprintf(stderr,
            " InnoDB: You are upgrading to an"
            " InnoDB version which allows multiple\n");
        ut_print_timestamp(stderr);
        fprintf(stderr,
            " InnoDB: tablespaces. Wait that purge"
            " and insert buffer merge run to\n");
        ut_print_timestamp(stderr);
        fprintf(stderr,
            " InnoDB: completion...\n");
        for (;;) {
            os_thread_sleep(1000000);

            if (0 == strcmp(srv_main_thread_op_info,
                    "waiting for server activity")) {

                ut_a(ibuf_is_empty());

                break;
            }
        }
        ut_print_timestamp(stderr);
        fprintf(stderr,
            " InnoDB: Full purge and insert buffer merge"
            " completed.\n");

        trx_sys_mark_upgraded_to_multiple_tablespaces();

        ut_print_timestamp(stderr);
        fprintf(stderr,
            " InnoDB: You have now successfully upgraded"
            " to the multiple tablespaces\n");
        ut_print_timestamp(stderr);
        fprintf(stderr,
            " InnoDB: format. You should NOT DOWNGRADE"
            " to an earlier version of\n");
        ut_print_timestamp(stderr);
        fprintf(stderr,
            " InnoDB: InnoDB! But if you absolutely need to"
            " downgrade, see\n");
        ut_print_timestamp(stderr);
        fprintf(stderr,
            " InnoDB: " REFMAN "multiple-tablespaces.html\n"
            " InnoDB: for instructions.\n");
    }

    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();
    }

    srv_file_per_table = srv_file_per_table_original_value;

    srv_was_started = TRUE;

    return((int) DB_SUCCESS);
}