diff options
Diffstat (limited to 'storage/xtradb/include/log0log.h')
| -rw-r--r-- | storage/xtradb/include/log0log.h | 1077 |
1 files changed, 0 insertions, 1077 deletions
diff --git a/storage/xtradb/include/log0log.h b/storage/xtradb/include/log0log.h deleted file mode 100644 index a55c1ea818c..00000000000 --- a/storage/xtradb/include/log0log.h +++ /dev/null @@ -1,1077 +0,0 @@ -/***************************************************************************** - -Copyright (c) 1995, 2013, Oracle and/or its affiliates. All rights reserved. -Copyright (c) 2009, Google Inc. -Copyright (c) 2017, MariaDB Corporation. All Rights Reserved. - -Portions of this file contain modifications contributed and copyrighted by -Google, Inc. Those modifications are gratefully acknowledged and are described -briefly in the InnoDB documentation. The contributions by Google are -incorporated with their permission, and subject to the conditions contained in -the file COPYING.Google. - -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 the Free Software -Foundation; version 2 of the License. - -This program is distributed in the hope that it will be useful, but WITHOUT -ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS -FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. - -You should have received a copy of the GNU General Public License along with -this program; if not, write to the Free Software Foundation, Inc., -51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA - -*****************************************************************************/ - -/**************************************************//** -@file include/log0log.h -Database log - -Created 12/9/1995 Heikki Tuuri -*******************************************************/ - -#ifndef log0log_h -#define log0log_h - -#include "univ.i" -#include "ut0byte.h" -#include "ut0lst.h" -#ifndef UNIV_HOTBACKUP -#include "sync0sync.h" -#include "sync0rw.h" -#endif /* !UNIV_HOTBACKUP */ -#include "log0crypt.h" - -/* Type used for all log sequence number storage and arithmetics */ -typedef ib_uint64_t lsn_t; -#define LSN_MAX IB_UINT64_MAX - -#define LSN_PF UINT64PF - -/** Redo log buffer */ -struct log_t; -/** Redo log group */ -struct log_group_t; - -#ifdef UNIV_DEBUG -/** Flag: write to log file? */ -extern ibool log_do_write; -/** Flag: enable debug output when writing to the log? */ -extern ibool log_debug_writes; -#else /* UNIV_DEBUG */ -/** Write to log */ -# define log_do_write TRUE -#endif /* UNIV_DEBUG */ - -/** Magic value to use instead of log checksums when they are disabled */ -#define LOG_NO_CHECKSUM_MAGIC 0xDEADBEEFUL - -typedef ulint (*log_checksum_func_t)(const byte* log_block); - -/** Pointer to the log checksum calculation function. Protected with -log_sys->mutex. */ -extern log_checksum_func_t log_checksum_algorithm_ptr; - -/** Wait modes for log_write_up_to @{ */ -#define LOG_NO_WAIT 91 -#define LOG_WAIT_ONE_GROUP 92 -#define LOG_WAIT_ALL_GROUPS 93 -/* @} */ -/** Maximum number of log groups in log_group_t::checkpoint_buf */ -#define LOG_MAX_N_GROUPS 32 - -#define IB_ARCHIVED_LOGS_PREFIX "ib_log_archive_" -#define IB_ARCHIVED_LOGS_PREFIX_LEN (sizeof(IB_ARCHIVED_LOGS_PREFIX) - 1) -#define IB_ARCHIVED_LOGS_SERIAL_LEN 20 - -/*******************************************************************//** -Calculates where in log files we find a specified lsn. -@return log file number */ -UNIV_INTERN -ulint -log_calc_where_lsn_is( -/*==================*/ - ib_int64_t* log_file_offset, /*!< out: offset in that file - (including the header) */ - ib_uint64_t first_header_lsn, /*!< in: first log file start - lsn */ - ib_uint64_t lsn, /*!< in: lsn whose position to - determine */ - ulint n_log_files, /*!< in: total number of log - files */ - ib_int64_t log_file_size); /*!< in: log file size - (including the header) */ -#ifndef UNIV_HOTBACKUP -/************************************************************//** -Writes to the log the string given. The log must be released with -log_release. -@return end lsn of the log record, zero if did not succeed */ -UNIV_INLINE -lsn_t -log_reserve_and_write_fast( -/*=======================*/ - const void* str, /*!< in: string */ - ulint len, /*!< in: string length */ - lsn_t* start_lsn);/*!< out: start lsn of the log record */ -/***********************************************************************//** -Releases the log mutex. */ -UNIV_INLINE -void -log_release(void); -/*=============*/ -/***********************************************************************//** -Checks if there is need for a log buffer flush or a new checkpoint, and does -this if yes. Any database operation should call this when it has modified -more than about 4 pages. NOTE that this function may only be called when the -OS thread owns no synchronization objects except the dictionary mutex. */ -UNIV_INLINE -void -log_free_check(void); -/*================*/ -/**************************************************************************//** -Locks the log mutex and opens the log for log_write_low. The log must be closed -with log_close and released with log_release. -@return start lsn of the log record */ -UNIV_INLINE -lsn_t -log_reserve_and_open( -/*=================*/ - ulint len); /*!< in: length of data to be catenated */ -/************************************************************//** -Opens the log for log_write_low. The log must be closed with log_close. -@return start lsn of the log record */ -UNIV_INTERN -lsn_t -log_open( -/*=====*/ - ulint len); /*!< in: length of data to be catenated */ -/************************************************************//** -Writes to the log the string given. It is assumed that the caller holds the -log mutex. */ -UNIV_INTERN -void -log_write_low( -/*==========*/ - byte* str, /*!< in: string */ - ulint str_len); /*!< in: string length */ -/************************************************************//** -Closes the log. -@return lsn */ -UNIV_INTERN -lsn_t -log_close(void); -/*===========*/ -/************************************************************//** -Gets the current lsn. -@return current lsn */ -UNIV_INLINE -lsn_t -log_get_lsn(void); -/*=============*/ -/************************************************************//** -Gets the current lsn. -@return current lsn */ -UNIV_INLINE -lsn_t -log_get_lsn_nowait(void); -/*=============*/ -/************************************************************//** -Gets the last lsn that is fully flushed to disk. -@return last flushed lsn */ -UNIV_INLINE -ib_uint64_t -log_get_flush_lsn(void); -/*=============*/ -/**************************************************************** -Gets the log group capacity. It is OK to read the value without -holding log_sys->mutex because it is constant. -@return log group capacity */ -UNIV_INLINE -lsn_t -log_get_capacity(void); -/*==================*/ -/**************************************************************** -Get log_sys::max_modified_age_async. It is OK to read the value without -holding log_sys::mutex because it is constant. -@return max_modified_age_async */ -UNIV_INLINE -lsn_t -log_get_max_modified_age_async(void); -/*================================*/ -/******************************************************//** -Initializes the log. */ -UNIV_INTERN -void -log_init(void); -/*==========*/ -/******************************************************************//** -Inits a log group to the log system. */ -UNIV_INTERN -void -log_group_init( -/*===========*/ - ulint id, /*!< in: group id */ - ulint n_files, /*!< in: number of log files */ - lsn_t file_size, /*!< in: log file size in bytes */ - ulint space_id, /*!< in: space id of the file space - which contains the log files of this - group */ - ulint archive_space_id); /*!< in: space id of the file space - which contains some archived log - files for this group; currently, only - for the first log group this is - used */ -/******************************************************//** -Completes an i/o to a log file. */ -UNIV_INTERN -void -log_io_complete( -/*============*/ - log_group_t* group); /*!< in: log group */ -/******************************************************//** -This function is called, e.g., when a transaction wants to commit. It checks -that the log has been written to the log file up to the last log entry written -by the transaction. If there is a flush running, it waits and checks if the -flush flushed enough. If not, starts a new flush. */ -UNIV_INTERN -void -log_write_up_to( -/*============*/ - lsn_t lsn, /*!< in: log sequence number up to which - the log should be written, LSN_MAX if not specified */ - ulint wait, /*!< in: LOG_NO_WAIT, LOG_WAIT_ONE_GROUP, - or LOG_WAIT_ALL_GROUPS */ - ibool flush_to_disk); - /*!< in: TRUE if we want the written log - also to be flushed to disk */ -/****************************************************************//** -Does a syncronous flush of the log buffer to disk. */ -UNIV_INTERN -void -log_buffer_flush_to_disk(void); -/*==========================*/ -/****************************************************************//** -This functions writes the log buffer to the log file and if 'flush' -is set it forces a flush of the log file as well. This is meant to be -called from background master thread only as it does not wait for -the write (+ possible flush) to finish. */ -UNIV_INTERN -void -log_buffer_sync_in_background( -/*==========================*/ - ibool flush); /*<! in: flush the logs to disk */ -/******************************************************//** -Makes a checkpoint. Note that this function does not flush dirty -blocks from the buffer pool: it only checks what is lsn of the oldest -modification in the pool, and writes information about the lsn in -log files. Use log_make_checkpoint_at to flush also the pool. -@return TRUE if success, FALSE if a checkpoint write was already running */ -UNIV_INTERN -ibool -log_checkpoint( -/*===========*/ - ibool sync, /*!< in: TRUE if synchronous operation is - desired */ - ibool write_always, /*!< in: the function normally checks if the - the new checkpoint would have a greater - lsn than the previous one: if not, then no - physical write is done; by setting this - parameter TRUE, a physical write will always be - made to log files */ - ibool safe_to_ignore);/*!< in: TRUE if checkpoint can be ignored in - the case checkpoint's are disabled */ - -/****************************************************************//** -Makes a checkpoint at a given lsn or later. */ -UNIV_INTERN -void -log_make_checkpoint_at( -/*===================*/ - lsn_t lsn, /*!< in: make a checkpoint at this or a - later lsn, if LSN_MAX, makes - a checkpoint at the latest lsn */ - ibool write_always); /*!< in: the function normally checks if - the new checkpoint would have a - greater lsn than the previous one: if - not, then no physical write is done; - by setting this parameter TRUE, a - physical write will always be made to - log files */ -/****************************************************************//** -Disable checkpoints. This is used when doing a volume snapshot -to ensure that we don't get checkpoint between snapshoting two -different volumes */ -UNIV_INTERN -ibool log_disable_checkpoint(); - -/****************************************************************//** -Enable checkpoints that was disabled with log_disable_checkpoint() */ -UNIV_INTERN -void log_enable_checkpoint(); - -/****************************************************************//** -Makes a checkpoint at the latest lsn and writes it to first page of each -data file in the database, so that we know that the file spaces contain -all modifications up to that lsn. This can only be called at database -shutdown. This function also writes all log in log files to the log archive. */ -UNIV_INTERN -void -logs_empty_and_mark_files_at_shutdown(void); -/*=======================================*/ -/******************************************************//** -Reads a checkpoint info from a log group header to log_sys->checkpoint_buf. */ -UNIV_INTERN -void -log_group_read_checkpoint_info( -/*===========================*/ - log_group_t* group, /*!< in: log group */ - ulint field); /*!< in: LOG_CHECKPOINT_1 or LOG_CHECKPOINT_2 */ -/*******************************************************************//** -Gets info from a checkpoint about a log group. */ -UNIV_INTERN -void -log_checkpoint_get_nth_group_info( -/*==============================*/ - const byte* buf, /*!< in: buffer containing checkpoint info */ - ulint n, /*!< in: nth slot */ - lsn_t* file_no);/*!< out: archived file number */ -/******************************************************//** -Writes checkpoint info to groups. */ -UNIV_INTERN -void -log_groups_write_checkpoint_info(void); -/*==================================*/ -/********************************************************************//** -Starts an archiving operation. -@return TRUE if succeed, FALSE if an archiving operation was already running */ -UNIV_INTERN -ibool -log_archive_do( -/*===========*/ - ibool sync, /*!< in: TRUE if synchronous operation is desired */ - ulint* n_bytes);/*!< out: archive log buffer size, 0 if nothing to - archive */ -/****************************************************************//** -Starts again archiving which has been stopped. -@return DB_SUCCESS or DB_ERROR */ -UNIV_INTERN -ulint -log_archive_start(void); -/*===================*/ -/****************************************************************//** -Stop archiving the log so that a gap may occur in the archived log files. -@return DB_SUCCESS or DB_ERROR */ -UNIV_INTERN -ulint -log_archive_noarchivelog(void); -/*==========================*/ -/****************************************************************//** -Start archiving the log so that a gap may occur in the archived log files. -@return DB_SUCCESS or DB_ERROR */ -UNIV_INTERN -ulint -log_archive_archivelog(void); -/*========================*/ -/******************************************************//** -Generates an archived log file name. */ -UNIV_INTERN -void -log_archived_file_name_gen( -/*=======================*/ - char* buf, /*!< in: buffer where to write */ - ulint buf_len,/*!< in: buffer length */ - ulint id, /*!< in: group id */ - lsn_t file_no);/*!< in: file number */ - -UNIV_INTERN -void -log_archived_get_offset( -/*====================*/ - log_group_t* group, /*!< in: log group */ - lsn_t file_no, /*!< in: archive log file number */ - lsn_t archived_lsn, /*!< in: last archived LSN */ - lsn_t* offset); /*!< out: offset within archived file */ -#else /* !UNIV_HOTBACKUP */ -/******************************************************//** -Writes info to a buffer of a log group when log files are created in -backup restoration. */ -UNIV_INTERN -void -log_reset_first_header_and_checkpoint( -/*==================================*/ - byte* hdr_buf,/*!< in: buffer which will be written to the - start of the first log file */ - ib_uint64_t start); /*!< in: lsn of the start of the first log file; - we pretend that there is a checkpoint at - start + LOG_BLOCK_HDR_SIZE */ -#endif /* !UNIV_HOTBACKUP */ -/********************************************************************//** -Checks that there is enough free space in the log to start a new query step. -Flushes the log buffer or makes a new checkpoint if necessary. NOTE: this -function may only be called if the calling thread owns no synchronization -objects! */ -UNIV_INTERN -void -log_check_margins(void); -/*===================*/ -#ifndef UNIV_HOTBACKUP -/******************************************************//** -Reads a specified log segment to a buffer. */ -UNIV_INTERN -void -log_group_read_log_seg( -/*===================*/ - ulint type, /*!< in: LOG_ARCHIVE or LOG_RECOVER */ - byte* buf, /*!< in: buffer where to read */ - log_group_t* group, /*!< in: log group */ - lsn_t start_lsn, /*!< in: read area start */ - lsn_t end_lsn, /*!< in: read area end */ - ibool release_mutex); /*!< in: whether the log_sys->mutex - should be released before the read */ -/******************************************************//** -Writes a buffer to a log file group. */ -UNIV_INTERN -void -log_group_write_buf( -/*================*/ - log_group_t* group, /*!< in: log group */ - byte* buf, /*!< in: buffer */ - ulint len, /*!< in: buffer len; must be divisible - by OS_FILE_LOG_BLOCK_SIZE */ - lsn_t start_lsn, /*!< in: start lsn of the buffer; must - be divisible by - OS_FILE_LOG_BLOCK_SIZE */ - ulint new_data_offset);/*!< in: start offset of new data in - buf: this parameter is used to decide - if we have to write a new log file - header */ -/********************************************************//** -Sets the field values in group to correspond to a given lsn. For this function -to work, the values must already be correctly initialized to correspond to -some lsn, for instance, a checkpoint lsn. */ -UNIV_INTERN -void -log_group_set_fields( -/*=================*/ - log_group_t* group, /*!< in/out: group */ - lsn_t lsn); /*!< in: lsn for which the values should be - set */ -/******************************************************//** -Calculates the data capacity of a log group, when the log file headers are not -included. -@return capacity in bytes */ -UNIV_INTERN -lsn_t -log_group_get_capacity( -/*===================*/ - const log_group_t* group); /*!< in: log group */ -#endif /* !UNIV_HOTBACKUP */ -/************************************************************//** -Gets a log block flush bit. -@return TRUE if this block was the first to be written in a log flush */ -UNIV_INLINE -ibool -log_block_get_flush_bit( -/*====================*/ - const byte* log_block); /*!< in: log block */ -/************************************************************//** -Gets a log block number stored in the header. -@return log block number stored in the block header */ -UNIV_INLINE -ulint -log_block_get_hdr_no( -/*=================*/ - const byte* log_block); /*!< in: log block */ -/************************************************************//** -Gets a log block data length. -@return log block data length measured as a byte offset from the block start */ -UNIV_INLINE -ulint -log_block_get_data_len( -/*===================*/ - const byte* log_block); /*!< in: log block */ -/************************************************************//** -Sets the log block data length. */ -UNIV_INLINE -void -log_block_set_data_len( -/*===================*/ - byte* log_block, /*!< in/out: log block */ - ulint len); /*!< in: data length */ -/************************************************************//** -Calculates the checksum for a log block. -@return checksum */ -UNIV_INLINE -ulint -log_block_calc_checksum( -/*====================*/ - const byte* block); /*!< in: log block */ -/************************************************************//** -Gets a log block checksum field value. -@return checksum */ -UNIV_INLINE -ulint -log_block_get_checksum( -/*===================*/ - const byte* log_block); /*!< in: log block */ -/************************************************************//** -Sets a log block checksum field value. */ -UNIV_INLINE -void -log_block_set_checksum( -/*===================*/ - byte* log_block, /*!< in/out: log block */ - ulint checksum); /*!< in: checksum */ -/************************************************************//** -Gets a log block first mtr log record group offset. -@return first mtr log record group byte offset from the block start, 0 -if none */ -UNIV_INLINE -ulint -log_block_get_first_rec_group( -/*==========================*/ - const byte* log_block); /*!< in: log block */ -/************************************************************//** -Sets the log block first mtr log record group offset. */ -UNIV_INLINE -void -log_block_set_first_rec_group( -/*==========================*/ - byte* log_block, /*!< in/out: log block */ - ulint offset); /*!< in: offset, 0 if none */ -/************************************************************//** -Gets a log block checkpoint number field (4 lowest bytes). -@return checkpoint no (4 lowest bytes) */ -UNIV_INLINE -ulint -log_block_get_checkpoint_no( -/*========================*/ - const byte* log_block); /*!< in: log block */ -/************************************************************//** -Initializes a log block in the log buffer. */ -UNIV_INLINE -void -log_block_init( -/*===========*/ - byte* log_block, /*!< in: pointer to the log buffer */ - lsn_t lsn); /*!< in: lsn within the log block */ -/************************************************************//** -Initializes a log block in the log buffer in the old, < 3.23.52 format, where -there was no checksum yet. */ -UNIV_INLINE -void -log_block_init_in_old_format( -/*=========================*/ - byte* log_block, /*!< in: pointer to the log buffer */ - lsn_t lsn); /*!< in: lsn within the log block */ -/************************************************************//** -Converts a lsn to a log block number. -@return log block number, it is > 0 and <= 1G */ -UNIV_INLINE -ulint -log_block_convert_lsn_to_no( -/*========================*/ - lsn_t lsn); /*!< in: lsn of a byte within the block */ -/******************************************************//** -Prints info of the log. */ -UNIV_INTERN -void -log_print( -/*======*/ - FILE* file); /*!< in: file where to print */ -/******************************************************//** -Peeks the current lsn. -@return TRUE if success, FALSE if could not get the log system mutex */ -UNIV_INTERN -ibool -log_peek_lsn( -/*=========*/ - lsn_t* lsn); /*!< out: if returns TRUE, current lsn is here */ -/**********************************************************************//** -Refreshes the statistics used to print per-second averages. */ -UNIV_INTERN -void -log_refresh_stats(void); -/*===================*/ -/********************************************************//** -Closes all log groups. */ -UNIV_INTERN -void -log_group_close_all(void); -/*=====================*/ -/********************************************************//** -Shutdown the log system but do not release all the memory. */ -UNIV_INTERN -void -log_shutdown(void); -/*==============*/ -/********************************************************//** -Free the log system data structures. */ -UNIV_INTERN -void -log_mem_free(void); -/*==============*/ - -/****************************************************************//** -Safely reads the log_sys->tracked_lsn value. The writer counterpart function -is log_set_tracked_lsn() in log0online.c. - -@return log_sys->tracked_lsn value. */ -UNIV_INLINE -lsn_t -log_get_tracked_lsn(void); -/*=====================*/ - -extern log_t* log_sys; - -/* Values used as flags */ -#define LOG_FLUSH 7652559 -#define LOG_CHECKPOINT 78656949 -#ifdef UNIV_LOG_ARCHIVE -# define LOG_ARCHIVE 11122331 -#endif /* UNIV_LOG_ARCHIVE */ -#define LOG_RECOVER 98887331 - -/* The counting of lsn's starts from this value: this must be non-zero */ -#define LOG_START_LSN ((lsn_t) (16 * OS_FILE_LOG_BLOCK_SIZE)) - -#define LOG_BUFFER_SIZE (srv_log_buffer_size * UNIV_PAGE_SIZE) -#define LOG_ARCHIVE_BUF_SIZE (srv_log_buffer_size * UNIV_PAGE_SIZE / 4) - -/* Offsets of a log block header */ -#define LOG_BLOCK_HDR_NO 0 /* block number which must be > 0 and - is allowed to wrap around at 2G; the - highest bit is set to 1 if this is the - first log block in a log flush write - segment */ -#define LOG_BLOCK_FLUSH_BIT_MASK 0x80000000UL - /* mask used to get the highest bit in - the preceding field */ -#define LOG_BLOCK_HDR_DATA_LEN 4 /* number of bytes of log written to - this block */ -#define LOG_BLOCK_FIRST_REC_GROUP 6 /* offset of the first start of an - mtr log record group in this log block, - 0 if none; if the value is the same - as LOG_BLOCK_HDR_DATA_LEN, it means - that the first rec group has not yet - been catenated to this log block, but - if it will, it will start at this - offset; an archive recovery can - start parsing the log records starting - from this offset in this log block, - if value not 0 */ -#define LOG_BLOCK_CHECKPOINT_NO 8 /* 4 lower bytes of the value of - log_sys->next_checkpoint_no when the - log block was last written to: if the - block has not yet been written full, - this value is only updated before a - log buffer flush */ -#define LOG_BLOCK_HDR_SIZE 12 /* size of the log block header in - bytes */ - -/* Offsets of a log block trailer from the end of the block */ -#define LOG_BLOCK_CHECKSUM 4 /* 4 byte checksum of the log block - contents; in InnoDB versions - < 3.23.52 this did not contain the - checksum but the same value as - .._HDR_NO */ -#define LOG_BLOCK_TRL_SIZE 4 /* trailer size in bytes */ - -/* Offsets for a checkpoint field */ -#define LOG_CHECKPOINT_NO 0 -#define LOG_CHECKPOINT_LSN 8 -#define LOG_CHECKPOINT_OFFSET_LOW32 16 -#define LOG_CHECKPOINT_LOG_BUF_SIZE 20 -#define LOG_CHECKPOINT_ARCHIVED_LSN 24 -#define LOG_CHECKPOINT_GROUP_ARRAY 32 - -/* For each value smaller than LOG_MAX_N_GROUPS the following 8 bytes: */ - -#define LOG_CHECKPOINT_ARCHIVED_FILE_NO 0 -#define LOG_CHECKPOINT_ARCHIVED_OFFSET 4 - -#define LOG_CHECKPOINT_ARRAY_END (LOG_CHECKPOINT_GROUP_ARRAY\ - + LOG_MAX_N_GROUPS * 8) -#define LOG_CHECKPOINT_CHECKSUM_1 LOG_CHECKPOINT_ARRAY_END -#define LOG_CHECKPOINT_CHECKSUM_2 (4 + LOG_CHECKPOINT_ARRAY_END) -#if 0 -#define LOG_CHECKPOINT_FSP_FREE_LIMIT (8 + LOG_CHECKPOINT_ARRAY_END) - /*!< Not used (0); - This used to contain the - current fsp free limit in - tablespace 0, in units of one - megabyte. - - This information might have been used - since mysqlbackup version 0.35 but - before 1.41 to decide if unused ends of - non-auto-extending data files - in space 0 can be truncated. - - This information was made obsolete - by mysqlbackup --compress. */ -#define LOG_CHECKPOINT_FSP_MAGIC_N (12 + LOG_CHECKPOINT_ARRAY_END) - /*!< Not used (0); - This magic number tells if the - checkpoint contains the above field: - the field was added to - InnoDB-3.23.50 and - removed from MySQL 5.6 */ -#define LOG_CHECKPOINT_FSP_MAGIC_N_VAL 1441231243 - /*!< if LOG_CHECKPOINT_FSP_MAGIC_N - contains this value, then - LOG_CHECKPOINT_FSP_FREE_LIMIT - is valid */ -#endif -#define LOG_CHECKPOINT_OFFSET_HIGH32 (16 + LOG_CHECKPOINT_ARRAY_END) -#define LOG_CRYPT_VER (20 + LOG_CHECKPOINT_ARRAY_END) - -#define LOG_CRYPT_MAX_ENTRIES (5) -#define LOG_CRYPT_ENTRY_SIZE (4 + 4 + 2 * MY_AES_BLOCK_SIZE) -#define LOG_CRYPT_SIZE (1 + 1 + \ - (LOG_CRYPT_MAX_ENTRIES * \ - LOG_CRYPT_ENTRY_SIZE)) - -#define LOG_CHECKPOINT_SIZE (20 + LOG_CHECKPOINT_ARRAY_END + \ - LOG_CRYPT_SIZE) - -/* Offsets of a log file header */ -#define LOG_GROUP_ID 0 /* log group number */ -#define LOG_FILE_START_LSN 4 /* lsn of the start of data in this - log file */ -#define LOG_FILE_NO 12 /* 4-byte archived log file number; - this field is only defined in an - archived log file */ -#define LOG_FILE_WAS_CREATED_BY_HOT_BACKUP 16 - /* a 32-byte field which contains - the string 'ibbackup' and the - creation time if the log file was - created by mysqlbackup --restore; - when mysqld is first time started - on the restored database, it can - print helpful info for the user */ -#define LOG_FILE_OS_FILE_LOG_BLOCK_SIZE 64 - /* extend to record log_block_size - of XtraDB. 0 means default 512 */ -#define LOG_FILE_ARCH_COMPLETED OS_FILE_LOG_BLOCK_SIZE - /* this 4-byte field is TRUE when - the writing of an archived log file - has been completed; this field is - only defined in an archived log file */ -#define LOG_FILE_END_LSN (OS_FILE_LOG_BLOCK_SIZE + 4) - /* lsn where the archived log file - at least extends: actually the - archived log file may extend to a - later lsn, as long as it is within the - same log block as this lsn; this field - is defined only when an archived log - file has been completely written */ -#define LOG_CHECKPOINT_1 OS_FILE_LOG_BLOCK_SIZE - /* first checkpoint field in the log - header; we write alternately to the - checkpoint fields when we make new - checkpoints; this field is only defined - in the first log file of a log group */ -#define LOG_CHECKPOINT_2 (3 * OS_FILE_LOG_BLOCK_SIZE) - /* second checkpoint field in the log - header */ -#define LOG_FILE_HDR_SIZE (4 * OS_FILE_LOG_BLOCK_SIZE) - -#define LOG_GROUP_OK 301 -#define LOG_GROUP_CORRUPTED 302 - -/** Log group consists of a number of log files, each of the same size; a log -group is implemented as a space in the sense of the module fil0fil. */ -struct log_group_t{ - /* The following fields are protected by log_sys->mutex */ - ulint id; /*!< log group id */ - ulint n_files; /*!< number of files in the group */ - lsn_t file_size; /*!< individual log file size in bytes, - including the log file header */ - ulint space_id; /*!< file space which implements the log - group */ - ulint state; /*!< LOG_GROUP_OK or - LOG_GROUP_CORRUPTED */ - lsn_t lsn; /*!< lsn used to fix coordinates within - the log group */ - lsn_t lsn_offset; /*!< the offset of the above lsn */ - ulint n_pending_writes;/*!< number of currently pending flush - writes for this log group */ - byte** file_header_bufs_ptr;/*!< unaligned buffers */ - byte** file_header_bufs;/*!< buffers for each file - header in the group */ -#ifdef UNIV_LOG_ARCHIVE - /*-----------------------------*/ - byte** archive_file_header_bufs_ptr;/*!< unaligned buffers */ - byte** archive_file_header_bufs;/*!< buffers for each file - header in the group */ - ulint archive_space_id;/*!< file space which - implements the log group - archive */ - lsn_t archived_file_no;/*!< file number corresponding to - log_sys->archived_lsn */ - lsn_t archived_offset;/*!< file offset corresponding to - log_sys->archived_lsn, 0 if we have - not yet written to the archive file - number archived_file_no */ - lsn_t next_archived_file_no;/*!< during an archive write, - until the write is completed, we - store the next value for - archived_file_no here: the write - completion function then sets the new - value to ..._file_no */ - lsn_t next_archived_offset; /*!< like the preceding field */ -#endif /* UNIV_LOG_ARCHIVE */ - /*-----------------------------*/ - lsn_t scanned_lsn; /*!< used only in recovery: recovery scan - succeeded up to this lsn in this log - group */ - byte* checkpoint_buf_ptr;/*!< unaligned checkpoint header */ - byte* checkpoint_buf; /*!< checkpoint header is written from - this buffer to the group */ - UT_LIST_NODE_T(log_group_t) - log_groups; /*!< list of log groups */ -}; - -/** Redo log buffer */ -struct log_t{ - byte pad[CACHE_LINE_SIZE]; /*!< padding to prevent other memory - update hotspots from residing on the - same memory cache line */ - lsn_t lsn; /*!< log sequence number */ - ulint buf_free; /*!< first free offset within the log - buffer */ -#ifndef UNIV_HOTBACKUP - ib_prio_mutex_t mutex; /*!< mutex protecting the log */ - - ib_mutex_t log_flush_order_mutex;/*!< mutex to serialize access to - the flush list when we are putting - dirty blocks in the list. The idea - behind this mutex is to be able - to release log_sys->mutex during - mtr_commit and still ensure that - insertions in the flush_list happen - in the LSN order. */ -#endif /* !UNIV_HOTBACKUP */ - byte* buf_ptr; /* unaligned log buffer */ - byte* buf; /*!< log buffer */ - ulint buf_size; /*!< log buffer size in bytes */ - ulint max_buf_free; /*!< recommended maximum value of - buf_free, after which the buffer is - flushed */ - #ifdef UNIV_LOG_DEBUG - ulint old_buf_free; /*!< value of buf free when log was - last time opened; only in the debug - version */ - ib_uint64_t old_lsn; /*!< value of lsn when log was - last time opened; only in the - debug version */ -#endif /* UNIV_LOG_DEBUG */ - ibool check_flush_or_checkpoint; - /*!< this is set to TRUE when there may - be need to flush the log buffer, or - preflush buffer pool pages, or make - a checkpoint; this MUST be TRUE when - lsn - last_checkpoint_lsn > - max_checkpoint_age; this flag is - peeked at by log_free_check(), which - does not reserve the log mutex */ - UT_LIST_BASE_NODE_T(log_group_t) - log_groups; /*!< log groups */ - -#ifndef UNIV_HOTBACKUP - /** The fields involved in the log buffer flush @{ */ - - ulint buf_next_to_write;/*!< first offset in the log buffer - where the byte content may not exist - written to file, e.g., the start - offset of a log record catenated - later; this is advanced when a flush - operation is completed to all the log - groups */ - volatile bool is_extending; /*!< this is set to true during extend - the log buffer size */ - lsn_t written_to_some_lsn; - /*!< first log sequence number not yet - written to any log group; for this to - be advanced, it is enough that the - write i/o has been completed for any - one log group */ - lsn_t written_to_all_lsn; - /*!< first log sequence number not yet - written to some log group; for this to - be advanced, it is enough that the - write i/o has been completed for all - log groups. - Note that since InnoDB currently - has only one log group therefore - this value is redundant. Also it - is possible that this value - falls behind the - flushed_to_disk_lsn transiently. - It is appropriate to use either - flushed_to_disk_lsn or - write_lsn which are always - up-to-date and accurate. */ - lsn_t write_lsn; /*!< end lsn for the current running - write */ - ulint write_end_offset;/*!< the data in buffer has - been written up to this offset - when the current write ends: - this field will then be copied - to buf_next_to_write */ - lsn_t current_flush_lsn;/*!< end lsn for the current running - write + flush operation */ - lsn_t flushed_to_disk_lsn; - /*!< how far we have written the log - AND flushed to disk */ - ulint n_pending_writes;/*!< number of currently - pending flushes or writes */ - /* NOTE on the 'flush' in names of the fields below: starting from - 4.0.14, we separate the write of the log file and the actual fsync() - or other method to flush it to disk. The names below should really - be 'flush_or_write'! */ - os_event_t no_flush_event; /*!< this event is in the reset state - when a flush or a write is running; - os_event_set() and os_event_reset() - are protected by log_sys_t::mutex */ - ibool one_flushed; /*!< during a flush, this is - first FALSE and becomes TRUE - when one log group has been - written or flushed */ - os_event_t one_flushed_event;/*!< this event is reset when the - flush or write has not yet completed - for any log group; e.g., this means - that a transaction has been committed - when this is set; - os_event_set() and os_event_reset() - are protected by log_sys_t::mutex */ - ulint n_log_ios; /*!< number of log i/os initiated thus - far */ - ulint n_log_ios_old; /*!< number of log i/o's at the - previous printout */ - time_t last_printout_time;/*!< when log_print was last time - called */ - /* @} */ - - /** Fields involved in checkpoints @{ */ - lsn_t log_group_capacity; /*!< capacity of the log group; if - the checkpoint age exceeds this, it is - a serious error because it is possible - we will then overwrite log and spoil - crash recovery */ - lsn_t max_modified_age_async; - /*!< when this recommended - value for lsn - - buf_pool_get_oldest_modification() - is exceeded, we start an - asynchronous preflush of pool pages */ - lsn_t max_modified_age_sync; - /*!< when this recommended - value for lsn - - buf_pool_get_oldest_modification() - is exceeded, we start a - synchronous preflush of pool pages */ - lsn_t max_checkpoint_age_async; - /*!< when this checkpoint age - is exceeded we start an - asynchronous writing of a new - checkpoint */ - lsn_t max_checkpoint_age; - /*!< this is the maximum allowed value - for lsn - last_checkpoint_lsn when a - new query step is started */ - ib_uint64_t next_checkpoint_no; - /*!< next checkpoint number */ - lsn_t last_checkpoint_lsn; - /*!< latest checkpoint lsn */ - lsn_t next_checkpoint_lsn; - /*!< next checkpoint lsn */ - ulint n_pending_checkpoint_writes; - /*!< number of currently pending - checkpoint writes */ - rw_lock_t checkpoint_lock;/*!< this latch is x-locked when a - checkpoint write is running; a thread - should wait for this without owning - the log mutex */ -#endif /* !UNIV_HOTBACKUP */ - byte* checkpoint_buf_ptr;/* unaligned checkpoint header */ - byte* checkpoint_buf; /*!< checkpoint header is read to this - buffer */ - /* @} */ -#ifdef UNIV_LOG_ARCHIVE - /** Fields involved in archiving @{ */ - ulint archiving_state;/*!< LOG_ARCH_ON, LOG_ARCH_STOPPING - LOG_ARCH_STOPPED, LOG_ARCH_OFF */ - lsn_t archived_lsn; /*!< archiving has advanced to this - lsn */ - lsn_t max_archived_lsn_age_async; - /*!< recommended maximum age of - archived_lsn, before we start - asynchronous copying to the archive */ - lsn_t max_archived_lsn_age; - /*!< maximum allowed age for - archived_lsn */ - lsn_t next_archived_lsn;/*!< during an archive write, - until the write is completed, we - store the next value for - archived_lsn here: the write - completion function then sets the new - value to archived_lsn */ - ulint archiving_phase;/*!< LOG_ARCHIVE_READ or - LOG_ARCHIVE_WRITE */ - ulint n_pending_archive_ios; - /*!< number of currently pending reads - or writes in archiving */ - rw_lock_t archive_lock; /*!< this latch is x-locked when an - archive write is running; a thread - should wait for this without owning - the log mutex */ - ulint archive_buf_size;/*!< size of archive_buf */ - byte* archive_buf_ptr;/*!< unaligned archived_buf */ - byte* archive_buf; /*!< log segment is written to the - archive from this buffer */ - os_event_t archiving_on; /*!< if archiving has been stopped; - os_event_set() and os_event_reset() - are protected by log_sys_t::mutex */ - /* @} */ -#endif /* UNIV_LOG_ARCHIVE */ - lsn_t tracked_lsn; /*!< log tracking has advanced to this - lsn. Field accessed atomically where - 64-bit atomic ops are supported, - protected by the log sys mutex - otherwise. */ -}; - -/** Test if flush order mutex is owned. */ -#define log_flush_order_mutex_own() \ - mutex_own(&log_sys->log_flush_order_mutex) - -/** Acquire the flush order mutex. */ -#define log_flush_order_mutex_enter() do { \ - mutex_enter(&log_sys->log_flush_order_mutex); \ -} while (0) -/** Release the flush order mutex. */ -# define log_flush_order_mutex_exit() do { \ - mutex_exit(&log_sys->log_flush_order_mutex); \ -} while (0) - -#ifdef UNIV_LOG_ARCHIVE -/** Archiving state @{ */ -#define LOG_ARCH_ON 71 -#define LOG_ARCH_STOPPING 72 -#define LOG_ARCH_STOPPING2 73 -#define LOG_ARCH_STOPPED 74 -#define LOG_ARCH_OFF 75 -/* @} */ -#endif /* UNIV_LOG_ARCHIVE */ - -/* log scrubbing speed, in bytes/sec */ -extern ulonglong innodb_scrub_log_speed; - -#ifndef UNIV_NONINL -#include "log0log.ic" -#endif - -#endif |