Bug#23251517: SEMISYNC REPLICATION HANGING

Revert following bug fix:

Bug#20685029: SLAVE IO THREAD SHOULD STOP WHEN DISK IS
FULL
Bug#21753696: MAKE SHOW SLAVE STATUS NON BLOCKING IF IO
THREAD WAITS FOR DISK SPACE

This fix results in a deadlock between slave IO thread
and SQL thread.

(cherry picked from commit e3fea6c6dbb36c6ab21c4ab777224560e9608b53)

mysql-test/include/assert_grep.inc

@@ -1,154 +0,0 @@
-# ==== Purpose ====
-#
-# Grep a file for a pattern, produce a single string out of the
-# matching lines, and assert that the string matches a given regular
-# expression.
-#
-# ==== Usage ====
-#
-# --let $assert_text= TEXT
-# --let $assert_file= FILE
-# --let $assert_select= REGEX
-# [--let $assert_match= REGEX | --let $assert_count= NUMBER]
-# [--let $assert_only_after= REGEX]
-# --source include/assert_grep.inc
-#
-# Parameters:
-#
-#   $assert_text
-#     Text that describes what is being checked. This text is written to
-#     the query log so it should not contain non-deterministic elements.
-#
-#   $assert_file
-#     File to search.
-#
-#   $assert_select
-#     All lines matching this text will be checked.
-#
-#   $assert_match
-#     The script will find all lines that match $assert_select,
-#     concatenate them to a long string, and assert that it matches
-#     $assert_match.
-#
-#   $assert_count
-#     Instead of asserting that the selected lines match
-#     $assert_match, assert that there were exactly $assert_count
-#     matching lines.
-#
-#   $assert_only_after
-#     Reset all the lines matched and the counter when finding this pattern.
-#     It is useful for searching things in the mysqld.err log file just
-#     after the last server restart for example (discarding the log content
-#     of previous server executions).
-
-
-if (!$assert_text)
-{
-  --die !!!ERROR IN TEST: you must set $assert_text
-}
-if (!$assert_file)
-{
-  --die !!!ERROR IN TEST: you must set $assert_file
-}
-if (!$assert_select)
-{
-  --die !!!ERROR IN TEST: you must set $assert_select
-}
-if ($assert_match == '')
-{
-  if ($assert_count == '')
-  {
-    --die !!!ERROR IN TEST: you must set either $assert_match or $assert_count
-  }
-}
-if ($assert_match != '')
-{
-  if ($assert_count != '')
-  {
-    --echo assert_text='$assert_text' assert_count='$assert_count'
-    --die !!!ERROR IN TEST: you must set only one of $assert_match or $assert_count
-  }
-}
-
-
---let $include_filename= assert_grep.inc [$assert_text]
---source include/begin_include_file.inc
-
-
---let _AG_ASSERT_TEXT= $assert_text
---let _AG_ASSERT_FILE= $assert_file
---let _AG_ASSERT_SELECT= $assert_select
---let _AG_ASSERT_MATCH= $assert_match
---let _AG_ASSERT_COUNT= $assert_count
---let _AG_OUT= `SELECT CONCAT('$MYSQLTEST_VARDIR/tmp/_ag_', UUID())`
---let _AG_ASSERT_ONLY_AFTER= $assert_only_after
-
-
---perl
-  use strict;
-  use warnings;
-  my $file= $ENV{'_AG_ASSERT_FILE'};
-  my $assert_select= $ENV{'_AG_ASSERT_SELECT'};
-  my $assert_match= $ENV{'_AG_ASSERT_MATCH'};
-  my $assert_count= $ENV{'_AG_ASSERT_COUNT'};
-  my $assert_only_after= $ENV{'_AG_ASSERT_ONLY_AFTER'};
-  my $out= $ENV{'_AG_OUT'};
-
-  my $result= '';
-  my $count= 0;
-  open(FILE, "$file") or die("Error $? opening $file: $!\n");
-  while (<FILE>) {
-    my $line = $_;
-    if ($assert_only_after && $line =~ /$assert_only_after/) {
-      $result = "";
-      $count = 0;
-    }
-    if ($line =~ /$assert_select/) {
-      if ($assert_count ne '') {
-        $count++;
-      }
-      else {
-        $result .= $line;
-      }
-    }
-  }
-  close(FILE) or die("Error $? closing $file: $!");
-  open OUT, "> $out" or die("Error $? opening $out: $!");
-  if ($assert_count ne '' && ($count != $assert_count)) {
-    print OUT ($count) or die("Error $? writing $out: $!");
-  }
-  elsif ($assert_count eq '' && $result !~ /$assert_match/) {
-    print OUT ($result) or die("Error $? writing $out: $!");
-  }
-  else {
-    print OUT ("assert_grep.inc ok");
-  }
-  close OUT or die("Error $? closing $out: $!");
-EOF
-
-
---let $_ag_outcome= `SELECT LOAD_FILE('$_AG_OUT')`
-if ($_ag_outcome != 'assert_grep.inc ok')
-{
-  --source include/show_rpl_debug_info.inc
-  --echo include/assert_grep.inc failed!
-  --echo assert_text: '$assert_text'
-  --echo assert_file: '$assert_file'
-  --echo assert_select: '$assert_select'
-  --echo assert_match: '$assert_match'
-  --echo assert_count: '$assert_count'
-  --echo assert_only_after: '$assert_only_after'
-  if ($assert_match != '')
-  {
-    --echo matching lines: '$_ag_outcome'
-  }
-  if ($assert_count != '')
-  {
-    --echo number of matching lines: $_ag_outcome
-  }
-  --die assert_grep.inc failed.
-}
-
-
---let $include_filename= include/assert_grep.inc [$assert_text]
---source include/end_include_file.inc

mysql-test/include/rpl_init.inc

@@ -43,7 +43,6 @@
 #
 #    [--let $rpl_server_count= 7]
 #    --let $rpl_topology= 1->2->3->1->4, 2->5, 6->7
-#    [--let $rpl_extra_connections_per_server= 1]
 #    [--let $rpl_check_server_ids= 1]
 #    [--let $rpl_skip_change_master= 1]
 #    [--let $rpl_skip_start_slave= 1]
@@ -66,12 +65,6 @@
 #      want to specify the empty topology (no server replicates at
 #      all), you have to set $rpl_topology=none.
 #
-#    $rpl_extra_connections_per_server
-#      By default, this script creates connections server_N and
-#      server_N_1.  If you can set this variable to a number, the
-#      script creates:
-#      server_N, server_N_1, ..., server_N_$rpl_extra_connections_per_server
-#
 #    $rpl_check_server_ids
 #      If $rpl_check_server_ids is set, this script checks that the
 #      @@server_id of all servers are different. This is normally
@@ -146,17 +139,8 @@ if (!$SERVER_MYPORT_4)
 # Check that $rpl_server_count is set
 if (!$rpl_server_count)
 {
-  --let $rpl_server_count= `SELECT REPLACE('$rpl_topology', '->', ',')`
+  --let $_compute_rpl_server_count= `SELECT REPLACE('$rpl_topology', '->', ',')`
-  if (`SELECT LOCATE(',', '$rpl_server_count')`)
+  --let $rpl_server_count= `SELECT GREATEST($_compute_rpl_server_count)`
-  {
-    --let $rpl_server_count= `SELECT GREATEST($rpl_server_count)`
-  }
-}
-
---let $_rpl_extra_connections_per_server= $rpl_extra_connections_per_server
-if ($_rpl_extra_connections_per_server == '')
-{
-  --let $_rpl_extra_connections_per_server= 1
 }
 
 
@@ -175,20 +159,15 @@ if (!$rpl_debug)
 # Create two connections to each server; reset master/slave, select
 # database, set autoinc variables.
 --let $_rpl_server= $rpl_server_count
---let $underscore= _
+--let $_rpl_one= _1
 while ($_rpl_server)
 {
   # Connect.
   --let $rpl_server_number= $_rpl_server
   --let $rpl_connection_name= server_$_rpl_server
   --source include/rpl_connect.inc
-  --let $_rpl_connection_number= 1
+  --let $rpl_connection_name= server_$_rpl_server$_rpl_one
-  while ($_rpl_connection_number <= $_rpl_extra_connections_per_server)
-  {
-    --let $rpl_connection_name= server_$_rpl_server$underscore$_rpl_connection_number
   --source include/rpl_connect.inc
-    --inc $_rpl_connection_number
-  }
 
   # Configure server.
   --let $rpl_connection_name= server_$_rpl_server

mysql-test/include/rpl_reconnect.inc

@@ -12,7 +12,6 @@
 # ==== Usage ====
 #
 # --let $rpl_server_number= N
-# [--let $rpl_extra_connections_per_server= 1]
 # [--let $rpl_debug= 1]
 # --source include/rpl_reconnect.inc
 #
@@ -22,7 +21,7 @@
 #     master server, 2 the slave server, 3 the 3rd server, and so on.
 #     Cf. include/rpl_init.inc
 #
-#   $rpl_extra_connections_per_server, $rpl_debug
+#   $rpl_debug
 #     See include/rpl_init.inc
 
 --let $include_filename= rpl_reconnect.inc
@@ -33,11 +32,6 @@ if (!$rpl_server_number)
   --die ERROR IN TEST: you must set $rpl_server_number before you source rpl_connect.inc
 }
 
-if ($_rpl_extra_connections_per_server == '')
-{
-  --let $_rpl_extra_connections_per_server= 1
-}
-
 
 if ($rpl_debug)
 {
@@ -78,14 +72,10 @@ if (!$_rpl_server_number)
 --source include/rpl_connection.inc
 --enable_reconnect
 
---let $_rpl_connection_number= 1
+--let $_rpl_one= _1
-while ($_rpl_connection_number <= $_rpl_extra_connections_per_server)
+--let $rpl_connection_name= server_$rpl_server_number$_rpl_one
-{
+--source include/rpl_connection.inc
-  --let $rpl_connection_name= server_$rpl_server_number$underscore$_rpl_connection_number
+--enable_reconnect
-  --source include/rpl_connection.inc
-  --enable_reconnect
-  --inc $_rpl_connection_number
-}
 
 if ($rpl_debug)
 {
@@ -132,15 +122,10 @@ if (!$_rpl_server_number)
 --source include/wait_until_connected_again.inc
 --disable_reconnect
 
---let $_rpl_connection_number= 1
+--let $rpl_connection_name= server_$rpl_server_number$_rpl_one
-while ($_rpl_connection_number <= $_rpl_extra_connections_per_server)
+--source include/rpl_connection.inc
-{
+--source include/wait_until_connected_again.inc
-  --let $rpl_connection_name= server_$rpl_server_number$underscore$_rpl_connection_number
+--disable_reconnect
-  --source include/rpl_connection.inc
-  --source include/wait_until_connected_again.inc
-  --disable_reconnect
-  --inc $_rpl_connection_number
-}
 
 
 --let $include_filename= rpl_reconnect.inc

mysql-test/include/start_slave_sql.inc

@@ -1,39 +0,0 @@
-# ==== Purpose ====
-#
-# Issues START SLAVE SQL_THREAD on the current connection. Then waits
-# until the SQL thread has started, or until a timeout is reached.
-#
-# Please use this instead of 'START SLAVE SQL_THREAD', to reduce the
-# risk of races in test cases.
-#
-#
-# ==== Usage ====
-#
-# [--let $slave_timeout= NUMBER]
-# [--let $rpl_debug= 1]
-# --source include/start_slave_sql.inc
-#
-# Parameters:
-#   $slave_timeout
-#     See include/wait_for_slave_param.inc
-#
-#   $rpl_debug
-#     See include/rpl_init.inc
-
-
---let $include_filename= start_slave_sql.inc
---source include/begin_include_file.inc
-
-
-if (!$rpl_debug)
-{
-  --disable_query_log
-}
-
-
-START SLAVE SQL_THREAD;
---source include/wait_for_slave_sql_to_start.inc
-
-
---let $include_filename= start_slave_sql.inc
---source include/end_include_file.inc

mysql-test/suite/rpl/r/rpl_io_thd_wait_for_disk_space.result

@@ -1,15 +0,0 @@
-include/master-slave.inc
-[connection master]
-CREATE TABLE t1(a INT);
-INSERT INTO t1 VALUES(1);
-CALL mtr.add_suppression("Disk is full writing");
-CALL mtr.add_suppression("Retry in 60 secs");
-include/stop_slave_sql.inc
-SET @@GLOBAL.DEBUG= 'd,simulate_io_thd_wait_for_disk_space';
-INSERT INTO t1 VALUES(2);
-SET DEBUG_SYNC='now WAIT_FOR parked';
-SET @@GLOBAL.DEBUG= '$debug_saved';
-include/assert_grep.inc [Found the disk full error message on the slave]
-include/start_slave_sql.inc
-DROP TABLE t1;
-include/rpl_end.inc

mysql-test/suite/rpl/t/rpl_io_thd_wait_for_disk_space.test

@@ -1,71 +0,0 @@
-# ==== Purpose ====
-#
-# Check that the execution of SHOW SLAVE STATUS command is not blocked when IO
-# thread is blocked waiting for disk space.
-#
-# ==== Implementation ====
-#
-# Simulate a scenario where IO thread is waiting for disk space while writing
-# into the relay log. Execute SHOW SLAVE STATUS command after IO thread is
-# blocked waiting for space. The command should not be blocked.
-#
-# ==== References ====
-#
-# Bug#21753696: MAKE SHOW SLAVE STATUS NON BLOCKING IF IO THREAD WAITS FOR
-# DISK SPACE
-# Bug#20685029: SLAVE IO THREAD SHOULD STOP WHEN DISK IS FULL
-#
-###############################################################################
---source include/have_debug.inc
-# Inorder to grep a specific error pattern in error log a fresh error log
-# needs to be generated.
---source include/force_restart.inc
---source include/master-slave.inc
-
-# Generate events to be replicated to the slave
-CREATE TABLE t1(a INT);
-INSERT INTO t1 VALUES(1);
---sync_slave_with_master
-
-# Those errors will only happen in the slave
-CALL mtr.add_suppression("Disk is full writing");
-CALL mtr.add_suppression("Retry in 60 secs");
-
-# Stop the SQL thread to avoid writing on disk
---source include/stop_slave_sql.inc
-
-# Set the debug option that will simulate disk full
---let $debug_saved= `SELECT @@GLOBAL.DEBUG`
-SET @@GLOBAL.DEBUG= 'd,simulate_io_thd_wait_for_disk_space';
-
-# Generate events to be replicated to the slave
---connection master
-INSERT INTO t1 VALUES(2);
-
---connection slave1
-SET DEBUG_SYNC='now WAIT_FOR parked';
-
-# Get the relay log file name using SHOW SLAVE STATUS
---let $relay_log_file= query_get_value(SHOW SLAVE STATUS, Relay_Log_File, 1)
-
---connection slave
-# Restore the debug options to "simulate" freed space on disk
-SET @@GLOBAL.DEBUG= '$debug_saved';
-
-# There should be a message in the error log of the slave stating
-# that it was waiting for space to write on the relay log.
---let $assert_file=$MYSQLTEST_VARDIR/log/mysqld.2.err
-# Grep only after the message that the I/O thread has started
---let $assert_only_after= Slave I/O .* connected to master .*replication started in log .* at position
---let $assert_count= 1
---let $assert_select=Disk is full writing .*$relay_log_file.*
---let $assert_text= Found the disk full error message on the slave
---source include/assert_grep.inc
-
-# Start the SQL thread to let the slave to sync and finish gracefully
---source include/start_slave_sql.inc
-
-# Cleanup
---connection master
-DROP TABLE t1;
---source include/rpl_end.inc

mysys/errors.c

@@ -15,7 +15,7 @@
 
 #include "mysys_priv.h"
 #include "mysys_err.h"
-#include "m_string.h"
+
 #ifndef SHARED_LIBRARY
 
 const char *globerrs[GLOBERRS]=
@@ -109,7 +109,6 @@ void init_glob_errs()
 */
 void wait_for_free_space(const char *filename, int errors)
 {
-  size_t time_to_sleep= MY_WAIT_FOR_USER_TO_FIX_PANIC;
   if (!(errors % MY_WAIT_GIVE_USER_A_MESSAGE))
   {
     my_printf_warning(EE(EE_DISK_FULL),
@@ -120,15 +119,10 @@ void wait_for_free_space(const char *filename, int errors)
   }
   DBUG_EXECUTE_IF("simulate_no_free_space_error",
                  {
-                   time_to_sleep= 1;
+                   (void) sleep(1);
+                   return;
                  });
-  DBUG_EXECUTE_IF("simulate_io_thd_wait_for_disk_space",
+  (void) sleep(MY_WAIT_FOR_USER_TO_FIX_PANIC);
-                 {
-                   time_to_sleep= 1;
-                 });
-
-  (void) sleep(time_to_sleep);
-  DEBUG_SYNC_C("disk_full_reached");
 }
 
 const char **get_global_errmsgs()

mysys/my_write.c

@@ -24,7 +24,6 @@ size_t my_write(File Filedes, const uchar *Buffer, size_t Count, myf MyFlags)
 {
   size_t writtenbytes, written;
   uint errors;
-  size_t ToWriteCount;
   DBUG_ENTER("my_write");
   DBUG_PRINT("my",("fd: %d  Buffer: %p  Count: %lu  MyFlags: %d",
 		   Filedes, Buffer, (ulong) Count, MyFlags));
@@ -38,14 +37,11 @@ size_t my_write(File Filedes, const uchar *Buffer, size_t Count, myf MyFlags)
                    { DBUG_SET("+d,simulate_file_write_error");});
   for (;;)
   {
-    ToWriteCount= Count;
-    DBUG_EXECUTE_IF("simulate_io_thd_wait_for_disk_space", { ToWriteCount= 1; });
 #ifdef _WIN32
-    writtenbytes= my_win_write(Filedes, Buffer, ToWriteCount);
+    writtenbytes= my_win_write(Filedes, Buffer, Count);
 #else
-    writtenbytes= write(Filedes, Buffer, ToWriteCount);
+    writtenbytes= write(Filedes, Buffer, Count);
 #endif
-    DBUG_EXECUTE_IF("simulate_io_thd_wait_for_disk_space", { errno= ENOSPC; });
     DBUG_EXECUTE_IF("simulate_file_write_error",
                     {
                       errno= ENOSPC;

sql/log.cc

@@ -37,7 +37,6 @@
 #include "log_event.h"          // Query_log_event
 #include "rpl_filter.h"
 #include "rpl_rli.h"
-#include "rpl_mi.h"
 #include "sql_audit.h"
 
 #include "sql_show.h"
@@ -4378,22 +4377,13 @@ end:
 }
 
 
-#ifdef HAVE_REPLICATION
+bool MYSQL_BIN_LOG::append(Log_event* ev)
-bool MYSQL_BIN_LOG::append(Log_event* ev,  Master_info *mi)
 {
   bool error = 0;
-  mysql_mutex_assert_owner(&mi->data_lock);
   mysql_mutex_lock(&LOCK_log);
   DBUG_ENTER("MYSQL_BIN_LOG::append");
 
   DBUG_ASSERT(log_file.type == SEQ_READ_APPEND);
-  /*
-    Release data_lock by holding LOCK_log, while writing into the relay log.
-    If slave IO thread waits here for free space, we don't want
-    SHOW SLAVE STATUS to hang on mi->data_lock. Note LOCK_log mutex is
-    sufficient to block SQL thread when IO thread is updating relay log here.
-  */
-  mysql_mutex_unlock(&mi->data_lock);
   /*
     Log_event::write() is smart enough to use my_b_write() or
     my_b_append() depending on the kind of cache we have.
@@ -4408,58 +4398,24 @@ bool MYSQL_BIN_LOG::append(Log_event* ev,  Master_info *mi)
   if (flush_and_sync(0))
     goto err;
   if ((uint) my_b_append_tell(&log_file) > max_size)
-  {
-    /*
-      If rotation is required we must acquire data_lock to protect
-      description_event from clients executing FLUSH LOGS in parallel.
-      In order do that we must release the existing LOCK_log so that we
-      get it once again in proper locking order to avoid dead locks.
-      i.e data_lock , LOCK_log.
-    */
-    mysql_mutex_unlock(&LOCK_log);
-    mysql_mutex_lock(&mi->data_lock);
-    mysql_mutex_lock(&LOCK_log);
     error= new_file_without_locking();
-    /*
-      After rotation release data_lock, we need the LOCK_log till we signal
-      the updation.
-    */
-    mysql_mutex_unlock(&mi->data_lock);
-  }
 err:
-  signal_update();				// Safe as we don't call close
   mysql_mutex_unlock(&LOCK_log);
-  mysql_mutex_lock(&mi->data_lock);
+  signal_update();				// Safe as we don't call close
   DBUG_RETURN(error);
 }
 
 
-bool MYSQL_BIN_LOG::appendv(Master_info* mi, const char* buf, uint len,...)
+bool MYSQL_BIN_LOG::appendv(const char* buf, uint len,...)
 {
   bool error= 0;
   DBUG_ENTER("MYSQL_BIN_LOG::appendv");
   va_list(args);
   va_start(args,len);
 
-  mysql_mutex_assert_owner(&mi->data_lock);
-  mysql_mutex_lock(&LOCK_log);
   DBUG_ASSERT(log_file.type == SEQ_READ_APPEND);
 
-  /*
+  mysql_mutex_assert_owner(&LOCK_log);
-    Release data_lock by holding LOCK_log, while writing into the relay log.
-    If slave IO thread waits here for free space, we don't want
-    SHOW SLAVE STATUS to hang on mi->data_lock. Note LOCK_log mutex is
-    sufficient to block SQL thread when IO thread is updating relay log here.
-  */
-  mysql_mutex_unlock(&mi->data_lock);
-  DBUG_EXECUTE_IF("simulate_io_thd_wait_for_disk_space",
-                  {
-                  const char act[]= "disk_full_reached SIGNAL parked";
-                  DBUG_ASSERT(opt_debug_sync_timeout > 0);
-                  DBUG_ASSERT(!debug_sync_set_action(current_thd,
-                                                     STRING_WITH_LEN(act)));
-                  };);
-
   do
   {
     if (my_b_append(&log_file,(uchar*) buf,len))
@@ -4472,34 +4428,13 @@ bool MYSQL_BIN_LOG::appendv(Master_info* mi, const char* buf, uint len,...)
   DBUG_PRINT("info",("max_size: %lu",max_size));
   if (flush_and_sync(0))
     goto err;
-  if ((uint) my_b_append_tell(&log_file) >
+  if ((uint) my_b_append_tell(&log_file) > max_size)
-      DBUG_EVALUATE_IF("rotate_slave_debug_group", 500, max_size))
-  {
-    /*
-      If rotation is required we must acquire data_lock to protect
-      description_event from clients executing FLUSH LOGS in parallel.
-      In order do that we must release the existing LOCK_log so that we
-      get it once again in proper locking order to avoid dead locks.
-      i.e data_lock , LOCK_log.
-    */
-    mysql_mutex_unlock(&LOCK_log);
-    mysql_mutex_lock(&mi->data_lock);
-    mysql_mutex_lock(&LOCK_log);
     error= new_file_without_locking();
-    /*
-      After rotation release data_lock, we need the LOCK_log till we signal
-      the updation.
-    */
-    mysql_mutex_unlock(&mi->data_lock);
-  }
 err:
   if (!error)
     signal_update();
-  mysql_mutex_unlock(&LOCK_log);
-  mysql_mutex_lock(&mi->data_lock);
   DBUG_RETURN(error);
 }
-#endif
 
 bool MYSQL_BIN_LOG::flush_and_sync(bool *synced)
 {

sql/log.h

@@ -20,7 +20,6 @@
 #include "handler.h"                            /* my_xid */
 
 class Relay_log_info;
-class Master_info;
 
 class Format_description_log_event;
 
@@ -455,8 +454,8 @@ public:
     v stands for vector
     invoked as appendv(buf1,len1,buf2,len2,...,bufn,lenn,0)
   */
-  bool appendv(Master_info* mi, const char* buf,uint len,...);
+  bool appendv(const char* buf,uint len,...);
-  bool append(Log_event* ev, Master_info* mi);
+  bool append(Log_event* ev);
 
   void make_log_name(char* buf, const char* log_ident);
   bool is_active(const char* log_file_name);

sql/slave.cc

@@ -1660,7 +1660,7 @@ Waiting for the slave SQL thread to free enough relay log space");
 #endif
     if (rli->sql_force_rotate_relay)
     {
-      rotate_relay_log(rli->mi, true/*need_data_lock=true*/);
+      rotate_relay_log(rli->mi);
       rli->sql_force_rotate_relay= false;
     }
 
@@ -1705,7 +1705,7 @@ static void write_ignored_events_info_to_relay_log(THD *thd, Master_info *mi)
     if (likely((bool)ev))
     {
       ev->server_id= 0; // don't be ignored by slave SQL thread
-      if (unlikely(rli->relay_log.append(ev, mi)))
+      if (unlikely(rli->relay_log.append(ev)))
         mi->report(ERROR_LEVEL, ER_SLAVE_RELAY_LOG_WRITE_FAILURE,
                    ER(ER_SLAVE_RELAY_LOG_WRITE_FAILURE),
                    "failed to write a Rotate event"
@@ -3605,7 +3605,7 @@ static int process_io_create_file(Master_info* mi, Create_file_log_event* cev)
           break;
         Execute_load_log_event xev(thd,0,0);
         xev.log_pos = cev->log_pos;
-        if (unlikely(mi->rli.relay_log.append(&xev, mi)))
+        if (unlikely(mi->rli.relay_log.append(&xev)))
         {
           mi->report(ERROR_LEVEL, ER_SLAVE_RELAY_LOG_WRITE_FAILURE,
                      ER(ER_SLAVE_RELAY_LOG_WRITE_FAILURE),
@@ -3619,7 +3619,7 @@ static int process_io_create_file(Master_info* mi, Create_file_log_event* cev)
       {
         cev->block = net->read_pos;
         cev->block_len = num_bytes;
-        if (unlikely(mi->rli.relay_log.append(cev, mi)))
+        if (unlikely(mi->rli.relay_log.append(cev)))
         {
           mi->report(ERROR_LEVEL, ER_SLAVE_RELAY_LOG_WRITE_FAILURE,
                      ER(ER_SLAVE_RELAY_LOG_WRITE_FAILURE),
@@ -3634,7 +3634,7 @@ static int process_io_create_file(Master_info* mi, Create_file_log_event* cev)
         aev.block = net->read_pos;
         aev.block_len = num_bytes;
         aev.log_pos = cev->log_pos;
-        if (unlikely(mi->rli.relay_log.append(&aev, mi)))
+        if (unlikely(mi->rli.relay_log.append(&aev)))
         {
           mi->report(ERROR_LEVEL, ER_SLAVE_RELAY_LOG_WRITE_FAILURE,
                      ER(ER_SLAVE_RELAY_LOG_WRITE_FAILURE),
@@ -3713,7 +3713,7 @@ static int process_io_rotate(Master_info *mi, Rotate_log_event *rev)
     Rotate the relay log makes binlog format detection easier (at next slave
     start or mysqlbinlog)
   */
-  DBUG_RETURN(rotate_relay_log(mi, false/*need_data_lock=false*/));
+  DBUG_RETURN(rotate_relay_log(mi) /* will take the right mutexes */);
 }
 
 /*
@@ -3819,7 +3819,7 @@ static int queue_binlog_ver_1_event(Master_info *mi, const char *buf,
       Log_event::Log_event(const char* buf...) in log_event.cc).
       */
       ev->log_pos+= event_len; /* make log_pos be the pos of the end of the event */
-    if (unlikely(rli->relay_log.append(ev, mi)))
+    if (unlikely(rli->relay_log.append(ev)))
     {
       delete ev;
       mysql_mutex_unlock(&mi->data_lock);
@@ -3875,7 +3875,7 @@ static int queue_binlog_ver_3_event(Master_info *mi, const char *buf,
     inc_pos= event_len;
     break;
   }
-  if (unlikely(rli->relay_log.append(ev, mi)))
+  if (unlikely(rli->relay_log.append(ev)))
   {
     delete ev;
     mysql_mutex_unlock(&mi->data_lock);
@@ -4083,6 +4083,7 @@ static int queue_event(Master_info* mi,const char* buf, ulong event_len)
      direct master (an unsupported, useless setup!).
   */
 
+  mysql_mutex_lock(log_lock);
   s_id= uint4korr(buf + SERVER_ID_OFFSET);
   if ((s_id == ::server_id && !mi->rli.replicate_same_server_id) ||
       /*
@@ -4115,7 +4116,6 @@ static int queue_event(Master_info* mi,const char* buf, ulong event_len)
       IGNORE_SERVER_IDS it increments mi->master_log_pos
       as well as rli->group_relay_log_pos.
     */
-    mysql_mutex_lock(log_lock);
     if (!(s_id == ::server_id && !mi->rli.replicate_same_server_id) ||
         (buf[EVENT_TYPE_OFFSET] != FORMAT_DESCRIPTION_EVENT &&
          buf[EVENT_TYPE_OFFSET] != ROTATE_EVENT &&
@@ -4127,14 +4127,13 @@ static int queue_event(Master_info* mi,const char* buf, ulong event_len)
       rli->ign_master_log_pos_end= mi->master_log_pos;
     }
     rli->relay_log.signal_update(); // the slave SQL thread needs to re-check
-    mysql_mutex_unlock(log_lock);
     DBUG_PRINT("info", ("master_log_pos: %lu, event originating from %u server, ignored",
                         (ulong) mi->master_log_pos, uint4korr(buf + SERVER_ID_OFFSET)));
   }
   else
   {
     /* write the event to the relay log */
-    if (likely(!(rli->relay_log.appendv(mi, buf,event_len,0))))
+    if (likely(!(rli->relay_log.appendv(buf,event_len,0))))
     {
       mi->master_log_pos+= inc_pos;
       DBUG_PRINT("info", ("master_log_pos: %lu", (ulong) mi->master_log_pos));
@@ -4144,10 +4143,9 @@ static int queue_event(Master_info* mi,const char* buf, ulong event_len)
     {
       error= ER_SLAVE_RELAY_LOG_WRITE_FAILURE;
     }
-    mysql_mutex_lock(log_lock);
     rli->ign_master_log_name_end[0]= 0; // last event is not ignored
-    mysql_mutex_unlock(log_lock);
   }
+  mysql_mutex_unlock(log_lock);
 
 skip_relay_logging:
   
@@ -5007,21 +5005,11 @@ err:
   locks; here we don't, so this function is mainly taking locks).
   Returns nothing as we cannot catch any error (MYSQL_BIN_LOG::new_file()
   is void).
-
-  @param mi Master_info for the IO thread.
-  @param need_data_lock If true, mi->data_lock will be acquired otherwise,
-  mi->data_lock must be held by the caller.
 */
 
-int rotate_relay_log(Master_info* mi, bool need_data_lock)
+int rotate_relay_log(Master_info* mi)
 {
   DBUG_ENTER("rotate_relay_log");
-  if (need_data_lock)
-    mysql_mutex_lock(&mi->data_lock);
-  else
-  {
-    mysql_mutex_assert_owner(&mi->data_lock);
-  }
   Relay_log_info* rli= &mi->rli;
   int error= 0;
 
@@ -5056,8 +5044,6 @@ int rotate_relay_log(Master_info* mi, bool need_data_lock)
   */
   rli->relay_log.harvest_bytes_written(&rli->log_space_total);
 end:
-  if (need_data_lock)
-    mysql_mutex_unlock(&mi->data_lock);
   DBUG_RETURN(error);
 }
 

sql/slave.h

@@ -205,7 +205,7 @@ int purge_relay_logs(Relay_log_info* rli, THD *thd, bool just_reset,
 		     const char** errmsg);
 void set_slave_thread_options(THD* thd);
 void set_slave_thread_default_charset(THD *thd, Relay_log_info const *rli);
-int rotate_relay_log(Master_info* mi, bool need_data_lock);
+int rotate_relay_log(Master_info* mi);
 int apply_event_and_update_pos(Log_event* ev, THD* thd, Relay_log_info* rli);
 
 pthread_handler_t handle_slave_io(void *arg);

sql/sql_reload.cc

@@ -157,7 +157,7 @@ bool reload_acl_and_cache(THD *thd, unsigned long options,
   {
 #ifdef HAVE_REPLICATION
     mysql_mutex_lock(&LOCK_active_mi);
-    if (rotate_relay_log(active_mi, true/*need_data_lock=true*/))
+    if (rotate_relay_log(active_mi))
       *write_to_binlog= -1;
     mysql_mutex_unlock(&LOCK_active_mi);
 #endif