Backport of my_malloc() changes from 5.1 to make it 64-bit safe on Unix platforms. (39e53b4f) · Commits · Software / OSDI20 Artifacts / mariadb

include/my_sys.h

+13 −13

Original line number	Diff line number	Diff line
		@@ -147,13 +147,13 @@ 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,
		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))
		@@ -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,
		extern gptr _mymalloc(size_t uSize, const char *sFile,
		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);
		extern gptr my_multi_malloc _VARARGS((myf MyFlags, ...));
		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,
		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

+6 −6

Original line number	Diff line number	Diff line
		@@ -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 @@ uint my_get_large_page_size_int(void)
		#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

+8 −8

Original line number	Diff line number	Diff line
		@@ -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

+13 −14

Original line number	Diff line number	Diff line
		@@ -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,7 +207,7 @@ gptr _mymalloc(uint size, const char *filename, uint lineno, myf MyFlags)
		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)
		{
		struct st_irem *irem;
		@@ -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,7 +502,7 @@ int _sanity(const char *filename, uint lineno)

		/* 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)
		{
		gptr ptr;
		@@ -517,14 +516,14 @@ 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,
		char _my_strdup_with_length(const char from, size_t length,
		const char *filename, uint lineno,
		myf MyFlags)
		{