Backport of my_malloc() changes from 5.1 to make it 64-bit safe on Unix platforms.

This is required to allow key_buffer_size > 4 GB (bug #5731).

include/my_sys.h

@@ -147,14 +147,14 @@ extern ulonglong sf_malloc_mem_limit;
 #define TERMINATE(A) {}
 #define QUICK_SAFEMALLOC
 #define NORMAL_SAFEMALLOC
-extern gptr my_malloc(uint Size,myf MyFlags);
+extern gptr my_malloc(size_t Size, myf MyFlags);
 #define my_malloc_ci(SZ,FLAG) my_malloc( SZ, FLAG )
 extern gptr my_realloc(gptr oldpoint,uint Size,myf MyFlags);
 extern void my_no_flags_free(gptr ptr);
-extern gptr my_memdup(const byte *from,uint length,myf MyFlags);
+extern gptr my_memdup(const byte *from, size_t length, myf MyFlags);
 extern char *my_strdup(const char *from,myf MyFlags);
-extern char *my_strdup_with_length(const char *from, uint length,
-				   myf MyFlags);
+extern char *my_strdup_with_length(const char *from, size_t length,
+                                   myf MyFlags);
 /* we do use FG (as a no-op) in below so that a typo on FG is caught */
 #define my_free(PTR,FG) ((void)FG,my_no_flags_free(PTR))
 #define CALLER_INFO_PROTO   /* nothing */
@@ -165,7 +165,7 @@ extern char *my_strdup_with_length(const char *from, uint length,
 
 #ifdef HAVE_LARGE_PAGES
 extern uint my_get_large_page_size(void);
-extern gptr my_large_malloc(uint size, myf my_flags);
+extern gptr my_large_malloc(size_t size, myf my_flags);
 extern void my_large_free(gptr ptr, myf my_flags);
 #else
 #define my_get_large_page_size() (0)
@@ -590,18 +590,18 @@ extern uint my_fwrite(FILE *stream,const byte *Buffer,uint Count,
 		      myf MyFlags);
 extern my_off_t my_fseek(FILE *stream,my_off_t pos,int whence,myf MyFlags);
 extern my_off_t my_ftell(FILE *stream,myf MyFlags);
-extern gptr _mymalloc(uint uSize,const char *sFile,
-		      uint uLine, myf MyFlag);
-extern gptr _myrealloc(gptr pPtr,uint uSize,const char *sFile,
-		       uint uLine, myf MyFlag);
+extern gptr _mymalloc(size_t uSize, const char *sFile,
+                       uint uLine, myf MyFlag);
+extern gptr _myrealloc(gptr pPtr, size_t uSize, const char *sFile,
+                        uint uLine, myf MyFlag);
 extern gptr my_multi_malloc _VARARGS((myf MyFlags, ...));
-extern void _myfree(gptr pPtr,const char *sFile,uint uLine, myf MyFlag);
+extern void _myfree(gptr pPtr, const char *sFile, uint uLine, myf MyFlag);
 extern int _sanity(const char *sFile,unsigned int uLine);
-extern gptr _my_memdup(const byte *from,uint length,
-		       const char *sFile, uint uLine,myf MyFlag);
+extern gptr _my_memdup(const byte *from, size_t length,
+                        const char *sFile, uint uLine, myf MyFlag);
 extern my_string _my_strdup(const char *from, const char *sFile, uint uLine,
 			    myf MyFlag);
-extern char *_my_strdup_with_length(const char *from, uint length,
+extern char *_my_strdup_with_length(const char *from, size_t length,
 				    const char *sFile, uint uLine,
 				    myf MyFlag);
 

mysys/my_largepage.c

@@ -26,7 +26,7 @@
 #endif
 
 static uint my_get_large_page_size_int(void);
-static gptr my_large_malloc_int(uint size, myf my_flags);
+static gptr my_large_malloc_int(size_t size, myf my_flags);
 static my_bool my_large_free_int(gptr ptr, myf my_flags);
 
 /* Gets the size of large pages from the OS */
@@ -48,7 +48,7 @@ uint my_get_large_page_size(void)
   my_malloc_lock() in case of failure
 */
 
-gptr my_large_malloc(uint size, myf my_flags)
+gptr my_large_malloc(size_t size, myf my_flags)
 {
   gptr ptr;
   DBUG_ENTER("my_large_malloc");
@@ -113,7 +113,7 @@ finish:
 #if HAVE_DECL_SHM_HUGETLB
 /* Linux-specific large pages allocator  */
     
-gptr my_large_malloc_int(uint size, myf my_flags)
+gptr my_large_malloc_int(size_t size, myf my_flags)
 {
   int shmid;
   gptr ptr;
@@ -123,13 +123,13 @@ gptr my_large_malloc_int(uint size, myf my_flags)
   /* Align block size to my_large_page_size */
   size = ((size - 1) & ~(my_large_page_size - 1)) + my_large_page_size;
   
-  shmid = shmget(IPC_PRIVATE, (size_t)size, SHM_HUGETLB | SHM_R | SHM_W);
+  shmid = shmget(IPC_PRIVATE, size, SHM_HUGETLB | SHM_R | SHM_W);
   if (shmid < 0)
   {
     if (my_flags & MY_WME)
       fprintf(stderr,
-              "Warning: Failed to allocate %d bytes from HugeTLB memory."
-              " errno %d\n", size, errno);
+              "Warning: Failed to allocate %lu bytesx from HugeTLB memory."
+              " errno %d\n", (ulong) size, errno);
 
     DBUG_RETURN(NULL);
   }

mysys/my_malloc.c

@@ -23,11 +23,11 @@
 
 	/* My memory allocator */
 
-gptr my_malloc(unsigned int size, myf my_flags)
+gptr my_malloc(size_t size, myf my_flags)
 {
   gptr point;
   DBUG_ENTER("my_malloc");
-  DBUG_PRINT("my",("size: %u  my_flags: %d",size, my_flags));
+  DBUG_PRINT("my",("size: %lu  my_flags: %d", (ulong) size, my_flags));
 
   if (!size)
     size=1;					/* Safety */
@@ -63,11 +63,11 @@ void my_no_flags_free(gptr ptr)
 
 	/* malloc and copy */
 
-gptr my_memdup(const byte *from, uint length, myf my_flags)
+gptr my_memdup(const byte *from, size_t length, myf my_flags)
 {
   gptr ptr;
   if ((ptr=my_malloc(length,my_flags)) != 0)
-    memcpy((byte*) ptr, (byte*) from,(size_t) length);
+    memcpy((byte*) ptr, (byte*)from, length);
   return(ptr);
 }
 
@@ -75,19 +75,19 @@ gptr my_memdup(const byte *from, uint length, myf my_flags)
 char *my_strdup(const char *from, myf my_flags)
 {
   gptr ptr;
-  uint length=(uint) strlen(from)+1;
+  size_t length= strlen(from)+1;
   if ((ptr=my_malloc(length,my_flags)) != 0)
-    memcpy((byte*) ptr, (byte*) from,(size_t) length);
+    memcpy((byte*) ptr, (byte*) from, length);
   return((my_string) ptr);
 }
 
 
-char *my_strdup_with_length(const char *from, uint length, myf my_flags)
+char *my_strdup_with_length(const char *from, size_t length, myf my_flags)
 {
   gptr ptr;
   if ((ptr=my_malloc(length+1,my_flags)) != 0)
   {
-    memcpy((byte*) ptr, (byte*) from,(size_t) length);
+    memcpy((byte*) ptr, (byte*) from, length);
     ((char*) ptr)[length]=0;
   }
   return((char*) ptr);

mysys/safemalloc.c

@@ -119,12 +119,12 @@ static int _checkchunk(struct st_irem *pRec, const char *sFile, uint uLine);
 
 /* Allocate some memory. */
 
-gptr _mymalloc(uint size, const char *filename, uint lineno, myf MyFlags)
+gptr _mymalloc(size_t size, const char *filename, uint lineno, myf MyFlags)
 {
   struct st_irem *irem;
   char *data;
   DBUG_ENTER("_mymalloc");
-  DBUG_PRINT("enter",("Size: %u",size));
+  DBUG_PRINT("enter",("Size: %lu", (ulong) size));
 
   if (!sf_malloc_quick)
     (void) _sanity (filename, lineno);
@@ -151,8 +151,8 @@ gptr _mymalloc(uint size, const char *filename, uint lineno, myf MyFlags)
       my_errno=errno;
       sprintf(buff,"Out of memory at line %d, '%s'", lineno, filename);
       my_message(EE_OUTOFMEMORY, buff, MYF(ME_BELL+ME_WAITTANG+ME_NOREFRESH));
-      sprintf(buff,"needed %d byte (%ldk), memory in use: %ld bytes (%ldk)",
-	      size, (size + 1023L) / 1024L,
+      sprintf(buff,"needed %u byte (%ldk), memory in use: %ld bytes (%ldk)",
+	      (uint) size, (uint) (size + 1023L) / 1024L,
 	      sf_malloc_max_memory, (sf_malloc_max_memory + 1023L) / 1024L);
       my_message(EE_OUTOFMEMORY, buff, MYF(ME_BELL+ME_WAITTANG+ME_NOREFRESH));
     }
@@ -207,8 +207,8 @@ gptr _mymalloc(uint size, const char *filename, uint lineno, myf MyFlags)
   Free then old memoryblock
 */
 
-gptr _myrealloc(register gptr ptr, register uint size,
-		const char *filename, uint lineno, myf MyFlags)
+gptr _myrealloc(register gptr ptr, register size_t size,
+                const char *filename, uint lineno, myf MyFlags)
 {
   struct st_irem *irem;
   char *data;
@@ -373,8 +373,7 @@ void TERMINATE(FILE *file)
   {
     if (file)
     {
-      fprintf(file, "Warning: Not freed memory segments: %u\n",
-	      sf_malloc_count);
+      fprintf(file, "Warning: Not freed memory segments: %u\n", sf_malloc_count);
       (void) fflush(file);
     }
     DBUG_PRINT("safe",("sf_malloc_count: %u", sf_malloc_count));
@@ -503,8 +502,8 @@ int _sanity(const char *filename, uint lineno)
 
 	/* malloc and copy */
 
-gptr _my_memdup(const byte *from, uint length, const char *filename,
-		uint lineno, myf MyFlags)
+gptr _my_memdup(const byte *from, size_t length, const char *filename,
+                  uint lineno, myf MyFlags)
 {
   gptr ptr;
   if ((ptr=_mymalloc(length,filename,lineno,MyFlags)) != 0)
@@ -517,16 +516,16 @@ char *_my_strdup(const char *from, const char *filename, uint lineno,
 		 myf MyFlags)
 {
   gptr ptr;
-  uint length=(uint) strlen(from)+1;
+  size_t length= strlen(from)+1;
   if ((ptr=_mymalloc(length,filename,lineno,MyFlags)) != 0)
     memcpy((byte*) ptr, (byte*) from,(size_t) length);
   return((char*) ptr);
 } /* _my_strdup */
 
 
-char *_my_strdup_with_length(const char *from, uint length,
-			     const char *filename, uint lineno,
-			     myf MyFlags)
+char *_my_strdup_with_length(const char *from, size_t length,
+                  const char *filename, uint lineno,
+                  myf MyFlags)
 {
   gptr ptr;
   if ((ptr=_mymalloc(length+1,filename,lineno,MyFlags)) != 0)