MySQL 8.0.29
Source Code Documentation
mdl.h
Go to the documentation of this file.
1#ifndef MDL_H
2#define MDL_H
3/* Copyright (c) 2009, 2021, 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 Note that requests waiting for user-level locks get special
397 treatment - waiting is aborted if connection to client is lost.
398 */
418 /* This should be the last ! */
420 };
421
422 const uchar *ptr() const { return pointer_cast<const uchar *>(m_ptr); }
423 uint length() const { return m_length; }
424
425 const char *db_name() const { return m_ptr + 1; }
427
428 const char *name() const {
430 : m_ptr + m_db_name_length + 2);
431 }
433
434 const char *col_name() const {
436
438 /* A column name was stored in the key buffer. */
440 }
441
442 /* No column name stored. */
443 return nullptr;
444 }
445
448
450 /* A column name was stored in the key buffer. */
452 }
453
454 /* No column name stored. */
455 return 0;
456 }
457
459 return (enum_mdl_namespace)(m_ptr[0]);
460 }
461
462 /**
463 Construct a metadata lock key from a triplet (mdl_namespace,
464 database and name).
465
466 @remark The key for a table is @<mdl_namespace@>+@<database name@>+@<table
467 name@>
468
469 @param mdl_namespace Id of namespace of object to be locked
470 @param db Name of database to which the object belongs
471 @param name Name of of the object
472 */
474 const char *name) {
475 m_ptr[0] = (char)mdl_namespace;
476
478
479 /*
480 It is responsibility of caller to ensure that db and object names
481 are not longer than NAME_LEN. Still we play safe and try to avoid
482 buffer overruns.
483
484 Implicit tablespace names in InnoDB may be longer than NAME_LEN.
485 We will lock based on the first NAME_LEN characters.
486
487 TODO: The patch acquires metadata locks on the NAME_LEN
488 first bytest of the tablespace names. For long names,
489 the consequence of locking on this prefix is
490 that locking a single implicit tablespace might end up
491 effectively lock all implicit tablespaces in the same
492 schema. A possible fix is to lock on a prefix of length
493 NAME_LEN * 2, since this is the real buffer size of
494 the metadata lock key. Dependencies from the PFS
495 implementation, possibly relying on the key format,
496 must be investigated first, though.
497 */
498 assert(strlen(db) <= NAME_LEN);
499 assert((mdl_namespace == TABLESPACE) || (strlen(name) <= NAME_LEN));
501 static_cast<uint16>(strmake(m_ptr + 1, db, NAME_LEN) - m_ptr - 1);
502 m_object_name_length = static_cast<uint16>(
504 m_db_name_length - 2);
506 }
507
508 /**
509 Construct a metadata lock key from a quadruplet (mdl_namespace,
510 database, table and column name).
511
512 @remark The key for a column is
513 @<mdl_namespace@>+@<database name@>+@<table name@>+@<column name@>
514
515 @param mdl_namespace Id of namespace of object to be locked
516 @param db Name of database to which the object belongs
517 @param name Name of of the object
518 @param column_name Name of of the column
519 */
521 const char *name, const char *column_name) {
522 m_ptr[0] = (char)mdl_namespace;
523 char *start;
524 char *end;
525
527
528 assert(strlen(db) <= NAME_LEN);
529 start = m_ptr + 1;
530 end = strmake(start, db, NAME_LEN);
531 m_db_name_length = static_cast<uint16>(end - start);
532
533 assert(strlen(name) <= NAME_LEN);
534 start = end + 1;
536 m_object_name_length = static_cast<uint16>(end - start);
537
538 size_t col_len = strlen(column_name);
539 assert(col_len <= NAME_LEN);
540 start = end + 1;
541 size_t remaining =
543 uint16 extra_length = 0;
544
545 /*
546 In theory:
547 - schema name is up to NAME_LEN characters
548 - object name is up to NAME_LEN characters
549 - column name is up to NAME_LEN characters
550 - NAME_LEN is 64 characters
551 - 1 character is up to 3 bytes (UTF8MB3),
552 and when moving to UTF8MB4, up to 4 bytes.
553 - Storing a SCHEMA + OBJECT MDL key
554 can take up to 387 bytes
555 - Storing a SCHEMA + OBJECT + COLUMN MDL key
556 can take up to 580 bytes.
557
558 In practice:
559 - full storage is allocated for SCHEMA + OBJECT only,
560 storage for COLUMN is **NOT** reserved.
561 - SCHEMA and OBJECT names are typically shorter,
562 and are not using systematically multi-bytes characters
563 for each character, so that less space is required.
564 - MDL keys that are not COLUMN_STATISTICS
565 are stored in full, without truncation.
566
567 For the COLUMN_STATISTICS name space:
568 - either the full SCHEMA + OBJECT + COLUMN key fits
569 within 387 bytes, in which case the fully qualified
570 column name is stored,
571 leading to MDL locks per column (as intended)
572 - or the SCHEMA and OBJECT names are very long,
573 so that not enough room is left to store a column name,
574 in which case the MDL key is truncated to be
575 COLUMN_STATISTICS + SCHEMA + NAME.
576 In this case, MDL locks for columns col_X and col_Y
577 in table LONG_FOO.LONG_BAR will both share the same
578 key LONG_FOO.LONG_BAR, in effect providing a lock
579 granularity not per column but per table.
580 This is a degraded mode of operation,
581 which serializes MDL access to columns
582 (for tables with a very long fully qualified name),
583 to reduce the memory footprint for all MDL access.
584
585 To be revised if the MDL key buffer is allocated dynamically
586 instead.
587 */
588
589 static_assert(MAX_MDLKEY_LENGTH == 387, "UTF8MB3");
590
591 /*
592 Check if there is room to store the whole column name.
593 This code is not trying to store truncated column names,
594 to avoid cutting column_name in the middle of a
595 multi-byte character.
596 */
597 if (remaining >= col_len + 1) {
598 end = strmake(start, column_name, remaining);
599 extra_length = static_cast<uint16>(end - start) + 1; // With \0
600 }
601 m_length = m_db_name_length + m_object_name_length + 3 + extra_length;
602 assert(m_length <= MAX_MDLKEY_LENGTH);
603 }
604
605 /**
606 Construct a metadata lock key from a quadruplet (mdl_namespace, database,
607 normalized object name buffer and the object name).
608
609 @remark The key for a routine/event/resource group/trigger is
610 @<mdl_namespace@>+@<database name@>+@<normalized object name@>
611 additionaly @<object name@> is stored in the same buffer for information
612 purpose if buffer has sufficent space.
613
614 Routine, Event and Resource group names are case sensitive and accent
615 sensitive. So normalized object name is used to form a MDL_key.
616
617 With the UTF8MB3 charset space reserved for the db name/object name is
618 64 * 3 bytes. utf8_general_ci collation is used for the Routine, Event and
619 Resource group names. With this collation, the normalized object name uses
620 just 2 bytes for each character (max length = 64 * 2 bytes). MDL_key has
621 still some space to store the object names. If there is a sufficient space
622 for the object name in the MDL_key then it is stored in the MDL_key (similar
623 to the column names in the MDL_key). Actual object name is used by the PFS.
624 Not listing actual object name from the PFS should be OK when there is no
625 space to store it (instead of increasing the MDL_key size). Object name is
626 not used in the key comparisons. So only (mdl_namespace + strlen(db) + 1 +
627 normalized_name_len + 1) value is stored in the m_length member.
628
629 @param mdl_namespace Id of namespace of object to be locked.
630 @param db Name of database to which the object belongs.
631 @param normalized_name Normalized name of the object.
632 @param normalized_name_len Length of the normalized object name.
633 @param name Name of the object.
634 */
636 const char *normalized_name, size_t normalized_name_len,
637 const char *name) {
638 m_ptr[0] = (char)mdl_namespace;
639
640 /*
641 FUNCTION, PROCEDURE, EVENT and RESOURCE_GROUPS names are case and accent
642 insensitive. For other objects key should not be formed from this method.
643 */
645
646 assert(strlen(db) <= NAME_LEN && strlen(name) <= NAME_LEN &&
647 normalized_name_len <= NAME_CHAR_LEN * 2);
648
649 // Database name.
651 static_cast<uint16>(strmake(m_ptr + 1, db, NAME_LEN) - m_ptr - 1);
652
653 // Normalized object name.
654 m_length = static_cast<uint16>(m_db_name_length + normalized_name_len + 3);
655 memcpy(m_ptr + m_db_name_length + 2, normalized_name, normalized_name_len);
656 *(m_ptr + m_length - 1) = 0;
657
658 /*
659 Copy name of the object if there is a sufficient space to store the name
660 in the MDL key. This code is not trying to store truncated object names,
661 to avoid cutting object_name in the middle of a multi-byte character.
662 */
663 if (strlen(name) < static_cast<size_t>(MAX_MDLKEY_LENGTH - m_length)) {
664 m_object_name_length = static_cast<uint16>(
666 m_ptr - m_length));
667 } else {
669 *(m_ptr + m_length) = 0;
670 }
671
673 }
674
675 /**
676 Construct a metadata lock key from namespace and partial key, which
677 contains info about object database and name.
678
679 @remark The partial key must be "<database>\0<name>\0".
680
681 @param mdl_namespace Id of namespace of object to be locked
682 @param part_key Partial key.
683 @param part_key_length Partial key length
684 @param db_length Database name length.
685 */
687 size_t part_key_length, size_t db_length) {
688 /*
689 Key suffix provided should be in compatible format and
690 its components should adhere to length restrictions.
691 */
692 assert(strlen(part_key) == db_length);
693 assert(db_length + 1 + strlen(part_key + db_length + 1) + 1 ==
694 part_key_length);
695 assert(db_length <= NAME_LEN);
696 assert(part_key_length <= NAME_LEN + 1 + NAME_LEN + 1);
697
698 m_ptr[0] = (char)mdl_namespace;
699 /*
700 Partial key of objects with normalized object name can not be used to
701 initialize MDL key.
702 */
704
705 memcpy(m_ptr + 1, part_key, part_key_length);
706 m_length = static_cast<uint16>(part_key_length + 1);
707 m_db_name_length = static_cast<uint16>(db_length);
709 }
710 void mdl_key_init(const MDL_key *rhs) {
711 uint16 copy_length = rhs->use_normalized_object_name()
712 ? rhs->m_length + rhs->m_object_name_length + 1
713 : rhs->m_length;
714 memcpy(m_ptr, rhs->m_ptr, copy_length);
715 m_length = rhs->m_length;
718 }
719 void reset() {
720 m_ptr[0] = NAMESPACE_END;
723 m_length = 0;
724 }
725 bool is_equal(const MDL_key *rhs) const {
726 return (m_length == rhs->m_length &&
727 memcmp(m_ptr, rhs->m_ptr, m_length) == 0);
728 }
729 /**
730 Compare two MDL keys lexicographically.
731 */
732 int cmp(const MDL_key *rhs) const {
733 /*
734 For the keys with the normalized names, there is a possibility of getting
735 '\0' in its middle. So only key content comparison would yield incorrect
736 result. Hence comparing key length too when keys are equal.
737 For other keys, key buffer is always '\0'-terminated. Since key character
738 set is utf-8, we can safely assume that no character starts with a zero
739 byte.
740 */
741 int res = memcmp(m_ptr, rhs->m_ptr, std::min(m_length, rhs->m_length));
742 if (res == 0) res = m_length - rhs->m_length;
743 return res;
744 }
745
746 MDL_key(const MDL_key &rhs) { mdl_key_init(&rhs); }
747
748 MDL_key &operator=(const MDL_key &rhs) {
749 mdl_key_init(&rhs);
750 return *this;
751 }
752
753 MDL_key(enum_mdl_namespace namespace_arg, const char *db_arg,
754 const char *name_arg) {
755 mdl_key_init(namespace_arg, db_arg, name_arg);
756 }
757 MDL_key() = default; /* To use when part of MDL_request. */
758
759 /**
760 Get thread state name to be used in case when we have to
761 wait on resource identified by key.
762 */
765 }
766
767 private:
768 /**
769 Check if normalized object name should be used.
770
771 @return true if normlized object name should be used, false
772 otherwise.
773 */
775 return (mdl_namespace() == FUNCTION || mdl_namespace() == PROCEDURE ||
778 }
779
780 private:
786};
787
788/**
789 A pending metadata lock request.
790
791 A lock request and a granted metadata lock are represented by
792 different classes because they have different allocation
793 sites and hence different lifetimes. The allocation of lock requests is
794 controlled from outside of the MDL subsystem, while allocation of granted
795 locks (tickets) is controlled within the MDL subsystem.
796*/
797
799 public:
800 /** Type of metadata lock. */
802 /** Duration for requested lock. */
804
805 /**
806 Pointers for participating in the list of lock requests for this context.
807 */
810 /**
811 Pointer to the lock ticket object for this lock request.
812 Valid only if this lock request is satisfied.
813 */
815
816 /** A lock is requested based on a fully qualified name and type. */
818
819 const char *m_src_file{nullptr};
821
822 public:
823 static void *operator new(size_t size, MEM_ROOT *mem_root,
824 const std::nothrow_t &arg
825 [[maybe_unused]] = std::nothrow) noexcept {
826 return mem_root->Alloc(size);
827 }
828
829 static void operator delete(void *, MEM_ROOT *,
830 const std::nothrow_t &) noexcept {}
831
833 const char *db_arg, const char *name_arg,
834 enum_mdl_type mdl_type_arg,
835 enum_mdl_duration mdl_duration_arg,
836 const char *src_file, uint src_line);
837 void init_by_key_with_source(const MDL_key *key_arg,
838 enum_mdl_type mdl_type_arg,
839 enum_mdl_duration mdl_duration_arg,
840 const char *src_file, uint src_line);
842 const char *part_key_arg,
843 size_t part_key_length_arg,
844 size_t db_length_arg,
845 enum_mdl_type mdl_type_arg,
846 enum_mdl_duration mdl_duration_arg,
847 const char *src_file, uint src_line);
848 /** Set type of lock request. Can be only applied to pending locks. */
849 inline void set_type(enum_mdl_type type_arg) {
850 assert(ticket == nullptr);
851 type = type_arg;
852 }
853
854 /**
855 Is this a request for a lock which allow data to be updated?
856
857 @note This method returns true for MDL_SHARED_UPGRADABLE type of
858 lock. Even though this type of lock doesn't allow updates
859 it will always be upgraded to one that does.
860 */
863 }
864
865 /** Is this a request for a strong, DDL/LOCK TABLES-type, of lock? */
867 return type >= MDL_SHARED_UPGRADABLE;
868 }
869
870 /**
871 This constructor exists for two reasons:
872
873 - TABLE_LIST objects are sometimes default-constructed. We plan to remove
874 this as there is no practical reason, the call to the default
875 constructor is always followed by either a call to TABLE_LIST::operator=
876 or memberwise assignments.
877
878 - In some legacy cases TABLE_LIST objects are copy-assigned without
879 intention to copy the TABLE_LIST::mdl_request member. In this cases they
880 are overwritten with an uninitialized MDL_request object. The cases are:
881
882 - Sql_cmd_handler_open::execute()
883 - mysql_execute_command()
884 - Query_expression::prepare()
885 - fill_defined_view_parts()
886
887 No new cases are expected. In all other cases, so far only
888 Locked_tables_list::rename_locked_table(), a move assignment is actually
889 what is intended.
890 */
891 MDL_request() = default;
892
894 : type(rhs.type), duration(rhs.duration), ticket(nullptr), key(rhs.key) {}
895
897
899};
900
901#define MDL_REQUEST_INIT(R, P1, P2, P3, P4, P5) \
902 (*R).init_with_source(P1, P2, P3, P4, P5, __FILE__, __LINE__)
903
904#define MDL_REQUEST_INIT_BY_KEY(R, P1, P2, P3) \
905 (*R).init_by_key_with_source(P1, P2, P3, __FILE__, __LINE__)
906
907#define MDL_REQUEST_INIT_BY_PART_KEY(R, P1, P2, P3, P4, P5, P6) \
908 (*R).init_by_part_key_with_source(P1, P2, P3, P4, P5, P6, __FILE__, __LINE__)
909
910/**
911 An abstract class for inspection of a connected
912 subgraph of the wait-for graph.
913*/
914
916 public:
917 virtual bool enter_node(MDL_context *node) = 0;
918 virtual void leave_node(MDL_context *node) = 0;
919
920 virtual bool inspect_edge(MDL_context *dest) = 0;
923
924 public:
925 /**
926 XXX, hack: During deadlock search, we may need to
927 inspect TABLE_SHAREs and acquire LOCK_open. Since
928 LOCK_open is not a recursive mutex, count here how many
929 times we "took" it (but only take and release once).
930 Not using a native recursive mutex or rwlock in 5.5 for
931 LOCK_open since it has significant performance impacts.
932 */
934};
935
936/**
937 Abstract class representing an edge in the waiters graph
938 to be traversed by deadlock detection algorithm.
939*/
940
942 public:
944
945 /**
946 Accept a wait-for graph visitor to inspect the node
947 this edge is leading to.
948 */
949 virtual bool accept_visitor(MDL_wait_for_graph_visitor *gvisitor) = 0;
950
951 static const uint DEADLOCK_WEIGHT_CO = 0;
952 static const uint DEADLOCK_WEIGHT_DML = 25;
953 static const uint DEADLOCK_WEIGHT_ULL = 50;
954 static const uint DEADLOCK_WEIGHT_DDL = 100;
955
956 /* A helper used to determine which lock request should be aborted. */
957 virtual uint get_deadlock_weight() const = 0;
958};
959
960/**
961 A granted metadata lock.
962
963 @warning MDL_ticket members are private to the MDL subsystem.
964
965 @note Multiple shared locks on a same object are represented by a
966 single ticket. The same does not apply for other lock types.
967
968 @note There are two groups of MDL_ticket members:
969 - "Externally accessible". These members can be accessed from
970 threads/contexts different than ticket owner in cases when
971 ticket participates in some list of granted or waiting tickets
972 for a lock. Therefore one should change these members before
973 including then to waiting/granted lists or while holding lock
974 protecting those lists.
975 - "Context private". Such members are private to thread/context
976 owning this ticket. I.e. they should not be accessed from other
977 threads/contexts.
978*/
979
981 public:
982 /**
983 Pointers for participating in the list of lock requests for this context.
984 Context private.
985 */
988
989 /**
990 Pointers for participating in the list of satisfied/pending requests
991 for the lock. Externally accessible.
992 */
995
996 public:
997 bool has_pending_conflicting_lock() const;
998
999 MDL_context *get_ctx() const { return m_ctx; }
1003 }
1004 enum_mdl_type get_type() const { return m_type; }
1005 MDL_lock *get_lock() const { return m_lock; }
1006 const MDL_key *get_key() const;
1008
1010
1013
1014 /** Implement MDL_wait_for_subgraph interface. */
1015 bool accept_visitor(MDL_wait_for_graph_visitor *dvisitor) override;
1016 uint get_deadlock_weight() const override;
1017
1018#ifndef NDEBUG
1021#endif
1022
1023 public:
1024 /**
1025 Status of lock request represented by the ticket as reflected in P_S.
1026 */
1033
1034 private:
1035 friend class MDL_context;
1036
1038#ifndef NDEBUG
1039 ,
1040 enum_mdl_duration duration_arg
1041#endif
1042 )
1043 : m_type(type_arg),
1044#ifndef NDEBUG
1045 m_duration(duration_arg),
1046#endif
1047 m_ctx(ctx_arg),
1048 m_lock(nullptr),
1049 m_is_fast_path(false),
1050 m_hton_notified(false),
1051 m_psi(nullptr) {
1052 }
1053
1054 ~MDL_ticket() override { assert(m_psi == nullptr); }
1055
1056 static MDL_ticket *create(MDL_context *ctx_arg, enum_mdl_type type_arg
1057#ifndef NDEBUG
1058 ,
1059 enum_mdl_duration duration_arg
1060#endif
1061 );
1062 static void destroy(MDL_ticket *ticket);
1063
1064 private:
1065 /** Type of metadata lock. Externally accessible. */
1067#ifndef NDEBUG
1068 /**
1069 Duration of lock represented by this ticket.
1070 Context private. Debug-only.
1071 */
1073#endif
1074 /**
1075 Context of the owner of the metadata lock ticket. Externally accessible.
1076 */
1078
1079 /**
1080 Pointer to the lock object for this lock ticket. Externally accessible.
1081 */
1083
1084 /**
1085 Indicates that ticket corresponds to lock acquired using "fast path"
1086 algorithm. Particularly this means that it was not included into
1087 MDL_lock::m_granted bitmap/list and instead is accounted for by
1088 MDL_lock::m_fast_path_locks_granted_counter
1089 */
1091
1092 /**
1093 Indicates that ticket corresponds to lock request which required
1094 storage engine notification during its acquisition and requires
1095 storage engine notification after its release.
1096 */
1098
1100
1101 private:
1102 MDL_ticket(const MDL_ticket &); /* not implemented */
1103 MDL_ticket &operator=(const MDL_ticket &); /* not implemented */
1104};
1105
1106/**
1107 Keep track of MDL_ticket for different durations. Maintains a
1108 hash-based secondary index into the linked lists, to speed up access
1109 by MDL_key.
1110 */
1112 public:
1113 /**
1114 Utility struct for representing a ticket pointer and its duration.
1115 */
1119
1122 : m_dur{d}, m_ticket{t} {}
1123 };
1124
1125 private:
1130
1131 struct Duration {
1133 /**
1134 m_mat_front tracks what was the front of m_ticket_list, the last
1135 time MDL_context::materialize_fast_path_locks() was called. This
1136 just an optimization which allows
1137 MDL_context::materialize_fast_path_locks() only to consider the
1138 locks added since the last time it ran. Consequently, it can be
1139 assumed that every ticket after m_mat_front is materialized, but
1140 the converse is not necessarily true as new, already
1141 materialized, locks may have been added since the last time
1142 materialize_fast_path_locks() ran.
1143 */
1145 };
1146
1148
1149 struct Hash {
1150 size_t operator()(const MDL_key *k) const;
1151 };
1152
1153 struct Key_equal {
1154 bool operator()(const MDL_key *a, const MDL_key *b) const {
1155 return a->is_equal(b);
1156 }
1157 };
1158
1159 using Ticket_map = std::unordered_multimap<const MDL_key *, MDL_ticket_handle,
1160 Hash, Key_equal>;
1161
1162 /**
1163 If the number of tickets in the ticket store (in all durations) is equal
1164 to, or exceeds this constant the hash index (in the form of an
1165 unordered_multi_map) will be maintained and used for lookups.
1166
1167 The value 256 is chosen as it has worked well in benchmarks.
1168 */
1169 const size_t THRESHOLD = 256;
1170
1171 /**
1172 Initial number of buckets in the hash index. THRESHOLD is chosen
1173 to get a fill-factor of 50% when reaching the threshold value.
1174 */
1176 size_t m_count = 0;
1177
1178 std::unique_ptr<Ticket_map> m_map;
1179
1181 MDL_ticket_handle find_in_hash(const MDL_request &req) const;
1182
1183 public:
1184 /**
1185 Public alias.
1186 */
1188
1189 /**
1190 Constructs store. The hash index is initially empty. Filled on demand.
1191 */
1193 : // Comment in to test threshold values in unit test micro benchmark
1194 // THRESHOLD{read_from_env("TS_THRESHOLD", 500)},
1195 m_map{nullptr} {}
1196
1197 /**
1198 Calls the closure provided as argument for each of the MDL_tickets
1199 in the given duration.
1200 @param dur duration list to iterate over
1201 @param clos closure to invoke for each ticket in the list
1202 */
1203 template <typename CLOS>
1205 List_iterator it(m_durations[dur].m_ticket_list);
1206 for (MDL_ticket *t = it++; t != nullptr; t = it++) {
1207 clos(t, dur);
1208 }
1209 }
1210
1211 /**
1212 Calls the closure provided as argument for each of the MDL_tickets
1213 in the store.
1214 @param clos closure to invoke for each ticket in the store
1215 */
1216 template <typename CLOS>
1218 for_each_ticket_in_duration_list(MDL_STATEMENT, std::forward<CLOS>(clos));
1219 for_each_ticket_in_duration_list(MDL_TRANSACTION, std::forward<CLOS>(clos));
1220 for_each_ticket_in_duration_list(MDL_EXPLICIT, std::forward<CLOS>(clos));
1221 }
1222
1223 /**
1224 Predicate for the emptiness of the store.
1225 @return true if there are no tickets in the store
1226 */
1227 bool is_empty() const;
1228
1229 /**
1230 Predicate for the emptiness of a given duration list.
1231 @param di the duration to check
1232 @return true if there are no tickets with the given duration
1233 */
1234 bool is_empty(int di) const;
1235
1236 /**
1237 Return the first MDL_ticket for the given duration.
1238
1239 @param di duration to get first ticket for
1240
1241 @return first ticket in the given duration or nullptr if no such
1242 tickets exist
1243 */
1244 MDL_ticket *front(int di);
1245
1246 /**
1247 Push a ticket onto the list for a given duration.
1248 @param dur duration list to push into
1249 @param ticket to push
1250 */
1251 void push_front(enum_mdl_duration dur, MDL_ticket *ticket);
1252
1253 /**
1254 Remove a ticket from a duration list. Note that since the
1255 underlying list is an intrusive linked list there is no guarantee
1256 that the ticket is actually in the duration list. It will be
1257 removed from which ever list it is in.
1258 */
1259 void remove(enum_mdl_duration dur, MDL_ticket *ticket);
1260
1261 /**
1262 Return a P-list iterator to the given duration.
1263 @param di duration list index
1264 @return P-list iterator to tickets with given duration
1265 */
1268 }
1269
1270 /**
1271 Move all tickets to the explicit duration list.
1272 */
1274
1275 /**
1276 Move all tickets to the transaction duration list.
1277 */
1279
1280 /**
1281 Look up a ticket based on its MDL_key.
1282 @param req request to locate ticket for
1283 @return MDL_ticket_handle with ticket pointer and found duration
1284 (or nullptr and MDL_DURATION_END if not found
1285 */
1286 MDL_ticket_handle find(const MDL_request &req) const;
1287
1288 /**
1289 Mark boundary for tickets with fast_path=false, so that later
1290 calls to materialize_fast_path_locks() do not have to traverse the
1291 whole set of tickets.
1292 */
1293 void set_materialized();
1294
1295 /**
1296 Return the first ticket for which materialize_fast_path_locks
1297 already has been called for the given duration.
1298
1299 @param di duration list index
1300 @return first materialized ticket for the given duration
1301 */
1303};
1304
1305/**
1306 Savepoint for MDL context.
1307
1308 Doesn't include metadata locks with explicit duration as
1309 they are not released during rollback to savepoint.
1310*/
1311
1313 public:
1314 MDL_savepoint() = default;
1315
1316 private:
1317 MDL_savepoint(MDL_ticket *stmt_ticket, MDL_ticket *trans_ticket)
1318 : m_stmt_ticket(stmt_ticket), m_trans_ticket(trans_ticket) {}
1319
1320 friend class MDL_context;
1321
1322 private:
1323 /**
1324 Pointer to last lock with statement duration which was taken
1325 before creation of savepoint.
1326 */
1328 /**
1329 Pointer to last lock with transaction duration which was taken
1330 before creation of savepoint.
1331 */
1333};
1334
1335/**
1336 A reliable way to wait on an MDL lock.
1337*/
1338
1340 public:
1341 MDL_wait();
1342 ~MDL_wait();
1343
1344 // WS_EMPTY since EMPTY conflicts with #define in system headers on some
1345 // platforms.
1347
1348 bool set_status(enum_wait_status result_arg);
1350 void reset_status();
1352 struct timespec *abs_timeout, bool signal_timeout,
1353 const PSI_stage_info *wait_state_name);
1354
1355 private:
1356 /**
1357 Condvar which is used for waiting until this context's pending
1358 request can be satisfied or this thread has to perform actions
1359 to resolve a potential deadlock (we subscribe to such
1360 notification by adding a ticket corresponding to the request
1361 to an appropriate queue of waiters).
1362 */
1366};
1367
1368/**
1369 Base class to find out if the lock represented by a given ticket
1370 should be released. Users of release_locks() need to subclass
1371 this and specify an implementation of release(). Only for locks
1372 with explicit duration.
1373*/
1374
1376 public:
1377 virtual ~MDL_release_locks_visitor() = default;
1378 /**
1379 Check if the given ticket represents a lock that should be released.
1380
1381 @retval true if the lock should be released, false otherwise.
1382 */
1383 virtual bool release(MDL_ticket *ticket) = 0;
1384};
1385
1386/**
1387 Abstract visitor class for inspecting MDL_context.
1388*/
1389
1391 public:
1392 virtual ~MDL_context_visitor() = default;
1393 virtual void visit_context(const MDL_context *ctx) = 0;
1394};
1395
1396typedef I_P_List<MDL_request,
1401
1402/**
1403 Context of the owner of metadata locks. I.e. each server
1404 connection has such a context.
1405*/
1406
1408 public:
1409 typedef I_P_List<MDL_ticket,
1413
1415
1416 MDL_context();
1417 void destroy();
1418
1420 bool acquire_lock(MDL_request *mdl_request, Timeout_type lock_wait_timeout);
1421 bool acquire_locks(MDL_request_list *requests,
1422 Timeout_type lock_wait_timeout);
1423 bool upgrade_shared_lock(MDL_ticket *mdl_ticket, enum_mdl_type new_type,
1424 Timeout_type lock_wait_timeout);
1425
1427
1428 /**
1429 Create copy of all granted tickets of particular duration from given
1430 context to current context.
1431 Used by XA for preserving locks during client disconnect.
1432
1433 @param ticket_owner Owner of tickets to be cloned
1434 @param duration MDL lock duration for that tickets are to be cloned
1435
1436 @retval true Out of memory or deadlock happened or
1437 lock request was refused by storage engine.
1438 @retval false Success.
1439 */
1440
1441 bool clone_tickets(const MDL_context *ticket_owner,
1442 enum_mdl_duration duration);
1443
1446 void release_lock(MDL_ticket *ticket);
1447
1448 bool owns_equal_or_stronger_lock(const MDL_key *mdl_key,
1449 enum_mdl_type mdl_type);
1450
1452 const char *db, const char *name,
1453 enum_mdl_type mdl_type);
1454
1455 bool find_lock_owner(const MDL_key *mdl_key, MDL_context_visitor *visitor);
1456
1457 bool has_lock(const MDL_savepoint &mdl_savepoint, MDL_ticket *mdl_ticket);
1458
1459 inline bool has_locks() const { return !m_ticket_store.is_empty(); }
1460
1461 bool has_locks(MDL_key::enum_mdl_namespace mdl_namespace) const;
1462
1463 bool has_locks_waited_for() const;
1464
1465#ifndef NDEBUG
1467 return !m_ticket_store.is_empty(duration);
1468 }
1469#endif
1470
1474 }
1475
1478 void set_lock_duration(MDL_ticket *mdl_ticket, enum_mdl_duration duration);
1479
1483
1485
1486 /** @pre Only valid if we started waiting for lock. */
1487 inline uint get_deadlock_weight() const {
1491 }
1492
1493 void init(MDL_context_owner *arg) { m_owner = arg; }
1494
1495 void set_needs_thr_lock_abort(bool needs_thr_lock_abort) {
1496 /*
1497 @note In theory, this member should be modified under protection
1498 of some lock since it can be accessed from different threads.
1499 In practice, this is not necessary as code which reads this
1500 value and so might miss the fact that value was changed will
1501 always re-try reading it after small timeout and therefore
1502 will see the new value eventually.
1503 */
1504 m_needs_thr_lock_abort = needs_thr_lock_abort;
1505
1507 /*
1508 For MDL_object_lock::notify_conflicting_locks() to work properly
1509 all context requiring thr_lock aborts should not have any "fast
1510 path" locks.
1511 */
1513 }
1514 }
1516
1517 void set_force_dml_deadlock_weight(bool force_dml_deadlock_weight) {
1518 m_force_dml_deadlock_weight = force_dml_deadlock_weight;
1519 }
1520
1521 /**
1522 Get pseudo random value in [0 .. 2^31-1] range.
1523
1524 @note We use Linear Congruential Generator with venerable constant
1525 parameters for this.
1526 It is known to have problems with its lower bits are not being
1527 very random so probably is not good enough for generic use.
1528 However, we only use it to do random dives into MDL_lock objects
1529 hash when searching for unused objects to be freed, and for this
1530 purposes it is sufficient.
1531 We rely on values of "get_random() % 2^k" expression having "2^k"
1532 as a period to ensure that random dives eventually cover all hash
1533 (the former can be proven to be true). This also means that there
1534 is no bias towards any specific objects to be expelled (as hash
1535 values don't repeat), which is nice for performance.
1536 */
1538 if (m_rand_state > INT_MAX32) {
1539 /*
1540 Perform lazy initialization of LCG. We can't initialize it at the
1541 point when MDL_context is created since THD represented through
1542 MDL_context_owner interface is not fully initialized at this point
1543 itself.
1544 */
1546 }
1547 m_rand_state = (m_rand_state * 1103515245 + 12345) & INT_MAX32;
1548 return m_rand_state;
1549 }
1550
1551 /**
1552 Within MDL subsystem this one is only used for DEBUG_SYNC.
1553 Do not use it to peek/poke into other parts of THD from MDL.
1554 @sa MDL_context_owner::get_thd().
1555 */
1556 THD *get_thd() const { return m_owner->get_thd(); }
1557
1558 public:
1559 /**
1560 If our request for a lock is scheduled, or aborted by the deadlock
1561 detector, the result is recorded in this class.
1562 */
1564
1565 private:
1566 /**
1567 Lists of all MDL tickets acquired by this connection.
1568
1569 Lists of MDL tickets:
1570 ---------------------
1571 The entire set of locks acquired by a connection can be separated
1572 in three subsets according to their duration: locks released at
1573 the end of statement, at the end of transaction and locks are
1574 released explicitly.
1575
1576 Statement and transactional locks are locks with automatic scope.
1577 They are accumulated in the course of a transaction, and released
1578 either at the end of uppermost statement (for statement locks) or
1579 on COMMIT, ROLLBACK or ROLLBACK TO SAVEPOINT (for transactional
1580 locks). They must not be (and never are) released manually,
1581 i.e. with release_lock() call.
1582
1583 Tickets with explicit duration are taken for locks that span
1584 multiple transactions or savepoints.
1585 These are: HANDLER SQL locks (HANDLER SQL is
1586 transaction-agnostic), LOCK TABLES locks (you can COMMIT/etc
1587 under LOCK TABLES, and the locked tables stay locked), user level
1588 locks (GET_LOCK()/RELEASE_LOCK() functions) and
1589 locks implementing "global read lock".
1590
1591 Statement/transactional locks are always prepended to the
1592 beginning of the appropriate list. In other words, they are
1593 stored in reverse temporal order. Thus, when we rollback to
1594 a savepoint, we start popping and releasing tickets from the
1595 front until we reach the last ticket acquired after the savepoint.
1596
1597 Locks with explicit duration are not stored in any
1598 particular order, and among each other can be split into
1599 four sets:
1600 - LOCK TABLES locks
1601 - User-level locks
1602 - HANDLER locks
1603 - GLOBAL READ LOCK locks
1604 */
1606
1608 /**
1609 true - if for this context we will break protocol and try to
1610 acquire table-level locks while having only S lock on
1611 some table.
1612 To avoid deadlocks which might occur during concurrent
1613 upgrade of SNRW lock on such object to X lock we have to
1614 abort waits for table-level locks for such connections.
1615 false - Otherwise.
1616 */
1618
1619 /**
1620 Indicates that we need to use DEADLOCK_WEIGHT_DML deadlock
1621 weight for this context and ignore the deadlock weight provided
1622 by the MDL_wait_for_subgraph object which we are waiting for.
1623
1624 @note Can be changed only when there is a guarantee that this
1625 MDL_context is not waiting for a metadata lock or table
1626 definition entry.
1627 */
1629
1630 /**
1631 Read-write lock protecting m_waiting_for member.
1632
1633 @note The fact that this read-write lock prefers readers is
1634 important as deadlock detector won't work correctly
1635 otherwise. @sa Comment for MDL_lock::m_rwlock.
1636 */
1638 /**
1639 Tell the deadlock detector what metadata lock or table
1640 definition cache entry this session is waiting for.
1641 In principle, this is redundant, as information can be found
1642 by inspecting waiting queues, but we'd very much like it to be
1643 readily available to the wait-for graph iterator.
1644 */
1646 /**
1647 Thread's pins (a.k.a. hazard pointers) to be used by lock-free
1648 implementation of MDL_map::m_locks container. NULL if pins are
1649 not yet allocated from container's pinbox.
1650 */
1652 /**
1653 State for pseudo random numbers generator (PRNG) which output
1654 is used to perform random dives into MDL_lock objects hash
1655 when searching for unused objects to free.
1656 */
1658
1659 private:
1662 MDL_ticket *sentinel);
1663 void release_lock(enum_mdl_duration duration, MDL_ticket *ticket);
1666
1668 bool fix_pins();
1669
1670 public:
1671 void find_deadlock();
1672
1674
1675 /** Inform the deadlock detector there is an edge in the wait-for graph. */
1676 void will_wait_for(MDL_wait_for_subgraph *waiting_for_arg) {
1677 /*
1678 Before starting wait for any resource we need to materialize
1679 all "fast path" tickets belonging to this thread. Otherwise
1680 locks acquired which are represented by these tickets won't
1681 be present in wait-for graph and could cause missed deadlocks.
1682
1683 It is OK for context which doesn't wait for any resource to
1684 have "fast path" tickets, as such context can't participate
1685 in any deadlock.
1686 */
1688
1690 m_waiting_for = waiting_for_arg;
1692 }
1693
1694 /** Remove the wait-for edge from the graph after we're done waiting. */
1697 m_waiting_for = nullptr;
1699 }
1702
1703 private:
1704 MDL_context(const MDL_context &rhs); /* not implemented */
1705 MDL_context &operator=(MDL_context &rhs); /* not implemented */
1706};
1707
1708void mdl_init();
1709void mdl_destroy();
1710
1711#ifndef NDEBUG
1713#endif
1714
1715/*
1716 Metadata locking subsystem tries not to grant more than
1717 max_write_lock_count high priority, strong locks successively,
1718 to avoid starving out weak, lower priority locks.
1719*/
1720extern ulong max_write_lock_count;
1721
1723
1724/**
1725 Default value for threshold for number of unused MDL_lock objects after
1726 exceeding which we start considering freeing them. Only unit tests use
1727 different threshold value.
1728*/
1730
1731/**
1732 Ratio of unused/total MDL_lock objects after exceeding which we
1733 start trying to free unused MDL_lock objects (assuming that
1734 mdl_locks_unused_locks_low_water threshold is passed as well).
1735 Note that this value should be high enough for our algorithm
1736 using random dives into hash to work well.
1737*/
1739
1741
1742/**
1743 Inspect if MDL_context is owned by any thread.
1744*/
1746 public:
1748
1749 /**
1750 Collects relevant information about the MDL lock owner.
1751
1752 This function is only called by MDL_context::find_lock_owner() when
1753 searching for MDL lock owners to collect extra information about the
1754 owner. As we only need to know that the MDL lock is owned, setting
1755 m_exists to true is enough.
1756 */
1757
1758 void visit_context(const MDL_context *ctx [[maybe_unused]]) override {
1759 m_exists = true;
1760 }
1761
1762 /**
1763 Returns if an owner for the MDL lock being inspected exists.
1764
1765 @return true when MDL lock is owned, false otherwise.
1766 */
1767
1768 bool exists() const { return m_exists; }
1769
1770 private:
1771 /* holds information about MDL being owned by any thread */
1773};
1774
1775#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:1390
virtual ~MDL_context_visitor()=default
virtual void visit_context(const MDL_context *ctx)=0
Context of the owner of metadata locks.
Definition: mdl.h:1407
Ticket_list::Iterator Ticket_iterator
Definition: mdl.h:1414
MDL_context_owner * get_owner() const
Definition: mdl.h:1484
bool acquire_locks(MDL_request_list *requests, Timeout_type lock_wait_timeout)
Acquire exclusive locks.
Definition: mdl.cc:3628
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:4365
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:3682
MDL_savepoint mdl_savepoint()
Definition: mdl.h:1471
MDL_context()
Initialize a metadata locking context.
Definition: mdl.cc:1434
bool has_locks(enum_mdl_duration duration)
Definition: mdl.h:1466
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:3357
uint get_deadlock_weight() const
Definition: mdl.h:1487
void set_explicit_duration_for_all_locks()
Set explicit duration for all locks in the context.
Definition: mdl.cc:4620
void set_force_dml_deadlock_weight(bool force_dml_deadlock_weight)
Definition: mdl.h:1517
void init(MDL_context_owner *arg)
Definition: mdl.h:1493
MDL_context_owner * m_owner
Definition: mdl.h:1607
void release_statement_locks()
Definition: mdl.cc:4499
void set_lock_duration(MDL_ticket *mdl_ticket, enum_mdl_duration duration)
Change lock duration for transactional lock.
Definition: mdl.cc:4596
void release_lock(MDL_ticket *ticket)
Release lock with explicit duration.
Definition: mdl.cc:4202
uint get_random()
Get pseudo random value in [0 .
Definition: mdl.h:1537
mysql_prlock_t m_LOCK_waiting_for
Read-write lock protecting m_waiting_for member.
Definition: mdl.h:1637
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:4267
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:4245
void set_needs_thr_lock_abort(bool needs_thr_lock_abort)
Definition: mdl.h:1495
bool clone_ticket(MDL_request *mdl_request)
Create a copy of a granted ticket.
Definition: mdl.cc:3170
void release_locks_stored_before(enum_mdl_duration duration, MDL_ticket *sentinel)
Release all locks associated with the context.
Definition: mdl.cc:4221
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:4418
void rollback_to_savepoint(const MDL_savepoint &mdl_savepoint)
Releases metadata locks that were acquired after a specific savepoint.
Definition: mdl.cc:4476
uint m_rand_state
State for pseudo random numbers generator (PRNG) which output is used to perform random dives into MD...
Definition: mdl.h:1657
bool try_acquire_lock_impl(MDL_request *mdl_request, MDL_ticket **out_ticket)
Auxiliary method for acquiring lock without waiting.
Definition: mdl.cc:2806
MDL_context(const MDL_context &rhs)
void find_deadlock()
Try to find a deadlock.
Definition: mdl.cc:4033
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:1628
void lock_deadlock_victim()
Definition: mdl.h:1700
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:1412
LF_PINS * m_pins
Thread's pins (a.k.a.
Definition: mdl.h:1651
void materialize_fast_path_locks()
"Materialize" requests for locks which were satisfied using "fast path" by properly including them in...
Definition: mdl.cc:2757
bool try_acquire_lock(MDL_request *mdl_request)
Try to acquire one lock.
Definition: mdl.cc:2683
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:4013
bool has_locks_waited_for() const
Do we hold any locks which are possibly being waited for by another MDL_context?
Definition: mdl.cc:4566
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:1617
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:3735
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:1645
void set_transaction_duration_for_all_locks()
Set transactional duration for all locks in the context.
Definition: mdl.cc:4628
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:2653
void done_waiting_for()
Remove the wait-for edge from the graph after we're done waiting.
Definition: mdl.h:1695
THD * get_thd() const
Within MDL subsystem this one is only used for DEBUG_SYNC.
Definition: mdl.h:1556
bool get_needs_thr_lock_abort() const
Definition: mdl.h:1515
bool has_lock(const MDL_savepoint &mdl_savepoint, MDL_ticket *mdl_ticket)
Does this savepoint have this lock?
Definition: mdl.cc:4514
bool has_locks() const
Definition: mdl.h:1459
MDL_ticket_store m_ticket_store
Lists of all MDL tickets acquired by this connection.
Definition: mdl.h:1605
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:1563
void destroy()
Destroy metadata locking context.
Definition: mdl.cc:1456
bool fix_pins()
Allocate pins which are necessary to work with MDL_map container if they are not allocated already.
Definition: mdl.cc:1470
void unlock_deadlock_victim()
Definition: mdl.h:1701
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:4493
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:1676
Inspect if MDL_context is owned by any thread.
Definition: mdl.h:1745
MDL_lock_is_owned_visitor()
Definition: mdl.h:1747
bool m_exists
Definition: mdl.h:1772
bool exists() const
Returns if an owner for the MDL lock being inspected exists.
Definition: mdl.h:1768
void visit_context(const MDL_context *ctx) override
Collects relevant information about the MDL lock owner.
Definition: mdl.h:1758
The lock context.
Definition: mdl.cc:426
Base class to find out if the lock represented by a given ticket should be released.
Definition: mdl.h:1375
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:798
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:866
bool is_write_lock_request() const
Is this a request for a lock which allow data to be updated?
Definition: mdl.h:861
MDL_request(MDL_request &&)=default
enum_mdl_type type
Type of metadata lock.
Definition: mdl.h:801
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:1536
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:1565
void set_type(enum_mdl_type type_arg)
Set type of lock request.
Definition: mdl.h:849
MDL_request & operator=(MDL_request &&)=default
MDL_ticket * ticket
Pointer to the lock ticket object for this lock request.
Definition: mdl.h:814
MDL_request ** prev_in_list
Definition: mdl.h:809
const char * m_src_file
Definition: mdl.h:819
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:1502
MDL_key key
A lock is requested based on a fully qualified name and type.
Definition: mdl.h:817
enum_mdl_duration duration
Duration for requested lock.
Definition: mdl.h:803
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:808
uint m_src_line
Definition: mdl.h:820
MDL_request(const MDL_request &rhs)
Definition: mdl.h:893
Savepoint for MDL context.
Definition: mdl.h:1312
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:1332
MDL_ticket * m_stmt_ticket
Pointer to last lock with statement duration which was taken before creation of savepoint.
Definition: mdl.h:1327
MDL_savepoint(MDL_ticket *stmt_ticket, MDL_ticket *trans_ticket)
Definition: mdl.h:1317
Keep track of MDL_ticket for different durations.
Definition: mdl.h:1111
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:1217
List_iterator list_iterator(int di) const
Return a P-list iterator to the given duration.
Definition: mdl.h:1266
std::unique_ptr< Ticket_map > m_map
Definition: mdl.h:1178
MDL_ticket_handle find(const MDL_request &req) const
Look up a ticket based on its MDL_key.
Definition: mdl.cc:4880
size_t m_count
Definition: mdl.h:1176
void set_materialized()
Mark boundary for tickets with fast_path=false, so that later calls to materialize_fast_path_locks() ...
Definition: mdl.cc:4894
const size_t INITIAL_BUCKET_COUNT
Initial number of buckets in the hash index.
Definition: mdl.h:1175
MDL_ticket_handle find_in_hash(const MDL_request &req) const
Definition: mdl.cc:4653
void remove(enum_mdl_duration dur, MDL_ticket *ticket)
Remove a ticket from a duration list.
Definition: mdl.cc:4734
void move_all_to_explicit_duration()
Move all tickets to the explicit duration list.
Definition: mdl.cc:4770
void move_explicit_to_transaction_duration()
Move all tickets to the transaction duration list.
Definition: mdl.cc:4829
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:4900
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:1169
MDL_ticket_store()
Constructs store.
Definition: mdl.h:1192
void push_front(enum_mdl_duration dur, MDL_ticket *ticket)
Push a ticket onto the list for a given duration.
Definition: mdl.cc:4691
Duration m_durations[MDL_DURATION_END]
Definition: mdl.h:1147
MDL_ticket * front(int di)
Return the first MDL_ticket for the given duration.
Definition: mdl.cc:4687
MDL_ticket_handle find_in_lists(const MDL_request &req) const
Definition: mdl.cc:4636
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:1204
bool is_empty() const
Predicate for the emptiness of the store.
Definition: mdl.cc:4675
std::unordered_multimap< const MDL_key *, MDL_ticket_handle, Hash, Key_equal > Ticket_map
Definition: mdl.h:1160
A granted metadata lock.
Definition: mdl.h:980
enum enum_mdl_type m_type
Type of metadata lock.
Definition: mdl.h:1066
bool m_is_fast_path
Indicates that ticket corresponds to lock acquired using "fast path" algorithm.
Definition: mdl.h:1090
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:2595
bool has_pending_conflicting_lock() const
Check if we have any pending locks which conflict with existing shared lock.
Definition: mdl.cc:4459
MDL_context * get_ctx() const
Definition: mdl.h:999
void downgrade_lock(enum_mdl_type type)
Downgrade an EXCLUSIVE or SHARED_NO_WRITE lock to shared metadata lock.
Definition: mdl.cc:4285
~MDL_ticket() override
Definition: mdl.h:1054
MDL_ticket(MDL_context *ctx_arg, enum_mdl_type type_arg, enum_mdl_duration duration_arg)
Definition: mdl.h:1037
MDL_ticket & operator=(const MDL_ticket &)
static void destroy(MDL_ticket *ticket)
Definition: mdl.cc:1679
bool accept_visitor(MDL_wait_for_graph_visitor *dvisitor) override
Implement MDL_wait_for_subgraph interface.
Definition: mdl.cc:3993
bool is_incompatible_when_waiting(enum_mdl_type type) const
Definition: mdl.cc:2606
MDL_ticket * next_in_context
Pointers for participating in the list of lock requests for this context.
Definition: mdl.h:986
bool is_incompatible_when_granted(enum_mdl_type type) const
Definition: mdl.cc:2602
PSI_metadata_lock * m_psi
Definition: mdl.h:1099
MDL_ticket ** prev_in_lock
Definition: mdl.h:994
MDL_ticket ** prev_in_context
Definition: mdl.h:987
uint get_deadlock_weight() const override
Return the 'weight' of this ticket for the victim selection algorithm.
Definition: mdl.cc:1696
enum_mdl_duration get_duration() const
Definition: mdl.h:1019
bool is_upgradable_or_exclusive() const
Definition: mdl.h:1000
bool m_hton_notified
Indicates that ticket corresponds to lock request which required storage engine notification during i...
Definition: mdl.h:1097
enum_mdl_duration m_duration
Duration of lock represented by this ticket.
Definition: mdl.h:1072
enum_psi_status
Status of lock request represented by the ticket as reflected in P_S.
Definition: mdl.h:1027
@ GRANTED
Definition: mdl.h:1029
@ POST_RELEASE_NOTIFY
Definition: mdl.h:1031
@ PRE_ACQUIRE_NOTIFY
Definition: mdl.h:1030
@ PENDING
Definition: mdl.h:1028
MDL_lock * m_lock
Pointer to the lock object for this lock ticket.
Definition: mdl.h:1082
void set_duration(enum_mdl_duration dur)
Definition: mdl.h:1020
enum_mdl_type get_type() const
Definition: mdl.h:1004
MDL_ticket * next_in_lock
Pointers for participating in the list of satisfied/pending requests for the lock.
Definition: mdl.h:993
const MDL_key * get_key() const
Return a key identifying this lock.
Definition: mdl.cc:4465
MDL_context * m_ctx
Context of the owner of the metadata lock ticket.
Definition: mdl.h:1077
MDL_lock * get_lock() const
Definition: mdl.h:1005
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:1665
An abstract class for inspection of a connected subgraph of the wait-for graph.
Definition: mdl.h:915
MDL_wait_for_graph_visitor()
Definition: mdl.h:922
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:933
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:941
static const uint DEADLOCK_WEIGHT_CO
Definition: mdl.h:951
static const uint DEADLOCK_WEIGHT_ULL
Definition: mdl.h:953
static const uint DEADLOCK_WEIGHT_DML
Definition: mdl.h:952
virtual ~MDL_wait_for_subgraph()
static const uint DEADLOCK_WEIGHT_DDL
Definition: mdl.h:954
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:1339
enum_wait_status m_wait_status
Definition: mdl.h:1365
bool set_status(enum_wait_status result_arg)
Set the status unless it's already set.
Definition: mdl.cc:1761
enum_wait_status
Definition: mdl.h:1346
@ KILLED
Definition: mdl.h:1346
@ WS_EMPTY
Definition: mdl.h:1346
@ TIMEOUT
Definition: mdl.h:1346
@ GRANTED
Definition: mdl.h:1346
@ VICTIM
Definition: mdl.h:1346
MDL_wait()
Construct an empty wait slot.
Definition: mdl.cc:1744
void reset_status()
Clear the current value of the wait slot.
Definition: mdl.cc:1785
mysql_cond_t m_COND_wait_status
Definition: mdl.h:1364
~MDL_wait()
Destroy system resources.
Definition: mdl.cc:1751
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:1805
enum_wait_status get_status()
Query the current value of the wait slot.
Definition: mdl.cc:1775
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:1363
For each client connection we create a separate thread with THD serving as a thread/connection descri...
Definition: sql_class.h:945
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:168
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:1071
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:1400
#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:282
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:1729
int32 mdl_get_unused_locks_count()
Get number of unused MDL_lock objects in MDL_map cache.
Definition: mdl.cc:1101
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:1738
void mdl_destroy()
Release resources of metadata locking subsystem.
Definition: mdl.cc:1089
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 coversion 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:782
int cmp(const MDL_key *rhs) const
Compare two MDL keys lexicographically.
Definition: mdl.h:732
const char * db_name() const
Definition: mdl.h:425
static void init_psi_keys()
Definition: mdl.cc:135
uint db_name_length() const
Definition: mdl.h:426
MDL_key(const MDL_key &rhs)
Definition: mdl.h:746
uint name_length() const
Definition: mdl.h:432
bool is_equal(const MDL_key *rhs) const
Definition: mdl.h:725
const char * name() const
Definition: mdl.h:428
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:473
enum_mdl_namespace
Object namespaces.
Definition: mdl.h:399
@ BACKUP_LOCK
Definition: mdl.h:401
@ EVENT
Definition: mdl.h:408
@ GLOBAL
Definition: mdl.h:400
@ LOCKING_SERVICE
Definition: mdl.h:411
@ USER_LEVEL_LOCK
Definition: mdl.h:410
@ COLUMN_STATISTICS
Definition: mdl.h:414
@ COMMIT
Definition: mdl.h:409
@ RESOURCE_GROUPS
Definition: mdl.h:415
@ SCHEMA
Definition: mdl.h:403
@ NAMESPACE_END
Definition: mdl.h:419
@ FUNCTION
Definition: mdl.h:405
@ TRIGGER
Definition: mdl.h:407
@ ACL_CACHE
Definition: mdl.h:413
@ FOREIGN_KEY
Definition: mdl.h:416
@ SRID
Definition: mdl.h:412
@ PROCEDURE
Definition: mdl.h:406
@ TABLESPACE
Definition: mdl.h:402
@ TABLE
Definition: mdl.h:404
@ CHECK_CONSTRAINT
Definition: mdl.h:417
enum_mdl_namespace mdl_namespace() const
Definition: mdl.h:458
void mdl_key_init(const MDL_key *rhs)
Definition: mdl.h:710
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:635
uint16 m_length
Definition: mdl.h:781
MDL_key()=default
uint length() const
Definition: mdl.h:423
char m_ptr[MAX_MDLKEY_LENGTH]
Definition: mdl.h:784
const uchar * ptr() const
Definition: mdl.h:422
const char * col_name() const
Definition: mdl.h:434
MDL_key & operator=(const MDL_key &rhs)
Definition: mdl.h:748
uint col_name_length() const
Definition: mdl.h:446
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:686
void reset()
Definition: mdl.h:719
MDL_key(enum_mdl_namespace namespace_arg, const char *db_arg, const char *name_arg)
Definition: mdl.h:753
uint16 m_object_name_length
Definition: mdl.h:783
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:520
bool use_normalized_object_name() const
Check if normalized object name should be used.
Definition: mdl.h:774
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:763
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:785
Definition: mdl.h:1131
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:1144
Ticket_p_list m_ticket_list
Definition: mdl.h:1132
Definition: mdl.h:1149
size_t operator()(const MDL_key *k) const
Definition: mdl.cc:4632
Definition: mdl.h:1153
bool operator()(const MDL_key *a, const MDL_key *b) const
Definition: mdl.h:1154
Utility struct for representing a ticket pointer and its duration.
Definition: mdl.h:1116
enum_mdl_duration m_dur
Definition: mdl.h:1117
MDL_ticket_handle(MDL_ticket *t, enum_mdl_duration d)
Definition: mdl.h:1121
MDL_ticket * m_ticket
Definition: mdl.h:1118
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