MySQL Lists are EOL. Please join:

List:Commits« Previous MessageNext Message »
From:Petr Chardin Date:June 15 2006 11:38am
Subject:bk commit into 5.1 tree (petr:1.2208)
View as plain text  
Below is the list of changes that have just been committed into a local
5.1 repository of cps. When cps 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.2208 06/06/15 15:38:14 petr@stripped +6 -0
  Merge pchardin@stripped:/home/bk/mysql-5.1-runtime
  into  mysql.com:/home/cps/mysql/devel/5.1-csv-remove-mmap

  sql/slave.cc
    1.273 06/06/15 15:38:09 petr@stripped +0 -0
    Auto merged

  sql/mysqld.cc
    1.559 06/06/15 15:38:09 petr@stripped +0 -0
    Auto merged

  sql/mysql_priv.h
    1.410 06/06/15 15:38:08 petr@stripped +0 -0
    Auto merged

  sql/log_event.h
    1.135 06/06/15 15:38:08 petr@stripped +0 -0
    Auto merged

  sql/log.cc
    1.214 06/06/15 15:38:08 petr@stripped +0 -0
    Auto merged

  sql/ha_ndbcluster_binlog.cc
    1.66 06/06/15 15:38:08 petr@stripped +0 -0
    Auto merged

# 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:	petr
# Host:	outpost.site
# Root:	/home/cps/mysql/devel/5.1-csv-remove-mmap/RESYNC

--- 1.213/sql/log.cc	2006-06-09 18:06:13 +04:00
+++ 1.214/sql/log.cc	2006-06-15 15:38:08 +04:00
@@ -42,7 +42,7 @@
 
 LOGGER logger;
 
-MYSQL_LOG mysql_bin_log;
+MYSQL_BIN_LOG mysql_bin_log;
 ulong sync_binlog_counter= 0;
 
 static bool test_if_number(const char *str,
@@ -86,8 +86,8 @@
   SYNOPSIS
     open_log_table()
 
-    log_type   type of the log table to open: QUERY_LOG_GENERAL
-               or QUERY_LOG_SLOW
+    log_table_type   type of the log table to open: QUERY_LOG_GENERAL
+                     or QUERY_LOG_SLOW
 
   DESCRIPTION
 
@@ -102,14 +102,14 @@
     TRUE - error occured
 */
 
-bool Log_to_csv_event_handler::open_log_table(uint log_type)
+bool Log_to_csv_event_handler::open_log_table(uint log_table_type)
 {
   THD *log_thd, *curr= current_thd;
   TABLE_LIST *table;
   bool error= FALSE;
   DBUG_ENTER("open_log_table");
 
-  switch (log_type) {
+  switch (log_table_type) {
   case QUERY_LOG_GENERAL:
     log_thd= general_log_thd;
     table= &general_log;
@@ -222,8 +222,8 @@
   SYNOPSIS
     reopen_log_table()
 
-    log_type   type of the log table to open: QUERY_LOG_GENERAL
-               or QUERY_LOG_SLOW
+    log_table_type   type of the log table to open: QUERY_LOG_GENERAL
+                     or QUERY_LOG_SLOW
 
   DESCRIPTION
 
@@ -240,12 +240,12 @@
     TRUE - open_log_table() returned an error
 */
 
-bool Log_to_csv_event_handler::reopen_log_table(uint log_type)
+bool Log_to_csv_event_handler::reopen_log_table(uint log_table_type)
 {
   /* don't open the log table, if it wasn't enabled during startup */
   if (!logger.is_log_tables_initialized)
     return FALSE;
-  return open_log_table(log_type);
+  return open_log_table(log_table_type);
 }
 
 void Log_to_csv_event_handler::cleanup()
@@ -525,9 +525,8 @@
 
 void Log_to_file_event_handler::flush()
 {
-  /* reopen log files */
-  mysql_log.new_file(1);
-  mysql_slow_log.new_file(1);
+  mysql_log.reopen_file();
+  mysql_slow_log.reopen_file();
 }
 
 /*
@@ -582,9 +581,9 @@
 }
 
 
-void LOGGER::close_log_table(uint log_type, bool lock_in_use)
+void LOGGER::close_log_table(uint log_table_type, bool lock_in_use)
 {
-  table_log_handler->close_log_table(log_type, lock_in_use);
+  table_log_handler->close_log_table(log_table_type, lock_in_use);
 }
 
 
@@ -624,9 +623,9 @@
 }
 
 
-bool LOGGER::reopen_log_table(uint log_type)
+bool LOGGER::reopen_log_table(uint log_table_type)
 {
-  return table_log_handler->reopen_log_table(log_type);
+  return table_log_handler->reopen_log_table(log_table_type);
 }
 
 
@@ -961,9 +960,9 @@
   SYNOPSIS
     close_log_table()
 
-    log_type       type of the log table to close: QUERY_LOG_GENERAL
-                   or QUERY_LOG_SLOW
-    lock_in_use    Set to TRUE if the caller owns LOCK_open. FALSE otherwise.
+    log_table_type   type of the log table to close: QUERY_LOG_GENERAL
+                     or QUERY_LOG_SLOW
+    lock_in_use      Set to TRUE if the caller owns LOCK_open. FALSE otherwise.
 
   DESCRIPTION
 
@@ -973,7 +972,7 @@
 */
 
 void Log_to_csv_event_handler::
-  close_log_table(uint log_type, bool lock_in_use)
+  close_log_table(uint log_table_type, bool lock_in_use)
 {
   THD *log_thd, *curr= current_thd;
   TABLE_LIST *table;
@@ -981,7 +980,7 @@
   if (!logger.is_log_tables_initialized)
     return;                                     /* do nothing */
 
-  switch (log_type) {
+  switch (log_table_type) {
   case QUERY_LOG_GENERAL:
     log_thd= general_log_thd;
     table= &general_log;
@@ -1022,7 +1021,7 @@
 
 /*
   this function is mostly a placeholder.
-  conceptually, binlog initialization (now mostly done in MYSQL_LOG::open)
+  conceptually, binlog initialization (now mostly done in MYSQL_BIN_LOG::open)
   should be moved here.
 */
 
@@ -1111,7 +1110,7 @@
     do nothing.
     just pretend we can do 2pc, so that MySQL won't
     switch to 1pc.
-    real work will be done in MYSQL_LOG::log()
+    real work will be done in MYSQL_BIN_LOG::log()
   */
   return 0;
 }
@@ -1127,7 +1126,7 @@
 
   if (trx_data->empty())
   {
-    // we're here because trans_log was flushed in MYSQL_LOG::log()
+    // we're here because trans_log was flushed in MYSQL_BIN_LOG::log()
     DBUG_RETURN(0);
   }
   Query_log_event qev(thd, STRING_WITH_LEN("COMMIT"), TRUE, FALSE);
@@ -1367,12 +1366,119 @@
 }
 
 
+void MYSQL_LOG::init(enum_log_type log_type_arg,
+                     enum cache_type io_cache_type_arg)
+{
+  DBUG_ENTER("MYSQL_LOG::init");
+  log_type= log_type_arg;
+  io_cache_type= io_cache_type_arg;
+  DBUG_PRINT("info",("log_type: %d", log_type));
+  DBUG_VOID_RETURN;
+}
+
+
+/*
+  Open a (new) log file.
+
+  SYNOPSIS
+    open()
+
+    log_name            The name of the log to open
+    log_type_arg        The type of the log. E.g. LOG_NORMAL
+    new_name            The new name for the logfile. This is only needed
+                        when the method is used to open the binlog file.
+    io_cache_type_arg   The type of the IO_CACHE to use for this log file
+
+  DESCRIPTION
+    Open the logfile, init IO_CACHE and write startup messages
+    (in case of general and slow query logs).
+
+  RETURN VALUES
+    0   ok
+    1   error
+*/
+
+bool MYSQL_LOG::open(const char *log_name, enum_log_type log_type_arg,
+                     const char *new_name, enum cache_type io_cache_type_arg)
+{
+  char buff[FN_REFLEN];
+  File file= -1;
+  int open_flags= O_CREAT | O_BINARY;
+  DBUG_ENTER("MYSQL_LOG::open");
+  DBUG_PRINT("enter", ("log_type: %d", (int) log_type_arg));
+
+  write_error= 0;
+
+  init(log_type_arg, io_cache_type_arg);
+
+  if (!(name= my_strdup(log_name, MYF(MY_WME))))
+  {
+    name= (char *)log_name; // for the error message
+    goto err;
+  }
+
+  if (new_name)
+    strmov(log_file_name, new_name);
+  else if (generate_new_name(log_file_name, name))
+    goto err;
+
+  if (io_cache_type == SEQ_READ_APPEND)
+    open_flags |= O_RDWR | O_APPEND;
+  else
+    open_flags |= O_WRONLY | (log_type == LOG_BIN ? 0 : O_APPEND);
+
+  db[0]= 0;
+
+  if ((file= my_open(log_file_name, open_flags,
+                     MYF(MY_WME | ME_WAITTANG))) < 0 ||
+      init_io_cache(&log_file, file, IO_SIZE, io_cache_type,
+                    my_tell(file, MYF(MY_WME)), 0,
+                    MYF(MY_WME | MY_NABP |
+                        ((log_type == LOG_BIN) ? MY_WAIT_IF_FULL : 0))))
+    goto err;
+
+  if (log_type == LOG_NORMAL)
+  {
+    char *end;
+    int len=my_snprintf(buff, sizeof(buff), "%s, Version: %s. "
+#ifdef EMBEDDED_LIBRARY
+		        "embedded library\n", my_progname, server_version
+#elif __NT__
+			"started with:\nTCP Port: %d, Named Pipe: %s\n",
+			my_progname, server_version, mysqld_port,
+                        mysqld_unix_port
+#else
+			"started with:\nTcp port: %d  Unix socket: %s\n",
+			my_progname, server_version, mysqld_port,
+                        mysqld_unix_port
+#endif
+                       );
+    end= strnmov(buff + len, "Time                 Id Command    Argument\n",
+                 sizeof(buff) - len);
+    if (my_b_write(&log_file, (byte*) buff, (uint) (end-buff)) ||
+	flush_io_cache(&log_file))
+      goto err;
+  }
+
+  log_state= LOG_OPENED;
+  DBUG_RETURN(0);
+
+err:
+  sql_print_error("Could not use %s for logging (error %d). \
+Turning logging off for the whole duration of the MySQL server process. \
+To turn it on again: fix the cause, \
+shutdown the MySQL server and restart it.", name, errno);
+  if (file >= 0)
+    my_close(file, MYF(0));
+  end_io_cache(&log_file);
+  safeFree(name);
+  log_state= LOG_CLOSED;
+  DBUG_RETURN(1);
+}
+
 MYSQL_LOG::MYSQL_LOG()
-  :bytes_written(0), last_time(0), query_start(0), name(0),
-   prepared_xids(0), log_type(LOG_CLOSED), file_id(1), open_count(1),
-   write_error(FALSE), inited(FALSE), need_start_event(TRUE),
-   m_table_map_version(0),
-   description_event_for_exec(0), description_event_for_queue(0)
+  : name(0),  log_type(LOG_UNKNOWN), log_state(LOG_CLOSED), write_error(FALSE),
+    inited(FALSE)
 {
   /*
     We don't want to initialize LOCK_Log here as such initialization depends on
@@ -1380,9 +1486,54 @@
     called only in main(). Doing initialization here would make it happen
     before main().
   */
-  index_file_name[0] = 0;
-  bzero((char*) &log_file,sizeof(log_file));
-  bzero((char*) &index_file, sizeof(index_file));
+  bzero((char*) &log_file, sizeof(log_file));
+}
+
+void MYSQL_LOG::init_pthread_objects()
+{
+  DBUG_ASSERT(inited == 0);
+  inited= 1;
+  (void) pthread_mutex_init(&LOCK_log, MY_MUTEX_INIT_SLOW);
+}
+
+/*
+  Close the log file
+
+  SYNOPSIS
+    close()
+    exiting     Bitmask. For the slow and general logs the only used bit is
+                LOG_CLOSE_TO_BE_OPENED. This is used if we intend to call
+                open at once after close.
+
+  NOTES
+    One can do an open on the object at once after doing a close.
+    The internal structures are not freed until cleanup() is called
+*/
+
+void MYSQL_LOG::close(uint exiting)
+{					// One can't set log_type here!
+  DBUG_ENTER("MYSQL_LOG::close");
+  DBUG_PRINT("enter",("exiting: %d", (int) exiting));
+  if (log_state == LOG_OPENED)
+  {
+    end_io_cache(&log_file);
+
+    if (my_sync(log_file.file, MYF(MY_WME)) && ! write_error)
+    {
+      write_error= 1;
+      sql_print_error(ER(ER_ERROR_ON_WRITE), name, errno);
+    }
+
+    if (my_close(log_file.file, MYF(MY_WME)) && ! write_error)
+    {
+      write_error= 1;
+      sql_print_error(ER(ER_ERROR_ON_WRITE), name, errno);
+    }
+  }
+
+  log_state= (exiting & LOG_CLOSE_TO_BE_OPENED) ? LOG_TO_BE_OPENED : LOG_CLOSED;
+  safeFree(name);
+  DBUG_VOID_RETURN;
 }
 
 /* this is called only once */
@@ -1393,12 +1544,8 @@
   if (inited)
   {
     inited= 0;
-    close(LOG_CLOSE_INDEX|LOG_CLOSE_STOP_EVENT);
-    delete description_event_for_queue;
-    delete description_event_for_exec;
     (void) pthread_mutex_destroy(&LOCK_log);
-    (void) pthread_mutex_destroy(&LOCK_index);
-    (void) pthread_cond_destroy(&update_cond);
+    close(0);
   }
   DBUG_VOID_RETURN;
 }
@@ -1406,8 +1553,8 @@
 
 int MYSQL_LOG::generate_new_name(char *new_name, const char *log_name)
 {
-  fn_format(new_name,log_name,mysql_data_home,"",4);
-  if (log_type != LOG_NORMAL)
+  fn_format(new_name, log_name, mysql_data_home, "", 4);
+  if (log_type == LOG_BIN)
   {
     if (!fn_ext(log_name)[0])
     {
@@ -1422,33 +1569,287 @@
 }
 
 
-void MYSQL_LOG::init(enum_log_type log_type_arg,
-		     enum cache_type io_cache_type_arg,
-		     bool no_auto_events_arg,
-                     ulong max_size_arg)
+/*
+  Reopen the log file
+
+  SYNOPSIS
+    reopen_file()
+
+  DESCRIPTION
+    Reopen the log file. The method is used during FLUSH LOGS
+    and locks LOCK_log mutex
+*/
+
+
+void MYSQL_QUERY_LOG::reopen_file()
 {
-  DBUG_ENTER("MYSQL_LOG::init");
-  log_type = log_type_arg;
-  io_cache_type = io_cache_type_arg;
-  no_auto_events = no_auto_events_arg;
-  max_size=max_size_arg;
-  DBUG_PRINT("info",("log_type: %d max_size: %lu", log_type, max_size));
+  char *save_name;
+
+  DBUG_ENTER("MYSQL_LOG::reopen_file");
+  if (!is_open())
+  {
+    DBUG_PRINT("info",("log is closed"));
+    DBUG_VOID_RETURN;
+  }
+
+  pthread_mutex_lock(&LOCK_log);
+
+  save_name= name;
+  name= 0;				// Don't free name
+  close(LOG_CLOSE_TO_BE_OPENED);
+
+  /*
+     Note that at this point, log_state != LOG_CLOSED (important for is_open()).
+  */
+
+  open(save_name, log_type, 0, io_cache_type);
+  my_free(save_name, MYF(0));
+
+  pthread_mutex_unlock(&LOCK_log);
+
   DBUG_VOID_RETURN;
 }
 
 
-void MYSQL_LOG::init_pthread_objects()
+/*
+  Write a command to traditional general log file
+
+  SYNOPSIS
+    write()
+
+    event_time        command start timestamp
+    user_host         the pointer to the string with user@host info
+    user_host_len     length of the user_host string. this is computed once
+                      and passed to all general log  event handlers
+    thread_id         Id of the thread, issued a query
+    command_type      the type of the command being logged
+    command_type_len  the length of the string above
+    sql_text          the very text of the query being executed
+    sql_text_len      the length of sql_text string
+
+  DESCRIPTION
+
+   Log given command to to normal (not rotable) log file
+
+  RETURN
+    FASE - OK
+    TRUE - error occured
+*/
+
+bool MYSQL_QUERY_LOG::write(time_t event_time, const char *user_host,
+                            uint user_host_len, int thread_id,
+                            const char *command_type, uint command_type_len,
+                            const char *sql_text, uint sql_text_len)
 {
-  DBUG_ASSERT(inited == 0);
-  inited= 1;
-  (void) pthread_mutex_init(&LOCK_log,MY_MUTEX_INIT_SLOW);
-  (void) pthread_mutex_init(&LOCK_index, MY_MUTEX_INIT_SLOW);
-  (void) pthread_cond_init(&update_cond, 0);
+  char buff[32];
+  uint length= 0;
+  char time_buff[MAX_TIME_SIZE];
+  struct tm start;
+  uint time_buff_len= 0;
+
+  /* Test if someone closed between the is_open test and lock */
+  if (is_open())
+  {
+    /* Note that my_b_write() assumes it knows the length for this */
+      if (event_time != last_time)
+      {
+        last_time= event_time;
+
+        localtime_r(&event_time, &start);
+
+        time_buff_len= my_snprintf(time_buff, MAX_TIME_SIZE,
+                                   "%02d%02d%02d %2d:%02d:%02d",
+                                   start.tm_year % 100, start.tm_mon + 1,
+                                   start.tm_mday, start.tm_hour,
+                                   start.tm_min, start.tm_sec);
+
+        if (my_b_write(&log_file, (byte*) &time_buff, time_buff_len))
+          goto err;
+      }
+      else
+        if (my_b_write(&log_file, (byte*) "\t\t" ,2) < 0)
+          goto err;
+
+    /* command_type, thread_id */
+    length= my_snprintf(buff, 32, "%5ld ", thread_id);
+
+    if (my_b_write(&log_file, (byte*) buff, length))
+      goto err;
+
+    if (my_b_write(&log_file, (byte*) command_type, command_type_len))
+      goto err;
+
+    if (my_b_write(&log_file, (byte*) "\t", 1))
+      goto err;
+
+    /* sql_text */
+    if (my_b_write(&log_file, (byte*) sql_text, sql_text_len))
+      goto err;
+
+    if (my_b_write(&log_file, (byte*) "\n", 1) ||
+        flush_io_cache(&log_file))
+      goto err;
+  }
+
+  return FALSE;
+err:
+
+  if (!write_error)
+  {
+    write_error= 1;
+    sql_print_error(ER(ER_ERROR_ON_WRITE), name, errno);
+  }
+  return TRUE;
 }
 
+
+/*
+  Log a query to the traditional slow log file
+
+  SYNOPSIS
+    write()
+
+    thd               THD of the query
+    current_time      current timestamp
+    query_start_arg   command start timestamp
+    user_host         the pointer to the string with user@host info
+    user_host_len     length of the user_host string. this is computed once
+                      and passed to all general log event handlers
+    query_time        Amount of time the query took to execute (in seconds)
+    lock_time         Amount of time the query was locked (in seconds)
+    is_command        The flag, which determines, whether the sql_text is a
+                      query or an administrator command.
+    sql_text          the very text of the query or administrator command
+                      processed
+    sql_text_len      the length of sql_text string
+
+  DESCRIPTION
+
+   Log a query to the slow log file.
+
+  RETURN
+    FALSE - OK
+    TRUE - error occured
+*/
+
+bool MYSQL_QUERY_LOG::write(THD *thd, time_t current_time,
+                            time_t query_start_arg, const char *user_host,
+                            uint user_host_len, longlong query_time,
+                            longlong lock_time, bool is_command,
+                            const char *sql_text, uint sql_text_len)
+{
+  bool error= 0;
+  DBUG_ENTER("MYSQL_QUERY_LOG::write");
+
+  if (!is_open())
+    DBUG_RETURN(0);
+
+  if (is_open())
+  {						// Safety agains reopen
+    int tmp_errno= 0;
+    char buff[80], *end;
+    uint buff_len;
+    end= buff;
+
+    if (!(specialflag & SPECIAL_SHORT_LOG_FORMAT))
+    {
+      Security_context *sctx= thd->security_ctx;
+      if (current_time != last_time)
+      {
+        last_time= current_time;
+        struct tm start;
+        localtime_r(&current_time, &start);
+
+        buff_len= my_snprintf(buff, sizeof buff,
+                              "# Time: %02d%02d%02d %2d:%02d:%02d\n",
+                              start.tm_year % 100, start.tm_mon + 1,
+                              start.tm_mday, start.tm_hour,
+                              start.tm_min, start.tm_sec);
+
+        /* Note that my_b_write() assumes it knows the length for this */
+        if (my_b_write(&log_file, (byte*) buff, buff_len))
+          tmp_errno= errno;
+      }
+      if (my_b_printf(&log_file, "# User@Host: ", sizeof("# User@Host: ") - 1)
+          != sizeof("# User@Host: ") - 1)
+        tmp_errno= errno;
+      if (my_b_printf(&log_file, user_host, user_host_len) != user_host_len)
+        tmp_errno= errno;
+      if (my_b_write(&log_file, (byte*) "\n", 1))
+        tmp_errno= errno;
+    }
+    /* For slow query log */
+    if (my_b_printf(&log_file,
+                    "# Query_time: %lu  Lock_time: %lu"
+                    " Rows_sent: %lu  Rows_examined: %lu\n",
+                    (ulong) query_time, (ulong) lock_time,
+                    (ulong) thd->sent_row_count,
+                    (ulong) thd->examined_row_count) == (uint) -1)
+      tmp_errno= errno;
+    if (thd->db && strcmp(thd->db, db))
+    {						// Database changed
+      if (my_b_printf(&log_file,"use %s;\n",thd->db) == (uint) -1)
+        tmp_errno= errno;
+      strmov(db,thd->db);
+    }
+    if (thd->last_insert_id_used)
+    {
+      end=strmov(end, ",last_insert_id=");
+      end=longlong10_to_str((longlong) thd->current_insert_id, end, -10);
+    }
+    // Save value if we do an insert.
+    if (thd->insert_id_used)
+    {
+      if (!(specialflag & SPECIAL_SHORT_LOG_FORMAT))
+      {
+        end=strmov(end,",insert_id=");
+        end=longlong10_to_str((longlong) thd->last_insert_id, end, -10);
+      }
+    }
+
+    /*
+      This info used to show up randomly, depending on whether the query
+      checked the query start time or not. now we always write current
+      timestamp to the slow log
+    */
+    end= strmov(end, ",timestamp=");
+    end= int10_to_str((long) current_time, end, 10);
+
+    if (end != buff)
+    {
+      *end++=';';
+      *end='\n';
+      if (my_b_write(&log_file, (byte*) "SET ", 4) ||
+          my_b_write(&log_file, (byte*) buff + 1, (uint) (end-buff)))
+        tmp_errno= errno;
+    }
+    if (is_command)
+    {
+      end= strxmov(buff, "# administrator command: ", NullS);
+      buff_len= (ulong) (end - buff);
+      my_b_write(&log_file, (byte*) buff, buff_len);
+    }
+    if (my_b_write(&log_file, (byte*) sql_text, sql_text_len) ||
+        my_b_write(&log_file, (byte*) ";\n",2) ||
+        flush_io_cache(&log_file))
+      tmp_errno= errno;
+    if (tmp_errno)
+    {
+      error= 1;
+      if (! write_error)
+      {
+        write_error= 1;
+        sql_print_error(ER(ER_ERROR_ON_WRITE), name, error);
+      }
+    }
+  }
+  DBUG_RETURN(error);
+}
+
+
 const char *MYSQL_LOG::generate_name(const char *log_name,
-                                     const char *suffix,
-                                     bool strip_ext, char *buff)
+                                      const char *suffix,
+                                      bool strip_ext, char *buff)
 {
   if (!log_name || !log_name[0])
   {
@@ -1456,23 +1857,79 @@
       TODO: The following should be using fn_format();  We just need to
       first change fn_format() to cut the file name if it's too long.
     */
-    strmake(buff,glob_hostname,FN_REFLEN-5);
-    strmov(fn_ext(buff),suffix);
+    strmake(buff, glob_hostname, FN_REFLEN - 5);
+    strmov(fn_ext(buff), suffix);
     return (const char *)buff;
   }
   // get rid of extension if the log is binary to avoid problems
   if (strip_ext)
   {
-    char *p = fn_ext(log_name);
-    uint length=(uint) (p-log_name);
-    strmake(buff,log_name,min(length,FN_REFLEN));
+    char *p= fn_ext(log_name);
+    uint length= (uint) (p - log_name);
+    strmake(buff, log_name, min(length, FN_REFLEN));
     return (const char*)buff;
   }
   return log_name;
 }
 
 
-bool MYSQL_LOG::open_index_file(const char *index_file_name_arg,
+
+MYSQL_BIN_LOG::MYSQL_BIN_LOG()
+  :bytes_written(0), prepared_xids(0), file_id(1), open_count(1),
+   need_start_event(TRUE), m_table_map_version(0),
+   description_event_for_exec(0), description_event_for_queue(0)
+{
+  /*
+    We don't want to initialize locks here as such initialization depends on
+    safe_mutex (when using safe_mutex) which depends on MY_INIT(), which is
+    called only in main(). Doing initialization here would make it happen
+    before main().
+  */
+  index_file_name[0] = 0;
+  bzero((char*) &index_file, sizeof(index_file));
+}
+
+/* this is called only once */
+
+void MYSQL_BIN_LOG::cleanup()
+{
+  DBUG_ENTER("cleanup");
+  if (inited)
+  {
+    inited= 0;
+    close(LOG_CLOSE_INDEX|LOG_CLOSE_STOP_EVENT);
+    delete description_event_for_queue;
+    delete description_event_for_exec;
+    (void) pthread_mutex_destroy(&LOCK_log);
+    (void) pthread_mutex_destroy(&LOCK_index);
+    (void) pthread_cond_destroy(&update_cond);
+  }
+  DBUG_VOID_RETURN;
+}
+
+
+/* Init binlog-specific vars */
+void MYSQL_BIN_LOG::init(bool no_auto_events_arg, ulong max_size_arg)
+{
+  DBUG_ENTER("MYSQL_BIN_LOG::init");
+  no_auto_events= no_auto_events_arg;
+  max_size= max_size_arg;
+  DBUG_PRINT("info",("max_size: %lu", max_size));
+  DBUG_VOID_RETURN;
+}
+
+
+void MYSQL_BIN_LOG::init_pthread_objects()
+{
+  DBUG_ASSERT(inited == 0);
+  inited= 1;
+  (void) pthread_mutex_init(&LOCK_log, MY_MUTEX_INIT_SLOW);
+  (void) pthread_mutex_init(&LOCK_index, MY_MUTEX_INIT_SLOW);
+  (void) pthread_cond_init(&update_cond, 0);
+}
+
+
+bool MYSQL_BIN_LOG::open_index_file(const char *index_file_name_arg,
                                 const char *log_name)
 {
   File index_file_nr= -1;
@@ -1509,10 +1966,10 @@
 
 
 /*
-  Open a (new) log file.
+  Open a (new) binlog file.
 
   DESCRIPTION
-  - If binary logs, also open the index file and register the new
+  - Open the log file and the index file. Register the new
     file name in it
   - When calling this when the file is in use, you must have a locks
     on LOCK_log and LOCK_index.
@@ -1522,94 +1979,32 @@
     1	error
 */
 
-bool MYSQL_LOG::open(const char *log_name,
-                     enum_log_type log_type_arg,
-                     const char *new_name,
-                     enum cache_type io_cache_type_arg,
-                     bool no_auto_events_arg,
-                     ulong max_size_arg,
-                     bool null_created_arg)
+bool MYSQL_BIN_LOG::open(const char *log_name,
+                         enum_log_type log_type_arg,
+                         const char *new_name,
+                         enum cache_type io_cache_type_arg,
+                         bool no_auto_events_arg,
+                         ulong max_size_arg,
+                         bool null_created_arg)
 {
   char buff[FN_REFLEN];
   File file= -1;
   int open_flags = O_CREAT | O_BINARY;
-  DBUG_ENTER("MYSQL_LOG::open");
+  DBUG_ENTER("MYSQL_BIN_LOG::open");
   DBUG_PRINT("enter",("log_type: %d",(int) log_type_arg));
 
-  last_time=query_start=0;
   write_error=0;
 
-  init(log_type_arg,io_cache_type_arg,no_auto_events_arg,max_size_arg);
+  /* open the main log file */
+  if (MYSQL_LOG::open(log_name, log_type_arg, new_name, io_cache_type_arg))
+    DBUG_RETURN(1);                            /* all warnings issued */
 
-  if (!(name=my_strdup(log_name,MYF(MY_WME))))
-  {
-    name= (char *)log_name; // for the error message
-    goto err;
-  }
-  if (new_name)
-    strmov(log_file_name,new_name);
-  else if (generate_new_name(log_file_name, name))
-    goto err;
+  init(no_auto_events_arg, max_size_arg);
 
-  if (io_cache_type == SEQ_READ_APPEND)
-    open_flags |= O_RDWR | O_APPEND;
-  else
-    open_flags |= O_WRONLY | (log_type == LOG_BIN ? 0 : O_APPEND);
-
-  db[0]=0;
   open_count++;
-  if ((file=my_open(log_file_name,open_flags,
-		    MYF(MY_WME | ME_WAITTANG))) < 0 ||
-      init_io_cache(&log_file, file, IO_SIZE, io_cache_type,
-		    my_tell(file,MYF(MY_WME)), 0, 
-                    MYF(MY_WME | MY_NABP |
-                        ((log_type == LOG_BIN) ? MY_WAIT_IF_FULL : 0))))
-    goto err;
 
-  switch (log_type) {
-  case LOG_NORMAL:
-  {
-    char *end;
-    int len=my_snprintf(buff, sizeof(buff), "%s, Version: %s. "
-#ifdef EMBEDDED_LIBRARY
-		        "embedded library\n", my_progname, server_version
-#elif __NT__
-			"started with:\nTCP Port: %d, Named Pipe: %s\n",
-			my_progname, server_version, mysqld_port, mysqld_unix_port
-#else
-			"started with:\nTcp port: %d  Unix socket: %s\n",
-			my_progname,server_version,mysqld_port,mysqld_unix_port
-#endif
-                       );
-    end=strnmov(buff+len,"Time                 Id Command    Argument\n",
-                sizeof(buff)-len);
-    if (my_b_write(&log_file, (byte*) buff,(uint) (end-buff)) ||
-	flush_io_cache(&log_file))
-      goto err;
-    break;
-  }
-  case LOG_NEW:
-  {
-    uint len;
-    time_t skr=time(NULL);
-    struct tm tm_tmp;
-
-    localtime_r(&skr,&tm_tmp);
-    len= my_snprintf(buff,sizeof(buff),
-		     "# %s, Version: %s at %02d%02d%02d %2d:%02d:%02d\n",
-		     my_progname,server_version,
-		     tm_tmp.tm_year % 100,
-		     tm_tmp.tm_mon+1,
-		     tm_tmp.tm_mday,
-		     tm_tmp.tm_hour,
-		     tm_tmp.tm_min,
-		     tm_tmp.tm_sec);
-    if (my_b_write(&log_file, (byte*) buff, len) ||
-	flush_io_cache(&log_file))
-      goto err;
-    break;
-  }
-  case LOG_BIN:
+  DBUG_ASSERT(log_type == LOG_BIN);
+
   {
     bool write_file_name_to_index_file=0;
 
@@ -1700,13 +2095,9 @@
           my_sync(index_file.file, MYF(MY_WME)))
 	goto err;
     }
-    break;
-  }
-  case LOG_CLOSED:				// Impossible
-  case LOG_TO_BE_OPENED:
-    DBUG_ASSERT(1);
-    break;
   }
+  log_state= LOG_OPENED;
+
   DBUG_RETURN(0);
 
 err:
@@ -1719,12 +2110,12 @@
   end_io_cache(&log_file);
   end_io_cache(&index_file);
   safeFree(name);
-  log_type= LOG_CLOSED;
+  log_state= LOG_CLOSED;
   DBUG_RETURN(1);
 }
 
 
-int MYSQL_LOG::get_current_log(LOG_INFO* linfo)
+int MYSQL_BIN_LOG::get_current_log(LOG_INFO* linfo)
 {
   pthread_mutex_lock(&LOCK_log);
   strmake(linfo->log_file_name, log_file_name, sizeof(linfo->log_file_name)-1);
@@ -1811,7 +2202,7 @@
     LOG_INFO_IO		Got IO error while reading file
 */
 
-int MYSQL_LOG::find_log_pos(LOG_INFO *linfo, const char *log_name,
+int MYSQL_BIN_LOG::find_log_pos(LOG_INFO *linfo, const char *log_name,
 			    bool need_lock)
 {
   int error= 0;
@@ -1885,7 +2276,7 @@
     LOG_INFO_IO		Got IO error while reading file
 */
 
-int MYSQL_LOG::find_next_log(LOG_INFO* linfo, bool need_lock)
+int MYSQL_BIN_LOG::find_next_log(LOG_INFO* linfo, bool need_lock)
 {
   int error= 0;
   uint length;
@@ -1933,12 +2324,11 @@
     1   error
 */
 
-bool MYSQL_LOG::reset_logs(THD* thd)
+bool MYSQL_BIN_LOG::reset_logs(THD* thd)
 {
   LOG_INFO linfo;
   bool error=0;
   const char* save_name;
-  enum_log_type save_log_type;
   DBUG_ENTER("reset_logs");
 
   ha_reset_logs(thd);
@@ -1960,7 +2350,6 @@
   /* Save variables so that we can reopen the log */
   save_name=name;
   name=0;					// Protect against free
-  save_log_type=log_type;
   close(LOG_CLOSE_TO_BE_OPENED);
 
   /* First delete all old log files */
@@ -1984,8 +2373,7 @@
   if (!thd->slave_thread)
     need_start_event=1;
   if (!open_index_file(index_file_name, 0))
-    open(save_name, save_log_type, 0,
-         io_cache_type, no_auto_events, max_size, 0);
+    open(save_name, log_type, 0, io_cache_type, no_auto_events, max_size, 0);
   my_free((gptr) save_name, MYF(0));
 
 err:
@@ -2033,7 +2421,7 @@
 
 #ifdef HAVE_REPLICATION
 
-int MYSQL_LOG::purge_first_log(struct st_relay_log_info* rli, bool included) 
+int MYSQL_BIN_LOG::purge_first_log(struct st_relay_log_info* rli, bool included) 
 {
   int error;
   DBUG_ENTER("purge_first_log");
@@ -2109,7 +2497,7 @@
   Update log index_file
 */
 
-int MYSQL_LOG::update_log_index(LOG_INFO* log_info, bool need_update_threads)
+int MYSQL_BIN_LOG::update_log_index(LOG_INFO* log_info, bool need_update_threads)
 {
   if (copy_up_file_and_fill(&index_file, log_info->index_file_start_offset))
     return LOG_INFO_IO;
@@ -2142,7 +2530,7 @@
     LOG_INFO_EOF		to_log not found
 */
 
-int MYSQL_LOG::purge_logs(const char *to_log, 
+int MYSQL_BIN_LOG::purge_logs(const char *to_log, 
                           bool included,
                           bool need_mutex, 
                           bool need_update_threads, 
@@ -2228,7 +2616,7 @@
     LOG_INFO_PURGE_NO_ROTATE	Binary file that can't be rotated
 */
 
-int MYSQL_LOG::purge_logs_before_date(time_t purge_time)
+int MYSQL_BIN_LOG::purge_logs_before_date(time_t purge_time)
 {
   int error;
   LOG_INFO log_info;
@@ -2287,7 +2675,7 @@
     If file name will be longer then FN_REFLEN it will be truncated
 */
 
-void MYSQL_LOG::make_log_name(char* buf, const char* log_ident)
+void MYSQL_BIN_LOG::make_log_name(char* buf, const char* log_ident)
 {
   uint dir_len = dirname_length(log_file_name); 
   if (dir_len > FN_REFLEN)
@@ -2301,29 +2689,48 @@
   Check if we are writing/reading to the given log file
 */
 
-bool MYSQL_LOG::is_active(const char *log_file_name_arg)
+bool MYSQL_BIN_LOG::is_active(const char *log_file_name_arg)
 {
   return !strcmp(log_file_name, log_file_name_arg);
 }
 
 
 /*
+  Wrappers around new_file_impl to avoid using argument
+  to control locking. The argument 1) less readable 2) breaks
+  incapsulation 3) allows external access to the class without
+  a lock (which is not possible with private new_file_without_locking
+  method).
+*/
+
+void MYSQL_BIN_LOG::new_file()
+{
+  new_file_impl(1);
+}
+
+
+void MYSQL_BIN_LOG::new_file_without_locking()
+{
+  new_file_impl(0);
+}
+
+
+/*
   Start writing to a new log file or reopen the old file
 
   SYNOPSIS
-    new_file()
+    new_file_impl()
     need_lock		Set to 1 if caller has not locked LOCK_log
 
   NOTE
     The new file name is stored last in the index file
 */
 
-void MYSQL_LOG::new_file(bool need_lock)
+void MYSQL_BIN_LOG::new_file_impl(bool need_lock)
 {
   char new_name[FN_REFLEN], *new_name_ptr, *old_name;
-  enum_log_type save_log_type;
 
-  DBUG_ENTER("MYSQL_LOG::new_file");
+  DBUG_ENTER("MYSQL_BIN_LOG::new_file_impl");
   if (!is_open())
   {
     DBUG_PRINT("info",("log is closed"));
@@ -2389,12 +2796,11 @@
     signal_update();
   }
   old_name=name;
-  save_log_type=log_type;
   name=0;				// Don't free name
   close(LOG_CLOSE_TO_BE_OPENED);
 
   /*
-     Note that at this point, log_type != LOG_CLOSED (important for is_open()).
+     Note that at this point, log_state != LOG_CLOSED (important for is_open()).
   */
 
   /*
@@ -2406,7 +2812,7 @@
      trigger temp tables deletion on slaves.
   */
 
-  open(old_name, save_log_type, new_name_ptr,
+  open(old_name, log_type, new_name_ptr,
        io_cache_type, no_auto_events, max_size, 1);
   my_free(old_name,MYF(0));
 
@@ -2419,11 +2825,11 @@
 }
 
 
-bool MYSQL_LOG::append(Log_event* ev)
+bool MYSQL_BIN_LOG::append(Log_event* ev)
 {
   bool error = 0;
   pthread_mutex_lock(&LOCK_log);
-  DBUG_ENTER("MYSQL_LOG::append");
+  DBUG_ENTER("MYSQL_BIN_LOG::append");
 
   DBUG_ASSERT(log_file.type == SEQ_READ_APPEND);
   /*
@@ -2438,7 +2844,7 @@
   bytes_written+= ev->data_written;
   DBUG_PRINT("info",("max_size: %lu",max_size));
   if ((uint) my_b_append_tell(&log_file) > max_size)
-    new_file(0);
+    new_file_without_locking();
 
 err:
   pthread_mutex_unlock(&LOCK_log);
@@ -2447,10 +2853,10 @@
 }
 
 
-bool MYSQL_LOG::appendv(const char* buf, uint len,...)
+bool MYSQL_BIN_LOG::appendv(const char* buf, uint len,...)
 {
   bool error= 0;
-  DBUG_ENTER("MYSQL_LOG::appendv");
+  DBUG_ENTER("MYSQL_BIN_LOG::appendv");
   va_list(args);
   va_start(args,len);
 
@@ -2468,7 +2874,7 @@
   } while ((buf=va_arg(args,const char*)) && (len=va_arg(args,uint)));
   DBUG_PRINT("info",("max_size: %lu",max_size));
   if ((uint) my_b_append_tell(&log_file) > max_size)
-    new_file(0);
+    new_file_without_locking();
 
 err:
   if (!error)
@@ -2477,99 +2883,7 @@
 }
 
 
-/*
-  Write a command to traditional general log file
-
-  SYNOPSIS
-    write()
-
-    event_time        command start timestamp
-    user_host         the pointer to the string with user@host info
-    user_host_len     length of the user_host string. this is computed once
-                      and passed to all general log  event handlers
-    thread_id         Id of the thread, issued a query
-    command_type      the type of the command being logged
-    command_type_len  the length of the string above
-    sql_text          the very text of the query being executed
-    sql_text_len      the length of sql_text string
-
-  DESCRIPTION
-
-   Log given command to to normal (not rotable) log file
-
-  RETURN
-    FASE - OK
-    TRUE - error occured
-*/
-
-bool MYSQL_LOG::write(time_t event_time, const char *user_host,
-                      uint user_host_len, int thread_id,
-                      const char *command_type, uint command_type_len,
-                      const char *sql_text, uint sql_text_len)
-{
-  char buff[32];
-  uint length= 0;
-  char time_buff[MAX_TIME_SIZE];
-  struct tm start;
-  uint time_buff_len= 0;
-
-  /* Test if someone closed between the is_open test and lock */
-  if (is_open())
-  {
-    /* Note that my_b_write() assumes it knows the length for this */
-      if (event_time != last_time)
-      {
-        last_time= event_time;
-
-        localtime_r(&event_time, &start);
-
-        time_buff_len= my_snprintf(time_buff, MAX_TIME_SIZE,
-                                   "%02d%02d%02d %2d:%02d:%02d",
-                                   start.tm_year % 100, start.tm_mon + 1,
-                                   start.tm_mday, start.tm_hour,
-                                   start.tm_min, start.tm_sec);
-
-        if (my_b_write(&log_file, (byte*) &time_buff, time_buff_len))
-          goto err;
-      }
-      else
-        if (my_b_write(&log_file, (byte*) "\t\t" ,2) < 0)
-          goto err;
-
-    /* command_type, thread_id */
-    length= my_snprintf(buff, 32, "%5ld ", thread_id);
-
-    if (my_b_write(&log_file, (byte*) buff, length))
-      goto err;
-
-    if (my_b_write(&log_file, (byte*) command_type, command_type_len))
-      goto err;
-
-    if (my_b_write(&log_file, (byte*) "\t", 1))
-      goto err;
-
-    /* sql_text */
-    if (my_b_write(&log_file, (byte*) sql_text, sql_text_len))
-      goto err;
-
-    if (my_b_write(&log_file, (byte*) "\n", 1) ||
-        flush_io_cache(&log_file))
-      goto err;
-  }
-
-  return FALSE;
-err:
-
-  if (!write_error)
-  {
-    write_error= 1;
-    sql_print_error(ER(ER_ERROR_ON_WRITE), name, errno);
-  }
-  return TRUE;
-}
-
-
-bool MYSQL_LOG::flush_and_sync()
+bool MYSQL_BIN_LOG::flush_and_sync()
 {
   int err=0, fd=log_file.file;
   safe_mutex_assert_owner(&LOCK_log);
@@ -2583,7 +2897,7 @@
   return err;
 }
 
-void MYSQL_LOG::start_union_events(THD *thd)
+void MYSQL_BIN_LOG::start_union_events(THD *thd)
 {
   DBUG_ASSERT(!thd->binlog_evt_union.do_union);
   thd->binlog_evt_union.do_union= TRUE;
@@ -2592,13 +2906,13 @@
   thd->binlog_evt_union.first_query_id= thd->query_id;
 }
 
-void MYSQL_LOG::stop_union_events(THD *thd)
+void MYSQL_BIN_LOG::stop_union_events(THD *thd)
 {
   DBUG_ASSERT(thd->binlog_evt_union.do_union);
   thd->binlog_evt_union.do_union= FALSE;
 }
 
-bool MYSQL_LOG::is_query_in_union(THD *thd, query_id_t query_id_param)
+bool MYSQL_BIN_LOG::is_query_in_union(THD *thd, query_id_t query_id_param)
 {
   return (thd->binlog_evt_union.do_union && 
           query_id_param >= thd->binlog_evt_union.first_query_id);
@@ -2705,9 +3019,10 @@
   (either cached binlog if transaction, or disk binlog). Sets a new pending
   event.
 */
-int MYSQL_LOG::flush_and_set_pending_rows_event(THD *thd, Rows_log_event* event)
+int MYSQL_BIN_LOG::
+  flush_and_set_pending_rows_event(THD *thd, Rows_log_event* event)
 {
-  DBUG_ENTER("MYSQL_LOG::flush_and_set_pending_rows_event(event)");
+  DBUG_ENTER("MYSQL_BIN_LOG::flush_and_set_pending_rows_event(event)");
   DBUG_ASSERT(thd->current_stmt_binlog_row_based && mysql_bin_log.is_open());
   DBUG_PRINT("enter", ("event=%p", event));
 
@@ -2791,11 +3106,11 @@
   Write an event to the binary log
 */
 
-bool MYSQL_LOG::write(Log_event *event_info)
+bool MYSQL_BIN_LOG::write(Log_event *event_info)
 {
   THD *thd= event_info->thd;
   bool error= 1;
-  DBUG_ENTER("MYSQL_LOG::write(Log_event *)");
+  DBUG_ENTER("MYSQL_BIN_LOG::write(Log_event *)");
 
   if (thd->binlog_evt_union.do_union)
   {
@@ -3015,14 +3330,14 @@
   return error;
 }
 
-void MYSQL_LOG::rotate_and_purge(uint flags)
+void MYSQL_BIN_LOG::rotate_and_purge(uint flags)
 {
   if (!(flags & RP_LOCK_LOG_IS_ALREADY_LOCKED))
     pthread_mutex_lock(&LOCK_log);
   if ((flags & RP_FORCE_ROTATE) ||
       (my_b_tell(&log_file) >= (my_off_t) max_size))
   {
-    new_file(0);
+    new_file_without_locking();
 #ifdef HAVE_REPLICATION
     if (expire_logs_days)
     {
@@ -3036,7 +3351,7 @@
     pthread_mutex_unlock(&LOCK_log);
 }
 
-uint MYSQL_LOG::next_file_id()
+uint MYSQL_BIN_LOG::next_file_id()
 {
   uint res;
   pthread_mutex_lock(&LOCK_log);
@@ -3067,9 +3382,9 @@
       that the same updates are run on the slave.
 */
 
-bool MYSQL_LOG::write(THD *thd, IO_CACHE *cache, Log_event *commit_event)
+bool MYSQL_BIN_LOG::write(THD *thd, IO_CACHE *cache, Log_event *commit_event)
 {
-  DBUG_ENTER("MYSQL_LOG::write(THD *, IO_CACHE *, Log_event *)");
+  DBUG_ENTER("MYSQL_BIN_LOG::write(THD *, IO_CACHE *, Log_event *)");
   VOID(pthread_mutex_lock(&LOCK_log));
 
   if (likely(is_open()))                       // Should always be true
@@ -3165,148 +3480,6 @@
 
 
 /*
-  Log a query to the traditional slow log file
-
-  SYNOPSIS
-    write()
-
-    thd               THD of the query
-    current_time      current timestamp
-    query_start_arg   command start timestamp
-    user_host         the pointer to the string with user@host info
-    user_host_len     length of the user_host string. this is computed once
-                      and passed to all general log event handlers
-    query_time        Amount of time the query took to execute (in seconds)
-    lock_time         Amount of time the query was locked (in seconds)
-    is_command        The flag, which determines, whether the sql_text is a
-                      query or an administrator command.
-    sql_text          the very text of the query or administrator command
-                      processed
-    sql_text_len      the length of sql_text string
-
-  DESCRIPTION
-
-   Log a query to the slow log file.
-
-  RETURN
-    FALSE - OK
-    TRUE - error occured
-*/
-
-bool MYSQL_LOG::write(THD *thd, time_t current_time, time_t query_start_arg,
-                      const char *user_host, uint user_host_len,
-                      longlong query_time, longlong lock_time, bool is_command,
-                      const char *sql_text, uint sql_text_len)
-{
-  bool error= 0;
-  DBUG_ENTER("MYSQL_LOG::write");
-
-  if (!is_open())
-    DBUG_RETURN(0);
-
-  if (is_open())
-  {						// Safety agains reopen
-    int tmp_errno= 0;
-    char buff[80], *end;
-    uint buff_len;
-    end= buff;
-
-    if (!(specialflag & SPECIAL_SHORT_LOG_FORMAT))
-    {
-      Security_context *sctx= thd->security_ctx;
-      if (current_time != last_time)
-      {
-        last_time= current_time;
-        struct tm start;
-        localtime_r(&current_time, &start);
-
-        buff_len= my_snprintf(buff, sizeof buff,
-                              "# Time: %02d%02d%02d %2d:%02d:%02d\n",
-                              start.tm_year % 100, start.tm_mon + 1,
-                              start.tm_mday, start.tm_hour,
-                              start.tm_min, start.tm_sec);
-
-        /* Note that my_b_write() assumes it knows the length for this */
-        if (my_b_write(&log_file, (byte*) buff, buff_len))
-          tmp_errno=errno;
-      }
-      if (my_b_printf(&log_file, "# User@Host: ", sizeof("# User@Host: ") - 1))
-        tmp_errno=errno;
-      if (my_b_printf(&log_file, user_host, user_host_len))
-        tmp_errno=errno;
-      if (my_b_write(&log_file, (byte*) "\n", 1))
-        tmp_errno=errno;
-    }
-    /* For slow query log */
-    if (my_b_printf(&log_file,
-                    "# Query_time: %lu  Lock_time: %lu"
-                    " Rows_sent: %lu  Rows_examined: %lu\n",
-                    (ulong) query_time, (ulong) lock_time,
-                    (ulong) thd->sent_row_count,
-                    (ulong) thd->examined_row_count) == (uint) -1)
-      tmp_errno=errno;
-    if (thd->db && strcmp(thd->db,db))
-    {						// Database changed
-      if (my_b_printf(&log_file,"use %s;\n",thd->db) == (uint) -1)
-        tmp_errno=errno;
-      strmov(db,thd->db);
-    }
-    if (thd->last_insert_id_used)
-    {
-      end=strmov(end,",last_insert_id=");
-      end=longlong10_to_str((longlong) thd->current_insert_id,end,-10);
-    }
-    // Save value if we do an insert.
-    if (thd->insert_id_used)
-    {
-      if (!(specialflag & SPECIAL_SHORT_LOG_FORMAT))
-      {
-        end=strmov(end,",insert_id=");
-        end=longlong10_to_str((longlong) thd->last_insert_id,end,-10);
-      }
-    }
-
-    /*
-      This info used to show up randomly, depending on whether the query
-      checked the query start time or not. now we always write current
-      timestamp to the slow log
-    */
-    end= strmov(end, ",timestamp=");
-    end= int10_to_str((long) current_time, end, 10);
-
-    if (end != buff)
-    {
-      *end++=';';
-      *end='\n';
-      if (my_b_write(&log_file, (byte*) "SET ",4) ||
-          my_b_write(&log_file, (byte*) buff+1,(uint) (end-buff)))
-        tmp_errno=errno;
-    }
-    if (is_command)
-    {
-      end= strxmov(buff, "# administrator command: ", NullS);
-      buff_len= (ulong) (end - buff);
-      my_b_write(&log_file, (byte*) buff, buff_len);
-    }
-    if (my_b_write(&log_file, (byte*) sql_text, sql_text_len) ||
-        my_b_write(&log_file, (byte*) ";\n",2) ||
-        flush_io_cache(&log_file))
-      tmp_errno=errno;
-    if (tmp_errno)
-    {
-      error=1;
-      if (! write_error)
-      {
-        write_error=1;
-        sql_print_error(ER(ER_ERROR_ON_WRITE),name,error);
-      }
-    }
-  }
-  DBUG_RETURN(error);
-}
-
-
-/*
   Wait until we get a signal that the binary log has been updated
 
   SYNOPSIS
@@ -3322,7 +3495,7 @@
     THD::enter_cond() (see NOTES in sql_class.h).
 */
 
-void MYSQL_LOG::wait_for_update(THD* thd, bool is_slave)
+void MYSQL_BIN_LOG::wait_for_update(THD* thd, bool is_slave)
 {
   const char *old_msg;
   DBUG_ENTER("wait_for_update");
@@ -3355,11 +3528,11 @@
     The internal structures are not freed until cleanup() is called
 */
 
-void MYSQL_LOG::close(uint exiting)
+void MYSQL_BIN_LOG::close(uint exiting)
 {					// One can't set log_type here!
-  DBUG_ENTER("MYSQL_LOG::close");
+  DBUG_ENTER("MYSQL_BIN_LOG::close");
   DBUG_PRINT("enter",("exiting: %d", (int) exiting));
-  if (log_type != LOG_CLOSED && log_type != LOG_TO_BE_OPENED)
+  if (log_state == LOG_OPENED)
   {
 #ifdef HAVE_REPLICATION
     if (log_type == LOG_BIN && !no_auto_events &&
@@ -3371,7 +3544,6 @@
       signal_update();
     }
 #endif /* HAVE_REPLICATION */
-    end_io_cache(&log_file);
 
     /* don't pwrite in a file opened with O_APPEND - it doesn't work */
     if (log_file.type == WRITE_CACHE && log_type == LOG_BIN)
@@ -3381,16 +3553,8 @@
       my_pwrite(log_file.file, &flags, 1, offset, MYF(0));
     }
 
-    if (my_sync(log_file.file,MYF(MY_WME)) && ! write_error)
-    {
-      write_error=1;
-      sql_print_error(ER(ER_ERROR_ON_WRITE), name, errno);
-    }
-    if (my_close(log_file.file,MYF(MY_WME)) && ! write_error)
-    {
-      write_error=1;
-      sql_print_error(ER(ER_ERROR_ON_WRITE), name, errno);
-    }
+    /* this will cleanup IO_CACHE, sync and close the file */
+    MYSQL_LOG::close(exiting);
   }
 
   /*
@@ -3407,13 +3571,13 @@
       sql_print_error(ER(ER_ERROR_ON_WRITE), index_file_name, errno);
     }
   }
-  log_type= (exiting & LOG_CLOSE_TO_BE_OPENED) ? LOG_TO_BE_OPENED : LOG_CLOSED;
+  log_state= (exiting & LOG_CLOSE_TO_BE_OPENED) ? LOG_TO_BE_OPENED : LOG_CLOSED;
   safeFree(name);
   DBUG_VOID_RETURN;
 }
 
 
-void MYSQL_LOG::set_max_size(ulong max_size_arg)
+void MYSQL_BIN_LOG::set_max_size(ulong max_size_arg)
 {
   /*
     We need to take locks, otherwise this may happen:
@@ -3422,7 +3586,7 @@
     uses the old_max_size argument, so max_size_arg has been overwritten and
     it's like if the SET command was never run.
   */
-  DBUG_ENTER("MYSQL_LOG::set_max_size");
+  DBUG_ENTER("MYSQL_BIN_LOG::set_max_size");
   pthread_mutex_lock(&LOCK_log);
   if (is_open())
     max_size= max_size_arg;
@@ -3571,9 +3735,9 @@
    return result;
 }
 
-void MYSQL_LOG::signal_update()
+void MYSQL_BIN_LOG::signal_update()
 {
-  DBUG_ENTER("MYSQL_LOG::signal_update");
+  DBUG_ENTER("MYSQL_BIN_LOG::signal_update");
   pthread_cond_broadcast(&update_cond);
   DBUG_VOID_RETURN;
 }
@@ -4176,7 +4340,7 @@
 }
 
 /****** transaction coordinator log for 2pc - binlog() based solution ******/
-#define TC_LOG_BINLOG MYSQL_LOG
+#define TC_LOG_BINLOG MYSQL_BIN_LOG
 
 /*
   TODO keep in-memory list of prepared transactions

--- 1.134/sql/log_event.h	2006-05-05 10:45:53 +04:00
+++ 1.135/sql/log_event.h	2006-06-15 15:38:08 +04:00
@@ -1221,9 +1221,6 @@
   bool write(IO_CACHE* file);
 #endif
   bool is_valid() const { return 1; }
-#if !defined(DBUG_OFF) && !defined(MYSQL_CLIENT)
-  static my_bool show_xid;
-#endif
 };
 
 /*****************************************************************************
@@ -1635,6 +1632,8 @@
 #endif
 char *str_to_hex(char *to, const char *from, uint len);
 
+#ifdef HAVE_ROW_BASED_REPLICATION
+
 /*****************************************************************************
 
   Table map log event class
@@ -1643,7 +1642,6 @@
   identifier (an integer number).
 
  ****************************************************************************/
-
 class Table_map_log_event : public Log_event
 {
 public:
@@ -1750,6 +1748,7 @@
 
  ****************************************************************************/
 
+
 class Rows_log_event : public Log_event
 {
 public:
@@ -2121,5 +2120,6 @@
 #endif
 };
 
+#endif /* HAVE_ROW_BASED_REPLICATION */
 
 #endif /* _log_event_h */

--- 1.409/sql/mysql_priv.h	2006-06-13 01:43:30 +04:00
+++ 1.410/sql/mysql_priv.h	2006-06-15 15:38:08 +04:00
@@ -1537,7 +1537,7 @@
 extern my_bool opt_large_pages;
 extern uint opt_large_page_size;
 
-extern MYSQL_LOG mysql_bin_log;
+extern MYSQL_BIN_LOG mysql_bin_log;
 extern LOGGER logger;
 extern TABLE_LIST general_log, slow_log;
 extern FILE *bootstrap_file;

--- 1.558/sql/mysqld.cc	2006-06-15 13:58:23 +04:00
+++ 1.559/sql/mysqld.cc	2006-06-15 15:38:09 +04:00
@@ -2635,10 +2635,10 @@
   global_system_variables.time_zone= my_tz_SYSTEM;
   
   /*
-    Init mutexes for the global MYSQL_LOG objects.
+    Init mutexes for the global MYSQL_BIN_LOG objects.
     As safe_mutex depends on what MY_INIT() does, we can't init the mutexes of
-    global MYSQL_LOGs in their constructors, because then they would be inited
-    before MY_INIT(). So we do it here.
+    global MYSQL_BIN_LOGs in their constructors, because then they would be
+    inited before MY_INIT(). So we do it here.
   */
   mysql_bin_log.init_pthread_objects();
 

--- 1.272/sql/slave.cc	2006-06-07 23:58:01 +04:00
+++ 1.273/sql/slave.cc	2006-06-15 15:38:09 +04:00
@@ -95,6 +95,8 @@
 {
   bool set_io = mi->slave_running, set_sql = mi->rli.slave_running;
   register int tmp_mask=0;
+  DBUG_ENTER("init_thread_mask");
+
   if (set_io)
     tmp_mask |= SLAVE_IO;
   if (set_sql)
@@ -102,6 +104,7 @@
   if (inverse)
     tmp_mask^= (SLAVE_IO | SLAVE_SQL);
   *mask = tmp_mask;
+  DBUG_VOID_RETURN;
 }
 
 
@@ -111,9 +114,12 @@
 
 void lock_slave_threads(MASTER_INFO* mi)
 {
+  DBUG_ENTER("lock_slave_threads");
+
   //TODO: see if we can do this without dual mutex
   pthread_mutex_lock(&mi->run_lock);
   pthread_mutex_lock(&mi->rli.run_lock);
+  DBUG_VOID_RETURN;
 }
 
 
@@ -123,9 +129,12 @@
 
 void unlock_slave_threads(MASTER_INFO* mi)
 {
+  DBUG_ENTER("unlock_slave_threads");
+
   //TODO: see if we can do this without dual mutex
   pthread_mutex_unlock(&mi->rli.run_lock);
   pthread_mutex_unlock(&mi->run_lock);
+  DBUG_VOID_RETURN;
 }
 
 
@@ -423,6 +432,8 @@
 void init_slave_skip_errors(const char* arg)
 {
   const char *p;
+  DBUG_ENTER("init_slave_skip_errors");
+
   if (bitmap_init(&slave_error_mask,0,MAX_SLAVE_ERROR,0))
   {
     fprintf(stderr, "Badly out of memory, please check your system status\n");
@@ -434,7 +445,7 @@
   if (!my_strnncoll(system_charset_info,(uchar*)arg,4,(const uchar*)"all",4))
   {
     bitmap_set_all(&slave_error_mask);
-    return;
+    DBUG_VOID_RETURN;
   }
   for (p= arg ; *p; )
   {
@@ -446,12 +457,15 @@
     while (!my_isdigit(system_charset_info,*p) && *p)
       p++;
   }
+  DBUG_VOID_RETURN;
 }
 
 
 void st_relay_log_info::inc_group_relay_log_pos(ulonglong log_pos,
 						bool skip_lock)  
 {
+  DBUG_ENTER("st_relay_log_info::inc_group_relay_log_pos");
+
   if (!skip_lock)
     pthread_mutex_lock(&data_lock);
   inc_event_relay_log_pos();
@@ -500,12 +514,14 @@
   pthread_cond_broadcast(&data_cond);
   if (!skip_lock)
     pthread_mutex_unlock(&data_lock);
+  DBUG_VOID_RETURN;
 }
 
 
 void st_relay_log_info::close_temporary_tables()
 {
   TABLE *table,*next;
+  DBUG_ENTER("st_relay_log_info::close_temporary_tables");
 
   for (table=save_temporary_tables ; table ; table=next)
   {
@@ -514,10 +530,12 @@
       Don't ask for disk deletion. For now, anyway they will be deleted when
       slave restarts, but it is a better intention to not delete them.
     */
+    DBUG_PRINT("info", ("table: %p", table));
     close_temporary(table, 1, 0);
   }
   save_temporary_tables= 0;
   slave_open_temp_tables= 0;
+  DBUG_VOID_RETURN;
 }
 
 /*
@@ -613,12 +631,13 @@
 
 int terminate_slave_threads(MASTER_INFO* mi,int thread_mask,bool skip_lock)
 {
+  DBUG_ENTER("terminate_slave_threads");
+
   if (!mi->inited)
-    return 0; /* successfully do nothing */
+    DBUG_RETURN(0); /* successfully do nothing */
   int error,force_all = (thread_mask & SLAVE_FORCE_ALL);
   pthread_mutex_t *sql_lock = &mi->rli.run_lock, *io_lock = &mi->run_lock;
   pthread_mutex_t *sql_cond_lock,*io_cond_lock;
-  DBUG_ENTER("terminate_slave_threads");
 
   sql_cond_lock=sql_lock;
   io_cond_lock=io_lock;
@@ -704,9 +723,10 @@
 {
   pthread_t th;
   ulong start_id;
-  DBUG_ASSERT(mi->inited);
   DBUG_ENTER("start_slave_thread");
 
+  DBUG_ASSERT(mi->inited);
+
   if (start_lock)
     pthread_mutex_lock(start_lock);
   if (!server_id)
@@ -810,8 +830,10 @@
 #ifdef NOT_USED_YET
 static int end_slave_on_walk(MASTER_INFO* mi, gptr /*unused*/)
 {
+  DBUG_ENTER("end_slave_on_walk");
+
   end_master_info(mi);
-  return 0;
+  DBUG_RETURN(0);
 }
 #endif
 
@@ -825,6 +847,8 @@
 
 void end_slave()
 {
+  DBUG_ENTER("end_slave");
+
   /*
     This is called when the server terminates, in close_connections().
     It terminates slave threads. However, some CHANGE MASTER etc may still be
@@ -846,19 +870,24 @@
     active_mi= 0;
   }
   pthread_mutex_unlock(&LOCK_active_mi);
+  DBUG_VOID_RETURN;
 }
 
 
 static bool io_slave_killed(THD* thd, MASTER_INFO* mi)
 {
+  DBUG_ENTER("io_slave_killed");
+
   DBUG_ASSERT(mi->io_thd == thd);
   DBUG_ASSERT(mi->slave_running); // tracking buffer overrun
-  return mi->abort_slave || abort_loop || thd->killed;
+  DBUG_RETURN(mi->abort_slave || abort_loop || thd->killed);
 }
 
 
 static bool sql_slave_killed(THD* thd, RELAY_LOG_INFO* rli)
 {
+  DBUG_ENTER("sql_slave_killed");
+
   DBUG_ASSERT(rli->sql_thd == thd);
   DBUG_ASSERT(rli->slave_running == 1);// tracking buffer overrun
   if (abort_loop || thd->killed || rli->abort_slave)
@@ -873,7 +902,7 @@
       is actively working.
     */
     if (!rli->unsafe_to_stop_at)
-      return 1;
+      DBUG_RETURN(1);
     DBUG_PRINT("info", ("Slave SQL thread is in an unsafe situation, giving "
                         "it some grace period"));
     if (difftime(time(0), rli->unsafe_to_stop_at) > 60)
@@ -885,10 +914,10 @@
                       "There is a risk of duplicate updates when the slave "
                       "SQL thread is restarted. Please check your tables' "
                       "contents after restart.");
-      return 1;
+      DBUG_RETURN(1);
     }
   }
-  return 0;
+  DBUG_RETURN(0);
 }
 
 
@@ -917,6 +946,8 @@
   char buff[MAX_SLAVE_ERRMSG], *pbuff= buff;
   uint pbuffsize= sizeof(buff);
   va_list args;
+  DBUG_ENTER("slave_print_msg");
+
   va_start(args,msg);
   switch (level)
   {
@@ -943,7 +974,7 @@
     break;
   default:
     DBUG_ASSERT(0); // should not come here
-    return; // don't crash production builds, just do nothing
+    DBUG_VOID_RETURN; // don't crash production builds, just do nothing
   }
   my_vsnprintf(pbuff, pbuffsize, msg, args);
   /* If the msg string ends with '.', do not add a ',' it would be ugly */
@@ -951,6 +982,7 @@
     (*report_function)("Slave: %s Error_code: %d", pbuff, err_code);
   else
     (*report_function)("Slave: %s, Error_code: %d", pbuff, err_code);
+  DBUG_VOID_RETURN;
 }
 
 /*
@@ -962,9 +994,12 @@
 
 void skip_load_data_infile(NET *net)
 {
+  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
+  DBUG_VOID_RETURN;
 }
 
 
@@ -983,13 +1018,17 @@
 
 const char *print_slave_db_safe(const char* db)
 {
-  return (db ? db : "");
+  DBUG_ENTER("*print_slave_db_safe");
+
+  DBUG_RETURN((db ? db : ""));
 }
 
 static int init_strvar_from_file(char *var, int max_size, IO_CACHE *f,
 				 const char *default_val)
 {
   uint length;
+  DBUG_ENTER("init_strvar_from_file");
+
   if ((length=my_b_gets(f,var, max_size)))
   {
     char* last_p = var + length -1;
@@ -1004,32 +1043,34 @@
       int c;
       while (((c=my_b_get(f)) != '\n' && c != my_b_EOF));
     }
-    return 0;
+    DBUG_RETURN(0);
   }
   else if (default_val)
   {
     strmake(var,  default_val, max_size-1);
-    return 0;
+    DBUG_RETURN(0);
   }
-  return 1;
+  DBUG_RETURN(1);
 }
 
 
 static int init_intvar_from_file(int* var, IO_CACHE* f, int default_val)
 {
   char buf[32];
+  DBUG_ENTER("init_intvar_from_file");
+
   
   if (my_b_gets(f, buf, sizeof(buf))) 
   {
     *var = atoi(buf);
-    return 0;
+    DBUG_RETURN(0);
   }
   else if (default_val)
   {
     *var = default_val;
-    return 0;
+    DBUG_RETURN(0);
   }
-  return 1;
+  DBUG_RETURN(1);
 }
 
 /*
@@ -1049,6 +1090,7 @@
 static int get_master_version_and_clock(MYSQL* mysql, MASTER_INFO* mi)
 {
   const char* errmsg= 0;
+  DBUG_ENTER("get_master_version_and_clock");
 
   /*
     Free old description_event_for_queue (that is needed if we are in
@@ -1104,14 +1146,14 @@
   if (errmsg)
   {
     sql_print_error(errmsg);
-    return 1;
+    DBUG_RETURN(1);
   }
 
   /* as we are here, we tried to allocate the event */
   if (!mi->rli.relay_log.description_event_for_queue)
   {
     sql_print_error("Slave I/O thread failed to create a default Format_description_log_event");
-    return 1;
+    DBUG_RETURN(1);
   }
 
   /*
@@ -1227,10 +1269,10 @@
   if (errmsg)
   {
     sql_print_error(errmsg);
-    return 1;
+    DBUG_RETURN(1);
   }
 
-  return 0;
+  DBUG_RETURN(0);
 }
 
 /*
@@ -1257,7 +1299,7 @@
   handler *file;
   ulong save_options;
   NET *net= &mysql->net;
-  DBUG_ENTER("create_table_from_dump");  
+  DBUG_ENTER("create_table_from_dump");
 
   packet_len= my_net_read(net); // read create table statement
   if (packet_len == packet_error)
@@ -1666,7 +1708,6 @@
   MASTER_INFO* mi = rli->mi;
   const char *save_proc_info;
   THD* thd = mi->io_thd;
-
   DBUG_ENTER("wait_for_relay_log_space");
 
   pthread_mutex_lock(&rli->log_space_lock);
@@ -1725,6 +1766,8 @@
 {
   RELAY_LOG_INFO *rli= &mi->rli;
   pthread_mutex_t *log_lock= rli->relay_log.get_log_lock();
+  DBUG_ENTER("write_ignored_events_info_to_relay_log");
+
   DBUG_ASSERT(thd == mi->io_thd);
   pthread_mutex_lock(log_lock);
   if (rli->ign_master_log_name_end[0])
@@ -1755,11 +1798,14 @@
   }
   else
     pthread_mutex_unlock(log_lock);
+  DBUG_VOID_RETURN;
 }
 
 
 void init_master_info_with_options(MASTER_INFO* mi)
 {
+  DBUG_ENTER("init_master_info_with_options");
+
   mi->master_log_name[0] = 0;
   mi->master_log_pos = BIN_LOG_HEADER_SIZE;		// skip magic number
   
@@ -1783,13 +1829,17 @@
     strmake(mi->ssl_cipher, master_ssl_cipher, sizeof(mi->ssl_cipher)-1);
   if (master_ssl_key)
     strmake(mi->ssl_key, master_ssl_key, sizeof(mi->ssl_key)-1);
+  DBUG_VOID_RETURN;
 }
 
 void clear_slave_error(RELAY_LOG_INFO* rli)
 {
+  DBUG_ENTER("clear_slave_error");
+
   /* Clear the errors displayed by SHOW SLAVE STATUS */
   rli->last_slave_error[0]= 0;
   rli->last_slave_errno= 0;
+  DBUG_VOID_RETURN;
 }
 
 /*
@@ -1800,9 +1850,12 @@
  */
 void clear_until_condition(RELAY_LOG_INFO* rli)
 {
+  DBUG_ENTER("clear_until_condition");
+
   rli->until_condition= RELAY_LOG_INFO::UNTIL_NONE;
   rli->until_log_name[0]= 0;
   rli->until_log_pos= 0;
+  DBUG_VOID_RETURN;
 }
 
 
@@ -2031,9 +2084,10 @@
 {
   char buf[1024], *pos= buf;
   uint report_host_len, report_user_len=0, report_password_len=0;
+  DBUG_ENTER("register_slave_on_master");
 
   if (!report_host)
-    return 0;
+    DBUG_RETURN(0);
   report_host_len= strlen(report_host);
   if (report_user)
     report_user_len= strlen(report_user);
@@ -2042,7 +2096,7 @@
   /* 30 is a good safety margin */
   if (report_host_len + report_user_len + report_password_len + 30 >
       sizeof(buf))
-    return 0;					// safety
+    DBUG_RETURN(0);					// safety
 
   int4store(pos, server_id); pos+= 4;
   pos= net_store_data(pos, report_host, report_host_len); 
@@ -2059,9 +2113,9 @@
     sql_print_error("Error on COM_REGISTER_SLAVE: %d '%s'",
 		    mysql_errno(mysql),
 		    mysql_error(mysql));
-    return 1;
+    DBUG_RETURN(1);
   }
-  return 0;
+  DBUG_RETURN(0);
 }
 
 
@@ -2313,6 +2367,8 @@
    m_reload_flags(RELOAD_NONE_F),
    unsafe_to_stop_at(0)
 {
+  DBUG_ENTER("st_relay_log_info::st_relay_log_info");
+
   group_relay_log_name[0]= event_relay_log_name[0]=
     group_master_log_name[0]= 0;
   last_slave_error[0]= until_log_name[0]= ign_master_log_name_end[0]= 0;
@@ -2327,11 +2383,14 @@
   pthread_cond_init(&stop_cond, NULL);
   pthread_cond_init(&log_space_cond, NULL);
   relay_log.init_pthread_objects();
+  DBUG_VOID_RETURN;
 }
 
 
 st_relay_log_info::~st_relay_log_info()
 {
+  DBUG_ENTER("st_relay_log_info::~st_relay_log_info");
+
   pthread_mutex_destroy(&run_lock);
   pthread_mutex_destroy(&data_lock);
   pthread_mutex_destroy(&log_space_lock);
@@ -2340,6 +2399,7 @@
   pthread_cond_destroy(&stop_cond);
   pthread_cond_destroy(&log_space_cond);
   relay_log.cleanup();
+  DBUG_VOID_RETURN;
 }
 
 /*
@@ -2371,14 +2431,16 @@
                                     longlong log_pos,
                                     longlong timeout)
 {
-  if (!inited)
-    return -1;
   int event_count = 0;
   ulong init_abort_pos_wait;
   int error=0;
   struct timespec abstime; // for timeout checking
   const char *msg;
-  DBUG_ENTER("wait_for_pos");
+  DBUG_ENTER("st_relay_log_info::wait_for_pos");
+
+  if (!inited)
+    DBUG_RETURN(-1);
+
   DBUG_PRINT("enter",("log_name: '%s'  log_pos: %lu  timeout: %lu",
                       log_name->c_ptr(), (ulong) log_pos, (ulong) timeout));
 
@@ -2546,13 +2608,18 @@
 
 void set_slave_thread_options(THD* thd)
 {
+  DBUG_ENTER("set_slave_thread_options");
+
   thd->options = ((opt_log_slave_updates) ? OPTION_BIN_LOG:0) |
     OPTION_AUTO_IS_NULL;
   thd->variables.completion_type= 0;
+  DBUG_VOID_RETURN;
 }
 
 void set_slave_thread_default_charset(THD* thd, RELAY_LOG_INFO *rli)
 {
+  DBUG_ENTER("set_slave_thread_default_charset");
+
   thd->variables.character_set_client=
     global_system_variables.character_set_client;
   thd->variables.collation_connection=
@@ -2561,6 +2628,7 @@
     global_system_variables.collation_server;
   thd->update_charset();
   rli->cached_charset_invalidate();
+  DBUG_VOID_RETURN;
 }
 
 /*
@@ -2622,6 +2690,8 @@
 {
   int nap_time;
   thr_alarm_t alarmed;
+  DBUG_ENTER("safe_sleep");
+
   thr_alarm_init(&alarmed);
   time_t start_time= time((time_t*) 0);
   time_t end_time= start_time+sec;
@@ -2639,10 +2709,10 @@
     thr_end_alarm(&alarmed);
     
     if ((*thread_killed)(thd,thread_killed_arg))
-      return 1;
+      DBUG_RETURN(1);
     start_time=time((time_t*) 0);
   }
-  return 0;
+  DBUG_RETURN(0);
 }
 
 
@@ -2684,13 +2754,15 @@
 static int request_table_dump(MYSQL* mysql, const char* db, const char* table)
 {
   char buf[1024];
+  DBUG_ENTER("request_table_dump");
+
   char * p = buf;
   uint table_len = (uint) strlen(table);
   uint db_len = (uint) strlen(db);
   if (table_len + db_len > sizeof(buf) - 2)
   {
     sql_print_error("request_table_dump: Buffer overrun");
-    return 1;
+    DBUG_RETURN(1);
   } 
   
   *p++ = db_len;
@@ -2703,10 +2775,10 @@
   {
     sql_print_error("request_table_dump: Error sending the table dump \
 command");
-    return 1;
+    DBUG_RETURN(1);
   }
 
-  return 0;
+  DBUG_RETURN(0);
 }
 
 
@@ -2730,6 +2802,7 @@
 static ulong read_event(MYSQL* mysql, MASTER_INFO *mi, bool* suppress_warnings)
 {
   ulong len;
+  DBUG_ENTER("read_event");
 
   *suppress_warnings= 0;
   /*
@@ -2738,7 +2811,7 @@
   */
 #ifndef DBUG_OFF
   if (disconnect_slave_event_count && !(mi->events_till_disconnect--))
-    return packet_error;      
+    DBUG_RETURN(packet_error);      
 #endif
   
   len = net_safe_read(mysql);
@@ -2756,7 +2829,7 @@
     else
       sql_print_error("Error reading packet from server: %s ( server_errno=%d)",
 		      mysql_error(mysql), mysql_errno(mysql));
-    return packet_error;
+    DBUG_RETURN(packet_error);
   }
 
   /* Check if eof packet */
@@ -2765,25 +2838,27 @@
     sql_print_information("Slave: received end packet from server, apparent "
                           "master shutdown: %s",
 		     mysql_error(mysql));
-     return packet_error;
+     DBUG_RETURN(packet_error);
   }
   
   DBUG_PRINT("info",( "len=%u, net->read_pos[4] = %d\n",
 		      len, mysql->net.read_pos[4]));
-  return len - 1;   
+  DBUG_RETURN(len - 1);   
 }
 
 
 int check_expected_error(THD* thd, RELAY_LOG_INFO* rli, int expected_error)
 {
+  DBUG_ENTER("check_expected_error");
+
   switch (expected_error) {
   case ER_NET_READ_ERROR:
   case ER_NET_ERROR_ON_WRITE:  
   case ER_SERVER_SHUTDOWN:  
   case ER_NEW_ABORTING_CONNECTION:
-    return 1;
+    DBUG_RETURN(1);
   default:
-    return 0;
+    DBUG_RETURN(0);
   }
 }
 
@@ -2819,6 +2894,7 @@
 {
   const char *log_name;
   ulonglong log_pos;
+  DBUG_ENTER("st_relay_log_info::is_until_satisfied");
 
   DBUG_ASSERT(until_condition != UNTIL_NONE);
   
@@ -2865,34 +2941,39 @@
         /* Probably error so we aborting */
         sql_print_error("Slave SQL thread is stopped because UNTIL "
                         "condition is bad.");
-        return TRUE;
+        DBUG_RETURN(TRUE);
       }
     }
     else
-      return until_log_pos == 0;
+      DBUG_RETURN(until_log_pos == 0);
   }
     
-  return ((until_log_names_cmp_result == UNTIL_LOG_NAMES_CMP_EQUAL && 
+  DBUG_RETURN(((until_log_names_cmp_result == UNTIL_LOG_NAMES_CMP_EQUAL && 
            log_pos >= until_log_pos) ||
-          until_log_names_cmp_result == UNTIL_LOG_NAMES_CMP_GREATER);
+          until_log_names_cmp_result == UNTIL_LOG_NAMES_CMP_GREATER));
 }
 
 
 void st_relay_log_info::cached_charset_invalidate()
 {
+  DBUG_ENTER("st_relay_log_info::cached_charset_invalidate");
+
   /* Full of zeroes means uninitialized. */
   bzero(cached_charset, sizeof(cached_charset));
+  DBUG_VOID_RETURN;
 }
 
 
 bool st_relay_log_info::cached_charset_compare(char *charset)
 {
+  DBUG_ENTER("st_relay_log_info::cached_charset_compare");
+
   if (bcmp(cached_charset, charset, sizeof(cached_charset)))
   {
     memcpy(cached_charset, charset, sizeof(cached_charset));
-    return 1;
+    DBUG_RETURN(1);
   }
-  return 0;
+  DBUG_RETURN(0);
 }
 
 /*
@@ -2904,8 +2985,10 @@
 */
 static int has_temporary_error(THD *thd)
 {
+  DBUG_ENTER("has_temporary_error");
+
   if (thd->is_fatal_error)
-    return 0;
+    DBUG_RETURN(0);
 
   /*
     Temporary error codes:
@@ -2914,7 +2997,7 @@
   */
   if (thd->net.last_errno == ER_LOCK_DEADLOCK ||
       thd->net.last_errno == ER_LOCK_WAIT_TIMEOUT)
-    return 1;
+    DBUG_RETURN(1);
 
 #ifdef HAVE_NDB_BINLOG
   /*
@@ -2928,17 +3011,19 @@
     switch (err->code)
     {
     case ER_GET_TEMPORARY_ERRMSG:
-      return 1;
+      DBUG_RETURN(1);
     default:
       break;
     }
   }
 #endif
-  return 0;
+  DBUG_RETURN(0);
 }
 
 static int exec_relay_log_event(THD* thd, RELAY_LOG_INFO* rli)
 {
+  DBUG_ENTER("exec_relay_log_event");
+
   /*
      We acquire this mutex since we need it for all operations except
      event execution. But we will release it in places where we will
@@ -2965,7 +3050,7 @@
     */
     rli->abort_slave= 1;
     pthread_mutex_unlock(&rli->data_lock);
-    return 1;
+    DBUG_RETURN(1);
   }
 
   Log_event * ev = next_event(rli);
@@ -2976,7 +3061,7 @@
   {
     pthread_mutex_unlock(&rli->data_lock);
     delete ev;
-    return 1;
+    DBUG_RETURN(1);
   }
   if (ev)
   {
@@ -3044,7 +3129,7 @@
         --rli->slave_skip_counter;
       pthread_mutex_unlock(&rli->data_lock);
       delete ev;
-      return 0;                                 // avoid infinite update loops
+      DBUG_RETURN(0);                                 // avoid infinite update loops
     }
     pthread_mutex_unlock(&rli->data_lock);
 
@@ -3125,13 +3210,11 @@
          */
         rli->trans_retries= 0; // restart from fresh
       }
-     }
-    return exec_res;
+    }
+    DBUG_RETURN(exec_res);
   }
-  else
-  {
-    pthread_mutex_unlock(&rli->data_lock);
-    slave_print_msg(ERROR_LEVEL, rli, 0, "\
+  pthread_mutex_unlock(&rli->data_lock);
+  slave_print_msg(ERROR_LEVEL, rli, 0, "\
 Could not parse relay log event entry. The possible reasons are: the master's \
 binary log is corrupted (you can check this by running 'mysqlbinlog' on the \
 binary log), the slave's relay log is corrupted (you can check this by running \
@@ -3140,8 +3223,7 @@
 relay log, you will be able to know their names by issuing 'SHOW SLAVE STATUS' \
 on this slave.\
 ");
-    return 1;
-  }
+  DBUG_RETURN(1);
 }
 
 
@@ -3461,6 +3543,7 @@
 {
   THD *thd;			/* needs to be first for thread_stack */
   char llbuff[22],llbuff1[22];
+
   RELAY_LOG_INFO* rli = &((MASTER_INFO*)arg)->rli;
   const char *errmsg;
 
@@ -4060,16 +4143,18 @@
 static int queue_old_event(MASTER_INFO *mi, const char *buf,
 			   ulong event_len)
 {
+  DBUG_ENTER("queue_old_event");
+
   switch (mi->rli.relay_log.description_event_for_queue->binlog_version)
   {
   case 1:
-      return queue_binlog_ver_1_event(mi,buf,event_len);
+      DBUG_RETURN(queue_binlog_ver_1_event(mi,buf,event_len));
   case 3:
-      return queue_binlog_ver_3_event(mi,buf,event_len);
+      DBUG_RETURN(queue_binlog_ver_3_event(mi,buf,event_len));
   default: /* unsupported format; eg version 2 */
     DBUG_PRINT("info",("unsupported binlog format %d in queue_old_event()",
                        mi->rli.relay_log.description_event_for_queue->binlog_version));  
-    return 1;
+    DBUG_RETURN(1);
   }
 }
 
@@ -4282,7 +4367,9 @@
 
 static int safe_connect(THD* thd, MYSQL* mysql, MASTER_INFO* mi)
 {
-  return connect_to_master(thd, mysql, mi, 0, 0);
+  DBUG_ENTER("safe_connect");
+
+  DBUG_RETURN(connect_to_master(thd, mysql, mi, 0, 0));
 }
 
 
@@ -4439,9 +4526,10 @@
 bool flush_relay_log_info(RELAY_LOG_INFO* rli)
 {
   bool error=0;
+  DBUG_ENTER("flush_relay_log_info");
 
   if (unlikely(rli->no_storage))
-    return 0;
+    DBUG_RETURN(0);
 
   IO_CACHE *file = &rli->info_file;
   char buff[FN_REFLEN*2+22*2+4], *pos;
@@ -4461,7 +4549,7 @@
     error=1;
 
   /* Flushing the relay log is done by the slave I/O thread */
-  return error;
+  DBUG_RETURN(error);
 }
 
 
@@ -4471,9 +4559,9 @@
 
 static IO_CACHE *reopen_relay_log(RELAY_LOG_INFO *rli, const char **errmsg)
 {
+  DBUG_ENTER("reopen_relay_log");
   DBUG_ASSERT(rli->cur_log != &rli->cache_buf);
   DBUG_ASSERT(rli->cur_log_fd == -1);
-  DBUG_ENTER("reopen_relay_log");
 
   IO_CACHE *cur_log = rli->cur_log=&rli->cache_buf;
   if ((rli->cur_log_fd=open_binlog(cur_log,rli->event_relay_log_name,
@@ -4494,11 +4582,11 @@
 {
   Log_event* ev;
   IO_CACHE* cur_log = rli->cur_log;
-  pthread_mutex_t *log_lock = rli->relay_log.get_log_lock(); 
+  pthread_mutex_t *log_lock = rli->relay_log.get_log_lock();
   const char* errmsg=0;
   THD* thd = rli->sql_thd;
-  
   DBUG_ENTER("next_event");
+
   DBUG_ASSERT(thd != 0);
 
 #ifndef DBUG_OFF
@@ -4910,12 +4998,16 @@
 {
   const char *lstr = static_cast<const char *>(lhs);
   const char *rstr = static_cast<const st_reload_entry*>(rhs)->table;
-  return strcmp(lstr, rstr);
+  DBUG_ENTER("reload_entry_compare");
+
+  DBUG_RETURN(strcmp(lstr, rstr));
 }
 
 void st_relay_log_info::touching_table(char const* db, char const* table,
                                        ulong table_id) 
 {
+  DBUG_ENTER("st_relay_log_info::touching_table");
+
   if (strcmp(db,"mysql") == 0)
   {
 #if defined(HAVE_BSEARCH) && defined(HAVE_SIZE_T)
@@ -4936,10 +5028,13 @@
     if (entry)
       m_reload_flags|= entry->flag;
   }
+  DBUG_VOID_RETURN;
 }
 
 void st_relay_log_info::transaction_end(THD* thd) 
 {
+  DBUG_ENTER("st_relay_log_info::transaction_end");
+
   if (m_reload_flags != RELOAD_NONE_F)
   {
     if (m_reload_flags & RELOAD_ACCESS_F)
@@ -4950,11 +5045,14 @@
 
     m_reload_flags= RELOAD_NONE_F;
   }
+  DBUG_VOID_RETURN;
 }
 
 #if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
 void st_relay_log_info::cleanup_context(THD *thd, bool error)
 {
+  DBUG_ENTER("st_relay_log_info::cleanup_context");
+
   DBUG_ASSERT(sql_thd == thd);
   /*
     1) Instances of Table_map_log_event, if ::exec_event() was called on them,
@@ -4977,6 +5075,7 @@
   close_thread_tables(thd);
   clear_tables_to_lock();
   unsafe_to_stop_at= 0;
+  DBUG_VOID_RETURN;
 }
 #endif
 

--- 1.65/sql/ha_ndbcluster_binlog.cc	2006-06-14 03:20:29 +04:00
+++ 1.66/sql/ha_ndbcluster_binlog.cc	2006-06-15 15:38:08 +04:00
@@ -453,7 +453,7 @@
 }
 
 /*
- Called from MYSQL_LOG::reset_logs in log.cc when binlog is emptied
+ Called from MYSQL_BIN_LOG::reset_logs in log.cc when binlog is emptied
 */
 static int ndbcluster_reset_logs(THD *thd)
 {
@@ -477,7 +477,7 @@
 }
 
 /*
-  Called from MYSQL_LOG::purge_logs in log.cc when the binlog "file"
+  Called from MYSQL_BIN_LOG::purge_logs in log.cc when the binlog "file"
   is removed
 */
 
Thread
bk commit into 5.1 tree (petr:1.2208)Petr Chardin15 Jun