mirror of
https://github.com/MariaDB/server.git
synced 2025-01-19 13:32:33 +01:00
780f80be16
* Fix BUG#15650: "DELETE with LEFT JOIN crashes server with innodb_locks_unsafe_for binlog"
* Fix BUG#17134: "Partitions: uncommitted changes are visible"
* Fix BUG#17992: "Partitions: InnoDB, somehow rotten table after UPDATE"
row0ins.c: MySQL's partitioned table code does not set preduilt->sql_stat_start right
if it does an insert in the same statement after doing a search first in the same
partition table. We now write trx id always to the buffer, not just when flag
sql_stat_start is on. This will waste CPU time very sightly.
* Fix BUG#18077: "InnoDB uses full explicit table locks in stored FUNCTION"
* Fix BUG#18238: "When locks exhaust the buffer pool, InnoDB does not roll back the trx"
* Fix BUG#18252" "Disk space leak in updates of InnoDB BLOB rows in 5.0 and 5.1"
* Fix BUG#18283: "When InnoDB returns error 'lock table full', MySQL can write to binlog too much"
* Fix BUG#18350: "Use consistent read in CREATE ... SELECT ... if innodb_locks_unsafe_for_binlog"
* Fix BUG#18384: "InnoDB memory leak on duplicate key errors in 5.0 if row has many columns"
* Fix BUG#18934: "InnoDB crashes when table uses column names like DB_ROW_ID"
Refuse tables that use reserved column names.
* InnoDB's SQL parser:
- Add support for UNSIGNED types, EXIT keyword, quoted identifiers, user-function callbacks
for processing results of FETCH statements, bound literals, DATA_VARCHAR for bound literals.
- Allow bound literals of type non-INTEGER to be of length 0.
- Add make_flex.sh and update lexer/parser generation documentation.
- Add comment clarifying the difference between 'alias' and 'indirection' fields in sym_node_t.
- Remove never reached duplicate code in pars_set_dfield_type().
- Rewrite pars_info datatypes and APIs, add a few helper functions.
- Since the functions definitions in pars_info_t are accessed after pars_sql() returns
in the query graph execution stage, we can't free pars_info_t in pars_sql(). Instead,
make pars_sql() transfer ownership of pars_info_t to the created query graph, and
make que_graph_free() free it if needed.
- Allow access to system columns like DB_ROW_ID.
* Use bound literals in row_truncate_table_for_mysql, row_drop_table_for_mysql,
row_discard_tablespace_for_mysql, and row_rename_table_for_mysql.
* Setting an isolation level of the transaction to read committed weakens the locks for
this session similarly like the option innodb_locks_unsafe_for binlog. This patch removes
alnost all gap locking (used in next-key locking) and makes MySQL to release the row locks
on the rows which does not belong to result set. Additionally, nonlocking selects on
INSERT INTO SELECT, UPDATE ... (SELECT ...), and CREATE ... SELECT ... use a nonlocking
consistent read. If a binlog is used, then binlog format should be set to row based
binloging to make the execution of the complex SQL statements.
* Disable the statistic variables btr_search_n_hash_fail and n_hash_succ, n_hash_fail,
n_patt_succ, and n_searches of btr_search_t in builds without #ifdef UNIV_SEARCH_PERF_STAT.
* Make innodb.test faster. Group all consistent read test cases to a one test case and
wait their lock timeout after all have been send to the server. Decrease amount of rows
inserted in a certain test - this has no effect on the effectiveness of the test and
reduces the running time by ~10 sec. Remove temporary work-arounds from innodb.result
now that ALTER TABLE DROP FOREIGN KEY works once again.
* Make innodb_unsafe_binlog.test faster. Grout all consistent read test cases to a one
test case amd wait their lock timeout after all have been sent to the server. Remove
unnecessary option --loose_innodb_lock_wait_timeout.
* Print dictionary memory size in SHOW INNODB STATUS.
* Fix memory leaks in row_create_table_for_mysql() in rare corner cases.
* Remove code related to clustered tables. They were never implemented, and the
implementation would be challenging with ROW_FORMAT=COMPACT. Remove the table types
DICT_TABLE_CLUSTER_MEMBER and DICT_TABLE_CLUSTER and all related tests and functions.
dict_table_t: Remove mix_id, mix_len, mix_id_len, mix_id_buf, and cluster_name.
plan_t: Remove mixed_index.
dict_create_sys_tables_tuple(): Set MIX_ID=0, MIX_LEN=0, CLUSTER_NAME=NULL when
inserting into SYS_TABLES.
dict_tree_check_search_tuple(): Enclose in #ifdef UNIV_DEBUG.
* Move calling of thr_local_free() from trx_free_for_mysql() to
innobase_close_connection().
385 lines
14 KiB
C
385 lines
14 KiB
C
/******************************************************
|
|
The memory management
|
|
|
|
(c) 1994, 1995 Innobase Oy
|
|
|
|
Created 6/9/1994 Heikki Tuuri
|
|
*******************************************************/
|
|
|
|
#ifndef mem0mem_h
|
|
#define mem0mem_h
|
|
|
|
#include "univ.i"
|
|
#include "ut0mem.h"
|
|
#include "ut0byte.h"
|
|
#include "ut0ut.h"
|
|
#include "ut0rnd.h"
|
|
#include "sync0sync.h"
|
|
#include "ut0lst.h"
|
|
#include "mach0data.h"
|
|
|
|
/* -------------------- MEMORY HEAPS ----------------------------- */
|
|
|
|
/* The info structure stored at the beginning of a heap block */
|
|
typedef struct mem_block_info_struct mem_block_info_t;
|
|
|
|
/* A block of a memory heap consists of the info structure
|
|
followed by an area of memory */
|
|
typedef mem_block_info_t mem_block_t;
|
|
|
|
/* A memory heap is a nonempty linear list of memory blocks */
|
|
typedef mem_block_t mem_heap_t;
|
|
|
|
/* Types of allocation for memory heaps: DYNAMIC means allocation from the
|
|
dynamic memory pool of the C compiler, BUFFER means allocation from the
|
|
buffer pool; the latter method is used for very big heaps */
|
|
|
|
#define MEM_HEAP_DYNAMIC 0 /* the most common type */
|
|
#define MEM_HEAP_BUFFER 1
|
|
#define MEM_HEAP_BTR_SEARCH 2 /* this flag can optionally be
|
|
ORed to MEM_HEAP_BUFFER, in which
|
|
case heap->free_block is used in
|
|
some cases for memory allocations,
|
|
and if it's NULL, the memory
|
|
allocation functions can return
|
|
NULL. */
|
|
|
|
/* The following start size is used for the first block in the memory heap if
|
|
the size is not specified, i.e., 0 is given as the parameter in the call of
|
|
create. The standard size is the maximum (payload) size of the blocks used for
|
|
allocations of small buffers. */
|
|
|
|
#define MEM_BLOCK_START_SIZE 64
|
|
#define MEM_BLOCK_STANDARD_SIZE 8000
|
|
|
|
/* If a memory heap is allowed to grow into the buffer pool, the following
|
|
is the maximum size for a single allocated buffer: */
|
|
#define MEM_MAX_ALLOC_IN_BUF (UNIV_PAGE_SIZE - 200)
|
|
|
|
/**********************************************************************
|
|
Initializes the memory system. */
|
|
|
|
void
|
|
mem_init(
|
|
/*=====*/
|
|
ulint size); /* in: common pool size in bytes */
|
|
/******************************************************************
|
|
Use this macro instead of the corresponding function! Macro for memory
|
|
heap creation. */
|
|
|
|
#define mem_heap_create(N) mem_heap_create_func(\
|
|
(N), NULL, MEM_HEAP_DYNAMIC, __FILE__, __LINE__)
|
|
/******************************************************************
|
|
Use this macro instead of the corresponding function! Macro for memory
|
|
heap creation. */
|
|
|
|
#define mem_heap_create_in_buffer(N) mem_heap_create_func(\
|
|
(N), NULL, MEM_HEAP_BUFFER, __FILE__, __LINE__)
|
|
/******************************************************************
|
|
Use this macro instead of the corresponding function! Macro for memory
|
|
heap creation. */
|
|
|
|
#define mem_heap_create_in_btr_search(N) mem_heap_create_func(\
|
|
(N), NULL, MEM_HEAP_BTR_SEARCH | MEM_HEAP_BUFFER,\
|
|
__FILE__, __LINE__)
|
|
/******************************************************************
|
|
Use this macro instead of the corresponding function! Macro for fast
|
|
memory heap creation. An initial block of memory B is given by the
|
|
caller, N is its size, and this memory block is not freed by
|
|
mem_heap_free. See the parameter comment in mem_heap_create_func below. */
|
|
|
|
#define mem_heap_fast_create(N, B) mem_heap_create_func(\
|
|
(N), (B), MEM_HEAP_DYNAMIC, __FILE__, __LINE__)
|
|
|
|
/******************************************************************
|
|
Use this macro instead of the corresponding function! Macro for memory
|
|
heap freeing. */
|
|
|
|
#define mem_heap_free(heap) mem_heap_free_func(\
|
|
(heap), __FILE__, __LINE__)
|
|
/*********************************************************************
|
|
NOTE: Use the corresponding macros instead of this function. Creates a
|
|
memory heap. For debugging purposes, takes also the file name and line as
|
|
arguments. */
|
|
UNIV_INLINE
|
|
mem_heap_t*
|
|
mem_heap_create_func(
|
|
/*=================*/
|
|
/* out, own: memory heap, NULL if
|
|
did not succeed (only possible for
|
|
MEM_HEAP_BTR_SEARCH type heaps)*/
|
|
ulint n, /* in: desired start block size,
|
|
this means that a single user buffer
|
|
of size n will fit in the block,
|
|
0 creates a default size block;
|
|
if init_block is not NULL, n tells
|
|
its size in bytes */
|
|
void* init_block, /* in: if very fast creation is
|
|
wanted, the caller can reserve some
|
|
memory from its stack, for example,
|
|
and pass it as the the initial block
|
|
to the heap: then no OS call of malloc
|
|
is needed at the creation. CAUTION:
|
|
the caller must make sure the initial
|
|
block is not unintentionally erased
|
|
(if allocated in the stack), before
|
|
the memory heap is explicitly freed. */
|
|
ulint type, /* in: heap type */
|
|
const char* file_name, /* in: file name where created */
|
|
ulint line); /* in: line where created */
|
|
/*********************************************************************
|
|
NOTE: Use the corresponding macro instead of this function. Frees the space
|
|
occupied by a memory heap. In the debug version erases the heap memory
|
|
blocks. */
|
|
UNIV_INLINE
|
|
void
|
|
mem_heap_free_func(
|
|
/*===============*/
|
|
mem_heap_t* heap, /* in, own: heap to be freed */
|
|
const char* file_name, /* in: file name where freed */
|
|
ulint line); /* in: line where freed */
|
|
/*******************************************************************
|
|
Allocates n bytes of memory from a memory heap. */
|
|
UNIV_INLINE
|
|
void*
|
|
mem_heap_alloc(
|
|
/*===========*/
|
|
/* out: allocated storage, NULL if did not
|
|
succeed (only possible for
|
|
MEM_HEAP_BTR_SEARCH type heaps) */
|
|
mem_heap_t* heap, /* in: memory heap */
|
|
ulint n); /* in: number of bytes; if the heap is allowed
|
|
to grow into the buffer pool, this must be
|
|
<= MEM_MAX_ALLOC_IN_BUF */
|
|
/*********************************************************************
|
|
Returns a pointer to the heap top. */
|
|
UNIV_INLINE
|
|
byte*
|
|
mem_heap_get_heap_top(
|
|
/*==================*/
|
|
/* out: pointer to the heap top */
|
|
mem_heap_t* heap); /* in: memory heap */
|
|
/*********************************************************************
|
|
Frees the space in a memory heap exceeding the pointer given. The
|
|
pointer must have been acquired from mem_heap_get_heap_top. The first
|
|
memory block of the heap is not freed. */
|
|
UNIV_INLINE
|
|
void
|
|
mem_heap_free_heap_top(
|
|
/*===================*/
|
|
mem_heap_t* heap, /* in: heap from which to free */
|
|
byte* old_top);/* in: pointer to old top of heap */
|
|
/*********************************************************************
|
|
Empties a memory heap. The first memory block of the heap is not freed. */
|
|
UNIV_INLINE
|
|
void
|
|
mem_heap_empty(
|
|
/*===========*/
|
|
mem_heap_t* heap); /* in: heap to empty */
|
|
/*********************************************************************
|
|
Returns a pointer to the topmost element in a memory heap.
|
|
The size of the element must be given. */
|
|
UNIV_INLINE
|
|
void*
|
|
mem_heap_get_top(
|
|
/*=============*/
|
|
/* out: pointer to the topmost element */
|
|
mem_heap_t* heap, /* in: memory heap */
|
|
ulint n); /* in: size of the topmost element */
|
|
/*********************************************************************
|
|
Frees the topmost element in a memory heap.
|
|
The size of the element must be given. */
|
|
UNIV_INLINE
|
|
void
|
|
mem_heap_free_top(
|
|
/*==============*/
|
|
mem_heap_t* heap, /* in: memory heap */
|
|
ulint n); /* in: size of the topmost element */
|
|
/*********************************************************************
|
|
Returns the space in bytes occupied by a memory heap. */
|
|
UNIV_INLINE
|
|
ulint
|
|
mem_heap_get_size(
|
|
/*==============*/
|
|
mem_heap_t* heap); /* in: heap */
|
|
/******************************************************************
|
|
Use this macro instead of the corresponding function!
|
|
Macro for memory buffer allocation */
|
|
|
|
#define mem_alloc(N) mem_alloc_func((N), __FILE__, __LINE__)
|
|
/******************************************************************
|
|
Use this macro instead of the corresponding function!
|
|
Macro for memory buffer allocation */
|
|
|
|
#define mem_alloc_noninline(N) mem_alloc_func_noninline(\
|
|
(N), __FILE__, __LINE__)
|
|
/*******************************************************************
|
|
NOTE: Use the corresponding macro instead of this function.
|
|
Allocates a single buffer of memory from the dynamic memory of
|
|
the C compiler. Is like malloc of C. The buffer must be freed
|
|
with mem_free. */
|
|
UNIV_INLINE
|
|
void*
|
|
mem_alloc_func(
|
|
/*===========*/
|
|
/* out, own: free storage */
|
|
ulint n, /* in: desired number of bytes */
|
|
const char* file_name, /* in: file name where created */
|
|
ulint line /* in: line where created */
|
|
);
|
|
/*******************************************************************
|
|
NOTE: Use the corresponding macro instead of this function.
|
|
Allocates a single buffer of memory from the dynamic memory of
|
|
the C compiler. Is like malloc of C. The buffer must be freed
|
|
with mem_free. */
|
|
|
|
void*
|
|
mem_alloc_func_noninline(
|
|
/*=====================*/
|
|
/* out, own: free storage */
|
|
ulint n, /* in: desired number of bytes */
|
|
const char* file_name, /* in: file name where created */
|
|
ulint line /* in: line where created */
|
|
);
|
|
/******************************************************************
|
|
Use this macro instead of the corresponding function!
|
|
Macro for memory buffer freeing */
|
|
|
|
#define mem_free(PTR) mem_free_func((PTR), __FILE__, __LINE__)
|
|
/*******************************************************************
|
|
NOTE: Use the corresponding macro instead of this function.
|
|
Frees a single buffer of storage from
|
|
the dynamic memory of C compiler. Similar to free of C. */
|
|
UNIV_INLINE
|
|
void
|
|
mem_free_func(
|
|
/*==========*/
|
|
void* ptr, /* in, own: buffer to be freed */
|
|
const char* file_name, /* in: file name where created */
|
|
ulint line /* in: line where created */
|
|
);
|
|
|
|
/**************************************************************************
|
|
Duplicates a NUL-terminated string. */
|
|
UNIV_INLINE
|
|
char*
|
|
mem_strdup(
|
|
/*=======*/
|
|
/* out, own: a copy of the string,
|
|
must be deallocated with mem_free */
|
|
const char* str); /* in: string to be copied */
|
|
/**************************************************************************
|
|
Makes a NUL-terminated copy of a nonterminated string. */
|
|
UNIV_INLINE
|
|
char*
|
|
mem_strdupl(
|
|
/*========*/
|
|
/* out, own: a copy of the string,
|
|
must be deallocated with mem_free */
|
|
const char* str, /* in: string to be copied */
|
|
ulint len); /* in: length of str, in bytes */
|
|
|
|
/**************************************************************************
|
|
Makes a NUL-terminated quoted copy of a NUL-terminated string. */
|
|
UNIV_INLINE
|
|
char*
|
|
mem_strdupq(
|
|
/*========*/
|
|
/* out, own: a quoted copy of the string,
|
|
must be deallocated with mem_free */
|
|
const char* str, /* in: string to be copied */
|
|
char q); /* in: quote character */
|
|
|
|
/**************************************************************************
|
|
Duplicates a NUL-terminated string, allocated from a memory heap. */
|
|
|
|
char*
|
|
mem_heap_strdup(
|
|
/*============*/
|
|
/* out, own: a copy of the string */
|
|
mem_heap_t* heap, /* in: memory heap where string is allocated */
|
|
const char* str); /* in: string to be copied */
|
|
/**************************************************************************
|
|
Makes a NUL-terminated copy of a nonterminated string,
|
|
allocated from a memory heap. */
|
|
UNIV_INLINE
|
|
char*
|
|
mem_heap_strdupl(
|
|
/*=============*/
|
|
/* out, own: a copy of the string */
|
|
mem_heap_t* heap, /* in: memory heap where string is allocated */
|
|
const char* str, /* in: string to be copied */
|
|
ulint len); /* in: length of str, in bytes */
|
|
|
|
/**************************************************************************
|
|
Concatenate two strings and return the result, using a memory heap. */
|
|
|
|
char*
|
|
mem_heap_strcat(
|
|
/*============*/
|
|
/* out, own: the result */
|
|
mem_heap_t* heap, /* in: memory heap where string is allocated */
|
|
const char* s1, /* in: string 1 */
|
|
const char* s2); /* in: string 2 */
|
|
|
|
#ifdef MEM_PERIODIC_CHECK
|
|
/**********************************************************************
|
|
Goes through the list of all allocated mem blocks, checks their magic
|
|
numbers, and reports possible corruption. */
|
|
|
|
void
|
|
mem_validate_all_blocks(void);
|
|
/*=========================*/
|
|
#endif
|
|
|
|
/*#######################################################################*/
|
|
|
|
/* The info header of a block in a memory heap */
|
|
|
|
struct mem_block_info_struct {
|
|
ulint magic_n;/* magic number for debugging */
|
|
char file_name[8];/* file name where the mem heap was created */
|
|
ulint line; /* line number where the mem heap was created */
|
|
UT_LIST_BASE_NODE_T(mem_block_t) base; /* In the first block in the
|
|
the list this is the base node of the list of blocks;
|
|
in subsequent blocks this is undefined */
|
|
UT_LIST_NODE_T(mem_block_t) list; /* This contains pointers to next
|
|
and prev in the list. The first block allocated
|
|
to the heap is also the first block in this list,
|
|
though it also contains the base node of the list. */
|
|
ulint len; /* physical length of this block in bytes */
|
|
ulint type; /* type of heap: MEM_HEAP_DYNAMIC, or
|
|
MEM_HEAP_BUF possibly ORed to MEM_HEAP_BTR_SEARCH */
|
|
ibool init_block; /* TRUE if this is the first block used in fast
|
|
creation of a heap: the memory will be freed
|
|
by the creator, not by mem_heap_free */
|
|
ulint free; /* offset in bytes of the first free position for
|
|
user data in the block */
|
|
ulint start; /* the value of the struct field 'free' at the
|
|
creation of the block */
|
|
byte* free_block;
|
|
/* if the MEM_HEAP_BTR_SEARCH bit is set in type,
|
|
and this is the heap root, this can contain an
|
|
allocated buffer frame, which can be appended as a
|
|
free block to the heap, if we need more space;
|
|
otherwise, this is NULL */
|
|
#ifdef MEM_PERIODIC_CHECK
|
|
UT_LIST_NODE_T(mem_block_t) mem_block_list;
|
|
/* List of all mem blocks allocated; protected
|
|
by the mem_comm_pool mutex */
|
|
#endif
|
|
};
|
|
|
|
#define MEM_BLOCK_MAGIC_N 764741555
|
|
#define MEM_FREED_BLOCK_MAGIC_N 547711122
|
|
|
|
/* Header size for a memory heap block */
|
|
#define MEM_BLOCK_HEADER_SIZE ut_calc_align(sizeof(mem_block_info_t),\
|
|
UNIV_MEM_ALIGNMENT)
|
|
#include "mem0dbg.h"
|
|
|
|
#ifndef UNIV_NONINL
|
|
#include "mem0mem.ic"
|
|
#endif
|
|
|
|
#endif
|