database/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-08-07 00:04:31 +03:00
Code Activity

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

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


include/my_sys.h:
  Backport of my_malloc() changes from 5.1 to make it 64-bit safe on Unix platforms.
mysys/my_largepage.c:
  Backport of my_malloc() changes from 5.1 to make it 64-bit safe on Unix platforms.
mysys/my_malloc.c:
  Backport of my_malloc() changes from 5.1 to make it 64-bit safe on Unix platforms.
mysys/safemalloc.c:
  Backport of my_malloc() changes from 5.1 to make it 64-bit safe on Unix platforms.
This commit is contained in:
unknown
2007-08-29 19:20:18 +04:00
parent 4dac538a0b
commit ac275fd5fa
4 changed files with 40 additions and 41 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
include/my_sys.h
View File

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

12
mysys/my_largepage.c
View File

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

16
mysys/my_malloc.c
View File

@@ -23,11 +23,11 @@
/* My memory allocator */ /* My memory allocator */
gptr my_malloc(unsigned int size, myf my_flags) gptr my_malloc(size_t size, myf my_flags)
{ {
gptr point; gptr point;
DBUG_ENTER("my_malloc"); 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) if (!size)
size=1; /* Safety */ size=1; /* Safety */
@@ -63,11 +63,11 @@ void my_no_flags_free(gptr ptr)
/* malloc and copy */ /* 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; gptr ptr;
if ((ptr=my_malloc(length,my_flags)) != 0) if ((ptr=my_malloc(length,my_flags)) != 0)
memcpy((byte*) ptr, (byte*) from,(size_t) length); memcpy((byte*) ptr, (byte*)from, length);
return(ptr); 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) char *my_strdup(const char *from, myf my_flags)
{ {
gptr ptr; gptr ptr;
uint length=(uint) strlen(from)+1; size_t length= strlen(from)+1;
if ((ptr=my_malloc(length,my_flags)) != 0) 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); 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; gptr ptr;
if ((ptr=my_malloc(length+1,my_flags)) != 0) 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; ((char*) ptr)[length]=0;
} }
return((char*) ptr); return((char*) ptr);

27
mysys/safemalloc.c
View File

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