MySQL 8.4.3
Source Code Documentation
srv0srv.h
Go to the documentation of this file.
1/*****************************************************************************
2
3Copyright (c) 1995, 2024, Oracle and/or its affiliates.
4Copyright (c) 2008, 2009, Google Inc.
5Copyright (c) 2009, Percona Inc.
6
7Portions of this file contain modifications contributed and copyrighted by
8Google, Inc. Those modifications are gratefully acknowledged and are described
9briefly in the InnoDB documentation. The contributions by Google are
10incorporated with their permission, and subject to the conditions contained in
11the file COPYING.Google.
12
13Portions of this file contain modifications contributed and copyrighted
14by Percona Inc.. Those modifications are
15gratefully acknowledged and are described briefly in the InnoDB
16documentation. The contributions by Percona Inc. are incorporated with
17their permission, and subject to the conditions contained in the file
18COPYING.Percona.
19
20This program is free software; you can redistribute it and/or modify it under
21the terms of the GNU General Public License, version 2.0, as published by the
22Free Software Foundation.
23
24This program is designed to work with certain software (including
25but not limited to OpenSSL) that is licensed under separate terms,
26as designated in a particular file or component or in included license
27documentation. The authors of MySQL hereby grant you an additional
28permission to link the program and your derivative works with the
29separately licensed software that they have either included with
30the program or referenced in the documentation.
31
32This program is distributed in the hope that it will be useful, but WITHOUT
33ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
34FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0,
35for more details.
36
37You should have received a copy of the GNU General Public License along with
38this program; if not, write to the Free Software Foundation, Inc.,
3951 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
40
41*****************************************************************************/
42
43/** @file include/srv0srv.h
44 The server main program
45
46 Created 10/10/1995 Heikki Tuuri
47 *******************************************************/
48
49#ifndef srv0srv_h
50#define srv0srv_h
51
52#include "buf0checksum.h"
53#include "fil0fil.h"
55#include "univ.i"
56
57#ifndef UNIV_HOTBACKUP
58#include "log0ddl.h"
59#include "os0event.h"
60#include "os0file.h"
61#include "os0thread.h"
62#include "que0types.h"
63#include "srv0conc.h"
64#include "trx0types.h"
65#include "ut0counter.h"
66
67#include <cstdint>
68#include <future>
69
70/* Global counters used inside InnoDB. */
77
78 /** Count the amount of data written in total (in bytes) */
80
81 /** Number of the log write requests done */
83
84 /** Number of physical writes to the log performed */
86
87 /** Amount of data written to the log files in bytes */
89
90 /** Number of writes being done to the log files */
92
93 /** We increase this counter, when we don't have enough
94 space in the log buffer and have to flush it */
96
97 /** Count the number of times the doublewrite buffer was flushed */
99
100 /** Store the number of pages that have been flushed to the
101 doublewrite buffer */
103
104 /** Store the number of write requests issued */
106
107 /** Store the number of times when we had to wait for a free page
108 in the buffer pool. It happens when the buffer pool is full and we
109 need to make a flush, in order to be able to read or create a page. */
111
112 /** Count the number of pages that were written from buffer
113 pool to the disk */
115
116 /** Number of buffer pool reads that led to the reading of
117 a disk page */
119
120 /** Number of data read in total (in bytes) */
122
123 /** Wait time of database locks */
125
126 /** Number of database lock waits */
128
129 /** Number of threads currently waiting on database locks */
131
132 /** Number of rows read. */
134
135 /** Number of rows updated */
137
138 /** Number of rows deleted */
140
141 /** Number of rows inserted */
143
144 /** Number of system rows read. */
146
147 /** Number of system rows updated */
149
150 /** Number of system rows deleted */
152
153 /** Number of system rows inserted */
155
156 /** Number of sampled pages read */
158
159 /** Number of sampled pages skipped */
161};
162
163/** Structure which keeps shared future objects for InnoDB background
164threads. One should use these objects to check if threads exited. */
166 /** Monitor thread (prints info). */
168
169 /** Error monitor thread. */
171
172 /** Redo files governor thread. */
174
175 /** Redo checkpointer thread. */
177
178 /** Redo writer thread. */
180
181 /** Redo flusher thread. */
183
184 /** Redo write notifier thread. */
186
187 /** Redo flush notifier thread. */
189
190 /** Redo log archiver (used by backup). */
192
193 /** Buffer pool dump thread. */
195
196 /** Buffer pool resize thread. */
198
199 /** Dict stats background thread. */
201
202 /** Thread detecting lock wait timeouts. */
204
205 /** The master thread. */
207
208 /** The ts_alter_encrypt thread. */
210
211 /** Thread doing rollbacks during recovery. */
213
214 /** Thread writing recovered pages during recovery. */
216
217 /** Purge coordinator (also being a worker) */
219
220 /** Number of purge workers and size of array below. */
222
223 /** Purge workers. Note that the m_purge_workers[0] is the same shared
224 state as m_purge_coordinator. */
226
227 /** Page cleaner coordinator (also being a worker). */
229
230 /** Number of page cleaner workers and size of array below. */
232
233 /** Page cleaner workers. Note that m_page_cleaner_workers[0] is the
234 same shared state as m_page_cleaner_coordinator. */
236
237 /** Archiver's log archiver (used by Clone). */
239
240 /** Archiver's page archiver (used by Clone). */
242
243 /** Thread doing optimization for FTS index. */
245
246 /** Thread for GTID persistence */
248
249#ifdef UNIV_DEBUG
250 /** Used in test scenario to delay threads' cleanup until the pre_dd_shutdown
251 is ended and final plugin's shutdown is started (when plugin is DELETED).
252 Note that you may only delay the shutdown for threads for which there is no
253 waiting procedure used in the pre_dd_shutdown. */
255#endif /* UNIV_DEBUG */
256
257 /** When the master thread notices that shutdown has started (by noticing
258 srv_shutdown_state >= SRV_SHUTDOWN_PRE_DD_AND_SYSTEM_TRANSACTIONS), it exits
259 its main loop. Then the master thread proceeds with actions related to tasks:
260 - which it has been responsible for,
261 - and which might depend on DD objects.
262 After finishing them, the master thread sets this event.
263 @remarks We use this event to wait in srv_pre_dd_shutdown before we enter
264 next phase (SRV_SHUTDOWN_PURGE) in which master thread is not allowed to
265 use system transactions or touch DD objects. */
267};
268
269/** Check if given thread is still active. */
270bool srv_thread_is_active(const IB_thread &thread);
271
272/** Check if given thread is cleaned-up and stopped. */
273bool srv_thread_is_stopped(const IB_thread &thread);
274
275/** Delay the thread after it discovered that the shutdown_state
276is greater or equal to SRV_SHUTDOWN_CLEANUP, before it proceeds
277with further clean up. This is used in the tests to see if such
278a possible delay does not have impact on the clean shutdown.
279@param[in] wait_for_signal wait until shutdown phase starts */
280void srv_thread_delay_cleanup_if_needed(bool wait_for_signal);
281
283 int n_cpu;
284 double utime_abs;
285 double stime_abs;
286 double utime_pct;
287 double stime_pct;
288};
289
290/** Structure with state of srv background threads. */
292
293/** Structure with cpu usage information. */
295
296extern Log_DDL *log_ddl;
297
298#ifdef INNODB_DD_TABLE
299extern bool srv_is_upgrade_mode;
300extern bool srv_downgrade_logs;
302#endif /* INNODB_DD_TABLE */
303
305
306extern const char *srv_main_thread_op_info;
307
308/* The monitor thread waits on this event. */
310
311/* The error monitor thread waits on this event. */
313
314/** The buffer pool dump/load thread waits on this event. */
316
317/** The buffer pool resize thread waits on this event. */
319#endif /* !UNIV_HOTBACKUP */
320
321/** The buffer pool dump/load file name */
322#define SRV_BUF_DUMP_FILENAME_DEFAULT "ib_buffer_pool"
323extern char *srv_buf_dump_filename;
324
325/** Boolean config knobs that tell InnoDB to dump the buffer pool at shutdown
326and/or load it during startup. */
329
330/* Whether to disable file system cache if it is defined */
332
333/** Enable or disable writing of NULLs while extending a tablespace.
334If this is false, then the server will just allocate the space without
335actually initializing it with NULLs. If the variable is true, the
336server will allocate and initialize the space by writing NULLs in it. */
338
339/* If the last data file is auto-extended, we add this many pages to it
340at a time */
341#define SRV_AUTO_EXTEND_INCREMENT (srv_sys_space.get_autoextend_increment())
342
343#ifndef UNIV_HOTBACKUP
344/** Mutex protecting page_zip_stat_per_index */
345extern ib_mutex_t page_zip_stat_per_index_mutex;
346/* Mutex for locking srv_monitor_file. Not created if srv_read_only_mode */
347extern ib_mutex_t srv_monitor_file_mutex;
348/* Temporary file for innodb monitor output */
349extern FILE *srv_monitor_file;
350/* Mutex for locking srv_misc_tmpfile. Only created if !srv_read_only_mode.
351This mutex has a very low rank; threads reserving it should not
352acquire any further latches or sleep before releasing this one. */
353extern ib_mutex_t srv_misc_tmpfile_mutex;
354/* Temporary file for miscellaneous diagnostic output */
355extern FILE *srv_misc_tmpfile;
356#endif /* !UNIV_HOTBACKUP */
357
358/* Server parameters which are read from the initfile */
359
360extern char *srv_data_home;
361
362/* Number of threads used for initializing rollback segments */
363extern uint32_t srv_rseg_init_threads;
364
365/** Number of pages per doublewrite thread/segment */
366extern ulong srv_dblwr_pages;
367
368/** Set if InnoDB must operate in read-only mode. We don't do any
369recovery and open all tables in RO mode instead of RW mode. We don't
370sync the max trx id to disk either. */
371extern bool srv_read_only_mode;
372/** Set if InnoDB operates in read-only mode or innodb-force-recovery
373is greater than SRV_FORCE_NO_TRX_UNDO. */
374extern bool high_level_read_only;
375/** store to its own file each table created by an user; data
376dictionary tables are in the system tablespace 0 */
377extern bool srv_file_per_table;
378/** Sleep delay for threads waiting to enter InnoDB. In micro-seconds. */
379extern ulong srv_thread_sleep_delay;
380/** Maximum sleep delay (in micro-seconds), value of 0 disables it.*/
382
383/** Sort buffer size in index creation */
384extern ulong srv_sort_buf_size;
385
386/** Maximum modification log file size for online index creation */
387extern unsigned long long srv_online_max_size;
388
389/** Number of threads to use for parallel reads. */
390extern ulong srv_parallel_read_threads;
391
392/* If this flag is true, then we will use the native aio of the
393OS (provided we compiled Innobase with it in), otherwise we will
394use simulated aio we build below with threads.
395Currently we support native aio on windows and linux */
396extern bool srv_use_native_aio;
397extern bool srv_numa_interleave;
398
399/* The innodb_directories variable value. This a list of directories
400deliminated by ';', i.e the FIL_PATH_SEPARATOR. */
401extern char *srv_innodb_directories;
402
403/** Server undo tablespaces directory, can be absolute path. */
404extern char *srv_undo_dir;
405
406/** Number of undo tablespaces to use. */
407extern ulong srv_undo_tablespaces;
408
409/** The number of rollback segments per tablespace */
410extern ulong srv_rollback_segments;
411
412/** Maximum size of undo tablespace. */
413extern unsigned long long srv_max_undo_tablespace_size;
414
415/** Rate at which UNDO records should be purged. */
417
418/** Enable or Disable Truncate of UNDO tablespace. */
419extern bool srv_undo_log_truncate;
420
421/** Enable or disable Encrypt of UNDO tablespace. */
422extern bool srv_undo_log_encrypt;
423
424/** Maximum number of recently truncated undo tablespace IDs for
425the same undo number. */
426extern const size_t CONCURRENT_UNDO_TRUNCATE_LIMIT;
427
428extern char *srv_log_group_home_dir;
429
430/** Enable or Disable Encrypt of REDO tablespace. */
431extern bool srv_redo_log_encrypt;
432
433/* Maximum number of redo files of a cloned DB. */
434constexpr size_t SRV_N_LOG_FILES_CLONE_MAX = 1000;
435
436/** Value of innodb_log_files_in_group. This is deprecated. */
437extern ulong srv_log_n_files;
438
439/** Value of innodb_log_file_size. Expressed in bytes. This is deprecated. */
441
442/** Value of innodb_redo_log_capacity. Expressed in bytes. Might be set
443during startup automatically when started in "dedicated server mode". */
445
446/** Assumed value of innodb_redo_log_capacity's - value which is used.
447Expressed in bytes. Might be set during startup automatically when
448started in "dedicated server mode". Might also be set during startup
449when old sysvar (innodb_log_file_size or innodb_log_files_in_group)
450are configured and the new sysvar (innodb_redo_log_capacity) is not. */
452
453#ifdef UNIV_DEBUG_DEDICATED
454extern ulong srv_debug_system_mem_size;
455#endif /* UNIV_DEBUG_DEDICATED */
456
457/** Space for log buffer, expressed in bytes. Note, that log buffer
458will use only the largest power of two, which is not greater than
459the assigned space. */
460extern ulong srv_log_buffer_size;
461
462/** When log writer follows links in the log recent written buffer,
463it stops when it has reached at least that many bytes to write,
464limiting how many bytes can be written in single call. */
465extern ulong srv_log_write_max_size;
466
467/** Size of block, used for writing ahead to avoid read-on-write. */
468extern ulong srv_log_write_ahead_size;
469
470/** Number of events used for notifications about redo write. */
471extern ulong srv_log_write_events;
472
473/** Number of events used for notifications about redo flush. */
474extern ulong srv_log_flush_events;
475
476/** Number of slots in a small buffer, which is used to allow concurrent
477writes to log buffer. The slots are addressed by LSN values modulo number
478of the slots. */
479extern ulong srv_log_recent_written_size;
480
481/** Number of slots in a small buffer, which is used to break requirement
482for total order of dirty pages, when they are added to flush lists.
483The slots are addressed by LSN values modulo number of the slots. */
484extern ulong srv_log_recent_closed_size;
485
486/** Whether to activate/pause the log writer threads. */
487extern bool srv_log_writer_threads;
488
489/** Minimum absolute value of cpu time for which spin-delay is used. */
490extern uint srv_log_spin_cpu_abs_lwm;
491
492/** Maximum percentage of cpu time for which spin-delay is used. */
493extern uint srv_log_spin_cpu_pct_hwm;
494
495/** Number of spin iterations, when spinning and waiting for log buffer
496written up to given LSN, before we fallback to loop with sleeps.
497This is not used when user thread has to wait for log flushed to disk. */
499
500/** Timeout used when waiting for redo write. */
501std::chrono::microseconds get_srv_log_wait_for_write_timeout();
502
503/** Number of spin iterations, when spinning and waiting for log flushed. */
505
506/** Maximum value of average log flush time for which spin-delay is used.
507When flushing takes longer, user threads no longer spin when waiting for
508flushed redo. Expressed in microseconds. */
510
511/** Timeout used when waiting for redo flush. */
512std::chrono::microseconds get_srv_log_wait_for_flush_timeout();
513
514/** Number of spin iterations, for which log writer thread is waiting
515for new data to write or flush without sleeping. */
516extern ulong srv_log_writer_spin_delay;
517
518/** Initial timeout used to wait on writer_event. */
519std::chrono::microseconds get_srv_log_writer_timeout();
520
521/** Period every which a periodical checkpoint is written by the log
522checkpointer thread (unless periodical checkpoints are disabled,
523which is a case during initial phase of startup). */
524std::chrono::milliseconds get_srv_log_checkpoint_every();
525
526/** Number of spin iterations, for which log flusher thread is waiting
527for new data to flush, without sleeping. */
528extern ulong srv_log_flusher_spin_delay;
529
530/** Initial timeout used to wait on flusher_event. */
531std::chrono::microseconds get_srv_log_flusher_timeout();
532
533/** Number of spin iterations, for which log write notifier thread is waiting
534for advanced writeed_to_disk_lsn without sleeping. */
536
537/** Initial timeout used to wait on write_notifier_event. */
538std::chrono::microseconds get_srv_log_write_notifier_timeout();
539
540/** Number of spin iterations, for which log flush notifier thread is waiting
541for advanced flushed_to_disk_lsn without sleeping. */
543
544/** Initial timeout used to wait on flush_notifier_event. */
545std::chrono::microseconds get_srv_log_flush_notifier_timeout();
546
547/** Whether to generate and require checksums on the redo log pages. */
548extern bool srv_log_checksums;
549
550#ifdef UNIV_DEBUG
551
552/** If true then disable checkpointing. */
553extern bool srv_checkpoint_disabled;
554
555/* Used to inject a failure to find a free rollback segment. */
557
558#endif /* UNIV_DEBUG */
559
560extern ulong srv_flush_log_at_trx_commit;
563extern bool srv_adaptive_flushing;
564extern bool srv_flush_sync;
565
566/* If this flag is true, then we will load the indexes' (and tables') metadata
567even if they are marked as "corrupted". Mostly it is for DBA to process
568corrupted index and table */
569extern bool srv_load_corrupted;
570
571/** Dedicated server setting */
572extern bool srv_dedicated_server;
573/** Requested size in bytes */
575/** Minimum pool size in bytes */
576extern const ulint srv_buf_pool_min_size;
577/** Default pool size in bytes */
578extern const ulint srv_buf_pool_def_size;
579/** Maximum pool size in bytes */
581/** Requested buffer pool chunk size. Each buffer pool instance consists
582of one or more chunks. */
584/** Minimum buffer pool chunk size. */
586/** The buffer pool chunk size must be a multiple of this number. */
588/** Maximum buffer pool chunk size. */
590
591/** Requested number of buffer pool instances */
592extern ulong srv_buf_pool_instances;
593/** Default number of buffer pool instances */
594extern const ulong srv_buf_pool_instances_default;
595/** Number of locks to protect buf_pool->page_hash */
596extern ulong srv_n_page_hash_locks;
597/** Whether to validate InnoDB tablespace paths on startup */
599/** Use fdatasync() instead of fsync(). */
600extern bool srv_use_fdatasync;
601/** Scan depth for LRU flush batch i.e.: number of blocks scanned*/
602extern ulong srv_LRU_scan_depth;
603/** Whether or not to flush neighbors of a block */
604extern ulong srv_flush_neighbors;
605/** Previously requested size. Accesses protected by memory barriers. */
607/** Current size as scaling factor for the other components */
609/** Current size in bytes */
610extern long long srv_buf_pool_curr_size;
611/** Dump this % of each buffer pool during BP dump */
612extern ulong srv_buf_pool_dump_pct;
613/** Lock table size in bytes */
615
616extern bool srv_random_read_ahead;
617extern ulong srv_read_ahead_threshold;
618extern ulong srv_n_read_io_threads;
619extern ulong srv_n_write_io_threads;
620
622
623/** Default value of srv_idle_flush_pct */
624extern const ulong srv_idle_flush_pct_default;
625/** How much flush to be done in case of server is idle */
626extern ulong srv_idle_flush_pct;
627
628/* Number of IO operations per second the server can do */
629extern ulong srv_io_capacity;
630
631/* We use this dummy default value at startup for max_io_capacity.
632The real value is set based on the value of io_capacity. */
635extern ulong srv_max_io_capacity;
636/* Returns the number of IO operations that is X percent of the
637capacity. PCT_IO(5) -> returns the number of IO operations that
638is 5% of the max where max is srv_io_capacity. */
639static inline ulong PCT_IO(ulong p) {
640 return (ulong)(srv_io_capacity * ((double)(p) / 100.0));
641}
642
643/** Maximum number of purge threads, including the purge coordinator */
644constexpr uint32_t MAX_PURGE_THREADS = 32;
645
646/* The "innodb_stats_method" setting, decides how InnoDB is going
647to treat NULL value when collecting statistics. It is not defined
648as enum type because the configure option takes unsigned integer type. */
649extern ulong srv_innodb_stats_method;
650
651/** Returns current value of the "innodb_open_files" configuration variable. */
653/** Sets new value of the "innodb_open_files" configuration variable to present
654to users.
655@param[in] new_limit new limit to be set. */
656void innobase_set_open_files_limit(long new_limit);
657
659extern uint srv_flush_log_at_timeout;
660extern bool srv_btr_search_enabled;
661extern ulong srv_replication_delay;
662
665extern ulong srv_log_writer_timeout;
666extern ulong srv_log_checkpoint_every;
667extern ulong srv_log_flusher_timeout;
670
671extern uint buf_LRU_old_threshold;
672
673extern ulong srv_n_page_cleaners;
674
675extern double srv_max_dirty_pages_pct;
676extern double srv_max_dirty_pages_pct_lwm;
677
678extern ulong srv_adaptive_flushing_lwm;
679extern ulong srv_flushing_avg_loops;
680
681extern ulong srv_force_recovery;
682#ifdef UNIV_DEBUG
683extern ulong srv_force_recovery_crash;
684#endif /* UNIV_DEBUG */
685
686/** The value of the configuration parameter innodb_fast_shutdown,
687controlling the InnoDB shutdown.
688
689If innodb_fast_shutdown=0, InnoDB shutdown will purge all undo log
690records (except XA PREPARE transactions) and complete the merge of the
691entire change buffer, and then shut down the redo log.
692
693If innodb_fast_shutdown=1, InnoDB shutdown will only flush the buffer
694pool to data files, cleanly shutting down the redo log.
695
696If innodb_fast_shutdown=2, shutdown will effectively 'crash' InnoDB
697(but lose no committed transactions). */
698extern ulong srv_fast_shutdown;
699extern bool srv_innodb_status;
700
701extern unsigned long long srv_stats_transient_sample_pages;
702extern bool srv_stats_persistent;
703extern unsigned long long srv_stats_persistent_sample_pages;
704extern bool srv_stats_auto_recalc;
706
707extern ulong srv_checksum_algorithm;
708
710extern ulong srv_max_purge_lag;
711extern ulong srv_max_purge_lag_delay;
712
713std::chrono::milliseconds get_srv_replication_delay();
714/*-------------------------------------------*/
715
716extern bool srv_print_innodb_monitor;
717/** In contrast to srv_print_innodb_monitor which is controlled by the user,
718this variable is controlled by InnoDB itself: if some module of InnoDB decides
719it would be good to print the monitoring information it increments this value,
720and decrements it when it no longer needs it. */
721extern std::atomic_uint32_t srv_innodb_needs_monitoring;
723
724extern ulong srv_n_spin_wait_rounds;
725extern ulong srv_n_free_tickets_to_enter;
726extern ulong srv_spin_wait_delay;
727extern bool srv_priority_boost;
728
730
731#if defined UNIV_DEBUG || defined UNIV_IBUF_DEBUG
733#endif /* UNIV_DEBUG || UNIV_IBUF_DEBUG */
734
735#ifdef UNIV_DEBUG
736extern bool srv_buf_pool_debug;
737extern bool srv_sync_debug;
739
740/** Value of MySQL global used to disable master thread. */
742#endif /* UNIV_DEBUG */
743
745extern std::atomic<int> srv_fatal_semaphore_wait_extend;
746
748
749#ifdef UNIV_HOTBACKUP
750// MAHI: changed from 130 to 1 assuming the apply-log is single threaded
751constexpr uint32_t SRV_MAX_N_IO_THREADS = 1;
752#else /* UNIV_HOTBACKUP */
753constexpr uint32_t SRV_MAX_N_IO_THREADS = 130;
754#endif /* UNIV_HOTBACKUP */
755
756/* Array of English strings describing the current state of an
757i/o handler thread */
758extern const char *srv_io_thread_op_info[];
759extern const char *srv_io_thread_function[];
760
761/* the number of purge threads to use from the worker pool (currently 0 or 1) */
762extern ulong srv_n_purge_threads;
763
764/* the number of pages to purge in one batch */
765extern ulong srv_purge_batch_size;
766
767/* the number of sync wait arrays */
768extern ulong srv_sync_array_size;
769
770/* print all user-level transactions deadlocks to mysqld stderr */
771extern bool srv_print_all_deadlocks;
772
773/** Print all DDL logs to mysqld stderr */
774extern bool srv_print_ddl_logs;
775
776extern bool srv_cmp_per_index_enabled;
777
778extern bool srv_redo_log;
779
780/** Status variables to be passed to MySQL */
781extern struct export_var_t export_vars;
782
783#ifndef UNIV_HOTBACKUP
784/** Global counters */
786
787/* Keys to register InnoDB threads with performance schema */
788
789#ifdef UNIV_PFS_THREAD
825#endif /* UNIV_PFS_THREAD */
826#endif /* !UNIV_HOTBACKUP */
827
828#ifdef HAVE_PSI_STAGE_INTERFACE
829/** Performance schema stage event for monitoring ALTER TABLE progress
830everything after flush log_make_latest_checkpoint(). */
832
833/** Performance schema stage event for monitoring ALTER TABLE progress
834log_make_latest_checkpoint(). */
836
837/** Performance schema stage event for monitoring ALTER TABLE progress
838row_merge_insert_index_tuples(). */
840
841/** Performance schema stage event for monitoring ALTER TABLE progress
842row_log_apply(). */
844
845/** Performance schema stage event for monitoring ALTER TABLE progress
846row_log_table_apply(). */
848
849/** Performance schema stage event for monitoring ALTER TABLE progress
850row_merge_sort(). */
852
853/** Performance schema stage event for monitoring ALTER TABLE progress
854row_merge_read_clustered_index(). */
856
857/** Performance schema stage event for monitoring ALTER TABLESPACE
858ENCRYPTION progress. */
860
861/** Performance schema stage event for monitoring buffer pool load progress. */
863#endif /* HAVE_PSI_STAGE_INTERFACE */
864
865/** Performance schema stage event for monitoring clone file copy progress. */
867
868/** Performance schema stage event for monitoring clone redo copy progress. */
870
871/** Performance schema stage event for monitoring clone page copy progress. */
873
874#ifndef _WIN32
875/** Alternatives for the file flush option in Unix.
876@see innodb_flush_method_names */
878 /** fsync, the default if O_DIRECT is not supported */
880 /** open log files in O_SYNC mode */
882 /** do not call os_file_flush() when writing data files, but do flush after
883 writing to log files */
885 /** do not flush after writing */
887 /** invoke os_file_set_nocache() on data files. This implies using
888 non-buffered IO but still using fsync, the reason for which is that some FS
889 do not flush meta-data when unbuffered IO happens. Default if supported */
891 /** do not use fsync() when using direct IO i.e.: it can be set to avoid the
892 fsync() call that we make when using SRV_UNIX_O_DIRECT. However, in this
893 case user/DBA should be sure about the integrity of the meta-data */
897
898inline bool srv_is_direct_io() {
901}
902
903#else
904/** Alternatives for file i/o in Windows. @see innodb_flush_method_names. */
905enum srv_win_flush_t {
906 /** unbuffered I/O; this is the default */
907 SRV_WIN_IO_UNBUFFERED = 0,
908 /** buffered I/O */
909 SRV_WIN_IO_NORMAL,
910};
911extern enum srv_win_flush_t srv_win_file_flush_method;
912
913inline bool srv_is_direct_io() {
914 return (srv_win_file_flush_method == SRV_WIN_IO_UNBUFFERED);
915}
916
917#endif /* _WIN32 */
918
919/** Alternatives for srv_force_recovery. Non-zero values are intended
920to help the user get a damaged database up so that he can dump intact
921tables and rows with SELECT INTO OUTFILE. The database must not otherwise
922be used with these options! A bigger number below means that all precautions
923of lower numbers are included. */
924enum {
925 SRV_FORCE_IGNORE_CORRUPT = 1, /*!< let the server run even if it
926 detects a corrupt page */
927 SRV_FORCE_NO_BACKGROUND = 2, /*!< prevent the main thread from
928 running: if a crash would occur
929 in purge, this prevents it */
930 SRV_FORCE_NO_TRX_UNDO = 3, /*!< do not run trx rollback after
931 recovery */
932 SRV_FORCE_NO_IBUF_MERGE = 4, /*!< prevent also ibuf operations:
933 if they would cause a crash, better
934 not do them */
935 SRV_FORCE_NO_UNDO_LOG_SCAN = 5, /*!< do not look at undo logs when
936 starting the database: InnoDB will
937 treat even incomplete transactions
938 as committed */
939 SRV_FORCE_NO_LOG_REDO = 6 /*!< do not do the log roll-forward
940 in connection with recovery */
942
943/* Alternatives for srv_innodb_stats_method, which could be changed by
944setting innodb_stats_method */
946 SRV_STATS_NULLS_EQUAL, /* All NULL values are treated as
947 equal. This is the default setting
948 for innodb_stats_method */
949 SRV_STATS_NULLS_UNEQUAL, /* All NULL values are treated as
950 NOT equal. */
951 SRV_STATS_NULLS_IGNORED /* NULL values are ignored */
953
955
956#ifdef UNIV_DEBUG
957/** Force all user tables to use page compression. */
958extern ulong srv_debug_compress;
959#endif /* UNIV_DEBUG */
960
961/** Types of threads existing in the system. */
963 SRV_NONE, /*!< None */
964 SRV_WORKER, /*!< threads serving parallelized
965 queries and queries released from
966 lock wait */
967 SRV_PURGE, /*!< Purge coordinator thread */
968 SRV_MASTER /*!< the master thread, (whose type
969 number must be biggest) */
971
972/** Boots Innobase server. */
973void srv_boot(void);
974/** Frees the data structures created in srv_init(). */
975void srv_free(void);
976
977/** Sets the info describing an i/o thread current state.
978@param[in] i The 'segment' of the i/o thread
979@param[in] str Constant char string describing the state */
980void srv_set_io_thread_op_info(ulint i, const char *str);
981
982/** Resets the info describing an i/o thread current state. */
984/** Tells the purge thread that there has been activity in the database
985 and wakes up the purge thread if it is suspended (not sleeping). Note
986 that there is a small chance that the purge thread stays suspended
987 (we do not protect our operation with the srv_sys_t:mutex, for
988 performance reasons). */
990/** Tells the Innobase server that there has been activity in the database
991 and wakes up the master thread if it is suspended (not sleeping). Used
992 in the MySQL interface. Note that there is a small chance that the master
993 thread stays suspended (we do not protect our operation with the kernel
994 mutex, for performance reasons). */
996static inline void srv_active_wake_master_thread() {
997 if (!srv_read_only_mode) {
999 }
1000}
1001/** Wakes up the master thread if it is suspended or being suspended. */
1002void srv_wake_master_thread(void);
1003#ifndef UNIV_HOTBACKUP
1004/** Outputs to a file the output of the InnoDB Monitor.
1005@param[in] file output stream
1006@param[in] nowait whether to wait for the exclusive global lock_sys latch
1007@param[out] trx_start file position of the start of the list of active
1008 transactions
1009@param[out] trx_end file position of the end of the list of active
1010 transactions
1011@return false if not all information printed due to failure to obtain necessary
1012 mutex */
1013bool srv_printf_innodb_monitor(FILE *file, bool nowait, ulint *trx_start,
1014 ulint *trx_end);
1015
1016/** Function to pass InnoDB status variables to MySQL */
1017void srv_export_innodb_status(void);
1018/** Get current server activity count. We don't hold srv_sys::mutex while
1019 reading this value as it is only used in heuristics.
1020 @return activity count. */
1022/** Check if there has been any activity.
1023 @return false if no change in activity counter. */
1024bool srv_check_activity(ulint old_activity_count); /*!< old activity count */
1025/** Increment the server activity counter. */
1026void srv_inc_activity_count(void);
1027
1028/** Enqueues a task to server task queue and releases a worker thread, if there
1029is a suspended one. */
1030void srv_que_task_enqueue_low(que_thr_t *thr); /*!< in: query thread */
1031
1032/** A thread which prints the info output by various InnoDB monitors. */
1033void srv_monitor_thread();
1034
1035/** A thread which prints warnings about semaphore waits which have lasted
1036too long. These can be used to track bugs which cause hangs. */
1038
1039/** The master thread controlling the server. */
1040void srv_master_thread();
1041
1042/** Purge coordinator thread that schedules the purge tasks. */
1044
1045/** Worker thread that reads tasks from the work queue and executes them. */
1046void srv_worker_thread();
1047
1048/** Set encryption for UNDO tablespace with given space id.
1049@param[in] space_id Undo tablespace id
1050@param[in] mtr Mini-transaction
1051@return false for success, true otherwise */
1053
1054/** Enable UNDO tablespaces encryption.
1055@return false for success, true otherwise. */
1057
1058/** Enable REDO log encryption.
1059@return false for success, true otherwise. */
1061
1062/** Get count of tasks in the queue.
1063 @return number of tasks in queue */
1065
1066/** Releases threads of the type given from suspension in the thread table.
1067 NOTE! The server mutex has to be reserved by the caller!
1068 @return number of threads released: this may be less than n if not
1069 enough threads were suspended at the moment */
1070ulint srv_release_threads(enum srv_thread_type type, /*!< in: thread type */
1071 ulint n); /*!< in: number of threads to release */
1072
1073/** Check whether the master thread is active.
1074This is polled during the final phase of shutdown.
1075The first phase of server shutdown must have already been executed
1076(or the server must not have been fully started up).
1077@see srv_pre_dd_shutdown()
1078@retval true if any thread is active
1079@retval false if no thread is active */
1081
1082/** Wakeup the purge threads. */
1083void srv_purge_wakeup(void);
1084
1085/** Check if the purge threads are active, both coordinator and worker threads
1086@return true if any thread is active, false if no thread is active */
1088
1089/** Create an undo tablespace with an explicit file name
1090This is called during CREATE UNDO TABLESPACE.
1091@param[in] space_name tablespace name
1092@param[in] file_name file name
1093@param[in] space_id Tablespace ID
1094@return DB_SUCCESS or error code */
1095dberr_t srv_undo_tablespace_create(const char *space_name,
1096 const char *file_name, space_id_t space_id);
1097
1098/** Initialize undo::spaces and trx_sys_undo_spaces,
1099called once during srv_start(). */
1100void undo_spaces_init();
1101
1102/** Free the resources occupied by undo::spaces and trx_sys_undo_spaces,
1103called once during thread de-initialization. */
1104void undo_spaces_deinit();
1105
1106/** Set redo log variable for performance schema global status.
1107@param[in] enable true => redo log enabled, false => redo log disabled */
1108void set_srv_redo_log(bool enable);
1109
1110#ifdef UNIV_DEBUG
1111struct SYS_VAR;
1112
1113/** Disables master thread. It's used by:
1114 SET GLOBAL innodb_master_thread_disabled_debug = 1 (0).
1115@param[in] thd thread handle
1116@param[in] var pointer to system variable
1117@param[out] var_ptr where the formal string goes
1118@param[in] save immediate result from check function */
1120 void *var_ptr, const void *save);
1121#endif /* UNIV_DEBUG */
1122#endif /* !UNIV_HOTBACKUP */
1123
1124/** Status variables to be passed to MySQL */
1126 ulint innodb_data_pending_reads; /*!< Pending reads */
1127 ulint innodb_data_pending_writes; /*!< Pending writes */
1128 ulint innodb_data_pending_fsyncs; /*!< Pending fsyncs */
1129 ulint innodb_data_fsyncs; /*!< Number of fsyncs so far */
1130 ulint innodb_data_read; /*!< Data bytes read */
1131 ulint innodb_data_writes; /*!< I/O write requests */
1132 ulint innodb_data_written; /*!< Data bytes written */
1133 ulint innodb_data_reads; /*!< I/O read requests */
1135 128]; /*!< Buf pool dump status */
1137 128]; /*!< Buf pool load status */
1138 char innodb_buffer_pool_resize_status[512]; /*!< Buf pool resize status */
1139 uint32_t
1140 innodb_buffer_pool_resize_status_code; /*!< Buf pool resize status code */
1141 uint32_t innodb_buffer_pool_resize_status_progress; /*!< Buf pool resize
1142 status progess */
1143 ulint innodb_buffer_pool_pages_total; /*!< Buffer pool size */
1145 ulint innodb_buffer_pool_bytes_data; /*!< File bytes used */
1146 ulint innodb_buffer_pool_pages_dirty; /*!< Dirty data pages */
1147 ulint innodb_buffer_pool_bytes_dirty; /*!< File bytes modified */
1148 ulint innodb_buffer_pool_pages_misc; /*!< Miscellaneous pages */
1150#ifdef UNIV_DEBUG
1152#endif /* UNIV_DEBUG */
1153 ulint innodb_buffer_pool_read_requests; /*!< buf_pool->stat.n_page_gets */
1154 ulint innodb_buffer_pool_reads; /*!< srv_buf_pool_reads */
1155 ulint innodb_buffer_pool_wait_free; /*!< srv_buf_pool_wait_free */
1156 ulint innodb_buffer_pool_pages_flushed; /*!< srv_buf_pool_flushed */
1157 ulint innodb_buffer_pool_write_requests; /*!< srv_buf_pool_write_requests */
1158 ulint innodb_buffer_pool_read_ahead_rnd; /*!< srv_read_ahead_rnd */
1159 ulint innodb_buffer_pool_read_ahead; /*!< srv_read_ahead */
1160 ulint innodb_buffer_pool_read_ahead_evicted; /*!< srv_read_ahead evicted*/
1161 ulint innodb_dblwr_pages_written; /*!< srv_dblwr_pages_written */
1162 ulint innodb_dblwr_writes; /*!< srv_dblwr_writes */
1163 char innodb_redo_log_resize_status[512]; /*!< Redo log resize status */
1164 bool innodb_redo_log_read_only; /*!< Is redo log read-only ? */
1165 ulonglong innodb_redo_log_uuid; /*!< Redo log UUID */
1166 ulonglong innodb_redo_log_checkpoint_lsn; /*!< Redo log checkpoint LSN */
1167 ulonglong innodb_redo_log_current_lsn; /*!< Redo log current LSN */
1168 ulonglong
1169 innodb_redo_log_flushed_to_disk_lsn; /*!< Redo log flushed to disk LSN */
1170 ulonglong innodb_redo_log_logical_size; /*!< Redo log logical size */
1171 ulonglong innodb_redo_log_physical_size; /*!< Redo log physical size */
1172 ulonglong innodb_redo_log_capacity_resized; /*!< Redo log capacity after
1173 the last finished redo resize */
1174 ulint innodb_log_waits; /*!< srv_log_waits */
1175 ulint innodb_log_write_requests; /*!< srv_log_write_requests */
1176 ulint innodb_log_writes; /*!< srv_log_writes */
1177 lsn_t innodb_os_log_written; /*!< srv_os_log_written */
1178 ulint innodb_os_log_fsyncs; /*!< log_total_flushes() */
1179 ulint innodb_os_log_pending_writes; /*!< srv_os_log_pending_writes */
1180 ulint innodb_os_log_pending_fsyncs; /*!< log_pending_flushes() */
1181 ulint innodb_page_size; /*!< UNIV_PAGE_SIZE */
1182 ulint innodb_pages_created; /*!< buf_pool->stat.n_pages_created */
1183 ulint innodb_pages_read; /*!< buf_pool->stat.n_pages_read */
1184 ulint innodb_pages_written; /*!< buf_pool->stat.n_pages_written */
1185 bool innodb_redo_log_enabled; /*!< srv_redo_log */
1186 ulint innodb_row_lock_waits; /*!< srv_n_lock_wait_count */
1187 ulint innodb_row_lock_current_waits; /*!< srv_n_lock_wait_current_count */
1188 int64_t innodb_row_lock_time; /*!< srv_n_lock_wait_time
1189 / 1000 */
1190 ulint innodb_row_lock_time_avg; /*!< srv_n_lock_wait_time
1191 / 1000
1192 / srv_n_lock_wait_count */
1193 ulint innodb_row_lock_time_max; /*!< srv_n_lock_max_wait_time
1194 / 1000 */
1195 ulint innodb_rows_read; /*!< srv_n_rows_read */
1196 ulint innodb_rows_inserted; /*!< srv_n_rows_inserted */
1197 ulint innodb_rows_updated; /*!< srv_n_rows_updated */
1198 ulint innodb_rows_deleted; /*!< srv_n_rows_deleted */
1199 ulint innodb_system_rows_read; /*!< srv_n_system_rows_read */
1200 ulint innodb_system_rows_inserted; /*!< srv_n_system_rows_inserted */
1201 ulint innodb_system_rows_updated; /*!< srv_n_system_rows_updated */
1202 ulint innodb_system_rows_deleted; /*!< srv_n_system_rows_deleted*/
1205 ulint innodb_num_open_files; /*!< fil_n_files_open */
1206 ulint innodb_truncated_status_writes; /*!< srv_truncated_status_writes */
1207 ulint innodb_undo_tablespaces_total; /*!< total number of undo tablespaces
1208 innoDB is tracking. */
1209 ulint innodb_undo_tablespaces_implicit; /*!< number of undo tablespaces
1210 innoDB created implicitly. */
1211 ulint innodb_undo_tablespaces_explicit; /*!< number of undo tablespaces
1212 the dba created explicitly. */
1213 ulint innodb_undo_tablespaces_active; /*!< number of active undo
1214 tablespaces */
1215#ifdef UNIV_DEBUG
1216 ulint innodb_purge_trx_id_age; /*!< rw_max_trx_no - purged trx_no */
1218 - purged view's min trx_no */
1219 ulint innodb_ahi_drop_lookups; /*!< number of adaptive hash
1220 index lookups when freeing
1221 file pages */
1222#endif /* UNIV_DEBUG */
1223};
1224
1225#ifndef UNIV_HOTBACKUP
1226/** Thread slot in the thread table. */
1228 /** Thread type: user, utility etc. */
1230
1231 /** true if this slot is in use. */
1233
1234 /** true if the thread is waiting for the event of this slot. */
1236
1237 /** Time when the thread was suspended. Initialized by
1238 lock_wait_table_reserve_slot() for lock wait. */
1239 std::chrono::steady_clock::time_point suspend_time;
1240
1241 /** Stores the current value of lock_wait_table_reservations, when
1242 lock_wait_table_reserve_slot is called.
1243 This can be used as a version number to avoid ABA problems.
1244 The difference lock_wait_table_reservations - reservation_no tells us how many
1245 other threads got suspended while our thr was sleeping.
1246 This can be used to determine if the wait was unfairly long, and it is time to
1247 boost trx->lock.schedule_weight.
1248 Protected by lock->wait_mutex. */
1250
1251 /** Wait time that if exceeded the thread will be timed out.
1252 Initialized by lock_wait_table_reserve_slot() for lock wait. */
1253 std::chrono::steady_clock::duration wait_timeout;
1254
1255 /** Event used in suspending the thread when it has nothing to do. */
1257
1258 /** Suspended query thread (only used for user threads). */
1260};
1261#endif /* !UNIV_HOTBACKUP */
1262
1263#endif
uint32_t space_id_t
Tablespace identifier.
Definition: api0api.h:48
Buffer pool checksum functions, also linked from /extra/innochecksum.cc.
Definition: os0thread.h:47
Class to write and replay ddl logs.
Definition: log0ddl.h:416
For each client connection we create a separate thread with THD serving as a thread/connection descri...
Definition: sql_lexer_thd.h:36
const char * p
Definition: ctype-mb.cc:1235
dberr_t
Definition: db0err.h:39
The low-level file system.
#define UINT32_MAX
Definition: lexyy.cc:86
DDL log.
uint64_t lsn_t
Type used for all log sequence number storage and arithmetic.
Definition: log0types.h:63
unsigned long long int ulonglong
Definition: my_inttypes.h:56
long long int longlong
Definition: my_inttypes.h:55
Instrumentation helpers for stages.
std::string str(const mysqlrouter::ConfigGenerator::Options::Endpoint &ep)
Definition: config_generator.cc:1081
const std::string FILE("FILE")
Definition: os0file.h:89
std::string file_name(Log_file_id file_id)
Provides name of the log file with the given file id, e.g.
Definition: log0pre_8_0_30.cc:94
The interface to the operating system condition variables.
The interface to the operating system file io.
constexpr uint32_t OS_FILE_MAX_PATH
Definition: os0file.h:650
The interface to the operating system process and thread control primitives.
Query graph global types.
required string type
Definition: replication_group_member_actions.proto:34
InnoDB concurrency manager header file.
bool high_level_read_only
Set if InnoDB operates in read-only mode or innodb-force-recovery is greater than SRV_FORCE_NO_TRX_UN...
Definition: srv0srv.cc:212
PSI_stage_info srv_stage_alter_tablespace_encryption
Performance schema stage event for monitoring ALTER TABLESPACE ENCRYPTION progress.
Definition: srv0srv.cc:843
ib_mutex_t srv_monitor_file_mutex
Definition: srv0srv.cc:629
FILE * srv_monitor_file
Temporary file for innodb monitor output.
Definition: srv0srv.cc:632
ulint srv_buf_pool_size
Requested size in bytes.
Definition: srv0srv.cc:424
constexpr uint32_t SRV_MAX_IO_CAPACITY_DUMMY_DEFAULT
Definition: srv0srv.h:633
mysql_pfs_key_t log_archiver_thread_key
ulong srv_buf_pool_dump_pct
Dump this % of each buffer pool during BP dump.
Definition: srv0srv.cc:462
bool srv_downgrade_logs
ulong srv_log_n_files
Value of innodb_log_files_in_group.
Definition: srv0srv.cc:243
bool set_undo_tablespace_encryption(space_id_t space_id, mtr_t *mtr)
Set encryption for UNDO tablespace with given space id.
Definition: srv0srv.cc:2547
ulong srv_log_wait_for_flush_timeout
Timeout used when waiting for redo flush (microseconds).
Definition: srv0srv.cc:317
bool srv_numa_interleave
Definition: srv0srv.cc:222
void set_srv_redo_log(bool enable)
Set redo log variable for performance schema global status.
Definition: srv0srv.cc:3275
bool srv_thread_is_active(const IB_thread &thread)
Check if given thread is still active.
Definition: srv0srv.cc:3261
mysql_pfs_key_t log_flush_notifier_thread_key
srv_thread_type
Types of threads existing in the system.
Definition: srv0srv.h:962
@ SRV_WORKER
threads serving parallelized queries and queries released from lock wait
Definition: srv0srv.h:964
@ SRV_MASTER
the master thread, (whose type number must be biggest)
Definition: srv0srv.h:968
@ SRV_NONE
None.
Definition: srv0srv.h:963
@ SRV_PURGE
Purge coordinator thread.
Definition: srv0srv.h:967
mysql_pfs_key_t srv_lock_timeout_thread_key
ulong srv_n_write_io_threads
Definition: srv0srv.cc:472
void srv_wake_purge_thread_if_not_active(void)
Tells the purge thread that there has been activity in the database and wakes up the purge thread if ...
Definition: srv0srv.cc:1960
ulong srv_log_write_notifier_spin_delay
Number of spin iterations, for which log write notifier thread is waiting for advanced writeed_to_dis...
Definition: srv0srv.cc:357
bool srv_buffer_pool_dump_at_shutdown
Boolean config knobs that tell InnoDB to dump the buffer pool at shutdown and/or load it during start...
Definition: srv0srv.cc:796
constexpr uint32_t SRV_MAX_IO_CAPACITY_LIMIT
Definition: srv0srv.h:634
mysql_pfs_key_t ddl_thread_key
mysql_pfs_key_t fts_parallel_tokenization_thread_key
PSI_stage_info srv_stage_alter_table_log_table
Performance schema stage event for monitoring ALTER TABLE progress row_log_table_apply().
Definition: srv0srv.cc:828
const ulonglong srv_buf_pool_chunk_unit_min
Minimum buffer pool chunk size.
Definition: srv0srv.cc:435
bool srv_sync_debug
Definition: sync0debug.cc:66
ulong srv_checksum_algorithm
the macro MYSQL_SYSVAR_ENUM() requires "long unsigned int" and if we use srv_checksum_algorithm_t her...
Definition: checksum.cc:57
@ SRV_FORCE_NO_BACKGROUND
prevent the main thread from running: if a crash would occur in purge, this prevents it
Definition: srv0srv.h:927
@ SRV_FORCE_NO_IBUF_MERGE
prevent also ibuf operations: if they would cause a crash, better not do them
Definition: srv0srv.h:932
@ SRV_FORCE_NO_LOG_REDO
do not do the log roll-forward in connection with recovery
Definition: srv0srv.h:939
@ SRV_FORCE_IGNORE_CORRUPT
let the server run even if it detects a corrupt page
Definition: srv0srv.h:925
@ SRV_FORCE_NO_TRX_UNDO
do not run trx rollback after recovery
Definition: srv0srv.h:930
@ SRV_FORCE_NO_UNDO_LOG_SCAN
do not look at undo logs when starting the database: InnoDB will treat even incomplete transactions a...
Definition: srv0srv.h:935
ulong srv_log_flush_notifier_spin_delay
Number of spin iterations, for which log flush notifier thread is waiting for advanced flushed_to_dis...
Definition: srv0srv.cc:370
ulong srv_fast_shutdown
The value of the configuration parameter innodb_fast_shutdown, controlling the InnoDB shutdown.
Definition: srv0srv.cc:568
ulong srv_log_wait_for_write_spin_delay
Number of spin iterations, when spinning and waiting for log buffer written up to given LSN,...
Definition: srv0srv.cc:301
ib_mutex_t page_zip_stat_per_index_mutex
Mutex protecting page_zip_stat_per_index.
Definition: srv0srv.cc:626
mysql_pfs_key_t log_flusher_thread_key
PSI_stage_info srv_stage_alter_table_flush
Performance schema stage event for monitoring ALTER TABLE progress log_make_latest_checkpoint().
Definition: srv0srv.cc:813
bool srv_btr_search_enabled
A value that basically stores the same as btr_search_enabled, but is not atomic and thus can be used ...
Definition: btr0sea.cc:67
unsigned long long srv_max_undo_tablespace_size
Maximum size of undo tablespace.
Definition: srv0srv.cc:190
ulong srv_log_write_ahead_size
Size of block, used for writing ahead to avoid read-on-write.
Definition: srv0srv.h:561
bool srv_print_ddl_logs
Print all DDL logs to mysqld stderr.
Definition: srv0srv.cc:548
uint srv_change_buffer_max_size
Maximum on-disk size of change buffer in terms of percentage of the buffer pool.
Definition: srv0srv.cc:483
bool srv_use_fdatasync
Use fdatasync() instead of fsync().
Definition: srv0srv.cc:450
void srv_purge_wakeup(void)
Wakeup the purge threads.
Definition: srv0srv.cc:3223
PSI_stage_info srv_stage_alter_table_end
Performance schema stage event for monitoring ALTER TABLE progress everything after flush log_make_la...
Definition: srv0srv.cc:808
ulong srv_sync_array_size
User configured sync array size.
Definition: sync0arr.cc:58
ulong srv_force_recovery_crash
Inject a crash at different steps of the recovery process.
Definition: srv0srv.cc:541
const ulint srv_buf_pool_def_size
Default pool size in bytes.
Definition: srv0srv.cc:428
void undo_spaces_deinit()
Free the resources occupied by undo::spaces and trx_sys_undo_spaces, called once during thread de-ini...
Definition: srv0start.cc:1153
char * srv_log_group_home_dir
Definition: srv0srv.cc:238
bool srv_ibuf_disable_background_merge
Definition: ibuf0ibuf.cc:45
mysql_pfs_key_t io_read_thread_key
std::chrono::seconds get_srv_flush_log_at_timeout()
Definition: srv0srv.cc:396
mysql_pfs_key_t srv_monitor_thread_key
uint srv_log_spin_cpu_pct_hwm
Maximum percentage of cpu time for which spin-delay is used.
Definition: srv0srv.cc:268
bool srv_stats_auto_recalc
Definition: srv0srv.cc:583
constexpr uint32_t MAX_PURGE_THREADS
Maximum number of purge threads, including the purge coordinator.
Definition: srv0srv.h:644
ulong srv_max_io_capacity
Definition: srv0srv.cc:493
ulong srv_log_flusher_spin_delay
Number of spin iterations, for which log flusher thread is waiting for new data to flush,...
Definition: srv0srv.cc:346
bool srv_purge_threads_active()
Check if the purge threads are active, both coordinator and worker threads.
Definition: srv0srv.cc:3240
const ulonglong srv_buf_pool_chunk_unit_blk_sz
The buffer pool chunk size must be a multiple of this number.
Definition: srv0srv.cc:437
void srv_worker_thread()
Worker thread that reads tasks from the work queue and executes them.
Definition: srv0srv.cc:2841
void srv_export_innodb_status(void)
Function to pass InnoDB status variables to MySQL.
Definition: srv0srv.cc:1569
ulong srv_undo_tablespaces
Number of undo tablespaces to use.
Definition: srv0srv.cc:159
ulong srv_spin_wait_delay
Definition: ut0mutex.h:107
std::chrono::milliseconds get_srv_replication_delay()
Definition: srv0srv.cc:586
std::atomic_uint32_t srv_innodb_needs_monitoring
In contrast to srv_print_innodb_monitor which is controlled by the user, this variable is controlled ...
Definition: srv0srv.cc:610
bool srv_file_per_table
store to its own file each table created by an user; data dictionary tables are in the system tablesp...
Definition: srv0srv.cc:204
const char * srv_main_thread_op_info
Definition: srv0srv.cc:133
const ulint srv_buf_pool_min_size
Minimum pool size in bytes.
Definition: srv0srv.cc:426
double srv_max_dirty_pages_pct_lwm
Definition: srv0srv.cc:504
mysql_pfs_key_t srv_ts_alter_encrypt_thread_key
ulong srv_log_buffer_size
Space for log buffer, expressed in bytes.
Definition: srv0srv.cc:256
void srv_inc_activity_count(void)
Increment the server activity counter.
Definition: srv0srv.cc:1906
ulong srv_log_recent_written_size
Number of slots in a small buffer, which is used to allow concurrent writes to log buffer.
Definition: srv0srv.cc:291
constexpr uint32_t SRV_MAX_N_IO_THREADS
Definition: srv0srv.h:753
double srv_max_buf_pool_modified_pct
Definition: srv0srv.cc:503
ulong srv_flush_log_at_trx_commit
Definition: srv0srv.cc:394
FILE * srv_misc_tmpfile
Temporary file for miscellaneous diagnostic output.
Definition: srv0srv.cc:638
void srv_purge_coordinator_thread()
Purge coordinator thread that schedules the purge tasks.
Definition: srv0srv.cc:3084
bool srv_adaptive_flushing
Definition: srv0srv.cc:406
bool srv_enable_redo_encryption()
Enable REDO log encryption.
Definition: srv0srv.cc:2513
bool srv_cmp_per_index_enabled
Enable INFORMATION_SCHEMA.innodb_cmp_per_index.
Definition: srv0srv.cc:551
bool srv_downgrade_partition_files
Definition: srv0srv.cc:119
void srv_set_io_thread_op_info(ulint i, const char *str)
Sets the info describing an i/o thread current state.
Definition: srv0srv.cc:879
dberr_t srv_undo_tablespace_create(const char *space_name, const char *file_name, space_id_t space_id)
Create an undo tablespace with an explicit file name This is called during CREATE UNDO TABLESPACE.
Definition: srv0start.cc:1072
enum srv_unix_flush_t srv_unix_file_flush_method
Definition: srv0srv.cc:486
ulong srv_LRU_scan_depth
Scan depth for LRU flush batch i.e.
Definition: srv0srv.cc:452
void srv_free(void)
Frees the data structures created in srv_init().
Definition: srv0srv.cc:1213
ulong srv_log_write_events
Number of events used for notifications about redo write.
Definition: srv0srv.cc:283
ulint srv_buf_pool_base_size
Current size as scaling factor for the other components.
Definition: srv0srv.cc:458
ulong srv_n_spin_wait_rounds
Definition: ut0mutex.h:108
void srv_thread_delay_cleanup_if_needed(bool wait_for_signal)
Delay the thread after it discovered that the shutdown_state is greater or equal to SRV_SHUTDOWN_CLEA...
Definition: srv0start.cc:2940
ulong srv_log_writer_timeout
Initial timeout used to wait on writer_event.
Definition: srv0srv.cc:329
static ulong PCT_IO(ulong p)
Definition: srv0srv.h:639
mysql_pfs_key_t clone_gtid_thread_key
unsigned long long srv_stats_persistent_sample_pages
Definition: srv0srv.cc:582
mysql_pfs_key_t parallel_read_thread_key
bool srv_disable_sort_file_cache
Whether to disable file system cache.
Definition: ddl0ddl.cc:47
const ulonglong srv_buf_pool_chunk_unit_max
Maximum buffer pool chunk size.
Definition: srv0srv.cc:439
mysql_pfs_key_t recv_writer_thread_key
void srv_active_wake_master_thread_low(void)
Tells the Innobase server that there has been activity in the database and wakes up the master thread...
Definition: srv0srv.cc:1924
ulong srv_dblwr_pages
Number of pages per doublewrite thread/segment.
ulong srv_idle_flush_pct
How much flush to be done in case of server is idle.
Definition: srv0srv.cc:467
bool srv_use_native_aio
If this flag is true, then we will use the native aio of the OS (provided we compiled Innobase with i...
Definition: srv0srv.cc:220
mysql_pfs_key_t srv_error_monitor_thread_key
mysql_pfs_key_t io_write_thread_key
mysql_pfs_key_t dict_stats_thread_key
ulong srv_flush_neighbors
Whether or not to flush neighbors of a block.
Definition: srv0srv.cc:454
bool tbsp_extend_and_initialize
Enable or disable writing of NULLs while extending a tablespace.
Definition: srv0srv.cc:524
void srv_que_task_enqueue_low(que_thr_t *thr)
Enqueues a task to server task queue and releases a worker thread, if there is a suspended one.
Definition: srv0srv.cc:3202
bool srv_buf_pool_debug
This is used to enable multiple buffer pool instances with small buffer pool size.
Definition: buf0buf.cc:337
bool srv_printf_innodb_monitor(FILE *file, bool nowait, ulint *trx_start, ulint *trx_end)
Outputs to a file the output of the InnoDB Monitor.
Definition: srv0srv.cc:1345
ulong srv_log_wait_for_write_timeout
Timeout used when waiting for redo write (microseconds).
Definition: srv0srv.cc:305
bool srv_log_writer_threads
Whether to activate/pause the log writer threads.
Definition: srv0srv.cc:262
char * srv_buf_dump_filename
The buffer pool dump/load file name.
Definition: srv0srv.cc:792
ulong srv_log_writer_spin_delay
Number of spin iterations, for which log writer thread is waiting for new data to write or flush with...
Definition: srv0srv.cc:326
std::atomic< int > srv_fatal_semaphore_wait_extend
Definition: srv0srv.cc:123
void undo_spaces_init()
Initialize undo::spaces and trx_sys_undo_spaces, called once during srv_start().
Definition: srv0start.cc:1140
bool srv_redo_log
If innodb redo logging is enabled.
Definition: srv0srv.cc:554
ulint srv_dml_needed_delay
Definition: srv0srv.cc:131
bool srv_priority_boost
Definition: srv0srv.cc:593
mysql_pfs_key_t buf_dump_thread_key
void srv_wake_master_thread(void)
Wakes up the master thread if it is suspended or being suspended.
Definition: srv0srv.cc:1970
ulong srv_max_purge_lag
Maximum allowable purge history length.
Definition: trx0purge.cc:71
struct export_var_t export_vars
Status variables to be passed to MySQL.
Definition: srv0srv.cc:531
uint32_t srv_rseg_init_threads
Number of threads spawned for initializing rollback segments in parallel.
Definition: srv0srv.cc:151
char * srv_undo_dir
Server undo tablespaces directory, can be absolute path.
Definition: srv0srv.cc:155
ulint srv_truncated_status_writes
Definition: srv0srv.cc:607
std::chrono::milliseconds get_srv_log_checkpoint_every()
Period every which a periodical checkpoint is written by the log checkpointer thread (unless periodic...
Definition: srv0srv.cc:340
bool srv_undo_log_encrypt
Enable or disable Encrypt of UNDO tablespace.
Definition: srv0srv.cc:187
const char * srv_io_thread_function[]
Definition: srv0srv.cc:617
std::chrono::microseconds get_srv_log_wait_for_flush_timeout()
Timeout used when waiting for redo flush.
Definition: srv0srv.cc:320
ulint srv_lock_table_size
Lock table size in bytes.
Definition: srv0srv.cc:464
bool srv_validate_tablespace_paths
Whether to validate InnoDB tablespace paths on startup.
Definition: srv0srv.cc:448
bool srv_check_activity(ulint old_activity_count)
Check if there has been any activity.
Definition: srv0srv.cc:1987
std::chrono::microseconds get_srv_log_write_notifier_timeout()
Initial timeout used to wait on write_notifier_event.
Definition: srv0srv.cc:364
ulint srv_get_activity_count(void)
Get current server activity count.
Definition: srv0srv.cc:1981
ulonglong srv_buf_pool_chunk_unit
Requested buffer pool chunk size.
Definition: srv0srv.cc:433
ulong srv_log_wait_for_flush_spin_delay
Number of spin iterations, when spinning and waiting for log flushed.
Definition: srv0srv.cc:313
char * srv_innodb_directories
The innodb_directories variable value.
Definition: srv0srv.cc:147
ulong srv_innodb_stats_method
Definition: srv0srv.cc:522
bool srv_master_thread_disabled_debug
Value of MySQL global used to disable master thread.
Definition: srv0srv.cc:230
ulong srv_debug_compress
Force all user tables to use page compression.
Definition: srv0srv.cc:226
void srv_boot(void)
Boots Innobase server.
Definition: srv0srv.cc:1284
PSI_stage_info srv_stage_clone_file_copy
Performance schema stage event for monitoring clone file copy progress.
Definition: srv0srv.cc:853
const ulong srv_idle_flush_pct_default
Default value of srv_idle_flush_pct.
Definition: srv0srv.cc:466
bool srv_print_innodb_monitor
Definition: srv0srv.cc:609
ulonglong srv_log_file_size
Value of innodb_log_file_size.
Definition: srv0srv.cc:245
ulong srv_buf_pool_instances
Requested number of buffer pool instances.
Definition: srv0srv.cc:442
mysql_pfs_key_t log_write_notifier_thread_key
srv_unix_flush_t
Alternatives for the file flush option in Unix.
Definition: srv0srv.h:877
@ SRV_UNIX_O_DSYNC
open log files in O_SYNC mode
Definition: srv0srv.h:881
@ SRV_UNIX_FSYNC
fsync, the default if O_DIRECT is not supported
Definition: srv0srv.h:879
@ SRV_UNIX_NOSYNC
do not flush after writing
Definition: srv0srv.h:886
@ SRV_UNIX_O_DIRECT_NO_FSYNC
do not use fsync() when using direct IO i.e.
Definition: srv0srv.h:894
@ SRV_UNIX_LITTLESYNC
do not call os_file_flush() when writing data files, but do flush after writing to log files
Definition: srv0srv.h:884
@ SRV_UNIX_O_DIRECT
invoke os_file_set_nocache() on data files.
Definition: srv0srv.h:890
mysql_pfs_key_t log_writer_thread_key
mysql_pfs_key_t buf_resize_thread_key
bool srv_is_direct_io()
Definition: srv0srv.h:898
bool srv_upgrade_old_undo_found
ulong srv_n_page_hash_locks
Number of locks to protect buf_pool->page_hash.
Definition: srv0srv.cc:446
bool srv_checkpoint_disabled
If true then disable checkpointing.
Definition: srv0srv.cc:388
std::chrono::seconds get_srv_fatal_semaphore_wait_threshold()
Definition: srv0srv.cc:125
ulong srv_adaptive_max_sleep_delay
Maximum sleep delay (in micro-seconds), value of 0 disables it.
Definition: srv0conc.cc:63
ulong srv_parallel_read_threads
Number of threads to use for parallel reads.
Definition: srv0srv.cc:215
unsigned long long srv_online_max_size
Maximum modification log file size for online index creation.
Definition: srv0srv.cc:209
ulong srv_flushing_avg_loops
Definition: srv0srv.cc:511
ulong srv_log_recent_closed_size
Number of slots in a small buffer, which is used to break requirement for total order of dirty pages,...
Definition: srv0srv.cc:296
bool srv_inject_too_many_concurrent_trxs
Definition: srv0srv.cc:390
ulint srv_buf_pool_old_size
Previously requested size.
Definition: srv0srv.cc:456
char * srv_data_home
Definition: srv0srv.cc:140
bool srv_load_corrupted
Definition: dict0load.cc:139
ulong srv_n_page_cleaners
Definition: srv0srv.cc:496
ulong srv_log_checkpoint_every
Number of milliseconds every which a periodical checkpoint is written by the log checkpointer thread ...
Definition: srv0srv.cc:338
bool srv_random_read_ahead
Definition: srv0srv.cc:475
bool srv_buffer_pool_load_at_startup
Definition: srv0srv.cc:797
ulong srv_n_read_io_threads
Definition: srv0srv.cc:471
ulong srv_n_free_tickets_to_enter
Number of times a thread is allowed to enter InnoDB within the same SQL query after it has once got t...
Definition: srv0conc.cc:60
PSI_stage_info srv_stage_buffer_pool_load
Performance schema stage event for monitoring buffer pool load progress.
Definition: srv0srv.cc:848
ulong srv_log_flush_notifier_timeout
Initial timeout used to wait on flush_notifier_event.
Definition: srv0srv.cc:374
double srv_max_dirty_pages_pct
ulong srv_replication_delay
Definition: srv0srv.cc:585
mysql_pfs_key_t srv_purge_thread_key
std::chrono::microseconds get_srv_log_flush_notifier_timeout()
Initial timeout used to wait on flush_notifier_event.
Definition: srv0srv.cc:377
void srv_master_thread_disabled_debug_update(THD *thd, SYS_VAR *var, void *var_ptr, const void *save)
Disables master thread.
Definition: srv0srv.cc:2065
ulong srv_purge_batch_size
Definition: srv0srv.cc:517
os_event_t srv_monitor_event
Event to signal the monitor thread.
Definition: srv0srv.cc:780
ulonglong srv_redo_log_capacity
Value of innodb_redo_log_capacity.
Definition: srv0srv.cc:247
PSI_stage_info srv_stage_alter_table_read_pk_internal_sort
Performance schema stage event for monitoring ALTER TABLE progress row_merge_read_clustered_index().
Definition: srv0srv.cc:837
mysql_pfs_key_t srv_master_thread_key
ulonglong srv_redo_log_capacity_used
Assumed value of innodb_redo_log_capacity's - value which is used.
Definition: srv0srv.cc:247
ulong srv_purge_rseg_truncate_frequency
Rate at which UNDO records should be purged.
Definition: srv0srv.cc:175
os_event_t srv_error_event
Event to signal the error thread.
Definition: srv0srv.cc:783
PSI_stage_info srv_stage_alter_table_insert
Performance schema stage event for monitoring ALTER TABLE progress row_merge_insert_index_tuples().
Definition: srv0srv.cc:817
mysql_pfs_key_t io_ibuf_thread_key
srv_stats_method_name_enum
Definition: srv0srv.h:945
@ SRV_STATS_NULLS_UNEQUAL
Definition: srv0srv.h:949
@ SRV_STATS_NULLS_IGNORED
Definition: srv0srv.h:951
@ SRV_STATS_NULLS_EQUAL
Definition: srv0srv.h:946
PSI_stage_info srv_stage_alter_table_merge_sort
Performance schema stage event for monitoring ALTER TABLE progress row_merge_sort().
Definition: srv0srv.cc:833
PSI_stage_info srv_stage_clone_page_copy
Performance schema stage event for monitoring clone page copy progress.
Definition: srv0srv.cc:861
uint srv_log_spin_cpu_abs_lwm
Minimum absolute value of cpu time for which spin-delay is used.
Definition: srv0srv.cc:265
os_event_t srv_buf_dump_event
The buffer pool dump/load thread waits on this event.
Definition: srv0srv.cc:786
bool srv_stats_persistent
Definition: srv0srv.cc:580
ulong srv_read_ahead_threshold
Definition: srv0srv.cc:479
void innobase_set_open_files_limit(long new_limit)
Sets new value of the "innodb_open_files" configuration variable to present to users.
Definition: ha_innodb.cc:5021
mysql_pfs_key_t log_checkpointer_thread_key
mysql_pfs_key_t page_flush_thread_key
bool srv_read_only_mode
Set if InnoDB must operate in read-only mode.
Definition: srv0srv.cc:200
ulong srv_log_wait_for_flush_spin_hwm
Maximum value of average log flush time for which spin-delay is used.
Definition: srv0srv.cc:273
bool srv_purge_view_update_only_debug
Definition: trx0purge.cc:87
mysql_pfs_key_t log_files_governor_thread_key
ulong srv_log_write_max_size
When log writer follows links in the log recent written buffer, it stops when it has reached at least...
Definition: srv0srv.cc:280
void srv_monitor_thread()
A thread which prints the info output by various InnoDB monitors.
Definition: srv0srv.cc:1775
bool srv_log_checksums
Whether to generate and require checksums on the redo log pages.
Definition: srv0srv.cc:384
bool srv_innodb_status
Definition: srv0srv.cc:571
enum srv_stats_method_name_enum srv_stats_method_name_t
Definition: srv0srv.h:954
const longlong srv_buf_pool_max_size
Maximum pool size in bytes.
Definition: srv0srv.cc:430
Srv_cpu_usage srv_cpu_usage
Structure with cpu usage information.
Definition: srv0srv.cc:107
mysql_pfs_key_t page_archiver_thread_key
bool srv_undo_log_truncate
Enable or Disable Truncate of UNDO tablespace.
Definition: srv0srv.cc:184
mysql_pfs_key_t clone_ddl_thread_key
uint buf_LRU_old_threshold
Move blocks to "new" LRU list only if the first access was at least this many milliseconds ago.
Definition: buf0lru.cc:132
ulong srv_fatal_semaphore_wait_threshold
Definition: srv0srv.cc:122
mysql_pfs_key_t parallel_rseg_init_thread_key
bool srv_print_innodb_lock_monitor
Definition: srv0srv.cc:611
ib_mutex_t srv_misc_tmpfile_mutex
Mutex for locking srv_misc_tmpfile.
Definition: srv0srv.cc:636
ulong srv_force_recovery
Normally 0.
Definition: srv0srv.cc:537
bool srv_stats_include_delete_marked
Definition: srv0srv.cc:581
ulong srv_adaptive_flushing_lwm
Definition: srv0srv.cc:508
ulong srv_n_purge_threads
Definition: srv0srv.cc:514
std::chrono::microseconds get_srv_log_writer_timeout()
Initial timeout used to wait on writer_event.
Definition: srv0srv.cc:331
ulong srv_log_write_notifier_timeout
Initial timeout used to wait on write_notifier_event.
Definition: srv0srv.cc:361
const char * srv_io_thread_op_info[]
Definition: srv0srv.cc:616
bool srv_dedicated_server
Dedicated server setting.
Definition: srv0srv.cc:422
Log_DDL * log_ddl
Object to handle Log_DDL.
Definition: log0ddl.cc:63
std::chrono::microseconds get_srv_log_wait_for_write_timeout()
Timeout used when waiting for redo write.
Definition: srv0srv.cc:308
bool srv_flush_sync
Definition: srv0srv.cc:409
PSI_stage_info srv_stage_clone_redo_copy
Performance schema stage event for monitoring clone redo copy progress.
Definition: srv0srv.cc:857
uint srv_flush_log_at_timeout
Definition: srv0srv.cc:395
long long srv_buf_pool_curr_size
Current size in bytes.
Definition: srv0srv.cc:460
ulong srv_log_flush_events
Number of events used for notifications about redo flush.
Definition: srv0srv.cc:286
ulong srv_log_flusher_timeout
Initial timeout used to wait on flusher_event.
Definition: srv0srv.cc:349
void srv_reset_io_thread_op_info()
Resets the info describing an i/o thread current state.
Definition: srv0srv.cc:886
unsigned long long srv_stats_transient_sample_pages
Definition: srv0srv.cc:579
mysql_pfs_key_t bulk_flusher_thread_key
srv_stats_t srv_stats
Global counters.
Definition: srv0srv.cc:527
ulong srv_io_capacity
Definition: srv0srv.cc:492
bool srv_is_upgrade_mode
mysql_pfs_key_t trx_recovery_rollback_thread_key
bool srv_master_thread_is_active()
Check whether the master thread is active.
Definition: srv0srv.cc:1915
void srv_error_monitor_thread()
A thread which prints warnings about semaphore waits which have lasted too long.
Definition: srv0srv.cc:1835
mysql_pfs_key_t srv_worker_thread_key
void srv_master_thread()
The master thread controlling the server.
Definition: srv0srv.cc:2742
const size_t CONCURRENT_UNDO_TRUNCATE_LIMIT
Maximum number of recently truncated undo tablespace IDs for the same undo number.
Definition: srv0srv.cc:194
ulong srv_sort_buf_size
Sort buffer size in index creation.
Definition: srv0srv.cc:207
Srv_threads srv_threads
Structure with state of srv background threads.
Definition: srv0srv.cc:104
PSI_stage_info srv_stage_alter_table_log_index
Performance schema stage event for monitoring ALTER TABLE progress row_log_apply().
Definition: srv0srv.cc:822
const ulong srv_buf_pool_instances_default
Default number of buffer pool instances.
Definition: srv0srv.cc:444
ulong srv_thread_sleep_delay
Sleep delay for threads waiting to enter InnoDB.
Definition: srv0conc.cc:65
mysql_pfs_key_t page_flush_coordinator_thread_key
std::chrono::microseconds get_srv_log_flusher_timeout()
Initial timeout used to wait on flusher_event.
Definition: srv0srv.cc:351
ulint srv_release_threads(enum srv_thread_type type, ulint n)
Releases threads of the type given from suspension in the thread table.
Definition: srv0srv.cc:1028
bool srv_print_all_deadlocks
Print all user-level transactions deadlocks to mysqld stderr.
Definition: srv0srv.cc:545
ulint srv_get_task_queue_length(void)
Get count of tasks in the queue.
Definition: srv0srv.cc:3216
ulong srv_max_purge_lag_delay
Max DML user threads delay in micro-seconds.
Definition: trx0purge.cc:74
mysql_pfs_key_t bulk_alloc_thread_key
bool srv_thread_is_stopped(const IB_thread &thread)
Check if given thread is cleaned-up and stopped.
Definition: srv0srv.cc:3265
mysql_pfs_key_t fts_parallel_merge_thread_key
ulong srv_rollback_segments
The number of rollback segments per tablespace.
Definition: srv0srv.cc:163
constexpr size_t SRV_N_LOG_FILES_CLONE_MAX
Definition: srv0srv.h:434
bool srv_enable_undo_encryption()
Enable UNDO tablespaces encryption.
Definition: srv0srv.cc:2591
os_event_t srv_buf_resize_event
The buffer pool resize thread waits on this event.
Definition: srv0srv.cc:789
mysql_pfs_key_t fts_optimize_thread_key
bool srv_redo_log_encrypt
Enable or Disable Encrypt of REDO tablespace.
Definition: srv0srv.cc:241
static void srv_active_wake_master_thread()
Definition: srv0srv.h:996
long innobase_get_open_files_limit()
Returns current value of the "innodb_open_files" configuration variable.
Definition: ha_innodb.cc:5020
Stage instrument information.
Definition: psi_stage_bits.h:74
Definition: plugin.h:69
Definition: srv0srv.h:282
double stime_abs
Definition: srv0srv.h:285
double utime_abs
Definition: srv0srv.h:284
double stime_pct
Definition: srv0srv.h:287
int n_cpu
Definition: srv0srv.h:283
double utime_pct
Definition: srv0srv.h:286
Structure which keeps shared future objects for InnoDB background threads.
Definition: srv0srv.h:165
IB_thread m_recv_writer
Thread writing recovered pages during recovery.
Definition: srv0srv.h:215
IB_thread m_gtid_persister
Thread for GTID persistence.
Definition: srv0srv.h:247
IB_thread * m_purge_workers
Purge workers.
Definition: srv0srv.h:225
IB_thread m_error_monitor
Error monitor thread.
Definition: srv0srv.h:170
IB_thread m_ts_alter_encrypt
The ts_alter_encrypt thread.
Definition: srv0srv.h:209
os_event_t m_shutdown_cleanup_dbg
Used in test scenario to delay threads' cleanup until the pre_dd_shutdown is ended and final plugin's...
Definition: srv0srv.h:254
size_t m_purge_workers_n
Number of purge workers and size of array below.
Definition: srv0srv.h:221
IB_thread m_purge_coordinator
Purge coordinator (also being a worker)
Definition: srv0srv.h:218
IB_thread m_log_flush_notifier
Redo flush notifier thread.
Definition: srv0srv.h:188
IB_thread * m_page_cleaner_workers
Page cleaner workers.
Definition: srv0srv.h:235
IB_thread m_buf_resize
Buffer pool resize thread.
Definition: srv0srv.h:197
IB_thread m_lock_wait_timeout
Thread detecting lock wait timeouts.
Definition: srv0srv.h:203
IB_thread m_backup_log_archiver
Redo log archiver (used by backup).
Definition: srv0srv.h:191
IB_thread m_log_flusher
Redo flusher thread.
Definition: srv0srv.h:182
IB_thread m_fts_optimize
Thread doing optimization for FTS index.
Definition: srv0srv.h:244
IB_thread m_log_files_governor
Redo files governor thread.
Definition: srv0srv.h:173
IB_thread m_log_archiver
Archiver's log archiver (used by Clone).
Definition: srv0srv.h:238
IB_thread m_page_cleaner_coordinator
Page cleaner coordinator (also being a worker).
Definition: srv0srv.h:228
IB_thread m_page_archiver
Archiver's page archiver (used by Clone).
Definition: srv0srv.h:241
IB_thread m_trx_recovery_rollback
Thread doing rollbacks during recovery.
Definition: srv0srv.h:212
IB_thread m_log_write_notifier
Redo write notifier thread.
Definition: srv0srv.h:185
IB_thread m_buf_dump
Buffer pool dump thread.
Definition: srv0srv.h:194
IB_thread m_monitor
Monitor thread (prints info).
Definition: srv0srv.h:167
os_event_t m_master_ready_for_dd_shutdown
When the master thread notices that shutdown has started (by noticing srv_shutdown_state >= SRV_SHUTD...
Definition: srv0srv.h:266
IB_thread m_log_writer
Redo writer thread.
Definition: srv0srv.h:179
IB_thread m_dict_stats
Dict stats background thread.
Definition: srv0srv.h:200
size_t m_page_cleaner_workers_n
Number of page cleaner workers and size of array below.
Definition: srv0srv.h:231
IB_thread m_log_checkpointer
Redo checkpointer thread.
Definition: srv0srv.h:176
IB_thread m_master
The master thread.
Definition: srv0srv.h:206
Status variables to be passed to MySQL.
Definition: srv0srv.h:1125
ulonglong innodb_redo_log_uuid
Redo log UUID.
Definition: srv0srv.h:1165
ulint innodb_buffer_pool_pages_flushed
srv_buf_pool_flushed
Definition: srv0srv.h:1156
ulonglong innodb_redo_log_logical_size
Redo log logical size.
Definition: srv0srv.h:1170
ulint innodb_buffer_pool_pages_latched
Latched pages.
Definition: srv0srv.h:1151
ulint innodb_system_rows_updated
srv_n_system_rows_updated
Definition: srv0srv.h:1201
ulint innodb_sampled_pages_read
Definition: srv0srv.h:1203
ulint innodb_buffer_pool_write_requests
srv_buf_pool_write_requests
Definition: srv0srv.h:1157
ulint innodb_data_written
Data bytes written.
Definition: srv0srv.h:1132
ulint innodb_pages_created
buf_pool->stat.n_pages_created
Definition: srv0srv.h:1182
ulint innodb_buffer_pool_read_ahead
srv_read_ahead
Definition: srv0srv.h:1159
ulint innodb_system_rows_read
srv_n_system_rows_read
Definition: srv0srv.h:1199
bool innodb_redo_log_read_only
Is redo log read-only ?
Definition: srv0srv.h:1164
char innodb_buffer_pool_resize_status[512]
Buf pool resize status.
Definition: srv0srv.h:1138
ulint innodb_num_open_files
fil_n_files_open
Definition: srv0srv.h:1205
int64_t innodb_row_lock_time
srv_n_lock_wait_time / 1000
Definition: srv0srv.h:1188
ulint innodb_data_read
Data bytes read.
Definition: srv0srv.h:1130
ulint innodb_data_pending_reads
Pending reads.
Definition: srv0srv.h:1126
ulint innodb_data_fsyncs
Number of fsyncs so far.
Definition: srv0srv.h:1129
ulint innodb_purge_view_trx_id_age
rw_max_trx_no
Definition: srv0srv.h:1217
ulint innodb_buffer_pool_bytes_dirty
File bytes modified.
Definition: srv0srv.h:1147
ulint innodb_buffer_pool_pages_free
Free pages.
Definition: srv0srv.h:1149
char innodb_redo_log_resize_status[512]
Redo log resize status.
Definition: srv0srv.h:1163
ulint innodb_dblwr_pages_written
srv_dblwr_pages_written
Definition: srv0srv.h:1161
ulint innodb_ahi_drop_lookups
number of adaptive hash index lookups when freeing file pages
Definition: srv0srv.h:1219
ulint innodb_buffer_pool_read_ahead_evicted
srv_read_ahead evicted
Definition: srv0srv.h:1160
ulint innodb_dblwr_writes
srv_dblwr_writes
Definition: srv0srv.h:1162
ulint innodb_buffer_pool_read_ahead_rnd
srv_read_ahead_rnd
Definition: srv0srv.h:1158
ulint innodb_data_pending_fsyncs
Pending fsyncs.
Definition: srv0srv.h:1128
ulint innodb_rows_deleted
srv_n_rows_deleted
Definition: srv0srv.h:1198
ulint innodb_data_reads
I/O read requests.
Definition: srv0srv.h:1133
ulint innodb_row_lock_time_avg
srv_n_lock_wait_time / 1000 / srv_n_lock_wait_count
Definition: srv0srv.h:1190
ulint innodb_page_size
UNIV_PAGE_SIZE.
Definition: srv0srv.h:1181
char innodb_buffer_pool_load_status[OS_FILE_MAX_PATH+128]
Buf pool load status.
Definition: srv0srv.h:1137
bool innodb_redo_log_enabled
srv_redo_log
Definition: srv0srv.h:1185
ulint innodb_undo_tablespaces_implicit
number of undo tablespaces innoDB created implicitly.
Definition: srv0srv.h:1209
ulint innodb_rows_inserted
srv_n_rows_inserted
Definition: srv0srv.h:1196
ulint innodb_buffer_pool_reads
srv_buf_pool_reads
Definition: srv0srv.h:1154
ulint innodb_undo_tablespaces_active
number of active undo tablespaces
Definition: srv0srv.h:1213
ulint innodb_data_writes
I/O write requests.
Definition: srv0srv.h:1131
ulint innodb_purge_trx_id_age
rw_max_trx_no - purged trx_no
Definition: srv0srv.h:1216
ulint innodb_buffer_pool_pages_dirty
Dirty data pages.
Definition: srv0srv.h:1146
ulint innodb_log_writes
srv_log_writes
Definition: srv0srv.h:1176
lsn_t innodb_os_log_written
srv_os_log_written
Definition: srv0srv.h:1177
ulonglong innodb_redo_log_capacity_resized
Redo log capacity after the last finished redo resize.
Definition: srv0srv.h:1172
ulonglong innodb_redo_log_current_lsn
Redo log current LSN.
Definition: srv0srv.h:1167
ulint innodb_rows_updated
srv_n_rows_updated
Definition: srv0srv.h:1197
ulint innodb_os_log_fsyncs
log_total_flushes()
Definition: srv0srv.h:1178
uint32_t innodb_buffer_pool_resize_status_progress
Buf pool resize status progess.
Definition: srv0srv.h:1141
ulint innodb_os_log_pending_writes
srv_os_log_pending_writes
Definition: srv0srv.h:1179
ulint innodb_buffer_pool_pages_total
Buffer pool size.
Definition: srv0srv.h:1143
ulint innodb_undo_tablespaces_total
total number of undo tablespaces innoDB is tracking.
Definition: srv0srv.h:1207
ulint innodb_buffer_pool_pages_misc
Miscellaneous pages.
Definition: srv0srv.h:1148
ulint innodb_row_lock_waits
srv_n_lock_wait_count
Definition: srv0srv.h:1186
ulint innodb_buffer_pool_pages_data
Data pages.
Definition: srv0srv.h:1144
ulint innodb_data_pending_writes
Pending writes.
Definition: srv0srv.h:1127
ulint innodb_buffer_pool_wait_free
srv_buf_pool_wait_free
Definition: srv0srv.h:1155
ulonglong innodb_redo_log_checkpoint_lsn
Redo log checkpoint LSN.
Definition: srv0srv.h:1166
ulint innodb_buffer_pool_bytes_data
File bytes used.
Definition: srv0srv.h:1145
uint32_t innodb_buffer_pool_resize_status_code
Buf pool resize status code.
Definition: srv0srv.h:1140
ulint innodb_buffer_pool_read_requests
buf_pool->stat.n_page_gets
Definition: srv0srv.h:1153
ulint innodb_log_write_requests
srv_log_write_requests
Definition: srv0srv.h:1175
ulonglong innodb_redo_log_physical_size
Redo log physical size.
Definition: srv0srv.h:1171
ulonglong innodb_redo_log_flushed_to_disk_lsn
Redo log flushed to disk LSN.
Definition: srv0srv.h:1169
ulint innodb_os_log_pending_fsyncs
log_pending_flushes()
Definition: srv0srv.h:1180
ulint innodb_pages_written
buf_pool->stat.n_pages_written
Definition: srv0srv.h:1184
ulint innodb_row_lock_current_waits
srv_n_lock_wait_current_count
Definition: srv0srv.h:1187
ulint innodb_undo_tablespaces_explicit
number of undo tablespaces the dba created explicitly.
Definition: srv0srv.h:1211
ulint innodb_pages_read
buf_pool->stat.n_pages_read
Definition: srv0srv.h:1183
ulint innodb_log_waits
srv_log_waits
Definition: srv0srv.h:1174
char innodb_buffer_pool_dump_status[OS_FILE_MAX_PATH+128]
Buf pool dump status.
Definition: srv0srv.h:1135
ulint innodb_sampled_pages_skipped
Definition: srv0srv.h:1204
ulint innodb_system_rows_inserted
srv_n_system_rows_inserted
Definition: srv0srv.h:1200
ulint innodb_truncated_status_writes
srv_truncated_status_writes
Definition: srv0srv.h:1206
ulint innodb_row_lock_time_max
srv_n_lock_max_wait_time / 1000
Definition: srv0srv.h:1193
ulint innodb_rows_read
srv_n_rows_read
Definition: srv0srv.h:1195
ulint innodb_system_rows_deleted
srv_n_system_rows_deleted
Definition: srv0srv.h:1202
Mini-transaction handle and buffer.
Definition: mtr0mtr.h:177
Define for performance schema registration key.
Definition: sync0sync.h:51
InnoDB condition variable.
Definition: os0event.cc:63
Definition: que0que.h:242
Thread slot in the thread table.
Definition: srv0srv.h:1227
bool in_use
true if this slot is in use.
Definition: srv0srv.h:1232
bool suspended
true if the thread is waiting for the event of this slot.
Definition: srv0srv.h:1235
std::chrono::steady_clock::duration wait_timeout
Wait time that if exceeded the thread will be timed out.
Definition: srv0srv.h:1253
que_thr_t * thr
Suspended query thread (only used for user threads).
Definition: srv0srv.h:1259
std::chrono::steady_clock::time_point suspend_time
Time when the thread was suspended.
Definition: srv0srv.h:1239
uint64_t reservation_no
Stores the current value of lock_wait_table_reservations, when lock_wait_table_reserve_slot is called...
Definition: srv0srv.h:1249
os_event_t event
Event used in suspending the thread when it has nothing to do.
Definition: srv0srv.h:1256
srv_thread_type type
Thread type: user, utility etc.
Definition: srv0srv.h:1229
Definition: srv0srv.h:71
ulint_ctr_64_t n_rows_inserted
Number of rows inserted.
Definition: srv0srv.h:142
ulint_ctr_64_t n_system_rows_inserted
Number of system rows inserted.
Definition: srv0srv.h:154
ulint_ctr_1_t buf_pool_reads
Number of buffer pool reads that led to the reading of a disk page.
Definition: srv0srv.h:118
ulint_ctr_1_t data_read
Number of data read in total (in bytes)
Definition: srv0srv.h:121
ulint_ctr_1_t log_write_requests
Number of the log write requests done.
Definition: srv0srv.h:82
ulint_ctr_1_t data_written
Count the amount of data written in total (in bytes)
Definition: srv0srv.h:79
ib_counter_t< lint, 1, single_indexer_t > lint_ctr_1_t
Definition: srv0srv.h:75
ulint_ctr_64_t n_rows_deleted
Number of rows deleted.
Definition: srv0srv.h:139
ulint_ctr_1_t dblwr_writes
Count the number of times the doublewrite buffer was flushed.
Definition: srv0srv.h:98
lint_ctr_1_t n_lock_wait_current_count
Number of threads currently waiting on database locks.
Definition: srv0srv.h:130
ulint_ctr_64_t n_system_rows_read
Number of system rows read.
Definition: srv0srv.h:145
ulint_ctr_64_t n_sampled_pages_read
Number of sampled pages read.
Definition: srv0srv.h:157
ulint_ctr_1_t buf_pool_write_requests
Store the number of write requests issued.
Definition: srv0srv.h:105
ulint_ctr_1_t buf_pool_flushed
Count the number of pages that were written from buffer pool to the disk.
Definition: srv0srv.h:114
ulint_ctr_64_t n_rows_read
Number of rows read.
Definition: srv0srv.h:133
ulint_ctr_64_t n_system_rows_deleted
Number of system rows deleted.
Definition: srv0srv.h:151
lint_ctr_1_t os_log_pending_writes
Number of writes being done to the log files.
Definition: srv0srv.h:91
ulint_ctr_1_t buf_pool_wait_free
Store the number of times when we had to wait for a free page in the buffer pool.
Definition: srv0srv.h:110
int64_ctr_1_t n_lock_wait_time
Wait time of database locks.
Definition: srv0srv.h:124
lsn_ctr_1_t os_log_written
Amount of data written to the log files in bytes.
Definition: srv0srv.h:88
ib_counter_t< int64_t, 1, single_indexer_t > int64_ctr_1_t
Definition: srv0srv.h:76
ulint_ctr_64_t n_rows_updated
Number of rows updated.
Definition: srv0srv.h:136
ulint_ctr_64_t n_sampled_pages_skipped
Number of sampled pages skipped.
Definition: srv0srv.h:160
ib_counter_t< ulint, 64 > ulint_ctr_64_t
Definition: srv0srv.h:72
ulint_ctr_1_t n_lock_wait_count
Number of database lock waits.
Definition: srv0srv.h:127
ulint_ctr_1_t dblwr_pages_written
Store the number of pages that have been flushed to the doublewrite buffer.
Definition: srv0srv.h:102
ib_counter_t< ulint, 1, single_indexer_t > ulint_ctr_1_t
Definition: srv0srv.h:74
ulint_ctr_64_t n_system_rows_updated
Number of system rows updated.
Definition: srv0srv.h:148
ib_counter_t< lsn_t, 1, single_indexer_t > lsn_ctr_1_t
Definition: srv0srv.h:73
ulint_ctr_1_t log_waits
We increase this counter, when we don't have enough space in the log buffer and have to flush it.
Definition: srv0srv.h:95
ulint_ctr_1_t log_writes
Number of physical writes to the log performed.
Definition: srv0srv.h:85
double seconds()
Definition: task.cc:310
Transaction system global type definitions.
Version control for database, common definitions, and include files.
unsigned long int ulint
Definition: univ.i:406
Counter utility class.
int n
Definition: xcom_base.cc:509