Skip to content

M
MariaDB
Commit ecdb1c76 authored by monty@narttu.mysql.fi's avatar monty@narttu.mysql.fi
Browse files
Options

Changed safemalloc structure to not have to be 8 byte aligned. (Portability problem)

parent a79bdf2e
Hide whitespace changes
Inline Side-by-side
Showing with 173 additions and 188 deletions
include/my_sys.h
View file @ ecdb1c76
......@@ -138,7 +138,7 @@ extern int NEAR my_errno; /* Last error in mysys */
#define QUICK_SAFEMALLOC sf_malloc_quick=1
#define NORMAL_SAFEMALLOC sf_malloc_quick=0
extern uint sf_malloc_prehunc,sf_malloc_endhunc,sf_malloc_quick;
extern ulonglong safemalloc_mem_limit;
extern ulonglong sf_malloc_mem_limit;
#define CALLER_INFO_PROTO , const char *sFile, uint uLine
#define CALLER_INFO , __FILE__, __LINE__
......@@ -239,7 +239,7 @@ extern int NEAR my_umask, /* Default creation mask */
NEAR my_safe_to_handle_signal, /* Set when allowed to SIGTSTP */
NEAR my_dont_interrupt; /* call remember_intr when set */
extern my_bool NEAR mysys_uses_curses, my_use_symdir;
extern long lCurMemory,lMaxMemory; /* from safemalloc */
extern ulong sf_malloc_cur_memory, sf_malloc_max_memory;
extern ulong my_default_record_cache_size;
extern my_bool NEAR my_disable_locking,NEAR my_disable_async_io,
......
mysys/default.c
View file @ ecdb1c76
......@@ -33,8 +33,6 @@
** --print-defaults ; Print the modified command line and exit
****************************************************************************/
#undef SAFEMALLOC /* safe_malloc is not yet initailized */
#include "mysys_priv.h"
#include "m_string.h"
#include "m_ctype.h"
......
mysys/my_static.c
View file @ ecdb1c76
......@@ -69,14 +69,13 @@ uint sf_malloc_prehunc=0, /* If you have problem with core- */
sf_malloc_endhunc=0, /* dump when malloc-message.... */
/* set theese to 64 or 128 */
sf_malloc_quick=0; /* set if no calls to sanity */
long lCurMemory = 0L; /* Current memory usage */
long lMaxMemory = 0L; /* Maximum memory usage */
uint cNewCount = 0; /* Number of times NEW() was called */
ulong sf_malloc_cur_memory= 0L; /* Current memory usage */
ulong sf_malloc_max_memory= 0L; /* Maximum memory usage */
uint sf_malloc_count= 0; /* Number of times NEW() was called */
byte *sf_min_adress= (byte*) ~(unsigned long) 0L,
*sf_max_adress= (byte*) 0L;
/* Root of the linked list of remembers */
struct remember *pRememberRoot = NULL;
/* Root of the linked list of struct st_irem */
struct st_irem *sf_malloc_root = NULL;
/* from my_alarm */
int volatile my_have_got_alarm=0; /* declare variable to reset */
......
mysys/my_static.h
View file @ ecdb1c76
......@@ -33,27 +33,23 @@ struct st_remember {
};
/*
The size of the following structure MUST be dividable by 8 to not cause
alignment problems on some cpu's
Structure that stores information of a allocated memory block
The data is at &struct_adr+sizeof(ALIGN_SIZE(sizeof(struct irem)))
The lspecialvalue is at the previous 4 bytes from this, which may not
necessarily be in the struct if the struct size isn't aligned at a 8 byte
boundary.
*/
struct irem
struct st_irem
{
struct remember *_pNext; /* Linked list of structures */
struct remember *_pPrev; /* Other link */
char *_sFileName; /* File in which memory was new'ed */
uint32 _uLineNum; /* Line number in above file */
uint32 _uDataSize; /* Size requested */
#if SIZEOF_CHARP == 8
long _filler; /* For alignment */
#endif
long _lSpecialValue; /* Underrun marker value */
struct st_irem *next; /* Linked list of structures */
struct st_irem *prev; /* Other link */
char *filename; /* File in which memory was new'ed */
uint32 linenum; /* Line number in above file */
uint32 datasize; /* Size requested */
uint32 SpecialValue; /* Underrun marker value */
};
struct remember {
struct irem tInt;
char aData[1];
};
extern char NEAR curr_dir[FN_REFLEN],NEAR home_dir_buff[FN_REFLEN];
......@@ -70,8 +66,8 @@ extern int _my_tempnam_used;
#endif
extern byte *sf_min_adress,*sf_max_adress;
extern uint cNewCount;
extern struct remember *pRememberRoot;
extern uint sf_malloc_count;
extern struct st_irem *sf_malloc_root;
#if defined(THREAD) && !defined(__WIN__)
extern sigset_t my_signals; /* signals blocked by mf_brkhant */
......
mysys/safemalloc.c
View file @ ecdb1c76
......@@ -69,18 +69,11 @@
#include "my_static.h"
#include "mysys_err.h"
ulonglong safemalloc_mem_limit= ~(ulonglong)0;
#define pNext tInt._pNext
#define pPrev tInt._pPrev
#define sFileName tInt._sFileName
#define uLineNum tInt._uLineNum
#define uDataSize tInt._uDataSize
#define lSpecialValue tInt._lSpecialValue
ulonglong sf_malloc_mem_limit= ~(ulonglong)0;
#ifndef PEDANTIC_SAFEMALLOC
/*
Set to 1 after TERMINATE() if we had to fiddle with cNewCount and
Set to 1 after TERMINATE() if we had to fiddle with sf_malloc_count and
the linked list of blocks so that _sanity() will not fuss when it
is not supposed to
*/
......@@ -92,7 +85,7 @@ static int sf_malloc_tampered= 0;
static int check_ptr(const char *where, byte *ptr, const char *sFile,
uint uLine);
static int _checkchunk(struct irem *pRec, const char *sFile, uint uLine);
static int _checkchunk(struct st_irem *pRec, const char *sFile, uint uLine);
/*
Note: We only fill up the allocated block. This do not include
......@@ -127,29 +120,29 @@ static int _checkchunk(struct irem *pRec, const char *sFile, uint uLine);
/* Allocate some memory. */
gptr _mymalloc(uint uSize, const char *sFile, uint uLine, myf MyFlags)
gptr _mymalloc(uint size, const char *filename, uint lineno, myf MyFlags)
{
struct remember *pTmp;
struct st_irem *irem;
char *data;
DBUG_ENTER("_mymalloc");
DBUG_PRINT("enter",("Size: %u",uSize));
DBUG_PRINT("enter",("Size: %u",size));
if (!sf_malloc_quick)
(void) _sanity (sFile, uLine);
(void) _sanity (filename, lineno);
if (uSize + lCurMemory > safemalloc_mem_limit)
pTmp= 0;
if (size + sf_malloc_cur_memory > sf_malloc_mem_limit)
irem= 0;
else
{
/* Allocate the physical memory */
pTmp= (struct remember *) malloc (ALIGN_SIZE(sizeof(struct irem)) +
sf_malloc_prehunc +
uSize + /* size requested */
4 + /* overrun mark */
sf_malloc_endhunc
);
irem= (struct st_irem *) malloc (ALIGN_SIZE(sizeof(struct st_irem)) +
sf_malloc_prehunc +
size + /* size requested */
4 + /* overrun mark */
sf_malloc_endhunc);
}
/* Check if there isn't anymore memory avaiable */
if (pTmp == NULL)
if (!irem)
{
if (MyFlags & MY_FAE)
error_handler_hook=fatal_error_handler_hook;
......@@ -157,126 +150,127 @@ gptr _mymalloc(uint uSize, const char *sFile, uint uLine, myf MyFlags)
{
char buff[SC_MAXWIDTH];
my_errno=errno;
sprintf(buff,"Out of memory at line %d, '%s'", uLine, sFile);
sprintf(buff,"Out of memory at line %d, '%s'", lineno, filename);
my_message(EE_OUTOFMEMORY,buff,MYF(ME_BELL+ME_WAITTANG));
sprintf(buff,"needed %d byte (%ldk), memory in use: %ld bytes (%ldk)",
uSize, (uSize + 1023L) / 1024L,
lMaxMemory, (lMaxMemory + 1023L) / 1024L);
size, (size + 1023L) / 1024L,
sf_malloc_max_memory, (sf_malloc_max_memory + 1023L) / 1024L);
my_message(EE_OUTOFMEMORY,buff,MYF(ME_BELL+ME_WAITTANG));
}
DBUG_PRINT("error",("Out of memory, in use: %ld at line %d, '%s'",
lMaxMemory,uLine, sFile));
sf_malloc_max_memory,lineno, filename));
if (MyFlags & MY_FAE)
exit(1);
DBUG_RETURN ((gptr) NULL);
DBUG_RETURN ((gptr) 0);
}
/* Fill up the structure */
*((uint32*) ((char*) &pTmp->lSpecialValue+sf_malloc_prehunc))= MAGICKEY;
pTmp->aData[uSize + sf_malloc_prehunc+0]= MAGICEND0;
pTmp->aData[uSize + sf_malloc_prehunc+1]= MAGICEND1;
pTmp->aData[uSize + sf_malloc_prehunc+2]= MAGICEND2;
pTmp->aData[uSize + sf_malloc_prehunc+3]= MAGICEND3;
pTmp->sFileName= (my_string) sFile;
pTmp->uLineNum= uLine;
pTmp->uDataSize= uSize;
pTmp->pPrev= NULL;
data= (((char*) irem) + ALIGN_SIZE(sizeof(struct st_irem)) +
sf_malloc_prehunc);
*((uint32*) (data-sizeof(uint32)))= MAGICKEY;
data[size + 0]= MAGICEND0;
data[size + 1]= MAGICEND1;
data[size + 2]= MAGICEND2;
data[size + 3]= MAGICEND3;
irem->filename= (my_string) filename;
irem->linenum= lineno;
irem->datasize= size;
irem->prev= NULL;
/* Add this remember structure to the linked list */
pthread_mutex_lock(&THR_LOCK_malloc);
if ((pTmp->pNext= pRememberRoot))
pRememberRoot->pPrev= pTmp;
pRememberRoot= pTmp;
if ((irem->next= sf_malloc_root))
sf_malloc_root->prev= irem;
sf_malloc_root= irem;
/* Keep the statistics */
lCurMemory+= uSize;
if (lCurMemory > lMaxMemory)
lMaxMemory= lCurMemory;
cNewCount++;
sf_malloc_cur_memory+= size;
if (sf_malloc_cur_memory > sf_malloc_max_memory)
sf_malloc_max_memory= sf_malloc_cur_memory;
sf_malloc_count++;
pthread_mutex_unlock(&THR_LOCK_malloc);
/* Set the memory to the aribtrary wierd value */
if ((MyFlags & MY_ZEROFILL) || !sf_malloc_quick)
bfill(&pTmp->aData[sf_malloc_prehunc],uSize,
(char) (MyFlags & MY_ZEROFILL ? 0 : ALLOC_VAL));
bfill(data, size, (char) (MyFlags & MY_ZEROFILL ? 0 : ALLOC_VAL));
/* Return a pointer to the real data */
DBUG_PRINT("exit",("ptr: %lx",&(pTmp->aData[sf_malloc_prehunc])));
if (sf_min_adress > &(pTmp->aData[sf_malloc_prehunc]))
sf_min_adress= &(pTmp->aData[sf_malloc_prehunc]);
if (sf_max_adress < &(pTmp->aData[sf_malloc_prehunc]))
sf_max_adress= &(pTmp->aData[sf_malloc_prehunc]);
DBUG_RETURN ((gptr) &(pTmp->aData[sf_malloc_prehunc]));
DBUG_PRINT("exit",("ptr: %lx", data));
if (sf_min_adress > data)
sf_min_adress= data;
if (sf_max_adress < data)
sf_max_adress= data;
DBUG_RETURN ((gptr) data);
}
/*
Allocate some new memory and move old memoryblock there.
Free then old memoryblock
*/
gptr _myrealloc(register gptr pPtr, register uint uSize,
const char *sFile, uint uLine, myf MyFlags)
gptr _myrealloc(register gptr ptr, register uint size,
const char *filename, uint lineno, myf MyFlags)
{
struct remember *pRec;
gptr ptr;
struct st_irem *irem;
char *data;
DBUG_ENTER("_myrealloc");
if (!pPtr && (MyFlags & MY_ALLOW_ZERO_PTR))
DBUG_RETURN(_mymalloc(uSize,sFile,uLine,MyFlags));
if (!ptr && (MyFlags & MY_ALLOW_ZERO_PTR))
DBUG_RETURN(_mymalloc(size, filename, lineno, MyFlags));
if (!sf_malloc_quick)
(void) _sanity (sFile, uLine);
(void) _sanity (filename, lineno);
if (check_ptr("Reallocating",(byte*) pPtr,sFile,uLine))
if (check_ptr("Reallocating", (byte*) ptr, filename, lineno))
DBUG_RETURN((gptr) NULL);
pRec= (struct remember *) ((char*) pPtr - ALIGN_SIZE(sizeof(struct irem))-
sf_malloc_prehunc);
if (*((uint32*) ((char*) &pRec->lSpecialValue+sf_malloc_prehunc))
!= MAGICKEY)
irem= (struct st_irem *) (((char*) ptr) - ALIGN_SIZE(sizeof(struct st_irem))-
sf_malloc_prehunc);
if (*((uint32*) (((char*) ptr)- sizeof(uint32))) != MAGICKEY)
{
fprintf(stderr, "Error: Reallocating unallocated data at line %d, '%s'\n",
uLine, sFile);
lineno, filename);
DBUG_PRINT("safe",("Reallocating unallocated data at line %d, '%s'",
uLine, sFile));
lineno, filename));
(void) fflush(stderr);
DBUG_RETURN((gptr) NULL);
}
if ((ptr=_mymalloc(uSize,sFile,uLine,MyFlags))) /* Allocate new area */
if ((data= _mymalloc(size,filename,lineno,MyFlags))) /* Allocate new area */
{
uSize=min(uSize,pRec-> uDataSize); /* Move as much as possibly */
memcpy((byte*) ptr,pPtr,(size_t) uSize); /* Copy old data */
_myfree(pPtr,sFile,uLine,0); /* Free not needed area */
size=min(size, irem->datasize); /* Move as much as possibly */
memcpy((byte*) data, ptr, (size_t) size); /* Copy old data */
_myfree(ptr, filename, lineno, 0); /* Free not needed area */
}
else
{
if (MyFlags & MY_HOLD_ON_ERROR)
DBUG_RETURN(pPtr);
DBUG_RETURN(ptr);
if (MyFlags & MY_FREE_ON_ERROR)
_myfree(pPtr,sFile,uLine,0);
_myfree(ptr, filename, lineno, 0);
}
DBUG_RETURN(ptr);
DBUG_RETURN(data);
} /* _myrealloc */
/* Deallocate some memory. */
void _myfree(gptr pPtr, const char *sFile, uint uLine, myf myflags)
void _myfree(gptr ptr, const char *filename, uint lineno, myf myflags)
{
struct remember *pRec;
struct st_irem *irem;
DBUG_ENTER("_myfree");
DBUG_PRINT("enter",("ptr: %lx",pPtr));
DBUG_PRINT("enter",("ptr: %lx", ptr));
if (!sf_malloc_quick)
(void) _sanity (sFile, uLine);
(void) _sanity (filename, lineno);
if ((!pPtr && (myflags & MY_ALLOW_ZERO_PTR)) ||
check_ptr("Freeing",(byte*) pPtr,sFile,uLine))
if ((!ptr && (myflags & MY_ALLOW_ZERO_PTR)) ||
check_ptr("Freeing",(byte*) ptr,filename,lineno))
DBUG_VOID_RETURN;
/* Calculate the address of the remember structure */
pRec= (struct remember *) ((byte*) pPtr- ALIGN_SIZE(sizeof(struct irem))-
sf_malloc_prehunc);
irem= (struct st_irem *) ((char*) ptr- ALIGN_SIZE(sizeof(struct st_irem))-
sf_malloc_prehunc);
/*
Check to make sure that we have a real remember structure.
......@@ -287,52 +281,50 @@ void _myfree(gptr pPtr, const char *sFile, uint uLine, myf myflags)
(4) A stray pointer hit this location
*/
if (*((uint32*) ((char*) &pRec->lSpecialValue+sf_malloc_prehunc))
!= MAGICKEY)
if (*((uint32*) ((char*) ptr- sizeof(uint32))) != MAGICKEY)
{
fprintf(stderr, "Error: Freeing unallocated data at line %d, '%s'\n",
uLine, sFile);
DBUG_PRINT("safe",("Unallocated data at line %d, '%s'",uLine,sFile));
lineno, filename);
DBUG_PRINT("safe",("Unallocated data at line %d, '%s'",lineno,filename));
(void) fflush(stderr);
DBUG_VOID_RETURN;
}
/* Remove this structure from the linked list */
pthread_mutex_lock(&THR_LOCK_malloc);
if (pRec->pPrev)
pRec->pPrev->pNext= pRec->pNext;
if (irem->prev)
irem->prev->next= irem->next;
else
pRememberRoot= pRec->pNext;
sf_malloc_root= irem->next;
if (pRec->pNext)
pRec->pNext->pPrev= pRec->pPrev;
if (irem->next)
irem->next->prev= irem->prev;
/* Handle the statistics */
lCurMemory -= pRec->uDataSize;
cNewCount--;
sf_malloc_cur_memory-= irem->datasize;
sf_malloc_count--;
pthread_mutex_unlock(&THR_LOCK_malloc);
#ifndef HAVE_purify
/* Mark this data as free'ed */
if (!sf_malloc_quick)
bfill(&pRec->aData[sf_malloc_prehunc],pRec->uDataSize,(pchar) FREE_VAL);
bfill(ptr, irem->datasize, (pchar) FREE_VAL);
#endif
*((uint32*) ((char*) &pRec->lSpecialValue+sf_malloc_prehunc))= ~MAGICKEY;
*((uint32*) ((char*) ptr- sizeof(uint32)))= ~MAGICKEY;
/* Actually free the memory */
free ((my_string ) pRec);
free((char*) irem);
DBUG_VOID_RETURN;
}
/* Check if we have a wrong pointer */
static int check_ptr(const char *where, byte *ptr, const char *sFile,
uint uLine)
static int check_ptr(const char *where, byte *ptr, const char *filename,
uint lineno)
{
if (!ptr)
{
fprintf(stderr, "Error: %s NULL pointer at line %d, '%s'\n",
where,uLine, sFile);
DBUG_PRINT("safe",("Null pointer at line %d '%s'", uLine, sFile));
where,lineno, filename);
DBUG_PRINT("safe",("Null pointer at line %d '%s'", lineno, filename));
(void) fflush(stderr);
return 1;
}
......@@ -340,9 +332,9 @@ static int check_ptr(const char *where, byte *ptr, const char *sFile,
if ((long) ptr & (ALIGN_SIZE(1)-1))
{
fprintf(stderr, "Error: %s wrong aligned pointer at line %d, '%s'\n",
where,uLine, sFile);
where,lineno, filename);
DBUG_PRINT("safe",("Wrong aligned pointer at line %d, '%s'",
uLine,sFile));
lineno,filename));
(void) fflush(stderr);
return 1;
}
......@@ -350,9 +342,9 @@ static int check_ptr(const char *where, byte *ptr, const char *sFile,
if (ptr < sf_min_adress || ptr > sf_max_adress)
{
fprintf(stderr, "Error: %s pointer out of range at line %d, '%s'\n",
where,uLine, sFile);
where,lineno, filename);
DBUG_PRINT("safe",("Pointer out of range at line %d '%s'",
uLine,sFile));
lineno,filename));
(void) fflush(stderr);
return 1;
}
......@@ -368,7 +360,7 @@ static int check_ptr(const char *where, byte *ptr, const char *sFile,
void TERMINATE(FILE *file)
{
struct remember *pPtr;
struct st_irem *irem;
DBUG_ENTER("TERMINATE");
pthread_mutex_lock(&THR_LOCK_malloc);
......@@ -378,14 +370,15 @@ void TERMINATE(FILE *file)
NEWs than FREEs. <0, etc.
*/
if (cNewCount)
if (sf_malloc_count)
{
if (file)
{
fprintf(file, "Warning: Not freed memory segments: %d\n", cNewCount);
fprintf(file, "Warning: Not freed memory segments: %d\n",
sf_malloc_count);
(void) fflush(file);
}
DBUG_PRINT("safe",("cNewCount: %d",cNewCount));
DBUG_PRINT("safe",("sf_malloc_count: %d", sf_malloc_count));
}
/*
......@@ -393,43 +386,44 @@ void TERMINATE(FILE *file)
but not free'ed with FREE.
*/
if ((pPtr=pRememberRoot))
if ((irem= sf_malloc_root))
{
if (file)
{
fprintf(file, "Warning: Memory that was not free'ed (%ld bytes):\n",
lCurMemory);
sf_malloc_cur_memory);
(void) fflush(file);
}
DBUG_PRINT("safe",("Memory that was not free'ed (%ld bytes):",lCurMemory));
while (pPtr)
DBUG_PRINT("safe",("Memory that was not free'ed (%ld bytes):",
sf_malloc_cur_memory));
while (irem)
{
char *data= (((char*) irem) + ALIGN_SIZE(sizeof(struct st_irem)) +
sf_malloc_prehunc);
if (file)
{
fprintf(file,
"\t%6u bytes at 0x%09lx, allocated at line %4u in '%s'",
pPtr->uDataSize,
(ulong) &(pPtr->aData[sf_malloc_prehunc]),
pPtr->uLineNum, pPtr->sFileName);
irem->datasize, (long) data, irem->linenum, irem->filename);
fprintf(file, "\n");
(void) fflush(file);
}
DBUG_PRINT("safe",
("%6u bytes at 0x%09lx, allocated at line %4d in '%s'",
pPtr->uDataSize, &(pPtr->aData[sf_malloc_prehunc]),
pPtr->uLineNum, pPtr->sFileName));
pPtr= pPtr->pNext;
irem->datasize, data, irem->linenum, irem->filename));
irem= irem->next;
}
}
/* Report the memory usage statistics */
if (file)
{
fprintf(file, "Maximum memory usage: %ld bytes (%ldk)\n",
lMaxMemory, (lMaxMemory + 1023L) / 1024L);
sf_malloc_max_memory, (sf_malloc_max_memory + 1023L) / 1024L);
(void) fflush(file);
}
DBUG_PRINT("safe",("Maximum memory usage: %ld bytes (%ldk)",
lMaxMemory, (lMaxMemory + 1023L) / 1024L));
sf_malloc_max_memory, (sf_malloc_max_memory + 1023L) /
1024L));
pthread_mutex_unlock(&THR_LOCK_malloc);
DBUG_VOID_RETURN;
}
......@@ -437,44 +431,41 @@ void TERMINATE(FILE *file)
/* Returns 0 if chunk is ok */
static int _checkchunk(register struct remember *pRec, const char *sFile,
uint uLine)
static int _checkchunk(register struct st_irem *irem, const char *filename,
uint lineno)
{
reg1 uint uSize;
reg2 my_string magicp;
reg3 int flag=0;
int flag=0;
char *magicp, *data;
data= (((char*) irem) + ALIGN_SIZE(sizeof(struct st_irem)) +
sf_malloc_prehunc);
/* Check for a possible underrun */
if (*((uint32*) ((char*) &pRec->lSpecialValue+sf_malloc_prehunc))
!= MAGICKEY)
if (*((uint32*) (data- sizeof(uint32))) != MAGICKEY)
{
fprintf(stderr, "Error: Memory allocated at %s:%d was underrun,",
pRec->sFileName, pRec->uLineNum);
fprintf(stderr, " discovered at %s:%d\n", sFile, uLine);
irem->filename, irem->linenum);
fprintf(stderr, " discovered at %s:%d\n", filename, lineno);
(void) fflush(stderr);
DBUG_PRINT("safe",("Underrun at %lx, allocated at %s:%d",
&(pRec->aData[sf_malloc_prehunc]),
pRec->sFileName,
pRec->uLineNum));
data, irem->filename, irem->linenum));
flag=1;
}
/* Check for a possible overrun */
uSize= pRec->uDataSize;
magicp= &(pRec->aData[uSize+sf_malloc_prehunc]);
magicp= data + irem->datasize;
if (*magicp++ != MAGICEND0 ||
*magicp++ != MAGICEND1 ||
*magicp++ != MAGICEND2 ||
*magicp++ != MAGICEND3)
{
fprintf(stderr, "Error: Memory allocated at %s:%d was overrun,",
pRec->sFileName, pRec->uLineNum);
fprintf(stderr, " discovered at '%s:%d'\n", sFile, uLine);
irem->filename, irem->linenum);
fprintf(stderr, " discovered at '%s:%d'\n", filename, lineno);
(void) fflush(stderr);
DBUG_PRINT("safe",("Overrun at %lx, allocated at %s:%d",
&(pRec->aData[sf_malloc_prehunc]),
pRec->sFileName,
pRec->uLineNum));
data,
irem->filename,
irem->linenum));
flag=1;
}
return(flag);
......@@ -483,28 +474,28 @@ static int _checkchunk(register struct remember *pRec, const char *sFile,
/* Returns how many wrong chunks */
int _sanity(const char *sFile, uint uLine)
int _sanity(const char *filename, uint lineno)
{
reg1 struct remember *pTmp;
reg1 struct st_irem *irem;
reg2 int flag=0;
uint count=0;
pthread_mutex_lock(&THR_LOCK_malloc);
#ifndef PEDANTIC_SAFEMALLOC
if (sf_malloc_tampered && cNewCount < 0)
cNewCount=0;
if (sf_malloc_tampered && sf_malloc_count < 0)
sf_malloc_count=0;
#endif
count=cNewCount;
for (pTmp= pRememberRoot; pTmp != NULL && count-- ; pTmp= pTmp->pNext)
flag+= _checkchunk (pTmp, sFile, uLine);
count=sf_malloc_count;
for (irem= sf_malloc_root; irem != NULL && count-- ; irem= irem->next)
flag+= _checkchunk (irem, filename, lineno);
pthread_mutex_unlock(&THR_LOCK_malloc);
if (count || pTmp)
if (count || irem)
{
const char *format="Error: Safemalloc link list destroyed, discovered at '%s:%d'";
fprintf(stderr, format, sFile, uLine); fputc('\n',stderr);
fprintf(stderr, "root=%p,count=%d,pTmp=%p\n", pRememberRoot,count,pTmp);
fprintf(stderr, format, filename, lineno); fputc('\n',stderr);
fprintf(stderr, "root=%p,count=%d,irem=%p\n", sf_malloc_root,count,irem);
(void) fflush(stderr);
DBUG_PRINT("safe",(format, sFile, uLine));
DBUG_PRINT("safe",(format, filename, lineno));
flag=1;
}
return flag;
......@@ -513,33 +504,33 @@ int _sanity(const char *sFile, uint uLine)
/* malloc and copy */
gptr _my_memdup(const byte *from, uint length, const char *sFile, uint uLine,
myf MyFlags)
gptr _my_memdup(const byte *from, uint length, const char *filename,
uint lineno, myf MyFlags)
{
gptr ptr;
if ((ptr=_mymalloc(length,sFile,uLine,MyFlags)) != 0)
if ((ptr=_mymalloc(length,filename,lineno,MyFlags)) != 0)
memcpy((byte*) ptr, (byte*) from,(size_t) length);
return(ptr);
} /*_my_memdup */
char *_my_strdup(const char *from, const char *sFile, uint uLine,
char *_my_strdup(const char *from, const char *filename, uint lineno,
myf MyFlags)
{
gptr ptr;
uint length=(uint) strlen(from)+1;
if ((ptr=_mymalloc(length,sFile,uLine,MyFlags)) != 0)
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 byte *from, uint length,
const char *sFile, uint uLine,
const char *filename, uint lineno,
myf MyFlags)
{
gptr ptr;
if ((ptr=_mymalloc(length+1,sFile,uLine,MyFlags)) != 0)
if ((ptr=_mymalloc(length+1,filename,lineno,MyFlags)) != 0)
{
memcpy((byte*) ptr, (byte*) from,(size_t) length);
ptr[length]=0;
......
sql/mysqld.cc
View file @ ecdb1c76
......@@ -4292,7 +4292,7 @@ get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
break;
case OPT_SAFEMALLOC_MEM_LIMIT:
#if !defined(DBUG_OFF) && defined(SAFEMALLOC)
safemalloc_mem_limit = atoi(argument);
sf_malloc_mem_limit = atoi(argument);
#endif
break;
#ifdef EMBEDDED_LIBRARY
......
sql/sql_parse.cc
View file @ ecdb1c76
......@@ -1208,9 +1208,10 @@ bool dispatch_command(enum enum_server_command command, THD *thd,
opened_tables,refresh_version, cached_tables(),
uptime ? (float)thd->query_id/(float)uptime : 0);
#ifdef SAFEMALLOC
if (lCurMemory) // Using SAFEMALLOC
if (sf_malloc_cur_memory) // Using SAFEMALLOC
sprintf(strend(buff), " Memory in use: %ldK Max memory used: %ldK",
(lCurMemory+1023L)/1024L,(lMaxMemory+1023L)/1024L);
(sf_malloc_cur_memory+1023L)/1024L,
(sf_malloc_max_memory+1023L)/1024L);
#endif
VOID(my_net_write(net, buff,(uint) strlen(buff)));
VOID(net_flush(net));
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7