MySQL 8.0.31
Source Code Documentation
mdl.h
Go to the documentation of this file.
1#ifndef MDL_H
2#define MDL_H
3/* Copyright (c) 2009, 2022, Oracle and/or its affiliates.
4
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License, version 2.0,
7 as published by the Free Software Foundation.
8
9 This program is also distributed with certain software (including
10 but not limited to OpenSSL) that is licensed under separate terms,
11 as designated in a particular file or component or in included license
12 documentation. The authors of MySQL hereby grant you an additional
13 permission to link the program and your derivative works with the
14 separately licensed software that they have included with MySQL.
15
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License, version 2.0, for more details.
20
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software
23 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
24
25#include <assert.h>
26#include <string.h>
27#include <sys/types.h>
28#include <algorithm>
29#include <new>
30#include <unordered_map>
31
32#include "m_string.h"
33#include "my_alloc.h"
34#include "my_compiler.h"
35
36#include "my_inttypes.h"
37#include "my_psi_config.h"
38#include "my_sys.h"
39#include "my_systime.h" // Timout_type
46#include "mysql_com.h"
47#include "sql/sql_plist.h"
48#include "template_utils.h"
49
50class MDL_context;
51class MDL_lock;
52class MDL_ticket;
53class THD;
54struct LF_PINS;
55struct MDL_key;
56struct MEM_ROOT;
57namespace mdl_unittest {
59}
60/**
61 @def ENTER_COND(C, M, S, O)
62 Start a wait on a condition.
63 @param C the condition to wait on
64 @param M the associated mutex
65 @param S the new stage to enter
66 @param O the previous stage
67 @sa EXIT_COND().
68*/
69#define ENTER_COND(C, M, S, O) \
70 enter_cond(C, M, S, O, __func__, __FILE__, __LINE__)
71
72/**
73 @def EXIT_COND(S)
74 End a wait on a condition
75 @param S the new stage to enter
76*/
77#define EXIT_COND(S) exit_cond(S, __func__, __FILE__, __LINE__)
78
79/**
80 An interface to separate the MDL module from the THD, and the rest of the
81 server code.
82 */
83
85 public:
86 virtual ~MDL_context_owner() = default;
87
88 /**
89 Enter a condition wait.
90 For @c enter_cond() / @c exit_cond() to work the mutex must be held before
91 @c enter_cond(); this mutex must then be released before @c exit_cond().
92 Usage must be: lock mutex; enter_cond(); your code; unlock mutex;
93 exit_cond().
94 @param cond the condition to wait on
95 @param mutex the associated mutex
96 @param [in] stage the stage to enter, or NULL
97 @param [out] old_stage the previous stage, or NULL
98 @param src_function function name of the caller
99 @param src_file file name of the caller
100 @param src_line line number of the caller
101 @sa ENTER_COND(), THD::enter_cond()
102 @sa EXIT_COND(), THD::exit_cond()
103 */
104 virtual void enter_cond(mysql_cond_t *cond, mysql_mutex_t *mutex,
105 const PSI_stage_info *stage,
106 PSI_stage_info *old_stage, const char *src_function,
107 const char *src_file, int src_line) = 0;
108
109 /**
110 End a wait on a condition
111 @param [in] stage the new stage to enter
112 @param src_function function name of the caller
113 @param src_file file name of the caller
114 @param src_line line number of the caller
115 @sa ENTER_COND(), THD::enter_cond()
116 @sa EXIT_COND(), THD::exit_cond()
117 */
118 virtual void exit_cond(const PSI_stage_info *stage, const char *src_function,
119 const char *src_file, int src_line) = 0;
120 /**
121 Has the owner thread been killed?
122 */
123 virtual int is_killed() const = 0;
124
125 /**
126 Does the owner still have connection to the client?
127 */
128 virtual bool is_connected() = 0;
129
130 /**
131 Indicates that owner thread might have some commit order (non-MDL) waits
132 for it which are still taken into account by MDL deadlock detection,
133 even in cases when it doesn't have any MDL locks acquired and therefore
134 can't have any MDL waiters.
135
136 @note It is important for this check to be non-racy and quick (perhaps
137 at expense of being pretty pessimistic), so it can be used to
138 make decisions reliably about whether we can skip deadlock
139 detection in some cases.
140 */
141 virtual bool might_have_commit_order_waiters() const = 0;
142
143 /**
144 Within MDL subsystem this one is only used for DEBUG_SYNC.
145 Do not use it to peek/poke into other parts of THD from MDL.
146 However it is OK to use this method in callbacks provided
147 by SQL-layer to MDL subsystem (since SQL-layer has full
148 access to THD anyway).
149
150 @warning For some derived classes implementation of this method
151 can return nullptr. Calling side must be ready to handle
152 this case.
153 */
154 virtual THD *get_thd() = 0;
155
156 /**
157 @see THD::notify_shared_lock()
158 */
160 bool needs_thr_lock_abort) = 0;
161
162 /**
163 Notify/get permission from interested storage engines before acquiring
164 exclusive lock for the key.
165
166 The returned argument 'victimized' specify reason for lock
167 not granted. If 'true', lock was refused in an attempt to
168 resolve a possible MDL->GSL deadlock. Locking may then be retried.
169
170 @return False if notification was successful and it is OK to acquire lock,
171 True if one of SEs asks to abort lock acquisition.
172 */
173 virtual bool notify_hton_pre_acquire_exclusive(const MDL_key *mdl_key,
174 bool *victimized) = 0;
175 /**
176 Notify interested storage engines that we have just released exclusive
177 lock for the key.
178 */
179 virtual void notify_hton_post_release_exclusive(const MDL_key *mdl_key) = 0;
180
181 /**
182 Get random seed specific to this THD to be used for initialization
183 of PRNG for the MDL_context.
184 */
185 virtual uint get_rand_seed() const = 0;
186};
187
188/**
189 Type of metadata lock request.
190
191 @sa Comments for MDL_object_lock::can_grant_lock() and
192 MDL_scoped_lock::can_grant_lock() for details.
193*/
194
196 /*
197 An intention exclusive metadata lock. Used only for scoped locks.
198 Owner of this type of lock can acquire upgradable exclusive locks on
199 individual objects.
200 This lock type is also used when doing lookups in the dictionary
201 cache. When acquiring objects in a schema, we lock the schema with IX
202 to prevent the schema from being deleted. This should conceptually
203 be an IS lock, but it would have the same behavior as the current IX.
204 Compatible with other IX locks, but is incompatible with scoped S and
205 X locks.
206 */
208 /*
209 A shared metadata lock.
210 To be used in cases when we are interested in object metadata only
211 and there is no intention to access object data (e.g. for stored
212 routines or during preparing prepared statements).
213 We also mis-use this type of lock for open HANDLERs, since lock
214 acquired by this statement has to be compatible with lock acquired
215 by LOCK TABLES ... WRITE statement, i.e. SNRW (We can't get by by
216 acquiring S lock at HANDLER ... OPEN time and upgrading it to SR
217 lock for HANDLER ... READ as it doesn't solve problem with need
218 to abort DML statements which wait on table level lock while having
219 open HANDLER in the same connection).
220 To avoid deadlock which may occur when SNRW lock is being upgraded to
221 X lock for table on which there is an active S lock which is owned by
222 thread which waits in its turn for table-level lock owned by thread
223 performing upgrade we have to use thr_abort_locks_for_thread()
224 facility in such situation.
225 This problem does not arise for locks on stored routines as we don't
226 use SNRW locks for them. It also does not arise when S locks are used
227 during PREPARE calls as table-level locks are not acquired in this
228 case.
229 */
231 /*
232 A high priority shared metadata lock.
233 Used for cases when there is no intention to access object data (i.e.
234 data in the table).
235 "High priority" means that, unlike other shared locks, it is granted
236 ignoring pending requests for exclusive locks. Intended for use in
237 cases when we only need to access metadata and not data, e.g. when
238 filling an INFORMATION_SCHEMA table.
239 Since SH lock is compatible with SNRW lock, the connection that
240 holds SH lock lock should not try to acquire any kind of table-level
241 or row-level lock, as this can lead to a deadlock. Moreover, after
242 acquiring SH lock, the connection should not wait for any other
243 resource, as it might cause starvation for X locks and a potential
244 deadlock during upgrade of SNW or SNRW to X lock (e.g. if the
245 upgrading connection holds the resource that is being waited for).
246 */
248 /*
249 A shared metadata lock for cases when there is an intention to read data
250 from table.
251 A connection holding this kind of lock can read table metadata and read
252 table data (after acquiring appropriate table and row-level locks).
253 This means that one can only acquire TL_READ, TL_READ_NO_INSERT, and
254 similar table-level locks on table if one holds SR MDL lock on it.
255 To be used for tables in SELECTs, subqueries, and LOCK TABLE ... READ
256 statements.
257 */
259 /*
260 A shared metadata lock for cases when there is an intention to modify
261 (and not just read) data in the table.
262 A connection holding SW lock can read table metadata and modify or read
263 table data (after acquiring appropriate table and row-level locks).
264 To be used for tables to be modified by INSERT, UPDATE, DELETE
265 statements, but not LOCK TABLE ... WRITE or DDL). Also taken by
266 SELECT ... FOR UPDATE.
267 */
269 /*
270 A version of MDL_SHARED_WRITE lock which has lower priority than
271 MDL_SHARED_READ_ONLY locks. Used by DML statements modifying
272 tables and using the LOW_PRIORITY clause.
273 */
275 /*
276 An upgradable shared metadata lock which allows concurrent updates and
277 reads of table data.
278 A connection holding this kind of lock can read table metadata and read
279 table data. It should not modify data as this lock is compatible with
280 SRO locks.
281 Can be upgraded to SNW, SNRW and X locks. Once SU lock is upgraded to X
282 or SNRW lock data modification can happen freely.
283 To be used for the first phase of ALTER TABLE.
284 */
286 /*
287 A shared metadata lock for cases when we need to read data from table
288 and block all concurrent modifications to it (for both data and metadata).
289 Used by LOCK TABLES READ statement.
290 */
292 /*
293 An upgradable shared metadata lock which blocks all attempts to update
294 table data, allowing reads.
295 A connection holding this kind of lock can read table metadata and read
296 table data.
297 Can be upgraded to X metadata lock.
298 Note, that since this type of lock is not compatible with SNRW or SW
299 lock types, acquiring appropriate engine-level locks for reading
300 (TL_READ* for MyISAM, shared row locks in InnoDB) should be
301 contention-free.
302 To be used for the first phase of ALTER TABLE, when copying data between
303 tables, to allow concurrent SELECTs from the table, but not UPDATEs.
304 */
306 /*
307 An upgradable shared metadata lock which allows other connections
308 to access table metadata, but not data.
309 It blocks all attempts to read or update table data, while allowing
310 INFORMATION_SCHEMA and SHOW queries.
311 A connection holding this kind of lock can read table metadata modify and
312 read table data.
313 Can be upgraded to X metadata lock.
314 To be used for LOCK TABLES WRITE statement.
315 Not compatible with any other lock type except S and SH.
316 */
318 /*
319 An exclusive metadata lock.
320 A connection holding this lock can modify both table's metadata and data.
321 No other type of metadata lock can be granted while this lock is held.
322 To be used for CREATE/DROP/RENAME TABLE statements and for execution of
323 certain phases of other DDL statements.
324 */
326 /* This should be the last !!! */
329
330/** Duration of metadata lock. */
331
333 /**
334 Locks with statement duration are automatically released at the end
335 of statement or transaction.
336 */
338 /**
339 Locks with transaction duration are automatically released at the end
340 of transaction.
341 */
343 /**
344 Locks with explicit duration survive the end of statement and transaction.
345 They have to be released explicitly by calling MDL_context::release_lock().
346 */
348 /* This should be the last ! */
351
352/** Maximal length of key for metadata locking subsystem. */
353#define MAX_MDLKEY_LENGTH (1 + NAME_LEN + 1 + NAME_LEN + 1)
354
355/**
356 Metadata lock object key.
357
358 A lock is requested or granted based on a fully qualified name and type.
359 E.g. They key for a table consists of @<0 (=table)@>+@<database@>+@<table
360 name@>. Elsewhere in the comments this triple will be referred to simply as
361 "key" or "name".
362*/
363
364struct MDL_key {
365 public:
366#ifdef HAVE_PSI_INTERFACE
367 static void init_psi_keys();
368#endif
369
370 /**
371 Object namespaces.
372 Sic: when adding a new member to this enum make sure to
373 update m_namespace_to_wait_state_name array in mdl.cc!
374
375 Different types of objects exist in different namespaces
376 - GLOBAL is used for the global read lock.
377 - BACKUP_LOCK is to block any operations that could cause
378 inconsistent backup. Such operations are most DDL statements,
379 and some administrative statements.
380 - TABLESPACE is for tablespaces.
381 - SCHEMA is for schemas (aka databases).
382 - TABLE is for tables and views.
383 - FUNCTION is for stored functions.
384 - PROCEDURE is for stored procedures.
385 - TRIGGER is for triggers.
386 - EVENT is for event scheduler events.
387 - COMMIT is for enabling the global read lock to block commits.
388 - USER_LEVEL_LOCK is for user-level locks.
389 - LOCKING_SERVICE is for the name plugin RW-lock service
390 - SRID is for spatial reference systems
391 - ACL_CACHE is for ACL caches
392 - COLUMN_STATISTICS is for column statistics, such as histograms
393 - RESOURCE_GROUPS is for resource groups.
394 - FOREIGN_KEY is for foreign key names.
395 - CHECK_CONSTRAINT is for check constraint names.
396 - RESOURCE_GROUPS_GLOBAL is global lock for resource groups.
397 Note that requests waiting for user-level locks get special
398 treatment - waiting is aborted if connection to client is lost.
399 */
420 /* This should be the last ! */
422 };
423
424 const uchar *ptr() const { return pointer_cast<const uchar *>(m_ptr); }
425 uint length() const { return m_length; }
426
427 const char *db_name() const { return m_ptr + 1; }
429
430 const char *name() const {
432 : m_ptr + m_db_name_length + 2);
433 }
435
436 const char *col_name() const {
438
440 /* A column name was stored in the key buffer. */
442 }
443
444 /* No column name stored. */
445 return nullptr;
446 }
447
450
452 /* A column name was stored in the key buffer. */
454 }
455
456 /* No column name stored. */
457 return 0;
458 }
459
461 return (enum_mdl_namespace)(m_ptr[0]);
462 }
463
464 /**
465 Construct a metadata lock key from a triplet (mdl_namespace,
466 database and name).
467
468 @remark The key for a table is @<mdl_namespace@>+@<database name@>+@<table
469 name@>
470
471 @param mdl_namespace Id of namespace of object to be locked
472 @param db Name of database to which the object belongs
473 @param name Name of of the object
474 */
476 const char *name) {
477 m_ptr[0] = (char)mdl_namespace;
478
480
481 /*
482 It is responsibility of caller to ensure that db and object names
483 are not longer than NAME_LEN. Still we play safe and try to avoid
484 buffer overruns.
485
486 Implicit tablespace names in InnoDB may be longer than NAME_LEN.
487 We will lock based on the first NAME_LEN characters.
488
489 TODO: The patch acquires metadata locks on the NAME_LEN
490 first bytest of the tablespace names. For long names,
491 the consequence of locking on this prefix is
492 that locking a single implicit tablespace might end up
493 effectively lock all implicit tablespaces in the same
494 schema. A possible fix is to lock on a prefix of length
495 NAME_LEN * 2, since this is the real buffer size of
496 the metadata lock key. Dependencies from the PFS
497 implementation, possibly relying on the key format,
498 must be investigated first, though.
499 */
500 assert(strlen(db) <= NAME_LEN);
501 assert((mdl_namespace == TABLESPACE) || (strlen(name) <= NAME_LEN));
503 static_cast<uint16>(strmake(m_ptr + 1, db, NAME_LEN) - m_ptr - 1);
504 m_object_name_length = static_cast<uint16>(
506 m_db_name_length - 2);
508 }
509
510 /**
511 Construct a metadata lock key from a quadruplet (mdl_namespace,
512 database, table and column name).
513
514 @remark The key for a column is
515 @<mdl_namespace@>+@<database name@>+@<table name@>+@<column name@>
516
517 @param mdl_namespace Id of namespace of object to be locked
518 @param db Name of database to which the object belongs
519 @param name Name of of the object
520 @param column_name Name of of the column
521 */
523 const char *name, const char *column_name) {
524 m_ptr[0] = (char)mdl_namespace;
525 char *start;
526 char *end;
527
529
530 assert(strlen(db) <= NAME_LEN);
531 start = m_ptr + 1;
532 end = strmake(start, db, NAME_LEN);
533 m_db_name_length = static_cast<uint16>(end - start);
534
535 assert(strlen(name) <= NAME_LEN);
536 start = end + 1;
538 m_object_name_length = static_cast<uint16>(end - start);
539
540 size_t col_len = strlen(column_name);
541 assert(col_len <= NAME_LEN);
542 start = end + 1;
543 size_t remaining =
545 uint16 extra_length = 0;
546
547 /*
548 In theory:
549 - schema name is up to NAME_LEN characters
550 - object name is up to NAME_LEN characters
551 - column name is up to NAME_LEN characters
552 - NAME_LEN is 64 characters
553 - 1 character is up to 3 bytes (UTF8MB3),
554 and when moving to UTF8MB4, up to 4 bytes.
555 - Storing a SCHEMA + OBJECT MDL key
556 can take up to 387 bytes
557 - Storing a SCHEMA + OBJECT + COLUMN MDL key
558 can take up to 580 bytes.
559
560 In practice:
561 - full storage is allocated for SCHEMA + OBJECT only,
562 storage for COLUMN is **NOT** reserved.
563 - SCHEMA and OBJECT names are typically shorter,
564 and are not using systematically multi-bytes characters
565 for each character, so that less space is required.
566 - MDL keys that are not COLUMN_STATISTICS
567 are stored in full, without truncation.
568
569 For the COLUMN_STATISTICS name space:
570 - either the full SCHEMA + OBJECT + COLUMN key fits
571 within 387 bytes, in which case the fully qualified
572 column name is stored,
573 leading to MDL locks per column (as intended)
574 - or the SCHEMA and OBJECT names are very long,
575 so that not enough room is left to store a column name,
576 in which case the MDL key is truncated to be
577 COLUMN_STATISTICS + SCHEMA + NAME.
578 In this case, MDL locks for columns col_X and col_Y
579 in table LONG_FOO.LONG_BAR will both share the same
580 key LONG_FOO.LONG_BAR, in effect providing a lock
581 granularity not per column but per table.
582 This is a degraded mode of operation,
583 which serializes MDL access to columns
584 (for tables with a very long fully qualified name),
585 to reduce the memory footprint for all MDL access.
586
587 To be revised if the MDL key buffer is allocated dynamically
588 instead.
589 */
590
591 static_assert(MAX_MDLKEY_LENGTH == 387, "UTF8MB3");
592
593 /*
594 Check if there is room to store the whole column name.
595 This code is not trying to store truncated column names,
596 to avoid cutting column_name in the middle of a
597 multi-byte character.
598 */
599 if (remaining >= col_len + 1) {
600 end = strmake(start, column_name, remaining);
601 extra_length = static_cast<uint16>(end - start) + 1; // With \0
602 }
603 m_length = m_db_name_length + m_object_name_length + 3 + extra_length;
604 assert(m_length <= MAX_MDLKEY_LENGTH);
605 }
606
607 /**
608 Construct a metadata lock key from a quadruplet (mdl_namespace, database,
609 normalized object name buffer and the object name).
610
611 @remark The key for a routine/event/resource group/trigger is
612 @<mdl_namespace@>+@<database name@>+@<normalized object name@>
613 additionally @<object name@> is stored in the same buffer for information
614 purpose if buffer has sufficient space.
615
616 Routine, Event and Resource group names are case sensitive and accent
617 sensitive. So normalized object name is used to form a MDL_key.
618
619 With the UTF8MB3 charset space reserved for the db name/object
620 name is 64 * 3 bytes. utf8mb3_general_ci collation is used for the
621 Routine, Event and Resource group names. With this collation, the
622 normalized object name uses just 2 bytes for each character (max
623 length = 64 * 2 bytes). MDL_key has still some space to store the
624 object names. If there is a sufficient space for the object name
625 in the MDL_key then it is stored in the MDL_key (similar to the
626 column names in the MDL_key). Actual object name is used by the
627 PFS. Not listing actual object name from the PFS should be OK
628 when there is no space to store it (instead of increasing the
629 MDL_key size). Object name is not used in the key comparisons. So
630 only (mdl_namespace + strlen(db) + 1 + normalized_name_len + 1)
631 value is stored in the m_length member.
632
633 @param mdl_namespace Id of namespace of object to be locked.
634 @param db Name of database to which the object belongs.
635 @param normalized_name Normalized name of the object.
636 @param normalized_name_len Length of the normalized object name.
637 @param name Name of the object.
638 */
640 const char *normalized_name, size_t normalized_name_len,
641 const char *name) {
642 m_ptr[0] = (char)mdl_namespace;
643
644 /*
645 FUNCTION, PROCEDURE, EVENT and RESOURCE_GROUPS names are case and accent
646 insensitive. For other objects key should not be formed from this method.
647 */
649
650 assert(strlen(db) <= NAME_LEN && strlen(name) <= NAME_LEN &&
651 normalized_name_len <= NAME_CHAR_LEN * 2);
652
653 // Database name.
655 static_cast<uint16>(strmake(m_ptr + 1, db, NAME_LEN) - m_ptr - 1);
656
657 // Normalized object name.
658 m_length = static_cast<uint16>(m_db_name_length + normalized_name_len + 3);
659 memcpy(m_ptr + m_db_name_length + 2, normalized_name, normalized_name_len);
660 *(m_ptr + m_length - 1) = 0;
661
662 /*
663 Copy name of the object if there is a sufficient space to store the name
664 in the MDL key. This code is not trying to store truncated object names,
665 to avoid cutting object_name in the middle of a multi-byte character.
666 */
667 if (strlen(name) < static_cast<size_t>(MAX_MDLKEY_LENGTH - m_length)) {
668 m_object_name_length = static_cast<uint16>(
670 m_ptr - m_length));
671 } else {
673 *(m_ptr + m_length) = 0;
674 }
675
677 }
678
679 /**
680 Construct a metadata lock key from namespace and partial key, which
681 contains info about object database and name.
682
683 @remark The partial key must be "<database>\0<name>\0".
684
685 @param mdl_namespace Id of namespace of object to be locked
686 @param part_key Partial key.
687 @param part_key_length Partial key length
688 @param db_length Database name length.
689 */
691 size_t part_key_length, size_t db_length) {
692 /*
693 Key suffix provided should be in compatible format and
694 its components should adhere to length restrictions.
695 */
696 assert(strlen(part_key) == db_length);
697 assert(db_length + 1 + strlen(part_key + db_length + 1) + 1 ==
698 part_key_length);
699 assert(db_length <= NAME_LEN);
700 assert(part_key_length <= NAME_LEN + 1 + NAME_LEN + 1);
701
702 m_ptr[0] = (char)mdl_namespace;
703 /*
704 Partial key of objects with normalized object name can not be used to
705 initialize MDL key.
706 */
708
709 memcpy(m_ptr + 1, part_key, part_key_length);
710 m_length = static_cast<uint16>(part_key_length + 1);
711 m_db_name_length = static_cast<uint16>(db_length);
713 }
714 void mdl_key_init(const MDL_key *rhs) {
715 uint16 copy_length = rhs->use_normalized_object_name()
716 ? rhs->m_length + rhs->m_object_name_length + 1
717 : rhs->m_length;
718 memcpy(m_ptr, rhs->m_ptr, copy_length);
719 m_length = rhs->m_length;
722 }
723 void reset() {
724 m_ptr[0] = NAMESPACE_END;
727 m_length = 0;
728 }
729 bool is_equal(const MDL_key *rhs) const {
730 return (m_length == rhs->m_length &&
731 memcmp(m_ptr, rhs->m_ptr, m_length) == 0);
732 }
733 /**
734 Compare two MDL keys lexicographically.
735 */
736 int cmp(const MDL_key *rhs) const {
737 /*
738 For the keys with the normalized names, there is a possibility of getting
739 '\0' in its middle. So only key content comparison would yield incorrect
740 result. Hence comparing key length too when keys are equal.
741 For other keys, key buffer is always '\0'-terminated. Since key character
742 set is utf-8, we can safely assume that no character starts with a zero
743 byte.
744 */
745 int res = memcmp(m_ptr, rhs->m_ptr, std::min(m_length, rhs->m_length));
746 if (res == 0) res = m_length - rhs->m_length;
747 return res;
748 }
749
750 MDL_key(const MDL_key &rhs) { mdl_key_init(&rhs); }
751
752 MDL_key &operator=(const MDL_key &rhs) {
753 mdl_key_init(&rhs);
754 return *this;
755 }
756
757 MDL_key(enum_mdl_namespace namespace_arg, const char *db_arg,
758 const char *name_arg) {
759 mdl_key_init(namespace_arg, db_arg, name_arg);
760 }
761 MDL_key() = default; /* To use when part of MDL_request. */
762
763 /**
764 Get thread state name to be used in case when we have to
765 wait on resource identified by key.
766 */
769 }
770
771 private:
772 /**
773 Check if normalized object name should be used.
774
775 @return true if normlized object name should be used, false
776 otherwise.
777 */
779 return (mdl_namespace() == FUNCTION || mdl_namespace() == PROCEDURE ||
782 }
783
784 private:
790};
791
792/**
793 A pending metadata lock request.
794
795 A lock request and a granted metadata lock are represented by
796 different classes because they have different allocation
797 sites and hence different lifetimes. The allocation of lock requests is
798 controlled from outside of the MDL subsystem, while allocation of granted
799 locks (tickets) is controlled within the MDL subsystem.
800*/
801
803 public:
804 /** Type of metadata lock. */
806 /** Duration for requested lock. */
808
809 /**
810 Pointers for participating in the list of lock requests for this context.
811 */
814 /**
815 Pointer to the lock ticket object for this lock request.
816 Valid only if this lock request is satisfied.
817 */
819
820 /** A lock is requested based on a fully qualified name and type. */
822
823 const char *m_src_file{nullptr};
825
826 public:
827 static void *operator new(size_t size, MEM_ROOT *mem_root,
828 const std::nothrow_t &arg
829 [[maybe_unused]] = std::nothrow) noexcept {
830 return mem_root->Alloc(size);
831 }
832
833 static void operator delete(void *, MEM_ROOT *,
834 const std::nothrow_t &) noexcept {}
835
837 const char *db_arg, const char *name_arg,
838 enum_mdl_type mdl_type_arg,
839 enum_mdl_duration mdl_duration_arg,
840 const char *src_file, uint src_line);
841 void init_by_key_with_source(const MDL_key *key_arg,
842 enum_mdl_type mdl_type_arg,
843 enum_mdl_duration mdl_duration_arg,
844 const char *src_file, uint src_line);
846 const char *part_key_arg,
847 size_t part_key_length_arg,
848 size_t db_length_arg,
849 enum_mdl_type mdl_type_arg,
850 enum_mdl_duration mdl_duration_arg,
851 const char *src_file, uint src_line);
852 /** Set type of lock request. Can be only applied to pending locks. */
853 inline void set_type(enum_mdl_type type_arg) {
854 assert(ticket == nullptr);
855 type = type_arg;
856 }
857
858 /**
859 Is this a request for a lock which allow data to be updated?
860
861 @note This method returns true for MDL_SHARED_UPGRADABLE type of
862 lock. Even though this type of lock doesn't allow updates
863 it will always be upgraded to one that does.
864 */
867 }
868
869 /** Is this a request for a strong, DDL/LOCK TABLES-type, of lock? */
871 return type >= MDL_SHARED_UPGRADABLE;
872 }
873
874 /**
875 This constructor exists for two reasons:
876
877 - TABLE_LIST objects are sometimes default-constructed. We plan to remove
878 this as there is no practical reason, the call to the default
879 constructor is always followed by either a call to TABLE_LIST::operator=
880 or memberwise assignments.
881
882 - In some legacy cases TABLE_LIST objects are copy-assigned without
883 intention to copy the TABLE_LIST::mdl_request member. In this cases they
884 are overwritten with an uninitialized MDL_request object. The cases are:
885
886 - Sql_cmd_handler_open::execute()
887 - mysql_execute_command()
888 - Query_expression::prepare()
889 - fill_defined_view_parts()
890
891 No new cases are expected. In all other cases, so far only
892 Locked_tables_list::rename_locked_table(), a move assignment is actually
893 what is intended.
894 */
895 MDL_request() = default;
896
898 : type(rhs.type), duration(rhs.duration), ticket(nullptr), key(rhs.key) {}
899
901
903};
904
905#define MDL_REQUEST_INIT(R, P1, P2, P3, P4, P5) \
906 (*R).init_with_source(P1, P2, P3, P4, P5, __FILE__, __LINE__)
907
908#define MDL_REQUEST_INIT_BY_KEY(R, P1, P2, P3) \
909 (*R).init_by_key_with_source(P1, P2, P3, __FILE__, __LINE__)
910
911#define MDL_REQUEST_INIT_BY_PART_KEY(R, P1, P2, P3, P4, P5, P6) \
912 (*R).init_by_part_key_with_source(P1, P2, P3, P4, P5, P6, __FILE__, __LINE__)
913
914/**
915 An abstract class for inspection of a connected
916 subgraph of the wait-for graph.
917*/
918
920 public:
921 virtual bool enter_node(MDL_context *node) = 0;
922 virtual void leave_node(MDL_context *node) = 0;
923
924 virtual bool inspect_edge(MDL_context *dest) = 0;
927
928 public:
929 /**
930 XXX, hack: During deadlock search, we may need to
931 inspect TABLE_SHAREs and acquire LOCK_open. Since
932 LOCK_open is not a recursive mutex, count here how many
933 times we "took" it (but only take and release once).
934 Not using a native recursive mutex or rwlock in 5.5 for
935 LOCK_open since it has significant performance impacts.
936 */
938};
939
940/**
941 Abstract class representing an edge in the waiters graph
942 to be traversed by deadlock detection algorithm.
943*/
944
946 public:
948
949 /**
950 Accept a wait-for graph visitor to inspect the node
951 this edge is leading to.
952 */
953 virtual bool accept_visitor(MDL_wait_for_graph_visitor *gvisitor) = 0;
954
955 static const uint DEADLOCK_WEIGHT_CO = 0;
956 static const uint DEADLOCK_WEIGHT_DML = 25;
957 static const uint DEADLOCK_WEIGHT_ULL = 50;
958 static const uint DEADLOCK_WEIGHT_DDL = 100;
959
960 /* A helper used to determine which lock request should be aborted. */
961 virtual uint get_deadlock_weight() const = 0;
962};
963
964/**
965 A granted metadata lock.
966
967 @warning MDL_ticket members are private to the MDL subsystem.
968
969 @note Multiple shared locks on a same object are represented by a
970 single ticket. The same does not apply for other lock types.
971
972 @note There are two groups of MDL_ticket members:
973 - "Externally accessible". These members can be accessed from
974 threads/contexts different than ticket owner in cases when
975 ticket participates in some list of granted or waiting tickets
976 for a lock. Therefore one should change these members before
977 including then to waiting/granted lists or while holding lock
978 protecting those lists.
979 - "Context private". Such members are private to thread/context
980 owning this ticket. I.e. they should not be accessed from other
981 threads/contexts.
982*/
983
985 public:
986 /**
987 Pointers for participating in the list of lock requests for this context.
988 Context private.
989 */
992
993 /**
994 Pointers for participating in the list of satisfied/pending requests
995 for the lock. Externally accessible.
996 */
999
1000 public:
1001 bool has_pending_conflicting_lock() const;
1002
1003 MDL_context *get_ctx() const { return m_ctx; }
1007 }
1008 enum_mdl_type get_type() const { return m_type; }
1009 MDL_lock *get_lock() const { return m_lock; }
1010 const MDL_key *get_key() const;
1012
1014
1017
1018 /** Implement MDL_wait_for_subgraph interface. */
1019 bool accept_visitor(MDL_wait_for_graph_visitor *dvisitor) override;
1020 uint get_deadlock_weight() const override;
1021
1022#ifndef NDEBUG
1025#endif
1026
1027 public:
1028 /**
1029 Status of lock request represented by the ticket as reflected in P_S.
1030 */
1037
1038 private:
1039 friend class MDL_context;
1040
1042#ifndef NDEBUG
1043 ,
1044 enum_mdl_duration duration_arg
1045#endif
1046 )
1047 : m_type(type_arg),
1048#ifndef NDEBUG
1049 m_duration(duration_arg),
1050#endif
1051 m_ctx(ctx_arg),
1052 m_lock(nullptr),
1053 m_is_fast_path(false),
1054 m_hton_notified(false),
1055 m_psi(nullptr) {
1056 }
1057
1058 ~MDL_ticket() override { assert(m_psi == nullptr); }
1059
1060 static MDL_ticket *create(MDL_context *ctx_arg, enum_mdl_type type_arg
1061#ifndef NDEBUG
1062 ,
1063 enum_mdl_duration duration_arg
1064#endif
1065 );
1066 static void destroy(MDL_ticket *ticket);
1067
1068 private:
1069 /** Type of metadata lock. Externally accessible. */
1071#ifndef NDEBUG
1072 /**
1073 Duration of lock represented by this ticket.
1074 Context private. Debug-only.
1075 */
1077#endif
1078 /**
1079 Context of the owner of the metadata lock ticket. Externally accessible.
1080 */
1082
1083 /**
1084 Pointer to the lock object for this lock ticket. Externally accessible.
1085 */
1087
1088 /**
1089 Indicates that ticket corresponds to lock acquired using "fast path"
1090 algorithm. Particularly this means that it was not included into
1091 MDL_lock::m_granted bitmap/list and instead is accounted for by
1092 MDL_lock::m_fast_path_locks_granted_counter
1093 */
1095
1096 /**
1097 Indicates that ticket corresponds to lock request which required
1098 storage engine notification during its acquisition and requires
1099 storage engine notification after its release.
1100 */
1102
1104
1105 private:
1106 MDL_ticket(const MDL_ticket &); /* not implemented */
1107 MDL_ticket &operator=(const MDL_ticket &); /* not implemented */
1108};
1109
1110/**
1111 Keep track of MDL_ticket for different durations. Maintains a
1112 hash-based secondary index into the linked lists, to speed up access
1113 by MDL_key.
1114 */
1116 public:
1117 /**
1118 Utility struct for representing a ticket pointer and its duration.
1119 */
1123
1126 : m_dur{d}, m_ticket{t} {}
1127 };
1128
1129 private:
1134
1135 struct Duration {
1137 /**
1138 m_mat_front tracks what was the front of m_ticket_list, the last
1139 time MDL_context::materialize_fast_path_locks() was called. This
1140 just an optimization which allows
1141 MDL_context::materialize_fast_path_locks() only to consider the
1142 locks added since the last time it ran. Consequently, it can be
1143 assumed that every ticket after m_mat_front is materialized, but
1144 the converse is not necessarily true as new, already
1145 materialized, locks may have been added since the last time
1146 materialize_fast_path_locks() ran.
1147 */
1149 };
1150
1152
1153 struct Hash {
1154 size_t operator()(const MDL_key *k) const;
1155 };
1156
1157 struct Key_equal {
1158 bool operator()(const MDL_key *a, const MDL_key *b) const {
1159 return a->is_equal(b);
1160 }
1161 };
1162
1163 using Ticket_map = std::unordered_multimap<const MDL_key *, MDL_ticket_handle,
1164 Hash, Key_equal>;
1165
1166 /**
1167 If the number of tickets in the ticket store (in all durations) is equal
1168 to, or exceeds this constant the hash index (in the form of an
1169 unordered_multi_map) will be maintained and used for lookups.
1170
1171 The value 256 is chosen as it has worked well in benchmarks.
1172 */
1173 const size_t THRESHOLD = 256;
1174
1175 /**
1176 Initial number of buckets in the hash index. THRESHOLD is chosen
1177 to get a fill-factor of 50% when reaching the threshold value.
1178 */
1180 size_t m_count = 0;
1181
1182 std::unique_ptr<Ticket_map> m_map;
1183
1185 MDL_ticket_handle find_in_hash(const MDL_request &req) const;
1186
1187 public:
1188 /**
1189 Public alias.
1190 */
1192
1193 /**
1194 Constructs store. The hash index is initially empty. Filled on demand.
1195 */
1197 : // Comment in to test threshold values in unit test micro benchmark
1198 // THRESHOLD{read_from_env("TS_THRESHOLD", 500)},
1199 m_map{nullptr} {}
1200
1201 /**
1202 Calls the closure provided as argument for each of the MDL_tickets
1203 in the given duration.
1204 @param dur duration list to iterate over
1205 @param clos closure to invoke for each ticket in the list
1206 */
1207 template <typename CLOS>
1209 List_iterator it(m_durations[dur].m_ticket_list);
1210 for (MDL_ticket *t = it++; t != nullptr; t = it++) {
1211 clos(t, dur);
1212 }
1213 }
1214
1215 /**
1216 Calls the closure provided as argument for each of the MDL_tickets
1217 in the store.
1218 @param clos closure to invoke for each ticket in the store
1219 */
1220 template <typename CLOS>
1222 for_each_ticket_in_duration_list(MDL_STATEMENT, std::forward<CLOS>(clos));
1223 for_each_ticket_in_duration_list(MDL_TRANSACTION, std::forward<CLOS>(clos));
1224 for_each_ticket_in_duration_list(MDL_EXPLICIT, std::forward<CLOS>(clos));
1225 }
1226
1227 /**
1228 Predicate for the emptiness of the store.
1229 @return true if there are no tickets in the store
1230 */
1231 bool is_empty() const;
1232
1233 /**
1234 Predicate for the emptiness of a given duration list.
1235 @param di the duration to check
1236 @return true if there are no tickets with the given duration
1237 */
1238 bool is_empty(int di) const;
1239
1240 /**
1241 Return the first MDL_ticket for the given duration.
1242
1243 @param di duration to get first ticket for
1244
1245 @return first ticket in the given duration or nullptr if no such
1246 tickets exist
1247 */
1248 MDL_ticket *front(int di);
1249
1250 /**
1251 Push a ticket onto the list for a given duration.
1252 @param dur duration list to push into
1253 @param ticket to push
1254 */
1255 void push_front(enum_mdl_duration dur, MDL_ticket *ticket);
1256
1257 /**
1258 Remove a ticket from a duration list. Note that since the
1259 underlying list is an intrusive linked list there is no guarantee
1260 that the ticket is actually in the duration list. It will be
1261 removed from which ever list it is in.
1262 */
1263 void remove(enum_mdl_duration dur, MDL_ticket *ticket);
1264
1265 /**
1266 Return a P-list iterator to the given duration.
1267 @param di duration list index
1268 @return P-list iterator to tickets with given duration
1269 */
1272 }
1273
1274 /**
1275 Move all tickets to the explicit duration list.
1276 */
1278
1279 /**
1280 Move all tickets to the transaction duration list.
1281 */
1283
1284 /**
1285 Look up a ticket based on its MDL_key.
1286 @param req request to locate ticket for
1287 @return MDL_ticket_handle with ticket pointer and found duration
1288 (or nullptr and MDL_DURATION_END if not found
1289 */
1290 MDL_ticket_handle find(const MDL_request &req) const;
1291
1292 /**
1293 Mark boundary for tickets with fast_path=false, so that later
1294 calls to materialize_fast_path_locks() do not have to traverse the
1295 whole set of tickets.
1296 */
1297 void set_materialized();
1298
1299 /**
1300 Return the first ticket for which materialize_fast_path_locks
1301 already has been called for the given duration.
1302
1303 @param di duration list index
1304 @return first materialized ticket for the given duration
1305 */
1307};
1308
1309/**
1310 Savepoint for MDL context.
1311
1312 Doesn't include metadata locks with explicit duration as
1313 they are not released during rollback to savepoint.
1314*/
1315
1317 public:
1318 MDL_savepoint() = default;
1319
1320 private:
1321 MDL_savepoint(MDL_ticket *stmt_ticket, MDL_ticket *trans_ticket)
1322 : m_stmt_ticket(stmt_ticket), m_trans_ticket(trans_ticket) {}
1323
1324 friend class MDL_context;
1325
1326 private:
1327 /**
1328 Pointer to last lock with statement duration which was taken
1329 before creation of savepoint.
1330 */
1332 /**
1333 Pointer to last lock with transaction duration which was taken
1334 before creation of savepoint.
1335 */
1337};
1338
1339/**
1340 A reliable way to wait on an MDL lock.
1341*/
1342
1344 public:
1345 MDL_wait();
1346 ~MDL_wait();
1347
1348 // WS_EMPTY since EMPTY conflicts with #define in system headers on some
1349 // platforms.
1351
1352 bool set_status(enum_wait_status result_arg);
1354 void reset_status();
1356 struct timespec *abs_timeout, bool signal_timeout,
1357 const PSI_stage_info *wait_state_name);
1358
1359 private:
1360 /**
1361 Condvar which is used for waiting until this context's pending
1362 request can be satisfied or this thread has to perform actions
1363 to resolve a potential deadlock (we subscribe to such
1364 notification by adding a ticket corresponding to the request
1365 to an appropriate queue of waiters).
1366 */
1370};
1371
1372/**
1373 Base class to find out if the lock represented by a given ticket
1374 should be released. Users of release_locks() need to subclass
1375 this and specify an implementation of release(). Only for locks
1376 with explicit duration.
1377*/
1378
1380 public:
1381 virtual ~MDL_release_locks_visitor() = default;
1382 /**
1383 Check if the given ticket represents a lock that should be released.
1384
1385 @retval true if the lock should be released, false otherwise.
1386 */
1387 virtual bool release(MDL_ticket *ticket) = 0;
1388};
1389
1390/**
1391 Abstract visitor class for inspecting MDL_context.
1392*/
1393
1395 public:
1396 virtual ~MDL_context_visitor() = default;
1397 virtual void visit_context(const MDL_context *ctx) = 0;
1398};
1399
1400typedef I_P_List<MDL_request,
1405
1406/**
1407 Context of the owner of metadata locks. I.e. each server
1408 connection has such a context.
1409*/
1410
1412 public:
1413 typedef I_P_List<MDL_ticket,
1417
1419
1420 MDL_context();
1421 void destroy();
1422
1424 bool acquire_lock(MDL_request *mdl_request, Timeout_type lock_wait_timeout);
1425 bool acquire_locks(MDL_request_list *requests,
1426 Timeout_type lock_wait_timeout);
1427 bool upgrade_shared_lock(MDL_ticket *mdl_ticket, enum_mdl_type new_type,
1428 Timeout_type lock_wait_timeout);
1429
1431
1432 /**
1433 Create copy of all granted tickets of particular duration from given
1434 context to current context.
1435 Used by XA for preserving locks during client disconnect.
1436
1437 @param ticket_owner Owner of tickets to be cloned
1438 @param duration MDL lock duration for that tickets are to be cloned
1439
1440 @retval true Out of memory or deadlock happened or
1441 lock request was refused by storage engine.
1442 @retval false Success.
1443 */
1444
1445 bool clone_tickets(const MDL_context *ticket_owner,
1446 enum_mdl_duration duration);
1447
1450 void release_lock(MDL_ticket *ticket);
1451
1452 bool owns_equal_or_stronger_lock(const MDL_key *mdl_key,
1453 enum_mdl_type mdl_type);
1454
1456 const char *db, const char *name,
1457 enum_mdl_type mdl_type);
1458
1459 bool find_lock_owner(const MDL_key *mdl_key, MDL_context_visitor *visitor);
1460
1461 bool has_lock(const MDL_savepoint &mdl_savepoint, MDL_ticket *mdl_ticket);
1462
1463 inline bool has_locks() const { return !m_ticket_store.is_empty(); }
1464
1465 bool has_locks(MDL_key::enum_mdl_namespace mdl_namespace) const;
1466
1467 bool has_locks_waited_for() const;
1468
1469#ifndef NDEBUG
1471 return !m_ticket_store.is_empty(duration);
1472 }
1473#endif
1474
1478 }
1479
1482 void set_lock_duration(MDL_ticket *mdl_ticket, enum_mdl_duration duration);
1483
1487
1489
1490 /** @pre Only valid if we started waiting for lock. */
1491 inline uint get_deadlock_weight() const {
1495 }
1496
1497 void init(MDL_context_owner *arg) { m_owner = arg; }
1498
1499 void set_needs_thr_lock_abort(bool needs_thr_lock_abort) {
1500 /*
1501 @note In theory, this member should be modified under protection
1502 of some lock since it can be accessed from different threads.
1503 In practice, this is not necessary as code which reads this
1504 value and so might miss the fact that value was changed will
1505 always re-try reading it after small timeout and therefore
1506 will see the new value eventually.
1507 */
1508 m_needs_thr_lock_abort = needs_thr_lock_abort;
1509
1511 /*
1512 For MDL_object_lock::notify_conflicting_locks() to work properly
1513 all context requiring thr_lock aborts should not have any "fast
1514 path" locks.
1515 */
1517 }
1518 }
1520
1521 void set_force_dml_deadlock_weight(bool force_dml_deadlock_weight) {
1522 m_force_dml_deadlock_weight = force_dml_deadlock_weight;
1523 }
1524
1525 /**
1526 Get pseudo random value in [0 .. 2^31-1] range.
1527
1528 @note We use Linear Congruential Generator with venerable constant
1529 parameters for this.
1530 It is known to have problems with its lower bits are not being
1531 very random so probably is not good enough for generic use.
1532 However, we only use it to do random dives into MDL_lock objects
1533 hash when searching for unused objects to be freed, and for this
1534 purposes it is sufficient.
1535 We rely on values of "get_random() % 2^k" expression having "2^k"
1536 as a period to ensure that random dives eventually cover all hash
1537 (the former can be proven to be true). This also means that there
1538 is no bias towards any specific objects to be expelled (as hash
1539 values don't repeat), which is nice for performance.
1540 */
1542 if (m_rand_state > INT_MAX32) {
1543 /*
1544 Perform lazy initialization of LCG. We can't initialize it at the
1545 point when MDL_context is created since THD represented through
1546 MDL_context_owner interface is not fully initialized at this point
1547 itself.
1548 */
1550 }
1551 m_rand_state = (m_rand_state * 1103515245 + 12345) & INT_MAX32;
1552 return m_rand_state;
1553 }
1554
1555 /**
1556 Within MDL subsystem this one is only used for DEBUG_SYNC.
1557 Do not use it to peek/poke into other parts of THD from MDL.
1558 @sa MDL_context_owner::get_thd().
1559 */
1560 THD *get_thd() const { return m_owner->get_thd(); }
1561
1562 public:
1563 /**
1564 If our request for a lock is scheduled, or aborted by the deadlock
1565 detector, the result is recorded in this class.
1566 */
1568
1569 private:
1570 /**
1571 Lists of all MDL tickets acquired by this connection.
1572
1573 Lists of MDL tickets:
1574 ---------------------
1575 The entire set of locks acquired by a connection can be separated
1576 in three subsets according to their duration: locks released at
1577 the end of statement, at the end of transaction and locks are
1578 released explicitly.
1579
1580 Statement and transactional locks are locks with automatic scope.
1581 They are accumulated in the course of a transaction, and released
1582 either at the end of uppermost statement (for statement locks) or
1583 on COMMIT, ROLLBACK or ROLLBACK TO SAVEPOINT (for transactional
1584 locks). They must not be (and never are) released manually,
1585 i.e. with release_lock() call.
1586
1587 Tickets with explicit duration are taken for locks that span
1588 multiple transactions or savepoints.
1589 These are: HANDLER SQL locks (HANDLER SQL is
1590 transaction-agnostic), LOCK TABLES locks (you can COMMIT/etc
1591 under LOCK TABLES, and the locked tables stay locked), user level
1592 locks (GET_LOCK()/RELEASE_LOCK() functions) and
1593 locks implementing "global read lock".
1594
1595 Statement/transactional locks are always prepended to the
1596 beginning of the appropriate list. In other words, they are
1597 stored in reverse temporal order. Thus, when we rollback to
1598 a savepoint, we start popping and releasing tickets from the
1599 front until we reach the last ticket acquired after the savepoint.
1600
1601 Locks with explicit duration are not stored in any
1602 particular order, and among each other can be split into
1603 four sets:
1604 - LOCK TABLES locks
1605 - User-level locks
1606 - HANDLER locks
1607 - GLOBAL READ LOCK locks
1608 */
1610
1612 /**
1613 true - if for this context we will break protocol and try to
1614 acquire table-level locks while having only S lock on
1615 some table.
1616 To avoid deadlocks which might occur during concurrent
1617 upgrade of SNRW lock on such object to X lock we have to
1618 abort waits for table-level locks for such connections.
1619 false - Otherwise.
1620 */
1622
1623 /**
1624 Indicates that we need to use DEADLOCK_WEIGHT_DML deadlock
1625 weight for this context and ignore the deadlock weight provided
1626 by the MDL_wait_for_subgraph object which we are waiting for.
1627
1628 @note Can be changed only when there is a guarantee that this
1629 MDL_context is not waiting for a metadata lock or table
1630 definition entry.
1631 */
1633
1634 /**
1635 Read-write lock protecting m_waiting_for member.
1636
1637 @note The fact that this read-write lock prefers readers is
1638 important as deadlock detector won't work correctly
1639 otherwise. @sa Comment for MDL_lock::m_rwlock.
1640 */
1642 /**
1643 Tell the deadlock detector what metadata lock or table
1644 definition cache entry this session is waiting for.
1645 In principle, this is redundant, as information can be found
1646 by inspecting waiting queues, but we'd very much like it to be
1647 readily available to the wait-for graph iterator.
1648 */
1650 /**
1651 Thread's pins (a.k.a. hazard pointers) to be used by lock-free
1652 implementation of MDL_map::m_locks container. NULL if pins are
1653 not yet allocated from container's pinbox.
1654 */
1656 /**
1657 State for pseudo random numbers generator (PRNG) which output
1658 is used to perform random dives into MDL_lock objects hash
1659 when searching for unused objects to free.
1660 */
1662
1663 private:
1666 MDL_ticket *sentinel);
1667 void release_lock(enum_mdl_duration duration, MDL_ticket *ticket);
1670
1672 bool fix_pins();
1673
1674 public:
1675 void find_deadlock();
1676
1678
1679 /** Inform the deadlock detector there is an edge in the wait-for graph. */
1680 void will_wait_for(MDL_wait_for_subgraph *waiting_for_arg) {
1681 /*
1682 Before starting wait for any resource we need to materialize
1683 all "fast path" tickets belonging to this thread. Otherwise
1684 locks acquired which are represented by these tickets won't
1685 be present in wait-for graph and could cause missed deadlocks.
1686
1687 It is OK for context which doesn't wait for any resource to
1688 have "fast path" tickets, as such context can't participate
1689 in any deadlock.
1690 */
1692
1694 m_waiting_for = waiting_for_arg;
1696 }
1697
1698 /** Remove the wait-for edge from the graph after we're done waiting. */
1701 m_waiting_for = nullptr;
1703 }
1706
1707 private:
1708 MDL_context(const MDL_context &rhs); /* not implemented */
1709 MDL_context &operator=(MDL_context &rhs); /* not implemented */
1710};
1711
1712void mdl_init();
1713void mdl_destroy();
1714
1715#ifndef NDEBUG
1717#endif
1718
1719/*
1720 Metadata locking subsystem tries not to grant more than
1721 max_write_lock_count high priority, strong locks successively,
1722 to avoid starving out weak, lower priority locks.
1723*/
1724extern ulong max_write_lock_count;
1725
1727
1728/**
1729 Default value for threshold for number of unused MDL_lock objects after
1730 exceeding which we start considering freeing them. Only unit tests use
1731 different threshold value.
1732*/
1734
1735/**
1736 Ratio of unused/total MDL_lock objects after exceeding which we
1737 start trying to free unused MDL_lock objects (assuming that
1738 mdl_locks_unused_locks_low_water threshold is passed as well).
1739 Note that this value should be high enough for our algorithm
1740 using random dives into hash to work well.
1741*/
1743
1745
1746/**
1747 Inspect if MDL_context is owned by any thread.
1748*/
1750 public:
1752
1753 /**
1754 Collects relevant information about the MDL lock owner.
1755
1756 This function is only called by MDL_context::find_lock_owner() when
1757 searching for MDL lock owners to collect extra information about the
1758 owner. As we only need to know that the MDL lock is owned, setting
1759 m_exists to true is enough.
1760 */
1761
1762 void visit_context(const MDL_context *ctx [[maybe_unused]]) override {
1763 m_exists = true;
1764 }
1765
1766 /**
1767 Returns if an owner for the MDL lock being inspected exists.
1768
1769 @return true when MDL lock is owned, false otherwise.
1770 */
1771
1772 bool exists() const { return m_exists; }
1773
1774 private:
1775 /* holds information about MDL being owned by any thread */
1777};
1778
1779#endif
Element counting policy class for I_P_List which provides basic element counting.
Definition: sql_plist.h:221
Iterator for I_P_List.
Definition: sql_plist.h:167
An interface to separate the MDL module from the THD, and the rest of the server code.
Definition: mdl.h:84
virtual bool is_connected()=0
Does the owner still have connection to the client?
virtual void notify_shared_lock(MDL_context_owner *in_use, bool needs_thr_lock_abort)=0
virtual bool notify_hton_pre_acquire_exclusive(const MDL_key *mdl_key, bool *victimized)=0
Notify/get permission from interested storage engines before acquiring exclusive lock for the key.
virtual ~MDL_context_owner()=default
virtual void exit_cond(const PSI_stage_info *stage, const char *src_function, const char *src_file, int src_line)=0
End a wait on a condition.
virtual void notify_hton_post_release_exclusive(const MDL_key *mdl_key)=0
Notify interested storage engines that we have just released exclusive lock for the key.
virtual bool might_have_commit_order_waiters() const =0
Indicates that owner thread might have some commit order (non-MDL) waits for it which are still taken...
virtual int is_killed() const =0
Has the owner thread been killed?
virtual uint get_rand_seed() const =0
Get random seed specific to this THD to be used for initialization of PRNG for the MDL_context.
virtual void enter_cond(mysql_cond_t *cond, mysql_mutex_t *mutex, const PSI_stage_info *stage, PSI_stage_info *old_stage, const char *src_function, const char *src_file, int src_line)=0
Enter a condition wait.
virtual THD * get_thd()=0
Within MDL subsystem this one is only used for DEBUG_SYNC.
Abstract visitor class for inspecting MDL_context.
Definition: mdl.h:1394
virtual ~MDL_context_visitor()=default
virtual void visit_context(const MDL_context *ctx)=0
Context of the owner of metadata locks.
Definition: mdl.h:1411
Ticket_list::Iterator Ticket_iterator
Definition: mdl.h:1418
MDL_context_owner * get_owner() const
Definition: mdl.h:1488
bool acquire_locks(MDL_request_list *requests, Timeout_type lock_wait_timeout)
Acquire exclusive locks.
Definition: mdl.cc:3629
bool owns_equal_or_stronger_lock(const MDL_key *mdl_key, enum_mdl_type mdl_type)
Auxiliary function which allows to check if we have some kind of lock on a object.
Definition: mdl.cc:4366
bool clone_tickets(const MDL_context *ticket_owner, enum_mdl_duration duration)
Create copy of all granted tickets of particular duration from given context to current context.
Definition: mdl.cc:3683
MDL_savepoint mdl_savepoint()
Definition: mdl.h:1475
MDL_context()
Initialize a metadata locking context.
Definition: mdl.cc:1435
bool has_locks(enum_mdl_duration duration)
Definition: mdl.h:1470
bool acquire_lock(MDL_request *mdl_request, Timeout_type lock_wait_timeout)
Acquire one lock with waiting for conflicting locks to go away if needed.
Definition: mdl.cc:3358
uint get_deadlock_weight() const
Definition: mdl.h:1491
void set_explicit_duration_for_all_locks()
Set explicit duration for all locks in the context.
Definition: mdl.cc:4621
void set_force_dml_deadlock_weight(bool force_dml_deadlock_weight)
Definition: mdl.h:1521
void init(MDL_context_owner *arg)
Definition: mdl.h:1497
MDL_context_owner * m_owner
Definition: mdl.h:1611
void release_statement_locks()
Definition: mdl.cc:4500
void set_lock_duration(MDL_ticket *mdl_ticket, enum_mdl_duration duration)
Change lock duration for transactional lock.
Definition: mdl.cc:4597
void release_lock(MDL_ticket *ticket)
Release lock with explicit duration.
Definition: mdl.cc:4203
uint get_random()
Get pseudo random value in [0 .
Definition: mdl.h:1541
mysql_prlock_t m_LOCK_waiting_for
Read-write lock protecting m_waiting_for member.
Definition: mdl.h:1641
void release_locks(MDL_release_locks_visitor *visitor)
Release all explicit locks in the context for which the release() method of the provided visitor eval...
Definition: mdl.cc:4268
void release_all_locks_for_name(MDL_ticket *ticket)
Release all explicit locks in the context which correspond to the same name/object as this lock reque...
Definition: mdl.cc:4246
void set_needs_thr_lock_abort(bool needs_thr_lock_abort)
Definition: mdl.h:1499
bool clone_ticket(MDL_request *mdl_request)
Create a copy of a granted ticket.
Definition: mdl.cc:3171
void release_locks_stored_before(enum_mdl_duration duration, MDL_ticket *sentinel)
Release all locks associated with the context.
Definition: mdl.cc:4222
bool find_lock_owner(const MDL_key *mdl_key, MDL_context_visitor *visitor)
Find the first context which owns the lock and inspect it by calling MDL_context_visitor::visit_conte...
Definition: mdl.cc:4419
void rollback_to_savepoint(const MDL_savepoint &mdl_savepoint)
Releases metadata locks that were acquired after a specific savepoint.
Definition: mdl.cc:4477
uint m_rand_state
State for pseudo random numbers generator (PRNG) which output is used to perform random dives into MD...
Definition: mdl.h:1661
bool try_acquire_lock_impl(MDL_request *mdl_request, MDL_ticket **out_ticket)
Auxiliary method for acquiring lock without waiting.
Definition: mdl.cc:2807
MDL_context(const MDL_context &rhs)
void find_deadlock()
Try to find a deadlock.
Definition: mdl.cc:4034
bool m_force_dml_deadlock_weight
Indicates that we need to use DEADLOCK_WEIGHT_DML deadlock weight for this context and ignore the dea...
Definition: mdl.h:1632
void lock_deadlock_victim()
Definition: mdl.h:1704
I_P_List< MDL_ticket, I_P_List_adapter< MDL_ticket, &MDL_ticket::next_in_context, &MDL_ticket::prev_in_context > > Ticket_list
Definition: mdl.h:1416
LF_PINS * m_pins
Thread's pins (a.k.a.
Definition: mdl.h:1655
void materialize_fast_path_locks()
"Materialize" requests for locks which were satisfied using "fast path" by properly including them in...
Definition: mdl.cc:2758
bool try_acquire_lock(MDL_request *mdl_request)
Try to acquire one lock.
Definition: mdl.cc:2684
bool visit_subgraph(MDL_wait_for_graph_visitor *dvisitor)
A fragment of recursive traversal of the wait-for graph of MDL contexts in the server in search for d...
Definition: mdl.cc:4014
bool has_locks_waited_for() const
Do we hold any locks which are possibly being waited for by another MDL_context?
Definition: mdl.cc:4567
bool m_needs_thr_lock_abort
true - if for this context we will break protocol and try to acquire table-level locks while having o...
Definition: mdl.h:1621
bool upgrade_shared_lock(MDL_ticket *mdl_ticket, enum_mdl_type new_type, Timeout_type lock_wait_timeout)
Upgrade a shared metadata lock.
Definition: mdl.cc:3736
MDL_wait_for_subgraph * m_waiting_for
Tell the deadlock detector what metadata lock or table definition cache entry this session is waiting...
Definition: mdl.h:1649
void set_transaction_duration_for_all_locks()
Set transactional duration for all locks in the context.
Definition: mdl.cc:4629
MDL_ticket * find_ticket(MDL_request *mdl_req, enum_mdl_duration *duration)
Check whether the context already holds a compatible lock ticket on an object.
Definition: mdl.cc:2654
void done_waiting_for()
Remove the wait-for edge from the graph after we're done waiting.
Definition: mdl.h:1699
THD * get_thd() const
Within MDL subsystem this one is only used for DEBUG_SYNC.
Definition: mdl.h:1560
bool get_needs_thr_lock_abort() const
Definition: mdl.h:1519
bool has_lock(const MDL_savepoint &mdl_savepoint, MDL_ticket *mdl_ticket)
Does this savepoint have this lock?
Definition: mdl.cc:4515
bool has_locks() const
Definition: mdl.h:1463
MDL_ticket_store m_ticket_store
Lists of all MDL tickets acquired by this connection.
Definition: mdl.h:1609
MDL_wait m_wait
If our request for a lock is scheduled, or aborted by the deadlock detector, the result is recorded i...
Definition: mdl.h:1567
void destroy()
Destroy metadata locking context.
Definition: mdl.cc:1457
bool fix_pins()
Allocate pins which are necessary to work with MDL_map container if they are not allocated already.
Definition: mdl.cc:1471
void unlock_deadlock_victim()
Definition: mdl.h:1705
MDL_context & operator=(MDL_context &rhs)
void release_transactional_locks()
Release locks acquired by normal statements (SELECT, UPDATE, DELETE, etc) in the course of a transact...
Definition: mdl.cc:4494
void will_wait_for(MDL_wait_for_subgraph *waiting_for_arg)
Inform the deadlock detector there is an edge in the wait-for graph.
Definition: mdl.h:1680
Inspect if MDL_context is owned by any thread.
Definition: mdl.h:1749
MDL_lock_is_owned_visitor()
Definition: mdl.h:1751
bool m_exists
Definition: mdl.h:1776
bool exists() const
Returns if an owner for the MDL lock being inspected exists.
Definition: mdl.h:1772
void visit_context(const MDL_context *ctx) override
Collects relevant information about the MDL lock owner.
Definition: mdl.h:1762
The lock context.
Definition: mdl.cc:427
Base class to find out if the lock represented by a given ticket should be released.
Definition: mdl.h:1379
virtual bool release(MDL_ticket *ticket)=0
Check if the given ticket represents a lock that should be released.
virtual ~MDL_release_locks_visitor()=default
A pending metadata lock request.
Definition: mdl.h:802
bool is_ddl_or_lock_tables_lock_request() const
Is this a request for a strong, DDL/LOCK TABLES-type, of lock?
Definition: mdl.h:870
bool is_write_lock_request() const
Is this a request for a lock which allow data to be updated?
Definition: mdl.h:865
MDL_request(MDL_request &&)=default
enum_mdl_type type
Type of metadata lock.
Definition: mdl.h:805
void init_by_key_with_source(const MDL_key *key_arg, enum_mdl_type mdl_type_arg, enum_mdl_duration mdl_duration_arg, const char *src_file, uint src_line)
Initialize a lock request using pre-built MDL_key.
Definition: mdl.cc:1537
void init_by_part_key_with_source(MDL_key::enum_mdl_namespace namespace_arg, const char *part_key_arg, size_t part_key_length_arg, size_t db_length_arg, enum_mdl_type mdl_type_arg, enum_mdl_duration mdl_duration_arg, const char *src_file, uint src_line)
Initialize a lock request using partial MDL key.
Definition: mdl.cc:1566
void set_type(enum_mdl_type type_arg)
Set type of lock request.
Definition: mdl.h:853
MDL_request & operator=(MDL_request &&)=default
MDL_ticket * ticket
Pointer to the lock ticket object for this lock request.
Definition: mdl.h:818
MDL_request ** prev_in_list
Definition: mdl.h:813
const char * m_src_file
Definition: mdl.h:823
void init_with_source(MDL_key::enum_mdl_namespace namespace_arg, const char *db_arg, const char *name_arg, enum_mdl_type mdl_type_arg, enum_mdl_duration mdl_duration_arg, const char *src_file, uint src_line)
Initialize a lock request.
Definition: mdl.cc:1503
MDL_key key
A lock is requested based on a fully qualified name and type.
Definition: mdl.h:821
enum_mdl_duration duration
Duration for requested lock.
Definition: mdl.h:807
MDL_request()=default
This constructor exists for two reasons:
MDL_request * next_in_list
Pointers for participating in the list of lock requests for this context.
Definition: mdl.h:812
uint m_src_line
Definition: mdl.h:824
MDL_request(const MDL_request &rhs)
Definition: mdl.h:897
Savepoint for MDL context.
Definition: mdl.h:1316
MDL_savepoint()=default
MDL_ticket * m_trans_ticket
Pointer to last lock with transaction duration which was taken before creation of savepoint.
Definition: mdl.h:1336
MDL_ticket * m_stmt_ticket
Pointer to last lock with statement duration which was taken before creation of savepoint.
Definition: mdl.h:1331
MDL_savepoint(MDL_ticket *stmt_ticket, MDL_ticket *trans_ticket)
Definition: mdl.h:1321
Keep track of MDL_ticket for different durations.
Definition: mdl.h:1115
void for_each_ticket_in_ticket_lists(CLOS &&clos)
Calls the closure provided as argument for each of the MDL_tickets in the store.
Definition: mdl.h:1221
List_iterator list_iterator(int di) const
Return a P-list iterator to the given duration.
Definition: mdl.h:1270
std::unique_ptr< Ticket_map > m_map
Definition: mdl.h:1182
MDL_ticket_handle find(const MDL_request &req) const
Look up a ticket based on its MDL_key.
Definition: mdl.cc:4881
size_t m_count
Definition: mdl.h:1180
void set_materialized()
Mark boundary for tickets with fast_path=false, so that later calls to materialize_fast_path_locks() ...
Definition: mdl.cc:4895
const size_t INITIAL_BUCKET_COUNT
Initial number of buckets in the hash index.
Definition: mdl.h:1179
MDL_ticket_handle find_in_hash(const MDL_request &req) const
Definition: mdl.cc:4654
void remove(enum_mdl_duration dur, MDL_ticket *ticket)
Remove a ticket from a duration list.
Definition: mdl.cc:4735
void move_all_to_explicit_duration()
Move all tickets to the explicit duration list.
Definition: mdl.cc:4771
void move_explicit_to_transaction_duration()
Move all tickets to the transaction duration list.
Definition: mdl.cc:4830
MDL_ticket * materialized_front(int di)
Return the first ticket for which materialize_fast_path_locks already has been called for the given d...
Definition: mdl.cc:4901
const size_t THRESHOLD
If the number of tickets in the ticket store (in all durations) is equal to, or exceeds this constant...
Definition: mdl.h:1173
MDL_ticket_store()
Constructs store.
Definition: mdl.h:1196
void push_front(enum_mdl_duration dur, MDL_ticket *ticket)
Push a ticket onto the list for a given duration.
Definition: mdl.cc:4692
Duration m_durations[MDL_DURATION_END]
Definition: mdl.h:1151
MDL_ticket * front(int di)
Return the first MDL_ticket for the given duration.
Definition: mdl.cc:4688
MDL_ticket_handle find_in_lists(const MDL_request &req) const
Definition: mdl.cc:4637
void for_each_ticket_in_duration_list(enum_mdl_duration dur, CLOS &&clos)
Calls the closure provided as argument for each of the MDL_tickets in the given duration.
Definition: mdl.h:1208
bool is_empty() const
Predicate for the emptiness of the store.
Definition: mdl.cc:4676
std::unordered_multimap< const MDL_key *, MDL_ticket_handle, Hash, Key_equal > Ticket_map
Definition: mdl.h:1164
A granted metadata lock.
Definition: mdl.h:984
enum enum_mdl_type m_type
Type of metadata lock.
Definition: mdl.h:1070
bool m_is_fast_path
Indicates that ticket corresponds to lock acquired using "fast path" algorithm.
Definition: mdl.h:1094
MDL_ticket(const MDL_ticket &)
bool has_stronger_or_equal_type(enum_mdl_type type) const
Check if ticket represents metadata lock of "stronger" or equal type than specified one.
Definition: mdl.cc:2596
bool has_pending_conflicting_lock() const
Check if we have any pending locks which conflict with existing shared lock.
Definition: mdl.cc:4460
MDL_context * get_ctx() const
Definition: mdl.h:1003
void downgrade_lock(enum_mdl_type type)
Downgrade an EXCLUSIVE or SHARED_NO_WRITE lock to shared metadata lock.
Definition: mdl.cc:4286
~MDL_ticket() override
Definition: mdl.h:1058
MDL_ticket(MDL_context *ctx_arg, enum_mdl_type type_arg, enum_mdl_duration duration_arg)
Definition: mdl.h:1041
MDL_ticket & operator=(const MDL_ticket &)
static void destroy(MDL_ticket *ticket)
Definition: mdl.cc:1680
bool accept_visitor(MDL_wait_for_graph_visitor *dvisitor) override
Implement MDL_wait_for_subgraph interface.
Definition: mdl.cc:3994
bool is_incompatible_when_waiting(enum_mdl_type type) const
Definition: mdl.cc:2607
MDL_ticket * next_in_context
Pointers for participating in the list of lock requests for this context.
Definition: mdl.h:990
bool is_incompatible_when_granted(enum_mdl_type type) const
Definition: mdl.cc:2603
PSI_metadata_lock * m_psi
Definition: mdl.h:1103
MDL_ticket ** prev_in_lock
Definition: mdl.h:998
MDL_ticket ** prev_in_context
Definition: mdl.h:991
uint get_deadlock_weight() const override
Return the 'weight' of this ticket for the victim selection algorithm.
Definition: mdl.cc:1697
enum_mdl_duration get_duration() const
Definition: mdl.h:1023
bool is_upgradable_or_exclusive() const
Definition: mdl.h:1004
bool m_hton_notified
Indicates that ticket corresponds to lock request which required storage engine notification during i...
Definition: mdl.h:1101
enum_mdl_duration m_duration
Duration of lock represented by this ticket.
Definition: mdl.h:1076
enum_psi_status
Status of lock request represented by the ticket as reflected in P_S.
Definition: mdl.h:1031
@ GRANTED
Definition: mdl.h:1033
@ POST_RELEASE_NOTIFY
Definition: mdl.h:1035
@ PRE_ACQUIRE_NOTIFY
Definition: mdl.h:1034
@ PENDING
Definition: mdl.h:1032
MDL_lock * m_lock
Pointer to the lock object for this lock ticket.
Definition: mdl.h:1086
void set_duration(enum_mdl_duration dur)
Definition: mdl.h:1024
enum_mdl_type get_type() const
Definition: mdl.h:1008
MDL_ticket * next_in_lock
Pointers for participating in the list of satisfied/pending requests for the lock.
Definition: mdl.h:997
const MDL_key * get_key() const
Return a key identifying this lock.
Definition: mdl.cc:4466
MDL_context * m_ctx
Context of the owner of the metadata lock ticket.
Definition: mdl.h:1081
MDL_lock * get_lock() const
Definition: mdl.h:1009
static MDL_ticket * create(MDL_context *ctx_arg, enum_mdl_type type_arg, enum_mdl_duration duration_arg)
Auxiliary functions needed for creation/destruction of MDL_ticket objects.
Definition: mdl.cc:1666
An abstract class for inspection of a connected subgraph of the wait-for graph.
Definition: mdl.h:919
MDL_wait_for_graph_visitor()
Definition: mdl.h:926
virtual bool enter_node(MDL_context *node)=0
virtual bool inspect_edge(MDL_context *dest)=0
virtual ~MDL_wait_for_graph_visitor()
uint m_lock_open_count
XXX, hack: During deadlock search, we may need to inspect TABLE_SHAREs and acquire LOCK_open.
Definition: mdl.h:937
virtual void leave_node(MDL_context *node)=0
Abstract class representing an edge in the waiters graph to be traversed by deadlock detection algori...
Definition: mdl.h:945
static const uint DEADLOCK_WEIGHT_CO
Definition: mdl.h:955
static const uint DEADLOCK_WEIGHT_ULL
Definition: mdl.h:957
static const uint DEADLOCK_WEIGHT_DML
Definition: mdl.h:956
virtual ~MDL_wait_for_subgraph()
static const uint DEADLOCK_WEIGHT_DDL
Definition: mdl.h:958
virtual bool accept_visitor(MDL_wait_for_graph_visitor *gvisitor)=0
Accept a wait-for graph visitor to inspect the node this edge is leading to.
virtual uint get_deadlock_weight() const =0
A reliable way to wait on an MDL lock.
Definition: mdl.h:1343
enum_wait_status m_wait_status
Definition: mdl.h:1369
bool set_status(enum_wait_status result_arg)
Set the status unless it's already set.
Definition: mdl.cc:1762
enum_wait_status
Definition: mdl.h:1350
@ KILLED
Definition: mdl.h:1350
@ WS_EMPTY
Definition: mdl.h:1350
@ TIMEOUT
Definition: mdl.h:1350
@ GRANTED
Definition: mdl.h:1350
@ VICTIM
Definition: mdl.h:1350
MDL_wait()
Construct an empty wait slot.
Definition: mdl.cc:1745
void reset_status()
Clear the current value of the wait slot.
Definition: mdl.cc:1786
mysql_cond_t m_COND_wait_status
Definition: mdl.h:1368
~MDL_wait()
Destroy system resources.
Definition: mdl.cc:1752
enum_wait_status timed_wait(MDL_context_owner *owner, struct timespec *abs_timeout, bool signal_timeout, const PSI_stage_info *wait_state_name)
Wait for the status to be assigned to this wait slot.
Definition: mdl.cc:1806
enum_wait_status get_status()
Query the current value of the wait slot.
Definition: mdl.cc:1776
mysql_mutex_t m_LOCK_wait_status
Condvar which is used for waiting until this context's pending request can be satisfied or this threa...
Definition: mdl.h:1367
For each client connection we create a separate thread with THD serving as a thread/connection descri...
Definition: sql_class.h:922
static MEM_ROOT mem_root
Definition: client_plugin.cc:109
#define mysql_prlock_wrlock(T)
Definition: mysql_rwlock.h:75
#define mysql_prlock_rdlock(T)
Definition: mysql_rwlock.h:65
#define mysql_prlock_unlock(T)
Definition: mysql_rwlock.h:95
Fido Client Authentication nullptr
Definition: fido_client_plugin.cc:221
mysql_mutex_t LOCK_open
LOCK_open protects the following variables/objects:
Definition: sql_base.cc:265
struct PSI_metadata_lock PSI_metadata_lock
Definition: psi_mdl_bits.h:51
static void start(mysql_harness::PluginFuncEnv *env)
Definition: http_auth_backend_plugin.cc:176
char * strmake(char *dst, const char *src, size_t length)
Definition: strmake.cc:42
void mdl_init()
Initialize the metadata locking subsystem.
Definition: mdl.cc:1072
I_P_List< MDL_request, I_P_List_adapter< MDL_request, &MDL_request::next_in_list, &MDL_request::prev_in_list >, I_P_List_counter > MDL_request_list
Definition: mdl.h:1404
#define MAX_MDLKEY_LENGTH
Maximal length of key for metadata locking subsystem.
Definition: mdl.h:353
int32 mdl_locks_unused_locks_low_water
Threshold for number of unused MDL_lock objects.
Definition: mdl.cc:283
const int32 MDL_LOCKS_UNUSED_LOCKS_LOW_WATER_DEFAULT
Default value for threshold for number of unused MDL_lock objects after exceeding which we start cons...
Definition: mdl.h:1733
int32 mdl_get_unused_locks_count()
Get number of unused MDL_lock objects in MDL_map cache.
Definition: mdl.cc:1102
enum_mdl_duration
Duration of metadata lock.
Definition: mdl.h:332
@ MDL_TRANSACTION
Locks with transaction duration are automatically released at the end of transaction.
Definition: mdl.h:342
@ MDL_STATEMENT
Locks with statement duration are automatically released at the end of statement or transaction.
Definition: mdl.h:337
@ MDL_EXPLICIT
Locks with explicit duration survive the end of statement and transaction.
Definition: mdl.h:347
@ MDL_DURATION_END
Definition: mdl.h:349
enum_mdl_type
Type of metadata lock request.
Definition: mdl.h:195
@ MDL_SHARED_WRITE
Definition: mdl.h:268
@ MDL_SHARED
Definition: mdl.h:230
@ MDL_SHARED_UPGRADABLE
Definition: mdl.h:285
@ MDL_SHARED_READ_ONLY
Definition: mdl.h:291
@ MDL_SHARED_HIGH_PRIO
Definition: mdl.h:247
@ MDL_SHARED_NO_WRITE
Definition: mdl.h:305
@ MDL_SHARED_NO_READ_WRITE
Definition: mdl.h:317
@ MDL_SHARED_WRITE_LOW_PRIO
Definition: mdl.h:274
@ MDL_SHARED_READ
Definition: mdl.h:258
@ MDL_TYPE_END
Definition: mdl.h:327
@ MDL_EXCLUSIVE
Definition: mdl.h:325
@ MDL_INTENTION_EXCLUSIVE
Definition: mdl.h:207
const double MDL_LOCKS_UNUSED_LOCKS_MIN_RATIO
Ratio of unused/total MDL_lock objects after exceeding which we start trying to free unused MDL_lock ...
Definition: mdl.h:1742
void mdl_destroy()
Release resources of metadata locking subsystem.
Definition: mdl.cc:1090
ulong max_write_lock_count
Definition: thr_lock.cc:122
This file follows Google coding style, except for the name MEM_ROOT (which is kept for historical rea...
Header for compiler-dependent features.
Some integer typedefs for easier portability.
unsigned char uchar
Definition: my_inttypes.h:51
#define INT_MAX32
Definition: my_inttypes.h:77
int32_t int32
Definition: my_inttypes.h:65
uint16_t uint16
Definition: my_inttypes.h:64
Defines various enable/disable and HAVE_ macros related to the performance schema instrumentation sys...
Common header for many mysys elements.
Defines for getting and processing the current system type programmatically.
std::uint64_t Timeout_type
Type alias to reduce chance of conversion errors on timeout values.
Definition: my_systime.h:124
Common definition between mysql server & client.
#define NAME_LEN
Definition: mysql_com.h:66
#define NAME_CHAR_LEN
Field/table name length.
Definition: mysql_com.h:59
Instrumentation helpers for conditions.
ABI for instrumented mutexes.
Instrumentation helpers for rwlock.
MDL_request * mdl_request(const Import_target &t, MEM_ROOT *mem_root)
Creates an MDL_request for exclusive MDL on the table being imported.
Definition: sdi_api.cc:244
MDL_request * mdl_req(THD *thd, const Tablespace_table_ref &tref, enum enum_mdl_type mdl_type)
Create am MDL_request for a the table identified by a Tablespace_table_ref.
Definition: tablespace_impl.cc:533
Definition: mdl.h:57
bool test_drive_fix_pins(MDL_context *)
Cursor end()
A past-the-end Cursor.
Definition: rules_table_service.cc:191
Instrumentation helpers for rwlock.
Performance schema instrumentation interface.
Performance schema instrumentation interface.
required string type
Definition: replication_group_member_actions.proto:33
case opt name
Definition: sslopt-case.h:32
Hook class which via its methods specifies which members of T should be used for participating in a i...
Definition: sql_plist.h:197
Definition: lf.h:83
Metadata lock object key.
Definition: mdl.h:364
uint16 m_db_name_length
Definition: mdl.h:786
int cmp(const MDL_key *rhs) const
Compare two MDL keys lexicographically.
Definition: mdl.h:736
const char * db_name() const
Definition: mdl.h:427
static void init_psi_keys()
Definition: mdl.cc:136
uint db_name_length() const
Definition: mdl.h:428
MDL_key(const MDL_key &rhs)
Definition: mdl.h:750
uint name_length() const
Definition: mdl.h:434
bool is_equal(const MDL_key *rhs) const
Definition: mdl.h:729
const char * name() const
Definition: mdl.h:430
void mdl_key_init(enum_mdl_namespace mdl_namespace, const char *db, const char *name)
Construct a metadata lock key from a triplet (mdl_namespace, database and name).
Definition: mdl.h:475
enum_mdl_namespace
Object namespaces.
Definition: mdl.h:400
@ BACKUP_LOCK
Definition: mdl.h:402
@ EVENT
Definition: mdl.h:409
@ GLOBAL
Definition: mdl.h:401
@ LOCKING_SERVICE
Definition: mdl.h:412
@ USER_LEVEL_LOCK
Definition: mdl.h:411
@ COLUMN_STATISTICS
Definition: mdl.h:415
@ COMMIT
Definition: mdl.h:410
@ RESOURCE_GROUPS
Definition: mdl.h:416
@ RESOURCE_GROUPS_GLOBAL
Definition: mdl.h:419
@ SCHEMA
Definition: mdl.h:404
@ NAMESPACE_END
Definition: mdl.h:421
@ FUNCTION
Definition: mdl.h:406
@ TRIGGER
Definition: mdl.h:408
@ ACL_CACHE
Definition: mdl.h:414
@ FOREIGN_KEY
Definition: mdl.h:417
@ SRID
Definition: mdl.h:413
@ PROCEDURE
Definition: mdl.h:407
@ TABLESPACE
Definition: mdl.h:403
@ TABLE
Definition: mdl.h:405
@ CHECK_CONSTRAINT
Definition: mdl.h:418
enum_mdl_namespace mdl_namespace() const
Definition: mdl.h:460
void mdl_key_init(const MDL_key *rhs)
Definition: mdl.h:714
void mdl_key_init(enum_mdl_namespace mdl_namespace, const char *db, const char *normalized_name, size_t normalized_name_len, const char *name)
Construct a metadata lock key from a quadruplet (mdl_namespace, database, normalized object name buff...
Definition: mdl.h:639
uint16 m_length
Definition: mdl.h:785
MDL_key()=default
uint length() const
Definition: mdl.h:425
char m_ptr[MAX_MDLKEY_LENGTH]
Definition: mdl.h:788
const uchar * ptr() const
Definition: mdl.h:424
const char * col_name() const
Definition: mdl.h:436
MDL_key & operator=(const MDL_key &rhs)
Definition: mdl.h:752
uint col_name_length() const
Definition: mdl.h:448
void mdl_key_init(enum_mdl_namespace mdl_namespace, const char *part_key, size_t part_key_length, size_t db_length)
Construct a metadata lock key from namespace and partial key, which contains info about object databa...
Definition: mdl.h:690
void reset()
Definition: mdl.h:723
MDL_key(enum_mdl_namespace namespace_arg, const char *db_arg, const char *name_arg)
Definition: mdl.h:757
uint16 m_object_name_length
Definition: mdl.h:787
void mdl_key_init(enum_mdl_namespace mdl_namespace, const char *db, const char *name, const char *column_name)
Construct a metadata lock key from a quadruplet (mdl_namespace, database, table and column name).
Definition: mdl.h:522
bool use_normalized_object_name() const
Check if normalized object name should be used.
Definition: mdl.h:778
const PSI_stage_info * get_wait_state_name() const
Get thread state name to be used in case when we have to wait on resource identified by key.
Definition: mdl.h:767
static PSI_stage_info m_namespace_to_wait_state_name[NAMESPACE_END]
Thread state names to be used in case when we have to wait on resource belonging to certain namespace...
Definition: mdl.h:789
Definition: mdl.h:1135
MDL_ticket * m_mat_front
m_mat_front tracks what was the front of m_ticket_list, the last time MDL_context::materialize_fast_p...
Definition: mdl.h:1148
Ticket_p_list m_ticket_list
Definition: mdl.h:1136
Definition: mdl.h:1153
size_t operator()(const MDL_key *k) const
Definition: mdl.cc:4633
Definition: mdl.h:1157
bool operator()(const MDL_key *a, const MDL_key *b) const
Definition: mdl.h:1158
Utility struct for representing a ticket pointer and its duration.
Definition: mdl.h:1120
enum_mdl_duration m_dur
Definition: mdl.h:1121
MDL_ticket_handle(MDL_ticket *t, enum_mdl_duration d)
Definition: mdl.h:1125
MDL_ticket * m_ticket
Definition: mdl.h:1122
The MEM_ROOT is a simple arena, where allocations are carved out of larger blocks.
Definition: my_alloc.h:82
void * Alloc(size_t length)
Allocate memory.
Definition: my_alloc.h:144
Stage instrument information.
Definition: psi_stage_bits.h:73
An instrumented cond structure.
Definition: mysql_cond_bits.h:49
An instrumented mutex structure.
Definition: mysql_mutex_bits.h:49
An instrumented prlock structure.
Definition: mysql_rwlock_bits.h:71
unsigned int uint
Definition: uca-dump.cc:29