MySQL 9.2.0
Source Code Documentation
fil0fil.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/fil0fil.h
29 The low-level file system
30
31 Created 10/25/1995 Heikki Tuuri
32 *******************************************************/
33
34#ifndef fil0fil_h
35#define fil0fil_h
36
37#include "univ.i"
38
39#include "dict0types.h"
40#include "fil0types.h"
41#include "log0recv.h"
42#include "page0size.h"
43#ifndef UNIV_HOTBACKUP
44#include "ibuf0types.h"
45#endif /* !UNIV_HOTBACKUP */
46#include "ut0new.h"
47
49#include "sql/dd/object_id.h"
50
51#include <atomic>
52#include <cstdint>
53#include <list>
54#include <vector>
55
56extern ulong srv_fast_shutdown;
57
58/** Maximum number of tablespaces to be scanned by a thread while scanning
59for available tablespaces during server startup. This is a hard maximum.
60If the number of files to be scanned is more than
61FIL_SCAN_MAX_TABLESPACES_PER_THREAD,
62then additional threads will be spawned to scan the additional files in
63parallel. */
65
66/** Maximum number of threads that will be used for scanning the tablespace
67files. This can be further adjusted depending on the number of available
68cores. */
69constexpr size_t FIL_SCAN_MAX_THREADS = 16;
70
71/** Number of threads per core. */
72constexpr size_t FIL_SCAN_THREADS_PER_CORE = 2;
73
74/** Calculate the number of threads that can be spawned to scan the given
75number of files taking into the consideration, number of cores available
76on the machine.
77@param[in] num_files Number of files to be scanned
78@return number of threads to be spawned for scanning the files */
79size_t fil_get_scan_threads(size_t num_files);
80
81/** This tablespace name is used internally during file discovery to open a
82general tablespace before the data dictionary is recovered and available. */
83static constexpr char general_space_name[] = "innodb_general";
84
85/** This tablespace name is used as the prefix for implicit undo tablespaces
86and during file discovery to open an undo tablespace before the DD is
87recovered and available. */
88static constexpr char undo_space_name[] = "innodb_undo";
89
90extern volatile bool recv_recovery_on;
91
92/** Initial size of an UNDO tablespace when it is created new
93or truncated under low load.
94page size | FSP_EXTENT_SIZE | Initial Size | Pages
95----------+------------------+--------------+-------
96 4 KB | 256 pages = 1 MB | 16 MB | 4096
97 8 KB | 128 pages = 1 MB | 16 MB | 2048
98 16 KB | 64 pages = 1 MB | 16 MB | 1024
99 32 KB | 64 pages = 2 MB | 16 MB | 512
100 64 KB | 64 pages = 4 MB | 16 MB | 256 */
101constexpr uint32_t UNDO_INITIAL_SIZE = 16 * 1024 * 1024;
102#define UNDO_INITIAL_SIZE_IN_PAGES \
103 os_offset_t { UNDO_INITIAL_SIZE / srv_page_size }
104
105#ifdef UNIV_HOTBACKUP
106#include <unordered_set>
107using Dir_set = std::unordered_set<std::string>;
108extern Dir_set rem_gen_ts_dirs;
109extern bool replay_in_datadir;
110#endif /* UNIV_HOTBACKUP */
111
112// Forward declaration
113struct trx_t;
114class page_id_t;
115
116using Filenames = std::vector<std::string, ut::allocator<std::string>>;
117using Space_ids = std::vector<space_id_t, ut::allocator<space_id_t>>;
118
119/** File types */
120enum fil_type_t : uint8_t {
121 /** temporary tablespace (temporary undo log or tables) */
123 /** a tablespace that is being imported (no logging until finished) */
125 /** persistent tablespace (for system, undo log or tables) */
127};
128
129/** Result of comparing a path. */
130enum class Fil_state {
131 /** The path matches what was found during the scan. */
132 MATCHES,
133
134 /** No MLOG_FILE_DELETE record and the file could not be found. */
135 MISSING,
136
137 /** A MLOG_FILE_DELETE was found, file was deleted. */
138 DELETED,
139
140 /** Space ID matches but the paths don't match. */
141 MOVED,
142
143 /** Space ID and paths match but dd_table data dir flag is false despite the
144 file being outside default data dir */
146
147 /** Tablespace and/or filename was renamed. The DDL log will handle
148 this case. */
149 RENAMED,
150
151 /** In case of error during comparison. */
153};
154
155struct fil_space_t;
156
157/** File node of a tablespace or the log data space */
159 /** Returns true if the file can be closed. */
160 bool can_be_closed() const;
161 /** Returns true if the file is flushed. */
162 bool is_flushed() const {
165 }
166 /** Sets file to flushed state. */
168
170
171 /** tablespace containing this file */
173
174 /** file name; protected by Fil_shard::m_mutex and log_sys->mutex. */
175 char *name;
176
177 /** whether this file is open. Note: We set the is_open flag after
178 we increase the write the MLOG_FILE_OPEN record to redo log. Therefore
179 we increment the in_use reference count before setting the OPEN flag. */
181
182 /** file handle (valid if is_open) */
184
185 /** event that groups and serializes calls to fsync */
187
188 /** whether the file actually is a raw device or disk partition */
190
191 bool is_offset_valid(os_offset_t byte_offset) const;
192
193 /** size of the file in database pages (0 if not known yet);
194 the possible last incomplete megabyte may be ignored
195 if space->id == 0 */
197
198 /** Size of the file when last flushed, used to force the flush when file
199 grows to keep the filesystem metadata synced when using O_DIRECT_NO_FSYNC */
201
202 /** initial size of the file in database pages;
203 FIL_IBD_FILE_INITIAL_SIZE by default */
205
206 /** maximum size of the file in database pages */
208
209 /** count of pending I/O's; is_open must be true if nonzero */
211
212 /** count of pending flushes; is_open must be true if nonzero */
214
215 /** Set to true when a file is being extended. */
217
218 /** number of writes to the file since the system was started */
220
221 /** the modification_counter of the latest flush to disk */
223
224 /** link to the fil_system->LRU list (keeping track of open files) */
226
227 /** whether the file system of this file supports PUNCH HOLE */
229
230 /** block size to use for punching holes */
232
233 /** FIL_NODE_MAGIC_N */
234 size_t magic_n;
235};
236
237/** Tablespace or log data space */
240 using Files = std::vector<fil_node_t, ut::allocator<fil_node_t>>;
241
242 /** Release the reserved free extents.
243 @param[in] n_reserved number of reserved extents */
244 void release_free_extents(ulint n_reserved);
245
246 /** @return true if the instance is queued for deletion. Guarantees the space
247 is not deleted as long as the fil_shard mutex is not released. */
248 bool is_deleted() const;
249
250 /** @return true if the instance was not queued for deletion. It does not
251 guarantee it is not queued for deletion at the moment. */
252 bool was_not_deleted() const;
253
254 /** Marks the space object for deletion. It will bump the space object version
255 and cause all pages in buffer pool that reference to the current space
256 object version to be stale and be freed on first encounter. */
257 void set_deleted();
258
259#ifndef UNIV_HOTBACKUP
260 /** Returns current version of the space object. It is being bumped when the
261 space is truncated or deleted. Guarantees the version returned is up to date
262 as long as fil_shard mutex is not released.*/
263 uint32_t get_current_version() const;
264
265 /** Returns current version of the space object. It is being bumped when the
266 space is truncated or deleted. It does not guarantee the version is current
267 one.*/
268 uint32_t get_recent_version() const;
269
270 /** Bumps the space object version and cause all pages in buffer pool that
271 reference the current space object version to be stale and be freed on
272 first encounter. */
273 void bump_version();
274
275 /** @return true if this space does not have any more references. Guarantees
276 the result only if true was returned. */
277 bool has_no_references() const;
278
279 /** @return Current number of references to the space. This method
280 should be called only while shutting down the server. Only when there is no
281 background nor user session activity the returned value will be valid. */
282 size_t get_reference_count() const;
283
284 /** Increment the page reference count. */
285 void inc_ref() noexcept {
286 /* We assume space is protected from being removed either through
287 n_pending_ops or m_n_ref_count already bumped, OR MDL latch is
288 protecting it, OR it is a private space. Bumping the n_pending_ops
289 can be done only under fil shard mutex and stopping new bumps is also
290 done under this mutex */
291 const auto o = m_n_ref_count.fetch_add(1);
292 ut_a(o != std::numeric_limits<size_t>::max());
293 }
294
295 /** Decrement the page reference count. */
296 void dec_ref() noexcept {
297 const auto o = m_n_ref_count.fetch_sub(1);
298 ut_a(o >= 1);
299 }
300#endif /* !UNIV_HOTBACKUP */
301
302#ifdef UNIV_DEBUG
303 /** Print the extent descriptor pages of this tablespace into
304 the given output stream.
305 @param[in] out the output stream.
306 @return the output stream. */
307 std::ostream &print_xdes_pages(std::ostream &out) const;
308
309 /** Print the extent descriptor pages of this tablespace into
310 the given file.
311 @param[in] filename the output file name. */
312 void print_xdes_pages(const char *filename) const;
313#endif /* UNIV_DEBUG */
314
315 public:
317 using Flush_observers = std::vector<Observer *, ut::allocator<Observer *>>;
318
319 /** When the tablespace was extended last. */
321
322 /** Extend undo tablespaces by so many pages. */
324
325 /** When an undo tablespace has been initialized with required header pages,
326 that size is recorded here. Auto-truncation happens when the file size
327 becomes bigger than both this and srv_max_undo_log_size. */
329
330 /** Tablespace name */
331 char *name{};
332
333 /** Tablespace ID */
335
336 /** Initializes fields. This could be replaced by a constructor if SunPro is
337 compiling it correctly. */
338 void initialize() noexcept {
340 new (&files) fil_space_t::Files();
341
342#ifndef UNIV_HOTBACKUP
343 new (&m_version) std::atomic<uint32_t>;
344 new (&m_n_ref_count) std::atomic_size_t;
345 new (&m_deleted) std::atomic<bool>;
346#endif /* !UNIV_HOTBACKUP */
347 }
348
349 private:
350#ifndef UNIV_HOTBACKUP
351 /** All pages in the buffer pool that reference this fil_space_t instance with
352 version before this version can be lazily freed or reused as free pages.
353 They should be rejected if there is an attempt to write them to disk.
354
355 Writes to m_version are guarded by the exclusive MDL/table lock latches
356 acquired by the caller, as stated in docs. Note that the Fil_shard mutex seems
357 to be latched in 2 of 3 usages only, so is not really an alternative.
358
359 Existence of the space object during reads is assured during these operations:
360 1. when read by the buf_page_init_low on page read/creation - the caller must
361 have acquired shared MDL/table lock latches.
362 2. when read on buf_page_t::is_stale() on page access for a query or for purge
363 operation. The caller must have acquired shared MDL/table lock latches.
364 3. when read on buf_page_t::is_stale() on page access from LRU list, flush
365 list or whatever else. Here, the fact that the page has latched the space
366 using the reference counting system is what guards the space existence.
367
368 When reading the value for the page being created with buf_page_init_low we
369 have the MDL latches on table that is in tablespace or the tablespace alone,
370 so we won't be able to bump m_version until they are released, so we will
371 read the current value of the version. When reading the value for the page
372 validation with buf_page_t::is_stale(), we will either:
373 a) have the MDL latches required in at least S mode in case we need to be
374 certain if the page is stale, to use it in a query or in purge operation, or
375 b) in case we don't not have the MDL latches, we may read an outdated value.
376 This happens for pages that are seen during for example LRU or flush page
377 scans. These pages are not needed for the query itself. The read is to decide
378 if the page can be safely discarded. Reading incorrect value can lead to no
379 action being executed. Reading incorrect value can't lead to page being
380 incorrectly evicted.
381 */
382 std::atomic<uint32_t> m_version{};
383
384 /** Number of buf_page_t entries that point to this instance.
385
386 This field is guarded by the Fil_shard mutex and the "reference
387 count system". The reference count system here is allowing to take a "latch"
388 on the space by incrementing the reference count, and release it by
389 decrementing it.
390
391 The increments are possible from two places:
392 1. buf_page_init_low is covered by the existing MDL/table lock latches only
393 and the fact that the space it is using is a current version of the space
394 (the version itself is also guarded by these MDL/table lock latches). It
395 implicitly acquires the "reference count system" latch after this operation.
396 2. buf_page_t::buf_page_t(const buf_page_t&) copy constructor - increases the
397 value, but it assumes the page being copied from has "reference count system"
398 latch so the reference count is greater than 0 during this constructor call.
399
400 For decrementing the reference count is itself a latch allowing for the safe
401 decrement.
402
403 The value is checked for being 0 in Fil_shard::checkpoint under the Fil_shard
404 mutex, and only if the space is deleted.
405 Observing m_n_ref_count==0 might trigger freeing the object. No other thread
406 can be during the process of incrementing m_n_ref_count from 0 to 1 in
407 parallel to this check. This is impossible for following reasons. Recall the
408 only two places where we do increments listed above:
409 1. If the space is deleted, then MDL/table lock latches guarantee there are
410 no users that would be able to see it as the current version of space and thus
411 will not attempt to increase the reference value from 0.
412 2. The buf_page_t copy constructor can increase it, but it assumes the page
413 being copied from has "reference count system" latch so the reference count is
414 greater than 0 during this constructor call.
415
416 There is also an opposite race possible: while we check for ref count being
417 zero, another thread may be decrementing it in parallel, and we might miss
418 that if we check too soon. This is benign, as it will result in us not
419 reclaiming the memory we could (but not have to) free, and will return to the
420 check on next checkpoint.
421 */
422 std::atomic_size_t m_n_ref_count{};
423#endif /* !UNIV_HOTBACKUP */
424
425 /** true if the tablespace is marked for deletion. */
426 std::atomic_bool m_deleted{};
427
428 /** true if bulk operation is in progress. */
429 std::atomic_bool m_is_bulk{false};
430
431 /** true if bulk operation is in progress. */
432 std::atomic<uint64_t> m_bulk_extend_size;
433
434 public:
435 /** Begin bulk operation on the space.
436 @param[in] extend_size space extension size for bulk operation */
437 void begin_bulk_operation(uint64_t extend_size) {
438 m_is_bulk.store(true);
439 m_bulk_extend_size.store(extend_size);
440 }
441
442 /** End bulk operation on the space. */
443 void end_bulk_operation() { m_is_bulk.store(false); }
444
445 /** @return true, if bulk operation in progress. */
446 bool is_bulk_operation_in_progress() const { return m_is_bulk.load(); }
447
448 /** @return automatic extension size for space. */
449 uint64_t get_auto_extend_size();
450
451 /** @return true if added space should be initialized while extending space.
452 */
454
455 /** true if we want to rename the .ibd file of tablespace and
456 want to temporarily prevent other threads from opening the file that is being
457 renamed. */
459
460 /** Throttles writing to log a message about long waiting for file to perform
461 rename. */
463
464 /** We set this true when we start deleting a single-table
465 tablespace. When this is set following new ops are not allowed:
466 * read IO request
467 * ibuf merge
468 * file flush
469 Note that we can still possibly have new write operations because we
470 don't check this flag when doing flush batches. */
472
473#ifdef UNIV_DEBUG
474 /** Reference count for operations who want to skip redo log in
475 the file space in order to make fsp_space_modify_check pass. */
477#endif /* UNIV_DEBUG */
478
479 /** Purpose */
481
482 /** Files attached to this tablespace. Note: Only the system tablespace
483 can have multiple files, this is a legacy issue. */
485
486 /** Tablespace file size in pages; 0 if not known yet */
488
489 /** FSP_SIZE in the tablespace header; 0 if not known yet */
491
492 /** Autoextend size */
494
495 /** Length of the FSP_FREE list */
496 uint32_t free_len{};
497
498 /** Contents of FSP_FREE_LIMIT */
500
501 /** Tablespace flags; see fsp_flags_is_valid() and
502 page_size_t(ulint) (constructor).
503 This is protected by space->latch and tablespace MDL */
504 uint32_t flags{};
505
506 /** Number of reserved free extents for ongoing operations like
507 B-tree page split */
509
510 /** This is positive when flushing the tablespace to disk;
511 dropping of the tablespace is forbidden if this is positive */
513
514 /** This is positive when we have pending operations against this
515 tablespace. The pending operations can be ibuf merges or lock
516 validation code trying to read a block. Dropping of the tablespace
517 is forbidden if this is positive. Protected by Fil_shard::m_mutex. */
518 uint32_t n_pending_ops{};
519
520#ifndef UNIV_HOTBACKUP
521 /** Latch protecting the file space storage allocation */
523#endif /* !UNIV_HOTBACKUP */
524
525 /** List of spaces with at least one unflushed file we have
526 written to */
528
529 /** true if this space is currently in unflushed_spaces */
531
532 /** Compression algorithm */
534
535 /** Encryption metadata */
537
538 /** Encryption is in progress */
540
541 /** Flush lsn of header page. It is used only during recovery */
543
544 /** FIL_SPACE_MAGIC_N */
546
547 /** System tablespace */
549
550 /** Check if the tablespace is compressed.
551 @return true if compressed, false otherwise. */
552 [[nodiscard]] bool is_compressed() const noexcept {
554 }
555
556 /** Check if the tablespace is encrypted.
557 @return true if encrypted, false otherwise. */
558 [[nodiscard]] bool is_encrypted() const noexcept {
560 }
561
562 /** Check if the encryption details, like the encryption key, type and
563 other details, that are needed to carry out encryption are available.
564 @return true if encryption can be done, false otherwise. */
565 [[nodiscard]] bool can_encrypt() const noexcept {
567 }
568
569 public:
570 /** Get the file node corresponding to the given page number of the
571 tablespace.
572 @param[in,out] page_no Caller passes the page number within a tablespace.
573 After return, it contains the page number within
574 the returned file node. For tablespaces containing
575 only one file, the given page_no will not change.
576 @return the file node object. */
577 [[nodiscard]] fil_node_t *get_file_node(page_no_t *page_no) noexcept;
578};
579
580/** Value of fil_space_t::magic_n */
581constexpr size_t FIL_SPACE_MAGIC_N = 89472;
582
583/** Value of fil_node_t::magic_n */
584constexpr size_t FIL_NODE_MAGIC_N = 89389;
585
586/** Common InnoDB file extensions */
589 IBD = 1,
590 CFG = 2,
591 CFP = 3,
592 IBT = 4,
593 IBU = 5,
594 DWR = 6,
595 BWR = 7
597
598extern const char *dot_ext[];
599
600#define DOT_IBD dot_ext[IBD]
601#define DOT_CFG dot_ext[CFG]
602#define DOT_CFP dot_ext[CFP]
603#define DOT_IBT dot_ext[IBT]
604#define DOT_IBU dot_ext[IBU]
605#define DOT_DWR dot_ext[DWR]
606
607#ifdef _WIN32
608/* Initialization of m_abs_path() produces warning C4351:
609"new behavior: elements of array '...' will be default initialized."
610See https://msdn.microsoft.com/en-us/library/1ywe7hcy.aspx */
611#pragma warning(disable : 4351)
612#endif /* _WIN32 */
613
614/** Wrapper for a path to a directory that may or may not exist. */
615class Fil_path {
616 public:
617 /** schema '/' table separator */
618 static constexpr auto DB_SEPARATOR = '/';
619
620 /** OS specific path separator. */
621 static constexpr auto OS_SEPARATOR = OS_PATH_SEPARATOR;
622
623 /** Directory separators that are supported. */
624 static constexpr auto SEPARATOR = "\\/";
625#ifdef _WIN32
626 static constexpr auto DOT_SLASH = ".\\";
627 static constexpr auto DOT_DOT_SLASH = "..\\";
628 static constexpr auto SLASH_DOT_DOT_SLASH = "\\..\\";
629#else
630 static constexpr auto DOT_SLASH = "./";
631 static constexpr auto DOT_DOT_SLASH = "../";
632 static constexpr auto SLASH_DOT_DOT_SLASH = "/../";
633#endif /* _WIN32 */
634
635 /** Various types of file paths. */
637
638 /** Default constructor. Defaults to MySQL_datadir_path. */
639 Fil_path();
640
641 /** Constructor
642 @param[in] path Path, not necessarily NUL terminated
643 @param[in] len Length of path
644 @param[in] normalize_path If false, it's the callers responsibility to
645 ensure that the path is normalized. */
646 explicit Fil_path(const char *path, size_t len, bool normalize_path = false);
647
648 /** Constructor
649 @param[in] path Path, not necessarily NUL terminated
650 @param[in] normalize_path If false, it's the callers responsibility to
651 ensure that the path is normalized. */
652 explicit Fil_path(const char *path, bool normalize_path = false);
653
654 /** Constructor
655 @param[in] path pathname (may also include the file basename)
656 @param[in] normalize_path If false, it's the callers responsibility to
657 ensure that the path is normalized. */
658 explicit Fil_path(const std::string &path, bool normalize_path = false);
659
660 /** Implicit type conversion
661 @return pointer to m_path.c_str() */
662 [[nodiscard]] operator const char *() const { return m_path.c_str(); }
663
664 /** Explicit type conversion
665 @return pointer to m_path.c_str() */
666 [[nodiscard]] const char *operator()() const { return m_path.c_str(); }
667
668 /** @return the value of m_path */
669 [[nodiscard]] const std::string &path() const { return (m_path); }
670
671 /** @return the length of m_path */
672 [[nodiscard]] size_t len() const { return (m_path.length()); }
673
674 /** Return the absolute path by value. If m_abs_path is null, calculate
675 it and return it by value without trying to reset this const object.
676 m_abs_path can be empty if the path did not exist when this object
677 was constructed.
678 @return the absolute path by value. */
679 [[nodiscard]] const std::string abs_path() const {
680 if (m_abs_path.empty()) {
681 return (get_real_path(m_path));
682 }
683
684 return (m_abs_path);
685 }
686
687 /** @return the length of m_abs_path */
688 [[nodiscard]] size_t abs_len() const { return (m_abs_path.length()); }
689
690 /** Determine if this path is equal to the other path.
691 @param[in] other path to compare to
692 @return true if the paths are the same */
693 bool operator==(const Fil_path &other) const { return (is_same_as(other)); }
694
695 /** Check if m_path is the same as this other path.
696 @param[in] other directory path to compare to
697 @return true if m_path is the same as path */
698 [[nodiscard]] bool is_same_as(const Fil_path &other) const;
699
700 /** Check if this path is the same as the other path.
701 @param[in] other directory path to compare to
702 @return true if this path is the same as the other path */
703 [[nodiscard]] bool is_same_as(const std::string &other) const;
704
705 /** Get the absolute directory of this path */
706 [[nodiscard]] Fil_path get_abs_directory() const;
707
708 /** Check if the directory to path is same as directory as the other path.
709 @param[in] other directory path to compare to
710 @return true if this path directory is the same as the other path directory */
711 [[nodiscard]] bool is_dir_same_as(const Fil_path &other) const;
712
713 /** Check if two path strings are equal. Put them into Fil_path objects
714 so that they can be compared correctly.
715 @param[in] first first path to check
716 @param[in] second socond path to check
717 @return true if these two paths are the same */
718 [[nodiscard]] static bool is_same_as(const std::string &first,
719 const std::string &second) {
720 if (first.empty() || second.empty()) {
721 return (false);
722 }
723
724 Fil_path first_path(first);
725 std::string first_abs = first_path.abs_path();
726 trim_separator(first_abs);
727
728 Fil_path second_path(second);
729 std::string second_abs = second_path.abs_path();
730 trim_separator(second_abs);
731
732 return (first_abs == second_abs);
733 }
734
735 /** Splits the path into directory and file name parts.
736 @param[in] path path to split
737 @return [directory, file] for the path */
738 [[nodiscard]] static std::pair<std::string, std::string> split(
739 const std::string &path);
740
741 /** Check if m_path is the parent of the other path.
742 @param[in] other path to compare to
743 @return true if m_path is an ancestor of name */
744 [[nodiscard]] bool is_ancestor(const Fil_path &other) const;
745
746 /** Check if this Fil_path is an ancestor of the other path.
747 @param[in] other path to compare to
748 @return true if this Fil_path is an ancestor of the other path */
749 [[nodiscard]] bool is_ancestor(const std::string &other) const;
750
751 /** Check if the first path is an ancestor of the second.
752 Do not assume that these paths have been converted to real paths
753 and are ready to compare. If the two paths are the same
754 we will return false.
755 @param[in] first Parent path to check
756 @param[in] second Descendent path to check
757 @return true if the first path is an ancestor of the second */
758 [[nodiscard]] static bool is_ancestor(const std::string &first,
759 const std::string &second) {
760 if (first.empty() || second.empty()) {
761 return (false);
762 }
763
764 Fil_path ancestor(first);
765 Fil_path descendant(second);
766
767 return (ancestor.is_ancestor(descendant));
768 }
769
770 /** @return true if m_path exists and is a file. */
771 [[nodiscard]] bool is_file_and_exists() const;
772
773 /** @return true if m_path exists and is a directory. */
774 [[nodiscard]] bool is_directory_and_exists() const;
775
776 /** This validation is only for ':'.
777 @return true if the path is valid. */
778 [[nodiscard]] bool is_valid() const;
779
780 /** Determine if m_path contains a circular section like "/anydir/../"
781 Fil_path::normalize() must be run before this.
782 @return true if a circular section if found, false if not */
783 [[nodiscard]] bool is_circular() const;
784
785 /** Determine if the file or directory is considered HIDDEN.
786 Most file systems identify the HIDDEN attribute by a '.' preceding the
787 basename. On Windows, a HIDDEN path is identified by a file attribute.
788 We will use the preceding '.' to indicate a HIDDEN attribute on ALL
789 file systems so that InnoDB tablespaces and their directory structure
790 remain portable.
791 @param[in] path The full or relative path of a file or directory.
792 @return true if the directory or path is HIDDEN. */
793 static bool is_hidden(std::string path);
794
795#ifdef _WIN32
796 /** Use the WIN32_FIND_DATA struncture to determine if the file or
797 directory is HIDDEN. Consider a SYSTEM attribute also as an indicator
798 that it is HIDDEN to InnoDB.
799 @param[in] dirent A directory entry obtained from a call to FindFirstFile()
800 or FindNextFile()
801 @return true if the directory or path is HIDDEN. */
802 static bool is_hidden(WIN32_FIND_DATA &dirent);
803#endif /* WIN32 */
804
805 /** Remove quotes e.g., 'a;b' or "a;b" -> a;b.
806 This will only remove the quotes if they are matching on the whole string.
807 This will not work if each delimited string is quoted since this is called
808 before the string is parsed.
809 @return pathspec with the quotes stripped */
810 static std::string remove_quotes(const char *pathspec) {
811 std::string path(pathspec);
812
813 ut_ad(!path.empty());
814
815 if (path.size() >= 2 && ((path.front() == '\'' && path.back() == '\'') ||
816 (path.front() == '"' && path.back() == '"'))) {
817 path.erase(0, 1);
818 path.erase(path.size() - 1);
819 }
820
821 return (path);
822 }
823
824 /** Determine if a path is a relative path or not.
825 @param[in] path OS directory or file path to evaluate
826 @retval true if the path is relative
827 @retval false if the path is absolute or file_name_only */
828 [[nodiscard]] static bool is_relative_path(const std::string &path) {
829 return (type_of_path(path) == relative);
830 }
831
832 /** @return true if the path is an absolute path. */
833 [[nodiscard]] bool is_absolute_path() const {
834 return (type_of_path(m_path) == absolute);
835 }
836
837 /** Determine if a path is an absolute path or not.
838 @param[in] path OS directory or file path to evaluate
839 @retval true if the path is absolute
840 @retval false if the path is relative or file_name_only */
841 [[nodiscard]] static bool is_absolute_path(const std::string &path) {
842 return (type_of_path(path) == absolute);
843 }
844
845 /** Determine what type of path is provided.
846 @param[in] path OS directory or file path to evaluate
847 @return the type of filepath; 'absolute', 'relative',
848 'file_name_only', or 'invalid' if the path is empty. */
849 [[nodiscard]] static path_type type_of_path(const std::string &path) {
850 if (path.empty()) {
851 return (invalid);
852 }
853
854 /* The most likely type is a file name only with no separators. */
855 auto first_separator = path.find_first_of(SEPARATOR);
856 if (first_separator == std::string::npos) {
857 return (file_name_only);
858 }
859
860 /* Any string that starts with an OS_SEPARATOR is
861 an absolute path. This includes any OS and even
862 paths like "\\Host\share" on Windows. */
863 if (first_separator == 0) {
864 return (absolute);
865 }
866
867#ifdef _WIN32
868 /* Windows may have an absolute path like 'A:\' */
869 if (path.length() >= 3 && isalpha(path.at(0)) && path.at(1) == ':' &&
870 (path.at(2) == '\\' || path.at(2) == '/')) {
871 return (absolute);
872 }
873#endif /* _WIN32 */
874
875 /* Since it contains separators and is not an absolute path,
876 it must be a relative path. */
877 return (relative);
878 }
879
880 /* Check if the path is prefixed with pattern.
881 @return true if prefix matches */
882 [[nodiscard]] static bool has_prefix(const std::string &path,
883 const std::string prefix) {
884 return (path.size() >= prefix.size() &&
885 std::equal(prefix.begin(), prefix.end(), path.begin()));
886 }
887
888 /** Normalize a directory path for the current OS:
889 On Windows, we convert '/' to '\', else we convert '\' to '/'.
890 @param[in,out] path Directory and file path */
891 static void normalize(std::string &path) {
892 for (auto &c : path) {
893 if (c == OS_PATH_SEPARATOR_ALT) {
894 c = OS_SEPARATOR;
895 }
896 }
897 }
898
899 /** Normalize a directory path for the current OS:
900 On Windows, we convert '/' to '\', else we convert '\' to '/'.
901 @param[in,out] path A NUL terminated path */
902 static void normalize(char *path) {
903 for (auto ptr = path; *ptr; ++ptr) {
904 if (*ptr == OS_PATH_SEPARATOR_ALT) {
905 *ptr = OS_SEPARATOR;
906 }
907 }
908 }
909
910 /** Convert a path string to lower case using the CHARSET my_charset_filename.
911 @param[in,out] path Directory and file path */
912 static void to_lower(std::string &path) {
913 for (auto &c : path) {
915 }
916 }
917
918 /** @return true if the path exists and is a file . */
919 [[nodiscard]] static os_file_type_t get_file_type(const std::string &path);
920
921 /** Return a string to display the file type of a path.
922 @param[in] path path name
923 @return true if the path exists and is a file . */
924 static const char *get_file_type_string(const std::string &path);
925
926 /** Return a string to display the file type of a path.
927 @param[in] type OS file type
928 @return true if the path exists and is a file . */
929 static const char *get_file_type_string(os_file_type_t type);
930
931 /** Get the real path for a directory or a file name. This path can be
932 used to compare with another absolute path. It will be converted to
933 lower case on case insensitive file systems and if it is a directory,
934 it will end with a directory separator. The call to my_realpath() may
935 fail on non-Windows platforms if the path does not exist. If so, the
936 parameter 'force' determines what to return.
937 @param[in] path directory or filename to convert to a real path
938 @param[in] force if true and my_realpath() fails, use the path provided.
939 if false and my_realpath() fails, return a null string.
940 @return the absolute path prepared for making comparisons with other real
941 paths. */
942 [[nodiscard]] static std::string get_real_path(const std::string &path,
943 bool force = true);
944
945 /** Get the basename of the file path. This is the file name without any
946 directory separators. In other words, the file name after the last separator.
947 @param[in] filepath The name of a file, optionally with a path. */
948 [[nodiscard]] static std::string get_basename(const std::string &filepath);
949
950 /** Separate the portion of a directory path that exists and the portion that
951 does not exist.
952 @param[in] path Path to evaluate
953 @param[in,out] ghost The portion of the path that does not exist.
954 @return the existing portion of a path. */
955 [[nodiscard]] static std::string get_existing_path(const std::string &path,
956 std::string &ghost);
957
958 /** Check if the name is an undo tablespace name.
959 @param[in] name Tablespace name
960 @return true if it is an undo tablespace name */
961 [[nodiscard]] static bool is_undo_tablespace_name(const std::string &name);
962
963 /** Check if the file has the the specified suffix
964 @param[in] sfx suffix to look for
965 @param[in] path Filename to check
966 @return true if it has the the ".ibd" suffix. */
967 static bool has_suffix(ib_file_suffix sfx, const std::string &path) {
968 const auto suffix = dot_ext[sfx];
969 size_t len = strlen(suffix);
970
971 return (path.size() >= len &&
972 path.compare(path.size() - len, len, suffix) == 0);
973 }
974
975 /** Check if the file has the the specified suffix and truncate
976 @param[in] sfx suffix to look for
977 @param[in,out] path Filename to check
978 @return true if the suffix is found and truncated. */
979 static bool truncate_suffix(ib_file_suffix sfx, std::string &path) {
980 const auto suffix = dot_ext[sfx];
981 size_t len = strlen(suffix);
982
983 if (path.size() < len ||
984 path.compare(path.size() - len, len, suffix) != 0) {
985 return (false);
986 }
987
988 path.resize(path.size() - len);
989 return (true);
990 }
991
992 /** Check if a character is a path separator ('\' or '/')
993 @param[in] c Character to check
994 @return true if it is a separator */
995 static bool is_separator(char c) { return (c == '\\' || c == '/'); }
996
997 /** If the last character of a directory path is a separator ('\' or '/')
998 trim it off the string.
999 @param[in] path file system path */
1000 static void trim_separator(std::string &path) {
1001 if (!path.empty() && is_separator(path.back())) {
1002 path.resize(path.size() - 1);
1003 }
1004 }
1005
1006 /** If the last character of a directory path is NOT a separator,
1007 append a separator to the path.
1008 NOTE: We leave it up to the caller to assure that the path is a directory
1009 and not a file since if that directory does not yet exist, this function
1010 cannot tell the difference.
1011 @param[in] path file system path */
1012 static void append_separator(std::string &path) {
1013 if (!path.empty() && !is_separator(path.back())) {
1014 path.push_back(OS_SEPARATOR);
1015 }
1016 }
1017
1018 /** Allocate and build a file name from a path, a table or
1019 tablespace name and a suffix.
1020 @param[in] path_in nullptr or the directory path or
1021 the full path and filename
1022 @param[in] name_in nullptr if path is full, or
1023 Table/Tablespace name
1024 @param[in] ext the file extension to use
1025 @param[in] trim whether last name on the path should
1026 be trimmed
1027 @return own: file name; must be freed by ut::free() */
1028 [[nodiscard]] static char *make(const std::string &path_in,
1029 const std::string &name_in,
1030 ib_file_suffix ext, bool trim = false);
1031
1032 /** Allocate and build a CFG file name from a path.
1033 @param[in] path_in Full path to the filename
1034 @return own: file name; must be freed by ut::free() */
1035 [[nodiscard]] static char *make_cfg(const std::string &path_in) {
1036 return (make(path_in, "", CFG));
1037 }
1038
1039 /** Allocate and build a CFP file name from a path.
1040 @param[in] path_in Full path to the filename
1041 @return own: file name; must be freed by ut::free() */
1042 [[nodiscard]] static char *make_cfp(const std::string &path_in) {
1043 return (make(path_in, "", CFP));
1044 }
1045
1046 /** Allocate and build a file name from a path, a table or
1047 tablespace name and a suffix.
1048 @param[in] path_in nullptr or the directory path or
1049 the full path and filename
1050 @param[in] name_in nullptr if path is full, or
1051 Table/Tablespace name
1052 @return own: file name; must be freed by ut::free() */
1053 [[nodiscard]] static char *make_ibd(const std::string &path_in,
1054 const std::string &name_in) {
1055 return (make(path_in, name_in, IBD));
1056 }
1057
1058 /** Allocate and build a file name from a path, a table or
1059 tablespace name and a suffix.
1060 @param[in] name_in Table/Tablespace name
1061 @return own: file name; must be freed by ut::free() */
1062 [[nodiscard]] static char *make_ibd_from_table_name(
1063 const std::string &name_in) {
1064 return (make("", name_in, IBD));
1065 }
1066
1067 /** Create an IBD path name after replacing the basename in an old path
1068 with a new basename. The old_path is a full path name including the
1069 extension. The tablename is in the normal form "schema/tablename".
1070 @param[in] path_in Pathname
1071 @param[in] name_in Contains new base name
1072 @param[in] extn File extension
1073 @return new full pathname */
1074 [[nodiscard]] static std::string make_new_path(const std::string &path_in,
1075 const std::string &name_in,
1076 ib_file_suffix extn);
1077
1078 /** Parse file-per-table file name and build Innodb dictionary table name.
1079 @param[in] file_path File name with complete path
1080 @param[in] extn File extension
1081 @param[out] dict_name Innodb dictionary table name
1082 @return true, if successful. */
1083 static bool parse_file_path(const std::string &file_path, ib_file_suffix extn,
1084 std::string &dict_name);
1085
1086 /** This function reduces a null-terminated full remote path name
1087 into the path that is sent by MySQL for DATA DIRECTORY clause.
1088 It replaces the 'databasename/tablename.ibd' found at the end of the
1089 path with just 'tablename'.
1090
1091 Since the result is always smaller than the path sent in, no new
1092 memory is allocated. The caller should allocate memory for the path
1093 sent in. This function manipulates that path in place. If the path
1094 format is not as expected, set data_dir_path to "" and return.
1095
1096 The result is used to inform a SHOW CREATE TABLE command.
1097 @param[in,out] data_dir_path Full path/data_dir_path */
1098 static void make_data_dir_path(char *data_dir_path);
1099
1100#ifndef UNIV_HOTBACKUP
1101 /** Check if the filepath provided is in a valid placement.
1102 This routine is run during file discovery at startup.
1103 1) File-per-table must be in a dir named for the schema.
1104 2) File-per-table must not be in the datadir.
1105 3) General tablespace must not be under the datadir.
1106 @param[in] space_name tablespace name
1107 @param[in] space_id tablespace ID
1108 @param[in] fsp_flags tablespace flags
1109 @param[in] path scanned realpath to an existing file to validate
1110 @retval true if the filepath is a valid datafile location */
1111 static bool is_valid_location(const char *space_name, space_id_t space_id,
1112 uint32_t fsp_flags, const std::string &path);
1113
1114 /** Check if the implicit filepath is immediately within a dir named for
1115 the schema.
1116 @param[in] space_name tablespace name
1117 @param[in] path scanned realpath to an existing file to validate
1118 @retval true if the filepath is valid */
1119 static bool is_valid_location_within_db(const char *space_name,
1120 const std::string &path);
1121
1122 /** Convert filename to the file system charset format.
1123 @param[in,out] name Filename to convert */
1124 static void convert_to_filename_charset(std::string &name);
1125
1126 /** Convert to lower case using the file system charset.
1127 @param[in,out] path Filepath to convert */
1128 static void convert_to_lower_case(std::string &path);
1129
1130#endif /* !UNIV_HOTBACKUP */
1131
1132 protected:
1133 /** Path to a file or directory. */
1134 std::string m_path;
1135
1136 /** A full absolute path to the same file. */
1137 std::string m_abs_path;
1138};
1139
1140/** The MySQL server --datadir value */
1142
1143/** The MySQL server --innodb-undo-directory value */
1145
1146/** The undo path is different from any other known directory. */
1147extern bool MySQL_undo_path_is_unique;
1148
1149/** Initial size of a single-table tablespace in pages */
1150constexpr size_t FIL_IBD_FILE_INITIAL_SIZE = 7;
1151constexpr size_t FIL_IBT_FILE_INITIAL_SIZE = 5;
1152
1153/** An empty tablespace (CREATE TABLESPACE) has minimum
1154of 4 pages and an empty CREATE TABLE (file_per_table) has 6 pages.
1155Minimum of these two is 4 */
1157
1158/** 'null' (undefined) page offset in the context of file spaces */
1159constexpr page_no_t FIL_NULL = std::numeric_limits<page_no_t>::max();
1160
1161/** Maximum Page Number, one less than FIL_NULL */
1162constexpr page_no_t PAGE_NO_MAX = std::numeric_limits<page_no_t>::max() - 1;
1163
1164/** Unknown space id */
1165constexpr space_id_t SPACE_UNKNOWN = std::numeric_limits<space_id_t>::max();
1166
1167/* Space address data type; this is intended to be used when
1168addresses accurate to a byte are stored in file pages. If the page part
1169of the address is FIL_NULL, the address is considered undefined. */
1170
1171/** 'type' definition in C: an address stored in a file page is a
1172string of bytes */
1174
1175/** File space address */
1177 /* Default constructor */
1179
1180 /** Constructor
1181 @param[in] p Logical page number
1182 @param[in] boff Offset within the page */
1183 fil_addr_t(page_no_t p, uint32_t boff) : page(p), boffset(boff) {}
1184
1185 /** Compare to instances
1186 @param[in] rhs Instance to compare with
1187 @return true if the page number and page offset are equal */
1188 bool is_equal(const fil_addr_t &rhs) const {
1189 return (page == rhs.page && boffset == rhs.boffset);
1190 }
1191
1192 /** Check if the file address is null.
1193 @return true if null */
1194 bool is_null() const { return (page == FIL_NULL && boffset == 0); }
1195
1196 /** Print a string representation.
1197 @param[in,out] out Stream to write to */
1198 std::ostream &print(std::ostream &out) const {
1199 out << "[fil_addr_t: page=" << page << ", boffset=" << boffset << "]";
1200
1201 return (out);
1202 }
1203
1204 /** Page number within a space */
1206
1207 /** Byte offset within the page */
1208 uint32_t boffset;
1209};
1210
1211/* For printing fil_addr_t to a stream.
1212@param[in,out] out Stream to write to
1213@param[in] obj fil_addr_t instance to write */
1214inline std::ostream &operator<<(std::ostream &out, const fil_addr_t &obj) {
1215 return (obj.print(out));
1216}
1217
1218/** The null file address */
1220
1221using page_type_t = uint16_t;
1222
1223/** File page types (values of FIL_PAGE_TYPE) @{ */
1224/** B-tree node */
1225constexpr page_type_t FIL_PAGE_INDEX = 17855;
1226
1227/** R-tree node */
1228constexpr page_type_t FIL_PAGE_RTREE = 17854;
1229
1230/** Tablespace SDI Index page */
1231constexpr page_type_t FIL_PAGE_SDI = 17853;
1232
1233/** This page type is unused. */
1235
1236/** Undo log page */
1238
1239/** Index node */
1241
1242/** Insert buffer free list */
1244
1245/* File page types introduced in MySQL/InnoDB 5.1.7 */
1246/** Freshly allocated page */
1248
1249/** Insert buffer bitmap */
1251
1252/** System page */
1254
1255/** Transaction system data */
1257
1258/** File space header */
1260
1261/** Extent descriptor page */
1263
1264/** Uncompressed BLOB page */
1266
1267/** First compressed BLOB page */
1269
1270/** Subsequent compressed BLOB page */
1272
1273/** In old tablespaces, garbage in FIL_PAGE_TYPE is replaced with
1274this value when flushing pages. */
1276
1277/** Compressed page */
1279
1280/** Encrypted page */
1282
1283/** Compressed and Encrypted page */
1285
1286/** Encrypted R-tree page */
1288
1289/** Uncompressed SDI BLOB page */
1291
1292/** Compressed SDI BLOB page */
1294
1295/** Legacy doublewrite buffer page. */
1297
1298/** Rollback Segment Array page */
1300
1301/** Index pages of uncompressed LOB */
1303
1304/** Data pages of uncompressed LOB */
1306
1307/** The first page of an uncompressed LOB */
1309
1310/** The first page of a compressed LOB */
1312
1313/** Data pages of compressed LOB */
1315
1316/** Index pages of compressed LOB. This page contains an array of
1317z_index_entry_t objects.*/
1319
1320/** Fragment pages of compressed LOB. */
1322
1323/** Index pages of fragment pages (compressed LOB). */
1325
1326/** Note the highest valid non-index page_type_t. */
1328
1329/** Check whether the page type is index (Btree or Rtree or SDI) type */
1330inline bool fil_page_type_is_index(page_type_t page_type) {
1331 return page_type == FIL_PAGE_INDEX || page_type == FIL_PAGE_SDI ||
1332 page_type == FIL_PAGE_RTREE;
1333}
1334
1335/** Get the file page type.
1336@param[in] page File page
1337@return page type */
1339 return (static_cast<page_type_t>(mach_read_from_2(page + FIL_PAGE_TYPE)));
1340}
1341
1342/** Check whether the page is index page (either regular Btree index or Rtree
1343index.
1344@param[in] page page frame whose page type is to be checked. */
1345inline bool fil_page_index_page_check(const byte *page) {
1347 const bool is_idx = fil_page_type_is_index(type);
1348 return is_idx;
1349}
1350
1351/** @} */
1352
1353/** Number of pending tablespace flushes */
1354extern std::atomic<std::uint64_t> fil_n_pending_tablespace_flushes;
1355
1356/** Number of files currently open */
1357extern std::atomic_size_t fil_n_files_open;
1358
1359/** Look up a tablespace.
1360The caller should hold an InnoDB table lock or a MDL that prevents
1361the tablespace from being dropped during the operation,
1362or the caller should be in single-threaded crash recovery mode
1363(no user connections that could drop tablespaces).
1364If this is not the case, fil_space_acquire() and fil_space_release()
1365should be used instead.
1366@param[in] space_id Tablespace ID
1367@return tablespace, or nullptr if not found */
1368[[nodiscard]] fil_space_t *fil_space_get(space_id_t space_id);
1369
1370#ifndef UNIV_HOTBACKUP
1371/** Returns the latch of a file space.
1372@param[in] space_id Tablespace ID
1373@return latch protecting storage allocation */
1374[[nodiscard]] rw_lock_t *fil_space_get_latch(space_id_t space_id);
1375
1376#ifdef UNIV_DEBUG
1377/** Gets the type of a file space.
1378@param[in] space_id Tablespace ID
1379@return file type */
1380[[nodiscard]] fil_type_t fil_space_get_type(space_id_t space_id);
1381#endif /* UNIV_DEBUG */
1382
1383/** Note that a tablespace has been imported.
1384It is initially marked as FIL_TYPE_IMPORT so that no logging is
1385done during the import process when the space ID is stamped to each page.
1386Now we change it to FIL_TYPE_TABLESPACE to start redo and undo logging.
1387NOTE: temporary tablespaces are never imported.
1388@param[in] space_id Tablespace ID */
1389void fil_space_set_imported(space_id_t space_id);
1390#endif /* !UNIV_HOTBACKUP */
1391
1392/** Attach a file to a tablespace. File must be closed.
1393@param[in] name file name (file must be closed)
1394@param[in] size file size in database blocks, rounded
1395 downwards to an integer
1396@param[in,out] space space where to append
1397@param[in] is_raw true if a raw device or a raw disk partition
1398@param[in] max_pages maximum number of pages in file
1399@return pointer to the file name
1400@retval nullptr if error */
1401[[nodiscard]] char *fil_node_create(const char *name, page_no_t size,
1402 fil_space_t *space, bool is_raw,
1403 page_no_t max_pages = PAGE_NO_MAX);
1404
1405/** Create a space memory object and put it to the fil_system hash table.
1406The tablespace name is independent from the tablespace file-name.
1407Error messages are issued to the server log.
1408@param[in] name Tablespace name
1409@param[in] space_id Tablespace ID
1410@param[in] flags Tablespace flags
1411@param[in] purpose Tablespace purpose
1412@return pointer to created tablespace, to be filled in with fil_node_create()
1413@retval nullptr on failure (such as when the same tablespace exists) */
1414[[nodiscard]] fil_space_t *fil_space_create(const char *name,
1415 space_id_t space_id, uint32_t flags,
1416 fil_type_t purpose);
1417
1418/** Assigns a new space id for a new single-table tablespace. This works
1419simply by incrementing the global counter. If 4 billion id's is not enough,
1420we may need to recycle id's.
1421@param[out] space_id Set this to the new tablespace ID
1422@return true if assigned, false if not */
1423[[nodiscard]] bool fil_assign_new_space_id(space_id_t *space_id);
1424
1425/** Returns the path from the first fil_node_t found with this space ID.
1426The caller is responsible for freeing the memory allocated here for the
1427value returned.
1428@param[in] space_id Tablespace ID
1429@return own: A copy of fil_node_t::path, nullptr if space ID is zero
1430 or not found. */
1431[[nodiscard]] char *fil_space_get_first_path(space_id_t space_id);
1432
1433/** Returns the size of the space in pages. The tablespace must be cached
1434in the memory cache.
1435@param[in] space_id Tablespace ID
1436@return space size, 0 if space not found */
1437[[nodiscard]] page_no_t fil_space_get_size(space_id_t space_id);
1438
1439/** Returns the size of an undo space just after it was initialized.
1440@param[in] space_id Tablespace ID
1441@return initial space size, 0 if space not found */
1443
1444/** This is called for an undo tablespace after it has been initialized
1445or opened. It sets the minimum size in pages at which it should be truncated
1446and the number of pages that it should be extended. An undo tablespace is
1447extended by larger amounts than normal tablespaces. It starts at 16Mb and
1448is increased during aggressive growth and decreased when the growth is slower.
1449@param[in] space_id Tablespace ID
1450@param[in] use_current If true, use the current size in pages as the initial
1451 size. If false, use UNDO_INITIAL_SIZE_IN_PAGES. */
1452void fil_space_set_undo_size(space_id_t space_id, bool use_current);
1453
1454/** Returns the flags of the space. The tablespace must be cached
1455in the memory cache.
1456@param[in] space_id Tablespace ID for which to get the flags
1457@return flags, ULINT_UNDEFINED if space not found */
1458[[nodiscard]] uint32_t fil_space_get_flags(space_id_t space_id);
1459
1460/** Sets the flags of the tablespace. The tablespace must be locked
1461in MDL_EXCLUSIVE MODE.
1462@param[in] space tablespace in-memory struct
1463@param[in] flags tablespace flags */
1464void fil_space_set_flags(fil_space_t *space, uint32_t flags);
1465
1466/** Open each file of a tablespace if not already open.
1467@param[in] space_id Tablespace ID
1468@retval true if all file nodes were opened
1469@retval false on failure */
1470[[nodiscard]] bool fil_space_open(space_id_t space_id);
1471
1472/** Close each file of a tablespace if open.
1473@param[in] space_id Tablespace ID */
1474void fil_space_close(space_id_t space_id);
1475
1476/** Returns the page size of the space and whether it is compressed or not.
1477The tablespace must be cached in the memory cache.
1478@param[in] space_id Tablespace ID
1479@param[out] found true if tablespace was found
1480@return page size */
1481[[nodiscard]] const page_size_t fil_space_get_page_size(space_id_t space_id,
1482 bool *found);
1483
1484/** Initializes the tablespace memory cache.
1485@param[in] max_n_open Maximum number of open files */
1486void fil_init(ulint max_n_open);
1487
1488/** Changes the maximum opened files limit.
1489@param[in, out] new_max_open_files New value for the open files limit. If the
1490limit cannot be changed, the value is changed to a minimum value recommended.
1491@return true if the new limit was set. */
1492bool fil_open_files_limit_update(size_t &new_max_open_files);
1493
1494/** Initializes the tablespace memory cache. */
1495void fil_close();
1496
1497/** Opens all log files and system tablespace data files.
1498They stay open until the database server shutdown. This should be called
1499at a server startup after the space objects for the log and the system
1500tablespace have been created. The purpose of this operation is to make
1501sure we never run out of file descriptors if we need to read from the
1502insert buffer or to write to the log. */
1504
1505/** Closes all open files. There must not be any pending i/o's or not flushed
1506modifications in the files. */
1507void fil_close_all_files();
1508
1509/** Iterate over the files in all the tablespaces. */
1511 public:
1512 using Function = std::function<dberr_t(fil_node_t *)>;
1513
1514 /** For each data file.
1515 @param[in] f Callback */
1516 template <typename F>
1517 static dberr_t for_each_file(F &&f) {
1518 return iterate([=](fil_node_t *file) { return (f(file)); });
1519 }
1520
1521 /** Iterate through all persistent tablespace files (FIL_TYPE_TABLESPACE)
1522 returning the nodes via callback function f.
1523 @param[in] f Callback
1524 @return any error returned by the callback function. */
1525 static dberr_t iterate(Function &&f);
1526};
1527
1528/** Sets the max tablespace id counter if the given number is bigger than the
1529previous value.
1530@param[in] max_id Maximum known tablespace ID */
1532
1533#ifndef UNIV_HOTBACKUP
1534
1535/** Write the flushed LSN to the page header of the first page in the
1536system tablespace.
1537@param[in] lsn Flushed LSN
1538@return DB_SUCCESS or error number */
1539[[nodiscard]] dberr_t fil_write_flushed_lsn(lsn_t lsn);
1540
1541#else /* !UNIV_HOTBACKUP */
1542/** Frees a space object from the tablespace memory cache.
1543Closes a tablespaces' files but does not delete them.
1544There must not be any pending i/o's or flushes on the files.
1545@param[in] space_id Tablespace ID
1546@return true if success */
1547bool meb_fil_space_free(space_id_t space_id);
1548
1549/** Extends all tablespaces to the size stored in the space header. During the
1550mysqlbackup --apply-log phase we extended the spaces on-demand so that log
1551records could be applied, but that may have left spaces still too small
1552compared to the size stored in the space header. */
1553void meb_extend_tablespaces_to_stored_len();
1554
1555/** Process a file name passed as an input
1556@param[in] name absolute path of tablespace file
1557@param[in] space_id the tablespace ID */
1558void meb_fil_name_process(const char *name, space_id_t space_id);
1559
1560#endif /* !UNIV_HOTBACKUP */
1561
1562/** Acquire a tablespace when it could be dropped concurrently.
1563Used by background threads that do not necessarily hold proper locks
1564for concurrency control.
1565@param[in] space_id Tablespace ID
1566@return the tablespace, or nullptr if missing or being deleted */
1567[[nodiscard]] fil_space_t *fil_space_acquire(space_id_t space_id);
1568
1569/** Acquire a tablespace that may not exist.
1570Used by background threads that do not necessarily hold proper locks
1571for concurrency control.
1572@param[in] space_id Tablespace ID
1573@return the tablespace, or nullptr if missing or being deleted */
1574[[nodiscard]] fil_space_t *fil_space_acquire_silent(space_id_t space_id);
1575
1576/** Release a tablespace acquired with fil_space_acquire().
1577@param[in,out] space Tablespace to release */
1578void fil_space_release(fil_space_t *space);
1579
1580/** Fetch the file name opened for a space_id from the file map.
1581@param[in] space_id tablespace ID
1582@param[out] name the scanned filename
1583@return true if the space_id is found. The name is set to an
1584empty string if the space_id is not found. */
1585bool fil_system_get_file_by_space_id(space_id_t space_id, std::string &name);
1586
1587/** Fetch the file name opened for an undo space number from the file map.
1588@param[in] space_num Undo tablespace Number
1589@param[out] space_id Undo tablespace ID
1590@param[out] name the scanned filename
1591@return true if the space_num was found. The name is set to an
1592empty string if the space_num is not found. */
1594 space_id_t &space_id, std::string &name);
1595
1596/** Truncate the tablespace to needed size.
1597@param[in] space_id Tablespace ID to truncate
1598@param[in] size_in_pages Truncate size.
1599@return true if truncate was successful. */
1600[[nodiscard]] bool fil_truncate_tablespace(space_id_t space_id,
1601 page_no_t size_in_pages);
1602
1603/** Closes a single-table tablespace. The tablespace must be cached in the
1604memory cache. Free all pages used by the tablespace.
1605@param[in] space_id Tablespace ID
1606@return DB_SUCCESS or error */
1607[[nodiscard]] dberr_t fil_close_tablespace(space_id_t space_id);
1608
1609/** Discards a single-table tablespace. The tablespace must be cached in the
1610memory cache. Discarding is like deleting a tablespace, but
1611
1612 1. We do not drop the table from the data dictionary;
1613
1614 2. We remove all insert buffer entries for the tablespace immediately;
1615 in DROP TABLE they are only removed gradually in the background;
1616
1617 3. When the user does IMPORT TABLESPACE, the tablespace will have the
1618 same id as it originally had.
1619
1620 4. Free all the pages in use by the tablespace if rename=true.
1621@param[in] space_id Tablespace ID
1622@return DB_SUCCESS or error */
1623[[nodiscard]] dberr_t fil_discard_tablespace(space_id_t space_id);
1624
1625/** Test if a tablespace file can be renamed to a new filepath by checking
1626if that the old filepath exists and the new filepath does not exist.
1627@param[in] space_id Tablespace ID
1628@param[in] old_path Old filepath
1629@param[in] new_path New filepath
1630@param[in] is_discarded Whether the tablespace is discarded
1631@return innodb error code */
1632[[nodiscard]] dberr_t fil_rename_tablespace_check(space_id_t space_id,
1633 const char *old_path,
1634 const char *new_path,
1635 bool is_discarded);
1636
1637/** Rename a single-table tablespace.
1638The tablespace must exist in the memory cache.
1639@param[in] space_id Tablespace ID
1640@param[in] old_path Old file name
1641@param[in] new_name New tablespace name in the schema/name format
1642@param[in] new_path_in New file name, or nullptr if it is located in
1643the normal data directory
1644@return InnoDB error code */
1645[[nodiscard]] dberr_t fil_rename_tablespace(space_id_t space_id,
1646 const char *old_path,
1647 const char *new_name,
1648 const char *new_path_in);
1649
1650/** Create an IBD tablespace file.
1651@param[in] space_id Tablespace ID
1652@param[in] name Tablespace name in dbname/tablename format.
1653 For general tablespaces, the 'dbname/' part
1654 may be missing.
1655@param[in] path Path and filename of the datafile to create.
1656@param[in] flags Tablespace flags
1657@param[in] size Initial size of the tablespace file in pages,
1658 must be >= FIL_IBD_FILE_INITIAL_SIZE
1659@return DB_SUCCESS or error code */
1660[[nodiscard]] dberr_t fil_ibd_create(space_id_t space_id, const char *name,
1661 const char *path, uint32_t flags,
1662 page_no_t size);
1663
1664/** Create a session temporary tablespace (IBT) file.
1665@param[in] space_id Tablespace ID
1666@param[in] name Tablespace name
1667@param[in] path Path and filename of the datafile to create.
1668@param[in] flags Tablespace flags
1669@param[in] size Initial size of the tablespace file in pages,
1670 must be >= FIL_IBT_FILE_INITIAL_SIZE
1671@return DB_SUCCESS or error code */
1672[[nodiscard]] dberr_t fil_ibt_create(space_id_t space_id, const char *name,
1673 const char *path, uint32_t flags,
1674 page_no_t size);
1675
1676/** Deletes an IBD or IBU tablespace.
1677The tablespace must be cached in the memory cache. This will delete the
1678datafile, fil_space_t & fil_node_t entries from the file_system_t cache.
1679@param[in] space_id Tablespace ID
1680@param[in] buf_remove Specify the action to take on the pages
1681for this table in the buffer pool.
1682@return DB_SUCCESS, DB_TABLESPCE_NOT_FOUND or DB_IO_ERROR */
1683[[nodiscard]] dberr_t fil_delete_tablespace(space_id_t space_id,
1684 buf_remove_t buf_remove);
1685
1686/** Open a single-table tablespace and optionally do some validation such
1687as checking that the space id is correct. If the file is already open,
1688the validation will be done before reporting success.
1689If not successful, print an error message to the error log.
1690This function is used to open a tablespace when we start up mysqld,
1691and also in IMPORT TABLESPACE.
1692NOTE that we assume this operation is used either at the database startup
1693or under the protection of the dictionary mutex, so that two users cannot
1694race here.
1695
1696The fil_node_t::handle will not be left open.
1697
1698@param[in] validate whether we should validate the tablespace
1699 (read the first page of the file and
1700 check that the space id in it matches id)
1701@param[in] purpose FIL_TYPE_TABLESPACE or FIL_TYPE_TEMPORARY
1702@param[in] space_id Tablespace ID
1703@param[in] flags tablespace flags
1704@param[in] space_name tablespace name of the datafile
1705 If file-per-table, it is the table name in the
1706 databasename/tablename format
1707@param[in] path_in expected filepath, usually read from dictionary
1708@param[in] strict whether to report error when open ibd failed
1709@param[in] old_space whether it is a 5.7 tablespace opening
1710 by upgrade
1711@return DB_SUCCESS or error code */
1712[[nodiscard]] dberr_t fil_ibd_open(bool validate, fil_type_t purpose,
1713 space_id_t space_id, uint32_t flags,
1714 const char *space_name, const char *path_in,
1715 bool strict, bool old_space);
1716
1717/** Returns true if a matching tablespace exists in the InnoDB tablespace
1718memory cache.
1719@param[in] space_id Tablespace ID
1720@param[in] name Tablespace name used in space_create().
1721@param[in] print_err Print detailed error information to the
1722 error log if a matching tablespace is
1723 not found from memory.
1724@param[in] adjust_space Whether to adjust space id on mismatch
1725@return true if a matching tablespace exists in the memory cache */
1726[[nodiscard]] bool fil_space_exists_in_mem(space_id_t space_id,
1727 const char *name, bool print_err,
1728 bool adjust_space);
1729
1730/** Extends all tablespaces to the size stored in the space header. During the
1731mysqlbackup --apply-log phase we extended the spaces on-demand so that log
1732records could be appllied, but that may have left spaces still too small
1733compared to the size stored in the space header. */
1735
1736/** Try to extend a tablespace if it is smaller than the specified size.
1737@param[in,out] space Tablespace ID
1738@param[in] size desired size in pages
1739@return whether the tablespace is at least as big as requested */
1740[[nodiscard]] bool fil_space_extend(fil_space_t *space, page_no_t size);
1741
1742/** Tries to reserve free extents in a file space.
1743@param[in] space_id Tablespace ID
1744@param[in] n_free_now Number of free extents now
1745@param[in] n_to_reserve How many one wants to reserve
1746@return true if succeed */
1747[[nodiscard]] bool fil_space_reserve_free_extents(space_id_t space_id,
1748 ulint n_free_now,
1749 ulint n_to_reserve);
1750
1751/** Releases free extents in a file space.
1752@param[in] space_id Tablespace ID
1753@param[in] n_reserved How many were reserved */
1754void fil_space_release_free_extents(space_id_t space_id, ulint n_reserved);
1755
1756/** Gets the number of reserved extents. If the database is silent, this
1757number should be zero.
1758@param[in] space_id Tablespace ID
1759@return the number of reserved extents */
1760[[nodiscard]] ulint fil_space_get_n_reserved_extents(space_id_t space_id);
1761
1762/** Read or write data from a file.
1763@param[in] type IO context
1764@param[in] sync If true then do synchronous IO
1765@param[in] page_id page id
1766@param[in] page_size page size
1767@param[in] byte_offset remainder of offset in bytes; in aio this
1768 must be divisible by the OS block size
1769@param[in] len how many bytes to read or write; this must
1770 not cross a file boundary; in AIO this must
1771 be a block size multiple
1772@param[in,out] buf buffer where to store read data or from where
1773 to write; in AIO this must be appropriately
1774 aligned
1775@param[in] message message for AIO handler if !sync, else ignored
1776@return error code
1777@retval DB_SUCCESS on success
1778@retval DB_TABLESPACE_DELETED if the tablespace does not exist */
1779[[nodiscard]] dberr_t fil_io(const IORequest &type, bool sync,
1780 const page_id_t &page_id,
1781 const page_size_t &page_size, ulint byte_offset,
1782 ulint len, void *buf, void *message);
1783
1784/** Waits for an AIO operation to complete. This function is used to write the
1785handler for completed requests. The aio array of pending requests is divided
1786into segments (see os0file.cc for more info). The thread specifies which
1787segment it wants to wait for.
1788@param[in] segment The number of the segment in the AIO array
1789 to wait for */
1790void fil_aio_wait(ulint segment);
1791
1792/** Flushes to disk possible writes cached by the OS. If the space does
1793not exist or is being dropped, does not do anything.
1794@param[in] space_id Tablespace ID */
1795void fil_flush(space_id_t space_id);
1796
1797/** Flush to disk the writes in file spaces possibly cached by the OS
1798(note: spaces of type FIL_TYPE_TEMPORARY are skipped) */
1800
1801#ifdef UNIV_DEBUG
1802/** Checks the consistency of the tablespace cache.
1803@return true if ok */
1804bool fil_validate();
1805#endif /* UNIV_DEBUG */
1806
1807/** Returns true if file address is undefined.
1808@param[in] addr File address to check
1809@return true if undefined */
1810[[nodiscard]] bool fil_addr_is_null(const fil_addr_t &addr);
1811
1812/** Get the predecessor of a file page.
1813@param[in] page File page
1814@return FIL_PAGE_PREV */
1815[[nodiscard]] page_no_t fil_page_get_prev(const byte *page);
1816
1817/** Get the successor of a file page.
1818@param[in] page File page
1819@return FIL_PAGE_NEXT */
1820[[nodiscard]] page_no_t fil_page_get_next(const byte *page);
1821
1822/** Sets the file page type.
1823@param[in,out] page File page
1824@param[in] type File page type to set */
1825void fil_page_set_type(byte *page, ulint type);
1826
1827/** Reset the page type.
1828Data files created before MySQL 5.1 may contain garbage in FIL_PAGE_TYPE.
1829In MySQL 3.23.53, only undo log pages and index pages were tagged.
1830Any other pages were written with uninitialized bytes in FIL_PAGE_TYPE.
1831@param[in] page_id Page number
1832@param[in,out] page Page with invalid FIL_PAGE_TYPE
1833@param[in] type Expected page type
1834@param[in,out] mtr Mini-transaction */
1835void fil_page_reset_type(const page_id_t &page_id, byte *page, ulint type,
1836 mtr_t *mtr);
1837
1838/** Check (and if needed, reset) the page type.
1839Data files created before MySQL 5.1 may contain
1840garbage in the FIL_PAGE_TYPE field.
1841In MySQL 3.23.53, only undo log pages and index pages were tagged.
1842Any other pages were written with uninitialized bytes in FIL_PAGE_TYPE.
1843@param[in] page_id Page number
1844@param[in,out] page Page with possibly invalid FIL_PAGE_TYPE
1845@param[in] type Expected page type
1846@param[in,out] mtr Mini-transaction */
1847inline void fil_page_check_type(const page_id_t &page_id, byte *page,
1848 ulint type, mtr_t *mtr) {
1849 ulint page_type = fil_page_get_type(page);
1850
1851 if (page_type != type) {
1852 fil_page_reset_type(page_id, page, type, mtr);
1853 }
1854}
1855
1856/** Check (and if needed, reset) the page type.
1857Data files created before MySQL 5.1 may contain
1858garbage in the FIL_PAGE_TYPE field.
1859In MySQL 3.23.53, only undo log pages and index pages were tagged.
1860Any other pages were written with uninitialized bytes in FIL_PAGE_TYPE.
1861@param[in,out] block Block with possibly invalid FIL_PAGE_TYPE
1862@param[in] type Expected page type
1863@param[in,out] mtr Mini-transaction */
1864#define fil_block_check_type(block, type, mtr) \
1865 fil_page_check_type(block->page.id, block->frame, type, mtr)
1866
1867#ifdef UNIV_DEBUG
1868/** Increase redo skipped count for a tablespace.
1869@param[in] space_id Tablespace ID */
1871
1872/** Decrease redo skipped count for a tablespace.
1873@param[in] space_id Tablespace ID */
1875
1876/** Check whether a single-table tablespace is redo skipped.
1877@param[in] space_id Tablespace ID
1878@return true if redo skipped */
1879[[nodiscard]] bool fil_space_is_redo_skipped(space_id_t space_id);
1880#endif /* UNIV_DEBUG */
1881
1882/** Delete the tablespace file and any related files like .cfg.
1883This should not be called for temporary tables.
1884@param[in] path File path of the IBD tablespace
1885@return true on success */
1886[[nodiscard]] bool fil_delete_file(const char *path);
1887
1888/** Callback functor. */
1890 /** Default constructor */
1892
1893 virtual ~PageCallback() UNIV_NOTHROW = default;
1894
1895 /** Called for page 0 in the tablespace file at the start.
1896 @param file_size size of the file in bytes
1897 @param block contents of the first page in the tablespace file
1898 @retval DB_SUCCESS or error code. */
1899 [[nodiscard]] virtual dberr_t init(os_offset_t file_size,
1900 const buf_block_t *block) UNIV_NOTHROW = 0;
1901
1902 /** Called for every page in the tablespace. If the page was not
1903 updated then its state must be set to BUF_PAGE_NOT_USED. For
1904 compressed tables the page descriptor memory will be at offset:
1905 block->frame + UNIV_PAGE_SIZE;
1906 @param offset physical offset within the file
1907 @param block block read from file, note it is not from the buffer pool
1908 @retval DB_SUCCESS or error code. */
1909 [[nodiscard]] virtual dberr_t operator()(os_offset_t offset,
1910 buf_block_t *block) UNIV_NOTHROW = 0;
1911
1912 /** Set the name of the physical file and the file handle that is used
1913 to open it for the file that is being iterated over.
1914 @param filename then physical name of the tablespace file.
1915 @param file OS file handle */
1917 m_file = file;
1919 }
1920
1921 /** @return the space id of the tablespace */
1922 [[nodiscard]] virtual space_id_t get_space_id() const UNIV_NOTHROW = 0;
1923
1924 /**
1925 @retval the space flags of the tablespace being iterated over */
1926 [[nodiscard]] virtual ulint get_space_flags() const UNIV_NOTHROW = 0;
1927
1928 /** Set the tablespace table size.
1929 @param[in] page a page belonging to the tablespace */
1931
1932 /** The compressed page size
1933 @return the compressed page size */
1934 [[nodiscard]] const page_size_t &get_page_size() const {
1935 return (m_page_size);
1936 }
1937
1938 /** The tablespace page size. */
1940
1941 /** File handle to the tablespace */
1943
1944 /** Physical file path. */
1945 const char *m_filepath;
1946
1947 // Disable copying
1949 PageCallback(const PageCallback &) = delete;
1951};
1952
1953/** Iterate over all the pages in the tablespace.
1954@param[in] encryption_metadata the encryption metadata to use for reading
1955@param[in] table the table definition in the server
1956@param[in] n_io_buffers number of blocks to read and write together
1957@param[in] compression_type compression type if compression is enabled,
1958else Compression::Type::NONE
1959@param[in,out] callback functor that will do the page updates
1960@return DB_SUCCESS or error code */
1961[[nodiscard]] dberr_t fil_tablespace_iterate(
1962 const Encryption_metadata &encryption_metadata, dict_table_t *table,
1963 ulint n_io_buffers, Compression::Type compression_type,
1964 PageCallback &callback);
1965
1966/** Looks for a pre-existing fil_space_t with the given tablespace ID
1967and, if found, returns the name and filepath in newly allocated buffers
1968that the caller must free.
1969@param[in] space_id The tablespace ID to search for.
1970@param[out] name Name of the tablespace found.
1971@param[out] filepath The filepath of the first datafile for the
1972tablespace.
1973@return true if tablespace is found, false if not. */
1974[[nodiscard]] bool fil_space_read_name_and_filepath(space_id_t space_id,
1975 char **name,
1976 char **filepath);
1977
1978/** Convert a file name to a tablespace name. Strip the file name
1979prefix and suffix, leaving only databasename/tablename.
1980@param[in] filename directory/databasename/tablename.ibd
1981@return database/tablename string, to be freed with ut::free() */
1982[[nodiscard]] char *fil_path_to_space_name(const char *filename);
1983
1984/** Returns the space ID based on the tablespace name.
1985The tablespace must be found in the tablespace memory cache.
1986This call is made from external to this module, so the mutex is not owned.
1987@param[in] name Tablespace name
1988@return space ID if tablespace found, SPACE_UNKNOWN if space not. */
1989[[nodiscard]] space_id_t fil_space_get_id_by_name(const char *name);
1990
1991/** Check if swapping two .ibd files can be done without failure
1992@param[in] old_table old table
1993@param[in] new_table new table
1994@param[in] tmp_name temporary table name
1995@return innodb error code */
1996[[nodiscard]] dberr_t fil_rename_precheck(const dict_table_t *old_table,
1997 const dict_table_t *new_table,
1998 const char *tmp_name);
1999
2000/** Set the compression type for the tablespace
2001@param[in] space_id Space ID of the tablespace
2002@param[in] algorithm Text representation of the algorithm
2003@return DB_SUCCESS or error code */
2004[[nodiscard]] dberr_t fil_set_compression(space_id_t space_id,
2005 const char *algorithm);
2006
2007/** Get the compression algorithm for a tablespace.
2008@param[in] space_id Space ID to check
2009@return the compression algorithm */
2010[[nodiscard]] Compression::Type fil_get_compression(space_id_t space_id);
2011
2012/** Set encryption information for IORequest.
2013@param[in,out] req_type IO request
2014@param[in] page_id page id
2015@param[in] space table space */
2016void fil_io_set_encryption(IORequest &req_type, const page_id_t &page_id,
2017 fil_space_t *space);
2018
2019/** Set the encryption type for the tablespace
2020@param[in] space_id Space ID of tablespace for which to set
2021@param[in] algorithm Encryption algorithm
2022@param[in] key Encryption key
2023@param[in] iv Encryption iv
2024@return DB_SUCCESS or error code */
2025[[nodiscard]] dberr_t fil_set_encryption(space_id_t space_id,
2026 Encryption::Type algorithm, byte *key,
2027 byte *iv);
2028
2029/** Set the autoextend_size attribute for the tablespace
2030@param[in] space_id Space ID of tablespace for which to set
2031@param[in] autoextend_size Value of autoextend_size attribute
2032@return DB_SUCCESS or error code */
2033dberr_t fil_set_autoextend_size(space_id_t space_id, uint64_t autoextend_size);
2034
2035/** Reset the encryption type for the tablespace
2036@param[in] space_id Space ID of tablespace for which to set
2037@return DB_SUCCESS or error code */
2038[[nodiscard]] dberr_t fil_reset_encryption(space_id_t space_id);
2039
2040/** Rotate the tablespace keys by new master key.
2041@return the number of tablespaces that failed to rotate. */
2042[[nodiscard]] size_t fil_encryption_rotate();
2043
2044/** Roencrypt the tablespace keys by current master key. */
2045void fil_encryption_reencrypt(std::vector<space_id_t> &sid_vector);
2046
2047/** During crash recovery, open a tablespace if it had not been opened
2048yet, to get valid size and flags.
2049@param[in,out] space Tablespace instance */
2051 if (space->size == 0) {
2052 /* Initially, size and flags will be set to 0,
2053 until the files are opened for the first time.
2054 fil_space_get_size() will open the file
2055 and adjust the size and flags. */
2057
2058 ut_a(size == space->size);
2059 }
2060}
2061
2062/** Note that the file system where the file resides doesn't support PUNCH HOLE.
2063Called from AIO handlers when IO returns DB_IO_NO_PUNCH_HOLE
2064@param[in,out] file file to set */
2066
2067#ifdef UNIV_ENABLE_UNIT_TEST_MAKE_FILEPATH
2068void test_make_filepath();
2069#endif /* UNIV_ENABLE_UNIT_TEST_MAKE_FILEPATH */
2070
2071/** @return the system tablespace instance */
2074}
2075
2076/** Redo a tablespace create.
2077@param[in] ptr redo log record
2078@param[in] end end of the redo log buffer
2079@param[in] page_id Tablespace Id and first page in file
2080@param[in] parsed_bytes Number of bytes parsed so far
2081@param[in] parse_only Don't apply, parse only
2082@return pointer to next redo log record
2083@retval nullptr if this log record was truncated */
2084[[nodiscard]] const byte *fil_tablespace_redo_create(const byte *ptr,
2085 const byte *end,
2086 const page_id_t &page_id,
2087 ulint parsed_bytes,
2088 bool parse_only);
2089
2090/** Redo a tablespace delete.
2091@param[in] ptr redo log record
2092@param[in] end end of the redo log buffer
2093@param[in] page_id Tablespace Id and first page in file
2094@param[in] parsed_bytes Number of bytes parsed so far
2095@param[in] parse_only Don't apply, parse only
2096@return pointer to next redo log record
2097@retval nullptr if this log record was truncated */
2098[[nodiscard]] const byte *fil_tablespace_redo_delete(const byte *ptr,
2099 const byte *end,
2100 const page_id_t &page_id,
2101 ulint parsed_bytes,
2102 bool parse_only);
2103
2104/** Redo a tablespace rename.
2105This function doesn't do anything, simply parses the redo log record.
2106@param[in] ptr redo log record
2107@param[in] end end of the redo log buffer
2108@param[in] page_id Tablespace Id and first page in file
2109@param[in] parsed_bytes Number of bytes parsed so far
2110@param[in] parse_only Don't apply, parse only
2111@return pointer to next redo log record
2112@retval nullptr if this log record was truncated */
2113[[nodiscard]] const byte *fil_tablespace_redo_rename(const byte *ptr,
2114 const byte *end,
2115 const page_id_t &page_id,
2116 ulint parsed_bytes,
2117 bool parse_only);
2118
2119/** Redo a tablespace extend
2120@param[in] ptr redo log record
2121@param[in] end end of the redo log buffer
2122@param[in] page_id Tablespace Id and first page in file
2123@param[in] parsed_bytes Number of bytes parsed so far
2124@param[in] parse_only Don't apply the log if true
2125@return pointer to next redo log record
2126@retval nullptr if this log record was truncated */
2127[[nodiscard]] const byte *fil_tablespace_redo_extend(const byte *ptr,
2128 const byte *end,
2129 const page_id_t &page_id,
2130 ulint parsed_bytes,
2131 bool parse_only);
2132
2133/** Parse and process an encryption redo record.
2134@param[in] ptr redo log record
2135@param[in] end end of the redo log buffer
2136@param[in] space_id the tablespace ID
2137@param[in] lsn lsn for REDO record
2138@return log record end, nullptr if not a complete record */
2139[[nodiscard]] const byte *fil_tablespace_redo_encryption(const byte *ptr,
2140 const byte *end,
2141 space_id_t space_id,
2142 lsn_t lsn);
2143
2144/** Read the tablespace id to path mapping from the file
2145@param[in] recovery true if called from crash recovery */
2147
2148/** Lookup the tablespace ID.
2149@param[in] space_id Tablespace ID to lookup
2150@return true if the space ID is known. */
2151[[nodiscard]] bool fil_tablespace_lookup_for_recovery(space_id_t space_id);
2152
2153/** Compare and update space name and dd path for partitioned table. Uniformly
2154converts partition separators and names to lower case.
2155@param[in] space_id tablespace ID
2156@param[in] fsp_flags tablespace flags
2157@param[in] update_space update space name
2158@param[in,out] space_name tablespace name
2159@param[in,out] dd_path file name with complete path
2160@return true, if names are updated. */
2161bool fil_update_partition_name(space_id_t space_id, uint32_t fsp_flags,
2162 bool update_space, std::string &space_name,
2163 std::string &dd_path);
2164
2165/** Add tablespace to the set of tablespaces to be updated in DD.
2166@param[in] dd_object_id Server DD tablespace ID
2167@param[in] space_id Innodb tablespace ID
2168@param[in] space_name New tablespace name
2169@param[in] old_path Old Path in the data dictionary
2170@param[in] new_path New path to be update in dictionary
2171@param[in] dd_flag_missing This tablespace is outside default data
2172 directory, yet it is missing
2173 DD_TABLE_DATA_DIRECTORY flag. This could
2174 happen in versions earlier than
2175 8.0.38/8.4.1/9.0.0 */
2176void fil_add_moved_space(dd::Object_id dd_object_id, space_id_t space_id,
2177 const char *space_name, const std::string &old_path,
2178 const std::string &new_path, bool dd_flag_missing);
2179
2180/** Lookup the tablespace ID and return the path to the file. The filename
2181is ignored when testing for equality. Only the path up to the file name is
2182considered for matching: e.g. ./test/a.ibd == ./test/b.ibd.
2183@param[in] space_id tablespace ID to lookup
2184@param[in] space_name tablespace name
2185@param[in] fsp_flags tablespace flags
2186@param[in] old_path the path found in dd:Tablespace_files
2187@param[out] new_path the scanned path for this space_id
2188@return status of the match. */
2189[[nodiscard]] Fil_state fil_tablespace_path_equals(space_id_t space_id,
2190 const char *space_name,
2191 ulint fsp_flags,
2192 std::string old_path,
2193 std::string *new_path);
2194
2195/** This function should be called after recovery has completed.
2196Check for tablespace files for which we did not see any MLOG_FILE_DELETE
2197or MLOG_FILE_RENAME record. These could not be recovered
2198@return true if there were some filenames missing for which we had to
2199ignore redo log records during the apply phase */
2200[[nodiscard]] bool fil_check_missing_tablespaces();
2201
2202/** Normalize and save a directory to scan for datafiles.
2203@param[in] directory directory to scan for ibd and ibu files
2204@param[in] is_undo_dir true for an undo directory */
2205void fil_set_scan_dir(const std::string &directory, bool is_undo_dir = false);
2206
2207/** Normalize and save a list of directories to scan for datafiles.
2208@param[in] directories Directories to scan for ibd and ibu files
2209 in the form: "dir1;dir2; ... dirN" */
2210void fil_set_scan_dirs(const std::string &directories);
2211
2212/** Discover tablespaces by reading the header from .ibd files.
2213@return DB_SUCCESS if all goes well */
2215
2216/** Open the tablespace and also get the tablespace filenames, space_id must
2217already be known.
2218@param[in] space_id Tablespace ID to lookup
2219@return DB_SUCCESS if open was successful */
2221
2222/** Replay a file rename operation for ddl replay.
2223@param[in] page_id Space ID and first page number in the file
2224@param[in] old_name old file name
2225@param[in] new_name new file name
2226@return whether the operation was successfully applied
2227(the name did not exist, or new_name did not exist and
2228name was successfully renamed to new_name) */
2229bool fil_op_replay_rename_for_ddl(const page_id_t &page_id,
2230 const char *old_name, const char *new_name);
2231
2232/** Free the Tablespace_files instance.
2233@param[in] read_only_mode true if InnoDB is started in read only mode.
2234@return DB_SUCCESS if all OK */
2235[[nodiscard]] dberr_t fil_open_for_business(bool read_only_mode);
2236
2237/** Check if a path is known to InnoDB meaning that it is in or under
2238one of the four path settings scanned at startup for file discovery.
2239@param[in] path Path to check
2240@return true if path is known to InnoDB */
2241[[nodiscard]] bool fil_path_is_known(const std::string &path);
2242
2243/** Get the list of directories that datafiles can reside in.
2244@return the list of directories 'dir1;dir2;....;dirN' */
2245[[nodiscard]] std::string fil_get_dirs();
2246
2247/** Rename a tablespace. Use the space_id to find the shard.
2248@param[in] space_id tablespace ID
2249@param[in] old_name old tablespace name
2250@param[in] new_name new tablespace name
2251@return DB_SUCCESS on success */
2252[[nodiscard]] dberr_t fil_rename_tablespace_by_id(space_id_t space_id,
2253 const char *old_name,
2254 const char *new_name);
2255
2256/** Write initial pages for a new tablespace file created.
2257@param[in] file open file handle
2258@param[in] path path and filename of the datafile
2259@param[in] type file type
2260@param[in] size Initial size of the tablespace file in pages
2261@param[in] encrypt_info encryption key information
2262@param[in] space_id tablespace ID
2263@param[in,out] space_flags tablespace flags
2264@param[out] punch_hole if punch hole is used
2265@return DB_SUCCESS on success */
2266[[nodiscard]] dberr_t fil_write_initial_pages(
2268 const byte *encrypt_info, space_id_t space_id, uint32_t &space_flags,
2269 bool &punch_hole);
2270
2271/** Free the data structures required for recovery. */
2273
2274/** Update the tablespace name. In case, the new name
2275and old name are same, no update done.
2276@param[in,out] space tablespace object on which name
2277 will be updated
2278@param[in] name new name for tablespace */
2279void fil_space_update_name(fil_space_t *space, const char *name);
2280
2281/** Adjust file name for import for partition files in different letter case.
2282@param[in] table Innodb dict table
2283@param[in] path file path to open
2284@param[in] extn file extension */
2286 ib_file_suffix extn);
2287
2288#ifndef UNIV_HOTBACKUP
2289
2290/** Allows fil system to do periodical cleanup. */
2291void fil_purge();
2292
2293/** Count how many truncated undo space IDs are still tracked in
2294the buffer pool and the file_system cache.
2295@param[in] undo_num undo tablespace number.
2296@return number of undo tablespaces that are still in memory. */
2297size_t fil_count_undo_deleted(space_id_t undo_num);
2298
2299#endif /* !UNIV_HOTBACKUP */
2300
2301/** Get the page type as a string.
2302@param[in] type page type to be converted to string.
2303@return the page type as a string. */
2304[[nodiscard]] const char *fil_get_page_type_str(page_type_t type) noexcept;
2305
2306/** Check if the given page type is valid.
2307@param[in] type the page type to be checked for validity.
2308@return true if it is valid page type, false otherwise. */
2309[[nodiscard]] bool fil_is_page_type_valid(page_type_t type) noexcept;
2310
2312 fil_node_t **node_out);
2313void fil_complete_write(space_id_t space_id, fil_node_t *node);
2314
2315inline bool fil_node_t::is_offset_valid(os_offset_t byte_offset) const {
2316 const page_size_t page_size(space->flags);
2317 const os_offset_t max_offset = size * page_size.physical();
2318 ut_ad(byte_offset < max_offset);
2319 return byte_offset < max_offset;
2320}
2321
2322#endif /* fil0fil_h */
uint32_t space_id_t
Tablespace identifier.
Definition: api0api.h:48
uint32_t page_no_t
Page number.
Definition: api0api.h:46
byte buf_frame_t
A buffer frame.
Definition: buf0types.h:62
buf_remove_t
Algorithm to remove the pages for a tablespace from the buffer pool.
Definition: buf0types.h:84
Type
Algorithm types supported.
Definition: os0enc.h:57
Progress
Encryption progress type.
Definition: os0enc.h:80
Iterate over the files in all the tablespaces.
Definition: fil0fil.h:1510
std::function< dberr_t(fil_node_t *)> Function
Definition: fil0fil.h:1512
static dberr_t iterate(Function &&f)
Iterate through all persistent tablespace files (FIL_TYPE_TABLESPACE) returning the nodes via callbac...
Definition: fil0fil.cc:3917
static dberr_t for_each_file(F &&f)
For each data file.
Definition: fil0fil.h:1517
Wrapper for a path to a directory that may or may not exist.
Definition: fil0fil.h:615
bool is_ancestor(const Fil_path &other) const
Check if m_path is the parent of the other path.
Definition: fil0fil.cc:9163
size_t abs_len() const
Definition: fil0fil.h:688
static void convert_to_filename_charset(std::string &name)
Convert filename to the file system charset format.
Definition: fil0fil.cc:11605
static bool is_same_as(const std::string &first, const std::string &second)
Check if two path strings are equal.
Definition: fil0fil.h:718
static char * make_ibd_from_table_name(const std::string &name_in)
Allocate and build a file name from a path, a table or tablespace name and a suffix.
Definition: fil0fil.h:1062
static const char * get_file_type_string(const std::string &path)
Return a string to display the file type of a path.
Definition: fil0fil.cc:9231
path_type
Various types of file paths.
Definition: fil0fil.h:636
@ absolute
Definition: fil0fil.h:636
@ invalid
Definition: fil0fil.h:636
@ relative
Definition: fil0fil.h:636
@ file_name_only
Definition: fil0fil.h:636
bool operator==(const Fil_path &other) const
Determine if this path is equal to the other path.
Definition: fil0fil.h:693
static char * make(const std::string &path_in, const std::string &name_in, ib_file_suffix ext, bool trim=false)
Allocate and build a file name from a path, a table or tablespace name and a suffix.
Definition: fil0fil.cc:4876
static bool is_ancestor(const std::string &first, const std::string &second)
Check if the first path is an ancestor of the second.
Definition: fil0fil.h:758
static char * make_cfp(const std::string &path_in)
Allocate and build a CFP file name from a path.
Definition: fil0fil.h:1042
static constexpr auto SEPARATOR
Directory separators that are supported.
Definition: fil0fil.h:624
static constexpr auto DOT_SLASH
Definition: fil0fil.h:630
std::string m_path
Path to a file or directory.
Definition: fil0fil.h:1134
const char * operator()() const
Explicit type conversion.
Definition: fil0fil.h:666
bool is_dir_same_as(const Fil_path &other) const
Check if the directory to path is same as directory as the other path.
Definition: fil0fil.cc:9153
static bool is_relative_path(const std::string &path)
Determine if a path is a relative path or not.
Definition: fil0fil.h:828
static bool is_absolute_path(const std::string &path)
Determine if a path is an absolute path or not.
Definition: fil0fil.h:841
static void convert_to_lower_case(std::string &path)
Convert to lower case using the file system charset.
Definition: fil0fil.cc:11622
static std::string get_basename(const std::string &filepath)
Get the basename of the file path.
Definition: fil0fil.cc:4293
bool is_same_as(const Fil_path &other) const
Check if m_path is the same as this other path.
Definition: fil0fil.cc:9123
const std::string abs_path() const
Return the absolute path by value.
Definition: fil0fil.h:679
bool is_valid() const
This validation is only for ':'.
Definition: fil0fil.cc:9273
static std::string make_new_path(const std::string &path_in, const std::string &name_in, ib_file_suffix extn)
Create an IBD path name after replacing the basename in an old path with a new basename.
Definition: fil0fil.cc:4988
std::string m_abs_path
A full absolute path to the same file.
Definition: fil0fil.h:1137
static bool is_separator(char c)
Check if a character is a path separator ('\' or '/')
Definition: fil0fil.h:995
static void append_separator(std::string &path)
If the last character of a directory path is NOT a separator, append a separator to the path.
Definition: fil0fil.h:1012
static bool is_valid_location_within_db(const char *space_name, const std::string &path)
Check if the implicit filepath is immediately within a dir named for the schema.
Definition: fil0fil.cc:11542
static constexpr auto SLASH_DOT_DOT_SLASH
Definition: fil0fil.h:632
static std::pair< std::string, std::string > split(const std::string &path)
Splits the path into directory and file name parts.
Definition: fil0fil.cc:9157
size_t len() const
Definition: fil0fil.h:672
static char * make_cfg(const std::string &path_in)
Allocate and build a CFG file name from a path.
Definition: fil0fil.h:1035
static std::string remove_quotes(const char *pathspec)
Remove quotes e.g., 'a;b' or "a;b" -> a;b.
Definition: fil0fil.h:810
Fil_path get_abs_directory() const
Get the absolute directory of this path.
Definition: fil0fil.cc:9147
static constexpr auto OS_SEPARATOR
OS specific path separator.
Definition: fil0fil.h:621
static bool is_valid_location(const char *space_name, space_id_t space_id, uint32_t fsp_flags, const std::string &path)
Check if the filepath provided is in a valid placement.
Definition: fil0fil.cc:11498
static bool is_undo_tablespace_name(const std::string &name)
Check if the name is an undo tablespace name.
Definition: fil0fil.cc:2108
static char * make_ibd(const std::string &path_in, const std::string &name_in)
Allocate and build a file name from a path, a table or tablespace name and a suffix.
Definition: fil0fil.h:1053
const std::string & path() const
Definition: fil0fil.h:669
bool is_circular() const
Determine if m_path contains a circular section like "/anydir/../" Fil_path::normalize() must be run ...
Definition: fil0fil.cc:9297
bool is_directory_and_exists() const
Definition: fil0fil.cc:9267
static std::string get_real_path(const std::string &path, bool force=true)
Get the real path for a directory or a file name.
Definition: fil0fil.cc:4183
bool is_file_and_exists() const
Definition: fil0fil.cc:9262
static bool is_hidden(std::string path)
Determine if the file or directory is considered HIDDEN.
Definition: fil0fil.cc:9194
bool is_absolute_path() const
Definition: fil0fil.h:833
static constexpr auto DB_SEPARATOR
schema '/' table separator
Definition: fil0fil.h:618
static void make_data_dir_path(char *data_dir_path)
This function reduces a null-terminated full remote path name into the path that is sent by MySQL for...
Definition: fil0fil.cc:5027
static void normalize(char *path)
Normalize a directory path for the current OS: On Windows, we convert '/' to '\', else we convert '\'...
Definition: fil0fil.h:902
Fil_path()
Default constructor.
Definition: fil0fil.cc:9120
static os_file_type_t get_file_type(const std::string &path)
Definition: fil0fil.cc:9220
static bool truncate_suffix(ib_file_suffix sfx, std::string &path)
Check if the file has the the specified suffix and truncate.
Definition: fil0fil.h:979
static void to_lower(std::string &path)
Convert a path string to lower case using the CHARSET my_charset_filename.
Definition: fil0fil.h:912
static bool parse_file_path(const std::string &file_path, ib_file_suffix extn, std::string &dict_name)
Parse file-per-table file name and build Innodb dictionary table name.
Definition: fil0fil.cc:4956
static path_type type_of_path(const std::string &path)
Determine what type of path is provided.
Definition: fil0fil.h:849
static void normalize(std::string &path)
Normalize a directory path for the current OS: On Windows, we convert '/' to '\', else we convert '\'...
Definition: fil0fil.h:891
static std::string get_existing_path(const std::string &path, std::string &ghost)
Separate the portion of a directory path that exists and the portion that does not exist.
Definition: fil0fil.cc:4153
static void trim_separator(std::string &path)
If the last character of a directory path is a separator ('\' or '/') trim it off the string.
Definition: fil0fil.h:1000
static constexpr auto DOT_DOT_SLASH
Definition: fil0fil.h:631
static bool has_prefix(const std::string &path, const std::string prefix)
Definition: fil0fil.h:882
static bool has_suffix(ib_file_suffix sfx, const std::string &path)
Check if the file has the the specified suffix.
Definition: fil0fil.h:967
We use Flush_observer to track flushing of non-redo logged pages in bulk create index(btr0load....
Definition: buf0flu.h:258
The IO Context that is passed down to the low level IO code.
Definition: os0file.h:265
Allows to monitor an event processing times, allowing to throttle the processing to one per throttle_...
Definition: ut0ut.h:368
For measuring time elapsed.
Definition: ut0ut.h:306
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
const char * p
Definition: ctype-mb.cc:1225
int page
Definition: ctype-mb.cc:1224
dberr_t
Definition: db0err.h:39
Data dictionary global types.
static duk_ret_t normalize_path(duk_context *ctx, duk_idx_t obj_idx)
Definition: duk_module_shim.cc:76
static constexpr char general_space_name[]
This tablespace name is used internally during file discovery to open a general tablespace before the...
Definition: fil0fil.h:83
bool fil_system_get_file_by_space_num(space_id_t space_num, space_id_t &space_id, std::string &name)
Fetch the file name opened for an undo space number from the file map.
Definition: fil0fil.cc:4441
const byte * fil_tablespace_redo_encryption(const byte *ptr, const byte *end, space_id_t space_id, lsn_t lsn)
Parse and process an encryption redo record.
Definition: fil0fil.cc:10606
constexpr page_type_t FIL_PAGE_TYPE_LOB_FIRST
The first page of an uncompressed LOB.
Definition: fil0fil.h:1308
bool fil_system_get_file_by_space_id(space_id_t space_id, std::string &name)
Fetch the file name opened for a space_id from the file map.
Definition: fil0fil.cc:4435
void fil_purge()
Allows fil system to do periodical cleanup.
Definition: fil0fil.cc:11634
bool fil_is_page_type_valid(page_type_t type) noexcept
Check if the given page type is valid.
Definition: fil0fil.cc:11685
bool fil_check_missing_tablespaces()
This function should be called after recovery has completed.
Definition: fil0fil.cc:10169
constexpr page_type_t FIL_PAGE_UNDO_LOG
Undo log page.
Definition: fil0fil.h:1237
fil_space_t * fil_space_create(const char *name, space_id_t space_id, uint32_t flags, fil_type_t purpose)
Create a space memory object and put it to the fil_system hash table.
Definition: fil0fil.cc:3284
std::ostream & operator<<(std::ostream &out, const fil_addr_t &obj)
Definition: fil0fil.h:1214
constexpr page_type_t FIL_PAGE_TYPE_LOB_INDEX
Index pages of uncompressed LOB.
Definition: fil0fil.h:1302
constexpr page_type_t FIL_PAGE_ENCRYPTED_RTREE
Encrypted R-tree page.
Definition: fil0fil.h:1287
bool fil_path_is_known(const std::string &path)
Check if a path is known to InnoDB meaning that it is in or under one of the four path settings scann...
Definition: fil0fil.cc:11467
bool fil_validate()
Checks the consistency of the tablespace cache.
Definition: fil0fil.cc:1959
constexpr page_no_t PAGE_NO_MAX
Maximum Page Number, one less than FIL_NULL.
Definition: fil0fil.h:1162
constexpr page_type_t FIL_PAGE_TYPE_LOB_DATA
Data pages of uncompressed LOB.
Definition: fil0fil.h:1305
constexpr page_type_t FIL_PAGE_TYPE_ZBLOB
First compressed BLOB page.
Definition: fil0fil.h:1268
uint32_t fil_space_get_flags(space_id_t space_id)
Returns the flags of the space.
Definition: fil0fil.cc:3504
void fil_io_set_encryption(IORequest &req_type, const page_id_t &page_id, fil_space_t *space)
Set encryption information for IORequest.
Definition: fil0fil.cc:7489
dberr_t fil_set_compression(space_id_t space_id, const char *algorithm)
Set the compression type for the tablespace.
Definition: fil0fil.cc:8786
page_no_t fil_page_get_prev(const byte *page)
Get the predecessor of a file page.
Definition: fil0fil.cc:8149
Fil_path MySQL_undo_path
The MySQL server –innodb-undo-directory value.
Definition: fil0fil.cc:282
bool fil_page_index_page_check(const byte *page)
Check whether the page is index page (either regular Btree index or Rtree index.
Definition: fil0fil.h:1345
rw_lock_t * fil_space_get_latch(space_id_t space_id)
Returns the latch of a file space.
Definition: fil0fil.cc:2246
bool fil_delete_file(const char *path)
Delete the tablespace file and any related files like .cfg.
Definition: fil0fil.cc:8665
ulint fil_space_get_n_reserved_extents(space_id_t space_id)
Gets the number of reserved extents.
Definition: fil0fil.cc:7341
const byte * fil_tablespace_redo_create(const byte *ptr, const byte *end, const page_id_t &page_id, ulint parsed_bytes, bool parse_only)
Redo a tablespace create.
Definition: fil0fil.cc:10237
ulong srv_fast_shutdown
The value of the configuration parameter innodb_fast_shutdown, controlling the InnoDB shutdown.
Definition: srv0srv.cc:569
constexpr size_t FIL_NODE_MAGIC_N
Value of fil_node_t::magic_n.
Definition: fil0fil.h:584
void fil_open_system_tablespace_files()
Opens all log files and system tablespace data files.
Definition: fil0fil.cc:3726
constexpr size_t FIL_SCAN_MAX_TABLESPACES_PER_THREAD
Maximum number of tablespaces to be scanned by a thread while scanning for available tablespaces duri...
Definition: fil0fil.h:64
constexpr page_type_t FIL_PAGE_COMPRESSED_AND_ENCRYPTED
Compressed and Encrypted page.
Definition: fil0fil.h:1284
char * fil_path_to_space_name(const char *filename)
Convert a file name to a tablespace name.
Definition: fil0fil.cc:5931
uint16_t page_type_t
Definition: fil0fil.h:1221
page_no_t fil_space_get_undo_initial_size(space_id_t space_id)
Returns the size of an undo space just after it was initialized.
Definition: fil0fil.cc:3468
void fil_encryption_reencrypt(std::vector< space_id_t > &sid_vector)
Roencrypt the tablespace keys by current master key.
Definition: fil0fil.cc:9075
fil_type_t fil_space_get_type(space_id_t space_id)
Gets the type of a file space.
Definition: fil0fil.cc:2263
void fil_space_inc_redo_skipped_count(space_id_t space_id)
Increase redo skipped count for a tablespace.
Definition: fil0fil.cc:4702
void fil_space_set_flags(fil_space_t *space, uint32_t flags)
Sets the flags of the tablespace.
Definition: fil0fil.cc:9330
dberr_t fil_tablespace_open_for_recovery(space_id_t space_id)
Open the tablespace and also get the tablespace filenames, space_id must already be known.
Definition: fil0fil.cc:9866
const byte * fil_tablespace_redo_rename(const byte *ptr, const byte *end, const page_id_t &page_id, ulint parsed_bytes, bool parse_only)
Redo a tablespace rename.
Definition: fil0fil.cc:10312
constexpr size_t FIL_IBD_FILE_INITIAL_SIZE_5_7
An empty tablespace (CREATE TABLESPACE) has minimum of 4 pages and an empty CREATE TABLE (file_per_ta...
Definition: fil0fil.h:1156
bool fil_space_extend(fil_space_t *space, page_no_t size)
Try to extend a tablespace if it is smaller than the specified size.
Definition: fil0fil.cc:6721
constexpr page_type_t FIL_PAGE_TYPE_ZLOB_FRAG_ENTRY
Index pages of fragment pages (compressed LOB).
Definition: fil0fil.h:1324
dberr_t fil_close_tablespace(space_id_t space_id)
Closes a single-table tablespace.
Definition: fil0fil.cc:4312
constexpr page_type_t FIL_PAGE_INODE
Index node.
Definition: fil0fil.h:1240
bool fil_update_partition_name(space_id_t space_id, uint32_t fsp_flags, bool update_space, std::string &space_name, std::string &dd_path)
Compare and update space name and dd path for partitioned table.
Definition: fil0fil.cc:10056
void fil_free_scanned_files()
Free the data structures required for recovery.
Definition: fil0fil.cc:11476
constexpr page_type_t FIL_PAGE_TYPE_UNUSED
This page type is unused.
Definition: fil0fil.h:1234
constexpr page_type_t FIL_PAGE_INDEX
File page types (values of FIL_PAGE_TYPE)
Definition: fil0fil.h:1225
std::atomic_size_t fil_n_files_open
Number of files currently open.
Definition: fil0fil.cc:295
bool MySQL_undo_path_is_unique
The undo path is different from any other known directory.
Definition: fil0fil.cc:285
void fil_space_dec_redo_skipped_count(space_id_t space_id)
Decrease redo skipped count for a tablespace.
Definition: fil0fil.cc:4718
constexpr page_type_t FIL_PAGE_RTREE
R-tree node.
Definition: fil0fil.h:1228
void fil_space_open_if_needed(fil_space_t *space)
During crash recovery, open a tablespace if it had not been opened yet, to get valid size and flags.
Definition: fil0fil.h:2050
constexpr size_t FIL_IBD_FILE_INITIAL_SIZE
Initial size of a single-table tablespace in pages.
Definition: fil0fil.h:1150
static constexpr char undo_space_name[]
This tablespace name is used as the prefix for implicit undo tablespaces and during file discovery to...
Definition: fil0fil.h:88
bool fil_space_exists_in_mem(space_id_t space_id, const char *name, bool print_err, bool adjust_space)
Returns true if a matching tablespace exists in the InnoDB tablespace memory cache.
Definition: fil0fil.cc:6381
dberr_t fil_write_initial_pages(pfs_os_file_t file, const char *path, fil_type_t type, page_no_t size, const byte *encrypt_info, space_id_t space_id, uint32_t &space_flags, bool &punch_hole)
Write initial pages for a new tablespace file created.
Definition: fil0fil.cc:5438
bool fil_space_read_name_and_filepath(space_id_t space_id, char **name, char **filepath)
Looks for a pre-existing fil_space_t with the given tablespace ID and, if found, returns the name and...
Definition: fil0fil.cc:5900
dberr_t fil_set_encryption(space_id_t space_id, Encryption::Type algorithm, byte *key, byte *iv)
Set the encryption type for the tablespace.
Definition: fil0fil.cc:8879
dberr_t fil_rename_tablespace_by_id(space_id_t space_id, const char *old_name, const char *new_name)
Rename a tablespace.
Definition: fil0fil.cc:5433
constexpr size_t FIL_IBT_FILE_INITIAL_SIZE
Definition: fil0fil.h:1151
void fil_space_update_name(fil_space_t *space, const char *name)
Update the tablespace name.
Definition: fil0fil.cc:11483
bool fil_open_files_limit_update(size_t &new_max_open_files)
Changes the maximum opened files limit.
Definition: fil0fil.cc:3601
constexpr page_no_t FIL_NULL
'null' (undefined) page offset in the context of file spaces
Definition: fil0fil.h:1159
constexpr size_t FIL_SPACE_MAGIC_N
Value of fil_space_t::magic_n.
Definition: fil0fil.h:581
dberr_t fil_reset_encryption(space_id_t space_id)
Reset the encryption type for the tablespace.
Definition: fil0fil.cc:8908
size_t fil_get_scan_threads(size_t num_files)
Calculate the number of threads that can be spawned to scan the given number of files taking into the...
Definition: fil0fil.cc:133
void fil_space_close(space_id_t space_id)
Close each file of a tablespace if open.
Definition: fil0fil.cc:3556
fil_space_t * fil_space_acquire(space_id_t space_id)
Acquire a tablespace when it could be dropped concurrently.
Definition: fil0fil.cc:4001
fil_space_t * fil_space_acquire_silent(space_id_t space_id)
Acquire a tablespace that may not exist.
Definition: fil0fil.cc:4010
Fil_state
Result of comparing a path.
Definition: fil0fil.h:130
@ MATCHES
The path matches what was found during the scan.
@ MISSING
No MLOG_FILE_DELETE record and the file could not be found.
@ DELETED
A MLOG_FILE_DELETE was found, file was deleted.
@ MOVED
Space ID matches but the paths don't match.
@ RENAMED
Tablespace and/or filename was renamed.
@ MOVED_PREV
Space ID and paths match but dd_table data dir flag is false despite the file being outside default d...
@ COMPARE_ERROR
In case of error during comparison.
void fil_add_moved_space(dd::Object_id dd_object_id, space_id_t space_id, const char *space_name, const std::string &old_path, const std::string &new_path, bool dd_flag_missing)
Add tablespace to the set of tablespaces to be updated in DD.
Definition: fil0fil.cc:10048
dberr_t fil_write_flushed_lsn(lsn_t lsn)
Write the flushed LSN to the page header of the first page in the system tablespace.
Definition: fil0fil.cc:3934
char * fil_space_get_first_path(space_id_t space_id)
Returns the path from the first fil_node_t found with this space ID.
Definition: fil0fil.cc:3430
constexpr page_type_t FIL_PAGE_TYPE_ZLOB_FRAG
Fragment pages of compressed LOB.
Definition: fil0fil.h:1321
constexpr page_type_t FIL_PAGE_TYPE_LAST
Note the highest valid non-index page_type_t.
Definition: fil0fil.h:1327
void fil_tablespace_open_init_for_recovery(bool recovery)
Read the tablespace id to path mapping from the file.
fil_addr_t fil_addr_null
The null file address.
Definition: fil0fil.cc:329
void fil_close_all_files()
Closes all open files.
Definition: fil0fil.cc:3871
void fil_init(ulint max_n_open)
Initializes the tablespace memory cache.
Definition: fil0fil.cc:3586
size_t fil_encryption_rotate()
Rotate the tablespace keys by new master key.
Definition: fil0fil.cc:9073
bool fil_page_type_is_index(page_type_t page_type)
Check whether the page type is index (Btree or Rtree or SDI) type.
Definition: fil0fil.h:1330
void fil_set_scan_dirs(const std::string &directories)
Normalize and save a list of directories to scan for datafiles.
Definition: fil0fil.cc:11455
fil_space_t * fil_space_get_sys_space()
Definition: fil0fil.h:2072
void fil_no_punch_hole(fil_node_t *file)
Note that the file system where the file resides doesn't support PUNCH HOLE.
Definition: fil0fil.cc:8784
const page_size_t fil_space_get_page_size(space_id_t space_id, bool *found)
Returns the page size of the space and whether it is compressed or not.
Definition: fil0fil.cc:3571
dberr_t fil_scan_for_tablespaces()
Discover tablespaces by reading the header from .ibd files.
Definition: fil0fil.cc:11461
byte fil_faddr_t
'type' definition in C: an address stored in a file page is a string of bytes
Definition: fil0fil.h:1173
dberr_t fil_rename_tablespace_check(space_id_t space_id, const char *old_path, const char *new_path, bool is_discarded)
Test if a tablespace file can be renamed to a new filepath by checking if that the old filepath exist...
Definition: fil0fil.cc:5058
void fil_space_release(fil_space_t *space)
Release a tablespace acquired with fil_space_acquire().
Definition: fil0fil.cc:4016
bool fil_truncate_tablespace(space_id_t space_id, page_no_t size_in_pages)
Truncate the tablespace to needed size.
Definition: fil0fil.cc:4693
void fil_close()
Initializes the tablespace memory cache.
Definition: fil0fil.cc:8183
const char * fil_get_page_type_str(page_type_t type) noexcept
Get the page type as a string.
Definition: fil0fil.cc:11646
void fil_flush_file_spaces()
Flush to disk the writes in file spaces possibly cached by the OS (note: spaces of type FIL_TYPE_TEMP...
Definition: fil0fil.cc:8137
std::vector< std::string, ut::allocator< std::string > > Filenames
Definition: fil0fil.h:116
bool fil_space_reserve_free_extents(space_id_t space_id, ulint n_free_now, ulint n_to_reserve)
Tries to reserve free extents in a file space.
Definition: fil0fil.cc:7289
dberr_t fil_ibd_open(bool validate, fil_type_t purpose, space_id_t space_id, uint32_t flags, const char *space_name, const char *path_in, bool strict, bool old_space)
Open a single-table tablespace and optionally do some validation such as checking that the space id i...
Definition: fil0fil.cc:5723
page_no_t fil_page_get_next(const byte *page)
Get the successor of a file page.
Definition: fil0fil.cc:8156
constexpr size_t FIL_SCAN_THREADS_PER_CORE
Number of threads per core.
Definition: fil0fil.h:72
constexpr page_type_t FIL_PAGE_TYPE_ZLOB_DATA
Data pages of compressed LOB.
Definition: fil0fil.h:1314
constexpr page_type_t FIL_PAGE_TYPE_XDES
Extent descriptor page.
Definition: fil0fil.h:1262
fil_type_t
File types.
Definition: fil0fil.h:120
@ FIL_TYPE_TEMPORARY
temporary tablespace (temporary undo log or tables)
Definition: fil0fil.h:122
@ FIL_TYPE_IMPORT
a tablespace that is being imported (no logging until finished)
Definition: fil0fil.h:124
@ FIL_TYPE_TABLESPACE
persistent tablespace (for system, undo log or tables)
Definition: fil0fil.h:126
void fil_space_set_undo_size(space_id_t space_id, bool use_current)
This is called for an undo tablespace after it has been initialized or opened.
Definition: fil0fil.cc:3482
constexpr page_type_t FIL_PAGE_COMPRESSED
Compressed page.
Definition: fil0fil.h:1278
std::vector< space_id_t, ut::allocator< space_id_t > > Space_ids
Definition: fil0fil.h:117
std::atomic< std::uint64_t > fil_n_pending_tablespace_flushes
Number of pending tablespace flushes.
Definition: fil0fil.cc:292
constexpr page_type_t FIL_PAGE_SDI
Tablespace SDI Index page.
Definition: fil0fil.h:1231
bool fil_tablespace_lookup_for_recovery(space_id_t space_id)
Lookup the tablespace ID.
Definition: fil0fil.cc:9813
dberr_t fil_rename_tablespace(space_id_t space_id, const char *old_path, const char *new_name, const char *new_path_in)
Rename a single-table tablespace.
Definition: fil0fil.cc:5357
dberr_t fil_tablespace_iterate(const Encryption_metadata &encryption_metadata, dict_table_t *table, ulint n_io_buffers, Compression::Type compression_type, PageCallback &callback)
Iterate over all the pages in the tablespace.
Definition: fil0fil.cc:8473
void fil_space_set_imported(space_id_t space_id)
Note that a tablespace has been imported.
Definition: fil0fil.cc:2277
constexpr size_t FIL_SCAN_MAX_THREADS
Maximum number of threads that will be used for scanning the tablespace files.
Definition: fil0fil.h:69
constexpr uint32_t UNDO_INITIAL_SIZE
Initial size of an UNDO tablespace when it is created new or truncated under low load.
Definition: fil0fil.h:101
void fil_extend_tablespaces_to_stored_len()
Extends all tablespaces to the size stored in the space header.
void fil_space_release_free_extents(space_id_t space_id, ulint n_reserved)
Releases free extents in a file space.
Definition: fil0fil.cc:7315
constexpr page_type_t FIL_PAGE_TYPE_ZBLOB2
Subsequent compressed BLOB page.
Definition: fil0fil.h:1271
constexpr page_type_t FIL_PAGE_TYPE_UNKNOWN
In old tablespaces, garbage in FIL_PAGE_TYPE is replaced with this value when flushing pages.
Definition: fil0fil.h:1275
constexpr page_type_t FIL_PAGE_TYPE_ZLOB_FIRST
The first page of a compressed LOB.
Definition: fil0fil.h:1311
fil_space_t * fil_space_get(space_id_t space_id)
Look up a tablespace.
Definition: fil0fil.cc:2229
constexpr page_type_t FIL_PAGE_TYPE_ALLOCATED
Freshly allocated page.
Definition: fil0fil.h:1247
constexpr page_type_t FIL_PAGE_TYPE_LEGACY_DBLWR
Legacy doublewrite buffer page.
Definition: fil0fil.h:1296
constexpr page_type_t FIL_PAGE_IBUF_FREE_LIST
Insert buffer free list.
Definition: fil0fil.h:1243
void fil_set_max_space_id_if_bigger(space_id_t max_id)
Sets the max tablespace id counter if the given number is bigger than the previous value.
Definition: fil0fil.cc:3922
volatile bool recv_recovery_on
true when applying redo log records during crash recovery; false otherwise.
Definition: log0recv.cc:103
constexpr page_type_t FIL_PAGE_SDI_ZBLOB
Compressed SDI BLOB page.
Definition: fil0fil.h:1293
constexpr page_type_t FIL_PAGE_TYPE_TRX_SYS
Transaction system data.
Definition: fil0fil.h:1256
Fil_state fil_tablespace_path_equals(space_id_t space_id, const char *space_name, ulint fsp_flags, std::string old_path, std::string *new_path)
Lookup the tablespace ID and return the path to the file.
Definition: fil0fil.cc:9870
page_type_t fil_page_get_type(const byte *page)
Get the file page type.
Definition: fil0fil.h:1338
constexpr page_type_t FIL_PAGE_ENCRYPTED
Encrypted page.
Definition: fil0fil.h:1281
dberr_t fil_set_autoextend_size(space_id_t space_id, uint64_t autoextend_size)
Set the autoextend_size attribute for the tablespace.
Definition: fil0fil.cc:8853
page_no_t fil_space_get_size(space_id_t space_id)
Returns the size of the space in pages.
Definition: fil0fil.cc:3454
dberr_t fil_ibt_create(space_id_t space_id, const char *name, const char *path, uint32_t flags, page_no_t size)
Create a session temporary tablespace (IBT) file.
Definition: fil0fil.cc:5715
char * fil_node_create(const char *name, page_no_t size, fil_space_t *space, bool is_raw, page_no_t max_pages=PAGE_NO_MAX)
Attach a file to a tablespace.
Definition: fil0fil.cc:2404
Compression::Type fil_get_compression(space_id_t space_id)
Get the compression algorithm for a tablespace.
Definition: fil0fil.cc:8843
space_id_t fil_space_get_id_by_name(const char *name)
Returns the space ID based on the tablespace name.
Definition: fil0fil.cc:6394
bool fil_assign_new_space_id(space_id_t *space_id)
Assigns a new space id for a new single-table tablespace.
Definition: fil0fil.cc:3371
constexpr space_id_t SPACE_UNKNOWN
Unknown space id.
Definition: fil0fil.h:1165
void fil_aio_wait(ulint segment)
Waits for an AIO operation to complete.
Definition: fil0fil.cc:7856
Fil_path MySQL_datadir_path
The MySQL server –datadir value.
Definition: fil0fil.cc:279
bool fil_op_replay_rename_for_ddl(const page_id_t &page_id, const char *old_name, const char *new_name)
Replay a file rename operation for ddl replay.
Definition: fil0fil.cc:9756
constexpr page_type_t FIL_PAGE_TYPE_SYS
System page.
Definition: fil0fil.h:1253
bool fil_space_is_redo_skipped(space_id_t space_id)
Check whether a single-table tablespace is redo skipped.
Definition: fil0fil.cc:4736
dberr_t fil_io(const IORequest &type, bool sync, const page_id_t &page_id, const page_size_t &page_size, ulint byte_offset, ulint len, void *buf, void *message)
Read or write data from a file.
Definition: fil0fil.cc:7913
void fil_page_reset_type(const page_id_t &page_id, byte *page, ulint type, mtr_t *mtr)
Reset the page type.
Definition: fil0fil.cc:8175
constexpr page_type_t FIL_PAGE_SDI_BLOB
Uncompressed SDI BLOB page.
Definition: fil0fil.h:1290
dberr_t fil_rename_precheck(const dict_table_t *old_table, const dict_table_t *new_table, const char *tmp_name)
Check if swapping two .ibd files can be done without failure.
Definition: fil0fil.cc:8691
constexpr page_type_t FIL_PAGE_TYPE_BLOB
Uncompressed BLOB page.
Definition: fil0fil.h:1265
bool fil_addr_is_null(const fil_addr_t &addr)
Returns true if file address is undefined.
Definition: fil0fil.cc:8142
constexpr page_type_t FIL_PAGE_TYPE_ZLOB_INDEX
Index pages of compressed LOB.
Definition: fil0fil.h:1318
void fil_page_set_type(byte *page, ulint type)
Sets the file page type.
Definition: fil0fil.cc:8163
const byte * fil_tablespace_redo_extend(const byte *ptr, const byte *end, const page_id_t &page_id, ulint parsed_bytes, bool parse_only)
Redo a tablespace extend.
Definition: fil0fil.cc:10364
dberr_t fil_discard_tablespace(space_id_t space_id)
Discards a single-table tablespace.
Definition: fil0fil.cc:4769
size_t fil_count_undo_deleted(space_id_t undo_num)
Count how many truncated undo space IDs are still tracked in the buffer pool and the file_system cach...
Definition: fil0fil.cc:11636
ib_file_suffix
Common InnoDB file extensions.
Definition: fil0fil.h:587
@ DWR
Definition: fil0fil.h:594
@ BWR
Definition: fil0fil.h:595
@ IBT
Definition: fil0fil.h:592
@ IBD
Definition: fil0fil.h:589
@ CFP
Definition: fil0fil.h:591
@ CFG
Definition: fil0fil.h:590
@ NO_EXT
Definition: fil0fil.h:588
@ IBU
Definition: fil0fil.h:593
const char * dot_ext[]
Common InnoDB file extensions.
Definition: fil0fil.cc:288
dberr_t fil_ibd_create(space_id_t space_id, const char *name, const char *path, uint32_t flags, page_no_t size)
Create an IBD tablespace file.
Definition: fil0fil.cc:5707
constexpr page_type_t FIL_PAGE_TYPE_RSEG_ARRAY
Rollback Segment Array page.
Definition: fil0fil.h:1299
void fil_adjust_name_import(dict_table_t *table, const char *path, ib_file_suffix extn)
Adjust file name for import for partition files in different letter case.
Definition: fil0fil.cc:8394
const byte * fil_tablespace_redo_delete(const byte *ptr, const byte *end, const page_id_t &page_id, ulint parsed_bytes, bool parse_only)
Redo a tablespace delete.
Definition: fil0fil.cc:10546
dberr_t fil_open_for_business(bool read_only_mode)
Free the Tablespace_files instance.
Definition: fil0fil.cc:9745
bool fil_space_open(space_id_t space_id)
Open each file of a tablespace if not already open.
Definition: fil0fil.cc:3542
dberr_t fil_delete_tablespace(space_id_t space_id, buf_remove_t buf_remove)
Deletes an IBD or IBU tablespace.
Definition: fil0fil.cc:4613
void fil_flush(space_id_t space_id)
Flushes to disk possible writes cached by the OS.
Definition: fil0fil.cc:8095
void fil_complete_write(space_id_t space_id, fil_node_t *node)
Definition: fil0fil.cc:11846
constexpr page_type_t FIL_PAGE_TYPE_FSP_HDR
File space header.
Definition: fil0fil.h:1259
std::string fil_get_dirs()
Get the list of directories that datafiles can reside in.
Definition: fil0fil.cc:11473
dberr_t fil_prepare_file_for_io(space_id_t space_id, page_no_t &page_no, fil_node_t **node_out)
Definition: fil0fil.cc:11826
void fil_set_scan_dir(const std::string &directory, bool is_undo_dir=false)
Normalize and save a directory to scan for datafiles.
Definition: fil0fil.cc:11451
void fil_page_check_type(const page_id_t &page_id, byte *page, ulint type, mtr_t *mtr)
Check (and if needed, reset) the page type.
Definition: fil0fil.h:1847
constexpr page_type_t FIL_PAGE_IBUF_BITMAP
Insert buffer bitmap.
Definition: fil0fil.h:1250
The low-level file system page header & trailer offsets.
constexpr uint32_t FIL_PAGE_TYPE
file page type: FIL_PAGE_INDEX,..., 2 bytes.
Definition: fil0types.h:76
static bool equal(const Item *i1, const Item *i2, const Field *f2)
Definition: sql_select.cc:3910
constexpr uint32_t FSP_FLAGS_GET_ENCRYPTION(uint32_t flags)
Return the contents of the ENCRYPTION field.
Definition: fsp0types.h:351
static int flags[50]
Definition: hp_test1.cc:40
Insert buffer global types.
unsigned char byte
Blob class.
Definition: common.h:151
Recovery.
uint64_t lsn_t
Type used for all log sequence number storage and arithmetic.
Definition: log0types.h:63
#define OS_PATH_SEPARATOR
Definition: log_sink_syseventlog.cc:94
A better implementation of the UNIX ctype(3) library.
char my_tolower(const CHARSET_INFO *cs, char ch)
Definition: m_ctype.h:561
MYSQL_STRINGS_EXPORT CHARSET_INFO my_charset_filename
Definition: ctype-utf8.cc:7056
static uint16_t mach_read_from_2(const byte *b)
The following function is used to fetch data from 2 consecutive bytes.
static const char * filepath
Definition: myisamlog.cc:97
static size_t file_size
Definition: mysql_config_editor.cc:72
static char * path
Definition: mysqldump.cc:149
static PFS_engine_table_share_proxy table
Definition: pfs.cc:61
Definition: buf0block_hint.cc:30
unsigned long long Object_id
Definition: object_id.h:31
Innodb data dictionary name.
Definition: dict0dd.cc:7295
Definition: os0file.h:89
Json_data_extension ext
Definition: backend.cc:50
@ NONE
Definition: base.h:45
bool isalpha(const char &ch)
Definition: parsing_helpers.h:37
HARNESS_EXPORT void trim(std::string &str)
Removes both leading and trailing whitespaces from the string.
Definition: string_utils.cc:70
size_t size(const char *const c)
Definition: base64.h:46
Cursor end()
A past-the-end Cursor.
Definition: rules_table_service.cc:192
os_file_type_t
Definition: os0file.h:616
uint64_t os_offset_t
File offset in bytes.
Definition: os0file.h:87
A class describing a page size.
const char * filename
Definition: pfs_example_component_population.cc:67
required string key
Definition: replication_asynchronous_connection_failover.proto:60
required string type
Definition: replication_group_member_actions.proto:34
case opt name
Definition: sslopt-case.h:29
Type
Algorithm types supported.
Definition: file.h:53
@ NONE
No compression.
Definition: file.h:59
Encryption metadata.
Definition: os0enc.h:445
Encryption::Type m_type
Encrypt type.
Definition: os0enc.h:447
Callback functor.
Definition: fil0fil.h:1889
virtual ulint get_space_flags() const 1=0
virtual dberr_t init(os_offset_t file_size, const buf_block_t *block) 1=0
Called for page 0 in the tablespace file at the start.
pfs_os_file_t m_file
File handle to the tablespace.
Definition: fil0fil.h:1942
virtual dberr_t operator()(os_offset_t offset, buf_block_t *block) 1=0
Called for every page in the tablespace.
page_size_t m_page_size
The tablespace page size.
Definition: fil0fil.h:1939
PageCallback()
Default constructor.
Definition: fil0fil.h:1891
void set_file(const char *filename, pfs_os_file_t file) 1
Set the name of the physical file and the file handle that is used to open it for the file that is be...
Definition: fil0fil.h:1916
void set_page_size(const buf_frame_t *page) 1
Set the tablespace table size.
Definition: fil0fil.cc:8657
PageCallback(PageCallback &&)=delete
const char * m_filepath
Physical file path.
Definition: fil0fil.h:1945
const page_size_t & get_page_size() const
The compressed page size.
Definition: fil0fil.h:1934
PageCallback(const PageCallback &)=delete
virtual space_id_t get_space_id() const 1=0
PageCallback & operator=(const PageCallback &)=delete
The buffer control block structure.
Definition: buf0buf.h:1746
Data structure for a database table.
Definition: dict0mem.h:1913
File space address.
Definition: fil0fil.h:1176
fil_addr_t()
Definition: fil0fil.h:1178
std::ostream & print(std::ostream &out) const
Print a string representation.
Definition: fil0fil.h:1198
uint32_t boffset
Byte offset within the page.
Definition: fil0fil.h:1208
fil_addr_t(page_no_t p, uint32_t boff)
Constructor.
Definition: fil0fil.h:1183
page_no_t page
Page number within a space.
Definition: fil0fil.h:1205
bool is_equal(const fil_addr_t &rhs) const
Compare to instances.
Definition: fil0fil.h:1188
bool is_null() const
Check if the file address is null.
Definition: fil0fil.h:1194
File node of a tablespace or the log data space.
Definition: fil0fil.h:158
page_no_t max_size
maximum size of the file in database pages
Definition: fil0fil.h:207
void set_flushed()
Sets file to flushed state.
Definition: fil0fil.h:167
size_t n_pending_ios
count of pending I/O's; is_open must be true if nonzero
Definition: fil0fil.h:210
fil_space_t * space
tablespace containing this file
Definition: fil0fil.h:172
size_t block_size
block size to use for punching holes
Definition: fil0fil.h:231
bool is_open
whether this file is open.
Definition: fil0fil.h:180
pfs_os_file_t handle
file handle (valid if is_open)
Definition: fil0fil.h:183
page_no_t init_size
initial size of the file in database pages; FIL_IBD_FILE_INITIAL_SIZE by default
Definition: fil0fil.h:204
page_no_t size
size of the file in database pages (0 if not known yet); the possible last incomplete megabyte may be...
Definition: fil0fil.h:196
size_t magic_n
FIL_NODE_MAGIC_N.
Definition: fil0fil.h:234
size_t n_pending_flushes
count of pending flushes; is_open must be true if nonzero
Definition: fil0fil.h:213
bool is_flushed() const
Returns true if the file is flushed.
Definition: fil0fil.h:162
os_event_t sync_event
event that groups and serializes calls to fsync
Definition: fil0fil.h:186
int64_t flush_counter
the modification_counter of the latest flush to disk
Definition: fil0fil.h:222
page_no_t flush_size
Size of the file when last flushed, used to force the flush when file grows to keep the filesystem me...
Definition: fil0fil.h:200
bool can_be_closed() const
Returns true if the file can be closed.
Definition: fil0fil.cc:1834
UT_LIST_NODE_T(fil_node_t) List_node
Definition: fil0fil.h:169
bool punch_hole
whether the file system of this file supports PUNCH HOLE
Definition: fil0fil.h:228
bool is_offset_valid(os_offset_t byte_offset) const
Definition: fil0fil.h:2315
int64_t modification_counter
number of writes to the file since the system was started
Definition: fil0fil.h:219
List_node LRU
link to the fil_system->LRU list (keeping track of open files)
Definition: fil0fil.h:225
char * name
file name; protected by Fil_shard::m_mutex and log_sys->mutex.
Definition: fil0fil.h:175
bool is_being_extended
Set to true when a file is being extended.
Definition: fil0fil.h:216
bool is_raw_disk
whether the file actually is a raw device or disk partition
Definition: fil0fil.h:189
Tablespace or log data space.
Definition: fil0fil.h:238
void initialize() noexcept
Initializes fields.
Definition: fil0fil.h:338
bool initialize_while_extending()
Definition: fil0fil.cc:11863
std::ostream & print_xdes_pages(std::ostream &out) const
Print the extent descriptor pages of this tablespace into the given output stream.
Definition: fil0fil.cc:9440
fil_node_t * get_file_node(page_no_t *page_no) noexcept
Get the file node corresponding to the given page number of the tablespace.
Definition: fil0fil.cc:11728
ib::Timer m_last_extended
When the tablespace was extended last.
Definition: fil0fil.h:320
size_t get_reference_count() const
Definition: fil0fil.cc:11790
space_id_t id
Tablespace ID.
Definition: fil0fil.h:334
bool is_compressed() const noexcept
Check if the tablespace is compressed.
Definition: fil0fil.h:552
Encryption::Progress encryption_op_in_progress
Encryption is in progress.
Definition: fil0fil.h:539
std::atomic_bool m_deleted
true if the tablespace is marked for deletion.
Definition: fil0fil.h:426
void bump_version()
Bumps the space object version and cause all pages in buffer pool that reference the current space ob...
Definition: fil0fil.cc:11812
List_node unflushed_spaces
List of spaces with at least one unflushed file we have written to.
Definition: fil0fil.h:527
page_no_t size
Tablespace file size in pages; 0 if not known yet.
Definition: fil0fil.h:487
rw_lock_t latch
Latch protecting the file space storage allocation.
Definition: fil0fil.h:522
ib::Throttler m_prevent_file_open_wait_message_throttler
Throttles writing to log a message about long waiting for file to perform rename.
Definition: fil0fil.h:462
uint32_t flags
Tablespace flags; see fsp_flags_is_valid() and page_size_t(ulint) (constructor).
Definition: fil0fil.h:504
void release_free_extents(ulint n_reserved)
Release the reserved free extents.
Definition: fil0fil.cc:9413
page_no_t size_in_header
FSP_SIZE in the tablespace header; 0 if not known yet.
Definition: fil0fil.h:490
std::atomic< uint32_t > m_version
All pages in the buffer pool that reference this fil_space_t instance with version before this versio...
Definition: fil0fil.h:382
Encryption_metadata m_encryption_metadata
Encryption metadata.
Definition: fil0fil.h:536
bool prevent_file_open
true if we want to rename the .ibd file of tablespace and want to temporarily prevent other threads f...
Definition: fil0fil.h:458
page_no_t m_undo_extend
Extend undo tablespaces by so many pages.
Definition: fil0fil.h:323
uint64_t autoextend_size_in_bytes
Autoextend size.
Definition: fil0fil.h:493
uint32_t free_len
Length of the FSP_FREE list.
Definition: fil0fil.h:496
lsn_t m_header_page_flush_lsn
Flush lsn of header page.
Definition: fil0fil.h:542
void dec_ref() noexcept
Decrement the page reference count.
Definition: fil0fil.h:296
std::atomic_size_t m_n_ref_count
Number of buf_page_t entries that point to this instance.
Definition: fil0fil.h:422
std::atomic< uint64_t > m_bulk_extend_size
true if bulk operation is in progress.
Definition: fil0fil.h:432
Files files
Files attached to this tablespace.
Definition: fil0fil.h:484
bool stop_new_ops
We set this true when we start deleting a single-table tablespace.
Definition: fil0fil.h:471
ulint magic_n
FIL_SPACE_MAGIC_N.
Definition: fil0fil.h:545
uint32_t n_reserved_extents
Number of reserved free extents for ongoing operations like B-tree page split.
Definition: fil0fil.h:508
bool can_encrypt() const noexcept
Check if the encryption details, like the encryption key, type and other details, that are needed to ...
Definition: fil0fil.h:565
uint64_t get_auto_extend_size()
Definition: fil0fil.cc:11853
uint32_t get_current_version() const
Returns current version of the space object.
Definition: fil0fil.cc:11770
bool is_encrypted() const noexcept
Check if the tablespace is encrypted.
Definition: fil0fil.h:558
static fil_space_t * s_sys_space
System tablespace.
Definition: fil0fil.h:548
uint32_t n_pending_ops
This is positive when we have pending operations against this tablespace.
Definition: fil0fil.h:518
page_no_t free_limit
Contents of FSP_FREE_LIMIT.
Definition: fil0fil.h:499
std::atomic_bool m_is_bulk
true if bulk operation is in progress.
Definition: fil0fil.h:429
UT_LIST_NODE_T(fil_space_t) List_node
Definition: fil0fil.h:239
uint32_t get_recent_version() const
Returns current version of the space object.
Definition: fil0fil.cc:11774
char * name
Tablespace name.
Definition: fil0fil.h:331
std::vector< Observer *, ut::allocator< Observer * > > Flush_observers
Definition: fil0fil.h:317
void end_bulk_operation()
End bulk operation on the space.
Definition: fil0fil.h:443
Compression::Type compression_type
Compression algorithm.
Definition: fil0fil.h:533
uint32_t n_pending_flushes
This is positive when flushing the tablespace to disk; dropping of the tablespace is forbidden if thi...
Definition: fil0fil.h:512
fil_type_t purpose
Purpose.
Definition: fil0fil.h:480
void set_deleted()
Marks the space object for deletion.
Definition: fil0fil.cc:11798
bool was_not_deleted() const
Definition: fil0fil.cc:11762
bool is_in_unflushed_spaces
true if this space is currently in unflushed_spaces
Definition: fil0fil.h:530
bool has_no_references() const
Definition: fil0fil.cc:11780
bool is_bulk_operation_in_progress() const
Definition: fil0fil.h:446
page_no_t m_undo_initial
When an undo tablespace has been initialized with required header pages, that size is recorded here.
Definition: fil0fil.h:328
std::vector< fil_node_t, ut::allocator< fil_node_t > > Files
Definition: fil0fil.h:240
void begin_bulk_operation(uint64_t extend_size)
Begin bulk operation on the space.
Definition: fil0fil.h:437
void inc_ref() noexcept
Increment the page reference count.
Definition: fil0fil.h:285
ulint redo_skipped_count
Reference count for operations who want to skip redo log in the file space in order to make fsp_space...
Definition: fil0fil.h:476
bool is_deleted() const
Definition: fil0fil.cc:11757
Mini-transaction handle and buffer.
Definition: mtr0mtr.h:177
InnoDB condition variable.
Definition: os0event.cc:63
Common file descriptor for file IO instrumentation with PFS on windows and other platforms.
Definition: os0file.h:172
The structure used in the spin lock implementation of a read-write lock.
Definition: sync0rw.h:363
Definition: trx0trx.h:675
Version control for database, common definitions, and include files.
#define UNIV_NOTHROW
Definition: univ.i:456
#define OS_PATH_SEPARATOR_ALT
Definition: univ.i:539
unsigned long int ulint
Definition: univ.i:406
#define ut_ad(EXPR)
Debug assertion.
Definition: ut0dbg.h:105
#define ut_a(EXPR)
Abort execution if EXPR does not evaluate to nonzero.
Definition: ut0dbg.h:93
#define UT_LIST_NODE_T(t)
Macro used for legacy reasons.
Definition: ut0lst.h:64
Dynamic memory allocation routines and custom allocators specifically crafted to support memory instr...
static uint64_t lsn
Definition: xcom_base.cc:446