Skip to content
Projects
Groups
Snippets
Help
Loading...
Help
Support
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in / Register
Toggle navigation
M
mariadb
Project overview
Project overview
Details
Activity
Releases
Repository
Repository
Files
Commits
Branches
Tags
Contributors
Graph
Compare
Issues
0
Issues
0
List
Boards
Labels
Milestones
Merge Requests
0
Merge Requests
0
Analytics
Analytics
Repository
Value Stream
Wiki
Wiki
Snippets
Snippets
Members
Members
Collapse sidebar
Close sidebar
Activity
Graph
Create a new issue
Commits
Issue Boards
Open sidebar
Kirill Smelkov
mariadb
Commits
1b6cb012
Commit
1b6cb012
authored
Dec 28, 2011
by
Marko Mäkelä
Browse files
Options
Browse Files
Download
Plain Diff
Merge mysql-5.1 to mysql-5.5.
parents
dcd00587
e498a1bf
Changes
7
Hide whitespace changes
Inline
Side-by-side
Showing
7 changed files
with
8 additions
and
140 deletions
+8
-140
storage/innobase/buf/buf0buf.c
storage/innobase/buf/buf0buf.c
+1
-4
storage/innobase/include/mem0mem.ic
storage/innobase/include/mem0mem.ic
+0
-4
storage/innobase/include/univ.i
storage/innobase/include/univ.i
+0
-17
storage/innobase/include/ut0mem.h
storage/innobase/include/ut0mem.h
+5
-26
storage/innobase/mem/mem0pool.c
storage/innobase/mem/mem0pool.c
+1
-5
storage/innobase/os/os0proc.c
storage/innobase/os/os0proc.c
+0
-3
storage/innobase/ut/ut0mem.c
storage/innobase/ut/ut0mem.c
+1
-81
No files found.
storage/innobase/buf/buf0buf.c
View file @
1b6cb012
...
@@ -989,11 +989,8 @@ buf_chunk_init(
...
@@ -989,11 +989,8 @@ buf_chunk_init(
for
(
i
=
chunk
->
size
;
i
--
;
)
{
for
(
i
=
chunk
->
size
;
i
--
;
)
{
buf_block_init
(
buf_pool
,
block
,
frame
);
buf_block_init
(
buf_pool
,
block
,
frame
);
UNIV_MEM_INVALID
(
block
->
frame
,
UNIV_PAGE_SIZE
);
#ifdef HAVE_purify
/* Wipe contents of frame to eliminate a Purify warning */
memset
(
block
->
frame
,
'\0'
,
UNIV_PAGE_SIZE
);
#endif
/* Add the block to the free list */
/* Add the block to the free list */
UT_LIST_ADD_LAST
(
list
,
buf_pool
->
free
,
(
&
block
->
page
));
UT_LIST_ADD_LAST
(
list
,
buf_pool
->
free
,
(
&
block
->
page
));
...
...
storage/innobase/include/mem0mem.ic
View file @
1b6cb012
...
@@ -208,10 +208,6 @@ mem_heap_alloc(
...
@@ -208,10 +208,6 @@ mem_heap_alloc(
caller */
caller */
buf = (byte*)buf + MEM_FIELD_HEADER_SIZE;
buf = (byte*)buf + MEM_FIELD_HEADER_SIZE;
#endif
#ifdef UNIV_SET_MEM_TO_ZERO
UNIV_MEM_ALLOC(buf, n);
memset(buf, '\0', n);
#endif
#endif
UNIV_MEM_ALLOC(buf, n);
UNIV_MEM_ALLOC(buf, n);
return(buf);
return(buf);
...
...
storage/innobase/include/univ.i
View file @
1b6cb012
...
@@ -154,14 +154,6 @@ resolved */
...
@@ -154,14 +154,6 @@ resolved */
/* DEBUG VERSION CONTROL
/* DEBUG VERSION CONTROL
===================== */
===================== */
/* The following flag will make InnoDB to initialize
all memory it allocates to zero. It hides Purify
warnings about reading unallocated memory unless
memory is read outside the allocated blocks. */
/*
#define UNIV_INIT_MEM_TO_ZERO
*/
/* When this macro is defined then additional test functions will be
/* When this macro is defined then additional test functions will be
compiled. These functions live at the end of each relevant source file
compiled. These functions live at the end of each relevant source file
and have "test_" prefix. These functions are not called from anywhere in
and have "test_" prefix. These functions are not called from anywhere in
...
@@ -231,15 +223,6 @@ operations (very slow); also UNIV_DEBUG must be defined */
...
@@ -231,15 +223,6 @@ operations (very slow); also UNIV_DEBUG must be defined */
#
define
UNIV_BTR_DEBUG
/* check B-tree links */
#
define
UNIV_BTR_DEBUG
/* check B-tree links */
#
define
UNIV_LIGHT_MEM_DEBUG
/* light memory debugging */
#
define
UNIV_LIGHT_MEM_DEBUG
/* light memory debugging */
#
ifdef
HAVE_purify
/* The following sets all new allocated memory to zero before use:
this can be used to eliminate unnecessary Purify warnings, but note that
it also masks many bugs Purify could detect. For detailed Purify analysis it
is best to remove the define below and look through the warnings one
by one. */
#
define
UNIV_SET_MEM_TO_ZERO
#
endif
/*
/*
#define UNIV_SQL_DEBUG
#define UNIV_SQL_DEBUG
#define UNIV_LOG_DEBUG
#define UNIV_LOG_DEBUG
...
...
storage/innobase/include/ut0mem.h
View file @
1b6cb012
...
@@ -78,40 +78,19 @@ ut_mem_init(void);
...
@@ -78,40 +78,19 @@ ut_mem_init(void);
/*=============*/
/*=============*/
/**********************************************************************//**
/**********************************************************************//**
Allocates memory. Sets it also to zero if UNIV_SET_MEM_TO_ZERO is
Allocates memory.
defined and set_to_zero is TRUE.
@return own: allocated memory */
@return own: allocated memory */
UNIV_INTERN
UNIV_INTERN
void
*
void
*
ut_malloc_low
(
ut_malloc_low
(
/*==========*/
/*==========*/
ulint
n
,
/*!< in: number of bytes to allocate */
ulint
n
,
/*!< in: number of bytes to allocate */
ibool
set_to_zero
,
/*!< in: TRUE if allocated memory
ibool
assert_on_error
)
/*!< in: if TRUE, we crash mysqld if
should be set to zero if
UNIV_SET_MEM_TO_ZERO is defined */
ibool
assert_on_error
);
/*!< in: if TRUE, we crash mysqld if
the memory cannot be allocated */
the memory cannot be allocated */
__attribute__
((
malloc
));
/**********************************************************************//**
/**********************************************************************//**
Allocates memory. Sets it also to zero if UNIV_SET_MEM_TO_ZERO is
Allocates memory. */
defined.
#define ut_malloc(n) ut_malloc_low(n, TRUE)
@return own: allocated memory */
UNIV_INTERN
void
*
ut_malloc
(
/*======*/
ulint
n
);
/*!< in: number of bytes to allocate */
#ifndef UNIV_HOTBACKUP
/**********************************************************************//**
Tests if malloc of n bytes would succeed. ut_malloc() asserts if memory runs
out. It cannot be used if we want to return an error message. Prints to
stderr a message if fails.
@return TRUE if succeeded */
UNIV_INTERN
ibool
ut_test_malloc
(
/*===========*/
ulint
n
);
/*!< in: try to allocate this many bytes */
#endif
/* !UNIV_HOTBACKUP */
/**********************************************************************//**
/**********************************************************************//**
Frees a memory block allocated with ut_malloc. Freeing a NULL pointer is
Frees a memory block allocated with ut_malloc. Freeing a NULL pointer is
a nop. */
a nop. */
...
...
storage/innobase/mem/mem0pool.c
View file @
1b6cb012
...
@@ -228,11 +228,7 @@ mem_pool_create(
...
@@ -228,11 +228,7 @@ mem_pool_create(
pool
=
ut_malloc
(
sizeof
(
mem_pool_t
));
pool
=
ut_malloc
(
sizeof
(
mem_pool_t
));
/* We do not set the memory to zero (FALSE) in the pool,
pool
->
buf
=
ut_malloc_low
(
size
,
TRUE
);
but only when allocated at a higher level in mem0mem.c.
This is to avoid masking useful Purify warnings. */
pool
->
buf
=
ut_malloc_low
(
size
,
FALSE
,
TRUE
);
pool
->
size
=
size
;
pool
->
size
=
size
;
mutex_create
(
mem_pool_mutex_key
,
&
pool
->
mutex
,
SYNC_MEM_POOL
);
mutex_create
(
mem_pool_mutex_key
,
&
pool
->
mutex
,
SYNC_MEM_POOL
);
...
...
storage/innobase/os/os0proc.c
View file @
1b6cb012
...
@@ -111,9 +111,6 @@ os_mem_alloc_large(
...
@@ -111,9 +111,6 @@ os_mem_alloc_large(
os_fast_mutex_lock
(
&
ut_list_mutex
);
os_fast_mutex_lock
(
&
ut_list_mutex
);
ut_total_allocated_memory
+=
size
;
ut_total_allocated_memory
+=
size
;
os_fast_mutex_unlock
(
&
ut_list_mutex
);
os_fast_mutex_unlock
(
&
ut_list_mutex
);
# ifdef UNIV_SET_MEM_TO_ZERO
memset
(
ptr
,
'\0'
,
size
);
# endif
UNIV_MEM_ALLOC
(
ptr
,
size
);
UNIV_MEM_ALLOC
(
ptr
,
size
);
return
(
ptr
);
return
(
ptr
);
}
}
...
...
storage/innobase/ut/ut0mem.c
View file @
1b6cb012
...
@@ -84,17 +84,13 @@ ut_mem_init(void)
...
@@ -84,17 +84,13 @@ ut_mem_init(void)
#endif
/* !UNIV_HOTBACKUP */
#endif
/* !UNIV_HOTBACKUP */
/**********************************************************************//**
/**********************************************************************//**
Allocates memory. Sets it also to zero if UNIV_SET_MEM_TO_ZERO is
Allocates memory.
defined and set_to_zero is TRUE.
@return own: allocated memory */
@return own: allocated memory */
UNIV_INTERN
UNIV_INTERN
void
*
void
*
ut_malloc_low
(
ut_malloc_low
(
/*==========*/
/*==========*/
ulint
n
,
/*!< in: number of bytes to allocate */
ulint
n
,
/*!< in: number of bytes to allocate */
ibool
set_to_zero
,
/*!< in: TRUE if allocated memory should be
set to zero if UNIV_SET_MEM_TO_ZERO is
defined */
ibool
assert_on_error
)
/*!< in: if TRUE, we crash mysqld if the
ibool
assert_on_error
)
/*!< in: if TRUE, we crash mysqld if the
memory cannot be allocated */
memory cannot be allocated */
{
{
...
@@ -106,12 +102,6 @@ ut_malloc_low(
...
@@ -106,12 +102,6 @@ ut_malloc_low(
ret
=
malloc
(
n
);
ret
=
malloc
(
n
);
ut_a
(
ret
||
!
assert_on_error
);
ut_a
(
ret
||
!
assert_on_error
);
#ifdef UNIV_SET_MEM_TO_ZERO
if
(
set_to_zero
)
{
memset
(
ret
,
'\0'
,
n
);
UNIV_MEM_ALLOC
(
ret
,
n
);
}
#endif
return
(
ret
);
return
(
ret
);
}
}
...
@@ -193,12 +183,6 @@ retry:
...
@@ -193,12 +183,6 @@ retry:
}
}
}
}
if
(
set_to_zero
)
{
#ifdef UNIV_SET_MEM_TO_ZERO
memset
(
ret
,
'\0'
,
n
+
sizeof
(
ut_mem_block_t
));
#endif
}
UNIV_MEM_ALLOC
(
ret
,
n
+
sizeof
(
ut_mem_block_t
));
UNIV_MEM_ALLOC
(
ret
,
n
+
sizeof
(
ut_mem_block_t
));
((
ut_mem_block_t
*
)
ret
)
->
size
=
n
+
sizeof
(
ut_mem_block_t
);
((
ut_mem_block_t
*
)
ret
)
->
size
=
n
+
sizeof
(
ut_mem_block_t
);
...
@@ -215,74 +199,10 @@ retry:
...
@@ -215,74 +199,10 @@ retry:
void
*
ret
=
malloc
(
n
);
void
*
ret
=
malloc
(
n
);
ut_a
(
ret
||
!
assert_on_error
);
ut_a
(
ret
||
!
assert_on_error
);
# ifdef UNIV_SET_MEM_TO_ZERO
if
(
set_to_zero
)
{
memset
(
ret
,
'\0'
,
n
);
}
# endif
return
(
ret
);
return
(
ret
);
#endif
/* !UNIV_HOTBACKUP */
#endif
/* !UNIV_HOTBACKUP */
}
}
/**********************************************************************//**
Allocates memory. Sets it also to zero if UNIV_SET_MEM_TO_ZERO is
defined.
@return own: allocated memory */
UNIV_INTERN
void
*
ut_malloc
(
/*======*/
ulint
n
)
/*!< in: number of bytes to allocate */
{
#ifndef UNIV_HOTBACKUP
return
(
ut_malloc_low
(
n
,
TRUE
,
TRUE
));
#else
/* !UNIV_HOTBACKUP */
return
(
malloc
(
n
));
#endif
/* !UNIV_HOTBACKUP */
}
#ifndef UNIV_HOTBACKUP
/**********************************************************************//**
Tests if malloc of n bytes would succeed. ut_malloc() asserts if memory runs
out. It cannot be used if we want to return an error message. Prints to
stderr a message if fails.
@return TRUE if succeeded */
UNIV_INTERN
ibool
ut_test_malloc
(
/*===========*/
ulint
n
)
/*!< in: try to allocate this many bytes */
{
void
*
ret
;
ret
=
malloc
(
n
);
if
(
ret
==
NULL
)
{
ut_print_timestamp
(
stderr
);
fprintf
(
stderr
,
" InnoDB: Error: cannot allocate"
" %lu bytes of memory for
\n
"
"InnoDB: a BLOB with malloc! Total allocated memory
\n
"
"InnoDB: by InnoDB %lu bytes."
" Operating system errno: %d
\n
"
"InnoDB: Check if you should increase"
" the swap file or
\n
"
"InnoDB: ulimits of your operating system.
\n
"
"InnoDB: On FreeBSD check you have"
" compiled the OS with
\n
"
"InnoDB: a big enough maximum process size.
\n
"
,
(
ulong
)
n
,
(
ulong
)
ut_total_allocated_memory
,
(
int
)
errno
);
return
(
FALSE
);
}
free
(
ret
);
return
(
TRUE
);
}
#endif
/* !UNIV_HOTBACKUP */
/**********************************************************************//**
/**********************************************************************//**
Frees a memory block allocated with ut_malloc. Freeing a NULL pointer is
Frees a memory block allocated with ut_malloc. Freeing a NULL pointer is
a nop. */
a nop. */
...
...
Write
Preview
Markdown
is supported
0%
Try again
or
attach a new file
Attach a file
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment