The tablespace memory cache. More...

#include <errno.h>
#include <fcntl.h>
#include <sys/types.h>
#include <mysql/service_thd_wait.h>
#include "scope_guard.h"
#include "my_config.h"
#include "detail/fil/open_files_limit.h"
#include "arch0page.h"
#include "btr0btr.h"
#include "buf0buf.h"
#include "buf0flu.h"
#include "clone0api.h"
#include "dict0boot.h"
#include "dict0dd.h"
#include "dict0dict.h"
#include "fil0fil.h"
#include "fil0innodb_pages_persistence.h"
#include "fil0innodb_tablespaces_nodes.h"
#include "fil0tablespace_node_handle_interface.h"
#include "fil0tablespace_scan.h"
#include "fil0tablespaces_nodes_interface.h"
#include "fsp0file.h"
#include "fsp0fsp.h"
#include "fsp0space.h"
#include "fsp0sysspace.h"
#include "ha_prototypes.h"
#include "hash0hash.h"
#include "log0buf.h"
#include "log0chkp.h"
#include "log0handler_interface.h"
#include "log0helpers.h"
#include "log0recv.h"
#include "mach0data.h"
#include "mem0mem.h"
#include "mtr0log.h"
#include "my_dbug.h"
#include "os0file.h"
#include "page0zip.h"
#include "sql/mysqld.h"
#include "srv0srv.h"
#include "srv0start.h"
#include "trx0purge.h"
#include "univ.i"
#include "ut0dbg.h"
#include "ut0new.h"
#include "buf0lru.h"
#include "ibuf0ibuf.h"
#include "mysql/components/library_mysys/my_system.h"
#include "os0event.h"
#include "row0mysql.h"
#include "sql_backup_lock.h"
#include "sql_class.h"
#include "sync0sync.h"
#include "os0thread-create.h"
#include "current_thd.h"
#include <array>
#include <fstream>
#include <functional>
#include <list>
#include <mutex>
#include <thread>
#include <tuple>
#include <unordered_map>

Classes
struct	dd_fil::Moved

struct	Char_Ptr_Hash
	Hash a NUL terminated 'string'. More...

struct	Char_Ptr_Compare
	Compare two 'strings'. More...

class	Fil_shard

class	Fil_system
	The tablespace memory cache. More...

struct	Fil_page_iterator

Namespaces
namespace	dd_fil
	Used for collecting the data in boot_tablespaces()

namespace	ib

namespace	ib::fil

Macros
#define	mutex_acquire() acquire(__LINE__)
	We want to store the line number from where it was called. More...

#define	fil_report_invalid_page_access(b, s, n, l, t) fil_report_invalid_page_access_low((b), (s), (n), (l), (t), __LINE__)

#define	PAGE_TYPE(x)

Typedefs
using	dd_fil::Tablespaces = std::vector< Moved >

Enumerations
enum	fil_load_status { FIL_LOAD_OK , FIL_LOAD_ID_CHANGED , FIL_LOAD_NOT_FOUND , FIL_LOAD_INVALID , FIL_LOAD_MISMATCH , FIL_LOAD_DBWLR_CORRUPTION }

enum	fil_operation_t { FIL_OPERATION_DELETE , FIL_OPERATION_CLOSE }
	File operations for tablespace. More...

Functions
dberr_t	dict_stats_rename_table (const char old_name, const char new_name, char *errstr, size_t errstr_sz)
	Renames a table in InnoDB persistent stats storage. More...

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 consideration, number of cores available on the machine. More...

static bool	fil_needs_flushes_for_durability (const fil_space_t *space)
	Determine if flush is needed for durability. More...

void	ib::fil::set_tablespaces_nodes (ut::unique_ptr< Tablespaces_nodes_interface > new_tablepsaces_nodes)

void	ib::fil::set_pages_persistence (ut::unique_ptr< Pages_persistence_interface > new_persistence)
	Sets the implementation of the Pages_persistence_interface. More...

static bool	is_fast_shutdown ()

static bool	fil_op_replay_rename (fil_space_t *space, const std::string &old_name, const std::string &new_name)
	Replay a file rename operation on space present in the fil subsystem cache, if it is possible to perform. More...

static bool	fil_validate_skip ()
	Checks the consistency of the tablespace cache some of the time. More...

bool	fil_validate ()
	Checks the consistency of the tablespace cache. More...

static dberr_t	fil_read (const page_id_t &page_id, const page_size_t &page_size, byte *buf)
	Reads data from a space to a buffer. More...

static dberr_t	fil_write (const page_id_t &page_id, const page_size_t &page_size, ulint len, byte *buf)
	Writes data to a space from a buffer. More...

fil_space_t *	fil_space_get (space_id_t space_id)
	Look up a tablespace. More...

rw_lock_t *	fil_space_get_latch (space_id_t space_id)
	Returns the latch of a file space. More...

fil_type_t	fil_space_get_type (space_id_t space_id)
	Gets the type of a file space. More...

void	fil_space_set_imported (space_id_t space_id)
	Note that a tablespace has been imported. More...

void	fil_node_create (const char name, fil_space_t space, bool is_raw, page_no_t max_pages)
	Attach a node to a tablespace. More...

static bool	fil_space_free (space_id_t space_id, bool x_latched)
	Frees a space object from the tablespace memory cache. More...

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. More...

bool	fil_assign_new_space_id (space_id_t *space_id)
	Assigns a new space id for a new single-table tablespace. More...

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. More...

page_no_t	fil_space_get_size (space_id_t space_id)
	Returns the size of the space in pages. More...

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. More...

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. More...

uint32_t	fil_space_get_flags (space_id_t space_id)
	Returns the flags of the space. More...

ut::Expected< fil_space_t * >	fil_space_open (space_id_t space_id)
	Looks up the tablespace, acquires the space, opens each node of a tablespace if not already open, validates the first page if it was not validated yet and fills the FSP-related cache if it was not filled yet. More...

void	fil_space_close (space_id_t space_id)
	Close each file of a tablespace if open. More...

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. More...

void	fil_init (ulint max_n_open)
	Initializes the tablespace memory cache. More...

bool	fil_open_files_limit_update (size_t &new_max_open_files)
	Changes the maximum opened files limit. More...

static void	fil_validate_space_reference_count (fil_space_t *space, Space_References &buffer_pool_references)

void	fil_close_all_files ()
	Closes all open files. More...

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. More...

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. More...

fil_space_t *	fil_space_acquire (space_id_t space_id)
	Acquire a tablespace when it could be dropped concurrently. More...

fil_space_t *	fil_space_acquire_silent (space_id_t space_id)
	Acquire a tablespace that may not exist. More...

void	fil_space_release (fil_space_t *space)
	Release a tablespace acquired with fil_space_acquire(). More...

dberr_t	fil_close_tablespace (space_id_t space_id)
	Closes a single-table tablespace. More...

void	fil_op_write_log (mlog_id_t type, space_id_t space_id, const char path, const char new_path, uint32_t flags, mtr_t *mtr)
	Write a log record about an operation on a tablespace file. More...

dberr_t	fil_delete_tablespace (space_id_t space_id)
	Deletes an IBD or IBU tablespace. More...

bool	fil_truncate_tablespace (space_id_t space_id, page_no_t size_in_pages)
	Basically recreates the tablespace`s only node and set it to the needed size in place. More...

void	fil_space_inc_redo_skipped_count (space_id_t space_id)
	Increase redo skipped count for a tablespace. More...

void	fil_space_dec_redo_skipped_count (space_id_t space_id)
	Decrease redo skipped count for a tablespace. More...

bool	fil_space_is_redo_skipped (space_id_t space_id)
	Check whether a single-table tablespace is redo skipped. More...

dberr_t	fil_discard_tablespace (space_id_t space_id)
	Discards a single-table tablespace. More...

static void	fil_name_write_rename (space_id_t space_id, const char old_name, const char new_name, mtr_t *mtr)
	Write redo log for renaming a file. More...

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 exists and the new filepath does not exist. More...

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. More...

dberr_t	fil_rename_tablespace_by_id (space_id_t space_id, const char old_name, const char new_name)
	Rename a tablespace. More...

dberr_t	fil_write_initial_pages (pfs_os_file_t file, const char path, const byte encrypt_info, space_id_t space_id, const uint32_t space_flags)
	Write initial pages for a new tablespace file created. More...

static dberr_t	fil_create_tablespace (const space_id_t space_id, const char *name, const uint32_t flags, const page_no_t size_in_pages, const fil_type_t type, const ib::fil::Tablespaces_nodes_interface::Create_node_hints &create_node_hints)
	Create a tablespace (an IBD or IBT or UNDO) file. More...

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. More...

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. More...

dberr_t	fil_undo_create (space_id_t space_id, const char name, const char path, uint32_t flags, page_no_t size, bool is_explicit)
	Create an UNDO tablespace file. More...

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 is correct. More...

bool	fil_space_read_name_and_filepath (space_id_t space_id, std::string &name, std::string &filepath)
	Looks for a pre-existing fil_space_t with the given tablespace ID and, if found, returns the name and filepath in newly allocated buffers that the caller must free. More...

std::string	fil_path_to_space_name (const std::string &file_path, space_id_t space_id, uint32_t flags)
	Convert a file path to a tablespace name, based on space ID and its flags. More...

std::string	fil_path_to_space_name (std::string file_path)
	Convert a file name to a tablespace name. More...

static void	fil_report_missing_tablespace (const char *name, space_id_t space_id)
	Report that a tablespace for a table was not found. More...

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. More...

space_id_t	fil_space_get_id_by_name (const char *name)
	Returns the space ID based on the tablespace name. More...

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. More...

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. More...

void	fil_space_release_free_extents (space_id_t space_id, ulint n_reserved)
	Releases free extents in a file space. More...

ulint	fil_space_get_n_reserved_extents (space_id_t space_id)
	Gets the number of reserved extents. More...

static void	fil_report_invalid_page_access_low (page_no_t block_offset, space_id_t space_id, const char *space_name, ulint len, bool is_read, int line)
	Report information about an invalid page access. More...

void	fil_io_set_encryption (IORequest &req_type, const page_id_t &page_id, fil_space_t *space)
	Set encryption information for IORequest. More...

void	fil_aio_wait (ulint segment)
	Waits for an AIO operation to complete. More...

dberr_t	fil_io (IORequest::Type type, bool sync, const page_id_t &page_id, const page_size_t &page_size, ulint len, byte buf, buf_page_t bpage, bool evict_after_write, std::function< void(dberr_t err)> pre_io_complete_callback)
	Read or write data for a single page from a file. More...

void	fil_flush (space_id_t space_id)
	Flushes to disk possible writes cached by the OS. More...

void	fil_flush_file_spaces ()
	Flush to disk the writes in file spaces possibly cached by the OS (note: spaces of type FIL_TYPE_TEMPORARY are skipped) More...

bool	fil_addr_is_null (const fil_addr_t &addr)
	Returns true if file address is undefined. More...

page_no_t	fil_page_get_prev (const byte *page)
	Get the predecessor of a file page. More...

page_no_t	fil_page_get_next (const byte *page)
	Get the successor of a file page. More...

void	fil_page_set_type (byte *page, ulint type)
	Sets the file page type. More...

void	fil_page_reset_type (const page_id_t &page_id, byte page, ulint type, mtr_t mtr)
	Reset the page type. More...

void	fil_close ()
	Closes the tablespace memory cache. More...

static void	fil_buf_block_init (buf_block_t block, byte frame)
	Initializes the buffer control block used by fil_tablespace_iterate. More...

static dberr_t	fil_iterate (const Fil_page_iterator &iter, buf_block_t *block, PageCallback &callback)
	TODO: This can be made parallel trivially by chunking up the file and creating a callback per thread. More...

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. More...

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. More...

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. More...

dberr_t	fil_set_compression (space_id_t space_id, const char *algorithm)
	Set the compression type for the tablespace. More...

Compression::Type	fil_get_compression (space_id_t space_id)
	Get the compression algorithm for a tablespace. More...

dberr_t	fil_set_autoextend_size (space_id_t space_id, uint64_t autoextend_size)
	Set the autoextend_size attribute for the tablespace. More...

dberr_t	fil_set_encryption (space_id_t space_id, Encryption::Type algorithm, byte key, byte iv)
	Set the encryption type for the tablespace. More...

dberr_t	fil_reset_encryption (space_id_t space_id)
	Reset the encryption type for the tablespace. More...

size_t	fil_encryption_rotate ()
	Rotate the tablespace keys by new master key. More...

void	fil_encryption_reencrypt (const std::vector< space_id_t > &sid_vector)
	Re-encrypt the tablespace keys by current master key. More...

void	fil_space_set_flags (fil_space_t *space, uint32_t flags)
	Sets the flags of the tablespace. More...

static void	fil_tablespace_encryption_init (const fil_space_t *space)
	Initialize the table space encryption. More...

static void	fil_adjust_partition_stat (const std::string &old_path, const std::string &new_path)
	Modify table name in Innodb persistent stat tables, if needed. More...

dberr_t	fil_open_for_business (bool read_only_mode)
	Free the Tablespace_files instance. More...

bool	fil_op_replay_rename_for_ddl (const space_id_t space_id, const char old_name, const char new_name)
	Replay a file rename operation for ddl replay. More...

static std::string	fil_real_dir_for_lookup (const std::string &dir)
	Real path of the input directory. More...

bool	fil_tablespace_lookup_for_recovery (space_id_t space_id)
	Lookup the tablespace ID. More...

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. More...

Fil_state	fil_tablespace_dir_equals (const space_id_t space_id, const char *space_name, const ulint fsp_flags, const Dirs_in_datadir &schema_dirs, const std::string old_path, std::string &new_path)
	Lookups the tablespace ID in the scanned tablespaces and return its path to the file. More...

void	fil_add_moved_space (dd::Object_id dd_object_id, space_id_t space_id, const char *space_name, const std::string &old_path, const std::string &new_path, bool dd_flag_missing)
	Add tablespace to the set of tablespaces to be updated in DD. More...

const byte *	fil_tablespace_redo_create_wrapper (const byte ptr, const byte end, space_id_t space_id)
	TODO: This is a wrapper for fil_tablespace_redo_create to be called during recovery, it uses tablespace_scanning to resolve tablespace file path. More...

static const byte *	parse_path_from_redo (const byte ptr, const byte end, bool check_suffix, std::string &path, std::string &error_str)
	Parse a path from a buffer. More...

const byte *	fil_tablespace_redo_create (const byte ptr, const byte end, space_id_t space_id, bool parse_only)
	Redo a tablespace create. More...

const byte *	fil_tablespace_redo_rename (const byte ptr, const byte end, space_id_t space_id, bool parse_only)
	Redo a tablespace rename. More...

const byte *	fil_tablespace_redo_extend_wrapper (const byte ptr, const byte end, space_id_t space_id)
	TODO: This is a wrapper for fil_tablespace_redo_extend to be called during recovery, it makes sure tablespace is loaded in fil cache. More...

const byte *	fil_tablespace_redo_extend (const byte ptr, const byte end, space_id_t space_id, bool parse_only)
	Redo a tablespace extend. More...

const byte *	fil_tablespace_redo_delete_wrapper (const byte ptr, const byte end, space_id_t space_id)
	TODO: This is a wrapper for fil_tablespace_redo_delete to be called during recovery, it uses tablespace_scanning to resolve tablespace file path. More...

const byte *	fil_tablespace_redo_delete (const byte ptr, const byte end, space_id_t space_id, bool parse_only)
	Redo a tablespace delete. More...

std::optional< bool >	fil_tablespace_redo_encryption (const byte ptr, const byte end, space_id_t space_id, lsn_t lsn)
	Parse and process an encryption redo record. More...

void	fil_space_update_name (fil_space_t space, const char name)
	Update the tablespace name. More...

void	fil_purge ()
	Allows fil system to do periodical cleanup. More...

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 cache. More...

const char *	fil_get_page_type_str (page_type_t type) noexcept
	Get the page type as a string. More...

bool	fil_is_page_type_valid (page_type_t type) noexcept
	Check if the given page type is valid. More...

dberr_t	fil_prepare_file_for_io (space_id_t space_id, page_no_t &page_no, fil_node_t **node_out)

void	fil_complete_write (space_id_t space_id, fil_node_t *node)

Variables
Fil_path	MySQL_datadir_path
	Reference to the server data directory. More...

Fil_path	MySQL_undo_path
	Reference to the server undo directory. More...

bool	MySQL_undo_path_is_unique
	The undo path is different from any other known directory. More...

const char *	dot_ext []
	Common InnoDB file extensions. More...

std::atomic< std::uint64_t >	fil_n_pending_tablespace_flushes = 0
	Number of pending tablespace flushes. More...

std::atomic_size_t	fil_n_files_open {0}
	Number of files currently open. More...

fil_addr_t	fil_addr_null = {FIL_NULL, 0}
	The null file address. More...

static const size_t	MAX_SHARDS = 68
	Maximum number of shards supported. More...

static const size_t	UNDO_SHARDS = 4
	Number of undo shards to reserve. More...

static const size_t	UNDO_SHARDS_START = MAX_SHARDS - UNDO_SHARDS
	The UNDO logs have their own shards (4). More...

static Fil_system *	fil_system = nullptr
	The tablespace memory cache. More...

ut::unique_ptr< ib::fil::Tablespaces_nodes_interface >	tablespaces_nodes
	The low-level tablespaces' nodes' storage implementation. More...

ut::unique_ptr< ib::fil::Pages_persistence_interface >	pages_persistence
	The implementation of persistence for the pages stored in tablespaces' nodes' storage. More...

ut::unique_ptr< ib::fil::Tablespace_scanning >	tablespace_scanning

static const size_t	FIL_VALIDATE_SKIP = 17
	Try fil_validate() every this many times. More...

Detailed Description

The tablespace memory cache.

Macro Definition Documentation

◆ fil_report_invalid_page_access

#define fil_report_invalid_page_access	(	b,
		s,
		n,
		l,
		t
	)	fil_report_invalid_page_access_low((b), (s), (n), (l), (t), __LINE__)

◆ mutex_acquire

#define mutex_acquire ( ) acquire(__LINE__)

We want to store the line number from where it was called.

◆ PAGE_TYPE

#define PAGE_TYPE ( x )

Value:

case x: \

return #x;

Enumeration Type Documentation

◆ fil_load_status

enum fil_load_status

Enumerator
FIL_LOAD_OK	The tablespace file(s) were found and valid.
FIL_LOAD_ID_CHANGED	The name no longer matches space_id.
FIL_LOAD_NOT_FOUND	The file(s) were not found.
FIL_LOAD_INVALID	The file(s) were not valid.
FIL_LOAD_MISMATCH	The tablespace file ID in the first page doesn't match expected value.
FIL_LOAD_DBWLR_CORRUPTION	Doublewrite buffer corruption.

◆ fil_operation_t

enum fil_operation_t

File operations for tablespace.

Enumerator
FIL_OPERATION_DELETE	delete a single-table tablespace
FIL_OPERATION_CLOSE	close a single-table tablespace

Function Documentation

◆ dict_stats_rename_table()

dberr_t dict_stats_rename_table	(	const char *	old_name,
		const char *	new_name,
		char *	errstr,
		size_t	errstr_sz
	)

Renames a table in InnoDB persistent stats storage.

This function creates its own transaction and commits it.

Returns: DB_SUCCESS or error code

Parameters

old_name	in: old name, e.g. 'db/table'
new_name	in: new name, e.g. 'db/table'
errstr	out: error string if != DB_SUCCESS is returned
errstr_sz	in: errstr size

◆ fil_add_moved_space()

void fil_add_moved_space	(	dd::Object_id	dd_object_id,
		space_id_t	space_id,
		const char *	space_name,
		const std::string &	old_path,
		const std::string &	new_path,
		bool	dd_flag_missing
	)

Add tablespace to the set of tablespaces to be updated in DD.

Parameters

[in]	dd_object_id	Server DD tablespace ID
[in]	space_id	Innodb tablespace ID
[in]	space_name	New tablespace name
[in]	old_path	Old Path in the data dictionary
[in]	new_path	New path to be update in dictionary
[in]	dd_flag_missing	This tablespace is outside default data directory, yet it is missing DD_TABLE_DATA_DIRECTORY flag. This could happen in versions earlier than 8.0.38/8.4.1/9.0.0

◆ fil_addr_is_null()

bool fil_addr_is_null ( const fil_addr_t & addr )

Returns true if file address is undefined.

Parameters

[in] addr File address to check

Returns: true if undefined

◆ fil_adjust_name_import()

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.

Parameters

[in]	table	Innodb dict table
[in]	path	file path to open
[in]	extn	file extension

◆ fil_adjust_partition_stat()

static void fil_adjust_partition_stat	(	const std::string &	old_path,
		const std::string &	new_path
	)

static

Modify table name in Innodb persistent stat tables, if needed.

Required when partitioned table file names from old versions are modified to change the letter case.

Parameters

[in]	old_path	path to old file
[in]	new_path	path to new file

◆ fil_aio_wait()

void fil_aio_wait ( ulint segment )

Waits for an AIO operation to complete.

This function is used to write the handler for completed requests. The aio array of pending requests is divided into segments (see os0file.cc for more info). The thread specifies which segment it wants to wait for.

Parameters

[in] segment The number of the segment in the AIO array to wait for

◆ fil_assign_new_space_id()

bool fil_assign_new_space_id ( space_id_t * space_id )

Assigns a new space id for a new single-table tablespace.

This works simply by incrementing the global counter. If 4 billion id's is not enough, we may need to recycle id's.

Parameters

[out] space_id Set this to the new tablespace ID

Returns: true if assigned, false if not

◆ fil_buf_block_init()

static void fil_buf_block_init	(	buf_block_t *	block,
		byte *	frame
	)

static

Initializes the buffer control block used by fil_tablespace_iterate.

Parameters

[in]	block	Pointer to the control block
[in]	frame	Pointer to buffer frame

◆ fil_close()

void fil_close ( )

Closes the tablespace memory cache.

Initializes the tablespace memory cache.

◆ fil_close_all_files()

void fil_close_all_files ( )

Closes all open files.

There must not be any pending i/o's or not flushed modifications in the files.

◆ fil_close_tablespace()

dberr_t fil_close_tablespace ( space_id_t space_id )

Closes a single-table tablespace.

The tablespace must be cached in the memory cache. Free all pages used by the tablespace.

Parameters

[in] space_id Tablespace ID

Returns: DB_SUCCESS or error

◆ fil_complete_write()

void fil_complete_write	(	space_id_t	space_id,
		fil_node_t *	node
	)

◆ fil_count_undo_deleted()

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 cache.

Parameters

[in] undo_num undo tablespace number.

Returns: number of undo tablespaces that are still in memory.

◆ fil_create_tablespace()

static dberr_t fil_create_tablespace	(	const space_id_t	space_id,
		const char *	name,
		const uint32_t	flags,
		const page_no_t	size_in_pages,
		const fil_type_t	type,
		const ib::fil::Tablespaces_nodes_interface::Create_node_hints &	create_node_hints
	)

static

Create a tablespace (an IBD or IBT or UNDO) file.

Parameters

[in]	space_id	Tablespace ID
[in]	name	Tablespace name in dbname/tablename format. For general tablespaces, the 'dbname/' part may be missing.
[in]	flags	Tablespace flags
[in]	size_in_pages	Initial size of the tablespace file in pages, must be >= FIL_IBD_FILE_INITIAL_SIZE
[in]	type	FIL_TYPE_TABLESPACE or FIL_TYPE_TEMPORARY
[in]	create_node_hints	Additional information that is required to create the tablespace.

Returns: DB_SUCCESS or error code

◆ fil_delete_tablespace()

dberr_t fil_delete_tablespace ( space_id_t space_id )

Deletes an IBD or IBU tablespace.

The tablespace must be cached in the memory cache. This will delete the datafile, fil_space_t & fil_node_t entries from the file_system_t cache. The pages of this space that are cached in the BufferPool will remain untouched, will be discarded lazily when accessed or encountered in lists like flush list or LRU, as they will be visible as being stale.

Parameters

[in] space_id Tablespace ID

Returns: DB_SUCCESS, DB_TABLESPCE_NOT_FOUND or DB_IO_ERROR

◆ fil_discard_tablespace()

dberr_t fil_discard_tablespace ( space_id_t space_id )

Discards a single-table tablespace.

The tablespace must be cached in the memory cache. Discarding is like deleting a tablespace, but

We do not drop the table from the data dictionary;
We remove all insert buffer entries for the tablespace immediately; in DROP TABLE they are only removed gradually in the background;
When the user does IMPORT TABLESPACE, the tablespace will have the same id as it originally had.
Free all the pages in use by the tablespace if rename=true.
Parameters

[in] space_id Tablespace ID

Returns
DB_SUCCESS or error

◆ fil_encryption_reencrypt()

void fil_encryption_reencrypt ( const std::vector< space_id_t > & sid_vector )

Re-encrypt the tablespace keys by current master key.

◆ fil_encryption_rotate()

size_t fil_encryption_rotate ( )

Rotate the tablespace keys by new master key.

Returns: the number of tablespaces that failed to rotate.

◆ fil_flush()

void fil_flush ( space_id_t space_id )

Flushes to disk possible writes cached by the OS.

If the space does not exist or is being dropped, does not do anything.

Parameters

[in] space_id Tablespace ID

◆ fil_flush_file_spaces()

void fil_flush_file_spaces ( )

Flush to disk the writes in file spaces possibly cached by the OS (note: spaces of type FIL_TYPE_TEMPORARY are skipped)

◆ fil_get_compression()

Compression::Type fil_get_compression ( space_id_t space_id )

Get the compression algorithm for a tablespace.

Parameters

[in] space_id Space ID to check

Returns: the compression algorithm

◆ fil_get_page_type_str()

const char * fil_get_page_type_str ( page_type_t type )

noexcept

Get the page type as a string.

Parameters

[in] type page type to be converted to string.

Returns: the page type as a string.

◆ fil_get_scan_threads()

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 consideration, number of cores available on the machine.

Parameters

[in] num_files Number of files to be scanned

Returns: number of threads to be spawned for scanning the files

◆ fil_ibd_create()

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.

Parameters

[in]	space_id	Tablespace ID
[in]	name	Tablespace name in dbname/tablename format. For general tablespaces, the 'dbname/' part may be missing.
[in]	path	Path and filename of the datafile to create.
[in]	flags	Tablespace flags
[in]	size	Initial size of the tablespace file in pages, must be >= FIL_IBD_FILE_INITIAL_SIZE

Returns: DB_SUCCESS or error code

◆ fil_ibd_open()

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 is correct.

If the file is already open, the validation will be done before reporting success. If not successful, print an error message to the error log. This function is used to open a tablespace when we start up mysqld, and also in IMPORT TABLESPACE. NOTE that we assume this operation is used either at the database startup or under the protection of the dictionary mutex, so that two users cannot race here.

The fil_node_t::handle will not be left open.

Parameters

[in]	validate	whether we should validate the tablespace (read the first page of the file and check that the space id in it matches id)
[in]	purpose	FIL_TYPE_TABLESPACE or FIL_TYPE_TEMPORARY
[in]	space_id	Tablespace ID
[in]	flags	tablespace flags
[in]	space_name	tablespace name of the datafile If file-per-table, it is the table name in the databasename/tablename format
[in]	path_in	expected filepath, usually read from dictionary
[in]	strict	whether to report error when open ibd failed
[in]	old_space	whether it is a 5.7 tablespace opening by upgrade

Returns: DB_SUCCESS or error code

◆ fil_ibt_create()

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.

Parameters

[in]	space_id	Tablespace ID
[in]	name	Tablespace name
[in]	path	Path and filename of the datafile to create.
[in]	flags	Tablespace flags
[in]	size	Initial size of the tablespace file in pages, must be >= FIL_IBT_FILE_INITIAL_SIZE

Returns: DB_SUCCESS or error code

◆ fil_init()

void fil_init ( ulint max_n_open )

Initializes the tablespace memory cache.

Parameters

[in] max_n_open Maximum number of open files

◆ fil_io()

dberr_t fil_io	(	IORequest::Type	type,
		bool	sync,
		const page_id_t &	page_id,
		const page_size_t &	page_size,
		ulint	len,
		byte *	buf,
		buf_page_t *	bpage,
		bool	evict_after_write,
		std::function< void(dberr_t err)>	pre_io_complete_callback = `[](dberr_t) {}`
	)

Read or write data for a single page from a file.

Parameters

[in]	type	IO type
[in]	sync	If true then do synchronous IO
[in]	page_id	Page id to read or write.
[in]	page_size	Structure with information on logical and physical page size in the affected tablespace.
[in]	len	Size of the `buf` supplied. It always has to be a multiply of OS block size (UNIV_SECTOR_SIZE). In case of write of an already compressed data, it is a length of the compressed data buffer. Otherwise it should be `page_size.physical()`. Actual number of bytes written can be smaller if the tablespace has compression enabled and data was not compressed already.
[in,out]	buf	A buffer where to store read data or from where to write. Data from this buffer might be copied and the copy transformed before writing it. It must be aligned in memory to OS block size (UNIV_SECTOR_SIZE). Additionally, for reads, it must be aligned to physical page size, too. The memory pointed is managed by the caller and must remain valid until the call returns if `sync` is true, or until the `postprocess_result` callback begins execution.
[in]	bpage	Pointer to the page descriptor in the buffer pool. This can be nullptr only if we assure the tablespace can't be deleted in meantime. If this is nullptr, the page with this page_id can't be in the buffer pool, as it risks race condition with a Buffer Pool-induced page flush.
[in]	evict_after_write	Evicts the page after successful write. It is ignored if `bpage` is nullptr or if it is not a write request.
[in]	pre_io_complete_callback	A callback to be called exactly once when the result of this IO operation is known. It may be a success if the read or write succeeded or a subset of `dberr_t` errors if the write or read could not be executed or if it failed. It can be called synchronously in this thread before returning from this method, or can be executed asynchronously from another thread, when `sync` is false, before or after this call returns. The `buf_page_io_complete()` is called after this callback returns DB_SUCCESS and `bpage` is not null.

Returns: error code

Return values

DB_SUCCESS	on success
DB_TABLESPACE_DELETED	if the tablespace does not exist Note: this is not an exhaustive list of errors returned.

◆ fil_io_set_encryption()

void fil_io_set_encryption	(	IORequest &	req_type,
		const page_id_t &	page_id,
		fil_space_t *	space
	)

Set encryption information for IORequest.

Parameters

[in,out]	req_type	IO request
[in]	page_id	page id
[in]	space	table space

◆ fil_is_page_type_valid()

bool fil_is_page_type_valid ( page_type_t type )

noexcept

Check if the given page type is valid.

Parameters

[in] type the page type to be checked for validity.

Returns: true if it is valid page type, false otherwise.

◆ fil_iterate()

static dberr_t fil_iterate	(	const Fil_page_iterator &	iter,
		buf_block_t *	block,
		PageCallback &	callback
	)

static

TODO: This can be made parallel trivially by chunking up the file and creating a callback per thread.

Main benefit will be to use multiple CPUs for checksums and compressed tables. We have to do compressed tables block by block right now. Secondly we need to decompress/compress and copy too much of data. These are CPU intensive.

Iterate over all the pages in the tablespace.

Parameters

[in]	iter	Tablespace iterator
[in,out]	block	Block to use for IO
[in]	callback	Callback to inspect and update page contents

Return values

DB_SUCCESS or error code

◆ fil_name_write_rename()

static void fil_name_write_rename	(	space_id_t	space_id,
		const char *	old_name,
		const char *	new_name,
		mtr_t *	mtr
	)

static

Write redo log for renaming a file.

Parameters

[in]	space_id	Tablespace id
[in]	old_name	Tablespace file name
[in]	new_name	Tablespace file name after renaming
[in,out]	mtr	Mini-transaction

◆ fil_needs_flushes_for_durability()

static bool fil_needs_flushes_for_durability ( const fil_space_t * space )

inlinestatic

Determine if flush is needed for durability.

It could be disabled for example when user has explicitly disabled fsync().

◆ fil_node_create()

void fil_node_create	(	const char *	name,
		fil_space_t *	space,
		bool	is_raw,
		page_no_t	max_pages
	)

Attach a node to a tablespace.

Parameters

[in]	name	file name (file must be closed)
[in,out]	space	space where to attach to. Must not be null.
[in]	is_raw	true if a raw device or a raw disk partition
[in]	max_pages	maximum number of pages in file

◆ fil_op_replay_rename()

static bool fil_op_replay_rename	(	fil_space_t *	space,
		const std::string &	old_name,
		const std::string &	new_name
	)

static

Replay a file rename operation on space present in the fil subsystem cache, if it is possible to perform.

Parameters

[in]	space	Pointer to the space object.
[in]	old_name	old file name
[in]	new_name	new file name

Returns: true iff the file for the specified space is already found at the new_name, or operation was successfully applied - the new name file did not exist before the rename as file was successfully renamed to new_name.

◆ fil_op_replay_rename_for_ddl()

bool fil_op_replay_rename_for_ddl	(	space_id_t	space_id,
		const char *	old_name,
		const char *	new_name
	)

Replay a file rename operation for ddl replay.

Parameters

[in]	space_id	Space ID
[in]	old_name	old file name
[in]	new_name	new file name

Returns: whether the operation was successfully applied (the name did not exist, or new_name did not exist and name was successfully renamed to new_name)

◆ fil_op_write_log()

void fil_op_write_log	(	mlog_id_t	type,
		space_id_t	space_id,
		const char *	path,
		const char *	new_path,
		uint32_t	flags,
		mtr_t *	mtr
	)

Write a log record about an operation on a tablespace file.

Parameters

[in]	type	MLOG_FILE_OPEN or MLOG_FILE_DELETE or MLOG_FILE_CREATE or MLOG_FILE_RENAME
[in]	space_id	Tablespace identifier
[in]	path	File path
[in]	new_path	If type is MLOG_FILE_RENAME, the new name
[in]	flags	If type is MLOG_FILE_CREATE, the space flags
[in,out]	mtr	Mini-transaction

◆ fil_open_files_limit_update()

bool fil_open_files_limit_update ( size_t & new_max_open_files )

Changes the maximum opened files limit.

Parameters

[in,out] new_max_open_files New value for the open files limit. If the limit cannot be changed, the value is changed to a minimum value recommended.

Returns: true if the new limit was set.

◆ fil_open_for_business()

dberr_t fil_open_for_business ( bool read_only_mode )

Free the Tablespace_files instance.

Parameters

[in] read_only_mode true if InnoDB is started in read only mode.

Returns: DB_SUCCESS if all OK

◆ fil_page_get_next()

page_no_t fil_page_get_next ( const byte * page )

Get the successor of a file page.

Parameters

[in] page File page

Returns: FIL_PAGE_NEXT

◆ fil_page_get_prev()

page_no_t fil_page_get_prev ( const byte * page )

Get the predecessor of a file page.

Parameters

[in] page File page

Returns: FIL_PAGE_PREV

◆ fil_page_reset_type()

void fil_page_reset_type	(	const page_id_t &	page_id,
		byte *	page,
		ulint	type,
		mtr_t *	mtr
	)

Reset the page type.

Data files created before MySQL 5.1 may contain garbage in FIL_PAGE_TYPE. In MySQL 3.23.53, only undo log pages and index pages were tagged. Any other pages were written with uninitialized bytes in FIL_PAGE_TYPE.

Parameters

[in]	page_id	Page number
[in,out]	page	Page with invalid FIL_PAGE_TYPE
[in]	type	Expected page type
[in,out]	mtr	Mini-transaction

◆ fil_page_set_type()

void fil_page_set_type	(	byte *	page,
		ulint	type
	)

Sets the file page type.

Parameters

[in,out]	page	File page
[in]	type	File page type to set

◆ fil_path_to_space_name() [1/2]

std::string fil_path_to_space_name	(	const std::string &	file_path,
		space_id_t	space_id,
		uint32_t	flags
	)

Convert a file path to a tablespace name, based on space ID and its flags.

Parameters

[in]	file_path	Full path to the tablespace file.
[in]	space_id	space_id emitted by the redo log
[in]	flags	FSP flags of the tablespace.

◆ fil_path_to_space_name() [2/2]

std::string fil_path_to_space_name ( std::string filename )

Convert a file name to a tablespace name.

Strip the file name prefix and suffix, leaving only databasename/tablename.

Parameters

[in] filename directory/databasename/tablename.ibd

Returns: database/tablename string

◆ fil_prepare_file_for_io()

dberr_t fil_prepare_file_for_io	(	space_id_t	space_id,
		page_no_t &	page_no,
		fil_node_t **	node_out
	)

◆ fil_purge()

void fil_purge ( )

Allows fil system to do periodical cleanup.

◆ fil_read()

static dberr_t fil_read	(	const page_id_t &	page_id,
		const page_size_t &	page_size,
		byte *	buf
	)

static

Reads data from a space to a buffer.

Remember that the possible incomplete blocks at the end of file are ignored: they are not taken into account when calculating the byte offset within a space. If the data on disk is compressed or encrypted, the data is decompressed and decrypted using tablespace's keys before returning in the buf.

Parameters

[in]	page_id	page id
[in]	page_size	Structure with information on logical and physical page size in the affected tablespace.
[in,out]	buf	A buffer where to store read data. It must be aligned to physical page size. It must be able to contain physical page size bytes of data. The memory pointed is managed by the caller and must remain valid until the call returns.

Returns: DB_SUCCESS, or DB_TABLESPACE_DELETED if we are trying to do I/O on a tablespace which does not exist

◆ fil_real_dir_for_lookup()

static std::string fil_real_dir_for_lookup ( const std::string & dir )

static

Real path of the input directory.

Parameters

[in] dir Directory path

Returns: normalized real path, without trailing separator

◆ fil_rename_precheck()

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.

Parameters

[in]	old_table	old table
[in]	new_table	new table
[in]	tmp_name	temporary table name

Returns: innodb error code

◆ fil_rename_tablespace()

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.

The tablespace must exist in the memory cache.

Parameters

[in]	space_id	Tablespace ID
[in]	old_path	Old file name
[in]	new_name	New tablespace name in the schema/name format
[in]	new_path_in	New file name, or nullptr if it is located in the normal data directory

Returns: InnoDB error code

◆ fil_rename_tablespace_by_id()

dberr_t fil_rename_tablespace_by_id	(	space_id_t	space_id,
		const char *	old_name,
		const char *	new_name
	)

Rename a tablespace.

Use the space_id to find the shard.

Parameters

[in]	space_id	tablespace ID
[in]	old_name	old tablespace name
[in]	new_name	new tablespace name

Returns: DB_SUCCESS on success

◆ fil_rename_tablespace_check()

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 exists and the new filepath does not exist.

Any unexpected errors are reported as DB_ERROR.

Parameters

[in]	space_id	Tablespace ID
[in]	old_path	Old filepath
[in]	new_path	New filepath
[in]	is_discarded	Whether the tablespace is discarded

Returns: innodb error code

◆ fil_report_invalid_page_access_low()

static void fil_report_invalid_page_access_low	(	page_no_t	block_offset,
		space_id_t	space_id,
		const char *	space_name,
		ulint	len,
		bool	is_read,
		int	line
	)

static

Report information about an invalid page access.

Parameters

[in]	block_offset	Block offset
[in]	space_id	Tablespace ID
[in]	space_name	Tablespace name
[in]	len	I/O length
[in]	is_read	I/O type
[in]	line	Line called from

◆ fil_report_missing_tablespace()

static void fil_report_missing_tablespace	(	const char *	name,
		space_id_t	space_id
	)

static

Report that a tablespace for a table was not found.

Parameters

[in]	name	Table name
[in]	space_id	Table's space ID

◆ fil_reset_encryption()

dberr_t fil_reset_encryption ( space_id_t space_id )

Reset the encryption type for the tablespace.

Parameters

[in] space_id Space ID of tablespace for which to set

Returns: DB_SUCCESS or error code

◆ fil_set_autoextend_size()

dberr_t fil_set_autoextend_size	(	space_id_t	space_id,
		uint64_t	autoextend_size
	)

Set the autoextend_size attribute for the tablespace.

Parameters

[in]	space_id	Space ID of tablespace for which to set
[in]	autoextend_size	Value of autoextend_size attribute

Returns: DB_SUCCESS or error code

◆ fil_set_compression()

dberr_t fil_set_compression	(	space_id_t	space_id,
		const char *	algorithm
	)

Set the compression type for the tablespace.

Parameters

[in]	space_id	Space ID of the tablespace
[in]	algorithm	Text representation of the algorithm

Returns: DB_SUCCESS or error code

◆ fil_set_encryption()

dberr_t fil_set_encryption	(	space_id_t	space_id,
		Encryption::Type	algorithm,
		byte *	key,
		byte *	iv
	)

Set the encryption type for the tablespace.

Parameters

[in]	space_id	Space ID of tablespace for which to set
[in]	algorithm	Encryption algorithm
[in]	key	Encryption key
[in]	iv	Encryption iv

Returns: DB_SUCCESS or error code

◆ fil_set_max_space_id_if_bigger()

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.

Parameters

[in] max_id Maximum known tablespace ID

◆ fil_space_acquire()

fil_space_t * fil_space_acquire ( space_id_t space_id )

Acquire a tablespace when it could be dropped concurrently.

Used by background threads that do not necessarily hold proper locks for concurrency control.

Parameters

[in] space_id Tablespace ID

Returns: the tablespace, or nullptr if missing or being deleted

◆ fil_space_acquire_silent()

fil_space_t * fil_space_acquire_silent ( space_id_t space_id )

Acquire a tablespace that may not exist.

Used by background threads that do not necessarily hold proper locks for concurrency control.

Parameters

[in] space_id Tablespace ID

Returns: the tablespace, or nullptr if missing or being deleted

◆ fil_space_close()

void fil_space_close ( space_id_t space_id )

Close each file of a tablespace if open.

Parameters

[in] space_id Tablespace ID

◆ fil_space_create()

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.

The tablespace name is independent from the tablespace file-name. Error messages are issued to the server log.

Parameters

[in]	name	Tablespace name
[in]	space_id	Tablespace ID
[in]	flags	Tablespace flags
[in]	purpose	Tablespace purpose

Returns: pointer to created tablespace, to be filled in with fil_node_create()

Return values

nullptr on failure (such as when the same tablespace exists)

◆ fil_space_dec_redo_skipped_count()

void fil_space_dec_redo_skipped_count ( space_id_t space_id )

Decrease redo skipped count for a tablespace.

Parameters

[in] space_id Tablespace ID

◆ fil_space_exists_in_mem()

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.

Parameters

[in]	space_id	Tablespace ID
[in]	name	Tablespace name used in space_create().
[in]	print_err	Print detailed error information to the error log if a matching tablespace is not found from memory.
[in]	adjust_space	Whether to adjust space id on mismatch

Returns: true if a matching tablespace exists in the memory cache

◆ fil_space_extend()

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.

Parameters

[in,out]	space	Tablespace ID
[in]	size	desired size in pages

Returns: whether the tablespace is at least as big as requested

◆ fil_space_free()

static bool fil_space_free	(	space_id_t	space_id,
		bool	x_latched
	)

static

Frees a space object from the tablespace memory cache.

Closes a tablespaces' files but does not delete them. There must not be any pending i/o's or flushes on the files.

Parameters

[in]	space_id	Tablespace ID
[in]	x_latched	Whether the caller holds X-mode space->latch

Returns: true if success

◆ fil_space_get()

fil_space_t * fil_space_get ( space_id_t space_id )

Look up a tablespace.

The caller should hold an InnoDB table lock or a MDL that prevents the tablespace from being dropped during the operation, or the caller should be in single-threaded crash recovery mode (no user connections that could drop tablespaces). If this is not the case, fil_space_acquire() and fil_space_release() should be used instead.

Parameters

[in] space_id Tablespace ID

Returns: tablespace, or nullptr if not found

◆ fil_space_get_first_path()

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.

The caller is responsible for freeing the memory allocated here for the value returned.

Parameters

[in] space_id Tablespace ID

Returns: own: A copy of fil_node_t::path, nullptr if space ID is zero or not found.

◆ fil_space_get_flags()

uint32_t fil_space_get_flags ( space_id_t space_id )

Returns the flags of the space.

The tablespace must be cached in the memory cache.

Parameters

[in] space_id Tablespace ID for which to get the flags

Returns: flags, ULINT_UNDEFINED if space not found

◆ fil_space_get_id_by_name()

space_id_t fil_space_get_id_by_name ( const char * name )

Returns the space ID based on the tablespace name.

The tablespace must be found in the tablespace memory cache. This call is made from external to this module, so the mutex is not owned.

Parameters

[in] name Tablespace name

Returns: space ID if tablespace found, SPACE_UNKNOWN if space not.

◆ fil_space_get_latch()

rw_lock_t * fil_space_get_latch ( space_id_t space_id )

Returns the latch of a file space.

Parameters

[in] space_id Tablespace ID

Returns: latch protecting storage allocation

◆ fil_space_get_n_reserved_extents()

ulint fil_space_get_n_reserved_extents ( space_id_t space_id )

Gets the number of reserved extents.

If the database is silent, this number should be zero.

Parameters

[in] space_id Tablespace ID

Returns: the number of reserved extents

◆ fil_space_get_page_size()

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.

The tablespace must be cached in the memory cache.

Parameters

[in]	space_id	Tablespace ID
[out]	found	true if tablespace was found

Returns: page size

◆ fil_space_get_size()

page_no_t fil_space_get_size ( space_id_t space_id )

Returns the size of the space in pages.

If the tablespace is not present in the fil subsystem mappings, a value of 0 is returned.

Parameters

[in] space_id Tablespace ID

Returns: space size, 0 if space not found

◆ fil_space_get_type()

fil_type_t fil_space_get_type ( space_id_t space_id )

Gets the type of a file space.

Parameters

[in] space_id Tablespace ID

Returns: file type

◆ fil_space_get_undo_initial_size()

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.

Parameters

[in] space_id Tablespace ID

Returns: initial space size, 0 if space not found

◆ fil_space_inc_redo_skipped_count()

void fil_space_inc_redo_skipped_count ( space_id_t space_id )

Increase redo skipped count for a tablespace.

Parameters

[in] space_id Tablespace ID

◆ fil_space_is_redo_skipped()

bool fil_space_is_redo_skipped ( space_id_t space_id )

Check whether a single-table tablespace is redo skipped.

Parameters

[in] space_id Tablespace ID

Returns: true if redo skipped

◆ fil_space_open()

ut::Expected< fil_space_t * > fil_space_open ( space_id_t space_id )

Looks up the tablespace, acquires the space, opens each node of a tablespace if not already open, validates the first page if it was not validated yet and fills the FSP-related cache if it was not filled yet.

A fil_space_release() needs to be called on the returned space.

Parameters

[in] space_id Tablespace ID

Returns: The opened and acquired space object or an error if tablespace is missing, being deleted, its nodes can't be opened or validation resulted in errors.

◆ fil_space_read_name_and_filepath()

bool fil_space_read_name_and_filepath	(	space_id_t	space_id,
		std::string &	name,
		std::string &	filepath
	)

Looks for a pre-existing fil_space_t with the given tablespace ID and, if found, returns the name and filepath in newly allocated buffers that the caller must free.

Parameters

[in]	space_id	The tablespace ID to search for.
[out]	name	Name of the tablespace found.
[out]	filepath	The filepath of the first datafile for the tablespace.

Returns: true if tablespace is found, false if not.

◆ fil_space_release()

void fil_space_release ( fil_space_t * space )

Release a tablespace acquired with fil_space_acquire().

Parameters

[in,out] space Tablespace to release

◆ fil_space_release_free_extents()

void fil_space_release_free_extents	(	space_id_t	space_id,
		ulint	n_reserved
	)

Releases free extents in a file space.

Parameters

[in]	space_id	Tablespace ID
[in]	n_reserved	How many were reserved

◆ fil_space_reserve_free_extents()

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.

Parameters

[in]	space_id	Tablespace ID
[in]	n_free_now	Number of free extents now
[in]	n_to_reserve	How many one wants to reserve

Returns: true if succeed

◆ fil_space_set_flags()

void fil_space_set_flags	(	fil_space_t *	space,
		uint32_t	flags
	)

Sets the flags of the tablespace.

The tablespace must be locked in MDL_EXCLUSIVE MODE.

Parameters

[in]	space	tablespace in-memory struct
[in]	flags	tablespace flags

◆ fil_space_set_imported()

void fil_space_set_imported ( space_id_t space_id )

Note that a tablespace has been imported.

It is initially marked as FIL_TYPE_IMPORT so that no logging is done during the import process when the space ID is stamped to each page. Now we change it to FIL_TYPE_TABLESPACE to start redo and undo logging. NOTE: temporary tablespaces are never imported.

Parameters

[in] space_id Tablespace ID

◆ fil_space_set_undo_size()

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.

It sets the minimum size in pages at which it should be truncated and the number of pages that it should be extended. An undo tablespace is extended by larger amounts than normal tablespaces. It starts at 16Mb and is increased during aggressive growth and decreased when the growth is slower.

Parameters

[in]	space_id	Tablespace ID
[in]	use_current	If true, use the current size in pages as the initial size. If false, use UNDO_INITIAL_SIZE_IN_PAGES.

◆ fil_space_update_name()

void fil_space_update_name	(	fil_space_t *	space,
		const char *	name
	)

Update the tablespace name.

In case, the new name and old name are same, no update done.

Parameters

[in,out]	space	tablespace object on which name will be updated
[in]	name	new name for tablespace

◆ fil_tablespace_dir_equals()

Fil_state fil_tablespace_dir_equals	(	const space_id_t	space_id,
		const char *	space_name,
		const ulint	fsp_flags,
		const Dirs_in_datadir &	dirs_in_datadir,
		const std::string	old_path,
		std::string &	new_path
	)

Lookups the tablespace ID in the scanned tablespaces and return its path to the file.

Compares the absolute base dir (absolute path without filename) of found scanned path and one supplied as the path from DD for equality. For example it will return path is matching for ./test/a.ibd and ./test/b.ibd.

Parameters

[in]	space_id	tablespace ID to lookup
[in]	space_name	tablespace name
[in]	fsp_flags	tablespace flags
[in]	dirs_in_datadir	full paths for dirs directly under datadir
[in]	old_path	the path found in dd:Tablespace_files
[out]	new_path	the scanned path for this space_id

Returns: status of the match.

◆ fil_tablespace_encryption_init()

static void fil_tablespace_encryption_init ( const fil_space_t * space )

static

Initialize the table space encryption.

Parameters

[in,out] space Tablespace instance

◆ fil_tablespace_iterate()

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.

Parameters

[in]	encryption_metadata	the encryption metadata to use for reading
[in]	table	the table definition in the server
[in]	n_io_buffers	number of blocks to read and write together
[in]	compression_type	compression type if compression is enabled, else Compression::Type::NONE
[in,out]	callback	functor that will do the page updates

Returns: DB_SUCCESS or error code

Add an extra page for compressed page scratch area.

◆ fil_tablespace_lookup_for_recovery()

bool fil_tablespace_lookup_for_recovery ( space_id_t space_id )

Lookup the tablespace ID.

Parameters

[in] space_id Tablespace ID to lookup

Returns: true if the space ID is known.

◆ fil_tablespace_open_for_recovery()

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.

Parameters

[in] space_id Tablespace ID to lookup

Returns: DB_SUCCESS if open was successful

◆ fil_tablespace_redo_create()

const byte * fil_tablespace_redo_create	(	const byte *	ptr,
		const byte *	end,
		space_id_t	space_id,
		bool	parse_only
	)

Redo a tablespace create.

Parameters

[in]	ptr	redo log record
[in]	end	end of the redo log buffer
[in]	space_id	Tablespace Id
[in]	parse_only	Don't apply, parse only

Returns: pointer to next redo log record

Return values

nullptr if this log record was truncated

◆ fil_tablespace_redo_create_wrapper()

const byte * fil_tablespace_redo_create_wrapper	(	const byte *	ptr,
		const byte *	end,
		space_id_t	space_id
	)

TODO: This is a wrapper for fil_tablespace_redo_create to be called during recovery, it uses tablespace_scanning to resolve tablespace file path.

The reason it exists is because we want to call fil_tablespace_redo_create from read replica code, and tablespace_scanning is not available in this case. OTOH, we have a special tablespace interface implementation for read replica, and it needs to be investigated further, how to hide these details behind the tablespace interface.

Parameters

[in]	ptr	redo log record
[in]	end	end of the redo log buffer
[in]	space_id	Tablespace Id

Returns: pointer to next redo log record

Return values

nullptr if this log record was truncated

◆ fil_tablespace_redo_delete()

const byte * fil_tablespace_redo_delete	(	const byte *	ptr,
		const byte *	end,
		space_id_t	space_id,
		bool	parse_only
	)

Redo a tablespace delete.

Parameters

[in]	ptr	redo log record
[in]	end	end of the redo log buffer
[in]	space_id	Tablespace Id
[in]	parse_only	Don't apply, parse only

Returns: pointer to next redo log record

Return values

nullptr if this log record was truncated

◆ fil_tablespace_redo_delete_wrapper()

const byte * fil_tablespace_redo_delete_wrapper	(	const byte *	ptr,
		const byte *	end,
		space_id_t	space_id
	)

TODO: This is a wrapper for fil_tablespace_redo_delete to be called during recovery, it uses tablespace_scanning to resolve tablespace file path.

The reason it exists is because we want to call fil_tablespace_redo_delete from read replica code, and tablespace_scanning is not available in this case. OTOH, we have a special tablespace interface implementation for read replica, and it needs to be investigated further, how to hide these details behind the tablespace interface.

Parameters

[in]	ptr	redo log record
[in]	end	end of the redo log buffer
[in]	space_id	Tablespace Id

Returns: pointer to next redo log record

Return values

nullptr if this log record was truncated

◆ fil_tablespace_redo_encryption()

std::optional< bool > fil_tablespace_redo_encryption	(	const byte *	ptr,
		const byte *	end,
		space_id_t	space_id,
		lsn_t	lsn
	)

Parse and process an encryption redo record.

Parameters

[in]	ptr	redo log record
[in]	end	end of the redo log buffer
[in]	space_id	the tablespace ID
[in]	lsn	lsn for REDO record

Returns: true to proceed for applying the log record, otherwise skip applying it the log record. Empty optional indicates some error in parsing the log record

◆ fil_tablespace_redo_extend()

const byte * fil_tablespace_redo_extend	(	const byte *	ptr,
		const byte *	end,
		space_id_t	space_id,
		bool	parse_only
	)

Redo a tablespace extend.

if parse_only is false, function expects tablespace to be present in fil cache.

Parameters

[in]	ptr	redo log record
[in]	end	end of the redo log buffer
[in]	space_id	Tablespace Id
[in]	parse_only	Don't apply the log if true

Returns: pointer to next redo log record

Return values

nullptr if this log record was truncated

◆ fil_tablespace_redo_extend_wrapper()

const byte * fil_tablespace_redo_extend_wrapper	(	const byte *	ptr,
		const byte *	end,
		space_id_t	space_id
	)

TODO: This is a wrapper for fil_tablespace_redo_extend to be called during recovery, it makes sure tablespace is loaded in fil cache.

The reason it exists is because we want to call fil_tablespace_redo_extend from read replica code, and loading tablespace for recovery does not make any sense in this case. OTOH, we have a special tablespace interface implementation for read replica, and it needs to be investigated further, how to hide these details behind the tablespace interface.

Parameters

[in]	ptr	redo log record
[in]	end	end of the redo log buffer
[in]	space_id	Tablespace Id

Returns: pointer to next redo log record

Return values

nullptr if this log record was truncated

◆ fil_tablespace_redo_rename()

const byte * fil_tablespace_redo_rename	(	const byte *	ptr,
		const byte *	end,
		space_id_t	space_id,
		bool	parse_only
	)

Redo a tablespace rename.

This function doesn't do anything, simply parses the redo log record.

Parameters

[in]	ptr	redo log record
[in]	end	end of the redo log buffer
[in]	space_id	Tablespace Id
[in]	parse_only	Don't apply, parse only

Returns: pointer to next redo log record

Return values

nullptr if this log record was truncated

◆ fil_truncate_tablespace()

bool fil_truncate_tablespace	(	space_id_t	space_id,
		page_no_t	size_in_pages
	)

Basically recreates the tablespace`s only node and set it to the needed size in place.

The content of the prefix up to new size is overwritten with zeros.

Parameters

[in]	space_id	Tablespace ID to truncate
[in]	size_in_pages	Truncate size.

Returns: true if truncate was successful.

◆ fil_undo_create()

dberr_t fil_undo_create	(	space_id_t	space_id,
		const char *	name,
		const char *	path,
		uint32_t	flags,
		page_no_t	size,
		bool	is_explicit
	)

Create an UNDO tablespace file.

Parameters

[in]	space_id	Tablespace ID
[in]	name	Tablespace name in dbname/tablename format.
[in]	path	Path and filename of the datafile to create.
[in]	flags	Tablespace flags
[in]	size	Initial size of the tablespace file in pages, must be >= FIL_IBD_FILE_INITIAL_SIZE
[in]	is_explicit	Enabled if it is an explicit UNDO tablespace

Returns: DB_SUCCESS or error code

◆ fil_validate()

bool fil_validate ( )

Checks the consistency of the tablespace cache.

Returns: true if ok

◆ fil_validate_skip()

static bool fil_validate_skip ( )

static

Checks the consistency of the tablespace cache some of the time.

Returns: true if ok or the check was skipped

The fil_validate() call skip counter. Use a signed type because of the race condition below.

◆ fil_validate_space_reference_count()

static void fil_validate_space_reference_count	(	fil_space_t *	space,
		Space_References &	buffer_pool_references
	)

static

◆ fil_write()

static dberr_t fil_write	(	const page_id_t &	page_id,
		const page_size_t &	page_size,
		ulint	len,
		byte *	buf
	)

static

Writes data to a space from a buffer.

Remember that the possible incomplete blocks at the end of file are ignored: they are not taken into account when calculating the byte offset within a space.

Parameters

[in]	page_id	page id
[in]	page_size	Structure with information on logical and physical page size in the affected tablespace.
[in]	len	Size of the `buf` supplied. It always has to be a multiple of OS block size (UNIV_SECTOR_SIZE). In case of write of an already compressed data, it is a length of the compressed data buffer. Otherwise it should be `page_size.physical()`. Actual number of bytes written can be smaller if the tablespace has compression enabled. The data supplied will be compressed and encrypted according to the tablespace settings.
[in,out]	buf	A buffer from where to write. Data from this buffer might be copied and the copy transformed before writing it. It must be aligned to OS block size (UNIV_SECTOR_SIZE). The memory pointed is managed by the caller and must remain valid until the call returns.

Returns: DB_SUCCESS, or DB_TABLESPACE_DELETED if we are trying to do I/O on a tablespace which does not exist

◆ fil_write_flushed_lsn()

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.

Assumes the Buffer Pool is empty, or at least does not contain the first page of the System Tablespace.

Parameters

[in] lsn Flushed LSN

Returns: DB_SUCCESS or error number

◆ fil_write_initial_pages()

dberr_t fil_write_initial_pages	(	pfs_os_file_t	file,
		const char *	path,
		const byte *	encrypt_info,
		space_id_t	space_id,
		uint32_t	space_flags
	)

Write initial pages for a new tablespace file created.

Caller of this function should call fsync() to make the effect of this function durable.

Parameters

[in]	file	open file handle
[in]	path	path and filename of the datafile
[in]	encrypt_info	encryption key information
[in]	space_id	tablespace ID
[in,out]	space_flags	tablespace flags

Returns: DB_SUCCESS on success

◆ is_fast_shutdown()

static bool is_fast_shutdown ( )

static

◆ parse_path_from_redo()

static const byte * parse_path_from_redo	(	const byte *	ptr,
		const byte *	end,
		bool	check_suffix,
		std::string &	path,
		std::string &	error_str
	)

static

Parse a path from a buffer.

Parameters

[in]	ptr	redo log record
[in]	end	end of the redo log buffer
[in]	check_suffix	indicate that .ibd suffix is required
[out]	path	the path parsed from the buffer
[out]	error_str	optional description of a detected corruption recv_sys->found_corrupt_log is set to true when error_str is set to a non empty string

Returns: pointer to next redo log record

Return values

nullptr if this log record was truncated or corrupted

Variable Documentation

◆ dot_ext

const char* dot_ext[]

Initial value:

= {"", ".ibd", ".cfg", ".cfp",

".ibt", ".ibu", ".dblwr", ".bdblwr"}

Common InnoDB file extensions.

◆ fil_addr_null

fil_addr_t fil_addr_null = {FIL_NULL, 0}

The null file address.

◆ fil_n_files_open

std::atomic_size_t fil_n_files_open {0}

Number of files currently open.

◆ fil_n_pending_tablespace_flushes

std::atomic<std::uint64_t> fil_n_pending_tablespace_flushes = 0

Number of pending tablespace flushes.

◆ fil_system

Fil_system* fil_system = nullptr

static

The tablespace memory cache.

This variable is nullptr before the module is initialized.

◆ FIL_VALIDATE_SKIP

const size_t FIL_VALIDATE_SKIP = 17

static

Try fil_validate() every this many times.

◆ MAX_SHARDS

const size_t MAX_SHARDS = 68

static

Maximum number of shards supported.

◆ MySQL_datadir_path

Fil_path MySQL_datadir_path

Reference to the server data directory.

The MySQL server –datadir value.

◆ MySQL_undo_path

Fil_path MySQL_undo_path

Reference to the server undo directory.

The MySQL server –innodb-undo-directory value.

◆ MySQL_undo_path_is_unique

bool MySQL_undo_path_is_unique

The undo path is different from any other known directory.

◆ pages_persistence

ut::unique_ptr<ib::fil::Pages_persistence_interface> pages_persistence

The implementation of persistence for the pages stored in tablespaces' nodes' storage.

◆ tablespace_scanning

ut::unique_ptr<ib::fil::Tablespace_scanning> tablespace_scanning

◆ tablespaces_nodes

ut::unique_ptr<ib::fil::Tablespaces_nodes_interface> tablespaces_nodes

The low-level tablespaces' nodes' storage implementation.

◆ UNDO_SHARDS

const size_t UNDO_SHARDS = 4

static

Number of undo shards to reserve.

◆ UNDO_SHARDS_START

const size_t UNDO_SHARDS_START = MAX_SHARDS - UNDO_SHARDS

static

The UNDO logs have their own shards (4).

Classes

Namespaces

Macros

Typedefs

Enumerations

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ fil_report_invalid_page_access

◆ mutex_acquire

◆ PAGE_TYPE

Enumeration Type Documentation

◆ fil_load_status

◆ fil_operation_t

Function Documentation

◆ dict_stats_rename_table()

◆ fil_add_moved_space()

◆ fil_addr_is_null()

◆ fil_adjust_name_import()

◆ fil_adjust_partition_stat()

◆ fil_aio_wait()

◆ fil_assign_new_space_id()

◆ fil_buf_block_init()

◆ fil_close()

◆ fil_close_all_files()

◆ fil_close_tablespace()

◆ fil_complete_write()

◆ fil_count_undo_deleted()

◆ fil_create_tablespace()

◆ fil_delete_tablespace()

◆ fil_discard_tablespace()

◆ fil_encryption_reencrypt()

◆ fil_encryption_rotate()

◆ fil_flush()

◆ fil_flush_file_spaces()

◆ fil_get_compression()

◆ fil_get_page_type_str()

◆ fil_get_scan_threads()

◆ fil_ibd_create()

◆ fil_ibd_open()

◆ fil_ibt_create()

◆ fil_init()

◆ fil_io()

◆ fil_io_set_encryption()

◆ fil_is_page_type_valid()

◆ fil_iterate()

◆ fil_name_write_rename()

◆ fil_needs_flushes_for_durability()

◆ fil_node_create()

◆ fil_op_replay_rename()

◆ fil_op_replay_rename_for_ddl()

◆ fil_op_write_log()

◆ fil_open_files_limit_update()

◆ fil_open_for_business()

◆ fil_page_get_next()

◆ fil_page_get_prev()

◆ fil_page_reset_type()

◆ fil_page_set_type()

◆ fil_path_to_space_name() [1/2]

◆ fil_path_to_space_name() [2/2]

◆ fil_prepare_file_for_io()

◆ fil_purge()

◆ fil_read()

◆ fil_real_dir_for_lookup()

◆ fil_rename_precheck()

◆ fil_rename_tablespace()

◆ fil_rename_tablespace_by_id()

◆ fil_rename_tablespace_check()

◆ fil_report_invalid_page_access_low()

◆ fil_report_missing_tablespace()

◆ fil_reset_encryption()

◆ fil_set_autoextend_size()

◆ fil_set_compression()

◆ fil_set_encryption()

◆ fil_set_max_space_id_if_bigger()

◆ fil_space_acquire()

◆ fil_space_acquire_silent()

◆ fil_space_close()

◆ fil_space_create()