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