~percona-dev/percona-server/windows-fixes

diff -ruN a/storage/innobase/buf/buf0flu.c b/storage/innobase/buf/buf0flu.c

--- a/storage/innobase/buf/buf0flu.c    2010-11-03 07:01:13.000000000 +0900

+++ b/storage/innobase/buf/buf0flu.c    2010-12-03 15:10:08.934990091 +0900

 

        ut_ad(flush_type == BUF_FLUSH_LRU || flush_type == BUF_FLUSH_LIST);

 

diff -ruN a/storage/innobase/handler/ha_innodb.cc b/storage/innobase/handler/ha_innodb.cc

--- a/storage/innobase/handler/ha_innodb.cc     2010-12-03 15:09:51.283956391 +0900

+++ b/storage/innobase/handler/ha_innodb.cc     2010-12-03 15:10:08.963980444 +0900

   "Timeout in seconds an InnoDB transaction may wait for a lock before being rolled back. Values above 100000000 disable the timeout.",

   NULL, NULL, 50, 1, 1024 * 1024 * 1024, 0);

 

 

 static handler *innobase_create_handler(handlerton *hton,

                                         TABLE_SHARE *table,

        }

 }

 

 /********************************************************************//**

 Obtain the InnoDB transaction of a MySQL thread.

 @return        reference to transaction pointer */

        srv_n_read_io_threads = (ulint) innobase_read_io_threads;

        srv_n_write_io_threads = (ulint) innobase_write_io_threads;

 

        srv_force_recovery = (ulint) innobase_force_recovery;

 

        srv_use_doublewrite_buf = (ibool) innobase_use_doublewrite;

            && (all

                || !thd_test_options(

                        thd, OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN))) {

 

                /* For ibbackup to work the order of transactions in binlog

                and InnoDB must be the same. Consider the situation

 

 static MYSQL_SYSVAR_ULONG(purge_threads, srv_n_purge_threads,

   PLUGIN_VAR_OPCMDARG | PLUGIN_VAR_READONLY,

   0,                   /* Minimum value */

   1, 0);               /* Maximum value */

 

   innodb_file_format_max_validate,

   innodb_file_format_max_update, "Antelope");

 

 

 static MYSQL_SYSVAR_STR(flush_method, innobase_file_flush_method,

   PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,

 static MYSQL_SYSVAR_LONGLONG(buffer_pool_size, innobase_buffer_pool_size,

   PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,

   "The size of the memory buffer InnoDB uses to cache data and indexes of its tables.",

 

 static MYSQL_SYSVAR_LONG(buffer_pool_instances, innobase_buffer_pool_instances,

   PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,

   "trigger a readahead.",

   NULL, NULL, 56, 0, 64, 0);

 

 static struct st_mysql_sys_var* innobase_system_variables[]= {

   MYSQL_SYSVAR(additional_mem_pool_size),

   MYSQL_SYSVAR(autoextend_increment),

   MYSQL_SYSVAR(file_format_check),

   MYSQL_SYSVAR(file_format_max),

   MYSQL_SYSVAR(flush_log_at_trx_commit),

   MYSQL_SYSVAR(flush_method),

   MYSQL_SYSVAR(force_recovery),

   MYSQL_SYSVAR(locks_unsafe_for_binlog),

   MYSQL_SYSVAR(show_verbose_locks),

   MYSQL_SYSVAR(show_locks_held),

   MYSQL_SYSVAR(version),

 

        mutex_create(ibuf_pessimistic_insert_mutex_key,

                     &ibuf_pessimistic_insert_mutex,

        size = ibuf->size;

        max_size = ibuf->max_size;

 

diff -ruN a/storage/innobase/os/os0file.c b/storage/innobase/os/os0file.c

--- a/storage/innobase/os/os0file.c     2010-11-03 07:01:13.000000000 +0900

+++ b/storage/innobase/os/os0file.c     2010-12-03 15:10:09.093023540 +0900

 #endif

 #ifdef UNIV_NON_BUFFERED_IO

 # ifndef UNIV_HOTBACKUP

                        /* Do not use unbuffered i/o to log files because

                        value 2 denotes that we do not flush the log at every

                        commit, but only once per second */

                attributes = 0;

 #ifdef UNIV_NON_BUFFERED_IO

 # ifndef UNIV_HOTBACKUP

                        /* Do not use unbuffered i/o to log files because

                        value 2 denotes that we do not flush the log at every

                        commit, but only once per second */

                os_file_set_nocache(file, name, mode_str);

        }

 

diff -ruN a/storage/innobase/srv/srv0srv.c b/storage/innobase/srv/srv0srv.c

--- a/storage/innobase/srv/srv0srv.c    2010-12-03 15:09:51.301987792 +0900

+++ b/storage/innobase/srv/srv0srv.c    2010-12-03 15:13:29.369986988 +0900

 UNIV_INTERN ulint      srv_log_file_size       = ULINT_MAX;

 /* size in database pages */

 UNIV_INTERN ulint      srv_log_buffer_size     = ULINT_MAX;

 

 /* Try to flush dirty pages so as to avoid IO bursts at

 the checkpoints. */

 

 UNIV_INTERN ulong      srv_replication_delay           = 0;

 

 /*-------------------------------------------*/

 UNIV_INTERN ulong      srv_n_spin_wait_rounds  = 30;

 UNIV_INTERN ulong      srv_n_free_tickets_to_enter = 500;

        ulint           n_pages_purged  = 0;

        ulint           n_bytes_merged;

        ulint           n_pages_flushed;

        ulint           n_bytes_archived;

        ulint           n_tables_to_drop;

        ulint           n_ios;

        ulint           n_ios_very_old;

        ulint           n_pend_ios;

        ulint           next_itr_time;

 

 #ifdef UNIV_DEBUG_THREAD_CREATION

        fprintf(stderr, "Master thread starts, id %lu\n",

 

        mutex_exit(&kernel_mutex);

 

 loop:

        /*****************************************************************/

        /* ---- When there is database activity by users, we cycle in this

        /* Sleep for 1 second on entrying the for loop below the first time. */

        next_itr_time = ut_time_ms() + 1000;

 

                /* ALTER TABLE in MySQL requires on Unix that the table handler

                can drop tables lazily after there no longer are SELECT

                queries to them. */

                srv_main_thread_op_info = "sleeping";

                srv_main_1_second_loops++;

 

                if (next_itr_time > cur_time

                    && srv_shutdown_state == SRV_SHUTDOWN_NONE) {

 

                                        (next_itr_time - cur_time)

                                         * 1000));

                        srv_main_sleeps++;

 

                /* Flush logs if needed */

                srv_sync_log_buffer_in_background();

                if (n_pend_ios < SRV_PEND_IO_THRESHOLD

                    && (n_ios - n_ios_old < SRV_RECENT_IO_ACTIVITY)) {

                        srv_main_thread_op_info = "doing insert buffer merge";

 

                        /* Flush logs if needed */

                        srv_sync_log_buffer_in_background();

                        n_pages_flushed = buf_flush_list(

                                PCT_IO(100), IB_ULONGLONG_MAX);

 

 

                        /* Try to keep the rate of flushing of dirty

                        pages such that redo log generation does not

                                                n_flush,

                                                IB_ULONGLONG_MAX);

                        }

                }

 

                if (srv_activity_count == old_activity_count) {

        even if the server were active */

 

        srv_main_thread_op_info = "doing insert buffer merge";

 

        /* Flush logs if needed */

        srv_sync_log_buffer_in_background();

                buf_flush_list below. Otherwise, the system favors

                clean pages over cleanup throughput. */

                n_bytes_merged = ibuf_contract_for_n_pages(FALSE,

        }

 

        srv_main_thread_op_info = "reserving kernel mutex";

        srv_slot_t*     slot;

        ulint           slot_no = ULINT_UNDEFINED;

        ulint           n_total_purged = ULINT_UNDEFINED;

 

        ut_a(srv_n_purge_threads == 1);

 

 

        mutex_exit(&kernel_mutex);

 

 

                /* If there are very few records to purge or the last

                purge didn't purge any records then wait for activity.

                } while (n_pages_purged > 0 && !srv_fast_shutdown);

 

                srv_sync_log_buffer_in_background();

diff -ruN a/storage/innobase/srv/srv0start.c b/storage/innobase/srv/srv0start.c

--- a/storage/innobase/srv/srv0start.c  2010-11-03 07:01:13.000000000 +0900

+++ b/storage/innobase/srv/srv0start.c  2010-12-03 15:10:09.103023543 +0900

        } else if (0 == ut_strcmp(srv_file_flush_method_str, "O_DIRECT")) {

                srv_unix_file_flush_method = SRV_UNIX_O_DIRECT;