Merge branch 'mysql-5.7' into mysql-trunk

Author: Sujatha Sivakumar

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

@@ -21,7 +21,6 @@
 #include "mysys_err.h"
 #include "my_sys.h"
 #include "my_thread_local.h"
-#include "m_string.h"
 
 const char *globerrs[GLOBERRS]=
 {
@@ -72,7 +71,6 @@ const char *globerrs[GLOBERRS]=
 */
 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))
   {
     char errbuf[MYSYS_STRERROR_SIZE];
@@ -86,15 +84,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",
-                 {
-                   time_to_sleep= 1;
-                 });
-
-  (void) sleep(time_to_sleep);
-  DEBUG_SYNC_C("disk_full_reached");
+  (void) sleep(MY_WAIT_FOR_USER_TO_FIX_PANIC);
 }
 
 const char *get_global_errmsg(int nr)

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

@@ -46,7 +46,6 @@ size_t my_write(File Filedes, const uchar *Buffer, size_t Count, myf MyFlags)
   size_t writtenbytes;
   size_t sum_written= 0;
   uint errors= 0;
-  size_t ToWriteCount;
   const size_t initial_count= Count;
 
   DBUG_ENTER("my_write");
@@ -62,14 +61,11 @@ size_t my_write(File Filedes, const uchar *Buffer, size_t Count, myf MyFlags)
   for (;;)
   {
     errno= 0;
-    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;

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

@@ -6723,6 +6723,7 @@ bool MYSQL_BIN_LOG::after_append_to_relay_log(Master_info *mi)
 
   // Check pre-conditions
   mysql_mutex_assert_owner(&LOCK_log);
+  mysql_mutex_assert_owner(&mi->data_lock);
   DBUG_ASSERT(is_relay_log);
   DBUG_ASSERT(current_thd->system_thread == SYSTEM_THREAD_SLAVE_IO);
 
@@ -6773,22 +6774,7 @@ bool MYSQL_BIN_LOG::after_append_to_relay_log(Master_info *mi)
     if ((uint) my_b_append_tell(&log_file) >
         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(mi->get_mi_description_event());
-      /*
-        After rotation release data_lock, we need the LOCK_log till we signal
-        the updation.
-      */
-      mysql_mutex_unlock(&mi->data_lock);
     }
   }
 
@@ -6800,21 +6786,14 @@ bool MYSQL_BIN_LOG::after_append_to_relay_log(Master_info *mi)
 
 bool MYSQL_BIN_LOG::append_event(Log_event* ev, Master_info *mi)
 {
-  DBUG_ENTER("MYSQL_BIN_LOG::append_event");
+  DBUG_ENTER("MYSQL_BIN_LOG::append");
 
-  mysql_mutex_assert_owner(&mi->data_lock);
-  mysql_mutex_lock(&LOCK_log);
   // check preconditions
   DBUG_ASSERT(log_file.type == SEQ_READ_APPEND);
   DBUG_ASSERT(is_relay_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);
+  // acquire locks
+  mysql_mutex_lock(&LOCK_log);
 
   // write data
   bool error = false;
@@ -6827,7 +6806,6 @@ bool MYSQL_BIN_LOG::append_event(Log_event* ev, Master_info *mi)
     error= true;
 
   mysql_mutex_unlock(&LOCK_log);
-  mysql_mutex_lock(&mi->data_lock);
   DBUG_RETURN(error);
 }
 
@@ -6836,25 +6814,11 @@ bool MYSQL_BIN_LOG::append_buffer(const char* buf, uint len, Master_info *mi)
 {
   DBUG_ENTER("MYSQL_BIN_LOG::append_buffer");
 
-  mysql_mutex_assert_owner(&mi->data_lock);
-  mysql_mutex_lock(&LOCK_log);
   // check preconditions
   DBUG_ASSERT(log_file.type == SEQ_READ_APPEND);
   DBUG_ASSERT(is_relay_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)));
-                  };);
+  mysql_mutex_assert_owner(&LOCK_log);
+
   // write data
   bool error= false;
   if (my_b_append(&log_file,(uchar*) buf,len) == 0)
@@ -6865,8 +6829,6 @@ bool MYSQL_BIN_LOG::append_buffer(const char* buf, uint len, Master_info *mi)
   else
     error= true;
 
-  mysql_mutex_unlock(&LOCK_log);
-  mysql_mutex_lock(&mi->data_lock);
   DBUG_RETURN(error);
 }
 #endif // ifdef HAVE_REPLICATION

mysys/errors.cc

@@ -8427,6 +8427,9 @@ bool queue_event(Master_info* mi,const char* buf, ulong event_len)
      direct master (an unsupported, useless setup!).
   */
 
+  mysql_mutex_lock(log_lock);
+  DBUG_ASSERT(lock_count == 1);
+  lock_count= 2;
 
   s_id= uint4korr(buf + SERVER_ID_OFFSET);
 
@@ -8468,7 +8471,6 @@ bool queue_event(Master_info* mi,const char* buf, ulong event_len)
       IGNORE_SERVER_IDS it increments mi->get_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) ||
         (event_type != binary_log::FORMAT_DESCRIPTION_EVENT &&
          event_type != binary_log::ROTATE_EVENT &&
@@ -8480,7 +8482,6 @@ bool queue_event(Master_info* mi,const char* buf, ulong event_len)
       rli->ign_master_log_pos_end= mi->get_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->get_master_log_pos(), uint4korr(buf + SERVER_ID_OFFSET)));
   }
@@ -8526,9 +8527,7 @@ bool queue_event(Master_info* mi,const char* buf, ulong event_len)
     }
     else
       is_error= true;
-    mysql_mutex_lock(log_lock);
     rli->ign_master_log_name_end[0]= 0; // last event is not ignored
-    mysql_mutex_unlock(log_lock);
     if (save_buf != NULL)
       buf= save_buf;
     if (is_error)
@@ -8547,6 +8546,8 @@ bool queue_event(Master_info* mi,const char* buf, ulong event_len)
 end:
   if (lock_count >= 1)
     mysql_mutex_unlock(&mi->data_lock);
+  if (lock_count >= 2)
+    mysql_mutex_unlock(log_lock);
   DBUG_PRINT("info", ("error: %d", error));
   DBUG_RETURN(error);
 }