MySQL  8.0.26
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
45 #include "mysql/psi/mysql_rwlock.h"
46 #include "mysql_com.h"
47 #include "sql/sql_plist.h"
48 #include "template_utils.h"
49 
50 class MDL_context;
51 class MDL_lock;
52 class MDL_ticket;
53 class THD;
54 struct LF_PINS;
55 struct MDL_key;
56 struct MEM_ROOT;
57 namespace 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  */
159  virtual void notify_shared_lock(MDL_context_owner *in_use,
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 !!! */
328 };
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 ! */
350 };
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 
364 struct 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  */
400  GLOBAL = 0,
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 {
435  assert(!use_normalized_object_name());
436 
438  /* A column name was stored in the key buffer. */
440  }
441 
442  /* No column name stored. */
443  return nullptr;
444  }
445 
447  assert(!use_normalized_object_name());
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 
477  assert(!use_normalized_object_name());
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 
526  assert(!use_normalized_object_name());
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  */
644  assert(use_normalized_object_name());
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  */
686  void mdl_key_init(enum_mdl_namespace mdl_namespace, const char *part_key,
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  */
703  assert(!use_normalized_object_name());
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;
721  m_db_name_length = 0;
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 ||
777  mdl_namespace() == TRIGGER);
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 
798 class MDL_request {
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  */
814  MDL_ticket *ticket{nullptr};
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 MY_ATTRIBUTE((unused)) =
825  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  */
861  bool is_write_lock_request() const {
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 
896  MDL_request(MDL_request &&) = default;
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  */
1028  PENDING = 0,
1032  };
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. */
1066  enum enum_mdl_type m_type;
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  */
1118  MDL_ticket *m_ticket = nullptr;
1119 
1120  MDL_ticket_handle() = default;
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  */
1175  const size_t INITIAL_BUCKET_COUNT = THRESHOLD * 2;
1176  size_t m_count = 0;
1177 
1178  std::unique_ptr<Ticket_map> m_map;
1179 
1180  MDL_ticket_handle find_in_lists(const MDL_request &req) const;
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  */
1302  MDL_ticket *materialized_front(int di);
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 
1339 class MDL_wait {
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 
1396 typedef 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 
1444  void release_all_locks_for_name(MDL_ticket *ticket);
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
1466  bool has_locks(enum_mdl_duration duration) {
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 
1480  void release_statement_locks();
1483 
1484  MDL_context_owner *get_owner() const { return m_owner; }
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 
1506  if (m_needs_thr_lock_abort) {
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 
1708 void mdl_init();
1709 void mdl_destroy();
1710 
1711 #ifndef NDEBUG
1712 extern mysql_mutex_t LOCK_open;
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 */
1720 extern 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 MY_ATTRIBUTE((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 */
1772  bool m_exists;
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 THD * get_thd()=0
Within MDL subsystem this one is only used for DEBUG_SYNC.
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.
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
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
THD * get_thd() const
Within MDL subsystem this one is only used for DEBUG_SYNC.
Definition: mdl.h:1556
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
MDL_context & operator=(MDL_context &rhs)
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
MDL_context_owner * get_owner() const
Definition: mdl.h:1484
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
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
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:4879
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:4893
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:4733
void move_all_to_explicit_duration()
Move all tickets to the explicit duration list.
Definition: mdl.cc:4769
void move_explicit_to_transaction_duration()
Move all tickets to the transaction duration list.
Definition: mdl.cc:4828
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:4899
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:4690
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:4686
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:4674
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_context * get_ctx() const
Definition: mdl.h:999
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_ticket & operator=(const MDL_ticket &)
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
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
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
MDL_lock * get_lock() const
Definition: mdl.h:1005
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:821
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
Dialog Client Authentication nullptr
Definition: dialog.cc:353
mysql_mutex_t LOCK_open
LOCK_open protects the following variables/objects:
Definition: sql_base.cc:245
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:161
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:126
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:188
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
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
const uchar * ptr() const
Definition: mdl.h:422
bool is_equal(const MDL_key *rhs) const
Definition: mdl.h:725
const char * col_name() const
Definition: mdl.h:434
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 char * db_name() const
Definition: mdl.h:425
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
MDL_key & operator=(const MDL_key &rhs)
Definition: mdl.h:748
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
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
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
const char * name() const
Definition: mdl.h:428
bool use_normalized_object_name() const
Check if normalized object name should be used.
Definition: mdl.h:774
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:78
void * Alloc(size_t length)
Allocate memory.
Definition: my_alloc.h:135
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