MySQL 8.0.30
Source Code Documentation
buf0dblwr.h
Go to the documentation of this file.
1/*****************************************************************************
2
3Copyright (c) 1995, 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/buf0dblwr.h
28 Doublewrite buffer module
29
30 Created 2011/12/19 Inaam Rana
31 *******************************************************/
32
33#ifndef buf0dblwr_h
34#define buf0dblwr_h
35
36#include "buf0types.h"
37#include "fil0fil.h"
38#include "log0recv.h"
39#include "ut0byte.h"
40
41/** Size of the doublewrite block in pages. */
42#define DBLWR_V1_EXTENT_SIZE FSP_EXTENT_SIZE
43
44/** Offset of the doublewrite buffer header on the trx system header page. */
45#define TRX_SYS_DBLWR_V1 (UNIV_PAGE_SIZE - 200)
46
47/** 4-byte ver number which shows if we have created the doublewrite buffer. */
49
50/** Page number of the first page in the first sequence of 64 (=
51FSP_EXTENT_SIZE) consecutive pages in the doublewrite buffer. */
53
54/** Page number of the first page in the second sequence of 64 consecutive
55pages in the doublewrite buffer. */
57
58namespace dblwr {
59
60/** IO buffer in UNIV_PAGE_SIZE units and aligned on UNIV_PAGE_SIZE */
61struct Buffer {
62 /** Constructor
63 @param[in] n_pages Number of pages to create */
64 explicit Buffer(size_t n_pages) noexcept
66
67 /** Constructor
68 @param[in] n_pages Number of pages to create
69 @param[in] phy_size physical page size. */
70 explicit Buffer(size_t n_pages, uint32_t phy_size) noexcept
71 : m_phy_size(phy_size), m_n_bytes(n_pages * phy_size) {
72 ut_a(n_pages > 0);
73 m_ptr = static_cast<byte *>(ut::aligned_zalloc(m_n_bytes, phy_size));
74
75 m_next = m_ptr;
76 }
77
78 /** Destructor */
79 ~Buffer() noexcept {
81 m_ptr = nullptr;
82 }
83
84 /** Add the contents of ptr upto n_bytes to the buffer.
85 @return false if it won't fit. Nothing is copied if it won't fit. */
86 bool append(const void *ptr, size_t n_bytes) noexcept {
88
89 if (m_next + m_phy_size > m_ptr + m_n_bytes) {
90 return false;
91 }
92
93 memcpy(m_next, ptr, n_bytes);
95
96 return true;
97 }
98
99 /** @return the start of the buffer to write from. */
100 byte *begin() noexcept { return m_ptr; }
101
102 /** @return the start of the buffer to write from. */
103 const byte *begin() const noexcept { return m_ptr; }
104
105 /** @return the size of of the buffer to write. */
106 size_t size() const noexcept {
107 ut_a(m_next >= m_ptr);
108 return std::ptrdiff_t(m_next - m_ptr);
109 }
110
111 /** @return the capacity of the buffer in bytes. */
112 size_t capacity() const noexcept { return m_n_bytes; }
113
114 /** @return true if the buffer is empty. */
115 bool empty() const noexcept { return size() == 0; }
116
117 /** Empty the buffer. */
118 void clear() noexcept { m_next = m_ptr; }
119
120 /** Page size on disk (aka physical page size). */
121 uint32_t m_phy_size;
122
123 /** Write buffer used in writing to the doublewrite buffer,
124 aligned to an address divisible by UNIV_PAGE_SIZE (which is
125 required by Windows AIO) */
126 byte *m_ptr{};
127
128 /** Start of next write to the buffer. */
129 byte *m_next{};
130
131 /** Size of the unaligned (raw) buffer. */
132 const size_t m_n_bytes{};
133
134 // Disable copying
135 Buffer(const Buffer &) = delete;
136 Buffer(const Buffer &&) = delete;
137 Buffer &operator=(Buffer &&) = delete;
138 Buffer &operator=(const Buffer &) = delete;
139};
140
141} // namespace dblwr
142
143#ifndef UNIV_HOTBACKUP
144
145// Forward declaration
146class buf_page_t;
147class Double_write;
148
149namespace dblwr {
150
151/** Double write files location. */
152extern std::string dir;
153
154#ifdef UNIV_DEBUG
155/** Crash the server after writing this page to the data file. */
157#endif /* UNIV_DEBUG */
158
159/** Startup the background thread(s) and create the instance.
160@return DB_SUCCESS or error code */
161[[nodiscard]] dberr_t open() noexcept;
162
163/** Enable the doublewrite reduced mode by creating the necessary dblwr files
164and in-memory structures
165@return DB_SUCCESS or error code */
166[[nodiscard]] dberr_t enable_reduced() noexcept;
167
168/** Check and open the reduced doublewrite files if necessary
169@return DB_SUCCESS or error code */
170[[nodiscard]] dberr_t reduced_open() noexcept;
171
172/** Shutdown the background thread and destroy the instance */
173void close() noexcept;
174
175/** Force a write of all pages in the queue.
176@param[in] flush_type FLUSH LIST or LRU_LIST flush request.
177@param[in] buf_pool_index Buffer pool instance for which called. */
178void force_flush(buf_flush_t flush_type, uint32_t buf_pool_index) noexcept;
179
180/** Force a write of all pages in all dblwr segments (reduced or regular)
181This is used only when switching the doublewrite mode dynamically */
182void force_flush_all() noexcept;
183
184/** Writes a page to the doublewrite buffer on disk, syncs it,
185then writes the page to the datafile.
186@param[in] flush_type Flush type
187@param[in] bpage Buffer block to write
188@param[in] sync True if sync IO requested
189@return DB_SUCCESS or error code */
190[[nodiscard]] dberr_t write(buf_flush_t flush_type, buf_page_t *bpage,
191 bool sync) noexcept;
192
193/** Obtain the encrypted frame and store it in bpage->m_io_frame
194@param[in,out] bpage the buffer page containing the unencrypted frame.
195@return the memory block containing the compressed + encrypted frame. */
196[[nodiscard]] file::Block *get_encrypted_frame(buf_page_t *bpage) noexcept;
197
198/** Updates the double write buffer when a write request is completed.
199@param[in] bpage Block that has just been writtent to disk.
200@param[in] flush_type Flush type that triggered the write. */
201void write_complete(buf_page_t *bpage, buf_flush_t flush_type) noexcept;
202
203/** Delete or adjust the dblwr file size if required. */
204void reset_files() noexcept;
205
206namespace v1 {
207/** Read the boundaries of the legacy dblwr buffer extents.
208@return DB_SUCCESS or error code. */
209[[nodiscard]] dberr_t init() noexcept;
210
211/** Create the dblwr data structures in the system tablespace.
212@return DB_SUCCESS or error code. */
213[[nodiscard]] dberr_t create() noexcept;
214
215/** Check if the read is of a page inside the legacy dblwr buffer.
216@param[in] page_no Page number to check.
217@return true if offset inside legacy dblwr buffer. */
218[[nodiscard]] bool is_inside(page_no_t page_no) noexcept;
219
220} // namespace v1
221} // namespace dblwr
222
223#endif /* !UNIV_HOTBACKUP */
224
225namespace dblwr {
226
227/** Number of pages per doublewrite thread/segment */
228extern ulong n_pages;
229
230const uint32_t REDUCED_BATCH_PAGE_SIZE = 8192;
231
232/* 20-byte header.
233Fields : [batch id][checksum][data len][batch type][unused ]
234Field Width : [4 bytes ][4 bytes ][2 bytes ][ 1 byte ][ 9 bytes]
235Field Offsets : [ 0 ][ 4 ][ 8 ][ 10 ][ 11 ] */
236const uint32_t RB_BATCH_ID_SIZE = 4;
237const uint32_t RB_CHECKSUM_SIZE = 4;
238const uint32_t RB_DATA_LEN_SIZE = 2;
239const uint32_t RB_BATCH_TYPE_SIZE = 1;
240const uint32_t RB_UNUSED_BYTES_SIZE = 9;
241
242/* Offsets of the header fields. */
243constexpr const uint32_t RB_OFF_BATCH_ID = 0;
248
249constexpr const uint32_t REDUCED_HEADER_SIZE =
250 RB_BATCH_ID_SIZE /* BATCH_ID */
251 + RB_CHECKSUM_SIZE /* CHECKSUM */
252 + RB_DATA_LEN_SIZE /* DATA_LEN */
253 + RB_BATCH_TYPE_SIZE /* BATCH_TYPE */
254 + 9 /* UNUSED BYTES */;
255
256constexpr const uint32_t REDUCED_ENTRY_SIZE =
257 sizeof(space_id_t) + sizeof(page_no_t) + sizeof(lsn_t);
258
259constexpr const uint32_t REDUCED_DATA_SIZE =
261
262constexpr const uint32_t REDUCED_MAX_ENTRIES =
264
265/** When --innodb-doublewrite=DETECT_ONLY, page contents are not written to the
266dblwr buffer. Only the following Reduced_entry information is stored in the
267dblwr buffer. */
272
274
276 : m_space_id(space_id), m_page_no(page_no), m_lsn(lsn) {}
277
278 byte *write(byte *ptr) {
279 uint16_t offset = 0;
280 mach_write_to_4(ptr + offset, m_space_id);
281 offset += sizeof(m_space_id);
282
283 mach_write_to_4(ptr + offset, m_page_no);
284 offset += sizeof(m_page_no);
285
286 mach_write_to_8(ptr + offset, m_lsn);
287 offset += sizeof(m_lsn);
288
289 return ptr + offset;
290 }
291};
292
293struct Mode {
294 /** The operating mode of doublewrite. The modes ON, TRUEE and
295 DETECT_AND_RECOVER are equal to one another. The modes OFF and FALSEE are
296 equal to one another.
297
298 @note If you change order or add new values, please update
299 innodb_doublewrite_names enum in handler/ha_innodb.cc */
300 enum mode_t {
301 /** Equal to FALSEE. In this mode, dblwr is disabled. */
303
304 /** Equal to TRUEE and DETECT_AND_RECOVER modes. */
306
307 /** In this mode, dblwr is used only to detect torn writes. At code level,
308 this mode is also called as reduced mode. It is called reduced because the
309 number of bytes written to the dblwr file is reduced in this mode. */
311
312 /** This mode is synonymous with ON, TRUEE. */
314
315 /** Equal to OFF mode. Intentionally wrong spelling because of compilation
316 issues on Windows. */
318
319 /** Equal to ON, DETECT_AND_RECOVER mode. Intentionally wrong spelling
320 because of compilation issues on Windows platform. */
321 TRUEE
322 };
323
324 /** Check if doublewrite is enabled.
325 @param[in] mode dblwr ENUM
326 @return true if dblwr is enabled. */
327 static inline bool is_enabled_low(ulong mode);
328
329 /** Check if the doublewrite mode is disabled.
330 @param[in] mode dblwr ENUM
331 @return true if dblwr mode is OFF. */
332 static inline bool is_disabled_low(ulong mode);
333
334 /** Check if the doublewrite mode is detect-only (aka reduced).
335 @param[in] mode dblwr ENUM
336 @return true if dblwr mode is DETECT_ONLY. */
337 static inline bool is_reduced_low(ulong mode);
338
339 /** Check if the dblwr mode provides atomic writes.
340 @return true if mode is ON, TRUEE or DETECT_AND_RECOVER.
341 @return false if mode is OFF, FALSE or DETECT_ONLY. */
342 static inline bool is_atomic(ulong mode);
343
344 /** Convert the dblwr mode into a string representation.
345 @param[in] mode the dblwr mode.
346 @return string representation of the dblwr mode. */
347 static const char *to_string(ulong mode);
348
349 /** Check if the mode transition is from enabled to disabled.
350 @param[in] new_value the new value of dblwr mode.
351 @return true if mode transition is from enabled to disabled. */
352 static inline bool is_enabled_to_disabled(ulong new_value);
353
354 /** Check if the mode transition is from disabled to enabled.
355 @param[in] new_value the new value of dblwr mode.
356 @return true if mode transition is from disabled to enabled. */
357 static inline bool is_disabled_to_enabled(ulong new_value);
358
359 /** Check if the mode transition is equivalent.
360 @param[in] new_value the new value of dblwr mode.
361 @return true if mode transition is equivalent. */
362 static bool is_same(ulong new_value);
363};
364
366 return mode == ON || mode == TRUEE || mode == DETECT_AND_RECOVER;
367}
368
370 return mode == ON || mode == TRUEE || mode == DETECT_AND_RECOVER ||
371 mode == DETECT_ONLY;
372}
373
374bool Mode::is_disabled_low(ulong mode) { return mode == OFF || mode == FALSEE; }
375
376bool Mode::is_reduced_low(ulong mode) { return mode == DETECT_ONLY; }
377
378/** DBLWR mode. */
379extern ulong g_mode;
380
381/** true if DETECT_ONLY (aka reduced) mode is inited */
382extern bool is_reduced_inited;
383
384/** Check if doublewrite is enabled.
385@return true if dblwr mode is ON, DETECT_ONLY, DETECT_AND_RECOVER
386@return false if dblwr mode is OFF. */
387inline bool is_enabled() { return Mode::is_enabled_low(g_mode); }
388
389/** Check if the doublewrite mode is detect-only (aka reduced).
390@return true if dblwr mode is DETECT_ONLY. */
391inline bool is_reduced() { return Mode::is_reduced_low(g_mode); }
392
393/** Check if the doublewrite mode is disabled.
394@return true if dblwr mode is OFF. */
395inline bool is_disabled() { return Mode::is_disabled_low(g_mode); }
396
397bool Mode::is_enabled_to_disabled(ulong new_value) {
398 return is_enabled() && Mode::is_disabled_low(new_value);
399}
400
401bool Mode::is_disabled_to_enabled(ulong new_value) {
402 return is_disabled() && Mode::is_enabled_low(new_value);
403}
404
405/** @return string version of dblwr numeric values
406@param[in] mode dblwr ENUM */
407const char *to_string(ulong mode);
408
409/** Number of files to use for the double write buffer. It must be <= than
410the number of buffer pool instances. */
411extern ulong n_files;
412
413/** Maximum number of pages to write in one batch. */
414extern ulong batch_size;
415
416/** Toggle the doublewrite buffer. */
417void set();
418
419namespace recv {
420
421class Pages;
422
423/** Create the recovery dblwr data structures
424@param[out] pages Pointer to newly created instance */
425void create(Pages *&pages) noexcept;
426
427/** Load the doublewrite buffer pages.
428@param[in,out] pages For storing the doublewrite pages read
429 from the double write buffer
430@return DB_SUCCESS or error code */
431[[nodiscard]] dberr_t load(Pages *pages) noexcept;
432
433/** Load the doublewrite buffer pages.
434@param[in,out] pages For storing the doublewrite pages read
435 from the double write buffer
436@return DB_SUCCESS or error code */
437[[nodiscard]] dberr_t reduced_load(Pages *pages) noexcept;
438
439/** Restore pages from the double write buffer to the tablespace.
440@param[in,out] pages Pages from the doublewrite buffer
441@param[in] space Tablespace pages to restore, if set to nullptr then try and
442 restore all.
443@return DB_SUCCESS on success, error code on failure. */
444dberr_t recover(Pages *pages, fil_space_t *space) noexcept;
445
446/** Find a doublewrite copy of a page.
447@param[in] pages Pages read from the doublewrite buffer
448@param[in] page_id Page number to lookup
449@return page frame
450@retval NULL if no page was found */
451[[nodiscard]] const byte *find(const Pages *pages,
452 const page_id_t &page_id) noexcept;
453
454/** Find the LSN of the given page id in the dblwr.
455@param[in] pages Pages read from the doublewrite buffer
456@param[in] page_id Page number to lookup
457@return 0th element is true if page_id found in double write buffer.
458@return 1st element is valid only if 0th element is true.
459@return 1st element contains the LSN of the page in dblwr. */
460[[nodiscard]] std::tuple<bool, lsn_t> find_entry(
461 const Pages *pages, const page_id_t &page_id) noexcept;
462
463/** Check if some pages from the double write buffer could not be
464restored because of the missing tablespace IDs.
465@param[in] pages Pages to check */
466void check_missing_tablespaces(const Pages *pages) noexcept;
467
468/** Free the recovery dblwr data structures
469@param[out] pages Free the instance */
470void destroy(Pages *&pages) noexcept;
471
472/** Redo recovery configuration. */
473class DBLWR {
474 public:
475 /** Constructor. */
476 explicit DBLWR() noexcept { create(m_pages); }
477
478 /** Destructor */
479 ~DBLWR() noexcept { destroy(m_pages); }
480
481 /** @return true if empty. */
482 bool empty() const noexcept { return (m_pages == nullptr); }
483
484 /** Load the doublewrite buffer pages. Doesn't create the doublewrite
485 @return DB_SUCCESS or error code */
486 [[nodiscard]] dberr_t load() noexcept { return (dblwr::recv::load(m_pages)); }
487
488 /** Load the doublewrite buffer pages. Doesn't create the doublewrite
489 @return DB_SUCCESS or error code */
490 [[nodiscard]] dberr_t reduced_load() noexcept {
492 }
493
494 /** Restore pages from the double write buffer to the tablespace.
495 @param[in] space Tablespace pages to restore,
496 if set to nullptr then try
497 and restore all. */
498 dberr_t recover(fil_space_t *space = nullptr) noexcept {
499 return dblwr::recv::recover(m_pages, space);
500 }
501
502 /** Find a doublewrite copy of a page.
503 @param[in] page_id Page number to lookup
504 @return page frame
505 @retval nullptr if no page was found */
506 [[nodiscard]] const byte *find(const page_id_t &page_id) noexcept {
507 return (dblwr::recv::find(m_pages, page_id));
508 }
509
510 /** Find the LSN of the given page id in the dblwr.
511 @param[in] page_id Page number to lookup
512 @return 0th element is true if page_id found in double write buffer.
513 @return 1st element is valid only if 0th element is true.
514 @return 1st element contains the LSN of the page in dblwr. */
515 [[nodiscard]] std::tuple<bool, lsn_t> find_entry(
516 const page_id_t &page_id) noexcept {
517 return (dblwr::recv::find_entry(m_pages, page_id));
518 }
519
520 /** Check if some pages from the double write buffer
521 could not be restored because of the missing tablespace IDs. */
524 }
525
526#ifndef UNIV_HOTBACKUP
527 /** Note that recovery is complete. Adjust the file sizes if necessary. */
528 void recovered() noexcept { dblwr::reset_files(); }
529#endif /* !UNIV_HOTBACKUP */
530
531 /** Disably copying. */
532 DBLWR(const DBLWR &) = delete;
533 DBLWR(const DBLWR &&) = delete;
534 DBLWR &operator=(DBLWR &&) = delete;
535 DBLWR &operator=(const DBLWR &) = delete;
536
537 private:
538 /** Pages read from the double write file. */
540};
541} // namespace recv
542
543#ifdef UNIV_DEBUG
544/** Check if the dblwr files contain encrypted pages.
545@return true if dblwr file contains any encrypted pages,
546 false if dblwr file contains no encrypted pages. */
547[[nodiscard]] bool has_encrypted_pages() noexcept;
548#endif /* UNIV_DEBUG */
549} // namespace dblwr
550
551#endif /* buf0dblwr_h */
uint32_t space_id_t
Tablespace identifier.
Definition: api0api.h:50
uint32_t page_no_t
Page number.
Definition: api0api.h:48
static ulint buf_pool_index(const buf_pool_t *buf_pool)
Calculates the index of a buffer pool to the buf_pool[] array.
constexpr ulint DBLWR_VER
4-byte ver number which shows if we have created the doublewrite buffer.
Definition: buf0dblwr.h:48
constexpr ulint DBLWR_V1_BLOCK1
Page number of the first page in the first sequence of 64 (= FSP_EXTENT_SIZE) consecutive pages in th...
Definition: buf0dblwr.h:52
constexpr ulint DBLWR_V1_BLOCK2
Page number of the first page in the second sequence of 64 consecutive pages in the doublewrite buffe...
Definition: buf0dblwr.h:56
The database buffer pool global types for the directory.
buf_flush_t
Flags for flush types.
Definition: buf0types.h:67
Doublewrite implementation.
Definition: buf0dblwr.cc:431
Definition: buf0buf.h:1126
Redo recovery configuration.
Definition: buf0dblwr.h:473
const byte * find(const page_id_t &page_id) noexcept
Find a doublewrite copy of a page.
Definition: buf0dblwr.h:506
void recovered() noexcept
Note that recovery is complete.
Definition: buf0dblwr.h:528
dberr_t recover(fil_space_t *space=nullptr) noexcept
Restore pages from the double write buffer to the tablespace.
Definition: buf0dblwr.h:498
DBLWR() noexcept
Constructor.
Definition: buf0dblwr.h:476
DBLWR(const DBLWR &&)=delete
void check_missing_tablespaces() noexcept
Check if some pages from the double write buffer could not be restored because of the missing tablesp...
Definition: buf0dblwr.h:522
Pages * m_pages
Pages read from the double write file.
Definition: buf0dblwr.h:539
DBLWR & operator=(const DBLWR &)=delete
~DBLWR() noexcept
Destructor.
Definition: buf0dblwr.h:479
DBLWR(const DBLWR &)=delete
Disably copying.
DBLWR & operator=(DBLWR &&)=delete
std::tuple< bool, lsn_t > find_entry(const page_id_t &page_id) noexcept
Find the LSN of the given page id in the dblwr.
Definition: buf0dblwr.h:515
bool empty() const noexcept
Definition: buf0dblwr.h:482
dberr_t reduced_load() noexcept
Load the doublewrite buffer pages.
Definition: buf0dblwr.h:490
dberr_t load() noexcept
Load the doublewrite buffer pages.
Definition: buf0dblwr.h:486
Pages recovered from the doublewrite buffer.
Definition: buf0dblwr.cc:248
Page identifier.
Definition: buf0types.h:171
size_t physical() const
Retrieve the physical page size (on-disk).
Definition: page0size.h:120
dberr_t
Definition: db0err.h:38
The low-level file system.
constexpr uint32_t FSEG_HEADER_SIZE
Length of the file system header, in bytes.
Definition: fsp0types.h:93
mysql_service_status_t recv(const char *tag, const unsigned char *data, size_t data_length) noexcept
Definition: gr_message_service_example.cc:38
flush_type
Definition: my_sys.h:291
Recovery.
uint64_t lsn_t
Type used for all log sequence number storage and arithmetics.
Definition: log0types.h:62
static void mach_write_to_8(void *b, uint64_t n)
The following function is used to store data in 8 consecutive bytes.
static void mach_write_to_4(byte *b, ulint n)
The following function is used to store data in 4 consecutive bytes.
const byte * find(const Pages *pages, const page_id_t &page_id) noexcept
Find a doublewrite copy of a page.
Definition: buf0dblwr.cc:3592
dberr_t load(Pages *pages) noexcept
Load the doublewrite buffer pages.
Definition: buf0dblwr.cc:3380
void destroy(Pages *&pages) noexcept
Free the recovery dblwr data structures.
Definition: buf0dblwr.cc:3607
std::tuple< bool, lsn_t > find_entry(const Pages *pages, const page_id_t &page_id) noexcept
Find the LSN of the given page id in the dblwr.
Definition: buf0dblwr.cc:3597
dberr_t recover(Pages *pages, fil_space_t *space) noexcept
Restore pages from the double write buffer to the tablespace.
Definition: buf0dblwr.cc:2626
void check_missing_tablespaces(const Pages *pages) noexcept
Check if some pages from the double write buffer could not be restored because of the missing tablesp...
Definition: buf0dblwr.cc:3614
dberr_t reduced_load(Pages *pages) noexcept
Load the doublewrite buffer pages.
Definition: buf0dblwr.cc:3492
void create(Pages *&pages) noexcept
Create the recovery dblwr data structures.
Definition: buf0dblwr.cc:3602
bool is_inside(page_no_t page_no) noexcept
Check if the read is of a page inside the legacy dblwr buffer.
Definition: buf0dblwr.cc:2915
dberr_t init() noexcept
Read the boundaries of the legacy dblwr buffer extents.
Definition: buf0dblwr.cc:2899
Definition: buf0dblwr.cc:74
file::Block * get_encrypted_frame(buf_page_t *bpage) noexcept
Obtain the encrypted frame and store it in bpage->m_io_frame.
Definition: buf0dblwr.cc:2425
ulong n_files
Number of files to use for the double write buffer.
Definition: buf0dblwr.cc:78
constexpr const uint32_t RB_OFF_UNUSED
Definition: buf0dblwr.h:247
dberr_t reduced_open() noexcept
Check and open the reduced doublewrite files if necessary.
Definition: buf0dblwr.cc:2722
dberr_t open() noexcept
Startup the background thread(s) and create the instance.
Definition: buf0dblwr.cc:2761
constexpr const uint32_t REDUCED_MAX_ENTRIES
Definition: buf0dblwr.h:262
void set()
Toggle the doublewrite buffer.
Definition: buf0dblwr.cc:2891
dberr_t enable_reduced() noexcept
Enable the doublewrite reduced mode by creating the necessary dblwr files and in-memory structures.
Definition: buf0dblwr.cc:2866
void close() noexcept
Shutdown the background thread and destroy the instance.
Definition: buf0dblwr.cc:2889
const uint32_t REDUCED_BATCH_PAGE_SIZE
Definition: buf0dblwr.h:230
void force_flush(buf_flush_t flush_type, uint32_t buf_pool_index) noexcept
Force a write of all pages in the queue.
Definition: buf0dblwr.cc:3150
ulong n_pages
Number of pages per doublewrite thread/segment.
Definition: buf0dblwr.cc:82
constexpr const uint32_t REDUCED_HEADER_SIZE
Definition: buf0dblwr.h:249
ulong g_mode
DBLWR mode.
Definition: buf0dblwr.cc:84
page_id_t Force_crash
Crash the server after writing this page to the data file.
Definition: buf0dblwr.cc:197
constexpr const uint32_t RB_OFF_CHECKSUM
Definition: buf0dblwr.h:244
const uint32_t RB_BATCH_TYPE_SIZE
Definition: buf0dblwr.h:239
void force_flush_all() noexcept
Force a write of all pages in all dblwr segments (reduced or regular) This is used only when switchin...
Definition: buf0dblwr.cc:3155
std::string dir
Double write files location.
Definition: buf0dblwr.cc:76
constexpr const uint32_t RB_OFF_BATCH_TYPE
Definition: buf0dblwr.h:246
ulong batch_size
Maximum number of pages to write in one batch.
Definition: buf0dblwr.cc:80
const uint32_t RB_BATCH_ID_SIZE
Definition: buf0dblwr.h:236
bool has_encrypted_pages() noexcept
Check if the dblwr files contain encrypted pages.
Definition: buf0dblwr.cc:3630
constexpr const uint32_t REDUCED_DATA_SIZE
Definition: buf0dblwr.h:259
bool is_enabled()
Check if doublewrite is enabled.
Definition: buf0dblwr.h:387
const char * to_string(ulong mode)
constexpr const uint32_t REDUCED_ENTRY_SIZE
Definition: buf0dblwr.h:256
void reset_files() noexcept
Delete or adjust the dblwr file size if required.
Definition: buf0dblwr.cc:2897
const uint32_t RB_DATA_LEN_SIZE
Definition: buf0dblwr.h:238
dberr_t write(buf_flush_t flush_type, buf_page_t *bpage, bool sync) noexcept
Writes a page to the doublewrite buffer on disk, syncs it, then writes the page to the datafile.
Definition: buf0dblwr.cc:2490
bool is_disabled()
Check if the doublewrite mode is disabled.
Definition: buf0dblwr.h:395
bool is_reduced()
Check if the doublewrite mode is detect-only (aka reduced).
Definition: buf0dblwr.h:391
constexpr const uint32_t RB_OFF_DATA_LEN
Definition: buf0dblwr.h:245
bool is_reduced_inited
true if DETECT_ONLY (aka reduced) mode is inited
Definition: buf0dblwr.cc:86
const uint32_t RB_CHECKSUM_SIZE
Definition: buf0dblwr.h:237
void write_complete(buf_page_t *bpage, buf_flush_t flush_type) noexcept
Updates the double write buffer when a write request is completed.
Definition: buf0dblwr.cc:2622
constexpr const uint32_t RB_OFF_BATCH_ID
Definition: buf0dblwr.h:243
const uint32_t RB_UNUSED_BYTES_SIZE
Definition: buf0dblwr.h:240
Definition: os0file.h:85
mode
Definition: file_handle.h:59
void * aligned_zalloc(std::size_t size, std::size_t alignment) noexcept
Dynamically allocates zero-initialized storage of given size and at the address aligned to the reques...
Definition: ut0new.h:1547
void aligned_free(void *ptr) noexcept
Releases storage which has been dynamically allocated through any of the aligned_alloc_*() or aligned...
Definition: ut0new.h:1561
page_size_t univ_page_size
IO buffer in UNIV_PAGE_SIZE units and aligned on UNIV_PAGE_SIZE.
Definition: buf0dblwr.h:61
Buffer & operator=(const Buffer &)=delete
Buffer(size_t n_pages) noexcept
Constructor.
Definition: buf0dblwr.h:64
size_t capacity() const noexcept
Definition: buf0dblwr.h:112
Buffer(const Buffer &&)=delete
uint32_t m_phy_size
Page size on disk (aka physical page size).
Definition: buf0dblwr.h:121
Buffer(const Buffer &)=delete
~Buffer() noexcept
Destructor.
Definition: buf0dblwr.h:79
bool append(const void *ptr, size_t n_bytes) noexcept
Add the contents of ptr upto n_bytes to the buffer.
Definition: buf0dblwr.h:86
const byte * begin() const noexcept
Definition: buf0dblwr.h:103
byte * m_next
Start of next write to the buffer.
Definition: buf0dblwr.h:129
byte * m_ptr
Write buffer used in writing to the doublewrite buffer, aligned to an address divisible by UNIV_PAGE_...
Definition: buf0dblwr.h:126
void clear() noexcept
Empty the buffer.
Definition: buf0dblwr.h:118
bool empty() const noexcept
Definition: buf0dblwr.h:115
size_t size() const noexcept
Definition: buf0dblwr.h:106
byte * begin() noexcept
Definition: buf0dblwr.h:100
const size_t m_n_bytes
Size of the unaligned (raw) buffer.
Definition: buf0dblwr.h:132
Buffer & operator=(Buffer &&)=delete
Buffer(size_t n_pages, uint32_t phy_size) noexcept
Constructor.
Definition: buf0dblwr.h:70
Definition: buf0dblwr.h:293
static bool is_disabled_low(ulong mode)
Check if the doublewrite mode is disabled.
Definition: buf0dblwr.h:374
static bool is_same(ulong new_value)
Check if the mode transition is equivalent.
Definition: buf0dblwr.cc:107
static bool is_enabled_to_disabled(ulong new_value)
Check if the mode transition is from enabled to disabled.
Definition: buf0dblwr.h:397
static bool is_atomic(ulong mode)
Check if the dblwr mode provides atomic writes.
Definition: buf0dblwr.h:365
static const char * to_string(ulong mode)
Convert the dblwr mode into a string representation.
Definition: buf0dblwr.cc:88
static bool is_disabled_to_enabled(ulong new_value)
Check if the mode transition is from disabled to enabled.
Definition: buf0dblwr.h:401
static bool is_enabled_low(ulong mode)
Check if doublewrite is enabled.
Definition: buf0dblwr.h:369
static bool is_reduced_low(ulong mode)
Check if the doublewrite mode is detect-only (aka reduced).
Definition: buf0dblwr.h:376
mode_t
The operating mode of doublewrite.
Definition: buf0dblwr.h:300
@ DETECT_ONLY
In this mode, dblwr is used only to detect torn writes.
Definition: buf0dblwr.h:310
@ FALSEE
Equal to OFF mode.
Definition: buf0dblwr.h:317
@ TRUEE
Equal to ON, DETECT_AND_RECOVER mode.
Definition: buf0dblwr.h:321
@ DETECT_AND_RECOVER
This mode is synonymous with ON, TRUEE.
Definition: buf0dblwr.h:313
@ ON
Equal to TRUEE and DETECT_AND_RECOVER modes.
Definition: buf0dblwr.h:305
@ OFF
Equal to FALSEE.
Definition: buf0dblwr.h:302
When –innodb-doublewrite=DETECT_ONLY, page contents are not written to the dblwr buffer.
Definition: buf0dblwr.h:268
lsn_t m_lsn
Definition: buf0dblwr.h:271
page_no_t m_page_no
Definition: buf0dblwr.h:270
space_id_t m_space_id
Definition: buf0dblwr.h:269
Reduced_entry(space_id_t space_id, page_no_t page_no, lsn_t lsn)
Definition: buf0dblwr.h:275
Reduced_entry(buf_page_t *bpage)
Definition: buf0dblwr.cc:3660
byte * write(byte *ptr)
Definition: buf0dblwr.h:278
Tablespace or log data space.
Definition: fil0fil.h:230
unsigned long int ulint
Definition: univ.i:407
Utilities for byte operations.
#define ut_a(EXPR)
Abort execution if EXPR does not evaluate to nonzero.
Definition: ut0dbg.h:56
static uint64_t lsn
Definition: xcom_base.cc:442