MySQL  8.0.27
Source Code Documentation
rpl_handler.h
Go to the documentation of this file.
1 /* Copyright (c) 2008, 2021, Oracle and/or its affiliates.
2 
3  This program is free software; you can redistribute it and/or modify
4  it under the terms of the GNU General Public License, version 2.0,
5  as published by the Free Software Foundation.
6 
7  This program is also distributed with certain software (including
8  but not limited to OpenSSL) that is licensed under separate terms,
9  as designated in a particular file or component or in included license
10  documentation. The authors of MySQL hereby grant you an additional
11  permission to link the program and your derivative works with the
12  separately licensed software that they have included with MySQL.
13 
14  This program is distributed in the hope that it will be useful,
15  but WITHOUT ANY WARRANTY; without even the implied warranty of
16  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17  GNU General Public License, version 2.0, for more details.
18 
19  You should have received a copy of the GNU General Public License
20  along with this program; if not, write to the Free Software
21  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
22 
23 #ifndef RPL_HANDLER_H
24 #define RPL_HANDLER_H
25 
26 #include <sys/types.h>
27 #include <atomic>
28 #include <map>
29 
30 #include "my_alloc.h"
31 #include "my_dbug.h"
32 #include "my_inttypes.h"
33 #include "my_psi_config.h"
34 #include "my_sys.h" // free_root
37 #include "mysql/psi/mysql_rwlock.h"
38 #include "sql/locks/shared_spin_lock.h" // Shared_spin_lock
39 #include "sql/sql_list.h" // List
40 #include "sql/sql_plugin.h" // my_plugin_(un)lock
41 #include "sql/sql_plugin_ref.h" // plugin_ref
42 
43 class Master_info;
44 class String;
45 class THD;
51 struct Trans_observer;
52 struct TABLE_LIST;
53 
54 /**
55  Variable to keep the value set for the
56  `replication_optimize_for_static_plugin_config` global.
57 
58  When this global variable value is set to `1`, we prevent all plugins that
59  register replication observers to be unloaded until the variable is set to
60  `0`, again. While the value of the variable is `1`, we are also exchanging the
61  `Delegate` class read-write lock by an atomic-based shared spin-lock.
62 
63  This behaviour is usefull for increasing the throughtput of the master when a
64  large number of slaves is connected, by preventing the acquisition of the
65  `LOCK_plugin` mutex and using a more read-friendly lock in the `Delegate`
66  class, when invoking the observer's hooks.
67 
68  Note that a large number of slaves means a large number of dump threads, which
69  means a large number of threads calling the registered observers hooks.
70 
71  If `UNINSTALL` is executed on a replication observer plugin while the variable
72  is set to `1`, the unload of the plugin will be deferred until the variable's
73  value is set to `0`.
74 */
76 /**
77  Variable to keep the value set for the
78  `replication_sender_observe_commit_only` global.
79 
80  When this global variable is set to `1`, only the replication observer's
81  commit hook will be called, every other registered hook invocation is skipped.
82 */
83 extern std::atomic<bool> opt_replication_sender_observe_commit_only;
84 
86  public:
87  void *observer;
90 
91  Observer_info(void *ob, st_plugin_int *p);
92 };
93 
94 /**
95  Base class for adding replication event observer infra-structure. It's
96  meant to be sub-classed by classes that will provide the support for the
97  specific event types. This class is meant just to provide basic support
98  for managing observers and managing resource access and lock acquisition.
99  */
100 class Delegate {
101  public:
104 
105  /**
106  Class constructor
107 
108  @param key the PFS key for instrumenting the class lock
109  */
110  explicit Delegate(
113 #endif
114  );
115  /**
116  Class destructor
117  */
118  virtual ~Delegate();
119 
120  /**
121  Adds an observer to the observer list.
122 
123  @param observer The observer object to be added to the list
124  @param plugin The plugin the observer is being loaded from
125 
126  @return 0 upon success, 1 otherwise
127  */
128  int add_observer(void *observer, st_plugin_int *plugin);
129  /**
130  Removes an observer from the observer list.
131 
132  @param observer The observer object to be added to the list
133  @param plugin The plugin the observer is being loaded from
134 
135  @return 0 upon success, 1 otherwise
136  */
137  int remove_observer(void *observer);
138  /**
139  Retrieves an iterator for the observer list.
140 
141  @return the iterator for the observer list
142  */
144  /**
145  Returns whether or not there are registered observers.
146 
147  @return whether or not there are registered observers
148  */
149  bool is_empty();
150  /**
151  Acquires this Delegate class instance lock in read/shared mode.
152 
153  @return 0 upon success, 1 otherwise
154  */
155  int read_lock();
156  /**
157  Acquires this Delegate class instance lock in write/exclusive mode.
158 
159  @return 0 upon success, 1 otherwise
160  */
161  int write_lock();
162  /**
163  Releases this Delegate class instance lock.
164 
165  @return 0 upon success, 1 otherwise
166  */
167  int unlock();
168  /**
169  Returns whether or not this instance was initialized.
170 
171  @return whether or not this instance was initialized
172  */
173  bool is_inited();
174  /**
175  Toggles the type of lock between a classical read-write lock and a
176  shared-exclusive spin-lock.
177  */
178  void update_lock_type();
179  /**
180  Increases the `info->plugin` usage reference counting if
181  `replication_optimize_for_static_plugin_config` is being enabled, in order
182  to prevent plugin removal.
183 
184  Decreases the `info->plugin` usage reference counting if
185  `replication_optimize_for_static_plugin_config` is being disabled, in order
186  to allow plugin removal.
187  */
189  /**
190  Returns whether or not to use the classic read-write lock.
191 
192  The read-write lock should be used if that type of lock is already
193  acquired by some thread or if the server is not optimized for static
194  plugin configuration.
195 
196  @returns true if one should use the classic read-write lock, false otherwise
197  */
198  bool use_rw_lock_type();
199  /**
200  Returns whether or not to use the shared spin-lock.
201 
202  The shared spin-lock should be used if that type of lock is already
203  acquired by some thread or if the server is optimized for static plugin
204  configuration.
205 
206  @returns true if one should use the shared spin-lock, false otherwise
207  */
208  bool use_spin_lock_type();
209 
210  private:
211  /** List of registered observers */
213  /**
214  A read/write lock to be used when not optimizing for static plugin config
215  */
217  /**
218  A shared-exclusive spin lock to be used when optimizing for static plugin
219  config.
220  */
222  /** Memory pool to be used to allocate the observers list */
224  /** Flag statign whether or not this instance was initialized */
225  bool inited;
226  /**
227  The type of lock configured to be used, either a classic read-write (-1)
228  lock or a shared-exclusive spin lock (1).
229  */
230  std::atomic<int> m_configured_lock_type;
231  /**
232  The count of locks acquired: -1 will be added for each classic
233  read-write lock acquisitions; +1 will be added for each
234  shared-exclusive spin lock acquisition.
235  */
236  std::atomic<int> m_acquired_locks;
237  /**
238  List of acquired plugin references, to be held while
239  `replication_optimize_for_static_plugin_config` option is enabled. If the
240  option is disabled, the references in this list will be released.
241  */
242  std::map<plugin_ref, size_t> m_acquired_references;
243 
245  DELEGATE_OS_LOCK = -1, // Lock used by this class is an OS RW lock
246  DELEGATE_SPIN_LOCK = 1, // Lock used by this class is a spin lock
247  };
248 
250  DELEGATE_LOCK_MODE_SHARED = 0, // Lock acquired in shared/read mode
251  DELEGATE_LOCK_MODE_EXCLUSIVE = 1, // Lock acquired in exclusive/write mode
252  };
253 
254  /**
255  Increases the `info->plugin` reference counting and stores that refernce
256  internally.
257  */
259  /**
260  Locks the active lock (OS read-write lock or shared spin-lock)
261  according to the mode passed on as a parameter.
262 
263  @param mode The mode to lock in, either DELEGATE_LOCK_MODE_SHARED or
264  DELEGATE_LOCK_MODE_EXCLUSIVE.
265  */
267 };
268 
269 #ifdef HAVE_PSI_RWLOCK_INTERFACE
271 #endif
272 
274 
275 class Trans_delegate : public Delegate {
276  public:
278  : Delegate(
281 #endif
282  ) {
283  }
284 
286 
287  int before_dml(THD *thd, int &result);
288  int before_commit(THD *thd, bool all, Binlog_cache_storage *trx_cache_log,
289  Binlog_cache_storage *stmt_cache_log,
290  ulonglong cache_log_max_size, bool is_atomic_ddl);
291  int before_rollback(THD *thd, bool all);
292  int after_commit(THD *thd, bool all);
293  int after_rollback(THD *thd, bool all);
294  int trans_begin(THD *thd, int &result);
295 };
296 
297 #ifdef HAVE_PSI_RWLOCK_INTERFACE
299 #endif
300 
302  public:
304  : Delegate(
307 #endif
308  ) {
309  }
310 
312  int before_handle_connection(THD *thd);
313  int before_recovery(THD *thd);
314  int after_engine_recovery(THD *thd);
315  int after_recovery(THD *thd);
316  int before_server_shutdown(THD *thd);
317  int after_server_shutdown(THD *thd);
318  int after_dd_upgrade_from_57(THD *thd);
319 };
320 
321 #ifdef HAVE_PSI_RWLOCK_INTERFACE
323 #endif
324 
326  public:
328  : Delegate(
331 #endif
332  ) {
333  }
334 
336  int after_flush(THD *thd, const char *log_file, my_off_t log_pos);
337  int after_sync(THD *thd, const char *log_file, my_off_t log_pos);
338 };
339 
340 #ifdef HAVE_PSI_RWLOCK_INTERFACE
342 #endif
343 
345  public:
347  : Delegate(
350 #endif
351  ) {
352  }
353 
355  int transmit_start(THD *thd, ushort flags, const char *log_file,
356  my_off_t log_pos, bool *observe_transmission);
357  int transmit_stop(THD *thd, ushort flags);
358  int reserve_header(THD *thd, ushort flags, String *packet);
359  int before_send_event(THD *thd, ushort flags, String *packet,
360  const char *log_file, my_off_t log_pos);
361  int after_send_event(THD *thd, ushort flags, String *packet,
362  const char *skipped_log_file, my_off_t skipped_log_pos);
363  int after_reset_master(THD *thd, ushort flags);
364 };
365 
366 #ifdef HAVE_PSI_RWLOCK_INTERFACE
368 #endif
369 
371  public:
373  : Delegate(
376 #endif
377  ) {
378  }
379 
381  int thread_start(THD *thd, Master_info *mi);
382  int thread_stop(THD *thd, Master_info *mi);
383  int applier_start(THD *thd, Master_info *mi);
384  int applier_stop(THD *thd, Master_info *mi, bool aborted);
385  int before_request_transmit(THD *thd, Master_info *mi, ushort flags);
386  int after_read_event(THD *thd, Master_info *mi, const char *packet, ulong len,
387  const char **event_buf, ulong *event_len);
388  int after_queue_event(THD *thd, Master_info *mi, const char *event_buf,
389  ulong event_len, bool synced);
390  int after_reset_slave(THD *thd, Master_info *mi);
391  int applier_log_event(THD *thd, int &out);
392 
393  private:
394  void init_param(Binlog_relay_IO_param *param, Master_info *mi);
395 };
396 
397 int delegates_init();
398 /**
399  Verify that the replication plugins are ready and OK to be unloaded.
400  */
401 void delegates_shutdown();
402 void delegates_destroy();
403 /**
404  Invokes `write_lock()` for all the observer delegate objects.
405 */
407 /**
408  Releases locks for all the observer delegate objects.
409 */
411 /**
412  Toggles the type of lock between a classical read-write lock and a
413  shared-exclusive spin-lock.
414 */
416 
422 
423 /*
424  if there is no observers in the delegate, we can return 0
425  immediately.
426 */
427 #define RUN_HOOK(group, hook, args) \
428  (group##_delegate->is_empty() ? 0 : group##_delegate->hook args)
429 
430 #define NO_HOOK(group) (group##_delegate->is_empty())
431 
432 int launch_hook_trans_begin(THD *thd, TABLE_LIST *table);
433 
434 #endif /* RPL_HANDLER_H */
Byte container that provides a storage for serializing session binlog events.
Definition: binlog_ostream.h:172
Definition: rpl_handler.h:370
int applier_start(THD *thd, Master_info *mi)
Definition: rpl_handler.cc:1117
int after_reset_slave(THD *thd, Master_info *mi)
Definition: rpl_handler.cc:1184
int thread_start(THD *thd, Master_info *mi)
Definition: rpl_handler.cc:1095
int applier_log_event(THD *thd, int &out)
Definition: rpl_handler.cc:1197
int applier_stop(THD *thd, Master_info *mi, bool aborted)
Definition: rpl_handler.cc:1128
Binlog_relay_IO_observer Observer
Definition: rpl_handler.h:380
int before_request_transmit(THD *thd, Master_info *mi, ushort flags)
Definition: rpl_handler.cc:1140
void init_param(Binlog_relay_IO_param *param, Master_info *mi)
Definition: rpl_handler.cc:1082
int after_queue_event(THD *thd, Master_info *mi, const char *event_buf, ulong event_len, bool synced)
Definition: rpl_handler.cc:1167
Binlog_relay_IO_delegate()
Definition: rpl_handler.h:372
int after_read_event(THD *thd, Master_info *mi, const char *packet, ulong len, const char **event_buf, ulong *event_len)
Definition: rpl_handler.cc:1152
int thread_stop(THD *thd, Master_info *mi)
Definition: rpl_handler.cc:1106
Definition: rpl_handler.h:325
Binlog_storage_observer Observer
Definition: rpl_handler.h:335
int after_sync(THD *thd, const char *log_file, my_off_t log_pos)
Definition: rpl_handler.cc:939
Binlog_storage_delegate()
Definition: rpl_handler.h:327
int after_flush(THD *thd, const char *log_file, my_off_t log_pos)
Definition: rpl_handler.cc:822
Definition: rpl_handler.h:344
int before_send_event(THD *thd, ushort flags, String *packet, const char *log_file, my_off_t log_pos)
Definition: rpl_handler.cc:1034
int transmit_stop(THD *thd, ushort flags)
Definition: rpl_handler.cc:969
int transmit_start(THD *thd, ushort flags, const char *log_file, my_off_t log_pos, bool *observe_transmission)
Definition: rpl_handler.cc:955
Binlog_transmit_observer Observer
Definition: rpl_handler.h:354
int after_reset_master(THD *thd, ushort flags)
Definition: rpl_handler.cc:1070
int after_send_event(THD *thd, ushort flags, String *packet, const char *skipped_log_file, my_off_t skipped_log_pos)
Definition: rpl_handler.cc:1052
int reserve_header(THD *thd, ushort flags, String *packet)
Definition: rpl_handler.cc:981
Binlog_transmit_delegate()
Definition: rpl_handler.h:346
Base class for adding replication event observer infra-structure.
Definition: rpl_handler.h:100
bool is_inited()
Returns whether or not this instance was initialized.
Definition: rpl_handler.cc:188
Delegate(PSI_rwlock_key key)
Class constructor.
Definition: rpl_handler.cc:85
int unlock()
Releases this Delegate class instance lock.
Definition: rpl_handler.cc:166
void update_plugin_ref_count()
Increases the info->plugin usage reference counting if replication_optimize_for_static_plugin_config ...
Definition: rpl_handler.cc:199
int read_lock()
Acquires this Delegate class instance lock in read/shared mode.
Definition: rpl_handler.cc:154
int remove_observer(void *observer)
Removes an observer from the observer list.
Definition: rpl_handler.cc:129
int write_lock()
Acquires this Delegate class instance lock in write/exclusive mode.
Definition: rpl_handler.cc:160
lock::Shared_spin_lock m_spin_lock
A shared-exclusive spin lock to be used when optimizing for static plugin config.
Definition: rpl_handler.h:221
bool is_empty()
Returns whether or not there are registered observers.
Definition: rpl_handler.cc:149
MEM_ROOT memroot
Memory pool to be used to allocate the observers list.
Definition: rpl_handler.h:223
Observer_info_list observer_info_list
List of registered observers.
Definition: rpl_handler.h:212
enum_delegate_lock_type
Definition: rpl_handler.h:244
@ DELEGATE_OS_LOCK
Definition: rpl_handler.h:245
@ DELEGATE_SPIN_LOCK
Definition: rpl_handler.h:246
bool use_spin_lock_type()
Returns whether or not to use the shared spin-lock.
Definition: rpl_handler.cc:234
bool inited
Flag statign whether or not this instance was initialized.
Definition: rpl_handler.h:225
void lock_it(enum_delegate_lock_mode mode)
Locks the active lock (OS read-write lock or shared spin-lock) according to the mode passed on as a p...
Definition: rpl_handler.cc:251
List_iterator< Observer_info > Observer_info_iterator
Definition: rpl_handler.h:103
void update_lock_type()
Toggles the type of lock between a classical read-write lock and a shared-exclusive spin-lock.
Definition: rpl_handler.cc:190
std::atomic< int > m_acquired_locks
The count of locks acquired: -1 will be added for each classic read-write lock acquisitions; +1 will ...
Definition: rpl_handler.h:236
virtual ~Delegate()
Class destructor.
Definition: rpl_handler.cc:104
Observer_info_iterator observer_info_iter()
Retrieves an iterator for the observer list.
Definition: rpl_handler.cc:145
mysql_rwlock_t lock
A read/write lock to be used when not optimizing for static plugin config.
Definition: rpl_handler.h:216
std::atomic< int > m_configured_lock_type
The type of lock configured to be used, either a classic read-write (-1) lock or a shared-exclusive s...
Definition: rpl_handler.h:230
enum_delegate_lock_mode
Definition: rpl_handler.h:249
@ DELEGATE_LOCK_MODE_SHARED
Definition: rpl_handler.h:250
@ DELEGATE_LOCK_MODE_EXCLUSIVE
Definition: rpl_handler.h:251
int add_observer(void *observer, st_plugin_int *plugin)
Adds an observer to the observer list.
Definition: rpl_handler.cc:110
bool use_rw_lock_type()
Returns whether or not to use the classic read-write lock.
Definition: rpl_handler.cc:222
List< Observer_info > Observer_info_list
Definition: rpl_handler.h:102
std::map< plugin_ref, size_t > m_acquired_references
List of acquired plugin references, to be held while replication_optimize_for_static_plugin_config op...
Definition: rpl_handler.h:242
void acquire_plugin_ref_count(Observer_info *info)
Increases the info->plugin reference counting and stores that refernce internally.
Definition: rpl_handler.cc:246
Definition: sql_list.h:570
Definition: rpl_mi.h:86
Definition: rpl_handler.h:85
void * observer
Definition: rpl_handler.h:87
Observer_info(void *ob, st_plugin_int *p)
Definition: rpl_handler.cc:80
plugin_ref plugin
Definition: rpl_handler.h:89
st_plugin_int * plugin_int
Definition: rpl_handler.h:88
Definition: rpl_handler.h:301
Server_state_observer Observer
Definition: rpl_handler.h:311
int after_server_shutdown(THD *thd)
This hook MUST be invoked after server shutdown operation is complete.
Definition: rpl_handler.cc:916
int before_handle_connection(THD *thd)
This hook MUST be invoked after ALL recovery operations are performed and the server is ready to serv...
Definition: rpl_handler.cc:841
int before_server_shutdown(THD *thd)
This hook MUST be invoked before server shutdown action is initiated.
Definition: rpl_handler.cc:901
Server_state_delegate()
Definition: rpl_handler.h:303
int after_engine_recovery(THD *thd)
This hook MUST be invoked after the recovery from the engine is complete.
Definition: rpl_handler.cc:870
int after_recovery(THD *thd)
This hook MUST be invoked after the server has completed the local recovery.
Definition: rpl_handler.cc:886
int before_recovery(THD *thd)
This hook MUST be invoked before ANY recovery action is started.
Definition: rpl_handler.cc:855
int after_dd_upgrade_from_57(THD *thd)
This hook MUST be invoked after upgrade from .frm to data dictionary.
Definition: rpl_handler.cc:930
Using this class is fraught with peril, and you need to be very careful when doing so.
Definition: sql_string.h:165
For each client connection we create a separate thread with THD serving as a thread/connection descri...
Definition: sql_class.h:821
Definition: rpl_handler.h:275
Trans_delegate()
Definition: rpl_handler.h:277
int after_rollback(THD *thd, bool all)
Definition: rpl_handler.cc:786
int before_dml(THD *thd, int &result)
Definition: rpl_handler.cc:705
int trans_begin(THD *thd, int &result)
Definition: rpl_handler.cc:805
int after_commit(THD *thd, bool all)
Definition: rpl_handler.cc:756
int before_rollback(THD *thd, bool all)
Definition: rpl_handler.cc:731
Trans_observer Observer
Definition: rpl_handler.h:285
int before_commit(THD *thd, bool all, Binlog_cache_storage *trx_cache_log, Binlog_cache_storage *stmt_cache_log, ulonglong cache_log_max_size, bool is_atomic_ddl)
Definition: rpl_handler.cc:540
Definition: shared_spin_lock.h:79
const char * p
Definition: ctype-mb.cc:1236
bool is_atomic_ddl(THD *thd, bool using_trans_arg)
The function lists all DDL instances that are supported for crash-recovery (WL9175).
Definition: log_event.cc:3768
unsigned int PSI_rwlock_key
Instrumented rwlock key.
Definition: psi_rwlock_bits.h:43
static int flags[50]
Definition: hp_test1.cc:39
This file follows Google coding style, except for the name MEM_ROOT (which is kept for historical rea...
Some integer typedefs for easier portability.
unsigned long long int ulonglong
Definition: my_inttypes.h:55
ulonglong my_off_t
Definition: my_inttypes.h:71
Defines various enable/disable and HAVE_ macros related to the performance schema instrumentation sys...
#define HAVE_PSI_RWLOCK_INTERFACE
Definition: my_psi_config.h:82
Common header for many mysys elements.
Instrumentation helpers for rwlock.
Log info(cout, "NOTE")
Logfile log_file
Definition: mysqltest.cc:259
mode
Definition: file_handle.h:59
Instrumentation helpers for rwlock.
Performance schema instrumentation interface.
required string key
Definition: replication_asynchronous_connection_failover.proto:59
void delegates_release_locks()
Releases locks for all the observer delegate objects.
Definition: rpl_handler.cc:432
PSI_rwlock_key key_rwlock_Trans_delegate_lock
Definition: mysqld.cc:11256
Binlog_storage_delegate * binlog_storage_delegate
Definition: rpl_handler.cc:71
Trans_delegate * transaction_delegate
Definition: rpl_handler.cc:70
Binlog_transmit_delegate * binlog_transmit_delegate
Definition: rpl_handler.cc:74
int delegates_init()
Definition: rpl_handler.cc:354
int launch_hook_trans_begin(THD *thd, TABLE_LIST *table)
Definition: rpl_handler.cc:1305
PSI_rwlock_key key_rwlock_Binlog_storage_delegate_lock
Definition: mysqld.cc:11258
PSI_rwlock_key key_rwlock_Binlog_relay_IO_delegate_lock
Definition: mysqld.cc:11260
PSI_rwlock_key key_rwlock_Server_state_delegate_lock
Definition: mysqld.cc:11257
Binlog_relay_IO_delegate * binlog_relay_io_delegate
Definition: rpl_handler.cc:75
Server_state_delegate * server_state_delegate
Definition: rpl_handler.cc:72
void delegates_update_lock_type()
Toggles the type of lock between a classical read-write lock and a shared-exclusive spin-lock.
Definition: rpl_handler.cc:440
std::atomic< bool > opt_replication_sender_observe_commit_only
Variable to keep the value set for the replication_sender_observe_commit_only global.
Definition: rpl_handler.cc:78
bool opt_replication_optimize_for_static_plugin_config
Variable to keep the value set for the replication_optimize_for_static_plugin_config global.
Definition: rpl_handler.cc:77
void delegates_shutdown()
Verify that the replication plugins are ready and OK to be unloaded.
Definition: rpl_handler.cc:393
void delegates_destroy()
Definition: rpl_handler.cc:402
void delegates_acquire_locks()
Invokes write_lock() for all the observer delegate objects.
Definition: rpl_handler.cc:424
PSI_rwlock_key key_rwlock_Binlog_transmit_delegate_lock
Definition: mysqld.cc:11259
Observes and extends the service of slave IO thread.
Definition: replication.h:717
Replication binlog relay IO observer parameter.
Definition: replication.h:581
Observe binlog logging storage.
Definition: replication.h:429
Observe and extends the binlog dumping thread.
Definition: replication.h:559
The MEM_ROOT is a simple arena, where allocations are carved out of larger blocks.
Definition: my_alloc.h:78
Observer server state.
Definition: replication.h:389
Definition: table.h:2694
Observes and extends transaction execution.
Definition: replication.h:285
An instrumented rwlock structure.
Definition: mysql_rwlock_bits.h:50
Definition: result.h:29
Definition: sql_plugin_ref.h:44
static int all(site_def const *s, node_no node)
Definition: xcom_transport.cc:858