MySQL 8.3.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
257
271
273
279
281
301
304
315
317
319
321
323
325
326 /** Level is varying. Only used with buffer pool page locks, which
327 do not have a fixed level, but instead have their level set after
328 the page is locked; see e.g. ibuf_bitmap_get_map_page(). */
329
331
332 /** This can be used to suppress order checking. */
334
335 /** Maximum level value */
338
339/** Each latch has an ID. This id is used for creating the latch and to look
340up its meta-data. See sync0debug.c. The order does not matter here, but
341alphabetical ordering seems useful */
467
468/** OS mutex, without any policy. It is a thin wrapper around the
469system mutexes. The interface is different from the policy mutexes,
470to ensure that it is called directly and not confused with the
471policy mutexes. */
472struct OSMutex {
473 /** Constructor */
475
476 /** Create the mutex by calling the system functions. */
478 ut_ad(m_freed);
479
480#ifdef _WIN32
481 InitializeCriticalSection((LPCRITICAL_SECTION)&m_mutex);
482#else
483 {
484 int ret = pthread_mutex_init(&m_mutex, nullptr);
485 ut_a(ret == 0);
486 }
487#endif /* _WIN32 */
488
489 ut_d(m_freed = false);
490 }
491
492 /** Destructor */
493 ~OSMutex() = default;
494
495 /** Destroy the mutex */
498#ifdef _WIN32
499 DeleteCriticalSection((LPCRITICAL_SECTION)&m_mutex);
500#else
501 int ret;
502
503 ret = pthread_mutex_destroy(&m_mutex);
504
505 if (ret != 0) {
506#ifdef UNIV_NO_ERR_MSGS
507 ib::error()
508#else
509 ib::error(ER_IB_MSG_1372)
510#endif
511 << "Return value " << ret << " when calling pthread_mutex_destroy().";
512 }
513#endif /* _WIN32 */
514 ut_d(m_freed = true);
515 }
516
517 /** Release the mutex. */
520#ifdef _WIN32
521 LeaveCriticalSection(&m_mutex);
522#else
523 int ret = pthread_mutex_unlock(&m_mutex);
524 ut_a(ret == 0);
525#endif /* _WIN32 */
526 }
527
528 /** Acquire the mutex. */
531#ifdef _WIN32
532 EnterCriticalSection((LPCRITICAL_SECTION)&m_mutex);
533#else
534 int ret = pthread_mutex_lock(&m_mutex);
535 ut_a(ret == 0);
536#endif /* _WIN32 */
537 }
538
539 void lock() { enter(); }
540 void unlock() { exit(); }
541
542 /** @return true if locking succeeded */
545#ifdef _WIN32
546 return (TryEnterCriticalSection(&m_mutex) != 0);
547#else
548 return (pthread_mutex_trylock(&m_mutex) == 0);
549#endif /* _WIN32 */
550 }
551
552 /** Required for os_event_t */
553 operator sys_mutex_t *() UNIV_NOTHROW { return (&m_mutex); }
554
555#if defined(UNIV_LIBRARY) && defined(UNIV_DEBUG)
556 bool is_owned() {
557 /* This should never be reached. This is
558 added to fix is_owned() compilation errors
559 for library. We will never reach here because
560 mutexes are disabled in library. */
561 ut_error;
562 return (false);
563 }
564#endif /* UNIV_LIBRARY && UNIV_DEBUG */
565
566 private:
567#ifdef UNIV_DEBUG
568 /** true if the mutex has been freed/destroyed. */
570#endif /* UNIV_DEBUG */
571
573};
574
575#ifndef UNIV_LIBRARY
576#ifdef UNIV_PFS_MUTEX
577/** Latch element
578Used for mutexes which have PFS keys defined under UNIV_PFS_MUTEX.
579@param[in] id Latch id
580@param[in] level Latch level
581@param[in] key PFS key */
582#define LATCH_ADD_MUTEX(id, level, key) \
583 latch_meta[LATCH_ID_##id] = ut::new_withkey<latch_meta_t>( \
584 UT_NEW_THIS_FILE_PSI_KEY, LATCH_ID_##id, #id, level, #level, key)
585
586#ifdef UNIV_PFS_RWLOCK
587/** Latch element.
588Used for rwlocks which have PFS keys defined under UNIV_PFS_RWLOCK.
589@param[in] id Latch id
590@param[in] level Latch level
591@param[in] key PFS key */
592#define LATCH_ADD_RWLOCK(id, level, key) \
593 latch_meta[LATCH_ID_##id] = ut::new_withkey<latch_meta_t>( \
594 UT_NEW_THIS_FILE_PSI_KEY, LATCH_ID_##id, #id, level, #level, key)
595#else
596#define LATCH_ADD_RWLOCK(id, level, key) \
597 latch_meta[LATCH_ID_##id] = \
598 ut::new_withkey<latch_meta_t>(UT_NEW_THIS_FILE_PSI_KEY, LATCH_ID_##id, \
599 #id, level, #level, PSI_NOT_INSTRUMENTED)
600#endif /* UNIV_PFS_RWLOCK */
601
602#else
603#define LATCH_ADD_MUTEX(id, level, key) \
604 latch_meta[LATCH_ID_##id] = ut::new_withkey<latch_meta_t>( \
605 UT_NEW_THIS_FILE_PSI_KEY, LATCH_ID_##id, #id, level, #level)
606#define LATCH_ADD_RWLOCK(id, level, key) \
607 latch_meta[LATCH_ID_##id] = ut::new_withkey<latch_meta_t>( \
608 UT_NEW_THIS_FILE_PSI_KEY, LATCH_ID_##id, #id, level, #level)
609#endif /* UNIV_PFS_MUTEX */
610
611/** Default latch counter */
613 public:
614 /** The counts we collect for a mutex */
615 struct Count {
616 /** Constructor */
618 /* No op */
619 }
620
621 /** Rest the values to zero */
623 m_spins = 0;
624 m_waits = 0;
625 m_calls = 0;
626 }
627
628 /** Number of spins trying to acquire the latch. */
629 uint32_t m_spins;
630
631 /** Number of waits trying to acquire the latch */
632 uint32_t m_waits;
633
634 /** Number of times it was called */
635 uint32_t m_calls;
636
637 /** true if enabled */
639 };
640
641 /** Constructor */
643
644 /** Destructor */
647
648 for (Count *count : m_counters) {
650 }
651 }
652
653 /** Reset all counters to zero. It is not protected by any
654 mutex and we don't care about atomicity. Unless it is a
655 demonstrated problem. The information collected is not
656 required for the correct functioning of the server. */
658 m_mutex.enter();
659
660 for (Count *count : m_counters) {
661 count->reset();
662 }
663
664 m_mutex.exit();
665 }
666
667 /** @return the aggregate counter */
669 m_mutex.enter();
670
671 Count *count;
672
673 if (m_counters.empty()) {
674 count = ut::new_withkey<Count>(UT_NEW_THIS_FILE_PSI_KEY);
675 m_counters.push_back(count);
676 } else {
677 ut_a(m_counters.size() == 1);
678 count = m_counters[0];
679 }
680
681 m_mutex.exit();
682
683 return (count);
684 }
685
686 /** Deregister the count. We don't do anything
687 @param[in] count The count instance to deregister */
689 [[maybe_unused]]) const UNIV_NOTHROW { /* Do nothing */
690 }
691
692 /** Register a single instance counter */
694 m_mutex.enter();
695
696 m_counters.push_back(count);
697
698 m_mutex.exit();
699 }
700
701 /** Deregister a single instance counter
702 @param[in] count The count instance to deregister */
704 m_mutex.enter();
705
706 m_counters.erase(std::remove(m_counters.begin(), m_counters.end(), count),
707 m_counters.end());
708
709 m_mutex.exit();
710 }
711
712 /** Iterate over the counters */
713 template <typename Callback>
714 void iterate(Callback &&callback) const UNIV_NOTHROW {
715 m_mutex.enter();
716 for (const Count *count : m_counters) {
717 std::forward<Callback>(callback)(count);
718 }
719 m_mutex.exit();
720 }
721
722 /** Disable the monitoring */
724 m_mutex.enter();
725
726 for (Count *count : m_counters) {
727 count->m_enabled = true;
728 }
729
730 m_active = true;
731
732 m_mutex.exit();
733 }
734
735 /** Disable the monitoring */
737 m_mutex.enter();
738
739 for (Count *count : m_counters) {
740 count->m_enabled = false;
741 }
742
743 m_active = false;
744
745 m_mutex.exit();
746 }
747
748 /** @return if monitoring is active */
749 bool is_enabled() const UNIV_NOTHROW { return (m_active); }
750
751 private:
752 /* Disable copying */
755
756 private:
757 typedef OSMutex Mutex;
758 typedef std::vector<Count *> Counters;
759
760 /** Mutex protecting m_counters */
761 mutable Mutex m_mutex;
762
763 /** Counters for the latches */
765
766 /** if true then we collect the data */
768};
769
770/** Latch meta data */
771template <typename Counter = LatchCounter>
773 public:
775
776#ifdef UNIV_PFS_MUTEX
778#endif /* UNIV_PFS_MUTEX */
779
780 /** Constructor */
783 m_name(),
786#ifdef UNIV_PFS_MUTEX
787 ,
788 m_pfs_key()
789#endif /* UNIV_PFS_MUTEX */
790 {
791 }
792
793 /** Destructor */
794 ~LatchMeta() = default;
795
796 /** Constructor
797 @param[in] id Latch id
798 @param[in] name Latch name
799 @param[in] level Latch level
800 @param[in] level_name Latch level text representation
801 @param[in] key PFS key */
802 LatchMeta(latch_id_t id, const char *name, latch_level_t level,
803 const char *level_name
804#ifdef UNIV_PFS_MUTEX
805 ,
807#endif /* UNIV_PFS_MUTEX */
808 )
809 : m_id(id),
810 m_name(name),
811 m_level(level),
812 m_level_name(level_name)
813#ifdef UNIV_PFS_MUTEX
814 ,
816#endif /* UNIV_PFS_MUTEX */
817 {
818 /* No op */
819 }
820
821 /* Less than operator.
822 @param[in] rhs Instance to compare against
823 @return true if this.get_id() < rhs.get_id() */
824 bool operator<(const LatchMeta &rhs) const {
825 return (get_id() < rhs.get_id());
826 }
827
828 /** @return the latch id */
829 latch_id_t get_id() const { return (m_id); }
830
831 /** @return the latch name */
832 const char *get_name() const { return (m_name); }
833
834 /** @return the latch level */
835 latch_level_t get_level() const { return (m_level); }
836
837 /** @return the latch level name */
838 const char *get_level_name() const { return (m_level_name); }
839
840#ifdef UNIV_PFS_MUTEX
841 /** @return the PFS key for the latch */
842 pfs_key_t get_pfs_key() const { return (m_pfs_key); }
843#endif /* UNIV_PFS_MUTEX */
844
845 /** @return the counter instance */
846 Counter *get_counter() { return (&m_counter); }
847
848 private:
849 /** Latch id */
851
852 /** Latch name */
853 const char *m_name;
854
855 /** Latch level in the ordering */
857
858 /** Latch level text representation */
859 const char *m_level_name;
860
861#ifdef UNIV_PFS_MUTEX
862 /** PFS key */
864#endif /* UNIV_PFS_MUTEX */
865
866 /** For gathering latch statistics */
868};
869
871typedef std::vector<latch_meta_t *, ut::allocator<latch_meta_t *>>
873
874/** Note: This is accessed without any mutex protection. It is initialised
875at startup and elements should not be added to or removed from it after
876that. See sync_latch_meta_init() */
878
879/** Get the latch meta-data from the latch ID
880@param[in] id Latch ID
881@return the latch meta data */
883 ut_ad(static_cast<size_t>(id) < latch_meta.size());
884 ut_ad(id == latch_meta[id]->get_id());
885
886 return (*latch_meta[id]);
887}
888
889/** Fetch the counter for the latch
890@param[in] id Latch ID
891@return the latch counter */
894
895 return (meta.get_counter());
896}
897
898/** Get the latch name from the latch ID
899@param[in] id Latch ID
900@return the name, will assert if not found */
901inline const char *sync_latch_get_name(latch_id_t id) {
902 const latch_meta_t &meta = sync_latch_get_meta(id);
903
904 return (meta.get_name());
905}
906
907/** Get the latch ordering level
908@param[in] id Latch id to lookup
909@return the latch level */
911 const latch_meta_t &meta = sync_latch_get_meta(id);
912
913 return (meta.get_level());
914}
915
916#ifdef UNIV_PFS_MUTEX
917/** Get the latch PFS key from the latch ID
918@param[in] id Latch ID
919@return the PFS key */
921 const latch_meta_t &meta = sync_latch_get_meta(id);
922
923 return (meta.get_pfs_key());
924}
925#endif /* UNIV_PFS_MUTEX */
926
927#ifndef UNIV_HOTBACKUP
928/** String representation of the filename and line number where the
929latch was created
930@param[in] id Latch ID
931@param[in] created Filename and line number where it was created
932@return the string representation */
933std::string sync_mutex_to_string(latch_id_t id, const std::string &created);
934
935/** Print the filename "basename"
936@return the basename */
937const char *sync_basename(const char *filename);
938#endif /* !UNIV_HOTBACKUP */
939
940/** Register a latch, called when it is created
941@param[in] ptr Latch instance that was created
942@param[in] filename Filename where it was created
943@param[in] line Line number in filename */
944void sync_file_created_register(const void *ptr, const char *filename,
945 uint16_t line);
946
947/** Deregister a latch, called when it is destroyed
948@param[in] ptr Latch to be destroyed */
949void sync_file_created_deregister(const void *ptr);
950
951/** Get the string where the file was created. Its format is "name:line"
952@param[in] ptr Latch instance
953@return created information or "" if can't be found */
954std::string sync_file_created_get(const void *ptr);
955
956#endif /* !UNIV_LIBRARY */
957
958#ifdef UNIV_DEBUG
959
960/** All (ordered) latches, used in debugging, must derive from this class. */
961struct latch_t {
962 /** Constructor
963 @param[in] id The latch ID */
965 m_rw_lock(),
966 m_temp_fsp() {}
967
968 latch_t &operator=(const latch_t &) = default;
969
970 /** Destructor */
971 virtual ~latch_t() UNIV_NOTHROW = default;
972
973 /** @return the latch ID */
974 latch_id_t get_id() const { return (m_id); }
975
976 /** @return true if it is a rw-lock */
977 bool is_rw_lock() const UNIV_NOTHROW { return (m_rw_lock); }
978
979 /** Print the latch context
980 @return the string representation */
981 virtual std::string to_string() const = 0;
982
983 /** @return "filename:line" from where the latch was last locked */
984 virtual std::string locked_from() const = 0;
985
986 /** @return the latch level */
989
990#ifndef UNIV_LIBRARY
991 return (sync_latch_get_level(m_id));
992#else
993 /* This should never be reached. This is
994 added to fix compilation errors
995 for library. We will never reach here because
996 mutexes are disabled in library. */
997 ut_error;
998 return (SYNC_UNKNOWN);
999#endif /* !UNIV_LIBRARY */
1000 }
1001
1002 /** @return true if the latch is for a temporary file space*/
1003 bool is_temp_fsp() const UNIV_NOTHROW { return (m_temp_fsp); }
1004
1005 /** Set the temporary tablespace flag. The latch order constraints
1006 are different for intrinsic tables. We don't always acquire the
1007 index->lock. We need to figure out the context and add some special
1008 rules during the checks. */
1011 m_temp_fsp = true;
1012 }
1013
1014 /** @return the latch name, m_id must be set */
1015 const char *get_name() const UNIV_NOTHROW {
1017
1018#ifndef UNIV_LIBRARY
1019 return (sync_latch_get_name(m_id));
1020#else
1021 /* This should never be reached. This is
1022 added to fix compilation errors
1023 for library. We will never reach here because
1024 mutexes are disabled in library. */
1025 ut_error;
1026 return (nullptr);
1027#endif /* !UNIV_LIBRARY */
1028 }
1029
1030 /** Latch ID */
1032
1033 /** true if it is a rw-lock. In debug mode, rw_lock_t derives from
1034 this class and sets this variable. */
1036
1037 /** true if it is an temporary space latch */
1039};
1040
1041/** Subclass this to iterate over a thread's acquired latch levels. */
1043 virtual ~sync_check_functor_t() = default;
1044 virtual bool operator()(const latch_level_t) = 0;
1045 virtual bool result() const = 0;
1046};
1047
1048/** Functor to check whether the calling thread owns the btr search mutex. */
1050 /** Constructor
1051 @param[in] has_search_latch true if owns the latch */
1052 explicit btrsea_sync_check(bool has_search_latch)
1053 : m_result(), m_has_search_latch(has_search_latch) {}
1054
1055 /** Destructor */
1056 ~btrsea_sync_check() override = default;
1057
1058 /** Called for every latch owned by the calling thread.
1059 @param[in] level Level of the existing latch
1060 @return true if the predicate check fails */
1061 bool operator()(const latch_level_t level) override {
1062 /* If calling thread doesn't hold search latch then
1063 check if there are latch level exception provided.
1064
1065 Note: Optimizer has added InnoDB intrinsic table as an
1066 alternative to MyISAM intrinsic table. With this a new
1067 control flow comes into existence, it is:
1068
1069 Server -> Plugin -> SE
1070
1071 Plugin in this case is I_S which is sharing the latch vector
1072 of InnoDB and so there could be lock conflicts. Ideally
1073 the Plugin should use a difference namespace latch vector
1074 as it doesn't have any dependency with SE latching protocol.
1075
1076 Added check that will allow thread to hold I_S latches */
1077
1078 if (!m_has_search_latch &&
1079 (level != SYNC_SEARCH_SYS && level != SYNC_DICT &&
1080 level != SYNC_FTS_CACHE && level != SYNC_UNDO_DDL &&
1081 level != SYNC_DICT_OPERATION && level != SYNC_TRX_I_S_LAST_READ &&
1082 level != SYNC_TRX_I_S_RWLOCK)) {
1083 m_result = true;
1084#ifdef UNIV_NO_ERR_MSGS
1085 ib::error()
1086#else
1087 ib::error(ER_IB_MSG_1373)
1088#endif
1089 << "Debug: Calling thread does not hold search "
1090 "latch but does hold latch level "
1091 << level << ".";
1092
1093 return (m_result);
1094 }
1095
1096 return (false);
1097 }
1098
1099 /** @return result from the check */
1100 bool result() const override { return (m_result); }
1101
1102 private:
1103 /** True if all OK */
1105
1106 /** If the caller owns the search latch */
1108};
1109
1110/** Functor to check for dictionary latching constraints. */
1112 /** Constructor
1113 @param[in] dict_mutex_allowed true if the dict mutex
1114 is allowed */
1115 explicit dict_sync_check(bool dict_mutex_allowed)
1116 : m_result(), m_dict_mutex_allowed(dict_mutex_allowed) {}
1117
1118 /** Destructor */
1119 ~dict_sync_check() override = default;
1120
1121 /** Check the latching constraints
1122 @param[in] level The level held by the thread */
1123 bool operator()(const latch_level_t level) override {
1124 if (!m_dict_mutex_allowed ||
1125 (level != SYNC_DICT && level != SYNC_UNDO_SPACES &&
1126 level != SYNC_FTS_CACHE && level != SYNC_DICT_OPERATION &&
1127 /* This only happens in recv_apply_hashed_log_recs. */
1128 level != SYNC_RECV_WRITER && level != SYNC_NO_ORDER_CHECK)) {
1129 m_result = true;
1130#ifdef UNIV_NO_ERR_MSGS
1131 ib::error()
1132#else
1133 ib::error(ER_IB_MSG_1374)
1134#endif
1135 << "Debug: Dictionary latch order violation for level " << level
1136 << ".";
1137
1138 return (true);
1139 }
1140
1141 return (false);
1142 }
1143
1144 /** @return the result of the check */
1145 virtual bool result() const override { return (m_result); }
1146
1147 private:
1148 /** True if all OK */
1150
1151 /** True if it is OK to hold the dict mutex */
1153};
1154
1155/** Functor to check for given latching constraints. */
1157 /** Constructor
1158 @param[in] from first element in an array of latch_level_t
1159 @param[in] to last element in an array of latch_level_t */
1161 : m_result(), m_latches(from, to) {}
1162
1163 /** Default constructor. The list of allowed latches is empty. */
1165
1166 /** Check whether the given latch_t violates the latch constraint.
1167 This object maintains a list of allowed latch levels, and if the given
1168 latch belongs to a latch level that is not there in the allowed list,
1169 then it is a violation.
1170
1171 @param[in] level The latch level to check
1172 @return true if there is a latch ordering violation */
1173 virtual bool operator()(const latch_level_t level) override {
1174 for (latch_level_t allowed_level : m_latches) {
1175 if (level == allowed_level) {
1176 m_result = false;
1177
1178 /* No violation */
1179 return (m_result);
1180 }
1181 }
1182
1183#ifdef UNIV_NO_ERR_MSGS
1184 ib::error()
1185#else
1186 ib::error(ER_IB_MSG_1375)
1187#endif
1188 << "Debug: sync_allowed_latches violation for level=" << level;
1189 m_result = true;
1190 return (m_result);
1191 }
1192
1193 /** @return the result of the check */
1194 virtual bool result() const override { return (m_result); }
1195
1196 private:
1197 /** Save the result of validation check here
1198 True if all OK */
1200
1201 typedef std::vector<latch_level_t, ut::allocator<latch_level_t>> latches_t;
1202
1203 /** List of latch levels that are allowed to be held */
1205};
1206
1208
1209/* Flags to specify lock types for rw_lock_own_flagged() */
1213 RW_LOCK_FLAG_SX = 1 << 2
1215
1216#endif /* UNIV_DBEUG */
1217
1218#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:612
LatchCounter(const LatchCounter &)
bool is_enabled() const 1
Definition: sync0types.h:749
void single_deregister(Count *count) 1
Deregister a single instance counter.
Definition: sync0types.h:703
Counters m_counters
Counters for the latches.
Definition: sync0types.h:764
LatchCounter() 1
Constructor.
Definition: sync0types.h:642
void sum_deregister(Count *count) const 1
Deregister the count.
Definition: sync0types.h:688
void iterate(Callback &&callback) const 1
Iterate over the counters.
Definition: sync0types.h:714
Mutex m_mutex
Mutex protecting m_counters.
Definition: sync0types.h:761
void disable() 1
Disable the monitoring.
Definition: sync0types.h:736
LatchCounter & operator=(const LatchCounter &)
OSMutex Mutex
Definition: sync0types.h:757
~LatchCounter() 1
Destructor.
Definition: sync0types.h:645
bool m_active
if true then we collect the data
Definition: sync0types.h:767
void single_register(Count *count) 1
Register a single instance counter.
Definition: sync0types.h:693
std::vector< Count * > Counters
Definition: sync0types.h:758
void enable() 1
Disable the monitoring.
Definition: sync0types.h:723
void reset() 1
Reset all counters to zero.
Definition: sync0types.h:657
Count * sum_register() 1
Definition: sync0types.h:668
Latch meta data.
Definition: sync0types.h:772
const char * get_level_name() const
Definition: sync0types.h:838
bool operator<(const LatchMeta &rhs) const
Definition: sync0types.h:824
mysql_pfs_key_t pfs_key_t
Definition: sync0types.h:777
Counter * get_counter()
Definition: sync0types.h:846
Counter CounterType
Definition: sync0types.h:774
pfs_key_t get_pfs_key() const
Definition: sync0types.h:842
latch_level_t m_level
Latch level in the ordering.
Definition: sync0types.h:856
pfs_key_t m_pfs_key
PFS key.
Definition: sync0types.h:863
latch_level_t get_level() const
Definition: sync0types.h:835
Counter m_counter
For gathering latch statistics.
Definition: sync0types.h:867
latch_id_t m_id
Latch id.
Definition: sync0types.h:850
~LatchMeta()=default
Destructor.
const char * get_name() const
Definition: sync0types.h:832
latch_id_t get_id() const
Definition: sync0types.h:829
LatchMeta(latch_id_t id, const char *name, latch_level_t level, const char *level_name, pfs_key_t key)
Constructor.
Definition: sync0types.h:802
LatchMeta()
Constructor.
Definition: sync0types.h:781
const char * m_level_name
Latch level text representation.
Definition: sync0types.h:859
const char * m_name
Latch name.
Definition: sync0types.h:853
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:615
uint32_t m_spins
Number of spins trying to acquire the latch.
Definition: sync0types.h:629
void reset() 1
Rest the values to zero.
Definition: sync0types.h:622
uint32_t m_calls
Number of times it was called.
Definition: sync0types.h:635
Count() 1
Constructor.
Definition: sync0types.h:617
uint32_t m_waits
Number of waits trying to acquire the latch.
Definition: sync0types.h:632
bool m_enabled
true if enabled
Definition: sync0types.h:638
OS mutex, without any policy.
Definition: sync0types.h:472
void exit() 1
Release the mutex.
Definition: sync0types.h:518
OSMutex() 1
Constructor.
Definition: sync0types.h:474
bool try_lock() 1
Definition: sync0types.h:543
void enter() 1
Acquire the mutex.
Definition: sync0types.h:529
sys_mutex_t m_mutex
Definition: sync0types.h:572
~OSMutex()=default
Destructor.
void lock()
Definition: sync0types.h:539
bool m_freed
true if the mutex has been freed/destroyed.
Definition: sync0types.h:569
void init() 1
Create the mutex by calling the system functions.
Definition: sync0types.h:477
void unlock()
Definition: sync0types.h:540
void destroy() 1
Destroy the mutex.
Definition: sync0types.h:496
Functor to check whether the calling thread owns the btr search mutex.
Definition: sync0types.h:1049
const bool m_has_search_latch
If the caller owns the search latch.
Definition: sync0types.h:1107
btrsea_sync_check(bool has_search_latch)
Constructor.
Definition: sync0types.h:1052
bool m_result
True if all OK.
Definition: sync0types.h:1104
bool operator()(const latch_level_t level) override
Called for every latch owned by the calling thread.
Definition: sync0types.h:1061
~btrsea_sync_check() override=default
Destructor.
bool result() const override
Definition: sync0types.h:1100
Functor to check for dictionary latching constraints.
Definition: sync0types.h:1111
dict_sync_check(bool dict_mutex_allowed)
Constructor.
Definition: sync0types.h:1115
const bool m_dict_mutex_allowed
True if it is OK to hold the dict mutex.
Definition: sync0types.h:1152
bool m_result
True if all OK.
Definition: sync0types.h:1149
bool operator()(const latch_level_t level) override
Check the latching constraints.
Definition: sync0types.h:1123
~dict_sync_check() override=default
Destructor.
virtual bool result() const override
Definition: sync0types.h:1145
All (ordered) latches, used in debugging, must derive from this class.
Definition: sync0types.h:961
latch_level_t get_level() const 1
Definition: sync0types.h:987
bool is_rw_lock() const 1
Definition: sync0types.h:977
bool m_temp_fsp
true if it is an temporary space latch
Definition: sync0types.h:1038
latch_id_t m_id
Latch ID.
Definition: sync0types.h:1031
virtual ~latch_t() 1=default
Destructor.
void set_temp_fsp() 1
Set the temporary tablespace flag.
Definition: sync0types.h:1009
latch_t & operator=(const latch_t &)=default
bool is_temp_fsp() const 1
Definition: sync0types.h:1003
virtual std::string locked_from() const =0
bool m_rw_lock
true if it is a rw-lock.
Definition: sync0types.h:1035
latch_id_t get_id() const
Definition: sync0types.h:974
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:964
const char * get_name() const 1
Definition: sync0types.h:1015
Define for performance schema registration key.
Definition: sync0sync.h:50
Functor to check for given latching constraints.
Definition: sync0types.h:1156
virtual bool result() const override
Definition: sync0types.h:1194
std::vector< latch_level_t, ut::allocator< latch_level_t > > latches_t
Definition: sync0types.h:1201
bool m_result
Save the result of validation check here True if all OK.
Definition: sync0types.h:1199
sync_allowed_latches(const latch_level_t *from, const latch_level_t *to)
Constructor.
Definition: sync0types.h:1160
latches_t m_latches
List of latch levels that are allowed to be held.
Definition: sync0types.h:1204
sync_allowed_latches()
Default constructor.
Definition: sync0types.h:1164
virtual bool operator()(const latch_level_t level) override
Check whether the given latch_t violates the latch constraint.
Definition: sync0types.h:1173
Subclass this to iterate over a thread's acquired latch levels.
Definition: sync0types.h:1042
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:1192
pthread_mutex_t sys_mutex_t
Native mutex.
Definition: sync0types.h:55
LatchMeta< LatchCounter > latch_meta_t
Definition: sync0types.h:870
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:234
latch_level_t sync_latch_get_level(latch_id_t id)
Get the latch ordering level.
Definition: sync0types.h:910
const char * sync_latch_get_name(latch_id_t id)
Get the latch name from the latch ID.
Definition: sync0types.h:901
std::vector< latch_meta_t *, ut::allocator< latch_meta_t * > > LatchMetaData
Definition: sync0types.h:872
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:1645
latch_meta_t & sync_latch_get_meta(latch_id_t id)
Get the latch meta-data from the latch ID.
Definition: sync0types.h:882
latch_id_t
Each latch has an ID.
Definition: sync0types.h:342
@ LATCH_ID_LOG_SN_MUTEX
Definition: sync0types.h:378
@ LATCH_ID_LOG_WRITE_NOTIFIER
Definition: sync0types.h:383
@ LATCH_ID_DBLR
Definition: sync0types.h:461
@ LATCH_ID_DICT_TABLE
Definition: sync0types.h:360
@ LATCH_ID_FILE_OPEN
Definition: sync0types.h:456
@ LATCH_ID_SRV_INNODB_MONITOR
Definition: sync0types.h:411
@ LATCH_ID_LOG_CHECKPOINTER
Definition: sync0types.h:379
@ LATCH_ID_RTR_SSN_MUTEX
Definition: sync0types.h:406
@ LATCH_ID_WORK_QUEUE
Definition: sync0types.h:435
@ LATCH_ID_CLONE_TASK
Definition: sync0types.h:458
@ LATCH_ID_TRX_POOL_MANAGER
Definition: sync0types.h:417
@ LATCH_ID_LOG_WRITER
Definition: sync0types.h:381
@ LATCH_ID_BUF_POOL_ZIP
Definition: sync0types.h:348
@ LATCH_ID_LOCK_FREE_HASH
Definition: sync0types.h:372
@ LATCH_ID_FTS_DOC_ID
Definition: sync0types.h:366
@ LATCH_ID_LOG_LIMITS
Definition: sync0types.h:385
@ LATCH_ID_DBLWR_SPACE_CACHE
Definition: sync0types.h:355
@ LATCH_ID_TEST_MUTEX
Definition: sync0types.h:464
@ LATCH_ID_BUF_POOL_ZIP_HASH
Definition: sync0types.h:352
@ LATCH_ID_LOCK_SYS_PAGE
Definition: sync0types.h:374
@ LATCH_ID_LOG_SN
Definition: sync0types.h:377
@ LATCH_ID_TRX
Definition: sync0types.h:419
@ LATCH_ID_FLUSH_LIST
Definition: sync0types.h:362
@ LATCH_ID_EVENT_MANAGER
Definition: sync0types.h:426
@ LATCH_ID_TEMP_SPACE_RSEG
Definition: sync0types.h:402
@ LATCH_ID_UNDO_SPACE_RSEG
Definition: sync0types.h:403
@ LATCH_ID_BUF_CHUNK_MAP_LATCH
Definition: sync0types.h:453
@ LATCH_ID_DICT_PERSIST_CHECKPOINT
Definition: sync0types.h:396
@ LATCH_ID_LOCK_SYS_GLOBAL
Definition: sync0types.h:373
@ LATCH_ID_LOG_ARCH
Definition: sync0types.h:389
@ LATCH_ID_DICT_PERSIST_DIRTY_TABLES
Definition: sync0types.h:394
@ LATCH_ID_RW_LOCK_LIST
Definition: sync0types.h:410
@ LATCH_ID_IBUF_BITMAP
Definition: sync0types.h:369
@ LATCH_ID_RECV_SYS
Definition: sync0types.h:400
@ LATCH_ID_DICT_TABLE_STATS
Definition: sync0types.h:451
@ LATCH_ID_FTS_CACHE
Definition: sync0types.h:445
@ LATCH_ID_IBUF_INDEX_TREE
Definition: sync0types.h:449
@ LATCH_ID_DICT_FOREIGN_ERR
Definition: sync0types.h:358
@ LATCH_ID_PERSIST_AUTOINC
Definition: sync0types.h:395
@ LATCH_ID_UNDO_SPACES
Definition: sync0types.h:442
@ LATCH_ID_LOG_FILES
Definition: sync0types.h:386
@ LATCH_ID_FTS_OPTIMIZE
Definition: sync0types.h:365
@ LATCH_ID_RTR_ACTIVE_MUTEX
Definition: sync0types.h:407
@ LATCH_ID_PURGE_SYS_PQ
Definition: sync0types.h:398
@ LATCH_ID_MASTER_KEY_ID_MUTEX
Definition: sync0types.h:455
@ LATCH_ID_PAGE_ARCH
Definition: sync0types.h:390
@ LATCH_ID_RW_LOCK_DEBUG
Definition: sync0types.h:405
@ LATCH_ID_IBUF_PESSIMISTIC_INSERT
Definition: sync0types.h:371
@ LATCH_ID_TRX_SYS
Definition: sync0types.h:420
@ LATCH_ID_AHI_ENABLED
Definition: sync0types.h:344
@ LATCH_ID_FIL_SHARD
Definition: sync0types.h:361
@ LATCH_ID_OS_AIO_WRITE_MUTEX
Definition: sync0types.h:431
@ LATCH_ID_TRX_UNDO
Definition: sync0types.h:415
@ LATCH_ID_TRX_I_S_CACHE
Definition: sync0types.h:447
@ LATCH_ID_UNDO_DDL
Definition: sync0types.h:443
@ LATCH_ID_BTR_SEARCH
Definition: sync0types.h:436
@ LATCH_ID_HASH_TABLE_MUTEX
Definition: sync0types.h:368
@ LATCH_ID_PAGE_ARCH_CLIENT
Definition: sync0types.h:392
@ LATCH_ID_ROW_DROP_LIST
Definition: sync0types.h:433
@ LATCH_ID_RECV_WRITER
Definition: sync0types.h:401
@ LATCH_ID_CLONE_SNAPSHOT
Definition: sync0types.h:459
@ LATCH_ID_TRX_PURGE
Definition: sync0types.h:448
@ LATCH_ID_TRX_POOL
Definition: sync0types.h:416
@ LATCH_ID_INDEX_TREE
Definition: sync0types.h:450
@ LATCH_ID_RTR_MATCH_MUTEX
Definition: sync0types.h:408
@ LATCH_ID_BUF_BLOCK_DEBUG
Definition: sync0types.h:438
@ LATCH_ID_MAX
Definition: sync0types.h:465
@ LATCH_ID_SRV_MISC_TMPFILE
Definition: sync0types.h:412
@ LATCH_ID_TRX_SYS_SERIALISATION
Definition: sync0types.h:422
@ LATCH_ID_BUF_POOL_CHUNKS
Definition: sync0types.h:347
@ LATCH_ID_HASH_TABLE_RW_LOCK
Definition: sync0types.h:452
@ LATCH_ID_CACHE_LAST_READ
Definition: sync0types.h:357
@ LATCH_ID_BUF_POOL_ZIP_FREE
Definition: sync0types.h:351
@ LATCH_ID_LOG_FLUSHER
Definition: sync0types.h:382
@ LATCH_ID_CLONE_SYS
Definition: sync0types.h:457
@ LATCH_ID_OS_AIO_IBUF_MUTEX
Definition: sync0types.h:432
@ LATCH_ID_PAGE_ARCH_OPER
Definition: sync0types.h:391
@ LATCH_ID_TRX_SYS_RSEG
Definition: sync0types.h:404
@ LATCH_ID_FTS_BG_THREADS
Definition: sync0types.h:363
@ LATCH_ID_SRV_SYS_TASKS
Definition: sync0types.h:424
@ LATCH_ID_RECALC_POOL
Definition: sync0types.h:399
@ LATCH_ID_LOCK_SYS_WAIT
Definition: sync0types.h:376
@ LATCH_ID_SYNC_DEBUG_MUTEX
Definition: sync0types.h:454
@ LATCH_ID_PARSER
Definition: sync0types.h:388
@ LATCH_ID_DBLWR
Definition: sync0types.h:354
@ LATCH_ID_LOG_CLOSER
Definition: sync0types.h:380
@ LATCH_ID_CHECKPOINT
Definition: sync0types.h:440
@ LATCH_ID_INDEX_ONLINE_LOG
Definition: sync0types.h:434
@ LATCH_ID_BUF_BLOCK_MUTEX
Definition: sync0types.h:346
@ LATCH_ID_FTS_DELETE
Definition: sync0types.h:364
@ LATCH_ID_DICT_OPERATION
Definition: sync0types.h:439
@ LATCH_ID_AUTOINC
Definition: sync0types.h:345
@ LATCH_ID_REDO_LOG_ARCHIVE_QUEUE_MUTEX
Definition: sync0types.h:463
@ LATCH_ID_LOG_GOVERNOR_MUTEX
Definition: sync0types.h:387
@ LATCH_ID_NONE
Definition: sync0types.h:343
@ LATCH_ID_LOG_FLUSH_NOTIFIER
Definition: sync0types.h:384
@ LATCH_ID_SYNC_THREAD
Definition: sync0types.h:414
@ LATCH_ID_IBUF
Definition: sync0types.h:370
@ LATCH_ID_LOCK_SYS_TABLE
Definition: sync0types.h:375
@ LATCH_ID_FTS_CACHE_INIT
Definition: sync0types.h:446
@ LATCH_ID_OS_AIO_READ_MUTEX
Definition: sync0types.h:430
@ LATCH_ID_BUF_BLOCK_LOCK
Definition: sync0types.h:437
@ LATCH_ID_FTS_PLL_TOKENIZE
Definition: sync0types.h:367
@ LATCH_ID_FIL_SPACE
Definition: sync0types.h:444
@ LATCH_ID_TEMP_POOL_MANAGER
Definition: sync0types.h:418
@ LATCH_ID_BUF_POOL_LRU_LIST
Definition: sync0types.h:349
@ LATCH_ID_DICT_SYS
Definition: sync0types.h:359
@ LATCH_ID_SYNC_ARRAY_MUTEX
Definition: sync0types.h:428
@ LATCH_ID_TRX_SYS_SHARD
Definition: sync0types.h:421
@ LATCH_ID_REDO_LOG_ARCHIVE_ADMIN_MUTEX
Definition: sync0types.h:462
@ LATCH_ID_PAGE_ZIP_STAT_PER_INDEX
Definition: sync0types.h:425
@ LATCH_ID_BUF_POOL_FLUSH_STATE
Definition: sync0types.h:353
@ LATCH_ID_PERSIST_METADATA_BUFFER
Definition: sync0types.h:393
@ LATCH_ID_PAGE_CLEANER
Definition: sync0types.h:397
@ LATCH_ID_SRV_MONITOR_FILE
Definition: sync0types.h:413
@ LATCH_ID_DDL_AUTOINC
Definition: sync0types.h:356
@ LATCH_ID_SRV_SYS
Definition: sync0types.h:423
@ LATCH_ID_PARALLEL_READ
Definition: sync0types.h:460
@ LATCH_ID_RSEGS
Definition: sync0types.h:441
@ LATCH_ID_RTR_PATH_MUTEX
Definition: sync0types.h:409
@ LATCH_ID_BUF_POOL_FREE_LIST
Definition: sync0types.h:350
@ LATCH_ID_ZIP_PAD_MUTEX
Definition: sync0types.h:429
@ LATCH_ID_EVENT_MUTEX
Definition: sync0types.h:427
latch_meta_t::CounterType * sync_latch_get_counter(latch_id_t id)
Fetch the counter for the latch.
Definition: sync0types.h:892
const char * sync_basename(const char *filename)
Print the filename "basename".
Definition: sync0sync.cc:217
latch_level_t
Latching order levels.
Definition: sync0types.h:200
@ SYNC_TREE_NODE_NEW
Definition: sync0types.h:297
@ SYNC_LOG_WRITER
Definition: sync0types.h:246
@ SYNC_DICT
Definition: sync0types.h:311
@ 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_LOG_GOVERNOR_MUTEX
Definition: sync0types.h:253
@ SYNC_DICT_AUTOINC_MUTEX
Definition: sync0types.h:310
@ SYNC_IBUF_BITMAP
Definition: sync0types.h:274
@ SYNC_POOL
Definition: sync0types.h:264
@ SYNC_LOG_FILES
Definition: sync0types.h:245
@ SYNC_BUF_CHUNKS
Definition: sync0types.h:229
@ SYNC_STATS_AUTO_RECALC
Definition: sync0types.h:309
@ SYNC_TRX_SYS
Definition: sync0types.h:267
@ SYNC_UNDO_SPACE_RSEG
Definition: sync0types.h:291
@ SYNC_BUF_ZIP_HASH
Definition: sync0types.h:223
@ SYNC_TREE_NODE
Definition: sync0types.h:295
@ SYNC_FSP_PAGE
Definition: sync0types.h:282
@ SYNC_FTS_CACHE_INIT
Definition: sync0types.h:240
@ SYNC_BUF_PAGE_HASH
Definition: sync0types.h:227
@ SYNC_TRX
Definition: sync0types.h:263
@ SYNC_LOG_WRITE_NOTIFIER
Definition: sync0types.h:247
@ SYNC_POOL_MANAGER
Definition: sync0types.h:265
@ 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:260
@ SYNC_PURGE_QUEUE
Definition: sync0types.h:261
@ SYNC_BUF_FLUSH_LIST
Definition: sync0types.h:221
@ SYNC_UNDO_SPACES
Definition: sync0types.h:300
@ SYNC_LOG_CLOSER
Definition: sync0types.h:249
@ SYNC_RSEG_ARRAY_HEADER
Definition: sync0types.h:286
@ SYNC_RECV_WRITER
Definition: sync0types.h:324
@ SYNC_FTS_CACHE
Definition: sync0types.h:313
@ SYNC_LOG_ARCH
Definition: sync0types.h:256
@ RW_LOCK_SX
Definition: sync0types.h:205
@ SYNC_LOCK_SYS_GLOBAL
Definition: sync0types.h:269
@ SYNC_DICT_HEADER
Definition: sync0types.h:307
@ SYNC_LOCK_SYS_SHARDED
Definition: sync0types.h:268
@ SYNC_PAGE_CLEANER
Definition: sync0types.h:258
@ SYNC_RSEG_HEADER
Definition: sync0types.h:288
@ SYNC_LOG_LIMITS
Definition: sync0types.h:243
@ SYNC_LEVEL_VARYING
Level is varying.
Definition: sync0types.h:330
@ SYNC_TRX_UNDO_PAGE
Definition: sync0types.h:287
@ SYNC_FIL_SHARD
Definition: sync0types.h:217
@ SYNC_TRX_SYS_SHARD
Definition: sync0types.h:266
@ SYNC_RECV
Definition: sync0types.h:241
@ SYNC_IBUF_PESS_INSERT_MUTEX
Definition: sync0types.h:305
@ SYNC_PERSIST_AUTOINC
Definition: sync0types.h:303
@ SYNC_TABLE
Definition: sync0types.h:308
@ SYNC_PAGE_ARCH
Definition: sync0types.h:254
@ SYNC_LOG_CHECKPOINTER
Definition: sync0types.h:250
@ SYNC_BUF_FLUSH_STATE
Definition: sync0types.h:222
@ SYNC_FSP
Definition: sync0types.h:283
@ SYNC_TRX_UNDO
Definition: sync0types.h:293
@ SYNC_TRX_I_S_LAST_READ
Definition: sync0types.h:320
@ SYNC_NO_ORDER_CHECK
This can be used to suppress order checking.
Definition: sync0types.h:333
@ SYNC_EXTERN_STORAGE
Definition: sync0types.h:285
@ SYNC_BUF_FREE_LIST
Definition: sync0types.h:224
@ SYNC_PARSER
Definition: sync0types.h:312
@ SYNC_IBUF_MUTEX
Definition: sync0types.h:280
@ SYNC_IBUF_HEADER
Definition: sync0types.h:306
@ SYNC_LOG_SN_MUTEX
Definition: sync0types.h:252
@ SYNC_LOCK_FREE_HASH
Definition: sync0types.h:211
@ SYNC_TRX_I_S_RWLOCK
Definition: sync0types.h:322
@ RW_LOCK_S
Definition: sync0types.h:207
@ SYNC_TEMP_SPACE_RSEG
Definition: sync0types.h:290
@ SYNC_TREE_NODE_FROM_HASH
Definition: sync0types.h:296
@ SYNC_PURGE_LATCH
Definition: sync0types.h:294
@ SYNC_MONITOR_MUTEX
Definition: sync0types.h:213
@ SYNC_PERSIST_DIRTY_TABLES
Definition: sync0types.h:302
@ SYNC_LOCK_WAIT_SYS
Definition: sync0types.h:270
@ SYNC_LOG_FLUSH_NOTIFIER
Definition: sync0types.h:248
@ SYNC_INDEX_ONLINE_LOG
Definition: sync0types.h:272
@ SYNC_TEMP_POOL_MANAGER
Definition: sync0types.h:284
@ 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:289
@ SYNC_UNDO_DDL
Definition: sync0types.h:314
@ SYNC_IBUF_INDEX_TREE
Definition: sync0types.h:278
@ SYNC_DICT_OPERATION
Definition: sync0types.h:316
@ SYNC_TRX_SYS_HEADER
Definition: sync0types.h:259
@ SYNC_RSEGS
Definition: sync0types.h:299
@ SYNC_IBUF_TREE_NODE_NEW
Definition: sync0types.h:277
@ RW_LOCK_X
Definition: sync0types.h:208
@ SYNC_IBUF_TREE_NODE
Definition: sync0types.h:276
@ SYNC_THREADS
Definition: sync0types.h:262
@ SYNC_LEVEL_MAX
Maximum level value.
Definition: sync0types.h:336
@ 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:255
@ SYNC_IBUF_BITMAP_MUTEX
Definition: sync0types.h:275
@ SYNC_INDEX_TREE
Definition: sync0types.h:298
@ SYNC_SEARCH_SYS
Definition: sync0types.h:233
@ SYNC_TRX_SYS_RSEG
Definition: sync0types.h:292
@ SYNC_LOG_SN
Definition: sync0types.h:251
@ SYNC_AHI_ENABLED
Definition: sync0types.h:318
@ 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:1652
rw_lock_flag_t
Definition: sync0types.h:1210
@ RW_LOCK_FLAG_X
Definition: sync0types.h:1212
@ RW_LOCK_FLAG_SX
Definition: sync0types.h:1213
@ RW_LOCK_FLAG_S
Definition: sync0types.h:1211
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:920
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:1659
ulint rw_lock_flags_t
Definition: sync0types.h:1207
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:100
#define ut_ad(EXPR)
Debug assertion.
Definition: ut0dbg.h:104
#define ut_d(EXPR)
Debug statement.
Definition: ut0dbg.h:106
#define ut_a(EXPR)
Abort execution if EXPR does not evaluate to nonzero.
Definition: ut0dbg.h:92
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