/* Copyright (C) 2007 MySQL AB & Sanja Belkin. 2010 Monty Program Ab. Copyright ( c ) 2020 , MariaDB Corporation . 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 #include "maria_def.h" #include "trnman.h" #include "ma_blockrec.h" /* for some constants and in-write hooks */ #include "ma_key_recover.h" /* For some in-write hooks */ #include "ma_checkpoint.h" #include "ma_servicethread.h" #include "ma_recovery.h" #include "ma_loghandler_lsn.h" #include "ma_recovery_util.h" /* On Windows , neither my_open ( ) nor mysql_file_sync ( ) work for directories . Also there is no need to flush filesystem changes , i . e to sync ( ) directories . #ifdef _WIN32#define sync_dir(A,B) 0 #else #define sync_dir(A,B) mysql_file_sync(A,B)#endif /** @ file @ brief Module which writes and reads to a transaction log /* 0xFF can never be valid first byte of a chunk */ #define TRANSLOG_FILLER 0 xFF/* number of opened log files in the pagecache (should be at least 2) */ #define OPENED_FILES_NUM 3 #define CACHED_FILES_NUM 5 #define CACHED_FILES_NUM_DIRECT_SEARCH_LIMIT 7 #if CACHED_FILES_NUM > CACHED_FILES_NUM_DIRECT_SEARCH_LIMIT#include <hash.h>#include <m_ctype.h>#endif /** @brief protects checkpoint_in_progress */ static mysql_mutex_t LOCK_soft_sync;/** @brief for killing the background checkpoint thread */ static mysql_cond_t COND_soft_sync;/** @brief control structure for checkpoint background thread */ static MA_SERVICE_THREAD_CONTROL soft_sync_control=0 , FALSE , FALSE , &LOCK_soft_sync, &COND_soft_sync};0 ;/* transaction log file descriptor */ typedef struct st_translog_file/* records buffer size (should be TRANSLOG_PAGE_SIZE * n) */ #define TRANSLOG_WRITE_BUFFER (1024 *1024 )/* pagecache_read / write / inject ( ) use bmove512 ( ) on their buffers so those must be long - aligned , which we guarantee by using the type below : typedef union #define MAX_TRUNSLOG_USED_BUFFERS 3 typedef struct struct st_translog_buffer *buff[MAX_TRUNSLOG_USED_BUFFERS];static void 0 ;static void struct st_translog_buffer *buff);static void struct st_translog_buffer *buff);static void /* min chunk length */ #define TRANSLOG_MIN_CHUNK 3 /* Number of buffers used by loghandler Should be at least 4 , because one thread can block up to 2 buffers in normal circumstances ( less then half of one and full other , or just switched one and other ) , But if we met end of the file in the middle and have to switch buffer it will be 3 . + 1 buffer for flushing / writing . We have a bigger number here for higher concurrency and to make division faster . The number should be power of 2 to be fast . #define TRANSLOG_BUFFERS_NO 8 /* number of bytes (+ header) which can be unused on first page in sequence */ #define TRANSLOG_MINCHUNK_CONTENT 1 /* version of log file */ #define TRANSLOG_VERSION_ID 10000 /* 1.00.00 */ #define TRANSLOG_PAGE_FLAGS 6 /* transaction log page flags offset */ /* Maximum length of compressed LSNs (the worst case of whole LSN storing) */ #define COMPRESSED_LSN_MAX_STORE_SIZE (2 + LSN_STORE_SIZE)#define MAX_NUMBER_OF_LSNS_PER_RECORD 2 /* max lsn calculation for buffer */ #define BUFFER_MAX_LSN(B) \/* log write buffer descriptor */ struct st_translog_buffer/* Cache for current log . Comes first to be aligned for bmove512 ( ) in pagecache_inject ( ) /* Maximum LSN of records which ends in this buffer ( or IMPOSSIBLE_LSN if no LSNs ends here ) /* last_lsn of previous buffer or IMPOSSIBLE_LSN if it is very first one */ /* This buffer offset in the file */ /* Next buffer offset in the file ( it is not always offset + size , in case of flush by LSN it can be offset + size - TRANSLOG_PAGE_SIZE ) /* Previous buffer offset to detect it flush finish */ /* If the buffer was forced to close it save value of its horizon otherwise LSN_IMPOSSIBLE /* How much is written ( or will be written when copy_to_buffer_in_progress become 0 ) to this buffer /* When moving from one log buffer to another , we write the last of the previous buffer to file and then move to start using the new log buffer . In the case of a part filed last page , this page is not moved to the start of the new buffer but instead we set the ' skip_data ' variable to tell us how much data at the beginning of the buffer is not relevant . /* File handler for this buffer */ /* Threads which are waiting for buffer filling/freeing */ /* Number of records which are in copy progress . Controlled via translog_buffer_increase_writers ( ) and translog_buffer_decrease_writers ( ) . 1 Simple case : translog_force_current_buffer_to_finish both called in the same procedure . 2 Simple case : translog_write_variable_record_1group : translog_advance_pointer ( ) increase writer of the buffer and translog_buffer_decrease_writers ( ) decrease it . Usual case : 1 ) translog_advance_pointer ( i . e . reserve place for future writing ) increase writers for all buffers where place reserved . Simpliest case : just all space reserved in one buffer complex case : end of the first buffer , all second buffer , beginning of the third buffer . 2 ) When we finish with writing translog_chaser_page_next ( ) will be called and unlock the buffer by decreasing number of writers . /* list of waiting buffer ready threads */ struct st_my_thread_var *waiting_flush;/* If true then previous buffer overlap with this one ( due to flush of loghandler , the last page of that buffer is the same as the first page of this buffer ) and have to be written first ( because contain old content of page which present in both buffers ) /* Lock for the buffer . Current buffer also lock the whole handler ( if one want lock the handler one should lock the current buffer ) . Buffers are locked only in one direction ( with overflow and beginning from the first buffer ) . If we keep lock on buffer N we can lock only buffer N + 1 ( never N - 1 ) . One thread do not lock more then 2 buffer in a time , so to make dead lock it should be N thread ( where N equal number of buffers ) takes one buffer and try to lock next . But it is impossible because there is only 2 cases when thread take 2 buffers : 1 ) one thread finishes current buffer ( where horizon is ) and start next ( to which horizon moves ) . 2 ) flush start from buffer after current ( oldest ) and go till the current crabbing by buffer sequence . And there is only one flush in a moment ( they are serialised ) . Because of above and number of buffers equal 5 we can ' t get dead lock ( it is impossible to get all 5 buffers locked simultaneously ) . /* Some thread is going to close the buffer and it should be done only by that thread /* Version of the buffer increases every time buffer the buffer flushed . With file and offset it allow detect buffer changes /* When previous buffer sent to disk it set its address here to allow to detect when it is done ( we have to keep it in this buffer to lock buffers only in one direction ) . struct st_buffer_cursor/* pointer into the buffer */ /* current buffer */ struct st_translog_buffer *buffer;/* How many bytes we wrote on the current page */ /* How many times we write the page on the disk during flushing process ( for sector protection ) . /* previous write offset */ /* Number of current buffer */ /* True if it is just filling buffer after advancing the pointer to the horizon . /* Is current page of the cursor already finished ( sector protection should be applied if it is needed ) protected ;typedef uint8 dirty_buffer_mask_t;struct st_translog_descriptor/* *** Parameters of the log handler *** */ /* Page cache for the log reads */ /* File open flags */ /* max size of one log size (for new logs creation) */ /* server ID (used for replication) */ /* Loghandler's buffer capacity in case of chunk 2 filling */ /* Half of the buffer capacity in case of chunk 2 filling , used to decide will we write a record in one group or many . It is written to the variable just to avoid devision every time we need it . /* Page overhead calculated by flags (whether CRC is enabled, etc) */ /* Page capacity ( " useful load " ) calculated by flags ( TRANSLOG_PAGE_SIZE - page_overhead - 1 ) /* Path to the directory where we store log store files */ char directory[FN_REFLEN];/* *** Current state of the log handler *** */ /* list of opened files */ /* min/max number of file in the array */ /* the opened files list guard */ /* File descriptor of the directory where we store log files for syncing it . /* buffers for log writing */ struct st_translog_buffer buffers[TRANSLOG_BUFFERS_NO];/* Mask where 1 in position N mean that buffer N is not flushed */ /* The above variable protection */ /* horizon - visible end of the log ( here is absolute end of the log : position where next chunk can start /* horizon buffer cursor */ struct st_buffer_cursor bc;/* maximum LSN of the current (not finished) file */ /* Last flushed LSN ( protected by log_flush_lock ) . Pointers in the log ordered like this : last_lsn_checked < = flushed < = sent_to_disk < = in_buffers_only < = max_lsn < = horizon /* Last LSN sent to the disk (but maybe not written yet) */ /* Horizon from which log started after initialization */ /* All what is after this address is not sent to disk yet */ /* protection of sent_to_disk and in_buffers_only */ /* Protect flushed ( see above ) and for flush serialization ( will be removed in v1 . 5 /* Protects changing of headers of finished files (max_lsn) */ /* Sorted array ( with protection ) of files where we started writing process and so we can ' t give last LSN yet /* minimum number of still needed file calculated during last translog_purge call /* Purger data: minimum file in the log (or 0 if unknown) */ /* Protect purger from many calls and it's data */ /* last low water mark checked */ /** Must be set to 0 under loghandler lock every time a new LSN is generated . /* True when flush pass is in progress */ /* The flush number (used to distinguish two flushes goes one by one) */ volatile int flush_no;/* Next flush pass variables */ static struct st_translog_descriptor log_descriptor;/* sync() of log files directory mode */ 0 ;/* Marker for end of log */ static uchar end_of_log= 0 ;#define END_OF_LOG &end_of_log/** Switch for " soft " sync ( no real sync ( ) but periodical sync by service thread ) static volatile my_bool soft_sync= FALSE ;/** Switch for " hard " group commit mode static volatile my_bool hard_group_commit= FALSE ;/** File numbers interval which have to be sync ( ) static uint32 soft_sync_min= 0 ;static uint32 soft_sync_max= 0 ;static uint32 soft_need_sync= 1 ;/** stores interval in microseconds static uint32 group_commit_wait= 0 ;enum enum_translog_status translog_status= TRANSLOG_UNINITED;0 ; /* Number of sync()s */ /* time of last flush */ static ulonglong flush_start= 0 ;/* chunk types */ #define TRANSLOG_CHUNK_LSN 0 x00 /* 0 chunk refer as LSN (head or tail */ #define TRANSLOG_CHUNK_FIXED (1 << 6 ) /* 1 (pseudo)fixed record (also LSN) */ #define TRANSLOG_CHUNK_NOHDR (2 << 6 ) /* 2 no head chunk (till page end) */ #define TRANSLOG_CHUNK_LNGTH (3 << 6 ) /* 3 chunk with chunk length */ #define TRANSLOG_CHUNK_TYPE (3 << 6 ) /* Mask to get chunk type */ #define TRANSLOG_REC_TYPE 0 x3F /* Mask to get record type */ #define TRANSLOG_CHUNK_0_CONT 0 x3F /* the type to mark chunk 0 continue */ /* compressed (relative) LSN constants */ #define TRANSLOG_CLSN_LEN_BITS 0 xC0 /* Mask to get compressed LSN length */ /* an array that maps id of a MARIA_SHARE to this MARIA_SHARE */ static MARIA_SHARE **id_to_share= NULL;static my_bool translog_page_validator(int res, PAGECACHE_IO_HOOK_ARGS *args);static my_bool translog_get_next_chunk(TRANSLOG_SCANNER_DATA *scanner);static uint32 translog_first_file(TRANSLOG_ADDRESS horizon, int is_protected);static void translog_free_link(PAGECACHE_BLOCK_LINK *direct_link);/* Initialize log_record_type_descriptors #ifndef DBUG_OFF#define translog_buffer_lock_assert_owner(B) \#define translog_lock_assert_owner() \void translog_lock_handler_assert_owner()/** @ brief check the description table validity @ param num how many records should be filled static uint max_allowed_translog_type= 0 ;void check_translog_description_table(int num)int i;"check_translog_description_table" );"enter" , ("last record: %d" , num));0 );/* last is reserved for extending the table */ 1 );0 ].rclass == LOGRECTYPE_NOT_ALLOWED);for (i= 0 ; i <= num; i++)"info" ,"record type: %d class: %d fixed: %u header: %u LSNs: %u " "name: %s" ,switch (log_record_type_descriptor[i].rclass) {case LOGRECTYPE_NOT_ALLOWED:0 );break ;case LOGRECTYPE_VARIABLE_LENGTH:0 );0 ) ||1 ) &&2 ) &&2 )));break ;case LOGRECTYPE_PSEUDOFIXEDLENGTH:0 );2 );break ;case LOGRECTYPE_FIXEDLENGTH:0 );break ;default :0 );for (i= num + 1 ; i < LOGREC_NUMBER_OF_TYPES; i++)#else #define translog_buffer_lock_assert_owner(B) {}#define translog_lock_assert_owner() {}#endif static LOG_DESC INIT_LOGREC_RESERVED_FOR_CHUNKS23=0 , 0 , NULL, NULL, NULL, 0 ,"reserved" , LOGREC_NOT_LAST_IN_GROUP, NULL, NULL };static LOG_DESC INIT_LOGREC_REDO_INSERT_ROW_HEAD=0 ,0 ,"redo_insert_row_head" , LOGREC_NOT_LAST_IN_GROUP, NULL, NULL};static LOG_DESC INIT_LOGREC_REDO_INSERT_ROW_TAIL=0 ,0 ,"redo_insert_row_tail" , LOGREC_NOT_LAST_IN_GROUP, NULL, NULL};static LOG_DESC INIT_LOGREC_REDO_NEW_ROW_HEAD=0 ,0 ,"redo_new_row_head" , LOGREC_NOT_LAST_IN_GROUP, NULL, NULL};static LOG_DESC INIT_LOGREC_REDO_NEW_ROW_TAIL=0 ,0 ,"redo_new_row_tail" , LOGREC_NOT_LAST_IN_GROUP, NULL, NULL};static LOG_DESC INIT_LOGREC_REDO_INSERT_ROW_BLOBS=0 , FILEID_STORE_SIZE, NULL,0 ,"redo_insert_row_blobs" , LOGREC_NOT_LAST_IN_GROUP, NULL, NULL};static LOG_DESC INIT_LOGREC_REDO_PURGE_ROW_HEAD=0 ,"redo_purge_row_head" , LOGREC_NOT_LAST_IN_GROUP, NULL, NULL};static LOG_DESC INIT_LOGREC_REDO_PURGE_ROW_TAIL=0 ,"redo_purge_row_tail" , LOGREC_NOT_LAST_IN_GROUP, NULL, NULL};static LOG_DESC INIT_LOGREC_REDO_FREE_BLOCKS=0 ,0 ,"redo_free_blocks" , LOGREC_NOT_LAST_IN_GROUP, NULL, NULL};static LOG_DESC INIT_LOGREC_REDO_FREE_HEAD_OR_TAIL=0 ,"redo_free_head_or_tail" , LOGREC_NOT_LAST_IN_GROUP, NULL, NULL};/* not yet used; for when we have versioning */ static LOG_DESC INIT_LOGREC_REDO_DELETE_ROW=16 , 16 , NULL, write_hook_for_redo, NULL, 0 ,"redo_delete_row" , LOGREC_NOT_LAST_IN_GROUP, NULL, NULL};/** @todo RECOVERY BUG unused, remove? */ static LOG_DESC INIT_LOGREC_REDO_UPDATE_ROW_HEAD=0 , 9 , NULL, write_hook_for_redo, NULL, 0 ,"redo_update_row_head" , LOGREC_NOT_LAST_IN_GROUP, NULL, NULL};static LOG_DESC INIT_LOGREC_REDO_INDEX=0 , 9 , NULL, write_hook_for_redo, NULL, 0 ,"redo_index" , LOGREC_NOT_LAST_IN_GROUP, NULL, NULL};static LOG_DESC INIT_LOGREC_REDO_INDEX_NEW_PAGE=0 ,2 + KEY_NR_STORE_SIZE + 1 ,0 ,"redo_index_new_page" , LOGREC_NOT_LAST_IN_GROUP, NULL, NULL};static LOG_DESC INIT_LOGREC_REDO_INDEX_FREE_PAGE=2 ,2 ,0 ,"redo_index_free_page" , LOGREC_NOT_LAST_IN_GROUP, NULL, NULL};static LOG_DESC INIT_LOGREC_REDO_UNDELETE_ROW=16 , 16 , NULL, write_hook_for_redo, NULL, 0 ,"redo_undelete_row" , LOGREC_NOT_LAST_IN_GROUP, NULL, NULL};static LOG_DESC INIT_LOGREC_CLR_END=0 , LSN_STORE_SIZE + FILEID_STORE_SIZE +1 ,"clr_end" , LOGREC_LAST_IN_GROUP, NULL, NULL};static LOG_DESC INIT_LOGREC_PURGE_END=5 , 5 , NULL, NULL, NULL, 1 ,"purge_end" , LOGREC_LAST_IN_GROUP, NULL, NULL};static LOG_DESC INIT_LOGREC_UNDO_ROW_INSERT=0 ,1 ,"undo_row_insert" , LOGREC_LAST_IN_GROUP, NULL, NULL};static LOG_DESC INIT_LOGREC_UNDO_ROW_DELETE=0 ,1 ,"undo_row_delete" , LOGREC_LAST_IN_GROUP, NULL, NULL};static LOG_DESC INIT_LOGREC_UNDO_ROW_UPDATE=0 ,1 ,"undo_row_update" , LOGREC_LAST_IN_GROUP, NULL, NULL};static LOG_DESC INIT_LOGREC_UNDO_KEY_INSERT=0 ,1 ,"undo_key_insert" , LOGREC_LAST_IN_GROUP, NULL, NULL};/* This will never be in the log, only in the clr */ static LOG_DESC INIT_LOGREC_UNDO_KEY_INSERT_WITH_ROOT=0 ,1 ,"undo_key_insert_with_root" , LOGREC_LAST_IN_GROUP, NULL, NULL};static LOG_DESC INIT_LOGREC_UNDO_KEY_DELETE=0 ,1 ,"undo_key_delete" , LOGREC_LAST_IN_GROUP, NULL, NULL};static LOG_DESC INIT_LOGREC_UNDO_KEY_DELETE_WITH_ROOT=0 ,1 ,"undo_key_delete_with_root" , LOGREC_LAST_IN_GROUP, NULL, NULL};static LOG_DESC INIT_LOGREC_PREPARE=0 , 0 , NULL, NULL, NULL, 0 ,"prepare" , LOGREC_IS_GROUP_ITSELF, NULL, NULL};static LOG_DESC INIT_LOGREC_PREPARE_WITH_UNDO_PURGE=0 , LSN_STORE_SIZE, NULL, NULL, NULL, 1 ,"prepare_with_undo_purge" , LOGREC_IS_GROUP_ITSELF, NULL, NULL};static LOG_DESC INIT_LOGREC_COMMIT=0 , 0 , NULL,0 , "commit" , LOGREC_IS_GROUP_ITSELF, NULL,static LOG_DESC INIT_LOGREC_COMMIT_WITH_UNDO_PURGE=5 , 5 , NULL, write_hook_for_commit, NULL, 1 ,"commit_with_undo_purge" , LOGREC_IS_GROUP_ITSELF, NULL, NULL};static LOG_DESC INIT_LOGREC_CHECKPOINT=0 , 0 , NULL, NULL, NULL, 0 ,"checkpoint" , LOGREC_IS_GROUP_ITSELF, NULL, NULL};static LOG_DESC INIT_LOGREC_REDO_CREATE_TABLE=0 , 1 + 2 , NULL, NULL, NULL, 0 ,"redo_create_table" , LOGREC_IS_GROUP_ITSELF, NULL, NULL};static LOG_DESC INIT_LOGREC_REDO_RENAME_TABLE=0 , 0 , NULL, NULL, NULL, 0 ,"redo_rename_table" , LOGREC_IS_GROUP_ITSELF, NULL, NULL};static LOG_DESC INIT_LOGREC_REDO_DROP_TABLE=0 , 0 , NULL, NULL, NULL, 0 ,"redo_drop_table" , LOGREC_IS_GROUP_ITSELF, NULL, NULL};static LOG_DESC INIT_LOGREC_REDO_DELETE_ALL=0 ,"redo_delete_all" , LOGREC_IS_GROUP_ITSELF, NULL, NULL};static LOG_DESC INIT_LOGREC_REDO_REPAIR_TABLE=8 + 8 , FILEID_STORE_SIZE + 8 + 8 ,0 ,"redo_repair_table" , LOGREC_IS_GROUP_ITSELF, NULL, NULL};static LOG_DESC INIT_LOGREC_FILE_ID=0 , 2 , NULL, write_hook_for_file_id, NULL, 0 ,"file_id" , LOGREC_IS_GROUP_ITSELF, NULL, NULL};static LOG_DESC INIT_LOGREC_LONG_TRANSACTION_ID=6 , 6 , NULL, NULL, NULL, 0 ,"long_transaction_id" , LOGREC_IS_GROUP_ITSELF, NULL, NULL};static LOG_DESC INIT_LOGREC_INCOMPLETE_LOG=0 ,"incomplete_log" , LOGREC_IS_GROUP_ITSELF, NULL, NULL};static LOG_DESC INIT_LOGREC_INCOMPLETE_GROUP=0 , 0 ,0 ,"incomplete_group" , LOGREC_IS_GROUP_ITSELF, NULL, NULL};static LOG_DESC INIT_LOGREC_UNDO_BULK_INSERT=0 ,1 ,"undo_bulk_insert" , LOGREC_LAST_IN_GROUP, NULL, NULL};static LOG_DESC INIT_LOGREC_REDO_BITMAP_NEW_PAGE=2 ,2 ,0 ,"redo_create_bitmap" , LOGREC_IS_GROUP_ITSELF, NULL, NULL};static LOG_DESC INIT_LOGREC_IMPORTED_TABLE=0 , 0 , NULL, NULL, NULL, 0 ,"imported_table" , LOGREC_IS_GROUP_ITSELF, NULL, NULL};static LOG_DESC INIT_LOGREC_DEBUG_INFO=0 , 0 , NULL, NULL, NULL, 0 ,"info" , LOGREC_IS_GROUP_ITSELF, NULL, NULL};const myf log_write_flags= MY_WME | MY_NABP | MY_WAIT_IF_FULL;void translog_table_init()int i;for (i= LOGREC_FIRST_FREE; i < LOGREC_NUMBER_OF_TYPES; i++)#ifndef DBUG_OFF1 );#endif /* all possible flags page overheads */ static uint page_overhead[TRANSLOG_FLAGS_NUM];typedef struct st_translog_validator_data/* Check cursor / buffer consistence SYNOPSIS translog_check_cursor cursor cursor which will be checked static void translog_check_cursor(struct st_buffer_cursor *cursor/** @ brief switch the loghandler in read only mode in case of write error void translog_stop_writing()"translog_stop_writing" );"error" , ("errno: %d my_errno: %d" , errno, my_errno));1 ;0 );/* @ brief Get file name of the log by log number @ param file_no Number of the log we want to open @ param path Pointer to buffer where file name will be stored ( must be FN_REFLEN bytes at least ) @ return pointer to path char *translog_filename_by_fileno(uint32 file_no, char *path)char buff[11 ], *end;"translog_filename_by_fileno" );0 xfffffff);/* log_descriptor.directory is already formatted */ "aria_log.0000000" , NullS);10 ) - buff);1 , buff);"info" , ("Path: '%s' path: %p" , path, path));/** @ brief Create log file with given number without cache @ param file_no Number of the log we want to open retval - 1 error retval # file descriptor number static File create_logfile_by_number_no_cache(uint32 file_no)char path[FN_REFLEN];"create_logfile_by_number_no_cache" );if (translog_status != TRANSLOG_OK)1 );/* TODO: add O_DIRECT to open flags (when buffer is aligned) */ if ((file= mysql_file_create(key_file_translog,0 , O_BINARY | O_RDWR | O_CLOEXEC, MYF(MY_WME))) < 0 )"error" , ("Error %d during creating file '%s'" , errno, path));1 );if (sync_log_dir >= TRANSLOG_SYNC_DIR_NEWFILE &&"error" , ("Error %d during syncing directory '%s'" ,0 ));1 );"info" , ("File: '%s' handler: %d" , path, file));/** @ brief Open ( not create ) log file with given number without cache @ param file_no Number of the log we want to open retval - 1 error retval # file descriptor number static File open_logfile_by_number_no_cache(uint32 file_no)char path[FN_REFLEN];"open_logfile_by_number_no_cache" );/* TODO: add O_DIRECT to open flags (when buffer is aligned) */ /* TODO: use mysql_file_create() */ if ((file= mysql_file_open(key_file_translog,0 )"error" , ("Error %d during opening file '%s'" , errno, path));1 );"info" , ("File: '%s' handler: %d" , path, file));/** @ brief get file descriptor by given number using cache @ param file_no Number of the log we want to open retval # file descriptor retval NULL file is not opened static TRANSLOG_FILE *get_logfile_by_number(uint32 file_no)"get_logfile_by_number" );if (log_descriptor.max_file - file_no >="info" , ("File #%u is not opened" , file_no));1 =="info" , ("File %p File no: %u, File handler: %d" ,1 )));/** @ brief get current file descriptor retval # file descriptor static TRANSLOG_FILE *get_current_logfile()"get_current_logfile" );"info" , ("max_file: %lu min_file: %lu open_files: %lu" ,1 ==0 , TRANSLOG_FILE **);254 , (uchar) 254 , (uchar) 11 , '\001' , 'M' , 'A' , 'R' , 'I' , 'A' ,'L' , 'O' , 'G' };/* Write log file page header in the just opened new log file SYNOPSIS translog_write_file_header ( ) ; NOTES First page is just a marker page ; We don ' t store any real log data in it . RETURN 0 OK 1 ERROR static my_bool translog_write_file_header()"translog_write_file_header" );/* file tag */ sizeof (maria_trans_file_magic));sizeof (maria_trans_file_magic);/* timestamp */ 8 ;/* maria version */ 4 ;/* mysql version (MYSQL_VERSION_ID) */ 4 ;/* server ID */ 4 ;/* loghandler page_size */ 1 );2 ;/* file number */ 3 ;sizeof (page_buff) - (page- page_buff));sizeof (page_buff), 0 ,0 ;/* Dropping the flag in such way can make false alarm : signalling than the file in not sync when it is sync , but the situation is quite rare and protections with mutexes give much more overhead to the whole engine 0 ;/* @ brief write the new LSN on the given file header @ param file The file descriptor @ param lsn That LSN which should be written @ retval 0 OK @ retval 1 Error static my_bool translog_max_lsn_to_header(File file, LSN lsn)"translog_max_lsn_to_header" );"enter" , ("File descriptor: %ld " "lsn: " LSN_FMT,long ) file,0 ||0 );/* We should not increase counter in case of error above , but it is so unlikely that we can ignore this case /* @ brief Extract hander file information from loghandler file page @ param desc header information descriptor to be filled with information @ param page_buff buffer with the page content void translog_interpret_file_header(LOGHANDLER_FILE_INFO *desc,sizeof (maria_trans_file_magic);8 ;4 ;4 ;4 ;1 ;2 ;3 ;/* @ brief Read hander file information from loghandler file @ param desc header information descriptor to be filled with information @ param file file descriptor to read @ retval 0 OK @ retval 1 Error "translog_read_file_header" );if (mysql_file_pread(file, page_buff,sizeof (page_buff), 0 , MYF(MY_FNABP | MY_WME)))"info" , ("log read fail error: %d" , my_errno));1 );"info" , ("timestamp: %llu aria ver: %lu mysql ver: %lu " "server id %lu page size %lu file number %lu " "max lsn: " LSN_FMT,0 );/* @ brief set the lsn to the files from_file - to_file if it is greater then written in the file @ param from_file first file number ( min ) @ param to_file last file number ( max ) @ param lsn the lsn for writing @ param is_locked true if current thread locked the log handler @ retval 0 OK @ retval 1 Error static my_bool translog_set_lsn_for_files(uint32 from_file, uint32 to_file,"translog_set_lsn_for_files" );"enter" , ("From: %lu to: %lu lsn: " LSN_FMT " locked: %d" ,0 ); /* we have not file 0 */ /* Checks the current file (not finished yet file) */ if (!is_locked)if (to_file == (uint32) LSN_FILE_NO(log_descriptor.horizon))if (likely(cmp_translog_addr(lsn, log_descriptor.max_lsn) > 0 ))if (!is_locked)/* Checks finished files if they are */ for (file= from_file; file <= to_file; file++)if ((fd < 0 ) ||0 &&1 );0 );/* descriptor of file in unfinished_files */ struct st_file_counter/* file number */ /* counter for started writes */ /* @ brief mark file " in progress " ( for multi - group records ) @ param file log file number static void translog_mark_file_unfinished(uint32 file)struct st_file_counter fc, *fc_ptr;"translog_mark_file_unfinished" );"enter" , ("file: %lu" , (ulong) file));1 ;if (log_descriptor.unfinished_files.elements == 0 )"info" , ("The first element inserted" ));goto end;for (place= log_descriptor.unfinished_files.elements - 1 ;0 ;struct st_file_counter *);if (fc_ptr->file <= file)break ;if (place >= 0 && fc_ptr->file == file)"info" , ("counter increased" ));goto end;if (place == (ssize_t)log_descriptor.unfinished_files.elements)"info" , ("The last element inserted" ));goto end;/* shift and assign new element */ 1 ,struct st_file_counter *));for (i= log_descriptor.unfinished_files.elements - 1 ; i > place; i--)/* we do not use set_dynamic() to avoid unneeded checks */ struct st_file_counter *),1 , struct st_file_counter *),sizeof (struct st_file_counter));1 , struct st_file_counter *),sizeof (struct st_file_counter));/* @ brief remove file mark " in progress " ( for multi - group records ) @ param file log file number static void translog_mark_file_finished(uint32 file)int i;struct st_file_counter *UNINIT_VAR(fc_ptr);"translog_mark_file_finished" );"enter" , ("file: %lu" , (ulong) file));0 );for (i= 0 ;int ) log_descriptor.unfinished_files.elements;struct st_file_counter *);if (fc_ptr->file == file)break ;int ) log_descriptor.unfinished_files.elements);if (! --fc_ptr->counter)/* @ brief get max LSN of the record which parts stored in this file @ param file file number @ return requested LSN or LSN_IMPOSSIBLE / LSN_ERROR @ retval LSN_IMPOSSIBLE File is still not finished @ retval LSN_ERROR Error opening file @ retval # LSN of the record which parts stored in this file "translog_get_file_max_lsn_stored" );"enter" , ("file: %lu" , (ulong)file));/* find file with minimum file number "in progress" */ if (log_descriptor.unfinished_files.elements > 0 )struct st_file_counter *fc_ptr;0 , struct st_file_counter *);/* minimal file number "in progress" */ /* if there is no " in progress file " then unfinished file is in progress for sure if (limit == FILENO_IMPOSSIBLE)if (file >= limit)"info" , ("The file in progress" ));if (fd < 0 ) "error" , ("Can't open file" ));if (translog_read_file_header(&info, fd))"error" , ("Can't read file header" ));if (mysql_file_close(fd, MYF(MY_WME)))"error" , ("Can't close file" ));"info" , ("Max lsn: " LSN_FMT, LSN_IN_PARTS(info.max_lsn)));/* Initialize transaction log file buffer SYNOPSIS translog_buffer_init ( ) buffer The buffer to initialize num Number of this buffer RETURN 0 OK 1 Error static my_bool translog_buffer_init(struct st_translog_buffer *buffer, int num)"translog_buffer_init" );"info" , ("last_lsn and prev_last_lsn set to 0 buffer: %p" ,/* This Buffer File */ 0 ;/* cache for current log */ /* Buffer size */ 0 ;0 ;/* cond of thread which is waiting for buffer filling */ if (mysql_cond_init(key_TRANSLOG_BUFFER_waiting_filling_buffer,0 ))1 );/* Number of records which are in copy progress */ 0 ;/* list of waiting buffer ready threads */ 0 ;/* Buffers locked by the following mutex . As far as buffers create logical circle ( after last buffer goes first ) it trigger false alarm of deadlock detect system , so we remove check of deadlock for this buffers . Indeed all mutex locks concentrated around current buffer except flushing thread ( but it is only one thread ) . One thread can ' t take more then 2 buffer locks at once . So deadlock is impossible here . To prevent false alarm of dead lock detection we switch dead lock detection for one buffer in the middle of the buffers chain . Excluding only one of eight buffers from deadlock detection hardly can hide other possible problems which include this mutexes . if (mysql_mutex_init(key_TRANSLOG_BUFFER_mutex,0 ))1 );0 ;0 ;0 );/* @ brief close transaction log file by descriptor @ param file pagecache file descriptor reference @ return Operation status @ retval 0 OK @ retval 1 Error static my_bool translog_close_log_file(TRANSLOG_FILE *file)int rc= 0 ;/* Sync file when we close it TODO : sync only we have changed the log if (!file->is_sync)return MY_TEST(rc);/** @ brief Initializes TRANSLOG_FILE structure @ param file reference on the file to initialize @ param number file number @ param is_sync is file synced on disk static void translog_file_init(TRANSLOG_FILE *file, uint32 number,0 ;/** @ brief Create and fill header of new file . @ note the caller must call it right after it has increased log_descriptor . horizon to the new file ( log_descriptor . horizon + = LSN_ONE_FILE ) @ retval 0 OK @ retval 1 Error static my_bool translog_create_new_file()sizeof (TRANSLOG_FILE),0 ));"translog_create_new_file" );if (file == NULL)goto error;/* Writes max_lsn to the file header before finishing it ( there is no need to lock file header buffer because it is still unfinished file , so only one thread can finish the file and nobody interested of LSN of current ( unfinished ) file , because no one can purge it ) . if (translog_max_lsn_to_header(old->handler.file, log_descriptor.max_lsn))goto error;1 ==1 );if (allocate_dynamic(&log_descriptor.open_files,2 ))goto error_lock;/* this call just expand the array */ if (insert_dynamic(&log_descriptor.open_files, (uchar*)&file))goto error_lock;if ((file->handler.file= create_logfile_by_number_no_cache(file_no)) == -1 )goto error_lock;0 );char *start= (char *) dynamic_element(&log_descriptor.open_files, 0 ,sizeof (TRANSLOG_FILE*), start,sizeof (TRANSLOG_FILE*) *1 - 1 ));/* can't fail we because we expanded array */ 0 );1 =="info" , ("file_no: %lu" , (ulong)file_no));if (translog_write_file_header())goto error;if (ma_control_file_write_and_force(last_checkpoint_lsn, file_no,goto error;0 );1 );/** @ brief Locks the loghandler buffer . @ param buffer This buffer which should be locked @ note See comment before buffer ' mutex ' variable . @ retval 0 OK @ retval 1 Error static void translog_buffer_lock(struct st_translog_buffer *buffer)"translog_buffer_lock" );"enter" ,"Lock buffer #%u: %p" , buffer->buffer_no,/* Unlock the loghandler buffer SYNOPSIS translog_buffer_unlock ( ) buffer This buffer which should be unlocked static void translog_buffer_unlock(struct st_translog_buffer *buffer)"translog_buffer_unlock" );"enter" , ("Unlock buffer... #%u (%p)" ,/* Write a header on the page SYNOPSIS translog_new_page_header ( ) horizon Where to write the page cursor Where to write the page NOTE - space for page header should be checked before static uchar translog_sector_random;static void translog_new_page_header(TRANSLOG_ADDRESS *horizon,struct st_buffer_cursor *cursor)"translog_new_page_header" );protected = 0 ;/* Page number */ 3 ;/* File number */ 3 ;if (log_descriptor.flags & TRANSLOG_PAGE_CRC)#ifndef DBUG_OFF"info" , ("write 0x11223344 CRC to " LSN_FMT,/* This will be overwritten by real CRC; This is just for debugging */ 0 x11223344);#endif /* CRC will be put when page is finished */ if (log_descriptor.flags & TRANSLOG_SECTOR_PROTECTION)/* translog_sector_randmo works like " random " values producer because it is enough to have such " random " for this purpose and it will not interfere with higher level pseudo random value generator 0 ]= translog_sector_random++;/* increasing the offset part of the address */ if (!cursor->chaser)"info" , ("NewP buffer #%u: %p chaser: %d Size: %lu (%lu) " "Horizon: " LSN_FMT,/* Put sector protection on the page image SYNOPSIS translog_put_sector_protection ( ) page reference on the page content cursor cursor of the buffer NOTES We put a sector protection on all following sectors on the page , except the first sector that is protected by page header . static void translog_put_sector_protection(uchar *page,struct st_buffer_cursor *cursor)1 ) /0 ] + cursor->write_counter;"translog_put_sector_protection" );if (start_sector == 0 )/* First sector is protected by file & page numbers in the page header. */ 1 ;"enter" , ("Write counter:%u value:%u offset:%u, " "last protected:%u start sector:%u" ,if (last_protected_sector == start_sector)/* restore data, because we modified sector which was protected */ if (offset < cursor->previous_offset)for (i= start_sector, offset= start_sector * DISK_DRIVE_SECTOR_SIZE;"info" , ("sector:%u offset:%u data 0x%x" ,"info" , ("sector:%u offset:%u data 0x%x" ,/* Calculate CRC32 of given area SYNOPSIS translog_crc ( ) area Pointer of the area beginning length The Area length RETURN CRC32 static uint32 translog_crc(uchar *area, uint length)"translog_crc" );0 L, area, length));/* Finish current page with zeros SYNOPSIS translog_finish_page ( ) horizon \ horizon & buffer pointers cursor / static void translog_finish_page(TRANSLOG_ADDRESS *horizon,struct st_buffer_cursor *cursor)"translog_finish_page" );"enter" , ("Buffer: #%u %p " "Buffer addr: " LSN_FMT " " "Page addr: " LSN_FMT " " "size:%u (%u) Pg:%u left:%u" ,if ((LSN_FILE_NO(*horizon) != LSN_FILE_NO(cursor->buffer->offset)))// everything wrong do not write to avoid more problems if (cursor->protected )"info" , ("Already protected and finished" ));protected = 1 ;if (left != 0 )"info" , ("left: %u" , (uint) left));/* offset increasing */ if (!cursor->chaser)/* We are finishing the page so reset the counter */ 0 ;"info" , ("Finish Page buffer #%u: %p " "chaser: %d Size: %lu (%lu)" ,/* When we are finishing the page other thread might not finish the page header yet ( in case if we started from the middle of the page ) so we have to read log_descriptor . flags but not the flags from the page . if (log_descriptor.flags & TRANSLOG_SECTOR_PROTECTION)"info" , ("drop write_counter" ));0 ;0 ;if (log_descriptor.flags & TRANSLOG_PAGE_CRC)"info" , ("CRC: %lx" , (ulong) crc));/* We have page number, file number and flag before crc */ 3 + 3 + 1 , crc);/* @ brief Wait until all threads have finished closing this buffer . @ param buffer This buffer should be check static void translog_wait_for_closing(struct st_translog_buffer *buffer)"translog_wait_for_closing" );"enter" , ("Buffer #%u %p copies in progress: %u " "is closing %u File: %d size: %lu" ,1 ),while (buffer->is_closing_buffer)"info" , ("wait for writers... buffer: #%u %p" ,"info" , ("wait for writers done buffer: #%u %p" ,/* @ brief Wait until all threads have finished filling this buffer . @ param buffer This buffer should be check static void translog_wait_for_writers(struct st_translog_buffer *buffer)"translog_wait_for_writers" );"enter" , ("Buffer #%u %p copies in progress: %u " "is closing %u File: %d size: %lu" ,1 ),while (buffer->copy_to_buffer_in_progress)"info" , ("wait for writers... buffer: #%u %p" ,"info" , ("wait for writers done buffer: #%u %p" ,/* Wait for buffer to become free SYNOPSIS translog_wait_for_buffer_free ( ) buffer The buffer we are waiting for NOTE - this buffer should be locked static void translog_wait_for_buffer_free(struct st_translog_buffer *buffer)"translog_wait_for_buffer_free" );"enter" , ("Buffer #%u %p copies in progress: %u " "is closing %u File: %d size: %lu" ,1 ),if (offset != buffer->offset || file != buffer->file || ver != buffer->ver)/* the buffer if already freed */ while (buffer->file != NULL)"info" , ("wait for writers... buffer: #%u %p" ,"info" , ("wait for writers done. buffer: #%u %p" ,0 );/* Initialize the cursor for a buffer SYNOPSIS translog_cursor_init ( ) buffer The buffer cursor It ' s cursor buffer_no Number of buffer static void translog_cursor_init(struct st_buffer_cursor *cursor,struct st_translog_buffer *buffer,"translog_cursor_init" );0 ;0 ;0 ;protected = 0 ;/* @ brief Initialize buffer for the current file , and a cursor for this buffer . @ param buffer The buffer @ param cursor It ' s cursor @ param buffer_no Number of buffer static void translog_start_buffer(struct st_translog_buffer *buffer,struct st_buffer_cursor *cursor,"translog_start_buffer" );"enter" ,"Assign buffer: #%u (%p) offset: 0x%x(%u)" ,"info" , ("last_lsn and prev_last_lsn set to 0 buffer: %p" ,0 ;0 ;0 ;"info" , ("file: #%ld (%d) init cursor #%u: %p " "chaser: %d Size: %lu (%lu)" ,long ) (buffer->file ? buffer->file->number : 0 ),1 ),1 << buffer->buffer_no);/* @ brief Switch to the next buffer in a chain . @ param horizon \ Pointers on current position in file and buffer @ param cursor / @ param new_file Also start new file @ note - loghandler should be locked - after return new and old buffer still are locked @ retval 0 OK @ retval 1 Error static my_bool translog_buffer_next(TRANSLOG_ADDRESS *horizon,struct st_buffer_cursor *cursor,1 ) % TRANSLOG_BUFFERS_NO;struct st_translog_buffer *new_buffer= log_descriptor.buffers + new_buffer_no;"translog_buffer_next" );"info" , ("horizon: " LSN_FMT " chasing: %d" ,0 );if (!chasing)#ifndef DBUG_OFF#endif #ifndef DBUG_OFF/* We keep the handler locked so nobody can start this new buffer */ 1 )) == new_buffer->ver);#endif else if (new_file)/* move the horizon to the next file and its header page */ if (!chasing && translog_create_new_file())1 );/* prepare next page */ if (chasing)else "info" , ("prev_last_lsn set to " LSN_FMT " buffer:%p" ,0 );/* Sets max LSN sent to file , and address from which data is only in the buffer SYNOPSIS translog_set_sent_to_disk ( ) buffer buffer which we have sent to disk TODO : use atomic operations if possible ( 64 bit architectures ? ) static void translog_set_sent_to_disk(struct st_translog_buffer *buffer)"translog_set_sent_to_disk" );"enter" , ("lsn: " LSN_FMT " in_buffers: " LSN_FMT " " "in_buffers_only: " LSN_FMT " start: " LSN_FMT " " "sent_to_disk: " LSN_FMT,/* We write sequentially ( first part of following assert ) but we rewrite the same page in case we started mysql and shut it down immediately ( second part of the following assert ) 0 ||0 );/* LSN_IMPOSSIBLE == 0 => it will work for very first time */ if (cmp_translog_addr(in_buffers, log_descriptor.in_buffers_only) > 0 )"info" , ("set new in_buffers_only" ));/* Sets address from which data is only in the buffer SYNOPSIS translog_set_only_in_buffers ( ) lsn LSN to assign in_buffers to assign to in_buffers_only static void translog_set_only_in_buffers(TRANSLOG_ADDRESS in_buffers)"translog_set_only_in_buffers" );"enter" , ("in_buffers: " LSN_FMT " " "in_buffers_only: " LSN_FMT,/* LSN_IMPOSSIBLE == 0 => it will work for very first time */ if (cmp_translog_addr(in_buffers, log_descriptor.in_buffers_only) > 0 )if (translog_status != TRANSLOG_OK)goto end;"info" , ("set new in_buffers_only" ));/* Gets address from which data is only in the buffer SYNOPSIS translog_only_in_buffers ( ) RETURN address from which data is only in the buffer static TRANSLOG_ADDRESS translog_only_in_buffers()register TRANSLOG_ADDRESS addr;"translog_only_in_buffers" );/* Get max LSN sent to file SYNOPSIS translog_get_sent_to_disk ( ) RETURN max LSN send to file static LSN translog_get_sent_to_disk()register LSN lsn;"translog_get_sent_to_disk" );"info" , ("sent to disk up to " LSN_FMT, LSN_IN_PARTS(lsn)));/* Get first chunk address on the given page SYNOPSIS translog_get_first_chunk_offset ( ) page The page where to find first chunk RETURN first chunk offset static my_bool translog_get_first_chunk_offset(uchar *page)"translog_get_first_chunk_offset" );/* Write coded length of record SYNOPSIS translog_write_variable_record_1group_code_len dst Destination buffer pointer length Length which should be coded header_len Calculated total header length static void switch (header_len) {case 6 : /* (5 + 1) */ 250 );return ;case 8 : /* (5 + 3) */ 0 xFFFF);251 ;1 , length);return ;case 9 : /* (5 + 4) */ 0 xFFFFFF);252 ;1 , length);return ;case 10 : /* (5 + 5) */ 253 ;1 , length);return ;default :0 );return ;/* Decode record data length and advance given pointer to the next field SYNOPSIS translog_variable_record_1group_decode_len ( ) src The pointer to the pointer to the length beginning RETURN decoded length static translog_size_t translog_variable_record_1group_decode_len(uchar **src)switch (first) {case 251 :3 ;return (uint2korr((*src) - 2 ));case 252 :4 ;return (uint3korr((*src) - 3 ));case 253 :5 ;return (uint4korr((*src) - 4 ));case 254 :case 255 :0 ); /* reserved for future use */ return (0 );default :return (first);/* Get total length of this chunk ( not only body ) SYNOPSIS translog_get_total_chunk_length ( ) page The page where chunk placed offset Offset of the chunk on this place RETURN total length of the chunk static uint16 translog_get_total_chunk_length(uchar *page, uint16 offset)"translog_get_total_chunk_length" );switch (page[offset] & TRANSLOG_CHUNK_TYPE) {case TRANSLOG_CHUNK_LSN:/* 0 chunk referred as LSN (head or tail) */ 1 + 2 ; /* chunk type and short trid */ "info" , ("TRANSLOG_CHUNK_LSN" ));2 ;"info" , ("rec len: %lu chunk len: %u header len: %u" ,if (chunk_len)"info" , ("chunk len: %u + %u = %u" ,"info" , ("page_rest %u" , (uint) page_rest));if (rec_len + header_len < page_rest)case TRANSLOG_CHUNK_FIXED:int i;/* 1 (pseudo)fixed record (also LSN) */ "info" , ("TRANSLOG_CHUNK_FIXED" ));if (log_record_type_descriptor[type].rclass == LOGRECTYPE_FIXEDLENGTH)"info" ,"Fixed length: %u" ,3 )));3 );3 ; /* first compressed LSN */ 3 ;for (i= 0 ; i < log_record_type_descriptor[type].compressed_LSN; i++)/* first 2 bits is length - 2 */ 6 ) + 2 ;if (ptr[0 ] == 0 && ((uint8) ptr[1 ]) == 1 )/* case of full LSN storing */ /* subtract saved bytes */ "info" , ("Pseudo-fixed length: %u" , length));case TRANSLOG_CHUNK_NOHDR:/* 2 no header chunk (till page end) */ "info" , ("TRANSLOG_CHUNK_NOHDR length: %u" ,case TRANSLOG_CHUNK_LNGTH: /* 3 chunk with chunk length */ "info" , ("TRANSLOG_CHUNK_LNGTH" ));3 );"info" , ("length: %u" , uint2korr(page + offset + 1 ) + 3 ));1 ) + 3 );default :0 );0 );/* @ brief Waits previous buffer flush finish @ param buffer buffer for check @ retval 0 previous buffer flushed and this thread have to flush this one @ retval 1 previous buffer flushed and this buffer flushed by other thread too struct st_translog_buffer *buffer)"translog_prev_buffer_flush_wait" );"enter" , ("buffer: %p #%u offset: " LSN_FMT " " "prev sent: " LSN_FMT " prev offset: " LSN_FMT,if (buffer->prev_buffer_offset != buffer->prev_sent_to_disk)do {if (buffer->file != file || buffer->offset != offset ||1 ); /* some the thread flushed the buffer already */ while (buffer->prev_buffer_offset != buffer->prev_sent_to_disk);0 );/* Flush given buffer SYNOPSIS translog_buffer_flush ( ) buffer This buffer should be flushed RETURN 0 OK 1 Error static my_bool translog_buffer_flush(struct st_translog_buffer *buffer)"translog_buffer_flush" );"enter" ,"Buffer: #%u %p file: %d offset: " LSN_FMT " size: %lu" ,if (buffer->file == NULL)0 );if (buffer->file != file || buffer->offset != offset || buffer->ver != ver)0 ); /* some the thread flushed the buffer already */ if (buffer->is_closing_buffer)/* some other flush in progress */ if (buffer->file != file || buffer->offset != offset || buffer->ver != ver)0 ); /* some the thread flushed the buffer already */ if (buffer->overlay && translog_prev_buffer_flush_wait(buffer))0 ); /* some the thread flushed the buffer already */ /* Send page by page in the pagecache what we are going to write on the disk for (i= 0 , pg= LSN_OFFSET(buffer->offset) / TRANSLOG_PAGE_SIZE;#ifdef DBUG_TRACE#endif "info" , ("send log form %lu till %lu address: " LSN_FMT " " "page #: %lu buffer size: %lu buffer: %p" ,if (translog_status != TRANSLOG_OK && translog_status != TRANSLOG_SHUTDOWN)1 );if (pagecache_write_part(log_descriptor.pagecache,3 ,0 ,"error" ,"Can't write page " LSN_FMT " to pagecache, error: %d" ,1 );0 ;0 ;if (my_pwrite(file->handler.file, buffer->buffer + buffer->skipped_data,"error" , ("Can't write buffer " LSN_FMT " size %lu " "to the disk (%d)" ,1 );/* Dropping the flag in such way can make false alarm : signalling than the file in not sync when it is sync , but the situation is quite rare and protections with mutexes give much more overhead to the whole engine 0 ;if (LSN_OFFSET(buffer->last_lsn) != 0 ) /* if buffer->last_lsn is set */ if (translog_prev_buffer_flush_wait(buffer))0 ); /* some the thread flushed the buffer already */ else /* say to next buffer that we are finished */ struct st_translog_buffer *next_buffer=1 ) % TRANSLOG_BUFFERS_NO);if (likely(translog_status == TRANSLOG_OK)){else /* It is shutdown = > 1 ) there is only one thread 2 ) mutexes of other buffers can be destroyed = > we can ' t use them /* Free buffer */ 0 ;1 << buffer->buffer_no);0 );/* Recover page with sector protection ( wipe out failed chunks ) SYNOPSYS translog_recover_page_up_to_sector ( ) page reference on the page offset offset of failed sector RETURN 0 OK 1 Error static my_bool translog_recover_page_up_to_sector(uchar *page, uint16 offset)"translog_recover_page_up_to_sector" );"enter" , ("offset: %u first chunk: %u" ,while (chunk_offset < offset && page[chunk_offset] != TRANSLOG_FILLER)if ((chunk_length=0 )"error" , ("cant get chunk length (offset %u)" ,1 );"info" , ("chunk: offset: %u length %u" ,if (((ulong) chunk_offset) + ((ulong) chunk_length) > TRANSLOG_PAGE_SIZE)"error" , ("damaged chunk (offset %u) in trusted area" ,1 );/* end of trusted area - sector parsing */ while (page[chunk_offset] != TRANSLOG_FILLER)if ((chunk_length=0 )break ;"info" , ("chunk: offset: %u length %u" ,if (((ulong) chunk_offset) + ((ulong) chunk_length) >break ;"info" , ("valid chunk end offset: %u" , (uint) valid_chunk_end));0 );/** @ brief Checks and removes sector protection . @ param page reference on the page content . @ param file transaction log descriptor . @ retvat 0 OK @ retval 1 Error static my_bool0 ];"translog_check_sector_protection" );for (i= 1 , offset= DISK_DRIVE_SECTOR_SIZE;/* TODO : add chunk counting for " suspecting " sectors ( difference is more than 1 - 2 ) , if difference more then present chunks then it is the problem . "info" , ("sector: #%u offset: %u current: %lx " "read: 0x%x stored: 0x%x%x" ,1 ]));/* 3 is minimal possible record length . So we can have " distance " between 2 sectors value more then DISK_DRIVE_SECTOR_SIZE / 3 only if it is old value , i . e . the sector was not written . if (((test < current) &&0 xFFL - current + test) > DISK_DRIVE_SECTOR_SIZE / 3 )) ||3 )))if (translog_recover_page_up_to_sector(page, offset))1 );1 ;0 );/* Restore value on the page */ "info" , ("sector: #%u offset: %u current: %lx " "read: 0x%x stored: 0x%x" ,0 );/** @ brief Log page validator ( read callback ) @ param page The page data to check @ param page_no The page number ( < offset > / < page length > ) @ param data_ptr Read callback data pointer ( pointer to TRANSLOG_FILE ) @ todo : add turning loghandler to read - only mode after merging with that patch . @ retval 0 OK @ retval 1 Error static my_bool translog_page_validator(int res, PAGECACHE_IO_HOOK_ARGS *args)#ifdef DBUG_TRACE#endif "translog_page_validator" );0 ;if (res)1 );if ((pgcache_page_no_t) uint3korr(page) != page_no ||3 ) != data->number)"error" , ("Page " LSN_FMT ": " "page address written in the page is incorrect: " "File %lu instead of %lu or page %lu instead of %lu" ,3 ), (ulong) data->number,1 );if (flags & ~(TRANSLOG_PAGE_CRC | TRANSLOG_SECTOR_PROTECTION |"error" , ("Page " LSN_FMT ": " "Garbage in the page flags field detected : %x" ,1 );3 + 3 + 1 );if (flags & TRANSLOG_PAGE_CRC)if (crc != uint4korr(page_pos))"error" , ("Page " LSN_FMT ": " "CRC mismatch: calculated: %lx on the page %lx" ,1 );/* Skip crc */ if (flags & TRANSLOG_SECTOR_PROTECTION &&1 );0 );/** @ brief Locks the loghandler . void translog_lock()"translog_lock" );/* Locking the loghandler mean locking current buffer , but it can change during locking , so we should check it for (;;)/* log_descriptor . bc . buffer_no is only one byte so its reading is an atomic operation if (log_descriptor.bc.buffer_no == current_buffer)break ;/* Unlock the loghandler SYNOPSIS translog_unlock ( ) RETURN 0 OK 1 Error void translog_unlock()/** @ brief Get log page by file number and offset of the beginning of the page @ param data validator data , which contains the page address @ param buffer buffer for page placing ( might not be used in some cache implementations ) @ param direct_link if it is not NULL then caller can accept direct link to the page cache @ retval NULL Error @ retval # pointer to the page cache which should be used to read this page static uchar *translog_get_page(TRANSLOG_VALIDATOR_DATA *data, uchar *buffer,"translog_get_page" );"enter" , ("File: %u Offset: %u(0x%x)" ,/* it is really page address */ 0 );if (direct_link)"info" , ("in_buffers: " LSN_FMT,if (in_buffers != LSN_IMPOSSIBLE &&0 )0 );/* recheck with locked loghandler */ if (cmp_translog_addr(addr, in_buffers) >= 0 )#ifdef DBUG_ASSERT_EXISTS#endif struct st_translog_buffer *buffer_unlock= log_descriptor.bc.buffer;struct st_translog_buffer *curr_buffer= log_descriptor.bc.buffer;for (;;)/* if the page is in the buffer and it is the last version of the page ( in case of division the page by buffer flush ) if (curr_buffer->file != NULL &&0 &&0 )int is_last_unfinished_page;0 ;if (offset != curr_buffer->offset || fl != curr_buffer->file ||goto restart;if (skipped_data && addr == curr_buffer->offset)/* We read page part of which is not present in buffer , so we should read absent part from file ( page cache actually ) /* it ' s ok to not lock the page because : - The log handler has it ' s own page cache . - There is only one thread that can access the log cache at a time if (!(buffer= pagecache_read(log_descriptor.pagecache,3 , buffer,else 0 ; /* Read after skipped in buffer data */ /* Now we have correct data in buffer up to ' skipped_data ' . The following memcpy ( ) will move the data from the internal buffer that was not yet on disk . /* We can use copy then in translog_page_validator ( ) because it do not put it permanently somewhere . We have to use copy because after releasing log lock we can ' t guaranty that the file still be present ( in real life it will be present but theoretically possible that it will be released already from last files cache ) ; if (is_last_unfinished_page &&1 ) /if (is_last_unfinished_page)/* This is last unfinished page = > we should not check CRC and remove only that protection which already installed ( no need to check it ) We do not check the flag of sector protection , because if ( buffer [ TRANSLOG_PAGE_FLAGS ] & TRANSLOG_SECTOR_PROTECTION ) is not set then last_protected_sector will be 0 so following loop will be never executed "info" , ("This is last unfinished page, " "last protected sector %u" ,for (i= 1 ; i <= last_protected_sector; i++)"info" , ("Sector %u: 0x%02x <- 0x%02x" ,else /* This IF should be true because we use in - memory data which supposed to be correct . if (translog_page_validator(0 , &args))0 );1 ) % TRANSLOG_BUFFERS_NO;/* we can't make a full circle */ 3 , (direct_link ? NULL : buffer),if (!buffer && direct_link)0 ;"info" , ("Direct link is assigned to : %p * %p" ,/** @ brief free direct log page link @ param direct_link the direct log page link to be freed static void translog_free_link(PAGECACHE_BLOCK_LINK *direct_link)"translog_free_link" );"info" , ("Direct link: %p" ,if (direct_link)0 , FALSE );/** @ brief Finds last full page of the given log file . @ param addr address structure to fill with data , which contain file number of the log file @ param last_page_ok Result of the check whether last page OK . ( for now only we check only that file length divisible on page length ) . @ param no_errors suppress messages about non - critical errors @ retval 0 OK @ retval 1 Error static my_bool translog_get_last_page_addr(TRANSLOG_ADDRESS *addr,char path[FN_REFLEN];#ifdef DBUG_TRACEchar buff[21 ];#endif "translog_get_last_page_addr" );if (likely((file= get_logfile_by_number(file_no)) != NULL))/* This function used only during initialization of loghandler or in scanner ( which mean we need read that part of the log ) , so the requested log file have to be opened and can ' t be freed after returning pointer on it ( file_size ) . 0 , SEEK_END, MYF(0 ));else /* This branch is used only during very early initialization when files are not opened . if ((fd= mysql_file_open(key_file_translog,0 ) : MYF(MY_WME)))) < 0 )"error" , ("Error %d during opening file #%d" ,1 );0 , SEEK_END, MYF(0 ));0 ));"info" , ("File size: %s" , llstr(file_size, buff)));if (file_size == MY_FILEPOS_ERROR)1 );0 xffffffffULL);if (((uint32)file_size) > TRANSLOG_PAGE_SIZE)1 ) *else 0 ;0 ;"info" , ("Last page: 0x%lx ok: %d" , (ulong) rec_offset,0 );/** @ brief Get number bytes for record length storing @ param length Record length which will be encoded @ return 1 , 3 , 4 , 5 - number of bytes to store given length static uint translog_variable_record_length_bytes(translog_size_t length)if (length < 250 )return 1 ;if (length < 0 xFFFF)return 3 ;if (length < (ulong) 0 xFFFFFF)return 4 ;return 5 ;/** @ brief Gets header of this chunk . @ param chunk The pointer to the chunk beginning @ retval # total length of the chunk @ retval 0 Error static uint16 translog_get_chunk_header_length(uchar *chunk)"translog_get_chunk_header_length" );switch (*chunk & TRANSLOG_CHUNK_TYPE) {case TRANSLOG_CHUNK_LSN:/* 0 chunk referred as LSN (head or tail) */ 1 + 2 ;"info" , ("TRANSLOG_CHUNK_LSN" ));2 ;"info" , ("rec len: %lu chunk len: %u header len: %u" ,if (chunk_len)/* TODO: fine header end */ /* The last chunk of multi - group record can be base for it header calculation ( we skip to the first group to read the header ) so if we stuck here something is wrong . 0 );0 ); /* Keep compiler happy */ case TRANSLOG_CHUNK_FIXED:/* 1 (pseudo)fixed record (also LSN) */ "info" , ("TRANSLOG_CHUNK_FIXED = 3" ));3 );case TRANSLOG_CHUNK_NOHDR:/* 2 no header chunk (till page end) */ "info" , ("TRANSLOG_CHUNK_NOHDR = 1" ));1 );break ;case TRANSLOG_CHUNK_LNGTH:/* 3 chunk with chunk length */ "info" , ("TRANSLOG_CHUNK_LNGTH = 3" ));3 );break ;0 );0 ); /* Keep compiler happy */ /** @ brief Truncate the log to the given address . Used during the startup if the end of log if corrupted . @ param addr new horizon @ retval 0 OK @ retval 1 Error static my_bool translog_truncate_log(TRANSLOG_ADDRESS addr)int rc;char path[FN_REFLEN];"translog_truncate_log" );/* TODO: write warning to the client */ "warning" , ("removing all records from " LSN_FMT " " "till " LSN_FMT,0 );/* remove files between the address and horizon */ for (i= LSN_FILE_NO(addr) + 1 ; i <= LSN_FILE_NO(log_descriptor.horizon); i++)if (mysql_file_delete(key_file_translog,1 );/* truncate the last file up to the last page */ 1 ) % TRANSLOG_PAGE_SIZE + 1 ) +0 ||0 ||0 && mysql_file_close(fd, MYF(MY_WME)));if (sync_log_dir >= TRANSLOG_SYNC_DIR_ALWAYS)if (rc)1 );/* fix the horizon */ /* fix the buffer data */ if ((page= translog_get_page(&data, log_descriptor.buffers->buffer, NULL)) ==1 );if (page != log_descriptor.buffers->buffer)0 );/** Applies function ' callback ' to all files ( in a directory ) which name looks like a log ' s name ( aria_log . [ 0 - 9 ] { 7 } ) . If ' callback ' returns TRUE this interrupts the walk and returns TRUE . Otherwise FALSE is returned after processing all log files . It cannot just use log_descriptor . directory because that may not yet have been initialized . @ param directory directory to scan @ param callback function to apply ; is passed directory and base name of found file const char *directory,const char *,const char *))FALSE ;/* Finds and removes transaction log files */ if (!(dirp = my_dir(directory, MYF(MY_DONT_SORT))))return FALSE ;for (i= 0 ; i < dirp->number_of_files; i++)char *file= dirp->dir_entry[i].name;if (strncmp(file, "aria_log." , 10 ) == 0 &&10 ] >= '0' && file[10 ] <= '9' &&11 ] >= '0' && file[11 ] <= '9' &&12 ] >= '0' && file[12 ] <= '9' &&13 ] >= '0' && file[13 ] <= '9' &&14 ] >= '0' && file[14 ] <= '9' &&15 ] >= '0' && file[15 ] <= '9' &&16 ] >= '0' && file[16 ] <= '9' &&17 ] >= '0' && file[17 ] <= '9' &&18 ] == '\0' && (*callback)(directory, file))TRUE ;break ;return rc;/** @ brief Fills table of dependence length of page header from page flags void translog_fill_overhead_table()for (i= 0 ; i < TRANSLOG_FLAGS_NUM; i++)7 ;if (i & TRANSLOG_PAGE_CRC)if (i & TRANSLOG_SECTOR_PROTECTION)/** Callback to find first log in directory . static my_bool translog_callback_search_first(const char *directoryconst char *filenamereturn TRUE ;/** @ brief Checks that chunk is LSN one @ param type type of the chunk @ retval 1 the chunk is LNS @ retval 0 the chunk is not LSN static my_bool translog_is_LSN_chunk(uchar type)"translog_is_LSN_chunk" );"info" , ("byte: %x chunk type: %u record type: %u" ,6 , type & TRANSLOG_REC_TYPE));/** @ brief Initialize transaction log @ param directory Directory where log files are put @ param log_file_max_size max size of one log size ( for new logs creation ) @ param server_version version of MySQL server ( MYSQL_VERSION_ID ) @ param server_id server ID ( replication & Co ) @ param pagecache Page cache for the log reads @ param flags flags ( TRANSLOG_PAGE_CRC , TRANSLOG_SECTOR_PROTECTION TRANSLOG_RECORD_CRC ) @ param read_only Put transaction log in read - only mode @ param init_table_func function to initialize record descriptors table @ param no_errors suppress messages about non - critical errors @ todo Free used resources in case of error . @ retval 0 OK @ retval 1 Error const char *directory,void (*init_table_func)(),int i;int old_log_was_recovered= 0 , logs_found= 0 ;1 ;0 ;"translog_init_with_table" );0 ;0 ;0 ;1 ;1 ;0 ;0 ;/* Normally in Aria this this calls translog_table_init() */ sizeof (log_descriptor.dirty_buffer_mask) * 8 >=0 ;if (readonly)else if (mysql_mutex_init(key_TRANSLOG_BUFFER_mutex,0 ) ||0 ) ||sizeof (TRANSLOG_FILE*), 10 , 10 , MYF(0 )) ||sizeof (struct st_file_counter),10 , 10 , MYF(0 )))goto err;0 ;0 ;/* Directory to store files */ #ifndef _WIN32if ((log_descriptor.directory_fd= my_open(log_descriptor.directory,0 )"error" , ("Error %d during opening directory '%s'" ,goto err;#endif 0 &&/* max size of one log size (for new logs creation) */ /* server version */ /* server ID */ /* Page cache for the log reads */ /* Flags */ 0 );1 ;0 );2 ;"info" ,"Overhead: %u pc2: %u bc2: %u, bc2/2: %u" ,/* Just to init it somehow (hack for bootstrap)*/ 0 ;1 ;0 );/* Buffers for log writing */ for (i= 0 ; i < TRANSLOG_BUFFERS_NO; i++)if (translog_buffer_init(log_descriptor.buffers + i, i))goto err;"info" , ("translog_buffer buffer #%u:%p" ,/* last_logno and last_checkpoint_lsn were set in ma_control_file_create_or_open ( ) if (logs_found)"info" , ("log found..." ));/* TODO : scan directory for aria_log . XXXXXXXX files and find highest XXXXXXXX & set logs_found TODO : check that last checkpoint within present log addresses space find the log end if (LSN_FILE_NO(last_checkpoint_lsn) == FILENO_IMPOSSIBLE)0 );/* only last log needs to be checked */ else 0 );/* Set horizon to the beginning of the last file first */ 0 );if (translog_get_last_page_addr(&last_page, &pageok, no_errors))if (!translog_walk_filenames(log_descriptor.directory,/* Files was deleted , just start from the next log number , so that existing tables are in the past . 1 ;/* no log so no checkpoint */ 0 ;else goto err;else if (LSN_OFFSET(last_page) == 0 )if (LSN_FILE_NO(last_page) == 1 ||1 )))0 ; /* file #1 has no pages */ "info" , ("log found. But is is empty => no log assumed" ));else do if (translog_get_last_page_addr(&last_page, &pageok, 0 ))goto err;while (LSN_OFFSET(last_page) == 0 && LSN_FILE_NO(last_page) >= 1 );if (LSN_OFFSET(last_page) == 0 )/* All files have a size less than TRANSLOG_PAGE_SIZE */ 0 ;if (logs_found)1 );/* Open all files */ if (allocate_dynamic(&log_descriptor.open_files,1 ))goto err;for (i = log_descriptor.max_file; i >= log_descriptor.min_file; i--)/* We can ' t allocate all file together because they will be freed one by one sizeof (TRANSLOG_FILE),0 ));0 xffffffffULL);if (file == NULL ||0 ||0 , SEEK_END, MYF(0 )) >=0 xffffffffULL)int j;for (j= i - log_descriptor.min_file - 1 ; j > 0 ; j--)if (file)goto err;else goto err;1 );/* we allocated space so it can't fail */ 1 ==else if (readonly)/* There is no logs and there is read-only mode => nothing to read */ "error" , ("No logs and read-only mode" ));goto err;if (logs_found)"info" , ("The log is really present" ));if (sure_page > last_page)"Aria engine: log data error\n" "last_log_page: " LSN_FMT " is less than\n" "checkpoint page: " LSN_FMT, MYF(0 ),goto err;/* TODO: check page size */ /* Scans and validate pages . We need it to show " outside " only for sure valid part of the log . If the log was damaged then fixed we have to cut off damaged part before some other process start write something in the log . do if (translog_get_last_page_addr(¤t_file_last_page, &pageok, 0 ))goto err;if (!pageok)"error" , ("File %lu have no complete last page" ,1 ;/* This file is not written till the end so it should be last */ if (LSN_OFFSET(current_file_last_page) >= TRANSLOG_PAGE_SIZE)do if ((page= translog_get_page(&data, psize_buff.buffer, NULL)) == NULL)goto err;if (data.was_recovered)"error" , ("file no: %lu (%d) " "rec_offset: 0x%lx (%lu) (%d)" ,3 ) !=1 ;break ;/* increase offset */ while (current_page <= current_file_last_page);while (LSN_FILE_NO(current_page) <= LSN_FILE_NO(last_page) &&if (last_valid_page == LSN_IMPOSSIBLE)/* Panic!!! Even page which should be valid is invalid */ /* TODO: issue error */ goto err;"info" , ("Last valid page is in file: %lu " "offset: %lu (0x%lx) " "Logs found: %d was recovered: %d " "flags match: %d" ,/* TODO: check server ID */ if (logs_found && !old_log_was_recovered && old_flags == flags)/* continue old log */ if ((page= translog_get_page(&data, psize_buff.buffer, NULL)) == NULL ||0 )goto err;/* Puts filled part of old page in the buffer */ 0 );/* Free space if filled with TRANSLOG_FILLER and first uchar of real chunk can ' t be TRANSLOG_FILLER while (chunk_offset < TRANSLOG_PAGE_SIZE &&if ((chunk_length=0 )goto err;"info" , ("chunk: offset: %u length: %u" ,/* chunk can't cross the page border */ "info" , ("Move Page #%u: %p chaser: %d Size: %lu (%lu)" ,if (!old_log_was_recovered && old_flags == flags)/* Accessing & log_descriptor . open_files without mutex is safe because it is initialization if (translog_read_file_header(&info,0 , TRANSLOG_FILE **))->goto err;"info" , ("Logs found: %d was recovered: %d" ,if (!logs_found && !readonly)sizeof (TRANSLOG_FILE), MYF(MY_WME));"info" , ("The log is not found => we will create new log" ));if (file == NULL)goto err;/* Start new log system from scratch */ /* header page */ 0 );if (insert_dynamic(&log_descriptor.open_files, (uchar*)&file))goto err;if ((file->handler.file=1 )goto err;if (translog_write_file_header())goto err;1 ==if (ma_control_file_write_and_force(checkpoint_lsn, start_file_num,goto err;/* assign buffer 0 */ 0 );else if ((old_log_was_recovered || old_flags != flags || version_changed) &&/* leave the damaged file untouched */ /* header page */ if (translog_create_new_file())goto err;/* Buffer system left untouched after recovery = > we should init it ( starting from buffer 0 ) 0 );else if (readonly && !logs_found)/* all LSNs that are on disk are flushed */ /* set to 0 */ /* Now ' flushed ' is set to ' horizon ' value , but ' horizon ' is ( potentially ) address of the next LSN and we want indicate that all LSNs that are already on the disk are flushed so we need decrease horizon on 1 ( we are sure that there is no LSN on the disk which is greater then ' flushed ' and there will not be LSN created that is equal or less then the value of the ' flushed ' ) . /* offset decreased */ /* offset decreased */ /* Log records will refer to a MARIA_SHARE by a unique 2 - byte id ; set up structures for generating 2 - byte ids : sizeof (MARIA_SHARE*),if (unlikely(!id_to_share))goto err;/* min id is 1 */ /* Check the last LSN record integrity */ if (logs_found)/* take very last page address and try to find LSN record on it if it fail take address of previous page and so on 1 ) % TRANSLOG_PAGE_SIZE + 1 ));if (translog_scanner_init(page_addr, 1 , &scanner, 1 ))goto err;for (;;)while (!translog_is_LSN_chunk(chunk_1byte) &&if (translog_get_next_chunk(&scanner))goto err;if (scanner.page != END_OF_LOG)if (translog_is_LSN_chunk(chunk_1byte))if (translog_get_next_chunk(&scanner))goto err;if (scanner.page == END_OF_LOG)break ; /* it was the last record */ continue ; /* try to find other record on this page */ if (last_lsn != LSN_IMPOSSIBLE)break ; /* there is no more records on the page */ /* We have to make step back */ if (unlikely(LSN_OFFSET(page_addr) == TRANSLOG_PAGE_SIZE))/* it is beginning of the current file */ do if (unlikely(file_no == 1 ))/* It is beginning of the log = > there is no LSNs in the log = > There is no harm in leaving it " as - is " . "info" , ("previous_flush_horizon: " LSN_FMT,0 );0 );while (LSN_OFFSET(page_addr) == 0 );/* page should be OK as it is not the last file */ else if (translog_scanner_init(page_addr, 1 , &scanner, 1 ))goto err;/* Now scanner points to the last LSN chunk, lets check it */ int len;1 ];"info" , ("going to check the last found record " LSN_FMT,if (unlikely (len == RECHEADER_READ_ERROR ||"error" , ("unexpected end of log or record during " "reading record header: " LSN_FMT " len: %d" ,if (readonly)else if (translog_truncate_log(last_lsn))goto err;else if (likely(rec.record_length != 0 ))/* Reading the last byte of record will trigger scanning all record chunks for now 1 , 1 ,if (rec_len != 1 )"error" , ("unexpected end of log or record during " "reading record body: " LSN_FMT " len: %d" ,if (readonly)else if (translog_truncate_log(last_lsn))goto err;"info" , ("previous_flush_horizon: " LSN_FMT,0 );0 , "log initialization failed" );1 );/* @ brief Free transaction log file buffer . @ param buffer_no The buffer to free static void translog_buffer_destroy(struct st_translog_buffer *buffer)"translog_buffer_destroy" );"enter" ,"Buffer #%u: %p file: %d offset: " LSN_FMT " size: %lu" ,1 ),if (buffer->file != NULL)/* We ignore errors here , because we can ' t do something about it ( it is shutting down ) We also have to take the locks even if there can ' t be any other threads running , because translog_buffer_flush ( ) requires that we have the buffer locked . "info" , ("Destroy mutex: %p" , &buffer->mutex));/* Free log handler resources SYNOPSIS translog_destroy ( ) void translog_destroy()"translog_destroy" );if (log_descriptor.bc.buffer->file != NULL)for (i= 0 ; i < TRANSLOG_BUFFERS_NO; i++)struct st_translog_buffer *buffer= (log_descriptor.buffers +1 ) %/* close files */ while ((file= (TRANSLOG_FILE **)pop_dynamic(&log_descriptor.open_files)))if (log_descriptor.directory_fd >= 0 )if (id_to_share != NULL)1 );/* @ brief Starts new page . @ param horizon \ Position in file and buffer where we are @ param cursor / @ param prev_buffer Buffer which should be flushed will be assigned here . This is always set ( to NULL if nothing to flush ) . @ note We do not want to flush the buffer immediately because we want to let caller of this function first advance ' horizon ' pointer and unlock the loghandler and only then flush the log which can take some time . @ retval 0 OK @ retval 1 Error static my_bool translog_page_next(TRANSLOG_ADDRESS *horizon,struct st_buffer_cursor *cursor,struct st_translog_buffer **prev_buffer)struct st_translog_buffer *buffer= cursor->buffer;"translog_page_next" );if ((cursor->ptr + TRANSLOG_PAGE_SIZE >"info" , ("Switch to next buffer Buffer Size: %lu (%lu) => %d " "File size: %lu max: %lu => %d" ,if (translog_buffer_next(horizon, cursor,1 );"info" , ("Buffer #%u (%p): have to be flushed" ,else "info" , ("Use the same buffer #%u (%p): " "Buffer Size: %lu (%lu)" ,0 );/* Write data of given length to the current page SYNOPSIS translog_write_data_on_page ( ) horizon \ Pointers on file and buffer cursor / length IN length of the chunk buffer buffer with data RETURN 0 OK 1 Error static my_bool translog_write_data_on_page(TRANSLOG_ADDRESS *horizon,struct st_buffer_cursor *cursor,"translog_write_data_on_page" );"enter" , ("Chunk length: %lu Page size %u" ,0 );/* adds offset */ if (!cursor->chaser)"info" , ("Write data buffer #%u: %p " "chaser: %d Size: %lu (%lu)" ,0 );/* Write data from parts of given length to the current page SYNOPSIS translog_write_parts_on_page ( ) horizon \ Pointers on file and buffer cursor / length IN length of the chunk parts IN / OUT chunk source RETURN 0 OK 1 Error static my_bool translog_write_parts_on_page(TRANSLOG_ADDRESS *horizon,struct st_buffer_cursor *cursor,struct st_translog_parts *parts)"translog_write_parts_on_page" );"enter" , ("Chunk length: %lu parts: %u of %u. Page size: %u " "Buffer size: %lu (%lu)" ,1 ), (uint) parts->elements,0 );do const uchar *buff;"info" , ("Part: %u Length: %lu left: %lu buff: %p" ,1 ), (ulong) part->length, (ulong) left,if (part->length > left)/* we should write less then the current part */ "info" , ("Set new part: %u Length: %lu" ,1 ), (ulong) part->length));else "info" , ("moved to next part (len: %lu)" , (ulong) len));"info" , ("copy: %p <- %p %u" ,if (likely(len))while (left);"info" , ("Horizon: " LSN_FMT " Length %u(0x%x)" ,/* offset increasing */ if (!cursor->chaser)/* We do not updating parts - > total_record_length here because it is need only before writing record to have total length "info" , ("Write parts buffer #%u: %p " "chaser: %d Size: %lu (%lu) " "Horizon: " LSN_FMT " buff offset: 0x%x" ,0 );/* Put 1 group chunk type 0 header into parts array SYNOPSIS translog_write_variable_record_1group_header ( ) parts Descriptor of record source parts type The log record type short_trid Short transaction ID or 0 if it has no sense header_length Calculated header length of chunk type 0 chunk0_header Buffer for the chunk header writing static void struct st_translog_parts *parts,enum translog_record_type type,0 ); /* first part is left for header */ /* puts chunk type */ 1 , short_trid);/* puts record length */ 3 ,/* puts 0 as chunk length which indicate 1 group record */ 2 , 0 );/* Increase number of writers for this buffer SYNOPSIS translog_buffer_increase_writers ( ) buffer target buffer static inline void struct st_translog_buffer *buffer)"translog_buffer_increase_writers" );"info" , ("copy_to_buffer_in_progress. Buffer #%u %p progress: %d" ,/* Decrease number of writers for this buffer SYNOPSIS translog_buffer_decrease_writers ( ) buffer target buffer static void translog_buffer_decrease_writers(struct st_translog_buffer *buffer)"translog_buffer_decrease_writers" );"info" ,"copy_to_buffer_in_progress. Buffer #%u %p progress: %d" ,if (buffer->copy_to_buffer_in_progress == 0 )/** @ brief Skip to the next page for chaser ( thread which advanced horizon pointer and now feeling the buffer ) @ param horizon \ Pointers on file position and buffer @ param cursor / @ retval 1 OK @ retval 0 Error static my_bool translog_chaser_page_next(TRANSLOG_ADDRESS *horizon,struct st_buffer_cursor *cursor)struct st_translog_buffer *buffer_to_flush;"translog_chaser_page_next" );if (buffer_to_flush != NULL)if (!rc)/* Put chunk 2 from new page beginning SYNOPSIS translog_write_variable_record_chunk2_page ( ) parts Descriptor of record source parts horizon \ Pointers on file position and buffer cursor / RETURN 0 OK 1 Error static my_boolstruct st_translog_parts *parts,struct st_buffer_cursor *cursor)1 ];"translog_write_variable_record_chunk2_page" );0 ]= TRANSLOG_CHUNK_NOHDR;if (translog_chaser_page_next(horizon, cursor))1 );/* Puts chunk type */ 1 , chunk2_header);/* Puts chunk body */ 0 );/* Put chunk 3 of requested length in the buffer from new page beginning SYNOPSIS translog_write_variable_record_chunk3_page ( ) parts Descriptor of record source parts length Length of this chunk horizon \ Pointers on file position and buffer cursor / RETURN 0 OK 1 Error static my_boolstruct st_translog_parts *parts,struct st_buffer_cursor *cursor)1 + 2 ];"translog_write_variable_record_chunk3_page" );if (translog_chaser_page_next(horizon, cursor))1 );if (length == 0 )/* It was call to write page header only (no data for chunk 3) */ "info" , ("It is a call to make page header only" ));0 );0 ); /* first part is left for header */ 1 + 2 );/* Puts chunk type */ /* Puts chunk length */ 1 , length);1 + 2 , parts);0 );/* Move log pointer ( horizon ) on given number pages starting from next page , and given offset on the last page SYNOPSIS translog_advance_pointer ( ) pages Number of full pages starting from the next one last_page_data Plus this data on the last page RETURN 0 OK 1 Error static my_bool translog_advance_pointer(int pages, uint16 last_page_data,"translog_advance_pointer" );"enter" , ("Pointer: " LSN_FMT " + %u + %u pages + %u + %u" ,if (pages == -1 )/* It is special case when we advance the pointer on the same page . It can happened when we write last part of multi - group record . goto end;"info" , ("last_page_offset %lu" , (ulong) last_page_offset));/* The loop will be executed 1 - 3 times . Usually we advance the pointer to fill only the current buffer ( if we have more then 1 / 2 of buffer free or 2 buffers ( rest of current and all next ) . In case of really huge record end where we write last group with " table of content " of all groups and ignore buffer borders we can occupy 3 buffers . for (;;)struct st_translog_buffer *new_buffer;struct st_translog_buffer *old_buffer;if (likely(log_descriptor.log_file_max_size >=else /* We already have written more then current file limit allow , So we will finish this page and start new file "info" , ("offset: %u buffer_end_offs: %u, " "file_end_offs: %u" ,"info" , ("Buff #%u %u (%p) offset 0x%x + size 0x%x = " "0x%x (0x%x)" ,if (offset <= buffer_end_offset && offset <= file_end_offset)break ;1 ) % TRANSLOG_BUFFERS_NO;#ifndef DBUG_OFF#endif #ifndef DBUG_OFF/* We keep the handler locked so nobody can start this new buffer */ 1 )) ==#endif /* TODO: check is it ptr or size enough */ "info" , ("NewP buffer #%u: %p chaser: %d Size: %lu (%lu)" ,// register for case of error if (file_end_offset <= buffer_end_offset)"info" , ("New file: %lu" ,if (translog_create_new_file())struct st_translog_buffer *ob= log_descriptor.bc.buffer;1 );else "info" , ("The same file" ));/* offset increasing */ "info" , ("drop write_counter" ));0 ;0 ;/* offset increasing */ "info" , ("NewP buffer #%u: %p chaser: %d Size: %lu (%lu) " "offset: %u last page: %u" ,"info" ,"pointer moved to: " LSN_FMT,protected = 0 ;0 );static void struct st_translog_buffer *buff)"used_buffs_add" );"enter" , ("ADD buffs: %p unlk %u (%p) wrt_ptr: %u (%p)" " buff %p (%u)" ,static void struct st_translog_buffer *buff"used_buffs_register_unlock" );"enter" , ("SUB buffs: %p unlk %u (%p) wrt_ptr: %u (%p)" " buff %p (%u)" ,static void used_buffs_urgent_unlock(TRUNSLOG_USED_BUFFERS *buffs)"used_buffs_urgent_unlock" );for (i= buffs->unlck_ptr; i < buffs->wrt_ptr; i++)struct st_translog_buffer *buf= buffs->buff[i];/* Get page rest SYNOPSIS translog_get_current_page_rest ( ) NOTE loghandler should be locked RETURN number of bytes left on the current page static uint translog_get_current_page_rest()return (TRANSLOG_PAGE_SIZE - log_descriptor.bc.current_page_fill);/* Get buffer rest in full pages SYNOPSIS translog_get_current_buffer_rest ( ) NOTE loghandler should be locked RETURN number of full pages left on the current buffer static uint translog_get_current_buffer_rest()return (uint)((log_descriptor.bc.buffer->buffer + TRANSLOG_WRITE_BUFFER -/* Calculate possible group size without first ( current ) page SYNOPSIS translog_get_current_group_size ( ) NOTE loghandler should be locked RETURN group size without first ( current ) page static translog_size_t translog_get_current_group_size()/* buffer rest in full pages */ "translog_get_current_group_size" );"info" , ("buffer_rest in pages: %u" , buffer_rest));/* in case of only half of buffer free we can write this and next buffer */ if (buffer_rest < log_descriptor.half_buffer_capacity_chunk_2)"info" , ("buffer_rest: %lu -> add %lu" ,"info" , ("buffer_rest: %lu" , (ulong) buffer_rest));static inline void set_lsn(LSN *lsn, LSN value)"set_lsn" );/* we generate LSN so something is not flushed in log */ 0 ;"info" , ("new LSN appeared: " LSN_FMT, LSN_IN_PARTS(value)));/** @ brief Write variable record in 1 group . @ param lsn LSN of the record will be written here @ param type the log record type @ param short_trid Short transaction ID or 0 if it has no sense @ param parts Descriptor of record source parts @ param buffer_to_flush Buffer which have to be flushed if it is not 0 @ param header_length Calculated header length of chunk type 0 @ param trn Transaction structure pointer for hooks by record log type , for short_id @ param hook_arg Argument which will be passed to pre - write and in - write hooks of this record . @ note We must have a translog_lock ( ) when entering this function We must have buffer_to_flush locked ( if not null ) @ return Operation status @ retval 0 OK @ retval 1 Error static my_boolenum translog_record_type type,struct st_translog_parts *parts,struct st_translog_buffervoid *hook_arg)struct st_buffer_cursor cursor;int rc= 0 ;0 ;1 + 2 + 5 + 2 ];"translog_write_variable_record_1group" );if (buffer_to_flush)if (translog_set_lsn_for_files(LSN_FILE_NO(*lsn), LSN_FILE_NO(*lsn),TRUE ) ||if (buffer_to_flush != NULL)1 );1 ;/* Advance pointer to be able unlock the loghandler */ if (record_rest + 1 == log_descriptor.page_capacity_chunk_2)"info" , ("2 chunks type 3 is needed" ));/* We will write 2 chunks type 3 at the end of this group */ 1 ;1 ;"info" , ("first_page: %u (%u) full_pages: %u (%lu) " "additional: %u (%u) rest %u = %u" ,1 ),/* record_rest + 3 is chunk type 3 overhead + record_rest */ int )(full_pages + additional_chunk3_page),3 : 0 ),"info" , ("last_lsn set to " LSN_FMT " buffer: %p" ,/* Check if we switched buffer and need process it ( current buffer is unlocked already = > we will not delay other threads if (buffer_to_flush != NULL)if (!rc)if (rc)//translog_advance_pointer decreased writers so it is OK 1 );/* fill the pages */ "info" , ("absolute horizon: " LSN_FMT " local: " LSN_FMT,for (i= 0 ; i < full_pages; i++)if (translog_write_variable_record_chunk2_page(parts, &horizon, &cursor))goto error;"info" , ("absolute horizon: " LSN_FMT " local: " LSN_FMT,if (additional_chunk3_page)if (translog_write_variable_record_chunk3_page(parts,2 ,goto error;"info" , ("absolute horizon: " LSN_FMT " local: " LSN_FMT,if (translog_write_variable_record_chunk3_page(parts,goto error;"info" , ("absolute horizon: " LSN_FMT " local: " LSN_FMT,0 );1 );/** @ brief Write variable record in 1 chunk . @ param lsn LSN of the record will be written here @ param type the log record type @ param short_trid Short transaction ID or 0 if it has no sense @ param parts Descriptor of record source parts @ param buffer_to_flush Buffer which have to be flushed if it is not 0 @ param header_length Calculated header length of chunk type 0 @ param trn Transaction structure pointer for hooks by record log type , for short_id @ param hook_arg Argument which will be passed to pre - write and in - write hooks of this record . @ note We must have a translog_lock ( ) when entering this function We must have buffer_to_flush locked ( if not null ) @ return Operation status @ retval 0 OK @ retval 1 Error static my_boolenum translog_record_type type,struct st_translog_parts *parts,struct st_translog_buffervoid *hook_arg)int rc;1 + 2 + 5 + 2 ];"translog_write_variable_record_1chunk" );if (buffer_to_flush)if (translog_set_lsn_for_files(LSN_FILE_NO(*lsn), LSN_FILE_NO(*lsn),TRUE ) ||1 ;goto err;"info" , ("last_lsn set to " LSN_FMT " buffer: %p" ,/* check if we switched buffer and need process it ( current buffer is unlocked already = > we will not delay other threads if (buffer_to_flush != NULL)if (!rc)/* @ brief Calculates and write LSN difference ( compressed LSN ) . @ param base_lsn LSN from which we calculate difference @ param lsn LSN for codding @ param dst Result will be written to dst [ - pack_length ] . . dst [ - 1 ] @ note To store an LSN in a compact way we will use the following compression : If a log record has LSN1 , and it contains the LSN2 as a back reference , Instead of LSN2 we write LSN1 - LSN2 , encoded as : two bits the number N ( see below ) 14 bits N bytes That is , LSN is encoded in 2 . . 5 bytes , and the number of bytes minus 2 is stored in the first two bits . @ note function made to write the result in backward direction with no special sense or tricks both directions are equal in complicity @ retval # pointer on coded LSN static uchar *translog_put_LSN_diff(LSN base_lsn, LSN lsn, uchar *dst)"translog_put_LSN_diff" );"enter" , ("Base: " LSN_FMT " val: " LSN_FMT " dst: %p" ,"info" , ("Diff: 0x%llx" , (ulonglong) diff));if (diff <= 0 x3FFF)2 ;/* Note we store this high uchar first to ensure that first uchar has 0 in the 3 upper bits . 0 ]= (uchar)(diff >> 8 );1 ]= (uchar)(diff & 0 xFF);else if (diff <= 0 x3FFFFFL)3 ;0 ]= (uchar)(0 x40 | (diff >> 16 ));1 , diff & 0 xFFFF);else if (diff <= 0 x3FFFFFFFL)4 ;0 ]= (uchar)(0 x80 | (diff >> 24 ));1 , diff & 0 xFFFFFFL);else if (diff <= 0 x3FFFFFFFFFLL)5 ;0 ]= (uchar)(0 xC0 | (diff >> 32 ));1 , diff & 0 xFFFFFFFFL);else /* It is full LSN after special 1 diff ( which is impossible in real life ) 2 + LSN_STORE_SIZE;0 ]= 0 ;1 ]= 1 ;2 , lsn);"info" , ("new dst: %p" , dst));/* Get LSN from LSN - difference ( compressed LSN ) SYNOPSIS translog_get_LSN_from_diff ( ) base_lsn LSN from which we calculate difference src pointer to coded lsn dst pointer to buffer where to write 7 byte LSN NOTE : To store an LSN in a compact way we will use the following compression : If a log record has LSN1 , and it contains the lSN2 as a back reference , Instead of LSN2 we write LSN1 - LSN2 , encoded as : two bits the number N ( see below ) 14 bits N bytes That is , LSN is encoded in 2 . . 5 bytes , and the number of bytes minus 2 is stored in the first two bits . RETURN pointer to buffer after decoded LSN static uchar *translog_get_LSN_from_diff(LSN base_lsn, uchar *src, uchar *dst)"translog_get_LSN_from_diff" );"enter" , ("Base: " LSN_FMT " src:%p dst %p" ,6 ; /* Length is in 2 most significant bits */ 0 x3F;/* Skip length + encode */ /* Assume relative */ "info" , ("code: %u first byte: %lu" ,switch (code) {case 0 :if (first_byte == 0 && *((uint8*)src) == 1 )/* It is full LSN after special 1 diff ( which is impossible in real life ) 1 , LSN_STORE_SIZE);"info" , ("Special case of full LSN, new src:%p" ,1 + LSN_STORE_SIZE));1 + LSN_STORE_SIZE);8 ) | *((uint8*)src));break ;case 1 :16 ) | diff);break ;case 2 :24 ) | diff);break ;case 3 :if (diff > LSN_OFFSET(base_lsn))/* take 1 from file offset */ 0 x100000000LL;break ;default :0 );1 ;"info" , ("new src:%p" , src));/** @ brief Encodes relative LSNs listed in the parameters . @ param parts Parts list with encoded LSN ( s ) @ param base_lsn LSN which is base for encoding @ param lsns number of LSN ( s ) to encode @ param compressed_LSNs buffer which can be used for storing compressed LSN ( s ) static void translog_relative_LSN_encode(struct st_translog_parts *parts,const uchar *cbuffer;"translog_relative_LSN_encode" );0 );/* collect all LSN(s) in one chunk if it (they) is (are) divided */ if (part->length < lsns_len)"info" , ("Using buffer:%p" , compressed_LSNs));1 ;do if ((next_part->length + copied) < lsns_len)0 ; next_part->str= 0 ;/* delete_dynamic_element(&parts->parts, parts->current + 1); */ else while (copied < lsns_len);else /* Compress */ int economy;const uchar *src_ptr;/* We write the result in backward direction with no special sense or tricks both directions are equal in complicity for (src_ptr= cbuffer + lsns_len - LSN_STORE_SIZE;const uchar*)cbuffer;"info" , ("new length of LSNs: %lu economy: %d" ,/** @ brief Write multi - group variable - size record . @ param lsn LSN of the record will be written here @ param type the log record type @ param short_trid Short transaction ID or 0 if it has no sense @ param parts Descriptor of record source parts @ param buffer_to_flush Buffer which have to be flushed if it is not 0 @ param header_length Header length calculated for 1 group @ param buffer_rest Beginning from which we plan to write in full pages @ param trn Transaction structure pointer for hooks by record log type , for short_id @ param hook_arg Argument which will be passed to pre - write and in - write hooks of this record . @ note We must have a translog_lock ( ) when entering this function We must have buffer_to_flush locked ( if not null ) buffer_to_flush should * NOT * be locked when calling this function . ( This is note is here as this is different from most other translog_write . . . ( ) functions which require the buffer to be locked ) @ return Operation status @ retval 0 OK @ retval 1 Error static my_boolenum translog_record_type type,struct st_translog_parts *parts,struct st_translog_buffervoid *hook_arg)struct st_buffer_cursor cursor;int rc= 0 ;0 ;1 ;0 ;struct st_translog_group_descriptor group;1 ;1 , first_chunk0= 1 ;1 + 2 + 5 + 2 + 2 ], group_desc[7 + 1 ];1 ];2 ;7 + 1 );int pages_to_skip;struct st_translog_buffer *buffer_of_last_lsn;TRUE ;"translog_write_variable_record_mgroup" );0 ]= TRANSLOG_CHUNK_NOHDR;if (my_init_dynamic_array(PSI_INSTRUMENT_ME, &groups,sizeof (struct st_translog_group_descriptor),10 , 10 , MYF(0 )))if (buffer_to_flush != NULL)"error" , ("init array failed" ));1 );1 );"info" , ("Record Rest: %lu" , (ulong) record_rest));if (record_rest < buffer_rest)/* The record ( group 1 type ) is larger than the free space on the page - we need to split it in two . But when we split it in two , the first part is big enough to hold all the data of the record ( because the header of the first part of the split is smaller than the header of the record as a whole when it takes only one chunk ) "info" , ("too many free space because changing header" ));do 1 ;if ((full_pages= buffer_rest / log_descriptor.page_capacity_chunk_2) > 255 )/* sizeof(uint8) == 256 is max number of chunk in multi-chunks group */ 255 ;/* group chunks = full pages + first page ( which actually can be full , too ) . But here we assign number of chunks - 1 if (insert_dynamic(&groups, (uchar*) &group))"error" , ("insert into array failed" ));goto err_unlock;"info" , ("chunk: #%zu first_page: %u (%u) " "full_pages: %lu (%lu) " "Left %lu" ,1 ,1 +int )full_pages, 0 , &cursor.buffs);if (buffer_to_flush != NULL)if (!external_buffer_to_flush)if (!rc)FALSE ;if (rc)"error" , ("flush of unlock buffer failed" ));//translog_advance_pointer decreased writers so it is OK goto err;1 , chunk2_header);1 , parts);"info" , ("absolute horizon: " LSN_FMT " local: " LSN_FMT " " "Left %lu" ,1 ) -for (i= 0 ; i < full_pages; i++)if (translog_write_variable_record_chunk2_page(parts, &horizon, &cursor))goto err;"info" , ("absolute horizon: " LSN_FMT " " "local: " LSN_FMT " " "Left: %lu" ,1 ) -1 + buffer_rest);if (translog_chaser_page_next(&horizon, &cursor))"error" , ("flush of unlock buffer failed" ));goto err;/* Check that we have place for chunk type 2 */ if (first_page <= 1 )if (translog_page_next(&log_descriptor.horizon, &log_descriptor.bc,goto err_unlock;if (buffer_to_flush)// will be unlocked while ((translog_size_t)(first_page + buffer_rest) <1 ;0 ; /* 0 because it does not matter */ if (insert_dynamic(&groups, (uchar*) &group))"error" , ("insert into array failed" ));goto err_unlock;"info" , ("Record rest: %lu" , (ulong) record_rest));if (first_page > record_rest + 1 )/* We have not so much data to fill all first page ( no speaking about full pages ) so it will be : < chunk0 < data > > or < chunk0 > . . . < chunk0 > < chunk0 < data > > or < chunk3 < data > > < chunk0 > . . . < chunk0 > < chunk0 < possible data of 1 byte > > 0 ;1 ;else /* We will have : < chunk2 < data > > . . . < chunk2 < data > > < chunk0 < data > > or < chunk2 < data > > . . . < chunk2 < data > > < chunk0 > . . . < chunk0 > < chunk0 < data > > or < chunk3 < data > > < chunk0 > . . . < chunk0 > < chunk0 < possible data of 1 byte > > 1 ;1 );0 ;0 ;if (last_page_capacity > record_rest + 1 && record_rest != 0 )if (last_page_capacity >7 + 1 ))/* 1 record of type 0 */ 0 ;else 1 ;if (record_rest + 2 == last_page_capacity)1 ;1 ;else 0 ;/* A first non - full page will hold type 0 chunk only if it fit in it with all its headers while (page_capacity <1 )) * (7 + 1 ))"info" , ("chunk0_pages: %u groups %zu groups per full page: %u " "Group on last page: %zu" ,7 + 1 )) *1 ))));"info" , ("first_page: %u chunk2: %u full_pages: %u (%lu) " "chunk3: %u (%u) rest: %u" ,int )(chunk0_pages - 1 ),7 + 1 )) *1 )) * (7 + 1 )),if (buffer_to_flush != NULL)if (!rc)if (rc)"error" , ("flush of unlock buffer failed" ));goto err;if (rc)goto err;if (chunk2_page)"info" , ("chunk 2 to finish first page" ));1 , chunk2_header);1 , parts);"info" , ("absolute horizon: " LSN_FMT " local: " LSN_FMT " " "Left: %lu" ,1 ) -else if (chunk3_pages)3 ];"info" , ("chunk 3" ));0 );0 ;0 ]= TRANSLOG_CHUNK_LNGTH;1 , chunk3_size);3 , chunk3_header);"info" , ("absolute horizon: " LSN_FMT " local: " LSN_FMT " " "Left: %lu" ,else "info" , ("no new_page_before_chunk0" ));0 ;for (i= 0 ; i < full_pages; i++)0 );if (translog_write_variable_record_chunk2_page(parts, &horizon, &cursor))goto err;"info" , ("absolute horizon: " LSN_FMT " local: " LSN_FMT " " "Left: %lu" ,1 ) -if (chunk3_pages &&goto err;"info" , ("absolute horizon: " LSN_FMT " local: " LSN_FMT,1 , short_trid);3 ,do if (new_page_before_chunk0 &&"error" , ("flush of unlock buffer failed" ));goto err;1 ;if (first_chunk0)0 ;/* We can drop " log_descriptor . is_everything_flushed " earlier when have lock on loghandler and assign initial value of " horizon " variable or before unlocking loghandler ( because we will increase writers counter on the buffer and every thread which wanted flush the buffer will wait till we finish with it ) . But IMHO better here take short lock and do not bother other threads with waiting . "info" , ("last_lsn set to " LSN_FMT " buffer: %p" ,if (log_record_type_descriptor[type].inwrite_hook &&goto err_unlock;/* A first non - full page will hold type 0 chunk only if it fit in it with all its headers = > the fist page is full or number of groups less then possible number of full page . "info" , ("Groups: %zu curr: %zu limit: %zu" ,if (chunk0_pages == 1 )"info" , ("chunk_len: 2 + %u * (7+1) + %u = %u" ,2 + limit * (7 + 1 ) + record_rest)));2 ,2 + limit * (7 + 1 ) + record_rest);else "info" , ("chunk_len: 2 + %u * (7+1) = %u" ,2 + limit * (7 + 1 ))));2 , 2 + limit * (7 + 1 ));for (i= curr_group; i < limit + curr_group; i++)struct st_translog_group_descriptor *grp_ptr;struct st_translog_group_descriptor *);7 ]= grp_ptr->num;7 + 1 ), group_desc);if (chunk0_pages == 1 && record_rest != 0 )/* put special type to indicate that it is not LSN chunk */ while (chunk0_pages != 0 );0 ;if (translog_set_lsn_for_files(file_of_the_first_group, LSN_FILE_NO(*lsn),FALSE ))goto err;0 );if (cursor.buffs.unlck_ptr != cursor.buffs.wrt_ptr)if (buffer_to_flush != NULL)/* This is to prevent locking buffer forever in case of error */ if (!external_buffer_to_flush)if (!rc)1 );/** @ brief Write the variable length log record . @ param lsn LSN of the record will be written here @ param type the log record type @ param short_trid Short transaction ID or 0 if it has no sense @ param parts Descriptor of record source parts @ param trn Transaction structure pointer for hooks by record log type , for short_id @ param hook_arg Argument which will be passed to pre - write and in - write hooks of this record . @ return Operation status @ retval 0 OK @ retval 1 Error static my_bool translog_write_variable_record(LSN *lsn,enum translog_record_type type,struct st_translog_parts *parts,void *hook_arg)struct st_translog_buffer *buffer_to_flush= NULL;1 + 2 + 2 +/* Max number of such LSNs per record is 2 */ "translog_write_variable_record" );"info" , ("horizon: " LSN_FMT,"info" , ("header length: %u page_rest: %u" ,/* header and part which we should read have to fit in one chunk TODO : allow to divide readable header if (page_rest <"info" ,"Next page, size: %u header: %u + %u" ,/* Chunk 2 header is 1 byte, so full page capacity will be one uchar more */ 1 ;"info" , ("page_rest: %u" , page_rest));/* To minimize compressed size we will compress always relative to very first chunk address ( log_descriptor . horizon for now ) if (log_record_type_descriptor[type].compressed_LSN > 0 )/* recalculate header length after compression */ 1 + 2 + 2 +"info" , ("after compressing LSN(s) header length: %u " "record length: %lu" ,/* TODO: check space on current page for header + few bytes */ if (page_rest >= parts->record_length + header_length1)/* following function makes translog_unlock(); */ if (buffer_rest >= parts->record_length + header_length1 - page_rest)/* following function makes translog_unlock(); */ /* following function makes translog_unlock(); */ /** @ brief Write the fixed and pseudo - fixed log record . @ param lsn LSN of the record will be written here @ param type the log record type @ param short_trid Short transaction ID or 0 if it has no sense @ param parts Descriptor of record source parts @ param trn Transaction structure pointer for hooks by record log type , for short_id @ param hook_arg Argument which will be passed to pre - write and in - write hooks of this record . @ return Operation status @ retval 0 OK @ retval 1 Error static my_bool translog_write_fixed_record(LSN *lsn,enum translog_record_type type,struct st_translog_parts *parts,void *hook_arg)struct st_translog_buffer *buffer_to_flush= NULL;1 + 2 ];/* Max number of such LSNs per record is 2 */ int rc= 1 ;"translog_write_fixed_record" );"info" , ("horizon: " LSN_FMT,"info" ,"Page size: %u record: %u next cond: %d" ,2 + 3 ),2 + 3 )) >/* check that there is enough place on current page . NOTE : compressing may increase page LSN size on two bytes for every LSN if ((((uint) log_descriptor.bc.current_page_fill) +2 + 3 )) >"info" , ("Next page" ));if (translog_page_next(&log_descriptor.horizon, &log_descriptor.bc,goto err; /* rc == 1 */ if (buffer_to_flush)if (translog_set_lsn_for_files(LSN_FILE_NO(*lsn), LSN_FILE_NO(*lsn),TRUE ) ||goto err;/* compress LSNs */ if (log_record_type_descriptor[type].rclass ==0 );/* Write the whole record at once ( we know that there is enough place on the destination page ) 0 ); /* first part is left for header */ 1 + 2 );1 , short_trid);"info" , ("last_lsn set to " LSN_FMT " buffer: %p" ,/* check if we switched buffer and need process it ( current buffer is unlocked already = > we will not delay other threads if (buffer_to_flush != NULL)if (!rc)/** @ brief Writes the log record If share has no 2 - byte - id yet , gives an id to the share and logs LOGREC_FILE_ID . If transaction has not logged LOGREC_LONG_TRANSACTION_ID yet , logs it . @ param lsn LSN of the record will be written here @ param type the log record type @ param trn Transaction structure pointer for hooks by record log type , for short_id @ param tbl_info MARIA_HA of table or NULL @ param rec_len record length or 0 ( count it ) @ param part_no number of parts or 0 ( count it ) @ param parts_data zero ended ( in case of number of parts is 0 ) array of LEX_STRINGs ( parts ) , first TRANSLOG_INTERNAL_PARTS positions in the log should be unused ( need for loghandler ) @ param store_share_id if tbl_info ! = NULL then share ' s id will automatically be stored in the two first bytes pointed ( so pointer is assumed to be ! = NULL ) @ param hook_arg argument which will be passed to pre - write and in - write hooks of this record . @ return Operation status @ retval 0 OK @ retval 1 Error enum translog_record_type type,void *hook_arg)struct st_translog_parts parts;int rc;"translog_write_record" );"enter" , ("type: %u (%s) ShortTrID: %u rec_len: %lu" ,0 );if (unlikely(translog_status != TRANSLOG_OK))"error" , ("Transaction log is write protected" ));1 );if (tbl_info && type != LOGREC_FILE_ID)if (unlikely(share->id == 0 ))/* First log write for this MARIA_SHARE ; give it a short id . When the lock manager is enabled and needs a short id , it should be assigned in the lock manager ( because row locks will be taken before log records are written ; for example SELECT FOR UPDATE takes locks but writes no log record . if (unlikely(translog_assign_id_to_share(tbl_info, trn)))1 );if (unlikely(!(trn->first_undo_lsn & TRANSACTION_LOGGED_LONG_ID)))1 ];6 ];0 ].str= log_data;0 ].length= sizeof (log_data);/* no recursion */ if (unlikely(translog_write_record(&dummy_lsn, LOGREC_LONG_TRANSACTION_ID,sizeof (log_data),sizeof (log_array)/sizeof (log_array[0 ]),1 );/* count parts if they are not counted by upper level */ if (part_no == 0 )for (part_no= TRANSLOG_INTERNAL_PARTS;0 ;/* clear TRANSLOG_INTERNAL_PARTS */ 0 );0 ].str= 0 ;0 ].length= 0 ;/* count length of the record */ if (rec_len == 0 )for (part= parts_data + TRANSLOG_INTERNAL_PARTS;\#ifndef DBUG_OFF0 ;#ifdef HAVE_valgrind0 ;#endif for (i= TRANSLOG_INTERNAL_PARTS; i < part_no; i++)#ifdef HAVE_valgrind/* Find uninitialized bytes early */ #endif #endif /* Start total_record_length from record_length then overhead will be add "info" , ("record length: %lu" , (ulong) parts.record_length));/* process this parts */ if (!(rc= (log_record_type_descriptor[type].prewrite_hook &&switch (log_record_type_descriptor[type].rclass) {case LOGRECTYPE_VARIABLE_LENGTH:break ;case LOGRECTYPE_PSEUDOFIXEDLENGTH:case LOGRECTYPE_FIXEDLENGTH:break ;case LOGRECTYPE_NOT_ALLOWED:default :0 );1 ;"info" , ("LSN: " LSN_FMT, LSN_IN_PARTS(*lsn)));/* Decode compressed ( relative ) LSN ( s ) SYNOPSIS translog_relative_lsn_decode ( ) base_lsn LSN for encoding src Decode LSN ( s ) from here dst Put decoded LSNs here lsns number of LSN ( s ) RETURN position in sources after decoded LSN ( s ) static uchar *translog_relative_LSN_decode(LSN base_lsn,for (i= 0 ; i < lsns; i++, dst+= LSN_STORE_SIZE)return src;/** @ brief Get header of fixed / pseudo length record and call hook for it processing @ param page Pointer to the buffer with page where LSN chunk is placed @ param page_offset Offset of the first chunk in the page @ param buff Buffer to be filled with header data @ return Length of header or operation status @ retval # number of bytes in TRANSLOG_HEADER_BUFFER : : header where stored decoded part of the header static int translog_fixed_length_header(uchar *page,struct st_log_record_type_descriptor *desc=3 ;int lsns= desc->compressed_LSN;"translog_fixed_length_header" );if (desc->rclass == LOGRECTYPE_PSEUDOFIXEDLENGTH)0 );int ) (src - start));else 0 ;0 ;/* Free resources used by TRANSLOG_HEADER_BUFFER SYNOPSIS translog_free_record_header ( ) ; void translog_free_record_header(TRANSLOG_HEADER_BUFFER *buff)"translog_free_record_header" );if (buff->groups_no != 0 )0 ;/** @ brief Returns the current horizon at the end of the current log @ return Horizon @ retval LSN_ERROR error @ retvar # Horizon return res;/** @ brief Returns the current horizon at the end of the current log , caller is assumed to already hold the lock @ return Horizon @ retval LSN_ERROR error @ retvar # Horizon return log_descriptor.horizon;/* Set last page in the scanner data structure SYNOPSIS translog_scanner_set_last_page ( ) scanner Information about current chunk during scanning RETURN 0 OK 1 Error static my_bool translog_scanner_set_last_page(TRANSLOG_SCANNER_DATA *scanner)if (LSN_FILE_NO(scanner->page_addr) == LSN_FILE_NO(scanner->horizon))/* It is last file => we can easy find last page address by horizon */ return (0 );return (translog_get_last_page_addr(&scanner->last_file_page, &page_ok, 0 ));/** @ brief Get page from page cache according to requested method @ param scanner The scanner data @ return operation status @ retval 0 OK @ retval 1 Error static my_bool"translog_scanner_get_page" );0 ;/** @ brief Initialize reader scanner . @ param lsn LSN with which it have to be inited @ param fixed_horizon true if it is OK do not read records which was written after scanning beginning @ param scanner scanner which have to be inited @ param use_direct prefer using direct links from page handler where it is possible . @ note If direct link was used translog_destroy_scanner should be called after it using @ return status of the operation @ retval 0 OK @ retval 1 Error "translog_scanner_init" );"enter" , ("Scanner: %p LSN: " LSN_FMT,"info" , ("horizon: " LSN_FMT, LSN_IN_PARTS(scanner->horizon)));/* lsn < horizon */ /*decrease offset */ if (translog_scanner_set_last_page(scanner))1 );if (translog_scanner_get_page(scanner))1 );0 );/** @ brief Destroy scanner object ; @ param scanner The scanner object to destroy void translog_destroy_scanner(TRANSLOG_SCANNER_DATA *scanner)"translog_destroy_scanner" );"enter" , ("Scanner: %p" , scanner));/* Checks End of the Log SYNOPSIS translog_scanner_eol ( ) scanner Information about current chunk during scanning RETURN 1 End of the Log 0 OK static my_bool translog_scanner_eol(TRANSLOG_SCANNER_DATA *scanner)"translog_scanner_eol" );"enter" ,"Horizon: " LSN_FMT " Current: (%u, 0x%x+0x%x=0x%x)" ,if (scanner->horizon > (scanner->page_addr +"info" , ("Horizon is not reached" ));0 );if (scanner->fixed_horizon)"info" , ("Horizon is fixed and reached" ));1 );"info" ,"Horizon is re-read, EOL: %d" ,/** @ brief Checks End of the Page @ param scanner Information about current chunk during scanning @ retval 1 End of the Page @ retval 0 OK static my_bool translog_scanner_eop(TRANSLOG_SCANNER_DATA *scanner)"translog_scanner_eop" );/** @ brief Checks End of the File ( i . e . we are scanning last page , which do not mean end of this page ) @ param scanner Information about current chunk during scanning @ retval 1 End of the File @ retval 0 OK static my_bool translog_scanner_eof(TRANSLOG_SCANNER_DATA *scanner)"translog_scanner_eof" );"enter" , ("curr Page: 0x%lx last page: 0x%lx " "normal EOF: %d" ,/* TODO : detect damaged file EOF , TODO : issue warning if damaged file EOF detected /* Move scanner to the next chunk SYNOPSIS translog_get_next_chunk ( ) scanner Information about current chunk during scanning RETURN 0 OK 1 Error static my_bool"translog_get_next_chunk" );if (translog_scanner_eop(scanner))else if ((len= translog_get_total_chunk_length(scanner->page,0 )1 );if (translog_scanner_eol(scanner))0 ;0 );if (translog_scanner_eop(scanner))/* before reading next page we should unpin current one if it was pinned */ if (translog_scanner_eof(scanner))"info" , ("horizon: " LSN_FMT " pageaddr: " LSN_FMT,/* if it is log end it have to be caught before */ do if (translog_scanner_set_last_page(scanner))1 );while (!LSN_OFFSET(scanner->last_file_page));else /* offset increased */ if (translog_scanner_get_page(scanner))1 );if (translog_scanner_eol(scanner))0 ;0 );#ifdef CHECK_EMPTY_PAGE#endif 0 );/** @ brief Get header of variable length record and call hook for it processing @ param page Pointer to the buffer with page where LSN chunk is placed @ param page_offset Offset of the first chunk in the page @ param buff Buffer to be filled with header data @ param scanner If present should be moved to the header page if it differ from LSN page @ return Length of header or operation status @ retval RECHEADER_READ_ERROR error @ retval RECHEADER_READ_EOF End of the log reached during the read @ retval # number of bytes in TRANSLOG_HEADER_BUFFER : : header where stored decoded part of the header static int struct st_log_record_type_descriptor *desc= (log_record_type_descriptor +1 + 2 ;int rc;"translog_variable_length_header" );"info" , ("rec len: %lu chunk len: %u length: %u bufflen: %u" ,if (chunk_len == 0 )"info" , ("1 group" ));2 ;else "info" , ("multi-group" ));2 );if (!(buff->groups=sizeof (TRANSLOG_GROUP) * grp_no,0 ))))"info" , ("Groups: %u" , (uint) grp_no));2 + 2 );0 ;0 ;for (;;)if (page_rest < grp_no * (7 + 1 ))7 + 1 );"info" , ("Read chunk0 page#%u read: %u left: %u " "start from: %u" ,for (i= 0 ; i < read_length; i++, curr++)7 + 1 ));7 + 1 ) + 7 ];"info" , ("group #%u " LSN_FMT " chunks: %u" ,if (grp_no == 0 )if (scanner)/* offset increased */ 7 + 1 ));else /* offset increased */ 7 + 1 ));2 - read_length * (7 + 1 );"info" , ("Data address: " LSN_FMT " len: %u" ,break ;if (scanner == NULL)"info" , ("use internal scanner for header reading" ));if (translog_scanner_init(buff->lsn, 1 , scanner, 0 ))goto exit_and_free;if (translog_get_next_chunk(scanner))if (scanner == &internal_scanner)goto exit_and_free;if (scanner->page == END_OF_LOG)if (scanner == &internal_scanner)goto exit_and_free;2 - 2 );"info" , ("Chunk len: %u" , (uint) chunk_len));if (scanner == NULL)"info" , ("use internal scanner" ));else 0 ].addr;1 , scanner, scanner == &internal_scanner);/* first group chunk is always chunk type 2 */ 1 ;if (scanner == &internal_scanner)if (lsns)int ) (lsns - (src - start)));"info" , ("lsns: %u length: %u economy: %d new length: %lu" ,int ) buff->compressed_LSN_economy,else 0 ;"info" , ("non_header_data_start_offset: %u len: %u buffer: %u" ,0 ; /* prevent try to use of buff->groups */ /** @ brief Read record header from the given buffer @ param page page content buffer @ param page_offset offset of the chunk in the page @ param buff destination buffer @ param scanner If this is set the scanner will be moved to the record header page ( differ from LSN page in case of multi - group records ) @ return Length of header or operation status @ retval RECHEADER_READ_ERROR error @ retval # number of bytes in TRANSLOG_HEADER_BUFFER : : header where stored decoded part of the header int translog_read_record_header_from_buffer(uchar *page,"translog_read_record_header_from_buffer" );"info" , ("page byte: 0x%x offset: %u" ,1 );"info" , ("Type %u, Short TrID %u, LSN " LSN_FMT,/* Read required bytes from the header and call hook */ switch (log_record_type_descriptor[buff->type].rclass) {case LOGRECTYPE_VARIABLE_LENGTH:break ;case LOGRECTYPE_PSEUDOFIXEDLENGTH:case LOGRECTYPE_FIXEDLENGTH:break ;default :0 ); /* we read some junk (got no LSN) */ /** @ brief Read record header and some fixed part of a record ( the part depend on record type ) . @ param lsn log record serial number ( address of the record ) @ param buff log record header buffer @ note Some type of record can be read completely by this call @ note " Decoded " header stored in TRANSLOG_HEADER_BUFFER : : header ( relative LSN can be translated to absolute one ) , some fields can be added ( like actual header length in the record if the header has variable length ) @ return Length of header or operation status @ retval RECHEADER_READ_ERROR error @ retval # number of bytes in TRANSLOG_HEADER_BUFFER : : header where stored decoded part of the header int translog_read_record_header(LSN lsn, TRANSLOG_HEADER_BUFFER *buff)"translog_read_record_header" );"enter" , ("LSN: " LSN_FMT, LSN_IN_PARTS(lsn)));0 );0 ;0 ;/* offset decreasing */ 0 );/** @ brief Read record header and some fixed part of a record ( the part depend on record type ) . @ param scan scanner position to read @ param buff log record header buffer @ param move_scanner request to move scanner to the header position @ note Some type of record can be read completely by this call @ note " Decoded " header stored in TRANSLOG_HEADER_BUFFER : : header ( relative LSN can be translated to absolute one ) , some fields can be added ( like actual header length in the record if the header has variable length ) @ return Length of header or operation status @ retval RECHEADER_READ_ERROR error @ retval # number of bytes in TRANSLOG_HEADER_BUFFER : : header where stored decoded part of the header int translog_read_record_header_scan(TRANSLOG_SCANNER_DATA *scanner,"translog_read_record_header_scan" );"enter" , ("Scanner: Cur: " LSN_FMT " Hrz: " LSN_FMT " " "Lst: " LSN_FMT " Offset: %u(%x) fixed %d" ,0 ;/* offset increasing */ 0 ));/** @ brief Read record header and some fixed part of the next record ( the part depend on record type ) . @ param scanner data for scanning if lsn is NULL scanner data will be used for continue scanning . The scanner can be NULL . @ param buff log record header buffer @ return Length of header or operation status @ retval RECHEADER_READ_ERROR error @ retval RECHEADER_READ_EOF EOF @ retval # number of bytes in TRANSLOG_HEADER_BUFFER : : header where stored decoded part of the header int translog_read_next_record_header(TRANSLOG_SCANNER_DATA *scanner,"translog_read_next_record_header" );0 ; /* to be sure that we will free it right */ "enter" , ("scanner: %p" , scanner));"info" , ("Scanner: Cur: " LSN_FMT " Hrz: " LSN_FMT " " "Lst: " LSN_FMT " Offset: %u(%x) fixed: %d" ,do if (translog_get_next_chunk(scanner))if (scanner->page == END_OF_LOG)"info" , ("End of file from the scanner" ));/* Last record was read */ "info" , ("Page: " LSN_FMT " offset: %lu byte: %x" ,while (!translog_is_LSN_chunk(scanner->page[scanner->page_offset]) &&if (scanner->page[scanner->page_offset] == TRANSLOG_FILLER)"info" , ("End of file" ));/* Last record was read */ /* Return 'end of log' marker */ else 0 );/* Moves record data reader to the next chunk and fill the data reader information about that chunk . SYNOPSIS translog_record_read_next_chunk ( ) data data cursor RETURN 0 OK 1 Error static my_bool translog_record_read_next_chunk(TRANSLOG_READER_DATA *data)"translog_record_read_next_chunk" );if (data->eor)"info" , ("end of the record flag set" ));1 );if (data->header.groups_no &&1 != data->current_group &&/* Goto next group */ 0 ;"info" , ("skip to group: #%u" , data->current_group));1 , &data->scanner, 1 );else if (translog_get_next_chunk(&data->scanner))1 );if (data->scanner.page == END_OF_LOG)/* Actually it should not happened , but we want to quit nicely in case of a truncated log 1 );if (type == TRANSLOG_CHUNK_LSN && data->header.groups_no)"info" ,"Last chunk: data len: %u offset: %u group: %u of %u" ,1 ));1 == data->current_group);1 , &data->scanner, 1 );1 ;0 );if (type == TRANSLOG_CHUNK_LSN || type == TRANSLOG_CHUNK_FIXED)1 ;1 ); /* End of record */ "info" , ("grp: %u chunk: %u body_offset: %u chunk_size: %u " "current_offset: %lu" ,0 );/* Initialize record reader data from LSN SYNOPSIS translog_init_reader_data ( ) lsn reference to LSN we should start from data reader data to initialize RETURN 0 OK 1 Error static my_bool translog_init_reader_data(LSN lsn,int read_header;"translog_init_reader_data" );if (translog_scanner_init(lsn, 1 , &data->scanner, 1 ) ||1 ))1 );0 ;0 ;0 ;"info" , ("read_header: %u " "body_offset: %u chunk_size: %u current_offset: %lu" ,0 );/** @ brief Destroy reader data object static void translog_destroy_reader_data(TRANSLOG_READER_DATA *data)/* Read a part of the record . SYNOPSIS translog_read_record_header ( ) lsn log record serial number ( address of the record ) offset From the beginning of the record beginning ( read by translog_read_record_header ) . length Length of record part which have to be read . buffer Buffer where to read the record part ( have to be at least ' length ' bytes length ) RETURN length of data actually read "translog_read_record" );if (data == NULL)if (lsn ||if (translog_init_reader_data(lsn, data))0 );"info" , ("Offset: %lu length: %lu " "Scanner: Cur: " LSN_FMT " Hrz: " LSN_FMT " " "Lst: " LSN_FMT " Offset: %u(%x) fixed: %d" ,if (offset < data->read_header)"info" ,"enter header offset: %lu length: %lu" ,if (length == 0 )"info" ,"len: %u offset: %lu curr: %lu length: %lu" ,/* TODO: find first page which we should read by offset */ /* read the record chunk by chunk */ for (;;)"info" ,"enter body offset: %lu curr: %lu " "length: %lu page_end: %lu" ,if (offset < page_end)/* in case we read beyond record's end */ if (length == 0 )"info" ,"len: %u offset: %lu curr: %lu length: %lu" ,if (translog_record_read_next_chunk(data))/* @ brief Force skipping to the next buffer @ todo Do not copy old page content if all page protections are switched off ( because we do not need calculate something or change old parts of the page ) static void translog_force_current_buffer_to_finish()1 ) % TRANSLOG_BUFFERS_NO;struct st_translog_buffer *new_buffer= (log_descriptor.buffers +struct st_translog_buffer *old_buffer= log_descriptor.bc.buffer;"translog_force_current_buffer_to_finish" );"enter" , ("Buffer #%u %p " "Buffer addr: " LSN_FMT " " "Page addr: " LSN_FMT " " "size: %lu (%lu) Pg: %u left: %u in progress %u" ,/* increase offset */ if (left)/* TODO : if ' left ' is so small that can ' t hold any other record then do not move the page "info" , ("left: %u" , (uint) left));/* decrease offset */ "info" , ("Finish Page buffer #%u: %p " "Size: %lu" ,else 0 ;#ifndef DBUG_OFF#endif #ifndef DBUG_OFF/* We keep the handler locked so nobody can start this new buffer */ 1 )) == new_buffer->ver);#endif /* Fix buffer offset (which was incorrectly set to horizon) */ "info" , ("prev_last_lsn set to " LSN_FMT " buffer: %p" ,/* Advances this log pointer , increases writers and let other threads to write to the log while we process old page content if (left)1 ;else /* We have to wait until all writers finish before start changing the pages by applying protection and copying the page content in the new buffer . #ifndef DBUG_OFF#endif /* Now only one thread can flush log ( buffer can flush many threads but log flush log flush where this function is used can do only one thread ) so no other thread can set is_closing_buffer . 1 ; /* Other flushes will wait */ "enter" , ("Buffer #%u %p is_closing_buffer set" ,#ifndef DBUG_OFF/* We blocked flushing this buffer so the buffer should not changed */ #endif if (log_descriptor.flags & TRANSLOG_SECTOR_PROTECTION)if (left)else "info" , ("drop write_counter" ));0 ;0 ;if (log_descriptor.flags & TRANSLOG_PAGE_CRC)"info" , ("CRC: 0x%x" , crc));3 + 3 + 1 , crc);0 ;"enter" , ("Buffer #%u %p is_closing_buffer cleared" ,if (left)if (log_descriptor.flags &else /* This page header does not change if we add more data to the page so we can not copy it and will not overwrite later /** @ brief Waits while given lsn will be flushed @ param lsn log record serial number up to which ( inclusive ) the log has to be flushed void translog_flush_wait_for_end(LSN lsn)"translog_flush_wait_for_end" );"enter" , ("LSN: " LSN_FMT, LSN_IN_PARTS(lsn)));while (cmp_translog_addr(log_descriptor.flushed, lsn) < 0 )/** @ brief Sets goal for the next flush pass and waits for this pass end . @ param lsn log record serial number up to which ( inclusive ) the log has to be flushed void translog_flush_set_new_goal_and_wait(TRANSLOG_ADDRESS lsn)int flush_no= log_descriptor.flush_no;"translog_flush_set_new_goal_and_wait" );"enter" , ("LSN: " LSN_FMT, LSN_IN_PARTS(lsn)));if (cmp_translog_addr(lsn, log_descriptor.next_pass_max_lsn) > 0 )while (flush_no == log_descriptor.flush_no)/** @ brief sync ( ) range of files ( inclusive ) and directory ( by request ) @ param min min internal file number to flush @ param max max internal file number to flush @ param sync_dir need sync directory return Operation status @ retval 0 OK @ retval 1 Error static my_bool translog_sync_files(uint32 min, uint32 max,0 ;"translog_sync_files" );"info" , ("min: %lu max: %lu sync dir: %d" ,int ) sync_dir));if (flush_interval)for (fn= min; fn <= max; fn++)if (!file->is_sync)if (mysql_file_sync(file->handler.file, MYF(MY_WME)))1 ;1 ;if (sync_dir)if (!(rc= sync_dir(log_descriptor.directory_fd,/** check_skipped_lsn Check if lsn skipped in redo is ok void check_skipped_lsn(MARIA_HA *info, LSN lsn, my_bool index_file,if (lsn <= log_descriptor.horizon)"info" , ("Page is up to date, skipping redo" ));else /* Give error, but don't flood the log */ if (skipped_lsn_err_count++ < MAX_LSN_ERRORS &&"Table %s has wrong LSN: " LSN_FMT " on page: %llu" ,/* @ brief Flushes buffers with LSNs in them less or equal address < lsn > @ param lsn address up to which all LSNs should be flushed , can be reset to real last LSN address @ parem sent_to_disk returns ' sent to disk ' position @ param flush_horizon returns horizon of the flush @ note About terminology see comment to translog_flush ( ) . void translog_flush_buffers(TRANSLOG_ADDRESS *lsn,"translog_flush_buffers" );/* We will recheck information when will lock buffers one by one so we can use unprotected read here ( this is just for speed up buffers processing ) "info" , ("Dirty buffer mask: %lx current buffer: %u" ,for (i= (log_descriptor.bc.buffer_no + 1 ) % TRANSLOG_BUFFERS_NO;1 << i));1 ) % TRANSLOG_BUFFERS_NO) {}"info" ,"start from: %u current: %u prev last lsn: " LSN_FMT,/* if LSN up to which we have to flush bigger then maximum LSN of previous buffer and at least one LSN was saved in the current buffer ( last_lsn ! = LSN_IMPOSSIBLE ) then we have to close the current buffer . if (cmp_translog_addr(*lsn, log_descriptor.bc.buffer->prev_last_lsn) > 0 &&struct st_translog_buffer *buffer= log_descriptor.bc.buffer;/* fix lsn if it was horizon */ "info" , ("LSN to flush fixed to last lsn: " LSN_FMT,1 ;else if (log_descriptor.bc.buffer->last_lsn == LSN_IMPOSSIBLE &&"info" , ("There is no LSNs yet generated => do nothing" ));/* fix lsn if it was horizon */ "info" , ("LSN to flush fixed to prev last lsn: " LSN_FMT,1 ) %/* flush buffers */ if (cmp_translog_addr(*lsn, *sent_to_disk) > 0 )"info" , ("Start buffer #: %u last buffer #: %u" ,1 ) % TRANSLOG_BUFFERS_NO;do struct st_translog_buffer *buffer= log_descriptor.buffers + i;"info" , ("Check buffer: %p #: %u " "prev last LSN: " LSN_FMT " " "last LSN: " LSN_FMT " status: %s" ,"dirty" : "closed" )));if (buffer->prev_last_lsn <= *lsn &&/* pre_force_close_horizon is reset during new buffer start */ "info" , ("flush_horizon: " LSN_FMT,1 ) % TRANSLOG_BUFFERS_NO;while (i != last_buffer_no);/** @ brief Flush the log up to given LSN ( included ) @ param lsn log record serial number up to which ( inclusive ) the log has to be flushed @ return Operation status @ retval 0 OK @ retval 1 Error @ note - Non group commit logic : Commits made in passes . Thread which started flush first is performing actual flush , other threads sets new goal ( LSN ) of the next pass ( if it is maximum ) and waits for the pass end or just wait for the pass end . - If hard group commit enabled and rate set to zero : The first thread sends all changed buffers to disk . This is repeated as long as there are new LSNs added . The process can not loop forever because we have limited number of threads and they will wait for the data to be synced . Pseudo code : do send changed buffers to disk while new_goal sync - If hard group commit switched ON and less than rate microseconds has passed from last sync , then after buffers have been sent to disk wait until rate microseconds has passed since last sync , do sync and return . This ensures that if we call sync infrequently we don ' t do any waits . - If soft group commit enabled everything works as with ' non group commit ' but the thread doesn ' t do any real sync ( ) . If rate is not zero the sync ( ) will be performed by a service thread with the given rate when needed ( new LSN appears ) . @ note Terminology : ' sent to disk ' means written to disk but not sync ( ) ed , ' flushed ' mean sent to disk and synced ( ) . struct timespec abstime;0 ;"translog_flush" );"enter" , ("Flush up to LSN: " LSN_FMT, LSN_IN_PARTS(lsn)));"info" , ("Everything is flushed up to " LSN_FMT,if (cmp_translog_addr(log_descriptor.flushed, lsn) >= 0 )0 );if (log_descriptor.flush_in_progress)/* fix lsn if it was horizon */ if (cmp_translog_addr(lsn, log_descriptor.bc.buffer->last_lsn) > 0 )if (!pthread_equal(log_descriptor.max_lsn_requester, pthread_self()))/* translog_flush_wait_for_end ( ) release log_flush_lock while is waiting then acquire it again 0 );1 ;"info" , ("flush_in_progress is set, flush_horizon: " LSN_FMT,if (hgroup_commit_at_start)if (log_descriptor.is_everything_flushed)"info" , ("everything is flushed" ));goto out;for (;;)/* Following function flushes buffers and makes translog_unlock() */ if (!hgroup_commit_at_start)break ; /* flush pass is ended */ /* We do not check time here because mysql_mutex_lock rarely takes a lot of time so we can sacrifice a bit precision to performance ( taking into account that microsecond_interval_timer ( ) might be expensive call ) . if (flush_interval == 0 )break ; /* flush pass is ended */ if (log_descriptor.next_pass_max_lsn == LSN_IMPOSSIBLE)if (flush_interval == 0 ||break ;"info" , ("flush waits: %llu interval: %llu spent: %llu" ,/* wait time or next goal */ "info" , ("retest conditions" ));goto retest;/* take next goal */ /* prevent other thread from continue */ "info" , ("flush took next goal: " LSN_FMT,/* next flush pass */ "info" , ("next flush pass" ));/* sync ( ) files from previous flush till current one if (!soft_sync || hgroup_commit_at_start)if ((rc=goto out;/* keep values for soft sync() and forced sync() actual */ else 1 ;if (sent_to_disk != LSN_IMPOSSIBLE)0 ;"info" , ("flush_in_progress is dropped" ));/** @ brief Gives a 2 - byte - id to MARIA_SHARE and logs this fact If a MARIA_SHARE does not yet have a 2 - byte - id ( unique over all currently open MARIA_SHAREs ) , give it one and record this assignment in the log ( LOGREC_FILE_ID log record ) . @ param tbl_info table @ param trn calling transaction @ return Operation status @ retval 0 OK @ retval 1 Error @ note Can be called even if share already has an id ( then will do nothing ) int translog_assign_id_to_share(MARIA_HA *tbl_info, TRN *trn)/* If you give an id to a non - BLOCK_RECORD table , you also need to release this id somewhere . Then you can change the assertion . /* re-check under mutex to avoid having 2 ids for the same share */ if (unlikely(share->id == 0 ))2 ];/* Inspired by set_short_trid() of trnman.c */ 1 ;0 ;do for ( ; i <= SHARE_ID_MAX ; i++) /* the range is [1..SHARE_ID_MAX] */ void *tmp= NULL;if (id_to_share[i] == NULL &&void **)&id_to_share[i], &tmp, share))break ;1 ; /* scan the whole array */ while (id == 0 );"info" , ("id_to_share: %p -> %u" , share, id));0 ].str= log_data;0 ].length= sizeof (log_data);/* open_file_name is an unresolved name ( symlinks are not resolved , datadir is not realpath - ed , etc ) which is good : the log can be moved to another directory and continue working . 1 ].str=1 ].length=1 ;/* We can ' t unlock share - > intern_lock before the log entry is written to ensure no one uses the id before it ' s logged . if (unlikely(translog_write_record(&lsn, LOGREC_FILE_ID, trn, tbl_info,sizeof (log_data) +1 ].length),sizeof (log_array)/sizeof (log_array[0 ]),return 1 ;/* Now when translog record is done , we can set share - > id . If we set it before , then translog_write_record may pick up the id before it ' s written to the log . return 0 ;/** @ brief Recycles a MARIA_SHARE ' s short id . @ param share table @ note Must be called only if share has an id ( i . e . id ! = 0 ) void translog_deassign_id_from_share(MARIA_SHARE *share)"info" , ("id_to_share: %p id %u -> 0" ,/* We don ' t need any mutex as we are called only when closing the last instance of the table or at the end of REPAIR : no writes can be happening . But a Checkpoint may be reading share - > id , so we require this mutex : void **)&id_to_share[share->id], 0 );0 ;/* useless but safety: */ void translog_assign_id_to_share_from_recovery(MARIA_SHARE *share,0 );/** @ brief check if such log file exists @ param file_no number of the file to test @ retval 0 no such file @ retval 1 there is file with such number char path[FN_REFLEN];return (MY_TEST(mysql_file_stat(key_file_translog,0 ))));/** @ brief returns minimum log file number @ param horizon the end of the log @ param is_protected true if it is under purge_log protection @ retval minimum file number @ retval 0 no files found static uint32 translog_first_file(TRANSLOG_ADDRESS horizon, int is_protected)1 , max_file;"translog_first_file" );if (!is_protected)if (log_descriptor.min_file_number)if (translog_is_file(log_descriptor.min_file_number))"info" , ("cached %lu" ,if (!is_protected)if (!translog_is_file(max_file))if (!is_protected)/* For compatibility */ /* binary search for last file */ while (min_file < max_file)2 ;"info" , ("min_file: %u test: %u max_file: %u" ,if (translog_is_file(test))else 1 ;if (!is_protected)"info" , ("first file :%lu" , (ulong) max_file));1 );/** @ brief returns the most close LSN higher the given chunk address @ param addr the chunk address to start from @ param horizon the horizon if it is known or LSN_IMPOSSIBLE @ retval LSN_ERROR Error @ retval LSN_IMPOSSIBLE no LSNs after the address @ retval # LSN of the most close LSN higher the given chunk address "translog_next_LSN" );if (horizon == LSN_IMPOSSIBLE)if (addr == horizon)0 , &scanner, 1 );/* addr can point not to a chunk beginning but page end so next page beginning . if (addr % TRANSLOG_PAGE_SIZE == 0 )/* We are emulating the page end which cased such horizon value to trigger translog_scanner_eop ( ) . We can ' t just increase addr on page header overhead because it can be file end so we allow translog_get_next_chunk ( ) to skip to the next page in correct way #ifndef DBUG_OFF/* prevent using incorrect page content */ #endif /* addr can point not to a chunk beginning but to a page end */ if (translog_scanner_eop(&scanner))if (translog_get_next_chunk(&scanner))goto out;if (scanner.page == END_OF_LOG)goto out;while (!translog_is_LSN_chunk(scanner.page[scanner.page_offset]) &&if (translog_get_next_chunk(&scanner))goto out;if (scanner.page == END_OF_LOG)goto out;if (scanner.page[scanner.page_offset] == TRANSLOG_FILLER)/* reached page filler */ else /** @ brief returns the LSN of the first record starting in this log @ retval LSN_ERROR Error @ retval LSN_IMPOSSIBLE no log or the log is empty @ retval # LSN of the first record "translog_first_lsn_in_log" );"info" , ("Horizon: " LSN_FMT, LSN_IN_PARTS(horizon)));if (!(file= translog_first_file(horizon, 0 )))/* log has no records yet */ /* the first page of the file */ if ((page= translog_get_page(&data, psize_buff.buffer, NULL)) == NULL ||0 )/** @ brief Returns theoretical first LSN if first log is present @ retval LSN_ERROR Error @ retval LSN_IMPOSSIBLE no log @ retval # LSN of the first record "translog_first_theoretical_lsn" );"info" , ("Horizon: " LSN_FMT, LSN_IN_PARTS(addr)));if (!translog_is_file(1 ))if (addr == MAKE_LSN(1 , TRANSLOG_PAGE_SIZE))/* log has no records yet */ 1 , TRANSLOG_PAGE_SIZE +1 , TRANSLOG_PAGE_SIZE); /* the first page of the file */ if ((page= translog_get_page(&data, psize_buff.buffer, NULL)) == NULL)1 , TRANSLOG_PAGE_SIZE +/** @ brief Checks given low water mark and purge files if it is need @ param low the last ( minimum ) address which is need @ retval 0 OK @ retval 1 Error int soft;int rc= 0 ;"translog_purge" );"enter" , ("low: " LSN_FMT, LSN_IN_PARTS(low)));"info" , ("min_unsync: %lu" , (ulong) min_unsync));if (soft && min_unsync < last_need_file)"info" , ("last_need_file set to %lu" , (ulong)last_need_file));"info" , ("last_lsn_checked file: %lu:" ,if (LSN_FILE_NO(log_descriptor.last_lsn_checked) < last_need_file)1 );0 ); /* log is already started */ "info" , ("min_file: %lu:" ,(ulong) min_file));for (i= min_file; i < last_need_file && rc == 0 ; i++)if (lsn == LSN_IMPOSSIBLE)break ; /* files are still in writing */ if (lsn == LSN_ERROR)1 ;break ;if (cmp_translog_addr(lsn, low) >= 0 )break ;"info" , ("purge file %lu" , (ulong) i));/* remove file descriptor from the cache */ /* log_descriptor . min_file can be changed only here during execution and the function is serialized , so we can access it without problems if (i >= log_descriptor.min_file)1 =="info" , ("Files : %zu" , log_descriptor.open_files.elements));1 ==if (log_purge_type == TRANSLOG_PURGE_IMMIDIATE && ! log_purge_disabled)char path[FN_REFLEN], *file_name;if (unlikely(rc == 1 ))0 ; /* impossible value */ else /** @ brief Purges files by stored min need file in case of " one demand " purge type @ note This function do real work only if it is " one demand " purge type and translog_purge ( ) was called at least once and last time without errors @ retval 0 OK @ retval 1 Error int rc= 0 ;"translog_purge_at_flush" );if (unlikely(translog_status == TRANSLOG_READONLY))"info" , ("The log is read only => exit" ));0 );if (log_purge_type != TRANSLOG_PURGE_ONDEMAND)"info" , ("It is not \" at_flush\" => exit" ));0 );if (unlikely(log_descriptor.min_need_file == 0 || log_purge_disabled))"info" , ("No info about min need file => exit" ));0 );1 );0 ); /* log is already started */ for (i= min_file; i < log_descriptor.min_need_file ; i++)char path[FN_REFLEN], *file_name;"info" , ("purge file %lu\n" , (ulong) i));0 );/** @ brief Gets min file number @ param horizon the end of the log @ retval minimum file number @ retval 0 no files found return translog_first_file(horizon, 0 );/** @ brief Gets min file number which is needed @ retval minimum file number @ retval 0 unknown return file_no;/** @ brief Gets transaction log file size @ return transaction log file size return (res);/** @ brief Sets transaction log file size @ return Returns actually set transaction log size void translog_set_file_size(uint32 size)struct st_translog_buffer *old_buffer= NULL;"translog_set_file_size" );"enter" , ("Size: %lu" , (ulong) size));0 );/* if current file longer then finish it*/ if (LSN_OFFSET(log_descriptor.horizon) >= log_descriptor.log_file_max_size)1 );if (old_buffer)/** Write debug information to log if we EXTRA_DEBUG is enabled enum translog_debug_info_type type#ifdef EXTRA_DEBUG2 ];if (!trn)/* We can ' t log the current transaction because we don ' t have an active transaction . Use a temporary transaction object instead 0 ].str= &debug_type;0 ].length= 1 ;1 ].str= info;1 ].length= length;return translog_write_record(&lsn, LOGREC_DEBUG_INFO,1 + length),sizeof (log_array)/sizeof (log_array[0 ]),#else return 0 ;#endif /** Sets soft sync mode @ param mode TRUE if we need switch soft sync on else off void translog_soft_sync(my_bool mode)/** Sets hard group commit @ param mode TRUE if we need switch hard group commit on else off void translog_hard_group_commit(my_bool mode)/** @ brief forced log sync ( used when we are switching modes ) void translog_sync()"ma_translog_sync" );/* The following is only true if initalization of translog succeded */ if (log_descriptor.open_files.elements != 0 )if (!min)/** @ brief set rate for group commit @ param interval interval to set . @ note We use this function with additional variable because have to restart service thread with new value which we can ' t make inside changing variable routine ( update_maria_group_commit_interval ) void translog_set_group_commit_interval(uint32 interval)"translog_set_group_commit_interval" );"info" , ("wait: %llu" ,/** @ brief syncing service thread static pthread_handler_tvoid *arg __attribute__((unused)))"ma_soft_sync_background" );for (;;)0 ;if (sync_request)FALSE );if (time > sleep)0 ;else if (my_service_thread_sleep(&soft_sync_control, sleep))break ;0 );/** @ brief Starts syncing thread int translog_soft_sync_start(void )int res= 0 ;"translog_soft_sync_start" );/* check and init variables */ if (!max)if (!min)1 ;if (!(res= ma_service_thread_control_init(&soft_sync_control)))if ((res= mysql_thread_create(key_thread_soft_sync,TRUE ;/** @ brief Stops syncing thread void translog_soft_sync_end(void )"translog_soft_sync_end" );if (soft_sync_control.inited)/** @ brief Dump information about file header page . static void dump_header_page(uchar *buff)char strbuff[21 ];struct tm tmp_tm;1000000 ULL;" This can be header page:\n" " Timestamp: %04d.%02d.%02d %02d.%02d.%02d (%s)\n" " Aria log version: %lu\n" " Server version: %lu\n" " Server id %lu\n" " Page size %lu\n" ,1900 , tmp_tm.tm_mon+1 , tmp_tm.tm_mday,if (desc.page_size != TRANSLOG_PAGE_SIZE)" WARNING: page size is not equal compiled in one %lu!!!\n" ," File number %lu\n" " Max lsn: " LSN_FMT "\n" ,static const char *record_class_string[]="LOGRECTYPE_NOT_ALLOWED" ,"LOGRECTYPE_VARIABLE_LENGTH" ,"LOGRECTYPE_PSEUDOFIXEDLENGTH" ,"LOGRECTYPE_FIXEDLENGTH" /** @ brief dump information about transaction log chunk @ param buffer reference to the whole page @ param ptr pointer to the chunk @ reval # reference to the next chunk @ retval NULL can ' t interpret data static uchar *dump_chunk(uchar *buffer, uchar *ptr)if (*ptr == TRANSLOG_FILLER)" Filler till the page end\n" );for (; ptr < buffer + TRANSLOG_PAGE_SIZE; ptr++)if (*ptr != TRANSLOG_FILLER)" WARNING: non filler character met before page end " "(page + 0x%04x: 0x%02x) (stop interpretation)!!!" ,0 ]);return NULL;return ptr;if (*ptr == 0 || *ptr == 0 xFF)" WARNING: chunk can't start from 0x0 " "(stop interpretation)!!!\n" );return NULL;switch (ptr[0 ] & TRANSLOG_CHUNK_TYPE) {case TRANSLOG_CHUNK_LSN:" LSN chunk type 0 (variable length)\n" );if (likely((ptr[0 ] & TRANSLOG_REC_TYPE) != TRANSLOG_CHUNK_0_CONT))" Record type %u: %s record class %s compressed LSNs: %u\n" ,0 ] & TRANSLOG_REC_TYPE,0 ] & TRANSLOG_REC_TYPE].name ?0 ] & TRANSLOG_REC_TYPE].name :"NULL" ),0 ] &0 ] & TRANSLOG_REC_TYPE].if (log_record_type_descriptor[ptr[0 ] & TRANSLOG_REC_TYPE].rclass !=" WARNING: this record class here can't be used " "(stop interpretation)!!!\n" );break ;else " Continuation of previous chunk 0 header \n" );" Short transaction id: %u\n" , (uint) uint2korr(ptr + 1 ));1 + 2 ; /* chunk type and short trid */ " Record length: %lu\n" ,if (chunk_len == 0 )" It is 1 group record (chunk length == 0)\n" );else " Chunk length %u\n" , (uint) chunk_len);2 );4 ;" Number of groups left to the end %u:\n" , (uint) groups);for (i= 0 ;1 )" Group +#%u: " LSN_FMT " pages: %u\n" ,break ;case TRANSLOG_CHUNK_FIXED:" LSN chunk type 1 (fixed size)\n" );" Record type %u: %s record class %s compressed LSNs: %u\n" ,0 ] & TRANSLOG_REC_TYPE,0 ] & TRANSLOG_REC_TYPE].name ?0 ] & TRANSLOG_REC_TYPE].name :"NULL" ),0 ] &0 ] & TRANSLOG_REC_TYPE].if (log_record_type_descriptor[ptr[0 ] & TRANSLOG_REC_TYPE].rclass !=0 ] & TRANSLOG_REC_TYPE].rclass !=" WARNING: this record class here can't be used " "(stop interpretation)!!!\n" );" Short transaction id: %u\n" , (uint) uint2korr(ptr + 1 ));break ;case TRANSLOG_CHUNK_NOHDR:" No header chunk type 2(till the end of the page)\n" );if (ptr[0 ] & TRANSLOG_REC_TYPE)" WARNING: chunk header content record type: 0x%02x " "(dtop interpretation)!!!" ,0 ]);return NULL;break ;case TRANSLOG_CHUNK_LNGTH:" Chunk with length type 3\n" );if (ptr[0 ] & TRANSLOG_REC_TYPE)" WARNING: chunk header content record type: 0x%02x " "(dtop interpretation)!!!" ,0 ]);return NULL;break ;" Length %u\n" , length);return ptr;/** @ brief Dump information about page with data . static void dump_datapage(uchar *buffer, File handler)" Page: %ld File number: %ld\n" ,3 )));if (page == 0 )" WARNING: page == 0!!!\n" );if (file == 0 )" WARNING: file == 0!!!\n" );" Flags (0x%x):\n" , (uint) buffer[TRANSLOG_PAGE_FLAGS]);if (buffer[TRANSLOG_PAGE_FLAGS])if (buffer[TRANSLOG_PAGE_FLAGS] & TRANSLOG_PAGE_CRC)" Page CRC\n" );if (buffer[TRANSLOG_PAGE_FLAGS] & TRANSLOG_SECTOR_PROTECTION)" Sector protection\n" );if (buffer[TRANSLOG_PAGE_FLAGS] & TRANSLOG_RECORD_CRC)" Record CRC (WARNING: not yet implemented!!!)\n" );if (buffer[TRANSLOG_PAGE_FLAGS] & ~(TRANSLOG_PAGE_CRC |" WARNING: unknown flags (stop interpretation)!!!\n" );return ;else " No flags\n" );" Page header length: %u\n" ,if (buffer[TRANSLOG_PAGE_FLAGS] & TRANSLOG_RECORD_CRC)1 );" Page CRC 0x%04lx\n" , (ulong) crc);if (crc != ccrc)" WARNING: calculated CRC: 0x%04lx!!!\n" , (ulong) ccrc);if (buffer[TRANSLOG_PAGE_FLAGS] & TRANSLOG_SECTOR_PROTECTION)" Sector protection current value: 0x%02x\n" , (uint) table[0 ]);for (i= 1 ; i < TRANSLOG_PAGE_SIZE / DISK_DRIVE_SECTOR_SIZE; i++)" Sector protection in sector: 0x%02x saved value 0x%02x\n" ,sizeof (tfile.handler));0 ;1 ;if (translog_check_sector_protection(buffer, &tfile))" WARNING: sector protection found problems!!!\n" );while (ptr && ptr < buffer + TRANSLOG_PAGE_SIZE)" Chunk %d %lld:\n" ,/** @ brief Dump information about page . void dump_page(uchar *buffer, File handler)if (strncmp((char *)maria_trans_file_magic, (char *)buffer,sizeof (maria_trans_file_magic)) == 0 )return ;/* Handle backup calls void translog_disable_purge()void translog_enable_purge()
Messung V0.5 in Prozent C=94 H=76 G=85
¤ Dauer der Verarbeitung: 0.903 Sekunden
(vorverarbeitet am 2026-10-08)
¤ *© Formatika GbR, Deutschland
