Fix for BUG#791:

a safer way of initing the mutexes in MYSQL_LOG.
is_open() is now always thread-safe.
See each file for details.


sql/handler.cc:
  is_open() with locks
sql/item_func.cc:
  is_open() with locks
sql/log.cc:
  No more 'inited'.
  We now always use is_open() in a thread-safe manner.
  This simplifies some functions (no more need to test is_open() twice).
sql/log_event.cc:
  is_open() with locks
sql/mysqld.cc:
  Init mutexes for the global MYSQL_LOG objects.
  We care about no_rotate, because we can't do it in open() anymore (because
  we don't have 'inited' anymore).
sql/repl_failsafe.cc:
  is_open() with locks
sql/slave.cc:
  init pthread objects (mutexes, conds) in the constructor of st_relay_log_info.
  Some better locking in rotate_relay_log().
sql/sql_base.cc:
  is_open() with locks
sql/sql_class.h:
  Before, we inited LOCK_log in MYSQL_LOG::open(), so in other places of the code
  when we were never 100% sure that it had been inited. For example, if the server
  was running without --log-bin, ::open() was not called so the mutex was not
  inited. We could detect it with !inited, but not safely as 'inited' was not
  protected by any mutex.
  So now:
  we *always* init the LOCK_log mutex, even if the log is not used. We can't init
  the mutex in MYSQL_LOG's constructor, because for global objects like
  mysql_bin_log, mysql_log etc, the constructor is called before MY_INIT(), but
  safe_mutex depends on MY_INIT(). So we have a new function MYSQL_LOG::init_pthread_objects
  which we call in main(), after MY_INIT().
  For the relay log, we call this function in the constructor of
  st_relay_log_info, which is called before any function tries to
  use the relay log (the relay log is always invoked as rli.relay_log).
  So now we should be safe in all cases and we don't need 'inited'.
sql/sql_db.cc:
  is_open() with locks
sql/sql_delete.cc:
  is_open() with locks
sql/sql_insert.cc:
  is_open() with locks
sql/sql_load.cc:
  is_open() with locks
sql/sql_parse.cc:
  is_open() with locks
sql/sql_rename.cc:
  is_open() with locks
sql/sql_repl.cc:
  is_open() with locks
sql/sql_table.cc:
  is_open() with locks
sql/sql_update.cc:
  is_open() with locks

1 files changed, 9 insertions, 2 deletions

diff --git a/sql/sql_class.h b/sql/sql_class.h
index 71b943b5d26..cd622520df3 100644
--- a/sql/sql_class.h
+++ b/sql/sql_class.h
@@ -61,6 +61,11 @@ class Log_event;
 
 class MYSQL_LOG {
  private:
+  /* 
+     LOCK_log is inited by MYSQL_LOG::init(), so one should try to lock it only
+     if he is sure MYSQL_LOG::init() has been called (i.e. if 'inited' is true).
+     Same for LOCK_index.
+  */
   pthread_mutex_t LOCK_log, LOCK_index;
   pthread_cond_t update_cond;
   ulonglong bytes_written;
@@ -80,7 +85,7 @@ class MYSQL_LOG {
   */
   volatile enum_log_type log_type;
   enum cache_type io_cache_type;
-  bool write_error,inited;
+  bool write_error;
   bool no_rotate;
   bool need_start_event;
   bool no_auto_events; // for relay binlog
@@ -123,6 +128,7 @@ public:
   void init(enum_log_type log_type_arg,
 	    enum cache_type io_cache_type_arg,
 	    bool no_auto_events_arg, ulong max_size);
+  void init_pthread_objects();
   void cleanup();
   bool open(const char *log_name,enum_log_type log_type,
 	    const char *new_name, const char *index_file_name_arg,
@@ -158,8 +164,8 @@ public:
   int find_next_log(LOG_INFO* linfo, bool need_mutex);
   int get_current_log(LOG_INFO* linfo);
   uint next_file_id();
+  bool is_open(bool need_mutex=0);
 
-  inline bool is_open() { return log_type != LOG_CLOSED; }
   inline char* get_index_fname() { return index_file_name;}
   inline char* get_log_fname() { return log_file_name; }
   inline pthread_mutex_t* get_log_lock() { return &LOCK_log; }
@@ -169,6 +175,7 @@ public:
   inline void unlock_index() { pthread_mutex_unlock(&LOCK_index);}
   inline IO_CACHE *get_index_file() { return &index_file;}
   inline uint32 get_open_count() { return open_count; }
+  inline void set_no_rotate(bool no_rotate_arg) {no_rotate= no_rotate_arg;}
 };
 
 /* character conversion tables */