MySQL 9.0.0
Source Code Documentation
sync0types.h
Go to the documentation of this file.
1/*****************************************************************************
2
3Copyright (c) 1995, 2024, Oracle and/or its affiliates.
4
5This program is free software; you can redistribute it and/or modify it under
6the terms of the GNU General Public License, version 2.0, as published by the
7Free Software Foundation.
8
9This program is designed to work with certain software (including
10but not limited to OpenSSL) that is licensed under separate terms,
11as designated in a particular file or component or in included license
12documentation. The authors of MySQL hereby grant you an additional
13permission to link the program and your derivative works with the
14separately licensed software that they have either included with
15the program or referenced in the documentation.
16
17This program is distributed in the hope that it will be useful, but WITHOUT
18ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
19FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0,
20for more details.
21
22You should have received a copy of the GNU General Public License along with
23this program; if not, write to the Free Software Foundation, Inc.,
2451 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
25
26*****************************************************************************/
27
28/** @file include/sync0types.h
29 Global types for sync
30
31 Created 9/5/1995 Heikki Tuuri
32 *******************************************************/
33
34#ifndef sync0types_h
35#define sync0types_h
36
37#include <iostream>
38#include <vector>
39
40#include "sync0sync.h"
41#include "univ.i"
42#include "ut0counter.h"
43#include "ut0log.h"
44#include "ut0new.h"
45
46#ifdef UNIV_DEBUG
47/** Set when InnoDB has invoked exit(). */
48extern bool innodb_calling_exit;
49#endif /* UNIV_DEBUG */
50
51#ifdef _WIN32
52/** Native mutex */
53typedef CRITICAL_SECTION sys_mutex_t;
54#else
55/** Native mutex */
56typedef pthread_mutex_t sys_mutex_t;
57#endif /* _WIN32 */
58
59/*
60 LATCHING ORDER WITHIN THE DATABASE
61 ==================================
62
63The mutex or latch in the central memory object, for instance, a rollback
64segment object, must be acquired before acquiring the latch or latches to
65the corresponding file data structure. In the latching order below, these
66file page object latches are placed immediately below the corresponding
67central memory object latch or mutex.
68
69Synchronization object Notes
70---------------------- -----
71
72Dictionary mutex If we have a pointer to a dictionary
73| object, e.g., a table, it can be
74| accessed without reserving the
75| dictionary mutex. We must have a
76| reservation, a memoryfix, to the
77| appropriate table object in this case,
78| and the table must be explicitly
79| released later.
80V
81Dictionary header
82|
83V
84Secondary index tree latch The tree latch protects also all
85| the B-tree non-leaf pages. These
86V can be read with the page only
87Secondary index non-leaf bufferfixed to save CPU time,
88| no s-latch is needed on the page.
89| Modification of a page requires an
90| x-latch on the page, however. If a
91| thread owns an x-latch to the tree,
92| it is allowed to latch non-leaf pages
93| even after it has acquired the fsp
94| latch.
95V
96Secondary index leaf The latch on the secondary index leaf
97| can be kept while accessing the
98| clustered index, to save CPU time.
99V
100Clustered index tree latch To increase concurrency, the tree
101| latch is usually released when the
102| leaf page latch has been acquired.
103V
104Clustered index non-leaf
105|
106V
107Clustered index leaf
108|
109V
110Transaction system header
111|
112V
113Transaction undo mutex The undo log entry must be written
114| before any index page is modified.
115| Transaction undo mutex is for the undo
116| logs the analogue of the tree latch
117| for a B-tree. If a thread has the
118| trx undo mutex reserved, it is allowed
119| to latch the undo log pages in any
120| order, and also after it has acquired
121| the fsp latch.
122V
123Rollback segment mutex The rollback segment mutex must be
124| reserved, if, e.g., a new page must
125| be added to an undo log. The rollback
126| segment and the undo logs in its
127| history list can be seen as an
128| analogue of a B-tree, and the latches
129| reserved similarly, using a version of
130| lock-coupling. If an undo log must be
131| extended by a page when inserting an
132| undo log record, this corresponds to
133| a pessimistic insert in a B-tree.
134V
135Rollback segment header
136|
137V
138Purge system latch
139|
140V
141Undo log pages If a thread owns the trx undo mutex,
142| or for a log in the history list, the
143| rseg mutex, it is allowed to latch
144| undo log pages in any order, and even
145| after it has acquired the fsp latch.
146| If a thread does not have the
147| appropriate mutex, it is allowed to
148| latch only a single undo log page in
149| a mini-transaction.
150V
151File space management latch If a mini-transaction must allocate
152| several file pages, it can do that,
153| because it keeps the x-latch to the
154| file space management in its memo.
155V
156File system pages
157|
158V
159lock_sys_wait_mutex Mutex protecting lock timeout data
160|
161V
162lock_sys->global_sharded_latch Sharded rw-latch protecting lock_sys_t
163|
164V
165lock_sys->table_mutexes Mutexes protecting lock_sys_t table
166| lock queues
167|
168V
169lock_sys->page_mutexes Mutexes protecting lock_sys_t page
170| lock queues
171|
172V
173trx_sys->mutex Mutex protecting trx_sys_t
174|
175V
176Threads mutex Background thread scheduling mutex
177|
178V
179query_thr_mutex Mutex protecting query threads
180|
181V
182trx_mutex Mutex protecting trx_t fields
183|
184V
185Search system mutex
186|
187V
188Buffer pool mutexes
189|
190V
191Log mutex
192|
193Any other latch
194|
195V
196Memory pool mutex */
197
198/** Latching order levels. If you modify these, you have to also update
199LatchDebug internals in sync0debug.cc */
200
203
205
211
213
215
217
219
221
231
233
235
237
243
258
272
274
280
282
302
305
316
318
320
322
324
326
327 /** Level is varying. Only used with buffer pool page locks, which
328 do not have a fixed level, but instead have their level set after
329 the page is locked; see e.g. ibuf_bitmap_get_map_page(). */
330
332
333 /** This can be used to suppress order checking. */
335
336 /** Maximum level value */
339
340/** Each latch has an ID. This id is used for creating the latch and to look
341up its meta-data. See sync0debug.c. The order does not matter here, but
342alphabetical ordering seems useful */
468
469/** OS mutex, without any policy. It is a thin wrapper around the
470system mutexes. The interface is different from the policy mutexes,
471to ensure that it is called directly and not confused with the
472policy mutexes. */
473struct OSMutex {
474 /** Constructor */
476
477 /** Create the mutex by calling the system functions. */
479 ut_ad(m_freed);
480
481#ifdef _WIN32
482 InitializeCriticalSection((LPCRITICAL_SECTION)&m_mutex);
483#else
484 {
485 int ret = pthread_mutex_init(&m_mutex, nullptr);
486 ut_a(ret == 0);
487 }
488#endif /* _WIN32 */
489
490 ut_d(m_freed = false);
491 }
492
493 /** Destructor */
494 ~OSMutex() = default;
495
496 /** Destroy the mutex */
499#ifdef _WIN32
500 DeleteCriticalSection((LPCRITICAL_SECTION)&m_mutex);
501#else
502 int ret;
503
504 ret = pthread_mutex_destroy(&m_mutex);
505
506 if (ret != 0) {
507#ifdef UNIV_NO_ERR_MSGS
508 ib::error()
509#else
510 ib::error(ER_IB_MSG_1372)
511#endif
512 << "Return value " << ret << " when calling pthread_mutex_destroy().";
513 }
514#endif /* _WIN32 */
515 ut_d(m_freed = true);
516 }
517
518 /** Release the mutex. */
521#ifdef _WIN32
522 LeaveCriticalSection(&m_mutex);
523#else
524 int ret = pthread_mutex_unlock(&m_mutex);
525 ut_a(ret == 0);
526#endif /* _WIN32 */
527 }
528
529 /** Acquire the mutex. */
532#ifdef _WIN32
533 EnterCriticalSection((LPCRITICAL_SECTION)&m_mutex);
534#else
535 int ret = pthread_mutex_lock(&m_mutex);
536 ut_a(ret == 0);
537#endif /* _WIN32 */
538 }
539
540 void lock() { enter(); }
541 void unlock() { exit(); }
542
543 /** @return true if locking succeeded */
546#ifdef _WIN32
547 return (TryEnterCriticalSection(&m_mutex) != 0);
548#else
549 return (pthread_mutex_trylock(&m_mutex) == 0);
550#endif /* _WIN32 */
551 }
552
553 /** Required for os_event_t */
554 operator sys_mutex_t *() UNIV_NOTHROW { return (&m_mutex); }
555
556#if defined(UNIV_LIBRARY) && defined(UNIV_DEBUG)
557 bool is_owned() {
558 /* This should never be reached. This is
559 added to fix is_owned() compilation errors
560 for library. We will never reach here because
561 mutexes are disabled in library. */
562 ut_error;
563 return (false);
564 }
565#endif /* UNIV_LIBRARY && UNIV_DEBUG */
566
567 private:
568#ifdef UNIV_DEBUG
569 /** true if the mutex has been freed/destroyed. */
571#endif /* UNIV_DEBUG */
572
574};
575
576#ifndef UNIV_LIBRARY
577#ifdef UNIV_PFS_MUTEX
578/** Latch element
579Used for mutexes which have PFS keys defined under UNIV_PFS_MUTEX.
580@param[in] id Latch id
581@param[in] level Latch level
582@param[in] key PFS key */
583#define LATCH_ADD_MUTEX(id, level, key) \
584 latch_meta[LATCH_ID_##id] = ut::new_withkey<latch_meta_t>( \
585 UT_NEW_THIS_FILE_PSI_KEY, LATCH_ID_##id, #id, level, #level, key)
586
587#ifdef UNIV_PFS_RWLOCK
588/** Latch element.
589Used for rwlocks which have PFS keys defined under UNIV_PFS_RWLOCK.
590@param[in] id Latch id
591@param[in] level Latch level
592@param[in] key PFS key */
593#define LATCH_ADD_RWLOCK(id, level, key) \
594 latch_meta[LATCH_ID_##id] = ut::new_withkey<latch_meta_t>( \
595 UT_NEW_THIS_FILE_PSI_KEY, LATCH_ID_##id, #id, level, #level, key)
596#else
597#define LATCH_ADD_RWLOCK(id, level, key) \
598 latch_meta[LATCH_ID_##id] = \
599 ut::new_withkey<latch_meta_t>(UT_NEW_THIS_FILE_PSI_KEY, LATCH_ID_##id, \
600 #id, level, #level, PSI_NOT_INSTRUMENTED)
601#endif /* UNIV_PFS_RWLOCK */
602
603#else
604#define LATCH_ADD_MUTEX(id, level, key) \
605 latch_meta[LATCH_ID_##id] = ut::new_withkey<latch_meta_t>( \
606 UT_NEW_THIS_FILE_PSI_KEY, LATCH_ID_##id, #id, level, #level)
607#define LATCH_ADD_RWLOCK(id, level, key) \
608 latch_meta[LATCH_ID_##id] = ut::new_withkey<latch_meta_t>( \
609 UT_NEW_THIS_FILE_PSI_KEY, LATCH_ID_##id, #id, level, #level)
610#endif /* UNIV_PFS_MUTEX */
611
612/** Default latch counter */
614 public:
615 /** The counts we collect for a mutex */
616 struct Count {
617 /** Constructor */
619 /* No op */
620 }
621
622 /** Rest the values to zero */
624 m_spins = 0;
625 m_waits = 0;
626 m_calls = 0;
627 }
628
629 /** Number of spins trying to acquire the latch. */
630 uint32_t m_spins;
631
632 /** Number of waits trying to acquire the latch */
633 uint32_t m_waits;
634
635 /** Number of times it was called */
636 uint32_t m_calls;
637
638 /** true if enabled */
640 };
641
642 /** Constructor */
644
645 /** Destructor */
648
649 for (Count *count : m_counters) {
651 }
652 }
653
654 /** Reset all counters to zero. It is not protected by any
655 mutex and we don't care about atomicity. Unless it is a
656 demonstrated problem. The information collected is not
657 required for the correct functioning of the server. */
659 m_mutex.enter();
660
661 for (Count *count : m_counters) {
662 count->reset();
663 }
664
665 m_mutex.exit();
666 }
667
668 /** @return the aggregate counter */
670 m_mutex.enter();
671
672 Count *count;
673
674 if (m_counters.empty()) {
675 count = ut::new_withkey<Count>(UT_NEW_THIS_FILE_PSI_KEY);
676 m_counters.push_back(count);
677 } else {
678 ut_a(m_counters.size() == 1);
679 count = m_counters[0];
680 }
681
682 m_mutex.exit();
683
684 return (count);
685 }
686
687 /** Deregister the count. We don't do anything
688 @param[in] count The count instance to deregister */
690 [[maybe_unused]]) const UNIV_NOTHROW { /* Do nothing */
691 }
692
693 /** Register a single instance counter */
695 m_mutex.enter();
696
697 m_counters.push_back(count);
698
699 m_mutex.exit();
700 }
701
702 /** Deregister a single instance counter
703 @param[in] count The count instance to deregister */
705 m_mutex.enter();
706
707 m_counters.erase(std::remove(m_counters.begin(), m_counters.end(), count),
708 m_counters.end());
709
710 m_mutex.exit();
711 }
712
713 /** Iterate over the counters */
714 template <typename Callback>
715 void iterate(Callback &&callback) const UNIV_NOTHROW {
716 m_mutex.enter();
717 for (const Count *count : m_counters) {
718 std::forward<Callback>(callback)(count);
719 }
720 m_mutex.exit();
721 }
722
723 /** Disable the monitoring */
725 m_mutex.enter();
726
727 for (Count *count : m_counters) {
728 count->m_enabled = true;
729 }
730
731 m_active = true;
732
733 m_mutex.exit();
734 }
735
736 /** Disable the monitoring */
738 m_mutex.enter();
739
740 for (Count *count : m_counters) {
741 count->m_enabled = false;
742 }
743
744 m_active = false;
745
746 m_mutex.exit();
747 }
748
749 /** @return if monitoring is active */
750 bool is_enabled() const UNIV_NOTHROW { return (m_active); }
751
752 private:
753 /* Disable copying */
756
757 private:
758 typedef OSMutex Mutex;
759 typedef std::vector<Count *> Counters;
760
761 /** Mutex protecting m_counters */
762 mutable Mutex m_mutex;
763
764 /** Counters for the latches */
766
767 /** if true then we collect the data */
769};
770
771/** Latch meta data */
772template <typename Counter = LatchCounter>
774 public:
776
777#ifdef UNIV_PFS_MUTEX
779#endif /* UNIV_PFS_MUTEX */
780
781 /** Constructor */
784 m_name(),
787#ifdef UNIV_PFS_MUTEX
788 ,
789 m_pfs_key()
790#endif /* UNIV_PFS_MUTEX */
791 {
792 }
793
794 /** Destructor */
795 ~LatchMeta() = default;
796
797 /** Constructor
798 @param[in] id Latch id
799 @param[in] name Latch name
800 @param[in] level Latch level
801 @param[in] level_name Latch level text representation
802 @param[in] key PFS key */
803 LatchMeta(latch_id_t id, const char *name, latch_level_t level,
804 const char *level_name
805#ifdef UNIV_PFS_MUTEX
806 ,
808#endif /* UNIV_PFS_MUTEX */
809 )
810 : m_id(id),
811 m_name(name),
812 m_level(level),
813 m_level_name(level_name)
814#ifdef UNIV_PFS_MUTEX
815 ,
817#endif /* UNIV_PFS_MUTEX */
818 {
819 /* No op */
820 }
821
822 /* Less than operator.
823 @param[in] rhs Instance to compare against
824 @return true if this.get_id() < rhs.get_id() */
825 bool operator<(const LatchMeta &rhs) const {
826 return (get_id() < rhs.get_id());
827 }
828
829 /** @return the latch id */
830 latch_id_t get_id() const { return (m_id); }
831
832 /** @return the latch name */
833 const char *get_name() const { return (m_name); }
834
835 /** @return the latch level */
836 latch_level_t get_level() const { return (m_level); }
837
838 /** @return the latch level name */
839 const char *get_level_name() const { return (m_level_name); }
840
841#ifdef UNIV_PFS_MUTEX
842 /** @return the PFS key for the latch */
843 pfs_key_t get_pfs_key() const { return (m_pfs_key); }
844#endif /* UNIV_PFS_MUTEX */
845
846 /** @return the counter instance */
847 Counter *get_counter() { return (&m_counter); }
848
849 private:
850 /** Latch id */
852
853 /** Latch name */
854 const char *m_name;
855
856 /** Latch level in the ordering */
858
859 /** Latch level text representation */
860 const char *m_level_name;
861
862#ifdef UNIV_PFS_MUTEX
863 /** PFS key */
865#endif /* UNIV_PFS_MUTEX */
866
867 /** For gathering latch statistics */
869};
870
872typedef std::vector<latch_meta_t *, ut::allocator<latch_meta_t *>>
874
875/** Note: This is accessed without any mutex protection. It is initialised
876at startup and elements should not be added to or removed from it after
877that. See sync_latch_meta_init() */
879
880/** Get the latch meta-data from the latch ID
881@param[in] id Latch ID
882@return the latch meta data */
884 ut_ad(static_cast<size_t>(id) < latch_meta.size());
885 ut_ad(id == latch_meta[id]->get_id());
886
887 return (*latch_meta[id]);
888}
889
890/** Fetch the counter for the latch
891@param[in] id Latch ID
892@return the latch counter */
895
896 return (meta.get_counter());
897}
898
899/** Get the latch name from the latch ID
900@param[in] id Latch ID
901@return the name, will assert if not found */
902inline const char *sync_latch_get_name(latch_id_t id) {
903 const latch_meta_t &meta = sync_latch_get_meta(id);
904
905 return (meta.get_name());
906}
907
908/** Get the latch ordering level
909@param[in] id Latch id to lookup
910@return the latch level */
912 const latch_meta_t &meta = sync_latch_get_meta(id);
913
914 return (meta.get_level());
915}
916
917#ifdef UNIV_PFS_MUTEX
918/** Get the latch PFS key from the latch ID
919@param[in] id Latch ID
920@return the PFS key */
922 const latch_meta_t &meta = sync_latch_get_meta(id);
923
924 return (meta.get_pfs_key());
925}
926#endif /* UNIV_PFS_MUTEX */
927
928#ifndef UNIV_HOTBACKUP
929/** String representation of the filename and line number where the
930latch was created
931@param[in] id Latch ID
932@param[in] created Filename and line number where it was created
933@return the string representation */
934std::string sync_mutex_to_string(latch_id_t id, const std::string &created);
935
936/** Print the filename "basename"
937@return the basename */
938const char *sync_basename(const char *filename);
939#endif /* !UNIV_HOTBACKUP */
940
941/** Register a latch, called when it is created
942@param[in] ptr Latch instance that was created
943@param[in] filename Filename where it was created
944@param[in] line Line number in filename */
945void sync_file_created_register(const void *ptr, const char *filename,
946 uint16_t line);
947
948/** Deregister a latch, called when it is destroyed
949@param[in] ptr Latch to be destroyed */
950void sync_file_created_deregister(const void *ptr);
951
952/** Get the string where the file was created. Its format is "name:line"
953@param[in] ptr Latch instance
954@return created information or "" if can't be found */
955std::string sync_file_created_get(const void *ptr);
956
957#endif /* !UNIV_LIBRARY */
958
959#ifdef UNIV_DEBUG
960
961/** All (ordered) latches, used in debugging, must derive from this class. */
962struct latch_t {
963 /** Constructor
964 @param[in] id The latch ID */
966 m_rw_lock(),
967 m_temp_fsp() {}
968
969 latch_t &operator=(const latch_t &) = default;
970
971 /** Destructor */
972 virtual ~latch_t() UNIV_NOTHROW = default;
973
974 /** @return the latch ID */
975 latch_id_t get_id() const { return (m_id); }
976
977 /** @return true if it is a rw-lock */
978 bool is_rw_lock() const UNIV_NOTHROW { return (m_rw_lock); }
979
980 /** Print the latch context
981 @return the string representation */
982 virtual std::string to_string() const = 0;
983
984 /** @return "filename:line" from where the latch was last locked */
985 virtual std::string locked_from() const = 0;
986
987 /** @return the latch level */
990
991#ifndef UNIV_LIBRARY
992 return (sync_latch_get_level(m_id));
993#else
994 /* This should never be reached. This is
995 added to fix compilation errors
996 for library. We will never reach here because
997 mutexes are disabled in library. */
998 ut_error;
999 return (SYNC_UNKNOWN);
1000#endif /* !UNIV_LIBRARY */
1001 }
1002
1003 /** @return true if the latch is for a temporary file space*/
1004 bool is_temp_fsp() const UNIV_NOTHROW { return (m_temp_fsp); }
1005
1006 /** Set the temporary tablespace flag. The latch order constraints
1007 are different for intrinsic tables. We don't always acquire the
1008 index->lock. We need to figure out the context and add some special
1009 rules during the checks. */
1012 m_temp_fsp = true;
1013 }
1014
1015 /** @return the latch name, m_id must be set */
1016 const char *get_name() const UNIV_NOTHROW {
1018
1019#ifndef UNIV_LIBRARY
1020 return (sync_latch_get_name(m_id));
1021#else
1022 /* This should never be reached. This is
1023 added to fix compilation errors
1024 for library. We will never reach here because
1025 mutexes are disabled in library. */
1026 ut_error;
1027 return (nullptr);
1028#endif /* !UNIV_LIBRARY */
1029 }
1030
1031 /** Latch ID */
1033
1034 /** true if it is a rw-lock. In debug mode, rw_lock_t derives from
1035 this class and sets this variable. */
1037
1038 /** true if it is an temporary space latch */
1040};
1041
1042/** Subclass this to iterate over a thread's acquired latch levels. */
1044 virtual ~sync_check_functor_t() = default;
1045 virtual bool operator()(const latch_level_t) = 0;
1046 virtual bool result() const = 0;
1047};
1048
1049/** Functor to check whether the calling thread owns the btr search mutex. */
1051 /** Constructor
1052 @param[in] has_search_latch true if owns the latch */
1053 explicit btrsea_sync_check(bool has_search_latch)
1054 : m_result(), m_has_search_latch(has_search_latch) {}
1055
1056 /** Destructor */
1057 ~btrsea_sync_check() override = default;
1058
1059 /** Called for every latch owned by the calling thread.
1060 @param[in] level Level of the existing latch
1061 @return true if the predicate check fails */
1062 bool operator()(const latch_level_t level) override {
1063 /* If calling thread doesn't hold search latch then
1064 check if there are latch level exception provided.
1065
1066 Note: Optimizer has added InnoDB intrinsic table as an
1067 alternative to MyISAM intrinsic table. With this a new
1068 control flow comes into existence, it is:
1069
1070 Server -> Plugin -> SE
1071
1072 Plugin in this case is I_S which is sharing the latch vector
1073 of InnoDB and so there could be lock conflicts. Ideally
1074 the Plugin should use a difference namespace latch vector
1075 as it doesn't have any dependency with SE latching protocol.
1076
1077 Added check that will allow thread to hold I_S latches */
1078
1079 if (!m_has_search_latch &&
1080 (level != SYNC_SEARCH_SYS && level != SYNC_DICT &&
1081 level != SYNC_FTS_CACHE && level != SYNC_UNDO_DDL &&
1082 level != SYNC_DICT_OPERATION && level != SYNC_TRX_I_S_LAST_READ &&
1083 level != SYNC_TRX_I_S_RWLOCK)) {
1084 m_result = true;
1085#ifdef UNIV_NO_ERR_MSGS
1086 ib::error()
1087#else
1088 ib::error(ER_IB_MSG_1373)
1089#endif
1090 << "Debug: Calling thread does not hold search "
1091 "latch but does hold latch level "
1092 << level << ".";
1093
1094 return (m_result);
1095 }
1096
1097 return (false);
1098 }
1099
1100 /** @return result from the check */
1101 bool result() const override { return (m_result); }
1102
1103 private:
1104 /** True if all OK */
1106
1107 /** If the caller owns the search latch */
1109};
1110
1111/** Functor to check for dictionary latching constraints. */
1113 /** Constructor
1114 @param[in] dict_mutex_allowed true if the dict mutex
1115 is allowed */
1116 explicit dict_sync_check(bool dict_mutex_allowed)
1117 : m_result(), m_dict_mutex_allowed(dict_mutex_allowed) {}
1118
1119 /** Destructor */
1120 ~dict_sync_check() override = default;
1121
1122 /** Check the latching constraints
1123 @param[in] level The level held by the thread */
1124 bool operator()(const latch_level_t level) override {
1125 if (!m_dict_mutex_allowed ||
1126 (level != SYNC_DICT && level != SYNC_UNDO_SPACES &&
1127 level != SYNC_FTS_CACHE && level != SYNC_DICT_OPERATION &&
1128 /* This only happens in recv_apply_hashed_log_recs. */
1129 level != SYNC_RECV_WRITER && level != SYNC_NO_ORDER_CHECK)) {
1130 m_result = true;
1131#ifdef UNIV_NO_ERR_MSGS
1132 ib::error()
1133#else
1134 ib::error(ER_IB_MSG_1374)
1135#endif
1136 << "Debug: Dictionary latch order violation for level " << level
1137 << ".";
1138
1139 return (true);
1140 }
1141
1142 return (false);
1143 }
1144
1145 /** @return the result of the check */
1146 virtual bool result() const override { return (m_result); }
1147
1148 private:
1149 /** True if all OK */
1151
1152 /** True if it is OK to hold the dict mutex */
1154};
1155
1156/** Functor to check for given latching constraints. */
1158 /** Constructor
1159 @param[in] from first element in an array of latch_level_t
1160 @param[in] to last element in an array of latch_level_t */
1162 : m_result(), m_latches(from, to) {}
1163
1164 /** Default constructor. The list of allowed latches is empty. */
1166
1167 /** Check whether the given latch_t violates the latch constraint.
1168 This object maintains a list of allowed latch levels, and if the given
1169 latch belongs to a latch level that is not there in the allowed list,
1170 then it is a violation.
1171
1172 @param[in] level The latch level to check
1173 @return true if there is a latch ordering violation */
1174 virtual bool operator()(const latch_level_t level) override {
1175 for (latch_level_t allowed_level : m_latches) {
1176 if (level == allowed_level) {
1177 m_result = false;
1178
1179 /* No violation */
1180 return (m_result);
1181 }
1182 }
1183
1184#ifdef UNIV_NO_ERR_MSGS
1185 ib::error()
1186#else
1187 ib::error(ER_IB_MSG_1375)
1188#endif
1189 << "Debug: sync_allowed_latches violation for level=" << level;
1190 m_result = true;
1191 return (m_result);
1192 }
1193
1194 /** @return the result of the check */
1195 virtual bool result() const override { return (m_result); }
1196
1197 private:
1198 /** Save the result of validation check here
1199 True if all OK */
1201
1202 typedef std::vector<latch_level_t, ut::allocator<latch_level_t>> latches_t;
1203
1204 /** List of latch levels that are allowed to be held */
1206};
1207
1209
1210/* Flags to specify lock types for rw_lock_own_flagged() */
1214 RW_LOCK_FLAG_SX = 1 << 2
1216
1217#endif /* UNIV_DBEUG */
1218
1219#endif /* sync0types_h */
Class that stores callback function reference as well as the result of the callback function call (in...
Definition: keyring_service.cc:43
Default latch counter.
Definition: sync0types.h:613
LatchCounter(const LatchCounter &)
bool is_enabled() const 1
Definition: sync0types.h:750
void single_deregister(Count *count) 1
Deregister a single instance counter.
Definition: sync0types.h:704
Counters m_counters
Counters for the latches.
Definition: sync0types.h:765
LatchCounter() 1
Constructor.
Definition: sync0types.h:643
void sum_deregister(Count *count) const 1
Deregister the count.
Definition: sync0types.h:689
void iterate(Callback &&callback) const 1
Iterate over the counters.
Definition: sync0types.h:715
Mutex m_mutex
Mutex protecting m_counters.
Definition: sync0types.h:762
void disable() 1
Disable the monitoring.
Definition: sync0types.h:737
LatchCounter & operator=(const LatchCounter &)
OSMutex Mutex
Definition: sync0types.h:758
~LatchCounter() 1
Destructor.
Definition: sync0types.h:646
bool m_active
if true then we collect the data
Definition: sync0types.h:768
void single_register(Count *count) 1
Register a single instance counter.
Definition: sync0types.h:694
std::vector< Count * > Counters
Definition: sync0types.h:759
void enable() 1
Disable the monitoring.
Definition: sync0types.h:724
void reset() 1
Reset all counters to zero.
Definition: sync0types.h:658
Count * sum_register() 1
Definition: sync0types.h:669
Latch meta data.
Definition: sync0types.h:773
const char * get_level_name() const
Definition: sync0types.h:839
bool operator<(const LatchMeta &rhs) const
Definition: sync0types.h:825
mysql_pfs_key_t pfs_key_t
Definition: sync0types.h:778
Counter * get_counter()
Definition: sync0types.h:847
Counter CounterType
Definition: sync0types.h:775
pfs_key_t get_pfs_key() const
Definition: sync0types.h:843
latch_level_t m_level
Latch level in the ordering.
Definition: sync0types.h:857
pfs_key_t m_pfs_key
PFS key.
Definition: sync0types.h:864
latch_level_t get_level() const
Definition: sync0types.h:836
Counter m_counter
For gathering latch statistics.
Definition: sync0types.h:868
latch_id_t m_id
Latch id.
Definition: sync0types.h:851
~LatchMeta()=default
Destructor.
const char * get_name() const
Definition: sync0types.h:833
latch_id_t get_id() const
Definition: sync0types.h:830
LatchMeta(latch_id_t id, const char *name, latch_level_t level, const char *level_name, pfs_key_t key)
Constructor.
Definition: sync0types.h:803
LatchMeta()
Constructor.
Definition: sync0types.h:782
const char * m_level_name
Latch level text representation.
Definition: sync0types.h:860
const char * m_name
Latch name.
Definition: sync0types.h:854
The class error is used to emit error messages.
Definition: ut0log.h:231
static int count
Definition: myisam_ftdump.cc:45
Sharded atomic counter.
Definition: ut0counter.h:221
static mysql_service_status_t remove(reference_caching_channel channel, const char *implementation_name) noexcept
Definition: component.cc:137
pid_type get_id()
Definition: process.h:48
void delete_(T *ptr) noexcept
Releases storage which has been dynamically allocated through any of the ut::new*() variants.
Definition: ut0new.h:810
const char * filename
Definition: pfs_example_component_population.cc:67
required string key
Definition: replication_asynchronous_connection_failover.proto:60
case opt name
Definition: sslopt-case.h:29
The counts we collect for a mutex.
Definition: sync0types.h:616
uint32_t m_spins
Number of spins trying to acquire the latch.
Definition: sync0types.h:630
void reset() 1
Rest the values to zero.
Definition: sync0types.h:623
uint32_t m_calls
Number of times it was called.
Definition: sync0types.h:636
Count() 1
Constructor.
Definition: sync0types.h:618
uint32_t m_waits
Number of waits trying to acquire the latch.
Definition: sync0types.h:633
bool m_enabled
true if enabled
Definition: sync0types.h:639
OS mutex, without any policy.
Definition: sync0types.h:473
void exit() 1
Release the mutex.
Definition: sync0types.h:519
OSMutex() 1
Constructor.
Definition: sync0types.h:475
bool try_lock() 1
Definition: sync0types.h:544
void enter() 1
Acquire the mutex.
Definition: sync0types.h:530
sys_mutex_t m_mutex
Definition: sync0types.h:573
~OSMutex()=default
Destructor.
void lock()
Definition: sync0types.h:540
bool m_freed
true if the mutex has been freed/destroyed.
Definition: sync0types.h:570
void init() 1
Create the mutex by calling the system functions.
Definition: sync0types.h:478
void unlock()
Definition: sync0types.h:541
void destroy() 1
Destroy the mutex.
Definition: sync0types.h:497
Functor to check whether the calling thread owns the btr search mutex.
Definition: sync0types.h:1050
const bool m_has_search_latch
If the caller owns the search latch.
Definition: sync0types.h:1108
btrsea_sync_check(bool has_search_latch)
Constructor.
Definition: sync0types.h:1053
bool m_result
True if all OK.
Definition: sync0types.h:1105
bool operator()(const latch_level_t level) override
Called for every latch owned by the calling thread.
Definition: sync0types.h:1062
~btrsea_sync_check() override=default
Destructor.
bool result() const override
Definition: sync0types.h:1101
Functor to check for dictionary latching constraints.
Definition: sync0types.h:1112
dict_sync_check(bool dict_mutex_allowed)
Constructor.
Definition: sync0types.h:1116
const bool m_dict_mutex_allowed
True if it is OK to hold the dict mutex.
Definition: sync0types.h:1153
bool m_result
True if all OK.
Definition: sync0types.h:1150
bool operator()(const latch_level_t level) override
Check the latching constraints.
Definition: sync0types.h:1124
~dict_sync_check() override=default
Destructor.
virtual bool result() const override
Definition: sync0types.h:1146
All (ordered) latches, used in debugging, must derive from this class.
Definition: sync0types.h:962
latch_level_t get_level() const 1
Definition: sync0types.h:988
bool is_rw_lock() const 1
Definition: sync0types.h:978
bool m_temp_fsp
true if it is an temporary space latch
Definition: sync0types.h:1039
latch_id_t m_id
Latch ID.
Definition: sync0types.h:1032
virtual ~latch_t() 1=default
Destructor.
void set_temp_fsp() 1
Set the temporary tablespace flag.
Definition: sync0types.h:1010
latch_t & operator=(const latch_t &)=default
bool is_temp_fsp() const 1
Definition: sync0types.h:1004
virtual std::string locked_from() const =0
bool m_rw_lock
true if it is a rw-lock.
Definition: sync0types.h:1036
latch_id_t get_id() const
Definition: sync0types.h:975
virtual std::string to_string() const =0
Print the latch context.
latch_t(latch_id_t id=LATCH_ID_NONE) 1
Constructor.
Definition: sync0types.h:965
const char * get_name() const 1
Definition: sync0types.h:1016
Define for performance schema registration key.
Definition: sync0sync.h:51
Functor to check for given latching constraints.
Definition: sync0types.h:1157
virtual bool result() const override
Definition: sync0types.h:1195
std::vector< latch_level_t, ut::allocator< latch_level_t > > latches_t
Definition: sync0types.h:1202
bool m_result
Save the result of validation check here True if all OK.
Definition: sync0types.h:1200
sync_allowed_latches(const latch_level_t *from, const latch_level_t *to)
Constructor.
Definition: sync0types.h:1161
latches_t m_latches
List of latch levels that are allowed to be held.
Definition: sync0types.h:1205
sync_allowed_latches()
Default constructor.
Definition: sync0types.h:1165
virtual bool operator()(const latch_level_t level) override
Check whether the given latch_t violates the latch constraint.
Definition: sync0types.h:1174
Subclass this to iterate over a thread's acquired latch levels.
Definition: sync0types.h:1043
virtual bool operator()(const latch_level_t)=0
virtual bool result() const =0
virtual ~sync_check_functor_t()=default
Mutex, the basic synchronization primitive.
LatchMetaData latch_meta
Note: This is accessed without any mutex protection.
Definition: sync0debug.cc:1193
pthread_mutex_t sys_mutex_t
Native mutex.
Definition: sync0types.h:56
LatchMeta< LatchCounter > latch_meta_t
Definition: sync0types.h:871
std::string sync_mutex_to_string(latch_id_t id, const std::string &created)
String representation of the filename and line number where the latch was created.
Definition: sync0sync.cc:235
latch_level_t sync_latch_get_level(latch_id_t id)
Get the latch ordering level.
Definition: sync0types.h:911
const char * sync_latch_get_name(latch_id_t id)
Get the latch name from the latch ID.
Definition: sync0types.h:902
std::vector< latch_meta_t *, ut::allocator< latch_meta_t * > > LatchMetaData
Definition: sync0types.h:873
void sync_file_created_register(const void *ptr, const char *filename, uint16_t line)
Register a latch, called when it is created.
Definition: sync0debug.cc:1646
latch_meta_t & sync_latch_get_meta(latch_id_t id)
Get the latch meta-data from the latch ID.
Definition: sync0types.h:883
latch_id_t
Each latch has an ID.
Definition: sync0types.h:343
@ LATCH_ID_LOG_SN_MUTEX
Definition: sync0types.h:379
@ LATCH_ID_LOG_WRITE_NOTIFIER
Definition: sync0types.h:384
@ LATCH_ID_DBLR
Definition: sync0types.h:462
@ LATCH_ID_DICT_TABLE
Definition: sync0types.h:361
@ LATCH_ID_FILE_OPEN
Definition: sync0types.h:457
@ LATCH_ID_SRV_INNODB_MONITOR
Definition: sync0types.h:412
@ LATCH_ID_LOG_CHECKPOINTER
Definition: sync0types.h:380
@ LATCH_ID_RTR_SSN_MUTEX
Definition: sync0types.h:407
@ LATCH_ID_WORK_QUEUE
Definition: sync0types.h:436
@ LATCH_ID_CLONE_TASK
Definition: sync0types.h:459
@ LATCH_ID_TRX_POOL_MANAGER
Definition: sync0types.h:418
@ LATCH_ID_LOG_WRITER
Definition: sync0types.h:382
@ LATCH_ID_BUF_POOL_ZIP
Definition: sync0types.h:349
@ LATCH_ID_LOCK_FREE_HASH
Definition: sync0types.h:373
@ LATCH_ID_FTS_DOC_ID
Definition: sync0types.h:367
@ LATCH_ID_LOG_LIMITS
Definition: sync0types.h:386
@ LATCH_ID_DBLWR_SPACE_CACHE
Definition: sync0types.h:356
@ LATCH_ID_TEST_MUTEX
Definition: sync0types.h:465
@ LATCH_ID_BUF_POOL_ZIP_HASH
Definition: sync0types.h:353
@ LATCH_ID_LOCK_SYS_PAGE
Definition: sync0types.h:375
@ LATCH_ID_LOG_SN
Definition: sync0types.h:378
@ LATCH_ID_TRX
Definition: sync0types.h:420
@ LATCH_ID_FLUSH_LIST
Definition: sync0types.h:363
@ LATCH_ID_EVENT_MANAGER
Definition: sync0types.h:427
@ LATCH_ID_TEMP_SPACE_RSEG
Definition: sync0types.h:403
@ LATCH_ID_UNDO_SPACE_RSEG
Definition: sync0types.h:404
@ LATCH_ID_BUF_CHUNK_MAP_LATCH
Definition: sync0types.h:454
@ LATCH_ID_DICT_PERSIST_CHECKPOINT
Definition: sync0types.h:397
@ LATCH_ID_LOCK_SYS_GLOBAL
Definition: sync0types.h:374
@ LATCH_ID_LOG_ARCH
Definition: sync0types.h:390
@ LATCH_ID_DICT_PERSIST_DIRTY_TABLES
Definition: sync0types.h:395
@ LATCH_ID_RW_LOCK_LIST
Definition: sync0types.h:411
@ LATCH_ID_IBUF_BITMAP
Definition: sync0types.h:370
@ LATCH_ID_RECV_SYS
Definition: sync0types.h:401
@ LATCH_ID_DICT_TABLE_STATS
Definition: sync0types.h:452
@ LATCH_ID_FTS_CACHE
Definition: sync0types.h:446
@ LATCH_ID_IBUF_INDEX_TREE
Definition: sync0types.h:450
@ LATCH_ID_DICT_FOREIGN_ERR
Definition: sync0types.h:359
@ LATCH_ID_PERSIST_AUTOINC
Definition: sync0types.h:396
@ LATCH_ID_UNDO_SPACES
Definition: sync0types.h:443
@ LATCH_ID_LOG_FILES
Definition: sync0types.h:387
@ LATCH_ID_FTS_OPTIMIZE
Definition: sync0types.h:366
@ LATCH_ID_RTR_ACTIVE_MUTEX
Definition: sync0types.h:408
@ LATCH_ID_PURGE_SYS_PQ
Definition: sync0types.h:399
@ LATCH_ID_MASTER_KEY_ID_MUTEX
Definition: sync0types.h:456
@ LATCH_ID_PAGE_ARCH
Definition: sync0types.h:391
@ LATCH_ID_RW_LOCK_DEBUG
Definition: sync0types.h:406
@ LATCH_ID_IBUF_PESSIMISTIC_INSERT
Definition: sync0types.h:372
@ LATCH_ID_TRX_SYS
Definition: sync0types.h:421
@ LATCH_ID_AHI_ENABLED
Definition: sync0types.h:345
@ LATCH_ID_FIL_SHARD
Definition: sync0types.h:362
@ LATCH_ID_OS_AIO_WRITE_MUTEX
Definition: sync0types.h:432
@ LATCH_ID_TRX_UNDO
Definition: sync0types.h:416
@ LATCH_ID_TRX_I_S_CACHE
Definition: sync0types.h:448
@ LATCH_ID_UNDO_DDL
Definition: sync0types.h:444
@ LATCH_ID_BTR_SEARCH
Definition: sync0types.h:437
@ LATCH_ID_HASH_TABLE_MUTEX
Definition: sync0types.h:369
@ LATCH_ID_PAGE_ARCH_CLIENT
Definition: sync0types.h:393
@ LATCH_ID_ROW_DROP_LIST
Definition: sync0types.h:434
@ LATCH_ID_RECV_WRITER
Definition: sync0types.h:402
@ LATCH_ID_CLONE_SNAPSHOT
Definition: sync0types.h:460
@ LATCH_ID_TRX_PURGE
Definition: sync0types.h:449
@ LATCH_ID_TRX_POOL
Definition: sync0types.h:417
@ LATCH_ID_INDEX_TREE
Definition: sync0types.h:451
@ LATCH_ID_RTR_MATCH_MUTEX
Definition: sync0types.h:409
@ LATCH_ID_BUF_BLOCK_DEBUG
Definition: sync0types.h:439
@ LATCH_ID_MAX
Definition: sync0types.h:466
@ LATCH_ID_SRV_MISC_TMPFILE
Definition: sync0types.h:413
@ LATCH_ID_TRX_SYS_SERIALISATION
Definition: sync0types.h:423
@ LATCH_ID_BUF_POOL_CHUNKS
Definition: sync0types.h:348
@ LATCH_ID_HASH_TABLE_RW_LOCK
Definition: sync0types.h:453
@ LATCH_ID_CACHE_LAST_READ
Definition: sync0types.h:358
@ LATCH_ID_BUF_POOL_ZIP_FREE
Definition: sync0types.h:352
@ LATCH_ID_LOG_FLUSHER
Definition: sync0types.h:383
@ LATCH_ID_CLONE_SYS
Definition: sync0types.h:458
@ LATCH_ID_OS_AIO_IBUF_MUTEX
Definition: sync0types.h:433
@ LATCH_ID_PAGE_ARCH_OPER
Definition: sync0types.h:392
@ LATCH_ID_TRX_SYS_RSEG
Definition: sync0types.h:405
@ LATCH_ID_FTS_BG_THREADS
Definition: sync0types.h:364
@ LATCH_ID_SRV_SYS_TASKS
Definition: sync0types.h:425
@ LATCH_ID_RECALC_POOL
Definition: sync0types.h:400
@ LATCH_ID_LOCK_SYS_WAIT
Definition: sync0types.h:377
@ LATCH_ID_SYNC_DEBUG_MUTEX
Definition: sync0types.h:455
@ LATCH_ID_PARSER
Definition: sync0types.h:389
@ LATCH_ID_DBLWR
Definition: sync0types.h:355
@ LATCH_ID_LOG_CLOSER
Definition: sync0types.h:381
@ LATCH_ID_CHECKPOINT
Definition: sync0types.h:441
@ LATCH_ID_INDEX_ONLINE_LOG
Definition: sync0types.h:435
@ LATCH_ID_BUF_BLOCK_MUTEX
Definition: sync0types.h:347
@ LATCH_ID_FTS_DELETE
Definition: sync0types.h:365
@ LATCH_ID_DICT_OPERATION
Definition: sync0types.h:440
@ LATCH_ID_AUTOINC
Definition: sync0types.h:346
@ LATCH_ID_REDO_LOG_ARCHIVE_QUEUE_MUTEX
Definition: sync0types.h:464
@ LATCH_ID_LOG_GOVERNOR_MUTEX
Definition: sync0types.h:388
@ LATCH_ID_NONE
Definition: sync0types.h:344
@ LATCH_ID_LOG_FLUSH_NOTIFIER
Definition: sync0types.h:385
@ LATCH_ID_SYNC_THREAD
Definition: sync0types.h:415
@ LATCH_ID_IBUF
Definition: sync0types.h:371
@ LATCH_ID_LOCK_SYS_TABLE
Definition: sync0types.h:376
@ LATCH_ID_FTS_CACHE_INIT
Definition: sync0types.h:447
@ LATCH_ID_OS_AIO_READ_MUTEX
Definition: sync0types.h:431
@ LATCH_ID_BUF_BLOCK_LOCK
Definition: sync0types.h:438
@ LATCH_ID_FTS_PLL_TOKENIZE
Definition: sync0types.h:368
@ LATCH_ID_FIL_SPACE
Definition: sync0types.h:445
@ LATCH_ID_TEMP_POOL_MANAGER
Definition: sync0types.h:419
@ LATCH_ID_BUF_POOL_LRU_LIST
Definition: sync0types.h:350
@ LATCH_ID_DICT_SYS
Definition: sync0types.h:360
@ LATCH_ID_SYNC_ARRAY_MUTEX
Definition: sync0types.h:429
@ LATCH_ID_TRX_SYS_SHARD
Definition: sync0types.h:422
@ LATCH_ID_REDO_LOG_ARCHIVE_ADMIN_MUTEX
Definition: sync0types.h:463
@ LATCH_ID_PAGE_ZIP_STAT_PER_INDEX
Definition: sync0types.h:426
@ LATCH_ID_BUF_POOL_FLUSH_STATE
Definition: sync0types.h:354
@ LATCH_ID_PERSIST_METADATA_BUFFER
Definition: sync0types.h:394
@ LATCH_ID_PAGE_CLEANER
Definition: sync0types.h:398
@ LATCH_ID_SRV_MONITOR_FILE
Definition: sync0types.h:414
@ LATCH_ID_DDL_AUTOINC
Definition: sync0types.h:357
@ LATCH_ID_SRV_SYS
Definition: sync0types.h:424
@ LATCH_ID_PARALLEL_READ
Definition: sync0types.h:461
@ LATCH_ID_RSEGS
Definition: sync0types.h:442
@ LATCH_ID_RTR_PATH_MUTEX
Definition: sync0types.h:410
@ LATCH_ID_BUF_POOL_FREE_LIST
Definition: sync0types.h:351
@ LATCH_ID_ZIP_PAD_MUTEX
Definition: sync0types.h:430
@ LATCH_ID_EVENT_MUTEX
Definition: sync0types.h:428
latch_meta_t::CounterType * sync_latch_get_counter(latch_id_t id)
Fetch the counter for the latch.
Definition: sync0types.h:893
const char * sync_basename(const char *filename)
Print the filename "basename".
Definition: sync0sync.cc:218
latch_level_t
Latching order levels.
Definition: sync0types.h:201
@ SYNC_TREE_NODE_NEW
Definition: sync0types.h:298
@ SYNC_LOG_WRITER
Definition: sync0types.h:247
@ SYNC_DICT
Definition: sync0types.h:312
@ SYNC_FTS_BG_THREADS
Definition: sync0types.h:240
@ SYNC_BUF_LRU_LIST
Definition: sync0types.h:229
@ SYNC_BUF_BLOCK
Definition: sync0types.h:227
@ SYNC_LOG_FLUSHER
Definition: sync0types.h:245
@ SYNC_LOG_GOVERNOR_MUTEX
Definition: sync0types.h:254
@ SYNC_DICT_AUTOINC_MUTEX
Definition: sync0types.h:311
@ SYNC_IBUF_BITMAP
Definition: sync0types.h:275
@ SYNC_POOL
Definition: sync0types.h:265
@ SYNC_LOG_FILES
Definition: sync0types.h:246
@ SYNC_BUF_CHUNKS
Definition: sync0types.h:230
@ SYNC_STATS_AUTO_RECALC
Definition: sync0types.h:310
@ SYNC_TRX_SYS
Definition: sync0types.h:268
@ SYNC_UNDO_SPACE_RSEG
Definition: sync0types.h:292
@ SYNC_BUF_ZIP_HASH
Definition: sync0types.h:224
@ SYNC_TREE_NODE
Definition: sync0types.h:296
@ SYNC_FSP_PAGE
Definition: sync0types.h:283
@ SYNC_FTS_CACHE_INIT
Definition: sync0types.h:241
@ SYNC_BUF_PAGE_HASH
Definition: sync0types.h:228
@ SYNC_TRX
Definition: sync0types.h:264
@ SYNC_LOG_WRITE_NOTIFIER
Definition: sync0types.h:248
@ SYNC_POOL_MANAGER
Definition: sync0types.h:266
@ SYNC_BUF_ZIP_FREE
Definition: sync0types.h:226
@ SYNC_FTS_TOKENIZE
Definition: sync0types.h:238
@ SYNC_MUTEX
Definition: sync0types.h:204
@ SYNC_TRX_SYS_SERIALISATION
Definition: sync0types.h:261
@ SYNC_PURGE_QUEUE
Definition: sync0types.h:262
@ SYNC_BUF_FLUSH_LIST
Definition: sync0types.h:222
@ SYNC_UNDO_SPACES
Definition: sync0types.h:301
@ SYNC_LOG_CLOSER
Definition: sync0types.h:250
@ SYNC_RSEG_ARRAY_HEADER
Definition: sync0types.h:287
@ SYNC_RECV_WRITER
Definition: sync0types.h:325
@ SYNC_FTS_CACHE
Definition: sync0types.h:314
@ SYNC_LOG_ARCH
Definition: sync0types.h:257
@ RW_LOCK_SX
Definition: sync0types.h:206
@ SYNC_LOCK_SYS_GLOBAL
Definition: sync0types.h:270
@ SYNC_DICT_HEADER
Definition: sync0types.h:308
@ SYNC_LOCK_SYS_SHARDED
Definition: sync0types.h:269
@ SYNC_PAGE_CLEANER
Definition: sync0types.h:259
@ SYNC_RSEG_HEADER
Definition: sync0types.h:289
@ SYNC_LOG_LIMITS
Definition: sync0types.h:244
@ SYNC_LEVEL_VARYING
Level is varying.
Definition: sync0types.h:331
@ SYNC_TRX_UNDO_PAGE
Definition: sync0types.h:288
@ SYNC_FIL_SHARD
Definition: sync0types.h:218
@ SYNC_TRX_SYS_SHARD
Definition: sync0types.h:267
@ SYNC_RECV
Definition: sync0types.h:242
@ SYNC_IBUF_PESS_INSERT_MUTEX
Definition: sync0types.h:306
@ SYNC_PERSIST_AUTOINC
Definition: sync0types.h:304
@ SYNC_TABLE
Definition: sync0types.h:309
@ SYNC_PAGE_ARCH
Definition: sync0types.h:255
@ SYNC_LOG_CHECKPOINTER
Definition: sync0types.h:251
@ SYNC_BUF_FLUSH_STATE
Definition: sync0types.h:223
@ SYNC_FSP
Definition: sync0types.h:284
@ SYNC_TRX_UNDO
Definition: sync0types.h:294
@ SYNC_TRX_I_S_LAST_READ
Definition: sync0types.h:321
@ SYNC_NO_ORDER_CHECK
This can be used to suppress order checking.
Definition: sync0types.h:334
@ SYNC_EXTERN_STORAGE
Definition: sync0types.h:286
@ SYNC_BUF_FREE_LIST
Definition: sync0types.h:225
@ SYNC_PARSER
Definition: sync0types.h:313
@ SYNC_IBUF_MUTEX
Definition: sync0types.h:281
@ SYNC_IBUF_HEADER
Definition: sync0types.h:307
@ SYNC_LOG_SN_MUTEX
Definition: sync0types.h:253
@ SYNC_LOCK_FREE_HASH
Definition: sync0types.h:212
@ SYNC_TRX_I_S_RWLOCK
Definition: sync0types.h:323
@ RW_LOCK_S
Definition: sync0types.h:208
@ SYNC_TEMP_SPACE_RSEG
Definition: sync0types.h:291
@ SYNC_TREE_NODE_FROM_HASH
Definition: sync0types.h:297
@ SYNC_PURGE_LATCH
Definition: sync0types.h:295
@ SYNC_MONITOR_MUTEX
Definition: sync0types.h:214
@ SYNC_PERSIST_DIRTY_TABLES
Definition: sync0types.h:303
@ SYNC_LOCK_WAIT_SYS
Definition: sync0types.h:271
@ SYNC_LOG_FLUSH_NOTIFIER
Definition: sync0types.h:249
@ SYNC_INDEX_ONLINE_LOG
Definition: sync0types.h:273
@ SYNC_TEMP_POOL_MANAGER
Definition: sync0types.h:285
@ SYNC_ANY_LATCH
Definition: sync0types.h:216
@ SYNC_FTS_OPTIMIZE
Definition: sync0types.h:239
@ SYNC_PAGE_ARCH_OPER
Definition: sync0types.h:220
@ SYNC_RSEG_HEADER_NEW
Definition: sync0types.h:290
@ SYNC_UNDO_DDL
Definition: sync0types.h:315
@ SYNC_IBUF_INDEX_TREE
Definition: sync0types.h:279
@ SYNC_DICT_OPERATION
Definition: sync0types.h:317
@ SYNC_TRX_SYS_HEADER
Definition: sync0types.h:260
@ SYNC_RSEGS
Definition: sync0types.h:300
@ SYNC_IBUF_TREE_NODE_NEW
Definition: sync0types.h:278
@ RW_LOCK_X
Definition: sync0types.h:209
@ SYNC_IBUF_TREE_NODE
Definition: sync0types.h:277
@ SYNC_THREADS
Definition: sync0types.h:263
@ SYNC_LEVEL_MAX
Maximum level value.
Definition: sync0types.h:337
@ SYNC_WORK_QUEUE
Definition: sync0types.h:236
@ SYNC_DBLWR
Definition: sync0types.h:232
@ RW_LOCK_NOT_LOCKED
Definition: sync0types.h:210
@ RW_LOCK_X_WAIT
Definition: sync0types.h:207
@ SYNC_PAGE_ARCH_CLIENT
Definition: sync0types.h:256
@ SYNC_IBUF_BITMAP_MUTEX
Definition: sync0types.h:276
@ SYNC_INDEX_TREE
Definition: sync0types.h:299
@ SYNC_SEARCH_SYS
Definition: sync0types.h:234
@ SYNC_TRX_SYS_RSEG
Definition: sync0types.h:293
@ SYNC_LOG_SN
Definition: sync0types.h:252
@ SYNC_AHI_ENABLED
Definition: sync0types.h:319
@ SYNC_UNKNOWN
Definition: sync0types.h:202
void sync_file_created_deregister(const void *ptr)
Deregister a latch, called when it is destroyed.
Definition: sync0debug.cc:1653
rw_lock_flag_t
Definition: sync0types.h:1211
@ RW_LOCK_FLAG_X
Definition: sync0types.h:1213
@ RW_LOCK_FLAG_SX
Definition: sync0types.h:1214
@ RW_LOCK_FLAG_S
Definition: sync0types.h:1212
mysql_pfs_key_t sync_latch_get_pfs_key(latch_id_t id)
Get the latch PFS key from the latch ID.
Definition: sync0types.h:921
bool innodb_calling_exit
Set when InnoDB has invoked exit().
Definition: srv0srv.cc:228
std::string sync_file_created_get(const void *ptr)
Get the string where the file was created.
Definition: sync0debug.cc:1660
ulint rw_lock_flags_t
Definition: sync0types.h:1208
Version control for database, common definitions, and include files.
#define UNIV_PFS_MUTEX
Definition: univ.i:131
#define UNIV_NOTHROW
Definition: univ.i:456
unsigned long int ulint
Definition: univ.i:406
Counter utility class.
#define ut_error
Abort execution.
Definition: ut0dbg.h:101
#define ut_ad(EXPR)
Debug assertion.
Definition: ut0dbg.h:105
#define ut_d(EXPR)
Debug statement.
Definition: ut0dbg.h:107
#define ut_a(EXPR)
Abort execution if EXPR does not evaluate to nonzero.
Definition: ut0dbg.h:93
Base of InnoDB utilities.
Dynamic memory allocation routines and custom allocators specifically crafted to support memory instr...
#define UT_NEW_THIS_FILE_PSI_KEY
Definition: ut0new.h:565
unsigned long id[MAX_DEAD]
Definition: xcom_base.cc:510