1 /* Copyright (c) 2011, 2020, Oracle and/or its affiliates. All rights reserved.
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 Without limiting anything contained in the foregoing, this file,
15 which is part of C Driver for MySQL (Connector/C), is also subject to the
16 Universal FOSS Exception, version 1.0, a copy of which can be found at
17 http://oss.oracle.com/licenses/universal-foss-exception.
18
19 This program is distributed in the hope that it will be useful,
20 but WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 GNU General Public License, version 2.0, for more details.
23
24 You should have received a copy of the GNU General Public License
25 along with this program; if not, write to the Free Software
26 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
27
28 /**
29 @file mysys/psi_noop.cc
30 Always provide the noop performance interface, for plugins.
31 */
32
33 #define HAVE_PSI_MUTEX_INTERFACE
34 #define HAVE_PSI_RWLOCK_INTERFACE
35 #define HAVE_PSI_COND_INTERFACE
36 #define HAVE_PSI_FILE_INTERFACE
37 #define HAVE_PSI_THREAD_INTERFACE
38 #define HAVE_PSI_TABLE_INTERFACE
39 #define HAVE_PSI_STAGE_INTERFACE
40 #define HAVE_PSI_STATEMENT_INTERFACE
41 #define HAVE_PSI_SP_INTERFACE
42 #define HAVE_PSI_PS_INTERFACE
43 #define HAVE_PSI_STATEMENT_DIGEST_INTERFACE
44 #define HAVE_PSI_TRANSACTION_INTERFACE
45 #define HAVE_PSI_SOCKET_INTERFACE
46 #define HAVE_PSI_MEMORY_INTERFACE
47 #define HAVE_PSI_ERROR_INTERFACE
48 #define HAVE_PSI_IDLE_INTERFACE
49 #define HAVE_PSI_METADATA_INTERFACE
50 #define HAVE_PSI_DATA_LOCK_INTERFACE
51 #define HAVE_PSI_SYSTEM_INTERFACE
52 #define HAVE_PSI_TLS_CHANNEL_INTERFACE
53
54 #ifdef HAVE_SYS_SOCKET_H
55 #include <sys/socket.h>
56 #endif
57 #include <sys/types.h>
58 #include <time.h>
59
60 #include "my_compiler.h"
61 #include "my_inttypes.h"
62 #include "my_io.h"
63 #include "my_macros.h"
64 #include "my_sys.h" // IWYU pragma: keep
65 #include "my_thread.h"
66 #include "mysql/psi/psi_base.h"
67 #include "mysql/psi/psi_cond.h"
68 #include "mysql/psi/psi_data_lock.h"
69 #include "mysql/psi/psi_error.h"
70 #include "mysql/psi/psi_file.h"
71 #include "mysql/psi/psi_idle.h"
72 #include "mysql/psi/psi_mdl.h"
73 #include "mysql/psi/psi_memory.h"
74 #include "mysql/psi/psi_mutex.h"
75 #include "mysql/psi/psi_rwlock.h"
76 #include "mysql/psi/psi_socket.h"
77 #include "mysql/psi/psi_stage.h"
78 #include "mysql/psi/psi_statement.h"
79 #include "mysql/psi/psi_system.h"
80 #include "mysql/psi/psi_table.h"
81 #include "mysql/psi/psi_thread.h"
82 #include "mysql/psi/psi_tls_channel.h"
83 #include "mysql/psi/psi_transaction.h"
84
85 class THD;
86 struct MDL_key;
87
88 // ===========================================================================
89
register_thread_noop(const char *,PSI_thread_info *,int)90 static void register_thread_noop(const char *, PSI_thread_info *, int) {
91 return;
92 }
93
spawn_thread_noop(PSI_thread_key,my_thread_handle * thread,const my_thread_attr_t * attr,my_start_routine start_routine,void * arg)94 static int spawn_thread_noop(PSI_thread_key, my_thread_handle *thread,
95 const my_thread_attr_t *attr,
96 my_start_routine start_routine, void *arg) {
97 return my_thread_create(thread, attr, start_routine, arg);
98 }
99
new_thread_noop(PSI_thread_key,const void *,ulonglong)100 static PSI_thread *new_thread_noop(PSI_thread_key, const void *, ulonglong) {
101 return nullptr;
102 }
103
set_thread_id_noop(PSI_thread *,ulonglong)104 static void set_thread_id_noop(PSI_thread *, ulonglong) { return; }
105
get_current_thread_internal_id_noop()106 static ulonglong get_current_thread_internal_id_noop() { return 0; }
107
get_thread_internal_id_noop(PSI_thread *)108 static ulonglong get_thread_internal_id_noop(PSI_thread *) { return 0; }
109
get_thread_by_id_noop(ulonglong)110 static PSI_thread *get_thread_by_id_noop(ulonglong) { return nullptr; }
111
set_thread_THD_noop(PSI_thread *,THD *)112 static void set_thread_THD_noop(PSI_thread *, THD *) { return; }
113
set_thread_os_id_noop(PSI_thread *)114 static void set_thread_os_id_noop(PSI_thread *) { return; }
115
get_thread_noop(void)116 static PSI_thread *get_thread_noop(void) { return nullptr; }
117
set_thread_user_noop(const char *,int)118 static void set_thread_user_noop(const char *, int) { return; }
119
set_thread_user_host_noop(const char *,int,const char *,int)120 static void set_thread_user_host_noop(const char *, int, const char *, int) {
121 return;
122 }
123
set_thread_db_noop(const char *,int)124 static void set_thread_db_noop(const char *, int) { return; }
125
set_thread_command_noop(int)126 static void set_thread_command_noop(int) { return; }
127
set_connection_type_noop(opaque_vio_type)128 static void set_connection_type_noop(opaque_vio_type) { return; }
129
set_thread_start_time_noop(time_t)130 static void set_thread_start_time_noop(time_t) { return; }
131
set_thread_info_noop(const char *,uint)132 static void set_thread_info_noop(const char *, uint) { return; }
133
set_thread_noop(PSI_thread *)134 static void set_thread_noop(PSI_thread *) { return; }
135
set_thread_resource_group_noop(const char *,int,void *)136 static int set_thread_resource_group_noop(const char *, int, void *) {
137 return 0;
138 }
139
set_thread_resource_group_by_id_noop(PSI_thread *,ulonglong,const char *,int,void *)140 static int set_thread_resource_group_by_id_noop(PSI_thread *, ulonglong,
141 const char *, int, void *) {
142 return 0;
143 }
144
aggregate_thread_status_noop(PSI_thread *)145 static void aggregate_thread_status_noop(PSI_thread *) { return; }
146
delete_current_thread_noop(void)147 static void delete_current_thread_noop(void) { return; }
148
delete_thread_noop(PSI_thread *)149 static void delete_thread_noop(PSI_thread *) { return; }
150
set_thread_connect_attrs_noop(const char * buffer MY_ATTRIBUTE ((unused)),uint length MY_ATTRIBUTE ((unused)),const void * from_cs MY_ATTRIBUTE ((unused)))151 static int set_thread_connect_attrs_noop(
152 const char *buffer MY_ATTRIBUTE((unused)),
153 uint length MY_ATTRIBUTE((unused)),
154 const void *from_cs MY_ATTRIBUTE((unused))) {
155 return 0;
156 }
157
get_current_thread_event_id_noop(ulonglong * thread_internal_id,ulonglong * event_id)158 static void get_current_thread_event_id_noop(ulonglong *thread_internal_id,
159 ulonglong *event_id) {
160 *thread_internal_id = 0;
161 *event_id = 0;
162 }
163
get_thread_event_id_noop(PSI_thread *,ulonglong * thread_internal_id,ulonglong * event_id)164 static void get_thread_event_id_noop(PSI_thread *,
165 ulonglong *thread_internal_id,
166 ulonglong *event_id) {
167 *thread_internal_id = 0;
168 *event_id = 0;
169 }
170
get_thread_system_attrs_noop(PSI_thread_attrs *)171 static int get_thread_system_attrs_noop(PSI_thread_attrs *) { return 0; }
172
get_thread_system_attrs_by_id_noop(PSI_thread *,ulonglong,PSI_thread_attrs *)173 static int get_thread_system_attrs_by_id_noop(PSI_thread *, ulonglong,
174 PSI_thread_attrs *) {
175 return 0;
176 }
177
register_notification_noop(const PSI_notification *,bool)178 static int register_notification_noop(const PSI_notification *, bool) {
179 return 0;
180 }
181
unregister_notification_noop(int)182 static int unregister_notification_noop(int) { return 0; }
183
notify_session_connect_noop(PSI_thread *)184 static void notify_session_connect_noop(PSI_thread *) { return; }
185
notify_session_disconnect_noop(PSI_thread *)186 static void notify_session_disconnect_noop(PSI_thread *) { return; }
187
notify_session_change_user_noop(PSI_thread *)188 static void notify_session_change_user_noop(PSI_thread *) { return; }
189
190 static PSI_thread_service_t psi_thread_noop = {
191 register_thread_noop,
192 spawn_thread_noop,
193 new_thread_noop,
194 set_thread_id_noop,
195 get_current_thread_internal_id_noop,
196 get_thread_internal_id_noop,
197 get_thread_by_id_noop,
198 set_thread_THD_noop,
199 set_thread_os_id_noop,
200 get_thread_noop,
201 set_thread_user_noop,
202 set_thread_user_host_noop,
203 set_thread_db_noop,
204 set_thread_command_noop,
205 set_connection_type_noop,
206 set_thread_start_time_noop,
207 set_thread_info_noop,
208 set_thread_resource_group_noop,
209 set_thread_resource_group_by_id_noop,
210 set_thread_noop,
211 aggregate_thread_status_noop,
212 delete_current_thread_noop,
213 delete_thread_noop,
214 set_thread_connect_attrs_noop,
215 get_current_thread_event_id_noop,
216 get_thread_event_id_noop,
217 get_thread_system_attrs_noop,
218 get_thread_system_attrs_by_id_noop,
219 register_notification_noop,
220 unregister_notification_noop,
221 notify_session_connect_noop,
222 notify_session_disconnect_noop,
223 notify_session_change_user_noop};
224
225 struct PSI_thread_bootstrap *psi_thread_hook = nullptr;
226 PSI_thread_service_t *psi_thread_service = &psi_thread_noop;
227
set_psi_thread_service(void * psi)228 void set_psi_thread_service(void *psi) {
229 psi_thread_service = (PSI_thread_service_t *)psi;
230 }
231
232 // ===========================================================================
233
register_mutex_noop(const char *,PSI_mutex_info *,int)234 static void register_mutex_noop(const char *, PSI_mutex_info *, int) { return; }
235
init_mutex_noop(PSI_mutex_key,const void *)236 static PSI_mutex *init_mutex_noop(PSI_mutex_key, const void *) {
237 return nullptr;
238 }
239
destroy_mutex_noop(PSI_mutex *)240 static void destroy_mutex_noop(PSI_mutex *) { return; }
241
start_mutex_wait_noop(PSI_mutex_locker_state *,PSI_mutex *,PSI_mutex_operation,const char *,uint)242 static PSI_mutex_locker *start_mutex_wait_noop(PSI_mutex_locker_state *,
243 PSI_mutex *, PSI_mutex_operation,
244 const char *, uint) {
245 return nullptr;
246 }
247
end_mutex_wait_noop(PSI_mutex_locker *,int)248 static void end_mutex_wait_noop(PSI_mutex_locker *, int) { return; }
249
unlock_mutex_noop(PSI_mutex *)250 static void unlock_mutex_noop(PSI_mutex *) { return; }
251
252 static PSI_mutex_service_t psi_mutex_noop = {
253 register_mutex_noop, init_mutex_noop, destroy_mutex_noop,
254 start_mutex_wait_noop, end_mutex_wait_noop, unlock_mutex_noop};
255
256 struct PSI_mutex_bootstrap *psi_mutex_hook = nullptr;
257 PSI_mutex_service_t *psi_mutex_service = &psi_mutex_noop;
258
set_psi_mutex_service(void * psi)259 void set_psi_mutex_service(void *psi) {
260 psi_mutex_service = (PSI_mutex_service_t *)psi;
261 }
262
263 // ===========================================================================
264
register_rwlock_noop(const char *,PSI_rwlock_info *,int)265 static void register_rwlock_noop(const char *, PSI_rwlock_info *, int) {
266 return;
267 }
268
init_rwlock_noop(PSI_rwlock_key,const void *)269 static PSI_rwlock *init_rwlock_noop(PSI_rwlock_key, const void *) {
270 return nullptr;
271 }
272
destroy_rwlock_noop(PSI_rwlock *)273 static void destroy_rwlock_noop(PSI_rwlock *) { return; }
274
start_rwlock_rdwait_noop(struct PSI_rwlock_locker_state_v1 *,struct PSI_rwlock *,enum PSI_rwlock_operation,const char *,uint)275 static PSI_rwlock_locker *start_rwlock_rdwait_noop(
276 struct PSI_rwlock_locker_state_v1 *, struct PSI_rwlock *,
277 enum PSI_rwlock_operation, const char *, uint) {
278 return nullptr;
279 }
280
end_rwlock_rdwait_noop(PSI_rwlock_locker *,int)281 static void end_rwlock_rdwait_noop(PSI_rwlock_locker *, int) { return; }
282
start_rwlock_wrwait_noop(struct PSI_rwlock_locker_state_v1 *,struct PSI_rwlock *,enum PSI_rwlock_operation,const char *,uint)283 static struct PSI_rwlock_locker *start_rwlock_wrwait_noop(
284 struct PSI_rwlock_locker_state_v1 *, struct PSI_rwlock *,
285 enum PSI_rwlock_operation, const char *, uint) {
286 return nullptr;
287 }
288
end_rwlock_wrwait_noop(PSI_rwlock_locker *,int)289 static void end_rwlock_wrwait_noop(PSI_rwlock_locker *, int) { return; }
290
unlock_rwlock_noop(PSI_rwlock *,enum PSI_rwlock_operation)291 static void unlock_rwlock_noop(PSI_rwlock *, enum PSI_rwlock_operation) {
292 return;
293 }
294
295 static PSI_rwlock_service_t psi_rwlock_noop = {
296 register_rwlock_noop, init_rwlock_noop, destroy_rwlock_noop,
297 start_rwlock_rdwait_noop, end_rwlock_rdwait_noop, start_rwlock_wrwait_noop,
298 end_rwlock_wrwait_noop, unlock_rwlock_noop};
299
300 struct PSI_rwlock_bootstrap *psi_rwlock_hook = nullptr;
301 PSI_rwlock_service_t *psi_rwlock_service = &psi_rwlock_noop;
302
set_psi_rwlock_service(void * psi)303 void set_psi_rwlock_service(void *psi) {
304 psi_rwlock_service = (PSI_rwlock_service_t *)psi;
305 }
306
307 // ===========================================================================
308
register_cond_noop(const char *,PSI_cond_info *,int)309 static void register_cond_noop(const char *, PSI_cond_info *, int) { return; }
310
init_cond_noop(PSI_cond_key,const void *)311 static PSI_cond *init_cond_noop(PSI_cond_key, const void *) { return nullptr; }
312
destroy_cond_noop(PSI_cond *)313 static void destroy_cond_noop(PSI_cond *) { return; }
314
signal_cond_noop(PSI_cond *)315 static void signal_cond_noop(PSI_cond *) { return; }
316
broadcast_cond_noop(PSI_cond *)317 static void broadcast_cond_noop(PSI_cond *) { return; }
318
start_cond_wait_noop(struct PSI_cond_locker_state_v1 *,struct PSI_cond *,struct PSI_mutex *,enum PSI_cond_operation,const char *,uint)319 static struct PSI_cond_locker *start_cond_wait_noop(
320 struct PSI_cond_locker_state_v1 *, struct PSI_cond *, struct PSI_mutex *,
321 enum PSI_cond_operation, const char *, uint) {
322 return nullptr;
323 }
324
end_cond_wait_noop(PSI_cond_locker *,int)325 static void end_cond_wait_noop(PSI_cond_locker *, int) { return; }
326
327 static PSI_cond_service_t psi_cond_noop = {
328 register_cond_noop, init_cond_noop, destroy_cond_noop,
329 signal_cond_noop, broadcast_cond_noop, start_cond_wait_noop,
330 end_cond_wait_noop};
331
332 struct PSI_cond_bootstrap *psi_cond_hook = nullptr;
333 PSI_cond_service_t *psi_cond_service = &psi_cond_noop;
334
set_psi_cond_service(void * psi)335 void set_psi_cond_service(void *psi) {
336 psi_cond_service = (PSI_cond_service_t *)psi;
337 }
338
339 // ===========================================================================
340
register_file_noop(const char *,PSI_file_info *,int)341 static void register_file_noop(const char *, PSI_file_info *, int) { return; }
342
get_thread_file_name_locker_noop(PSI_file_locker_state *,PSI_file_key,enum PSI_file_operation,const char *,const void *)343 static PSI_file_locker *get_thread_file_name_locker_noop(
344 PSI_file_locker_state *, PSI_file_key, enum PSI_file_operation,
345 const char *, const void *) {
346 return nullptr;
347 }
348
get_thread_file_stream_locker_noop(PSI_file_locker_state *,PSI_file *,enum PSI_file_operation)349 static PSI_file_locker *get_thread_file_stream_locker_noop(
350 PSI_file_locker_state *, PSI_file *, enum PSI_file_operation) {
351 return nullptr;
352 }
353
get_thread_file_descriptor_locker_noop(PSI_file_locker_state *,File,enum PSI_file_operation)354 static PSI_file_locker *get_thread_file_descriptor_locker_noop(
355 PSI_file_locker_state *, File, enum PSI_file_operation) {
356 return nullptr;
357 }
358
create_file_noop(PSI_file_key,const char *,File)359 static void create_file_noop(PSI_file_key, const char *, File) { return; }
360
start_file_open_wait_noop(PSI_file_locker *,const char *,uint)361 static void start_file_open_wait_noop(PSI_file_locker *, const char *, uint) {
362 return;
363 }
364
end_file_open_wait_noop(PSI_file_locker *,void *)365 static PSI_file *end_file_open_wait_noop(PSI_file_locker *, void *) {
366 return nullptr;
367 }
368
end_file_open_wait_and_bind_to_descriptor_noop(PSI_file_locker *,File)369 static void end_file_open_wait_and_bind_to_descriptor_noop(PSI_file_locker *,
370 File) {
371 return;
372 }
373
end_temp_file_open_wait_and_bind_to_descriptor_noop(PSI_file_locker *,File,const char *)374 static void end_temp_file_open_wait_and_bind_to_descriptor_noop(
375 PSI_file_locker *, File, const char *) {
376 return;
377 }
378
start_file_wait_noop(PSI_file_locker *,size_t,const char *,uint)379 static void start_file_wait_noop(PSI_file_locker *, size_t, const char *,
380 uint) {
381 return;
382 }
383
end_file_wait_noop(PSI_file_locker *,size_t)384 static void end_file_wait_noop(PSI_file_locker *, size_t) { return; }
385
start_file_close_wait_noop(PSI_file_locker *,const char *,uint)386 static void start_file_close_wait_noop(PSI_file_locker *, const char *, uint) {
387 return;
388 }
389
end_file_close_wait_noop(PSI_file_locker *,int)390 static void end_file_close_wait_noop(PSI_file_locker *, int) { return; }
391
start_file_rename_wait_noop(PSI_file_locker *,size_t,const char *,const char *,const char *,uint)392 static void start_file_rename_wait_noop(PSI_file_locker *, size_t, const char *,
393 const char *, const char *, uint) {
394 return;
395 }
396
end_file_rename_wait_noop(PSI_file_locker *,const char *,const char *,int)397 static void end_file_rename_wait_noop(PSI_file_locker *, const char *,
398 const char *, int) {
399 return;
400 }
401
402 static PSI_file_service_t psi_file_noop = {
403 register_file_noop,
404 create_file_noop,
405 get_thread_file_name_locker_noop,
406 get_thread_file_stream_locker_noop,
407 get_thread_file_descriptor_locker_noop,
408 start_file_open_wait_noop,
409 end_file_open_wait_noop,
410 end_file_open_wait_and_bind_to_descriptor_noop,
411 end_temp_file_open_wait_and_bind_to_descriptor_noop,
412 start_file_wait_noop,
413 end_file_wait_noop,
414 start_file_close_wait_noop,
415 end_file_close_wait_noop,
416 start_file_rename_wait_noop,
417 end_file_rename_wait_noop};
418
419 struct PSI_file_bootstrap *psi_file_hook = nullptr;
420 PSI_file_service_t *psi_file_service = &psi_file_noop;
421
set_psi_file_service(void * psi)422 void set_psi_file_service(void *psi) {
423 psi_file_service = (PSI_file_service_t *)psi;
424 }
425
426 // ===========================================================================
427
register_socket_noop(const char *,PSI_socket_info *,int)428 static void register_socket_noop(const char *, PSI_socket_info *, int) {
429 return;
430 }
431
init_socket_noop(PSI_socket_key,const my_socket *,const struct sockaddr *,socklen_t)432 static PSI_socket *init_socket_noop(PSI_socket_key, const my_socket *,
433 const struct sockaddr *, socklen_t) {
434 return nullptr;
435 }
436
destroy_socket_noop(PSI_socket *)437 static void destroy_socket_noop(PSI_socket *) { return; }
438
start_socket_wait_noop(PSI_socket_locker_state *,PSI_socket *,PSI_socket_operation,size_t,const char *,uint)439 static PSI_socket_locker *start_socket_wait_noop(PSI_socket_locker_state *,
440 PSI_socket *,
441 PSI_socket_operation, size_t,
442 const char *, uint) {
443 return nullptr;
444 }
445
end_socket_wait_noop(PSI_socket_locker *,size_t)446 static void end_socket_wait_noop(PSI_socket_locker *, size_t) { return; }
447
set_socket_state_noop(PSI_socket *,enum PSI_socket_state)448 static void set_socket_state_noop(PSI_socket *, enum PSI_socket_state) {
449 return;
450 }
451
set_socket_info_noop(PSI_socket *,const my_socket *,const struct sockaddr *,socklen_t)452 static void set_socket_info_noop(PSI_socket *, const my_socket *,
453 const struct sockaddr *, socklen_t) {
454 return;
455 }
456
set_socket_thread_owner_noop(PSI_socket *)457 static void set_socket_thread_owner_noop(PSI_socket *) { return; }
458
459 static PSI_socket_service_t psi_socket_noop = {
460 register_socket_noop, init_socket_noop,
461 destroy_socket_noop, start_socket_wait_noop,
462 end_socket_wait_noop, set_socket_state_noop,
463 set_socket_info_noop, set_socket_thread_owner_noop};
464
465 struct PSI_socket_bootstrap *psi_socket_hook = nullptr;
466 PSI_socket_service_t *psi_socket_service = &psi_socket_noop;
467
set_psi_socket_service(void * psi)468 void set_psi_socket_service(void *psi) {
469 psi_socket_service = (PSI_socket_service_t *)psi;
470 }
471
472 // ===========================================================================
473
get_table_share_noop(bool,struct TABLE_SHARE *)474 static PSI_table_share *get_table_share_noop(bool, struct TABLE_SHARE *) {
475 return nullptr;
476 }
477
release_table_share_noop(PSI_table_share *)478 static void release_table_share_noop(PSI_table_share *) { return; }
479
drop_table_share_noop(bool,const char *,int,const char *,int)480 static void drop_table_share_noop(bool, const char *, int, const char *, int) {
481 return;
482 }
483
open_table_noop(PSI_table_share *,const void *)484 static PSI_table *open_table_noop(PSI_table_share *, const void *) {
485 return nullptr;
486 }
487
unbind_table_noop(PSI_table *)488 static void unbind_table_noop(PSI_table *) { return; }
489
rebind_table_noop(PSI_table_share *,const void *,PSI_table *)490 static PSI_table *rebind_table_noop(PSI_table_share *, const void *,
491 PSI_table *) {
492 return nullptr;
493 }
494
close_table_noop(struct TABLE_SHARE *,PSI_table *)495 static void close_table_noop(struct TABLE_SHARE *, PSI_table *) { return; }
496
start_table_io_wait_noop(struct PSI_table_locker_state *,struct PSI_table *,enum PSI_table_io_operation,uint,const char *,uint)497 static struct PSI_table_locker *start_table_io_wait_noop(
498 struct PSI_table_locker_state *, struct PSI_table *,
499 enum PSI_table_io_operation, uint, const char *, uint) {
500 return nullptr;
501 }
502
end_table_io_wait_noop(PSI_table_locker *,ulonglong)503 static void end_table_io_wait_noop(PSI_table_locker *, ulonglong) { return; }
504
start_table_lock_wait_noop(struct PSI_table_locker_state *,struct PSI_table *,enum PSI_table_lock_operation,ulong,const char *,uint)505 static struct PSI_table_locker *start_table_lock_wait_noop(
506 struct PSI_table_locker_state *, struct PSI_table *,
507 enum PSI_table_lock_operation, ulong, const char *, uint) {
508 return nullptr;
509 }
510
end_table_lock_wait_noop(PSI_table_locker *)511 static void end_table_lock_wait_noop(PSI_table_locker *) { return; }
512
unlock_table_noop(PSI_table *)513 static void unlock_table_noop(PSI_table *) { return; }
514
515 static PSI_table_service_t psi_table_noop = {
516 get_table_share_noop, release_table_share_noop,
517 drop_table_share_noop, open_table_noop,
518 unbind_table_noop, rebind_table_noop,
519 close_table_noop, start_table_io_wait_noop,
520 end_table_io_wait_noop, start_table_lock_wait_noop,
521 end_table_lock_wait_noop, unlock_table_noop};
522
523 struct PSI_table_bootstrap *psi_table_hook = nullptr;
524 PSI_table_service_t *psi_table_service = &psi_table_noop;
525
set_psi_table_service(void * psi)526 void set_psi_table_service(void *psi) {
527 psi_table_service = (PSI_table_service_t *)psi;
528 }
529
530 // ===========================================================================
531
create_metadata_lock_noop(void *,const MDL_key *,opaque_mdl_type,opaque_mdl_duration,opaque_mdl_status,const char *,uint)532 static PSI_metadata_lock *create_metadata_lock_noop(void *, const MDL_key *,
533 opaque_mdl_type,
534 opaque_mdl_duration,
535 opaque_mdl_status,
536 const char *, uint) {
537 return nullptr;
538 }
539
set_metadata_lock_status_noop(PSI_metadata_lock *,opaque_mdl_status)540 static void set_metadata_lock_status_noop(PSI_metadata_lock *,
541 opaque_mdl_status) {}
542
destroy_metadata_lock_noop(PSI_metadata_lock *)543 static void destroy_metadata_lock_noop(PSI_metadata_lock *) {}
544
start_metadata_wait_noop(PSI_metadata_locker_state *,PSI_metadata_lock *,const char *,uint)545 static PSI_metadata_locker *start_metadata_wait_noop(
546 PSI_metadata_locker_state *, PSI_metadata_lock *, const char *, uint) {
547 return nullptr;
548 }
549
end_metadata_wait_noop(PSI_metadata_locker *,int)550 static void end_metadata_wait_noop(PSI_metadata_locker *, int) {}
551
552 static PSI_mdl_service_t psi_mdl_noop = {
553 create_metadata_lock_noop, set_metadata_lock_status_noop,
554 destroy_metadata_lock_noop, start_metadata_wait_noop,
555 end_metadata_wait_noop};
556
557 struct PSI_mdl_bootstrap *psi_mdl_hook = nullptr;
558 PSI_mdl_service_t *psi_mdl_service = &psi_mdl_noop;
559
set_psi_mdl_service(void * psi)560 void set_psi_mdl_service(void *psi) {
561 psi_mdl_service = (PSI_mdl_service_t *)psi;
562 }
563
564 // ===========================================================================
565
start_idle_wait_noop(PSI_idle_locker_state *,const char *,uint)566 static PSI_idle_locker *start_idle_wait_noop(PSI_idle_locker_state *,
567 const char *, uint) {
568 return nullptr;
569 }
570
end_idle_wait_noop(PSI_idle_locker *)571 static void end_idle_wait_noop(PSI_idle_locker *) { return; }
572
573 static PSI_idle_service_t psi_idle_noop = {start_idle_wait_noop,
574 end_idle_wait_noop};
575
576 struct PSI_idle_bootstrap *psi_idle_hook = nullptr;
577 PSI_idle_service_t *psi_idle_service = &psi_idle_noop;
578
set_psi_idle_service(void * psi)579 void set_psi_idle_service(void *psi) {
580 psi_idle_service = (PSI_idle_service_t *)psi;
581 }
582
583 // ===========================================================================
584
register_stage_noop(const char *,PSI_stage_info **,int)585 static void register_stage_noop(const char *, PSI_stage_info **, int) {
586 return;
587 }
588
start_stage_noop(PSI_stage_key,const char *,int)589 static PSI_stage_progress *start_stage_noop(PSI_stage_key, const char *, int) {
590 return nullptr;
591 }
592
get_current_stage_progress_noop()593 static PSI_stage_progress *get_current_stage_progress_noop() { return nullptr; }
594
end_stage_noop(void)595 static void end_stage_noop(void) { return; }
596
597 static PSI_stage_service_t psi_stage_noop = {
598 register_stage_noop, start_stage_noop, get_current_stage_progress_noop,
599 end_stage_noop};
600
601 struct PSI_stage_bootstrap *psi_stage_hook = nullptr;
602 PSI_stage_service_t *psi_stage_service = &psi_stage_noop;
603
set_psi_stage_service(void * psi)604 void set_psi_stage_service(void *psi) {
605 psi_stage_service = (PSI_stage_service_t *)psi;
606 }
607
608 // ===========================================================================
609
register_statement_noop(const char *,PSI_statement_info *,int)610 static void register_statement_noop(const char *, PSI_statement_info *, int) {
611 return;
612 }
613
get_thread_statement_locker_noop(PSI_statement_locker_state *,PSI_statement_key,const void *,PSI_sp_share *)614 static PSI_statement_locker *get_thread_statement_locker_noop(
615 PSI_statement_locker_state *, PSI_statement_key, const void *,
616 PSI_sp_share *) {
617 return nullptr;
618 }
619
refine_statement_noop(PSI_statement_locker *,PSI_statement_key)620 static PSI_statement_locker *refine_statement_noop(PSI_statement_locker *,
621 PSI_statement_key) {
622 return nullptr;
623 }
624
start_statement_noop(PSI_statement_locker *,const char *,uint,const char *,uint)625 static void start_statement_noop(PSI_statement_locker *, const char *, uint,
626 const char *, uint) {
627 return;
628 }
629
set_statement_text_noop(PSI_statement_locker *,const char *,uint)630 static void set_statement_text_noop(PSI_statement_locker *, const char *,
631 uint) {
632 return;
633 }
634
set_statement_query_id_noop(PSI_statement_locker *,ulonglong)635 static void set_statement_query_id_noop(PSI_statement_locker *, ulonglong) {
636 return;
637 }
638
set_statement_lock_time_noop(PSI_statement_locker *,ulonglong)639 static void set_statement_lock_time_noop(PSI_statement_locker *, ulonglong) {
640 return;
641 }
642
set_statement_rows_sent_noop(PSI_statement_locker *,ulonglong)643 static void set_statement_rows_sent_noop(PSI_statement_locker *, ulonglong) {
644 return;
645 }
646
set_statement_rows_examined_noop(PSI_statement_locker *,ulonglong)647 static void set_statement_rows_examined_noop(PSI_statement_locker *,
648 ulonglong) {
649 return;
650 }
651
inc_statement_created_tmp_disk_tables_noop(PSI_statement_locker *,ulong)652 static void inc_statement_created_tmp_disk_tables_noop(PSI_statement_locker *,
653 ulong) {
654 return;
655 }
656
inc_statement_created_tmp_tables_noop(PSI_statement_locker *,ulong)657 static void inc_statement_created_tmp_tables_noop(PSI_statement_locker *,
658 ulong) {
659 return;
660 }
661
inc_statement_select_full_join_noop(PSI_statement_locker *,ulong)662 static void inc_statement_select_full_join_noop(PSI_statement_locker *, ulong) {
663 return;
664 }
665
inc_statement_select_full_range_join_noop(PSI_statement_locker *,ulong)666 static void inc_statement_select_full_range_join_noop(PSI_statement_locker *,
667 ulong) {
668 return;
669 }
670
inc_statement_select_range_noop(PSI_statement_locker *,ulong)671 static void inc_statement_select_range_noop(PSI_statement_locker *, ulong) {
672 return;
673 }
674
inc_statement_select_range_check_noop(PSI_statement_locker *,ulong)675 static void inc_statement_select_range_check_noop(PSI_statement_locker *,
676 ulong) {
677 return;
678 }
679
inc_statement_select_scan_noop(PSI_statement_locker *,ulong)680 static void inc_statement_select_scan_noop(PSI_statement_locker *, ulong) {
681 return;
682 }
683
inc_statement_sort_merge_passes_noop(PSI_statement_locker *,ulong)684 static void inc_statement_sort_merge_passes_noop(PSI_statement_locker *,
685 ulong) {
686 return;
687 }
688
inc_statement_sort_range_noop(PSI_statement_locker *,ulong)689 static void inc_statement_sort_range_noop(PSI_statement_locker *, ulong) {
690 return;
691 }
692
inc_statement_sort_rows_noop(PSI_statement_locker *,ulong)693 static void inc_statement_sort_rows_noop(PSI_statement_locker *, ulong) {
694 return;
695 }
696
inc_statement_sort_scan_noop(PSI_statement_locker *,ulong)697 static void inc_statement_sort_scan_noop(PSI_statement_locker *, ulong) {
698 return;
699 }
700
set_statement_no_index_used_noop(PSI_statement_locker *)701 static void set_statement_no_index_used_noop(PSI_statement_locker *) { return; }
702
set_statement_no_good_index_used_noop(PSI_statement_locker *)703 static void set_statement_no_good_index_used_noop(PSI_statement_locker *) {
704 return;
705 }
706
end_statement_noop(PSI_statement_locker *,void *)707 static void end_statement_noop(PSI_statement_locker *, void *) { return; }
708
create_prepared_stmt_noop(void *,uint,PSI_statement_locker *,const char *,size_t,const char *,size_t)709 static PSI_prepared_stmt *create_prepared_stmt_noop(void *, uint,
710 PSI_statement_locker *,
711 const char *, size_t,
712 const char *, size_t) {
713 return nullptr;
714 }
715
destroy_prepared_stmt_noop(PSI_prepared_stmt *)716 static void destroy_prepared_stmt_noop(PSI_prepared_stmt *) { return; }
717
reprepare_prepared_stmt_noop(PSI_prepared_stmt *)718 static void reprepare_prepared_stmt_noop(PSI_prepared_stmt *) { return; }
719
execute_prepared_stmt_noop(PSI_statement_locker *,PSI_prepared_stmt *)720 static void execute_prepared_stmt_noop(PSI_statement_locker *,
721 PSI_prepared_stmt *) {
722 return;
723 }
724
set_prepared_stmt_text_noop(PSI_prepared_stmt *,const char *,uint)725 static void set_prepared_stmt_text_noop(PSI_prepared_stmt *, const char *,
726 uint) {
727 return;
728 }
729
digest_start_noop(PSI_statement_locker *)730 static struct PSI_digest_locker *digest_start_noop(PSI_statement_locker *) {
731 return nullptr;
732 }
733
digest_end_noop(PSI_digest_locker *,const struct sql_digest_storage *)734 static void digest_end_noop(PSI_digest_locker *,
735 const struct sql_digest_storage *) {
736 return;
737 }
738
get_sp_share_noop(uint,const char *,uint,const char *,uint)739 static PSI_sp_share *get_sp_share_noop(uint, const char *, uint, const char *,
740 uint) {
741 return nullptr;
742 }
743
release_sp_share_noop(PSI_sp_share *)744 static void release_sp_share_noop(PSI_sp_share *) { return; }
745
start_sp_noop(PSI_sp_locker_state *,PSI_sp_share *)746 static PSI_sp_locker *start_sp_noop(PSI_sp_locker_state *, PSI_sp_share *) {
747 return nullptr;
748 }
749
end_sp_noop(PSI_sp_locker *)750 static void end_sp_noop(PSI_sp_locker *) { return; }
751
drop_sp_noop(uint,const char *,uint,const char *,uint)752 static void drop_sp_noop(uint, const char *, uint, const char *, uint) {
753 return;
754 }
755
756 static PSI_statement_service_t psi_statement_noop = {
757 register_statement_noop,
758 get_thread_statement_locker_noop,
759 refine_statement_noop,
760 start_statement_noop,
761 set_statement_text_noop,
762 set_statement_query_id_noop,
763 set_statement_lock_time_noop,
764 set_statement_rows_sent_noop,
765 set_statement_rows_examined_noop,
766 inc_statement_created_tmp_disk_tables_noop,
767 inc_statement_created_tmp_tables_noop,
768 inc_statement_select_full_join_noop,
769 inc_statement_select_full_range_join_noop,
770 inc_statement_select_range_noop,
771 inc_statement_select_range_check_noop,
772 inc_statement_select_scan_noop,
773 inc_statement_sort_merge_passes_noop,
774 inc_statement_sort_range_noop,
775 inc_statement_sort_rows_noop,
776 inc_statement_sort_scan_noop,
777 set_statement_no_index_used_noop,
778 set_statement_no_good_index_used_noop,
779 end_statement_noop,
780 create_prepared_stmt_noop,
781 destroy_prepared_stmt_noop,
782 reprepare_prepared_stmt_noop,
783 execute_prepared_stmt_noop,
784 set_prepared_stmt_text_noop,
785 digest_start_noop,
786 digest_end_noop,
787 get_sp_share_noop,
788 release_sp_share_noop,
789 start_sp_noop,
790 end_sp_noop,
791 drop_sp_noop};
792
793 struct PSI_statement_bootstrap *psi_statement_hook = nullptr;
794 PSI_statement_service_t *psi_statement_service = &psi_statement_noop;
795
set_psi_statement_service(void * psi)796 void set_psi_statement_service(void *psi) {
797 psi_statement_service = (PSI_statement_service_t *)psi;
798 }
799
800 // ===========================================================================
801
get_thread_transaction_locker_noop(PSI_transaction_locker_state *,const void *,const ulonglong *,int,bool,bool)802 static PSI_transaction_locker *get_thread_transaction_locker_noop(
803 PSI_transaction_locker_state *, const void *, const ulonglong *, int, bool,
804 bool) {
805 return nullptr;
806 }
807
start_transaction_noop(PSI_transaction_locker *,const char *,uint)808 static void start_transaction_noop(PSI_transaction_locker *, const char *,
809 uint) {
810 return;
811 }
812
set_transaction_xid_noop(PSI_transaction_locker *,const void *,int)813 static void set_transaction_xid_noop(PSI_transaction_locker *, const void *,
814 int) {
815 return;
816 }
817
set_transaction_xa_state_noop(PSI_transaction_locker *,int)818 static void set_transaction_xa_state_noop(PSI_transaction_locker *, int) {
819 return;
820 }
821
set_transaction_gtid_noop(PSI_transaction_locker *,const void *,const void *)822 static void set_transaction_gtid_noop(PSI_transaction_locker *, const void *,
823 const void *) {
824 return;
825 }
826
set_transaction_trxid_noop(PSI_transaction_locker *,const ulonglong *)827 static void set_transaction_trxid_noop(PSI_transaction_locker *,
828 const ulonglong *) {
829 return;
830 }
831
inc_transaction_savepoints_noop(PSI_transaction_locker *,ulong)832 static void inc_transaction_savepoints_noop(PSI_transaction_locker *, ulong) {
833 return;
834 }
835
inc_transaction_rollback_to_savepoint_noop(PSI_transaction_locker *,ulong)836 static void inc_transaction_rollback_to_savepoint_noop(PSI_transaction_locker *,
837 ulong) {
838 return;
839 }
840
inc_transaction_release_savepoint_noop(PSI_transaction_locker *,ulong)841 static void inc_transaction_release_savepoint_noop(PSI_transaction_locker *,
842 ulong) {
843 return;
844 }
845
end_transaction_noop(PSI_transaction_locker *,bool)846 static void end_transaction_noop(PSI_transaction_locker *, bool) { return; }
847
848 static PSI_transaction_service_t psi_transaction_noop = {
849 get_thread_transaction_locker_noop,
850 start_transaction_noop,
851 set_transaction_xid_noop,
852 set_transaction_xa_state_noop,
853 set_transaction_gtid_noop,
854 set_transaction_trxid_noop,
855 inc_transaction_savepoints_noop,
856 inc_transaction_rollback_to_savepoint_noop,
857 inc_transaction_release_savepoint_noop,
858 end_transaction_noop};
859
860 struct PSI_transaction_bootstrap *psi_transaction_hook = nullptr;
861 PSI_transaction_service_t *psi_transaction_service = &psi_transaction_noop;
862
set_psi_transaction_service(void * psi)863 void set_psi_transaction_service(void *psi) {
864 psi_transaction_service = (PSI_transaction_service_t *)psi;
865 }
866
867 // ===========================================================================
868
log_error_noop(unsigned int,PSI_error_operation)869 static void log_error_noop(unsigned int, PSI_error_operation) {}
870
871 static PSI_error_service_t psi_error_noop = {log_error_noop};
872
873 struct PSI_error_bootstrap *psi_error_hook = nullptr;
874 PSI_error_service_t *psi_error_service = &psi_error_noop;
875
set_psi_error_service(void * psi)876 void set_psi_error_service(void *psi) {
877 psi_error_service = (PSI_error_service_t *)psi;
878 }
879
880 // ===========================================================================
881
register_memory_noop(const char *,PSI_memory_info *,int)882 static void register_memory_noop(const char *, PSI_memory_info *, int) {
883 return;
884 }
885
memory_alloc_noop(PSI_memory_key,size_t,struct PSI_thread ** owner)886 static PSI_memory_key memory_alloc_noop(PSI_memory_key, size_t,
887 struct PSI_thread **owner) {
888 *owner = nullptr;
889 return PSI_NOT_INSTRUMENTED;
890 }
891
memory_realloc_noop(PSI_memory_key,size_t,size_t,struct PSI_thread ** owner)892 static PSI_memory_key memory_realloc_noop(PSI_memory_key, size_t, size_t,
893 struct PSI_thread **owner) {
894 *owner = nullptr;
895 return PSI_NOT_INSTRUMENTED;
896 }
897
memory_claim_noop(PSI_memory_key,size_t,struct PSI_thread ** owner)898 static PSI_memory_key memory_claim_noop(PSI_memory_key, size_t,
899 struct PSI_thread **owner) {
900 *owner = nullptr;
901 return PSI_NOT_INSTRUMENTED;
902 }
903
memory_free_noop(PSI_memory_key,size_t,struct PSI_thread *)904 static void memory_free_noop(PSI_memory_key, size_t, struct PSI_thread *) {
905 return;
906 }
907
908 static PSI_memory_service_t psi_memory_noop = {
909 register_memory_noop, memory_alloc_noop, memory_realloc_noop,
910 memory_claim_noop, memory_free_noop};
911
912 struct PSI_memory_bootstrap *psi_memory_hook = nullptr;
913 PSI_memory_service_t *psi_memory_service = &psi_memory_noop;
914
set_psi_memory_service(void * psi)915 void set_psi_memory_service(void *psi) {
916 psi_memory_service = (PSI_memory_service_t *)psi;
917 }
918
919 // ===========================================================================
920
register_data_lock_noop(PSI_engine_data_lock_inspector *)921 static void register_data_lock_noop(PSI_engine_data_lock_inspector *) {
922 return;
923 }
924
unregister_data_lock_noop(PSI_engine_data_lock_inspector *)925 static void unregister_data_lock_noop(PSI_engine_data_lock_inspector *) {
926 return;
927 }
928
929 static PSI_data_lock_service_t psi_data_lock_noop = {register_data_lock_noop,
930 unregister_data_lock_noop};
931
932 struct PSI_data_lock_bootstrap *psi_data_lock_hook = nullptr;
933 PSI_data_lock_service_t *psi_data_lock_service = &psi_data_lock_noop;
934
set_psi_data_lock_service(void * psi)935 void set_psi_data_lock_service(void *psi) {
936 psi_data_lock_service = (PSI_data_lock_service_t *)psi;
937 }
938
939 // ===========================================================================
940
unload_plugin_noop(const char *)941 static void unload_plugin_noop(const char *) { return; }
942
943 static PSI_system_service_t psi_system_noop = {unload_plugin_noop};
944
945 struct PSI_system_bootstrap *psi_system_hook = nullptr;
946 PSI_system_service_t *psi_system_service = &psi_system_noop;
947
set_psi_system_service(void * psi)948 void set_psi_system_service(void *psi) {
949 psi_system_service = (PSI_system_service_t *)psi;
950 }
951
952 // ===========================================================================
953
register_tls_channel_noop(TLS_channel_property_iterator *)954 static void register_tls_channel_noop(TLS_channel_property_iterator *) {
955 return;
956 }
957
unregister_tls_channel_noop(TLS_channel_property_iterator *)958 static void unregister_tls_channel_noop(TLS_channel_property_iterator *) {
959 return;
960 }
961 static PSI_tls_channel_service_t psi_tls_channel_noop = {
962 register_tls_channel_noop, unregister_tls_channel_noop};
963
964 struct PSI_tls_channel_bootstrap *psi_tls_channel_hook = nullptr;
965 PSI_tls_channel_service_t *psi_tls_channel_service = &psi_tls_channel_noop;
966
set_psi_tls_channel_service(void * psi)967 void set_psi_tls_channel_service(void *psi) {
968 psi_tls_channel_service = (PSI_tls_channel_service_t *)psi;
969 }
970