MySQL Lists are EOL. Please join:

List:Commits« Previous MessageNext Message »
From:Greg Lehey Date:July 7 2006 7:41am
Subject:bk commit into 5.1 tree (grog:1.2234) BUG#20850
View as plain text  
Below is the list of changes that have just been committed into a local
5.1 repository of grog. When grog does a push these changes will
be propagated to the main repository and, within 24 hours after the
push, to the public repository.
For information on how to access the public repository
see http://dev.mysql.com/doc/mysql/en/installing-source-tree.html

ChangeSet
  1.2234 06/07/07 17:11:24 grog@stripped +1 -0
  slave.cc:
    BUG#20850: Assert during slave shutdown in many rpl_* tests.
    This was caused by a race condition at the end of handle_slave_io
    which under some circumstances allowed the cleanup to proceed before
    the thread had completed.

  sql/slave.cc
    1.277 06/07/07 17:08:52 grog@stripped +390 -390
    BUG#20850: Assert during slave shutdown in many rpl_* tests.
    This was caused by a race condition at the end of handle_slave_io
    which under some circumstances allowed the cleanup to proceed before
    the thread had completed.

# This is a BitKeeper patch.  What follows are the unified diffs for the
# set of deltas contained in the patch.  The rest of the patch, the part
# that BitKeeper cares about, is below these diffs.
# User:	grog
# Host:	eucla.lemis.com
# Root:	/home/MySQL/5.1-Bug-20850

--- 1.276/sql/slave.cc	2006-07-07 16:57:05 +09:30
+++ 1.277/sql/slave.cc	2006-07-07 17:08:52 +09:30
@@ -63,14 +63,14 @@
 static int init_slave_thread(THD* thd, SLAVE_THD_TYPE thd_type);
 static int safe_connect(THD* thd, MYSQL* mysql, MASTER_INFO* mi);
 static int safe_reconnect(THD* thd, MYSQL* mysql, MASTER_INFO* mi,
-                          bool suppress_warnings);
+			  bool suppress_warnings);
 static int connect_to_master(THD* thd, MYSQL* mysql, MASTER_INFO* mi,
-                             bool reconnect, bool suppress_warnings);
+			     bool reconnect, bool suppress_warnings);
 static int safe_sleep(THD* thd, int sec, CHECK_KILLED_FUNC thread_killed,
-                      void* thread_killed_arg);
+		      void* thread_killed_arg);
 static int request_table_dump(MYSQL* mysql, const char* db, const char* table);
 static int create_table_from_dump(THD* thd, MYSQL *mysql, const char* db,
-                                  const char* table_name, bool overwrite);
+				  const char* table_name, bool overwrite);
 static int get_master_version_and_clock(MYSQL* mysql, MASTER_INFO* mi);
 
 /*
@@ -78,17 +78,17 @@
 
   SYNOPSIS
     init_thread_mask()
-    mask                Return value here
-    mi                  master_info for slave
-    inverse             If set, returns which threads are not running
+    mask		Return value here
+    mi			master_info for slave
+    inverse		If set, returns which threads are not running
 
   IMPLEMENTATION
     Get a bit mask for which threads are running so that we can later restart
     these threads.
 
   RETURN
-    mask        If inverse == 0, running threads
-                If inverse == 1, stopped threads
+    mask	If inverse == 0, running threads
+		If inverse == 1, stopped threads
 */
 
 void init_thread_mask(int* mask,MASTER_INFO* mi,bool inverse)
@@ -168,7 +168,7 @@
   }
 
   if (init_master_info(active_mi,master_info_file,relay_log_info_file,
-                       !master_host, (SLAVE_IO | SLAVE_SQL)))
+		       !master_host, (SLAVE_IO | SLAVE_SQL)))
   {
     sql_print_error("Failed to initialize the master info structure");
     goto err;
@@ -182,11 +182,11 @@
   if (master_host && !opt_skip_slave_start)
   {
     if (start_slave_threads(1 /* need mutex */,
-                            0 /* no wait for start*/,
-                            active_mi,
-                            master_info_file,
-                            relay_log_info_file,
-                            SLAVE_IO | SLAVE_SQL))
+			    0 /* no wait for start*/,
+			    active_mi,
+			    master_info_file,
+			    relay_log_info_file,
+			    SLAVE_IO | SLAVE_SQL))
     {
       sql_print_error("Failed to create slave threads");
       goto err;
@@ -206,11 +206,11 @@
 
   SYNOPSIS
     init_relay_log_pos()
-    rli                 Relay information (will be initialized)
-    log                 Name of relay log file to read from. NULL = First log
-    pos                 Position in relay log file
-    need_data_lock      Set to 1 if this functions should do mutex locks
-    errmsg              Store pointer to error message here
+    rli			Relay information (will be initialized)
+    log			Name of relay log file to read from. NULL = First log
+    pos			Position in relay log file
+    need_data_lock	Set to 1 if this functions should do mutex locks
+    errmsg		Store pointer to error message here
     look_for_description_event
                         1 if we should look for such an event. We only need
                         this when the SQL thread starts and opens an existing
@@ -229,13 +229,13 @@
     - check proper initialization of group_master_log_name/group_master_log_pos
 
   RETURN VALUES
-    0   ok
-    1   error.  errmsg is set to point to the error message
+    0	ok
+    1	error.  errmsg is set to point to the error message
 */
 
 int init_relay_log_pos(RELAY_LOG_INFO* rli,const char* log,
-                       ulonglong pos, bool need_data_lock,
-                       const char** errmsg,
+		       ulonglong pos, bool need_data_lock,
+		       const char** errmsg,
                        bool look_for_description_event)
 {
   DBUG_ENTER("init_relay_log_pos");
@@ -293,9 +293,9 @@
     goto err;
   }
   strmake(rli->group_relay_log_name,rli->linfo.log_file_name,
-          sizeof(rli->group_relay_log_name)-1);
+	  sizeof(rli->group_relay_log_name)-1);
   strmake(rli->event_relay_log_name,rli->linfo.log_file_name,
-          sizeof(rli->event_relay_log_name)-1);
+	  sizeof(rli->event_relay_log_name)-1);
   if (rli->relay_log.is_active(rli->linfo.log_file_name))
   {
     /*
@@ -314,7 +314,7 @@
       Open the relay log and set rli->cur_log to point at this one
     */
     if ((rli->cur_log_fd=open_binlog(&rli->cache_buf,
-                                     rli->linfo.log_file_name,errmsg)) < 0)
+				     rli->linfo.log_file_name,errmsg)) < 0)
       goto err;
     rli->cur_log = &rli->cache_buf;
   }
@@ -423,7 +423,7 @@
 
   SYNOPSIS
     init_slave_skip_errors()
-    arg         List of errors numbers to skip, separated with ','
+    arg		List of errors numbers to skip, separated with ','
 
   NOTES
     Called from get_options() in mysqld.cc on start-up
@@ -462,7 +462,7 @@
 
 
 void st_relay_log_info::inc_group_relay_log_pos(ulonglong log_pos,
-                                                bool skip_lock)
+						bool skip_lock)
 {
   DBUG_ENTER("st_relay_log_info::inc_group_relay_log_pos");
 
@@ -471,7 +471,7 @@
   inc_event_relay_log_pos();
   group_relay_log_pos= event_relay_log_pos;
   strmake(group_relay_log_name,event_relay_log_name,
-          sizeof(group_relay_log_name)-1);
+	  sizeof(group_relay_log_name)-1);
 
   notify_group_relay_log_name_update();
 
@@ -506,7 +506,7 @@
     With the end_log_pos solution, we avoid computations involving lengthes.
   */
   DBUG_PRINT("info", ("log_pos: %lu  group_master_log_pos: %lu",
-                      (long) log_pos, (long) group_master_log_pos));
+		      (long) log_pos, (long) group_master_log_pos));
   if (log_pos) // 3.23 binlogs don't have log_posx
   {
     group_master_log_pos= log_pos;
@@ -546,7 +546,7 @@
 */
 
 int purge_relay_logs(RELAY_LOG_INFO* rli, THD *thd, bool just_reset,
-                     const char** errmsg)
+		     const char** errmsg)
 {
   int error=0;
   DBUG_ENTER("purge_relay_logs");
@@ -605,9 +605,9 @@
   }
   /* Save name of used relay log file */
   strmake(rli->group_relay_log_name, rli->relay_log.get_log_fname(),
-          sizeof(rli->group_relay_log_name)-1);
+	  sizeof(rli->group_relay_log_name)-1);
   strmake(rli->event_relay_log_name, rli->relay_log.get_log_fname(),
-          sizeof(rli->event_relay_log_name)-1);
+ 	  sizeof(rli->event_relay_log_name)-1);
   rli->group_relay_log_pos= rli->event_relay_log_pos= BIN_LOG_HEADER_SIZE;
   if (count_relay_log_space(rli))
   {
@@ -617,7 +617,7 @@
   if (!just_reset)
     error= init_relay_log_pos(rli, rli->group_relay_log_name,
                               rli->group_relay_log_pos,
-                              0 /* do not need data lock */, errmsg, 0);
+  			      0 /* do not need data lock */, errmsg, 0);
 
 err:
 #ifndef DBUG_OFF
@@ -651,10 +651,10 @@
     DBUG_PRINT("info",("Terminating IO thread"));
     mi->abort_slave=1;
     if ((error=terminate_slave_thread(mi->io_thd,io_lock,
-                                      io_cond_lock,
-                                      &mi->stop_cond,
-                                      &mi->slave_running)) &&
-        !force_all)
+				      io_cond_lock,
+				      &mi->stop_cond,
+				      &mi->slave_running)) &&
+	!force_all)
       DBUG_RETURN(error);
   }
   if ((thread_mask & (SLAVE_SQL|SLAVE_FORCE_ALL)) && mi->rli.slave_running)
@@ -663,10 +663,10 @@
     DBUG_ASSERT(mi->rli.sql_thd != 0) ;
     mi->rli.abort_slave=1;
     if ((error=terminate_slave_thread(mi->rli.sql_thd,sql_lock,
-                                      sql_cond_lock,
-                                      &mi->rli.stop_cond,
-                                      &mi->rli.slave_running)) &&
-        !force_all)
+				      sql_cond_lock,
+				      &mi->rli.stop_cond,
+				      &mi->rli.slave_running)) &&
+	!force_all)
       DBUG_RETURN(error);
   }
   DBUG_RETURN(0);
@@ -674,9 +674,9 @@
 
 
 int terminate_slave_thread(THD* thd, pthread_mutex_t* term_lock,
-                           pthread_mutex_t *cond_lock,
-                           pthread_cond_t* term_cond,
-                           volatile uint *slave_running)
+			   pthread_mutex_t *cond_lock,
+			   pthread_cond_t* term_cond,
+			   volatile uint *slave_running)
 {
   DBUG_ENTER("terminate_slave_thread");
   if (term_lock)
@@ -695,7 +695,7 @@
     be referening freed memory trying to kick it
   */
 
-  while (*slave_running)                        // Should always be true
+  while (*slave_running)			// Should always be true
   {
     DBUG_PRINT("loop", ("killing slave thread"));
     KICK_SLAVE(thd);
@@ -714,11 +714,11 @@
 
 
 int start_slave_thread(pthread_handler h_func, pthread_mutex_t *start_lock,
-                       pthread_mutex_t *cond_lock,
-                       pthread_cond_t *start_cond,
-                       volatile uint *slave_running,
-                       volatile ulong *slave_run_id,
-                       MASTER_INFO* mi,
+		       pthread_mutex_t *cond_lock,
+		       pthread_cond_t *start_cond,
+		       volatile uint *slave_running,
+		       volatile ulong *slave_run_id,
+		       MASTER_INFO* mi,
                        bool high_priority)
 {
   pthread_t th;
@@ -764,12 +764,12 @@
     {
       DBUG_PRINT("sleep",("Waiting for slave thread to start"));
       const char* old_msg = thd->enter_cond(start_cond,cond_lock,
-                                            "Waiting for slave thread to start");
+					    "Waiting for slave thread to start");
       pthread_cond_wait(start_cond,cond_lock);
       thd->exit_cond(old_msg);
       pthread_mutex_lock(cond_lock); // re-acquire it as exit_cond() released
       if (thd->killed)
-        DBUG_RETURN(thd->killed_errno());
+	DBUG_RETURN(thd->killed_errno());
     }
   }
   if (start_lock)
@@ -788,8 +788,8 @@
 */
 
 int start_slave_threads(bool need_slave_mutex, bool wait_for_start,
-                        MASTER_INFO* mi, const char* master_info_fname,
-                        const char* slave_info_fname, int thread_mask)
+			MASTER_INFO* mi, const char* master_info_fname,
+			const char* slave_info_fname, int thread_mask)
 {
   pthread_mutex_t *lock_io=0,*lock_sql=0,*lock_cond_io=0,*lock_cond_sql=0;
   pthread_cond_t* cond_io=0,*cond_sql=0;
@@ -811,15 +811,15 @@
 
   if (thread_mask & SLAVE_IO)
     error=start_slave_thread(handle_slave_io,lock_io,lock_cond_io,
-                             cond_io,
-                             &mi->slave_running, &mi->slave_run_id,
-                             mi, 1); //high priority, to read the most possible
+			     cond_io,
+			     &mi->slave_running, &mi->slave_run_id,
+			     mi, 1); //high priority, to read the most possible
   if (!error && (thread_mask & SLAVE_SQL))
   {
     error=start_slave_thread(handle_slave_sql,lock_sql,lock_cond_sql,
-                             cond_sql,
-                             &mi->rli.slave_running, &mi->rli.slave_run_id,
-                             mi, 0);
+			     cond_sql,
+			     &mi->rli.slave_running, &mi->rli.slave_run_id,
+			     mi, 0);
     if (error)
       terminate_slave_threads(mi, thread_mask & SLAVE_IO, 0);
   }
@@ -997,8 +997,8 @@
   DBUG_ENTER("skip_load_data_infile");
 
   (void)net_request_file(net, "/dev/null");
-  (void)my_net_read(net);                               // discard response
-  (void)net_write_command(net, 0, "", 0, "", 0);        // Send ok
+  (void)my_net_read(net);				// discard response
+  (void)net_write_command(net, 0, "", 0, "", 0);	// Send ok
   DBUG_VOID_RETURN;
 }
 
@@ -1024,7 +1024,7 @@
 }
 
 static int init_strvar_from_file(char *var, int max_size, IO_CACHE *f,
-                                 const char *default_val)
+				 const char *default_val)
 {
   uint length;
   DBUG_ENTER("init_strvar_from_file");
@@ -1037,8 +1037,8 @@
     else
     {
       /*
-        If we truncated a line or stopped on last char, remove all chars
-        up to and including newline.
+	If we truncated a line or stopped on last char, remove all chars
+	up to and including newline.
       */
       int c;
       while (((c=my_b_get(f)) != '\n' && c != my_b_EOF));
@@ -1287,7 +1287,7 @@
 */
 
 static int create_table_from_dump(THD* thd, MYSQL *mysql, const char* db,
-                                  const char* table_name, bool overwrite)
+				  const char* table_name, bool overwrite)
 {
   ulong packet_len;
   char *query, *save_db;
@@ -1311,8 +1311,8 @@
   {
     char *err_msg;
     err_msg= (char*) net->read_pos + ((mysql->server_capabilities &
-                                       CLIENT_PROTOCOL_41) ?
-                                      3+SQLSTATE_LENGTH+1 : 3);
+				       CLIENT_PROTOCOL_41) ?
+				      3+SQLSTATE_LENGTH+1 : 3);
     my_error(ER_MASTER, MYF(0), err_msg);
     DBUG_RETURN(1);
   }
@@ -1351,12 +1351,12 @@
   DBUG_ASSERT(thd->db != 0);
   thd->db_length= strlen(thd->db);
   mysql_parse(thd, thd->query, packet_len); // run create table
-  thd->db = save_db;            // leave things the way the were before
+  thd->db = save_db;		// leave things the way the were before
   thd->db_length= save_db_length;
   thd->options = save_options;
 
   if (thd->query_error)
-    goto err;                   // mysql_parse took care of the error send
+    goto err;			// mysql_parse took care of the error send
 
   thd->proc_info = "Opening master dump table";
   tables.lock_type = TL_WRITE;
@@ -1401,14 +1401,14 @@
 
 
 int fetch_master_table(THD *thd, const char *db_name, const char *table_name,
-                       MASTER_INFO *mi, MYSQL *mysql, bool overwrite)
+		       MASTER_INFO *mi, MYSQL *mysql, bool overwrite)
 {
   int error= 1;
   const char *errmsg=0;
   bool called_connected= (mysql != NULL);
   DBUG_ENTER("fetch_master_table");
   DBUG_PRINT("enter", ("db_name: '%s'  table_name: '%s'",
-                       db_name,table_name));
+		       db_name,table_name));
 
   if (!called_connected)
   {
@@ -1442,7 +1442,7 @@
     goto err;
   }
   if (create_table_from_dump(thd, mysql, db_name,
-                             table_name, overwrite))
+			     table_name, overwrite))
     goto err;    // create_table_from_dump have sent the error already
   error = 0;
 
@@ -1452,7 +1452,7 @@
     mysql_close(mysql);
   if (errmsg && thd->vio_ok())
     my_message(error, errmsg, MYF(0));
-  DBUG_RETURN(test(error));                     // Return 1 on error
+  DBUG_RETURN(test(error));			// Return 1 on error
 }
 
 
@@ -1568,17 +1568,17 @@
       goto err;
     }
     if (init_io_cache(&rli->info_file, info_fd, IO_SIZE*2, READ_CACHE, 0L,0,
-                      MYF(MY_WME)))
+		      MYF(MY_WME)))
     {
       sql_print_error("Failed to create a cache on relay log info file '%s'",
-                      fname);
+		      fname);
       msg= current_thd->net.last_error;
       goto err;
     }
 
     /* Init relay log with first entry in the relay index file */
     if (init_relay_log_pos(rli,NullS,BIN_LOG_HEADER_SIZE,0 /* no data lock */,
-                           &msg, 0))
+			   &msg, 0))
     {
       sql_print_error("Failed to open the relay log 'FIRST' (relay_log_pos 4)");
       goto err;
@@ -1598,14 +1598,14 @@
       {
         sql_print_error("\
 Failed to open the existing relay log info file '%s' (errno %d)",
-                        fname, my_errno);
+			fname, my_errno);
         error= 1;
       }
       else if (init_io_cache(&rli->info_file, info_fd,
                              IO_SIZE*2, READ_CACHE, 0L, 0, MYF(MY_WME)))
       {
         sql_print_error("Failed to create a cache on relay log info file '%s'",
-                        fname);
+			fname);
         error= 1;
       }
       if (error)
@@ -1622,12 +1622,12 @@
     rli->info_fd = info_fd;
     int relay_log_pos, master_log_pos;
     if (init_strvar_from_file(rli->group_relay_log_name,
-                              sizeof(rli->group_relay_log_name),
+			      sizeof(rli->group_relay_log_name),
                               &rli->info_file, "") ||
        init_intvar_from_file(&relay_log_pos,
-                             &rli->info_file, BIN_LOG_HEADER_SIZE) ||
+			     &rli->info_file, BIN_LOG_HEADER_SIZE) ||
        init_strvar_from_file(rli->group_master_log_name,
-                             sizeof(rli->group_master_log_name),
+			     sizeof(rli->group_master_log_name),
                              &rli->info_file, "") ||
        init_intvar_from_file(&master_log_pos, &rli->info_file, 0))
     {
@@ -1640,15 +1640,15 @@
     rli->group_master_log_pos= master_log_pos;
 
     if (init_relay_log_pos(rli,
-                           rli->group_relay_log_name,
-                           rli->group_relay_log_pos,
-                           0 /* no data lock*/,
-                           &msg, 0))
+			   rli->group_relay_log_name,
+			   rli->group_relay_log_pos,
+			   0 /* no data lock*/,
+			   &msg, 0))
     {
       char llbuf[22];
       sql_print_error("Failed to open the relay log '%s' (relay_log_pos %s)",
-                      rli->group_relay_log_name,
-                      llstr(rli->group_relay_log_pos, llbuf));
+		      rli->group_relay_log_name,
+		      llstr(rli->group_relay_log_pos, llbuf));
       goto err;
     }
   }
@@ -1699,7 +1699,7 @@
   if (!my_stat(linfo->log_file_name,&s,MYF(0)))
   {
     sql_print_error("log %s listed in the index, but failed to stat",
-                    linfo->log_file_name);
+		    linfo->log_file_name);
     DBUG_RETURN(1);
   }
   rli->log_space_total += s.st_size;
@@ -1721,11 +1721,11 @@
 
   pthread_mutex_lock(&rli->log_space_lock);
   save_proc_info= thd->enter_cond(&rli->log_space_cond,
-                                  &rli->log_space_lock,
-                                  "\
+				  &rli->log_space_lock,
+				  "\
 Waiting for the slave SQL thread to free enough relay log space");
   while (rli->log_space_limit < rli->log_space_total &&
-         !(slave_killed=io_slave_killed(thd,mi)) &&
+	 !(slave_killed=io_slave_killed(thd,mi)) &&
          !rli->ignore_log_space_limit)
     pthread_cond_wait(&rli->log_space_cond, &rli->log_space_lock);
   thd->exit_cond(save_proc_info);
@@ -1816,7 +1816,7 @@
   DBUG_ENTER("init_master_info_with_options");
 
   mi->master_log_name[0] = 0;
-  mi->master_log_pos = BIN_LOG_HEADER_SIZE;             // skip magic number
+  mi->master_log_pos = BIN_LOG_HEADER_SIZE;		// skip magic number
 
   if (master_host)
     strmake(mi->host, master_host, sizeof(mi->host) - 1);
@@ -1935,7 +1935,7 @@
       goto err;
     }
     if (init_io_cache(&mi->file, fd, IO_SIZE*2, READ_CACHE, 0L,0,
-                      MYF(MY_WME)))
+		      MYF(MY_WME)))
     {
       sql_print_error("Failed to create a cache on master info file (\
 file '%s')", fname);
@@ -1995,8 +1995,8 @@
        overwritten by the second row later.
     */
     if (init_strvar_from_file(mi->master_log_name,
-                              sizeof(mi->master_log_name), &mi->file,
-                              ""))
+			      sizeof(mi->master_log_name), &mi->file,
+			      ""))
       goto errwithmsg;
 
     lines= strtoul(mi->master_log_name, &first_non_digit, 10);
@@ -2012,15 +2012,15 @@
       lines= 7;
 
     if (init_intvar_from_file(&master_log_pos, &mi->file, 4) ||
-        init_strvar_from_file(mi->host, sizeof(mi->host), &mi->file,
-                              master_host) ||
-        init_strvar_from_file(mi->user, sizeof(mi->user), &mi->file,
-                              master_user) ||
+	init_strvar_from_file(mi->host, sizeof(mi->host), &mi->file,
+			      master_host) ||
+	init_strvar_from_file(mi->user, sizeof(mi->user), &mi->file,
+			      master_user) ||
         init_strvar_from_file(mi->password, SCRAMBLED_PASSWORD_CHAR_LENGTH+1,
                               &mi->file, master_password) ||
-        init_intvar_from_file(&port, &mi->file, master_port) ||
-        init_intvar_from_file(&connect_retry, &mi->file,
-                              master_connect_retry))
+	init_intvar_from_file(&port, &mi->file, master_port) ||
+	init_intvar_from_file(&connect_retry, &mi->file,
+			      master_connect_retry))
       goto errwithmsg;
 
     /*
@@ -2059,8 +2059,8 @@
     mi->ssl= (my_bool) ssl;
   }
   DBUG_PRINT("master_info",("log_file_name: %s  position: %ld",
-                            mi->master_log_name,
-                            (ulong) mi->master_log_pos));
+			    mi->master_log_name,
+			    (ulong) mi->master_log_pos));
 
   mi->rli.mi = mi;
   if (init_relay_log_info(&mi->rli, slave_info_fname))
@@ -2105,23 +2105,23 @@
   /* 30 is a good safety margin */
   if (report_host_len + report_user_len + report_password_len + 30 >
       sizeof(buf))
-    DBUG_RETURN(0);                                     // safety
+    DBUG_RETURN(0);					// safety
 
   int4store(pos, server_id); pos+= 4;
   pos= net_store_data(pos, report_host, report_host_len);
   pos= net_store_data(pos, report_user, report_user_len);
   pos= net_store_data(pos, report_password, report_password_len);
   int2store(pos, (uint16) report_port); pos+= 2;
-  int4store(pos, rpl_recovery_rank);    pos+= 4;
+  int4store(pos, rpl_recovery_rank);	pos+= 4;
   /* The master will fill in master_id */
-  int4store(pos, 0);                    pos+= 4;
+  int4store(pos, 0);			pos+= 4;
 
   if (simple_command(mysql, COM_REGISTER_SLAVE, (char*) buf,
-                        (uint) (pos- buf), 0))
+			(uint) (pos- buf), 0))
   {
     sql_print_error("Error on COM_REGISTER_SLAVE: %d '%s'",
-                    mysql_errno(mysql),
-                    mysql_error(mysql));
+		    mysql_errno(mysql),
+		    mysql_error(mysql));
     DBUG_RETURN(1);
   }
   DBUG_RETURN(0);
@@ -2136,25 +2136,25 @@
   DBUG_ENTER("show_master_info");
 
   field_list.push_back(new Item_empty_string("Slave_IO_State",
-                                                     14));
+						     14));
   field_list.push_back(new Item_empty_string("Master_Host",
-                                                     sizeof(mi->host)));
+						     sizeof(mi->host)));
   field_list.push_back(new Item_empty_string("Master_User",
-                                                     sizeof(mi->user)));
+						     sizeof(mi->user)));
   field_list.push_back(new Item_return_int("Master_Port", 7,
-                                           MYSQL_TYPE_LONG));
+					   MYSQL_TYPE_LONG));
   field_list.push_back(new Item_return_int("Connect_Retry", 10,
-                                           MYSQL_TYPE_LONG));
+					   MYSQL_TYPE_LONG));
   field_list.push_back(new Item_empty_string("Master_Log_File",
-                                             FN_REFLEN));
+					     FN_REFLEN));
   field_list.push_back(new Item_return_int("Read_Master_Log_Pos", 10,
-                                           MYSQL_TYPE_LONGLONG));
+					   MYSQL_TYPE_LONGLONG));
   field_list.push_back(new Item_empty_string("Relay_Log_File",
-                                             FN_REFLEN));
+					     FN_REFLEN));
   field_list.push_back(new Item_return_int("Relay_Log_Pos", 10,
-                                           MYSQL_TYPE_LONGLONG));
+					   MYSQL_TYPE_LONGLONG));
   field_list.push_back(new Item_empty_string("Relay_Master_Log_File",
-                                             FN_REFLEN));
+					     FN_REFLEN));
   field_list.push_back(new Item_empty_string("Slave_IO_Running", 3));
   field_list.push_back(new Item_empty_string("Slave_SQL_Running", 3));
   field_list.push_back(new Item_empty_string("Replicate_Do_DB", 20));
@@ -2163,15 +2163,15 @@
   field_list.push_back(new Item_empty_string("Replicate_Ignore_Table", 23));
   field_list.push_back(new Item_empty_string("Replicate_Wild_Do_Table", 24));
   field_list.push_back(new Item_empty_string("Replicate_Wild_Ignore_Table",
-                                             28));
+					     28));
   field_list.push_back(new Item_return_int("Last_Errno", 4, MYSQL_TYPE_LONG));
   field_list.push_back(new Item_empty_string("Last_Error", 20));
   field_list.push_back(new Item_return_int("Skip_Counter", 10,
-                                           MYSQL_TYPE_LONG));
+					   MYSQL_TYPE_LONG));
   field_list.push_back(new Item_return_int("Exec_Master_Log_Pos", 10,
-                                           MYSQL_TYPE_LONGLONG));
+					   MYSQL_TYPE_LONGLONG));
   field_list.push_back(new Item_return_int("Relay_Log_Space", 10,
-                                           MYSQL_TYPE_LONGLONG));
+					   MYSQL_TYPE_LONGLONG));
   field_list.push_back(new Item_empty_string("Until_Condition", 6));
   field_list.push_back(new Item_empty_string("Until_Log_File", FN_REFLEN));
   field_list.push_back(new Item_return_int("Until_Log_Pos", 10,
@@ -2216,8 +2216,8 @@
     protocol->store(mi->master_log_name, &my_charset_bin);
     protocol->store((ulonglong) mi->master_log_pos);
     protocol->store(mi->rli.group_relay_log_name +
-                    dirname_length(mi->rli.group_relay_log_name),
-                    &my_charset_bin);
+		    dirname_length(mi->rli.group_relay_log_name),
+		    &my_charset_bin);
     protocol->store((ulonglong) mi->rli.group_relay_log_pos);
     protocol->store(mi->rli.group_master_log_name, &my_charset_bin);
     protocol->store(mi->slave_running == MYSQL_SLAVE_RUN_CONNECT ?
@@ -2355,10 +2355,10 @@
 
   my_b_seek(file, 0L);
   my_b_printf(file, "%u\n%s\n%s\n%s\n%s\n%s\n%d\n%d\n%d\n%s\n%s\n%s\n%s\n%s\n",
-              LINES_IN_MASTER_INFO_WITH_SSL,
+	      LINES_IN_MASTER_INFO_WITH_SSL,
               mi->master_log_name, llstr(mi->master_log_pos, lbuf),
-              mi->host, mi->user,
-              mi->password, mi->port, mi->connect_retry,
+	      mi->host, mi->user,
+	      mi->password, mi->port, mi->connect_retry,
               (int)(mi->ssl), mi->ssl_ca, mi->ssl_capath, mi->ssl_cert,
               mi->ssl_cipher, mi->ssl_key);
   DBUG_RETURN(-flush_io_cache(file));
@@ -2680,7 +2680,7 @@
 
 #if !defined(__WIN__) && !defined(__NETWARE__)
   sigset_t set;
-  VOID(sigemptyset(&set));                      // Get mask in use
+  VOID(sigemptyset(&set));			// Get mask in use
   VOID(pthread_sigmask(SIG_UNBLOCK,&set,&thd->block_signals));
 #endif
 
@@ -2695,7 +2695,7 @@
 
 
 static int safe_sleep(THD* thd, int sec, CHECK_KILLED_FUNC thread_killed,
-                      void* thread_killed_arg)
+		      void* thread_killed_arg)
 {
   int nap_time;
   thr_alarm_t alarmed;
@@ -2726,7 +2726,7 @@
 
 
 static int request_dump(MYSQL* mysql, MASTER_INFO* mi,
-                        bool *suppress_warnings)
+			bool *suppress_warnings)
 {
   char buf[FN_REFLEN + 10];
   int len;
@@ -2748,11 +2748,11 @@
       now we just fill up the error log :-)
     */
     if (mysql_errno(mysql) == ER_NET_READ_INTERRUPTED)
-      *suppress_warnings= 1;                    // Suppress reconnect warning
+      *suppress_warnings= 1;			// Suppress reconnect warning
     else
       sql_print_error("Error on COM_BINLOG_DUMP: %d  %s, will retry in %d secs",
-                      mysql_errno(mysql), mysql_error(mysql),
-                      master_connect_retry);
+		      mysql_errno(mysql), mysql_error(mysql),
+		      master_connect_retry);
     DBUG_RETURN(1);
   }
 
@@ -2796,16 +2796,16 @@
 
   SYNOPSIS
     read_event()
-    mysql               MySQL connection
-    mi                  Master connection information
-    suppress_warnings   TRUE when a normal net read timeout has caused us to
-                        try a reconnect.  We do not want to print anything to
-                        the error log in this case because this a anormal
-                        event in an idle server.
+    mysql		MySQL connection
+    mi			Master connection information
+    suppress_warnings	TRUE when a normal net read timeout has caused us to
+			try a reconnect.  We do not want to print anything to
+			the error log in this case because this a anormal
+			event in an idle server.
 
     RETURN VALUES
-    'packet_error'      Error
-    number              Length of packet
+    'packet_error'	Error
+    number		Length of packet
 */
 
 static ulong read_event(MYSQL* mysql, MASTER_INFO *mi, bool* suppress_warnings)
@@ -2829,15 +2829,15 @@
     if (mysql_errno(mysql) == ER_NET_READ_INTERRUPTED)
     {
       /*
-        We are trying a normal reconnect after a read timeout;
-        we suppress prints to .err file as long as the reconnect
-        happens without problems
+	We are trying a normal reconnect after a read timeout;
+	we suppress prints to .err file as long as the reconnect
+	happens without problems
       */
       *suppress_warnings= TRUE;
     }
     else
       sql_print_error("Error reading packet from server: %s ( server_errno=%d)",
-                      mysql_error(mysql), mysql_errno(mysql));
+		      mysql_error(mysql), mysql_errno(mysql));
     DBUG_RETURN(packet_error);
   }
 
@@ -2846,12 +2846,12 @@
   {
     sql_print_information("Slave: received end packet from server, apparent "
                           "master shutdown: %s",
-                     mysql_error(mysql));
+		     mysql_error(mysql));
      DBUG_RETURN(packet_error);
   }
 
   DBUG_PRINT("info",( "len=%u, net->read_pos[4] = %d\n",
-                      len, mysql->net.read_pos[4]));
+		      len, mysql->net.read_pos[4]));
   DBUG_RETURN(len - 1);
 }
 
@@ -3143,7 +3143,7 @@
     pthread_mutex_unlock(&rli->data_lock);
 
     thd->server_id = ev->server_id; // use the original server id for logging
-    thd->set_time();                            // time the query
+    thd->set_time();				// time the query
     thd->lex->current_select= 0;
     if (!ev->when)
       ev->when = time(NULL);
@@ -3192,16 +3192,16 @@
           {
             exec_res= 0;
             end_trans(thd, ROLLBACK);
-            /* chance for concurrent connection to get more locks */
+	    /* chance for concurrent connection to get more locks */
             safe_sleep(thd, min(rli->trans_retries, MAX_SLAVE_RETRY_PAUSE),
-                       (CHECK_KILLED_FUNC)sql_slave_killed, (void*)rli);
+		       (CHECK_KILLED_FUNC)sql_slave_killed, (void*)rli);
             pthread_mutex_lock(&rli->data_lock); // because of SHOW STATUS
-            rli->trans_retries++;
+	    rli->trans_retries++;
             rli->retried_trans++;
             pthread_mutex_unlock(&rli->data_lock);
             DBUG_PRINT("info", ("Slave retries transaction "
                                 "rli->trans_retries: %lu", rli->trans_retries));
-          }
+	  }
         }
         else
           sql_print_error("Slave SQL thread retried transaction %lu time(s) "
@@ -3285,8 +3285,8 @@
   pthread_cond_broadcast(&mi->start_cond);
 
   DBUG_PRINT("master_info",("log_file_name: '%s'  position: %s",
-                            mi->master_log_name,
-                            llstr(mi->master_log_pos,llbuff)));
+			    mi->master_log_name,
+			    llstr(mi->master_log_pos,llbuff)));
 
   if (!(mi->mysql = mysql = mysql_init(NULL)))
   {
@@ -3299,9 +3299,9 @@
   if (!safe_connect(thd, mysql, mi))
     sql_print_information("Slave I/O thread: connected to master '%s@%s:%d',\
   replication started in log '%s' at position %s", mi->user,
-                    mi->host, mi->port,
-                    IO_RPL_LOG_NAME,
-                    llstr(mi->master_log_pos,llbuff));
+		    mi->host, mi->port,
+		    IO_RPL_LOG_NAME,
+		    llstr(mi->master_log_pos,llbuff));
   else
   {
     sql_print_information("Slave I/O thread killed while connecting to master");
@@ -3339,9 +3339,9 @@
       sql_print_error("Failed on request_dump()");
       if (io_slave_killed(thd,mi))
       {
-        sql_print_information("Slave I/O thread killed while requesting master \
+	sql_print_information("Slave I/O thread killed while requesting master \
 dump");
-        goto err;
+	goto err;
       }
 
       mi->slave_running= MYSQL_SLAVE_RUN_NOT_CONNECT;
@@ -3351,35 +3351,35 @@
 #endif
       end_server(mysql);
       /*
-        First time retry immediately, assuming that we can recover
-        right away - if first time fails, sleep between re-tries
-        hopefuly the admin can fix the problem sometime
+	First time retry immediately, assuming that we can recover
+	right away - if first time fails, sleep between re-tries
+	hopefuly the admin can fix the problem sometime
       */
       if (retry_count++)
       {
-        if (retry_count > master_retry_count)
-          goto err;                             // Don't retry forever
-        safe_sleep(thd,mi->connect_retry,(CHECK_KILLED_FUNC)io_slave_killed,
-                   (void*)mi);
+	if (retry_count > master_retry_count)
+	  goto err;				// Don't retry forever
+	safe_sleep(thd,mi->connect_retry,(CHECK_KILLED_FUNC)io_slave_killed,
+		   (void*)mi);
       }
       if (io_slave_killed(thd,mi))
       {
-        sql_print_information("Slave I/O thread killed while retrying master \
+	sql_print_information("Slave I/O thread killed while retrying master \
 dump");
-        goto err;
+	goto err;
       }
 
       thd->proc_info = "Reconnecting after a failed binlog dump request";
       if (!suppress_warnings)
-        sql_print_error("Slave I/O thread: failed dump request, \
+	sql_print_error("Slave I/O thread: failed dump request, \
 reconnecting to try again, log '%s' at postion %s", IO_RPL_LOG_NAME,
-                        llstr(mi->master_log_pos,llbuff));
+			llstr(mi->master_log_pos,llbuff));
       if (safe_reconnect(thd, mysql, mi, suppress_warnings) ||
-          io_slave_killed(thd,mi))
+	  io_slave_killed(thd,mi))
       {
-        sql_print_information("Slave I/O thread killed during or \
+	sql_print_information("Slave I/O thread killed during or \
 after reconnect");
-        goto err;
+	goto err;
       }
 
       goto connected;
@@ -3398,72 +3398,72 @@
       ulong event_len = read_event(mysql, mi, &suppress_warnings);
       if (io_slave_killed(thd,mi))
       {
-        if (global_system_variables.log_warnings)
-          sql_print_information("Slave I/O thread killed while reading event");
-        goto err;
+	if (global_system_variables.log_warnings)
+	  sql_print_information("Slave I/O thread killed while reading event");
+	goto err;
       }
 
       if (event_len == packet_error)
       {
-        uint mysql_error_number= mysql_errno(mysql);
-        if (mysql_error_number == ER_NET_PACKET_TOO_LARGE)
-        {
-          sql_print_error("\
+	uint mysql_error_number= mysql_errno(mysql);
+	if (mysql_error_number == ER_NET_PACKET_TOO_LARGE)
+	{
+	  sql_print_error("\
 Log entry on master is longer than max_allowed_packet (%ld) on \
 slave. If the entry is correct, restart the server with a higher value of \
 max_allowed_packet",
-                          thd->variables.max_allowed_packet);
-          goto err;
-        }
-        if (mysql_error_number == ER_MASTER_FATAL_ERROR_READING_BINLOG)
-        {
-          sql_print_error(ER(mysql_error_number), mysql_error_number,
-                          mysql_error(mysql));
-          goto err;
-        }
+			  thd->variables.max_allowed_packet);
+	  goto err;
+	}
+	if (mysql_error_number == ER_MASTER_FATAL_ERROR_READING_BINLOG)
+	{
+	  sql_print_error(ER(mysql_error_number), mysql_error_number,
+			  mysql_error(mysql));
+	  goto err;
+	}
         mi->slave_running= MYSQL_SLAVE_RUN_NOT_CONNECT;
-        thd->proc_info = "Waiting to reconnect after a failed master event read";
+	thd->proc_info = "Waiting to reconnect after a failed master event read";
 #ifdef SIGNAL_WITH_VIO_CLOSE
         thd->clear_active_vio();
 #endif
-        end_server(mysql);
-        if (retry_count++)
-        {
-          if (retry_count > master_retry_count)
-            goto err;                           // Don't retry forever
-          safe_sleep(thd,mi->connect_retry,(CHECK_KILLED_FUNC)io_slave_killed,
-                     (void*) mi);
-        }
-        if (io_slave_killed(thd,mi))
-        {
-          if (global_system_variables.log_warnings)
-            sql_print_information("Slave I/O thread killed while waiting to \
+	end_server(mysql);
+	if (retry_count++)
+	{
+	  if (retry_count > master_retry_count)
+	    goto err;				// Don't retry forever
+	  safe_sleep(thd,mi->connect_retry,(CHECK_KILLED_FUNC)io_slave_killed,
+		     (void*) mi);
+	}
+	if (io_slave_killed(thd,mi))
+	{
+	  if (global_system_variables.log_warnings)
+	    sql_print_information("Slave I/O thread killed while waiting to \
 reconnect after a failed read");
-          goto err;
-        }
-        thd->proc_info = "Reconnecting after a failed master event read";
-        if (!suppress_warnings)
-          sql_print_information("Slave I/O thread: Failed reading log event, \
+	  goto err;
+	}
+	thd->proc_info = "Reconnecting after a failed master event read";
+	if (!suppress_warnings)
+	  sql_print_information("Slave I/O thread: Failed reading log event, \
 reconnecting to retry, log '%s' position %s", IO_RPL_LOG_NAME,
-                          llstr(mi->master_log_pos, llbuff));
-        if (safe_reconnect(thd, mysql, mi, suppress_warnings) ||
-            io_slave_killed(thd,mi))
-        {
-          if (global_system_variables.log_warnings)
-            sql_print_information("Slave I/O thread killed during or after a \
+			  llstr(mi->master_log_pos, llbuff));
+	if (safe_reconnect(thd, mysql, mi, suppress_warnings) ||
+	    io_slave_killed(thd,mi))
+	{
+	  if (global_system_variables.log_warnings)
+	    sql_print_information("Slave I/O thread killed during or after a \
 reconnect done to recover from failed read");
-          goto err;
-        }
-        goto connected;
+	  goto err;
+	}
+	goto connected;
       } // if (event_len == packet_error)
 
-      retry_count=0;                    // ok event, reset retry counter
+      retry_count=0;			// ok event, reset retry counter
       thd->proc_info = "Queueing master event to the relay log";
       if (queue_event(mi,(const char*)mysql->net.read_pos + 1,
-                      event_len))
+		      event_len))
       {
-        sql_print_error("Slave I/O thread could not queue event from master");
-        goto err;
+	sql_print_error("Slave I/O thread could not queue event from master");
+	goto err;
       }
       if (flush_master_info(mi, 1))
       {
@@ -3494,14 +3494,14 @@
 #endif
 
       if (rli->log_space_limit && rli->log_space_limit <
-          rli->log_space_total &&
+	  rli->log_space_total &&
           !rli->ignore_log_space_limit)
-        if (wait_for_relay_log_space(rli))
-        {
-          sql_print_error("Slave I/O thread aborted while waiting for relay \
+	if (wait_for_relay_log_space(rli))
+	{
+	  sql_print_error("Slave I/O thread aborted while waiting for relay \
 log space");
-          goto err;
-        }
+	  goto err;
+	}
     }
   }
 
@@ -3509,7 +3509,7 @@
 err:
   // print the current replication position
   sql_print_information("Slave I/O thread exiting, read up to log '%s', position %s",
-                  IO_RPL_LOG_NAME, llstr(mi->master_log_pos,llbuff));
+		  IO_RPL_LOG_NAME, llstr(mi->master_log_pos,llbuff));
   VOID(pthread_mutex_lock(&LOCK_thread_count));
   thd->query = thd->db = 0; // extra safety
   thd->query_length= thd->db_length= 0;
@@ -3533,15 +3533,12 @@
   write_ignored_events_info_to_relay_log(thd, mi);
   thd->proc_info = "Waiting for slave mutex on exit";
   pthread_mutex_lock(&mi->run_lock);
-  mi->slave_running = 0;
-  mi->io_thd = 0;
 
   /* Forget the relay log's format */
   delete mi->rli.relay_log.description_event_for_queue;
   mi->rli.relay_log.description_event_for_queue= 0;
   // TODO: make rpl_status part of MASTER_INFO
   change_rpl_status(RPL_ACTIVE_SLAVE,RPL_IDLE_SLAVE);
-  mi->abort_slave = 0; // TODO: check if this is needed
   DBUG_ASSERT(thd->net.buff != 0);
   net_end(&thd->net); // destructor will not free it, because net.vio is 0
   close_thread_tables(thd, 0);
@@ -3549,11 +3546,14 @@
   THD_CHECK_SENTRY(thd);
   delete thd;
   pthread_mutex_unlock(&LOCK_thread_count);
-  pthread_cond_broadcast(&mi->stop_cond);       // tell the world we are done
+  pthread_cond_broadcast(&mi->stop_cond);	// tell the world we are done
   pthread_mutex_unlock(&mi->run_lock);
   my_thread_end();
+  mi->abort_slave = 0;
+  mi->slave_running = 0;
+  mi->io_thd = 0;
   pthread_exit(0);
-  DBUG_RETURN(0);                               // Can't return anything here
+  DBUG_RETURN(0);				// Can't return anything here
 }
 
 
@@ -3561,7 +3561,7 @@
 
 pthread_handler_t handle_slave_sql(void *arg)
 {
-  THD *thd;                     /* needs to be first for thread_stack */
+  THD *thd;			/* needs to be first for thread_stack */
   char llbuff[22],llbuff1[22];
 
   RELAY_LOG_INFO* rli = &((MASTER_INFO*)arg)->rli;
@@ -3635,13 +3635,13 @@
   rli->trans_retries= 0; // start from "no error"
 
   if (init_relay_log_pos(rli,
-                         rli->group_relay_log_name,
-                         rli->group_relay_log_pos,
-                         1 /*need data lock*/, &errmsg,
+			 rli->group_relay_log_name,
+			 rli->group_relay_log_pos,
+			 1 /*need data lock*/, &errmsg,
                          1 /*look for a description_event*/))
   {
     sql_print_error("Error initializing relay log position: %s",
-                    errmsg);
+		    errmsg);
     goto err;
   }
   THD_CHECK_SENTRY(thd);
@@ -3672,13 +3672,13 @@
   DBUG_ASSERT(rli->sql_thd == thd);
 
   DBUG_PRINT("master_info",("log_file_name: %s  position: %s",
-                            rli->group_master_log_name,
-                            llstr(rli->group_master_log_pos,llbuff)));
+			    rli->group_master_log_name,
+			    llstr(rli->group_master_log_pos,llbuff)));
   if (global_system_variables.log_warnings)
     sql_print_information("Slave SQL thread initialized, starting replication in \
 log '%s' at position %s, relay log '%s' position: %s", RPL_LOG_NAME,
-                    llstr(rli->group_master_log_pos,llbuff),rli->group_relay_log_name,
-                    llstr(rli->group_relay_log_pos,llbuff1));
+		    llstr(rli->group_master_log_pos,llbuff),rli->group_relay_log_name,
+		    llstr(rli->group_relay_log_pos,llbuff1));
 
   /* execute init_slave variable */
   if (sys_init_slave.value_length)
@@ -3742,8 +3742,8 @@
 
   /* Thread stopped. Print the current replication position to the log */
   sql_print_information("Slave SQL thread exiting, replication stopped in log "
-                        "'%s' at position %s",
-                        RPL_LOG_NAME, llstr(rli->group_master_log_pos,llbuff));
+ 			"'%s' at position %s",
+		        RPL_LOG_NAME, llstr(rli->group_master_log_pos,llbuff));
 
  err:
 
@@ -3801,7 +3801,7 @@
   pthread_mutex_unlock(&rli->run_lock);
   my_thread_end();
   pthread_exit(0);
-  DBUG_RETURN(0);                               // Can't return anything here
+  DBUG_RETURN(0);				// Can't return anything here
 }
 
 
@@ -3834,7 +3834,7 @@
   if (unlikely(net_request_file(net,cev->fname)))
   {
     sql_print_error("Slave I/O: failed requesting download of '%s'",
-                    cev->fname);
+		    cev->fname);
     goto err;
   }
 
@@ -3850,13 +3850,13 @@
     {
       if (unlikely((num_bytes=my_net_read(net)) == packet_error))
       {
-        sql_print_error("Network read error downloading '%s' from master",
-                        cev->fname);
-        goto err;
+	sql_print_error("Network read error downloading '%s' from master",
+			cev->fname);
+	goto err;
       }
       if (unlikely(!num_bytes)) /* eof */
       {
-        net_write_command(net, 0, "", 0, "", 0);/* 3.23 master wants it */
+	net_write_command(net, 0, "", 0, "", 0);/* 3.23 master wants it */
         /*
           If we wrote Create_file_log_event, then we need to write
           Execute_load_log_event. If we did not write Create_file_log_event,
@@ -3864,43 +3864,43 @@
           INFILE had not existed, i.e. write nothing.
         */
         if (unlikely(cev_not_written))
-          break;
-        Execute_load_log_event xev(thd,0,0);
-        xev.log_pos = cev->log_pos;
-        if (unlikely(mi->rli.relay_log.append(&xev)))
-        {
-          sql_print_error("Slave I/O: error writing Exec_load event to \
+	  break;
+	Execute_load_log_event xev(thd,0,0);
+	xev.log_pos = cev->log_pos;
+	if (unlikely(mi->rli.relay_log.append(&xev)))
+	{
+	  sql_print_error("Slave I/O: error writing Exec_load event to \
 relay log");
-          goto err;
-        }
-        mi->rli.relay_log.harvest_bytes_written(&mi->rli.log_space_total);
-        break;
+	  goto err;
+	}
+	mi->rli.relay_log.harvest_bytes_written(&mi->rli.log_space_total);
+	break;
       }
       if (unlikely(cev_not_written))
       {
-        cev->block = (char*)net->read_pos;
-        cev->block_len = num_bytes;
-        if (unlikely(mi->rli.relay_log.append(cev)))
-        {
-          sql_print_error("Slave I/O: error writing Create_file event to \
+	cev->block = (char*)net->read_pos;
+	cev->block_len = num_bytes;
+	if (unlikely(mi->rli.relay_log.append(cev)))
+	{
+	  sql_print_error("Slave I/O: error writing Create_file event to \
 relay log");
-          goto err;
-        }
-        cev_not_written=0;
-        mi->rli.relay_log.harvest_bytes_written(&mi->rli.log_space_total);
+	  goto err;
+	}
+	cev_not_written=0;
+	mi->rli.relay_log.harvest_bytes_written(&mi->rli.log_space_total);
       }
       else
       {
-        aev.block = (char*)net->read_pos;
-        aev.block_len = num_bytes;
-        aev.log_pos = cev->log_pos;
-        if (unlikely(mi->rli.relay_log.append(&aev)))
-        {
-          sql_print_error("Slave I/O: error writing Append_block event to \
+	aev.block = (char*)net->read_pos;
+	aev.block_len = num_bytes;
+	aev.log_pos = cev->log_pos;
+	if (unlikely(mi->rli.relay_log.append(&aev)))
+	{
+	  sql_print_error("Slave I/O: error writing Append_block event to \
 relay log");
-          goto err;
-        }
-        mi->rli.relay_log.harvest_bytes_written(&mi->rli.log_space_total) ;
+	  goto err;
+	}
+	mi->rli.relay_log.harvest_bytes_written(&mi->rli.log_space_total) ;
       }
     }
   }
@@ -3915,8 +3915,8 @@
 
   SYNOPSIS
     process_io_rotate()
-    mi                  master_info for the slave
-    rev                 The rotate log event read from the binary log
+    mi			master_info for the slave
+    rev			The rotate log event read from the binary log
 
   DESCRIPTION
     Updates the master info with the place in the next binary
@@ -3927,8 +3927,8 @@
     We assume we already locked mi->data_lock
 
   RETURN VALUES
-    0           ok
-    1           Log event is illegal
+    0		ok
+    1	        Log event is illegal
 
 */
 
@@ -3944,7 +3944,7 @@
   memcpy(mi->master_log_name, rev->new_log_ident, rev->ident_len+1);
   mi->master_log_pos= rev->pos;
   DBUG_PRINT("info", ("master_log_pos: '%s' %d",
-                      mi->master_log_name, (ulong) mi->master_log_pos));
+		      mi->master_log_name, (ulong) mi->master_log_pos));
 #ifndef DBUG_OFF
   /*
     If we do not do this, we will be getting the first
@@ -3981,7 +3981,7 @@
   copied from MySQL 4.0.
 */
 static int queue_binlog_ver_1_event(MASTER_INFO *mi, const char *buf,
-                           ulong event_len)
+			   ulong event_len)
 {
   const char *errmsg = 0;
   ulong inc_pos;
@@ -4025,7 +4025,7 @@
   {
     sql_print_error("Read invalid event from master: '%s',\
  master could be corrupt but a more likely cause of this is a bug",
-                    errmsg);
+		    errmsg);
     my_free((char*) tmp_buf, MYF(MY_ALLOW_ZERO_PTR));
     DBUG_RETURN(1);
   }
@@ -4097,7 +4097,7 @@
   from queue_binlog_ver_1_event(), with some affordable simplifications.
 */
 static int queue_binlog_ver_3_event(MASTER_INFO *mi, const char *buf,
-                           ulong event_len)
+			   ulong event_len)
 {
   const char *errmsg = 0;
   ulong inc_pos;
@@ -4112,7 +4112,7 @@
   {
     sql_print_error("Read invalid event from master: '%s',\
  master could be corrupt but a more likely cause of this is a bug",
-                    errmsg);
+		    errmsg);
     my_free((char*) tmp_buf, MYF(MY_ALLOW_ZERO_PTR));
     DBUG_RETURN(1);
   }
@@ -4161,7 +4161,7 @@
 */
 
 static int queue_old_event(MASTER_INFO *mi, const char *buf,
-                           ulong event_len)
+			   ulong event_len)
 {
   DBUG_ENTER("queue_old_event");
 
@@ -4376,13 +4376,13 @@
 
   SYNPOSIS
     safe_connect()
-    thd                 Thread handler for slave
-    mysql               MySQL connection handle
-    mi                  Replication handle
+    thd			Thread handler for slave
+    mysql		MySQL connection handle
+    mi			Replication handle
 
   RETURN
-    0   ok
-    #   Error
+    0	ok
+    #	Error
 */
 
 static int safe_connect(THD* thd, MYSQL* mysql, MASTER_INFO* mi)
@@ -4403,10 +4403,10 @@
 */
 
 static int connect_to_master(THD* thd, MYSQL* mysql, MASTER_INFO* mi,
-                             bool reconnect, bool suppress_warnings)
+			     bool reconnect, bool suppress_warnings)
 {
   int slave_was_killed;
-  int last_errno= -2;                           // impossible error
+  int last_errno= -2;				// impossible error
   ulong err_count=0;
   char llbuff[22];
   DBUG_ENTER("connect_to_master");
@@ -4416,7 +4416,7 @@
 #endif
   ulong client_flag= CLIENT_REMEMBER_OPTIONS;
   if (opt_slave_compressed_protocol)
-    client_flag=CLIENT_COMPRESS;                /* We will use compression */
+    client_flag=CLIENT_COMPRESS;		/* We will use compression */
 
   mysql_options(mysql, MYSQL_OPT_CONNECT_TIMEOUT, (char *) &slave_net_timeout);
   mysql_options(mysql, MYSQL_OPT_READ_TIMEOUT, (char *) &slave_net_timeout);
@@ -4436,9 +4436,9 @@
   mysql_options(mysql, MYSQL_SET_CHARSET_DIR, (char *) charsets_dir);
 
   while (!(slave_was_killed = io_slave_killed(thd,mi)) &&
-         (reconnect ? mysql_reconnect(mysql) != 0 :
-          mysql_real_connect(mysql, mi->host, mi->user, mi->password, 0,
-                             mi->port, 0, client_flag) == 0))
+	 (reconnect ? mysql_reconnect(mysql) != 0 :
+	  mysql_real_connect(mysql, mi->host, mi->user, mi->password, 0,
+			     mi->port, 0, client_flag) == 0))
   {
     /* Don't repeat last error */
     if ((int)mysql_errno(mysql) != last_errno)
@@ -4448,11 +4448,11 @@
       sql_print_error("Slave I/O thread: error %s to master \
 '%s@%s:%d': \
 Error: '%s'  errno: %d  retry-time: %d  retries: %d",
-                      (reconnect ? "reconnecting" : "connecting"),
-                      mi->user,mi->host,mi->port,
-                      mysql_error(mysql), last_errno,
-                      mi->connect_retry,
-                      master_retry_count);
+		      (reconnect ? "reconnecting" : "connecting"),
+		      mi->user,mi->host,mi->port,
+		      mysql_error(mysql), last_errno,
+		      mi->connect_retry,
+		      master_retry_count);
     }
     /*
       By default we try forever. The reason is that failure will trigger
@@ -4468,7 +4468,7 @@
       break;
     }
     safe_sleep(thd,mi->connect_retry,(CHECK_KILLED_FUNC)io_slave_killed,
-               (void*)mi);
+	       (void*)mi);
   }
 
   if (!slave_was_killed)
@@ -4476,11 +4476,11 @@
     if (reconnect)
     {
       if (!suppress_warnings && global_system_variables.log_warnings)
-        sql_print_information("Slave: connected to master '%s@%s:%d',\
+	sql_print_information("Slave: connected to master '%s@%s:%d',\
 replication resumed in log '%s' at position %s", mi->user,
-                        mi->host, mi->port,
-                        IO_RPL_LOG_NAME,
-                        llstr(mi->master_log_pos,llbuff));
+			mi->host, mi->port,
+			IO_RPL_LOG_NAME,
+			llstr(mi->master_log_pos,llbuff));
     }
     else
     {
@@ -4507,7 +4507,7 @@
 */
 
 static int safe_reconnect(THD* thd, MYSQL* mysql, MASTER_INFO* mi,
-                          bool suppress_warnings)
+			  bool suppress_warnings)
 {
   DBUG_ENTER("safe_reconnect");
   DBUG_RETURN(connect_to_master(thd, mysql, mi, 1, suppress_warnings));
@@ -4520,7 +4520,7 @@
 
   SYNOPSIS
     flush_relay_log_info()
-    rli                 Relay log information
+    rli			Relay log information
 
   NOTES
     - As this is only called by the slave thread, we don't need to
@@ -4539,8 +4539,8 @@
       longlong2str.
 
   RETURN VALUES
-    0   ok
-    1   write error
+    0	ok
+    1	write error
 */
 
 bool flush_relay_log_info(RELAY_LOG_INFO* rli)
@@ -4585,12 +4585,12 @@
 
   IO_CACHE *cur_log = rli->cur_log=&rli->cache_buf;
   if ((rli->cur_log_fd=open_binlog(cur_log,rli->event_relay_log_name,
-                                   errmsg)) <0)
+				   errmsg)) <0)
     DBUG_RETURN(0);
   /*
     We want to start exactly where we was before:
-    relay_log_pos       Current log pos
-    pending             Number of bytes already processed from the event
+    relay_log_pos	Current log pos
+    pending		Number of bytes already processed from the event
   */
   rli->event_relay_log_pos= max(rli->event_relay_log_pos, BIN_LOG_HEADER_SIZE);
   my_b_seek(cur_log,rli->event_relay_log_pos);
@@ -4643,17 +4643,17 @@
       pthread_mutex_lock(log_lock);
 
       /*
-        Reading xxx_file_id is safe because the log will only
-        be rotated when we hold relay_log.LOCK_log
+	Reading xxx_file_id is safe because the log will only
+	be rotated when we hold relay_log.LOCK_log
       */
       if (rli->relay_log.get_open_count() != rli->cur_log_old_open_count)
       {
-        // The master has switched to a new log file; Reopen the old log file
-        cur_log=reopen_relay_log(rli, &errmsg);
-        pthread_mutex_unlock(log_lock);
-        if (!cur_log)                           // No more log files
-          goto err;
-        hot_log=0;                              // Using old binary log
+	// The master has switched to a new log file; Reopen the old log file
+	cur_log=reopen_relay_log(rli, &errmsg);
+	pthread_mutex_unlock(log_lock);
+	if (!cur_log)				// No more log files
+	  goto err;
+	hot_log=0;				// Using old binary log
       }
     }
 
@@ -4691,25 +4691,25 @@
       */
       rli->future_event_relay_log_pos= my_b_tell(cur_log);
       if (hot_log)
-        pthread_mutex_unlock(log_lock);
+	pthread_mutex_unlock(log_lock);
       DBUG_RETURN(ev);
     }
     DBUG_ASSERT(thd==rli->sql_thd);
-    if (opt_reckless_slave)                     // For mysql-test
+    if (opt_reckless_slave)			// For mysql-test
       cur_log->error = 0;
     if (cur_log->error < 0)
     {
       errmsg = "slave SQL thread aborted because of I/O error";
       if (hot_log)
-        pthread_mutex_unlock(log_lock);
+	pthread_mutex_unlock(log_lock);
       goto err;
     }
     if (!cur_log->error) /* EOF */
     {
       /*
-        On a hot log, EOF means that there are no more updates to
-        process and we must block until I/O thread adds some and
-        signals us to continue
+	On a hot log, EOF means that there are no more updates to
+	process and we must block until I/O thread adds some and
+	signals us to continue
       */
       if (hot_log)
       {
@@ -4728,7 +4728,7 @@
         time_t save_timestamp= rli->last_master_timestamp;
         rli->last_master_timestamp= 0;
 
-        DBUG_ASSERT(rli->relay_log.get_open_count() ==
+	DBUG_ASSERT(rli->relay_log.get_open_count() ==
                     rli->cur_log_old_open_count);
 
         if (rli->ign_master_log_name_end[0])
@@ -4750,11 +4750,11 @@
           DBUG_RETURN(ev);
         }
 
-        /*
-          We can, and should release data_lock while we are waiting for
-          update. If we do not, show slave status will block
-        */
-        pthread_mutex_unlock(&rli->data_lock);
+	/*
+	  We can, and should release data_lock while we are waiting for
+	  update. If we do not, show slave status will block
+	*/
+	pthread_mutex_unlock(&rli->data_lock);
 
         /*
           Possible deadlock :
@@ -4796,12 +4796,12 @@
         // re-acquire data lock since we released it earlier
         pthread_mutex_lock(&rli->data_lock);
         rli->last_master_timestamp= save_timestamp;
-        continue;
+	continue;
       }
       /*
-        If the log was not hot, we need to move to the next log in
-        sequence. The next log could be hot or cold, we deal with both
-        cases separately after doing some common initialization
+	If the log was not hot, we need to move to the next log in
+	sequence. The next log could be hot or cold, we deal with both
+	cases separately after doing some common initialization
       */
       end_io_cache(cur_log);
       DBUG_ASSERT(rli->cur_log_fd >= 0);
@@ -4810,7 +4810,7 @@
 
       if (relay_log_purge)
       {
-        /*
+	/*
           purge_first_log will properly set up relay log coordinates in rli.
           If the group's coordinates are equal to the event's coordinates
           (i.e. the relay log was not rotated in the middle of a group),
@@ -4821,33 +4821,33 @@
           - I see no better detection method
           - purge_first_log is not called that often
         */
-        if (rli->relay_log.purge_first_log
+	if (rli->relay_log.purge_first_log
             (rli,
              rli->group_relay_log_pos == rli->event_relay_log_pos
              && !strcmp(rli->group_relay_log_name,rli->event_relay_log_name)))
-        {
-          errmsg = "Error purging processed logs";
-          goto err;
-        }
+	{
+	  errmsg = "Error purging processed logs";
+	  goto err;
+	}
       }
       else
       {
-        /*
-          If hot_log is set, then we already have a lock on
-          LOCK_log.  If not, we have to get the lock.
-
-          According to Sasha, the only time this code will ever be executed
-          is if we are recovering from a bug.
-        */
-        if (rli->relay_log.find_next_log(&rli->linfo, !hot_log))
-        {
-          errmsg = "error switching to the next log";
-          goto err;
-        }
-        rli->event_relay_log_pos = BIN_LOG_HEADER_SIZE;
-        strmake(rli->event_relay_log_name,rli->linfo.log_file_name,
-                sizeof(rli->event_relay_log_name)-1);
-        flush_relay_log_info(rli);
+	/*
+	  If hot_log is set, then we already have a lock on
+	  LOCK_log.  If not, we have to get the lock.
+
+	  According to Sasha, the only time this code will ever be executed
+	  is if we are recovering from a bug.
+	*/
+	if (rli->relay_log.find_next_log(&rli->linfo, !hot_log))
+	{
+	  errmsg = "error switching to the next log";
+	  goto err;
+	}
+	rli->event_relay_log_pos = BIN_LOG_HEADER_SIZE;
+	strmake(rli->event_relay_log_name,rli->linfo.log_file_name,
+		sizeof(rli->event_relay_log_name)-1);
+	flush_relay_log_info(rli);
       }
 
       /*
@@ -4866,61 +4866,61 @@
       if (rli->relay_log.is_active(rli->linfo.log_file_name))
       {
 #ifdef EXTRA_DEBUG
-        if (global_system_variables.log_warnings)
-          sql_print_information("next log '%s' is currently active",
+	if (global_system_variables.log_warnings)
+	  sql_print_information("next log '%s' is currently active",
                                 rli->linfo.log_file_name);
 #endif
-        rli->cur_log= cur_log= rli->relay_log.get_log_file();
-        rli->cur_log_old_open_count= rli->relay_log.get_open_count();
-        DBUG_ASSERT(rli->cur_log_fd == -1);
-
-        /*
-          Read pointer has to be at the start since we are the only
-          reader.
+	rli->cur_log= cur_log= rli->relay_log.get_log_file();
+	rli->cur_log_old_open_count= rli->relay_log.get_open_count();
+	DBUG_ASSERT(rli->cur_log_fd == -1);
+
+	/*
+	  Read pointer has to be at the start since we are the only
+	  reader.
           We must keep the LOCK_log to read the 4 first bytes, as this is a hot
           log (same as when we call read_log_event() above: for a hot log we
           take the mutex).
-        */
-        if (check_binlog_magic(cur_log,&errmsg))
+	*/
+	if (check_binlog_magic(cur_log,&errmsg))
         {
           if (!hot_log) pthread_mutex_unlock(log_lock);
-          goto err;
+	  goto err;
         }
         if (!hot_log) pthread_mutex_unlock(log_lock);
-        continue;
+	continue;
       }
       if (!hot_log) pthread_mutex_unlock(log_lock);
       /*
-        if we get here, the log was not hot, so we will have to open it
-        ourselves. We are sure that the log is still not hot now (a log can get
-        from hot to cold, but not from cold to hot). No need for LOCK_log.
+	if we get here, the log was not hot, so we will have to open it
+	ourselves. We are sure that the log is still not hot now (a log can get
+	from hot to cold, but not from cold to hot). No need for LOCK_log.
       */
 #ifdef EXTRA_DEBUG
       if (global_system_variables.log_warnings)
-        sql_print_information("next log '%s' is not active",
+	sql_print_information("next log '%s' is not active",
                               rli->linfo.log_file_name);
 #endif
       // open_binlog() will check the magic header
       if ((rli->cur_log_fd=open_binlog(cur_log,rli->linfo.log_file_name,
-                                       &errmsg)) <0)
-        goto err;
+				       &errmsg)) <0)
+	goto err;
     }
     else
     {
       /*
-        Read failed with a non-EOF error.
-        TODO: come up with something better to handle this error
+	Read failed with a non-EOF error.
+	TODO: come up with something better to handle this error
       */
       if (hot_log)
-        pthread_mutex_unlock(log_lock);
+	pthread_mutex_unlock(log_lock);
       sql_print_error("Slave SQL thread: I/O error reading \
 event(errno: %d  cur_log->error: %d)",
-                      my_errno,cur_log->error);
+		      my_errno,cur_log->error);
       // set read position to the beginning of the event
       my_b_seek(cur_log,rli->event_relay_log_pos);
       /* otherwise, we have had a partial read */
       errmsg = "Aborting slave SQL thread because of partial event read";
-      break;                                    // To end of function
+      break;					// To end of function
     }
   }
   if (!errmsg && global_system_variables.log_warnings)
Thread
bk commit into 5.1 tree (grog:1.2234) BUG#20850Greg Lehey7 Jul