MySQL 8.0.31
Source Code Documentation
log0recv.h
Go to the documentation of this file.
1/*****************************************************************************
2
3Copyright (c) 1997, 2022, Oracle and/or its affiliates.
4
5This program is free software; you can redistribute it and/or modify it under
6the terms of the GNU General Public License, version 2.0, as published by the
7Free Software Foundation.
8
9This program is also distributed with certain software (including but not
10limited to OpenSSL) that is licensed under separate terms, as designated in a
11particular file or component or in included license documentation. The authors
12of MySQL hereby grant you an additional permission to link the program and
13your derivative works with the separately licensed software that they have
14included with MySQL.
15
16This program is distributed in the hope that it will be useful, but WITHOUT
17ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
18FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0,
19for more details.
20
21You should have received a copy of the GNU General Public License along with
22this program; if not, write to the Free Software Foundation, Inc.,
2351 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
24
25*****************************************************************************/
26
27/** @file include/log0recv.h
28 Recovery
29
30 Created 9/20/1997 Heikki Tuuri
31 *******************************************************/
32
33#ifndef log0recv_h
34#define log0recv_h
35
36#include "buf0types.h"
37#include "dict0types.h"
38#include "hash0hash.h"
39#include "log0sys.h"
40#include "mtr0types.h"
41
42/* OS_FILE_LOG_BLOCK_SIZE */
43#include "os0file.h"
44
45#include "ut0byte.h"
46#include "ut0new.h"
47
48#include <list>
49#include <set>
50#include <unordered_map>
51
52class MetadataRecover;
54
55#ifdef UNIV_HOTBACKUP
56
57struct recv_addr_t;
58
59/** list of tablespaces, that experienced an inplace DDL during a backup op */
60extern std::list<std::pair<space_id_t, lsn_t>> index_load_list;
61/** the last redo log flush len as seen by MEB */
62extern volatile lsn_t backup_redo_log_flushed_lsn;
63/** true when the redo log is being backed up */
64extern bool recv_is_making_a_backup;
65
66/** Scans the log segment and n_bytes_scanned is set to the length of valid
67log scanned.
68@param[in] buf buffer containing log data
69@param[in] buf_len data length in that buffer
70@param[in,out] scanned_lsn lsn of buffer start, we return scanned
71lsn
72@param[in,out] scanned_checkpoint_no 4 lowest bytes of the highest scanned
73@param[out] block_no highest block no in scanned buffer.
74checkpoint number so far
75@param[out] n_bytes_scanned how much we were able to scan, smaller
76than buf_len if log data ended here
77@param[out] has_encrypted_log set true, if buffer contains encrypted
78redo log, set false otherwise */
79void meb_scan_log_seg(byte *buf, size_t buf_len, lsn_t *scanned_lsn,
80 uint32_t *scanned_checkpoint_no, uint32_t *block_no,
81 size_t *n_bytes_scanned, bool *has_encrypted_log);
82
83/** Applies the hashed log records to the page, if the page lsn is less than the
84lsn of a log record. This can be called when a buffer page has just been
85read in, or also for a page already in the buffer pool.
86
87
88@param[in,out] block buffer block */
90
91/** Wrapper for recv_recover_page_func().
92Applies the hashed log records to the page, if the page lsn is less than the
93lsn of a log record. This can be called when a buffer page has just been
94read in, or also for a page already in the buffer pool.
95@param jri in: true if just read in (the i/o handler calls this for
96a freshly read page)
97@param block in,out: the buffer block
98*/
99static inline void recv_recover_page(bool jri [[maybe_unused]],
100 buf_block_t *block) {
102}
103
104/** Applies log records in the hash table to a backup. */
105void meb_apply_log_recs(void);
106
107/** Applies log records in the hash table to a backup using a callback
108functions.
109@param[in] apply_log_record_function function for apply
110@param[in] wait_till_done_function function for wait */
111void meb_apply_log_recs_via_callback(
112 void (*apply_log_record_function)(recv_addr_t *),
113 void (*wait_till_done_function)());
114
115/** Applies a log record in the hash table to a backup.
116@param[in] recv_addr chain of log records
117@param[in,out] block buffer block to apply the records to */
118void meb_apply_log_record(recv_addr_t *recv_addr, buf_block_t *block);
119
120/** Process a file name passed as an input
121@param[in] name absolute path of tablespace file
122@param[in] space_id the tablespace ID
123@retval true if able to process file successfully.
124@retval false if unable to process the file */
125void meb_fil_name_process(const char *name, space_id_t space_id);
126
127/** Scans log from a buffer and stores new log data to the parsing buffer.
128Parses and hashes the log records if new data found. Unless
129UNIV_HOTBACKUP is defined, this function will apply log records
130automatically when the hash table becomes full.
131@param[in] available_memory we let the hash table of recs
132to grow to this size, at the maximum
133@param[in] buf buffer containing a log
134segment or garbage
135@param[in] len buffer length
136@param[in] start_lsn buffer start lsn
137@param[out] group_scanned_lsn scanning succeeded up to this lsn
138@param[out] err error code as returned by recv_init_crash_recovery().
139@retval true if limit_lsn has been reached, or not able to scan any
140more in this log group
141@retval false otherwise */
142bool meb_scan_log_recs(size_t available_memory, const byte *buf, size_t len,
143 lsn_t start_lsn, lsn_t *group_scanned_lsn, dberr_t &err);
144
145/** Check the 4-byte checksum to the trailer checksum field of a log
146block.
147@param[in] block pointer to a log block
148@return whether the checksum matches */
149bool log_block_checksum_is_ok(const byte *block);
150#else /* UNIV_HOTBACKUP */
151
152/** Applies the hashed log records to the page, if the page lsn is less than the
153lsn of a log record. This can be called when a buffer page has just been
154read in, or also for a page already in the buffer pool.
155
156
157@param[in] just_read_in true if the IO handler calls this for a freshly
158 read page
159@param[in,out] block buffer block */
160void recv_recover_page_func(bool just_read_in, buf_block_t *block);
161
162/** Wrapper for recv_recover_page_func().
163Applies the hashed log records to the page, if the page lsn is less than the
164lsn of a log record. This can be called when a buffer page has just been
165read in, or also for a page already in the buffer pool.
166@param jri in: true if just read in (the i/o handler calls this for
167a freshly read page)
168@param[in,out] block buffer block */
169static inline void recv_recover_page(bool jri, buf_block_t *block) {
170 recv_recover_page_func(jri, block);
171}
172
173#endif /* UNIV_HOTBACKUP */
174
175/** Frees the recovery system. */
176void recv_sys_free();
177
178/** Reset the state of the recovery system variables. */
179void recv_sys_var_init();
180
181#ifdef UNIV_HOTBACKUP
182/** Get the number of bytes used by all the heaps
183@return number of bytes used */
184size_t meb_heap_used();
185#endif /* UNIV_HOTBACKUP */
186
187/** Returns true if recovery is currently running.
188@return recv_recovery_on */
189[[nodiscard]] static inline bool recv_recovery_is_on();
190
191/** Returns true if the page is brand new (the next log record is init_file_page
192or no records to apply).
193@param[in] block buffer block
194@return true if brand new */
196
197/** Start recovering from a redo log checkpoint.
198@see recv_recovery_from_checkpoint_finish
199@param[in,out] log redo log
200@param[in] flush_lsn lsn stored at offset FIL_PAGE_FILE_FLUSH_LSN
201 in the system tablespace header
202@return error code or DB_SUCCESS */
204 lsn_t flush_lsn);
205
206/** Complete the recovery from the latest checkpoint.
207@param[in] aborting true if the server has to abort due to an error
208@return recovered persistent metadata or nullptr if aborting*/
210 bool aborting);
211
212/** Creates the recovery system. */
213void recv_sys_create();
214
215/** Release recovery system mutexes. */
216void recv_sys_close();
217
218/** Inits the recovery system for a recovery operation. */
219void recv_sys_init();
220
221/** Calculates the new value for lsn when more data is added to the log.
222@param[in] lsn Old LSN
223@param[in] len This many bytes of data is added, log block
224 headers not included
225@return LSN after data addition */
227
228/** Empties the hash table of stored log records, applying them to appropriate
229pages.
230@param[in,out] log redo log
231@param[in] allow_ibuf if true, ibuf operations are allowed during
232 the application; if false, no ibuf operations
233 are allowed, and after the application all
234 file pages are flushed to disk and invalidated
235 in buffer pool: this alternative means that
236 no new log records can be generated during
237 the application; the caller must in this case
238 own the log mutex */
239dberr_t recv_apply_hashed_log_recs(log_t &log, bool allow_ibuf);
240
241#if defined(UNIV_DEBUG) || defined(UNIV_HOTBACKUP)
242/** Return string name of the redo log record type.
243@param[in] type record log record enum
244@return string name of record log record */
245const char *get_mlog_string(mlog_id_t type);
246#endif /* UNIV_DEBUG || UNIV_HOTBACKUP */
247
248/** Block of log record data */
250 /** pointer to the next block or NULL. The log record data
251 is stored physically immediately after this struct, max amount
252 RECV_DATA_BLOCK_SIZE bytes of it */
253
255};
256
257/** Stored log record struct */
258struct recv_t {
260
261 /** Log record type */
263
264 /** Log record body length in bytes */
266
267 /** Chain of blocks containing the log record body */
269
270 /** Start lsn of the log segment written by the mtr which generated
271 this log record: NOTE that this is not necessarily the start lsn of
272 this log record */
274
275 /** End lsn of the log segment written by the mtr which generated
276 this log record: NOTE that this is not necessarily the end LSN of
277 this log record */
279
280 /** List node, list anchored in recv_addr_t */
282};
283
284/** States of recv_addr_t */
286
287 /** not yet processed */
289
290 /** page is being read */
292
293 /** log records are being applied on the page */
295
296 /** log records have been applied on the page */
298
299 /** log records have been discarded because the tablespace
300 does not exist */
303
304/** Hashed page file address struct */
307
308 /** recovery state of the page */
310
311 /** Space ID */
313
314 /** Page number */
316
317 /** List of log records for this page */
319};
320
321// Forward declaration
322namespace dblwr {
323namespace recv {
324class DBLWR;
325}
326} // namespace dblwr
327
328/** Class to parse persistent dynamic metadata redo log, store and
329merge them and apply them to in-memory table objects finally */
332 table_id_t, PersistentTableMetadata *, std::less<table_id_t>,
334
335 public:
336 /** Default constructor */
338
339 /** Destructor */
341
342 /** Parse a dynamic metadata redo log of a table and store
343 the metadata locally
344 @param[in] id table id
345 @param[in] version table dynamic metadata version
346 @param[in] ptr redo log start
347 @param[in] end end of redo log
348 @retval ptr to next redo log record, nullptr if this log record
349 was truncated */
350 byte *parseMetadataLog(table_id_t id, uint64_t version, byte *ptr, byte *end);
351
352 /** Apply the collected persistent dynamic metadata to in-memory
353 table objects */
354 void apply();
355
356 /** Store the collected persistent dynamic metadata to
357 mysql.innodb_dynamic_metadata */
358 void store();
359
360 /** If there is any metadata to be applied
361 @return true if any metadata to be applied, otherwise false */
362 bool empty() const { return m_tables.empty(); }
363
364 private:
365 /** Get the dynamic metadata of a specified table,
366 create a new one if not exist
367 @param[in] id table id
368 @return the metadata of the specified table */
370
371 private:
372 /** Map used to store and merge persistent dynamic metadata */
374};
375
376/** Recovery system data structure */
378 using Pages =
379 std::unordered_map<page_no_t, recv_addr_t *, std::hash<page_no_t>,
380 std::equal_to<page_no_t>>;
381
382 /** Every space has its own heap and pages that belong to it. */
383 struct Space {
384 /** Constructor
385 @param[in,out] heap Heap to use for the log records. */
386 explicit Space(mem_heap_t *heap) : m_heap(heap), m_pages() {}
387
388 /** Default constructor */
389 Space() : m_heap(), m_pages() {}
390
391 /** Memory heap of log records and file addresses */
393
394 /** Pages that need to be recovered */
396 };
397
398 using Missing_Ids = std::set<space_id_t>;
399
400 using Spaces = std::unordered_map<space_id_t, Space, std::hash<space_id_t>,
401 std::equal_to<space_id_t>>;
402
403 /* Recovery encryption information */
405 /** Tablespace ID */
407
408 /** LSN of REDO log encryption entry */
410
411 /** Encryption key */
412 byte *ptr;
413
414 /** Encryption IV */
415 byte *iv;
416 };
417
418 using Encryption_Keys = std::vector<Encryption_Key>;
419
420 /** Mini transaction log record. */
421 struct Mlog_record {
422 /* Space ID */
424 /* Page number */
426 /* Log type */
428 /* Log body */
429 const byte *body;
430 /* Record size */
431 size_t size;
432 };
433
434 using Mlog_records = std::vector<Mlog_record, ut::allocator<Mlog_record>>;
435
436 /** While scanning logs for multi-record mini-transaction (mtr), we have two
437 passes. In first pass, we check if all the logs of the mtr is present in
438 current recovery buffer or not. If yes, then in second pass we go through the
439 logs again the add to hash table for apply. To avoid parsing multiple times,
440 we save the parsed records in first pass and reuse them in second pass.
441
442 Parsing of redo log takes significant amount of time and this optimization of
443 avoiding second parse gave about 1.8x speed up on recovery scan time of 1G of
444 redo log from sysbench rw test.
445
446 There is currently no limit for maximum number of logs in an mtr. Practically,
447 from sysbench rw test recovery with 1G of redo log to recover from the record
448 count were spread from 3 - 1235 with majority between 600 - 700. So, it is
449 likely by saving 1k records we could avoid most of the re-parsing overhead.
450 Considering possible bigger number of records in other load and future changes
451 the limit for number of saved records is kept at 8k. The same value from the
452 contribution patch. The memory requirement 32 x 8k = 256k seems fine as one
453 time overhead for the entire instance. */
454 static constexpr size_t MAX_SAVED_MLOG_RECS = 8 * 1024;
455
456 /** Save mlog record information. Silently returns if cannot save. Works only
457 in single threaded recovery scanner.
458 @param[in] rec_num record number in multi record group
459 @param[in] space_id space ID for the log record
460 @param[in] page_no page number for the log record
461 @param[in] type log record type
462 @param[in] body pointer to log record body in recovery buffer
463 @param[in] len length of the log record */
464 void save_rec(size_t rec_num, space_id_t space_id, page_no_t page_no,
465 mlog_id_t type, const byte *body, size_t len) {
466 /* No more space to save log. */
467 if (rec_num >= MAX_SAVED_MLOG_RECS) {
468 return;
469 }
470
471 ut_ad(rec_num < saved_recs.size());
472
473 if (rec_num >= saved_recs.size()) {
474 return;
475 }
476
477 auto &saved_rec = saved_recs[rec_num];
478
479 saved_rec.space_id = space_id;
480 saved_rec.page_no = page_no;
481 saved_rec.type = type;
482 saved_rec.body = body;
483 saved_rec.size = len;
484 }
485
486 /** Return saved mlog record information, if there. Works only
487 in single threaded recovery scanner.
488 @param[in] rec_num record number in multi record group
489 @param[out] space_id space ID for the log record
490 @param[out] page_no page number for the log record
491 @param[out] type log record type
492 @param[out] body pointer to log record body in recovery buffer
493 @param[out] len length of the log record
494 @return true iff saved record data is found. */
495 bool get_saved_rec(size_t rec_num, space_id_t &space_id, page_no_t &page_no,
496 mlog_id_t &type, byte *&body, size_t &len) {
497 if (rec_num >= MAX_SAVED_MLOG_RECS) {
498 return false;
499 }
500
501 ut_ad(rec_num < saved_recs.size());
502
503 if (rec_num >= saved_recs.size()) {
504 return false;
505 }
506
507 auto &saved_rec = saved_recs[rec_num];
508
509 space_id = saved_rec.space_id;
510 page_no = saved_rec.page_no;
511 type = saved_rec.type;
512 body = const_cast<byte *>(saved_rec.body);
513 len = saved_rec.size;
514
515 return true;
516 }
517
518#ifndef UNIV_HOTBACKUP
519
520 /*!< mutex protecting the fields apply_log_recs, n_addrs, and the
521 state field in each recv_addr struct */
522 ib_mutex_t mutex;
523
524 /** mutex coordinating flushing between recv_writer_thread and
525 the recovery thread. */
526 ib_mutex_t writer_mutex;
527
528 /** event to activate page cleaner threads */
530
531 /** event to signal that the page cleaner has finished the request */
533
534 /** type of the flush request. BUF_FLUSH_LRU: flush end of LRU,
535 keeping free blocks. BUF_FLUSH_LIST: flush all of blocks. */
537
538#else /* !UNIV_HOTBACKUP */
539 bool apply_file_operations;
540#endif /* !UNIV_HOTBACKUP */
541
542 /** This is true when log rec application to pages is allowed;
543 this flag tells the i/o-handler if it should do log record
544 application */
546
547 /** This is true when a log rec application batch is running */
549
550 /** Possible incomplete last recovered log block */
552
553 /** Buffer for parsing log records */
554 byte *buf;
555
556 /** Size of the parsing buffer */
557 size_t buf_len;
558
559 /** Amount of data in buf */
561
562 /** This is the lsn from which we were able to start parsing
563 log records and adding them to the hash table; zero if a suitable
564 start point not found yet */
566
567 /** Checkpoint lsn that was used during recovery (read from file). */
569
570 /** Number of data bytes to ignore until we reach checkpoint_lsn. */
572
573 /** The log data has been scanned up to this lsn */
575
576 /** The log data has been scanned up to this epoch_no */
578
579 /** Start offset of non-parsed log records in buf */
581
582 /** The log records have been parsed up to this lsn */
584
585 /** The previous value of recovered_lsn - before we parsed the last mtr.
586 It is equal to recovered_lsn before we parsed any mtr. This is used to
587 find moments in which recovered_lsn moves to the next block in which case
588 we should update the last_block_first_rec_group (described below). */
590
591 /** Tracks what should be the proper value of first_rec_group field in the
592 header of the block to which recovered_lsn belongs. It might be also zero,
593 in which case it means we do not know. */
595
596 /** Set when finding a corrupt log block or record, or there
597 is a log parsing buffer overflow */
599
600 /** Set when an inconsistency with the file system contents
601 is detected during log scan or apply */
603
604 /** Data directory has been recognized as cloned data directory. */
606
607 /** Data directory has been recognized as data directory from MEB. */
609
610 /** Doublewrite buffer state before MEB recovery starts. We restore to this
611 state after MEB recovery completes and disable the doublewrite buffer during
612 MEB recovery. */
614
615 /** Hash table of pages, indexed by SpaceID. */
617
618 /** Number of not processed hashed file addresses in the hash table */
620
621 /** Doublewrite buffer pages, destroyed after recovery completes */
623
624 /** We store and merge all table persistent data here during
625 scanning redo logs */
627
628 /** Encryption Key information per tablespace ID */
630
631 /** Tablespace IDs that were ignored during redo log apply. */
633
634 /** Tablespace IDs that were explicitly deleted. */
636
637 /* Saved log records to avoid second round parsing log. */
639};
640
641/** The recovery system */
642extern recv_sys_t *recv_sys;
643
644/** true when applying redo log records during crash recovery; false
645otherwise. Note that this is false while a background thread is
646rolling back incomplete transactions. */
647extern volatile bool recv_recovery_on;
648
649/** If the following is true, the buffer pool file pages must be invalidated
650after recovery and no ibuf operations are allowed; this becomes true if
651the log record hash table becomes too full, and log records must be merged
652to file pages already before the recovery is finished: in this case no
653ibuf operations are allowed, as they could modify the pages read in the
654buffer pool before the pages have been recovered to the up-to-date state.
655
656true means that recovery is running and no operations on the log files
657are allowed yet: the variable name is misleading. */
658extern bool recv_no_ibuf_operations;
659
660/** true when recv_init_crash_recovery() has been called. */
661extern bool recv_needed_recovery;
662
663/** true if buf_page_is_corrupted() should check if the log sequence
664number (FIL_PAGE_LSN) is in the future. Initially false, and set by
665recv_recovery_from_checkpoint_start(). */
666extern bool recv_lsn_checks_on;
667
668/** Size of the parsing buffer; it must accommodate RECV_SCAN_SIZE many
669times! */
670constexpr uint32_t RECV_PARSING_BUF_SIZE = 2 * 1024 * 1024;
671
672/** Size of block reads when the log groups are scanned forward to do a
673roll-forward */
674#define RECV_SCAN_SIZE (4 * UNIV_PAGE_SIZE)
675
676/** This many frames must be left free in the buffer pool when we scan
677the log and store the scanned log records in the buffer pool: we will
678use these free frames to read in pages when we start applying the
679log records to the database. */
681
682/** A list of tablespaces for which (un)encryption process was not
683completed before crash. */
684extern std::list<space_id_t> recv_encr_ts_list;
685
686#include "log0recv.ic"
687
688#endif
uint32_t space_id_t
Tablespace identifier.
Definition: api0api.h:50
uint32_t page_no_t
Page number.
Definition: api0api.h:48
The database buffer pool global types for the directory.
buf_flush_t
Flags for flush types.
Definition: buf0types.h:67
Definition: sql_list.h:433
Class to parse persistent dynamic metadata redo log, store and merge them and apply them to in-memory...
Definition: log0recv.h:330
MetadataRecover() 1=default
Default constructor.
bool empty() const
If there is any metadata to be applied.
Definition: log0recv.h:362
void store()
Store the collected persistent dynamic metadata to mysql.innodb_dynamic_metadata.
Definition: log0recv.cc:751
PersistentTableMetadata * getMetadata(table_id_t id)
Get the dynamic metadata of a specified table, create a new one if not exist.
Definition: log0recv.cc:266
void apply()
Apply the collected persistent dynamic metadata to in-memory table objects.
Definition: log0recv.cc:325
PersistentTables m_tables
Map used to store and merge persistent dynamic metadata.
Definition: log0recv.h:373
std::map< table_id_t, PersistentTableMetadata *, std::less< table_id_t >, ut::allocator< std::pair< const table_id_t, PersistentTableMetadata * > > > PersistentTables
Definition: log0recv.h:333
byte * parseMetadataLog(table_id_t id, uint64_t version, byte *ptr, byte *end)
Parse a dynamic metadata redo log of a table and store the metadata locally.
Definition: log0recv.cc:292
Persistent dynamic metadata for a table.
Definition: dict0mem.h:2729
Redo recovery configuration.
Definition: buf0dblwr.h:473
Allocator that allows std::* containers to manage their memory through ut::malloc* and ut::free libra...
Definition: ut0new.h:2179
dberr_t
Definition: db0err.h:38
Data dictionary global types.
ib_id_t table_id_t
Table or partition identifier (unique within an InnoDB instance).
Definition: dict0types.h:217
mysql_service_status_t recv(const char *tag, const unsigned char *data, size_t data_length) noexcept
Definition: gr_message_service_example.cc:38
The simple hash table utility.
bool recv_is_making_a_backup
true When the redo log is being backed up
Definition: log0recv.cc:171
static bool log_block_checksum_is_ok(const byte *block)
Check the 4-byte checksum to the trailer checksum field of a log block.
Definition: log0recv.cc:684
bool recv_no_ibuf_operations
If the following is true, the buffer pool file pages must be invalidated after recovery and no ibuf o...
Definition: log0recv.cc:168
MetadataRecover * recv_recovery_from_checkpoint_finish(bool aborting)
Complete the recovery from the latest checkpoint.
Definition: log0recv.cc:4109
void recv_sys_free()
Frees the recovery system.
Definition: log0recv.cc:836
void recv_sys_init()
Inits the recovery system for a recovery operation.
Definition: log0recv.cc:592
recv_addr_state
States of recv_addr_t.
Definition: log0recv.h:285
@ RECV_BEING_READ
page is being read
Definition: log0recv.h:291
@ RECV_DISCARDED
log records have been discarded because the tablespace does not exist
Definition: log0recv.h:301
@ RECV_BEING_PROCESSED
log records are being applied on the page
Definition: log0recv.h:294
@ RECV_NOT_PROCESSED
not yet processed
Definition: log0recv.h:288
@ RECV_PROCESSED
log records have been applied on the page
Definition: log0recv.h:297
lsn_t recv_calc_lsn_on_data_add(lsn_t lsn, os_offset_t len)
Calculates the new value for lsn when more data is added to the log.
Definition: log0recv.cc:236
void recv_sys_close()
Release recovery system mutexes.
Definition: log0recv.cc:477
constexpr uint32_t RECV_PARSING_BUF_SIZE
Size of the parsing buffer; it must accommodate RECV_SCAN_SIZE many times!
Definition: log0recv.h:670
dberr_t recv_apply_hashed_log_recs(log_t &log, bool allow_ibuf)
Empties the hash table of stored log records, applying them to appropriate pages.
Definition: log0recv.cc:1197
void recv_sys_var_init()
Reset the state of the recovery system variables.
Definition: log0recv.cc:514
bool recv_page_is_brand_new(buf_block_t *block)
Returns true if the page is brand new (the next log record is init_file_page or no records to apply).
Definition: log0recv.cc:2583
static void recv_recover_page(bool jri, buf_block_t *block)
Wrapper for recv_recover_page_func().
Definition: log0recv.h:169
const char * get_mlog_string(mlog_id_t type)
Return string name of the redo log record type.
Definition: log0recv.cc:4204
recv_sys_t * recv_sys
The recovery system.
Definition: log0recv.cc:94
bool recv_needed_recovery
true when recv_init_crash_recovery() has been called.
Definition: log0recv.cc:152
void recv_sys_create()
Creates the recovery system.
Definition: log0recv.cc:393
static bool recv_recovery_is_on()
Returns true if recovery is currently running.
volatile bool recv_recovery_on
true when applying redo log records during crash recovery; false otherwise.
Definition: log0recv.cc:99
bool recv_lsn_checks_on
true if buf_page_is_corrupted() should check if the log sequence number (FIL_PAGE_LSN) is in the futu...
Definition: log0recv.cc:157
ulint recv_n_pool_free_frames
This many frames must be left free in the buffer pool when we scan the log and store the scanned log ...
Definition: log0recv.cc:195
void recv_recover_page_func(bool just_read_in, buf_block_t *block)
Applies the hashed log records to the page, if the page lsn is less than the lsn of a log record.
Definition: log0recv.cc:2616
dberr_t recv_recovery_from_checkpoint_start(log_t &log, lsn_t flush_lsn)
Start recovering from a redo log checkpoint.
Definition: log0recv.cc:3845
std::list< space_id_t > recv_encr_ts_list
A list of tablespaces for which (un)encryption process was not completed before crash.
Definition: log0recv.cc:84
Recovery.
Redo log - the log_sys.
uint64_t lsn_t
Type used for all log sequence number storage and arithmetic.
Definition: log0types.h:62
Mini-transaction buffer global types.
mlog_id_t
Definition: mtr0types.h:62
Definition: buf0block_hint.cc:29
Definition: buf0dblwr.cc:74
static Value err()
Create a Value object that represents an error condition.
Definition: json_binary.cc:909
Cursor end()
A past-the-end Cursor.
Definition: rules_table_service.cc:191
std::map< Key, Value, Compare, ut::allocator< std::pair< const Key, Value > > > map
Specialization of map which uses ut_allocator.
Definition: ut0new.h:2873
The interface to the operating system file io.
uint64_t os_offset_t
File offset in bytes.
Definition: os0file.h:83
required uint64 version
Definition: replication_group_member_actions.proto:40
required string type
Definition: replication_group_member_actions.proto:33
case opt name
Definition: sslopt-case.h:32
The buffer control block structure.
Definition: buf0buf.h:1664
Redo log - single data structure with state of the redo log system.
Definition: log0sys.h:74
The info structure stored at the beginning of a heap block.
Definition: mem0mem.h:299
InnoDB condition variable.
Definition: os0event.cc:62
Hashed page file address struct.
Definition: log0recv.h:305
page_no_t page_no
Page number.
Definition: log0recv.h:315
recv_addr_state state
recovery state of the page
Definition: log0recv.h:309
space_id_t space
Space ID.
Definition: log0recv.h:312
List rec_list
List of log records for this page.
Definition: log0recv.h:318
Block of log record data.
Definition: log0recv.h:249
recv_data_t * next
pointer to the next block or NULL.
Definition: log0recv.h:254
Definition: log0recv.h:404
byte * ptr
Encryption key.
Definition: log0recv.h:412
space_id_t space_id
Tablespace ID.
Definition: log0recv.h:406
byte * iv
Encryption IV.
Definition: log0recv.h:415
lsn_t lsn
LSN of REDO log encryption entry.
Definition: log0recv.h:409
Mini transaction log record.
Definition: log0recv.h:421
space_id_t space_id
Definition: log0recv.h:423
size_t size
Definition: log0recv.h:431
const byte * body
Definition: log0recv.h:429
page_no_t page_no
Definition: log0recv.h:425
mlog_id_t type
Definition: log0recv.h:427
Every space has its own heap and pages that belong to it.
Definition: log0recv.h:383
Pages m_pages
Pages that need to be recovered.
Definition: log0recv.h:395
mem_heap_t * m_heap
Memory heap of log records and file addresses.
Definition: log0recv.h:392
Space(mem_heap_t *heap)
Constructor.
Definition: log0recv.h:386
Space()
Default constructor.
Definition: log0recv.h:389
Recovery system data structure.
Definition: log0recv.h:377
std::vector< Encryption_Key > Encryption_Keys
Definition: log0recv.h:418
Missing_Ids deleted
Tablespace IDs that were explicitly deleted.
Definition: log0recv.h:635
ulint n_addrs
Number of not processed hashed file addresses in the hash table.
Definition: log0recv.h:619
ulint len
Amount of data in buf.
Definition: log0recv.h:560
bool found_corrupt_fs
Set when an inconsistency with the file system contents is detected during log scan or apply.
Definition: log0recv.h:602
ib_mutex_t mutex
Definition: log0recv.h:522
bool is_meb_db
Data directory has been recognized as data directory from MEB.
Definition: log0recv.h:608
lsn_t previous_recovered_lsn
The previous value of recovered_lsn - before we parsed the last mtr.
Definition: log0recv.h:589
ulint bytes_to_ignore_before_checkpoint
Number of data bytes to ignore until we reach checkpoint_lsn.
Definition: log0recv.h:571
os_event_t flush_end
event to signal that the page cleaner has finished the request
Definition: log0recv.h:532
void save_rec(size_t rec_num, space_id_t space_id, page_no_t page_no, mlog_id_t type, const byte *body, size_t len)
Save mlog record information.
Definition: log0recv.h:464
dblwr::recv::DBLWR * dblwr
Doublewrite buffer pages, destroyed after recovery completes.
Definition: log0recv.h:622
std::set< space_id_t > Missing_Ids
Definition: log0recv.h:398
Spaces * spaces
Hash table of pages, indexed by SpaceID.
Definition: log0recv.h:616
bool get_saved_rec(size_t rec_num, space_id_t &space_id, page_no_t &page_no, mlog_id_t &type, byte *&body, size_t &len)
Return saved mlog record information, if there.
Definition: log0recv.h:495
lsn_t recovered_lsn
The log records have been parsed up to this lsn.
Definition: log0recv.h:583
bool apply_batch_on
This is true when a log rec application batch is running.
Definition: log0recv.h:548
std::vector< Mlog_record, ut::allocator< Mlog_record > > Mlog_records
Definition: log0recv.h:434
ulint recovered_offset
Start offset of non-parsed log records in buf.
Definition: log0recv.h:580
std::unordered_map< page_no_t, recv_addr_t *, std::hash< page_no_t >, std::equal_to< page_no_t > > Pages
Definition: log0recv.h:380
std::unordered_map< space_id_t, Space, std::hash< space_id_t >, std::equal_to< space_id_t > > Spaces
Definition: log0recv.h:401
ib_mutex_t writer_mutex
mutex coordinating flushing between recv_writer_thread and the recovery thread.
Definition: log0recv.h:526
Mlog_records saved_recs
Definition: log0recv.h:638
bool is_cloned_db
Data directory has been recognized as cloned data directory.
Definition: log0recv.h:605
os_event_t flush_start
event to activate page cleaner threads
Definition: log0recv.h:529
Missing_Ids missing_ids
Tablespace IDs that were ignored during redo log apply.
Definition: log0recv.h:632
lsn_t checkpoint_lsn
Checkpoint lsn that was used during recovery (read from file).
Definition: log0recv.h:568
uint32_t scanned_epoch_no
The log data has been scanned up to this epoch_no.
Definition: log0recv.h:577
size_t buf_len
Size of the parsing buffer.
Definition: log0recv.h:557
buf_flush_t flush_type
type of the flush request.
Definition: log0recv.h:536
Encryption_Keys * keys
Encryption Key information per tablespace ID.
Definition: log0recv.h:629
bool dblwr_state
Doublewrite buffer state before MEB recovery starts.
Definition: log0recv.h:613
bool found_corrupt_log
Set when finding a corrupt log block or record, or there is a log parsing buffer overflow.
Definition: log0recv.h:598
lsn_t parse_start_lsn
This is the lsn from which we were able to start parsing log records and adding them to the hash tabl...
Definition: log0recv.h:565
lsn_t scanned_lsn
The log data has been scanned up to this lsn.
Definition: log0recv.h:574
byte * buf
Buffer for parsing log records.
Definition: log0recv.h:554
byte * last_block
Possible incomplete last recovered log block.
Definition: log0recv.h:551
bool apply_log_recs
This is true when log rec application to pages is allowed; this flag tells the i/o-handler if it shou...
Definition: log0recv.h:545
MetadataRecover * metadata_recover
We store and merge all table persistent data here during scanning redo logs.
Definition: log0recv.h:626
uint32_t last_block_first_rec_group
Tracks what should be the proper value of first_rec_group field in the header of the block to which r...
Definition: log0recv.h:594
static constexpr size_t MAX_SAVED_MLOG_RECS
While scanning logs for multi-record mini-transaction (mtr), we have two passes.
Definition: log0recv.h:454
Stored log record struct.
Definition: log0recv.h:258
recv_data_t * data
Chain of blocks containing the log record body.
Definition: log0recv.h:268
lsn_t start_lsn
Start lsn of the log segment written by the mtr which generated this log record: NOTE that this is no...
Definition: log0recv.h:273
UT_LIST_NODE_T(recv_t) Node
Definition: log0recv.h:259
ulint len
Log record body length in bytes.
Definition: log0recv.h:265
lsn_t end_lsn
End lsn of the log segment written by the mtr which generated this log record: NOTE that this is not ...
Definition: log0recv.h:278
Node rec_list
List node, list anchored in recv_addr_t.
Definition: log0recv.h:281
mlog_id_t type
Log record type.
Definition: log0recv.h:262
typedef UT_LIST_BASE_NODE_T(rw_lock_t, list) rw_lock_list_t
#define UNIV_NOTHROW
Definition: univ.i:457
unsigned long int ulint
Definition: univ.i:407
Utilities for byte operations.
#define ut_ad(EXPR)
Debug assertion.
Definition: ut0dbg.h:68
#define UT_LIST_NODE_T(t)
Macro used for legacy reasons.
Definition: ut0lst.h:63
Dynamic memory allocation routines and custom allocators specifically crafted to support memory instr...
static uint64_t lsn
Definition: xcom_base.cc:442