bk commit into 5.0 tree (SergeyV:1.1961) BUG#13377

[sergeyv]

Below is the list of changes that have just been committed into a local
5.0 repository of sergeyv. When sergeyv 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.1961 05/11/14 18:10:16 SergeyV@selena. +7 -0
  Import patch for bug #13377 from current 5.0 bk tree.

  sql/sql_repl.cc
    1.144 05/11/14 17:56:00 SergeyV@selena.[SergeyV] +7 -32
    Import patch 00.txt

  sql/sql_class.h
    1.273 05/11/14 17:56:00 SergeyV@selena.[SergeyV] +1 -5
    Import patch 00.txt

  sql/log.cc
    1.183 05/11/14 17:56:00 SergeyV@selena.[SergeyV] +1 -61
    Import patch 00.txt

  mysys/my_open.c
    1.22 05/11/14 17:56:00 SergeyV@selena.[SergeyV] +184 -0
    Import patch 00.txt

  mysys/my_create.c
    1.11 05/11/14 17:56:00 SergeyV@selena.[SergeyV] +4 -1
    Import patch 00.txt

  include/my_sys.h
    1.176 05/11/14 17:56:00 SergeyV@selena.[SergeyV] +1 -0
    Import patch 00.txt

  include/my_global.h
    1.110 05/11/14 17:56:00 SergeyV@selena.[SergeyV] +9 -0
    Import patch 00.txt

# 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:	SergeyV
# Host:	selena.
# Root:	H:/MYSQL/bkt/mysql-5.0-rel

--- 1.175/include/my_sys.h	2005-10-13 02:24:10 +04:00
+++ 1.176/include/my_sys.h	2005-11-14 17:56:00 +03:00
@@ -601,6 +601,7 @@
 
 #ifdef __WIN__
 extern int my_access(const char *path, int amode);
+extern File my_sopen(const char *path, int oflag, int shflag, int pmode);
 #else
 #define my_access access
 #endif

--- 1.10/mysys/my_create.c	2001-12-06 15:10:42 +03:00
+++ 1.11/mysys/my_create.c	2005-11-14 17:56:00 +03:00
@@ -47,13 +47,16 @@
 #elif defined(VMS)
   fd = open((my_string) FileName, access_flags | O_CREAT, 0,
 	    "ctx=stm","ctx=bin");
-#elif defined(MSDOS) || defined(__WIN__) || defined(__EMX__) || defined(OS2)
+#elif defined(MSDOS) || defined(__EMX__) || defined(OS2)
   if (access_flags & O_SHARE)
     fd = sopen((my_string) FileName, access_flags | O_CREAT | O_BINARY,
 	       SH_DENYNO, MY_S_IREAD | MY_S_IWRITE);
   else
     fd =  open((my_string) FileName, access_flags | O_CREAT | O_BINARY,
 	       MY_S_IREAD | MY_S_IWRITE);
+#elif defined(__WIN__)
+  fd= my_sopen((my_string) FileName, access_flags | O_CREAT | O_BINARY,
+	       SH_DENYNO, MY_S_IREAD | MY_S_IWRITE);
 #else
   fd = open(FileName, access_flags);
 #endif

--- 1.21/mysys/my_open.c	2005-05-26 21:54:23 +04:00
+++ 1.22/mysys/my_open.c	2005-11-14 17:56:00 +03:00
@@ -56,12 +56,18 @@
     DBUG_RETURN(my_register_filename(-1, FileName, FILE_BY_OPEN,
                                      EE_FILENOTFOUND, MyFlags));
   }
+#ifndef __WIN__
   if (Flags & O_SHARE)
     fd = sopen((my_string) FileName, (Flags & ~O_SHARE) | O_BINARY, SH_DENYNO,
 	       MY_S_IREAD | MY_S_IWRITE);
   else
     fd = open((my_string) FileName, Flags | O_BINARY,
 	      MY_S_IREAD | MY_S_IWRITE);
+#else
+  fd= my_sopen((my_string) FileName, (Flags & ~O_SHARE) | O_BINARY, SH_DENYNO,
+	       MY_S_IREAD | MY_S_IWRITE);
+#endif
+
 #elif !defined(NO_OPEN_3)
   fd = open(FileName, Flags, my_umask);	/* Normal unix */
 #else
@@ -167,3 +173,181 @@
 	     FileName, my_errno);
   return(fd);
 }
+
+#ifdef __WIN__
+
+extern void __cdecl _dosmaperr(unsigned long);
+
+/*
+  Open a file with sharing. Similar to _sopen() from libc, but allows managing
+  share delete on win32
+
+  SYNOPSIS
+    my_sopen()
+      path    fully qualified file name
+      oflag   operation flags
+      shflag	share flag
+      pmode   permission flags
+
+  RETURN VALUE
+    File descriptor of opened file if success
+    -1 and sets errno if fails.
+*/
+
+File my_sopen(const char *path, int oflag, int shflag, int pmode)
+{
+  int  fh;                                /* handle of opened file */
+  int mask;
+  HANDLE osfh;                            /* OS handle of opened file */
+  DWORD fileaccess;                       /* OS file access (requested) */
+  DWORD fileshare;                        /* OS file sharing mode */
+  DWORD filecreate;                       /* OS method of opening/creating */
+  DWORD fileattrib;                       /* OS file attribute flags */
+  SECURITY_ATTRIBUTES SecurityAttributes;
+
+  SecurityAttributes.nLength= sizeof(SecurityAttributes);
+  SecurityAttributes.lpSecurityDescriptor= NULL;
+  SecurityAttributes.bInheritHandle= !(oflag & _O_NOINHERIT);
+
+  /*
+   * decode the access flags
+   */
+  switch (oflag & (_O_RDONLY | _O_WRONLY | _O_RDWR)) {
+    case _O_RDONLY:         /* read access */
+      fileaccess= GENERIC_READ;
+      break;
+    case _O_WRONLY:         /* write access */
+      fileaccess= GENERIC_WRITE;
+      break;
+    case _O_RDWR:           /* read and write access */
+      fileaccess= GENERIC_READ | GENERIC_WRITE;
+      break;
+    default:                /* error, bad oflag */
+      errno= EINVAL;
+      _doserrno= 0L;        /* not an OS error */
+      return -1;
+  }
+
+  /*
+   * decode sharing flags
+   */
+  switch (shflag) {
+    case _SH_DENYRW:        /* exclusive access except delete */
+      fileshare= FILE_SHARE_DELETE;
+      break;
+    case _SH_DENYWR:        /* share read and delete access */
+      fileshare= FILE_SHARE_READ | FILE_SHARE_DELETE;
+      break;
+    case _SH_DENYRD:        /* share write and delete access */
+      fileshare= FILE_SHARE_WRITE | FILE_SHARE_DELETE;
+      break;
+    case _SH_DENYNO:        /* share read, write and delete access */
+      fileshare= FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE;
+      break;
+    case _SH_DENYRWD:       /* exclusive access */
+      fileshare= 0L;
+      break;
+    case _SH_DENYWRD:       /* share read access */
+      fileshare= FILE_SHARE_READ;
+      break;
+    case _SH_DENYRDD:       /* share write access */
+      fileshare= FILE_SHARE_WRITE;
+      break;
+    case _SH_DENYDEL:       /* share read and write access */
+      fileshare= FILE_SHARE_READ | FILE_SHARE_WRITE;
+      break;
+    default:                /* error, bad shflag */
+      errno= EINVAL;
+      _doserrno= 0L;        /* not an OS error */
+      return -1;
+  }
+
+  /*
+   * decode open/create method flags
+   */
+  switch (oflag & (_O_CREAT | _O_EXCL | _O_TRUNC)) {
+    case 0:
+    case _O_EXCL:                   // ignore EXCL w/o CREAT
+      filecreate= OPEN_EXISTING;
+      break;
+
+    case _O_CREAT:
+      filecreate= OPEN_ALWAYS;
+      break;
+
+    case _O_CREAT | _O_EXCL:
+    case _O_CREAT | _O_TRUNC | _O_EXCL:
+      filecreate= CREATE_NEW;
+      break;
+
+    case _O_TRUNC:
+    case _O_TRUNC | _O_EXCL:        // ignore EXCL w/o CREAT
+      filecreate= TRUNCATE_EXISTING;
+      break;
+
+    case _O_CREAT | _O_TRUNC:
+      filecreate= CREATE_ALWAYS;
+      break;
+
+    default:
+      // this can't happen ... all cases are covered
+      errno= EINVAL;
+      _doserrno= 0L;
+      return -1;
+  }
+
+  /*
+   * decode file attribute flags if _O_CREAT was specified
+   */
+  fileattrib= FILE_ATTRIBUTE_NORMAL;     /* default */
+  if (oflag & _O_CREAT) 
+  {
+    _umask((mask= _umask(0)));
+    
+    if (!((pmode & ~mask) & _S_IWRITE))
+      fileattrib= FILE_ATTRIBUTE_READONLY;
+  }
+
+  /*
+   * Set temporary file (delete-on-close) attribute if requested.
+   */
+  if (oflag & _O_TEMPORARY) 
+  {
+    fileattrib|= FILE_FLAG_DELETE_ON_CLOSE;
+    fileaccess|= DELETE;
+  }
+
+  /*
+   * Set temporary file (delay-flush-to-disk) attribute if requested.
+   */
+  if (oflag & _O_SHORT_LIVED)
+    fileattrib|= FILE_ATTRIBUTE_TEMPORARY;
+
+  /*
+   * Set sequential or random access attribute if requested.
+   */
+  if (oflag & _O_SEQUENTIAL)
+    fileattrib|= FILE_FLAG_SEQUENTIAL_SCAN;
+  else if (oflag & _O_RANDOM)
+    fileattrib|= FILE_FLAG_RANDOM_ACCESS;
+
+  /*
+   * try to open/create the file
+   */
+  if ((osfh= CreateFile(path, fileaccess, fileshare, &SecurityAttributes, 
+                        filecreate, fileattrib, NULL)) == (HANDLE)0xffffffff)
+  {
+    /*
+     * OS call to open/create file failed! map the error, release
+     * the lock, and return -1. note that it's not necessary to
+     * call _free_osfhnd (it hasn't been used yet).
+     */
+    _dosmaperr(GetLastError());     /* map error */
+    return -1;                      /* return error to caller */
+  }
+
+  fh= _open_osfhandle((long)osfh, oflag & (_O_APPEND | _O_RDONLY | _O_TEXT));
+
+  return fh;                        /* return handle */
+}
+#endif /* __WIN__ */

--- 1.182/sql/log.cc	2005-11-04 16:12:19 +03:00
+++ 1.183/sql/log.cc	2005-11-14 17:56:00 +03:00
@@ -357,8 +357,7 @@
 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),
-   readers_count(0), reset_pending(FALSE), write_error(FALSE), inited(FALSE),
-   need_start_event(TRUE),
+   write_error(FALSE), inited(FALSE), need_start_event(TRUE),
    description_event_for_exec(0), description_event_for_queue(0)
 {
   /*
@@ -385,9 +384,7 @@
     delete description_event_for_exec;
     (void) pthread_mutex_destroy(&LOCK_log);
     (void) pthread_mutex_destroy(&LOCK_index);
-    (void) pthread_mutex_destroy(&LOCK_readers);
     (void) pthread_cond_destroy(&update_cond);
-    (void) pthread_cond_destroy(&reset_cond);
   }
   DBUG_VOID_RETURN;
 }
@@ -432,9 +429,7 @@
   inited= 1;
   (void) pthread_mutex_init(&LOCK_log,MY_MUTEX_INIT_SLOW);
   (void) pthread_mutex_init(&LOCK_index, MY_MUTEX_INIT_SLOW);
-  (void) pthread_mutex_init(&LOCK_readers, MY_MUTEX_INIT_SLOW);
   (void) pthread_cond_init(&update_cond, 0);
-  (void) pthread_cond_init(&reset_cond, 0);
 }
 
 const char *MYSQL_LOG::generate_name(const char *log_name,
@@ -938,12 +933,6 @@
   pthread_mutex_lock(&LOCK_log);
   pthread_mutex_lock(&LOCK_index);
 
-  /* 
-    we need one more lock to block attempts to open a log while
-    we are waiting untill all log files will be closed
-  */
-  pthread_mutex_lock(&LOCK_readers);
-
   /*
     The following mutex is needed to ensure that no threads call
     'delete thd' as we would then risk missing a 'rollback' from this
@@ -966,19 +955,6 @@
     goto err;
   }
 
-  reset_pending= TRUE;
-  /* 
-    send update signal just in case so that all reader threads waiting
-    for log update will leave wait condition
-  */
-  signal_update();
-  /* 
-    if there are active readers wait until all of them will 
-    release opened files 
-  */
-  while (readers_count)
-    pthread_cond_wait(&reset_cond, &LOCK_log);
-
   for (;;)
   {
     my_delete(linfo.log_file_name, MYF(MY_WME));
@@ -997,10 +973,7 @@
   my_free((gptr) save_name, MYF(0));
 
 err:
-  reset_pending= FALSE;
-
   (void) pthread_mutex_unlock(&LOCK_thread_count);
-  pthread_mutex_unlock(&LOCK_readers);
   pthread_mutex_unlock(&LOCK_index);
   pthread_mutex_unlock(&LOCK_log);
   DBUG_RETURN(error);
@@ -2073,12 +2046,6 @@
 {
   const char *old_msg;
   DBUG_ENTER("wait_for_update");
-  
-  if (reset_pending)
-  {
-    pthread_mutex_unlock(&LOCK_log);
-    DBUG_VOID_RETURN;
-  }
 
   old_msg= thd->enter_cond(&update_cond, &LOCK_log,
                            is_slave ?
@@ -2327,33 +2294,6 @@
 {
   DBUG_ENTER("MYSQL_LOG::signal_update");
   pthread_cond_broadcast(&update_cond);
-  DBUG_VOID_RETURN;
-}
-
-void MYSQL_LOG::readers_addref()
-{
-  /* 
-    There is no necessity for reference counting on *nix, since it allows to
-    delete opened files, however it is more clean way to wait
-    untill all files will be closed on *nix as well.
-  */
-  DBUG_ENTER("MYSQL_LOG::reader_addref");
-  pthread_mutex_lock(&LOCK_log);
-  pthread_mutex_lock(&LOCK_readers);
-  readers_count++;
-  pthread_mutex_unlock(&LOCK_readers);
-  pthread_mutex_unlock(&LOCK_log);
-  DBUG_VOID_RETURN;
-}
-
-void MYSQL_LOG::readers_release()
-{
-  DBUG_ENTER("MYSQL_LOG::reader_release");
-  pthread_mutex_lock(&LOCK_log);
-  readers_count--;
-  if (!readers_count)
-    pthread_cond_broadcast(&reset_cond);
-  pthread_mutex_unlock(&LOCK_log);
   DBUG_VOID_RETURN;
 }
 

--- 1.272/sql/sql_class.h	2005-11-04 16:12:19 +03:00
+++ 1.273/sql/sql_class.h	2005-11-14 17:56:00 +03:00
@@ -189,11 +189,10 @@
 {
  private:
   /* LOCK_log and LOCK_index are inited by init_pthread_objects() */
-  pthread_mutex_t LOCK_log, LOCK_index, LOCK_readers;
+  pthread_mutex_t LOCK_log, LOCK_index;
   pthread_mutex_t LOCK_prep_xids;
   pthread_cond_t  COND_prep_xids;
   pthread_cond_t update_cond;
-  pthread_cond_t reset_cond;
   ulonglong bytes_written;
   time_t last_time,query_start;
   IO_CACHE log_file;
@@ -335,9 +334,6 @@
   int purge_logs_before_date(time_t purge_time);
   int purge_first_log(struct st_relay_log_info* rli, bool included);
   bool reset_logs(THD* thd);
-  inline bool is_reset_pending() { return reset_pending; }
-  void readers_addref();
-  void readers_release();
   void close(uint exiting);
 
   // iterating through the log index file

--- 1.109/include/my_global.h	2005-09-23 17:46:59 +04:00
+++ 1.110/include/my_global.h	2005-11-14 17:56:00 +03:00
@@ -553,6 +553,15 @@
 #define O_NOFOLLOW      0
 #endif
 
+/* additional file share flags for win32 */
+#ifdef __WIN__
+#define _SH_DENYRWD     0x110    /* deny read/write mode & delete */
+#define _SH_DENYWRD     0x120    /* deny write mode & delete      */
+#define _SH_DENYRDD     0x130    /* deny read mode & delete       */
+#define _SH_DENYDEL     0x140    /* deny delete only              */
+#endif /* __WIN__ */
+
+
 /* #define USE_RECORD_LOCK	*/
 
 	/* Unsigned types supported by the compiler */

--- 1.143/sql/sql_repl.cc	2005-10-03 20:34:19 +04:00
+++ 1.144/sql/sql_repl.cc	2005-11-14 17:56:00 +03:00
@@ -372,11 +372,6 @@
     goto err;
   }
 
-  /*
-    Call readers_addref before opening log to track count 
-    of binlog readers
-  */
-  mysql_bin_log.readers_addref();
   if ((file=open_binlog(&log, log_file_name, &errmsg)) < 0)
   {
     my_errno= ER_MASTER_FATAL_ERROR_READING_BINLOG;
@@ -574,8 +569,7 @@
       goto err;
 
     if (!(flags & BINLOG_DUMP_NON_BLOCK) &&
-        mysql_bin_log.is_active(log_file_name) &&
-        !mysql_bin_log.is_reset_pending())
+        mysql_bin_log.is_active(log_file_name))
     {
       /*
 	Block until there is more data in the log
@@ -688,13 +682,7 @@
     else
     {
       bool loop_breaker = 0;
-      // need this to break out of the for loop from switch
-
-      // if we are going to switch log file anyway, close current log first
-      end_io_cache(&log);
-      (void) my_close(file, MYF(MY_WME));
-      // decrease reference count of binlog readers
-      mysql_bin_log.readers_release();
+      /* need this to break out of the for loop from switch */
 
       thd->proc_info = "Finished reading one binlog; switching to next binlog";
       switch (mysql_bin_log.find_next_log(&linfo, 1)) {
@@ -704,25 +692,16 @@
       case 0:
 	break;
       default:
-	// need following call to do release on err label
-	mysql_bin_log.readers_addref(); 
 	errmsg = "could not find next log";
 	my_errno= ER_MASTER_FATAL_ERROR_READING_BINLOG;
 	goto err;
       }
 
-	if (loop_breaker)
-	{
-	  // need following call to do release on end label
-	  mysql_bin_log.readers_addref();
-	  break;
-	}
-
-      /*
-        Call readers_addref before opening log to track count 
-        of binlog readers
-      */
-      mysql_bin_log.readers_addref();
+      if (loop_breaker)
+        break;
+      
+      end_io_cache(&log);
+      (void) my_close(file, MYF(MY_WME));
 
       /*
         Call fake_rotate_event() in case the previous log (the one which
@@ -755,8 +734,6 @@
 
   end_io_cache(&log);
   (void)my_close(file, MYF(MY_WME));
-  // decrease reference count of binlog readers
-  mysql_bin_log.readers_release();
 
   send_eof(thd);
   thd->proc_info = "Waiting to finalize termination";
@@ -783,8 +760,6 @@
   pthread_mutex_unlock(&LOCK_thread_count);
   if (file >= 0)
     (void) my_close(file, MYF(MY_WME));
-  // decrease reference count of binlog readers
-  mysql_bin_log.readers_release();
 
   my_message(my_errno, errmsg, MYF(0));
   DBUG_VOID_RETURN;