List:Commits« Previous MessageNext Message »
From:Alexey Kopytov Date:August 29 2007 3:20pm
Subject:bk commit into 5.0 tree (kaa:1.2512) BUG#5731
View as plain text  
Below is the list of changes that have just been committed into a local
5.0 repository of kaa. When kaa 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@stripped, 2007-08-29 19:20:18+04:00, kaa@stripped +4 -0
  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@stripped, 2007-08-29 19:20:12+04:00, kaa@stripped +13 -13
    Backport of my_malloc() changes from 5.1 to make it 64-bit safe on Unix platforms.

  mysys/my_largepage.c@stripped, 2007-08-29 19:20:12+04:00, kaa@stripped +6 -6
    Backport of my_malloc() changes from 5.1 to make it 64-bit safe on Unix platforms.

  mysys/my_malloc.c@stripped, 2007-08-29 19:20:12+04:00, kaa@stripped +8 -8
    Backport of my_malloc() changes from 5.1 to make it 64-bit safe on Unix platforms.

  mysys/safemalloc.c@stripped, 2007-08-29 19:20:12+04:00, kaa@stripped +13 -14
    Backport of my_malloc() changes from 5.1 to make it 64-bit safe on Unix platforms.

diff -Nrup a/include/my_sys.h b/include/my_sys.h
--- a/include/my_sys.h	2007-05-17 11:48:09 +04:00
+++ b/include/my_sys.h	2007-08-29 19:20:12 +04:00
@@ -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
 
 #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
 		      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);
 
diff -Nrup a/mysys/my_largepage.c b/mysys/my_largepage.c
--- a/mysys/my_largepage.c	2006-12-23 22:04:07 +03:00
+++ b/mysys/my_largepage.c	2007-08-29 19:20:12 +04:00
@@ -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 
   /* 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);
   }
diff -Nrup a/mysys/my_malloc.c b/mysys/my_malloc.c
--- a/mysys/my_malloc.c	2007-04-12 13:46:05 +04:00
+++ b/mysys/my_malloc.c	2007-08-29 19:20:12 +04:00
@@ -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 le
 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);
diff -Nrup a/mysys/safemalloc.c b/mysys/safemalloc.c
--- a/mysys/safemalloc.c	2007-04-12 13:46:05 +04:00
+++ b/mysys/safemalloc.c	2007-08-29 19:20:12 +04:00
@@ -119,12 +119,12 @@ static int _checkchunk(struct st_irem *p
 
 /* 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 *fi
       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 *fi
   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 l
 
 	/* 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
 		 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)
Thread
bk commit into 5.0 tree (kaa:1.2512) BUG#5731Alexey Kopytov29 Aug