Merge lp:~vlad-lesin/percona-server/5.6-sql_timeout into lp:percona-server/5.6

[Vlad Lesin]

New system variable "SQL_TIMEOUT" allows to set limit for query execution time.
If this limit is exceeded the query is killed. SQL_TIMEOUT can be global or
session variable.

The timeout expiration is checked on each db-thread killed state check. If timeout
expires the function that returns thread killed status will return the value which
corresponds to "killed query" status.

Jenkins: http://jenkins.percona.com/view/PS%205.6/job/percona-server-5.6-param/19
Clean 5.6: http://jenkins.percona.com/view/PS%205.6/job/percona-server-5.6-param/20

There can be some issues during merging as THD::killed was renamed to THD::killed_status and became private. But there are getter THD::get_killed() and setter THD::set_killed() which can be used to resolve issues if some new code work with THD::killed.

[lp:~vlad-lesin/percona-server/5.6-sql_timeout]

311. By Vlad Lesin on 2013-01-09

New system variable "SQL_TIMEOUT" allows to set limit for query execution time.
If this limit is exceeded the query is killed. SQL_TIMEOUT can be global or
session variable.

The timeout expiration is checked on each db-thread killed state check. If timeout
expires the function that returns thread killed status will return the value which
corresponds to "killed query" status.

[Vlad Lesin (vlad-lesin)]

Failed perfschema.threads_mysql test is fixed now.

[Alexey Kopytov (akopytov)]

Vlad,

  - generally I would use check_killed() instead of get_killed(). yes,
    that would be a bit inconsistent naming with set_killed(), but that
    would also make porting APC easier, should we need to do so.
  - mysqld--help-win.result also needs an adjustment
  - setting sql_timeout_expire in mysql_parse() prevents the feature
    from working with client API prepared statements. this check should
    be done in dispatch_command()
  - doing it in dispatch_command() will also make statement-based
    replication immune to sql_timeout. which is good.
  - many lines use tabs for indentation. you can get them with the
    following command:

  bzr diff -c-1 | grep "+\t"

  - changes in merge_buffers() in filesort.cc break the logic it used
    previously, i.e. check the killed state on each iteration in the
    "while" loop, unless param->not_killable is set.

    What we do now is: check the killed state before executing the loop,
    reset it if param->not_killable is set, then check the same value
    inside the loop. See how that code has been changed in MariaDB to
    support APC.

  - same problem as above in storage/myisam/sort.c

  - in Interruptible_wait::wait() we check for the killed status, but
    only after waiting for the full timeout value, which means up to 5
    seconds. Why not do a similar check as with the m_abs_timeout? In
    this case you don't even need a call to m_thd->get_killed() as it
    will be checked by the caller.

  - another problem from the above code is that checking get_killed()
    and resetting the error in Interruptible_wait::wait() returns a
    normal status to the user. I.e. SELECT SLEEP(N) should fail "ERROR
    1317 (70100): Query execution was interrupted" when the timeout is
    exceeded, but it doesn't. Same with user-level locks.

  - in get_killed(), I'd rewrite it like this to not rely on how smart
    is the compiler:

    if (!sql_timeout_expire)
      return killed_status;
    return (my_micro_time() >= sql_timeout_expire) ? THD::KILL_QUERY :
                                                     killed_status;

  - I wonder if we really need my_micro_time() for this. my_time() has
    1 second resolution (which is sufficient in this case) and is also
    faster.

  - in MyISAM code, I would use thd_killed() and keep the killed_ptr()
    name in the same way it is implemented in MariaDB.

review: Needs Fixing

[Alexey Kopytov (akopytov)]

Vlad,

Please also update the BP. It should contain everything Hrvoje needs to know to document the feature.

Unmerged revisions

311. By Vlad Lesin on 2013-01-09

New system variable "SQL_TIMEOUT" allows to set limit for query execution time.
If this limit is exceeded the query is killed. SQL_TIMEOUT can be global or
session variable.

The timeout expiration is checked on each db-thread killed state check. If timeout
expires the function that returns thread killed status will return the value which
corresponds to "killed query" status.

=== modified file 'Percona-Server/mysql-test/r/mysqld--help-notwin.result'
--- Percona-Server/mysql-test/r/mysqld--help-notwin.result	2012-12-04 08:24:59 +0000
+++ Percona-Server/mysql-test/r/mysqld--help-notwin.result	2013-01-09 13:41:38 +0000
@@ -894,6 +894,7 @@
  replication.
  --sql-mode=name     Syntax: sql-mode=mode[,mode[,mode...]]. See the manual
  for the complete list of valid sql modes
+ --sql-timeout=#     Timeout in seconds to wait before killing query.
  --stored-program-cache=# 
  The soft upper limit for number of cached stored routines
  for one connection.
@@ -1233,6 +1234,7 @@
 sort-buffer-size 262144
 sporadic-binlog-dump-fail FALSE
 sql-mode NO_ENGINE_SUBSTITUTION
+sql-timeout 0
 stored-program-cache 256
 symbolic-links FALSE
 sync-binlog 0
 
=== added file 'Percona-Server/mysql-test/r/percona_sql_timeout.result'
--- Percona-Server/mysql-test/r/percona_sql_timeout.result	1970-01-01 00:00:00 +0000
+++ Percona-Server/mysql-test/r/percona_sql_timeout.result	2013-01-09 13:41:38 +0000
@@ -0,0 +1,120 @@
+SLEEP(1)
+0
+SLEEP(1000)
+1
+SLEEP(2)
+0
+SLEEP(1)
+0
+SLEEP(1000)
+1
+SLEEP(2)
+0
+SLEEP(1)
+0
+SLEEP(1000)
+1
+SLEEP(2)
+0
+SLEEP(1)
+0
+SLEEP(1000)
+1
+SLEEP(2)
+0
+SLEEP(1)
+0
+SLEEP(1000)
+1
+SLEEP(2)
+0
+SLEEP(1)
+0
+SLEEP(1000)
+1
+SLEEP(2)
+0
+SLEEP(1)
+0
+SLEEP(1000)
+1
+SLEEP(2)
+0
+SLEEP(1)
+0
+SLEEP(1000)
+1
+SLEEP(2)
+0
+SLEEP(1)
+0
+SLEEP(1000)
+1
+SLEEP(2)
+0
+SLEEP(1)
+0
+SLEEP(1000)
+1
+SLEEP(2)
+0
+SLEEP(1)
+0
+SLEEP(1000)
+1
+SLEEP(2)
+0
+SLEEP(1)
+0
+SLEEP(1000)
+1
+SLEEP(2)
+0
+SLEEP(1)
+0
+SLEEP(1000)
+1
+SLEEP(2)
+0
+SLEEP(1)
+0
+SLEEP(1000)
+1
+SLEEP(2)
+0
+SLEEP(1)
+0
+SLEEP(1000)
+1
+SLEEP(2)
+0
+SLEEP(1)
+0
+SLEEP(1000)
+1
+SLEEP(2)
+0
+SLEEP(1)
+0
+SLEEP(1000)
+1
+SLEEP(2)
+0
+SLEEP(1)
+0
+SLEEP(1000)
+1
+SLEEP(2)
+0
+SLEEP(1)
+0
+SLEEP(1000)
+1
+SLEEP(2)
+0
+SLEEP(1)
+0
+SLEEP(1000)
+1
+SLEEP(2)
+0
 
=== added file 'Percona-Server/mysql-test/suite/sys_vars/r/sql_timeout_basic.result'
--- Percona-Server/mysql-test/suite/sys_vars/r/sql_timeout_basic.result	1970-01-01 00:00:00 +0000
+++ Percona-Server/mysql-test/suite/sys_vars/r/sql_timeout_basic.result	2013-01-09 13:41:38 +0000
@@ -0,0 +1,151 @@
+SET @start_global_value = @@global.sql_timeout;
+SELECT @start_global_value;
+@start_global_value
+0
+SET @start_session_value = @@session.sql_timeout;
+SELECT @start_session_value;
+@start_session_value
+0
+'#--------------------FN_DYNVARS_083_01-------------------------#'
+SET @@global.sql_timeout = 100;
+SET @@global.sql_timeout = DEFAULT;
+SELECT @@global.sql_timeout;
+@@global.sql_timeout
+0
+SET @@session.sql_timeout = 200;
+SET @@session.sql_timeout = DEFAULT;
+SELECT @@session.sql_timeout;
+@@session.sql_timeout
+0
+'#--------------------FN_DYNVARS_083_03-------------------------#'
+SET @@global.sql_timeout = 100;
+SELECT @@global.sql_timeout;
+@@global.sql_timeout
+100
+SET @@global.sql_timeout = 200;
+SELECT @@global.sql_timeout;
+@@global.sql_timeout
+200
+SET @@global.sql_timeout = 65536;
+SELECT @@global.sql_timeout;
+@@global.sql_timeout
+65536
+SET @@global.sql_timeout = 4294967295;
+SELECT @@global.sql_timeout;
+@@global.sql_timeout
[phone]
+SET @@global.sql_timeout = 4294967294;
+SELECT @@global.sql_timeout;
+@@global.sql_timeout
[phone]
+'#--------------------FN_DYNVARS_083_04-------------------------#'
+SET @@session.sql_timeout = 100;
+SELECT @@session.sql_timeout;
+@@session.sql_timeout
+100
+SET @@session.sql_timeout = 200;
+SELECT @@session.sql_timeout;
+@@session.sql_timeout
+200
+SET @@session.sql_timeout = 4294967295;
+SELECT @@session.sql_timeout;
+@@session.sql_timeout
[phone]
+SET @@session.sql_timeout = 4294967294;
+SELECT @@session.sql_timeout;
+@@session.sql_timeout
[phone]
+SET @@session.sql_timeout = 65535;
+SELECT @@session.sql_timeout;
+@@session.sql_timeout
+65535
+'#------------------FN_DYNVARS_083_05-----------------------#'
+SET @@global.sql_timeout = 0;
+SELECT @@global.sql_timeout;
+@@global.sql_timeout
+0
+SET @@global.sql_timeout = -1024;
+Warnings:
+Warning	1292	Truncated incorrect sql_timeout value: '-1024'
+SELECT @@global.sql_timeout;
+@@global.sql_timeout
+0
+SET @@global.sql_timeout = 65530.34;
+ERROR 42000: Incorrect argument type to variable 'sql_timeout'
+SELECT @@global.sql_timeout;
+@@global.sql_timeout
+0
+SET @@global.sql_timeout = test;
+ERROR 42000: Incorrect argument type to variable 'sql_timeout'
+SELECT @@global.sql_timeout;
+@@global.sql_timeout
+0
+SET @@session.sql_timeout = 0;
+SELECT @@session.sql_timeout;
+@@session.sql_timeout
+0
+SET @@session.sql_timeout = -2;
+Warnings:
+Warning	1292	Truncated incorrect sql_timeout value: '-2'
+SELECT @@session.sql_timeout;
+@@session.sql_timeout
+0
+SET @@session.sql_timeout = 65530.34;
+ERROR 42000: Incorrect argument type to variable 'sql_timeout'
+SELECT @@session.sql_timeout;
+@@session.sql_timeout
+0
+SET @@session.sql_timeout = test;
+ERROR 42000: Incorrect argument type to variable 'sql_timeout'
+SELECT @@session.sql_timeout;
+@@session.sql_timeout
+0
+'#------------------FN_DYNVARS_083_06-----------------------#'
+SELECT @@global.sql_timeout = VARIABLE_VALUE
+FROM INFORMATION_SCHEMA.GLOBAL_VARIABLES
+WHERE VARIABLE_NAME='sql_timeout';
+@@global.sql_timeout = VARIABLE_VALUE
+1
+'#------------------FN_DYNVARS_083_07-----------------------#'
+SELECT @@session.sql_timeout = VARIABLE_VALUE
+FROM INFORMATION_SCHEMA.SESSION_VARIABLES
+WHERE VARIABLE_NAME='sql_timeout';
+@@session.sql_timeout = VARIABLE_VALUE
+1
+'#------------------FN_DYNVARS_083_08-----------------------#'
+SET @@global.sql_timeout = FALSE;
+SELECT @@global.sql_timeout;
+@@global.sql_timeout
+0
+'#---------------------FN_DYNVARS_083_09----------------------#'
+SET @@global.sql_timeout = 100;
+SELECT @@sql_timeout = @@global.sql_timeout;
+@@sql_timeout = @@global.sql_timeout
+0
+'#---------------------FN_DYNVARS_083_10----------------------#'
+SET @@sql_timeout = 1000;
+SELECT @@sql_timeout = @@local.sql_timeout;
+@@sql_timeout = @@local.sql_timeout
+1
+SELECT @@local.sql_timeout = @@session.sql_timeout;
+@@local.sql_timeout = @@session.sql_timeout
+1
+'#---------------------FN_DYNVARS_083_11----------------------#'
+SET sql_timeout = 100;
+SELECT @@sql_timeout;
+@@sql_timeout
+100
+SELECT local.sql_timeout;
+ERROR 42S02: Unknown table 'local' in field list
+SELECT session.sql_timeout;
+ERROR 42S02: Unknown table 'session' in field list
+SELECT sql_timeout = @@session.sql_timeout;
+ERROR 42S22: Unknown column 'sql_timeout' in 'field list'
+SET @@global.sql_timeout = @start_global_value;
+SELECT @@global.sql_timeout;
+@@global.sql_timeout
+0
+SET @@session.sql_timeout = @start_session_value;
+SELECT @@session.sql_timeout;
+@@session.sql_timeout
+0
 
=== added file 'Percona-Server/mysql-test/suite/sys_vars/t/sql_timeout_basic.test'
--- Percona-Server/mysql-test/suite/sys_vars/t/sql_timeout_basic.test	1970-01-01 00:00:00 +0000
+++ Percona-Server/mysql-test/suite/sys_vars/t/sql_timeout_basic.test	2013-01-09 13:41:38 +0000
@@ -0,0 +1,194 @@
+############mysql-test\suite\sysvars\t\sql_timeout_basic.test##################
+#                                                                             #
+# Variable Name: sql_timeout                                                  #
+# Scope: GLOBAL | SESSION                                                     #
+# Access Type: Dynamic                                                        #
+# Data Type: numeric                                                          #
+# Default Value:  0                                                           #
+# Range:  1-4294967295                                                        #
+#                                                                             #
+#                                                                             #
+# Creation Date: 2012-02-08                                                   #
+# Author:  Vlad Lesin                                                         #
+#                                                                             #
+# Description: Test Cases of Dynamic System Variable sql_timeout              #
+#              that checks the behavior of this variable in the following ways#
+#              * Default Value                                                #
+#              * Valid & Invalid values                                       #
+#              * Scope & Access method                                        #
+#              * Data Integrity                                               #
+#                                                                             #
+# Reference: none                                                             #
+#    https://blueprints.launchpad.net/percona-server/+spec/sql-timeout        #
+#                                                                             #
+#                                                                             #
+###############################################################################
+
+############################################################
+#           START OF sql_timeout TESTS                     #
+############################################################
+
+
+#############################################################
+#                 Save initial value                        #
+#############################################################
+
+SET @start_global_value = @@global.sql_timeout;
+SELECT @start_global_value;
+SET @start_session_value = @@session.sql_timeout;
+SELECT @start_session_value;
+
+
+--echo '#--------------------FN_DYNVARS_083_01-------------------------#'
+#################################################################
+#     Display the DEFAULT value of sql_timeout                  #
+#################################################################
+
+SET @@global.sql_timeout = 100;
+SET @@global.sql_timeout = DEFAULT;
+SELECT @@global.sql_timeout;
+
+SET @@session.sql_timeout = 200;
+SET @@session.sql_timeout = DEFAULT;
+SELECT @@session.sql_timeout;
+
+--echo '#--------------------FN_DYNVARS_083_03-------------------------#'
+###########################################################################
+# Change the value of sql_timeout to a valid value for GLOBAL Scope       #
+###########################################################################
+
+SET @@global.sql_timeout = 100;
+SELECT @@global.sql_timeout;
+SET @@global.sql_timeout = 200;
+SELECT @@global.sql_timeout;
+SET @@global.sql_timeout = 65536;
+SELECT @@global.sql_timeout;
+SET @@global.sql_timeout = 4294967295;
+SELECT @@global.sql_timeout;
+SET @@global.sql_timeout = 4294967294;
+SELECT @@global.sql_timeout;
+
+
+--echo '#--------------------FN_DYNVARS_083_04-------------------------#'
+############################################################################
+# Change the value of sql_timeout to a valid value for SESSION Scope       #
+############################################################################
+SET @@session.sql_timeout = 100;
+SELECT @@session.sql_timeout;
+SET @@session.sql_timeout = 200;
+SELECT @@session.sql_timeout;
+SET @@session.sql_timeout = 4294967295;
+SELECT @@session.sql_timeout;
+SET @@session.sql_timeout = 4294967294;
+SELECT @@session.sql_timeout;
+SET @@session.sql_timeout = 65535;
+SELECT @@session.sql_timeout;
+
+
+--echo '#------------------FN_DYNVARS_083_05-----------------------#'
+#############################################################
+# Change the value of sql_timeout to an invalid value       #
+#############################################################
+
+SET @@global.sql_timeout = 0;
+SELECT @@global.sql_timeout;
+SET @@global.sql_timeout = -1024;
+SELECT @@global.sql_timeout;
+--Error ER_WRONG_TYPE_FOR_VAR
+SET @@global.sql_timeout = 65530.34;
+SELECT @@global.sql_timeout;
+--Error ER_WRONG_TYPE_FOR_VAR
+SET @@global.sql_timeout = test;
+SELECT @@global.sql_timeout;
+
+SET @@session.sql_timeout = 0;
+SELECT @@session.sql_timeout;
+SET @@session.sql_timeout = -2;
+SELECT @@session.sql_timeout;
+--Error ER_WRONG_TYPE_FOR_VAR
+SET @@session.sql_timeout = 65530.34;
+SELECT @@session.sql_timeout;
+
+--Error ER_WRONG_TYPE_FOR_VAR
+SET @@session.sql_timeout = test;
+SELECT @@session.sql_timeout;
+
+
+--echo '#------------------FN_DYNVARS_083_06-----------------------#'
+####################################################################
+#   Check if the value in GLOBAL Table matches value in variable   #
+####################################################################
+
+
+SELECT @@global.sql_timeout = VARIABLE_VALUE
+FROM INFORMATION_SCHEMA.GLOBAL_VARIABLES
+WHERE VARIABLE_NAME='sql_timeout';
+
+--echo '#------------------FN_DYNVARS_083_07-----------------------#'
+####################################################################
+#  Check if the value in SESSION Table matches value in variable   #
+####################################################################
+
+SELECT @@session.sql_timeout = VARIABLE_VALUE
+FROM INFORMATION_SCHEMA.SESSION_VARIABLES
+WHERE VARIABLE_NAME='sql_timeout';
+
+
+--echo '#------------------FN_DYNVARS_083_08-----------------------#'
+####################################################################
+#     Check if FALSE value can be used on variable                 #
+####################################################################
+
+SET @@global.sql_timeout = FALSE;
+SELECT @@global.sql_timeout;
+
+
+--echo '#---------------------FN_DYNVARS_083_09----------------------#'
+#############################################################################
+#  Check if accessing variable with and without GLOBAL point                #
+#  to same variable                                                         #
+#############################################################################
+
+SET @@global.sql_timeout = 100;
+SELECT @@sql_timeout = @@global.sql_timeout;
+
+
+--echo '#---------------------FN_DYNVARS_083_10----------------------#'
+#############################################################################
+#  Check if accessing variable with SESSION,LOCAL and without SCOPE points  #
+#  to same session variable                                                 #
+#############################################################################
+
+SET @@sql_timeout = 1000;
+SELECT @@sql_timeout = @@local.sql_timeout;
+SELECT @@local.sql_timeout = @@session.sql_timeout;
+
+
+--echo '#---------------------FN_DYNVARS_083_11----------------------#'
+############################################################################
+#   Check if sql_timeout can be accessed with and without @@ sign          #
+############################################################################
+
+SET sql_timeout = 100;
+SELECT @@sql_timeout;
+--Error ER_UNKNOWN_TABLE
+SELECT local.sql_timeout;
+--Error ER_UNKNOWN_TABLE
+SELECT session.sql_timeout;
+--Error ER_BAD_FIELD_ERROR
+SELECT sql_timeout = @@session.sql_timeout;
+
+
+####################################
+#    Restore initial value         #
+####################################
+
+SET @@global.sql_timeout = @start_global_value;
+SELECT @@global.sql_timeout;
+SET @@session.sql_timeout = @start_session_value;
+SELECT @@session.sql_timeout;
+
+
+#############################################################
+#                END OF sql_timeout TESTS                   #
+#############################################################
 
=== added file 'Percona-Server/mysql-test/t/percona_sql_timeout.test'
--- Percona-Server/mysql-test/t/percona_sql_timeout.test	1970-01-01 00:00:00 +0000
+++ Percona-Server/mysql-test/t/percona_sql_timeout.test	2013-01-09 13:41:38 +0000
@@ -0,0 +1,82 @@
+#
+#   SQL_TIMEOUT test
+#
+#   SQL_TIMEOUT is a session variable or
+#   query keyword which sets the time
+#   limit for query execution.
+
+# Save the initial number of concurrent sessions
+--source include/count_sessions.inc
+
+
+--disable_query_log
+
+--let $sessions_count=10
+--let $sessions_prepared_count=10
+
+--let $i=$sessions_count
+while ($i) {
+--dec $i
+--let $connection_name=connection_$i
+--connect ($connection_name,localhost,root,,)
+--delimiter +++
+  let $statement=
+  SELECT SLEEP(1);
+  SET @@SESSION.SQL_TIMEOUT = 1;
+  SELECT SLEEP(1000);
+  SET @@SESSION.SQL_TIMEOUT = 0;
+  SELECT SLEEP(2);
++++
+--delimiter ;
+--send_eval $statement
+}
+
+--let $i=$sessions_prepared_count
+while ($i) {
+--dec $i
+--let $ti=$sessions_count+$i
+--let $connection_name=connection_$ti
+--connect ($connection_name,localhost,root,,)
+--delimiter +++
+  let $statement=
+  PREPARE P_1_$i FROM 'SELECT SLEEP(1)';
+  PREPARE P_2_$i FROM 'SET @@SESSION.SQL_TIMEOUT = 1';
+  PREPARE P_3_$i FROM 'SELECT SLEEP(1000)';
+  PREPARE P_4_$i FROM 'SET @@SESSION.SQL_TIMEOUT = 0';
+  PREPARE P_5_$i FROM 'SELECT SLEEP(2)';
+  EXECUTE P_1_$i;
+  EXECUTE P_2_$i;
+  EXECUTE P_3_$i;
+  EXECUTE P_4_$i;
+  EXECUTE P_5_$i;
++++
+--delimiter ;
+--send_eval $statement
+}
+
+--let $i=$sessions_count
+while ($i) {
+--dec $i
+--let $connection_name=connection_$i
+--connection $connection_name
+--reap
+--disconnect $connection_name
+}
+
+--let $i=$sessions_prepared_count
+while ($i) {
+--dec $i
+--let $ti=$sessions_count+$i
+--let $connection_name=connection_$ti
+--connection $connection_name
+--reap
+--eval DROP PREPARE P_1_$i
+--eval DROP PREPARE P_2_$i
+--eval DROP PREPARE P_3_$i
+--eval DROP PREPARE P_4_$i
+--eval DROP PREPARE P_5_$i
+--disconnect $connection_name
+}
+
+--connection default
+--source include/wait_until_count_sessions.inc
 
=== modified file 'Percona-Server/sql/binlog.cc'
--- Percona-Server/sql/binlog.cc	2012-12-04 08:24:59 +0000
+++ Percona-Server/sql/binlog.cc	2013-01-09 13:41:38 +0000
@@ -1573,7 +1573,7 @@
     append_identifier(thd, &log_query, thd->lex->ident.str,
                       thd->lex->ident.length);
 
-  int errcode= query_error_code(thd, thd->killed == THD::NOT_KILLED);
+  int errcode= query_error_code(thd, thd->get_killed() == THD::NOT_KILLED);
   Query_log_event qinfo(thd, log_query.c_ptr_safe(), log_query.length(),
                         TRUE, FALSE, TRUE, errcode);
   /* 
@@ -1615,7 +1615,7 @@
         log_query.append(thd->lex->ident.str, thd->lex->ident.length) ||
         log_query.append("`"))
       DBUG_RETURN(1);
-    int errcode= query_error_code(thd, thd->killed == THD::NOT_KILLED);
+    int errcode= query_error_code(thd, thd->get_killed() == THD::NOT_KILLED);
     Query_log_event qinfo(thd, log_query.c_ptr_safe(), log_query.length(),
                           TRUE, FALSE, TRUE, errcode);
     DBUG_RETURN(mysql_bin_log.write_event(&qinfo));
@@ -1930,7 +1930,7 @@
 {
   int error;
   
-  if (not_killed || (thd->killed == THD::KILL_BAD_DATA))
+  if (not_killed || (thd->get_killed() == THD::KILL_BAD_DATA))
   {
     error= thd->is_error() ? thd->get_stmt_da()->sql_errno() : 0;
 
 
=== modified file 'Percona-Server/sql/debug_sync.cc'
--- Percona-Server/sql/debug_sync.cc	2012-08-22 01:40:20 +0000
+++ Percona-Server/sql/debug_sync.cc	2013-01-09 13:41:38 +0000
@@ -224,10 +224,10 @@
   mysql_mutex_lock(&mutex);
   thd->enter_cond(&condition_variable, &mutex, new_message);
   #if defined(ENABLE_DEBUG_SYNC)
-  if (!thd->killed && !end_of_wait_condition)
+  if (!thd->get_killed() && !end_of_wait_condition)
      DEBUG_SYNC(thd, "sync_point_name");
   #endif
-  while (!thd->killed && !end_of_wait_condition)
+  while (!thd->get_killed() && !end_of_wait_condition)
     mysql_cond_wait(&condition_variable, &mutex);
   thd->exit_cond(old_message);
 
@@ -262,11 +262,11 @@
   A bit off-topic: At some places, the loop is taken around the whole
   synchronization pattern:
 
-  while (!thd->killed && !end_of_wait_condition)
+  while (!thd->get_killed() && !end_of_wait_condition)
   {
     mysql_mutex_lock(&mutex);
     thd->enter_cond(&condition_variable, &mutex, new_message);
-    if (!thd->killed [&& !end_of_wait_condition])
+    if (!thd->get_killed() [&& !end_of_wait_condition])
     {
       [DEBUG_SYNC(thd, "sync_point_name");]
       mysql_cond_wait(&condition_variable, &mutex);
@@ -274,9 +274,9 @@
     thd->exit_cond(old_message);
   }
 
-  Note that it is important to repeat the test for thd->killed after
+  Note that it is important to repeat the test for thd->get_killed() after
   enter_cond(). Otherwise the killing thread may kill this thread after
-  it tested thd->killed in the loop condition and before it registered
+  it tested thd->get_killed() in the loop condition and before it registered
   the condition variable and mutex in enter_cond(). In this case, the
   killing thread does not know that this thread is going to wait on a
   condition variable. It would just set THD::killed. But if we would not
@@ -1123,13 +1123,13 @@
       point decremented it to 0. In this case the following happened:
 
       - an error message was reported with my_error() and
-      - the statement was killed with thd->killed= THD::KILL_QUERY.
+      - the statement was killed with thd->get_killed()= THD::KILL_QUERY.
 
       If a statement reports an error, it must not call send_ok().
       The calling functions will not call send_ok(), if we return TRUE
       from this function.
 
-      thd->killed is also set if the wait is interrupted from a
+      thd->get_killed() is also set if the wait is interrupted from a
       KILL or KILL QUERY statement. In this case, no error is reported
       and shall not be reported as a result of SET DEBUG_SYNC.
       Hence, we check for the first condition above.
@@ -1775,7 +1775,7 @@
         the required dynamic memory allocated.
       */
       while (stringcmp(&debug_sync_global.ds_signal, &action->wait_for) &&
-             !thd->killed && opt_debug_sync_timeout)
+             !thd->get_killed() && opt_debug_sync_timeout)
       {
         error= mysql_cond_timedwait(&debug_sync_global.ds_cond,
                                     &debug_sync_global.ds_mutex,
@@ -1800,10 +1800,10 @@
         error= 0;
       }
       DBUG_EXECUTE("debug_sync_exec",
-                   if (thd->killed)
+                   if (thd->get_killed())
                      DBUG_PRINT("debug_sync_exec",
                                 ("killed %d from '%s'  at: '%s'",
-                                 thd->killed, sig_wait, dsp_name));
+                                 thd->get_killed(), sig_wait, dsp_name));
                    else
                      DBUG_PRINT("debug_sync_exec",
                                 ("%s from '%s'  at: '%s'",
@@ -1842,7 +1842,7 @@
   {
     if (!--action->hit_limit)
     {
-      thd->killed= THD::KILL_QUERY;
+      thd->set_killed(THD::KILL_QUERY);
       my_error(ER_DEBUG_SYNC_HIT_LIMIT, MYF(0));
     }
     DBUG_PRINT("debug_sync_exec", ("hit_limit: %lu  at: '%s'",
 
=== modified file 'Percona-Server/sql/event_queue.cc'
--- Percona-Server/sql/event_queue.cc	2011-09-07 10:08:09 +0000
+++ Percona-Server/sql/event_queue.cc	2013-01-09 13:41:38 +0000
@@ -575,9 +575,9 @@
     Event_queue_element *top= NULL;
 
     /* Break loop if thd has been killed */
-    if (thd->killed)
+    if (thd->get_killed())
     {
-      DBUG_PRINT("info", ("thd->killed=%d", thd->killed));
+      DBUG_PRINT("info", ("thd->get_killed()=%d", thd->get_killed()));
       goto end;
     }
 
@@ -754,7 +754,7 @@
 
   thd->enter_cond(&COND_queue_state, &LOCK_event_queue, stage, NULL, src_func, src_file, src_line);
 
-  if (!thd->killed)
+  if (!thd->get_killed())
   {
     if (!abstime)
       mysql_cond_wait(&COND_queue_state, &LOCK_event_queue);
 
=== modified file 'Percona-Server/sql/event_scheduler.cc'
--- Percona-Server/sql/event_scheduler.cc	2012-08-22 01:40:20 +0000
+++ Percona-Server/sql/event_scheduler.cc	2013-01-09 13:41:38 +0000
@@ -495,7 +495,7 @@
     }
     else
     {
-      DBUG_ASSERT(thd->killed);
+      DBUG_ASSERT(thd->get_killed());
       DBUG_PRINT("info", ("job_data is NULL, the thread was killed"));
     }
     DBUG_PRINT("info", ("state=%s", scheduler_states_names[state].str));
 
=== modified file 'Percona-Server/sql/filesort.cc'
--- Percona-Server/sql/filesort.cc	2012-12-04 08:24:59 +0000
+++ Percona-Server/sql/filesort.cc	2013-01-09 13:41:38 +0000
@@ -684,7 +684,6 @@
   my_off_t record;
   TABLE *sort_form;
   THD *thd= current_thd;
-  volatile THD::killed_state *killed= &thd->killed;
   handler *file;
   MY_BITMAP *save_read_set, *save_write_set;
   bool skip_record;
@@ -774,7 +773,7 @@
 	break;
     }
 
-    if (*killed)
+    if (thd->get_killed())
     {
       DBUG_PRINT("info",("Sort killed by user"));
       if (!quick_select)
@@ -1567,15 +1566,13 @@
   QUEUE queue;
   qsort2_cmp cmp;
   void *first_cmp_arg;
-  volatile THD::killed_state *killed= &current_thd->killed;
-  THD::killed_state not_killable;
+  THD::killed_state killed= current_thd->get_killed();
   DBUG_ENTER("merge_buffers");
 
   current_thd->inc_status_sort_merge_passes();
   if (param->not_killable)
   {
-    killed= &not_killable;
-    not_killable= THD::NOT_KILLED;
+    killed= THD::NOT_KILLED;
   }
 
   error=0;
@@ -1646,7 +1643,7 @@
 
   while (queue.elements > 1)
   {
-    if (*killed)
+    if (killed)
     {
       error= 1; goto err;                        /* purecov: inspected */
     }
 
=== modified file 'Percona-Server/sql/ha_ndbcluster.cc'
--- Percona-Server/sql/ha_ndbcluster.cc	2012-08-22 01:40:20 +0000
+++ Percona-Server/sql/ha_ndbcluster.cc	2013-01-09 13:41:38 +0000
@@ -4971,7 +4971,7 @@
       Ndb_tuple_id_range_guard g(m_share);
       if (ndb->getAutoIncrementValue(m_table, g.range, auto_value, 1000) == -1)
       {
-	if (--retries && !thd->killed &&
+	if (--retries && !thd->get_killed() &&
 	    ndb->getNdbError().status == NdbError::TemporaryError)
 	{
 	  do_retry_sleep(retry_sleep);
@@ -8998,7 +8998,7 @@
           Ndb_tuple_id_range_guard g(m_share);
           if (ndb->readAutoIncrementValue(ndbtab, g.range, auto_value))
           {
-            if (--retries && !thd->killed &&
+            if (--retries && !thd->get_killed() &&
                 ndb->getNdbError().status == NdbError::TemporaryError)
             {
               do_retry_sleep(retry_sleep);
@@ -9628,7 +9628,7 @@
       Failed to create an index,
       drop the table (and all it's indexes)
     */
-    while (!thd->killed)
+    while (!thd->get_killed())
     {
       if (dict->beginSchemaTrans() == -1)
         goto cleanup_failed;
@@ -9637,7 +9637,7 @@
         switch (dict->getNdbError().status)
         {
         case NdbError::TemporaryError:
-          if (!thd->killed) 
+          if (!thd->get_killed()) 
           {
             if (dict->endSchemaTrans(NdbDictionary::Dictionary::SchemaTransAbort)
                 == -1)
@@ -10238,7 +10238,7 @@
       switch (dict->getNdbError().status)
       {
         case NdbError::TemporaryError:
-          if (!thd->killed) 
+          if (!thd->get_killed()) 
             goto retry_temporary_error1; // retry indefinitly
           break;
         default:
@@ -10270,7 +10270,7 @@
           switch (dict->getNdbError().status)
           {
             case NdbError::TemporaryError:
-              if (!thd->killed) 
+              if (!thd->get_killed()) 
                 goto retry_temporary_error2; // retry indefinitly
               break;
             default:
@@ -10426,7 +10426,7 @@
                                    Uint32(m_autoincrement_prefetch), 
                                    increment, offset))
     {
-      if (--retries && !thd->killed &&
+      if (--retries && !thd->get_killed() &&
           ndb->getNdbError().status == NdbError::TemporaryError)
       {
         do_retry_sleep(retry_sleep);
@@ -10734,7 +10734,7 @@
   }
   while((result= th.next()) == 1)
   {
-    if (thd->killed)
+    if (thd->get_killed())
       DBUG_RETURN(-1);
     my_sleep(1000*delay);
   }
@@ -10746,7 +10746,7 @@
   };
   for (i= 0; i < MAX_KEY; i++)
   {
-    if (thd->killed)
+    if (thd->get_killed())
       DBUG_RETURN(-1);
     if (m_index[i].status == ACTIVE)
     {
@@ -10765,7 +10765,7 @@
         }
         while((result= ih.next()) == 1)
         {
-          if (thd->killed)
+          if (thd->get_killed())
             DBUG_RETURN(-1);
           my_sleep(1000*delay);        
         }
@@ -10787,7 +10787,7 @@
         } 
         while((result= ih.next()) == 1)
         {
-          if (thd->killed)
+          if (thd->get_killed())
             DBUG_RETURN(-1);
           my_sleep(1000*delay);
         }
@@ -13451,7 +13451,7 @@
       pTrans= NULL;
     }
     if (error.status == NdbError::TemporaryError &&
-        retries-- && !thd->killed)
+        retries-- && !thd->get_killed())
     {
       do_retry_sleep(retry_sleep);
       continue;
 
=== modified file 'Percona-Server/sql/ha_ndbcluster_binlog.cc'
--- Percona-Server/sql/ha_ndbcluster_binlog.cc	2012-12-04 08:24:59 +0000
+++ Percona-Server/sql/ha_ndbcluster_binlog.cc	2013-01-09 13:41:38 +0000
@@ -485,7 +485,7 @@
       thd->proc_info= "Waiting for ndbcluster binlog update to "
 	"reach current position";
     pthread_mutex_lock(&injector_mutex);
-    while (!(thd && thd->killed) && count && ndb_binlog_running &&
+    while (!(thd && thd->get_killed()) && count && ndb_binlog_running &&
            (ndb_latest_handled_binlog_epoch == 0 ||
             ndb_latest_handled_binlog_epoch < wait_epoch))
     {
@@ -1291,7 +1291,7 @@
       ndb->closeTransaction(trans);
       trans= NULL;
     }
-    if (ndb_error.status == NdbError::TemporaryError && !thd->killed)
+    if (ndb_error.status == NdbError::TemporaryError && !thd->get_killed())
     {
       if (retries--)
       {
@@ -1302,7 +1302,7 @@
         continue; // retry
       }
     }
-    if (!thd->killed)
+    if (!thd->get_killed())
     {
       sql_print_error("NDB: ndbcluster_find_all_databases fail: %u - %s",
                       ndb_error.code,
@@ -1663,7 +1663,7 @@
   err:
     const NdbError *this_error= trans ?
       &trans->getNdbError() : &ndb->getNdbError();
-    if (this_error->status == NdbError::TemporaryError && !thd->killed)
+    if (this_error->status == NdbError::TemporaryError && !thd->get_killed())
     {
       if (retries--)
       {
@@ -2128,7 +2128,7 @@
 err:
     const NdbError *this_error= trans ?
       &trans->getNdbError() : &ndb->getNdbError();
-    if (this_error->status == NdbError::TemporaryError && !thd->killed)
+    if (this_error->status == NdbError::TemporaryError && !thd->get_killed())
     {
       if (retries--)
       {
@@ -2183,7 +2183,7 @@
       int ret= pthread_cond_timedwait(&injector_cond,
                                       &ndb_schema_object->mutex,
                                       &abstime);
-      if (thd->killed)
+      if (thd->get_killed())
         break;
 
       /* begin protect ndb_schema_share */
@@ -2424,7 +2424,7 @@
   char *thd_db_save= thd->db;
   thd->server_id = loggedServerId;
   thd->db= schema->db;
-  int errcode = query_error_code(thd, thd->killed == THD::NOT_KILLED);
+  int errcode = query_error_code(thd, thd->get_killed() == THD::NOT_KILLED);
   thd->binlog_query(THD::STMT_QUERY_TYPE, schema->query,
                     schema->query_length, FALSE,
 #ifdef NDB_THD_BINLOG_QUERY_HAS_DIRECT
@@ -3253,7 +3253,7 @@
     MYSQL_LOCK_IGNORE_TIMEOUT; /* Wait for lock "infinitely" */
   if (open_and_lock_tables(thd, &tables, derived, flags))
   {
-    if (thd->killed)
+    if (thd->get_killed())
       sql_print_error("NDB Binlog: Opening ndb_binlog_index: killed");
     else
       sql_print_error("NDB Binlog: Opening ndb_binlog_index: %d, '%s'",
@@ -5392,7 +5392,7 @@
       share->event_data= event_data;
       op->setCustomData(NULL);
       ndb->dropEventOperation(op);
-      if (retries && !thd->killed)
+      if (retries && !thd->get_killed())
       {
         do_retry_sleep(retry_sleep);
         continue;
@@ -5530,7 +5530,7 @@
     int ret= pthread_cond_timedwait(&injector_cond,
                                     &share->mutex,
                                     &abstime);
-    if (thd->killed ||
+    if (thd->get_killed() ||
         share->op == 0)
       break;
     if (ret)
@@ -7206,15 +7206,15 @@
                  Writing to ndb_binlog_index failed, check if we are
                  being killed and retry
               */
-              if (thd->killed)
+              if (thd->get_killed())
               {
                 (void) mysql_mutex_lock(&LOCK_thread_count);
-                volatile THD::killed_state killed= thd->killed;
+                volatile THD::killed_state killed= thd->get_killed();
                 /* We are cleaning up, allow for flushing last epoch */
-                thd->killed= THD::NOT_KILLED;
+                thd->set_killed(THD::NOT_KILLED);
                 ndb_binlog_index_table__write_rows(thd, rows);
                 /* Restore kill flag */
-                thd->killed= killed;
+                thd->set_killed(killed);
                 (void) mysql_mutex_unlock(&LOCK_thread_count);
               }
             }
 
=== modified file 'Percona-Server/sql/handler.cc'
--- Percona-Server/sql/handler.cc	2012-12-04 08:24:59 +0000
+++ Percona-Server/sql/handler.cc	2013-01-09 13:41:38 +0000
@@ -1603,7 +1603,7 @@
 #endif
   if ((all || thd->transaction.stmt.ha_list == 0) &&
       thd->transaction.all.cannot_safely_rollback() &&
-      !thd->slave_thread && thd->killed != THD::KILL_CONNECTION)
+      !thd->slave_thread && thd->get_killed() != THD::KILL_CONNECTION)
     thd->transaction.push_unsafe_rollback_warnings(thd);
   DBUG_RETURN(error);
 }
@@ -3210,7 +3210,7 @@
     /*
       first test if the query was aborted due to strict mode constraints
     */
-    if (thd->killed == THD::KILL_BAD_DATA)
+    if (thd->get_killed() == THD::KILL_BAD_DATA)
       DBUG_RETURN(HA_ERR_AUTOINC_ERANGE);
 
     /*
@@ -5452,7 +5452,7 @@
 
   @note
     This method (or an overriding one in a derived class) must check for
-    thd->killed and return HA_POS_ERROR if it is not zero. This is required
+    thd->get_killed() and return HA_POS_ERROR if it is not zero. This is required
     for a user to be able to interrupt the calculation by killing the
     connection/query.
 
@@ -5479,12 +5479,12 @@
   /* Default MRR implementation doesn't need buffer */
   *bufsz= 0;
 
-  DBUG_EXECUTE_IF("bug13822652_2", thd->killed= THD::KILL_QUERY;);
+  DBUG_EXECUTE_IF("bug13822652_2", thd->set_killed(THD::KILL_QUERY););
 
   seq_it= seq->init(seq_init_param, n_ranges, *flags);
   while (!seq->next(seq_it, &range))
   {
-    if (unlikely(thd->killed != 0))
+    if (unlikely(thd->get_killed() != 0))
       return HA_POS_ERROR;
     
     n_ranges++;
 
=== modified file 'Percona-Server/sql/item_func.cc'
--- Percona-Server/sql/item_func.cc	2012-12-04 08:24:59 +0000
+++ Percona-Server/sql/item_func.cc	2013-01-09 13:41:38 +0000
@@ -4215,6 +4215,11 @@
     error= mysql_cond_timedwait(cond, mutex, &timeout);
     if (error == ETIMEDOUT || error == ETIME)
     {
+      if (m_thd->get_killed())
+      {
+        error= 0;
+	break;
+      }
       /* Return error if timed out or connection is broken. */
       if (!cmp_timespec(timeout, m_abs_timeout) || !m_thd->is_connected())
         break;
@@ -4312,7 +4317,7 @@
 
   error= 0;
   thd_wait_begin(thd, THD_WAIT_USER_LOCK);
-  while (ull->locked && !thd->killed)
+  while (ull->locked && !thd->get_killed())
   {
     DBUG_PRINT("info", ("waiting on lock"));
     error= timed_cond.wait(&ull->cond, &LOCK_user_locks);
@@ -4332,7 +4337,7 @@
       DBUG_ASSERT(0);
       delete ull;				// Should never happen
     }
-    if (!error)                                 // Killed (thd->killed != 0)
+    if (!error)                                 // Killed (thd->get_killed() != 0)
     {
       error=1;
       null_value=1;				// Return NULL
@@ -4469,7 +4474,7 @@
   }
 
   null_value=0;
-  for (ulonglong loop=0 ; loop < loop_count && !thd->killed; loop++)
+  for (ulonglong loop=0 ; loop < loop_count && !thd->get_killed(); loop++)
   {
     switch (args[1]->result_type()) {
     case REAL_RESULT:
@@ -4541,7 +4546,7 @@
 
   error= 0;
   thd_wait_begin(thd, THD_WAIT_SLEEP);
-  while (!thd->killed)
+  while (!thd->get_killed())
   {
     error= timed_cond.wait(&cond, &LOCK_user_locks);
     if (error == ETIMEDOUT || error == ETIME)
@@ -6742,7 +6747,7 @@
   {
     null_value= 1;
     context->process_error(thd);
-    if (thd->killed)
+    if (thd->get_killed())
       thd->send_kill_message();
     return TRUE;
   }
 
=== modified file 'Percona-Server/sql/item_subselect.cc'
--- Percona-Server/sql/item_subselect.cc	2012-12-04 08:24:59 +0000
+++ Percona-Server/sql/item_subselect.cc	2013-01-09 13:41:38 +0000
@@ -572,7 +572,7 @@
     or if the query has been killed.
   */
   THD * const thd= unit->thd;
-  if (thd->is_error() || thd->killed)
+  if (thd->is_error() || thd->get_killed())
     DBUG_RETURN(true);
 
   DBUG_ASSERT(!thd->lex->context_analysis_only);
 
=== modified file 'Percona-Server/sql/lock.cc'
--- Percona-Server/sql/lock.cc	2012-03-06 14:29:42 +0000
+++ Percona-Server/sql/lock.cc	2013-01-09 13:41:38 +0000
@@ -324,11 +324,11 @@
     if (sql_lock->table_count)
       (void) unlock_external(thd, sql_lock->table, sql_lock->table_count);
     reset_lock_data_and_free(&sql_lock);
-    if (! thd->killed)
+    if (! thd->get_killed())
       my_error(rc, MYF(0));
   }
 end:
-  if (thd->killed)
+  if (thd->get_killed())
   {
     thd->send_kill_message();
     if (sql_lock)
 
=== modified file 'Percona-Server/sql/log.cc'
--- Percona-Server/sql/log.cc	2012-12-04 08:24:59 +0000
+++ Percona-Server/sql/log.cc	2013-01-09 13:41:38 +0000
@@ -501,7 +501,7 @@
   result= FALSE;
 
 err:
-  if (result && !thd->killed)
+  if (result && !thd->get_killed())
     sql_print_error("Failed to write to mysql.general_log: %s",
                     error_handler.message());
 
@@ -699,7 +699,7 @@
 err:
   thd->pop_internal_handler();
 
-  if (result && !thd->killed)
+  if (result && !thd->get_killed())
     sql_print_error("Failed to write to mysql.slow_log: %s",
                     error_handler.message());
 
 
=== modified file 'Percona-Server/sql/log_event.cc'
--- Percona-Server/sql/log_event.cc	2012-12-04 08:24:59 +0000
+++ Percona-Server/sql/log_event.cc	2013-01-09 13:41:38 +0000
@@ -4799,7 +4799,7 @@
 		 get_type_str(), thd->get_stmt_da()->message());
       }
       clear_all_errors(thd, const_cast<Relay_log_info*>(rli));
-      thd->killed= THD::NOT_KILLED;
+      thd->set_killed(THD::NOT_KILLED);
     }
     /*
       Other cases: mostly we expected no error and get one.
 
=== modified file 'Percona-Server/sql/mysqld.cc'
--- Percona-Server/sql/mysqld.cc	2012-12-04 08:24:59 +0000
+++ Percona-Server/sql/mysqld.cc	2013-01-09 13:41:38 +0000
@@ -1376,7 +1376,7 @@
     if (tmp->slave_thread)
       continue;
 
-    tmp->killed= THD::KILL_CONNECTION;
+    tmp->set_killed(THD::KILL_CONNECTION);
     MYSQL_CALLBACK(thread_scheduler, post_kill_notification, (tmp));
     mysql_mutex_lock(&tmp->LOCK_thd_data);
     if (tmp->mysys_var)
@@ -5933,7 +5933,7 @@
       DBUG_PRINT("error",
                  ("Can't create thread to handle request (error %d)",
                   error));
-      thd->killed= THD::KILL_CONNECTION;      // Safety
+      thd->set_killed(THD::KILL_CONNECTION);      // Safety
       mysql_mutex_unlock(&LOCK_thread_count);
 
       mysql_mutex_lock(&LOCK_connection_count);
 
=== modified file 'Percona-Server/sql/opt_range.cc'
--- Percona-Server/sql/opt_range.cc	2012-12-04 08:24:59 +0000
+++ Percona-Server/sql/opt_range.cc	2013-01-09 13:41:38 +0000
@@ -9866,7 +9866,7 @@
       break;
     }
 
-    if (thd->killed)
+    if (thd->get_killed())
       DBUG_RETURN(1);
 
     /* skip row if it will be retrieved by clustered PK scan */
 
=== modified file 'Percona-Server/sql/records.cc'
--- Percona-Server/sql/records.cc	2012-12-04 08:24:59 +0000
+++ Percona-Server/sql/records.cc	2013-01-09 13:41:38 +0000
@@ -340,7 +340,7 @@
 
 static int rr_handle_error(READ_RECORD *info, int error)
 {
-  if (info->thd->killed)
+  if (info->thd->get_killed())
   {
     info->thd->send_kill_message();
     return 1;
@@ -366,7 +366,7 @@
   int tmp;
   while ((tmp= info->select->quick->get_next()))
   {
-    if (info->thd->killed || (tmp != HA_ERR_RECORD_DELETED))
+    if (info->thd->get_killed() || (tmp != HA_ERR_RECORD_DELETED))
     {
       tmp= rr_handle_error(info, tmp);
       break;
@@ -481,7 +481,7 @@
       ha_rnd_next can return RECORD_DELETED for MyISAM when one thread is
       reading and another deleting without locks.
     */
-    if (info->thd->killed || (tmp != HA_ERR_RECORD_DELETED))
+    if (info->thd->get_killed() || (tmp != HA_ERR_RECORD_DELETED))
     {
       tmp= rr_handle_error(info, tmp);
       break;
 
=== modified file 'Percona-Server/sql/rpl_gtid_execution.cc'
--- Percona-Server/sql/rpl_gtid_execution.cc	2012-09-17 18:49:38 +0000
+++ Percona-Server/sql/rpl_gtid_execution.cc	2013-01-09 13:41:38 +0000
@@ -78,7 +78,7 @@
       // global_sid_lock and mutex are now released
 
       // Check if thread was killed.
-      if (thd->killed || abort_loop)
+      if (thd->get_killed() || abort_loop)
         DBUG_RETURN(1);
 #ifdef HAVE_REPLICATION
       // If this thread is a slave SQL thread or slave SQL worker
@@ -159,7 +159,7 @@
 
     // at this point, we don't hold any locks. re-acquire the global
     // read lock that was held when this function was invoked
-    if (thd->killed || abort_loop)
+    if (thd->get_killed() || abort_loop)
       DBUG_RETURN(1);
 #ifdef HAVE_REPLICATION
     // If this thread is a slave SQL thread or slave SQL worker
 
=== modified file 'Percona-Server/sql/rpl_gtid_state.cc'
--- Percona-Server/sql/rpl_gtid_state.cc	2012-09-17 18:49:38 +0000
+++ Percona-Server/sql/rpl_gtid_state.cc	2013-01-09 13:41:38 +0000
@@ -262,7 +262,7 @@
   sid_locks.enter_cond(thd, gtid.sidno,
                        &stage_waiting_for_gtid_to_be_written_to_binary_log,
                        &old_stage);
-  //while (get_owner(g.sidno, g.gno) != 0 && !thd->killed && !abort_loop)
+  //while (get_owner(g.sidno, g.gno) != 0 && !thd->get_killed() && !abort_loop)
   sid_locks.wait(gtid.sidno);
   thd->EXIT_COND(&old_stage);
 
 
=== modified file 'Percona-Server/sql/rpl_master.cc'
--- Percona-Server/sql/rpl_master.cc	2012-10-16 06:21:51 +0000
+++ Percona-Server/sql/rpl_master.cc	2013-01-09 13:41:38 +0000
@@ -1090,7 +1090,7 @@
   /* seek to the requested position, to start the requested dump */
   my_b_seek(&log, pos);			// Seek will done on next read
 
-  while (!net->error && net->vio != 0 && !thd->killed)
+  while (!net->error && net->vio != 0 && !thd->get_killed())
   {
     Log_event_type event_type= UNKNOWN_EVENT;
 
@@ -1430,7 +1430,7 @@
             {
               DBUG_PRINT("wait",("binary log received update or a broadcast signal caught"));
             }
-          } while (signal_cnt == mysql_bin_log.signal_cnt && !thd->killed);
+          } while (signal_cnt == mysql_bin_log.signal_cnt && !thd->get_killed());
           thd->EXIT_COND(&old_stage);
         }
         break;
 
=== modified file 'Percona-Server/sql/rpl_rli.cc'
--- Percona-Server/sql/rpl_rli.cc	2012-12-04 08:24:59 +0000
+++ Percona-Server/sql/rpl_rli.cc	2013-01-09 13:41:38 +0000
@@ -675,7 +675,7 @@
   }
 
   /* The "compare and wait" main loop */
-  while (!thd->killed &&
+  while (!thd->get_killed() &&
          init_abort_pos_wait == abort_pos_wait &&
          slave_running)
   {
@@ -727,7 +727,7 @@
 
       pos_reached= ((!cmp_result && group_master_log_pos >= (ulonglong)log_pos) ||
                     cmp_result > 0);
-      if (pos_reached || thd->killed)
+      if (pos_reached || thd->get_killed())
         break;
     }
 
@@ -785,7 +785,7 @@
                      (int) slave_running,
                      (int) (error == -2),
                      (int) (error == -1)));
-  if (thd->killed || init_abort_pos_wait != abort_pos_wait ||
+  if (thd->get_killed() || init_abort_pos_wait != abort_pos_wait ||
       !slave_running)
   {
     error= -2;
@@ -845,7 +845,7 @@
   global_sid_lock->unlock();
 
   /* The "compare and wait" main loop */
-  while (!thd->killed &&
+  while (!thd->get_killed() &&
          init_abort_pos_wait == abort_pos_wait &&
          slave_running)
   {
@@ -931,7 +931,7 @@
                      (int) slave_running,
                      (int) (error == -2),
                      (int) (error == -1)));
-  if (thd->killed || init_abort_pos_wait != abort_pos_wait ||
+  if (thd->get_killed() || init_abort_pos_wait != abort_pos_wait ||
       !slave_running)
   {
     error= -2;
 
=== modified file 'Percona-Server/sql/rpl_rli_pdb.cc'
--- Percona-Server/sql/rpl_rli_pdb.cc	2012-12-04 08:24:59 +0000
+++ Percona-Server/sql/rpl_rli_pdb.cc	2013-01-09 13:41:38 +0000
@@ -887,10 +887,10 @@
                                    &stage_slave_waiting_worker_to_release_partition,
                                    &old_stage);
         mysql_cond_wait(&slave_worker_hash_cond, &slave_worker_hash_lock);
-      } while (entry->usage != 0 && !thd->killed);
+      } while (entry->usage != 0 && !thd->get_killed());
 
       thd->EXIT_COND(&old_stage);
-      if (thd->killed)
+      if (thd->get_killed())
       {
         entry= NULL;
         goto err;
@@ -1500,7 +1500,7 @@
       continue;
     }
 
-    if (entry->usage > 0 && !thd->killed)
+    if (entry->usage > 0 && !thd->get_killed())
     {
       PSI_stage_info old_stage;
       Slave_worker *w_entry= entry->worker;
@@ -1517,7 +1517,7 @@
                    ("Either got awakened of notified: "
                     "entry %p, usage %lu, worker %lu",
                     entry, entry->usage, w_entry->id));
-      } while (entry->usage != 0 && !thd->killed);
+      } while (entry->usage != 0 && !thd->get_killed());
       entry->worker= w_entry; // restoring last association, needed only for assert
       thd->EXIT_COND(&old_stage);
       ret++;
@@ -1659,7 +1659,7 @@
                     &stage_slave_waiting_worker_to_free_events, &old_stage);
     mysql_cond_wait(&rli->pending_jobs_cond, &rli->pending_jobs_lock);
     thd->EXIT_COND(&old_stage);
-    if (thd->killed)
+    if (thd->get_killed())
       return true;
     if (log_warnings > 1 && (rli->wq_size_waits_cnt % 10 == 1))
       sql_print_information("Multi-threaded slave: Coordinator has waited "
@@ -1701,7 +1701,7 @@
   mysql_mutex_lock(&worker->jobs_lock);
 
   // possible WQ overfill
-  while (worker->running_status == Slave_worker::RUNNING && !thd->killed &&
+  while (worker->running_status == Slave_worker::RUNNING && !thd->get_killed() &&
          (ret= en_queue(&worker->jobs, job_item)) == -1)
   {
     thd->ENTER_COND(&worker->jobs_cond, &worker->jobs_lock, 
@@ -1752,7 +1752,7 @@
 
   mysql_mutex_lock(&worker->jobs_lock);
 
-  while (!job_item->data && !thd->killed &&
+  while (!job_item->data && !thd->get_killed() &&
          worker->running_status == Slave_worker::RUNNING)
   {
     PSI_stage_info old_stage;
@@ -1805,7 +1805,7 @@
   DBUG_ENTER("slave_worker_exec_job");
 
   job_item= pop_jobs_item(worker, job_item);
-  if (thd->killed || worker->running_status != Slave_worker::RUNNING)
+  if (thd->get_killed() || worker->running_status != Slave_worker::RUNNING)
   {
     // de-queueing and decrement counters is in the caller's exit branch
     error= -1;
@@ -1978,7 +1978,7 @@
     if (log_warnings > 1)
       sql_print_information("Worker %lu is exiting: killed %i, error %i, "
                             "running_status %d",
-                            worker->id, thd->killed, thd->is_error(),
+                            worker->id, thd->get_killed(), thd->is_error(),
                             worker->running_status);
     worker->slave_worker_ends_group(ev, error);
   }
 
=== modified file 'Percona-Server/sql/rpl_slave.cc'
--- Percona-Server/sql/rpl_slave.cc	2012-12-04 08:24:59 +0000
+++ Percona-Server/sql/rpl_slave.cc	2013-01-09 13:41:38 +0000
@@ -1034,15 +1034,15 @@
       /*
         It is not sufficient to test this at loop bottom. We must test
         it after registering the mutex in enter_cond(). If the kill
-        happens after testing of thd->killed and before the mutex is
-        registered, we could otherwise go waiting though thd->killed is
+        happens after testing of thd->get_killed() and before the mutex is
+        registered, we could otherwise go waiting though thd->get_killed() is
         set.
       */
-      if (!thd->killed)
+      if (!thd->get_killed())
         mysql_cond_wait(start_cond, cond_lock);
       thd->EXIT_COND(& saved_stage);
       mysql_mutex_lock(cond_lock); // re-acquire it as exit_cond() released
-      if (thd->killed)
+      if (thd->get_killed())
       {
         if (start_lock)
           mysql_mutex_unlock(start_lock);
@@ -1192,7 +1192,7 @@
 
   DBUG_ASSERT(mi->info_thd == thd);
   DBUG_ASSERT(mi->slave_running); // tracking buffer overrun
-  DBUG_RETURN(mi->abort_slave || abort_loop || thd->killed);
+  DBUG_RETURN(mi->abort_slave || abort_loop || thd->get_killed());
 }
 
 /**
@@ -1223,10 +1223,10 @@
 
   DBUG_ASSERT(rli->info_thd == thd);
   DBUG_ASSERT(rli->slave_running == 1);
-  if (abort_loop || thd->killed || rli->abort_slave)
+  if (abort_loop || thd->get_killed() || rli->abort_slave)
   {
     is_parallel_warn= (rli->is_parallel_exec() && 
-                       (rli->is_mts_in_group() || thd->killed));
+                       (rli->is_mts_in_group() || thd->get_killed()));
     /*
       Slave can execute stop being in one of two MTS or Single-Threaded mode.
       The modes define different criteria to accept the stop.
@@ -5153,7 +5153,7 @@
     commit-events of last assigned groups.
   */
   if (rli->mts_group_status != Relay_log_info::MTS_KILLED_GROUP &&
-      thd->killed == THD::NOT_KILLED)
+      thd->get_killed() == THD::NOT_KILLED)
   {
     DBUG_ASSERT(rli->mts_group_status != Relay_log_info::MTS_IN_GROUP ||
                 thd->is_error());
@@ -7166,7 +7166,7 @@
             set_timespec_nsec(waittime, period);
             ret= rli->relay_log.wait_for_update_relay_log(thd, &waittime);
           } while ((ret == ETIMEDOUT || ret == ETIME) /* todo:remove */ &&
-                   signal_cnt == rli->relay_log.signal_cnt && !thd->killed);
+                   signal_cnt == rli->relay_log.signal_cnt && !thd->get_killed());
         }
         else
         {
 
=== modified file 'Percona-Server/sql/signal_handler.cc'
--- Percona-Server/sql/signal_handler.cc	2012-08-22 01:40:20 +0000
+++ Percona-Server/sql/signal_handler.cc	2013-01-09 13:41:38 +0000
@@ -165,7 +165,7 @@
   if (thd)
   {
     const char *kreason= "UNKNOWN";
-    switch (thd->killed) {
+    switch (thd->get_killed()) {
     case THD::NOT_KILLED:
       kreason= "NOT_KILLED";
       break;
 
=== modified file 'Percona-Server/sql/sp.cc'
--- Percona-Server/sql/sp.cc	2012-12-04 08:24:59 +0000
+++ Percona-Server/sql/sp.cc	2013-01-09 13:41:38 +0000
@@ -1484,7 +1484,7 @@
       or is outdated. We therefore only abort mysql_rm_db() if we
       have errors not handled by the error handler.
     */
-    DBUG_RETURN(thd->is_error() || thd->killed);
+    DBUG_RETURN(thd->is_error() || thd->get_killed());
   }
 
   table->field[MYSQL_PROC_FIELD_DB]->store(db, strlen(db), system_charset_info);
@@ -2077,7 +2077,7 @@
       break;
     default:
       /* Query might have been killed, don't set error. */
-      if (thd->killed)
+      if (thd->get_killed())
         break;
       /*
         Any error when loading an existing routine is either some problem
 
=== modified file 'Percona-Server/sql/sp_head.cc'
--- Percona-Server/sql/sp_head.cc	2012-10-16 06:21:51 +0000
+++ Percona-Server/sql/sp_head.cc	2013-01-09 13:41:38 +0000
@@ -675,7 +675,7 @@
     /* Reset sp_rcontext::end_partial_result_set flag. */
     thd->sp_runtime_ctx->end_partial_result_set= FALSE;
 
-  } while (!err_status && !thd->killed && !thd->is_fatal_error);
+  } while (!err_status && !thd->get_killed() && !thd->is_fatal_error);
 
 #if defined(ENABLED_PROFILING)
   thd->profiling.finish_current_query();
@@ -751,16 +751,16 @@
 
  done:
   DBUG_PRINT("info", ("err_status: %d  killed: %d  is_slave_error: %d  report_error: %d",
-                      err_status, thd->killed, thd->is_slave_error,
+                      err_status, thd->get_killed(), thd->is_slave_error,
                       thd->is_error()));
 
-  if (thd->killed)
+  if (thd->get_killed())
     err_status= TRUE;
   /*
     If the DB has changed, the pointer has changed too, but the
     original thd->db will then have been freed
   */
-  if (cur_db_changed && thd->killed != THD::KILL_CONNECTION)
+  if (cur_db_changed && thd->get_killed() != THD::KILL_CONNECTION)
   {
     /*
       Force switching back to the saved current database, because it may be
@@ -901,7 +901,7 @@
   free_root(&call_mem_root, MYF(0));
   thd->sp_runtime_ctx= parent_sp_runtime_ctx;
 
-  if (thd->killed)
+  if (thd->get_killed())
     thd->send_kill_message();
 
   DBUG_RETURN(err_status);
@@ -1096,7 +1096,7 @@
     thd->variables.option_bits= binlog_save_options;
     if (thd->binlog_evt_union.unioned_events)
     {
-      int errcode = query_error_code(thd, thd->killed == THD::NOT_KILLED);
+      int errcode = query_error_code(thd, thd->get_killed() == THD::NOT_KILLED);
       Query_log_event qinfo(thd, binlog_buf.ptr(), binlog_buf.length(),
                             thd->binlog_evt_union.unioned_events_trans, FALSE, FALSE, errcode);
       if (mysql_bin_log.write_event(&qinfo) &&
 
=== modified file 'Percona-Server/sql/sp_instr.cc'
--- Percona-Server/sql/sp_instr.cc	2012-07-16 15:43:41 +0000
+++ Percona-Server/sql/sp_instr.cc	2013-01-09 13:41:38 +0000
@@ -630,7 +630,7 @@
     */
     if (stmt_reprepare_observer &&
         !thd->is_fatal_error &&
-        !thd->killed &&
+        !thd->get_killed() &&
         thd->get_stmt_da()->sql_errno() == ER_NEED_REPREPARE &&
         reprepare_attempt++ < 3)
     {
 
=== modified file 'Percona-Server/sql/sp_rcontext.cc'
--- Percona-Server/sql/sp_rcontext.cc	2012-12-04 08:24:59 +0000
+++ Percona-Server/sql/sp_rcontext.cc	2013-01-09 13:41:38 +0000
@@ -353,7 +353,7 @@
 
   /* Reset error state. */
   thd->clear_error();
-  thd->killed= THD::NOT_KILLED; // Some errors set thd->killed
+  thd->set_killed(THD::NOT_KILLED); // Some errors set thd->get_killed()
                                 // (e.g. "bad data").
 
   /* Add a frame to handler-call-stack. */
 
=== modified file 'Percona-Server/sql/sql_admin.cc'
--- Percona-Server/sql/sql_admin.cc	2012-10-16 06:21:51 +0000
+++ Percona-Server/sql/sql_admin.cc	2013-01-09 13:41:38 +0000
@@ -804,7 +804,7 @@
       protocol->store(operator_name, system_charset_info);
       if (result_code) // either mysql_recreate_table or analyze failed
       {
-        DBUG_ASSERT(thd->is_error() || thd->killed);
+        DBUG_ASSERT(thd->is_error() || thd->get_killed());
         if (thd->is_error())
         {
           const char *err_msg= thd->get_stmt_da()->message();
 
=== modified file 'Percona-Server/sql/sql_base.cc'
--- Percona-Server/sql/sql_base.cc	2012-12-04 08:24:59 +0000
+++ Percona-Server/sql/sql_base.cc	2013-01-09 13:41:38 +0000
@@ -850,9 +850,9 @@
     THD *in_use= tab->in_use;
 
     if ((in_use->system_thread & SYSTEM_THREAD_DELAYED_INSERT) &&
-        ! in_use->killed)
+        ! in_use->get_killed())
     {
-      in_use->killed= THD::KILL_CONNECTION;
+      in_use->set_killed(THD::KILL_CONNECTION);
       mysql_mutex_lock(&in_use->mysys_var->mutex);
       if (in_use->mysys_var->current_cond)
       {
@@ -983,7 +983,7 @@
   /* Wait until all threads have closed all the tables we are flushing. */
   DBUG_PRINT("info", ("Waiting for other threads to close their open tables"));
 
-  while (found && ! thd->killed)
+  while (found && ! thd->get_killed())
   {
     TABLE_SHARE *share;
     found= FALSE;
@@ -2594,7 +2594,7 @@
   if (check_stack_overrun(thd, STACK_MIN_SIZE_FOR_OPEN, (uchar *)&alias))
     DBUG_RETURN(TRUE);
 
-  if (thd->killed)
+  if (thd->get_killed())
     DBUG_RETURN(TRUE);
 
   key_length= get_table_def_key(table_list, &key);
@@ -3530,7 +3530,7 @@
                          mysql_lock_merge(thd->lock, lock)) == NULL)
     {
       unlink_all_closed_tables(thd, lock, reopen_count);
-      if (! thd->killed)
+      if (! thd->get_killed())
         my_error(ER_LOCK_DEADLOCK, MYF(0));
       return TRUE;
     }
 
=== modified file 'Percona-Server/sql/sql_cache.cc'
--- Percona-Server/sql/sql_cache.cc	2012-10-03 12:51:45 +0000
+++ Percona-Server/sql/sql_cache.cc	2013-01-09 13:41:38 +0000
@@ -1001,7 +1001,7 @@
   if (query_cache_tls->first_query_block == NULL)
     DBUG_VOID_RETURN;
 
-  if (thd->killed || thd->is_error())
+  if (thd->get_killed() || thd->is_error())
   {
     query_cache_abort(&thd->query_cache_tls);
     DBUG_VOID_RETURN;
@@ -4239,7 +4239,7 @@
   DBUG_PRINT("warning", ("%5d QUERY CACHE WRECK => DISABLED",line));
   DBUG_PRINT("warning", ("=================================="));
   if (thd)
-    thd->killed= THD::KILL_CONNECTION;
+    thd->set_killed(THD::KILL_CONNECTION);
   cache_dump();
   /* check_integrity(0); */ /* Can't call it here because of locks */
   bins_dump();
 
=== modified file 'Percona-Server/sql/sql_class.cc'
--- Percona-Server/sql/sql_class.cc	2012-12-04 08:24:59 +0000
+++ Percona-Server/sql/sql_class.cc	2013-01-09 13:41:38 +0000
@@ -273,7 +273,7 @@
 */
 void thd_set_killed(THD *thd)
 {
-  thd->killed= THD::KILL_CONNECTION;
+  thd->set_killed(THD::KILL_CONNECTION);
 }
 
 /**
@@ -928,7 +928,7 @@
   password= 0;
   query_start_used= query_start_usec_used= 0;
   count_cuted_fields= CHECK_FIELD_IGNORE;
-  killed= NOT_KILLED;
+  set_killed(NOT_KILLED);
   col_access=0;
   is_slave_error= thread_specific_used= FALSE;
   my_hash_clear(&handler_tables_hash);
@@ -945,6 +945,7 @@
   start_time.tv_sec= 0;
   start_time.tv_usec= 0;
   start_utime= prior_thr_create_utime= 0L;
+  sql_timeout_expire= 0;
   utime_after_lock= 0L;
   current_linfo =  0;
   slave_thread = 0;
@@ -1227,7 +1228,7 @@
       push_warning and strict SQL_MODE case.
     */
     level= Sql_condition::WARN_LEVEL_ERROR;
-    killed= THD::KILL_BAD_DATA;
+    set_killed(THD::KILL_BAD_DATA);
   }
 
   switch (level)
@@ -1433,7 +1434,7 @@
   mysql_mutex_unlock(&LOCK_status);
 
   cleanup();
-  killed= NOT_KILLED;
+  set_killed(NOT_KILLED);
   cleanup_done= 0;
   init();
   stmt_map.reset();
@@ -1454,7 +1455,7 @@
   DBUG_ENTER("THD::cleanup");
   DBUG_ASSERT(cleanup_done == 0);
 
-  killed= KILL_CONNECTION;
+  set_killed(KILL_CONNECTION);
 #ifdef ENABLE_WHEN_BINLOG_WILL_BE_ABLE_TO_PREPARE
   if (transaction.xid_state.xa_state == XA_PREPARED)
   {
@@ -1692,7 +1693,7 @@
   mysql_mutex_assert_owner(&LOCK_thd_data);
 
   /* Set the 'killed' flag of 'this', which is the target THD object. */
-  killed= state_to_set;
+  set_killed(state_to_set);
 
   if (state_to_set != THD::KILL_QUERY)
   {
@@ -1713,7 +1714,7 @@
 
         On the other hand, without closing the socket we have a race
         condition. If "this" target thread passes the check of
-        thd->killed, and then the current thread runs through
+        thd->get_killed(), and then the current thread runs through
         THD::awake(), sets the 'killed' flag and completes the
         signaling, and then the target thread runs into read(), it will
         block on the socket. As a result of the discussions around
@@ -1721,7 +1722,7 @@
         condition. A second KILL awakes the target from read().
 
         If we are killing ourselves, we know that we are not blocked.
-        We also know that we will check thd->killed before we go for
+        We also know that we will check thd->get_killed() before we go for
         reading the next statement.
       */
 
@@ -1759,7 +1760,7 @@
       current_cond and current_mutex are 0), then the victim will not get
       a signal and it may wait "forever" on the cond (until
       we issue a second KILL or the status it's waiting for happens).
-      It's true that we have set its thd->killed but it may not
+      It's true that we have set its thd->get_killed() but it may not
       see it immediately and so may have time to reach the cond_wait().
 
       However, where possible, we test for killed once again after
@@ -1792,7 +1793,7 @@
 
   mysql_mutex_lock(&LOCK_thd_data);
 
-  killed= THD::KILL_CONNECTION;
+  set_killed(THD::KILL_CONNECTION);
 
 #ifdef SIGNAL_WITH_VIO_CLOSE
   /*
@@ -1820,9 +1821,9 @@
   THD *in_use= ctx_in_use->get_thd();
   bool signalled= FALSE;
   if ((in_use->system_thread & SYSTEM_THREAD_DELAYED_INSERT) &&
-      !in_use->killed)
+      !in_use->get_killed())
   {
-    in_use->killed= THD::KILL_CONNECTION;
+    in_use->set_killed(THD::KILL_CONNECTION);
     mysql_mutex_lock(&in_use->mysys_var->mutex);
     if (in_use->mysys_var->current_cond)
       mysql_cond_broadcast(in_use->mysys_var->current_cond);
@@ -2185,7 +2186,7 @@
   {
     my_error(EE_OUTOFMEMORY, MYF(ME_BELL),
              ALIGN_SIZE(sizeof(TABLE_LIST)) + key_length + 1);
-    killed= KILL_CONNECTION;
+    set_killed(KILL_CONNECTION);
     return 0;
   }
 
@@ -3992,7 +3993,7 @@
 */
 extern "C" int thd_killed(const MYSQL_THD thd)
 {
-  return(thd->killed);
+  return(thd->get_killed());
 }
 
 /**
 
=== modified file 'Percona-Server/sql/sql_class.h'
--- Percona-Server/sql/sql_class.h	2012-12-04 08:24:59 +0000
+++ Percona-Server/sql/sql_class.h	2013-01-09 13:41:38 +0000
@@ -481,6 +481,7 @@
   ulong trans_alloc_block_size;
   ulong trans_prealloc_size;
   ulong group_concat_max_len;
+  ulong sql_timeout;
 
   ulong binlog_format; ///< binlog format for this thd (see enum_binlog_format)
   my_bool binlog_direct_non_trans_update;
@@ -2124,6 +2125,12 @@
   uint16 peer_port;
   struct timeval start_time;
   struct timeval user_time;
+  /*
+    Expire time in microseconds for sql_timeout monitor thread. The 0 value
+    means the current thread is not monitored by sql_timeout monitor.
+  */
+  ulonglong sql_timeout_expire;
+
   // track down slow pthread_create
   ulonglong  prior_thr_create_utime, thr_create_utime;
   ulonglong  start_utime, utime_after_lock;
@@ -2807,7 +2814,27 @@
     KILL_QUERY=ER_QUERY_INTERRUPTED,
     KILLED_NO_VALUE      /* means neither of the states */
   };
-  killed_state volatile killed;
+
+private:
+  killed_state volatile killed_status;
+
+public:
+  killed_state get_killed() const
+  {
+    if (killed_status)
+      return killed_status;
+    if (sql_timeout_expire &&
+	(my_micro_time() >= sql_timeout_expire))
+    {
+      return THD::KILL_QUERY;
+    }
+    return killed_status;
+  }
+
+  void set_killed(killed_state new_killed)
+  {
+    killed_status= new_killed;
+  }
 
   /* scramble - random string sent to client on handshake */
   char	     scramble[SCRAMBLE_LENGTH+1];
@@ -3080,7 +3107,7 @@
     DBUG_VOID_RETURN;
   }
 
-  virtual int is_killed() { return killed; }
+  virtual int is_killed() { return get_killed(); }
   virtual THD* get_thd() { return this; }
 
   /**
@@ -3331,7 +3358,7 @@
   */
   inline void fatal_error()
   {
-    DBUG_ASSERT(get_stmt_da()->is_error() || killed);
+    DBUG_ASSERT(get_stmt_da()->is_error() || get_killed());
     is_fatal_error= 1;
     DBUG_PRINT("error",("Fatal error set"));
   }
@@ -3420,7 +3447,7 @@
   inline int killed_errno() const
   {
     killed_state killed_val; /* to cache the volatile 'killed' */
-    return (killed_val= killed) != KILL_BAD_DATA ? killed_val : 0;
+    return (killed_val= get_killed()) != KILL_BAD_DATA ? killed_val : 0;
   }
   inline void send_kill_message() const
   {
 
=== modified file 'Percona-Server/sql/sql_connect.cc'
--- Percona-Server/sql/sql_connect.cc	2012-12-04 08:24:59 +0000
+++ Percona-Server/sql/sql_connect.cc	2013-01-09 13:41:38 +0000
@@ -768,14 +768,14 @@
   */
   release_user_connection(thd);
 
-  if (thd->killed || (net->error && net->vio != 0))
+  if (thd->get_killed() || (net->error && net->vio != 0))
   {
     statistic_increment(aborted_threads,&LOCK_status);
   }
 
   if (net->error && net->vio != 0)
   {
-    if (!thd->killed && log_warnings > 1)
+    if (!thd->get_killed() && log_warnings > 1)
     {
       Security_context *sctx= thd->security_ctx;
 
@@ -846,7 +846,7 @@
 
       thd->server_status&= ~SERVER_STATUS_CLEAR_SET;
       thd->protocol->end_statement();
-      thd->killed = THD::KILL_CONNECTION;
+      thd->set_killed(THD::KILL_CONNECTION);
       errors.m_init_connect= 1;
       inc_host_errors(thd->main_security_ctx.ip, &errors);
       return;
@@ -907,7 +907,7 @@
   NET *net= &thd->net;
   if (!net->error &&
       net->vio != 0 &&
-      !(thd->killed == THD::KILL_CONNECTION))
+      !(thd->get_killed() == THD::KILL_CONNECTION))
     return TRUE;
   return FALSE;
 }
 
=== modified file 'Percona-Server/sql/sql_db.cc'
--- Percona-Server/sql/sql_db.cc	2012-12-04 08:24:59 +0000
+++ Percona-Server/sql/sql_db.cc	2013-01-09 13:41:38 +0000
@@ -840,7 +840,7 @@
   }
 
   thd->push_internal_handler(&err_handler);
-  if (!thd->killed &&
+  if (!thd->get_killed() &&
       !(tables &&
         mysql_rm_table_no_locks(thd, tables, true, false, true, true)))
   {
@@ -1025,7 +1025,7 @@
   tot_list_next_local= tot_list_next_global= &tot_list;
 
   for (uint idx=0 ;
-       idx < (uint) dirp->number_off_files && !thd->killed ;
+       idx < (uint) dirp->number_off_files && !thd->get_killed() ;
        idx++)
   {
     FILEINFO *file=dirp->dir_entry+idx;
@@ -1206,7 +1206,7 @@
   DBUG_PRINT("enter", ("path: %s", org_path));
 
   for (uint idx=0 ;
-       idx < (uint) dirp->number_off_files && !thd->killed ;
+       idx < (uint) dirp->number_off_files && !thd->get_killed() ;
        idx++)
   {
     FILEINFO *file=dirp->dir_entry+idx;
@@ -1241,7 +1241,7 @@
     }
     deleted++;
   }
-  if (thd->killed)
+  if (thd->get_killed())
     goto err;
 
   my_dirend(dirp);
@@ -1710,7 +1710,7 @@
   if ((dirp = my_dir(path,MYF(MY_DONT_SORT))))
   {
     uint nfiles= (uint) dirp->number_off_files;
-    for (uint idx=0 ; idx < nfiles && !thd->killed ; idx++)
+    for (uint idx=0 ; idx < nfiles && !thd->get_killed() ; idx++)
     {
       FILEINFO *file= dirp->dir_entry + idx;
       char *extension, tname[FN_REFLEN + 1];
 
=== modified file 'Percona-Server/sql/sql_delete.cc'
--- Percona-Server/sql/sql_delete.cc	2012-12-04 08:24:59 +0000
+++ Percona-Server/sql/sql_delete.cc	2013-01-09 13:41:38 +0000
@@ -350,7 +350,7 @@
       select && select->quick && select->quick->index != MAX_KEY)
     read_removal= table->check_read_removal(select->quick->index);
 
-  while (!(error=info.read_record(&info)) && !thd->killed &&
+  while (!(error=info.read_record(&info)) && !thd->get_killed() &&
 	 ! thd->is_error())
   {
     thd->inc_examined_row_count(1);
@@ -406,7 +406,7 @@
     else
       break;
   }
-  killed_status= thd->killed;
+  killed_status= thd->get_killed();
   if (killed_status != THD::NOT_KILLED || thd->is_error())
     error= 1;					// Aborted
   if (will_batch && (loc_error= table->file->end_bulk_delete()))
@@ -479,7 +479,7 @@
     my_ok(thd, deleted);
     DBUG_PRINT("info",("%ld records deleted",(long) deleted));
   }
-  DBUG_RETURN(thd->is_error() || thd->killed);
+  DBUG_RETURN(thd->is_error() || thd->get_killed());
 
 #ifdef WITH_PARTITION_STORAGE_ENGINE
 exit_all_parts_pruned_away:
@@ -496,7 +496,7 @@
   delete select;
   free_underlaid_joins(thd, select_lex);
   table->set_keyread(false);
-  DBUG_RETURN((err || thd->is_error() || thd->killed) ? 1 : 0);
+  DBUG_RETURN((err || thd->is_error() || thd->get_killed()) ? 1 : 0);
 }
 
 
@@ -893,7 +893,7 @@
     */
     if (mysql_bin_log.is_open())
     {
-      int errcode= query_error_code(thd, thd->killed == THD::NOT_KILLED);
+      int errcode= query_error_code(thd, thd->get_killed() == THD::NOT_KILLED);
       /* possible error of writing binary log is ignored deliberately */
       (void) thd->binlog_query(THD::ROW_QUERY_TYPE,
                                thd->query(), thd->query_length(),
@@ -938,7 +938,7 @@
     int local_error= 
       do_table_deletes(table, thd->lex->current_select->no_error);
 
-    if (thd->killed && !local_error)
+    if (thd->get_killed() && !local_error)
       DBUG_RETURN(1);
 
     if (local_error == -1)				// End of file
@@ -980,7 +980,7 @@
   */
   info.ignore_not_found_rows= 1;
   bool will_batch= !table->file->start_bulk_delete();
-  while (!(local_error= info.read_record(&info)) && !thd->killed)
+  while (!(local_error= info.read_record(&info)) && !thd->get_killed())
   {
     if (table->triggers &&
         table->triggers->process_triggers(thd, TRG_EVENT_DELETE,
@@ -1048,7 +1048,7 @@
 
   /* compute a total error to know if something failed */
   local_error= local_error || error;
-  killed_status= (local_error == 0)? THD::NOT_KILLED : thd->killed;
+  killed_status= (local_error == 0)? THD::NOT_KILLED : thd->get_killed();
   /* reset used flags */
   THD_STAGE_INFO(thd, stage_end);
 
 
=== modified file 'Percona-Server/sql/sql_executor.cc'
--- Percona-Server/sql/sql_executor.cc	2012-12-04 08:24:59 +0000
+++ Percona-Server/sql/sql_executor.cc	2013-01-09 13:41:38 +0000
@@ -1033,7 +1033,7 @@
 
   DBUG_ENTER("sub_select_op");
 
-  if (join->thd->killed)
+  if (join->thd->get_killed())
   {
     /* The user has aborted the execution of the query */
     join->thd->send_kill_message();
@@ -1248,13 +1248,13 @@
     else
       error= info->read_record(info);
 
-    DBUG_EXECUTE_IF("bug13822652_1", join->thd->killed= THD::KILL_QUERY;);
+    DBUG_EXECUTE_IF("bug13822652_1", join->thd->set_killed(THD::KILL_QUERY););
 
     if (error > 0 || (join->thd->is_error()))   // Fatal error
       rc= NESTED_LOOP_ERROR;
     else if (error < 0)
       break;
-    else if (join->thd->killed)			// Aborted by user
+    else if (join->thd->get_killed())			// Aborted by user
     {
       join->thd->send_kill_message();
       rc= NESTED_LOOP_KILLED;
@@ -1450,7 +1450,7 @@
   {
     found= test(condition->val_int());
 
-    if (join->thd->killed)
+    if (join->thd->get_killed())
     {
       join->thd->send_kill_message();
       DBUG_RETURN(NESTED_LOOP_KILLED);
@@ -1737,7 +1737,7 @@
   if (error != HA_ERR_LOCK_DEADLOCK &&
       error != HA_ERR_LOCK_WAIT_TIMEOUT &&
       error != HA_ERR_TABLE_DEF_CHANGED &&
-      !table->in_use->killed)
+      !table->in_use->get_killed())
     sql_print_error("Got error %d when reading table '%s'",
 		    error, table->s->path.str);
   table->file->print_error(error,MYF(0));
@@ -2922,7 +2922,7 @@
   TABLE *const table= join_tab->table;
   DBUG_ENTER("end_write");
 
-  if (join->thd->killed)			// Aborted by user
+  if (join->thd->get_killed())			// Aborted by user
   {
     join->thd->send_kill_message();
     DBUG_RETURN(NESTED_LOOP_KILLED);             /* purecov: inspected */
@@ -2977,7 +2977,7 @@
 
   if (end_of_records)
     DBUG_RETURN(NESTED_LOOP_OK);
-  if (join->thd->killed)			// Aborted by user
+  if (join->thd->get_killed())			// Aborted by user
   {
     join->thd->send_kill_message();
     DBUG_RETURN(NESTED_LOOP_KILLED);             /* purecov: inspected */
@@ -3057,7 +3057,7 @@
 
   if (end_of_records)
     DBUG_RETURN(NESTED_LOOP_OK);
-  if (join->thd->killed)			// Aborted by user
+  if (join->thd->get_killed())			// Aborted by user
   {
     join->thd->send_kill_message();
     DBUG_RETURN(NESTED_LOOP_KILLED);             /* purecov: inspected */
@@ -3103,7 +3103,7 @@
   int	  idx= -1;
   DBUG_ENTER("end_write_group");
 
-  if (join->thd->killed)
+  if (join->thd->get_killed())
   {						// Aborted by user
     join->thd->send_kill_message();
     DBUG_RETURN(NESTED_LOOP_KILLED);             /* purecov: inspected */
@@ -3406,7 +3406,7 @@
   error=file->ha_rnd_next(record);
   for (;;)
   {
-    if (thd->killed)
+    if (thd->get_killed())
     {
       thd->send_kill_message();
       error=0;
@@ -3538,7 +3538,7 @@
   for (;;)
   {
     uchar *org_key_pos;
-    if (thd->killed)
+    if (thd->get_killed())
     {
       thd->send_kill_message();
       error=0;
@@ -4298,7 +4298,7 @@
       rc= NESTED_LOOP_ERROR;
     else if (error < 0)
       break;
-    else if (join->thd->killed)		  // Aborted by user
+    else if (join->thd->get_killed())		  // Aborted by user
     {
       join->thd->send_kill_message();
       rc= NESTED_LOOP_KILLED;
 
=== modified file 'Percona-Server/sql/sql_insert.cc'
--- Percona-Server/sql/sql_insert.cc	2012-12-04 08:24:59 +0000
+++ Percona-Server/sql/sql_insert.cc	2013-01-09 13:41:38 +0000
@@ -1106,7 +1106,7 @@
 	  thd->clear_error();
 	}
         else
-          errcode= query_error_code(thd, thd->killed == THD::NOT_KILLED);
+          errcode= query_error_code(thd, thd->get_killed() == THD::NOT_KILLED);
         
 	/* bug#22725:
 
@@ -1120,7 +1120,7 @@
 	routines did not result in any error due to the KILLED.  In
 	such case the flag is ignored for constructing binlog event.
 	*/
-	DBUG_ASSERT(thd->killed != THD::KILL_BAD_DATA || error > 0);
+	DBUG_ASSERT(thd->get_killed() != THD::KILL_BAD_DATA || error > 0);
         if (was_insert_delayed && table_list->lock_type ==  TL_WRITE)
         {
           /* Binlog INSERT DELAYED as INSERT without DELAYED. */
@@ -2201,7 +2201,7 @@
     if (!--locks_in_memory)
     {
       mysql_mutex_lock(&mutex);
-      if (thd.killed && ! stacked_inserts && ! tables_in_use)
+      if (thd.get_killed() && ! stacked_inserts && ! tables_in_use)
       {
         mysql_cond_signal(&cond);
 	status=1;
@@ -2370,18 +2370,18 @@
       */
       THD_STAGE_INFO(thd, stage_waiting_for_handler_open);
       while (!di->handler_thread_initialized ||
-             (!di->thd.killed && !di->table && !thd->killed))
+             (!di->thd.get_killed() && !di->table && !thd->get_killed()))
       {
         mysql_cond_wait(&di->cond_client, &di->mutex);
       }
       mysql_mutex_unlock(&di->mutex);
       THD_STAGE_INFO(thd, stage_got_old_table);
-      if (thd->killed)
+      if (thd->get_killed())
       {
         di->unlock();
         goto end_create;
       }
-      if (di->thd.killed)
+      if (di->thd.get_killed())
       {
         if (di->thd.is_error())
         {
@@ -2459,14 +2459,14 @@
   {
     THD_STAGE_INFO(client_thd, stage_waiting_for_handler_lock);
     mysql_cond_signal(&cond);			// Tell handler to lock table
-    while (!thd.killed && !thd.lock && ! client_thd->killed)
+    while (!thd.get_killed() && !thd.lock && ! client_thd->get_killed())
     {
       mysql_cond_wait(&cond_client, &mutex);
     }
     THD_STAGE_INFO(client_thd, stage_got_handler_lock);
-    if (client_thd->killed)
+    if (client_thd->get_killed())
       goto error;
-    if (thd.killed)
+    if (thd.get_killed())
     {
       /*
         Copy the error message. Note that we don't treat fatal
@@ -2598,11 +2598,11 @@
 
   THD_STAGE_INFO(thd, stage_waiting_for_handler_insert);
   mysql_mutex_lock(&di->mutex);
-  while (di->stacked_inserts >= delayed_queue_size && !thd->killed)
+  while (di->stacked_inserts >= delayed_queue_size && !thd->get_killed())
     mysql_cond_wait(&di->cond_client, &di->mutex);
   THD_STAGE_INFO(thd, stage_storing_row_into_queue);
 
-  if (thd->killed)
+  if (thd->get_killed())
     goto err;
 
   /*
@@ -2652,7 +2652,7 @@
   Delayed_insert *di=thd->di;
   mysql_mutex_lock(&di->mutex);
   DBUG_PRINT("info",("tables in use: %d",di->tables_in_use));
-  if (!--di->tables_in_use || di->thd.killed)
+  if (!--di->tables_in_use || di->thd.get_killed())
   {						// Unlock table
     di->status=1;
     mysql_cond_signal(&di->cond);
@@ -2672,7 +2672,7 @@
   Delayed_insert *di;
   while ((di= it++))
   {
-    di->thd.killed= THD::KILL_CONNECTION;
+    di->thd.set_killed(THD::KILL_CONNECTION);
     if (di->thd.mysys_var)
     {
       mysql_mutex_lock(&di->thd.mysys_var->mutex);
@@ -2809,7 +2809,7 @@
   thd->thread_id= thd->variables.pseudo_thread_id= thread_id++;
   thd->set_current_time();
   add_global_thread(thd);
-  thd->killed=abort_loop ? THD::KILL_CONNECTION : THD::NOT_KILLED;
+  thd->set_killed(abort_loop ? THD::KILL_CONNECTION : THD::NOT_KILLED);
   mysql_mutex_unlock(&LOCK_thread_count);
 
   mysql_thread_set_psi_id(thd->thread_id);
@@ -2882,7 +2882,7 @@
 
     for (;;)
     {
-      if (thd->killed)
+      if (thd->get_killed())
       {
         uint lock_count;
         /*
@@ -2900,7 +2900,7 @@
       }
 
       /* Shouldn't wait if killed or an insert is waiting. */
-      if (!thd->killed && !di->status && !di->stacked_inserts)
+      if (!thd->get_killed() && !di->status && !di->stacked_inserts)
       {
         struct timespec abstime;
         set_timespec(abstime, delayed_insert_timeout);
@@ -2911,7 +2911,7 @@
         THD_STAGE_INFO(&(di->thd), stage_waiting_for_insert);
 
         DBUG_PRINT("info",("Waiting for someone to insert rows"));
-        while (!thd->killed && !di->status)
+        while (!thd->get_killed() && !di->status)
         {
           int error;
           mysql_audit_release(thd);
@@ -2929,7 +2929,7 @@
 #endif
 #endif
           if (error == ETIMEDOUT || error == ETIME)
-            thd->killed= THD::KILL_CONNECTION;
+            thd->set_killed(THD::KILL_CONNECTION);
         }
         /* We can't lock di->mutex and mysys_var->mutex at the same time */
         mysql_mutex_unlock(&di->mutex);
@@ -2940,7 +2940,7 @@
         mysql_mutex_lock(&di->mutex);
       }
 
-      if (di->tables_in_use && ! thd->lock && !thd->killed)
+      if (di->tables_in_use && ! thd->lock && !thd->get_killed())
       {
         /*
           Request for new delayed insert.
@@ -2955,7 +2955,7 @@
         if (! (thd->lock= mysql_lock_tables(thd, &di->table, 1, 0)))
         {
           /* Fatal error */
-          thd->killed= THD::KILL_CONNECTION;
+          thd->set_killed(THD::KILL_CONNECTION);
         }
         mysql_cond_broadcast(&di->cond_client);
       }
@@ -2964,7 +2964,7 @@
         if (di->handle_inserts())
         {
           /* Some fatal error */
-          thd->killed= THD::KILL_CONNECTION;
+          thd->set_killed(THD::KILL_CONNECTION);
         }
       }
       di->status=0;
@@ -2999,7 +2999,7 @@
   close_thread_tables(thd);			// Free the table
   thd->mdl_context.release_transactional_locks();
   di->table=0;
-  thd->killed= THD::KILL_CONNECTION;	        // If error
+  thd->set_killed(THD::KILL_CONNECTION);	        // If error
   mysql_cond_broadcast(&di->cond_client);       // Safety
   mysql_mutex_unlock(&di->mutex);
 
@@ -3079,9 +3079,9 @@
 
   THD_STAGE_INFO(&thd, stage_insert);
   max_rows= delayed_insert_limit;
-  if (thd.killed || table->s->has_old_version())
+  if (thd.get_killed() || table->s->has_old_version())
   {
-    thd.killed= THD::KILL_CONNECTION;
+    thd.set_killed(THD::KILL_CONNECTION);
     max_rows= ULONG_MAX;                     // Do as much as possible
   }
 
@@ -3691,7 +3691,7 @@
   bool const trans_table= table->file->has_transactions();
   ulonglong id, row_count;
   bool changed;
-  THD::killed_state killed_status= thd->killed;
+  THD::killed_state killed_status= thd->get_killed();
   DBUG_ENTER("select_insert::send_eof");
   DBUG_PRINT("enter", ("trans_table=%d, table_type='%s'",
                        trans_table, table->file->table_type()));
@@ -3812,7 +3812,7 @@
     {
         if (mysql_bin_log.is_open())
         {
-          int errcode= query_error_code(thd, thd->killed == THD::NOT_KILLED);
+          int errcode= query_error_code(thd, thd->get_killed() == THD::NOT_KILLED);
           /* error of writing binary log is ignored */
           (void) thd->binlog_query(THD::ROW_QUERY_TYPE, thd->query(),
                                    thd->query_length(),
@@ -4221,7 +4221,7 @@
 
   if (mysql_bin_log.is_open())
   {
-    int errcode= query_error_code(thd, thd->killed == THD::NOT_KILLED);
+    int errcode= query_error_code(thd, thd->get_killed() == THD::NOT_KILLED);
     result= thd->binlog_query(THD::STMT_QUERY_TYPE,
                               query.ptr(), query.length(),
                               /* is_trans */ TRUE,
 
=== modified file 'Percona-Server/sql/sql_join_buffer.cc'
--- Percona-Server/sql/sql_join_buffer.cc	2012-10-16 06:21:51 +0000
+++ Percona-Server/sql/sql_join_buffer.cc	2013-01-09 13:41:38 +0000
@@ -1839,7 +1839,7 @@
     if (join_tab->keep_current_rowid)
       join_tab->table->file->position(join_tab->table->record[0]);
 
-    if (join->thd->killed)
+    if (join->thd->get_killed())
     {
       /* The user has aborted the execution of the query */
       join->thd->send_kill_message();
@@ -2121,7 +2121,7 @@
 
   for ( ; cnt; cnt--)
   {
-    if (join->thd->killed)
+    if (join->thd->get_killed())
     {
       /* The user has aborted the execution of the query */
       join->thd->send_kill_message();
@@ -2331,7 +2331,7 @@
 
   while (!(error= file->multi_range_read_next((char **) &rec_ptr)))
   {
-    if (join->thd->killed)
+    if (join->thd->get_killed())
     {
       /* The user has aborted the execution of the query */
       join->thd->send_kill_message();
@@ -3261,7 +3261,7 @@
       next_rec_ref_ptr= get_next_rec_ref(next_rec_ref_ptr);
       uchar *rec_ptr= next_rec_ref_ptr+rec_fields_offset;
 
-      if (join->thd->killed)
+      if (join->thd->get_killed())
       {
         /* The user has aborted the execution of the query */
         join->thd->send_kill_message();
 
=== modified file 'Percona-Server/sql/sql_load.cc'
--- Percona-Server/sql/sql_load.cc	2012-12-04 08:24:59 +0000
+++ Percona-Server/sql/sql_load.cc	2013-01-09 13:41:38 +0000
@@ -526,11 +526,11 @@
   DBUG_EXECUTE_IF("simulate_kill_bug27571",
                   {
                     error=1;
-                    thd->killed= THD::KILL_QUERY;
+                    thd->set_killed(THD::KILL_QUERY);
                   };);
 
 #ifndef EMBEDDED_LIBRARY
-  killed_status= (error == 0) ? THD::NOT_KILLED : thd->killed;
+  killed_status= (error == 0) ? THD::NOT_KILLED : thd->get_killed();
 #endif
 
   /*
@@ -795,7 +795,7 @@
 
   while (!read_info.read_fixed_length())
   {
-    if (thd->killed)
+    if (thd->get_killed())
     {
       thd->send_kill_message();
       DBUG_RETURN(1);
@@ -870,7 +870,7 @@
                           thd->get_stmt_da()->current_row_for_warning());
     }
 
-    if (thd->killed ||
+    if (thd->get_killed() ||
         fill_record_n_invoke_before_triggers(thd, set_fields, set_values,
                                              ignore_check_option_errors,
                                              table->triggers,
@@ -931,7 +931,7 @@
 
   for (;;it.rewind())
   {
-    if (thd->killed)
+    if (thd->get_killed())
     {
       thd->send_kill_message();
       DBUG_RETURN(1);
@@ -1080,7 +1080,7 @@
       }
     }
 
-    if (thd->killed ||
+    if (thd->get_killed() ||
         fill_record_n_invoke_before_triggers(thd, set_fields, set_values,
                                              ignore_check_option_errors,
                                              table->triggers,
@@ -1112,7 +1112,7 @@
       push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
                           ER_WARN_TOO_MANY_RECORDS, ER(ER_WARN_TOO_MANY_RECORDS),
                           thd->get_stmt_da()->current_row_for_warning());
-      if (thd->killed)
+      if (thd->get_killed())
         DBUG_RETURN(1);
     }
     thd->get_stmt_da()->inc_current_row_for_warning();
@@ -1140,7 +1140,7 @@
 
   for ( ; ; it.rewind())
   {
-    if (thd->killed)
+    if (thd->get_killed())
     {
       thd->send_kill_message();
       DBUG_RETURN(1);
@@ -1254,7 +1254,7 @@
       }
     }
 
-    if (thd->killed ||
+    if (thd->get_killed() ||
         fill_record_n_invoke_before_triggers(thd, set_fields, set_values,
                                              ignore_check_option_errors,
                                              table->triggers,
 
=== modified file 'Percona-Server/sql/sql_optimizer.cc'
--- Percona-Server/sql/sql_optimizer.cc	2012-12-04 08:24:59 +0000
+++ Percona-Server/sql/sql_optimizer.cc	2013-01-09 13:41:38 +0000
@@ -3730,8 +3730,8 @@
   if (Optimize_table_order(thd, join, NULL).choose_table_order())
     DBUG_RETURN(true);
 
-  DBUG_EXECUTE_IF("bug13820776_1", thd->killed= THD::KILL_QUERY;);
-  if (thd->killed || thd->is_error())
+  DBUG_EXECUTE_IF("bug13820776_1", thd->set_killed(THD::KILL_QUERY););
+  if (thd->get_killed() || thd->is_error())
     DBUG_RETURN(true);
 
   if (join->decide_subquery_strategy())
 
=== modified file 'Percona-Server/sql/sql_parse.cc'
--- Percona-Server/sql/sql_parse.cc	2012-12-04 08:24:59 +0000
+++ Percona-Server/sql/sql_parse.cc	2013-01-09 13:41:38 +0000
@@ -942,7 +942,7 @@
   /*
     Synchronization point for testing of KILL_CONNECTION.
     This sync point can wait here, to simulate slow code execution
-    between the last test of thd->killed and blocking in read().
+    between the last test of thd->get_killed() and blocking in read().
 
     The goal of this test is to verify that a connection does not
     hang, if it is killed at this point of execution.
@@ -1311,7 +1311,7 @@
 
     mysql_parse(thd, thd->query(), thd->query_length(), &parser_state);
 
-    while (!thd->killed && (parser_state.m_lip.found_semicolon != NULL) &&
+    while (!thd->get_killed() && (parser_state.m_lip.found_semicolon != NULL) &&
            ! thd->is_error())
     {
       /*
@@ -1690,7 +1690,7 @@
 
   /* Finalize server status flags after executing a command. */
   thd->update_server_status();
-  if (thd->killed)
+  if (thd->get_killed())
     thd->send_kill_message();
   thd->protocol->end_statement();
   query_cache_end_of_result(thd);
@@ -4179,7 +4179,7 @@
     }
     /* Disconnect the current client connection. */
     if (tx_release)
-      thd->killed= THD::KILL_CONNECTION;
+      thd->set_killed(THD::KILL_CONNECTION);
     my_ok(thd);
     break;
   }
@@ -4210,7 +4210,7 @@
     }
     /* Disconnect the current client connection. */
     if (tx_release)
-      thd->killed= THD::KILL_CONNECTION;
+      thd->set_killed(THD::KILL_CONNECTION);
     my_ok(thd);
     break;
   }
@@ -4469,7 +4469,7 @@
         }
 	else
         {
-          DBUG_ASSERT(thd->is_error() || thd->killed);
+          DBUG_ASSERT(thd->is_error() || thd->get_killed());
 	  goto error;		// Substatement should already have sent error
         }
       }
@@ -4495,7 +4495,7 @@
       /* Conditionally writes to binlog */
       int sp_result= sp_update_routine(thd, sp_type, lex->spname,
                                        &lex->sp_chistics);
-      if (thd->killed)
+      if (thd->get_killed())
         goto error;
       switch (sp_result)
       {
@@ -4808,7 +4808,7 @@
         drop_server() can fail without reporting an error
         due to IF EXISTS clause. In this case, call my_ok().
       */
-      if (thd->is_error() || thd->killed)
+      if (thd->is_error() || thd->get_killed())
         goto error;
       DBUG_ASSERT(lex->drop_if_exists);
       my_ok(thd, 0);
@@ -4883,9 +4883,9 @@
     /* report error issued during command execution */
     if (thd->killed_errno())
       thd->send_kill_message();
-    if (thd->killed == THD::KILL_QUERY || thd->killed == THD::KILL_BAD_DATA)
+    if (thd->get_killed() == THD::KILL_QUERY || thd->get_killed() == THD::KILL_BAD_DATA)
     {
-      thd->killed= THD::NOT_KILLED;
+      thd->set_killed(THD::NOT_KILLED);
       thd->mysys_var->abort= 0;
     }
     if (thd->is_error() || (thd->variables.option_bits & OPTION_MASTER_SQL_ERROR))
@@ -6096,7 +6096,15 @@
             error= 1;
           }
           else
-            error= mysql_execute_command(thd);
+	  {
+	    if (thd->variables.sql_timeout)
+	      thd->sql_timeout_expire= my_micro_time() +
+	        (ulonglong)thd->variables.sql_timeout*1000000;
+
+	    error= mysql_execute_command(thd);
+
+            thd->sql_timeout_expire= 0;
+	  }
           if (error == 0 &&
               thd->variables.gtid_next.type == GTID_GROUP &&
               thd->owned_gtid.sidno != 0 &&
@@ -7009,7 +7017,7 @@
   uint error;
   if (!(error= kill_one_thread(thd, id, only_kill_query)))
   {
-    if (! thd->killed)
+    if (! thd->get_killed())
       my_ok(thd);
   }
   else
 
=== modified file 'Percona-Server/sql/sql_planner.cc'
--- Percona-Server/sql/sql_planner.cc	2012-10-16 06:21:51 +0000
+++ Percona-Server/sql/sql_planner.cc	2013-01-09 13:41:38 +0000
@@ -1768,8 +1768,8 @@
 {
   DBUG_ENTER("Optimize_table_order::best_extension_by_limited_search");
 
-  DBUG_EXECUTE_IF("bug13820776_2", thd->killed= THD::KILL_QUERY;);
-  if (thd->killed)  // Abort
+  DBUG_EXECUTE_IF("bug13820776_2", thd->set_killed(THD::KILL_QUERY););
+  if (thd->get_killed())  // Abort
     DBUG_RETURN(true);
   Opt_trace_context * const trace= &thd->opt_trace;
 
 
=== modified file 'Percona-Server/sql/sql_prepare.cc'
--- Percona-Server/sql/sql_prepare.cc	2012-12-04 08:24:59 +0000
+++ Percona-Server/sql/sql_prepare.cc	2013-01-09 13:41:38 +0000
@@ -3553,7 +3553,7 @@
   thd->pop_reprepare_observer();
 
   if ((sql_command_flags[lex->sql_command] & CF_REEXECUTION_FRAGILE) &&
-      error && !thd->is_fatal_error && !thd->killed &&
+      error && !thd->is_fatal_error && !thd->get_killed() &&
       reprepare_observer.is_invalidated() &&
       reprepare_attempt++ < MAX_REPREPARE_ATTEMPTS)
   {
 
=== modified file 'Percona-Server/sql/sql_reload.cc'
--- Percona-Server/sql/sql_reload.cc	2012-08-22 01:40:20 +0000
+++ Percona-Server/sql/sql_reload.cc	2013-01-09 13:41:38 +0000
@@ -50,7 +50,7 @@
 
   @return Error status code
     @retval 0 Ok
-    @retval !=0  Error; thd->killed is set or thd->is_error() is true
+    @retval !=0  Error; thd->get_killed() is set or thd->is_error() is true
 */
 
 bool reload_acl_and_cache(THD *thd, unsigned long options,
@@ -340,7 +340,7 @@
  /*
    If the query was killed then this function must fail.
  */
- return result || (thd ? thd->killed : 0);
+ return result || (thd ? thd->get_killed() : 0);
 }
 
 
 
=== modified file 'Percona-Server/sql/sql_servers.cc'
--- Percona-Server/sql/sql_servers.cc	2012-07-30 13:28:51 +0000
+++ Percona-Server/sql/sql_servers.cc	2013-01-09 13:41:38 +0000
@@ -607,7 +607,7 @@
   }
 
   mysql_rwlock_unlock(&THR_LOCK_servers);
-  DBUG_RETURN(error || thd->killed);
+  DBUG_RETURN(error || thd->get_killed());
 }
 
 
@@ -936,7 +936,7 @@
 
 end:
   mysql_rwlock_unlock(&THR_LOCK_servers);
-  DBUG_RETURN(error || thd->killed);
+  DBUG_RETURN(error || thd->get_killed());
 }
 
 
@@ -984,7 +984,7 @@
 
 end:
   mysql_rwlock_unlock(&THR_LOCK_servers);
-  DBUG_RETURN(error || thd->killed);
+  DBUG_RETURN(error || thd->get_killed());
 }
 
 
 
=== modified file 'Percona-Server/sql/sql_show.cc'
--- Percona-Server/sql/sql_show.cc	2012-12-04 08:24:59 +0000
+++ Percona-Server/sql/sql_show.cc	2013-01-09 13:41:38 +0000
@@ -859,7 +859,7 @@
                   MYSQL_OPEN_FORCE_SHARED_HIGH_PRIO_MDL) ||
                   mysql_handle_derived(thd->lex, &mysql_derived_prepare);
     thd->pop_internal_handler();
-    if (open_error && (thd->killed || thd->is_error()))
+    if (open_error && (thd->get_killed() || thd->is_error()))
       goto exit;
   }
 
@@ -2040,7 +2040,7 @@
                             Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
     DBUG_VOID_RETURN;
 
-  if (!thd->killed)
+  if (!thd->get_killed())
   {
     mysql_mutex_lock(&LOCK_thread_count);
     Thread_iterator it= global_thread_list_begin();
@@ -2076,7 +2076,7 @@
         mysql_mutex_lock(&tmp->LOCK_thd_data);
         if ((mysys_var= tmp->mysys_var))
           mysql_mutex_lock(&mysys_var->mutex);
-        thd_info->proc_info= (char*) (tmp->killed == THD::KILL_CONNECTION? "Killed" : 0);
+        thd_info->proc_info= (char*) (tmp->get_killed() == THD::KILL_CONNECTION? "Killed" : 0);
         thd_info->state_info= thread_state_info(tmp);
         if (mysys_var)
           mysql_mutex_unlock(&mysys_var->mutex);
@@ -2137,7 +2137,7 @@
   user= thd->security_ctx->master_access & PROCESS_ACL ?
         NullS : thd->security_ctx->priv_user;
 
-  if (!thd->killed)
+  if (!thd->get_killed())
   {
     mysql_mutex_lock(&LOCK_thread_count);
     Thread_iterator it= global_thread_list_begin();
@@ -2183,7 +2183,7 @@
       if ((mysys_var= tmp->mysys_var))
         mysql_mutex_lock(&mysys_var->mutex);
       /* COMMAND */
-      if ((val= (char *) (tmp->killed == THD::KILL_CONNECTION? "Killed" : 0)))
+      if ((val= (char *) (tmp->get_killed() == THD::KILL_CONNECTION? "Killed" : 0)))
         table->field[4]->store(val, strlen(val), cs);
       else
         table->field[4]->store(command_name[tmp->get_command()].str,
 
=== modified file 'Percona-Server/sql/sql_table.cc'
--- Percona-Server/sql/sql_table.cc	2012-12-04 08:24:59 +0000
+++ Percona-Server/sql/sql_table.cc	2013-01-09 13:41:38 +0000
@@ -2335,7 +2335,7 @@
       DBUG_ASSERT(thd->mdl_context.is_lock_owner(MDL_key::TABLE, table->db,
                                                  table->table_name,
                                                  MDL_EXCLUSIVE));
-      if (thd->killed)
+      if (thd->get_killed())
       {
         error= -1;
         goto err;
@@ -8513,7 +8513,7 @@
   restore_record(to, s->default_values);        // Create empty record
   while (!(error=info.read_record(&info)))
   {
-    if (thd->killed)
+    if (thd->get_killed())
     {
       thd->send_kill_message();
       error= 1;
@@ -8760,7 +8760,7 @@
 	{
 	  for (;;)
 	  {
-            if (thd->killed)
+            if (thd->get_killed())
             {
               /* 
                  we've been killed; let handler clean up, and remove the 
 
=== modified file 'Percona-Server/sql/sql_update.cc'
--- Percona-Server/sql/sql_update.cc	2012-12-04 08:24:59 +0000
+++ Percona-Server/sql/sql_update.cc	2013-01-09 13:41:38 +0000
@@ -622,7 +622,7 @@
       THD_STAGE_INFO(thd, stage_searching_rows_for_update);
       ha_rows tmp_limit= limit;
 
-      while (!(error=info.read_record(&info)) && !thd->killed)
+      while (!(error=info.read_record(&info)) && !thd->get_killed())
       {
         thd->inc_examined_row_count(1);
         bool skip_record= FALSE;
@@ -653,7 +653,7 @@
 	else
 	  table->file->unlock_row();
       }
-      if (thd->killed && !error)
+      if (thd->get_killed() && !error)
 	error= 1;				// Aborted
       limit= tmp_limit;
       table->file->try_semi_consistent_read(0);
@@ -724,7 +724,7 @@
       check_constant_expressions(values))
     read_removal= table->check_read_removal(select->quick->index);
 
-  while (!(error=info.read_record(&info)) && !thd->killed)
+  while (!(error=info.read_record(&info)) && !thd->get_killed())
   {
     thd->inc_examined_row_count(1);
     bool skip_record;
@@ -897,11 +897,11 @@
     It's assumed that if an error was set in combination with an effective 
     killed status then the error is due to killing.
   */
-  killed_status= thd->killed; // get the status of the volatile 
+  killed_status= thd->get_killed(); // get the status of the volatile 
   // simulated killing after the loop must be ineffective for binlogging
   DBUG_EXECUTE_IF("simulate_kill_bug27571",
                   {
-                    thd->killed= THD::KILL_QUERY;
+                    thd->set_killed(THD::KILL_QUERY);
                   };);
   error= (killed_status == THD::NOT_KILLED)?  error : 1;
   
@@ -2185,7 +2185,7 @@
         got caught and if happens later the killed error is written
         into repl event.
       */
-      int errcode= query_error_code(thd, thd->killed == THD::NOT_KILLED);
+      int errcode= query_error_code(thd, thd->get_killed() == THD::NOT_KILLED);
       /* the error of binary logging is ignored */
       (void)thd->binlog_query(THD::ROW_QUERY_TYPE,
                         thd->query(), thd->query_length(),
@@ -2249,7 +2249,7 @@
 
     for (;;)
     {
-      if (thd->killed && trans_safe)
+      if (thd->get_killed() && trans_safe)
 	goto err;
       if ((local_error=tmp_table->file->ha_rnd_next(tmp_table->record[0])))
       {
@@ -2389,7 +2389,7 @@
     if local_error is not set ON until after do_updates() then
     later carried out killing should not affect binlogging.
   */
-  killed_status= (local_error == 0)? THD::NOT_KILLED : thd->killed;
+  killed_status= (local_error == 0)? THD::NOT_KILLED : thd->get_killed();
   THD_STAGE_INFO(thd, stage_end);
 
   /* We must invalidate the query cache before binlog writing and
 
=== modified file 'Percona-Server/sql/sys_vars.cc'
--- Percona-Server/sql/sys_vars.cc	2012-12-04 08:24:59 +0000
+++ Percona-Server/sql/sys_vars.cc	2013-01-09 13:41:38 +0000
@@ -3519,6 +3519,12 @@
        SESSION_VAR(group_concat_max_len), CMD_LINE(REQUIRED_ARG),
        VALID_RANGE(4, ULONG_MAX), DEFAULT(1024), BLOCK_SIZE(1));
 
+static Sys_var_ulong Sys_sql_timeout(
+       "sql_timeout",
+       "Timeout in seconds to wait before killing query.",
+       SESSION_VAR(sql_timeout), CMD_LINE(REQUIRED_ARG),
+       VALID_RANGE(0, ULONG_MAX), DEFAULT(0), BLOCK_SIZE(1));
+
 static char *glob_hostname_ptr;
 static Sys_var_charptr Sys_hostname(
        "hostname", "Server host name",
 
=== modified file 'Percona-Server/sql/table.cc'
--- Percona-Server/sql/table.cc	2012-12-04 08:24:59 +0000
+++ Percona-Server/sql/table.cc	2013-01-09 13:41:38 +0000
@@ -3941,7 +3941,7 @@
 
 void TABLE_LIST::hide_view_error(THD *thd)
 {
-  if (thd->killed || thd->get_internal_handler())
+  if (thd->get_killed() || thd->get_internal_handler())
     return;
   /* Hide "Unknown column" or "Unknown function" error */
   DBUG_ASSERT(thd->is_error());
 
=== modified file 'Percona-Server/storage/innobase/row/row0mysql.cc'
--- Percona-Server/storage/innobase/row/row0mysql.cc	2012-12-17 22:22:38 +0000
+++ Percona-Server/storage/innobase/row/row0mysql.cc	2013-01-09 13:41:38 +0000
@@ -5062,7 +5062,7 @@
 
 	ret = row_search_for_mysql(buf, PAGE_CUR_G, prebuilt, 0, 0);
 loop:
-	/* Check thd->killed every 1,000 scanned rows */
+	/* Check thd->get_killed() every 1,000 scanned rows */
 	if (--cnt == 0) {
 		if (trx_is_interrupted(prebuilt->trx)) {
 			goto func_exit;
 
=== modified file 'Percona-Server/storage/myisam/ha_myisam.cc'
--- Percona-Server/storage/myisam/ha_myisam.cc	2012-10-16 06:21:51 +0000
+++ Percona-Server/storage/myisam/ha_myisam.cc	2013-01-09 13:41:38 +0000
@@ -118,7 +118,7 @@
   THD *thd;
   thd= current_thd;
   prev_info= thd_proc_info(thd, info);
-  while(!thd->killed)
+  while(!thd->get_killed())
     my_sleep(1000);
   DBUG_PRINT("info", ("Exit debug_wait_for_kill"));
   thd_proc_info(thd, prev_info);
@@ -562,10 +562,10 @@
 
 extern "C" {
 
-volatile int *killed_ptr(MI_CHECK *param)
+int killed_status(MI_CHECK *param)
 {
   /* In theory Unsafe conversion, but should be ok for now */
-  return (int*) &(((THD *)(param->thd))->killed);
+  return (int) (((THD *)(param->thd))->get_killed());
 }
 
 void mi_check_print_error(MI_CHECK *param, const char *fmt,...)
@@ -902,7 +902,7 @@
 	   HA_STATUS_CONST);
     }
   }
-  else if (!mi_is_crashed(file) && !thd->killed)
+  else if (!mi_is_crashed(file) && !thd->get_killed())
   {
     mi_mark_crashed(file);
     file->update |= HA_STATE_CHANGED | HA_STATE_ROW_CHANGED;
@@ -945,7 +945,7 @@
     error=update_state_info(&param,file,UPDATE_STAT);
     mysql_mutex_unlock(&share->intern_lock);
   }
-  else if (!mi_is_crashed(file) && !thd->killed)
+  else if (!mi_is_crashed(file) && !thd->get_killed())
     mi_mark_crashed(file);
   return error ? HA_ADMIN_CORRUPT : HA_ADMIN_OK;
 }
@@ -1537,7 +1537,7 @@
      */
    
       if (((err= enable_indexes(HA_KEY_SWITCH_NONUNIQ_SAVE)) != 0) && 
-                                                  current_thd->killed)
+                                                  current_thd->get_killed())
       {
         delete_all_rows();
         /* not crashed, despite being killed during repair */
 
=== modified file 'Percona-Server/storage/myisam/mi_check.c'
--- Percona-Server/storage/myisam/mi_check.c	2012-09-12 14:19:10 +0000
+++ Percona-Server/storage/myisam/mi_check.c	2013-01-09 13:41:38 +0000
@@ -164,7 +164,7 @@
     empty=0;
     for (i= info->state->del ; i > 0L && next_link != HA_OFFSET_ERROR ; i--)
     {
-      if (*killed_ptr(param))
+      if (killed_status(param))
         DBUG_RETURN(1);
       if (test_flag & T_VERBOSE)
 	printf(" %9s",llstr(next_link,buff));
@@ -259,7 +259,7 @@
   records= (ha_rows) (info->state->key_file_length / block_size);
   while (next_link != HA_OFFSET_ERROR && records > 0)
   {
-    if (*killed_ptr(param))
+    if (killed_status(param))
       DBUG_RETURN(1);
     if (param->testflag & T_VERBOSE)
       printf("%16s",llstr(next_link,llbuff));
@@ -773,7 +773,7 @@
   }
   for ( ;; )
   {
-    if (*killed_ptr(param))
+    if (killed_status(param))
       goto err;
     memcpy((char*) info->lastkey,(char*) key,key_length);
     info->lastkey_length=key_length;
@@ -985,7 +985,7 @@
   memset(key_checksum, 0, info->s->base.keys * sizeof(key_checksum[0]));
   while (pos < info->state->data_file_length)
   {
-    if (*killed_ptr(param))
+    if (killed_status(param))
       goto err2;
     switch (info->s->data_file_type) {
     case STATIC_RECORD:
@@ -3253,7 +3253,7 @@
   char llbuff[22],llbuff2[22];
   DBUG_ENTER("sort_get_next_record");
 
-  if (*killed_ptr(param))
+  if (killed_status(param))
     DBUG_RETURN(1);
 
   switch (share->data_file_type) {
 
=== modified file 'Percona-Server/storage/myisam/myisamchk.c'
--- Percona-Server/storage/myisam/myisamchk.c	2012-08-22 01:40:20 +0000
+++ Percona-Server/storage/myisam/myisamchk.c	2013-01-09 13:41:38 +0000
@@ -1702,11 +1702,9 @@
   sorting
 */
 
-static int not_killed= 0;
-
-volatile int *killed_ptr(MI_CHECK *param __attribute__((unused)))
+int killed_status(MI_CHECK *param __attribute__((unused)))
 {
-  return &not_killed;			/* always NULL */
+  return 0;			/* always NULL */
 }
 
 	/* print warnings and errors */
 
=== modified file 'Percona-Server/storage/myisam/myisamdef.h'
--- Percona-Server/storage/myisam/myisamdef.h	2012-03-06 14:29:42 +0000
+++ Percona-Server/storage/myisam/myisamdef.h	2013-01-09 13:41:38 +0000
@@ -769,7 +769,7 @@
 int mi_check_index_cond(register MI_INFO *info, uint keynr, uchar *record);
 
     /* Functions needed by mi_check */
-volatile int *killed_ptr(MI_CHECK *param);
+int killed_status(MI_CHECK *param);
 void mi_check_print_error(MI_CHECK *param, const char *fmt,...);
 void mi_check_print_warning(MI_CHECK *param, const char *fmt,...);
 void mi_check_print_info(MI_CHECK *param, const char *fmt,...);
 
=== modified file 'Percona-Server/storage/myisam/sort.c'
--- Percona-Server/storage/myisam/sort.c	2012-03-06 14:29:42 +0000
+++ Percona-Server/storage/myisam/sort.c	2013-01-09 13:41:38 +0000
@@ -910,7 +910,7 @@
   uchar *strpos;
   BUFFPEK *buffpek,**refpek;
   QUEUE queue;
-  volatile int *killed= killed_ptr(info->sort_info->param);
+  int killed= killed_status(info->sort_info->param);
   DBUG_ENTER("merge_buffers");
 
   count=error=0;
@@ -943,7 +943,7 @@
   {
     for (;;)
     {
-      if (*killed)
+      if (killed)
       {
         error=1; goto err;
       }