mirror of
https://github.com/MariaDB/server.git
synced 2026-05-15 19:37:16 +02:00
Merge with 4.0.14
BitKeeper/etc/logging_ok: auto-union scripts/make_win_src_distribution.old: Merge rename: scripts/make_win_src_distribution.sh -> scripts/make_win_src_distribution.old BUILD/compile-pentium-debug-max: Auto merged BitKeeper/deleted/.del-sel000001.result~383913ae4505ec86: Auto merged BitKeeper/deleted/.del-sel000001.test~9567c1646058cc: Auto merged Build-tools/Bootstrap: Auto merged Build-tools/Do-compile: Auto merged Docs/Makefile.am: Auto merged client/get_password.c: Auto merged client/mysql.cc: Auto merged client/mysqltest.c: Auto merged extra/perror.c: Auto merged include/config-win.h: Auto merged include/my_sys.h: Auto merged innobase/btr/btr0cur.c: Auto merged innobase/btr/btr0pcur.c: Auto merged innobase/buf/buf0buf.c: Auto merged innobase/buf/buf0flu.c: Auto merged innobase/dict/dict0dict.c: Auto merged innobase/dict/dict0load.c: Auto merged innobase/include/buf0buf.h: Auto merged innobase/include/log0recv.h: Auto merged innobase/include/row0sel.h: Auto merged innobase/include/srv0srv.h: Auto merged innobase/include/ut0mem.h: Auto merged innobase/lock/lock0lock.c: Auto merged innobase/log/log0log.c: Auto merged innobase/mem/mem0pool.c: Auto merged innobase/os/os0file.c: Auto merged innobase/row/row0mysql.c: Auto merged innobase/row/row0sel.c: Auto merged innobase/srv/srv0srv.c: Auto merged innobase/srv/srv0start.c: Auto merged innobase/trx/trx0sys.c: Auto merged innobase/trx/trx0trx.c: Auto merged innobase/ut/ut0mem.c: Auto merged innobase/ut/ut0ut.c: Auto merged myisam/ft_boolean_search.c: Auto merged myisam/mi_check.c: Auto merged myisam/mi_extra.c: Auto merged myisam/mi_key.c: Auto merged myisam/myisamdef.h: Auto merged myisammrg/myrg_queue.c: Auto merged mysql-test/mysql-test-run.sh: Auto merged mysql-test/r/ctype_latin1_de.result: Auto merged mysql-test/r/flush.result: Auto merged mysql-test/r/func_time.result: Auto merged mysql-test/r/grant_cache.result: Auto merged mysql-test/r/join.result: Auto merged mysql-test/r/join_outer.result: Auto merged mysql-test/r/range.result: Auto merged mysql-test/r/rpl000018.result: Auto merged mysql-test/r/rpl_insert_id.result: Auto merged mysql-test/r/rpl_master_pos_wait.result: Auto merged mysql-test/r/rpl_relayspace.result: Auto merged mysql-test/r/select_safe.result: Auto merged mysql-test/r/symlink.result: Auto merged mysql-test/r/type_date.result: Auto merged mysql-test/r/type_datetime.result: Auto merged mysql-test/t/alias.test: Auto merged mysql-test/t/ctype_latin1_de.test: Auto merged mysql-test/t/fulltext_left_join.test: Auto merged mysql-test/t/func_time.test: Auto merged mysql-test/t/handler.test: Auto merged mysql-test/t/heap.test: Auto merged mysql-test/t/join.test: Auto merged mysql-test/t/join_outer.test: Auto merged mysql-test/t/order_by.test: Auto merged mysql-test/t/range.test: Auto merged mysql-test/t/rpl000001.test: Auto merged mysql-test/t/rpl000018.test: Auto merged mysql-test/t/rpl_insert_id.test: Auto merged mysql-test/t/sel000100.test: Auto merged mysql-test/t/select_safe.test: Auto merged mysql-test/t/type_date.test: Auto merged mysql-test/t/type_datetime.test: Auto merged mysql-test/t/user_var.test: Auto merged mysys/default.c: Auto merged mysys/mf_format.c: Auto merged mysys/my_getopt.c: Auto merged mysys/thr_lock.c: Auto merged mysys/tree.c: Auto merged scripts/Makefile.am: Auto merged scripts/mysql_install_db.sh: Auto merged scripts/mysqld_safe.sh: Auto merged sql/Makefile.am: Auto merged sql/field_conv.cc: Auto merged sql/ha_innodb.h: Auto merged sql/ha_myisam.cc: Auto merged sql/ha_myisammrg.h: Auto merged sql/handler.cc: Auto merged sql/handler.h: Auto merged sql/item.h: Auto merged sql/item_func.cc: Auto merged sql/item_timefunc.cc: Auto merged sql/net_serv.cc: Auto merged sql/nt_servc.cc: Auto merged sql/opt_range.cc: Auto merged sql/sql_base.cc: Auto merged sql/sql_cache.h: Auto merged sql/sql_db.cc: Auto merged sql/sql_delete.cc: Auto merged sql/sql_insert.cc: Auto merged sql/sql_list.h: Auto merged sql/sql_load.cc: Auto merged sql/sql_rename.cc: Auto merged sql/sql_repl.h: Auto merged sql/sql_update.cc: Auto merged sql/table.cc: Auto merged sql/table.h: Auto merged sql/uniques.cc: Auto merged support-files/mysql.spec.sh: Auto merged vio/viosocket.c: Auto merged BitKeeper/deleted/.del-ctype-latin1_de.c~c5d8f9208bceb98e: merge BitKeeper/deleted/.del-mini_client.cc~8677895ec8169183: merge acinclude.m4: Merge with 4.0 (openssl patch) client/mysqlbinlog.cc: Merge with 4.0 in which we had added code from 4.1 (We are basicly only using the 4.1 code here) configure.in: Keep 4.1 file heap/hp_open.c: merge with 4.0 include/my_base.h: merge with 4.0 include/my_global.h: merge with 4.0 include/mysqld_error.h: merge with 4.0 innobase/ha/ha0ha.c: merge with 4.0 (Code should be same but we use indentaion from 4.0) innobase/log/log0recv.c: merge with 4.0 libmysql/libmysql.c: Remove with 4.0 code that was ported from 4.1 libmysqld/lib_sql.cc: merge with 4.0 myisam/mi_open.c: Remove 4.0 specific code myisam/myisamchk.c: merge with 4.0 myisammrg/myrg_rkey.c: merge with 4.0 mysql-test/r/alter_table.result: May need to be fixed after merge mysql-test/r/create.result: May need to be fixed after merge mysql-test/r/distinct.result: May need to be fixed after merge mysql-test/r/drop.result: May need to be fixed after merge mysql-test/r/fulltext.result: May need to be fixed after merge mysql-test/r/func_set.result: May need to be fixed after merge mysql-test/r/func_str.result: May need to be fixed after merge mysql-test/r/func_test.result: May need to be fixed after merge mysql-test/r/grant.result: May need to be fixed after merge mysql-test/r/group_by.result: May need to be fixed after merge mysql-test/r/handler.result: May need to be fixed after merge mysql-test/r/heap.result: May need to be fixed after merge mysql-test/r/innodb.result: May need to be fixed after merge mysql-test/r/insert.result: May need to be fixed after merge mysql-test/r/insert_select.result: May need to be fixed after merge mysql-test/r/key_diff.result: May need to be fixed after merge mysql-test/r/merge.result: May need to be fixed after merge mysql-test/r/myisam.result: May need to be fixed after merge mysql-test/r/order_by.result: May need to be fixed after merge mysql-test/r/query_cache.result: May need to be fixed after merge mysql-test/r/rpl_flush_log_loop.result: May need to be fixed after merge mysql-test/r/rpl_loaddata.result: May need to be fixed after merge mysql-test/r/rpl_log.result: May need to be fixed after merge mysql-test/r/rpl_log_pos.result: May need to be fixed after merge mysql-test/r/rpl_rotate_logs.result: May need to be fixed after merge mysql-test/r/select.result: May need to be fixed after merge mysql-test/r/union.result: May need to be fixed after merge mysql-test/r/user_var.result: May need to be fixed after merge mysql-test/t/alter_table.test: merge with 4.0 mysql-test/t/create.test: merge with 4.0 mysql-test/t/distinct.test: merge with 4.0 mysql-test/t/drop.test: merge with 4.0 mysql-test/t/flush.test: merge with 4.0 mysql-test/t/fulltext.test: merge with 4.0 mysql-test/t/func_set.test: merge with 4.0 mysql-test/t/func_str.test: merge with 4.0 mysql-test/t/func_test.test: merge with 4.0 mysql-test/t/grant.test: merge with 4.0 mysql-test/t/grant_cache.test: merge with 4.0 mysql-test/t/innodb.test: Add back EXPLAIN and SHOW KEYS statements, but make them independent of number of rows returned by InnoDB mysql-test/t/insert.test: merge with 4.0 mysql-test/t/insert_select.test: merge with 4.0 mysql-test/t/merge.test: merge with 4.0 mysql-test/t/query_cache.test: merge with 4.0 mysql-test/t/rpl_flush_log_loop.test: merge with 4.0 mysql-test/t/rpl_loaddata.test: merge with 4.0 mysql-test/t/rpl_rotate_logs.test: merge with 4.0 mysql-test/t/select.test: merge with 4.0 mysql-test/t/symlink.test: merge with 4.0 mysql-test/t/union.test: merge with 4.0 mysys/charset.c: merge with 4.0 scripts/mysql_fix_privilege_tables.sh: merge with 4.0 (Add quoting for some variables) sql/field.h: merge with 4.0 sql/ha_innodb.cc: merge with 4.0 sql/item_cmpfunc.cc: merge with 4.0 sql/item_cmpfunc.h: merge with 4.0 sql/item_func.h: merge with 4.0 sql/item_strfunc.cc: merge with 4.0 Fixed null handling with ELT() sql/item_timefunc.h: merge with 4.0 sql/lex.h: merge with 4.0 sql/log.cc: merge with 4.0 sql/log_event.cc: Merge with 4.0 Cleanups: - Indentation - #endif comments - Replace strmov() with *pos++= for two byte strings - Moved variable declarations to start of functions - Merged identical code (LOAD_EVENT) - Added casts when subtracting pointers Did a full diff between this and 4.0 to ensure that the file is correct after merge. sql/log_event.h: merge with 4.0 sql/mysql_priv.h: merge with 4.0 sql/mysqld.cc: merge with 4.0 sql/repl_failsafe.cc: merge with 4.0 sql/set_var.cc: merge with 4.0 sql/set_var.h: merge with 4.0 sql/share/czech/errmsg.txt: merge with 4.0 sql/share/danish/errmsg.txt: merge with 4.0 sql/share/dutch/errmsg.txt: merge with 4.0 sql/share/english/errmsg.txt: merge with 4.0 sql/share/estonian/errmsg.txt: merge with 4.0 sql/share/french/errmsg.txt: merge with 4.0 sql/share/german/errmsg.txt: merge with 4.0 sql/share/greek/errmsg.txt: merge with 4.0 sql/share/hungarian/errmsg.txt: merge with 4.0 sql/share/italian/errmsg.txt: merge with 4.0 sql/share/japanese/errmsg.txt: merge with 4.0 sql/share/korean/errmsg.txt: merge with 4.0 sql/share/norwegian-ny/errmsg.txt: merge with 4.0 sql/share/norwegian/errmsg.txt: merge with 4.0 sql/share/polish/errmsg.txt: merge with 4.0 sql/share/portuguese/errmsg.txt: merge with 4.0 sql/share/romanian/errmsg.txt: merge with 4.0 sql/share/russian/errmsg.txt: merge with 4.0 sql/share/slovak/errmsg.txt: merge with 4.0 sql/share/spanish/errmsg.txt: merge with 4.0 sql/share/swedish/errmsg.txt: merge with 4.0 sql/share/ukrainian/errmsg.txt: merge with 4.0 sql/slave.cc: Merge + some indentation fixes sql/slave.h: merge with 4.0 sql/sql_acl.cc: merge with 4.0 Some end space removal to make it easier to do future merges sql/sql_acl.h: merge with 4.0 sql/sql_cache.cc: merge with 4.0 sql/sql_class.h: merge with 4.0 sql/sql_handler.cc: merge with 4.0 sql/sql_lex.cc: merge with 4.0 sql/sql_lex.h: merge with 4.0 sql/sql_parse.cc: merge with 4.0 sql/sql_repl.cc: merge with 4.0 sql/sql_select.cc: merge with 4.0 sql/sql_table.cc: merge with 4.0 sql/sql_union.cc: Merge with 4.0 Note that I couldn't find out how to merge OPTION_FOUND_ROWS handling so this has to be fixed later sql/sql_yacc.yy: merge with 4.0 Removed end space to make merge easier vio/Makefile.am: merge with 4.0
This commit is contained in:
unknown
commit
034b44cb9f
363 changed files with 13808 additions and 2884 deletions
|
|
@ -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"
|
||||
|
|
|
|||
|
|
@ -105,7 +105,7 @@ my_string fn_format(my_string to, const char *name, const char *dir,
|
|||
strmov(buff,to);
|
||||
(void) my_readlink(to, buff, MYF(0));
|
||||
}
|
||||
DBUG_RETURN (to);
|
||||
DBUG_RETURN(to);
|
||||
} /* fn_format */
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -253,15 +253,27 @@ void symdirget(char *dir)
|
|||
}
|
||||
#endif /* USE_SYMDIR */
|
||||
|
||||
/* Unpacks dirname to name that can be used by open... */
|
||||
/* Make that last char of to is '/' if from not empty and
|
||||
from doesn't end in FN_DEVCHAR */
|
||||
/* Uses cleanup_dirname and changes ~/.. to home_dir/.. */
|
||||
/* Returns length of new directory */
|
||||
|
||||
/*
|
||||
Fixes a directroy name so that can be used by open()
|
||||
|
||||
SYNOPSIS
|
||||
unpack_dirname()
|
||||
to Store result here. May be = from
|
||||
from 'Packed' directory name (may contain ~)
|
||||
|
||||
IMPLEMENTATION
|
||||
Make that last char of to is '/' if from not empty and
|
||||
from doesn't end in FN_DEVCHAR
|
||||
Uses cleanup_dirname and changes ~/.. to home_dir/..
|
||||
|
||||
Changes a UNIX filename to system filename (replaces / with \ on windows)
|
||||
|
||||
RETURN
|
||||
Length of new directory name (= length of to)
|
||||
*/
|
||||
|
||||
uint unpack_dirname(my_string to, const char *from)
|
||||
|
||||
/* to may be == from */
|
||||
{
|
||||
uint length,h_length;
|
||||
char buff[FN_REFLEN+1+4],*suffix,*tilde_expansion;
|
||||
|
|
|
|||
|
|
@ -670,9 +670,9 @@ static ulonglong getopt_ull(char *arg, const struct my_option *optp, int *err)
|
|||
|
||||
ulonglong getopt_ull_limit_value(ulonglong num, const struct my_option *optp)
|
||||
{
|
||||
if ((ulonglong) num > (ulonglong) (ulong) optp->max_value &&
|
||||
if ((ulonglong) num > (ulonglong) optp->max_value &&
|
||||
optp->max_value) /* if max value is not set -> no upper limit */
|
||||
num= (ulonglong) (ulong) optp->max_value;
|
||||
num= (ulonglong) optp->max_value;
|
||||
if (optp->block_size > 1)
|
||||
{
|
||||
num/= (ulonglong) optp->block_size;
|
||||
|
|
|
|||
|
|
@ -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 */
|
||||
|
|
|
|||
|
|
@ -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 */
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* Copyright (C) 2000 MySQL AB
|
||||
/* Copyright (C) 2000-2003 MySQL AB
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
|
|
@ -69,22 +69,15 @@
|
|||
#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
|
||||
*/
|
||||
static int sf_malloc_tampered = 0;
|
||||
static int sf_malloc_tampered= 0;
|
||||
#endif
|
||||
|
||||
|
||||
|
|
@ -92,11 +85,11 @@ static int sf_malloc_tampered = 0;
|
|||
|
||||
static int check_ptr(const char *where, byte *ptr, const char *sFile,
|
||||
uint uLine);
|
||||
static int _checkchunk(struct remember *pRec, const char *sFile, uint uLine);
|
||||
static int _checkchunk(struct st_irem *pRec, const char *sFile, uint uLine);
|
||||
|
||||
/*
|
||||
Note: both these refer to the NEW'ed data only. They do not include
|
||||
malloc() roundoff or the extra space required by the remember
|
||||
Note: We only fill up the allocated block. This do not include
|
||||
malloc() roundoff or the extra space required by the irem
|
||||
structures.
|
||||
*/
|
||||
|
||||
|
|
@ -127,218 +120,211 @@ static int _checkchunk(struct remember *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;
|
||||
DBUG_ENTER("_mymalloc");
|
||||
DBUG_PRINT("enter",("Size: %u",uSize));
|
||||
struct st_irem *irem;
|
||||
char *data;
|
||||
DBUG_ENTER("_mymalloc");
|
||||
DBUG_PRINT("enter",("Size: %u",size));
|
||||
|
||||
if (!sf_malloc_quick)
|
||||
(void) _sanity (filename, lineno);
|
||||
|
||||
if (!sf_malloc_quick)
|
||||
(void) _sanity (sFile, uLine);
|
||||
|
||||
if (uSize + lCurMemory > safemalloc_mem_limit)
|
||||
pTmp = 0;
|
||||
else
|
||||
if (size + sf_malloc_cur_memory > sf_malloc_mem_limit)
|
||||
irem= 0;
|
||||
else
|
||||
{
|
||||
/* Allocate the physical memory */
|
||||
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 (!irem)
|
||||
{
|
||||
if (MyFlags & MY_FAE)
|
||||
error_handler_hook=fatal_error_handler_hook;
|
||||
if (MyFlags & (MY_FAE+MY_WME))
|
||||
{
|
||||
/* Allocate the physical memory */
|
||||
pTmp = (struct remember *) malloc (
|
||||
ALIGN_SIZE(sizeof(struct irem)) /* remember data */
|
||||
+ sf_malloc_prehunc
|
||||
+ uSize /* size requested */
|
||||
+ 4 /* overrun mark */
|
||||
+ sf_malloc_endhunc
|
||||
);
|
||||
}
|
||||
/* Check if there isn't anymore memory avaiable */
|
||||
if (pTmp == NULL)
|
||||
{
|
||||
if (MyFlags & MY_FAE)
|
||||
error_handler_hook=fatal_error_handler_hook;
|
||||
if (MyFlags & (MY_FAE+MY_WME))
|
||||
{
|
||||
char buff[SC_MAXWIDTH];
|
||||
my_errno=errno;
|
||||
sprintf(buff,"Out of memory at line %d, '%s'", uLine, sFile);
|
||||
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);
|
||||
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));
|
||||
if (MyFlags & MY_FAE)
|
||||
exit(1);
|
||||
DBUG_RETURN ((gptr) NULL);
|
||||
char buff[SC_MAXWIDTH];
|
||||
my_errno=errno;
|
||||
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)",
|
||||
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'",
|
||||
sf_malloc_max_memory,lineno, filename));
|
||||
if (MyFlags & MY_FAE)
|
||||
exit(1);
|
||||
DBUG_RETURN ((gptr) 0);
|
||||
}
|
||||
|
||||
/* Fill up the structure */
|
||||
*((long*) ((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;
|
||||
/* Fill up the structure */
|
||||
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;
|
||||
/* Add this remember structure to the linked list */
|
||||
pthread_mutex_lock(&THR_LOCK_malloc);
|
||||
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++;
|
||||
pthread_mutex_unlock(&THR_LOCK_malloc);
|
||||
/* Keep the statistics */
|
||||
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));
|
||||
/* 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]));
|
||||
/* Set the memory to the aribtrary wierd value */
|
||||
if ((MyFlags & MY_ZEROFILL) || !sf_malloc_quick)
|
||||
bfill(data, size, (char) (MyFlags & MY_ZEROFILL ? 0 : ALLOC_VAL));
|
||||
/* Return a pointer to the real data */
|
||||
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 (*((long*) ((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.
|
||||
Note: this test could fail for four reasons:
|
||||
(1) The memory was already free'ed
|
||||
(2) The memory was never new'ed
|
||||
(3) There was an underrun
|
||||
(4) A stray pointer hit this location
|
||||
(1) The memory was already free'ed
|
||||
(2) The memory was never new'ed
|
||||
(3) There was an underrun
|
||||
(4) A stray pointer hit this location
|
||||
*/
|
||||
|
||||
if (*((long*) ((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;
|
||||
} else {
|
||||
pRememberRoot = pRec -> pNext;
|
||||
}
|
||||
if (pRec -> pNext) {
|
||||
pRec -> pNext -> pPrev = pRec -> pPrev;
|
||||
}
|
||||
if (irem->prev)
|
||||
irem->prev->next= irem->next;
|
||||
else
|
||||
sf_malloc_root= irem->next;
|
||||
|
||||
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
|
||||
*((long*) ((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;
|
||||
}
|
||||
|
|
@ -346,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;
|
||||
}
|
||||
|
|
@ -356,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;
|
||||
}
|
||||
|
|
@ -372,9 +358,9 @@ static int check_ptr(const char *where, byte *ptr, const char *sFile,
|
|||
free'ed as well as the statistics.
|
||||
*/
|
||||
|
||||
void TERMINATE (FILE *file)
|
||||
void TERMINATE(FILE *file)
|
||||
{
|
||||
struct remember *pPtr;
|
||||
struct st_irem *irem;
|
||||
DBUG_ENTER("TERMINATE");
|
||||
pthread_mutex_lock(&THR_LOCK_malloc);
|
||||
|
||||
|
|
@ -384,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: %u\n",
|
||||
sf_malloc_count);
|
||||
(void) fflush(file);
|
||||
}
|
||||
DBUG_PRINT("safe",("cNewCount: %d",cNewCount));
|
||||
DBUG_PRINT("safe",("sf_malloc_count: %u", sf_malloc_count));
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -399,42 +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);
|
||||
fprintf(file, "Warning: Memory that was not free'ed (%ld bytes):\n",
|
||||
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;
|
||||
}
|
||||
|
|
@ -442,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 (*((long*) ((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);
|
||||
|
|
@ -488,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 && (int) 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;
|
||||
|
|
@ -518,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;
|
||||
|
|
|
|||
|
|
@ -220,8 +220,7 @@ void thr_end_alarm(thr_alarm_t *alarmed)
|
|||
{
|
||||
ALARM *alarm_data;
|
||||
sigset_t old_mask;
|
||||
uint i;
|
||||
my_bool found=0;
|
||||
uint i, found=0;
|
||||
DBUG_ENTER("thr_end_alarm");
|
||||
|
||||
pthread_sigmask(SIG_BLOCK,&full_signal_set,&old_mask);
|
||||
|
|
@ -235,11 +234,13 @@ void thr_end_alarm(thr_alarm_t *alarmed)
|
|||
queue_remove(&alarm_queue,i),MYF(0);
|
||||
if (alarm_data->malloced)
|
||||
my_free((gptr) alarm_data,MYF(0));
|
||||
found=1;
|
||||
found++;
|
||||
#ifndef DBUG_OFF
|
||||
break;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
DBUG_ASSERT(!*alarmed || found);
|
||||
DBUG_ASSERT(!*alarmed || found == 1);
|
||||
if (!found)
|
||||
{
|
||||
if (*alarmed)
|
||||
|
|
@ -717,7 +718,7 @@ sig_handler process_alarm(int sig __attribute__((unused)))
|
|||
}
|
||||
|
||||
|
||||
bool thr_alarm(thr_alarm_t *alrm, uint sec, ALARM *alarm)
|
||||
my_bool thr_alarm(thr_alarm_t *alrm, uint sec, ALARM *alarm)
|
||||
{
|
||||
(*alrm)= &alarm->alarmed;
|
||||
if (alarm_aborted)
|
||||
|
|
|
|||
|
|
@ -172,10 +172,13 @@ static int check_lock(struct st_lock_list *list, const char* lock_type,
|
|||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static void check_locks(THR_LOCK *lock, const char *where,
|
||||
my_bool allow_no_locks)
|
||||
{
|
||||
uint old_found_errors=found_errors;
|
||||
DBUG_ENTER("check_locks");
|
||||
|
||||
if (found_errors < MAX_FOUND_ERRORS)
|
||||
{
|
||||
if (check_lock(&lock->write,"write",where,1,1) |
|
||||
|
|
@ -252,18 +255,21 @@ static void check_locks(THR_LOCK *lock, const char *where,
|
|||
}
|
||||
if (lock->read.data)
|
||||
{
|
||||
if ((!pthread_equal(lock->write.data->thread,
|
||||
lock->read.data->thread) &&
|
||||
lock->write.data->type > TL_WRITE_DELAYED &&
|
||||
lock->write.data->type != TL_WRITE_ONLY) ||
|
||||
((lock->write.data->type == TL_WRITE_CONCURRENT_INSERT ||
|
||||
lock->write.data->type == TL_WRITE_ALLOW_WRITE) &&
|
||||
lock->read_no_write_count))
|
||||
if (!pthread_equal(lock->write.data->thread,
|
||||
lock->read.data->thread) &&
|
||||
((lock->write.data->type > TL_WRITE_DELAYED &&
|
||||
lock->write.data->type != TL_WRITE_ONLY) ||
|
||||
((lock->write.data->type == TL_WRITE_CONCURRENT_INSERT ||
|
||||
lock->write.data->type == TL_WRITE_ALLOW_WRITE) &&
|
||||
lock->read_no_write_count)))
|
||||
{
|
||||
found_errors++;
|
||||
fprintf(stderr,
|
||||
"Warning at '%s': Found lock of type %d that is write and read locked\n",
|
||||
where, lock->write.data->type);
|
||||
DBUG_PRINT("warning",("At '%s': Found lock of type %d that is write and read locked\n",
|
||||
where, lock->write.data->type));
|
||||
|
||||
}
|
||||
}
|
||||
if (lock->read_wait.data)
|
||||
|
|
@ -286,6 +292,7 @@ static void check_locks(THR_LOCK *lock, const char *where,
|
|||
DBUG_PRINT("error",("Found wrong lock"));
|
||||
}
|
||||
}
|
||||
DBUG_VOID_RETURN;
|
||||
}
|
||||
|
||||
#else /* EXTRA_DEBUG */
|
||||
|
|
|
|||
|
|
@ -109,6 +109,11 @@ void init_tree(TREE *tree, uint default_alloc_size, uint memory_limit,
|
|||
if (!free_element && size >= 0 &&
|
||||
((uint) size <= sizeof(void*) || ((uint) size & (sizeof(void*)-1))))
|
||||
{
|
||||
/*
|
||||
We know that the data doesn't have to be aligned (like if the key
|
||||
contains a double), so we can store the data combined with the
|
||||
TREE_ELEMENT.
|
||||
*/
|
||||
tree->offset_to_key=sizeof(TREE_ELEMENT); /* Put key after element */
|
||||
/* Fix allocation size so that we don't lose any memory */
|
||||
default_alloc_size/=(sizeof(TREE_ELEMENT)+size);
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue