~tsarev/percona-server/5.5-processlist_rows_stats-sporadic_fails-fix

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;

   PLUGIN_VAR_OPCMDARG | PLUGIN_VAR_READONLY,

   "Purge threads can be either 0 or 1.",

   NULL, NULL,

   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),

diff -ruN a/storage/innobase/ibuf/ibuf0ibuf.c b/storage/innobase/ibuf/ibuf0ibuf.c

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

+++ b/storage/innobase/ibuf/ibuf0ibuf.c 2010-12-03 15:10:09.073984282 +0900

        grow in size, as the references on the upper levels of the tree can

        change */

 

 

        mutex_create(ibuf_pessimistic_insert_mutex_key,

                     &ibuf_pessimistic_insert_mutex,

        size = ibuf->size;

        max_size = ibuf->max_size;

 

diff -ruN a/storage/innobase/include/ha_prototypes.h b/storage/innobase/include/ha_prototypes.h

--- a/storage/innobase/include/ha_prototypes.h  2010-11-03 07:01:13.000000000 +0900

+++ b/storage/innobase/include/ha_prototypes.h  2010-12-03 15:10:09.078026360 +0900

 /*===================*/

         void*   thd,   /*!< in: thread handle (THD*) */

         ulint   value);        /*!< in: time waited for the lock */

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";

        ulint           retries = 0;

        ulint           n_total_purged = ULINT_UNDEFINED;

+       ulint           next_itr_time;

 

        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;

 

diff -ruN a/storage/innobase/trx/trx0trx.c b/storage/innobase/trx/trx0trx.c

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

+++ b/storage/innobase/trx/trx0trx.c    2010-12-03 15:10:09.106023937 +0900

        trx->read_view = NULL;

 

        if (lsn) {

 

                mutex_exit(&kernel_mutex);

 

                        trx_undo_insert_cleanup(trx);

                }

 

                /* NOTE that we could possibly make a group commit more

                efficient here: call os_thread_yield here to allow also other

                trxs to come to commit! */

                if (trx->flush_log_later) {

                        /* Do nothing yet */

                        trx->must_flush_log_later = TRUE;

                        if (srv_unix_file_flush_method == SRV_UNIX_NOSYNC) {

                                /* Write the log but do not flush it to disk */

 

 

                                log_write_up_to(lsn, LOG_WAIT_ONE_GROUP, TRUE);

                        }

 

                        /* Write the log but do not flush it to disk */

 

        trx_t*  trx)    /*!< in: trx handle */

 {

        ib_uint64_t     lsn     = trx->commit_lsn;

                if (srv_unix_file_flush_method == SRV_UNIX_NOSYNC) {

                        /* Write the log but do not flush it to disk */

 

 

                        log_write_up_to(lsn, LOG_WAIT_ONE_GROUP, TRUE);

                }

 

                /* Write the log but do not flush it to disk */

 

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

 

        if (lsn) {

                /* Depending on the my.cnf options, we may now write the log

                buffer to the log files, making the prepared state of the

                transaction durable if the OS does not crash. We may also

 

                mutex_exit(&kernel_mutex);

 

                        if (srv_unix_file_flush_method == SRV_UNIX_NOSYNC) {

                                /* Write the log but do not flush it to disk */

 

 

                                log_write_up_to(lsn, LOG_WAIT_ONE_GROUP, TRUE);

                        }