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