Bug #19031370: ADD SUPPORT FOR VISUAL STUDIO CRT MEMORY LEAKS TRACKING

Added support for MS Visual Studio CRT memory leak tracing:
* Made a new CMake parameter : WITH_MSCRT_DEBUG=YES/NO (default NO)
* Added a code to my_init.c to initialize the CRT debugging to print to stderr
* Enabled convertion all malloc to _malloc_dbg, calloc to _calloc_dbg  and realloc to _realloc_dbg to get line numbers in the report
* Renamed all the class methods and members named free/malloc/calloc/realloc to mem_free/mem_malloc/mem_calloc/mem_realloc to avoid
  conflicts with the #define
* Marked the my_malloc/my_free allocations as "client" blocks and left all the others as "normal" blocks.
* Made sure NDB compiles too
* Addressed Magnus' comments (renamed some of the ndb mem_free to more meaningful names)
* Addressed second set of Magnus' comments (renamed num_free_bytes) to num_free.
* updated to the latest trunk
* fixed an ndb compilation failure on windows
* Addressed Jon-Olav's remarks: moved definiton out of my_global.h, some cmake cleanups.

Author: gkodinov

CMakeLists.txt

@@ -229,6 +229,9 @@ OPTION(WITHOUT_SERVER OFF)
 IF(UNIX)
   OPTION(WITH_VALGRIND "Valgrind instrumentation" OFF)
 ENDIF()
+IF(WIN32)
+  OPTION(WITH_MSCRT_DEBUG "MS Visual Studio Debug CRT instrumentation" OFF)
+ENDIF()
 IF(NOT WITHOUT_SERVER)
   OPTION (WITH_UNIT_TESTS "Compile MySQL with unit tests" ON)
 ENDIF()

client/mysql.cc

@@ -1276,7 +1276,7 @@ int main(int argc,char *argv[])
     my_end(0);
     exit(1);
   }
-  glob_buffer.realloc(512);
+  glob_buffer.mem_realloc(512);
   completion_hash_init(&ht, 128);
   init_alloc_root(PSI_NOT_INSTRUMENTED, &hash_mem_root, 16384, 0);
   memset(&mysql, 0, sizeof(mysql));
@@ -1439,9 +1439,9 @@ void mysql_end(int sig)
 
   if (sig >= 0)
     put_info(sig ? "Aborted" : "Bye", INFO_RESULT);
-  glob_buffer.free();
-  old_buffer.free();
-  processed_prompt.free();
+  glob_buffer.mem_free();
+  old_buffer.mem_free();
+  processed_prompt.mem_free();
   my_free(server_version);
   my_free(opt_password);
   my_free(opt_mysql_unix_port);
@@ -2301,8 +2301,8 @@ static int read_and_execute(bool interactive)
   }
 
 #if defined(_WIN32)
-  buffer.free();
-  tmpbuf.free();
+  buffer.mem_free();
+  tmpbuf.mem_free();
 #else
   if (interactive)
     /*
@@ -2706,7 +2706,7 @@ static bool add_line(String &buffer, char *line, size_t line_length,
       length++;
     }
     if (buffer.length() + length >= buffer.alloced_length())
-      buffer.realloc(buffer.length()+length+IO_SIZE);
+      buffer.mem_realloc(buffer.length()+length+IO_SIZE);
     if ((!*ml_comment || preserve_comments) && buffer.append(line, length))
       DBUG_RETURN(1);
   }
@@ -5497,7 +5497,7 @@ static void mysql_end_timer(ulong start_time,char *buff)
 
 static const char* construct_prompt()
 {
-  processed_prompt.free();			// Erase the old prompt
+  processed_prompt.mem_free();			// Erase the old prompt
   time_t  lclock = time(NULL);			// Get the date struct
   struct tm *t = localtime(&lclock);
 

cmake/os/Windows.cmake

@@ -58,6 +58,11 @@ ADD_DEFINITIONS(-DWIN32_LEAN_AND_MEAN -DNOGDI)
 
 # We want to use std::min/std::max, not the windows.h macros
 ADD_DEFINITIONS(-DNOMINMAX)
+
+IF(WITH_MSCRT_DEBUG)
+  ADD_DEFINITIONS(-DMY_MSCRT_DEBUG)
+  ADD_DEFINITIONS(-D_CRTDBG_MAP_ALLOC)
+ENDIF()
 
 IF(MSVC)
   # Enable debug info also in Release build,

include/m_ctype.h

@@ -254,9 +254,9 @@ typedef struct my_charset_loader_st
 {
   char error[128];
   void *(*once_alloc)(size_t);
-  void *(*malloc)(size_t);
-  void *(*realloc)(void *, size_t);
-  void (*free)(void *);
+  void *(*mem_malloc)(size_t);
+  void *(*mem_realloc)(void *, size_t);
+  void (*mem_free)(void *);
   void (*reporter)(enum loglevel, const char *format, ...);
   int  (*add_collation)(struct charset_info_st *cs);
 } MY_CHARSET_LOADER;

include/my_global.h

@@ -32,7 +32,6 @@
 #endif
 
 #include <stdio.h>
-#include <stdarg.h>
 #include <stdlib.h>
 #include <stddef.h>
 #include <math.h>
@@ -49,6 +48,9 @@
 #if !defined(_WIN32)
 #include <netdb.h>
 #endif
+#ifdef MY_MSCRT_DEBUG
+#include <crtdbg.h>
+#endif
 
 /*
   A lot of our programs uses asserts, so better to always include it

include/sql_string.h

@@ -186,7 +186,7 @@ class String
   }
   static void operator delete(void *, MEM_ROOT *)
   { /* never called */ }
-  ~String() { free(); }
+  ~String() { mem_free(); }
 
   void set_charset(const CHARSET_INFO *charset_arg)
   { m_charset= charset_arg; }
@@ -204,7 +204,7 @@ class String
                 (m_alloced_length >= (m_length + 1)));
 
     if (!m_ptr || m_ptr[m_length])		/* Should be safe */
-      (void) realloc(m_length);
+      (void) mem_realloc(m_length);
     return m_ptr;
   }
   char *c_ptr_quick()
@@ -218,7 +218,7 @@ class String
     if (m_ptr && m_length < m_alloced_length)
       m_ptr[m_length]= 0;
     else
-      (void) realloc(m_length);
+      (void) mem_realloc(m_length);
     return m_ptr;
   }
   LEX_STRING lex_string() const
@@ -236,7 +236,7 @@ class String
   void set(String &str,size_t offset, size_t arg_length)
   {
     DBUG_ASSERT(&str != this);
-    free();
+    mem_free();
     m_ptr= const_cast<char*>(str.ptr()) + offset;
     m_length= arg_length;
     m_is_alloced= false;
@@ -258,15 +258,15 @@ class String
   */
   void set(char *str, size_t arg_length, const CHARSET_INFO *cs)
   {
-    free();
+    mem_free();
     m_ptr= str;
     m_length= m_alloced_length= static_cast<uint32>(arg_length);
     m_is_alloced= false;
     m_charset= cs;
   }
   void set(const char *str, size_t arg_length, const CHARSET_INFO *cs)
   {
-    free();
+    mem_free();
     m_ptr= const_cast<char*>(str);
     m_length= arg_length;
     m_alloced_length= 0;
@@ -320,7 +320,7 @@ class String
     DBUG_ASSERT(strlen(m_ptr) == m_length);
   }
 
-  void free()
+  void mem_free()
   {
     if (m_is_alloced)
     {
@@ -338,7 +338,7 @@ class String
     return real_alloc(arg_length);
   }
   bool real_alloc(size_t arg_length);			// Empties old string
-  bool realloc(size_t arg_length);
+  bool mem_realloc(size_t arg_length);
 
   // Shrink the buffer, but only if it is allocated on the heap.
   void shrink(size_t arg_length)
@@ -371,7 +371,7 @@ class String
         some_string = substring_of_that_string
        */
       DBUG_ASSERT(!s.uses_buffer_owned_by(this));
-      free();
+      mem_free();
       m_ptr= s.m_ptr;
       m_length= s.m_length;
       m_alloced_length= s.m_alloced_length;
@@ -393,7 +393,7 @@ class String
     DBUG_ASSERT(this != &s);
     // Make sure buffers of the two Strings do not overlap
     DBUG_ASSERT(!s.uses_buffer_owned_by(this));
-    free();
+    mem_free();
     m_ptr= s.m_ptr;
     m_length= s.m_length;
     m_alloced_length= s.m_alloced_length;
@@ -456,7 +456,7 @@ class String
     }
     else
     {
-      if (realloc(m_length+1))
+      if (mem_realloc(m_length+1))
 	return 1;
       m_ptr[m_length++]= chr;
     }
@@ -472,7 +472,7 @@ class String
 
   int reserve(size_t space_needed)
   {
-    return realloc(m_length + space_needed);
+    return mem_realloc(m_length + space_needed);
   }
   int reserve(size_t space_needed, size_t grow_by);
   /*
@@ -528,7 +528,7 @@ class String
     size_t new_length= arg_length + m_length;
     if (new_length > m_alloced_length)
     {
-      if (realloc(new_length + step_alloc))
+      if (mem_realloc(new_length + step_alloc))
         return NULL;
     }
     size_t old_length= m_length;
@@ -539,7 +539,7 @@ class String
   bool append(const char *s, size_t arg_length, size_t step_alloc)
   {
     size_t new_length= arg_length + m_length;
-    if (new_length > m_alloced_length && realloc(new_length + step_alloc))
+    if (new_length > m_alloced_length && mem_realloc(new_length + step_alloc))
       return true;
     memcpy(m_ptr+m_length, s, arg_length);
     m_length+= arg_length;

libmysql/authentication_win/handshake.cc

@@ -66,7 +66,7 @@ Handshake::~Handshake()
     FreeCredentialsHandle(&m_cred);
   if (m_have_sec_context)
     DeleteSecurityContext(&m_sctx);
-  m_output.free();
+  m_output.mem_free();
 
 #ifndef DBUG_OFF
   if (m_ssp_info)
@@ -278,7 +278,7 @@ Security_buffer::Security_buffer(): m_allocated(true)
 }
 
 
-void Security_buffer::free(void)
+void Security_buffer::mem_free(void)
 {
   if (m_allocated && NULL != ptr())
   {

libmysql/authentication_win/handshake.h

@@ -67,7 +67,7 @@ class Security_buffer: public SecBufferDesc
 
   ~Security_buffer()
   {
-    free();
+    mem_free();
   }
 
   byte*  ptr() const
@@ -85,7 +85,7 @@ class Security_buffer: public SecBufferDesc
     return Blob(ptr(), len());
   }
 
-  void free(void);
+  void mem_free(void);
 };
 
 

libmysql/authentication_win/handshake_client.cc

@@ -278,7 +278,7 @@ Blob Handshake_client::process_data(const Blob &data)
   Security_buffer  input(data);
   SECURITY_STATUS  ret;
 
-  m_output.free();
+  m_output.mem_free();
 
   ret= InitializeSecurityContextW(
          &m_cred,

mysys/charset.c

@@ -395,9 +395,9 @@ my_charset_loader_init_mysys(MY_CHARSET_LOADER *loader)
 {
   loader->error[0]= '\0';
   loader->once_alloc= my_once_alloc_c;
-  loader->malloc= my_malloc_c;
-  loader->realloc= my_realloc_c;
-  loader->free= my_free_c;
+  loader->mem_malloc= my_malloc_c;
+  loader->mem_realloc= my_realloc_c;
+  loader->mem_free= my_free_c;
   loader->reporter= my_charset_error_reporter;
   loader->add_collation= add_collation;
 }

mysys/my_init.c

@@ -55,6 +55,27 @@ static ulong atoi_octal(const char *str)
 MYSQL_FILE *mysql_stdin= NULL;
 static MYSQL_FILE instrumented_stdin;
 
+#if defined(MY_MSCRT_DEBUG)
+int set_crt_report_leaks()
+{
+  HANDLE hLogFile;
+
+  _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF        // debug allocation on
+                 | _CRTDBG_LEAK_CHECK_DF     // leak checks on exit
+                 | _CRTDBG_CHECK_ALWAYS_DF   // memory check (slow)
+                 );
+
+  return ((
+    NULL == (hLogFile= GetStdHandle(STD_ERROR_HANDLE)) ||
+    -1 == _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE) ||
+    _CRTDBG_HFILE_ERROR == _CrtSetReportFile(_CRT_WARN, hLogFile) ||
+    -1 == _CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_FILE) ||
+    _CRTDBG_HFILE_ERROR == _CrtSetReportFile(_CRT_ERROR, hLogFile) ||
+    -1 == _CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE) ||
+    _CRTDBG_HFILE_ERROR == _CrtSetReportFile(_CRT_ASSERT, hLogFile)) ? 1 : 0);
+}
+#endif
+
 
 /**
   Initialize my_sys functions, resources and variables
@@ -72,6 +93,10 @@ my_bool my_init(void)
 
   my_init_done= 1;
 
+#if defined(MY_MSCRT_DEBUG)
+  set_crt_report_leaks();
+#endif
+
   my_umask= 0660;                       /* Default umask for new files */
   my_umask_dir= 0700;                   /* Default umask for new directories */
 

mysys/my_malloc.c

@@ -159,10 +159,17 @@ static void *my_raw_malloc(size_t size, myf my_flags)
   if (!size)
     size=1;
 
+#if defined(MY_MSCRT_DEBUG)
+  if (my_flags & MY_ZEROFILL)
+    point= _calloc_dbg(size, 1, _CLIENT_BLOCK, __FILE__, __LINE__);
+  else
+    point= _malloc_dbg(size, _CLIENT_BLOCK, __FILE__, __LINE__);
+#else
   if (my_flags & MY_ZEROFILL)
     point= calloc(size, 1);
   else
     point= malloc(size);
+#endif
 
   DBUG_EXECUTE_IF("simulate_out_of_memory",
                   {
@@ -221,7 +228,11 @@ static void *my_raw_realloc(void *oldpoint, size_t size, myf my_flags)
                   goto end;);
   if (!oldpoint && (my_flags & MY_ALLOW_ZERO_PTR))
     DBUG_RETURN(my_raw_malloc(size, my_flags));
+#if defined(MY_MSCRT_DEBUG)
+  point= _realloc_dbg(oldpoint, size, _CLIENT_BLOCK, __FILE__, __LINE__);
+#else
   point= realloc(oldpoint, size);
+#endif
 #ifndef DBUG_OFF
 end:
 #endif
@@ -254,7 +265,11 @@ static void my_raw_free(void *ptr)
 {
   DBUG_ENTER("my_free");
   DBUG_PRINT("my",("ptr: %p", ptr));
+#if defined(MY_MSCRT_DEBUG)
+  _free_dbg(ptr, _CLIENT_BLOCK);
+#else
   free(ptr);
+#endif
   DBUG_VOID_RETURN;
 }