MySQL 9.4.0
Source Code Documentation
srv0srv.h
Go to the documentation of this file.
1/*****************************************************************************
2
3Copyright (c) 1995, 2025, 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;
301#endif /* INNODB_DD_TABLE */
302
304
305extern const char *srv_main_thread_op_info;
306
307/* The monitor thread waits on this event. */
309
310/* The error monitor thread waits on this event. */
312
313/** The buffer pool dump/load thread waits on this event. */
315
316/** The buffer pool resize thread waits on this event. */
318#endif /* !UNIV_HOTBACKUP */
319
320/** The buffer pool dump/load file name */
321#define SRV_BUF_DUMP_FILENAME_DEFAULT "ib_buffer_pool"
322extern char *srv_buf_dump_filename;
323
324/** Boolean config knobs that tell InnoDB to dump the buffer pool at shutdown
325and/or load it during startup. */
328
329/* Whether to disable file system cache if it is defined */
331
332/** Enable or disable writing of NULLs while extending a tablespace.
333If this is false, then the server will just allocate the space without
334actually initializing it with NULLs. If the variable is true, the
335server will allocate and initialize the space by writing NULLs in it. */
337
338/* If the last data file is auto-extended, we add this many pages to it
339at a time */
340#define SRV_AUTO_EXTEND_INCREMENT (srv_sys_space.get_autoextend_increment())
341
342#ifndef UNIV_HOTBACKUP
343/** Mutex protecting page_zip_stat_per_index */
344extern ib_mutex_t page_zip_stat_per_index_mutex;
345/* Mutex for locking srv_monitor_file. Not created if srv_read_only_mode */
346extern ib_mutex_t srv_monitor_file_mutex;
347/* Temporary file for innodb monitor output */
348extern FILE *srv_monitor_file;
349/* Mutex for locking srv_misc_tmpfile. Only created if !srv_read_only_mode.
350This mutex has a very low rank; threads reserving it should not
351acquire any further latches or sleep before releasing this one. */
352extern ib_mutex_t srv_misc_tmpfile_mutex;
353/* Temporary file for miscellaneous diagnostic output */
354extern FILE *srv_misc_tmpfile;
355#endif /* !UNIV_HOTBACKUP */
356
357/* Server parameters which are read from the initfile */
358
359extern char *srv_data_home;
360
361/* Number of threads used for initializing rollback segments */
362extern uint32_t srv_rseg_init_threads;
363
364/** Number of pages per doublewrite thread/segment */
365extern ulong srv_dblwr_pages;
366
367/** Set if InnoDB must operate in read-only mode. We don't do any
368recovery and open all tables in RO mode instead of RW mode. We don't
369sync the max trx id to disk either. */
370extern bool srv_read_only_mode;
371/** Set if InnoDB operates in read-only mode or innodb-force-recovery
372is greater than SRV_FORCE_NO_TRX_UNDO. */
373extern bool high_level_read_only;
374/** store to its own file each table created by an user; data
375dictionary tables are in the system tablespace 0 */
376extern bool srv_file_per_table;
377/** Sleep delay for threads waiting to enter InnoDB. In micro-seconds. */
378extern ulong srv_thread_sleep_delay;
379/** Maximum sleep delay (in micro-seconds), value of 0 disables it.*/
381
382/** Sort buffer size in index creation */
383extern ulong srv_sort_buf_size;
384
385/** Maximum modification log file size for online index creation */
386extern unsigned long long srv_online_max_size;
387
388/** Number of threads to use for parallel reads. */
389extern ulong srv_parallel_read_threads;
390
391/* If this flag is true, then we will use the native aio of the
392OS (provided we compiled Innobase with it in), otherwise we will
393use simulated aio we build below with threads.
394Currently we support native aio on windows and linux */
395extern bool srv_use_native_aio;
396extern bool srv_numa_interleave;
397
398/* The innodb_directories variable value. This a list of directories
399deliminated by ';', i.e the FIL_PATH_SEPARATOR. */
400extern char *srv_innodb_directories;
401
402/** Server undo tablespaces directory, can be absolute path. */
403extern char *srv_undo_dir;
404
405/** The number of rollback segments per tablespace */
406extern ulong srv_rollback_segments;
407
408/** Maximum size of undo tablespace. */
409extern unsigned long long srv_max_undo_tablespace_size;
410
411/** Rate at which UNDO records should be purged. */
413
414/** Enable or Disable Truncate of UNDO tablespace. */
415extern bool srv_undo_log_truncate;
416
417/** Enable or disable Encrypt of UNDO tablespace. */
418extern bool srv_undo_log_encrypt;
419
420/** Maximum number of recently truncated undo tablespace IDs for
421the same undo number. */
422extern const size_t CONCURRENT_UNDO_TRUNCATE_LIMIT;
423
424extern char *srv_log_group_home_dir;
425
426/** Enable or Disable Encrypt of REDO tablespace. */
427extern bool srv_redo_log_encrypt;
428
429/* Maximum number of redo files of a cloned DB. */
430constexpr size_t SRV_N_LOG_FILES_CLONE_MAX = 1000;
431
432/** Value of innodb_redo_log_capacity. Expressed in bytes. Might be set
433during startup automatically when started in "dedicated server mode". */
435
436/** Assumed value of innodb_redo_log_capacity's - value which is used.
437Expressed in bytes. Might be set during startup automatically when
438started in "dedicated server mode". Might also be set during startup
439when old sysvar (innodb_log_file_size or innodb_log_files_in_group)
440are configured and the new sysvar (innodb_redo_log_capacity) is not. */
442
443#ifdef UNIV_DEBUG_DEDICATED
444extern ulong srv_debug_system_mem_size;
445#endif /* UNIV_DEBUG_DEDICATED */
446
447/** Space for log buffer, expressed in bytes. Note, that log buffer
448will use only the largest power of two, which is not greater than
449the assigned space. */
450extern ulong srv_log_buffer_size;
451
452/** When log writer follows links in the log recent written buffer,
453it stops when it has reached at least that many bytes to write,
454limiting how many bytes can be written in single call. */
455extern ulong srv_log_write_max_size;
456
457/** Size of block, used for writing ahead to avoid read-on-write. */
458extern ulong srv_log_write_ahead_size;
459
460/** Number of events used for notifications about redo write. */
461extern ulong srv_log_write_events;
462
463/** Number of events used for notifications about redo flush. */
464extern ulong srv_log_flush_events;
465
466/** Number of slots in a small buffer, which is used to allow concurrent
467writes to log buffer. The slots are addressed by LSN values modulo number
468of the slots. */
469extern ulong srv_log_recent_written_size;
470
471/** Number of slots in a small link buffer, which is used to break requirement
472for total order of dirty pages, when they are added to flush lists.
473The slots are addressed by LSN values modulo number of the slots. */
475
476/** Whether to activate/pause the log writer threads. */
477extern bool srv_log_writer_threads;
478
479/** Minimum absolute value of cpu time for which spin-delay is used. */
480extern uint srv_log_spin_cpu_abs_lwm;
481
482/** Maximum percentage of cpu time for which spin-delay is used. */
483extern uint srv_log_spin_cpu_pct_hwm;
484
485/** Number of spin iterations, when spinning and waiting for log buffer
486written up to given LSN, before we fallback to loop with sleeps.
487This is not used when user thread has to wait for log flushed to disk. */
489
490/** Timeout used when waiting for redo write. */
491std::chrono::microseconds get_srv_log_wait_for_write_timeout();
492
493/** Number of spin iterations, when spinning and waiting for log flushed. */
495
496/** Maximum value of average log flush time for which spin-delay is used.
497When flushing takes longer, user threads no longer spin when waiting for
498flushed redo. Expressed in microseconds. */
500
501/** Timeout used when waiting for redo flush. */
502std::chrono::microseconds get_srv_log_wait_for_flush_timeout();
503
504/** Number of spin iterations, for which log writer thread is waiting
505for new data to write or flush without sleeping. */
506extern ulong srv_log_writer_spin_delay;
507
508/** Initial timeout used to wait on writer_event. */
509std::chrono::microseconds get_srv_log_writer_timeout();
510
511/** Period every which a periodical checkpoint is written by the log
512checkpointer thread (unless periodical checkpoints are disabled,
513which is a case during initial phase of startup). */
515
516/** Number of spin iterations, for which log flusher thread is waiting
517for new data to flush, without sleeping. */
518extern ulong srv_log_flusher_spin_delay;
519
520/** Initial timeout used to wait on flusher_event. */
521std::chrono::microseconds get_srv_log_flusher_timeout();
522
523/** Number of spin iterations, for which log write notifier thread is waiting
524for advanced writeed_to_disk_lsn without sleeping. */
526
527/** Initial timeout used to wait on write_notifier_event. */
528std::chrono::microseconds get_srv_log_write_notifier_timeout();
529
530/** Number of spin iterations, for which log flush notifier thread is waiting
531for advanced flushed_to_disk_lsn without sleeping. */
533
534/** Initial timeout used to wait on flush_notifier_event. */
535std::chrono::microseconds get_srv_log_flush_notifier_timeout();
536
537/** Whether to generate and require checksums on the redo log pages. */
538extern bool srv_log_checksums;
539
540#ifdef UNIV_DEBUG
541
542/** If true then disable checkpointing. */
543extern bool srv_checkpoint_disabled;
544
545/* Used to inject a failure to find a free rollback segment. */
547
548#endif /* UNIV_DEBUG */
549
550extern ulong srv_flush_log_at_trx_commit;
553extern bool srv_adaptive_flushing;
554extern bool srv_flush_sync;
555
556/* If this flag is true, then we will load the indexes' (and tables') metadata
557even if they are marked as "corrupted". Mostly it is for DBA to process
558corrupted index and table */
559extern bool srv_load_corrupted;
560
561/** Dedicated server setting */
562extern bool srv_dedicated_server;
563/** Requested size in bytes */
565/** Minimum pool size in bytes */
566extern const ulint srv_buf_pool_min_size;
567/** Default pool size in bytes */
568extern const ulint srv_buf_pool_def_size;
569/** Maximum pool size in bytes */
571/** Requested buffer pool chunk size. Each buffer pool instance consists
572of one or more chunks. */
574/** Minimum buffer pool chunk size. */
576/** The buffer pool chunk size must be a multiple of this number. */
578/** Maximum buffer pool chunk size. */
580
581/** Requested number of buffer pool instances */
582extern ulong srv_buf_pool_instances;
583/** Default number of buffer pool instances */
584extern const ulong srv_buf_pool_instances_default;
585/** Number of locks to protect buf_pool->page_hash */
586extern ulong srv_n_page_hash_locks;
587/** Whether to validate InnoDB tablespace paths on startup */
589/** Use fdatasync() instead of fsync(). */
590extern bool srv_use_fdatasync;
591/** Scan depth for LRU flush batch i.e.: number of blocks scanned*/
592extern ulong srv_LRU_scan_depth;
593/** Whether or not to flush neighbors of a block */
594extern ulong srv_flush_neighbors;
595/** Previously requested size. Accesses protected by memory barriers. */
597/** Current size as scaling factor for the other components */
599/** Current size in bytes */
600extern long long srv_buf_pool_curr_size;
601/** Dump this % of each buffer pool during BP dump */
602extern ulong srv_buf_pool_dump_pct;
603/** Lock table size in bytes */
605
606extern bool srv_random_read_ahead;
607extern ulong srv_read_ahead_threshold;
608extern ulong srv_n_read_io_threads;
609extern ulong srv_n_write_io_threads;
610
612
613/** Default value of srv_idle_flush_pct */
614extern const ulong srv_idle_flush_pct_default;
615/** How much flush to be done in case of server is idle */
616extern ulong srv_idle_flush_pct;
617
618/* Number of IO operations per second the server can do */
619extern ulong srv_io_capacity;
620
621/* We use this dummy default value at startup for max_io_capacity.
622The real value is set based on the value of io_capacity. */
625extern ulong srv_max_io_capacity;
626/* Returns the number of IO operations that is X percent of the
627capacity. PCT_IO(5) -> returns the number of IO operations that
628is 5% of the max where max is srv_io_capacity. */
629static inline ulong PCT_IO(ulong p) {
630 return (ulong)(srv_io_capacity * ((double)(p) / 100.0));
631}
632
633/** Maximum number of purge threads, including the purge coordinator */
634constexpr uint32_t MAX_PURGE_THREADS = 32;
635
636/* The "innodb_stats_method" setting, decides how InnoDB is going
637to treat NULL value when collecting statistics. It is not defined
638as enum type because the configure option takes unsigned integer type. */
639extern ulong srv_innodb_stats_method;
640
641/** Returns current value of the "innodb_open_files" configuration variable. */
643/** Sets new value of the "innodb_open_files" configuration variable to present
644to users.
645@param[in] new_limit new limit to be set. */
646void innobase_set_open_files_limit(long new_limit);
647
649extern uint srv_flush_log_at_timeout;
650extern bool srv_btr_search_enabled;
651extern ulong srv_replication_delay;
652
655extern ulong srv_log_writer_timeout;
656extern ulong srv_log_checkpoint_every;
657extern ulong srv_log_flusher_timeout;
660
661extern uint buf_LRU_old_threshold;
662
663extern ulong srv_n_page_cleaners;
664
665extern double srv_max_dirty_pages_pct;
666extern double srv_max_dirty_pages_pct_lwm;
667
668extern ulong srv_adaptive_flushing_lwm;
669extern ulong srv_flushing_avg_loops;
670
671extern ulong srv_force_recovery;
672#ifdef UNIV_DEBUG
673extern ulong srv_force_recovery_crash;
674#endif /* UNIV_DEBUG */
675
676/** The value of the configuration parameter innodb_fast_shutdown,
677controlling the InnoDB shutdown.
678
679If innodb_fast_shutdown=0, InnoDB shutdown will purge all undo log
680records (except XA PREPARE transactions) and complete the merge of the
681entire change buffer, and then shut down the redo log.
682
683If innodb_fast_shutdown=1, InnoDB shutdown will only flush the buffer
684pool to data files, cleanly shutting down the redo log.
685
686If innodb_fast_shutdown=2, shutdown will effectively 'crash' InnoDB
687(but lose no committed transactions). */
688extern ulong srv_fast_shutdown;
689extern bool srv_innodb_status;
690
691extern unsigned long long srv_stats_transient_sample_pages;
692extern bool srv_stats_persistent;
693extern unsigned long long srv_stats_persistent_sample_pages;
694extern bool srv_stats_auto_recalc;
696
697extern ulong srv_checksum_algorithm;
698
700extern ulong srv_max_purge_lag;
701extern ulong srv_max_purge_lag_delay;
702
704/*-------------------------------------------*/
705
706extern bool srv_print_innodb_monitor;
707/** In contrast to srv_print_innodb_monitor which is controlled by the user,
708this variable is controlled by InnoDB itself: if some module of InnoDB decides
709it would be good to print the monitoring information it increments this value,
710and decrements it when it no longer needs it. */
711extern std::atomic_uint32_t srv_innodb_needs_monitoring;
713
714extern ulong srv_n_spin_wait_rounds;
715extern ulong srv_n_free_tickets_to_enter;
716extern ulong srv_spin_wait_delay;
717extern bool srv_priority_boost;
718
720
721#if defined UNIV_DEBUG || defined UNIV_IBUF_DEBUG
723#endif /* UNIV_DEBUG || UNIV_IBUF_DEBUG */
724
725#ifdef UNIV_DEBUG
726extern bool srv_buf_pool_debug;
727extern bool srv_sync_debug;
729
730/** Value of MySQL global used to disable master thread. */
732#endif /* UNIV_DEBUG */
733
735extern std::atomic<int> srv_fatal_semaphore_wait_extend;
736
738
739#ifdef UNIV_HOTBACKUP
740// MAHI: changed from 130 to 1 assuming the apply-log is single threaded
741constexpr uint32_t SRV_MAX_N_IO_THREADS = 1;
742#else /* UNIV_HOTBACKUP */
743constexpr uint32_t SRV_MAX_N_IO_THREADS = 130;
744#endif /* UNIV_HOTBACKUP */
745
746/* Array of English strings describing the current state of an
747i/o handler thread */
748extern const char *srv_io_thread_op_info[];
749extern const char *srv_io_thread_function[];
750
751/* the number of purge threads to use from the worker pool (currently 0 or 1) */
752extern ulong srv_n_purge_threads;
753
754/* the number of pages to purge in one batch */
755extern ulong srv_purge_batch_size;
756
757/* the number of sync wait arrays */
758extern ulong srv_sync_array_size;
759
760/* print all user-level transactions deadlocks to mysqld stderr */
761extern bool srv_print_all_deadlocks;
762
763/** Print all DDL logs to mysqld stderr */
764extern bool srv_print_ddl_logs;
765
766extern bool srv_cmp_per_index_enabled;
767
768extern bool srv_redo_log;
769
770/** Status variables to be passed to MySQL */
771extern struct export_var_t export_vars;
772
773#ifndef UNIV_HOTBACKUP
774/** Global counters */
776
777/* Keys to register InnoDB threads with performance schema */
778
779#ifdef UNIV_PFS_THREAD
815#endif /* UNIV_PFS_THREAD */
816#endif /* !UNIV_HOTBACKUP */
817
818#ifdef HAVE_PSI_STAGE_INTERFACE
819/** Performance schema stage event for monitoring ALTER TABLE progress
820everything after flush log_make_latest_checkpoint(). */
822
823/** Performance schema stage event for monitoring ALTER TABLE progress
824log_make_latest_checkpoint(). */
826
827/** Performance schema stage event for monitoring ALTER TABLE progress
828row_merge_insert_index_tuples(). */
830
831/** Performance schema stage event for monitoring ALTER TABLE progress
832row_log_apply(). */
834
835/** Performance schema stage event for monitoring ALTER TABLE progress
836row_log_table_apply(). */
838
839/** Performance schema stage event for monitoring ALTER TABLE progress
840row_merge_sort(). */
842
843/** Performance schema stage event for monitoring ALTER TABLE progress
844row_merge_read_clustered_index(). */
846
847/** Performance schema stage event for monitoring ALTER TABLESPACE
848ENCRYPTION progress. */
850
851/** Performance schema stage event for monitoring buffer pool load progress. */
853#endif /* HAVE_PSI_STAGE_INTERFACE */
854
855/** Performance schema stage event for monitoring clone file copy progress. */
857
858/** Performance schema stage event for monitoring clone redo copy progress. */
860
861/** Performance schema stage event for monitoring clone page copy progress. */
863
864#ifndef _WIN32
865/** Alternatives for the file flush option in Unix.
866@see innodb_flush_method_names */
868 /** fsync, the default if O_DIRECT is not supported */
870 /** open log files in O_SYNC mode */
872 /** do not call os_file_flush() when writing data files, but do flush after
873 writing to log files */
875 /** do not flush after writing */
877 /** invoke os_file_set_nocache() on data files. This implies using
878 non-buffered IO but still using fsync, the reason for which is that some FS
879 do not flush meta-data when unbuffered IO happens. Default if supported */
881 /** do not use fsync() when using direct IO i.e.: it can be set to avoid the
882 fsync() call that we make when using SRV_UNIX_O_DIRECT. However, in this
883 case user/DBA should be sure about the integrity of the meta-data */
887
888inline bool srv_is_direct_io() {
891}
892
893#else
894/** Alternatives for file i/o in Windows. @see innodb_flush_method_names. */
895enum srv_win_flush_t {
896 /** unbuffered I/O; this is the default */
897 SRV_WIN_IO_UNBUFFERED = 0,
898 /** buffered I/O */
899 SRV_WIN_IO_NORMAL,
900};
901extern enum srv_win_flush_t srv_win_file_flush_method;
902
903inline bool srv_is_direct_io() {
904 return (srv_win_file_flush_method == SRV_WIN_IO_UNBUFFERED);
905}
906
907#endif /* _WIN32 */
908
909/** Alternatives for srv_force_recovery. Non-zero values are intended
910to help the user get a damaged database up so that he can dump intact
911tables and rows with SELECT INTO OUTFILE. The database must not otherwise
912be used with these options! A bigger number below means that all precautions
913of lower numbers are included. */
914enum {
915 SRV_FORCE_IGNORE_CORRUPT = 1, /*!< let the server run even if it
916 detects a corrupt page */
917 SRV_FORCE_NO_BACKGROUND = 2, /*!< prevent the main thread from
918 running: if a crash would occur
919 in purge, this prevents it */
920 SRV_FORCE_NO_TRX_UNDO = 3, /*!< do not run trx rollback after
921 recovery */
922 SRV_FORCE_NO_IBUF_MERGE = 4, /*!< prevent also ibuf operations:
923 if they would cause a crash, better
924 not do them */
925 SRV_FORCE_NO_UNDO_LOG_SCAN = 5, /*!< do not look at undo logs when
926 starting the database: InnoDB will
927 treat even incomplete transactions
928 as committed */
929 SRV_FORCE_NO_LOG_REDO = 6 /*!< do not do the log roll-forward
930 in connection with recovery */
932
933/* Alternatives for srv_innodb_stats_method, which could be changed by
934setting innodb_stats_method */
936 SRV_STATS_NULLS_EQUAL, /* All NULL values are treated as
937 equal. This is the default setting
938 for innodb_stats_method */
939 SRV_STATS_NULLS_UNEQUAL, /* All NULL values are treated as
940 NOT equal. */
941 SRV_STATS_NULLS_IGNORED /* NULL values are ignored */
943
945
946#ifdef UNIV_DEBUG
947/** Force all user tables to use page compression. */
948extern ulong srv_debug_compress;
949#endif /* UNIV_DEBUG */
950
951/** Types of threads existing in the system. */
953 SRV_NONE, /*!< None */
954 SRV_WORKER, /*!< threads serving parallelized
955 queries and queries released from
956 lock wait */
957 SRV_PURGE, /*!< Purge coordinator thread */
958 SRV_MASTER /*!< the master thread, (whose type
959 number must be biggest) */
961
962/** Boots Innobase server. */
963void srv_boot(void);
964/** Frees the data structures created in srv_init(). */
965void srv_free(void);
966
967/** Sets the info describing an i/o thread current state.
968@param[in] i The 'segment' of the i/o thread
969@param[in] str Constant char string describing the state */
970void srv_set_io_thread_op_info(ulint i, const char *str);
971
972/** Resets the info describing an i/o thread current state. */
974/** Tells the purge thread that there has been activity in the database
975 and wakes up the purge thread if it is suspended (not sleeping). Note
976 that there is a small chance that the purge thread stays suspended
977 (we do not protect our operation with the srv_sys_t:mutex, for
978 performance reasons). */
980/** Tells the Innobase server that there has been activity in the database
981 and wakes up the master thread if it is suspended (not sleeping). Used
982 in the MySQL interface. Note that there is a small chance that the master
983 thread stays suspended (we do not protect our operation with the kernel
984 mutex, for performance reasons). */
986static inline void srv_active_wake_master_thread() {
987 if (!srv_read_only_mode) {
989 }
990}
991/** Wakes up the master thread if it is suspended or being suspended. */
992void srv_wake_master_thread(void);
993#ifndef UNIV_HOTBACKUP
994/** Outputs to a file the output of the InnoDB Monitor.
995@param[in] file output stream
996@param[in] nowait whether to wait for the exclusive global lock_sys latch
997@param[out] trx_start file position of the start of the list of active
998 transactions
999@param[out] trx_end file position of the end of the list of active
1000 transactions
1001@return false if not all information printed due to failure to obtain necessary
1002 mutex */
1003bool srv_printf_innodb_monitor(FILE *file, bool nowait, ulint *trx_start,
1004 ulint *trx_end);
1005
1006/** Function to pass InnoDB status variables to MySQL */
1007void srv_export_innodb_status(void);
1008/** Get current server activity count. We don't hold srv_sys::mutex while
1009 reading this value as it is only used in heuristics.
1010 @return activity count. */
1012/** Check if there has been any activity.
1013 @return false if no change in activity counter. */
1014bool srv_check_activity(ulint old_activity_count); /*!< old activity count */
1015/** Increment the server activity counter. */
1016void srv_inc_activity_count(void);
1017
1018/** Enqueues a task to server task queue and releases a worker thread, if there
1019is a suspended one. */
1020void srv_que_task_enqueue_low(que_thr_t *thr); /*!< in: query thread */
1021
1022/** A thread which prints the info output by various InnoDB monitors. */
1023void srv_monitor_thread();
1024
1025/** A thread which prints warnings about semaphore waits which have lasted
1026too long. These can be used to track bugs which cause hangs. */
1028
1029/** The master thread controlling the server. */
1030void srv_master_thread();
1031
1032/** Purge coordinator thread that schedules the purge tasks. */
1034
1035/** Worker thread that reads tasks from the work queue and executes them. */
1036void srv_worker_thread();
1037
1038/** Set encryption for UNDO tablespace with given space id.
1039@param[in] space_id Undo tablespace id
1040@param[in] mtr Mini-transaction
1041@return false for success, true otherwise */
1043
1044/** Enable UNDO tablespaces encryption.
1045@return false for success, true otherwise. */
1047
1048/** Enable REDO log encryption.
1049@return false for success, true otherwise. */
1051
1052/** Get count of tasks in the queue.
1053 @return number of tasks in queue */
1055
1056/** Releases threads of the type given from suspension in the thread table.
1057 NOTE! The server mutex has to be reserved by the caller!
1058 @return number of threads released: this may be less than n if not
1059 enough threads were suspended at the moment */
1060ulint srv_release_threads(enum srv_thread_type type, /*!< in: thread type */
1061 ulint n); /*!< in: number of threads to release */
1062
1063/** Check whether the master thread is active.
1064This is polled during the final phase of shutdown.
1065The first phase of server shutdown must have already been executed
1066(or the server must not have been fully started up).
1067@see srv_pre_dd_shutdown()
1068@retval true if any thread is active
1069@retval false if no thread is active */
1071
1072/** Wakeup the purge threads. */
1073void srv_purge_wakeup(void);
1074
1075/** Check if the purge threads are active, both coordinator and worker threads
1076@return true if any thread is active, false if no thread is active */
1078
1079/** Create an undo tablespace with an explicit file name
1080This is called during CREATE UNDO TABLESPACE.
1081@param[in] space_name tablespace name
1082@param[in] file_name file name
1083@param[in] space_id Tablespace ID
1084@return DB_SUCCESS or error code */
1085dberr_t srv_undo_tablespace_create(const char *space_name,
1086 const char *file_name, space_id_t space_id);
1087
1088/** Initialize undo::spaces,
1089called once during srv_start(). */
1090void undo_spaces_init();
1091
1092/** Free the resources occupied by undo::spaces,
1093called once during thread de-initialization. */
1094void undo_spaces_deinit();
1095
1096/** Set redo log variable for performance schema global status.
1097@param[in] enable true => redo log enabled, false => redo log disabled */
1098void set_srv_redo_log(bool enable);
1099
1100#ifdef UNIV_DEBUG
1101struct SYS_VAR;
1102
1103/** Disables master thread. It's used by:
1104 SET GLOBAL innodb_master_thread_disabled_debug = 1 (0).
1105@param[in] thd thread handle
1106@param[in] var pointer to system variable
1107@param[out] var_ptr where the formal string goes
1108@param[in] save immediate result from check function */
1110 void *var_ptr, const void *save);
1111#endif /* UNIV_DEBUG */
1112#endif /* !UNIV_HOTBACKUP */
1113
1114/** Status variables to be passed to MySQL */
1116 ulint innodb_data_pending_reads; /*!< Pending reads */
1117 ulint innodb_data_pending_writes; /*!< Pending writes */
1118 ulint innodb_data_pending_fsyncs; /*!< Pending fsyncs */
1119 ulint innodb_data_fsyncs; /*!< Number of fsyncs so far */
1120 ulint innodb_data_read; /*!< Data bytes read */
1121 ulint innodb_data_writes; /*!< I/O write requests */
1122 ulint innodb_data_written; /*!< Data bytes written */
1123 ulint innodb_data_reads; /*!< I/O read requests */
1125 128]; /*!< Buf pool dump status */
1127 128]; /*!< Buf pool load status */
1128 char innodb_buffer_pool_resize_status[512]; /*!< Buf pool resize status */
1129 uint32_t
1130 innodb_buffer_pool_resize_status_code; /*!< Buf pool resize status code */
1131 uint32_t innodb_buffer_pool_resize_status_progress; /*!< Buf pool resize
1132 status progess */
1133 ulint innodb_buffer_pool_pages_total; /*!< Buffer pool size */
1135 ulint innodb_buffer_pool_bytes_data; /*!< File bytes used */
1136 ulint innodb_buffer_pool_pages_dirty; /*!< Dirty data pages */
1137 ulint innodb_buffer_pool_bytes_dirty; /*!< File bytes modified */
1138 ulint innodb_buffer_pool_pages_misc; /*!< Miscellaneous pages */
1140#ifdef UNIV_DEBUG
1142#endif /* UNIV_DEBUG */
1143 ulint innodb_buffer_pool_read_requests; /*!< buf_pool->stat.n_page_gets */
1144 ulint innodb_buffer_pool_reads; /*!< srv_buf_pool_reads */
1145 ulint innodb_buffer_pool_wait_free; /*!< srv_buf_pool_wait_free */
1146 ulint innodb_buffer_pool_pages_flushed; /*!< srv_buf_pool_flushed */
1147 ulint innodb_buffer_pool_write_requests; /*!< srv_buf_pool_write_requests */
1148 ulint innodb_buffer_pool_read_ahead_rnd; /*!< srv_read_ahead_rnd */
1149 ulint innodb_buffer_pool_read_ahead; /*!< srv_read_ahead */
1150 ulint innodb_buffer_pool_read_ahead_evicted; /*!< srv_read_ahead evicted*/
1151 ulint innodb_dblwr_pages_written; /*!< srv_dblwr_pages_written */
1152 ulint innodb_dblwr_writes; /*!< srv_dblwr_writes */
1153 char innodb_redo_log_resize_status[512]; /*!< Redo log resize status */
1154 bool innodb_redo_log_read_only; /*!< Is redo log read-only ? */
1155 ulonglong innodb_redo_log_uuid; /*!< Redo log UUID */
1156 ulonglong innodb_redo_log_checkpoint_lsn; /*!< Redo log checkpoint LSN */
1157 ulonglong innodb_redo_log_current_lsn; /*!< Redo log current LSN */
1158 ulonglong
1159 innodb_redo_log_flushed_to_disk_lsn; /*!< Redo log flushed to disk LSN */
1160 ulonglong innodb_redo_log_logical_size; /*!< Redo log logical size */
1161 ulonglong innodb_redo_log_physical_size; /*!< Redo log physical size */
1162 ulonglong innodb_redo_log_capacity_resized; /*!< Redo log capacity after
1163 the last finished redo resize */
1164 ulint innodb_log_waits; /*!< srv_log_waits */
1165 ulint innodb_log_write_requests; /*!< srv_log_write_requests */
1166 ulint innodb_log_writes; /*!< srv_log_writes */
1167 lsn_t innodb_os_log_written; /*!< srv_os_log_written */
1168 ulint innodb_os_log_fsyncs; /*!< log_total_flushes() */
1169 ulint innodb_os_log_pending_writes; /*!< srv_os_log_pending_writes */
1170 ulint innodb_os_log_pending_fsyncs; /*!< log_pending_flushes() */
1171 ulint innodb_page_size; /*!< UNIV_PAGE_SIZE */
1172 ulint innodb_pages_created; /*!< buf_pool->stat.n_pages_created */
1173 ulint innodb_pages_read; /*!< buf_pool->stat.n_pages_read */
1174 ulint innodb_pages_written; /*!< buf_pool->stat.n_pages_written */
1175 bool innodb_redo_log_enabled; /*!< srv_redo_log */
1176 ulint innodb_row_lock_waits; /*!< srv_n_lock_wait_count */
1177 ulint innodb_row_lock_current_waits; /*!< srv_n_lock_wait_current_count */
1178 int64_t innodb_row_lock_time; /*!< srv_n_lock_wait_time
1179 / 1000 */
1180 ulint innodb_row_lock_time_avg; /*!< srv_n_lock_wait_time
1181 / 1000
1182 / srv_n_lock_wait_count */
1183 ulint innodb_row_lock_time_max; /*!< srv_n_lock_max_wait_time
1184 / 1000 */
1185 ulint innodb_rows_read; /*!< srv_n_rows_read */
1186 ulint innodb_rows_inserted; /*!< srv_n_rows_inserted */
1187 ulint innodb_rows_updated; /*!< srv_n_rows_updated */
1188 ulint innodb_rows_deleted; /*!< srv_n_rows_deleted */
1189 ulint innodb_system_rows_read; /*!< srv_n_system_rows_read */
1190 ulint innodb_system_rows_inserted; /*!< srv_n_system_rows_inserted */
1191 ulint innodb_system_rows_updated; /*!< srv_n_system_rows_updated */
1192 ulint innodb_system_rows_deleted; /*!< srv_n_system_rows_deleted*/
1195 ulint innodb_num_open_files; /*!< fil_n_files_open */
1196 ulint innodb_truncated_status_writes; /*!< srv_truncated_status_writes */
1197 ulint innodb_undo_tablespaces_total; /*!< total number of undo tablespaces
1198 innoDB is tracking. */
1199 ulint innodb_undo_tablespaces_implicit; /*!< number of undo tablespaces
1200 innoDB created implicitly. */
1201 ulint innodb_undo_tablespaces_explicit; /*!< number of undo tablespaces
1202 the dba created explicitly. */
1203 ulint innodb_undo_tablespaces_active; /*!< number of active undo
1204 tablespaces */
1205#ifdef UNIV_DEBUG
1206 ulint innodb_purge_trx_id_age; /*!< rw_max_trx_no - purged trx_no */
1208 - purged view's min trx_no */
1209 ulint innodb_ahi_drop_lookups; /*!< number of adaptive hash
1210 index lookups when freeing
1211 file pages */
1212#endif /* UNIV_DEBUG */
1213};
1214
1215#ifndef UNIV_HOTBACKUP
1216/** Thread slot in the thread table. */
1218 /** Thread type: user, utility etc. */
1220
1221 /** true if this slot is in use. */
1223
1224 /** true if the thread is waiting for the event of this slot. */
1226
1227 /** Time when the thread was suspended. Initialized by
1228 lock_wait_table_reserve_slot() for lock wait. */
1229 std::chrono::steady_clock::time_point suspend_time;
1230
1231 /** Stores the current value of lock_wait_table_reservations, when
1232 lock_wait_table_reserve_slot is called.
1233 This can be used as a version number to avoid ABA problems.
1234 The difference lock_wait_table_reservations - reservation_no tells us how many
1235 other threads got suspended while our thr was sleeping.
1236 This can be used to determine if the wait was unfairly long, and it is time to
1237 boost trx->lock.schedule_weight.
1238 Protected by lock->wait_mutex. */
1240
1241 /** Wait time that if exceeded the thread will be timed out.
1242 Initialized by lock_wait_table_reserve_slot() for lock wait. */
1243 std::chrono::steady_clock::duration wait_timeout;
1244
1245 /** Event used in suspending the thread when it has nothing to do. */
1247
1248 /** Suspended query thread (only used for user threads). */
1250};
1251#endif /* !UNIV_HOTBACKUP */
1252
1253#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:419
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:1227
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:1084
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
std::chrono::seconds seconds
Definition: authorize_manager.cc:68
std::chrono::milliseconds milliseconds
Definition: authorize_manager.cc:67
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:651
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:209
PSI_stage_info srv_stage_alter_tablespace_encryption
Performance schema stage event for monitoring ALTER TABLESPACE ENCRYPTION progress.
Definition: srv0srv.cc:836
ib_mutex_t srv_monitor_file_mutex
Definition: srv0srv.cc:622
FILE * srv_monitor_file
Temporary file for innodb monitor output.
Definition: srv0srv.cc:625
ulint srv_buf_pool_size
Requested size in bytes.
Definition: srv0srv.cc:417
constexpr uint32_t SRV_MAX_IO_CAPACITY_DUMMY_DEFAULT
Definition: srv0srv.h:623
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:455
bool srv_downgrade_logs
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:2501
ulong srv_log_wait_for_flush_timeout
Timeout used when waiting for redo flush (microseconds).
Definition: srv0srv.cc:310
bool srv_numa_interleave
Definition: srv0srv.cc:219
void set_srv_redo_log(bool enable)
Set redo log variable for performance schema global status.
Definition: srv0srv.cc:3230
bool srv_thread_is_active(const IB_thread &thread)
Check if given thread is still active.
Definition: srv0srv.cc:3216
mysql_pfs_key_t log_flush_notifier_thread_key
srv_thread_type
Types of threads existing in the system.
Definition: srv0srv.h:952
@ SRV_WORKER
threads serving parallelized queries and queries released from lock wait
Definition: srv0srv.h:954
@ SRV_MASTER
the master thread, (whose type number must be biggest)
Definition: srv0srv.h:958
@ SRV_NONE
None.
Definition: srv0srv.h:953
@ SRV_PURGE
Purge coordinator thread.
Definition: srv0srv.h:957
mysql_pfs_key_t srv_lock_timeout_thread_key
ulong srv_n_write_io_threads
Definition: srv0srv.cc:465
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:1953
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:350
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:789
ulong srv_buf_flush_list_added_size
Number of slots in a small link buffer, which is used to break requirement for total order of dirty p...
Definition: srv0srv.cc:289
constexpr uint32_t SRV_MAX_IO_CAPACITY_LIMIT
Definition: srv0srv.h:624
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:821
const ulonglong srv_buf_pool_chunk_unit_min
Minimum buffer pool chunk size.
Definition: srv0srv.cc:428
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
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:363
ulong srv_fast_shutdown
The value of the configuration parameter innodb_fast_shutdown, controlling the InnoDB shutdown.
Definition: srv0srv.cc:561
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:294
ib_mutex_t page_zip_stat_per_index_mutex
Mutex protecting page_zip_stat_per_index.
Definition: srv0srv.cc:619
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:806
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:187
ulong srv_log_write_ahead_size
Size of block, used for writing ahead to avoid read-on-write.
Definition: srv0srv.h:551
bool srv_print_ddl_logs
Print all DDL logs to mysqld stderr.
Definition: srv0srv.cc:541
uint srv_change_buffer_max_size
Maximum on-disk size of change buffer in terms of percentage of the buffer pool.
Definition: srv0srv.cc:476
bool srv_use_fdatasync
Use fdatasync() instead of fsync().
Definition: srv0srv.cc:443
void srv_purge_wakeup(void)
Wakeup the purge threads.
Definition: srv0srv.cc:3178
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:801
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:534
const ulint srv_buf_pool_def_size
Default pool size in bytes.
Definition: srv0srv.cc:421
void undo_spaces_deinit()
Free the resources occupied by undo::spaces, called once during thread de-initialization.
Definition: srv0start.cc:945
char * srv_log_group_home_dir
Definition: srv0srv.cc:235
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:389
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:261
bool srv_stats_auto_recalc
Definition: srv0srv.cc:576
constexpr uint32_t MAX_PURGE_THREADS
Maximum number of purge threads, including the purge coordinator.
Definition: srv0srv.h:634
ulong srv_max_io_capacity
Definition: srv0srv.cc:486
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:339
bool srv_purge_threads_active()
Check if the purge threads are active, both coordinator and worker threads.
Definition: srv0srv.cc:3195
const ulonglong srv_buf_pool_chunk_unit_blk_sz
The buffer pool chunk size must be a multiple of this number.
Definition: srv0srv.cc:430
void srv_worker_thread()
Worker thread that reads tasks from the work queue and executes them.
Definition: srv0srv.cc:2796
void srv_export_innodb_status(void)
Function to pass InnoDB status variables to MySQL.
Definition: srv0srv.cc:1562
ulong srv_spin_wait_delay
Definition: ut0mutex.h:107
std::chrono::milliseconds get_srv_replication_delay()
Definition: srv0srv.cc:579
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:603
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:201
const char * srv_main_thread_op_info
Definition: srv0srv.cc:134
const ulint srv_buf_pool_min_size
Minimum pool size in bytes.
Definition: srv0srv.cc:419
double srv_max_dirty_pages_pct_lwm
Definition: srv0srv.cc:497
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:249
void srv_inc_activity_count(void)
Increment the server activity counter.
Definition: srv0srv.cc:1899
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:284
constexpr uint32_t SRV_MAX_N_IO_THREADS
Definition: srv0srv.h:743
double srv_max_buf_pool_modified_pct
Definition: srv0srv.cc:496
ulong srv_flush_log_at_trx_commit
Definition: srv0srv.cc:387
FILE * srv_misc_tmpfile
Temporary file for miscellaneous diagnostic output.
Definition: srv0srv.cc:631
void srv_purge_coordinator_thread()
Purge coordinator thread that schedules the purge tasks.
Definition: srv0srv.cc:3039
bool srv_adaptive_flushing
Definition: srv0srv.cc:399
bool srv_enable_redo_encryption()
Enable REDO log encryption.
Definition: srv0srv.cc:2467
bool srv_cmp_per_index_enabled
Enable INFORMATION_SCHEMA.innodb_cmp_per_index.
Definition: srv0srv.cc:544
bool srv_downgrade_partition_files
Definition: srv0srv.cc:120
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:872
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:870
enum srv_unix_flush_t srv_unix_file_flush_method
Definition: srv0srv.cc:479
ulong srv_LRU_scan_depth
Scan depth for LRU flush batch i.e.
Definition: srv0srv.cc:445
void srv_free(void)
Frees the data structures created in srv_init().
Definition: srv0srv.cc:1206
ulong srv_log_write_events
Number of events used for notifications about redo write.
Definition: srv0srv.cc:276
ulint srv_buf_pool_base_size
Current size as scaling factor for the other components.
Definition: srv0srv.cc:451
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:2682
ulong srv_log_writer_timeout
Initial timeout used to wait on writer_event.
Definition: srv0srv.cc:322
static ulong PCT_IO(ulong p)
Definition: srv0srv.h:629
mysql_pfs_key_t clone_gtid_thread_key
unsigned long long srv_stats_persistent_sample_pages
Definition: srv0srv.cc:575
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:432
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:1917
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:460
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:217
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:447
bool tbsp_extend_and_initialize
Enable or disable writing of NULLs while extending a tablespace.
Definition: srv0srv.cc:517
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:3157
bool srv_buf_pool_debug
This is used to enable multiple buffer pool instances with small buffer pool size.
Definition: buf0buf.cc:343
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:1338
ulong srv_log_wait_for_write_timeout
Timeout used when waiting for redo write (microseconds).
Definition: srv0srv.cc:298
bool srv_log_writer_threads
Whether to activate/pause the log writer threads.
Definition: srv0srv.cc:255
char * srv_buf_dump_filename
The buffer pool dump/load file name.
Definition: srv0srv.cc:785
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:319
std::atomic< int > srv_fatal_semaphore_wait_extend
Definition: srv0srv.cc:124
void undo_spaces_init()
Initialize undo::spaces, called once during srv_start().
Definition: srv0start.cc:936
bool srv_redo_log
If innodb redo logging is enabled.
Definition: srv0srv.cc:547
ulint srv_dml_needed_delay
Definition: srv0srv.cc:132
bool srv_priority_boost
Definition: srv0srv.cc:586
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:1963
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:524
uint32_t srv_rseg_init_threads
Number of threads spawned for initializing rollback segments in parallel.
Definition: srv0srv.cc:152
char * srv_undo_dir
Server undo tablespaces directory, can be absolute path.
Definition: srv0srv.cc:156
ulint srv_truncated_status_writes
Definition: srv0srv.cc:600
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:333
bool srv_undo_log_encrypt
Enable or disable Encrypt of UNDO tablespace.
Definition: srv0srv.cc:184
const char * srv_io_thread_function[]
Definition: srv0srv.cc:610
std::chrono::microseconds get_srv_log_wait_for_flush_timeout()
Timeout used when waiting for redo flush.
Definition: srv0srv.cc:313
ulint srv_lock_table_size
Lock table size in bytes.
Definition: srv0srv.cc:457
bool srv_validate_tablespace_paths
Whether to validate InnoDB tablespace paths on startup.
Definition: srv0srv.cc:441
bool srv_check_activity(ulint old_activity_count)
Check if there has been any activity.
Definition: srv0srv.cc:1980
std::chrono::microseconds get_srv_log_write_notifier_timeout()
Initial timeout used to wait on write_notifier_event.
Definition: srv0srv.cc:357
ulint srv_get_activity_count(void)
Get current server activity count.
Definition: srv0srv.cc:1974
ulonglong srv_buf_pool_chunk_unit
Requested buffer pool chunk size.
Definition: srv0srv.cc:426
ulong srv_log_wait_for_flush_spin_delay
Number of spin iterations, when spinning and waiting for log flushed.
Definition: srv0srv.cc:306
char * srv_innodb_directories
The innodb_directories variable value.
Definition: srv0srv.cc:148
ulong srv_innodb_stats_method
Definition: srv0srv.cc:515
bool srv_master_thread_disabled_debug
Value of MySQL global used to disable master thread.
Definition: srv0srv.cc:227
ulong srv_debug_compress
Force all user tables to use page compression.
Definition: srv0srv.cc:223
void srv_boot(void)
Boots Innobase server.
Definition: srv0srv.cc:1277
PSI_stage_info srv_stage_clone_file_copy
Performance schema stage event for monitoring clone file copy progress.
Definition: srv0srv.cc:846
const ulong srv_idle_flush_pct_default
Default value of srv_idle_flush_pct.
Definition: srv0srv.cc:459
bool srv_print_innodb_monitor
Definition: srv0srv.cc:602
ulong srv_buf_pool_instances
Requested number of buffer pool instances.
Definition: srv0srv.cc:435
mysql_pfs_key_t log_write_notifier_thread_key
srv_unix_flush_t
Alternatives for the file flush option in Unix.
Definition: srv0srv.h:867
@ SRV_UNIX_O_DSYNC
open log files in O_SYNC mode
Definition: srv0srv.h:871
@ SRV_UNIX_FSYNC
fsync, the default if O_DIRECT is not supported
Definition: srv0srv.h:869
@ SRV_UNIX_NOSYNC
do not flush after writing
Definition: srv0srv.h:876
@ SRV_UNIX_O_DIRECT_NO_FSYNC
do not use fsync() when using direct IO i.e.
Definition: srv0srv.h:884
@ SRV_UNIX_LITTLESYNC
do not call os_file_flush() when writing data files, but do flush after writing to log files
Definition: srv0srv.h:874
@ SRV_UNIX_O_DIRECT
invoke os_file_set_nocache() on data files.
Definition: srv0srv.h:880
mysql_pfs_key_t log_writer_thread_key
mysql_pfs_key_t buf_resize_thread_key
bool srv_is_direct_io()
Definition: srv0srv.h:888
ulong srv_n_page_hash_locks
Number of locks to protect buf_pool->page_hash.
Definition: srv0srv.cc:439
bool srv_checkpoint_disabled
If true then disable checkpointing.
Definition: srv0srv.cc:381
std::chrono::seconds get_srv_fatal_semaphore_wait_threshold()
Definition: srv0srv.cc:126
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:212
unsigned long long srv_online_max_size
Maximum modification log file size for online index creation.
Definition: srv0srv.cc:206
ulong srv_flushing_avg_loops
Definition: srv0srv.cc:504
bool srv_inject_too_many_concurrent_trxs
Definition: srv0srv.cc:383
ulint srv_buf_pool_old_size
Previously requested size.
Definition: srv0srv.cc:449
char * srv_data_home
Definition: srv0srv.cc:141
bool srv_load_corrupted
Definition: dict0load.cc:137
ulong srv_n_page_cleaners
Definition: srv0srv.cc:489
ulong srv_log_checkpoint_every
Number of milliseconds every which a periodical checkpoint is written by the log checkpointer thread ...
Definition: srv0srv.cc:331
bool srv_random_read_ahead
Definition: srv0srv.cc:468
bool srv_buffer_pool_load_at_startup
Definition: srv0srv.cc:790
ulong srv_n_read_io_threads
Definition: srv0srv.cc:464
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:841
ulong srv_log_flush_notifier_timeout
Initial timeout used to wait on flush_notifier_event.
Definition: srv0srv.cc:367
double srv_max_dirty_pages_pct
ulong srv_replication_delay
Definition: srv0srv.cc:578
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:370
void srv_master_thread_disabled_debug_update(THD *thd, SYS_VAR *var, void *var_ptr, const void *save)
Disables master thread.
Definition: srv0srv.cc:2058
ulong srv_purge_batch_size
Definition: srv0srv.cc:510
os_event_t srv_monitor_event
Event to signal the monitor thread.
Definition: srv0srv.cc:773
ulonglong srv_redo_log_capacity
Value of innodb_redo_log_capacity.
Definition: srv0srv.cc:240
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:830
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:240
ulong srv_purge_rseg_truncate_frequency
Rate at which UNDO records should be purged.
Definition: srv0srv.cc:172
os_event_t srv_error_event
Event to signal the error thread.
Definition: srv0srv.cc:776
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:810
mysql_pfs_key_t io_ibuf_thread_key
srv_stats_method_name_enum
Definition: srv0srv.h:935
@ SRV_STATS_NULLS_UNEQUAL
Definition: srv0srv.h:939
@ SRV_STATS_NULLS_IGNORED
Definition: srv0srv.h:941
@ SRV_STATS_NULLS_EQUAL
Definition: srv0srv.h:936
PSI_stage_info srv_stage_alter_table_merge_sort
Performance schema stage event for monitoring ALTER TABLE progress row_merge_sort().
Definition: srv0srv.cc:826
PSI_stage_info srv_stage_clone_page_copy
Performance schema stage event for monitoring clone page copy progress.
Definition: srv0srv.cc:854
uint srv_log_spin_cpu_abs_lwm
Minimum absolute value of cpu time for which spin-delay is used.
Definition: srv0srv.cc:258
os_event_t srv_buf_dump_event
The buffer pool dump/load thread waits on this event.
Definition: srv0srv.cc:779
bool srv_stats_persistent
Definition: srv0srv.cc:573
@ SRV_FORCE_NO_BACKGROUND
prevent the main thread from running: if a crash would occur in purge, this prevents it
Definition: srv0srv.h:917
@ SRV_FORCE_NO_IBUF_MERGE
prevent also ibuf operations: if they would cause a crash, better not do them
Definition: srv0srv.h:922
@ SRV_FORCE_NO_LOG_REDO
do not do the log roll-forward in connection with recovery
Definition: srv0srv.h:929
@ SRV_FORCE_IGNORE_CORRUPT
let the server run even if it detects a corrupt page
Definition: srv0srv.h:915
@ SRV_FORCE_NO_TRX_UNDO
do not run trx rollback after recovery
Definition: srv0srv.h:920
@ 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:925
ulong srv_read_ahead_threshold
Definition: srv0srv.cc:472
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:5001
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:197
ulong srv_log_wait_for_flush_spin_hwm
Maximum value of average log flush time for which spin-delay is used.
Definition: srv0srv.cc:266
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:273
void srv_monitor_thread()
A thread which prints the info output by various InnoDB monitors.
Definition: srv0srv.cc:1768
bool srv_log_checksums
Whether to generate and require checksums on the redo log pages.
Definition: srv0srv.cc:377
bool srv_innodb_status
Definition: srv0srv.cc:564
enum srv_stats_method_name_enum srv_stats_method_name_t
Definition: srv0srv.h:944
const longlong srv_buf_pool_max_size
Maximum pool size in bytes.
Definition: srv0srv.cc:423
Srv_cpu_usage srv_cpu_usage
Structure with cpu usage information.
Definition: srv0srv.cc:109
mysql_pfs_key_t page_archiver_thread_key
bool srv_undo_log_truncate
Enable or Disable Truncate of UNDO tablespace.
Definition: srv0srv.cc:181
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:123
mysql_pfs_key_t parallel_rseg_init_thread_key
bool srv_print_innodb_lock_monitor
Definition: srv0srv.cc:604
ib_mutex_t srv_misc_tmpfile_mutex
Mutex for locking srv_misc_tmpfile.
Definition: srv0srv.cc:629
ulong srv_force_recovery
Normally 0.
Definition: srv0srv.cc:530
bool srv_stats_include_delete_marked
Definition: srv0srv.cc:574
ulong srv_adaptive_flushing_lwm
Definition: srv0srv.cc:501
ulong srv_n_purge_threads
Definition: srv0srv.cc:507
std::chrono::microseconds get_srv_log_writer_timeout()
Initial timeout used to wait on writer_event.
Definition: srv0srv.cc:324
ulong srv_log_write_notifier_timeout
Initial timeout used to wait on write_notifier_event.
Definition: srv0srv.cc:354
const char * srv_io_thread_op_info[]
Definition: srv0srv.cc:609
bool srv_dedicated_server
Dedicated server setting.
Definition: srv0srv.cc:415
Log_DDL * log_ddl
Object to handle Log_DDL.
Definition: log0ddl.cc:65
std::chrono::microseconds get_srv_log_wait_for_write_timeout()
Timeout used when waiting for redo write.
Definition: srv0srv.cc:301
bool srv_flush_sync
Definition: srv0srv.cc:402
PSI_stage_info srv_stage_clone_redo_copy
Performance schema stage event for monitoring clone redo copy progress.
Definition: srv0srv.cc:850
uint srv_flush_log_at_timeout
Definition: srv0srv.cc:388
long long srv_buf_pool_curr_size
Current size in bytes.
Definition: srv0srv.cc:453
ulong srv_log_flush_events
Number of events used for notifications about redo flush.
Definition: srv0srv.cc:279
ulong srv_log_flusher_timeout
Initial timeout used to wait on flusher_event.
Definition: srv0srv.cc:342
void srv_reset_io_thread_op_info()
Resets the info describing an i/o thread current state.
Definition: srv0srv.cc:879
unsigned long long srv_stats_transient_sample_pages
Definition: srv0srv.cc:572
mysql_pfs_key_t bulk_flusher_thread_key
srv_stats_t srv_stats
Global counters.
Definition: srv0srv.cc:520
ulong srv_io_capacity
Definition: srv0srv.cc:485
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:1908
void srv_error_monitor_thread()
A thread which prints warnings about semaphore waits which have lasted too long.
Definition: srv0srv.cc:1828
mysql_pfs_key_t srv_worker_thread_key
void srv_master_thread()
The master thread controlling the server.
Definition: srv0srv.cc:2697
const size_t CONCURRENT_UNDO_TRUNCATE_LIMIT
Maximum number of recently truncated undo tablespace IDs for the same undo number.
Definition: srv0srv.cc:191
ulong srv_sort_buf_size
Sort buffer size in index creation.
Definition: srv0srv.cc:204
Srv_threads srv_threads
Structure with state of srv background threads.
Definition: srv0srv.cc:106
PSI_stage_info srv_stage_alter_table_log_index
Performance schema stage event for monitoring ALTER TABLE progress row_log_apply().
Definition: srv0srv.cc:815
const ulong srv_buf_pool_instances_default
Default number of buffer pool instances.
Definition: srv0srv.cc:437
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:344
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:1021
bool srv_print_all_deadlocks
Print all user-level transactions deadlocks to mysqld stderr.
Definition: srv0srv.cc:538
ulint srv_get_task_queue_length(void)
Get count of tasks in the queue.
Definition: srv0srv.cc:3171
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:3220
mysql_pfs_key_t fts_parallel_merge_thread_key
ulong srv_rollback_segments
The number of rollback segments per tablespace.
Definition: srv0srv.cc:160
constexpr size_t SRV_N_LOG_FILES_CLONE_MAX
Definition: srv0srv.h:430
bool srv_enable_undo_encryption()
Enable UNDO tablespaces encryption.
Definition: srv0srv.cc:2545
os_event_t srv_buf_resize_event
The buffer pool resize thread waits on this event.
Definition: srv0srv.cc:782
mysql_pfs_key_t fts_optimize_thread_key
bool srv_redo_log_encrypt
Enable or Disable Encrypt of REDO tablespace.
Definition: srv0srv.cc:238
static void srv_active_wake_master_thread()
Definition: srv0srv.h:986
long innobase_get_open_files_limit()
Returns current value of the "innodb_open_files" configuration variable.
Definition: ha_innodb.cc:5000
Stage instrument information.
Definition: psi_stage_bits.h:74
Definition: system_variables_bits.h:153
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:1115
ulonglong innodb_redo_log_uuid
Redo log UUID.
Definition: srv0srv.h:1155
ulint innodb_buffer_pool_pages_flushed
srv_buf_pool_flushed
Definition: srv0srv.h:1146
ulonglong innodb_redo_log_logical_size
Redo log logical size.
Definition: srv0srv.h:1160
ulint innodb_buffer_pool_pages_latched
Latched pages.
Definition: srv0srv.h:1141
ulint innodb_system_rows_updated
srv_n_system_rows_updated
Definition: srv0srv.h:1191
ulint innodb_sampled_pages_read
Definition: srv0srv.h:1193
ulint innodb_buffer_pool_write_requests
srv_buf_pool_write_requests
Definition: srv0srv.h:1147
ulint innodb_data_written
Data bytes written.
Definition: srv0srv.h:1122
ulint innodb_pages_created
buf_pool->stat.n_pages_created
Definition: srv0srv.h:1172
ulint innodb_buffer_pool_read_ahead
srv_read_ahead
Definition: srv0srv.h:1149
ulint innodb_system_rows_read
srv_n_system_rows_read
Definition: srv0srv.h:1189
bool innodb_redo_log_read_only
Is redo log read-only ?
Definition: srv0srv.h:1154
char innodb_buffer_pool_resize_status[512]
Buf pool resize status.
Definition: srv0srv.h:1128
ulint innodb_num_open_files
fil_n_files_open
Definition: srv0srv.h:1195
int64_t innodb_row_lock_time
srv_n_lock_wait_time / 1000
Definition: srv0srv.h:1178
ulint innodb_data_read
Data bytes read.
Definition: srv0srv.h:1120
ulint innodb_data_pending_reads
Pending reads.
Definition: srv0srv.h:1116
ulint innodb_data_fsyncs
Number of fsyncs so far.
Definition: srv0srv.h:1119
ulint innodb_purge_view_trx_id_age
rw_max_trx_no
Definition: srv0srv.h:1207
ulint innodb_buffer_pool_bytes_dirty
File bytes modified.
Definition: srv0srv.h:1137
ulint innodb_buffer_pool_pages_free
Free pages.
Definition: srv0srv.h:1139
char innodb_redo_log_resize_status[512]
Redo log resize status.
Definition: srv0srv.h:1153
ulint innodb_dblwr_pages_written
srv_dblwr_pages_written
Definition: srv0srv.h:1151
ulint innodb_ahi_drop_lookups
number of adaptive hash index lookups when freeing file pages
Definition: srv0srv.h:1209
ulint innodb_buffer_pool_read_ahead_evicted
srv_read_ahead evicted
Definition: srv0srv.h:1150
ulint innodb_dblwr_writes
srv_dblwr_writes
Definition: srv0srv.h:1152
ulint innodb_buffer_pool_read_ahead_rnd
srv_read_ahead_rnd
Definition: srv0srv.h:1148
ulint innodb_data_pending_fsyncs
Pending fsyncs.
Definition: srv0srv.h:1118
ulint innodb_rows_deleted
srv_n_rows_deleted
Definition: srv0srv.h:1188
ulint innodb_data_reads
I/O read requests.
Definition: srv0srv.h:1123
ulint innodb_row_lock_time_avg
srv_n_lock_wait_time / 1000 / srv_n_lock_wait_count
Definition: srv0srv.h:1180
ulint innodb_page_size
UNIV_PAGE_SIZE.
Definition: srv0srv.h:1171
char innodb_buffer_pool_load_status[OS_FILE_MAX_PATH+128]
Buf pool load status.
Definition: srv0srv.h:1127
bool innodb_redo_log_enabled
srv_redo_log
Definition: srv0srv.h:1175
ulint innodb_undo_tablespaces_implicit
number of undo tablespaces innoDB created implicitly.
Definition: srv0srv.h:1199
ulint innodb_rows_inserted
srv_n_rows_inserted
Definition: srv0srv.h:1186
ulint innodb_buffer_pool_reads
srv_buf_pool_reads
Definition: srv0srv.h:1144
ulint innodb_undo_tablespaces_active
number of active undo tablespaces
Definition: srv0srv.h:1203
ulint innodb_data_writes
I/O write requests.
Definition: srv0srv.h:1121
ulint innodb_purge_trx_id_age
rw_max_trx_no - purged trx_no
Definition: srv0srv.h:1206
ulint innodb_buffer_pool_pages_dirty
Dirty data pages.
Definition: srv0srv.h:1136
ulint innodb_log_writes
srv_log_writes
Definition: srv0srv.h:1166
lsn_t innodb_os_log_written
srv_os_log_written
Definition: srv0srv.h:1167
ulonglong innodb_redo_log_capacity_resized
Redo log capacity after the last finished redo resize.
Definition: srv0srv.h:1162
ulonglong innodb_redo_log_current_lsn
Redo log current LSN.
Definition: srv0srv.h:1157
ulint innodb_rows_updated
srv_n_rows_updated
Definition: srv0srv.h:1187
ulint innodb_os_log_fsyncs
log_total_flushes()
Definition: srv0srv.h:1168
uint32_t innodb_buffer_pool_resize_status_progress
Buf pool resize status progess.
Definition: srv0srv.h:1131
ulint innodb_os_log_pending_writes
srv_os_log_pending_writes
Definition: srv0srv.h:1169
ulint innodb_buffer_pool_pages_total
Buffer pool size.
Definition: srv0srv.h:1133
ulint innodb_undo_tablespaces_total
total number of undo tablespaces innoDB is tracking.
Definition: srv0srv.h:1197
ulint innodb_buffer_pool_pages_misc
Miscellaneous pages.
Definition: srv0srv.h:1138
ulint innodb_row_lock_waits
srv_n_lock_wait_count
Definition: srv0srv.h:1176
ulint innodb_buffer_pool_pages_data
Data pages.
Definition: srv0srv.h:1134
ulint innodb_data_pending_writes
Pending writes.
Definition: srv0srv.h:1117
ulint innodb_buffer_pool_wait_free
srv_buf_pool_wait_free
Definition: srv0srv.h:1145
ulonglong innodb_redo_log_checkpoint_lsn
Redo log checkpoint LSN.
Definition: srv0srv.h:1156
ulint innodb_buffer_pool_bytes_data
File bytes used.
Definition: srv0srv.h:1135
uint32_t innodb_buffer_pool_resize_status_code
Buf pool resize status code.
Definition: srv0srv.h:1130
ulint innodb_buffer_pool_read_requests
buf_pool->stat.n_page_gets
Definition: srv0srv.h:1143
ulint innodb_log_write_requests
srv_log_write_requests
Definition: srv0srv.h:1165
ulonglong innodb_redo_log_physical_size
Redo log physical size.
Definition: srv0srv.h:1161
ulonglong innodb_redo_log_flushed_to_disk_lsn
Redo log flushed to disk LSN.
Definition: srv0srv.h:1159
ulint innodb_os_log_pending_fsyncs
log_pending_flushes()
Definition: srv0srv.h:1170
ulint innodb_pages_written
buf_pool->stat.n_pages_written
Definition: srv0srv.h:1174
ulint innodb_row_lock_current_waits
srv_n_lock_wait_current_count
Definition: srv0srv.h:1177
ulint innodb_undo_tablespaces_explicit
number of undo tablespaces the dba created explicitly.
Definition: srv0srv.h:1201
ulint innodb_pages_read
buf_pool->stat.n_pages_read
Definition: srv0srv.h:1173
ulint innodb_log_waits
srv_log_waits
Definition: srv0srv.h:1164
char innodb_buffer_pool_dump_status[OS_FILE_MAX_PATH+128]
Buf pool dump status.
Definition: srv0srv.h:1125
ulint innodb_sampled_pages_skipped
Definition: srv0srv.h:1194
ulint innodb_system_rows_inserted
srv_n_system_rows_inserted
Definition: srv0srv.h:1190
ulint innodb_truncated_status_writes
srv_truncated_status_writes
Definition: srv0srv.h:1196
ulint innodb_row_lock_time_max
srv_n_lock_max_wait_time / 1000
Definition: srv0srv.h:1183
ulint innodb_rows_read
srv_n_rows_read
Definition: srv0srv.h:1185
ulint innodb_system_rows_deleted
srv_n_system_rows_deleted
Definition: srv0srv.h:1192
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:1217
bool in_use
true if this slot is in use.
Definition: srv0srv.h:1222
bool suspended
true if the thread is waiting for the event of this slot.
Definition: srv0srv.h:1225
std::chrono::steady_clock::duration wait_timeout
Wait time that if exceeded the thread will be timed out.
Definition: srv0srv.h:1243
que_thr_t * thr
Suspended query thread (only used for user threads).
Definition: srv0srv.h:1249
std::chrono::steady_clock::time_point suspend_time
Time when the thread was suspended.
Definition: srv0srv.h:1229
uint64_t reservation_no
Stores the current value of lock_wait_table_reservations, when lock_wait_table_reserve_slot is called...
Definition: srv0srv.h:1239
os_event_t event
Event used in suspending the thread when it has nothing to do.
Definition: srv0srv.h:1246
srv_thread_type type
Thread type: user, utility etc.
Definition: srv0srv.h:1219
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
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