MySQL 8.4.3
Source Code Documentation
fsp0fsp.h
Go to the documentation of this file.
1/*****************************************************************************
2
3Copyright (c) 1995, 2024, 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 designed to work with certain software (including
10but not limited to OpenSSL) that is licensed under separate terms,
11as designated in a particular file or component or in included license
12documentation. The authors of MySQL hereby grant you an additional
13permission to link the program and your derivative works with the
14separately licensed software that they have either included with
15the program or referenced in the documentation.
16
17This program is distributed in the hope that it will be useful, but WITHOUT
18ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
19FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0,
20for more details.
21
22You should have received a copy of the GNU General Public License along with
23this program; if not, write to the Free Software Foundation, Inc.,
2451 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
25
26*****************************************************************************/
27
28/** @file include/fsp0fsp.h
29 File space management
30
31 Created 12/18/1995 Heikki Tuuri
32 *******************************************************/
33
34#ifndef fsp0fsp_h
35#define fsp0fsp_h
36
37#include "univ.i"
38
39#include "fsp0space.h"
40#include "fut0lst.h"
41#include "mtr0mtr.h"
44#include "page0types.h"
45#include "rem0types.h"
46#include "ut0byte.h"
47
48#include <random>
49#include "fsp0types.h"
50
51#ifdef UNIV_HOTBACKUP
52#include "buf0buf.h"
53#endif /* UNIV_HOTBACKUP */
54
55class DDL_Record;
56extern std::vector<DDL_Record *> ts_encrypt_ddl_records;
59
60/** @defgroup Tablespace Header Constants (moved from fsp0fsp.c)
61@{ */
62#ifdef UNIV_DEBUG
63extern std::vector<space_id_t> flag_mismatch_spaces;
64#endif
65
66/** Offset of the space header within a file page */
67constexpr uint32_t FSP_HEADER_OFFSET = FIL_PAGE_DATA;
68
69/** The number of bytes required to store SDI root page number(4)
70and SDI version(4) at Page 0 */
71constexpr uint32_t FSP_SDI_HEADER_LEN = 8;
72
73/* The data structures in files are defined just as byte strings in C */
74typedef byte fsp_header_t;
75typedef byte xdes_t;
76
77#ifdef UNIV_DEBUG
78/** Check if the state of extent descriptor is valid.
79@param[in] state the extent descriptor state
80@return true if state is valid, false otherwise */
81bool xdes_state_is_valid(ulint state);
82#endif /* UNIV_DEBUG */
83
84#ifdef UNIV_DEBUG
85struct xdes_mem_t {
86 xdes_mem_t(const xdes_t *xdes) : m_xdes(xdes) {}
87
88 const char *state_name() const;
89
90 bool is_valid() const;
91 const xdes_t *m_xdes;
92
93 std::ostream &print(std::ostream &out) const;
94};
95
96inline std::ostream &operator<<(std::ostream &out, const xdes_mem_t &obj) {
97 return (obj.print(out));
98}
99
100/** In-memory representation of the fsp_header_t file structure. */
102 fsp_header_mem_t(const fsp_header_t *header, mtr_t *mtr);
103
116
117 std::ostream &print(std::ostream &out) const;
118};
119
120inline std::ostream &operator<<(std::ostream &out,
121 const fsp_header_mem_t &obj) {
122 return (obj.print(out));
123}
124#endif /* UNIV_DEBUG */
125
126/* SPACE HEADER
127 ============
128
129File space header data structure: this data structure is contained in the
130first page of a space. The space for this header is reserved in every extent
131descriptor page, but used only in the first. */
132
133/*-------------------------------------*/
134/** space id */
135constexpr uint32_t FSP_SPACE_ID = 0;
136/** this field contained a value up to which we know that the modifications in
137 the database have been flushed to the file space; not used now */
138constexpr uint32_t FSP_NOT_USED = 4;
139/** Current size of the space in pages */
140constexpr uint32_t FSP_SIZE = 8;
141/** Minimum page number for which the free list has not been initialized: the
142 pages >= this limit are, bydefinition, free; note that in a single-table
143 tablespace where size < 64 pages, this number is 64, i.e.,we have initialized
144 the space about the first extent, but have not physically allocated those
145 pages to thefile */
146constexpr uint32_t FSP_FREE_LIMIT = 12;
147/** fsp_space_t.flags, similar to dict_table_t::flags */
148constexpr uint32_t FSP_SPACE_FLAGS = 16;
149/** number of used pages in the FSP_FREE_FRAG list */
150constexpr uint32_t FSP_FRAG_N_USED = 20;
151/** list of free extents */
152constexpr uint32_t FSP_FREE = 24;
153/** list of partially free extents not belonging to any segment */
154constexpr uint32_t FSP_FREE_FRAG = 24 + FLST_BASE_NODE_SIZE;
155
156/** list of full extents not belonging to any segment */
157constexpr uint32_t FSP_FULL_FRAG = 24 + 2 * FLST_BASE_NODE_SIZE;
158
159/** 8 bytes which give the first unused segment id */
160constexpr uint32_t FSP_SEG_ID = 24 + 3 * FLST_BASE_NODE_SIZE;
161
162/** list of pages containing segment headers, where all the segment inode slots
163 are reserved */
164constexpr uint32_t FSP_SEG_INODES_FULL = 32 + 3 * FLST_BASE_NODE_SIZE;
165
166/** list of pages containing segment headers, where not all the segment header
167 slots are reserved */
168constexpr uint32_t FSP_SEG_INODES_FREE = 32 + 4 * FLST_BASE_NODE_SIZE;
169
170/*-------------------------------------*/
171/* File space header size */
172constexpr uint32_t FSP_HEADER_SIZE = 32 + 5 * FLST_BASE_NODE_SIZE;
173
174/** This many free extents are added to the free list from above FSP_FREE_LIMIT
175 at a time */
176constexpr uint32_t FSP_FREE_ADD = 4;
177
178/** @} */
179
180/* Maximum allowed value of AUTOEXTEND_SIZE attribute */
181constexpr uint64_t FSP_MAX_AUTOEXTEND_SIZE = 4 * 1024 * 1024 * 1024ULL;
182
183/** @defgroup File Segment Inode Constants (moved from fsp0fsp.c)
184@{ */
185
186/* FILE SEGMENT INODE
187 ==================
188
189Segment inode which is created for each segment in a tablespace. NOTE: in
190purge we assume that a segment having only one currently used page can be
191freed in a few steps, so that the freeing cannot fill the file buffer with
192bufferfixed file pages. */
193
194typedef byte fseg_inode_t;
195
197/* the list node for linking
198segment inode pages */
199
201/*-------------------------------------*/
202/* 8 bytes of segment id: if this is 0, it means that the header is unused */
203constexpr uint32_t FSEG_ID = 0;
204/** number of used segment pages in the FSEG_NOT_FULL list */
205constexpr uint32_t FSEG_NOT_FULL_N_USED = 8;
206/** list of free extents of this segment */
207constexpr uint32_t FSEG_FREE = 12;
208/** list of partially free extents */
209constexpr uint32_t FSEG_NOT_FULL = 12 + FLST_BASE_NODE_SIZE;
210/** list of full extents */
211constexpr uint32_t FSEG_FULL = 12 + 2 * FLST_BASE_NODE_SIZE;
212/** magic number used in debugging */
213constexpr uint32_t FSEG_MAGIC_N = 12 + 3 * FLST_BASE_NODE_SIZE;
214/** array of individual pages belonging to this segment in fsp fragment extent
215 lists */
216constexpr uint32_t FSEG_FRAG_ARR = 16 + 3 * FLST_BASE_NODE_SIZE;
217/* number of slots in the array for the fragment pages */
218#define FSEG_FRAG_ARR_N_SLOTS (FSP_EXTENT_SIZE / 2)
219/** a fragment page slot contains its page number within space, FIL_NULL means
220 that the slot is not in use */
221constexpr uint32_t FSEG_FRAG_SLOT_SIZE = 4;
222
223/*-------------------------------------*/
224#define FSEG_INODE_SIZE \
225 (16 + 3 * FLST_BASE_NODE_SIZE + FSEG_FRAG_ARR_N_SLOTS * FSEG_FRAG_SLOT_SIZE)
226
227static inline uint32_t FSP_SEG_INODES_PER_PAGE(page_size_t page_size) {
228 return (page_size.physical() - FSEG_ARR_OFFSET - 10) / FSEG_INODE_SIZE;
229}
230/* Number of segment inodes which fit on a
231single page */
232
233constexpr uint32_t FSEG_MAGIC_N_VALUE = 97937874;
234
235/** The segment_reserve_factor is the ratio x/y expressed in percentage,
236where x is the number of free pages in the segment, and y is the total number
237of pages in the segment. The number of used pages in the segment is given by
238(y-x). The number of free pages in the segment (x) will be maintained such
239that the actual segment_reserve_factor will be >= the requested
240segment_reserve_factor, which is contained in this variable. */
241extern double fseg_reserve_pct;
242
243/* Various constants related to segment reserve factor */
244constexpr double FSEG_RESERVE_PCT_DFLT = 12.50;
245constexpr double FSEG_RESERVE_PCT_MIN = 0.03;
246constexpr double FSEG_RESERVE_PCT_MAX = 40.00;
247
248#define FSEG_FRAG_LIMIT FSEG_FRAG_ARR_N_SLOTS
249
250/** If the reserved size of a segment is at least this many extents, we allow
251extents to be put to the free list of the extent: at most
252FSEG_FREE_LIST_MAX_LEN many */
253constexpr uint32_t FSEG_FREE_LIST_LIMIT = 40;
254constexpr uint32_t FSEG_FREE_LIST_MAX_LEN = 4;
255/** @} */
256
257/** @defgroup Extent Descriptor Constants (moved from fsp0fsp.c)
258@{ */
259
260/* EXTENT DESCRIPTOR
261 =================
262
263File extent descriptor data structure: contains bits to tell which pages in
264the extent are free and which contain old tuple version to clean. */
265
266/*-------------------------------------*/
267/** The identifier of the segment to which this extent belongs */
268constexpr uint32_t XDES_ID = 0;
269/** The list node data structure for the descriptors */
270constexpr uint32_t XDES_FLST_NODE = 8;
271/** contains state information of the extent */
272constexpr uint32_t XDES_STATE = FLST_NODE_SIZE + 8;
273/** Descriptor bitmap of the pages in the extent */
274constexpr uint32_t XDES_BITMAP = FLST_NODE_SIZE + 12;
275
276/*-------------------------------------*/
277
278/** How many bits are there per page */
279constexpr uint32_t XDES_BITS_PER_PAGE = 2;
280/** Index of the bit which tells if the page is free */
281constexpr uint32_t XDES_FREE_BIT = 0;
282/** NOTE: currently not used! Index of the bit which tells if there are old
283versions of tuples on the page */
284constexpr uint32_t XDES_CLEAN_BIT = 1;
285
286/** States of a descriptor */
288
289 /** extent descriptor is not initialized */
291
292 /** extent is in free list of space */
294
295 /** extent is in free fragment list of space */
297
298 /** extent is in full fragment list of space */
300
301 /** extent belongs to a segment */
303
304 /** fragment extent leased to segment */
307
308/** File extent data structure size in bytes. */
309#define XDES_SIZE \
310 (XDES_BITMAP + UT_BITS_IN_BYTES(FSP_EXTENT_SIZE * XDES_BITS_PER_PAGE))
311
312/** File extent data structure size in bytes for MAX page size. */
313#define XDES_SIZE_MAX \
314 (XDES_BITMAP + UT_BITS_IN_BYTES(FSP_EXTENT_SIZE_MAX * XDES_BITS_PER_PAGE))
315
316/** File extent data structure size in bytes for MIN page size. */
317#define XDES_SIZE_MIN \
318 (XDES_BITMAP + UT_BITS_IN_BYTES(FSP_EXTENT_SIZE_MIN * XDES_BITS_PER_PAGE))
319
320/** Offset of the descriptor array on a descriptor page */
322
323/** The number of reserved pages in a fragment extent. */
325
326/** @} */
327
328/** Initializes the file space system. */
329void fsp_init(void);
330
331/** Gets the size of the system tablespace from the tablespace header. If
332 we do not have an auto-extending data file, this should be equal to
333 the size of the data files. If there is an auto-extending data file,
334 this can be smaller.
335 @return size in pages */
337
338/** Calculate the number of pages to extend a datafile.
339We extend single-table and general tablespaces first one extent at a time,
340but 4 at a time for bigger tablespaces. It is not enough to extend always
341by one extent, because we need to add at least one extent to FSP_FREE.
342A single extent descriptor page will track many extents. And the extent
343that uses its extent descriptor page is put onto the FSP_FREE_FRAG list.
344Extents that do not use their extent descriptor page are added to FSP_FREE.
345The physical page size is used to determine how many extents are tracked
346on one extent descriptor page. See xdes_calc_descriptor_page().
347@param[in] page_size page_size of the datafile
348@param[in] size current number of pages in the datafile
349@return number of pages to extend the file. */
352
353/** Calculate the number of physical pages in an extent for this file.
354@param[in] page_size page_size of the datafile
355@return number of pages in an extent for this file. */
357 const page_size_t &page_size) {
358 return (static_cast<page_no_t>(FSP_EXTENT_SIZE * UNIV_PAGE_SIZE /
359 page_size.physical()));
360}
361
362/** Reads the space id from the first page of a tablespace.
363 @return space id, ULINT UNDEFINED if error */
365 const page_t *page); /*!< in: first page of a tablespace */
366
367/** Read the server version number from the DD tablespace header.
368@param[out] version server version from tablespace header
369@return false if success. */
371
372/** Read a tablespace header field.
373@param[in] page first page of a tablespace
374@param[in] field the header field
375@return the contents of the header field */
376inline uint32_t fsp_header_get_field(const page_t *page, uint32_t field) {
377 return (mach_read_from_4(FSP_HEADER_OFFSET + field + page));
378}
379
380/** Update a tablespace header field.
381@param[in] page first page of a tablespace
382@param[in] field the header field
383@param[in] val field value */
384inline void fsp_header_set_field(page_t *page, uint32_t field, uint32_t val) {
385 mach_write_to_4(page + FSP_HEADER_OFFSET + field, val);
386}
387
388/** Read the flags from the tablespace header page.
389@param[in] page first page of a tablespace
390@return the contents of FSP_SPACE_FLAGS */
391inline uint32_t fsp_header_get_flags(const page_t *page) {
393}
394
395/** Reads the page size from the first page of a tablespace.
396@param[in] page first page of a tablespace
397@return page size */
399
400/** Reads the encryption key from the first page of a tablespace.
401@param[in] fsp_flags tablespace flags
402@param[in,out] e_key tablespace key, iv
403@param[in] page first page of a tablespace
404@return true if success */
405bool fsp_header_get_encryption_key(uint32_t fsp_flags, Encryption_key &e_key,
406 page_t *page);
407
408/** Get encryption operation type in progress from the first
409page of a tablespace.
410@param[in] page first page of a tablespace
411@param[in] page_size tablespace page size
412@return operation type
413*/
415 const page_t *page, page_size_t page_size);
416
417/** Check if the tablespace size information is valid.
418@param[in] space_id the tablespace identifier
419@return true if valid, false if invalid. */
421
422/** Writes the space id and flags to a tablespace header. The flags contain
423 row type, physical/compressed page size, and logical/uncompressed page
424 size of the tablespace. */
426 page_t *page, /*!< in/out: first page in the space */
427 space_id_t space_id, /*!< in: space id */
428 uint32_t flags); /*!< in: tablespace flags
429 (FSP_SPACE_FLAGS): 0, or
430 table->flags if newer than COMPACT */
431
432/** Get the offset of encryption information in page 0.
433@param[in] page_size page size.
434@return offset on success, otherwise 0. */
436
437/** Write the encryption info into the space header.
438@param[in] space_id Tablespace id
439@param[in] space_flags Tablespace flags
440@param[in] encrypt_info Buffer for re-encrypt key
441@param[in] update_fsp_flags If it need to update the space flags
442@param[in] rotate_encryption If it is called during key rotation
443@param[in,out] mtr Mini-transaction
444@return true if success. */
445bool fsp_header_write_encryption(space_id_t space_id, uint32_t space_flags,
446 byte *encrypt_info, bool update_fsp_flags,
447 bool rotate_encryption, mtr_t *mtr);
448
449/** Write the encryption progress info into the space header.
450@param[in] space_id Tablespace id
451@param[in] space_flags Tablespace flags
452@param[in] progress_info Max pages (un)encrypted
453@param[in] operation_type Type of operation
454@param[in] update_operation_type Is operation to be updated
455@param[in,out] mtr Mini-transaction
456@return true if success. */
458 space_id_t space_id, ulint space_flags, ulint progress_info,
459 byte operation_type, bool update_operation_type, mtr_t *mtr);
460
461/** Rotate the encryption info in the space header.
462@param[in] space Tablespace
463@param[in] encrypt_info Buffer for re-encrypt key.
464@param[in,out] mtr Mini-transaction
465@return true if success. */
466bool fsp_header_rotate_encryption(fil_space_t *space, byte *encrypt_info,
467 mtr_t *mtr);
468
469/** Initializes the space header of a new created space and creates also the
470insert buffer tree root if space == 0.
471@param[in] space_id Space id
472@param[in] size Current size in blocks
473@param[in,out] mtr Mini-transaction
474@return true on success, otherwise false. */
475bool fsp_header_init(space_id_t space_id, page_no_t size, mtr_t *mtr);
476
477/** Increases the space size field of a space.
478@param[in] space_id Space id
479@param[in] size_inc Size increment in pages
480@param[in,out] mtr Mini-transaction */
481void fsp_header_inc_size(space_id_t space_id, page_no_t size_inc, mtr_t *mtr);
482
483/** Creates a new segment.
484 @return the block where the segment header is placed, x-latched, NULL
485 if could not create segment because of lack of space */
487 space_id_t space, /*!< in: space id */
488 page_no_t page, /*!< in: page where the segment header is
489 placed: if this is != 0, the page must belong
490 to another segment, if this is 0, a new page
491 will be allocated and it will belong to the
492 created segment */
493 ulint byte_offset, /*!< in: byte offset of the created
494 segment header on the page */
495 mtr_t *mtr); /*!< in/out: mini-transaction */
496
497/** Creates a new segment.
498@param[in] space_id Space id
499@param[in,out] page Page where the segment header is placed: if this is != 0,
500the page must belong to another segment, if this is 0, a new page will be
501allocated and it will belong to the created segment
502@param[in] byte_offset Byte offset of the created segment header on the page
503@param[in,out] has_done_reservation True if the caller has already done the
504reservation for the pages with fsp_reserve_free_extents (at least 2 extents: one
505for the inode and the other for the segment) then there is no need to do the
506check for this individual operation
507@param[in,out] mtr Mini-transaction
508@return the block where the segment header is placed, x-latched, NULL
509if could not create segment because of lack of space */
511 ulint byte_offset, bool has_done_reservation,
512 mtr_t *mtr);
513
514/** Calculates the number of pages reserved by a segment, and how many pages are
515 currently used.
516 @return number of reserved pages */
518 fseg_header_t *header, /*!< in: segment header */
519 ulint *used, /*!< out: number of pages used (<= reserved) */
520 mtr_t *mtr); /*!< in/out: mini-transaction */
521
522/** Allocates a single free page from a segment. This function implements
523 the intelligent allocation strategy which tries to minimize file space
524 fragmentation.
525@param[in,out] seg_header Segment header
526@param[in] hint Hint of which page would be desirable
527@param[in,out] direction If the new page is needed because of an index page
528split, and records are inserted there in order, into which direction they go
529alphabetically: fsp_down, fsp_up, fsp_no_dir
530@param[in] has_done_reservation True if the caller has already done the
531reservation for the page with fsp_reserve_free_extents, then there is no need to
532do the check for this individual page
533@param[in,out] mtr Mini-transaction
534@param[in,out] init_mtr mtr or another mini-transaction in which
535the page should be initialized. if init_mtr!=mtr, but the page is already
536latched in mtr, do not initialize the page.
537@retval NULL if no page could be allocated
538@retval block, rw_lock_x_lock_count(&block->lock) == 1 if allocation succeeded
539(init_mtr == mtr, or the page was not previously freed in mtr),
540returned block is not allocated nor initialized otherwise */
542 fseg_header_t *seg_header, page_no_t hint, byte direction,
543 bool has_done_reservation, mtr_t *mtr, mtr_t *init_mtr);
544
545/** Allocates a single free page from a segment. This function implements
546 the intelligent allocation strategy which tries to minimize
547 file space fragmentation.
548 @param[in,out] seg_header Segment header
549 @param[in] hint Hint of which page would be desirable
550 @param[in] direction If the new page is needed because
551 of an index page split, and records are
552 inserted there in order, into which
553 direction they go alphabetically: FSP_DOWN,
554 FSP_UP, FSP_NO_DIR
555 @param[in,out] mtr Mini-transaction
556 @return X-latched block, or NULL if no page could be allocated */
558 page_no_t hint, byte direction,
559 mtr_t *mtr) {
560 return fseg_alloc_free_page_general(seg_header, hint, direction, false, mtr,
561 mtr);
562}
563
564/** Reserves free pages from a tablespace. All mini-transactions which may
565use several pages from the tablespace should call this function beforehand
566and reserve enough free extents so that they certainly will be able
567to do their operation, like a B-tree page split, fully. Reservations
568must be released with function fil_space_release_free_extents!
569
570The alloc_type below has the following meaning: FSP_NORMAL means an
571operation which will probably result in more space usage, like an
572insert in a B-tree; FSP_UNDO means allocation to undo logs: if we are
573deleting rows, then this allocation will in the long run result in
574less space usage (after a purge); FSP_CLEANING means allocation done
575in a physical record delete (like in a purge) or other cleaning operation
576which will result in less space usage in the long run. We prefer the latter
577two types of allocation: when space is scarce, FSP_NORMAL allocations
578will not succeed, but the latter two allocations will succeed, if possible.
579The purpose is to avoid dead end where the database is full but the
580user cannot free any space because these freeing operations temporarily
581reserve some space.
582
583Single-table tablespaces whose size is < FSP_EXTENT_SIZE pages are a special
584case. In this function we would liberally reserve several extents for
585every page split or merge in a B-tree. But we do not want to waste disk space
586if the table only occupies < FSP_EXTENT_SIZE pages. That is why we apply
587different rules in that special case, just ensuring that there are n_pages
588free pages available.
589
590@param[out] n_reserved Number of extents actually reserved; if we
591 return true and the tablespace size is <
592 FSP_EXTENT_SIZE pages, then this can be 0,
593 otherwise it is n_ext
594@param[in] space_id Tablespace identifier
595@param[in] n_ext Number of extents to reserve
596@param[in] alloc_type Page reservation type (FSP_BLOB, etc)
597@param[in,out] mtr Mini-transaction
598@param[in] n_pages For small tablespaces (tablespace size is
599 less than FSP_EXTENT_SIZE), number of free
600 pages to reserve.
601@return true if we were able to make the reservation */
602bool fsp_reserve_free_extents(ulint *n_reserved, space_id_t space_id,
603 ulint n_ext, fsp_reserve_t alloc_type, mtr_t *mtr,
604 page_no_t n_pages = 2);
605
606/** Calculate how many KiB of new data we will be able to insert to the
607tablespace without running out of space.
608@param[in] space_id tablespace ID
609@return available space in KiB
610@retval UINTMAX_MAX if unknown */
612
613/** Calculate how many KiB of new data we will be able to insert to the
614tablespace without running out of space. Start with a space object that has
615been acquired by the caller who holds it for the calculation,
616@param[in] space tablespace object from fil_space_acquire()
617@return available space in KiB */
619
620/** Frees a single page of a segment.
621@param[in] seg_header Segment header
622@param[in] space_id Space id
623@param[in] page Page offset
624@param[in] ahi Whether we may need to drop the adaptive hash index
625@param[in,out] mtr Mini-transaction */
626void fseg_free_page(fseg_header_t *seg_header, space_id_t space_id,
627 page_no_t page, bool ahi, mtr_t *mtr);
628
629/** Checks if a single page of a segment is free.
630 @return true if free */
631[[nodiscard]] bool fseg_page_is_free(
632 fseg_header_t *seg_header, /*!< in: segment header */
633 space_id_t space_id, /*!< in: space id */
634 page_no_t page); /*!< in: page offset */
635/** Frees part of a segment. This function can be used to free a segment
636 by repeatedly calling this function in different mini-transactions.
637 Doing the freeing in a single mini-transaction might result in
638 too big a mini-transaction.
639 @return true if freeing completed */
640[[nodiscard]] bool fseg_free_step(
641 fseg_header_t *header, /*!< in, own: segment header; NOTE: if the header
642 resides on the first page of the frag list
643 of the segment, this pointer becomes obsolete
644 after the last freeing step */
645 bool ahi, /*!< in: whether we may need to drop
646 the adaptive hash index */
647 mtr_t *mtr); /*!< in/out: mini-transaction */
648/** Frees part of a segment. Differs from fseg_free_step because this function
649 leaves the header page unfreed.
650 @return true if freeing completed, except the header page */
651[[nodiscard]] bool fseg_free_step_not_header(
652 fseg_header_t *header, /*!< in: segment header which must reside on
653 the first fragment page of the segment */
654 bool ahi, /*!< in: whether we may need to drop
655 the adaptive hash index */
656 mtr_t *mtr); /*!< in/out: mini-transaction */
657
658/** Checks if a page address is an extent descriptor page address.
659@param[in] page_id page id
660@param[in] page_size page size
661@return true if a descriptor page */
662static inline bool fsp_descr_page(const page_id_t &page_id,
663 const page_size_t &page_size);
664
665/** Parses a redo log record of a file page init.
666@param[in] ptr Buffer.
667@param[in] end_ptr Buffer end.
668@param[in] block Block or nullptr.
669@return end of log record or nullptr */
670const byte *fsp_parse_init_file_page(const byte *ptr, const byte *end_ptr,
671 buf_block_t *block);
672
673#ifdef UNIV_BTR_PRINT
674/** Writes info of a segment. */
675void fseg_print(fseg_header_t *header, /*!< in: segment header */
676 mtr_t *mtr); /*!< in/out: mini-transaction */
677#endif /* UNIV_BTR_PRINT */
678
679/** Check whether a space id is an undo tablespace ID
680Undo tablespaces have space_id's starting 1 less than the redo logs.
681They are numbered down from this. Since rseg_id=0 always refers to the
682system tablespace, undo_space_num values start at 1. The current limit
683is 127. The translation from an undo_space_num is:
684 undo space_id = log_first_space_id - undo_space_num
685@param[in] space_id space id to check
686@return true if it is undo tablespace else false. */
688
689static inline bool fsp_is_system_tablespace(space_id_t space_id) {
690 return (space_id == TRX_SYS_SPACE);
691}
692
693/** Check if the space_id is for a system-tablespace (shared + temp).
694@param[in] space_id tablespace ID
695@return true if id is a system tablespace, false if not. */
696static inline bool fsp_is_system_or_temp_tablespace(space_id_t space_id) {
697 return (fsp_is_system_tablespace(space_id) ||
698 fsp_is_system_temporary(space_id));
699}
700
701/** Determine if the space ID is an IBD tablespace, either file_per_table
702or a general shared tablespace, where user tables exist.
703@param[in] space_id tablespace ID
704@return true if it is a user tablespace ID */
705static inline bool fsp_is_ibd_tablespace(space_id_t space_id) {
706 return (space_id != TRX_SYS_SPACE && !fsp_is_undo_tablespace(space_id) &&
707 !fsp_is_system_temporary(space_id));
708}
709
710/** Check if tablespace is file-per-table.
711@param[in] space_id tablespace ID
712@param[in] fsp_flags tablespace flags
713@return true if tablespace is file-per-table. */
714static inline bool fsp_is_file_per_table(space_id_t space_id,
715 uint32_t fsp_flags) {
716 return (!fsp_is_shared_tablespace(fsp_flags) &&
717 fsp_is_ibd_tablespace(space_id));
718}
719
720/** Check if tablespace is dd tablespace.
721@param[in] space_id tablespace ID
722@return true if tablespace is dd tablespace. */
723bool fsp_is_dd_tablespace(space_id_t space_id);
724
725/** Determine if the tablespace is compressed from tablespace flags.
726@param[in] flags Tablespace flags
727@return true if compressed, false if not compressed */
728static inline bool fsp_flags_is_compressed(uint32_t flags);
729
730/** Determine if two tablespaces are equivalent or compatible.
731@param[in] flags1 First tablespace flags
732@param[in] flags2 Second tablespace flags
733@return true the flags are compatible, false if not */
734static inline bool fsp_flags_are_equal(uint32_t flags1, uint32_t flags2);
735
736/** Initialize an FSP flags integer.
737@param[in] page_size page sizes in bytes and compression flag.
738@param[in] atomic_blobs Used by Dynamic and Compressed.
739@param[in] has_data_dir This tablespace is in a remote location.
740@param[in] is_shared This tablespace can be shared by many tables.
741@param[in] is_temporary This tablespace is temporary.
742@param[in] is_encrypted This tablespace is encrypted.
743@return tablespace flags after initialization */
744static inline uint32_t fsp_flags_init(const page_size_t &page_size,
745 bool atomic_blobs, bool has_data_dir,
746 bool is_shared, bool is_temporary,
747 bool is_encrypted = false);
748
749/** Convert a 32 bit integer tablespace flags to the 32 bit table flags.
750This can only be done for a tablespace that was built as a file-per-table
751tablespace. Note that the fsp_flags cannot show the difference between a
752Compact and Redundant table, so an extra Compact boolean must be supplied.
753 Low order bit
754 | REDUNDANT | COMPACT | COMPRESSED | DYNAMIC
755fil_space_t::flags | 0 | 0 | 1 | 1
756dict_table_t::flags | 0 | 1 | 1 | 1
757@param[in] fsp_flags fil_space_t::flags
758@param[in] compact true if not Redundant row format
759@return tablespace flags (fil_space_t::flags) */
760uint32_t fsp_flags_to_dict_tf(uint32_t fsp_flags, bool compact);
761
762/** Calculates the descriptor index within a descriptor page.
763@param[in] page_size page size
764@param[in] offset page offset
765@return descriptor index */
766static inline ulint xdes_calc_descriptor_index(const page_size_t &page_size,
767 ulint offset);
768
769/** Mark all the pages of the extent as used.
770@param[in] descr extent descriptor
771@param[in] mtr mini transaction context. */
772void xdes_mark_all_used(xdes_t *descr, mtr_t *mtr);
773
774/** Mark all the pages of the extent from given page_no as free.
775@param[in] descr extent descriptor
776@param[in] mtr mini transaction context.
777@param[in] from all pages from this page_no is marked as free. */
778void xdes_mark_pages_free(xdes_t *descr, mtr_t *mtr, const page_no_t from);
779
780/** Gets a descriptor bit of a page.
781@param[in] descr descriptor
782@param[in] bit XDES_FREE_BIT or XDES_CLEAN_BIT
783@param[in] offset page offset within extent: 0 ... FSP_EXTENT_SIZE - 1
784@return true if free */
785static inline bool xdes_get_bit(const xdes_t *descr, ulint bit,
786 page_no_t offset);
787
788/** Calculates the page where the descriptor of a page resides.
789@param[in] page_size page size
790@param[in] offset page offset
791@return descriptor page offset */
792static inline page_no_t xdes_calc_descriptor_page(const page_size_t &page_size,
793 page_no_t offset);
794
795/** Gets a pointer to the space header and acquires a
796SX lock on the page.
797@param[in] id Space id
798@param[in] page_size Page size
799@param[in,out] mtr Mini-transaction
800@param[out] block Block
801@return pointer to the space header, page x-locked */
803 const page_size_t &page_size,
804 mtr_t *mtr, buf_block_t **block);
805
806/** Gets a pointer to the space header and acquires a
807SX lock on the page.
808@param[in] id Space id
809@param[in] page_size Page size
810@param[in,out] mtr Mini-transaction
811@return pointer to the space header, page x-locked */
813 mtr_t *mtr);
814
815/** Retrieve tablespace dictionary index root page number stored in the
816page 0
817@param[in] space Tablespace id
818@param[in] page_size Page size
819@param[in,out] mtr Mini-transaction
820@return root page num of the tablespace dictionary index copy */
822 const page_size_t &page_size, mtr_t *mtr);
823
824/** Write SDI Index root page num to page 0 of tablespace.
825@param[in,out] page Page 0 frame
826@param[in] page_size Size of page
827@param[in] root_page_num Root page number of SDI
828@param[in,out] mtr Mini-transaction */
829void fsp_sdi_write_root_to_page(page_t *page, const page_size_t &page_size,
830 page_no_t root_page_num, mtr_t *mtr);
831
832#include "fsp0fsp.ic"
833
834/** Reads the server version from the first page of a tablespace.
835@param[in] page first page of a tablespace
836@return space server version */
838
839/** Reads the server space version from the first page of a tablespace.
840@param[in] page first page of a tablespace
841@return space server version */
843
844/** Get the state of an xdes.
845@param[in] descr extent descriptor
846@param[in,out] mtr Mini-transaction.
847@return state */
848inline xdes_state_t xdes_get_state(const xdes_t *descr, mtr_t *mtr) {
849 ut_ad(descr && mtr);
851
852 const ulint state = mach_read_from_4(descr + XDES_STATE);
853
855 return (static_cast<xdes_state_t>(state));
856}
857
858#ifdef UNIV_DEBUG
859/** Print the extent descriptor page in user-friendly format.
860@param[in] out The output file stream
861@param[in] xdes The extent descriptor page
862@param[in] page_no The page number of xdes page
863@param[in] mtr Mini-transaction.
864@return None. */
865std::ostream &xdes_page_print(std::ostream &out, const page_t *xdes,
866 page_no_t page_no, mtr_t *mtr);
867
868inline bool xdes_mem_t::is_valid() const {
869 const ulint state = mach_read_from_4(m_xdes + XDES_STATE);
870 return (xdes_state_is_valid(state));
871}
872
873inline const char *xdes_mem_t::state_name() const {
875
877
878 xdes_state_t state = static_cast<xdes_state_t>(val);
879
880 switch (state) {
881 case XDES_NOT_INITED:
882 return ("XDES_NOT_INITED");
883 case XDES_FREE:
884 return ("XDES_FREE");
885 case XDES_FREE_FRAG:
886 return ("XDES_FREE_FRAG");
887 case XDES_FULL_FRAG:
888 return ("XDES_FULL_FRAG");
889 case XDES_FSEG:
890 return ("XDES_FSEG");
891 case XDES_FSEG_FRAG:
892 return ("XDES_FSEG_FRAG");
893 }
894 return ("UNKNOWN");
895}
896
897#endif /* UNIV_DEBUG */
898
899/** Update the tablespace size information and generate redo log for it.
900@param[in] header Tablespace header.
901@param[in] size New tablespace size in pages.
902@param[in] mtr Mini-transaction context. */
904 mtr_t *mtr) {
906
907 DBUG_LOG("ib_log", "old_size=" << mach_read_from_4(header + FSP_SIZE)
908 << ", new_size=" << size);
909
910 mlog_write_ulint(header + FSP_SIZE, size, MLOG_4BYTES, mtr);
911}
912
913/** Check if a specified page is inode page or not. This is used for
914index root pages of hard-coded DD tables, we can safely assume that the passed
915in page number is in the range of pages which are only either index root page
916or inode page
917@param[in] page Page number to check
918@return true if it's inode page, otherwise false */
919inline bool fsp_is_inode_page(page_no_t page);
920
921/** Get the offset of SDI root page number in page 0.
922@param[in] page_size Page size.
923@return offset on success, else 0 */
924inline ulint fsp_header_get_sdi_offset(const page_size_t &page_size);
925
926/** Get the offset of encryption progress information in page 0.
927@param[in] page_size page size.
928@return offset on success, otherwise 0. */
930 const page_size_t &page_size);
931
932/** Determine if the tablespace has SDI.
933@param[in] space_id Tablespace id
934@return DB_SUCCESS if SDI is present else DB_ERROR
935or DB_TABLESPACE_NOT_FOUND */
937
938/** Encrypt/Unencrypt a tablespace.
939@param[in] thd current thread
940@param[in] space_id Tablespace id
941@param[in] to_encrypt true if to encrypt, false if to decrypt
942@param[in,out] dd_space_in dd tablespace object
943@return 0 for success, otherwise error code */
945 bool to_encrypt, void *dd_space_in);
946
947/** Initiate roll-forward of alter encrypt in background thread */
949
950/** A wrapper class to operate on a file segment inode pointer (fseg_inode_t*)
951 */
953 public:
954 /** Constructor
955 @param[in] space_id Table space identifier
956 @param[in] page_size Size of each page in the tablespace.
957 @param[in] inode File segment inode pointer
958 @param[in] mtr Mini-transaction context. */
959 File_segment_inode(space_id_t space_id, const page_size_t &page_size,
960 fseg_inode_t *inode, mtr_t *mtr)
961 : m_space_id(space_id),
962 m_page_size(page_size),
963 m_fseg_inode(inode),
964 m_mtr(mtr) IF_DEBUG(, m_random_engine(m_rd()), m_dist(1, 100)) {}
965
966 /** Update the value of FSEG_NOT_FULL_N_USED.
967 @param[in] n_used the new value of FSEG_NOT_FULL_N_USED. */
968 void write_not_full_n_used(uint32_t n_used);
969
970 /** Get the current value of FSEG_NOT_FULL_N_USED.
971 @return the current value of FSEG_NOT_FULL_N_USED. */
972 uint32_t read_not_full_n_used() const;
973
974 /** Get the segment identifier value.
975 @return the segment identifier value. */
976 uint64_t get_seg_id() const {
978 }
979
980 /** Print the current object into the given output stream.
981 @return the output stream. */
982 std::ostream &print(std::ostream &out) const;
983
984 private:
985 /** Unique tablespace identifier */
987
988 /** The page size used in this tablespace. */
990
991 /** file segment inode pointer that is being wrapped by this object. */
993
994 /** The mini-transaction operation context. */
996
997#ifdef UNIV_DEBUG
998 public:
999 /** Verify the stored FSEG_NOT_FULL_N_USED value.
1000 @return true if correct value, false if incorrect. */
1002
1003 private:
1004 /** Calculate the value of FSEG_NOT_FULL_N_USED by traversing
1005 the FSEG_NOT_FULL list.
1006 @return the calculated value of FSEG_NOT_FULL_N_USED. */
1008
1009 std::random_device m_rd;
1010 std::default_random_engine m_random_engine;
1011 std::uniform_int_distribution<int> m_dist;
1012
1013 /** To reduce the cost of verification of FSEG_NOT_FULL_N_USED, do it
1014 only when this function returns true.
1015 @return true for 10% of the time. */
1016 bool do_verify() { return (m_dist(m_random_engine) > 90); }
1017#endif /* UNIV_DEBUG */
1018};
1019
1020/** The global output stream operator is overloaded to work with an object
1021 of type File_segment_inode.
1022@param[in] out the output stream.
1023@param[in] obj an object of type File_segment_inode.
1024@return the output stream. */
1025inline std::ostream &operator<<(std::ostream &out,
1026 const File_segment_inode &obj) {
1027 return (obj.print(out));
1028}
1029
1030/** Returns the file segment inode, page x-latched.
1031@param[in] header Segment header
1032@param[in] space Space id
1033@param[in] page_size Page size
1034@param[in,out] mtr Mini-transaction
1035@param[out] block Inode block
1036@return segment inode, page x-latched */
1038 const page_size_t &page_size, mtr_t *mtr,
1039 buf_block_t **block = nullptr);
1040
1042 Page_alloc_info(space_id_t space_id, const page_size_t &page_size,
1043 fseg_header_t *fseg_hdr)
1044 : m_space_id(space_id), m_page_size(page_size), m_fseg_header(fseg_hdr) {}
1045
1046 /** Tablespace ID. */
1048
1049 /** Page size. */
1051
1052 /** File segment header. */
1054};
1055
1056using Page_range_t = std::pair<page_no_t, page_no_t>;
1057
1058/** Allocate pages in bulk. */
1060 Page_range_t &page_range);
1061
1063
1064/** Allocate a page number.
1065@param[in] space tablespace object
1066@param[in] page_size page size in the given tablespace.
1067@param[in] seg_inode file segment inode where page number is to be allocated.
1068@param[in] hint hint of which page would be desirable.
1069@param[in] direction If the new page is needed because of an index page split,
1070 and records are inserted there in order, into which direction
1071 they go alphabetically: FSP_DOWN, FSP_UP, FSP_NO_DIR
1072@param[in] mtr mini-transaction context.
1073@param[in,out] has_done_reservation true if caller has done reservation.
1074@return the allocated page number. */
1075page_no_t fseg_alloc_page_no(fil_space_t *space, const page_size_t &page_size,
1076 fseg_inode_t *seg_inode, page_no_t hint,
1077 byte direction,
1078 mtr_t *mtr IF_DEBUG(, bool has_done_reservation));
1079
1080/** Extend space by default extension size.
1081@param[in] space_id space ID
1082@param[in] make_old add the header to LRU tail to flush at the earliest.
1083@param[out] space_size size after extending the space
1084@return true iff successful. */
1085bool fsp_extend_by_default_size(space_id_t space_id, bool make_old,
1086 size_t &space_size);
1087
1088#endif
uint32_t space_id_t
Tablespace identifier.
Definition: api0api.h:48
uint32_t page_no_t
Page number.
Definition: api0api.h:46
std::pair< page_no_t, page_no_t > Page_range_t
Definition: btr0btr.h:131
The database buffer pool high-level routines.
DDL log record.
Definition: log0ddl.h:78
Progress
Encryption progress type.
Definition: os0enc.h:80
A wrapper class to operate on a file segment inode pointer (fseg_inode_t*)
Definition: fsp0fsp.h:952
const page_size_t & m_page_size
The page size used in this tablespace.
Definition: fsp0fsp.h:989
space_id_t m_space_id
Unique tablespace identifier.
Definition: fsp0fsp.h:986
page_no_t calculate_not_full_n_used()
Calculate the value of FSEG_NOT_FULL_N_USED by traversing the FSEG_NOT_FULL list.
Definition: fsp0fsp.cc:4998
mtr_t * m_mtr
The mini-transaction operation context.
Definition: fsp0fsp.h:995
fseg_inode_t * m_fseg_inode
file segment inode pointer that is being wrapped by this object.
Definition: fsp0fsp.h:992
std::random_device m_rd
Definition: fsp0fsp.h:1009
std::default_random_engine m_random_engine
Definition: fsp0fsp.h:1010
std::ostream & print(std::ostream &out) const
Print the current object into the given output stream.
Definition: fsp0fsp.cc:5019
bool verify_not_full_n_used()
Verify the stored FSEG_NOT_FULL_N_USED value.
Definition: fsp0fsp.cc:4988
void write_not_full_n_used(uint32_t n_used)
Update the value of FSEG_NOT_FULL_N_USED.
Definition: fsp0fsp.cc:4957
uint64_t get_seg_id() const
Get the segment identifier value.
Definition: fsp0fsp.h:976
bool do_verify()
To reduce the cost of verification of FSEG_NOT_FULL_N_USED, do it only when this function returns tru...
Definition: fsp0fsp.h:1016
std::uniform_int_distribution< int > m_dist
Definition: fsp0fsp.h:1011
uint32_t read_not_full_n_used() const
Get the current value of FSEG_NOT_FULL_N_USED.
Definition: fsp0fsp.cc:5013
File_segment_inode(space_id_t space_id, const page_size_t &page_size, fseg_inode_t *inode, mtr_t *mtr)
Constructor.
Definition: fsp0fsp.h:959
For each client connection we create a separate thread with THD serving as a thread/connection descri...
Definition: sql_lexer_thd.h:36
Page identifier.
Definition: buf0types.h:207
Page size descriptor.
Definition: page0size.h:50
size_t physical() const
Retrieve the physical page size (on-disk).
Definition: page0size.h:121
int page
Definition: ctype-mb.cc:1234
dberr_t
Definition: db0err.h:39
#define is_shared(S, V)
Definition: dbug.cc:204
constexpr uint32_t FIL_PAGE_DATA
start of the data on the page
Definition: fil0types.h:111
bool fsp_is_system_temporary(space_id_t space_id)
Check if tablespace is system temporary.
Definition: fsp0fsp.cc:305
xdes_state_t xdes_get_state(const xdes_t *descr, mtr_t *mtr)
Get the state of an xdes.
Definition: fsp0fsp.h:848
static bool fsp_flags_are_equal(uint32_t flags1, uint32_t flags2)
Determine if two tablespaces are equivalent or compatible.
std::ostream & xdes_page_print(std::ostream &out, const page_t *xdes, page_no_t page_no, mtr_t *mtr)
Print the extent descriptor page in user-friendly format.
Definition: fsp0fsp.cc:4023
const byte * fsp_parse_init_file_page(const byte *ptr, const byte *end_ptr, buf_block_t *block)
Parses a redo log record of a file page init.
Definition: fsp0fsp.cc:780
static page_no_t fsp_get_extent_size_in_pages(const page_size_t &page_size)
Calculate the number of physical pages in an extent for this file.
Definition: fsp0fsp.h:356
dberr_t fsp_alter_encrypt_tablespace(THD *thd, space_id_t space_id, bool to_encrypt, void *dd_space_in)
Encrypt/Unencrypt a tablespace.
Definition: fsp0fsp.cc:4683
static buf_block_t * fseg_alloc_free_page(fseg_header_t *seg_header, page_no_t hint, byte direction, mtr_t *mtr)
Allocates a single free page from a segment.
Definition: fsp0fsp.h:557
void fsp_sdi_write_root_to_page(page_t *page, const page_size_t &page_size, page_no_t root_page_num, mtr_t *mtr)
Write SDI Index root page num to page 0 of tablespace.
Definition: fsp0fsp.cc:3945
static bool fsp_is_file_per_table(space_id_t space_id, uint32_t fsp_flags)
Check if tablespace is file-per-table.
Definition: fsp0fsp.h:714
dberr_t fseg_alloc_pages_of_extent(const Page_alloc_info &info, mtr_t *mtr, Page_range_t &page_range)
Allocate pages in bulk.
Definition: fsp0fsp.cc:5026
void fsp_header_set_field(page_t *page, uint32_t field, uint32_t val)
Update a tablespace header field.
Definition: fsp0fsp.h:384
bool fsp_extend_by_default_size(space_id_t space_id, bool make_old, size_t &space_size)
Extend space by default extension size.
Definition: fsp0fsp.cc:3262
bool fsp_reserve_free_extents(ulint *n_reserved, space_id_t space_id, ulint n_ext, fsp_reserve_t alloc_type, mtr_t *mtr, page_no_t n_pages=2)
Reserves free pages from a tablespace.
Definition: fsp0fsp.cc:3130
ulint fsp_header_get_encryption_progress_offset(const page_size_t &page_size)
Get the offset of encryption progress information in page 0.
Definition: fsp0fsp.ic:396
uint32_t fsp_flags_to_dict_tf(uint32_t fsp_flags, bool compact)
Convert a 32 bit integer tablespace flags to the 32 bit table flags.
Definition: fsp0fsp.cc:237
static ulint xdes_calc_descriptor_index(const page_size_t &page_size, ulint offset)
Calculates the descriptor index within a descriptor page.
static bool fsp_is_system_or_temp_tablespace(space_id_t space_id)
Check if the space_id is for a system-tablespace (shared + temp).
Definition: fsp0fsp.h:696
bool fsp_check_tablespace_size(space_id_t space_id)
Check if the tablespace size information is valid.
Definition: fsp0fsp.cc:4066
buf_block_t * fseg_alloc_free_page_general(fseg_header_t *seg_header, page_no_t hint, byte direction, bool has_done_reservation, mtr_t *mtr, mtr_t *init_mtr)
Allocates a single free page from a segment.
Definition: fsp0fsp.cc:3005
bool fsp_header_dict_get_server_version(uint *version)
Read the server version number from the DD tablespace header.
Definition: fsp0fsp.cc:989
bool fsp_header_write_encryption_progress(space_id_t space_id, ulint space_flags, ulint progress_info, byte operation_type, bool update_operation_type, mtr_t *mtr)
Write the encryption progress info into the space header.
bool fseg_free_step_not_header(fseg_header_t *header, bool ahi, mtr_t *mtr)
Frees part of a segment.
Definition: fsp0fsp.cc:3746
void fsp_init_file_page_low(buf_block_t *block)
Inits a file page whose prior contents should be ignored.
Definition: fsp0fsp.cc:694
fsp_header_t * fsp_get_space_header_block(space_id_t id, const page_size_t &page_size, mtr_t *mtr, buf_block_t **block)
Gets a pointer to the space header and acquires a SX lock on the page.
Definition: fsp0fsp.cc:196
uint32_t fsp_header_get_space_version(const page_t *page)
Reads the server space version from the first page of a tablespace.
buf_block_t * fseg_create(space_id_t space, page_no_t page, ulint byte_offset, mtr_t *mtr)
Creates a new segment.
Definition: fsp0fsp.cc:2427
fseg_inode_t * fseg_inode_get(const fseg_header_t *header, space_id_t space, const page_size_t &page_size, mtr_t *mtr, buf_block_t **block=nullptr)
Returns the file segment inode, page x-latched.
Definition: fsp0fsp.cc:2176
void xdes_mark_all_used(xdes_t *descr, mtr_t *mtr)
Mark all the pages of the extent as used.
Definition: fsp0fsp.cc:420
bool fseg_page_is_free(fseg_header_t *seg_header, space_id_t space_id, page_no_t page)
Checks if a single page of a segment is free.
Definition: fsp0fsp.cc:3554
constexpr uint64_t FSP_MAX_AUTOEXTEND_SIZE
Definition: fsp0fsp.h:181
page_no_t fsp_get_pages_to_extend_ibd(const page_size_t &page_size, page_no_t size)
Calculate the number of pages to extend a datafile.
Definition: fsp0fsp.cc:1407
bool fsp_is_inode_page(page_no_t page)
Check if a specified page is inode page or not.
Definition: fsp0fsp.ic:281
uint32_t fsp_header_get_flags(const page_t *page)
Read the flags from the tablespace header page.
Definition: fsp0fsp.h:391
bool fsp_header_init(space_id_t space_id, page_no_t size, mtr_t *mtr)
Initializes the space header of a new created space and creates also the insert buffer tree root if s...
Definition: fsp0fsp.cc:1014
dberr_t fsp_has_sdi(space_id_t space_id)
Determine if the tablespace has SDI.
Definition: fsp0fsp.cc:4096
uint32_t fsp_header_get_field(const page_t *page, uint32_t field)
Read a tablespace header field.
Definition: fsp0fsp.h:376
static bool fsp_descr_page(const page_id_t &page_id, const page_size_t &page_size)
Checks if a page address is an extent descriptor page address.
static bool fsp_flags_is_compressed(uint32_t flags)
Determine if the tablespace is compressed from tablespace flags.
void fsp_init(void)
Initializes the file space system.
Definition: fsp0fsp.cc:791
ulint fsp_header_get_sdi_offset(const page_size_t &page_size)
Get the offset of SDI root page number in page 0.
Definition: fsp0fsp.ic:384
mysql_cond_t resume_encryption_cond
Definition: ha_innodb.cc:298
static uint32_t fsp_flags_init(const page_size_t &page_size, bool atomic_blobs, bool has_data_dir, bool is_shared, bool is_temporary, bool is_encrypted=false)
Initialize an FSP flags integer.
Encryption::Progress fsp_header_encryption_op_type_in_progress(const page_t *page, page_size_t page_size)
Get encryption operation type in progress from the first page of a tablespace.
Definition: fsp0fsp.cc:881
static bool fsp_is_ibd_tablespace(space_id_t space_id)
Determine if the space ID is an IBD tablespace, either file_per_table or a general shared tablespace,...
Definition: fsp0fsp.h:705
uint32_t fsp_header_get_server_version(const page_t *page)
Reads the server version from the first page of a tablespace.
static page_no_t xdes_calc_descriptor_page(const page_size_t &page_size, page_no_t offset)
Calculates the page where the descriptor of a page resides.
void fsp_header_size_update(fsp_header_t *header, ulint size, mtr_t *mtr)
Update the tablespace size information and generate redo log for it.
Definition: fsp0fsp.h:903
void fseg_free_page(fseg_header_t *seg_header, space_id_t space_id, page_no_t page, bool ahi, mtr_t *mtr)
Frees a single page of a segment.
Definition: fsp0fsp.cc:3531
std::vector< DDL_Record * > ts_encrypt_ddl_records
DDL records for tablespace (un)encryption.
Definition: fsp0fsp.cc:82
void xdes_mark_pages_free(xdes_t *descr, mtr_t *mtr, const page_no_t from)
Mark all the pages of the extent from given page_no as free.
Definition: fsp0fsp.cc:429
bool fsp_header_write_encryption(space_id_t space_id, uint32_t space_flags, byte *encrypt_info, bool update_fsp_flags, bool rotate_encryption, mtr_t *mtr)
Write the encryption info into the space header.
Definition: fsp0fsp.cc:912
bool fsp_is_undo_tablespace(space_id_t space_id)
Check whether a space id is an undo tablespace ID Undo tablespaces have space_id's starting 1 less th...
Definition: fsp0fsp.cc:271
bool fseg_free_step(fseg_header_t *header, bool ahi, mtr_t *mtr)
Frees part of a segment.
Definition: fsp0fsp.cc:3661
page_no_t fsp_header_get_tablespace_size(void)
Gets the size of the system tablespace from the tablespace header.
Definition: fsp0fsp.cc:1204
ulint fseg_n_reserved_pages(fseg_header_t *header, ulint *used, mtr_t *mtr)
Calculates the number of pages reserved by a segment, and how many pages are currently used.
Definition: fsp0fsp.cc:2493
space_id_t fsp_header_get_space_id(const page_t *page)
Reads the space id from the first page of a tablespace.
Definition: fsp0fsp.cc:1124
bool fsp_header_rotate_encryption(fil_space_t *space, byte *encrypt_info, mtr_t *mtr)
Rotate the encryption info in the space header.
Definition: fsp0fsp.cc:968
fsp_header_t * fsp_get_space_header(space_id_t id, const page_size_t &page_size, mtr_t *mtr)
Gets a pointer to the space header and acquires a SX lock on the page.
Definition: fsp0fsp.cc:218
page_no_t fsp_sdi_get_root_page_num(space_id_t space, const page_size_t &page_size, mtr_t *mtr)
Retrieve tablespace dictionary index root page number stored in the page 0.
Definition: fsp0fsp.cc:3913
void fsp_header_inc_size(space_id_t space_id, page_no_t size_inc, mtr_t *mtr)
Increases the space size field of a space.
Definition: fsp0fsp.cc:1177
static bool xdes_get_bit(const xdes_t *descr, ulint bit, page_no_t offset)
Gets a descriptor bit of a page.
void fsp_init_resume_alter_encrypt_tablespace()
Initiate roll-forward of alter encrypt in background thread.
Definition: fsp0fsp.cc:4949
page_size_t fsp_header_get_page_size(const page_t *page)
Reads the page size from the first page of a tablespace.
Definition: fsp0fsp.cc:1148
static bool fsp_is_system_tablespace(space_id_t space_id)
Definition: fsp0fsp.h:689
buf_block_t * fseg_create_general(space_id_t space_id, page_no_t page, ulint byte_offset, bool has_done_reservation, mtr_t *mtr)
Creates a new segment.
Definition: fsp0fsp.cc:2287
mysql_mutex_t resume_encryption_cond_m
Definition: ha_innodb.cc:299
void fsp_header_init_fields(page_t *page, space_id_t space_id, uint32_t flags)
Writes the space id and flags to a tablespace header.
Definition: fsp0fsp.cc:808
bool fsp_header_get_encryption_key(uint32_t fsp_flags, Encryption_key &e_key, page_t *page)
Reads the encryption key from the first page of a tablespace.
Definition: fsp0fsp.cc:1157
page_no_t fseg_alloc_page_no(fil_space_t *space, const page_size_t &page_size, fseg_inode_t *seg_inode, page_no_t hint, byte direction, mtr_t *mtr, bool has_done_reservation)
Allocate a page number.
Definition: fsp0fsp.cc:2743
uintmax_t fsp_get_available_space_in_free_extents(space_id_t space_id)
Calculate how many KiB of new data we will be able to insert to the tablespace without running out of...
Definition: fsp0fsp.cc:3291
ulint fsp_header_get_encryption_offset(const page_size_t &page_size)
Get the offset of encryption information in page 0.
Definition: fsp0fsp.cc:820
bool fsp_is_dd_tablespace(space_id_t space_id)
Check if tablespace is dd tablespace.
Definition: fsp0fsp.cc:259
File space management.
General shared tablespace implementation.
#define FSP_EXTENT_SIZE
File space extent size in pages page size | file space extent size -------—+--------------------— 4 K...
Definition: fsp0types.h:64
constexpr uint32_t FSEG_PAGE_DATA
On a page of any file segment, data may be put starting from this offset.
Definition: fsp0types.h:79
fsp_reserve_t
Flags for fsp_reserve_free_extents.
Definition: fsp0types.h:136
byte fseg_header_t
Data type for file segment header.
Definition: fsp0types.h:85
File-based list utilities.
constexpr ulint FLST_BASE_NODE_SIZE
Definition: fut0lst.h:50
constexpr ulint FLST_NODE_SIZE
Definition: fut0lst.h:53
constexpr uint32_t XDES_FLST_NODE
The list node data structure for the descriptors.
Definition: fsp0fsp.h:270
constexpr uint32_t XDES_ID
The identifier of the segment to which this extent belongs.
Definition: fsp0fsp.h:268
constexpr uint32_t XDES_STATE
contains state information of the extent
Definition: fsp0fsp.h:272
constexpr uint32_t XDES_FREE_BIT
Index of the bit which tells if the page is free.
Definition: fsp0fsp.h:281
constexpr uint32_t XDES_BITMAP
Descriptor bitmap of the pages in the extent.
Definition: fsp0fsp.h:274
constexpr uint32_t XDES_ARR_OFFSET
Offset of the descriptor array on a descriptor page.
Definition: fsp0fsp.h:321
const ulint XDES_FRAG_N_USED
The number of reserved pages in a fragment extent.
Definition: fsp0fsp.h:324
xdes_state_t
States of a descriptor.
Definition: fsp0fsp.h:287
constexpr uint32_t XDES_BITS_PER_PAGE
How many bits are there per page.
Definition: fsp0fsp.h:279
constexpr uint32_t XDES_CLEAN_BIT
NOTE: currently not used! Index of the bit which tells if there are old versions of tuples on the pag...
Definition: fsp0fsp.h:284
@ XDES_NOT_INITED
extent descriptor is not initialized
Definition: fsp0fsp.h:290
@ XDES_FULL_FRAG
extent is in full fragment list of space
Definition: fsp0fsp.h:299
@ XDES_FSEG
extent belongs to a segment
Definition: fsp0fsp.h:302
@ XDES_FSEG_FRAG
fragment extent leased to segment
Definition: fsp0fsp.h:305
@ XDES_FREE
extent is in free list of space
Definition: fsp0fsp.h:293
@ XDES_FREE_FRAG
extent is in free fragment list of space
Definition: fsp0fsp.h:296
#define FSEG_INODE_SIZE
Definition: fsp0fsp.h:224
constexpr uint32_t FSEG_FREE_LIST_MAX_LEN
Definition: fsp0fsp.h:254
constexpr uint32_t FSEG_NOT_FULL
list of partially free extents
Definition: fsp0fsp.h:209
constexpr uint32_t FSEG_INODE_PAGE_NODE
Definition: fsp0fsp.h:196
constexpr uint32_t FSEG_MAGIC_N
magic number used in debugging
Definition: fsp0fsp.h:213
constexpr double FSEG_RESERVE_PCT_MIN
Definition: fsp0fsp.h:245
constexpr uint32_t FSEG_FRAG_ARR
array of individual pages belonging to this segment in fsp fragment extent lists
Definition: fsp0fsp.h:216
constexpr double FSEG_RESERVE_PCT_DFLT
Definition: fsp0fsp.h:244
constexpr uint32_t FSEG_MAGIC_N_VALUE
Definition: fsp0fsp.h:233
constexpr uint32_t FSEG_NOT_FULL_N_USED
number of used segment pages in the FSEG_NOT_FULL list
Definition: fsp0fsp.h:205
static uint32_t FSP_SEG_INODES_PER_PAGE(page_size_t page_size)
Definition: fsp0fsp.h:227
constexpr uint32_t FSEG_FRAG_SLOT_SIZE
a fragment page slot contains its page number within space, FIL_NULL means that the slot is not in us...
Definition: fsp0fsp.h:221
constexpr uint32_t FSEG_FREE_LIST_LIMIT
If the reserved size of a segment is at least this many extents, we allow extents to be put to the fr...
Definition: fsp0fsp.h:253
constexpr uint32_t FSEG_ID
Definition: fsp0fsp.h:203
double fseg_reserve_pct
The segment_reserve_factor is the ratio x/y expressed in percentage, where x is the number of free pa...
Definition: fsp0fsp.cc:67
byte fseg_inode_t
Definition: fsp0fsp.h:194
constexpr double FSEG_RESERVE_PCT_MAX
Definition: fsp0fsp.h:246
constexpr uint32_t FSEG_FULL
list of full extents
Definition: fsp0fsp.h:211
constexpr uint32_t FSEG_FREE
list of free extents of this segment
Definition: fsp0fsp.h:207
constexpr uint32_t FSEG_ARR_OFFSET
Definition: fsp0fsp.h:200
byte xdes_t
Definition: fsp0fsp.h:75
constexpr uint32_t FSP_FREE_ADD
This many free extents are added to the free list from above FSP_FREE_LIMIT at a time.
Definition: fsp0fsp.h:176
constexpr uint32_t FSP_NOT_USED
this field contained a value up to which we know that the modifications in the database have been flu...
Definition: fsp0fsp.h:138
constexpr uint32_t FSP_SEG_INODES_FREE
list of pages containing segment headers, where not all the segment header slots are reserved
Definition: fsp0fsp.h:168
constexpr uint32_t FSP_FRAG_N_USED
number of used pages in the FSP_FREE_FRAG list
Definition: fsp0fsp.h:150
std::vector< space_id_t > flag_mismatch_spaces
Definition: fsp0fsp.cc:85
constexpr uint32_t FSP_SDI_HEADER_LEN
The number of bytes required to store SDI root page number(4) and SDI version(4) at Page 0.
Definition: fsp0fsp.h:71
constexpr uint32_t FSP_SPACE_ID
space id
Definition: fsp0fsp.h:135
constexpr uint32_t FSP_SEG_INODES_FULL
list of pages containing segment headers, where all the segment inode slots are reserved
Definition: fsp0fsp.h:164
constexpr uint32_t FSP_SEG_ID
8 bytes which give the first unused segment id
Definition: fsp0fsp.h:160
constexpr uint32_t FSP_FREE
list of free extents
Definition: fsp0fsp.h:152
constexpr uint32_t FSP_FULL_FRAG
list of full extents not belonging to any segment
Definition: fsp0fsp.h:157
bool xdes_state_is_valid(ulint state)
Check if the state of extent descriptor is valid.
Definition: fsp0fsp.cc:457
constexpr uint32_t FSP_HEADER_SIZE
Definition: fsp0fsp.h:172
constexpr uint32_t FSP_HEADER_OFFSET
Offset of the space header within a file page.
Definition: fsp0fsp.h:67
std::ostream & operator<<(std::ostream &out, const xdes_mem_t &obj)
Definition: fsp0fsp.h:96
constexpr uint32_t FSP_FREE_LIMIT
Minimum page number for which the free list has not been initialized: the pages >= this limit are,...
Definition: fsp0fsp.h:146
constexpr uint32_t FSP_SPACE_FLAGS
fsp_space_t.flags, similar to dict_table_t::flags
Definition: fsp0fsp.h:148
constexpr uint32_t FSP_FREE_FRAG
list of partially free extents not belonging to any segment
Definition: fsp0fsp.h:154
byte fsp_header_t
Definition: fsp0fsp.h:74
constexpr uint32_t FSP_SIZE
Current size of the space in pages.
Definition: fsp0fsp.h:140
constexpr uint32_t fsp_is_shared_tablespace(uint32_t flags)
Use an alias in the code for FSP_FLAGS_GET_SHARED()
Definition: fsp0types.h:388
static int flags[50]
Definition: hp_test1.cc:40
static uint32_t mach_read_from_4(const byte *b)
The following function is used to fetch data from 4 consecutive bytes.
static void mach_write_to_4(byte *b, ulint n)
The following function is used to store data in 4 consecutive bytes.
static uint64_t mach_read_from_8(const byte *b)
The following function is used to fetch data from 8 consecutive bytes.
void mlog_write_ulint(byte *ptr, ulint val, mlog_id_t type, mtr_t *mtr)
Writes 1, 2 or 4 bytes to a file page.
Definition: mtr0log.cc:258
Mini-transaction buffer.
#define mtr_memo_contains_page(m, p, t)
Check if memo contains the given page.
Definition: mtr0mtr.h:111
@ MLOG_4BYTES
4 bytes ...
Definition: mtr0types.h:76
@ MTR_MEMO_PAGE_SX_FIX
Definition: mtr0types.h:275
#define DBUG_LOG(keyword, v)
Definition: my_dbug.h:315
#define DBUG_TRACE
Definition: my_dbug.h:146
Instrumentation helpers for conditions.
ABI for instrumented mutexes.
ulong n_pages
Number of pages per doublewrite thread/segment.
Definition: buf0dblwr.cc:83
bool is_encrypted(const String_type &type)
Definition: dd_table.h:422
size_t size(const char *const c)
Definition: base64.h:46
Index page routines.
byte page_t
Type of the index page.
Definition: page0types.h:152
Record manager global types.
required uint64 version
Definition: replication_group_member_actions.proto:41
Definition: os0enc.h:461
Definition: fsp0fsp.h:1041
Page_alloc_info(space_id_t space_id, const page_size_t &page_size, fseg_header_t *fseg_hdr)
Definition: fsp0fsp.h:1042
fseg_header_t * m_fseg_header
File segment header.
Definition: fsp0fsp.h:1053
page_size_t m_page_size
Page size.
Definition: fsp0fsp.h:1050
space_id_t m_space_id
Tablespace ID.
Definition: fsp0fsp.h:1047
The buffer control block structure.
Definition: buf0buf.h:1747
Tablespace or log data space.
Definition: fil0fil.h:238
In-memory representation of flst_base_node_t.
Definition: fut0lst.h:148
In-memory representation of the fsp_header_t file structure.
Definition: fsp0fsp.h:101
ulint m_space_id
Definition: fsp0fsp.h:104
flst_bnode_t m_free_frag
Definition: fsp0fsp.h:111
flst_bnode_t m_inodes_free
Definition: fsp0fsp.h:115
ulint m_notused
Definition: fsp0fsp.h:105
ulint m_free_limit
Definition: fsp0fsp.h:107
ulint m_fsp_frag_n_used
Definition: fsp0fsp.h:109
ulint m_flags
Definition: fsp0fsp.h:108
ib_id_t m_segid
Definition: fsp0fsp.h:113
ulint m_fsp_size
Definition: fsp0fsp.h:106
flst_bnode_t m_fsp_free
Definition: fsp0fsp.h:110
flst_bnode_t m_full_frag
Definition: fsp0fsp.h:112
std::ostream & print(std::ostream &out) const
Definition: fsp0fsp.cc:4005
fsp_header_mem_t(const fsp_header_t *header, mtr_t *mtr)
Definition: fsp0fsp.cc:3991
flst_bnode_t m_inodes_full
Definition: fsp0fsp.h:114
Mini-transaction handle and buffer.
Definition: mtr0mtr.h:177
An instrumented cond structure.
Definition: mysql_cond_bits.h:50
An instrumented mutex structure.
Definition: mysql_mutex_bits.h:50
Definition: fsp0fsp.h:85
const xdes_t * m_xdes
Definition: fsp0fsp.h:91
bool is_valid() const
Definition: fsp0fsp.h:868
const char * state_name() const
Definition: fsp0fsp.h:873
xdes_mem_t(const xdes_t *xdes)
Definition: fsp0fsp.h:86
std::ostream & print(std::ostream &out) const
Definition: fsp0fsp.cc:4047
static const space_id_t TRX_SYS_SPACE
Space id of the transaction system page (the system tablespace)
Definition: trx0types.h:52
Version control for database, common definitions, and include files.
uint64_t ib_id_t
The generic InnoDB system object identifier data type.
Definition: univ.i:443
#define UNIV_PAGE_SIZE
The universal page size of the database.
Definition: univ.i:294
#define IF_DEBUG(...)
Definition: univ.i:674
unsigned long int ulint
Definition: univ.i:406
Utilities for byte operations.
#define ut_ad(EXPR)
Debug assertion.
Definition: ut0dbg.h:105