summaryrefslogtreecommitdiffstats
path: root/storage/perfschema
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-05-04 18:07:14 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-05-04 18:07:14 +0000
commita175314c3e5827eb193872241446f2f8f5c9d33c (patch)
treecd3d60ca99ae00829c52a6ca79150a5b6e62528b /storage/perfschema
parentInitial commit. (diff)
downloadmariadb-10.5-a175314c3e5827eb193872241446f2f8f5c9d33c.tar.xz
mariadb-10.5-a175314c3e5827eb193872241446f2f8f5c9d33c.zip
Adding upstream version 1:10.5.12.upstream/1%10.5.12upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to '')
-rw-r--r--storage/perfschema/CMakeLists.txt388
-rw-r--r--storage/perfschema/cursor_by_account.cc82
-rw-r--r--storage/perfschema/cursor_by_account.h68
-rw-r--r--storage/perfschema/cursor_by_host.cc82
-rw-r--r--storage/perfschema/cursor_by_host.h68
-rw-r--r--storage/perfschema/cursor_by_thread.cc83
-rw-r--r--storage/perfschema/cursor_by_thread.h68
-rw-r--r--storage/perfschema/cursor_by_thread_connect_attr.cc92
-rw-r--r--storage/perfschema/cursor_by_thread_connect_attr.h89
-rw-r--r--storage/perfschema/cursor_by_user.cc82
-rw-r--r--storage/perfschema/cursor_by_user.h68
-rw-r--r--storage/perfschema/ha_perfschema.cc497
-rw-r--r--storage/perfschema/ha_perfschema.h251
-rw-r--r--storage/perfschema/my_thread.h133
-rw-r--r--storage/perfschema/mysqld_thd_manager.cc39
-rw-r--r--storage/perfschema/mysqld_thd_manager.h29
-rw-r--r--storage/perfschema/pfs.cc7158
-rw-r--r--storage/perfschema/pfs.h63
-rw-r--r--storage/perfschema/pfs_account.cc747
-rw-r--r--storage/perfschema/pfs_account.h136
-rw-r--r--storage/perfschema/pfs_atomic.h141
-rw-r--r--storage/perfschema/pfs_autosize.cc315
-rw-r--r--storage/perfschema/pfs_buffer_container.cc883
-rw-r--r--storage/perfschema/pfs_buffer_container.h1626
-rw-r--r--storage/perfschema/pfs_builtin_memory.cc382
-rw-r--r--storage/perfschema/pfs_builtin_memory.h143
-rw-r--r--storage/perfschema/pfs_column_types.h328
-rw-r--r--storage/perfschema/pfs_column_values.cc67
-rw-r--r--storage/perfschema/pfs_column_values.h61
-rw-r--r--storage/perfschema/pfs_con_slice.cc82
-rw-r--r--storage/perfschema/pfs_con_slice.h261
-rw-r--r--storage/perfschema/pfs_config.h.cmake6
-rw-r--r--storage/perfschema/pfs_defaults.cc106
-rw-r--r--storage/perfschema/pfs_defaults.h39
-rw-r--r--storage/perfschema/pfs_digest.cc412
-rw-r--r--storage/perfschema/pfs_digest.h94
-rw-r--r--storage/perfschema/pfs_engine_table.cc1931
-rw-r--r--storage/perfschema/pfs_engine_table.h610
-rw-r--r--storage/perfschema/pfs_events.h71
-rw-r--r--storage/perfschema/pfs_events_stages.cc246
-rw-r--r--storage/perfschema/pfs_events_stages.h72
-rw-r--r--storage/perfschema/pfs_events_statements.cc329
-rw-r--r--storage/perfschema/pfs_events_statements.h152
-rw-r--r--storage/perfschema/pfs_events_transactions.cc267
-rw-r--r--storage/perfschema/pfs_events_transactions.h132
-rw-r--r--storage/perfschema/pfs_events_waits.cc301
-rw-r--r--storage/perfschema/pfs_events_waits.h157
-rw-r--r--storage/perfschema/pfs_global.cc267
-rw-r--r--storage/perfschema/pfs_global.h201
-rw-r--r--storage/perfschema/pfs_host.cc374
-rw-r--r--storage/perfschema/pfs_host.h120
-rw-r--r--storage/perfschema/pfs_instr.cc2343
-rw-r--r--storage/perfschema/pfs_instr.h814
-rw-r--r--storage/perfschema/pfs_instr_class.cc2064
-rw-r--r--storage/perfschema/pfs_instr_class.h646
-rw-r--r--storage/perfschema/pfs_lock.h310
-rw-r--r--storage/perfschema/pfs_memory.cc98
-rw-r--r--storage/perfschema/pfs_memory.h38
-rw-r--r--storage/perfschema/pfs_prepared_stmt.cc145
-rw-r--r--storage/perfschema/pfs_prepared_stmt.h95
-rw-r--r--storage/perfschema/pfs_program.cc322
-rw-r--r--storage/perfschema/pfs_program.h103
-rw-r--r--storage/perfschema/pfs_server.cc448
-rw-r--r--storage/perfschema/pfs_server.h309
-rw-r--r--storage/perfschema/pfs_setup_actor.cc342
-rw-r--r--storage/perfschema/pfs_setup_actor.h112
-rw-r--r--storage/perfschema/pfs_setup_object.cc338
-rw-r--r--storage/perfschema/pfs_setup_object.h107
-rw-r--r--storage/perfschema/pfs_stat.h1332
-rw-r--r--storage/perfschema/pfs_status.cc166
-rw-r--r--storage/perfschema/pfs_status.h51
-rw-r--r--storage/perfschema/pfs_timer.cc345
-rw-r--r--storage/perfschema/pfs_timer.h152
-rw-r--r--storage/perfschema/pfs_user.cc339
-rw-r--r--storage/perfschema/pfs_user.h122
-rw-r--r--storage/perfschema/pfs_variable.cc1291
-rw-r--r--storage/perfschema/pfs_variable.h716
-rw-r--r--storage/perfschema/pfs_visitor.cc1694
-rw-r--r--storage/perfschema/pfs_visitor.h687
-rw-r--r--storage/perfschema/rpl_gtid.h17
-rw-r--r--storage/perfschema/table_accounts.cc142
-rw-r--r--storage/perfschema/table_accounts.h85
-rw-r--r--storage/perfschema/table_all_instr.cc188
-rw-r--r--storage/perfschema/table_all_instr.h124
-rw-r--r--storage/perfschema/table_esgs_by_account_by_event_name.cc210
-rw-r--r--storage/perfschema/table_esgs_by_account_by_event_name.h128
-rw-r--r--storage/perfschema/table_esgs_by_host_by_event_name.cc211
-rw-r--r--storage/perfschema/table_esgs_by_host_by_event_name.h128
-rw-r--r--storage/perfschema/table_esgs_by_thread_by_event_name.cc202
-rw-r--r--storage/perfschema/table_esgs_by_thread_by_event_name.h132
-rw-r--r--storage/perfschema/table_esgs_by_user_by_event_name.cc210
-rw-r--r--storage/perfschema/table_esgs_by_user_by_event_name.h133
-rw-r--r--storage/perfschema/table_esgs_global_by_event_name.cc191
-rw-r--r--storage/perfschema/table_esgs_global_by_event_name.h99
-rw-r--r--storage/perfschema/table_esms_by_account_by_event_name.cc232
-rw-r--r--storage/perfschema/table_esms_by_account_by_event_name.h128
-rw-r--r--storage/perfschema/table_esms_by_digest.cc226
-rw-r--r--storage/perfschema/table_esms_by_digest.h101
-rw-r--r--storage/perfschema/table_esms_by_host_by_event_name.cc233
-rw-r--r--storage/perfschema/table_esms_by_host_by_event_name.h128
-rw-r--r--storage/perfschema/table_esms_by_program.cc245
-rw-r--r--storage/perfschema/table_esms_by_program.h113
-rw-r--r--storage/perfschema/table_esms_by_thread_by_event_name.cc225
-rw-r--r--storage/perfschema/table_esms_by_thread_by_event_name.h132
-rw-r--r--storage/perfschema/table_esms_by_user_by_event_name.cc232
-rw-r--r--storage/perfschema/table_esms_by_user_by_event_name.h128
-rw-r--r--storage/perfschema/table_esms_global_by_event_name.cc215
-rw-r--r--storage/perfschema/table_esms_global_by_event_name.h99
-rw-r--r--storage/perfschema/table_ets_by_account_by_event_name.cc225
-rw-r--r--storage/perfschema/table_ets_by_account_by_event_name.h134
-rw-r--r--storage/perfschema/table_ets_by_host_by_event_name.cc226
-rw-r--r--storage/perfschema/table_ets_by_host_by_event_name.h134
-rw-r--r--storage/perfschema/table_ets_by_thread_by_event_name.cc218
-rw-r--r--storage/perfschema/table_ets_by_thread_by_event_name.h138
-rw-r--r--storage/perfschema/table_ets_by_user_by_event_name.cc225
-rw-r--r--storage/perfschema/table_ets_by_user_by_event_name.h134
-rw-r--r--storage/perfschema/table_ets_global_by_event_name.cc200
-rw-r--r--storage/perfschema/table_ets_global_by_event_name.h105
-rw-r--r--storage/perfschema/table_events_stages.cc541
-rw-r--r--storage/perfschema/table_events_stages.h221
-rw-r--r--storage/perfschema/table_events_statements.cc940
-rw-r--r--storage/perfschema/table_events_statements.h314
-rw-r--r--storage/perfschema/table_events_transactions.cc718
-rw-r--r--storage/perfschema/table_events_transactions.h254
-rw-r--r--storage/perfschema/table_events_waits.cc1143
-rw-r--r--storage/perfschema/table_events_waits.h267
-rw-r--r--storage/perfschema/table_events_waits_summary.cc236
-rw-r--r--storage/perfschema/table_events_waits_summary.h97
-rw-r--r--storage/perfschema/table_ews_by_account_by_event_name.cc271
-rw-r--r--storage/perfschema/table_ews_by_account_by_event_name.h139
-rw-r--r--storage/perfschema/table_ews_by_host_by_event_name.cc273
-rw-r--r--storage/perfschema/table_ews_by_host_by_event_name.h139
-rw-r--r--storage/perfschema/table_ews_by_thread_by_event_name.cc279
-rw-r--r--storage/perfschema/table_ews_by_thread_by_event_name.h138
-rw-r--r--storage/perfschema/table_ews_by_user_by_event_name.cc272
-rw-r--r--storage/perfschema/table_ews_by_user_by_event_name.h139
-rw-r--r--storage/perfschema/table_ews_global_by_event_name.cc437
-rw-r--r--storage/perfschema/table_ews_global_by_event_name.h135
-rw-r--r--storage/perfschema/table_file_instances.cc174
-rw-r--r--storage/perfschema/table_file_instances.h96
-rw-r--r--storage/perfschema/table_file_summary_by_event_name.cc259
-rw-r--r--storage/perfschema/table_file_summary_by_event_name.h97
-rw-r--r--storage/perfschema/table_file_summary_by_instance.cc279
-rw-r--r--storage/perfschema/table_file_summary_by_instance.h105
-rw-r--r--storage/perfschema/table_global_status.cc190
-rw-r--r--storage/perfschema/table_global_status.h118
-rw-r--r--storage/perfschema/table_global_variables.cc184
-rw-r--r--storage/perfschema/table_global_variables.h117
-rw-r--r--storage/perfschema/table_helper.cc896
-rw-r--r--storage/perfschema/table_helper.h702
-rw-r--r--storage/perfschema/table_host_cache.cc372
-rw-r--r--storage/perfschema/table_host_cache.h150
-rw-r--r--storage/perfschema/table_hosts.cc149
-rw-r--r--storage/perfschema/table_hosts.h85
-rw-r--r--storage/perfschema/table_md_locks.cc207
-rw-r--r--storage/perfschema/table_md_locks.h106
-rw-r--r--storage/perfschema/table_mems_by_account_by_event_name.cc221
-rw-r--r--storage/perfschema/table_mems_by_account_by_event_name.h129
-rw-r--r--storage/perfschema/table_mems_by_host_by_event_name.cc221
-rw-r--r--storage/perfschema/table_mems_by_host_by_event_name.h129
-rw-r--r--storage/perfschema/table_mems_by_thread_by_event_name.cc214
-rw-r--r--storage/perfschema/table_mems_by_thread_by_event_name.h129
-rw-r--r--storage/perfschema/table_mems_by_user_by_event_name.cc221
-rw-r--r--storage/perfschema/table_mems_by_user_by_event_name.h129
-rw-r--r--storage/perfschema/table_mems_global_by_event_name.cc241
-rw-r--r--storage/perfschema/table_mems_global_by_event_name.h132
-rw-r--r--storage/perfschema/table_os_global_by_type.cc303
-rw-r--r--storage/perfschema/table_os_global_by_type.h131
-rw-r--r--storage/perfschema/table_performance_timers.cc177
-rw-r--r--storage/perfschema/table_performance_timers.h92
-rw-r--r--storage/perfschema/table_prepared_stmt_instances.cc294
-rw-r--r--storage/perfschema/table_prepared_stmt_instances.h132
-rw-r--r--storage/perfschema/table_replication_applier_configuration.cc194
-rw-r--r--storage/perfschema/table_replication_applier_configuration.h107
-rw-r--r--storage/perfschema/table_replication_applier_status.cc222
-rw-r--r--storage/perfschema/table_replication_applier_status.h118
-rw-r--r--storage/perfschema/table_replication_applier_status_by_coordinator.cc249
-rw-r--r--storage/perfschema/table_replication_applier_status_by_coordinator.h124
-rw-r--r--storage/perfschema/table_replication_applier_status_by_worker.cc412
-rw-r--r--storage/perfschema/table_replication_applier_status_by_worker.h182
-rw-r--r--storage/perfschema/table_replication_connection_configuration.cc333
-rw-r--r--storage/perfschema/table_replication_connection_configuration.h152
-rw-r--r--storage/perfschema/table_replication_connection_status.cc440
-rw-r--r--storage/perfschema/table_replication_connection_status.h150
-rw-r--r--storage/perfschema/table_replication_group_member_stats.cc372
-rw-r--r--storage/perfschema/table_replication_group_member_stats.h116
-rw-r--r--storage/perfschema/table_replication_group_members.cc281
-rw-r--r--storage/perfschema/table_replication_group_members.h108
-rw-r--r--storage/perfschema/table_session_account_connect_attrs.cc82
-rw-r--r--storage/perfschema/table_session_account_connect_attrs.h57
-rw-r--r--storage/perfschema/table_session_connect.cc295
-rw-r--r--storage/perfschema/table_session_connect.h86
-rw-r--r--storage/perfschema/table_session_connect_attrs.cc55
-rw-r--r--storage/perfschema/table_session_connect_attrs.h54
-rw-r--r--storage/perfschema/table_session_status.cc185
-rw-r--r--storage/perfschema/table_session_status.h119
-rw-r--r--storage/perfschema/table_session_variables.cc187
-rw-r--r--storage/perfschema/table_session_variables.h117
-rw-r--r--storage/perfschema/table_setup_actors.cc312
-rw-r--r--storage/perfschema/table_setup_actors.h115
-rw-r--r--storage/perfschema/table_setup_consumers.cc275
-rw-r--r--storage/perfschema/table_setup_consumers.h95
-rw-r--r--storage/perfschema/table_setup_instruments.cc372
-rw-r--r--storage/perfschema/table_setup_instruments.h135
-rw-r--r--storage/perfschema/table_setup_objects.cc334
-rw-r--r--storage/perfschema/table_setup_objects.h114
-rw-r--r--storage/perfschema/table_setup_timers.cc205
-rw-r--r--storage/perfschema/table_setup_timers.h91
-rw-r--r--storage/perfschema/table_socket_instances.cc208
-rw-r--r--storage/perfschema/table_socket_instances.h108
-rw-r--r--storage/perfschema/table_socket_summary_by_event_name.cc255
-rw-r--r--storage/perfschema/table_socket_summary_by_event_name.h98
-rw-r--r--storage/perfschema/table_socket_summary_by_instance.cc271
-rw-r--r--storage/perfschema/table_socket_summary_by_instance.h101
-rw-r--r--storage/perfschema/table_status_by_account.cc246
-rw-r--r--storage/perfschema/table_status_by_account.h156
-rw-r--r--storage/perfschema/table_status_by_host.cc245
-rw-r--r--storage/perfschema/table_status_by_host.h154
-rw-r--r--storage/perfschema/table_status_by_thread.cc239
-rw-r--r--storage/perfschema/table_status_by_thread.h151
-rw-r--r--storage/perfschema/table_status_by_user.cc246
-rw-r--r--storage/perfschema/table_status_by_user.h153
-rw-r--r--storage/perfschema/table_sync_instances.cc472
-rw-r--r--storage/perfschema/table_sync_instances.h210
-rw-r--r--storage/perfschema/table_table_handles.cc214
-rw-r--r--storage/perfschema/table_table_handles.h108
-rw-r--r--storage/perfschema/table_threads.cc365
-rw-r--r--storage/perfschema/table_threads.h128
-rw-r--r--storage/perfschema/table_tiws_by_index_usage.cc371
-rw-r--r--storage/perfschema/table_tiws_by_index_usage.h124
-rw-r--r--storage/perfschema/table_tiws_by_table.cc333
-rw-r--r--storage/perfschema/table_tiws_by_table.h99
-rw-r--r--storage/perfschema/table_tlws_by_table.cc485
-rw-r--r--storage/perfschema/table_tlws_by_table.h99
-rw-r--r--storage/perfschema/table_users.cc149
-rw-r--r--storage/perfschema/table_users.h85
-rw-r--r--storage/perfschema/table_uvar_by_thread.cc329
-rw-r--r--storage/perfschema/table_uvar_by_thread.h195
-rw-r--r--storage/perfschema/table_variables_by_thread.cc229
-rw-r--r--storage/perfschema/table_variables_by_thread.h151
-rw-r--r--storage/perfschema/unittest/CMakeLists.txt40
-rw-r--r--storage/perfschema/unittest/conf.txt427
-rw-r--r--storage/perfschema/unittest/pfs-t.cc1909
-rw-r--r--storage/perfschema/unittest/pfs_account-oom-t.cc174
-rw-r--r--storage/perfschema/unittest/pfs_connect_attr-t.cc352
-rw-r--r--storage/perfschema/unittest/pfs_host-oom-t.cc148
-rw-r--r--storage/perfschema/unittest/pfs_instr-oom-t.cc459
-rw-r--r--storage/perfschema/unittest/pfs_instr-t.cc488
-rw-r--r--storage/perfschema/unittest/pfs_instr_class-oom-t.cc114
-rw-r--r--storage/perfschema/unittest/pfs_instr_class-t.cc750
-rw-r--r--storage/perfschema/unittest/pfs_misc-t.cc95
-rw-r--r--storage/perfschema/unittest/pfs_noop-t.cc242
-rw-r--r--storage/perfschema/unittest/pfs_server_stubs.cc63
-rw-r--r--storage/perfschema/unittest/pfs_timer-t.cc128
-rw-r--r--storage/perfschema/unittest/pfs_user-oom-t.cc146
-rw-r--r--storage/perfschema/unittest/stub_global_status_var.h31
-rw-r--r--storage/perfschema/unittest/stub_pfs_defaults.h30
-rw-r--r--storage/perfschema/unittest/stub_pfs_global.h89
-rw-r--r--storage/perfschema/unittest/stub_print_error.h72
259 files changed, 75817 insertions, 0 deletions
diff --git a/storage/perfschema/CMakeLists.txt b/storage/perfschema/CMakeLists.txt
new file mode 100644
index 00000000..d5625afb
--- /dev/null
+++ b/storage/perfschema/CMakeLists.txt
@@ -0,0 +1,388 @@
+# Copyright (c) 2009, 2019, Oracle and/or its affiliates. All rights reserved.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License, version 2.0,
+# as published by the Free Software Foundation.
+#
+# This program is also distributed with certain software (including
+# but not limited to OpenSSL) that is licensed under separate terms,
+# as designated in a particular file or component or in included license
+# documentation. The authors of MySQL hereby grant you an additional
+# permission to link the program and your derivative works with the
+# separately licensed software that they have included with MySQL.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License, version 2.0, for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA
+
+INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/include
+ ${CMAKE_SOURCE_DIR}/sql
+ ${CMAKE_BINARY_DIR}/sql
+ ${CMAKE_CURRENT_BINARY_DIR}
+ ${PCRE_INCLUDES}
+ ${SSL_INCLUDE_DIRS})
+
+ADD_DEFINITIONS(-DMYSQL_SERVER)
+IF (SSL_DEFINES)
+ ADD_DEFINITIONS(${SSL_DEFINES})
+ENDIF()
+
+IF(CMAKE_SYSTEM_NAME MATCHES AIX)
+ # Workaround linker bug on AIX
+ SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,-berok")
+ENDIF()
+
+#
+# Maintainer: keep this list sorted, to avoid merge collisions.
+# Tip: ls -1 *.h, ls -1 *.cc
+#
+SET(PERFSCHEMA_SOURCES
+ha_perfschema.h
+cursor_by_account.h
+cursor_by_host.h
+cursor_by_thread.h
+cursor_by_user.h
+pfs.h
+pfs_account.h
+pfs_atomic.h
+pfs_buffer_container.h
+pfs_builtin_memory.h
+pfs_column_types.h
+pfs_column_values.h
+pfs_con_slice.h
+pfs_defaults.h
+pfs_digest.h
+pfs_program.h
+pfs_prepared_stmt.h
+pfs_engine_table.h
+pfs_events.h
+pfs_events_stages.h
+pfs_events_statements.h
+pfs_events_transactions.h
+pfs_events_waits.h
+pfs_global.h
+pfs_host.h
+pfs_instr.h
+pfs_instr_class.h
+pfs_lock.h
+pfs_memory.h
+pfs_server.h
+pfs_setup_actor.h
+pfs_setup_object.h
+pfs_stat.h
+pfs_status.h
+pfs_timer.h
+pfs_user.h
+pfs_variable.h
+pfs_visitor.h
+table_accounts.h
+table_all_instr.h
+table_esgs_by_account_by_event_name.h
+table_esgs_by_host_by_event_name.h
+table_esgs_by_thread_by_event_name.h
+table_esgs_by_user_by_event_name.h
+table_esgs_global_by_event_name.h
+table_esms_by_account_by_event_name.h
+table_esms_by_host_by_event_name.h
+table_esms_by_digest.h
+table_esms_by_program.h
+table_prepared_stmt_instances.h
+table_esms_by_thread_by_event_name.h
+table_esms_by_user_by_event_name.h
+table_esms_global_by_event_name.h
+table_ets_by_account_by_event_name.h
+table_ets_by_host_by_event_name.h
+table_ets_by_thread_by_event_name.h
+table_ets_by_user_by_event_name.h
+table_ets_global_by_event_name.h
+table_events_stages.h
+table_events_statements.h
+table_events_transactions.h
+table_events_waits.h
+table_events_waits_summary.h
+table_ews_by_account_by_event_name.h
+table_ews_by_host_by_event_name.h
+table_ews_by_thread_by_event_name.h
+table_ews_by_user_by_event_name.h
+table_ews_global_by_event_name.h
+table_file_instances.h
+table_md_locks.h
+table_mems_global_by_event_name.h
+table_mems_by_account_by_event_name.h
+table_mems_by_host_by_event_name.h
+table_mems_by_thread_by_event_name.h
+table_mems_by_user_by_event_name.h
+table_file_summary_by_instance.h
+table_file_summary_by_event_name.h
+table_socket_instances.h
+table_socket_summary_by_instance.h
+table_socket_summary_by_event_name.h
+table_helper.h
+table_host_cache.h
+table_hosts.h
+table_os_global_by_type.h
+table_performance_timers.h
+table_setup_actors.h
+table_setup_consumers.h
+table_setup_instruments.h
+table_setup_objects.h
+table_setup_timers.h
+table_sync_instances.h
+table_status_by_account.h
+table_status_by_host.h
+table_status_by_thread.h
+table_status_by_user.h
+table_global_status.h
+table_session_status.h
+table_variables_by_thread.h
+table_global_variables.h
+table_session_variables.h
+table_table_handles.h
+table_threads.h
+table_tiws_by_index_usage.h
+table_tiws_by_table.h
+table_tlws_by_table.h
+table_users.h
+table_uvar_by_thread.h
+cursor_by_thread_connect_attr.h
+table_session_connect.h
+table_session_connect_attrs.h
+table_session_account_connect_attrs.h
+table_replication_connection_configuration.h
+table_replication_group_members.h
+table_replication_connection_status.h
+table_replication_applier_configuration.h
+table_replication_applier_status.h
+table_replication_applier_status_by_coordinator.h
+table_replication_applier_status_by_worker.h
+table_replication_group_member_stats.h
+cursor_by_account.cc
+cursor_by_host.cc
+cursor_by_thread.cc
+cursor_by_user.cc
+ha_perfschema.cc
+mysqld_thd_manager.cc
+pfs.cc
+pfs_account.cc
+pfs_autosize.cc
+pfs_buffer_container.cc
+pfs_builtin_memory.cc
+pfs_column_values.cc
+pfs_con_slice.cc
+pfs_defaults.cc
+pfs_digest.cc
+pfs_program.cc
+pfs_prepared_stmt.cc
+pfs_engine_table.cc
+pfs_events_stages.cc
+pfs_events_statements.cc
+pfs_events_transactions.cc
+pfs_events_waits.cc
+pfs_global.cc
+pfs_host.cc
+pfs_instr.cc
+pfs_instr_class.cc
+pfs_memory.cc
+pfs_server.cc
+pfs_setup_actor.cc
+pfs_setup_object.cc
+pfs_status.cc
+pfs_timer.cc
+pfs_user.cc
+pfs_variable.cc
+pfs_visitor.cc
+table_accounts.cc
+table_all_instr.cc
+table_esgs_by_account_by_event_name.cc
+table_esgs_by_host_by_event_name.cc
+table_esgs_by_thread_by_event_name.cc
+table_esgs_by_user_by_event_name.cc
+table_esgs_global_by_event_name.cc
+table_esms_by_account_by_event_name.cc
+table_esms_by_host_by_event_name.cc
+table_esms_by_digest.cc
+table_esms_by_program.cc
+table_prepared_stmt_instances.cc
+table_esms_by_thread_by_event_name.cc
+table_esms_by_user_by_event_name.cc
+table_esms_global_by_event_name.cc
+table_ets_by_account_by_event_name.cc
+table_ets_by_host_by_event_name.cc
+table_ets_by_thread_by_event_name.cc
+table_ets_by_user_by_event_name.cc
+table_ets_global_by_event_name.cc
+table_events_stages.cc
+table_events_statements.cc
+table_events_transactions.cc
+table_events_waits.cc
+table_events_waits_summary.cc
+table_ews_by_account_by_event_name.cc
+table_ews_by_host_by_event_name.cc
+table_ews_by_thread_by_event_name.cc
+table_ews_by_user_by_event_name.cc
+table_ews_global_by_event_name.cc
+table_file_instances.cc
+table_md_locks.cc
+table_mems_global_by_event_name.cc
+table_mems_by_account_by_event_name.cc
+table_mems_by_host_by_event_name.cc
+table_mems_by_thread_by_event_name.cc
+table_mems_by_user_by_event_name.cc
+table_file_summary_by_instance.cc
+table_file_summary_by_event_name.cc
+table_socket_instances.cc
+table_socket_summary_by_instance.cc
+table_socket_summary_by_event_name.cc
+table_helper.cc
+table_host_cache.cc
+table_hosts.cc
+table_os_global_by_type.cc
+table_performance_timers.cc
+table_setup_actors.cc
+table_setup_consumers.cc
+table_setup_instruments.cc
+table_setup_objects.cc
+table_setup_timers.cc
+table_sync_instances.cc
+table_status_by_account.cc
+table_status_by_host.cc
+table_status_by_thread.cc
+table_status_by_user.cc
+table_global_status.cc
+table_session_status.cc
+#table_variables_by_thread.cc
+#table_global_variables.cc
+#table_session_variables.cc
+table_table_handles.cc
+table_threads.cc
+table_tiws_by_index_usage.cc
+table_tiws_by_table.cc
+table_tlws_by_table.cc
+table_users.cc
+table_uvar_by_thread.cc
+cursor_by_thread_connect_attr.cc
+table_session_connect.cc
+table_session_connect_attrs.cc
+table_session_account_connect_attrs.cc
+table_replication_connection_configuration.cc
+#table_replication_group_members.cc
+#table_replication_connection_status.cc
+table_replication_applier_configuration.cc
+table_replication_applier_status.cc
+table_replication_applier_status_by_coordinator.cc
+#table_replication_applier_status_by_worker.cc
+#table_replication_group_member_stats.cc
+)
+
+# Check for pthread_threadid_np()
+CHECK_C_SOURCE_COMPILES("
+#include <pthread.h>
+int main(int ac, char **av)
+{
+ unsigned long long tid64;
+ pthread_threadid_np(NULL, &tid64);
+ return (tid64 != 0 ? 0 : 1);
+}"
+HAVE_PTHREAD_THREADID_NP)
+
+# gettid() library function (glibc-2.30+)
+CHECK_SYMBOL_EXISTS(gettid unistd.h HAVE_GETTID)
+
+# Check for gettid() system call
+CHECK_C_SOURCE_COMPILES("
+#include <sys/types.h>
+#include <sys/syscall.h>
+#include <unistd.h>
+int main(int ac, char **av)
+{
+ unsigned long long tid = syscall(SYS_gettid);
+ return (tid != 0 ? 0 : 1);
+}"
+HAVE_SYS_GETTID)
+
+# Check for getthrid()
+CHECK_C_SOURCE_COMPILES("
+#include <unistd.h>
+int main(int ac, char **av)
+{
+ unsigned long long tid = getthrid();
+ return (tid != 0 ? 0 : 1);
+}"
+HAVE_GETTHRID)
+
+# Check for pthread_getthreadid_np()
+CHECK_C_SOURCE_COMPILES("
+#include <pthread_np.h>
+int main(int ac, char **av)
+{
+ unsigned long long tid = pthread_getthreadid_np();
+ return (tid != 0 ? 0 : 1);
+}"
+HAVE_PTHREAD_GETTHREADID_NP)
+
+# Check for pthread_self() returning an integer type
+CHECK_C_SOURCE_COMPILES("
+#include <sys/types.h>
+#include <pthread.h>
+int main(int ac, char **av)
+{
+ unsigned long long tid = pthread_self();
+ return (tid != 0 ? 0 : 1);
+}"
+HAVE_INTEGER_PTHREAD_SELF
+FAIL_REGEX "warning: incompatible pointer to integer conversion"
+)
+
+CONFIGURE_FILE(pfs_config.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/pfs_config.h)
+
+MYSQL_ADD_PLUGIN(perfschema ${PERFSCHEMA_SOURCES} STORAGE_ENGINE DEFAULT
+ STATIC_ONLY RECOMPILE_FOR_EMBEDDED)
+IF (TARGET perfschema)
+ ADD_DEPENDENCIES(perfschema GenServerSource)
+ IF(WITH_UNIT_TESTS)
+ ADD_SUBDIRECTORY(unittest)
+ ENDIF(WITH_UNIT_TESTS)
+ENDIF(TARGET perfschema)
+
+# Only disable threads when building without *any* instrumentation,
+# as other instrumentations have a dependency on threads.
+OPTION(DISABLE_PSI_THREAD "Exclude the performance schema thread instrumentation" OFF)
+
+OPTION(DISABLE_PSI_MUTEX "Exclude the performance schema mutex instrumentation" OFF)
+OPTION(DISABLE_PSI_RWLOCK "Exclude the performance schema rwlock instrumentation" OFF)
+OPTION(DISABLE_PSI_COND "Exclude the performance schema condition instrumentation" OFF)
+OPTION(DISABLE_PSI_FILE "Exclude the performance schema file instrumentation" OFF)
+OPTION(DISABLE_PSI_TABLE "Exclude the performance schema table instrumentation" OFF)
+OPTION(DISABLE_PSI_SOCKET "Exclude the performance schema socket instrumentation" OFF)
+OPTION(DISABLE_PSI_STAGE "Exclude the performance schema stage instrumentation" OFF)
+OPTION(DISABLE_PSI_STATEMENT "Exclude the performance schema statement instrumentation" OFF)
+OPTION(DISABLE_PSI_SP "Exclude the performance schema stored procedure instrumentation" OFF)
+OPTION(DISABLE_PSI_PS "Exclude the performance schema prepared statements instances instrumentation" OFF)
+OPTION(DISABLE_PSI_IDLE "Exclude the performance schema idle instrumentation" OFF)
+OPTION(DISABLE_PSI_STATEMENT_DIGEST "Exclude the performance schema statement digest instrumentation" OFF)
+OPTION(DISABLE_PSI_METADATA "Exclude the performance schema metadata instrumentation" OFF)
+OPTION(DISABLE_PSI_MEMORY "Exclude the performance schema memory instrumentation" OFF)
+OPTION(DISABLE_PSI_TRANSACTION "Exclude the performance schema transaction instrumentation" OFF)
+
+MARK_AS_ADVANCED(DISABLE_PSI_THREAD)
+
+MARK_AS_ADVANCED(DISABLE_PSI_MUTEX)
+MARK_AS_ADVANCED(DISABLE_PSI_RWLOCK)
+MARK_AS_ADVANCED(DISABLE_PSI_COND)
+MARK_AS_ADVANCED(DISABLE_PSI_FILE)
+MARK_AS_ADVANCED(DISABLE_PSI_TABLE)
+MARK_AS_ADVANCED(DISABLE_PSI_SOCKET)
+MARK_AS_ADVANCED(DISABLE_PSI_STAGE)
+MARK_AS_ADVANCED(DISABLE_PSI_STATEMENT)
+MARK_AS_ADVANCED(DISABLE_PSI_SP)
+MARK_AS_ADVANCED(DISABLE_PSI_PS)
+MARK_AS_ADVANCED(DISABLE_PSI_IDLE)
+MARK_AS_ADVANCED(DISABLE_PSI_STATEMENT_DIGEST)
+MARK_AS_ADVANCED(DISABLE_PSI_METADATA)
+MARK_AS_ADVANCED(DISABLE_PSI_MEMORY)
+MARK_AS_ADVANCED(DISABLE_PSI_TRANSACTION)
diff --git a/storage/perfschema/cursor_by_account.cc b/storage/perfschema/cursor_by_account.cc
new file mode 100644
index 00000000..1b208e00
--- /dev/null
+++ b/storage/perfschema/cursor_by_account.cc
@@ -0,0 +1,82 @@
+/* Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/cursor_by_account.cc
+ Cursor CURSOR_BY_ACCOUNT (implementation).
+*/
+
+#include "my_global.h"
+#include "cursor_by_account.h"
+#include "pfs_buffer_container.h"
+
+ha_rows
+cursor_by_account::get_row_count(void)
+{
+ return global_account_container.get_row_count();
+}
+
+cursor_by_account::cursor_by_account(const PFS_engine_table_share *share)
+ : PFS_engine_table(share, &m_pos),
+ m_pos(0), m_next_pos(0)
+{}
+
+void cursor_by_account::reset_position(void)
+{
+ m_pos.m_index= 0;
+ m_next_pos.m_index= 0;
+}
+
+int cursor_by_account::rnd_next(void)
+{
+ PFS_account *pfs;
+
+ m_pos.set_at(&m_next_pos);
+ PFS_account_iterator it= global_account_container.iterate(m_pos.m_index);
+ pfs= it.scan_next(& m_pos.m_index);
+ if (pfs != NULL)
+ {
+ make_row(pfs);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int
+cursor_by_account::rnd_pos(const void *pos)
+{
+ PFS_account *pfs;
+
+ set_position(pos);
+
+ pfs= global_account_container.get(m_pos.m_index);
+ if (pfs != NULL)
+ {
+ make_row(pfs);
+ return 0;
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
diff --git a/storage/perfschema/cursor_by_account.h b/storage/perfschema/cursor_by_account.h
new file mode 100644
index 00000000..d689cf6c
--- /dev/null
+++ b/storage/perfschema/cursor_by_account.h
@@ -0,0 +1,68 @@
+/* Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef CURSOR_BY_ACCOUNT_H
+#define CURSOR_BY_ACCOUNT_H
+
+/**
+ @file storage/perfschema/cursor_by_account.h
+ Cursor CURSOR_BY_ACCOUNT (declarations).
+*/
+
+#include "pfs_engine_table.h"
+#include "pfs_account.h"
+#include "table_helper.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/** Cursor CURSOR_BY_ACCOUNT. */
+class cursor_by_account : public PFS_engine_table
+{
+public:
+ static ha_rows get_row_count();
+
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ cursor_by_account(const PFS_engine_table_share *share);
+
+public:
+ ~cursor_by_account()
+ {}
+
+protected:
+ virtual void make_row(PFS_account *account)= 0;
+
+private:
+ /** Current position. */
+ PFS_simple_index m_pos;
+ /** Next position. */
+ PFS_simple_index m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/cursor_by_host.cc b/storage/perfschema/cursor_by_host.cc
new file mode 100644
index 00000000..6aa3423c
--- /dev/null
+++ b/storage/perfschema/cursor_by_host.cc
@@ -0,0 +1,82 @@
+/* Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/cursor_by_host.cc
+ Cursor CURSOR_BY_HOST (implementation).
+*/
+
+#include "my_global.h"
+#include "cursor_by_host.h"
+#include "pfs_buffer_container.h"
+
+ha_rows
+cursor_by_host::get_row_count(void)
+{
+ return global_host_container.get_row_count();
+}
+
+cursor_by_host::cursor_by_host(const PFS_engine_table_share *share)
+ : PFS_engine_table(share, &m_pos),
+ m_pos(0), m_next_pos(0)
+{}
+
+void cursor_by_host::reset_position(void)
+{
+ m_pos.m_index= 0;
+ m_next_pos.m_index= 0;
+}
+
+int cursor_by_host::rnd_next(void)
+{
+ PFS_host *pfs;
+
+ m_pos.set_at(&m_next_pos);
+ PFS_host_iterator it= global_host_container.iterate(m_pos.m_index);
+ pfs= it.scan_next(& m_pos.m_index);
+ if (pfs != NULL)
+ {
+ make_row(pfs);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int
+cursor_by_host::rnd_pos(const void *pos)
+{
+ PFS_host *pfs;
+
+ set_position(pos);
+
+ pfs= global_host_container.get(m_pos.m_index);
+ if (pfs != NULL)
+ {
+ make_row(pfs);
+ return 0;
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
diff --git a/storage/perfschema/cursor_by_host.h b/storage/perfschema/cursor_by_host.h
new file mode 100644
index 00000000..8f256156
--- /dev/null
+++ b/storage/perfschema/cursor_by_host.h
@@ -0,0 +1,68 @@
+/* Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef CURSOR_BY_HOST_H
+#define CURSOR_BY_HOST_H
+
+/**
+ @file storage/perfschema/cursor_by_host.h
+ Cursor CURSOR_BY_HOST (declarations).
+*/
+
+#include "pfs_engine_table.h"
+#include "pfs_host.h"
+#include "table_helper.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/** Cursor CURSOR_BY_HOST. */
+class cursor_by_host : public PFS_engine_table
+{
+public:
+ static ha_rows get_row_count();
+
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ cursor_by_host(const PFS_engine_table_share *share);
+
+public:
+ ~cursor_by_host()
+ {}
+
+protected:
+ virtual void make_row(PFS_host *host)= 0;
+
+private:
+ /** Current position. */
+ PFS_simple_index m_pos;
+ /** Next position. */
+ PFS_simple_index m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/cursor_by_thread.cc b/storage/perfschema/cursor_by_thread.cc
new file mode 100644
index 00000000..5d56794b
--- /dev/null
+++ b/storage/perfschema/cursor_by_thread.cc
@@ -0,0 +1,83 @@
+/* Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/cursor_by_thread.cc
+ Cursor CURSOR_BY_THREAD (implementation).
+*/
+
+#include "my_global.h"
+#include "cursor_by_thread.h"
+#include "pfs_instr.h"
+#include "pfs_buffer_container.h"
+
+ha_rows
+cursor_by_thread::get_row_count(void)
+{
+ return global_thread_container.get_row_count();
+}
+
+cursor_by_thread::cursor_by_thread(const PFS_engine_table_share *share)
+ : PFS_engine_table(share, &m_pos),
+ m_pos(0), m_next_pos(0)
+{}
+
+void cursor_by_thread::reset_position(void)
+{
+ m_pos.m_index= 0;
+ m_next_pos.m_index= 0;
+}
+
+int cursor_by_thread::rnd_next(void)
+{
+ PFS_thread *pfs;
+
+ m_pos.set_at(&m_next_pos);
+ PFS_thread_iterator it= global_thread_container.iterate(m_pos.m_index);
+ pfs= it.scan_next(& m_pos.m_index);
+ if (pfs != NULL)
+ {
+ make_row(pfs);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int
+cursor_by_thread::rnd_pos(const void *pos)
+{
+ PFS_thread *pfs;
+
+ set_position(pos);
+
+ pfs= global_thread_container.get(m_pos.m_index);
+ if (pfs != NULL)
+ {
+ make_row(pfs);
+ return 0;
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
diff --git a/storage/perfschema/cursor_by_thread.h b/storage/perfschema/cursor_by_thread.h
new file mode 100644
index 00000000..1fd803d9
--- /dev/null
+++ b/storage/perfschema/cursor_by_thread.h
@@ -0,0 +1,68 @@
+/* Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef CURSOR_BY_THREAD_H
+#define CURSOR_BY_THREAD_H
+
+/**
+ @file storage/perfschema/cursor_by_thread.h
+ Cursor CURSOR_BY_THREAD (declarations).
+*/
+
+#include "pfs_engine_table.h"
+#include "pfs_instr.h"
+#include "table_helper.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/** Cursor CURSOR_BY_THREAD. */
+class cursor_by_thread : public PFS_engine_table
+{
+public:
+ static ha_rows get_row_count();
+
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ cursor_by_thread(const PFS_engine_table_share *share);
+
+public:
+ ~cursor_by_thread()
+ {}
+
+protected:
+ virtual void make_row(PFS_thread *thread)= 0;
+
+private:
+ /** Current position. */
+ PFS_simple_index m_pos;
+ /** Next position. */
+ PFS_simple_index m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/cursor_by_thread_connect_attr.cc b/storage/perfschema/cursor_by_thread_connect_attr.cc
new file mode 100644
index 00000000..b4462a8d
--- /dev/null
+++ b/storage/perfschema/cursor_by_thread_connect_attr.cc
@@ -0,0 +1,92 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#include "my_global.h"
+#include "cursor_by_thread_connect_attr.h"
+#include "pfs_buffer_container.h"
+
+ha_rows
+cursor_by_thread_connect_attr::get_row_count(void)
+{
+ /*
+ The real number of attributes per thread does not matter,
+ we only need to hint the optimizer there are many per thread,
+ so abusing session_connect_attrs_size_per_thread
+ (which is a number of bytes, not attributes)
+ */
+ return global_thread_container.get_row_count() *
+ session_connect_attrs_size_per_thread;
+}
+
+cursor_by_thread_connect_attr::cursor_by_thread_connect_attr(
+ const PFS_engine_table_share *share) :
+ PFS_engine_table(share, &m_pos), m_row_exists(false)
+{}
+
+int cursor_by_thread_connect_attr::rnd_next(void)
+{
+ PFS_thread *thread;
+ bool has_more_thread= true;
+
+ for (m_pos.set_at(&m_next_pos);
+ has_more_thread;
+ m_pos.next_thread())
+ {
+ thread= global_thread_container.get(m_pos.m_index_1, & has_more_thread);
+ if (thread != NULL)
+ {
+ make_row(thread, m_pos.m_index_2);
+ if (m_row_exists)
+ {
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+
+int cursor_by_thread_connect_attr::rnd_pos(const void *pos)
+{
+ PFS_thread *thread;
+
+ set_position(pos);
+
+ thread= global_thread_container.get(m_pos.m_index_1);
+ if (thread != NULL)
+ {
+ make_row(thread, m_pos.m_index_2);
+ if (m_row_exists)
+ return 0;
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+
+void cursor_by_thread_connect_attr::reset_position(void)
+{
+ m_pos.reset();
+ m_next_pos.reset();
+}
diff --git a/storage/perfschema/cursor_by_thread_connect_attr.h b/storage/perfschema/cursor_by_thread_connect_attr.h
new file mode 100644
index 00000000..7aa31115
--- /dev/null
+++ b/storage/perfschema/cursor_by_thread_connect_attr.h
@@ -0,0 +1,89 @@
+/* Copyright (c) 2012, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef CURSOR_BY_THREAD_CONNECT_ATTR_H
+#define CURSOR_BY_THREAD_CONNECT_ATTR_H
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_instr.h"
+
+/**
+ \addtogroup Performance_schema_tables
+ @{
+*/
+
+/**
+ Position of a cursor on abstract table
+ PERFORMANCE_SCHEMA.SESSION_CONNECT_ATTRS.
+*/
+struct pos_connect_attr_by_thread_by_attr
+: public PFS_double_index
+{
+ pos_connect_attr_by_thread_by_attr()
+ : PFS_double_index(0, 0)
+ {}
+
+ inline void next_thread(void)
+ {
+ m_index_1++;
+ m_index_2= 0;
+ }
+
+ inline void reset(void)
+ {
+ m_index_1= 0;
+ m_index_2= 0;
+ }
+};
+
+/** Cursor CURSOR_BY_THREAD_CONNECT_ATTR. */
+class cursor_by_thread_connect_attr : public PFS_engine_table
+{
+public:
+ static ha_rows get_row_count();
+
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ cursor_by_thread_connect_attr(const PFS_engine_table_share *share);
+
+public:
+ ~cursor_by_thread_connect_attr()
+ {}
+
+protected:
+ virtual void make_row(PFS_thread *thread, uint ordinal)= 0;
+ /** True if row exists */
+ bool m_row_exists;
+
+private:
+ /** Current position. */
+ pos_connect_attr_by_thread_by_attr m_pos;
+ /** Next position. */
+ pos_connect_attr_by_thread_by_attr m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/cursor_by_user.cc b/storage/perfschema/cursor_by_user.cc
new file mode 100644
index 00000000..7699bcf1
--- /dev/null
+++ b/storage/perfschema/cursor_by_user.cc
@@ -0,0 +1,82 @@
+/* Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/cursor_by_user.cc
+ Cursor CURSOR_BY_USER (implementation).
+*/
+
+#include "my_global.h"
+#include "cursor_by_user.h"
+#include "pfs_buffer_container.h"
+
+ha_rows
+cursor_by_user::get_row_count(void)
+{
+ return global_user_container.get_row_count();
+}
+
+cursor_by_user::cursor_by_user(const PFS_engine_table_share *share)
+ : PFS_engine_table(share, &m_pos),
+ m_pos(0), m_next_pos(0)
+{}
+
+void cursor_by_user::reset_position(void)
+{
+ m_pos.m_index= 0;
+ m_next_pos.m_index= 0;
+}
+
+int cursor_by_user::rnd_next(void)
+{
+ PFS_user *pfs;
+
+ m_pos.set_at(&m_next_pos);
+ PFS_user_iterator it= global_user_container.iterate(m_pos.m_index);
+ pfs= it.scan_next(& m_pos.m_index);
+ if (pfs != NULL)
+ {
+ make_row(pfs);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int
+cursor_by_user::rnd_pos(const void *pos)
+{
+ PFS_user *pfs;
+
+ set_position(pos);
+
+ pfs= global_user_container.get(m_pos.m_index);
+ if (pfs != NULL)
+ {
+ make_row(pfs);
+ return 0;
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
diff --git a/storage/perfschema/cursor_by_user.h b/storage/perfschema/cursor_by_user.h
new file mode 100644
index 00000000..d31f8861
--- /dev/null
+++ b/storage/perfschema/cursor_by_user.h
@@ -0,0 +1,68 @@
+/* Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef CURSOR_BY_USER_H
+#define CURSOR_BY_USER_H
+
+/**
+ @file storage/perfschema/cursor_by_user.h
+ Cursor CURSOR_BY_USER (declarations).
+*/
+
+#include "pfs_engine_table.h"
+#include "pfs_user.h"
+#include "table_helper.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/** Cursor CURSOR_BY_USER. */
+class cursor_by_user : public PFS_engine_table
+{
+public:
+ static ha_rows get_row_count();
+
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ cursor_by_user(const PFS_engine_table_share *share);
+
+public:
+ ~cursor_by_user()
+ {}
+
+protected:
+ virtual void make_row(PFS_user *user)= 0;
+
+private:
+ /** Current position. */
+ PFS_simple_index m_pos;
+ /** Next position. */
+ PFS_simple_index m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/ha_perfschema.cc b/storage/perfschema/ha_perfschema.cc
new file mode 100644
index 00000000..da0c2c08
--- /dev/null
+++ b/storage/perfschema/ha_perfschema.cc
@@ -0,0 +1,497 @@
+/* Copyright (c) 2008, 2016, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/ha_perfschema.cc
+ Performance schema storage engine (implementation).
+*/
+
+#include "sql_plugin.h"
+#include "my_pthread.h"
+#include "ha_perfschema.h"
+#include "pfs_engine_table.h"
+#include "pfs_column_values.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "pfs_account.h"
+#include "pfs_host.h"
+#include "pfs_user.h"
+#include "pfs_program.h"
+#include "pfs_prepared_stmt.h"
+#include "pfs_buffer_container.h"
+
+handlerton *pfs_hton= NULL;
+
+#define PFS_ENABLED() (pfs_initialized && (pfs_enabled || m_table_share->m_perpetual))
+
+static handler* pfs_create_handler(handlerton *hton,
+ TABLE_SHARE *table,
+ MEM_ROOT *mem_root)
+{
+ return new (mem_root) ha_perfschema(hton, table);
+}
+
+static int compare_database_names(const char *name1, const char *name2)
+{
+ if (lower_case_table_names)
+ return strcasecmp(name1, name2);
+ return strcmp(name1, name2);
+}
+
+static const PFS_engine_table_share*
+find_table_share(const char *db, const char *name)
+{
+ DBUG_ENTER("find_table_share");
+
+ if (compare_database_names(db, PERFORMANCE_SCHEMA_str.str) != 0)
+ DBUG_RETURN(NULL);
+
+ const PFS_engine_table_share* result;
+ result= PFS_engine_table::find_engine_table_share(name);
+ DBUG_RETURN(result);
+}
+
+static int pfs_discover_table(handlerton *hton, THD *thd, TABLE_SHARE *share)
+{
+ const PFS_engine_table_share *pfs_share;
+
+ if ((pfs_share= find_table_share(share->db.str, share->table_name.str)))
+ return share->init_from_sql_statement_string(thd, false,
+ pfs_share->sql.str,
+ pfs_share->sql.length);
+ return HA_ERR_NO_SUCH_TABLE;
+}
+
+static int pfs_discover_table_existence(handlerton *hton, const char *db,
+ const char *table_name)
+{
+ return MY_TEST(find_table_share(db, table_name));
+}
+
+static int pfs_init_func(void *p)
+{
+ DBUG_ENTER("pfs_init_func");
+
+ pfs_hton= reinterpret_cast<handlerton *> (p);
+
+ pfs_hton->create= pfs_create_handler;
+ pfs_hton->drop_table= [](handlerton *, const char*) { return -1; };
+ pfs_hton->show_status= pfs_show_status;
+ pfs_hton->flags= HTON_ALTER_NOT_SUPPORTED | HTON_TEMPORARY_NOT_SUPPORTED |
+ HTON_NO_PARTITION | HTON_NO_BINLOG_ROW_OPT;
+
+ /*
+ As long as the server implementation keeps using legacy_db_type,
+ as for example in mysql_truncate(),
+ we can not rely on the fact that different mysqld process will assign
+ consistently the same legacy_db_type for a given storage engine name.
+ In particular, using different --loose-skip-xxx options between
+ ./mysqld --bootstrap
+ ./mysqld
+ creates bogus .frm forms when bootstrapping the performance schema,
+ if we rely on ha_initialize_handlerton to assign a really dynamic value.
+ To fix this, a dedicated DB_TYPE is officially assigned to
+ the performance schema. See Bug#43039.
+ */
+ pfs_hton->db_type= DB_TYPE_PERFORMANCE_SCHEMA;
+ pfs_hton->discover_table= pfs_discover_table;
+ pfs_hton->discover_table_existence= pfs_discover_table_existence;
+ pfs_hton->discover_table_names= pfs_discover_table_names;
+
+ PFS_engine_table_share::init_all_locks();
+
+ DBUG_RETURN(0);
+}
+
+static int pfs_done_func(void *p)
+{
+ DBUG_ENTER("pfs_done_func");
+
+ pfs_hton= NULL;
+
+ PFS_engine_table_share::delete_all_locks();
+
+ DBUG_RETURN(0);
+}
+
+static int show_func_mutex_instances_lost(THD *thd, SHOW_VAR *var, char *buff)
+{
+ var->type= SHOW_LONG;
+ var->value= buff;
+ long *value= reinterpret_cast<long*>(buff);
+ *value= global_mutex_container.get_lost_counter();
+ return 0;
+}
+
+static struct st_mysql_show_var pfs_status_vars[]=
+{
+ {"Performance_schema_mutex_classes_lost",
+ (char*) &mutex_class_lost, SHOW_LONG_NOFLUSH},
+ {"Performance_schema_rwlock_classes_lost",
+ (char*) &rwlock_class_lost, SHOW_LONG_NOFLUSH},
+ {"Performance_schema_cond_classes_lost",
+ (char*) &cond_class_lost, SHOW_LONG_NOFLUSH},
+ {"Performance_schema_thread_classes_lost",
+ (char*) &thread_class_lost, SHOW_LONG_NOFLUSH},
+ {"Performance_schema_file_classes_lost",
+ (char*) &file_class_lost, SHOW_LONG_NOFLUSH},
+ {"Performance_schema_socket_classes_lost",
+ (char*) &socket_class_lost, SHOW_LONG_NOFLUSH},
+ {"Performance_schema_memory_classes_lost",
+ (char*) &memory_class_lost, SHOW_LONG_NOFLUSH},
+ {"Performance_schema_mutex_instances_lost",
+ (char*) &show_func_mutex_instances_lost, SHOW_FUNC},
+ {"Performance_schema_rwlock_instances_lost",
+ (char*) &global_rwlock_container.m_lost, SHOW_LONG},
+ {"Performance_schema_cond_instances_lost",
+ (char*) &global_cond_container.m_lost, SHOW_LONG},
+ {"Performance_schema_thread_instances_lost",
+ (char*) &global_thread_container.m_lost, SHOW_LONG},
+ {"Performance_schema_file_instances_lost",
+ (char*) &global_file_container.m_lost, SHOW_LONG},
+ {"Performance_schema_file_handles_lost",
+ (char*) &file_handle_lost, SHOW_LONG},
+ {"Performance_schema_socket_instances_lost",
+ (char*) &global_socket_container.m_lost, SHOW_LONG},
+ {"Performance_schema_locker_lost",
+ (char*) &locker_lost, SHOW_LONG},
+ /* table shares, can be flushed */
+ {"Performance_schema_table_instances_lost",
+ (char*) &global_table_share_container.m_lost, SHOW_LONG},
+ /* table handles, can be flushed */
+ {"Performance_schema_table_handles_lost",
+ (char*) &global_table_container.m_lost, SHOW_LONG},
+ /* table lock stats, can be flushed */
+ {"Performance_schema_table_lock_stat_lost",
+ (char*) &global_table_share_lock_container.m_lost, SHOW_LONG},
+ /* table index stats, can be flushed */
+ {"Performance_schema_index_stat_lost",
+ (char*) &global_table_share_index_container.m_lost, SHOW_LONG},
+ {"Performance_schema_hosts_lost",
+ (char*) &global_host_container.m_lost, SHOW_LONG},
+ {"Performance_schema_users_lost",
+ (char*) &global_user_container.m_lost, SHOW_LONG},
+ {"Performance_schema_accounts_lost",
+ (char*) &global_account_container.m_lost, SHOW_LONG},
+ {"Performance_schema_stage_classes_lost",
+ (char*) &stage_class_lost, SHOW_LONG},
+ {"Performance_schema_statement_classes_lost",
+ (char*) &statement_class_lost, SHOW_LONG},
+ {"Performance_schema_digest_lost",
+ (char*) &digest_lost, SHOW_LONG},
+ {"Performance_schema_session_connect_attrs_lost",
+ (char*) &session_connect_attrs_lost, SHOW_LONG},
+ {"Performance_schema_program_lost",
+ (char*) &global_program_container.m_lost, SHOW_LONG},
+ {"Performance_schema_nested_statement_lost",
+ (char*) &nested_statement_lost, SHOW_LONG},
+ {"Performance_schema_prepared_statements_lost",
+ (char*) &global_prepared_stmt_container.m_lost, SHOW_LONG},
+ {"Performance_schema_metadata_lock_lost",
+ (char*) &global_mdl_container.m_lost, SHOW_LONG},
+ {NullS, NullS, SHOW_LONG}
+};
+
+struct st_mysql_storage_engine pfs_storage_engine=
+{ MYSQL_HANDLERTON_INTERFACE_VERSION };
+
+const char* pfs_engine_name= "PERFORMANCE_SCHEMA";
+
+maria_declare_plugin(perfschema)
+{
+ MYSQL_STORAGE_ENGINE_PLUGIN,
+ &pfs_storage_engine,
+ pfs_engine_name,
+ "Marc Alff, Oracle",
+ "Performance Schema",
+ PLUGIN_LICENSE_GPL,
+ pfs_init_func,
+ pfs_done_func,
+ 0x0001,
+ pfs_status_vars,
+ NULL,
+ "5.7.31",
+ MariaDB_PLUGIN_MATURITY_STABLE
+}
+maria_declare_plugin_end;
+
+ha_perfschema::ha_perfschema(handlerton *hton, TABLE_SHARE *share)
+ : handler(hton, share), m_table_share(NULL), m_table(NULL)
+{}
+
+ha_perfschema::~ha_perfschema()
+{}
+
+int ha_perfschema::open(const char *name, int mode, uint test_if_locked)
+{
+ DBUG_ENTER("ha_perfschema::open");
+
+ m_table_share= find_table_share(table_share->db.str,
+ table_share->table_name.str);
+ if (! m_table_share)
+ DBUG_RETURN(HA_ERR_NO_SUCH_TABLE);
+
+ thr_lock_data_init(m_table_share->m_thr_lock_ptr, &m_thr_lock, NULL);
+ ref_length= m_table_share->m_ref_length;
+
+ DBUG_RETURN(0);
+}
+
+int ha_perfschema::close(void)
+{
+ DBUG_ENTER("ha_perfschema::close");
+ m_table_share= NULL;
+ delete m_table;
+ m_table= NULL;
+
+ DBUG_RETURN(0);
+}
+
+int ha_perfschema::write_row(const uchar *buf)
+{
+ int result;
+
+ DBUG_ENTER("ha_perfschema::write_row");
+ if (!PFS_ENABLED())
+ DBUG_RETURN(HA_ERR_WRONG_COMMAND);
+
+ DBUG_ASSERT(m_table_share);
+ result= m_table_share->write_row(table, buf, table->field);
+ DBUG_RETURN(result);
+}
+
+void ha_perfschema::use_hidden_primary_key(void)
+{
+ /*
+ This is also called in case of row based replication,
+ see TABLE::mark_columns_needed_for_update().
+ Add all columns to the read set, but do not touch the write set,
+ as some columns in the SETUP_ tables are not writable.
+ */
+ table->column_bitmaps_set_no_signal(&table->s->all_set, table->write_set);
+}
+
+int ha_perfschema::update_row(const uchar *old_data, const uchar *new_data)
+{
+ DBUG_ENTER("ha_perfschema::update_row");
+ if (!PFS_ENABLED())
+ DBUG_RETURN(HA_ERR_WRONG_COMMAND);
+
+ if (is_executed_by_slave())
+ DBUG_RETURN(0);
+
+ DBUG_ASSERT(m_table);
+ int result= m_table->update_row(table, old_data, new_data, table->field);
+ DBUG_RETURN(result);
+}
+
+int ha_perfschema::delete_row(const uchar *buf)
+{
+ DBUG_ENTER("ha_perfschema::delete_row");
+ if (!PFS_ENABLED())
+ DBUG_RETURN(HA_ERR_WRONG_COMMAND);
+
+ DBUG_ASSERT(m_table);
+ int result= m_table->delete_row(table, buf, table->field);
+ DBUG_RETURN(result);
+}
+
+int ha_perfschema::rnd_init(bool scan)
+{
+ int result;
+ DBUG_ENTER("ha_perfschema::rnd_init");
+
+ DBUG_ASSERT(m_table_share);
+ DBUG_ASSERT(m_table_share->m_open_table != NULL);
+
+ stats.records= 0;
+ if (m_table == NULL)
+ m_table= m_table_share->m_open_table();
+ else
+ m_table->reset_position();
+
+ if (m_table != NULL)
+ m_table->rnd_init(scan);
+
+ result= m_table ? 0 : HA_ERR_OUT_OF_MEM;
+ DBUG_RETURN(result);
+}
+
+int ha_perfschema::rnd_end(void)
+{
+ DBUG_ENTER("ha_perfschema::rnd_end");
+ DBUG_ASSERT(m_table);
+ delete m_table;
+ m_table= NULL;
+ DBUG_RETURN(0);
+}
+
+int ha_perfschema::rnd_next(uchar *buf)
+{
+ DBUG_ENTER("ha_perfschema::rnd_next");
+ if (!PFS_ENABLED())
+ {
+ table->status= STATUS_NOT_FOUND;
+ DBUG_RETURN(HA_ERR_END_OF_FILE);
+ }
+
+ DBUG_ASSERT(m_table);
+
+ int result= m_table->rnd_next();
+ if (result == 0)
+ {
+ result= m_table->read_row(table, buf, table->field);
+ if (result == 0)
+ stats.records++;
+ }
+ table->status= (result ? STATUS_NOT_FOUND : 0);
+ DBUG_RETURN(result);
+}
+
+void ha_perfschema::position(const uchar *record)
+{
+ DBUG_ENTER("ha_perfschema::position");
+
+ DBUG_ASSERT(m_table);
+ m_table->get_position(ref);
+ DBUG_VOID_RETURN;
+}
+
+int ha_perfschema::rnd_pos(uchar *buf, uchar *pos)
+{
+ DBUG_ENTER("ha_perfschema::rnd_pos");
+ if (!PFS_ENABLED())
+ {
+ table->status= STATUS_NOT_FOUND;
+ DBUG_RETURN(HA_ERR_END_OF_FILE);
+ }
+
+ DBUG_ASSERT(m_table);
+ int result= m_table->rnd_pos(pos);
+ if (result == 0)
+ result= m_table->read_row(table, buf, table->field);
+ table->status= (result ? STATUS_NOT_FOUND : 0);
+ DBUG_RETURN(result);
+}
+
+int ha_perfschema::info(uint flag)
+{
+ DBUG_ENTER("ha_perfschema::info");
+ DBUG_ASSERT(m_table_share);
+ if (flag & HA_STATUS_VARIABLE)
+ stats.records= m_table_share->get_row_count();
+ if (flag & HA_STATUS_CONST)
+ ref_length= m_table_share->m_ref_length;
+ DBUG_RETURN(0);
+}
+
+int ha_perfschema::delete_all_rows(void)
+{
+ int result;
+
+ DBUG_ENTER("ha_perfschema::delete_all_rows");
+ if (!PFS_ENABLED())
+ DBUG_RETURN(0);
+
+ if (is_executed_by_slave())
+ DBUG_RETURN(0);
+
+ DBUG_ASSERT(m_table_share);
+ if (m_table_share->m_delete_all_rows)
+ result= m_table_share->m_delete_all_rows();
+ else
+ {
+ result= HA_ERR_WRONG_COMMAND;
+ }
+ DBUG_RETURN(result);
+}
+
+int ha_perfschema::truncate()
+{
+ return delete_all_rows();
+}
+
+THR_LOCK_DATA **ha_perfschema::store_lock(THD *thd,
+ THR_LOCK_DATA **to,
+ enum thr_lock_type lock_type)
+{
+ if (lock_type != TL_IGNORE && m_thr_lock.type == TL_UNLOCK)
+ m_thr_lock.type= lock_type;
+ *to++= &m_thr_lock;
+ m_thr_lock.m_psi= m_psi;
+ return to;
+}
+
+int ha_perfschema::delete_table(const char *name)
+{
+ DBUG_ENTER("ha_perfschema::delete_table");
+ DBUG_RETURN(0);
+}
+
+int ha_perfschema::rename_table(const char * from, const char * to)
+{
+ DBUG_ENTER("ha_perfschema::rename_table ");
+ DBUG_RETURN(HA_ERR_WRONG_COMMAND);
+}
+
+int ha_perfschema::create(const char *name, TABLE *table_arg,
+ HA_CREATE_INFO *create_info)
+{
+ DBUG_ENTER("ha_perfschema::create");
+ /*
+ This is not a general purpose engine.
+ Failure to CREATE TABLE is the expected result.
+ */
+ DBUG_RETURN(HA_ERR_WRONG_COMMAND);
+}
+
+void ha_perfschema::print_error(int error, myf errflag)
+{
+ switch (error)
+ {
+ case HA_ERR_TABLE_NEEDS_UPGRADE:
+ /*
+ The error message for ER_TABLE_NEEDS_UPGRADE refers to REPAIR table,
+ which does not apply to performance schema tables.
+ */
+ my_error(ER_WRONG_NATIVE_TABLE_STRUCTURE, MYF(0),
+ table_share->db.str, table_share->table_name.str);
+ break;
+ case HA_ERR_WRONG_COMMAND:
+ /*
+ The performance schema is not a general purpose storage engine,
+ some operations are not supported, by design.
+ We do not want to print "Command not supported",
+ which gives the impression that a command implementation is missing,
+ and that the failure should be considered a bug.
+ We print "Invalid performance_schema usage." instead,
+ to emphasise that the operation attempted is not meant to be legal,
+ and that the failure returned is indeed the expected result.
+ */
+ my_error(ER_WRONG_PERFSCHEMA_USAGE, MYF(0));
+ break;
+ default:
+ handler::print_error(error, errflag);
+ break;
+ }
+}
+
diff --git a/storage/perfschema/ha_perfschema.h b/storage/perfschema/ha_perfschema.h
new file mode 100644
index 00000000..690bf8d1
--- /dev/null
+++ b/storage/perfschema/ha_perfschema.h
@@ -0,0 +1,251 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef HA_PERFSCHEMA_H
+#define HA_PERFSCHEMA_H
+
+#include "handler.h" /* class handler */
+#include "table.h"
+#include "sql_class.h"
+
+/**
+ @file storage/perfschema/ha_perfschema.h
+ Performance schema storage engine (declarations).
+
+ @defgroup Performance_schema_engine Performance Schema Engine
+ @ingroup Performance_schema_implementation
+ @{
+*/
+struct PFS_engine_table_share;
+class PFS_engine_table;
+/** Name of the performance schema engine. */
+extern const char *pfs_engine_name;
+
+/** A handler for a PERFORMANCE_SCHEMA table. */
+class ha_perfschema final : public handler
+{
+public:
+ /**
+ Create a new performance schema table handle on a table.
+ @param hton storage engine handler singleton
+ @param share table share
+ */
+ ha_perfschema(handlerton *hton, TABLE_SHARE *share);
+
+ ~ha_perfschema();
+
+ const char *index_type(uint) { return ""; }
+
+ /** Capabilities of the performance schema tables. */
+ ulonglong table_flags(void) const
+ {
+ /*
+ About HA_FAST_KEY_READ:
+
+ The storage engine ::rnd_pos() method is fast to locate records by key,
+ so HA_FAST_KEY_READ is technically true, but the record content can be
+ overwritten between ::rnd_next() and ::rnd_pos(), because all the P_S
+ data is volatile.
+ The HA_FAST_KEY_READ flag is not advertised, to force the optimizer
+ to cache records instead, to provide more consistent records.
+ For example, consider the following statement:
+ - select * from P_S.EVENTS_WAITS_HISTORY_LONG where THREAD_ID=<n>
+ order by ...
+ With HA_FAST_KEY_READ, it can return records where "THREAD_ID=<n>"
+ is false, because the where clause was evaluated to true after
+ ::rnd_pos(), then the content changed, then the record was fetched by
+ key using ::rnd_pos().
+ Without HA_FAST_KEY_READ, the optimizer reads all columns and never
+ calls ::rnd_pos(), so it is guaranteed to return only thread <n>
+ records.
+ */
+ return HA_NO_TRANSACTIONS | HA_REC_NOT_IN_SEQ | HA_NO_AUTO_INCREMENT |
+ HA_PRIMARY_KEY_REQUIRED_FOR_DELETE;
+ }
+
+ /**
+ Operations supported by indexes.
+ None, there are no indexes.
+ */
+ ulong index_flags(uint , uint , bool ) const
+ { return 0; }
+
+ uint max_supported_record_length(void) const
+ { return HA_MAX_REC_LENGTH; }
+
+ uint max_supported_keys(void) const
+ { return 0; }
+
+ uint max_supported_key_parts(void) const
+ { return 0; }
+
+ uint max_supported_key_length(void) const
+ { return 0; }
+
+ ha_rows estimate_rows_upper_bound(void)
+ { return HA_POS_ERROR; }
+
+ double scan_time(void)
+ { return 1.0; }
+
+ /**
+ Open a performance schema table.
+ @param name the table to open
+ @param mode unused
+ @param test_if_locked unused
+ @return 0 on success
+ */
+ int open(const char *name, int mode, uint test_if_locked);
+
+ /**
+ Close a table handle.
+ @sa open.
+ */
+ int close(void);
+
+ /**
+ Write a row.
+ @param buf the row to write
+ @return 0 on success
+ */
+ int write_row(const uchar *buf);
+
+ void use_hidden_primary_key();
+
+ /**
+ Update a row.
+ @param old_data the row old values
+ @param new_data the row new values
+ @return 0 on success
+ */
+ int update_row(const uchar *old_data, const uchar *new_data);
+
+ /**
+ Delete a row.
+ @param buf the row to delete
+ @return 0 on success
+ */
+ int delete_row(const uchar *buf);
+
+ int rnd_init(bool scan);
+
+ /**
+ Scan end.
+ @sa rnd_init.
+ */
+ int rnd_end(void);
+
+ /**
+ Iterator, fetch the next row.
+ @param[out] buf the row fetched.
+ @return 0 on success
+ */
+ int rnd_next(uchar *buf);
+
+ /**
+ Iterator, fetch the row at a given position.
+ @param[out] buf the row fetched.
+ @param pos the row position
+ @return 0 on success
+ */
+ int rnd_pos(uchar *buf, uchar *pos);
+
+ /**
+ Read the row current position.
+ @param record the current row
+ */
+ void position(const uchar *record);
+
+ int info(uint);
+
+ int delete_all_rows(void);
+
+ int truncate();
+
+ int delete_table(const char *from);
+
+ int rename_table(const char * from, const char * to);
+
+ int create(const char *name, TABLE *form,
+ HA_CREATE_INFO *create_info);
+
+ THR_LOCK_DATA **store_lock(THD *thd, THR_LOCK_DATA **to,
+ enum thr_lock_type lock_type);
+
+ virtual uint8 table_cache_type(void)
+ { return HA_CACHE_TBL_NOCACHE; }
+
+ virtual my_bool register_query_cache_table
+ (THD *, const char *, uint , qc_engine_callback *engine_callback,
+ ulonglong *)
+ {
+ *engine_callback= 0;
+ return FALSE;
+ }
+
+ virtual void print_error(int error, myf errflags);
+
+private:
+ /**
+ Check if the caller is a replication thread or the caller is called
+ by a client thread executing base64 encoded BINLOG'... statement.
+
+ In theory, performance schema tables are not supposed to be replicated.
+ This is true and enforced starting with MySQL 5.6.10.
+ In practice, in previous versions such as MySQL 5.5 (GA) or earlier 5.6
+ (non GA) DML on performance schema tables could end up written in the binlog,
+ both in STATEMENT and ROW format.
+ While these records are not supposed to be there, they are found when:
+ - performing replication from a 5.5 master to a 5.6 slave during
+ upgrades
+ - performing replication from 5.5 (performance_schema enabled)
+ to a 5.6 slave
+ - performing point in time recovery in 5.6 with old archived logs.
+
+ This API detects when the code calling the performance schema storage
+ engine is a slave thread or whether the code calling isthe client thread
+ executing a BINLOG'.. statement.
+
+ This API acts as a late filter for the above mentioned cases.
+
+ For ROW format, @see Rows_log_event::do_apply_event()
+
+ */
+ bool is_executed_by_slave() const
+ {
+ DBUG_ASSERT(table != NULL);
+ DBUG_ASSERT(table->in_use != NULL);
+ return table->in_use->slave_thread;
+
+ }
+
+ /** MySQL lock */
+ THR_LOCK_DATA m_thr_lock;
+ /** Performance schema table share for this table handler. */
+ const PFS_engine_table_share *m_table_share;
+ /** Performance schema table cursor. */
+ PFS_engine_table *m_table;
+};
+
+/** @} */
+#endif
+
diff --git a/storage/perfschema/my_thread.h b/storage/perfschema/my_thread.h
new file mode 100644
index 00000000..5ddea9b1
--- /dev/null
+++ b/storage/perfschema/my_thread.h
@@ -0,0 +1,133 @@
+#ifndef STORAGE_PERFSCHEMA_MY_THREAD_INCLUDED
+#define STORAGE_PERFSCHEMA_MY_THREAD_INCLUDED
+
+#include <my_pthread.h>
+#include <m_string.h>
+#include "pfs_config.h"
+
+#ifdef HAVE_SYS_GETTID
+#include <sys/types.h>
+#include <sys/syscall.h>
+#endif
+
+#ifdef HAVE_PTHREAD_GETTHREADID_NP
+#include <pthread_np.h>
+#endif
+
+typedef pthread_key_t thread_local_key_t;
+typedef pthread_t my_thread_handle;
+typedef pthread_attr_t my_thread_attr_t;
+#if defined(HAVE_PTHREAD_THREADID_NP) || defined(HAVE_GETTID) || defined(HAVE_SYS_GETTID) || defined(HAVE_GETTHRID)
+typedef pid_t my_thread_os_id_t;
+#elif defined(_WIN32)
+typedef uint32 my_thread_os_id_t;
+#elif defined(HAVE_PTHREAD_GETTHREADID_NP)
+typedef int my_thread_os_id_t;
+#elif defined(HAVE_INTEGER_PTHREAD_SELF)
+typedef uintptr_t my_thread_os_id_t;
+#else
+typedef unsigned long long my_thread_os_id_t;
+#endif
+
+#define LOCK_plugin_delete LOCK_plugin
+
+static inline int my_create_thread_local_key(thread_local_key_t *key, void (*destructor)(void*))
+{ return pthread_key_create(key, destructor); }
+
+static inline int my_delete_thread_local_key(thread_local_key_t key)
+{ return pthread_key_delete(key); }
+
+static inline void *my_get_thread_local(thread_local_key_t key)
+{ return pthread_getspecific(key); }
+
+static inline int my_set_thread_local(thread_local_key_t key, const void *ptr)
+{ return pthread_setspecific(key, ptr); }
+
+static inline int my_thread_create(my_thread_handle *thread,
+ const my_thread_attr_t *attr, void *(*start_routine)(void *), void *arg)
+{ return pthread_create(thread, attr, start_routine, arg); }
+
+static inline my_thread_os_id_t my_thread_os_id()
+{
+#ifdef HAVE_PTHREAD_THREADID_NP
+ /*
+ macOS.
+
+ Be careful to use this version first, and to not use SYS_gettid on macOS,
+ as SYS_gettid has a different meaning compared to linux gettid().
+ */
+ uint64_t tid64;
+ pthread_threadid_np(nullptr, &tid64);
+ return (pid_t)tid64;
+#else
+#ifdef HAVE_GETTID
+ /* Linux glibc-2.30+ */
+ return gettid();
+#else
+#ifdef HAVE_SYS_GETTID
+ /*
+ Linux before glibc-2.30
+ See man gettid
+ */
+ return syscall(SYS_gettid);
+#else
+#ifdef _WIN32
+ /* Windows */
+ return GetCurrentThreadId();
+#else
+#ifdef HAVE_PTHREAD_GETTHREADID_NP
+ /* FreeBSD 10.2 */
+ return pthread_getthreadid_np();
+#else
+#ifdef HAVE_GETTHRID
+ /* OpenBSD */
+ return getthrid();
+#else
+#ifdef HAVE_INTEGER_PTHREAD_SELF
+ /* NetBSD, and perhaps something else, fallback. */
+ return (my_thread_os_id_t) pthread_self();
+#else
+ /* Feature not available. */
+ return 0;
+#endif /* HAVE_INTEGER_PTHREAD_SELF */
+#endif /* HAVE_GETTHRID */
+#endif /* HAVE_PTHREAD_GETTHREADID_NP */
+#endif /* _WIN32 */
+#endif /* HAVE_SYS_GETTID */
+#endif /* HAVE_GETTID */
+#endif /* HAVE_PTHREAD_THREADID_NP */
+}
+
+#define CHANNEL_NAME_LENGTH MAX_CONNECTION_NAME
+
+enum enum_mysql_show_scope
+{
+ SHOW_SCOPE_UNDEF,
+ SHOW_SCOPE_GLOBAL,
+ SHOW_SCOPE_SESSION,
+ SHOW_SCOPE_ALL
+};
+typedef enum enum_mysql_show_scope SHOW_SCOPE;
+
+#define SHOW_VAR_MAX_NAME_LEN NAME_LEN
+
+static inline char *my_stpnmov(char *dst, const char *src, size_t n)
+{ return strnmov(dst, src, n); }
+
+static inline size_t bin_to_hex_str(char *to, size_t to_len,
+ const char *from, size_t from_len)
+{
+ if (to_len < from_len * 2 + 1)
+ return 0 ;
+ for (size_t i=0; i < from_len; i++, from++)
+ {
+ *to++=_dig_vec_upper[((unsigned char) *from) >> 4];
+ *to++=_dig_vec_upper[((unsigned char) *from) & 0xF];
+ }
+ *to= '\0';
+ return from_len * 2 + 1;
+}
+
+#define thd_get_psi(X) ((X)->get_psi())
+
+#endif
diff --git a/storage/perfschema/mysqld_thd_manager.cc b/storage/perfschema/mysqld_thd_manager.cc
new file mode 100644
index 00000000..61282b7e
--- /dev/null
+++ b/storage/perfschema/mysqld_thd_manager.cc
@@ -0,0 +1,39 @@
+#include "mysqld_thd_manager.h"
+#include "sql_class.h"
+
+static Global_THD_manager manager;
+Global_THD_manager* Global_THD_manager::get_instance()
+{
+ return &manager;
+}
+
+struct find_thd_arg
+{
+ Find_THD_Impl *func;
+ THD *cur;
+};
+
+static my_bool find_thd_cb(THD *tmp, find_thd_arg *arg)
+{
+ arg->cur= tmp;
+ return (*arg->func)(tmp);
+}
+
+THD* Global_THD_manager::find_thd(Find_THD_Impl *func)
+{
+ find_thd_arg arg= {func, NULL};
+ if (THD_list_iterator::iterator()->iterate(find_thd_cb, &arg))
+ return arg.cur;
+ return NULL;
+}
+
+static my_bool do_for_all_cb(THD *tmp, Do_THD_Impl *arg)
+{
+ (*arg)(tmp);
+ return 0;
+}
+
+void Global_THD_manager::do_for_all_thd(Do_THD_Impl *arg)
+{
+ THD_list_iterator::iterator()->iterate(do_for_all_cb, arg);
+}
diff --git a/storage/perfschema/mysqld_thd_manager.h b/storage/perfschema/mysqld_thd_manager.h
new file mode 100644
index 00000000..fbb6f86a
--- /dev/null
+++ b/storage/perfschema/mysqld_thd_manager.h
@@ -0,0 +1,29 @@
+#ifndef STORAGE_PERFSCHEMA_MYSQL_THD_MANAGER_INCLUDED
+#define STORAGE_PERFSCHEMA_MYSQL_THD_MANAGER_INCLUDED
+#include "my_global.h"
+#include "my_thread.h"
+
+class Find_THD_Impl
+{
+ public:
+ virtual ~Find_THD_Impl() {}
+ virtual bool operator()(THD *thd) = 0;
+};
+
+class Do_THD_Impl
+{
+ public:
+ virtual ~Do_THD_Impl() {}
+ virtual void operator()(THD*) = 0;
+};
+
+class Global_THD_manager
+{
+ public:
+ static Global_THD_manager* get_instance();
+ THD* find_thd(Find_THD_Impl *func);
+ void do_for_all_thd(Do_THD_Impl *arg);
+};
+
+ulong get_system_variable_hash_records(void);
+#endif
diff --git a/storage/perfschema/pfs.cc b/storage/perfschema/pfs.cc
new file mode 100644
index 00000000..3e9198a6
--- /dev/null
+++ b/storage/perfschema/pfs.cc
@@ -0,0 +1,7158 @@
+/* Copyright (c) 2008, 2017, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/pfs.cc
+ The performance schema implementation of all instruments.
+*/
+#include "my_global.h"
+#include "thr_lock.h"
+
+/* Make sure exported prototypes match the implementation. */
+#include "pfs_file_provider.h"
+#include "pfs_idle_provider.h"
+#include "pfs_memory_provider.h"
+#include "pfs_metadata_provider.h"
+#include "pfs_socket_provider.h"
+#include "pfs_stage_provider.h"
+#include "pfs_statement_provider.h"
+#include "pfs_table_provider.h"
+#include "pfs_thread_provider.h"
+#include "pfs_transaction_provider.h"
+
+#include "mysql/psi/psi.h"
+#include "mysql/psi/mysql_thread.h"
+#include "my_pthread.h"
+#include "sql_const.h"
+#include "pfs.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "pfs_host.h"
+#include "pfs_user.h"
+#include "pfs_account.h"
+#include "pfs_global.h"
+#include "pfs_column_values.h"
+#include "pfs_timer.h"
+#include "pfs_events_waits.h"
+#include "pfs_events_stages.h"
+#include "pfs_events_statements.h"
+#include "pfs_events_transactions.h"
+#include "pfs_setup_actor.h"
+#include "pfs_setup_object.h"
+#include "sql_error.h"
+#include "sp_head.h"
+#include "mdl.h" /* mdl_key_init */
+#include "pfs_digest.h"
+#include "pfs_program.h"
+#include "pfs_prepared_stmt.h"
+
+using std::min;
+
+/*
+ This is a development tool to investigate memory statistics,
+ do not use in production.
+*/
+#undef PFS_PARANOID
+
+#ifdef PFS_PARANOID
+static void report_memory_accounting_error(
+ const char *api_name,
+ PFS_thread *new_thread,
+ size_t size,
+ PFS_memory_class *klass,
+ PFS_thread *old_thread)
+{
+ pfs_print_error("%s "
+ "thread <%d> of class <%s> "
+ "not owner of <%d> bytes in class <%s> "
+ "allocated by thread <%d> of class <%s>\n",
+ api_name,
+ new_thread->m_thread_internal_id,
+ new_thread->m_class->m_name,
+ size, klass->m_name,
+ old_thread->m_thread_internal_id,
+ old_thread->m_class->m_name);
+
+ DBUG_ASSERT(strcmp(new_thread->m_class->m_name, "thread/sql/event_worker") != 0);
+ DBUG_ASSERT(strcmp(new_thread->m_class->m_name, "thread/sql/event_scheduler") != 0);
+ DBUG_ASSERT(strcmp(new_thread->m_class->m_name, "thread/sql/one_connection") != 0);
+}
+#endif /* PFS_PARANOID */
+
+/**
+ @page PAGE_PERFORMANCE_SCHEMA The Performance Schema main page
+ MySQL PERFORMANCE_SCHEMA implementation.
+
+ @section INTRO Introduction
+ The PERFORMANCE_SCHEMA is a way to introspect the internal execution of
+ the server at runtime.
+ The performance schema focuses primarily on performance data,
+ as opposed to the INFORMATION_SCHEMA whose purpose is to inspect metadata.
+
+ From a user point of view, the performance schema consists of:
+ - a dedicated database schema, named PERFORMANCE_SCHEMA,
+ - SQL tables, used to query the server internal state or change
+ configuration settings.
+
+ From an implementation point of view, the performance schema is a dedicated
+ Storage Engine which exposes data collected by 'Instrumentation Points'
+ placed in the server code.
+
+ @section INTERFACES Multiple interfaces
+
+ The performance schema exposes many different interfaces,
+ for different components, and for different purposes.
+
+ @subsection INT_INSTRUMENTING Instrumenting interface
+
+ All the data representing the server internal state exposed
+ in the performance schema must be first collected:
+ this is the role of the instrumenting interface.
+ The instrumenting interface is a coding interface provided
+ by implementors (of the performance schema) to implementors
+ (of the server or server components).
+
+ This interface is available to:
+ - C implementations
+ - C++ implementations
+ - the core SQL layer (/sql)
+ - the mysys library (/mysys)
+ - MySQL plugins, including storage engines,
+ - third party plugins, including third party storage engines.
+
+ For details, see the @ref PAGE_INSTRUMENTATION_INTERFACE
+ "instrumentation interface page".
+
+ @subsection INT_COMPILING Compiling interface
+
+ The implementation of the performance schema can be enabled or disabled at
+ build time, when building MySQL from the source code.
+
+ When building with the performance schema code, some compilation flags
+ are available to change the default values used in the code, if required.
+
+ For more details, see:
+ @verbatim ./configure --help @endverbatim
+
+ To compile with the performance schema:
+ @verbatim ./configure --with-perfschema @endverbatim
+
+ The implementation of all the compiling options is located in
+ @verbatim ./storage/perfschema/plug.in @endverbatim
+
+ @subsection INT_STARTUP Server startup interface
+
+ The server startup interface consists of the "./mysqld ..."
+ command line used to start the server.
+ When the performance schema is compiled in the server binary,
+ extra command line options are available.
+
+ These extra start options allow the DBA to:
+ - enable or disable the performance schema
+ - specify some sizing parameters.
+
+ To see help for the performance schema startup options, see:
+ @verbatim ./sql/mysqld --verbose --help @endverbatim
+
+ The implementation of all the startup options is located in
+ @verbatim ./sql/mysqld.cc, my_long_options[] @endverbatim
+
+ @subsection INT_BOOTSTRAP Server bootstrap interface
+
+ The bootstrap interface is a private interface exposed by
+ the performance schema, and used by the SQL layer.
+ Its role is to advertise all the SQL tables natively
+ supported by the performance schema to the SQL server.
+ The code consists of creating MySQL tables for the
+ performance schema itself, and is used in './mysql --bootstrap'
+ mode when a server is installed.
+
+ The implementation of the database creation script is located in
+ @verbatim ./scripts/mysql_performance_tables.sql @endverbatim
+
+ @subsection INT_CONFIG Runtime configuration interface
+
+ When the performance schema is used at runtime, various configuration
+ parameters can be used to specify what kind of data is collected,
+ what kind of aggregations are computed, what kind of timers are used,
+ what events are timed, etc.
+
+ For all these capabilities, not a single statement or special syntax
+ was introduced in the parser.
+ Instead of new SQL statements, the interface consists of DML
+ (SELECT, INSERT, UPDATE, DELETE) against special "SETUP" tables.
+
+ For example:
+ @verbatim mysql> update performance_schema.SETUP_INSTRUMENTS
+ set ENABLED='YES', TIMED='YES';
+ Query OK, 234 rows affected (0.00 sec)
+ Rows matched: 234 Changed: 234 Warnings: 0 @endverbatim
+
+ @subsection INT_STATUS Internal audit interface
+
+ The internal audit interface is provided to the DBA to inspect if the
+ performance schema code itself is functioning properly.
+ This interface is necessary because a failure caused while
+ instrumenting code in the server should not cause failures in the
+ MySQL server itself, so that the performance schema implementation
+ never raises errors during runtime execution.
+
+ This auditing interface consists of:
+ @verbatim SHOW ENGINE PERFORMANCE_SCHEMA STATUS; @endverbatim
+ It displays data related to the memory usage of the performance schema,
+ as well as statistics about lost events, if any.
+
+ The SHOW STATUS command is implemented in
+ @verbatim ./storage/perfschema/pfs_engine_table.cc @endverbatim
+
+ @subsection INT_QUERY Query interface
+
+ The query interface is used to query the internal state of a running server.
+ It is provided as SQL tables.
+
+ For example:
+ @verbatim mysql> select * from performance_schema.EVENTS_WAITS_CURRENT;
+ @endverbatim
+
+ @section DESIGN_PRINCIPLES Design principles
+
+ @subsection PRINCIPLE_BEHAVIOR No behavior changes
+
+ The primary goal of the performance schema is to measure (instrument) the
+ execution of the server. A good measure should not cause any change
+ in behavior.
+
+ To achieve this, the overall design of the performance schema complies
+ with the following very severe design constraints:
+
+ The parser is unchanged. There are no new keywords, no new statements.
+ This guarantees that existing applications will run the same way with or
+ without the performance schema.
+
+ All the instrumentation points return "void", there are no error codes.
+ Even if the performance schema internally fails, execution of the server
+ code will proceed.
+
+ None of the instrumentation points allocate memory.
+ All the memory used by the performance schema is pre-allocated at startup,
+ and is considered "static" during the server life time.
+
+ None of the instrumentation points use any pthread_mutex, pthread_rwlock,
+ or pthread_cond (or platform equivalents).
+ Executing the instrumentation point should not cause thread scheduling to
+ change in the server.
+
+ In other words, the implementation of the instrumentation points,
+ including all the code called by the instrumentation points, is:
+ - malloc free
+ - mutex free
+ - rwlock free
+
+ TODO: All the code located in storage/perfschema is malloc free,
+ but unfortunately the usage of LF_HASH introduces some memory allocation.
+ This should be revised if possible, to use a lock-free,
+ malloc-free hash code table.
+
+ @subsection PRINCIPLE_PERFORMANCE No performance hit
+
+ The instrumentation of the server should be as fast as possible.
+ In cases when there are choices between:
+ - doing some processing when recording the performance data
+ in the instrumentation,
+ - doing some processing when retrieving the performance data,
+
+ priority is given in the design to make the instrumentation faster,
+ pushing some complexity to data retrieval.
+
+ As a result, some parts of the design, related to:
+ - the setup code path,
+ - the query code path,
+
+ might appear to be sub-optimal.
+
+ The criterion used here is to optimize primarily the critical path (data
+ collection), possibly at the expense of non-critical code paths.
+
+ @subsection PRINCIPLE_NOT_INTRUSIVE Unintrusive instrumentation
+
+ For the performance schema in general to be successful, the barrier
+ of entry for a developer should be low, so it's easy to instrument code.
+
+ In particular, the instrumentation interface:
+ - is available for C and C++ code (so it's a C interface),
+ - does not require parameters that the calling code can't easily provide,
+ - supports partial instrumentation (for example, instrumenting mutexes does
+ not require that every mutex is instrumented)
+
+ @subsection PRINCIPLE_EXTENDABLE Extendable instrumentation
+
+ As the content of the performance schema improves,
+ with more tables exposed and more data collected,
+ the instrumentation interface will also be augmented
+ to support instrumenting new concepts.
+ Existing instrumentations should not be affected when additional
+ instrumentation is made available, and making a new instrumentation
+ available should not require existing instrumented code to support it.
+
+ @subsection PRINCIPLE_VERSIONED Versioned instrumentation
+
+ Given that the instrumentation offered by the performance schema will
+ be augmented with time, when more features are implemented,
+ the interface itself should be versioned, to keep compatibility
+ with previous instrumented code.
+
+ For example, after both plugin-A and plugin-B have been instrumented for
+ mutexes, read write locks and conditions, using the instrumentation
+ interface, we can anticipate that the instrumentation interface
+ is expanded to support file based operations.
+
+ Plugin-A, a file based storage engine, will most likely use the expanded
+ interface and instrument its file usage, using the version 2
+ interface, while Plugin-B, a network based storage engine, will not change
+ its code and not release a new binary.
+
+ When later the instrumentation interface is expanded to support network
+ based operations (which will define interface version 3), the Plugin-B code
+ can then be changed to make use of it.
+
+ Note, this is just an example to illustrate the design concept here.
+ Both mutexes and file instrumentation are already available
+ since version 1 of the instrumentation interface.
+
+ @subsection PRINCIPLE_DEPLOYMENT Easy deployment
+
+ Internally, we might want every plugin implementation to upgrade the
+ instrumented code to the latest available, but this will cause additional
+ work and this is not practical if the code change is monolithic.
+
+ Externally, for third party plugin implementors, asking implementors to
+ always stay aligned to the latest instrumentation and make new releases,
+ even when the change does not provide new functionality for them,
+ is a bad idea.
+
+ For example, requiring a network based engine to re-release because the
+ instrumentation interface changed for file based operations, will create
+ too many deployment issues.
+
+ So, the performance schema implementation must support concurrently,
+ in the same deployment, multiple versions of the instrumentation
+ interface, and ensure binary compatibility with each version.
+
+ In addition to this, the performance schema can be included or excluded
+ from the server binary, using build time configuration options.
+
+ Regardless, the following types of deployment are valid:
+ - a server supporting the performance schema + a storage engine
+ that is not instrumented
+ - a server not supporting the performance schema + a storage engine
+ that is instrumented
+*/
+
+/**
+ @page PAGE_INSTRUMENTATION_INTERFACE Performance schema: instrumentation interface page.
+ MySQL performance schema instrumentation interface.
+
+ @section INTRO Introduction
+
+ The instrumentation interface consist of two layers:
+ - a raw ABI (Application Binary Interface) layer, that exposes the primitive
+ instrumentation functions exported by the performance schema instrumentation
+ - an API (Application Programing Interface) layer,
+ that provides many helpers for a developer instrumenting some code,
+ to make the instrumentation as easy as possible.
+
+ The ABI layer consists of:
+@code
+#include "mysql/psi/psi.h"
+@endcode
+
+ The API layer consists of:
+@code
+#include "mysql/psi/mutex_mutex.h"
+#include "mysql/psi/mutex_file.h"
+@endcode
+
+ The first helper is for mutexes, rwlocks and conditions,
+ the second for file io.
+
+ The API layer exposes C macros and typedefs which will expand:
+ - either to non-instrumented code, when compiled without the performance
+ schema instrumentation
+ - or to instrumented code, that will issue the raw calls to the ABI layer
+ so that the implementation can collect data.
+
+ Note that all the names introduced (for example, @c mysql_mutex_lock) do not
+ collide with any other namespace.
+ In particular, the macro @c mysql_mutex_lock is on purpose not named
+ @c pthread_mutex_lock.
+ This is to:
+ - avoid overloading @c pthread_mutex_lock with yet another macro,
+ which is dangerous as it can affect user code and pollute
+ the end-user namespace.
+ - allow the developer instrumenting code to selectively instrument
+ some code but not all.
+
+ @section PRINCIPLES Design principles
+
+ The ABI part is designed as a facade, that exposes basic primitives.
+ The expectation is that each primitive will be very stable over time,
+ but the list will constantly grow when more instruments are supported.
+ To support binary compatibility with plugins compiled with a different
+ version of the instrumentation, the ABI itself is versioned
+ (see @c PSI_v1, @c PSI_v2).
+
+ For a given instrumentation point in the API, the basic coding pattern
+ used is:
+ - (a) notify the performance schema of the operation
+ about to be performed.
+ - (b) execute the instrumented code.
+ - (c) notify the performance schema that the operation
+ is completed.
+
+ An opaque "locker" pointer is returned by (a), that is given to (c).
+ This pointer helps the implementation to keep context, for performances.
+
+ The following code fragment is annotated to show how in detail this pattern
+ in implemented, when the instrumentation is compiled in:
+
+@verbatim
+static inline int mysql_mutex_lock(
+ mysql_mutex_t *that, myf flags, const char *src_file, uint src_line)
+{
+ int result;
+ struct PSI_mutex_locker_state state;
+ struct PSI_mutex_locker *locker= NULL;
+
+ ............... (a)
+ locker= PSI_MUTEX_CALL(start_mutex_wait)(&state, that->p_psi, PSI_MUTEX_LOCK,
+ locker, src_file, src_line);
+
+ ............... (b)
+ result= pthread_mutex_lock(&that->m_mutex);
+
+ ............... (c)
+ PSI_MUTEX_CALL(end_mutex_wait)(locker, result);
+
+ return result;
+}
+@endverbatim
+
+ When the performance schema instrumentation is not compiled in,
+ the code becomes simply a wrapper, expanded in line by the compiler:
+
+@verbatim
+static inline int mysql_mutex_lock(...)
+{
+ int result;
+
+ ............... (b)
+ result= pthread_mutex_lock(&that->m_mutex);
+
+ return result;
+}
+@endverbatim
+
+ When the performance schema instrumentation is compiled in,
+ and when the code compiled is internal to the server implementation,
+ PSI_MUTEX_CALL expands directly to functions calls in the performance schema,
+ to make (a) and (c) calls as efficient as possible.
+
+@verbatim
+static inline int mysql_mutex_lock(...)
+{
+ int result;
+ struct PSI_mutex_locker_state state;
+ struct PSI_mutex_locker *locker= NULL;
+
+ ............... (a)
+ locker= pfs_start_mutex_wait_v1(&state, that->p_psi, PSI_MUTEX_LOCK,
+ locker, src_file, src_line);
+
+ ............... (b)
+ result= pthread_mutex_lock(&that->m_mutex);
+
+ ............... (c)
+ pfs_end_mutex_wait_v1(locker, result);
+
+ return result;
+}
+@endverbatim
+
+ When the performance schema instrumentation is compiled in,
+ and when the code compiled is external to the server implementation
+ (typically, a dynamic plugin),
+ PSI_MUTEX_CALL expands to dynamic calls to the underlying implementation,
+ using the PSI_server entry point.
+ This makes (a) and (c) slower, as a function pointer is used instead of a static call,
+ but also independent of the implementation, for binary compatibility.
+
+@verbatim
+static inline int mysql_mutex_lock(...)
+{
+ int result;
+ struct PSI_mutex_locker_state state;
+ struct PSI_mutex_locker *locker= NULL;
+
+ ............... (a)
+ locker= PSI_server->start_mutex_wait(&state, that->p_psi, PSI_MUTEX_LOCK,
+ locker, src_file, src_line);
+
+ ............... (b)
+ result= pthread_mutex_lock(&that->m_mutex);
+
+ ............... (c)
+ PSI_server->end_mutex_wait(locker, result);
+
+ return result;
+}
+@endverbatim
+
+*/
+
+/**
+ @page PAGE_AGGREGATES Performance schema: the aggregates page.
+ Performance schema aggregates.
+
+ @section INTRO Introduction
+
+ Aggregates tables are tables that can be formally defined as
+ SELECT ... from EVENTS_WAITS_HISTORY_INFINITE ... group by 'group clause'.
+
+ Each group clause defines a different kind of aggregate, and corresponds to
+ a different table exposed by the performance schema.
+
+ Aggregates can be either:
+ - computed on the fly,
+ - computed on demand, based on other available data.
+
+ 'EVENTS_WAITS_HISTORY_INFINITE' is a table that does not exist,
+ the best approximation is EVENTS_WAITS_HISTORY_LONG.
+ Aggregates computed on the fly in fact are based on EVENTS_WAITS_CURRENT,
+ while aggregates computed on demand are based on other
+ EVENTS_WAITS_SUMMARY_BY_xxx tables.
+
+ To better understand the implementation itself, a bit of math is
+ required first, to understand the model behind the code:
+ the code is deceptively simple, the real complexity resides
+ in the flyweight of pointers between various performance schema buffers.
+
+ @section DIMENSION Concept of dimension
+
+ An event measured by the instrumentation has many attributes.
+ An event is represented as a data point P(x1, x2, ..., xN),
+ where each x_i coordinate represents a given attribute value.
+
+ Examples of attributes are:
+ - the time waited
+ - the object waited on
+ - the instrument waited on
+ - the thread that waited
+ - the operation performed
+ - per object or per operation additional attributes, such as spins,
+ number of bytes, etc.
+
+ Computing an aggregate per thread is fundamentally different from
+ computing an aggregate by instrument, so the "_BY_THREAD" and
+ "_BY_EVENT_NAME" aggregates are different dimensions,
+ operating on different x_i and x_j coordinates.
+ These aggregates are "orthogonal".
+
+ @section PROJECTION Concept of projection
+
+ A given x_i attribute value can convey either just one basic information,
+ such as a number of bytes, or can convey implied information,
+ such as an object fully qualified name.
+
+ For example, from the value "test.t1", the name of the object schema
+ "test" can be separated from the object name "t1", so that now aggregates
+ by object schema can be implemented.
+
+ In math terms, that corresponds to defining a function:
+ F_i (x): x --> y
+ Applying this function to our point P gives another point P':
+
+ F_i (P):
+ P(x1, x2, ..., x{i-1}, x_i, x{i+1}, ..., x_N)
+ --> P' (x1, x2, ..., x{i-1}, f_i(x_i), x{i+1}, ..., x_N)
+
+ That function defines in fact an aggregate !
+ In SQL terms, this aggregate would look like the following table:
+
+@verbatim
+ CREATE VIEW EVENTS_WAITS_SUMMARY_BY_Func_i AS
+ SELECT col_1, col_2, ..., col_{i-1},
+ Func_i(col_i),
+ COUNT(col_i),
+ MIN(col_i), AVG(col_i), MAX(col_i), -- if col_i is a numeric value
+ col_{i+1}, ..., col_N
+ FROM EVENTS_WAITS_HISTORY_INFINITE
+ group by col_1, col_2, ..., col_{i-1}, col{i+1}, ..., col_N.
+@endverbatim
+
+ Note that not all columns have to be included,
+ in particular some columns that are dependent on the x_i column should
+ be removed, so that in practice, MySQL's aggregation method tends to
+ remove many attributes at each aggregation steps.
+
+ For example, when aggregating wait events by object instances,
+ - the wait_time and number_of_bytes can be summed,
+ and sum(wait_time) now becomes an object instance attribute.
+ - the source, timer_start, timer_end columns are not in the
+ _BY_INSTANCE table, because these attributes are only
+ meaningful for a wait.
+
+ @section COMPOSITION Concept of composition
+
+ Now, the "test.t1" --> "test" example was purely theory,
+ just to explain the concept, and does not lead very far.
+ Let's look at a more interesting example of data that can be derived
+ from the row event.
+
+ An event creates a transient object, PFS_wait_locker, per operation.
+ This object's life cycle is extremely short: it's created just
+ before the start_wait() instrumentation call, and is destroyed in
+ the end_wait() call.
+
+ The wait locker itself contains a pointer to the object instance
+ waited on.
+ That allows to implement a wait_locker --> object instance projection,
+ with m_target.
+ The object instance life cycle depends on _init and _destroy calls
+ from the code, such as mysql_mutex_init()
+ and mysql_mutex_destroy() for a mutex.
+
+ The object instance waited on contains a pointer to the object class,
+ which is represented by the instrument name.
+ That allows to implement an object instance --> object class projection.
+ The object class life cycle is permanent, as instruments are loaded in
+ the server and never removed.
+
+ The object class is named in such a way
+ (for example, "wait/sync/mutex/sql/LOCK_open",
+ "wait/io/file/maria/data_file) that the component ("sql", "maria")
+ that it belongs to can be inferred.
+ That allows to implement an object class --> server component projection.
+
+ Back to math again, we have, for example for mutexes:
+
+ F1 (l) : PFS_wait_locker l --> PFS_mutex m = l->m_target.m_mutex
+
+ F1_to_2 (m) : PFS_mutex m --> PFS_mutex_class i = m->m_class
+
+ F2_to_3 (i) : PFS_mutex_class i --> const char *component =
+ substring(i->m_name, ...)
+
+ Per components aggregates are not implemented, this is just an illustration.
+
+ F1 alone defines this aggregate:
+
+ EVENTS_WAITS_HISTORY_INFINITE --> EVENTS_WAITS_SUMMARY_BY_INSTANCE
+ (or MUTEX_INSTANCE)
+
+ F1_to_2 alone could define this aggregate:
+
+ EVENTS_WAITS_SUMMARY_BY_INSTANCE --> EVENTS_WAITS_SUMMARY_BY_EVENT_NAME
+
+ Alternatively, using function composition, with
+ F2 = F1_to_2 o F1, F2 defines:
+
+ EVENTS_WAITS_HISTORY_INFINITE --> EVENTS_WAITS_SUMMARY_BY_EVENT_NAME
+
+ Likewise, F_2_to_3 defines:
+
+ EVENTS_WAITS_SUMMARY_BY_EVENT_NAME --> EVENTS_WAITS_SUMMARY_BY_COMPONENT
+
+ and F3 = F_2_to_3 o F_1_to_2 o F1 defines:
+
+ EVENTS_WAITS_HISTORY_INFINITE --> EVENTS_WAITS_SUMMARY_BY_COMPONENT
+
+ What has all this to do with the code ?
+
+ Functions (or aggregates) such as F_3 are not implemented as is.
+ Instead, they are decomposed into F_2_to_3 o F_1_to_2 o F1,
+ and each intermediate aggregate is stored into an internal buffer.
+ This allows to support every F1, F2, F3 aggregates from shared
+ internal buffers, where computation already performed to compute F2
+ is reused when computing F3.
+
+ @section OBJECT_GRAPH Object graph
+
+ In terms of object instances, or records, pointers between
+ different buffers define an object instance graph.
+
+ For example, assuming the following scenario:
+ - A mutex class "M" is instrumented, the instrument name
+ is "wait/sync/mutex/sql/M"
+ - This mutex instrument has been instantiated twice,
+ mutex instances are noted M-1 and M-2
+ - Threads T-A and T-B are locking mutex instance M-1
+ - Threads T-C and T-D are locking mutex instance M-2
+
+ The performance schema will record the following data:
+ - EVENTS_WAITS_CURRENT has 4 rows, one for each mutex locker
+ - EVENTS_WAITS_SUMMARY_BY_INSTANCE shows 2 rows, for M-1 and M-2
+ - EVENTS_WAITS_SUMMARY_BY_EVENT_NAME shows 1 row, for M
+
+ The graph of structures will look like:
+
+@verbatim
+ PFS_wait_locker (T-A, M-1) ----------
+ |
+ v
+ PFS_mutex (M-1)
+ - m_wait_stat ------------
+ ^ |
+ | |
+ PFS_wait_locker (T-B, M-1) ---------- |
+ v
+ PFS_mutex_class (M)
+ - m_wait_stat
+ PFS_wait_locker (T-C, M-2) ---------- ^
+ | |
+ v |
+ PFS_mutex (M-2) |
+ - m_wait_stat ------------
+ ^
+ |
+ PFS_wait_locker (T-D, M-2) ----------
+
+ || || ||
+ || || ||
+ vv vv vv
+
+ EVENTS_WAITS_CURRENT ..._SUMMARY_BY_INSTANCE ..._SUMMARY_BY_EVENT_NAME
+@endverbatim
+
+ @section ON_THE_FLY On the fly aggregates
+
+ 'On the fly' aggregates are computed during the code execution.
+ This is necessary because the data the aggregate is based on is volatile,
+ and can not be kept indefinitely.
+
+ With on the fly aggregates:
+ - the writer thread does all the computation
+ - the reader thread accesses the result directly
+
+ This model is to be avoided if possible, due to the overhead
+ caused when instrumenting code.
+
+ @section HIGHER_LEVEL Higher level aggregates
+
+ 'Higher level' aggregates are implemented on demand only.
+ The code executing a SELECT from the aggregate table is
+ collecting data from multiple internal buffers to produce the result.
+
+ With higher level aggregates:
+ - the reader thread does all the computation
+ - the writer thread has no overhead.
+
+ @section MIXED Mixed level aggregates
+
+ The 'Mixed' model is a compromise between 'On the fly' and 'Higher level'
+ aggregates, for internal buffers that are not permanent.
+
+ While an object is present in a buffer, the higher level model is used.
+ When an object is about to be destroyed, statistics are saved into
+ a 'parent' buffer with a longer life cycle, to follow the on the fly model.
+
+ With mixed aggregates:
+ - the reader thread does a lot of complex computation,
+ - the writer thread has minimal overhead, on destroy events.
+
+ @section IMPL_WAIT Implementation for waits aggregates
+
+ For waits, the tables that contains aggregated wait data are:
+ - EVENTS_WAITS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME
+ - EVENTS_WAITS_SUMMARY_BY_HOST_BY_EVENT_NAME
+ - EVENTS_WAITS_SUMMARY_BY_INSTANCE
+ - EVENTS_WAITS_SUMMARY_BY_THREAD_BY_EVENT_NAME
+ - EVENTS_WAITS_SUMMARY_BY_USER_BY_EVENT_NAME
+ - EVENTS_WAITS_SUMMARY_GLOBAL_BY_EVENT_NAME
+ - FILE_SUMMARY_BY_EVENT_NAME
+ - FILE_SUMMARY_BY_INSTANCE
+ - SOCKET_SUMMARY_BY_INSTANCE
+ - SOCKET_SUMMARY_BY_EVENT_NAME
+ - OBJECTS_SUMMARY_GLOBAL_BY_TYPE
+
+ The instrumented code that generates waits events consist of:
+ - mutexes (mysql_mutex_t)
+ - rwlocks (mysql_rwlock_t)
+ - conditions (mysql_cond_t)
+ - file io (MYSQL_FILE)
+ - socket io (MYSQL_SOCKET)
+ - table io
+ - table lock
+ - idle
+
+ The flow of data between aggregates tables varies for each instrumentation.
+
+ @subsection IMPL_WAIT_MUTEX Mutex waits
+
+@verbatim
+ mutex_locker(T, M)
+ |
+ | [1]
+ |
+ |-> pfs_mutex(M) =====>> [B], [C]
+ | |
+ | | [2]
+ | |
+ | |-> pfs_mutex_class(M.class) =====>> [C]
+ |
+ |-> pfs_thread(T).event_name(M) =====>> [A], [D], [E], [F]
+ |
+ | [3]
+ |
+ 3a |-> pfs_account(U, H).event_name(M) =====>> [D], [E], [F]
+ . |
+ . | [4-RESET]
+ . |
+ 3b .....+-> pfs_user(U).event_name(M) =====>> [E]
+ . |
+ 3c .....+-> pfs_host(H).event_name(M) =====>> [F]
+@endverbatim
+
+ How to read this diagram:
+ - events that occur during the instrumented code execution are noted with numbers,
+ as in [1]. Code executed by these events has an impact on overhead.
+ - events that occur during TRUNCATE TABLE operations are noted with numbers,
+ followed by "-RESET", as in [4-RESET].
+ Code executed by these events has no impact on overhead,
+ since they are executed by independent monitoring sessions.
+ - events that occur when a reader extracts data from a performance schema table
+ are noted with letters, as in [A]. The name of the table involved,
+ and the method that builds a row are documented. Code executed by these events
+ has no impact on the instrumentation overhead. Note that the table
+ implementation may pull data from different buffers.
+ - nominal code paths are in plain lines. A "nominal" code path corresponds to
+ cases where the performance schema buffers are sized so that no records are lost.
+ - degenerated code paths are in dotted lines. A "degenerated" code path corresponds
+ to edge cases where parent buffers are full, which forces the code to aggregate to
+ grand parents directly.
+
+ Implemented as:
+ - [1] @c start_mutex_wait_v1(), @c end_mutex_wait_v1()
+ - [2] @c destroy_mutex_v1()
+ - [3] @c aggregate_thread_waits()
+ - [4] @c PFS_account::aggregate_waits()
+ - [A] EVENTS_WAITS_SUMMARY_BY_THREAD_BY_EVENT_NAME,
+ @c table_ews_by_thread_by_event_name::make_row()
+ - [B] EVENTS_WAITS_SUMMARY_BY_INSTANCE,
+ @c table_events_waits_summary_by_instance::make_mutex_row()
+ - [C] EVENTS_WAITS_SUMMARY_GLOBAL_BY_EVENT_NAME,
+ @c table_ews_global_by_event_name::make_mutex_row()
+ - [D] EVENTS_WAITS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME,
+ @c table_ews_by_account_by_event_name::make_row()
+ - [E] EVENTS_WAITS_SUMMARY_BY_USER_BY_EVENT_NAME,
+ @c table_ews_by_user_by_event_name::make_row()
+ - [F] EVENTS_WAITS_SUMMARY_BY_HOST_BY_EVENT_NAME,
+ @c table_ews_by_host_by_event_name::make_row()
+
+ Table EVENTS_WAITS_SUMMARY_BY_INSTANCE is a 'on the fly' aggregate,
+ because the data is collected on the fly by (1) and stored into a buffer,
+ pfs_mutex. The table implementation [B] simply reads the results directly
+ from this buffer.
+
+ Table EVENTS_WAITS_SUMMARY_GLOBAL_BY_EVENT_NAME is a 'mixed' aggregate,
+ because some data is collected on the fly (1),
+ some data is preserved with (2) at a later time in the life cycle,
+ and two different buffers pfs_mutex and pfs_mutex_class are used to store the
+ statistics collected. The table implementation [C] is more complex, since
+ it reads from two buffers pfs_mutex and pfs_mutex_class.
+
+ @subsection IMPL_WAIT_RWLOCK Rwlock waits
+
+@verbatim
+ rwlock_locker(T, R)
+ |
+ | [1]
+ |
+ |-> pfs_rwlock(R) =====>> [B], [C]
+ | |
+ | | [2]
+ | |
+ | |-> pfs_rwlock_class(R.class) =====>> [C]
+ |
+ |-> pfs_thread(T).event_name(R) =====>> [A]
+ |
+ ...
+@endverbatim
+
+ Implemented as:
+ - [1] @c start_rwlock_rdwait_v1(), @c end_rwlock_rdwait_v1(), ...
+ - [2] @c destroy_rwlock_v1()
+ - [A] EVENTS_WAITS_SUMMARY_BY_THREAD_BY_EVENT_NAME,
+ @c table_ews_by_thread_by_event_name::make_row()
+ - [B] EVENTS_WAITS_SUMMARY_BY_INSTANCE,
+ @c table_events_waits_summary_by_instance::make_rwlock_row()
+ - [C] EVENTS_WAITS_SUMMARY_GLOBAL_BY_EVENT_NAME,
+ @c table_ews_global_by_event_name::make_rwlock_row()
+
+ @subsection IMPL_WAIT_COND Cond waits
+
+@verbatim
+ cond_locker(T, C)
+ |
+ | [1]
+ |
+ |-> pfs_cond(C) =====>> [B], [C]
+ | |
+ | | [2]
+ | |
+ | |-> pfs_cond_class(C.class) =====>> [C]
+ |
+ |-> pfs_thread(T).event_name(C) =====>> [A]
+ |
+ ...
+@endverbatim
+
+ Implemented as:
+ - [1] @c start_cond_wait_v1(), @c end_cond_wait_v1()
+ - [2] @c destroy_cond_v1()
+ - [A] EVENTS_WAITS_SUMMARY_BY_THREAD_BY_EVENT_NAME,
+ @c table_ews_by_thread_by_event_name::make_row()
+ - [B] EVENTS_WAITS_SUMMARY_BY_INSTANCE,
+ @c table_events_waits_summary_by_instance::make_cond_row()
+ - [C] EVENTS_WAITS_SUMMARY_GLOBAL_BY_EVENT_NAME,
+ @c table_ews_global_by_event_name::make_cond_row()
+
+ @subsection IMPL_WAIT_FILE File waits
+
+@verbatim
+ file_locker(T, F)
+ |
+ | [1]
+ |
+ |-> pfs_file(F) =====>> [B], [C], [D], [E]
+ | |
+ | | [2]
+ | |
+ | |-> pfs_file_class(F.class) =====>> [C], [D]
+ |
+ |-> pfs_thread(T).event_name(F) =====>> [A]
+ |
+ ...
+@endverbatim
+
+ Implemented as:
+ - [1] @c get_thread_file_name_locker_v1(), @c start_file_wait_v1(),
+ @c end_file_wait_v1(), ...
+ - [2] @c close_file_v1()
+ - [A] EVENTS_WAITS_SUMMARY_BY_THREAD_BY_EVENT_NAME,
+ @c table_ews_by_thread_by_event_name::make_row()
+ - [B] EVENTS_WAITS_SUMMARY_BY_INSTANCE,
+ @c table_events_waits_summary_by_instance::make_file_row()
+ - [C] EVENTS_WAITS_SUMMARY_GLOBAL_BY_EVENT_NAME,
+ @c table_ews_global_by_event_name::make_file_row()
+ - [D] FILE_SUMMARY_BY_EVENT_NAME,
+ @c table_file_summary_by_event_name::make_row()
+ - [E] FILE_SUMMARY_BY_INSTANCE,
+ @c table_file_summary_by_instance::make_row()
+
+ @subsection IMPL_WAIT_SOCKET Socket waits
+
+@verbatim
+ socket_locker(T, S)
+ |
+ | [1]
+ |
+ |-> pfs_socket(S) =====>> [A], [B], [C], [D], [E]
+ |
+ | [2]
+ |
+ |-> pfs_socket_class(S.class) =====>> [C], [D]
+ |
+ |-> pfs_thread(T).event_name(S) =====>> [A]
+ |
+ | [3]
+ |
+ 3a |-> pfs_account(U, H).event_name(S) =====>> [F], [G], [H]
+ . |
+ . | [4-RESET]
+ . |
+ 3b .....+-> pfs_user(U).event_name(S) =====>> [G]
+ . |
+ 3c .....+-> pfs_host(H).event_name(S) =====>> [H]
+@endverbatim
+
+ Implemented as:
+ - [1] @c start_socket_wait_v1(), @c end_socket_wait_v1().
+ - [2] @c close_socket_v1()
+ - [3] @c aggregate_thread_waits()
+ - [4] @c PFS_account::aggregate_waits()
+ - [5] @c PFS_host::aggregate_waits()
+ - [A] EVENTS_WAITS_SUMMARY_BY_THREAD_BY_EVENT_NAME,
+ @c table_ews_by_thread_by_event_name::make_row()
+ - [B] EVENTS_WAITS_SUMMARY_BY_INSTANCE,
+ @c table_events_waits_summary_by_instance::make_socket_row()
+ - [C] EVENTS_WAITS_SUMMARY_GLOBAL_BY_EVENT_NAME,
+ @c table_ews_global_by_event_name::make_socket_row()
+ - [D] SOCKET_SUMMARY_BY_EVENT_NAME,
+ @c table_socket_summary_by_event_name::make_row()
+ - [E] SOCKET_SUMMARY_BY_INSTANCE,
+ @c table_socket_summary_by_instance::make_row()
+ - [F] EVENTS_WAITS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME,
+ @c table_ews_by_account_by_event_name::make_row()
+ - [G] EVENTS_WAITS_SUMMARY_BY_USER_BY_EVENT_NAME,
+ @c table_ews_by_user_by_event_name::make_row()
+ - [H] EVENTS_WAITS_SUMMARY_BY_HOST_BY_EVENT_NAME,
+ @c table_ews_by_host_by_event_name::make_row()
+
+ @subsection IMPL_WAIT_TABLE Table waits
+
+@verbatim
+ table_locker(Thread Th, Table Tb, Event = io or lock)
+ |
+ | [1]
+ |
+1a |-> pfs_table(Tb) =====>> [A], [B], [C]
+ | |
+ | | [2]
+ | |
+ | |-> pfs_table_share(Tb.share) =====>> [B], [C]
+ | |
+ | | [3]
+ | |
+ | |-> global_table_io_stat =====>> [C]
+ | |
+ | |-> global_table_lock_stat =====>> [C]
+ |
+1b |-> pfs_thread(Th).event_name(E) =====>> [D], [E], [F], [G]
+ | |
+ | | [ 4-RESET]
+ | |
+ | |-> pfs_account(U, H).event_name(E) =====>> [E], [F], [G]
+ | . |
+ | . | [5-RESET]
+ | . |
+ | .....+-> pfs_user(U).event_name(E) =====>> [F]
+ | . |
+ | .....+-> pfs_host(H).event_name(E) =====>> [G]
+ |
+1c |-> pfs_thread(Th).waits_current(W) =====>> [H]
+ |
+1d |-> pfs_thread(Th).waits_history(W) =====>> [I]
+ |
+1e |-> waits_history_long(W) =====>> [J]
+@endverbatim
+
+ Implemented as:
+ - [1] @c start_table_io_wait_v1(), @c end_table_io_wait_v1()
+ - [2] @c close_table_v1()
+ - [3] @c drop_table_share_v1()
+ - [4] @c TRUNCATE TABLE EVENTS_WAITS_SUMMARY_BY_THREAD_BY_EVENT_NAME
+ - [5] @c TRUNCATE TABLE EVENTS_WAITS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME
+ - [A] EVENTS_WAITS_SUMMARY_BY_INSTANCE,
+ @c table_events_waits_summary_by_instance::make_table_row()
+ - [B] OBJECTS_SUMMARY_GLOBAL_BY_TYPE,
+ @c table_os_global_by_type::make_row()
+ - [C] EVENTS_WAITS_SUMMARY_GLOBAL_BY_EVENT_NAME,
+ @c table_ews_global_by_event_name::make_table_io_row(),
+ @c table_ews_global_by_event_name::make_table_lock_row()
+ - [D] EVENTS_WAITS_SUMMARY_BY_THREAD_BY_EVENT_NAME,
+ @c table_ews_by_thread_by_event_name::make_row()
+ - [E] EVENTS_WAITS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME,
+ @c table_ews_by_user_by_account_name::make_row()
+ - [F] EVENTS_WAITS_SUMMARY_BY_USER_BY_EVENT_NAME,
+ @c table_ews_by_user_by_event_name::make_row()
+ - [G] EVENTS_WAITS_SUMMARY_BY_HOST_BY_EVENT_NAME,
+ @c table_ews_by_host_by_event_name::make_row()
+ - [H] EVENTS_WAITS_CURRENT,
+ @c table_events_waits_common::make_row()
+ - [I] EVENTS_WAITS_HISTORY,
+ @c table_events_waits_common::make_row()
+ - [J] EVENTS_WAITS_HISTORY_LONG,
+ @c table_events_waits_common::make_row()
+
+ @section IMPL_STAGE Implementation for stages aggregates
+
+ For stages, the tables that contains aggregated data are:
+ - EVENTS_STAGES_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME
+ - EVENTS_STAGES_SUMMARY_BY_HOST_BY_EVENT_NAME
+ - EVENTS_STAGES_SUMMARY_BY_THREAD_BY_EVENT_NAME
+ - EVENTS_STAGES_SUMMARY_BY_USER_BY_EVENT_NAME
+ - EVENTS_STAGES_SUMMARY_GLOBAL_BY_EVENT_NAME
+
+@verbatim
+ start_stage(T, S)
+ |
+ | [1]
+ |
+1a |-> pfs_thread(T).event_name(S) =====>> [A], [B], [C], [D], [E]
+ | |
+ | | [2]
+ | |
+ | 2a |-> pfs_account(U, H).event_name(S) =====>> [B], [C], [D], [E]
+ | . |
+ | . | [3-RESET]
+ | . |
+ | 2b .....+-> pfs_user(U).event_name(S) =====>> [C]
+ | . |
+ | 2c .....+-> pfs_host(H).event_name(S) =====>> [D], [E]
+ | . . |
+ | . . | [4-RESET]
+ | 2d . . |
+1b |----+----+----+-> pfs_stage_class(S) =====>> [E]
+
+@endverbatim
+
+ Implemented as:
+ - [1] @c start_stage_v1()
+ - [2] @c delete_thread_v1(), @c aggregate_thread_stages()
+ - [3] @c PFS_account::aggregate_stages()
+ - [4] @c PFS_host::aggregate_stages()
+ - [A] EVENTS_STAGES_SUMMARY_BY_THREAD_BY_EVENT_NAME,
+ @c table_esgs_by_thread_by_event_name::make_row()
+ - [B] EVENTS_STAGES_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME,
+ @c table_esgs_by_account_by_event_name::make_row()
+ - [C] EVENTS_STAGES_SUMMARY_BY_USER_BY_EVENT_NAME,
+ @c table_esgs_by_user_by_event_name::make_row()
+ - [D] EVENTS_STAGES_SUMMARY_BY_HOST_BY_EVENT_NAME,
+ @c table_esgs_by_host_by_event_name::make_row()
+ - [E] EVENTS_STAGES_SUMMARY_GLOBAL_BY_EVENT_NAME,
+ @c table_esgs_global_by_event_name::make_row()
+
+@section IMPL_STATEMENT Implementation for statements consumers
+
+ For statements, the tables that contains individual event data are:
+ - EVENTS_STATEMENTS_CURRENT
+ - EVENTS_STATEMENTS_HISTORY
+ - EVENTS_STATEMENTS_HISTORY_LONG
+
+ For statements, the tables that contains aggregated data are:
+ - EVENTS_STATEMENTS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME
+ - EVENTS_STATEMENTS_SUMMARY_BY_HOST_BY_EVENT_NAME
+ - EVENTS_STATEMENTS_SUMMARY_BY_THREAD_BY_EVENT_NAME
+ - EVENTS_STATEMENTS_SUMMARY_BY_USER_BY_EVENT_NAME
+ - EVENTS_STATEMENTS_SUMMARY_GLOBAL_BY_EVENT_NAME
+ - EVENTS_STATEMENTS_SUMMARY_BY_DIGEST
+
+@verbatim
+ statement_locker(T, S)
+ |
+ | [1]
+ |
+1a |-> pfs_thread(T).event_name(S) =====>> [A], [B], [C], [D], [E]
+ | |
+ | | [2]
+ | |
+ | 2a |-> pfs_account(U, H).event_name(S) =====>> [B], [C], [D], [E]
+ | . |
+ | . | [3-RESET]
+ | . |
+ | 2b .....+-> pfs_user(U).event_name(S) =====>> [C]
+ | . |
+ | 2c .....+-> pfs_host(H).event_name(S) =====>> [D], [E]
+ | . . |
+ | . . | [4-RESET]
+ | 2d . . |
+1b |----+----+----+-> pfs_statement_class(S) =====>> [E]
+ |
+1c |-> pfs_thread(T).statement_current(S) =====>> [F]
+ |
+1d |-> pfs_thread(T).statement_history(S) =====>> [G]
+ |
+1e |-> statement_history_long(S) =====>> [H]
+ |
+1f |-> statement_digest(S) =====>> [I]
+
+@endverbatim
+
+ Implemented as:
+ - [1] @c start_statement_v1(), end_statement_v1()
+ (1a, 1b) is an aggregation by EVENT_NAME,
+ (1c, 1d, 1e) is an aggregation by TIME,
+ (1f) is an aggregation by DIGEST
+ all of these are orthogonal,
+ and implemented in end_statement_v1().
+ - [2] @c delete_thread_v1(), @c aggregate_thread_statements()
+ - [3] @c PFS_account::aggregate_statements()
+ - [4] @c PFS_host::aggregate_statements()
+ - [A] EVENTS_STATEMENTS_SUMMARY_BY_THREAD_BY_EVENT_NAME,
+ @c table_esms_by_thread_by_event_name::make_row()
+ - [B] EVENTS_STATEMENTS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME,
+ @c table_esms_by_account_by_event_name::make_row()
+ - [C] EVENTS_STATEMENTS_SUMMARY_BY_USER_BY_EVENT_NAME,
+ @c table_esms_by_user_by_event_name::make_row()
+ - [D] EVENTS_STATEMENTS_SUMMARY_BY_HOST_BY_EVENT_NAME,
+ @c table_esms_by_host_by_event_name::make_row()
+ - [E] EVENTS_STATEMENTS_SUMMARY_GLOBAL_BY_EVENT_NAME,
+ @c table_esms_global_by_event_name::make_row()
+ - [F] EVENTS_STATEMENTS_CURRENT,
+ @c table_events_statements_current::rnd_next(),
+ @c table_events_statements_common::make_row()
+ - [G] EVENTS_STATEMENTS_HISTORY,
+ @c table_events_statements_history::rnd_next(),
+ @c table_events_statements_common::make_row()
+ - [H] EVENTS_STATEMENTS_HISTORY_LONG,
+ @c table_events_statements_history_long::rnd_next(),
+ @c table_events_statements_common::make_row()
+ - [I] EVENTS_STATEMENTS_SUMMARY_BY_DIGEST
+ @c table_esms_by_digest::make_row()
+
+@section IMPL_TRANSACTION Implementation for transactions consumers
+
+ For transactions, the tables that contains individual event data are:
+ - EVENTS_TRANSACTIONS_CURRENT
+ - EVENTS_TRANSACTIONS_HISTORY
+ - EVENTS_TRANSACTIONS_HISTORY_LONG
+
+ For transactions, the tables that contains aggregated data are:
+ - EVENTS_TRANSACTIONS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME
+ - EVENTS_TRANSACTIONS_SUMMARY_BY_HOST_BY_EVENT_NAME
+ - EVENTS_TRANSACTIONS_SUMMARY_BY_THREAD_BY_EVENT_NAME
+ - EVENTS_TRANSACTIONS_SUMMARY_BY_USER_BY_EVENT_NAME
+ - EVENTS_TRANSACTIONS_SUMMARY_GLOBAL_BY_EVENT_NAME
+
+@verbatim
+ transaction_locker(T, TX)
+ |
+ | [1]
+ |
+1a |-> pfs_thread(T).event_name(TX) =====>> [A], [B], [C], [D], [E]
+ | |
+ | | [2]
+ | |
+ | 2a |-> pfs_account(U, H).event_name(TX) =====>> [B], [C], [D], [E]
+ | . |
+ | . | [3-RESET]
+ | . |
+ | 2b .....+-> pfs_user(U).event_name(TX) =====>> [C]
+ | . |
+ | 2c .....+-> pfs_host(H).event_name(TX) =====>> [D], [E]
+ | . . |
+ | . . | [4-RESET]
+ | 2d . . |
+1b |----+----+----+-> pfs_transaction_class(TX) =====>> [E]
+ |
+1c |-> pfs_thread(T).transaction_current(TX) =====>> [F]
+ |
+1d |-> pfs_thread(T).transaction_history(TX) =====>> [G]
+ |
+1e |-> transaction_history_long(TX) =====>> [H]
+
+@endverbatim
+
+ Implemented as:
+ - [1] @c start_transaction_v1(), end_transaction_v1()
+ (1a, 1b) is an aggregation by EVENT_NAME,
+ (1c, 1d, 1e) is an aggregation by TIME,
+ all of these are orthogonal,
+ and implemented in end_transaction_v1().
+ - [2] @c delete_thread_v1(), @c aggregate_thread_transactions()
+ - [3] @c PFS_account::aggregate_transactions()
+ - [4] @c PFS_host::aggregate_transactions()
+
+ - [A] EVENTS_TRANSACTIONS_SUMMARY_BY_THREAD_BY_EVENT_NAME,
+ @c table_ets_by_thread_by_event_name::make_row()
+ - [B] EVENTS_TRANSACTIONS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME,
+ @c table_ets_by_account_by_event_name::make_row()
+ - [C] EVENTS_TRANSACTIONS_SUMMARY_BY_USER_BY_EVENT_NAME,
+ @c table_ets_by_user_by_event_name::make_row()
+ - [D] EVENTS_TRANSACTIONS_SUMMARY_BY_HOST_BY_EVENT_NAME,
+ @c table_ets_by_host_by_event_name::make_row()
+ - [E] EVENTS_TRANSACTIONS_SUMMARY_GLOBAL_BY_EVENT_NAME,
+ @c table_ets_global_by_event_name::make_row()
+ - [F] EVENTS_TRANSACTIONS_CURRENT,
+ @c table_events_transactions_current::rnd_next(),
+ @c table_events_transactions_common::make_row()
+ - [G] EVENTS_TRANSACTIONS_HISTORY,
+ @c table_events_transactions_history::rnd_next(),
+ @c table_events_transactions_common::make_row()
+ - [H] EVENTS_TRANSACTIONS_HISTORY_LONG,
+ @c table_events_transactions_history_long::rnd_next(),
+ @c table_events_transactions_common::make_row()
+
+@section IMPL_MEMORY Implementation for memory instruments
+
+ For memory, there are no tables that contains individual event data.
+
+ For memory, the tables that contains aggregated data are:
+ - MEMORY_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME
+ - MEMORY_SUMMARY_BY_HOST_BY_EVENT_NAME
+ - MEMORY_SUMMARY_BY_THREAD_BY_EVENT_NAME
+ - MEMORY_SUMMARY_BY_USER_BY_EVENT_NAME
+ - MEMORY_SUMMARY_GLOBAL_BY_EVENT_NAME
+
+@verbatim
+ memory_event(T, S)
+ |
+ | [1]
+ |
+1a |-> pfs_thread(T).event_name(S) =====>> [A], [B], [C], [D], [E]
+ | |
+ | | [2]
+ | |
+1+ | 2a |-> pfs_account(U, H).event_name(S) =====>> [B], [C], [D], [E]
+ | . |
+ | . | [3-RESET]
+ | . |
+1+ | 2b .....+-> pfs_user(U).event_name(S) =====>> [C]
+ | . |
+1+ | 2c .....+-> pfs_host(H).event_name(S) =====>> [D], [E]
+ | . . |
+ | . . | [4-RESET]
+ | 2d . . |
+1b |----+----+----+-> global.event_name(S) =====>> [E]
+
+@endverbatim
+
+ Implemented as:
+ - [1] @c pfs_memory_alloc_v1(),
+ @c pfs_memory_realloc_v1(),
+ @c pfs_memory_free_v1().
+ - [1+] are overflows that can happen during [1a],
+ implemented with @c carry_memory_stat_delta()
+ - [2] @c delete_thread_v1(), @c aggregate_thread_memory()
+ - [3] @c PFS_account::aggregate_memory()
+ - [4] @c PFS_host::aggregate_memory()
+ - [A] EVENTS_STATEMENTS_SUMMARY_BY_THREAD_BY_EVENT_NAME,
+ @c table_mems_by_thread_by_event_name::make_row()
+ - [B] EVENTS_STATEMENTS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME,
+ @c table_mems_by_account_by_event_name::make_row()
+ - [C] EVENTS_STATEMENTS_SUMMARY_BY_USER_BY_EVENT_NAME,
+ @c table_mems_by_user_by_event_name::make_row()
+ - [D] EVENTS_STATEMENTS_SUMMARY_BY_HOST_BY_EVENT_NAME,
+ @c table_mems_by_host_by_event_name::make_row()
+ - [E] EVENTS_STATEMENTS_SUMMARY_GLOBAL_BY_EVENT_NAME,
+ @c table_mems_global_by_event_name::make_row()
+
+*/
+
+/**
+ @defgroup Performance_schema Performance Schema
+ The performance schema component.
+ For details, see the
+ @ref PAGE_PERFORMANCE_SCHEMA "performance schema main page".
+
+ @defgroup Performance_schema_implementation Performance Schema Implementation
+ @ingroup Performance_schema
+
+ @defgroup Performance_schema_tables Performance Schema Tables
+ @ingroup Performance_schema_implementation
+*/
+
+thread_local_key_t THR_PFS;
+thread_local_key_t THR_PFS_VG; // global_variables
+thread_local_key_t THR_PFS_SV; // session_variables
+thread_local_key_t THR_PFS_VBT; // variables_by_thread
+thread_local_key_t THR_PFS_SG; // global_status
+thread_local_key_t THR_PFS_SS; // session_status
+thread_local_key_t THR_PFS_SBT; // status_by_thread
+thread_local_key_t THR_PFS_SBU; // status_by_user
+thread_local_key_t THR_PFS_SBH; // status_by_host
+thread_local_key_t THR_PFS_SBA; // status_by_account
+
+bool THR_PFS_initialized= false;
+
+static inline PFS_thread*
+my_thread_get_THR_PFS()
+{
+ DBUG_ASSERT(THR_PFS_initialized);
+ PFS_thread *thread= static_cast<PFS_thread*>(my_get_thread_local(THR_PFS));
+ DBUG_ASSERT(thread == NULL || sanitize_thread(thread) != NULL);
+ return thread;
+}
+
+static inline void
+my_thread_set_THR_PFS(PFS_thread *pfs)
+{
+ DBUG_ASSERT(THR_PFS_initialized);
+ my_set_thread_local(THR_PFS, pfs);
+}
+
+/**
+ Conversion map from PSI_mutex_operation to enum_operation_type.
+ Indexed by enum PSI_mutex_operation.
+*/
+static enum_operation_type mutex_operation_map[]=
+{
+ OPERATION_TYPE_LOCK,
+ OPERATION_TYPE_TRYLOCK
+};
+
+/**
+ Conversion map from PSI_rwlock_operation to enum_operation_type.
+ Indexed by enum PSI_rwlock_operation.
+*/
+static enum_operation_type rwlock_operation_map[]=
+{
+ OPERATION_TYPE_READLOCK,
+ OPERATION_TYPE_WRITELOCK,
+ OPERATION_TYPE_TRYREADLOCK,
+ OPERATION_TYPE_TRYWRITELOCK,
+
+ OPERATION_TYPE_SHAREDLOCK,
+ OPERATION_TYPE_SHAREDEXCLUSIVELOCK,
+ OPERATION_TYPE_EXCLUSIVELOCK,
+ OPERATION_TYPE_TRYSHAREDLOCK,
+ OPERATION_TYPE_TRYSHAREDEXCLUSIVELOCK,
+ OPERATION_TYPE_TRYEXCLUSIVELOCK,
+};
+
+/**
+ Conversion map from PSI_cond_operation to enum_operation_type.
+ Indexed by enum PSI_cond_operation.
+*/
+static enum_operation_type cond_operation_map[]=
+{
+ OPERATION_TYPE_WAIT,
+ OPERATION_TYPE_TIMEDWAIT
+};
+
+/**
+ Conversion map from PSI_file_operation to enum_operation_type.
+ Indexed by enum PSI_file_operation.
+*/
+static enum_operation_type file_operation_map[]=
+{
+ OPERATION_TYPE_FILECREATE,
+ OPERATION_TYPE_FILECREATETMP,
+ OPERATION_TYPE_FILEOPEN,
+ OPERATION_TYPE_FILESTREAMOPEN,
+ OPERATION_TYPE_FILECLOSE,
+ OPERATION_TYPE_FILESTREAMCLOSE,
+ OPERATION_TYPE_FILEREAD,
+ OPERATION_TYPE_FILEWRITE,
+ OPERATION_TYPE_FILESEEK,
+ OPERATION_TYPE_FILETELL,
+ OPERATION_TYPE_FILEFLUSH,
+ OPERATION_TYPE_FILESTAT,
+ OPERATION_TYPE_FILEFSTAT,
+ OPERATION_TYPE_FILECHSIZE,
+ OPERATION_TYPE_FILEDELETE,
+ OPERATION_TYPE_FILERENAME,
+ OPERATION_TYPE_FILESYNC
+};
+
+/**
+ Conversion map from PSI_table_operation to enum_operation_type.
+ Indexed by enum PSI_table_io_operation.
+*/
+static enum_operation_type table_io_operation_map[]=
+{
+ OPERATION_TYPE_TABLE_FETCH,
+ OPERATION_TYPE_TABLE_WRITE_ROW,
+ OPERATION_TYPE_TABLE_UPDATE_ROW,
+ OPERATION_TYPE_TABLE_DELETE_ROW
+};
+
+/**
+ Conversion map from enum PFS_TL_LOCK_TYPE to enum_operation_type.
+ Indexed by enum PFS_TL_LOCK_TYPE.
+*/
+static enum_operation_type table_lock_operation_map[]=
+{
+ OPERATION_TYPE_TL_READ_NORMAL, /* PFS_TL_READ */
+ OPERATION_TYPE_TL_READ_WITH_SHARED_LOCKS, /* PFS_TL_READ_WITH_SHARED_LOCKS */
+ OPERATION_TYPE_TL_READ_HIGH_PRIORITY, /* PFS_TL_READ_HIGH_PRIORITY */
+ OPERATION_TYPE_TL_READ_NO_INSERTS, /* PFS_TL_READ_NO_INSERT */
+ OPERATION_TYPE_TL_WRITE_ALLOW_WRITE, /* PFS_TL_WRITE_ALLOW_WRITE */
+ OPERATION_TYPE_TL_WRITE_CONCURRENT_INSERT, /* PFS_TL_WRITE_CONCURRENT_INSERT */
+ OPERATION_TYPE_TL_WRITE_DELAYED, /* PFS_TL_WRITE_DELAYED */
+ OPERATION_TYPE_TL_WRITE_LOW_PRIORITY, /* PFS_TL_WRITE_LOW_PRIORITY */
+ OPERATION_TYPE_TL_WRITE_NORMAL, /* PFS_TL_WRITE */
+ OPERATION_TYPE_TL_READ_EXTERNAL, /* PFS_TL_READ_EXTERNAL */
+ OPERATION_TYPE_TL_WRITE_EXTERNAL /* PFS_TL_WRITE_EXTERNAL */
+};
+
+/**
+ Conversion map from PSI_socket_operation to enum_operation_type.
+ Indexed by enum PSI_socket_operation.
+*/
+static enum_operation_type socket_operation_map[]=
+{
+ OPERATION_TYPE_SOCKETCREATE,
+ OPERATION_TYPE_SOCKETCONNECT,
+ OPERATION_TYPE_SOCKETBIND,
+ OPERATION_TYPE_SOCKETCLOSE,
+ OPERATION_TYPE_SOCKETSEND,
+ OPERATION_TYPE_SOCKETRECV,
+ OPERATION_TYPE_SOCKETSENDTO,
+ OPERATION_TYPE_SOCKETRECVFROM,
+ OPERATION_TYPE_SOCKETSENDMSG,
+ OPERATION_TYPE_SOCKETRECVMSG,
+ OPERATION_TYPE_SOCKETSEEK,
+ OPERATION_TYPE_SOCKETOPT,
+ OPERATION_TYPE_SOCKETSTAT,
+ OPERATION_TYPE_SOCKETSHUTDOWN,
+ OPERATION_TYPE_SOCKETSELECT
+};
+
+/**
+ Build the prefix name of a class of instruments in a category.
+ For example, this function builds the string 'wait/sync/mutex/sql/' from
+ a prefix 'wait/sync/mutex' and a category 'sql'.
+ This prefix is used later to build each instrument name, such as
+ 'wait/sync/mutex/sql/LOCK_open'.
+ @param prefix Prefix for this class of instruments
+ @param category Category name
+ @param [out] output Buffer of length PFS_MAX_INFO_NAME_LENGTH.
+ @param [out] output_length Length of the resulting output string.
+ @return 0 for success, non zero for errors
+*/
+static int build_prefix(const LEX_CSTRING *prefix, const char *category,
+ char *output, size_t *output_length)
+{
+ size_t len= strlen(category);
+ char *out_ptr= output;
+ size_t prefix_length= prefix->length;
+
+ if (unlikely((prefix_length + len + 1) >=
+ PFS_MAX_FULL_PREFIX_NAME_LENGTH))
+ {
+ pfs_print_error("build_prefix: prefix+category is too long <%s> <%s>\n",
+ prefix->str, category);
+ return 1;
+ }
+
+ if (unlikely(strchr(category, '/') != NULL))
+ {
+ pfs_print_error("build_prefix: invalid category <%s>\n",
+ category);
+ return 1;
+ }
+
+ /* output = prefix + category + '/' */
+ memcpy(out_ptr, prefix->str, prefix_length);
+ out_ptr+= prefix_length;
+ if (len > 0)
+ {
+ memcpy(out_ptr, category, len);
+ out_ptr+= len;
+ *out_ptr= '/';
+ out_ptr++;
+ }
+ *output_length= int(out_ptr - output);
+
+ return 0;
+}
+
+#define REGISTER_BODY_V1(KEY_T, PREFIX, REGISTER_FUNC) \
+ KEY_T key; \
+ char formatted_name[PFS_MAX_INFO_NAME_LENGTH]; \
+ size_t prefix_length; \
+ size_t len; \
+ size_t full_length; \
+ \
+ DBUG_ASSERT(category != NULL); \
+ DBUG_ASSERT(info != NULL); \
+ if (unlikely(build_prefix(&PREFIX, category, \
+ formatted_name, &prefix_length)) || \
+ ! pfs_initialized) \
+ { \
+ for (; count>0; count--, info++) \
+ *(info->m_key)= 0; \
+ return ; \
+ } \
+ \
+ for (; count>0; count--, info++) \
+ { \
+ DBUG_ASSERT(info->m_key != NULL); \
+ DBUG_ASSERT(info->m_name != NULL); \
+ len= strlen(info->m_name); \
+ full_length= prefix_length + len; \
+ if (likely(full_length <= PFS_MAX_INFO_NAME_LENGTH)) \
+ { \
+ memcpy(formatted_name + prefix_length, info->m_name, len); \
+ key= REGISTER_FUNC(formatted_name, (uint)full_length, info->m_flags); \
+ } \
+ else \
+ { \
+ pfs_print_error("REGISTER_BODY_V1: name too long <%s> <%s>\n", \
+ category, info->m_name); \
+ key= 0; \
+ } \
+ \
+ *(info->m_key)= key; \
+ } \
+ return;
+
+/* Use C linkage for the interface functions. */
+
+C_MODE_START
+
+/**
+ Implementation of the mutex instrumentation interface.
+ @sa PSI_v1::register_mutex.
+*/
+void pfs_register_mutex_v1(const char *category,
+ PSI_mutex_info_v1 *info,
+ int count)
+{
+ REGISTER_BODY_V1(PSI_mutex_key,
+ mutex_instrument_prefix,
+ register_mutex_class)
+}
+
+/**
+ Implementation of the rwlock instrumentation interface.
+ @sa PSI_v1::register_rwlock.
+*/
+void pfs_register_rwlock_v1(const char *category,
+ PSI_rwlock_info_v1 *info,
+ int count)
+{
+ PSI_rwlock_key key;
+ char rw_formatted_name[PFS_MAX_INFO_NAME_LENGTH];
+ char sx_formatted_name[PFS_MAX_INFO_NAME_LENGTH];
+ size_t rw_prefix_length;
+ size_t sx_prefix_length;
+ size_t len;
+ size_t full_length;
+
+ DBUG_ASSERT(category != NULL);
+ DBUG_ASSERT(info != NULL);
+ if (build_prefix(&rwlock_instrument_prefix, category,
+ rw_formatted_name, &rw_prefix_length) ||
+ build_prefix(&sxlock_instrument_prefix, category,
+ sx_formatted_name, &sx_prefix_length) ||
+ ! pfs_initialized)
+ {
+ for (; count>0; count--, info++)
+ *(info->m_key)= 0;
+ return ;
+ }
+
+ for (; count>0; count--, info++)
+ {
+ DBUG_ASSERT(info->m_key != NULL);
+ DBUG_ASSERT(info->m_name != NULL);
+ len= strlen(info->m_name);
+
+ if (info->m_flags & PSI_RWLOCK_FLAG_SX)
+ {
+ full_length= sx_prefix_length + len;
+ if (likely(full_length <= PFS_MAX_INFO_NAME_LENGTH))
+ {
+ memcpy(sx_formatted_name + sx_prefix_length, info->m_name, len);
+ key= register_rwlock_class(sx_formatted_name, (uint)full_length, info->m_flags);
+ }
+ else
+ {
+ pfs_print_error("REGISTER_BODY_V1: (sx) name too long <%s> <%s>\n",
+ category, info->m_name);
+ key= 0;
+ }
+ }
+ else
+ {
+ full_length= rw_prefix_length + len;
+ if (likely(full_length <= PFS_MAX_INFO_NAME_LENGTH))
+ {
+ memcpy(rw_formatted_name + rw_prefix_length, info->m_name, len);
+ key= register_rwlock_class(rw_formatted_name, (uint)full_length, info->m_flags);
+ }
+ else
+ {
+ pfs_print_error("REGISTER_BODY_V1: (rw) name too long <%s> <%s>\n",
+ category, info->m_name);
+ key= 0;
+ }
+ }
+
+ *(info->m_key)= key;
+ }
+ return;
+}
+
+/**
+ Implementation of the cond instrumentation interface.
+ @sa PSI_v1::register_cond.
+*/
+void pfs_register_cond_v1(const char *category,
+ PSI_cond_info_v1 *info,
+ int count)
+{
+ REGISTER_BODY_V1(PSI_cond_key,
+ cond_instrument_prefix,
+ register_cond_class)
+}
+
+/**
+ Implementation of the thread instrumentation interface.
+ @sa PSI_v1::register_thread.
+*/
+void pfs_register_thread_v1(const char *category,
+ PSI_thread_info_v1 *info,
+ int count)
+{
+ REGISTER_BODY_V1(PSI_thread_key,
+ thread_instrument_prefix,
+ register_thread_class)
+}
+
+/**
+ Implementation of the file instrumentation interface.
+ @sa PSI_v1::register_file.
+*/
+void pfs_register_file_v1(const char *category,
+ PSI_file_info_v1 *info,
+ int count)
+{
+ REGISTER_BODY_V1(PSI_file_key,
+ file_instrument_prefix,
+ register_file_class)
+}
+
+void pfs_register_stage_v1(const char *category,
+ PSI_stage_info_v1 **info_array,
+ int count)
+{
+ char formatted_name[PFS_MAX_INFO_NAME_LENGTH];
+ size_t prefix_length;
+ size_t len;
+ size_t full_length;
+ PSI_stage_info_v1 *info;
+
+ DBUG_ASSERT(category != NULL);
+ DBUG_ASSERT(info_array != NULL);
+ if (unlikely(build_prefix(&stage_instrument_prefix, category,
+ formatted_name, &prefix_length)) ||
+ ! pfs_initialized)
+ {
+ for (; count>0; count--, info_array++)
+ (*info_array)->m_key= 0;
+ return ;
+ }
+
+ for (; count>0; count--, info_array++)
+ {
+ info= *info_array;
+ DBUG_ASSERT(info != NULL);
+ DBUG_ASSERT(info->m_name != NULL);
+ len= (int)strlen(info->m_name);
+ DBUG_ASSERT(len <= 64); // see table_threads.cc near PROCESSLIST_STATE
+ full_length= prefix_length + len;
+ if (likely(full_length <= PFS_MAX_INFO_NAME_LENGTH))
+ {
+ memcpy(formatted_name + prefix_length, info->m_name, len);
+ info->m_key= register_stage_class(formatted_name,
+ (uint)prefix_length,
+ (uint)full_length,
+ info->m_flags);
+ }
+ else
+ {
+ pfs_print_error("register_stage_v1: name too long <%s> <%s>\n",
+ category, info->m_name);
+ info->m_key= 0;
+ }
+ }
+ return;
+}
+
+void pfs_register_statement_v1(const char *category,
+ PSI_statement_info_v1 *info,
+ int count)
+{
+ char formatted_name[PFS_MAX_INFO_NAME_LENGTH];
+ size_t prefix_length;
+ size_t len;
+ size_t full_length;
+
+ DBUG_ASSERT(category != NULL);
+ DBUG_ASSERT(info != NULL);
+ if (unlikely(build_prefix(&statement_instrument_prefix,
+ category, formatted_name, &prefix_length)) ||
+ ! pfs_initialized)
+ {
+ for (; count>0; count--, info++)
+ info->m_key= 0;
+ return ;
+ }
+
+ for (; count>0; count--, info++)
+ {
+ if (info->m_name == NULL)
+ continue;
+
+ len= (int)strlen(info->m_name);
+ full_length= prefix_length + len;
+ if (likely(full_length <= PFS_MAX_INFO_NAME_LENGTH))
+ {
+ memcpy(formatted_name + prefix_length, info->m_name, len);
+ info->m_key= register_statement_class(formatted_name, (uint)full_length, info->m_flags);
+ }
+ else
+ {
+ pfs_print_error("register_statement_v1: name too long <%s>\n",
+ info->m_name);
+ info->m_key= 0;
+ }
+ }
+ return;
+}
+
+void pfs_register_socket_v1(const char *category,
+ PSI_socket_info_v1 *info,
+ int count)
+{
+ REGISTER_BODY_V1(PSI_socket_key,
+ socket_instrument_prefix,
+ register_socket_class)
+}
+
+#define INIT_BODY_V1(T, KEY, ID) \
+ PFS_##T##_class *klass; \
+ PFS_##T *pfs; \
+ klass= find_##T##_class(KEY); \
+ if (unlikely(klass == NULL)) \
+ return NULL; \
+ pfs= create_##T(klass, ID); \
+ return reinterpret_cast<PSI_##T *> (pfs)
+
+/**
+ Implementation of the mutex instrumentation interface.
+ @sa PSI_v1::init_mutex.
+*/
+PSI_mutex*
+pfs_init_mutex_v1(PSI_mutex_key key, const void *identity)
+{
+ INIT_BODY_V1(mutex, key, identity);
+}
+
+/**
+ Implementation of the mutex instrumentation interface.
+ @sa PSI_v1::destroy_mutex.
+*/
+void pfs_destroy_mutex_v1(PSI_mutex* mutex)
+{
+ PFS_mutex *pfs= reinterpret_cast<PFS_mutex*> (mutex);
+
+ DBUG_ASSERT(pfs != NULL);
+
+ destroy_mutex(pfs);
+}
+
+/**
+ Implementation of the rwlock instrumentation interface.
+ @sa PSI_v1::init_rwlock.
+*/
+PSI_rwlock*
+pfs_init_rwlock_v1(PSI_rwlock_key key, const void *identity)
+{
+ INIT_BODY_V1(rwlock, key, identity);
+}
+
+/**
+ Implementation of the rwlock instrumentation interface.
+ @sa PSI_v1::destroy_rwlock.
+*/
+void pfs_destroy_rwlock_v1(PSI_rwlock* rwlock)
+{
+ PFS_rwlock *pfs= reinterpret_cast<PFS_rwlock*> (rwlock);
+
+ DBUG_ASSERT(pfs != NULL);
+
+ destroy_rwlock(pfs);
+}
+
+/**
+ Implementation of the cond instrumentation interface.
+ @sa PSI_v1::init_cond.
+*/
+PSI_cond*
+pfs_init_cond_v1(PSI_cond_key key, const void *identity)
+{
+ INIT_BODY_V1(cond, key, identity);
+}
+
+/**
+ Implementation of the cond instrumentation interface.
+ @sa PSI_v1::destroy_cond.
+*/
+void pfs_destroy_cond_v1(PSI_cond* cond)
+{
+ PFS_cond *pfs= reinterpret_cast<PFS_cond*> (cond);
+
+ DBUG_ASSERT(pfs != NULL);
+
+ destroy_cond(pfs);
+}
+
+/**
+ Implementation of the table instrumentation interface.
+ @sa PSI_v1::get_table_share.
+*/
+PSI_table_share*
+pfs_get_table_share_v1(my_bool temporary, TABLE_SHARE *share)
+{
+ /* Ignore temporary tables and views. */
+ if (temporary || share->is_view)
+ return NULL;
+ /* An instrumented thread is required, for LF_PINS. */
+ PFS_thread *pfs_thread= my_thread_get_THR_PFS();
+ if (unlikely(pfs_thread == NULL))
+ return NULL;
+ PFS_table_share* pfs_share;
+ pfs_share= find_or_create_table_share(pfs_thread, temporary, share);
+ return reinterpret_cast<PSI_table_share*> (pfs_share);
+}
+
+/**
+ Implementation of the table instrumentation interface.
+ @sa PSI_v1::release_table_share.
+*/
+void pfs_release_table_share_v1(PSI_table_share* share)
+{
+ PFS_table_share* pfs= reinterpret_cast<PFS_table_share*> (share);
+
+ if (unlikely(pfs == NULL))
+ return;
+
+ release_table_share(pfs);
+}
+
+/**
+ Implementation of the table instrumentation interface.
+ @sa PSI_v1::drop_table_share.
+*/
+void
+pfs_drop_table_share_v1(my_bool temporary,
+ const char *schema_name, int schema_name_length,
+ const char *table_name, int table_name_length)
+{
+ /* Ignore temporary tables. */
+ if (temporary)
+ return;
+ PFS_thread *pfs_thread= my_thread_get_THR_PFS();
+ if (unlikely(pfs_thread == NULL))
+ return;
+ /* TODO: temporary tables */
+ drop_table_share(pfs_thread, temporary, schema_name, schema_name_length,
+ table_name, table_name_length);
+}
+
+/**
+ Implementation of the table instrumentation interface.
+ @sa PSI_v1::open_table.
+*/
+PSI_table*
+pfs_open_table_v1(PSI_table_share *share, const void *identity)
+{
+ PFS_table_share *pfs_table_share= reinterpret_cast<PFS_table_share*> (share);
+
+ /*
+ When the performance schema is off, do not instrument anything.
+ Table handles have short life cycle, instrumentation will happen
+ again if needed during the next open().
+ */
+ if (psi_unlikely(! flag_global_instrumentation))
+ return NULL;
+
+ if (unlikely(pfs_table_share == NULL))
+ return NULL;
+
+ /* This object is not to be instrumented. */
+ if (! pfs_table_share->m_enabled)
+ return NULL;
+
+ /* This object is instrumented, but all table instruments are disabled. */
+ if (! global_table_io_class.m_enabled && ! global_table_lock_class.m_enabled)
+ return NULL;
+
+ PFS_thread *thread= my_thread_get_THR_PFS();
+
+ if (unlikely(thread == NULL))
+ return NULL;
+
+ PFS_table *pfs_table= create_table(pfs_table_share, thread, identity);
+ return reinterpret_cast<PSI_table *> (pfs_table);
+}
+
+/**
+ Implementation of the table instrumentation interface.
+ @sa PSI_v1::unbind_table.
+*/
+void pfs_unbind_table_v1(PSI_table *table)
+{
+ PFS_table *pfs= reinterpret_cast<PFS_table*> (table);
+ if (likely(pfs != NULL))
+ {
+ pfs->m_thread_owner= NULL;
+ pfs->m_owner_event_id= 0;
+ }
+}
+
+/**
+ Implementation of the table instrumentation interface.
+ @sa PSI_v1::rebind_table.
+*/
+PSI_table *
+pfs_rebind_table_v1(PSI_table_share *share, const void *identity, PSI_table *table)
+{
+ PFS_table *pfs= reinterpret_cast<PFS_table*> (table);
+ if (likely(pfs != NULL))
+ {
+ DBUG_ASSERT(pfs->m_thread_owner == NULL);
+
+ if (unlikely(! pfs->m_share->m_enabled))
+ {
+ destroy_table(pfs);
+ return NULL;
+ }
+
+ if (unlikely(! global_table_io_class.m_enabled && ! global_table_lock_class.m_enabled))
+ {
+ destroy_table(pfs);
+ return NULL;
+ }
+
+ if (psi_unlikely(! flag_global_instrumentation))
+ {
+ destroy_table(pfs);
+ return NULL;
+ }
+
+ /* The table handle was already instrumented, reuse it for this thread. */
+ PFS_thread *thread= my_thread_get_THR_PFS();
+ pfs->m_thread_owner= thread;
+ if (thread != NULL)
+ pfs->m_owner_event_id= thread->m_event_id;
+ else
+ pfs->m_owner_event_id= 0;
+ return table;
+ }
+
+ /* See open_table_v1() */
+
+ PFS_table_share *pfs_table_share= reinterpret_cast<PFS_table_share*> (share);
+
+ if (unlikely(pfs_table_share == NULL))
+ return NULL;
+
+ if (! pfs_table_share->m_enabled)
+ return NULL;
+
+ if (! global_table_io_class.m_enabled && ! global_table_lock_class.m_enabled)
+ return NULL;
+
+ if (! flag_global_instrumentation)
+ return NULL;
+
+ PFS_thread *thread= my_thread_get_THR_PFS();
+ if (unlikely(thread == NULL))
+ return NULL;
+
+ PFS_table *pfs_table= create_table(pfs_table_share, thread, identity);
+ return reinterpret_cast<PSI_table *> (pfs_table);
+}
+
+/**
+ Implementation of the table instrumentation interface.
+ @sa PSI_v1::close_table.
+*/
+void pfs_close_table_v1(TABLE_SHARE *server_share, PSI_table *table)
+{
+ PFS_table *pfs= reinterpret_cast<PFS_table*> (table);
+ if (unlikely(pfs == NULL))
+ return;
+ pfs->aggregate(server_share);
+ destroy_table(pfs);
+}
+
+PSI_socket*
+pfs_init_socket_v1(PSI_socket_key key, const my_socket *fd,
+ const struct sockaddr *addr, socklen_t addr_len)
+{
+ PFS_socket_class *klass;
+ PFS_socket *pfs;
+ klass= find_socket_class(key);
+ if (unlikely(klass == NULL))
+ return NULL;
+ pfs= create_socket(klass, fd, addr, addr_len);
+ return reinterpret_cast<PSI_socket *> (pfs);
+}
+
+void pfs_destroy_socket_v1(PSI_socket *socket)
+{
+ PFS_socket *pfs= reinterpret_cast<PFS_socket*> (socket);
+
+ DBUG_ASSERT(pfs != NULL);
+
+ destroy_socket(pfs);
+}
+
+/**
+ Implementation of the file instrumentation interface.
+ @sa PSI_v1::create_file.
+*/
+void pfs_create_file_v1(PSI_file_key key, const char *name, File file)
+{
+ if (psi_unlikely(! flag_global_instrumentation))
+ return;
+ int index= (int) file;
+ if (unlikely(index < 0))
+ return;
+ PFS_file_class *klass= find_file_class(key);
+ if (unlikely(klass == NULL))
+ return;
+ if (! klass->m_enabled)
+ return;
+
+ /* A thread is needed for LF_PINS */
+ PFS_thread *pfs_thread= my_thread_get_THR_PFS();
+ if (unlikely(pfs_thread == NULL))
+ return;
+
+ if (flag_thread_instrumentation && ! pfs_thread->m_enabled)
+ return;
+
+ /*
+ We want this check after pfs_thread->m_enabled,
+ to avoid reporting false loss.
+ */
+ if (unlikely(index >= file_handle_max))
+ {
+ file_handle_lost++;
+ return;
+ }
+
+ uint len= (uint)strlen(name);
+ PFS_file *pfs_file= find_or_create_file(pfs_thread, klass, name, len, true);
+
+ file_handle_array[index]= pfs_file;
+}
+
+/**
+ Arguments given from a parent to a child thread, packaged in one structure.
+ This data is used when spawning a new instrumented thread.
+ @sa pfs_spawn_thread.
+*/
+struct PFS_spawn_thread_arg
+{
+ ulonglong m_thread_internal_id;
+ char m_username[USERNAME_LENGTH];
+ uint m_username_length;
+ char m_hostname[HOSTNAME_LENGTH];
+ uint m_hostname_length;
+
+ PSI_thread_key m_child_key;
+ const void *m_child_identity;
+ void *(*m_user_start_routine)(void*);
+ void *m_user_arg;
+};
+
+extern "C" void* pfs_spawn_thread(void *arg)
+{
+ PFS_spawn_thread_arg *typed_arg= (PFS_spawn_thread_arg*) arg;
+ void *user_arg;
+ void *(*user_start_routine)(void*);
+
+ PFS_thread *pfs;
+
+ /* First, attach instrumentation to this newly created pthread. */
+ PFS_thread_class *klass= find_thread_class(typed_arg->m_child_key);
+ if (likely(klass != NULL))
+ {
+ pfs= create_thread(klass, typed_arg->m_child_identity, 0);
+ if (likely(pfs != NULL))
+ {
+ clear_thread_account(pfs);
+
+ pfs->m_parent_thread_internal_id= typed_arg->m_thread_internal_id;
+
+ memcpy(pfs->m_username, typed_arg->m_username, sizeof(pfs->m_username));
+ pfs->m_username_length= typed_arg->m_username_length;
+
+ memcpy(pfs->m_hostname, typed_arg->m_hostname, sizeof(pfs->m_hostname));
+ pfs->m_hostname_length= typed_arg->m_hostname_length;
+
+ set_thread_account(pfs);
+ }
+ }
+ else
+ {
+ pfs= NULL;
+ }
+ my_thread_set_THR_PFS(pfs);
+
+ /*
+ Secondly, free the memory allocated in spawn_thread_v1().
+ It is preferable to do this before invoking the user
+ routine, to avoid memory leaks at shutdown, in case
+ the server exits without waiting for this thread.
+ */
+ user_start_routine= typed_arg->m_user_start_routine;
+ user_arg= typed_arg->m_user_arg;
+ my_free(typed_arg);
+
+ /* Then, execute the user code for this thread. */
+ (*user_start_routine)(user_arg);
+
+ return NULL;
+}
+
+/**
+ Implementation of the thread instrumentation interface.
+ @sa PSI_v1::spawn_thread.
+*/
+int pfs_spawn_thread_v1(PSI_thread_key key,
+ my_thread_handle *thread, const my_thread_attr_t *attr,
+ void *(*start_routine)(void*), void *arg)
+{
+ PFS_spawn_thread_arg *psi_arg;
+ PFS_thread *parent;
+
+ /* psi_arg can not be global, and can not be a local variable. */
+ psi_arg= (PFS_spawn_thread_arg*) my_malloc(PSI_NOT_INSTRUMENTED,
+ sizeof(PFS_spawn_thread_arg),
+ MYF(MY_WME));
+ if (unlikely(psi_arg == NULL))
+ return EAGAIN;
+
+ psi_arg->m_child_key= key;
+ psi_arg->m_child_identity= (arg ? arg : thread);
+ psi_arg->m_user_start_routine= start_routine;
+ psi_arg->m_user_arg= arg;
+
+ parent= my_thread_get_THR_PFS();
+ if (parent != NULL)
+ {
+ /*
+ Make a copy of the parent attributes.
+ This is required, because instrumentation for this thread (the parent)
+ may be destroyed before the child thread instrumentation is created.
+ */
+ psi_arg->m_thread_internal_id= parent->m_thread_internal_id;
+
+ memcpy(psi_arg->m_username, parent->m_username, sizeof(psi_arg->m_username));
+ psi_arg->m_username_length= parent->m_username_length;
+
+ memcpy(psi_arg->m_hostname, parent->m_hostname, sizeof(psi_arg->m_hostname));
+ psi_arg->m_hostname_length= parent->m_hostname_length;
+ }
+ else
+ {
+ psi_arg->m_thread_internal_id= 0;
+ psi_arg->m_username_length= 0;
+ psi_arg->m_hostname_length= 0;
+ }
+
+ int result= my_thread_create(thread, attr, pfs_spawn_thread, psi_arg);
+ if (unlikely(result != 0))
+ my_free(psi_arg);
+ return result;
+}
+
+/**
+ Implementation of the thread instrumentation interface.
+ @sa PSI_v1::new_thread.
+*/
+PSI_thread*
+pfs_new_thread_v1(PSI_thread_key key, const void *identity, ulonglong processlist_id)
+{
+ PFS_thread *pfs;
+
+ PFS_thread_class *klass= find_thread_class(key);
+ if (likely(klass != NULL))
+ {
+ pfs= create_thread(klass, identity, processlist_id);
+ if (pfs != NULL)
+ {
+ PFS_thread *parent= my_thread_get_THR_PFS();
+ if (parent != NULL)
+ pfs->m_parent_thread_internal_id= parent->m_parent_thread_internal_id;
+ }
+ }
+ else
+ pfs= NULL;
+
+ return reinterpret_cast<PSI_thread*> (pfs);
+}
+
+/**
+ Implementation of the thread instrumentation interface.
+ @sa PSI_v1::set_thread_id.
+*/
+void pfs_set_thread_id_v1(PSI_thread *thread, ulonglong processlist_id)
+{
+ PFS_thread *pfs= reinterpret_cast<PFS_thread*> (thread);
+ if (unlikely(pfs == NULL))
+ return;
+ pfs->m_processlist_id= (ulong)processlist_id;
+}
+
+/**
+ Implementation of the thread instrumentation interface.
+ @sa PSI_v1::set_thread_THD.
+*/
+void pfs_set_thread_THD_v1(PSI_thread *thread, THD *thd)
+{
+ PFS_thread *pfs= reinterpret_cast<PFS_thread*> (thread);
+ if (unlikely(pfs == NULL))
+ return;
+ pfs->m_thd= thd;
+}
+
+/**
+ Implementation of the thread instrumentation interface.
+ @sa PSI_v1::set_thread_os_thread_id.
+*/
+void pfs_set_thread_os_id_v1(PSI_thread *thread)
+{
+ PFS_thread *pfs= reinterpret_cast<PFS_thread*> (thread);
+ if (unlikely(pfs == NULL))
+ return;
+ pfs->m_thread_os_id= my_thread_os_id();
+}
+
+/**
+ Implementation of the thread instrumentation interface.
+ @sa PSI_v1::get_thread_id.
+*/
+PSI_thread*
+pfs_get_thread_v1(void)
+{
+ PFS_thread *pfs= my_thread_get_THR_PFS();
+ return reinterpret_cast<PSI_thread*> (pfs);
+}
+
+/**
+ Implementation of the thread instrumentation interface.
+ @sa PSI_v1::set_thread_user.
+*/
+void pfs_set_thread_user_v1(const char *user, int user_len)
+{
+ pfs_dirty_state dirty_state;
+ PFS_thread *pfs= my_thread_get_THR_PFS();
+
+ DBUG_ASSERT((user != NULL) || (user_len == 0));
+ DBUG_ASSERT(user_len >= 0);
+ DBUG_ASSERT((uint) user_len <= sizeof(pfs->m_username));
+
+ if (unlikely(pfs == NULL))
+ return;
+
+ aggregate_thread(pfs, pfs->m_account, pfs->m_user, pfs->m_host);
+
+ pfs->m_session_lock.allocated_to_dirty(& dirty_state);
+
+ clear_thread_account(pfs);
+
+ if (user_len > 0)
+ memcpy(pfs->m_username, user, user_len);
+ pfs->m_username_length= user_len;
+
+ set_thread_account(pfs);
+
+ bool enabled;
+ bool history;
+ if (pfs->m_account != NULL)
+ {
+ enabled= pfs->m_account->m_enabled;
+ history= pfs->m_account->m_history;
+ }
+ else
+ {
+ if ((pfs->m_username_length > 0) && (pfs->m_hostname_length > 0))
+ {
+ lookup_setup_actor(pfs,
+ pfs->m_username, pfs->m_username_length,
+ pfs->m_hostname, pfs->m_hostname_length,
+ &enabled, &history);
+ }
+ else
+ {
+ /* There is no setting for background threads */
+ enabled= true;
+ history= true;
+ }
+ }
+ pfs->set_enabled(enabled);
+ pfs->set_history(history);
+
+ pfs->m_session_lock.dirty_to_allocated(& dirty_state);
+}
+
+/**
+ Implementation of the thread instrumentation interface.
+ @sa PSI_v1::set_thread_account.
+*/
+void pfs_set_thread_account_v1(const char *user, int user_len,
+ const char *host, int host_len)
+{
+ pfs_dirty_state dirty_state;
+ PFS_thread *pfs= my_thread_get_THR_PFS();
+
+ DBUG_ASSERT((user != NULL) || (user_len == 0));
+ DBUG_ASSERT(user_len >= 0);
+ DBUG_ASSERT((uint) user_len <= sizeof(pfs->m_username));
+ DBUG_ASSERT((host != NULL) || (host_len == 0));
+ DBUG_ASSERT(host_len >= 0);
+
+ host_len= MY_MIN(host_len, static_cast<int>(sizeof(pfs->m_hostname)));
+
+ if (unlikely(pfs == NULL))
+ return;
+
+ pfs->m_session_lock.allocated_to_dirty(& dirty_state);
+
+ clear_thread_account(pfs);
+
+ if (host_len > 0)
+ memcpy(pfs->m_hostname, host, host_len);
+ pfs->m_hostname_length= host_len;
+
+ if (user_len > 0)
+ memcpy(pfs->m_username, user, user_len);
+ pfs->m_username_length= user_len;
+
+ set_thread_account(pfs);
+
+ bool enabled;
+ bool history;
+ if (pfs->m_account != NULL)
+ {
+ enabled= pfs->m_account->m_enabled;
+ history= pfs->m_account->m_history;
+ }
+ else
+ {
+ if ((pfs->m_username_length > 0) && (pfs->m_hostname_length > 0))
+ {
+ lookup_setup_actor(pfs,
+ pfs->m_username, pfs->m_username_length,
+ pfs->m_hostname, pfs->m_hostname_length,
+ &enabled, &history);
+ }
+ else
+ {
+ /* There is no setting for background threads */
+ enabled= true;
+ history= true;
+ }
+ }
+ pfs->set_enabled(enabled);
+ pfs->set_history(history);
+
+ pfs->m_session_lock.dirty_to_allocated(& dirty_state);
+}
+
+/**
+ Implementation of the thread instrumentation interface.
+ @sa PSI_v1::set_thread_db.
+*/
+void pfs_set_thread_db_v1(const char* db, int db_len)
+{
+ PFS_thread *pfs= my_thread_get_THR_PFS();
+
+ DBUG_ASSERT((db != NULL) || (db_len == 0));
+ DBUG_ASSERT(db_len >= 0);
+ DBUG_ASSERT((uint) db_len <= sizeof(pfs->m_dbname));
+
+ if (likely(pfs != NULL))
+ {
+ pfs_dirty_state dirty_state;
+ pfs->m_stmt_lock.allocated_to_dirty(& dirty_state);
+ if (db_len > 0)
+ memcpy(pfs->m_dbname, db, db_len);
+ pfs->m_dbname_length= db_len;
+ pfs->m_stmt_lock.dirty_to_allocated(& dirty_state);
+ }
+}
+
+/**
+ Implementation of the thread instrumentation interface.
+ @sa PSI_v1::set_thread_command.
+*/
+void pfs_set_thread_command_v1(int command)
+{
+ PFS_thread *pfs= my_thread_get_THR_PFS();
+
+ DBUG_ASSERT(command >= 0);
+ DBUG_ASSERT(command <= (int) COM_END);
+
+ if (likely(pfs != NULL))
+ {
+ pfs->m_command= command;
+ }
+}
+
+/**
+Implementation of the thread instrumentation interface.
+@sa PSI_v1::set_thread_connection_type.
+*/
+void pfs_set_connection_type_v1(opaque_vio_type conn_type)
+{
+ PFS_thread *pfs= my_thread_get_THR_PFS();
+
+ if (likely(pfs != NULL))
+ {
+ pfs->m_connection_type= static_cast<enum_vio_type> (conn_type);
+ }
+}
+
+
+/**
+ Implementation of the thread instrumentation interface.
+ @sa PSI_v1::set_thread_start_time.
+*/
+void pfs_set_thread_start_time_v1(time_t start_time)
+{
+ PFS_thread *pfs= my_thread_get_THR_PFS();
+
+ if (likely(pfs != NULL))
+ {
+ pfs->m_start_time= start_time;
+ }
+}
+
+/**
+ Implementation of the thread instrumentation interface.
+ @sa PSI_v1::set_thread_state.
+*/
+void pfs_set_thread_state_v1(const char* state)
+{
+ /* DEPRECATED. */
+}
+
+/**
+ Implementation of the thread instrumentation interface.
+ @sa PSI_v1::set_thread_info.
+*/
+void pfs_set_thread_info_v1(const char* info, uint info_len)
+{
+ pfs_dirty_state dirty_state;
+ PFS_thread *pfs= my_thread_get_THR_PFS();
+
+ DBUG_ASSERT((info != NULL) || (info_len == 0));
+
+ if (likely(pfs != NULL))
+ {
+ if ((info != NULL) && (info_len > 0))
+ {
+ if (info_len > sizeof(pfs->m_processlist_info))
+ info_len= sizeof(pfs->m_processlist_info);
+
+ pfs->m_stmt_lock.allocated_to_dirty(& dirty_state);
+ memcpy(pfs->m_processlist_info, info, info_len);
+ pfs->m_processlist_info_length= info_len;
+ pfs->m_stmt_lock.dirty_to_allocated(& dirty_state);
+ }
+ else
+ {
+ pfs->m_stmt_lock.allocated_to_dirty(& dirty_state);
+ pfs->m_processlist_info_length= 0;
+ pfs->m_stmt_lock.dirty_to_allocated(& dirty_state);
+ }
+ }
+}
+
+/**
+ Implementation of the thread instrumentation interface.
+ @sa PSI_v1::set_thread.
+*/
+void pfs_set_thread_v1(PSI_thread* thread)
+{
+ PFS_thread *pfs= reinterpret_cast<PFS_thread*> (thread);
+ my_thread_set_THR_PFS(pfs);
+}
+
+/**
+ Implementation of the thread instrumentation interface.
+ @sa PSI_v1::delete_current_thread.
+*/
+void pfs_delete_current_thread_v1(void)
+{
+ PFS_thread *thread= my_thread_get_THR_PFS();
+ if (thread != NULL)
+ {
+ aggregate_thread(thread, thread->m_account, thread->m_user, thread->m_host);
+ my_thread_set_THR_PFS(NULL);
+ destroy_thread(thread);
+ }
+}
+
+/**
+ Implementation of the thread instrumentation interface.
+ @sa PSI_v1::delete_thread.
+*/
+void pfs_delete_thread_v1(PSI_thread *thread)
+{
+ PFS_thread *pfs= reinterpret_cast<PFS_thread*> (thread);
+
+ if (pfs != NULL)
+ {
+ aggregate_thread(pfs, pfs->m_account, pfs->m_user, pfs->m_host);
+ destroy_thread(pfs);
+ }
+}
+
+/**
+ Implementation of the mutex instrumentation interface.
+ @sa PSI_v1::start_mutex_wait.
+*/
+PSI_mutex_locker*
+pfs_start_mutex_wait_v1(PSI_mutex_locker_state *state,
+ PSI_mutex *mutex, PSI_mutex_operation op,
+ const char *src_file, uint src_line)
+{
+ PFS_mutex *pfs_mutex= reinterpret_cast<PFS_mutex*> (mutex);
+ DBUG_ASSERT((int) op >= 0);
+ DBUG_ASSERT((uint) op < array_elements(mutex_operation_map));
+ DBUG_ASSERT(state != NULL);
+
+ DBUG_ASSERT(pfs_mutex != NULL);
+ DBUG_ASSERT(pfs_mutex->m_class != NULL);
+
+ if (! pfs_mutex->m_enabled)
+ return NULL;
+
+ uint flags;
+ ulonglong timer_start= 0;
+
+ if (flag_thread_instrumentation)
+ {
+ PFS_thread *pfs_thread= my_thread_get_THR_PFS();
+ if (unlikely(pfs_thread == NULL))
+ return NULL;
+ if (! pfs_thread->m_enabled)
+ return NULL;
+ state->m_thread= reinterpret_cast<PSI_thread *> (pfs_thread);
+ flags= STATE_FLAG_THREAD;
+
+ if (pfs_mutex->m_timed)
+ {
+ timer_start= get_timer_raw_value_and_function(wait_timer, & state->m_timer);
+ state->m_timer_start= timer_start;
+ flags|= STATE_FLAG_TIMED;
+ }
+
+ if (flag_events_waits_current)
+ {
+ if (unlikely(pfs_thread->m_events_waits_current >=
+ & pfs_thread->m_events_waits_stack[WAIT_STACK_SIZE]))
+ {
+ locker_lost++;
+ return NULL;
+ }
+ PFS_events_waits *wait= pfs_thread->m_events_waits_current;
+ state->m_wait= wait;
+ flags|= STATE_FLAG_EVENT;
+
+ PFS_events_waits *parent_event= wait - 1;
+ wait->m_event_type= EVENT_TYPE_WAIT;
+ wait->m_nesting_event_id= parent_event->m_event_id;
+ wait->m_nesting_event_type= parent_event->m_event_type;
+
+ wait->m_thread_internal_id= pfs_thread->m_thread_internal_id;
+ wait->m_class= pfs_mutex->m_class;
+ wait->m_timer_start= timer_start;
+ wait->m_timer_end= 0;
+ wait->m_object_instance_addr= pfs_mutex->m_identity;
+ wait->m_event_id= pfs_thread->m_event_id++;
+ wait->m_end_event_id= 0;
+ wait->m_operation= mutex_operation_map[(int) op];
+ wait->m_source_file= src_file;
+ wait->m_source_line= src_line;
+ wait->m_wait_class= WAIT_CLASS_MUTEX;
+
+ pfs_thread->m_events_waits_current++;
+ }
+ }
+ else
+ {
+ if (pfs_mutex->m_timed)
+ {
+ timer_start= get_timer_raw_value_and_function(wait_timer, & state->m_timer);
+ state->m_timer_start= timer_start;
+ flags= STATE_FLAG_TIMED;
+ state->m_thread= NULL;
+ }
+ else
+ {
+ /*
+ Complete shortcut.
+ */
+ /* Aggregate to EVENTS_WAITS_SUMMARY_BY_INSTANCE (counted) */
+ pfs_mutex->m_mutex_stat.m_wait_stat.aggregate_counted();
+ return NULL;
+ }
+ }
+
+ state->m_flags= flags;
+ state->m_mutex= mutex;
+ return reinterpret_cast<PSI_mutex_locker*> (state);
+}
+
+/**
+ Implementation of the rwlock instrumentation interface.
+ @sa PSI_v1::start_rwlock_rdwait
+ @sa PSI_v1::start_rwlock_wrwait
+*/
+PSI_rwlock_locker*
+pfs_start_rwlock_wait_v1(PSI_rwlock_locker_state *state,
+ PSI_rwlock *rwlock,
+ PSI_rwlock_operation op,
+ const char *src_file, uint src_line)
+{
+ PFS_rwlock *pfs_rwlock= reinterpret_cast<PFS_rwlock*> (rwlock);
+ DBUG_ASSERT(static_cast<int> (op) >= 0);
+ DBUG_ASSERT(static_cast<uint> (op) < array_elements(rwlock_operation_map));
+ DBUG_ASSERT(state != NULL);
+ DBUG_ASSERT(pfs_rwlock != NULL);
+ DBUG_ASSERT(pfs_rwlock->m_class != NULL);
+
+ /* Operations supported for READ WRITE LOCK */
+
+ DBUG_ASSERT( pfs_rwlock->m_class->is_shared_exclusive()
+ || (op == PSI_RWLOCK_READLOCK)
+ || (op == PSI_RWLOCK_WRITELOCK)
+ || (op == PSI_RWLOCK_TRYREADLOCK)
+ || (op == PSI_RWLOCK_TRYWRITELOCK)
+ );
+
+ /* Operations supported for SHARED EXCLUSIVE LOCK */
+
+ DBUG_ASSERT( ! pfs_rwlock->m_class->is_shared_exclusive()
+ || (op == PSI_RWLOCK_SHAREDLOCK)
+ || (op == PSI_RWLOCK_SHAREDEXCLUSIVELOCK)
+ || (op == PSI_RWLOCK_EXCLUSIVELOCK)
+ || (op == PSI_RWLOCK_TRYSHAREDLOCK)
+ || (op == PSI_RWLOCK_TRYSHAREDEXCLUSIVELOCK)
+ || (op == PSI_RWLOCK_TRYEXCLUSIVELOCK)
+ );
+
+ if (! pfs_rwlock->m_enabled)
+ return NULL;
+
+ uint flags;
+ ulonglong timer_start= 0;
+
+ if (flag_thread_instrumentation)
+ {
+ PFS_thread *pfs_thread= my_thread_get_THR_PFS();
+ if (unlikely(pfs_thread == NULL))
+ return NULL;
+ if (! pfs_thread->m_enabled)
+ return NULL;
+ state->m_thread= reinterpret_cast<PSI_thread *> (pfs_thread);
+ flags= STATE_FLAG_THREAD;
+
+ if (pfs_rwlock->m_timed)
+ {
+ timer_start= get_timer_raw_value_and_function(wait_timer, & state->m_timer);
+ state->m_timer_start= timer_start;
+ flags|= STATE_FLAG_TIMED;
+ }
+
+ if (flag_events_waits_current)
+ {
+ if (unlikely(pfs_thread->m_events_waits_current >=
+ & pfs_thread->m_events_waits_stack[WAIT_STACK_SIZE]))
+ {
+ locker_lost++;
+ return NULL;
+ }
+ PFS_events_waits *wait= pfs_thread->m_events_waits_current;
+ state->m_wait= wait;
+ flags|= STATE_FLAG_EVENT;
+
+ PFS_events_waits *parent_event= wait - 1;
+ wait->m_event_type= EVENT_TYPE_WAIT;
+ wait->m_nesting_event_id= parent_event->m_event_id;
+ wait->m_nesting_event_type= parent_event->m_event_type;
+
+ wait->m_thread_internal_id= pfs_thread->m_thread_internal_id;
+ wait->m_class= pfs_rwlock->m_class;
+ wait->m_timer_start= timer_start;
+ wait->m_timer_end= 0;
+ wait->m_object_instance_addr= pfs_rwlock->m_identity;
+ wait->m_event_id= pfs_thread->m_event_id++;
+ wait->m_end_event_id= 0;
+ wait->m_operation= rwlock_operation_map[static_cast<int> (op)];
+ wait->m_source_file= src_file;
+ wait->m_source_line= src_line;
+ wait->m_wait_class= WAIT_CLASS_RWLOCK;
+
+ pfs_thread->m_events_waits_current++;
+ }
+ }
+ else
+ {
+ if (pfs_rwlock->m_timed)
+ {
+ timer_start= get_timer_raw_value_and_function(wait_timer, & state->m_timer);
+ state->m_timer_start= timer_start;
+ flags= STATE_FLAG_TIMED;
+ state->m_thread= NULL;
+ }
+ else
+ {
+ /*
+ Complete shortcut.
+ */
+ /* Aggregate to EVENTS_WAITS_SUMMARY_BY_INSTANCE (counted) */
+ pfs_rwlock->m_rwlock_stat.m_wait_stat.aggregate_counted();
+ return NULL;
+ }
+ }
+
+ state->m_flags= flags;
+ state->m_rwlock= rwlock;
+ state->m_operation= op;
+ return reinterpret_cast<PSI_rwlock_locker*> (state);
+}
+
+PSI_rwlock_locker*
+pfs_start_rwlock_rdwait_v1(PSI_rwlock_locker_state *state,
+ PSI_rwlock *rwlock,
+ PSI_rwlock_operation op,
+ const char *src_file, uint src_line)
+{
+ DBUG_ASSERT((op == PSI_RWLOCK_READLOCK) ||
+ (op == PSI_RWLOCK_TRYREADLOCK) ||
+ (op == PSI_RWLOCK_SHAREDLOCK) ||
+ (op == PSI_RWLOCK_TRYSHAREDLOCK));
+
+ return pfs_start_rwlock_wait_v1(state, rwlock, op, src_file, src_line);
+}
+
+PSI_rwlock_locker*
+pfs_start_rwlock_wrwait_v1(PSI_rwlock_locker_state *state,
+ PSI_rwlock *rwlock,
+ PSI_rwlock_operation op,
+ const char *src_file, uint src_line)
+{
+ DBUG_ASSERT((op == PSI_RWLOCK_WRITELOCK) ||
+ (op == PSI_RWLOCK_TRYWRITELOCK) ||
+ (op == PSI_RWLOCK_SHAREDEXCLUSIVELOCK) ||
+ (op == PSI_RWLOCK_TRYSHAREDEXCLUSIVELOCK) ||
+ (op == PSI_RWLOCK_EXCLUSIVELOCK) ||
+ (op == PSI_RWLOCK_TRYEXCLUSIVELOCK));
+
+ return pfs_start_rwlock_wait_v1(state, rwlock, op, src_file, src_line);
+}
+
+/**
+ Implementation of the cond instrumentation interface.
+ @sa PSI_v1::start_cond_wait.
+*/
+PSI_cond_locker*
+pfs_start_cond_wait_v1(PSI_cond_locker_state *state,
+ PSI_cond *cond, PSI_mutex *mutex,
+ PSI_cond_operation op,
+ const char *src_file, uint src_line)
+{
+ /*
+ Note about the unused PSI_mutex *mutex parameter:
+ In the pthread library, a call to pthread_cond_wait()
+ causes an unlock() + lock() on the mutex associated with the condition.
+ This mutex operation is not instrumented, so the mutex will still
+ appear as locked when a thread is waiting on a condition.
+ This has no impact now, as unlock_mutex() is not recording events.
+ When unlock_mutex() is implemented by later work logs,
+ this parameter here will be used to adjust the mutex state,
+ in start_cond_wait_v1() and end_cond_wait_v1().
+ */
+ PFS_cond *pfs_cond= reinterpret_cast<PFS_cond*> (cond);
+ DBUG_ASSERT(static_cast<int> (op) >= 0);
+ DBUG_ASSERT(static_cast<uint> (op) < array_elements(cond_operation_map));
+ DBUG_ASSERT(state != NULL);
+ DBUG_ASSERT(pfs_cond != NULL);
+ DBUG_ASSERT(pfs_cond->m_class != NULL);
+
+ if (! pfs_cond->m_enabled)
+ return NULL;
+
+ uint flags;
+ ulonglong timer_start= 0;
+
+ if (flag_thread_instrumentation)
+ {
+ PFS_thread *pfs_thread= my_thread_get_THR_PFS();
+ if (unlikely(pfs_thread == NULL))
+ return NULL;
+ if (! pfs_thread->m_enabled)
+ return NULL;
+ state->m_thread= reinterpret_cast<PSI_thread *> (pfs_thread);
+ flags= STATE_FLAG_THREAD;
+
+ if (pfs_cond->m_timed)
+ {
+ timer_start= get_timer_raw_value_and_function(wait_timer, & state->m_timer);
+ state->m_timer_start= timer_start;
+ flags|= STATE_FLAG_TIMED;
+ }
+
+ if (flag_events_waits_current)
+ {
+ if (unlikely(pfs_thread->m_events_waits_current >=
+ & pfs_thread->m_events_waits_stack[WAIT_STACK_SIZE]))
+ {
+ locker_lost++;
+ return NULL;
+ }
+ PFS_events_waits *wait= pfs_thread->m_events_waits_current;
+ state->m_wait= wait;
+ flags|= STATE_FLAG_EVENT;
+
+ PFS_events_waits *parent_event= wait - 1;
+ wait->m_event_type= EVENT_TYPE_WAIT;
+ wait->m_nesting_event_id= parent_event->m_event_id;
+ wait->m_nesting_event_type= parent_event->m_event_type;
+
+ wait->m_thread_internal_id= pfs_thread->m_thread_internal_id;
+ wait->m_class= pfs_cond->m_class;
+ wait->m_timer_start= timer_start;
+ wait->m_timer_end= 0;
+ wait->m_object_instance_addr= pfs_cond->m_identity;
+ wait->m_event_id= pfs_thread->m_event_id++;
+ wait->m_end_event_id= 0;
+ wait->m_operation= cond_operation_map[static_cast<int> (op)];
+ wait->m_source_file= src_file;
+ wait->m_source_line= src_line;
+ wait->m_wait_class= WAIT_CLASS_COND;
+
+ pfs_thread->m_events_waits_current++;
+ }
+ }
+ else
+ {
+ if (pfs_cond->m_timed)
+ {
+ timer_start= get_timer_raw_value_and_function(wait_timer, & state->m_timer);
+ state->m_timer_start= timer_start;
+ flags= STATE_FLAG_TIMED;
+ }
+ else
+ {
+ /*
+ Complete shortcut.
+ */
+ /* Aggregate to EVENTS_WAITS_SUMMARY_BY_INSTANCE (counted) */
+ pfs_cond->m_cond_stat.m_wait_stat.aggregate_counted();
+ return NULL;
+ }
+ }
+
+ state->m_flags= flags;
+ state->m_cond= cond;
+ state->m_mutex= mutex;
+ return reinterpret_cast<PSI_cond_locker*> (state);
+}
+
+static inline PFS_TL_LOCK_TYPE lock_flags_to_lock_type(uint flags)
+{
+ enum thr_lock_type value= static_cast<enum thr_lock_type> (flags);
+
+ switch (value)
+ {
+ case TL_READ:
+ return PFS_TL_READ;
+ case TL_READ_WITH_SHARED_LOCKS:
+ return PFS_TL_READ_WITH_SHARED_LOCKS;
+ case TL_READ_HIGH_PRIORITY:
+ return PFS_TL_READ_HIGH_PRIORITY;
+ case TL_READ_NO_INSERT:
+ return PFS_TL_READ_NO_INSERT;
+ case TL_WRITE_ALLOW_WRITE:
+ return PFS_TL_WRITE_ALLOW_WRITE;
+ case TL_WRITE_CONCURRENT_INSERT:
+ return PFS_TL_WRITE_CONCURRENT_INSERT;
+ case TL_WRITE_DELAYED:
+ return PFS_TL_WRITE_DELAYED;
+ case TL_WRITE_LOW_PRIORITY:
+ return PFS_TL_WRITE_LOW_PRIORITY;
+ case TL_WRITE:
+ return PFS_TL_WRITE;
+
+ case TL_WRITE_ONLY:
+ case TL_IGNORE:
+ case TL_UNLOCK:
+ case TL_READ_DEFAULT:
+ case TL_WRITE_DEFAULT:
+ default:
+ DBUG_ASSERT(false);
+ }
+
+ /* Dead code */
+ return PFS_TL_READ;
+}
+
+static inline PFS_TL_LOCK_TYPE external_lock_flags_to_lock_type(uint flags)
+{
+ DBUG_ASSERT(flags == F_RDLCK || flags == F_WRLCK);
+ return (flags == F_RDLCK ? PFS_TL_READ_EXTERNAL : PFS_TL_WRITE_EXTERNAL);
+}
+
+/**
+ Implementation of the table instrumentation interface.
+ @sa PSI_v1::start_table_io_wait_v1
+*/
+PSI_table_locker*
+pfs_start_table_io_wait_v1(PSI_table_locker_state *state,
+ PSI_table *table,
+ PSI_table_io_operation op,
+ uint index,
+ const char *src_file, uint src_line)
+{
+ DBUG_ASSERT(static_cast<int> (op) >= 0);
+ DBUG_ASSERT(static_cast<uint> (op) < array_elements(table_io_operation_map));
+ DBUG_ASSERT(state != NULL);
+ PFS_table *pfs_table= reinterpret_cast<PFS_table*> (table);
+ DBUG_ASSERT(pfs_table != NULL);
+ DBUG_ASSERT(pfs_table->m_share != NULL);
+
+ if (! pfs_table->m_io_enabled)
+ return NULL;
+
+ PFS_thread *pfs_thread= my_thread_get_THR_PFS();
+
+ uint flags;
+ ulonglong timer_start= 0;
+
+ if (flag_thread_instrumentation)
+ {
+ if (pfs_thread == NULL)
+ return NULL;
+ if (! pfs_thread->m_enabled)
+ return NULL;
+ state->m_thread= reinterpret_cast<PSI_thread *> (pfs_thread);
+ flags= STATE_FLAG_THREAD;
+
+ if (pfs_table->m_io_timed)
+ {
+ timer_start= get_timer_raw_value_and_function(wait_timer, & state->m_timer);
+ state->m_timer_start= timer_start;
+ flags|= STATE_FLAG_TIMED;
+ }
+
+ if (flag_events_waits_current)
+ {
+ if (unlikely(pfs_thread->m_events_waits_current >=
+ & pfs_thread->m_events_waits_stack[WAIT_STACK_SIZE]))
+ {
+ locker_lost++;
+ return NULL;
+ }
+ PFS_events_waits *wait= pfs_thread->m_events_waits_current;
+ state->m_wait= wait;
+ flags|= STATE_FLAG_EVENT;
+
+ PFS_events_waits *parent_event= wait - 1;
+ wait->m_event_type= EVENT_TYPE_WAIT;
+ wait->m_nesting_event_id= parent_event->m_event_id;
+ wait->m_nesting_event_type= parent_event->m_event_type;
+
+ PFS_table_share *share= pfs_table->m_share;
+ wait->m_thread_internal_id= pfs_thread->m_thread_internal_id;
+ wait->m_class= &global_table_io_class;
+ wait->m_timer_start= timer_start;
+ wait->m_timer_end= 0;
+ wait->m_object_instance_addr= pfs_table->m_identity;
+ wait->m_event_id= pfs_thread->m_event_id++;
+ wait->m_end_event_id= 0;
+ wait->m_operation= table_io_operation_map[static_cast<int> (op)];
+ wait->m_flags= 0;
+ wait->m_object_type= share->get_object_type();
+ wait->m_weak_table_share= share;
+ wait->m_weak_version= share->get_version();
+ wait->m_index= index;
+ wait->m_source_file= src_file;
+ wait->m_source_line= src_line;
+ wait->m_wait_class= WAIT_CLASS_TABLE;
+
+ pfs_thread->m_events_waits_current++;
+ }
+ }
+ else
+ {
+ if (pfs_table->m_io_timed)
+ {
+ timer_start= get_timer_raw_value_and_function(wait_timer, & state->m_timer);
+ state->m_timer_start= timer_start;
+ flags= STATE_FLAG_TIMED;
+ }
+ else
+ {
+ /* TODO: consider a shortcut here */
+ flags= 0;
+ }
+ }
+
+ state->m_flags= flags;
+ state->m_table= table;
+ state->m_io_operation= op;
+ state->m_index= index;
+ return reinterpret_cast<PSI_table_locker*> (state);
+}
+
+/**
+ Implementation of the table instrumentation interface.
+ @sa PSI_v1::start_table_lock_wait.
+*/
+PSI_table_locker*
+pfs_start_table_lock_wait_v1(PSI_table_locker_state *state,
+ PSI_table *table,
+ PSI_table_lock_operation op,
+ ulong op_flags,
+ const char *src_file, uint src_line)
+{
+ DBUG_ASSERT(state != NULL);
+ DBUG_ASSERT((op == PSI_TABLE_LOCK) || (op == PSI_TABLE_EXTERNAL_LOCK));
+
+ PFS_table *pfs_table= reinterpret_cast<PFS_table*> (table);
+
+ DBUG_ASSERT(pfs_table != NULL);
+ DBUG_ASSERT(pfs_table->m_share != NULL);
+
+ if (! pfs_table->m_lock_enabled)
+ return NULL;
+
+ PFS_thread *pfs_thread= my_thread_get_THR_PFS();
+
+ PFS_TL_LOCK_TYPE lock_type;
+
+ switch (op)
+ {
+ case PSI_TABLE_LOCK:
+ lock_type= lock_flags_to_lock_type(op_flags);
+ pfs_table->m_internal_lock= lock_type;
+ break;
+ case PSI_TABLE_EXTERNAL_LOCK:
+ /*
+ See the handler::external_lock() API design,
+ there is no handler::external_unlock().
+ */
+ if (op_flags == F_UNLCK)
+ {
+ pfs_table->m_external_lock= PFS_TL_NONE;
+ return NULL;
+ }
+ lock_type= external_lock_flags_to_lock_type(op_flags);
+ pfs_table->m_external_lock= lock_type;
+ break;
+ default:
+ lock_type= PFS_TL_READ;
+ DBUG_ASSERT(false);
+ }
+
+ DBUG_ASSERT((uint) lock_type < array_elements(table_lock_operation_map));
+
+ uint flags;
+ ulonglong timer_start= 0;
+
+ if (flag_thread_instrumentation)
+ {
+ if (pfs_thread == NULL)
+ return NULL;
+ if (! pfs_thread->m_enabled)
+ return NULL;
+ state->m_thread= reinterpret_cast<PSI_thread *> (pfs_thread);
+ flags= STATE_FLAG_THREAD;
+
+ if (pfs_table->m_lock_timed)
+ {
+ timer_start= get_timer_raw_value_and_function(wait_timer, & state->m_timer);
+ state->m_timer_start= timer_start;
+ flags|= STATE_FLAG_TIMED;
+ }
+
+ if (flag_events_waits_current)
+ {
+ if (unlikely(pfs_thread->m_events_waits_current >=
+ & pfs_thread->m_events_waits_stack[WAIT_STACK_SIZE]))
+ {
+ locker_lost++;
+ return NULL;
+ }
+ PFS_events_waits *wait= pfs_thread->m_events_waits_current;
+ state->m_wait= wait;
+ flags|= STATE_FLAG_EVENT;
+
+ PFS_events_waits *parent_event= wait - 1;
+ wait->m_event_type= EVENT_TYPE_WAIT;
+ wait->m_nesting_event_id= parent_event->m_event_id;
+ wait->m_nesting_event_type= parent_event->m_event_type;
+
+ PFS_table_share *share= pfs_table->m_share;
+ wait->m_thread_internal_id= pfs_thread->m_thread_internal_id;
+ wait->m_class= &global_table_lock_class;
+ wait->m_timer_start= timer_start;
+ wait->m_timer_end= 0;
+ wait->m_object_instance_addr= pfs_table->m_identity;
+ wait->m_event_id= pfs_thread->m_event_id++;
+ wait->m_end_event_id= 0;
+ wait->m_operation= table_lock_operation_map[lock_type];
+ wait->m_flags= 0;
+ wait->m_object_type= share->get_object_type();
+ wait->m_weak_table_share= share;
+ wait->m_weak_version= share->get_version();
+ wait->m_index= 0;
+ wait->m_source_file= src_file;
+ wait->m_source_line= src_line;
+ wait->m_wait_class= WAIT_CLASS_TABLE;
+
+ pfs_thread->m_events_waits_current++;
+ }
+ }
+ else
+ {
+ if (pfs_table->m_lock_timed)
+ {
+ timer_start= get_timer_raw_value_and_function(wait_timer, & state->m_timer);
+ state->m_timer_start= timer_start;
+ flags= STATE_FLAG_TIMED;
+ }
+ else
+ {
+ /* TODO: consider a shortcut here */
+ flags= 0;
+ }
+ }
+
+ state->m_flags= flags;
+ state->m_table= table;
+ state->m_index= lock_type;
+ return reinterpret_cast<PSI_table_locker*> (state);
+}
+
+/**
+ Implementation of the file instrumentation interface.
+ @sa PSI_v1::get_thread_file_name_locker.
+*/
+PSI_file_locker*
+pfs_get_thread_file_name_locker_v1(PSI_file_locker_state *state,
+ PSI_file_key key,
+ PSI_file_operation op,
+ const char *name, const void *identity)
+{
+ DBUG_ASSERT(static_cast<int> (op) >= 0);
+ DBUG_ASSERT(static_cast<uint> (op) < array_elements(file_operation_map));
+ DBUG_ASSERT(state != NULL);
+
+ if (psi_unlikely(! flag_global_instrumentation))
+ return NULL;
+ PFS_file_class *klass= find_file_class(key);
+ if (unlikely(klass == NULL))
+ return NULL;
+ if (! klass->m_enabled)
+ return NULL;
+
+ /* Needed for the LF_HASH */
+ PFS_thread *pfs_thread= my_thread_get_THR_PFS();
+ if (unlikely(pfs_thread == NULL))
+ return NULL;
+
+ if (flag_thread_instrumentation && ! pfs_thread->m_enabled)
+ return NULL;
+
+ uint flags;
+
+ state->m_thread= reinterpret_cast<PSI_thread *> (pfs_thread);
+ flags= STATE_FLAG_THREAD;
+
+ if (klass->m_timed)
+ flags|= STATE_FLAG_TIMED;
+
+ if (flag_events_waits_current)
+ {
+ if (unlikely(pfs_thread->m_events_waits_current >=
+ & pfs_thread->m_events_waits_stack[WAIT_STACK_SIZE]))
+ {
+ locker_lost++;
+ return NULL;
+ }
+ PFS_events_waits *wait= pfs_thread->m_events_waits_current;
+ state->m_wait= wait;
+ flags|= STATE_FLAG_EVENT;
+
+ PFS_events_waits *parent_event= wait - 1;
+ wait->m_event_type= EVENT_TYPE_WAIT;
+ wait->m_nesting_event_id= parent_event->m_event_id;
+ wait->m_nesting_event_type= parent_event->m_event_type;
+
+ wait->m_thread_internal_id= pfs_thread->m_thread_internal_id;
+ wait->m_class= klass;
+ wait->m_timer_start= 0;
+ wait->m_timer_end= 0;
+ wait->m_object_instance_addr= NULL;
+ wait->m_weak_file= NULL;
+ wait->m_weak_version= 0;
+ wait->m_event_id= pfs_thread->m_event_id++;
+ wait->m_end_event_id= 0;
+ wait->m_operation= file_operation_map[static_cast<int> (op)];
+ wait->m_wait_class= WAIT_CLASS_FILE;
+
+ pfs_thread->m_events_waits_current++;
+ }
+
+ state->m_flags= flags;
+ state->m_file= NULL;
+ state->m_name= name;
+ state->m_class= klass;
+ state->m_operation= op;
+ return reinterpret_cast<PSI_file_locker*> (state);
+}
+
+/**
+ Implementation of the file instrumentation interface.
+ @sa PSI_v1::get_thread_file_stream_locker.
+*/
+PSI_file_locker*
+pfs_get_thread_file_stream_locker_v1(PSI_file_locker_state *state,
+ PSI_file *file, PSI_file_operation op)
+{
+ PFS_file *pfs_file= reinterpret_cast<PFS_file*> (file);
+ DBUG_ASSERT(static_cast<int> (op) >= 0);
+ DBUG_ASSERT(static_cast<uint> (op) < array_elements(file_operation_map));
+ DBUG_ASSERT(state != NULL);
+
+ if (unlikely(pfs_file == NULL))
+ return NULL;
+ DBUG_ASSERT(pfs_file->m_class != NULL);
+ PFS_file_class *klass= pfs_file->m_class;
+
+ if (! pfs_file->m_enabled)
+ return NULL;
+
+ /* Needed for the LF_HASH */
+ PFS_thread *pfs_thread= my_thread_get_THR_PFS();
+ if (unlikely(pfs_thread == NULL))
+ return NULL;
+
+ uint flags;
+
+ /* Always populated */
+ state->m_thread= reinterpret_cast<PSI_thread *> (pfs_thread);
+
+ if (flag_thread_instrumentation)
+ {
+ if (! pfs_thread->m_enabled)
+ return NULL;
+ flags= STATE_FLAG_THREAD;
+
+ if (pfs_file->m_timed)
+ flags|= STATE_FLAG_TIMED;
+
+ if (flag_events_waits_current)
+ {
+ if (unlikely(pfs_thread->m_events_waits_current >=
+ & pfs_thread->m_events_waits_stack[WAIT_STACK_SIZE]))
+ {
+ locker_lost++;
+ return NULL;
+ }
+ PFS_events_waits *wait= pfs_thread->m_events_waits_current;
+ state->m_wait= wait;
+ flags|= STATE_FLAG_EVENT;
+
+ PFS_events_waits *parent_event= wait - 1;
+ wait->m_event_type= EVENT_TYPE_WAIT;
+ wait->m_nesting_event_id= parent_event->m_event_id;
+ wait->m_nesting_event_type= parent_event->m_event_type;
+
+ wait->m_thread_internal_id= pfs_thread->m_thread_internal_id;
+ wait->m_class= klass;
+ wait->m_timer_start= 0;
+ wait->m_timer_end= 0;
+ wait->m_object_instance_addr= pfs_file;
+ wait->m_weak_file= pfs_file;
+ wait->m_weak_version= pfs_file->get_version();
+ wait->m_event_id= pfs_thread->m_event_id++;
+ wait->m_end_event_id= 0;
+ wait->m_operation= file_operation_map[static_cast<int> (op)];
+ wait->m_wait_class= WAIT_CLASS_FILE;
+
+ pfs_thread->m_events_waits_current++;
+ }
+ }
+ else
+ {
+ if (pfs_file->m_timed)
+ {
+ flags= STATE_FLAG_TIMED;
+ }
+ else
+ {
+ /* TODO: consider a shortcut. */
+ flags= 0;
+ }
+ }
+
+ state->m_flags= flags;
+ state->m_file= reinterpret_cast<PSI_file*> (pfs_file);
+ state->m_operation= op;
+ state->m_name= NULL;
+ state->m_class= klass;
+ return reinterpret_cast<PSI_file_locker*> (state);
+}
+
+/**
+ Implementation of the file instrumentation interface.
+ @sa PSI_v1::get_thread_file_descriptor_locker.
+*/
+PSI_file_locker*
+pfs_get_thread_file_descriptor_locker_v1(PSI_file_locker_state *state,
+ File file, PSI_file_operation op)
+{
+ int index= static_cast<int> (file);
+ DBUG_ASSERT(static_cast<int> (op) >= 0);
+ DBUG_ASSERT(static_cast<uint> (op) < array_elements(file_operation_map));
+ DBUG_ASSERT(state != NULL);
+
+ if (unlikely((index < 0) || (index >= file_handle_max)))
+ return NULL;
+
+ PFS_file *pfs_file= file_handle_array[index];
+ if (unlikely(pfs_file == NULL))
+ return NULL;
+
+ /*
+ We are about to close a file by descriptor number,
+ and the calling code still holds the descriptor.
+ Cleanup the file descriptor <--> file instrument association.
+ Remove the instrumentation *before* the close to avoid race
+ conditions with another thread opening a file
+ (that could be given the same descriptor).
+ */
+ if (op == PSI_FILE_CLOSE)
+ file_handle_array[index]= NULL;
+
+ if (! pfs_file->m_enabled)
+ return NULL;
+
+ DBUG_ASSERT(pfs_file->m_class != NULL);
+ PFS_file_class *klass= pfs_file->m_class;
+
+ /* Needed for the LF_HASH */
+ PFS_thread *pfs_thread= my_thread_get_THR_PFS();
+ if (unlikely(pfs_thread == NULL))
+ return NULL;
+
+ uint flags;
+
+ /* Always populated */
+ state->m_thread= reinterpret_cast<PSI_thread *> (pfs_thread);
+
+ if (flag_thread_instrumentation)
+ {
+ if (! pfs_thread->m_enabled)
+ return NULL;
+ flags= STATE_FLAG_THREAD;
+
+ if (pfs_file->m_timed)
+ flags|= STATE_FLAG_TIMED;
+
+ if (flag_events_waits_current)
+ {
+ if (unlikely(pfs_thread->m_events_waits_current >=
+ & pfs_thread->m_events_waits_stack[WAIT_STACK_SIZE]))
+ {
+ locker_lost++;
+ return NULL;
+ }
+ PFS_events_waits *wait= pfs_thread->m_events_waits_current;
+ state->m_wait= wait;
+ flags|= STATE_FLAG_EVENT;
+
+ PFS_events_waits *parent_event= wait - 1;
+ wait->m_event_type= EVENT_TYPE_WAIT;
+ wait->m_nesting_event_id= parent_event->m_event_id;
+ wait->m_nesting_event_type= parent_event->m_event_type;
+
+ wait->m_thread_internal_id= pfs_thread->m_thread_internal_id;
+ wait->m_class= klass;
+ wait->m_timer_start= 0;
+ wait->m_timer_end= 0;
+ wait->m_object_instance_addr= pfs_file;
+ wait->m_weak_file= pfs_file;
+ wait->m_weak_version= pfs_file->get_version();
+ wait->m_event_id= pfs_thread->m_event_id++;
+ wait->m_end_event_id= 0;
+ wait->m_operation= file_operation_map[static_cast<int> (op)];
+ wait->m_wait_class= WAIT_CLASS_FILE;
+
+ pfs_thread->m_events_waits_current++;
+ }
+ }
+ else
+ {
+ if (pfs_file->m_timed)
+ {
+ flags= STATE_FLAG_TIMED;
+ }
+ else
+ {
+ /* TODO: consider a shortcut. */
+ flags= 0;
+ }
+ }
+
+ state->m_flags= flags;
+ state->m_file= reinterpret_cast<PSI_file*> (pfs_file);
+ state->m_operation= op;
+ state->m_name= NULL;
+ state->m_class= klass;
+ return reinterpret_cast<PSI_file_locker*> (state);
+}
+
+/** Socket locker */
+
+PSI_socket_locker*
+pfs_start_socket_wait_v1(PSI_socket_locker_state *state,
+ PSI_socket *socket,
+ PSI_socket_operation op,
+ size_t count,
+ const char *src_file, uint src_line)
+{
+ DBUG_ASSERT(static_cast<int> (op) >= 0);
+ DBUG_ASSERT(static_cast<uint> (op) < array_elements(socket_operation_map));
+ DBUG_ASSERT(state != NULL);
+ PFS_socket *pfs_socket= reinterpret_cast<PFS_socket*> (socket);
+
+ DBUG_ASSERT(pfs_socket != NULL);
+ DBUG_ASSERT(pfs_socket->m_class != NULL);
+
+ if (!pfs_socket->m_enabled || pfs_socket->m_idle)
+ return NULL;
+
+ uint flags= 0;
+ ulonglong timer_start= 0;
+
+ if (flag_thread_instrumentation)
+ {
+ /*
+ Do not use pfs_socket->m_thread_owner here,
+ as different threads may use concurrently the same socket,
+ for example during a KILL.
+ */
+ PFS_thread *pfs_thread= my_thread_get_THR_PFS();
+
+ if (unlikely(pfs_thread == NULL))
+ return NULL;
+
+ if (!pfs_thread->m_enabled)
+ return NULL;
+
+ state->m_thread= reinterpret_cast<PSI_thread *> (pfs_thread);
+ flags= STATE_FLAG_THREAD;
+
+ if (pfs_socket->m_timed)
+ {
+ timer_start= get_timer_raw_value_and_function(wait_timer, & state->m_timer);
+ state->m_timer_start= timer_start;
+ flags|= STATE_FLAG_TIMED;
+ }
+
+ if (flag_events_waits_current)
+ {
+ if (unlikely(pfs_thread->m_events_waits_current >=
+ & pfs_thread->m_events_waits_stack[WAIT_STACK_SIZE]))
+ {
+ locker_lost++;
+ return NULL;
+ }
+ PFS_events_waits *wait= pfs_thread->m_events_waits_current;
+ state->m_wait= wait;
+ flags|= STATE_FLAG_EVENT;
+
+ PFS_events_waits *parent_event= wait - 1;
+ wait->m_event_type= EVENT_TYPE_WAIT;
+ wait->m_nesting_event_id= parent_event->m_event_id;
+ wait->m_nesting_event_type= parent_event->m_event_type;
+ wait->m_thread_internal_id= pfs_thread->m_thread_internal_id;
+ wait->m_class= pfs_socket->m_class;
+ wait->m_timer_start= timer_start;
+ wait->m_timer_end= 0;
+ wait->m_object_instance_addr= pfs_socket->m_identity;
+ wait->m_weak_socket= pfs_socket;
+ wait->m_weak_version= pfs_socket->get_version();
+ wait->m_event_id= pfs_thread->m_event_id++;
+ wait->m_end_event_id= 0;
+ wait->m_operation= socket_operation_map[static_cast<int>(op)];
+ wait->m_source_file= src_file;
+ wait->m_source_line= src_line;
+ wait->m_number_of_bytes= count;
+ wait->m_wait_class= WAIT_CLASS_SOCKET;
+
+ pfs_thread->m_events_waits_current++;
+ }
+ }
+ else
+ {
+ if (pfs_socket->m_timed)
+ {
+ timer_start= get_timer_raw_value_and_function(wait_timer, & state->m_timer);
+ state->m_timer_start= timer_start;
+ flags= STATE_FLAG_TIMED;
+ }
+ else
+ {
+ /*
+ Even if timing is disabled, end_socket_wait() still needs a locker to
+ capture the number of bytes sent or received by the socket operation.
+ For operations that do not have a byte count, then just increment the
+ event counter and return a NULL locker.
+ */
+ switch (op)
+ {
+ case PSI_SOCKET_CONNECT:
+ case PSI_SOCKET_CREATE:
+ case PSI_SOCKET_BIND:
+ case PSI_SOCKET_SEEK:
+ case PSI_SOCKET_OPT:
+ case PSI_SOCKET_STAT:
+ case PSI_SOCKET_SHUTDOWN:
+ case PSI_SOCKET_CLOSE:
+ case PSI_SOCKET_SELECT:
+ pfs_socket->m_socket_stat.m_io_stat.m_misc.aggregate_counted();
+ return NULL;
+ default:
+ break;
+ }
+ }
+ }
+
+ state->m_flags= flags;
+ state->m_socket= socket;
+ state->m_operation= op;
+ return reinterpret_cast<PSI_socket_locker*> (state);
+}
+
+/**
+ Implementation of the mutex instrumentation interface.
+ @sa PSI_v1::unlock_mutex.
+*/
+void pfs_unlock_mutex_v1(PSI_mutex *mutex)
+{
+ PFS_mutex *pfs_mutex= reinterpret_cast<PFS_mutex*> (mutex);
+
+ DBUG_ASSERT(pfs_mutex != NULL);
+
+ /*
+ Note that this code is still protected by the instrumented mutex,
+ and therefore is thread safe. See inline_mysql_mutex_unlock().
+ */
+
+ /* Always update the instrumented state */
+ pfs_mutex->m_owner= NULL;
+ pfs_mutex->m_last_locked= 0;
+
+#ifdef LATER_WL2333
+ /*
+ See WL#2333: SHOW ENGINE ... LOCK STATUS.
+ PFS_mutex::m_lock_stat is not exposed in user visible tables
+ currently, so there is no point spending time computing it.
+ */
+ if (! pfs_mutex->m_enabled)
+ return;
+
+ if (! pfs_mutex->m_timed)
+ return;
+
+ ulonglong locked_time;
+ locked_time= get_timer_pico_value(wait_timer) - pfs_mutex->m_last_locked;
+ pfs_mutex->m_mutex_stat.m_lock_stat.aggregate_value(locked_time);
+#endif
+}
+
+/**
+ Implementation of the rwlock instrumentation interface.
+ @sa PSI_v1::unlock_rwlock.
+*/
+void pfs_unlock_rwlock_v1(PSI_rwlock *rwlock)
+{
+ PFS_rwlock *pfs_rwlock= reinterpret_cast<PFS_rwlock*> (rwlock);
+ DBUG_ASSERT(pfs_rwlock != NULL);
+ DBUG_ASSERT(pfs_rwlock == sanitize_rwlock(pfs_rwlock));
+ DBUG_ASSERT(pfs_rwlock->m_class != NULL);
+ DBUG_ASSERT(pfs_rwlock->m_lock.is_populated());
+
+ bool last_writer= false;
+ bool last_reader= false;
+
+ /*
+ Note that this code is still protected by the instrumented rwlock,
+ and therefore is:
+ - thread safe for write locks
+ - almost thread safe for read locks (pfs_rwlock->m_readers is unsafe).
+ See inline_mysql_rwlock_unlock()
+ */
+
+ /* Always update the instrumented state */
+ if (pfs_rwlock->m_writer != NULL)
+ {
+ /* Nominal case, a writer is unlocking. */
+ last_writer= true;
+ pfs_rwlock->m_writer= NULL;
+ /* Reset the readers stats, they could be off */
+ pfs_rwlock->m_readers= 0;
+ }
+ else if (likely(pfs_rwlock->m_readers > 0))
+ {
+ /* Nominal case, a reader is unlocking. */
+ if (--(pfs_rwlock->m_readers) == 0)
+ last_reader= true;
+ }
+ else
+ {
+ /*
+ Edge case, we have no writer and no readers,
+ on an unlock event.
+ This is possible for:
+ - partial instrumentation
+ - instrumentation disabled at runtime,
+ see when get_thread_rwlock_locker_v1() returns NULL
+ No further action is taken here, the next
+ write lock will put the statistics is a valid state.
+ */
+ }
+
+#ifdef LATER_WL2333
+ /* See WL#2333: SHOW ENGINE ... LOCK STATUS. */
+
+ if (! pfs_rwlock->m_enabled)
+ return;
+
+ if (! pfs_rwlock->m_timed)
+ return;
+
+ ulonglong locked_time;
+ if (last_writer)
+ {
+ locked_time= get_timer_pico_value(wait_timer) - pfs_rwlock->m_last_written;
+ pfs_rwlock->m_rwlock_stat.m_write_lock_stat.aggregate_value(locked_time);
+ }
+ else if (last_reader)
+ {
+ locked_time= get_timer_pico_value(wait_timer) - pfs_rwlock->m_last_read;
+ pfs_rwlock->m_rwlock_stat.m_read_lock_stat.aggregate_value(locked_time);
+ }
+#else
+ (void) last_reader;
+ (void) last_writer;
+#endif
+}
+
+/**
+ Implementation of the cond instrumentation interface.
+ @sa PSI_v1::signal_cond.
+*/
+void pfs_signal_cond_v1(PSI_cond* cond)
+{
+#ifdef PFS_LATER
+ PFS_cond *pfs_cond= reinterpret_cast<PFS_cond*> (cond);
+
+ DBUG_ASSERT(pfs_cond != NULL);
+
+ pfs_cond->m_cond_stat.m_signal_count++;
+#endif
+}
+
+/**
+ Implementation of the cond instrumentation interface.
+ @sa PSI_v1::broadcast_cond.
+*/
+void pfs_broadcast_cond_v1(PSI_cond* cond)
+{
+#ifdef PFS_LATER
+ PFS_cond *pfs_cond= reinterpret_cast<PFS_cond*> (cond);
+
+ DBUG_ASSERT(pfs_cond != NULL);
+
+ pfs_cond->m_cond_stat.m_broadcast_count++;
+#endif
+}
+
+/**
+ Implementation of the idle instrumentation interface.
+ @sa PSI_v1::start_idle_wait.
+*/
+PSI_idle_locker*
+pfs_start_idle_wait_v1(PSI_idle_locker_state* state, const char *src_file, uint src_line)
+{
+ DBUG_ASSERT(state != NULL);
+
+ if (psi_unlikely(! flag_global_instrumentation))
+ return NULL;
+
+ if (!global_idle_class.m_enabled)
+ return NULL;
+
+ uint flags= 0;
+ ulonglong timer_start= 0;
+
+ if (flag_thread_instrumentation)
+ {
+ PFS_thread *pfs_thread= my_thread_get_THR_PFS();
+ if (unlikely(pfs_thread == NULL))
+ return NULL;
+ if (!pfs_thread->m_enabled)
+ return NULL;
+ state->m_thread= reinterpret_cast<PSI_thread *> (pfs_thread);
+ flags= STATE_FLAG_THREAD;
+
+ DBUG_ASSERT(pfs_thread->m_events_statements_count == 0);
+
+ if (global_idle_class.m_timed)
+ {
+ timer_start= get_timer_raw_value_and_function(idle_timer, &state->m_timer);
+ state->m_timer_start= timer_start;
+ flags|= STATE_FLAG_TIMED;
+ }
+
+ if (flag_events_waits_current)
+ {
+ if (unlikely(pfs_thread->m_events_waits_current >=
+ & pfs_thread->m_events_waits_stack[WAIT_STACK_SIZE]))
+ {
+ locker_lost++;
+ return NULL;
+ }
+ PFS_events_waits *wait= pfs_thread->m_events_waits_current;
+ state->m_wait= wait;
+ flags|= STATE_FLAG_EVENT;
+
+ wait->m_event_type= EVENT_TYPE_WAIT;
+ /*
+ IDLE events are waits, but by definition we know that
+ such waits happen outside of any STAGE and STATEMENT,
+ so they have no parents.
+ */
+ wait->m_nesting_event_id= 0;
+ /* no need to set wait->m_nesting_event_type */
+
+ wait->m_thread_internal_id= pfs_thread->m_thread_internal_id;
+ wait->m_class= &global_idle_class;
+ wait->m_timer_start= timer_start;
+ wait->m_timer_end= 0;
+ wait->m_event_id= pfs_thread->m_event_id++;
+ wait->m_end_event_id= 0;
+ wait->m_operation= OPERATION_TYPE_IDLE;
+ wait->m_source_file= src_file;
+ wait->m_source_line= src_line;
+ wait->m_wait_class= WAIT_CLASS_IDLE;
+
+ pfs_thread->m_events_waits_current++;
+ }
+ }
+ else
+ {
+ if (global_idle_class.m_timed)
+ {
+ timer_start= get_timer_raw_value_and_function(idle_timer, &state->m_timer);
+ state->m_timer_start= timer_start;
+ flags= STATE_FLAG_TIMED;
+ }
+ }
+
+ state->m_flags= flags;
+ return reinterpret_cast<PSI_idle_locker*> (state);
+}
+
+/**
+ Implementation of the mutex instrumentation interface.
+ @sa PSI_v1::end_idle_wait.
+*/
+void pfs_end_idle_wait_v1(PSI_idle_locker* locker)
+{
+ PSI_idle_locker_state *state= reinterpret_cast<PSI_idle_locker_state*> (locker);
+ DBUG_ASSERT(state != NULL);
+ ulonglong timer_end= 0;
+ ulonglong wait_time= 0;
+
+ uint flags= state->m_flags;
+
+ if (flags & STATE_FLAG_TIMED)
+ {
+ timer_end= state->m_timer();
+ wait_time= timer_end - state->m_timer_start;
+ }
+
+ if (flags & STATE_FLAG_THREAD)
+ {
+ PFS_thread *thread= reinterpret_cast<PFS_thread *> (state->m_thread);
+ PFS_single_stat *event_name_array;
+ event_name_array= thread->write_instr_class_waits_stats();
+
+ if (flags & STATE_FLAG_TIMED)
+ {
+ /* Aggregate to EVENTS_WAITS_SUMMARY_BY_THREAD_BY_EVENT_NAME (timed) */
+ event_name_array[GLOBAL_IDLE_EVENT_INDEX].aggregate_value(wait_time);
+ }
+ else
+ {
+ /* Aggregate to EVENTS_WAITS_SUMMARY_BY_THREAD_BY_EVENT_NAME (counted) */
+ event_name_array[GLOBAL_IDLE_EVENT_INDEX].aggregate_counted();
+ }
+
+ if (flags & STATE_FLAG_EVENT)
+ {
+ PFS_events_waits *wait= reinterpret_cast<PFS_events_waits*> (state->m_wait);
+ DBUG_ASSERT(wait != NULL);
+
+ wait->m_timer_end= timer_end;
+ wait->m_end_event_id= thread->m_event_id;
+ if (thread->m_flag_events_waits_history)
+ insert_events_waits_history(thread, wait);
+ if (thread->m_flag_events_waits_history_long)
+ insert_events_waits_history_long(wait);
+ thread->m_events_waits_current--;
+
+ DBUG_ASSERT(wait == thread->m_events_waits_current);
+ }
+ }
+
+ if (flags & STATE_FLAG_TIMED)
+ {
+ /* Aggregate to EVENTS_WAITS_SUMMARY_GLOBAL_BY_EVENT_NAME (timed) */
+ global_idle_stat.aggregate_value(wait_time);
+ }
+ else
+ {
+ /* Aggregate to EVENTS_WAITS_SUMMARY_GLOBAL_BY_EVENT_NAME (counted) */
+ global_idle_stat.aggregate_counted();
+ }
+}
+
+/**
+ Implementation of the mutex instrumentation interface.
+ @sa PSI_v1::end_mutex_wait.
+*/
+void pfs_end_mutex_wait_v1(PSI_mutex_locker* locker, int rc)
+{
+ PSI_mutex_locker_state *state= reinterpret_cast<PSI_mutex_locker_state*> (locker);
+ DBUG_ASSERT(state != NULL);
+
+ ulonglong timer_end= 0;
+ ulonglong wait_time= 0;
+
+ PFS_mutex *mutex= reinterpret_cast<PFS_mutex *> (state->m_mutex);
+ DBUG_ASSERT(mutex != NULL);
+ PFS_thread *thread= reinterpret_cast<PFS_thread *> (state->m_thread);
+
+ uint flags= state->m_flags;
+
+ if (flags & STATE_FLAG_TIMED)
+ {
+ timer_end= state->m_timer();
+ wait_time= timer_end - state->m_timer_start;
+ /* Aggregate to EVENTS_WAITS_SUMMARY_BY_INSTANCE (timed) */
+ mutex->m_mutex_stat.m_wait_stat.aggregate_value(wait_time);
+ }
+ else
+ {
+ /* Aggregate to EVENTS_WAITS_SUMMARY_BY_INSTANCE (counted) */
+ mutex->m_mutex_stat.m_wait_stat.aggregate_counted();
+ }
+
+ if (likely(rc == 0))
+ {
+ mutex->m_owner= thread;
+ mutex->m_last_locked= timer_end;
+ }
+
+ if (flags & STATE_FLAG_THREAD)
+ {
+ PFS_single_stat *event_name_array;
+ event_name_array= thread->write_instr_class_waits_stats();
+ uint index= mutex->m_class->m_event_name_index;
+
+ DBUG_ASSERT(index <= wait_class_max);
+ DBUG_ASSERT(sanitize_thread(thread) != NULL);
+
+ if (flags & STATE_FLAG_TIMED)
+ {
+ /* Aggregate to EVENTS_WAITS_SUMMARY_BY_THREAD_BY_EVENT_NAME (timed) */
+ event_name_array[index].aggregate_value(wait_time);
+ }
+ else
+ {
+ /* Aggregate to EVENTS_WAITS_SUMMARY_BY_THREAD_BY_EVENT_NAME (counted) */
+ event_name_array[index].aggregate_counted();
+ }
+
+ if (flags & STATE_FLAG_EVENT)
+ {
+ PFS_events_waits *wait= reinterpret_cast<PFS_events_waits*> (state->m_wait);
+ DBUG_ASSERT(wait != NULL);
+
+ wait->m_timer_end= timer_end;
+ wait->m_end_event_id= thread->m_event_id;
+ if (thread->m_flag_events_waits_history)
+ insert_events_waits_history(thread, wait);
+ if (thread->m_flag_events_waits_history_long)
+ insert_events_waits_history_long(wait);
+ thread->m_events_waits_current--;
+
+ DBUG_ASSERT(wait == thread->m_events_waits_current);
+ }
+ }
+}
+
+/**
+ Implementation of the rwlock instrumentation interface.
+ @sa PSI_v1::end_rwlock_rdwait.
+*/
+void pfs_end_rwlock_rdwait_v1(PSI_rwlock_locker* locker, int rc)
+{
+ PSI_rwlock_locker_state *state= reinterpret_cast<PSI_rwlock_locker_state*> (locker);
+ DBUG_ASSERT(state != NULL);
+
+ ulonglong timer_end= 0;
+ ulonglong wait_time= 0;
+
+ PFS_rwlock *rwlock= reinterpret_cast<PFS_rwlock *> (state->m_rwlock);
+ DBUG_ASSERT(rwlock != NULL);
+
+ if (state->m_flags & STATE_FLAG_TIMED)
+ {
+ timer_end= state->m_timer();
+ wait_time= timer_end - state->m_timer_start;
+ /* Aggregate to EVENTS_WAITS_SUMMARY_BY_INSTANCE (timed) */
+ rwlock->m_rwlock_stat.m_wait_stat.aggregate_value(wait_time);
+ }
+ else
+ {
+ /* Aggregate to EVENTS_WAITS_SUMMARY_BY_INSTANCE (counted) */
+ rwlock->m_rwlock_stat.m_wait_stat.aggregate_counted();
+ }
+
+ if (rc == 0)
+ {
+ /*
+ Warning:
+ Multiple threads can execute this section concurrently
+ (since multiple readers can execute in parallel).
+ The statistics generated are not safe, which is why they are
+ just statistics, not facts.
+ */
+ if (rwlock->m_readers == 0)
+ rwlock->m_last_read= timer_end;
+ rwlock->m_writer= NULL;
+ rwlock->m_readers++;
+ }
+
+ if (state->m_flags & STATE_FLAG_THREAD)
+ {
+ PFS_thread *thread= reinterpret_cast<PFS_thread *> (state->m_thread);
+ DBUG_ASSERT(thread != NULL);
+
+ PFS_single_stat *event_name_array;
+ event_name_array= thread->write_instr_class_waits_stats();
+ uint index= rwlock->m_class->m_event_name_index;
+
+ if (state->m_flags & STATE_FLAG_TIMED)
+ {
+ /* Aggregate to EVENTS_WAITS_SUMMARY_BY_THREAD_BY_EVENT_NAME (timed) */
+ event_name_array[index].aggregate_value(wait_time);
+ }
+ else
+ {
+ /* Aggregate to EVENTS_WAITS_SUMMARY_BY_THREAD_BY_EVENT_NAME (counted) */
+ event_name_array[index].aggregate_counted();
+ }
+
+ if (state->m_flags & STATE_FLAG_EVENT)
+ {
+ PFS_events_waits *wait= reinterpret_cast<PFS_events_waits*> (state->m_wait);
+ DBUG_ASSERT(wait != NULL);
+
+ wait->m_timer_end= timer_end;
+ wait->m_end_event_id= thread->m_event_id;
+ if (thread->m_flag_events_waits_history)
+ insert_events_waits_history(thread, wait);
+ if (thread->m_flag_events_waits_history_long)
+ insert_events_waits_history_long(wait);
+ thread->m_events_waits_current--;
+
+ DBUG_ASSERT(wait == thread->m_events_waits_current);
+ }
+ }
+}
+
+/**
+ Implementation of the rwlock instrumentation interface.
+ @sa PSI_v1::end_rwlock_wrwait.
+*/
+void pfs_end_rwlock_wrwait_v1(PSI_rwlock_locker* locker, int rc)
+{
+ PSI_rwlock_locker_state *state= reinterpret_cast<PSI_rwlock_locker_state*> (locker);
+ DBUG_ASSERT(state != NULL);
+
+ ulonglong timer_end= 0;
+ ulonglong wait_time= 0;
+
+ PFS_rwlock *rwlock= reinterpret_cast<PFS_rwlock *> (state->m_rwlock);
+ DBUG_ASSERT(rwlock != NULL);
+ PFS_thread *thread= reinterpret_cast<PFS_thread *> (state->m_thread);
+
+ if (state->m_flags & STATE_FLAG_TIMED)
+ {
+ timer_end= state->m_timer();
+ wait_time= timer_end - state->m_timer_start;
+ /* Aggregate to EVENTS_WAITS_SUMMARY_BY_INSTANCE (timed) */
+ rwlock->m_rwlock_stat.m_wait_stat.aggregate_value(wait_time);
+ }
+ else
+ {
+ /* Aggregate to EVENTS_WAITS_SUMMARY_BY_INSTANCE (counted) */
+ rwlock->m_rwlock_stat.m_wait_stat.aggregate_counted();
+ }
+
+ if (likely(rc == 0))
+ {
+ /* Thread safe : we are protected by the instrumented rwlock */
+ rwlock->m_writer= thread;
+ rwlock->m_last_written= timer_end;
+
+ if ((state->m_operation != PSI_RWLOCK_SHAREDEXCLUSIVELOCK) &&
+ (state->m_operation != PSI_RWLOCK_TRYSHAREDEXCLUSIVELOCK))
+ {
+ /* Reset the readers stats, they could be off */
+ rwlock->m_readers= 0;
+ rwlock->m_last_read= 0;
+ }
+ }
+
+ if (state->m_flags & STATE_FLAG_THREAD)
+ {
+ PFS_single_stat *event_name_array;
+ event_name_array= thread->write_instr_class_waits_stats();
+ uint index= rwlock->m_class->m_event_name_index;
+
+ if (state->m_flags & STATE_FLAG_TIMED)
+ {
+ /* Aggregate to EVENTS_WAITS_SUMMARY_BY_THREAD_BY_EVENT_NAME (timed) */
+ event_name_array[index].aggregate_value(wait_time);
+ }
+ else
+ {
+ /* Aggregate to EVENTS_WAITS_SUMMARY_BY_THREAD_BY_EVENT_NAME (counted) */
+ event_name_array[index].aggregate_counted();
+ }
+
+ if (state->m_flags & STATE_FLAG_EVENT)
+ {
+ PFS_events_waits *wait= reinterpret_cast<PFS_events_waits*> (state->m_wait);
+ DBUG_ASSERT(wait != NULL);
+
+ wait->m_timer_end= timer_end;
+ wait->m_end_event_id= thread->m_event_id;
+ if (thread->m_flag_events_waits_history)
+ insert_events_waits_history(thread, wait);
+ if (thread->m_flag_events_waits_history_long)
+ insert_events_waits_history_long(wait);
+ thread->m_events_waits_current--;
+
+ DBUG_ASSERT(wait == thread->m_events_waits_current);
+ }
+ }
+}
+
+/**
+ Implementation of the cond instrumentation interface.
+ @sa PSI_v1::end_cond_wait.
+*/
+void pfs_end_cond_wait_v1(PSI_cond_locker* locker, int rc)
+{
+ PSI_cond_locker_state *state= reinterpret_cast<PSI_cond_locker_state*> (locker);
+ DBUG_ASSERT(state != NULL);
+
+ ulonglong timer_end= 0;
+ ulonglong wait_time= 0;
+
+ PFS_cond *cond= reinterpret_cast<PFS_cond *> (state->m_cond);
+ /* PFS_mutex *mutex= reinterpret_cast<PFS_mutex *> (state->m_mutex); */
+
+ if (state->m_flags & STATE_FLAG_TIMED)
+ {
+ timer_end= state->m_timer();
+ wait_time= timer_end - state->m_timer_start;
+ /* Aggregate to EVENTS_WAITS_SUMMARY_BY_INSTANCE (timed) */
+ cond->m_cond_stat.m_wait_stat.aggregate_value(wait_time);
+ }
+ else
+ {
+ /* Aggregate to EVENTS_WAITS_SUMMARY_BY_INSTANCE (counted) */
+ cond->m_cond_stat.m_wait_stat.aggregate_counted();
+ }
+
+ if (state->m_flags & STATE_FLAG_THREAD)
+ {
+ PFS_thread *thread= reinterpret_cast<PFS_thread *> (state->m_thread);
+ DBUG_ASSERT(thread != NULL);
+
+ PFS_single_stat *event_name_array;
+ event_name_array= thread->write_instr_class_waits_stats();
+ uint index= cond->m_class->m_event_name_index;
+
+ if (state->m_flags & STATE_FLAG_TIMED)
+ {
+ /* Aggregate to EVENTS_WAITS_SUMMARY_BY_THREAD_BY_EVENT_NAME (timed) */
+ event_name_array[index].aggregate_value(wait_time);
+ }
+ else
+ {
+ /* Aggregate to EVENTS_WAITS_SUMMARY_BY_THREAD_BY_EVENT_NAME (counted) */
+ event_name_array[index].aggregate_counted();
+ }
+
+ if (state->m_flags & STATE_FLAG_EVENT)
+ {
+ PFS_events_waits *wait= reinterpret_cast<PFS_events_waits*> (state->m_wait);
+ DBUG_ASSERT(wait != NULL);
+
+ wait->m_timer_end= timer_end;
+ wait->m_end_event_id= thread->m_event_id;
+ if (thread->m_flag_events_waits_history)
+ insert_events_waits_history(thread, wait);
+ if (thread->m_flag_events_waits_history_long)
+ insert_events_waits_history_long(wait);
+ thread->m_events_waits_current--;
+
+ DBUG_ASSERT(wait == thread->m_events_waits_current);
+ }
+ }
+}
+
+/**
+ Implementation of the table instrumentation interface.
+ @sa PSI_v1::end_table_io_wait.
+*/
+void pfs_end_table_io_wait_v1(PSI_table_locker* locker, ulonglong numrows)
+{
+ PSI_table_locker_state *state= reinterpret_cast<PSI_table_locker_state*> (locker);
+ DBUG_ASSERT(state != NULL);
+
+ ulonglong timer_end= 0;
+ ulonglong wait_time= 0;
+
+ PFS_table *table= reinterpret_cast<PFS_table *> (state->m_table);
+ DBUG_ASSERT(table != NULL);
+
+ PFS_single_stat *stat;
+ PFS_table_io_stat *table_io_stat;
+
+ DBUG_ASSERT((state->m_index < table->m_share->m_key_count) ||
+ (state->m_index == MAX_INDEXES));
+
+ table_io_stat= & table->m_table_stat.m_index_stat[state->m_index];
+ table_io_stat->m_has_data= true;
+
+ switch (state->m_io_operation)
+ {
+ case PSI_TABLE_FETCH_ROW:
+ stat= & table_io_stat->m_fetch;
+ break;
+ case PSI_TABLE_WRITE_ROW:
+ stat= & table_io_stat->m_insert;
+ break;
+ case PSI_TABLE_UPDATE_ROW:
+ stat= & table_io_stat->m_update;
+ break;
+ case PSI_TABLE_DELETE_ROW:
+ stat= & table_io_stat->m_delete;
+ break;
+ default:
+ DBUG_ASSERT(false);
+ stat= NULL;
+ break;
+ }
+
+ uint flags= state->m_flags;
+
+ if (flags & STATE_FLAG_TIMED)
+ {
+ timer_end= state->m_timer();
+ wait_time= timer_end - state->m_timer_start;
+ stat->aggregate_many_value(wait_time, numrows);
+ }
+ else
+ {
+ stat->aggregate_counted(numrows);
+ }
+
+ if (flags & STATE_FLAG_THREAD)
+ {
+ PFS_thread *thread= reinterpret_cast<PFS_thread *> (state->m_thread);
+ DBUG_ASSERT(thread != NULL);
+
+ PFS_single_stat *event_name_array;
+ event_name_array= thread->write_instr_class_waits_stats();
+
+ /*
+ Aggregate to EVENTS_WAITS_SUMMARY_BY_THREAD_BY_EVENT_NAME
+ (for wait/io/table/sql/handler)
+ */
+ if (flags & STATE_FLAG_TIMED)
+ {
+ event_name_array[GLOBAL_TABLE_IO_EVENT_INDEX].aggregate_many_value(wait_time, numrows);
+ }
+ else
+ {
+ event_name_array[GLOBAL_TABLE_IO_EVENT_INDEX].aggregate_counted(numrows);
+ }
+
+ if (flags & STATE_FLAG_EVENT)
+ {
+ PFS_events_waits *wait= reinterpret_cast<PFS_events_waits*> (state->m_wait);
+ DBUG_ASSERT(wait != NULL);
+
+ wait->m_timer_end= timer_end;
+ wait->m_end_event_id= thread->m_event_id;
+ wait->m_number_of_bytes= static_cast<size_t>(numrows);
+ if (thread->m_flag_events_waits_history)
+ insert_events_waits_history(thread, wait);
+ if (thread->m_flag_events_waits_history_long)
+ insert_events_waits_history_long(wait);
+ thread->m_events_waits_current--;
+
+ DBUG_ASSERT(wait == thread->m_events_waits_current);
+ }
+ }
+
+ table->m_has_io_stats= true;
+}
+
+/**
+ Implementation of the table instrumentation interface.
+ @sa PSI_v1::end_table_lock_wait.
+*/
+void pfs_end_table_lock_wait_v1(PSI_table_locker* locker)
+{
+ PSI_table_locker_state *state= reinterpret_cast<PSI_table_locker_state*> (locker);
+ DBUG_ASSERT(state != NULL);
+
+ ulonglong timer_end= 0;
+ ulonglong wait_time= 0;
+
+ PFS_table *table= reinterpret_cast<PFS_table *> (state->m_table);
+ DBUG_ASSERT(table != NULL);
+
+ PFS_single_stat *stat= & table->m_table_stat.m_lock_stat.m_stat[state->m_index];
+
+ uint flags= state->m_flags;
+
+ if (flags & STATE_FLAG_TIMED)
+ {
+ timer_end= state->m_timer();
+ wait_time= timer_end - state->m_timer_start;
+ stat->aggregate_value(wait_time);
+ }
+ else
+ {
+ stat->aggregate_counted();
+ }
+
+ if (flags & STATE_FLAG_THREAD)
+ {
+ PFS_thread *thread= reinterpret_cast<PFS_thread *> (state->m_thread);
+ DBUG_ASSERT(thread != NULL);
+
+ PFS_single_stat *event_name_array;
+ event_name_array= thread->write_instr_class_waits_stats();
+
+ /*
+ Aggregate to EVENTS_WAITS_SUMMARY_BY_THREAD_BY_EVENT_NAME
+ (for wait/lock/table/sql/handler)
+ */
+ if (flags & STATE_FLAG_TIMED)
+ {
+ event_name_array[GLOBAL_TABLE_LOCK_EVENT_INDEX].aggregate_value(wait_time);
+ }
+ else
+ {
+ event_name_array[GLOBAL_TABLE_LOCK_EVENT_INDEX].aggregate_counted();
+ }
+
+ if (flags & STATE_FLAG_EVENT)
+ {
+ PFS_events_waits *wait= reinterpret_cast<PFS_events_waits*> (state->m_wait);
+ DBUG_ASSERT(wait != NULL);
+
+ wait->m_timer_end= timer_end;
+ wait->m_end_event_id= thread->m_event_id;
+ if (thread->m_flag_events_waits_history)
+ insert_events_waits_history(thread, wait);
+ if (thread->m_flag_events_waits_history_long)
+ insert_events_waits_history_long(wait);
+ thread->m_events_waits_current--;
+
+ DBUG_ASSERT(wait == thread->m_events_waits_current);
+ }
+ }
+
+ table->m_has_lock_stats= true;
+}
+
+void pfs_start_file_wait_v1(PSI_file_locker *locker,
+ size_t count,
+ const char *src_file,
+ uint src_line);
+
+void pfs_end_file_wait_v1(PSI_file_locker *locker,
+ size_t count);
+
+/**
+ Implementation of the file instrumentation interface.
+ @sa PSI_v1::start_file_open_wait.
+*/
+void pfs_start_file_open_wait_v1(PSI_file_locker *locker,
+ const char *src_file,
+ uint src_line)
+{
+ pfs_start_file_wait_v1(locker, 0, src_file, src_line);
+
+ return;
+}
+
+/**
+ Implementation of the file instrumentation interface.
+ @sa PSI_v1::end_file_open_wait.
+*/
+PSI_file*
+pfs_end_file_open_wait_v1(PSI_file_locker *locker,
+ void *result)
+{
+ PSI_file_locker_state *state= reinterpret_cast<PSI_file_locker_state*> (locker);
+ DBUG_ASSERT(state != NULL);
+
+ switch (state->m_operation)
+ {
+ case PSI_FILE_STAT:
+ case PSI_FILE_RENAME:
+ break;
+ case PSI_FILE_STREAM_OPEN:
+ case PSI_FILE_CREATE:
+ case PSI_FILE_OPEN:
+ if (result != NULL)
+ {
+ PFS_file_class *klass= reinterpret_cast<PFS_file_class*> (state->m_class);
+ PFS_thread *thread= reinterpret_cast<PFS_thread*> (state->m_thread);
+ const char *name= state->m_name;
+ uint len= (uint)strlen(name);
+ PFS_file *pfs_file= find_or_create_file(thread, klass, name, len, true);
+ state->m_file= reinterpret_cast<PSI_file*> (pfs_file);
+ }
+ break;
+ default:
+ DBUG_ASSERT(false);
+ break;
+ }
+
+ pfs_end_file_wait_v1(locker, 0);
+
+ return state->m_file;
+}
+
+/**
+ Implementation of the file instrumentation interface.
+ @sa PSI_v1::end_file_open_wait_and_bind_to_descriptor.
+*/
+void pfs_end_file_open_wait_and_bind_to_descriptor_v1
+ (PSI_file_locker *locker, File file)
+{
+ PFS_file *pfs_file= NULL;
+ int index= (int) file;
+ PSI_file_locker_state *state= reinterpret_cast<PSI_file_locker_state*> (locker);
+ DBUG_ASSERT(state != NULL);
+
+ if (index >= 0)
+ {
+ PFS_file_class *klass= reinterpret_cast<PFS_file_class*> (state->m_class);
+ PFS_thread *thread= reinterpret_cast<PFS_thread*> (state->m_thread);
+ const char *name= state->m_name;
+ uint len= (uint)strlen(name);
+ pfs_file= find_or_create_file(thread, klass, name, len, true);
+ state->m_file= reinterpret_cast<PSI_file*> (pfs_file);
+ }
+
+ pfs_end_file_wait_v1(locker, 0);
+
+ if (likely(index >= 0))
+ {
+ if (likely(index < file_handle_max))
+ file_handle_array[index]= pfs_file;
+ else
+ {
+ if (pfs_file != NULL)
+ release_file(pfs_file);
+ file_handle_lost++;
+ }
+ }
+}
+
+/**
+ Implementation of the file instrumentation interface.
+ @sa PSI_v1::end_temp_file_open_wait_and_bind_to_descriptor.
+*/
+void pfs_end_temp_file_open_wait_and_bind_to_descriptor_v1
+ (PSI_file_locker *locker, File file, const char *filename)
+{
+ DBUG_ASSERT(filename != NULL);
+ PSI_file_locker_state *state= reinterpret_cast<PSI_file_locker_state*> (locker);
+ DBUG_ASSERT(state != NULL);
+
+ /* Set filename that was generated during creation of temporary file. */
+ state->m_name= filename;
+ pfs_end_file_open_wait_and_bind_to_descriptor_v1(locker, file);
+
+ PFS_file *pfs_file= reinterpret_cast<PFS_file *> (state->m_file);
+ if (pfs_file != NULL)
+ {
+ pfs_file->m_temporary= true;
+ }
+}
+
+
+/**
+ Implementation of the file instrumentation interface.
+ @sa PSI_v1::start_file_wait.
+*/
+void pfs_start_file_wait_v1(PSI_file_locker *locker,
+ size_t count,
+ const char *src_file,
+ uint src_line)
+{
+ ulonglong timer_start= 0;
+ PSI_file_locker_state *state= reinterpret_cast<PSI_file_locker_state*> (locker);
+ DBUG_ASSERT(state != NULL);
+
+ uint flags= state->m_flags;
+
+ if (flags & STATE_FLAG_TIMED)
+ {
+ timer_start= get_timer_raw_value_and_function(wait_timer, & state->m_timer);
+ state->m_timer_start= timer_start;
+ }
+
+ if (flags & STATE_FLAG_EVENT)
+ {
+ PFS_events_waits *wait= reinterpret_cast<PFS_events_waits*> (state->m_wait);
+ DBUG_ASSERT(wait != NULL);
+
+ wait->m_timer_start= timer_start;
+ wait->m_source_file= src_file;
+ wait->m_source_line= src_line;
+ wait->m_number_of_bytes= count;
+ }
+}
+
+/**
+ Implementation of the file instrumentation interface.
+ @sa PSI_v1::end_file_wait.
+*/
+void pfs_end_file_wait_v1(PSI_file_locker *locker,
+ size_t byte_count)
+{
+ PSI_file_locker_state *state= reinterpret_cast<PSI_file_locker_state*> (locker);
+ DBUG_ASSERT(state != NULL);
+ PFS_file *file= reinterpret_cast<PFS_file *> (state->m_file);
+ PFS_file_class *klass= reinterpret_cast<PFS_file_class *> (state->m_class);
+ PFS_thread *thread= reinterpret_cast<PFS_thread *> (state->m_thread);
+
+ ulonglong timer_end= 0;
+ ulonglong wait_time= 0;
+ PFS_byte_stat *byte_stat;
+ uint flags= state->m_flags;
+ size_t bytes= ((int)byte_count > -1 ? byte_count : 0);
+
+ PFS_file_stat *file_stat;
+
+ if (file != NULL)
+ {
+ file_stat= & file->m_file_stat;
+ }
+ else
+ {
+ file_stat= & klass->m_file_stat;
+ }
+
+ switch (state->m_operation)
+ {
+ /* Group read operations */
+ case PSI_FILE_READ:
+ byte_stat= &file_stat->m_io_stat.m_read;
+ break;
+ /* Group write operations */
+ case PSI_FILE_WRITE:
+ byte_stat= &file_stat->m_io_stat.m_write;
+ break;
+ /* Group remaining operations as miscellaneous */
+ case PSI_FILE_CREATE:
+ case PSI_FILE_CREATE_TMP:
+ case PSI_FILE_OPEN:
+ case PSI_FILE_STREAM_OPEN:
+ case PSI_FILE_STREAM_CLOSE:
+ case PSI_FILE_SEEK:
+ case PSI_FILE_TELL:
+ case PSI_FILE_FLUSH:
+ case PSI_FILE_FSTAT:
+ case PSI_FILE_CHSIZE:
+ case PSI_FILE_DELETE:
+ case PSI_FILE_RENAME:
+ case PSI_FILE_SYNC:
+ case PSI_FILE_STAT:
+ case PSI_FILE_CLOSE:
+ byte_stat= &file_stat->m_io_stat.m_misc;
+ break;
+ default:
+ DBUG_ASSERT(false);
+ byte_stat= NULL;
+ break;
+ }
+
+ /* Aggregation for EVENTS_WAITS_SUMMARY_BY_INSTANCE */
+ if (flags & STATE_FLAG_TIMED)
+ {
+ timer_end= state->m_timer();
+ wait_time= timer_end - state->m_timer_start;
+ /* Aggregate to EVENTS_WAITS_SUMMARY_BY_INSTANCE (timed) */
+ byte_stat->aggregate(wait_time, bytes);
+ }
+ else
+ {
+ /* Aggregate to EVENTS_WAITS_SUMMARY_BY_INSTANCE (counted) */
+ byte_stat->aggregate_counted(bytes);
+ }
+
+ if (flags & STATE_FLAG_THREAD)
+ {
+ DBUG_ASSERT(thread != NULL);
+
+ PFS_single_stat *event_name_array;
+ event_name_array= thread->write_instr_class_waits_stats();
+ uint index= klass->m_event_name_index;
+
+ if (flags & STATE_FLAG_TIMED)
+ {
+ /* Aggregate to EVENTS_WAITS_SUMMARY_BY_THREAD_BY_EVENT_NAME (timed) */
+ event_name_array[index].aggregate_value(wait_time);
+ }
+ else
+ {
+ /* Aggregate to EVENTS_WAITS_SUMMARY_BY_THREAD_BY_EVENT_NAME (counted) */
+ event_name_array[index].aggregate_counted();
+ }
+
+ if (state->m_flags & STATE_FLAG_EVENT)
+ {
+ PFS_events_waits *wait= reinterpret_cast<PFS_events_waits*> (state->m_wait);
+ DBUG_ASSERT(wait != NULL);
+
+ wait->m_timer_end= timer_end;
+ wait->m_number_of_bytes= bytes;
+ wait->m_end_event_id= thread->m_event_id;
+ wait->m_object_instance_addr= file;
+ wait->m_weak_file= file;
+ wait->m_weak_version= (file ? file->get_version() : 0);
+
+ if (thread->m_flag_events_waits_history)
+ insert_events_waits_history(thread, wait);
+ if (thread->m_flag_events_waits_history_long)
+ insert_events_waits_history_long(wait);
+ thread->m_events_waits_current--;
+
+ DBUG_ASSERT(wait == thread->m_events_waits_current);
+ }
+ }
+}
+
+/**
+ Implementation of the file instrumentation interface.
+ @sa PSI_v1::start_file_close_wait.
+*/
+void pfs_start_file_close_wait_v1(PSI_file_locker *locker,
+ const char *src_file,
+ uint src_line)
+{
+ PFS_thread *thread;
+ const char *name;
+ uint len;
+ PFS_file *pfs_file;
+ PSI_file_locker_state *state= reinterpret_cast<PSI_file_locker_state*> (locker);
+ DBUG_ASSERT(state != NULL);
+
+ switch (state->m_operation)
+ {
+ case PSI_FILE_DELETE:
+ thread= reinterpret_cast<PFS_thread*> (state->m_thread);
+ name= state->m_name;
+ len= (uint)strlen(name);
+ pfs_file= find_or_create_file(thread, NULL, name, len, false);
+ state->m_file= reinterpret_cast<PSI_file*> (pfs_file);
+ break;
+ case PSI_FILE_STREAM_CLOSE:
+ case PSI_FILE_CLOSE:
+ break;
+ default:
+ DBUG_ASSERT(false);
+ break;
+ }
+
+ pfs_start_file_wait_v1(locker, 0, src_file, src_line);
+
+ return;
+}
+
+/**
+ Implementation of the file instrumentation interface.
+ @sa PSI_v1::end_file_close_wait.
+*/
+void pfs_end_file_close_wait_v1(PSI_file_locker *locker, int rc)
+{
+ PSI_file_locker_state *state= reinterpret_cast<PSI_file_locker_state*> (locker);
+ DBUG_ASSERT(state != NULL);
+
+ pfs_end_file_wait_v1(locker, 0);
+
+ if (rc == 0)
+ {
+ PFS_thread *thread= reinterpret_cast<PFS_thread*> (state->m_thread);
+ PFS_file *file= reinterpret_cast<PFS_file*> (state->m_file);
+
+ /* Release or destroy the file if necessary */
+ switch(state->m_operation)
+ {
+ case PSI_FILE_CLOSE:
+ if (file != NULL)
+ {
+ if (file->m_temporary)
+ {
+ DBUG_ASSERT(file->m_file_stat.m_open_count <= 1);
+ destroy_file(thread, file);
+ }
+ else
+ release_file(file);
+ }
+ break;
+ case PSI_FILE_STREAM_CLOSE:
+ if (file != NULL)
+ release_file(file);
+ break;
+ case PSI_FILE_DELETE:
+ if (file != NULL)
+ destroy_file(thread, file);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ break;
+ }
+ }
+ return;
+}
+
+/**
+ Implementation of the file instrumentation interface.
+ @sa PSI_v1::end_file_rename_wait.
+*/
+void pfs_end_file_rename_wait_v1(PSI_file_locker *locker, const char *old_name,
+ const char *new_name, int rc)
+{
+ PSI_file_locker_state *state= reinterpret_cast<PSI_file_locker_state*> (locker);
+ DBUG_ASSERT(state != NULL);
+ DBUG_ASSERT(state->m_operation == PSI_FILE_RENAME);
+
+ if (rc == 0)
+ {
+ PFS_thread *thread= reinterpret_cast<PFS_thread *> (state->m_thread);
+
+ uint old_len= (uint)strlen(old_name);
+ uint new_len= (uint)strlen(new_name);
+
+ find_and_rename_file(thread, old_name, old_len, new_name, new_len);
+ }
+
+ pfs_end_file_wait_v1(locker, 0);
+ return;
+}
+
+PSI_stage_progress*
+pfs_start_stage_v1(PSI_stage_key key, const char *src_file, int src_line)
+{
+ ulonglong timer_value= 0;
+
+ PFS_thread *pfs_thread= my_thread_get_THR_PFS();
+ if (unlikely(pfs_thread == NULL))
+ return NULL;
+
+ /* Always update column threads.processlist_state. */
+ pfs_thread->m_stage= key;
+ /* Default value when the stage is not instrumented for progress */
+ pfs_thread->m_stage_progress= NULL;
+
+ if (psi_unlikely(! flag_global_instrumentation))
+ return NULL;
+
+ if (flag_thread_instrumentation && ! pfs_thread->m_enabled)
+ return NULL;
+
+ PFS_events_stages *pfs= & pfs_thread->m_stage_current;
+ PFS_events_waits *child_wait= & pfs_thread->m_events_waits_stack[0];
+ PFS_events_statements *parent_statement= & pfs_thread->m_statement_stack[0];
+
+ PFS_instr_class *old_class= pfs->m_class;
+ if (old_class != NULL)
+ {
+ PFS_stage_stat *event_name_array;
+ event_name_array= pfs_thread->write_instr_class_stages_stats();
+ uint index= old_class->m_event_name_index;
+
+ /* Finish old event */
+ if (old_class->m_timed)
+ {
+ timer_value= get_timer_raw_value(stage_timer);;
+ pfs->m_timer_end= timer_value;
+
+ /* Aggregate to EVENTS_STAGES_SUMMARY_BY_THREAD_BY_EVENT_NAME (timed) */
+ ulonglong stage_time= timer_value - pfs->m_timer_start;
+ event_name_array[index].aggregate_value(stage_time);
+ }
+ else
+ {
+ /* Aggregate to EVENTS_STAGES_SUMMARY_BY_THREAD_BY_EVENT_NAME (counted) */
+ event_name_array[index].aggregate_counted();
+ }
+
+ if (flag_events_stages_current)
+ {
+ pfs->m_end_event_id= pfs_thread->m_event_id;
+ if (pfs_thread->m_flag_events_stages_history)
+ insert_events_stages_history(pfs_thread, pfs);
+ if (pfs_thread->m_flag_events_stages_history_long)
+ insert_events_stages_history_long(pfs);
+ }
+
+ /* This stage event is now complete. */
+ pfs->m_class= NULL;
+
+ /* New waits will now be attached directly to the parent statement. */
+ child_wait->m_event_id= parent_statement->m_event_id;
+ child_wait->m_event_type= parent_statement->m_event_type;
+ /* See below for new stages, that may overwrite this. */
+ }
+
+ /* Start new event */
+
+ PFS_stage_class *new_klass= find_stage_class(key);
+ if (unlikely(new_klass == NULL))
+ return NULL;
+
+ if (! new_klass->m_enabled)
+ return NULL;
+
+ pfs->m_class= new_klass;
+ if (new_klass->m_timed)
+ {
+ /*
+ Do not call the timer again if we have a
+ TIMER_END for the previous stage already.
+ */
+ if (timer_value == 0)
+ timer_value= get_timer_raw_value(stage_timer);
+ pfs->m_timer_start= timer_value;
+ }
+ else
+ pfs->m_timer_start= 0;
+ pfs->m_timer_end= 0;
+
+ if (flag_events_stages_current)
+ {
+ pfs->m_thread_internal_id= pfs_thread->m_thread_internal_id;
+ pfs->m_event_id= pfs_thread->m_event_id++;
+ pfs->m_end_event_id= 0;
+ pfs->m_source_file= src_file;
+ pfs->m_source_line= src_line;
+
+ /* New wait events will have this new stage as parent. */
+ child_wait->m_event_id= pfs->m_event_id;
+ child_wait->m_event_type= EVENT_TYPE_STAGE;
+ }
+
+ if (new_klass->is_progress())
+ {
+ pfs_thread->m_stage_progress= & pfs->m_progress;
+ pfs->m_progress.m_work_completed= 0;
+ pfs->m_progress.m_work_estimated= 0;
+ }
+
+ return pfs_thread->m_stage_progress;
+}
+
+PSI_stage_progress*
+pfs_get_current_stage_progress_v1(void)
+{
+ PFS_thread *pfs_thread= my_thread_get_THR_PFS();
+ if (unlikely(pfs_thread == NULL))
+ return NULL;
+
+ return pfs_thread->m_stage_progress;
+}
+
+void pfs_end_stage_v1()
+{
+ ulonglong timer_value= 0;
+
+ PFS_thread *pfs_thread= my_thread_get_THR_PFS();
+ if (unlikely(pfs_thread == NULL))
+ return;
+
+ pfs_thread->m_stage= 0;
+ pfs_thread->m_stage_progress= NULL;
+
+ if (psi_unlikely(! flag_global_instrumentation))
+ return;
+
+ if (flag_thread_instrumentation && ! pfs_thread->m_enabled)
+ return;
+
+ PFS_events_stages *pfs= & pfs_thread->m_stage_current;
+
+ PFS_instr_class *old_class= pfs->m_class;
+ if (old_class != NULL)
+ {
+ PFS_stage_stat *event_name_array;
+ event_name_array= pfs_thread->write_instr_class_stages_stats();
+ uint index= old_class->m_event_name_index;
+
+ /* Finish old event */
+ if (old_class->m_timed)
+ {
+ timer_value= get_timer_raw_value(stage_timer);;
+ pfs->m_timer_end= timer_value;
+
+ /* Aggregate to EVENTS_STAGES_SUMMARY_BY_THREAD_BY_EVENT_NAME (timed) */
+ ulonglong stage_time= timer_value - pfs->m_timer_start;
+ event_name_array[index].aggregate_value(stage_time);
+ }
+ else
+ {
+ /* Aggregate to EVENTS_STAGES_SUMMARY_BY_THREAD_BY_EVENT_NAME (counted) */
+ event_name_array[index].aggregate_counted();
+ }
+
+ if (flag_events_stages_current)
+ {
+ pfs->m_end_event_id= pfs_thread->m_event_id;
+ if (pfs_thread->m_flag_events_stages_history)
+ insert_events_stages_history(pfs_thread, pfs);
+ if (pfs_thread->m_flag_events_stages_history_long)
+ insert_events_stages_history_long(pfs);
+ }
+
+ /* New waits will now be attached directly to the parent statement. */
+ PFS_events_waits *child_wait= & pfs_thread->m_events_waits_stack[0];
+ PFS_events_statements *parent_statement= & pfs_thread->m_statement_stack[0];
+ child_wait->m_event_id= parent_statement->m_event_id;
+ child_wait->m_event_type= parent_statement->m_event_type;
+
+ /* This stage is completed */
+ pfs->m_class= NULL;
+ }
+}
+
+PSI_statement_locker*
+pfs_get_thread_statement_locker_v1(PSI_statement_locker_state *state,
+ PSI_statement_key key,
+ const void *charset, PSI_sp_share *sp_share)
+{
+ DBUG_ASSERT(state != NULL);
+ DBUG_ASSERT(charset != NULL);
+
+ if (psi_unlikely(! flag_global_instrumentation))
+ return NULL;
+ PFS_statement_class *klass= find_statement_class(key);
+ if (unlikely(klass == NULL))
+ return NULL;
+ if (! klass->m_enabled)
+ return NULL;
+
+ uint flags;
+
+ if (flag_thread_instrumentation)
+ {
+ PFS_thread *pfs_thread= my_thread_get_THR_PFS();
+ if (unlikely(pfs_thread == NULL))
+ return NULL;
+ if (! pfs_thread->m_enabled)
+ return NULL;
+ state->m_thread= reinterpret_cast<PSI_thread *> (pfs_thread);
+ flags= STATE_FLAG_THREAD;
+
+ if (klass->m_timed)
+ flags|= STATE_FLAG_TIMED;
+
+ if (flag_events_statements_current)
+ {
+ ulonglong event_id= pfs_thread->m_event_id++;
+
+ if (pfs_thread->m_events_statements_count >= statement_stack_max)
+ {
+ nested_statement_lost++;
+ return NULL;
+ }
+
+ pfs_dirty_state dirty_state;
+ pfs_thread->m_stmt_lock.allocated_to_dirty(& dirty_state);
+ PFS_events_statements *pfs= & pfs_thread->m_statement_stack[pfs_thread->m_events_statements_count];
+ pfs->m_thread_internal_id= pfs_thread->m_thread_internal_id;
+ pfs->m_event_id= event_id;
+ pfs->m_event_type= EVENT_TYPE_STATEMENT;
+ pfs->m_end_event_id= 0;
+ pfs->m_class= klass;
+ pfs->m_timer_start= 0;
+ pfs->m_timer_end= 0;
+ pfs->m_lock_time= 0;
+ pfs->m_current_schema_name_length= 0;
+ pfs->m_sqltext_length= 0;
+ pfs->m_sqltext_truncated= false;
+ pfs->m_sqltext_cs_number= system_charset_info->number; /* default */
+
+ pfs->m_message_text[0]= '\0';
+ pfs->m_sql_errno= 0;
+ pfs->m_sqlstate[0]= '\0';
+ pfs->m_error_count= 0;
+ pfs->m_warning_count= 0;
+ pfs->m_rows_affected= 0;
+
+ pfs->m_rows_sent= 0;
+ pfs->m_rows_examined= 0;
+ pfs->m_created_tmp_disk_tables= 0;
+ pfs->m_created_tmp_tables= 0;
+ pfs->m_select_full_join= 0;
+ pfs->m_select_full_range_join= 0;
+ pfs->m_select_range= 0;
+ pfs->m_select_range_check= 0;
+ pfs->m_select_scan= 0;
+ pfs->m_sort_merge_passes= 0;
+ pfs->m_sort_range= 0;
+ pfs->m_sort_rows= 0;
+ pfs->m_sort_scan= 0;
+ pfs->m_no_index_used= 0;
+ pfs->m_no_good_index_used= 0;
+ pfs->m_digest_storage.reset();
+
+ /* New stages will have this statement as parent */
+ PFS_events_stages *child_stage= & pfs_thread->m_stage_current;
+ child_stage->m_nesting_event_id= event_id;
+ child_stage->m_nesting_event_type= EVENT_TYPE_STATEMENT;
+
+ /* New waits will have this statement as parent, if no stage is instrumented */
+ PFS_events_waits *child_wait= & pfs_thread->m_events_waits_stack[0];
+ child_wait->m_event_id= event_id;
+ child_wait->m_event_type= EVENT_TYPE_STATEMENT;
+
+ PFS_events_statements *parent_statement= NULL;
+ PFS_events_transactions *parent_transaction= &pfs_thread->m_transaction_current;
+ ulonglong parent_event= 0;
+ enum_event_type parent_type= EVENT_TYPE_STATEMENT;
+ uint parent_level= 0;
+
+ if (pfs_thread->m_events_statements_count > 0)
+ {
+ parent_statement= pfs - 1;
+ parent_event= parent_statement->m_event_id;
+ parent_type= parent_statement->m_event_type;
+ parent_level= parent_statement->m_nesting_event_level + 1;
+ }
+
+ if (parent_transaction->m_state == TRANS_STATE_ACTIVE &&
+ parent_transaction->m_event_id > parent_event)
+ {
+ parent_event= parent_transaction->m_event_id;
+ parent_type= parent_transaction->m_event_type;
+ }
+
+ pfs->m_nesting_event_id= parent_event;
+ pfs->m_nesting_event_type= parent_type;
+ pfs->m_nesting_event_level= parent_level;
+
+ /* Set parent Stored Procedure information for this statement. */
+ if(sp_share)
+ {
+ PFS_program *parent_sp= reinterpret_cast<PFS_program*>(sp_share);
+ pfs->m_sp_type= parent_sp->m_type;
+ memcpy(pfs->m_schema_name, parent_sp->m_schema_name,
+ parent_sp->m_schema_name_length);
+ pfs->m_schema_name_length= parent_sp->m_schema_name_length;
+ memcpy(pfs->m_object_name, parent_sp->m_object_name,
+ parent_sp->m_object_name_length);
+ pfs->m_object_name_length= parent_sp->m_object_name_length;
+ }
+ else
+ {
+ pfs->m_sp_type= NO_OBJECT_TYPE;
+ pfs->m_schema_name_length= 0;
+ pfs->m_object_name_length= 0;
+ }
+
+ state->m_statement= pfs;
+ flags|= STATE_FLAG_EVENT;
+
+ pfs_thread->m_events_statements_count++;
+ pfs_thread->m_stmt_lock.dirty_to_allocated(& dirty_state);
+ }
+ else
+ {
+ state->m_statement= NULL;
+ }
+ }
+ else
+ {
+ state->m_statement= NULL;
+
+ if (klass->m_timed)
+ flags= STATE_FLAG_TIMED;
+ else
+ flags= 0;
+ }
+
+ if (flag_statements_digest)
+ {
+ flags|= STATE_FLAG_DIGEST;
+ }
+
+ state->m_discarded= false;
+ state->m_class= klass;
+ state->m_flags= flags;
+
+ state->m_lock_time= 0;
+ state->m_rows_sent= 0;
+ state->m_rows_examined= 0;
+ state->m_created_tmp_disk_tables= 0;
+ state->m_created_tmp_tables= 0;
+ state->m_select_full_join= 0;
+ state->m_select_full_range_join= 0;
+ state->m_select_range= 0;
+ state->m_select_range_check= 0;
+ state->m_select_scan= 0;
+ state->m_sort_merge_passes= 0;
+ state->m_sort_range= 0;
+ state->m_sort_rows= 0;
+ state->m_sort_scan= 0;
+ state->m_no_index_used= 0;
+ state->m_no_good_index_used= 0;
+
+ state->m_digest= NULL;
+ state->m_cs_number= ((CHARSET_INFO *)charset)->number;
+
+ state->m_schema_name_length= 0;
+ state->m_parent_sp_share= sp_share;
+ state->m_parent_prepared_stmt= NULL;
+
+ return reinterpret_cast<PSI_statement_locker*> (state);
+}
+
+PSI_statement_locker*
+pfs_refine_statement_v1(PSI_statement_locker *locker,
+ PSI_statement_key key)
+{
+ PSI_statement_locker_state *state= reinterpret_cast<PSI_statement_locker_state*> (locker);
+ if (state == NULL)
+ return NULL;
+ DBUG_ASSERT(state->m_class != NULL);
+ PFS_statement_class *klass;
+ /* Only refine statements for mutable instrumentation */
+ klass= reinterpret_cast<PFS_statement_class*> (state->m_class);
+ DBUG_ASSERT(klass->is_mutable());
+ klass= find_statement_class(key);
+
+ uint flags= state->m_flags;
+
+ if (unlikely(klass == NULL) || !klass->m_enabled)
+ {
+ /* pop statement stack */
+ if (flags & STATE_FLAG_THREAD)
+ {
+ PFS_thread *pfs_thread= reinterpret_cast<PFS_thread *> (state->m_thread);
+ DBUG_ASSERT(pfs_thread != NULL);
+ if (pfs_thread->m_events_statements_count > 0)
+ pfs_thread->m_events_statements_count--;
+ }
+
+ state->m_discarded= true;
+ return NULL;
+ }
+
+ if ((flags & STATE_FLAG_TIMED) && ! klass->m_timed)
+ flags= flags & ~STATE_FLAG_TIMED;
+
+ if (flags & STATE_FLAG_EVENT)
+ {
+ PFS_events_statements *pfs= reinterpret_cast<PFS_events_statements*> (state->m_statement);
+ DBUG_ASSERT(pfs != NULL);
+
+ /* mutate EVENTS_STATEMENTS_CURRENT.EVENT_NAME */
+ pfs->m_class= klass;
+ }
+
+ state->m_class= klass;
+ state->m_flags= flags;
+ return reinterpret_cast<PSI_statement_locker*> (state);
+}
+
+void pfs_start_statement_v1(PSI_statement_locker *locker,
+ const char *db, uint db_len,
+ const char *src_file, uint src_line)
+{
+ PSI_statement_locker_state *state= reinterpret_cast<PSI_statement_locker_state*> (locker);
+ DBUG_ASSERT(state != NULL);
+
+ uint flags= state->m_flags;
+ ulonglong timer_start= 0;
+
+ if (flags & STATE_FLAG_TIMED)
+ {
+ timer_start= get_timer_raw_value_and_function(statement_timer, & state->m_timer);
+ state->m_timer_start= timer_start;
+ }
+
+ compile_time_assert(PSI_SCHEMA_NAME_LEN == NAME_LEN);
+ DBUG_ASSERT(db_len <= sizeof(state->m_schema_name));
+
+ if (db_len > 0)
+ memcpy(state->m_schema_name, db, db_len);
+ state->m_schema_name_length= db_len;
+
+ if (flags & STATE_FLAG_EVENT)
+ {
+ PFS_events_statements *pfs= reinterpret_cast<PFS_events_statements*> (state->m_statement);
+ DBUG_ASSERT(pfs != NULL);
+
+ pfs->m_timer_start= timer_start;
+ pfs->m_source_file= src_file;
+ pfs->m_source_line= src_line;
+
+ DBUG_ASSERT(db_len <= sizeof(pfs->m_current_schema_name));
+ if (db_len > 0)
+ memcpy(pfs->m_current_schema_name, db, db_len);
+ pfs->m_current_schema_name_length= db_len;
+ }
+}
+
+void pfs_set_statement_text_v1(PSI_statement_locker *locker,
+ const char *text, uint text_len)
+{
+ PSI_statement_locker_state *state= reinterpret_cast<PSI_statement_locker_state*> (locker);
+ DBUG_ASSERT(state != NULL);
+
+ if (state->m_discarded)
+ return;
+
+ if (state->m_flags & STATE_FLAG_EVENT)
+ {
+ PFS_events_statements *pfs= reinterpret_cast<PFS_events_statements*> (state->m_statement);
+ DBUG_ASSERT(pfs != NULL);
+ if (text_len > pfs_max_sqltext)
+ {
+ text_len= (uint)pfs_max_sqltext;
+ pfs->m_sqltext_truncated= true;
+ }
+ if (text_len)
+ memcpy(pfs->m_sqltext, text, text_len);
+ pfs->m_sqltext_length= text_len;
+ pfs->m_sqltext_cs_number= state->m_cs_number;
+ }
+
+ return;
+}
+
+#define SET_STATEMENT_ATTR_BODY(LOCKER, ATTR, VALUE) \
+ PSI_statement_locker_state *state; \
+ state= reinterpret_cast<PSI_statement_locker_state*> (LOCKER); \
+ if (unlikely(state == NULL)) \
+ return; \
+ if (state->m_discarded) \
+ return; \
+ state->ATTR= VALUE; \
+ if (state->m_flags & STATE_FLAG_EVENT) \
+ { \
+ PFS_events_statements *pfs; \
+ pfs= reinterpret_cast<PFS_events_statements*> (state->m_statement); \
+ DBUG_ASSERT(pfs != NULL); \
+ pfs->ATTR= VALUE; \
+ } \
+ return;
+
+#define INC_STATEMENT_ATTR_BODY(LOCKER, ATTR, VALUE) \
+ PSI_statement_locker_state *state; \
+ state= reinterpret_cast<PSI_statement_locker_state*> (LOCKER); \
+ if (unlikely(state == NULL)) \
+ return; \
+ if (state->m_discarded) \
+ return; \
+ state->ATTR+= VALUE; \
+ if (state->m_flags & STATE_FLAG_EVENT) \
+ { \
+ PFS_events_statements *pfs; \
+ pfs= reinterpret_cast<PFS_events_statements*> (state->m_statement); \
+ DBUG_ASSERT(pfs != NULL); \
+ pfs->ATTR+= VALUE; \
+ } \
+ return;
+
+void pfs_set_statement_lock_time_v1(PSI_statement_locker *locker,
+ ulonglong count)
+{
+ SET_STATEMENT_ATTR_BODY(locker, m_lock_time, count);
+}
+
+void pfs_set_statement_rows_sent_v1(PSI_statement_locker *locker,
+ ulonglong count)
+{
+ SET_STATEMENT_ATTR_BODY(locker, m_rows_sent, count);
+}
+
+void pfs_set_statement_rows_examined_v1(PSI_statement_locker *locker,
+ ulonglong count)
+{
+ SET_STATEMENT_ATTR_BODY(locker, m_rows_examined, count);
+}
+
+void pfs_inc_statement_created_tmp_disk_tables_v1(PSI_statement_locker *locker,
+ ulong count)
+{
+ INC_STATEMENT_ATTR_BODY(locker, m_created_tmp_disk_tables, count);
+}
+
+void pfs_inc_statement_created_tmp_tables_v1(PSI_statement_locker *locker,
+ ulong count)
+{
+ INC_STATEMENT_ATTR_BODY(locker, m_created_tmp_tables, count);
+}
+
+void pfs_inc_statement_select_full_join_v1(PSI_statement_locker *locker,
+ ulong count)
+{
+ INC_STATEMENT_ATTR_BODY(locker, m_select_full_join, count);
+}
+
+void pfs_inc_statement_select_full_range_join_v1(PSI_statement_locker *locker,
+ ulong count)
+{
+ INC_STATEMENT_ATTR_BODY(locker, m_select_full_range_join, count);
+}
+
+void pfs_inc_statement_select_range_v1(PSI_statement_locker *locker,
+ ulong count)
+{
+ INC_STATEMENT_ATTR_BODY(locker, m_select_range, count);
+}
+
+void pfs_inc_statement_select_range_check_v1(PSI_statement_locker *locker,
+ ulong count)
+{
+ INC_STATEMENT_ATTR_BODY(locker, m_select_range_check, count);
+}
+
+void pfs_inc_statement_select_scan_v1(PSI_statement_locker *locker,
+ ulong count)
+{
+ INC_STATEMENT_ATTR_BODY(locker, m_select_scan, count);
+}
+
+void pfs_inc_statement_sort_merge_passes_v1(PSI_statement_locker *locker,
+ ulong count)
+{
+ INC_STATEMENT_ATTR_BODY(locker, m_sort_merge_passes, count);
+}
+
+void pfs_inc_statement_sort_range_v1(PSI_statement_locker *locker,
+ ulong count)
+{
+ INC_STATEMENT_ATTR_BODY(locker, m_sort_range, count);
+}
+
+void pfs_inc_statement_sort_rows_v1(PSI_statement_locker *locker,
+ ulong count)
+{
+ INC_STATEMENT_ATTR_BODY(locker, m_sort_rows, count);
+}
+
+void pfs_inc_statement_sort_scan_v1(PSI_statement_locker *locker,
+ ulong count)
+{
+ INC_STATEMENT_ATTR_BODY(locker, m_sort_scan, count);
+}
+
+void pfs_set_statement_no_index_used_v1(PSI_statement_locker *locker)
+{
+ SET_STATEMENT_ATTR_BODY(locker, m_no_index_used, 1);
+}
+
+void pfs_set_statement_no_good_index_used_v1(PSI_statement_locker *locker)
+{
+ SET_STATEMENT_ATTR_BODY(locker, m_no_good_index_used, 1);
+}
+
+void pfs_end_statement_v1(PSI_statement_locker *locker, void *stmt_da)
+{
+ PSI_statement_locker_state *state= reinterpret_cast<PSI_statement_locker_state*> (locker);
+ Diagnostics_area *da= reinterpret_cast<Diagnostics_area*> (stmt_da);
+ DBUG_ASSERT(state != NULL);
+ DBUG_ASSERT(da != NULL);
+
+ if (state->m_discarded)
+ return;
+
+ PFS_statement_class *klass= reinterpret_cast<PFS_statement_class *> (state->m_class);
+ DBUG_ASSERT(klass != NULL);
+
+ ulonglong timer_end= 0;
+ ulonglong wait_time= 0;
+ uint flags= state->m_flags;
+
+ if (flags & STATE_FLAG_TIMED)
+ {
+ timer_end= state->m_timer();
+ wait_time= timer_end - state->m_timer_start;
+ }
+
+ PFS_statement_stat *event_name_array;
+ uint index= klass->m_event_name_index;
+ PFS_statement_stat *stat;
+
+ /*
+ Capture statement stats by digest.
+ */
+ const sql_digest_storage *digest_storage= NULL;
+ PFS_statement_stat *digest_stat= NULL;
+ PFS_program *pfs_program= NULL;
+ PFS_prepared_stmt *pfs_prepared_stmt= NULL;
+
+ if (flags & STATE_FLAG_THREAD)
+ {
+ PFS_thread *thread= reinterpret_cast<PFS_thread *> (state->m_thread);
+ DBUG_ASSERT(thread != NULL);
+ event_name_array= thread->write_instr_class_statements_stats();
+ /* Aggregate to EVENTS_STATEMENTS_SUMMARY_BY_THREAD_BY_EVENT_NAME */
+ stat= & event_name_array[index];
+
+ if (flags & STATE_FLAG_DIGEST)
+ {
+ digest_storage= state->m_digest;
+
+ if (digest_storage != NULL)
+ {
+ /* Populate PFS_statements_digest_stat with computed digest information.*/
+ digest_stat= find_or_create_digest(thread, digest_storage,
+ state->m_schema_name,
+ state->m_schema_name_length);
+ }
+ }
+
+ if (flags & STATE_FLAG_EVENT)
+ {
+ PFS_events_statements *pfs= reinterpret_cast<PFS_events_statements*> (state->m_statement);
+ DBUG_ASSERT(pfs != NULL);
+
+ pfs_dirty_state dirty_state;
+ thread->m_stmt_lock.allocated_to_dirty(& dirty_state);
+
+ switch(da->status())
+ {
+ case Diagnostics_area::DA_OK_BULK:
+ case Diagnostics_area::DA_EOF_BULK:
+ case Diagnostics_area::DA_EMPTY:
+ break;
+ case Diagnostics_area::DA_OK:
+ memcpy(pfs->m_message_text, da->message(),
+ MYSQL_ERRMSG_SIZE);
+ pfs->m_message_text[MYSQL_ERRMSG_SIZE]= 0;
+ pfs->m_rows_affected= da->affected_rows();
+ pfs->m_warning_count= da->statement_warn_count();
+ memcpy(pfs->m_sqlstate, "00000", SQLSTATE_LENGTH);
+ break;
+ case Diagnostics_area::DA_EOF:
+ pfs->m_warning_count= da->statement_warn_count();
+ break;
+ case Diagnostics_area::DA_ERROR:
+ memcpy(pfs->m_message_text, da->message(),
+ MYSQL_ERRMSG_SIZE);
+ pfs->m_message_text[MYSQL_ERRMSG_SIZE]= 0;
+ pfs->m_sql_errno= da->sql_errno();
+ memcpy(pfs->m_sqlstate, da->get_sqlstate(), SQLSTATE_LENGTH);
+ pfs->m_error_count++;
+ break;
+ case Diagnostics_area::DA_DISABLED:
+ break;
+ }
+
+ pfs->m_timer_end= timer_end;
+ pfs->m_end_event_id= thread->m_event_id;
+
+ if (digest_storage != NULL)
+ {
+ /*
+ The following columns in events_statement_current:
+ - DIGEST,
+ - DIGEST_TEXT
+ are computed from the digest storage.
+ */
+ pfs->m_digest_storage.copy(digest_storage);
+ }
+
+ pfs_program= reinterpret_cast<PFS_program*>(state->m_parent_sp_share);
+ pfs_prepared_stmt= reinterpret_cast<PFS_prepared_stmt*>(state->m_parent_prepared_stmt);
+
+ if (thread->m_flag_events_statements_history)
+ insert_events_statements_history(thread, pfs);
+ if (thread->m_flag_events_statements_history_long)
+ insert_events_statements_history_long(pfs);
+
+ DBUG_ASSERT(thread->m_events_statements_count > 0);
+ thread->m_events_statements_count--;
+ thread->m_stmt_lock.dirty_to_allocated(& dirty_state);
+ }
+ }
+ else
+ {
+ if (flags & STATE_FLAG_DIGEST)
+ {
+ PFS_thread *thread= my_thread_get_THR_PFS();
+
+ /* An instrumented thread is required, for LF_PINS. */
+ if (thread != NULL)
+ {
+ /* Set digest stat. */
+ digest_storage= state->m_digest;
+
+ if (digest_storage != NULL)
+ {
+ /* Populate statements_digest_stat with computed digest information. */
+ digest_stat= find_or_create_digest(thread, digest_storage,
+ state->m_schema_name,
+ state->m_schema_name_length);
+ }
+ }
+ }
+
+ event_name_array= global_instr_class_statements_array;
+ /* Aggregate to EVENTS_STATEMENTS_SUMMARY_GLOBAL_BY_EVENT_NAME */
+ stat= & event_name_array[index];
+ }
+
+ stat->mark_used();
+
+ if (flags & STATE_FLAG_TIMED)
+ {
+ /* Aggregate to EVENTS_STATEMENTS_SUMMARY_..._BY_EVENT_NAME (timed) */
+ stat->aggregate_value(wait_time);
+ }
+ else
+ {
+ /* Aggregate to EVENTS_STATEMENTS_SUMMARY_..._BY_EVENT_NAME (counted) */
+ stat->aggregate_counted();
+ }
+
+ stat->m_lock_time+= state->m_lock_time;
+ stat->m_rows_sent+= state->m_rows_sent;
+ stat->m_rows_examined+= state->m_rows_examined;
+ stat->m_created_tmp_disk_tables+= state->m_created_tmp_disk_tables;
+ stat->m_created_tmp_tables+= state->m_created_tmp_tables;
+ stat->m_select_full_join+= state->m_select_full_join;
+ stat->m_select_full_range_join+= state->m_select_full_range_join;
+ stat->m_select_range+= state->m_select_range;
+ stat->m_select_range_check+= state->m_select_range_check;
+ stat->m_select_scan+= state->m_select_scan;
+ stat->m_sort_merge_passes+= state->m_sort_merge_passes;
+ stat->m_sort_range+= state->m_sort_range;
+ stat->m_sort_rows+= state->m_sort_rows;
+ stat->m_sort_scan+= state->m_sort_scan;
+ stat->m_no_index_used+= state->m_no_index_used;
+ stat->m_no_good_index_used+= state->m_no_good_index_used;
+
+ if (digest_stat != NULL)
+ {
+ digest_stat->mark_used();
+
+ if (flags & STATE_FLAG_TIMED)
+ {
+ digest_stat->aggregate_value(wait_time);
+ }
+ else
+ {
+ digest_stat->aggregate_counted();
+ }
+
+ digest_stat->m_lock_time+= state->m_lock_time;
+ digest_stat->m_rows_sent+= state->m_rows_sent;
+ digest_stat->m_rows_examined+= state->m_rows_examined;
+ digest_stat->m_created_tmp_disk_tables+= state->m_created_tmp_disk_tables;
+ digest_stat->m_created_tmp_tables+= state->m_created_tmp_tables;
+ digest_stat->m_select_full_join+= state->m_select_full_join;
+ digest_stat->m_select_full_range_join+= state->m_select_full_range_join;
+ digest_stat->m_select_range+= state->m_select_range;
+ digest_stat->m_select_range_check+= state->m_select_range_check;
+ digest_stat->m_select_scan+= state->m_select_scan;
+ digest_stat->m_sort_merge_passes+= state->m_sort_merge_passes;
+ digest_stat->m_sort_range+= state->m_sort_range;
+ digest_stat->m_sort_rows+= state->m_sort_rows;
+ digest_stat->m_sort_scan+= state->m_sort_scan;
+ digest_stat->m_no_index_used+= state->m_no_index_used;
+ digest_stat->m_no_good_index_used+= state->m_no_good_index_used;
+ }
+
+ if(pfs_program != NULL)
+ {
+ PFS_statement_stat *sub_stmt_stat= NULL;
+ sub_stmt_stat= &pfs_program->m_stmt_stat;
+ if(sub_stmt_stat != NULL)
+ {
+ sub_stmt_stat->mark_used();
+
+ if (flags & STATE_FLAG_TIMED)
+ {
+ sub_stmt_stat->aggregate_value(wait_time);
+ }
+ else
+ {
+ sub_stmt_stat->aggregate_counted();
+ }
+
+ sub_stmt_stat->m_lock_time+= state->m_lock_time;
+ sub_stmt_stat->m_rows_sent+= state->m_rows_sent;
+ sub_stmt_stat->m_rows_examined+= state->m_rows_examined;
+ sub_stmt_stat->m_created_tmp_disk_tables+= state->m_created_tmp_disk_tables;
+ sub_stmt_stat->m_created_tmp_tables+= state->m_created_tmp_tables;
+ sub_stmt_stat->m_select_full_join+= state->m_select_full_join;
+ sub_stmt_stat->m_select_full_range_join+= state->m_select_full_range_join;
+ sub_stmt_stat->m_select_range+= state->m_select_range;
+ sub_stmt_stat->m_select_range_check+= state->m_select_range_check;
+ sub_stmt_stat->m_select_scan+= state->m_select_scan;
+ sub_stmt_stat->m_sort_merge_passes+= state->m_sort_merge_passes;
+ sub_stmt_stat->m_sort_range+= state->m_sort_range;
+ sub_stmt_stat->m_sort_rows+= state->m_sort_rows;
+ sub_stmt_stat->m_sort_scan+= state->m_sort_scan;
+ sub_stmt_stat->m_no_index_used+= state->m_no_index_used;
+ sub_stmt_stat->m_no_good_index_used+= state->m_no_good_index_used;
+ }
+ }
+
+ if (pfs_prepared_stmt != NULL)
+ {
+ if(state->m_in_prepare)
+ {
+ PFS_single_stat *prepared_stmt_stat= NULL;
+ prepared_stmt_stat= &pfs_prepared_stmt->m_prepare_stat;
+ if(prepared_stmt_stat != NULL)
+ {
+ if (flags & STATE_FLAG_TIMED)
+ {
+ prepared_stmt_stat->aggregate_value(wait_time);
+ }
+ else
+ {
+ prepared_stmt_stat->aggregate_counted();
+ }
+ }
+ }
+ else
+ {
+ PFS_statement_stat *prepared_stmt_stat= NULL;
+ prepared_stmt_stat= &pfs_prepared_stmt->m_execute_stat;
+ if(prepared_stmt_stat != NULL)
+ {
+ if (flags & STATE_FLAG_TIMED)
+ {
+ prepared_stmt_stat->aggregate_value(wait_time);
+ }
+ else
+ {
+ prepared_stmt_stat->aggregate_counted();
+ }
+
+ prepared_stmt_stat->m_lock_time+= state->m_lock_time;
+ prepared_stmt_stat->m_rows_sent+= state->m_rows_sent;
+ prepared_stmt_stat->m_rows_examined+= state->m_rows_examined;
+ prepared_stmt_stat->m_created_tmp_disk_tables+= state->m_created_tmp_disk_tables;
+ prepared_stmt_stat->m_created_tmp_tables+= state->m_created_tmp_tables;
+ prepared_stmt_stat->m_select_full_join+= state->m_select_full_join;
+ prepared_stmt_stat->m_select_full_range_join+= state->m_select_full_range_join;
+ prepared_stmt_stat->m_select_range+= state->m_select_range;
+ prepared_stmt_stat->m_select_range_check+= state->m_select_range_check;
+ prepared_stmt_stat->m_select_scan+= state->m_select_scan;
+ prepared_stmt_stat->m_sort_merge_passes+= state->m_sort_merge_passes;
+ prepared_stmt_stat->m_sort_range+= state->m_sort_range;
+ prepared_stmt_stat->m_sort_rows+= state->m_sort_rows;
+ prepared_stmt_stat->m_sort_scan+= state->m_sort_scan;
+ prepared_stmt_stat->m_no_index_used+= state->m_no_index_used;
+ prepared_stmt_stat->m_no_good_index_used+= state->m_no_good_index_used;
+ }
+ }
+ }
+
+ PFS_statement_stat *sub_stmt_stat= NULL;
+ if (pfs_program != NULL)
+ sub_stmt_stat= &pfs_program->m_stmt_stat;
+
+ PFS_statement_stat *prepared_stmt_stat= NULL;
+ if (pfs_prepared_stmt != NULL && !state->m_in_prepare)
+ prepared_stmt_stat= &pfs_prepared_stmt->m_execute_stat;
+
+ switch (da->status())
+ {
+ case Diagnostics_area::DA_OK_BULK:
+ case Diagnostics_area::DA_EOF_BULK:
+ case Diagnostics_area::DA_EMPTY:
+ break;
+ case Diagnostics_area::DA_OK:
+ stat->m_rows_affected+= da->affected_rows();
+ stat->m_warning_count+= da->statement_warn_count();
+ if (digest_stat != NULL)
+ {
+ digest_stat->m_rows_affected+= da->affected_rows();
+ digest_stat->m_warning_count+= da->statement_warn_count();
+ }
+ if(sub_stmt_stat != NULL)
+ {
+ sub_stmt_stat->m_rows_affected+= da->affected_rows();
+ sub_stmt_stat->m_warning_count+= da->statement_warn_count();
+ }
+ if (prepared_stmt_stat != NULL)
+ {
+ prepared_stmt_stat->m_rows_affected+= da->affected_rows();
+ prepared_stmt_stat->m_warning_count+= da->statement_warn_count();
+ }
+ break;
+ case Diagnostics_area::DA_EOF:
+ stat->m_warning_count+= da->statement_warn_count();
+ if (digest_stat != NULL)
+ {
+ digest_stat->m_warning_count+= da->statement_warn_count();
+ }
+ if(sub_stmt_stat != NULL)
+ {
+ sub_stmt_stat->m_warning_count+= da->statement_warn_count();
+ }
+ if (prepared_stmt_stat != NULL)
+ {
+ prepared_stmt_stat->m_warning_count+= da->statement_warn_count();
+ }
+ break;
+ case Diagnostics_area::DA_ERROR:
+ stat->m_error_count++;
+ if (digest_stat != NULL)
+ {
+ digest_stat->m_error_count++;
+ }
+ if (sub_stmt_stat != NULL)
+ {
+ sub_stmt_stat->m_error_count++;
+ }
+ if (prepared_stmt_stat != NULL)
+ {
+ prepared_stmt_stat->m_error_count++;
+ }
+ break;
+ case Diagnostics_area::DA_DISABLED:
+ break;
+ }
+}
+
+static inline enum_object_type sp_type_to_object_type(uint sp_type)
+{
+ enum enum_sp_type value= static_cast<enum enum_sp_type> (sp_type);
+
+ switch (value)
+ {
+ case SP_TYPE_FUNCTION:
+ return OBJECT_TYPE_FUNCTION;
+ case SP_TYPE_PROCEDURE:
+ return OBJECT_TYPE_PROCEDURE;
+ case SP_TYPE_PACKAGE:
+ return OBJECT_TYPE_PACKAGE;
+ case SP_TYPE_PACKAGE_BODY:
+ return OBJECT_TYPE_PACKAGE_BODY;
+ case SP_TYPE_TRIGGER:
+ return OBJECT_TYPE_TRIGGER;
+ case SP_TYPE_EVENT:
+ return OBJECT_TYPE_EVENT;
+ default:
+ DBUG_ASSERT(false);
+ /* Dead code */
+ return NO_OBJECT_TYPE;
+ }
+}
+
+/**
+ Implementation of the stored program instrumentation interface.
+ @sa PSI_v1::get_sp_share.
+*/
+PSI_sp_share *pfs_get_sp_share_v1(uint sp_type,
+ const char* schema_name,
+ uint schema_name_length,
+ const char* object_name,
+ uint object_name_length)
+{
+
+ PFS_thread *pfs_thread= my_thread_get_THR_PFS();
+ if (unlikely(pfs_thread == NULL))
+ return NULL;
+
+ if (object_name_length > COL_OBJECT_NAME_SIZE)
+ object_name_length= COL_OBJECT_NAME_SIZE;
+ if (schema_name_length > COL_OBJECT_SCHEMA_SIZE)
+ schema_name_length= COL_OBJECT_SCHEMA_SIZE;
+
+ PFS_program *pfs_program;
+ pfs_program= find_or_create_program(pfs_thread,
+ sp_type_to_object_type(sp_type),
+ object_name,
+ object_name_length,
+ schema_name,
+ schema_name_length);
+
+ return reinterpret_cast<PSI_sp_share *>(pfs_program);
+}
+
+void pfs_release_sp_share_v1(PSI_sp_share* sp_share)
+{
+ /* Unused */
+ return;
+}
+
+PSI_sp_locker* pfs_start_sp_v1(PSI_sp_locker_state *state,
+ PSI_sp_share *sp_share)
+{
+ DBUG_ASSERT(state != NULL);
+ if (! flag_global_instrumentation)
+ return NULL;
+
+ if (flag_thread_instrumentation)
+ {
+ PFS_thread *pfs_thread= my_thread_get_THR_PFS();
+ if (unlikely(pfs_thread == NULL))
+ return NULL;
+ if (! pfs_thread->m_enabled)
+ return NULL;
+ }
+
+ /*
+ sp share might be null in case when stat array is full and no new
+ stored program stats are being inserted into it.
+ */
+ PFS_program *pfs_program= reinterpret_cast<PFS_program*>(sp_share);
+ if (pfs_program == NULL || !pfs_program->m_enabled)
+ return NULL;
+
+ state->m_flags= 0;
+
+ if(pfs_program->m_timed)
+ {
+ state->m_flags|= STATE_FLAG_TIMED;
+ state->m_timer_start= get_timer_raw_value_and_function(statement_timer,
+ & state->m_timer);
+ }
+
+ state->m_sp_share= sp_share;
+
+ return reinterpret_cast<PSI_sp_locker*> (state);
+}
+
+void pfs_end_sp_v1(PSI_sp_locker *locker)
+{
+ PSI_sp_locker_state *state= reinterpret_cast<PSI_sp_locker_state*> (locker);
+ DBUG_ASSERT(state != NULL);
+
+ ulonglong timer_end;
+ ulonglong wait_time;
+
+ PFS_program *pfs_program= reinterpret_cast<PFS_program *>(state->m_sp_share);
+ PFS_sp_stat *stat= &pfs_program->m_sp_stat;
+
+ if (state->m_flags & STATE_FLAG_TIMED)
+ {
+ timer_end= state->m_timer();
+ wait_time= timer_end - state->m_timer_start;
+
+ /* Now use this timer_end and wait_time for timing information. */
+ stat->aggregate_value(wait_time);
+ }
+ else
+ {
+ stat->aggregate_counted();
+ }
+}
+
+void pfs_drop_sp_v1(uint sp_type,
+ const char* schema_name,
+ uint schema_name_length,
+ const char* object_name,
+ uint object_name_length)
+{
+ PFS_thread *pfs_thread= my_thread_get_THR_PFS();
+ if (unlikely(pfs_thread == NULL))
+ return;
+
+ if (object_name_length > COL_OBJECT_NAME_SIZE)
+ object_name_length= COL_OBJECT_NAME_SIZE;
+ if (schema_name_length > COL_OBJECT_SCHEMA_SIZE)
+ schema_name_length= COL_OBJECT_SCHEMA_SIZE;
+
+ drop_program(pfs_thread,
+ sp_type_to_object_type(sp_type),
+ object_name, object_name_length,
+ schema_name, schema_name_length);
+}
+
+PSI_transaction_locker*
+pfs_get_thread_transaction_locker_v1(PSI_transaction_locker_state *state,
+ const void *xid,
+ ulonglong trxid,
+ int isolation_level,
+ my_bool read_only,
+ my_bool autocommit)
+{
+ DBUG_ASSERT(state != NULL);
+
+ if (!flag_global_instrumentation)
+ return NULL;
+
+ if (!global_transaction_class.m_enabled)
+ return NULL;
+
+ uint flags;
+
+ if (flag_thread_instrumentation)
+ {
+ PFS_thread *pfs_thread= my_thread_get_THR_PFS();
+ if (unlikely(pfs_thread == NULL))
+ return NULL;
+ if (!pfs_thread->m_enabled)
+ return NULL;
+ state->m_thread= reinterpret_cast<PSI_thread *> (pfs_thread);
+ flags= STATE_FLAG_THREAD;
+
+ if (global_transaction_class.m_timed)
+ flags|= STATE_FLAG_TIMED;
+
+ if (flag_events_transactions_current)
+ {
+ ulonglong event_id= pfs_thread->m_event_id++;
+
+ PFS_events_transactions *pfs= &pfs_thread->m_transaction_current;
+ pfs->m_thread_internal_id = pfs_thread->m_thread_internal_id;
+ pfs->m_event_id= event_id;
+ pfs->m_event_type= EVENT_TYPE_TRANSACTION;
+ pfs->m_end_event_id= 0;
+ pfs->m_class= &global_transaction_class;
+ pfs->m_timer_start= 0;
+ pfs->m_timer_end= 0;
+ if (xid != NULL)
+ pfs->m_xid= *(PSI_xid *)xid;
+ pfs->m_xa= false;
+ pfs->m_xa_state= TRANS_STATE_XA_NOTR;
+ pfs->m_trxid= trxid;
+ pfs->m_isolation_level= (enum_isolation_level)isolation_level;
+ pfs->m_read_only= read_only;
+ pfs->m_autocommit= autocommit;
+ pfs->m_savepoint_count= 0;
+ pfs->m_rollback_to_savepoint_count= 0;
+ pfs->m_release_savepoint_count= 0;
+
+ uint statements_count= pfs_thread->m_events_statements_count;
+ if (statements_count > 0)
+ {
+ PFS_events_statements *pfs_statement=
+ &pfs_thread->m_statement_stack[statements_count - 1];
+ pfs->m_nesting_event_id= pfs_statement->m_event_id;
+ pfs->m_nesting_event_type= pfs_statement->m_event_type;
+ }
+ else
+ {
+ pfs->m_nesting_event_id= 0;
+ /* pfs->m_nesting_event_type not used when m_nesting_event_id is 0 */
+ }
+
+ state->m_transaction= pfs;
+ flags|= STATE_FLAG_EVENT;
+ }
+ }
+ else
+ {
+ if (global_transaction_class.m_timed)
+ flags= STATE_FLAG_TIMED;
+ else
+ flags= 0;
+ }
+
+ state->m_class= &global_transaction_class;
+ state->m_flags= flags;
+ state->m_autocommit= autocommit;
+ state->m_read_only= read_only;
+ state->m_savepoint_count= 0;
+ state->m_rollback_to_savepoint_count= 0;
+ state->m_release_savepoint_count= 0;
+
+ return reinterpret_cast<PSI_transaction_locker*> (state);
+}
+
+void pfs_start_transaction_v1(PSI_transaction_locker *locker,
+ const char *src_file, uint src_line)
+{
+ PSI_transaction_locker_state *state= reinterpret_cast<PSI_transaction_locker_state*> (locker);
+ DBUG_ASSERT(state != NULL);
+
+ uint flags= state->m_flags;
+ ulonglong timer_start= 0;
+
+ if (flags & STATE_FLAG_TIMED)
+ {
+ timer_start= get_timer_raw_value_and_function(transaction_timer, &state->m_timer);
+ state->m_timer_start= timer_start;
+ }
+
+ if (flags & STATE_FLAG_EVENT)
+ {
+ PFS_events_transactions *pfs= reinterpret_cast<PFS_events_transactions*> (state->m_transaction);
+ DBUG_ASSERT(pfs != NULL);
+
+ pfs->m_timer_start= timer_start;
+ pfs->m_source_file= src_file;
+ pfs->m_source_line= src_line;
+ pfs->m_state= TRANS_STATE_ACTIVE;
+ //pfs->m_sid.clear();
+ bzero(&pfs->m_gtid_spec, sizeof(pfs->m_gtid_spec));
+ }
+}
+
+void pfs_set_transaction_gtid_v1(PSI_transaction_locker *locker,
+ const void *sid,
+ const void *gtid_spec)
+{
+ PSI_transaction_locker_state *state= reinterpret_cast<PSI_transaction_locker_state*> (locker);
+ DBUG_ASSERT(state != NULL);
+ DBUG_ASSERT(sid != NULL);
+ DBUG_ASSERT(gtid_spec != NULL);
+
+ if (state->m_flags & STATE_FLAG_EVENT)
+ {
+ PFS_events_transactions *pfs= reinterpret_cast<PFS_events_transactions*> (state->m_transaction);
+ DBUG_ASSERT(pfs != NULL);
+ //pfs->m_sid= *(rpl_sid *)sid;
+ pfs->m_gtid_spec= *(Gtid_specification*)gtid_spec;
+ }
+}
+
+void pfs_set_transaction_xid_v1(PSI_transaction_locker *locker,
+ const void *xid,
+ int xa_state)
+{
+ PSI_transaction_locker_state *state= reinterpret_cast<PSI_transaction_locker_state*> (locker);
+ DBUG_ASSERT(state != NULL);
+
+ if (state->m_flags & STATE_FLAG_EVENT)
+ {
+ PFS_events_transactions *pfs= reinterpret_cast<PFS_events_transactions*> (state->m_transaction);
+ DBUG_ASSERT(pfs != NULL);
+ DBUG_ASSERT(xid != NULL);
+
+ pfs->m_xid= *(PSI_xid *)xid;
+ pfs->m_xa_state= (enum_xa_transaction_state)xa_state;
+ pfs->m_xa= true;
+ }
+ return;
+}
+
+void pfs_set_transaction_xa_state_v1(PSI_transaction_locker *locker,
+ int xa_state)
+{
+ PSI_transaction_locker_state *state= reinterpret_cast<PSI_transaction_locker_state*> (locker);
+ DBUG_ASSERT(state != NULL);
+
+ if (state->m_flags & STATE_FLAG_EVENT)
+ {
+ PFS_events_transactions *pfs= reinterpret_cast<PFS_events_transactions*> (state->m_transaction);
+ DBUG_ASSERT(pfs != NULL);
+
+ pfs->m_xa_state= (enum_xa_transaction_state)xa_state;
+ pfs->m_xa= true;
+ }
+ return;
+}
+
+void pfs_set_transaction_trxid_v1(PSI_transaction_locker *locker,
+ const ulonglong *trxid)
+{
+ DBUG_ASSERT(trxid != NULL);
+
+ PSI_transaction_locker_state *state= reinterpret_cast<PSI_transaction_locker_state*> (locker);
+ DBUG_ASSERT(state != NULL);
+
+ if (state->m_flags & STATE_FLAG_EVENT)
+ {
+ PFS_events_transactions *pfs= reinterpret_cast<PFS_events_transactions*> (state->m_transaction);
+ DBUG_ASSERT(pfs != NULL);
+
+ if (pfs->m_trxid == 0)
+ pfs->m_trxid= *trxid;
+ }
+}
+
+#define INC_TRANSACTION_ATTR_BODY(LOCKER, ATTR, VALUE) \
+ PSI_transaction_locker_state *state; \
+ state= reinterpret_cast<PSI_transaction_locker_state*> (LOCKER); \
+ if (unlikely(state == NULL)) \
+ return; \
+ state->ATTR+= VALUE; \
+ if (state->m_flags & STATE_FLAG_EVENT) \
+ { \
+ PFS_events_transactions *pfs; \
+ pfs= reinterpret_cast<PFS_events_transactions*> (state->m_transaction); \
+ DBUG_ASSERT(pfs != NULL); \
+ pfs->ATTR+= VALUE; \
+ } \
+ return;
+
+
+void pfs_inc_transaction_savepoints_v1(PSI_transaction_locker *locker,
+ ulong count)
+{
+ INC_TRANSACTION_ATTR_BODY(locker, m_savepoint_count, count);
+}
+
+void pfs_inc_transaction_rollback_to_savepoint_v1(PSI_transaction_locker *locker,
+ ulong count)
+{
+ INC_TRANSACTION_ATTR_BODY(locker, m_rollback_to_savepoint_count, count);
+}
+
+void pfs_inc_transaction_release_savepoint_v1(PSI_transaction_locker *locker,
+ ulong count)
+{
+ INC_TRANSACTION_ATTR_BODY(locker, m_release_savepoint_count, count);
+}
+
+void pfs_end_transaction_v1(PSI_transaction_locker *locker, my_bool commit)
+{
+ PSI_transaction_locker_state *state= reinterpret_cast<PSI_transaction_locker_state*> (locker);
+ DBUG_ASSERT(state != NULL);
+
+ ulonglong timer_end= 0;
+ ulonglong wait_time= 0;
+ uint flags= state->m_flags;
+
+ if (flags & STATE_FLAG_TIMED)
+ {
+ timer_end= state->m_timer();
+ wait_time= timer_end - state->m_timer_start;
+ }
+
+ PFS_transaction_stat *stat;
+
+ if (flags & STATE_FLAG_THREAD)
+ {
+ PFS_thread *pfs_thread= reinterpret_cast<PFS_thread *> (state->m_thread);
+ DBUG_ASSERT(pfs_thread != NULL);
+
+ /* Aggregate to EVENTS_TRANSACTIONS_SUMMARY_BY_THREAD_BY_EVENT_NAME */
+ stat= &pfs_thread->write_instr_class_transactions_stats()[GLOBAL_TRANSACTION_INDEX];
+
+ if (flags & STATE_FLAG_EVENT)
+ {
+ PFS_events_transactions *pfs= reinterpret_cast<PFS_events_transactions*> (state->m_transaction);
+ DBUG_ASSERT(pfs != NULL);
+
+ /* events_transactions_current may have been cleared while the transaction was active */
+ if (unlikely(pfs->m_class == NULL))
+ return;
+
+ pfs->m_timer_end= timer_end;
+ pfs->m_end_event_id= pfs_thread->m_event_id;
+
+ pfs->m_state= (commit ? TRANS_STATE_COMMITTED : TRANS_STATE_ROLLED_BACK);
+
+ if (pfs->m_xa)
+ pfs->m_xa_state= (commit ? TRANS_STATE_XA_COMMITTED : TRANS_STATE_XA_ROLLBACK_ONLY);
+
+ if (pfs_thread->m_flag_events_transactions_history)
+ insert_events_transactions_history(pfs_thread, pfs);
+ if (pfs_thread->m_flag_events_transactions_history_long)
+ insert_events_transactions_history_long(pfs);
+ }
+ }
+ else
+ {
+ /* Aggregate to EVENTS_TRANSACTIONS_SUMMARY_GLOBAL_BY_EVENT_NAME */
+ stat= &global_transaction_stat;
+ }
+
+ if (flags & STATE_FLAG_TIMED)
+ {
+ /* Aggregate to EVENTS_TRANSACTIONS_SUMMARY_..._BY_EVENT_NAME (timed) */
+ if(state->m_read_only)
+ stat->m_read_only_stat.aggregate_value(wait_time);
+ else
+ stat->m_read_write_stat.aggregate_value(wait_time);
+ }
+ else
+ {
+ /* Aggregate to EVENTS_TRANSACTIONS_SUMMARY_..._BY_EVENT_NAME (counted) */
+ if(state->m_read_only)
+ stat->m_read_only_stat.aggregate_counted();
+ else
+ stat->m_read_write_stat.aggregate_counted();
+ }
+
+ stat->m_savepoint_count+= state->m_savepoint_count;
+ stat->m_rollback_to_savepoint_count+= state->m_rollback_to_savepoint_count;
+ stat->m_release_savepoint_count+= state->m_release_savepoint_count;
+}
+
+
+/**
+ Implementation of the socket instrumentation interface.
+ @sa PSI_v1::end_socket_wait.
+*/
+void pfs_end_socket_wait_v1(PSI_socket_locker *locker, size_t byte_count)
+{
+ PSI_socket_locker_state *state= reinterpret_cast<PSI_socket_locker_state*> (locker);
+ DBUG_ASSERT(state != NULL);
+
+ PFS_socket *socket= reinterpret_cast<PFS_socket *>(state->m_socket);
+ DBUG_ASSERT(socket != NULL);
+
+ ulonglong timer_end= 0;
+ ulonglong wait_time= 0;
+ PFS_byte_stat *byte_stat;
+ uint flags= state->m_flags;
+ size_t bytes= ((int)byte_count > -1 ? byte_count : 0);
+
+ switch (state->m_operation)
+ {
+ /* Group read operations */
+ case PSI_SOCKET_RECV:
+ case PSI_SOCKET_RECVFROM:
+ case PSI_SOCKET_RECVMSG:
+ byte_stat= &socket->m_socket_stat.m_io_stat.m_read;
+ break;
+ /* Group write operations */
+ case PSI_SOCKET_SEND:
+ case PSI_SOCKET_SENDTO:
+ case PSI_SOCKET_SENDMSG:
+ byte_stat= &socket->m_socket_stat.m_io_stat.m_write;
+ break;
+ /* Group remaining operations as miscellaneous */
+ case PSI_SOCKET_CONNECT:
+ case PSI_SOCKET_CREATE:
+ case PSI_SOCKET_BIND:
+ case PSI_SOCKET_SEEK:
+ case PSI_SOCKET_OPT:
+ case PSI_SOCKET_STAT:
+ case PSI_SOCKET_SHUTDOWN:
+ case PSI_SOCKET_SELECT:
+ case PSI_SOCKET_CLOSE:
+ byte_stat= &socket->m_socket_stat.m_io_stat.m_misc;
+ break;
+ default:
+ DBUG_ASSERT(false);
+ byte_stat= NULL;
+ break;
+ }
+
+ /* Aggregation for EVENTS_WAITS_SUMMARY_BY_INSTANCE */
+ if (flags & STATE_FLAG_TIMED)
+ {
+ timer_end= state->m_timer();
+ wait_time= timer_end - state->m_timer_start;
+
+ /* Aggregate to the socket instrument for now (timed) */
+ byte_stat->aggregate(wait_time, bytes);
+ }
+ else
+ {
+ /* Aggregate to the socket instrument (event count and byte count) */
+ byte_stat->aggregate_counted(bytes);
+ }
+
+ /* Aggregate to EVENTS_WAITS_HISTORY and EVENTS_WAITS_HISTORY_LONG */
+ if (flags & STATE_FLAG_EVENT)
+ {
+ PFS_thread *thread= reinterpret_cast<PFS_thread *>(state->m_thread);
+ DBUG_ASSERT(thread != NULL);
+ PFS_events_waits *wait= reinterpret_cast<PFS_events_waits*> (state->m_wait);
+ DBUG_ASSERT(wait != NULL);
+
+ wait->m_timer_end= timer_end;
+ wait->m_end_event_id= thread->m_event_id;
+ wait->m_number_of_bytes= bytes;
+
+ if (thread->m_flag_events_waits_history)
+ insert_events_waits_history(thread, wait);
+ if (thread->m_flag_events_waits_history_long)
+ insert_events_waits_history_long(wait);
+ thread->m_events_waits_current--;
+
+ DBUG_ASSERT(wait == thread->m_events_waits_current);
+ }
+}
+
+void pfs_set_socket_state_v1(PSI_socket *socket, PSI_socket_state state)
+{
+ DBUG_ASSERT((state == PSI_SOCKET_STATE_IDLE) || (state == PSI_SOCKET_STATE_ACTIVE));
+ PFS_socket *pfs= reinterpret_cast<PFS_socket*>(socket);
+ DBUG_ASSERT(pfs != NULL);
+ DBUG_ASSERT(pfs->m_idle || (state == PSI_SOCKET_STATE_IDLE));
+ DBUG_ASSERT(!pfs->m_idle || (state == PSI_SOCKET_STATE_ACTIVE));
+ pfs->m_idle= (state == PSI_SOCKET_STATE_IDLE);
+}
+
+/**
+ Set socket descriptor and address info.
+*/
+void pfs_set_socket_info_v1(PSI_socket *socket,
+ const my_socket *fd,
+ const struct sockaddr *addr,
+ socklen_t addr_len)
+{
+ PFS_socket *pfs= reinterpret_cast<PFS_socket*>(socket);
+ DBUG_ASSERT(pfs != NULL);
+
+ /** Set socket descriptor */
+ if (fd != NULL)
+ pfs->m_fd= (uint)*fd;
+
+ /** Set raw socket address and length */
+ if (likely(addr != NULL && addr_len > 0))
+ {
+ pfs->m_addr_len= addr_len;
+
+ /** Restrict address length to size of struct */
+ if (unlikely(pfs->m_addr_len > sizeof(sockaddr_storage)))
+ pfs->m_addr_len= sizeof(struct sockaddr_storage);
+
+ memcpy(&pfs->m_sock_addr, addr, pfs->m_addr_len);
+ }
+}
+
+/**
+ Implementation of the socket instrumentation interface.
+ @sa PSI_v1::set_socket_info.
+*/
+void pfs_set_socket_thread_owner_v1(PSI_socket *socket)
+{
+ PFS_socket *pfs_socket= reinterpret_cast<PFS_socket*>(socket);
+ DBUG_ASSERT(pfs_socket != NULL);
+ pfs_socket->m_thread_owner= my_thread_get_THR_PFS();
+}
+
+struct PSI_digest_locker*
+pfs_digest_start_v1(PSI_statement_locker *locker)
+{
+ PSI_statement_locker_state *statement_state;
+ statement_state= reinterpret_cast<PSI_statement_locker_state*> (locker);
+ DBUG_ASSERT(statement_state != NULL);
+
+ if (statement_state->m_discarded)
+ return NULL;
+
+ if (statement_state->m_flags & STATE_FLAG_DIGEST)
+ {
+ return reinterpret_cast<PSI_digest_locker*> (locker);
+ }
+
+ return NULL;
+}
+
+void pfs_digest_end_v1(PSI_digest_locker *locker, const sql_digest_storage *digest)
+{
+ PSI_statement_locker_state *statement_state;
+ statement_state= reinterpret_cast<PSI_statement_locker_state*> (locker);
+ DBUG_ASSERT(statement_state != NULL);
+ DBUG_ASSERT(digest != NULL);
+
+ if (statement_state->m_discarded)
+ return;
+
+ if (statement_state->m_flags & STATE_FLAG_DIGEST)
+ {
+ statement_state->m_digest= digest;
+ }
+}
+
+PSI_prepared_stmt*
+pfs_create_prepared_stmt_v1(void *identity, uint stmt_id,
+ PSI_statement_locker *locker,
+ const char *stmt_name, size_t stmt_name_length)
+{
+ PSI_statement_locker_state *state= reinterpret_cast<PSI_statement_locker_state*> (locker);
+ PFS_events_statements *pfs_stmt= reinterpret_cast<PFS_events_statements*> (state->m_statement);
+ PFS_program *pfs_program= reinterpret_cast<PFS_program *>(state->m_parent_sp_share);
+
+ PFS_thread *pfs_thread= my_thread_get_THR_PFS();
+ if (unlikely(pfs_thread == NULL))
+ return NULL;
+
+ PFS_prepared_stmt *pfs= create_prepared_stmt(identity,
+ pfs_thread, pfs_program,
+ pfs_stmt, stmt_id,
+ stmt_name, static_cast<uint>(stmt_name_length));
+
+ state->m_parent_prepared_stmt= reinterpret_cast<PSI_prepared_stmt*>(pfs);
+ state->m_in_prepare= true;
+
+ return reinterpret_cast<PSI_prepared_stmt*>(pfs);
+}
+
+void pfs_execute_prepared_stmt_v1 (PSI_statement_locker *locker,
+ PSI_prepared_stmt* ps)
+{
+ PSI_statement_locker_state *state= reinterpret_cast<PSI_statement_locker_state*> (locker);
+ DBUG_ASSERT(state != NULL);
+
+ state->m_parent_prepared_stmt= ps;
+ state->m_in_prepare= false;
+}
+
+void pfs_destroy_prepared_stmt_v1(PSI_prepared_stmt* prepared_stmt)
+{
+ PFS_prepared_stmt *pfs_prepared_stmt= reinterpret_cast<PFS_prepared_stmt*>(prepared_stmt);
+ delete_prepared_stmt(pfs_prepared_stmt);
+ return;
+}
+
+void pfs_reprepare_prepared_stmt_v1(PSI_prepared_stmt* prepared_stmt)
+{
+ PFS_prepared_stmt *pfs_prepared_stmt= reinterpret_cast<PFS_prepared_stmt*>(prepared_stmt);
+ PFS_single_stat *prepared_stmt_stat= &pfs_prepared_stmt->m_reprepare_stat;
+
+ if (prepared_stmt_stat != NULL)
+ prepared_stmt_stat->aggregate_counted();
+ return;
+}
+
+/**
+ Implementation of the thread attribute connection interface
+ @sa PSI_v1::set_thread_connect_attr.
+*/
+int pfs_set_thread_connect_attrs_v1(const char *buffer, uint length,
+ const void *from_cs)
+{
+ PFS_thread *thd= my_thread_get_THR_PFS();
+
+ DBUG_ASSERT(buffer != NULL);
+
+ if (likely(thd != NULL) && session_connect_attrs_size_per_thread > 0)
+ {
+ pfs_dirty_state dirty_state;
+ const CHARSET_INFO *cs = static_cast<const CHARSET_INFO *> (from_cs);
+
+ /* copy from the input buffer as much as we can fit */
+ uint copy_size= (uint)(length < session_connect_attrs_size_per_thread ?
+ length : session_connect_attrs_size_per_thread);
+ thd->m_session_lock.allocated_to_dirty(& dirty_state);
+ memcpy(thd->m_session_connect_attrs, buffer, copy_size);
+ thd->m_session_connect_attrs_length= copy_size;
+ thd->m_session_connect_attrs_cs_number= cs->number;
+ thd->m_session_lock.dirty_to_allocated(& dirty_state);
+
+ if (copy_size == length)
+ return 0;
+
+ session_connect_attrs_lost++;
+ return 1;
+ }
+ return 0;
+}
+
+void pfs_register_memory_v1(const char *category,
+ PSI_memory_info_v1 *info,
+ int count)
+{
+ REGISTER_BODY_V1(PSI_memory_key,
+ memory_instrument_prefix,
+ register_memory_class)
+}
+
+PSI_memory_key pfs_memory_alloc_v1(PSI_memory_key key, size_t size, PSI_thread **owner)
+{
+ PFS_thread ** owner_thread= reinterpret_cast<PFS_thread**>(owner);
+ DBUG_ASSERT(owner_thread != NULL);
+
+ if (! flag_global_instrumentation)
+ {
+ *owner_thread= NULL;
+ return PSI_NOT_INSTRUMENTED;
+ }
+
+ PFS_memory_class *klass= find_memory_class(key);
+ if (klass == NULL)
+ {
+ *owner_thread= NULL;
+ return PSI_NOT_INSTRUMENTED;
+ }
+
+ if (! klass->m_enabled)
+ {
+ *owner_thread= NULL;
+ return PSI_NOT_INSTRUMENTED;
+ }
+
+ PFS_memory_stat *event_name_array;
+ PFS_memory_stat *stat;
+ uint index= klass->m_event_name_index;
+ PFS_memory_stat_delta delta_buffer;
+ PFS_memory_stat_delta *delta;
+
+ if (flag_thread_instrumentation && ! klass->is_global())
+ {
+ PFS_thread *pfs_thread= my_thread_get_THR_PFS();
+ if (unlikely(pfs_thread == NULL))
+ {
+ *owner_thread= NULL;
+ return PSI_NOT_INSTRUMENTED;
+ }
+ if (! pfs_thread->m_enabled)
+ {
+ *owner_thread= NULL;
+ return PSI_NOT_INSTRUMENTED;
+ }
+
+ /* Aggregate to MEMORY_SUMMARY_BY_THREAD_BY_EVENT_NAME */
+ event_name_array= pfs_thread->write_instr_class_memory_stats();
+ stat= & event_name_array[index];
+ delta= stat->count_alloc(size, &delta_buffer);
+
+ if (delta != NULL)
+ {
+ pfs_thread->carry_memory_stat_delta(delta, index);
+ }
+
+ /* Flag this memory as owned by the current thread. */
+ *owner_thread= pfs_thread;
+ }
+ else
+ {
+ /* Aggregate to MEMORY_SUMMARY_GLOBAL_BY_EVENT_NAME */
+ event_name_array= global_instr_class_memory_array;
+ stat= & event_name_array[index];
+ (void) stat->count_alloc(size, &delta_buffer);
+
+ *owner_thread= NULL;
+ }
+
+ return key;
+}
+
+PSI_memory_key pfs_memory_realloc_v1(PSI_memory_key key, size_t old_size, size_t new_size, PSI_thread **owner)
+{
+ PFS_thread ** owner_thread_hdl= reinterpret_cast<PFS_thread**>(owner);
+ DBUG_ASSERT(owner != NULL);
+
+ PFS_memory_class *klass= find_memory_class(key);
+ if (klass == NULL)
+ {
+ *owner_thread_hdl= NULL;
+ return PSI_NOT_INSTRUMENTED;
+ }
+
+ PFS_memory_stat *event_name_array;
+ PFS_memory_stat *stat;
+ uint index= klass->m_event_name_index;
+ PFS_memory_stat_delta delta_buffer;
+ PFS_memory_stat_delta *delta;
+
+ if (flag_thread_instrumentation && ! klass->is_global())
+ {
+ PFS_thread *pfs_thread= my_thread_get_THR_PFS();
+ if (likely(pfs_thread != NULL))
+ {
+#ifdef PFS_PARANOID
+ PFS_thread *owner_thread= *owner_thread_hdl;
+ if (owner_thread != pfs_thread)
+ {
+ owner_thread= sanitize_thread(owner_thread);
+ if (owner_thread != NULL)
+ {
+ report_memory_accounting_error("pfs_memory_realloc_v1",
+ pfs_thread, old_size, klass, owner_thread);
+ }
+ }
+#endif /* PFS_PARANOID */
+
+ /* Aggregate to MEMORY_SUMMARY_BY_THREAD_BY_EVENT_NAME */
+ event_name_array= pfs_thread->write_instr_class_memory_stats();
+ stat= & event_name_array[index];
+
+ if (flag_global_instrumentation && klass->m_enabled)
+ {
+ delta= stat->count_realloc(old_size, new_size, &delta_buffer);
+ *owner_thread_hdl= pfs_thread;
+ }
+ else
+ {
+ delta= stat->count_free(old_size, &delta_buffer);
+ *owner_thread_hdl= NULL;
+ key= PSI_NOT_INSTRUMENTED;
+ }
+
+ if (delta != NULL)
+ {
+ pfs_thread->carry_memory_stat_delta(delta, index);
+ }
+ return key;
+ }
+ }
+
+ /* Aggregate to MEMORY_SUMMARY_GLOBAL_BY_EVENT_NAME */
+ event_name_array= global_instr_class_memory_array;
+ stat= & event_name_array[index];
+
+ if (flag_global_instrumentation && klass->m_enabled)
+ {
+ (void) stat->count_realloc(old_size, new_size, &delta_buffer);
+ }
+ else
+ {
+ (void) stat->count_free(old_size, &delta_buffer);
+ key= PSI_NOT_INSTRUMENTED;
+ }
+
+ *owner_thread_hdl= NULL;
+ return key;
+}
+
+PSI_memory_key pfs_memory_claim_v1(PSI_memory_key key, size_t size, PSI_thread **owner)
+{
+ PFS_thread ** owner_thread= reinterpret_cast<PFS_thread**>(owner);
+ DBUG_ASSERT(owner_thread != NULL);
+
+ PFS_memory_class *klass= find_memory_class(key);
+ if (klass == NULL)
+ {
+ *owner_thread= NULL;
+ return PSI_NOT_INSTRUMENTED;
+ }
+
+ /*
+ Do not check klass->m_enabled.
+ Do not check flag_global_instrumentation.
+ If a memory alloc was instrumented,
+ the corresponding free must be instrumented.
+ */
+
+ PFS_memory_stat *event_name_array;
+ PFS_memory_stat *stat;
+ uint index= klass->m_event_name_index;
+ PFS_memory_stat_delta delta_buffer;
+ PFS_memory_stat_delta *delta;
+
+ if (flag_thread_instrumentation)
+ {
+ PFS_thread *old_thread= sanitize_thread(*owner_thread);
+ PFS_thread *new_thread= my_thread_get_THR_PFS();
+ if (old_thread != new_thread)
+ {
+ if (old_thread != NULL)
+ {
+ event_name_array= old_thread->write_instr_class_memory_stats();
+ stat= & event_name_array[index];
+ delta= stat->count_free(size, &delta_buffer);
+
+ if (delta != NULL)
+ {
+ old_thread->carry_memory_stat_delta(delta, index);
+ }
+ }
+
+ if (new_thread != NULL)
+ {
+ event_name_array= new_thread->write_instr_class_memory_stats();
+ stat= & event_name_array[index];
+ delta= stat->count_alloc(size, &delta_buffer);
+
+ if (delta != NULL)
+ {
+ new_thread->carry_memory_stat_delta(delta, index);
+ }
+ }
+
+ *owner_thread= new_thread;
+ }
+
+ return key;
+ }
+
+ *owner_thread= NULL;
+ return key;
+}
+
+void pfs_memory_free_v1(PSI_memory_key key, size_t size, PSI_thread *owner)
+{
+ PFS_memory_class *klass= find_memory_class(key);
+ if (klass == NULL)
+ return;
+
+ /*
+ Do not check klass->m_enabled.
+ Do not check flag_global_instrumentation.
+ If a memory alloc was instrumented,
+ the corresponding free must be instrumented.
+ */
+
+ PFS_memory_stat *event_name_array;
+ PFS_memory_stat *stat;
+ uint index= klass->m_event_name_index;
+ PFS_memory_stat_delta delta_buffer;
+ PFS_memory_stat_delta *delta;
+
+ if (flag_thread_instrumentation && ! klass->is_global())
+ {
+ PFS_thread *pfs_thread= my_thread_get_THR_PFS();
+ if (likely(pfs_thread != NULL))
+ {
+#ifdef PFS_PARANOID
+ PFS_thread *owner_thread= reinterpret_cast<PFS_thread*>(owner);
+
+ if (owner_thread != pfs_thread)
+ {
+ owner_thread= sanitize_thread(owner_thread);
+ if (owner_thread != NULL)
+ {
+ report_memory_accounting_error("pfs_memory_free_v1",
+ pfs_thread, size, klass, owner_thread);
+ }
+ }
+#endif /* PFS_PARANOID */
+
+ /*
+ Do not check pfs_thread->m_enabled.
+ If a memory alloc was instrumented,
+ the corresponding free must be instrumented.
+ */
+ /* Aggregate to MEMORY_SUMMARY_BY_THREAD_BY_EVENT_NAME */
+ event_name_array= pfs_thread->write_instr_class_memory_stats();
+ stat= & event_name_array[index];
+ delta= stat->count_free(size, &delta_buffer);
+
+ if (delta != NULL)
+ {
+ pfs_thread->carry_memory_stat_delta(delta, index);
+ }
+ return;
+ }
+ }
+
+ /* Aggregate to MEMORY_SUMMARY_GLOBAL_BY_EVENT_NAME */
+ event_name_array= global_instr_class_memory_array;
+ if (event_name_array)
+ {
+ stat= & event_name_array[index];
+ (void) stat->count_free(size, &delta_buffer);
+ }
+ return;
+}
+
+void pfs_unlock_table_v1(PSI_table *table)
+{
+ PFS_table *pfs_table= reinterpret_cast<PFS_table*> (table);
+
+ DBUG_ASSERT(pfs_table != NULL);
+
+ pfs_table->m_internal_lock= PFS_TL_NONE;
+ return;
+}
+
+PSI_metadata_lock *
+pfs_create_metadata_lock_v1(
+ void *identity,
+ const MDL_key *mdl_key,
+ opaque_mdl_type mdl_type,
+ opaque_mdl_duration mdl_duration,
+ opaque_mdl_status mdl_status,
+ const char *src_file,
+ uint src_line)
+{
+ if (! flag_global_instrumentation)
+ return NULL;
+
+ if (! global_metadata_class.m_enabled)
+ return NULL;
+
+ PFS_thread *pfs_thread= my_thread_get_THR_PFS();
+ if (pfs_thread == NULL)
+ return NULL;
+
+ PFS_metadata_lock *pfs;
+ pfs= create_metadata_lock(identity, mdl_key,
+ mdl_type, mdl_duration, mdl_status,
+ src_file, src_line);
+
+ if (pfs != NULL)
+ {
+ pfs->m_owner_thread_id= pfs_thread->m_thread_internal_id;
+ pfs->m_owner_event_id= pfs_thread->m_event_id;
+ }
+
+ return reinterpret_cast<PSI_metadata_lock *> (pfs);
+}
+
+void
+pfs_set_metadata_lock_status_v1(PSI_metadata_lock *lock, opaque_mdl_status mdl_status)
+{
+ PFS_metadata_lock *pfs= reinterpret_cast<PFS_metadata_lock*> (lock);
+ DBUG_ASSERT(pfs != NULL);
+ pfs->m_mdl_status= mdl_status;
+}
+
+void
+pfs_destroy_metadata_lock_v1(PSI_metadata_lock *lock)
+{
+ PFS_metadata_lock *pfs= reinterpret_cast<PFS_metadata_lock*> (lock);
+ DBUG_ASSERT(pfs != NULL);
+ destroy_metadata_lock(pfs);
+}
+
+PSI_metadata_locker *
+pfs_start_metadata_wait_v1(PSI_metadata_locker_state *state,
+ PSI_metadata_lock *lock,
+ const char *src_file,
+ uint src_line)
+{
+ PFS_metadata_lock *pfs_lock= reinterpret_cast<PFS_metadata_lock*> (lock);
+ DBUG_ASSERT(state != NULL);
+ DBUG_ASSERT(pfs_lock != NULL);
+
+ if (! pfs_lock->m_enabled)
+ return NULL;
+
+ uint flags;
+ ulonglong timer_start= 0;
+
+ if (flag_thread_instrumentation)
+ {
+ PFS_thread *pfs_thread= my_thread_get_THR_PFS();
+ if (unlikely(pfs_thread == NULL))
+ return NULL;
+ if (! pfs_thread->m_enabled)
+ return NULL;
+ state->m_thread= reinterpret_cast<PSI_thread *> (pfs_thread);
+ flags= STATE_FLAG_THREAD;
+
+ if (pfs_lock->m_timed)
+ {
+ timer_start= get_timer_raw_value_and_function(wait_timer, & state->m_timer);
+ state->m_timer_start= timer_start;
+ flags|= STATE_FLAG_TIMED;
+ }
+
+ if (flag_events_waits_current)
+ {
+ if (unlikely(pfs_thread->m_events_waits_current >=
+ & pfs_thread->m_events_waits_stack[WAIT_STACK_SIZE]))
+ {
+ locker_lost++;
+ return NULL;
+ }
+ PFS_events_waits *wait= pfs_thread->m_events_waits_current;
+ state->m_wait= wait;
+ flags|= STATE_FLAG_EVENT;
+
+ PFS_events_waits *parent_event= wait - 1;
+ wait->m_event_type= EVENT_TYPE_WAIT;
+ wait->m_nesting_event_id= parent_event->m_event_id;
+ wait->m_nesting_event_type= parent_event->m_event_type;
+
+ wait->m_thread_internal_id= pfs_thread->m_thread_internal_id;
+ wait->m_class= &global_metadata_class;
+ wait->m_timer_start= timer_start;
+ wait->m_timer_end= 0;
+ wait->m_object_instance_addr= pfs_lock->m_identity;
+ wait->m_event_id= pfs_thread->m_event_id++;
+ wait->m_end_event_id= 0;
+ wait->m_weak_metadata_lock= pfs_lock;
+ wait->m_weak_version= pfs_lock->get_version();
+ wait->m_operation= OPERATION_TYPE_METADATA;
+ wait->m_source_file= src_file;
+ wait->m_source_line= src_line;
+ wait->m_wait_class= WAIT_CLASS_METADATA;
+
+ pfs_thread->m_events_waits_current++;
+ }
+ }
+ else
+ {
+ if (pfs_lock->m_timed)
+ {
+ timer_start= get_timer_raw_value_and_function(wait_timer, & state->m_timer);
+ state->m_timer_start= timer_start;
+ flags= STATE_FLAG_TIMED;
+ state->m_thread= NULL;
+ }
+ else
+ {
+ /*
+ Complete shortcut.
+ */
+ /* Aggregate to EVENTS_WAITS_SUMMARY_GLOBAL_BY_EVENT_NAME (counted) */
+ global_metadata_stat.aggregate_counted();
+ return NULL;
+ }
+ }
+
+ state->m_flags= flags;
+ state->m_metadata_lock= lock;
+ return reinterpret_cast<PSI_metadata_locker*> (state);
+}
+
+void
+pfs_end_metadata_wait_v1(PSI_metadata_locker *locker,
+ int rc)
+{
+ PSI_metadata_locker_state *state= reinterpret_cast<PSI_metadata_locker_state*> (locker);
+ DBUG_ASSERT(state != NULL);
+
+ ulonglong timer_end= 0;
+ ulonglong wait_time= 0;
+
+ PFS_thread *thread= reinterpret_cast<PFS_thread *> (state->m_thread);
+
+ uint flags= state->m_flags;
+
+ if (flags & STATE_FLAG_TIMED)
+ {
+ timer_end= state->m_timer();
+ wait_time= timer_end - state->m_timer_start;
+ }
+
+ if (flags & STATE_FLAG_THREAD)
+ {
+ PFS_single_stat *event_name_array;
+ event_name_array= thread->write_instr_class_waits_stats();
+
+ if (flags & STATE_FLAG_TIMED)
+ {
+ /* Aggregate to EVENTS_WAITS_SUMMARY_BY_THREAD_BY_EVENT_NAME (timed) */
+ event_name_array[GLOBAL_METADATA_EVENT_INDEX].aggregate_value(wait_time);
+ }
+ else
+ {
+ /* Aggregate to EVENTS_WAITS_SUMMARY_BY_THREAD_BY_EVENT_NAME (counted) */
+ event_name_array[GLOBAL_METADATA_EVENT_INDEX].aggregate_counted();
+ }
+
+ if (flags & STATE_FLAG_EVENT)
+ {
+ PFS_events_waits *wait= reinterpret_cast<PFS_events_waits*> (state->m_wait);
+ DBUG_ASSERT(wait != NULL);
+
+ wait->m_timer_end= timer_end;
+ wait->m_end_event_id= thread->m_event_id;
+ if (thread->m_flag_events_waits_history)
+ insert_events_waits_history(thread, wait);
+ if (thread->m_flag_events_waits_history_long)
+ insert_events_waits_history_long(wait);
+ thread->m_events_waits_current--;
+
+ DBUG_ASSERT(wait == thread->m_events_waits_current);
+ }
+ }
+ else
+ {
+ if (flags & STATE_FLAG_TIMED)
+ {
+ /* Aggregate to EVENTS_WAITS_SUMMARY_GLOBAL_BY_EVENT_NAME (timed) */
+ global_metadata_stat.aggregate_value(wait_time);
+ }
+ else
+ {
+ /* Aggregate to EVENTS_WAITS_SUMMARY_GLOBAL_BY_EVENT_NAME (counted) */
+ global_metadata_stat.aggregate_counted();
+ }
+ }
+}
+
+void pfs_set_prepared_stmt_text_v1(PSI_prepared_stmt *prepared_stmt,
+ const char *text,
+ uint text_len)
+{
+ PFS_prepared_stmt *pfs_prepared_stmt =
+ reinterpret_cast<PFS_prepared_stmt *>(prepared_stmt);
+ DBUG_ASSERT(pfs_prepared_stmt != NULL);
+
+ uint max_len = COL_INFO_SIZE;
+ if (text_len > max_len)
+ {
+ text_len = max_len;
+ }
+
+ memcpy(pfs_prepared_stmt->m_sqltext, text, text_len);
+ pfs_prepared_stmt->m_sqltext_length = text_len;
+
+ return;
+}
+
+/**
+ Implementation of the instrumentation interface.
+ @sa PSI_v1.
+*/
+PSI_v1 PFS_v1=
+{
+ pfs_register_mutex_v1,
+ pfs_register_rwlock_v1,
+ pfs_register_cond_v1,
+ pfs_register_thread_v1,
+ pfs_register_file_v1,
+ pfs_register_stage_v1,
+ pfs_register_statement_v1,
+ pfs_register_socket_v1,
+ pfs_init_mutex_v1,
+ pfs_destroy_mutex_v1,
+ pfs_init_rwlock_v1,
+ pfs_destroy_rwlock_v1,
+ pfs_init_cond_v1,
+ pfs_destroy_cond_v1,
+ pfs_init_socket_v1,
+ pfs_destroy_socket_v1,
+ pfs_get_table_share_v1,
+ pfs_release_table_share_v1,
+ pfs_drop_table_share_v1,
+ pfs_open_table_v1,
+ pfs_unbind_table_v1,
+ pfs_rebind_table_v1,
+ pfs_close_table_v1,
+ pfs_create_file_v1,
+ pfs_spawn_thread_v1,
+ pfs_new_thread_v1,
+ pfs_set_thread_id_v1,
+ pfs_set_thread_THD_v1,
+ pfs_set_thread_os_id_v1,
+ pfs_get_thread_v1,
+ pfs_set_thread_user_v1,
+ pfs_set_thread_account_v1,
+ pfs_set_thread_db_v1,
+ pfs_set_thread_command_v1,
+ pfs_set_connection_type_v1,
+ pfs_set_thread_start_time_v1,
+ pfs_set_thread_state_v1,
+ pfs_set_thread_info_v1,
+ pfs_set_thread_v1,
+ pfs_delete_current_thread_v1,
+ pfs_delete_thread_v1,
+ pfs_get_thread_file_name_locker_v1,
+ pfs_get_thread_file_stream_locker_v1,
+ pfs_get_thread_file_descriptor_locker_v1,
+ pfs_unlock_mutex_v1,
+ pfs_unlock_rwlock_v1,
+ pfs_signal_cond_v1,
+ pfs_broadcast_cond_v1,
+ pfs_start_idle_wait_v1,
+ pfs_end_idle_wait_v1,
+ pfs_start_mutex_wait_v1,
+ pfs_end_mutex_wait_v1,
+ pfs_start_rwlock_rdwait_v1,
+ pfs_end_rwlock_rdwait_v1,
+ pfs_start_rwlock_wrwait_v1,
+ pfs_end_rwlock_wrwait_v1,
+ pfs_start_cond_wait_v1,
+ pfs_end_cond_wait_v1,
+ pfs_start_table_io_wait_v1,
+ pfs_end_table_io_wait_v1,
+ pfs_start_table_lock_wait_v1,
+ pfs_end_table_lock_wait_v1,
+ pfs_start_file_open_wait_v1,
+ pfs_end_file_open_wait_v1,
+ pfs_end_file_open_wait_and_bind_to_descriptor_v1,
+ pfs_end_temp_file_open_wait_and_bind_to_descriptor_v1,
+ pfs_start_file_wait_v1,
+ pfs_end_file_wait_v1,
+ pfs_start_file_close_wait_v1,
+ pfs_end_file_close_wait_v1,
+ pfs_end_file_rename_wait_v1,
+ pfs_start_stage_v1,
+ pfs_get_current_stage_progress_v1,
+ pfs_end_stage_v1,
+ pfs_get_thread_statement_locker_v1,
+ pfs_refine_statement_v1,
+ pfs_start_statement_v1,
+ pfs_set_statement_text_v1,
+ pfs_set_statement_lock_time_v1,
+ pfs_set_statement_rows_sent_v1,
+ pfs_set_statement_rows_examined_v1,
+ pfs_inc_statement_created_tmp_disk_tables_v1,
+ pfs_inc_statement_created_tmp_tables_v1,
+ pfs_inc_statement_select_full_join_v1,
+ pfs_inc_statement_select_full_range_join_v1,
+ pfs_inc_statement_select_range_v1,
+ pfs_inc_statement_select_range_check_v1,
+ pfs_inc_statement_select_scan_v1,
+ pfs_inc_statement_sort_merge_passes_v1,
+ pfs_inc_statement_sort_range_v1,
+ pfs_inc_statement_sort_rows_v1,
+ pfs_inc_statement_sort_scan_v1,
+ pfs_set_statement_no_index_used_v1,
+ pfs_set_statement_no_good_index_used_v1,
+ pfs_end_statement_v1,
+ pfs_get_thread_transaction_locker_v1,
+ pfs_start_transaction_v1,
+ pfs_set_transaction_xid_v1,
+ pfs_set_transaction_xa_state_v1,
+ pfs_set_transaction_gtid_v1,
+ pfs_set_transaction_trxid_v1,
+ pfs_inc_transaction_savepoints_v1,
+ pfs_inc_transaction_rollback_to_savepoint_v1,
+ pfs_inc_transaction_release_savepoint_v1,
+ pfs_end_transaction_v1,
+ pfs_start_socket_wait_v1,
+ pfs_end_socket_wait_v1,
+ pfs_set_socket_state_v1,
+ pfs_set_socket_info_v1,
+ pfs_set_socket_thread_owner_v1,
+ pfs_create_prepared_stmt_v1,
+ pfs_destroy_prepared_stmt_v1,
+ pfs_reprepare_prepared_stmt_v1,
+ pfs_execute_prepared_stmt_v1,
+ pfs_set_prepared_stmt_text_v1,
+ pfs_digest_start_v1,
+ pfs_digest_end_v1,
+ pfs_set_thread_connect_attrs_v1,
+ pfs_start_sp_v1,
+ pfs_end_sp_v1,
+ pfs_drop_sp_v1,
+ pfs_get_sp_share_v1,
+ pfs_release_sp_share_v1,
+ pfs_register_memory_v1,
+ pfs_memory_alloc_v1,
+ pfs_memory_realloc_v1,
+ pfs_memory_claim_v1,
+ pfs_memory_free_v1,
+ pfs_unlock_table_v1,
+ pfs_create_metadata_lock_v1,
+ pfs_set_metadata_lock_status_v1,
+ pfs_destroy_metadata_lock_v1,
+ pfs_start_metadata_wait_v1,
+ pfs_end_metadata_wait_v1
+};
+
+static void* get_interface(int version)
+{
+ switch (version)
+ {
+ case PSI_VERSION_1:
+ return &PFS_v1;
+ default:
+ return NULL;
+ }
+}
+
+C_MODE_END
+
+struct PSI_bootstrap PFS_bootstrap=
+{
+ get_interface
+};
diff --git a/storage/perfschema/pfs.h b/storage/perfschema/pfs.h
new file mode 100644
index 00000000..69b23be4
--- /dev/null
+++ b/storage/perfschema/pfs.h
@@ -0,0 +1,63 @@
+/* Copyright (c) 2008, 2016, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef PFS_H
+#define PFS_H
+
+/**
+ @file storage/perfschema/pfs.h
+ Performance schema instrumentation (declarations).
+*/
+
+#define HAVE_PSI_1
+
+#include <my_global.h>
+#include "my_thread.h"
+#include <mysql/psi/psi.h>
+
+/**
+ Entry point to the performance schema implementation.
+ This singleton is used to discover the performance schema services.
+*/
+extern struct PSI_bootstrap PFS_bootstrap;
+/** Performance schema Thread Local Storage key. */
+extern pthread_key_t THR_PFS;
+extern pthread_key_t THR_PFS_VG; // global_variables
+extern pthread_key_t THR_PFS_SV; // session_variables
+extern pthread_key_t THR_PFS_VBT; // variables_by_thread
+extern pthread_key_t THR_PFS_SG; // global_status
+extern pthread_key_t THR_PFS_SS; // session_status
+extern pthread_key_t THR_PFS_SBT; // status_by_thread
+extern pthread_key_t THR_PFS_SBU; // status_by_user
+extern pthread_key_t THR_PFS_SBA; // status_by_host
+extern pthread_key_t THR_PFS_SBH; // status_by_account
+
+/** True when @c THR_PFS and all other Performance Schema TLS keys are initialized. */
+extern bool THR_PFS_initialized;
+
+#define PSI_VOLATILITY_UNKNOWN 0
+#define PSI_VOLATILITY_SESSION 1
+
+#define PSI_COUNT_VOLATILITY 2
+
+#endif
+
diff --git a/storage/perfschema/pfs_account.cc b/storage/perfschema/pfs_account.cc
new file mode 100644
index 00000000..b6090d06
--- /dev/null
+++ b/storage/perfschema/pfs_account.cc
@@ -0,0 +1,747 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/pfs_account.cc
+ Performance schema account (implementation).
+*/
+
+#include "my_global.h"
+#include "my_sys.h"
+#include "pfs.h"
+#include "pfs_stat.h"
+#include "pfs_instr.h"
+#include "pfs_setup_actor.h"
+#include "pfs_host.h"
+#include "pfs_host.h"
+#include "pfs_user.h"
+#include "pfs_account.h"
+#include "pfs_global.h"
+#include "pfs_instr_class.h"
+#include "pfs_buffer_container.h"
+
+/**
+ @addtogroup Performance_schema_buffers
+ @{
+*/
+
+LF_HASH account_hash;
+static bool account_hash_inited= false;
+
+/**
+ Initialize the user buffers.
+ @param param sizing parameters
+ @return 0 on success
+*/
+int init_account(const PFS_global_param *param)
+{
+ if (global_account_container.init(param->m_account_sizing))
+ return 1;
+
+ return 0;
+}
+
+/** Cleanup all the account buffers. */
+void cleanup_account(void)
+{
+ global_account_container.cleanup();
+}
+
+C_MODE_START
+static uchar *account_hash_get_key(const uchar *entry, size_t *length,
+ my_bool)
+{
+ const PFS_account * const *typed_entry;
+ const PFS_account *account;
+ const void *result;
+ typed_entry= reinterpret_cast<const PFS_account* const *> (entry);
+ DBUG_ASSERT(typed_entry != NULL);
+ account= *typed_entry;
+ DBUG_ASSERT(account != NULL);
+ *length= account->m_key.m_key_length;
+ result= account->m_key.m_hash_key;
+ return const_cast<uchar*> (reinterpret_cast<const uchar*> (result));
+}
+C_MODE_END
+
+/**
+ Initialize the user hash.
+ @return 0 on success
+*/
+int init_account_hash(const PFS_global_param *param)
+{
+ if ((! account_hash_inited) && (param->m_account_sizing != 0))
+ {
+ lf_hash_init(&account_hash, sizeof(PFS_account*), LF_HASH_UNIQUE,
+ 0, 0, account_hash_get_key, &my_charset_bin);
+ account_hash_inited= true;
+ }
+ return 0;
+}
+
+/** Cleanup the user hash. */
+void cleanup_account_hash(void)
+{
+ if (account_hash_inited)
+ {
+ lf_hash_destroy(&account_hash);
+ account_hash_inited= false;
+ }
+}
+
+static LF_PINS* get_account_hash_pins(PFS_thread *thread)
+{
+ if (unlikely(thread->m_account_hash_pins == NULL))
+ {
+ if (! account_hash_inited)
+ return NULL;
+ thread->m_account_hash_pins= lf_hash_get_pins(&account_hash);
+ }
+ return thread->m_account_hash_pins;
+}
+
+static void set_account_key(PFS_account_key *key,
+ const char *user, uint user_length,
+ const char *host, uint host_length)
+{
+ DBUG_ASSERT(user_length <= USERNAME_LENGTH);
+ DBUG_ASSERT(host_length <= HOSTNAME_LENGTH);
+
+ char *ptr= &key->m_hash_key[0];
+ if (user_length > 0)
+ {
+ memcpy(ptr, user, user_length);
+ ptr+= user_length;
+ }
+ ptr[0]= 0;
+ ptr++;
+ if (host_length > 0)
+ {
+ memcpy(ptr, host, host_length);
+ ptr+= host_length;
+ }
+ ptr[0]= 0;
+ ptr++;
+ key->m_key_length= (uint)(ptr - &key->m_hash_key[0]);
+}
+
+PFS_account *
+find_or_create_account(PFS_thread *thread,
+ const char *username, uint username_length,
+ const char *hostname, uint hostname_length)
+{
+ LF_PINS *pins= get_account_hash_pins(thread);
+ if (unlikely(pins == NULL))
+ {
+ global_account_container.m_lost++;
+ return NULL;
+ }
+
+ PFS_account_key key;
+ set_account_key(&key, username, username_length,
+ hostname, hostname_length);
+
+ PFS_account **entry;
+ PFS_account *pfs;
+ uint retry_count= 0;
+ const uint retry_max= 3;
+ pfs_dirty_state dirty_state;
+
+search:
+ entry= reinterpret_cast<PFS_account**>
+ (lf_hash_search(&account_hash, pins,
+ key.m_hash_key, key.m_key_length));
+ if (entry && (entry != MY_ERRPTR))
+ {
+ pfs= *entry;
+ pfs->inc_refcount();
+ lf_hash_search_unpin(pins);
+ return pfs;
+ }
+
+ lf_hash_search_unpin(pins);
+
+ pfs= global_account_container.allocate(& dirty_state);
+ if (pfs != NULL)
+ {
+ pfs->m_key= key;
+ if (username_length > 0)
+ pfs->m_username= &pfs->m_key.m_hash_key[0];
+ else
+ pfs->m_username= NULL;
+ pfs->m_username_length= username_length;
+
+ if (hostname_length > 0)
+ pfs->m_hostname= &pfs->m_key.m_hash_key[username_length + 1];
+ else
+ pfs->m_hostname= NULL;
+ pfs->m_hostname_length= hostname_length;
+
+ pfs->m_user= find_or_create_user(thread, username, username_length);
+ pfs->m_host= find_or_create_host(thread, hostname, hostname_length);
+
+ pfs->init_refcount();
+ pfs->reset_stats();
+ pfs->m_disconnected_count= 0;
+
+ if (username_length > 0 && hostname_length > 0)
+ {
+ lookup_setup_actor(thread, username, username_length, hostname, hostname_length,
+ & pfs->m_enabled, & pfs->m_history);
+ }
+ else
+ {
+ pfs->m_enabled= true;
+ pfs->m_history= true;
+ }
+
+ int res;
+ pfs->m_lock.dirty_to_allocated(& dirty_state);
+ res= lf_hash_insert(&account_hash, pins, &pfs);
+ if (likely(res == 0))
+ {
+ return pfs;
+ }
+
+ if (pfs->m_user)
+ {
+ pfs->m_user->release();
+ pfs->m_user= NULL;
+ }
+ if (pfs->m_host)
+ {
+ pfs->m_host->release();
+ pfs->m_host= NULL;
+ }
+
+ global_account_container.deallocate(pfs);
+
+ if (res > 0)
+ {
+ if (++retry_count > retry_max)
+ {
+ global_account_container.m_lost++;
+ return NULL;
+ }
+ goto search;
+ }
+
+ global_account_container.m_lost++;
+ return NULL;
+ }
+
+ return NULL;
+}
+
+void PFS_account::aggregate(bool alive, PFS_user *safe_user, PFS_host *safe_host)
+{
+ aggregate_waits(safe_user, safe_host);
+ aggregate_stages(safe_user, safe_host);
+ aggregate_statements(safe_user, safe_host);
+ aggregate_transactions(safe_user, safe_host);
+ aggregate_memory(alive, safe_user, safe_host);
+ aggregate_status(safe_user, safe_host);
+ aggregate_stats(safe_user, safe_host);
+}
+
+void PFS_account::aggregate_waits(PFS_user *safe_user, PFS_host *safe_host)
+{
+ if (read_instr_class_waits_stats() == NULL)
+ return;
+
+ if (likely(safe_user != NULL && safe_host != NULL))
+ {
+ /*
+ Aggregate EVENTS_WAITS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME to:
+ - EVENTS_WAITS_SUMMARY_BY_USER_BY_EVENT_NAME
+ - EVENTS_WAITS_SUMMARY_BY_HOST_BY_EVENT_NAME
+ in parallel.
+ */
+ aggregate_all_event_names(write_instr_class_waits_stats(),
+ safe_user->write_instr_class_waits_stats(),
+ safe_host->write_instr_class_waits_stats());
+ return;
+ }
+
+ if (safe_user != NULL)
+ {
+ /*
+ Aggregate EVENTS_WAITS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME to:
+ - EVENTS_WAITS_SUMMARY_BY_USER_BY_EVENT_NAME
+ */
+ aggregate_all_event_names(write_instr_class_waits_stats(),
+ safe_user->write_instr_class_waits_stats());
+ return;
+ }
+
+ if (safe_host != NULL)
+ {
+ /*
+ Aggregate EVENTS_WAITS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME to:
+ - EVENTS_WAITS_SUMMARY_BY_HOST_BY_EVENT_NAME
+ */
+ aggregate_all_event_names(write_instr_class_waits_stats(),
+ safe_host->write_instr_class_waits_stats());
+ return;
+ }
+
+ /* Orphan account, no parent to aggregate to. */
+ reset_waits_stats();
+ return;
+}
+
+void PFS_account::aggregate_stages(PFS_user *safe_user, PFS_host *safe_host)
+{
+ if (read_instr_class_stages_stats() == NULL)
+ return;
+
+ if (likely(safe_user != NULL && safe_host != NULL))
+ {
+ /*
+ Aggregate EVENTS_STAGES_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME to:
+ - EVENTS_STAGES_SUMMARY_BY_USER_BY_EVENT_NAME
+ - EVENTS_STAGES_SUMMARY_BY_HOST_BY_EVENT_NAME
+ in parallel.
+ */
+ aggregate_all_stages(write_instr_class_stages_stats(),
+ safe_user->write_instr_class_stages_stats(),
+ safe_host->write_instr_class_stages_stats());
+ return;
+ }
+
+ if (safe_user != NULL)
+ {
+ /*
+ Aggregate EVENTS_STAGES_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME to:
+ - EVENTS_STAGES_SUMMARY_BY_USER_BY_EVENT_NAME
+ - EVENTS_STAGES_SUMMARY_GLOBAL_BY_EVENT_NAME
+ in parallel.
+ */
+ aggregate_all_stages(write_instr_class_stages_stats(),
+ safe_user->write_instr_class_stages_stats(),
+ global_instr_class_stages_array);
+ return;
+ }
+
+ if (safe_host != NULL)
+ {
+ /*
+ Aggregate EVENTS_STAGES_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME to:
+ - EVENTS_STAGES_SUMMARY_BY_HOST_BY_EVENT_NAME
+ */
+ aggregate_all_stages(write_instr_class_stages_stats(),
+ safe_host->write_instr_class_stages_stats());
+ return;
+ }
+
+ /*
+ Aggregate EVENTS_STAGES_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME to:
+ - EVENTS_STAGES_SUMMARY_GLOBAL_BY_EVENT_NAME
+ */
+ aggregate_all_stages(write_instr_class_stages_stats(),
+ global_instr_class_stages_array);
+ return;
+}
+
+void PFS_account::aggregate_statements(PFS_user *safe_user, PFS_host *safe_host)
+{
+ if (read_instr_class_statements_stats() == NULL)
+ return;
+
+ if (likely(safe_user != NULL && safe_host != NULL))
+ {
+ /*
+ Aggregate EVENTS_STATEMENTS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME to:
+ - EVENTS_STATEMENTS_SUMMARY_BY_USER_BY_EVENT_NAME
+ - EVENTS_STATEMENTS_SUMMARY_BY_HOST_BY_EVENT_NAME
+ in parallel.
+ */
+ aggregate_all_statements(write_instr_class_statements_stats(),
+ safe_user->write_instr_class_statements_stats(),
+ safe_host->write_instr_class_statements_stats());
+ return;
+ }
+
+ if (safe_user != NULL)
+ {
+ /*
+ Aggregate EVENTS_STATEMENTS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME to:
+ - EVENTS_STATEMENTS_SUMMARY_BY_USER_BY_EVENT_NAME
+ - EVENTS_STATEMENTS_SUMMARY_GLOBAL_BY_EVENT_NAME
+ in parallel.
+ */
+ aggregate_all_statements(write_instr_class_statements_stats(),
+ safe_user->write_instr_class_statements_stats(),
+ global_instr_class_statements_array);
+ return;
+ }
+
+ if (safe_host != NULL)
+ {
+ /*
+ Aggregate EVENTS_STATEMENTS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME to:
+ - EVENTS_STATEMENTS_SUMMARY_BY_HOST_BY_EVENT_NAME
+ */
+ aggregate_all_statements(write_instr_class_statements_stats(),
+ safe_host->write_instr_class_statements_stats());
+ return;
+ }
+
+ /*
+ Aggregate EVENTS_STATEMENTS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME to:
+ - EVENTS_STATEMENTS_SUMMARY_GLOBAL_BY_EVENT_NAME
+ */
+ aggregate_all_statements(write_instr_class_statements_stats(),
+ global_instr_class_statements_array);
+ return;
+}
+
+void PFS_account::aggregate_transactions(PFS_user *safe_user, PFS_host *safe_host)
+{
+ if (read_instr_class_transactions_stats() == NULL)
+ return;
+
+ if (likely(safe_user != NULL && safe_host != NULL))
+ {
+ /*
+ Aggregate EVENTS_TRANSACTIONS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME to:
+ - EVENTS_TRANSACTIONS_SUMMARY_BY_USER_BY_EVENT_NAME
+ - EVENTS_TRANSACTIONS_SUMMARY_BY_HOST_BY_EVENT_NAME
+ in parallel.
+ */
+ aggregate_all_transactions(write_instr_class_transactions_stats(),
+ safe_user->write_instr_class_transactions_stats(),
+ safe_host->write_instr_class_transactions_stats());
+ return;
+ }
+
+ if (safe_user != NULL)
+ {
+ /*
+ Aggregate EVENTS_TRANSACTIONS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME to:
+ - EVENTS_TRANSACTIONS_SUMMARY_BY_USER_BY_EVENT_NAME
+ - EVENTS_TRANSACTIONS_SUMMARY_GLOBAL_BY_EVENT_NAME
+ in parallel.
+ */
+ aggregate_all_transactions(write_instr_class_transactions_stats(),
+ safe_user->write_instr_class_transactions_stats(),
+ &global_transaction_stat);
+ return;
+ }
+
+ if (safe_host != NULL)
+ {
+ /*
+ Aggregate EVENTS_TRANSACTIONS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME to:
+ - EVENTS_TRANSACTIONS_SUMMARY_BY_HOST_BY_EVENT_NAME
+ */
+ aggregate_all_transactions(write_instr_class_transactions_stats(),
+ safe_host->write_instr_class_transactions_stats());
+ return;
+ }
+
+ /*
+ Aggregate EVENTS_TRANSACTIONS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME to:
+ - EVENTS_TRANSACTIONS_SUMMARY_GLOBAL_BY_EVENT_NAME
+ */
+ aggregate_all_transactions(write_instr_class_transactions_stats(),
+ &global_transaction_stat);
+ return;
+}
+
+void PFS_account::aggregate_memory(bool alive, PFS_user *safe_user, PFS_host *safe_host)
+{
+ if (read_instr_class_memory_stats() == NULL)
+ return;
+
+ if (likely(safe_user != NULL && safe_host != NULL))
+ {
+ /*
+ Aggregate MEMORY_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME to:
+ - MEMORY_SUMMARY_BY_USER_BY_EVENT_NAME
+ - MEMORY_SUMMARY_BY_HOST_BY_EVENT_NAME
+ in parallel.
+ */
+ aggregate_all_memory(alive,
+ write_instr_class_memory_stats(),
+ safe_user->write_instr_class_memory_stats(),
+ safe_host->write_instr_class_memory_stats());
+ return;
+ }
+
+ if (safe_user != NULL)
+ {
+ /*
+ Aggregate MEMORY_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME to:
+ - MEMORY_SUMMARY_BY_USER_BY_EVENT_NAME
+ - MEMORY_SUMMARY_GLOBAL_BY_EVENT_NAME
+ in parallel.
+ */
+ aggregate_all_memory(alive,
+ write_instr_class_memory_stats(),
+ safe_user->write_instr_class_memory_stats(),
+ global_instr_class_memory_array);
+ return;
+ }
+
+ if (safe_host != NULL)
+ {
+ /*
+ Aggregate MEMORY_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME to:
+ - MEMORY_SUMMARY_BY_HOST_BY_EVENT_NAME
+ */
+ aggregate_all_memory(alive,
+ write_instr_class_memory_stats(),
+ safe_host->write_instr_class_memory_stats());
+ return;
+ }
+
+ /*
+ Aggregate MEMORY_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME to:
+ - MEMORY_SUMMARY_GLOBAL_BY_EVENT_NAME
+ */
+ aggregate_all_memory(alive,
+ write_instr_class_memory_stats(),
+ global_instr_class_memory_array);
+ return;
+}
+
+void PFS_account::aggregate_status(PFS_user *safe_user, PFS_host *safe_host)
+{
+ if (likely(safe_user != NULL && safe_host != NULL))
+ {
+ /*
+ Aggregate STATUS_BY_ACCOUNT to:
+ - STATUS_BY_USER
+ - STATUS_BY_HOST
+ */
+ safe_user->m_status_stats.aggregate(& m_status_stats);
+ safe_host->m_status_stats.aggregate(& m_status_stats);
+ m_status_stats.reset();
+ return;
+ }
+
+ if (safe_user != NULL)
+ {
+ /*
+ Aggregate STATUS_BY_ACCOUNT to:
+ - STATUS_BY_USER
+ - GLOBAL_STATUS
+ */
+ safe_user->m_status_stats.aggregate(& m_status_stats);
+ //m_status_stats.aggregate_to(& global_status_var);
+ m_status_stats.reset();
+ return;
+ }
+
+ if (safe_host != NULL)
+ {
+ /*
+ Aggregate STATUS_BY_ACCOUNT to:
+ - STATUS_BY_HOST
+ */
+ safe_host->m_status_stats.aggregate(& m_status_stats);
+ m_status_stats.reset();
+ return;
+ }
+
+ /*
+ Aggregate STATUS_BY_ACCOUNT to:
+ - GLOBAL_STATUS
+ */
+ //m_status_stats.aggregate_to(& global_status_var);
+ m_status_stats.reset();
+ return;
+}
+
+void PFS_account::aggregate_stats(PFS_user *safe_user, PFS_host *safe_host)
+{
+ if (likely(safe_user != NULL && safe_host != NULL))
+ {
+ safe_user->m_disconnected_count+= m_disconnected_count;
+ safe_host->m_disconnected_count+= m_disconnected_count;
+ m_disconnected_count= 0;
+ return;
+ }
+
+ if (safe_user != NULL)
+ {
+ safe_user->m_disconnected_count+= m_disconnected_count;
+ m_disconnected_count= 0;
+ return;
+ }
+
+ if (safe_host != NULL)
+ {
+ safe_host->m_disconnected_count+= m_disconnected_count;
+ m_disconnected_count= 0;
+ return;
+ }
+
+ m_disconnected_count= 0;
+ return;
+}
+
+void PFS_account::release()
+{
+ dec_refcount();
+}
+
+void PFS_account::carry_memory_stat_delta(PFS_memory_stat_delta *delta, uint index)
+{
+ PFS_memory_stat *event_name_array;
+ PFS_memory_stat *stat;
+ PFS_memory_stat_delta delta_buffer;
+ PFS_memory_stat_delta *remaining_delta;
+
+ event_name_array= write_instr_class_memory_stats();
+ stat= & event_name_array[index];
+ remaining_delta= stat->apply_delta(delta, &delta_buffer);
+
+ if (remaining_delta == NULL)
+ return;
+
+ if (m_user != NULL)
+ {
+ m_user->carry_memory_stat_delta(remaining_delta, index);
+ /* do not return, need to process m_host below */
+ }
+
+ if (m_host != NULL)
+ {
+ m_host->carry_memory_stat_delta(remaining_delta, index);
+ return;
+ }
+
+ carry_global_memory_stat_delta(remaining_delta, index);
+}
+
+PFS_account *sanitize_account(PFS_account *unsafe)
+{
+ return global_account_container.sanitize(unsafe);
+}
+
+void purge_account(PFS_thread *thread, PFS_account *account)
+{
+ LF_PINS *pins= get_account_hash_pins(thread);
+ if (unlikely(pins == NULL))
+ return;
+
+ PFS_account **entry;
+ entry= reinterpret_cast<PFS_account**>
+ (lf_hash_search(&account_hash, pins,
+ account->m_key.m_hash_key,
+ account->m_key.m_key_length));
+ if (entry && (entry != MY_ERRPTR))
+ {
+ DBUG_ASSERT(*entry == account);
+ if (account->get_refcount() == 0)
+ {
+ lf_hash_delete(&account_hash, pins,
+ account->m_key.m_hash_key,
+ account->m_key.m_key_length);
+ account->aggregate(false, account->m_user, account->m_host);
+ if (account->m_user != NULL)
+ {
+ account->m_user->release();
+ account->m_user= NULL;
+ }
+ if (account->m_host != NULL)
+ {
+ account->m_host->release();
+ account->m_host= NULL;
+ }
+ global_account_container.deallocate(account);
+ }
+ }
+
+ lf_hash_search_unpin(pins);
+}
+
+class Proc_purge_account
+ : public PFS_buffer_processor<PFS_account>
+{
+public:
+ Proc_purge_account(PFS_thread *thread)
+ : m_thread(thread)
+ {}
+
+ virtual void operator()(PFS_account *pfs)
+ {
+ PFS_user *user= sanitize_user(pfs->m_user);
+ PFS_host *host= sanitize_host(pfs->m_host);
+ pfs->aggregate(true, user, host);
+
+ if (pfs->get_refcount() == 0)
+ purge_account(m_thread, pfs);
+ }
+
+private:
+ PFS_thread *m_thread;
+};
+
+/** Purge non connected accounts, reset stats of connected account. */
+void purge_all_account(void)
+{
+ PFS_thread *thread= PFS_thread::get_current_thread();
+ if (unlikely(thread == NULL))
+ return;
+
+ Proc_purge_account proc(thread);
+ global_account_container.apply(proc);
+}
+
+class Proc_update_accounts_derived_flags
+ : public PFS_buffer_processor<PFS_account>
+{
+public:
+ Proc_update_accounts_derived_flags(PFS_thread *thread)
+ : m_thread(thread)
+ {}
+
+ virtual void operator()(PFS_account *pfs)
+ {
+ if (pfs->m_username_length > 0 && pfs->m_hostname_length > 0)
+ {
+ lookup_setup_actor(m_thread,
+ pfs->m_username, pfs->m_username_length,
+ pfs->m_hostname, pfs->m_hostname_length,
+ & pfs->m_enabled, & pfs->m_history);
+ }
+ else
+ {
+ pfs->m_enabled= true;
+ pfs->m_history= true;
+ }
+ }
+
+private:
+ PFS_thread *m_thread;
+};
+
+void update_accounts_derived_flags(PFS_thread *thread)
+{
+ Proc_update_accounts_derived_flags proc(thread);
+ global_account_container.apply(proc);
+}
+
+/** @} */
diff --git a/storage/perfschema/pfs_account.h b/storage/perfschema/pfs_account.h
new file mode 100644
index 00000000..8a966f4c
--- /dev/null
+++ b/storage/perfschema/pfs_account.h
@@ -0,0 +1,136 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef PFS_ACCOUNT_H
+#define PFS_ACCOUNT_H
+
+/**
+ @file storage/perfschema/pfs_account.h
+ Performance schema account (declarations).
+*/
+
+#include "pfs_lock.h"
+#include "lf.h"
+#include "pfs_con_slice.h"
+#include "mysql_com.h" /* USERNAME_LENGTH */
+
+struct PFS_global_param;
+struct PFS_user;
+struct PFS_host;
+struct PFS_thread;
+struct PFS_memory_stat_delta;
+
+/**
+ @addtogroup Performance_schema_buffers
+ @{
+*/
+
+/** Hash key for an account. */
+struct PFS_account_key
+{
+ /**
+ Hash search key.
+ This has to be a string for LF_HASH,
+ the format is "<username><0x00><hostname><0x00>"
+ */
+ char m_hash_key[USERNAME_LENGTH + 1 + HOSTNAME_LENGTH + 1];
+ uint m_key_length;
+};
+
+/** Per account statistics. */
+struct PFS_ALIGNED PFS_account : PFS_connection_slice
+{
+public:
+ inline void init_refcount(void)
+ {
+ PFS_atomic::store_32(& m_refcount, 1);
+ }
+
+ inline int get_refcount(void)
+ {
+ return PFS_atomic::load_32(& m_refcount);
+ }
+
+ inline void inc_refcount(void)
+ {
+ PFS_atomic::add_32(& m_refcount, 1);
+ }
+
+ inline void dec_refcount(void)
+ {
+ PFS_atomic::add_32(& m_refcount, -1);
+ }
+
+ void aggregate(bool alive, PFS_user *safe_user, PFS_host *safe_host);
+ void aggregate_waits(PFS_user *safe_user, PFS_host *safe_host);
+ void aggregate_stages(PFS_user *safe_user, PFS_host *safe_host);
+ void aggregate_statements(PFS_user *safe_user, PFS_host *safe_host);
+ void aggregate_transactions(PFS_user *safe_user, PFS_host *safe_host);
+ void aggregate_memory(bool alive, PFS_user *safe_user, PFS_host *safe_host);
+ void aggregate_status(PFS_user *safe_user, PFS_host *safe_host);
+ void aggregate_stats(PFS_user *safe_user, PFS_host *safe_host);
+ void release(void);
+
+ void carry_memory_stat_delta(PFS_memory_stat_delta *delta, uint index);
+
+ /** Internal lock. */
+ pfs_lock m_lock;
+ PFS_account_key m_key;
+ /** True if this account is enabled, per rules in table SETUP_ACTORS. */
+ bool m_enabled;
+ /** True if this account has history enabled, per rules in table SETUP_ACTORS. */
+ bool m_history;
+ const char *m_username;
+ uint m_username_length;
+ const char *m_hostname;
+ uint m_hostname_length;
+ PFS_user *m_user;
+ PFS_host *m_host;
+
+ ulonglong m_disconnected_count;
+
+private:
+ int m_refcount;
+};
+
+int init_account(const PFS_global_param *param);
+void cleanup_account(void);
+int init_account_hash(const PFS_global_param *param);
+void cleanup_account_hash(void);
+
+PFS_account *
+find_or_create_account(PFS_thread *thread,
+ const char *username, uint username_length,
+ const char *hostname, uint hostname_length);
+
+PFS_account *sanitize_account(PFS_account *unsafe);
+void purge_all_account(void);
+
+void update_accounts_derived_flags(PFS_thread *thread);
+
+/* For show status. */
+
+extern LF_HASH account_hash;
+
+/** @} */
+#endif
+
diff --git a/storage/perfschema/pfs_atomic.h b/storage/perfschema/pfs_atomic.h
new file mode 100644
index 00000000..959b66dc
--- /dev/null
+++ b/storage/perfschema/pfs_atomic.h
@@ -0,0 +1,141 @@
+/* Copyright (c) 2009, 2013, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef PFS_ATOMIC_H
+#define PFS_ATOMIC_H
+
+/**
+ @file storage/perfschema/pfs_atomic.h
+ Atomic operations (declarations).
+*/
+
+#include <my_atomic.h>
+
+/** Helper for atomic operations. */
+class PFS_atomic
+{
+public:
+ /** Atomic load. */
+ static inline int32 load_32(int32 *ptr)
+ {
+ return my_atomic_load32(ptr);
+ }
+
+ /** Atomic load. */
+ static inline int64 load_64(int64 *ptr)
+ {
+ return my_atomic_load64(ptr);
+ }
+
+ /** Atomic load. */
+ static inline uint32 load_u32(uint32 *ptr)
+ {
+ return (uint32) my_atomic_load32((int32*) ptr);
+ }
+
+ /** Atomic load. */
+ static inline uint64 load_u64(uint64 *ptr)
+ {
+ return (uint64) my_atomic_load64((int64*) ptr);
+ }
+
+ /** Atomic store. */
+ static inline void store_32(int32 *ptr, int32 value)
+ {
+ my_atomic_store32(ptr, value);
+ }
+
+ /** Atomic store. */
+ static inline void store_64(int64 *ptr, int64 value)
+ {
+ my_atomic_store64(ptr, value);
+ }
+
+ /** Atomic store. */
+ static inline void store_u32(uint32 *ptr, uint32 value)
+ {
+ my_atomic_store32((int32*) ptr, (int32) value);
+ }
+
+ /** Atomic store. */
+ static inline void store_u64(uint64 *ptr, uint64 value)
+ {
+ my_atomic_store64((int64*) ptr, (int64) value);
+ }
+
+ /** Atomic add. */
+ static inline int32 add_32(int32 *ptr, int32 value)
+ {
+ return my_atomic_add32(ptr, value);
+ }
+
+ /** Atomic add. */
+ static inline int64 add_64(int64 *ptr, int64 value)
+ {
+ return my_atomic_add64(ptr, value);
+ }
+
+ /** Atomic add. */
+ static inline uint32 add_u32(uint32 *ptr, uint32 value)
+ {
+ return (uint32) my_atomic_add32((int32*) ptr, (int32) value);
+ }
+
+ /** Atomic add. */
+ static inline uint64 add_u64(uint64 *ptr, uint64 value)
+ {
+ return (uint64) my_atomic_add64((int64*) ptr, (int64) value);
+ }
+
+ /** Atomic compare and swap. */
+ static inline bool cas_32(int32 *ptr, int32 *old_value,
+ int32 new_value)
+ {
+ return my_atomic_cas32(ptr, old_value, new_value);
+ }
+
+ /** Atomic compare and swap. */
+ static inline bool cas_64(int64 *ptr, int64 *old_value,
+ int64 new_value)
+ {
+ return my_atomic_cas64(ptr, old_value, new_value);
+ }
+
+ /** Atomic compare and swap. */
+ static inline bool cas_u32(uint32 *ptr, uint32 *old_value,
+ uint32 new_value)
+ {
+ return my_atomic_cas32((int32*) ptr, (int32*) old_value,
+ (uint32) new_value);
+ }
+
+ /** Atomic compare and swap. */
+ static inline bool cas_u64(uint64 *ptr, uint64 *old_value,
+ uint64 new_value)
+ {
+ return my_atomic_cas64((int64*) ptr, (int64*) old_value,
+ (uint64) new_value);
+ }
+};
+
+#endif
+
diff --git a/storage/perfschema/pfs_autosize.cc b/storage/perfschema/pfs_autosize.cc
new file mode 100644
index 00000000..024f5519
--- /dev/null
+++ b/storage/perfschema/pfs_autosize.cc
@@ -0,0 +1,315 @@
+/* Copyright (c) 2012, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/pfs_autosize.cc
+ Private interface for the server (implementation).
+*/
+
+#include "my_global.h"
+#include "sql_const.h"
+#include "pfs_server.h"
+#include "set_var.h"
+
+#include "my_thread.h" /* For pthread_t */
+/* Make sure HAVE_PSI_XXX_INTERFACE flags are set */
+#include "mysql/psi/psi.h"
+
+#include <algorithm>
+using std::min;
+using std::max;
+
+/** Performance schema sizing heuristics. */
+struct PFS_sizing_data
+{
+ /** Default value for @c PFS_param.m_events_waits_history_sizing. */
+ ulong m_events_waits_history_sizing;
+ /** Default value for @c PFS_param.m_events_waits_history_long_sizing. */
+ ulong m_events_waits_history_long_sizing;
+ /** Default value for @c PFS_param.m_events_stages_history_sizing. */
+ ulong m_events_stages_history_sizing;
+ /** Default value for @c PFS_param.m_events_stages_history_long_sizing. */
+ ulong m_events_stages_history_long_sizing;
+ /** Default value for @c PFS_param.m_events_statements_history_sizing. */
+ ulong m_events_statements_history_sizing;
+ /** Default value for @c PFS_param.m_events_statements_history_long_sizing. */
+ ulong m_events_statements_history_long_sizing;
+ /** Default value for @c PFS_param.m_events_transactions_history_sizing. */
+ ulong m_events_transactions_history_sizing;
+ /** Default value for @c PFS_param.m_events_transactions_history_long_sizing. */
+ ulong m_events_transactions_history_long_sizing;
+ /** Default value for @c PFS_param.m_digest_sizing. */
+ ulong m_digest_sizing;
+ /** Default value for @c PFS_param.m_session_connect_attrs_sizing. */
+ ulong m_session_connect_attrs_sizing;
+};
+
+PFS_sizing_data small_data=
+{
+ /* History sizes */
+ 5, 100, 5, 100, 5, 100, 5, 100,
+ /* Digests */
+ 1000,
+ /* Session connect attrs. */
+ 512
+};
+
+PFS_sizing_data medium_data=
+{
+ /* History sizes */
+ 10, 1000, 10, 1000, 10, 1000, 10, 1000,
+ /* Digests */
+ 5000,
+ /* Session connect attrs. */
+ 512
+};
+
+PFS_sizing_data large_data=
+{
+ /* History sizes */
+ 10, 10000, 10, 10000, 10, 10000, 10, 10000,
+ /* Digests */
+ 10000,
+ /* Session connect attrs. */
+ 512
+};
+
+PFS_sizing_data *estimate_hints(PFS_global_param *param)
+{
+ if ((param->m_hints.m_max_connections <= MAX_CONNECTIONS_DEFAULT) &&
+ (param->m_hints.m_table_definition_cache <= TABLE_DEF_CACHE_DEFAULT) &&
+ (param->m_hints.m_table_open_cache <= TABLE_OPEN_CACHE_DEFAULT))
+ {
+ /* The my.cnf used is either unchanged, or lower than factory defaults. */
+ return & small_data;
+ }
+
+ if ((param->m_hints.m_max_connections <= MAX_CONNECTIONS_DEFAULT * 2) &&
+ (param->m_hints.m_table_definition_cache <= TABLE_DEF_CACHE_DEFAULT * 2) &&
+ (param->m_hints.m_table_open_cache <= TABLE_OPEN_CACHE_DEFAULT * 2))
+ {
+ /* Some defaults have been increased, to "moderate" values. */
+ return & medium_data;
+ }
+
+ /* Looks like a server in production. */
+ return & large_data;
+}
+
+static void apply_heuristic(PFS_global_param *p, PFS_sizing_data *h)
+{
+ if (p->m_events_waits_history_sizing < 0)
+ {
+ SYSVAR_AUTOSIZE(p->m_events_waits_history_sizing,
+ h->m_events_waits_history_sizing);
+ }
+
+ if (p->m_events_waits_history_long_sizing < 0)
+ {
+ SYSVAR_AUTOSIZE(p->m_events_waits_history_long_sizing,
+ h->m_events_waits_history_long_sizing);
+ }
+
+ if (p->m_events_stages_history_sizing < 0)
+ {
+ SYSVAR_AUTOSIZE(p->m_events_stages_history_sizing,
+ h->m_events_stages_history_sizing);
+ }
+
+ if (p->m_events_stages_history_long_sizing < 0)
+ {
+ SYSVAR_AUTOSIZE(p->m_events_stages_history_long_sizing,
+ h->m_events_stages_history_long_sizing);
+ }
+
+ if (p->m_events_statements_history_sizing < 0)
+ {
+ SYSVAR_AUTOSIZE(p->m_events_statements_history_sizing,
+ h->m_events_statements_history_sizing);
+ }
+
+ if (p->m_events_statements_history_long_sizing < 0)
+ {
+ SYSVAR_AUTOSIZE(p->m_events_statements_history_long_sizing,
+ h->m_events_statements_history_long_sizing);
+ }
+
+ if (p->m_digest_sizing < 0)
+ {
+ SYSVAR_AUTOSIZE(p->m_digest_sizing,
+ h->m_digest_sizing);
+ }
+
+ if (p->m_events_transactions_history_sizing < 0)
+ {
+ SYSVAR_AUTOSIZE(p->m_events_transactions_history_sizing,
+ h->m_events_transactions_history_sizing);
+ }
+
+ if (p->m_events_transactions_history_long_sizing < 0)
+ {
+ SYSVAR_AUTOSIZE(p->m_events_transactions_history_long_sizing,
+ h->m_events_transactions_history_long_sizing);
+ }
+
+ if (p->m_session_connect_attrs_sizing < 0)
+ {
+ SYSVAR_AUTOSIZE(p->m_session_connect_attrs_sizing,
+ h->m_session_connect_attrs_sizing);
+ }
+}
+
+void pfs_automated_sizing(PFS_global_param *param)
+{
+ if (param->m_enabled)
+ {
+#ifndef HAVE_PSI_MUTEX_INTERFACE
+ param->m_mutex_class_sizing= 0;
+ param->m_mutex_sizing= 0;
+#endif
+
+#ifndef HAVE_PSI_RWLOCK_INTERFACE
+ param->m_rwlock_class_sizing= 0;
+ param->m_rwlock_sizing= 0;
+#endif
+
+#ifndef HAVE_PSI_COND_INTERFACE
+ param->m_cond_class_sizing= 0;
+ param->m_cond_sizing= 0;
+#endif
+
+#ifndef HAVE_PSI_FILE_INTERFACE
+ param->m_file_class_sizing= 0;
+ param->m_file_sizing= 0;
+ param->m_file_handle_sizing= 0;
+#endif
+
+#ifndef HAVE_PSI_TABLE_INTERFACE
+ param->m_table_share_sizing= 0;
+ param->m_table_sizing= 0;
+ param->m_table_lock_stat_sizing= 0;
+ param->m_index_stat_sizing= 0;
+#endif
+
+#ifndef HAVE_PSI_SOCKET_INTERFACE
+ param->m_socket_class_sizing= 0;
+ param->m_socket_sizing= 0;
+#endif
+
+#ifndef HAVE_PSI_STAGE_INTERFACE
+ param->m_stage_class_sizing= 0;
+ param->m_events_stages_history_sizing= 0;
+ param->m_events_stages_history_long_sizing= 0;
+#endif
+
+#ifndef HAVE_PSI_STATEMENT_INTERFACE
+ param->m_statement_class_sizing= 0;
+ param->m_events_statements_history_sizing= 0;
+ param->m_events_statements_history_long_sizing= 0;
+#endif
+
+#ifndef HAVE_PSI_SP_INTERFACE
+ param->m_program_sizing= 0;
+ if (param->m_statement_stack_sizing > 1)
+ param->m_statement_stack_sizing= 1;
+#endif
+
+#ifndef HAVE_PSI_PS_INTERFACE
+ param->m_prepared_stmt_sizing= 0;
+#endif
+
+#ifndef HAVE_PSI_STATEMENT_DIGEST_INTERFACE
+ param->m_digest_sizing= 0;
+#endif
+
+#ifndef HAVE_PSI_METADATA_INTERFACE
+ param->m_metadata_lock_sizing= 0;
+#endif
+
+#ifndef HAVE_PSI_MEMORY_INTERFACE
+ param->m_memory_class_sizing= 0;
+#endif
+
+ PFS_sizing_data *heuristic;
+ heuristic= estimate_hints(param);
+ apply_heuristic(param, heuristic);
+
+ DBUG_ASSERT(param->m_events_waits_history_sizing >= 0);
+ DBUG_ASSERT(param->m_events_waits_history_long_sizing >= 0);
+ DBUG_ASSERT(param->m_events_stages_history_sizing >= 0);
+ DBUG_ASSERT(param->m_events_stages_history_long_sizing >= 0);
+ DBUG_ASSERT(param->m_events_statements_history_sizing >= 0);
+ DBUG_ASSERT(param->m_events_statements_history_long_sizing >= 0);
+ DBUG_ASSERT(param->m_events_transactions_history_sizing >= 0);
+ DBUG_ASSERT(param->m_events_transactions_history_long_sizing >= 0);
+ DBUG_ASSERT(param->m_session_connect_attrs_sizing >= 0);
+ }
+ else
+ {
+ /*
+ The Performance Schema is disabled. Set the instrument sizings to zero to
+ disable all instrumentation while retaining support for the status and
+ system variable tables, the host cache table and the replication tables.
+ */
+ SYSVAR_AUTOSIZE(param->m_mutex_class_sizing, 0);
+ SYSVAR_AUTOSIZE(param->m_rwlock_class_sizing, 0);
+ SYSVAR_AUTOSIZE(param->m_cond_class_sizing, 0);
+ SYSVAR_AUTOSIZE(param->m_thread_class_sizing, 0);
+ SYSVAR_AUTOSIZE(param->m_table_share_sizing, 0);
+ SYSVAR_AUTOSIZE(param->m_table_lock_stat_sizing, 0);
+ SYSVAR_AUTOSIZE(param->m_index_stat_sizing, 0);
+ SYSVAR_AUTOSIZE(param->m_file_class_sizing, 0);
+ SYSVAR_AUTOSIZE(param->m_mutex_sizing, 0);
+ SYSVAR_AUTOSIZE(param->m_rwlock_sizing, 0);
+ SYSVAR_AUTOSIZE(param->m_cond_sizing, 0);
+ SYSVAR_AUTOSIZE(param->m_thread_sizing, 0);
+ SYSVAR_AUTOSIZE(param->m_table_sizing, 0);
+ SYSVAR_AUTOSIZE(param->m_file_sizing, 0);
+ SYSVAR_AUTOSIZE(param->m_file_handle_sizing, 0);
+ SYSVAR_AUTOSIZE(param->m_socket_sizing, 0);
+ SYSVAR_AUTOSIZE(param->m_socket_class_sizing, 0);
+ SYSVAR_AUTOSIZE(param->m_events_waits_history_sizing, 0);
+ SYSVAR_AUTOSIZE(param->m_events_waits_history_long_sizing, 0);
+ SYSVAR_AUTOSIZE(param->m_setup_actor_sizing, 0);
+ SYSVAR_AUTOSIZE(param->m_setup_object_sizing, 0);
+ SYSVAR_AUTOSIZE(param->m_host_sizing, 0);
+ SYSVAR_AUTOSIZE(param->m_user_sizing, 0);
+ SYSVAR_AUTOSIZE(param->m_account_sizing, 0);
+ SYSVAR_AUTOSIZE(param->m_stage_class_sizing, 0);
+ SYSVAR_AUTOSIZE(param->m_events_stages_history_sizing, 0);
+ SYSVAR_AUTOSIZE(param->m_events_stages_history_long_sizing, 0);
+ SYSVAR_AUTOSIZE(param->m_statement_class_sizing, 0);
+ SYSVAR_AUTOSIZE(param->m_events_statements_history_sizing, 0);
+ SYSVAR_AUTOSIZE(param->m_events_statements_history_long_sizing, 0);
+ SYSVAR_AUTOSIZE(param->m_digest_sizing, 0);
+ SYSVAR_AUTOSIZE(param->m_program_sizing, 0);
+ SYSVAR_AUTOSIZE(param->m_prepared_stmt_sizing, 0);
+ SYSVAR_AUTOSIZE(param->m_events_transactions_history_sizing, 0);
+ SYSVAR_AUTOSIZE(param->m_events_transactions_history_long_sizing, 0);
+ SYSVAR_AUTOSIZE(param->m_session_connect_attrs_sizing, 0);
+ SYSVAR_AUTOSIZE(param->m_statement_stack_sizing, 0);
+ SYSVAR_AUTOSIZE(param->m_memory_class_sizing, 0);
+ SYSVAR_AUTOSIZE(param->m_metadata_lock_sizing, 0);
+ SYSVAR_AUTOSIZE(param->m_max_digest_length, 0);
+ SYSVAR_AUTOSIZE(param->m_max_sql_text_length, 0);
+ }
+}
diff --git a/storage/perfschema/pfs_buffer_container.cc b/storage/perfschema/pfs_buffer_container.cc
new file mode 100644
index 00000000..cd87cb24
--- /dev/null
+++ b/storage/perfschema/pfs_buffer_container.cc
@@ -0,0 +1,883 @@
+/* Copyright (c) 2014, 2016, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
+
+#include "my_global.h"
+#include "pfs_global.h"
+#include "pfs_lock.h"
+#include "pfs_account.h"
+#include "pfs_user.h"
+#include "pfs_host.h"
+#include "pfs_buffer_container.h"
+#include "pfs_builtin_memory.h"
+
+PFS_buffer_default_allocator<PFS_mutex> default_mutex_allocator(& builtin_memory_mutex);
+PFS_mutex_container global_mutex_container(& default_mutex_allocator);
+
+PFS_buffer_default_allocator<PFS_rwlock> default_rwlock_allocator(& builtin_memory_rwlock);
+PFS_rwlock_container global_rwlock_container(& default_rwlock_allocator);
+
+PFS_buffer_default_allocator<PFS_cond> default_cond_allocator(& builtin_memory_cond);
+PFS_cond_container global_cond_container(& default_cond_allocator);
+
+PFS_buffer_default_allocator<PFS_file> default_file_allocator(& builtin_memory_file);
+PFS_file_container global_file_container(& default_file_allocator);
+
+PFS_buffer_default_allocator<PFS_socket> default_socket_allocator(& builtin_memory_socket);
+PFS_socket_container global_socket_container(& default_socket_allocator);
+
+PFS_buffer_default_allocator<PFS_metadata_lock> default_mdl_allocator(& builtin_memory_mdl);
+PFS_mdl_container global_mdl_container(& default_mdl_allocator);
+
+PFS_buffer_default_allocator<PFS_setup_actor> default_setup_actor_allocator(& builtin_memory_setup_actor);
+PFS_setup_actor_container global_setup_actor_container(& default_setup_actor_allocator);
+
+PFS_buffer_default_allocator<PFS_setup_object> default_setup_object_allocator(& builtin_memory_setup_object);
+PFS_setup_object_container global_setup_object_container(& default_setup_object_allocator);
+
+PFS_buffer_default_allocator<PFS_table> default_table_allocator(& builtin_memory_table);
+PFS_table_container global_table_container(& default_table_allocator);
+
+PFS_buffer_default_allocator<PFS_table_share> default_table_share_allocator(& builtin_memory_table_share);
+PFS_table_share_container global_table_share_container(& default_table_share_allocator);
+
+PFS_buffer_default_allocator<PFS_table_share_index> default_table_share_index_allocator(& builtin_memory_table_share_index);
+PFS_table_share_index_container global_table_share_index_container(& default_table_share_index_allocator);
+
+PFS_buffer_default_allocator<PFS_table_share_lock> default_table_share_lock_allocator(& builtin_memory_table_share_lock);
+PFS_table_share_lock_container global_table_share_lock_container(& default_table_share_lock_allocator);
+
+PFS_buffer_default_allocator<PFS_program> default_program_allocator(& builtin_memory_program);
+PFS_program_container global_program_container(& default_program_allocator);
+
+PFS_buffer_default_allocator<PFS_prepared_stmt> default_prepared_stmt_allocator(& builtin_memory_prepared_stmt);
+PFS_prepared_stmt_container global_prepared_stmt_container(& default_prepared_stmt_allocator);
+
+int PFS_account_allocator::alloc_array(PFS_account_array *array)
+{
+ size_t size= array->m_max;
+ size_t index;
+ size_t waits_sizing= size * wait_class_max;
+ size_t stages_sizing= size * stage_class_max;
+ size_t statements_sizing= size * statement_class_max;
+ size_t transactions_sizing= size * transaction_class_max;
+ size_t memory_sizing= size * memory_class_max;
+
+ array->m_ptr= NULL;
+ array->m_full= true;
+ array->m_instr_class_waits_array= NULL;
+ array->m_instr_class_stages_array= NULL;
+ array->m_instr_class_statements_array= NULL;
+ array->m_instr_class_transactions_array= NULL;
+ array->m_instr_class_memory_array= NULL;
+
+ if (size > 0)
+ {
+ array->m_ptr=
+ PFS_MALLOC_ARRAY(& builtin_memory_account,
+ size, sizeof(PFS_account), PFS_account, MYF(MY_ZEROFILL));
+ if (array->m_ptr == NULL)
+ return 1;
+ }
+
+ if (waits_sizing > 0)
+ {
+ array->m_instr_class_waits_array=
+ PFS_MALLOC_ARRAY(& builtin_memory_account_waits,
+ waits_sizing, sizeof(PFS_single_stat), PFS_single_stat, MYF(MY_ZEROFILL));
+ if (array->m_instr_class_waits_array == NULL)
+ return 1;
+
+ for (index=0; index < waits_sizing; index++)
+ array->m_instr_class_waits_array[index].reset();
+ }
+
+ if (stages_sizing > 0)
+ {
+ array->m_instr_class_stages_array=
+ PFS_MALLOC_ARRAY(& builtin_memory_account_stages,
+ stages_sizing, sizeof(PFS_stage_stat), PFS_stage_stat, MYF(MY_ZEROFILL));
+ if (array->m_instr_class_stages_array == NULL)
+ return 1;
+
+ for (index=0; index < stages_sizing; index++)
+ array->m_instr_class_stages_array[index].reset();
+ }
+
+ if (statements_sizing > 0)
+ {
+ array->m_instr_class_statements_array=
+ PFS_MALLOC_ARRAY(& builtin_memory_account_statements,
+ statements_sizing, sizeof(PFS_statement_stat), PFS_statement_stat, MYF(MY_ZEROFILL));
+ if (array->m_instr_class_statements_array == NULL)
+ return 1;
+
+ for (index=0; index < statements_sizing; index++)
+ array->m_instr_class_statements_array[index].reset();
+ }
+
+ if (transactions_sizing > 0)
+ {
+ array->m_instr_class_transactions_array=
+ PFS_MALLOC_ARRAY(& builtin_memory_account_transactions,
+ transactions_sizing, sizeof(PFS_transaction_stat), PFS_transaction_stat, MYF(MY_ZEROFILL));
+ if (array->m_instr_class_transactions_array == NULL)
+ return 1;
+
+ for (index=0; index < transactions_sizing; index++)
+ array->m_instr_class_transactions_array[index].reset();
+ }
+
+ if (memory_sizing > 0)
+ {
+ array->m_instr_class_memory_array=
+ PFS_MALLOC_ARRAY(& builtin_memory_account_memory,
+ memory_sizing, sizeof(PFS_memory_stat), PFS_memory_stat, MYF(MY_ZEROFILL));
+ if (array->m_instr_class_memory_array == NULL)
+ return 1;
+
+ for (index=0; index < memory_sizing; index++)
+ array->m_instr_class_memory_array[index].reset();
+ }
+
+ for (index= 0; index < size; index++)
+ {
+ array->m_ptr[index].set_instr_class_waits_stats(
+ & array->m_instr_class_waits_array[index * wait_class_max]);
+ array->m_ptr[index].set_instr_class_stages_stats(
+ & array->m_instr_class_stages_array[index * stage_class_max]);
+ array->m_ptr[index].set_instr_class_statements_stats(
+ & array->m_instr_class_statements_array[index * statement_class_max]);
+ array->m_ptr[index].set_instr_class_transactions_stats(
+ & array->m_instr_class_transactions_array[index * transaction_class_max]);
+ array->m_ptr[index].set_instr_class_memory_stats(
+ & array->m_instr_class_memory_array[index * memory_class_max]);
+ }
+
+ array->m_full= false;
+ return 0;
+}
+
+void PFS_account_allocator::free_array(PFS_account_array *array)
+{
+ size_t size= array->m_max;
+ size_t waits_sizing= size * wait_class_max;
+ size_t stages_sizing= size * stage_class_max;
+ size_t statements_sizing= size * statement_class_max;
+ size_t transactions_sizing= size * transaction_class_max;
+ size_t memory_sizing= size * memory_class_max;
+
+ PFS_FREE_ARRAY(& builtin_memory_account,
+ size, sizeof(PFS_account), array->m_ptr);
+ array->m_ptr= NULL;
+
+ PFS_FREE_ARRAY(& builtin_memory_account_waits,
+ waits_sizing, sizeof(PFS_single_stat),
+ array->m_instr_class_waits_array);
+ array->m_instr_class_waits_array= NULL;
+
+ PFS_FREE_ARRAY(& builtin_memory_account_stages,
+ stages_sizing, sizeof(PFS_stage_stat),
+ array->m_instr_class_stages_array);
+ array->m_instr_class_stages_array= NULL;
+
+ PFS_FREE_ARRAY(& builtin_memory_account_statements,
+ statements_sizing, sizeof(PFS_statement_stat),
+ array->m_instr_class_statements_array);
+ array->m_instr_class_statements_array= NULL;
+
+ PFS_FREE_ARRAY(& builtin_memory_account_transactions,
+ transactions_sizing, sizeof(PFS_transaction_stat),
+ array->m_instr_class_transactions_array);
+ array->m_instr_class_transactions_array= NULL;
+
+ PFS_FREE_ARRAY(& builtin_memory_account_memory,
+ memory_sizing, sizeof(PFS_memory_stat),
+ array->m_instr_class_memory_array);
+ array->m_instr_class_memory_array= NULL;
+}
+
+PFS_account_allocator account_allocator;
+PFS_account_container global_account_container(& account_allocator);
+
+int PFS_host_allocator::alloc_array(PFS_host_array *array)
+{
+ size_t size= array->m_max;
+ PFS_host *pfs;
+ size_t index;
+ size_t waits_sizing= size * wait_class_max;
+ size_t stages_sizing= size * stage_class_max;
+ size_t statements_sizing= size * statement_class_max;
+ size_t transactions_sizing= size * transaction_class_max;
+ size_t memory_sizing= size * memory_class_max;
+
+ array->m_ptr= NULL;
+ array->m_full= true;
+ array->m_instr_class_waits_array= NULL;
+ array->m_instr_class_stages_array= NULL;
+ array->m_instr_class_statements_array= NULL;
+ array->m_instr_class_transactions_array= NULL;
+ array->m_instr_class_memory_array= NULL;
+
+ if (size > 0)
+ {
+ array->m_ptr=
+ PFS_MALLOC_ARRAY(& builtin_memory_host,
+ size, sizeof(PFS_host), PFS_host, MYF(MY_ZEROFILL));
+ if (array->m_ptr == NULL)
+ return 1;
+ }
+
+ if (waits_sizing > 0)
+ {
+ array->m_instr_class_waits_array=
+ PFS_MALLOC_ARRAY(& builtin_memory_host_waits,
+ waits_sizing, sizeof(PFS_single_stat), PFS_single_stat, MYF(MY_ZEROFILL));
+ if (array->m_instr_class_waits_array == NULL)
+ return 1;
+
+ for (index=0; index < waits_sizing; index++)
+ array->m_instr_class_waits_array[index].reset();
+ }
+
+ if (stages_sizing > 0)
+ {
+ array->m_instr_class_stages_array=
+ PFS_MALLOC_ARRAY(& builtin_memory_host_stages,
+ stages_sizing, sizeof(PFS_stage_stat), PFS_stage_stat, MYF(MY_ZEROFILL));
+ if (array->m_instr_class_stages_array == NULL)
+ return 1;
+
+ for (index=0; index < stages_sizing; index++)
+ array->m_instr_class_stages_array[index].reset();
+ }
+
+ if (statements_sizing > 0)
+ {
+ array->m_instr_class_statements_array=
+ PFS_MALLOC_ARRAY(& builtin_memory_host_statements,
+ statements_sizing, sizeof(PFS_statement_stat), PFS_statement_stat, MYF(MY_ZEROFILL));
+ if (array->m_instr_class_statements_array == NULL)
+ return 1;
+
+ for (index=0; index < statements_sizing; index++)
+ array->m_instr_class_statements_array[index].reset();
+ }
+
+ if (transactions_sizing > 0)
+ {
+ array->m_instr_class_transactions_array=
+ PFS_MALLOC_ARRAY(& builtin_memory_host_transactions,
+ transactions_sizing, sizeof(PFS_transaction_stat), PFS_transaction_stat, MYF(MY_ZEROFILL));
+ if (array->m_instr_class_transactions_array == NULL)
+ return 1;
+
+ for (index=0; index < transactions_sizing; index++)
+ array->m_instr_class_transactions_array[index].reset();
+ }
+
+ if (memory_sizing > 0)
+ {
+ array->m_instr_class_memory_array=
+ PFS_MALLOC_ARRAY(& builtin_memory_host_memory,
+ memory_sizing, sizeof(PFS_memory_stat), PFS_memory_stat, MYF(MY_ZEROFILL));
+ if (array->m_instr_class_memory_array == NULL)
+ return 1;
+
+ for (index=0; index < memory_sizing; index++)
+ array->m_instr_class_memory_array[index].reset();
+ }
+
+ for (index= 0; index < size; index++)
+ {
+ pfs= & array->m_ptr[index];
+
+ pfs->set_instr_class_waits_stats(
+ & array->m_instr_class_waits_array[index * wait_class_max]);
+ pfs->set_instr_class_stages_stats(
+ & array->m_instr_class_stages_array[index * stage_class_max]);
+ pfs->set_instr_class_statements_stats(
+ & array->m_instr_class_statements_array[index * statement_class_max]);
+ pfs->set_instr_class_transactions_stats(
+ & array->m_instr_class_transactions_array[index * transaction_class_max]);
+ pfs->set_instr_class_memory_stats(
+ & array->m_instr_class_memory_array[index * memory_class_max]);
+ }
+
+ array->m_full= false;
+ return 0;
+}
+
+void PFS_host_allocator::free_array(PFS_host_array *array)
+{
+ size_t size= array->m_max;
+ size_t waits_sizing= size * wait_class_max;
+ size_t stages_sizing= size * stage_class_max;
+ size_t statements_sizing= size * statement_class_max;
+ size_t transactions_sizing= size * transaction_class_max;
+ size_t memory_sizing= size * memory_class_max;
+
+ PFS_FREE_ARRAY(& builtin_memory_host,
+ size, sizeof(PFS_host), array->m_ptr);
+ array->m_ptr= NULL;
+
+ PFS_FREE_ARRAY(& builtin_memory_host_waits,
+ waits_sizing, sizeof(PFS_single_stat),
+ array->m_instr_class_waits_array);
+ array->m_instr_class_waits_array= NULL;
+
+ PFS_FREE_ARRAY(& builtin_memory_host_stages,
+ stages_sizing, sizeof(PFS_stage_stat),
+ array->m_instr_class_stages_array);
+ array->m_instr_class_stages_array= NULL;
+
+ PFS_FREE_ARRAY(& builtin_memory_host_statements,
+ statements_sizing, sizeof(PFS_statement_stat),
+ array->m_instr_class_statements_array);
+ array->m_instr_class_statements_array= NULL;
+
+ PFS_FREE_ARRAY(& builtin_memory_host_transactions,
+ transactions_sizing, sizeof(PFS_transaction_stat),
+ array->m_instr_class_transactions_array);
+ array->m_instr_class_transactions_array= NULL;
+
+ PFS_FREE_ARRAY(& builtin_memory_host_memory,
+ memory_sizing, sizeof(PFS_memory_stat),
+ array->m_instr_class_memory_array);
+ array->m_instr_class_memory_array= NULL;
+}
+
+PFS_host_allocator host_allocator;
+PFS_host_container global_host_container(& host_allocator);
+
+int PFS_thread_allocator::alloc_array(PFS_thread_array *array)
+{
+ size_t size= array->m_max;
+ PFS_thread *pfs;
+ PFS_events_statements *pfs_stmt;
+ unsigned char *pfs_tokens;
+
+ size_t index;
+ size_t waits_sizing= size * wait_class_max;
+ size_t stages_sizing= size * stage_class_max;
+ size_t statements_sizing= size * statement_class_max;
+ size_t transactions_sizing= size * transaction_class_max;
+ size_t memory_sizing= size * memory_class_max;
+
+ size_t waits_history_sizing= size * events_waits_history_per_thread;
+ size_t stages_history_sizing= size * events_stages_history_per_thread;
+ size_t statements_history_sizing= size * events_statements_history_per_thread;
+ size_t statements_stack_sizing= size * statement_stack_max;
+ size_t transactions_history_sizing= size * events_transactions_history_per_thread;
+ size_t session_connect_attrs_sizing= size * session_connect_attrs_size_per_thread;
+
+ size_t current_sqltext_sizing= size * pfs_max_sqltext * statement_stack_max;
+ size_t history_sqltext_sizing= size * pfs_max_sqltext * events_statements_history_per_thread;
+ size_t current_digest_tokens_sizing= size * pfs_max_digest_length * statement_stack_max;
+ size_t history_digest_tokens_sizing= size * pfs_max_digest_length * events_statements_history_per_thread;
+
+ array->m_ptr= NULL;
+ array->m_full= true;
+ array->m_instr_class_waits_array= NULL;
+ array->m_instr_class_stages_array= NULL;
+ array->m_instr_class_statements_array= NULL;
+ array->m_instr_class_transactions_array= NULL;
+ array->m_instr_class_memory_array= NULL;
+
+ array->m_waits_history_array= NULL;
+ array->m_stages_history_array= NULL;
+ array->m_statements_history_array= NULL;
+ array->m_statements_stack_array= NULL;
+ array->m_transactions_history_array= NULL;
+ array->m_session_connect_attrs_array= NULL;
+
+ array->m_current_stmts_text_array= NULL;
+ array->m_current_stmts_digest_token_array= NULL;
+ array->m_history_stmts_text_array= NULL;
+ array->m_history_stmts_digest_token_array= NULL;
+
+ if (size > 0)
+ {
+ array->m_ptr=
+ PFS_MALLOC_ARRAY(& builtin_memory_thread,
+ size, sizeof(PFS_thread), PFS_thread, MYF(MY_ZEROFILL));
+ if (array->m_ptr == NULL)
+ return 1;
+ }
+
+ if (waits_sizing > 0)
+ {
+ array->m_instr_class_waits_array=
+ PFS_MALLOC_ARRAY(& builtin_memory_thread_waits,
+ waits_sizing, sizeof(PFS_single_stat), PFS_single_stat, MYF(MY_ZEROFILL));
+ if (array->m_instr_class_waits_array == NULL)
+ return 1;
+
+ for (index=0; index < waits_sizing; index++)
+ array->m_instr_class_waits_array[index].reset();
+ }
+
+ if (stages_sizing > 0)
+ {
+ array->m_instr_class_stages_array=
+ PFS_MALLOC_ARRAY(& builtin_memory_thread_stages,
+ stages_sizing, sizeof(PFS_stage_stat), PFS_stage_stat, MYF(MY_ZEROFILL));
+ if (array->m_instr_class_stages_array == NULL)
+ return 1;
+
+ for (index=0; index < stages_sizing; index++)
+ array->m_instr_class_stages_array[index].reset();
+ }
+
+ if (statements_sizing > 0)
+ {
+ array->m_instr_class_statements_array=
+ PFS_MALLOC_ARRAY(& builtin_memory_thread_statements,
+ statements_sizing, sizeof(PFS_statement_stat), PFS_statement_stat, MYF(MY_ZEROFILL));
+ if (array->m_instr_class_statements_array == NULL)
+ return 1;
+
+ for (index=0; index < statements_sizing; index++)
+ array->m_instr_class_statements_array[index].reset();
+ }
+
+ if (transactions_sizing > 0)
+ {
+ array->m_instr_class_transactions_array=
+ PFS_MALLOC_ARRAY(& builtin_memory_thread_transactions,
+ transactions_sizing, sizeof(PFS_transaction_stat), PFS_transaction_stat, MYF(MY_ZEROFILL));
+ if (array->m_instr_class_transactions_array == NULL)
+ return 1;
+
+ for (index=0; index < transactions_sizing; index++)
+ array->m_instr_class_transactions_array[index].reset();
+ }
+
+ if (memory_sizing > 0)
+ {
+ array->m_instr_class_memory_array=
+ PFS_MALLOC_ARRAY(& builtin_memory_thread_memory,
+ memory_sizing, sizeof(PFS_memory_stat), PFS_memory_stat, MYF(MY_ZEROFILL));
+ if (array->m_instr_class_memory_array == NULL)
+ return 1;
+
+ for (index=0; index < memory_sizing; index++)
+ array->m_instr_class_memory_array[index].reset();
+ }
+
+ if (waits_history_sizing > 0)
+ {
+ array->m_waits_history_array=
+ PFS_MALLOC_ARRAY(& builtin_memory_thread_waits_history,
+ waits_history_sizing, sizeof(PFS_events_waits), PFS_events_waits, MYF(MY_ZEROFILL));
+ if (unlikely(array->m_waits_history_array == NULL))
+ return 1;
+ }
+
+ if (stages_history_sizing > 0)
+ {
+ array->m_stages_history_array=
+ PFS_MALLOC_ARRAY(& builtin_memory_thread_stages_history,
+ stages_history_sizing, sizeof(PFS_events_stages), PFS_events_stages, MYF(MY_ZEROFILL));
+ if (unlikely(array->m_stages_history_array == NULL))
+ return 1;
+ }
+
+ if (statements_history_sizing > 0)
+ {
+ array->m_statements_history_array=
+ PFS_MALLOC_ARRAY(& builtin_memory_thread_statements_history,
+ statements_history_sizing, sizeof(PFS_events_statements), PFS_events_statements, MYF(MY_ZEROFILL));
+ if (unlikely(array->m_statements_history_array == NULL))
+ return 1;
+ }
+
+ if (statements_stack_sizing > 0)
+ {
+ array->m_statements_stack_array=
+ PFS_MALLOC_ARRAY(& builtin_memory_thread_statements_stack,
+ statements_stack_sizing, sizeof(PFS_events_statements), PFS_events_statements, MYF(MY_ZEROFILL));
+ if (unlikely(array->m_statements_stack_array == NULL))
+ return 1;
+ }
+
+ if (transactions_history_sizing > 0)
+ {
+ array->m_transactions_history_array=
+ PFS_MALLOC_ARRAY(& builtin_memory_thread_transaction_history,
+ transactions_history_sizing, sizeof(PFS_events_transactions), PFS_events_transactions, MYF(MY_ZEROFILL));
+ if (unlikely(array->m_transactions_history_array == NULL))
+ return 1;
+ }
+
+ if (session_connect_attrs_sizing > 0)
+ {
+ array->m_session_connect_attrs_array=
+ (char *)pfs_malloc(& builtin_memory_thread_session_connect_attrs,
+ session_connect_attrs_sizing, MYF(MY_ZEROFILL));
+ if (unlikely(array->m_session_connect_attrs_array == NULL))
+ return 1;
+ }
+
+ if (current_sqltext_sizing > 0)
+ {
+ array->m_current_stmts_text_array=
+ (char *)pfs_malloc(& builtin_memory_thread_statements_stack_sqltext,
+ current_sqltext_sizing, MYF(MY_ZEROFILL));
+ if (unlikely(array->m_current_stmts_text_array == NULL))
+ return 1;
+ }
+
+ if (history_sqltext_sizing > 0)
+ {
+ array->m_history_stmts_text_array=
+ (char *)pfs_malloc(& builtin_memory_thread_statements_history_sqltext,
+ history_sqltext_sizing, MYF(MY_ZEROFILL));
+ if (unlikely(array->m_history_stmts_text_array == NULL))
+ return 1;
+ }
+
+ if (current_digest_tokens_sizing > 0)
+ {
+ array->m_current_stmts_digest_token_array=
+ (unsigned char *)pfs_malloc(& builtin_memory_thread_statements_stack_tokens,
+ current_digest_tokens_sizing, MYF(MY_ZEROFILL));
+ if (unlikely(array->m_current_stmts_digest_token_array == NULL))
+ return 1;
+ }
+
+ if (history_digest_tokens_sizing > 0)
+ {
+ array->m_history_stmts_digest_token_array=
+ (unsigned char *)pfs_malloc(& builtin_memory_thread_statements_history_tokens,
+ history_digest_tokens_sizing, MYF(MY_ZEROFILL));
+ if (unlikely(array->m_history_stmts_digest_token_array == NULL))
+ return 1;
+ }
+
+ for (index= 0; index < size; index++)
+ {
+ pfs= & array->m_ptr[index];
+
+ pfs->set_instr_class_waits_stats(
+ & array->m_instr_class_waits_array[index * wait_class_max]);
+ pfs->set_instr_class_stages_stats(
+ & array->m_instr_class_stages_array[index * stage_class_max]);
+ pfs->set_instr_class_statements_stats(
+ & array->m_instr_class_statements_array[index * statement_class_max]);
+ pfs->set_instr_class_transactions_stats(
+ & array->m_instr_class_transactions_array[index * transaction_class_max]);
+ pfs->set_instr_class_memory_stats(
+ & array->m_instr_class_memory_array[index * memory_class_max]);
+
+ pfs->m_waits_history=
+ & array->m_waits_history_array[index * events_waits_history_per_thread];
+ pfs->m_stages_history=
+ & array->m_stages_history_array[index * events_stages_history_per_thread];
+ pfs->m_statements_history=
+ & array->m_statements_history_array[index * events_statements_history_per_thread];
+ pfs->m_statement_stack=
+ & array->m_statements_stack_array[index * statement_stack_max];
+ pfs->m_transactions_history=
+ & array->m_transactions_history_array[index * events_transactions_history_per_thread];
+ pfs->m_session_connect_attrs=
+ & array->m_session_connect_attrs_array[index * session_connect_attrs_size_per_thread];
+ }
+
+ for (index= 0; index < statements_stack_sizing; index++)
+ {
+ pfs_stmt= & array->m_statements_stack_array[index];
+
+ pfs_stmt->m_sqltext= & array->m_current_stmts_text_array[index * pfs_max_sqltext];
+
+ pfs_tokens= & array->m_current_stmts_digest_token_array[index * pfs_max_digest_length];
+ pfs_stmt->m_digest_storage.reset(pfs_tokens, pfs_max_digest_length);
+ }
+
+ for (index= 0; index < statements_history_sizing; index++)
+ {
+ pfs_stmt= & array->m_statements_history_array[index];
+
+ pfs_stmt->m_sqltext= & array->m_history_stmts_text_array[index * pfs_max_sqltext];
+
+ pfs_tokens= & array->m_history_stmts_digest_token_array[index * pfs_max_digest_length];
+ pfs_stmt->m_digest_storage.reset(pfs_tokens, pfs_max_digest_length);
+ }
+
+ array->m_full= false;
+ return 0;
+}
+
+void PFS_thread_allocator::free_array(PFS_thread_array *array)
+{
+ size_t size= array->m_max;
+ size_t waits_sizing= size * wait_class_max;
+ size_t stages_sizing= size * stage_class_max;
+ size_t statements_sizing= size * statement_class_max;
+ size_t transactions_sizing= size * transaction_class_max;
+ size_t memory_sizing= size * memory_class_max;
+
+ size_t waits_history_sizing= size * events_waits_history_per_thread;
+ size_t stages_history_sizing= size * events_stages_history_per_thread;
+ size_t statements_history_sizing= size * events_statements_history_per_thread;
+ size_t statements_stack_sizing= size * statement_stack_max;
+ size_t transactions_history_sizing= size * events_transactions_history_per_thread;
+ size_t session_connect_attrs_sizing= size * session_connect_attrs_size_per_thread;
+
+ size_t current_sqltext_sizing= size * pfs_max_sqltext * statement_stack_max;
+ size_t history_sqltext_sizing= size * pfs_max_sqltext * events_statements_history_per_thread;
+ size_t current_digest_tokens_sizing= size * pfs_max_digest_length * statement_stack_max;
+ size_t history_digest_tokens_sizing= size * pfs_max_digest_length * events_statements_history_per_thread;
+
+ PFS_FREE_ARRAY(& builtin_memory_thread,
+ size, sizeof(PFS_thread), array->m_ptr);
+ array->m_ptr= NULL;
+
+ PFS_FREE_ARRAY(& builtin_memory_thread_waits,
+ waits_sizing, sizeof(PFS_single_stat),
+ array->m_instr_class_waits_array);
+ array->m_instr_class_waits_array= NULL;
+
+ PFS_FREE_ARRAY(& builtin_memory_thread_stages,
+ stages_sizing, sizeof(PFS_stage_stat),
+ array->m_instr_class_stages_array);
+ array->m_instr_class_stages_array= NULL;
+
+ PFS_FREE_ARRAY(& builtin_memory_thread_statements,
+ statements_sizing, sizeof(PFS_statement_stat),
+ array->m_instr_class_statements_array);
+ array->m_instr_class_statements_array= NULL;
+
+ PFS_FREE_ARRAY(& builtin_memory_thread_transactions,
+ transactions_sizing, sizeof(PFS_transaction_stat),
+ array->m_instr_class_transactions_array);
+ array->m_instr_class_transactions_array= NULL;
+
+ PFS_FREE_ARRAY(& builtin_memory_thread_memory,
+ memory_sizing, sizeof(PFS_memory_stat),
+ array->m_instr_class_memory_array);
+ array->m_instr_class_memory_array= NULL;
+
+
+ PFS_FREE_ARRAY(& builtin_memory_thread_waits_history,
+ waits_history_sizing, sizeof(PFS_events_waits),
+ array->m_waits_history_array);
+ array->m_waits_history_array= NULL;
+
+ PFS_FREE_ARRAY(& builtin_memory_thread_stages_history,
+ stages_history_sizing, sizeof(PFS_events_stages),
+ array->m_stages_history_array);
+ array->m_stages_history_array= NULL;
+
+ PFS_FREE_ARRAY(& builtin_memory_thread_statements_history,
+ statements_history_sizing, sizeof(PFS_events_statements),
+ array->m_statements_history_array);
+ array->m_statements_history_array= NULL;
+
+ PFS_FREE_ARRAY(& builtin_memory_thread_statements_stack,
+ statements_stack_sizing, sizeof(PFS_events_statements),
+ array->m_statements_stack_array);
+ array->m_statements_stack_array= NULL;
+
+ PFS_FREE_ARRAY(& builtin_memory_thread_transaction_history,
+ transactions_history_sizing, sizeof(PFS_events_transactions),
+ array->m_transactions_history_array);
+ array->m_transactions_history_array= NULL;
+
+ pfs_free(& builtin_memory_thread_session_connect_attrs,
+ session_connect_attrs_sizing,
+ array->m_session_connect_attrs_array);
+ array->m_session_connect_attrs_array= NULL;
+
+ pfs_free(& builtin_memory_thread_statements_stack_sqltext,
+ current_sqltext_sizing,
+ array->m_current_stmts_text_array);
+ array->m_current_stmts_text_array= NULL;
+
+ pfs_free(& builtin_memory_thread_statements_history_sqltext,
+ history_sqltext_sizing,
+ array->m_history_stmts_text_array);
+ array->m_history_stmts_text_array= NULL;
+
+ pfs_free(& builtin_memory_thread_statements_stack_tokens,
+ current_digest_tokens_sizing,
+ array->m_current_stmts_digest_token_array);
+ array->m_current_stmts_digest_token_array= NULL;
+
+ pfs_free(& builtin_memory_thread_statements_history_tokens,
+ history_digest_tokens_sizing,
+ array->m_history_stmts_digest_token_array);
+ array->m_history_stmts_digest_token_array= NULL;
+}
+
+PFS_thread_allocator thread_allocator;
+PFS_thread_container global_thread_container(& thread_allocator);
+
+int PFS_user_allocator::alloc_array(PFS_user_array *array)
+{
+ size_t size= array->m_max;
+ PFS_user *pfs;
+ size_t index;
+ size_t waits_sizing= size * wait_class_max;
+ size_t stages_sizing= size * stage_class_max;
+ size_t statements_sizing= size * statement_class_max;
+ size_t transactions_sizing= size * transaction_class_max;
+ size_t memory_sizing= size * memory_class_max;
+
+ array->m_ptr= NULL;
+ array->m_full= true;
+ array->m_instr_class_waits_array= NULL;
+ array->m_instr_class_stages_array= NULL;
+ array->m_instr_class_statements_array= NULL;
+ array->m_instr_class_transactions_array= NULL;
+ array->m_instr_class_memory_array= NULL;
+
+ if (size > 0)
+ {
+ array->m_ptr=
+ PFS_MALLOC_ARRAY(& builtin_memory_user,
+ size, sizeof(PFS_user), PFS_user, MYF(MY_ZEROFILL));
+ if (array->m_ptr == NULL)
+ return 1;
+ }
+
+ if (waits_sizing > 0)
+ {
+ array->m_instr_class_waits_array=
+ PFS_MALLOC_ARRAY(& builtin_memory_user_waits,
+ waits_sizing, sizeof(PFS_single_stat), PFS_single_stat, MYF(MY_ZEROFILL));
+ if (array->m_instr_class_waits_array == NULL)
+ return 1;
+
+ for (index=0; index < waits_sizing; index++)
+ array->m_instr_class_waits_array[index].reset();
+ }
+
+ if (stages_sizing > 0)
+ {
+ array->m_instr_class_stages_array=
+ PFS_MALLOC_ARRAY(& builtin_memory_user_stages,
+ stages_sizing, sizeof(PFS_stage_stat), PFS_stage_stat, MYF(MY_ZEROFILL));
+ if (array->m_instr_class_stages_array == NULL)
+ return 1;
+
+ for (index=0; index < stages_sizing; index++)
+ array->m_instr_class_stages_array[index].reset();
+ }
+
+ if (statements_sizing > 0)
+ {
+ array->m_instr_class_statements_array=
+ PFS_MALLOC_ARRAY(& builtin_memory_user_statements,
+ statements_sizing, sizeof(PFS_statement_stat), PFS_statement_stat, MYF(MY_ZEROFILL));
+ if (array->m_instr_class_statements_array == NULL)
+ return 1;
+
+ for (index=0; index < statements_sizing; index++)
+ array->m_instr_class_statements_array[index].reset();
+ }
+
+ if (transactions_sizing > 0)
+ {
+ array->m_instr_class_transactions_array=
+ PFS_MALLOC_ARRAY(& builtin_memory_user_transactions,
+ transactions_sizing, sizeof(PFS_transaction_stat), PFS_transaction_stat, MYF(MY_ZEROFILL));
+ if (array->m_instr_class_transactions_array == NULL)
+ return 1;
+
+ for (index=0; index < transactions_sizing; index++)
+ array->m_instr_class_transactions_array[index].reset();
+ }
+
+ if (memory_sizing > 0)
+ {
+ array->m_instr_class_memory_array=
+ PFS_MALLOC_ARRAY(& builtin_memory_user_memory,
+ memory_sizing, sizeof(PFS_memory_stat), PFS_memory_stat, MYF(MY_ZEROFILL));
+ if (array->m_instr_class_memory_array == NULL)
+ return 1;
+
+ for (index=0; index < memory_sizing; index++)
+ array->m_instr_class_memory_array[index].reset();
+ }
+
+ for (index= 0; index < size; index++)
+ {
+ pfs= & array->m_ptr[index];
+
+ pfs->set_instr_class_waits_stats(
+ & array->m_instr_class_waits_array[index * wait_class_max]);
+ pfs->set_instr_class_stages_stats(
+ & array->m_instr_class_stages_array[index * stage_class_max]);
+ pfs->set_instr_class_statements_stats(
+ & array->m_instr_class_statements_array[index * statement_class_max]);
+ pfs->set_instr_class_transactions_stats(
+ & array->m_instr_class_transactions_array[index * transaction_class_max]);
+ pfs->set_instr_class_memory_stats(
+ & array->m_instr_class_memory_array[index * memory_class_max]);
+ }
+
+ array->m_full= false;
+ return 0;
+}
+
+void PFS_user_allocator::free_array(PFS_user_array *array)
+{
+ size_t size= array->m_max;
+ size_t waits_sizing= size * wait_class_max;
+ size_t stages_sizing= size * stage_class_max;
+ size_t statements_sizing= size * statement_class_max;
+ size_t transactions_sizing= size * transaction_class_max;
+ size_t memory_sizing= size * memory_class_max;
+
+ PFS_FREE_ARRAY(& builtin_memory_user,
+ size, sizeof(PFS_user), array->m_ptr);
+ array->m_ptr= NULL;
+
+ PFS_FREE_ARRAY(& builtin_memory_user_waits,
+ waits_sizing, sizeof(PFS_single_stat),
+ array->m_instr_class_waits_array);
+ array->m_instr_class_waits_array= NULL;
+
+ PFS_FREE_ARRAY(& builtin_memory_user_stages,
+ stages_sizing, sizeof(PFS_stage_stat),
+ array->m_instr_class_stages_array);
+ array->m_instr_class_stages_array= NULL;
+
+ PFS_FREE_ARRAY(& builtin_memory_user_statements,
+ statements_sizing, sizeof(PFS_statement_stat),
+ array->m_instr_class_statements_array);
+ array->m_instr_class_statements_array= NULL;
+
+ PFS_FREE_ARRAY(& builtin_memory_user_transactions,
+ transactions_sizing, sizeof(PFS_transaction_stat),
+ array->m_instr_class_transactions_array);
+ array->m_instr_class_transactions_array= NULL;
+
+ PFS_FREE_ARRAY(& builtin_memory_user_memory,
+ memory_sizing, sizeof(PFS_memory_stat),
+ array->m_instr_class_memory_array);
+ array->m_instr_class_memory_array= NULL;
+}
+
+PFS_user_allocator user_allocator;
+PFS_user_container global_user_container(& user_allocator);
+
diff --git a/storage/perfschema/pfs_buffer_container.h b/storage/perfschema/pfs_buffer_container.h
new file mode 100644
index 00000000..141cbdf2
--- /dev/null
+++ b/storage/perfschema/pfs_buffer_container.h
@@ -0,0 +1,1626 @@
+/* Copyright (c) 2014, 2016, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
+
+#ifndef PFS_BUFFER_CONTAINER_H
+#define PFS_BUFFER_CONTAINER_H
+
+#include "my_global.h"
+#include "pfs.h" // PSI_COUNT_VOLATILITY
+#include "pfs_lock.h"
+#include "pfs_instr.h"
+#include "pfs_setup_actor.h"
+#include "pfs_setup_object.h"
+#include "pfs_program.h"
+#include "pfs_prepared_stmt.h"
+#include "pfs_builtin_memory.h"
+
+#define USE_SCALABLE
+
+class PFS_opaque_container_page;
+class PFS_opaque_container;
+
+struct PFS_builtin_memory_class;
+
+template <class T>
+class PFS_buffer_const_iterator;
+
+template <class T>
+class PFS_buffer_processor;
+
+template <class T, class U, class V>
+class PFS_buffer_iterator;
+
+template <class T, int PFS_PAGE_SIZE, int PFS_PAGE_COUNT, class U, class V>
+class PFS_buffer_scalable_iterator;
+
+template <class T>
+class PFS_buffer_default_array;
+
+template <class T>
+class PFS_buffer_default_allocator;
+
+template <class T, class U, class V>
+class PFS_buffer_container;
+
+template <class T, int PFS_PAGE_SIZE, int PFS_PAGE_COUNT, class U, class V>
+class PFS_buffer_scalable_container;
+
+template <class B, int COUNT>
+class PFS_partitioned_buffer_scalable_iterator;
+
+template <class B, int COUNT>
+class PFS_partitioned_buffer_scalable_container;
+
+
+template <class T>
+class PFS_buffer_default_array
+{
+public:
+ typedef T value_type;
+
+ value_type *allocate(pfs_dirty_state *dirty_state)
+ {
+ uint index;
+ uint monotonic;
+ uint monotonic_max;
+ value_type *pfs;
+
+ if (m_full)
+ return NULL;
+
+ monotonic= PFS_atomic::add_u32(& m_monotonic.m_u32, 1);
+ monotonic_max= monotonic + static_cast<uint>(m_max);
+
+ while (monotonic < monotonic_max)
+ {
+ index= monotonic % m_max;
+ pfs= m_ptr + index;
+
+ if (pfs->m_lock.free_to_dirty(dirty_state))
+ {
+ return pfs;
+ }
+ monotonic= PFS_atomic::add_u32(& m_monotonic.m_u32, 1);
+ }
+
+ m_full= true;
+ return NULL;
+ }
+
+ void deallocate(value_type *pfs)
+ {
+ pfs->m_lock.allocated_to_free();
+ m_full= false;
+ }
+
+ T* get_first()
+ {
+ return m_ptr;
+ }
+
+ T* get_last()
+ {
+ return m_ptr + m_max;
+ }
+
+ bool m_full;
+ PFS_cacheline_uint32 m_monotonic;
+ T * m_ptr;
+ size_t m_max;
+ /** Container. */
+ PFS_opaque_container *m_container;
+};
+
+template <class T>
+class PFS_buffer_default_allocator
+{
+public:
+ typedef PFS_buffer_default_array<T> array_type;
+
+ PFS_buffer_default_allocator(PFS_builtin_memory_class *klass)
+ : m_builtin_class(klass)
+ {}
+
+ int alloc_array(array_type *array)
+ {
+ array->m_ptr= NULL;
+ array->m_full= true;
+ array->m_monotonic.m_u32= 0;
+
+ if (array->m_max > 0)
+ {
+ array->m_ptr= PFS_MALLOC_ARRAY(m_builtin_class,
+ array->m_max, sizeof(T), T, MYF(MY_ZEROFILL));
+ if (array->m_ptr == NULL)
+ return 1;
+ array->m_full= false;
+ }
+ return 0;
+ }
+
+ void free_array(array_type *array)
+ {
+ DBUG_ASSERT(array->m_max > 0);
+
+ PFS_FREE_ARRAY(m_builtin_class,
+ array->m_max, sizeof(T), array->m_ptr);
+ array->m_ptr= NULL;
+ }
+
+private:
+ PFS_builtin_memory_class *m_builtin_class;
+};
+
+template <class T,
+ class U = PFS_buffer_default_array<T>,
+ class V = PFS_buffer_default_allocator<T> >
+class PFS_buffer_container
+{
+public:
+ friend class PFS_buffer_iterator<T, U, V>;
+
+ typedef T value_type;
+ typedef U array_type;
+ typedef V allocator_type;
+ typedef PFS_buffer_const_iterator<T> const_iterator_type;
+ typedef PFS_buffer_iterator<T, U, V> iterator_type;
+ typedef PFS_buffer_processor<T> processor_type;
+ typedef void (*function_type)(value_type *);
+
+ PFS_buffer_container(allocator_type *allocator)
+ {
+ m_array.m_full= true;
+ m_array.m_ptr= NULL;
+ m_array.m_max= 0;
+ m_array.m_monotonic.m_u32= 0;
+ m_lost= 0;
+ m_max= 0;
+ m_allocator= allocator;
+ }
+
+ int init(ulong max_size)
+ {
+ if (max_size > 0)
+ {
+ m_array.m_max= max_size;
+ int rc= m_allocator->alloc_array(& m_array);
+ if (rc != 0)
+ {
+ m_allocator->free_array(& m_array);
+ return 1;
+ }
+ m_max= max_size;
+ m_array.m_full= false;
+ }
+ return 0;
+ }
+
+ void cleanup()
+ {
+ m_allocator->free_array(& m_array);
+ }
+
+ ulong get_row_count() const
+ {
+ return m_max;
+ }
+
+ ulong get_row_size() const
+ {
+ return sizeof(value_type);
+ }
+
+ ulong get_memory() const
+ {
+ return get_row_count() * get_row_size();
+ }
+
+ value_type *allocate(pfs_dirty_state *dirty_state)
+ {
+ value_type *pfs;
+
+ pfs= m_array.allocate(dirty_state, m_max);
+ if (pfs == NULL)
+ {
+ m_lost++;
+ }
+
+ return pfs;
+ }
+
+ void deallocate(value_type *pfs)
+ {
+ m_array.deallocate(pfs);
+ }
+
+ iterator_type iterate()
+ {
+ return PFS_buffer_iterator<T, U, V>(this, 0);
+ }
+
+ iterator_type iterate(uint index)
+ {
+ DBUG_ASSERT(index <= m_max);
+ return PFS_buffer_iterator<T, U, V>(this, index);
+ }
+
+ void apply(function_type fct)
+ {
+ value_type *pfs= m_array.get_first();
+ value_type *pfs_last= m_array.get_last();
+
+ while (pfs < pfs_last)
+ {
+ if (pfs->m_lock.is_populated())
+ {
+ fct(pfs);
+ }
+ pfs++;
+ }
+ }
+
+ void apply_all(function_type fct)
+ {
+ value_type *pfs= m_array.get_first();
+ value_type *pfs_last= m_array.get_last();
+
+ while (pfs < pfs_last)
+ {
+ fct(pfs);
+ pfs++;
+ }
+ }
+
+ void apply(processor_type & proc)
+ {
+ value_type *pfs= m_array.get_first();
+ value_type *pfs_last= m_array.get_last();
+
+ while (pfs < pfs_last)
+ {
+ if (pfs->m_lock.is_populated())
+ {
+ proc(pfs);
+ }
+ pfs++;
+ }
+ }
+
+ void apply_all(processor_type & proc)
+ {
+ value_type *pfs= m_array.get_first();
+ value_type *pfs_last= m_array.get_last();
+
+ while (pfs < pfs_last)
+ {
+ proc(pfs);
+ pfs++;
+ }
+ }
+
+ inline value_type* get(uint index)
+ {
+ DBUG_ASSERT(index < m_max);
+
+ value_type *pfs= m_array.m_ptr + index;
+ if (pfs->m_lock.is_populated())
+ {
+ return pfs;
+ }
+
+ return NULL;
+ }
+
+ value_type* get(uint index, bool *has_more)
+ {
+ if (index >= m_max)
+ {
+ *has_more= false;
+ return NULL;
+ }
+
+ *has_more= true;
+ return get(index);
+ }
+
+ value_type *sanitize(value_type *unsafe)
+ {
+ intptr offset;
+ value_type *pfs= m_array.get_first();
+ value_type *pfs_last= m_array.get_last();
+
+ if ((pfs <= unsafe) &&
+ (unsafe < pfs_last))
+ {
+ offset= ((intptr) unsafe - (intptr) pfs) % sizeof(value_type);
+ if (offset == 0)
+ return unsafe;
+ }
+
+ return NULL;
+ }
+
+ ulong m_lost;
+
+private:
+ value_type* scan_next(uint & index, uint * found_index)
+ {
+ DBUG_ASSERT(index <= m_max);
+
+ value_type *pfs_first= m_array.get_first();
+ value_type *pfs= pfs_first + index;
+ value_type *pfs_last= m_array.get_last();
+
+ while (pfs < pfs_last)
+ {
+ if (pfs->m_lock.is_populated())
+ {
+ uint found= pfs - pfs_first;
+ *found_index= found;
+ index= found + 1;
+ return pfs;
+ }
+ pfs++;
+ }
+
+ index= m_max;
+ return NULL;
+ }
+
+ ulong m_max;
+ array_type m_array;
+ allocator_type *m_allocator;
+};
+
+template <class T,
+ int PFS_PAGE_SIZE,
+ int PFS_PAGE_COUNT,
+ class U = PFS_buffer_default_array<T>,
+ class V = PFS_buffer_default_allocator<T> >
+class PFS_buffer_scalable_container
+{
+public:
+ friend class PFS_buffer_scalable_iterator<T, PFS_PAGE_SIZE, PFS_PAGE_COUNT, U, V>;
+
+ /**
+ Type of elements in the buffer.
+ The following attributes are required:
+ - pfs_lock m_lock
+ - PFS_opaque_container_page *m_page
+ */
+ typedef T value_type;
+ /**
+ Type of pages in the buffer.
+ The following attributes are required:
+ - PFS_opaque_container *m_container
+ */
+ typedef U array_type;
+ typedef V allocator_type;
+ /** This container type */
+ typedef PFS_buffer_scalable_container<T, PFS_PAGE_SIZE, PFS_PAGE_COUNT, U, V> container_type;
+ typedef PFS_buffer_const_iterator<T> const_iterator_type;
+ typedef PFS_buffer_scalable_iterator<T, PFS_PAGE_SIZE, PFS_PAGE_COUNT, U, V> iterator_type;
+ typedef PFS_buffer_processor<T> processor_type;
+ typedef void (*function_type)(value_type *);
+
+ static const size_t MAX_SIZE= PFS_PAGE_SIZE*PFS_PAGE_COUNT;
+
+ PFS_buffer_scalable_container(allocator_type *allocator)
+ {
+ m_allocator= allocator;
+ m_initialized= false;
+ m_lost= 0;
+ }
+
+ int init(long max_size)
+ {
+ int i;
+
+ m_initialized= true;
+ m_full= true;
+ m_max= PFS_PAGE_COUNT * PFS_PAGE_SIZE;
+ m_max_page_count= PFS_PAGE_COUNT;
+ m_last_page_size= PFS_PAGE_SIZE;
+ m_lost= 0;
+ m_monotonic.m_u32= 0;
+ m_max_page_index.m_u32= 0;
+
+ for (i=0 ; i < PFS_PAGE_COUNT; i++)
+ {
+ m_pages[i]= NULL;
+ }
+
+ if (max_size == 0)
+ {
+ /* No allocation. */
+ m_max_page_count= 0;
+ }
+ else if (max_size > 0)
+ {
+ if (max_size % PFS_PAGE_SIZE == 0)
+ {
+ m_max_page_count= max_size / PFS_PAGE_SIZE;
+ }
+ else
+ {
+ m_max_page_count= max_size / PFS_PAGE_SIZE + 1;
+ m_last_page_size= max_size % PFS_PAGE_SIZE;
+ }
+ /* Bounded allocation. */
+ m_full= false;
+
+ if (m_max_page_count > PFS_PAGE_COUNT)
+ {
+ m_max_page_count= PFS_PAGE_COUNT;
+ m_last_page_size= PFS_PAGE_SIZE;
+ }
+ }
+ else
+ {
+ /* max_size = -1 means unbounded allocation */
+ m_full= false;
+ }
+
+ DBUG_ASSERT(m_max_page_count <= PFS_PAGE_COUNT);
+ DBUG_ASSERT(0 < m_last_page_size);
+ DBUG_ASSERT(m_last_page_size <= PFS_PAGE_SIZE);
+
+ pthread_mutex_init(& m_critical_section, NULL);
+ return 0;
+ }
+
+ void cleanup()
+ {
+ int i;
+ array_type *page;
+
+ if (! m_initialized)
+ return;
+
+ pthread_mutex_lock(& m_critical_section);
+
+ for (i=0 ; i < PFS_PAGE_COUNT; i++)
+ {
+ page= m_pages[i];
+ if (page != NULL)
+ {
+ m_allocator->free_array(page);
+ delete page;
+ m_pages[i]= NULL;
+ }
+ }
+ pthread_mutex_unlock(& m_critical_section);
+
+ pthread_mutex_destroy(& m_critical_section);
+
+ m_initialized= false;
+ }
+
+ ulong get_row_count()
+ {
+ ulong page_count= PFS_atomic::load_u32(& m_max_page_index.m_u32);
+
+ return page_count * PFS_PAGE_SIZE;
+ }
+
+ ulong get_row_size() const
+ {
+ return sizeof(value_type);
+ }
+
+ ulong get_memory()
+ {
+ return get_row_count() * get_row_size();
+ }
+
+ value_type *allocate(pfs_dirty_state *dirty_state)
+ {
+ if (m_full)
+ {
+ m_lost++;
+ return NULL;
+ }
+
+ uint index;
+ uint monotonic;
+ uint monotonic_max;
+ uint current_page_count;
+ value_type *pfs;
+ array_type *array;
+
+ void *addr;
+ void * volatile * typed_addr;
+ void *ptr;
+
+ /*
+ 1: Try to find an available record within the existing pages
+ */
+ current_page_count= PFS_atomic::load_u32(& m_max_page_index.m_u32);
+
+ if (current_page_count != 0)
+ {
+ monotonic= PFS_atomic::load_u32(& m_monotonic.m_u32);
+ monotonic_max= monotonic + current_page_count;
+
+ while (monotonic < monotonic_max)
+ {
+ /*
+ Scan in the [0 .. current_page_count - 1] range,
+ in parallel with m_monotonic (see below)
+ */
+ index= monotonic % current_page_count;
+
+ /* Atomic Load, array= m_pages[index] */
+ addr= & m_pages[index];
+ typed_addr= static_cast<void * volatile *>(addr);
+ ptr= my_atomic_loadptr(typed_addr);
+ array= static_cast<array_type *>(ptr);
+
+ if (array != NULL)
+ {
+ pfs= array->allocate(dirty_state);
+ if (pfs != NULL)
+ {
+ /* Keep a pointer to the parent page, for deallocate(). */
+ pfs->m_page= reinterpret_cast<PFS_opaque_container_page *> (array);
+ return pfs;
+ }
+ }
+
+ /*
+ Parallel scans collaborate to increase
+ the common monotonic scan counter.
+
+ Note that when all the existing page are full,
+ one thread will eventually add a new page,
+ and cause m_max_page_index to increase,
+ which fools all the modulo logic for scans already in progress,
+ because the monotonic counter is not folded to the same place
+ (sometime modulo N, sometime modulo N+1).
+
+ This is actually ok: since all the pages are full anyway,
+ there is nothing to miss, so better increase the monotonic
+ counter faster and then move on to the detection of new pages,
+ in part 2: below.
+ */
+ monotonic= PFS_atomic::add_u32(& m_monotonic.m_u32, 1);
+ };
+ }
+
+ /*
+ 2: Try to add a new page, beyond the m_max_page_index limit
+ */
+ while (current_page_count < m_max_page_count)
+ {
+ /* Peek for pages added by collaborating threads */
+
+ /* (2-a) Atomic Load, array= m_pages[current_page_count] */
+ addr= & m_pages[current_page_count];
+ typed_addr= static_cast<void * volatile *>(addr);
+ ptr= my_atomic_loadptr(typed_addr);
+ array= static_cast<array_type *>(ptr);
+
+ if (array == NULL)
+ {
+ // ==================================================================
+ // BEGIN CRITICAL SECTION -- buffer expand
+ // ==================================================================
+
+ /*
+ On a fresh started server, buffers are typically empty.
+ When a sudden load spike is seen by the server,
+ multiple threads may want to expand the buffer at the same time.
+
+ Using a compare and swap to allow multiple pages to be added,
+ possibly freeing duplicate pages on collisions,
+ does not work well because the amount of code involved
+ when creating a new page can be significant (PFS_thread),
+ causing MANY collisions between (2-b) and (2-d).
+
+ A huge number of collisions (which can happen when thousands
+ of new connections hits the server after a restart)
+ leads to a huge memory consumption, and to OOM.
+
+ To mitigate this, we use here a mutex,
+ to enforce that only ONE page is added at a time,
+ so that scaling the buffer happens in a predictable
+ and controlled manner.
+ */
+ pthread_mutex_lock(& m_critical_section);
+
+ /*
+ Peek again for pages added by collaborating threads,
+ this time as the only thread allowed to expand the buffer
+ */
+
+ /* (2-b) Atomic Load, array= m_pages[current_page_count] */
+
+ ptr= my_atomic_loadptr(typed_addr);
+ array= static_cast<array_type *>(ptr);
+
+ if (array == NULL)
+ {
+ /* (2-c) Found no page, allocate a new one */
+ array= new array_type();
+ builtin_memory_scalable_buffer.count_alloc(sizeof (array_type));
+
+ array->m_max= get_page_logical_size(current_page_count);
+ int rc= m_allocator->alloc_array(array);
+ if (rc != 0)
+ {
+ m_allocator->free_array(array);
+ delete array;
+ builtin_memory_scalable_buffer.count_free(sizeof (array_type));
+ m_lost++;
+ pthread_mutex_unlock(& m_critical_section);
+ return NULL;
+ }
+
+ /* Keep a pointer to this container, for static_deallocate(). */
+ array->m_container= reinterpret_cast<PFS_opaque_container *> (this);
+
+ /* (2-d) Atomic STORE, m_pages[current_page_count] = array */
+ ptr= array;
+ my_atomic_storeptr(typed_addr, ptr);
+
+ /* Advertise the new page */
+ PFS_atomic::add_u32(& m_max_page_index.m_u32, 1);
+ }
+
+ pthread_mutex_unlock(& m_critical_section);
+
+ // ==================================================================
+ // END CRITICAL SECTION -- buffer expand
+ // ==================================================================
+ }
+
+ DBUG_ASSERT(array != NULL);
+ pfs= array->allocate(dirty_state);
+ if (pfs != NULL)
+ {
+ /* Keep a pointer to the parent page, for deallocate(). */
+ pfs->m_page= reinterpret_cast<PFS_opaque_container_page *> (array);
+ return pfs;
+ }
+
+ current_page_count++;
+ }
+
+ m_lost++;
+ m_full= true;
+ return NULL;
+ }
+
+ void deallocate(value_type *safe_pfs)
+ {
+ /* Find the containing page */
+ PFS_opaque_container_page *opaque_page= safe_pfs->m_page;
+ array_type *page= reinterpret_cast<array_type *> (opaque_page);
+
+ /* Mark the object free */
+ safe_pfs->m_lock.allocated_to_free();
+
+ /* Flag the containing page as not full. */
+ page->m_full= false;
+
+ /* Flag the overall container as not full. */
+ m_full= false;
+ }
+
+ static void static_deallocate(value_type *safe_pfs)
+ {
+ /* Find the containing page */
+ PFS_opaque_container_page *opaque_page= safe_pfs->m_page;
+ array_type *page= reinterpret_cast<array_type *> (opaque_page);
+
+ /* Mark the object free */
+ safe_pfs->m_lock.allocated_to_free();
+
+ /* Flag the containing page as not full. */
+ page->m_full= false;
+
+ /* Find the containing buffer */
+ PFS_opaque_container *opaque_container= page->m_container;
+ PFS_buffer_scalable_container *container;
+ container= reinterpret_cast<container_type *> (opaque_container);
+
+ /* Flag the overall container as not full. */
+ container->m_full= false;
+ }
+
+ iterator_type iterate()
+ {
+ return PFS_buffer_scalable_iterator<T, PFS_PAGE_SIZE, PFS_PAGE_COUNT, U, V>(this, 0);
+ }
+
+ iterator_type iterate(uint index)
+ {
+ DBUG_ASSERT(index <= m_max);
+ return PFS_buffer_scalable_iterator<T, PFS_PAGE_SIZE, PFS_PAGE_COUNT, U, V>(this, index);
+ }
+
+ void apply(function_type fct)
+ {
+ uint i;
+ array_type *page;
+ value_type *pfs;
+ value_type *pfs_last;
+
+ for (i=0 ; i < PFS_PAGE_COUNT; i++)
+ {
+ page= m_pages[i];
+ if (page != NULL)
+ {
+ pfs= page->get_first();
+ pfs_last= page->get_last();
+
+ while (pfs < pfs_last)
+ {
+ if (pfs->m_lock.is_populated())
+ {
+ fct(pfs);
+ }
+ pfs++;
+ }
+ }
+ }
+ }
+
+ void apply_all(function_type fct)
+ {
+ uint i;
+ array_type *page;
+ value_type *pfs;
+ value_type *pfs_last;
+
+ for (i=0 ; i < PFS_PAGE_COUNT; i++)
+ {
+ page= m_pages[i];
+ if (page != NULL)
+ {
+ pfs= page->get_first();
+ pfs_last= page->get_last();
+
+ while (pfs < pfs_last)
+ {
+ fct(pfs);
+ pfs++;
+ }
+ }
+ }
+ }
+
+ void apply(processor_type & proc)
+ {
+ uint i;
+ array_type *page;
+ value_type *pfs;
+ value_type *pfs_last;
+
+ for (i=0 ; i < PFS_PAGE_COUNT; i++)
+ {
+ page= m_pages[i];
+ if (page != NULL)
+ {
+ pfs= page->get_first();
+ pfs_last= page->get_last();
+
+ while (pfs < pfs_last)
+ {
+ if (pfs->m_lock.is_populated())
+ {
+ proc(pfs);
+ }
+ pfs++;
+ }
+ }
+ }
+ }
+
+ void apply_all(processor_type & proc)
+ {
+ uint i;
+ array_type *page;
+ value_type *pfs;
+ value_type *pfs_last;
+
+ for (i=0 ; i < PFS_PAGE_COUNT; i++)
+ {
+ page= m_pages[i];
+ if (page != NULL)
+ {
+ pfs= page->get_first();
+ pfs_last= page->get_last();
+
+ while (pfs < pfs_last)
+ {
+ proc(pfs);
+ pfs++;
+ }
+ }
+ }
+ }
+
+ value_type* get(uint index)
+ {
+ DBUG_ASSERT(index < m_max);
+
+ uint index_1= index / PFS_PAGE_SIZE;
+ array_type *page= m_pages[index_1];
+ if (page != NULL)
+ {
+ uint index_2= index % PFS_PAGE_SIZE;
+
+ if (index_2 >= page->m_max)
+ {
+ return NULL;
+ }
+
+ value_type *pfs= page->m_ptr + index_2;
+
+ if (pfs->m_lock.is_populated())
+ {
+ return pfs;
+ }
+ }
+
+ return NULL;
+ }
+
+ value_type* get(uint index, bool *has_more)
+ {
+ if (index >= m_max)
+ {
+ *has_more= false;
+ return NULL;
+ }
+
+ uint index_1= index / PFS_PAGE_SIZE;
+ array_type *page= m_pages[index_1];
+
+ if (page == NULL)
+ {
+ *has_more= false;
+ return NULL;
+ }
+
+ uint index_2= index % PFS_PAGE_SIZE;
+
+ if (index_2 >= page->m_max)
+ {
+ *has_more= false;
+ return NULL;
+ }
+
+ *has_more= true;
+ value_type *pfs= page->m_ptr + index_2;
+
+ if (pfs->m_lock.is_populated())
+ {
+ return pfs;
+ }
+
+ return NULL;
+ }
+
+ value_type *sanitize(value_type *unsafe)
+ {
+ intptr offset;
+ uint i;
+ array_type *page;
+ value_type *pfs;
+ value_type *pfs_last;
+
+ for (i=0 ; i < PFS_PAGE_COUNT; i++)
+ {
+ page= m_pages[i];
+ if (page != NULL)
+ {
+ pfs= page->get_first();
+ pfs_last= page->get_last();
+
+ if ((pfs <= unsafe) &&
+ (unsafe < pfs_last))
+ {
+ offset= ((intptr) unsafe - (intptr) pfs) % sizeof(value_type);
+ if (offset == 0)
+ return unsafe;
+ }
+ }
+ }
+
+ return NULL;
+ }
+
+ ulong m_lost;
+
+private:
+
+ uint get_page_logical_size(uint page_index)
+ {
+ if (page_index + 1 < m_max_page_count)
+ return PFS_PAGE_SIZE;
+ DBUG_ASSERT(page_index + 1 == m_max_page_count);
+ return m_last_page_size;
+ }
+
+ value_type* scan_next(uint & index, uint * found_index)
+ {
+ DBUG_ASSERT(index <= m_max);
+
+ uint index_1= index / PFS_PAGE_SIZE;
+ uint index_2= index % PFS_PAGE_SIZE;
+ array_type *page;
+ value_type *pfs_first;
+ value_type *pfs;
+ value_type *pfs_last;
+
+ while (index_1 < PFS_PAGE_COUNT)
+ {
+ page= m_pages[index_1];
+
+ if (page == NULL)
+ {
+ index= static_cast<uint>(m_max);
+ return NULL;
+ }
+
+ pfs_first= page->get_first();
+ pfs= pfs_first + index_2;
+ pfs_last= page->get_last();
+
+ while (pfs < pfs_last)
+ {
+ if (pfs->m_lock.is_populated())
+ {
+ uint found= index_1 * PFS_PAGE_SIZE + static_cast<uint>(pfs - pfs_first);
+ *found_index= found;
+ index= found + 1;
+ return pfs;
+ }
+ pfs++;
+ }
+
+ index_1++;
+ index_2= 0;
+ }
+
+ index= static_cast<uint>(m_max);
+ return NULL;
+ }
+
+ bool m_initialized;
+ bool m_full;
+ size_t m_max;
+ PFS_cacheline_uint32 m_monotonic;
+ PFS_cacheline_uint32 m_max_page_index;
+ ulong m_max_page_count;
+ ulong m_last_page_size;
+ array_type * m_pages[PFS_PAGE_COUNT];
+ allocator_type *m_allocator;
+ pthread_mutex_t m_critical_section;
+};
+
+template <class T, class U, class V>
+class PFS_buffer_iterator
+{
+ friend class PFS_buffer_container<T, U, V>;
+
+ typedef T value_type;
+ typedef PFS_buffer_container<T, U, V> container_type;
+
+public:
+ value_type* scan_next()
+ {
+ uint unused;
+ return m_container->scan_next(m_index, & unused);
+ }
+
+ value_type* scan_next(uint * found_index)
+ {
+ return m_container->scan_next(m_index, found_index);
+ }
+
+private:
+ PFS_buffer_iterator(container_type *container, uint index)
+ : m_container(container),
+ m_index(index)
+ {}
+
+ container_type *m_container;
+ uint m_index;
+};
+
+template <class T, int page_size, int page_count, class U, class V>
+class PFS_buffer_scalable_iterator
+{
+ friend class PFS_buffer_scalable_container<T, page_size, page_count, U, V>;
+
+ typedef T value_type;
+ typedef PFS_buffer_scalable_container<T, page_size, page_count, U, V> container_type;
+
+public:
+ value_type* scan_next()
+ {
+ uint unused;
+ return m_container->scan_next(m_index, & unused);
+ }
+
+ value_type* scan_next(uint * found_index)
+ {
+ return m_container->scan_next(m_index, found_index);
+ }
+
+private:
+ PFS_buffer_scalable_iterator(container_type *container, uint index)
+ : m_container(container),
+ m_index(index)
+ {}
+
+ container_type *m_container;
+ uint m_index;
+};
+
+template <class T>
+class PFS_buffer_processor
+{
+public:
+ virtual ~PFS_buffer_processor<T> ()
+ {}
+ virtual void operator()(T *element) = 0;
+};
+
+template <class B, int PFS_PARTITION_COUNT>
+class PFS_partitioned_buffer_scalable_container
+{
+public:
+ friend class PFS_partitioned_buffer_scalable_iterator<B, PFS_PARTITION_COUNT>;
+
+ typedef typename B::value_type value_type;
+ typedef typename B::allocator_type allocator_type;
+ typedef PFS_partitioned_buffer_scalable_iterator<B, PFS_PARTITION_COUNT> iterator_type;
+ typedef typename B::iterator_type sub_iterator_type;
+ typedef typename B::processor_type processor_type;
+ typedef typename B::function_type function_type;
+
+ PFS_partitioned_buffer_scalable_container(allocator_type *allocator)
+ {
+ for (int i=0 ; i < PFS_PARTITION_COUNT; i++)
+ {
+ m_partitions[i]= new B(allocator);
+ }
+ }
+
+ ~PFS_partitioned_buffer_scalable_container()
+ {
+ for (int i=0 ; i < PFS_PARTITION_COUNT; i++)
+ {
+ delete m_partitions[i];
+ }
+ }
+
+ int init(long max_size)
+ {
+ int rc= 0;
+ // FIXME: we have max_size * PFS_PARTITION_COUNT here
+ for (int i=0 ; i < PFS_PARTITION_COUNT; i++)
+ {
+ rc|= m_partitions[i]->init(max_size);
+ }
+ return rc;
+ }
+
+ void cleanup()
+ {
+ for (int i=0 ; i < PFS_PARTITION_COUNT; i++)
+ {
+ m_partitions[i]->cleanup();
+ }
+ }
+
+ ulong get_row_count() const
+ {
+ ulong sum= 0;
+
+ for (int i=0; i < PFS_PARTITION_COUNT; i++)
+ {
+ sum += m_partitions[i]->get_row_count();
+ }
+
+ return sum;
+ }
+
+ ulong get_row_size() const
+ {
+ return sizeof(value_type);
+ }
+
+ ulong get_memory() const
+ {
+ ulong sum= 0;
+
+ for (int i=0; i < PFS_PARTITION_COUNT; i++)
+ {
+ sum += m_partitions[i]->get_memory();
+ }
+
+ return sum;
+ }
+
+ long get_lost_counter()
+ {
+ long sum= 0;
+
+ for (int i=0; i < PFS_PARTITION_COUNT; i++)
+ {
+ sum += m_partitions[i]->m_lost;
+ }
+
+ return sum;
+ }
+
+ value_type *allocate(pfs_dirty_state *dirty_state, uint partition)
+ {
+ DBUG_ASSERT(partition < PFS_PARTITION_COUNT);
+
+ return m_partitions[partition]->allocate(dirty_state);
+ }
+
+ void deallocate(value_type *safe_pfs)
+ {
+ /*
+ One issue here is that we do not know which partition
+ the record belongs to.
+ Each record points to the parent page,
+ and each page points to the parent buffer,
+ so using static_deallocate here,
+ which will find the correct partition by itself.
+ */
+ B::static_deallocate(safe_pfs);
+ }
+
+ iterator_type iterate()
+ {
+ return iterator_type(this, 0, 0);
+ }
+
+ iterator_type iterate(uint user_index)
+ {
+ uint partition_index;
+ uint sub_index;
+ unpack_index(user_index, &partition_index, &sub_index);
+ return iterator_type(this, partition_index, sub_index);
+ }
+
+ void apply(function_type fct)
+ {
+ for (int i=0; i < PFS_PARTITION_COUNT; i++)
+ {
+ m_partitions[i]->apply(fct);
+ }
+ }
+
+ void apply_all(function_type fct)
+ {
+ for (int i=0; i < PFS_PARTITION_COUNT; i++)
+ {
+ m_partitions[i]->apply_all(fct);
+ }
+ }
+
+ void apply(processor_type & proc)
+ {
+ for (int i=0; i < PFS_PARTITION_COUNT; i++)
+ {
+ m_partitions[i]->apply(proc);
+ }
+ }
+
+ void apply_all(processor_type & proc)
+ {
+ for (int i=0; i < PFS_PARTITION_COUNT; i++)
+ {
+ m_partitions[i]->apply_all(proc);
+ }
+ }
+
+ value_type* get(uint user_index)
+ {
+ uint partition_index;
+ uint sub_index;
+ unpack_index(user_index, &partition_index, &sub_index);
+
+ if (partition_index >= PFS_PARTITION_COUNT)
+ {
+ return NULL;
+ }
+
+ return m_partitions[partition_index]->get(sub_index);
+ }
+
+ value_type* get(uint user_index, bool *has_more)
+ {
+ uint partition_index;
+ uint sub_index;
+ unpack_index(user_index, &partition_index, &sub_index);
+
+ if (partition_index >= PFS_PARTITION_COUNT)
+ {
+ *has_more= false;
+ return NULL;
+ }
+
+ *has_more= true;
+ return m_partitions[partition_index]->get(sub_index);
+ }
+
+ value_type *sanitize(value_type *unsafe)
+ {
+ value_type *safe= NULL;
+
+ for (int i=0; i < PFS_PARTITION_COUNT; i++)
+ {
+ safe= m_partitions[i]->sanitize(unsafe);
+ if (safe != NULL)
+ {
+ return safe;
+ }
+ }
+
+ return safe;
+ }
+
+private:
+ static void pack_index(uint partition_index, uint sub_index, uint *user_index)
+ {
+ /* 2^8 = 256 partitions max */
+ compile_time_assert(PFS_PARTITION_COUNT <= (1 << 8));
+ /* 2^24 = 16777216 max per partitioned buffer. */
+ compile_time_assert((B::MAX_SIZE) <= (1 << 24));
+
+ *user_index= (partition_index << 24) + sub_index;
+ }
+
+ static void unpack_index(uint user_index, uint *partition_index, uint *sub_index)
+ {
+ *partition_index= user_index >> 24;
+ *sub_index= user_index & 0x00FFFFFF;
+ }
+
+ value_type* scan_next(uint & partition_index, uint & sub_index, uint * found_partition, uint * found_sub_index)
+ {
+ value_type *record= NULL;
+ DBUG_ASSERT(partition_index < PFS_PARTITION_COUNT);
+
+ while (partition_index < PFS_PARTITION_COUNT)
+ {
+ sub_iterator_type sub_iterator= m_partitions[partition_index]->iterate(sub_index);
+ record= sub_iterator.scan_next(found_sub_index);
+ if (record != NULL)
+ {
+ *found_partition= partition_index;
+ sub_index= *found_sub_index + 1;
+ return record;
+ }
+
+ partition_index++;
+ sub_index= 0;
+ }
+
+ *found_partition= PFS_PARTITION_COUNT;
+ *found_sub_index= 0;
+ sub_index= 0;
+ return NULL;
+ }
+
+ B *m_partitions[PFS_PARTITION_COUNT];
+};
+
+template <class B, int PFS_PARTITION_COUNT>
+class PFS_partitioned_buffer_scalable_iterator
+{
+public:
+ friend class PFS_partitioned_buffer_scalable_container<B, PFS_PARTITION_COUNT>;
+
+ typedef typename B::value_type value_type;
+ typedef PFS_partitioned_buffer_scalable_container<B, PFS_PARTITION_COUNT> container_type;
+
+ value_type* scan_next()
+ {
+ uint unused_partition;
+ uint unused_sub_index;
+ return m_container->scan_next(m_partition, m_sub_index, & unused_partition, & unused_sub_index);
+ }
+
+ value_type* scan_next(uint *found_user_index)
+ {
+ uint found_partition;
+ uint found_sub_index;
+ value_type *record;
+ record= m_container->scan_next(m_partition, m_sub_index, &found_partition, &found_sub_index);
+ container_type::pack_index(found_partition, found_sub_index, found_user_index);
+ return record;
+ }
+
+private:
+ PFS_partitioned_buffer_scalable_iterator(container_type *container, uint partition, uint sub_index)
+ : m_container(container),
+ m_partition(partition),
+ m_sub_index(sub_index)
+ {}
+
+ container_type *m_container;
+ uint m_partition;
+ uint m_sub_index;
+};
+
+#ifdef USE_SCALABLE
+typedef PFS_buffer_scalable_container<PFS_mutex, 1024, 1024> PFS_mutex_basic_container;
+typedef PFS_partitioned_buffer_scalable_container<PFS_mutex_basic_container, PSI_COUNT_VOLATILITY> PFS_mutex_container;
+#else
+typedef PFS_buffer_container<PFS_mutex> PFS_mutex_container;
+#endif
+typedef PFS_mutex_container::iterator_type PFS_mutex_iterator;
+extern PFS_mutex_container global_mutex_container;
+
+#ifdef USE_SCALABLE
+typedef PFS_buffer_scalable_container<PFS_rwlock, 1024, 1024> PFS_rwlock_container;
+#else
+typedef PFS_buffer_container<PFS_rwlock> PFS_rwlock_container;
+#endif
+typedef PFS_rwlock_container::iterator_type PFS_rwlock_iterator;
+extern PFS_rwlock_container global_rwlock_container;
+
+#ifdef USE_SCALABLE
+typedef PFS_buffer_scalable_container<PFS_cond, 256, 256> PFS_cond_container;
+#else
+typedef PFS_buffer_container<PFS_cond> PFS_cond_container;
+#endif
+typedef PFS_cond_container::iterator_type PFS_cond_iterator;
+extern PFS_cond_container global_cond_container;
+
+#ifdef USE_SCALABLE
+typedef PFS_buffer_scalable_container<PFS_file, 4 * 1024, 4 * 1024> PFS_file_container;
+#else
+typedef PFS_buffer_container<PFS_file> PFS_file_container;
+#endif
+typedef PFS_file_container::iterator_type PFS_file_iterator;
+extern PFS_file_container global_file_container;
+
+#ifdef USE_SCALABLE
+typedef PFS_buffer_scalable_container<PFS_socket, 256, 256> PFS_socket_container;
+#else
+typedef PFS_buffer_container<PFS_socket> PFS_socket_container;
+#endif
+typedef PFS_socket_container::iterator_type PFS_socket_iterator;
+extern PFS_socket_container global_socket_container;
+
+#ifdef USE_SCALABLE
+typedef PFS_buffer_scalable_container<PFS_metadata_lock, 1024, 1024> PFS_mdl_container;
+#else
+typedef PFS_buffer_container<PFS_metadata_lock> PFS_mdl_container;
+#endif
+typedef PFS_mdl_container::iterator_type PFS_mdl_iterator;
+extern PFS_mdl_container global_mdl_container;
+
+#ifdef USE_SCALABLE
+typedef PFS_buffer_scalable_container<PFS_setup_actor, 128, 1024> PFS_setup_actor_container;
+#else
+typedef PFS_buffer_container<PFS_setup_actor> PFS_setup_actor_container;
+#endif
+typedef PFS_setup_actor_container::iterator_type PFS_setup_actor_iterator;
+extern PFS_setup_actor_container global_setup_actor_container;
+
+#ifdef USE_SCALABLE
+typedef PFS_buffer_scalable_container<PFS_setup_object, 128, 1024> PFS_setup_object_container;
+#else
+typedef PFS_buffer_container<PFS_setup_object> PFS_setup_object_container;
+#endif
+typedef PFS_setup_object_container::iterator_type PFS_setup_object_iterator;
+extern PFS_setup_object_container global_setup_object_container;
+
+#ifdef USE_SCALABLE
+typedef PFS_buffer_scalable_container<PFS_table, 1024, 1024> PFS_table_container;
+#else
+typedef PFS_buffer_container<PFS_table> PFS_table_container;
+#endif
+typedef PFS_table_container::iterator_type PFS_table_iterator;
+extern PFS_table_container global_table_container;
+
+#ifdef USE_SCALABLE
+typedef PFS_buffer_scalable_container<PFS_table_share, 4 * 1024, 4 * 1024> PFS_table_share_container;
+#else
+typedef PFS_buffer_container<PFS_table_share> PFS_table_share_container;
+#endif
+typedef PFS_table_share_container::iterator_type PFS_table_share_iterator;
+extern PFS_table_share_container global_table_share_container;
+
+#ifdef USE_SCALABLE
+typedef PFS_buffer_scalable_container<PFS_table_share_index, 8 * 1024, 8 * 1024> PFS_table_share_index_container;
+#else
+typedef PFS_buffer_container<PFS_table_share_index> PFS_table_share_index_container;
+#endif
+typedef PFS_table_share_index_container::iterator_type PFS_table_share_index_iterator;
+extern PFS_table_share_index_container global_table_share_index_container;
+
+#ifdef USE_SCALABLE
+typedef PFS_buffer_scalable_container<PFS_table_share_lock, 4 * 1024, 4 * 1024> PFS_table_share_lock_container;
+#else
+typedef PFS_buffer_container<PFS_table_share_lock> PFS_table_share_lock_container;
+#endif
+typedef PFS_table_share_lock_container::iterator_type PFS_table_share_lock_iterator;
+extern PFS_table_share_lock_container global_table_share_lock_container;
+
+#ifdef USE_SCALABLE
+typedef PFS_buffer_scalable_container<PFS_program, 1024, 1024> PFS_program_container;
+#else
+typedef PFS_buffer_container<PFS_program> PFS_program_container;
+#endif
+typedef PFS_program_container::iterator_type PFS_program_iterator;
+extern PFS_program_container global_program_container;
+
+#ifdef USE_SCALABLE
+typedef PFS_buffer_scalable_container<PFS_prepared_stmt, 1024, 1024> PFS_prepared_stmt_container;
+#else
+typedef PFS_buffer_container<PFS_prepared_stmt> PFS_prepared_stmt_container;
+#endif
+typedef PFS_prepared_stmt_container::iterator_type PFS_prepared_stmt_iterator;
+extern PFS_prepared_stmt_container global_prepared_stmt_container;
+
+class PFS_account_array : public PFS_buffer_default_array<PFS_account>
+{
+public:
+ PFS_single_stat *m_instr_class_waits_array;
+ PFS_stage_stat *m_instr_class_stages_array;
+ PFS_statement_stat *m_instr_class_statements_array;
+ PFS_transaction_stat *m_instr_class_transactions_array;
+ PFS_memory_stat *m_instr_class_memory_array;
+};
+
+class PFS_account_allocator
+{
+public:
+ int alloc_array(PFS_account_array *array);
+ void free_array(PFS_account_array *array);
+};
+
+#ifdef USE_SCALABLE
+typedef PFS_buffer_scalable_container<PFS_account,
+ 128,
+ 128,
+ PFS_account_array,
+ PFS_account_allocator> PFS_account_container;
+#else
+typedef PFS_buffer_container<PFS_account,
+ PFS_account_array,
+ PFS_account_allocator> PFS_account_container;
+#endif
+typedef PFS_account_container::iterator_type PFS_account_iterator;
+extern PFS_account_container global_account_container;
+
+class PFS_host_array : public PFS_buffer_default_array<PFS_host>
+{
+public:
+ PFS_single_stat *m_instr_class_waits_array;
+ PFS_stage_stat *m_instr_class_stages_array;
+ PFS_statement_stat *m_instr_class_statements_array;
+ PFS_transaction_stat *m_instr_class_transactions_array;
+ PFS_memory_stat *m_instr_class_memory_array;
+};
+
+class PFS_host_allocator
+{
+public:
+ int alloc_array(PFS_host_array *array);
+ void free_array(PFS_host_array *array);
+};
+
+#ifdef USE_SCALABLE
+typedef PFS_buffer_scalable_container<PFS_host,
+ 128,
+ 128,
+ PFS_host_array,
+ PFS_host_allocator> PFS_host_container;
+#else
+typedef PFS_buffer_container<PFS_host,
+ PFS_host_array,
+ PFS_host_allocator> PFS_host_container;
+#endif
+typedef PFS_host_container::iterator_type PFS_host_iterator;
+extern PFS_host_container global_host_container;
+
+class PFS_thread_array : public PFS_buffer_default_array<PFS_thread>
+{
+public:
+ PFS_single_stat *m_instr_class_waits_array;
+ PFS_stage_stat *m_instr_class_stages_array;
+ PFS_statement_stat *m_instr_class_statements_array;
+ PFS_transaction_stat *m_instr_class_transactions_array;
+ PFS_memory_stat *m_instr_class_memory_array;
+
+ PFS_events_waits *m_waits_history_array;
+ PFS_events_stages *m_stages_history_array;
+ PFS_events_statements *m_statements_history_array;
+ PFS_events_statements *m_statements_stack_array;
+ PFS_events_transactions *m_transactions_history_array;
+ char *m_session_connect_attrs_array;
+
+ char *m_current_stmts_text_array;
+ char *m_history_stmts_text_array;
+ unsigned char *m_current_stmts_digest_token_array;
+ unsigned char *m_history_stmts_digest_token_array;
+};
+
+class PFS_thread_allocator
+{
+public:
+ int alloc_array(PFS_thread_array *array);
+ void free_array(PFS_thread_array *array);
+};
+
+#ifdef USE_SCALABLE
+typedef PFS_buffer_scalable_container<PFS_thread,
+ 256,
+ 256,
+ PFS_thread_array,
+ PFS_thread_allocator> PFS_thread_container;
+#else
+typedef PFS_buffer_container<PFS_thread,
+ PFS_thread_array,
+ PFS_thread_allocator> PFS_thread_container;
+#endif
+typedef PFS_thread_container::iterator_type PFS_thread_iterator;
+extern PFS_thread_container global_thread_container;
+
+class PFS_user_array : public PFS_buffer_default_array<PFS_user>
+{
+public:
+ PFS_single_stat *m_instr_class_waits_array;
+ PFS_stage_stat *m_instr_class_stages_array;
+ PFS_statement_stat *m_instr_class_statements_array;
+ PFS_transaction_stat *m_instr_class_transactions_array;
+ PFS_memory_stat *m_instr_class_memory_array;
+};
+
+class PFS_user_allocator
+{
+public:
+ int alloc_array(PFS_user_array *array);
+ void free_array(PFS_user_array *array);
+};
+
+#ifdef USE_SCALABLE
+typedef PFS_buffer_scalable_container<PFS_user,
+ 128,
+ 128,
+ PFS_user_array,
+ PFS_user_allocator> PFS_user_container;
+#else
+typedef PFS_buffer_container<PFS_user,
+ PFS_user_array,
+ PFS_user_allocator> PFS_user_container;
+#endif
+typedef PFS_user_container::iterator_type PFS_user_iterator;
+extern PFS_user_container global_user_container;
+
+#endif
+
diff --git a/storage/perfschema/pfs_builtin_memory.cc b/storage/perfschema/pfs_builtin_memory.cc
new file mode 100644
index 00000000..676a9094
--- /dev/null
+++ b/storage/perfschema/pfs_builtin_memory.cc
@@ -0,0 +1,382 @@
+/* Copyright (c) 2014, 2019, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
+
+#include "my_global.h"
+#include "m_string.h"
+#include "pfs_global.h"
+#include "pfs_builtin_memory.h"
+
+PFS_builtin_memory_class builtin_memory_mutex;
+PFS_builtin_memory_class builtin_memory_rwlock;
+PFS_builtin_memory_class builtin_memory_cond;
+PFS_builtin_memory_class builtin_memory_file;
+PFS_builtin_memory_class builtin_memory_socket;
+PFS_builtin_memory_class builtin_memory_mdl;
+PFS_builtin_memory_class builtin_memory_file_handle;
+
+PFS_builtin_memory_class builtin_memory_account;
+PFS_builtin_memory_class builtin_memory_account_waits;
+PFS_builtin_memory_class builtin_memory_account_stages;
+PFS_builtin_memory_class builtin_memory_account_statements;
+PFS_builtin_memory_class builtin_memory_account_transactions;
+PFS_builtin_memory_class builtin_memory_account_memory;
+
+PFS_builtin_memory_class builtin_memory_global_stages;
+PFS_builtin_memory_class builtin_memory_global_statements;
+PFS_builtin_memory_class builtin_memory_global_memory;
+
+PFS_builtin_memory_class builtin_memory_host;
+PFS_builtin_memory_class builtin_memory_host_waits;
+PFS_builtin_memory_class builtin_memory_host_stages;
+PFS_builtin_memory_class builtin_memory_host_statements;
+PFS_builtin_memory_class builtin_memory_host_transactions;
+PFS_builtin_memory_class builtin_memory_host_memory;
+
+PFS_builtin_memory_class builtin_memory_thread;
+PFS_builtin_memory_class builtin_memory_thread_waits;
+PFS_builtin_memory_class builtin_memory_thread_stages;
+PFS_builtin_memory_class builtin_memory_thread_statements;
+PFS_builtin_memory_class builtin_memory_thread_transactions;
+PFS_builtin_memory_class builtin_memory_thread_memory;
+
+PFS_builtin_memory_class builtin_memory_thread_waits_history;
+PFS_builtin_memory_class builtin_memory_thread_stages_history;
+PFS_builtin_memory_class builtin_memory_thread_statements_history;
+PFS_builtin_memory_class builtin_memory_thread_statements_history_tokens;
+PFS_builtin_memory_class builtin_memory_thread_statements_history_sqltext;
+PFS_builtin_memory_class builtin_memory_thread_statements_stack;
+PFS_builtin_memory_class builtin_memory_thread_statements_stack_tokens;
+PFS_builtin_memory_class builtin_memory_thread_statements_stack_sqltext;
+PFS_builtin_memory_class builtin_memory_thread_transaction_history;
+PFS_builtin_memory_class builtin_memory_thread_session_connect_attrs;
+
+PFS_builtin_memory_class builtin_memory_user;
+PFS_builtin_memory_class builtin_memory_user_waits;
+PFS_builtin_memory_class builtin_memory_user_stages;
+PFS_builtin_memory_class builtin_memory_user_statements;
+PFS_builtin_memory_class builtin_memory_user_transactions;
+PFS_builtin_memory_class builtin_memory_user_memory;
+
+PFS_builtin_memory_class builtin_memory_mutex_class;
+PFS_builtin_memory_class builtin_memory_rwlock_class;
+PFS_builtin_memory_class builtin_memory_cond_class;
+PFS_builtin_memory_class builtin_memory_thread_class;
+PFS_builtin_memory_class builtin_memory_file_class;
+PFS_builtin_memory_class builtin_memory_socket_class;
+PFS_builtin_memory_class builtin_memory_stage_class;
+PFS_builtin_memory_class builtin_memory_statement_class;
+PFS_builtin_memory_class builtin_memory_memory_class;
+
+PFS_builtin_memory_class builtin_memory_setup_actor;
+PFS_builtin_memory_class builtin_memory_setup_object;
+
+PFS_builtin_memory_class builtin_memory_digest;
+PFS_builtin_memory_class builtin_memory_digest_tokens;
+
+PFS_builtin_memory_class builtin_memory_stages_history_long;
+PFS_builtin_memory_class builtin_memory_statements_history_long;
+PFS_builtin_memory_class builtin_memory_statements_history_long_tokens;
+PFS_builtin_memory_class builtin_memory_statements_history_long_sqltext;
+PFS_builtin_memory_class builtin_memory_transactions_history_long;
+PFS_builtin_memory_class builtin_memory_waits_history_long;
+
+PFS_builtin_memory_class builtin_memory_table;
+PFS_builtin_memory_class builtin_memory_table_share;
+PFS_builtin_memory_class builtin_memory_table_share_index;
+PFS_builtin_memory_class builtin_memory_table_share_lock;
+
+PFS_builtin_memory_class builtin_memory_program;
+PFS_builtin_memory_class builtin_memory_prepared_stmt;
+
+PFS_builtin_memory_class builtin_memory_scalable_buffer;
+
+static void init_builtin_memory_class(PFS_builtin_memory_class *klass, const char* name)
+{
+ klass->m_class.m_type= PFS_CLASS_MEMORY;
+ klass->m_class.m_enabled= true; /* Immutable */
+ klass->m_class.m_timed= false; /* Immutable */
+ klass->m_class.m_flags= PSI_FLAG_GLOBAL;
+ klass->m_class.m_event_name_index= 0;
+ my_snprintf(klass->m_class.m_name, sizeof(klass->m_class.m_name), "%.*s",
+ PFS_MAX_INFO_NAME_LENGTH - 1, name);
+ klass->m_class.m_name_length= static_cast<uint>(strlen(name));
+ DBUG_ASSERT(klass->m_class.m_name_length < sizeof(klass->m_class.m_name));
+ klass->m_class.m_timer= NULL;
+
+ klass->m_stat.reset();
+}
+
+void init_all_builtin_memory_class()
+{
+ init_builtin_memory_class( & builtin_memory_mutex,
+ "memory/performance_schema/mutex_instances");
+ init_builtin_memory_class( & builtin_memory_rwlock,
+ "memory/performance_schema/rwlock_instances");
+ init_builtin_memory_class( & builtin_memory_cond,
+ "memory/performance_schema/cond_instances");
+ init_builtin_memory_class( & builtin_memory_file,
+ "memory/performance_schema/file_instances");
+ init_builtin_memory_class( & builtin_memory_socket,
+ "memory/performance_schema/socket_instances");
+ init_builtin_memory_class( & builtin_memory_mdl,
+ "memory/performance_schema/metadata_locks");
+ init_builtin_memory_class( & builtin_memory_file_handle,
+ "memory/performance_schema/file_handle");
+
+ init_builtin_memory_class( & builtin_memory_account,
+ "memory/performance_schema/accounts");
+ init_builtin_memory_class( & builtin_memory_account_waits,
+ "memory/performance_schema/events_waits_summary_by_account_by_event_name");
+ init_builtin_memory_class( & builtin_memory_account_stages,
+ "memory/performance_schema/events_stages_summary_by_account_by_event_name");
+ init_builtin_memory_class( & builtin_memory_account_statements,
+ "memory/performance_schema/events_statements_summary_by_account_by_event_name");
+ init_builtin_memory_class( & builtin_memory_account_transactions,
+ "memory/performance_schema/events_transactions_summary_by_account_by_event_name");
+ init_builtin_memory_class( & builtin_memory_account_memory,
+ "memory/performance_schema/memory_summary_by_account_by_event_name");
+
+ init_builtin_memory_class( & builtin_memory_global_stages,
+ "memory/performance_schema/events_stages_summary_global_by_event_name");
+ init_builtin_memory_class( & builtin_memory_global_statements,
+ "memory/performance_schema/events_statements_summary_global_by_event_name");
+ init_builtin_memory_class( & builtin_memory_global_memory,
+ "memory/performance_schema/memory_summary_global_by_event_name");
+
+ init_builtin_memory_class( & builtin_memory_host,
+ "memory/performance_schema/hosts");
+ init_builtin_memory_class( & builtin_memory_host_waits,
+ "memory/performance_schema/events_waits_summary_by_host_by_event_name");
+ init_builtin_memory_class( & builtin_memory_host_stages,
+ "memory/performance_schema/events_stages_summary_by_host_by_event_name");
+ init_builtin_memory_class( & builtin_memory_host_statements,
+ "memory/performance_schema/events_statements_summary_by_host_by_event_name");
+ init_builtin_memory_class( & builtin_memory_host_transactions,
+ "memory/performance_schema/events_transactions_summary_by_host_by_event_name");
+ init_builtin_memory_class( & builtin_memory_host_memory,
+ "memory/performance_schema/memory_summary_by_host_by_event_name");
+
+ init_builtin_memory_class( & builtin_memory_thread,
+ "memory/performance_schema/threads");
+ init_builtin_memory_class( & builtin_memory_thread_waits,
+ "memory/performance_schema/events_waits_summary_by_thread_by_event_name");
+ init_builtin_memory_class( & builtin_memory_thread_stages,
+ "memory/performance_schema/events_stages_summary_by_thread_by_event_name");
+ init_builtin_memory_class( & builtin_memory_thread_statements,
+ "memory/performance_schema/events_statements_summary_by_thread_by_event_name");
+ init_builtin_memory_class( & builtin_memory_thread_transactions,
+ "memory/performance_schema/events_transactions_summary_by_thread_by_event_name");
+ init_builtin_memory_class( & builtin_memory_thread_memory,
+ "memory/performance_schema/memory_summary_by_thread_by_event_name");
+
+ init_builtin_memory_class( & builtin_memory_thread_waits_history,
+ "memory/performance_schema/events_waits_history");
+ init_builtin_memory_class( & builtin_memory_thread_stages_history,
+ "memory/performance_schema/events_stages_history");
+ init_builtin_memory_class( & builtin_memory_thread_statements_history,
+ "memory/performance_schema/events_statements_history");
+ init_builtin_memory_class( & builtin_memory_thread_statements_history_tokens,
+ "memory/performance_schema/events_statements_history.tokens");
+ init_builtin_memory_class( & builtin_memory_thread_statements_history_sqltext,
+ "memory/performance_schema/events_statements_history.sqltext");
+ init_builtin_memory_class( & builtin_memory_thread_statements_stack,
+ "memory/performance_schema/events_statements_current");
+ init_builtin_memory_class( & builtin_memory_thread_statements_stack_tokens,
+ "memory/performance_schema/events_statements_current.tokens");
+ init_builtin_memory_class( & builtin_memory_thread_statements_stack_sqltext,
+ "memory/performance_schema/events_statements_current.sqltext");
+ init_builtin_memory_class( & builtin_memory_thread_transaction_history,
+ "memory/performance_schema/events_transactions_history");
+ init_builtin_memory_class( & builtin_memory_thread_session_connect_attrs,
+ "memory/performance_schema/session_connect_attrs");
+
+ init_builtin_memory_class( & builtin_memory_user,
+ "memory/performance_schema/users");
+ init_builtin_memory_class( & builtin_memory_user_waits,
+ "memory/performance_schema/events_waits_summary_by_user_by_event_name");
+ init_builtin_memory_class( & builtin_memory_user_stages,
+ "memory/performance_schema/events_stages_summary_by_user_by_event_name");
+ init_builtin_memory_class( & builtin_memory_user_statements,
+ "memory/performance_schema/events_statements_summary_by_user_by_event_name");
+ init_builtin_memory_class( & builtin_memory_user_transactions,
+ "memory/performance_schema/events_transactions_summary_by_user_by_event_name");
+ init_builtin_memory_class( & builtin_memory_user_memory,
+ "memory/performance_schema/memory_summary_by_user_by_event_name");
+
+ init_builtin_memory_class( & builtin_memory_mutex_class,
+ "memory/performance_schema/mutex_class");
+ init_builtin_memory_class( & builtin_memory_rwlock_class,
+ "memory/performance_schema/rwlock_class");
+ init_builtin_memory_class( & builtin_memory_cond_class,
+ "memory/performance_schema/cond_class");
+ init_builtin_memory_class( & builtin_memory_thread_class,
+ "memory/performance_schema/thread_class");
+ init_builtin_memory_class( & builtin_memory_file_class,
+ "memory/performance_schema/file_class");
+ init_builtin_memory_class( & builtin_memory_socket_class,
+ "memory/performance_schema/socket_class");
+ init_builtin_memory_class( & builtin_memory_stage_class,
+ "memory/performance_schema/stage_class");
+ init_builtin_memory_class( & builtin_memory_statement_class,
+ "memory/performance_schema/statement_class");
+ init_builtin_memory_class( & builtin_memory_memory_class,
+ "memory/performance_schema/memory_class");
+
+ init_builtin_memory_class( & builtin_memory_setup_actor,
+ "memory/performance_schema/setup_actors");
+ init_builtin_memory_class( & builtin_memory_setup_object,
+ "memory/performance_schema/setup_objects");
+
+ init_builtin_memory_class( & builtin_memory_digest,
+ "memory/performance_schema/events_statements_summary_by_digest");
+ init_builtin_memory_class( & builtin_memory_digest_tokens,
+ "memory/performance_schema/events_statements_summary_by_digest.tokens");
+
+ init_builtin_memory_class( & builtin_memory_stages_history_long,
+ "memory/performance_schema/events_stages_history_long");
+ init_builtin_memory_class( & builtin_memory_statements_history_long,
+ "memory/performance_schema/events_statements_history_long");
+ init_builtin_memory_class( & builtin_memory_statements_history_long_tokens,
+ "memory/performance_schema/events_statements_history_long.tokens");
+ init_builtin_memory_class( & builtin_memory_statements_history_long_sqltext,
+ "memory/performance_schema/events_statements_history_long.sqltext");
+ init_builtin_memory_class( & builtin_memory_transactions_history_long,
+ "memory/performance_schema/events_transactions_history_long");
+ init_builtin_memory_class( & builtin_memory_waits_history_long,
+ "memory/performance_schema/events_waits_history_long");
+
+ init_builtin_memory_class( & builtin_memory_table,
+ "memory/performance_schema/table_handles");
+ init_builtin_memory_class( & builtin_memory_table_share,
+ "memory/performance_schema/table_shares");
+ init_builtin_memory_class( & builtin_memory_table_share_index,
+ "memory/performance_schema/table_io_waits_summary_by_index_usage");
+ init_builtin_memory_class( & builtin_memory_table_share_lock,
+ "memory/performance_schema/table_lock_waits_summary_by_table");
+
+ init_builtin_memory_class( & builtin_memory_program,
+ "memory/performance_schema/events_statements_summary_by_program");
+ init_builtin_memory_class( & builtin_memory_prepared_stmt,
+ "memory/performance_schema/prepared_statements_instances");
+
+ init_builtin_memory_class( & builtin_memory_scalable_buffer,
+ "memory/performance_schema/scalable_buffer");
+}
+
+static PFS_builtin_memory_class* all_builtin_memory[]=
+{
+ & builtin_memory_mutex,
+ & builtin_memory_rwlock,
+ & builtin_memory_cond,
+ & builtin_memory_file,
+ & builtin_memory_socket,
+ & builtin_memory_mdl,
+ & builtin_memory_file_handle,
+
+ & builtin_memory_account,
+ & builtin_memory_account_waits,
+ & builtin_memory_account_stages,
+ & builtin_memory_account_statements,
+ & builtin_memory_account_transactions,
+ & builtin_memory_account_memory,
+
+ & builtin_memory_global_stages,
+ & builtin_memory_global_statements,
+ & builtin_memory_global_memory,
+
+ & builtin_memory_host,
+ & builtin_memory_host_waits,
+ & builtin_memory_host_stages,
+ & builtin_memory_host_statements,
+ & builtin_memory_host_transactions,
+ & builtin_memory_host_memory,
+
+ & builtin_memory_thread,
+ & builtin_memory_thread_waits,
+ & builtin_memory_thread_stages,
+ & builtin_memory_thread_statements,
+ & builtin_memory_thread_transactions,
+ & builtin_memory_thread_memory,
+
+ & builtin_memory_thread_waits_history,
+ & builtin_memory_thread_stages_history,
+ & builtin_memory_thread_statements_history,
+ & builtin_memory_thread_statements_history_tokens,
+ & builtin_memory_thread_statements_history_sqltext,
+ & builtin_memory_thread_statements_stack,
+ & builtin_memory_thread_statements_stack_tokens,
+ & builtin_memory_thread_statements_stack_sqltext,
+ & builtin_memory_thread_transaction_history,
+ & builtin_memory_thread_session_connect_attrs,
+
+ & builtin_memory_user,
+ & builtin_memory_user_waits,
+ & builtin_memory_user_stages,
+ & builtin_memory_user_statements,
+ & builtin_memory_user_transactions,
+ & builtin_memory_user_memory,
+
+ & builtin_memory_mutex_class,
+ & builtin_memory_rwlock_class,
+ & builtin_memory_cond_class,
+ & builtin_memory_thread_class,
+ & builtin_memory_file_class,
+ & builtin_memory_socket_class,
+ & builtin_memory_stage_class,
+ & builtin_memory_statement_class,
+ & builtin_memory_memory_class,
+
+ & builtin_memory_setup_actor,
+ & builtin_memory_setup_object,
+
+ & builtin_memory_digest,
+ & builtin_memory_digest_tokens,
+
+ & builtin_memory_stages_history_long,
+ & builtin_memory_statements_history_long,
+ & builtin_memory_statements_history_long_tokens,
+ & builtin_memory_statements_history_long_sqltext,
+ & builtin_memory_transactions_history_long,
+ & builtin_memory_waits_history_long,
+
+ & builtin_memory_table,
+ & builtin_memory_table_share,
+ & builtin_memory_table_share_index,
+ & builtin_memory_table_share_lock,
+
+ & builtin_memory_program,
+ & builtin_memory_prepared_stmt,
+
+ & builtin_memory_scalable_buffer,
+
+ NULL
+};
+
+
+PFS_builtin_memory_class *find_builtin_memory_class(PFS_builtin_memory_key key)
+{
+ if (key == 0)
+ return NULL;
+
+ return all_builtin_memory[key - 1];
+}
+
diff --git a/storage/perfschema/pfs_builtin_memory.h b/storage/perfschema/pfs_builtin_memory.h
new file mode 100644
index 00000000..1c00275d
--- /dev/null
+++ b/storage/perfschema/pfs_builtin_memory.h
@@ -0,0 +1,143 @@
+/* Copyright (c) 2014, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
+
+#ifndef PFS_BUILTIN_MEMORY_H
+#define PFS_BUILTIN_MEMORY_H
+
+#include "my_global.h"
+#include "pfs_global.h"
+#include "pfs_instr_class.h"
+
+/**
+ @file storage/perfschema/pfs_builtin_memory.h
+ Performance schema instruments meta data (declarations).
+*/
+
+typedef uint PFS_builtin_memory_key;
+
+struct PFS_builtin_memory_class
+{
+ PFS_memory_class m_class;
+ PFS_memory_stat m_stat;
+
+ inline void count_alloc(size_t size)
+ {
+ m_stat.count_builtin_alloc(size);
+ }
+
+ inline void count_free(size_t size)
+ {
+ m_stat.count_builtin_free(size);
+ }
+};
+
+void init_all_builtin_memory_class();
+
+PFS_builtin_memory_class *find_builtin_memory_class(PFS_builtin_memory_key);
+
+extern PFS_builtin_memory_class builtin_memory_mutex;
+extern PFS_builtin_memory_class builtin_memory_rwlock;
+extern PFS_builtin_memory_class builtin_memory_cond;
+extern PFS_builtin_memory_class builtin_memory_file;
+extern PFS_builtin_memory_class builtin_memory_socket;
+extern PFS_builtin_memory_class builtin_memory_mdl;
+extern PFS_builtin_memory_class builtin_memory_file_handle;
+
+extern PFS_builtin_memory_class builtin_memory_account;
+extern PFS_builtin_memory_class builtin_memory_account_waits;
+extern PFS_builtin_memory_class builtin_memory_account_stages;
+extern PFS_builtin_memory_class builtin_memory_account_statements;
+extern PFS_builtin_memory_class builtin_memory_account_transactions;
+extern PFS_builtin_memory_class builtin_memory_account_memory;
+
+extern PFS_builtin_memory_class builtin_memory_global_stages;
+extern PFS_builtin_memory_class builtin_memory_global_statements;
+extern PFS_builtin_memory_class builtin_memory_global_memory;
+
+extern PFS_builtin_memory_class builtin_memory_host;
+extern PFS_builtin_memory_class builtin_memory_host_waits;
+extern PFS_builtin_memory_class builtin_memory_host_stages;
+extern PFS_builtin_memory_class builtin_memory_host_statements;
+extern PFS_builtin_memory_class builtin_memory_host_transactions;
+extern PFS_builtin_memory_class builtin_memory_host_memory;
+
+extern PFS_builtin_memory_class builtin_memory_thread;
+extern PFS_builtin_memory_class builtin_memory_thread_waits;
+extern PFS_builtin_memory_class builtin_memory_thread_stages;
+extern PFS_builtin_memory_class builtin_memory_thread_statements;
+extern PFS_builtin_memory_class builtin_memory_thread_transactions;
+extern PFS_builtin_memory_class builtin_memory_thread_memory;
+
+extern PFS_builtin_memory_class builtin_memory_thread_waits_history;
+extern PFS_builtin_memory_class builtin_memory_thread_stages_history;
+extern PFS_builtin_memory_class builtin_memory_thread_statements_history;
+extern PFS_builtin_memory_class builtin_memory_thread_statements_history_tokens;
+extern PFS_builtin_memory_class builtin_memory_thread_statements_history_sqltext;
+extern PFS_builtin_memory_class builtin_memory_thread_statements_stack;
+extern PFS_builtin_memory_class builtin_memory_thread_statements_stack_tokens;
+extern PFS_builtin_memory_class builtin_memory_thread_statements_stack_sqltext;
+extern PFS_builtin_memory_class builtin_memory_thread_transaction_history;
+extern PFS_builtin_memory_class builtin_memory_thread_session_connect_attrs;
+
+extern PFS_builtin_memory_class builtin_memory_user;
+extern PFS_builtin_memory_class builtin_memory_user_waits;
+extern PFS_builtin_memory_class builtin_memory_user_stages;
+extern PFS_builtin_memory_class builtin_memory_user_statements;
+extern PFS_builtin_memory_class builtin_memory_user_transactions;
+extern PFS_builtin_memory_class builtin_memory_user_memory;
+
+extern PFS_builtin_memory_class builtin_memory_mutex_class;
+extern PFS_builtin_memory_class builtin_memory_rwlock_class;
+extern PFS_builtin_memory_class builtin_memory_cond_class;
+extern PFS_builtin_memory_class builtin_memory_thread_class;
+extern PFS_builtin_memory_class builtin_memory_file_class;
+extern PFS_builtin_memory_class builtin_memory_socket_class;
+extern PFS_builtin_memory_class builtin_memory_stage_class;
+extern PFS_builtin_memory_class builtin_memory_statement_class;
+extern PFS_builtin_memory_class builtin_memory_memory_class;
+
+extern PFS_builtin_memory_class builtin_memory_setup_actor;
+extern PFS_builtin_memory_class builtin_memory_setup_object;
+
+extern PFS_builtin_memory_class builtin_memory_digest;
+extern PFS_builtin_memory_class builtin_memory_digest_tokens;
+
+extern PFS_builtin_memory_class builtin_memory_stages_history_long;
+extern PFS_builtin_memory_class builtin_memory_statements_history_long;
+extern PFS_builtin_memory_class builtin_memory_statements_history_long_tokens;
+extern PFS_builtin_memory_class builtin_memory_statements_history_long_sqltext;
+extern PFS_builtin_memory_class builtin_memory_transactions_history_long;
+extern PFS_builtin_memory_class builtin_memory_waits_history_long;
+
+extern PFS_builtin_memory_class builtin_memory_table;
+extern PFS_builtin_memory_class builtin_memory_table_share;
+extern PFS_builtin_memory_class builtin_memory_table_share_index;
+extern PFS_builtin_memory_class builtin_memory_table_share_lock;
+
+extern PFS_builtin_memory_class builtin_memory_program;
+extern PFS_builtin_memory_class builtin_memory_prepared_stmt;
+
+extern PFS_builtin_memory_class builtin_memory_scalable_buffer;
+
+/** @} */
+#endif
+
diff --git a/storage/perfschema/pfs_column_types.h b/storage/perfschema/pfs_column_types.h
new file mode 100644
index 00000000..e4577fdb
--- /dev/null
+++ b/storage/perfschema/pfs_column_types.h
@@ -0,0 +1,328 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef PFS_COLUMN_TYPES_H
+#define PFS_COLUMN_TYPES_H
+
+/**
+ @file storage/perfschema/pfs_column_types.h
+ Data types for columns used in the performance schema tables (declarations)
+*/
+
+/** Size of the OBJECT_SCHEMA columns. */
+#define COL_OBJECT_SCHEMA_SIZE 64
+
+/**
+ Size of the extended OBJECT_NAME columns.
+ 'Extended' columns are used when the object name also represents
+ the name of a non SQL object, such as a file name.
+ Size in bytes of:
+ - performance_schema.events_waits_current (OBJECT_NAME)
+ - performance_schema.events_waits_history (OBJECT_NAME)
+ - performance_schema.events_waits_history_long (OBJECT_NAME)
+*/
+#define COL_OBJECT_NAME_EXTENDED_SIZE 512
+
+/** Size of the OBJECT_NAME columns. */
+#define COL_OBJECT_NAME_SIZE 64
+
+/** Size of the INDEX_NAME columns. */
+#define COL_INDEX_NAME_SIZE 64
+
+/**
+ Size of INFO columns.
+ Size in bytes of:
+ - performance_schema.events_statement_current (INFO)
+ - performance_schema.events_statement_history (INFO)
+ - performance_schema.events_statement_history_long (INFO)
+*/
+#define COL_INFO_SIZE 1024
+
+/** Size of the SOURCE columns. */
+#define COL_SOURCE_SIZE 64
+
+/** Size of the DIGEST columns. */
+#define COL_DIGEST_SIZE 64
+
+/**
+ Enum values for the TIMER_NAME columns.
+ This enum is found in the following tables:
+ - performance_schema.setup_timer (TIMER_NAME)
+ - performance_schema.performance_timer (TIMER_NAME)
+*/
+enum enum_timer_name
+{
+ TIMER_NAME_CYCLE= 1,
+ TIMER_NAME_NANOSEC= 2,
+ TIMER_NAME_MICROSEC= 3,
+ TIMER_NAME_MILLISEC= 4,
+ TIMER_NAME_TICK= 5
+};
+
+/** Integer, first value of @sa enum_timer_name. */
+#define FIRST_TIMER_NAME (static_cast<int> (TIMER_NAME_CYCLE))
+/** Integer, last value of @sa enum_timer_name. */
+#define LAST_TIMER_NAME (static_cast<int> (TIMER_NAME_TICK))
+/** Integer, number of values of @sa enum_timer_name. */
+#define COUNT_TIMER_NAME (LAST_TIMER_NAME - FIRST_TIMER_NAME + 1)
+
+/**
+ Enum values for the various YES/NO columns.
+ This enum is found in the following tables:
+ - performance_schema.setup_instruments (ENABLED)
+ - performance_schema.setup_instruments (TIMED)
+ - performance_schema.setup_consumers (ENABLED)
+*/
+enum enum_yes_no
+{
+ ENUM_YES= 1,
+ ENUM_NO= 2
+};
+
+/**
+ Enum values for the various OPERATION columns.
+ This enum is found in the following tables:
+ - performance_schema.events_waits_current (OPERATION)
+ - performance_schema.events_waits_history (OPERATION)
+ - performance_schema.events_waits_history_long (OPERATION)
+*/
+enum enum_operation_type
+{
+ /* Mutex operations */
+ OPERATION_TYPE_LOCK= 1,
+ OPERATION_TYPE_TRYLOCK= 2,
+
+ /* Rwlock operations (RW-lock) */
+ OPERATION_TYPE_READLOCK= 3,
+ OPERATION_TYPE_WRITELOCK= 4,
+ OPERATION_TYPE_TRYREADLOCK= 5,
+ OPERATION_TYPE_TRYWRITELOCK= 6,
+
+ /* Rwlock operations (SX-lock) */
+ OPERATION_TYPE_SHAREDLOCK= 7,
+ OPERATION_TYPE_SHAREDEXCLUSIVELOCK= 8,
+ OPERATION_TYPE_EXCLUSIVELOCK= 9,
+ OPERATION_TYPE_TRYSHAREDLOCK= 10,
+ OPERATION_TYPE_TRYSHAREDEXCLUSIVELOCK= 11,
+ OPERATION_TYPE_TRYEXCLUSIVELOCK= 12,
+
+ /* Cond operations */
+ OPERATION_TYPE_WAIT= 13,
+ OPERATION_TYPE_TIMEDWAIT= 14,
+
+ /* File operations */
+ OPERATION_TYPE_FILECREATE= 15,
+ OPERATION_TYPE_FILECREATETMP= 16,
+ OPERATION_TYPE_FILEOPEN= 17,
+ OPERATION_TYPE_FILESTREAMOPEN= 18,
+ OPERATION_TYPE_FILECLOSE= 19,
+ OPERATION_TYPE_FILESTREAMCLOSE= 20,
+ OPERATION_TYPE_FILEREAD= 21,
+ OPERATION_TYPE_FILEWRITE= 22,
+ OPERATION_TYPE_FILESEEK= 23,
+ OPERATION_TYPE_FILETELL= 24,
+ OPERATION_TYPE_FILEFLUSH= 25,
+ OPERATION_TYPE_FILESTAT= 26,
+ OPERATION_TYPE_FILEFSTAT= 27,
+ OPERATION_TYPE_FILECHSIZE= 28,
+ OPERATION_TYPE_FILEDELETE= 29,
+ OPERATION_TYPE_FILERENAME= 30,
+ OPERATION_TYPE_FILESYNC= 31,
+
+ /* Table io operations */
+ OPERATION_TYPE_TABLE_FETCH= 32,
+ OPERATION_TYPE_TABLE_WRITE_ROW= 33,
+ OPERATION_TYPE_TABLE_UPDATE_ROW= 34,
+ OPERATION_TYPE_TABLE_DELETE_ROW= 35,
+
+ /* Table lock operations */
+ OPERATION_TYPE_TL_READ_NORMAL= 36,
+ OPERATION_TYPE_TL_READ_WITH_SHARED_LOCKS= 37,
+ OPERATION_TYPE_TL_READ_HIGH_PRIORITY= 38,
+ OPERATION_TYPE_TL_READ_NO_INSERTS= 39,
+ OPERATION_TYPE_TL_WRITE_ALLOW_WRITE= 40,
+ OPERATION_TYPE_TL_WRITE_CONCURRENT_INSERT= 41,
+ OPERATION_TYPE_TL_WRITE_DELAYED= 42,
+ OPERATION_TYPE_TL_WRITE_LOW_PRIORITY= 43,
+ OPERATION_TYPE_TL_WRITE_NORMAL= 44,
+ OPERATION_TYPE_TL_READ_EXTERNAL= 45,
+ OPERATION_TYPE_TL_WRITE_EXTERNAL= 46,
+
+ /* Socket operations */
+ OPERATION_TYPE_SOCKETCREATE = 47,
+ OPERATION_TYPE_SOCKETCONNECT = 48,
+ OPERATION_TYPE_SOCKETBIND = 49,
+ OPERATION_TYPE_SOCKETCLOSE = 50,
+ OPERATION_TYPE_SOCKETSEND = 51,
+ OPERATION_TYPE_SOCKETRECV = 52,
+ OPERATION_TYPE_SOCKETSENDTO = 53,
+ OPERATION_TYPE_SOCKETRECVFROM = 54,
+ OPERATION_TYPE_SOCKETSENDMSG = 55,
+ OPERATION_TYPE_SOCKETRECVMSG = 56,
+ OPERATION_TYPE_SOCKETSEEK = 57,
+ OPERATION_TYPE_SOCKETOPT = 58,
+ OPERATION_TYPE_SOCKETSTAT = 59,
+ OPERATION_TYPE_SOCKETSHUTDOWN = 60,
+ OPERATION_TYPE_SOCKETSELECT = 61,
+
+ /* Idle operation */
+ OPERATION_TYPE_IDLE= 62,
+
+ /* Metadata lock operation */
+ OPERATION_TYPE_METADATA= 63
+};
+/** Integer, first value of @sa enum_operation_type. */
+#define FIRST_OPERATION_TYPE (static_cast<int> (OPERATION_TYPE_LOCK))
+/** Integer, last value of @sa enum_operation_type. */
+#define LAST_OPERATION_TYPE (static_cast<int> (OPERATION_TYPE_METADATA))
+/** Integer, number of values of @sa enum_operation_type. */
+#define COUNT_OPERATION_TYPE (LAST_OPERATION_TYPE - FIRST_OPERATION_TYPE + 1)
+
+/**
+ Enum values for the various OBJECT_TYPE columns.
+*/
+enum enum_object_type
+{
+ NO_OBJECT_TYPE= 0,
+
+ /* Advertised in SQL ENUM (see table_setup_object.cc) */
+
+ OBJECT_TYPE_EVENT= 1,
+ OBJECT_TYPE_FUNCTION= 2,
+ OBJECT_TYPE_PROCEDURE= 3,
+ OBJECT_TYPE_TABLE= 4,
+ OBJECT_TYPE_TRIGGER= 5,
+
+ /* Not advertised in SQL ENUM, only displayed as VARCHAR */
+
+ OBJECT_TYPE_TEMPORARY_TABLE= 6,
+ OBJECT_TYPE_BACKUP= 7,
+ OBJECT_TYPE_SCHEMA= 8,
+ OBJECT_TYPE_PACKAGE= 9,
+ OBJECT_TYPE_PACKAGE_BODY= 10,
+ OBJECT_TYPE_USER_LEVEL_LOCK= 11,
+};
+/** Integer, first value of @sa enum_object_type. */
+#define FIRST_OBJECT_TYPE (static_cast<int> (OBJECT_TYPE_EVENT))
+/** Integer, last value of @sa enum_object_type. */
+#define LAST_OBJECT_TYPE (static_cast<int> (OBJECT_TYPE_USER_LEVEL_LOCK))
+/** Integer, number of values of @sa enum_object_type. */
+#define COUNT_OBJECT_TYPE (LAST_OBJECT_TYPE - FIRST_OBJECT_TYPE + 1)
+
+/**
+ Enum values for the NESTING_EVENT_TYPE columns.
+ This enum is found in the following tables:
+ - performance_schema.events_waits_current (NESTING_EVENT_TYPE)
+ - performance_schema.events_stages_current (NESTING_EVENT_TYPE)
+ - performance_schema.events_statements_current (NESTING_EVENT_TYPE)
+*/
+enum enum_event_type
+{
+ EVENT_TYPE_TRANSACTION= 1,
+ EVENT_TYPE_STATEMENT= 2,
+ EVENT_TYPE_STAGE= 3,
+ EVENT_TYPE_WAIT= 4
+};
+
+/** Integer, first value of @sa enum_event_type. */
+#define FIRST_EVENT_TYPE (static_cast<int> (EVENT_TYPE_TRANSACTION))
+/** Integer, last value of @sa enum_event_type. */
+#define LAST_EVENT_TYPE (static_cast<int> (EVENT_TYPE_WAIT))
+/** Integer, number of values of @sa enum_event_type. */
+#define COUNT_EVENT_TYPE (LAST_EVENT_TYPE - FIRST_EVENT_TYPE + 1)
+
+/**
+ Enum values for transaction state columns.
+*/
+enum enum_transaction_state
+{
+ TRANS_STATE_ACTIVE= 1,
+ TRANS_STATE_COMMITTED= 2,
+ TRANS_STATE_ROLLED_BACK= 3
+};
+
+/** Integer, first value of @sa enum_transaction_state. */
+#define FIRST_TRANS_STATE (static_cast<int> (TRANS_STATE_ACTIVE))
+/** Integer, last value of @sa enum_transaction_state. */
+#define LAST_TRANS_STATE (static_cast<int> (TRANS_STATE_ROLLED_BACK))
+/** Integer, number of values of @sa enum_transaction_state. */
+#define COUNT_TRANS_STATE (LAST_TRANS_STATE - FIRST_TRANS_STATE + 1)
+
+/**
+ Enum values for XA transaction state columns. Enums 0-3 match those used by
+ the server. See XID_STATE::enum xa_states in xa.h.
+*/
+enum enum_xa_transaction_state
+{
+ TRANS_STATE_XA_NOTR=-1,
+ TRANS_STATE_XA_ACTIVE=0,
+ TRANS_STATE_XA_IDLE,
+ TRANS_STATE_XA_PREPARED,
+ TRANS_STATE_XA_ROLLBACK_ONLY,
+ TRANS_STATE_XA_COMMITTED
+};
+
+/** Integer, first value of @sa enum_xa_transaction_state. */
+#define FIRST_TRANS_STATE_XA (static_cast<int> (TRANS_STATE_XA_NOTR))
+/** Integer, last value of @sa enum_xa_transaction_state. */
+#define LAST_TRANS_STATE_XA (static_cast<int> (TRANS_STATE_XA_COMMITTED))
+/** Integer, number of values of @sa enum_xa_transaction_state. */
+#define COUNT_TRANS_STATE_XA (LAST_TRANS_STATE_XA - FIRST_TRANS_STATE_XA + 1)
+
+/**
+ Enum values for transaction isolation level columns.
+ See enum_tx_isolation in handler.h.
+*/
+enum enum_isolation_level
+{
+ TRANS_LEVEL_READ_UNCOMMITTED,
+ TRANS_LEVEL_READ_COMMITTED,
+ TRANS_LEVEL_REPEATABLE_READ,
+ TRANS_LEVEL_SERIALIZABLE
+};
+
+/** Integer, first value of @sa enum_isolation_level. */
+#define FIRST_TRANS_LEVEL (static_cast<int> (TRANS_LEVEL_READ_UNCOMMITTED))
+/** Integer, last value of @sa enum_isolation_level. */
+#define LAST_TRANS_LEVEL (static_cast<int> (TRANS_LEVEL_SERIALIZABLE))
+/** Integer, number of values of @sa enum_isolation_level. */
+#define COUNT_TRANS_LEVEL (LAST_TRANS_LEVEL - FIRST_TRANS_LEVEL + 1)
+
+/**
+ Enum values for transaction acces mode columns.
+*/
+enum enum_transaction_mode
+{
+ TRANS_MODE_READ_ONLY= 1,
+ TRANS_MODE_READ_WRITE= 2
+};
+
+/** Integer, first value of @sa enum_transaction_mode. */
+#define FIRST_TRANS_MODE (static_cast<int> (TRANS_MODE_READ_WRITE))
+/** Integer, last value of @sa enum_transaction_mode. */
+#define LAST_TRANS_MODE (static_cast<int> (TRANS_MODE_READ_ONLY))
+/** Integer, number of values of @sa enum_transaction_mode. */
+#define COUNT_TRANS_MODE (LAST_TRANS_MODE - FIRST_TRANS_MODE + 1)
+
+
+#endif
+
diff --git a/storage/perfschema/pfs_column_values.cc b/storage/perfschema/pfs_column_values.cc
new file mode 100644
index 00000000..9ce9b3b4
--- /dev/null
+++ b/storage/perfschema/pfs_column_values.cc
@@ -0,0 +1,67 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/pfs_column_values.cc
+ Literal values for columns used in the performance
+ schema tables (implementation).
+*/
+
+#include "my_global.h"
+#include "pfs_column_values.h"
+
+LEX_CSTRING PERFORMANCE_SCHEMA_str=
+{ STRING_WITH_LEN("performance_schema") };
+
+LEX_CSTRING mutex_instrument_prefix=
+{ STRING_WITH_LEN("wait/synch/mutex/") };
+
+LEX_CSTRING rwlock_instrument_prefix=
+{ STRING_WITH_LEN("wait/synch/rwlock/") };
+
+LEX_CSTRING sxlock_instrument_prefix=
+{ C_STRING_WITH_LEN("wait/synch/sxlock/") };
+
+LEX_CSTRING cond_instrument_prefix=
+{ C_STRING_WITH_LEN("wait/synch/cond/") };
+
+LEX_CSTRING thread_instrument_prefix=
+{ STRING_WITH_LEN("thread/") };
+
+LEX_CSTRING file_instrument_prefix=
+{ STRING_WITH_LEN("wait/io/file/") };
+
+LEX_CSTRING stage_instrument_prefix=
+{ STRING_WITH_LEN("stage/") };
+
+LEX_CSTRING statement_instrument_prefix=
+{ STRING_WITH_LEN("statement/") };
+
+LEX_CSTRING transaction_instrument_prefix=
+{ C_STRING_WITH_LEN("transaction") };
+
+LEX_CSTRING socket_instrument_prefix=
+{ C_STRING_WITH_LEN("wait/io/socket/") };
+
+LEX_CSTRING memory_instrument_prefix=
+{ C_STRING_WITH_LEN("memory/") };
+
diff --git a/storage/perfschema/pfs_column_values.h b/storage/perfschema/pfs_column_values.h
new file mode 100644
index 00000000..ea3d9eb9
--- /dev/null
+++ b/storage/perfschema/pfs_column_values.h
@@ -0,0 +1,61 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef PFS_COLUMN_VALUES_H
+#define PFS_COLUMN_VALUES_H
+
+#include "m_string.h" /* LEX_CSTRING */
+
+/**
+ @file storage/perfschema/pfs_column_values.h
+ Literal values for columns used in the
+ performance schema tables (declarations).
+*/
+
+/** String, "PERFORMANCE_SCHEMA". */
+extern LEX_CSTRING PERFORMANCE_SCHEMA_str;
+
+/** String prefix for all mutex instruments. */
+extern LEX_CSTRING mutex_instrument_prefix;
+/** String prefix for all rwlock instruments. */
+extern LEX_CSTRING rwlock_instrument_prefix;
+/** String prefix for all sxlock instruments. */
+extern LEX_CSTRING sxlock_instrument_prefix;
+/** String prefix for all cond instruments. */
+extern LEX_CSTRING cond_instrument_prefix;
+/** String prefix for all thread instruments. */
+extern LEX_CSTRING thread_instrument_prefix;
+/** String prefix for all file instruments. */
+extern LEX_CSTRING file_instrument_prefix;
+/** String prefix for all stage instruments. */
+extern LEX_CSTRING stage_instrument_prefix;
+/** String prefix for all statement instruments. */
+extern LEX_CSTRING statement_instrument_prefix;
+/** String prefix for all transaction instruments. */
+extern LEX_CSTRING transaction_instrument_prefix;
+/** String prefix for all socket instruments. */
+extern LEX_CSTRING socket_instrument_prefix;
+/** String prefix for all memory instruments. */
+extern LEX_CSTRING memory_instrument_prefix;
+
+#endif
+
diff --git a/storage/perfschema/pfs_con_slice.cc b/storage/perfschema/pfs_con_slice.cc
new file mode 100644
index 00000000..3733ad9e
--- /dev/null
+++ b/storage/perfschema/pfs_con_slice.cc
@@ -0,0 +1,82 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
+
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "pfs_con_slice.h"
+#include "pfs_stat.h"
+#include "pfs_global.h"
+#include "pfs_instr_class.h"
+
+/**
+ @file storage/perfschema/pfs_con_slice.cc
+ Performance schema connection slice (implementation).
+*/
+
+/**
+ @addtogroup Performance_schema_buffers
+ @{
+*/
+
+void PFS_connection_slice::reset_waits_stats()
+{
+ PFS_single_stat *stat= m_instr_class_waits_stats;
+ PFS_single_stat *stat_last= stat + wait_class_max;
+ for ( ; stat < stat_last; stat++)
+ stat->reset();
+}
+
+void PFS_connection_slice::reset_stages_stats()
+{
+ PFS_stage_stat *stat= m_instr_class_stages_stats;
+ PFS_stage_stat *stat_last= stat + stage_class_max;
+ for ( ; stat < stat_last; stat++)
+ stat->reset();
+}
+
+void PFS_connection_slice::reset_statements_stats()
+{
+ PFS_statement_stat *stat= m_instr_class_statements_stats;
+ PFS_statement_stat *stat_last= stat + statement_class_max;
+ for ( ; stat < stat_last; stat++)
+ stat->reset();
+}
+
+void PFS_connection_slice::reset_transactions_stats()
+{
+ PFS_transaction_stat *stat=
+ &m_instr_class_transactions_stats[GLOBAL_TRANSACTION_INDEX];
+ if (stat)
+ stat->reset();
+}
+
+void PFS_connection_slice::rebase_memory_stats()
+{
+ PFS_memory_stat *stat= m_instr_class_memory_stats;
+ PFS_memory_stat *stat_last= stat + memory_class_max;
+ for ( ; stat < stat_last; stat++)
+ stat->reset();
+}
+
+/** @} */
+
diff --git a/storage/perfschema/pfs_con_slice.h b/storage/perfschema/pfs_con_slice.h
new file mode 100644
index 00000000..56497ffe
--- /dev/null
+++ b/storage/perfschema/pfs_con_slice.h
@@ -0,0 +1,261 @@
+/* Copyright (c) 2010, 2016, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef PFS_CON_SLICE_H
+#define PFS_CON_SLICE_H
+
+/**
+ @file storage/perfschema/pfs_con_slice.h
+ Performance schema connection slice (declarations).
+*/
+
+#include "sql_class.h"
+#include "pfs_lock.h"
+#include "lf.h"
+#include "pfs_status.h"
+
+struct PFS_single_stat;
+struct PFS_stage_stat;
+struct PFS_statement_stat;
+struct PFS_transaction_stat;
+struct PFS_memory_stat;
+class PFS_opaque_container_page;
+
+/**
+ @addtogroup Performance_schema_buffers
+ @{
+*/
+
+/**
+ A connection slice, an arbitrary grouping of several connections.
+ This structure holds statistics for grouping of connections.
+*/
+struct PFS_connection_slice
+{
+ /** Reset all statistics. */
+ inline void reset_stats()
+ {
+ m_has_waits_stats= false;
+ m_has_stages_stats= false;
+ m_has_statements_stats= false;
+ m_has_transactions_stats= false;
+ m_has_memory_stats= false;
+ reset_status_stats();
+ }
+
+ /** Reset all wait statistics. */
+ void reset_waits_stats();
+ /** Reset all stages statistics. */
+ void reset_stages_stats();
+ /** Reset all statements statistics. */
+ void reset_statements_stats();
+ /** Reset all transactions statistics. */
+ void reset_transactions_stats();
+ /** Reset all memory statistics. */
+ void rebase_memory_stats();
+ /** Reset all status variable statistics. */
+ void reset_status_stats()
+ {
+ m_status_stats.reset();
+ }
+
+ void set_instr_class_waits_stats(PFS_single_stat *array)
+ {
+ m_has_waits_stats= false;
+ m_instr_class_waits_stats= array;
+ }
+
+ const PFS_single_stat* read_instr_class_waits_stats() const
+ {
+ if (! m_has_waits_stats)
+ return NULL;
+ return m_instr_class_waits_stats;
+ }
+
+ PFS_single_stat* write_instr_class_waits_stats()
+ {
+ if (! m_has_waits_stats)
+ {
+ reset_waits_stats();
+ m_has_waits_stats= true;
+ }
+ return m_instr_class_waits_stats;
+ }
+
+ void set_instr_class_stages_stats(PFS_stage_stat *array)
+ {
+ m_has_stages_stats= false;
+ m_instr_class_stages_stats= array;
+ }
+
+ const PFS_stage_stat* read_instr_class_stages_stats() const
+ {
+ if (! m_has_stages_stats)
+ return NULL;
+ return m_instr_class_stages_stats;
+ }
+
+ PFS_stage_stat* write_instr_class_stages_stats()
+ {
+ if (! m_has_stages_stats)
+ {
+ reset_stages_stats();
+ m_has_stages_stats= true;
+ }
+ return m_instr_class_stages_stats;
+ }
+
+ void set_instr_class_statements_stats(PFS_statement_stat *array)
+ {
+ m_has_statements_stats= false;
+ m_instr_class_statements_stats= array;
+ }
+
+ const PFS_statement_stat* read_instr_class_statements_stats() const
+ {
+ if (! m_has_statements_stats)
+ return NULL;
+ return m_instr_class_statements_stats;
+ }
+
+ PFS_statement_stat* write_instr_class_statements_stats()
+ {
+ if (! m_has_statements_stats)
+ {
+ reset_statements_stats();
+ m_has_statements_stats= true;
+ }
+ return m_instr_class_statements_stats;
+ }
+
+ void set_instr_class_transactions_stats(PFS_transaction_stat *array)
+ {
+ m_has_transactions_stats= false;
+ m_instr_class_transactions_stats= array;
+ }
+
+ const PFS_transaction_stat* read_instr_class_transactions_stats() const
+ {
+ if (! m_has_transactions_stats)
+ return NULL;
+ return m_instr_class_transactions_stats;
+ }
+
+ PFS_transaction_stat* write_instr_class_transactions_stats()
+ {
+ if (! m_has_transactions_stats)
+ {
+ reset_transactions_stats();
+ m_has_transactions_stats= true;
+ }
+ return m_instr_class_transactions_stats;
+ }
+
+ void set_instr_class_memory_stats(PFS_memory_stat *array)
+ {
+ m_has_memory_stats= false;
+ m_instr_class_memory_stats= array;
+ }
+
+ const PFS_memory_stat* read_instr_class_memory_stats() const
+ {
+ if (! m_has_memory_stats)
+ return NULL;
+ return m_instr_class_memory_stats;
+ }
+
+ PFS_memory_stat* write_instr_class_memory_stats()
+ {
+ if (! m_has_memory_stats)
+ {
+ rebase_memory_stats();
+ m_has_memory_stats= true;
+ }
+ return m_instr_class_memory_stats;
+ }
+
+private:
+ bool m_has_waits_stats;
+ bool m_has_stages_stats;
+ bool m_has_statements_stats;
+ bool m_has_transactions_stats;
+ bool m_has_memory_stats;
+
+ /**
+ Per connection slice waits aggregated statistics.
+ This member holds the data for the table
+ PERFORMANCE_SCHEMA.EVENTS_WAITS_SUMMARY_BY_*_BY_EVENT_NAME.
+ Immutable, safe to use without internal lock.
+ */
+ PFS_single_stat *m_instr_class_waits_stats;
+
+ /**
+ Per connection slice stages aggregated statistics.
+ This member holds the data for the table
+ PERFORMANCE_SCHEMA.EVENTS_STAGES_SUMMARY_BY_*_BY_EVENT_NAME.
+ Immutable, safe to use without internal lock.
+ */
+ PFS_stage_stat *m_instr_class_stages_stats;
+
+ /**
+ Per connection slice statements aggregated statistics.
+ This member holds the data for the table
+ PERFORMANCE_SCHEMA.EVENTS_STATEMENTS_SUMMARY_BY_*_BY_EVENT_NAME.
+ Immutable, safe to use without internal lock.
+ */
+ PFS_statement_stat *m_instr_class_statements_stats;
+
+ /**
+ Per connection slice transactions aggregated statistics.
+ This member holds the data for the table
+ PERFORMANCE_SCHEMA.EVENTS_TRANSACTIONS_SUMMARY_BY_*_BY_EVENT_NAME.
+ Immutable, safe to use without internal lock.
+ */
+ PFS_transaction_stat *m_instr_class_transactions_stats;
+
+ /**
+ Per connection slice memory aggregated statistics.
+ This member holds the data for the table
+ PERFORMANCE_SCHEMA.MEMORY_SUMMARY_BY_*_BY_EVENT_NAME.
+ Immutable, safe to use without internal lock.
+ */
+ PFS_memory_stat *m_instr_class_memory_stats;
+
+public:
+
+ void aggregate_status_stats(const STATUS_VAR *status_vars)
+ {
+ m_status_stats.aggregate_from(status_vars);
+ }
+
+ /**
+ Aggregated status variables.
+ */
+ PFS_status_stats m_status_stats;
+
+ /** Container page. */
+ PFS_opaque_container_page *m_page;
+};
+
+/** @} */
+#endif
+
diff --git a/storage/perfschema/pfs_config.h.cmake b/storage/perfschema/pfs_config.h.cmake
new file mode 100644
index 00000000..2b61b7e1
--- /dev/null
+++ b/storage/perfschema/pfs_config.h.cmake
@@ -0,0 +1,6 @@
+#cmakedefine HAVE_PTHREAD_THREADID_NP 1
+#cmakedefine HAVE_SYS_GETTID 1
+#cmakedefine HAVE_GETTID
+#cmakedefine HAVE_GETTHRID 1
+#cmakedefine HAVE_PTHREAD_GETTHREADID_NP 1
+#cmakedefine HAVE_INTEGER_PTHREAD_SELF 1
diff --git a/storage/perfschema/pfs_defaults.cc b/storage/perfschema/pfs_defaults.cc
new file mode 100644
index 00000000..0b615773
--- /dev/null
+++ b/storage/perfschema/pfs_defaults.cc
@@ -0,0 +1,106 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/pfs_defaults.cc
+ Default setup (implementation).
+*/
+
+#include <my_global.h>
+#include "pfs.h"
+#include "pfs_defaults.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "pfs_setup_actor.h"
+#include "pfs_setup_object.h"
+
+static PSI_thread_key thread_key;
+static PSI_thread_info thread_info= { &thread_key, "setup", PSI_FLAG_GLOBAL };
+
+const char* pfs_category= "performance_schema";
+
+void install_default_setup(PSI_bootstrap *boot)
+{
+ PSI *psi= (PSI*) boot->get_interface(PSI_CURRENT_VERSION);
+ if (psi == NULL)
+ return;
+
+ psi->register_thread(pfs_category, &thread_info, 1);
+ PSI_thread *psi_thread= psi->new_thread(thread_key, NULL, 0);
+
+ if (psi_thread != NULL)
+ {
+ /* LF_HASH needs a thread, for PINS */
+ psi->set_thread(psi_thread);
+
+ String percent("%", 1, &my_charset_utf8mb3_bin);
+ /* Enable all users on all hosts by default */
+ insert_setup_actor(&percent, &percent, &percent, true, true);
+
+ String mysql_db("mysql", 5, &my_charset_utf8mb3_bin);
+ String PS_db("performance_schema", 18, &my_charset_utf8mb3_bin);
+ String IS_db("information_schema", 18, &my_charset_utf8mb3_bin);
+
+ /* Disable sp by default in mysql. */
+ insert_setup_object(OBJECT_TYPE_EVENT, &mysql_db, &percent, false, false);
+ /* Disable sp in performance/information schema. */
+ insert_setup_object(OBJECT_TYPE_EVENT, &PS_db, &percent, false, false);
+ insert_setup_object(OBJECT_TYPE_EVENT, &IS_db, &percent, false, false);
+ /* Enable every other sp. */
+ insert_setup_object(OBJECT_TYPE_EVENT, &percent, &percent, true, true);
+
+ /* Disable sp by default in mysql. */
+ insert_setup_object(OBJECT_TYPE_FUNCTION, &mysql_db, &percent, false, false);
+ /* Disable sp in performance/information schema. */
+ insert_setup_object(OBJECT_TYPE_FUNCTION, &PS_db, &percent, false, false);
+ insert_setup_object(OBJECT_TYPE_FUNCTION, &IS_db, &percent, false, false);
+ /* Enable every other sp. */
+ insert_setup_object(OBJECT_TYPE_FUNCTION, &percent, &percent, true, true);
+
+ /* Disable sp by default in mysql. */
+ insert_setup_object(OBJECT_TYPE_PROCEDURE, &mysql_db, &percent, false, false);
+ /* Disable sp in performance/information schema. */
+ insert_setup_object(OBJECT_TYPE_PROCEDURE, &PS_db, &percent, false, false);
+ insert_setup_object(OBJECT_TYPE_PROCEDURE, &IS_db, &percent, false, false);
+ /* Enable every other sp. */
+ insert_setup_object(OBJECT_TYPE_PROCEDURE, &percent, &percent, true, true);
+
+ /* Disable system tables by default */
+ insert_setup_object(OBJECT_TYPE_TABLE, &mysql_db, &percent, false, false);
+ /* Disable performance/information schema tables. */
+ insert_setup_object(OBJECT_TYPE_TABLE, &PS_db, &percent, false, false);
+ insert_setup_object(OBJECT_TYPE_TABLE, &IS_db, &percent, false, false);
+ /* Enable every other tables */
+ insert_setup_object(OBJECT_TYPE_TABLE, &percent, &percent, true, true);
+
+ /* Disable sp by default in mysql. */
+ insert_setup_object(OBJECT_TYPE_TRIGGER, &mysql_db, &percent, false, false);
+ /* Disable sp in performance/information schema. */
+ insert_setup_object(OBJECT_TYPE_TRIGGER, &PS_db, &percent, false, false);
+ insert_setup_object(OBJECT_TYPE_TRIGGER, &IS_db, &percent, false, false);
+ /* Enable every other sp. */
+ insert_setup_object(OBJECT_TYPE_TRIGGER, &percent, &percent, true, true);
+ }
+
+ psi->delete_current_thread();
+}
+
diff --git a/storage/perfschema/pfs_defaults.h b/storage/perfschema/pfs_defaults.h
new file mode 100644
index 00000000..7751b55b
--- /dev/null
+++ b/storage/perfschema/pfs_defaults.h
@@ -0,0 +1,39 @@
+/* Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef PFS_DEFAULTS_H
+#define PFS_DEFAULTS_H
+
+/**
+ @file storage/perfschema/pfs_defaults.h
+ Default setup (declarations).
+*/
+
+/**
+ Configure the performance schema setup tables with default content.
+ The tables populated are:
+ - SETUP_ACTORS
+ - SETUP_OBJECTS
+*/
+void install_default_setup(PSI_bootstrap *boot);
+
+#endif
diff --git a/storage/perfschema/pfs_digest.cc b/storage/perfschema/pfs_digest.cc
new file mode 100644
index 00000000..6f0b93f9
--- /dev/null
+++ b/storage/perfschema/pfs_digest.cc
@@ -0,0 +1,412 @@
+/* Copyright (c) 2008, 2017, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/pfs_digest.h
+ Statement Digest data structures (implementation).
+*/
+
+/*
+ This code needs extra visibility in the lexer structures
+*/
+
+#define MYSQL_LEX 1
+
+#include "my_global.h"
+#include "my_sys.h"
+#include "pfs_instr.h"
+#include "pfs_digest.h"
+#include "pfs_global.h"
+#include "pfs_builtin_memory.h"
+#include "table_helper.h"
+#include "sql_lex.h"
+#include "sql_signal.h"
+#include "sql_get_diagnostics.h"
+#include "sql_string.h"
+#include <string.h>
+
+size_t digest_max= 0;
+ulong digest_lost= 0;
+
+/** EVENTS_STATEMENTS_HISTORY_LONG circular buffer. */
+PFS_statements_digest_stat *statements_digest_stat_array= NULL;
+static unsigned char *statements_digest_token_array= NULL;
+/** Consumer flag for table EVENTS_STATEMENTS_SUMMARY_BY_DIGEST. */
+bool flag_statements_digest= true;
+/**
+ Current index in Stat array where new record is to be inserted.
+ index 0 is reserved for "all else" case when entire array is full.
+*/
+static PFS_ALIGNED PFS_cacheline_uint32 digest_monotonic_index;
+
+bool digest_full= false;
+
+LF_HASH digest_hash;
+static bool digest_hash_inited= false;
+
+/**
+ Initialize table EVENTS_STATEMENTS_SUMMARY_BY_DIGEST.
+ @param param performance schema sizing
+*/
+int init_digest(const PFS_global_param *param)
+{
+ /*
+ Allocate memory for statements_digest_stat_array based on
+ performance_schema_digests_size values
+ */
+ digest_max= param->m_digest_sizing;
+ digest_lost= 0;
+ PFS_atomic::store_u32(& digest_monotonic_index.m_u32, 1);
+ digest_full= false;
+
+ if (digest_max == 0)
+ return 0;
+
+ statements_digest_stat_array=
+ PFS_MALLOC_ARRAY(& builtin_memory_digest,
+ digest_max,
+ sizeof(PFS_statements_digest_stat), PFS_statements_digest_stat,
+ MYF(MY_ZEROFILL));
+
+ if (unlikely(statements_digest_stat_array == NULL))
+ {
+ cleanup_digest();
+ return 1;
+ }
+
+ if (pfs_max_digest_length > 0)
+ {
+ /* Size of each digest array. */
+ size_t digest_memory_size= pfs_max_digest_length * sizeof(unsigned char);
+
+ statements_digest_token_array=
+ PFS_MALLOC_ARRAY(& builtin_memory_digest_tokens,
+ digest_max,
+ digest_memory_size,
+ unsigned char,
+ MYF(MY_ZEROFILL));
+
+ if (unlikely(statements_digest_token_array == NULL))
+ {
+ cleanup_digest();
+ return 1;
+ }
+ }
+
+ for (size_t index= 0; index < digest_max; index++)
+ {
+ statements_digest_stat_array[index].reset_data(statements_digest_token_array
+ + index * pfs_max_digest_length, pfs_max_digest_length);
+ }
+
+ /* Set record[0] as allocated. */
+ statements_digest_stat_array[0].m_lock.set_allocated();
+
+ /* Set record[0] as allocated. */
+ statements_digest_stat_array[0].m_lock.set_allocated();
+
+ return 0;
+}
+
+/** Cleanup table EVENTS_STATEMENTS_SUMMARY_BY_DIGEST. */
+void cleanup_digest(void)
+{
+ PFS_FREE_ARRAY(& builtin_memory_digest,
+ digest_max,
+ sizeof(PFS_statements_digest_stat),
+ statements_digest_stat_array);
+
+ PFS_FREE_ARRAY(& builtin_memory_digest_tokens,
+ digest_max,
+ (pfs_max_digest_length * sizeof(unsigned char)),
+ statements_digest_token_array);
+
+ statements_digest_stat_array= NULL;
+ statements_digest_token_array= NULL;
+}
+
+C_MODE_START
+static uchar *digest_hash_get_key(const uchar *entry, size_t *length,
+ my_bool)
+{
+ const PFS_statements_digest_stat * const *typed_entry;
+ const PFS_statements_digest_stat *digest;
+ const void *result;
+ typed_entry= reinterpret_cast<const PFS_statements_digest_stat*const*>(entry);
+ DBUG_ASSERT(typed_entry != NULL);
+ digest= *typed_entry;
+ DBUG_ASSERT(digest != NULL);
+ *length= sizeof (PFS_digest_key);
+ result= & digest->m_digest_key;
+ return const_cast<uchar*> (reinterpret_cast<const uchar*> (result));
+}
+C_MODE_END
+
+
+/**
+ Initialize the digest hash.
+ @return 0 on success
+*/
+int init_digest_hash(const PFS_global_param *param)
+{
+ if ((! digest_hash_inited) && (param->m_digest_sizing != 0))
+ {
+ lf_hash_init(&digest_hash, sizeof(PFS_statements_digest_stat*),
+ LF_HASH_UNIQUE, 0, 0, digest_hash_get_key,
+ &my_charset_bin);
+ digest_hash_inited= true;
+ }
+ return 0;
+}
+
+void cleanup_digest_hash(void)
+{
+ if (digest_hash_inited)
+ {
+ lf_hash_destroy(&digest_hash);
+ digest_hash_inited= false;
+ }
+}
+
+static LF_PINS* get_digest_hash_pins(PFS_thread *thread)
+{
+ if (unlikely(thread->m_digest_hash_pins == NULL))
+ {
+ if (!digest_hash_inited)
+ return NULL;
+ thread->m_digest_hash_pins= lf_hash_get_pins(&digest_hash);
+ }
+ return thread->m_digest_hash_pins;
+}
+
+PFS_statement_stat*
+find_or_create_digest(PFS_thread *thread,
+ const sql_digest_storage *digest_storage,
+ const char *schema_name,
+ uint schema_name_length)
+{
+ DBUG_ASSERT(digest_storage != NULL);
+
+ if (statements_digest_stat_array == NULL)
+ return NULL;
+
+ if (digest_storage->m_byte_count <= 0)
+ return NULL;
+
+ LF_PINS *pins= get_digest_hash_pins(thread);
+ if (unlikely(pins == NULL))
+ return NULL;
+
+ /*
+ Note: the LF_HASH key is a block of memory,
+ make sure to clean unused bytes,
+ so that memcmp() can compare keys.
+ */
+ PFS_digest_key hash_key;
+ memset(& hash_key, 0, sizeof(hash_key));
+ /* Compute MD5 Hash of the tokens received. */
+ compute_digest_md5(digest_storage, hash_key.m_md5);
+ memcpy((void*)& digest_storage->m_md5, &hash_key.m_md5, MD5_HASH_SIZE);
+ /* Add the current schema to the key */
+ hash_key.m_schema_name_length= schema_name_length;
+ if (schema_name_length > 0)
+ memcpy(hash_key.m_schema_name, schema_name, schema_name_length);
+
+ int res;
+ uint retry_count= 0;
+ const uint retry_max= 3;
+ size_t safe_index;
+ size_t attempts= 0;
+ PFS_statements_digest_stat **entry;
+ PFS_statements_digest_stat *pfs= NULL;
+ pfs_dirty_state dirty_state;
+
+ ulonglong now= my_hrtime().val;
+
+search:
+
+ /* Lookup LF_HASH using this new key. */
+ entry= reinterpret_cast<PFS_statements_digest_stat**>
+ (lf_hash_search(&digest_hash, pins,
+ &hash_key, sizeof(PFS_digest_key)));
+
+ if (entry && (entry != MY_ERRPTR))
+ {
+ /* If digest already exists, update stats and return. */
+ pfs= *entry;
+ pfs->m_last_seen= now;
+ lf_hash_search_unpin(pins);
+ return & pfs->m_stat;
+ }
+
+ lf_hash_search_unpin(pins);
+
+ if (digest_full)
+ {
+ /* digest_stat array is full. Add stat at index 0 and return. */
+ pfs= &statements_digest_stat_array[0];
+ digest_lost++;
+
+ if (pfs->m_first_seen == 0)
+ pfs->m_first_seen= now;
+ pfs->m_last_seen= now;
+ return & pfs->m_stat;
+ }
+
+ while (++attempts <= digest_max)
+ {
+ safe_index= PFS_atomic::add_u32(& digest_monotonic_index.m_u32, 1) % digest_max;
+ if (safe_index == 0)
+ {
+ /* Record [0] is reserved. */
+ continue;
+ }
+
+ /* Add a new record in digest stat array. */
+ DBUG_ASSERT(safe_index < digest_max);
+ pfs= &statements_digest_stat_array[safe_index];
+
+ if (pfs->m_lock.is_free())
+ {
+ if (pfs->m_lock.free_to_dirty(& dirty_state))
+ {
+ /* Copy digest hash/LF Hash search key. */
+ memcpy(& pfs->m_digest_key, &hash_key, sizeof(PFS_digest_key));
+
+ /*
+ Copy digest storage to statement_digest_stat_array so that it could be
+ used later to generate digest text.
+ */
+ pfs->m_digest_storage.copy(digest_storage);
+
+ pfs->m_first_seen= now;
+ pfs->m_last_seen= now;
+
+ res= lf_hash_insert(&digest_hash, pins, &pfs);
+ if (likely(res == 0))
+ {
+ pfs->m_lock.dirty_to_allocated(& dirty_state);
+ return & pfs->m_stat;
+ }
+
+ pfs->m_lock.dirty_to_free(& dirty_state);
+
+ if (res > 0)
+ {
+ /* Duplicate insert by another thread */
+ if (++retry_count > retry_max)
+ {
+ /* Avoid infinite loops */
+ digest_lost++;
+ return NULL;
+ }
+ goto search;
+ }
+
+ /* OOM in lf_hash_insert */
+ digest_lost++;
+ return NULL;
+ }
+ }
+ }
+
+ /* The digest array is now full. */
+ digest_full= true;
+ pfs= &statements_digest_stat_array[0];
+
+ if (pfs->m_first_seen == 0)
+ pfs->m_first_seen= now;
+ pfs->m_last_seen= now;
+ return & pfs->m_stat;
+}
+
+void purge_digest(PFS_thread* thread, PFS_digest_key *hash_key)
+{
+ LF_PINS *pins= get_digest_hash_pins(thread);
+ if (unlikely(pins == NULL))
+ return;
+
+ PFS_statements_digest_stat **entry;
+
+ /* Lookup LF_HASH using this new key. */
+ entry= reinterpret_cast<PFS_statements_digest_stat**>
+ (lf_hash_search(&digest_hash, pins,
+ hash_key, sizeof(PFS_digest_key)));
+
+ if (entry && (entry != MY_ERRPTR))
+ {
+ lf_hash_delete(&digest_hash, pins,
+ hash_key, sizeof(PFS_digest_key));
+ }
+ lf_hash_search_unpin(pins);
+ return;
+}
+
+void PFS_statements_digest_stat::reset_data(unsigned char *token_array, size_t length)
+{
+ pfs_dirty_state dirty_state;
+ m_lock.set_dirty(& dirty_state);
+ m_digest_storage.reset(token_array, length);
+ m_stat.reset();
+ m_first_seen= 0;
+ m_last_seen= 0;
+ m_lock.dirty_to_free(& dirty_state);
+}
+
+void PFS_statements_digest_stat::reset_index(PFS_thread *thread)
+{
+ /* Only remove entries that exists in the HASH index. */
+ if (m_digest_storage.m_byte_count > 0)
+ {
+ purge_digest(thread, & m_digest_key);
+ }
+}
+
+void reset_esms_by_digest()
+{
+ uint index;
+
+ if (statements_digest_stat_array == NULL)
+ return;
+
+ PFS_thread *thread= PFS_thread::get_current_thread();
+ if (unlikely(thread == NULL))
+ return;
+
+ /* Reset statements_digest_stat_array. */
+ for (index= 0; index < digest_max; index++)
+ {
+ statements_digest_stat_array[index].reset_index(thread);
+ statements_digest_stat_array[index].reset_data(statements_digest_token_array + index * pfs_max_digest_length, pfs_max_digest_length);
+ }
+
+ /* Mark record[0] as allocated again. */
+ statements_digest_stat_array[0].m_lock.set_allocated();
+
+ /*
+ Reset index which indicates where the next calculated digest information
+ to be inserted in statements_digest_stat_array.
+ */
+ PFS_atomic::store_u32(& digest_monotonic_index.m_u32, 1);
+ digest_full= false;
+}
+
diff --git a/storage/perfschema/pfs_digest.h b/storage/perfschema/pfs_digest.h
new file mode 100644
index 00000000..39fe6109
--- /dev/null
+++ b/storage/perfschema/pfs_digest.h
@@ -0,0 +1,94 @@
+/* Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef PFS_DIGEST_H
+#define PFS_DIGEST_H
+
+/**
+ @file storage/perfschema/pfs_digest.h
+ Statement Digest data structures (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "lf.h"
+#include "pfs_stat.h"
+#include "sql_digest.h"
+
+extern bool flag_statements_digest;
+extern size_t digest_max;
+extern ulong digest_lost;
+struct PFS_thread;
+
+/**
+ Structure to store a MD5 hash value (digest) for a statement.
+*/
+struct PFS_digest_key
+{
+ unsigned char m_md5[MD5_HASH_SIZE];
+ char m_schema_name[NAME_LEN];
+ uint m_schema_name_length;
+};
+
+/** A statement digest stat record. */
+struct PFS_ALIGNED PFS_statements_digest_stat
+{
+ /** Internal lock. */
+ pfs_lock m_lock;
+
+ /** Digest Schema + MD5 Hash. */
+ PFS_digest_key m_digest_key;
+
+ /** Digest Storage. */
+ sql_digest_storage m_digest_storage;
+
+ /** Statement stat. */
+ PFS_statement_stat m_stat;
+
+ /** First and last seen timestamps.*/
+ ulonglong m_first_seen;
+ ulonglong m_last_seen;
+
+ /** Reset data for this record. */
+ void reset_data(unsigned char* token_array, size_t length);
+ /** Reset data and remove index for this record. */
+ void reset_index(PFS_thread *thread);
+};
+
+int init_digest(const PFS_global_param *param);
+void cleanup_digest();
+
+int init_digest_hash(const PFS_global_param *param);
+void cleanup_digest_hash(void);
+PFS_statement_stat* find_or_create_digest(PFS_thread *thread,
+ const sql_digest_storage *digest_storage,
+ const char *schema_name,
+ uint schema_name_length);
+
+void reset_esms_by_digest();
+
+/* Exposing the data directly, for iterators. */
+extern PFS_statements_digest_stat *statements_digest_stat_array;
+
+extern LF_HASH digest_hash;
+
+#endif
+
diff --git a/storage/perfschema/pfs_engine_table.cc b/storage/perfschema/pfs_engine_table.cc
new file mode 100644
index 00000000..22ed3132
--- /dev/null
+++ b/storage/perfschema/pfs_engine_table.cc
@@ -0,0 +1,1931 @@
+/* Copyright (c) 2008, 2019, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/pfs_engine_table.cc
+ Performance schema tables (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "hostname.h" /* For Host_entry */
+#include "pfs_engine_table.h"
+#include "pfs_buffer_container.h"
+
+#include "table_events_waits.h"
+#include "table_setup_actors.h"
+#include "table_setup_consumers.h"
+#include "table_setup_instruments.h"
+#include "table_setup_objects.h"
+#include "table_setup_timers.h"
+#include "table_performance_timers.h"
+#include "table_events_waits_summary.h"
+#include "table_ews_by_thread_by_event_name.h"
+#include "table_ews_global_by_event_name.h"
+#include "table_host_cache.h"
+#include "table_os_global_by_type.h"
+#include "table_sync_instances.h"
+#include "table_file_instances.h"
+#include "table_file_summary_by_instance.h"
+#include "table_file_summary_by_event_name.h"
+#include "table_threads.h"
+
+#include "table_ews_by_host_by_event_name.h"
+#include "table_ews_by_user_by_event_name.h"
+#include "table_ews_by_account_by_event_name.h"
+#include "table_tiws_by_index_usage.h"
+#include "table_tiws_by_table.h"
+#include "table_tlws_by_table.h"
+
+#include "table_events_stages.h"
+#include "table_esgs_by_thread_by_event_name.h"
+#include "table_esgs_by_host_by_event_name.h"
+#include "table_esgs_by_user_by_event_name.h"
+#include "table_esgs_by_account_by_event_name.h"
+#include "table_esgs_global_by_event_name.h"
+
+#include "table_events_statements.h"
+#include "table_esms_by_thread_by_event_name.h"
+#include "table_esms_by_host_by_event_name.h"
+#include "table_esms_by_user_by_event_name.h"
+#include "table_esms_by_account_by_event_name.h"
+#include "table_esms_global_by_event_name.h"
+#include "table_esms_by_digest.h"
+#include "table_esms_by_program.h"
+
+#include "table_events_transactions.h"
+#include "table_ets_by_thread_by_event_name.h"
+#include "table_ets_by_host_by_event_name.h"
+#include "table_ets_by_user_by_event_name.h"
+#include "table_ets_by_account_by_event_name.h"
+#include "table_ets_global_by_event_name.h"
+
+#include "table_users.h"
+#include "table_accounts.h"
+#include "table_hosts.h"
+
+#include "table_socket_instances.h"
+#include "table_socket_summary_by_instance.h"
+#include "table_socket_summary_by_event_name.h"
+#include "table_session_connect_attrs.h"
+#include "table_session_account_connect_attrs.h"
+#include "table_mems_global_by_event_name.h"
+#include "table_mems_by_account_by_event_name.h"
+#include "table_mems_by_host_by_event_name.h"
+#include "table_mems_by_thread_by_event_name.h"
+#include "table_mems_by_user_by_event_name.h"
+
+/* For replication related perfschema tables. */
+#include "table_replication_connection_configuration.h"
+#include "table_replication_group_members.h"
+#include "table_replication_connection_status.h"
+#include "table_replication_applier_configuration.h"
+#include "table_replication_applier_status.h"
+#include "table_replication_applier_status_by_coordinator.h"
+#include "table_replication_applier_status_by_worker.h"
+#include "table_replication_group_member_stats.h"
+
+#include "table_prepared_stmt_instances.h"
+
+#include "table_md_locks.h"
+#include "table_table_handles.h"
+
+#include "table_uvar_by_thread.h"
+
+#include "table_status_by_account.h"
+#include "table_status_by_host.h"
+#include "table_status_by_thread.h"
+#include "table_status_by_user.h"
+#include "table_global_status.h"
+#include "table_session_status.h"
+
+#include "table_variables_by_thread.h"
+#include "table_global_variables.h"
+#include "table_session_variables.h"
+
+/* For show status */
+#include "pfs_column_values.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "pfs_setup_actor.h"
+#include "pfs_setup_object.h"
+#include "pfs_global.h"
+#include "pfs_digest.h"
+
+#include "sql_base.h" // close_thread_tables
+#include "lock.h" // MYSQL_LOCK_IGNORE_TIMEOUT
+#include "log.h"
+
+/**
+ @addtogroup Performance_schema_engine
+ @{
+*/
+
+bool PFS_table_context::initialize(void)
+{
+ if (m_restore)
+ {
+ /* Restore context from TLS. */
+ PFS_table_context *context= static_cast<PFS_table_context *>(my_get_thread_local(m_thr_key));
+ DBUG_ASSERT(context != NULL);
+
+ if(context)
+ {
+ m_last_version= context->m_current_version;
+ m_map= context->m_map;
+ DBUG_ASSERT(m_map_size == context->m_map_size);
+ m_map_size= context->m_map_size;
+ }
+ }
+ else
+ {
+ /* Check that TLS is not in use. */
+ PFS_table_context *context= static_cast<PFS_table_context *>(my_get_thread_local(m_thr_key));
+ //DBUG_ASSERT(context == NULL);
+
+ context= this;
+
+ /* Initialize a new context, store in TLS. */
+ m_last_version= m_current_version;
+ m_map= NULL;
+
+ /* Allocate a bitmap to record which threads are materialized. */
+ if (m_map_size > 0)
+ {
+ THD *thd= current_thd;
+ ulong words= m_map_size / m_word_size + (m_map_size % m_word_size > 0);
+ m_map= (ulong *)thd->calloc(words * m_word_size);
+ }
+
+ /* Write to TLS. */
+ my_set_thread_local(m_thr_key, static_cast<void *>(context));
+ }
+
+ m_initialized= (m_map_size > 0) ? (m_map != NULL) : true;
+
+ return m_initialized;
+}
+
+/* Constructor for global or single thread tables, map size = 0. */
+PFS_table_context::PFS_table_context(ulonglong current_version, bool restore, thread_local_key_t key) :
+ m_thr_key(key), m_current_version(current_version), m_last_version(0),
+ m_map(NULL), m_map_size(0),
+ m_restore(restore), m_initialized(false), m_last_item(0)
+{
+ initialize();
+}
+
+/* Constructor for by-thread or aggregate tables, map size = max thread/user/host/account. */
+PFS_table_context::PFS_table_context(ulonglong current_version, ulong map_size, bool restore, thread_local_key_t key) :
+ m_thr_key(key), m_current_version(current_version), m_last_version(0),
+ m_map(NULL), m_map_size(map_size),
+ m_restore(restore), m_initialized(false), m_last_item(0)
+{
+ initialize();
+}
+
+PFS_table_context::~PFS_table_context(void)
+{
+ /* Clear TLS after final use. */ // TODO: How is that determined?
+// if (m_restore)
+// {
+// my_set_thread_local(m_thr_key, NULL);
+// }
+}
+
+void PFS_table_context::set_item(ulong n)
+{
+ if (n == m_last_item)
+ return;
+ ulong word= n / m_word_size;
+ ulong bit= n % m_word_size;
+ m_map[word] |= (1UL << bit);
+ m_last_item= n;
+}
+
+bool PFS_table_context::is_item_set(ulong n)
+{
+ ulong word= n / m_word_size;
+ ulong bit= n % m_word_size;
+ return (m_map[word] & (1 << bit));
+}
+
+
+static PFS_engine_table_share *all_shares[]=
+{
+ &table_cond_instances::m_share,
+ &table_events_waits_current::m_share,
+ &table_events_waits_history::m_share,
+ &table_events_waits_history_long::m_share,
+ &table_ews_by_host_by_event_name::m_share,
+ &table_events_waits_summary_by_instance::m_share,
+ &table_ews_by_thread_by_event_name::m_share,
+ &table_ews_by_user_by_event_name::m_share,
+ &table_ews_by_account_by_event_name::m_share,
+ &table_ews_global_by_event_name::m_share,
+ &table_file_instances::m_share,
+ &table_file_summary_by_event_name::m_share,
+ &table_file_summary_by_instance::m_share,
+ &table_host_cache::m_share,
+ &table_mutex_instances::m_share,
+ &table_os_global_by_type::m_share,
+ &table_performance_timers::m_share,
+ &table_rwlock_instances::m_share,
+ &table_setup_actors::m_share,
+ &table_setup_consumers::m_share,
+ &table_setup_instruments::m_share,
+ &table_setup_objects::m_share,
+ &table_setup_timers::m_share,
+ &table_tiws_by_index_usage::m_share,
+ &table_tiws_by_table::m_share,
+ &table_tlws_by_table::m_share,
+ &table_threads::m_share,
+
+ &table_events_stages_current::m_share,
+ &table_events_stages_history::m_share,
+ &table_events_stages_history_long::m_share,
+ &table_esgs_by_thread_by_event_name::m_share,
+ &table_esgs_by_account_by_event_name::m_share,
+ &table_esgs_by_user_by_event_name::m_share,
+ &table_esgs_by_host_by_event_name::m_share,
+ &table_esgs_global_by_event_name::m_share,
+
+ &table_events_statements_current::m_share,
+ &table_events_statements_history::m_share,
+ &table_events_statements_history_long::m_share,
+ &table_esms_by_thread_by_event_name::m_share,
+ &table_esms_by_account_by_event_name::m_share,
+ &table_esms_by_user_by_event_name::m_share,
+ &table_esms_by_host_by_event_name::m_share,
+ &table_esms_global_by_event_name::m_share,
+ &table_esms_by_digest::m_share,
+ &table_esms_by_program::m_share,
+
+ &table_events_transactions_current::m_share,
+ &table_events_transactions_history::m_share,
+ &table_events_transactions_history_long::m_share,
+ &table_ets_by_thread_by_event_name::m_share,
+ &table_ets_by_account_by_event_name::m_share,
+ &table_ets_by_user_by_event_name::m_share,
+ &table_ets_by_host_by_event_name::m_share,
+ &table_ets_global_by_event_name::m_share,
+
+ &table_users::m_share,
+ &table_accounts::m_share,
+ &table_hosts::m_share,
+
+ &table_socket_instances::m_share,
+ &table_socket_summary_by_instance::m_share,
+ &table_socket_summary_by_event_name::m_share,
+
+ &table_session_connect_attrs::m_share,
+ &table_session_account_connect_attrs::m_share,
+
+ &table_mems_global_by_event_name::m_share,
+ &table_mems_by_account_by_event_name::m_share,
+ &table_mems_by_host_by_event_name::m_share,
+ &table_mems_by_thread_by_event_name::m_share,
+ &table_mems_by_user_by_event_name::m_share,
+ &table_table_handles::m_share,
+ &table_metadata_locks::m_share,
+
+#ifdef HAVE_REPLICATION
+ &table_replication_connection_configuration::m_share,
+ //&table_replication_group_members::m_share,
+ //&table_replication_connection_status::m_share,
+ &table_replication_applier_configuration::m_share,
+ &table_replication_applier_status::m_share,
+ &table_replication_applier_status_by_coordinator::m_share,
+ //&table_replication_applier_status_by_worker::m_share,
+ //&table_replication_group_member_stats::m_share,
+#endif
+
+ &table_prepared_stmt_instances::m_share,
+
+ &table_uvar_by_thread::m_share,
+ &table_status_by_account::m_share,
+ &table_status_by_host::m_share,
+ &table_status_by_thread::m_share,
+ &table_status_by_user::m_share,
+ &table_global_status::m_share,
+ &table_session_status::m_share,
+
+ //&table_variables_by_thread::m_share,
+ //&table_global_variables::m_share,
+ //&table_session_variables::m_share,
+
+ NULL
+};
+
+/** Initialize all the table share locks. */
+void PFS_engine_table_share::init_all_locks(void)
+{
+ PFS_engine_table_share **current;
+
+ for (current= &all_shares[0]; (*current) != NULL; current++)
+ thr_lock_init((*current)->m_thr_lock_ptr);
+}
+
+/** Delete all the table share locks. */
+void PFS_engine_table_share::delete_all_locks(void)
+{
+ PFS_engine_table_share **current;
+
+ for (current= &all_shares[0]; (*current) != NULL; current++)
+ thr_lock_delete((*current)->m_thr_lock_ptr);
+}
+
+ha_rows PFS_engine_table_share::get_row_count(void) const
+{
+ return m_get_row_count();
+}
+
+int PFS_engine_table_share::write_row(TABLE *table, const unsigned char *buf,
+ Field **fields) const
+{
+ if (m_write_row == NULL)
+ {
+ return HA_ERR_WRONG_COMMAND;
+ }
+
+ /* We internally read from Fields to support the write interface */
+ MY_BITMAP *org_bitmap= dbug_tmp_use_all_columns(table, &table->read_set);
+ int result= m_write_row(table, buf, fields);
+ dbug_tmp_restore_column_map(&table->read_set, org_bitmap);
+
+ return result;
+}
+
+static int compare_table_names(const char *name1, const char *name2)
+{
+ /*
+ The performance schema is implemented as a storage engine, in memory.
+ The current storage engine interface exposed by the server,
+ and in particular handlerton::discover, uses 'FRM' files to describe a
+ table structure, which are later stored on disk, by the server,
+ in ha_create_table_from_engine().
+ Because the table metadata is stored on disk, the table naming rules
+ used by the performance schema then have to comply with the constraints
+ imposed by the disk storage, and in particular with lower_case_table_names.
+ Once the server is changed to be able to discover a table in a storage engine
+ and then open the table without storing a FRM file on disk, this constraint
+ on the performance schema will be lifted, and the naming logic can be relaxed
+ to be simply my_strcasecmp(system_charset_info, name1, name2).
+ */
+ if (lower_case_table_names)
+ return strcasecmp(name1, name2);
+ return strcmp(name1, name2);
+}
+
+/**
+ Find a table share by name.
+ @param name The table name
+ @return table share
+*/
+const PFS_engine_table_share*
+PFS_engine_table::find_engine_table_share(const char *name)
+{
+ DBUG_ENTER("PFS_engine_table::find_table_share");
+
+ PFS_engine_table_share **current;
+
+ for (current= &all_shares[0]; (*current) != NULL; current++)
+ {
+ if (compare_table_names(name, (*current)->m_name.str) == 0)
+ DBUG_RETURN(*current);
+ }
+
+ DBUG_RETURN(NULL);
+}
+
+/**
+ Read a table row.
+ @param table Table handle
+ @param buf Row buffer
+ @param fields Table fields
+ @return 0 on success
+*/
+int PFS_engine_table::read_row(TABLE *table,
+ unsigned char *buf,
+ Field **fields)
+{
+ Field *f;
+ Field **fields_reset;
+
+ /* We must read all columns in case a table is opened for update */
+ bool read_all= !bitmap_is_clear_all(table->write_set);
+
+ /* We internally write to Fields to support the read interface */
+ MY_BITMAP *org_bitmap= dbug_tmp_use_all_columns(table, &table->write_set);
+
+ /*
+ Some callers of the storage engine interface do not honor the
+ f->is_null() flag, and will attempt to read the data itself.
+ A known offender is mysql_checksum_table().
+ For robustness, reset every field.
+ */
+ for (fields_reset= fields; (f= *fields_reset) ; fields_reset++)
+ f->reset();
+
+ int result= read_row_values(table, buf, fields, read_all);
+ dbug_tmp_restore_column_map(&table->write_set, org_bitmap);
+
+ return result;
+}
+
+/**
+ Update a table row.
+ @param table Table handle
+ @param old_buf old row buffer
+ @param new_buf new row buffer
+ @param fields Table fields
+ @return 0 on success
+*/
+int PFS_engine_table::update_row(TABLE *table,
+ const unsigned char *old_buf,
+ const unsigned char *new_buf,
+ Field **fields)
+{
+ /* We internally read from Fields to support the write interface */
+ MY_BITMAP *org_bitmap= dbug_tmp_use_all_columns(table, &table->read_set);
+ int result= update_row_values(table, old_buf, new_buf, fields);
+ dbug_tmp_restore_column_map(&table->read_set, org_bitmap);
+
+ return result;
+}
+
+int PFS_engine_table::delete_row(TABLE *table,
+ const unsigned char *buf,
+ Field **fields)
+{
+ /* We internally read from Fields to support the delete interface */
+ MY_BITMAP *org_bitmap= dbug_tmp_use_all_columns(table, &table->read_set);
+ int result= delete_row_values(table, buf, fields);
+ dbug_tmp_restore_column_map(&table->read_set, org_bitmap);
+
+ return result;
+}
+
+int PFS_engine_table::delete_row_values(TABLE *,
+ const unsigned char *,
+ Field **)
+{
+ return HA_ERR_WRONG_COMMAND;
+}
+
+/**
+ Get the position of the current row.
+ @param [out] ref position
+*/
+void PFS_engine_table::get_position(void *ref)
+{
+ memcpy(ref, m_pos_ptr, m_share_ptr->m_ref_length);
+}
+
+/**
+ Set the table cursor at a given position.
+ @param [in] ref position
+*/
+void PFS_engine_table::set_position(const void *ref)
+{
+ memcpy(m_pos_ptr, ref, m_share_ptr->m_ref_length);
+}
+
+/**
+ Get the timer normalizer and class type for the current row.
+ @param [in] instr_class class
+*/
+void PFS_engine_table::get_normalizer(PFS_instr_class *instr_class)
+{
+ if (instr_class->m_type != m_class_type)
+ {
+ m_normalizer= time_normalizer::get(*instr_class->m_timer);
+ m_class_type= instr_class->m_type;
+ }
+}
+
+void PFS_engine_table::set_field_long(Field *f, long value)
+{
+ DBUG_ASSERT(f->real_type() == MYSQL_TYPE_LONG);
+ Field_long *f2= (Field_long*) f;
+ f2->store(value, false);
+}
+
+void PFS_engine_table::set_field_ulong(Field *f, ulong value)
+{
+ DBUG_ASSERT(f->real_type() == MYSQL_TYPE_LONG);
+ Field_long *f2= (Field_long*) f;
+ f2->store(value, true);
+}
+
+void PFS_engine_table::set_field_longlong(Field *f, longlong value)
+{
+ DBUG_ASSERT(f->real_type() == MYSQL_TYPE_LONGLONG);
+ Field_longlong *f2= (Field_longlong*) f;
+ f2->store(value, false);
+}
+
+void PFS_engine_table::set_field_ulonglong(Field *f, ulonglong value)
+{
+ DBUG_ASSERT(f->real_type() == MYSQL_TYPE_LONGLONG);
+ Field_longlong *f2= (Field_longlong*) f;
+ f2->store(value, true);
+}
+
+void PFS_engine_table::set_field_char_utf8(Field *f, const char* str,
+ uint len)
+{
+ DBUG_ASSERT(f->real_type() == MYSQL_TYPE_STRING);
+ Field_string *f2= (Field_string*) f;
+ f2->store(str, len, &my_charset_utf8mb3_bin);
+}
+
+void PFS_engine_table::set_field_varchar(Field *f,
+ const CHARSET_INFO *cs,
+ const char* str,
+ uint len)
+{
+ DBUG_ASSERT(f->real_type() == MYSQL_TYPE_VARCHAR);
+ Field_varstring *f2= (Field_varstring*) f;
+ f2->store(str, len, cs);
+}
+
+void PFS_engine_table::set_field_varchar_utf8(Field *f, const char* str,
+ uint len)
+{
+ DBUG_ASSERT(f->real_type() == MYSQL_TYPE_VARCHAR);
+ Field_varstring *f2= (Field_varstring*) f;
+ f2->store(str, len, &my_charset_utf8mb3_bin);
+}
+
+void PFS_engine_table::set_field_longtext_utf8(Field *f, const char* str,
+ uint len)
+{
+ DBUG_ASSERT(f->real_type() == MYSQL_TYPE_BLOB);
+ Field_blob *f2= (Field_blob*) f;
+ f2->store(str, len, &my_charset_utf8mb3_bin);
+}
+
+void PFS_engine_table::set_field_blob(Field *f, const char* val,
+ uint len)
+{
+ DBUG_ASSERT(f->real_type() == MYSQL_TYPE_BLOB);
+ Field_blob *f2= (Field_blob*) f;
+ f2->store(val, len, &my_charset_utf8mb3_bin);
+}
+
+void PFS_engine_table::set_field_enum(Field *f, ulonglong value)
+{
+ DBUG_ASSERT(f->real_type() == MYSQL_TYPE_ENUM);
+ Field_enum *f2= (Field_enum*) f;
+ f2->store_type(value);
+}
+
+void PFS_engine_table::set_field_timestamp(Field *f, ulonglong value)
+{
+ DBUG_ASSERT(f->type_handler()->is_timestamp_type());
+ Field_timestamp *f2= (Field_timestamp*) f;
+ f2->store_TIME((long)(value / 1000000), (value % 1000000));
+}
+
+void PFS_engine_table::set_field_double(Field *f, double value)
+{
+ DBUG_ASSERT(f->real_type() == MYSQL_TYPE_DOUBLE);
+ Field_double *f2= (Field_double*) f;
+ f2->store(value);
+}
+
+ulonglong PFS_engine_table::get_field_enum(Field *f)
+{
+ DBUG_ASSERT(f->real_type() == MYSQL_TYPE_ENUM);
+ Field_enum *f2= (Field_enum*) f;
+ return f2->val_int();
+}
+
+String*
+PFS_engine_table::get_field_char_utf8(Field *f, String *val)
+{
+ DBUG_ASSERT(f->real_type() == MYSQL_TYPE_STRING);
+ Field_string *f2= (Field_string*) f;
+ val= f2->val_str(NULL, val);
+ return val;
+}
+
+String*
+PFS_engine_table::get_field_varchar_utf8(Field *f, String *val)
+{
+ DBUG_ASSERT(f->real_type() == MYSQL_TYPE_VARCHAR);
+ Field_varstring *f2= (Field_varstring*) f;
+ val= f2->val_str(NULL, val);
+ return val;
+}
+
+int PFS_engine_table::update_row_values(TABLE *,
+ const unsigned char *,
+ const unsigned char *,
+ Field **)
+{
+ return HA_ERR_WRONG_COMMAND;
+}
+
+/** Implementation of internal ACL checks, for the performance schema. */
+class PFS_internal_schema_access : public ACL_internal_schema_access
+{
+public:
+ PFS_internal_schema_access()
+ {}
+
+ ~PFS_internal_schema_access()
+ {}
+
+ ACL_internal_access_result check(privilege_t want_access,
+ privilege_t *save_priv) const;
+
+ const ACL_internal_table_access *lookup(const char *name) const;
+};
+
+ACL_internal_access_result
+PFS_internal_schema_access::check(privilege_t want_access,
+ privilege_t *save_priv) const
+{
+ const privilege_t always_forbidden= /* CREATE_ACL | */ REFERENCES_ACL
+ | INDEX_ACL | ALTER_ACL | CREATE_TMP_ACL | EXECUTE_ACL
+ | CREATE_VIEW_ACL | SHOW_VIEW_ACL | CREATE_PROC_ACL | ALTER_PROC_ACL
+ | EVENT_ACL | TRIGGER_ACL ;
+
+ if (unlikely((want_access & always_forbidden) != NO_ACL))
+ return ACL_INTERNAL_ACCESS_DENIED;
+
+ /*
+ Proceed with regular grant tables,
+ to give administrative control to the DBA.
+ */
+ return ACL_INTERNAL_ACCESS_CHECK_GRANT;
+}
+
+const ACL_internal_table_access *
+PFS_internal_schema_access::lookup(const char *name) const
+{
+ const PFS_engine_table_share* share;
+ share= PFS_engine_table::find_engine_table_share(name);
+ if (share)
+ return share->m_acl;
+ /*
+ Do not return NULL, it would mean we are not interested
+ in privilege checks for unknown tables.
+ Instead, return an object that denies every actions,
+ to prevent users for creating their own tables in the
+ performance_schema database schema.
+ */
+ return &pfs_unknown_acl;
+}
+
+PFS_internal_schema_access pfs_internal_access;
+
+void initialize_performance_schema_acl(bool bootstrap)
+{
+ /*
+ ACL is always enforced, even if the performance schema
+ is not enabled (the tables are still visible).
+ */
+ if (! bootstrap)
+ {
+ ACL_internal_schema_registry::register_schema(&PERFORMANCE_SCHEMA_str,
+ &pfs_internal_access);
+ }
+}
+
+static bool allow_drop_table_privilege() {
+ /*
+ The same DROP_ACL privilege is used for different statements,
+ in particular:
+ - TRUNCATE TABLE
+ - DROP TABLE
+ - ALTER TABLE
+ Here, we want to prevent DROP / ALTER while allowing TRUNCATE.
+ Note that we must also allow GRANT to transfer the truncate privilege.
+ */
+ THD *thd= current_thd;
+ if (thd == NULL) {
+ return false;
+ }
+
+ DBUG_ASSERT(thd->lex != NULL);
+ if ((thd->lex->sql_command != SQLCOM_TRUNCATE) &&
+ (thd->lex->sql_command != SQLCOM_GRANT)) {
+ return false;
+ }
+
+ return true;
+}
+
+
+PFS_readonly_acl pfs_readonly_acl;
+
+ACL_internal_access_result
+PFS_readonly_acl::check(privilege_t want_access, privilege_t *save_priv) const
+{
+ const privilege_t always_forbidden= INSERT_ACL | UPDATE_ACL | DELETE_ACL
+ | /* CREATE_ACL | */ REFERENCES_ACL | INDEX_ACL | ALTER_ACL
+ | CREATE_VIEW_ACL | SHOW_VIEW_ACL | TRIGGER_ACL | LOCK_TABLES_ACL;
+
+ if (unlikely((want_access & always_forbidden) != NO_ACL))
+ return ACL_INTERNAL_ACCESS_DENIED;
+
+ return ACL_INTERNAL_ACCESS_CHECK_GRANT;
+}
+
+
+PFS_readonly_world_acl pfs_readonly_world_acl;
+
+ACL_internal_access_result
+PFS_readonly_world_acl::check(privilege_t want_access, privilege_t *save_priv) const
+{
+ ACL_internal_access_result res= PFS_readonly_acl::check(want_access, save_priv);
+ if (res == ACL_INTERNAL_ACCESS_CHECK_GRANT)
+ {
+ if (want_access == SELECT_ACL)
+ res= ACL_INTERNAL_ACCESS_GRANTED;
+ }
+ return res;
+}
+
+
+PFS_truncatable_acl pfs_truncatable_acl;
+
+ACL_internal_access_result
+PFS_truncatable_acl::check(privilege_t want_access, privilege_t *save_priv) const
+{
+ const privilege_t always_forbidden= INSERT_ACL | UPDATE_ACL | DELETE_ACL
+ | /* CREATE_ACL | */ REFERENCES_ACL | INDEX_ACL | ALTER_ACL
+ | CREATE_VIEW_ACL | SHOW_VIEW_ACL | TRIGGER_ACL | LOCK_TABLES_ACL;
+
+ if (unlikely((want_access & always_forbidden) != NO_ACL))
+ return ACL_INTERNAL_ACCESS_DENIED;
+
+ return ACL_INTERNAL_ACCESS_CHECK_GRANT;
+}
+
+
+PFS_truncatable_world_acl pfs_truncatable_world_acl;
+
+ACL_internal_access_result
+PFS_truncatable_world_acl::check(privilege_t want_access, privilege_t *save_priv) const
+{
+ ACL_internal_access_result res= PFS_truncatable_acl::check(want_access, save_priv);
+ if (res == ACL_INTERNAL_ACCESS_CHECK_GRANT)
+ {
+ if (want_access == DROP_ACL)
+ {
+ if (allow_drop_table_privilege())
+ res= ACL_INTERNAL_ACCESS_GRANTED;
+ }
+ else if (want_access == SELECT_ACL)
+ res= ACL_INTERNAL_ACCESS_GRANTED;
+ }
+ return res;
+}
+
+
+PFS_updatable_acl pfs_updatable_acl;
+
+ACL_internal_access_result
+PFS_updatable_acl::check(privilege_t want_access, privilege_t *save_priv) const
+{
+ const privilege_t always_forbidden= INSERT_ACL | DELETE_ACL
+ | /* CREATE_ACL | */ REFERENCES_ACL | INDEX_ACL | ALTER_ACL
+ | CREATE_VIEW_ACL | SHOW_VIEW_ACL | TRIGGER_ACL;
+
+ if (unlikely((want_access & always_forbidden) != NO_ACL))
+ return ACL_INTERNAL_ACCESS_DENIED;
+
+ return ACL_INTERNAL_ACCESS_CHECK_GRANT;
+}
+
+PFS_editable_acl pfs_editable_acl;
+
+ACL_internal_access_result
+PFS_editable_acl::check(privilege_t want_access, privilege_t *save_priv) const
+{
+ const privilege_t always_forbidden= /* CREATE_ACL | */ REFERENCES_ACL
+ | INDEX_ACL | ALTER_ACL | CREATE_VIEW_ACL | SHOW_VIEW_ACL | TRIGGER_ACL;
+
+ if (unlikely((want_access & always_forbidden) != NO_ACL))
+ return ACL_INTERNAL_ACCESS_DENIED;
+
+ return ACL_INTERNAL_ACCESS_CHECK_GRANT;
+}
+
+PFS_unknown_acl pfs_unknown_acl;
+
+ACL_internal_access_result
+PFS_unknown_acl::check(privilege_t want_access, privilege_t *save_priv) const
+{
+ const privilege_t always_forbidden= CREATE_ACL
+ | REFERENCES_ACL | INDEX_ACL | ALTER_ACL
+ | CREATE_VIEW_ACL | TRIGGER_ACL;
+
+ if (unlikely((want_access & always_forbidden) != NO_ACL))
+ return ACL_INTERNAL_ACCESS_DENIED;
+
+ /*
+ There is no point in hiding (by enforcing ACCESS_DENIED for SELECT_ACL
+ on performance_schema.*) tables that do not exist anyway.
+ When SELECT_ACL is granted on performance_schema.* or *.*,
+ SELECT * from performance_schema.wrong_table
+ will fail with a more understandable ER_NO_SUCH_TABLE error,
+ instead of ER_TABLEACCESS_DENIED_ERROR.
+ The same goes for other DML (INSERT_ACL | UPDATE_ACL | DELETE_ACL),
+ for ease of use: error messages will be less surprising.
+ */
+ return ACL_INTERNAL_ACCESS_CHECK_GRANT;
+}
+
+/**
+ SHOW ENGINE PERFORMANCE_SCHEMA STATUS.
+ @param hton Storage engine handler
+ @param thd Current thread
+ @param print Print function
+ @param stat status to show
+*/
+bool pfs_show_status(handlerton *hton, THD *thd,
+ stat_print_fn *print, enum ha_stat_type stat)
+{
+ char buf[1024];
+ uint buflen;
+ const char *name;
+ int i;
+ size_t size;
+
+ DBUG_ENTER("pfs_show_status");
+
+ /*
+ Note about naming conventions:
+ - Internal buffers exposed as a table in the performance schema are named
+ after the table, as in 'events_waits_current'
+ - Internal buffers not exposed by a table are named with parenthesis,
+ as in '(pfs_mutex_class)'.
+ */
+ if (stat != HA_ENGINE_STATUS)
+ DBUG_RETURN(false);
+
+ size_t total_memory= 0;
+
+ for (i=0; /* empty */; i++)
+ {
+ switch (i){
+ case 0:
+ name= "events_waits_current.size";
+ size= sizeof(PFS_events_waits);
+ break;
+ case 1:
+ name= "events_waits_current.count";
+ size= WAIT_STACK_SIZE * global_thread_container.get_row_count();
+ break;
+ case 2:
+ name= "events_waits_history.size";
+ size= sizeof(PFS_events_waits);
+ break;
+ case 3:
+ name= "events_waits_history.count";
+ size= events_waits_history_per_thread * global_thread_container.get_row_count();
+ break;
+ case 4:
+ name= "events_waits_history.memory";
+ size= events_waits_history_per_thread * global_thread_container.get_row_count()
+ * sizeof(PFS_events_waits);
+ total_memory+= size;
+ break;
+ case 5:
+ name= "events_waits_history_long.size";
+ size= sizeof(PFS_events_waits);
+ break;
+ case 6:
+ name= "events_waits_history_long.count";
+ size= events_waits_history_long_size;
+ break;
+ case 7:
+ name= "events_waits_history_long.memory";
+ size= events_waits_history_long_size * sizeof(PFS_events_waits);
+ total_memory+= size;
+ break;
+ case 8:
+ name= "(pfs_mutex_class).size";
+ size= sizeof(PFS_mutex_class);
+ break;
+ case 9:
+ name= "(pfs_mutex_class).count";
+ size= mutex_class_max;
+ break;
+ case 10:
+ name= "(pfs_mutex_class).memory";
+ size= mutex_class_max * sizeof(PFS_mutex_class);
+ total_memory+= size;
+ break;
+ case 11:
+ name= "(pfs_rwlock_class).size";
+ size= sizeof(PFS_rwlock_class);
+ break;
+ case 12:
+ name= "(pfs_rwlock_class).count";
+ size= rwlock_class_max;
+ break;
+ case 13:
+ name= "(pfs_rwlock_class).memory";
+ size= rwlock_class_max * sizeof(PFS_rwlock_class);
+ total_memory+= size;
+ break;
+ case 14:
+ name= "(pfs_cond_class).size";
+ size= sizeof(PFS_cond_class);
+ break;
+ case 15:
+ name= "(pfs_cond_class).count";
+ size= cond_class_max;
+ break;
+ case 16:
+ name= "(pfs_cond_class).memory";
+ size= cond_class_max * sizeof(PFS_cond_class);
+ total_memory+= size;
+ break;
+ case 17:
+ name= "(pfs_thread_class).size";
+ size= sizeof(PFS_thread_class);
+ break;
+ case 18:
+ name= "(pfs_thread_class).count";
+ size= thread_class_max;
+ break;
+ case 19:
+ name= "(pfs_thread_class).memory";
+ size= thread_class_max * sizeof(PFS_thread_class);
+ total_memory+= size;
+ break;
+ case 20:
+ name= "(pfs_file_class).size";
+ size= sizeof(PFS_file_class);
+ break;
+ case 21:
+ name= "(pfs_file_class).count";
+ size= file_class_max;
+ break;
+ case 22:
+ name= "(pfs_file_class).memory";
+ size= file_class_max * sizeof(PFS_file_class);
+ total_memory+= size;
+ break;
+ case 23:
+ name= "mutex_instances.size";
+ size= global_mutex_container.get_row_size();
+ break;
+ case 24:
+ name= "mutex_instances.count";
+ size= global_mutex_container.get_row_count();
+ break;
+ case 25:
+ name= "mutex_instances.memory";
+ size= global_mutex_container.get_memory();
+ total_memory+= size;
+ break;
+ case 26:
+ name= "rwlock_instances.size";
+ size= global_rwlock_container.get_row_size();
+ break;
+ case 27:
+ name= "rwlock_instances.count";
+ size= global_rwlock_container.get_row_count();
+ break;
+ case 28:
+ name= "rwlock_instances.memory";
+ size= global_rwlock_container.get_memory();
+ total_memory+= size;
+ break;
+ case 29:
+ name= "cond_instances.size";
+ size= global_cond_container.get_row_size();
+ break;
+ case 30:
+ name= "cond_instances.count";
+ size= global_cond_container.get_row_count();
+ break;
+ case 31:
+ name= "cond_instances.memory";
+ size= global_cond_container.get_memory();
+ total_memory+= size;
+ break;
+ case 32:
+ name= "threads.size";
+ size= global_thread_container.get_row_size();
+ break;
+ case 33:
+ name= "threads.count";
+ size= global_thread_container.get_row_count();
+ break;
+ case 34:
+ name= "threads.memory";
+ size= global_thread_container.get_memory();
+ total_memory+= size;
+ break;
+ case 35:
+ name= "file_instances.size";
+ size= global_file_container.get_row_size();
+ break;
+ case 36:
+ name= "file_instances.count";
+ size= global_file_container.get_row_count();
+ break;
+ case 37:
+ name= "file_instances.memory";
+ size= global_file_container.get_memory();
+ total_memory+= size;
+ break;
+ case 38:
+ name= "(pfs_file_handle).size";
+ size= sizeof(PFS_file*);
+ break;
+ case 39:
+ name= "(pfs_file_handle).count";
+ size= file_handle_max;
+ break;
+ case 40:
+ name= "(pfs_file_handle).memory";
+ size= file_handle_max * sizeof(PFS_file*);
+ total_memory+= size;
+ break;
+ case 41:
+ name= "events_waits_summary_by_thread_by_event_name.size";
+ size= sizeof(PFS_single_stat);
+ break;
+ case 42:
+ name= "events_waits_summary_by_thread_by_event_name.count";
+ size= global_thread_container.get_row_count() * wait_class_max;
+ break;
+ case 43:
+ name= "events_waits_summary_by_thread_by_event_name.memory";
+ size= global_thread_container.get_row_count() * wait_class_max * sizeof(PFS_single_stat);
+ total_memory+= size;
+ break;
+ case 44:
+ name= "(pfs_table_share).size";
+ size= global_table_share_container.get_row_size();
+ break;
+ case 45:
+ name= "(pfs_table_share).count";
+ size= global_table_share_container.get_row_count();
+ break;
+ case 46:
+ name= "(pfs_table_share).memory";
+ size= global_table_share_container.get_memory();
+ total_memory+= size;
+ break;
+ case 47:
+ name= "(pfs_table).size";
+ size= global_table_container.get_row_size();
+ break;
+ case 48:
+ name= "(pfs_table).count";
+ size= global_table_container.get_row_count();
+ break;
+ case 49:
+ name= "(pfs_table).memory";
+ size= global_table_container.get_memory();
+ total_memory+= size;
+ break;
+ case 50:
+ name= "setup_actors.size";
+ size= global_setup_actor_container.get_row_size();
+ break;
+ case 51:
+ name= "setup_actors.count";
+ size= global_setup_actor_container.get_row_count();
+ break;
+ case 52:
+ name= "setup_actors.memory";
+ size= global_setup_actor_container.get_memory();
+ total_memory+= size;
+ break;
+ case 53:
+ name= "setup_objects.size";
+ size= global_setup_object_container.get_row_size();
+ break;
+ case 54:
+ name= "setup_objects.count";
+ size= global_setup_object_container.get_row_count();
+ break;
+ case 55:
+ name= "setup_objects.memory";
+ size= global_setup_object_container.get_memory();
+ total_memory+= size;
+ break;
+ case 56:
+ name= "(pfs_account).size";
+ size= global_account_container.get_row_size();
+ break;
+ case 57:
+ name= "(pfs_account).count";
+ size= global_account_container.get_row_count();
+ break;
+ case 58:
+ name= "(pfs_account).memory";
+ size= global_account_container.get_memory();
+ total_memory+= size;
+ break;
+ case 59:
+ name= "events_waits_summary_by_account_by_event_name.size";
+ size= sizeof(PFS_single_stat);
+ break;
+ case 60:
+ name= "events_waits_summary_by_account_by_event_name.count";
+ size= global_account_container.get_row_count() * wait_class_max;
+ break;
+ case 61:
+ name= "events_waits_summary_by_account_by_event_name.memory";
+ size= global_account_container.get_row_count() * wait_class_max * sizeof(PFS_single_stat);
+ total_memory+= size;
+ break;
+ case 62:
+ name= "events_waits_summary_by_user_by_event_name.size";
+ size= sizeof(PFS_single_stat);
+ break;
+ case 63:
+ name= "events_waits_summary_by_user_by_event_name.count";
+ size= global_user_container.get_row_count() * wait_class_max;
+ break;
+ case 64:
+ name= "events_waits_summary_by_user_by_event_name.memory";
+ size= global_user_container.get_row_count() * wait_class_max * sizeof(PFS_single_stat);
+ total_memory+= size;
+ break;
+ case 65:
+ name= "events_waits_summary_by_host_by_event_name.size";
+ size= sizeof(PFS_single_stat);
+ break;
+ case 66:
+ name= "events_waits_summary_by_host_by_event_name.count";
+ size= global_host_container.get_row_count() * wait_class_max;
+ break;
+ case 67:
+ name= "events_waits_summary_by_host_by_event_name.memory";
+ size= global_host_container.get_row_count() * wait_class_max * sizeof(PFS_single_stat);
+ total_memory+= size;
+ break;
+ case 68:
+ name= "(pfs_user).size";
+ size= global_user_container.get_row_size();
+ break;
+ case 69:
+ name= "(pfs_user).count";
+ size= global_user_container.get_row_count();
+ break;
+ case 70:
+ name= "(pfs_user).memory";
+ size= global_user_container.get_memory();
+ total_memory+= size;
+ break;
+ case 71:
+ name= "(pfs_host).size";
+ size= global_host_container.get_row_size();
+ break;
+ case 72:
+ name= "(pfs_host).count";
+ size= global_host_container.get_row_count();
+ break;
+ case 73:
+ name= "(pfs_host).memory";
+ size= global_host_container.get_memory();
+ total_memory+= size;
+ break;
+ case 74:
+ name= "(pfs_stage_class).size";
+ size= sizeof(PFS_stage_class);
+ break;
+ case 75:
+ name= "(pfs_stage_class).count";
+ size= stage_class_max;
+ break;
+ case 76:
+ name= "(pfs_stage_class).memory";
+ size= stage_class_max * sizeof(PFS_stage_class);
+ total_memory+= size;
+ break;
+ case 77:
+ name= "events_stages_history.size";
+ size= sizeof(PFS_events_stages);
+ break;
+ case 78:
+ name= "events_stages_history.count";
+ size= events_stages_history_per_thread * global_thread_container.get_row_count();
+ break;
+ case 79:
+ name= "events_stages_history.memory";
+ size= events_stages_history_per_thread * global_thread_container.get_row_count()
+ * sizeof(PFS_events_stages);
+ total_memory+= size;
+ break;
+ case 80:
+ name= "events_stages_history_long.size";
+ size= sizeof(PFS_events_stages);
+ break;
+ case 81:
+ name= "events_stages_history_long.count";
+ size= events_stages_history_long_size;
+ break;
+ case 82:
+ name= "events_stages_history_long.memory";
+ size= events_stages_history_long_size * sizeof(PFS_events_stages);
+ total_memory+= size;
+ break;
+ case 83:
+ name= "events_stages_summary_by_thread_by_event_name.size";
+ size= sizeof(PFS_stage_stat);
+ break;
+ case 84:
+ name= "events_stages_summary_by_thread_by_event_name.count";
+ size= global_thread_container.get_row_count() * stage_class_max;
+ break;
+ case 85:
+ name= "events_stages_summary_by_thread_by_event_name.memory";
+ size= global_thread_container.get_row_count() * stage_class_max * sizeof(PFS_stage_stat);
+ total_memory+= size;
+ break;
+ case 86:
+ name= "events_stages_summary_global_by_event_name.size";
+ size= sizeof(PFS_stage_stat);
+ break;
+ case 87:
+ name= "events_stages_summary_global_by_event_name.count";
+ size= stage_class_max;
+ break;
+ case 88:
+ name= "events_stages_summary_global_by_event_name.memory";
+ size= stage_class_max * sizeof(PFS_stage_stat);
+ total_memory+= size;
+ break;
+ case 89:
+ name= "events_stages_summary_by_account_by_event_name.size";
+ size= sizeof(PFS_stage_stat);
+ break;
+ case 90:
+ name= "events_stages_summary_by_account_by_event_name.count";
+ size= global_account_container.get_row_count() * stage_class_max;
+ break;
+ case 91:
+ name= "events_stages_summary_by_account_by_event_name.memory";
+ size= global_account_container.get_row_count() * stage_class_max * sizeof(PFS_stage_stat);
+ total_memory+= size;
+ break;
+ case 92:
+ name= "events_stages_summary_by_user_by_event_name.size";
+ size= sizeof(PFS_stage_stat);
+ break;
+ case 93:
+ name= "events_stages_summary_by_user_by_event_name.count";
+ size= global_user_container.get_row_count() * stage_class_max;
+ break;
+ case 94:
+ name= "events_stages_summary_by_user_by_event_name.memory";
+ size= global_user_container.get_row_count() * stage_class_max * sizeof(PFS_stage_stat);
+ total_memory+= size;
+ break;
+ case 95:
+ name= "events_stages_summary_by_host_by_event_name.size";
+ size= sizeof(PFS_stage_stat);
+ break;
+ case 96:
+ name= "events_stages_summary_by_host_by_event_name.count";
+ size= global_host_container.get_row_count() * stage_class_max;
+ break;
+ case 97:
+ name= "events_stages_summary_by_host_by_event_name.memory";
+ size= global_host_container.get_row_count() * stage_class_max * sizeof(PFS_stage_stat);
+ total_memory+= size;
+ break;
+ case 98:
+ name= "(pfs_statement_class).size";
+ size= sizeof(PFS_statement_class);
+ break;
+ case 99:
+ name= "(pfs_statement_class).count";
+ size= statement_class_max;
+ break;
+ case 100:
+ name= "(pfs_statement_class).memory";
+ size= statement_class_max * sizeof(PFS_statement_class);
+ total_memory+= size;
+ break;
+ case 101:
+ name= "events_statements_history.size";
+ size= sizeof(PFS_events_statements);
+ break;
+ case 102:
+ name= "events_statements_history.count";
+ size= events_statements_history_per_thread * global_thread_container.get_row_count();
+ break;
+ case 103:
+ name= "events_statements_history.memory";
+ size= events_statements_history_per_thread * global_thread_container.get_row_count()
+ * sizeof(PFS_events_statements);
+ total_memory+= size;
+ break;
+ case 104:
+ name= "events_statements_history_long.size";
+ size= sizeof(PFS_events_statements);
+ break;
+ case 105:
+ name= "events_statements_history_long.count";
+ size= events_statements_history_long_size;
+ break;
+ case 106:
+ name= "events_statements_history_long.memory";
+ size= events_statements_history_long_size * (sizeof(PFS_events_statements));
+ total_memory+= size;
+ break;
+ case 107:
+ name= "events_statements_summary_by_thread_by_event_name.size";
+ size= sizeof(PFS_statement_stat);
+ break;
+ case 108:
+ name= "events_statements_summary_by_thread_by_event_name.count";
+ size= global_thread_container.get_row_count() * statement_class_max;
+ break;
+ case 109:
+ name= "events_statements_summary_by_thread_by_event_name.memory";
+ size= global_thread_container.get_row_count() * statement_class_max * sizeof(PFS_statement_stat);
+ total_memory+= size;
+ break;
+ case 110:
+ name= "events_statements_summary_global_by_event_name.size";
+ size= sizeof(PFS_statement_stat);
+ break;
+ case 111:
+ name= "events_statements_summary_global_by_event_name.count";
+ size= statement_class_max;
+ break;
+ case 112:
+ name= "events_statements_summary_global_by_event_name.memory";
+ size= statement_class_max * sizeof(PFS_statement_stat);
+ total_memory+= size;
+ break;
+ case 113:
+ name= "events_statements_summary_by_account_by_event_name.size";
+ size= sizeof(PFS_statement_stat);
+ break;
+ case 114:
+ name= "events_statements_summary_by_account_by_event_name.count";
+ size= global_account_container.get_row_count() * statement_class_max;
+ break;
+ case 115:
+ name= "events_statements_summary_by_account_by_event_name.memory";
+ size= global_account_container.get_row_count() * statement_class_max * sizeof(PFS_statement_stat);
+ total_memory+= size;
+ break;
+ case 116:
+ name= "events_statements_summary_by_user_by_event_name.size";
+ size= sizeof(PFS_statement_stat);
+ break;
+ case 117:
+ name= "events_statements_summary_by_user_by_event_name.count";
+ size= global_user_container.get_row_count() * statement_class_max;
+ break;
+ case 118:
+ name= "events_statements_summary_by_user_by_event_name.memory";
+ size= global_user_container.get_row_count() * statement_class_max * sizeof(PFS_statement_stat);
+ total_memory+= size;
+ break;
+ case 119:
+ name= "events_statements_summary_by_host_by_event_name.size";
+ size= sizeof(PFS_statement_stat);
+ break;
+ case 120:
+ name= "events_statements_summary_by_host_by_event_name.count";
+ size= global_host_container.get_row_count() * statement_class_max;
+ break;
+ case 121:
+ name= "events_statements_summary_by_host_by_event_name.memory";
+ size= global_host_container.get_row_count() * statement_class_max * sizeof(PFS_statement_stat);
+ total_memory+= size;
+ break;
+ case 122:
+ name= "events_statements_current.size";
+ size= sizeof(PFS_events_statements);
+ break;
+ case 123:
+ name= "events_statements_current.count";
+ size= global_thread_container.get_row_count() * statement_stack_max;
+ break;
+ case 124:
+ name= "events_statements_current.memory";
+ size= global_thread_container.get_row_count() * statement_stack_max * sizeof(PFS_events_statements);
+ total_memory+= size;
+ break;
+ case 125:
+ name= "(pfs_socket_class).size";
+ size= sizeof(PFS_socket_class);
+ break;
+ case 126:
+ name= "(pfs_socket_class).count";
+ size= socket_class_max;
+ break;
+ case 127:
+ name= "(pfs_socket_class).memory";
+ size= socket_class_max * sizeof(PFS_socket_class);
+ total_memory+= size;
+ break;
+ case 128:
+ name= "socket_instances.size";
+ size= global_socket_container.get_row_size();
+ break;
+ case 129:
+ name= "socket_instances.count";
+ size= global_socket_container.get_row_count();
+ break;
+ case 130:
+ name= "socket_instances.memory";
+ size= global_socket_container.get_memory();
+ total_memory+= size;
+ break;
+ case 131:
+ name= "events_statements_summary_by_digest.size";
+ size= sizeof(PFS_statements_digest_stat);
+ break;
+ case 132:
+ name= "events_statements_summary_by_digest.count";
+ size= digest_max;
+ break;
+ case 133:
+ name= "events_statements_summary_by_digest.memory";
+ size= digest_max * (sizeof(PFS_statements_digest_stat));
+ total_memory+= size;
+ break;
+ case 134:
+ name= "events_statements_summary_by_program.size";
+ size= global_program_container.get_row_size();
+ break;
+ case 135:
+ name= "events_statements_summary_by_program.count";
+ size= global_program_container.get_row_count();
+ break;
+ case 136:
+ name= "events_statements_summary_by_program.memory";
+ size= global_program_container.get_memory();
+ total_memory+= size;
+ break;
+ case 137:
+ name= "session_connect_attrs.size";
+ size= global_thread_container.get_row_count();
+ break;
+ case 138:
+ name= "session_connect_attrs.count";
+ size= session_connect_attrs_size_per_thread;
+ break;
+ case 139:
+ name= "session_connect_attrs.memory";
+ size= global_thread_container.get_row_count() * session_connect_attrs_size_per_thread;
+ total_memory+= size;
+ break;
+ case 140:
+ name= "prepared_statements_instances.size";
+ size= global_prepared_stmt_container.get_row_size();
+ break;
+ case 141:
+ name= "prepared_statements_instances.count";
+ size= global_prepared_stmt_container.get_row_count();
+ break;
+ case 142:
+ name= "prepared_statements_instances.memory";
+ size= global_prepared_stmt_container.get_memory();
+ total_memory+= size;
+ break;
+
+ case 143:
+ name= "(account_hash).count";
+ size= account_hash.count;
+ break;
+ case 144:
+ name= "(account_hash).size";
+ size= account_hash.size;
+ break;
+ case 145:
+ name= "(digest_hash).count";
+ size= digest_hash.count;
+ break;
+ case 146:
+ name= "(digest_hash).size";
+ size= digest_hash.size;
+ break;
+ case 147:
+ name= "(filename_hash).count";
+ size= pfs_filename_hash.count;
+ break;
+ case 148:
+ name= "(filename_hash).size";
+ size= pfs_filename_hash.size;
+ break;
+ case 149:
+ name= "(host_hash).count";
+ size= host_hash.count;
+ break;
+ case 150:
+ name= "(host_hash).size";
+ size= host_hash.size;
+ break;
+ case 151:
+ name= "(setup_actor_hash).count";
+ size= setup_actor_hash.count;
+ break;
+ case 152:
+ name= "(setup_actor_hash).size";
+ size= setup_actor_hash.size;
+ break;
+ case 153:
+ name= "(setup_object_hash).count";
+ size= setup_object_hash.count;
+ break;
+ case 154:
+ name= "(setup_object_hash).size";
+ size= setup_object_hash.size;
+ break;
+ case 155:
+ name= "(table_share_hash).count";
+ size= table_share_hash.count;
+ break;
+ case 156:
+ name= "(table_share_hash).size";
+ size= table_share_hash.size;
+ break;
+ case 157:
+ name= "(user_hash).count";
+ size= user_hash.count;
+ break;
+ case 158:
+ name= "(user_hash).size";
+ size= user_hash.size;
+ break;
+ case 159:
+ name= "(program_hash).count";
+ size= program_hash.count;
+ break;
+ case 160:
+ name= "(program_hash).size";
+ size= program_hash.size;
+ break;
+ case 161:
+ /*
+ This is not a performance_schema buffer,
+ the data is maintained in the server,
+ in hostname_cache.
+ Print the size only, there are:
+ - no host_cache.count
+ - no host_cache.memory
+ */
+ name= "host_cache.size";
+ size= sizeof(Host_entry);
+ break;
+
+ case 162:
+ name= "(pfs_memory_class).row_size";
+ size= sizeof(PFS_memory_class);
+ break;
+ case 163:
+ name= "(pfs_memory_class).row_count";
+ size= memory_class_max;
+ break;
+ case 164:
+ name= "(pfs_memory_class).memory";
+ size= memory_class_max * sizeof(PFS_memory_class);
+ total_memory+= size;
+ break;
+
+ case 165:
+ name= "memory_summary_by_thread_by_event_name.row_size";
+ size= sizeof(PFS_memory_stat);
+ break;
+ case 166:
+ name= "memory_summary_by_thread_by_event_name.row_count";
+ size= global_thread_container.get_row_count() * memory_class_max;
+ break;
+ case 167:
+ name= "memory_summary_by_thread_by_event_name.memory";
+ size= global_thread_container.get_row_count() * memory_class_max * sizeof(PFS_memory_stat);
+ total_memory+= size;
+ break;
+ case 168:
+ name= "memory_summary_global_by_event_name.row_size";
+ size= sizeof(PFS_memory_stat);
+ break;
+ case 169:
+ name= "memory_summary_global_by_event_name.row_count";
+ size= memory_class_max;
+ break;
+ case 170:
+ name= "memory_summary_global_by_event_name.memory";
+ size= memory_class_max * sizeof(PFS_memory_stat);
+ total_memory+= size;
+ break;
+ case 171:
+ name= "memory_summary_by_account_by_event_name.row_size";
+ size= sizeof(PFS_memory_stat);
+ break;
+ case 172:
+ name= "memory_summary_by_account_by_event_name.row_count";
+ size= global_account_container.get_row_count() * memory_class_max;
+ break;
+ case 173:
+ name= "memory_summary_by_account_by_event_name.memory";
+ size= global_account_container.get_row_count() * memory_class_max * sizeof(PFS_memory_stat);
+ total_memory+= size;
+ break;
+ case 174:
+ name= "memory_summary_by_user_by_event_name.row_size";
+ size= sizeof(PFS_memory_stat);
+ break;
+ case 175:
+ name= "memory_summary_by_user_by_event_name.row_count";
+ size= global_user_container.get_row_count() * memory_class_max;
+ break;
+ case 176:
+ name= "memory_summary_by_user_by_event_name.memory";
+ size= global_user_container.get_row_count() * memory_class_max * sizeof(PFS_memory_stat);
+ total_memory+= size;
+ break;
+ case 177:
+ name= "memory_summary_by_host_by_event_name.row_size";
+ size= sizeof(PFS_memory_stat);
+ break;
+ case 178:
+ name= "memory_summary_by_host_by_event_name.row_count";
+ size= global_host_container.get_row_count() * memory_class_max;
+ break;
+ case 179:
+ name= "memory_summary_by_host_by_event_name.memory";
+ size= global_host_container.get_row_count() * memory_class_max * sizeof(PFS_memory_stat);
+ total_memory+= size;
+ break;
+ case 180:
+ name= "metadata_locks.row_size";
+ size= global_mdl_container.get_row_size();
+ break;
+ case 181:
+ name= "metadata_locks.row_count";
+ size= global_mdl_container.get_row_count();
+ break;
+ case 182:
+ name= "metadata_locks.memory";
+ size= global_mdl_container.get_memory();
+ total_memory+= size;
+ break;
+ case 183:
+ name= "events_transactions_history.size";
+ size= sizeof(PFS_events_transactions);
+ break;
+ case 184:
+ name= "events_transactions_history.count";
+ size= events_transactions_history_per_thread * global_thread_container.get_row_count();
+ break;
+ case 185:
+ name= "events_transactions_history.memory";
+ size= events_transactions_history_per_thread * global_thread_container.get_row_count()
+ * sizeof(PFS_events_transactions);
+ total_memory+= size;
+ break;
+ case 186:
+ name= "events_transactions_history_long.size";
+ size= sizeof(PFS_events_transactions);
+ break;
+ case 187:
+ name= "events_transactions_history_long.count";
+ size= events_transactions_history_long_size;
+ break;
+ case 188:
+ name= "events_transactions_history_long.memory";
+ size= events_transactions_history_long_size * sizeof(PFS_events_transactions);
+ total_memory+= size;
+ break;
+ case 189:
+ name= "events_transactions_summary_by_thread_by_event_name.size";
+ size= sizeof(PFS_transaction_stat);
+ break;
+ case 190:
+ name= "events_transactions_summary_by_thread_by_event_name.count";
+ size= global_thread_container.get_row_count() * transaction_class_max;
+ break;
+ case 191:
+ name= "events_transactions_summary_by_thread_by_event_name.memory";
+ size= global_thread_container.get_row_count() * transaction_class_max * sizeof(PFS_transaction_stat);
+ total_memory+= size;
+ break;
+ case 192:
+ name= "events_transactions_summary_by_account_by_event_name.size";
+ size= sizeof(PFS_transaction_stat);
+ break;
+ case 193:
+ name= "events_transactions_summary_by_account_by_event_name.count";
+ size= global_account_container.get_row_count() * transaction_class_max;
+ break;
+ case 194:
+ name= "events_transactions_summary_by_account_by_event_name.memory";
+ size= global_account_container.get_row_count() * transaction_class_max * sizeof(PFS_transaction_stat);
+ total_memory+= size;
+ break;
+ case 195:
+ name= "events_transactions_summary_by_user_by_event_name.size";
+ size= sizeof(PFS_transaction_stat);
+ break;
+ case 196:
+ name= "events_transactions_summary_by_user_by_event_name.count";
+ size= global_user_container.get_row_count() * transaction_class_max;
+ break;
+ case 197:
+ name= "events_transactions_summary_by_user_by_event_name.memory";
+ size= global_user_container.get_row_count() * transaction_class_max * sizeof(PFS_transaction_stat);
+ total_memory+= size;
+ break;
+ case 198:
+ name= "events_transactions_summary_by_host_by_event_name.size";
+ size= sizeof(PFS_transaction_stat);
+ break;
+ case 199:
+ name= "events_transactions_summary_by_host_by_event_name.count";
+ size= global_host_container.get_row_count() * transaction_class_max;
+ break;
+ case 200:
+ name= "events_transactions_summary_by_host_by_event_name.memory";
+ size= global_host_container.get_row_count() * transaction_class_max * sizeof(PFS_transaction_stat);
+ total_memory+= size;
+ break;
+ case 201:
+ name= "table_lock_waits_summary_by_table.size";
+ size= global_table_share_lock_container.get_row_size();
+ break;
+ case 202:
+ name= "table_lock_waits_summary_by_table.count";
+ size= global_table_share_lock_container.get_row_count();
+ break;
+ case 203:
+ name= "table_lock_waits_summary_by_table.memory";
+ size= global_table_share_lock_container.get_memory();
+ total_memory+= size;
+ break;
+ case 204:
+ name= "table_io_waits_summary_by_index_usage.size";
+ size= global_table_share_index_container.get_row_size();
+ break;
+ case 205:
+ name= "table_io_waits_summary_by_index_usage.count";
+ size= global_table_share_index_container.get_row_count();
+ break;
+ case 206:
+ name= "table_io_waits_summary_by_index_usage.memory";
+ size= global_table_share_index_container.get_memory();
+ total_memory+= size;
+ break;
+ case 207:
+ name= "(history_long_statements_digest_token_array).count";
+ size= events_statements_history_long_size;
+ break;
+ case 208:
+ name= "(history_long_statements_digest_token_array).size";
+ size= pfs_max_digest_length;
+ break;
+ case 209:
+ name= "(history_long_statements_digest_token_array).memory";
+ size= events_statements_history_long_size * pfs_max_digest_length;
+ total_memory+= size;
+ break;
+ case 210:
+ name= "(history_statements_digest_token_array).count";
+ size= global_thread_container.get_row_count() * events_statements_history_per_thread;
+ break;
+ case 211:
+ name= "(history_statements_digest_token_array).size";
+ size= pfs_max_digest_length;
+ break;
+ case 212:
+ name= "(history_statements_digest_token_array).memory";
+ size= global_thread_container.get_row_count() * events_statements_history_per_thread * pfs_max_digest_length;
+ total_memory+= size;
+ break;
+ case 213:
+ name= "(current_statements_digest_token_array).count";
+ size= global_thread_container.get_row_count() * statement_stack_max;
+ break;
+ case 214:
+ name= "(current_statements_digest_token_array).size";
+ size= pfs_max_digest_length;
+ break;
+ case 215:
+ name= "(current_statements_digest_token_array).memory";
+ size= global_thread_container.get_row_count() * statement_stack_max * pfs_max_digest_length;
+ total_memory+= size;
+ break;
+ case 216:
+ name= "(history_long_statements_text_array).count";
+ size= events_statements_history_long_size;
+ break;
+ case 217:
+ name= "(history_long_statements_text_array).size";
+ size= pfs_max_sqltext;
+ break;
+ case 218:
+ name= "(history_long_statements_text_array).memory";
+ size= events_statements_history_long_size * pfs_max_sqltext;
+ total_memory+= size;
+ break;
+ case 219:
+ name= "(history_statements_text_array).count";
+ size= global_thread_container.get_row_count() * events_statements_history_per_thread;
+ break;
+ case 220:
+ name= "(history_statements_text_array).size";
+ size= pfs_max_sqltext;
+ break;
+ case 221:
+ name= "(history_statements_text_array).memory";
+ size= global_thread_container.get_row_count() * events_statements_history_per_thread * pfs_max_sqltext;
+ total_memory+= size;
+ break;
+ case 222:
+ name= "(current_statements_text_array).count";
+ size= global_thread_container.get_row_count() * statement_stack_max;
+ break;
+ case 223:
+ name= "(current_statements_text_array).size";
+ size= pfs_max_sqltext;
+ break;
+ case 224:
+ name= "(current_statements_text_array).memory";
+ size= global_thread_container.get_row_count() * statement_stack_max * pfs_max_sqltext;
+ total_memory+= size;
+ break;
+ case 225:
+ name= "(statements_digest_token_array).count";
+ size= digest_max;
+ break;
+ case 226:
+ name= "(statements_digest_token_array).size";
+ size= pfs_max_digest_length;
+ break;
+ case 227:
+ name= "(statements_digest_token_array).memory";
+ size= digest_max * pfs_max_digest_length;
+ total_memory+= size;
+ break;
+ /*
+ This case must be last,
+ for aggregation in total_memory.
+ */
+ case 228:
+ name= "performance_schema.memory";
+ size= total_memory;
+ break;
+ default:
+ goto end;
+ break;
+ }
+
+ buflen= (uint)(longlong10_to_str(size, buf, 10) - buf);
+ if (print(thd,
+ PERFORMANCE_SCHEMA_str.str, PERFORMANCE_SCHEMA_str.length,
+ name, strlen(name),
+ buf, buflen))
+ DBUG_RETURN(true);
+ }
+
+end:
+ DBUG_RETURN(false);
+}
+
+int pfs_discover_table_names(handlerton *hton __attribute__((unused)),
+ LEX_CSTRING *db,
+ MY_DIR *dir __attribute__((unused)),
+ handlerton::discovered_list *result)
+{
+ if (compare_table_names(db->str, PERFORMANCE_SCHEMA_str.str))
+ return 0;
+ for (size_t i= 0; i < array_elements(all_shares) - 1; i++)
+ result->add_table(all_shares[i]->m_name.str,
+ all_shares[i]->m_name.length);
+ return 0;
+}
+
+/** @} */
+
diff --git a/storage/perfschema/pfs_engine_table.h b/storage/perfschema/pfs_engine_table.h
new file mode 100644
index 00000000..883ff07c
--- /dev/null
+++ b/storage/perfschema/pfs_engine_table.h
@@ -0,0 +1,610 @@
+/* Copyright (c) 2008, 2016, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef PFS_ENGINE_TABLE_H
+#define PFS_ENGINE_TABLE_H
+
+#include "table.h"
+#include "sql_acl.h"
+/**
+ @file storage/perfschema/pfs_engine_table.h
+ Performance schema tables (declarations).
+*/
+
+#include "pfs_instr_class.h"
+extern pthread_key_t THR_PFS_VG; // global_variables
+extern pthread_key_t THR_PFS_SV; // session_variables
+extern pthread_key_t THR_PFS_VBT; // variables_by_thread
+extern pthread_key_t THR_PFS_SG; // global_status
+extern pthread_key_t THR_PFS_SS; // session_status
+extern pthread_key_t THR_PFS_SBT; // status_by_thread
+extern pthread_key_t THR_PFS_SBU; // status_by_user
+extern pthread_key_t THR_PFS_SBH; // status_by_host
+extern pthread_key_t THR_PFS_SBA; // status_by_account
+
+class Field;
+struct PFS_engine_table_share;
+struct time_normalizer;
+
+/**
+ @addtogroup Performance_schema_engine
+ @{
+*/
+
+/**
+ Store and retrieve table state information during a query.
+*/
+class PFS_table_context
+{
+public:
+ PFS_table_context(ulonglong current_version, bool restore, pthread_key_t key);
+ PFS_table_context(ulonglong current_version, ulong map_size, bool restore, pthread_key_t key);
+~PFS_table_context(void);
+
+ bool initialize(void);
+ bool is_initialized(void) { return m_initialized; }
+ ulonglong current_version(void) { return m_current_version; }
+ ulonglong last_version(void) { return m_last_version; }
+ bool versions_match(void) { return m_last_version == m_current_version; }
+ void set_item(ulong n);
+ bool is_item_set(ulong n);
+ pthread_key_t m_thr_key;
+
+private:
+ ulonglong m_current_version;
+ ulonglong m_last_version;
+ ulong *m_map;
+ ulong m_map_size;
+ static constexpr ulong m_word_size= 8 * sizeof(ulong);
+ bool m_restore;
+ bool m_initialized;
+ ulong m_last_item;
+};
+
+/**
+ An abstract PERFORMANCE_SCHEMA table.
+ Every table implemented in the performance schema schema and storage engine
+ derives from this class.
+*/
+class PFS_engine_table
+{
+public:
+ static const PFS_engine_table_share*
+ find_engine_table_share(const char *name);
+
+ int read_row(TABLE *table, unsigned char *buf, Field **fields);
+
+ int update_row(TABLE *table, const unsigned char *old_buf,
+ const unsigned char *new_buf, Field **fields);
+
+ /**
+ Delete a row from this table.
+ @param table Table handle
+ @param buf the row buffer to delete
+ @param fields Table fields
+ @return 0 on success
+ */
+ int delete_row(TABLE *table, const unsigned char *buf, Field **fields);
+
+ /** Initialize table scan. */
+ virtual int rnd_init(bool scan){return 0;};
+
+ /** Fetch the next row in this cursor. */
+ virtual int rnd_next(void)= 0;
+ /**
+ Fetch a row by position.
+ @param pos position to fetch
+ */
+ virtual int rnd_pos(const void *pos)= 0;
+
+ void get_position(void *ref);
+ void set_position(const void *ref);
+ /** Reset the cursor position to the beginning of the table. */
+ virtual void reset_position(void)= 0;
+
+ /** Get the normalizer and class type for the current row. */
+ void get_normalizer(PFS_instr_class *instr_class);
+
+ /** Destructor. */
+ virtual ~PFS_engine_table()
+ {}
+
+ /**
+ Helper, assign a value to a long field.
+ @param f the field to set
+ @param value the value to assign
+ */
+ static void set_field_long(Field *f, long value);
+ /**
+ Helper, assign a value to a ulong field.
+ @param f the field to set
+ @param value the value to assign
+ */
+ static void set_field_ulong(Field *f, ulong value);
+ /**
+ Helper, assign a value to a longlong field.
+ @param f the field to set
+ @param value the value to assign
+ */
+ static void set_field_longlong(Field *f, longlong value);
+ /**
+ Helper, assign a value to a ulonglong field.
+ @param f the field to set
+ @param value the value to assign
+ */
+ static void set_field_ulonglong(Field *f, ulonglong value);
+ /**
+ Helper, assign a value to a char utf8 field.
+ @param f the field to set
+ @param str the string to assign
+ @param len the length of the string to assign
+ */
+ static void set_field_char_utf8(Field *f, const char *str, uint len);
+ /**
+ Helper, assign a value to a varchar utf8 field.
+ @param f the field to set
+ @param cs the string character set
+ @param str the string to assign
+ @param len the length of the string to assign
+ */
+ static void set_field_varchar(Field *f, const CHARSET_INFO *cs, const char *str, uint len);
+ /**
+ Helper, assign a value to a varchar utf8 field.
+ @param f the field to set
+ @param str the string to assign
+ @param len the length of the string to assign
+ */
+ static void set_field_varchar_utf8(Field *f, const char *str, uint len);
+ /**
+ Helper, assign a value to a longtext utf8 field.
+ @param f the field to set
+ @param str the string to assign
+ @param len the length of the string to assign
+ */
+ static void set_field_longtext_utf8(Field *f, const char *str, uint len);
+ /**
+ Helper, assign a value to a blob field.
+ @param f the field to set
+ @param val the value to assign
+ @param len the length of the string to assign
+ */
+ static void set_field_blob(Field *f, const char *val, uint len);
+ /**
+ Helper, assign a value to an enum field.
+ @param f the field to set
+ @param value the value to assign
+ */
+ static void set_field_enum(Field *f, ulonglong value);
+ /**
+ Helper, assign a value to a timestamp field.
+ @param f the field to set
+ @param value the value to assign
+ */
+ static void set_field_timestamp(Field *f, ulonglong value);
+ /**
+ Helper, assign a value to a double field.
+ @param f the field to set
+ @param value the value to assign
+ */
+ static void set_field_double(Field *f, double value);
+ /**
+ Helper, read a value from an enum field.
+ @param f the field to read
+ @return the field value
+ */
+ static ulonglong get_field_enum(Field *f);
+ /**
+ Helper, read a value from a char utf8 field.
+ @param f the field to read
+ @param[out] val the field value
+ @return the field value
+ */
+ static String *get_field_char_utf8(Field *f, String *val);
+ /**
+ Helper, read a value from a varchar utf8 field.
+ @param f the field to read
+ @param[out] val the field value
+ @return the field value
+ */
+ static String *get_field_varchar_utf8(Field *f, String *val);
+
+protected:
+ /**
+ Read the current row values.
+ @param table Table handle
+ @param buf row buffer
+ @param fields Table fields
+ @param read_all true if all columns are read.
+ */
+ virtual int read_row_values(TABLE *table, unsigned char *buf,
+ Field **fields, bool read_all)= 0;
+
+ /**
+ Update the current row values.
+ @param table Table handle
+ @param old_buf old row buffer
+ @param new_buf new row buffer
+ @param fields Table fields
+ */
+ virtual int update_row_values(TABLE *table, const unsigned char *old_buf,
+ const unsigned char *new_buf, Field **fields);
+
+ /**
+ Delete a row.
+ @param table Table handle
+ @param buf Row buffer
+ @param fields Table fields
+ */
+ virtual int delete_row_values(TABLE *table, const unsigned char *buf,
+ Field **fields);
+ /**
+ Constructor.
+ @param share table share
+ @param pos address of the m_pos position member
+ */
+ PFS_engine_table(const PFS_engine_table_share *share, void *pos)
+ : m_share_ptr(share), m_pos_ptr(pos),
+ m_normalizer(NULL), m_class_type(PFS_CLASS_NONE)
+ {}
+
+ /** Table share. */
+ const PFS_engine_table_share *m_share_ptr;
+ /** Opaque pointer to the m_pos position of this cursor. */
+ void *m_pos_ptr;
+ /** Current normalizer */
+ time_normalizer *m_normalizer;
+ /** Current class type */
+ enum PFS_class_type m_class_type;
+};
+
+/** Callback to open a table. */
+typedef PFS_engine_table* (*pfs_open_table_t)(void);
+/** Callback to write a row. */
+typedef int (*pfs_write_row_t)(TABLE *table,
+ const unsigned char *buf, Field **fields);
+/** Callback to delete all rows. */
+typedef int (*pfs_delete_all_rows_t)(void);
+/** Callback to get a row count. */
+typedef ha_rows (*pfs_get_row_count_t)(void);
+
+/**
+ A PERFORMANCE_SCHEMA table share.
+ This data is shared by all the table handles opened on the same table.
+*/
+struct PFS_engine_table_share
+{
+ static void init_all_locks(void);
+ static void delete_all_locks(void);
+ /** Get the row count. */
+ ha_rows get_row_count(void) const;
+ /** Write a row. */
+ int write_row(TABLE *table, const unsigned char *buf, Field **fields) const;
+
+ /** Table name. */
+ LEX_STRING m_name;
+ /** Table ACL. */
+ const ACL_internal_table_access *m_acl;
+ /** Open table function. */
+ pfs_open_table_t m_open_table;
+ /** Write row function. */
+ pfs_write_row_t m_write_row;
+ /** Delete all rows function. */
+ pfs_delete_all_rows_t m_delete_all_rows;
+ /** Get rows count function. */
+ pfs_get_row_count_t m_get_row_count;
+ /** Length of the m_pos position structure. */
+ uint m_ref_length;
+ /** The lock, stored on behalf of the SQL layer. */
+ THR_LOCK *m_thr_lock_ptr;
+ /** Table definition. */
+ LEX_STRING sql;
+ /** Table is available even if the Performance Schema is disabled. */
+ bool m_perpetual;
+};
+
+/**
+ Privileges for read only tables.
+ The only operation allowed is SELECT.
+*/
+class PFS_readonly_acl : public ACL_internal_table_access
+{
+public:
+ PFS_readonly_acl()
+ {}
+
+ ~PFS_readonly_acl()
+ {}
+
+ virtual ACL_internal_access_result check(privilege_t want_access,
+ privilege_t *save_priv) const;
+};
+
+/** Singleton instance of PFS_readonly_acl. */
+extern PFS_readonly_acl pfs_readonly_acl;
+
+/**
+ Privileges for truncatable tables.
+ Operations allowed are SELECT and TRUNCATE.
+*/
+class PFS_truncatable_acl : public ACL_internal_table_access
+{
+public:
+ PFS_truncatable_acl()
+ {}
+
+ ~PFS_truncatable_acl()
+ {}
+
+ ACL_internal_access_result check(privilege_t want_access,
+ privilege_t *save_priv) const;
+};
+
+/** Singleton instance of PFS_truncatable_acl. */
+extern PFS_truncatable_acl pfs_truncatable_acl;
+
+/**
+ Privileges for updatable tables.
+ Operations allowed are SELECT and UPDATE.
+*/
+class PFS_updatable_acl : public ACL_internal_table_access
+{
+public:
+ PFS_updatable_acl()
+ {}
+
+ ~PFS_updatable_acl()
+ {}
+
+ ACL_internal_access_result check(privilege_t want_access,
+ privilege_t *save_priv) const;
+};
+
+/** Singleton instance of PFS_updatable_acl. */
+extern PFS_updatable_acl pfs_updatable_acl;
+
+/**
+ Privileges for editable tables.
+ Operations allowed are SELECT, INSERT, UPDATE, DELETE and TRUNCATE.
+*/
+class PFS_editable_acl : public ACL_internal_table_access
+{
+public:
+ PFS_editable_acl()
+ {}
+
+ ~PFS_editable_acl()
+ {}
+
+ ACL_internal_access_result check(privilege_t want_access,
+ privilege_t *save_priv) const;
+};
+
+/** Singleton instance of PFS_editable_acl. */
+extern PFS_editable_acl pfs_editable_acl;
+
+/**
+ Privileges for unknown tables.
+*/
+class PFS_unknown_acl : public ACL_internal_table_access
+{
+public:
+ PFS_unknown_acl()
+ {}
+
+ ~PFS_unknown_acl()
+ {}
+
+ ACL_internal_access_result check(privilege_t want_access,
+ privilege_t *save_priv) const;
+};
+
+/** Singleton instance of PFS_unknown_acl. */
+extern PFS_unknown_acl pfs_unknown_acl;
+
+
+/**
+ Privileges for world readable tables.
+*/
+class PFS_readonly_world_acl : public PFS_readonly_acl
+{
+public:
+ PFS_readonly_world_acl()
+ {}
+
+ ~PFS_readonly_world_acl()
+ {}
+ virtual ACL_internal_access_result check(privilege_t want_access, privilege_t *save_priv) const;
+};
+
+
+/** Singleton instance of PFS_readonly_world_acl */
+extern PFS_readonly_world_acl pfs_readonly_world_acl;
+
+
+/**
+Privileges for world readable truncatable tables.
+*/
+class PFS_truncatable_world_acl : public PFS_truncatable_acl
+{
+public:
+ PFS_truncatable_world_acl()
+ {}
+
+ ~PFS_truncatable_world_acl()
+ {}
+ virtual ACL_internal_access_result check(privilege_t want_access, privilege_t *save_priv) const;
+};
+
+
+/** Singleton instance of PFS_readonly_world_acl */
+extern PFS_truncatable_world_acl pfs_truncatable_world_acl;
+
+
+/** Position of a cursor, for simple iterations. */
+struct PFS_simple_index
+{
+ /** Current row index. */
+ uint m_index;
+
+ /**
+ Constructor.
+ @param index the index initial value.
+ */
+ PFS_simple_index(uint index)
+ : m_index(index)
+ {}
+
+ /**
+ Set this index at a given position.
+ @param index an index
+ */
+ void set_at(uint index)
+ { m_index= index; }
+
+ /**
+ Set this index at a given position.
+ @param other a position
+ */
+ void set_at(const struct PFS_simple_index *other)
+ { m_index= other->m_index; }
+
+ /**
+ Set this index after a given position.
+ @param other a position
+ */
+ void set_after(const struct PFS_simple_index *other)
+ { m_index= other->m_index + 1; }
+
+ /** Set this index to the next record. */
+ void next(void)
+ { m_index++; }
+};
+
+/** Position of a double cursor, for iterations using 2 nested loops. */
+struct PFS_double_index
+{
+ /** Outer index. */
+ uint m_index_1;
+ /** Current index within index_1. */
+ uint m_index_2;
+
+ /**
+ Constructor.
+ @param index_1 the first index initial value.
+ @param index_2 the second index initial value.
+ */
+ PFS_double_index(uint index_1, uint index_2)
+ : m_index_1(index_1), m_index_2(index_2)
+ {}
+
+ /**
+ Set this index at a given position.
+ */
+ void set_at(uint index_1, uint index_2)
+ {
+ m_index_1= index_1;
+ m_index_2= index_2;
+ }
+
+ /**
+ Set this index at a given position.
+ @param other a position
+ */
+ void set_at(const struct PFS_double_index *other)
+ {
+ m_index_1= other->m_index_1;
+ m_index_2= other->m_index_2;
+ }
+
+ /**
+ Set this index after a given position.
+ @param other a position
+ */
+ void set_after(const struct PFS_double_index *other)
+ {
+ m_index_1= other->m_index_1;
+ m_index_2= other->m_index_2 + 1;
+ }
+};
+
+/** Position of a triple cursor, for iterations using 3 nested loops. */
+struct PFS_triple_index
+{
+ /** Outer index. */
+ uint m_index_1;
+ /** Current index within index_1. */
+ uint m_index_2;
+ /** Current index within index_2. */
+ uint m_index_3;
+
+ /**
+ Constructor.
+ @param index_1 the first index initial value.
+ @param index_2 the second index initial value.
+ @param index_3 the third index initial value.
+ */
+ PFS_triple_index(uint index_1, uint index_2, uint index_3)
+ : m_index_1(index_1), m_index_2(index_2), m_index_3(index_3)
+ {}
+
+ /**
+ Set this index at a given position.
+ */
+ void set_at(uint index_1, uint index_2, uint index_3)
+ {
+ m_index_1= index_1;
+ m_index_2= index_2;
+ m_index_3= index_3;
+ }
+
+ /**
+ Set this index at a given position.
+ @param other a position
+ */
+ void set_at(const struct PFS_triple_index *other)
+ {
+ m_index_1= other->m_index_1;
+ m_index_2= other->m_index_2;
+ m_index_3= other->m_index_3;
+ }
+
+ /**
+ Set this index after a given position.
+ @param other a position
+ */
+ void set_after(const struct PFS_triple_index *other)
+ {
+ m_index_1= other->m_index_1;
+ m_index_2= other->m_index_2;
+ m_index_3= other->m_index_3 + 1;
+ }
+};
+
+bool pfs_show_status(handlerton *hton, THD *thd,
+ stat_print_fn *print, enum ha_stat_type stat);
+
+int pfs_discover_table_names(handlerton *hton, LEX_CSTRING *db,
+ MY_DIR *dir,
+ handlerton::discovered_list *result);
+
+/** @} */
+#endif
diff --git a/storage/perfschema/pfs_events.h b/storage/perfschema/pfs_events.h
new file mode 100644
index 00000000..6d4a2893
--- /dev/null
+++ b/storage/perfschema/pfs_events.h
@@ -0,0 +1,71 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef PFS_EVENTS_H
+#define PFS_EVENTS_H
+
+/**
+ @file storage/perfschema/pfs_events.h
+ Events data structures (declarations).
+*/
+
+#include "pfs_column_types.h"
+
+struct PFS_instr_class;
+
+/** An event record. */
+struct PFS_events
+{
+ /** THREAD_ID. */
+ ulonglong m_thread_internal_id;
+ /** EVENT_ID. */
+ ulonglong m_event_id;
+ /** END_EVENT_ID. */
+ ulonglong m_end_event_id;
+ /** (EVENT_TYPE) */
+ enum_event_type m_event_type;
+ /** NESTING_EVENT_ID. */
+ ulonglong m_nesting_event_id;
+ /** NESTING_EVENT_TYPE */
+ enum_event_type m_nesting_event_type;
+ /** NESTING_EVENT_LEVEL */
+ uint m_nesting_event_level;
+ /** Instrument metadata. */
+ PFS_instr_class *m_class;
+ /**
+ Timer start.
+ This member is populated only if m_class->m_timed is true.
+ */
+ ulonglong m_timer_start;
+ /**
+ Timer end.
+ This member is populated only if m_class->m_timed is true.
+ */
+ ulonglong m_timer_end;
+ /** Location of the instrumentation in the source code (file name). */
+ const char *m_source_file;
+ /** Location of the instrumentation in the source code (line number). */
+ uint m_source_line;
+};
+
+#endif
+
diff --git a/storage/perfschema/pfs_events_stages.cc b/storage/perfschema/pfs_events_stages.cc
new file mode 100644
index 00000000..e5a6b9a2
--- /dev/null
+++ b/storage/perfschema/pfs_events_stages.cc
@@ -0,0 +1,246 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/pfs_events_stages.cc
+ Events stages data structures (implementation).
+*/
+
+#include "my_global.h"
+#include "my_sys.h"
+#include "pfs_global.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "pfs_account.h"
+#include "pfs_host.h"
+#include "pfs_user.h"
+#include "pfs_events_stages.h"
+#include "pfs_atomic.h"
+#include "pfs_buffer_container.h"
+#include "pfs_builtin_memory.h"
+#include "m_string.h"
+
+PFS_ALIGNED ulong events_stages_history_long_size= 0;
+/** Consumer flag for table EVENTS_STAGES_CURRENT. */
+PFS_ALIGNED bool flag_events_stages_current= false;
+/** Consumer flag for table EVENTS_STAGES_HISTORY. */
+PFS_ALIGNED bool flag_events_stages_history= false;
+/** Consumer flag for table EVENTS_STAGES_HISTORY_LONG. */
+PFS_ALIGNED bool flag_events_stages_history_long= false;
+
+/** True if EVENTS_STAGES_HISTORY_LONG circular buffer is full. */
+PFS_ALIGNED bool events_stages_history_long_full= false;
+/** Index in EVENTS_STAGES_HISTORY_LONG circular buffer. */
+PFS_ALIGNED PFS_cacheline_uint32 events_stages_history_long_index;
+/** EVENTS_STAGES_HISTORY_LONG circular buffer. */
+PFS_ALIGNED PFS_events_stages *events_stages_history_long_array= NULL;
+
+/**
+ Initialize table EVENTS_STAGES_HISTORY_LONG.
+ @param events_stages_history_long_sizing table sizing
+*/
+int init_events_stages_history_long(uint events_stages_history_long_sizing)
+{
+ events_stages_history_long_size= events_stages_history_long_sizing;
+ events_stages_history_long_full= false;
+ PFS_atomic::store_u32(&events_stages_history_long_index.m_u32, 0);
+
+ if (events_stages_history_long_size == 0)
+ return 0;
+
+ events_stages_history_long_array=
+ PFS_MALLOC_ARRAY(& builtin_memory_stages_history_long,
+ events_stages_history_long_size,
+ sizeof(PFS_events_stages), PFS_events_stages,
+ MYF(MY_ZEROFILL));
+
+ return (events_stages_history_long_array ? 0 : 1);
+}
+
+/** Cleanup table EVENTS_STAGES_HISTORY_LONG. */
+void cleanup_events_stages_history_long(void)
+{
+ PFS_FREE_ARRAY(& builtin_memory_stages_history_long,
+ events_stages_history_long_size, sizeof(PFS_events_stages),
+ events_stages_history_long_array);
+ events_stages_history_long_array= NULL;
+}
+
+static inline void copy_events_stages(PFS_events_stages *dest,
+ const PFS_events_stages *source)
+{
+ memcpy(dest, source, sizeof(PFS_events_stages));
+}
+
+/**
+ Insert a stage record in table EVENTS_STAGES_HISTORY.
+ @param thread thread that executed the wait
+ @param stage record to insert
+*/
+void insert_events_stages_history(PFS_thread *thread, PFS_events_stages *stage)
+{
+ if (unlikely(events_stages_history_per_thread == 0))
+ return;
+
+ DBUG_ASSERT(thread->m_stages_history != NULL);
+
+ uint index= thread->m_stages_history_index;
+
+ /*
+ A concurrent thread executing TRUNCATE TABLE EVENTS_STAGES_CURRENT
+ could alter the data that this thread is inserting,
+ causing a potential race condition.
+ We are not testing for this and insert a possibly empty record,
+ to make this thread (the writer) faster.
+ This is ok, the readers of m_stages_history will filter this out.
+ */
+ copy_events_stages(&thread->m_stages_history[index], stage);
+
+ index++;
+ if (index >= events_stages_history_per_thread)
+ {
+ index= 0;
+ thread->m_stages_history_full= true;
+ }
+ thread->m_stages_history_index= index;
+}
+
+/**
+ Insert a stage record in table EVENTS_STAGES_HISTORY_LONG.
+ @param stage record to insert
+*/
+void insert_events_stages_history_long(PFS_events_stages *stage)
+{
+ if (unlikely(events_stages_history_long_size == 0))
+ return;
+
+ DBUG_ASSERT(events_stages_history_long_array != NULL);
+
+ uint index= PFS_atomic::add_u32(&events_stages_history_long_index.m_u32, 1);
+
+ index= index % events_stages_history_long_size;
+ if (index == 0)
+ events_stages_history_long_full= true;
+
+ /* See related comment in insert_events_stages_history. */
+ copy_events_stages(&events_stages_history_long_array[index], stage);
+}
+
+static void fct_reset_events_stages_current(PFS_thread *pfs)
+{
+ pfs->m_stage_current.m_class= NULL;
+}
+
+/** Reset table EVENTS_STAGES_CURRENT data. */
+void reset_events_stages_current(void)
+{
+ global_thread_container.apply_all(fct_reset_events_stages_current);
+}
+
+static void fct_reset_events_stages_history(PFS_thread *pfs_thread)
+{
+ PFS_events_stages *pfs= pfs_thread->m_stages_history;
+ PFS_events_stages *pfs_last= pfs + events_stages_history_per_thread;
+
+ pfs_thread->m_stages_history_index= 0;
+ pfs_thread->m_stages_history_full= false;
+ for ( ; pfs < pfs_last; pfs++)
+ pfs->m_class= NULL;
+}
+
+/** Reset table EVENTS_STAGES_HISTORY data. */
+void reset_events_stages_history(void)
+{
+ global_thread_container.apply_all(fct_reset_events_stages_history);
+}
+
+/** Reset table EVENTS_STAGES_HISTORY_LONG data. */
+void reset_events_stages_history_long(void)
+{
+ PFS_atomic::store_u32(&events_stages_history_long_index.m_u32, 0);
+ events_stages_history_long_full= false;
+
+ PFS_events_stages *pfs= events_stages_history_long_array;
+ PFS_events_stages *pfs_last= pfs + events_stages_history_long_size;
+ for ( ; pfs < pfs_last; pfs++)
+ pfs->m_class= NULL;
+}
+
+static void fct_reset_events_stages_by_thread(PFS_thread *thread)
+{
+ PFS_account *account= sanitize_account(thread->m_account);
+ PFS_user *user= sanitize_user(thread->m_user);
+ PFS_host *host= sanitize_host(thread->m_host);
+ aggregate_thread_stages(thread, account, user, host);
+}
+
+/** Reset table EVENTS_STAGES_SUMMARY_BY_THREAD_BY_EVENT_NAME data. */
+void reset_events_stages_by_thread()
+{
+ global_thread_container.apply(fct_reset_events_stages_by_thread);
+}
+
+static void fct_reset_events_stages_by_account(PFS_account *pfs)
+{
+ PFS_user *user= sanitize_user(pfs->m_user);
+ PFS_host *host= sanitize_host(pfs->m_host);
+ pfs->aggregate_stages(user, host);
+}
+
+/** Reset table EVENTS_STAGES_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME data. */
+void reset_events_stages_by_account()
+{
+ global_account_container.apply(fct_reset_events_stages_by_account);
+}
+
+static void fct_reset_events_stages_by_user(PFS_user *pfs)
+{
+ pfs->aggregate_stages();
+}
+
+/** Reset table EVENTS_STAGES_SUMMARY_BY_USER_BY_EVENT_NAME data. */
+void reset_events_stages_by_user()
+{
+ global_user_container.apply(fct_reset_events_stages_by_user);
+}
+
+static void fct_reset_events_stages_by_host(PFS_host *pfs)
+{
+ pfs->aggregate_stages();
+}
+
+/** Reset table EVENTS_STAGES_SUMMARY_BY_HOST_BY_EVENT_NAME data. */
+void reset_events_stages_by_host()
+{
+ global_host_container.apply(fct_reset_events_stages_by_host);
+}
+
+/** Reset table EVENTS_STAGES_GLOBAL_BY_EVENT_NAME data. */
+void reset_events_stages_global()
+{
+ PFS_stage_stat *stat= global_instr_class_stages_array;
+ PFS_stage_stat *stat_last= global_instr_class_stages_array + stage_class_max;
+
+ for ( ; stat < stat_last; stat++)
+ stat->reset();
+}
+
diff --git a/storage/perfschema/pfs_events_stages.h b/storage/perfschema/pfs_events_stages.h
new file mode 100644
index 00000000..0b7d27de
--- /dev/null
+++ b/storage/perfschema/pfs_events_stages.h
@@ -0,0 +1,72 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef PFS_EVENTS_STAGES_H
+#define PFS_EVENTS_STAGES_H
+
+/**
+ @file storage/perfschema/pfs_events_stages.h
+ Events waits data structures (declarations).
+*/
+
+#include "pfs_events.h"
+
+struct PFS_thread;
+struct PFS_account;
+struct PFS_user;
+struct PFS_host;
+
+/** A stage record. */
+struct PFS_events_stages : public PFS_events
+{
+ PSI_stage_progress m_progress;
+};
+
+void insert_events_stages_history(PFS_thread *thread, PFS_events_stages *stage);
+void insert_events_stages_history_long(PFS_events_stages *stage);
+
+extern bool flag_events_stages_current;
+extern bool flag_events_stages_history;
+extern bool flag_events_stages_history_long;
+
+extern bool events_stages_history_long_full;
+extern PFS_ALIGNED PFS_cacheline_uint32 events_stages_history_long_index;
+extern PFS_events_stages *events_stages_history_long_array;
+extern ulong events_stages_history_long_size;
+
+int init_events_stages_history_long(uint events_stages_history_long_sizing);
+void cleanup_events_stages_history_long();
+
+void reset_events_stages_current();
+void reset_events_stages_history();
+void reset_events_stages_history_long();
+void reset_events_stages_by_thread();
+void reset_events_stages_by_account();
+void reset_events_stages_by_user();
+void reset_events_stages_by_host();
+void reset_events_stages_global();
+void aggregate_account_stages(PFS_account *account);
+void aggregate_user_stages(PFS_user *user);
+void aggregate_host_stages(PFS_host *host);
+
+#endif
+
diff --git a/storage/perfschema/pfs_events_statements.cc b/storage/perfschema/pfs_events_statements.cc
new file mode 100644
index 00000000..e0f1b2bf
--- /dev/null
+++ b/storage/perfschema/pfs_events_statements.cc
@@ -0,0 +1,329 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/pfs_events_statements.cc
+ Events statements data structures (implementation).
+*/
+
+#include "my_global.h"
+#include "my_sys.h"
+#include "pfs_global.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "pfs_account.h"
+#include "pfs_host.h"
+#include "pfs_user.h"
+#include "pfs_events_statements.h"
+#include "pfs_atomic.h"
+#include "pfs_buffer_container.h"
+#include "pfs_builtin_memory.h"
+#include "m_string.h"
+
+PFS_ALIGNED size_t events_statements_history_long_size= 0;
+/** Consumer flag for table EVENTS_STATEMENTS_CURRENT. */
+PFS_ALIGNED bool flag_events_statements_current= false;
+/** Consumer flag for table EVENTS_STATEMENTS_HISTORY. */
+PFS_ALIGNED bool flag_events_statements_history= false;
+/** Consumer flag for table EVENTS_STATEMENTS_HISTORY_LONG. */
+PFS_ALIGNED bool flag_events_statements_history_long= false;
+
+/** True if EVENTS_STATEMENTS_HISTORY_LONG circular buffer is full. */
+PFS_ALIGNED bool events_statements_history_long_full= false;
+/** Index in EVENTS_STATEMENTS_HISTORY_LONG circular buffer. */
+PFS_ALIGNED PFS_cacheline_uint32 events_statements_history_long_index;
+/** EVENTS_STATEMENTS_HISTORY_LONG circular buffer. */
+PFS_ALIGNED PFS_events_statements *events_statements_history_long_array= NULL;
+static unsigned char *h_long_stmts_digest_token_array= NULL;
+static char *h_long_stmts_text_array= NULL;
+
+/**
+ Initialize table EVENTS_STATEMENTS_HISTORY_LONG.
+ @param events_statements_history_long_sizing table sizing
+*/
+int init_events_statements_history_long(size_t events_statements_history_long_sizing)
+{
+ events_statements_history_long_size= events_statements_history_long_sizing;
+ events_statements_history_long_full= false;
+ PFS_atomic::store_u32(&events_statements_history_long_index.m_u32, 0);
+
+ if (events_statements_history_long_size == 0)
+ return 0;
+
+ events_statements_history_long_array=
+ PFS_MALLOC_ARRAY(& builtin_memory_statements_history_long,
+ events_statements_history_long_size, sizeof(PFS_events_statements),
+ PFS_events_statements, MYF(MY_ZEROFILL));
+
+ if (events_statements_history_long_array == NULL)
+ {
+ cleanup_events_statements_history_long();
+ return 1;
+ }
+
+ if (pfs_max_digest_length > 0)
+ {
+ /* Size of each digest text array. */
+ size_t digest_text_size= pfs_max_digest_length * sizeof(unsigned char);
+
+ h_long_stmts_digest_token_array=
+ PFS_MALLOC_ARRAY(& builtin_memory_statements_history_long_tokens,
+ events_statements_history_long_size, digest_text_size,
+ unsigned char, MYF(MY_ZEROFILL));
+
+ if (h_long_stmts_digest_token_array == NULL)
+ {
+ cleanup_events_statements_history_long();
+ return 1;
+ }
+ }
+
+ if (pfs_max_sqltext > 0)
+ {
+ /* Size of each sql text array. */
+ size_t sqltext_size= pfs_max_sqltext * sizeof(char);
+
+ h_long_stmts_text_array=
+ PFS_MALLOC_ARRAY(& builtin_memory_statements_history_long_sqltext,
+ events_statements_history_long_size, sqltext_size,
+ char, MYF(MY_ZEROFILL));
+
+ if (h_long_stmts_text_array == NULL)
+ {
+ cleanup_events_statements_history_long();
+ return 1;
+ }
+ }
+
+ for (size_t index= 0; index < events_statements_history_long_size; index++)
+ {
+ events_statements_history_long_array[index].m_digest_storage.reset(h_long_stmts_digest_token_array
+ + index * pfs_max_digest_length, pfs_max_digest_length);
+ events_statements_history_long_array[index].m_sqltext= h_long_stmts_text_array + index * pfs_max_sqltext;
+ }
+
+ return 0;
+}
+
+/** Cleanup table EVENTS_STATEMENTS_HISTORY_LONG. */
+void cleanup_events_statements_history_long(void)
+{
+ PFS_FREE_ARRAY(& builtin_memory_statements_history_long,
+ events_statements_history_long_size,
+ sizeof(PFS_events_statements),
+ events_statements_history_long_array);
+
+ PFS_FREE_ARRAY(& builtin_memory_statements_history_long_tokens,
+ events_statements_history_long_size,
+ (pfs_max_digest_length * sizeof(unsigned char)),
+ h_long_stmts_digest_token_array);
+
+ PFS_FREE_ARRAY(& builtin_memory_statements_history_long_sqltext,
+ events_statements_history_long_size,
+ (pfs_max_sqltext * sizeof(char)),
+ h_long_stmts_text_array);
+
+ events_statements_history_long_array= NULL;
+ h_long_stmts_digest_token_array= NULL;
+ h_long_stmts_text_array= NULL;
+}
+
+static inline void copy_events_statements(PFS_events_statements *dest,
+ const PFS_events_statements *source)
+{
+ /* Copy all attributes except SQL TEXT and DIGEST */
+ memcpy(dest, source, my_offsetof(PFS_events_statements, m_sqltext));
+
+ /* Copy SQL TEXT */
+ int sqltext_length= source->m_sqltext_length;
+
+ if (sqltext_length > 0)
+ {
+ memcpy(dest->m_sqltext, source->m_sqltext, sqltext_length);
+ dest->m_sqltext_length= sqltext_length;
+ }
+ else
+ {
+ dest->m_sqltext_length= 0;
+ }
+
+ /* Copy DIGEST */
+ dest->m_digest_storage.copy(& source->m_digest_storage);
+}
+
+/**
+ Insert a statement record in table EVENTS_STATEMENTS_HISTORY.
+ @param thread thread that executed the wait
+ @param statement record to insert
+*/
+void insert_events_statements_history(PFS_thread *thread, PFS_events_statements *statement)
+{
+ if (unlikely(events_statements_history_per_thread == 0))
+ return;
+
+ DBUG_ASSERT(thread->m_statements_history != NULL);
+
+ uint index= thread->m_statements_history_index;
+
+ /*
+ A concurrent thread executing TRUNCATE TABLE EVENTS_STATEMENTS_CURRENT
+ could alter the data that this thread is inserting,
+ causing a potential race condition.
+ We are not testing for this and insert a possibly empty record,
+ to make this thread (the writer) faster.
+ This is ok, the readers of m_statements_history will filter this out.
+ */
+ copy_events_statements(&thread->m_statements_history[index], statement);
+
+ index++;
+ if (index >= events_statements_history_per_thread)
+ {
+ index= 0;
+ thread->m_statements_history_full= true;
+ }
+ thread->m_statements_history_index= index;
+}
+
+/**
+ Insert a statement record in table EVENTS_STATEMENTS_HISTORY_LONG.
+ @param statement record to insert
+*/
+void insert_events_statements_history_long(PFS_events_statements *statement)
+{
+ if (unlikely(events_statements_history_long_size == 0))
+ return ;
+
+ DBUG_ASSERT(events_statements_history_long_array != NULL);
+
+ uint index= PFS_atomic::add_u32(&events_statements_history_long_index.m_u32, 1);
+
+ index= index % events_statements_history_long_size;
+ if (index == 0)
+ events_statements_history_long_full= true;
+
+ /* See related comment in insert_events_statements_history. */
+ copy_events_statements(&events_statements_history_long_array[index], statement);
+}
+
+static void fct_reset_events_statements_current(PFS_thread *pfs_thread)
+{
+ PFS_events_statements *pfs_stmt= & pfs_thread->m_statement_stack[0];
+ PFS_events_statements *pfs_stmt_last= pfs_stmt + statement_stack_max;
+
+ for ( ; pfs_stmt < pfs_stmt_last; pfs_stmt++)
+ pfs_stmt->m_class= NULL;
+}
+
+/** Reset table EVENTS_STATEMENTS_CURRENT data. */
+void reset_events_statements_current(void)
+{
+ global_thread_container.apply_all(fct_reset_events_statements_current);
+}
+
+static void fct_reset_events_statements_history(PFS_thread *pfs_thread)
+{
+ PFS_events_statements *pfs= pfs_thread->m_statements_history;
+ PFS_events_statements *pfs_last= pfs + events_statements_history_per_thread;
+
+ pfs_thread->m_statements_history_index= 0;
+ pfs_thread->m_statements_history_full= false;
+ for ( ; pfs < pfs_last; pfs++)
+ pfs->m_class= NULL;
+}
+
+/** Reset table EVENTS_STATEMENTS_HISTORY data. */
+void reset_events_statements_history(void)
+{
+ global_thread_container.apply_all(fct_reset_events_statements_history);
+}
+
+/** Reset table EVENTS_STATEMENTS_HISTORY_LONG data. */
+void reset_events_statements_history_long(void)
+{
+ PFS_atomic::store_u32(&events_statements_history_long_index.m_u32, 0);
+ events_statements_history_long_full= false;
+
+ PFS_events_statements *pfs= events_statements_history_long_array;
+ PFS_events_statements *pfs_last= pfs + events_statements_history_long_size;
+ for ( ; pfs < pfs_last; pfs++)
+ pfs->m_class= NULL;
+}
+
+static void fct_reset_events_statements_by_thread(PFS_thread *thread)
+{
+ PFS_account *account= sanitize_account(thread->m_account);
+ PFS_user *user= sanitize_user(thread->m_user);
+ PFS_host *host= sanitize_host(thread->m_host);
+ aggregate_thread_statements(thread, account, user, host);
+}
+
+/** Reset table EVENTS_STATEMENTS_SUMMARY_BY_THREAD_BY_EVENT_NAME data. */
+void reset_events_statements_by_thread()
+{
+ global_thread_container.apply(fct_reset_events_statements_by_thread);
+}
+
+static void fct_reset_events_statements_by_account(PFS_account *pfs)
+{
+ PFS_user *user= sanitize_user(pfs->m_user);
+ PFS_host *host= sanitize_host(pfs->m_host);
+ pfs->aggregate_statements(user, host);
+}
+
+/** Reset table EVENTS_STATEMENTS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME data. */
+void reset_events_statements_by_account()
+{
+ global_account_container.apply(fct_reset_events_statements_by_account);
+}
+
+static void fct_reset_events_statements_by_user(PFS_user *pfs)
+{
+ pfs->aggregate_statements();
+}
+
+/** Reset table EVENTS_STATEMENTS_SUMMARY_BY_USER_BY_EVENT_NAME data. */
+void reset_events_statements_by_user()
+{
+ global_user_container.apply(fct_reset_events_statements_by_user);
+}
+
+static void fct_reset_events_statements_by_host(PFS_host *pfs)
+{
+ pfs->aggregate_statements();
+}
+
+/** Reset table EVENTS_STATEMENTS_SUMMARY_BY_HOST_BY_EVENT_NAME data. */
+void reset_events_statements_by_host()
+{
+ global_host_container.apply(fct_reset_events_statements_by_host);
+}
+
+/** Reset table EVENTS_STATEMENTS_GLOBAL_BY_EVENT_NAME data. */
+void reset_events_statements_global()
+{
+ PFS_statement_stat *stat= global_instr_class_statements_array;
+ PFS_statement_stat *stat_last= global_instr_class_statements_array + statement_class_max;
+
+ for ( ; stat < stat_last; stat++)
+ stat->reset();
+}
+
diff --git a/storage/perfschema/pfs_events_statements.h b/storage/perfschema/pfs_events_statements.h
new file mode 100644
index 00000000..8b24a9e7
--- /dev/null
+++ b/storage/perfschema/pfs_events_statements.h
@@ -0,0 +1,152 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef PFS_EVENTS_STATEMENTS_H
+#define PFS_EVENTS_STATEMENTS_H
+
+/**
+ @file storage/perfschema/pfs_events_statements.h
+ Events statements data structures (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_events.h"
+#include "pfs_digest.h"
+
+struct PFS_thread;
+struct PFS_account;
+struct PFS_user;
+struct PFS_host;
+
+/** A statement record. */
+struct PFS_events_statements : public PFS_events
+{
+ enum_object_type m_sp_type;
+ char m_schema_name[NAME_LEN];
+ uint m_schema_name_length;
+ char m_object_name[NAME_LEN];
+ uint m_object_name_length;
+
+ /** Database name. */
+ char m_current_schema_name[NAME_LEN];
+ /** Length of @c m_current_schema_name. */
+ uint m_current_schema_name_length;
+
+ /** Locked time. */
+ ulonglong m_lock_time;
+
+ /** Diagnostics area, message text. */
+ char m_message_text[MYSQL_ERRMSG_SIZE+1];
+ /** Diagnostics area, error number. */
+ uint m_sql_errno;
+ /** Diagnostics area, SQLSTATE. */
+ char m_sqlstate[SQLSTATE_LENGTH];
+ /** Diagnostics area, error count. */
+ uint m_error_count;
+ /** Diagnostics area, warning count. */
+ uint m_warning_count;
+ /** Diagnostics area, rows affected. */
+ ulonglong m_rows_affected;
+
+ /** Optimizer metric, number of rows sent. */
+ ulonglong m_rows_sent;
+ /** Optimizer metric, number of rows examined. */
+ ulonglong m_rows_examined;
+ /** Optimizer metric, number of temporary tables created on disk. */
+ ulonglong m_created_tmp_disk_tables;
+ /** Optimizer metric, number of temporary tables created. */
+ ulonglong m_created_tmp_tables;
+ /** Optimizer metric, number of full join. */
+ ulonglong m_select_full_join;
+ /** Optimizer metric, number of full range join. */
+ ulonglong m_select_full_range_join;
+ /** Optimizer metric, number of select range. */
+ ulonglong m_select_range;
+ /** Optimizer metric, number of select range checks. */
+ ulonglong m_select_range_check;
+ /** Optimizer metric, number of select scans. */
+ ulonglong m_select_scan;
+ /** Optimizer metric, number of sort merge passes. */
+ ulonglong m_sort_merge_passes;
+ /** Optimizer metric, number of sort ranges. */
+ ulonglong m_sort_range;
+ /** Optimizer metric, number of sort rows. */
+ ulonglong m_sort_rows;
+ /** Optimizer metric, number of sort scans. */
+ ulonglong m_sort_scan;
+ /** Optimizer metric, number of 'no index used'. */
+ ulonglong m_no_index_used;
+ /** Optimizer metric, number of 'no good index used'. */
+ ulonglong m_no_good_index_used;
+
+ /** True if sqltext was truncated. */
+ bool m_sqltext_truncated;
+ /** Statement character set number. */
+ uint m_sqltext_cs_number;
+
+ /**
+ SQL_TEXT.
+ This pointer is immutable,
+ and always point to pre allocated memory.
+ */
+ char *m_sqltext;
+ /** Length of @ m_info. */
+ uint m_sqltext_length;
+ /**
+ Statement digest.
+ This underlying token array storage pointer is immutable,
+ and always point to pre allocated memory.
+ */
+ sql_digest_storage m_digest_storage;
+};
+
+void insert_events_statements_history(PFS_thread *thread, PFS_events_statements *statement);
+void insert_events_statements_history_long(PFS_events_statements *statement);
+
+extern ulong nested_statement_lost;
+
+extern bool flag_events_statements_current;
+extern bool flag_events_statements_history;
+extern bool flag_events_statements_history_long;
+
+extern bool events_statements_history_long_full;
+extern PFS_ALIGNED PFS_cacheline_uint32 events_statements_history_long_index;
+extern PFS_events_statements *events_statements_history_long_array;
+extern size_t events_statements_history_long_size;
+
+int init_events_statements_history_long(size_t events_statements_history_long_sizing);
+void cleanup_events_statements_history_long();
+
+void reset_events_statements_current();
+void reset_events_statements_history();
+void reset_events_statements_history_long();
+void reset_events_statements_by_thread();
+void reset_events_statements_by_account();
+void reset_events_statements_by_user();
+void reset_events_statements_by_host();
+void reset_events_statements_global();
+void aggregate_account_statements(PFS_account *account);
+void aggregate_user_statements(PFS_user *user);
+void aggregate_host_statements(PFS_host *host);
+
+#endif
+
diff --git a/storage/perfschema/pfs_events_transactions.cc b/storage/perfschema/pfs_events_transactions.cc
new file mode 100644
index 00000000..88423491
--- /dev/null
+++ b/storage/perfschema/pfs_events_transactions.cc
@@ -0,0 +1,267 @@
+/* Copyright (c) 2013, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/pfs_events_transactions.cc
+ Events transactions data structures (implementation).
+*/
+
+#include "my_global.h"
+#include "my_sys.h"
+#include "pfs_global.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "pfs_account.h"
+#include "pfs_host.h"
+#include "pfs_user.h"
+#include "pfs_events_transactions.h"
+#include "pfs_atomic.h"
+#include "pfs_buffer_container.h"
+#include "pfs_builtin_memory.h"
+#include "m_string.h"
+
+PFS_ALIGNED ulong events_transactions_history_long_size= 0;
+/** Consumer flag for table EVENTS_TRANSACTIONS_CURRENT. */
+PFS_ALIGNED bool flag_events_transactions_current= false;
+/** Consumer flag for table EVENTS_TRANSACTIONS_HISTORY. */
+PFS_ALIGNED bool flag_events_transactions_history= false;
+/** Consumer flag for table EVENTS_TRANSACTIONS_HISTORY_LONG. */
+PFS_ALIGNED bool flag_events_transactions_history_long= false;
+
+/** True if EVENTS_TRANSACTIONS_HISTORY_LONG circular buffer is full. */
+PFS_ALIGNED bool events_transactions_history_long_full= false;
+/** Index in EVENTS_TRANSACTIONS_HISTORY_LONG circular buffer. */
+PFS_ALIGNED PFS_cacheline_uint32 events_transactions_history_long_index;
+/** EVENTS_TRANSACTIONS_HISTORY_LONG circular buffer. */
+PFS_ALIGNED PFS_events_transactions *events_transactions_history_long_array= NULL;
+
+/**
+ Initialize table EVENTS_TRANSACTIONS_HISTORY_LONG.
+ @param events_transactions_history_long_sizing table sizing
+*/
+int init_events_transactions_history_long(uint events_transactions_history_long_sizing)
+{
+ events_transactions_history_long_size= events_transactions_history_long_sizing;
+ events_transactions_history_long_full= false;
+ PFS_atomic::store_u32(&events_transactions_history_long_index.m_u32, 0);
+
+ if (events_transactions_history_long_size == 0)
+ return 0;
+
+ events_transactions_history_long_array=
+ PFS_MALLOC_ARRAY(& builtin_memory_transactions_history_long,
+ events_transactions_history_long_size,
+ sizeof(PFS_events_transactions), PFS_events_transactions,
+ MYF(MY_ZEROFILL));
+
+ return (events_transactions_history_long_array ? 0 : 1);
+}
+
+/** Cleanup table EVENTS_TRANSACTIONS_HISTORY_LONG. */
+void cleanup_events_transactions_history_long(void)
+{
+ PFS_FREE_ARRAY(& builtin_memory_transactions_history_long,
+ events_transactions_history_long_size, sizeof(PFS_events_transactions),
+ events_transactions_history_long_array);
+ events_transactions_history_long_array= NULL;
+}
+
+static inline void copy_events_transactions(PFS_events_transactions *dest,
+ const PFS_events_transactions *source)
+{
+ memcpy(dest, source, sizeof(PFS_events_transactions));
+}
+
+/**
+ Insert a transaction record in table EVENTS_TRANSACTIONS_HISTORY.
+ @param thread thread that executed the wait
+ @param transaction record to insert
+*/
+void insert_events_transactions_history(PFS_thread *thread, PFS_events_transactions *transaction)
+{
+ if (unlikely(events_transactions_history_per_thread == 0))
+ return;
+
+ DBUG_ASSERT(thread->m_transactions_history != NULL);
+
+ uint index= thread->m_transactions_history_index;
+
+ /*
+ A concurrent thread executing TRUNCATE TABLE EVENTS_TRANSACTIONS_CURRENT
+ could alter the data that this thread is inserting,
+ causing a potential race condition.
+ We are not testing for this and insert a possibly empty record,
+ to make this thread (the writer) faster.
+ This is ok, the readers of m_transactions_history will filter this out.
+ */
+ copy_events_transactions(&thread->m_transactions_history[index], transaction);
+
+ index++;
+ if (index >= events_transactions_history_per_thread)
+ {
+ index= 0;
+ thread->m_transactions_history_full= true;
+ }
+ thread->m_transactions_history_index= index;
+}
+
+/**
+ Insert a transaction record in table EVENTS_TRANSACTIONS_HISTORY_LONG.
+ @param transaction record to insert
+*/
+void insert_events_transactions_history_long(PFS_events_transactions *transaction)
+{
+ if (unlikely(events_transactions_history_long_size == 0))
+ return ;
+
+ DBUG_ASSERT(events_transactions_history_long_array != NULL);
+
+ uint index= PFS_atomic::add_u32(&events_transactions_history_long_index.m_u32, 1);
+
+ index= index % events_transactions_history_long_size;
+ if (index == 0)
+ events_transactions_history_long_full= true;
+
+ /* See related comment in insert_events_transactions_history. */
+ copy_events_transactions(&events_transactions_history_long_array[index], transaction);
+}
+
+static void fct_reset_events_transactions_current(PFS_thread *pfs)
+{
+ pfs->m_transaction_current.m_class= NULL;
+}
+
+/** Reset table EVENTS_TRANSACTIONS_CURRENT data. */
+void reset_events_transactions_current(void)
+{
+ global_thread_container.apply_all(fct_reset_events_transactions_current);
+}
+
+static void fct_reset_events_transactions_history(PFS_thread *pfs_thread)
+{
+ PFS_events_transactions *pfs= pfs_thread->m_transactions_history;
+ PFS_events_transactions *pfs_last= pfs + events_transactions_history_per_thread;
+
+ pfs_thread->m_transactions_history_index= 0;
+ pfs_thread->m_transactions_history_full= false;
+ for ( ; pfs < pfs_last; pfs++)
+ pfs->m_class= NULL;
+}
+
+/** Reset table EVENTS_TRANSACTIONS_HISTORY data. */
+void reset_events_transactions_history(void)
+{
+ global_thread_container.apply_all(fct_reset_events_transactions_history);
+}
+
+/** Reset table EVENTS_TRANSACTIONS_HISTORY_LONG data. */
+void reset_events_transactions_history_long(void)
+{
+ PFS_atomic::store_u32(&events_transactions_history_long_index.m_u32, 0);
+ events_transactions_history_long_full= false;
+
+ PFS_events_transactions *pfs= events_transactions_history_long_array;
+ PFS_events_transactions *pfs_last= pfs + events_transactions_history_long_size;
+ for ( ; pfs < pfs_last; pfs++)
+ pfs->m_class= NULL;
+}
+
+static void fct_reset_events_transactions_by_thread(PFS_thread *thread)
+{
+ PFS_account *account= sanitize_account(thread->m_account);
+ PFS_user *user= sanitize_user(thread->m_user);
+ PFS_host *host= sanitize_host(thread->m_host);
+ aggregate_thread_transactions(thread, account, user, host);
+}
+
+/** Reset table EVENTS_TRANSACTIONS_SUMMARY_BY_THREAD_BY_EVENT_NAME data. */
+void reset_events_transactions_by_thread()
+{
+ global_thread_container.apply(fct_reset_events_transactions_by_thread);
+}
+
+static void fct_reset_events_transactions_by_account(PFS_account *pfs)
+{
+ PFS_user *user= sanitize_user(pfs->m_user);
+ PFS_host *host= sanitize_host(pfs->m_host);
+ pfs->aggregate_transactions(user, host);
+}
+
+/** Reset table EVENTS_TRANSACTIONS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME data. */
+void reset_events_transactions_by_account()
+{
+ global_account_container.apply(fct_reset_events_transactions_by_account);
+}
+
+static void fct_reset_events_transactions_by_user(PFS_user *pfs)
+{
+ pfs->aggregate_transactions();
+}
+
+/** Reset table EVENTS_TRANSACTIONS_SUMMARY_BY_USER_BY_EVENT_NAME data. */
+void reset_events_transactions_by_user()
+{
+ global_user_container.apply(fct_reset_events_transactions_by_user);
+}
+
+static void fct_reset_events_transactions_by_host(PFS_host *pfs)
+{
+ pfs->aggregate_transactions();
+}
+
+/** Reset table EVENTS_TRANSACTIONS_SUMMARY_BY_HOST_BY_EVENT_NAME data. */
+void reset_events_transactions_by_host()
+{
+ global_host_container.apply(fct_reset_events_transactions_by_host);
+}
+
+/** Reset table EVENTS_TRANSACTIONS_GLOBAL_BY_EVENT_NAME data. */
+void reset_events_transactions_global()
+{
+ global_transaction_stat.reset();
+}
+
+/**
+ Check if the XID consists of printable characters, ASCII 32 - 127.
+ @param xid XID structure
+ @param offset offset into XID.data[]
+ @param length number of bytes to process
+ @return true if all bytes are in printable range
+*/
+bool xid_printable(PSI_xid *xid, size_t offset, size_t length)
+{
+ if (xid->is_null())
+ return false;
+
+ DBUG_ASSERT(offset + length <= MYSQL_XIDDATASIZE);
+
+ unsigned char *c= (unsigned char*)&xid->data + offset;
+
+ for (size_t i= 0; i < length; i++, c++)
+ {
+ if(*c < 32 || *c > 127)
+ return false;
+ }
+
+ return true;
+}
+
diff --git a/storage/perfschema/pfs_events_transactions.h b/storage/perfschema/pfs_events_transactions.h
new file mode 100644
index 00000000..dc4fd8b0
--- /dev/null
+++ b/storage/perfschema/pfs_events_transactions.h
@@ -0,0 +1,132 @@
+/* Copyright (c) 2013, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
+
+#ifndef PFS_EVENTS_TRANSACTIONS_H
+#define PFS_EVENTS_TRANSACTIONS_H
+
+/**
+ @file storage/perfschema/pfs_events_transactions.h
+ Events transactions data structures (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_events.h"
+#include "rpl_gtid.h"
+#include "mysql/plugin.h" /* MYSQL_XIDDATASIZE */
+#include "my_thread.h"
+
+struct PFS_thread;
+struct PFS_account;
+struct PFS_user;
+struct PFS_host;
+
+/**
+ struct PSI_xid is binary compatible with the XID structure as
+ in the X/Open CAE Specification, Distributed Transaction Processing:
+ The XA Specification, X/Open Company Ltd., 1991.
+ http://www.opengroup.org/bookstore/catalog/c193.htm
+
+ A value of -1 in formatID means that the XID is null.
+ Max length for bqual and gtrid is 64 bytes each.
+
+ @see XID in sql/handler.h
+ @see MYSQL_XID in mysql/plugin.h
+*/
+struct PSI_xid
+{
+ /** Format identifier. */
+ long formatID;
+ /** GTRID length, value 1-64. */
+ long gtrid_length;
+ /** BQUAL length, value 1-64. */
+ long bqual_length;
+ /** XID raw data, not \0-terminated */
+ char data[MYSQL_XIDDATASIZE];
+
+ PSI_xid() {null();}
+ bool is_null() { return formatID == -1; }
+ void null() { formatID= -1; gtrid_length= 0; bqual_length= 0;}
+};
+typedef struct PSI_xid PSI_xid;
+
+/** A transaction record. */
+struct PFS_events_transactions : public PFS_events
+{
+ /** Source identifier, mapped from internal format. */
+ //rpl_sid m_sid;
+ /** InnoDB transaction ID. */
+ ulonglong m_trxid;
+ /** Status */
+ enum_transaction_state m_state;
+ /** Global Transaction ID specifier. */
+ Gtid_specification m_gtid_spec;
+ /** True if XA transaction. */
+ my_bool m_xa;
+ /** XA transaction ID. */
+ PSI_xid m_xid;
+ /** XA status */
+ enum_xa_transaction_state m_xa_state;
+ /** Transaction isolation level. */
+ enum_isolation_level m_isolation_level;
+ /** True if read-only transaction, otherwise read-write. */
+ my_bool m_read_only;
+ /** True if autocommit transaction. */
+ my_bool m_autocommit;
+ /** Total number of savepoints. */
+ ulonglong m_savepoint_count;
+ /** Number of rollback_to_savepoint. */
+ ulonglong m_rollback_to_savepoint_count;
+ /** Number of release_savepoint. */
+ ulonglong m_release_savepoint_count;
+};
+
+bool xid_printable(PSI_xid *xid, size_t offset, size_t length);
+
+void insert_events_transactions_history(PFS_thread *thread, PFS_events_transactions *transaction);
+void insert_events_transactions_history_long(PFS_events_transactions *transaction);
+
+extern bool flag_events_transactions_current;
+extern bool flag_events_transactions_history;
+extern bool flag_events_transactions_history_long;
+
+extern bool events_transactions_history_long_full;
+extern PFS_cacheline_uint32 events_transactions_history_long_index;
+extern PFS_events_transactions *events_transactions_history_long_array;
+extern ulong events_transactions_history_long_size;
+
+int init_events_transactions_history_long(uint events_transactions_history_long_sizing);
+void cleanup_events_transactions_history_long();
+
+void reset_events_transactions_current();
+void reset_events_transactions_history();
+void reset_events_transactions_history_long();
+void reset_events_transactions_by_thread();
+void reset_events_transactions_by_account();
+void reset_events_transactions_by_user();
+void reset_events_transactions_by_host();
+void reset_events_transactions_global();
+void aggregate_account_transactions(PFS_account *account);
+void aggregate_user_transactions(PFS_user *user);
+void aggregate_host_transactions(PFS_host *host);
+
+#endif
+
diff --git a/storage/perfschema/pfs_events_waits.cc b/storage/perfschema/pfs_events_waits.cc
new file mode 100644
index 00000000..b51ee5fd
--- /dev/null
+++ b/storage/perfschema/pfs_events_waits.cc
@@ -0,0 +1,301 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/pfs_events_waits.cc
+ Events waits data structures (implementation).
+*/
+
+#include "my_global.h"
+#include "my_sys.h"
+#include "pfs_global.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "pfs_user.h"
+#include "pfs_host.h"
+#include "pfs_account.h"
+#include "pfs_events_waits.h"
+#include "pfs_atomic.h"
+#include "pfs_buffer_container.h"
+#include "pfs_builtin_memory.h"
+#include "m_string.h"
+
+PFS_ALIGNED ulong events_waits_history_long_size= 0;
+/** Consumer flag for table EVENTS_WAITS_CURRENT. */
+PFS_ALIGNED bool flag_events_waits_current= false;
+/** Consumer flag for table EVENTS_WAITS_HISTORY. */
+PFS_ALIGNED bool flag_events_waits_history= false;
+/** Consumer flag for table EVENTS_WAITS_HISTORY_LONG. */
+PFS_ALIGNED bool flag_events_waits_history_long= false;
+/** Consumer flag for the global instrumentation. */
+PFS_ALIGNED bool flag_global_instrumentation= false;
+/** Consumer flag for the per thread instrumentation. */
+PFS_ALIGNED bool flag_thread_instrumentation= false;
+
+/** True if EVENTS_WAITS_HISTORY_LONG circular buffer is full. */
+PFS_ALIGNED bool events_waits_history_long_full= false;
+/** Index in EVENTS_WAITS_HISTORY_LONG circular buffer. */
+PFS_ALIGNED PFS_cacheline_uint32 events_waits_history_long_index;
+/** EVENTS_WAITS_HISTORY_LONG circular buffer. */
+PFS_ALIGNED PFS_events_waits *events_waits_history_long_array= NULL;
+
+/**
+ Initialize table EVENTS_WAITS_HISTORY_LONG.
+ @param events_waits_history_long_sizing table sizing
+*/
+int init_events_waits_history_long(uint events_waits_history_long_sizing)
+{
+ events_waits_history_long_size= events_waits_history_long_sizing;
+ events_waits_history_long_full= false;
+ PFS_atomic::store_u32(&events_waits_history_long_index.m_u32, 0);
+
+ if (events_waits_history_long_size == 0)
+ return 0;
+
+ events_waits_history_long_array=
+ PFS_MALLOC_ARRAY(& builtin_memory_waits_history_long,
+ events_waits_history_long_size,
+ sizeof(PFS_events_waits), PFS_events_waits,
+ MYF(MY_ZEROFILL));
+
+ return (events_waits_history_long_array ? 0 : 1);
+}
+
+/** Cleanup table EVENTS_WAITS_HISTORY_LONG. */
+void cleanup_events_waits_history_long(void)
+{
+ PFS_FREE_ARRAY(& builtin_memory_waits_history_long,
+ events_waits_history_long_size, sizeof(PFS_events_waits),
+ events_waits_history_long_array);
+ events_waits_history_long_array= NULL;
+}
+
+static inline void copy_events_waits(PFS_events_waits *dest,
+ const PFS_events_waits *source)
+{
+ memcpy(dest, source, sizeof(PFS_events_waits));
+}
+
+/**
+ Insert a wait record in table EVENTS_WAITS_HISTORY.
+ @param thread thread that executed the wait
+ @param wait record to insert
+*/
+void insert_events_waits_history(PFS_thread *thread, PFS_events_waits *wait)
+{
+ if (unlikely(events_waits_history_per_thread == 0))
+ return;
+
+ uint index= thread->m_waits_history_index;
+
+ /*
+ A concurrent thread executing TRUNCATE TABLE EVENTS_WAITS_CURRENT
+ could alter the data that this thread is inserting,
+ causing a potential race condition.
+ We are not testing for this and insert a possibly empty record,
+ to make this thread (the writer) faster.
+ This is ok, the readers of m_waits_history will filter this out.
+ */
+ copy_events_waits(&thread->m_waits_history[index], wait);
+
+ index++;
+ if (index >= events_waits_history_per_thread)
+ {
+ index= 0;
+ thread->m_waits_history_full= true;
+ }
+ thread->m_waits_history_index= index;
+}
+
+/**
+ Insert a wait record in table EVENTS_WAITS_HISTORY_LONG.
+ @param wait record to insert
+*/
+void insert_events_waits_history_long(PFS_events_waits *wait)
+{
+ if (unlikely(events_waits_history_long_size == 0))
+ return;
+
+ uint index= PFS_atomic::add_u32(&events_waits_history_long_index.m_u32, 1);
+
+ index= index % events_waits_history_long_size;
+ if (index == 0)
+ events_waits_history_long_full= true;
+
+ /* See related comment in insert_events_waits_history. */
+ copy_events_waits(&events_waits_history_long_array[index], wait);
+}
+
+static void fct_reset_events_waits_current(PFS_thread *pfs_thread)
+{
+ PFS_events_waits *pfs_wait= pfs_thread->m_events_waits_stack;
+ PFS_events_waits *pfs_wait_last= pfs_wait + WAIT_STACK_SIZE;
+
+ for ( ; pfs_wait < pfs_wait_last; pfs_wait++)
+ pfs_wait->m_wait_class= NO_WAIT_CLASS;
+}
+
+
+/** Reset table EVENTS_WAITS_CURRENT data. */
+void reset_events_waits_current(void)
+{
+ global_thread_container.apply_all(fct_reset_events_waits_current);
+}
+
+static void fct_reset_events_waits_history(PFS_thread *pfs_thread)
+{
+ PFS_events_waits *wait= pfs_thread->m_waits_history;
+ PFS_events_waits *wait_last= wait + events_waits_history_per_thread;
+
+ pfs_thread->m_waits_history_index= 0;
+ pfs_thread->m_waits_history_full= false;
+ for ( ; wait < wait_last; wait++)
+ wait->m_wait_class= NO_WAIT_CLASS;
+}
+
+/** Reset table EVENTS_WAITS_HISTORY data. */
+void reset_events_waits_history(void)
+{
+ global_thread_container.apply_all(fct_reset_events_waits_history);
+}
+
+/** Reset table EVENTS_WAITS_HISTORY_LONG data. */
+void reset_events_waits_history_long(void)
+{
+ PFS_atomic::store_u32(&events_waits_history_long_index.m_u32, 0);
+ events_waits_history_long_full= false;
+
+ PFS_events_waits *wait= events_waits_history_long_array;
+ PFS_events_waits *wait_last= wait + events_waits_history_long_size;
+ for ( ; wait < wait_last; wait++)
+ wait->m_wait_class= NO_WAIT_CLASS;
+}
+
+static void fct_reset_events_waits_by_thread(PFS_thread *thread)
+{
+ PFS_account *account= sanitize_account(thread->m_account);
+ PFS_user *user= sanitize_user(thread->m_user);
+ PFS_host *host= sanitize_host(thread->m_host);
+ aggregate_thread_waits(thread, account, user, host);
+}
+
+/** Reset table EVENTS_WAITS_SUMMARY_BY_THREAD_BY_EVENT_NAME data. */
+void reset_events_waits_by_thread()
+{
+ global_thread_container.apply(fct_reset_events_waits_by_thread);
+}
+
+static void fct_reset_events_waits_by_account(PFS_account *pfs)
+{
+ PFS_user *user= sanitize_user(pfs->m_user);
+ PFS_host *host= sanitize_host(pfs->m_host);
+ pfs->aggregate_waits(user, host);
+}
+
+/** Reset table EVENTS_WAITS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME data. */
+void reset_events_waits_by_account()
+{
+ global_account_container.apply(fct_reset_events_waits_by_account);
+}
+
+static void fct_reset_events_waits_by_user(PFS_user *pfs)
+{
+ pfs->aggregate_waits();
+}
+
+/** Reset table EVENTS_WAITS_SUMMARY_BY_USER_BY_EVENT_NAME data. */
+void reset_events_waits_by_user()
+{
+ global_user_container.apply(fct_reset_events_waits_by_user);
+}
+
+static void fct_reset_events_waits_by_host(PFS_host *pfs)
+{
+ pfs->aggregate_waits();
+}
+
+/** Reset table EVENTS_WAITS_SUMMARY_BY_HOST_BY_EVENT_NAME data. */
+void reset_events_waits_by_host()
+{
+ global_host_container.apply(fct_reset_events_waits_by_host);
+}
+
+static void fct_reset_table_waits_by_table(PFS_table_share *pfs)
+{
+ pfs->aggregate();
+}
+
+void reset_table_waits_by_table()
+{
+ global_table_share_container.apply(fct_reset_table_waits_by_table);
+}
+
+static void fct_reset_table_io_waits_by_table(PFS_table_share *pfs)
+{
+ pfs->aggregate_io();
+}
+
+void reset_table_io_waits_by_table()
+{
+ global_table_share_container.apply(fct_reset_table_io_waits_by_table);
+}
+
+static void fct_reset_table_lock_waits_by_table(PFS_table_share *pfs)
+{
+ pfs->aggregate_lock();
+}
+
+void reset_table_lock_waits_by_table()
+{
+ global_table_share_container.apply(fct_reset_table_lock_waits_by_table);
+}
+
+void fct_reset_table_waits_by_table_handle(PFS_table *pfs)
+{
+ pfs->sanitized_aggregate();
+}
+
+void reset_table_waits_by_table_handle()
+{
+ global_table_container.apply(fct_reset_table_waits_by_table_handle);
+}
+
+void fct_reset_table_io_waits_by_table_handle(PFS_table *pfs)
+{
+ pfs->sanitized_aggregate_io();
+}
+
+void reset_table_io_waits_by_table_handle()
+{
+ global_table_container.apply(fct_reset_table_io_waits_by_table_handle);
+}
+
+void fct_reset_table_lock_waits_by_table_handle(PFS_table *pfs)
+{
+ pfs->sanitized_aggregate_lock();
+}
+
+void reset_table_lock_waits_by_table_handle()
+{
+ global_table_container.apply(fct_reset_table_lock_waits_by_table_handle);
+}
+
diff --git a/storage/perfschema/pfs_events_waits.h b/storage/perfschema/pfs_events_waits.h
new file mode 100644
index 00000000..87e43459
--- /dev/null
+++ b/storage/perfschema/pfs_events_waits.h
@@ -0,0 +1,157 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+ Copyright (c) 2017, 2019, MariaDB Corporation.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef PFS_EVENTS_WAITS_H
+#define PFS_EVENTS_WAITS_H
+
+/**
+ @file storage/perfschema/pfs_events_waits.h
+ Events waits data structures (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_lock.h"
+#include "pfs_events.h"
+
+struct PFS_mutex;
+struct PFS_rwlock;
+struct PFS_cond;
+struct PFS_table;
+struct PFS_file;
+struct PFS_thread;
+struct PFS_socket;
+struct PFS_instr_class;
+struct PFS_table_share;
+struct PFS_account;
+struct PFS_user;
+struct PFS_host;
+struct PFS_metadata_lock;
+
+/** Class of a wait event. */
+enum events_waits_class
+{
+ NO_WAIT_CLASS= 0,
+ WAIT_CLASS_MUTEX,
+ WAIT_CLASS_RWLOCK,
+ WAIT_CLASS_COND,
+ WAIT_CLASS_TABLE,
+ WAIT_CLASS_FILE,
+ WAIT_CLASS_SOCKET,
+ WAIT_CLASS_IDLE,
+ WAIT_CLASS_METADATA
+};
+
+/** A wait event record. */
+struct PFS_events_waits : public PFS_events
+{
+ /**
+ The type of wait.
+ Readers:
+ - the consumer threads.
+ Writers:
+ - the producer threads, in the instrumentation.
+ Out of bound Writers:
+ - TRUNCATE EVENTS_WAITS_CURRENT
+ - TRUNCATE EVENTS_WAITS_HISTORY
+ - TRUNCATE EVENTS_WAITS_HISTORY_LONG
+ */
+ events_waits_class m_wait_class;
+ /** Object type */
+ enum_object_type m_object_type;
+ /** Table share, for table operations only. */
+ PFS_table_share *m_weak_table_share;
+ /** File, for file operations only. */
+ PFS_file *m_weak_file;
+ /** Socket, for socket operations only. */
+ PFS_socket *m_weak_socket;
+ /** Metadata lock, for mdl operations only. */
+ PFS_metadata_lock *m_weak_metadata_lock;
+ /** For weak pointers, target object version. */
+ uint32 m_weak_version;
+ /** Address in memory of the object instance waited on. */
+ const void *m_object_instance_addr;
+ /** Operation performed. */
+ enum_operation_type m_operation;
+ /**
+ Number of bytes/rows read/written.
+ This member is populated for FILE READ/WRITE operations, with a number of bytes.
+ This member is populated for TABLE IO operations, with a number of rows.
+ */
+ size_t m_number_of_bytes;
+ /**
+ Index used.
+ This member is populated for TABLE IO operations only.
+ */
+ uint m_index;
+ /** Flags */
+ ulong m_flags;
+};
+
+/** TIMED bit in the state flags bitfield. */
+#define STATE_FLAG_TIMED (1U<<0)
+/** THREAD bit in the state flags bitfield. */
+#define STATE_FLAG_THREAD (1U<<1)
+/** EVENT bit in the state flags bitfield. */
+#define STATE_FLAG_EVENT (1U<<2)
+/** DIGEST bit in the state flags bitfield. */
+#define STATE_FLAG_DIGEST (1U<<3)
+
+void insert_events_waits_history(PFS_thread *thread, PFS_events_waits *wait);
+
+void insert_events_waits_history_long(PFS_events_waits *wait);
+
+extern bool flag_events_waits_current;
+extern bool flag_events_waits_history;
+extern bool flag_events_waits_history_long;
+extern bool flag_global_instrumentation;
+extern bool flag_thread_instrumentation;
+
+extern bool events_waits_history_long_full;
+extern PFS_ALIGNED PFS_cacheline_uint32 events_waits_history_long_index;
+extern PFS_events_waits *events_waits_history_long_array;
+extern ulong events_waits_history_long_size;
+
+int init_events_waits_history_long(uint events_waits_history_long_sizing);
+void cleanup_events_waits_history_long();
+
+void reset_events_waits_current();
+void reset_events_waits_history();
+void reset_events_waits_history_long();
+void reset_events_waits_by_thread();
+void reset_events_waits_by_account();
+void reset_events_waits_by_user();
+void reset_events_waits_by_host();
+void reset_events_waits_global();
+void aggregate_account_waits(PFS_account *account);
+void aggregate_user_waits(PFS_user *user);
+void aggregate_host_waits(PFS_host *host);
+
+void reset_table_waits_by_table();
+void reset_table_io_waits_by_table();
+void reset_table_lock_waits_by_table();
+void reset_table_waits_by_table_handle();
+void reset_table_io_waits_by_table_handle();
+void reset_table_lock_waits_by_table_handle();
+
+#endif
+
diff --git a/storage/perfschema/pfs_global.cc b/storage/perfschema/pfs_global.cc
new file mode 100644
index 00000000..26cb693d
--- /dev/null
+++ b/storage/perfschema/pfs_global.cc
@@ -0,0 +1,267 @@
+/* Copyright (c) 2008, 2017, Oracle and/or its affiliates. All rights
+ reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/pfs_global.cc
+ Miscellaneous global dependencies (implementation).
+*/
+
+#include <my_global.h>
+#include "pfs_global.h"
+#include "pfs_builtin_memory.h"
+#include "log.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#ifdef _WIN32
+#include <winsock2.h>
+#endif
+#ifdef HAVE_ARPA_INET_H
+#include <arpa/inet.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+#ifdef HAVE_MALLOC_H
+#include <malloc.h>
+#endif
+
+bool pfs_initialized= false;
+
+/**
+ Memory allocation for the performance schema.
+ The memory used internally in the performance schema implementation.
+ It is allocated at startup, or during runtime with scalable buffers.
+*/
+void *pfs_malloc(PFS_builtin_memory_class *klass, size_t size, myf flags)
+{
+ DBUG_ASSERT(klass != NULL);
+ DBUG_ASSERT(size > 0);
+
+ void *ptr= NULL;
+
+#ifdef PFS_ALIGNEMENT
+#ifdef HAVE_POSIX_MEMALIGN
+ /* Linux */
+ if (unlikely(posix_memalign(& ptr, PFS_ALIGNEMENT, size)))
+ return NULL;
+#else
+#ifdef HAVE_MEMALIGN
+ /* Solaris */
+ ptr= memalign(PFS_ALIGNEMENT, size);
+ if (unlikely(ptr == NULL))
+ return NULL;
+#else
+#ifdef HAVE_ALIGNED_MALLOC
+ /* Windows */
+ ptr= _aligned_malloc(size, PFS_ALIGNEMENT);
+ if (unlikely(ptr == NULL))
+ return NULL;
+#else
+#error "Missing implementation for PFS_ALIGNENT"
+#endif /* HAVE_ALIGNED_MALLOC */
+#endif /* HAVE_MEMALIGN */
+#endif /* HAVE_POSIX_MEMALIGN */
+#else /* PFS_ALIGNMENT */
+ /* Everything else */
+ ptr= malloc(size);
+ if (unlikely(ptr == NULL))
+ return NULL;
+#endif
+
+ klass->count_alloc(size);
+
+ if (flags & MY_ZEROFILL)
+ memset(ptr, 0, size);
+ return ptr;
+}
+
+void pfs_free(PFS_builtin_memory_class *klass, size_t size, void *ptr)
+{
+ if (ptr == NULL)
+ return;
+
+#ifdef HAVE_POSIX_MEMALIGN
+ /* Allocated with posix_memalign() */
+ free(ptr);
+#else
+#ifdef HAVE_MEMALIGN
+ /* Allocated with memalign() */
+ free(ptr);
+#else
+#ifdef HAVE_ALIGNED_MALLOC
+ /* Allocated with _aligned_malloc() */
+ _aligned_free(ptr);
+#else
+ /* Allocated with malloc() */
+ free(ptr);
+#endif /* HAVE_ALIGNED_MALLOC */
+#endif /* HAVE_MEMALIGN */
+#endif /* HAVE_POSIX_MEMALIGN */
+
+ klass->count_free(size);
+}
+
+/**
+ Array allocation for the performance schema.
+ Checks for overflow of n * size before allocating.
+ @param klass performance schema memory class
+ @param n number of array elements
+ @param size element size
+ @param flags malloc flags
+ @return pointer to memory on success, else NULL
+*/
+void *pfs_malloc_array(PFS_builtin_memory_class *klass, size_t n, size_t size, myf flags)
+{
+ DBUG_ASSERT(klass != NULL);
+ DBUG_ASSERT(n > 0);
+ DBUG_ASSERT(size > 0);
+ void *ptr= NULL;
+ size_t array_size= n * size;
+ /* Check for overflow before allocating. */
+ if (is_overflow(array_size, n, size))
+ {
+ sql_print_warning("Failed to allocate memory for %zu chunks each of size "
+ "%zu for buffer '%s' due to overflow", n, size,
+ klass->m_class.m_name);
+ return NULL;
+ }
+
+ if(NULL == (ptr= pfs_malloc(klass, array_size, flags)))
+ {
+ sql_print_warning("Failed to allocate %zu bytes for buffer '%s' due to "
+ "out-of-memory", array_size, klass->m_class.m_name);
+ }
+ return ptr;
+}
+
+/**
+ Free array allocated by @sa pfs_malloc_array.
+ @param klass performance schema memory class
+ @param n number of array elements
+ @param size element size
+ @param ptr pointer to memory
+*/
+void pfs_free_array(PFS_builtin_memory_class *klass, size_t n, size_t size, void *ptr)
+{
+ if (ptr == NULL)
+ return;
+ size_t array_size= n * size;
+ /* Overflow should have been detected by pfs_malloc_array. */
+ DBUG_ASSERT(!is_overflow(array_size, n, size));
+ return pfs_free(klass, array_size, ptr);
+}
+
+/**
+ Detect multiplication overflow.
+ @param product multiplication product
+ @param n1 operand
+ @param n2 operand
+ @return true if multiplication caused an overflow.
+*/
+bool is_overflow(size_t product, size_t n1, size_t n2)
+{
+ if (n1 != 0 && (product / n1 != n2))
+ return true;
+ else
+ return false;
+}
+
+void pfs_print_error(const char *format, ...)
+{
+ va_list args;
+ va_start(args, format);
+ /*
+ Printing to anything else, like the error log, would generate even more
+ recursive calls to the performance schema implementation
+ (file io is instrumented), so that could lead to catastrophic results.
+ Printing to something safe, and low level: stderr only.
+ */
+ vfprintf(stderr, format, args);
+ va_end(args);
+ fflush(stderr);
+}
+
+
+/** Convert raw ip address into readable format. Do not do a reverse DNS lookup. */
+
+uint pfs_get_socket_address(char *host,
+ uint host_len,
+ uint *port,
+ const struct sockaddr_storage *src_addr,
+ socklen_t src_len)
+{
+ DBUG_ASSERT(host);
+ DBUG_ASSERT(src_addr);
+ DBUG_ASSERT(port);
+
+ memset(host, 0, host_len);
+ *port= 0;
+
+ switch (src_addr->ss_family)
+ {
+ case AF_INET:
+ {
+ if (host_len < INET_ADDRSTRLEN+1)
+ return 0;
+ struct sockaddr_in *sa4= (struct sockaddr_in *)(src_addr);
+ #ifdef _WIN32
+ /* Older versions of Windows do not support inet_ntop() */
+ getnameinfo((struct sockaddr *)sa4, sizeof(struct sockaddr_in),
+ host, host_len, NULL, 0, NI_NUMERICHOST);
+ #else
+ inet_ntop(AF_INET, &(sa4->sin_addr), host, INET_ADDRSTRLEN);
+ #endif
+ *port= ntohs(sa4->sin_port);
+ }
+ break;
+
+#ifdef HAVE_IPV6
+ case AF_INET6:
+ {
+ if (host_len < INET6_ADDRSTRLEN+1)
+ return 0;
+ struct sockaddr_in6 *sa6= (struct sockaddr_in6 *)(src_addr);
+ #ifdef _WIN32
+ /* Older versions of Windows do not support inet_ntop() */
+ getnameinfo((struct sockaddr *)sa6, sizeof(struct sockaddr_in6),
+ host, host_len, NULL, 0, NI_NUMERICHOST);
+ #else
+ inet_ntop(AF_INET6, &(sa6->sin6_addr), host, INET6_ADDRSTRLEN);
+ #endif
+ *port= ntohs(sa6->sin6_port);
+ }
+ break;
+#endif
+
+ default:
+ break;
+ }
+
+ /* Return actual IP address string length */
+ return ((uint)strlen((const char*)host));
+}
diff --git a/storage/perfschema/pfs_global.h b/storage/perfschema/pfs_global.h
new file mode 100644
index 00000000..d26e81ad
--- /dev/null
+++ b/storage/perfschema/pfs_global.h
@@ -0,0 +1,201 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef PFS_GLOBAL_H
+#define PFS_GLOBAL_H
+
+#include "my_compiler.h"
+
+/**
+ @file storage/perfschema/pfs_global.h
+ Miscellaneous global dependencies (declarations).
+*/
+
+/** True when the performance schema is initialized. */
+extern bool pfs_initialized;
+/** Total memory allocated by the performance schema, in bytes. */
+extern size_t pfs_allocated_memory;
+
+#if defined(HAVE_POSIX_MEMALIGN) || defined(HAVE_MEMALIGN) || defined(HAVE_ALIGNED_MALLOC)
+#define PFS_ALIGNEMENT CPU_LEVEL1_DCACHE_LINESIZE
+#define PFS_ALIGNED MY_ALIGNED(PFS_ALIGNEMENT)
+#else
+/*
+ Known platforms that do not provide aligned memory:
+ - MacOSX Darwin (osx10.5)
+ For these platforms, compile without the alignment optimization.
+*/
+#define PFS_ALIGNED
+#endif /* HAVE_POSIX_MEMALIGN || HAVE_MEMALIGN || HAVE_ALIGNED_MALLOC */
+
+#ifdef CPU_LEVEL1_DCACHE_LINESIZE
+#define PFS_CACHE_LINE_SIZE CPU_LEVEL1_DCACHE_LINESIZE
+#else
+#define PFS_CACHE_LINE_SIZE 128
+#endif
+
+/**
+ A uint32 variable, guaranteed to be alone in a CPU cache line.
+ This is for performance, for variables accessed very frequently.
+*/
+struct PFS_cacheline_uint32
+{
+ uint32 m_u32;
+ char m_full_cache_line[PFS_CACHE_LINE_SIZE - sizeof(uint32)];
+
+ PFS_cacheline_uint32()
+ : m_u32(0)
+ {}
+};
+
+/**
+ A uint64 variable, guaranteed to be alone in a CPU cache line.
+ This is for performance, for variables accessed very frequently.
+*/
+struct PFS_cacheline_uint64
+{
+ uint64 m_u64;
+ char m_full_cache_line[PFS_CACHE_LINE_SIZE - sizeof(uint64)];
+
+ PFS_cacheline_uint64()
+ : m_u64(0)
+ {}
+};
+
+struct PFS_builtin_memory_class;
+
+/** Memory allocation for the performance schema. */
+void *pfs_malloc(PFS_builtin_memory_class *klass, size_t size, myf flags);
+
+/** Allocate an array of structures with overflow check. */
+void *pfs_malloc_array(PFS_builtin_memory_class *klass, size_t n, size_t size, myf flags);
+
+/**
+ Helper, to allocate an array of structures.
+ @param k memory class
+ @param n number of elements in the array
+ @param s size of array element
+ @param T type of an element
+ @param f flags to use when allocating memory
+*/
+#define PFS_MALLOC_ARRAY(k, n, s, T, f) \
+ reinterpret_cast<T*>(pfs_malloc_array((k), (n), (s), (f)))
+
+/** Free memory allocated with @sa pfs_malloc. */
+void pfs_free(PFS_builtin_memory_class *klass, size_t size, void *ptr);
+
+/** Free memory allocated with @sa pfs_malloc_array. */
+void pfs_free_array(PFS_builtin_memory_class *klass, size_t n, size_t size, void *ptr);
+
+/**
+ Helper, to free an array of structures.
+ @param k memory class
+ @param n number of elements in the array
+ @param s size of array element
+ @param p the array to free
+*/
+#define PFS_FREE_ARRAY(k, n, s, p) \
+ pfs_free_array((k), (n), (s), (p))
+
+/** Detect multiplication overflow. */
+bool is_overflow(size_t product, size_t n1, size_t n2);
+
+uint pfs_get_socket_address(char *host,
+ uint host_len,
+ uint *port,
+ const struct sockaddr_storage *src_addr,
+ socklen_t src_len);
+
+/**
+ Compute a random index value in an interval.
+ @param ptr seed address
+ @param max_size maximun size of the interval
+ @return a random value in [0, max_size-1]
+*/
+inline uint randomized_index(const void *ptr, uint max_size)
+{
+ static uint seed1= 0;
+ static uint seed2= 0;
+ uint result;
+ intptr value;
+
+ if (unlikely(max_size == 0))
+ return 0;
+
+ /*
+ ptr is typically an aligned structure, and can be in an array.
+ - The last bits are not random because of alignment,
+ so we divide by 8.
+ - The high bits are mostly constant, especially with 64 bits architectures,
+ but we keep most of them anyway, by doing computation in intptr.
+ The high bits are significant depending on where the data is
+ stored (the data segment, the stack, the heap, ...).
+ - To spread consecutive cells in an array further, we multiply by
+ a factor A. This factor should not be too high, which would cause
+ an overflow and cause loss of randomness (droping the top high bits).
+ The factor is a prime number, to help spread the distribution.
+ - To add more noise, and to be more robust if the calling code is
+ passing a constant value instead of a random identity,
+ we add the previous results, for hysteresys, with a degree 2 polynom,
+ X^2 + X + 1.
+ - Last, a modulo is applied to be within the [0, max_size - 1] range.
+ Note that seed1 and seed2 are static, and are *not* thread safe,
+ which is even better.
+ Effect with arrays: T array[N]
+ - ptr(i) = & array[i] = & array[0] + i * sizeof(T)
+ - ptr(i+1) = ptr(i) + sizeof(T).
+ What we want here, is to have index(i) and index(i+1) fall into
+ very different areas in [0, max_size - 1], to avoid locality.
+ */
+ value= (reinterpret_cast<intptr> (ptr)) >> 3;
+ value*= 1789;
+ value+= seed2 + seed1 + 1;
+
+ result= (static_cast<uint> (value)) % max_size;
+
+ seed2= seed1*seed1;
+ seed1= result;
+
+ DBUG_ASSERT(result < max_size);
+ return result;
+}
+
+void pfs_print_error(const char *format, ...);
+
+/**
+ Given an array defined as T ARRAY[MAX],
+ check that an UNSAFE pointer actually points to an element
+ within the array.
+*/
+#define SANITIZE_ARRAY_BODY(T, ARRAY, MAX, UNSAFE) \
+ intptr offset; \
+ if ((&ARRAY[0] <= UNSAFE) && \
+ (UNSAFE < &ARRAY[MAX])) \
+ { \
+ offset= ((intptr) UNSAFE - (intptr) ARRAY) % sizeof(T); \
+ if (offset == 0) \
+ return UNSAFE; \
+ } \
+ return NULL
+
+#endif
+
diff --git a/storage/perfschema/pfs_host.cc b/storage/perfschema/pfs_host.cc
new file mode 100644
index 00000000..b896215e
--- /dev/null
+++ b/storage/perfschema/pfs_host.cc
@@ -0,0 +1,374 @@
+/* Copyright (c) 2010, 2018, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/pfs_host.cc
+ Performance schema host (implementation).
+*/
+
+#include "my_global.h"
+#include "my_sys.h"
+#include "pfs.h"
+#include "pfs_stat.h"
+#include "pfs_instr.h"
+#include "pfs_setup_actor.h"
+#include "pfs_host.h"
+#include "pfs_global.h"
+#include "pfs_instr_class.h"
+#include "pfs_buffer_container.h"
+
+/**
+ @addtogroup Performance_schema_buffers
+ @{
+*/
+
+LF_HASH host_hash;
+static bool host_hash_inited= false;
+
+/**
+ Initialize the host buffers.
+ @param param sizing parameters
+ @return 0 on success
+*/
+int init_host(const PFS_global_param *param)
+{
+ if (global_host_container.init(param->m_host_sizing))
+ return 1;
+
+ return 0;
+}
+
+/** Cleanup all the host buffers. */
+void cleanup_host(void)
+{
+ global_host_container.cleanup();
+}
+
+C_MODE_START
+static uchar *host_hash_get_key(const uchar *entry, size_t *length,
+ my_bool)
+{
+ const PFS_host * const *typed_entry;
+ const PFS_host *host;
+ const void *result;
+ typed_entry= reinterpret_cast<const PFS_host* const *> (entry);
+ DBUG_ASSERT(typed_entry != NULL);
+ host= *typed_entry;
+ DBUG_ASSERT(host != NULL);
+ *length= host->m_key.m_key_length;
+ result= host->m_key.m_hash_key;
+ return const_cast<uchar*> (reinterpret_cast<const uchar*> (result));
+}
+C_MODE_END
+
+/**
+ Initialize the host hash.
+ @return 0 on success
+*/
+int init_host_hash(const PFS_global_param *param)
+{
+ if ((! host_hash_inited) && (param->m_host_sizing != 0))
+ {
+ lf_hash_init(&host_hash, sizeof(PFS_host*), LF_HASH_UNIQUE,
+ 0, 0, host_hash_get_key, &my_charset_bin);
+ host_hash_inited= true;
+ }
+ return 0;
+}
+
+/** Cleanup the host hash. */
+void cleanup_host_hash(void)
+{
+ if (host_hash_inited)
+ {
+ lf_hash_destroy(&host_hash);
+ host_hash_inited= false;
+ }
+}
+
+static LF_PINS* get_host_hash_pins(PFS_thread *thread)
+{
+ if (unlikely(thread->m_host_hash_pins == NULL))
+ {
+ if (! host_hash_inited)
+ return NULL;
+ thread->m_host_hash_pins= lf_hash_get_pins(&host_hash);
+ }
+ return thread->m_host_hash_pins;
+}
+
+static void set_host_key(PFS_host_key *key,
+ const char *host, uint host_length)
+{
+ DBUG_ASSERT(host_length <= HOSTNAME_LENGTH);
+
+ char *ptr= &key->m_hash_key[0];
+ if (host_length > 0)
+ {
+ memcpy(ptr, host, host_length);
+ ptr+= host_length;
+ }
+ ptr[0]= 0;
+ ptr++;
+ key->m_key_length= (uint)(ptr - &key->m_hash_key[0]);
+}
+
+PFS_host *find_or_create_host(PFS_thread *thread,
+ const char *hostname, uint hostname_length)
+{
+ static PFS_ALIGNED PFS_cacheline_uint32 monotonic;
+
+ LF_PINS *pins= get_host_hash_pins(thread);
+ if (unlikely(pins == NULL))
+ {
+ global_host_container.m_lost++;
+ return NULL;
+ }
+
+ PFS_host_key key;
+ set_host_key(&key, hostname, hostname_length);
+
+ PFS_host **entry;
+ PFS_host *pfs;
+ uint retry_count= 0;
+ const uint retry_max= 3;
+ pfs_dirty_state dirty_state;
+
+search:
+ entry= reinterpret_cast<PFS_host**>
+ (lf_hash_search(&host_hash, pins,
+ key.m_hash_key, key.m_key_length));
+ if (entry && (entry != MY_ERRPTR))
+ {
+ PFS_host *pfs;
+ pfs= *entry;
+ pfs->inc_refcount();
+ lf_hash_search_unpin(pins);
+ return pfs;
+ }
+
+ lf_hash_search_unpin(pins);
+
+ pfs= global_host_container.allocate(& dirty_state);
+ if (pfs != NULL)
+ {
+ pfs->m_key= key;
+ if (hostname_length > 0)
+ pfs->m_hostname= &pfs->m_key.m_hash_key[0];
+ else
+ pfs->m_hostname= NULL;
+ pfs->m_hostname_length= hostname_length;
+
+ pfs->init_refcount();
+ pfs->reset_stats();
+ pfs->m_disconnected_count= 0;
+
+ int res;
+ pfs->m_lock.dirty_to_allocated(& dirty_state);
+ res= lf_hash_insert(&host_hash, pins, &pfs);
+ if (likely(res == 0))
+ {
+ return pfs;
+ }
+
+ global_host_container.deallocate(pfs);
+
+ if (res > 0)
+ {
+ if (++retry_count > retry_max)
+ {
+ global_host_container.m_lost++;
+ return NULL;
+ }
+ goto search;
+ }
+
+ global_host_container.m_lost++;
+ return NULL;
+ }
+
+ return NULL;
+}
+
+void PFS_host::aggregate(bool alive)
+{
+ aggregate_waits();
+ aggregate_stages();
+ aggregate_statements();
+ aggregate_transactions();
+ aggregate_memory(alive);
+ aggregate_status();
+ aggregate_stats();
+}
+
+void PFS_host::aggregate_waits()
+{
+ /* No parent to aggregate to, clean the stats */
+ reset_waits_stats();
+}
+
+void PFS_host::aggregate_stages()
+{
+ if (read_instr_class_stages_stats() == NULL)
+ return;
+
+ /*
+ Aggregate EVENTS_STAGES_SUMMARY_BY_HOST_BY_EVENT_NAME to:
+ - EVENTS_STAGES_SUMMARY_GLOBAL_BY_EVENT_NAME
+ */
+ aggregate_all_stages(write_instr_class_stages_stats(),
+ global_instr_class_stages_array);
+}
+
+void PFS_host::aggregate_statements()
+{
+ if (read_instr_class_statements_stats() == NULL)
+ return;
+
+ /*
+ Aggregate EVENTS_STATEMENTS_SUMMARY_BY_HOST_BY_EVENT_NAME to:
+ - EVENTS_STATEMENTS_SUMMARY_GLOBAL_BY_EVENT_NAME
+ */
+ aggregate_all_statements(write_instr_class_statements_stats(),
+ global_instr_class_statements_array);
+}
+
+void PFS_host::aggregate_transactions()
+{
+ if (read_instr_class_transactions_stats() == NULL)
+ return;
+
+ /*
+ Aggregate EVENTS_TRANSACTIONS_SUMMARY_BY_HOST_BY_EVENT_NAME to:
+ - EVENTS_TRANSACTIONS_SUMMARY_GLOBAL_BY_EVENT_NAME
+ */
+ aggregate_all_transactions(write_instr_class_transactions_stats(),
+ &global_transaction_stat);
+}
+
+void PFS_host::aggregate_memory(bool alive)
+{
+ if (read_instr_class_memory_stats() == NULL)
+ return;
+
+ /*
+ Aggregate MEMORY_SUMMARY_BY_HOST_BY_EVENT_NAME to:
+ - MEMORY_SUMMARY_GLOBAL_BY_EVENT_NAME
+ */
+ aggregate_all_memory(alive,
+ write_instr_class_memory_stats(),
+ global_instr_class_memory_array);
+}
+
+void PFS_host::aggregate_status()
+{
+ /* No parent to aggregate to, clean the stats */
+ m_status_stats.reset();
+}
+
+void PFS_host::aggregate_stats()
+{
+ /* No parent to aggregate to, clean the stats */
+ m_disconnected_count= 0;
+}
+
+void PFS_host::release()
+{
+ dec_refcount();
+}
+
+void PFS_host::carry_memory_stat_delta(PFS_memory_stat_delta *delta, uint index)
+{
+ PFS_memory_stat *event_name_array;
+ PFS_memory_stat *stat;
+ PFS_memory_stat_delta delta_buffer;
+ PFS_memory_stat_delta *remaining_delta;
+
+ event_name_array= write_instr_class_memory_stats();
+ stat= & event_name_array[index];
+ remaining_delta= stat->apply_delta(delta, &delta_buffer);
+
+ if (remaining_delta != NULL)
+ carry_global_memory_stat_delta(remaining_delta, index);
+}
+
+PFS_host *sanitize_host(PFS_host *unsafe)
+{
+ return global_host_container.sanitize(unsafe);
+}
+
+void purge_host(PFS_thread *thread, PFS_host *host)
+{
+ LF_PINS *pins= get_host_hash_pins(thread);
+ if (unlikely(pins == NULL))
+ return;
+
+ PFS_host **entry;
+ entry= reinterpret_cast<PFS_host**>
+ (lf_hash_search(&host_hash, pins,
+ host->m_key.m_hash_key, host->m_key.m_key_length));
+ if (entry && (entry != MY_ERRPTR))
+ {
+ DBUG_ASSERT(*entry == host);
+ if (host->get_refcount() == 0)
+ {
+ lf_hash_delete(&host_hash, pins,
+ host->m_key.m_hash_key, host->m_key.m_key_length);
+ host->aggregate(false);
+ global_host_container.deallocate(host);
+ }
+ }
+
+ lf_hash_search_unpin(pins);
+}
+
+class Proc_purge_host
+ : public PFS_buffer_processor<PFS_host>
+{
+public:
+ Proc_purge_host(PFS_thread *thread)
+ : m_thread(thread)
+ {}
+
+ virtual void operator()(PFS_host *pfs)
+ {
+ pfs->aggregate(true);
+ if (pfs->get_refcount() == 0)
+ purge_host(m_thread, pfs);
+ }
+
+private:
+ PFS_thread *m_thread;
+};
+
+/** Purge non connected hosts, reset stats of connected hosts. */
+void purge_all_host(void)
+{
+ PFS_thread *thread= PFS_thread::get_current_thread();
+ if (unlikely(thread == NULL))
+ return;
+
+ Proc_purge_host proc(thread);
+ global_host_container.apply(proc);
+}
+
+/** @} */
diff --git a/storage/perfschema/pfs_host.h b/storage/perfschema/pfs_host.h
new file mode 100644
index 00000000..37819882
--- /dev/null
+++ b/storage/perfschema/pfs_host.h
@@ -0,0 +1,120 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef PFS_HOST_H
+#define PFS_HOST_H
+
+/**
+ @file storage/perfschema/pfs_host.h
+ Performance schema host (declarations).
+*/
+
+#include "pfs_lock.h"
+#include "lf.h"
+#include "pfs_con_slice.h"
+
+struct PFS_global_param;
+struct PFS_thread;
+
+/**
+ @addtogroup Performance_schema_buffers
+ @{
+*/
+
+/** Hash key for a host. */
+struct PFS_host_key
+{
+ /**
+ Hash search key.
+ This has to be a string for LF_HASH,
+ the format is "<hostname><0x00>"
+ */
+ char m_hash_key[HOSTNAME_LENGTH + 1];
+ uint m_key_length;
+};
+
+/** Per host statistics. */
+struct PFS_ALIGNED PFS_host : PFS_connection_slice
+{
+public:
+ inline void init_refcount(void)
+ {
+ PFS_atomic::store_32(& m_refcount, 1);
+ }
+
+ inline int get_refcount(void)
+ {
+ return PFS_atomic::load_32(& m_refcount);
+ }
+
+ inline void inc_refcount(void)
+ {
+ PFS_atomic::add_32(& m_refcount, 1);
+ }
+
+ inline void dec_refcount(void)
+ {
+ PFS_atomic::add_32(& m_refcount, -1);
+ }
+
+ void aggregate(bool alive);
+ void aggregate_waits(void);
+ void aggregate_stages(void);
+ void aggregate_statements(void);
+ void aggregate_transactions(void);
+ void aggregate_memory(bool alive);
+ void aggregate_status(void);
+ void aggregate_stats(void);
+ void release(void);
+
+ void carry_memory_stat_delta(PFS_memory_stat_delta *delta, uint index);
+
+ /* Internal lock. */
+ pfs_lock m_lock;
+ PFS_host_key m_key;
+ const char *m_hostname;
+ uint m_hostname_length;
+
+ ulonglong m_disconnected_count;
+
+private:
+ int m_refcount;
+};
+
+int init_host(const PFS_global_param *param);
+void cleanup_host(void);
+int init_host_hash(const PFS_global_param *param);
+void cleanup_host_hash(void);
+
+PFS_host *find_or_create_host(PFS_thread *thread,
+ const char *hostname, uint hostname_length);
+
+PFS_host *sanitize_host(PFS_host *unsafe);
+void purge_all_host(void);
+
+/* For show status. */
+
+extern LF_HASH host_hash;
+
+/** @} */
+#endif
+
diff --git a/storage/perfschema/pfs_instr.cc b/storage/perfschema/pfs_instr.cc
new file mode 100644
index 00000000..cd820146
--- /dev/null
+++ b/storage/perfschema/pfs_instr.cc
@@ -0,0 +1,2343 @@
+/* Copyright (c) 2008, 2018, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/pfs_instr.cc
+ Performance schema instruments (implementation).
+*/
+
+#include <my_global.h>
+#include <string.h>
+
+#include "my_sys.h"
+#include "pfs.h"
+#include "pfs_stat.h"
+#include "pfs_instr.h"
+#include "pfs_host.h"
+#include "pfs_user.h"
+#include "pfs_account.h"
+#include "pfs_global.h"
+#include "pfs_instr_class.h"
+#include "pfs_buffer_container.h"
+#include "pfs_builtin_memory.h"
+
+ulong nested_statement_lost= 0;
+
+/**
+ @addtogroup Performance_schema_buffers
+ @{
+*/
+
+/**
+ Size of the file handle array. @sa file_handle_array.
+ Signed value, for easier comparisons with a file descriptor number.
+*/
+long file_handle_max= 0;
+/** True when @c file_handle_array is full. */
+bool file_handle_full;
+/** Number of file handle lost. @sa file_handle_array */
+ulong file_handle_lost= 0;
+/** Number of EVENTS_WAITS_HISTORY records per thread. */
+ulong events_waits_history_per_thread= 0;
+/** Number of EVENTS_STAGES_HISTORY records per thread. */
+ulong events_stages_history_per_thread= 0;
+/** Number of EVENTS_STATEMENTS_HISTORY records per thread. */
+ulong events_statements_history_per_thread= 0;
+uint statement_stack_max= 0;
+size_t pfs_max_digest_length= 0;
+size_t pfs_max_sqltext= 0;
+/** Number of locker lost. @sa LOCKER_STACK_SIZE. */
+ulong locker_lost= 0;
+/** Number of statements lost. @sa STATEMENT_STACK_SIZE. */
+ulong statement_lost= 0;
+/** Size of connection attribute storage per thread */
+ulong session_connect_attrs_size_per_thread;
+/** Number of connection attributes lost */
+ulong session_connect_attrs_lost= 0;
+
+/** Number of EVENTS_TRANSACTIONS_HISTORY records per thread. */
+ulong events_transactions_history_per_thread= 0;
+
+/**
+ File instrumentation handle array.
+ @sa file_handle_max
+ @sa file_handle_lost
+*/
+PFS_file **file_handle_array= NULL;
+
+PFS_stage_stat *global_instr_class_stages_array= NULL;
+PFS_statement_stat *global_instr_class_statements_array= NULL;
+PFS_memory_stat *global_instr_class_memory_array= NULL;
+
+static PFS_ALIGNED PFS_cacheline_uint64 thread_internal_id_counter;
+
+/** Hash table for instrumented files. */
+LF_HASH pfs_filename_hash;
+/** True if pfs_filename_hash is initialized. */
+static bool filename_hash_inited= false;
+
+my_bool show_compatibility_56= 0;
+
+/**
+ Initialize all the instruments instance buffers.
+ @param param sizing parameters
+ @return 0 on success
+*/
+int init_instruments(const PFS_global_param *param)
+{
+ uint index;
+
+ /* Make sure init_event_name_sizing is called */
+ DBUG_ASSERT(wait_class_max != 0);
+
+ file_handle_max= param->m_file_handle_sizing;
+ file_handle_full= false;
+ file_handle_lost= 0;
+
+ pfs_max_digest_length= param->m_max_digest_length;
+ pfs_max_sqltext= param->m_max_sql_text_length;
+
+ events_waits_history_per_thread= param->m_events_waits_history_sizing;
+
+ events_stages_history_per_thread= param->m_events_stages_history_sizing;
+
+ events_statements_history_per_thread= param->m_events_statements_history_sizing;
+
+ statement_stack_max= param->m_statement_stack_sizing;
+
+ events_transactions_history_per_thread= param->m_events_transactions_history_sizing;
+
+ session_connect_attrs_size_per_thread= param->m_session_connect_attrs_sizing;
+ session_connect_attrs_lost= 0;
+
+ file_handle_array= NULL;
+
+ thread_internal_id_counter.m_u64= 0;
+
+ if (global_mutex_container.init(param->m_mutex_sizing))
+ return 1;
+
+ if (global_rwlock_container.init(param->m_rwlock_sizing))
+ return 1;
+
+ if (global_cond_container.init(param->m_cond_sizing))
+ return 1;
+
+ if (global_file_container.init(param->m_file_sizing))
+ return 1;
+
+ if (file_handle_max > 0)
+ {
+ file_handle_array= PFS_MALLOC_ARRAY(& builtin_memory_file_handle,
+ file_handle_max,
+ sizeof(PFS_file*), PFS_file*,
+ MYF(MY_ZEROFILL));
+ if (unlikely(file_handle_array == NULL))
+ return 1;
+ }
+
+ if (global_table_container.init(param->m_table_sizing))
+ return 1;
+
+ if (global_socket_container.init(param->m_socket_sizing))
+ return 1;
+
+ if (global_mdl_container.init(param->m_metadata_lock_sizing))
+ return 1;
+
+ if (global_thread_container.init(param->m_thread_sizing))
+ return 1;
+
+ if (stage_class_max > 0)
+ {
+ global_instr_class_stages_array=
+ PFS_MALLOC_ARRAY(& builtin_memory_global_stages,
+ stage_class_max,
+ sizeof(PFS_stage_stat), PFS_stage_stat,
+ MYF(MY_ZEROFILL));
+ if (unlikely(global_instr_class_stages_array == NULL))
+ return 1;
+
+ for (index= 0; index < stage_class_max; index++)
+ global_instr_class_stages_array[index].reset();
+ }
+
+ if (statement_class_max > 0)
+ {
+ global_instr_class_statements_array=
+ PFS_MALLOC_ARRAY(& builtin_memory_global_statements,
+ statement_class_max,
+ sizeof(PFS_statement_stat), PFS_statement_stat,
+ MYF(MY_ZEROFILL));
+ if (unlikely(global_instr_class_statements_array == NULL))
+ return 1;
+
+ for (index= 0; index < statement_class_max; index++)
+ global_instr_class_statements_array[index].reset();
+ }
+
+ if (memory_class_max > 0)
+ {
+ global_instr_class_memory_array=
+ PFS_MALLOC_ARRAY(& builtin_memory_global_memory,
+ memory_class_max,
+ sizeof(PFS_memory_stat), PFS_memory_stat,
+ MYF(MY_ZEROFILL));
+ if (unlikely(global_instr_class_memory_array == NULL))
+ return 1;
+
+ for (index= 0; index < memory_class_max; index++)
+ global_instr_class_memory_array[index].reset();
+ }
+
+ return 0;
+}
+
+/** Cleanup all the instruments buffers. */
+void cleanup_instruments(void)
+{
+ global_mutex_container.cleanup();
+ global_rwlock_container.cleanup();
+ global_cond_container.cleanup();
+ global_file_container.cleanup();
+
+ PFS_FREE_ARRAY(& builtin_memory_file_handle,
+ file_handle_max, sizeof(PFS_file*),
+ file_handle_array);
+ file_handle_array= NULL;
+ file_handle_max= 0;
+
+ global_table_container.cleanup();
+ global_socket_container.cleanup();
+ global_mdl_container.cleanup();
+ global_thread_container.cleanup();
+
+ PFS_FREE_ARRAY(& builtin_memory_global_stages,
+ stage_class_max,
+ sizeof(PFS_stage_stat),
+ global_instr_class_stages_array);
+ global_instr_class_stages_array= NULL;
+
+ PFS_FREE_ARRAY(& builtin_memory_global_statements,
+ statement_class_max,
+ sizeof(PFS_statement_stat),
+ global_instr_class_statements_array);
+ global_instr_class_statements_array= NULL;
+
+ PFS_FREE_ARRAY(& builtin_memory_global_memory,
+ memory_class_max,
+ sizeof(PFS_memory_stat),
+ global_instr_class_memory_array);
+ global_instr_class_memory_array= NULL;
+}
+
+C_MODE_START
+/** Get hash table key for instrumented files. */
+static uchar *filename_hash_get_key(const uchar *entry, size_t *length,
+ my_bool)
+{
+ const PFS_file * const *typed_entry;
+ const PFS_file *file;
+ const void *result;
+ typed_entry= reinterpret_cast<const PFS_file* const *> (entry);
+ DBUG_ASSERT(typed_entry != NULL);
+ file= *typed_entry;
+ DBUG_ASSERT(file != NULL);
+ *length= file->m_filename_length;
+ result= file->m_filename;
+ return const_cast<uchar*> (reinterpret_cast<const uchar*> (result));
+}
+C_MODE_END
+
+/**
+ Initialize the file name hash.
+ @return 0 on success
+*/
+int init_file_hash(const PFS_global_param *param)
+{
+ if ((! filename_hash_inited) && (param->m_file_sizing != 0))
+ {
+ lf_hash_init(&pfs_filename_hash, sizeof(PFS_file*), LF_HASH_UNIQUE,
+ 0, 0, filename_hash_get_key, &my_charset_bin);
+ filename_hash_inited= true;
+ }
+ return 0;
+}
+
+/** Cleanup the file name hash. */
+void cleanup_file_hash(void)
+{
+ if (filename_hash_inited)
+ {
+ lf_hash_destroy(&pfs_filename_hash);
+ filename_hash_inited= false;
+ }
+}
+
+/**
+ Create instrumentation for a mutex instance.
+ @param klass the mutex class
+ @param identity the mutex address
+ @return a mutex instance, or NULL
+*/
+PFS_mutex* create_mutex(PFS_mutex_class *klass, const void *identity)
+{
+ PFS_mutex *pfs;
+ pfs_dirty_state dirty_state;
+
+ pfs= global_mutex_container.allocate(& dirty_state, klass->m_volatility);
+ if (pfs != NULL)
+ {
+ pfs->m_identity= identity;
+ pfs->m_class= klass;
+ pfs->m_enabled= klass->m_enabled && flag_global_instrumentation;
+ pfs->m_timed= klass->m_timed;
+ pfs->m_mutex_stat.reset();
+ pfs->m_owner= NULL;
+ pfs->m_last_locked= 0;
+ pfs->m_lock.dirty_to_allocated(& dirty_state);
+ if (klass->is_singleton())
+ klass->m_singleton= pfs;
+ }
+
+ return pfs;
+}
+
+/**
+ Destroy instrumentation for a mutex instance.
+ @param pfs the mutex to destroy
+*/
+void destroy_mutex(PFS_mutex *pfs)
+{
+ DBUG_ASSERT(pfs != NULL);
+ PFS_mutex_class *klass= pfs->m_class;
+ /* Aggregate to EVENTS_WAITS_SUMMARY_GLOBAL_BY_EVENT_NAME */
+ klass->m_mutex_stat.aggregate(& pfs->m_mutex_stat);
+ pfs->m_mutex_stat.reset();
+ if (klass->is_singleton())
+ klass->m_singleton= NULL;
+
+ global_mutex_container.deallocate(pfs);
+}
+
+/**
+ Create instrumentation for a rwlock instance.
+ @param klass the rwlock class
+ @param identity the rwlock address
+ @return a rwlock instance, or NULL
+*/
+PFS_rwlock* create_rwlock(PFS_rwlock_class *klass, const void *identity)
+{
+ PFS_rwlock *pfs;
+ pfs_dirty_state dirty_state;
+
+ pfs= global_rwlock_container.allocate(& dirty_state);
+ if (pfs != NULL)
+ {
+ pfs->m_identity= identity;
+ pfs->m_class= klass;
+ pfs->m_enabled= klass->m_enabled && flag_global_instrumentation;
+ pfs->m_timed= klass->m_timed;
+ pfs->m_rwlock_stat.reset();
+ pfs->m_writer= NULL;
+ pfs->m_readers= 0;
+ pfs->m_last_written= 0;
+ pfs->m_last_read= 0;
+ pfs->m_lock.dirty_to_allocated(& dirty_state);
+ if (klass->is_singleton())
+ klass->m_singleton= pfs;
+ }
+
+ return pfs;
+}
+
+/**
+ Destroy instrumentation for a rwlock instance.
+ @param pfs the rwlock to destroy
+*/
+void destroy_rwlock(PFS_rwlock *pfs)
+{
+ DBUG_ASSERT(pfs != NULL);
+ PFS_rwlock_class *klass= pfs->m_class;
+ /* Aggregate to EVENTS_WAITS_SUMMARY_GLOBAL_BY_EVENT_NAME */
+ klass->m_rwlock_stat.aggregate(& pfs->m_rwlock_stat);
+ pfs->m_rwlock_stat.reset();
+ if (klass->is_singleton())
+ klass->m_singleton= NULL;
+
+ global_rwlock_container.deallocate(pfs);
+}
+
+/**
+ Create instrumentation for a condition instance.
+ @param klass the condition class
+ @param identity the condition address
+ @return a condition instance, or NULL
+*/
+PFS_cond* create_cond(PFS_cond_class *klass, const void *identity)
+{
+ PFS_cond *pfs;
+ pfs_dirty_state dirty_state;
+
+ pfs= global_cond_container.allocate(& dirty_state);
+ if (pfs != NULL)
+ {
+ pfs->m_identity= identity;
+ pfs->m_class= klass;
+ pfs->m_enabled= klass->m_enabled && flag_global_instrumentation;
+ pfs->m_timed= klass->m_timed;
+ pfs->m_cond_stat.reset();
+ pfs->m_lock.dirty_to_allocated(& dirty_state);
+ if (klass->is_singleton())
+ klass->m_singleton= pfs;
+ }
+
+ return pfs;
+}
+
+/**
+ Destroy instrumentation for a condition instance.
+ @param pfs the condition to destroy
+*/
+void destroy_cond(PFS_cond *pfs)
+{
+ DBUG_ASSERT(pfs != NULL);
+ PFS_cond_class *klass= pfs->m_class;
+ /* Aggregate to EVENTS_WAITS_SUMMARY_GLOBAL_BY_EVENT_NAME */
+ klass->m_cond_stat.aggregate(& pfs->m_cond_stat);
+ pfs->m_cond_stat.reset();
+ if (klass->is_singleton())
+ klass->m_singleton= NULL;
+
+ global_cond_container.deallocate(pfs);
+}
+
+PFS_thread* PFS_thread::get_current_thread()
+{
+ return static_cast<PFS_thread*>(my_get_thread_local(THR_PFS));
+}
+
+void PFS_thread::reset_session_connect_attrs()
+{
+ m_session_connect_attrs_length= 0;
+ m_session_connect_attrs_cs_number= 0;
+
+ if ((m_session_connect_attrs != NULL) &&
+ (session_connect_attrs_size_per_thread > 0) )
+ {
+ /* Do not keep user data */
+ memset(m_session_connect_attrs, 0, session_connect_attrs_size_per_thread);
+ }
+}
+
+void PFS_thread::set_history_derived_flags()
+{
+ if (m_history)
+ {
+ m_flag_events_waits_history= flag_events_waits_history;
+ m_flag_events_waits_history_long= flag_events_waits_history_long;
+ m_flag_events_stages_history= flag_events_stages_history;
+ m_flag_events_stages_history_long= flag_events_stages_history_long;
+ m_flag_events_statements_history= flag_events_statements_history;
+ m_flag_events_statements_history_long= flag_events_statements_history_long;
+ m_flag_events_transactions_history= flag_events_transactions_history;
+ m_flag_events_transactions_history_long= flag_events_transactions_history_long;
+ }
+ else
+ {
+ m_flag_events_waits_history= false;
+ m_flag_events_waits_history_long= false;
+ m_flag_events_stages_history= false;
+ m_flag_events_stages_history_long= false;
+ m_flag_events_statements_history= false;
+ m_flag_events_statements_history_long= false;
+ m_flag_events_transactions_history= false;
+ m_flag_events_transactions_history_long= false;
+ }
+}
+
+void PFS_thread::carry_memory_stat_delta(PFS_memory_stat_delta *delta, uint index)
+{
+ if (m_account != NULL)
+ {
+ m_account->carry_memory_stat_delta(delta, index);
+ return;
+ }
+
+ if (m_user != NULL)
+ {
+ m_user->carry_memory_stat_delta(delta, index);
+ /* do not return, need to process m_host below */
+ }
+
+ if (m_host != NULL)
+ {
+ m_host->carry_memory_stat_delta(delta, index);
+ return;
+ }
+
+ carry_global_memory_stat_delta(delta, index);
+}
+
+void carry_global_memory_stat_delta(PFS_memory_stat_delta *delta, uint index)
+{
+ PFS_memory_stat *stat;
+ PFS_memory_stat_delta delta_buffer;
+
+ stat= & global_instr_class_memory_array[index];
+ (void) stat->apply_delta(delta, &delta_buffer);
+}
+
+/**
+ Create instrumentation for a thread instance.
+ @param klass the thread class
+ @param identity the thread address,
+ or a value characteristic of this thread
+ @param processlist_id the PROCESSLIST id,
+ or 0 if unknown
+ @return a thread instance, or NULL
+*/
+PFS_thread* create_thread(PFS_thread_class *klass, const void *identity,
+ ulonglong processlist_id)
+{
+ PFS_thread *pfs;
+ pfs_dirty_state dirty_state;
+
+ pfs= global_thread_container.allocate(& dirty_state);
+ if (pfs != NULL)
+ {
+ pfs->m_thread_internal_id=
+ PFS_atomic::add_u64(&thread_internal_id_counter.m_u64, 1);
+ pfs->m_parent_thread_internal_id= 0;
+ pfs->m_processlist_id= static_cast<ulong>(processlist_id);
+ pfs->m_thread_os_id= my_thread_os_id();
+ pfs->m_event_id= 1;
+ pfs->m_stmt_lock.set_allocated();
+ pfs->m_session_lock.set_allocated();
+ pfs->set_enabled(true);
+ pfs->set_history(true);
+ pfs->m_class= klass;
+ pfs->m_events_waits_current= & pfs->m_events_waits_stack[WAIT_STACK_BOTTOM];
+ pfs->m_waits_history_full= false;
+ pfs->m_waits_history_index= 0;
+ pfs->m_stages_history_full= false;
+ pfs->m_stages_history_index= 0;
+ pfs->m_statements_history_full= false;
+ pfs->m_statements_history_index= 0;
+ pfs->m_transactions_history_full= false;
+ pfs->m_transactions_history_index= 0;
+
+ pfs->reset_stats();
+ pfs->reset_session_connect_attrs();
+
+ pfs->m_filename_hash_pins= NULL;
+ pfs->m_table_share_hash_pins= NULL;
+ pfs->m_setup_actor_hash_pins= NULL;
+ pfs->m_setup_object_hash_pins= NULL;
+ pfs->m_user_hash_pins= NULL;
+ pfs->m_account_hash_pins= NULL;
+ pfs->m_host_hash_pins= NULL;
+ pfs->m_digest_hash_pins= NULL;
+ pfs->m_program_hash_pins= NULL;
+
+ pfs->m_username_length= 0;
+ pfs->m_hostname_length= 0;
+ pfs->m_dbname_length= 0;
+ pfs->m_command= 0;
+ pfs->m_start_time= 0;
+ pfs->m_stage= 0;
+ pfs->m_stage_progress= NULL;
+ pfs->m_processlist_info[0]= '\0';
+ pfs->m_processlist_info_length= 0;
+ pfs->m_connection_type= VIO_CLOSED;
+
+ pfs->m_thd= NULL;
+ pfs->m_host= NULL;
+ pfs->m_user= NULL;
+ pfs->m_account= NULL;
+ set_thread_account(pfs);
+
+ /*
+ For child waits, by default,
+ - NESTING_EVENT_ID is NULL
+ - NESTING_EVENT_TYPE is NULL
+ */
+ PFS_events_waits *child_wait= & pfs->m_events_waits_stack[0];
+ child_wait->m_event_id= 0;
+
+ /*
+ For child stages, by default,
+ - NESTING_EVENT_ID is NULL
+ - NESTING_EVENT_TYPE is NULL
+ */
+ PFS_events_stages *child_stage= & pfs->m_stage_current;
+ child_stage->m_nesting_event_id= 0;
+
+ pfs->m_events_statements_count= 0;
+ pfs->m_transaction_current.m_event_id= 0;
+
+ pfs->m_lock.dirty_to_allocated(& dirty_state);
+ }
+
+ return pfs;
+}
+
+PFS_mutex *sanitize_mutex(PFS_mutex *unsafe)
+{
+ return global_mutex_container.sanitize(unsafe);
+}
+
+PFS_rwlock *sanitize_rwlock(PFS_rwlock *unsafe)
+{
+ return global_rwlock_container.sanitize(unsafe);
+}
+
+PFS_cond *sanitize_cond(PFS_cond *unsafe)
+{
+ return global_cond_container.sanitize(unsafe);
+}
+
+/**
+ Sanitize a PFS_thread pointer.
+ Validate that the PFS_thread is part of thread_array.
+ Sanitizing data is required when the data can be
+ damaged with expected race conditions, for example
+ involving EVENTS_WAITS_HISTORY_LONG.
+ @param unsafe the pointer to sanitize
+ @return a valid pointer, or NULL
+*/
+PFS_thread *sanitize_thread(PFS_thread *unsafe)
+{
+ return global_thread_container.sanitize(unsafe);
+}
+
+PFS_file *sanitize_file(PFS_file *unsafe)
+{
+ return global_file_container.sanitize(unsafe);
+}
+
+PFS_socket *sanitize_socket(PFS_socket *unsafe)
+{
+ return global_socket_container.sanitize(unsafe);
+}
+
+PFS_metadata_lock *sanitize_metadata_lock(PFS_metadata_lock *unsafe)
+{
+ return global_mdl_container.sanitize(unsafe);
+}
+
+/**
+ Destroy instrumentation for a thread instance.
+ @param pfs the thread to destroy
+*/
+void destroy_thread(PFS_thread *pfs)
+{
+ DBUG_ASSERT(pfs != NULL);
+ pfs->reset_session_connect_attrs();
+ if (pfs->m_account != NULL)
+ {
+ pfs->m_account->release();
+ pfs->m_account= NULL;
+ DBUG_ASSERT(pfs->m_user == NULL);
+ DBUG_ASSERT(pfs->m_host == NULL);
+ }
+ else
+ {
+ if (pfs->m_user != NULL)
+ {
+ pfs->m_user->release();
+ pfs->m_user= NULL;
+ }
+ if (pfs->m_host != NULL)
+ {
+ pfs->m_host->release();
+ pfs->m_host= NULL;
+ }
+ }
+ if (pfs->m_filename_hash_pins)
+ {
+ lf_hash_put_pins(pfs->m_filename_hash_pins);
+ pfs->m_filename_hash_pins= NULL;
+ }
+ if (pfs->m_table_share_hash_pins)
+ {
+ lf_hash_put_pins(pfs->m_table_share_hash_pins);
+ pfs->m_table_share_hash_pins= NULL;
+ }
+ if (pfs->m_setup_actor_hash_pins)
+ {
+ lf_hash_put_pins(pfs->m_setup_actor_hash_pins);
+ pfs->m_setup_actor_hash_pins= NULL;
+ }
+ if (pfs->m_setup_object_hash_pins)
+ {
+ lf_hash_put_pins(pfs->m_setup_object_hash_pins);
+ pfs->m_setup_object_hash_pins= NULL;
+ }
+ if (pfs->m_user_hash_pins)
+ {
+ lf_hash_put_pins(pfs->m_user_hash_pins);
+ pfs->m_user_hash_pins= NULL;
+ }
+ if (pfs->m_account_hash_pins)
+ {
+ lf_hash_put_pins(pfs->m_account_hash_pins);
+ pfs->m_account_hash_pins= NULL;
+ }
+ if (pfs->m_host_hash_pins)
+ {
+ lf_hash_put_pins(pfs->m_host_hash_pins);
+ pfs->m_host_hash_pins= NULL;
+ }
+ if (pfs->m_digest_hash_pins)
+ {
+ lf_hash_put_pins(pfs->m_digest_hash_pins);
+ pfs->m_digest_hash_pins= NULL;
+ }
+ if (pfs->m_program_hash_pins)
+ {
+ lf_hash_put_pins(pfs->m_program_hash_pins);
+ pfs->m_program_hash_pins= NULL;
+ }
+ global_thread_container.deallocate(pfs);
+}
+
+/**
+ Get the hash pins for @pfs_filename_hash.
+ @param thread The running thread.
+ @returns The LF_HASH pins for the thread.
+*/
+LF_PINS* get_filename_hash_pins(PFS_thread *thread)
+{
+ if (unlikely(thread->m_filename_hash_pins == NULL))
+ {
+ if (! filename_hash_inited)
+ return NULL;
+ thread->m_filename_hash_pins= lf_hash_get_pins(&pfs_filename_hash);
+ }
+ return thread->m_filename_hash_pins;
+}
+
+/**
+ Find or create instrumentation for a file instance by file name.
+ @param thread the executing instrumented thread
+ @param klass the file class
+ @param filename the file name
+ @param len the length in bytes of filename
+ @param create create a file instance if none found
+ @return a file instance, or NULL
+*/
+PFS_file*
+find_or_create_file(PFS_thread *thread, PFS_file_class *klass,
+ const char *filename, uint len, bool create)
+{
+ PFS_file *pfs;
+
+ DBUG_ASSERT(klass != NULL || ! create);
+
+ LF_PINS *pins= get_filename_hash_pins(thread);
+ if (unlikely(pins == NULL))
+ {
+ global_file_container.m_lost++;
+ return NULL;
+ }
+
+ char safe_buffer[FN_REFLEN];
+ const char *safe_filename;
+
+ if (len >= FN_REFLEN)
+ {
+ /*
+ The instrumented code uses file names that exceeds FN_REFLEN.
+ This could be legal for instrumentation on non mysys APIs,
+ so we support it.
+ Truncate the file name so that:
+ - it fits into pfs->m_filename
+ - it is safe to use mysys apis to normalize the file name.
+ */
+ memcpy(safe_buffer, filename, FN_REFLEN - 1);
+ safe_buffer[FN_REFLEN - 1]= 0;
+ safe_filename= safe_buffer;
+ }
+ else
+ safe_filename= filename;
+
+ /*
+ Normalize the file name to avoid duplicates when using aliases:
+ - absolute or relative paths
+ - symbolic links
+ Names are resolved as follows:
+ - /real/path/to/real_file ==> same
+ - /path/with/link/to/real_file ==> /real/path/to/real_file
+ - real_file ==> /real/path/to/real_file
+ - ./real_file ==> /real/path/to/real_file
+ - /real/path/to/sym_link ==> same
+ - /path/with/link/to/sym_link ==> /real/path/to/sym_link
+ - sym_link ==> /real/path/to/sym_link
+ - ./sym_link ==> /real/path/to/sym_link
+ When the last component of a file is a symbolic link,
+ the last component is *not* resolved, so that all file io
+ operations on a link (create, read, write, delete) are counted
+ against the link itself, not the target file.
+ Resolving the name would lead to create counted against the link,
+ and read/write/delete counted against the target, leading to
+ incoherent results and instrumentation leaks.
+ Also note that, when creating files, this name resolution
+ works properly for files that do not exist (yet) on the file system.
+ */
+ char buffer[FN_REFLEN];
+ char dirbuffer[FN_REFLEN];
+ size_t dirlen;
+ const char *normalized_filename;
+ uint normalized_length;
+
+ dirlen= dirname_length(safe_filename);
+ if (dirlen == 0)
+ {
+ dirbuffer[0]= FN_CURLIB;
+ dirbuffer[1]= FN_LIBCHAR;
+ dirbuffer[2]= '\0';
+ }
+ else
+ {
+ memcpy(dirbuffer, safe_filename, dirlen);
+ dirbuffer[dirlen]= '\0';
+ }
+
+ if (my_realpath(buffer, dirbuffer, MYF(0)) != 0)
+ {
+ global_file_container.m_lost++;
+ return NULL;
+ }
+
+ /* Append the unresolved file name to the resolved path */
+ char *ptr= buffer + strlen(buffer);
+ char *buf_end= &buffer[sizeof(buffer)-1];
+ if ((buf_end > ptr) && (*(ptr-1) != FN_LIBCHAR))
+ *ptr++= FN_LIBCHAR;
+ if (buf_end > ptr)
+ strncpy(ptr, safe_filename + dirlen, buf_end - ptr);
+ *buf_end= '\0';
+
+ normalized_filename= buffer;
+ normalized_length= (uint)strlen(normalized_filename);
+
+ PFS_file **entry;
+ uint retry_count= 0;
+ const uint retry_max= 3;
+ pfs_dirty_state dirty_state;
+
+search:
+
+ entry= reinterpret_cast<PFS_file**>
+ (lf_hash_search(&pfs_filename_hash, pins,
+ normalized_filename, normalized_length));
+ if (entry && (entry != MY_ERRPTR))
+ {
+ pfs= *entry;
+ pfs->m_file_stat.m_open_count++;
+ lf_hash_search_unpin(pins);
+ return pfs;
+ }
+
+ lf_hash_search_unpin(pins);
+
+ if (! create)
+ {
+ /* No lost counter, just looking for the file existence. */
+ return NULL;
+ }
+
+ pfs= global_file_container.allocate(& dirty_state);
+ if (pfs != NULL)
+ {
+ pfs->m_class= klass;
+ pfs->m_enabled= klass->m_enabled && flag_global_instrumentation;
+ pfs->m_timed= klass->m_timed;
+ memcpy(pfs->m_filename, normalized_filename, normalized_length);
+ pfs->m_filename[normalized_length]= '\0';
+ pfs->m_filename_length= normalized_length;
+ pfs->m_file_stat.m_open_count= 1;
+ pfs->m_file_stat.m_io_stat.reset();
+ pfs->m_identity= (const void *)pfs;
+ pfs->m_temporary= false;
+
+ int res;
+ pfs->m_lock.dirty_to_allocated(& dirty_state);
+ res= lf_hash_insert(&pfs_filename_hash, pins,
+ &pfs);
+ if (likely(res == 0))
+ {
+ if (klass->is_singleton())
+ klass->m_singleton= pfs;
+ return pfs;
+ }
+
+ global_file_container.deallocate(pfs);
+
+ if (res > 0)
+ {
+ /* Duplicate insert by another thread */
+ if (++retry_count > retry_max)
+ {
+ /* Avoid infinite loops */
+ global_file_container.m_lost++;
+ return NULL;
+ }
+ goto search;
+ }
+
+ /* OOM in lf_hash_insert */
+ global_file_container.m_lost++;
+ return NULL;
+ }
+
+ return NULL;
+}
+
+/**
+ Find a file instrumentation instance by name, and rename it
+ @param thread the executing instrumented thread
+ @param old_filename the file to be renamed
+ @param old_len the length in bytes of the old filename
+ @param new_filename the new file name
+ @param new_len the length in bytes of the new filename
+*/
+void find_and_rename_file(PFS_thread *thread, const char *old_filename,
+ uint old_len, const char *new_filename, uint new_len)
+{
+ PFS_file *pfs;
+
+ DBUG_ASSERT(thread != NULL);
+
+ LF_PINS *pins= get_filename_hash_pins(thread);
+ if (unlikely(pins == NULL))
+ {
+ global_file_container.m_lost++;
+ return;
+ }
+
+ /*
+ Normalize the old file name.
+ */
+ char safe_buffer[FN_REFLEN];
+ const char *safe_filename;
+
+ if (old_len >= FN_REFLEN)
+ {
+ memcpy(safe_buffer, old_filename, FN_REFLEN - 1);
+ safe_buffer[FN_REFLEN - 1]= 0;
+ safe_filename= safe_buffer;
+ }
+ else
+ safe_filename= old_filename;
+
+ char buffer[FN_REFLEN];
+ char dirbuffer[FN_REFLEN];
+ size_t dirlen;
+ const char *normalized_filename;
+ uint normalized_length;
+
+ dirlen= dirname_length(safe_filename);
+ if (dirlen == 0)
+ {
+ dirbuffer[0]= FN_CURLIB;
+ dirbuffer[1]= FN_LIBCHAR;
+ dirbuffer[2]= '\0';
+ }
+ else
+ {
+ memcpy(dirbuffer, safe_filename, dirlen);
+ dirbuffer[dirlen]= '\0';
+ }
+
+ if (my_realpath(buffer, dirbuffer, MYF(0)) != 0)
+ {
+ global_file_container.m_lost++;
+ return;
+ }
+
+ /* Append the unresolved file name to the resolved path */
+ char *ptr= buffer + strlen(buffer);
+ char *buf_end= &buffer[sizeof(buffer)-1];
+ if ((buf_end > ptr) && (*(ptr-1) != FN_LIBCHAR))
+ *ptr++= FN_LIBCHAR;
+ if (buf_end > ptr)
+ strncpy(ptr, safe_filename + dirlen, buf_end - ptr);
+ *buf_end= '\0';
+
+ normalized_filename= buffer;
+ normalized_length= (uint)strlen(normalized_filename);
+
+ PFS_file **entry;
+ entry= reinterpret_cast<PFS_file**>
+ (lf_hash_search(&pfs_filename_hash, pins,
+ normalized_filename, normalized_length));
+
+ if (entry && (entry != MY_ERRPTR))
+ pfs= *entry;
+ else
+ {
+ lf_hash_search_unpin(pins);
+ return;
+ }
+
+ lf_hash_delete(&pfs_filename_hash, pins,
+ pfs->m_filename, pfs->m_filename_length);
+
+ /*
+ Normalize the new file name.
+ */
+ if (new_len >= FN_REFLEN)
+ {
+ memcpy(safe_buffer, new_filename, FN_REFLEN - 1);
+ safe_buffer[FN_REFLEN - 1]= 0;
+ safe_filename= safe_buffer;
+ }
+ else
+ safe_filename= new_filename;
+
+ dirlen= dirname_length(safe_filename);
+ if (dirlen == 0)
+ {
+ dirbuffer[0]= FN_CURLIB;
+ dirbuffer[1]= FN_LIBCHAR;
+ dirbuffer[2]= '\0';
+ }
+ else
+ {
+ memcpy(dirbuffer, safe_filename, dirlen);
+ dirbuffer[dirlen]= '\0';
+ }
+
+ if (my_realpath(buffer, dirbuffer, MYF(0)) != 0)
+ {
+ global_file_container.m_lost++;
+ return;
+ }
+
+ /* Append the unresolved file name to the resolved path */
+ ptr= buffer + strlen(buffer);
+ buf_end= &buffer[sizeof(buffer)-1];
+ if ((buf_end > ptr) && (*(ptr-1) != FN_LIBCHAR))
+ *ptr++= FN_LIBCHAR;
+ if (buf_end > ptr)
+ strncpy(ptr, safe_filename + dirlen, buf_end - ptr);
+ *buf_end= '\0';
+
+ normalized_filename= buffer;
+ normalized_length= (uint)strlen(normalized_filename);
+
+ memcpy(pfs->m_filename, normalized_filename, normalized_length);
+ pfs->m_filename[normalized_length]= '\0';
+ pfs->m_filename_length= normalized_length;
+
+ int res;
+ res= lf_hash_insert(&pfs_filename_hash, pins, &pfs);
+
+ if (likely(res == 0))
+ return;
+ else
+ {
+ global_file_container.deallocate(pfs);
+ global_file_container.m_lost++;
+ return;
+ }
+}
+
+/**
+ Release instrumentation for a file instance.
+ @param pfs the file to release
+*/
+void release_file(PFS_file *pfs)
+{
+ DBUG_ASSERT(pfs != NULL);
+ pfs->m_file_stat.m_open_count--;
+}
+
+/**
+ Destroy instrumentation for a file instance.
+ @param thread the executing thread instrumentation
+ @param pfs the file to destroy
+*/
+void destroy_file(PFS_thread *thread, PFS_file *pfs)
+{
+ DBUG_ASSERT(thread != NULL);
+ DBUG_ASSERT(pfs != NULL);
+ PFS_file_class *klass= pfs->m_class;
+
+ /* Aggregate to FILE_SUMMARY_BY_EVENT_NAME */
+ klass->m_file_stat.aggregate(& pfs->m_file_stat);
+ pfs->m_file_stat.reset();
+
+ if (klass->is_singleton())
+ klass->m_singleton= NULL;
+
+ LF_PINS *pins= get_filename_hash_pins(thread);
+ DBUG_ASSERT(pins != NULL);
+
+ lf_hash_delete(&pfs_filename_hash, pins,
+ pfs->m_filename, pfs->m_filename_length);
+ if (klass->is_singleton())
+ klass->m_singleton= NULL;
+
+ global_file_container.deallocate(pfs);
+}
+
+/**
+ Create instrumentation for a table instance.
+ @param share the table share
+ @param opening_thread the opening thread
+ @param identity the table address
+ @return a table instance, or NULL
+*/
+PFS_table* create_table(PFS_table_share *share, PFS_thread *opening_thread,
+ const void *identity)
+{
+ PFS_table *pfs;
+ pfs_dirty_state dirty_state;
+
+ pfs= global_table_container.allocate(& dirty_state);
+ if (pfs != NULL)
+ {
+ pfs->m_identity= identity;
+ pfs->m_share= share;
+ pfs->m_io_enabled= share->m_enabled &&
+ flag_global_instrumentation && global_table_io_class.m_enabled;
+ pfs->m_io_timed= share->m_timed && global_table_io_class.m_timed;
+ pfs->m_lock_enabled= share->m_enabled &&
+ flag_global_instrumentation && global_table_lock_class.m_enabled;
+ pfs->m_lock_timed= share->m_timed && global_table_lock_class.m_timed;
+ pfs->m_has_io_stats= false;
+ pfs->m_has_lock_stats= false;
+ pfs->m_internal_lock= PFS_TL_NONE;
+ pfs->m_external_lock= PFS_TL_NONE;
+ share->inc_refcount();
+ pfs->m_table_stat.fast_reset();
+ pfs->m_thread_owner= opening_thread;
+ pfs->m_owner_event_id= opening_thread->m_event_id;
+ pfs->m_lock.dirty_to_allocated(& dirty_state);
+ }
+
+ return pfs;
+}
+
+void PFS_table::sanitized_aggregate(void)
+{
+ /*
+ This thread could be a TRUNCATE on an aggregated summary table,
+ and not own the table handle.
+ */
+ PFS_table_share *safe_share= sanitize_table_share(m_share);
+ if (safe_share != NULL)
+ {
+ if (m_has_io_stats)
+ {
+ safe_aggregate_io(NULL, & m_table_stat, safe_share);
+ m_has_io_stats= false;
+ }
+ if (m_has_lock_stats)
+ {
+ safe_aggregate_lock(& m_table_stat, safe_share);
+ m_has_lock_stats= false;
+ }
+ }
+}
+
+void PFS_table::sanitized_aggregate_io(void)
+{
+ PFS_table_share *safe_share= sanitize_table_share(m_share);
+ if (safe_share != NULL && m_has_io_stats)
+ {
+ safe_aggregate_io(NULL, & m_table_stat, safe_share);
+ m_has_io_stats= false;
+ }
+}
+
+void PFS_table::sanitized_aggregate_lock(void)
+{
+ PFS_table_share *safe_share= sanitize_table_share(m_share);
+ if (safe_share != NULL && m_has_lock_stats)
+ {
+ safe_aggregate_lock(& m_table_stat, safe_share);
+ m_has_lock_stats= false;
+ }
+}
+
+void PFS_table::safe_aggregate_io(const TABLE_SHARE *optional_server_share,
+ PFS_table_stat *table_stat,
+ PFS_table_share *table_share)
+{
+ DBUG_ASSERT(table_stat != NULL);
+ DBUG_ASSERT(table_share != NULL);
+
+ uint key_count= sanitize_index_count(table_share->m_key_count);
+
+ PFS_table_share_index *to_stat;
+ PFS_table_io_stat *from_stat;
+ uint index;
+
+ DBUG_ASSERT(key_count <= MAX_INDEXES);
+
+ /* Aggregate stats for each index, if any */
+ for (index= 0; index < key_count; index++)
+ {
+ from_stat= & table_stat->m_index_stat[index];
+ if (from_stat->m_has_data)
+ {
+ if (optional_server_share != NULL)
+ {
+ /*
+ An instrumented thread is closing a table,
+ and capable of providing index names when
+ creating index statistics on the fly.
+ */
+ to_stat= table_share->find_or_create_index_stat(optional_server_share, index);
+ }
+ else
+ {
+ /*
+ A monitoring thread, performing TRUNCATE TABLE,
+ is asking to flush existing stats from table handles,
+ but it does not know about index names used in handles.
+ If the index stat already exists, find it and aggregate to it.
+ It the index stat does not exist yet, drop the stat and do nothing.
+ */
+ to_stat= table_share->find_index_stat(index);
+ }
+ if (to_stat != NULL)
+ {
+ /* Aggregate to TABLE_IO_SUMMARY */
+ to_stat->m_stat.aggregate(from_stat);
+ }
+ }
+ }
+
+ /* Aggregate stats for the table */
+ from_stat= & table_stat->m_index_stat[MAX_INDEXES];
+ if (from_stat->m_has_data)
+ {
+ to_stat= table_share->find_or_create_index_stat(NULL, MAX_INDEXES);
+ if (to_stat != NULL)
+ {
+ /* Aggregate to TABLE_IO_SUMMARY */
+ to_stat->m_stat.aggregate(from_stat);
+ }
+ }
+
+ table_stat->fast_reset_io();
+}
+
+void PFS_table::safe_aggregate_lock(PFS_table_stat *table_stat,
+ PFS_table_share *table_share)
+{
+ DBUG_ASSERT(table_stat != NULL);
+ DBUG_ASSERT(table_share != NULL);
+
+ PFS_table_lock_stat *from_stat= & table_stat->m_lock_stat;
+
+ PFS_table_share_lock *to_stat;
+
+ to_stat= table_share->find_or_create_lock_stat();
+ if (to_stat != NULL)
+ {
+ /* Aggregate to TABLE_LOCK_SUMMARY */
+ to_stat->m_stat.aggregate(from_stat);
+ }
+
+ table_stat->fast_reset_lock();
+}
+
+/**
+ Destroy instrumentation for a table instance.
+ @param pfs the table to destroy
+*/
+void destroy_table(PFS_table *pfs)
+{
+ DBUG_ASSERT(pfs != NULL);
+ pfs->m_share->dec_refcount();
+ global_table_container.deallocate(pfs);
+}
+
+/**
+ Create instrumentation for a socket instance.
+ @param klass the socket class
+ @param fd the socket file descriptor
+ @param addr the socket address
+ @param addr_len the socket address length
+ @return a socket instance, or NULL
+*/
+PFS_socket* create_socket(PFS_socket_class *klass, const my_socket *fd,
+ const struct sockaddr *addr, socklen_t addr_len)
+{
+ PFS_socket *pfs;
+ pfs_dirty_state dirty_state;
+
+ uint fd_used= 0;
+ uint addr_len_used= addr_len;
+
+ if (fd != NULL)
+ fd_used= (int)*fd;
+
+ if (addr_len_used > sizeof(sockaddr_storage))
+ addr_len_used= sizeof(sockaddr_storage);
+
+ pfs= global_socket_container.allocate(& dirty_state);
+
+ if (pfs != NULL)
+ {
+ pfs->m_fd= fd_used;
+ /* There is no socket object, so we use the instrumentation. */
+ pfs->m_identity= pfs;
+ pfs->m_class= klass;
+ pfs->m_enabled= klass->m_enabled && flag_global_instrumentation;
+ pfs->m_timed= klass->m_timed;
+ pfs->m_idle= false;
+ pfs->m_socket_stat.reset();
+ pfs->m_thread_owner= NULL;
+
+ pfs->m_addr_len= addr_len_used;
+ if ((addr != NULL) && (addr_len_used > 0))
+ {
+ pfs->m_addr_len= addr_len_used;
+ memcpy(&pfs->m_sock_addr, addr, addr_len_used);
+ }
+ else
+ {
+ pfs->m_addr_len= 0;
+ }
+
+ pfs->m_lock.dirty_to_allocated(& dirty_state);
+
+ if (klass->is_singleton())
+ klass->m_singleton= pfs;
+ }
+
+ return pfs;
+}
+
+/**
+ Destroy instrumentation for a socket instance.
+ @param pfs the socket to destroy
+*/
+void destroy_socket(PFS_socket *pfs)
+{
+ DBUG_ASSERT(pfs != NULL);
+ PFS_socket_class *klass= pfs->m_class;
+
+ /* Aggregate to SOCKET_SUMMARY_BY_EVENT_NAME */
+ klass->m_socket_stat.m_io_stat.aggregate(&pfs->m_socket_stat.m_io_stat);
+
+ if (klass->is_singleton())
+ klass->m_singleton= NULL;
+
+ /* Aggregate to EVENTS_WAITS_SUMMARY_BY_THREAD_BY_EVENT_NAME */
+ PFS_thread *thread= pfs->m_thread_owner;
+ if (thread != NULL)
+ {
+ /* Combine stats for all operations */
+ PFS_single_stat stat;
+ pfs->m_socket_stat.m_io_stat.sum_waits(&stat);
+ if (stat.m_count != 0)
+ {
+ PFS_single_stat *event_name_array;
+ event_name_array= thread->write_instr_class_waits_stats();
+ uint index= pfs->m_class->m_event_name_index;
+
+ event_name_array[index].aggregate(&stat);
+ }
+ }
+
+ pfs->m_socket_stat.reset();
+ pfs->m_thread_owner= NULL;
+ pfs->m_fd= 0;
+ pfs->m_addr_len= 0;
+
+ global_socket_container.deallocate(pfs);
+}
+
+PFS_metadata_lock* create_metadata_lock(void *identity,
+ const MDL_key *mdl_key,
+ opaque_mdl_type mdl_type,
+ opaque_mdl_duration mdl_duration,
+ opaque_mdl_status mdl_status,
+ const char *src_file,
+ uint src_line)
+{
+ PFS_metadata_lock *pfs;
+ pfs_dirty_state dirty_state;
+
+ pfs= global_mdl_container.allocate(& dirty_state);
+ if (pfs != NULL)
+ {
+ pfs->m_identity= identity;
+ pfs->m_enabled= global_metadata_class.m_enabled && flag_global_instrumentation;
+ pfs->m_timed= global_metadata_class.m_timed;
+ pfs->m_mdl_key.mdl_key_init(mdl_key);
+ pfs->m_mdl_type= mdl_type;
+ pfs->m_mdl_duration= mdl_duration;
+ pfs->m_mdl_status= mdl_status;
+ pfs->m_src_file= src_file;
+ pfs->m_src_line= src_line;
+ pfs->m_owner_thread_id= 0;
+ pfs->m_owner_event_id= 0;
+ pfs->m_lock.dirty_to_allocated(& dirty_state);
+ }
+
+ return pfs;
+}
+
+void destroy_metadata_lock(PFS_metadata_lock *pfs)
+{
+ DBUG_ASSERT(pfs != NULL);
+ global_mdl_container.deallocate(pfs);
+}
+
+static void fct_reset_mutex_waits(PFS_mutex *pfs)
+{
+ pfs->m_mutex_stat.reset();
+}
+
+static void reset_mutex_waits_by_instance(void)
+{
+ global_mutex_container.apply_all(fct_reset_mutex_waits);
+}
+
+static void fct_reset_rwlock_waits(PFS_rwlock *pfs)
+{
+ pfs->m_rwlock_stat.reset();
+}
+
+static void reset_rwlock_waits_by_instance(void)
+{
+ global_rwlock_container.apply_all(fct_reset_rwlock_waits);
+}
+
+static void fct_reset_cond_waits(PFS_cond *pfs)
+{
+ pfs->m_cond_stat.reset();
+}
+
+static void reset_cond_waits_by_instance(void)
+{
+ global_cond_container.apply_all(fct_reset_cond_waits);
+}
+
+static void fct_reset_file_waits(PFS_file *pfs)
+{
+ pfs->m_file_stat.reset();
+}
+
+static void reset_file_waits_by_instance(void)
+{
+ global_file_container.apply_all(fct_reset_file_waits);
+}
+
+static void fct_reset_socket_waits(PFS_socket *pfs)
+{
+ pfs->m_socket_stat.reset();
+}
+
+static void reset_socket_waits_by_instance(void)
+{
+ global_socket_container.apply_all(fct_reset_socket_waits);
+}
+
+/** Reset the wait statistics per object instance. */
+void reset_events_waits_by_instance(void)
+{
+ reset_mutex_waits_by_instance();
+ reset_rwlock_waits_by_instance();
+ reset_cond_waits_by_instance();
+ reset_file_waits_by_instance();
+ reset_socket_waits_by_instance();
+}
+
+static void fct_reset_file_io(PFS_file *pfs)
+{
+ pfs->m_file_stat.m_io_stat.reset();
+}
+
+/** Reset the io statistics per file instance. */
+void reset_file_instance_io(void)
+{
+ global_file_container.apply_all(fct_reset_file_io);
+}
+
+static void fct_reset_socket_io(PFS_socket *pfs)
+{
+ pfs->m_socket_stat.m_io_stat.reset();
+}
+
+/** Reset the io statistics per socket instance. */
+void reset_socket_instance_io(void)
+{
+ global_socket_container.apply_all(fct_reset_socket_io);
+}
+
+void aggregate_all_event_names(PFS_single_stat *from_array,
+ PFS_single_stat *to_array)
+{
+ PFS_single_stat *from;
+ PFS_single_stat *from_last;
+ PFS_single_stat *to;
+
+ from= from_array;
+ from_last= from_array + wait_class_max;
+ to= to_array;
+
+ for ( ; from < from_last ; from++, to++)
+ {
+ if (from->m_count > 0)
+ {
+ to->aggregate(from);
+ from->reset();
+ }
+ }
+}
+
+void aggregate_all_event_names(PFS_single_stat *from_array,
+ PFS_single_stat *to_array_1,
+ PFS_single_stat *to_array_2)
+{
+ PFS_single_stat *from;
+ PFS_single_stat *from_last;
+ PFS_single_stat *to_1;
+ PFS_single_stat *to_2;
+
+ from= from_array;
+ from_last= from_array + wait_class_max;
+ to_1= to_array_1;
+ to_2= to_array_2;
+
+ for ( ; from < from_last ; from++, to_1++, to_2++)
+ {
+ if (from->m_count > 0)
+ {
+ to_1->aggregate(from);
+ to_2->aggregate(from);
+ from->reset();
+ }
+ }
+}
+
+void aggregate_all_stages(PFS_stage_stat *from_array,
+ PFS_stage_stat *to_array)
+{
+ PFS_stage_stat *from;
+ PFS_stage_stat *from_last;
+ PFS_stage_stat *to;
+
+ from= from_array;
+ from_last= from_array + stage_class_max;
+ to= to_array;
+
+ for ( ; from < from_last ; from++, to++)
+ {
+ if (from->m_timer1_stat.m_count > 0)
+ {
+ to->aggregate(from);
+ from->reset();
+ }
+ }
+}
+
+void aggregate_all_stages(PFS_stage_stat *from_array,
+ PFS_stage_stat *to_array_1,
+ PFS_stage_stat *to_array_2)
+{
+ PFS_stage_stat *from;
+ PFS_stage_stat *from_last;
+ PFS_stage_stat *to_1;
+ PFS_stage_stat *to_2;
+
+ from= from_array;
+ from_last= from_array + stage_class_max;
+ to_1= to_array_1;
+ to_2= to_array_2;
+
+ for ( ; from < from_last ; from++, to_1++, to_2++)
+ {
+ if (from->m_timer1_stat.m_count > 0)
+ {
+ to_1->aggregate(from);
+ to_2->aggregate(from);
+ from->reset();
+ }
+ }
+}
+
+void aggregate_all_statements(PFS_statement_stat *from_array,
+ PFS_statement_stat *to_array)
+{
+ PFS_statement_stat *from;
+ PFS_statement_stat *from_last;
+ PFS_statement_stat *to;
+
+ from= from_array;
+ from_last= from_array + statement_class_max;
+ to= to_array;
+
+ for ( ; from < from_last ; from++, to++)
+ {
+ if (from->m_timer1_stat.m_count > 0)
+ {
+ to->aggregate(from);
+ from->reset();
+ }
+ }
+}
+
+void aggregate_all_statements(PFS_statement_stat *from_array,
+ PFS_statement_stat *to_array_1,
+ PFS_statement_stat *to_array_2)
+{
+ PFS_statement_stat *from;
+ PFS_statement_stat *from_last;
+ PFS_statement_stat *to_1;
+ PFS_statement_stat *to_2;
+
+ from= from_array;
+ from_last= from_array + statement_class_max;
+ to_1= to_array_1;
+ to_2= to_array_2;
+
+ for ( ; from < from_last ; from++, to_1++, to_2++)
+ {
+ if (from->m_timer1_stat.m_count > 0)
+ {
+ to_1->aggregate(from);
+ to_2->aggregate(from);
+ from->reset();
+ }
+ }
+}
+
+void aggregate_all_transactions(PFS_transaction_stat *from_array,
+ PFS_transaction_stat *to_array)
+{
+ DBUG_ASSERT(from_array != NULL);
+ DBUG_ASSERT(to_array != NULL);
+
+ if (from_array->count() > 0)
+ {
+ to_array->aggregate(from_array);
+ from_array->reset();
+ }
+}
+
+void aggregate_all_transactions(PFS_transaction_stat *from_array,
+ PFS_transaction_stat *to_array_1,
+ PFS_transaction_stat *to_array_2)
+{
+ DBUG_ASSERT(from_array != NULL);
+ DBUG_ASSERT(to_array_1 != NULL);
+ DBUG_ASSERT(to_array_2 != NULL);
+
+ if (from_array->count() > 0)
+ {
+ to_array_1->aggregate(from_array);
+ to_array_2->aggregate(from_array);
+ from_array->reset();
+ }
+}
+
+void aggregate_all_memory(bool alive,
+ PFS_memory_stat *from_array,
+ PFS_memory_stat *to_array)
+{
+ PFS_memory_stat *from;
+ PFS_memory_stat *from_last;
+ PFS_memory_stat *to;
+
+ from= from_array;
+ from_last= from_array + memory_class_max;
+ to= to_array;
+
+ if (alive)
+ {
+ for ( ; from < from_last ; from++, to++)
+ {
+ from->partial_aggregate_to(to);
+ }
+ }
+ else
+ {
+ for ( ; from < from_last ; from++, to++)
+ {
+ from->full_aggregate_to(to);
+ from->reset();
+ }
+ }
+}
+
+void aggregate_all_memory(bool alive,
+ PFS_memory_stat *from_array,
+ PFS_memory_stat *to_array_1,
+ PFS_memory_stat *to_array_2)
+{
+ PFS_memory_stat *from;
+ PFS_memory_stat *from_last;
+ PFS_memory_stat *to_1;
+ PFS_memory_stat *to_2;
+
+ from= from_array;
+ from_last= from_array + memory_class_max;
+ to_1= to_array_1;
+ to_2= to_array_2;
+
+ if (alive)
+ {
+ for ( ; from < from_last ; from++, to_1++, to_2++)
+ {
+ from->partial_aggregate_to(to_1, to_2);
+ }
+ }
+ else
+ {
+ for ( ; from < from_last ; from++, to_1++, to_2++)
+ {
+ from->full_aggregate_to(to_1, to_2);
+ from->reset();
+ }
+ }
+}
+
+void aggregate_thread_status(PFS_thread *thread,
+ PFS_account *safe_account,
+ PFS_user *safe_user,
+ PFS_host *safe_host)
+{
+ THD *thd= thread->m_thd;
+
+ if (thd == NULL)
+ return;
+
+ if (likely(safe_account != NULL))
+ {
+ safe_account->aggregate_status_stats(&thd->status_var);
+ return;
+ }
+
+ if (safe_user != NULL)
+ {
+ safe_user->aggregate_status_stats(&thd->status_var);
+ }
+
+ if (safe_host != NULL)
+ {
+ safe_host->aggregate_status_stats(&thd->status_var);
+ }
+ return;
+}
+
+void aggregate_thread_stats(PFS_thread *thread,
+ PFS_account *safe_account,
+ PFS_user *safe_user,
+ PFS_host *safe_host)
+{
+ if (likely(safe_account != NULL))
+ {
+ safe_account->m_disconnected_count++;
+ }
+
+ if (safe_user != NULL)
+ {
+ safe_user->m_disconnected_count++;
+ }
+
+ if (safe_host != NULL)
+ {
+ safe_host->m_disconnected_count++;
+ }
+
+ /* There is no global table for connections statistics. */
+ return;
+}
+
+void aggregate_thread(PFS_thread *thread,
+ PFS_account *safe_account,
+ PFS_user *safe_user,
+ PFS_host *safe_host)
+{
+ /* No HAVE_PSI_???_INTERFACE flag, waits cover multiple instrumentations */
+ aggregate_thread_waits(thread, safe_account, safe_user, safe_host);
+
+#ifdef HAVE_PSI_STAGE_INTERFACE
+ aggregate_thread_stages(thread, safe_account, safe_user, safe_host);
+#endif
+
+#ifdef HAVE_PSI_STATEMENT_INTERFACE
+ aggregate_thread_statements(thread, safe_account, safe_user, safe_host);
+#endif
+
+#ifdef HAVE_PSI_TRANSACTION_INTERFACE
+ aggregate_thread_transactions(thread, safe_account, safe_user, safe_host);
+#endif
+
+#ifdef HAVE_PSI_MEMORY_INTERFACE
+ aggregate_thread_memory(false, thread, safe_account, safe_user, safe_host);
+#endif
+
+ if (!show_compatibility_56)
+ aggregate_thread_status(thread, safe_account, safe_user, safe_host);
+
+ aggregate_thread_stats(thread, safe_account, safe_user, safe_host);
+}
+
+void aggregate_thread_waits(PFS_thread *thread,
+ PFS_account *safe_account,
+ PFS_user *safe_user,
+ PFS_host *safe_host)
+{
+ if (thread->read_instr_class_waits_stats() == NULL)
+ return;
+
+ if (likely(safe_account != NULL))
+ {
+ /*
+ Aggregate EVENTS_WAITS_SUMMARY_BY_THREAD_BY_EVENT_NAME
+ to EVENTS_WAITS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME.
+ */
+ aggregate_all_event_names(thread->write_instr_class_waits_stats(),
+ safe_account->write_instr_class_waits_stats());
+
+ return;
+ }
+
+ if ((safe_user != NULL) && (safe_host != NULL))
+ {
+ /*
+ Aggregate EVENTS_WAITS_SUMMARY_BY_THREAD_BY_EVENT_NAME to:
+ - EVENTS_WAITS_SUMMARY_BY_USER_BY_EVENT_NAME
+ - EVENTS_WAITS_SUMMARY_BY_HOST_BY_EVENT_NAME
+ in parallel.
+ */
+ aggregate_all_event_names(thread->write_instr_class_waits_stats(),
+ safe_user->write_instr_class_waits_stats(),
+ safe_host->write_instr_class_waits_stats());
+ return;
+ }
+
+ if (safe_user != NULL)
+ {
+ /*
+ Aggregate EVENTS_WAITS_SUMMARY_BY_THREAD_BY_EVENT_NAME
+ to EVENTS_WAITS_SUMMARY_BY_USER_BY_EVENT_NAME, directly.
+ */
+ aggregate_all_event_names(thread->write_instr_class_waits_stats(),
+ safe_user->write_instr_class_waits_stats());
+ return;
+ }
+
+ if (safe_host != NULL)
+ {
+ /*
+ Aggregate EVENTS_WAITS_SUMMARY_BY_THREAD_BY_EVENT_NAME
+ to EVENTS_WAITS_SUMMARY_BY_HOST_BY_EVENT_NAME, directly.
+ */
+ aggregate_all_event_names(thread->write_instr_class_waits_stats(),
+ safe_host->write_instr_class_waits_stats());
+ return;
+ }
+
+ /* Orphan thread, clean the waits stats. */
+ thread->reset_waits_stats();
+}
+
+void aggregate_thread_stages(PFS_thread *thread,
+ PFS_account *safe_account,
+ PFS_user *safe_user,
+ PFS_host *safe_host)
+{
+ if (thread->read_instr_class_stages_stats() == NULL)
+ return;
+
+ if (likely(safe_account != NULL))
+ {
+ /*
+ Aggregate EVENTS_STAGES_SUMMARY_BY_THREAD_BY_EVENT_NAME
+ to EVENTS_STAGES_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME.
+ */
+ aggregate_all_stages(thread->write_instr_class_stages_stats(),
+ safe_account->write_instr_class_stages_stats());
+
+ return;
+ }
+
+ if ((safe_user != NULL) && (safe_host != NULL))
+ {
+ /*
+ Aggregate EVENTS_STAGES_SUMMARY_BY_THREAD_BY_EVENT_NAME to:
+ - EVENTS_STAGES_SUMMARY_BY_USER_BY_EVENT_NAME
+ - EVENTS_STAGES_SUMMARY_BY_HOST_BY_EVENT_NAME
+ in parallel.
+ */
+ aggregate_all_stages(thread->write_instr_class_stages_stats(),
+ safe_user->write_instr_class_stages_stats(),
+ safe_host->write_instr_class_stages_stats());
+ return;
+ }
+
+ if (safe_user != NULL)
+ {
+ /*
+ Aggregate EVENTS_STAGES_SUMMARY_BY_THREAD_BY_EVENT_NAME to:
+ - EVENTS_STAGES_SUMMARY_BY_USER_BY_EVENT_NAME
+ - EVENTS_STAGES_SUMMARY_GLOBAL_BY_EVENT_NAME
+ in parallel.
+ */
+ aggregate_all_stages(thread->write_instr_class_stages_stats(),
+ safe_user->write_instr_class_stages_stats(),
+ global_instr_class_stages_array);
+ return;
+ }
+
+ if (safe_host != NULL)
+ {
+ /*
+ Aggregate EVENTS_STAGES_SUMMARY_BY_THREAD_BY_EVENT_NAME
+ to EVENTS_STAGES_SUMMARY_BY_HOST_BY_EVENT_NAME, directly.
+ */
+ aggregate_all_stages(thread->write_instr_class_stages_stats(),
+ safe_host->write_instr_class_stages_stats());
+ return;
+ }
+
+ /*
+ Aggregate EVENTS_STAGES_SUMMARY_BY_THREAD_BY_EVENT_NAME
+ to EVENTS_STAGES_SUMMARY_GLOBAL_BY_EVENT_NAME.
+ */
+ aggregate_all_stages(thread->write_instr_class_stages_stats(),
+ global_instr_class_stages_array);
+}
+
+void aggregate_thread_statements(PFS_thread *thread,
+ PFS_account *safe_account,
+ PFS_user *safe_user,
+ PFS_host *safe_host)
+{
+ if (thread->read_instr_class_statements_stats() == NULL)
+ return;
+
+ if (likely(safe_account != NULL))
+ {
+ /*
+ Aggregate EVENTS_STATEMENTS_SUMMARY_BY_THREAD_BY_EVENT_NAME
+ to EVENTS_STATEMENTS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME.
+ */
+ aggregate_all_statements(thread->write_instr_class_statements_stats(),
+ safe_account->write_instr_class_statements_stats());
+
+ return;
+ }
+
+ if ((safe_user != NULL) && (safe_host != NULL))
+ {
+ /*
+ Aggregate EVENTS_STATEMENT_SUMMARY_BY_THREAD_BY_EVENT_NAME to:
+ - EVENTS_STATEMENT_SUMMARY_BY_USER_BY_EVENT_NAME
+ - EVENTS_STATEMENT_SUMMARY_BY_HOST_BY_EVENT_NAME
+ in parallel.
+ */
+ aggregate_all_statements(thread->write_instr_class_statements_stats(),
+ safe_user->write_instr_class_statements_stats(),
+ safe_host->write_instr_class_statements_stats());
+ return;
+ }
+
+ if (safe_user != NULL)
+ {
+ /*
+ Aggregate EVENTS_STATEMENTS_SUMMARY_BY_THREAD_BY_EVENT_NAME to:
+ - EVENTS_STATEMENTS_SUMMARY_BY_USER_BY_EVENT_NAME
+ - EVENTS_STATEMENTS_SUMMARY_GLOBAL_BY_EVENT_NAME
+ in parallel.
+ */
+ aggregate_all_statements(thread->write_instr_class_statements_stats(),
+ safe_user->write_instr_class_statements_stats(),
+ global_instr_class_statements_array);
+ return;
+ }
+
+ if (safe_host != NULL)
+ {
+ /*
+ Aggregate EVENTS_STATEMENTS_SUMMARY_BY_THREAD_BY_EVENT_NAME
+ to EVENTS_STATEMENTS_SUMMARY_BY_HOST_BY_EVENT_NAME, directly.
+ */
+ aggregate_all_statements(thread->write_instr_class_statements_stats(),
+ safe_host->write_instr_class_statements_stats());
+ return;
+ }
+
+ /*
+ Aggregate EVENTS_STATEMENTS_SUMMARY_BY_THREAD_BY_EVENT_NAME
+ to EVENTS_STATEMENTS_SUMMARY_GLOBAL_BY_EVENT_NAME.
+ */
+ aggregate_all_statements(thread->write_instr_class_statements_stats(),
+ global_instr_class_statements_array);
+}
+
+void aggregate_thread_transactions(PFS_thread *thread,
+ PFS_account *safe_account,
+ PFS_user *safe_user,
+ PFS_host *safe_host)
+{
+ if (thread->read_instr_class_transactions_stats() == NULL)
+ return;
+
+ if (likely(safe_account != NULL))
+ {
+ /*
+ Aggregate EVENTS_TRANSACTIONS_SUMMARY_BY_THREAD_BY_EVENT_NAME
+ to EVENTS_TRANSACTIONS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME.
+ */
+ aggregate_all_transactions(thread->write_instr_class_transactions_stats(),
+ safe_account->write_instr_class_transactions_stats());
+
+ return;
+ }
+
+ if ((safe_user != NULL) && (safe_host != NULL))
+ {
+ /*
+ Aggregate EVENTS_TRANSACTION_SUMMARY_BY_THREAD_BY_EVENT_NAME to:
+ - EVENTS_TRANSACTION_SUMMARY_BY_USER_BY_EVENT_NAME
+ - EVENTS_TRANSACTION_SUMMARY_BY_HOST_BY_EVENT_NAME
+ in parallel.
+ */
+ aggregate_all_transactions(thread->write_instr_class_transactions_stats(),
+ safe_user->write_instr_class_transactions_stats(),
+ safe_host->write_instr_class_transactions_stats());
+ return;
+ }
+
+ if (safe_user != NULL)
+ {
+ /*
+ Aggregate EVENTS_TRANSACTIONS_SUMMARY_BY_THREAD_BY_EVENT_NAME to:
+ - EVENTS_TRANSACTIONS_SUMMARY_BY_USER_BY_EVENT_NAME
+ - EVENTS_TRANSACTIONS_SUMMARY_GLOBAL_BY_EVENT_NAME
+ in parallel.
+ */
+ aggregate_all_transactions(thread->write_instr_class_transactions_stats(),
+ safe_user->write_instr_class_transactions_stats(),
+ &global_transaction_stat);
+ return;
+ }
+
+ if (safe_host != NULL)
+ {
+ /*
+ Aggregate EVENTS_TRANSACTIONS_SUMMARY_BY_THREAD_BY_EVENT_NAME
+ to EVENTS_TRANSACTIONS_SUMMARY_BY_HOST_BY_EVENT_NAME, directly.
+ */
+ aggregate_all_transactions(thread->write_instr_class_transactions_stats(),
+ safe_host->write_instr_class_transactions_stats());
+ return;
+ }
+
+ /*
+ Aggregate EVENTS_TRANSACTIONS_SUMMARY_BY_THREAD_BY_EVENT_NAME
+ to EVENTS_TRANSACTIONS_SUMMARY_GLOBAL_BY_EVENT_NAME.
+ */
+ aggregate_all_transactions(thread->write_instr_class_transactions_stats(),
+ &global_transaction_stat);
+}
+
+void aggregate_thread_memory(bool alive, PFS_thread *thread,
+ PFS_account *safe_account,
+ PFS_user *safe_user,
+ PFS_host *safe_host)
+{
+ if (thread->read_instr_class_memory_stats() == NULL)
+ return;
+
+ if (likely(safe_account != NULL))
+ {
+ /*
+ Aggregate MEMORY_SUMMARY_BY_THREAD_BY_EVENT_NAME
+ to MEMORY_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME.
+ */
+ aggregate_all_memory(alive,
+ thread->write_instr_class_memory_stats(),
+ safe_account->write_instr_class_memory_stats());
+
+ return;
+ }
+
+ if ((safe_user != NULL) && (safe_host != NULL))
+ {
+ /*
+ Aggregate MEMORY_SUMMARY_BY_THREAD_BY_EVENT_NAME to:
+ - MEMORY_SUMMARY_BY_USER_BY_EVENT_NAME
+ - MEMORY_SUMMARY_BY_HOST_BY_EVENT_NAME
+ in parallel.
+ */
+ aggregate_all_memory(alive,
+ thread->write_instr_class_memory_stats(),
+ safe_user->write_instr_class_memory_stats(),
+ safe_host->write_instr_class_memory_stats());
+ return;
+ }
+
+ if (safe_user != NULL)
+ {
+ /*
+ Aggregate MEMORY_SUMMARY_BY_THREAD_BY_EVENT_NAME to:
+ - MEMORY_SUMMARY_BY_USER_BY_EVENT_NAME
+ - MEMORY_SUMMARY_GLOBAL_BY_EVENT_NAME
+ in parallel.
+ */
+ aggregate_all_memory(alive,
+ thread->write_instr_class_memory_stats(),
+ safe_user->write_instr_class_memory_stats(),
+ global_instr_class_memory_array);
+ return;
+ }
+
+ if (safe_host != NULL)
+ {
+ /*
+ Aggregate MEMORY_SUMMARY_BY_THREAD_BY_EVENT_NAME
+ to MEMORY_SUMMARY_BY_HOST_BY_EVENT_NAME, directly.
+ */
+ aggregate_all_memory(alive,
+ thread->write_instr_class_memory_stats(),
+ safe_host->write_instr_class_memory_stats());
+ return;
+ }
+
+ /*
+ Aggregate MEMORY_SUMMARY_BY_THREAD_BY_EVENT_NAME
+ to MEMORY_SUMMARY_GLOBAL_BY_EVENT_NAME.
+ */
+ aggregate_all_memory(alive,
+ thread->write_instr_class_memory_stats(),
+ global_instr_class_memory_array);
+}
+
+void clear_thread_account(PFS_thread *thread)
+{
+ if (thread->m_account != NULL)
+ {
+ thread->m_account->release();
+ thread->m_account= NULL;
+ }
+
+ if (thread->m_user != NULL)
+ {
+ thread->m_user->release();
+ thread->m_user= NULL;
+ }
+
+ if (thread->m_host != NULL)
+ {
+ thread->m_host->release();
+ thread->m_host= NULL;
+ }
+}
+
+void set_thread_account(PFS_thread *thread)
+{
+ DBUG_ASSERT(thread->m_account == NULL);
+ DBUG_ASSERT(thread->m_user == NULL);
+ DBUG_ASSERT(thread->m_host == NULL);
+
+ thread->m_account= find_or_create_account(thread,
+ thread->m_username,
+ thread->m_username_length,
+ thread->m_hostname,
+ thread->m_hostname_length);
+
+ if ((thread->m_account == NULL) && (thread->m_username_length > 0))
+ thread->m_user= find_or_create_user(thread,
+ thread->m_username,
+ thread->m_username_length);
+
+ if ((thread->m_account == NULL) && (thread->m_hostname_length > 0))
+ thread->m_host= find_or_create_host(thread,
+ thread->m_hostname,
+ thread->m_hostname_length);
+}
+
+static void fct_update_mutex_derived_flags(PFS_mutex *pfs)
+{
+ PFS_mutex_class *klass= sanitize_mutex_class(pfs->m_class);
+ if (likely(klass != NULL))
+ {
+ pfs->m_enabled= klass->m_enabled && flag_global_instrumentation;
+ pfs->m_timed= klass->m_timed;
+ }
+ else
+ {
+ pfs->m_enabled= false;
+ pfs->m_timed= false;
+ }
+}
+
+void update_mutex_derived_flags()
+{
+ global_mutex_container.apply_all(fct_update_mutex_derived_flags);
+}
+
+static void fct_update_rwlock_derived_flags(PFS_rwlock *pfs)
+{
+ PFS_rwlock_class *klass= sanitize_rwlock_class(pfs->m_class);
+ if (likely(klass != NULL))
+ {
+ pfs->m_enabled= klass->m_enabled && flag_global_instrumentation;
+ pfs->m_timed= klass->m_timed;
+ }
+ else
+ {
+ pfs->m_enabled= false;
+ pfs->m_timed= false;
+ }
+}
+
+void update_rwlock_derived_flags()
+{
+ global_rwlock_container.apply_all(fct_update_rwlock_derived_flags);
+}
+
+static void fct_update_cond_derived_flags(PFS_cond *pfs)
+{
+ PFS_cond_class *klass= sanitize_cond_class(pfs->m_class);
+ if (likely(klass != NULL))
+ {
+ pfs->m_enabled= klass->m_enabled && flag_global_instrumentation;
+ pfs->m_timed= klass->m_timed;
+ }
+ else
+ {
+ pfs->m_enabled= false;
+ pfs->m_timed= false;
+ }
+}
+
+void update_cond_derived_flags()
+{
+ global_cond_container.apply_all(fct_update_cond_derived_flags);
+}
+
+static void fct_update_file_derived_flags(PFS_file *pfs)
+{
+ PFS_file_class *klass= sanitize_file_class(pfs->m_class);
+ if (likely(klass != NULL))
+ {
+ pfs->m_enabled= klass->m_enabled && flag_global_instrumentation;
+ pfs->m_timed= klass->m_timed;
+ }
+ else
+ {
+ pfs->m_enabled= false;
+ pfs->m_timed= false;
+ }
+}
+
+void update_file_derived_flags()
+{
+ global_file_container.apply_all(fct_update_file_derived_flags);
+}
+
+void fct_update_table_derived_flags(PFS_table *pfs)
+{
+ PFS_table_share *share= sanitize_table_share(pfs->m_share);
+ if (likely(share != NULL))
+ {
+ pfs->m_io_enabled= share->m_enabled &&
+ flag_global_instrumentation && global_table_io_class.m_enabled;
+ pfs->m_io_timed= share->m_timed && global_table_io_class.m_timed;
+ pfs->m_lock_enabled= share->m_enabled &&
+ flag_global_instrumentation && global_table_lock_class.m_enabled;
+ pfs->m_lock_timed= share->m_timed && global_table_lock_class.m_timed;
+ }
+ else
+ {
+ pfs->m_io_enabled= false;
+ pfs->m_io_timed= false;
+ pfs->m_lock_enabled= false;
+ pfs->m_lock_timed= false;
+ }
+}
+
+void update_table_derived_flags()
+{
+ global_table_container.apply_all(fct_update_table_derived_flags);
+}
+
+static void fct_update_socket_derived_flags(PFS_socket *pfs)
+{
+ PFS_socket_class *klass= sanitize_socket_class(pfs->m_class);
+ if (likely(klass != NULL))
+ {
+ pfs->m_enabled= klass->m_enabled && flag_global_instrumentation;
+ pfs->m_timed= klass->m_timed;
+ }
+ else
+ {
+ pfs->m_enabled= false;
+ pfs->m_timed= false;
+ }
+}
+
+void update_socket_derived_flags()
+{
+ global_socket_container.apply_all(fct_update_socket_derived_flags);
+}
+
+static void fct_update_metadata_derived_flags(PFS_metadata_lock *pfs)
+{
+ pfs->m_enabled= global_metadata_class.m_enabled && flag_global_instrumentation;
+ pfs->m_timed= global_metadata_class.m_timed;
+}
+
+void update_metadata_derived_flags()
+{
+ global_mdl_container.apply_all(fct_update_metadata_derived_flags);
+}
+
+static void fct_update_thread_derived_flags(PFS_thread *pfs)
+{
+ pfs->set_history_derived_flags();
+}
+
+void update_thread_derived_flags()
+{
+ global_thread_container.apply(fct_update_thread_derived_flags);
+}
+
+void update_instruments_derived_flags()
+{
+ update_mutex_derived_flags();
+ update_rwlock_derived_flags();
+ update_cond_derived_flags();
+ update_file_derived_flags();
+ update_table_derived_flags();
+ update_socket_derived_flags();
+ update_metadata_derived_flags();
+ /* nothing for stages, statements and transactions (no instances) */
+}
+
+/** @} */
diff --git a/storage/perfschema/pfs_instr.h b/storage/perfschema/pfs_instr.h
new file mode 100644
index 00000000..ec7dff7d
--- /dev/null
+++ b/storage/perfschema/pfs_instr.h
@@ -0,0 +1,814 @@
+/* Copyright (c) 2008, 2017, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef PFS_INSTR_H
+#define PFS_INSTR_H
+
+/**
+ @file storage/perfschema/pfs_instr.h
+ Performance schema instruments (declarations).
+*/
+
+struct PFS_mutex_class;
+struct PFS_rwlock_class;
+struct PFS_cond_class;
+struct PFS_file_class;
+struct PFS_table_share;
+struct PFS_thread_class;
+struct PFS_socket_class;
+class PFS_opaque_container_page;
+
+class THD;
+
+#include "my_global.h"
+#ifdef _WIN32
+#include <winsock2.h>
+#endif
+#ifdef HAVE_ARPA_INET_H
+#include <arpa/inet.h>
+#endif
+#include "my_compiler.h"
+#include "pfs_lock.h"
+#include "pfs_stat.h"
+#include "pfs_instr_class.h"
+#include "pfs_events_waits.h"
+#include "pfs_events_stages.h"
+#include "pfs_events_statements.h"
+#include "pfs_events_transactions.h"
+#include "pfs_server.h"
+#include "lf.h"
+#include "pfs_con_slice.h"
+#include "pfs_column_types.h"
+#include "mdl.h"
+#include "violite.h" /* enum_vio_type */
+
+extern PFS_single_stat *thread_instr_class_waits_array_start;
+extern PFS_single_stat *thread_instr_class_waits_array_end;
+extern my_bool show_compatibility_56;
+
+/**
+ @addtogroup Performance_schema_buffers
+ @{
+*/
+
+struct PFS_thread;
+struct PFS_host;
+struct PFS_user;
+struct PFS_account;
+
+/** Base structure for wait instruments. */
+struct PFS_instr
+{
+ /** Internal lock. */
+ pfs_lock m_lock;
+ /** Enabled flag. */
+ bool m_enabled;
+ /** Timed flag. */
+ bool m_timed;
+ /** Container page. */
+ PFS_opaque_container_page *m_page;
+};
+
+/** Instrumented mutex implementation. @see PSI_mutex. */
+struct PFS_ALIGNED PFS_mutex : public PFS_instr
+{
+ /** Mutex identity, typically a pthread_mutex_t. */
+ const void *m_identity;
+ /** Mutex class. */
+ PFS_mutex_class *m_class;
+ /** Instrument statistics. */
+ PFS_mutex_stat m_mutex_stat;
+ /** Current owner. */
+ PFS_thread *m_owner;
+ /**
+ Timestamp of the last lock.
+ This statistic is not exposed in user visible tables yet.
+ */
+ ulonglong m_last_locked;
+};
+
+/** Instrumented rwlock implementation. @see PSI_rwlock. */
+struct PFS_ALIGNED PFS_rwlock : public PFS_instr
+{
+ /** RWLock identity, typically a pthread_rwlock_t. */
+ const void *m_identity;
+ /** RWLock class. */
+ PFS_rwlock_class *m_class;
+ /** Instrument statistics. */
+ PFS_rwlock_stat m_rwlock_stat;
+ /** Current writer thread. */
+ PFS_thread *m_writer;
+ /** Current count of readers. */
+ uint m_readers;
+ /**
+ Timestamp of the last write.
+ This statistic is not exposed in user visible tables yet.
+ */
+ ulonglong m_last_written;
+ /**
+ Timestamp of the last read.
+ This statistic is not exposed in user visible tables yet.
+ */
+ ulonglong m_last_read;
+};
+
+/** Instrumented cond implementation. @see PSI_cond. */
+struct PFS_ALIGNED PFS_cond : public PFS_instr
+{
+ /** Condition identity, typically a pthread_cond_t. */
+ const void *m_identity;
+ /** Condition class. */
+ PFS_cond_class *m_class;
+ /** Condition instance usage statistics. */
+ PFS_cond_stat m_cond_stat;
+};
+
+/** Instrumented File and FILE implementation. @see PSI_file. */
+struct PFS_ALIGNED PFS_file : public PFS_instr
+{
+ uint32 get_version()
+ { return m_lock.get_version(); }
+
+ /** File identity */
+ const void *m_identity;
+ /** File name. */
+ char m_filename[FN_REFLEN];
+ /** File name length in bytes. */
+ uint m_filename_length;
+ /** File class. */
+ PFS_file_class *m_class;
+ /** File usage statistics. */
+ PFS_file_stat m_file_stat;
+ /** True if a temporary file. */
+ bool m_temporary;
+};
+
+/** Instrumented table implementation. @see PSI_table. */
+struct PFS_ALIGNED PFS_table
+{
+ /**
+ True if table io instrumentation is enabled.
+ This flag is computed.
+ */
+ bool m_io_enabled;
+ /**
+ True if table lock instrumentation is enabled.
+ This flag is computed.
+ */
+ bool m_lock_enabled;
+ /**
+ True if table io instrumentation is timed.
+ This flag is computed.
+ */
+ bool m_io_timed;
+ /**
+ True if table lock instrumentation is timed.
+ This flag is computed.
+ */
+ bool m_lock_timed;
+
+ /** True if table io statistics have been collected. */
+ bool m_has_io_stats;
+
+ /** True if table lock statistics have been collected. */
+ bool m_has_lock_stats;
+
+public:
+ /**
+ Aggregate this table handle statistics to the parents.
+ Only use this method for handles owned by the calling code.
+ @sa sanitized_aggregate.
+ */
+ void aggregate(const TABLE_SHARE *server_share)
+ {
+ if (m_has_io_stats)
+ {
+ safe_aggregate_io(server_share, & m_table_stat, m_share);
+ m_has_io_stats= false;
+ }
+ if (m_has_lock_stats)
+ {
+ safe_aggregate_lock(& m_table_stat, m_share);
+ m_has_lock_stats= false;
+ }
+ }
+
+ /**
+ Aggregate this table handle statistics to the parents.
+ This method is safe to call on handles not owned by the calling code.
+ @sa aggregate
+ @sa sanitized_aggregate_io
+ @sa sanitized_aggregate_lock
+ */
+ void sanitized_aggregate(void);
+
+ /**
+ Aggregate this table handle io statistics to the parents.
+ This method is safe to call on handles not owned by the calling code.
+ */
+ void sanitized_aggregate_io(void);
+
+ /**
+ Aggregate this table handle lock statistics to the parents.
+ This method is safe to call on handles not owned by the calling code.
+ */
+ void sanitized_aggregate_lock(void);
+
+ /** Internal lock. */
+ pfs_lock m_lock;
+ /** Thread Owner. */
+ PFS_thread *m_thread_owner;
+ /** Event Owner. */
+ ulonglong m_owner_event_id;
+ /** Table share. */
+ PFS_table_share *m_share;
+ /** Table identity, typically a handler. */
+ const void *m_identity;
+ /** Table statistics. */
+ PFS_table_stat m_table_stat;
+ /** Current internal lock. */
+ PFS_TL_LOCK_TYPE m_internal_lock;
+ /** Current external lock. */
+ PFS_TL_LOCK_TYPE m_external_lock;
+ /** Container page. */
+ PFS_opaque_container_page *m_page;
+
+private:
+ static void safe_aggregate_io(const TABLE_SHARE *optional_server_share,
+ PFS_table_stat *stat,
+ PFS_table_share *safe_share);
+ static void safe_aggregate_lock(PFS_table_stat *stat,
+ PFS_table_share *safe_share);
+};
+
+/** Instrumented socket implementation. @see PSI_socket. */
+struct PFS_ALIGNED PFS_socket : public PFS_instr
+{
+ uint32 get_version()
+ { return m_lock.get_version(); }
+
+ /** Socket identity, typically int */
+ const void *m_identity;
+ /** Owning thread, if applicable */
+ PFS_thread *m_thread_owner;
+ /** Socket file descriptor */
+ uint m_fd;
+ /** Raw socket address */
+ struct sockaddr_storage m_sock_addr;
+ /** Length of address */
+ socklen_t m_addr_len;
+ /** Idle flag. */
+ bool m_idle;
+ /** Socket class. */
+ PFS_socket_class *m_class;
+ /** Socket usage statistics. */
+ PFS_socket_stat m_socket_stat;
+};
+
+/** Instrumented metadata lock implementation. @see PSI_metadata_lock. */
+struct PFS_ALIGNED PFS_metadata_lock : public PFS_instr
+{
+ uint32 get_version()
+ { return m_lock.get_version(); }
+
+ /** Lock identity. */
+ const void *m_identity;
+ MDL_key m_mdl_key;
+ opaque_mdl_type m_mdl_type;
+ opaque_mdl_duration m_mdl_duration;
+ opaque_mdl_status m_mdl_status;
+ const char *m_src_file;
+ uint m_src_line;
+ ulonglong m_owner_thread_id;
+ ulonglong m_owner_event_id;
+};
+
+/**
+ @def WAIT_STACK_LOGICAL_SIZE
+ Maximum number of nested waits.
+ Some waits, such as:
+ - "wait/io/table/sql/handler"
+ - "wait/lock/table/sql/handler"
+ are implemented by calling code in a storage engine,
+ that can cause nested waits (file io, mutex, ...)
+ Because of partitioned tables, a table io event (on the whole table)
+ can contain a nested table io event (on a partition).
+ Because of additional debug instrumentation,
+ waiting on what looks like a "mutex" (safe_mutex, innodb sync0sync, ...)
+ can cause nested waits to be recorded.
+ For example, a wait on innodb mutexes can lead to:
+ - wait/sync/mutex/innobase/some_mutex
+ - wait/sync/mutex/innobase/sync0sync
+ - wait/sync/mutex/innobase/os0sync
+ The max depth of the event stack must be sufficient
+ for these low level details to be visible.
+*/
+#define WAIT_STACK_LOGICAL_SIZE 5
+/**
+ @def WAIT_STACK_BOTTOM
+ Maximum number dummy waits records.
+ One dummy record is reserved for the parent stage / statement / transaction,
+ at the bottom of the wait stack.
+*/
+#define WAIT_STACK_BOTTOM 1
+/**
+ @def WAIT_STACK_SIZE
+ Physical size of the waits stack
+*/
+#define WAIT_STACK_SIZE (WAIT_STACK_BOTTOM + WAIT_STACK_LOGICAL_SIZE)
+
+/** Max size of the statements stack. */
+extern uint statement_stack_max;
+/** Max size of the digests token array. */
+extern size_t pfs_max_digest_length;
+/** Max size of SQL TEXT. */
+extern size_t pfs_max_sqltext;
+
+/** Instrumented thread implementation. @see PSI_thread. */
+struct PFS_ALIGNED PFS_thread : PFS_connection_slice
+{
+ static PFS_thread* get_current_thread(void);
+
+ /** Thread instrumentation flag. */
+ bool m_enabled;
+ /** Thread history instrumentation flag. */
+ bool m_history;
+
+ /**
+ Derived flag flag_events_waits_history, per thread.
+ Cached computation of
+ TABLE SETUP_CONSUMERS[EVENTS_WAITS_HISTORY].ENABLED == 'YES'
+ AND
+ TABLE THREADS[THREAD_ID].HISTORY == 'YES'
+ */
+ bool m_flag_events_waits_history;
+ /**
+ Derived flag flag_events_waits_history_long, per thread.
+ Cached computation of
+ TABLE SETUP_CONSUMERS[EVENTS_WAITS_HISTORY_LONG].ENABLED == 'YES'
+ AND
+ TABLE THREADS[THREAD_ID].HISTORY == 'YES'
+ */
+ bool m_flag_events_waits_history_long;
+ /**
+ Derived flag flag_events_stages_history, per thread.
+ Cached computation of
+ TABLE SETUP_CONSUMERS[EVENTS_STAGES_HISTORY].ENABLED == 'YES'
+ AND
+ TABLE THREADS[THREAD_ID].HISTORY == 'YES'
+ */
+ bool m_flag_events_stages_history;
+ /**
+ Derived flag flag_events_stages_history_long, per thread.
+ Cached computation of
+ TABLE SETUP_CONSUMERS[EVENTS_STAGES_HISTORY_LONG].ENABLED == 'YES'
+ AND
+ TABLE THREADS[THREAD_ID].HISTORY == 'YES'
+ */
+ bool m_flag_events_stages_history_long;
+ /**
+ Derived flag flag_events_statements_history, per thread.
+ Cached computation of
+ TABLE SETUP_CONSUMERS[EVENTS_STATEMENTS_HISTORY].ENABLED == 'YES'
+ AND
+ TABLE THREADS[THREAD_ID].HISTORY == 'YES'
+ */
+ bool m_flag_events_statements_history;
+ /**
+ Derived flag flag_events_statements_history_long, per thread.
+ Cached computation of
+ TABLE SETUP_CONSUMERS[EVENTS_STATEMENTS_HISTORY_LONG].ENABLED == 'YES'
+ AND
+ TABLE THREADS[THREAD_ID].HISTORY == 'YES'
+ */
+ bool m_flag_events_statements_history_long;
+ /**
+ Derived flag flag_events_transactions_history, per thread.
+ Cached computation of
+ TABLE SETUP_CONSUMERS[EVENTS_TRANSACTIONS_HISTORY].ENABLED == 'YES'
+ AND
+ TABLE THREADS[THREAD_ID].HISTORY == 'YES'
+ */
+ bool m_flag_events_transactions_history;
+ /**
+ Derived flag flag_events_transactions_history_long, per thread.
+ Cached computation of
+ TABLE SETUP_CONSUMERS[EVENTS_TRANSACTIONS_HISTORY_LONG].ENABLED == 'YES'
+ AND
+ TABLE THREADS[THREAD_ID].HISTORY == 'YES'
+ */
+ bool m_flag_events_transactions_history_long;
+
+ /** Current wait event in the event stack. */
+ PFS_events_waits *m_events_waits_current;
+ /** Event ID counter */
+ ulonglong m_event_id;
+ /**
+ Internal lock.
+ This lock is exclusively used to protect against races
+ when creating and destroying PFS_thread.
+ Do not use this lock to protect thread attributes,
+ use one of @c m_stmt_lock or @c m_session_lock instead.
+ */
+ pfs_lock m_lock;
+ /** Pins for filename_hash. */
+ LF_PINS *m_filename_hash_pins;
+ /** Pins for table_share_hash. */
+ LF_PINS *m_table_share_hash_pins;
+ /** Pins for setup_actor_hash. */
+ LF_PINS *m_setup_actor_hash_pins;
+ /** Pins for setup_object_hash. */
+ LF_PINS *m_setup_object_hash_pins;
+ /** Pins for host_hash. */
+ LF_PINS *m_host_hash_pins;
+ /** Pins for user_hash. */
+ LF_PINS *m_user_hash_pins;
+ /** Pins for account_hash. */
+ LF_PINS *m_account_hash_pins;
+ /** Pins for digest_hash. */
+ LF_PINS *m_digest_hash_pins;
+ /** Pins for routine_hash. */
+ LF_PINS *m_program_hash_pins;
+ /** Internal thread identifier, unique. */
+ ulonglong m_thread_internal_id;
+ /** Parent internal thread identifier. */
+ ulonglong m_parent_thread_internal_id;
+ /** External (SHOW PROCESSLIST) thread identifier, not unique. */
+ ulong m_processlist_id;
+ /** External (Operating system) thread identifier, if any. */
+ uint32 m_thread_os_id;
+ /** Thread class. */
+ PFS_thread_class *m_class;
+ /**
+ Stack of events waits.
+ This member holds the data for the table PERFORMANCE_SCHEMA.EVENTS_WAITS_CURRENT.
+ Note that stack[0] is a dummy record that represents the parent stage/statement/transaction.
+ For example, assuming the following tree:
+ - STAGE ID 100
+ - WAIT ID 101, parent STAGE 100
+ - WAIT ID 102, parent wait 101
+ the data in the stack will be:
+ stack[0].m_event_id= 100, set by the stage instrumentation
+ stack[0].m_event_type= STAGE, set by the stage instrumentation
+ stack[0].m_nesting_event_id= unused
+ stack[0].m_nesting_event_type= unused
+ stack[1].m_event_id= 101
+ stack[1].m_event_type= WAIT
+ stack[1].m_nesting_event_id= stack[0].m_event_id= 100
+ stack[1].m_nesting_event_type= stack[0].m_event_type= STAGE
+ stack[2].m_event_id= 102
+ stack[2].m_event_type= WAIT
+ stack[2].m_nesting_event_id= stack[1].m_event_id= 101
+ stack[2].m_nesting_event_type= stack[1].m_event_type= WAIT
+
+ The whole point of the stack[0] record is to allow this optimization
+ in the code, in the instrumentation for wait events:
+ wait->m_nesting_event_id= (wait-1)->m_event_id;
+ wait->m_nesting_event_type= (wait-1)->m_event_type;
+ This code works for both the top level wait, and nested waits,
+ and works without if conditions, which helps performances.
+ */
+ PFS_events_waits m_events_waits_stack[WAIT_STACK_SIZE];
+ /** True if the circular buffer @c m_waits_history is full. */
+ bool m_waits_history_full;
+ /** Current index in the circular buffer @c m_waits_history. */
+ uint m_waits_history_index;
+ /**
+ Waits history circular buffer.
+ This member holds the data for the table
+ PERFORMANCE_SCHEMA.EVENTS_WAITS_HISTORY.
+ */
+ PFS_events_waits *m_waits_history;
+
+ /** True if the circular buffer @c m_stages_history is full. */
+ bool m_stages_history_full;
+ /** Current index in the circular buffer @c m_stages_history. */
+ uint m_stages_history_index;
+ /**
+ Stages history circular buffer.
+ This member holds the data for the table
+ PERFORMANCE_SCHEMA.EVENTS_STAGES_HISTORY.
+ */
+ PFS_events_stages *m_stages_history;
+
+ /** True if the circular buffer @c m_statements_history is full. */
+ bool m_statements_history_full;
+ /** Current index in the circular buffer @c m_statements_history. */
+ uint m_statements_history_index;
+ /**
+ Statements history circular buffer.
+ This member holds the data for the table
+ PERFORMANCE_SCHEMA.EVENTS_STATEMENTS_HISTORY.
+ */
+ PFS_events_statements *m_statements_history;
+
+ /** True if the circular buffer @c m_transactions_history is full. */
+ bool m_transactions_history_full;
+ /** Current index in the circular buffer @c m_transactions_history. */
+ uint m_transactions_history_index;
+ /**
+ Statements history circular buffer.
+ This member holds the data for the table
+ PERFORMANCE_SCHEMA.EVENTS_TRANSACTIONS_HISTORY.
+ */
+ PFS_events_transactions *m_transactions_history;
+
+ /**
+ Internal lock, for session attributes.
+ Statement attributes are expected to be updated in frequently,
+ typically per session execution.
+ */
+ pfs_lock m_session_lock;
+
+ /**
+ User name.
+ Protected by @c m_session_lock.
+ */
+ char m_username[USERNAME_LENGTH];
+ /**
+ Length of @c m_username.
+ Protected by @c m_session_lock.
+ */
+ uint m_username_length;
+ /**
+ Host name.
+ Protected by @c m_session_lock.
+ */
+ char m_hostname[HOSTNAME_LENGTH];
+ /**
+ Length of @c m_hostname.
+ Protected by @c m_session_lock.
+ */
+ uint m_hostname_length;
+ /**
+ Database name.
+ Protected by @c m_stmt_lock.
+ */
+ char m_dbname[NAME_LEN];
+ /**
+ Length of @c m_dbname.
+ Protected by @c m_stmt_lock.
+ */
+ uint m_dbname_length;
+ /** Current command. */
+ int m_command;
+ /** Connection type. */
+ enum_vio_type m_connection_type;
+ /** Start time. */
+ time_t m_start_time;
+ /**
+ Internal lock, for statement attributes.
+ Statement attributes are expected to be updated frequently,
+ typically per statement execution.
+ */
+ pfs_lock m_stmt_lock;
+ /** Processlist state (derived from stage). */
+ PFS_stage_key m_stage;
+ /** Current stage progress. */
+ PSI_stage_progress* m_stage_progress;
+ /**
+ Processlist info.
+ Protected by @c m_stmt_lock.
+ */
+ char m_processlist_info[COL_INFO_SIZE];
+ /**
+ Length of @c m_processlist_info_length.
+ Protected by @c m_stmt_lock.
+ */
+ uint m_processlist_info_length;
+
+ PFS_events_stages m_stage_current;
+
+ /** Size of @c m_events_statements_stack. */
+ uint m_events_statements_count;
+ PFS_events_statements *m_statement_stack;
+
+ PFS_events_transactions m_transaction_current;
+
+ THD *m_thd;
+ PFS_host *m_host;
+ PFS_user *m_user;
+ PFS_account *m_account;
+
+ /** Reset session connect attributes */
+ void reset_session_connect_attrs();
+
+ /**
+ Buffer for the connection attributes.
+ Protected by @c m_session_lock.
+ */
+ char *m_session_connect_attrs;
+ /**
+ Length used by @c m_connect_attrs.
+ Protected by @c m_session_lock.
+ */
+ uint m_session_connect_attrs_length;
+ /**
+ Character set in which @c m_connect_attrs are encoded.
+ Protected by @c m_session_lock.
+ */
+ uint m_session_connect_attrs_cs_number;
+
+ void carry_memory_stat_delta(PFS_memory_stat_delta *delta, uint index);
+
+ void set_enabled(bool enabled)
+ {
+ m_enabled= enabled;
+ }
+
+ void set_history(bool history)
+ {
+ m_history= history;
+ set_history_derived_flags();
+ }
+
+ void set_history_derived_flags();
+};
+
+void carry_global_memory_stat_delta(PFS_memory_stat_delta *delta, uint index);
+
+extern PFS_stage_stat *global_instr_class_stages_array;
+extern PFS_statement_stat *global_instr_class_statements_array;
+extern PFS_memory_stat *global_instr_class_memory_array;
+
+PFS_mutex *sanitize_mutex(PFS_mutex *unsafe);
+PFS_rwlock *sanitize_rwlock(PFS_rwlock *unsafe);
+PFS_cond *sanitize_cond(PFS_cond *unsafe);
+PFS_thread *sanitize_thread(PFS_thread *unsafe);
+PFS_file *sanitize_file(PFS_file *unsafe);
+PFS_socket *sanitize_socket(PFS_socket *unsafe);
+PFS_metadata_lock *sanitize_metadata_lock(PFS_metadata_lock *unsafe);
+
+int init_instruments(const PFS_global_param *param);
+void cleanup_instruments();
+int init_file_hash(const PFS_global_param *param);
+void cleanup_file_hash();
+PFS_mutex* create_mutex(PFS_mutex_class *mutex_class, const void *identity);
+void destroy_mutex(PFS_mutex *pfs);
+PFS_rwlock* create_rwlock(PFS_rwlock_class *klass, const void *identity);
+void destroy_rwlock(PFS_rwlock *pfs);
+PFS_cond* create_cond(PFS_cond_class *klass, const void *identity);
+void destroy_cond(PFS_cond *pfs);
+
+PFS_thread* create_thread(PFS_thread_class *klass, const void *identity,
+ ulonglong processlist_id);
+
+void destroy_thread(PFS_thread *pfs);
+
+PFS_file* find_or_create_file(PFS_thread *thread, PFS_file_class *klass,
+ const char *filename, uint len, bool create);
+void find_and_rename_file(PFS_thread *thread, const char *old_filename,
+ uint old_len, const char *new_filename,
+ uint new_len);
+
+void release_file(PFS_file *pfs);
+void destroy_file(PFS_thread *thread, PFS_file *pfs);
+PFS_table* create_table(PFS_table_share *share, PFS_thread *opening_thread,
+ const void *identity);
+void destroy_table(PFS_table *pfs);
+
+PFS_socket* create_socket(PFS_socket_class *socket_class,
+ const my_socket *fd,
+ const struct sockaddr *addr,
+ socklen_t addr_len);
+void destroy_socket(PFS_socket *pfs);
+
+PFS_metadata_lock* create_metadata_lock(void *identity,
+ const MDL_key *mdl_key,
+ opaque_mdl_type mdl_type,
+ opaque_mdl_duration mdl_duration,
+ opaque_mdl_status mdl_status,
+ const char *src_file,
+ uint src_line);
+void destroy_metadata_lock(PFS_metadata_lock *pfs);
+
+/* For iterators and show status. */
+
+extern long file_handle_max;
+extern ulong file_handle_lost;
+extern ulong events_waits_history_per_thread;
+extern ulong events_stages_history_per_thread;
+extern ulong events_statements_history_per_thread;
+extern ulong events_transactions_history_per_thread;
+extern ulong locker_lost;
+extern ulong statement_lost;
+extern ulong session_connect_attrs_lost;
+extern ulong session_connect_attrs_size_per_thread;
+
+/* Exposing the data directly, for iterators. */
+
+extern PFS_file **file_handle_array;
+
+void reset_events_waits_by_instance();
+void reset_file_instance_io();
+void reset_socket_instance_io();
+
+void aggregate_all_event_names(PFS_single_stat *from_array,
+ PFS_single_stat *to_array);
+void aggregate_all_event_names(PFS_single_stat *from_array,
+ PFS_single_stat *to_array_1,
+ PFS_single_stat *to_array_2);
+
+void aggregate_all_stages(PFS_stage_stat *from_array,
+ PFS_stage_stat *to_array);
+void aggregate_all_stages(PFS_stage_stat *from_array,
+ PFS_stage_stat *to_array_1,
+ PFS_stage_stat *to_array_2);
+
+void aggregate_all_statements(PFS_statement_stat *from_array,
+ PFS_statement_stat *to_array);
+void aggregate_all_statements(PFS_statement_stat *from_array,
+ PFS_statement_stat *to_array_1,
+ PFS_statement_stat *to_array_2);
+
+void aggregate_all_transactions(PFS_transaction_stat *from_array,
+ PFS_transaction_stat *to_array);
+void aggregate_all_transactions(PFS_transaction_stat *from_array,
+ PFS_transaction_stat *to_array_1,
+ PFS_transaction_stat *to_array_2);
+
+void aggregate_all_memory(bool alive,
+ PFS_memory_stat *from_array,
+ PFS_memory_stat *to_array);
+void aggregate_all_memory(bool alive,
+ PFS_memory_stat *from_array,
+ PFS_memory_stat *to_array_1,
+ PFS_memory_stat *to_array_2);
+
+void aggregate_thread(PFS_thread *thread,
+ PFS_account *safe_account,
+ PFS_user *safe_user,
+ PFS_host *safe_host);
+void aggregate_thread_waits(PFS_thread *thread,
+ PFS_account *safe_account,
+ PFS_user *safe_user,
+ PFS_host *safe_host);
+void aggregate_thread_stages(PFS_thread *thread,
+ PFS_account *safe_account,
+ PFS_user *safe_user,
+ PFS_host *safe_host);
+void aggregate_thread_statements(PFS_thread *thread,
+ PFS_account *safe_account,
+ PFS_user *safe_user,
+ PFS_host *safe_host);
+void aggregate_thread_transactions(PFS_thread *thread,
+ PFS_account *safe_account,
+ PFS_user *safe_user,
+ PFS_host *safe_host);
+
+void aggregate_thread_memory(bool alive, PFS_thread *thread,
+ PFS_account *safe_account,
+ PFS_user *safe_user,
+ PFS_host *safe_host);
+
+void aggregate_thread_status(PFS_thread *thread,
+ PFS_account *safe_account,
+ PFS_user *safe_user,
+ PFS_host *safe_host);
+
+void clear_thread_account(PFS_thread *thread);
+void set_thread_account(PFS_thread *thread);
+
+/** Update derived flags for all mutex instances. */
+void update_mutex_derived_flags();
+/** Update derived flags for all rwlock instances. */
+void update_rwlock_derived_flags();
+/** Update derived flags for all condition instances. */
+void update_cond_derived_flags();
+/** Update derived flags for all file handles. */
+void update_file_derived_flags();
+/** Update derived flags for all table handles. */
+void update_table_derived_flags();
+/** Update derived flags for all socket instances. */
+void update_socket_derived_flags();
+/** Update derived flags for all metadata instances. */
+void update_metadata_derived_flags();
+/** Update derived flags for all thread instances. */
+void update_thread_derived_flags();
+/** Update derived flags for all instruments. */
+void update_instruments_derived_flags();
+
+extern LF_HASH pfs_filename_hash;
+
+/** @} */
+#endif
+
diff --git a/storage/perfschema/pfs_instr_class.cc b/storage/perfschema/pfs_instr_class.cc
new file mode 100644
index 00000000..3b59375c
--- /dev/null
+++ b/storage/perfschema/pfs_instr_class.cc
@@ -0,0 +1,2064 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+ Copyright (c) 2020, MariaDB Corporation.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/pfs_instr_class.cc
+ Performance schema instruments meta data (implementation).
+*/
+
+#include "my_global.h"
+#include "my_sys.h"
+#include "table.h"
+#include "pfs_instr_class.h"
+#include "pfs_builtin_memory.h"
+#include "pfs_instr.h"
+#include "pfs_global.h"
+#include "pfs_timer.h"
+#include "pfs_events_waits.h"
+#include "pfs_setup_object.h"
+#include "pfs_atomic.h"
+#include "pfs_program.h"
+#include "pfs_buffer_container.h"
+#include "mysql/psi/mysql_thread.h"
+#include "lf.h"
+
+#include <string.h>
+
+/**
+ @defgroup Performance_schema_buffers Performance Schema Buffers
+ @ingroup Performance_schema_implementation
+ @{
+*/
+
+/**
+ Global performance schema flag.
+ Indicate if the performance schema is enabled.
+ This flag is set at startup, and never changes.
+*/
+my_bool pfs_enabled= TRUE;
+
+/**
+ PFS_INSTRUMENT option settings array
+ */
+Pfs_instr_config_array *pfs_instr_config_array= NULL;
+
+static void configure_instr_class(PFS_instr_class *entry);
+
+static void init_instr_class(PFS_instr_class *klass,
+ const char *name,
+ uint name_length,
+ int flags,
+ PFS_class_type class_type);
+
+/**
+ Current number of elements in mutex_class_array.
+ This global variable is written to during:
+ - the performance schema initialization
+ - a plugin initialization
+*/
+static uint32 mutex_class_dirty_count= 0;
+static uint32 mutex_class_allocated_count= 0;
+static uint32 rwlock_class_dirty_count= 0;
+static uint32 rwlock_class_allocated_count= 0;
+static uint32 cond_class_dirty_count= 0;
+static uint32 cond_class_allocated_count= 0;
+
+/** Size of the mutex class array. @sa mutex_class_array */
+ulong mutex_class_max= 0;
+/** Number of mutex class lost. @sa mutex_class_array */
+ulong mutex_class_lost= 0;
+/** Size of the rwlock class array. @sa rwlock_class_array */
+ulong rwlock_class_max= 0;
+/** Number of rwlock class lost. @sa rwlock_class_array */
+ulong rwlock_class_lost= 0;
+/** Size of the condition class array. @sa cond_class_array */
+ulong cond_class_max= 0;
+/** Number of condition class lost. @sa cond_class_array */
+ulong cond_class_lost= 0;
+/** Size of the thread class array. @sa thread_class_array */
+ulong thread_class_max= 0;
+/** Number of thread class lost. @sa thread_class_array */
+ulong thread_class_lost= 0;
+/** Size of the file class array. @sa file_class_array */
+ulong file_class_max= 0;
+/** Number of file class lost. @sa file_class_array */
+ulong file_class_lost= 0;
+/** Size of the stage class array. @sa stage_class_array */
+ulong stage_class_max= 0;
+/** Number of stage class lost. @sa stage_class_array */
+ulong stage_class_lost= 0;
+/** Size of the statement class array. @sa statement_class_array */
+ulong statement_class_max= 0;
+/** Number of statement class lost. @sa statement_class_array */
+ulong statement_class_lost= 0;
+/** Size of the socket class array. @sa socket_class_array */
+ulong socket_class_max= 0;
+/** Number of socket class lost. @sa socket_class_array */
+ulong socket_class_lost= 0;
+/** Size of the memory class array. @sa memory_class_array */
+ulong memory_class_max= 0;
+/** Number of memory class lost. @sa memory_class_array */
+ulong memory_class_lost= 0;
+
+/**
+ Number of transaction classes. Although there is only one transaction class,
+ this is used for sizing by other event classes.
+ @sa global_transaction_class
+*/
+ulong transaction_class_max= 0;
+
+PFS_mutex_class *mutex_class_array= NULL;
+PFS_rwlock_class *rwlock_class_array= NULL;
+PFS_cond_class *cond_class_array= NULL;
+
+/**
+ Current number or elements in thread_class_array.
+ This global variable is written to during:
+ - the performance schema initialization
+ - a plugin initialization
+*/
+static uint32 thread_class_dirty_count= 0;
+static uint32 thread_class_allocated_count= 0;
+
+static PFS_thread_class *thread_class_array= NULL;
+
+PFS_ALIGNED PFS_single_stat global_idle_stat;
+PFS_ALIGNED PFS_table_io_stat global_table_io_stat;
+PFS_ALIGNED PFS_table_lock_stat global_table_lock_stat;
+PFS_ALIGNED PFS_single_stat global_metadata_stat;
+PFS_ALIGNED PFS_transaction_stat global_transaction_stat;
+PFS_ALIGNED PFS_instr_class global_table_io_class;
+PFS_ALIGNED PFS_instr_class global_table_lock_class;
+PFS_ALIGNED PFS_instr_class global_idle_class;
+PFS_ALIGNED PFS_instr_class global_metadata_class;
+PFS_ALIGNED PFS_transaction_class global_transaction_class;
+
+/** Class-timer map */
+enum_timer_name *class_timers[] =
+{&wait_timer, /* PFS_CLASS_NONE */
+ &wait_timer, /* PFS_CLASS_MUTEX */
+ &wait_timer, /* PFS_CLASS_RWLOCK */
+ &wait_timer, /* PFS_CLASS_COND */
+ &wait_timer, /* PFS_CLASS_FILE */
+ &wait_timer, /* PFS_CLASS_TABLE */
+ &stage_timer, /* PFS_CLASS_STAGE */
+ &statement_timer, /* PFS_CLASS_STATEMENT */
+ &transaction_timer, /* PFS_CLASS_TRANSACTION */
+ &wait_timer, /* PFS_CLASS_SOCKET */
+ &wait_timer, /* PFS_CLASS_TABLE_IO */
+ &wait_timer, /* PFS_CLASS_TABLE_LOCK */
+ &idle_timer, /* PFS_CLASS_IDLE */
+ &wait_timer, /* PFS_CLASS_METADATA */
+ &wait_timer /* PFS_CLASS_MEMORY */
+};
+
+/**
+ Hash index for instrumented table shares.
+ This index is searched by table fully qualified name (@c PFS_table_share_key),
+ and points to instrumented table shares (@c PFS_table_share).
+ @sa PFS_table_share_key
+ @sa PFS_table_share
+ @sa table_share_hash_get_key
+ @sa get_table_share_hash_pins
+*/
+LF_HASH table_share_hash;
+/** True if table_share_hash is initialized. */
+static bool table_share_hash_inited= false;
+
+static uint32 file_class_dirty_count= 0;
+static uint32 file_class_allocated_count= 0;
+
+PFS_file_class *file_class_array= NULL;
+
+static uint32 stage_class_dirty_count= 0;
+static uint32 stage_class_allocated_count= 0;
+
+static PFS_stage_class *stage_class_array= NULL;
+
+static uint32 statement_class_dirty_count= 0;
+static uint32 statement_class_allocated_count= 0;
+
+static PFS_statement_class *statement_class_array= NULL;
+
+static uint32 socket_class_dirty_count= 0;
+static uint32 socket_class_allocated_count= 0;
+
+static PFS_socket_class *socket_class_array= NULL;
+
+static uint32 memory_class_dirty_count= 0;
+static uint32 memory_class_allocated_count= 0;
+
+static PFS_memory_class *memory_class_array= NULL;
+
+uint mutex_class_start= 0;
+uint rwlock_class_start= 0;
+uint cond_class_start= 0;
+uint file_class_start= 0;
+uint wait_class_max= 0;
+uint socket_class_start= 0;
+
+void init_event_name_sizing(const PFS_global_param *param)
+{
+ /* global table io, table lock, idle, metadata */
+ mutex_class_start= COUNT_GLOBAL_EVENT_INDEX;
+ rwlock_class_start= mutex_class_start + param->m_mutex_class_sizing;
+ cond_class_start= rwlock_class_start + param->m_rwlock_class_sizing;
+ file_class_start= cond_class_start + param->m_cond_class_sizing;
+ socket_class_start= file_class_start + param->m_file_class_sizing;
+ wait_class_max= socket_class_start + param->m_socket_class_sizing;
+}
+
+void register_global_classes()
+{
+ /* Table IO class */
+ init_instr_class(&global_table_io_class, "wait/io/table/sql/handler", 25,
+ 0, PFS_CLASS_TABLE_IO);
+ global_table_io_class.m_event_name_index= GLOBAL_TABLE_IO_EVENT_INDEX;
+ configure_instr_class(&global_table_io_class);
+
+ /* Table lock class */
+ init_instr_class(&global_table_lock_class, "wait/lock/table/sql/handler", 27,
+ 0, PFS_CLASS_TABLE_LOCK);
+ global_table_lock_class.m_event_name_index= GLOBAL_TABLE_LOCK_EVENT_INDEX;
+ configure_instr_class(&global_table_lock_class);
+
+ /* Idle class */
+ init_instr_class(&global_idle_class, "idle", 4,
+ 0, PFS_CLASS_IDLE);
+ global_idle_class.m_event_name_index= GLOBAL_IDLE_EVENT_INDEX;
+ configure_instr_class(&global_idle_class);
+
+ /* Metadata class */
+ init_instr_class(&global_metadata_class, "wait/lock/metadata/sql/mdl", 26,
+ 0, PFS_CLASS_METADATA);
+ global_metadata_class.m_event_name_index= GLOBAL_METADATA_EVENT_INDEX;
+ global_metadata_class.m_enabled= false; /* Disabled by default */
+ global_metadata_class.m_timed= false;
+ configure_instr_class(&global_metadata_class);
+
+ /* Transaction class */
+ init_instr_class(&global_transaction_class, "transaction", 11,
+ 0, PFS_CLASS_TRANSACTION);
+ global_transaction_class.m_event_name_index= GLOBAL_TRANSACTION_INDEX;
+ global_transaction_class.m_enabled= false; /* Disabled by default */
+ global_transaction_class.m_timed= false;
+ configure_instr_class(&global_transaction_class);
+ transaction_class_max= 1; /* used for sizing by other event classes */
+}
+
+/**
+ Initialize the instrument synch class buffers.
+ @param mutex_class_sizing max number of mutex class
+ @param rwlock_class_sizing max number of rwlock class
+ @param cond_class_sizing max number of condition class
+ @return 0 on success
+*/
+int init_sync_class(uint mutex_class_sizing,
+ uint rwlock_class_sizing,
+ uint cond_class_sizing)
+{
+ mutex_class_dirty_count= mutex_class_allocated_count= 0;
+ rwlock_class_dirty_count= rwlock_class_allocated_count= 0;
+ cond_class_dirty_count= cond_class_allocated_count= 0;
+ mutex_class_max= mutex_class_sizing;
+ rwlock_class_max= rwlock_class_sizing;
+ cond_class_max= cond_class_sizing;
+ mutex_class_lost= rwlock_class_lost= cond_class_lost= 0;
+
+ mutex_class_array= NULL;
+ rwlock_class_array= NULL;
+ cond_class_array= NULL;
+
+ if (mutex_class_max > 0)
+ {
+ mutex_class_array= PFS_MALLOC_ARRAY(& builtin_memory_mutex_class,
+ mutex_class_max,
+ sizeof(PFS_mutex_class), PFS_mutex_class,
+ MYF(MY_ZEROFILL));
+ if (unlikely(mutex_class_array == NULL))
+ return 1;
+ }
+
+ if (rwlock_class_max > 0)
+ {
+ rwlock_class_array= PFS_MALLOC_ARRAY(& builtin_memory_rwlock_class,
+ rwlock_class_max,
+ sizeof(PFS_rwlock_class), PFS_rwlock_class,
+ MYF(MY_ZEROFILL));
+ if (unlikely(rwlock_class_array == NULL))
+ return 1;
+ }
+
+ if (cond_class_max > 0)
+ {
+ cond_class_array= PFS_MALLOC_ARRAY(& builtin_memory_cond_class,
+ cond_class_max,
+ sizeof(PFS_cond_class), PFS_cond_class,
+ MYF(MY_ZEROFILL));
+ if (unlikely(cond_class_array == NULL))
+ return 1;
+ }
+
+ return 0;
+}
+
+/** Cleanup the instrument synch class buffers. */
+void cleanup_sync_class(void)
+{
+ PFS_FREE_ARRAY(& builtin_memory_mutex_class,
+ mutex_class_max, sizeof(PFS_mutex_class),
+ mutex_class_array);
+ mutex_class_array= NULL;
+ mutex_class_dirty_count= mutex_class_allocated_count= mutex_class_max= 0;
+
+ PFS_FREE_ARRAY(& builtin_memory_rwlock_class,
+ rwlock_class_max, sizeof(PFS_rwlock_class),
+ rwlock_class_array);
+ rwlock_class_array= NULL;
+ rwlock_class_dirty_count= rwlock_class_allocated_count= rwlock_class_max= 0;
+
+ PFS_FREE_ARRAY(& builtin_memory_cond_class,
+ cond_class_max, sizeof(PFS_cond_class),
+ cond_class_array);
+ cond_class_array= NULL;
+ cond_class_dirty_count= cond_class_allocated_count= cond_class_max= 0;
+}
+
+/**
+ Initialize the thread class buffer.
+ @param thread_class_sizing max number of thread class
+ @return 0 on success
+*/
+int init_thread_class(uint thread_class_sizing)
+{
+ int result= 0;
+ thread_class_dirty_count= thread_class_allocated_count= 0;
+ thread_class_max= thread_class_sizing;
+ thread_class_lost= 0;
+
+ if (thread_class_max > 0)
+ {
+ thread_class_array= PFS_MALLOC_ARRAY(& builtin_memory_thread_class,
+ thread_class_max,
+ sizeof(PFS_thread_class), PFS_thread_class,
+ MYF(MY_ZEROFILL));
+ if (unlikely(thread_class_array == NULL))
+ result= 1;
+ }
+ else
+ thread_class_array= NULL;
+
+ return result;
+}
+
+/** Cleanup the thread class buffers. */
+void cleanup_thread_class(void)
+{
+ PFS_FREE_ARRAY(& builtin_memory_thread_class,
+ thread_class_max, sizeof(PFS_thread_class),
+ thread_class_array);
+ thread_class_array= NULL;
+ thread_class_dirty_count= thread_class_allocated_count= 0;
+ thread_class_max= 0;
+}
+
+/**
+ Initialize the table share buffer.
+ @param table_share_sizing max number of table share
+ @return 0 on success
+*/
+int init_table_share(uint table_share_sizing)
+{
+ if (global_table_share_container.init(table_share_sizing))
+ return 1;
+
+ return 0;
+}
+
+/** Cleanup the table share buffers. */
+void cleanup_table_share(void)
+{
+ global_table_share_container.cleanup();
+}
+
+C_MODE_START
+/** get_key function for @c table_share_hash. */
+static uchar *table_share_hash_get_key(const uchar *entry, size_t *length,
+ my_bool)
+{
+ const PFS_table_share * const *typed_entry;
+ const PFS_table_share *share;
+ const void *result;
+ typed_entry= reinterpret_cast<const PFS_table_share* const *> (entry);
+ DBUG_ASSERT(typed_entry != NULL);
+ share= *typed_entry;
+ DBUG_ASSERT(share != NULL);
+ *length= share->m_key.m_key_length;
+ result= &share->m_key.m_hash_key[0];
+ return const_cast<uchar*> (reinterpret_cast<const uchar*> (result));
+}
+C_MODE_END
+
+/** Initialize the table share hash table. */
+int init_table_share_hash(const PFS_global_param *param)
+{
+ if ((! table_share_hash_inited) && (param->m_table_share_sizing != 0))
+ {
+ lf_hash_init(&table_share_hash, sizeof(PFS_table_share*), LF_HASH_UNIQUE,
+ 0, 0, table_share_hash_get_key, &my_charset_bin);
+ table_share_hash_inited= true;
+ }
+ return 0;
+}
+
+/** Cleanup the table share hash table. */
+void cleanup_table_share_hash(void)
+{
+ if (table_share_hash_inited)
+ {
+ lf_hash_destroy(&table_share_hash);
+ table_share_hash_inited= false;
+ }
+}
+
+/**
+ Get the hash pins for @sa table_share_hash.
+ @param thread The running thread.
+ @returns The LF_HASH pins for the thread.
+*/
+LF_PINS* get_table_share_hash_pins(PFS_thread *thread)
+{
+ if (unlikely(thread->m_table_share_hash_pins == NULL))
+ {
+ if (! table_share_hash_inited)
+ return NULL;
+ thread->m_table_share_hash_pins= lf_hash_get_pins(&table_share_hash);
+ }
+ return thread->m_table_share_hash_pins;
+}
+
+/**
+ Set a table share hash key.
+ @param [out] key The key to populate.
+ @param temporary True for TEMPORARY TABLE.
+ @param schema_name The table schema name.
+ @param schema_name_length The table schema name length.
+ @param table_name The table name.
+ @param table_name_length The table name length.
+*/
+static void set_table_share_key(PFS_table_share_key *key,
+ bool temporary,
+ const char *schema_name, size_t schema_name_length,
+ const char *table_name, size_t table_name_length)
+{
+ DBUG_ASSERT(schema_name_length <= NAME_LEN);
+ DBUG_ASSERT(table_name_length <= NAME_LEN);
+ char *saved_schema_name;
+ char *saved_table_name;
+
+ char *ptr= &key->m_hash_key[0];
+ ptr[0]= (temporary ? OBJECT_TYPE_TEMPORARY_TABLE : OBJECT_TYPE_TABLE);
+ ptr++;
+ saved_schema_name= ptr;
+ memcpy(ptr, schema_name, schema_name_length);
+ ptr+= schema_name_length;
+ ptr[0]= 0;
+ ptr++;
+ saved_table_name= ptr;
+ memcpy(ptr, table_name, table_name_length);
+ ptr+= table_name_length;
+ ptr[0]= 0;
+ ptr++;
+ key->m_key_length= (uint)(ptr - &key->m_hash_key[0]);
+
+ if (lower_case_table_names)
+ {
+ my_casedn_str(files_charset_info, saved_schema_name);
+ my_casedn_str(files_charset_info, saved_table_name);
+ }
+}
+
+/**
+ Find an existing table share lock instrumentation.
+ @return a table share lock.
+*/
+PFS_table_share_lock*
+PFS_table_share::find_lock_stat() const
+{
+ PFS_table_share *that= const_cast<PFS_table_share*>(this);
+ void *addr= & that->m_race_lock_stat;
+ void * volatile * typed_addr= static_cast<void * volatile *>(addr);
+ void *ptr;
+
+ /* Atomic Load */
+ ptr= my_atomic_loadptr(typed_addr);
+
+ PFS_table_share_lock *pfs;
+ pfs= static_cast<PFS_table_share_lock *>(ptr);
+ return pfs;
+}
+
+/**
+ Find or create a table share lock instrumentation.
+ @return a table share lock, or NULL.
+*/
+PFS_table_share_lock*
+PFS_table_share::find_or_create_lock_stat()
+{
+ void *addr= & this->m_race_lock_stat;
+ void * volatile * typed_addr= static_cast<void * volatile *>(addr);
+ void *ptr;
+
+ /* (1) Atomic Load */
+ ptr= my_atomic_loadptr(typed_addr);
+
+ PFS_table_share_lock *pfs;
+ if (ptr != NULL)
+ {
+ pfs= static_cast<PFS_table_share_lock *>(ptr);
+ return pfs;
+ }
+
+ /* (2) Create a lock stat */
+ pfs= create_table_share_lock_stat();
+ if (pfs == NULL)
+ return NULL;
+ pfs->m_owner= this;
+
+ void *old_ptr= NULL;
+ ptr= pfs;
+
+ /* (3) Atomic CAS */
+ if (my_atomic_casptr(typed_addr, & old_ptr, ptr))
+ {
+ /* Ok. */
+ return pfs;
+ }
+
+ /* Collision with another thread that also executed (2) and (3). */
+ release_table_share_lock_stat(pfs);
+
+ pfs= static_cast<PFS_table_share_lock *>(old_ptr);
+ return pfs;
+}
+
+/** Destroy a table share lock instrumentation. */
+void PFS_table_share::destroy_lock_stat()
+{
+ void *addr= & this->m_race_lock_stat;
+ void * volatile * typed_addr= static_cast<void * volatile *>(addr);
+ void *new_ptr= NULL;
+ void *old_ptr;
+
+ old_ptr= my_atomic_fasptr(typed_addr, new_ptr);
+ if (old_ptr != NULL)
+ {
+ PFS_table_share_lock *pfs;
+ pfs= static_cast<PFS_table_share_lock *>(old_ptr);
+ release_table_share_lock_stat(pfs);
+ }
+}
+
+/**
+ Find an existing table share index instrumentation.
+ @return a table share index
+*/
+PFS_table_share_index*
+PFS_table_share::find_index_stat(uint index) const
+{
+ DBUG_ASSERT(index <= MAX_INDEXES);
+
+ PFS_table_share *that= const_cast<PFS_table_share*>(this);
+ void *addr= & that->m_race_index_stat[index];
+ void * volatile * typed_addr= static_cast<void * volatile *>(addr);
+ void *ptr;
+
+ /* Atomic Load */
+ ptr= my_atomic_loadptr(typed_addr);
+
+ PFS_table_share_index *pfs;
+ pfs= static_cast<PFS_table_share_index *>(ptr);
+ return pfs;
+}
+
+/**
+ Find or create a table share index instrumentation.
+ @param server_share
+ @index index
+ @return a table share index, or NULL
+*/
+PFS_table_share_index*
+PFS_table_share::find_or_create_index_stat(const TABLE_SHARE *server_share, uint index)
+{
+ DBUG_ASSERT(index <= MAX_INDEXES);
+
+ void *addr= & this->m_race_index_stat[index];
+ void * volatile * typed_addr= static_cast<void * volatile *>(addr);
+ void *ptr;
+
+ /* (1) Atomic Load */
+ ptr= my_atomic_loadptr(typed_addr);
+
+ PFS_table_share_index *pfs;
+ if (ptr != NULL)
+ {
+ pfs= static_cast<PFS_table_share_index *>(ptr);
+ return pfs;
+ }
+
+ /* (2) Create an index stat */
+ pfs= create_table_share_index_stat(server_share, index);
+ if (pfs == NULL)
+ return NULL;
+ pfs->m_owner= this;
+
+ void *old_ptr= NULL;
+ ptr= pfs;
+
+ /* (3) Atomic CAS */
+ if (my_atomic_casptr(typed_addr, & old_ptr, ptr))
+ {
+ /* Ok. */
+ return pfs;
+ }
+
+ /* Collision with another thread that also executed (2) and (3). */
+ release_table_share_index_stat(pfs);
+
+ pfs= static_cast<PFS_table_share_index *>(old_ptr);
+ return pfs;
+}
+
+/** Destroy table share index instrumentation. */
+void PFS_table_share::destroy_index_stats()
+{
+ uint index;
+
+ for (index= 0; index <= MAX_INDEXES; index++)
+ {
+ void *addr= & this->m_race_index_stat[index];
+ void * volatile * typed_addr= static_cast<void * volatile *>(addr);
+ void *new_ptr= NULL;
+ void *old_ptr;
+
+ old_ptr= my_atomic_fasptr(typed_addr, new_ptr);
+ if (old_ptr != NULL)
+ {
+ PFS_table_share_index *pfs;
+ pfs= static_cast<PFS_table_share_index *>(old_ptr);
+ release_table_share_index_stat(pfs);
+ }
+ }
+}
+
+void PFS_table_share::refresh_setup_object_flags(PFS_thread *thread)
+{
+ bool old_enabled= m_enabled;
+
+ lookup_setup_object(thread,
+ OBJECT_TYPE_TABLE,
+ m_schema_name, m_schema_name_length,
+ m_table_name, m_table_name_length,
+ &m_enabled, &m_timed);
+
+ /*
+ If instrumentation for this table was enabled earlier and is disabled now,
+ cleanup slots reserved for lock stats and index stats.
+ */
+ if (old_enabled && ! m_enabled)
+ {
+ destroy_lock_stat();
+ destroy_index_stats();
+ }
+}
+
+/**
+ Initialize the table lock stat buffer.
+ @param table_stat_sizing max number of table lock statistics
+ @return 0 on success
+*/
+int init_table_share_lock_stat(uint table_stat_sizing)
+{
+ if (global_table_share_lock_container.init(table_stat_sizing))
+ return 1;
+
+ return 0;
+}
+
+/**
+ Create a table share lock instrumentation.
+ @return table share lock instrumentation, or NULL
+*/
+PFS_table_share_lock*
+create_table_share_lock_stat()
+{
+ PFS_table_share_lock *pfs= NULL;
+ pfs_dirty_state dirty_state;
+
+ /* Create a new record in table stat array. */
+ pfs= global_table_share_lock_container.allocate(& dirty_state);
+ if (pfs != NULL)
+ {
+ /* Reset the stats. */
+ pfs->m_stat.reset();
+
+ /* Use this stat buffer. */
+ pfs->m_lock.dirty_to_allocated(& dirty_state);
+ }
+
+ return pfs;
+}
+
+/** Release a table share lock instrumentation. */
+void release_table_share_lock_stat(PFS_table_share_lock *pfs)
+{
+ pfs->m_owner= NULL;
+ global_table_share_lock_container.deallocate(pfs);
+ return;
+}
+
+/** Cleanup the table stat buffers. */
+void cleanup_table_share_lock_stat(void)
+{
+ global_table_share_lock_container.cleanup();
+}
+
+/**
+ Initialize table index stat buffer.
+ @param index_stat_sizing max number of index statistics
+ @return 0 on success
+*/
+int init_table_share_index_stat(uint index_stat_sizing)
+{
+ if (global_table_share_index_container.init(index_stat_sizing))
+ return 1;
+
+ return 0;
+}
+
+/**
+ Create a table share index instrumentation.
+ @return table share index instrumentation, or NULL
+*/
+PFS_table_share_index*
+create_table_share_index_stat(const TABLE_SHARE *server_share, uint server_index)
+{
+ DBUG_ASSERT((server_share != NULL) || (server_index == MAX_INDEXES));
+
+ PFS_table_share_index *pfs= NULL;
+ pfs_dirty_state dirty_state;
+
+ /* Create a new record in index stat array. */
+ pfs= global_table_share_index_container.allocate(& dirty_state);
+ if (pfs != NULL)
+ {
+ if (server_index == MAX_INDEXES)
+ {
+ pfs->m_key.m_name_length= 0;
+ }
+ else
+ {
+ KEY *key_info= server_share->key_info + server_index;
+ size_t len= key_info->name.length;
+
+ memcpy(pfs->m_key.m_name, key_info->name.str, len);
+ pfs->m_key.m_name_length= static_cast<uint>(len);
+ }
+
+ /* Reset the stats. */
+ pfs->m_stat.reset();
+
+ /* Use this stat buffer. */
+ pfs->m_lock.dirty_to_allocated(& dirty_state);
+ }
+
+ return pfs;
+}
+
+/** Release a table share index instrumentation. */
+void release_table_share_index_stat(PFS_table_share_index *pfs)
+{
+ pfs->m_owner= NULL;
+ global_table_share_index_container.deallocate(pfs);
+ return;
+}
+
+/** Cleanup the table stat buffers. */
+void cleanup_table_share_index_stat(void)
+{
+ global_table_share_index_container.cleanup();
+}
+
+/**
+ Initialize the file class buffer.
+ @param file_class_sizing max number of file class
+ @return 0 on success
+*/
+int init_file_class(uint file_class_sizing)
+{
+ int result= 0;
+ file_class_dirty_count= file_class_allocated_count= 0;
+ file_class_max= file_class_sizing;
+ file_class_lost= 0;
+
+ if (file_class_max > 0)
+ {
+ file_class_array= PFS_MALLOC_ARRAY(& builtin_memory_file_class,
+ file_class_max,
+ sizeof(PFS_file_class), PFS_file_class,
+ MYF(MY_ZEROFILL));
+ if (unlikely(file_class_array == NULL))
+ return 1;
+ }
+ else
+ file_class_array= NULL;
+
+ return result;
+}
+
+/** Cleanup the file class buffers. */
+void cleanup_file_class(void)
+{
+ PFS_FREE_ARRAY(& builtin_memory_file_class,
+ file_class_max, sizeof(PFS_file_class),
+ file_class_array);
+ file_class_array= NULL;
+ file_class_dirty_count= file_class_allocated_count= 0;
+ file_class_max= 0;
+}
+
+/**
+ Initialize the stage class buffer.
+ @param stage_class_sizing max number of stage class
+ @return 0 on success
+*/
+int init_stage_class(uint stage_class_sizing)
+{
+ int result= 0;
+ stage_class_dirty_count= stage_class_allocated_count= 0;
+ stage_class_max= stage_class_sizing;
+ stage_class_lost= 0;
+
+ if (stage_class_max > 0)
+ {
+ stage_class_array= PFS_MALLOC_ARRAY(& builtin_memory_stage_class,
+ stage_class_max,
+ sizeof(PFS_stage_class), PFS_stage_class,
+ MYF(MY_ZEROFILL));
+ if (unlikely(stage_class_array == NULL))
+ return 1;
+ }
+ else
+ stage_class_array= NULL;
+
+ return result;
+}
+
+/** Cleanup the stage class buffers. */
+void cleanup_stage_class(void)
+{
+ PFS_FREE_ARRAY(& builtin_memory_stage_class,
+ stage_class_max, sizeof(PFS_stage_class),
+ stage_class_array);
+ stage_class_array= NULL;
+ stage_class_dirty_count= stage_class_allocated_count= 0;
+ stage_class_max= 0;
+}
+
+/**
+ Initialize the statement class buffer.
+ @param statement_class_sizing max number of statement class
+ @return 0 on success
+*/
+int init_statement_class(uint statement_class_sizing)
+{
+ int result= 0;
+ statement_class_dirty_count= statement_class_allocated_count= 0;
+ statement_class_max= statement_class_sizing;
+ statement_class_lost= 0;
+
+ if (statement_class_max > 0)
+ {
+ statement_class_array= PFS_MALLOC_ARRAY(& builtin_memory_statement_class,
+ statement_class_max,
+ sizeof(PFS_statement_class), PFS_statement_class,
+ MYF(MY_ZEROFILL));
+ if (unlikely(statement_class_array == NULL))
+ return 1;
+ }
+ else
+ statement_class_array= NULL;
+
+ return result;
+}
+
+/** Cleanup the statement class buffers. */
+void cleanup_statement_class(void)
+{
+ PFS_FREE_ARRAY(& builtin_memory_statement_class,
+ statement_class_max, sizeof(PFS_statement_class),
+ statement_class_array);
+ statement_class_array= NULL;
+ statement_class_dirty_count= statement_class_allocated_count= 0;
+ statement_class_max= 0;
+}
+
+/**
+ Initialize the socket class buffer.
+ @param socket_class_sizing max number of socket class
+ @return 0 on success
+*/
+int init_socket_class(uint socket_class_sizing)
+{
+ int result= 0;
+ socket_class_dirty_count= socket_class_allocated_count= 0;
+ socket_class_max= socket_class_sizing;
+ socket_class_lost= 0;
+
+ if (socket_class_max > 0)
+ {
+ socket_class_array= PFS_MALLOC_ARRAY(& builtin_memory_socket_class,
+ socket_class_max,
+ sizeof(PFS_socket_class), PFS_socket_class,
+ MYF(MY_ZEROFILL));
+ if (unlikely(socket_class_array == NULL))
+ return 1;
+ }
+ else
+ socket_class_array= NULL;
+
+ return result;
+}
+
+/** Cleanup the socket class buffers. */
+void cleanup_socket_class(void)
+{
+ PFS_FREE_ARRAY(& builtin_memory_socket_class,
+ socket_class_max, sizeof(PFS_socket_class),
+ socket_class_array);
+ socket_class_array= NULL;
+ socket_class_dirty_count= socket_class_allocated_count= 0;
+ socket_class_max= 0;
+}
+
+/**
+ Initialize the memory class buffer.
+ @param memory_class_sizing max number of memory class
+ @return 0 on success
+*/
+int init_memory_class(uint memory_class_sizing)
+{
+ int result= 0;
+ memory_class_dirty_count= memory_class_allocated_count= 0;
+ memory_class_max= memory_class_sizing;
+ memory_class_lost= 0;
+
+ if (memory_class_max > 0)
+ {
+ memory_class_array= PFS_MALLOC_ARRAY(& builtin_memory_memory_class,
+ memory_class_max,
+ sizeof(PFS_memory_class), PFS_memory_class,
+ MYF(MY_ZEROFILL));
+ if (unlikely(memory_class_array == NULL))
+ return 1;
+ }
+ else
+ memory_class_array= NULL;
+
+ return result;
+}
+
+/** Cleanup the memory class buffers. */
+void cleanup_memory_class(void)
+{
+ PFS_FREE_ARRAY(& builtin_memory_memory_class,
+ memory_class_max, sizeof(PFS_memory_class),
+ memory_class_array);
+ memory_class_array= NULL;
+ memory_class_dirty_count= memory_class_allocated_count= 0;
+ memory_class_max= 0;
+}
+
+static void init_instr_class(PFS_instr_class *klass,
+ const char *name,
+ uint name_length,
+ int flags,
+ PFS_class_type class_type)
+{
+ DBUG_ASSERT(name_length <= PFS_MAX_INFO_NAME_LENGTH);
+ memset(klass, 0, sizeof(PFS_instr_class));
+ strncpy(klass->m_name, name, name_length);
+ klass->m_name[PFS_MAX_INFO_NAME_LENGTH - 1]= '\0';
+ klass->m_name_length= name_length;
+ klass->m_flags= flags;
+ klass->m_enabled= true;
+ klass->m_timed= true;
+ klass->m_type= class_type;
+ klass->m_timer= class_timers[class_type];
+}
+
+/**
+ Set user-defined configuration values for an instrument.
+*/
+static void configure_instr_class(PFS_instr_class *entry)
+{
+ uint match_length= 0; /* length of matching pattern */
+
+ // May be NULL in unit tests
+ if (pfs_instr_config_array == NULL)
+ return;
+ PFS_instr_config **it= pfs_instr_config_array->front();
+ for ( ; it != pfs_instr_config_array->end(); it++)
+ {
+ PFS_instr_config* e= *it;
+
+ /**
+ Compare class name to all configuration entries. In case of multiple
+ matches, the longer specification wins. For example, the pattern
+ 'ABC/DEF/GHI=ON' has precedence over 'ABC/DEF/%=OFF' regardless of
+ position within the configuration file or command line.
+
+ Consecutive wildcards affect the count.
+ */
+ if (!my_charset_latin1.wildcmp(
+ entry->m_name, entry->m_name+entry->m_name_length,
+ e->m_name, e->m_name+e->m_name_length,
+ '\\', '?','%'))
+ {
+ if (e->m_name_length >= match_length)
+ {
+ entry->m_enabled= e->m_enabled;
+ entry->m_timed= e->m_timed;
+ match_length= MY_MAX(e->m_name_length, match_length);
+ }
+ }
+ }
+}
+
+#define REGISTER_CLASS_BODY_PART(INDEX, ARRAY, MAX, NAME, NAME_LENGTH) \
+ for (INDEX= 0; INDEX < MAX; INDEX++) \
+ { \
+ entry= &ARRAY[INDEX]; \
+ if ((entry->m_name_length == NAME_LENGTH) && \
+ (strncmp(entry->m_name, NAME, NAME_LENGTH) == 0)) \
+ { \
+ DBUG_ASSERT(entry->m_flags == flags); \
+ return (INDEX + 1); \
+ } \
+ }
+
+/**
+ Register a mutex instrumentation metadata.
+ @param name the instrumented name
+ @param name_length length in bytes of name
+ @param flags the instrumentation flags
+ @return a mutex instrumentation key
+*/
+PFS_sync_key register_mutex_class(const char *name, uint name_length,
+ int flags)
+{
+ uint32 index;
+ PFS_mutex_class *entry;
+
+ /*
+ This is a full array scan, which is not optimal.
+ This is acceptable since this code is only used at startup,
+ or when a plugin is loaded.
+ */
+ REGISTER_CLASS_BODY_PART(index, mutex_class_array, mutex_class_max,
+ name, name_length)
+ /*
+ Note that:
+ mutex_class_dirty_count is incremented *before* an entry is added
+ mutex_class_allocated_count is incremented *after* an entry is added
+ */
+ index= PFS_atomic::add_u32(&mutex_class_dirty_count, 1);
+
+ if (index < mutex_class_max)
+ {
+ /*
+ The instrument was not found (from a possible previous
+ load / unload of a plugin), allocate it.
+ This code is safe when 2 threads execute in parallel
+ for different mutex classes:
+ - thread 1 registering class A
+ - thread 2 registering class B
+ will not collide in the same mutex_class_array[index] entry.
+ This code does not protect against 2 threads registering
+ in parallel the same class:
+ - thread 1 registering class A
+ - thread 2 registering class A
+ could lead to a duplicate class A entry.
+ This is ok, since this case can not happen in the caller:
+ - classes names are derived from a plugin name
+ ('wait/synch/mutex/<plugin>/xxx')
+ - 2 threads can not register concurrently the same plugin
+ in INSTALL PLUGIN.
+ */
+ entry= &mutex_class_array[index];
+ init_instr_class(entry, name, name_length, flags, PFS_CLASS_MUTEX);
+ entry->m_mutex_stat.reset();
+ entry->m_event_name_index= mutex_class_start + index;
+ entry->m_singleton= NULL;
+ entry->m_enabled= false; /* disabled by default */
+ entry->m_timed= false;
+
+ /* Set user-defined configuration options for this instrument */
+ configure_instr_class(entry);
+
+ /*
+ Now that this entry is populated, advertise it
+
+ Technically, there is a small race condition here:
+ T0:
+ mutex_class_dirty_count= 10
+ mutex_class_allocated_count= 10
+ T1: Thread A increment mutex_class_dirty_count to 11
+ T2: Thread B increment mutex_class_dirty_count to 12
+ T3: Thread A populate entry 11
+ T4: Thread B populate entry 12
+ T5: Thread B increment mutex_class_allocated_count to 11,
+ advertise thread A incomplete record 11,
+ but does not advertise thread B complete record 12
+ T6: Thread A increment mutex_class_allocated_count to 12
+ This has no impact, and is acceptable.
+ A reader will not see record 12 for a short time.
+ A reader will see an incomplete record 11 for a short time,
+ which is ok: the mutex name / statistics will be temporarily
+ empty/NULL/zero, but this won't cause a crash
+ (mutex_class_array is initialized with MY_ZEROFILL).
+ */
+ PFS_atomic::add_u32(&mutex_class_allocated_count, 1);
+ return (index + 1);
+ }
+
+ /*
+ Out of space, report to SHOW STATUS that
+ the allocated memory was too small.
+ */
+ if (pfs_enabled)
+ mutex_class_lost++;
+ return 0;
+}
+
+/**
+ Register a rwlock instrumentation metadata.
+ @param name the instrumented name
+ @param name_length length in bytes of name
+ @param flags the instrumentation flags
+ @return a rwlock instrumentation key
+*/
+PFS_sync_key register_rwlock_class(const char *name, uint name_length,
+ int flags)
+{
+ /* See comments in register_mutex_class */
+ uint32 index;
+ PFS_rwlock_class *entry;
+
+ REGISTER_CLASS_BODY_PART(index, rwlock_class_array, rwlock_class_max,
+ name, name_length)
+
+ index= PFS_atomic::add_u32(&rwlock_class_dirty_count, 1);
+
+ if (index < rwlock_class_max)
+ {
+ entry= &rwlock_class_array[index];
+ init_instr_class(entry, name, name_length, flags, PFS_CLASS_RWLOCK);
+ entry->m_rwlock_stat.reset();
+ entry->m_event_name_index= rwlock_class_start + index;
+ entry->m_singleton= NULL;
+ entry->m_enabled= false; /* disabled by default */
+ entry->m_timed= false;
+ /* Set user-defined configuration options for this instrument */
+ configure_instr_class(entry);
+ PFS_atomic::add_u32(&rwlock_class_allocated_count, 1);
+ return (index + 1);
+ }
+
+ if (pfs_enabled)
+ rwlock_class_lost++;
+ return 0;
+}
+
+/**
+ Register a condition instrumentation metadata.
+ @param name the instrumented name
+ @param name_length length in bytes of name
+ @param flags the instrumentation flags
+ @return a condition instrumentation key
+*/
+PFS_sync_key register_cond_class(const char *name, uint name_length,
+ int flags)
+{
+ /* See comments in register_mutex_class */
+ uint32 index;
+ PFS_cond_class *entry;
+
+ REGISTER_CLASS_BODY_PART(index, cond_class_array, cond_class_max,
+ name, name_length)
+
+ index= PFS_atomic::add_u32(&cond_class_dirty_count, 1);
+
+ if (index < cond_class_max)
+ {
+ entry= &cond_class_array[index];
+ init_instr_class(entry, name, name_length, flags, PFS_CLASS_COND);
+ entry->m_event_name_index= cond_class_start + index;
+ entry->m_singleton= NULL;
+ entry->m_enabled= false; /* disabled by default */
+ entry->m_timed= false;
+ /* Set user-defined configuration options for this instrument */
+ configure_instr_class(entry);
+ PFS_atomic::add_u32(&cond_class_allocated_count, 1);
+ return (index + 1);
+ }
+
+ if (pfs_enabled)
+ cond_class_lost++;
+ return 0;
+}
+
+#define FIND_CLASS_BODY(KEY, COUNT, ARRAY) \
+ if ((KEY == 0) || (KEY > COUNT)) \
+ return NULL; \
+ return &ARRAY[KEY - 1]
+
+/**
+ Find a mutex instrumentation class by key.
+ @param key the instrument key
+ @return the instrument class, or NULL
+*/
+PFS_mutex_class *find_mutex_class(PFS_sync_key key)
+{
+ FIND_CLASS_BODY(key, mutex_class_allocated_count, mutex_class_array);
+}
+
+PFS_mutex_class *sanitize_mutex_class(PFS_mutex_class *unsafe)
+{
+ SANITIZE_ARRAY_BODY(PFS_mutex_class, mutex_class_array, mutex_class_max, unsafe);
+}
+
+/**
+ Find a rwlock instrumentation class by key.
+ @param key the instrument key
+ @return the instrument class, or NULL
+*/
+PFS_rwlock_class *find_rwlock_class(PFS_sync_key key)
+{
+ FIND_CLASS_BODY(key, rwlock_class_allocated_count, rwlock_class_array);
+}
+
+PFS_rwlock_class *sanitize_rwlock_class(PFS_rwlock_class *unsafe)
+{
+ SANITIZE_ARRAY_BODY(PFS_rwlock_class, rwlock_class_array, rwlock_class_max, unsafe);
+}
+
+/**
+ Find a condition instrumentation class by key.
+ @param key the instrument key
+ @return the instrument class, or NULL
+*/
+PFS_cond_class *find_cond_class(PFS_sync_key key)
+{
+ FIND_CLASS_BODY(key, cond_class_allocated_count, cond_class_array);
+}
+
+PFS_cond_class *sanitize_cond_class(PFS_cond_class *unsafe)
+{
+ SANITIZE_ARRAY_BODY(PFS_cond_class, cond_class_array, cond_class_max, unsafe);
+}
+
+/**
+ Register a thread instrumentation metadata.
+ @param name the instrumented name
+ @param name_length length in bytes of name
+ @param flags the instrumentation flags
+ @return a thread instrumentation key
+*/
+PFS_thread_key register_thread_class(const char *name, uint name_length,
+ int flags)
+{
+ /* See comments in register_mutex_class */
+ uint32 index;
+ PFS_thread_class *entry;
+
+ for (index= 0; index < thread_class_max; index++)
+ {
+ entry= &thread_class_array[index];
+
+ if ((entry->m_name_length == name_length) &&
+ (strncmp(entry->m_name, name, name_length) == 0))
+ return (index + 1);
+ }
+
+ index= PFS_atomic::add_u32(&thread_class_dirty_count, 1);
+
+ if (index < thread_class_max)
+ {
+ entry= &thread_class_array[index];
+ DBUG_ASSERT(name_length <= PFS_MAX_INFO_NAME_LENGTH);
+ strncpy(entry->m_name, name, name_length);
+ entry->m_name_length= name_length;
+ entry->m_enabled= true;
+ PFS_atomic::add_u32(&thread_class_allocated_count, 1);
+ return (index + 1);
+ }
+
+ if (pfs_enabled)
+ thread_class_lost++;
+ return 0;
+}
+
+/**
+ Find a thread instrumentation class by key.
+ @param key the instrument key
+ @return the instrument class, or NULL
+*/
+PFS_thread_class *find_thread_class(PFS_sync_key key)
+{
+ FIND_CLASS_BODY(key, thread_class_allocated_count, thread_class_array);
+}
+
+PFS_thread_class *sanitize_thread_class(PFS_thread_class *unsafe)
+{
+ SANITIZE_ARRAY_BODY(PFS_thread_class, thread_class_array, thread_class_max, unsafe);
+}
+
+/**
+ Register a file instrumentation metadata.
+ @param name the instrumented name
+ @param name_length length in bytes of name
+ @param flags the instrumentation flags
+ @return a file instrumentation key
+*/
+PFS_file_key register_file_class(const char *name, uint name_length,
+ int flags)
+{
+ /* See comments in register_mutex_class */
+ uint32 index;
+ PFS_file_class *entry;
+
+ REGISTER_CLASS_BODY_PART(index, file_class_array, file_class_max,
+ name, name_length)
+
+ index= PFS_atomic::add_u32(&file_class_dirty_count, 1);
+
+ if (index < file_class_max)
+ {
+ entry= &file_class_array[index];
+ init_instr_class(entry, name, name_length, flags, PFS_CLASS_FILE);
+ entry->m_event_name_index= file_class_start + index;
+ entry->m_singleton= NULL;
+ entry->m_enabled= true; /* enabled by default */
+ entry->m_timed= true;
+ /* Set user-defined configuration options for this instrument */
+ configure_instr_class(entry);
+ PFS_atomic::add_u32(&file_class_allocated_count, 1);
+
+ return (index + 1);
+ }
+
+ if (pfs_enabled)
+ file_class_lost++;
+ return 0;
+}
+
+/**
+ Register a stage instrumentation metadata.
+ @param name the instrumented name
+ @param prefix_length length in bytes of the name prefix
+ @param name_length length in bytes of name
+ @param flags the instrumentation flags
+ @return a stage instrumentation key
+*/
+PFS_stage_key register_stage_class(const char *name,
+ uint prefix_length,
+ uint name_length,
+ int flags)
+{
+ /* See comments in register_mutex_class */
+ uint32 index;
+ PFS_stage_class *entry;
+
+ REGISTER_CLASS_BODY_PART(index, stage_class_array, stage_class_max,
+ name, name_length)
+
+ index= PFS_atomic::add_u32(&stage_class_dirty_count, 1);
+
+ if (index < stage_class_max)
+ {
+ entry= &stage_class_array[index];
+ init_instr_class(entry, name, name_length, flags, PFS_CLASS_STAGE);
+ entry->m_prefix_length= prefix_length;
+ entry->m_event_name_index= index;
+
+ if (flags & PSI_FLAG_STAGE_PROGRESS)
+ {
+ /* Stages with progress information are enabled and timed by default */
+ entry->m_enabled= true;
+ entry->m_timed= true;
+ }
+ else
+ {
+ /* Stages without progress information are disabled by default */
+ entry->m_enabled= false;
+ entry->m_timed= false;
+ }
+
+ /* Set user-defined configuration options for this instrument */
+ configure_instr_class(entry);
+ PFS_atomic::add_u32(&stage_class_allocated_count, 1);
+
+ return (index + 1);
+ }
+
+ if (pfs_enabled)
+ stage_class_lost++;
+ return 0;
+}
+
+/**
+ Register a statement instrumentation metadata.
+ @param name the instrumented name
+ @param name_length length in bytes of name
+ @param flags the instrumentation flags
+ @return a statement instrumentation key
+*/
+PFS_statement_key register_statement_class(const char *name, uint name_length,
+ int flags)
+{
+ /* See comments in register_mutex_class */
+ uint32 index;
+ PFS_statement_class *entry;
+
+ REGISTER_CLASS_BODY_PART(index, statement_class_array, statement_class_max,
+ name, name_length)
+
+ index= PFS_atomic::add_u32(&statement_class_dirty_count, 1);
+
+ if (index < statement_class_max)
+ {
+ entry= &statement_class_array[index];
+ init_instr_class(entry, name, name_length, flags, PFS_CLASS_STATEMENT);
+ entry->m_event_name_index= index;
+ entry->m_enabled= true; /* enabled by default */
+ entry->m_timed= true;
+ /* Set user-defined configuration options for this instrument */
+ configure_instr_class(entry);
+ PFS_atomic::add_u32(&statement_class_allocated_count, 1);
+
+ return (index + 1);
+ }
+
+ if (pfs_enabled)
+ statement_class_lost++;
+ return 0;
+}
+
+/**
+ Find a file instrumentation class by key.
+ @param key the instrument key
+ @return the instrument class, or NULL
+*/
+PFS_file_class *find_file_class(PFS_file_key key)
+{
+ FIND_CLASS_BODY(key, file_class_allocated_count, file_class_array);
+}
+
+PFS_file_class *sanitize_file_class(PFS_file_class *unsafe)
+{
+ SANITIZE_ARRAY_BODY(PFS_file_class, file_class_array, file_class_max, unsafe);
+}
+
+/**
+ Find a stage instrumentation class by key.
+ @param key the instrument key
+ @return the instrument class, or NULL
+*/
+PFS_stage_class *find_stage_class(PFS_stage_key key)
+{
+ FIND_CLASS_BODY(key, stage_class_allocated_count, stage_class_array);
+}
+
+PFS_stage_class *sanitize_stage_class(PFS_stage_class *unsafe)
+{
+ SANITIZE_ARRAY_BODY(PFS_stage_class, stage_class_array, stage_class_max, unsafe);
+}
+
+/**
+ Find a statement instrumentation class by key.
+ @param key the instrument key
+ @return the instrument class, or NULL
+*/
+PFS_statement_class *find_statement_class(PFS_stage_key key)
+{
+ FIND_CLASS_BODY(key, statement_class_allocated_count, statement_class_array);
+}
+
+PFS_statement_class *sanitize_statement_class(PFS_statement_class *unsafe)
+{
+ SANITIZE_ARRAY_BODY(PFS_statement_class, statement_class_array, statement_class_max, unsafe);
+}
+
+/**
+ Register a socket instrumentation metadata.
+ @param name the instrumented name
+ @param name_length length in bytes of name
+ @param flags the instrumentation flags
+ @return a socket instrumentation key
+*/
+PFS_socket_key register_socket_class(const char *name, uint name_length,
+ int flags)
+{
+ /* See comments in register_mutex_class */
+ uint32 index;
+ PFS_socket_class *entry;
+
+ REGISTER_CLASS_BODY_PART(index, socket_class_array, socket_class_max,
+ name, name_length)
+
+ index= PFS_atomic::add_u32(&socket_class_dirty_count, 1);
+
+ if (index < socket_class_max)
+ {
+ entry= &socket_class_array[index];
+ init_instr_class(entry, name, name_length, flags, PFS_CLASS_SOCKET);
+ entry->m_event_name_index= socket_class_start + index;
+ entry->m_singleton= NULL;
+ entry->m_enabled= false; /* disabled by default */
+ entry->m_timed= false;
+ /* Set user-defined configuration options for this instrument */
+ configure_instr_class(entry);
+ PFS_atomic::add_u32(&socket_class_allocated_count, 1);
+ return (index + 1);
+ }
+
+ if (pfs_enabled)
+ socket_class_lost++;
+ return 0;
+}
+
+/**
+ Find a socket instrumentation class by key.
+ @param key the instrument key
+ @return the instrument class, or NULL
+*/
+PFS_socket_class *find_socket_class(PFS_socket_key key)
+{
+ FIND_CLASS_BODY(key, socket_class_allocated_count, socket_class_array);
+}
+
+PFS_socket_class *sanitize_socket_class(PFS_socket_class *unsafe)
+{
+ SANITIZE_ARRAY_BODY(PFS_socket_class, socket_class_array, socket_class_max, unsafe);
+}
+
+/**
+ Register a memory instrumentation metadata.
+ @param name the instrumented name
+ @param name_length length in bytes of name
+ @param flags the instrumentation flags
+ @return a memory instrumentation key
+*/
+PFS_memory_key register_memory_class(const char *name, uint name_length,
+ int flags)
+{
+ /* See comments in register_mutex_class */
+ uint32 index;
+ PFS_memory_class *entry;
+
+ REGISTER_CLASS_BODY_PART(index, memory_class_array, memory_class_max,
+ name, name_length)
+
+ index= PFS_atomic::add_u32(&memory_class_dirty_count, 1);
+
+ if (index < memory_class_max)
+ {
+ entry= &memory_class_array[index];
+ init_instr_class(entry, name, name_length, flags, PFS_CLASS_MEMORY);
+ entry->m_event_name_index= index;
+ entry->m_enabled= false; /* disabled by default */
+ /* Set user-defined configuration options for this instrument */
+ configure_instr_class(entry);
+ entry->m_timed= false; /* Immutable */
+ PFS_atomic::add_u32(&memory_class_allocated_count, 1);
+ return (index + 1);
+ }
+
+ if (pfs_enabled)
+ memory_class_lost++;
+ return 0;
+}
+
+/**
+ Find a memory instrumentation class by key.
+ @param key the instrument key
+ @return the instrument class, or NULL
+*/
+PFS_memory_class *find_memory_class(PFS_memory_key key)
+{
+ FIND_CLASS_BODY(key, memory_class_allocated_count, memory_class_array);
+}
+
+PFS_memory_class *sanitize_memory_class(PFS_memory_class *unsafe)
+{
+ SANITIZE_ARRAY_BODY(PFS_memory_class, memory_class_array, memory_class_max, unsafe);
+}
+
+PFS_instr_class *find_table_class(uint index)
+{
+ if (index == 1)
+ return & global_table_io_class;
+ if (index == 2)
+ return & global_table_lock_class;
+ return NULL;
+}
+
+PFS_instr_class *sanitize_table_class(PFS_instr_class *unsafe)
+{
+ if (likely((& global_table_io_class == unsafe) ||
+ (& global_table_lock_class == unsafe)))
+ return unsafe;
+ return NULL;
+}
+
+PFS_instr_class *find_idle_class(uint index)
+{
+ if (index == 1)
+ return & global_idle_class;
+ return NULL;
+}
+
+PFS_instr_class *sanitize_idle_class(PFS_instr_class *unsafe)
+{
+ if (likely(& global_idle_class == unsafe))
+ return unsafe;
+ return NULL;
+}
+
+PFS_instr_class *find_metadata_class(uint index)
+{
+ if (index == 1)
+ return & global_metadata_class;
+ return NULL;
+}
+
+PFS_instr_class *sanitize_metadata_class(PFS_instr_class *unsafe)
+{
+ if (likely(& global_metadata_class == unsafe))
+ return unsafe;
+ return NULL;
+}
+
+PFS_transaction_class *find_transaction_class(uint index)
+{
+ if (index == 1)
+ return &global_transaction_class;
+ return NULL;
+}
+
+PFS_transaction_class *sanitize_transaction_class(PFS_transaction_class *unsafe)
+{
+ if (likely(&global_transaction_class == unsafe))
+ return unsafe;
+ return NULL;
+}
+
+static int compare_keys(PFS_table_share *pfs, const TABLE_SHARE *share)
+{
+ if (pfs->m_key_count != share->keys)
+ return 1;
+
+ size_t len;
+ uint index= 0;
+ uint key_count= share->keys;
+ KEY *key_info= share->key_info;
+ PFS_table_share_index *index_stat;
+
+ for ( ; index < key_count; key_info++, index++)
+ {
+ index_stat= pfs->find_index_stat(index);
+ if (index_stat != NULL)
+ {
+ len= key_info->name.length;
+
+ if (len != index_stat->m_key.m_name_length)
+ return 1;
+
+ if (memcmp(index_stat->m_key.m_name, key_info->name.str, len) != 0)
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
+
+/**
+ Find or create a table share instrumentation.
+ @param thread the executing instrumented thread
+ @param temporary true for TEMPORARY TABLE
+ @param share table share
+ @return a table share, or NULL
+*/
+PFS_table_share* find_or_create_table_share(PFS_thread *thread,
+ bool temporary,
+ const TABLE_SHARE *share)
+{
+ /* See comments in register_mutex_class */
+ PFS_table_share_key key;
+
+ LF_PINS *pins= get_table_share_hash_pins(thread);
+ if (unlikely(pins == NULL))
+ {
+ global_table_share_container.m_lost++;
+ return NULL;
+ }
+
+ const char *schema_name= share->db.str;
+ size_t schema_name_length= share->db.length;
+ const char *table_name= share->table_name.str;
+ size_t table_name_length= share->table_name.length;
+
+ set_table_share_key(&key, temporary,
+ schema_name, schema_name_length,
+ table_name, table_name_length);
+
+ PFS_table_share **entry;
+ uint retry_count= 0;
+ const uint retry_max= 3;
+ bool enabled= true;
+ bool timed= true;
+ PFS_table_share *pfs;
+ pfs_dirty_state dirty_state;
+
+search:
+ entry= reinterpret_cast<PFS_table_share**>
+ (lf_hash_search(&table_share_hash, pins,
+ key.m_hash_key, key.m_key_length));
+ if (entry && (entry != MY_ERRPTR))
+ {
+ pfs= *entry;
+ pfs->inc_refcount() ;
+ if (compare_keys(pfs, share) != 0)
+ {
+ /*
+ Some DDL was detected.
+ - keep the lock stats, they are unaffected
+ - destroy the index stats, indexes changed.
+ - adjust the expected key count
+ - recreate index stats
+ */
+ pfs->destroy_index_stats();
+ pfs->m_key_count= share->keys;
+ for (uint index= 0; index < pfs->m_key_count; index++)
+ {
+ (void)pfs->find_or_create_index_stat(share, index);
+ }
+ }
+ lf_hash_search_unpin(pins);
+ return pfs;
+ }
+
+ lf_hash_search_unpin(pins);
+
+ if (retry_count == 0)
+ {
+ lookup_setup_object(thread,
+ OBJECT_TYPE_TABLE,
+ schema_name, static_cast<uint>(schema_name_length),
+ table_name, static_cast<uint>(table_name_length),
+ &enabled, &timed);
+ /*
+ Even when enabled is false, a record is added in the dictionary:
+ - It makes enabling a table already in the table cache possible,
+ - It improves performances for the next time a TABLE_SHARE is reloaded
+ in the table cache.
+ */
+ }
+
+ pfs= global_table_share_container.allocate(& dirty_state);
+ if (pfs != NULL)
+ {
+ pfs->m_key= key;
+ pfs->m_schema_name= &pfs->m_key.m_hash_key[1];
+ pfs->m_schema_name_length= static_cast<uint>(schema_name_length);
+ pfs->m_table_name= &pfs->m_key.m_hash_key[schema_name_length + 2];
+ pfs->m_table_name_length= static_cast<uint>(table_name_length);
+ pfs->m_enabled= enabled;
+ pfs->m_timed= timed;
+ pfs->init_refcount();
+ pfs->destroy_lock_stat();
+ pfs->destroy_index_stats();
+ pfs->m_key_count= share->keys;
+
+ int res;
+ pfs->m_lock.dirty_to_allocated(& dirty_state);
+ res= lf_hash_insert(&table_share_hash, pins, &pfs);
+
+ if (likely(res == 0))
+ {
+ /* Create table share index stats. */
+ for (uint index= 0; index < pfs->m_key_count; index++)
+ {
+ (void)pfs->find_or_create_index_stat(share, index);
+ }
+ return pfs;
+ }
+
+ global_table_share_container.deallocate(pfs);
+
+ if (res > 0)
+ {
+ /* Duplicate insert by another thread */
+ if (++retry_count > retry_max)
+ {
+ /* Avoid infinite loops */
+ global_table_share_container.m_lost++;
+ return NULL;
+ }
+ goto search;
+ }
+
+ /* OOM in lf_hash_insert */
+ global_table_share_container.m_lost++;
+ return NULL;
+ }
+
+ return NULL;
+}
+
+void PFS_table_share::aggregate_io(void)
+{
+ uint index;
+ uint safe_key_count= sanitize_index_count(m_key_count);
+ PFS_table_share_index *from_stat;
+ PFS_table_io_stat sum_io;
+
+ /* Aggregate stats for each index, if any */
+ for (index= 0; index < safe_key_count; index++)
+ {
+ from_stat= find_index_stat(index);
+ if (from_stat != NULL)
+ {
+ sum_io.aggregate(& from_stat->m_stat);
+ from_stat->m_stat.reset();
+ }
+ }
+
+ /* Aggregate stats for the table */
+ from_stat= find_index_stat(MAX_INDEXES);
+ if (from_stat != NULL)
+ {
+ sum_io.aggregate(& from_stat->m_stat);
+ from_stat->m_stat.reset();
+ }
+
+ /* Add this table stats to the global sink. */
+ global_table_io_stat.aggregate(& sum_io);
+}
+
+void PFS_table_share::sum_io(PFS_single_stat *result, uint key_count)
+{
+ uint index;
+ PFS_table_share_index *stat;
+
+ DBUG_ASSERT(key_count <= MAX_INDEXES);
+
+ /* Sum stats for each index, if any */
+ for (index= 0; index < key_count; index++)
+ {
+ stat= find_index_stat(index);
+ if (stat != NULL)
+ {
+ stat->m_stat.sum(result);
+ }
+ }
+
+ /* Sum stats for the table */
+ stat= find_index_stat(MAX_INDEXES);
+ if (stat != NULL)
+ {
+ stat->m_stat.sum(result);
+ }
+}
+
+void PFS_table_share::sum_lock(PFS_single_stat *result)
+{
+ PFS_table_share_lock *lock_stat;
+ lock_stat= find_lock_stat();
+ if (lock_stat != NULL)
+ lock_stat->m_stat.sum(result);
+}
+
+void PFS_table_share::sum(PFS_single_stat *result, uint key_count)
+{
+ sum_io(result, key_count);
+ sum_lock(result);
+}
+
+void PFS_table_share::aggregate_lock(void)
+{
+ PFS_table_share_lock *lock_stat;
+ lock_stat= find_lock_stat();
+ if (lock_stat != NULL)
+ {
+ global_table_lock_stat.aggregate(& lock_stat->m_stat);
+ /* Reset lock stat. */
+ lock_stat->m_stat.reset();
+ }
+}
+
+void release_table_share(PFS_table_share *pfs)
+{
+ DBUG_ASSERT(pfs->get_refcount() > 0);
+ pfs->dec_refcount();
+}
+
+/**
+ Drop the instrumented table share associated with a table.
+ @param thread The running thread
+ @param temporary True for TEMPORARY TABLE
+ @param schema_name The table schema name
+ @param schema_name_length The table schema name length
+ @param table_name The table name
+ @param table_name_length The table name length
+*/
+void drop_table_share(PFS_thread *thread,
+ bool temporary,
+ const char *schema_name, uint schema_name_length,
+ const char *table_name, uint table_name_length)
+{
+ PFS_table_share_key key;
+ LF_PINS* pins= get_table_share_hash_pins(thread);
+ if (unlikely(pins == NULL))
+ return;
+ set_table_share_key(&key, temporary, schema_name, schema_name_length,
+ table_name, table_name_length);
+ PFS_table_share **entry;
+ entry= reinterpret_cast<PFS_table_share**>
+ (lf_hash_search(&table_share_hash, pins,
+ key.m_hash_key, key.m_key_length));
+ if (entry && (entry != MY_ERRPTR))
+ {
+ PFS_table_share *pfs= *entry;
+ lf_hash_delete(&table_share_hash, pins,
+ pfs->m_key.m_hash_key, pfs->m_key.m_key_length);
+ pfs->destroy_lock_stat();
+ pfs->destroy_index_stats();
+
+ pfs->m_lock.allocated_to_free();
+ }
+
+ lf_hash_search_unpin(pins);
+}
+
+/**
+ Sanitize an unsafe table_share pointer.
+ @param unsafe The possibly corrupt pointer.
+ @return A valid table_safe_pointer, or NULL.
+*/
+PFS_table_share *sanitize_table_share(PFS_table_share *unsafe)
+{
+ return global_table_share_container.sanitize(unsafe);
+}
+
+/** Reset the wait statistics per instrument class. */
+void reset_events_waits_by_class()
+{
+ reset_file_class_io();
+ reset_socket_class_io();
+ global_idle_stat.reset();
+ global_table_io_stat.reset();
+ global_table_lock_stat.reset();
+ global_metadata_stat.reset();
+}
+
+/** Reset the io statistics per file class. */
+void reset_file_class_io(void)
+{
+ PFS_file_class *pfs= file_class_array;
+ PFS_file_class *pfs_last= file_class_array + file_class_max;
+
+ for ( ; pfs < pfs_last; pfs++)
+ pfs->m_file_stat.m_io_stat.reset();
+}
+
+/** Reset the io statistics per socket class. */
+void reset_socket_class_io(void)
+{
+ PFS_socket_class *pfs= socket_class_array;
+ PFS_socket_class *pfs_last= socket_class_array + socket_class_max;
+
+ for ( ; pfs < pfs_last; pfs++)
+ pfs->m_socket_stat.m_io_stat.reset();
+}
+
+class Proc_table_share_derived_flags
+ : public PFS_buffer_processor<PFS_table_share>
+{
+public:
+ Proc_table_share_derived_flags(PFS_thread *thread)
+ : m_thread(thread)
+ {}
+
+ virtual void operator()(PFS_table_share *pfs)
+ {
+ pfs->refresh_setup_object_flags(m_thread);
+ }
+
+private:
+ PFS_thread* m_thread;
+};
+
+void update_table_share_derived_flags(PFS_thread *thread)
+{
+ Proc_table_share_derived_flags proc(thread);
+ global_table_share_container.apply(proc);
+}
+
+class Proc_program_share_derived_flags
+ : public PFS_buffer_processor<PFS_program>
+{
+public:
+ Proc_program_share_derived_flags(PFS_thread *thread)
+ : m_thread(thread)
+ {}
+
+ virtual void operator()(PFS_program *pfs)
+ {
+ pfs->refresh_setup_object_flags(m_thread);
+ }
+
+private:
+ PFS_thread* m_thread;
+};
+
+void update_program_share_derived_flags(PFS_thread *thread)
+{
+ Proc_program_share_derived_flags proc(thread);
+ global_program_container.apply(proc);
+}
+
+/** @} */
+
diff --git a/storage/perfschema/pfs_instr_class.h b/storage/perfschema/pfs_instr_class.h
new file mode 100644
index 00000000..573cfe33
--- /dev/null
+++ b/storage/perfschema/pfs_instr_class.h
@@ -0,0 +1,646 @@
+/* Copyright (c) 2008, 2016, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef PFS_INSTR_CLASS_H
+#define PFS_INSTR_CLASS_H
+
+#include "my_global.h"
+#include "mysql_com.h" /* NAME_LEN */
+#include "lf.h"
+#include "pfs_global.h"
+#include "pfs_atomic.h"
+#include "sql_array.h"
+
+/**
+ @file storage/perfschema/pfs_instr_class.h
+ Performance schema instruments meta data (declarations).
+*/
+
+/**
+ Maximum length of an instrument name.
+ For example, 'wait/sync/mutex/sql/LOCK_open' is an instrument name.
+*/
+#define PFS_MAX_INFO_NAME_LENGTH 128
+
+/**
+ Maximum length of the 'full' prefix of an instrument name.
+ For example, for the instrument name 'wait/sync/mutex/sql/LOCK_open',
+ the full prefix is 'wait/sync/mutex/sql/', which in turn derives from
+ a prefix 'wait/sync/mutex' for mutexes, and a category of 'sql' for mutexes
+ of the sql layer in the server.
+*/
+#define PFS_MAX_FULL_PREFIX_NAME_LENGTH 32
+
+#include <my_sys.h>
+#include <mysql/psi/psi.h>
+#include "pfs_lock.h"
+#include "pfs_stat.h"
+#include "pfs_column_types.h"
+
+struct PFS_global_param;
+struct PFS_table_share;
+class PFS_opaque_container_page;
+
+/**
+ @addtogroup Performance_schema_buffers
+ @{
+*/
+
+extern my_bool pfs_enabled;
+extern enum_timer_name *class_timers[];
+
+/** Key, naming a synch instrument (mutex, rwlock, cond). */
+typedef unsigned int PFS_sync_key;
+/** Key, naming a thread instrument. */
+typedef unsigned int PFS_thread_key;
+/** Key, naming a file instrument. */
+typedef unsigned int PFS_file_key;
+/** Key, naming a stage instrument. */
+typedef unsigned int PFS_stage_key;
+/** Key, naming a statement instrument. */
+typedef unsigned int PFS_statement_key;
+/** Key, naming a transaction instrument. */
+typedef unsigned int PFS_transaction_key;
+/** Key, naming a socket instrument. */
+typedef unsigned int PFS_socket_key;
+/** Key, naming a memory instrument. */
+typedef unsigned int PFS_memory_key;
+
+enum PFS_class_type
+{
+ PFS_CLASS_NONE= 0,
+ PFS_CLASS_MUTEX= 1,
+ PFS_CLASS_RWLOCK= 2,
+ PFS_CLASS_COND= 3,
+ PFS_CLASS_FILE= 4,
+ PFS_CLASS_TABLE= 5,
+ PFS_CLASS_STAGE= 6,
+ PFS_CLASS_STATEMENT= 7,
+ PFS_CLASS_TRANSACTION= 8,
+ PFS_CLASS_SOCKET= 9,
+ PFS_CLASS_TABLE_IO= 10,
+ PFS_CLASS_TABLE_LOCK= 11,
+ PFS_CLASS_IDLE= 12,
+ PFS_CLASS_MEMORY= 13,
+ PFS_CLASS_METADATA= 14,
+ PFS_CLASS_LAST= PFS_CLASS_METADATA,
+ PFS_CLASS_MAX= PFS_CLASS_LAST + 1
+};
+
+/** User-defined instrument configuration. */
+struct PFS_instr_config
+{
+ /* Instrument name. */
+ char *m_name;
+ /* Name length. */
+ uint m_name_length;
+ /** Enabled flag. */
+ bool m_enabled;
+ /** Timed flag. */
+ bool m_timed;
+};
+
+typedef Dynamic_array<PFS_instr_config*> Pfs_instr_config_array;
+extern Pfs_instr_config_array *pfs_instr_config_array;
+
+struct PFS_thread;
+
+extern uint mutex_class_start;
+extern uint rwlock_class_start;
+extern uint cond_class_start;
+extern uint file_class_start;
+extern uint socket_class_start;
+extern uint wait_class_max;
+
+/** Information for all instrumentation. */
+struct PFS_instr_class
+{
+ /** Class type */
+ PFS_class_type m_type;
+ /** True if this instrument is enabled. */
+ bool m_enabled;
+ /** True if this instrument is timed. */
+ bool m_timed;
+ /** Instrument flags. */
+ int m_flags;
+ /** Volatility index. */
+ int m_volatility;
+ /**
+ Instrument name index.
+ Self index in:
+ - EVENTS_WAITS_SUMMARY_*_BY_EVENT_NAME for waits
+ - EVENTS_STAGES_SUMMARY_*_BY_EVENT_NAME for stages
+ - EVENTS_STATEMENTS_SUMMARY_*_BY_EVENT_NAME for statements
+ - EVENTS_TRANSACTIONS_SUMMARY_*_BY_EVENT_NAME for transactions
+ */
+ uint m_event_name_index;
+ /** Instrument name. */
+ char m_name[PFS_MAX_INFO_NAME_LENGTH];
+ /** Length in bytes of @c m_name. */
+ uint m_name_length;
+ /** Timer associated with this class. */
+ enum_timer_name *m_timer;
+
+ bool is_singleton() const
+ {
+ return m_flags & PSI_FLAG_GLOBAL;
+ }
+
+ bool is_mutable() const
+ {
+ return m_flags & PSI_FLAG_MUTABLE;
+ }
+
+ bool is_progress() const
+ {
+ DBUG_ASSERT(m_type == PFS_CLASS_STAGE);
+ return m_flags & PSI_FLAG_STAGE_PROGRESS;
+ }
+
+ bool is_shared_exclusive() const
+ {
+ DBUG_ASSERT(m_type == PFS_CLASS_RWLOCK);
+ return m_flags & PSI_RWLOCK_FLAG_SX;
+ }
+
+ static void set_enabled(PFS_instr_class *pfs, bool enabled);
+ static void set_timed(PFS_instr_class *pfs, bool timed);
+
+ bool is_deferred() const
+ {
+ switch(m_type)
+ {
+ case PFS_CLASS_SOCKET:
+ return true;
+ break;
+ default:
+ return false;
+ break;
+ };
+ }
+};
+
+struct PFS_mutex;
+
+/** Instrumentation metadata for a MUTEX. */
+struct PFS_ALIGNED PFS_mutex_class : public PFS_instr_class
+{
+ /** Mutex usage statistics. */
+ PFS_mutex_stat m_mutex_stat;
+ /** Singleton instance. */
+ PFS_mutex *m_singleton;
+};
+
+struct PFS_rwlock;
+
+/** Instrumentation metadata for a RWLOCK. */
+struct PFS_ALIGNED PFS_rwlock_class : public PFS_instr_class
+{
+ /** Rwlock usage statistics. */
+ PFS_rwlock_stat m_rwlock_stat;
+ /** Singleton instance. */
+ PFS_rwlock *m_singleton;
+};
+
+struct PFS_cond;
+
+/** Instrumentation metadata for a COND. */
+struct PFS_ALIGNED PFS_cond_class : public PFS_instr_class
+{
+ /**
+ Condition usage statistics.
+ This statistic is not exposed in user visible tables yet.
+ */
+ PFS_cond_stat m_cond_stat;
+ /** Singleton instance. */
+ PFS_cond *m_singleton;
+};
+
+/** Instrumentation metadata of a thread. */
+struct PFS_ALIGNED PFS_thread_class
+{
+ /** True if this thread instrument is enabled. */
+ bool m_enabled;
+ /** Singleton instance. */
+ PFS_thread *m_singleton;
+ /** Thread instrument name. */
+ char m_name[PFS_MAX_INFO_NAME_LENGTH];
+ /** Length in bytes of @c m_name. */
+ uint m_name_length;
+};
+
+#define PFS_TABLESHARE_HASHKEY_SIZE (NAME_LEN + 1 + NAME_LEN + 1)
+
+/** Key identifying a table share. */
+struct PFS_table_share_key
+{
+ /**
+ Hash search key.
+ This has to be a string for LF_HASH,
+ the format is "<enum_object_type><schema_name><0x00><object_name><0x00>"
+ @see create_table_def_key
+ */
+ char m_hash_key[PFS_TABLESHARE_HASHKEY_SIZE];
+ /** Length in bytes of @c m_hash_key. */
+ uint m_key_length;
+};
+
+/** Table index or 'key' */
+struct PFS_table_key
+{
+ /** Index name */
+ char m_name[NAME_LEN];
+ /** Length in bytes of @c m_name. */
+ uint m_name_length;
+};
+
+/** Index statistics of a table.*/
+struct PFS_table_share_index
+{
+ pfs_lock m_lock;
+ /** The index name */
+ PFS_table_key m_key;
+ /** The index stat */
+ PFS_table_io_stat m_stat;
+ /** Owner table share. To be used later. */
+ PFS_table_share* m_owner;
+ /** Container page. */
+ PFS_opaque_container_page *m_page;
+};
+
+/** Lock statistics of a table.*/
+struct PFS_table_share_lock
+{
+ pfs_lock m_lock;
+ /** Lock stats. */
+ PFS_table_lock_stat m_stat;
+ /** Owner table share. To be used later. */
+ PFS_table_share* m_owner;
+ /** Container page. */
+ PFS_opaque_container_page *m_page;
+};
+
+/** Instrumentation metadata for a table share. */
+struct PFS_ALIGNED PFS_table_share
+{
+public:
+ uint32 get_version()
+ { return m_lock.get_version(); }
+
+ enum_object_type get_object_type()
+ {
+ return (enum_object_type) m_key.m_hash_key[0];
+ }
+
+ void aggregate_io(void);
+ void aggregate_lock(void);
+
+ void sum_io(PFS_single_stat *result, uint key_count);
+ void sum_lock(PFS_single_stat *result);
+ void sum(PFS_single_stat *result, uint key_count);
+
+ inline void aggregate(void)
+ {
+ aggregate_io();
+ aggregate_lock();
+ }
+
+ inline void init_refcount(void)
+ {
+ PFS_atomic::store_32(& m_refcount, 1);
+ }
+
+ inline int get_refcount(void)
+ {
+ return PFS_atomic::load_32(& m_refcount);
+ }
+
+ inline void inc_refcount(void)
+ {
+ PFS_atomic::add_32(& m_refcount, 1);
+ }
+
+ inline void dec_refcount(void)
+ {
+ PFS_atomic::add_32(& m_refcount, -1);
+ }
+
+ void refresh_setup_object_flags(PFS_thread *thread);
+
+ /** Internal lock. */
+ pfs_lock m_lock;
+ /**
+ True if table instrumentation is enabled.
+ This flag is computed from the content of table setup_objects.
+ */
+ bool m_enabled;
+ /**
+ True if table instrumentation is timed.
+ This flag is computed from the content of table setup_objects.
+ */
+ bool m_timed;
+
+ /** Search key. */
+ PFS_table_share_key m_key;
+ /** Schema name. */
+ const char *m_schema_name;
+ /** Length in bytes of @c m_schema_name. */
+ uint m_schema_name_length;
+ /** Table name. */
+ const char *m_table_name;
+ /** Length in bytes of @c m_table_name. */
+ uint m_table_name_length;
+ /** Number of indexes. */
+ uint m_key_count;
+ /** Container page. */
+ PFS_opaque_container_page *m_page;
+
+ PFS_table_share_lock *find_lock_stat() const;
+ PFS_table_share_lock *find_or_create_lock_stat();
+ void destroy_lock_stat();
+
+ PFS_table_share_index *find_index_stat(uint index) const;
+ PFS_table_share_index *find_or_create_index_stat(const TABLE_SHARE *server_share, uint index);
+ void destroy_index_stats();
+
+private:
+ /** Number of opened table handles. */
+ int m_refcount;
+ /** Table locks statistics. */
+ PFS_table_share_lock *m_race_lock_stat;
+ /** Table indexes' stats. */
+ PFS_table_share_index *m_race_index_stat[MAX_INDEXES + 1];
+};
+
+/** Statistics for the IDLE instrument. */
+extern PFS_single_stat global_idle_stat;
+/** Statistics for dropped table io. */
+extern PFS_table_io_stat global_table_io_stat;
+/** Statistics for dropped table lock. */
+extern PFS_table_lock_stat global_table_lock_stat;
+/** Statistics for the METADATA instrument. */
+extern PFS_single_stat global_metadata_stat;
+/** Statistics for the transaction instrument. */
+extern PFS_transaction_stat global_transaction_stat;
+
+inline uint sanitize_index_count(uint count)
+{
+ if (likely(count <= MAX_INDEXES))
+ return count;
+ return 0;
+}
+
+#define GLOBAL_TABLE_IO_EVENT_INDEX 0
+#define GLOBAL_TABLE_LOCK_EVENT_INDEX 1
+#define GLOBAL_IDLE_EVENT_INDEX 2
+#define GLOBAL_METADATA_EVENT_INDEX 3
+/** Number of global wait events. */
+#define COUNT_GLOBAL_EVENT_INDEX 4
+
+/** Transaction events are not wait events .*/
+#define GLOBAL_TRANSACTION_INDEX 0
+
+/**
+ Instrument controlling all table io.
+ This instrument is used with table SETUP_OBJECTS.
+*/
+extern PFS_instr_class global_table_io_class;
+
+/**
+ Instrument controlling all table lock.
+ This instrument is used with table SETUP_OBJECTS.
+*/
+extern PFS_instr_class global_table_lock_class;
+
+/**
+ Instrument controlling all idle waits.
+*/
+extern PFS_instr_class global_idle_class;
+
+extern PFS_instr_class global_metadata_class;
+
+struct PFS_file;
+
+/** Instrumentation metadata for a file. */
+struct PFS_ALIGNED PFS_file_class : public PFS_instr_class
+{
+ /** File usage statistics. */
+ PFS_file_stat m_file_stat;
+ /** Singleton instance. */
+ PFS_file *m_singleton;
+};
+
+/** Instrumentation metadata for a stage. */
+struct PFS_ALIGNED PFS_stage_class : public PFS_instr_class
+{
+ /**
+ Length of the 'stage/<component>/' prefix.
+ This is to extract 'foo' from 'stage/sql/foo'.
+ */
+ uint m_prefix_length;
+ /** Stage usage statistics. */
+ PFS_stage_stat m_stage_stat;
+};
+
+/** Instrumentation metadata for a statement. */
+struct PFS_ALIGNED PFS_statement_class : public PFS_instr_class
+{
+};
+
+/** Instrumentation metadata for a transaction. */
+struct PFS_ALIGNED PFS_transaction_class : public PFS_instr_class
+{
+};
+
+extern PFS_transaction_class global_transaction_class;
+
+struct PFS_socket;
+
+/** Instrumentation metadata for a socket. */
+struct PFS_ALIGNED PFS_socket_class : public PFS_instr_class
+{
+ /** Socket usage statistics. */
+ PFS_socket_stat m_socket_stat;
+ /** Singleton instance. */
+ PFS_socket *m_singleton;
+};
+
+/** Instrumentation metadata for a memory. */
+struct PFS_ALIGNED PFS_memory_class : public PFS_instr_class
+{
+ bool is_global() const
+ {
+ return m_flags & PSI_FLAG_GLOBAL;
+ }
+
+ bool is_transferable() const
+ {
+ return m_flags & PSI_FLAG_TRANSFER;
+ }
+};
+
+void init_event_name_sizing(const PFS_global_param *param);
+
+void register_global_classes();
+
+int init_sync_class(uint mutex_class_sizing,
+ uint rwlock_class_sizing,
+ uint cond_class_sizing);
+
+void cleanup_sync_class();
+int init_thread_class(uint thread_class_sizing);
+void cleanup_thread_class();
+int init_table_share(uint table_share_sizing);
+void cleanup_table_share();
+
+int init_table_share_lock_stat(uint table_stat_sizing);
+void cleanup_table_share_lock_stat();
+PFS_table_share_lock* create_table_share_lock_stat();
+void release_table_share_lock_stat(PFS_table_share_lock *pfs);
+
+int init_table_share_index_stat(uint index_stat_sizing);
+void cleanup_table_share_index_stat();
+PFS_table_share_index* create_table_share_index_stat(const TABLE_SHARE *share, uint index);
+void release_table_share_index_stat(PFS_table_share_index *pfs);
+
+int init_table_share_hash(const PFS_global_param *param);
+void cleanup_table_share_hash();
+int init_file_class(uint file_class_sizing);
+void cleanup_file_class();
+int init_stage_class(uint stage_class_sizing);
+void cleanup_stage_class();
+int init_statement_class(uint statement_class_sizing);
+void cleanup_statement_class();
+int init_socket_class(uint socket_class_sizing);
+void cleanup_socket_class();
+int init_memory_class(uint memory_class_sizing);
+void cleanup_memory_class();
+
+PFS_sync_key register_mutex_class(const char *name, uint name_length,
+ int flags);
+
+PFS_sync_key register_rwlock_class(const char *name, uint name_length,
+ int flags);
+
+PFS_sync_key register_cond_class(const char *name, uint name_length,
+ int flags);
+
+PFS_thread_key register_thread_class(const char *name, uint name_length,
+ int flags);
+
+PFS_file_key register_file_class(const char *name, uint name_length,
+ int flags);
+
+PFS_stage_key register_stage_class(const char *name,
+ uint prefix_length,
+ uint name_length,
+ int flags);
+
+PFS_statement_key register_statement_class(const char *name, uint name_length,
+ int flags);
+
+PFS_socket_key register_socket_class(const char *name, uint name_length,
+ int flags);
+
+PFS_memory_key register_memory_class(const char *name, uint name_length,
+ int flags);
+
+PFS_mutex_class *find_mutex_class(PSI_mutex_key key);
+PFS_mutex_class *sanitize_mutex_class(PFS_mutex_class *unsafe);
+PFS_rwlock_class *find_rwlock_class(PSI_rwlock_key key);
+PFS_rwlock_class *sanitize_rwlock_class(PFS_rwlock_class *unsafe);
+PFS_cond_class *find_cond_class(PSI_cond_key key);
+PFS_cond_class *sanitize_cond_class(PFS_cond_class *unsafe);
+PFS_thread_class *find_thread_class(PSI_thread_key key);
+PFS_thread_class *sanitize_thread_class(PFS_thread_class *unsafe);
+PFS_file_class *find_file_class(PSI_file_key key);
+PFS_file_class *sanitize_file_class(PFS_file_class *unsafe);
+PFS_stage_class *find_stage_class(PSI_stage_key key);
+PFS_stage_class *sanitize_stage_class(PFS_stage_class *unsafe);
+PFS_statement_class *find_statement_class(PSI_statement_key key);
+PFS_statement_class *sanitize_statement_class(PFS_statement_class *unsafe);
+PFS_instr_class *find_table_class(uint index);
+PFS_instr_class *sanitize_table_class(PFS_instr_class *unsafe);
+PFS_socket_class *find_socket_class(PSI_socket_key key);
+PFS_socket_class *sanitize_socket_class(PFS_socket_class *unsafe);
+PFS_memory_class *find_memory_class(PSI_memory_key key);
+PFS_memory_class *sanitize_memory_class(PFS_memory_class *unsafe);
+PFS_instr_class *find_idle_class(uint index);
+PFS_instr_class *sanitize_idle_class(PFS_instr_class *unsafe);
+PFS_instr_class *find_metadata_class(uint index);
+PFS_instr_class *sanitize_metadata_class(PFS_instr_class *unsafe);
+PFS_transaction_class *find_transaction_class(uint index);
+PFS_transaction_class *sanitize_transaction_class(PFS_transaction_class *unsafe);
+
+PFS_table_share *find_or_create_table_share(PFS_thread *thread,
+ bool temporary,
+ const TABLE_SHARE *share);
+void release_table_share(PFS_table_share *pfs);
+void drop_table_share(PFS_thread *thread,
+ bool temporary,
+ const char *schema_name, uint schema_name_length,
+ const char *table_name, uint table_name_length);
+
+PFS_table_share *sanitize_table_share(PFS_table_share *unsafe);
+
+extern ulong mutex_class_max;
+extern ulong mutex_class_lost;
+extern ulong rwlock_class_max;
+extern ulong rwlock_class_lost;
+extern ulong cond_class_max;
+extern ulong cond_class_lost;
+extern ulong thread_class_max;
+extern ulong thread_class_lost;
+extern ulong file_class_max;
+extern ulong file_class_lost;
+extern ulong stage_class_max;
+extern ulong stage_class_lost;
+extern ulong statement_class_max;
+extern ulong statement_class_lost;
+extern ulong transaction_class_max;
+extern ulong socket_class_max;
+extern ulong socket_class_lost;
+extern ulong memory_class_max;
+extern ulong memory_class_lost;
+
+/* Exposing the data directly, for iterators. */
+
+extern PFS_mutex_class *mutex_class_array;
+extern PFS_rwlock_class *rwlock_class_array;
+extern PFS_cond_class *cond_class_array;
+extern PFS_file_class *file_class_array;
+
+void reset_events_waits_by_class();
+void reset_file_class_io();
+void reset_socket_class_io();
+
+/** Update derived flags for all table shares. */
+void update_table_share_derived_flags(PFS_thread *thread);
+
+/** Update derived flags for all stored procedure shares. */
+void update_program_share_derived_flags(PFS_thread *thread);
+
+extern LF_HASH table_share_hash;
+
+/** @} */
+#endif
+
diff --git a/storage/perfschema/pfs_lock.h b/storage/perfschema/pfs_lock.h
new file mode 100644
index 00000000..3730e61c
--- /dev/null
+++ b/storage/perfschema/pfs_lock.h
@@ -0,0 +1,310 @@
+/* Copyright (c) 2009, 2016, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef PFS_LOCK_H
+#define PFS_LOCK_H
+
+/**
+ @file storage/perfschema/pfs_lock.h
+ Performance schema internal locks (declarations).
+*/
+
+#include "my_global.h"
+
+#include "pfs_atomic.h"
+
+/* to cause bugs, testing */
+// #define MEM(X) std::memory_order_relaxed
+/* correct code */
+#define MEM(X) X
+
+/**
+ @addtogroup Performance_schema_buffers
+ @{
+*/
+
+/**
+ State of a free record.
+ Values of a free record should not be read by a reader.
+ Writers can concurrently attempt to allocate a free record.
+*/
+#define PFS_LOCK_FREE 0x00
+/**
+ State of a dirty record.
+ Values of a dirty record should not be read by a reader,
+ as the record is currently being modified.
+ Only one writer, the writer which owns the record, should
+ modify the record content.
+*/
+#define PFS_LOCK_DIRTY 0x01
+/**
+ State of an allocated record.
+ Values of an allocated record are safe to read by a reader.
+ A writer may modify some but not all properties of the record:
+ only modifying values that can never cause the reader to crash is allowed.
+*/
+#define PFS_LOCK_ALLOCATED 0x02
+
+#define VERSION_MASK 0xFFFFFFFC
+#define STATE_MASK 0x00000003
+#define VERSION_INC 4
+
+struct pfs_optimistic_state
+{
+ uint32 m_version_state;
+};
+
+struct pfs_dirty_state
+{
+ uint32 m_version_state;
+};
+
+/**
+ A 'lock' protecting performance schema internal buffers.
+ This lock is used to mark the state of a record.
+ Access to the record is not enforced here,
+ it's up to the readers and writers to look at the record state
+ before making an actual read or write operation.
+*/
+struct pfs_lock
+{
+ /**
+ The record internal version and state
+ @sa PFS_LOCK_FREE
+ @sa PFS_LOCK_DIRTY
+ @sa PFS_LOCK_ALLOCATED
+ The version number is to transform the 'ABA' problem
+ (see http://en.wikipedia.org/wiki/ABA_problem)
+ into an 'A(n)BA(n + 1)' problem, where 'n' is the m_version number.
+ When the performance schema instrumentation deletes a record,
+ then create a different record reusing the same memory allocation,
+ the version number is incremented, so that a reader can detect that
+ the record was changed. Note that the version number is never
+ reset to zero when a new record is created.
+ The version number is stored in the high 30 bits.
+ The state is stored in the low 2 bits.
+ */
+ uint32 m_version_state;
+
+ uint32 copy_version_state()
+ {
+ uint32 copy;
+
+ copy= m_version_state; /* dirty read */
+
+ return copy;
+ }
+
+ /** Returns true if the record is free. */
+ bool is_free(void)
+ {
+ uint32 copy;
+
+ copy= PFS_atomic::load_u32(&m_version_state);
+
+ return ((copy & STATE_MASK) == PFS_LOCK_FREE);
+ }
+
+ /** Returns true if the record contains values that can be read. */
+ bool is_populated(void)
+ {
+ uint32 copy;
+
+ copy= PFS_atomic::load_u32(&m_version_state);
+
+ return ((copy & STATE_MASK) == PFS_LOCK_ALLOCATED);
+ }
+
+ /**
+ Execute a free to dirty transition.
+ This transition is safe to execute concurrently by multiple writers.
+ Only one writer will succeed to acquire the record.
+ @return true if the operation succeed
+ */
+ bool free_to_dirty(pfs_dirty_state *copy_ptr)
+ {
+ uint32 old_val;
+
+ old_val= PFS_atomic::load_u32(&m_version_state);
+
+ if ((old_val & STATE_MASK) != PFS_LOCK_FREE)
+ {
+ return false;
+ }
+
+ uint32 new_val= (old_val & VERSION_MASK) + PFS_LOCK_DIRTY;
+ bool pass;
+
+ pass= PFS_atomic::cas_u32(&m_version_state, &old_val, new_val);
+
+ if (pass)
+ {
+ copy_ptr->m_version_state= new_val;
+ }
+
+ return pass;
+ }
+
+ /**
+ Execute an allocated to dirty transition.
+ This transition should be executed by the writer that owns the record,
+ before the record is modified.
+ */
+ void allocated_to_dirty(pfs_dirty_state *copy_ptr)
+ {
+ uint32 copy= copy_version_state();
+ /* Make sure the record was ALLOCATED. */
+ DBUG_ASSERT((copy & STATE_MASK) == PFS_LOCK_ALLOCATED);
+ /* Keep the same version, set the DIRTY state */
+ uint32 new_val= (copy & VERSION_MASK) + PFS_LOCK_DIRTY;
+ /* We own the record, no need to use compare and swap. */
+
+ PFS_atomic::store_u32(&m_version_state, new_val);
+
+ copy_ptr->m_version_state= new_val;
+ }
+
+ /**
+ Execute a dirty to allocated transition.
+ This transition should be executed by the writer that owns the record,
+ after the record is in a state ready to be read.
+ */
+ void dirty_to_allocated(const pfs_dirty_state *copy)
+ {
+ /* Make sure the record was DIRTY. */
+ DBUG_ASSERT((copy->m_version_state & STATE_MASK) == PFS_LOCK_DIRTY);
+ /* Increment the version, set the ALLOCATED state */
+ uint32 new_val= (copy->m_version_state & VERSION_MASK) + VERSION_INC + PFS_LOCK_ALLOCATED;
+
+ PFS_atomic::store_u32(&m_version_state, new_val);
+ }
+
+ /**
+ Initialize a lock to allocated.
+ This transition should be executed by the writer that owns the record and the lock,
+ after the record is in a state ready to be read.
+ */
+ void set_allocated(void)
+ {
+ /* Do not set the version to 0, read the previous value. */
+ uint32 copy= copy_version_state();
+ /* Increment the version, set the ALLOCATED state */
+ uint32 new_val= (copy & VERSION_MASK) + VERSION_INC + PFS_LOCK_ALLOCATED;
+
+ PFS_atomic::store_u32(&m_version_state, new_val);
+ }
+
+ /**
+ Initialize a lock to dirty.
+ */
+ void set_dirty(pfs_dirty_state *copy_ptr)
+ {
+ /* Do not set the version to 0, read the previous value. */
+ uint32 copy= PFS_atomic::load_u32(&m_version_state);
+ /* Increment the version, set the DIRTY state */
+ uint32 new_val= (copy & VERSION_MASK) + VERSION_INC + PFS_LOCK_DIRTY;
+ PFS_atomic::store_u32(&m_version_state, new_val);
+
+ copy_ptr->m_version_state= new_val;
+ }
+
+ /**
+ Execute a dirty to free transition.
+ This transition should be executed by the writer that owns the record.
+ */
+ void dirty_to_free(const pfs_dirty_state *copy)
+ {
+ /* Make sure the record was DIRTY. */
+ DBUG_ASSERT((copy->m_version_state & STATE_MASK) == PFS_LOCK_DIRTY);
+ /* Keep the same version, set the FREE state */
+ uint32 new_val= (copy->m_version_state & VERSION_MASK) + PFS_LOCK_FREE;
+
+ PFS_atomic::store_u32(&m_version_state, new_val);
+ }
+
+ /**
+ Execute an allocated to free transition.
+ This transition should be executed by the writer that owns the record.
+ */
+ void allocated_to_free(void)
+ {
+ /*
+ If this record is not in the ALLOCATED state and the caller is trying
+ to free it, this is a bug: the caller is confused,
+ and potentially damaging data owned by another thread or object.
+ */
+ uint32 copy= copy_version_state();
+ /* Make sure the record was ALLOCATED. */
+ DBUG_ASSERT(((copy & STATE_MASK) == PFS_LOCK_ALLOCATED));
+ /* Keep the same version, set the FREE state */
+ uint32 new_val= (copy & VERSION_MASK) + PFS_LOCK_FREE;
+
+ PFS_atomic::store_u32(&m_version_state, new_val);
+ }
+
+ /**
+ Start an optimistic read operation.
+ @param [out] copy Saved lock state
+ @sa end_optimist_lock.
+ */
+ void begin_optimistic_lock(struct pfs_optimistic_state *copy)
+ {
+ copy->m_version_state= PFS_atomic::load_u32(&m_version_state);
+ }
+
+ /**
+ End an optimistic read operation.
+ @sa begin_optimist_lock.
+ @param copy Saved lock state
+ @return true if the data read is safe to use.
+ */
+ bool end_optimistic_lock(const struct pfs_optimistic_state *copy)
+ {
+ uint32 version_state;
+
+ /* Check there was valid data to look at. */
+ if ((copy->m_version_state & STATE_MASK) != PFS_LOCK_ALLOCATED)
+ return false;
+
+ version_state= PFS_atomic::load_u32(&m_version_state);
+
+ /* Check the version + state has not changed. */
+ if (copy->m_version_state != version_state)
+ return false;
+
+ return true;
+ }
+
+ uint32 get_version()
+ {
+ uint32 version_state;
+
+ version_state= PFS_atomic::load_u32(&m_version_state);
+
+ return (version_state & VERSION_MASK);
+ }
+};
+
+
+/** @} */
+#endif
+
diff --git a/storage/perfschema/pfs_memory.cc b/storage/perfschema/pfs_memory.cc
new file mode 100644
index 00000000..c4e92d7d
--- /dev/null
+++ b/storage/perfschema/pfs_memory.cc
@@ -0,0 +1,98 @@
+/* Copyright (c) 2013, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/pfs_memory.cc
+ Memory statistics aggregation (implementation).
+*/
+
+#include "my_global.h"
+#include "my_sys.h"
+#include "pfs_global.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "pfs_account.h"
+#include "pfs_host.h"
+#include "pfs_user.h"
+#include "pfs_atomic.h"
+#include "pfs_buffer_container.h"
+#include "m_string.h"
+
+static void fct_reset_memory_by_thread(PFS_thread *pfs)
+{
+ PFS_account *account= sanitize_account(pfs->m_account);
+ PFS_user *user= sanitize_user(pfs->m_user);
+ PFS_host *host= sanitize_host(pfs->m_host);
+ aggregate_thread_memory(true, pfs, account, user, host);
+}
+
+/** Reset table MEMORY_SUMMARY_BY_THREAD_BY_EVENT_NAME data. */
+void reset_memory_by_thread()
+{
+ global_thread_container.apply(fct_reset_memory_by_thread);
+}
+
+static void fct_reset_memory_by_account(PFS_account *pfs)
+{
+ PFS_user *user= sanitize_user(pfs->m_user);
+ PFS_host *host= sanitize_host(pfs->m_host);
+ pfs->aggregate_memory(true, user, host);
+}
+
+/** Reset table MEMORY_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME data. */
+void reset_memory_by_account()
+{
+ global_account_container.apply(fct_reset_memory_by_account);
+}
+
+static void fct_reset_memory_by_user(PFS_user *pfs)
+{
+ pfs->aggregate_memory(true);
+}
+
+/** Reset table MEMORY_SUMMARY_BY_USER_BY_EVENT_NAME data. */
+void reset_memory_by_user()
+{
+ global_user_container.apply(fct_reset_memory_by_user);
+}
+
+static void fct_reset_memory_by_host(PFS_host *pfs)
+{
+ pfs->aggregate_memory(true);
+}
+
+/** Reset table MEMORY_SUMMARY_BY_HOST_BY_EVENT_NAME data. */
+void reset_memory_by_host()
+{
+ global_host_container.apply(fct_reset_memory_by_host);
+}
+
+/** Reset table MEMORY_GLOBAL_BY_EVENT_NAME data. */
+void reset_memory_global()
+{
+ PFS_memory_stat *stat= global_instr_class_memory_array;
+ PFS_memory_stat *stat_last= global_instr_class_memory_array + memory_class_max;
+
+ for ( ; stat < stat_last; stat++)
+ stat->rebase();
+}
+
diff --git a/storage/perfschema/pfs_memory.h b/storage/perfschema/pfs_memory.h
new file mode 100644
index 00000000..4dc21b89
--- /dev/null
+++ b/storage/perfschema/pfs_memory.h
@@ -0,0 +1,38 @@
+/* Copyright (c) 2013, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
+
+#ifndef PFS_MEMORY_H
+#define PFS_MEMORY_H
+
+/**
+ @file storage/perfschema/pfs_memory.h
+ Memory statistics aggregation (declarations).
+*/
+
+void reset_memory_by_thread();
+void reset_memory_by_account();
+void reset_memory_by_user();
+void reset_memory_by_host();
+void reset_memory_global();
+
+#endif
+
diff --git a/storage/perfschema/pfs_prepared_stmt.cc b/storage/perfschema/pfs_prepared_stmt.cc
new file mode 100644
index 00000000..dcb79916
--- /dev/null
+++ b/storage/perfschema/pfs_prepared_stmt.cc
@@ -0,0 +1,145 @@
+/* Copyright (c) 2014, 2017, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/pfs_prepared_stmt.cc
+ Prepared Statement data structures (implementation).
+*/
+
+/*
+ This code needs extra visibility in the lexer structures
+*/
+
+#include "my_global.h"
+#include "my_sys.h"
+#include "pfs_instr.h"
+#include "pfs_prepared_stmt.h"
+#include "pfs_global.h"
+#include "sql_string.h"
+#include "pfs_buffer_container.h"
+#include <string.h>
+
+/**
+ Initialize table PREPARED_STATEMENTS_INSTANCE.
+ @param param performance schema sizing
+*/
+int init_prepared_stmt(const PFS_global_param *param)
+{
+ if (global_prepared_stmt_container.init(param->m_prepared_stmt_sizing))
+ return 1;
+
+ reset_prepared_stmt_instances();
+ return 0;
+}
+
+/** Cleanup table PREPARED_STATEMENTS_INSTANCE. */
+void cleanup_prepared_stmt(void)
+{
+ global_prepared_stmt_container.cleanup();
+}
+
+void PFS_prepared_stmt::reset_data()
+{
+ m_prepare_stat.reset();
+ m_reprepare_stat.reset();
+ m_execute_stat.reset();
+}
+
+static void fct_reset_prepared_stmt_instances(PFS_prepared_stmt *pfs)
+{
+ pfs->reset_data();
+}
+
+void reset_prepared_stmt_instances()
+{
+ global_prepared_stmt_container.apply_all(fct_reset_prepared_stmt_instances);
+}
+
+PFS_prepared_stmt*
+create_prepared_stmt(void *identity,
+ PFS_thread *thread, PFS_program *pfs_program,
+ PFS_events_statements *pfs_stmt, uint stmt_id,
+ const char* stmt_name, uint stmt_name_length)
+{
+ PFS_prepared_stmt *pfs= NULL;
+ pfs_dirty_state dirty_state;
+
+ /* Create a new record in prepared stmt stat array. */
+ pfs= global_prepared_stmt_container.allocate(& dirty_state);
+ if (pfs != NULL)
+ {
+ /* Reset the stats. */
+ pfs->reset_data();
+ /* Do the assignments. */
+ pfs->m_identity= identity;
+
+ pfs->m_sqltext_length= 0;
+
+ if (stmt_name != NULL)
+ {
+ pfs->m_stmt_name_length= stmt_name_length;
+ if (pfs->m_stmt_name_length > PS_NAME_LENGTH)
+ pfs->m_stmt_name_length= PS_NAME_LENGTH;
+ strncpy(pfs->m_stmt_name, stmt_name, pfs->m_stmt_name_length);
+ }
+ else
+ pfs->m_stmt_name_length= 0;
+
+ pfs->m_stmt_id= stmt_id;
+ pfs->m_owner_thread_id= thread->m_thread_internal_id;
+
+ /* If this statement prepare is called from a SP. */
+ if (pfs_program)
+ {
+ pfs->m_owner_object_type= pfs_program->m_type;
+ strncpy(pfs->m_owner_object_schema, pfs_program->m_schema_name, pfs_program->m_schema_name_length);
+ pfs->m_owner_object_schema_length= pfs_program->m_schema_name_length;
+ strncpy(pfs->m_owner_object_name, pfs_program->m_object_name, pfs_program->m_object_name_length);
+ pfs->m_owner_object_name_length= pfs_program->m_object_name_length;
+ }
+ else
+ {
+ pfs->m_owner_object_type= NO_OBJECT_TYPE;
+ pfs->m_owner_object_schema_length= 0;
+ pfs->m_owner_object_name_length= 0;
+ }
+
+ if (pfs_stmt)
+ {
+ if (pfs_program)
+ pfs->m_owner_event_id= pfs_stmt->m_nesting_event_id;
+ else
+ pfs->m_owner_event_id= pfs_stmt->m_event_id;
+ }
+
+ /* Insert this record. */
+ pfs->m_lock.dirty_to_allocated(& dirty_state);
+ }
+
+ return pfs;
+}
+
+void delete_prepared_stmt(PFS_prepared_stmt *pfs)
+{
+ global_prepared_stmt_container.deallocate(pfs);
+ return;
+}
diff --git a/storage/perfschema/pfs_prepared_stmt.h b/storage/perfschema/pfs_prepared_stmt.h
new file mode 100644
index 00000000..1b017b50
--- /dev/null
+++ b/storage/perfschema/pfs_prepared_stmt.h
@@ -0,0 +1,95 @@
+/* Copyright (c) 2014, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
+
+#ifndef PFS_PS_H
+#define PFS_PS_H
+
+/**
+ @file storage/perfschema/pfs_prepared_statement.h
+ Stored Program data structures (declarations).
+*/
+
+#include "pfs_stat.h"
+#include "mysql/psi/psi.h"
+#include "mysql/psi/mysql_ps.h"
+#include "pfs_program.h"
+
+#define PS_NAME_LENGTH NAME_LEN
+
+struct PFS_ALIGNED PFS_prepared_stmt : public PFS_instr
+{
+ /** Column OBJECT_INSTANCE_BEGIN */
+ const void *m_identity;
+
+ /** STATEMENT_ID */
+ ulonglong m_stmt_id;
+
+ /** STATEMENT_NAME */
+ char m_stmt_name[PS_NAME_LENGTH];
+ uint m_stmt_name_length;
+
+ /** SQL_TEXT */
+ char m_sqltext[COL_INFO_SIZE];
+ uint m_sqltext_length;
+
+ /** Column OWNER_THREAD_ID */
+ ulonglong m_owner_thread_id;
+
+ /** Column OWNER_EVENT_ID. */
+ ulonglong m_owner_event_id;
+
+ /** Column OBJECT_OWNER_TYPE. */
+ enum_object_type m_owner_object_type;
+
+ /** Column OBJECT_OWNER_SCHEMA. */
+ char m_owner_object_schema[COL_OBJECT_SCHEMA_SIZE];
+ uint m_owner_object_schema_length;
+
+ /** Column OBJECT_OWNER_NAME. */
+ char m_owner_object_name[COL_OBJECT_NAME_SIZE];
+ uint m_owner_object_name_length;
+
+ /** COLUMN TIMER_PREPARE. Prepared stmt prepare stat. */
+ PFS_single_stat m_prepare_stat;
+
+ /** COLUMN COUNT_REPREPARE. Prepared stmt reprepare stat. */
+ PFS_single_stat m_reprepare_stat;
+
+ /** Prepared stmt execution stat. */
+ PFS_statement_stat m_execute_stat;
+
+ /** Reset data for this record. */
+ void reset_data();
+};
+
+int init_prepared_stmt(const PFS_global_param *param);
+void cleanup_prepared_stmt(void);
+
+void reset_prepared_stmt_instances();
+
+PFS_prepared_stmt*
+create_prepared_stmt(void *identity,
+ PFS_thread *thread, PFS_program *pfs_program,
+ PFS_events_statements *pfs_stmt, uint stmt_id,
+ const char* stmt_name, uint stmt_name_length);
+void delete_prepared_stmt(PFS_prepared_stmt *pfs_ps);
+#endif
diff --git a/storage/perfschema/pfs_program.cc b/storage/perfschema/pfs_program.cc
new file mode 100644
index 00000000..8e6d02c7
--- /dev/null
+++ b/storage/perfschema/pfs_program.cc
@@ -0,0 +1,322 @@
+/* Copyright (c) 2013, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/pfs_program.cc
+ Statement Digest data structures (implementation).
+*/
+
+/*
+ This code needs extra visibility in the lexer structures
+*/
+
+#include "my_global.h"
+#include "my_sys.h"
+#include "pfs_instr.h"
+#include "pfs_program.h"
+#include "pfs_global.h"
+#include "sql_string.h"
+#include "pfs_setup_object.h"
+#include "pfs_buffer_container.h"
+#include "mysqld.h" //system_charset_info
+#include <string.h>
+
+LF_HASH program_hash;
+static bool program_hash_inited= false;
+
+/**
+ Initialize table EVENTS_STATEMENTS_SUMMARY_BY_PROGRAM.
+ @param param performance schema sizing
+*/
+int init_program(const PFS_global_param *param)
+{
+ if (global_program_container.init(param->m_program_sizing))
+ return 1;
+
+ reset_esms_by_program();
+ return 0;
+}
+
+/** Cleanup table EVENTS_STATEMENTS_SUMMARY_BY_PROGRAM. */
+void cleanup_program(void)
+{
+ global_program_container.cleanup();
+}
+
+C_MODE_START
+static uchar *program_hash_get_key(const uchar *entry, size_t *length,
+ my_bool)
+{
+ const PFS_program * const *typed_entry;
+ const PFS_program *program;
+ const void *result;
+ typed_entry= reinterpret_cast<const PFS_program* const *> (entry);
+ DBUG_ASSERT(typed_entry != NULL);
+ program= *typed_entry;
+ DBUG_ASSERT(program != NULL);
+ *length= program->m_key.m_key_length;
+ result= program->m_key.m_hash_key;
+ return const_cast<uchar*> (reinterpret_cast<const uchar*> (result));
+}
+C_MODE_END
+
+/**
+ Initialize the program hash.
+ @return 0 on success
+*/
+int init_program_hash(const PFS_global_param *param)
+{
+ if ((! program_hash_inited) && (param->m_program_sizing != 0))
+ {
+ lf_hash_init(&program_hash, sizeof(PFS_program*), LF_HASH_UNIQUE,
+ 0, 0, program_hash_get_key, &my_charset_bin);
+ program_hash_inited= true;
+ }
+ return 0;
+}
+
+/** Cleanup the program hash. */
+void cleanup_program_hash(void)
+{
+ if (program_hash_inited)
+ {
+ lf_hash_destroy(&program_hash);
+ program_hash_inited= false;
+ }
+}
+
+static void set_program_key(PFS_program_key *key,
+ enum_object_type object_type,
+ const char *object_name, uint object_name_length,
+ const char *schema_name, uint schema_name_length)
+{
+ DBUG_ASSERT(object_name_length <= COL_OBJECT_NAME_SIZE);
+ DBUG_ASSERT(schema_name_length <= COL_OBJECT_SCHEMA_SIZE);
+
+ /*
+ To make sure generated key is case insensitive,
+ convert object_name/schema_name to lowercase.
+ */
+
+ char *ptr= &key->m_hash_key[0];
+
+ ptr[0]= object_type;
+ ptr++;
+
+ if (object_name_length > 0)
+ {
+ char tmp_object_name[COL_OBJECT_NAME_SIZE + 1];
+ memcpy(tmp_object_name, object_name, object_name_length);
+ tmp_object_name[object_name_length]= '\0';
+ my_casedn_str(system_charset_info, tmp_object_name);
+ memcpy(ptr, tmp_object_name, object_name_length);
+ ptr+= object_name_length;
+ }
+ ptr[0]= 0;
+ ptr++;
+
+ if (schema_name_length > 0)
+ {
+ char tmp_schema_name[COL_OBJECT_SCHEMA_SIZE + 1];
+ memcpy(tmp_schema_name, schema_name, schema_name_length);
+ tmp_schema_name[schema_name_length]='\0';
+ my_casedn_str(system_charset_info, tmp_schema_name);
+ memcpy(ptr, tmp_schema_name, schema_name_length);
+ ptr+= schema_name_length;
+ }
+ ptr[0]= 0;
+ ptr++;
+
+ key->m_key_length= static_cast<uint>(ptr - &key->m_hash_key[0]);
+}
+
+
+
+void PFS_program::reset_data()
+{
+ m_sp_stat.reset();
+ m_stmt_stat.reset();
+}
+
+static void fct_reset_esms_by_program(PFS_program *pfs)
+{
+ pfs->reset_data();
+}
+
+void reset_esms_by_program()
+{
+ global_program_container.apply_all(fct_reset_esms_by_program);
+}
+
+static LF_PINS* get_program_hash_pins(PFS_thread *thread)
+{
+ if (unlikely(thread->m_program_hash_pins == NULL))
+ {
+ if (! program_hash_inited)
+ return NULL;
+ thread->m_program_hash_pins= lf_hash_get_pins(&program_hash);
+ }
+ return thread->m_program_hash_pins;
+}
+
+PFS_program*
+find_or_create_program(PFS_thread *thread,
+ enum_object_type object_type,
+ const char *object_name,
+ uint object_name_length,
+ const char *schema_name,
+ uint schema_name_length)
+{
+ bool is_enabled, is_timed;
+
+ LF_PINS *pins= get_program_hash_pins(thread);
+ if (unlikely(pins == NULL))
+ {
+ global_program_container.m_lost++;
+ return NULL;
+ }
+
+ /* Prepare program key */
+ PFS_program_key key;
+ set_program_key(&key, object_type,
+ object_name, object_name_length,
+ schema_name, schema_name_length);
+
+ PFS_program **entry;
+ PFS_program *pfs= NULL;
+ uint retry_count= 0;
+ const uint retry_max= 3;
+ pfs_dirty_state dirty_state;
+
+search:
+ entry= reinterpret_cast<PFS_program**>
+ (lf_hash_search(&program_hash, pins,
+ key.m_hash_key, key.m_key_length));
+
+ if (entry && (entry != MY_ERRPTR))
+ {
+ /* If record already exists then return its pointer. */
+ pfs= *entry;
+ lf_hash_search_unpin(pins);
+ return pfs;
+ }
+
+ lf_hash_search_unpin(pins);
+
+ /*
+ First time while inserting this record to program array we need to
+ find out if it is enabled and timed.
+ */
+ lookup_setup_object(thread, object_type,
+ schema_name, schema_name_length,
+ object_name, object_name_length,
+ &is_enabled, &is_timed);
+
+ /* Else create a new record in program stat array. */
+ pfs= global_program_container.allocate(& dirty_state);
+ if (pfs != NULL)
+ {
+ /* Do the assignments. */
+ memcpy(pfs->m_key.m_hash_key, key.m_hash_key, key.m_key_length);
+ pfs->m_key.m_key_length= key.m_key_length;
+ pfs->m_type= object_type;
+
+ pfs->m_object_name= pfs->m_key.m_hash_key + 1;
+ pfs->m_object_name_length= object_name_length;
+ pfs->m_schema_name= pfs->m_object_name + object_name_length + 1;
+ pfs->m_schema_name_length= schema_name_length;
+ pfs->m_enabled= is_enabled;
+ pfs->m_timed= is_timed;
+
+ /* Insert this record. */
+ pfs->m_lock.dirty_to_allocated(& dirty_state);
+ int res= lf_hash_insert(&program_hash, pins, &pfs);
+
+ if (likely(res == 0))
+ {
+ return pfs;
+ }
+
+ global_program_container.deallocate(pfs);
+
+ if (res > 0)
+ {
+ /* Duplicate insert by another thread */
+ if (++retry_count > retry_max)
+ {
+ /* Avoid infinite loops */
+ global_program_container.m_lost++;
+ return NULL;
+ }
+ goto search;
+ }
+ /* OOM in lf_hash_insert */
+ global_program_container.m_lost++;
+ return NULL;
+ }
+
+ return NULL;
+}
+
+void drop_program(PFS_thread *thread,
+ enum_object_type object_type,
+ const char *object_name,
+ uint object_name_length,
+ const char *schema_name,
+ uint schema_name_length)
+{
+ LF_PINS *pins= get_program_hash_pins(thread);
+ if (unlikely(pins == NULL))
+ return;
+
+ /* Prepare program key */
+ PFS_program_key key;
+ set_program_key(&key, object_type,
+ object_name, object_name_length,
+ schema_name, schema_name_length);
+
+ PFS_program **entry;
+ entry= reinterpret_cast<PFS_program**>
+ (lf_hash_search(&program_hash, pins,
+ key.m_hash_key, key.m_key_length));
+
+ if (entry && (entry != MY_ERRPTR))
+ {
+ PFS_program *pfs= NULL;
+ pfs= *entry;
+
+ lf_hash_delete(&program_hash, pins,
+ key.m_hash_key, key.m_key_length);
+ global_program_container.deallocate(pfs);
+ }
+
+ lf_hash_search_unpin(pins);
+ return;
+}
+
+void PFS_program::refresh_setup_object_flags(PFS_thread *thread)
+{
+ lookup_setup_object(thread, m_type,
+ m_schema_name, m_schema_name_length,
+ m_object_name, m_object_name_length,
+ &m_enabled, &m_timed);
+}
diff --git a/storage/perfschema/pfs_program.h b/storage/perfschema/pfs_program.h
new file mode 100644
index 00000000..0cbd24b8
--- /dev/null
+++ b/storage/perfschema/pfs_program.h
@@ -0,0 +1,103 @@
+/* Copyright (c) 2013, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
+
+#ifndef PFS_PROGRAM_H
+#define PFS_PROGRAM_H
+
+/**
+ @file storage/perfschema/pfs_program.h
+ Stored Program data structures (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_stat.h"
+
+#define PROGRAM_HASH_KEY_LENGTH sizeof(enum_object_type) + COL_OBJECT_NAME_SIZE + 1 + COL_OBJECT_SCHEMA_SIZE + 1
+
+extern LF_HASH program_hash;
+
+/**
+ Hash key for a program.
+*/
+struct PFS_program_key
+{
+ /**
+ Hash search key.
+ This has to be a string for LF_HASH,
+ the format is "<object_type><0x00><object_name><0x00><schema_name><0x00>"
+ */
+ char m_hash_key[PROGRAM_HASH_KEY_LENGTH];
+ uint m_key_length;
+};
+
+struct PFS_ALIGNED PFS_program : public PFS_instr
+{
+ /** Object type. */
+ enum_object_type m_type;
+
+ /** Object name. */
+ const char *m_object_name;
+ int m_object_name_length;
+
+ /** Object Schema name. */
+ const char *m_schema_name;
+ int m_schema_name_length;
+
+ /** Hash key */
+ PFS_program_key m_key;
+
+ /** Sub statement stat. */
+ PFS_statement_stat m_stmt_stat;
+
+ /** Stored program stat. */
+ PFS_sp_stat m_sp_stat;
+
+ /** Referesh setup object flags. */
+ void refresh_setup_object_flags(PFS_thread* thread);
+
+ /** Reset data for this record. */
+ void reset_data();
+};
+
+int init_program(const PFS_global_param *param);
+void cleanup_program(void);
+int init_program_hash(const PFS_global_param *param);
+void cleanup_program_hash(void);
+
+void reset_esms_by_program();
+
+PFS_program*
+find_or_create_program(PFS_thread *thread,
+ enum_object_type object_type,
+ const char *object_name,
+ uint object_name_length,
+ const char *schema,
+ uint schema_length);
+
+void
+drop_program(PFS_thread *thread,
+ enum_object_type object_type,
+ const char *object_name,
+ uint object_name_length,
+ const char *schema_name,
+ uint schema_name_length);
+#endif
diff --git a/storage/perfschema/pfs_server.cc b/storage/perfschema/pfs_server.cc
new file mode 100644
index 00000000..63deba92
--- /dev/null
+++ b/storage/perfschema/pfs_server.cc
@@ -0,0 +1,448 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/pfs_server.cc
+ Private interface for the server (implementation).
+*/
+
+#include "my_global.h"
+#include "my_sys.h"
+#include "mysys_err.h"
+#include "pfs_server.h"
+#include "pfs.h"
+#include "pfs_global.h"
+#include "pfs_instr_class.h"
+#include "pfs_builtin_memory.h"
+#include "pfs_instr.h"
+#include "pfs_events_waits.h"
+#include "pfs_events_stages.h"
+#include "pfs_events_statements.h"
+#include "pfs_events_transactions.h"
+#include "pfs_timer.h"
+#include "pfs_setup_actor.h"
+#include "pfs_setup_object.h"
+#include "pfs_host.h"
+#include "pfs_user.h"
+#include "pfs_account.h"
+#include "pfs_defaults.h"
+#include "pfs_digest.h"
+#include "pfs_program.h"
+//#include "template_utils.h"
+#include "pfs_prepared_stmt.h"
+
+PFS_global_param pfs_param;
+
+PFS_table_stat PFS_table_stat::g_reset_template;
+
+C_MODE_START
+static void destroy_pfs_thread(void *key);
+C_MODE_END
+
+static void cleanup_performance_schema(void);
+void cleanup_instrument_config(void);
+
+void pre_initialize_performance_schema()
+{
+ pfs_initialized= false;
+
+ init_all_builtin_memory_class();
+
+ PFS_table_stat::g_reset_template.reset();
+ global_idle_stat.reset();
+ global_table_io_stat.reset();
+ global_table_lock_stat.reset();
+
+ if (my_create_thread_local_key(&THR_PFS, destroy_pfs_thread))
+ return;
+ if (my_create_thread_local_key(&THR_PFS_VG, NULL)) // global_variables
+ return;
+ if (my_create_thread_local_key(&THR_PFS_SV, NULL)) // session_variables
+ return;
+ if (my_create_thread_local_key(&THR_PFS_VBT, NULL)) // variables_by_thread
+ return;
+ if (my_create_thread_local_key(&THR_PFS_SG, NULL)) // global_status
+ return;
+ if (my_create_thread_local_key(&THR_PFS_SS, NULL)) // session_status
+ return;
+ if (my_create_thread_local_key(&THR_PFS_SBT, NULL)) // status_by_thread
+ return;
+ if (my_create_thread_local_key(&THR_PFS_SBU, NULL)) // status_by_user
+ return;
+ if (my_create_thread_local_key(&THR_PFS_SBH, NULL)) // status_by_host
+ return;
+ if (my_create_thread_local_key(&THR_PFS_SBA, NULL)) // status_by_account
+ return;
+
+ THR_PFS_initialized= true;
+}
+
+struct PSI_bootstrap*
+initialize_performance_schema(PFS_global_param *param)
+{
+ if (!THR_PFS_initialized)
+ {
+ /* Pre-initialization failed. */
+ return NULL;
+ }
+
+ pfs_enabled= param->m_enabled;
+
+ pfs_automated_sizing(param);
+ init_timers();
+ init_event_name_sizing(param);
+ register_global_classes();
+
+ if (init_sync_class(param->m_mutex_class_sizing,
+ param->m_rwlock_class_sizing,
+ param->m_cond_class_sizing) ||
+ init_thread_class(param->m_thread_class_sizing) ||
+ init_table_share(param->m_table_share_sizing) ||
+ init_table_share_lock_stat(param->m_table_lock_stat_sizing) ||
+ init_table_share_index_stat(param->m_index_stat_sizing) ||
+ init_file_class(param->m_file_class_sizing) ||
+ init_stage_class(param->m_stage_class_sizing) ||
+ init_statement_class(param->m_statement_class_sizing) ||
+ init_socket_class(param->m_socket_class_sizing) ||
+ init_memory_class(param->m_memory_class_sizing) ||
+ init_instruments(param) ||
+ init_events_waits_history_long(
+ param->m_events_waits_history_long_sizing) ||
+ init_events_stages_history_long(
+ param->m_events_stages_history_long_sizing) ||
+ init_events_statements_history_long(
+ param->m_events_statements_history_long_sizing) ||
+ init_events_transactions_history_long(
+ param->m_events_transactions_history_long_sizing) ||
+ init_file_hash(param) ||
+ init_table_share_hash(param) ||
+ init_setup_actor(param) ||
+ init_setup_actor_hash(param) ||
+ init_setup_object(param) ||
+ init_setup_object_hash(param) ||
+ init_host(param) ||
+ init_host_hash(param) ||
+ init_user(param) ||
+ init_user_hash(param) ||
+ init_account(param) ||
+ init_account_hash(param) ||
+ init_digest(param) ||
+ init_digest_hash(param) ||
+ init_program(param) ||
+ init_program_hash(param) ||
+ init_prepared_stmt(param))
+ {
+ /*
+ The performance schema initialization failed.
+ Free the memory used, and disable the instrumentation.
+ */
+ cleanup_performance_schema();
+ return NULL;
+ }
+
+ if (param->m_enabled)
+ {
+ /** Default values for SETUP_CONSUMERS */
+ flag_events_stages_current= param->m_consumer_events_stages_current_enabled;
+ flag_events_stages_history= param->m_consumer_events_stages_history_enabled;
+ flag_events_stages_history_long= param->m_consumer_events_stages_history_long_enabled;
+ flag_events_statements_current= param->m_consumer_events_statements_current_enabled;
+ flag_events_statements_history= param->m_consumer_events_statements_history_enabled;
+ flag_events_statements_history_long= param->m_consumer_events_statements_history_long_enabled;
+ flag_events_transactions_current= param->m_consumer_events_transactions_current_enabled;
+ flag_events_transactions_history= param->m_consumer_events_transactions_history_enabled;
+ flag_events_transactions_history_long= param->m_consumer_events_transactions_history_long_enabled;
+ flag_events_waits_current= param->m_consumer_events_waits_current_enabled;
+ flag_events_waits_history= param->m_consumer_events_waits_history_enabled;
+ flag_events_waits_history_long= param->m_consumer_events_waits_history_long_enabled;
+ flag_global_instrumentation= param->m_consumer_global_instrumentation_enabled;
+ flag_thread_instrumentation= param->m_consumer_thread_instrumentation_enabled;
+ flag_statements_digest= param->m_consumer_statement_digest_enabled;
+ }
+ else
+ {
+ flag_events_stages_current= false;
+ flag_events_stages_history= false;
+ flag_events_stages_history_long= false;
+ flag_events_statements_current= false;
+ flag_events_statements_history= false;
+ flag_events_statements_history_long= false;
+ flag_events_transactions_current= false;
+ flag_events_transactions_history= false;
+ flag_events_transactions_history_long= false;
+ flag_events_waits_current= false;
+ flag_events_waits_history= false;
+ flag_events_waits_history_long= false;
+ flag_global_instrumentation= false;
+ flag_thread_instrumentation= false;
+ flag_statements_digest= false;
+ }
+
+ pfs_initialized= true;
+
+ if (param->m_enabled)
+ {
+ install_default_setup(&PFS_bootstrap);
+ return &PFS_bootstrap;
+ }
+
+ return NULL;
+}
+
+static void destroy_pfs_thread(void *key)
+{
+ PFS_thread* pfs= reinterpret_cast<PFS_thread*> (key);
+ DBUG_ASSERT(pfs);
+ /*
+ This automatic cleanup is a last resort and best effort to avoid leaks,
+ and may not work on windows due to the implementation of pthread_key_create().
+ Please either use:
+ - my_thread_end()
+ - or PSI_server->delete_current_thread()
+ in the instrumented code, to explicitly cleanup the instrumentation.
+
+ Avoid invalid writes when the main() thread completes after shutdown:
+ the memory pointed by pfs is already released.
+ */
+ if (pfs_initialized)
+ destroy_thread(pfs);
+}
+
+static void cleanup_performance_schema(void)
+{
+ /*
+ my.cnf options
+ */
+
+ cleanup_instrument_config();
+
+ /*
+ All the LF_HASH
+ */
+
+ cleanup_setup_actor_hash();
+ cleanup_setup_object_hash();
+ cleanup_account_hash();
+ cleanup_host_hash();
+ cleanup_user_hash();
+ cleanup_program_hash();
+ cleanup_table_share_hash();
+ cleanup_file_hash();
+ cleanup_digest_hash();
+
+ /*
+ Then the lookup tables
+ */
+
+ cleanup_setup_actor();
+ cleanup_setup_object();
+
+ /*
+ Then the history tables
+ */
+
+ cleanup_events_waits_history_long();
+ cleanup_events_stages_history_long();
+ cleanup_events_statements_history_long();
+ cleanup_events_transactions_history_long();
+
+ /*
+ Then the various aggregations
+ */
+
+ cleanup_digest();
+ cleanup_account();
+ cleanup_host();
+ cleanup_user();
+
+ /*
+ Then the instrument classes.
+ Once a class is cleaned up,
+ find_XXX_class(key)
+ will return PSI_NOT_INSTRUMENTED
+ */
+ cleanup_program();
+ cleanup_prepared_stmt();
+ cleanup_sync_class();
+ cleanup_thread_class();
+ cleanup_table_share();
+ cleanup_table_share_lock_stat();
+ cleanup_table_share_index_stat();
+ cleanup_file_class();
+ cleanup_stage_class();
+ cleanup_statement_class();
+ cleanup_socket_class();
+ cleanup_memory_class();
+
+ cleanup_instruments();
+}
+
+void shutdown_performance_schema(void)
+{
+ pfs_initialized= false;
+
+ /* disable everything, especially for this thread. */
+ flag_events_stages_current= false;
+ flag_events_stages_history= false;
+ flag_events_stages_history_long= false;
+ flag_events_statements_current= false;
+ flag_events_statements_history= false;
+ flag_events_statements_history_long= false;
+ flag_events_transactions_current= false;
+ flag_events_transactions_history= false;
+ flag_events_transactions_history_long= false;
+ flag_events_waits_current= false;
+ flag_events_waits_history= false;
+ flag_events_waits_history_long= false;
+ flag_global_instrumentation= false;
+ flag_thread_instrumentation= false;
+ flag_statements_digest= false;
+
+ global_table_io_class.m_enabled= false;
+ global_table_lock_class.m_enabled= false;
+ global_idle_class.m_enabled= false;
+ global_metadata_class.m_enabled= false;
+ global_transaction_class.m_enabled= false;
+
+ cleanup_performance_schema();
+ /*
+ Be careful to not delete un-initialized keys,
+ this would affect key 0, which is THR_KEY_mysys,
+ */
+ if (THR_PFS_initialized)
+ {
+ my_set_thread_local(THR_PFS, NULL);
+ my_set_thread_local(THR_PFS_VG, NULL); // global_variables
+ my_set_thread_local(THR_PFS_SV, NULL); // session_variables
+ my_set_thread_local(THR_PFS_VBT, NULL); // variables_by_thread
+ my_set_thread_local(THR_PFS_SG, NULL); // global_status
+ my_set_thread_local(THR_PFS_SS, NULL); // session_status
+ my_set_thread_local(THR_PFS_SBT, NULL); // status_by_thread
+ my_set_thread_local(THR_PFS_SBU, NULL); // status_by_user
+ my_set_thread_local(THR_PFS_SBH, NULL); // status_by_host
+ my_set_thread_local(THR_PFS_SBA, NULL); // status_by_account
+
+ my_delete_thread_local_key(THR_PFS);
+ my_delete_thread_local_key(THR_PFS_VG);
+ my_delete_thread_local_key(THR_PFS_SV);
+ my_delete_thread_local_key(THR_PFS_VBT);
+ my_delete_thread_local_key(THR_PFS_SG);
+ my_delete_thread_local_key(THR_PFS_SS);
+ my_delete_thread_local_key(THR_PFS_SBT);
+ my_delete_thread_local_key(THR_PFS_SBU);
+ my_delete_thread_local_key(THR_PFS_SBH);
+ my_delete_thread_local_key(THR_PFS_SBA);
+
+ THR_PFS_initialized= false;
+ }
+}
+
+/**
+ Initialize the dynamic array used to hold PFS_INSTRUMENT configuration
+ options.
+*/
+void init_pfs_instrument_array()
+{
+ pfs_instr_config_array= new Pfs_instr_config_array((PSI_memory_key)PSI_NOT_INSTRUMENTED);
+}
+
+/**
+ Deallocate the PFS_INSTRUMENT array.
+*/
+void cleanup_instrument_config()
+{
+ if (pfs_instr_config_array != NULL)
+ {
+ PFS_instr_config **it= pfs_instr_config_array->front();
+ for ( ; it != pfs_instr_config_array->end(); it++)
+ my_free(*it);
+ }
+ delete pfs_instr_config_array;
+ pfs_instr_config_array= NULL;
+}
+
+/**
+ Process one performance_schema_instrument configuration string. Isolate the
+ instrument name, evaluate the option value, and store them in a dynamic array.
+ Return 'false' for success, 'true' for error.
+
+ @param name Instrument name
+ @param value Configuration option: 'on', 'off', etc.
+ @return 0 for success, non zero for errors
+*/
+
+int add_pfs_instr_to_array(const char* name, const char* value)
+{
+ size_t name_length= strlen(name);
+ size_t value_length= strlen(value);
+
+ /* Allocate structure plus string buffers plus null terminators */
+ PFS_instr_config* e = (PFS_instr_config*)my_malloc(PSI_NOT_INSTRUMENTED,
+ sizeof(PFS_instr_config)
+ + name_length + 1 + value_length + 1, MYF(MY_WME));
+ if (!e) return 1;
+
+ /* Copy the instrument name */
+ e->m_name= (char*)e + sizeof(PFS_instr_config);
+ memcpy(e->m_name, name, name_length);
+ e->m_name_length= (uint)name_length;
+ e->m_name[name_length]= '\0';
+
+ /* Set flags accordingly */
+ if (!my_strcasecmp(&my_charset_latin1, value, "counted"))
+ {
+ e->m_enabled= true;
+ e->m_timed= false;
+ }
+ else
+ if (!my_strcasecmp(&my_charset_latin1, value, "true") ||
+ !my_strcasecmp(&my_charset_latin1, value, "on") ||
+ !my_strcasecmp(&my_charset_latin1, value, "1") ||
+ !my_strcasecmp(&my_charset_latin1, value, "yes"))
+ {
+ e->m_enabled= true;
+ e->m_timed= true;
+ }
+ else
+ if (!my_strcasecmp(&my_charset_latin1, value, "false") ||
+ !my_strcasecmp(&my_charset_latin1, value, "off") ||
+ !my_strcasecmp(&my_charset_latin1, value, "0") ||
+ !my_strcasecmp(&my_charset_latin1, value, "no"))
+ {
+ e->m_enabled= false;
+ e->m_timed= false;
+ }
+ else
+ {
+ my_free(e);
+ return 1;
+ }
+
+ /* Add to the array of default startup options */
+ if (pfs_instr_config_array->push(e))
+ {
+ my_free(e);
+ return 1;
+ }
+
+ return 0;
+}
diff --git a/storage/perfschema/pfs_server.h b/storage/perfschema/pfs_server.h
new file mode 100644
index 00000000..68f6f71d
--- /dev/null
+++ b/storage/perfschema/pfs_server.h
@@ -0,0 +1,309 @@
+/* Copyright (c) 2008, 2018, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef PFS_SERVER_H
+#define PFS_SERVER_H
+
+/**
+ @file storage/perfschema/pfs_server.h
+ Private interface for the server (declarations).
+*/
+
+#define PFS_AUTOSCALE_VALUE (-1)
+#define PFS_AUTOSIZE_VALUE (-1)
+
+#ifndef PFS_MAX_MUTEX_CLASS
+ #define PFS_MAX_MUTEX_CLASS 210
+#endif
+#ifndef PFS_MAX_RWLOCK_CLASS
+ #define PFS_MAX_RWLOCK_CLASS 50
+#endif
+#ifndef PFS_MAX_COND_CLASS
+ #define PFS_MAX_COND_CLASS 90
+#endif
+#ifndef PFS_MAX_THREAD_CLASS
+ #define PFS_MAX_THREAD_CLASS 50
+#endif
+#ifndef PFS_MAX_FILE_CLASS
+ #define PFS_MAX_FILE_CLASS 80
+#endif
+#ifndef PFS_MAX_FILE_HANDLE
+ #define PFS_MAX_FILE_HANDLE 32768
+#endif
+#ifndef PFS_MAX_SOCKET_CLASS
+ #define PFS_MAX_SOCKET_CLASS 10
+#endif
+#ifndef PFS_MAX_STAGE_CLASS
+ #define PFS_MAX_STAGE_CLASS 160
+#endif
+#ifndef PFS_STATEMENTS_STACK_SIZE
+ #define PFS_STATEMENTS_STACK_SIZE 10
+#endif
+#ifndef PFS_MAX_MEMORY_CLASS
+ #define PFS_MAX_MEMORY_CLASS 320
+#endif
+
+/** Sizing hints, from the server configuration. */
+struct PFS_sizing_hints
+{
+ /** Value of @c Sys_table_def_size */
+ long m_table_definition_cache;
+ /** Value of @c Sys_table_cache_size */
+ long m_table_open_cache;
+ /** Value of @c Sys_max_connections */
+ long m_max_connections;
+ /** Value of @c Sys_open_files_limit */
+ long m_open_files_limit;
+ /** Value of @c Sys_max_prepared_stmt_count */
+ long m_max_prepared_stmt_count;
+};
+
+/** Performance schema global sizing parameters. */
+struct PFS_global_param
+{
+ /** True if the performance schema is enabled. */
+ bool m_enabled;
+ /** Default values for SETUP_CONSUMERS. */
+ bool m_consumer_events_stages_current_enabled;
+ bool m_consumer_events_stages_history_enabled;
+ bool m_consumer_events_stages_history_long_enabled;
+ bool m_consumer_events_statements_current_enabled;
+ bool m_consumer_events_statements_history_enabled;
+ bool m_consumer_events_statements_history_long_enabled;
+ bool m_consumer_events_transactions_current_enabled;
+ bool m_consumer_events_transactions_history_enabled;
+ bool m_consumer_events_transactions_history_long_enabled;
+ bool m_consumer_events_waits_current_enabled;
+ bool m_consumer_events_waits_history_enabled;
+ bool m_consumer_events_waits_history_long_enabled;
+ bool m_consumer_global_instrumentation_enabled;
+ bool m_consumer_thread_instrumentation_enabled;
+ bool m_consumer_statement_digest_enabled;
+
+ /** Default instrument configuration option. */
+ char *m_pfs_instrument;
+
+ /**
+ Maximum number of instrumented mutex classes.
+ @sa mutex_class_lost.
+ */
+ ulong m_mutex_class_sizing;
+ /**
+ Maximum number of instrumented rwlock classes.
+ @sa rwlock_class_lost.
+ */
+ ulong m_rwlock_class_sizing;
+ /**
+ Maximum number of instrumented cond classes.
+ @sa cond_class_lost.
+ */
+ ulong m_cond_class_sizing;
+ /**
+ Maximum number of instrumented thread classes.
+ @sa thread_class_lost.
+ */
+ ulong m_thread_class_sizing;
+ /**
+ Maximum number of instrumented table share.
+ @sa table_share_lost.
+ */
+ long m_table_share_sizing;
+ /**
+ Maximum number of lock statistics collected for tables.
+ @sa table_lock_stat_lost.
+ */
+ long m_table_lock_stat_sizing;
+ /**
+ Maximum number of index statistics collected for tables.
+ @sa table_index_lost.
+ */
+ long m_index_stat_sizing;
+ /**
+ Maximum number of instrumented file classes.
+ @sa file_class_lost.
+ */
+ ulong m_file_class_sizing;
+ /**
+ Maximum number of instrumented mutex instances.
+ @sa mutex_lost.
+ */
+ long m_mutex_sizing;
+ /**
+ Maximum number of instrumented rwlock instances.
+ @sa rwlock_lost.
+ */
+ long m_rwlock_sizing;
+ /**
+ Maximum number of instrumented cond instances.
+ @sa cond_lost.
+ */
+ long m_cond_sizing;
+ /**
+ Maximum number of instrumented thread instances.
+ @sa thread_lost.
+ */
+ long m_thread_sizing;
+ /**
+ Maximum number of instrumented table handles.
+ @sa table_lost.
+ */
+ long m_table_sizing;
+ /**
+ Maximum number of instrumented file instances.
+ @sa file_lost.
+ */
+ long m_file_sizing;
+ /**
+ Maximum number of instrumented file handles.
+ @sa file_handle_lost.
+ */
+ long m_file_handle_sizing;
+ /**
+ Maxium number of instrumented socket instances
+ @sa socket_lost
+ */
+ long m_socket_sizing;
+ /**
+ Maximum number of instrumented socket classes.
+ @sa socket_class_lost.
+ */
+ ulong m_socket_class_sizing;
+ /** Maximum number of rows per thread in table EVENTS_WAITS_HISTORY. */
+ long m_events_waits_history_sizing;
+ /** Maximum number of rows in table EVENTS_WAITS_HISTORY_LONG. */
+ long m_events_waits_history_long_sizing;
+ /** Maximum number of rows in table SETUP_ACTORS. */
+ long m_setup_actor_sizing;
+ /** Maximum number of rows in table SETUP_OBJECTS. */
+ long m_setup_object_sizing;
+ /** Maximum number of rows in table HOSTS. */
+ long m_host_sizing;
+ /** Maximum number of rows in table USERS. */
+ long m_user_sizing;
+ /** Maximum number of rows in table ACCOUNTS. */
+ long m_account_sizing;
+ /**
+ Maximum number of instrumented stage classes.
+ @sa stage_class_lost.
+ */
+ ulong m_stage_class_sizing;
+ /** Maximum number of rows per thread in table EVENTS_STAGES_HISTORY. */
+ long m_events_stages_history_sizing;
+ /** Maximum number of rows in table EVENTS_STAGES_HISTORY_LONG. */
+ long m_events_stages_history_long_sizing;
+ /**
+ Maximum number of instrumented statement classes.
+ @sa statement_class_lost.
+ */
+ ulong m_statement_class_sizing;
+ /** Maximum number of rows per thread in table EVENTS_STATEMENTS_HISTORY. */
+ long m_events_statements_history_sizing;
+ /** Maximum number of rows in table EVENTS_STATEMENTS_HISTORY_LONG. */
+ long m_events_statements_history_long_sizing;
+ /** Maximum number of digests to be captured */
+ long m_digest_sizing;
+ /** Maximum number of programs to be captured */
+ long m_program_sizing;
+ /** Maximum number of prepared statements to be captured */
+ long m_prepared_stmt_sizing;
+ /** Maximum number of rows per thread in table EVENTS_TRANSACTIONS_HISTORY. */
+ long m_events_transactions_history_sizing;
+ /** Maximum number of rows in table EVENTS_TRANSACTIONS_HISTORY_LONG. */
+ long m_events_transactions_history_long_sizing;
+
+ /** Maximum number of session attribute strings per thread */
+ long m_session_connect_attrs_sizing;
+ /** Maximum size of statement stack */
+ ulong m_statement_stack_sizing;
+
+ /**
+ Maximum number of instrumented memory classes.
+ @sa memory_class_lost.
+ */
+ ulong m_memory_class_sizing;
+
+ long m_metadata_lock_sizing;
+
+ long m_max_digest_length;
+ ulong m_max_sql_text_length;
+
+ /** Sizing hints, for auto tuning. */
+ PFS_sizing_hints m_hints;
+};
+
+/**
+ Performance schema sizing values for the server.
+ This global variable is set when parsing server startup options.
+*/
+extern PFS_global_param pfs_param;
+
+/**
+ Null initialization.
+ Disable all instrumentation, size all internal buffers to 0.
+ This pre initialization step is needed to ensure that events can be collected
+ and discarded, until such time @c initialize_performance_schema() is called.
+*/
+void pre_initialize_performance_schema();
+
+/**
+ Initialize the performance schema.
+ @param param Size parameters to use.
+ @return A bootstrap handle, or NULL.
+*/
+struct PSI_bootstrap*
+initialize_performance_schema(PFS_global_param *param);
+
+void pfs_automated_sizing(PFS_global_param *param);
+
+/**
+ Initialize the performance schema ACL.
+ ACL is strictly enforced when the server is running in normal mode,
+ to enforce that only legal operations are allowed.
+ When running in bootstrap mode, ACL restrictions are relaxed,
+ to allow the bootstrap scripts to DROP / CREATE performance schema tables.
+ @sa ACL_internal_schema_registry
+ @param bootstrap True if the server is starting in bootstrap mode.
+*/
+void initialize_performance_schema_acl(bool bootstrap);
+
+/**
+ Reset the aggregated status counter stats.
+*/
+void reset_pfs_status_stats();
+
+/**
+ Initialize the dynamic array holding individual instrument settings collected
+ from the server configuration options.
+*/
+void init_pfs_instrument_array();
+
+/**
+ Process one PFS_INSTRUMENT configuration string.
+*/
+int add_pfs_instr_to_array(const char* name, const char* value);
+
+/**
+ Shutdown the performance schema.
+*/
+void shutdown_performance_schema();
+
+#endif
diff --git a/storage/perfschema/pfs_setup_actor.cc b/storage/perfschema/pfs_setup_actor.cc
new file mode 100644
index 00000000..96b367b6
--- /dev/null
+++ b/storage/perfschema/pfs_setup_actor.cc
@@ -0,0 +1,342 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/pfs_setup_actor.cc
+ Performance schema setup actor (implementation).
+*/
+
+#include "my_global.h"
+#include "my_sys.h"
+#include "my_base.h"
+#include "pfs.h"
+#include "pfs_stat.h"
+#include "pfs_instr.h"
+#include "pfs_setup_actor.h"
+#include "pfs_account.h"
+#include "pfs_global.h"
+#include "pfs_buffer_container.h"
+
+/**
+ @addtogroup Performance_schema_buffers
+ @{
+*/
+
+/** Hash table for setup_actor records. */
+LF_HASH setup_actor_hash;
+/** True if @c setup_actor_hash is initialized. */
+static bool setup_actor_hash_inited= false;
+
+/**
+ Initialize the setup actor buffers.
+ @param param sizing parameters
+ @return 0 on success
+*/
+int init_setup_actor(const PFS_global_param *param)
+{
+ return global_setup_actor_container.init(param->m_setup_actor_sizing);
+}
+
+/** Cleanup all the setup actor buffers. */
+void cleanup_setup_actor(void)
+{
+ global_setup_actor_container.cleanup();
+}
+
+C_MODE_START
+static uchar *setup_actor_hash_get_key(const uchar *entry, size_t *length,
+ my_bool)
+{
+ const PFS_setup_actor * const *typed_entry;
+ const PFS_setup_actor *setup_actor;
+ const void *result;
+ typed_entry= reinterpret_cast<const PFS_setup_actor* const *> (entry);
+ DBUG_ASSERT(typed_entry != NULL);
+ setup_actor= *typed_entry;
+ DBUG_ASSERT(setup_actor != NULL);
+ *length= setup_actor->m_key.m_key_length;
+ result= setup_actor->m_key.m_hash_key;
+ return const_cast<uchar*> (reinterpret_cast<const uchar*> (result));
+}
+C_MODE_END
+
+/**
+ Initialize the setup actor hash.
+ @return 0 on success
+*/
+int init_setup_actor_hash(const PFS_global_param *param)
+{
+ if ((! setup_actor_hash_inited) && (param->m_setup_actor_sizing != 0))
+ {
+ lf_hash_init(&setup_actor_hash, sizeof(PFS_setup_actor*), LF_HASH_UNIQUE,
+ 0, 0, setup_actor_hash_get_key, &my_charset_bin);
+ /* setup_actor_hash.size= param->m_setup_actor_sizing; */
+ setup_actor_hash_inited= true;
+ }
+ return 0;
+}
+
+/** Cleanup the setup actor hash. */
+void cleanup_setup_actor_hash(void)
+{
+ if (setup_actor_hash_inited)
+ {
+ lf_hash_destroy(&setup_actor_hash);
+ setup_actor_hash_inited= false;
+ }
+}
+
+static LF_PINS* get_setup_actor_hash_pins(PFS_thread *thread)
+{
+ if (unlikely(thread->m_setup_actor_hash_pins == NULL))
+ {
+ if (! setup_actor_hash_inited)
+ return NULL;
+ thread->m_setup_actor_hash_pins= lf_hash_get_pins(&setup_actor_hash);
+ }
+ return thread->m_setup_actor_hash_pins;
+}
+
+static void set_setup_actor_key(PFS_setup_actor_key *key,
+ const char *user, uint user_length,
+ const char *host, uint host_length,
+ const char *role, uint role_length)
+{
+ DBUG_ASSERT(user_length <= USERNAME_LENGTH);
+ DBUG_ASSERT(host_length <= HOSTNAME_LENGTH);
+
+ char *ptr= &key->m_hash_key[0];
+ memcpy(ptr, user, user_length);
+ ptr+= user_length;
+ ptr[0]= 0;
+ ptr++;
+ memcpy(ptr, host, host_length);
+ ptr+= host_length;
+ ptr[0]= 0;
+ ptr++;
+ memcpy(ptr, role, role_length);
+ ptr+= role_length;
+ ptr[0]= 0;
+ ptr++;
+ key->m_key_length= (uint)(ptr - &key->m_hash_key[0]);
+}
+
+int insert_setup_actor(const String *user, const String *host, const String *role,
+ bool enabled, bool history)
+{
+ PFS_thread *thread= PFS_thread::get_current_thread();
+ if (unlikely(thread == NULL))
+ return HA_ERR_OUT_OF_MEM;
+
+ LF_PINS *pins= get_setup_actor_hash_pins(thread);
+ if (unlikely(pins == NULL))
+ return HA_ERR_OUT_OF_MEM;
+
+ PFS_setup_actor *pfs;
+ pfs_dirty_state dirty_state;
+
+ pfs= global_setup_actor_container.allocate(& dirty_state);
+ if (pfs != NULL)
+ {
+ set_setup_actor_key(&pfs->m_key,
+ user->ptr(), user->length(),
+ host->ptr(), host->length(),
+ role->ptr(), role->length());
+ pfs->m_username= &pfs->m_key.m_hash_key[0];
+ pfs->m_username_length= user->length();
+ pfs->m_hostname= pfs->m_username + pfs->m_username_length + 1;
+ pfs->m_hostname_length= host->length();
+ pfs->m_rolename= pfs->m_hostname + pfs->m_hostname_length + 1;
+ pfs->m_rolename_length= role->length();
+ pfs->m_enabled= enabled;
+ pfs->m_history= history;
+
+ int res;
+ pfs->m_lock.dirty_to_allocated(& dirty_state);
+ res= lf_hash_insert(&setup_actor_hash, pins, &pfs);
+ if (likely(res == 0))
+ {
+ update_setup_actors_derived_flags();
+ return 0;
+ }
+
+ global_setup_actor_container.deallocate(pfs);
+
+ if (res > 0)
+ return HA_ERR_FOUND_DUPP_KEY;
+ return HA_ERR_OUT_OF_MEM;
+ }
+
+ return HA_ERR_RECORD_FILE_FULL;
+}
+
+int delete_setup_actor(const String *user, const String *host, const String *role)
+{
+ PFS_thread *thread= PFS_thread::get_current_thread();
+ if (unlikely(thread == NULL))
+ return HA_ERR_OUT_OF_MEM;
+
+ LF_PINS* pins= get_setup_actor_hash_pins(thread);
+ if (unlikely(pins == NULL))
+ return HA_ERR_OUT_OF_MEM;
+
+ PFS_setup_actor_key key;
+ set_setup_actor_key(&key,
+ user->ptr(), user->length(),
+ host->ptr(), host->length(),
+ role->ptr(), role->length());
+
+ PFS_setup_actor **entry;
+ entry= reinterpret_cast<PFS_setup_actor**>
+ (lf_hash_search(&setup_actor_hash, pins, key.m_hash_key, key.m_key_length));
+
+ if (entry && (entry != MY_ERRPTR))
+ {
+ PFS_setup_actor *pfs= *entry;
+ lf_hash_delete(&setup_actor_hash, pins, key.m_hash_key, key.m_key_length);
+ global_setup_actor_container.deallocate(pfs);
+ }
+
+ lf_hash_search_unpin(pins);
+
+ update_setup_actors_derived_flags();
+
+ return 0;
+}
+
+class Proc_reset_setup_actor
+ : public PFS_buffer_processor<PFS_setup_actor>
+{
+public:
+ Proc_reset_setup_actor(LF_PINS* pins)
+ : m_pins(pins)
+ {}
+
+ virtual void operator()(PFS_setup_actor *pfs)
+ {
+ lf_hash_delete(&setup_actor_hash, m_pins,
+ pfs->m_key.m_hash_key, pfs->m_key.m_key_length);
+
+ global_setup_actor_container.deallocate(pfs);
+ }
+
+private:
+ LF_PINS* m_pins;
+};
+
+int reset_setup_actor()
+{
+ PFS_thread *thread= PFS_thread::get_current_thread();
+ if (unlikely(thread == NULL))
+ return HA_ERR_OUT_OF_MEM;
+
+ LF_PINS* pins= get_setup_actor_hash_pins(thread);
+ if (unlikely(pins == NULL))
+ return HA_ERR_OUT_OF_MEM;
+
+ Proc_reset_setup_actor proc(pins);
+ // FIXME: delete helper instead
+ global_setup_actor_container.apply(proc);
+
+ update_setup_actors_derived_flags();
+
+ return 0;
+}
+
+long setup_actor_count()
+{
+ return setup_actor_hash.count;
+}
+
+/*
+ - '%' should be replaced by NULL in table SETUP_ACTOR
+ - add an ENABLED column to include/exclude patterns, more flexible
+ - the principle is similar to SETUP_OBJECTS
+*/
+void lookup_setup_actor(PFS_thread *thread,
+ const char *user, uint user_length,
+ const char *host, uint host_length,
+ bool *enabled, bool *history)
+{
+ PFS_setup_actor_key key;
+ PFS_setup_actor **entry;
+ int i;
+
+ LF_PINS* pins= get_setup_actor_hash_pins(thread);
+ if (unlikely(pins == NULL))
+ {
+ *enabled= false;
+ *history= false;
+ return;
+ }
+
+ for (i= 1; i<=4; i++)
+ {
+ /*
+ WL#988 Roles is not implemented, so we do not have a role name.
+ Looking up "%" in SETUP_ACTORS.ROLE.
+ */
+ switch(i)
+ {
+ case 1:
+ set_setup_actor_key(&key, user, user_length, host, host_length, "%", 1);
+ break;
+ case 2:
+ set_setup_actor_key(&key, user, user_length, "%", 1, "%", 1);
+ break;
+ case 3:
+ set_setup_actor_key(&key, "%", 1, host, host_length, "%", 1);
+ break;
+ case 4:
+ set_setup_actor_key(&key, "%", 1, "%", 1, "%", 1);
+ break;
+ }
+ entry= reinterpret_cast<PFS_setup_actor**>
+ (lf_hash_search(&setup_actor_hash, pins, key.m_hash_key, key.m_key_length));
+
+ if (entry && (entry != MY_ERRPTR))
+ {
+ PFS_setup_actor *pfs= *entry;
+ lf_hash_search_unpin(pins);
+ *enabled= pfs->m_enabled;
+ *history= pfs->m_history;
+ return;
+ }
+
+ lf_hash_search_unpin(pins);
+ }
+ *enabled= false;
+ *history= false;
+ return;
+}
+
+int update_setup_actors_derived_flags()
+{
+ PFS_thread *thread= PFS_thread::get_current_thread();
+ if (unlikely(thread == NULL))
+ return HA_ERR_OUT_OF_MEM;
+
+ update_accounts_derived_flags(thread);
+ return 0;
+}
+
+/** @} */
diff --git a/storage/perfschema/pfs_setup_actor.h b/storage/perfschema/pfs_setup_actor.h
new file mode 100644
index 00000000..3d00c52a
--- /dev/null
+++ b/storage/perfschema/pfs_setup_actor.h
@@ -0,0 +1,112 @@
+/* Copyright (c) 2010, 2016, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef PFS_SETUP_ACTOR_H
+#define PFS_SETUP_ACTOR_H
+
+/**
+ @file storage/perfschema/pfs_setup_actor.h
+ Performance schema setup actors (declarations).
+*/
+
+#include "sql_string.h"
+#include "pfs_lock.h"
+#include "lf.h"
+
+struct PFS_global_param;
+class PFS_opaque_container_page;
+
+/* WL#988 Roles Not implemented yet */
+#define ROLENAME_LENGTH 64
+
+/**
+ @addtogroup Performance_schema_buffers
+ @{
+*/
+
+/** Hash key for @sa PFS_setup_actor. */
+struct PFS_setup_actor_key
+{
+ /**
+ Hash search key.
+ This has to be a string for LF_HASH,
+ the format is "<username><0x00><hostname><0x00><rolename><0x00>"
+ */
+ char m_hash_key[USERNAME_LENGTH + 1 + HOSTNAME_LENGTH + 1 + ROLENAME_LENGTH + 1];
+ /** Length of @c m_hash_key. */
+ uint m_key_length;
+};
+
+/** A setup_actor record. */
+struct PFS_ALIGNED PFS_setup_actor
+{
+ /** Internal lock. */
+ pfs_lock m_lock;
+ /** Hash key. */
+ PFS_setup_actor_key m_key;
+ /** User name. This points inside the hash key. */
+ const char *m_username;
+ /** Length of @c m_username. */
+ uint m_username_length;
+ /** Host name. This points inside the hash key. */
+ const char *m_hostname;
+ /** Length of @c m_hostname. */
+ uint m_hostname_length;
+ /** Role name. This points inside the hash key. */
+ const char *m_rolename;
+ /** Length of @c m_rolename. */
+ uint m_rolename_length;
+ /** ENABLED flag. */
+ bool m_enabled;
+ /** HISTORY flag. */
+ bool m_history;
+ /** Container page. */
+ PFS_opaque_container_page *m_page;
+};
+
+int init_setup_actor(const PFS_global_param *param);
+void cleanup_setup_actor(void);
+int init_setup_actor_hash(const PFS_global_param *param);
+void cleanup_setup_actor_hash(void);
+
+int insert_setup_actor(const String *user, const String *host,
+ const String *role, bool enabled, bool history);
+int delete_setup_actor(const String *user, const String *host,
+ const String *role);
+int reset_setup_actor(void);
+long setup_actor_count(void);
+
+void lookup_setup_actor(PFS_thread *thread,
+ const char *user, uint user_length,
+ const char *host, uint host_length,
+ bool *enabled, bool *history);
+
+/** Update derived flags for all setup_actors. */
+int update_setup_actors_derived_flags();
+
+/* For show status. */
+
+extern LF_HASH setup_actor_hash;
+
+/** @} */
+#endif
+
diff --git a/storage/perfschema/pfs_setup_object.cc b/storage/perfschema/pfs_setup_object.cc
new file mode 100644
index 00000000..47afd130
--- /dev/null
+++ b/storage/perfschema/pfs_setup_object.cc
@@ -0,0 +1,338 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/pfs_setup_object.cc
+ Performance schema setup object (implementation).
+*/
+
+#include "my_global.h"
+#include "my_sys.h"
+#include "my_base.h"
+#include "sql_string.h"
+#include "pfs.h"
+#include "pfs_stat.h"
+#include "pfs_instr.h"
+#include "pfs_setup_object.h"
+#include "pfs_global.h"
+#include "pfs_buffer_container.h"
+
+/**
+ @addtogroup Performance_schema_buffers
+ @{
+*/
+
+uint setup_objects_version= 0;
+
+LF_HASH setup_object_hash;
+static bool setup_object_hash_inited= false;
+
+/**
+ Initialize the setup object buffers.
+ @param param sizing parameters
+ @return 0 on success
+*/
+int init_setup_object(const PFS_global_param *param)
+{
+ return global_setup_object_container.init(param->m_setup_object_sizing);
+}
+
+/** Cleanup all the setup object buffers. */
+void cleanup_setup_object(void)
+{
+ global_setup_object_container.cleanup();
+}
+
+C_MODE_START
+static uchar *setup_object_hash_get_key(const uchar *entry, size_t *length,
+ my_bool)
+{
+ const PFS_setup_object * const *typed_entry;
+ const PFS_setup_object *setup_object;
+ const void *result;
+ typed_entry= reinterpret_cast<const PFS_setup_object* const *> (entry);
+ DBUG_ASSERT(typed_entry != NULL);
+ setup_object= *typed_entry;
+ DBUG_ASSERT(setup_object != NULL);
+ *length= setup_object->m_key.m_key_length;
+ result= setup_object->m_key.m_hash_key;
+ return const_cast<uchar*> (reinterpret_cast<const uchar*> (result));
+}
+C_MODE_END
+
+/**
+ Initialize the setup objects hash.
+ @return 0 on success
+*/
+int init_setup_object_hash(const PFS_global_param *param)
+{
+ if ((! setup_object_hash_inited) && (param->m_setup_object_sizing != 0))
+ {
+ lf_hash_init(&setup_object_hash, sizeof(PFS_setup_object*), LF_HASH_UNIQUE,
+ 0, 0, setup_object_hash_get_key, &my_charset_bin);
+ setup_object_hash_inited= true;
+ }
+ return 0;
+}
+
+/** Cleanup the setup objects hash. */
+void cleanup_setup_object_hash(void)
+{
+ if (setup_object_hash_inited)
+ {
+ setup_object_hash_inited= false;
+ lf_hash_destroy(&setup_object_hash);
+ }
+}
+
+static LF_PINS* get_setup_object_hash_pins(PFS_thread *thread)
+{
+ if (unlikely(thread->m_setup_object_hash_pins == NULL))
+ {
+ if (! setup_object_hash_inited)
+ return NULL;
+ thread->m_setup_object_hash_pins= lf_hash_get_pins(&setup_object_hash);
+ }
+ return thread->m_setup_object_hash_pins;
+}
+
+static void set_setup_object_key(PFS_setup_object_key *key,
+ enum_object_type object_type,
+ const char *schema, uint schema_length,
+ const char *object, uint object_length)
+{
+ DBUG_ASSERT(schema_length <= NAME_LEN);
+ DBUG_ASSERT(object_length <= NAME_LEN);
+
+ char *ptr= &key->m_hash_key[0];
+ ptr[0]= (char) object_type;
+ ptr++;
+ if (schema_length)
+ {
+ memcpy(ptr, schema, schema_length);
+ ptr+= schema_length;
+ }
+ ptr[0]= 0;
+ ptr++;
+ if (object_length)
+ {
+ memcpy(ptr, object, object_length);
+ ptr+= object_length;
+ }
+ ptr[0]= 0;
+ ptr++;
+ key->m_key_length= (uint)(ptr - &key->m_hash_key[0]);
+}
+
+int insert_setup_object(enum_object_type object_type, const String *schema,
+ const String *object, bool enabled, bool timed)
+{
+ PFS_thread *thread= PFS_thread::get_current_thread();
+ if (unlikely(thread == NULL))
+ return HA_ERR_OUT_OF_MEM;
+
+ LF_PINS* pins= get_setup_object_hash_pins(thread);
+ if (unlikely(pins == NULL))
+ return HA_ERR_OUT_OF_MEM;
+
+ PFS_setup_object *pfs;
+ pfs_dirty_state dirty_state;
+
+ pfs= global_setup_object_container.allocate(& dirty_state);
+ if (pfs != NULL)
+ {
+ set_setup_object_key(&pfs->m_key, object_type,
+ schema->ptr(), schema->length(),
+ object->ptr(), object->length());
+ pfs->m_schema_name= &pfs->m_key.m_hash_key[1];
+ pfs->m_schema_name_length= schema->length();
+ pfs->m_object_name= pfs->m_schema_name + pfs->m_schema_name_length + 1;
+ pfs->m_object_name_length= object->length();
+ pfs->m_enabled= enabled;
+ pfs->m_timed= timed;
+
+ int res;
+ pfs->m_lock.dirty_to_allocated(& dirty_state);
+ res= lf_hash_insert(&setup_object_hash, pins, &pfs);
+ if (likely(res == 0))
+ {
+ setup_objects_version++;
+ return 0;
+ }
+
+ global_setup_object_container.deallocate(pfs);
+
+ if (res > 0)
+ return HA_ERR_FOUND_DUPP_KEY;
+ /* OOM in lf_hash_insert */
+ return HA_ERR_OUT_OF_MEM;
+ }
+
+ return HA_ERR_RECORD_FILE_FULL;
+}
+
+int delete_setup_object(enum_object_type object_type, const String *schema,
+ const String *object)
+{
+ PFS_thread *thread= PFS_thread::get_current_thread();
+ if (unlikely(thread == NULL))
+ return HA_ERR_OUT_OF_MEM;
+
+ LF_PINS* pins= get_setup_object_hash_pins(thread);
+ if (unlikely(pins == NULL))
+ return HA_ERR_OUT_OF_MEM;
+
+ PFS_setup_object_key key;
+ set_setup_object_key(&key, object_type,
+ schema->ptr(), schema->length(),
+ object->ptr(), object->length());
+
+ PFS_setup_object **entry;
+ entry= reinterpret_cast<PFS_setup_object**>
+ (lf_hash_search(&setup_object_hash, pins, key.m_hash_key, key.m_key_length));
+
+ if (entry && (entry != MY_ERRPTR))
+ {
+ PFS_setup_object *pfs= *entry;
+ lf_hash_delete(&setup_object_hash, pins, key.m_hash_key, key.m_key_length);
+ global_setup_object_container.deallocate(pfs);
+ }
+
+ lf_hash_search_unpin(pins);
+
+ setup_objects_version++;
+ return 0;
+}
+
+class Proc_reset_setup_object
+ : public PFS_buffer_processor<PFS_setup_object>
+{
+public:
+ Proc_reset_setup_object(LF_PINS* pins)
+ : m_pins(pins)
+ {}
+
+ virtual void operator()(PFS_setup_object *pfs)
+ {
+ lf_hash_delete(&setup_object_hash, m_pins,
+ pfs->m_key.m_hash_key, pfs->m_key.m_key_length);
+
+ global_setup_object_container.deallocate(pfs);
+ }
+
+private:
+ LF_PINS* m_pins;
+};
+
+int reset_setup_object()
+{
+ PFS_thread *thread= PFS_thread::get_current_thread();
+ if (unlikely(thread == NULL))
+ return HA_ERR_OUT_OF_MEM;
+
+ LF_PINS* pins= get_setup_object_hash_pins(thread);
+ if (unlikely(pins == NULL))
+ return HA_ERR_OUT_OF_MEM;
+
+ Proc_reset_setup_object proc(pins);
+ // FIXME: delete helper instead
+ global_setup_object_container.apply(proc);
+
+ setup_objects_version++;
+ return 0;
+}
+
+long setup_object_count()
+{
+ return setup_object_hash.count;
+}
+
+void lookup_setup_object(PFS_thread *thread,
+ enum_object_type object_type,
+ const char *schema_name, int schema_name_length,
+ const char *object_name, int object_name_length,
+ bool *enabled, bool *timed)
+{
+ PFS_setup_object_key key;
+ PFS_setup_object **entry;
+ PFS_setup_object *pfs;
+ int i;
+
+ /*
+ The table io instrumentation uses "TABLE" and "TEMPORARY TABLE".
+ SETUP_OBJECT uses "TABLE" for both concepts.
+ There is no way to provide a different setup for:
+ - TABLE foo.bar
+ - TEMPORARY TABLE foo.bar
+ */
+ DBUG_ASSERT(object_type != OBJECT_TYPE_TEMPORARY_TABLE);
+
+ LF_PINS* pins= get_setup_object_hash_pins(thread);
+ if (unlikely(pins == NULL))
+ {
+ *enabled= false;
+ *timed= false;
+ return;
+ }
+
+ for (i= 1; i<=3; i++)
+ {
+ switch(i)
+ {
+ case 1:
+ /* Lookup OBJECT_TYPE + OBJECT_SCHEMA + OBJECT_NAME in SETUP_OBJECTS */
+ set_setup_object_key(&key,
+ object_type,
+ schema_name, schema_name_length,
+ object_name, object_name_length);
+ break;
+ case 2:
+ /* Lookup OBJECT_TYPE + OBJECT_SCHEMA + "%" in SETUP_OBJECTS */
+ set_setup_object_key(&key,
+ object_type,
+ schema_name, schema_name_length, "%", 1);
+ break;
+ case 3:
+ /* Lookup OBJECT_TYPE + "%" + "%" in SETUP_OBJECTS */
+ set_setup_object_key(&key, object_type, "%", 1, "%", 1);
+ break;
+ }
+ entry= reinterpret_cast<PFS_setup_object**>
+ (lf_hash_search(&setup_object_hash, pins, key.m_hash_key, key.m_key_length));
+
+ if (entry && (entry != MY_ERRPTR))
+ {
+ pfs= *entry;
+ *enabled= pfs->m_enabled;
+ *timed= pfs->m_timed;
+ lf_hash_search_unpin(pins);
+ return;
+ }
+
+ lf_hash_search_unpin(pins);
+ }
+ *enabled= false;
+ *timed= false;
+ return;
+}
+
+/** @} */
diff --git a/storage/perfschema/pfs_setup_object.h b/storage/perfschema/pfs_setup_object.h
new file mode 100644
index 00000000..d49be341
--- /dev/null
+++ b/storage/perfschema/pfs_setup_object.h
@@ -0,0 +1,107 @@
+/* Copyright (c) 2010, 2016, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef PFS_SETUP_OBJECT_H
+#define PFS_SETUP_OBJECT_H
+
+/**
+ @file storage/perfschema/pfs_setup_object.h
+ Performance schema setup object (declarations).
+*/
+
+#include "pfs_lock.h"
+#include "lf.h"
+
+class String;
+struct PFS_global_param;
+class PFS_opaque_container_page;
+
+/**
+ @addtogroup Performance_schema_buffers
+ @{
+*/
+
+/** Hash key for @sa PFS_setup_object. */
+struct PFS_setup_object_key
+{
+ /**
+ Hash search key.
+ This has to be a string for LF_HASH,
+ the format is "<enum_object_type><schema_name><0x00><object_name><0x00>"
+ */
+ char m_hash_key[1 + NAME_LEN + 1 + NAME_LEN + 1];
+ uint m_key_length;
+};
+
+/** A setup_object record. */
+struct PFS_ALIGNED PFS_setup_object
+{
+ enum_object_type get_object_type()
+ {
+ return (enum_object_type) m_key.m_hash_key[0];
+ }
+
+ /** Internal lock. */
+ pfs_lock m_lock;
+ /** Hash key. */
+ PFS_setup_object_key m_key;
+ /** Schema name. Points inside m_key. */
+ const char *m_schema_name;
+ /** Length of @c m_schema_name. */
+ uint m_schema_name_length;
+ /** Object name. Points inside m_key. */
+ const char *m_object_name;
+ /** Length of @c m_object_name. */
+ uint m_object_name_length;
+ /** ENABLED flag. */
+ bool m_enabled;
+ /** TIMED flag. */
+ bool m_timed;
+ /** Container page. */
+ PFS_opaque_container_page *m_page;
+};
+
+int init_setup_object(const PFS_global_param *param);
+void cleanup_setup_object(void);
+int init_setup_object_hash(const PFS_global_param *param);
+void cleanup_setup_object_hash(void);
+
+int insert_setup_object(enum_object_type object_type, const String *schema,
+ const String *object, bool enabled, bool timed);
+int delete_setup_object(enum_object_type object_type, const String *schema,
+ const String *object);
+int reset_setup_object(void);
+long setup_object_count(void);
+
+void lookup_setup_object(PFS_thread *thread,
+ enum_object_type object_type,
+ const char *schema_name, int schema_name_length,
+ const char *object_name, int object_name_length,
+ bool *enabled, bool *timed);
+
+/* For show status. */
+
+extern LF_HASH setup_object_hash;
+
+/** @} */
+#endif
+
diff --git a/storage/perfschema/pfs_stat.h b/storage/perfschema/pfs_stat.h
new file mode 100644
index 00000000..e3e06760
--- /dev/null
+++ b/storage/perfschema/pfs_stat.h
@@ -0,0 +1,1332 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef PFS_STAT_H
+#define PFS_STAT_H
+
+#include <algorithm>
+#include "sql_const.h"
+/* memcpy */
+#include "string.h"
+
+/**
+ @file storage/perfschema/pfs_stat.h
+ Statistics (declarations).
+*/
+
+/**
+ @addtogroup Performance_schema_buffers
+ @{
+*/
+
+/** Single statistic. */
+struct PFS_single_stat
+{
+ /** Count of values. */
+ ulonglong m_count;
+ /** Sum of values. */
+ ulonglong m_sum;
+ /** Minimum value. */
+ ulonglong m_min;
+ /** Maximum value. */
+ ulonglong m_max;
+
+ PFS_single_stat()
+ {
+ m_count= 0;
+ m_sum= 0;
+ m_min= ULLONG_MAX;
+ m_max= 0;
+ }
+
+ inline void reset(void)
+ {
+ m_count= 0;
+ m_sum= 0;
+ m_min= ULLONG_MAX;
+ m_max= 0;
+ }
+
+ inline bool has_timed_stats() const
+ {
+ return (m_min <= m_max);
+ }
+
+ inline void aggregate(const PFS_single_stat *stat)
+ {
+ if (stat->m_count != 0)
+ {
+ m_count+= stat->m_count;
+ m_sum+= stat->m_sum;
+ if (unlikely(m_min > stat->m_min))
+ m_min= stat->m_min;
+ if (unlikely(m_max < stat->m_max))
+ m_max= stat->m_max;
+ }
+ }
+
+ inline void aggregate_no_check(const PFS_single_stat *stat)
+ {
+ m_count+= stat->m_count;
+ m_sum+= stat->m_sum;
+ if (unlikely(m_min > stat->m_min))
+ m_min= stat->m_min;
+ if (unlikely(m_max < stat->m_max))
+ m_max= stat->m_max;
+ }
+
+ inline void aggregate_counted()
+ {
+ m_count++;
+ }
+
+ inline void aggregate_counted(ulonglong count)
+ {
+ m_count+= count;
+ }
+
+ inline void aggregate_value(ulonglong value)
+ {
+ m_count++;
+ m_sum+= value;
+ if (unlikely(m_min > value))
+ m_min= value;
+ if (unlikely(m_max < value))
+ m_max= value;
+ }
+
+ inline void aggregate_many_value(ulonglong value, ulonglong count)
+ {
+ m_count+= count;
+ m_sum+= value;
+ if (unlikely(m_min > value))
+ m_min= value;
+ if (unlikely(m_max < value))
+ m_max= value;
+ }
+};
+
+/** Combined statistic. */
+struct PFS_byte_stat : public PFS_single_stat
+{
+ /** Byte count statistics */
+ ulonglong m_bytes;
+
+ /** Aggregate wait stats, event count and byte count */
+ inline void aggregate(const PFS_byte_stat *stat)
+ {
+ if (stat->m_count != 0)
+ {
+ PFS_single_stat::aggregate_no_check(stat);
+ m_bytes+= stat->m_bytes;
+ }
+ }
+
+ /** Aggregate wait stats, event count and byte count */
+ inline void aggregate_no_check(const PFS_byte_stat *stat)
+ {
+ PFS_single_stat::aggregate_no_check(stat);
+ m_bytes+= stat->m_bytes;
+ }
+
+ /** Aggregate individual wait time, event count and byte count */
+ inline void aggregate(ulonglong wait, ulonglong bytes)
+ {
+ aggregate_value(wait);
+ m_bytes+= bytes;
+ }
+
+ /** Aggregate wait stats and event count */
+ inline void aggregate_waits(const PFS_byte_stat *stat)
+ {
+ PFS_single_stat::aggregate(stat);
+ }
+
+ /** Aggregate event count and byte count */
+ inline void aggregate_counted()
+ {
+ PFS_single_stat::aggregate_counted();
+ }
+
+ /** Aggregate event count and byte count */
+ inline void aggregate_counted(ulonglong bytes)
+ {
+ PFS_single_stat::aggregate_counted();
+ m_bytes+= bytes;
+ }
+
+ PFS_byte_stat()
+ {
+ reset();
+ }
+
+ inline void reset(void)
+ {
+ PFS_single_stat::reset();
+ m_bytes= 0;
+ }
+};
+
+/** Statistics for mutex usage. */
+struct PFS_mutex_stat
+{
+ /** Wait statistics. */
+ PFS_single_stat m_wait_stat;
+#ifdef PFS_LATER
+ /**
+ Lock statistics.
+ This statistic is not exposed in user visible tables yet.
+ */
+ PFS_single_stat m_lock_stat;
+#endif
+
+ inline void aggregate(const PFS_mutex_stat *stat)
+ {
+ m_wait_stat.aggregate(&stat->m_wait_stat);
+#ifdef PFS_LATER
+ m_lock_stat.aggregate(&stat->m_lock_stat);
+#endif
+ }
+
+ inline void reset(void)
+ {
+ m_wait_stat.reset();
+#ifdef PFS_LATER
+ m_lock_stat.reset();
+#endif
+ }
+};
+
+/** Statistics for rwlock usage. */
+struct PFS_rwlock_stat
+{
+ /** Wait statistics. */
+ PFS_single_stat m_wait_stat;
+#ifdef PFS_LATER
+ /**
+ RWLock read lock usage statistics.
+ This statistic is not exposed in user visible tables yet.
+ */
+ PFS_single_stat m_read_lock_stat;
+ /**
+ RWLock write lock usage statistics.
+ This statistic is not exposed in user visible tables yet.
+ */
+ PFS_single_stat m_write_lock_stat;
+#endif
+
+ inline void aggregate(const PFS_rwlock_stat *stat)
+ {
+ m_wait_stat.aggregate(&stat->m_wait_stat);
+#ifdef PFS_LATER
+ m_read_lock_stat.aggregate(&stat->m_read_lock_stat);
+ m_write_lock_stat.aggregate(&stat->m_write_lock_stat);
+#endif
+ }
+
+ inline void reset(void)
+ {
+ m_wait_stat.reset();
+#ifdef PFS_LATER
+ m_read_lock_stat.reset();
+ m_write_lock_stat.reset();
+#endif
+ }
+};
+
+/** Statistics for COND usage. */
+struct PFS_cond_stat
+{
+ /** Wait statistics. */
+ PFS_single_stat m_wait_stat;
+#ifdef PFS_LATER
+ /**
+ Number of times a condition was signalled.
+ This statistic is not exposed in user visible tables yet.
+ */
+ ulonglong m_signal_count;
+ /**
+ Number of times a condition was broadcast.
+ This statistic is not exposed in user visible tables yet.
+ */
+ ulonglong m_broadcast_count;
+#endif
+
+ inline void aggregate(const PFS_cond_stat *stat)
+ {
+ m_wait_stat.aggregate(&stat->m_wait_stat);
+#ifdef PFS_LATER
+ m_signal_count+= stat->m_signal_count;
+ m_broadcast_count+= stat->m_broadcast_count;
+#endif
+ }
+
+ inline void reset(void)
+ {
+ m_wait_stat.reset();
+#ifdef PFS_LATER
+ m_signal_count= 0;
+ m_broadcast_count= 0;
+#endif
+ }
+};
+
+/** Statistics for FILE IO. Used for both waits and byte counts. */
+struct PFS_file_io_stat
+{
+ /** READ statistics */
+ PFS_byte_stat m_read;
+ /** WRITE statistics */
+ PFS_byte_stat m_write;
+ /** Miscellaneous statistics */
+ PFS_byte_stat m_misc;
+
+ inline void reset(void)
+ {
+ m_read.reset();
+ m_write.reset();
+ m_misc.reset();
+ }
+
+ inline void aggregate(const PFS_file_io_stat *stat)
+ {
+ m_read.aggregate(&stat->m_read);
+ m_write.aggregate(&stat->m_write);
+ m_misc.aggregate(&stat->m_misc);
+ }
+
+ /* Sum waits and byte counts */
+ inline void sum(PFS_byte_stat *stat)
+ {
+ stat->aggregate(&m_read);
+ stat->aggregate(&m_write);
+ stat->aggregate(&m_misc);
+ }
+
+ /* Sum waits only */
+ inline void sum_waits(PFS_single_stat *stat)
+ {
+ stat->aggregate(&m_read);
+ stat->aggregate(&m_write);
+ stat->aggregate(&m_misc);
+ }
+};
+
+/** Statistics for FILE usage. */
+struct PFS_file_stat
+{
+ /** Number of current open handles. */
+ ulong m_open_count;
+ /** File IO statistics. */
+ PFS_file_io_stat m_io_stat;
+
+ inline void aggregate(const PFS_file_stat *stat)
+ {
+ m_io_stat.aggregate(&stat->m_io_stat);
+ }
+
+ /** Reset file statistics. */
+ inline void reset(void)
+ {
+ m_io_stat.reset();
+ }
+};
+
+/** Statistics for stage usage. */
+struct PFS_stage_stat
+{
+ PFS_single_stat m_timer1_stat;
+
+ inline void reset(void)
+ { m_timer1_stat.reset(); }
+
+ inline void aggregate_counted()
+ { m_timer1_stat.aggregate_counted(); }
+
+ inline void aggregate_value(ulonglong value)
+ { m_timer1_stat.aggregate_value(value); }
+
+ inline void aggregate(const PFS_stage_stat *stat)
+ { m_timer1_stat.aggregate(& stat->m_timer1_stat); }
+};
+
+/** Statistics for stored program usage. */
+struct PFS_sp_stat
+{
+ PFS_single_stat m_timer1_stat;
+
+ inline void reset(void)
+ { m_timer1_stat.reset(); }
+
+ inline void aggregate_counted()
+ { m_timer1_stat.aggregate_counted(); }
+
+ inline void aggregate_value(ulonglong value)
+ { m_timer1_stat.aggregate_value(value); }
+
+ inline void aggregate(const PFS_stage_stat *stat)
+ { m_timer1_stat.aggregate(& stat->m_timer1_stat); }
+};
+
+/** Statistics for prepared statement usage. */
+struct PFS_prepared_stmt_stat
+{
+ PFS_single_stat m_timer1_stat;
+
+ inline void reset(void)
+ { m_timer1_stat.reset(); }
+
+ inline void aggregate_counted()
+ { m_timer1_stat.aggregate_counted(); }
+
+ inline void aggregate_value(ulonglong value)
+ { m_timer1_stat.aggregate_value(value); }
+
+ inline void aggregate(PFS_stage_stat *stat)
+ { m_timer1_stat.aggregate(& stat->m_timer1_stat); }
+};
+
+/**
+ Statistics for statement usage.
+ This structure uses lazy initialization,
+ controlled by member @c m_timer1_stat.m_count.
+*/
+struct PFS_statement_stat
+{
+ PFS_single_stat m_timer1_stat;
+ ulonglong m_error_count;
+ ulonglong m_warning_count;
+ ulonglong m_rows_affected;
+ ulonglong m_lock_time;
+ ulonglong m_rows_sent;
+ ulonglong m_rows_examined;
+ ulonglong m_created_tmp_disk_tables;
+ ulonglong m_created_tmp_tables;
+ ulonglong m_select_full_join;
+ ulonglong m_select_full_range_join;
+ ulonglong m_select_range;
+ ulonglong m_select_range_check;
+ ulonglong m_select_scan;
+ ulonglong m_sort_merge_passes;
+ ulonglong m_sort_range;
+ ulonglong m_sort_rows;
+ ulonglong m_sort_scan;
+ ulonglong m_no_index_used;
+ ulonglong m_no_good_index_used;
+
+ PFS_statement_stat()
+ {
+ reset();
+ }
+
+ inline void reset()
+ {
+ m_timer1_stat.m_count= 0;
+ }
+
+ inline void mark_used()
+ {
+ delayed_reset();
+ }
+
+private:
+ inline void delayed_reset(void)
+ {
+ if (m_timer1_stat.m_count == 0)
+ {
+ m_timer1_stat.reset();
+ m_error_count= 0;
+ m_warning_count= 0;
+ m_rows_affected= 0;
+ m_lock_time= 0;
+ m_rows_sent= 0;
+ m_rows_examined= 0;
+ m_created_tmp_disk_tables= 0;
+ m_created_tmp_tables= 0;
+ m_select_full_join= 0;
+ m_select_full_range_join= 0;
+ m_select_range= 0;
+ m_select_range_check= 0;
+ m_select_scan= 0;
+ m_sort_merge_passes= 0;
+ m_sort_range= 0;
+ m_sort_rows= 0;
+ m_sort_scan= 0;
+ m_no_index_used= 0;
+ m_no_good_index_used= 0;
+ }
+ }
+
+public:
+ inline void aggregate_counted()
+ {
+ delayed_reset();
+ m_timer1_stat.aggregate_counted();
+ }
+
+ inline void aggregate_value(ulonglong value)
+ {
+ delayed_reset();
+ m_timer1_stat.aggregate_value(value);
+ }
+
+ inline void aggregate(const PFS_statement_stat *stat)
+ {
+ if (stat->m_timer1_stat.m_count != 0)
+ {
+ delayed_reset();
+ m_timer1_stat.aggregate_no_check(& stat->m_timer1_stat);
+
+ m_error_count+= stat->m_error_count;
+ m_warning_count+= stat->m_warning_count;
+ m_rows_affected+= stat->m_rows_affected;
+ m_lock_time+= stat->m_lock_time;
+ m_rows_sent+= stat->m_rows_sent;
+ m_rows_examined+= stat->m_rows_examined;
+ m_created_tmp_disk_tables+= stat->m_created_tmp_disk_tables;
+ m_created_tmp_tables+= stat->m_created_tmp_tables;
+ m_select_full_join+= stat->m_select_full_join;
+ m_select_full_range_join+= stat->m_select_full_range_join;
+ m_select_range+= stat->m_select_range;
+ m_select_range_check+= stat->m_select_range_check;
+ m_select_scan+= stat->m_select_scan;
+ m_sort_merge_passes+= stat->m_sort_merge_passes;
+ m_sort_range+= stat->m_sort_range;
+ m_sort_rows+= stat->m_sort_rows;
+ m_sort_scan+= stat->m_sort_scan;
+ m_no_index_used+= stat->m_no_index_used;
+ m_no_good_index_used+= stat->m_no_good_index_used;
+ }
+ }
+};
+
+/** Statistics for transaction usage. */
+struct PFS_transaction_stat
+{
+ PFS_single_stat m_read_write_stat;
+ PFS_single_stat m_read_only_stat;
+
+ ulonglong m_savepoint_count;
+ ulonglong m_rollback_to_savepoint_count;
+ ulonglong m_release_savepoint_count;
+
+ PFS_transaction_stat()
+ {
+ m_savepoint_count= 0;
+ m_rollback_to_savepoint_count= 0;
+ m_release_savepoint_count= 0;
+ }
+
+ ulonglong count(void)
+ {
+ return (m_read_write_stat.m_count + m_read_only_stat.m_count);
+ }
+
+ inline void reset(void)
+ {
+ m_read_write_stat.reset();
+ m_read_only_stat.reset();
+ m_savepoint_count= 0;
+ m_rollback_to_savepoint_count= 0;
+ m_release_savepoint_count= 0;
+ }
+
+ inline void aggregate(const PFS_transaction_stat *stat)
+ {
+ m_read_write_stat.aggregate(&stat->m_read_write_stat);
+ m_read_only_stat.aggregate(&stat->m_read_only_stat);
+ m_savepoint_count+= stat->m_savepoint_count;
+ m_rollback_to_savepoint_count+= stat->m_rollback_to_savepoint_count;
+ m_release_savepoint_count+= stat->m_release_savepoint_count;
+ }
+};
+
+/** Single table io statistic. */
+struct PFS_table_io_stat
+{
+ bool m_has_data;
+ /** FETCH statistics */
+ PFS_single_stat m_fetch;
+ /** INSERT statistics */
+ PFS_single_stat m_insert;
+ /** UPDATE statistics */
+ PFS_single_stat m_update;
+ /** DELETE statistics */
+ PFS_single_stat m_delete;
+
+ PFS_table_io_stat()
+ {
+ m_has_data= false;
+ }
+
+ inline void reset(void)
+ {
+ m_has_data= false;
+ m_fetch.reset();
+ m_insert.reset();
+ m_update.reset();
+ m_delete.reset();
+ }
+
+ inline void aggregate(const PFS_table_io_stat *stat)
+ {
+ if (stat->m_has_data)
+ {
+ m_has_data= true;
+ m_fetch.aggregate(&stat->m_fetch);
+ m_insert.aggregate(&stat->m_insert);
+ m_update.aggregate(&stat->m_update);
+ m_delete.aggregate(&stat->m_delete);
+ }
+ }
+
+ inline void sum(PFS_single_stat *result)
+ {
+ if (m_has_data)
+ {
+ result->aggregate(& m_fetch);
+ result->aggregate(& m_insert);
+ result->aggregate(& m_update);
+ result->aggregate(& m_delete);
+ }
+ }
+};
+
+enum PFS_TL_LOCK_TYPE
+{
+ /* Locks from enum thr_lock */
+ PFS_TL_READ= 0,
+ PFS_TL_READ_WITH_SHARED_LOCKS= 1,
+ PFS_TL_READ_HIGH_PRIORITY= 2,
+ PFS_TL_READ_NO_INSERT= 3,
+ PFS_TL_WRITE_ALLOW_WRITE= 4,
+ PFS_TL_WRITE_CONCURRENT_INSERT= 5,
+ PFS_TL_WRITE_DELAYED= 6,
+ PFS_TL_WRITE_LOW_PRIORITY= 7,
+ PFS_TL_WRITE= 8,
+
+ /* Locks for handler::ha_external_lock() */
+ PFS_TL_READ_EXTERNAL= 9,
+ PFS_TL_WRITE_EXTERNAL= 10,
+
+ PFS_TL_NONE= 99
+};
+
+#define COUNT_PFS_TL_LOCK_TYPE 11
+
+/** Statistics for table locks. */
+struct PFS_table_lock_stat
+{
+ PFS_single_stat m_stat[COUNT_PFS_TL_LOCK_TYPE];
+
+ inline void reset(void)
+ {
+ PFS_single_stat *pfs= & m_stat[0];
+ PFS_single_stat *pfs_last= & m_stat[COUNT_PFS_TL_LOCK_TYPE];
+ for ( ; pfs < pfs_last ; pfs++)
+ pfs->reset();
+ }
+
+ inline void aggregate(const PFS_table_lock_stat *stat)
+ {
+ PFS_single_stat *pfs= & m_stat[0];
+ PFS_single_stat *pfs_last= & m_stat[COUNT_PFS_TL_LOCK_TYPE];
+ const PFS_single_stat *pfs_from= & stat->m_stat[0];
+ for ( ; pfs < pfs_last ; pfs++, pfs_from++)
+ pfs->aggregate(pfs_from);
+ }
+
+ inline void sum(PFS_single_stat *result)
+ {
+ PFS_single_stat *pfs= & m_stat[0];
+ PFS_single_stat *pfs_last= & m_stat[COUNT_PFS_TL_LOCK_TYPE];
+ for ( ; pfs < pfs_last ; pfs++)
+ result->aggregate(pfs);
+ }
+};
+
+/** Statistics for TABLE usage. */
+struct PFS_table_stat
+{
+ /**
+ Statistics, per index.
+ Each index stat is in [0, MAX_INDEXES-1],
+ stats when using no index are in [MAX_INDEXES].
+ */
+ PFS_table_io_stat m_index_stat[MAX_INDEXES + 1];
+
+ /**
+ Statistics, per lock type.
+ */
+ PFS_table_lock_stat m_lock_stat;
+
+ /** Reset table io statistic. */
+ inline void reset_io(void)
+ {
+ PFS_table_io_stat *stat= & m_index_stat[0];
+ PFS_table_io_stat *stat_last= & m_index_stat[MAX_INDEXES + 1];
+ for ( ; stat < stat_last ; stat++)
+ stat->reset();
+ }
+
+ /** Reset table lock statistic. */
+ inline void reset_lock(void)
+ {
+ m_lock_stat.reset();
+ }
+
+ /** Reset table statistic. */
+ inline void reset(void)
+ {
+ reset_io();
+ reset_lock();
+ }
+
+ inline void fast_reset_io(void)
+ {
+ memcpy(& m_index_stat, & g_reset_template.m_index_stat, sizeof(m_index_stat));
+ }
+
+ inline void fast_reset_lock(void)
+ {
+ memcpy(& m_lock_stat, & g_reset_template.m_lock_stat, sizeof(m_lock_stat));
+ }
+
+ inline void fast_reset(void)
+ {
+ memcpy(this, & g_reset_template, sizeof(*this));
+ }
+
+ inline void aggregate_io(const PFS_table_stat *stat, uint key_count)
+ {
+ PFS_table_io_stat *to_stat;
+ PFS_table_io_stat *to_stat_last;
+ const PFS_table_io_stat *from_stat;
+
+ DBUG_ASSERT(key_count <= MAX_INDEXES);
+
+ /* Aggregate stats for each index, if any */
+ to_stat= & m_index_stat[0];
+ to_stat_last= to_stat + key_count;
+ from_stat= & stat->m_index_stat[0];
+ for ( ; to_stat < to_stat_last ; from_stat++, to_stat++)
+ to_stat->aggregate(from_stat);
+
+ /* Aggregate stats for the table */
+ to_stat= & m_index_stat[MAX_INDEXES];
+ from_stat= & stat->m_index_stat[MAX_INDEXES];
+ to_stat->aggregate(from_stat);
+ }
+
+ inline void aggregate_lock(const PFS_table_stat *stat)
+ {
+ m_lock_stat.aggregate(& stat->m_lock_stat);
+ }
+
+ inline void aggregate(const PFS_table_stat *stat, uint key_count)
+ {
+ aggregate_io(stat, key_count);
+ aggregate_lock(stat);
+ }
+
+ inline void sum_io(PFS_single_stat *result, uint key_count)
+ {
+ PFS_table_io_stat *stat;
+ PFS_table_io_stat *stat_last;
+
+ DBUG_ASSERT(key_count <= MAX_INDEXES);
+
+ /* Sum stats for each index, if any */
+ stat= & m_index_stat[0];
+ stat_last= stat + key_count;
+ for ( ; stat < stat_last ; stat++)
+ stat->sum(result);
+
+ /* Sum stats for the table */
+ m_index_stat[MAX_INDEXES].sum(result);
+ }
+
+ inline void sum_lock(PFS_single_stat *result)
+ {
+ m_lock_stat.sum(result);
+ }
+
+ inline void sum(PFS_single_stat *result, uint key_count)
+ {
+ sum_io(result, key_count);
+ sum_lock(result);
+ }
+
+ static struct PFS_table_stat g_reset_template;
+};
+
+/** Statistics for SOCKET IO. Used for both waits and byte counts. */
+struct PFS_socket_io_stat
+{
+ /** READ statistics */
+ PFS_byte_stat m_read;
+ /** WRITE statistics */
+ PFS_byte_stat m_write;
+ /** Miscellaneous statistics */
+ PFS_byte_stat m_misc;
+
+ inline void reset(void)
+ {
+ m_read.reset();
+ m_write.reset();
+ m_misc.reset();
+ }
+
+ inline void aggregate(const PFS_socket_io_stat *stat)
+ {
+ m_read.aggregate(&stat->m_read);
+ m_write.aggregate(&stat->m_write);
+ m_misc.aggregate(&stat->m_misc);
+ }
+
+ /* Sum waits and byte counts */
+ inline void sum(PFS_byte_stat *stat)
+ {
+ stat->aggregate(&m_read);
+ stat->aggregate(&m_write);
+ stat->aggregate(&m_misc);
+ }
+
+ /* Sum waits only */
+ inline void sum_waits(PFS_single_stat *stat)
+ {
+ stat->aggregate(&m_read);
+ stat->aggregate(&m_write);
+ stat->aggregate(&m_misc);
+ }
+};
+
+/** Statistics for SOCKET usage. */
+struct PFS_socket_stat
+{
+ /** Socket timing and byte count statistics per operation */
+ PFS_socket_io_stat m_io_stat;
+
+ /** Reset socket statistics. */
+ inline void reset(void)
+ {
+ m_io_stat.reset();
+ }
+};
+
+struct PFS_memory_stat_delta
+{
+ size_t m_alloc_count_delta;
+ size_t m_free_count_delta;
+ size_t m_alloc_size_delta;
+ size_t m_free_size_delta;
+
+ void reset()
+ {
+ m_alloc_count_delta= 0;
+ m_free_count_delta= 0;
+ m_alloc_size_delta= 0;
+ m_free_size_delta= 0;
+ }
+};
+
+/**
+ Memory statistics.
+ Conceptually, the following statistics are maintained:
+ - CURRENT_COUNT_USED,
+ - LOW_COUNT_USED,
+ - HIGH_COUNT_USED
+ - CURRENT_SIZE_USED,
+ - LOW_SIZE_USED,
+ - HIGH_SIZE_USED
+ Now, the implementation keeps different counters,
+ which are easier (less overhead) to maintain while
+ collecting statistics.
+ Invariants are as follows:
+ CURRENT_COUNT_USED = @c m_alloc_count - @c m_free_count
+ LOW_COUNT_USED + @c m_free_count_capacity = CURRENT_COUNT_USED
+ CURRENT_COUNT_USED + @c m_alloc_count_capacity = HIGH_COUNT_USED
+ CURRENT_SIZE_USED = @c m_alloc_size - @c m_free_size
+ LOW_SIZE_USED + @c m_free_size_capacity = CURRENT_SIZE_USED
+ CURRENT_SIZE_USED + @c m_alloc_size_capacity = HIGH_SIZE_USED
+
+*/
+struct PFS_memory_stat
+{
+ bool m_used;
+ size_t m_alloc_count;
+ size_t m_free_count;
+ size_t m_alloc_size;
+ size_t m_free_size;
+
+ size_t m_alloc_count_capacity;
+ size_t m_free_count_capacity;
+ size_t m_alloc_size_capacity;
+ size_t m_free_size_capacity;
+
+ inline void reset(void)
+ {
+ m_used= false;
+ m_alloc_count= 0;
+ m_free_count= 0;
+ m_alloc_size= 0;
+ m_free_size= 0;
+
+ m_alloc_count_capacity= 0;
+ m_free_count_capacity= 0;
+ m_alloc_size_capacity= 0;
+ m_free_size_capacity= 0;
+ }
+
+ inline void rebase(void)
+ {
+ if (! m_used)
+ return;
+
+ size_t base;
+
+ base= std::min<size_t>(m_alloc_count, m_free_count);
+ m_alloc_count-= base;
+ m_free_count-= base;
+
+ base= std::min<size_t>(m_alloc_size, m_free_size);
+ m_alloc_size-= base;
+ m_free_size-= base;
+
+ m_alloc_count_capacity= 0;
+ m_free_count_capacity= 0;
+ m_alloc_size_capacity= 0;
+ m_free_size_capacity= 0;
+ }
+
+ inline void partial_aggregate_to(PFS_memory_stat *stat)
+ {
+ if (! m_used)
+ return;
+
+ size_t base;
+
+ stat->m_used= true;
+
+ base= std::min<size_t>(m_alloc_count, m_free_count);
+ if (base != 0)
+ {
+ stat->m_alloc_count+= base;
+ stat->m_free_count+= base;
+ m_alloc_count-= base;
+ m_free_count-= base;
+ }
+
+ base= std::min<size_t>(m_alloc_size, m_free_size);
+ if (base != 0)
+ {
+ stat->m_alloc_size+= base;
+ stat->m_free_size+= base;
+ m_alloc_size-= base;
+ m_free_size-= base;
+ }
+
+ stat->m_alloc_count_capacity+= m_alloc_count_capacity;
+ stat->m_free_count_capacity+= m_free_count_capacity;
+ stat->m_alloc_size_capacity+= m_alloc_size_capacity;
+ stat->m_free_size_capacity+= m_free_size_capacity;
+
+ m_alloc_count_capacity= 0;
+ m_free_count_capacity= 0;
+ m_alloc_size_capacity= 0;
+ m_free_size_capacity= 0;
+ }
+
+ inline void full_aggregate_to(PFS_memory_stat *stat) const
+ {
+ if (! m_used)
+ return;
+
+ stat->m_used= true;
+
+ stat->m_alloc_count+= m_alloc_count;
+ stat->m_free_count+= m_free_count;
+ stat->m_alloc_size+= m_alloc_size;
+ stat->m_free_size+= m_free_size;
+
+ stat->m_alloc_count_capacity+= m_alloc_count_capacity;
+ stat->m_free_count_capacity+= m_free_count_capacity;
+ stat->m_alloc_size_capacity+= m_alloc_size_capacity;
+ stat->m_free_size_capacity+= m_free_size_capacity;
+ }
+
+ inline void partial_aggregate_to(PFS_memory_stat *stat1, PFS_memory_stat *stat2)
+ {
+ if (! m_used)
+ return;
+
+ size_t base;
+
+ stat1->m_used= true;
+ stat2->m_used= true;
+
+ base= std::min<size_t>(m_alloc_count, m_free_count);
+ if (base != 0)
+ {
+ stat1->m_alloc_count+= base;
+ stat2->m_alloc_count+= base;
+ stat1->m_free_count+= base;
+ stat2->m_free_count+= base;
+ m_alloc_count-= base;
+ m_free_count-= base;
+ }
+
+ base= std::min<size_t>(m_alloc_size, m_free_size);
+ if (base != 0)
+ {
+ stat1->m_alloc_size+= base;
+ stat2->m_alloc_size+= base;
+ stat1->m_free_size+= base;
+ stat2->m_free_size+= base;
+ m_alloc_size-= base;
+ m_free_size-= base;
+ }
+
+ stat1->m_alloc_count_capacity+= m_alloc_count_capacity;
+ stat2->m_alloc_count_capacity+= m_alloc_count_capacity;
+ stat1->m_free_count_capacity+= m_free_count_capacity;
+ stat2->m_free_count_capacity+= m_free_count_capacity;
+ stat1->m_alloc_size_capacity+= m_alloc_size_capacity;
+ stat2->m_alloc_size_capacity+= m_alloc_size_capacity;
+ stat1->m_free_size_capacity+= m_free_size_capacity;
+ stat2->m_free_size_capacity+= m_free_size_capacity;
+
+ m_alloc_count_capacity= 0;
+ m_free_count_capacity= 0;
+ m_alloc_size_capacity= 0;
+ m_free_size_capacity= 0;
+ }
+
+ inline void full_aggregate_to(PFS_memory_stat *stat1, PFS_memory_stat *stat2) const
+ {
+ if (! m_used)
+ return;
+
+ stat1->m_used= true;
+ stat2->m_used= true;
+
+ stat1->m_alloc_count+= m_alloc_count;
+ stat2->m_alloc_count+= m_alloc_count;
+ stat1->m_free_count+= m_free_count;
+ stat2->m_free_count+= m_free_count;
+ stat1->m_alloc_size+= m_alloc_size;
+ stat2->m_alloc_size+= m_alloc_size;
+ stat1->m_free_size+= m_free_size;
+ stat2->m_free_size+= m_free_size;
+
+ stat1->m_alloc_count_capacity+= m_alloc_count_capacity;
+ stat2->m_alloc_count_capacity+= m_alloc_count_capacity;
+ stat1->m_free_count_capacity+= m_free_count_capacity;
+ stat2->m_free_count_capacity+= m_free_count_capacity;
+ stat1->m_alloc_size_capacity+= m_alloc_size_capacity;
+ stat2->m_alloc_size_capacity+= m_alloc_size_capacity;
+ stat1->m_free_size_capacity+= m_free_size_capacity;
+ stat2->m_free_size_capacity+= m_free_size_capacity;
+ }
+
+ void count_builtin_alloc(size_t size)
+ {
+ m_used= true;
+
+ m_alloc_count++;
+ m_free_count_capacity++;
+ m_alloc_size+= size;
+ m_free_size_capacity+= size;
+
+ if (m_alloc_count_capacity >= 1)
+ {
+ m_alloc_count_capacity--;
+ }
+
+ if (m_alloc_size_capacity >= size)
+ {
+ m_alloc_size_capacity-= size;
+ }
+
+ return;
+ }
+
+ void count_builtin_free(size_t size)
+ {
+ m_used= true;
+
+ m_free_count++;
+ m_alloc_count_capacity++;
+ m_free_size+= size;
+ m_alloc_size_capacity+= size;
+
+ if (m_free_count_capacity >= 1)
+ {
+ m_free_count_capacity--;
+ }
+
+ if (m_free_size_capacity >= size)
+ {
+ m_free_size_capacity-= size;
+ }
+
+ return;
+ }
+
+ inline PFS_memory_stat_delta *count_alloc(size_t size,
+ PFS_memory_stat_delta *delta)
+ {
+ m_used= true;
+
+ m_alloc_count++;
+ m_free_count_capacity++;
+ m_alloc_size+= size;
+ m_free_size_capacity+= size;
+
+ if ((m_alloc_count_capacity >= 1) &&
+ (m_alloc_size_capacity >= size))
+ {
+ m_alloc_count_capacity--;
+ m_alloc_size_capacity-= size;
+ return NULL;
+ }
+
+ delta->reset();
+
+ if (m_alloc_count_capacity >= 1)
+ {
+ m_alloc_count_capacity--;
+ }
+ else
+ {
+ delta->m_alloc_count_delta= 1;
+ }
+
+ if (m_alloc_size_capacity >= size)
+ {
+ m_alloc_size_capacity-= size;
+ }
+ else
+ {
+ delta->m_alloc_size_delta= size - m_alloc_size_capacity;
+ m_alloc_size_capacity= 0;
+ }
+
+ return delta;
+ }
+
+ inline PFS_memory_stat_delta *count_realloc(size_t old_size, size_t new_size,
+ PFS_memory_stat_delta *delta)
+ {
+ m_used= true;
+
+ size_t size_delta= new_size - old_size;
+ m_alloc_count++;
+ m_alloc_size+= new_size;
+ m_free_count++;
+ m_free_size+= old_size;
+
+ if (new_size == old_size)
+ {
+ return NULL;
+ }
+
+ if (new_size > old_size)
+ {
+ /* Growing */
+ size_delta= new_size - old_size;
+ m_free_size_capacity+= size_delta;
+
+ if (m_alloc_size_capacity >= size_delta)
+ {
+ m_alloc_size_capacity-= size_delta;
+ return NULL;
+ }
+
+ delta->reset();
+ delta->m_alloc_size_delta= size_delta - m_alloc_size_capacity;
+ m_alloc_size_capacity= 0;
+ }
+ else
+ {
+ /* Shrinking */
+ size_delta= old_size - new_size;
+ m_alloc_size_capacity+= size_delta;
+
+ if (m_free_size_capacity >= size_delta)
+ {
+ m_free_size_capacity-= size_delta;
+ return NULL;
+ }
+
+ delta->reset();
+ delta->m_free_size_delta= size_delta - m_free_size_capacity;
+ m_free_size_capacity= 0;
+ }
+
+ return delta;
+ }
+
+ inline PFS_memory_stat_delta *count_free(size_t size, PFS_memory_stat_delta *delta)
+ {
+ m_used= true;
+
+ m_free_count++;
+ m_alloc_count_capacity++;
+ m_free_size+= size;
+ m_alloc_size_capacity+= size;
+
+ if ((m_free_count_capacity >= 1) &&
+ (m_free_size_capacity >= size))
+ {
+ m_free_count_capacity--;
+ m_free_size_capacity-= size;
+ return NULL;
+ }
+
+ delta->reset();
+
+ if (m_free_count_capacity >= 1)
+ {
+ m_free_count_capacity--;
+ }
+ else
+ {
+ delta->m_free_count_delta= 1;
+ }
+
+ if (m_free_size_capacity >= size)
+ {
+ m_free_size_capacity-= size;
+ }
+ else
+ {
+ delta->m_free_size_delta= size - m_free_size_capacity;
+ m_free_size_capacity= 0;
+ }
+
+ return delta;
+ }
+
+ inline PFS_memory_stat_delta *apply_delta(const PFS_memory_stat_delta *delta,
+ PFS_memory_stat_delta *delta_buffer)
+ {
+ size_t val;
+ size_t remaining_alloc_count;
+ size_t remaining_alloc_size;
+ size_t remaining_free_count;
+ size_t remaining_free_size;
+ bool has_remaining= false;
+
+ m_used= true;
+
+ val= delta->m_alloc_count_delta;
+ if (val <= m_alloc_count_capacity)
+ {
+ m_alloc_count_capacity-= val;
+ remaining_alloc_count= 0;
+ }
+ else
+ {
+ remaining_alloc_count= val - m_alloc_count_capacity;
+ m_alloc_count_capacity= 0;
+ has_remaining= true;
+ }
+
+ val= delta->m_alloc_size_delta;
+ if (val <= m_alloc_size_capacity)
+ {
+ m_alloc_size_capacity-= val;
+ remaining_alloc_size= 0;
+ }
+ else
+ {
+ remaining_alloc_size= val - m_alloc_size_capacity;
+ m_alloc_size_capacity= 0;
+ has_remaining= true;
+ }
+
+ val= delta->m_free_count_delta;
+ if (val <= m_free_count_capacity)
+ {
+ m_free_count_capacity-= val;
+ remaining_free_count= 0;
+ }
+ else
+ {
+ remaining_free_count= val - m_free_count_capacity;
+ m_free_count_capacity= 0;
+ has_remaining= true;
+ }
+
+ val= delta->m_free_size_delta;
+ if (val <= m_free_size_capacity)
+ {
+ m_free_size_capacity-= val;
+ remaining_free_size= 0;
+ }
+ else
+ {
+ remaining_free_size= val - m_free_size_capacity;
+ m_free_size_capacity= 0;
+ has_remaining= true;
+ }
+
+ if (! has_remaining)
+ return NULL;
+
+ delta_buffer->m_alloc_count_delta= remaining_alloc_count;
+ delta_buffer->m_alloc_size_delta= remaining_alloc_size;
+ delta_buffer->m_free_count_delta= remaining_free_count;
+ delta_buffer->m_free_size_delta= remaining_free_size;
+ return delta_buffer;
+ }
+};
+
+#define PFS_MEMORY_STAT_INITIALIZER { false, 0, 0, 0, 0, 0, 0, 0, 0}
+
+/** Connections statistics. */
+struct PFS_connection_stat
+{
+ PFS_connection_stat()
+ : m_current_connections(0),
+ m_total_connections(0)
+ {}
+
+ ulonglong m_current_connections;
+ ulonglong m_total_connections;
+
+ inline void aggregate_active(ulonglong active)
+ {
+ m_current_connections+= active;
+ m_total_connections+= active;
+ }
+
+ inline void aggregate_disconnected(ulonglong disconnected)
+ {
+ m_total_connections+= disconnected;
+ }
+};
+
+/** @} */
+#endif
+
diff --git a/storage/perfschema/pfs_status.cc b/storage/perfschema/pfs_status.cc
new file mode 100644
index 00000000..2007d191
--- /dev/null
+++ b/storage/perfschema/pfs_status.cc
@@ -0,0 +1,166 @@
+/* Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/pfs_status.cc
+ Status variables statistics (implementation).
+*/
+
+#include "my_global.h"
+#include "my_sys.h"
+#include "pfs_global.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "pfs_account.h"
+#include "pfs_host.h"
+#include "pfs_user.h"
+#include "pfs_status.h"
+#include "pfs_atomic.h"
+#include "pfs_buffer_container.h"
+
+#include "sql_show.h" /* reset_status_vars */
+
+PFS_status_stats::PFS_status_stats()
+{
+ reset();
+}
+
+void PFS_status_stats::reset()
+{
+ m_has_stats= false;
+ memset(&m_stats, 0, sizeof(m_stats));
+}
+
+void PFS_status_stats::aggregate(const PFS_status_stats *from)
+{
+ if (from->m_has_stats)
+ {
+ m_has_stats= true;
+ for (int i= 0; i < COUNT_GLOBAL_STATUS_VARS; i++)
+ {
+ m_stats[i] += from->m_stats[i];
+ }
+ }
+}
+
+void PFS_status_stats::aggregate_from(const STATUS_VAR *from)
+{
+ ulong *from_var= (ulong*) from;
+
+ m_has_stats= true;
+ for (int i= 0;
+ i < COUNT_GLOBAL_STATUS_VARS;
+ i++, from_var++)
+ {
+ m_stats[i] += *from_var;
+ }
+}
+
+void PFS_status_stats::aggregate_to(STATUS_VAR *to)
+{
+ if (m_has_stats)
+ {
+ ulong *to_var= (ulong*) to;
+
+ for (int i= 0;
+ i < COUNT_GLOBAL_STATUS_VARS;
+ i++, to_var++)
+ {
+ *to_var += m_stats[i];
+ }
+ }
+}
+
+static void fct_reset_status_by_thread(PFS_thread *thread)
+{
+ PFS_account *account;
+ PFS_user *user;
+ PFS_host *host;
+
+ if (thread->m_lock.is_populated())
+ {
+ account= sanitize_account(thread->m_account);
+ user= sanitize_user(thread->m_user);
+ host= sanitize_host(thread->m_host);
+ aggregate_thread_status(thread, account, user, host);
+ }
+}
+
+/** Reset table STATUS_BY_THREAD data. */
+void reset_status_by_thread()
+{
+ global_thread_container.apply_all(fct_reset_status_by_thread);
+}
+
+static void fct_reset_status_by_account(PFS_account *account)
+{
+ PFS_user *user;
+ PFS_host *host;
+
+ if (account->m_lock.is_populated())
+ {
+ user= sanitize_user(account->m_user);
+ host= sanitize_host(account->m_host);
+ account->aggregate_status(user, host);
+ }
+}
+
+/** Reset table STATUS_BY_ACCOUNT data. */
+void reset_status_by_account()
+{
+ global_account_container.apply_all(fct_reset_status_by_account);
+}
+
+static void fct_reset_status_by_user(PFS_user *user)
+{
+ if (user->m_lock.is_populated())
+ user->aggregate_status();
+}
+
+/** Reset table STATUS_BY_USER data. */
+void reset_status_by_user()
+{
+ global_user_container.apply_all(fct_reset_status_by_user);
+}
+
+static void fct_reset_status_by_host(PFS_host *host)
+{
+ if (host->m_lock.is_populated())
+ host->aggregate_status();
+}
+
+/** Reset table STATUS_BY_HOST data. */
+void reset_status_by_host()
+{
+ global_host_container.apply_all(fct_reset_status_by_host);
+}
+
+/** Reset table GLOBAL_STATUS data. */
+void reset_global_status()
+{
+ /*
+ Do not memset global_status_var,
+ NO_FLUSH counters need to be preserved
+ */
+ reset_status_vars();
+}
+
diff --git a/storage/perfschema/pfs_status.h b/storage/perfschema/pfs_status.h
new file mode 100644
index 00000000..6b35a162
--- /dev/null
+++ b/storage/perfschema/pfs_status.h
@@ -0,0 +1,51 @@
+/* Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
+
+#ifndef PFS_STATUS_H
+#define PFS_STATUS_H
+
+/**
+ @file storage/perfschema/pfs_status.h
+ Status variables statistics (declarations).
+*/
+
+struct PFS_status_stats
+{
+ PFS_status_stats();
+
+ void reset();
+ void aggregate(const PFS_status_stats *from);
+ void aggregate_from(const STATUS_VAR *from);
+ void aggregate_to(STATUS_VAR *to);
+
+ bool m_has_stats;
+ ulong m_stats[COUNT_GLOBAL_STATUS_VARS];
+};
+
+void reset_status_by_thread();
+void reset_status_by_account();
+void reset_status_by_user();
+void reset_status_by_host();
+void reset_global_status();
+
+#endif
+
diff --git a/storage/perfschema/pfs_timer.cc b/storage/perfschema/pfs_timer.cc
new file mode 100644
index 00000000..ceec4ed9
--- /dev/null
+++ b/storage/perfschema/pfs_timer.cc
@@ -0,0 +1,345 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/pfs_timer.cc
+ Performance schema timers (implementation).
+*/
+
+#include "my_global.h"
+#include "pfs_timer.h"
+#include "my_rdtsc.h"
+
+enum_timer_name idle_timer= TIMER_NAME_MICROSEC;
+enum_timer_name wait_timer= TIMER_NAME_CYCLE;
+enum_timer_name stage_timer= TIMER_NAME_NANOSEC;
+enum_timer_name statement_timer= TIMER_NAME_NANOSEC;
+enum_timer_name transaction_timer= TIMER_NAME_NANOSEC;
+
+static ulonglong cycle_v0;
+static ulonglong nanosec_v0;
+static ulonglong microsec_v0;
+static ulonglong millisec_v0;
+static ulonglong tick_v0;
+
+static ulong cycle_to_pico; /* 1000 at 1 GHz, 333 at 3GHz, 250 at 4GHz */
+static ulong nanosec_to_pico; /* In theory, 1 000 */
+static ulong microsec_to_pico; /* In theory, 1 000 000 */
+static ulong millisec_to_pico; /* In theory, 1 000 000 000, fits in uint32 */
+static ulonglong tick_to_pico; /* 1e10 at 100 Hz, 1.666e10 at 60 Hz */
+
+/* Indexed by enum enum_timer_name */
+static struct time_normalizer to_pico_data[FIRST_TIMER_NAME + COUNT_TIMER_NAME]=
+{
+ { 0, 0}, /* unused */
+ { 0, 0}, /* cycle */
+ { 0, 0}, /* nanosec */
+ { 0, 0}, /* microsec */
+ { 0, 0}, /* millisec */
+ { 0, 0} /* tick */
+};
+
+static inline ulong round_to_ulong(double value)
+{
+ return (ulong) (value + 0.5);
+}
+
+static inline ulonglong round_to_ulonglong(double value)
+{
+ return (ulonglong) (value + 0.5);
+}
+
+void init_timers(void)
+{
+ double pico_frequency= 1.0e12;
+
+ cycle_v0= my_timer_cycles();
+ nanosec_v0= my_timer_nanoseconds();
+ microsec_v0= my_timer_microseconds();
+ millisec_v0= my_timer_milliseconds();
+ tick_v0= my_timer_ticks();
+
+ if (sys_timer_info.cycles.frequency > 0)
+ cycle_to_pico= round_to_ulong(pico_frequency/
+ (double)sys_timer_info.cycles.frequency);
+ else
+ cycle_to_pico= 0;
+
+ if (sys_timer_info.nanoseconds.frequency > 0)
+ nanosec_to_pico= round_to_ulong(pico_frequency/
+ (double)sys_timer_info.nanoseconds.frequency);
+ else
+ nanosec_to_pico= 0;
+
+ if (sys_timer_info.microseconds.frequency > 0)
+ microsec_to_pico= round_to_ulong(pico_frequency/
+ (double)sys_timer_info.microseconds.frequency);
+ else
+ microsec_to_pico= 0;
+
+ if (sys_timer_info.milliseconds.frequency > 0)
+ millisec_to_pico= round_to_ulong(pico_frequency/
+ (double)sys_timer_info.milliseconds.frequency);
+ else
+ millisec_to_pico= 0;
+
+ if (sys_timer_info.ticks.frequency > 0)
+ tick_to_pico= round_to_ulonglong(pico_frequency/
+ (double)sys_timer_info.ticks.frequency);
+ else
+ tick_to_pico= 0;
+
+ to_pico_data[TIMER_NAME_CYCLE].m_v0= cycle_v0;
+ to_pico_data[TIMER_NAME_CYCLE].m_factor= cycle_to_pico;
+
+ to_pico_data[TIMER_NAME_NANOSEC].m_v0= nanosec_v0;
+ to_pico_data[TIMER_NAME_NANOSEC].m_factor= nanosec_to_pico;
+
+ to_pico_data[TIMER_NAME_MICROSEC].m_v0= microsec_v0;
+ to_pico_data[TIMER_NAME_MICROSEC].m_factor= microsec_to_pico;
+
+ to_pico_data[TIMER_NAME_MILLISEC].m_v0= millisec_v0;
+ to_pico_data[TIMER_NAME_MILLISEC].m_factor= millisec_to_pico;
+
+ to_pico_data[TIMER_NAME_TICK].m_v0= tick_v0;
+ to_pico_data[TIMER_NAME_TICK].m_factor= tick_to_pico;
+
+ /*
+ Depending on the platform and build options,
+ some timers may not be available.
+ Pick best replacements.
+ */
+
+ /*
+ For WAIT, the cycle timer is used by default. However, it is not available
+ on all architectures. Fall back to the nanosecond timer in this case. It is
+ unlikely that neither cycle nor nanosecond are available, but we continue
+ probing less resolution timers anyway for consistency with other events.
+ */
+
+ if (cycle_to_pico != 0)
+ {
+ /* Normal case. */
+ wait_timer= TIMER_NAME_CYCLE;
+ }
+ else if (nanosec_to_pico != 0)
+ {
+ /* Robustness, no known cases. */
+ wait_timer= TIMER_NAME_NANOSEC;
+ }
+ else if (microsec_to_pico != 0)
+ {
+ /* Robustness, no known cases. */
+ wait_timer= TIMER_NAME_MICROSEC;
+ }
+ else if (millisec_to_pico != 0)
+ {
+ /* Robustness, no known cases. */
+ wait_timer= TIMER_NAME_MILLISEC;
+ }
+ else
+ {
+ /*
+ Will never be reached on any architecture, but must provide a default if
+ no other timers are available.
+ */
+ wait_timer= TIMER_NAME_TICK;
+ }
+
+ /*
+ For STAGE and STATEMENT, a timer with a fixed frequency is better.
+ The prefered timer is nanosecond, or lower resolutions.
+ */
+
+ if (nanosec_to_pico != 0)
+ {
+ /* Normal case. */
+ stage_timer= TIMER_NAME_NANOSEC;
+ statement_timer= TIMER_NAME_NANOSEC;
+ transaction_timer= TIMER_NAME_NANOSEC;
+ }
+ else if (microsec_to_pico != 0)
+ {
+ /* Windows. */
+ stage_timer= TIMER_NAME_MICROSEC;
+ statement_timer= TIMER_NAME_MICROSEC;
+ transaction_timer= TIMER_NAME_MICROSEC;
+ }
+ else if (millisec_to_pico != 0)
+ {
+ /* Robustness, no known cases. */
+ stage_timer= TIMER_NAME_MILLISEC;
+ statement_timer= TIMER_NAME_MILLISEC;
+ transaction_timer= TIMER_NAME_MILLISEC;
+ }
+ else if (tick_to_pico != 0)
+ {
+ /* Robustness, no known cases. */
+ stage_timer= TIMER_NAME_TICK;
+ statement_timer= TIMER_NAME_TICK;
+ transaction_timer= TIMER_NAME_TICK;
+ }
+ else
+ {
+ /* Robustness, no known cases. */
+ stage_timer= TIMER_NAME_CYCLE;
+ statement_timer= TIMER_NAME_CYCLE;
+ transaction_timer= TIMER_NAME_CYCLE;
+ }
+
+ /*
+ For IDLE, a timer with a fixed frequency is critical,
+ as the CPU clock may slow down a lot if the server is completely idle.
+ The prefered timer is microsecond, or lower resolutions.
+ */
+
+ if (microsec_to_pico != 0)
+ {
+ /* Normal case. */
+ idle_timer= TIMER_NAME_MICROSEC;
+ }
+ else if (millisec_to_pico != 0)
+ {
+ /* Robustness, no known cases. */
+ wait_timer= TIMER_NAME_MILLISEC;
+ }
+ else if (tick_to_pico != 0)
+ {
+ /* Robustness, no known cases. */
+ idle_timer= TIMER_NAME_TICK;
+ }
+ else
+ {
+ /* Robustness, no known cases. */
+ idle_timer= TIMER_NAME_CYCLE;
+ }
+}
+
+ulonglong get_timer_raw_value(enum_timer_name timer_name)
+{
+ switch (timer_name)
+ {
+ case TIMER_NAME_CYCLE:
+ return my_timer_cycles();
+ case TIMER_NAME_NANOSEC:
+ return my_timer_nanoseconds();
+ case TIMER_NAME_MICROSEC:
+ return my_timer_microseconds();
+ case TIMER_NAME_MILLISEC:
+ return my_timer_milliseconds();
+ case TIMER_NAME_TICK:
+ return my_timer_ticks();
+ default:
+ DBUG_ASSERT(false);
+ }
+ return 0;
+}
+
+ulonglong get_timer_raw_value_and_function(enum_timer_name timer_name, timer_fct_t *fct)
+{
+ switch (timer_name)
+ {
+ case TIMER_NAME_CYCLE:
+ *fct= my_timer_cycles;
+ return my_timer_cycles();
+ case TIMER_NAME_NANOSEC:
+ *fct= my_timer_nanoseconds;
+ return my_timer_nanoseconds();
+ case TIMER_NAME_MICROSEC:
+ *fct= my_timer_microseconds;
+ return my_timer_microseconds();
+ case TIMER_NAME_MILLISEC:
+ *fct= my_timer_milliseconds;
+ return my_timer_milliseconds();
+ case TIMER_NAME_TICK:
+ *fct= my_timer_ticks;
+ return my_timer_ticks();
+ default:
+ *fct= NULL;
+ DBUG_ASSERT(false);
+ }
+ return 0;
+}
+
+ulonglong get_timer_pico_value(enum_timer_name timer_name)
+{
+ ulonglong result;
+
+ switch (timer_name)
+ {
+ case TIMER_NAME_CYCLE:
+ result= (my_timer_cycles() - cycle_v0) * cycle_to_pico;
+ break;
+ case TIMER_NAME_NANOSEC:
+ result= (my_timer_nanoseconds() - nanosec_v0) * nanosec_to_pico;
+ break;
+ case TIMER_NAME_MICROSEC:
+ result= (my_timer_microseconds() - microsec_v0) * microsec_to_pico;
+ break;
+ case TIMER_NAME_MILLISEC:
+ result= (my_timer_milliseconds() - millisec_v0) * millisec_to_pico;
+ break;
+ case TIMER_NAME_TICK:
+ result= (my_timer_ticks() - tick_v0) * tick_to_pico;
+ break;
+ default:
+ result= 0;
+ DBUG_ASSERT(false);
+ }
+ return result;
+}
+
+time_normalizer* time_normalizer::get(enum_timer_name timer_name)
+{
+ uint index= static_cast<uint> (timer_name);
+
+ DBUG_ASSERT(index >= FIRST_TIMER_NAME);
+ DBUG_ASSERT(index <= LAST_TIMER_NAME);
+
+ return & to_pico_data[index];
+}
+
+void time_normalizer::to_pico(ulonglong start, ulonglong end,
+ ulonglong *pico_start, ulonglong *pico_end, ulonglong *pico_wait)
+{
+ if (start == 0)
+ {
+ *pico_start= 0;
+ *pico_end= 0;
+ *pico_wait= 0;
+ }
+ else
+ {
+ *pico_start= (start - m_v0) * m_factor;
+ if (end == 0)
+ {
+ *pico_end= 0;
+ *pico_wait= 0;
+ }
+ else
+ {
+ *pico_end= (end - m_v0) * m_factor;
+ *pico_wait= (end - start) * m_factor;
+ }
+ }
+}
+
diff --git a/storage/perfschema/pfs_timer.h b/storage/perfschema/pfs_timer.h
new file mode 100644
index 00000000..f2bedc87
--- /dev/null
+++ b/storage/perfschema/pfs_timer.h
@@ -0,0 +1,152 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef PFS_TIMER_H
+#define PFS_TIMER_H
+
+/**
+ @file storage/perfschema/pfs_timer.h
+ Performance schema timers (declarations).
+*/
+#include <my_rdtsc.h>
+#include "pfs_column_types.h"
+
+/** Conversion factor, from micro seconds to pico seconds. */
+#define MICROSEC_TO_PICOSEC 1000000
+
+/**
+ A time normalizer.
+ A time normalizer consist of a transformation that
+ converts raw timer values (expressed in the timer unit)
+ to normalized values, expressed in picoseconds.
+*/
+struct time_normalizer
+{
+ /**
+ Get a time normalizer for a given timer.
+ @param timer_name the timer name
+ @return the normalizer for the timer
+ */
+ static time_normalizer* get(enum_timer_name timer_name);
+
+ /** Timer value at server statup. */
+ ulonglong m_v0;
+ /** Conversion factor from timer values to pico seconds. */
+ ulonglong m_factor;
+
+ /**
+ Convert a wait from timer units to pico seconds.
+ @param wait a wait, expressed in timer units
+ @return the wait, expressed in pico seconds
+ */
+ inline ulonglong wait_to_pico(ulonglong wait)
+ {
+ return wait * m_factor;
+ }
+
+ /**
+ Convert a time from timer units to pico seconds.
+ @param t a time, expressed in timer units
+ @return the time, expressed in pico seconds
+ */
+ inline ulonglong time_to_pico(ulonglong t)
+ {
+ return (t == 0 ? 0 : (t - m_v0) * m_factor);
+ }
+
+ /**
+ Convert start / end times from timer units to pico seconds.
+ @param start start time, expressed in timer units
+ @param end end time, expressed in timer units
+ @param[out] pico_start start time, expressed in pico seconds
+ @param[out] pico_end end time, expressed in pico seconds
+ @param[out] pico_wait wait time, expressed in pico seconds
+ */
+ void to_pico(ulonglong start, ulonglong end,
+ ulonglong *pico_start, ulonglong *pico_end, ulonglong *pico_wait);
+};
+
+/**
+ Idle timer.
+ The timer used to measure all idle events.
+*/
+extern enum_timer_name idle_timer;
+/**
+ Wait timer.
+ The timer used to measure all wait events.
+*/
+extern enum_timer_name wait_timer;
+/**
+ Stage timer.
+ The timer used to measure all stage events.
+*/
+extern enum_timer_name stage_timer;
+/**
+ Statement timer.
+ The timer used to measure all statement events.
+*/
+extern enum_timer_name statement_timer;
+/**
+ Transaction timer.
+ The timer used to measure all transaction events.
+*/
+extern enum_timer_name transaction_timer;
+/**
+ Timer information data.
+ Characteristics about each supported timer.
+*/
+extern MYSQL_PLUGIN_IMPORT MY_TIMER_INFO sys_timer_info;
+
+/** Initialize the timer component. */
+void init_timers();
+
+extern "C"
+{
+ /** A timer function. */
+ typedef ulonglong (*timer_fct_t)(void);
+}
+
+/**
+ Get a timer value, in pico seconds.
+ @param timer_name the timer to use
+ @return timer value, in pico seconds
+*/
+ulonglong get_timer_pico_value(enum_timer_name timer_name);
+/**
+ Get a timer value, in timer units.
+ @param timer_name the timer to use
+ @return timer value, in timer units
+*/
+ulonglong get_timer_raw_value(enum_timer_name timer_name);
+/**
+ Get a timer value and function, in timer units.
+ This function is useful when code needs to call the same timer several times.
+ The returned timer function can be invoked directly, which avoids having to
+ resolve the timer by name for each call.
+ @param timer_name the timer to use
+ @param[out] fct the timer function
+ @return timer value, in timer units
+*/
+ulonglong get_timer_raw_value_and_function(enum_timer_name timer_name, timer_fct_t *fct);
+
+#endif
+
diff --git a/storage/perfschema/pfs_user.cc b/storage/perfschema/pfs_user.cc
new file mode 100644
index 00000000..feb99f41
--- /dev/null
+++ b/storage/perfschema/pfs_user.cc
@@ -0,0 +1,339 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/pfs_user.cc
+ Performance schema user (implementation).
+*/
+
+#include "my_global.h"
+#include "my_sys.h"
+#include "pfs.h"
+#include "pfs_stat.h"
+#include "pfs_instr.h"
+#include "pfs_setup_actor.h"
+#include "pfs_user.h"
+#include "pfs_global.h"
+#include "pfs_instr_class.h"
+#include "pfs_buffer_container.h"
+
+/**
+ @addtogroup Performance_schema_buffers
+ @{
+*/
+
+LF_HASH user_hash;
+static bool user_hash_inited= false;
+
+/**
+ Initialize the user buffers.
+ @param param sizing parameters
+ @return 0 on success
+*/
+int init_user(const PFS_global_param *param)
+{
+ if (global_user_container.init(param->m_user_sizing))
+ return 1;
+
+ return 0;
+}
+
+/** Cleanup all the user buffers. */
+void cleanup_user(void)
+{
+ global_user_container.cleanup();
+}
+
+C_MODE_START
+static uchar *user_hash_get_key(const uchar *entry, size_t *length,
+ my_bool)
+{
+ const PFS_user * const *typed_entry;
+ const PFS_user *user;
+ const void *result;
+ typed_entry= reinterpret_cast<const PFS_user* const *> (entry);
+ DBUG_ASSERT(typed_entry != NULL);
+ user= *typed_entry;
+ DBUG_ASSERT(user != NULL);
+ *length= user->m_key.m_key_length;
+ result= user->m_key.m_hash_key;
+ return const_cast<uchar*> (reinterpret_cast<const uchar*> (result));
+}
+C_MODE_END
+
+/**
+ Initialize the user hash.
+ @return 0 on success
+*/
+int init_user_hash(const PFS_global_param *param)
+{
+ if ((! user_hash_inited) && (param->m_user_sizing != 0))
+ {
+ lf_hash_init(&user_hash, sizeof(PFS_user*), LF_HASH_UNIQUE,
+ 0, 0, user_hash_get_key, &my_charset_bin);
+ user_hash_inited= true;
+ }
+ return 0;
+}
+
+/** Cleanup the user hash. */
+void cleanup_user_hash(void)
+{
+ if (user_hash_inited)
+ {
+ lf_hash_destroy(&user_hash);
+ user_hash_inited= false;
+ }
+}
+
+static LF_PINS* get_user_hash_pins(PFS_thread *thread)
+{
+ if (unlikely(thread->m_user_hash_pins == NULL))
+ {
+ if (! user_hash_inited)
+ return NULL;
+ thread->m_user_hash_pins= lf_hash_get_pins(&user_hash);
+ }
+ return thread->m_user_hash_pins;
+}
+
+static void set_user_key(PFS_user_key *key,
+ const char *user, uint user_length)
+{
+ DBUG_ASSERT(user_length <= USERNAME_LENGTH);
+
+ char *ptr= &key->m_hash_key[0];
+ if (user_length > 0)
+ {
+ memcpy(ptr, user, user_length);
+ ptr+= user_length;
+ }
+ ptr[0]= 0;
+ ptr++;
+ key->m_key_length= (uint)(ptr - &key->m_hash_key[0]);
+}
+
+PFS_user *
+find_or_create_user(PFS_thread *thread,
+ const char *username, uint username_length)
+{
+ LF_PINS *pins= get_user_hash_pins(thread);
+ if (unlikely(pins == NULL))
+ {
+ global_user_container.m_lost++;
+ return NULL;
+ }
+
+ PFS_user_key key;
+ set_user_key(&key, username, username_length);
+
+ PFS_user **entry;
+ PFS_user *pfs;
+ uint retry_count= 0;
+ const uint retry_max= 3;
+ pfs_dirty_state dirty_state;
+
+search:
+ entry= reinterpret_cast<PFS_user**>
+ (lf_hash_search(&user_hash, pins,
+ key.m_hash_key, key.m_key_length));
+ if (entry && (entry != MY_ERRPTR))
+ {
+ pfs= *entry;
+ pfs->inc_refcount();
+ lf_hash_search_unpin(pins);
+ return pfs;
+ }
+
+ lf_hash_search_unpin(pins);
+
+ pfs= global_user_container.allocate(& dirty_state);
+ if (pfs != NULL)
+ {
+ pfs->m_key= key;
+ if (username_length > 0)
+ pfs->m_username= &pfs->m_key.m_hash_key[0];
+ else
+ pfs->m_username= NULL;
+ pfs->m_username_length= username_length;
+
+ pfs->init_refcount();
+ pfs->reset_stats();
+ pfs->m_disconnected_count= 0;
+
+ int res;
+ pfs->m_lock.dirty_to_allocated(& dirty_state);
+ res= lf_hash_insert(&user_hash, pins, &pfs);
+ if (likely(res == 0))
+ {
+ return pfs;
+ }
+
+ global_user_container.deallocate(pfs);
+
+ if (res > 0)
+ {
+ if (++retry_count > retry_max)
+ {
+ global_user_container.m_lost++;
+ return NULL;
+ }
+ goto search;
+ }
+
+ global_user_container.m_lost++;
+ return NULL;
+ }
+
+ return NULL;
+}
+
+void PFS_user::aggregate(bool alive)
+{
+ aggregate_waits();
+ aggregate_stages();
+ aggregate_statements();
+ aggregate_transactions();
+ aggregate_memory(alive);
+ aggregate_status();
+ aggregate_stats();
+}
+
+void PFS_user::aggregate_waits()
+{
+ /* No parent to aggregate to, clean the stats */
+ reset_waits_stats();
+}
+
+void PFS_user::aggregate_stages()
+{
+ /* No parent to aggregate to, clean the stats */
+ reset_stages_stats();
+}
+
+void PFS_user::aggregate_statements()
+{
+ /* No parent to aggregate to, clean the stats */
+ reset_statements_stats();
+}
+
+void PFS_user::aggregate_transactions()
+{
+ /* No parent to aggregate to, clean the stats */
+ reset_transactions_stats();
+}
+
+void PFS_user::aggregate_memory(bool alive)
+{
+ /* No parent to aggregate to, clean the stats */
+ rebase_memory_stats();
+}
+
+void PFS_user::aggregate_status()
+{
+ /* No parent to aggregate to, clean the stats */
+ reset_status_stats();
+}
+
+void PFS_user::aggregate_stats()
+{
+ /* No parent to aggregate to, clean the stats */
+ m_disconnected_count= 0;
+}
+
+void PFS_user::release()
+{
+ dec_refcount();
+}
+
+void PFS_user::carry_memory_stat_delta(PFS_memory_stat_delta *delta, uint index)
+{
+ PFS_memory_stat *event_name_array;
+ PFS_memory_stat *stat;
+ PFS_memory_stat_delta delta_buffer;
+
+ event_name_array= write_instr_class_memory_stats();
+ stat= & event_name_array[index];
+ (void) stat->apply_delta(delta, &delta_buffer);
+}
+
+PFS_user *sanitize_user(PFS_user *unsafe)
+{
+ return global_user_container.sanitize(unsafe);
+}
+
+void purge_user(PFS_thread *thread, PFS_user *user)
+{
+ LF_PINS *pins= get_user_hash_pins(thread);
+ if (unlikely(pins == NULL))
+ return;
+
+ PFS_user **entry;
+ entry= reinterpret_cast<PFS_user**>
+ (lf_hash_search(&user_hash, pins,
+ user->m_key.m_hash_key, user->m_key.m_key_length));
+ if (entry && (entry != MY_ERRPTR))
+ {
+ DBUG_ASSERT(*entry == user);
+ if (user->get_refcount() == 0)
+ {
+ lf_hash_delete(&user_hash, pins,
+ user->m_key.m_hash_key, user->m_key.m_key_length);
+ user->aggregate(false);
+ global_user_container.deallocate(user);
+ }
+ }
+
+ lf_hash_search_unpin(pins);
+}
+
+class Proc_purge_user
+ : public PFS_buffer_processor<PFS_user>
+{
+public:
+ Proc_purge_user(PFS_thread *thread)
+ : m_thread(thread)
+ {}
+
+ virtual void operator()(PFS_user *pfs)
+ {
+ pfs->aggregate(true);
+ if (pfs->get_refcount() == 0)
+ purge_user(m_thread, pfs);
+ }
+
+private:
+ PFS_thread *m_thread;
+};
+
+/** Purge non connected users, reset stats of connected users. */
+void purge_all_user(void)
+{
+ PFS_thread *thread= PFS_thread::get_current_thread();
+ if (unlikely(thread == NULL))
+ return;
+
+ Proc_purge_user proc(thread);
+ global_user_container.apply(proc);
+}
+
+/** @} */
diff --git a/storage/perfschema/pfs_user.h b/storage/perfschema/pfs_user.h
new file mode 100644
index 00000000..9553ff8c
--- /dev/null
+++ b/storage/perfschema/pfs_user.h
@@ -0,0 +1,122 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef PFS_USER_H
+#define PFS_USER_H
+
+/**
+ @file storage/perfschema/pfs_user.h
+ Performance schema user (declarations).
+*/
+
+#include "pfs_lock.h"
+#include "lf.h"
+#include "pfs_con_slice.h"
+
+struct PFS_global_param;
+struct PFS_thread;
+
+/**
+ @addtogroup Performance_schema_buffers
+ @{
+*/
+
+/** Hash key for a user. */
+struct PFS_user_key
+{
+ /**
+ Hash search key.
+ This has to be a string for LF_HASH,
+ the format is "<username><0x00>"
+ */
+ char m_hash_key[USERNAME_LENGTH + 1];
+ uint m_key_length;
+};
+
+/** Per user statistics. */
+struct PFS_ALIGNED PFS_user : public PFS_connection_slice
+{
+public:
+ inline void init_refcount(void)
+ {
+ PFS_atomic::store_32(& m_refcount, 1);
+ }
+
+ inline int get_refcount(void)
+ {
+ return PFS_atomic::load_32(& m_refcount);
+ }
+
+ inline void inc_refcount(void)
+ {
+ PFS_atomic::add_32(& m_refcount, 1);
+ }
+
+ inline void dec_refcount(void)
+ {
+ PFS_atomic::add_32(& m_refcount, -1);
+ }
+
+ void aggregate(bool alive);
+ void aggregate_waits(void);
+ void aggregate_stages(void);
+ void aggregate_statements(void);
+ void aggregate_transactions(void);
+ void aggregate_memory(bool alive);
+ void aggregate_status(void);
+ void aggregate_stats(void);
+ void release(void);
+
+ void carry_memory_stat_delta(PFS_memory_stat_delta *delta, uint index);
+
+ /** Internal lock. */
+ pfs_lock m_lock;
+ PFS_user_key m_key;
+ const char *m_username;
+ uint m_username_length;
+
+ ulonglong m_disconnected_count;
+
+private:
+ int m_refcount;
+};
+
+int init_user(const PFS_global_param *param);
+void cleanup_user(void);
+int init_user_hash(const PFS_global_param *param);
+void cleanup_user_hash(void);
+
+PFS_user *
+find_or_create_user(PFS_thread *thread,
+ const char *username, uint username_length);
+
+PFS_user *sanitize_user(PFS_user *unsafe);
+void purge_all_user(void);
+
+
+/* For show status. */
+
+extern LF_HASH user_hash;
+
+/** @} */
+#endif
+
diff --git a/storage/perfschema/pfs_variable.cc b/storage/perfschema/pfs_variable.cc
new file mode 100644
index 00000000..9be6f12e
--- /dev/null
+++ b/storage/perfschema/pfs_variable.cc
@@ -0,0 +1,1291 @@
+/* Copyright (c) 2015, 2018, Oracle and/or its affiliates. All rights reserved.
+ Copyright (c) 2020, MariaDB Corporation.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA */
+
+/**
+ @file storage/perfschema/pfs_variable.cc
+ Performance schema system variable and status variable (implementation).
+*/
+#include "sql_plugin.h"
+#include "pfs_variable.h"
+#include "my_sys.h"
+#include "debug_sync.h"
+#include "pfs.h"
+#include "pfs_global.h"
+#include "pfs_visitor.h"
+#include "sql_audit.h" // audit_global_variable_get
+
+static inline SHOW_SCOPE show_scope_from_type(enum enum_mysql_show_type type)
+{
+ switch(type) {
+ case SHOW_BOOL:
+ case SHOW_CHAR:
+ case SHOW_CHAR_PTR:
+ case SHOW_DOUBLE:
+ case SHOW_HAVE:
+ case SHOW_HA_ROWS:
+ case SHOW_KEY_CACHE_LONG:
+ case SHOW_LEX_STRING:
+ case SHOW_LONG_NOFLUSH:
+ case SHOW_MY_BOOL:
+ case SHOW_SINT:
+ case SHOW_SLONG:
+ case SHOW_SLONGLONG:
+ case SHOW_SYS:
+ case SHOW_UINT:
+ case SHOW_ULONG:
+ case SHOW_ULONGLONG:
+ return SHOW_SCOPE_GLOBAL;
+
+ case SHOW_DOUBLE_STATUS:
+ case SHOW_LONGLONG_STATUS:
+ case SHOW_LONG_STATUS:
+ return SHOW_SCOPE_ALL;
+
+ case SHOW_ARRAY:
+ case SHOW_FUNC:
+ case SHOW_SIMPLE_FUNC:
+ case SHOW_UNDEF:
+ default:
+ return SHOW_SCOPE_UNDEF;
+ }
+ return SHOW_SCOPE_UNDEF;
+}
+
+
+/**
+ CLASS PFS_system_variable_cache
+*/
+
+/**
+ Build a sorted list of all system variables from the system variable hash.
+ Filter by scope. Must be called inside of LOCK_plugin_delete.
+*/
+bool PFS_system_variable_cache::init_show_var_array(enum_var_type scope, bool strict)
+{
+ DBUG_ASSERT(!m_initialized);
+ m_query_scope= scope;
+
+ mysql_prlock_rdlock(&LOCK_system_variables_hash);
+ DEBUG_SYNC(m_current_thd, "acquired_LOCK_system_variables_hash");
+
+ /* Record the system variable hash version to detect subsequent changes. */
+ m_version= get_system_variable_hash_version();
+
+ /* Build the SHOW_VAR array from the system variable hash. */
+ SHOW_VAR *vars= enumerate_sys_vars(m_current_thd, true, m_query_scope/*, strict */);
+ m_show_var_array.reserve(get_system_variable_hash_records());
+ for (int i=0; vars[i].name; i++)
+ m_show_var_array.set(i, vars[i]);
+
+ mysql_prlock_unlock(&LOCK_system_variables_hash);
+
+ /* Increase cache size if necessary. */
+ m_cache.reserve(m_show_var_array.elements());
+
+ m_initialized= true;
+ return true;
+}
+
+/**
+ Build an array of SHOW_VARs from the system variable hash.
+ Filter for SESSION scope.
+*/
+bool PFS_system_variable_cache::do_initialize_session(void)
+{
+ /* Block plugins from unloading. */
+ mysql_mutex_lock(&LOCK_plugin_delete);
+
+ /* Build the array. */
+ bool ret= init_show_var_array(OPT_SESSION, true);
+
+ mysql_mutex_unlock(&LOCK_plugin_delete);
+ return ret;
+}
+
+/**
+ Match system variable scope to desired scope.
+*/
+bool PFS_system_variable_cache::match_scope(int scope)
+{
+ switch (scope)
+ {
+ case sys_var::GLOBAL:
+ return m_query_scope == OPT_GLOBAL;
+ break;
+
+ case sys_var::SESSION:
+ return (m_query_scope == OPT_GLOBAL || m_query_scope == OPT_SESSION);
+ break;
+
+ case sys_var::ONLY_SESSION:
+ return m_query_scope == OPT_SESSION;
+ break;
+
+ default:
+ return false;
+ break;
+ }
+ return false;
+}
+
+/**
+ Build a GLOBAL system variable cache.
+*/
+int PFS_system_variable_cache::do_materialize_global(void)
+{
+ /* Block system variable additions or deletions. */
+ mysql_mutex_lock(&LOCK_global_system_variables);
+
+ m_materialized= false;
+
+ /*
+ Build array of SHOW_VARs from system variable hash. Do this within
+ LOCK_plugin_delete to ensure that the hash table remains unchanged
+ during materialization.
+ */
+ if (!m_external_init)
+ init_show_var_array(OPT_GLOBAL, true);
+
+ /* Resolve the value for each SHOW_VAR in the array, add to cache. */
+ for (SHOW_VAR *show_var= m_show_var_array.front();
+ show_var->value && (show_var != m_show_var_array.end()); show_var++)
+ {
+ const char* name= show_var->name;
+ sys_var *value= (sys_var *)show_var->value;
+ DBUG_ASSERT(value);
+
+ if ((m_query_scope == OPT_GLOBAL) &&
+ (!my_strcasecmp(system_charset_info, name, "sql_log_bin")))
+ {
+ /*
+ PLEASE READ:
+ http://dev.mysql.com/doc/relnotes/mysql/5.7/en/news-5-7-6.html
+
+ SQL_LOG_BIN is:
+ - declared in sys_vars.cc as both GLOBAL and SESSION in 5.7
+ - impossible to SET with SET GLOBAL (raises an error)
+ - and yet can be read with @@global.sql_log_bin
+
+ When show_compatibility_56 = ON,
+ - SHOW GLOBAL VARIABLES does expose a row for SQL_LOG_BIN
+ - INFORMATION_SCHEMA.GLOBAL_VARIABLES also does expose a row,
+ both are for backward compatibility of existing applications,
+ so that no application logic change is required.
+
+ Now, with show_compatibility_56 = OFF (aka, in this code)
+ - SHOW GLOBAL VARIABLES does -- not -- expose a row for SQL_LOG_BIN
+ - PERFORMANCE_SCHEMA.GLOBAL_VARIABLES also does -- not -- expose a row
+ so that a clean interface is exposed to (upgraded and modified) applications.
+
+ The assert below will fail once SQL_LOG_BIN really is defined
+ as SESSION_ONLY (in 5.8), so that this special case can be removed.
+ */
+ DBUG_ASSERT(value->scope() == sys_var::SESSION);
+ continue;
+ }
+
+ /* Match the system variable scope to the target scope. */
+ if (match_scope(value->scope()))
+ {
+ /* Resolve value, convert to text, add to cache. */
+ System_variable system_var(m_current_thd, show_var, m_query_scope, false);
+ m_cache.push(system_var);
+ }
+ }
+
+ m_materialized= true;
+ mysql_mutex_unlock(&LOCK_global_system_variables);
+ return 0;
+}
+
+/**
+ Build a GLOBAL and SESSION system variable cache.
+*/
+int PFS_system_variable_cache::do_materialize_all(THD *unsafe_thd)
+{
+ int ret= 1;
+
+ m_unsafe_thd= unsafe_thd;
+ m_safe_thd= NULL;
+ m_materialized= false;
+ m_cache.clear();
+
+ /* Block plugins from unloading. */
+ mysql_mutex_lock(&LOCK_plugin_delete);
+
+ /*
+ Build array of SHOW_VARs from system variable hash. Do this within
+ LOCK_plugin_delete to ensure that the hash table remains unchanged
+ while this thread is materialized.
+ */
+ if (!m_external_init)
+ init_show_var_array(OPT_SESSION, false);
+
+ /* Get and lock a validated THD from the thread manager. */
+ if ((m_safe_thd= get_THD(unsafe_thd)) != NULL)
+ {
+ DEBUG_SYNC(m_current_thd, "materialize_session_variable_array_THD_locked");
+ for (SHOW_VAR *show_var= m_show_var_array.front();
+ show_var->value && (show_var != m_show_var_array.end()); show_var++)
+ {
+ /* Resolve value, convert to text, add to cache. */
+ System_variable system_var(m_safe_thd, show_var, m_query_scope, false);
+ m_cache.push(system_var);
+ }
+
+ /* Release lock taken in get_THD(). */
+ mysql_mutex_unlock(&m_safe_thd->LOCK_thd_data);
+
+ m_materialized= true;
+ ret= 0;
+ }
+
+ mysql_mutex_unlock(&LOCK_plugin_delete);
+ return ret;
+}
+
+/**
+ Allocate and assign mem_root for system variable materialization.
+*/
+void PFS_system_variable_cache::set_mem_root(void)
+{
+ if (m_mem_sysvar_ptr == NULL)
+ {
+ init_sql_alloc(PSI_INSTRUMENT_ME, &m_mem_sysvar, SYSVAR_MEMROOT_BLOCK_SIZE, 0, 0);
+ m_mem_sysvar_ptr= &m_mem_sysvar;
+ }
+ m_mem_thd= &current_thd->mem_root; /* pointer to current THD mem_root */
+ m_mem_thd_save= *m_mem_thd; /* restore later */
+ *m_mem_thd= &m_mem_sysvar; /* use temporary mem_root */
+}
+
+/**
+ Mark memory blocks in the temporary mem_root as free.
+ Restore THD::mem_root.
+*/
+void PFS_system_variable_cache::clear_mem_root(void)
+{
+ if (m_mem_sysvar_ptr)
+ {
+ free_root(&m_mem_sysvar, MYF(MY_MARK_BLOCKS_FREE));
+ *m_mem_thd= m_mem_thd_save; /* restore original mem_root */
+ m_mem_thd= NULL;
+ m_mem_thd_save= NULL;
+ }
+}
+
+/**
+ Free the temporary mem_root.
+ Restore THD::mem_root if necessary.
+*/
+void PFS_system_variable_cache::free_mem_root(void)
+{
+ if (m_mem_sysvar_ptr)
+ {
+ free_root(&m_mem_sysvar, MYF(0));
+ m_mem_sysvar_ptr= NULL;
+ if (m_mem_thd && m_mem_thd_save)
+ {
+ *m_mem_thd= m_mem_thd_save; /* restore original mem_root */
+ m_mem_thd= NULL;
+ m_mem_thd_save= NULL;
+ }
+ }
+}
+
+/**
+ Build a SESSION system variable cache for a pfs_thread.
+ Requires that init_show_var_array() has already been called.
+ Return 0 for success.
+*/
+int PFS_system_variable_cache::do_materialize_session(PFS_thread *pfs_thread)
+{
+ int ret= 1;
+
+ m_pfs_thread= pfs_thread;
+ m_materialized= false;
+ m_cache.clear();
+
+ /* Block plugins from unloading. */
+ mysql_mutex_lock(&LOCK_plugin_delete);
+
+ /* The SHOW_VAR array must be initialized externally. */
+ DBUG_ASSERT(m_initialized);
+
+ /* Use a temporary mem_root to avoid depleting THD mem_root. */
+ if (m_use_mem_root)
+ set_mem_root();
+
+ /* Get and lock a validated THD from the thread manager. */
+ if ((m_safe_thd= get_THD(pfs_thread)) != NULL)
+ {
+ for (SHOW_VAR *show_var= m_show_var_array.front();
+ show_var->value && (show_var != m_show_var_array.end()); show_var++)
+ {
+ sys_var *value= (sys_var *)show_var->value;
+
+ /* Match the system variable scope to the target scope. */
+ if (match_scope(value->scope()))
+ {
+ /* Resolve value, convert to text, add to cache. */
+ System_variable system_var(m_safe_thd, show_var, m_query_scope, false);
+ m_cache.push(system_var);
+ }
+ }
+
+ /* Release lock taken in get_THD(). */
+ mysql_mutex_unlock(&m_safe_thd->LOCK_thd_data);
+
+ m_materialized= true;
+ ret= 0;
+ }
+
+ /* Mark mem_root blocks as free. */
+ if (m_use_mem_root)
+ clear_mem_root();
+
+ mysql_mutex_unlock(&LOCK_plugin_delete);
+ return ret;
+}
+
+/**
+ Materialize a single system variable for a pfs_thread.
+ Requires that init_show_var_array() has already been called.
+ Return 0 for success.
+*/
+int PFS_system_variable_cache::do_materialize_session(PFS_thread *pfs_thread, uint index)
+{
+ int ret= 1;
+
+ m_pfs_thread= pfs_thread;
+ m_materialized= false;
+ m_cache.clear();
+
+ /* Block plugins from unloading. */
+ mysql_mutex_lock(&LOCK_plugin_delete);
+
+ /* The SHOW_VAR array must be initialized externally. */
+ DBUG_ASSERT(m_initialized);
+
+ /* Get and lock a validated THD from the thread manager. */
+ if ((m_safe_thd= get_THD(pfs_thread)) != NULL)
+ {
+ SHOW_VAR *show_var= &m_show_var_array.at(index);
+
+ if (show_var && show_var->value &&
+ (show_var != m_show_var_array.end()))
+ {
+ sys_var *value= (sys_var *)show_var->value;
+
+ /* Match the system variable scope to the target scope. */
+ if (match_scope(value->scope()))
+ {
+ /* Resolve value, convert to text, add to cache. */
+ System_variable system_var(m_safe_thd, show_var, m_query_scope, false);
+ m_cache.push(system_var);
+ }
+ }
+
+ /* Release lock taken in get_THD(). */
+ mysql_mutex_unlock(&m_safe_thd->LOCK_thd_data);
+
+ m_materialized= true;
+ ret= 0;
+ }
+
+ mysql_mutex_unlock(&LOCK_plugin_delete);
+ return ret;
+}
+
+/**
+ Build a SESSION system variable cache for a THD.
+*/
+int PFS_system_variable_cache::do_materialize_session(THD *unsafe_thd)
+{
+ int ret= 1;
+
+ m_unsafe_thd= unsafe_thd;
+ m_safe_thd= NULL;
+ m_materialized= false;
+ m_cache.clear();
+
+ /* Block plugins from unloading. */
+ mysql_mutex_lock(&LOCK_plugin_delete);
+
+ /*
+ Build array of SHOW_VARs from system variable hash. Do this within
+ LOCK_plugin_delete to ensure that the hash table remains unchanged
+ while this thread is materialized.
+ */
+ if (!m_external_init)
+ init_show_var_array(OPT_SESSION, true);
+
+ /* Get and lock a validated THD from the thread manager. */
+ if ((m_safe_thd= get_THD(unsafe_thd)) != NULL)
+ {
+ for (SHOW_VAR *show_var= m_show_var_array.front();
+ show_var->value && (show_var != m_show_var_array.end()); show_var++)
+ {
+ sys_var *value = (sys_var *)show_var->value;
+
+ /* Match the system variable scope to the target scope. */
+ if (match_scope(value->scope()))
+ {
+ /* Resolve value, convert to text, add to cache. */
+ System_variable system_var(m_safe_thd, show_var, m_query_scope, false);
+ m_cache.push(system_var);
+ }
+ }
+
+ /* Release lock taken in get_THD(). */
+ mysql_mutex_unlock(&m_safe_thd->LOCK_thd_data);
+
+ m_materialized= true;
+ ret= 0;
+ }
+
+ mysql_mutex_unlock(&LOCK_plugin_delete);
+ return ret;
+}
+
+
+/**
+ CLASS System_variable
+*/
+
+/**
+ Empty placeholder.
+*/
+System_variable::System_variable()
+ : m_name(NULL), m_name_length(0), m_value_length(0), m_type(SHOW_UNDEF), m_scope(0),
+ m_ignore(false), m_charset(NULL), m_initialized(false)
+{
+ m_value_str[0]= '\0';
+}
+
+/**
+ GLOBAL or SESSION system variable.
+*/
+System_variable::System_variable(THD *target_thd, const SHOW_VAR *show_var,
+ enum_var_type query_scope, bool ignore)
+ : m_name(NULL), m_name_length(0), m_value_length(0), m_type(SHOW_UNDEF), m_scope(0),
+ m_ignore(ignore), m_charset(NULL), m_initialized(false)
+{
+ init(target_thd, show_var, query_scope);
+}
+
+/**
+ Get sys_var value from global or local source then convert to string.
+*/
+void System_variable::init(THD *target_thd, const SHOW_VAR *show_var,
+ enum_var_type query_scope)
+{
+ if (show_var == NULL || show_var->name == NULL)
+ return;
+
+ DBUG_ASSERT(show_var->type == SHOW_SYS);
+
+ m_name= show_var->name;
+ m_name_length= strlen(m_name);
+
+ /* Deprecated variables are ignored but must still be accounted for. */
+ if (m_ignore)
+ {
+ m_value_str[0]= '\0';
+ m_value_length= 0;
+ m_initialized= true;
+ return;
+ }
+
+ /* Block remote target thread from updating this system variable. */
+ /*XXX
+ THD *current_thread= current_thd;
+ if (target_thd != current_thread)
+ mysql_mutex_lock(&target_thd->LOCK_thd_sysvar);*/
+
+ sys_var *system_var= (sys_var *)show_var->value;
+ DBUG_ASSERT(system_var != NULL);
+ m_charset= system_var->charset(target_thd);
+ m_type= system_var->show_type();
+ m_scope= system_var->scope();
+
+ /* Get the value of the system variable. */
+ String buf(m_value_str, sizeof(m_value_str) - 1, system_charset_info);
+ if (!system_var->val_str_nolock(&buf, target_thd,
+ system_var->value_ptr(target_thd, query_scope, &null_clex_str)))
+ buf.length(0);
+
+ m_value_length= MY_MIN(buf.length(), SHOW_VAR_FUNC_BUFF_SIZE);
+
+ /* Returned value may reference a string other than m_value_str. */
+ if (buf.ptr() != m_value_str)
+ memcpy(m_value_str, buf.ptr(), m_value_length);
+ m_value_str[m_value_length]= 0;
+
+ /*XXX
+ if (target_thd != current_thread)
+ mysql_mutex_unlock(&target_thd->LOCK_thd_sysvar);*/
+
+ m_initialized= true;
+}
+
+
+/**
+ CLASS PFS_status_variable_cache
+*/
+
+PFS_status_variable_cache::
+PFS_status_variable_cache(bool external_init) :
+ PFS_variable_cache<Status_variable>(external_init),
+ m_show_command(false), m_sum_client_status(NULL)
+{
+ /* Determine if the originating query is a SHOW command. */
+ m_show_command= (m_current_thd->lex->sql_command == SQLCOM_SHOW_STATUS);
+}
+
+/**
+ Build cache of SESSION status variables for a user.
+*/
+int PFS_status_variable_cache::materialize_user(PFS_user *pfs_user)
+{
+ if (!pfs_user)
+ return 1;
+
+ if (is_materialized(pfs_user))
+ return 0;
+
+ if (!pfs_user->m_lock.is_populated())
+ return 1;
+
+ /* Set callback function. */
+ m_sum_client_status= sum_user_status;
+ return do_materialize_client((PFS_client *)pfs_user);
+}
+
+/**
+ Build cache of SESSION status variables for a host.
+*/
+int PFS_status_variable_cache::materialize_host(PFS_host *pfs_host)
+{
+ if (!pfs_host)
+ return 1;
+
+ if (is_materialized(pfs_host))
+ return 0;
+
+ if (!pfs_host->m_lock.is_populated())
+ return 1;
+
+ /* Set callback function. */
+ m_sum_client_status= sum_host_status;
+ return do_materialize_client((PFS_client *)pfs_host);
+}
+
+/**
+ Build cache of SESSION status variables for an account.
+*/
+int PFS_status_variable_cache::materialize_account(PFS_account *pfs_account)
+{
+ if (!pfs_account)
+ return 1;
+
+ if (is_materialized(pfs_account))
+ return 0;
+
+ if (!pfs_account->m_lock.is_populated())
+ return 1;
+
+ /* Set callback function. */
+ m_sum_client_status= sum_account_status;
+ return do_materialize_client((PFS_client *)pfs_account);
+}
+/**
+ Compare status variable scope to desired scope.
+ @param variable_scope Scope of current status variable
+ @return TRUE if variable matches the query scope
+*/
+bool PFS_status_variable_cache::match_scope(SHOW_SCOPE variable_scope, bool strict)
+{
+ switch (variable_scope)
+ {
+ case SHOW_SCOPE_GLOBAL:
+ return (m_query_scope == OPT_GLOBAL) || (! strict && (m_query_scope == OPT_SESSION));
+ break;
+ case SHOW_SCOPE_SESSION:
+ /* Ignore session-only vars if aggregating by user, host or account. */
+ if (m_aggregate)
+ return false;
+ else
+ return (m_query_scope == OPT_SESSION);
+ break;
+ case SHOW_SCOPE_ALL:
+ return (m_query_scope == OPT_GLOBAL || m_query_scope == OPT_SESSION);
+ break;
+ case SHOW_SCOPE_UNDEF:
+ default:
+ return false;
+ break;
+ }
+ return false;
+}
+
+/*
+ Exclude specific status variables from the query by name or prefix.
+ Return TRUE if variable should be filtered.
+*/
+bool PFS_status_variable_cache::filter_by_name(const SHOW_VAR *show_var)
+{
+ DBUG_ASSERT(show_var);
+ DBUG_ASSERT(show_var->name);
+
+ if (show_var->type == SHOW_ARRAY)
+ {
+ /* The SHOW_ARRAY name is the prefix for the variables in the subarray. */
+ const char *prefix= show_var->name;
+ /* Exclude COM counters if not a SHOW STATUS command. */
+ if (!my_strcasecmp(system_charset_info, prefix, "Com") && !m_show_command)
+ return true;
+ }
+ else
+ {
+ /*
+ Slave status resides in Performance Schema replication tables. Exclude
+ these slave status variables from the SHOW STATUS command and from the
+ status tables.
+ Assume null prefix to ensure that only server-defined slave status
+ variables are filtered.
+ */
+ const char *name= show_var->name;
+ if (!my_strcasecmp(system_charset_info, name, "Slave_running") ||
+ !my_strcasecmp(system_charset_info, name, "Slave_retried_transactions") ||
+ !my_strcasecmp(system_charset_info, name, "Slave_last_heartbeat") ||
+ !my_strcasecmp(system_charset_info, name, "Slave_received_heartbeats") ||
+ !my_strcasecmp(system_charset_info, name, "Slave_heartbeat_period"))
+ {
+ return true;
+ }
+ }
+
+ return false;
+}
+
+/**
+ Check that the variable type is aggregatable.
+
+ @param variable_type Status variable type
+ @return TRUE if variable type can be aggregated
+*/
+bool PFS_status_variable_cache::can_aggregate(enum_mysql_show_type variable_type)
+{
+ switch(variable_type)
+ {
+ /*
+ All server status counters that are totaled across threads are defined in
+ system_status_var as either SHOW_LONGLONG_STATUS or SHOW_LONG_STATUS.
+ These data types are not available to plugins.
+ */
+ case SHOW_LONGLONG_STATUS:
+ case SHOW_LONG_STATUS:
+ return true;
+ break;
+
+ /* Server and plugin */
+ case SHOW_UNDEF:
+ case SHOW_BOOL:
+ case SHOW_CHAR:
+ case SHOW_CHAR_PTR:
+ case SHOW_ARRAY:
+ case SHOW_FUNC:
+ case SHOW_INT:
+ case SHOW_LONG:
+ case SHOW_LONGLONG:
+ case SHOW_DOUBLE:
+ /* Server only */
+ case SHOW_HAVE:
+ case SHOW_MY_BOOL:
+ case SHOW_SYS:
+ case SHOW_LEX_STRING:
+ case SHOW_KEY_CACHE_LONG:
+ case SHOW_DOUBLE_STATUS:
+ case SHOW_HA_ROWS:
+ case SHOW_LONG_NOFLUSH:
+ case SHOW_SLONG:
+ default:
+ return false;
+ break;
+ }
+}
+
+/**
+ Check if a status variable should be excluded from the query.
+ Return TRUE if the variable should be excluded.
+*/
+bool PFS_status_variable_cache::filter_show_var(const SHOW_VAR *show_var, bool strict)
+{
+ /* Match the variable scope with the query scope. */
+ if (!match_scope(show_scope_from_type(show_var->type), strict))
+ return true;
+
+ /* Exclude specific status variables by name or prefix. */
+ if (filter_by_name(show_var))
+ return true;
+
+ /* For user, host or account, ignore variables having non-aggregatable types. */
+ if (m_aggregate && !can_aggregate(show_var->type))
+ return true;
+
+ return false;
+}
+
+
+/**
+ Build an array of SHOW_VARs from the global status array. Expand nested
+ subarrays, filter unwanted variables.
+ NOTE: Must be done inside of LOCK_status to guard against plugin load/unload.
+*/
+bool PFS_status_variable_cache::init_show_var_array(enum_var_type scope, bool strict)
+{
+ DBUG_ASSERT(!m_initialized);
+
+ /* Resize if necessary. */
+ m_show_var_array.reserve(all_status_vars.elements + 1);
+
+ m_query_scope= scope;
+
+ for (SHOW_VAR *show_var_iter= dynamic_element(&all_status_vars, 0, SHOW_VAR *);
+ show_var_iter != dynamic_element(&all_status_vars, all_status_vars.elements, SHOW_VAR *);
+ show_var_iter++)
+ {
+ SHOW_VAR show_var= *show_var_iter;
+
+ /* Check if this status var should be excluded from the query. */
+ if (filter_show_var(&show_var, strict))
+ continue;
+
+ if (show_var.type == SHOW_ARRAY)
+ {
+ /* Expand nested subarray. The name is used as a prefix. */
+ expand_show_var_array((SHOW_VAR *)show_var.value, show_var.name, strict);
+ }
+ else
+ {
+ show_var.name= make_show_var_name(NULL, show_var.name);
+ m_show_var_array.push(show_var);
+ }
+ }
+
+ /* Last element is NULL. */
+ st_mysql_show_var empty= {0,0,SHOW_UNDEF};
+ m_show_var_array.push(empty);
+
+ /* Get the latest version of all_status_vars. */
+ m_version= get_status_vars_version();
+
+ /* Increase cache size if necessary. */
+ m_cache.reserve(m_show_var_array.elements());
+
+ m_initialized= true;
+ return true;
+}
+
+/**
+ Expand a nested subarray of status variables, indicated by a type of SHOW_ARRAY.
+*/
+void PFS_status_variable_cache::expand_show_var_array(const SHOW_VAR *show_var_array, const char *prefix, bool strict)
+{
+ for (const SHOW_VAR *show_var_ptr= show_var_array;
+ show_var_ptr && show_var_ptr->name;
+ show_var_ptr++)
+ {
+ SHOW_VAR show_var= *show_var_ptr;
+
+ if (filter_show_var(&show_var, strict))
+ continue;
+
+ if (show_var.type == SHOW_ARRAY)
+ {
+ char name_buf[SHOW_VAR_MAX_NAME_LEN];
+ show_var.name= make_show_var_name(prefix, show_var.name, name_buf, sizeof(name_buf));
+ /* Expand nested subarray. The name is used as a prefix. */
+ expand_show_var_array((SHOW_VAR *)show_var.value, show_var.name, strict);
+ }
+ else
+ {
+ /* Add the SHOW_VAR element. Make a local copy of the name string. */
+ show_var.name= make_show_var_name(prefix, show_var.name);
+ m_show_var_array.push(show_var);
+ }
+ }
+}
+
+/**
+ Build the complete status variable name, with prefix. Return in buffer provided.
+*/
+char * PFS_status_variable_cache::make_show_var_name(const char* prefix, const char* name,
+ char *name_buf, size_t buf_len)
+{
+ DBUG_ASSERT(name_buf != NULL);
+ char *prefix_end= name_buf;
+
+ if (prefix && *prefix)
+ {
+ /* Drop the prefix into the front of the name buffer. */
+ prefix_end= my_stpnmov(name_buf, prefix, buf_len-1);
+ *prefix_end++= '_';
+ }
+
+ /* Restrict name length to remaining buffer size. */
+ size_t max_name_len= name_buf + buf_len - prefix_end;
+
+ /* Load the name into the buffer after the prefix. */
+ my_stpnmov(prefix_end, name, max_name_len);
+ name_buf[buf_len-1]= 0;
+
+ return (name_buf);
+}
+
+/**
+ Make a copy of the name string prefixed with the subarray name if necessary.
+*/
+char * PFS_status_variable_cache::make_show_var_name(const char* prefix, const char* name)
+{
+ char name_buf[SHOW_VAR_MAX_NAME_LEN];
+ size_t buf_len= sizeof(name_buf);
+ make_show_var_name(prefix, name, name_buf, buf_len);
+ return m_current_thd->strdup(name_buf); /* freed at statement end */
+}
+
+/**
+ Build an internal SHOW_VAR array from the external status variable array.
+*/
+bool PFS_status_variable_cache::do_initialize_session(void)
+{
+ /* Acquire LOCK_status to guard against plugin load/unload. */
+ //if (m_current_thd->fill_status_recursion_level++ == 0)
+ mysql_mutex_lock(&LOCK_status);
+
+ bool ret= init_show_var_array(OPT_SESSION, true);
+
+ //if (m_current_thd->fill_status_recursion_level-- == 1)
+ mysql_mutex_unlock(&LOCK_status);
+
+ return ret;
+}
+
+/**
+ For the current THD, use initial_status_vars taken from before the query start.
+*/
+STATUS_VAR *PFS_status_variable_cache::set_status_vars(void)
+{
+ STATUS_VAR *status_vars;
+ if (m_safe_thd == m_current_thd && m_current_thd->initial_status_var != NULL)
+ status_vars= m_current_thd->initial_status_var;
+ else
+ status_vars= &m_safe_thd->status_var;
+
+ return status_vars;
+}
+
+/**
+ Build cache for GLOBAL status variables using values totaled from all threads.
+*/
+int PFS_status_variable_cache::do_materialize_global(void)
+{
+ STATUS_VAR status_totals;
+
+ m_materialized= false;
+ DEBUG_SYNC(m_current_thd, "before_materialize_global_status_array");
+
+ /* Acquire LOCK_status to guard against plugin load/unload. */
+ //if (m_current_thd->fill_status_recursion_level++ == 0)
+ mysql_mutex_lock(&LOCK_status);
+
+ /*
+ Build array of SHOW_VARs from global status array. Do this within
+ LOCK_status to ensure that the array remains unchanged during
+ materialization.
+ */
+ if (!m_external_init)
+ init_show_var_array(OPT_GLOBAL, true);
+
+ /*
+ Collect totals for all active threads. Start with global status vars as a
+ baseline.
+ */
+ PFS_connection_status_visitor visitor(&status_totals);
+ PFS_connection_iterator::visit_global(false, /* hosts */
+ false, /* users */
+ false, /* accounts */
+ false, /* threads */
+ true, /* THDs */
+ &visitor);
+ /*
+ Build the status variable cache using the SHOW_VAR array as a reference.
+ Use the status totals collected from all threads.
+ */
+ manifest(m_current_thd, m_show_var_array.front(), &status_totals, "", false, true);
+
+ //if (m_current_thd->fill_status_recursion_level-- == 1)
+ mysql_mutex_unlock(&LOCK_status);
+
+ m_materialized= true;
+ DEBUG_SYNC(m_current_thd, "after_materialize_global_status_array");
+
+ return 0;
+}
+
+/**
+ Build GLOBAL and SESSION status variable cache using values for a non-instrumented thread.
+*/
+int PFS_status_variable_cache::do_materialize_all(THD* unsafe_thd)
+{
+ int ret= 1;
+ DBUG_ASSERT(unsafe_thd != NULL);
+
+ m_unsafe_thd= unsafe_thd;
+ m_materialized= false;
+ m_cache.clear();
+
+ /* Avoid recursive acquisition of LOCK_status. */
+ //if (m_current_thd->fill_status_recursion_level++ == 0)
+ mysql_mutex_lock(&LOCK_status);
+
+ /*
+ Build array of SHOW_VARs from global status array. Do this within
+ LOCK_status to ensure that the array remains unchanged while this
+ thread is materialized.
+ */
+ if (!m_external_init)
+ init_show_var_array(OPT_SESSION, false);
+
+ /* Get and lock a validated THD from the thread manager. */
+ if ((m_safe_thd= get_THD(unsafe_thd)) != NULL)
+ {
+ /*
+ Build the status variable cache using the SHOW_VAR array as a reference.
+ Use the status values from the THD protected by the thread manager lock.
+ */
+ STATUS_VAR *status_vars= set_status_vars();
+ manifest(m_safe_thd, m_show_var_array.front(), status_vars, "", false, false);
+
+ /* Release lock taken in get_THD(). */
+ mysql_mutex_unlock(&m_safe_thd->LOCK_thd_data);
+
+ m_materialized= true;
+ ret= 0;
+ }
+
+ //if (m_current_thd->fill_status_recursion_level-- == 1)
+ mysql_mutex_unlock(&LOCK_status);
+ return ret;
+}
+
+/**
+ Build SESSION status variable cache using values for a non-instrumented thread.
+*/
+int PFS_status_variable_cache::do_materialize_session(THD* unsafe_thd)
+{
+ int ret= 1;
+ DBUG_ASSERT(unsafe_thd != NULL);
+
+ m_unsafe_thd= unsafe_thd;
+ m_materialized= false;
+ m_cache.clear();
+
+ /* Avoid recursive acquisition of LOCK_status. */
+ //if (m_current_thd->fill_status_recursion_level++ == 0)
+ mysql_mutex_lock(&LOCK_status);
+
+ /*
+ Build array of SHOW_VARs from global status array. Do this within
+ LOCK_status to ensure that the array remains unchanged while this
+ thread is materialized.
+ */
+ if (!m_external_init)
+ init_show_var_array(OPT_SESSION, true);
+
+ /* Get and lock a validated THD from the thread manager. */
+ if ((m_safe_thd= get_THD(unsafe_thd)) != NULL)
+ {
+ /*
+ Build the status variable cache using the SHOW_VAR array as a reference.
+ Use the status values from the THD protected by the thread manager lock.
+ */
+ STATUS_VAR *status_vars= set_status_vars();
+ manifest(m_safe_thd, m_show_var_array.front(), status_vars, "", false, true);
+
+ /* Release lock taken in get_THD(). */
+ mysql_mutex_unlock(&m_safe_thd->LOCK_thd_data);
+
+ m_materialized= true;
+ ret= 0;
+ }
+
+ //if (m_current_thd->fill_status_recursion_level-- == 1)
+ mysql_mutex_unlock(&LOCK_status);
+ return ret;
+}
+
+/**
+ Build SESSION status variable cache using values for a PFS_thread.
+ NOTE: Requires that init_show_var_array() has already been called.
+*/
+int PFS_status_variable_cache::do_materialize_session(PFS_thread *pfs_thread)
+{
+ int ret= 1;
+ DBUG_ASSERT(pfs_thread != NULL);
+
+ m_pfs_thread= pfs_thread;
+ m_materialized= false;
+ m_cache.clear();
+
+ /* Acquire LOCK_status to guard against plugin load/unload. */
+ //if (m_current_thd->fill_status_recursion_level++ == 0)
+ mysql_mutex_lock(&LOCK_status);
+
+ /* The SHOW_VAR array must be initialized externally. */
+ DBUG_ASSERT(m_initialized);
+
+ /* Get and lock a validated THD from the thread manager. */
+ if ((m_safe_thd= get_THD(pfs_thread)) != NULL)
+ {
+ /*
+ Build the status variable cache using the SHOW_VAR array as a reference.
+ Use the status values from the THD protected by the thread manager lock.
+ */
+ STATUS_VAR *status_vars= set_status_vars();
+ manifest(m_safe_thd, m_show_var_array.front(), status_vars, "", false, true);
+
+ /* Release lock taken in get_THD(). */
+ mysql_mutex_unlock(&m_safe_thd->LOCK_thd_data);
+
+ m_materialized= true;
+ ret= 0;
+ }
+
+ //if (m_current_thd->fill_status_recursion_level-- == 1)
+ mysql_mutex_unlock(&LOCK_status);
+ return ret;
+}
+
+/**
+ Build cache of SESSION status variables using the status values provided.
+ The cache is associated with a user, host or account, but not with any
+ particular thread.
+ NOTE: Requires that init_show_var_array() has already been called.
+*/
+int PFS_status_variable_cache::do_materialize_client(PFS_client *pfs_client)
+{
+ DBUG_ASSERT(pfs_client != NULL);
+ STATUS_VAR status_totals;
+
+ m_pfs_client= pfs_client;
+ m_materialized= false;
+ m_cache.clear();
+
+ /* Acquire LOCK_status to guard against plugin load/unload. */
+ //if (m_current_thd->fill_status_recursion_level++ == 0)
+ mysql_mutex_lock(&LOCK_status);
+
+ /* The SHOW_VAR array must be initialized externally. */
+ DBUG_ASSERT(m_initialized);
+
+ /*
+ Generate status totals from active threads and from totals aggregated
+ from disconnected threads.
+ */
+ m_sum_client_status(pfs_client, &status_totals);
+
+ /*
+ Build the status variable cache using the SHOW_VAR array as a reference and
+ the status totals collected from threads associated with this client.
+ */
+ manifest(m_current_thd, m_show_var_array.front(), &status_totals, "", false, true);
+
+ //if (m_current_thd->fill_status_recursion_level-- == 1)
+ mysql_mutex_unlock(&LOCK_status);
+
+ m_materialized= true;
+ return 0;
+}
+
+/*
+ Build the status variable cache from the expanded and sorted SHOW_VAR array.
+ Resolve status values using the STATUS_VAR struct provided.
+*/
+void PFS_status_variable_cache::manifest(THD *thd, const SHOW_VAR *show_var_array,
+ STATUS_VAR *status_vars, const char *prefix,
+ bool nested_array, bool strict)
+{
+ for (const SHOW_VAR *show_var_iter= show_var_array;
+ show_var_iter && show_var_iter->name;
+ show_var_iter++)
+ {
+ // work buffer, must be aligned to handle long/longlong values
+ my_aligned_storage<SHOW_VAR_FUNC_BUFF_SIZE+1, MY_ALIGNOF(longlong)>
+ value_buf;
+ SHOW_VAR show_var_tmp;
+ const SHOW_VAR *show_var_ptr= show_var_iter; /* preserve array pointer */
+
+ /*
+ If the value is a function reference, then execute the function and
+ reevaluate the new SHOW_TYPE and value. Handle nested case where
+ SHOW_FUNC resolves to another SHOW_FUNC.
+ */
+ if (show_var_ptr->type == SHOW_FUNC)
+ {
+ show_var_tmp= *show_var_ptr;
+ /*
+ Execute the function reference in show_var_tmp->value, which returns
+ show_var_tmp with a new type and new value.
+ */
+ for (const SHOW_VAR *var= show_var_ptr; var->type == SHOW_FUNC; var= &show_var_tmp)
+ {
+ ((mysql_show_var_func)(var->value))(thd, &show_var_tmp, value_buf.data, NULL, m_query_scope);
+ }
+ show_var_ptr= &show_var_tmp;
+ }
+
+ /*
+ If we are expanding a SHOW_ARRAY, filter variables that were not prefiltered by
+ init_show_var_array().
+ */
+ if (nested_array && filter_show_var(show_var_ptr, strict))
+ continue;
+
+ if (show_var_ptr->type == SHOW_ARRAY)
+ {
+ /*
+ Status variables of type SHOW_ARRAY were expanded and filtered by
+ init_show_var_array(), except where a SHOW_FUNC resolves into a
+ SHOW_ARRAY, such as with InnoDB. Recurse to expand the subarray.
+ */
+ manifest(thd, (SHOW_VAR *)show_var_ptr->value, status_vars, show_var_ptr->name, true, strict);
+ }
+ else
+ {
+ /* Add the materialized status variable to the cache. */
+ SHOW_VAR show_var= *show_var_ptr;
+ /*
+ For nested array expansions, make a copy of the variable name, just as
+ done in init_show_var_array().
+ */
+ if (nested_array)
+ show_var.name= make_show_var_name(prefix, show_var_ptr->name);
+
+ /* Convert status value to string format. Add to the cache. */
+ Status_variable status_var(&show_var, status_vars, m_query_scope);
+ m_cache.push(status_var);
+ }
+ }
+}
+
+/**
+ CLASS Status_variable
+*/
+Status_variable::Status_variable(const SHOW_VAR *show_var, STATUS_VAR *status_vars, enum_var_type query_scope)
+ : m_name_length(0), m_value_length(0), m_type(SHOW_UNDEF),
+ m_charset(NULL), m_initialized(false)
+{
+ init(show_var, status_vars, query_scope);
+}
+
+/**
+ Resolve status value, convert to string.
+ show_var->value is an offset into status_vars.
+ NOTE: Assumes LOCK_status is held.
+*/
+void Status_variable::init(const SHOW_VAR *show_var, STATUS_VAR *status_vars, enum_var_type query_scope)
+{
+ if (show_var == NULL || show_var->name == NULL)
+ return;
+ m_name= show_var->name;
+ m_name_length= strlen(m_name);
+ m_type= show_var->type;
+
+ /* Get the value of the status variable. */
+ const char *value;
+ value= get_one_variable(current_thd, show_var, query_scope, m_type,
+ status_vars, &m_charset, m_value_str, &m_value_length);
+ m_value_length= MY_MIN(m_value_length, SHOW_VAR_FUNC_BUFF_SIZE);
+ m_charset= system_charset_info;
+
+ /* Returned value may reference a string other than m_value_str. */
+ if (value != m_value_str)
+ memcpy(m_value_str, value, m_value_length);
+ m_value_str[m_value_length]= 0;
+
+ m_initialized= true;
+}
+
+/*
+ Get status totals for this user from active THDs and related accounts.
+*/
+void sum_user_status(PFS_client *pfs_user, STATUS_VAR *status_totals)
+{
+ PFS_connection_status_visitor visitor(status_totals);
+ PFS_connection_iterator::visit_user((PFS_user *)pfs_user,
+ true, /* accounts */
+ false, /* threads */
+ true, /* THDs */
+ &visitor);
+}
+
+/*
+ Get status totals for this host from active THDs and related accounts.
+*/
+void sum_host_status(PFS_client *pfs_host, STATUS_VAR *status_totals)
+{
+ PFS_connection_status_visitor visitor(status_totals);
+ PFS_connection_iterator::visit_host((PFS_host *)pfs_host,
+ true, /* accounts */
+ false, /* threads */
+ true, /* THDs */
+ &visitor);
+}
+
+/*
+ Get status totals for this account from active THDs and from totals aggregated
+ from disconnectd threads.
+*/
+void sum_account_status(PFS_client *pfs_account, STATUS_VAR *status_totals)
+{
+ PFS_connection_status_visitor visitor(status_totals);
+ PFS_connection_iterator::visit_account((PFS_account *)pfs_account,
+ false, /* threads */
+ true, /* THDs */
+ &visitor);
+}
+
+/**
+ Reset aggregated status counter stats for account, user and host.
+ NOTE: Assumes LOCK_status is held.
+*/
+void reset_pfs_status_stats()
+{
+ reset_status_by_account();
+ reset_status_by_user();
+ reset_status_by_host();
+}
+
+/** @} */
diff --git a/storage/perfschema/pfs_variable.h b/storage/perfschema/pfs_variable.h
new file mode 100644
index 00000000..bfe51c6d
--- /dev/null
+++ b/storage/perfschema/pfs_variable.h
@@ -0,0 +1,716 @@
+/* Copyright (c) 2015, 2018, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA */
+
+#ifndef PFS_VARIABLE_H
+#define PFS_VARIABLE_H
+
+/**
+ @file storage/perfschema/pfs_variable.h
+ Performance schema system and status variables (declarations).
+*/
+
+/**
+ OVERVIEW
+ --------
+ Status and system variables are implemented differently in the server, but the
+ steps to process them in the Performance Schema are essentially the same:
+
+ 1. INITIALIZE - Build or acquire a sorted list of variables to use for input.
+ Use the SHOW_VAR struct as an intermediate format common to system, status
+ and user vars:
+
+ SHOW_VAR
+ Name - Text string
+ Value - Pointer to memory location, function, subarray structure
+ Type - Scalar, function, or subarray
+ Scope - SESSION, GLOBAL, BOTH
+
+ Steps:
+ - Register the server's internal buffer with the class. Acquire locks
+ if necessary, then scan the contents of the input buffer.
+ - For system variables, convert each element to SHOW_VAR format, store in
+ a temporary array.
+ - For status variables, copy existing global status array into a local
+ array that can be used without locks. Expand nested subarrays, indicated
+ by a type of SHOW_ARRAY.
+
+ 2. MATERIALIZE - Convert the list of SHOW_VAR variables to string format,
+ store in a local cache:
+ - Resolve each variable according to the type.
+ - Recursively process unexpanded nested arrays and callback functions.
+ - Aggregate values across threads for global status.
+ - Convert numeric values to a string.
+ - Prefix variable name with the plugin name.
+
+ 3. OUTPUT - Iterate the cache for the SHOW command or table query.
+
+ CLASS OVERVIEW
+ --------------
+ 1. System_variable - A materialized system variable
+ 2. Status_variable - A materialized status variable
+ 3. PFS_variable_cache - Base class that defines the interface for the operations above.
+ public
+ init_show_var_array() - Build SHOW_VAR list of variables for processing
+ materialize_global() - Materialize global variables, aggregate across sessions
+ materialize_session() - Materialize variables for a given PFS_thread or THD
+ materialize_user() - Materialize variables for a user, aggregate across related threads.
+ materialize_host() - Materialize variables for a host, aggregate across related threads.
+ materialize_account() - Materialize variables for a account, aggregate across related threads.
+ private
+ m_show_var_array - Prealloc_array of SHOW_VARs for input to Materialize
+ m_cache - Prealloc_array of materialized variables for output
+ do_materialize_global() - Implementation of materialize_global()
+ do_materialize_session() - Implementation of materialize_session()
+ do_materialize_client() - Implementation of materialize_user/host/account()
+
+ 4. PFS_system_variable_cache - System variable implementation of PFS_variable_cache
+ 5. PFS_status_variable_cache - Status variable implementation of PFS_variable_cache
+ 6. Find_THD_variable - Used by the thread manager to find and lock a THD.
+
+ GLOSSARY
+ --------
+ Status variable - Server or plugin status counter. Not dynamic.
+ System variable - Server or plugin configuration variable. Usually dynamic.
+ GLOBAL scope - Associated with the server, no context at thread level.
+ SESSION scope - Associated with a connection or thread, but no global context.
+ BOTH scope - Globally defined but applies at the session level.
+ Initialize - Build list of variables in SHOW_VAR format.
+ Materialize - Convert variables in SHOW_VAR list to string, cache for output.
+ Manifest - Substep of Materialize. Resolve variable values according to
+ type. This includes SHOW_FUNC types which are resolved by
+ executing a callback function (possibly recursively), and
+ SHOW_ARRAY types that expand into nested subarrays.
+ LOCK PRIORITIES
+ ---------------
+ System Variables
+ LOCK_plugin_delete (block plugin delete)
+ LOCK_system_variables_hash
+ LOCK_thd_data (block THD delete)
+ LOCK_thd_sysvar (block system variable updates, alloc_and_copy_thd_dynamic_variables)
+ LOCK_global_system_variables (very briefly held)
+
+ Status Variables
+ LOCK_status
+ LOCK_thd_data (block THD delete)
+*/
+
+/* Iteration on THD from the sql layer. */
+#include "mysqld_thd_manager.h"
+#define PFS_VAR
+/* Class sys_var */
+#include "set_var.h"
+/* convert_value_to_string */
+#include "sql_show.h"
+/* PFS_thread */
+#include "pfs_instr.h"
+#include "pfs_user.h"
+#include "pfs_host.h"
+#include "pfs_account.h"
+
+/* Global array of all server and plugin-defined status variables. */
+extern DYNAMIC_ARRAY all_status_vars;
+extern bool status_vars_inited;
+static const uint SYSVAR_MEMROOT_BLOCK_SIZE = 4096;
+
+extern mysql_mutex_t LOCK_plugin_delete;
+
+class Find_THD_Impl;
+class Find_THD_variable;
+typedef PFS_connection_slice PFS_client;
+
+/**
+ CLASS System_variable - System variable derived from sys_var object.
+*/
+class System_variable
+{
+public:
+ System_variable();
+ System_variable(THD *target_thd, const SHOW_VAR *show_var,
+ enum_var_type query_scope, bool ignore);
+ ~System_variable() {}
+
+ bool is_null() const { return !m_initialized; }
+ bool is_ignored() const { return m_ignore; }
+
+public:
+ const char *m_name;
+ size_t m_name_length;
+ char m_value_str[SHOW_VAR_FUNC_BUFF_SIZE+1];
+ size_t m_value_length;
+ enum_mysql_show_type m_type;
+ int m_scope;
+ bool m_ignore;
+ const CHARSET_INFO *m_charset;
+
+private:
+ bool m_initialized;
+ void init(THD *thd, const SHOW_VAR *show_var, enum_var_type query_scope);
+};
+
+
+/**
+ CLASS Status_variable - Status variable derived from SHOW_VAR.
+*/
+class Status_variable
+{
+public:
+ Status_variable() : m_name(NULL), m_name_length(0), m_value_length(0),
+ m_type(SHOW_UNDEF),
+ m_charset(NULL), m_initialized(false) {}
+
+ Status_variable(const SHOW_VAR *show_var, STATUS_VAR *status_array, enum_var_type query_scope);
+
+ ~Status_variable() {}
+
+ bool is_null() const {return !m_initialized;};
+
+public:
+ const char *m_name;
+ size_t m_name_length;
+ char m_value_str[SHOW_VAR_FUNC_BUFF_SIZE+1];
+ size_t m_value_length;
+ SHOW_TYPE m_type;
+ const CHARSET_INFO *m_charset;
+private:
+ bool m_initialized;
+ void init(const SHOW_VAR *show_var, STATUS_VAR *status_array, enum_var_type query_scope);
+};
+
+
+/**
+ CLASS Find_THD_variable - Get and lock a validated THD from the thread manager.
+*/
+class Find_THD_variable : public Find_THD_Impl
+{
+public:
+ Find_THD_variable() : m_unsafe_thd(NULL) {}
+ Find_THD_variable(THD *unsafe_thd) : m_unsafe_thd(unsafe_thd) {}
+
+ virtual bool operator()(THD *thd)
+ {
+ //TODO: filter bg threads?
+ if (thd != m_unsafe_thd)
+ return false;
+
+ /* Hold this lock to keep THD during materialization. */
+ mysql_mutex_lock(&thd->LOCK_thd_data);
+ return true;
+ }
+ void set_unsafe_thd(THD *unsafe_thd) { m_unsafe_thd= unsafe_thd; }
+private:
+ THD *m_unsafe_thd;
+};
+
+/**
+ CLASS PFS_variable_cache - Base class for a system or status variable cache.
+*/
+template <class Var_type>
+class PFS_variable_cache
+{
+public:
+ typedef Dynamic_array<Var_type> Variable_array;
+
+ PFS_variable_cache(bool external_init)
+ : m_safe_thd(NULL),
+ m_unsafe_thd(NULL),
+ m_current_thd(current_thd),
+ m_pfs_thread(NULL),
+ m_pfs_client(NULL),
+ m_thd_finder(),
+ m_cache(PSI_INSTRUMENT_MEM),
+ m_initialized(false),
+ m_external_init(external_init),
+ m_materialized(false),
+ m_show_var_array(PSI_INSTRUMENT_MEM),
+ m_version(0),
+ m_query_scope(OPT_DEFAULT),
+ m_use_mem_root(false),
+ m_aggregate(false)
+ { }
+
+ virtual ~PFS_variable_cache()= 0;
+
+ /**
+ Build array of SHOW_VARs from the external variable source.
+ Filter using session scope.
+ */
+ bool initialize_session(void);
+
+ /**
+ Build array of SHOW_VARs suitable for aggregation by user, host or account.
+ Filter using session scope.
+ */
+ bool initialize_client_session(void);
+
+ /**
+ Build cache of GLOBAL system or status variables.
+ Aggregate across threads if applicable.
+ */
+ int materialize_global();
+
+ /**
+ Build cache of GLOBAL and SESSION variables for a non-instrumented thread.
+ */
+ int materialize_all(THD *thd);
+
+ /**
+ Build cache of SESSION variables for a non-instrumented thread.
+ */
+ int materialize_session(THD *thd);
+
+ /**
+ Build cache of SESSION variables for an instrumented thread.
+ */
+ int materialize_session(PFS_thread *pfs_thread, bool use_mem_root= false);
+
+ /**
+ Cache a single SESSION variable for an instrumented thread.
+ */
+ int materialize_session(PFS_thread *pfs_thread, uint index);
+
+ /**
+ Build cache of SESSION status variables for a user.
+ */
+ int materialize_user(PFS_user *pfs_user);
+
+ /**
+ Build cache of SESSION status variables for a host.
+ */
+ int materialize_host(PFS_host *pfs_host);
+
+ /**
+ Build cache of SESSION status variables for an account.
+ */
+ int materialize_account(PFS_account *pfs_account);
+
+ /**
+ True if variables have been materialized.
+ */
+ bool is_materialized(void)
+ {
+ return m_materialized;
+ }
+
+ /**
+ True if variables have been materialized for given THD.
+ */
+ bool is_materialized(THD *unsafe_thd)
+ {
+ return (unsafe_thd == m_unsafe_thd && m_materialized);
+ }
+
+ /**
+ True if variables have been materialized for given PFS_thread.
+ */
+ bool is_materialized(PFS_thread *pfs_thread)
+ {
+ return (pfs_thread == m_pfs_thread && m_materialized);
+ }
+
+ /**
+ True if variables have been materialized for given PFS_user.
+ */
+ bool is_materialized(PFS_user *pfs_user)
+ {
+ return (static_cast<PFS_client *>(pfs_user) == m_pfs_client && m_materialized);
+ }
+
+ /**
+ True if variables have been materialized for given PFS_host.
+ */
+ bool is_materialized(PFS_host *pfs_host)
+ {
+ return (static_cast<PFS_client *>(pfs_host) == m_pfs_client && m_materialized);
+ }
+
+ /**
+ True if variables have been materialized for given PFS_account.
+ */
+ bool is_materialized(PFS_account *pfs_account)
+ {
+ return (static_cast<PFS_client *>(pfs_account) == m_pfs_client && m_materialized);
+ }
+
+ /**
+ True if variables have been materialized for given PFS_user/host/account.
+ */
+ bool is_materialized(PFS_client *pfs_client)
+ {
+ return (static_cast<PFS_client *>(pfs_client) == m_pfs_client && m_materialized);
+ }
+
+ /**
+ Get a validated THD from the thread manager. Execute callback function while
+ inside of the thread manager locks.
+ */
+ THD *get_THD(THD *thd);
+ THD *get_THD(PFS_thread *pfs_thread);
+
+ /**
+ Get a single variable from the cache.
+ Get the first element in the cache by default.
+ */
+ const Var_type *get(uint index= 0) const
+ {
+ if (index >= m_cache.elements())
+ return NULL;
+
+ const Var_type *p= &m_cache.at(index);
+ return p;
+ }
+
+ /**
+ Number of elements in the cache.
+ */
+ uint size()
+ {
+ return (uint)m_cache.elements();
+ }
+
+private:
+ virtual bool do_initialize_global(void) { return true; }
+ virtual bool do_initialize_session(void) { return true; }
+ virtual int do_materialize_global(void) { return 1; }
+ virtual int do_materialize_all(THD *thd) { return 1; }
+ virtual int do_materialize_session(THD *thd) { return 1; }
+ virtual int do_materialize_session(PFS_thread *) { return 1; }
+ virtual int do_materialize_session(PFS_thread *, uint index) { return 1; }
+
+protected:
+ /* Validated THD */
+ THD *m_safe_thd;
+
+ /* Unvalidated THD */
+ THD *m_unsafe_thd;
+
+ /* Current THD */
+ THD *m_current_thd;
+
+ /* Current PFS_thread. */
+ PFS_thread *m_pfs_thread;
+
+ /* Current PFS_user, host or account. */
+ PFS_client *m_pfs_client;
+
+ /* Callback for thread iterator. */
+ Find_THD_variable m_thd_finder;
+
+ /* Cache of materialized variables. */
+ Variable_array m_cache;
+
+ /* True when list of SHOW_VAR is complete. */
+ bool m_initialized;
+
+ /*
+ True if the SHOW_VAR array must be initialized externally from the
+ materialization step, such as with aggregations and queries by thread.
+ */
+ bool m_external_init;
+
+ /* True when cache is complete. */
+ bool m_materialized;
+
+ /* Array of variables to be materialized. Last element must be null. */
+ Dynamic_array<SHOW_VAR> m_show_var_array;
+
+ /* Version of global hash/array. Changes when vars added/removed. */
+ ulonglong m_version;
+
+ /* Query scope: GLOBAL or SESSION. */
+ enum_var_type m_query_scope;
+
+ /* True if temporary mem_root should be used for materialization. */
+ bool m_use_mem_root;
+
+ /* True if summarizing across users, hosts or accounts. */
+ bool m_aggregate;
+
+};
+
+/**
+ Required implementation for pure virtual destructor of a template class.
+*/
+template <class Var_type>
+PFS_variable_cache<Var_type>::~PFS_variable_cache()
+{
+}
+
+/**
+ Get a validated THD from the thread manager. Execute callback function while
+ while inside the thread manager lock.
+*/
+template <class Var_type>
+THD *PFS_variable_cache<Var_type>::get_THD(THD *unsafe_thd)
+{
+ if (unsafe_thd == NULL)
+ {
+ /*
+ May happen, precisely because the pointer is unsafe
+ (THD just disconnected for example).
+ No need to walk Global_THD_manager for that.
+ */
+ return NULL;
+ }
+
+ m_thd_finder.set_unsafe_thd(unsafe_thd);
+ THD* safe_thd= Global_THD_manager::get_instance()->find_thd(&m_thd_finder);
+ return safe_thd;
+}
+
+template <class Var_type>
+THD *PFS_variable_cache<Var_type>::get_THD(PFS_thread *pfs_thread)
+{
+ DBUG_ASSERT(pfs_thread != NULL);
+ return get_THD(pfs_thread->m_thd);
+}
+
+/**
+ Build array of SHOW_VARs from external source of system or status variables.
+ Filter using session scope.
+*/
+template <class Var_type>
+bool PFS_variable_cache<Var_type>::initialize_session(void)
+{
+ if (m_initialized)
+ return 0;
+
+ return do_initialize_session();
+}
+
+/**
+ Build array of SHOW_VARs suitable for aggregation by user, host or account.
+ Filter using session scope.
+*/
+template <class Var_type>
+bool PFS_variable_cache<Var_type>::initialize_client_session(void)
+{
+ if (m_initialized)
+ return 0;
+
+ /* Requires aggregation by user, host or account. */
+ m_aggregate= true;
+
+ return do_initialize_session();
+}
+
+/**
+ Build cache of all GLOBAL variables.
+*/
+template <class Var_type>
+int PFS_variable_cache<Var_type>::materialize_global()
+{
+ if (is_materialized())
+ return 0;
+
+ return do_materialize_global();
+}
+
+/**
+ Build cache of GLOBAL and SESSION variables for a non-instrumented thread.
+*/
+template <class Var_type>
+int PFS_variable_cache<Var_type>::materialize_all(THD *unsafe_thd)
+{
+ if (!unsafe_thd)
+ return 1;
+
+ if (is_materialized(unsafe_thd))
+ return 0;
+
+ return do_materialize_all(unsafe_thd);
+}
+
+/**
+ Build cache of SESSION variables for a non-instrumented thread.
+*/
+template <class Var_type>
+int PFS_variable_cache<Var_type>::materialize_session(THD *unsafe_thd)
+{
+ if (!unsafe_thd)
+ return 1;
+
+ if (is_materialized(unsafe_thd))
+ return 0;
+
+ return do_materialize_session(unsafe_thd);
+}
+
+/**
+ Build cache of SESSION variables for a thread.
+*/
+template <class Var_type>
+int PFS_variable_cache<Var_type>::materialize_session(PFS_thread *pfs_thread, bool use_mem_root)
+{
+ if (!pfs_thread)
+ return 1;
+
+ if (is_materialized(pfs_thread))
+ return 0;
+
+ if (!pfs_thread->m_lock.is_populated() || pfs_thread->m_thd == NULL)
+ return 1;
+
+ m_use_mem_root= use_mem_root;
+
+ return do_materialize_session(pfs_thread);
+}
+
+/**
+ Materialize a single variable for a thread.
+*/
+template <class Var_type>
+int PFS_variable_cache<Var_type>::materialize_session(PFS_thread *pfs_thread, uint index)
+{
+ /* No check for is_materialized(). */
+
+ if (!pfs_thread)
+ return 1;
+
+ if (!pfs_thread->m_lock.is_populated() || pfs_thread->m_thd == NULL)
+ return 1;
+
+ return do_materialize_session(pfs_thread, index);
+}
+
+/**
+ CLASS PFS_system_variable_cache - System variable cache.
+*/
+class PFS_system_variable_cache : public PFS_variable_cache<System_variable>
+{
+public:
+ PFS_system_variable_cache(bool external_init) :
+ PFS_variable_cache<System_variable>(external_init),
+ m_mem_thd(NULL), m_mem_thd_save(NULL),
+ m_mem_sysvar_ptr(NULL) { }
+ bool match_scope(int scope);
+ ulonglong get_sysvar_hash_version(void) { return m_version; }
+ ~PFS_system_variable_cache() { free_mem_root(); }
+
+private:
+ /* Build SHOW_var array. */
+ bool init_show_var_array(enum_var_type scope, bool strict);
+ bool do_initialize_session(void);
+
+ /* Global */
+ int do_materialize_global(void);
+ /* Global and Session - THD */
+ int do_materialize_all(THD* thd);
+ /* Session - THD */
+ int do_materialize_session(THD* thd);
+ /* Session - PFS_thread */
+ int do_materialize_session(PFS_thread *thread);
+ /* Single variable - PFS_thread */
+ int do_materialize_session(PFS_thread *pfs_thread, uint index);
+
+ /* Temporary mem_root to use for materialization. */
+ MEM_ROOT m_mem_sysvar;
+ /* Pointer to THD::mem_root. */
+ MEM_ROOT **m_mem_thd;
+ /* Save THD::mem_root. */
+ MEM_ROOT *m_mem_thd_save;
+ /* Pointer to temporary mem_root. */
+ MEM_ROOT *m_mem_sysvar_ptr;
+ /* Allocate and/or assign temporary mem_root. */
+ void set_mem_root(void);
+ /* Mark all memory blocks as free in temporary mem_root. */
+ void clear_mem_root(void);
+ /* Free mem_root memory. */
+ void free_mem_root(void);
+};
+
+
+/**
+ CLASS PFS_status_variable_cache - Status variable cache
+*/
+class PFS_status_variable_cache : public PFS_variable_cache<Status_variable>
+{
+public:
+ PFS_status_variable_cache(bool external_init);
+
+ int materialize_user(PFS_user *pfs_user);
+ int materialize_host(PFS_host *pfs_host);
+ int materialize_account(PFS_account *pfs_account);
+
+ ulonglong get_status_array_version(void) { return m_version; }
+
+protected:
+ /* Get PFS_user, account or host associated with a PFS_thread. Implemented by table class. */
+ virtual PFS_client *get_pfs(PFS_thread *pfs_thread) { return NULL; }
+
+ /* True if query is a SHOW command. */
+ bool m_show_command;
+
+private:
+ bool do_initialize_session(void);
+
+ int do_materialize_global(void);
+ /* Global and Session - THD */
+ int do_materialize_all(THD* thd);
+ int do_materialize_session(THD *thd);
+ int do_materialize_session(PFS_thread *thread);
+ int do_materialize_session(PFS_thread *thread, uint index) { return 0; }
+ int do_materialize_client(PFS_client *pfs_client);
+
+ /* Callback to sum user, host or account status variables. */
+ void (*m_sum_client_status)(PFS_client *pfs_client, STATUS_VAR *status_totals);
+
+ /* Build SHOW_VAR array from external source. */
+ bool init_show_var_array(enum_var_type scope, bool strict);
+
+ /* Recursively expand nested SHOW_VAR arrays. */
+ void expand_show_var_array(const SHOW_VAR *show_var_array, const char *prefix, bool strict);
+
+ /* Exclude unwanted variables from the query. */
+ bool filter_show_var(const SHOW_VAR *show_var, bool strict);
+
+ /* Check the variable scope against the query scope. */
+ bool match_scope(SHOW_SCOPE variable_scope, bool strict);
+
+ /* Exclude specific status variables by name or prefix. */
+ bool filter_by_name(const SHOW_VAR *show_var);
+
+ /* Check if a variable has an aggregatable type. */
+ bool can_aggregate(enum_mysql_show_type variable_type);
+
+ /* Build status variable name with prefix. Return in the buffer provided. */
+ char *make_show_var_name(const char* prefix, const char* name, char *name_buf, size_t buf_len);
+
+ /* Build status variable name with prefix. Return copy of the string. */
+ char *make_show_var_name(const char* prefix, const char* name);
+
+ /* For the current THD, use initial_status_vars taken from before the query start. */
+ STATUS_VAR *set_status_vars(void);
+
+ /* Build the list of status variables from SHOW_VAR array. */
+ void manifest(THD *thd, const SHOW_VAR *show_var_array,
+ STATUS_VAR *status_var_array, const char *prefix, bool nested_array, bool strict);
+};
+
+/* Callback functions to sum status variables for a given user, host or account. */
+void sum_user_status(PFS_client *pfs_user, STATUS_VAR *status_totals);
+void sum_host_status(PFS_client *pfs_host, STATUS_VAR *status_totals);
+void sum_account_status(PFS_client *pfs_account, STATUS_VAR *status_totals);
+
+
+/** @} */
+#endif
+
diff --git a/storage/perfschema/pfs_visitor.cc b/storage/perfschema/pfs_visitor.cc
new file mode 100644
index 00000000..638877d8
--- /dev/null
+++ b/storage/perfschema/pfs_visitor.cc
@@ -0,0 +1,1694 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#include "my_global.h"
+#include "my_sys.h"
+#include "pfs_visitor.h"
+#include "pfs_instr.h"
+#include "pfs_instr_class.h"
+#include "pfs_user.h"
+#include "pfs_host.h"
+#include "pfs_account.h"
+#include "pfs_buffer_container.h"
+
+#include "mysqld_thd_manager.h"
+
+/**
+ @file storage/perfschema/pfs_visitor.cc
+ Visitors (implementation).
+*/
+
+/**
+ @addtogroup Performance_schema_buffers
+ @{
+*/
+
+class All_THD_visitor_adapter : public Do_THD_Impl
+{
+public:
+ All_THD_visitor_adapter(PFS_connection_visitor *visitor)
+ : m_visitor(visitor)
+ {}
+
+ virtual void operator()(THD *thd)
+ {
+ m_visitor->visit_THD(thd);
+ }
+
+private:
+ PFS_connection_visitor *m_visitor;
+};
+
+/** Connection iterator */
+void PFS_connection_iterator::visit_global(bool with_hosts, bool with_users,
+ bool with_accounts, bool with_threads,
+ bool with_THDs,
+ PFS_connection_visitor *visitor)
+{
+ DBUG_ASSERT(visitor != NULL);
+ DBUG_ASSERT(! with_threads || ! with_THDs);
+
+ visitor->visit_global();
+
+ if (with_hosts)
+ {
+ PFS_host_iterator it= global_host_container.iterate();
+ PFS_host *pfs= it.scan_next();
+
+ while (pfs != NULL)
+ {
+ visitor->visit_host(pfs);
+ pfs= it.scan_next();
+ }
+ }
+
+ if (with_users)
+ {
+ PFS_user_iterator it= global_user_container.iterate();
+ PFS_user *pfs= it.scan_next();
+
+ while (pfs != NULL)
+ {
+ visitor->visit_user(pfs);
+ pfs= it.scan_next();
+ }
+ }
+
+ if (with_accounts)
+ {
+ PFS_account_iterator it= global_account_container.iterate();
+ PFS_account *pfs= it.scan_next();
+
+ while (pfs != NULL)
+ {
+ visitor->visit_account(pfs);
+ pfs= it.scan_next();
+ }
+ }
+
+
+ if (with_threads)
+ {
+ PFS_thread_iterator it= global_thread_container.iterate();
+ PFS_thread *pfs= it.scan_next();
+
+ while (pfs != NULL)
+ {
+ visitor->visit_thread(pfs);
+ pfs= it.scan_next();
+ }
+ }
+
+ if (with_THDs)
+ {
+ All_THD_visitor_adapter adapter(visitor);
+ Global_THD_manager::get_instance()->do_for_all_thd(& adapter);
+ }
+}
+
+class All_host_THD_visitor_adapter : public Do_THD_Impl
+{
+public:
+ All_host_THD_visitor_adapter(PFS_connection_visitor *visitor, PFS_host *host)
+ : m_visitor(visitor), m_host(host)
+ {}
+
+ virtual void operator()(THD *thd)
+ {
+ PSI_thread *psi= thd->get_psi();
+ PFS_thread *pfs= reinterpret_cast<PFS_thread*>(psi);
+ pfs= sanitize_thread(pfs);
+ if (pfs != NULL)
+ {
+ PFS_account *account= sanitize_account(pfs->m_account);
+ if (account != NULL)
+ {
+ if (account->m_host == m_host)
+ {
+ m_visitor->visit_THD(thd);
+ }
+ }
+ else if (pfs->m_host == m_host)
+ {
+ m_visitor->visit_THD(thd);
+ }
+ }
+ }
+
+private:
+ PFS_connection_visitor *m_visitor;
+ PFS_host *m_host;
+};
+
+void PFS_connection_iterator::visit_host(PFS_host *host,
+ bool with_accounts, bool with_threads,
+ bool with_THDs,
+ PFS_connection_visitor *visitor)
+{
+ DBUG_ASSERT(visitor != NULL);
+ DBUG_ASSERT(! with_threads || ! with_THDs);
+
+ visitor->visit_host(host);
+
+ if (with_accounts)
+ {
+ PFS_account_iterator it= global_account_container.iterate();
+ PFS_account *pfs= it.scan_next();
+
+ while (pfs != NULL)
+ {
+ if (pfs->m_host == host)
+ {
+ visitor->visit_account(pfs);
+ }
+ pfs= it.scan_next();
+ }
+ }
+
+ if (with_threads)
+ {
+ PFS_thread_iterator it= global_thread_container.iterate();
+ PFS_thread *pfs= it.scan_next();
+
+ while (pfs != NULL)
+ {
+ PFS_account *safe_account= sanitize_account(pfs->m_account);
+ if (((safe_account != NULL) && (safe_account->m_host == host)) /* 1 */
+ || (pfs->m_host == host)) /* 2 */
+ {
+ /*
+ If the thread belongs to:
+ - (1) a known user@host that belongs to this host,
+ - (2) a 'lost' user@host that belongs to this host
+ process it.
+ */
+ visitor->visit_thread(pfs);
+ }
+ pfs= it.scan_next();
+ }
+ }
+
+ if (with_THDs)
+ {
+ All_host_THD_visitor_adapter adapter(visitor, host);
+ Global_THD_manager::get_instance()->do_for_all_thd(& adapter);
+ }
+}
+
+class All_user_THD_visitor_adapter : public Do_THD_Impl
+{
+public:
+ All_user_THD_visitor_adapter(PFS_connection_visitor *visitor, PFS_user *user)
+ : m_visitor(visitor), m_user(user)
+ {}
+
+ virtual void operator()(THD *thd)
+ {
+ PSI_thread *psi= thd->get_psi();
+ PFS_thread *pfs= reinterpret_cast<PFS_thread*>(psi);
+ pfs= sanitize_thread(pfs);
+ if (pfs != NULL)
+ {
+ PFS_account *account= sanitize_account(pfs->m_account);
+ if (account != NULL)
+ {
+ if (account->m_user == m_user)
+ {
+ m_visitor->visit_THD(thd);
+ }
+ }
+ else if (pfs->m_user == m_user)
+ {
+ m_visitor->visit_THD(thd);
+ }
+ }
+ }
+
+private:
+ PFS_connection_visitor *m_visitor;
+ PFS_user *m_user;
+};
+
+void PFS_connection_iterator::visit_user(PFS_user *user,
+ bool with_accounts, bool with_threads,
+ bool with_THDs,
+ PFS_connection_visitor *visitor)
+{
+ DBUG_ASSERT(visitor != NULL);
+ DBUG_ASSERT(! with_threads || ! with_THDs);
+
+ visitor->visit_user(user);
+
+ if (with_accounts)
+ {
+ PFS_account_iterator it= global_account_container.iterate();
+ PFS_account *pfs= it.scan_next();
+
+ while (pfs != NULL)
+ {
+ if (pfs->m_user == user)
+ {
+ visitor->visit_account(pfs);
+ }
+ pfs= it.scan_next();
+ }
+ }
+
+ if (with_threads)
+ {
+ PFS_thread_iterator it= global_thread_container.iterate();
+ PFS_thread *pfs= it.scan_next();
+
+ while (pfs != NULL)
+ {
+ PFS_account *safe_account= sanitize_account(pfs->m_account);
+ if (((safe_account != NULL) && (safe_account->m_user == user)) /* 1 */
+ || (pfs->m_user == user)) /* 2 */
+ {
+ /*
+ If the thread belongs to:
+ - (1) a known user@host that belongs to this user,
+ - (2) a 'lost' user@host that belongs to this user
+ process it.
+ */
+ visitor->visit_thread(pfs);
+ }
+ pfs= it.scan_next();
+ }
+ }
+
+ if (with_THDs)
+ {
+ All_user_THD_visitor_adapter adapter(visitor, user);
+ Global_THD_manager::get_instance()->do_for_all_thd(& adapter);
+ }
+}
+
+class All_account_THD_visitor_adapter : public Do_THD_Impl
+{
+public:
+ All_account_THD_visitor_adapter(PFS_connection_visitor *visitor, PFS_account *account)
+ : m_visitor(visitor), m_account(account)
+ {}
+
+ virtual void operator()(THD *thd)
+ {
+ PSI_thread *psi= thd->get_psi();
+ PFS_thread *pfs= reinterpret_cast<PFS_thread*>(psi);
+ pfs= sanitize_thread(pfs);
+ if (pfs != NULL)
+ {
+ if (pfs->m_account == m_account)
+ {
+ m_visitor->visit_THD(thd);
+ }
+ }
+ }
+
+private:
+ PFS_connection_visitor *m_visitor;
+ PFS_account *m_account;
+};
+
+void PFS_connection_iterator::visit_account(PFS_account *account,
+ bool with_threads,
+ bool with_THDs,
+ PFS_connection_visitor *visitor)
+{
+ DBUG_ASSERT(visitor != NULL);
+ DBUG_ASSERT(! with_threads || ! with_THDs);
+
+ visitor->visit_account(account);
+
+ if (with_threads)
+ {
+ PFS_thread_iterator it= global_thread_container.iterate();
+ PFS_thread *pfs= it.scan_next();
+
+ while (pfs != NULL)
+ {
+ if (pfs->m_account == account)
+ {
+ visitor->visit_thread(pfs);
+ }
+ pfs= it.scan_next();
+ }
+ }
+
+ if (with_THDs)
+ {
+ All_account_THD_visitor_adapter adapter(visitor, account);
+ Global_THD_manager::get_instance()->do_for_all_thd(& adapter);
+ }
+}
+
+void PFS_connection_iterator::visit_THD(THD *thd,
+ PFS_connection_visitor *visitor)
+{
+ DBUG_ASSERT(visitor != NULL);
+ visitor->visit_THD(thd);
+}
+
+void PFS_instance_iterator::visit_all(PFS_instance_visitor *visitor)
+{
+ visit_all_mutex(visitor);
+ visit_all_rwlock(visitor);
+ visit_all_cond(visitor);
+ visit_all_file(visitor);
+}
+
+void PFS_instance_iterator::visit_all_mutex(PFS_instance_visitor *visitor)
+{
+ visit_all_mutex_classes(visitor);
+ visit_all_mutex_instances(visitor);
+}
+
+void PFS_instance_iterator::visit_all_mutex_classes(PFS_instance_visitor *visitor)
+{
+ PFS_mutex_class *pfs= mutex_class_array;
+ PFS_mutex_class *pfs_last= pfs + mutex_class_max;
+ for ( ; pfs < pfs_last; pfs++)
+ {
+ if (pfs->m_name_length != 0)
+ {
+ visitor->visit_mutex_class(pfs);
+ }
+ }
+}
+
+void PFS_instance_iterator::visit_all_mutex_instances(PFS_instance_visitor *visitor)
+{
+ PFS_mutex_iterator it= global_mutex_container.iterate();
+ PFS_mutex *pfs= it.scan_next();
+
+ while (pfs != NULL)
+ {
+ visitor->visit_mutex(pfs);
+ pfs= it.scan_next();
+ }
+}
+
+void PFS_instance_iterator::visit_all_rwlock(PFS_instance_visitor *visitor)
+{
+ visit_all_rwlock_classes(visitor);
+ visit_all_rwlock_instances(visitor);
+}
+
+void PFS_instance_iterator::visit_all_rwlock_classes(PFS_instance_visitor *visitor)
+{
+ PFS_rwlock_class *pfs= rwlock_class_array;
+ PFS_rwlock_class *pfs_last= pfs + rwlock_class_max;
+ for ( ; pfs < pfs_last; pfs++)
+ {
+ if (pfs->m_name_length != 0)
+ {
+ visitor->visit_rwlock_class(pfs);
+ }
+ }
+}
+
+void PFS_instance_iterator::visit_all_rwlock_instances(PFS_instance_visitor *visitor)
+{
+ PFS_rwlock_iterator it= global_rwlock_container.iterate();
+ PFS_rwlock *pfs= it.scan_next();
+
+ while (pfs != NULL)
+ {
+ visitor->visit_rwlock(pfs);
+ pfs= it.scan_next();
+ }
+}
+
+void PFS_instance_iterator::visit_all_cond(PFS_instance_visitor *visitor)
+{
+ visit_all_cond_classes(visitor);
+ visit_all_cond_instances(visitor);
+}
+
+void PFS_instance_iterator::visit_all_cond_classes(PFS_instance_visitor *visitor)
+{
+ PFS_cond_class *pfs= cond_class_array;
+ PFS_cond_class *pfs_last= pfs + cond_class_max;
+ for ( ; pfs < pfs_last; pfs++)
+ {
+ if (pfs->m_name_length != 0)
+ {
+ visitor->visit_cond_class(pfs);
+ }
+ }
+}
+
+void PFS_instance_iterator::visit_all_cond_instances(PFS_instance_visitor *visitor)
+{
+ PFS_cond_iterator it= global_cond_container.iterate();
+ PFS_cond *pfs= it.scan_next();
+
+ while (pfs != NULL)
+ {
+ visitor->visit_cond(pfs);
+ pfs= it.scan_next();
+ }
+}
+
+void PFS_instance_iterator::visit_all_file(PFS_instance_visitor *visitor)
+{
+ visit_all_file_classes(visitor);
+ visit_all_file_instances(visitor);
+}
+
+void PFS_instance_iterator::visit_all_file_classes(PFS_instance_visitor *visitor)
+{
+ PFS_file_class *pfs= file_class_array;
+ PFS_file_class *pfs_last= pfs + file_class_max;
+ for ( ; pfs < pfs_last; pfs++)
+ {
+ if (pfs->m_name_length != 0)
+ {
+ visitor->visit_file_class(pfs);
+ }
+ }
+}
+
+void PFS_instance_iterator::visit_all_file_instances(PFS_instance_visitor *visitor)
+{
+ PFS_file_iterator it= global_file_container.iterate();
+ PFS_file *pfs= it.scan_next();
+
+ while (pfs != NULL)
+ {
+ visitor->visit_file(pfs);
+ pfs= it.scan_next();
+ }
+}
+
+/** Instance iterator */
+
+void PFS_instance_iterator::visit_mutex_instances(PFS_mutex_class *klass,
+ PFS_instance_visitor *visitor)
+{
+ DBUG_ASSERT(visitor != NULL);
+
+ visitor->visit_mutex_class(klass);
+
+ if (klass->is_singleton())
+ {
+ PFS_mutex *pfs= sanitize_mutex(klass->m_singleton);
+ if (likely(pfs != NULL))
+ {
+ if (likely(pfs->m_lock.is_populated()))
+ {
+ visitor->visit_mutex(pfs);
+ }
+ }
+ }
+ else
+ {
+ PFS_mutex_iterator it= global_mutex_container.iterate();
+ PFS_mutex *pfs= it.scan_next();
+
+ while (pfs != NULL)
+ {
+ if (pfs->m_class == klass)
+ {
+ visitor->visit_mutex(pfs);
+ }
+ pfs= it.scan_next();
+ }
+ }
+}
+
+void PFS_instance_iterator::visit_rwlock_instances(PFS_rwlock_class *klass,
+ PFS_instance_visitor *visitor)
+{
+ DBUG_ASSERT(visitor != NULL);
+
+ visitor->visit_rwlock_class(klass);
+
+ if (klass->is_singleton())
+ {
+ PFS_rwlock *pfs= sanitize_rwlock(klass->m_singleton);
+ if (likely(pfs != NULL))
+ {
+ if (likely(pfs->m_lock.is_populated()))
+ {
+ visitor->visit_rwlock(pfs);
+ }
+ }
+ }
+ else
+ {
+ PFS_rwlock_iterator it= global_rwlock_container.iterate();
+ PFS_rwlock *pfs= it.scan_next();
+
+ while (pfs != NULL)
+ {
+ if (pfs->m_class == klass)
+ {
+ visitor->visit_rwlock(pfs);
+ }
+ pfs= it.scan_next();
+ }
+ }
+}
+
+void PFS_instance_iterator::visit_cond_instances(PFS_cond_class *klass,
+ PFS_instance_visitor *visitor)
+{
+ DBUG_ASSERT(visitor != NULL);
+
+ visitor->visit_cond_class(klass);
+
+ if (klass->is_singleton())
+ {
+ PFS_cond *pfs= sanitize_cond(klass->m_singleton);
+ if (likely(pfs != NULL))
+ {
+ if (likely(pfs->m_lock.is_populated()))
+ {
+ visitor->visit_cond(pfs);
+ }
+ }
+ }
+ else
+ {
+ PFS_cond_iterator it= global_cond_container.iterate();
+ PFS_cond *pfs= it.scan_next();
+
+ while (pfs != NULL)
+ {
+ if (pfs->m_class == klass)
+ {
+ visitor->visit_cond(pfs);
+ }
+ pfs= it.scan_next();
+ }
+ }
+}
+
+void PFS_instance_iterator::visit_file_instances(PFS_file_class *klass,
+ PFS_instance_visitor *visitor)
+{
+ DBUG_ASSERT(visitor != NULL);
+
+ visitor->visit_file_class(klass);
+
+ if (klass->is_singleton())
+ {
+ PFS_file *pfs= sanitize_file(klass->m_singleton);
+ if (likely(pfs != NULL))
+ {
+ if (likely(pfs->m_lock.is_populated()))
+ {
+ visitor->visit_file(pfs);
+ }
+ }
+ }
+ else
+ {
+ PFS_file_iterator it= global_file_container.iterate();
+ PFS_file *pfs= it.scan_next();
+
+ while (pfs != NULL)
+ {
+ if (pfs->m_class == klass)
+ {
+ visitor->visit_file(pfs);
+ }
+ pfs= it.scan_next();
+ }
+ }
+}
+
+/** Socket instance iterator visting a socket class and all instances */
+
+void PFS_instance_iterator::visit_socket_instances(PFS_socket_class *klass,
+ PFS_instance_visitor *visitor)
+{
+ DBUG_ASSERT(visitor != NULL);
+
+ visitor->visit_socket_class(klass);
+
+ if (klass->is_singleton())
+ {
+ PFS_socket *pfs= sanitize_socket(klass->m_singleton);
+ if (likely(pfs != NULL))
+ {
+ if (likely(pfs->m_lock.is_populated()))
+ {
+ visitor->visit_socket(pfs);
+ }
+ }
+ }
+ else
+ {
+ PFS_socket_iterator it= global_socket_container.iterate();
+ PFS_socket *pfs= it.scan_next();
+
+ while (pfs != NULL)
+ {
+ if (pfs->m_class == klass)
+ {
+ visitor->visit_socket(pfs);
+ }
+ pfs= it.scan_next();
+ }
+ }
+}
+
+/** Socket instance iterator visting sockets owned by PFS_thread. */
+
+void PFS_instance_iterator::visit_socket_instances(PFS_socket_class *klass,
+ PFS_instance_visitor *visitor,
+ PFS_thread *thread,
+ bool visit_class)
+{
+ DBUG_ASSERT(visitor != NULL);
+ DBUG_ASSERT(thread != NULL);
+
+ if (visit_class)
+ visitor->visit_socket_class(klass);
+
+ if (klass->is_singleton())
+ {
+ PFS_socket *pfs= sanitize_socket(klass->m_singleton);
+ if (likely(pfs != NULL))
+ {
+ if (unlikely(pfs->m_thread_owner == thread))
+ visitor->visit_socket(pfs);
+ }
+ }
+ else
+ {
+ /* Get current socket stats from each socket instance owned by this thread */
+ PFS_socket_iterator it= global_socket_container.iterate();
+ PFS_socket *pfs= it.scan_next();
+
+ while (pfs != NULL)
+ {
+ if (unlikely((pfs->m_class == klass) &&
+ (pfs->m_thread_owner == thread)))
+ {
+ visitor->visit_socket(pfs);
+ }
+ pfs= it.scan_next();
+ }
+ }
+}
+
+/** Generic instance iterator with PFS_thread as matching criteria */
+
+void PFS_instance_iterator::visit_instances(PFS_instr_class *klass,
+ PFS_instance_visitor *visitor,
+ PFS_thread *thread,
+ bool visit_class)
+{
+ DBUG_ASSERT(visitor != NULL);
+ DBUG_ASSERT(klass != NULL);
+
+ switch (klass->m_type)
+ {
+ case PFS_CLASS_SOCKET:
+ {
+ PFS_socket_class *socket_class= reinterpret_cast<PFS_socket_class*>(klass);
+ PFS_instance_iterator::visit_socket_instances(socket_class, visitor,
+ thread, visit_class);
+ }
+ break;
+ default:
+ break;
+ }
+}
+
+/** Object iterator */
+void PFS_object_iterator::visit_all(PFS_object_visitor *visitor)
+{
+ visit_all_tables(visitor);
+}
+
+class Proc_all_table_shares
+ : public PFS_buffer_processor<PFS_table_share>
+{
+public:
+ Proc_all_table_shares(PFS_object_visitor *visitor)
+ : m_visitor(visitor)
+ {}
+
+ virtual void operator()(PFS_table_share *pfs)
+ {
+ if (pfs->m_enabled)
+ {
+ m_visitor->visit_table_share(pfs);
+ }
+ }
+
+private:
+ PFS_object_visitor* m_visitor;
+};
+
+class Proc_all_table_handles
+ : public PFS_buffer_processor<PFS_table>
+{
+public:
+ Proc_all_table_handles(PFS_object_visitor *visitor)
+ : m_visitor(visitor)
+ {}
+
+ virtual void operator()(PFS_table *pfs)
+ {
+ PFS_table_share *safe_share= sanitize_table_share(pfs->m_share);
+ if (safe_share != NULL)
+ {
+ if (safe_share->m_enabled)
+ {
+ m_visitor->visit_table(pfs);
+ }
+ }
+ }
+
+private:
+ PFS_object_visitor* m_visitor;
+};
+
+void PFS_object_iterator::visit_all_tables(PFS_object_visitor *visitor)
+{
+ DBUG_ASSERT(visitor != NULL);
+
+ visitor->visit_global();
+
+ /* For all the table shares ... */
+ Proc_all_table_shares proc_shares(visitor);
+ global_table_share_container.apply(proc_shares);
+
+ /* For all the table handles ... */
+ Proc_all_table_handles proc_handles(visitor);
+ global_table_container.apply(proc_handles);
+}
+
+class Proc_one_table_share_handles
+ : public PFS_buffer_processor<PFS_table>
+{
+public:
+ Proc_one_table_share_handles(PFS_object_visitor *visitor, PFS_table_share *share)
+ : m_visitor(visitor), m_share(share)
+ {}
+
+ virtual void operator()(PFS_table *pfs)
+ {
+ if (pfs->m_share == m_share)
+ {
+ m_visitor->visit_table(pfs);
+ }
+ }
+
+private:
+ PFS_object_visitor* m_visitor;
+ PFS_table_share* m_share;
+};
+
+void PFS_object_iterator::visit_tables(PFS_table_share *share,
+ PFS_object_visitor *visitor)
+{
+ DBUG_ASSERT(visitor != NULL);
+
+ if (!share->m_enabled)
+ return;
+
+ visitor->visit_table_share(share);
+
+#ifdef LATER
+ if (share->get_refcount() == 0)
+ return;
+#endif
+
+ /* For all the table handles ... */
+ Proc_one_table_share_handles proc(visitor, share);
+ global_table_container.apply(proc);
+}
+
+class Proc_one_table_share_indexes
+ : public PFS_buffer_processor<PFS_table>
+{
+public:
+ Proc_one_table_share_indexes(PFS_object_visitor *visitor, PFS_table_share *share, uint index)
+ : m_visitor(visitor), m_share(share), m_index(index)
+ {}
+
+ virtual void operator()(PFS_table *pfs)
+ {
+ if (pfs->m_share == m_share)
+ {
+ m_visitor->visit_table_index(pfs, m_index);
+ }
+ }
+
+private:
+ PFS_object_visitor* m_visitor;
+ PFS_table_share* m_share;
+ uint m_index;
+};
+
+void PFS_object_iterator::visit_table_indexes(PFS_table_share *share,
+ uint index,
+ PFS_object_visitor *visitor)
+{
+ DBUG_ASSERT(visitor != NULL);
+
+ if (!share->m_enabled)
+ return;
+
+ visitor->visit_table_share_index(share, index);
+
+#ifdef LATER
+ if (share->get_refcount() == 0)
+ return;
+#endif
+
+ /* For all the table handles ... */
+ Proc_one_table_share_indexes proc(visitor, share, index);
+ global_table_container.apply(proc);
+}
+
+/** Connection wait visitor */
+
+PFS_connection_wait_visitor
+::PFS_connection_wait_visitor(PFS_instr_class *klass)
+{
+ m_index= klass->m_event_name_index;
+}
+
+PFS_connection_wait_visitor::~PFS_connection_wait_visitor()
+{}
+
+void PFS_connection_wait_visitor::visit_global()
+{
+ /*
+ This visitor is used only for global instruments
+ that do not have instances.
+ For waits, do not sum by connection but by instances,
+ it is more efficient.
+ */
+ DBUG_ASSERT( (m_index == global_idle_class.m_event_name_index)
+ || (m_index == global_metadata_class.m_event_name_index));
+
+ if (m_index == global_idle_class.m_event_name_index)
+ {
+ m_stat.aggregate(& global_idle_stat);
+ }
+ else
+ {
+ m_stat.aggregate(& global_metadata_stat);
+ }
+}
+
+void PFS_connection_wait_visitor::visit_host(PFS_host *pfs)
+{
+ const PFS_single_stat *event_name_array;
+ event_name_array= pfs->read_instr_class_waits_stats();
+ if (event_name_array != NULL)
+ {
+ m_stat.aggregate(& event_name_array[m_index]);
+ }
+}
+
+void PFS_connection_wait_visitor::visit_user(PFS_user *pfs)
+{
+ const PFS_single_stat *event_name_array;
+ event_name_array= pfs->read_instr_class_waits_stats();
+ if (event_name_array != NULL)
+ {
+ m_stat.aggregate(& event_name_array[m_index]);
+ }
+}
+
+void PFS_connection_wait_visitor::visit_account(PFS_account *pfs)
+{
+ const PFS_single_stat *event_name_array;
+ event_name_array= pfs->read_instr_class_waits_stats();
+ if (event_name_array != NULL)
+ {
+ m_stat.aggregate(& event_name_array[m_index]);
+ }
+}
+
+void PFS_connection_wait_visitor::visit_thread(PFS_thread *pfs)
+{
+ const PFS_single_stat *event_name_array;
+ event_name_array= pfs->read_instr_class_waits_stats();
+ if (event_name_array != NULL)
+ {
+ m_stat.aggregate(& event_name_array[m_index]);
+ }
+}
+
+PFS_connection_all_wait_visitor
+::PFS_connection_all_wait_visitor()
+{}
+
+PFS_connection_all_wait_visitor::~PFS_connection_all_wait_visitor()
+{}
+
+void PFS_connection_all_wait_visitor::visit_global()
+{
+ /* Sum by instances, not by connection */
+ DBUG_ASSERT(false);
+}
+
+void PFS_connection_all_wait_visitor::visit_connection_slice(PFS_connection_slice *pfs)
+{
+ const PFS_single_stat *stat= pfs->read_instr_class_waits_stats();
+ if (stat != NULL)
+ {
+ const PFS_single_stat *stat_last= stat + wait_class_max;
+ for ( ; stat < stat_last; stat++)
+ {
+ m_stat.aggregate(stat);
+ }
+ }
+}
+
+void PFS_connection_all_wait_visitor::visit_host(PFS_host *pfs)
+{
+ visit_connection_slice(pfs);
+}
+
+void PFS_connection_all_wait_visitor::visit_user(PFS_user *pfs)
+{
+ visit_connection_slice(pfs);
+}
+
+void PFS_connection_all_wait_visitor::visit_account(PFS_account *pfs)
+{
+ visit_connection_slice(pfs);
+}
+
+void PFS_connection_all_wait_visitor::visit_thread(PFS_thread *pfs)
+{
+ visit_connection_slice(pfs);
+}
+
+PFS_connection_stage_visitor::PFS_connection_stage_visitor(PFS_stage_class *klass)
+{
+ m_index= klass->m_event_name_index;
+}
+
+PFS_connection_stage_visitor::~PFS_connection_stage_visitor()
+{}
+
+void PFS_connection_stage_visitor::visit_global()
+{
+ m_stat.aggregate(& global_instr_class_stages_array[m_index]);
+}
+
+void PFS_connection_stage_visitor::visit_host(PFS_host *pfs)
+{
+ const PFS_stage_stat *event_name_array;
+ event_name_array= pfs->read_instr_class_stages_stats();
+ if (event_name_array != NULL)
+ {
+ m_stat.aggregate(& event_name_array[m_index]);
+ }
+}
+
+void PFS_connection_stage_visitor::visit_user(PFS_user *pfs)
+{
+ const PFS_stage_stat *event_name_array;
+ event_name_array= pfs->read_instr_class_stages_stats();
+ if (event_name_array != NULL)
+ {
+ m_stat.aggregate(& event_name_array[m_index]);
+ }
+}
+
+void PFS_connection_stage_visitor::visit_account(PFS_account *pfs)
+{
+ const PFS_stage_stat *event_name_array;
+ event_name_array= pfs->read_instr_class_stages_stats();
+ if (event_name_array != NULL)
+ {
+ m_stat.aggregate(& event_name_array[m_index]);
+ }
+}
+
+void PFS_connection_stage_visitor::visit_thread(PFS_thread *pfs)
+{
+ const PFS_stage_stat *event_name_array;
+ event_name_array= pfs->read_instr_class_stages_stats();
+ if (event_name_array != NULL)
+ {
+ m_stat.aggregate(& event_name_array[m_index]);
+ }
+}
+
+PFS_connection_statement_visitor
+::PFS_connection_statement_visitor(PFS_statement_class *klass)
+{
+ m_index= klass->m_event_name_index;
+}
+
+PFS_connection_statement_visitor::~PFS_connection_statement_visitor()
+{}
+
+void PFS_connection_statement_visitor::visit_global()
+{
+ m_stat.aggregate(& global_instr_class_statements_array[m_index]);
+}
+
+void PFS_connection_statement_visitor::visit_host(PFS_host *pfs)
+{
+ const PFS_statement_stat *event_name_array;
+ event_name_array= pfs->read_instr_class_statements_stats();
+ if (event_name_array != NULL)
+ {
+ m_stat.aggregate(& event_name_array[m_index]);
+ }
+}
+
+void PFS_connection_statement_visitor::visit_user(PFS_user *pfs)
+{
+ const PFS_statement_stat *event_name_array;
+ event_name_array= pfs->read_instr_class_statements_stats();
+ if (event_name_array != NULL)
+ {
+ m_stat.aggregate(& event_name_array[m_index]);
+ }
+}
+
+void PFS_connection_statement_visitor::visit_account(PFS_account *pfs)
+{
+ const PFS_statement_stat *event_name_array;
+ event_name_array= pfs->read_instr_class_statements_stats();
+ if (event_name_array != NULL)
+ {
+ m_stat.aggregate(& event_name_array[m_index]);
+ }
+}
+
+void PFS_connection_statement_visitor::visit_thread(PFS_thread *pfs)
+{
+ const PFS_statement_stat *event_name_array;
+ event_name_array= pfs->read_instr_class_statements_stats();
+ if (event_name_array != NULL)
+ {
+ m_stat.aggregate(& event_name_array[m_index]);
+ }
+}
+
+/** Instance wait visitor */
+PFS_connection_all_statement_visitor
+::PFS_connection_all_statement_visitor()
+{}
+
+PFS_connection_all_statement_visitor::~PFS_connection_all_statement_visitor()
+{}
+
+void PFS_connection_all_statement_visitor::visit_global()
+{
+ PFS_statement_stat *stat= global_instr_class_statements_array;
+ PFS_statement_stat *stat_last= stat + statement_class_max;
+ for ( ; stat < stat_last; stat++)
+ {
+ m_stat.aggregate(stat);
+ }
+}
+
+void PFS_connection_all_statement_visitor::visit_connection_slice(PFS_connection_slice *pfs)
+{
+ const PFS_statement_stat *stat= pfs->read_instr_class_statements_stats();
+ if (stat != NULL)
+ {
+ const PFS_statement_stat *stat_last= stat + statement_class_max;
+ for ( ; stat < stat_last; stat++)
+ {
+ m_stat.aggregate(stat);
+ }
+ }
+}
+
+void PFS_connection_all_statement_visitor::visit_host(PFS_host *pfs)
+{
+ visit_connection_slice(pfs);
+}
+
+void PFS_connection_all_statement_visitor::visit_user(PFS_user *pfs)
+{
+ visit_connection_slice(pfs);
+}
+
+void PFS_connection_all_statement_visitor::visit_account(PFS_account *pfs)
+{
+ visit_connection_slice(pfs);
+}
+
+void PFS_connection_all_statement_visitor::visit_thread(PFS_thread *pfs)
+{
+ visit_connection_slice(pfs);
+}
+
+PFS_connection_transaction_visitor
+::PFS_connection_transaction_visitor(PFS_transaction_class *klass)
+{
+ m_index= klass->m_event_name_index;
+}
+
+PFS_connection_transaction_visitor::~PFS_connection_transaction_visitor()
+{}
+
+void PFS_connection_transaction_visitor::visit_global()
+{
+ m_stat.aggregate(&global_transaction_stat);
+}
+
+void PFS_connection_transaction_visitor::visit_host(PFS_host *pfs)
+{
+ const PFS_transaction_stat *event_name_array;
+ event_name_array= pfs->read_instr_class_transactions_stats();
+ if (event_name_array != NULL)
+ {
+ m_stat.aggregate(& event_name_array[m_index]);
+ }
+}
+
+void PFS_connection_transaction_visitor::visit_user(PFS_user *pfs)
+{
+ const PFS_transaction_stat *event_name_array;
+ event_name_array= pfs->read_instr_class_transactions_stats();
+ if (event_name_array != NULL)
+ {
+ m_stat.aggregate(& event_name_array[m_index]);
+ }
+}
+
+void PFS_connection_transaction_visitor::visit_account(PFS_account *pfs)
+{
+ const PFS_transaction_stat *event_name_array;
+ event_name_array= pfs->read_instr_class_transactions_stats();
+ if (event_name_array != NULL)
+ {
+ m_stat.aggregate(& event_name_array[m_index]);
+ }
+}
+
+void PFS_connection_transaction_visitor::visit_thread(PFS_thread *pfs)
+{
+ const PFS_transaction_stat *event_name_array;
+ event_name_array= pfs->read_instr_class_transactions_stats();
+ if (event_name_array != NULL)
+ {
+ m_stat.aggregate(& event_name_array[m_index]);
+ }
+}
+
+/** Disabled pending code review */
+#if 0
+/** Instance wait visitor */
+PFS_connection_all_transaction_visitor
+::PFS_connection_all_transaction_visitor()
+{}
+
+PFS_connection_all_transaction_visitor::~PFS_connection_all_transaction_visitor()
+{}
+
+void PFS_connection_all_transaction_visitor::visit_global()
+{
+ m_stat.aggregate(&global_transaction_stat);
+}
+
+void PFS_connection_all_transaction_visitor::visit_connection_slice(PFS_connection_slice *pfs)
+{
+ PFS_transaction_stat *stat= pfs->m_instr_class_transactions_stats;
+ m_stat.aggregate(stat);
+}
+
+void PFS_connection_all_transaction_visitor::visit_host(PFS_host *pfs)
+{
+ visit_connection_slice(pfs);
+}
+
+void PFS_connection_all_transaction_visitor::visit_user(PFS_user *pfs)
+{
+ visit_connection_slice(pfs);
+}
+
+void PFS_connection_all_transaction_visitor::visit_account(PFS_account *pfs)
+{
+ visit_connection_slice(pfs);
+}
+
+void PFS_connection_all_transaction_visitor::visit_thread(PFS_thread *pfs)
+{
+ visit_connection_slice(pfs);
+}
+#endif
+
+PFS_connection_stat_visitor::PFS_connection_stat_visitor()
+{}
+
+PFS_connection_stat_visitor::~PFS_connection_stat_visitor()
+{}
+
+void PFS_connection_stat_visitor::visit_global()
+{}
+
+void PFS_connection_stat_visitor::visit_host(PFS_host *pfs)
+{
+ m_stat.aggregate_disconnected(pfs->m_disconnected_count);
+}
+
+void PFS_connection_stat_visitor::visit_user(PFS_user *pfs)
+{
+ m_stat.aggregate_disconnected(pfs->m_disconnected_count);
+}
+
+void PFS_connection_stat_visitor::visit_account(PFS_account *pfs)
+{
+ m_stat.aggregate_disconnected(pfs->m_disconnected_count);
+}
+
+void PFS_connection_stat_visitor::visit_thread(PFS_thread *)
+{
+ m_stat.aggregate_active(1);
+}
+
+PFS_connection_memory_visitor
+::PFS_connection_memory_visitor(PFS_memory_class *klass)
+{
+ m_index= klass->m_event_name_index;
+ m_stat.reset();
+}
+
+PFS_connection_memory_visitor::~PFS_connection_memory_visitor()
+{}
+
+void PFS_connection_memory_visitor::visit_global()
+{
+ PFS_memory_stat *stat;
+ stat= & global_instr_class_memory_array[m_index];
+ stat->full_aggregate_to(& m_stat);
+}
+
+void PFS_connection_memory_visitor::visit_host(PFS_host *pfs)
+{
+ const PFS_memory_stat *event_name_array;
+ event_name_array= pfs->read_instr_class_memory_stats();
+ if (event_name_array != NULL)
+ {
+ const PFS_memory_stat *stat;
+ stat= & event_name_array[m_index];
+ stat->full_aggregate_to(& m_stat);
+ }
+}
+
+void PFS_connection_memory_visitor::visit_user(PFS_user *pfs)
+{
+ const PFS_memory_stat *event_name_array;
+ event_name_array= pfs->read_instr_class_memory_stats();
+ if (event_name_array != NULL)
+ {
+ const PFS_memory_stat *stat;
+ stat= & event_name_array[m_index];
+ stat->full_aggregate_to(& m_stat);
+ }
+}
+
+void PFS_connection_memory_visitor::visit_account(PFS_account *pfs)
+{
+ const PFS_memory_stat *event_name_array;
+ event_name_array= pfs->read_instr_class_memory_stats();
+ if (event_name_array != NULL)
+ {
+ const PFS_memory_stat *stat;
+ stat= & event_name_array[m_index];
+ stat->full_aggregate_to(& m_stat);
+ }
+}
+
+void PFS_connection_memory_visitor::visit_thread(PFS_thread *pfs)
+{
+ const PFS_memory_stat *event_name_array;
+ event_name_array= pfs->read_instr_class_memory_stats();
+ if (event_name_array != NULL)
+ {
+ const PFS_memory_stat *stat;
+ stat= & event_name_array[m_index];
+ stat->full_aggregate_to(& m_stat);
+ }
+}
+
+
+PFS_connection_status_visitor::
+PFS_connection_status_visitor(STATUS_VAR *status_vars) : m_status_vars(status_vars)
+{
+ memset(m_status_vars, 0, sizeof(STATUS_VAR));
+}
+
+PFS_connection_status_visitor::~PFS_connection_status_visitor()
+{}
+
+/** Aggregate from global status. */
+void PFS_connection_status_visitor::visit_global()
+{
+ /* NOTE: Requires lock on LOCK_status. */
+ mysql_mutex_assert_owner(&LOCK_status);
+ add_to_status(m_status_vars, &global_status_var);
+}
+
+void PFS_connection_status_visitor::visit_host(PFS_host *pfs)
+{
+ pfs->m_status_stats.aggregate_to(m_status_vars);
+}
+
+void PFS_connection_status_visitor::visit_user(PFS_user *pfs)
+{
+ pfs->m_status_stats.aggregate_to(m_status_vars);
+}
+
+void PFS_connection_status_visitor::visit_account(PFS_account *pfs)
+{
+ pfs->m_status_stats.aggregate_to(m_status_vars);
+}
+
+void PFS_connection_status_visitor::visit_thread(PFS_thread *pfs)
+{
+}
+
+void PFS_connection_status_visitor::visit_THD(THD *thd)
+{
+ add_to_status(m_status_vars, &thd->status_var);
+}
+
+
+PFS_instance_wait_visitor::PFS_instance_wait_visitor()
+{}
+
+PFS_instance_wait_visitor::~PFS_instance_wait_visitor()
+{}
+
+void PFS_instance_wait_visitor::visit_mutex_class(PFS_mutex_class *pfs)
+{
+ m_stat.aggregate(&pfs->m_mutex_stat.m_wait_stat);
+}
+
+void PFS_instance_wait_visitor::visit_rwlock_class(PFS_rwlock_class *pfs)
+{
+ m_stat.aggregate(&pfs->m_rwlock_stat.m_wait_stat);
+}
+
+void PFS_instance_wait_visitor::visit_cond_class(PFS_cond_class *pfs)
+{
+ m_stat.aggregate(&pfs->m_cond_stat.m_wait_stat);
+}
+
+void PFS_instance_wait_visitor::visit_file_class(PFS_file_class *pfs)
+{
+ pfs->m_file_stat.m_io_stat.sum_waits(&m_stat);
+}
+
+void PFS_instance_wait_visitor::visit_socket_class(PFS_socket_class *pfs)
+{
+ pfs->m_socket_stat.m_io_stat.sum_waits(&m_stat);
+}
+
+void PFS_instance_wait_visitor::visit_mutex(PFS_mutex *pfs)
+{
+ m_stat.aggregate(& pfs->m_mutex_stat.m_wait_stat);
+}
+
+void PFS_instance_wait_visitor::visit_rwlock(PFS_rwlock *pfs)
+{
+ m_stat.aggregate(& pfs->m_rwlock_stat.m_wait_stat);
+}
+
+void PFS_instance_wait_visitor::visit_cond(PFS_cond *pfs)
+{
+ m_stat.aggregate(& pfs->m_cond_stat.m_wait_stat);
+}
+
+void PFS_instance_wait_visitor::visit_file(PFS_file *pfs)
+{
+ /* Combine per-operation file wait stats before aggregating */
+ PFS_single_stat stat;
+ pfs->m_file_stat.m_io_stat.sum_waits(&stat);
+ m_stat.aggregate(&stat);
+}
+
+void PFS_instance_wait_visitor::visit_socket(PFS_socket *pfs)
+{
+ /* Combine per-operation socket wait stats before aggregating */
+ PFS_single_stat stat;
+ pfs->m_socket_stat.m_io_stat.sum_waits(&stat);
+ m_stat.aggregate(&stat);
+}
+
+/** Table IO wait visitor */
+
+PFS_object_wait_visitor::PFS_object_wait_visitor()
+{}
+
+PFS_object_wait_visitor::~PFS_object_wait_visitor()
+{}
+
+void PFS_object_wait_visitor::visit_global()
+{
+ global_table_io_stat.sum(& m_stat);
+ global_table_lock_stat.sum(& m_stat);
+}
+
+void PFS_object_wait_visitor::visit_table_share(PFS_table_share *pfs)
+{
+ uint safe_key_count= sanitize_index_count(pfs->m_key_count);
+ pfs->sum(& m_stat, safe_key_count);
+}
+
+void PFS_object_wait_visitor::visit_table(PFS_table *pfs)
+{
+ PFS_table_share *table_share= sanitize_table_share(pfs->m_share);
+ if (table_share != NULL)
+ {
+ uint safe_key_count= sanitize_index_count(table_share->m_key_count);
+ pfs->m_table_stat.sum(& m_stat, safe_key_count);
+ }
+}
+
+PFS_table_io_wait_visitor::PFS_table_io_wait_visitor()
+{}
+
+PFS_table_io_wait_visitor::~PFS_table_io_wait_visitor()
+{}
+
+void PFS_table_io_wait_visitor::visit_global()
+{
+ global_table_io_stat.sum(& m_stat);
+}
+
+void PFS_table_io_wait_visitor::visit_table_share(PFS_table_share *pfs)
+{
+ PFS_table_io_stat io_stat;
+ uint safe_key_count= sanitize_index_count(pfs->m_key_count);
+ uint index;
+ PFS_table_share_index *index_stat;
+
+ /* Aggregate index stats */
+ for (index= 0; index < safe_key_count; index++)
+ {
+ index_stat= pfs->find_index_stat(index);
+ if (index_stat != NULL)
+ io_stat.aggregate(& index_stat->m_stat);
+ }
+
+ /* Aggregate global stats */
+ index_stat= pfs->find_index_stat(MAX_INDEXES);
+ if (index_stat != NULL)
+ io_stat.aggregate(& index_stat->m_stat);
+
+ io_stat.sum(& m_stat);
+}
+
+void PFS_table_io_wait_visitor::visit_table(PFS_table *pfs)
+{
+ PFS_table_share *safe_share= sanitize_table_share(pfs->m_share);
+
+ if (likely(safe_share != NULL))
+ {
+ PFS_table_io_stat io_stat;
+ uint safe_key_count= sanitize_index_count(safe_share->m_key_count);
+ uint index;
+
+ /* Aggregate index stats */
+ for (index= 0; index < safe_key_count; index++)
+ io_stat.aggregate(& pfs->m_table_stat.m_index_stat[index]);
+
+ /* Aggregate global stats */
+ io_stat.aggregate(& pfs->m_table_stat.m_index_stat[MAX_INDEXES]);
+
+ io_stat.sum(& m_stat);
+ }
+}
+
+/** Table IO stat visitor */
+
+PFS_table_io_stat_visitor::PFS_table_io_stat_visitor()
+{}
+
+PFS_table_io_stat_visitor::~PFS_table_io_stat_visitor()
+{}
+
+void PFS_table_io_stat_visitor::visit_table_share(PFS_table_share *pfs)
+{
+ uint safe_key_count= sanitize_index_count(pfs->m_key_count);
+ uint index;
+ PFS_table_share_index *index_stat;
+
+ /* Aggregate index stats */
+ for (index= 0; index < safe_key_count; index++)
+ {
+ index_stat= pfs->find_index_stat(index);
+ if (index_stat != NULL)
+ m_stat.aggregate(& index_stat->m_stat);
+ }
+
+ /* Aggregate global stats */
+ index_stat= pfs->find_index_stat(MAX_INDEXES);
+ if (index_stat != NULL)
+ m_stat.aggregate(& index_stat->m_stat);
+}
+
+void PFS_table_io_stat_visitor::visit_table(PFS_table *pfs)
+{
+ PFS_table_share *safe_share= sanitize_table_share(pfs->m_share);
+
+ if (likely(safe_share != NULL))
+ {
+ uint safe_key_count= sanitize_index_count(safe_share->m_key_count);
+ uint index;
+
+ /* Aggregate index stats */
+ for (index= 0; index < safe_key_count; index++)
+ m_stat.aggregate(& pfs->m_table_stat.m_index_stat[index]);
+
+ /* Aggregate global stats */
+ m_stat.aggregate(& pfs->m_table_stat.m_index_stat[MAX_INDEXES]);
+ }
+}
+
+/** Index IO stat visitor */
+
+PFS_index_io_stat_visitor::PFS_index_io_stat_visitor()
+{}
+
+PFS_index_io_stat_visitor::~PFS_index_io_stat_visitor()
+{}
+
+void PFS_index_io_stat_visitor::visit_table_share_index(PFS_table_share *pfs, uint index)
+{
+ PFS_table_share_index *index_stat;
+
+ index_stat= pfs->find_index_stat(index);
+ if (index_stat != NULL)
+ m_stat.aggregate(& index_stat->m_stat);
+}
+
+void PFS_index_io_stat_visitor::visit_table_index(PFS_table *pfs, uint index)
+{
+ m_stat.aggregate(& pfs->m_table_stat.m_index_stat[index]);
+}
+
+/** Table lock wait visitor */
+
+PFS_table_lock_wait_visitor::PFS_table_lock_wait_visitor()
+{}
+
+PFS_table_lock_wait_visitor::~PFS_table_lock_wait_visitor()
+{}
+
+void PFS_table_lock_wait_visitor::visit_global()
+{
+ global_table_lock_stat.sum(& m_stat);
+}
+
+void PFS_table_lock_wait_visitor::visit_table_share(PFS_table_share *pfs)
+{
+ pfs->sum_lock(& m_stat);
+}
+
+void PFS_table_lock_wait_visitor::visit_table(PFS_table *pfs)
+{
+ pfs->m_table_stat.sum_lock(& m_stat);
+}
+
+/** Table lock stat visitor */
+
+PFS_table_lock_stat_visitor::PFS_table_lock_stat_visitor()
+{}
+
+PFS_table_lock_stat_visitor::~PFS_table_lock_stat_visitor()
+{}
+
+void PFS_table_lock_stat_visitor::visit_table_share(PFS_table_share *pfs)
+{
+ PFS_table_share_lock *lock_stat;
+
+ lock_stat= pfs->find_lock_stat();
+ if (lock_stat != NULL)
+ m_stat.aggregate(& lock_stat->m_stat);
+}
+
+void PFS_table_lock_stat_visitor::visit_table(PFS_table *pfs)
+{
+ m_stat.aggregate(& pfs->m_table_stat.m_lock_stat);
+}
+
+PFS_instance_socket_io_stat_visitor::PFS_instance_socket_io_stat_visitor()
+{}
+
+PFS_instance_socket_io_stat_visitor::~PFS_instance_socket_io_stat_visitor()
+{}
+
+void PFS_instance_socket_io_stat_visitor::visit_socket_class(PFS_socket_class *pfs)
+{
+ /* Aggregate wait times, event counts and byte counts */
+ m_socket_io_stat.aggregate(&pfs->m_socket_stat.m_io_stat);
+}
+
+void PFS_instance_socket_io_stat_visitor::visit_socket(PFS_socket *pfs)
+{
+ /* Aggregate wait times, event counts and byte counts */
+ m_socket_io_stat.aggregate(&pfs->m_socket_stat.m_io_stat);
+}
+
+PFS_instance_file_io_stat_visitor::PFS_instance_file_io_stat_visitor()
+{}
+
+PFS_instance_file_io_stat_visitor::~PFS_instance_file_io_stat_visitor()
+{}
+
+void PFS_instance_file_io_stat_visitor::visit_file_class(PFS_file_class *pfs)
+{
+ /* Aggregate wait times, event counts and byte counts */
+ m_file_io_stat.aggregate(&pfs->m_file_stat.m_io_stat);
+}
+
+void PFS_instance_file_io_stat_visitor::visit_file(PFS_file *pfs)
+{
+ /* Aggregate wait times, event counts and byte counts */
+ m_file_io_stat.aggregate(&pfs->m_file_stat.m_io_stat);
+}
+/** @} */
diff --git a/storage/perfschema/pfs_visitor.h b/storage/perfschema/pfs_visitor.h
new file mode 100644
index 00000000..a81567e9
--- /dev/null
+++ b/storage/perfschema/pfs_visitor.h
@@ -0,0 +1,687 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef PFS_VISITOR_H
+#define PFS_VISITOR_H
+
+#include "pfs_stat.h"
+
+typedef struct system_status_var STATUS_VAR;
+
+/**
+ @file storage/perfschema/pfs_visitor.h
+ Visitors (declarations).
+*/
+
+/**
+ @addtogroup Performance_schema_buffers
+ @{
+*/
+
+struct PFS_user;
+struct PFS_account;
+struct PFS_host;
+struct PFS_thread;
+struct PFS_instr_class;
+struct PFS_mutex_class;
+struct PFS_rwlock_class;
+struct PFS_cond_class;
+struct PFS_file_class;
+struct PFS_socket_class;
+struct PFS_memory_class;
+struct PFS_table_share;
+struct PFS_mutex;
+struct PFS_rwlock;
+struct PFS_cond;
+struct PFS_file;
+struct PFS_table;
+struct PFS_stage_class;
+struct PFS_statement_class;
+struct PFS_transaction_class;
+struct PFS_socket;
+struct PFS_connection_slice;
+
+/**
+ Interface class to visit groups of connections.
+ @sa PFS_connection_iterator
+*/
+class PFS_connection_visitor
+{
+public:
+ PFS_connection_visitor() {}
+ virtual ~PFS_connection_visitor() {}
+ /** Visit all connections. */
+ virtual void visit_global() {}
+ /** Visit all connections of a host. */
+ virtual void visit_host(PFS_host *pfs) {}
+ /** Visit all connections of a user+host. */
+ virtual void visit_account(PFS_account *pfs) {}
+ /** Visit all connections of a user. */
+ virtual void visit_user(PFS_user *pfs) {}
+ /** Visit a thread. */
+ virtual void visit_thread(PFS_thread *pfs) {}
+ /** Visit a THD associated with a thread. */
+ virtual void visit_THD(THD *thd) {}
+};
+
+/**
+ Iterator over groups of connections.
+ @sa PFS_connection_visitor
+*/
+class PFS_connection_iterator
+{
+public:
+ /**
+ Visit all connections.
+ @param with_hosts when true, visit also all hosts.
+ @param with_users when true, visit also all users.
+ @param with_accounts when true, visit also all user+host.
+ @param with_threads when true, visit also all threads.
+ @param with_THDs when true, visit also all threads THD.
+ @param visitor the visitor to call
+ */
+ static void visit_global(bool with_hosts, bool with_users,
+ bool with_accounts, bool with_threads,
+ bool with_THDs,
+ PFS_connection_visitor *visitor);
+ /**
+ Visit all connections of a host.
+ @param host the host to visit.
+ @param with_accounts when true, visit also all related user+host.
+ @param with_threads when true, visit also all related threads.
+ @param with_THDs when true, visit also all related threads THD.
+ @param visitor the visitor to call
+ */
+ static void visit_host(PFS_host *host, bool with_accounts, bool with_threads,
+ bool with_THDs,
+ PFS_connection_visitor *visitor);
+ /**
+ Visit all connections of a user.
+ @param user the user to visit.
+ @param with_accounts when true, visit also all related user+host.
+ @param with_threads when true, visit also all related threads.
+ @param with_THDs when true, visit also all related threads THD.
+ @param visitor the visitor to call
+ */
+ static void visit_user(PFS_user *user, bool with_accounts, bool with_threads,
+ bool with_THDs,
+ PFS_connection_visitor *visitor);
+ /**
+ Visit all connections of a user+host.
+ @param account the user+host to visit.
+ @param with_threads when true, visit also all related threads.
+ @param with_THDs when true, visit also all related threads THD.
+ @param visitor the visitor to call
+ */
+ static void visit_account(PFS_account *account, bool with_threads,
+ bool with_THDs,
+ PFS_connection_visitor *visitor);
+ /**
+ Visit a thread or connection.
+ @param thread the thread to visit.
+ @param visitor the visitor to call
+ */
+ static inline void visit_thread(PFS_thread *thread,
+ PFS_connection_visitor *visitor)
+ { visitor->visit_thread(thread); }
+
+ /**
+ Visit THD.
+ @param thd the THD to visit.
+ @param visitor the visitor to call.
+ */
+ static void visit_THD(THD *thd, PFS_connection_visitor *visitor);
+};
+
+/**
+ Interface class to visit groups of instrumentation point instances.
+ @sa PFS_instance_iterator
+*/
+class PFS_instance_visitor
+{
+public:
+ PFS_instance_visitor() {}
+ virtual ~PFS_instance_visitor() {}
+ /** Visit a mutex class. */
+ virtual void visit_mutex_class(PFS_mutex_class *pfs) {}
+ /** Visit a rwlock class. */
+ virtual void visit_rwlock_class(PFS_rwlock_class *pfs) {}
+ /** Visit a cond class. */
+ virtual void visit_cond_class(PFS_cond_class *pfs) {}
+ /** Visit a file class. */
+ virtual void visit_file_class(PFS_file_class *pfs) {}
+ /** Visit a socket class. */
+ virtual void visit_socket_class(PFS_socket_class *pfs) {}
+ /** Visit a mutex instance. */
+ virtual void visit_mutex(PFS_mutex *pfs) {}
+ /** Visit a rwlock instance. */
+ virtual void visit_rwlock(PFS_rwlock *pfs) {}
+ /** Visit a cond instance. */
+ virtual void visit_cond(PFS_cond *pfs) {}
+ /** Visit a file instance. */
+ virtual void visit_file(PFS_file *pfs) {}
+ /** Visit a socket instance. */
+ virtual void visit_socket(PFS_socket *pfs) {}
+};
+
+/**
+ Iterator over groups of instrumentation point instances.
+ @sa PFS_instance_visitor
+*/
+class PFS_instance_iterator
+{
+public:
+ static void visit_all(PFS_instance_visitor *visitor);
+ static void visit_all_mutex(PFS_instance_visitor *visitor);
+ static void visit_all_mutex_classes(PFS_instance_visitor *visitor);
+ static void visit_all_mutex_instances(PFS_instance_visitor *visitor);
+ static void visit_all_rwlock(PFS_instance_visitor *visitor);
+ static void visit_all_rwlock_classes(PFS_instance_visitor *visitor);
+ static void visit_all_rwlock_instances(PFS_instance_visitor *visitor);
+ static void visit_all_cond(PFS_instance_visitor *visitor);
+ static void visit_all_cond_classes(PFS_instance_visitor *visitor);
+ static void visit_all_cond_instances(PFS_instance_visitor *visitor);
+ static void visit_all_file(PFS_instance_visitor *visitor);
+ static void visit_all_file_classes(PFS_instance_visitor *visitor);
+ static void visit_all_file_instances(PFS_instance_visitor *visitor);
+
+ /**
+ Visit a mutex class and related instances.
+ @param klass the klass to visit.
+ @param visitor the visitor to call
+ */
+ static void visit_mutex_instances(PFS_mutex_class *klass,
+ PFS_instance_visitor *visitor);
+ /**
+ Visit a rwlock class and related instances.
+ @param klass the klass to visit.
+ @param visitor the visitor to call
+ */
+ static void visit_rwlock_instances(PFS_rwlock_class *klass,
+ PFS_instance_visitor *visitor);
+ /**
+ Visit a cond class and related instances.
+ @param klass the klass to visit.
+ @param visitor the visitor to call
+ */
+ static void visit_cond_instances(PFS_cond_class *klass,
+ PFS_instance_visitor *visitor);
+ /**
+ Visit a file class and related instances.
+ @param klass the klass to visit.
+ @param visitor the visitor to call
+ */
+ static void visit_file_instances(PFS_file_class *klass,
+ PFS_instance_visitor *visitor);
+ /**
+ Visit a socket class and related instances.
+ @param klass the klass to visit.
+ @param visitor the visitor to call
+ */
+ static void visit_socket_instances(PFS_socket_class *klass,
+ PFS_instance_visitor *visitor);
+ /**
+ Visit a socket class and related instances.
+ @param klass the klass to visit.
+ @param visitor the visitor to call
+ @param thread the owning thread to match
+ @param visit_class if true then visit the socket class
+ */
+ static void visit_socket_instances(PFS_socket_class *klass,
+ PFS_instance_visitor *visitor,
+ PFS_thread *thread,
+ bool visit_class= true);
+ /**
+ Visit an instrument class and related instances.
+ @param klass the klass to visit.
+ @param visitor the visitor to call
+ @param thread comparison criteria
+ @param visit_class if true then visit the class
+ */
+ static void visit_instances(PFS_instr_class *klass,
+ PFS_instance_visitor *visitor,
+ PFS_thread *thread,
+ bool visit_class= true);
+};
+
+/**
+ Interface class to visit groups of SQL objects.
+ @sa PFS_object_iterator
+*/
+class PFS_object_visitor
+{
+public:
+ PFS_object_visitor() {}
+ virtual ~PFS_object_visitor() {}
+ /** Visit global data. */
+ virtual void visit_global() {}
+ /** Visit a table share. */
+ virtual void visit_table_share(PFS_table_share *pfs) {}
+ /** Visit a table share index. */
+ virtual void visit_table_share_index(PFS_table_share *pfs, uint index) {}
+ /** Visit a table. */
+ virtual void visit_table(PFS_table *pfs) {}
+ /** Visit a table index. */
+ virtual void visit_table_index(PFS_table *pfs, uint index) {}
+};
+
+/**
+ Iterator over groups of SQL objects.
+ @sa PFS_object_visitor
+*/
+class PFS_object_iterator
+{
+public:
+ /** Visit all objects. */
+ static void visit_all(PFS_object_visitor *visitor);
+ /** Visit all tables and related handles. */
+ static void visit_all_tables(PFS_object_visitor *visitor);
+ /** Visit a table and related table handles. */
+ static void visit_tables(PFS_table_share *share,
+ PFS_object_visitor *visitor);
+ /** Visit a table index and related table handles indexes. */
+ static void visit_table_indexes(PFS_table_share *share,
+ uint index,
+ PFS_object_visitor *visitor);
+};
+
+/**
+ A concrete connection visitor that aggregates
+ wait statistics for a given event_name.
+*/
+class PFS_connection_wait_visitor : public PFS_connection_visitor
+{
+public:
+ /** Constructor. */
+ PFS_connection_wait_visitor(PFS_instr_class *klass);
+ virtual ~PFS_connection_wait_visitor();
+ virtual void visit_global();
+ virtual void visit_host(PFS_host *pfs);
+ virtual void visit_account(PFS_account *pfs);
+ virtual void visit_user(PFS_user *pfs);
+ virtual void visit_thread(PFS_thread *pfs);
+
+ /** EVENT_NAME instrument index. */
+ uint m_index;
+ /** Wait statistic collected. */
+ PFS_single_stat m_stat;
+};
+
+/**
+ A concrete connection visitor that aggregates
+ wait statistics for all events.
+*/
+class PFS_connection_all_wait_visitor : public PFS_connection_visitor
+{
+public:
+ /** Constructor. */
+ PFS_connection_all_wait_visitor();
+ virtual ~PFS_connection_all_wait_visitor();
+ virtual void visit_global();
+ virtual void visit_host(PFS_host *pfs);
+ virtual void visit_account(PFS_account *pfs);
+ virtual void visit_user(PFS_user *pfs);
+ virtual void visit_thread(PFS_thread *pfs);
+
+ /** Wait statistic collected. */
+ PFS_single_stat m_stat;
+
+private:
+ void visit_connection_slice(PFS_connection_slice *pfs);
+};
+
+/**
+ A concrete connection visitor that aggregates
+ stage statistics.
+*/
+class PFS_connection_stage_visitor : public PFS_connection_visitor
+{
+public:
+ /** Constructor. */
+ PFS_connection_stage_visitor(PFS_stage_class *klass);
+ virtual ~PFS_connection_stage_visitor();
+ virtual void visit_global();
+ virtual void visit_host(PFS_host *pfs);
+ virtual void visit_account(PFS_account *pfs);
+ virtual void visit_user(PFS_user *pfs);
+ virtual void visit_thread(PFS_thread *pfs);
+
+ /** EVENT_NAME instrument index. */
+ uint m_index;
+ /** Stage statistic collected. */
+ PFS_stage_stat m_stat;
+};
+
+/**
+ A concrete connection visitor that aggregates
+ statement statistics for a given event_name.
+*/
+class PFS_connection_statement_visitor : public PFS_connection_visitor
+{
+public:
+ /** Constructor. */
+ PFS_connection_statement_visitor(PFS_statement_class *klass);
+ virtual ~PFS_connection_statement_visitor();
+ virtual void visit_global();
+ virtual void visit_host(PFS_host *pfs);
+ virtual void visit_account(PFS_account *pfs);
+ virtual void visit_user(PFS_user *pfs);
+ virtual void visit_thread(PFS_thread *pfs);
+
+ /** EVENT_NAME instrument index. */
+ uint m_index;
+ /** Statement statistic collected. */
+ PFS_statement_stat m_stat;
+};
+
+/**
+ A concrete connection visitor that aggregates
+ statement statistics for all events.
+*/
+class PFS_connection_all_statement_visitor : public PFS_connection_visitor
+{
+public:
+ /** Constructor. */
+ PFS_connection_all_statement_visitor();
+ virtual ~PFS_connection_all_statement_visitor();
+ virtual void visit_global();
+ virtual void visit_host(PFS_host *pfs);
+ virtual void visit_account(PFS_account *pfs);
+ virtual void visit_user(PFS_user *pfs);
+ virtual void visit_thread(PFS_thread *pfs);
+
+ /** Statement statistic collected. */
+ PFS_statement_stat m_stat;
+
+private:
+ void visit_connection_slice(PFS_connection_slice *pfs);
+};
+
+/**
+ A concrete connection visitor that aggregates
+ transaction statistics for a given event_name.
+*/
+class PFS_connection_transaction_visitor : public PFS_connection_visitor
+{
+public:
+ /** Constructor. */
+ PFS_connection_transaction_visitor(PFS_transaction_class *klass);
+ virtual ~PFS_connection_transaction_visitor();
+ virtual void visit_global();
+ virtual void visit_host(PFS_host *pfs);
+ virtual void visit_account(PFS_account *pfs);
+ virtual void visit_user(PFS_user *pfs);
+ virtual void visit_thread(PFS_thread *pfs);
+
+ /** EVENT_NAME instrument index. */
+ uint m_index;
+ /** Statement statistic collected. */
+ PFS_transaction_stat m_stat;
+};
+
+/** Disabled pending code review */
+#if 0
+/**
+ A concrete connection visitor that aggregates
+ transaction statistics for all events.
+*/
+class PFS_connection_all_transaction_visitor : public PFS_connection_visitor
+{
+public:
+ /** Constructor. */
+ PFS_connection_all_transaction_visitor();
+ virtual ~PFS_connection_all_transaction_visitor();
+ virtual void visit_global();
+ virtual void visit_host(PFS_host *pfs);
+ virtual void visit_account(PFS_account *pfs);
+ virtual void visit_user(PFS_user *pfs);
+ virtual void visit_thread(PFS_thread *pfs);
+
+ /** Statement statistic collected. */
+ PFS_transaction_stat m_stat;
+
+private:
+ void visit_connection_slice(PFS_connection_slice *pfs);
+};
+#endif
+
+/**
+ A concrete connection visitor that aggregates
+ connection statistics.
+*/
+class PFS_connection_stat_visitor : public PFS_connection_visitor
+{
+public:
+ /** Constructor. */
+ PFS_connection_stat_visitor();
+ virtual ~PFS_connection_stat_visitor();
+ virtual void visit_global();
+ virtual void visit_host(PFS_host *pfs);
+ virtual void visit_account(PFS_account *pfs);
+ virtual void visit_user(PFS_user *pfs);
+ virtual void visit_thread(PFS_thread *pfs);
+
+ /** Connection statistic collected. */
+ PFS_connection_stat m_stat;
+};
+
+/**
+ A concrete connection visitor that aggregates
+ memory statistics for a given event_name.
+*/
+class PFS_connection_memory_visitor : public PFS_connection_visitor
+{
+public:
+ /** Constructor. */
+ PFS_connection_memory_visitor(PFS_memory_class *klass);
+ virtual ~PFS_connection_memory_visitor();
+ virtual void visit_global();
+ virtual void visit_host(PFS_host *pfs);
+ virtual void visit_account(PFS_account *pfs);
+ virtual void visit_user(PFS_user *pfs);
+ virtual void visit_thread(PFS_thread *pfs);
+
+ /** EVENT_NAME instrument index. */
+ uint m_index;
+ /** Statement statistic collected. */
+ PFS_memory_stat m_stat;
+};
+
+/**
+ A concrete connection visitor that aggregates
+ status variables.
+*/
+class PFS_connection_status_visitor : public PFS_connection_visitor
+{
+public:
+ /** Constructor. */
+ PFS_connection_status_visitor(STATUS_VAR *status_vars);
+ virtual ~PFS_connection_status_visitor();
+ virtual void visit_global();
+ virtual void visit_host(PFS_host *pfs);
+ virtual void visit_account(PFS_account *pfs);
+ virtual void visit_user(PFS_user *pfs);
+ virtual void visit_thread(PFS_thread *pfs);
+ virtual void visit_THD(THD *thd);
+
+private:
+ STATUS_VAR *m_status_vars;
+};
+
+/**
+ A concrete instance visitor that aggregates
+ wait statistics.
+*/
+class PFS_instance_wait_visitor : public PFS_instance_visitor
+{
+public:
+ PFS_instance_wait_visitor();
+ virtual ~PFS_instance_wait_visitor();
+ virtual void visit_mutex_class(PFS_mutex_class *pfs);
+ virtual void visit_rwlock_class(PFS_rwlock_class *pfs);
+ virtual void visit_cond_class(PFS_cond_class *pfs);
+ virtual void visit_file_class(PFS_file_class *pfs);
+ virtual void visit_socket_class(PFS_socket_class *pfs);
+ virtual void visit_mutex(PFS_mutex *pfs);
+ virtual void visit_rwlock(PFS_rwlock *pfs);
+ virtual void visit_cond(PFS_cond *pfs);
+ virtual void visit_file(PFS_file *pfs);
+ virtual void visit_socket(PFS_socket *pfs);
+
+ /** Wait statistic collected. */
+ PFS_single_stat m_stat;
+};
+
+/**
+ A concrete object visitor that aggregates
+ object wait statistics.
+*/
+class PFS_object_wait_visitor : public PFS_object_visitor
+{
+public:
+ PFS_object_wait_visitor();
+ virtual ~PFS_object_wait_visitor();
+ virtual void visit_global();
+ virtual void visit_table_share(PFS_table_share *pfs);
+ virtual void visit_table(PFS_table *pfs);
+
+ /** Object wait statistic collected. */
+ PFS_single_stat m_stat;
+};
+
+/**
+ A concrete object visitor that aggregates
+ table io wait statistics.
+*/
+class PFS_table_io_wait_visitor : public PFS_object_visitor
+{
+public:
+ PFS_table_io_wait_visitor();
+ virtual ~PFS_table_io_wait_visitor();
+ virtual void visit_global();
+ virtual void visit_table_share(PFS_table_share *pfs);
+ virtual void visit_table(PFS_table *pfs);
+
+ /** Table io wait statistic collected. */
+ PFS_single_stat m_stat;
+};
+
+/**
+ A concrete object visitor that aggregates
+ table io statistics.
+*/
+class PFS_table_io_stat_visitor : public PFS_object_visitor
+{
+public:
+ PFS_table_io_stat_visitor();
+ virtual ~PFS_table_io_stat_visitor();
+ virtual void visit_table_share(PFS_table_share *pfs);
+ virtual void visit_table(PFS_table *pfs);
+
+ /** Table io statistic collected. */
+ PFS_table_io_stat m_stat;
+};
+
+/**
+ A concrete object visitor that aggregates
+ index io statistics.
+*/
+class PFS_index_io_stat_visitor : public PFS_object_visitor
+{
+public:
+ PFS_index_io_stat_visitor();
+ virtual ~PFS_index_io_stat_visitor();
+ virtual void visit_table_share_index(PFS_table_share *pfs, uint index);
+ virtual void visit_table_index(PFS_table *pfs, uint index);
+
+ /** Index io statistic collected. */
+ PFS_table_io_stat m_stat;
+};
+
+/**
+ A concrete object visitor that aggregates
+ table lock wait statistics.
+*/
+class PFS_table_lock_wait_visitor : public PFS_object_visitor
+{
+public:
+ PFS_table_lock_wait_visitor();
+ virtual ~PFS_table_lock_wait_visitor();
+ virtual void visit_global();
+ virtual void visit_table_share(PFS_table_share *pfs);
+ virtual void visit_table(PFS_table *pfs);
+
+ /** Table lock wait statistic collected. */
+ PFS_single_stat m_stat;
+};
+
+/**
+ A concrete object visitor that aggregates
+ table lock statistics.
+*/
+class PFS_table_lock_stat_visitor : public PFS_object_visitor
+{
+public:
+ PFS_table_lock_stat_visitor();
+ virtual ~PFS_table_lock_stat_visitor();
+ virtual void visit_table_share(PFS_table_share *pfs);
+ virtual void visit_table(PFS_table *pfs);
+
+ /** Table lock statistic collected. */
+ PFS_table_lock_stat m_stat;
+};
+
+/**
+ A concrete instance visitor that aggregates
+ socket wait and byte count statistics.
+*/
+class PFS_instance_socket_io_stat_visitor : public PFS_instance_visitor
+{
+public:
+ PFS_instance_socket_io_stat_visitor();
+ virtual ~PFS_instance_socket_io_stat_visitor();
+ virtual void visit_socket_class(PFS_socket_class *pfs);
+ virtual void visit_socket(PFS_socket *pfs);
+
+ /** Wait and byte count statistics collected. */
+ PFS_socket_io_stat m_socket_io_stat;
+};
+
+/**
+ A concrete instance visitor that aggregates
+ file wait and byte count statistics.
+*/
+class PFS_instance_file_io_stat_visitor : public PFS_instance_visitor
+{
+public:
+ PFS_instance_file_io_stat_visitor();
+ virtual ~PFS_instance_file_io_stat_visitor();
+ virtual void visit_file_class(PFS_file_class *pfs);
+ virtual void visit_file(PFS_file *pfs);
+
+ /** Wait and byte count statistics collected. */
+ PFS_file_io_stat m_file_io_stat;
+};
+
+/** @} */
+#endif
+
diff --git a/storage/perfschema/rpl_gtid.h b/storage/perfschema/rpl_gtid.h
new file mode 100644
index 00000000..6d9ecb0e
--- /dev/null
+++ b/storage/perfschema/rpl_gtid.h
@@ -0,0 +1,17 @@
+#ifndef STORAGE_PERFSCHEMA_RPL_GTID_INCLUDED
+#define STORAGE_PERFSCHEMA_RPL_GTID_INCLUDED
+
+struct TABLE;
+
+#include "../../sql/rpl_gtid.h"
+
+class Gtid_specification: public rpl_gtid
+{
+public:
+ size_t to_string(char *buf)
+ {
+ return my_snprintf(buf, GTID_MAX_STR_LENGTH, "%u-%u-%llu",
+ domain_id, server_id, seq_no);
+ }
+};
+#endif
diff --git a/storage/perfschema/table_accounts.cc b/storage/perfschema/table_accounts.cc
new file mode 100644
index 00000000..310c81f2
--- /dev/null
+++ b/storage/perfschema/table_accounts.cc
@@ -0,0 +1,142 @@
+/* Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "table_accounts.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "pfs_account.h"
+#include "pfs_visitor.h"
+#include "pfs_memory.h"
+#include "pfs_status.h"
+#include "field.h"
+
+THR_LOCK table_accounts::m_table_lock;
+
+PFS_engine_table_share
+table_accounts::m_share=
+{
+ { C_STRING_WITH_LEN("accounts") },
+ &pfs_truncatable_acl,
+ table_accounts::create,
+ NULL, /* write_row */
+ table_accounts::delete_all_rows,
+ cursor_by_account::get_row_count,
+ sizeof(PFS_simple_index), /* ref length */
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE accounts("
+ "USER CHAR(" USERNAME_CHAR_LENGTH_STR ") collate utf8_bin default null,"
+ "HOST CHAR(" HOSTNAME_LENGTH_STR ") collate utf8_bin default null,"
+ "CURRENT_CONNECTIONS bigint not null,"
+ "TOTAL_CONNECTIONS bigint not null)") },
+ false /* perpetual */
+};
+
+PFS_engine_table* table_accounts::create()
+{
+ return new table_accounts();
+}
+
+int
+table_accounts::delete_all_rows(void)
+{
+ reset_events_waits_by_thread();
+ reset_events_waits_by_account();
+ reset_events_stages_by_thread();
+ reset_events_stages_by_account();
+ reset_events_statements_by_thread();
+ reset_events_statements_by_account();
+ reset_events_transactions_by_thread();
+ reset_events_transactions_by_account();
+ reset_memory_by_thread();
+ reset_memory_by_account();
+ reset_status_by_thread();
+ reset_status_by_account();
+ purge_all_account();
+ return 0;
+}
+
+table_accounts::table_accounts()
+ : cursor_by_account(& m_share),
+ m_row_exists(false)
+{}
+
+void table_accounts::make_row(PFS_account *pfs)
+{
+ pfs_optimistic_state lock;
+
+ m_row_exists= false;
+ pfs->m_lock.begin_optimistic_lock(&lock);
+
+ if (m_row.m_account.make_row(pfs))
+ return;
+
+ PFS_connection_stat_visitor visitor;
+ PFS_connection_iterator::visit_account(pfs,
+ true, /* threads */
+ false, /* THDs */
+ & visitor);
+
+ if (! pfs->m_lock.end_optimistic_lock(& lock))
+ return;
+
+ m_row.m_connection_stat.set(& visitor.m_stat);
+ m_row_exists= true;
+}
+
+int table_accounts::read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* USER */
+ case 1: /* HOST */
+ m_row.m_account.set_field(f->field_index, f);
+ break;
+ case 2: /* CURRENT_CONNECTIONS */
+ case 3: /* TOTAL_CONNECTIONS */
+ m_row.m_connection_stat.set_field(f->field_index - 2, f);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+ return 0;
+}
+
diff --git a/storage/perfschema/table_accounts.h b/storage/perfschema/table_accounts.h
new file mode 100644
index 00000000..7563e85c
--- /dev/null
+++ b/storage/perfschema/table_accounts.h
@@ -0,0 +1,85 @@
+/* Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_ACCOUNTS_H
+#define TABLE_ACCOUNTS_H
+
+#include "pfs_column_types.h"
+#include "cursor_by_account.h"
+#include "table_helper.h"
+
+struct PFS_account;
+
+/**
+ \addtogroup Performance_schema_tables
+ @{
+*/
+
+/**
+ A row of PERFORMANCE_SCHEMA.ACCOUNTS.
+*/
+struct row_accounts
+{
+ /** Column USER, HOST. */
+ PFS_account_row m_account;
+ /** Columns CURRENT_CONNECTIONS, TOTAL_CONNECTIONS. */
+ PFS_connection_stat_row m_connection_stat;
+};
+
+/** Table PERFORMANCE_SCHEMA.ACCOUNTS. */
+class table_accounts : public cursor_by_account
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ /** Table builder */
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+
+protected:
+ table_accounts();
+
+public:
+ ~table_accounts()
+ {}
+
+private:
+ virtual void make_row(PFS_account *pfs);
+
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ /** Current row. */
+ row_accounts m_row;
+ /** True if the current row exists. */
+ bool m_row_exists;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_all_instr.cc b/storage/perfschema/table_all_instr.cc
new file mode 100644
index 00000000..b030b882
--- /dev/null
+++ b/storage/perfschema/table_all_instr.cc
@@ -0,0 +1,188 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_all_instr.cc
+ Abstract tables for all instruments (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "table_all_instr.h"
+#include "pfs_global.h"
+#include "pfs_buffer_container.h"
+
+ha_rows
+table_all_instr::get_row_count(void)
+{
+ return global_mutex_container.get_row_count()
+ + global_rwlock_container.get_row_count()
+ + global_cond_container.get_row_count()
+ + global_file_container.get_row_count()
+ + global_socket_container.get_row_count() ;
+}
+
+table_all_instr::table_all_instr(const PFS_engine_table_share *share)
+ : PFS_engine_table(share, &m_pos),
+ m_pos(), m_next_pos()
+{}
+
+void table_all_instr::reset_position(void)
+{
+ m_pos.reset();
+ m_next_pos.reset();
+}
+
+int table_all_instr::rnd_next(void)
+{
+ PFS_mutex *mutex;
+ PFS_rwlock *rwlock;
+ PFS_cond *cond;
+ PFS_file *file;
+ PFS_socket *socket;
+
+ for (m_pos.set_at(&m_next_pos);
+ m_pos.has_more_view();
+ m_pos.next_view())
+ {
+ switch (m_pos.m_index_1) {
+ case pos_all_instr::VIEW_MUTEX:
+ {
+ PFS_mutex_iterator it= global_mutex_container.iterate(m_pos.m_index_2);
+ mutex= it.scan_next(& m_pos.m_index_2);
+ if (mutex != NULL)
+ {
+ make_mutex_row(mutex);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+ break;
+ case pos_all_instr::VIEW_RWLOCK:
+ {
+ PFS_rwlock_iterator it= global_rwlock_container.iterate(m_pos.m_index_2);
+ rwlock= it.scan_next(& m_pos.m_index_2);
+ if (rwlock != NULL)
+ {
+ make_rwlock_row(rwlock);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+ break;
+ case pos_all_instr::VIEW_COND:
+ {
+ PFS_cond_iterator it= global_cond_container.iterate(m_pos.m_index_2);
+ cond= it.scan_next(& m_pos.m_index_2);
+ if (cond != NULL)
+ {
+ make_cond_row(cond);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+ break;
+ case pos_all_instr::VIEW_FILE:
+ {
+ PFS_file_iterator it= global_file_container.iterate(m_pos.m_index_2);
+ file= it.scan_next(& m_pos.m_index_2);
+ if (file != NULL)
+ {
+ make_file_row(file);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+ break;
+ case pos_all_instr::VIEW_SOCKET:
+ {
+ PFS_socket_iterator it= global_socket_container.iterate(m_pos.m_index_2);
+ socket= it.scan_next(& m_pos.m_index_2);
+ if (socket != NULL)
+ {
+ make_socket_row(socket);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+ break;
+ }
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int table_all_instr::rnd_pos(const void *pos)
+{
+ PFS_mutex *mutex;
+ PFS_rwlock *rwlock;
+ PFS_cond *cond;
+ PFS_file *file;
+ PFS_socket *socket;
+
+ set_position(pos);
+
+ switch (m_pos.m_index_1) {
+ case pos_all_instr::VIEW_MUTEX:
+ mutex= global_mutex_container.get(m_pos.m_index_2);
+ if (mutex != NULL)
+ {
+ make_mutex_row(mutex);
+ return 0;
+ }
+ break;
+ case pos_all_instr::VIEW_RWLOCK:
+ rwlock= global_rwlock_container.get(m_pos.m_index_2);
+ if (rwlock != NULL)
+ {
+ make_rwlock_row(rwlock);
+ return 0;
+ }
+ break;
+ case pos_all_instr::VIEW_COND:
+ cond= global_cond_container.get(m_pos.m_index_2);
+ if (cond != NULL)
+ {
+ make_cond_row(cond);
+ return 0;
+ }
+ break;
+ case pos_all_instr::VIEW_FILE:
+ file= global_file_container.get(m_pos.m_index_2);
+ if (file != NULL)
+ {
+ make_file_row(file);
+ return 0;
+ }
+ break;
+ case pos_all_instr::VIEW_SOCKET:
+ socket= global_socket_container.get(m_pos.m_index_2);
+ if (socket != NULL)
+ {
+ make_socket_row(socket);
+ return 0;
+ }
+ break;
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
diff --git a/storage/perfschema/table_all_instr.h b/storage/perfschema/table_all_instr.h
new file mode 100644
index 00000000..3b5388df
--- /dev/null
+++ b/storage/perfschema/table_all_instr.h
@@ -0,0 +1,124 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_ALL_INSTR_H
+#define TABLE_ALL_INSTR_H
+
+/**
+ @file storage/perfschema/table_all_instr.h
+ Abstract tables for all instruments (declarations).
+*/
+
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "pfs_engine_table.h"
+#include "table_helper.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/** Position of a cursor on table_all_instr. */
+struct pos_all_instr : public PFS_double_index,
+ public PFS_instrument_view_constants
+{
+ pos_all_instr()
+ : PFS_double_index(FIRST_VIEW, 0)
+ {}
+
+ inline void reset(void)
+ {
+ m_index_1= FIRST_VIEW;
+ m_index_2= 0;
+ }
+
+ inline bool has_more_view(void)
+ { return (m_index_1 <= LAST_VIEW); }
+
+ inline void next_view(void)
+ {
+ m_index_1++;
+ m_index_2= 0;
+ }
+};
+
+/**
+ Abstract table, a union of all instrumentations instances.
+ This table is a union of:
+ - a view on all mutex instances,
+ - a view on all rwlock instances,
+ - a view on all cond instances,
+ - a view on all file instances,
+ - a view on all socket instances
+*/
+class table_all_instr : public PFS_engine_table
+{
+public:
+ static ha_rows get_row_count();
+
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ table_all_instr(const PFS_engine_table_share *share);
+
+public:
+ ~table_all_instr()
+ {}
+
+protected:
+ /**
+ Build a row in the mutex instance view.
+ @param pfs the mutex instance
+ */
+ virtual void make_mutex_row(PFS_mutex *pfs)= 0;
+ /**
+ Build a row in the rwlock instance view.
+ @param pfs the rwlock instance
+ */
+ virtual void make_rwlock_row(PFS_rwlock *pfs)= 0;
+ /**
+ Build a row in the condition instance view.
+ @param pfs the condition instance
+ */
+ virtual void make_cond_row(PFS_cond *pfs)= 0;
+ /**
+ Build a row in the file instance view.
+ @param pfs the file instance
+ */
+ virtual void make_file_row(PFS_file *pfs)= 0;
+ /**
+ Build a row in the socket instance view.
+ @param pfs the socket instance
+ */
+ virtual void make_socket_row(PFS_socket *pfs)= 0;
+
+ /** Current position. */
+ pos_all_instr m_pos;
+ /** Next position. */
+ pos_all_instr m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_esgs_by_account_by_event_name.cc b/storage/perfschema/table_esgs_by_account_by_event_name.cc
new file mode 100644
index 00000000..42bef1aa
--- /dev/null
+++ b/storage/perfschema/table_esgs_by_account_by_event_name.cc
@@ -0,0 +1,210 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_esgs_by_account_by_event_name.cc
+ Table EVENTS_STAGES_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "pfs_instr_class.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "table_esgs_by_account_by_event_name.h"
+#include "pfs_global.h"
+#include "pfs_visitor.h"
+#include "pfs_buffer_container.h"
+#include "field.h"
+
+THR_LOCK table_esgs_by_account_by_event_name::m_table_lock;
+
+PFS_engine_table_share
+table_esgs_by_account_by_event_name::m_share=
+{
+ { C_STRING_WITH_LEN("events_stages_summary_by_account_by_event_name") },
+ &pfs_truncatable_acl,
+ table_esgs_by_account_by_event_name::create,
+ NULL, /* write_row */
+ table_esgs_by_account_by_event_name::delete_all_rows,
+ table_esgs_by_account_by_event_name::get_row_count,
+ sizeof(pos_esgs_by_account_by_event_name),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE events_stages_summary_by_account_by_event_name("
+ "USER CHAR(" USERNAME_CHAR_LENGTH_STR ") collate utf8_bin default null,"
+ "HOST CHAR(" HOSTNAME_LENGTH_STR ") collate utf8_bin default null,"
+ "EVENT_NAME VARCHAR(128) not null,"
+ "COUNT_STAR BIGINT unsigned not null,"
+ "SUM_TIMER_WAIT BIGINT unsigned not null,"
+ "MIN_TIMER_WAIT BIGINT unsigned not null,"
+ "AVG_TIMER_WAIT BIGINT unsigned not null,"
+ "MAX_TIMER_WAIT BIGINT unsigned not null)") },
+ false /* perpetual */
+};
+
+PFS_engine_table*
+table_esgs_by_account_by_event_name::create(void)
+{
+ return new table_esgs_by_account_by_event_name();
+}
+
+int
+table_esgs_by_account_by_event_name::delete_all_rows(void)
+{
+ reset_events_stages_by_thread();
+ reset_events_stages_by_account();
+ return 0;
+}
+
+ha_rows
+table_esgs_by_account_by_event_name::get_row_count(void)
+{
+ return global_account_container.get_row_count() * stage_class_max;
+}
+
+table_esgs_by_account_by_event_name::table_esgs_by_account_by_event_name()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(), m_next_pos()
+{}
+
+void table_esgs_by_account_by_event_name::reset_position(void)
+{
+ m_pos.reset();
+ m_next_pos.reset();
+}
+
+int table_esgs_by_account_by_event_name::rnd_init(bool scan)
+{
+ m_normalizer= time_normalizer::get(stage_timer);
+ return 0;
+}
+
+int table_esgs_by_account_by_event_name::rnd_next(void)
+{
+ PFS_account *account;
+ PFS_stage_class *stage_class;
+ bool has_more_account= true;
+
+ for (m_pos.set_at(&m_next_pos);
+ has_more_account;
+ m_pos.next_account())
+ {
+ account= global_account_container.get(m_pos.m_index_1, & has_more_account);
+ if (account != NULL)
+ {
+ stage_class= find_stage_class(m_pos.m_index_2);
+ if (stage_class)
+ {
+ make_row(account, stage_class);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int
+table_esgs_by_account_by_event_name::rnd_pos(const void *pos)
+{
+ PFS_account *account;
+ PFS_stage_class *stage_class;
+
+ set_position(pos);
+
+ account= global_account_container.get(m_pos.m_index_1);
+ if (account != NULL)
+ {
+ stage_class= find_stage_class(m_pos.m_index_2);
+ if (stage_class)
+ {
+ make_row(account, stage_class);
+ return 0;
+ }
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_esgs_by_account_by_event_name
+::make_row(PFS_account *account, PFS_stage_class *klass)
+{
+ pfs_optimistic_state lock;
+ m_row_exists= false;
+
+ account->m_lock.begin_optimistic_lock(&lock);
+
+ if (m_row.m_account.make_row(account))
+ return;
+
+ m_row.m_event_name.make_row(klass);
+
+ PFS_connection_stage_visitor visitor(klass);
+ PFS_connection_iterator::visit_account(account,
+ true, /* threads */
+ false, /* THDs */
+ & visitor);
+
+ if (! account->m_lock.end_optimistic_lock(&lock))
+ return;
+
+ m_row_exists= true;
+ m_row.m_stat.set(m_normalizer, & visitor.m_stat);
+}
+
+int table_esgs_by_account_by_event_name
+::read_row_values(TABLE *table, unsigned char *buf, Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* USER */
+ case 1: /* HOST */
+ m_row.m_account.set_field(f->field_index, f);
+ break;
+ case 2: /* EVENT_NAME */
+ m_row.m_event_name.set_field(f);
+ break;
+ default: /* 3, ... COUNT/SUM/MIN/AVG/MAX */
+ m_row.m_stat.set_field(f->field_index - 3, f);
+ break;
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_esgs_by_account_by_event_name.h b/storage/perfschema/table_esgs_by_account_by_event_name.h
new file mode 100644
index 00000000..011503aa
--- /dev/null
+++ b/storage/perfschema/table_esgs_by_account_by_event_name.h
@@ -0,0 +1,128 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_ESGS_BY_ACCOUNT_BY_EVENT_NAME_H
+#define TABLE_ESGS_BY_ACCOUNT_BY_EVENT_NAME_H
+
+/**
+ @file storage/perfschema/table_esgs_by_account_by_event_name.h
+ Table EVENTS_STAGES_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "pfs_account.h"
+#include "table_helper.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/**
+ A row of table
+ PERFORMANCE_SCHEMA.EVENTS_STAGES_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME.
+*/
+struct row_esgs_by_account_by_event_name
+{
+ /** Column USER, HOST. */
+ PFS_account_row m_account;
+ /** Column EVENT_NAME. */
+ PFS_event_name_row m_event_name;
+ /** Columns COUNT_STAR, SUM/MIN/AVG/MAX TIMER_WAIT. */
+ PFS_stage_stat_row m_stat;
+};
+
+/**
+ Position of a cursor on
+ PERFORMANCE_SCHEMA.EVENTS_STAGES_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME.
+ Index 1 on account (0 based)
+ Index 2 on stage class (1 based)
+*/
+struct pos_esgs_by_account_by_event_name
+: public PFS_double_index
+{
+ pos_esgs_by_account_by_event_name()
+ : PFS_double_index(0, 1)
+ {}
+
+ inline void reset(void)
+ {
+ m_index_1= 0;
+ m_index_2= 1;
+ }
+
+ inline void next_account(void)
+ {
+ m_index_1++;
+ m_index_2= 1;
+ }
+};
+
+/** Table PERFORMANCE_SCHEMA.EVENTS_STAGES_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME. */
+class table_esgs_by_account_by_event_name : public PFS_engine_table
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_init(bool scan);
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_esgs_by_account_by_event_name();
+
+public:
+ ~table_esgs_by_account_by_event_name()
+ {}
+
+protected:
+ void make_row(PFS_account *account, PFS_stage_class *klass);
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ /** Current row. */
+ row_esgs_by_account_by_event_name m_row;
+ /** True is the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ pos_esgs_by_account_by_event_name m_pos;
+ /** Next position. */
+ pos_esgs_by_account_by_event_name m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_esgs_by_host_by_event_name.cc b/storage/perfschema/table_esgs_by_host_by_event_name.cc
new file mode 100644
index 00000000..ebacdc6e
--- /dev/null
+++ b/storage/perfschema/table_esgs_by_host_by_event_name.cc
@@ -0,0 +1,211 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_esgs_by_host_by_event_name.cc
+ Table EVENTS_STAGES_SUMMARY_BY_HOST_BY_EVENT_NAME (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "pfs_instr_class.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "table_esgs_by_host_by_event_name.h"
+#include "pfs_global.h"
+#include "pfs_account.h"
+#include "pfs_visitor.h"
+#include "pfs_buffer_container.h"
+#include "field.h"
+
+THR_LOCK table_esgs_by_host_by_event_name::m_table_lock;
+
+PFS_engine_table_share
+table_esgs_by_host_by_event_name::m_share=
+{
+ { C_STRING_WITH_LEN("events_stages_summary_by_host_by_event_name") },
+ &pfs_truncatable_acl,
+ table_esgs_by_host_by_event_name::create,
+ NULL, /* write_row */
+ table_esgs_by_host_by_event_name::delete_all_rows,
+ table_esgs_by_host_by_event_name::get_row_count,
+ sizeof(pos_esgs_by_host_by_event_name),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE events_stages_summary_by_host_by_event_name("
+ "HOST CHAR(" STRINGIFY_ARG(HOSTNAME_LENGTH) ") collate utf8_bin default null,"
+ "EVENT_NAME VARCHAR(128) not null,"
+ "COUNT_STAR BIGINT unsigned not null,"
+ "SUM_TIMER_WAIT BIGINT unsigned not null,"
+ "MIN_TIMER_WAIT BIGINT unsigned not null,"
+ "AVG_TIMER_WAIT BIGINT unsigned not null,"
+ "MAX_TIMER_WAIT BIGINT unsigned not null)") },
+ false /* perpetual */
+};
+
+PFS_engine_table*
+table_esgs_by_host_by_event_name::create(void)
+{
+ return new table_esgs_by_host_by_event_name();
+}
+
+int
+table_esgs_by_host_by_event_name::delete_all_rows(void)
+{
+ reset_events_stages_by_thread();
+ reset_events_stages_by_account();
+ reset_events_stages_by_host();
+ return 0;
+}
+
+ha_rows
+table_esgs_by_host_by_event_name::get_row_count(void)
+{
+ return global_host_container.get_row_count() * stage_class_max;
+}
+
+table_esgs_by_host_by_event_name::table_esgs_by_host_by_event_name()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(), m_next_pos()
+{}
+
+void table_esgs_by_host_by_event_name::reset_position(void)
+{
+ m_pos.reset();
+ m_next_pos.reset();
+}
+
+int table_esgs_by_host_by_event_name::rnd_init(bool scan)
+{
+ m_normalizer= time_normalizer::get(stage_timer);
+ return 0;
+}
+
+int table_esgs_by_host_by_event_name::rnd_next(void)
+{
+ PFS_host *host;
+ PFS_stage_class *stage_class;
+ bool has_more_host= true;
+
+ for (m_pos.set_at(&m_next_pos);
+ has_more_host;
+ m_pos.next_host())
+ {
+ host= global_host_container.get(m_pos.m_index_1, & has_more_host);
+ if (host != NULL)
+ {
+ stage_class= find_stage_class(m_pos.m_index_2);
+ if (stage_class)
+ {
+ make_row(host, stage_class);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int
+table_esgs_by_host_by_event_name::rnd_pos(const void *pos)
+{
+ PFS_host *host;
+ PFS_stage_class *stage_class;
+
+ set_position(pos);
+
+ host= global_host_container.get(m_pos.m_index_1);
+ if (host != NULL)
+ {
+ stage_class= find_stage_class(m_pos.m_index_2);
+ if (stage_class)
+ {
+ make_row(host, stage_class);
+ return 0;
+ }
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_esgs_by_host_by_event_name
+::make_row(PFS_host *host, PFS_stage_class *klass)
+{
+ pfs_optimistic_state lock;
+ m_row_exists= false;
+
+ host->m_lock.begin_optimistic_lock(&lock);
+
+ if (m_row.m_host.make_row(host))
+ return;
+
+ m_row.m_event_name.make_row(klass);
+
+ PFS_connection_stage_visitor visitor(klass);
+ PFS_connection_iterator::visit_host(host,
+ true, /* accounts */
+ true, /* threads */
+ false, /* THDs */
+ & visitor);
+
+ if (! host->m_lock.end_optimistic_lock(&lock))
+ return;
+
+ m_row_exists= true;
+ m_row.m_stat.set(m_normalizer, & visitor.m_stat);
+}
+
+int table_esgs_by_host_by_event_name
+::read_row_values(TABLE *table, unsigned char *buf, Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* HOST */
+ m_row.m_host.set_field(f);
+ break;
+ case 1: /* EVENT_NAME */
+ m_row.m_event_name.set_field(f);
+ break;
+ default: /* 2, ... COUNT/SUM/MIN/AVG/MAX */
+ m_row.m_stat.set_field(f->field_index - 2, f);
+ break;
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_esgs_by_host_by_event_name.h b/storage/perfschema/table_esgs_by_host_by_event_name.h
new file mode 100644
index 00000000..14ddbb8b
--- /dev/null
+++ b/storage/perfschema/table_esgs_by_host_by_event_name.h
@@ -0,0 +1,128 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_ESGS_BY_HOST_BY_EVENT_NAME_H
+#define TABLE_ESGS_BY_HOST_BY_EVENT_NAME_H
+
+/**
+ @file storage/perfschema/table_esgs_by_host_by_event_name.h
+ Table EVENTS_STAGES_SUMMARY_BY_HOST_BY_EVENT_NAME (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "pfs_host.h"
+#include "table_helper.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/**
+ A row of table
+ PERFORMANCE_SCHEMA.EVENTS_STAGES_SUMMARY_BY_HOST_BY_EVENT_NAME.
+*/
+struct row_esgs_by_host_by_event_name
+{
+ /** Column HOST. */
+ PFS_host_row m_host;
+ /** Column EVENT_NAME. */
+ PFS_event_name_row m_event_name;
+ /** Columns COUNT_STAR, SUM/MIN/AVG/MAX TIMER_WAIT. */
+ PFS_stage_stat_row m_stat;
+};
+
+/**
+ Position of a cursor on
+ PERFORMANCE_SCHEMA.EVENTS_STAGES_SUMMARY_BY_HOST_BY_EVENT_NAME.
+ Index 1 on host (0 based)
+ Index 2 on stage class (1 based).
+*/
+struct pos_esgs_by_host_by_event_name
+: public PFS_double_index
+{
+ pos_esgs_by_host_by_event_name()
+ : PFS_double_index(0, 1)
+ {}
+
+ inline void reset(void)
+ {
+ m_index_1= 0;
+ m_index_2= 1;
+ }
+
+ inline void next_host(void)
+ {
+ m_index_1++;
+ m_index_2= 1;
+ }
+};
+
+/** Table PERFORMANCE_SCHEMA.EVENTS_STAGES_SUMMARY_BY_HOST_BY_EVENT_NAME. */
+class table_esgs_by_host_by_event_name : public PFS_engine_table
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_init(bool scan);
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_esgs_by_host_by_event_name();
+
+public:
+ ~table_esgs_by_host_by_event_name()
+ {}
+
+protected:
+ void make_row(PFS_host *host, PFS_stage_class *klass);
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ /** Current row. */
+ row_esgs_by_host_by_event_name m_row;
+ /** True is the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ pos_esgs_by_host_by_event_name m_pos;
+ /** Next position. */
+ pos_esgs_by_host_by_event_name m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_esgs_by_thread_by_event_name.cc b/storage/perfschema/table_esgs_by_thread_by_event_name.cc
new file mode 100644
index 00000000..c266bfaf
--- /dev/null
+++ b/storage/perfschema/table_esgs_by_thread_by_event_name.cc
@@ -0,0 +1,202 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_esgs_by_thread_by_event_name.cc
+ Table EVENTS_STAGES_SUMMARY_BY_HOST_BY_EVENT_NAME (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "pfs_instr_class.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "table_esgs_by_thread_by_event_name.h"
+#include "pfs_global.h"
+#include "pfs_visitor.h"
+#include "pfs_buffer_container.h"
+#include "field.h"
+
+THR_LOCK table_esgs_by_thread_by_event_name::m_table_lock;
+
+PFS_engine_table_share
+table_esgs_by_thread_by_event_name::m_share=
+{
+ { C_STRING_WITH_LEN("events_stages_summary_by_thread_by_event_name") },
+ &pfs_truncatable_acl,
+ table_esgs_by_thread_by_event_name::create,
+ NULL, /* write_row */
+ table_esgs_by_thread_by_event_name::delete_all_rows,
+ table_esgs_by_thread_by_event_name::get_row_count,
+ sizeof(pos_esgs_by_thread_by_event_name),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE events_stages_summary_by_thread_by_event_name("
+ "THREAD_ID BIGINT unsigned not null,"
+ "EVENT_NAME VARCHAR(128) not null,"
+ "COUNT_STAR BIGINT unsigned not null,"
+ "SUM_TIMER_WAIT BIGINT unsigned not null,"
+ "MIN_TIMER_WAIT BIGINT unsigned not null,"
+ "AVG_TIMER_WAIT BIGINT unsigned not null,"
+ "MAX_TIMER_WAIT BIGINT unsigned not null)") },
+ false /* perpetual */
+};
+
+PFS_engine_table*
+table_esgs_by_thread_by_event_name::create(void)
+{
+ return new table_esgs_by_thread_by_event_name();
+}
+
+int
+table_esgs_by_thread_by_event_name::delete_all_rows(void)
+{
+ reset_events_stages_by_thread();
+ return 0;
+}
+
+ha_rows
+table_esgs_by_thread_by_event_name::get_row_count(void)
+{
+ return global_thread_container.get_row_count() * stage_class_max;
+}
+
+table_esgs_by_thread_by_event_name::table_esgs_by_thread_by_event_name()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(), m_next_pos()
+{}
+
+void table_esgs_by_thread_by_event_name::reset_position(void)
+{
+ m_pos.reset();
+ m_next_pos.reset();
+}
+
+int table_esgs_by_thread_by_event_name::rnd_init(bool scan)
+{
+ m_normalizer= time_normalizer::get(stage_timer);
+ return 0;
+}
+
+int table_esgs_by_thread_by_event_name::rnd_next(void)
+{
+ PFS_thread *thread;
+ PFS_stage_class *stage_class;
+ bool has_more_thread= true;
+
+ for (m_pos.set_at(&m_next_pos);
+ has_more_thread;
+ m_pos.next_thread())
+ {
+ thread= global_thread_container.get(m_pos.m_index_1, & has_more_thread);
+ if (thread != NULL)
+ {
+ stage_class= find_stage_class(m_pos.m_index_2);
+ if (stage_class)
+ {
+ make_row(thread, stage_class);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int
+table_esgs_by_thread_by_event_name::rnd_pos(const void *pos)
+{
+ PFS_thread *thread;
+ PFS_stage_class *stage_class;
+
+ set_position(pos);
+
+ thread= global_thread_container.get(m_pos.m_index_1);
+ if (thread != NULL)
+ {
+ stage_class= find_stage_class(m_pos.m_index_2);
+ if (stage_class)
+ {
+ make_row(thread, stage_class);
+ return 0;
+ }
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_esgs_by_thread_by_event_name
+::make_row(PFS_thread *thread, PFS_stage_class *klass)
+{
+ pfs_optimistic_state lock;
+ m_row_exists= false;
+
+ /* Protect this reader against a thread termination */
+ thread->m_lock.begin_optimistic_lock(&lock);
+
+ m_row.m_thread_internal_id= thread->m_thread_internal_id;
+
+ m_row.m_event_name.make_row(klass);
+
+ PFS_connection_stage_visitor visitor(klass);
+ PFS_connection_iterator::visit_thread(thread, & visitor);
+
+ if (thread->m_lock.end_optimistic_lock(&lock))
+ m_row_exists= true;
+
+ m_row.m_stat.set(m_normalizer, & visitor.m_stat);
+}
+
+int table_esgs_by_thread_by_event_name
+::read_row_values(TABLE *table, unsigned char *, Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 0);
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* THREAD_ID */
+ set_field_ulonglong(f, m_row.m_thread_internal_id);
+ break;
+ case 1: /* NAME */
+ m_row.m_event_name.set_field(f);
+ break;
+ default: /* 2, ... COUNT/SUM/MIN/AVG/MAX */
+ m_row.m_stat.set_field(f->field_index - 2, f);
+ break;
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_esgs_by_thread_by_event_name.h b/storage/perfschema/table_esgs_by_thread_by_event_name.h
new file mode 100644
index 00000000..d3798e41
--- /dev/null
+++ b/storage/perfschema/table_esgs_by_thread_by_event_name.h
@@ -0,0 +1,132 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_ESGS_BY_THREAD_BY_EVENT_NAME_H
+#define TABLE_ESGS_BY_THREAD_BY_EVENT_NAME_H
+
+/**
+ @file storage/perfschema/table_esgs_by_thread_by_event_name.h
+ Table EVENTS_STAGES_SUMMARY_BY_THREAD_BY_EVENT_NAME (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "table_helper.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/**
+ A row of table
+ PERFORMANCE_SCHEMA.EVENTS_STAGES_SUMMARY_BY_THREAD_BY_EVENT_NAME.
+*/
+struct row_esgs_by_thread_by_event_name
+{
+ /** Column THREAD_ID. */
+ ulonglong m_thread_internal_id;
+ /** Column EVENT_NAME. */
+ PFS_event_name_row m_event_name;
+ /** Columns COUNT_STAR, SUM/MIN/AVG/MAX TIMER_WAIT. */
+ PFS_stage_stat_row m_stat;
+};
+
+/**
+ Position of a cursor on
+ PERFORMANCE_SCHEMA.EVENTS_STAGES_SUMMARY_BY_THREAD_BY_EVENT_NAME.
+ Index 1 on thread (0 based).
+ Index 2 on stage class (1 based).
+*/
+struct pos_esgs_by_thread_by_event_name
+: public PFS_double_index
+{
+ pos_esgs_by_thread_by_event_name()
+ : PFS_double_index(0, 1)
+ {}
+
+ inline void reset(void)
+ {
+ m_index_1= 0;
+ m_index_2= 1;
+ }
+
+ inline void next_thread(void)
+ {
+ m_index_1++;
+ m_index_2= 1;
+ }
+
+ inline void next_stage(void)
+ {
+ m_index_2++;
+ }
+};
+
+/** Table PERFORMANCE_SCHEMA.EVENTS_STAGES_SUMMARY_BY_THREAD_BY_EVENT_NAME. */
+class table_esgs_by_thread_by_event_name : public PFS_engine_table
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_init(bool scan);
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_esgs_by_thread_by_event_name();
+
+public:
+ ~table_esgs_by_thread_by_event_name()
+ {}
+
+protected:
+ void make_row(PFS_thread *thread, PFS_stage_class *klass);
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ /** Current row. */
+ row_esgs_by_thread_by_event_name m_row;
+ /** True is the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ pos_esgs_by_thread_by_event_name m_pos;
+ /** Next position. */
+ pos_esgs_by_thread_by_event_name m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_esgs_by_user_by_event_name.cc b/storage/perfschema/table_esgs_by_user_by_event_name.cc
new file mode 100644
index 00000000..e6e6c321
--- /dev/null
+++ b/storage/perfschema/table_esgs_by_user_by_event_name.cc
@@ -0,0 +1,210 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_esgs_by_user_by_event_name.cc
+ Table EVENTS_STAGES_SUMMARY_BY_USER_BY_EVENT_NAME (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "pfs_instr_class.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "table_esgs_by_user_by_event_name.h"
+#include "pfs_global.h"
+#include "pfs_visitor.h"
+#include "pfs_buffer_container.h"
+#include "field.h"
+
+THR_LOCK table_esgs_by_user_by_event_name::m_table_lock;
+
+PFS_engine_table_share
+table_esgs_by_user_by_event_name::m_share=
+{
+ { C_STRING_WITH_LEN("events_stages_summary_by_user_by_event_name") },
+ &pfs_truncatable_acl,
+ table_esgs_by_user_by_event_name::create,
+ NULL, /* write_row */
+ table_esgs_by_user_by_event_name::delete_all_rows,
+ table_esgs_by_user_by_event_name::get_row_count,
+ sizeof(pos_esgs_by_user_by_event_name),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE events_stages_summary_by_user_by_event_name("
+ "USER CHAR(" USERNAME_CHAR_LENGTH_STR ") collate utf8_bin default null,"
+ "EVENT_NAME VARCHAR(128) not null,"
+ "COUNT_STAR BIGINT unsigned not null,"
+ "SUM_TIMER_WAIT BIGINT unsigned not null,"
+ "MIN_TIMER_WAIT BIGINT unsigned not null,"
+ "AVG_TIMER_WAIT BIGINT unsigned not null,"
+ "MAX_TIMER_WAIT BIGINT unsigned not null)") },
+ false /* perpetual */
+};
+
+PFS_engine_table*
+table_esgs_by_user_by_event_name::create(void)
+{
+ return new table_esgs_by_user_by_event_name();
+}
+
+int
+table_esgs_by_user_by_event_name::delete_all_rows(void)
+{
+ reset_events_stages_by_thread();
+ reset_events_stages_by_account();
+ reset_events_stages_by_user();
+ return 0;
+}
+
+ha_rows
+table_esgs_by_user_by_event_name::get_row_count(void)
+{
+ return global_user_container.get_row_count() * stage_class_max;
+}
+
+table_esgs_by_user_by_event_name::table_esgs_by_user_by_event_name()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(), m_next_pos()
+{}
+
+void table_esgs_by_user_by_event_name::reset_position(void)
+{
+ m_pos.reset();
+ m_next_pos.reset();
+}
+
+int table_esgs_by_user_by_event_name::rnd_init(bool scan)
+{
+ m_normalizer= time_normalizer::get(stage_timer);
+ return 0;
+}
+
+int table_esgs_by_user_by_event_name::rnd_next(void)
+{
+ PFS_user *user;
+ PFS_stage_class *stage_class;
+ bool has_more_user= true;
+
+ for (m_pos.set_at(&m_next_pos);
+ has_more_user;
+ m_pos.next_user())
+ {
+ user= global_user_container.get(m_pos.m_index_1, & has_more_user);
+ if (user != NULL)
+ {
+ stage_class= find_stage_class(m_pos.m_index_2);
+ if (stage_class)
+ {
+ make_row(user, stage_class);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int
+table_esgs_by_user_by_event_name::rnd_pos(const void *pos)
+{
+ PFS_user *user;
+ PFS_stage_class *stage_class;
+
+ set_position(pos);
+
+ user= global_user_container.get(m_pos.m_index_1);
+ if (user != NULL)
+ {
+ stage_class= find_stage_class(m_pos.m_index_2);
+ if (stage_class)
+ {
+ make_row(user, stage_class);
+ return 0;
+ }
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_esgs_by_user_by_event_name
+::make_row(PFS_user *user, PFS_stage_class *klass)
+{
+ pfs_optimistic_state lock;
+ m_row_exists= false;
+
+ user->m_lock.begin_optimistic_lock(&lock);
+
+ if (m_row.m_user.make_row(user))
+ return;
+
+ m_row.m_event_name.make_row(klass);
+
+ PFS_connection_stage_visitor visitor(klass);
+ PFS_connection_iterator::visit_user(user,
+ true, /* accounts */
+ true, /* threads */
+ false, /* THDs */
+ & visitor);
+
+ if (! user->m_lock.end_optimistic_lock(&lock))
+ return;
+
+ m_row_exists= true;
+ m_row.m_stat.set(m_normalizer, & visitor.m_stat);
+}
+
+int table_esgs_by_user_by_event_name
+::read_row_values(TABLE *table, unsigned char *buf, Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* USER */
+ m_row.m_user.set_field(f);
+ break;
+ case 1: /* EVENT_NAME */
+ m_row.m_event_name.set_field(f);
+ break;
+ default: /* 2, ... COUNT/SUM/MIN/AVG/MAX */
+ m_row.m_stat.set_field(f->field_index - 2, f);
+ break;
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_esgs_by_user_by_event_name.h b/storage/perfschema/table_esgs_by_user_by_event_name.h
new file mode 100644
index 00000000..464165a0
--- /dev/null
+++ b/storage/perfschema/table_esgs_by_user_by_event_name.h
@@ -0,0 +1,133 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_ESGS_BY_USER_BY_EVENT_NAME_H
+#define TABLE_ESGS_BY_USER_BY_EVENT_NAME_H
+
+/**
+ @file storage/perfschema/table_esgs_by_user_by_event_name.h
+ Table EVENTS_STAGES_SUMMARY_BY_USER_BY_EVENT_NAME (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "pfs_user.h"
+#include "table_helper.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/**
+ A row of table
+ PERFORMANCE_SCHEMA.EVENTS_STAGES_SUMMARY_BY_USER_BY_EVENT_NAME.
+*/
+struct row_esgs_by_user_by_event_name
+{
+ /** Column USER. */
+ PFS_user_row m_user;
+ /** Column EVENT_NAME. */
+ PFS_event_name_row m_event_name;
+ /** Columns COUNT_STAR, SUM/MIN/AVG/MAX TIMER_WAIT. */
+ PFS_stage_stat_row m_stat;
+};
+
+/**
+ Position of a cursor on
+ PERFORMANCE_SCHEMA.EVENTS_STAGES_SUMMARY_BY_USER_BY_EVENT_NAME.
+ Index 1 on user (0 based)
+ Index 2 on stage class (1 based)
+*/
+struct pos_esgs_by_user_by_event_name
+: public PFS_double_index
+{
+ pos_esgs_by_user_by_event_name()
+ : PFS_double_index(0, 1)
+ {}
+
+ inline void reset(void)
+ {
+ m_index_1= 0;
+ m_index_2= 1;
+ }
+
+ inline void next_user(void)
+ {
+ m_index_1++;
+ m_index_2= 1;
+ }
+
+ inline void next_stage(void)
+ {
+ m_index_2++;
+ }
+};
+
+/** Table PERFORMANCE_SCHEMA.EVENTS_STAGES_SUMMARY_BY_USER_BY_EVENT_NAME. */
+class table_esgs_by_user_by_event_name : public PFS_engine_table
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_init(bool scan);
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_esgs_by_user_by_event_name();
+
+public:
+ ~table_esgs_by_user_by_event_name()
+ {}
+
+protected:
+ void make_row(PFS_user *user, PFS_stage_class *klass);
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ /** Current row. */
+ row_esgs_by_user_by_event_name m_row;
+ /** True is the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ pos_esgs_by_user_by_event_name m_pos;
+ /** Next position. */
+ pos_esgs_by_user_by_event_name m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_esgs_global_by_event_name.cc b/storage/perfschema/table_esgs_global_by_event_name.cc
new file mode 100644
index 00000000..71145844
--- /dev/null
+++ b/storage/perfschema/table_esgs_global_by_event_name.cc
@@ -0,0 +1,191 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_esgs_global_by_event_name.cc
+ Table EVENTS_STAGES_SUMMARY_GLOBAL_BY_EVENT_NAME (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "pfs_instr_class.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "table_esgs_global_by_event_name.h"
+#include "pfs_global.h"
+#include "pfs_instr.h"
+#include "pfs_timer.h"
+#include "pfs_visitor.h"
+#include "field.h"
+
+THR_LOCK table_esgs_global_by_event_name::m_table_lock;
+
+PFS_engine_table_share
+table_esgs_global_by_event_name::m_share=
+{
+ { C_STRING_WITH_LEN("events_stages_summary_global_by_event_name") },
+ &pfs_truncatable_acl,
+ table_esgs_global_by_event_name::create,
+ NULL, /* write_row */
+ table_esgs_global_by_event_name::delete_all_rows,
+ table_esgs_global_by_event_name::get_row_count,
+ sizeof(PFS_simple_index),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE events_stages_summary_global_by_event_name("
+ "EVENT_NAME VARCHAR(128) not null,"
+ "COUNT_STAR BIGINT unsigned not null,"
+ "SUM_TIMER_WAIT BIGINT unsigned not null,"
+ "MIN_TIMER_WAIT BIGINT unsigned not null,"
+ "AVG_TIMER_WAIT BIGINT unsigned not null,"
+ "MAX_TIMER_WAIT BIGINT unsigned not null)") },
+ false /* perpetual */
+};
+
+PFS_engine_table*
+table_esgs_global_by_event_name::create(void)
+{
+ return new table_esgs_global_by_event_name();
+}
+
+int
+table_esgs_global_by_event_name::delete_all_rows(void)
+{
+ reset_events_stages_by_thread();
+ reset_events_stages_by_account();
+ reset_events_stages_by_user();
+ reset_events_stages_by_host();
+ reset_events_stages_global();
+ return 0;
+}
+
+ha_rows
+table_esgs_global_by_event_name::get_row_count(void)
+{
+ return stage_class_max;
+}
+
+table_esgs_global_by_event_name::table_esgs_global_by_event_name()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(1), m_next_pos(1)
+{}
+
+void table_esgs_global_by_event_name::reset_position(void)
+{
+ m_pos= 1;
+ m_next_pos= 1;
+}
+
+int table_esgs_global_by_event_name::rnd_init(bool scan)
+{
+ m_normalizer= time_normalizer::get(stage_timer);
+ return 0;
+}
+
+int table_esgs_global_by_event_name::rnd_next(void)
+{
+ PFS_stage_class *stage_class;
+
+ if (global_instr_class_stages_array == NULL)
+ return HA_ERR_END_OF_FILE;
+
+ m_pos.set_at(&m_next_pos);
+
+ stage_class= find_stage_class(m_pos.m_index);
+ if (stage_class)
+ {
+ make_row(stage_class);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int
+table_esgs_global_by_event_name::rnd_pos(const void *pos)
+{
+ PFS_stage_class *stage_class;
+
+ set_position(pos);
+
+ if (global_instr_class_stages_array == NULL)
+ return HA_ERR_END_OF_FILE;
+
+ stage_class=find_stage_class(m_pos.m_index);
+ if (stage_class)
+ {
+ make_row(stage_class);
+ return 0;
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+
+void table_esgs_global_by_event_name
+::make_row(PFS_stage_class *klass)
+{
+ m_row.m_event_name.make_row(klass);
+
+ PFS_connection_stage_visitor visitor(klass);
+ PFS_connection_iterator::visit_global(true, /* hosts */
+ false, /* users */
+ true, /* accounts */
+ true, /* threads */
+ false, /* THDs */
+ & visitor);
+
+ m_row.m_stat.set(m_normalizer, & visitor.m_stat);
+ m_row_exists= true;
+}
+
+int table_esgs_global_by_event_name
+::read_row_values(TABLE *table, unsigned char *, Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 0);
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* NAME */
+ m_row.m_event_name.set_field(f);
+ break;
+ default: /* 1, ... COUNT/SUM/MIN/AVG/MAX */
+ m_row.m_stat.set_field(f->field_index - 1, f);
+ break;
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_esgs_global_by_event_name.h b/storage/perfschema/table_esgs_global_by_event_name.h
new file mode 100644
index 00000000..44b3ea5c
--- /dev/null
+++ b/storage/perfschema/table_esgs_global_by_event_name.h
@@ -0,0 +1,99 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_ESGS_GLOBAL_BY_EVENT_NAME_H
+#define TABLE_ESGS_GLOBAL_BY_EVENT_NAME_H
+
+/**
+ @file storage/perfschema/table_esgs_global_by_event_name.h
+ Table EVENTS_STAGES_SUMMARY_GLOBAL_BY_EVENT_NAME (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "table_helper.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/**
+ A row of table
+ PERFORMANCE_SCHEMA.EVENTS_STAGES_SUMMARY_GLOBAL_BY_EVENT_NAME.
+*/
+struct row_esgs_global_by_event_name
+{
+ /** Column EVENT_NAME. */
+ PFS_event_name_row m_event_name;
+ /** Columns COUNT_STAR, SUM/MIN/AVG/MAX TIMER_WAIT. */
+ PFS_stage_stat_row m_stat;
+};
+
+/** Table PERFORMANCE_SCHEMA.EVENTS_STAGES_SUMMARY_GLOBAL_BY_EVENT_NAME. */
+class table_esgs_global_by_event_name : public PFS_engine_table
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_init(bool scan);
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_esgs_global_by_event_name();
+
+public:
+ ~table_esgs_global_by_event_name()
+ {}
+
+protected:
+ void make_row(PFS_stage_class *klass);
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ /** Current row. */
+ row_esgs_global_by_event_name m_row;
+ /** True is the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ PFS_simple_index m_pos;
+ /** Next position. */
+ PFS_simple_index m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_esms_by_account_by_event_name.cc b/storage/perfschema/table_esms_by_account_by_event_name.cc
new file mode 100644
index 00000000..589f62b9
--- /dev/null
+++ b/storage/perfschema/table_esms_by_account_by_event_name.cc
@@ -0,0 +1,232 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_esms_by_account_by_event_name.cc
+ Table EVENTS_STATEMENTS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "pfs_instr_class.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "table_esms_by_account_by_event_name.h"
+#include "pfs_global.h"
+#include "pfs_visitor.h"
+#include "pfs_buffer_container.h"
+#include "field.h"
+
+THR_LOCK table_esms_by_account_by_event_name::m_table_lock;
+
+PFS_engine_table_share
+table_esms_by_account_by_event_name::m_share=
+{
+ { C_STRING_WITH_LEN("events_statements_summary_by_account_by_event_name") },
+ &pfs_truncatable_acl,
+ table_esms_by_account_by_event_name::create,
+ NULL, /* write_row */
+ table_esms_by_account_by_event_name::delete_all_rows,
+ table_esms_by_account_by_event_name::get_row_count,
+ sizeof(pos_esms_by_account_by_event_name),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE events_statements_summary_by_account_by_event_name("
+ "USER CHAR(" USERNAME_CHAR_LENGTH_STR ") collate utf8_bin default null,"
+ "HOST CHAR(" HOSTNAME_LENGTH_STR ") collate utf8_bin default null,"
+ "EVENT_NAME VARCHAR(128) not null,"
+ "COUNT_STAR BIGINT unsigned not null,"
+ "SUM_TIMER_WAIT BIGINT unsigned not null,"
+ "MIN_TIMER_WAIT BIGINT unsigned not null,"
+ "AVG_TIMER_WAIT BIGINT unsigned not null,"
+ "MAX_TIMER_WAIT BIGINT unsigned not null,"
+ "SUM_LOCK_TIME BIGINT unsigned not null,"
+ "SUM_ERRORS BIGINT unsigned not null,"
+ "SUM_WARNINGS BIGINT unsigned not null,"
+ "SUM_ROWS_AFFECTED BIGINT unsigned not null,"
+ "SUM_ROWS_SENT BIGINT unsigned not null,"
+ "SUM_ROWS_EXAMINED BIGINT unsigned not null,"
+ "SUM_CREATED_TMP_DISK_TABLES BIGINT unsigned not null,"
+ "SUM_CREATED_TMP_TABLES BIGINT unsigned not null,"
+ "SUM_SELECT_FULL_JOIN BIGINT unsigned not null,"
+ "SUM_SELECT_FULL_RANGE_JOIN BIGINT unsigned not null,"
+ "SUM_SELECT_RANGE BIGINT unsigned not null,"
+ "SUM_SELECT_RANGE_CHECK BIGINT unsigned not null,"
+ "SUM_SELECT_SCAN BIGINT unsigned not null,"
+ "SUM_SORT_MERGE_PASSES BIGINT unsigned not null,"
+ "SUM_SORT_RANGE BIGINT unsigned not null,"
+ "SUM_SORT_ROWS BIGINT unsigned not null,"
+ "SUM_SORT_SCAN BIGINT unsigned not null,"
+ "SUM_NO_INDEX_USED BIGINT unsigned not null,"
+ "SUM_NO_GOOD_INDEX_USED BIGINT unsigned not null)") },
+ false /* perpetual */
+};
+
+PFS_engine_table*
+table_esms_by_account_by_event_name::create(void)
+{
+ return new table_esms_by_account_by_event_name();
+}
+
+int
+table_esms_by_account_by_event_name::delete_all_rows(void)
+{
+ reset_events_statements_by_thread();
+ reset_events_statements_by_account();
+ return 0;
+}
+
+ha_rows
+table_esms_by_account_by_event_name::get_row_count(void)
+{
+ return global_account_container.get_row_count() * statement_class_max;
+}
+
+table_esms_by_account_by_event_name::table_esms_by_account_by_event_name()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(), m_next_pos()
+{}
+
+void table_esms_by_account_by_event_name::reset_position(void)
+{
+ m_pos.reset();
+ m_next_pos.reset();
+}
+
+int table_esms_by_account_by_event_name::rnd_init(bool scan)
+{
+ m_normalizer= time_normalizer::get(statement_timer);
+ return 0;
+}
+
+int table_esms_by_account_by_event_name::rnd_next(void)
+{
+ PFS_account *account;
+ PFS_statement_class *statement_class;
+ bool has_more_account= true;
+
+ for (m_pos.set_at(&m_next_pos);
+ has_more_account;
+ m_pos.next_account())
+ {
+ account= global_account_container.get(m_pos.m_index_1, & has_more_account);
+ if (account != NULL)
+ {
+ statement_class= find_statement_class(m_pos.m_index_2);
+ if (statement_class)
+ {
+ make_row(account, statement_class);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int
+table_esms_by_account_by_event_name::rnd_pos(const void *pos)
+{
+ PFS_account *account;
+ PFS_statement_class *statement_class;
+
+ set_position(pos);
+
+ account= global_account_container.get(m_pos.m_index_1);
+ if (account != NULL)
+ {
+ statement_class= find_statement_class(m_pos.m_index_2);
+ if (statement_class)
+ {
+ make_row(account, statement_class);
+ return 0;
+ }
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_esms_by_account_by_event_name
+::make_row(PFS_account *account, PFS_statement_class *klass)
+{
+ pfs_optimistic_state lock;
+ m_row_exists= false;
+
+ if (klass->is_mutable())
+ return;
+
+ account->m_lock.begin_optimistic_lock(&lock);
+
+ if (m_row.m_account.make_row(account))
+ return;
+
+ m_row.m_event_name.make_row(klass);
+
+ PFS_connection_statement_visitor visitor(klass);
+ PFS_connection_iterator::visit_account(account,
+ true, /* threads */
+ false, /* THDs */
+ & visitor);
+
+ if (! account->m_lock.end_optimistic_lock(&lock))
+ return;
+
+ m_row_exists= true;
+ m_row.m_stat.set(m_normalizer, & visitor.m_stat);
+}
+
+int table_esms_by_account_by_event_name
+::read_row_values(TABLE *table, unsigned char *buf, Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* USER */
+ case 1: /* HOST */
+ m_row.m_account.set_field(f->field_index, f);
+ break;
+ case 2: /* EVENT_NAME */
+ m_row.m_event_name.set_field(f);
+ break;
+ default: /* 3, ... COUNT/SUM/MIN/AVG/MAX */
+ m_row.m_stat.set_field(f->field_index - 3, f);
+ break;
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_esms_by_account_by_event_name.h b/storage/perfschema/table_esms_by_account_by_event_name.h
new file mode 100644
index 00000000..3881dd5d
--- /dev/null
+++ b/storage/perfschema/table_esms_by_account_by_event_name.h
@@ -0,0 +1,128 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_ESMS_BY_ACCOUNT_BY_EVENT_NAME_H
+#define TABLE_ESMS_BY_ACCOUNT_BY_EVENT_NAME_H
+
+/**
+ @file storage/perfschema/table_esms_by_account_by_event_name.h
+ Table EVENTS_STATEMENTS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "pfs_account.h"
+#include "table_helper.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/**
+ A row of table
+ PERFORMANCE_SCHEMA.EVENTS_STATEMENTS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME.
+*/
+struct row_esms_by_account_by_event_name
+{
+ /** Column USER, HOST. */
+ PFS_account_row m_account;
+ /** Column EVENT_NAME. */
+ PFS_event_name_row m_event_name;
+ /** Columns COUNT_STAR, SUM/MIN/AVG/MAX TIMER_WAIT. */
+ PFS_statement_stat_row m_stat;
+};
+
+/**
+ Position of a cursor on
+ PERFORMANCE_SCHEMA.EVENTS_STATEMENTS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME.
+ Index 1 on account (0 based)
+ Index 2 on statement class (1 based)
+*/
+struct pos_esms_by_account_by_event_name
+: public PFS_double_index
+{
+ pos_esms_by_account_by_event_name()
+ : PFS_double_index(0, 1)
+ {}
+
+ inline void reset(void)
+ {
+ m_index_1= 0;
+ m_index_2= 1;
+ }
+
+ inline void next_account(void)
+ {
+ m_index_1++;
+ m_index_2= 1;
+ }
+};
+
+/** Table PERFORMANCE_SCHEMA.EVENTS_STATEMENTS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME. */
+class table_esms_by_account_by_event_name : public PFS_engine_table
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_init(bool scan);
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_esms_by_account_by_event_name();
+
+public:
+ ~table_esms_by_account_by_event_name()
+ {}
+
+protected:
+ void make_row(PFS_account *account, PFS_statement_class *klass);
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ /** Current row. */
+ row_esms_by_account_by_event_name m_row;
+ /** True is the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ pos_esms_by_account_by_event_name m_pos;
+ /** Next position. */
+ pos_esms_by_account_by_event_name m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_esms_by_digest.cc b/storage/perfschema/table_esms_by_digest.cc
new file mode 100644
index 00000000..acb9e059
--- /dev/null
+++ b/storage/perfschema/table_esms_by_digest.cc
@@ -0,0 +1,226 @@
+/* Copyright (c) 2010, 2016, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_esms_by_digest.cc
+ Table EVENTS_STATEMENTS_SUMMARY_GLOBAL_BY_DIGEST (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "pfs_instr_class.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "table_esms_by_digest.h"
+#include "pfs_global.h"
+#include "pfs_instr.h"
+#include "pfs_timer.h"
+#include "pfs_visitor.h"
+#include "table_esms_by_digest.h"
+#include "pfs_digest.h"
+#include "field.h"
+
+THR_LOCK table_esms_by_digest::m_table_lock;
+
+PFS_engine_table_share
+table_esms_by_digest::m_share=
+{
+ { C_STRING_WITH_LEN("events_statements_summary_by_digest") },
+ &pfs_truncatable_acl,
+ table_esms_by_digest::create,
+ NULL, /* write_row */
+ table_esms_by_digest::delete_all_rows,
+ table_esms_by_digest::get_row_count,
+ sizeof(PFS_simple_index),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE events_statements_summary_by_digest("
+ "SCHEMA_NAME VARCHAR(64),"
+ "DIGEST VARCHAR(32),"
+ "DIGEST_TEXT LONGTEXT,"
+ "COUNT_STAR BIGINT unsigned not null,"
+ "SUM_TIMER_WAIT BIGINT unsigned not null,"
+ "MIN_TIMER_WAIT BIGINT unsigned not null,"
+ "AVG_TIMER_WAIT BIGINT unsigned not null,"
+ "MAX_TIMER_WAIT BIGINT unsigned not null,"
+ "SUM_LOCK_TIME BIGINT unsigned not null,"
+ "SUM_ERRORS BIGINT unsigned not null,"
+ "SUM_WARNINGS BIGINT unsigned not null,"
+ "SUM_ROWS_AFFECTED BIGINT unsigned not null,"
+ "SUM_ROWS_SENT BIGINT unsigned not null,"
+ "SUM_ROWS_EXAMINED BIGINT unsigned not null,"
+ "SUM_CREATED_TMP_DISK_TABLES BIGINT unsigned not null,"
+ "SUM_CREATED_TMP_TABLES BIGINT unsigned not null,"
+ "SUM_SELECT_FULL_JOIN BIGINT unsigned not null,"
+ "SUM_SELECT_FULL_RANGE_JOIN BIGINT unsigned not null,"
+ "SUM_SELECT_RANGE BIGINT unsigned not null,"
+ "SUM_SELECT_RANGE_CHECK BIGINT unsigned not null,"
+ "SUM_SELECT_SCAN BIGINT unsigned not null,"
+ "SUM_SORT_MERGE_PASSES BIGINT unsigned not null,"
+ "SUM_SORT_RANGE BIGINT unsigned not null,"
+ "SUM_SORT_ROWS BIGINT unsigned not null,"
+ "SUM_SORT_SCAN BIGINT unsigned not null,"
+ "SUM_NO_INDEX_USED BIGINT unsigned not null,"
+ "SUM_NO_GOOD_INDEX_USED BIGINT unsigned not null,"
+ "FIRST_SEEN TIMESTAMP(0) NOT NULL default 0,"
+ "LAST_SEEN TIMESTAMP(0) NOT NULL default 0)") },
+ false /* perpetual */
+};
+
+PFS_engine_table*
+table_esms_by_digest::create(void)
+{
+ return new table_esms_by_digest();
+}
+
+int
+table_esms_by_digest::delete_all_rows(void)
+{
+ reset_esms_by_digest();
+ return 0;
+}
+
+ha_rows
+table_esms_by_digest::get_row_count(void)
+{
+ return digest_max;
+}
+
+table_esms_by_digest::table_esms_by_digest()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(0), m_next_pos(0)
+{}
+
+void table_esms_by_digest::reset_position(void)
+{
+ m_pos= 0;
+ m_next_pos= 0;
+}
+
+int table_esms_by_digest::rnd_next(void)
+{
+ PFS_statements_digest_stat* digest_stat;
+
+ if (statements_digest_stat_array == NULL)
+ return HA_ERR_END_OF_FILE;
+
+ for (m_pos.set_at(&m_next_pos);
+ m_pos.m_index < digest_max;
+ m_pos.next())
+ {
+ digest_stat= &statements_digest_stat_array[m_pos.m_index];
+ if (digest_stat->m_lock.is_populated())
+ {
+ if (digest_stat->m_first_seen != 0)
+ {
+ make_row(digest_stat);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int
+table_esms_by_digest::rnd_pos(const void *pos)
+{
+ PFS_statements_digest_stat* digest_stat;
+
+ if (statements_digest_stat_array == NULL)
+ return HA_ERR_END_OF_FILE;
+
+ set_position(pos);
+ digest_stat= &statements_digest_stat_array[m_pos.m_index];
+
+ if (digest_stat->m_lock.is_populated())
+ {
+ if (digest_stat->m_first_seen != 0)
+ {
+ make_row(digest_stat);
+ return 0;
+ }
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+
+void table_esms_by_digest::make_row(PFS_statements_digest_stat* digest_stat)
+{
+ m_row_exists= false;
+ m_row.m_first_seen= digest_stat->m_first_seen;
+ m_row.m_last_seen= digest_stat->m_last_seen;
+ m_row.m_digest.make_row(digest_stat);
+
+ /*
+ Get statements stats.
+ */
+ time_normalizer *normalizer= time_normalizer::get(statement_timer);
+ m_row.m_stat.set(normalizer, & digest_stat->m_stat);
+
+ m_row_exists= true;
+}
+
+int table_esms_by_digest
+::read_row_values(TABLE *table, unsigned char *buf, Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /*
+ Set the null bits. It indicates how many fields could be null
+ in the table.
+ */
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* SCHEMA_NAME */
+ case 1: /* DIGEST */
+ case 2: /* DIGEST_TEXT */
+ m_row.m_digest.set_field(f->field_index, f);
+ break;
+ case 27: /* FIRST_SEEN */
+ set_field_timestamp(f, m_row.m_first_seen);
+ break;
+ case 28: /* LAST_SEEN */
+ set_field_timestamp(f, m_row.m_last_seen);
+ break;
+ default: /* 3, ... COUNT/SUM/MIN/AVG/MAX */
+ m_row.m_stat.set_field(f->field_index - 3, f);
+ break;
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_esms_by_digest.h b/storage/perfschema/table_esms_by_digest.h
new file mode 100644
index 00000000..9aa005bb
--- /dev/null
+++ b/storage/perfschema/table_esms_by_digest.h
@@ -0,0 +1,101 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_ESMS_BY_DIGEST_H
+#define TABLE_ESMS_BY_DIGEST_H
+
+/**
+ @file storage/perfschema/table_esms_by_digest.h
+ Table EVENTS_STATEMENTS_SUMMARY_BY_DIGEST (declarations).
+*/
+
+#include "table_helper.h"
+#include "pfs_digest.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/**
+ A row of table
+ PERFORMANCE_SCHEMA.EVENTS_STATEMENTS_SUMMARY_BY_DIGEST.
+*/
+struct row_esms_by_digest
+{
+ /** Columns DIGEST/DIGEST_TEXT. */
+ PFS_digest_row m_digest;
+
+ /** Columns COUNT_STAR, SUM/MIN/AVG/MAX TIMER_WAIT. */
+ PFS_statement_stat_row m_stat;
+
+ /** Column FIRST_SEEN. */
+ ulonglong m_first_seen;
+ /** Column LAST_SEEN. */
+ ulonglong m_last_seen;
+};
+
+/** Table PERFORMANCE_SCHEMA.EVENTS_STATEMENTS_SUMMARY_BY_DIGEST. */
+class table_esms_by_digest : public PFS_engine_table
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_esms_by_digest();
+
+public:
+ ~table_esms_by_digest()
+ {}
+
+protected:
+ void make_row(PFS_statements_digest_stat*);
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ /** Current row. */
+ row_esms_by_digest m_row;
+ /** True is the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ PFS_simple_index m_pos;
+ /** Next position. */
+ PFS_simple_index m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_esms_by_host_by_event_name.cc b/storage/perfschema/table_esms_by_host_by_event_name.cc
new file mode 100644
index 00000000..f5f6372d
--- /dev/null
+++ b/storage/perfschema/table_esms_by_host_by_event_name.cc
@@ -0,0 +1,233 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_esms_by_host_by_event_name.cc
+ Table EVENTS_STATEMENTS_SUMMARY_BY_HOST_BY_EVENT_NAME (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "pfs_instr_class.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "table_esms_by_host_by_event_name.h"
+#include "pfs_global.h"
+#include "pfs_account.h"
+#include "pfs_visitor.h"
+#include "pfs_buffer_container.h"
+#include "field.h"
+
+THR_LOCK table_esms_by_host_by_event_name::m_table_lock;
+
+PFS_engine_table_share
+table_esms_by_host_by_event_name::m_share=
+{
+ { C_STRING_WITH_LEN("events_statements_summary_by_host_by_event_name") },
+ &pfs_truncatable_acl,
+ table_esms_by_host_by_event_name::create,
+ NULL, /* write_row */
+ table_esms_by_host_by_event_name::delete_all_rows,
+ table_esms_by_host_by_event_name::get_row_count,
+ sizeof(pos_esms_by_host_by_event_name),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE events_statements_summary_by_host_by_event_name("
+ "HOST CHAR(" STRINGIFY_ARG(HOSTNAME_LENGTH) ") collate utf8_bin default null,"
+ "EVENT_NAME VARCHAR(128) not null,"
+ "COUNT_STAR BIGINT unsigned not null,"
+ "SUM_TIMER_WAIT BIGINT unsigned not null,"
+ "MIN_TIMER_WAIT BIGINT unsigned not null,"
+ "AVG_TIMER_WAIT BIGINT unsigned not null,"
+ "MAX_TIMER_WAIT BIGINT unsigned not null,"
+ "SUM_LOCK_TIME BIGINT unsigned not null,"
+ "SUM_ERRORS BIGINT unsigned not null,"
+ "SUM_WARNINGS BIGINT unsigned not null,"
+ "SUM_ROWS_AFFECTED BIGINT unsigned not null,"
+ "SUM_ROWS_SENT BIGINT unsigned not null,"
+ "SUM_ROWS_EXAMINED BIGINT unsigned not null,"
+ "SUM_CREATED_TMP_DISK_TABLES BIGINT unsigned not null,"
+ "SUM_CREATED_TMP_TABLES BIGINT unsigned not null,"
+ "SUM_SELECT_FULL_JOIN BIGINT unsigned not null,"
+ "SUM_SELECT_FULL_RANGE_JOIN BIGINT unsigned not null,"
+ "SUM_SELECT_RANGE BIGINT unsigned not null,"
+ "SUM_SELECT_RANGE_CHECK BIGINT unsigned not null,"
+ "SUM_SELECT_SCAN BIGINT unsigned not null,"
+ "SUM_SORT_MERGE_PASSES BIGINT unsigned not null,"
+ "SUM_SORT_RANGE BIGINT unsigned not null,"
+ "SUM_SORT_ROWS BIGINT unsigned not null,"
+ "SUM_SORT_SCAN BIGINT unsigned not null,"
+ "SUM_NO_INDEX_USED BIGINT unsigned not null,"
+ "SUM_NO_GOOD_INDEX_USED BIGINT unsigned not null)") },
+ false /* perpetual */
+};
+
+PFS_engine_table*
+table_esms_by_host_by_event_name::create(void)
+{
+ return new table_esms_by_host_by_event_name();
+}
+
+int
+table_esms_by_host_by_event_name::delete_all_rows(void)
+{
+ reset_events_statements_by_thread();
+ reset_events_statements_by_account();
+ reset_events_statements_by_host();
+ return 0;
+}
+
+ha_rows
+table_esms_by_host_by_event_name::get_row_count(void)
+{
+ return global_host_container.get_row_count() * statement_class_max;
+}
+
+table_esms_by_host_by_event_name::table_esms_by_host_by_event_name()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(), m_next_pos()
+{}
+
+void table_esms_by_host_by_event_name::reset_position(void)
+{
+ m_pos.reset();
+ m_next_pos.reset();
+}
+
+int table_esms_by_host_by_event_name::rnd_init(bool scan)
+{
+ m_normalizer= time_normalizer::get(statement_timer);
+ return 0;
+}
+
+int table_esms_by_host_by_event_name::rnd_next(void)
+{
+ PFS_host *host;
+ PFS_statement_class *statement_class;
+ bool has_more_host= true;
+
+ for (m_pos.set_at(&m_next_pos);
+ has_more_host;
+ m_pos.next_host())
+ {
+ host= global_host_container.get(m_pos.m_index_1, & has_more_host);
+ if (host != NULL)
+ {
+ statement_class= find_statement_class(m_pos.m_index_2);
+ if (statement_class)
+ {
+ make_row(host, statement_class);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int
+table_esms_by_host_by_event_name::rnd_pos(const void *pos)
+{
+ PFS_host *host;
+ PFS_statement_class *statement_class;
+
+ set_position(pos);
+
+ host= global_host_container.get(m_pos.m_index_1);
+ if (host != NULL)
+ {
+ statement_class= find_statement_class(m_pos.m_index_2);
+ if (statement_class)
+ {
+ make_row(host, statement_class);
+ return 0;
+ }
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_esms_by_host_by_event_name
+::make_row(PFS_host *host, PFS_statement_class *klass)
+{
+ pfs_optimistic_state lock;
+ m_row_exists= false;
+
+ if (klass->is_mutable())
+ return;
+
+ host->m_lock.begin_optimistic_lock(&lock);
+
+ if (m_row.m_host.make_row(host))
+ return;
+
+ m_row.m_event_name.make_row(klass);
+
+ PFS_connection_statement_visitor visitor(klass);
+ PFS_connection_iterator::visit_host(host,
+ true, /* accounts */
+ true, /* threads */
+ false, /* THDs */
+ & visitor);
+
+ if (! host->m_lock.end_optimistic_lock(&lock))
+ return;
+
+ m_row_exists= true;
+ m_row.m_stat.set(m_normalizer, & visitor.m_stat);
+}
+
+int table_esms_by_host_by_event_name
+::read_row_values(TABLE *table, unsigned char *buf, Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* HOST */
+ m_row.m_host.set_field(f);
+ break;
+ case 1: /* EVENT_NAME */
+ m_row.m_event_name.set_field(f);
+ break;
+ default: /* 2, ... COUNT/SUM/MIN/AVG/MAX */
+ m_row.m_stat.set_field(f->field_index - 2, f);
+ break;
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_esms_by_host_by_event_name.h b/storage/perfschema/table_esms_by_host_by_event_name.h
new file mode 100644
index 00000000..807db6d4
--- /dev/null
+++ b/storage/perfschema/table_esms_by_host_by_event_name.h
@@ -0,0 +1,128 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_ESMS_BY_HOST_BY_EVENT_NAME_H
+#define TABLE_ESMS_BY_HOST_BY_EVENT_NAME_H
+
+/**
+ @file storage/perfschema/table_esms_by_host_by_event_name.h
+ Table EVENTS_STATEMENTS_SUMMARY_BY_HOST_BY_EVENT_NAME (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "pfs_host.h"
+#include "table_helper.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/**
+ A row of table
+ PERFORMANCE_SCHEMA.EVENTS_STATEMENTS_SUMMARY_BY_HOST_BY_EVENT_NAME.
+*/
+struct row_esms_by_host_by_event_name
+{
+ /** Column HOST */
+ PFS_host_row m_host;
+ /** Column EVENT_NAME */
+ PFS_event_name_row m_event_name;
+ /** Columns COUNT_STAR, SUM/MIN/AVG/MAX TIMER_WAIT. */
+ PFS_statement_stat_row m_stat;
+};
+
+/**
+ Position of a cursor on
+ PERFORMANCE_SCHEMA.EVENTS_STATEMENTS_SUMMARY_BY_HOST_BY_EVENT_NAME.
+ Index 1 on host (0 based)
+ Index 2 on statement class (1 based)
+*/
+struct pos_esms_by_host_by_event_name
+: public PFS_double_index
+{
+ pos_esms_by_host_by_event_name()
+ : PFS_double_index(0, 1)
+ {}
+
+ inline void reset(void)
+ {
+ m_index_1= 0;
+ m_index_2= 1;
+ }
+
+ inline void next_host(void)
+ {
+ m_index_1++;
+ m_index_2= 1;
+ }
+};
+
+/** Table PERFORMANCE_SCHEMA.EVENTS_STATEMENTS_SUMMARY_BY_HOST_BY_EVENT_NAME. */
+class table_esms_by_host_by_event_name : public PFS_engine_table
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_init(bool scan);
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_esms_by_host_by_event_name();
+
+public:
+ ~table_esms_by_host_by_event_name()
+ {}
+
+protected:
+ void make_row(PFS_host *host, PFS_statement_class *klass);
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ /** Current row. */
+ row_esms_by_host_by_event_name m_row;
+ /** True is the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ pos_esms_by_host_by_event_name m_pos;
+ /** Next position. */
+ pos_esms_by_host_by_event_name m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_esms_by_program.cc b/storage/perfschema/table_esms_by_program.cc
new file mode 100644
index 00000000..3cb2e4a4
--- /dev/null
+++ b/storage/perfschema/table_esms_by_program.cc
@@ -0,0 +1,245 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_esms_by_program.cc
+ Table EVENTS_STATEMENTS_SUMMARY_BY_PROGRAM (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "pfs_instr_class.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "pfs_global.h"
+#include "pfs_instr.h"
+#include "pfs_timer.h"
+#include "pfs_visitor.h"
+#include "pfs_program.h"
+#include "table_esms_by_program.h"
+#include "pfs_buffer_container.h"
+#include "field.h"
+
+THR_LOCK table_esms_by_program::m_table_lock;
+
+PFS_engine_table_share
+table_esms_by_program::m_share=
+{
+ { C_STRING_WITH_LEN("events_statements_summary_by_program") },
+ &pfs_truncatable_acl,
+ table_esms_by_program::create,
+ NULL, /* write_row */
+ table_esms_by_program::delete_all_rows,
+ table_esms_by_program::get_row_count,
+ sizeof(PFS_simple_index),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE events_statements_summary_by_program ("
+ "OBJECT_TYPE enum('EVENT', 'FUNCTION', 'PROCEDURE', 'TABLE', 'TRIGGER'),"
+ "OBJECT_SCHEMA varchar(64) NOT NULL,"
+ "OBJECT_NAME varchar(64) NOT NULL,"
+ "COUNT_STAR bigint(20) unsigned NOT NULL,"
+ "SUM_TIMER_WAIT bigint(20) unsigned NOT NULL,"
+ "MIN_TIMER_WAIT bigint(20) unsigned NOT NULL,"
+ "AVG_TIMER_WAIT bigint(20) unsigned NOT NULL,"
+ "MAX_TIMER_WAIT bigint(20) unsigned NOT NULL,"
+ "COUNT_STATEMENTS bigint(20) unsigned NOT NULL,"
+ "SUM_STATEMENTS_WAIT bigint(20) unsigned NOT NULL,"
+ "MIN_STATEMENTS_WAIT bigint(20) unsigned NOT NULL,"
+ "AVG_STATEMENTS_WAIT bigint(20) unsigned NOT NULL,"
+ "MAX_STATEMENTS_WAIT bigint(20) unsigned NOT NULL,"
+ "SUM_LOCK_TIME bigint(20) unsigned NOT NULL,"
+ "SUM_ERRORS bigint(20) unsigned NOT NULL,"
+ "SUM_WARNINGS bigint(20) unsigned NOT NULL,"
+ "SUM_ROWS_AFFECTED bigint(20) unsigned NOT NULL,"
+ "SUM_ROWS_SENT bigint(20) unsigned NOT NULL,"
+ "SUM_ROWS_EXAMINED bigint(20) unsigned NOT NULL,"
+ "SUM_CREATED_TMP_DISK_TABLES bigint(20) unsigned NOT NULL,"
+ "SUM_CREATED_TMP_TABLES bigint(20) unsigned NOT NULL,"
+ "SUM_SELECT_FULL_JOIN bigint(20) unsigned NOT NULL,"
+ "SUM_SELECT_FULL_RANGE_JOIN bigint(20) unsigned NOT NULL,"
+ "SUM_SELECT_RANGE bigint(20) unsigned NOT NULL,"
+ "SUM_SELECT_RANGE_CHECK bigint(20) unsigned NOT NULL,"
+ "SUM_SELECT_SCAN bigint(20) unsigned NOT NULL,"
+ "SUM_SORT_MERGE_PASSES bigint(20) unsigned NOT NULL,"
+ "SUM_SORT_RANGE bigint(20) unsigned NOT NULL,"
+ "SUM_SORT_ROWS bigint(20) unsigned NOT NULL,"
+ "SUM_SORT_SCAN bigint(20) unsigned NOT NULL,"
+ "SUM_NO_INDEX_USED bigint(20) unsigned NOT NULL,"
+ "SUM_NO_GOOD_INDEX_USED bigint(20) unsigned NOT NULL)")},
+ false /* perpetual */
+};
+
+PFS_engine_table*
+table_esms_by_program::create(void)
+{
+ return new table_esms_by_program();
+}
+
+int
+table_esms_by_program::delete_all_rows(void)
+{
+ reset_esms_by_program();
+ return 0;
+}
+
+ha_rows
+table_esms_by_program::get_row_count(void)
+{
+ return global_program_container.get_row_count();
+}
+
+table_esms_by_program::table_esms_by_program()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(0), m_next_pos(0)
+{}
+
+void table_esms_by_program::reset_position(void)
+{
+ m_pos= 0;
+ m_next_pos= 0;
+}
+
+int table_esms_by_program::rnd_next(void)
+{
+ PFS_program* pfs;
+
+ m_pos.set_at(&m_next_pos);
+ PFS_program_iterator it= global_program_container.iterate(m_pos.m_index);
+ pfs= it.scan_next(& m_pos.m_index);
+ if (pfs != NULL)
+ {
+ make_row(pfs);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int
+table_esms_by_program::rnd_pos(const void *pos)
+{
+ PFS_program* pfs;
+
+ set_position(pos);
+
+ pfs= global_program_container.get(m_pos.m_index);
+ if (pfs != NULL)
+ {
+ make_row(pfs);
+ return 0;
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+
+void table_esms_by_program::make_row(PFS_program* program)
+{
+ pfs_optimistic_state lock;
+ m_row_exists= false;
+
+ program->m_lock.begin_optimistic_lock(&lock);
+
+ m_row.m_object_type= program->m_type;
+
+ m_row.m_object_name_length= program->m_object_name_length;
+ if(m_row.m_object_name_length > 0)
+ memcpy(m_row.m_object_name, program->m_object_name,
+ m_row.m_object_name_length);
+
+ m_row.m_schema_name_length= program->m_schema_name_length;
+ if(m_row.m_schema_name_length > 0)
+ memcpy(m_row.m_schema_name, program->m_schema_name,
+ m_row.m_schema_name_length);
+
+ time_normalizer *normalizer= time_normalizer::get(statement_timer);
+ /* Get stored program's over all stats. */
+ m_row.m_sp_stat.set(normalizer, &program->m_sp_stat);
+ /* Get sub statements' stats. */
+ m_row.m_stmt_stat.set(normalizer, & program->m_stmt_stat);
+
+ if (! program->m_lock.end_optimistic_lock(&lock))
+ return;
+
+ m_row_exists= true;
+}
+
+int table_esms_by_program
+::read_row_values(TABLE *table, unsigned char *buf, Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /*
+ Set the null bits. It indicates how many fields could be null
+ in the table.
+ */
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* OBJECT_TYPE */
+ if(m_row.m_object_type != 0)
+ set_field_enum(f, m_row.m_object_type);
+ else
+ f->set_null();
+ break;
+ case 1: /* OBJECT_SCHEMA */
+ if(m_row.m_schema_name_length > 0)
+ set_field_varchar_utf8(f, m_row.m_schema_name,
+ m_row.m_schema_name_length);
+ else
+ f->set_null();
+ break;
+ case 2: /* OBJECT_NAME */
+ if(m_row.m_object_name_length > 0)
+ set_field_varchar_utf8(f, m_row.m_object_name,
+ m_row.m_object_name_length);
+ else
+ f->set_null();
+ break;
+ case 3: /* COUNT_STAR */
+ case 4: /* SUM_TIMER_WAIT */
+ case 5: /* MIN_TIMER_WAIT */
+ case 6: /* AVG_TIMER_WAIT */
+ case 7: /* MAX_TIMER_WAIT */
+ m_row.m_sp_stat.set_field(f->field_index - 3, f);
+ break;
+ default: /* 8, ... COUNT/SUM/MIN/AVG/MAX */
+ m_row.m_stmt_stat.set_field(f->field_index - 8, f);
+ break;
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_esms_by_program.h b/storage/perfschema/table_esms_by_program.h
new file mode 100644
index 00000000..cc263878
--- /dev/null
+++ b/storage/perfschema/table_esms_by_program.h
@@ -0,0 +1,113 @@
+/* Copyright (c) 2013, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_ESMS_BY_PROGRAM_H
+#define TABLE_ESMS_BY_PROGRAM_H
+
+/**
+ @file storage/perfschema/table_esms_by_program.h
+ Table EVENTS_STATEMENTS_SUMMARY_BY_PROGRAM (declarations).
+*/
+
+#include "table_helper.h"
+#include "pfs_program.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/**
+ A row of table
+ PERFORMANCE_SCHEMA.EVENTS_STATEMENTS_SUMMARY_BY_PROGRAM.
+*/
+struct row_esms_by_program
+{
+ /** Column OBJECT_TYPE. */
+ enum_object_type m_object_type;
+ /** Column OBJECT_SCHEMA. */
+ char m_schema_name[COL_OBJECT_SCHEMA_SIZE];
+ int m_schema_name_length;
+ /** Column OBJECT_NAME. */
+ char m_object_name[COL_OBJECT_NAME_SIZE];
+ int m_object_name_length;
+
+ /**
+ Columns COUNT_STAR
+ SUM_TIMER_WAIT
+ MIN_TIMER_WAIT
+ AVG_TIMER_WAIT
+ MAX_TIMER_WAIT
+ */
+ PFS_sp_stat_row m_sp_stat;
+
+ /** Columns COUNT_STATEMENTS,SUM_STATEMENTS_WAIT...SUM_NO_GOOD_INDEX_USED. */
+ PFS_statement_stat_row m_stmt_stat;
+};
+
+/** Table PERFORMANCE_SCHEMA.EVENTS_STATEMENTS_SUMMARY_BY_PROGRAM. */
+class table_esms_by_program : public PFS_engine_table
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_esms_by_program();
+
+public:
+ ~table_esms_by_program()
+ {}
+
+protected:
+ void make_row(PFS_program*);
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+ /** Fields definition. */
+ static TABLE_FIELD_DEF m_field_def;
+
+ /** Current row. */
+ row_esms_by_program m_row;
+ /** True is the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ PFS_simple_index m_pos;
+ /** Next position. */
+ PFS_simple_index m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_esms_by_thread_by_event_name.cc b/storage/perfschema/table_esms_by_thread_by_event_name.cc
new file mode 100644
index 00000000..306edc76
--- /dev/null
+++ b/storage/perfschema/table_esms_by_thread_by_event_name.cc
@@ -0,0 +1,225 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_esms_by_thread_by_event_name.cc
+ Table EVENTS_STATEMENTS_SUMMARY_BY_HOST_BY_EVENT_NAME (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "pfs_instr_class.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "table_esms_by_thread_by_event_name.h"
+#include "pfs_global.h"
+#include "pfs_visitor.h"
+#include "pfs_buffer_container.h"
+#include "field.h"
+
+THR_LOCK table_esms_by_thread_by_event_name::m_table_lock;
+
+PFS_engine_table_share
+table_esms_by_thread_by_event_name::m_share=
+{
+ { C_STRING_WITH_LEN("events_statements_summary_by_thread_by_event_name") },
+ &pfs_truncatable_acl,
+ table_esms_by_thread_by_event_name::create,
+ NULL, /* write_row */
+ table_esms_by_thread_by_event_name::delete_all_rows,
+ table_esms_by_thread_by_event_name::get_row_count,
+ sizeof(pos_esms_by_thread_by_event_name),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE events_statements_summary_by_thread_by_event_name("
+ "THREAD_ID BIGINT unsigned not null,"
+ "EVENT_NAME VARCHAR(128) not null,"
+ "COUNT_STAR BIGINT unsigned not null,"
+ "SUM_TIMER_WAIT BIGINT unsigned not null,"
+ "MIN_TIMER_WAIT BIGINT unsigned not null,"
+ "AVG_TIMER_WAIT BIGINT unsigned not null,"
+ "MAX_TIMER_WAIT BIGINT unsigned not null,"
+ "SUM_LOCK_TIME BIGINT unsigned not null,"
+ "SUM_ERRORS BIGINT unsigned not null,"
+ "SUM_WARNINGS BIGINT unsigned not null,"
+ "SUM_ROWS_AFFECTED BIGINT unsigned not null,"
+ "SUM_ROWS_SENT BIGINT unsigned not null,"
+ "SUM_ROWS_EXAMINED BIGINT unsigned not null,"
+ "SUM_CREATED_TMP_DISK_TABLES BIGINT unsigned not null,"
+ "SUM_CREATED_TMP_TABLES BIGINT unsigned not null,"
+ "SUM_SELECT_FULL_JOIN BIGINT unsigned not null,"
+ "SUM_SELECT_FULL_RANGE_JOIN BIGINT unsigned not null,"
+ "SUM_SELECT_RANGE BIGINT unsigned not null,"
+ "SUM_SELECT_RANGE_CHECK BIGINT unsigned not null,"
+ "SUM_SELECT_SCAN BIGINT unsigned not null,"
+ "SUM_SORT_MERGE_PASSES BIGINT unsigned not null,"
+ "SUM_SORT_RANGE BIGINT unsigned not null,"
+ "SUM_SORT_ROWS BIGINT unsigned not null,"
+ "SUM_SORT_SCAN BIGINT unsigned not null,"
+ "SUM_NO_INDEX_USED BIGINT unsigned not null,"
+ "SUM_NO_GOOD_INDEX_USED BIGINT unsigned not null)") },
+ false /* perpetual */
+};
+
+PFS_engine_table*
+table_esms_by_thread_by_event_name::create(void)
+{
+ return new table_esms_by_thread_by_event_name();
+}
+
+int
+table_esms_by_thread_by_event_name::delete_all_rows(void)
+{
+ reset_events_statements_by_thread();
+ return 0;
+}
+
+ha_rows
+table_esms_by_thread_by_event_name::get_row_count(void)
+{
+ return global_thread_container.get_row_count() * statement_class_max;
+}
+
+table_esms_by_thread_by_event_name::table_esms_by_thread_by_event_name()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(), m_next_pos()
+{}
+
+void table_esms_by_thread_by_event_name::reset_position(void)
+{
+ m_pos.reset();
+ m_next_pos.reset();
+}
+
+int table_esms_by_thread_by_event_name::rnd_init(bool scan)
+{
+ m_normalizer= time_normalizer::get(statement_timer);
+ return 0;
+}
+
+int table_esms_by_thread_by_event_name::rnd_next(void)
+{
+ PFS_thread *thread;
+ PFS_statement_class *statement_class;
+ bool has_more_thread= true;
+
+ for (m_pos.set_at(&m_next_pos);
+ has_more_thread;
+ m_pos.next_thread())
+ {
+ thread= global_thread_container.get(m_pos.m_index_1, & has_more_thread);
+ if (thread != NULL)
+ {
+ statement_class= find_statement_class(m_pos.m_index_2);
+ if (statement_class)
+ {
+ make_row(thread, statement_class);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int
+table_esms_by_thread_by_event_name::rnd_pos(const void *pos)
+{
+ PFS_thread *thread;
+ PFS_statement_class *statement_class;
+
+ set_position(pos);
+
+ thread= global_thread_container.get(m_pos.m_index_1);
+ if (thread != NULL)
+ {
+ statement_class= find_statement_class(m_pos.m_index_2);
+ if (statement_class)
+ {
+ make_row(thread, statement_class);
+ return 0;
+ }
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_esms_by_thread_by_event_name
+::make_row(PFS_thread *thread, PFS_statement_class *klass)
+{
+ pfs_optimistic_state lock;
+ m_row_exists= false;
+
+ if (klass->is_mutable())
+ return;
+
+ /* Protect this reader against a thread termination */
+ thread->m_lock.begin_optimistic_lock(&lock);
+
+ m_row.m_thread_internal_id= thread->m_thread_internal_id;
+
+ m_row.m_event_name.make_row(klass);
+
+ PFS_connection_statement_visitor visitor(klass);
+ PFS_connection_iterator::visit_thread(thread, & visitor);
+
+ if (! thread->m_lock.end_optimistic_lock(&lock))
+ return;
+
+ m_row_exists= true;
+ m_row.m_stat.set(m_normalizer, & visitor.m_stat);
+}
+
+int table_esms_by_thread_by_event_name
+::read_row_values(TABLE *table, unsigned char *, Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 0);
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* THREAD_ID */
+ set_field_ulonglong(f, m_row.m_thread_internal_id);
+ break;
+ case 1: /* EVENT_NAME */
+ m_row.m_event_name.set_field(f);
+ break;
+ default: /* 2, ... COUNT/SUM/MIN/AVG/MAX */
+ m_row.m_stat.set_field(f->field_index - 2, f);
+ break;
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_esms_by_thread_by_event_name.h b/storage/perfschema/table_esms_by_thread_by_event_name.h
new file mode 100644
index 00000000..41fec4e1
--- /dev/null
+++ b/storage/perfschema/table_esms_by_thread_by_event_name.h
@@ -0,0 +1,132 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_ESMS_BY_THREAD_BY_EVENT_NAME_H
+#define TABLE_ESMS_BY_THREAD_BY_EVENT_NAME_H
+
+/**
+ @file storage/perfschema/table_esms_by_thread_by_event_name.h
+ Table EVENTS_STATEMENTS_SUMMARY_BY_THREAD_BY_EVENT_NAME (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "table_helper.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/**
+ A row of table
+ PERFORMANCE_SCHEMA.EVENTS_STATEMENTS_SUMMARY_BY_THREAD_BY_EVENT_NAME.
+*/
+struct row_esms_by_thread_by_event_name
+{
+ /** Column THREAD_ID. */
+ ulonglong m_thread_internal_id;
+ /** Column EVENT_NAME. */
+ PFS_event_name_row m_event_name;
+ /** Columns COUNT_STAR, SUM/MIN/AVG/MAX TIMER_WAIT. */
+ PFS_statement_stat_row m_stat;
+};
+
+/**
+ Position of a cursor on
+ PERFORMANCE_SCHEMA.EVENTS_STATEMENTS_SUMMARY_BY_THREAD_BY_EVENT_NAME.
+ Index 1 on thread (0 based).
+ Index 2 on statement class (1 based).
+*/
+struct pos_esms_by_thread_by_event_name
+: public PFS_double_index, public PFS_instrument_view_constants
+{
+ pos_esms_by_thread_by_event_name()
+ : PFS_double_index(0, 1)
+ {}
+
+ inline void reset(void)
+ {
+ m_index_1= 0;
+ m_index_2= 1;
+ }
+
+ inline void next_thread(void)
+ {
+ m_index_1++;
+ m_index_2= 1;
+ }
+
+ inline void next_statement(void)
+ {
+ m_index_2++;
+ }
+};
+
+/** Table PERFORMANCE_SCHEMA.EVENTS_STATEMENTS_SUMMARY_BY_THREAD_BY_EVENT_NAME. */
+class table_esms_by_thread_by_event_name : public PFS_engine_table
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_init(bool scan);
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_esms_by_thread_by_event_name();
+
+public:
+ ~table_esms_by_thread_by_event_name()
+ {}
+
+protected:
+ void make_row(PFS_thread *thread, PFS_statement_class *klass);
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ /** Current row. */
+ row_esms_by_thread_by_event_name m_row;
+ /** True is the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ pos_esms_by_thread_by_event_name m_pos;
+ /** Next position. */
+ pos_esms_by_thread_by_event_name m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_esms_by_user_by_event_name.cc b/storage/perfschema/table_esms_by_user_by_event_name.cc
new file mode 100644
index 00000000..c0517748
--- /dev/null
+++ b/storage/perfschema/table_esms_by_user_by_event_name.cc
@@ -0,0 +1,232 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_esms_by_user_by_event_name.cc
+ Table EVENTS_STATEMENTS_SUMMARY_BY_USER_BY_EVENT_NAME (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "pfs_instr_class.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "table_esms_by_user_by_event_name.h"
+#include "pfs_global.h"
+#include "pfs_visitor.h"
+#include "pfs_buffer_container.h"
+#include "field.h"
+
+THR_LOCK table_esms_by_user_by_event_name::m_table_lock;
+
+PFS_engine_table_share
+table_esms_by_user_by_event_name::m_share=
+{
+ { C_STRING_WITH_LEN("events_statements_summary_by_user_by_event_name") },
+ &pfs_truncatable_acl,
+ table_esms_by_user_by_event_name::create,
+ NULL, /* write_row */
+ table_esms_by_user_by_event_name::delete_all_rows,
+ table_esms_by_user_by_event_name::get_row_count,
+ sizeof(pos_esms_by_user_by_event_name),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE events_statements_summary_by_user_by_event_name("
+ "USER CHAR(" USERNAME_CHAR_LENGTH_STR ") collate utf8_bin default null,"
+ "EVENT_NAME VARCHAR(128) not null,"
+ "COUNT_STAR BIGINT unsigned not null,"
+ "SUM_TIMER_WAIT BIGINT unsigned not null,"
+ "MIN_TIMER_WAIT BIGINT unsigned not null,"
+ "AVG_TIMER_WAIT BIGINT unsigned not null,"
+ "MAX_TIMER_WAIT BIGINT unsigned not null,"
+ "SUM_LOCK_TIME BIGINT unsigned not null,"
+ "SUM_ERRORS BIGINT unsigned not null,"
+ "SUM_WARNINGS BIGINT unsigned not null,"
+ "SUM_ROWS_AFFECTED BIGINT unsigned not null,"
+ "SUM_ROWS_SENT BIGINT unsigned not null,"
+ "SUM_ROWS_EXAMINED BIGINT unsigned not null,"
+ "SUM_CREATED_TMP_DISK_TABLES BIGINT unsigned not null,"
+ "SUM_CREATED_TMP_TABLES BIGINT unsigned not null,"
+ "SUM_SELECT_FULL_JOIN BIGINT unsigned not null,"
+ "SUM_SELECT_FULL_RANGE_JOIN BIGINT unsigned not null,"
+ "SUM_SELECT_RANGE BIGINT unsigned not null,"
+ "SUM_SELECT_RANGE_CHECK BIGINT unsigned not null,"
+ "SUM_SELECT_SCAN BIGINT unsigned not null,"
+ "SUM_SORT_MERGE_PASSES BIGINT unsigned not null,"
+ "SUM_SORT_RANGE BIGINT unsigned not null,"
+ "SUM_SORT_ROWS BIGINT unsigned not null,"
+ "SUM_SORT_SCAN BIGINT unsigned not null,"
+ "SUM_NO_INDEX_USED BIGINT unsigned not null,"
+ "SUM_NO_GOOD_INDEX_USED BIGINT unsigned not null)") },
+ false /* perpetual */
+};
+
+PFS_engine_table*
+table_esms_by_user_by_event_name::create(void)
+{
+ return new table_esms_by_user_by_event_name();
+}
+
+int
+table_esms_by_user_by_event_name::delete_all_rows(void)
+{
+ reset_events_statements_by_thread();
+ reset_events_statements_by_account();
+ reset_events_statements_by_user();
+ return 0;
+}
+
+ha_rows
+table_esms_by_user_by_event_name::get_row_count(void)
+{
+ return global_user_container.get_row_count() * statement_class_max;
+}
+
+table_esms_by_user_by_event_name::table_esms_by_user_by_event_name()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(), m_next_pos()
+{}
+
+void table_esms_by_user_by_event_name::reset_position(void)
+{
+ m_pos.reset();
+ m_next_pos.reset();
+}
+
+int table_esms_by_user_by_event_name::rnd_init(bool scan)
+{
+ m_normalizer= time_normalizer::get(statement_timer);
+ return 0;
+}
+
+int table_esms_by_user_by_event_name::rnd_next(void)
+{
+ PFS_user *user;
+ PFS_statement_class *statement_class;
+ bool has_more_user= true;
+
+ for (m_pos.set_at(&m_next_pos);
+ has_more_user;
+ m_pos.next_user())
+ {
+ user= global_user_container.get(m_pos.m_index_1, & has_more_user);
+ if (user != NULL)
+ {
+ statement_class= find_statement_class(m_pos.m_index_2);
+ if (statement_class)
+ {
+ make_row(user, statement_class);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int
+table_esms_by_user_by_event_name::rnd_pos(const void *pos)
+{
+ PFS_user *user;
+ PFS_statement_class *statement_class;
+
+ set_position(pos);
+
+ user= global_user_container.get(m_pos.m_index_1);
+ if (user != NULL)
+ {
+ statement_class= find_statement_class(m_pos.m_index_2);
+ if (statement_class)
+ {
+ make_row(user, statement_class);
+ return 0;
+ }
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_esms_by_user_by_event_name
+::make_row(PFS_user *user, PFS_statement_class *klass)
+{
+ pfs_optimistic_state lock;
+ m_row_exists= false;
+
+ if (klass->is_mutable())
+ return;
+
+ user->m_lock.begin_optimistic_lock(&lock);
+
+ if (m_row.m_user.make_row(user))
+ return;
+
+ m_row.m_event_name.make_row(klass);
+
+ PFS_connection_statement_visitor visitor(klass);
+ PFS_connection_iterator::visit_user(user,
+ true, /* accounts */
+ true, /* threads */
+ false, /* THDs */
+ & visitor);
+
+ if (! user->m_lock.end_optimistic_lock(&lock))
+ return;
+
+ m_row_exists= true;
+ m_row.m_stat.set(m_normalizer, & visitor.m_stat);
+}
+
+int table_esms_by_user_by_event_name
+::read_row_values(TABLE *table, unsigned char *buf, Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* USER */
+ m_row.m_user.set_field(f);
+ break;
+ case 1: /* EVENT_NAME */
+ m_row.m_event_name.set_field(f);
+ break;
+ default: /* 2, ... COUNT/SUM/MIN/AVG/MAX */
+ m_row.m_stat.set_field(f->field_index - 2, f);
+ break;
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_esms_by_user_by_event_name.h b/storage/perfschema/table_esms_by_user_by_event_name.h
new file mode 100644
index 00000000..0ed9899d
--- /dev/null
+++ b/storage/perfschema/table_esms_by_user_by_event_name.h
@@ -0,0 +1,128 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_ESMS_BY_USER_BY_EVENT_NAME_H
+#define TABLE_ESMS_BY_USER_BY_EVENT_NAME_H
+
+/**
+ @file storage/perfschema/table_esms_by_user_by_event_name.h
+ Table EVENTS_STATEMENTS_SUMMARY_BY_USER_BY_EVENT_NAME (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "pfs_user.h"
+#include "table_helper.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/**
+ A row of table
+ PERFORMANCE_SCHEMA.EVENTS_STATEMENTS_SUMMARY_BY_USER_BY_EVENT_NAME.
+*/
+struct row_esms_by_user_by_event_name
+{
+ /** Column USER. */
+ PFS_user_row m_user;
+ /** Column EVENT_NAME. */
+ PFS_event_name_row m_event_name;
+ /** Columns COUNT_STAR, SUM/MIN/AVG/MAX TIMER_WAIT. */
+ PFS_statement_stat_row m_stat;
+};
+
+/**
+ Position of a cursor on
+ PERFORMANCE_SCHEMA.EVENTS_STATEMENTS_SUMMARY_BY_USER_BY_EVENT_NAME.
+ Index 1 on user (0 based)
+ Index 2 on statement class (1 based)
+*/
+struct pos_esms_by_user_by_event_name
+: public PFS_double_index
+{
+ pos_esms_by_user_by_event_name()
+ : PFS_double_index(0, 1)
+ {}
+
+ inline void reset(void)
+ {
+ m_index_1= 0;
+ m_index_2= 1;
+ }
+
+ inline void next_user(void)
+ {
+ m_index_1++;
+ m_index_2= 1;
+ }
+};
+
+/** Table PERFORMANCE_SCHEMA.EVENTS_STATEMENTS_SUMMARY_BY_USER_BY_EVENT_NAME. */
+class table_esms_by_user_by_event_name : public PFS_engine_table
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_init(bool scan);
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_esms_by_user_by_event_name();
+
+public:
+ ~table_esms_by_user_by_event_name()
+ {}
+
+protected:
+ void make_row(PFS_user *user, PFS_statement_class *klass);
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ /** Current row. */
+ row_esms_by_user_by_event_name m_row;
+ /** True is the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ pos_esms_by_user_by_event_name m_pos;
+ /** Next position. */
+ pos_esms_by_user_by_event_name m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_esms_global_by_event_name.cc b/storage/perfschema/table_esms_global_by_event_name.cc
new file mode 100644
index 00000000..6e2408be
--- /dev/null
+++ b/storage/perfschema/table_esms_global_by_event_name.cc
@@ -0,0 +1,215 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_esms_global_by_event_name.cc
+ Table EVENTS_STATEMENTS_SUMMARY_GLOBAL_BY_EVENT_NAME (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "pfs_instr_class.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "table_esms_global_by_event_name.h"
+#include "pfs_global.h"
+#include "pfs_instr.h"
+#include "pfs_timer.h"
+#include "pfs_visitor.h"
+#include "field.h"
+
+THR_LOCK table_esms_global_by_event_name::m_table_lock;
+
+PFS_engine_table_share
+table_esms_global_by_event_name::m_share=
+{
+ { C_STRING_WITH_LEN("events_statements_summary_global_by_event_name") },
+ &pfs_truncatable_acl,
+ table_esms_global_by_event_name::create,
+ NULL, /* write_row */
+ table_esms_global_by_event_name::delete_all_rows,
+ table_esms_global_by_event_name::get_row_count,
+ sizeof(PFS_simple_index),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE events_statements_summary_global_by_event_name("
+ "EVENT_NAME VARCHAR(128) not null,"
+ "COUNT_STAR BIGINT unsigned not null,"
+ "SUM_TIMER_WAIT BIGINT unsigned not null,"
+ "MIN_TIMER_WAIT BIGINT unsigned not null,"
+ "AVG_TIMER_WAIT BIGINT unsigned not null,"
+ "MAX_TIMER_WAIT BIGINT unsigned not null,"
+ "SUM_LOCK_TIME BIGINT unsigned not null,"
+ "SUM_ERRORS BIGINT unsigned not null,"
+ "SUM_WARNINGS BIGINT unsigned not null,"
+ "SUM_ROWS_AFFECTED BIGINT unsigned not null,"
+ "SUM_ROWS_SENT BIGINT unsigned not null,"
+ "SUM_ROWS_EXAMINED BIGINT unsigned not null,"
+ "SUM_CREATED_TMP_DISK_TABLES BIGINT unsigned not null,"
+ "SUM_CREATED_TMP_TABLES BIGINT unsigned not null,"
+ "SUM_SELECT_FULL_JOIN BIGINT unsigned not null,"
+ "SUM_SELECT_FULL_RANGE_JOIN BIGINT unsigned not null,"
+ "SUM_SELECT_RANGE BIGINT unsigned not null,"
+ "SUM_SELECT_RANGE_CHECK BIGINT unsigned not null,"
+ "SUM_SELECT_SCAN BIGINT unsigned not null,"
+ "SUM_SORT_MERGE_PASSES BIGINT unsigned not null,"
+ "SUM_SORT_RANGE BIGINT unsigned not null,"
+ "SUM_SORT_ROWS BIGINT unsigned not null,"
+ "SUM_SORT_SCAN BIGINT unsigned not null,"
+ "SUM_NO_INDEX_USED BIGINT unsigned not null,"
+ "SUM_NO_GOOD_INDEX_USED BIGINT unsigned not null)") },
+ false /* perpetual */
+};
+
+PFS_engine_table*
+table_esms_global_by_event_name::create(void)
+{
+ return new table_esms_global_by_event_name();
+}
+
+int
+table_esms_global_by_event_name::delete_all_rows(void)
+{
+ reset_events_statements_by_thread();
+ reset_events_statements_by_account();
+ reset_events_statements_by_user();
+ reset_events_statements_by_host();
+ reset_events_statements_global();
+ return 0;
+}
+
+ha_rows
+table_esms_global_by_event_name::get_row_count(void)
+{
+ return statement_class_max;
+}
+
+table_esms_global_by_event_name::table_esms_global_by_event_name()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(1), m_next_pos(1)
+{}
+
+void table_esms_global_by_event_name::reset_position(void)
+{
+ m_pos= 1;
+ m_next_pos= 1;
+}
+
+int table_esms_global_by_event_name::rnd_init(bool scan)
+{
+ m_normalizer= time_normalizer::get(statement_timer);
+ return 0;
+}
+
+int table_esms_global_by_event_name::rnd_next(void)
+{
+ PFS_statement_class *statement_class;
+
+ if (global_instr_class_statements_array == NULL)
+ return HA_ERR_END_OF_FILE;
+
+ m_pos.set_at(&m_next_pos);
+
+ statement_class= find_statement_class(m_pos.m_index);
+ if (statement_class)
+ {
+ make_row(statement_class);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int
+table_esms_global_by_event_name::rnd_pos(const void *pos)
+{
+ PFS_statement_class *statement_class;
+
+ set_position(pos);
+
+ if (global_instr_class_statements_array == NULL)
+ return HA_ERR_END_OF_FILE;
+
+ statement_class=find_statement_class(m_pos.m_index);
+ if (statement_class)
+ {
+ make_row(statement_class);
+ return 0;
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+
+void table_esms_global_by_event_name
+::make_row(PFS_statement_class *klass)
+{
+ m_row_exists= false;
+
+ if (klass->is_mutable())
+ return;
+
+ m_row.m_event_name.make_row(klass);
+
+ PFS_connection_statement_visitor visitor(klass);
+ PFS_connection_iterator::visit_global(true, /* hosts */
+ false, /* users */
+ true, /* accounts */
+ true, /* threads */
+ false, /* THDs */
+ & visitor);
+
+ m_row.m_stat.set(m_normalizer, & visitor.m_stat);
+ m_row_exists= true;
+}
+
+int table_esms_global_by_event_name
+::read_row_values(TABLE *table, unsigned char *, Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 0);
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* NAME */
+ m_row.m_event_name.set_field(f);
+ break;
+ default: /* 1, ... COUNT/SUM/MIN/AVG/MAX */
+ m_row.m_stat.set_field(f->field_index - 1, f);
+ break;
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_esms_global_by_event_name.h b/storage/perfschema/table_esms_global_by_event_name.h
new file mode 100644
index 00000000..d4e34b7c
--- /dev/null
+++ b/storage/perfschema/table_esms_global_by_event_name.h
@@ -0,0 +1,99 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_ESMS_GLOBAL_BY_EVENT_NAME_H
+#define TABLE_ESMS_GLOBAL_BY_EVENT_NAME_H
+
+/**
+ @file storage/perfschema/table_esms_global_by_event_name.h
+ Table EVENTS_STATEMENTS_SUMMARY_GLOBAL_BY_EVENT_NAME (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "table_helper.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/**
+ A row of table
+ PERFORMANCE_SCHEMA.EVENTS_STATEMENTS_SUMMARY_GLOBAL_BY_EVENT_NAME.
+*/
+struct row_esms_global_by_event_name
+{
+ /** Column EVENT_NAME. */
+ PFS_event_name_row m_event_name;
+ /** Columns COUNT_STAR, SUM/MIN/AVG/MAX TIMER_WAIT. */
+ PFS_statement_stat_row m_stat;
+};
+
+/** Table PERFORMANCE_SCHEMA.EVENTS_STATEMENTS_SUMMARY_GLOBAL_BY_EVENT_NAME. */
+class table_esms_global_by_event_name : public PFS_engine_table
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_init(bool scan);
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_esms_global_by_event_name();
+
+public:
+ ~table_esms_global_by_event_name()
+ {}
+
+protected:
+ void make_row(PFS_statement_class *klass);
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ /** Current row. */
+ row_esms_global_by_event_name m_row;
+ /** True is the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ PFS_simple_index m_pos;
+ /** Next position. */
+ PFS_simple_index m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_ets_by_account_by_event_name.cc b/storage/perfschema/table_ets_by_account_by_event_name.cc
new file mode 100644
index 00000000..f951be21
--- /dev/null
+++ b/storage/perfschema/table_ets_by_account_by_event_name.cc
@@ -0,0 +1,225 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_ets_by_account_by_event_name.cc
+ Table EVENTS_TRANSACTIONS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "pfs_instr_class.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "table_ets_by_account_by_event_name.h"
+#include "pfs_global.h"
+#include "pfs_visitor.h"
+#include "pfs_buffer_container.h"
+#include "field.h"
+
+THR_LOCK table_ets_by_account_by_event_name::m_table_lock;
+
+PFS_engine_table_share
+table_ets_by_account_by_event_name::m_share=
+{
+ { C_STRING_WITH_LEN("events_transactions_summary_by_account_by_event_name") },
+ &pfs_truncatable_acl,
+ table_ets_by_account_by_event_name::create,
+ NULL, /* write_row */
+ table_ets_by_account_by_event_name::delete_all_rows,
+ table_ets_by_account_by_event_name::get_row_count,
+ sizeof(pos_ets_by_account_by_event_name),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE events_transactions_summary_by_account_by_event_name("
+ "USER CHAR(32) collate utf8_bin default null,"
+ "HOST CHAR(60) collate utf8_bin default null,"
+ "EVENT_NAME VARCHAR(128) not null,"
+ "COUNT_STAR BIGINT unsigned not null,"
+ "SUM_TIMER_WAIT BIGINT unsigned not null,"
+ "MIN_TIMER_WAIT BIGINT unsigned not null,"
+ "AVG_TIMER_WAIT BIGINT unsigned not null,"
+ "MAX_TIMER_WAIT BIGINT unsigned not null,"
+ "COUNT_READ_WRITE BIGINT unsigned not null,"
+ "SUM_TIMER_READ_WRITE BIGINT unsigned not null,"
+ "MIN_TIMER_READ_WRITE BIGINT unsigned not null,"
+ "AVG_TIMER_READ_WRITE BIGINT unsigned not null,"
+ "MAX_TIMER_READ_WRITE BIGINT unsigned not null,"
+ "COUNT_READ_ONLY BIGINT unsigned not null,"
+ "SUM_TIMER_READ_ONLY BIGINT unsigned not null,"
+ "MIN_TIMER_READ_ONLY BIGINT unsigned not null,"
+ "AVG_TIMER_READ_ONLY BIGINT unsigned not null,"
+ "MAX_TIMER_READ_ONLY BIGINT unsigned not null)")},
+ false /* perpetual */
+};
+
+PFS_engine_table*
+table_ets_by_account_by_event_name::create(void)
+{
+ return new table_ets_by_account_by_event_name();
+}
+
+int
+table_ets_by_account_by_event_name::delete_all_rows(void)
+{
+ reset_events_transactions_by_thread();
+ reset_events_transactions_by_account();
+ return 0;
+}
+
+ha_rows
+table_ets_by_account_by_event_name::get_row_count(void)
+{
+ return global_account_container.get_row_count() * transaction_class_max;
+}
+
+table_ets_by_account_by_event_name::table_ets_by_account_by_event_name()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(), m_next_pos()
+{}
+
+void table_ets_by_account_by_event_name::reset_position(void)
+{
+ m_pos.reset();
+ m_next_pos.reset();
+}
+
+int table_ets_by_account_by_event_name::rnd_init(bool scan)
+{
+ m_normalizer= time_normalizer::get(transaction_timer);
+ return 0;
+}
+
+int table_ets_by_account_by_event_name::rnd_next(void)
+{
+ PFS_account *account;
+ PFS_transaction_class *transaction_class;
+ bool has_more_account= true;
+
+ for (m_pos.set_at(&m_next_pos);
+ has_more_account;
+ m_pos.next_account())
+ {
+ account= global_account_container.get(m_pos.m_index_1, & has_more_account);
+ if (account != NULL)
+ {
+ transaction_class= find_transaction_class(m_pos.m_index_2);
+ if (transaction_class)
+ {
+ make_row(account, transaction_class);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int
+table_ets_by_account_by_event_name::rnd_pos(const void *pos)
+{
+ PFS_account *account;
+ PFS_transaction_class *transaction_class;
+
+ set_position(pos);
+
+ account= global_account_container.get(m_pos.m_index_1);
+ if (account != NULL)
+ {
+ transaction_class= find_transaction_class(m_pos.m_index_2);
+ if (transaction_class)
+ {
+ make_row(account, transaction_class);
+ return 0;
+ }
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_ets_by_account_by_event_name
+::make_row(PFS_account *account, PFS_transaction_class *klass)
+{
+ pfs_optimistic_state lock;
+ m_row_exists= false;
+
+ account->m_lock.begin_optimistic_lock(&lock);
+
+ if (m_row.m_account.make_row(account))
+ return;
+
+ m_row.m_event_name.make_row(klass);
+
+ PFS_connection_transaction_visitor visitor(klass);
+ PFS_connection_iterator::visit_account(account,
+ true, /* threads */
+ false, /* THDs */
+ &visitor);
+
+ if (! account->m_lock.end_optimistic_lock(&lock))
+ return;
+
+ m_row_exists= true;
+ m_row.m_stat.set(m_normalizer, &visitor.m_stat);
+}
+
+int table_ets_by_account_by_event_name
+::read_row_values(TABLE *table, unsigned char *buf, Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* USER */
+ case 1: /* HOST */
+ m_row.m_account.set_field(f->field_index, f);
+ break;
+ case 2: /* EVENT_NAME */
+ m_row.m_event_name.set_field(f);
+ break;
+ default:
+ /**
+ COUNT_STAR, SUM/MIN/AVG/MAX_TIMER_WAIT,
+ COUNT_READ_WRITE, SUM/MIN/AVG/MAX_TIMER_READ_WRITE,
+ COUNT_READ_ONLY, SUM/MIN/AVG/MAX_TIMER_READ_ONLY
+ */
+ m_row.m_stat.set_field(f->field_index-3, f);
+ break;
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_ets_by_account_by_event_name.h b/storage/perfschema/table_ets_by_account_by_event_name.h
new file mode 100644
index 00000000..98fb45f7
--- /dev/null
+++ b/storage/perfschema/table_ets_by_account_by_event_name.h
@@ -0,0 +1,134 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_ETS_BY_ACCOUNT_BY_EVENT_NAME_H
+#define TABLE_ETS_BY_ACCOUNT_BY_EVENT_NAME_H
+
+/**
+ @file storage/perfschema/table_ets_by_account_by_event_name.h
+ Table EVENTS_TRANSACTIONS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "pfs_account.h"
+#include "table_helper.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/**
+ A row of table
+ PERFORMANCE_SCHEMA.EVENTS_TRANSACTIONS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME.
+*/
+struct row_ets_by_account_by_event_name
+{
+ /** Columns USER, HOST. */
+ PFS_account_row m_account;
+ /** Column EVENT_NAME. */
+ PFS_event_name_row m_event_name;
+ /**
+ Columns COUNT_STAR, SUM/MIN/AVG/MAX_TIMER_WAIT,
+ COUNT_READ_WRITE, SUM/MIN/AVG/MAX_TIMER_READ_WRITE,
+ COUNT_READ_ONLY, SUM/MIN/AVG/MAX_TIMER_READ_ONLY
+ */
+ PFS_transaction_stat_row m_stat;
+};
+
+/**
+ Position of a cursor on
+ PERFORMANCE_SCHEMA.EVENTS_TRANSACTIONS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME.
+ Index 1 on account (0 based)
+ Index 2 on transaction class (1 based)
+*/
+struct pos_ets_by_account_by_event_name
+: public PFS_double_index
+{
+ pos_ets_by_account_by_event_name()
+ : PFS_double_index(0, 1)
+ {}
+
+ inline void reset(void)
+ {
+ m_index_1= 0;
+ m_index_2= 1;
+ }
+
+ inline void next_account(void)
+ {
+ m_index_1++;
+ m_index_2= 1;
+ }
+};
+
+/** Table PERFORMANCE_SCHEMA.EVENTS_TRANSACTIONS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME. */
+class table_ets_by_account_by_event_name : public PFS_engine_table
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_init(bool scan);
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_ets_by_account_by_event_name();
+
+public:
+ ~table_ets_by_account_by_event_name()
+ {}
+
+protected:
+ void make_row(PFS_account *account, PFS_transaction_class *klass);
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+ /** Fields definition. */
+ static TABLE_FIELD_DEF m_field_def;
+
+ /** Current row. */
+ row_ets_by_account_by_event_name m_row;
+ /** True is the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ pos_ets_by_account_by_event_name m_pos;
+ /** Next position. */
+ pos_ets_by_account_by_event_name m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_ets_by_host_by_event_name.cc b/storage/perfschema/table_ets_by_host_by_event_name.cc
new file mode 100644
index 00000000..f0293624
--- /dev/null
+++ b/storage/perfschema/table_ets_by_host_by_event_name.cc
@@ -0,0 +1,226 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_ets_by_host_by_event_name.cc
+ Table EVENTS_TRANSACTIONS_SUMMARY_BY_HOST_BY_EVENT_NAME (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "pfs_instr_class.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "table_ets_by_host_by_event_name.h"
+#include "pfs_global.h"
+#include "pfs_account.h"
+#include "pfs_visitor.h"
+#include "pfs_buffer_container.h"
+#include "field.h"
+
+THR_LOCK table_ets_by_host_by_event_name::m_table_lock;
+
+PFS_engine_table_share
+table_ets_by_host_by_event_name::m_share=
+{
+ { C_STRING_WITH_LEN("events_transactions_summary_by_host_by_event_name") },
+ &pfs_truncatable_acl,
+ table_ets_by_host_by_event_name::create,
+ NULL, /* write_row */
+ table_ets_by_host_by_event_name::delete_all_rows,
+ table_ets_by_host_by_event_name::get_row_count,
+ sizeof(pos_ets_by_host_by_event_name),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE events_transactions_summary_by_host_by_event_name("
+ "HOST CHAR(60) collate utf8_bin default null,"
+ "EVENT_NAME VARCHAR(128) not null,"
+ "COUNT_STAR BIGINT unsigned not null,"
+ "SUM_TIMER_WAIT BIGINT unsigned not null,"
+ "MIN_TIMER_WAIT BIGINT unsigned not null,"
+ "AVG_TIMER_WAIT BIGINT unsigned not null,"
+ "MAX_TIMER_WAIT BIGINT unsigned not null,"
+ "COUNT_READ_WRITE BIGINT unsigned not null,"
+ "SUM_TIMER_READ_WRITE BIGINT unsigned not null,"
+ "MIN_TIMER_READ_WRITE BIGINT unsigned not null,"
+ "AVG_TIMER_READ_WRITE BIGINT unsigned not null,"
+ "MAX_TIMER_READ_WRITE BIGINT unsigned not null,"
+ "COUNT_READ_ONLY BIGINT unsigned not null,"
+ "SUM_TIMER_READ_ONLY BIGINT unsigned not null,"
+ "MIN_TIMER_READ_ONLY BIGINT unsigned not null,"
+ "AVG_TIMER_READ_ONLY BIGINT unsigned not null,"
+ "MAX_TIMER_READ_ONLY BIGINT unsigned not null)")},
+ false /* perpetual */
+};
+
+PFS_engine_table*
+table_ets_by_host_by_event_name::create(void)
+{
+ return new table_ets_by_host_by_event_name();
+}
+
+int
+table_ets_by_host_by_event_name::delete_all_rows(void)
+{
+ reset_events_transactions_by_thread();
+ reset_events_transactions_by_account();
+ reset_events_transactions_by_host();
+ return 0;
+}
+
+ha_rows
+table_ets_by_host_by_event_name::get_row_count(void)
+{
+ return global_host_container.get_row_count() * transaction_class_max;
+}
+
+table_ets_by_host_by_event_name::table_ets_by_host_by_event_name()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(), m_next_pos()
+{}
+
+void table_ets_by_host_by_event_name::reset_position(void)
+{
+ m_pos.reset();
+ m_next_pos.reset();
+}
+
+int table_ets_by_host_by_event_name::rnd_init(bool scan)
+{
+ m_normalizer= time_normalizer::get(transaction_timer);
+ return 0;
+}
+
+int table_ets_by_host_by_event_name::rnd_next(void)
+{
+ PFS_host *host;
+ PFS_transaction_class *transaction_class;
+ bool has_more_host= true;
+
+ for (m_pos.set_at(&m_next_pos);
+ has_more_host;
+ m_pos.next_host())
+ {
+ host= global_host_container.get(m_pos.m_index_1, & has_more_host);
+ if (host != NULL)
+ {
+ transaction_class= find_transaction_class(m_pos.m_index_2);
+ if (transaction_class)
+ {
+ make_row(host, transaction_class);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int
+table_ets_by_host_by_event_name::rnd_pos(const void *pos)
+{
+ PFS_host *host;
+ PFS_transaction_class *transaction_class;
+
+ set_position(pos);
+
+ host= global_host_container.get(m_pos.m_index_1);
+ if (host != NULL)
+ {
+ transaction_class= find_transaction_class(m_pos.m_index_2);
+ if (transaction_class)
+ {
+ make_row(host, transaction_class);
+ return 0;
+ }
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_ets_by_host_by_event_name
+::make_row(PFS_host *host, PFS_transaction_class *klass)
+{
+ pfs_optimistic_state lock;
+ m_row_exists= false;
+
+ host->m_lock.begin_optimistic_lock(&lock);
+
+ if (m_row.m_host.make_row(host))
+ return;
+
+ m_row.m_event_name.make_row(klass);
+
+ PFS_connection_transaction_visitor visitor(klass);
+ PFS_connection_iterator::visit_host(host,
+ true, /* accounts */
+ true, /* threads */
+ false, /* THDs */
+ & visitor);
+
+ if (! host->m_lock.end_optimistic_lock(&lock))
+ return;
+
+ m_row_exists= true;
+ m_row.m_stat.set(m_normalizer, & visitor.m_stat);
+}
+
+int table_ets_by_host_by_event_name
+::read_row_values(TABLE *table, unsigned char *buf, Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* HOST */
+ m_row.m_host.set_field(f);
+ break;
+ case 1: /* EVENT_NAME */
+ m_row.m_event_name.set_field(f);
+ break;
+ default:
+ /**
+ COUNT_STAR, SUM/MIN/AVG/MAX_TIMER_WAIT,
+ COUNT_READ_WRITE, SUM/MIN/AVG/MAX_TIMER_READ_WRITE,
+ COUNT_READ_ONLY, SUM/MIN/AVG/MAX_TIMER_READ_ONLY
+ */
+ m_row.m_stat.set_field(f->field_index-2, f);
+ break;
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_ets_by_host_by_event_name.h b/storage/perfschema/table_ets_by_host_by_event_name.h
new file mode 100644
index 00000000..341c3878
--- /dev/null
+++ b/storage/perfschema/table_ets_by_host_by_event_name.h
@@ -0,0 +1,134 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_ETS_BY_HOST_BY_EVENT_NAME_H
+#define TABLE_ETS_BY_HOST_BY_EVENT_NAME_H
+
+/**
+ @file storage/perfschema/table_ets_by_host_by_event_name.h
+ Table EVENTS_TRANSACTIONS_SUMMARY_BY_HOST_BY_EVENT_NAME (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "pfs_host.h"
+#include "table_helper.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/**
+ A row of table
+ PERFORMANCE_SCHEMA.EVENTS_TRANSACTIONS_SUMMARY_BY_HOST_BY_EVENT_NAME.
+*/
+struct row_ets_by_host_by_event_name
+{
+ /** Column HOST */
+ PFS_host_row m_host;
+ /** Column EVENT_NAME */
+ PFS_event_name_row m_event_name;
+ /**
+ Columns COUNT_STAR, SUM/MIN/AVG/MAX_TIMER_WAIT,
+ COUNT_READ_WRITE, SUM/MIN/AVG/MAX_TIMER_READ_WRITE,
+ COUNT_READ_ONLY, SUM/MIN/AVG/MAX_TIMER_READ_ONLY
+ */
+ PFS_transaction_stat_row m_stat;
+};
+
+/**
+ Position of a cursor on
+ PERFORMANCE_SCHEMA.EVENTS_TRANSACTIONS_SUMMARY_BY_HOST_BY_EVENT_NAME.
+ Index 1 on host (0 based)
+ Index 2 on transaction class (1 based)
+*/
+struct pos_ets_by_host_by_event_name
+: public PFS_double_index
+{
+ pos_ets_by_host_by_event_name()
+ : PFS_double_index(0, 1)
+ {}
+
+ inline void reset(void)
+ {
+ m_index_1= 0;
+ m_index_2= 1;
+ }
+
+ inline void next_host(void)
+ {
+ m_index_1++;
+ m_index_2= 1;
+ }
+};
+
+/** Table PERFORMANCE_SCHEMA.EVENTS_TRANSACTIONS_SUMMARY_BY_HOST_BY_EVENT_NAME. */
+class table_ets_by_host_by_event_name : public PFS_engine_table
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_init(bool scan);
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_ets_by_host_by_event_name();
+
+public:
+ ~table_ets_by_host_by_event_name()
+ {}
+
+protected:
+ void make_row(PFS_host *host, PFS_transaction_class *klass);
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+ /** Fields definition. */
+ static TABLE_FIELD_DEF m_field_def;
+
+ /** Current row. */
+ row_ets_by_host_by_event_name m_row;
+ /** True is the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ pos_ets_by_host_by_event_name m_pos;
+ /** Next position. */
+ pos_ets_by_host_by_event_name m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_ets_by_thread_by_event_name.cc b/storage/perfschema/table_ets_by_thread_by_event_name.cc
new file mode 100644
index 00000000..81ebf23b
--- /dev/null
+++ b/storage/perfschema/table_ets_by_thread_by_event_name.cc
@@ -0,0 +1,218 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
+
+/**
+ @file storage/perfschema/table_ets_by_thread_by_event_name.cc
+ Table EVENTS_TRANSACTIONS_SUMMARY_BY_HOST_BY_EVENT_NAME (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "pfs_instr_class.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "table_ets_by_thread_by_event_name.h"
+#include "pfs_global.h"
+#include "pfs_visitor.h"
+#include "pfs_buffer_container.h"
+#include "field.h"
+
+THR_LOCK table_ets_by_thread_by_event_name::m_table_lock;
+
+PFS_engine_table_share
+table_ets_by_thread_by_event_name::m_share=
+{
+ { C_STRING_WITH_LEN("events_transactions_summary_by_thread_by_event_name") },
+ &pfs_truncatable_acl,
+ table_ets_by_thread_by_event_name::create,
+ NULL, /* write_row */
+ table_ets_by_thread_by_event_name::delete_all_rows,
+ table_ets_by_thread_by_event_name::get_row_count,
+ sizeof(pos_ets_by_thread_by_event_name),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE events_transactions_summary_by_thread_by_event_name("
+ "THREAD_ID BIGINT unsigned not null,"
+ "EVENT_NAME VARCHAR(128) not null,"
+ "COUNT_STAR BIGINT unsigned not null,"
+ "SUM_TIMER_WAIT BIGINT unsigned not null,"
+ "MIN_TIMER_WAIT BIGINT unsigned not null,"
+ "AVG_TIMER_WAIT BIGINT unsigned not null,"
+ "MAX_TIMER_WAIT BIGINT unsigned not null,"
+ "COUNT_READ_WRITE BIGINT unsigned not null,"
+ "SUM_TIMER_READ_WRITE BIGINT unsigned not null,"
+ "MIN_TIMER_READ_WRITE BIGINT unsigned not null,"
+ "AVG_TIMER_READ_WRITE BIGINT unsigned not null,"
+ "MAX_TIMER_READ_WRITE BIGINT unsigned not null,"
+ "COUNT_READ_ONLY BIGINT unsigned not null,"
+ "SUM_TIMER_READ_ONLY BIGINT unsigned not null,"
+ "MIN_TIMER_READ_ONLY BIGINT unsigned not null,"
+ "AVG_TIMER_READ_ONLY BIGINT unsigned not null,"
+ "MAX_TIMER_READ_ONLY BIGINT unsigned not null)")},
+ false /* perpetual */
+};
+
+PFS_engine_table*
+table_ets_by_thread_by_event_name::create(void)
+{
+ return new table_ets_by_thread_by_event_name();
+}
+
+int
+table_ets_by_thread_by_event_name::delete_all_rows(void)
+{
+ reset_events_transactions_by_thread();
+ return 0;
+}
+
+ha_rows
+table_ets_by_thread_by_event_name::get_row_count(void)
+{
+ return global_thread_container.get_row_count() * transaction_class_max;
+}
+
+table_ets_by_thread_by_event_name::table_ets_by_thread_by_event_name()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(), m_next_pos()
+{}
+
+void table_ets_by_thread_by_event_name::reset_position(void)
+{
+ m_pos.reset();
+ m_next_pos.reset();
+}
+
+int table_ets_by_thread_by_event_name::rnd_init(bool scan)
+{
+ m_normalizer= time_normalizer::get(transaction_timer);
+ return 0;
+}
+
+int table_ets_by_thread_by_event_name::rnd_next(void)
+{
+ PFS_thread *thread;
+ PFS_transaction_class *transaction_class;
+ bool has_more_thread= true;
+
+ for (m_pos.set_at(&m_next_pos);
+ has_more_thread;
+ m_pos.next_thread())
+ {
+ thread= global_thread_container.get(m_pos.m_index_1, & has_more_thread);
+ if (thread != NULL)
+ {
+ transaction_class= find_transaction_class(m_pos.m_index_2);
+ if (transaction_class)
+ {
+ make_row(thread, transaction_class);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int
+table_ets_by_thread_by_event_name::rnd_pos(const void *pos)
+{
+ PFS_thread *thread;
+ PFS_transaction_class *transaction_class;
+
+ set_position(pos);
+
+ thread= global_thread_container.get(m_pos.m_index_1);
+ if (thread != NULL)
+ {
+ transaction_class= find_transaction_class(m_pos.m_index_2);
+ if (transaction_class)
+ {
+ make_row(thread, transaction_class);
+ return 0;
+ }
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_ets_by_thread_by_event_name
+::make_row(PFS_thread *thread, PFS_transaction_class *klass)
+{
+ pfs_optimistic_state lock;
+ m_row_exists= false;
+
+ /* Protect this reader against a thread termination */
+ thread->m_lock.begin_optimistic_lock(&lock);
+
+ m_row.m_thread_internal_id= thread->m_thread_internal_id;
+
+ m_row.m_event_name.make_row(klass);
+
+ PFS_connection_transaction_visitor visitor(klass);
+ PFS_connection_iterator::visit_thread(thread, &visitor);
+
+ if (! thread->m_lock.end_optimistic_lock(&lock))
+ return;
+
+ m_row_exists= true;
+ m_row.m_stat.set(m_normalizer, &visitor.m_stat);
+}
+
+int table_ets_by_thread_by_event_name
+::read_row_values(TABLE *table, unsigned char *, Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 0);
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* THREAD_ID */
+ set_field_ulonglong(f, m_row.m_thread_internal_id);
+ break;
+ case 1: /* EVENT_NAME */
+ m_row.m_event_name.set_field(f);
+ break;
+ default:
+ /**
+ COUNT_STAR, SUM/MIN/AVG/MAX_TIMER_WAIT
+ COUNT_READ_WRITE, SUM/MIN/AVG/MAX_TIMER_READ_WRITE
+ COUNT_READ_ONLY, SUM/MIN/AVG/MAX_TIMER_READ_ONLY
+ */
+ m_row.m_stat.set_field(f->field_index-2, f);
+ break;
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_ets_by_thread_by_event_name.h b/storage/perfschema/table_ets_by_thread_by_event_name.h
new file mode 100644
index 00000000..ad63efa3
--- /dev/null
+++ b/storage/perfschema/table_ets_by_thread_by_event_name.h
@@ -0,0 +1,138 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
+
+#ifndef TABLE_ETS_BY_THREAD_BY_EVENT_NAME_H
+#define TABLE_ETS_BY_THREAD_BY_EVENT_NAME_H
+
+/**
+ @file storage/perfschema/table_ets_by_thread_by_event_name.h
+ Table EVENTS_TRANSACTIONS_SUMMARY_BY_THREAD_BY_EVENT_NAME (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "table_helper.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/**
+ A row of table
+ PERFORMANCE_SCHEMA.EVENTS_TRANSACTIONS_SUMMARY_BY_THREAD_BY_EVENT_NAME.
+*/
+struct row_ets_by_thread_by_event_name
+{
+ /** Column THREAD_ID. */
+ ulonglong m_thread_internal_id;
+ /** Column EVENT_NAME. */
+ PFS_event_name_row m_event_name;
+ /**
+ Columns COUNT_STAR, SUM/MIN/AVG/MAX_TIMER_WAIT,
+ COUNT_READ_WRITE, SUM/MIN/AVG/MAX_TIMER_READ_WRITE,
+ COUNT_READ_ONLY, SUM/MIN/AVG/MAX_TIMER_READ_ONLY
+ */
+ PFS_transaction_stat_row m_stat;
+};
+
+/**
+ Position of a cursor on
+ PERFORMANCE_SCHEMA.EVENTS_TRANSACTIONS_SUMMARY_BY_THREAD_BY_EVENT_NAME.
+ Index 1 on thread (0 based).
+ Index 2 on transaction class (1 based).
+*/
+struct pos_ets_by_thread_by_event_name
+: public PFS_double_index, public PFS_instrument_view_constants
+{
+ pos_ets_by_thread_by_event_name()
+ : PFS_double_index(0, 1)
+ {}
+
+ inline void reset(void)
+ {
+ m_index_1= 0;
+ m_index_2= 1;
+ }
+
+ inline void next_thread(void)
+ {
+ m_index_1++;
+ m_index_2= 1;
+ }
+
+ inline void next_transaction(void)
+ {
+ m_index_2++;
+ }
+};
+
+/** Table PERFORMANCE_SCHEMA.EVENTS_TRANSACTIONS_SUMMARY_BY_THREAD_BY_EVENT_NAME. */
+class table_ets_by_thread_by_event_name : public PFS_engine_table
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_init(bool scan);
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_ets_by_thread_by_event_name();
+
+public:
+ ~table_ets_by_thread_by_event_name()
+ {}
+
+protected:
+ void make_row(PFS_thread *thread, PFS_transaction_class *klass);
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+ /** Fields definition. */
+ static TABLE_FIELD_DEF m_field_def;
+
+ /** Current row. */
+ row_ets_by_thread_by_event_name m_row;
+ /** True is the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ pos_ets_by_thread_by_event_name m_pos;
+ /** Next position. */
+ pos_ets_by_thread_by_event_name m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_ets_by_user_by_event_name.cc b/storage/perfschema/table_ets_by_user_by_event_name.cc
new file mode 100644
index 00000000..66aae431
--- /dev/null
+++ b/storage/perfschema/table_ets_by_user_by_event_name.cc
@@ -0,0 +1,225 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_ets_by_user_by_event_name.cc
+ Table EVENTS_TRANSACTIONS_SUMMARY_BY_USER_BY_EVENT_NAME (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "pfs_instr_class.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "table_ets_by_user_by_event_name.h"
+#include "pfs_global.h"
+#include "pfs_visitor.h"
+#include "pfs_buffer_container.h"
+#include "field.h"
+
+THR_LOCK table_ets_by_user_by_event_name::m_table_lock;
+
+PFS_engine_table_share
+table_ets_by_user_by_event_name::m_share=
+{
+ { C_STRING_WITH_LEN("events_transactions_summary_by_user_by_event_name") },
+ &pfs_truncatable_acl,
+ table_ets_by_user_by_event_name::create,
+ NULL, /* write_row */
+ table_ets_by_user_by_event_name::delete_all_rows,
+ table_ets_by_user_by_event_name::get_row_count,
+ sizeof(pos_ets_by_user_by_event_name),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE events_transactions_summary_by_user_by_event_name("
+ "USER CHAR(32) collate utf8_bin default null,"
+ "EVENT_NAME VARCHAR(128) not null,"
+ "COUNT_STAR BIGINT unsigned not null,"
+ "SUM_TIMER_WAIT BIGINT unsigned not null,"
+ "MIN_TIMER_WAIT BIGINT unsigned not null,"
+ "AVG_TIMER_WAIT BIGINT unsigned not null,"
+ "MAX_TIMER_WAIT BIGINT unsigned not null,"
+ "COUNT_READ_WRITE BIGINT unsigned not null,"
+ "SUM_TIMER_READ_WRITE BIGINT unsigned not null,"
+ "MIN_TIMER_READ_WRITE BIGINT unsigned not null,"
+ "AVG_TIMER_READ_WRITE BIGINT unsigned not null,"
+ "MAX_TIMER_READ_WRITE BIGINT unsigned not null,"
+ "COUNT_READ_ONLY BIGINT unsigned not null,"
+ "SUM_TIMER_READ_ONLY BIGINT unsigned not null,"
+ "MIN_TIMER_READ_ONLY BIGINT unsigned not null,"
+ "AVG_TIMER_READ_ONLY BIGINT unsigned not null,"
+ "MAX_TIMER_READ_ONLY BIGINT unsigned not null)")},
+ false /* perpetual */
+};
+
+PFS_engine_table*
+table_ets_by_user_by_event_name::create(void)
+{
+ return new table_ets_by_user_by_event_name();
+}
+
+int
+table_ets_by_user_by_event_name::delete_all_rows(void)
+{
+ reset_events_transactions_by_thread();
+ reset_events_transactions_by_account();
+ reset_events_transactions_by_user();
+ return 0;
+}
+
+ha_rows
+table_ets_by_user_by_event_name::get_row_count(void)
+{
+ return global_user_container.get_row_count() * transaction_class_max;
+}
+
+table_ets_by_user_by_event_name::table_ets_by_user_by_event_name()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(), m_next_pos()
+{}
+
+void table_ets_by_user_by_event_name::reset_position(void)
+{
+ m_pos.reset();
+ m_next_pos.reset();
+}
+
+int table_ets_by_user_by_event_name::rnd_init(bool scan)
+{
+ m_normalizer= time_normalizer::get(transaction_timer);
+ return 0;
+}
+
+int table_ets_by_user_by_event_name::rnd_next(void)
+{
+ PFS_user *user;
+ PFS_transaction_class *transaction_class;
+ bool has_more_user= true;
+
+ for (m_pos.set_at(&m_next_pos);
+ has_more_user;
+ m_pos.next_user())
+ {
+ user= global_user_container.get(m_pos.m_index_1, & has_more_user);
+ if (user != NULL)
+ {
+ transaction_class= find_transaction_class(m_pos.m_index_2);
+ if (transaction_class)
+ {
+ make_row(user, transaction_class);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int
+table_ets_by_user_by_event_name::rnd_pos(const void *pos)
+{
+ PFS_user *user;
+ PFS_transaction_class *transaction_class;
+
+ set_position(pos);
+
+ user= global_user_container.get(m_pos.m_index_1);
+ if (user != NULL)
+ {
+ transaction_class= find_transaction_class(m_pos.m_index_2);
+ if (transaction_class)
+ {
+ make_row(user, transaction_class);
+ return 0;
+ }
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_ets_by_user_by_event_name
+::make_row(PFS_user *user, PFS_transaction_class *klass)
+{
+ pfs_optimistic_state lock;
+ m_row_exists= false;
+
+ user->m_lock.begin_optimistic_lock(&lock);
+
+ if (m_row.m_user.make_row(user))
+ return;
+
+ m_row.m_event_name.make_row(klass);
+
+ PFS_connection_transaction_visitor visitor(klass);
+ PFS_connection_iterator::visit_user(user,
+ true, /* accounts */
+ true, /* threads */
+ false, /* THDs */
+ & visitor);
+
+ if (! user->m_lock.end_optimistic_lock(&lock))
+ return;
+
+ m_row_exists= true;
+ m_row.m_stat.set(m_normalizer, & visitor.m_stat);
+}
+
+int table_ets_by_user_by_event_name
+::read_row_values(TABLE *table, unsigned char *buf, Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* USER */
+ m_row.m_user.set_field(f);
+ break;
+ case 1: /* EVENT_NAME */
+ m_row.m_event_name.set_field(f);
+ break;
+ default:
+ /**
+ COUNT_STAR, SUM/MIN/AVG/MAX_TIMER_WAIT,
+ COUNT_READ_WRITE, SUM/MIN/AVG/MAX_TIMER_READ_WRITE,
+ COUNT_READ_ONLY, SUM/MIN/AVG/MAX_TIMER_READ_ONLY
+ */
+ m_row.m_stat.set_field(f->field_index-2, f);
+ break;
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_ets_by_user_by_event_name.h b/storage/perfschema/table_ets_by_user_by_event_name.h
new file mode 100644
index 00000000..c3a1d0b5
--- /dev/null
+++ b/storage/perfschema/table_ets_by_user_by_event_name.h
@@ -0,0 +1,134 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_ETS_BY_USER_BY_EVENT_NAME_H
+#define TABLE_ETS_BY_USER_BY_EVENT_NAME_H
+
+/**
+ @file storage/perfschema/table_ets_by_user_by_event_name.h
+ Table EVENTS_TRANSACTIONS_SUMMARY_BY_USER_BY_EVENT_NAME (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "pfs_user.h"
+#include "table_helper.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/**
+ A row of table
+ PERFORMANCE_SCHEMA.EVENTS_TRANSACTIONS_SUMMARY_BY_USER_BY_EVENT_NAME.
+*/
+struct row_ets_by_user_by_event_name
+{
+ /** Column USER */
+ PFS_user_row m_user;
+ /** Column EVENT_NAME */
+ PFS_event_name_row m_event_name;
+ /**
+ Columns COUNT_STAR, SUM/MIN/AVG/MAX_TIMER_WAIT,
+ COUNT_READ_WRITE, SUM/MIN/AVG/MAX_TIMER_READ_WRITE,
+ COUNT_READ_ONLY, SUM/MIN/AVG/MAX_TIMER_READ_ONLY
+ */
+ PFS_transaction_stat_row m_stat;
+};
+
+/**
+ Position of a cursor on
+ PERFORMANCE_SCHEMA.EVENTS_TRANSACTIONS_SUMMARY_BY_USER_BY_EVENT_NAME.
+ Index 1 on user (0 based)
+ Index 2 on transaction class (1 based)
+*/
+struct pos_ets_by_user_by_event_name
+: public PFS_double_index
+{
+ pos_ets_by_user_by_event_name()
+ : PFS_double_index(0, 1)
+ {}
+
+ inline void reset(void)
+ {
+ m_index_1= 0;
+ m_index_2= 1;
+ }
+
+ inline void next_user(void)
+ {
+ m_index_1++;
+ m_index_2= 1;
+ }
+};
+
+/** Table PERFORMANCE_SCHEMA.EVENTS_TRANSACTIONS_SUMMARY_BY_USER_BY_EVENT_NAME. */
+class table_ets_by_user_by_event_name : public PFS_engine_table
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_init(bool scan);
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_ets_by_user_by_event_name();
+
+public:
+ ~table_ets_by_user_by_event_name()
+ {}
+
+protected:
+ void make_row(PFS_user *user, PFS_transaction_class *klass);
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+ /** Fields definition. */
+ static TABLE_FIELD_DEF m_field_def;
+
+ /** Current row. */
+ row_ets_by_user_by_event_name m_row;
+ /** True is the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ pos_ets_by_user_by_event_name m_pos;
+ /** Next position. */
+ pos_ets_by_user_by_event_name m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_ets_global_by_event_name.cc b/storage/perfschema/table_ets_global_by_event_name.cc
new file mode 100644
index 00000000..6c13871a
--- /dev/null
+++ b/storage/perfschema/table_ets_global_by_event_name.cc
@@ -0,0 +1,200 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
+
+/**
+ @file storage/perfschema/table_ets_global_by_event_name.cc
+ Table EVENTS_TRANSACTIONS_SUMMARY_GLOBAL_BY_EVENT_NAME (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "pfs_instr_class.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "table_ets_global_by_event_name.h"
+#include "pfs_global.h"
+#include "pfs_instr.h"
+#include "pfs_timer.h"
+#include "pfs_visitor.h"
+#include "field.h"
+
+THR_LOCK table_ets_global_by_event_name::m_table_lock;
+
+PFS_engine_table_share
+table_ets_global_by_event_name::m_share=
+{
+ { C_STRING_WITH_LEN("events_transactions_summary_global_by_event_name") },
+ &pfs_truncatable_acl,
+ table_ets_global_by_event_name::create,
+ NULL, /* write_row */
+ table_ets_global_by_event_name::delete_all_rows,
+ table_ets_global_by_event_name::get_row_count,
+ sizeof(PFS_simple_index),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE events_transactions_summary_global_by_event_name("
+ "EVENT_NAME VARCHAR(128) not null,"
+ "COUNT_STAR BIGINT unsigned not null,"
+ "SUM_TIMER_WAIT BIGINT unsigned not null,"
+ "MIN_TIMER_WAIT BIGINT unsigned not null,"
+ "AVG_TIMER_WAIT BIGINT unsigned not null,"
+ "MAX_TIMER_WAIT BIGINT unsigned not null,"
+ "COUNT_READ_WRITE BIGINT unsigned not null,"
+ "SUM_TIMER_READ_WRITE BIGINT unsigned not null,"
+ "MIN_TIMER_READ_WRITE BIGINT unsigned not null,"
+ "AVG_TIMER_READ_WRITE BIGINT unsigned not null,"
+ "MAX_TIMER_READ_WRITE BIGINT unsigned not null,"
+ "COUNT_READ_ONLY BIGINT unsigned not null,"
+ "SUM_TIMER_READ_ONLY BIGINT unsigned not null,"
+ "MIN_TIMER_READ_ONLY BIGINT unsigned not null,"
+ "AVG_TIMER_READ_ONLY BIGINT unsigned not null,"
+ "MAX_TIMER_READ_ONLY BIGINT unsigned not null)")},
+ false /* perpetual */
+};
+
+PFS_engine_table*
+table_ets_global_by_event_name::create(void)
+{
+ return new table_ets_global_by_event_name();
+}
+
+int
+table_ets_global_by_event_name::delete_all_rows(void)
+{
+ reset_events_transactions_by_thread();
+ reset_events_transactions_by_account();
+ reset_events_transactions_by_user();
+ reset_events_transactions_by_host();
+ reset_events_transactions_global();
+ return 0;
+}
+
+ha_rows
+table_ets_global_by_event_name::get_row_count(void)
+{
+ return transaction_class_max;
+}
+
+table_ets_global_by_event_name::table_ets_global_by_event_name()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(1), m_next_pos(1)
+{}
+
+void table_ets_global_by_event_name::reset_position(void)
+{
+ m_pos= 1;
+ m_next_pos= 1;
+}
+
+int table_ets_global_by_event_name::rnd_init(bool scan)
+{
+ m_normalizer= time_normalizer::get(transaction_timer);
+ return 0;
+}
+
+int table_ets_global_by_event_name::rnd_next(void)
+{
+ PFS_transaction_class *transaction_class;
+
+ m_pos.set_at(&m_next_pos);
+
+ transaction_class= find_transaction_class(m_pos.m_index);
+ if (transaction_class)
+ {
+ make_row(transaction_class);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int
+table_ets_global_by_event_name::rnd_pos(const void *pos)
+{
+ PFS_transaction_class *transaction_class;
+
+ set_position(pos);
+
+ transaction_class=find_transaction_class(m_pos.m_index);
+ if (transaction_class)
+ {
+ make_row(transaction_class);
+ return 0;
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+
+void table_ets_global_by_event_name
+::make_row(PFS_transaction_class *klass)
+{
+ m_row.m_event_name.make_row(klass);
+
+ PFS_connection_transaction_visitor visitor(klass);
+ PFS_connection_iterator::visit_global(true, /* hosts */
+ false, /* users */
+ true, /* accounts */
+ true, /* threads */
+ false, /* THDs */
+ & visitor);
+
+ m_row.m_stat.set(m_normalizer, & visitor.m_stat);
+ m_row_exists= true;
+}
+
+int table_ets_global_by_event_name
+::read_row_values(TABLE *table, unsigned char *, Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 0);
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* NAME */
+ m_row.m_event_name.set_field(f);
+ break;
+ default:
+ /**
+ Columns COUNT_STAR, SUM/MIN/AVG/MAX_TIMER_WAIT,
+ COUNT_READ_WRITE, SUM/MIN/AVG/MAX_TIMER_READ_WRITE,
+ COUNT_READ_ONLY, SUM/MIN/AVG/MAX_TIMER_READ_ONLY
+ */
+ m_row.m_stat.set_field(f->field_index - 1, f);
+ break;
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_ets_global_by_event_name.h b/storage/perfschema/table_ets_global_by_event_name.h
new file mode 100644
index 00000000..47c8828c
--- /dev/null
+++ b/storage/perfschema/table_ets_global_by_event_name.h
@@ -0,0 +1,105 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
+
+#ifndef TABLE_ETS_GLOBAL_BY_EVENT_NAME_H
+#define TABLE_ETS_GLOBAL_BY_EVENT_NAME_H
+
+/**
+ @file storage/perfschema/table_ets_global_by_event_name.h
+ Table EVENTS_TRANSACTIONS_SUMMARY_GLOBAL_BY_EVENT_NAME (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "table_helper.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/**
+ A row of table
+ PERFORMANCE_SCHEMA.EVENTS_TRANSACTIONS_SUMMARY_GLOBAL_BY_EVENT_NAME.
+*/
+struct row_ets_global_by_event_name
+{
+ /** Column EVENT_NAME. */
+ PFS_event_name_row m_event_name;
+ /**
+ Columns COUNT_STAR, SUM/MIN/AVG/MAX_TIMER_WAIT,
+ COUNT_READ_WRITE, SUM/MIN/AVG/MAX_TIMER_READ_WRITE,
+ COUNT_READ_ONLY, SUM/MIN/AVG/MAX_TIMER_READ_ONLY
+ */
+ PFS_transaction_stat_row m_stat;
+};
+
+/** Table PERFORMANCE_SCHEMA.EVENTS_TRANSACTIONS_SUMMARY_GLOBAL_BY_EVENT_NAME. */
+class table_ets_global_by_event_name : public PFS_engine_table
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_init(bool scan);
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_ets_global_by_event_name();
+
+public:
+ ~table_ets_global_by_event_name()
+ {}
+
+protected:
+ void make_row(PFS_transaction_class *klass);
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+ /** Fields definition. */
+ static TABLE_FIELD_DEF m_field_def;
+
+ /** Current row. */
+ row_ets_global_by_event_name m_row;
+ /** True is the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ PFS_simple_index m_pos;
+ /** Next position. */
+ PFS_simple_index m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_events_stages.cc b/storage/perfschema/table_events_stages.cc
new file mode 100644
index 00000000..cd6c79df
--- /dev/null
+++ b/storage/perfschema/table_events_stages.cc
@@ -0,0 +1,541 @@
+/* Copyright (c) 2010, 2018, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_events_stages.cc
+ Table EVENTS_STAGES_xxx (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "table_events_stages.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "pfs_events_stages.h"
+#include "pfs_timer.h"
+#include "pfs_buffer_container.h"
+#include "field.h"
+
+THR_LOCK table_events_stages_current::m_table_lock;
+
+PFS_engine_table_share
+table_events_stages_current::m_share=
+{
+ { C_STRING_WITH_LEN("events_stages_current") },
+ &pfs_truncatable_acl,
+ table_events_stages_current::create,
+ NULL, /* write_row */
+ table_events_stages_current::delete_all_rows,
+ table_events_stages_current::get_row_count,
+ sizeof(PFS_simple_index), /* ref length */
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE events_stages_current("
+ "THREAD_ID BIGINT unsigned not null,"
+ "EVENT_ID BIGINT unsigned not null,"
+ "END_EVENT_ID BIGINT unsigned,"
+ "EVENT_NAME VARCHAR(128) not null,"
+ "SOURCE VARCHAR(64),"
+ "TIMER_START BIGINT unsigned,"
+ "TIMER_END BIGINT unsigned,"
+ "TIMER_WAIT BIGINT unsigned,"
+ "WORK_COMPLETED BIGINT unsigned,"
+ "WORK_ESTIMATED BIGINT unsigned,"
+ "NESTING_EVENT_ID BIGINT unsigned,"
+ "NESTING_EVENT_TYPE ENUM('TRANSACTION', 'STATEMENT', 'STAGE', 'WAIT'))") },
+ false /* perpetual */
+};
+
+THR_LOCK table_events_stages_history::m_table_lock;
+
+PFS_engine_table_share
+table_events_stages_history::m_share=
+{
+ { C_STRING_WITH_LEN("events_stages_history") },
+ &pfs_truncatable_acl,
+ table_events_stages_history::create,
+ NULL, /* write_row */
+ table_events_stages_history::delete_all_rows,
+ table_events_stages_history::get_row_count,
+ sizeof(pos_events_stages_history), /* ref length */
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE events_stages_history("
+ "THREAD_ID BIGINT unsigned not null,"
+ "EVENT_ID BIGINT unsigned not null,"
+ "END_EVENT_ID BIGINT unsigned,"
+ "EVENT_NAME VARCHAR(128) not null,"
+ "SOURCE VARCHAR(64),"
+ "TIMER_START BIGINT unsigned,"
+ "TIMER_END BIGINT unsigned,"
+ "TIMER_WAIT BIGINT unsigned,"
+ "WORK_COMPLETED BIGINT unsigned,"
+ "WORK_ESTIMATED BIGINT unsigned,"
+ "NESTING_EVENT_ID BIGINT unsigned,"
+ "NESTING_EVENT_TYPE ENUM('TRANSACTION', 'STATEMENT', 'STAGE', 'WAIT'))") },
+ false /* perpetual */
+};
+
+THR_LOCK table_events_stages_history_long::m_table_lock;
+
+PFS_engine_table_share
+table_events_stages_history_long::m_share=
+{
+ { C_STRING_WITH_LEN("events_stages_history_long") },
+ &pfs_truncatable_acl,
+ table_events_stages_history_long::create,
+ NULL, /* write_row */
+ table_events_stages_history_long::delete_all_rows,
+ table_events_stages_history_long::get_row_count,
+ sizeof(PFS_simple_index), /* ref length */
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE events_stages_history_long("
+ "THREAD_ID BIGINT unsigned not null,"
+ "EVENT_ID BIGINT unsigned not null,"
+ "END_EVENT_ID BIGINT unsigned,"
+ "EVENT_NAME VARCHAR(128) not null,"
+ "SOURCE VARCHAR(64),"
+ "TIMER_START BIGINT unsigned,"
+ "TIMER_END BIGINT unsigned,"
+ "TIMER_WAIT BIGINT unsigned,"
+ "WORK_COMPLETED BIGINT unsigned,"
+ "WORK_ESTIMATED BIGINT unsigned,"
+ "NESTING_EVENT_ID BIGINT unsigned,"
+ "NESTING_EVENT_TYPE ENUM('TRANSACTION', 'STATEMENT', 'STAGE', 'WAIT'))") },
+ false /* perpetual */
+};
+
+table_events_stages_common::table_events_stages_common
+(const PFS_engine_table_share *share, void *pos)
+ : PFS_engine_table(share, pos),
+ m_row_exists(false)
+{}
+
+/**
+ Build a row.
+ @param stage the stage the cursor is reading
+*/
+void table_events_stages_common::make_row(PFS_events_stages *stage)
+{
+ ulonglong timer_end;
+
+ m_row_exists= false;
+
+ PFS_stage_class *unsafe= (PFS_stage_class*) stage->m_class;
+ PFS_stage_class *klass= sanitize_stage_class(unsafe);
+ if (unlikely(klass == NULL))
+ return;
+
+ m_row.m_thread_internal_id= stage->m_thread_internal_id;
+ m_row.m_event_id= stage->m_event_id;
+ m_row.m_end_event_id= stage->m_end_event_id;
+ m_row.m_nesting_event_id= stage->m_nesting_event_id;
+ m_row.m_nesting_event_type= stage->m_nesting_event_type;
+
+ if (m_row.m_end_event_id == 0)
+ {
+ timer_end= get_timer_raw_value(stage_timer);
+ }
+ else
+ {
+ timer_end= stage->m_timer_end;
+ }
+
+ m_normalizer->to_pico(stage->m_timer_start, timer_end,
+ & m_row.m_timer_start, & m_row.m_timer_end, & m_row.m_timer_wait);
+
+ m_row.m_name= klass->m_name;
+ m_row.m_name_length= klass->m_name_length;
+
+ /* Disable source file and line to avoid stale __FILE__ pointers. */
+ m_row.m_source_length= 0;
+
+ if (klass->is_progress())
+ {
+ m_row.m_progress= true;
+ m_row.m_work_completed= stage->m_progress.m_work_completed;
+ m_row.m_work_estimated= stage->m_progress.m_work_estimated;
+ }
+ else
+ {
+ m_row.m_progress= false;
+ }
+
+ m_row_exists= true;
+ return;
+}
+
+int table_events_stages_common::read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 2);
+ buf[0]= 0;
+ buf[1]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* THREAD_ID */
+ set_field_ulonglong(f, m_row.m_thread_internal_id);
+ break;
+ case 1: /* EVENT_ID */
+ set_field_ulonglong(f, m_row.m_event_id);
+ break;
+ case 2: /* END_EVENT_ID */
+ if (m_row.m_end_event_id > 0)
+ set_field_ulonglong(f, m_row.m_end_event_id - 1);
+ else
+ f->set_null();
+ break;
+ case 3: /* EVENT_NAME */
+ set_field_varchar_utf8(f, m_row.m_name, m_row.m_name_length);
+ break;
+ case 4: /* SOURCE */
+ set_field_varchar_utf8(f, m_row.m_source, m_row.m_source_length);
+ break;
+ case 5: /* TIMER_START */
+ if (m_row.m_timer_start != 0)
+ set_field_ulonglong(f, m_row.m_timer_start);
+ else
+ f->set_null();
+ break;
+ case 6: /* TIMER_END */
+ if (m_row.m_timer_end != 0)
+ set_field_ulonglong(f, m_row.m_timer_end);
+ else
+ f->set_null();
+ break;
+ case 7: /* TIMER_WAIT */
+ if (m_row.m_timer_wait != 0)
+ set_field_ulonglong(f, m_row.m_timer_wait);
+ else
+ f->set_null();
+ break;
+ case 8: /* WORK_COMPLETED */
+ if (m_row.m_progress)
+ set_field_ulonglong(f, m_row.m_work_completed);
+ else
+ f->set_null();
+ break;
+ case 9: /* WORK_ESTIMATED */
+ if (m_row.m_progress)
+ set_field_ulonglong(f, m_row.m_work_estimated);
+ else
+ f->set_null();
+ break;
+ case 10: /* NESTING_EVENT_ID */
+ if (m_row.m_nesting_event_id != 0)
+ set_field_ulonglong(f, m_row.m_nesting_event_id);
+ else
+ f->set_null();
+ break;
+ case 11: /* NESTING_EVENT_TYPE */
+ if (m_row.m_nesting_event_id != 0)
+ set_field_enum(f, m_row.m_nesting_event_type);
+ else
+ f->set_null();
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+ return 0;
+}
+
+PFS_engine_table* table_events_stages_current::create(void)
+{
+ return new table_events_stages_current();
+}
+
+table_events_stages_current::table_events_stages_current()
+ : table_events_stages_common(&m_share, &m_pos),
+ m_pos(0), m_next_pos(0)
+{}
+
+void table_events_stages_current::reset_position(void)
+{
+ m_pos.m_index= 0;
+ m_next_pos.m_index= 0;
+}
+
+int table_events_stages_current::rnd_init(bool scan)
+{
+ m_normalizer= time_normalizer::get(stage_timer);
+ return 0;
+}
+
+int table_events_stages_current::rnd_next(void)
+{
+ PFS_thread *pfs_thread;
+ PFS_events_stages *stage;
+
+ m_pos.set_at(&m_next_pos);
+ PFS_thread_iterator it= global_thread_container.iterate(m_pos.m_index);
+ pfs_thread= it.scan_next(& m_pos.m_index);
+ if (pfs_thread != NULL)
+ {
+ stage= &pfs_thread->m_stage_current;
+ make_row(stage);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int table_events_stages_current::rnd_pos(const void *pos)
+{
+ PFS_thread *pfs_thread;
+ PFS_events_stages *stage;
+
+ set_position(pos);
+
+ pfs_thread= global_thread_container.get(m_pos.m_index);
+ if (pfs_thread != NULL)
+ {
+ stage= &pfs_thread->m_stage_current;
+ make_row(stage);
+ return 0;
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+int table_events_stages_current::delete_all_rows(void)
+{
+ reset_events_stages_current();
+ return 0;
+}
+
+ha_rows
+table_events_stages_current::get_row_count(void)
+{
+ return global_thread_container.get_row_count();
+}
+
+PFS_engine_table* table_events_stages_history::create(void)
+{
+ return new table_events_stages_history();
+}
+
+table_events_stages_history::table_events_stages_history()
+ : table_events_stages_common(&m_share, &m_pos),
+ m_pos(), m_next_pos()
+{}
+
+void table_events_stages_history::reset_position(void)
+{
+ m_pos.reset();
+ m_next_pos.reset();
+}
+
+int table_events_stages_history::rnd_init(bool scan)
+{
+ m_normalizer= time_normalizer::get(stage_timer);
+ return 0;
+}
+
+int table_events_stages_history::rnd_next(void)
+{
+ PFS_thread *pfs_thread;
+ PFS_events_stages *stage;
+ bool has_more_thread= true;
+
+ if (events_stages_history_per_thread == 0)
+ return HA_ERR_END_OF_FILE;
+
+ for (m_pos.set_at(&m_next_pos);
+ has_more_thread;
+ m_pos.next_thread())
+ {
+ pfs_thread= global_thread_container.get(m_pos.m_index_1, & has_more_thread);
+ if (pfs_thread != NULL)
+ {
+ if (m_pos.m_index_2 >= events_stages_history_per_thread)
+ {
+ /* This thread does not have more (full) history */
+ continue;
+ }
+
+ if ( ! pfs_thread->m_stages_history_full &&
+ (m_pos.m_index_2 >= pfs_thread->m_stages_history_index))
+ {
+ /* This thread does not have more (not full) history */
+ continue;
+ }
+
+ stage= &pfs_thread->m_stages_history[m_pos.m_index_2];
+
+ if (stage->m_class != NULL)
+ {
+ make_row(stage);
+ /* Next iteration, look for the next history in this thread */
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int table_events_stages_history::rnd_pos(const void *pos)
+{
+ PFS_thread *pfs_thread;
+ PFS_events_stages *stage;
+
+ DBUG_ASSERT(events_stages_history_per_thread != 0);
+ set_position(pos);
+
+ DBUG_ASSERT(m_pos.m_index_2 < events_stages_history_per_thread);
+
+ pfs_thread= global_thread_container.get(m_pos.m_index_1);
+ if (pfs_thread != NULL)
+ {
+ if ( ! pfs_thread->m_stages_history_full &&
+ (m_pos.m_index_2 >= pfs_thread->m_stages_history_index))
+ return HA_ERR_RECORD_DELETED;
+
+ stage= &pfs_thread->m_stages_history[m_pos.m_index_2];
+
+ if (stage->m_class != NULL)
+ {
+ make_row(stage);
+ return 0;
+ }
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+int table_events_stages_history::delete_all_rows(void)
+{
+ reset_events_stages_history();
+ return 0;
+}
+
+ha_rows
+table_events_stages_history::get_row_count(void)
+{
+ return events_stages_history_per_thread * global_thread_container.get_row_count();
+}
+
+PFS_engine_table* table_events_stages_history_long::create(void)
+{
+ return new table_events_stages_history_long();
+}
+
+table_events_stages_history_long::table_events_stages_history_long()
+ : table_events_stages_common(&m_share, &m_pos),
+ m_pos(0), m_next_pos(0)
+{}
+
+void table_events_stages_history_long::reset_position(void)
+{
+ m_pos.m_index= 0;
+ m_next_pos.m_index= 0;
+}
+
+int table_events_stages_history_long::rnd_init(bool scan)
+{
+ m_normalizer= time_normalizer::get(stage_timer);
+ return 0;
+}
+
+int table_events_stages_history_long::rnd_next(void)
+{
+ PFS_events_stages *stage;
+ uint limit;
+
+ if (events_stages_history_long_size == 0)
+ return HA_ERR_END_OF_FILE;
+
+ if (events_stages_history_long_full)
+ limit= events_stages_history_long_size;
+ else
+ limit= events_stages_history_long_index.m_u32 % events_stages_history_long_size;
+
+ for (m_pos.set_at(&m_next_pos); m_pos.m_index < limit; m_pos.next())
+ {
+ stage= &events_stages_history_long_array[m_pos.m_index];
+
+ if (stage->m_class != NULL)
+ {
+ make_row(stage);
+ /* Next iteration, look for the next entry */
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int table_events_stages_history_long::rnd_pos(const void *pos)
+{
+ PFS_events_stages *stage;
+ uint limit;
+
+ if (events_stages_history_long_size == 0)
+ return HA_ERR_RECORD_DELETED;
+
+ set_position(pos);
+
+ if (events_stages_history_long_full)
+ limit= events_stages_history_long_size;
+ else
+ limit= events_stages_history_long_index.m_u32 % events_stages_history_long_size;
+
+ if (m_pos.m_index > limit)
+ return HA_ERR_RECORD_DELETED;
+
+ stage= &events_stages_history_long_array[m_pos.m_index];
+
+ if (stage->m_class == NULL)
+ return HA_ERR_RECORD_DELETED;
+
+ make_row(stage);
+ return 0;
+}
+
+int table_events_stages_history_long::delete_all_rows(void)
+{
+ reset_events_stages_history_long();
+ return 0;
+}
+
+ha_rows
+table_events_stages_history_long::get_row_count(void)
+{
+ return events_stages_history_long_size;
+}
+
diff --git a/storage/perfschema/table_events_stages.h b/storage/perfschema/table_events_stages.h
new file mode 100644
index 00000000..16e3fc96
--- /dev/null
+++ b/storage/perfschema/table_events_stages.h
@@ -0,0 +1,221 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_EVENTS_STAGES_H
+#define TABLE_EVENTS_STAGES_H
+
+/**
+ @file storage/perfschema/table_events_stages.h
+ Table EVENTS_STAGES_xxx (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_events_stages.h"
+
+struct PFS_thread;
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/** A row of table_events_stages_common. */
+struct row_events_stages
+{
+ /** Column THREAD_ID. */
+ ulonglong m_thread_internal_id;
+ /** Column EVENT_ID. */
+ ulonglong m_event_id;
+ /** Column END_EVENT_ID. */
+ ulonglong m_end_event_id;
+ /** Column NESTING_EVENT_ID. */
+ ulonglong m_nesting_event_id;
+ /** Column NESTING_EVENT_TYPE. */
+ enum_event_type m_nesting_event_type;
+ /** Column EVENT_NAME. */
+ const char *m_name;
+ /** Length in bytes of @c m_name. */
+ uint m_name_length;
+ /** Column TIMER_START. */
+ ulonglong m_timer_start;
+ /** Column TIMER_END. */
+ ulonglong m_timer_end;
+ /** Column TIMER_WAIT. */
+ ulonglong m_timer_wait;
+ /** Column SOURCE. */
+ char m_source[COL_SOURCE_SIZE];
+ /** Length in bytes of @c m_source. */
+ uint m_source_length;
+ bool m_progress;
+ /** Column WORK_COMPLETED. */
+ ulonglong m_work_completed;
+ /** Column WORK_ESTIMATED. */
+ ulonglong m_work_estimated;
+};
+
+/** Position of a cursor on PERFORMANCE_SCHEMA.EVENTS_STAGES_HISTORY. */
+struct pos_events_stages_history : public PFS_double_index
+{
+ pos_events_stages_history()
+ : PFS_double_index(0, 0)
+ {}
+
+ inline void reset(void)
+ {
+ m_index_1= 0;
+ m_index_2= 0;
+ }
+
+ inline void next_thread(void)
+ {
+ m_index_1++;
+ m_index_2= 0;
+ }
+};
+
+/**
+ Adapter, for table sharing the structure of
+ PERFORMANCE_SCHEMA.EVENTS_STAGES_CURRENT.
+*/
+class table_events_stages_common : public PFS_engine_table
+{
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_events_stages_common(const PFS_engine_table_share *share, void *pos);
+
+ ~table_events_stages_common()
+ {}
+
+ void make_row(PFS_events_stages *stage);
+
+ /** Current row. */
+ row_events_stages m_row;
+ /** True if the current row exists. */
+ bool m_row_exists;
+};
+
+/** Table PERFORMANCE_SCHEMA.EVENTS_STAGES_CURRENT. */
+class table_events_stages_current : public table_events_stages_common
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_init(bool scan);
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ table_events_stages_current();
+
+public:
+ ~table_events_stages_current()
+ {}
+
+private:
+ friend class table_events_stages_history;
+ friend class table_events_stages_history_long;
+
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ /** Current position. */
+ PFS_simple_index m_pos;
+ /** Next position. */
+ PFS_simple_index m_next_pos;
+};
+
+/** Table PERFORMANCE_SCHEMA.EVENTS_STAGES_HISTORY. */
+class table_events_stages_history : public table_events_stages_common
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_init(bool scan);
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ table_events_stages_history();
+
+public:
+ ~table_events_stages_history()
+ {}
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ /** Current position. */
+ pos_events_stages_history m_pos;
+ /** Next position. */
+ pos_events_stages_history m_next_pos;
+};
+
+/** Table PERFORMANCE_SCHEMA.EVENTS_STAGES_HISTORY_LONG. */
+class table_events_stages_history_long : public table_events_stages_common
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_init(bool scan);
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ table_events_stages_history_long();
+
+public:
+ ~table_events_stages_history_long()
+ {}
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ /** Current position. */
+ PFS_simple_index m_pos;
+ /** Next position. */
+ PFS_simple_index m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_events_statements.cc b/storage/perfschema/table_events_statements.cc
new file mode 100644
index 00000000..c3667f06
--- /dev/null
+++ b/storage/perfschema/table_events_statements.cc
@@ -0,0 +1,940 @@
+/* Copyright (c) 2010, 2018, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_events_statements.cc
+ Table EVENTS_STATEMENTS_xxx (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "table_events_statements.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "pfs_events_statements.h"
+#include "pfs_timer.h"
+#include "sp_head.h" /* TYPE_ENUM_FUNCTION, ... */
+#include "table_helper.h"
+#include "my_md5.h"
+#include "pfs_buffer_container.h"
+
+THR_LOCK table_events_statements_current::m_table_lock;
+
+PFS_engine_table_share
+table_events_statements_current::m_share=
+{
+ { C_STRING_WITH_LEN("events_statements_current") },
+ &pfs_truncatable_acl,
+ table_events_statements_current::create,
+ NULL, /* write_row */
+ table_events_statements_current::delete_all_rows,
+ table_events_statements_current::get_row_count,
+ sizeof(pos_events_statements_current), /* ref length */
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE events_statements_current("
+ "THREAD_ID BIGINT unsigned not null,"
+ "EVENT_ID BIGINT unsigned not null,"
+ "END_EVENT_ID BIGINT unsigned,"
+ "EVENT_NAME VARCHAR(128) not null,"
+ "SOURCE VARCHAR(64),"
+ "TIMER_START BIGINT unsigned,"
+ "TIMER_END BIGINT unsigned,"
+ "TIMER_WAIT BIGINT unsigned,"
+ "LOCK_TIME bigint unsigned not null,"
+ "SQL_TEXT LONGTEXT,"
+ "DIGEST VARCHAR(32),"
+ "DIGEST_TEXT LONGTEXT,"
+ "CURRENT_SCHEMA VARCHAR(64),"
+ "OBJECT_TYPE VARCHAR(64),"
+ "OBJECT_SCHEMA VARCHAR(64),"
+ "OBJECT_NAME VARCHAR(64),"
+ "OBJECT_INSTANCE_BEGIN BIGINT unsigned,"
+ "MYSQL_ERRNO INTEGER,"
+ "RETURNED_SQLSTATE VARCHAR(5),"
+ "MESSAGE_TEXT VARCHAR(128),"
+ "ERRORS BIGINT unsigned not null,"
+ "WARNINGS BIGINT unsigned not null,"
+ "ROWS_AFFECTED BIGINT unsigned not null,"
+ "ROWS_SENT BIGINT unsigned not null,"
+ "ROWS_EXAMINED BIGINT unsigned not null,"
+ "CREATED_TMP_DISK_TABLES BIGINT unsigned not null,"
+ "CREATED_TMP_TABLES BIGINT unsigned not null,"
+ "SELECT_FULL_JOIN BIGINT unsigned not null,"
+ "SELECT_FULL_RANGE_JOIN BIGINT unsigned not null,"
+ "SELECT_RANGE BIGINT unsigned not null,"
+ "SELECT_RANGE_CHECK BIGINT unsigned not null,"
+ "SELECT_SCAN BIGINT unsigned not null,"
+ "SORT_MERGE_PASSES BIGINT unsigned not null,"
+ "SORT_RANGE BIGINT unsigned not null,"
+ "SORT_ROWS BIGINT unsigned not null,"
+ "SORT_SCAN BIGINT unsigned not null,"
+ "NO_INDEX_USED BIGINT unsigned not null,"
+ "NO_GOOD_INDEX_USED BIGINT unsigned not null,"
+ "NESTING_EVENT_ID BIGINT unsigned,"
+ "NESTING_EVENT_TYPE ENUM('TRANSACTION', 'STATEMENT', 'STAGE', 'WAIT'),"
+ "NESTING_EVENT_LEVEL INT)") },
+ false /* perpetual */
+};
+
+THR_LOCK table_events_statements_history::m_table_lock;
+
+PFS_engine_table_share
+table_events_statements_history::m_share=
+{
+ { C_STRING_WITH_LEN("events_statements_history") },
+ &pfs_truncatable_acl,
+ table_events_statements_history::create,
+ NULL, /* write_row */
+ table_events_statements_history::delete_all_rows,
+ table_events_statements_history::get_row_count,
+ sizeof(pos_events_statements_history), /* ref length */
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE events_statements_history("
+ "THREAD_ID BIGINT unsigned not null,"
+ "EVENT_ID BIGINT unsigned not null,"
+ "END_EVENT_ID BIGINT unsigned,"
+ "EVENT_NAME VARCHAR(128) not null,"
+ "SOURCE VARCHAR(64),"
+ "TIMER_START BIGINT unsigned,"
+ "TIMER_END BIGINT unsigned,"
+ "TIMER_WAIT BIGINT unsigned,"
+ "LOCK_TIME bigint unsigned not null,"
+ "SQL_TEXT LONGTEXT,"
+ "DIGEST VARCHAR(32),"
+ "DIGEST_TEXT LONGTEXT,"
+ "CURRENT_SCHEMA VARCHAR(64),"
+ "OBJECT_TYPE VARCHAR(64),"
+ "OBJECT_SCHEMA VARCHAR(64),"
+ "OBJECT_NAME VARCHAR(64),"
+ "OBJECT_INSTANCE_BEGIN BIGINT unsigned,"
+ "MYSQL_ERRNO INTEGER,"
+ "RETURNED_SQLSTATE VARCHAR(5),"
+ "MESSAGE_TEXT VARCHAR(128),"
+ "ERRORS BIGINT unsigned not null,"
+ "WARNINGS BIGINT unsigned not null,"
+ "ROWS_AFFECTED BIGINT unsigned not null,"
+ "ROWS_SENT BIGINT unsigned not null,"
+ "ROWS_EXAMINED BIGINT unsigned not null,"
+ "CREATED_TMP_DISK_TABLES BIGINT unsigned not null,"
+ "CREATED_TMP_TABLES BIGINT unsigned not null,"
+ "SELECT_FULL_JOIN BIGINT unsigned not null,"
+ "SELECT_FULL_RANGE_JOIN BIGINT unsigned not null,"
+ "SELECT_RANGE BIGINT unsigned not null,"
+ "SELECT_RANGE_CHECK BIGINT unsigned not null,"
+ "SELECT_SCAN BIGINT unsigned not null,"
+ "SORT_MERGE_PASSES BIGINT unsigned not null,"
+ "SORT_RANGE BIGINT unsigned not null,"
+ "SORT_ROWS BIGINT unsigned not null,"
+ "SORT_SCAN BIGINT unsigned not null,"
+ "NO_INDEX_USED BIGINT unsigned not null,"
+ "NO_GOOD_INDEX_USED BIGINT unsigned not null,"
+ "NESTING_EVENT_ID BIGINT unsigned,"
+ "NESTING_EVENT_TYPE ENUM('TRANSACTION', 'STATEMENT', 'STAGE', 'WAIT'),"
+ "NESTING_EVENT_LEVEL INT)") },
+ false /* perpetual */
+};
+
+THR_LOCK table_events_statements_history_long::m_table_lock;
+
+PFS_engine_table_share
+table_events_statements_history_long::m_share=
+{
+ { C_STRING_WITH_LEN("events_statements_history_long") },
+ &pfs_truncatable_acl,
+ table_events_statements_history_long::create,
+ NULL, /* write_row */
+ table_events_statements_history_long::delete_all_rows,
+ table_events_statements_history_long::get_row_count,
+ sizeof(PFS_simple_index), /* ref length */
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE events_statements_history_long("
+ "THREAD_ID BIGINT unsigned not null,"
+ "EVENT_ID BIGINT unsigned not null,"
+ "END_EVENT_ID BIGINT unsigned,"
+ "EVENT_NAME VARCHAR(128) not null,"
+ "SOURCE VARCHAR(64),"
+ "TIMER_START BIGINT unsigned,"
+ "TIMER_END BIGINT unsigned,"
+ "TIMER_WAIT BIGINT unsigned,"
+ "LOCK_TIME bigint unsigned not null,"
+ "SQL_TEXT LONGTEXT,"
+ "DIGEST VARCHAR(32),"
+ "DIGEST_TEXT LONGTEXT,"
+ "CURRENT_SCHEMA VARCHAR(64),"
+ "OBJECT_TYPE VARCHAR(64),"
+ "OBJECT_SCHEMA VARCHAR(64),"
+ "OBJECT_NAME VARCHAR(64),"
+ "OBJECT_INSTANCE_BEGIN BIGINT unsigned,"
+ "MYSQL_ERRNO INTEGER,"
+ "RETURNED_SQLSTATE VARCHAR(5),"
+ "MESSAGE_TEXT VARCHAR(128),"
+ "ERRORS BIGINT unsigned not null,"
+ "WARNINGS BIGINT unsigned not null,"
+ "ROWS_AFFECTED BIGINT unsigned not null,"
+ "ROWS_SENT BIGINT unsigned not null,"
+ "ROWS_EXAMINED BIGINT unsigned not null,"
+ "CREATED_TMP_DISK_TABLES BIGINT unsigned not null,"
+ "CREATED_TMP_TABLES BIGINT unsigned not null,"
+ "SELECT_FULL_JOIN BIGINT unsigned not null,"
+ "SELECT_FULL_RANGE_JOIN BIGINT unsigned not null,"
+ "SELECT_RANGE BIGINT unsigned not null,"
+ "SELECT_RANGE_CHECK BIGINT unsigned not null,"
+ "SELECT_SCAN BIGINT unsigned not null,"
+ "SORT_MERGE_PASSES BIGINT unsigned not null,"
+ "SORT_RANGE BIGINT unsigned not null,"
+ "SORT_ROWS BIGINT unsigned not null,"
+ "SORT_SCAN BIGINT unsigned not null,"
+ "NO_INDEX_USED BIGINT unsigned not null,"
+ "NO_GOOD_INDEX_USED BIGINT unsigned not null,"
+ "NESTING_EVENT_ID BIGINT unsigned,"
+ "NESTING_EVENT_TYPE ENUM('TRANSACTION', 'STATEMENT', 'STAGE', 'WAIT'),"
+ "NESTING_EVENT_LEVEL INT)") },
+ false /* perpetual */
+};
+
+table_events_statements_common::table_events_statements_common
+(const PFS_engine_table_share *share, void *pos)
+ : PFS_engine_table(share, pos),
+ m_row_exists(false)
+{}
+
+/**
+ Build a row.
+ @param statement the statement the cursor is reading
+*/
+void table_events_statements_common::make_row_part_1(PFS_events_statements *statement,
+ sql_digest_storage *digest)
+{
+ ulonglong timer_end;
+
+ m_row_exists= false;
+
+ PFS_statement_class *unsafe= (PFS_statement_class*) statement->m_class;
+ PFS_statement_class *klass= sanitize_statement_class(unsafe);
+ if (unlikely(klass == NULL))
+ return;
+
+ m_row.m_thread_internal_id= statement->m_thread_internal_id;
+ m_row.m_event_id= statement->m_event_id;
+ m_row.m_end_event_id= statement->m_end_event_id;
+ m_row.m_nesting_event_id= statement->m_nesting_event_id;
+ m_row.m_nesting_event_type= statement->m_nesting_event_type;
+ m_row.m_nesting_event_level= statement->m_nesting_event_level;
+
+ if (m_row.m_end_event_id == 0)
+ {
+ timer_end= get_timer_raw_value(statement_timer);
+ }
+ else
+ {
+ timer_end= statement->m_timer_end;
+ }
+
+ m_normalizer->to_pico(statement->m_timer_start, timer_end,
+ & m_row.m_timer_start, & m_row.m_timer_end, & m_row.m_timer_wait);
+ m_row.m_lock_time= statement->m_lock_time * MICROSEC_TO_PICOSEC;
+
+ m_row.m_name= klass->m_name;
+ m_row.m_name_length= klass->m_name_length;
+
+ CHARSET_INFO *cs= get_charset(statement->m_sqltext_cs_number, MYF(0));
+ size_t valid_length= statement->m_sqltext_length;
+
+ if (cs != NULL)
+ {
+ if (cs->mbmaxlen > 1)
+ {
+ valid_length= Well_formed_prefix(cs,
+ statement->m_sqltext,
+ valid_length).length();
+ }
+ }
+
+ m_row.m_sqltext.set_charset(cs);
+ m_row.m_sqltext.length(0);
+ m_row.m_sqltext.append(statement->m_sqltext, (uint32)valid_length, cs);
+
+ /* Indicate that sqltext is truncated or not well-formed. */
+ if (statement->m_sqltext_truncated || valid_length < statement->m_sqltext_length)
+ {
+ size_t chars= m_row.m_sqltext.numchars();
+ if (chars > 3)
+ {
+ chars-= 3;
+ uint32 bytes_offset= m_row.m_sqltext.charpos(chars, 0);
+ m_row.m_sqltext.length(bytes_offset);
+ m_row.m_sqltext.append("...", 3);
+ }
+ }
+
+ m_row.m_current_schema_name_length= statement->m_current_schema_name_length;
+ if (m_row.m_current_schema_name_length > 0)
+ memcpy(m_row.m_current_schema_name, statement->m_current_schema_name, m_row.m_current_schema_name_length);
+
+ m_row.m_object_type= statement->m_sp_type;
+
+ m_row.m_schema_name_length= statement->m_schema_name_length;
+ if (m_row.m_schema_name_length > 0)
+ memcpy(m_row.m_schema_name, statement->m_schema_name, m_row.m_schema_name_length);
+
+ m_row.m_object_name_length= statement->m_object_name_length;
+ if (m_row.m_object_name_length > 0)
+ memcpy(m_row.m_object_name, statement->m_object_name, m_row.m_object_name_length);
+
+ /* Disable source file and line to avoid stale __FILE__ pointers. */
+ m_row.m_source_length= 0;
+
+ memcpy(m_row.m_message_text, statement->m_message_text, sizeof(m_row.m_message_text));
+ m_row.m_sql_errno= statement->m_sql_errno;
+ memcpy(m_row.m_sqlstate, statement->m_sqlstate, SQLSTATE_LENGTH);
+ m_row.m_error_count= statement->m_error_count;
+ m_row.m_warning_count= statement->m_warning_count;
+ m_row.m_rows_affected= statement->m_rows_affected;
+
+ m_row.m_rows_sent= statement->m_rows_sent;
+ m_row.m_rows_examined= statement->m_rows_examined;
+ m_row.m_created_tmp_disk_tables= statement->m_created_tmp_disk_tables;
+ m_row.m_created_tmp_tables= statement->m_created_tmp_tables;
+ m_row.m_select_full_join= statement->m_select_full_join;
+ m_row.m_select_full_range_join= statement->m_select_full_range_join;
+ m_row.m_select_range= statement->m_select_range;
+ m_row.m_select_range_check= statement->m_select_range_check;
+ m_row.m_select_scan= statement->m_select_scan;
+ m_row.m_sort_merge_passes= statement->m_sort_merge_passes;
+ m_row.m_sort_range= statement->m_sort_range;
+ m_row.m_sort_rows= statement->m_sort_rows;
+ m_row.m_sort_scan= statement->m_sort_scan;
+ m_row.m_no_index_used= statement->m_no_index_used;
+ m_row.m_no_good_index_used= statement->m_no_good_index_used;
+
+ /*
+ Making a copy of digest storage.
+ */
+ digest->copy(& statement->m_digest_storage);
+
+ m_row_exists= true;
+ return;
+}
+
+void table_events_statements_common::make_row_part_2(const sql_digest_storage *digest)
+{
+ /*
+ Filling up statement digest information.
+ */
+ size_t safe_byte_count= digest->m_byte_count;
+ if (safe_byte_count > 0 &&
+ safe_byte_count <= pfs_max_digest_length)
+ {
+ /* Generate the DIGEST string from the MD5 digest */
+ MD5_HASH_TO_STRING(digest->m_md5,
+ m_row.m_digest.m_digest);
+ m_row.m_digest.m_digest_length= MD5_HASH_TO_STRING_LENGTH;
+
+ /* Generate the DIGEST_TEXT string from the token array */
+ compute_digest_text(digest, &m_row.m_digest.m_digest_text);
+
+ if (m_row.m_digest.m_digest_text.length() == 0)
+ m_row.m_digest.m_digest_length= 0;
+ }
+ else
+ {
+ m_row.m_digest.m_digest_length= 0;
+ m_row.m_digest.m_digest_text.length(0);
+ }
+
+ return;
+}
+
+int table_events_statements_common::read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+ uint len;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 3);
+ buf[0]= 0;
+ buf[1]= 0;
+ buf[2]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* THREAD_ID */
+ set_field_ulonglong(f, m_row.m_thread_internal_id);
+ break;
+ case 1: /* EVENT_ID */
+ set_field_ulonglong(f, m_row.m_event_id);
+ break;
+ case 2: /* END_EVENT_ID */
+ if (m_row.m_end_event_id > 0)
+ set_field_ulonglong(f, m_row.m_end_event_id - 1);
+ else
+ f->set_null();
+ break;
+ case 3: /* EVENT_NAME */
+ set_field_varchar_utf8(f, m_row.m_name, m_row.m_name_length);
+ break;
+ case 4: /* SOURCE */
+ set_field_varchar_utf8(f, m_row.m_source, m_row.m_source_length);
+ break;
+ case 5: /* TIMER_START */
+ if (m_row.m_timer_start != 0)
+ set_field_ulonglong(f, m_row.m_timer_start);
+ else
+ f->set_null();
+ break;
+ case 6: /* TIMER_END */
+ if (m_row.m_timer_end != 0)
+ set_field_ulonglong(f, m_row.m_timer_end);
+ else
+ f->set_null();
+ break;
+ case 7: /* TIMER_WAIT */
+ if (m_row.m_timer_wait != 0)
+ set_field_ulonglong(f, m_row.m_timer_wait);
+ else
+ f->set_null();
+ break;
+ case 8: /* LOCK_TIME */
+ if (m_row.m_lock_time != 0)
+ set_field_ulonglong(f, m_row.m_lock_time);
+ else
+ f->set_null();
+ break;
+ case 9: /* SQL_TEXT */
+ if (m_row.m_sqltext.length())
+ set_field_longtext_utf8(f, m_row.m_sqltext.ptr(), m_row.m_sqltext.length());
+ else
+ f->set_null();
+ break;
+ case 10: /* DIGEST */
+ if (m_row.m_digest.m_digest_length > 0)
+ set_field_varchar_utf8(f, m_row.m_digest.m_digest,
+ m_row.m_digest.m_digest_length);
+ else
+ f->set_null();
+ break;
+ case 11: /* DIGEST_TEXT */
+ if (m_row.m_digest.m_digest_text.length() > 0)
+ set_field_longtext_utf8(f, m_row.m_digest.m_digest_text.ptr(),
+ m_row.m_digest.m_digest_text.length());
+ else
+ f->set_null();
+ break;
+ case 12: /* CURRENT_SCHEMA */
+ if (m_row.m_current_schema_name_length)
+ set_field_varchar_utf8(f, m_row.m_current_schema_name,
+ m_row.m_current_schema_name_length);
+ else
+ f->set_null();
+ break;
+ case 13: /* OBJECT_TYPE */
+ if (m_row.m_object_name_length > 0)
+ set_field_object_type(f, m_row.m_object_type);
+ else
+ f->set_null();
+ break;
+ case 14: /* OBJECT_SCHEMA */
+ if (m_row.m_schema_name_length)
+ set_field_varchar_utf8(f, m_row.m_schema_name,
+ m_row.m_schema_name_length);
+ else
+ f->set_null();
+ break;
+ case 15: /* OBJECT_NAME */
+ if (m_row.m_object_name_length)
+ set_field_varchar_utf8(f, m_row.m_object_name,
+ m_row.m_object_name_length);
+ else
+ f->set_null();
+ break;
+ case 16: /* OBJECT_INSTANCE_BEGIN */
+ f->set_null();
+ break;
+ case 17: /* MYSQL_ERRNO */
+ set_field_ulong(f, m_row.m_sql_errno);
+ break;
+ case 18: /* RETURNED_SQLSTATE */
+ if (m_row.m_sqlstate[0] != 0)
+ set_field_varchar_utf8(f, m_row.m_sqlstate, SQLSTATE_LENGTH);
+ else
+ f->set_null();
+ break;
+ case 19: /* MESSAGE_TEXT */
+ len= static_cast<uint>(strlen(m_row.m_message_text));
+ if (len)
+ set_field_varchar_utf8(f, m_row.m_message_text, len);
+ else
+ f->set_null();
+ break;
+ case 20: /* ERRORS */
+ set_field_ulonglong(f, m_row.m_error_count);
+ break;
+ case 21: /* WARNINGS */
+ set_field_ulonglong(f, m_row.m_warning_count);
+ break;
+ case 22: /* ROWS_AFFECTED */
+ set_field_ulonglong(f, m_row.m_rows_affected);
+ break;
+ case 23: /* ROWS_SENT */
+ set_field_ulonglong(f, m_row.m_rows_sent);
+ break;
+ case 24: /* ROWS_EXAMINED */
+ set_field_ulonglong(f, m_row.m_rows_examined);
+ break;
+ case 25: /* CREATED_TMP_DISK_TABLES */
+ set_field_ulonglong(f, m_row.m_created_tmp_disk_tables);
+ break;
+ case 26: /* CREATED_TMP_TABLES */
+ set_field_ulonglong(f, m_row.m_created_tmp_tables);
+ break;
+ case 27: /* SELECT_FULL_JOIN */
+ set_field_ulonglong(f, m_row.m_select_full_join);
+ break;
+ case 28: /* SELECT_FULL_RANGE_JOIN */
+ set_field_ulonglong(f, m_row.m_select_full_range_join);
+ break;
+ case 29: /* SELECT_RANGE */
+ set_field_ulonglong(f, m_row.m_select_range);
+ break;
+ case 30: /* SELECT_RANGE_CHECK */
+ set_field_ulonglong(f, m_row.m_select_range_check);
+ break;
+ case 31: /* SELECT_SCAN */
+ set_field_ulonglong(f, m_row.m_select_scan);
+ break;
+ case 32: /* SORT_MERGE_PASSES */
+ set_field_ulonglong(f, m_row.m_sort_merge_passes);
+ break;
+ case 33: /* SORT_RANGE */
+ set_field_ulonglong(f, m_row.m_sort_range);
+ break;
+ case 34: /* SORT_ROWS */
+ set_field_ulonglong(f, m_row.m_sort_rows);
+ break;
+ case 35: /* SORT_SCAN */
+ set_field_ulonglong(f, m_row.m_sort_scan);
+ break;
+ case 36: /* NO_INDEX_USED */
+ set_field_ulonglong(f, m_row.m_no_index_used);
+ break;
+ case 37: /* NO_GOOD_INDEX_USED */
+ set_field_ulonglong(f, m_row.m_no_good_index_used);
+ break;
+ case 38: /* NESTING_EVENT_ID */
+ if (m_row.m_nesting_event_id != 0)
+ set_field_ulonglong(f, m_row.m_nesting_event_id);
+ else
+ f->set_null();
+ break;
+ case 39: /* NESTING_EVENT_TYPE */
+ if (m_row.m_nesting_event_id != 0)
+ set_field_enum(f, m_row.m_nesting_event_type);
+ else
+ f->set_null();
+ break;
+ case 40: /* NESTING_EVENT_LEVEL */
+ set_field_ulong(f, m_row.m_nesting_event_level);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+ return 0;
+}
+
+PFS_engine_table* table_events_statements_current::create(void)
+{
+ return new table_events_statements_current();
+}
+
+table_events_statements_current::table_events_statements_current()
+ : table_events_statements_common(&m_share, &m_pos),
+ m_pos(), m_next_pos()
+{}
+
+void table_events_statements_current::reset_position(void)
+{
+ m_pos.reset();
+ m_next_pos.reset();
+}
+
+int table_events_statements_current::rnd_init(bool scan)
+{
+ m_normalizer= time_normalizer::get(statement_timer);
+ return 0;
+}
+
+int table_events_statements_current::rnd_next(void)
+{
+ PFS_thread *pfs_thread;
+ PFS_events_statements *statement;
+ bool has_more_thread= true;
+
+ for (m_pos.set_at(&m_next_pos);
+ has_more_thread;
+ m_pos.next_thread())
+ {
+ pfs_thread= global_thread_container.get(m_pos.m_index_1, & has_more_thread);
+ if (pfs_thread != NULL)
+ {
+ uint safe_events_statements_count= pfs_thread->m_events_statements_count;
+
+ if (safe_events_statements_count == 0)
+ {
+ /* Display the last top level statement, when completed */
+ if (m_pos.m_index_2 >= 1)
+ continue;
+ }
+ else
+ {
+ /* Display all pending statements, when in progress */
+ if (m_pos.m_index_2 >= safe_events_statements_count)
+ continue;
+ }
+
+ statement= &pfs_thread->m_statement_stack[m_pos.m_index_2];
+
+ make_row(pfs_thread, statement);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int table_events_statements_current::rnd_pos(const void *pos)
+{
+ PFS_thread *pfs_thread;
+ PFS_events_statements *statement;
+
+ set_position(pos);
+
+ pfs_thread= global_thread_container.get(m_pos.m_index_1);
+ if (pfs_thread != NULL)
+ {
+ uint safe_events_statements_count= pfs_thread->m_events_statements_count;
+
+ if (safe_events_statements_count == 0)
+ {
+ /* Display the last top level statement, when completed */
+ if (m_pos.m_index_2 >= 1)
+ return HA_ERR_RECORD_DELETED;
+ }
+ else
+ {
+ /* Display all pending statements, when in progress */
+ if (m_pos.m_index_2 >= safe_events_statements_count)
+ return HA_ERR_RECORD_DELETED;
+ }
+
+ DBUG_ASSERT(m_pos.m_index_2 < statement_stack_max);
+
+ statement= &pfs_thread->m_statement_stack[m_pos.m_index_2];
+
+ if (statement->m_class != NULL)
+ {
+ make_row(pfs_thread, statement);
+ return 0;
+ }
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_events_statements_current::make_row(PFS_thread *pfs_thread,
+ PFS_events_statements *statement)
+{
+ sql_digest_storage digest;
+ pfs_optimistic_state lock;
+ pfs_optimistic_state stmt_lock;
+
+ digest.reset(m_token_array, MAX_DIGEST_STORAGE_SIZE);
+ /* Protect this reader against thread termination. */
+ pfs_thread->m_lock.begin_optimistic_lock(&lock);
+ /* Protect this reader against writing on statement information. */
+ pfs_thread->m_stmt_lock.begin_optimistic_lock(&stmt_lock);
+
+ table_events_statements_common::make_row_part_1(statement, &digest);
+
+ if (!pfs_thread->m_stmt_lock.end_optimistic_lock(&stmt_lock) ||
+ !pfs_thread->m_lock.end_optimistic_lock(&lock))
+ {
+ m_row_exists= false;
+ return;
+ }
+ table_events_statements_common::make_row_part_2(&digest);
+ return;
+}
+
+int table_events_statements_current::delete_all_rows(void)
+{
+ reset_events_statements_current();
+ return 0;
+}
+
+ha_rows
+table_events_statements_current::get_row_count(void)
+{
+ return global_thread_container.get_row_count() * statement_stack_max;
+}
+
+PFS_engine_table* table_events_statements_history::create(void)
+{
+ return new table_events_statements_history();
+}
+
+table_events_statements_history::table_events_statements_history()
+ : table_events_statements_common(&m_share, &m_pos),
+ m_pos(), m_next_pos()
+{}
+
+void table_events_statements_history::reset_position(void)
+{
+ m_pos.reset();
+ m_next_pos.reset();
+}
+
+int table_events_statements_history::rnd_init(bool scan)
+{
+ m_normalizer= time_normalizer::get(statement_timer);
+ return 0;
+}
+
+int table_events_statements_history::rnd_next(void)
+{
+ PFS_thread *pfs_thread;
+ PFS_events_statements *statement;
+ bool has_more_thread= true;
+
+ if (events_statements_history_per_thread == 0)
+ return HA_ERR_END_OF_FILE;
+
+ for (m_pos.set_at(&m_next_pos);
+ has_more_thread;
+ m_pos.next_thread())
+ {
+ pfs_thread= global_thread_container.get(m_pos.m_index_1, & has_more_thread);
+ if (pfs_thread != NULL)
+ {
+ if (m_pos.m_index_2 >= events_statements_history_per_thread)
+ {
+ /* This thread does not have more (full) history */
+ continue;
+ }
+
+ if ( ! pfs_thread->m_statements_history_full &&
+ (m_pos.m_index_2 >= pfs_thread->m_statements_history_index))
+ {
+ /* This thread does not have more (not full) history */
+ continue;
+ }
+
+ statement= &pfs_thread->m_statements_history[m_pos.m_index_2];
+
+ if (statement->m_class != NULL)
+ {
+ make_row(pfs_thread, statement);
+ /* Next iteration, look for the next history in this thread */
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int table_events_statements_history::rnd_pos(const void *pos)
+{
+ PFS_thread *pfs_thread;
+ PFS_events_statements *statement;
+
+ DBUG_ASSERT(events_statements_history_per_thread != 0);
+ set_position(pos);
+
+ pfs_thread= global_thread_container.get(m_pos.m_index_1);
+ if (pfs_thread != NULL)
+ {
+ DBUG_ASSERT(m_pos.m_index_2 < events_statements_history_per_thread);
+
+ if ( ! pfs_thread->m_statements_history_full &&
+ (m_pos.m_index_2 >= pfs_thread->m_statements_history_index))
+ return HA_ERR_RECORD_DELETED;
+
+ statement= &pfs_thread->m_statements_history[m_pos.m_index_2];
+ if (statement->m_class != NULL)
+ {
+ make_row(pfs_thread, statement);
+ return 0;
+ }
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_events_statements_history::make_row(PFS_thread *pfs_thread,
+ PFS_events_statements *statement)
+{
+ sql_digest_storage digest;
+ pfs_optimistic_state lock;
+
+ digest.reset(m_token_array, MAX_DIGEST_STORAGE_SIZE);
+ /* Protect this reader against thread termination. */
+ pfs_thread->m_lock.begin_optimistic_lock(&lock);
+
+ table_events_statements_common::make_row_part_1(statement, &digest);
+
+ if (!pfs_thread->m_lock.end_optimistic_lock(&lock))
+ {
+ m_row_exists= false;
+ return;
+ }
+ table_events_statements_common::make_row_part_2(&digest);
+ return;
+}
+
+
+int table_events_statements_history::delete_all_rows(void)
+{
+ reset_events_statements_history();
+ return 0;
+}
+
+ha_rows
+table_events_statements_history::get_row_count(void)
+{
+ return events_statements_history_per_thread * global_thread_container.get_row_count();
+}
+
+PFS_engine_table* table_events_statements_history_long::create(void)
+{
+ return new table_events_statements_history_long();
+}
+
+table_events_statements_history_long::table_events_statements_history_long()
+ : table_events_statements_common(&m_share, &m_pos),
+ m_pos(0), m_next_pos(0)
+{}
+
+void table_events_statements_history_long::reset_position(void)
+{
+ m_pos.m_index= 0;
+ m_next_pos.m_index= 0;
+}
+
+int table_events_statements_history_long::rnd_init(bool scan)
+{
+ m_normalizer= time_normalizer::get(statement_timer);
+ return 0;
+}
+
+int table_events_statements_history_long::rnd_next(void)
+{
+ PFS_events_statements *statement;
+ uint limit;
+
+ if (events_statements_history_long_size == 0)
+ return HA_ERR_END_OF_FILE;
+
+ if (events_statements_history_long_full)
+ limit= static_cast<uint>(events_statements_history_long_size);
+ else
+ limit= events_statements_history_long_index.m_u32 % events_statements_history_long_size;
+
+ for (m_pos.set_at(&m_next_pos); m_pos.m_index < limit; m_pos.next())
+ {
+ statement= &events_statements_history_long_array[m_pos.m_index];
+
+ if (statement->m_class != NULL)
+ {
+ make_row(statement);
+ /* Next iteration, look for the next entry */
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int table_events_statements_history_long::rnd_pos(const void *pos)
+{
+ PFS_events_statements *statement;
+ uint limit;
+
+ if (events_statements_history_long_size == 0)
+ return HA_ERR_RECORD_DELETED;
+
+ set_position(pos);
+
+ if (events_statements_history_long_full)
+ limit= static_cast<uint>(events_statements_history_long_size);
+ else
+ limit= events_statements_history_long_index.m_u32 % events_statements_history_long_size;
+
+ if (m_pos.m_index >= limit)
+ return HA_ERR_RECORD_DELETED;
+
+ statement= &events_statements_history_long_array[m_pos.m_index];
+
+ if (statement->m_class == NULL)
+ return HA_ERR_RECORD_DELETED;
+
+ make_row(statement);
+ return 0;
+}
+
+void table_events_statements_history_long::make_row(PFS_events_statements *statement)
+{
+ sql_digest_storage digest;
+
+ digest.reset(m_token_array, MAX_DIGEST_STORAGE_SIZE);
+ table_events_statements_common::make_row_part_1(statement, &digest);
+
+ table_events_statements_common::make_row_part_2(&digest);
+ return;
+}
+
+int table_events_statements_history_long::delete_all_rows(void)
+{
+ reset_events_statements_history_long();
+ return 0;
+}
+
+ha_rows
+table_events_statements_history_long::get_row_count(void)
+{
+ return events_statements_history_long_size;
+}
+
diff --git a/storage/perfschema/table_events_statements.h b/storage/perfschema/table_events_statements.h
new file mode 100644
index 00000000..02127cad
--- /dev/null
+++ b/storage/perfschema/table_events_statements.h
@@ -0,0 +1,314 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_EVENTS_STATEMENTS_H
+#define TABLE_EVENTS_STATEMENTS_H
+
+/**
+ @file storage/perfschema/table_events_statements.h
+ Table EVENTS_STATEMENTS_xxx (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_events_statements.h"
+#include "table_helper.h"
+
+struct PFS_thread;
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/** A row of table_events_statements_common. */
+struct row_events_statements
+{
+ /** Column THREAD_ID. */
+ ulonglong m_thread_internal_id;
+ /** Column EVENT_ID. */
+ ulonglong m_event_id;
+ /** Column END_EVENT_ID. */
+ ulonglong m_end_event_id;
+ /** Column NESTING_EVENT_ID. */
+ ulonglong m_nesting_event_id;
+ /** Column NESTING_EVENT_TYPE. */
+ enum_event_type m_nesting_event_type;
+ /** Column NESTING_EVENT_LEVEL. */
+ uint m_nesting_event_level;
+ /** Column EVENT_NAME. */
+ const char *m_name;
+ /** Length in bytes of @c m_name. */
+ uint m_name_length;
+ /** Column TIMER_START. */
+ ulonglong m_timer_start;
+ /** Column TIMER_END. */
+ ulonglong m_timer_end;
+ /** Column TIMER_WAIT. */
+ ulonglong m_timer_wait;
+ /** Column LOCK_TIME. */
+ ulonglong m_lock_time;
+ /** Column SOURCE. */
+ char m_source[COL_SOURCE_SIZE];
+ /** Length in bytes of @c m_source. */
+ uint m_source_length;
+ /** Column SQL_TEXT. */
+ String m_sqltext;
+ /** Column DIGEST and DIGEST_TEXT. */
+ PFS_digest_row m_digest;
+ /** Column CURRENT_SCHEMA. */
+ char m_current_schema_name[NAME_LEN];
+ /** Length in bytes of @c m_current_schema_name. */
+ uint m_current_schema_name_length;
+
+ /** Column OBJECT_TYPE. */
+ enum_object_type m_object_type;
+ /** Column OBJECT_SCHEMA. */
+ char m_schema_name[NAME_LEN];
+ /** Length in bytes of @c m_schema_name. */
+ uint m_schema_name_length;
+ /** Column OBJECT_NAME. */
+ char m_object_name[NAME_LEN];
+ /** Length in bytes of @c m_object_name. */
+ uint m_object_name_length;
+
+
+ /** Column MESSAGE_TEXT. */
+ char m_message_text[MYSQL_ERRMSG_SIZE+1];
+ /** Column MYSQL_ERRNO. */
+ uint m_sql_errno;
+ /** Column RETURNED_SQLSTATE. */
+ char m_sqlstate[SQLSTATE_LENGTH];
+ /** Column ERRORS. */
+ uint m_error_count;
+ /** Column WARNINGS. */
+ uint m_warning_count;
+ /** Column ROWS_AFFECTED. */
+ ulonglong m_rows_affected;
+ /** Column ROWS_SENT. */
+ ulonglong m_rows_sent;
+ /** Column ROWS_EXAMINED. */
+ ulonglong m_rows_examined;
+ /** Column CREATED_TMP_DISK_TABLES. */
+ ulonglong m_created_tmp_disk_tables;
+ /** Column CREATED_TMP_TABLES. */
+ ulonglong m_created_tmp_tables;
+ /** Column SELECT_FULL_JOIN. */
+ ulonglong m_select_full_join;
+ /** Column SELECT_FULL_RANGE_JOIN. */
+ ulonglong m_select_full_range_join;
+ /** Column SELECT_RANGE. */
+ ulonglong m_select_range;
+ /** Column SELECT_RANGE_CHECK. */
+ ulonglong m_select_range_check;
+ /** Column SELECT_SCAN. */
+ ulonglong m_select_scan;
+ /** Column SORT_MERGE_PASSES. */
+ ulonglong m_sort_merge_passes;
+ /** Column SORT_RANGE. */
+ ulonglong m_sort_range;
+ /** Column SORT_ROWS. */
+ ulonglong m_sort_rows;
+ /** Column SORT_SCAN. */
+ ulonglong m_sort_scan;
+ /** Column NO_INDEX_USED. */
+ ulonglong m_no_index_used;
+ /** Column NO_GOOD_INDEX_USED. */
+ ulonglong m_no_good_index_used;
+};
+
+/** Position of a cursor on PERFORMANCE_SCHEMA.EVENTS_STATEMENTS_CURRENT. */
+struct pos_events_statements_current : public PFS_double_index
+{
+ pos_events_statements_current()
+ : PFS_double_index(0, 0)
+ {}
+
+ inline void reset(void)
+ {
+ m_index_1= 0;
+ m_index_2= 0;
+ }
+
+ inline void next_thread(void)
+ {
+ m_index_1++;
+ m_index_2= 0;
+ }
+};
+
+/** Position of a cursor on PERFORMANCE_SCHEMA.EVENTS_STATEMENTS_HISTORY. */
+struct pos_events_statements_history : public PFS_double_index
+{
+ pos_events_statements_history()
+ : PFS_double_index(0, 0)
+ {}
+
+ inline void reset(void)
+ {
+ m_index_1= 0;
+ m_index_2= 0;
+ }
+
+ inline void next_thread(void)
+ {
+ m_index_1++;
+ m_index_2= 0;
+ }
+};
+
+/**
+ Adapter, for table sharing the structure of
+ PERFORMANCE_SCHEMA.EVENTS_STATEMENTS_CURRENT.
+*/
+class table_events_statements_common : public PFS_engine_table
+{
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_events_statements_common(const PFS_engine_table_share *share, void *pos);
+
+ ~table_events_statements_common()
+ {}
+
+ void make_row_part_1(PFS_events_statements *statement,
+ sql_digest_storage *digest);
+
+ void make_row_part_2(const sql_digest_storage *digest);
+
+ /** Current row. */
+ row_events_statements m_row;
+ /** True if the current row exists. */
+ bool m_row_exists;
+ unsigned char m_token_array[MAX_DIGEST_STORAGE_SIZE];
+};
+
+/** Table PERFORMANCE_SCHEMA.EVENTS_STATEMENTS_CURRENT. */
+class table_events_statements_current : public table_events_statements_common
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_init(bool scan);
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ table_events_statements_current();
+
+public:
+ ~table_events_statements_current()
+ {}
+
+private:
+ friend class table_events_statements_history;
+ friend class table_events_statements_history_long;
+
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ void make_row(PFS_thread* pfs_thread, PFS_events_statements *statement);
+
+ /** Current position. */
+ pos_events_statements_current m_pos;
+ /** Next position. */
+ pos_events_statements_current m_next_pos;
+};
+
+/** Table PERFORMANCE_SCHEMA.EVENTS_STATEMENTS_HISTORY. */
+class table_events_statements_history : public table_events_statements_common
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_init(bool scan);
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ table_events_statements_history();
+
+public:
+ ~table_events_statements_history()
+ {}
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ void make_row(PFS_thread* pfs_thread, PFS_events_statements *statement);
+
+ /** Current position. */
+ pos_events_statements_history m_pos;
+ /** Next position. */
+ pos_events_statements_history m_next_pos;
+};
+
+/** Table PERFORMANCE_SCHEMA.EVENTS_STATEMENTS_HISTORY_LONG. */
+class table_events_statements_history_long : public table_events_statements_common
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_init(bool scan);
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ table_events_statements_history_long();
+
+public:
+ ~table_events_statements_history_long()
+ {}
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ void make_row(PFS_events_statements *statement);
+
+ /** Current position. */
+ PFS_simple_index m_pos;
+ /** Next position. */
+ PFS_simple_index m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_events_transactions.cc b/storage/perfschema/table_events_transactions.cc
new file mode 100644
index 00000000..1d717979
--- /dev/null
+++ b/storage/perfschema/table_events_transactions.cc
@@ -0,0 +1,718 @@
+/* Copyright (c) 2010, 2018, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_events_transactions.cc
+ Table EVENTS_TRANSACTIONS_xxx (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "table_events_transactions.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "pfs_events_transactions.h"
+#include "pfs_timer.h"
+#include "table_helper.h"
+#include "pfs_buffer_container.h"
+#include "field.h"
+//#include "xa.h"
+
+THR_LOCK table_events_transactions_current::m_table_lock;
+
+PFS_engine_table_share
+table_events_transactions_current::m_share=
+{
+ { C_STRING_WITH_LEN("events_transactions_current") },
+ &pfs_truncatable_acl,
+ table_events_transactions_current::create,
+ NULL, /* write_row */
+ table_events_transactions_current::delete_all_rows,
+ table_events_transactions_current::get_row_count,
+ sizeof(PFS_simple_index), /* ref length */
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE events_transactions_current("
+ "THREAD_ID BIGINT unsigned not null,"
+ "EVENT_ID BIGINT unsigned not null,"
+ "END_EVENT_ID BIGINT unsigned,"
+ "EVENT_NAME VARCHAR(128) not null,"
+ "STATE ENUM('ACTIVE', 'COMMITTED', 'ROLLED BACK'),"
+ "TRX_ID BIGINT unsigned,"
+ "GTID VARCHAR(64),"
+ "XID_FORMAT_ID INTEGER,"
+ "XID_GTRID VARCHAR(130),"
+ "XID_BQUAL VARCHAR(130),"
+ "XA_STATE VARCHAR(64),"
+ "SOURCE VARCHAR(64),"
+ "TIMER_START BIGINT unsigned,"
+ "TIMER_END BIGINT unsigned,"
+ "TIMER_WAIT BIGINT unsigned,"
+ "ACCESS_MODE ENUM('READ ONLY', 'READ WRITE'),"
+ "ISOLATION_LEVEL VARCHAR(64),"
+ "AUTOCOMMIT ENUM('YES','NO') not null,"
+ "NUMBER_OF_SAVEPOINTS BIGINT unsigned,"
+ "NUMBER_OF_ROLLBACK_TO_SAVEPOINT BIGINT unsigned,"
+ "NUMBER_OF_RELEASE_SAVEPOINT BIGINT unsigned,"
+ "OBJECT_INSTANCE_BEGIN BIGINT unsigned,"
+ "NESTING_EVENT_ID BIGINT unsigned,"
+ "NESTING_EVENT_TYPE ENUM('TRANSACTION', 'STATEMENT', 'STAGE', 'WAIT'))")},
+ false /* perpetual */
+};
+
+THR_LOCK table_events_transactions_history::m_table_lock;
+
+PFS_engine_table_share
+table_events_transactions_history::m_share=
+{
+ { C_STRING_WITH_LEN("events_transactions_history") },
+ &pfs_truncatable_acl,
+ table_events_transactions_history::create,
+ NULL, /* write_row */
+ table_events_transactions_history::delete_all_rows,
+ table_events_transactions_history::get_row_count,
+ sizeof(pos_events_transactions_history), /* ref length */
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE events_transactions_history("
+ "THREAD_ID BIGINT unsigned not null,"
+ "EVENT_ID BIGINT unsigned not null,"
+ "END_EVENT_ID BIGINT unsigned,"
+ "EVENT_NAME VARCHAR(128) not null,"
+ "STATE ENUM('ACTIVE', 'COMMITTED', 'ROLLED BACK'),"
+ "TRX_ID BIGINT unsigned,"
+ "GTID VARCHAR(64),"
+ "XID_FORMAT_ID INTEGER,"
+ "XID_GTRID VARCHAR(130),"
+ "XID_BQUAL VARCHAR(130),"
+ "XA_STATE VARCHAR(64),"
+ "SOURCE VARCHAR(64),"
+ "TIMER_START BIGINT unsigned,"
+ "TIMER_END BIGINT unsigned,"
+ "TIMER_WAIT BIGINT unsigned,"
+ "ACCESS_MODE ENUM('READ ONLY', 'READ WRITE'),"
+ "ISOLATION_LEVEL VARCHAR(64),"
+ "AUTOCOMMIT ENUM('YES','NO') not null,"
+ "NUMBER_OF_SAVEPOINTS BIGINT unsigned,"
+ "NUMBER_OF_ROLLBACK_TO_SAVEPOINT BIGINT unsigned,"
+ "NUMBER_OF_RELEASE_SAVEPOINT BIGINT unsigned,"
+ "OBJECT_INSTANCE_BEGIN BIGINT unsigned,"
+ "NESTING_EVENT_ID BIGINT unsigned,"
+ "NESTING_EVENT_TYPE ENUM('TRANSACTION', 'STATEMENT', 'STAGE', 'WAIT'))")},
+ false /* perpetual */
+};
+
+THR_LOCK table_events_transactions_history_long::m_table_lock;
+
+PFS_engine_table_share
+table_events_transactions_history_long::m_share=
+{
+ { C_STRING_WITH_LEN("events_transactions_history_long") },
+ &pfs_truncatable_acl,
+ table_events_transactions_history_long::create,
+ NULL, /* write_row */
+ table_events_transactions_history_long::delete_all_rows,
+ table_events_transactions_history_long::get_row_count,
+ sizeof(PFS_simple_index), /* ref length */
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE events_transactions_history_long("
+ "THREAD_ID BIGINT unsigned not null,"
+ "EVENT_ID BIGINT unsigned not null,"
+ "END_EVENT_ID BIGINT unsigned,"
+ "EVENT_NAME VARCHAR(128) not null,"
+ "STATE ENUM('ACTIVE', 'COMMITTED', 'ROLLED BACK'),"
+ "TRX_ID BIGINT unsigned,"
+ "GTID VARCHAR(64),"
+ "XID_FORMAT_ID INTEGER,"
+ "XID_GTRID VARCHAR(130),"
+ "XID_BQUAL VARCHAR(130),"
+ "XA_STATE VARCHAR(64),"
+ "SOURCE VARCHAR(64),"
+ "TIMER_START BIGINT unsigned,"
+ "TIMER_END BIGINT unsigned,"
+ "TIMER_WAIT BIGINT unsigned,"
+ "ACCESS_MODE ENUM('READ ONLY', 'READ WRITE'),"
+ "ISOLATION_LEVEL VARCHAR(64),"
+ "AUTOCOMMIT ENUM('YES','NO') not null,"
+ "NUMBER_OF_SAVEPOINTS BIGINT unsigned,"
+ "NUMBER_OF_ROLLBACK_TO_SAVEPOINT BIGINT unsigned,"
+ "NUMBER_OF_RELEASE_SAVEPOINT BIGINT unsigned,"
+ "OBJECT_INSTANCE_BEGIN BIGINT unsigned,"
+ "NESTING_EVENT_ID BIGINT unsigned,"
+ "NESTING_EVENT_TYPE ENUM('TRANSACTION', 'STATEMENT', 'STAGE', 'WAIT'))")},
+ false /* perpetual */
+};
+
+table_events_transactions_common::table_events_transactions_common
+(const PFS_engine_table_share *share, void *pos)
+ : PFS_engine_table(share, pos),
+ m_row_exists(false)
+{}
+
+/**
+ Build a row.
+ @param transaction the transaction the cursor is reading
+*/
+void table_events_transactions_common::make_row(PFS_events_transactions *transaction)
+{
+ ulonglong timer_end;
+
+ m_row_exists= false;
+
+ PFS_transaction_class *unsafe= (PFS_transaction_class*) transaction->m_class;
+ PFS_transaction_class *klass= sanitize_transaction_class(unsafe);
+ if (unlikely(klass == NULL))
+ return;
+
+ m_row.m_thread_internal_id= transaction->m_thread_internal_id;
+ m_row.m_event_id= transaction->m_event_id;
+ m_row.m_end_event_id= transaction->m_end_event_id;
+ m_row.m_nesting_event_id= transaction->m_nesting_event_id;
+ m_row.m_nesting_event_type= transaction->m_nesting_event_type;
+
+ if (m_row.m_end_event_id == 0)
+ {
+ timer_end= get_timer_raw_value(transaction_timer);
+ }
+ else
+ {
+ timer_end= transaction->m_timer_end;
+ }
+
+ m_normalizer->to_pico(transaction->m_timer_start, timer_end,
+ &m_row.m_timer_start, &m_row.m_timer_end, &m_row.m_timer_wait);
+ m_row.m_name= klass->m_name;
+ m_row.m_name_length= klass->m_name_length;
+
+ /* Disable source file and line to avoid stale __FILE__ pointers. */
+ m_row.m_source_length= 0;
+
+ /* A GTID consists of the SID (source id) and GNO (transaction number).
+ The SID is stored in transaction->m_sid and the GNO is stored in
+ transaction->m_gtid_spec.gno.
+
+ On a master, the GTID is assigned when the transaction commit.
+ On a slave, the GTID is assigned before the transaction starts.
+ If GTID_MODE = OFF, all transactions have the special GTID
+ 'ANONYMOUS'.
+
+ Therefore, a transaction can be in three different states wrt GTIDs:
+ - Before the GTID has been assigned, the state is 'AUTOMATIC'.
+ On a master, this is the state until the transaction commits.
+ On a slave, this state does not appear.
+ - If GTID_MODE = ON, and a GTID is assigned, the GTID is a string
+ of the form 'UUID:NUMBER'.
+ - If GTID_MODE = OFF, and a GTID is assigned, the GTID is a string
+ of the form 'ANONYMOUS'.
+
+ The Gtid_specification contains the GNO, as well as a type code
+ that specifies which of the three modes is currently in effect.
+ Given a SID, it can generate the textual representation of the
+ GTID.
+ */
+ //rpl_sid *sid= &transaction->m_sid;
+ Gtid_specification *gtid_spec= &transaction->m_gtid_spec;
+ m_row.m_gtid_length= static_cast<uint>(gtid_spec->to_string(m_row.m_gtid));
+
+ m_row.m_xid= transaction->m_xid;
+ m_row.m_isolation_level= transaction->m_isolation_level;
+ m_row.m_read_only= transaction->m_read_only;
+ m_row.m_trxid= transaction->m_trxid;
+ m_row.m_state= transaction->m_state;
+ m_row.m_xa_state= transaction->m_xa_state;
+ m_row.m_xa= transaction->m_xa;
+ m_row.m_autocommit= transaction->m_autocommit;
+ m_row.m_savepoint_count= transaction->m_savepoint_count;
+ m_row.m_rollback_to_savepoint_count= transaction->m_rollback_to_savepoint_count;
+ m_row.m_release_savepoint_count= transaction->m_release_savepoint_count;
+ m_row_exists= true;
+ return;
+}
+
+/** Size of XID converted to null-terminated hex string prefixed with 0x. */
+static const ulong XID_BUFFER_SIZE= XIDDATASIZE*2 + 2 + 1;
+
+/**
+ Convert the XID to HEX string prefixed by '0x'
+
+ @param[out] buf output hex string buffer, null-terminated
+ @param buf_len size of buffer, must be at least @c XID_BUFFER_SIZE
+ @param xid XID structure
+ @param offset offset into XID.data[]
+ @param length number of bytes to process
+ @return number of bytes in hex string
+*/
+static size_t xid_to_hex(char *buf, size_t buf_len, PSI_xid *xid, size_t offset, size_t length)
+{
+ DBUG_ASSERT(buf_len >= XID_BUFFER_SIZE);
+ DBUG_ASSERT(offset + length <= XIDDATASIZE);
+ *buf++= '0';
+ *buf++= 'x';
+ return bin_to_hex_str(buf, buf_len-2, (char*)(xid->data + offset), length) + 2;
+}
+
+/**
+ Store the XID in printable format if possible, otherwise convert
+ to a string of hex digits.
+
+ @param field Record field
+ @param xid XID structure
+ @param offset offset into XID.data[]
+ @param length number of bytes to process
+*/
+static void xid_store(Field *field, PSI_xid *xid, size_t offset, size_t length)
+{
+ DBUG_ASSERT(!xid->is_null());
+ if (xid_printable(xid, offset, length))
+ {
+ field->store(xid->data + offset, length, &my_charset_bin);
+ }
+ else
+ {
+ /*
+ xid_buf contains enough space for 0x followed by hex representation of
+ the binary XID data and one null termination character.
+ */
+ char xid_buf[XID_BUFFER_SIZE];
+
+ size_t xid_str_len= xid_to_hex(xid_buf, sizeof(xid_buf), xid, offset, length);
+ field->store(xid_buf, xid_str_len, &my_charset_bin);
+ }
+}
+
+static void xid_store_bqual(Field *field, PSI_xid *xid)
+{
+ xid_store(field, xid, xid->gtrid_length, xid->bqual_length);
+}
+
+static void xid_store_gtrid(Field *field, PSI_xid *xid)
+{
+ xid_store(field, xid, 0, xid->gtrid_length);
+}
+
+int table_events_transactions_common::read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 3);
+ buf[0]= 0;
+ buf[1]= 0;
+ buf[2]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* THREAD_ID */
+ set_field_ulonglong(f, m_row.m_thread_internal_id);
+ break;
+ case 1: /* EVENT_ID */
+ set_field_ulonglong(f, m_row.m_event_id);
+ break;
+ case 2: /* END_EVENT_ID */
+ if (m_row.m_end_event_id > 0)
+ set_field_ulonglong(f, m_row.m_end_event_id - 1);
+ else
+ f->set_null();
+ break;
+ case 3: /* EVENT_NAME */
+ set_field_varchar_utf8(f, m_row.m_name, m_row.m_name_length);
+ break;
+ case 4: /* STATE */
+ set_field_enum(f, m_row.m_state);
+ break;
+ case 5: /* TRX_ID */
+ if (m_row.m_trxid != 0)
+ set_field_ulonglong(f, m_row.m_trxid);
+ else
+ f->set_null();
+ break;
+ case 6: /* GTID */
+ set_field_varchar_utf8(f, m_row.m_gtid, m_row.m_gtid_length);
+ break;
+ case 7: /* XID_FORMAT_ID */
+ if (!m_row.m_xa || m_row.m_xid.is_null())
+ f->set_null();
+ else
+ set_field_long(f, m_row.m_xid.formatID);
+ break;
+ case 8: /* XID_GTRID */
+ if (!m_row.m_xa || m_row.m_xid.is_null() || m_row.m_xid.gtrid_length <= 0)
+ f->set_null();
+ else
+ xid_store_gtrid(f, &m_row.m_xid);
+ break;
+ case 9: /* XID_BQUAL */
+ if (!m_row.m_xa || m_row.m_xid.is_null() || m_row.m_xid.bqual_length <= 0)
+ f->set_null();
+ else
+ xid_store_bqual(f, &m_row.m_xid);
+ break;
+ case 10: /* XA STATE */
+ if (!m_row.m_xa || m_row.m_xid.is_null())
+ f->set_null();
+ else
+ set_field_xa_state(f, m_row.m_xa_state);
+ break;
+ case 11: /* SOURCE */
+ set_field_varchar_utf8(f, m_row.m_source, m_row.m_source_length);
+ break;
+ case 12: /* TIMER_START */
+ if (m_row.m_timer_start != 0)
+ set_field_ulonglong(f, m_row.m_timer_start);
+ else
+ f->set_null();
+ break;
+ case 13: /* TIMER_END */
+ if (m_row.m_timer_end != 0)
+ set_field_ulonglong(f, m_row.m_timer_end);
+ else
+ f->set_null();
+ break;
+ case 14: /* TIMER_WAIT */
+ if (m_row.m_timer_wait != 0)
+ set_field_ulonglong(f, m_row.m_timer_wait);
+ else
+ f->set_null();
+ break;
+ case 15: /* ACCESS_MODE */
+ set_field_enum(f, m_row.m_read_only ? TRANS_MODE_READ_ONLY
+ : TRANS_MODE_READ_WRITE);
+ break;
+ case 16: /* ISOLATION_LEVEL */
+ set_field_isolation_level(f, m_row.m_isolation_level);
+ break;
+ case 17: /* AUTOCOMMIT */
+ set_field_enum(f, m_row.m_autocommit ? ENUM_YES : ENUM_NO);
+ break;
+ case 18: /* NUMBER_OF_SAVEPOINTS */
+ set_field_ulonglong(f, m_row.m_savepoint_count);
+ break;
+ case 19: /* NUMBER_OF_ROLLBACK_TO_SAVEPOINT */
+ set_field_ulonglong(f, m_row.m_rollback_to_savepoint_count);
+ break;
+ case 20: /* NUMBER_OF_RELEASE_SAVEPOINT */
+ set_field_ulonglong(f, m_row.m_release_savepoint_count);
+ break;
+ case 21: /* OBJECT_INSTANCE_BEGIN */
+ f->set_null();
+ break;
+ case 22: /* NESTING_EVENT_ID */
+ if (m_row.m_nesting_event_id != 0)
+ set_field_ulonglong(f, m_row.m_nesting_event_id);
+ else
+ f->set_null();
+ break;
+ case 23: /* NESTING_EVENT_TYPE */
+ if (m_row.m_nesting_event_id != 0)
+ set_field_enum(f, m_row.m_nesting_event_type);
+ else
+ f->set_null();
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+ return 0;
+}
+
+PFS_engine_table* table_events_transactions_current::create(void)
+{
+ return new table_events_transactions_current();
+}
+
+table_events_transactions_current::table_events_transactions_current()
+ : table_events_transactions_common(&m_share, &m_pos),
+ m_pos(0), m_next_pos(0)
+{}
+
+void table_events_transactions_current::reset_position(void)
+{
+ m_pos.m_index= 0;
+ m_next_pos.m_index= 0;
+}
+
+int table_events_transactions_current::rnd_init(bool scan)
+{
+ m_normalizer= time_normalizer::get(transaction_timer);
+ return 0;
+}
+
+int table_events_transactions_current::rnd_next(void)
+{
+ PFS_thread *pfs_thread;
+ PFS_events_transactions *transaction;
+ bool has_more_thread= true;
+
+ for (m_pos.set_at(&m_next_pos);
+ has_more_thread;
+ m_pos.next())
+ {
+ pfs_thread= global_thread_container.get(m_pos.m_index, & has_more_thread);
+ if (pfs_thread != NULL)
+ {
+ transaction= &pfs_thread->m_transaction_current;
+ make_row(transaction);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int table_events_transactions_current::rnd_pos(const void *pos)
+{
+ PFS_thread *pfs_thread;
+ PFS_events_transactions *transaction;
+
+ set_position(pos);
+
+ pfs_thread= global_thread_container.get(m_pos.m_index);
+ if (pfs_thread != NULL)
+ {
+ transaction= &pfs_thread->m_transaction_current;
+ if (transaction->m_class != NULL)
+ {
+ make_row(transaction);
+ return 0;
+ }
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+int table_events_transactions_current::delete_all_rows(void)
+{
+ reset_events_transactions_current();
+ return 0;
+}
+
+ha_rows
+table_events_transactions_current::get_row_count(void)
+{
+ return global_thread_container.get_row_count();
+}
+
+PFS_engine_table* table_events_transactions_history::create(void)
+{
+ return new table_events_transactions_history();
+}
+
+table_events_transactions_history::table_events_transactions_history()
+ : table_events_transactions_common(&m_share, &m_pos),
+ m_pos(), m_next_pos()
+{}
+
+void table_events_transactions_history::reset_position(void)
+{
+ m_pos.reset();
+ m_next_pos.reset();
+}
+
+int table_events_transactions_history::rnd_init(bool scan)
+{
+ m_normalizer= time_normalizer::get(transaction_timer);
+ return 0;
+}
+
+int table_events_transactions_history::rnd_next(void)
+{
+ PFS_thread *pfs_thread;
+ PFS_events_transactions *transaction;
+ bool has_more_thread= true;
+
+ if (events_transactions_history_per_thread == 0)
+ return HA_ERR_END_OF_FILE;
+
+ for (m_pos.set_at(&m_next_pos);
+ has_more_thread;
+ m_pos.next_thread())
+ {
+ pfs_thread= global_thread_container.get(m_pos.m_index_1, & has_more_thread);
+ if (pfs_thread != NULL)
+ {
+ if (m_pos.m_index_2 >= events_transactions_history_per_thread)
+ {
+ /* This thread does not have more (full) history */
+ continue;
+ }
+
+ if ( ! pfs_thread->m_transactions_history_full &&
+ (m_pos.m_index_2 >= pfs_thread->m_transactions_history_index))
+ {
+ /* This thread does not have more (not full) history */
+ continue;
+ }
+
+ transaction= &pfs_thread->m_transactions_history[m_pos.m_index_2];
+ if (transaction->m_class != NULL)
+ {
+ make_row(transaction);
+ /* Next iteration, look for the next history in this thread */
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int table_events_transactions_history::rnd_pos(const void *pos)
+{
+ PFS_thread *pfs_thread;
+ PFS_events_transactions *transaction;
+
+ DBUG_ASSERT(events_transactions_history_per_thread != 0);
+ set_position(pos);
+
+ DBUG_ASSERT(m_pos.m_index_2 < events_transactions_history_per_thread);
+
+ pfs_thread= global_thread_container.get(m_pos.m_index_1);
+ if (pfs_thread != NULL)
+ {
+ if ( ! pfs_thread->m_transactions_history_full &&
+ (m_pos.m_index_2 >= pfs_thread->m_transactions_history_index))
+ return HA_ERR_RECORD_DELETED;
+
+ transaction= &pfs_thread->m_transactions_history[m_pos.m_index_2];
+ if (transaction->m_class != NULL)
+ {
+ make_row(transaction);
+ return 0;
+ }
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+int table_events_transactions_history::delete_all_rows(void)
+{
+ reset_events_transactions_history();
+ return 0;
+}
+
+ha_rows
+table_events_transactions_history::get_row_count(void)
+{
+ return events_transactions_history_per_thread * global_thread_container.get_row_count();
+}
+
+PFS_engine_table* table_events_transactions_history_long::create(void)
+{
+ return new table_events_transactions_history_long();
+}
+
+table_events_transactions_history_long::table_events_transactions_history_long()
+ : table_events_transactions_common(&m_share, &m_pos),
+ m_pos(0), m_next_pos(0)
+{}
+
+void table_events_transactions_history_long::reset_position(void)
+{
+ m_pos.m_index= 0;
+ m_next_pos.m_index= 0;
+}
+
+int table_events_transactions_history_long::rnd_init(bool scan)
+{
+ m_normalizer= time_normalizer::get(transaction_timer);
+ return 0;
+}
+
+int table_events_transactions_history_long::rnd_next(void)
+{
+ PFS_events_transactions *transaction;
+ uint limit;
+
+ if (events_transactions_history_long_size == 0)
+ return HA_ERR_END_OF_FILE;
+
+ if (events_transactions_history_long_full)
+ limit= events_transactions_history_long_size;
+ else
+ limit= events_transactions_history_long_index.m_u32 % events_transactions_history_long_size;
+
+ for (m_pos.set_at(&m_next_pos); m_pos.m_index < limit; m_pos.next())
+ {
+ transaction= &events_transactions_history_long_array[m_pos.m_index];
+
+ if (transaction->m_class != NULL)
+ {
+ make_row(transaction);
+ /* Next iteration, look for the next entry */
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int table_events_transactions_history_long::rnd_pos(const void *pos)
+{
+ PFS_events_transactions *transaction;
+ uint limit;
+
+ if (events_transactions_history_long_size == 0)
+ return HA_ERR_RECORD_DELETED;
+
+ set_position(pos);
+
+ if (events_transactions_history_long_full)
+ limit= events_transactions_history_long_size;
+ else
+ limit= events_transactions_history_long_index.m_u32 % events_transactions_history_long_size;
+
+ if (m_pos.m_index >= limit)
+ return HA_ERR_RECORD_DELETED;
+
+ transaction= &events_transactions_history_long_array[m_pos.m_index];
+
+ if (transaction->m_class == NULL)
+ return HA_ERR_RECORD_DELETED;
+
+ make_row(transaction);
+ return 0;
+}
+
+int table_events_transactions_history_long::delete_all_rows(void)
+{
+ reset_events_transactions_history_long();
+ return 0;
+}
+
+ha_rows
+table_events_transactions_history_long::get_row_count(void)
+{
+ return events_transactions_history_long_size;
+}
+
diff --git a/storage/perfschema/table_events_transactions.h b/storage/perfschema/table_events_transactions.h
new file mode 100644
index 00000000..9987319a
--- /dev/null
+++ b/storage/perfschema/table_events_transactions.h
@@ -0,0 +1,254 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_EVENTS_TRANSACTIONS_H
+#define TABLE_EVENTS_TRANSACTIONS_H
+
+/**
+ @file storage/perfschema/table_events_HA_ERR_WRONG_COMMAND.h
+ Table EVENTS_TRANSACTIONS_xxx (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_events_transactions.h"
+#include "table_helper.h"
+#include "rpl_gtid.h"
+
+struct PFS_thread;
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/** A row of table_events_transactions_common. */
+struct row_events_transactions
+{
+ /** Column THREAD_ID. */
+ ulonglong m_thread_internal_id;
+ /** Column EVENT_ID. */
+ ulonglong m_event_id;
+ /** Column END_EVENT_ID. */
+ ulonglong m_end_event_id;
+ /** Column NESTING_EVENT_ID. */
+ ulonglong m_nesting_event_id;
+ /** Column NESTING_EVENT_TYPE. */
+ enum_event_type m_nesting_event_type;
+ /** Column EVENT_NAME. */
+ const char *m_name;
+ /** Length in bytes of @c m_name. */
+ uint m_name_length;
+ /** Column TIMER_START. */
+ ulonglong m_timer_start;
+ /** Column TIMER_END. */
+ ulonglong m_timer_end;
+ /** Column TIMER_WAIT. */
+ ulonglong m_timer_wait;
+ /** Column SOURCE. */
+ char m_source[COL_SOURCE_SIZE];
+ /** Length in bytes of @c m_source. */
+ uint m_source_length;
+ /** InnoDB transaction id. */
+ ulonglong m_trxid;
+ /** Transaction state. */
+ enum_transaction_state m_state;
+ /** Global Transaction ID. */
+ char m_gtid[GTID_MAX_STR_LENGTH + 1];
+ /** GTID length in bytes*/
+ int m_gtid_length;
+ /** XA transaction ID. */
+ PSI_xid m_xid;
+ /** XA transaction state. */
+ enum_xa_transaction_state m_xa_state;
+ /** True if XA transaction. */
+ bool m_xa;
+ /** True if autocommit transaction. */
+ bool m_autocommit;
+ /** Isolation level. */
+ enum_isolation_level m_isolation_level;
+ /** True if read-only, read-write otherwise. */
+ bool m_read_only;
+ /** Column NUMBER_OF_SAVEPOINTS. */
+ ulonglong m_savepoint_count;
+ /** Column NUMBER_OF_ROLLBACK_TO_SAVEPOINT. */
+ ulonglong m_rollback_to_savepoint_count;
+ /** Column NUMBER_OF_RELEASE_SAVEPOINT. */
+ ulonglong m_release_savepoint_count;
+};
+
+/**
+ Position of a cursor on PERFORMANCE_SCHEMA.EVENTS_TRANSACTIONS_HISTORY.
+ Index 1 on thread (0 based)
+ Index 2 on transaction event record in thread history (0 based)
+*/
+struct pos_events_transactions_history : public PFS_double_index
+{
+ pos_events_transactions_history()
+ : PFS_double_index(0, 0)
+ {}
+
+ inline void reset(void)
+ {
+ m_index_1= 0;
+ m_index_2= 0;
+ }
+
+ inline void next_thread(void)
+ {
+ m_index_1++;
+ m_index_2= 0;
+ }
+};
+
+/**
+ Adapter, for table sharing the structure of
+ PERFORMANCE_SCHEMA.EVENTS_TRANSACTIONS_CURRENT.
+*/
+class table_events_transactions_common : public PFS_engine_table
+{
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_events_transactions_common(const PFS_engine_table_share *share, void *pos);
+
+ ~table_events_transactions_common()
+ {}
+
+ void make_row(PFS_events_transactions *statement);
+
+ /** Current row. */
+ row_events_transactions m_row;
+ /** True if the current row exists. */
+ bool m_row_exists;
+};
+
+/** Table PERFORMANCE_SCHEMA.EVENTS_TRANSACTIONS_CURRENT. */
+class table_events_transactions_current : public table_events_transactions_common
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_init(bool scan);
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ table_events_transactions_current();
+
+public:
+ ~table_events_transactions_current()
+ {}
+
+private:
+ friend class table_events_transactions_history;
+ friend class table_events_transactions_history_long;
+
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+ /**
+ Fields definition.
+ Also used by table_events_transactions_history
+ and table_events_transactions_history_long.
+ */
+ static TABLE_FIELD_DEF m_field_def;
+
+ /** Current position. */
+ PFS_simple_index m_pos;
+ /** Next position. */
+ PFS_simple_index m_next_pos;
+};
+
+/** Table PERFORMANCE_SCHEMA.EVENTS_TRANSACTIONS_HISTORY. */
+class table_events_transactions_history : public table_events_transactions_common
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_init(bool scan);
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ table_events_transactions_history();
+
+public:
+ ~table_events_transactions_history()
+ {}
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ /** Current position. */
+ pos_events_transactions_history m_pos;
+ /** Next position. */
+ pos_events_transactions_history m_next_pos;
+};
+
+/** Table PERFORMANCE_SCHEMA.EVENTS_TRANSACTIONS_HISTORY_LONG. */
+class table_events_transactions_history_long : public table_events_transactions_common
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_init(bool scan);
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ table_events_transactions_history_long();
+
+public:
+ ~table_events_transactions_history_long()
+ {}
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ /** Current position. */
+ PFS_simple_index m_pos;
+ /** Next position. */
+ PFS_simple_index m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_events_waits.cc b/storage/perfschema/table_events_waits.cc
new file mode 100644
index 00000000..aa73344f
--- /dev/null
+++ b/storage/perfschema/table_events_waits.cc
@@ -0,0 +1,1143 @@
+/* Copyright (c) 2008, 2018, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_events_waits.cc
+ Table EVENTS_WAITS_xxx (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "table_events_waits.h"
+#include "pfs_global.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "pfs_events_waits.h"
+#include "pfs_timer.h"
+#include "m_string.h"
+#include "pfs_buffer_container.h"
+#include "field.h"
+
+THR_LOCK table_events_waits_current::m_table_lock;
+
+PFS_engine_table_share
+table_events_waits_current::m_share=
+{
+ { C_STRING_WITH_LEN("events_waits_current") },
+ &pfs_truncatable_acl,
+ table_events_waits_current::create,
+ NULL, /* write_row */
+ table_events_waits_current::delete_all_rows,
+ table_events_waits_current::get_row_count,
+ sizeof(pos_events_waits_current), /* ref length */
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE events_waits_current("
+ "THREAD_ID BIGINT unsigned not null,"
+ "EVENT_ID BIGINT unsigned not null,"
+ "END_EVENT_ID BIGINT unsigned,"
+ "EVENT_NAME VARCHAR(128) not null,"
+ "SOURCE VARCHAR(64),"
+ "TIMER_START BIGINT unsigned,"
+ "TIMER_END BIGINT unsigned,"
+ "TIMER_WAIT BIGINT unsigned,"
+ "SPINS INTEGER unsigned,"
+ "OBJECT_SCHEMA VARCHAR(64),"
+ "OBJECT_NAME VARCHAR(512),"
+ "INDEX_NAME VARCHAR(64),"
+ "OBJECT_TYPE VARCHAR(64),"
+ "OBJECT_INSTANCE_BEGIN BIGINT unsigned not null,"
+ "NESTING_EVENT_ID BIGINT unsigned,"
+ "NESTING_EVENT_TYPE ENUM('TRANSACTION', 'STATEMENT', 'STAGE', 'WAIT'),"
+ "OPERATION VARCHAR(32) not null,"
+ "NUMBER_OF_BYTES BIGINT,"
+ "FLAGS INTEGER unsigned)") },
+ false /* perpetual */
+};
+
+THR_LOCK table_events_waits_history::m_table_lock;
+
+PFS_engine_table_share
+table_events_waits_history::m_share=
+{
+ { C_STRING_WITH_LEN("events_waits_history") },
+ &pfs_truncatable_acl,
+ table_events_waits_history::create,
+ NULL, /* write_row */
+ table_events_waits_history::delete_all_rows,
+ table_events_waits_history::get_row_count,
+ sizeof(pos_events_waits_history), /* ref length */
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE events_waits_history("
+ "THREAD_ID BIGINT unsigned not null,"
+ "EVENT_ID BIGINT unsigned not null,"
+ "END_EVENT_ID BIGINT unsigned,"
+ "EVENT_NAME VARCHAR(128) not null,"
+ "SOURCE VARCHAR(64),"
+ "TIMER_START BIGINT unsigned,"
+ "TIMER_END BIGINT unsigned,"
+ "TIMER_WAIT BIGINT unsigned,"
+ "SPINS INTEGER unsigned,"
+ "OBJECT_SCHEMA VARCHAR(64),"
+ "OBJECT_NAME VARCHAR(512),"
+ "INDEX_NAME VARCHAR(64),"
+ "OBJECT_TYPE VARCHAR(64),"
+ "OBJECT_INSTANCE_BEGIN BIGINT unsigned not null,"
+ "NESTING_EVENT_ID BIGINT unsigned,"
+ "NESTING_EVENT_TYPE ENUM('TRANSACTION', 'STATEMENT', 'STAGE', 'WAIT'),"
+ "OPERATION VARCHAR(32) not null,"
+ "NUMBER_OF_BYTES BIGINT,"
+ "FLAGS INTEGER unsigned)") },
+ false /* perpetual */
+};
+
+THR_LOCK table_events_waits_history_long::m_table_lock;
+
+PFS_engine_table_share
+table_events_waits_history_long::m_share=
+{
+ { C_STRING_WITH_LEN("events_waits_history_long") },
+ &pfs_truncatable_acl,
+ table_events_waits_history_long::create,
+ NULL, /* write_row */
+ table_events_waits_history_long::delete_all_rows,
+ table_events_waits_history_long::get_row_count,
+ sizeof(PFS_simple_index), /* ref length */
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE events_waits_history_long("
+ "THREAD_ID BIGINT unsigned not null,"
+ "EVENT_ID BIGINT unsigned not null,"
+ "END_EVENT_ID BIGINT unsigned,"
+ "EVENT_NAME VARCHAR(128) not null,"
+ "SOURCE VARCHAR(64),"
+ "TIMER_START BIGINT unsigned,"
+ "TIMER_END BIGINT unsigned,"
+ "TIMER_WAIT BIGINT unsigned,"
+ "SPINS INTEGER unsigned,"
+ "OBJECT_SCHEMA VARCHAR(64),"
+ "OBJECT_NAME VARCHAR(512),"
+ "INDEX_NAME VARCHAR(64),"
+ "OBJECT_TYPE VARCHAR(64),"
+ "OBJECT_INSTANCE_BEGIN BIGINT unsigned not null,"
+ "NESTING_EVENT_ID BIGINT unsigned,"
+ "NESTING_EVENT_TYPE ENUM('TRANSACTION', 'STATEMENT', 'STAGE', 'WAIT'),"
+ "OPERATION VARCHAR(32) not null,"
+ "NUMBER_OF_BYTES BIGINT,"
+ "FLAGS INTEGER unsigned)") },
+ false /* perpetual */
+};
+
+table_events_waits_common::table_events_waits_common
+(const PFS_engine_table_share *share, void *pos)
+ : PFS_engine_table(share, pos),
+ m_row_exists(false)
+{}
+
+void table_events_waits_common::clear_object_columns()
+{
+ m_row.m_object_type_length= 0;
+ m_row.m_object_schema_length= 0;
+ m_row.m_object_name_length= 0;
+ m_row.m_index_name_length= 0;
+}
+
+int table_events_waits_common::make_table_object_columns(PFS_events_waits *wait)
+{
+ uint safe_index;
+ PFS_table_share *safe_table_share;
+
+ safe_table_share= sanitize_table_share(wait->m_weak_table_share);
+ if (unlikely(safe_table_share == NULL))
+ return 1;
+
+ if (wait->m_object_type == OBJECT_TYPE_TABLE)
+ {
+ m_row.m_object_type= "TABLE";
+ m_row.m_object_type_length= 5;
+ }
+ else
+ {
+ m_row.m_object_type= "TEMPORARY TABLE";
+ m_row.m_object_type_length= 15;
+ }
+
+ if (safe_table_share->get_version() == wait->m_weak_version)
+ {
+ /* OBJECT SCHEMA */
+ m_row.m_object_schema_length= safe_table_share->m_schema_name_length;
+ if (unlikely((m_row.m_object_schema_length == 0) ||
+ (m_row.m_object_schema_length > sizeof(m_row.m_object_schema))))
+ return 1;
+ memcpy(m_row.m_object_schema, safe_table_share->m_schema_name, m_row.m_object_schema_length);
+
+ /* OBJECT NAME */
+ m_row.m_object_name_length= safe_table_share->m_table_name_length;
+ if (unlikely((m_row.m_object_name_length == 0) ||
+ (m_row.m_object_name_length > sizeof(m_row.m_object_name))))
+ return 1;
+ memcpy(m_row.m_object_name, safe_table_share->m_table_name, m_row.m_object_name_length);
+
+ /* INDEX NAME */
+ safe_index= wait->m_index;
+ uint safe_key_count= sanitize_index_count(safe_table_share->m_key_count);
+ if (safe_index < safe_key_count)
+ {
+ PFS_table_share_index *index_stat;
+ index_stat= safe_table_share->find_index_stat(safe_index);
+
+ if (index_stat != NULL)
+ {
+ m_row.m_index_name_length= index_stat->m_key.m_name_length;
+
+ if (unlikely((m_row.m_index_name_length == 0) ||
+ (m_row.m_index_name_length > sizeof(m_row.m_index_name))))
+ return 1;
+
+ memcpy(m_row.m_index_name, index_stat->m_key.m_name, m_row.m_index_name_length);
+ }
+ else
+ {
+ m_row.m_index_name_length= 0;
+ }
+ }
+ else
+ {
+ m_row.m_index_name_length= 0;
+ }
+ }
+ else
+ {
+ m_row.m_object_schema_length= 0;
+ m_row.m_object_name_length= 0;
+ m_row.m_index_name_length= 0;
+ }
+
+ m_row.m_object_instance_addr= (intptr) wait->m_object_instance_addr;
+ return 0;
+}
+
+int table_events_waits_common::make_file_object_columns(PFS_events_waits *wait)
+{
+ PFS_file *safe_file;
+
+ safe_file= sanitize_file(wait->m_weak_file);
+ if (unlikely(safe_file == NULL))
+ return 1;
+
+ m_row.m_object_type= "FILE";
+ m_row.m_object_type_length= 4;
+ m_row.m_object_schema_length= 0;
+ m_row.m_object_instance_addr= (intptr) wait->m_object_instance_addr;
+
+ if (safe_file->get_version() == wait->m_weak_version)
+ {
+ /* OBJECT NAME */
+ m_row.m_object_name_length= safe_file->m_filename_length;
+ if (unlikely((m_row.m_object_name_length == 0) ||
+ (m_row.m_object_name_length > sizeof(m_row.m_object_name))))
+ return 1;
+ memcpy(m_row.m_object_name, safe_file->m_filename, m_row.m_object_name_length);
+ }
+ else
+ {
+ m_row.m_object_name_length= 0;
+ }
+
+ m_row.m_index_name_length= 0;
+
+ return 0;
+}
+
+int table_events_waits_common::make_socket_object_columns(PFS_events_waits *wait)
+{
+ PFS_socket *safe_socket;
+
+ safe_socket= sanitize_socket(wait->m_weak_socket);
+ if (unlikely(safe_socket == NULL))
+ return 1;
+
+ m_row.m_object_type= "SOCKET";
+ m_row.m_object_type_length= 6;
+ m_row.m_object_schema_length= 0;
+ m_row.m_object_instance_addr= (intptr) wait->m_object_instance_addr;
+
+ if (safe_socket->get_version() == wait->m_weak_version)
+ {
+ /* Convert port number to string, include delimiter in port name length */
+
+ uint port;
+ char port_str[128];
+ char ip_str[INET6_ADDRSTRLEN+1];
+ /*
+ "ip_length" was "ip_len" originally.
+ but it conflicted with some macro on AIX. Renamed.
+ */
+ uint ip_length= 0;
+ port_str[0]= ':';
+
+ /* Get the IP address and port number */
+ ip_length= pfs_get_socket_address(ip_str, sizeof(ip_str), &port,
+ &safe_socket->m_sock_addr,
+ safe_socket->m_addr_len);
+
+ /* Convert port number to a string (length includes ':') */
+ size_t port_len= int10_to_str(port, (port_str+1), 10) - port_str + 1;
+
+ /* OBJECT NAME */
+ m_row.m_object_name_length= ip_length + static_cast<uint>(port_len);
+
+ if (unlikely((m_row.m_object_name_length == 0) ||
+ (m_row.m_object_name_length > sizeof(m_row.m_object_name))))
+ return 1;
+
+ char *name= m_row.m_object_name;
+ memcpy(name, ip_str, ip_length);
+ memcpy(name + ip_length, port_str, port_len);
+ }
+ else
+ {
+ m_row.m_object_name_length= 0;
+ }
+
+ m_row.m_index_name_length= 0;
+
+ return 0;
+}
+
+int table_events_waits_common::make_metadata_lock_object_columns(PFS_events_waits *wait)
+{
+ PFS_metadata_lock *safe_metadata_lock;
+
+ safe_metadata_lock= sanitize_metadata_lock(wait->m_weak_metadata_lock);
+ if (unlikely(safe_metadata_lock == NULL))
+ return 1;
+
+ if (safe_metadata_lock->get_version() == wait->m_weak_version)
+ {
+ MDL_key *mdl= & safe_metadata_lock->m_mdl_key;
+ MDL_key user_lock_workaround;
+
+ switch(mdl->mdl_namespace())
+ {
+ case MDL_key::BACKUP:
+ m_row.m_object_type= "BACKUP";
+ m_row.m_object_type_length= 6;
+ m_row.m_object_schema_length= 0;
+ m_row.m_object_name_length= 0;
+ break;
+ case MDL_key::SCHEMA:
+ m_row.m_object_type= "SCHEMA";
+ m_row.m_object_type_length= 6;
+ m_row.m_object_schema_length= mdl->db_name_length();
+ m_row.m_object_name_length= 0;
+ break;
+ case MDL_key::TABLE:
+ m_row.m_object_type= "TABLE";
+ m_row.m_object_type_length= 5;
+ m_row.m_object_schema_length= mdl->db_name_length();
+ m_row.m_object_name_length= mdl->name_length();
+ break;
+ case MDL_key::FUNCTION:
+ m_row.m_object_type= "FUNCTION";
+ m_row.m_object_type_length= 8;
+ m_row.m_object_schema_length= mdl->db_name_length();
+ m_row.m_object_name_length= mdl->name_length();
+ break;
+ case MDL_key::PROCEDURE:
+ m_row.m_object_type= "PROCEDURE";
+ m_row.m_object_type_length= 9;
+ m_row.m_object_schema_length= mdl->db_name_length();
+ m_row.m_object_name_length= mdl->name_length();
+ break;
+ case MDL_key::PACKAGE_BODY:
+ m_row.m_object_type= "PACKAGE_BODY";
+ m_row.m_object_type_length= 12;
+ m_row.m_object_schema_length= mdl->db_name_length();
+ m_row.m_object_name_length= mdl->name_length();
+ break;
+ case MDL_key::TRIGGER:
+ m_row.m_object_type= "TRIGGER";
+ m_row.m_object_type_length= 7;
+ m_row.m_object_schema_length= mdl->db_name_length();
+ m_row.m_object_name_length= mdl->name_length();
+ break;
+ case MDL_key::EVENT:
+ m_row.m_object_type= "EVENT";
+ m_row.m_object_type_length= 5;
+ m_row.m_object_schema_length= mdl->db_name_length();
+ m_row.m_object_name_length= mdl->name_length();
+ break;
+ case MDL_key::USER_LOCK:
+ m_row.m_object_type= "USER LEVEL LOCK";
+ m_row.m_object_type_length= 15;
+ user_lock_workaround.mdl_key_init(MDL_key::USER_LOCK, "", mdl->db_name());
+ mdl=& user_lock_workaround;
+ m_row.m_object_schema_length= 0;
+ m_row.m_object_name_length= mdl->name_length();
+ break;
+ case MDL_key::NAMESPACE_END:
+ default:
+ m_row.m_object_type_length= 0;
+ m_row.m_object_schema_length= 0;
+ m_row.m_object_name_length= 0;
+ break;
+ }
+
+ if (m_row.m_object_schema_length > sizeof(m_row.m_object_schema))
+ return 1;
+ if (m_row.m_object_schema_length > 0)
+ memcpy(m_row.m_object_schema, mdl->db_name(), m_row.m_object_schema_length);
+
+ if (m_row.m_object_name_length > sizeof(m_row.m_object_name))
+ return 1;
+ if (m_row.m_object_name_length > 0)
+ memcpy(m_row.m_object_name, mdl->name(), m_row.m_object_name_length);
+
+ m_row.m_object_instance_addr= (intptr) wait->m_object_instance_addr;
+ }
+ else
+ {
+ m_row.m_object_type_length= 0;
+ m_row.m_object_schema_length= 0;
+ m_row.m_object_name_length= 0;
+ m_row.m_object_instance_addr= 0;
+ }
+
+ /* INDEX NAME */
+ m_row.m_index_name_length= 0;
+
+ return 0;
+}
+
+/**
+ Build a row.
+ @param wait the wait the cursor is reading
+*/
+void table_events_waits_common::make_row(PFS_events_waits *wait)
+{
+ PFS_instr_class *safe_class;
+ enum_timer_name timer_name= wait_timer;
+ ulonglong timer_end;
+
+ m_row_exists= false;
+
+ /*
+ Design choice:
+ We could have used a pfs_lock in PFS_events_waits here,
+ to protect the reader from concurrent event generation,
+ but this leads to too many pfs_lock atomic operations
+ each time an event is recorded:
+ - 1 dirty() + 1 allocated() per event start, for EVENTS_WAITS_CURRENT
+ - 1 dirty() + 1 allocated() per event end, for EVENTS_WAITS_CURRENT
+ - 1 dirty() + 1 allocated() per copy to EVENTS_WAITS_HISTORY
+ - 1 dirty() + 1 allocated() per copy to EVENTS_WAITS_HISTORY_LONG
+ or 8 atomics per recorded event.
+ The problem is that we record a *lot* of events ...
+
+ This code is prepared to accept *dirty* records,
+ and sanitizes all the data before returning a row.
+ */
+
+ /*
+ PFS_events_waits::m_class needs to be sanitized,
+ for race conditions when this code:
+ - reads a new value in m_wait_class,
+ - reads an old value in m_class.
+ */
+ switch (wait->m_wait_class)
+ {
+ case WAIT_CLASS_METADATA:
+ if (make_metadata_lock_object_columns(wait))
+ return;
+ safe_class= sanitize_metadata_class(wait->m_class);
+ break;
+ case WAIT_CLASS_IDLE:
+ clear_object_columns();
+ m_row.m_object_instance_addr= 0;
+ safe_class= sanitize_idle_class(wait->m_class);
+ timer_name= idle_timer;
+ break;
+ case WAIT_CLASS_MUTEX:
+ clear_object_columns();
+ m_row.m_object_instance_addr= (intptr) wait->m_object_instance_addr;
+ safe_class= sanitize_mutex_class((PFS_mutex_class*) wait->m_class);
+ break;
+ case WAIT_CLASS_RWLOCK:
+ clear_object_columns();
+ m_row.m_object_instance_addr= (intptr) wait->m_object_instance_addr;
+ safe_class= sanitize_rwlock_class((PFS_rwlock_class*) wait->m_class);
+ break;
+ case WAIT_CLASS_COND:
+ clear_object_columns();
+ m_row.m_object_instance_addr= (intptr) wait->m_object_instance_addr;
+ safe_class= sanitize_cond_class((PFS_cond_class*) wait->m_class);
+ break;
+ case WAIT_CLASS_TABLE:
+ if (make_table_object_columns(wait))
+ return;
+ safe_class= sanitize_table_class(wait->m_class);
+ break;
+ case WAIT_CLASS_FILE:
+ if (make_file_object_columns(wait))
+ return;
+ safe_class= sanitize_file_class((PFS_file_class*) wait->m_class);
+ break;
+ case WAIT_CLASS_SOCKET:
+ if (make_socket_object_columns(wait))
+ return;
+ safe_class= sanitize_socket_class((PFS_socket_class*) wait->m_class);
+ break;
+ case NO_WAIT_CLASS:
+ default:
+ return;
+ }
+
+ if (unlikely(safe_class == NULL))
+ return;
+
+ m_row.m_thread_internal_id= wait->m_thread_internal_id;
+ m_row.m_event_id= wait->m_event_id;
+ m_row.m_end_event_id= wait->m_end_event_id;
+ m_row.m_nesting_event_id= wait->m_nesting_event_id;
+ m_row.m_nesting_event_type= wait->m_nesting_event_type;
+
+ get_normalizer(safe_class);
+
+ if (m_row.m_end_event_id == 0)
+ {
+ timer_end= get_timer_raw_value(timer_name);
+ }
+ else
+ {
+ timer_end= wait->m_timer_end;
+ }
+
+ m_normalizer->to_pico(wait->m_timer_start, timer_end,
+ & m_row.m_timer_start, & m_row.m_timer_end, & m_row.m_timer_wait);
+
+ m_row.m_name= safe_class->m_name;
+ m_row.m_name_length= safe_class->m_name_length;
+
+ /* Disable source file and line to avoid stale __FILE__ pointers. */
+ m_row.m_source_length= 0;
+
+ m_row.m_operation= wait->m_operation;
+ m_row.m_number_of_bytes= wait->m_number_of_bytes;
+ m_row.m_flags= wait->m_flags;
+
+ m_row_exists= true;
+}
+
+/**
+ Operations names map, as displayed in the 'OPERATION' column.
+ Indexed by enum_operation_type - 1.
+ Note: enum_operation_type contains a more precise definition,
+ since more details are needed internally by the instrumentation.
+ Different similar operations (CLOSE vs STREAMCLOSE) are displayed
+ with the same name 'close'.
+*/
+static const LEX_STRING operation_names_map[]=
+{
+ /* Mutex operations */
+ { C_STRING_WITH_LEN("lock") },
+ { C_STRING_WITH_LEN("try_lock") },
+
+ /* RWLock operations (RW-lock) */
+ { C_STRING_WITH_LEN("read_lock") },
+ { C_STRING_WITH_LEN("write_lock") },
+ { C_STRING_WITH_LEN("try_read_lock") },
+ { C_STRING_WITH_LEN("try_write_lock") },
+
+ /* RWLock operations (SX-lock) */
+ { C_STRING_WITH_LEN("shared_lock") },
+ { C_STRING_WITH_LEN("shared_exclusive_lock") },
+ { C_STRING_WITH_LEN("exclusive_lock") },
+ { C_STRING_WITH_LEN("try_shared_lock") },
+ { C_STRING_WITH_LEN("try_shared_exclusive_lock") },
+ { C_STRING_WITH_LEN("try_exclusive_lock") },
+
+ /* Condition operations */
+ { C_STRING_WITH_LEN("wait") },
+ { C_STRING_WITH_LEN("timed_wait") },
+
+ /* File operations */
+ { C_STRING_WITH_LEN("create") },
+ { C_STRING_WITH_LEN("create") }, /* create tmp */
+ { C_STRING_WITH_LEN("open") },
+ { C_STRING_WITH_LEN("open") }, /* stream open */
+ { C_STRING_WITH_LEN("close") },
+ { C_STRING_WITH_LEN("close") }, /* stream close */
+ { C_STRING_WITH_LEN("read") },
+ { C_STRING_WITH_LEN("write") },
+ { C_STRING_WITH_LEN("seek") },
+ { C_STRING_WITH_LEN("tell") },
+ { C_STRING_WITH_LEN("flush") },
+ { C_STRING_WITH_LEN("stat") },
+ { C_STRING_WITH_LEN("stat") }, /* fstat */
+ { C_STRING_WITH_LEN("chsize") },
+ { C_STRING_WITH_LEN("delete") },
+ { C_STRING_WITH_LEN("rename") },
+ { C_STRING_WITH_LEN("sync") },
+
+ /* Table io operations */
+ { C_STRING_WITH_LEN("fetch") },
+ { C_STRING_WITH_LEN("insert") }, /* write row */
+ { C_STRING_WITH_LEN("update") }, /* update row */
+ { C_STRING_WITH_LEN("delete") }, /* delete row */
+
+ /* Table lock operations */
+ { C_STRING_WITH_LEN("read normal") },
+ { C_STRING_WITH_LEN("read with shared locks") },
+ { C_STRING_WITH_LEN("read high priority") },
+ { C_STRING_WITH_LEN("read no inserts") },
+ { C_STRING_WITH_LEN("write allow write") },
+ { C_STRING_WITH_LEN("write concurrent insert") },
+ { C_STRING_WITH_LEN("write delayed") },
+ { C_STRING_WITH_LEN("write low priority") },
+ { C_STRING_WITH_LEN("write normal") },
+ { C_STRING_WITH_LEN("read external") },
+ { C_STRING_WITH_LEN("write external") },
+
+ /* Socket operations */
+ { C_STRING_WITH_LEN("create") },
+ { C_STRING_WITH_LEN("connect") },
+ { C_STRING_WITH_LEN("bind") },
+ { C_STRING_WITH_LEN("close") },
+ { C_STRING_WITH_LEN("send") },
+ { C_STRING_WITH_LEN("recv") },
+ { C_STRING_WITH_LEN("sendto") },
+ { C_STRING_WITH_LEN("recvfrom") },
+ { C_STRING_WITH_LEN("sendmsg") },
+ { C_STRING_WITH_LEN("recvmsg") },
+ { C_STRING_WITH_LEN("seek") },
+ { C_STRING_WITH_LEN("opt") },
+ { C_STRING_WITH_LEN("stat") },
+ { C_STRING_WITH_LEN("shutdown") },
+ { C_STRING_WITH_LEN("select") },
+
+ /* Idle operations */
+ { C_STRING_WITH_LEN("idle") },
+
+ /* Medatada lock operations */
+ { C_STRING_WITH_LEN("metadata lock") }
+};
+
+
+int table_events_waits_common::read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+ const LEX_STRING *operation;
+
+ compile_time_assert(COUNT_OPERATION_TYPE ==
+ array_elements(operation_names_map));
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 2);
+ buf[0]= 0;
+ buf[1]= 0;
+
+ /*
+ Some columns are unreliable, because they are joined with other buffers,
+ which could have changed and been reused for something else.
+ These columns are:
+ - THREAD_ID (m_thread joins with PFS_thread),
+ - SCHEMA_NAME (m_schema_name joins with PFS_table_share)
+ - OBJECT_NAME (m_object_name joins with PFS_table_share)
+ */
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* THREAD_ID */
+ set_field_ulonglong(f, m_row.m_thread_internal_id);
+ break;
+ case 1: /* EVENT_ID */
+ set_field_ulonglong(f, m_row.m_event_id);
+ break;
+ case 2: /* END_EVENT_ID */
+ if (m_row.m_end_event_id > 0)
+ set_field_ulonglong(f, m_row.m_end_event_id - 1);
+ else
+ f->set_null();
+ break;
+ case 3: /* EVENT_NAME */
+ set_field_varchar_utf8(f, m_row.m_name, m_row.m_name_length);
+ break;
+ case 4: /* SOURCE */
+ set_field_varchar_utf8(f, m_row.m_source, m_row.m_source_length);
+ break;
+ case 5: /* TIMER_START */
+ if (m_row.m_timer_start != 0)
+ set_field_ulonglong(f, m_row.m_timer_start);
+ else
+ f->set_null();
+ break;
+ case 6: /* TIMER_END */
+ if (m_row.m_timer_end != 0)
+ set_field_ulonglong(f, m_row.m_timer_end);
+ else
+ f->set_null();
+ break;
+ case 7: /* TIMER_WAIT */
+ if (m_row.m_timer_wait != 0)
+ set_field_ulonglong(f, m_row.m_timer_wait);
+ else
+ f->set_null();
+ break;
+ case 8: /* SPINS */
+ f->set_null();
+ break;
+ case 9: /* OBJECT_SCHEMA */
+ if (m_row.m_object_schema_length > 0)
+ {
+ set_field_varchar_utf8(f, m_row.m_object_schema,
+ m_row.m_object_schema_length);
+ }
+ else
+ f->set_null();
+ break;
+ case 10: /* OBJECT_NAME */
+ if (m_row.m_object_name_length > 0)
+ {
+ set_field_varchar_utf8(f, m_row.m_object_name,
+ m_row.m_object_name_length);
+ }
+ else
+ f->set_null();
+ break;
+ case 11: /* INDEX_NAME */
+ if (m_row.m_index_name_length > 0)
+ {
+ set_field_varchar_utf8(f, m_row.m_index_name,
+ m_row.m_index_name_length);
+ }
+ else
+ f->set_null();
+ break;
+ case 12: /* OBJECT_TYPE */
+ if (m_row.m_object_type_length > 0)
+ {
+ set_field_varchar_utf8(f, m_row.m_object_type,
+ m_row.m_object_type_length);
+ }
+ else
+ f->set_null();
+ break;
+ case 13: /* OBJECT_INSTANCE */
+ set_field_ulonglong(f, m_row.m_object_instance_addr);
+ break;
+ case 14: /* NESTING_EVENT_ID */
+ if (m_row.m_nesting_event_id != 0)
+ set_field_ulonglong(f, m_row.m_nesting_event_id);
+ else
+ f->set_null();
+ break;
+ case 15: /* NESTING_EVENT_TYPE */
+ if (m_row.m_nesting_event_id != 0)
+ set_field_enum(f, m_row.m_nesting_event_type);
+ else
+ f->set_null();
+ break;
+ case 16: /* OPERATION */
+ operation= &operation_names_map[(int) m_row.m_operation - 1];
+ set_field_varchar_utf8(f, operation->str, (uint)operation->length);
+ break;
+ case 17: /* NUMBER_OF_BYTES (also used for ROWS) */
+ if ((m_row.m_operation == OPERATION_TYPE_FILEREAD) ||
+ (m_row.m_operation == OPERATION_TYPE_FILEWRITE) ||
+ (m_row.m_operation == OPERATION_TYPE_FILECHSIZE) ||
+ (m_row.m_operation == OPERATION_TYPE_SOCKETSEND) ||
+ (m_row.m_operation == OPERATION_TYPE_SOCKETRECV) ||
+ (m_row.m_operation == OPERATION_TYPE_SOCKETSENDTO) ||
+ (m_row.m_operation == OPERATION_TYPE_SOCKETRECVFROM) ||
+ (m_row.m_operation == OPERATION_TYPE_TABLE_FETCH) ||
+ (m_row.m_operation == OPERATION_TYPE_TABLE_WRITE_ROW) ||
+ (m_row.m_operation == OPERATION_TYPE_TABLE_UPDATE_ROW) ||
+ (m_row.m_operation == OPERATION_TYPE_TABLE_DELETE_ROW))
+ set_field_ulonglong(f, m_row.m_number_of_bytes);
+ else
+ f->set_null();
+ break;
+ case 18: /* FLAGS */
+ f->set_null();
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+ return 0;
+}
+
+PFS_engine_table* table_events_waits_current::create(void)
+{
+ return new table_events_waits_current();
+}
+
+table_events_waits_current::table_events_waits_current()
+ : table_events_waits_common(&m_share, &m_pos),
+ m_pos(), m_next_pos()
+{}
+
+void table_events_waits_current::reset_position(void)
+{
+ m_pos.reset();
+ m_next_pos.reset();
+}
+
+int table_events_waits_current::rnd_next(void)
+{
+ PFS_thread *pfs_thread;
+ PFS_events_waits *wait;
+ bool has_more_thread= true;
+
+ for (m_pos.set_at(&m_next_pos);
+ has_more_thread;
+ m_pos.next_thread())
+ {
+ pfs_thread= global_thread_container.get(m_pos.m_index_1, & has_more_thread);
+ if (pfs_thread != NULL)
+ {
+ /*
+ We do not show nested events for now,
+ this will be revised with TABLE io
+ */
+// #define ONLY_SHOW_ONE_WAIT
+
+#ifdef ONLY_SHOW_ONE_WAIT
+ if (m_pos.m_index_2 >= 1)
+ continue;
+#else
+ /* m_events_waits_stack[0] is a dummy record */
+ PFS_events_waits *top_wait = &pfs_thread->m_events_waits_stack[WAIT_STACK_BOTTOM];
+ wait= &pfs_thread->m_events_waits_stack[m_pos.m_index_2 + WAIT_STACK_BOTTOM];
+
+ PFS_events_waits *safe_current = pfs_thread->m_events_waits_current;
+
+ if (safe_current == top_wait)
+ {
+ /* Display the last top level wait, when completed */
+ if (m_pos.m_index_2 >= 1)
+ continue;
+ }
+ else
+ {
+ /* Display all pending waits, when in progress */
+ if (wait >= safe_current)
+ continue;
+ }
+#endif
+
+ if (wait->m_wait_class == NO_WAIT_CLASS)
+ {
+ /*
+ This locker does not exist.
+ There can not be more lockers in the stack, skip to the next thread
+ */
+ continue;
+ }
+
+ make_row(pfs_thread, wait);
+ /* Next iteration, look for the next locker in this thread */
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int table_events_waits_current::rnd_pos(const void *pos)
+{
+ PFS_thread *pfs_thread;
+ PFS_events_waits *wait;
+
+ set_position(pos);
+
+ pfs_thread= global_thread_container.get(m_pos.m_index_1);
+ if (pfs_thread != NULL)
+ {
+#ifdef ONLY_SHOW_ONE_WAIT
+ if (m_pos.m_index_2 >= 1)
+ return HA_ERR_RECORD_DELETED;
+#else
+ /* m_events_waits_stack[0] is a dummy record */
+ PFS_events_waits *top_wait = &pfs_thread->m_events_waits_stack[WAIT_STACK_BOTTOM];
+ wait= &pfs_thread->m_events_waits_stack[m_pos.m_index_2 + WAIT_STACK_BOTTOM];
+
+ PFS_events_waits *safe_current = pfs_thread->m_events_waits_current;
+
+ if (safe_current == top_wait)
+ {
+ /* Display the last top level wait, when completed */
+ if (m_pos.m_index_2 >= 1)
+ return HA_ERR_RECORD_DELETED;
+ }
+ else
+ {
+ /* Display all pending waits, when in progress */
+ if (wait >= safe_current)
+ return HA_ERR_RECORD_DELETED;
+ }
+#endif
+
+ DBUG_ASSERT(m_pos.m_index_2 < WAIT_STACK_LOGICAL_SIZE);
+
+ if (wait->m_wait_class != NO_WAIT_CLASS)
+ {
+ make_row(pfs_thread, wait);
+ return 0;
+ }
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_events_waits_current::make_row(PFS_thread *thread, PFS_events_waits *wait)
+{
+ pfs_optimistic_state lock;
+
+ /* Protect this reader against a thread termination */
+ thread->m_lock.begin_optimistic_lock(&lock);
+
+ table_events_waits_common::make_row(wait);
+
+ if (! thread->m_lock.end_optimistic_lock(&lock))
+ m_row_exists= false;
+}
+
+int table_events_waits_current::delete_all_rows(void)
+{
+ reset_events_waits_current();
+ return 0;
+}
+
+ha_rows
+table_events_waits_current::get_row_count(void)
+{
+ return WAIT_STACK_SIZE * global_thread_container.get_row_count();
+}
+
+PFS_engine_table* table_events_waits_history::create(void)
+{
+ return new table_events_waits_history();
+}
+
+table_events_waits_history::table_events_waits_history()
+ : table_events_waits_common(&m_share, &m_pos),
+ m_pos(), m_next_pos()
+{}
+
+void table_events_waits_history::reset_position(void)
+{
+ m_pos.reset();
+ m_next_pos.reset();
+}
+
+int table_events_waits_history::rnd_next(void)
+{
+ PFS_thread *pfs_thread;
+ PFS_events_waits *wait;
+ bool has_more_thread= true;
+
+ if (events_waits_history_per_thread == 0)
+ return HA_ERR_END_OF_FILE;
+
+ for (m_pos.set_at(&m_next_pos);
+ has_more_thread;
+ m_pos.next_thread())
+ {
+ pfs_thread= global_thread_container.get(m_pos.m_index_1, & has_more_thread);
+ if (pfs_thread != NULL)
+ {
+ if (m_pos.m_index_2 >= events_waits_history_per_thread)
+ {
+ /* This thread does not have more (full) history */
+ continue;
+ }
+
+ if ( ! pfs_thread->m_waits_history_full &&
+ (m_pos.m_index_2 >= pfs_thread->m_waits_history_index))
+ {
+ /* This thread does not have more (not full) history */
+ continue;
+ }
+
+ wait= &pfs_thread->m_waits_history[m_pos.m_index_2];
+ if (wait->m_wait_class != NO_WAIT_CLASS)
+ {
+ make_row(pfs_thread, wait);
+ /* Next iteration, look for the next history in this thread */
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int table_events_waits_history::rnd_pos(const void *pos)
+{
+ PFS_thread *pfs_thread;
+ PFS_events_waits *wait;
+
+ DBUG_ASSERT(events_waits_history_per_thread != 0);
+ set_position(pos);
+
+ pfs_thread= global_thread_container.get(m_pos.m_index_1);
+ if (pfs_thread != NULL)
+ {
+ DBUG_ASSERT(m_pos.m_index_2 < events_waits_history_per_thread);
+
+ if ( ! pfs_thread->m_waits_history_full &&
+ (m_pos.m_index_2 >= pfs_thread->m_waits_history_index))
+ return HA_ERR_RECORD_DELETED;
+
+ wait= &pfs_thread->m_waits_history[m_pos.m_index_2];
+
+ if (wait->m_wait_class != NO_WAIT_CLASS)
+ {
+ make_row(pfs_thread, wait);
+ return 0;
+ }
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_events_waits_history::make_row(PFS_thread *thread, PFS_events_waits *wait)
+{
+ pfs_optimistic_state lock;
+
+ /* Protect this reader against a thread termination */
+ thread->m_lock.begin_optimistic_lock(&lock);
+
+ table_events_waits_common::make_row(wait);
+
+ if (! thread->m_lock.end_optimistic_lock(&lock))
+ m_row_exists= false;
+}
+
+int table_events_waits_history::delete_all_rows(void)
+{
+ reset_events_waits_history();
+ return 0;
+}
+
+ha_rows
+table_events_waits_history::get_row_count(void)
+{
+ return events_waits_history_per_thread * global_thread_container.get_row_count();
+}
+
+PFS_engine_table* table_events_waits_history_long::create(void)
+{
+ return new table_events_waits_history_long();
+}
+
+table_events_waits_history_long::table_events_waits_history_long()
+ : table_events_waits_common(&m_share, &m_pos),
+ m_pos(0), m_next_pos(0)
+{}
+
+void table_events_waits_history_long::reset_position(void)
+{
+ m_pos.m_index= 0;
+ m_next_pos.m_index= 0;
+}
+
+int table_events_waits_history_long::rnd_next(void)
+{
+ PFS_events_waits *wait;
+ uint limit;
+
+ if (events_waits_history_long_size == 0)
+ return HA_ERR_END_OF_FILE;
+
+ if (events_waits_history_long_full)
+ limit= events_waits_history_long_size;
+ else
+ limit= events_waits_history_long_index.m_u32 % events_waits_history_long_size;
+
+ for (m_pos.set_at(&m_next_pos); m_pos.m_index < limit; m_pos.next())
+ {
+ wait= &events_waits_history_long_array[m_pos.m_index];
+
+ if (wait->m_wait_class != NO_WAIT_CLASS)
+ {
+ make_row(wait);
+ /* Next iteration, look for the next entry */
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int table_events_waits_history_long::rnd_pos(const void *pos)
+{
+ PFS_events_waits *wait;
+ uint limit;
+
+ if (events_waits_history_long_size == 0)
+ return HA_ERR_RECORD_DELETED;
+
+ set_position(pos);
+
+ if (events_waits_history_long_full)
+ limit= events_waits_history_long_size;
+ else
+ limit= events_waits_history_long_index.m_u32 % events_waits_history_long_size;
+
+ if (m_pos.m_index >= limit)
+ return HA_ERR_RECORD_DELETED;
+
+ wait= &events_waits_history_long_array[m_pos.m_index];
+
+ if (wait->m_wait_class == NO_WAIT_CLASS)
+ return HA_ERR_RECORD_DELETED;
+
+ make_row(wait);
+ return 0;
+}
+
+int table_events_waits_history_long::delete_all_rows(void)
+{
+ reset_events_waits_history_long();
+ return 0;
+}
+
+ha_rows
+table_events_waits_history_long::get_row_count(void)
+{
+ return events_waits_history_long_size;
+}
+
diff --git a/storage/perfschema/table_events_waits.h b/storage/perfschema/table_events_waits.h
new file mode 100644
index 00000000..9173ec30
--- /dev/null
+++ b/storage/perfschema/table_events_waits.h
@@ -0,0 +1,267 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_EVENTS_WAITS_H
+#define TABLE_EVENTS_WAITS_H
+
+/**
+ @file storage/perfschema/table_events_waits.h
+ Table EVENTS_WAITS_xxx (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_events_waits.h"
+
+struct PFS_thread;
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/** A row of table_events_waits_common. */
+struct row_events_waits
+{
+ /** Column THREAD_ID. */
+ ulonglong m_thread_internal_id;
+ /** Column EVENT_ID. */
+ ulonglong m_event_id;
+ /** Column END_EVENT_ID. */
+ ulonglong m_end_event_id;
+ /** Column NESTING_EVENT_ID. */
+ ulonglong m_nesting_event_id;
+ /** Column NESTING_EVENT_TYPE. */
+ enum_event_type m_nesting_event_type;
+ /** Column EVENT_NAME. */
+ const char *m_name;
+ /** Length in bytes of @c m_name. */
+ uint m_name_length;
+ /** Column TIMER_START. */
+ ulonglong m_timer_start;
+ /** Column TIMER_END. */
+ ulonglong m_timer_end;
+ /** Column TIMER_WAIT. */
+ ulonglong m_timer_wait;
+ /** Column OBJECT_TYPE. */
+ const char *m_object_type;
+ /** Length in bytes of @c m_object_type. */
+ uint m_object_type_length;
+ /** Column OBJECT_SCHEMA. */
+ char m_object_schema[COL_OBJECT_SCHEMA_SIZE];
+ /** Length in bytes of @c m_object_schema. */
+ uint m_object_schema_length;
+ /** Column OBJECT_NAME. */
+ char m_object_name[COL_OBJECT_NAME_EXTENDED_SIZE];
+ /** Length in bytes of @c m_object_name. */
+ uint m_object_name_length;
+ /** Column INDEX_NAME. */
+ char m_index_name[COL_INDEX_NAME_SIZE];
+ /** Length in bytes of @c m_index_name. */
+ uint m_index_name_length;
+ /** Column OBJECT_INSTANCE_BEGIN. */
+ intptr m_object_instance_addr;
+ /** Column SOURCE. */
+ char m_source[COL_SOURCE_SIZE];
+ /** Length in bytes of @c m_source. */
+ uint m_source_length;
+ /** Column OPERATION. */
+ enum_operation_type m_operation;
+ /** Column NUMBER_OF_BYTES. */
+ ulonglong m_number_of_bytes;
+ /** Column FLAGS. */
+ uint m_flags;
+};
+
+/** Position of a cursor on PERFORMANCE_SCHEMA.EVENTS_WAITS_CURRENT. */
+struct pos_events_waits_current : public PFS_double_index
+{
+ pos_events_waits_current()
+ : PFS_double_index(0, 0)
+ {}
+
+ inline void reset(void)
+ {
+ m_index_1= 0;
+ m_index_2= 0;
+ }
+
+ inline void next_thread(void)
+ {
+ m_index_1++;
+ m_index_2= 0;
+ }
+};
+
+/** Position of a cursor on PERFORMANCE_SCHEMA.EVENTS_WAITS_HISTORY. */
+struct pos_events_waits_history : public PFS_double_index
+{
+ pos_events_waits_history()
+ : PFS_double_index(0, 0)
+ {}
+
+ inline void reset(void)
+ {
+ m_index_1= 0;
+ m_index_2= 0;
+ }
+
+ inline void next_thread(void)
+ {
+ m_index_1++;
+ m_index_2= 0;
+ }
+};
+
+/**
+ Adapter, for table sharing the structure of
+ PERFORMANCE_SCHEMA.EVENTS_WAITS_CURRENT.
+*/
+class table_events_waits_common : public PFS_engine_table
+{
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_events_waits_common(const PFS_engine_table_share *share, void *pos);
+
+ ~table_events_waits_common()
+ {}
+
+ void clear_object_columns();
+ int make_table_object_columns(PFS_events_waits *wait);
+ int make_file_object_columns(PFS_events_waits *wait);
+ int make_socket_object_columns(PFS_events_waits *wait);
+ int make_metadata_lock_object_columns(PFS_events_waits *wait);
+
+ void make_row(PFS_events_waits *wait);
+
+ /** Current row. */
+ row_events_waits m_row;
+ /** True if the current row exists. */
+ bool m_row_exists;
+};
+
+/** Table PERFORMANCE_SCHEMA.EVENTS_WAITS_CURRENT. */
+class table_events_waits_current : public table_events_waits_common
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ table_events_waits_current();
+
+public:
+ ~table_events_waits_current()
+ {}
+
+private:
+ friend class table_events_waits_history;
+ friend class table_events_waits_history_long;
+
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ void make_row(PFS_thread *thread, PFS_events_waits *wait);
+
+ /** Current position. */
+ pos_events_waits_current m_pos;
+ /** Next position. */
+ pos_events_waits_current m_next_pos;
+};
+
+/** Table PERFORMANCE_SCHEMA.EVENTS_WAITS_HISTORY. */
+class table_events_waits_history : public table_events_waits_common
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ table_events_waits_history();
+
+public:
+ ~table_events_waits_history()
+ {}
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ void make_row(PFS_thread *thread, PFS_events_waits *wait);
+
+ /** Current position. */
+ pos_events_waits_history m_pos;
+ /** Next position. */
+ pos_events_waits_history m_next_pos;
+};
+
+/** Table PERFORMANCE_SCHEMA.EVENTS_WAITS_HISTORY_LONG. */
+class table_events_waits_history_long : public table_events_waits_common
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ table_events_waits_history_long();
+
+public:
+ ~table_events_waits_history_long()
+ {}
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ /** Current position. */
+ PFS_simple_index m_pos;
+ /** Next position. */
+ PFS_simple_index m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_events_waits_summary.cc b/storage/perfschema/table_events_waits_summary.cc
new file mode 100644
index 00000000..71ae6eae
--- /dev/null
+++ b/storage/perfschema/table_events_waits_summary.cc
@@ -0,0 +1,236 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_events_waits_summary.cc
+ Table EVENTS_WAITS_SUMMARY_BY_xxx (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "pfs_instr_class.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "table_events_waits_summary.h"
+#include "pfs_global.h"
+#include "field.h"
+
+THR_LOCK table_events_waits_summary_by_instance::m_table_lock;
+
+PFS_engine_table_share
+table_events_waits_summary_by_instance::m_share=
+{
+ { C_STRING_WITH_LEN("events_waits_summary_by_instance") },
+ &pfs_truncatable_acl,
+ table_events_waits_summary_by_instance::create,
+ NULL, /* write_row */
+ table_events_waits_summary_by_instance::delete_all_rows,
+ table_all_instr::get_row_count,
+ sizeof(pos_all_instr),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE events_waits_summary_by_instance("
+ "EVENT_NAME VARCHAR(128) not null,"
+ "OBJECT_INSTANCE_BEGIN BIGINT unsigned not null,"
+ "COUNT_STAR BIGINT unsigned not null,"
+ "SUM_TIMER_WAIT BIGINT unsigned not null,"
+ "MIN_TIMER_WAIT BIGINT unsigned not null,"
+ "AVG_TIMER_WAIT BIGINT unsigned not null,"
+ "MAX_TIMER_WAIT BIGINT unsigned not null)") },
+ false /* perpetual */
+};
+
+PFS_engine_table* table_events_waits_summary_by_instance::create(void)
+{
+ return new table_events_waits_summary_by_instance();
+}
+
+int table_events_waits_summary_by_instance::delete_all_rows(void)
+{
+ reset_events_waits_by_instance();
+ return 0;
+}
+
+table_events_waits_summary_by_instance
+::table_events_waits_summary_by_instance()
+ : table_all_instr(&m_share), m_row_exists(false)
+{}
+
+void table_events_waits_summary_by_instance
+::make_instr_row(PFS_instr *pfs, PFS_instr_class *klass,
+ const void *object_instance_begin,
+ PFS_single_stat *pfs_stat)
+{
+ pfs_optimistic_state lock;
+ m_row_exists= false;
+
+ /*
+ Protect this reader against a mutex/rwlock/cond destroy,
+ file delete, table drop.
+ */
+ pfs->m_lock.begin_optimistic_lock(&lock);
+
+ m_row.m_name= klass->m_name;
+ m_row.m_name_length= klass->m_name_length;
+ m_row.m_object_instance_addr= (intptr) object_instance_begin;
+
+ get_normalizer(klass);
+ m_row.m_stat.set(m_normalizer, pfs_stat);
+
+ if (pfs->m_lock.end_optimistic_lock(&lock))
+ m_row_exists= true;
+}
+
+/**
+ Build a row, for mutex statistics in a thread.
+ @param pfs the mutex this cursor is reading
+*/
+void table_events_waits_summary_by_instance::make_mutex_row(PFS_mutex *pfs)
+{
+ PFS_mutex_class *safe_class;
+ safe_class= sanitize_mutex_class(pfs->m_class);
+ if (unlikely(safe_class == NULL))
+ return;
+
+ make_instr_row(pfs, safe_class, pfs->m_identity, &pfs->m_mutex_stat.m_wait_stat);
+}
+
+/**
+ Build a row, for rwlock statistics in a thread.
+ @param pfs the rwlock this cursor is reading
+*/
+void table_events_waits_summary_by_instance::make_rwlock_row(PFS_rwlock *pfs)
+{
+ PFS_rwlock_class *safe_class;
+ safe_class= sanitize_rwlock_class(pfs->m_class);
+ if (unlikely(safe_class == NULL))
+ return;
+
+ make_instr_row(pfs, safe_class, pfs->m_identity, &pfs->m_rwlock_stat.m_wait_stat);
+}
+
+/**
+ Build a row, for condition statistics in a thread.
+ @param pfs the condition this cursor is reading
+*/
+void table_events_waits_summary_by_instance::make_cond_row(PFS_cond *pfs)
+{
+ PFS_cond_class *safe_class;
+ safe_class= sanitize_cond_class(pfs->m_class);
+ if (unlikely(safe_class == NULL))
+ return;
+
+ make_instr_row(pfs, safe_class, pfs->m_identity, &pfs->m_cond_stat.m_wait_stat);
+}
+
+/**
+ Build a row, for file statistics in a thread.
+ @param pfs the file this cursor is reading
+*/
+void table_events_waits_summary_by_instance::make_file_row(PFS_file *pfs)
+{
+ PFS_file_class *safe_class;
+ safe_class= sanitize_file_class(pfs->m_class);
+ if (unlikely(safe_class == NULL))
+ return;
+
+ PFS_single_stat sum;
+ pfs->m_file_stat.m_io_stat.sum_waits(& sum);
+ /*
+ Files don't have a in memory structure associated to it,
+ so we use the address of the PFS_file buffer as object_instance_begin
+ */
+ make_instr_row(pfs, safe_class, pfs, & sum);
+}
+
+/**
+ Build a row, for socket statistics in a thread.
+ @param pfs the socket this cursor is reading
+*/
+void table_events_waits_summary_by_instance::make_socket_row(PFS_socket *pfs)
+{
+ PFS_socket_class *safe_class;
+ safe_class= sanitize_socket_class(pfs->m_class);
+ if (unlikely(safe_class == NULL))
+ return;
+
+ /*
+ Consolidate wait times and byte counts for individual operations. This is
+ done by the consumer in order to reduce overhead on the socket instrument.
+ */
+ PFS_byte_stat pfs_stat;
+ pfs->m_socket_stat.m_io_stat.sum(&pfs_stat);
+
+ /*
+ Sockets don't have an associated in-memory structure, so use the address of
+ the PFS_socket buffer as object_instance_begin.
+ */
+ make_instr_row(pfs, safe_class, pfs, &pfs_stat);
+}
+
+int table_events_waits_summary_by_instance
+::read_row_values(TABLE *table, unsigned char *, Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 0);
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* NAME */
+ set_field_varchar_utf8(f, m_row.m_name, m_row.m_name_length);
+ break;
+ case 1: /* OBJECT_INSTANCE */
+ set_field_ulonglong(f, m_row.m_object_instance_addr);
+ break;
+ case 2: /* COUNT */
+ set_field_ulonglong(f, m_row.m_stat.m_count);
+ break;
+ case 3: /* SUM */
+ set_field_ulonglong(f, m_row.m_stat.m_sum);
+ break;
+ case 4: /* MIN */
+ set_field_ulonglong(f, m_row.m_stat.m_min);
+ break;
+ case 5: /* AVG */
+ set_field_ulonglong(f, m_row.m_stat.m_avg);
+ break;
+ case 6: /* MAX */
+ set_field_ulonglong(f, m_row.m_stat.m_max);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_events_waits_summary.h b/storage/perfschema/table_events_waits_summary.h
new file mode 100644
index 00000000..51d8a62e
--- /dev/null
+++ b/storage/perfschema/table_events_waits_summary.h
@@ -0,0 +1,97 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_EVENTS_WAITS_SUMMARY_H
+#define TABLE_EVENTS_WAITS_SUMMARY_H
+
+/**
+ @file storage/perfschema/table_events_waits_summary.h
+ Table EVENTS_WAITS_SUMMARY_BY_xxx (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "table_all_instr.h"
+#include "table_helper.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/** A row of PERFORMANCE_SCHEMA.EVENTS_WAITS_SUMMARY_BY_INSTANCE. */
+struct row_events_waits_summary_by_instance
+{
+ /** Column EVENT_NAME. */
+ const char *m_name;
+ /** Length in bytes of @c m_name. */
+ uint m_name_length;
+ /** Column OBJECT_INSTANCE_BEGIN. */
+ intptr m_object_instance_addr;
+ /** Columns COUNT_STAR, SUM/MIN/AVG/MAX TIMER_WAIT. */
+ PFS_stat_row m_stat;
+};
+
+/** Table PERFORMANCE_SCHEMA.EVENTS_WAITS_SUMMARY_BY_INSTANCE. */
+class table_events_waits_summary_by_instance : public table_all_instr
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+
+protected:
+ void make_instr_row(PFS_instr *pfs, PFS_instr_class *klass,
+ const void *object_instance_begin,
+ PFS_single_stat *pfs_stat);
+ virtual void make_mutex_row(PFS_mutex *pfs);
+ virtual void make_rwlock_row(PFS_rwlock *pfs);
+ virtual void make_cond_row(PFS_cond *pfs);
+ virtual void make_file_row(PFS_file *pfs);
+ virtual void make_socket_row(PFS_socket *pfs);
+
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_events_waits_summary_by_instance();
+
+public:
+ ~table_events_waits_summary_by_instance()
+ {}
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ /** Current row. */
+ row_events_waits_summary_by_instance m_row;
+ /** True if the current row exists. */
+ bool m_row_exists;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_ews_by_account_by_event_name.cc b/storage/perfschema/table_ews_by_account_by_event_name.cc
new file mode 100644
index 00000000..05c874ea
--- /dev/null
+++ b/storage/perfschema/table_ews_by_account_by_event_name.cc
@@ -0,0 +1,271 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_ews_by_account_by_event_name.cc
+ Table EVENTS_WAITS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "pfs_instr_class.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "table_ews_by_account_by_event_name.h"
+#include "pfs_global.h"
+#include "pfs_visitor.h"
+#include "pfs_buffer_container.h"
+#include "field.h"
+
+THR_LOCK table_ews_by_account_by_event_name::m_table_lock;
+
+PFS_engine_table_share
+table_ews_by_account_by_event_name::m_share=
+{
+ { C_STRING_WITH_LEN("events_waits_summary_by_account_by_event_name") },
+ &pfs_truncatable_acl,
+ table_ews_by_account_by_event_name::create,
+ NULL, /* write_row */
+ table_ews_by_account_by_event_name::delete_all_rows,
+ table_ews_by_account_by_event_name::get_row_count,
+ sizeof(pos_ews_by_account_by_event_name),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE events_waits_summary_by_account_by_event_name("
+ "USER CHAR(" USERNAME_CHAR_LENGTH_STR ") collate utf8_bin default null,"
+ "HOST CHAR(" HOSTNAME_LENGTH_STR ") collate utf8_bin default null,"
+ "EVENT_NAME VARCHAR(128) not null,"
+ "COUNT_STAR BIGINT unsigned not null,"
+ "SUM_TIMER_WAIT BIGINT unsigned not null,"
+ "MIN_TIMER_WAIT BIGINT unsigned not null,"
+ "AVG_TIMER_WAIT BIGINT unsigned not null,"
+ "MAX_TIMER_WAIT BIGINT unsigned not null)") },
+ false /* perpetual */
+};
+
+PFS_engine_table*
+table_ews_by_account_by_event_name::create(void)
+{
+ return new table_ews_by_account_by_event_name();
+}
+
+int
+table_ews_by_account_by_event_name::delete_all_rows(void)
+{
+ reset_events_waits_by_thread();
+ reset_events_waits_by_account();
+ return 0;
+}
+
+ha_rows
+table_ews_by_account_by_event_name::get_row_count(void)
+{
+ return global_account_container.get_row_count() * wait_class_max;
+}
+
+table_ews_by_account_by_event_name::table_ews_by_account_by_event_name()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(), m_next_pos()
+{}
+
+void table_ews_by_account_by_event_name::reset_position(void)
+{
+ m_pos.reset();
+ m_next_pos.reset();
+}
+
+int table_ews_by_account_by_event_name::rnd_next(void)
+{
+ PFS_account *account;
+ PFS_instr_class *instr_class;
+ bool has_more_account= true;
+
+ for (m_pos.set_at(&m_next_pos);
+ has_more_account;
+ m_pos.next_account())
+ {
+ account= global_account_container.get(m_pos.m_index_1, & has_more_account);
+ if (account != NULL)
+ {
+ for ( ;
+ m_pos.has_more_view();
+ m_pos.next_view())
+ {
+ switch (m_pos.m_index_2)
+ {
+ case pos_ews_by_account_by_event_name::VIEW_MUTEX:
+ instr_class= find_mutex_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_account_by_event_name::VIEW_RWLOCK:
+ instr_class= find_rwlock_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_account_by_event_name::VIEW_COND:
+ instr_class= find_cond_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_account_by_event_name::VIEW_FILE:
+ instr_class= find_file_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_account_by_event_name::VIEW_TABLE:
+ instr_class= find_table_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_account_by_event_name::VIEW_SOCKET:
+ instr_class= find_socket_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_account_by_event_name::VIEW_IDLE:
+ instr_class= find_idle_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_account_by_event_name::VIEW_METADATA:
+ instr_class= find_metadata_class(m_pos.m_index_3);
+ break;
+ default:
+ instr_class= NULL;
+ DBUG_ASSERT(false);
+ break;
+ }
+
+ if (instr_class)
+ {
+ make_row(account, instr_class);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+ }
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int
+table_ews_by_account_by_event_name::rnd_pos(const void *pos)
+{
+ PFS_account *account;
+ PFS_instr_class *instr_class;
+
+ set_position(pos);
+
+ account= global_account_container.get(m_pos.m_index_1);
+ if (account == NULL)
+ return HA_ERR_RECORD_DELETED;
+
+ switch (m_pos.m_index_2)
+ {
+ case pos_ews_by_account_by_event_name::VIEW_MUTEX:
+ instr_class= find_mutex_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_account_by_event_name::VIEW_RWLOCK:
+ instr_class= find_rwlock_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_account_by_event_name::VIEW_COND:
+ instr_class= find_cond_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_account_by_event_name::VIEW_FILE:
+ instr_class= find_file_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_account_by_event_name::VIEW_TABLE:
+ instr_class= find_table_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_account_by_event_name::VIEW_SOCKET:
+ instr_class= find_socket_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_account_by_event_name::VIEW_IDLE:
+ instr_class= find_idle_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_account_by_event_name::VIEW_METADATA:
+ instr_class= find_metadata_class(m_pos.m_index_3);
+ break;
+ default:
+ instr_class= NULL;
+ DBUG_ASSERT(false);
+ }
+ if (instr_class)
+ {
+ make_row(account, instr_class);
+ return 0;
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_ews_by_account_by_event_name
+::make_row(PFS_account *account, PFS_instr_class *klass)
+{
+ pfs_optimistic_state lock;
+ m_row_exists= false;
+
+ account->m_lock.begin_optimistic_lock(&lock);
+
+ if (m_row.m_account.make_row(account))
+ return;
+
+ m_row.m_event_name.make_row(klass);
+
+ PFS_connection_wait_visitor visitor(klass);
+ PFS_connection_iterator::visit_account(account,
+ true, /* threads */
+ false, /* THDs */
+ & visitor);
+
+ if (! account->m_lock.end_optimistic_lock(&lock))
+ return;
+
+ m_row_exists= true;
+
+ get_normalizer(klass);
+ m_row.m_stat.set(m_normalizer, & visitor.m_stat);
+}
+
+int table_ews_by_account_by_event_name
+::read_row_values(TABLE *table, unsigned char *buf, Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* USER */
+ case 1: /* HOST */
+ m_row.m_account.set_field(f->field_index, f);
+ break;
+ case 2: /* EVENT_NAME */
+ m_row.m_event_name.set_field(f);
+ break;
+ default: /* 3, ... COUNT/SUM/MIN/AVG/MAX */
+ m_row.m_stat.set_field(f->field_index - 3, f);
+ break;
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_ews_by_account_by_event_name.h b/storage/perfschema/table_ews_by_account_by_event_name.h
new file mode 100644
index 00000000..e64a61b2
--- /dev/null
+++ b/storage/perfschema/table_ews_by_account_by_event_name.h
@@ -0,0 +1,139 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_EWS_BY_ACCOUNT_BY_EVENT_NAME_H
+#define TABLE_EWS_BY_ACCOUNT_BY_EVENT_NAME_H
+
+/**
+ @file storage/perfschema/table_ews_by_account_by_event_name.h
+ Table EVENTS_WAITS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "pfs_account.h"
+#include "table_helper.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/**
+ A row of table
+ PERFORMANCE_SCHEMA.EVENTS_WAITS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME.
+*/
+struct row_ews_by_account_by_event_name
+{
+ /** Column USER, HOST. */
+ PFS_account_row m_account;
+ /** Column EVENT_NAME. */
+ PFS_event_name_row m_event_name;
+ /** Columns COUNT_STAR, SUM/MIN/AVG/MAX TIMER_WAIT. */
+ PFS_stat_row m_stat;
+};
+
+/**
+ Position of a cursor on
+ PERFORMANCE_SCHEMA.EVENTS_WAITS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME.
+ Index 1 on account (0 based)
+ Index 2 on instrument view
+ Index 3 on instrument class (1 based)
+*/
+struct pos_ews_by_account_by_event_name
+: public PFS_triple_index, public PFS_instrument_view_constants
+{
+ pos_ews_by_account_by_event_name()
+ : PFS_triple_index(0, FIRST_VIEW, 1)
+ {}
+
+ inline void reset(void)
+ {
+ m_index_1= 0;
+ m_index_2= VIEW_MUTEX;
+ m_index_3= 1;
+ }
+
+ inline void next_account(void)
+ {
+ m_index_1++;
+ m_index_2= FIRST_VIEW;
+ m_index_3= 1;
+ }
+
+ inline bool has_more_view(void)
+ { return (m_index_2 <= LAST_VIEW); }
+
+ inline void next_view(void)
+ {
+ m_index_2++;
+ m_index_3= 1;
+ }
+};
+
+/** Table PERFORMANCE_SCHEMA.EVENTS_WAITS_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME. */
+class table_ews_by_account_by_event_name : public PFS_engine_table
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_ews_by_account_by_event_name();
+
+public:
+ ~table_ews_by_account_by_event_name()
+ {}
+
+protected:
+ void make_row(PFS_account *account, PFS_instr_class *klass);
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ /** Current row. */
+ row_ews_by_account_by_event_name m_row;
+ /** True is the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ pos_ews_by_account_by_event_name m_pos;
+ /** Next position. */
+ pos_ews_by_account_by_event_name m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_ews_by_host_by_event_name.cc b/storage/perfschema/table_ews_by_host_by_event_name.cc
new file mode 100644
index 00000000..129709b8
--- /dev/null
+++ b/storage/perfschema/table_ews_by_host_by_event_name.cc
@@ -0,0 +1,273 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_ews_by_host_by_event_name.cc
+ Table EVENTS_WAITS_SUMMARY_BY_HOST_BY_EVENT_NAME (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "pfs_instr_class.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "table_ews_by_host_by_event_name.h"
+#include "pfs_global.h"
+#include "pfs_account.h"
+#include "pfs_visitor.h"
+#include "pfs_buffer_container.h"
+#include "field.h"
+
+THR_LOCK table_ews_by_host_by_event_name::m_table_lock;
+
+PFS_engine_table_share
+table_ews_by_host_by_event_name::m_share=
+{
+ { C_STRING_WITH_LEN("events_waits_summary_by_host_by_event_name") },
+ &pfs_truncatable_acl,
+ table_ews_by_host_by_event_name::create,
+ NULL, /* write_row */
+ table_ews_by_host_by_event_name::delete_all_rows,
+ table_ews_by_host_by_event_name::get_row_count,
+ sizeof(pos_ews_by_host_by_event_name),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE events_waits_summary_by_host_by_event_name("
+ "HOST CHAR(" STRINGIFY_ARG(HOSTNAME_LENGTH) ") collate utf8_bin default null,"
+ "EVENT_NAME VARCHAR(128) not null,"
+ "COUNT_STAR BIGINT unsigned not null,"
+ "SUM_TIMER_WAIT BIGINT unsigned not null,"
+ "MIN_TIMER_WAIT BIGINT unsigned not null,"
+ "AVG_TIMER_WAIT BIGINT unsigned not null,"
+ "MAX_TIMER_WAIT BIGINT unsigned not null)") },
+ false /* perpetual */
+};
+
+PFS_engine_table*
+table_ews_by_host_by_event_name::create(void)
+{
+ return new table_ews_by_host_by_event_name();
+}
+
+int
+table_ews_by_host_by_event_name::delete_all_rows(void)
+{
+ reset_events_waits_by_thread();
+ reset_events_waits_by_account();
+ reset_events_waits_by_host();
+ return 0;
+}
+
+ha_rows
+table_ews_by_host_by_event_name::get_row_count(void)
+{
+ return global_host_container.get_row_count() * wait_class_max;
+}
+
+table_ews_by_host_by_event_name::table_ews_by_host_by_event_name()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(), m_next_pos()
+{}
+
+void table_ews_by_host_by_event_name::reset_position(void)
+{
+ m_pos.reset();
+ m_next_pos.reset();
+}
+
+int table_ews_by_host_by_event_name::rnd_next(void)
+{
+ PFS_host *host;
+ PFS_instr_class *instr_class;
+ bool has_more_host= true;
+
+ for (m_pos.set_at(&m_next_pos);
+ has_more_host;
+ m_pos.next_host())
+ {
+ host= global_host_container.get(m_pos.m_index_1, & has_more_host);
+ if (host != NULL)
+ {
+ for ( ;
+ m_pos.has_more_view();
+ m_pos.next_view())
+ {
+ switch (m_pos.m_index_2)
+ {
+ case pos_ews_by_host_by_event_name::VIEW_MUTEX:
+ instr_class= find_mutex_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_host_by_event_name::VIEW_RWLOCK:
+ instr_class= find_rwlock_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_host_by_event_name::VIEW_COND:
+ instr_class= find_cond_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_host_by_event_name::VIEW_FILE:
+ instr_class= find_file_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_host_by_event_name::VIEW_TABLE:
+ instr_class= find_table_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_host_by_event_name::VIEW_SOCKET:
+ instr_class= find_socket_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_host_by_event_name::VIEW_IDLE:
+ instr_class= find_idle_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_host_by_event_name::VIEW_METADATA:
+ instr_class= find_metadata_class(m_pos.m_index_3);
+ break;
+ default:
+ instr_class= NULL;
+ DBUG_ASSERT(false);
+ break;
+ }
+
+ if (instr_class)
+ {
+ make_row(host, instr_class);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+ }
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int
+table_ews_by_host_by_event_name::rnd_pos(const void *pos)
+{
+ PFS_host *host;
+ PFS_instr_class *instr_class;
+
+ set_position(pos);
+
+ host= global_host_container.get(m_pos.m_index_1);
+ if (host == NULL)
+ return HA_ERR_RECORD_DELETED;
+
+ switch (m_pos.m_index_2)
+ {
+ case pos_ews_by_host_by_event_name::VIEW_MUTEX:
+ instr_class= find_mutex_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_host_by_event_name::VIEW_RWLOCK:
+ instr_class= find_rwlock_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_host_by_event_name::VIEW_COND:
+ instr_class= find_cond_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_host_by_event_name::VIEW_FILE:
+ instr_class= find_file_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_host_by_event_name::VIEW_TABLE:
+ instr_class= find_table_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_host_by_event_name::VIEW_SOCKET:
+ instr_class= find_socket_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_host_by_event_name::VIEW_IDLE:
+ instr_class= find_idle_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_host_by_event_name::VIEW_METADATA:
+ instr_class= find_metadata_class(m_pos.m_index_3);
+ break;
+ default:
+ instr_class= NULL;
+ DBUG_ASSERT(false);
+ break;
+ }
+ if (instr_class)
+ {
+ make_row(host, instr_class);
+ return 0;
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_ews_by_host_by_event_name
+::make_row(PFS_host *host, PFS_instr_class *klass)
+{
+ pfs_optimistic_state lock;
+ m_row_exists= false;
+
+ host->m_lock.begin_optimistic_lock(&lock);
+
+ if (m_row.m_host.make_row(host))
+ return;
+
+ m_row.m_event_name.make_row(klass);
+
+ PFS_connection_wait_visitor visitor(klass);
+ PFS_connection_iterator::visit_host(host,
+ true, /* accounts */
+ true, /* threads */
+ false, /* THDs */
+ & visitor);
+
+ if (! host->m_lock.end_optimistic_lock(&lock))
+ return;
+
+ m_row_exists= true;
+
+ get_normalizer(klass);
+ m_row.m_stat.set(m_normalizer, &visitor.m_stat);
+}
+
+int table_ews_by_host_by_event_name
+::read_row_values(TABLE *table, unsigned char *buf, Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* HOST */
+ m_row.m_host.set_field(f);
+ break;
+ case 1: /* EVENT_NAME */
+ m_row.m_event_name.set_field(f);
+ break;
+ default: /* 2, ... COUNT/SUM/MIN/AVG/MAX */
+ m_row.m_stat.set_field(f->field_index - 2, f);
+ break;
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_ews_by_host_by_event_name.h b/storage/perfschema/table_ews_by_host_by_event_name.h
new file mode 100644
index 00000000..074ec0be
--- /dev/null
+++ b/storage/perfschema/table_ews_by_host_by_event_name.h
@@ -0,0 +1,139 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_EWS_BY_HOST_BY_EVENT_NAME_H
+#define TABLE_EWS_BY_HOST_BY_EVENT_NAME_H
+
+/**
+ @file storage/perfschema/table_ews_by_host_by_event_name.h
+ Table EVENTS_WAITS_SUMMARY_BY_HOST_BY_EVENT_NAME (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "pfs_host.h"
+#include "table_helper.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/**
+ A row of table
+ PERFORMANCE_SCHEMA.EVENTS_WAITS_SUMMARY_BY_HOST_BY_EVENT_NAME.
+*/
+struct row_ews_by_host_by_event_name
+{
+ /** Column HOST. */
+ PFS_host_row m_host;
+ /** Column EVENT_NAME. */
+ PFS_event_name_row m_event_name;
+ /** Columns COUNT_STAR, SUM/MIN/AVG/MAX TIMER_WAIT. */
+ PFS_stat_row m_stat;
+};
+
+/**
+ Position of a cursor on
+ PERFORMANCE_SCHEMA.EVENTS_WAITS_SUMMARY_BY_HOST_BY_EVENT_NAME.
+ Index 1 on host (0 based)
+ Index 2 on instrument view
+ Index 3 on instrument class (1 based)
+*/
+struct pos_ews_by_host_by_event_name
+: public PFS_triple_index, public PFS_instrument_view_constants
+{
+ pos_ews_by_host_by_event_name()
+ : PFS_triple_index(0, FIRST_VIEW, 1)
+ {}
+
+ inline void reset(void)
+ {
+ m_index_1= 0;
+ m_index_2= FIRST_VIEW;
+ m_index_3= 1;
+ }
+
+ inline void next_host(void)
+ {
+ m_index_1++;
+ m_index_2= FIRST_VIEW;
+ m_index_3= 1;
+ }
+
+ inline bool has_more_view(void)
+ { return (m_index_2 <= LAST_VIEW); }
+
+ inline void next_view(void)
+ {
+ m_index_2++;
+ m_index_3= 1;
+ }
+};
+
+/** Table PERFORMANCE_SCHEMA.EVENTS_WAITS_SUMMARY_BY_HOST_BY_EVENT_NAME. */
+class table_ews_by_host_by_event_name : public PFS_engine_table
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_ews_by_host_by_event_name();
+
+public:
+ ~table_ews_by_host_by_event_name()
+ {}
+
+protected:
+ void make_row(PFS_host *host, PFS_instr_class *klass);
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ /** Current row. */
+ row_ews_by_host_by_event_name m_row;
+ /** True is the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ pos_ews_by_host_by_event_name m_pos;
+ /** Next position. */
+ pos_ews_by_host_by_event_name m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_ews_by_thread_by_event_name.cc b/storage/perfschema/table_ews_by_thread_by_event_name.cc
new file mode 100644
index 00000000..11b8a84d
--- /dev/null
+++ b/storage/perfschema/table_ews_by_thread_by_event_name.cc
@@ -0,0 +1,279 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_ews_by_thread_by_event_name.cc
+ Table EVENTS_WAITS_SUMMARY_BY_HOST_BY_EVENT_NAME (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "pfs_instr_class.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "table_ews_by_thread_by_event_name.h"
+#include "pfs_global.h"
+#include "pfs_visitor.h"
+#include "pfs_buffer_container.h"
+#include "field.h"
+
+THR_LOCK table_ews_by_thread_by_event_name::m_table_lock;
+
+PFS_engine_table_share
+table_ews_by_thread_by_event_name::m_share=
+{
+ { C_STRING_WITH_LEN("events_waits_summary_by_thread_by_event_name") },
+ &pfs_truncatable_acl,
+ table_ews_by_thread_by_event_name::create,
+ NULL, /* write_row */
+ table_ews_by_thread_by_event_name::delete_all_rows,
+ table_ews_by_thread_by_event_name::get_row_count,
+ sizeof(pos_ews_by_thread_by_event_name),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE events_waits_summary_by_thread_by_event_name("
+ "THREAD_ID BIGINT unsigned not null,"
+ "EVENT_NAME VARCHAR(128) not null,"
+ "COUNT_STAR BIGINT unsigned not null,"
+ "SUM_TIMER_WAIT BIGINT unsigned not null,"
+ "MIN_TIMER_WAIT BIGINT unsigned not null,"
+ "AVG_TIMER_WAIT BIGINT unsigned not null,"
+ "MAX_TIMER_WAIT BIGINT unsigned not null)") },
+ false /* perpetual */
+};
+
+PFS_engine_table*
+table_ews_by_thread_by_event_name::create(void)
+{
+ return new table_ews_by_thread_by_event_name();
+}
+
+int
+table_ews_by_thread_by_event_name::delete_all_rows(void)
+{
+ reset_events_waits_by_thread();
+ return 0;
+}
+
+ha_rows
+table_ews_by_thread_by_event_name::get_row_count(void)
+{
+ return global_thread_container.get_row_count() * wait_class_max;
+}
+
+table_ews_by_thread_by_event_name::table_ews_by_thread_by_event_name()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(), m_next_pos()
+{}
+
+void table_ews_by_thread_by_event_name::reset_position(void)
+{
+ m_pos.reset();
+ m_next_pos.reset();
+}
+
+int table_ews_by_thread_by_event_name::rnd_next(void)
+{
+ PFS_thread *thread;
+ PFS_instr_class *instr_class;
+ bool has_more_thread= true;
+
+ for (m_pos.set_at(&m_next_pos);
+ has_more_thread;
+ m_pos.next_thread())
+ {
+ thread= global_thread_container.get(m_pos.m_index_1, & has_more_thread);
+ if (thread != NULL)
+ {
+ for ( ;
+ m_pos.has_more_view();
+ m_pos.next_view())
+ {
+ switch (m_pos.m_index_2)
+ {
+ case pos_ews_by_thread_by_event_name::VIEW_MUTEX:
+ instr_class= find_mutex_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_thread_by_event_name::VIEW_RWLOCK:
+ instr_class= find_rwlock_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_thread_by_event_name::VIEW_COND:
+ instr_class= find_cond_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_thread_by_event_name::VIEW_FILE:
+ instr_class= find_file_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_thread_by_event_name::VIEW_TABLE:
+ instr_class= find_table_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_thread_by_event_name::VIEW_SOCKET:
+ instr_class= find_socket_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_thread_by_event_name::VIEW_IDLE:
+ instr_class= find_idle_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_thread_by_event_name::VIEW_METADATA:
+ instr_class= find_metadata_class(m_pos.m_index_3);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ instr_class= NULL;
+ break;
+ }
+
+ if (instr_class != NULL)
+ {
+ make_row(thread, instr_class);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+ }
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int
+table_ews_by_thread_by_event_name::rnd_pos(const void *pos)
+{
+ PFS_thread *thread;
+ PFS_instr_class *instr_class;
+
+ set_position(pos);
+
+ thread= global_thread_container.get(m_pos.m_index_1);
+ if (thread != NULL)
+ {
+ switch (m_pos.m_index_2)
+ {
+ case pos_ews_by_thread_by_event_name::VIEW_MUTEX:
+ instr_class= find_mutex_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_thread_by_event_name::VIEW_RWLOCK:
+ instr_class= find_rwlock_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_thread_by_event_name::VIEW_COND:
+ instr_class= find_cond_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_thread_by_event_name::VIEW_FILE:
+ instr_class= find_file_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_thread_by_event_name::VIEW_TABLE:
+ instr_class= find_table_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_thread_by_event_name::VIEW_SOCKET:
+ instr_class= find_socket_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_thread_by_event_name::VIEW_IDLE:
+ instr_class= find_idle_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_thread_by_event_name::VIEW_METADATA:
+ instr_class= find_metadata_class(m_pos.m_index_3);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ instr_class= NULL;
+ }
+
+ if (instr_class)
+ {
+ make_row(thread, instr_class);
+ return 0;
+ }
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_ews_by_thread_by_event_name
+::make_row(PFS_thread *thread, PFS_instr_class *klass)
+{
+ pfs_optimistic_state lock;
+ m_row_exists= false;
+
+ /* Protect this reader against a thread termination */
+ thread->m_lock.begin_optimistic_lock(&lock);
+
+ m_row.m_thread_internal_id= thread->m_thread_internal_id;
+
+ m_row.m_event_name.make_row(klass);
+
+ PFS_connection_wait_visitor visitor(klass);
+ PFS_connection_iterator::visit_thread(thread, &visitor);
+
+ /*
+ If the aggregation for this class is deferred, then we must pull the
+ current wait stats from the instances associated with this thread.
+ */
+ if (klass->is_deferred())
+ {
+ /* Visit instances owned by this thread. Do not visit the class. */
+ PFS_instance_wait_visitor inst_visitor;
+ PFS_instance_iterator::visit_instances(klass, &inst_visitor,
+ thread, false);
+ /* Combine the deferred stats and global stats */
+ visitor.m_stat.aggregate(&inst_visitor.m_stat);
+ }
+
+ if (! thread->m_lock.end_optimistic_lock(&lock))
+ return;
+
+ m_row_exists= true;
+
+ get_normalizer(klass);
+ m_row.m_stat.set(m_normalizer, & visitor.m_stat);
+}
+
+int table_ews_by_thread_by_event_name
+::read_row_values(TABLE *table, unsigned char *, Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 0);
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* THREAD_ID */
+ set_field_ulonglong(f, m_row.m_thread_internal_id);
+ break;
+ case 1: /* EVENT_NAME */
+ m_row.m_event_name.set_field(f);
+ break;
+ default: /* 2, ... COUNT/SUM/MIN/AVG/MAX */
+ m_row.m_stat.set_field(f->field_index - 2, f);
+ break;
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_ews_by_thread_by_event_name.h b/storage/perfschema/table_ews_by_thread_by_event_name.h
new file mode 100644
index 00000000..d3850e93
--- /dev/null
+++ b/storage/perfschema/table_ews_by_thread_by_event_name.h
@@ -0,0 +1,138 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_EWS_BY_THREAD_BY_EVENT_NAME_H
+#define TABLE_EWS_BY_THREAD_BY_EVENT_NAME_H
+
+/**
+ @file storage/perfschema/table_ews_by_thread_by_event_name.h
+ Table EVENTS_WAITS_SUMMARY_BY_THREAD_BY_EVENT_NAME (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "table_helper.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/**
+ A row of table
+ PERFORMANCE_SCHEMA.EVENTS_WAITS_SUMMARY_BY_THREAD_BY_EVENT_NAME.
+*/
+struct row_ews_by_thread_by_event_name
+{
+ /** Column THREAD_ID. */
+ ulonglong m_thread_internal_id;
+ /** Column EVENT_NAME. */
+ PFS_event_name_row m_event_name;
+ /** Columns COUNT_STAR, SUM/MIN/AVG/MAX TIMER_WAIT. */
+ PFS_stat_row m_stat;
+};
+
+/**
+ Position of a cursor on
+ PERFORMANCE_SCHEMA.EVENTS_WAITS_SUMMARY_BY_THREAD_BY_EVENT_NAME.
+ Index 1 on thread (0 based)
+ Index 2 on instrument view
+ Index 3 on instrument class (1 based)
+*/
+struct pos_ews_by_thread_by_event_name
+: public PFS_triple_index, public PFS_instrument_view_constants
+{
+ pos_ews_by_thread_by_event_name()
+ : PFS_triple_index(0, FIRST_VIEW, 1)
+ {}
+
+ inline void reset(void)
+ {
+ m_index_1= 0;
+ m_index_2= FIRST_VIEW;
+ m_index_3= 1;
+ }
+
+ inline void next_thread(void)
+ {
+ m_index_1++;
+ m_index_2= FIRST_VIEW;
+ m_index_3= 1;
+ }
+
+ inline bool has_more_view(void)
+ { return (m_index_2 <= LAST_VIEW); }
+
+ inline void next_view(void)
+ {
+ m_index_2++;
+ m_index_3= 1;
+ }
+};
+
+/** Table PERFORMANCE_SCHEMA.EVENTS_WAITS_SUMMARY_BY_THREAD_BY_EVENT_NAME. */
+class table_ews_by_thread_by_event_name : public PFS_engine_table
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_ews_by_thread_by_event_name();
+
+public:
+ ~table_ews_by_thread_by_event_name()
+ {}
+
+protected:
+ void make_row(PFS_thread *thread, PFS_instr_class *klass);
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ /** Current row. */
+ row_ews_by_thread_by_event_name m_row;
+ /** True is the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ pos_ews_by_thread_by_event_name m_pos;
+ /** Next position. */
+ pos_ews_by_thread_by_event_name m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_ews_by_user_by_event_name.cc b/storage/perfschema/table_ews_by_user_by_event_name.cc
new file mode 100644
index 00000000..5425d773
--- /dev/null
+++ b/storage/perfschema/table_ews_by_user_by_event_name.cc
@@ -0,0 +1,272 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_ews_by_user_by_event_name.cc
+ Table EVENTS_WAITS_SUMMARY_BY_USER_BY_EVENT_NAME (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "pfs_instr_class.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "table_ews_by_user_by_event_name.h"
+#include "pfs_global.h"
+#include "pfs_visitor.h"
+#include "pfs_buffer_container.h"
+#include "field.h"
+
+THR_LOCK table_ews_by_user_by_event_name::m_table_lock;
+
+PFS_engine_table_share
+table_ews_by_user_by_event_name::m_share=
+{
+ { C_STRING_WITH_LEN("events_waits_summary_by_user_by_event_name") },
+ &pfs_truncatable_acl,
+ table_ews_by_user_by_event_name::create,
+ NULL, /* write_row */
+ table_ews_by_user_by_event_name::delete_all_rows,
+ table_ews_by_user_by_event_name::get_row_count,
+ sizeof(pos_ews_by_user_by_event_name),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE events_waits_summary_by_user_by_event_name("
+ "USER CHAR(" USERNAME_CHAR_LENGTH_STR ") collate utf8_bin default null,"
+ "EVENT_NAME VARCHAR(128) not null,"
+ "COUNT_STAR BIGINT unsigned not null,"
+ "SUM_TIMER_WAIT BIGINT unsigned not null,"
+ "MIN_TIMER_WAIT BIGINT unsigned not null,"
+ "AVG_TIMER_WAIT BIGINT unsigned not null,"
+ "MAX_TIMER_WAIT BIGINT unsigned not null)") },
+ false /* perpetual */
+};
+
+PFS_engine_table*
+table_ews_by_user_by_event_name::create(void)
+{
+ return new table_ews_by_user_by_event_name();
+}
+
+int
+table_ews_by_user_by_event_name::delete_all_rows(void)
+{
+ reset_events_waits_by_thread();
+ reset_events_waits_by_account();
+ reset_events_waits_by_user();
+ return 0;
+}
+
+ha_rows
+table_ews_by_user_by_event_name::get_row_count(void)
+{
+ return global_user_container.get_row_count() * wait_class_max;
+}
+
+table_ews_by_user_by_event_name::table_ews_by_user_by_event_name()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(), m_next_pos()
+{}
+
+void table_ews_by_user_by_event_name::reset_position(void)
+{
+ m_pos.reset();
+ m_next_pos.reset();
+}
+
+int table_ews_by_user_by_event_name::rnd_next(void)
+{
+ PFS_user *user;
+ PFS_instr_class *instr_class;
+ bool has_more_user= true;
+
+ for (m_pos.set_at(&m_next_pos);
+ has_more_user;
+ m_pos.next_user())
+ {
+ user= global_user_container.get(m_pos.m_index_1, & has_more_user);
+ if (user != NULL)
+ {
+ for ( ;
+ m_pos.has_more_view();
+ m_pos.next_view())
+ {
+ switch (m_pos.m_index_2)
+ {
+ case pos_ews_by_user_by_event_name::VIEW_MUTEX:
+ instr_class= find_mutex_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_user_by_event_name::VIEW_RWLOCK:
+ instr_class= find_rwlock_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_user_by_event_name::VIEW_COND:
+ instr_class= find_cond_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_user_by_event_name::VIEW_FILE:
+ instr_class= find_file_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_user_by_event_name::VIEW_TABLE:
+ instr_class= find_table_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_user_by_event_name::VIEW_SOCKET:
+ instr_class= find_socket_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_user_by_event_name::VIEW_IDLE:
+ instr_class= find_idle_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_user_by_event_name::VIEW_METADATA:
+ instr_class= find_metadata_class(m_pos.m_index_3);
+ break;
+ default:
+ instr_class= NULL;
+ DBUG_ASSERT(false);
+ break;
+ }
+
+ if (instr_class)
+ {
+ make_row(user, instr_class);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+ }
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int
+table_ews_by_user_by_event_name::rnd_pos(const void *pos)
+{
+ PFS_user *user;
+ PFS_instr_class *instr_class;
+
+ set_position(pos);
+
+ user= global_user_container.get(m_pos.m_index_1);
+ if (user == NULL)
+ return HA_ERR_RECORD_DELETED;
+
+ switch (m_pos.m_index_2)
+ {
+ case pos_ews_by_user_by_event_name::VIEW_MUTEX:
+ instr_class= find_mutex_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_user_by_event_name::VIEW_RWLOCK:
+ instr_class= find_rwlock_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_user_by_event_name::VIEW_COND:
+ instr_class= find_cond_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_user_by_event_name::VIEW_FILE:
+ instr_class= find_file_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_user_by_event_name::VIEW_TABLE:
+ instr_class= find_table_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_user_by_event_name::VIEW_SOCKET:
+ instr_class= find_socket_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_user_by_event_name::VIEW_IDLE:
+ instr_class= find_idle_class(m_pos.m_index_3);
+ break;
+ case pos_ews_by_user_by_event_name::VIEW_METADATA:
+ instr_class= find_metadata_class(m_pos.m_index_3);
+ break;
+ default:
+ instr_class= NULL;
+ DBUG_ASSERT(false);
+ break;
+ }
+ if (instr_class)
+ {
+ make_row(user, instr_class);
+ return 0;
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_ews_by_user_by_event_name
+::make_row(PFS_user *user, PFS_instr_class *klass)
+{
+ pfs_optimistic_state lock;
+ m_row_exists= false;
+
+ user->m_lock.begin_optimistic_lock(&lock);
+
+ if (m_row.m_user.make_row(user))
+ return;
+
+ m_row.m_event_name.make_row(klass);
+
+ PFS_connection_wait_visitor visitor(klass);
+ PFS_connection_iterator::visit_user(user,
+ true, /* accounts */
+ true, /* threads */
+ false, /* THDs */
+ & visitor);
+
+ if (! user->m_lock.end_optimistic_lock(&lock))
+ return;
+
+ m_row_exists= true;
+
+ get_normalizer(klass);
+ m_row.m_stat.set(m_normalizer, &visitor.m_stat);
+}
+
+int table_ews_by_user_by_event_name
+::read_row_values(TABLE *table, unsigned char *buf, Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* USER */
+ m_row.m_user.set_field(f);
+ break;
+ case 1: /* EVENT_NAME */
+ m_row.m_event_name.set_field(f);
+ break;
+ default: /* 2, ... COUNT/SUM/MIN/AVG/MAX */
+ m_row.m_stat.set_field(f->field_index - 2, f);
+ break;
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_ews_by_user_by_event_name.h b/storage/perfschema/table_ews_by_user_by_event_name.h
new file mode 100644
index 00000000..b088c8e2
--- /dev/null
+++ b/storage/perfschema/table_ews_by_user_by_event_name.h
@@ -0,0 +1,139 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_EWS_BY_USER_BY_EVENT_NAME_H
+#define TABLE_EWS_BY_USER_BY_EVENT_NAME_H
+
+/**
+ @file storage/perfschema/table_ews_by_user_by_event_name.h
+ Table EVENTS_WAITS_SUMMARY_BY_USER_BY_EVENT_NAME (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "pfs_user.h"
+#include "table_helper.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/**
+ A row of table
+ PERFORMANCE_SCHEMA.EVENTS_WAITS_SUMMARY_BY_USER_BY_EVENT_NAME.
+*/
+struct row_ews_by_user_by_event_name
+{
+ /** Column USER. */
+ PFS_user_row m_user;
+ /** Column EVENT_NAME. */
+ PFS_event_name_row m_event_name;
+ /** Columns COUNT_STAR, SUM/MIN/AVG/MAX TIMER_WAIT. */
+ PFS_stat_row m_stat;
+};
+
+/**
+ Position of a cursor on
+ PERFORMANCE_SCHEMA.EVENTS_WAITS_SUMMARY_BY_USER_BY_EVENT_NAME.
+ Index 1 on user (0 based)
+ Index 2 on instrument view
+ Index 3 on instrument class (1 based)
+*/
+struct pos_ews_by_user_by_event_name
+: public PFS_triple_index, public PFS_instrument_view_constants
+{
+ pos_ews_by_user_by_event_name()
+ : PFS_triple_index(0, FIRST_VIEW, 1)
+ {}
+
+ inline void reset(void)
+ {
+ m_index_1= 0;
+ m_index_2= FIRST_VIEW;
+ m_index_3= 1;
+ }
+
+ inline void next_user(void)
+ {
+ m_index_1++;
+ m_index_2= FIRST_VIEW;
+ m_index_3= 1;
+ }
+
+ inline bool has_more_view(void)
+ { return (m_index_2 <= LAST_VIEW); }
+
+ inline void next_view(void)
+ {
+ m_index_2++;
+ m_index_3= 1;
+ }
+};
+
+/** Table PERFORMANCE_SCHEMA.EVENTS_WAITS_SUMMARY_BY_USER_BY_EVENT_NAME. */
+class table_ews_by_user_by_event_name : public PFS_engine_table
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_ews_by_user_by_event_name();
+
+public:
+ ~table_ews_by_user_by_event_name()
+ {}
+
+protected:
+ void make_row(PFS_user *user, PFS_instr_class *klass);
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ /** Current row. */
+ row_ews_by_user_by_event_name m_row;
+ /** True is the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ pos_ews_by_user_by_event_name m_pos;
+ /** Next position. */
+ pos_ews_by_user_by_event_name m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_ews_global_by_event_name.cc b/storage/perfschema/table_ews_global_by_event_name.cc
new file mode 100644
index 00000000..13839ddb
--- /dev/null
+++ b/storage/perfschema/table_ews_global_by_event_name.cc
@@ -0,0 +1,437 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_ews_global_by_event_name.cc
+ Table EVENTS_WAITS_SUMMARY_GLOBAL_BY_EVENT_NAME (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "pfs_instr_class.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "table_ews_global_by_event_name.h"
+#include "pfs_global.h"
+#include "pfs_instr.h"
+#include "pfs_timer.h"
+#include "pfs_visitor.h"
+#include "field.h"
+
+THR_LOCK table_ews_global_by_event_name::m_table_lock;
+
+PFS_engine_table_share
+table_ews_global_by_event_name::m_share=
+{
+ { C_STRING_WITH_LEN("events_waits_summary_global_by_event_name") },
+ &pfs_truncatable_acl,
+ table_ews_global_by_event_name::create,
+ NULL, /* write_row */
+ table_ews_global_by_event_name::delete_all_rows,
+ table_ews_global_by_event_name::get_row_count,
+ sizeof(pos_ews_global_by_event_name),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE events_waits_summary_global_by_event_name("
+ "EVENT_NAME VARCHAR(128) not null,"
+ "COUNT_STAR BIGINT unsigned not null,"
+ "SUM_TIMER_WAIT BIGINT unsigned not null,"
+ "MIN_TIMER_WAIT BIGINT unsigned not null,"
+ "AVG_TIMER_WAIT BIGINT unsigned not null,"
+ "MAX_TIMER_WAIT BIGINT unsigned not null)") },
+ false /* perpetual */
+};
+
+PFS_engine_table*
+table_ews_global_by_event_name::create(void)
+{
+ return new table_ews_global_by_event_name();
+}
+
+int
+table_ews_global_by_event_name::delete_all_rows(void)
+{
+ reset_events_waits_by_instance();
+ reset_table_waits_by_table_handle();
+ reset_table_waits_by_table();
+ reset_events_waits_by_class();
+ return 0;
+}
+
+ha_rows
+table_ews_global_by_event_name::get_row_count(void)
+{
+ return wait_class_max;
+}
+
+table_ews_global_by_event_name::table_ews_global_by_event_name()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(), m_next_pos()
+{}
+
+void table_ews_global_by_event_name::reset_position(void)
+{
+ m_pos.reset();
+ m_next_pos.reset();
+}
+
+int table_ews_global_by_event_name::rnd_next(void)
+{
+ PFS_mutex_class *mutex_class;
+ PFS_rwlock_class *rwlock_class;
+ PFS_cond_class *cond_class;
+ PFS_file_class *file_class;
+ PFS_socket_class *socket_class;
+ PFS_instr_class *instr_class;
+
+ for (m_pos.set_at(&m_next_pos);
+ m_pos.has_more_view();
+ m_pos.next_view())
+ {
+ switch (m_pos.m_index_1)
+ {
+ case pos_ews_global_by_event_name::VIEW_MUTEX:
+ mutex_class= find_mutex_class(m_pos.m_index_2);
+ if (mutex_class)
+ {
+ make_mutex_row(mutex_class);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ break;
+ case pos_ews_global_by_event_name::VIEW_RWLOCK:
+ rwlock_class= find_rwlock_class(m_pos.m_index_2);
+ if (rwlock_class)
+ {
+ make_rwlock_row(rwlock_class);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ break;
+ case pos_ews_global_by_event_name::VIEW_COND:
+ cond_class= find_cond_class(m_pos.m_index_2);
+ if (cond_class)
+ {
+ make_cond_row(cond_class);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ break;
+ case pos_ews_global_by_event_name::VIEW_FILE:
+ file_class= find_file_class(m_pos.m_index_2);
+ if (file_class)
+ {
+ make_file_row(file_class);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ break;
+ case pos_ews_global_by_event_name::VIEW_TABLE:
+ if (m_pos.m_index_2 == 1)
+ {
+ make_table_io_row(&global_table_io_class);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ if (m_pos.m_index_2 == 2)
+ {
+ make_table_lock_row(&global_table_lock_class);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ break;
+ case pos_ews_global_by_event_name::VIEW_SOCKET:
+ socket_class= find_socket_class(m_pos.m_index_2);
+ if (socket_class)
+ {
+ make_socket_row(socket_class);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ break;
+ case pos_ews_global_by_event_name::VIEW_IDLE:
+ instr_class= find_idle_class(m_pos.m_index_2);
+ if (instr_class)
+ {
+ make_idle_row(instr_class);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ break;
+ case pos_ews_global_by_event_name::VIEW_METADATA:
+ instr_class= find_metadata_class(m_pos.m_index_2);
+ if (instr_class)
+ {
+ make_metadata_row(instr_class);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ break;
+ default:
+ break;
+ }
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int
+table_ews_global_by_event_name::rnd_pos(const void *pos)
+{
+ PFS_mutex_class *mutex_class;
+ PFS_rwlock_class *rwlock_class;
+ PFS_cond_class *cond_class;
+ PFS_file_class *file_class;
+ PFS_socket_class *socket_class;
+ PFS_instr_class *instr_class;
+
+ set_position(pos);
+
+ switch (m_pos.m_index_1)
+ {
+ case pos_ews_global_by_event_name::VIEW_MUTEX:
+ mutex_class= find_mutex_class(m_pos.m_index_2);
+ if (mutex_class)
+ {
+ make_mutex_row(mutex_class);
+ return 0;
+ }
+ break;
+ case pos_ews_global_by_event_name::VIEW_RWLOCK:
+ rwlock_class= find_rwlock_class(m_pos.m_index_2);
+ if (rwlock_class)
+ {
+ make_rwlock_row(rwlock_class);
+ return 0;
+ }
+ break;
+ case pos_ews_global_by_event_name::VIEW_COND:
+ cond_class= find_cond_class(m_pos.m_index_2);
+ if (cond_class)
+ {
+ make_cond_row(cond_class);
+ return 0;
+ }
+ break;
+ case pos_ews_global_by_event_name::VIEW_FILE:
+ file_class= find_file_class(m_pos.m_index_2);
+ if (file_class)
+ {
+ make_file_row(file_class);
+ return 0;
+ }
+ break;
+ case pos_ews_global_by_event_name::VIEW_TABLE:
+ DBUG_ASSERT(m_pos.m_index_2 >= 1);
+ DBUG_ASSERT(m_pos.m_index_2 <= 2);
+ if (m_pos.m_index_2 == 1)
+ make_table_io_row(&global_table_io_class);
+ else
+ make_table_lock_row(&global_table_lock_class);
+ break;
+ case pos_ews_global_by_event_name::VIEW_SOCKET:
+ socket_class= find_socket_class(m_pos.m_index_2);
+ if (socket_class)
+ {
+ make_socket_row(socket_class);
+ return 0;
+ }
+ break;
+ case pos_ews_global_by_event_name::VIEW_IDLE:
+ instr_class= find_idle_class(m_pos.m_index_2);
+ if (instr_class)
+ {
+ make_idle_row(instr_class);
+ return 0;
+ }
+ break;
+ case pos_ews_global_by_event_name::VIEW_METADATA:
+ instr_class= find_metadata_class(m_pos.m_index_2);
+ if (instr_class)
+ {
+ make_metadata_row(instr_class);
+ return 0;
+ }
+ break;
+ default:
+ DBUG_ASSERT(false);
+ break;
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_ews_global_by_event_name
+::make_mutex_row(PFS_mutex_class *klass)
+{
+ m_row.m_event_name.make_row(klass);
+
+ PFS_instance_wait_visitor visitor;
+ PFS_instance_iterator::visit_mutex_instances(klass, & visitor);
+
+ get_normalizer(klass);
+ m_row.m_stat.set(m_normalizer, & visitor.m_stat);
+ m_row_exists= true;
+}
+
+void table_ews_global_by_event_name
+::make_rwlock_row(PFS_rwlock_class *klass)
+{
+ m_row.m_event_name.make_row(klass);
+
+ PFS_instance_wait_visitor visitor;
+ PFS_instance_iterator::visit_rwlock_instances(klass, & visitor);
+
+ get_normalizer(klass);
+ m_row.m_stat.set(m_normalizer, & visitor.m_stat);
+ m_row_exists= true;
+}
+
+void table_ews_global_by_event_name
+::make_cond_row(PFS_cond_class *klass)
+{
+ m_row.m_event_name.make_row(klass);
+
+ PFS_instance_wait_visitor visitor;
+ PFS_instance_iterator::visit_cond_instances(klass, & visitor);
+
+ get_normalizer(klass);
+ m_row.m_stat.set(m_normalizer, & visitor.m_stat);
+ m_row_exists= true;
+}
+
+void table_ews_global_by_event_name
+::make_file_row(PFS_file_class *klass)
+{
+ m_row.m_event_name.make_row(klass);
+
+ PFS_instance_wait_visitor visitor;
+ PFS_instance_iterator::visit_file_instances(klass, & visitor);
+
+ get_normalizer(klass);
+ m_row.m_stat.set(m_normalizer, & visitor.m_stat);
+ m_row_exists= true;
+}
+
+void table_ews_global_by_event_name
+::make_table_io_row(PFS_instr_class *klass)
+{
+ m_row.m_event_name.make_row(klass);
+
+ PFS_table_io_wait_visitor visitor;
+ PFS_object_iterator::visit_all_tables(& visitor);
+
+ get_normalizer(klass);
+ m_row.m_stat.set(m_normalizer, & visitor.m_stat);
+ m_row_exists= true;
+}
+
+void table_ews_global_by_event_name
+::make_table_lock_row(PFS_instr_class *klass)
+{
+ m_row.m_event_name.make_row(klass);
+
+ PFS_table_lock_wait_visitor visitor;
+ PFS_object_iterator::visit_all_tables(& visitor);
+
+ get_normalizer(klass);
+ m_row.m_stat.set(m_normalizer, & visitor.m_stat);
+ m_row_exists= true;
+}
+
+void table_ews_global_by_event_name
+::make_socket_row(PFS_socket_class *klass)
+{
+ m_row.m_event_name.make_row(klass);
+
+ PFS_instance_wait_visitor visitor;
+ PFS_instance_iterator::visit_socket_instances(klass, &visitor);
+
+ get_normalizer(klass);
+ m_row.m_stat.set(m_normalizer, &visitor.m_stat);
+ m_row_exists= true;
+}
+
+void table_ews_global_by_event_name
+::make_idle_row(PFS_instr_class *klass)
+{
+ m_row.m_event_name.make_row(klass);
+
+ PFS_connection_wait_visitor visitor(klass);
+ PFS_connection_iterator::visit_global(false, /* hosts */
+ false, /* users */
+ false, /* accounts */
+ true, /* threads */
+ false, /* THDs */
+ &visitor);
+ get_normalizer(klass);
+ m_row.m_stat.set(m_normalizer, &visitor.m_stat);
+ m_row_exists= true;
+}
+
+void table_ews_global_by_event_name
+::make_metadata_row(PFS_instr_class *klass)
+{
+ m_row.m_event_name.make_row(klass);
+
+ PFS_connection_wait_visitor visitor(klass);
+ PFS_connection_iterator::visit_global(false, /* hosts */
+ true, /* users */
+ true, /* accounts */
+ true, /* threads */
+ false, /* THDs */
+ &visitor);
+ get_normalizer(klass);
+ m_row.m_stat.set(m_normalizer, &visitor.m_stat);
+ m_row_exists= true;
+}
+
+int table_ews_global_by_event_name
+::read_row_values(TABLE *table, unsigned char *, Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 0);
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* EVENT_NAME */
+ m_row.m_event_name.set_field(f);
+ break;
+ default: /* 1, ... COUNT/SUM/MIN/AVG/MAX */
+ m_row.m_stat.set_field(f->field_index - 1, f);
+ break;
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_ews_global_by_event_name.h b/storage/perfschema/table_ews_global_by_event_name.h
new file mode 100644
index 00000000..a9deb97a
--- /dev/null
+++ b/storage/perfschema/table_ews_global_by_event_name.h
@@ -0,0 +1,135 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_EWS_GLOBAL_BY_EVENT_NAME_H
+#define TABLE_EWS_GLOBAL_BY_EVENT_NAME_H
+
+/**
+ @file storage/perfschema/table_ews_global_by_event_name.h
+ Table EVENTS_WAITS_SUMMARY_GLOBAL_BY_EVENT_NAME (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "table_helper.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/**
+ A row of table
+ PERFORMANCE_SCHEMA.EVENTS_WAITS_SUMMARY_GLOBAL_BY_EVENT_NAME.
+*/
+struct row_ews_global_by_event_name
+{
+ /** Column EVENT_NAME. */
+ PFS_event_name_row m_event_name;
+ /** Columns COUNT_STAR, SUM/MIN/AVG/MAX TIMER_WAIT. */
+ PFS_stat_row m_stat;
+};
+
+/**
+ Position of a cursor on
+ PERFORMANCE_SCHEMA.EVENTS_WAITS_SUMMARY_GLOBAL_BY_EVENT_NAME.
+ Index 1 on instrument view
+ Index 2 on instrument class (1 based)
+*/
+struct pos_ews_global_by_event_name
+: public PFS_double_index, public PFS_instrument_view_constants
+{
+ pos_ews_global_by_event_name()
+ : PFS_double_index(FIRST_VIEW, 1)
+ {}
+
+ inline void reset(void)
+ {
+ m_index_1= FIRST_VIEW;
+ m_index_2= 1;
+ }
+
+ inline bool has_more_view(void)
+ { return (m_index_1 <= LAST_VIEW); }
+
+ inline void next_view(void)
+ {
+ m_index_1++;
+ m_index_2= 1;
+ }
+};
+
+/** Table PERFORMANCE_SCHEMA.EVENTS_WAITS_SUMMARY_GLOBAL_BY_EVENT_NAME. */
+class table_ews_global_by_event_name : public PFS_engine_table
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_ews_global_by_event_name();
+
+public:
+ ~table_ews_global_by_event_name()
+ {}
+
+protected:
+ void make_mutex_row(PFS_mutex_class *klass);
+ void make_rwlock_row(PFS_rwlock_class *klass);
+ void make_cond_row(PFS_cond_class *klass);
+ void make_file_row(PFS_file_class *klass);
+ void make_table_io_row(PFS_instr_class *klass);
+ void make_table_lock_row(PFS_instr_class *klass);
+ void make_socket_row(PFS_socket_class *klass);
+ void make_idle_row(PFS_instr_class *klass);
+ void make_metadata_row(PFS_instr_class *klass);
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ /** Current row. */
+ row_ews_global_by_event_name m_row;
+ /** True is the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ pos_ews_global_by_event_name m_pos;
+ /** Next position. */
+ pos_ews_global_by_event_name m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_file_instances.cc b/storage/perfschema/table_file_instances.cc
new file mode 100644
index 00000000..ca77b606
--- /dev/null
+++ b/storage/perfschema/table_file_instances.cc
@@ -0,0 +1,174 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_file_instances.cc
+ Table FILE_INSTANCES (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "pfs_instr.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "table_file_instances.h"
+#include "pfs_global.h"
+#include "pfs_buffer_container.h"
+#include "field.h"
+
+THR_LOCK table_file_instances::m_table_lock;
+
+PFS_engine_table_share
+table_file_instances::m_share=
+{
+ { C_STRING_WITH_LEN("file_instances") },
+ &pfs_readonly_acl,
+ table_file_instances::create,
+ NULL, /* write_row */
+ NULL, /* delete_all_rows */
+ table_file_instances::get_row_count,
+ sizeof(PFS_simple_index),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE file_instances("
+ "FILE_NAME VARCHAR(512) not null,"
+ "EVENT_NAME VARCHAR(128) not null,"
+ "OPEN_COUNT INTEGER unsigned not null)") },
+ false /* perpetual */
+};
+
+PFS_engine_table* table_file_instances::create(void)
+{
+ return new table_file_instances();
+}
+
+ha_rows
+table_file_instances::get_row_count(void)
+{
+ return global_file_container.get_row_count();
+}
+
+table_file_instances::table_file_instances()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(0), m_next_pos(0)
+{}
+
+void table_file_instances::reset_position(void)
+{
+ m_pos.m_index= 0;
+ m_next_pos.m_index= 0;
+}
+
+int table_file_instances::rnd_next(void)
+{
+ PFS_file *pfs;
+
+ m_pos.set_at(&m_next_pos);
+ PFS_file_iterator it= global_file_container.iterate(m_pos.m_index);
+ pfs= it.scan_next(& m_pos.m_index);
+ if (pfs != NULL)
+ {
+ make_row(pfs);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int table_file_instances::rnd_pos(const void *pos)
+{
+ PFS_file *pfs;
+
+ set_position(pos);
+
+ pfs= global_file_container.get(m_pos.m_index);
+ if (pfs != NULL)
+ {
+ make_row(pfs);
+ return 0;
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_file_instances::make_row(PFS_file *pfs)
+{
+ pfs_optimistic_state lock;
+ PFS_file_class *safe_class;
+
+ m_row_exists= false;
+
+ /* Protect this reader against a file delete */
+ pfs->m_lock.begin_optimistic_lock(&lock);
+
+ safe_class= sanitize_file_class(pfs->m_class);
+ if (unlikely(safe_class == NULL))
+ return;
+
+ m_row.m_filename= pfs->m_filename;
+ m_row.m_filename_length= pfs->m_filename_length;
+ m_row.m_event_name= safe_class->m_name;
+ m_row.m_event_name_length= safe_class->m_name_length;
+ m_row.m_open_count= pfs->m_file_stat.m_open_count;
+
+ if (pfs->m_lock.end_optimistic_lock(&lock))
+ m_row_exists= true;
+}
+
+int table_file_instances::read_row_values(TABLE *table,
+ unsigned char *,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 0);
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* FILENAME */
+ set_field_varchar_utf8(f, m_row.m_filename, m_row.m_filename_length);
+ break;
+ case 1: /* EVENT_NAME */
+ set_field_varchar_utf8(f, m_row.m_event_name,
+ m_row.m_event_name_length);
+ break;
+ case 2: /* OPEN_COUNT */
+ set_field_ulong(f, m_row.m_open_count);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_file_instances.h b/storage/perfschema/table_file_instances.h
new file mode 100644
index 00000000..cb3d39d4
--- /dev/null
+++ b/storage/perfschema/table_file_instances.h
@@ -0,0 +1,96 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_FILE_INSTANCES_H
+#define TABLE_FILE_INSTANCES_H
+
+/**
+ @file storage/perfschema/table_file_instances.h
+ Table FILE_INSTANCES (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/** A row of PERFORMANCE_SCHEMA.FILE_INSTANCES. */
+struct row_file_instances
+{
+ /** Column FILE_NAME. */
+ const char *m_filename;
+ /** Length in bytes of @c m_filename. */
+ uint m_filename_length;
+ /** Column EVENT_NAME. */
+ const char *m_event_name;
+ /** Length in bytes of @c m_event_name. */
+ uint m_event_name_length;
+ /** Column OPEN_COUNT. */
+ uint m_open_count;
+};
+
+/** Table PERFORMANCE_SCHEMA.FILE_INSTANCES. */
+class table_file_instances : public PFS_engine_table
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static ha_rows get_row_count();
+
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+private:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_file_instances();
+
+public:
+ ~table_file_instances()
+ {}
+
+private:
+ void make_row(PFS_file *pfs);
+
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ /** Current row. */
+ row_file_instances m_row;
+ /** True if the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ PFS_simple_index m_pos;
+ /** Next position. */
+ PFS_simple_index m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_file_summary_by_event_name.cc b/storage/perfschema/table_file_summary_by_event_name.cc
new file mode 100644
index 00000000..404b5818
--- /dev/null
+++ b/storage/perfschema/table_file_summary_by_event_name.cc
@@ -0,0 +1,259 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_file_summary_by_event_name.cc
+ Table FILE_SUMMARY_BY_EVENT_NAME(implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "pfs_instr_class.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "table_file_summary_by_event_name.h"
+#include "pfs_global.h"
+#include "pfs_visitor.h"
+#include "field.h"
+
+THR_LOCK table_file_summary_by_event_name::m_table_lock;
+
+PFS_engine_table_share
+table_file_summary_by_event_name::m_share=
+{
+ { C_STRING_WITH_LEN("file_summary_by_event_name") },
+ &pfs_truncatable_acl,
+ table_file_summary_by_event_name::create,
+ NULL, /* write_row */
+ table_file_summary_by_event_name::delete_all_rows,
+ table_file_summary_by_event_name::get_row_count,
+ sizeof(PFS_simple_index),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE file_summary_by_event_name("
+ "EVENT_NAME VARCHAR(128) not null,"
+ "COUNT_STAR BIGINT unsigned not null,"
+ "SUM_TIMER_WAIT BIGINT unsigned not null,"
+ "MIN_TIMER_WAIT BIGINT unsigned not null,"
+ "AVG_TIMER_WAIT BIGINT unsigned not null,"
+ "MAX_TIMER_WAIT BIGINT unsigned not null,"
+ "COUNT_READ BIGINT unsigned not null,"
+ "SUM_TIMER_READ BIGINT unsigned not null,"
+ "MIN_TIMER_READ BIGINT unsigned not null,"
+ "AVG_TIMER_READ BIGINT unsigned not null,"
+ "MAX_TIMER_READ BIGINT unsigned not null,"
+ "SUM_NUMBER_OF_BYTES_READ BIGINT not null,"
+ "COUNT_WRITE BIGINT unsigned not null,"
+ "SUM_TIMER_WRITE BIGINT unsigned not null,"
+ "MIN_TIMER_WRITE BIGINT unsigned not null,"
+ "AVG_TIMER_WRITE BIGINT unsigned not null,"
+ "MAX_TIMER_WRITE BIGINT unsigned not null,"
+ "SUM_NUMBER_OF_BYTES_WRITE BIGINT not null,"
+ "COUNT_MISC BIGINT unsigned not null,"
+ "SUM_TIMER_MISC BIGINT unsigned not null,"
+ "MIN_TIMER_MISC BIGINT unsigned not null,"
+ "AVG_TIMER_MISC BIGINT unsigned not null,"
+ "MAX_TIMER_MISC BIGINT unsigned not null)") },
+ false /* perpetual */
+};
+
+PFS_engine_table* table_file_summary_by_event_name::create(void)
+{
+ return new table_file_summary_by_event_name();
+}
+
+int table_file_summary_by_event_name::delete_all_rows(void)
+{
+ reset_file_instance_io();
+ reset_file_class_io();
+ return 0;
+}
+
+ha_rows
+table_file_summary_by_event_name::get_row_count(void)
+{
+ return file_class_max;
+}
+
+table_file_summary_by_event_name::table_file_summary_by_event_name()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_pos(1), m_next_pos(1)
+{}
+
+void table_file_summary_by_event_name::reset_position(void)
+{
+ m_pos.m_index= 1;
+ m_next_pos.m_index= 1;
+}
+
+int table_file_summary_by_event_name::rnd_next(void)
+{
+ PFS_file_class *file_class;
+
+ m_pos.set_at(&m_next_pos);
+
+ file_class= find_file_class(m_pos.m_index);
+ if (file_class)
+ {
+ make_row(file_class);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int table_file_summary_by_event_name::rnd_pos(const void *pos)
+{
+ PFS_file_class *file_class;
+
+ set_position(pos);
+
+ file_class= find_file_class(m_pos.m_index);
+ if (file_class)
+ {
+ make_row(file_class);
+ return 0;
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+/**
+ Build a row.
+ @param file_class the file class the cursor is reading
+*/
+void table_file_summary_by_event_name::make_row(PFS_file_class *file_class)
+{
+ m_row.m_event_name.make_row(file_class);
+
+ PFS_instance_file_io_stat_visitor visitor;
+ PFS_instance_iterator::visit_file_instances(file_class, &visitor);
+
+ time_normalizer *normalizer= time_normalizer::get(wait_timer);
+
+ /* Collect timer and byte count stats */
+ m_row.m_io_stat.set(normalizer, &visitor.m_file_io_stat);
+ m_row_exists= true;
+
+}
+
+int table_file_summary_by_event_name::read_row_values(TABLE *table,
+ unsigned char *,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(!m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 0);
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* EVENT_NAME */
+ m_row.m_event_name.set_field(f);
+ break;
+ case 1: /* COUNT_STAR */
+ set_field_ulonglong(f, m_row.m_io_stat.m_all.m_waits.m_count);
+ break;
+ case 2: /* SUM_TIMER_WAIT */
+ set_field_ulonglong(f, m_row.m_io_stat.m_all.m_waits.m_sum);
+ break;
+ case 3: /* MIN_TIMER_WAIT */
+ set_field_ulonglong(f, m_row.m_io_stat.m_all.m_waits.m_min);
+ break;
+ case 4: /* AVG_TIMER_WAIT */
+ set_field_ulonglong(f, m_row.m_io_stat.m_all.m_waits.m_avg);
+ break;
+ case 5: /* MAX_TIMER_WAIT */
+ set_field_ulonglong(f, m_row.m_io_stat.m_all.m_waits.m_max);
+ break;
+
+ case 6: /* COUNT_READ */
+ set_field_ulonglong(f, m_row.m_io_stat.m_read.m_waits.m_count);
+ break;
+ case 7: /* SUM_TIMER_READ */
+ set_field_ulonglong(f, m_row.m_io_stat.m_read.m_waits.m_sum);
+ break;
+ case 8: /* MIN_TIMER_READ */
+ set_field_ulonglong(f, m_row.m_io_stat.m_read.m_waits.m_min);
+ break;
+ case 9: /* AVG_TIMER_READ */
+ set_field_ulonglong(f, m_row.m_io_stat.m_read.m_waits.m_avg);
+ break;
+ case 10: /* MAX_TIMER_READ */
+ set_field_ulonglong(f, m_row.m_io_stat.m_read.m_waits.m_max);
+ break;
+ case 11: /* SUM_NUMBER_OF_BYTES_READ */
+ set_field_ulonglong(f, m_row.m_io_stat.m_read.m_bytes);
+ break;
+
+ case 12: /* COUNT_WRITE */
+ set_field_ulonglong(f, m_row.m_io_stat.m_write.m_waits.m_count);
+ break;
+ case 13: /* SUM_TIMER_WRITE */
+ set_field_ulonglong(f, m_row.m_io_stat.m_write.m_waits.m_sum);
+ break;
+ case 14: /* MIN_TIMER_WRITE */
+ set_field_ulonglong(f, m_row.m_io_stat.m_write.m_waits.m_min);
+ break;
+ case 15: /* AVG_TIMER_WRITE */
+ set_field_ulonglong(f, m_row.m_io_stat.m_write.m_waits.m_avg);
+ break;
+ case 16: /* MAX_TIMER_WRITE */
+ set_field_ulonglong(f, m_row.m_io_stat.m_write.m_waits.m_max);
+ break;
+ case 17: /* SUM_NUMBER_OF_BYTES_WRITE */
+ set_field_ulonglong(f, m_row.m_io_stat.m_write.m_bytes);
+ break;
+
+ case 18: /* COUNT_MISC */
+ set_field_ulonglong(f, m_row.m_io_stat.m_misc.m_waits.m_count);
+ break;
+ case 19: /* SUM_TIMER_MISC */
+ set_field_ulonglong(f, m_row.m_io_stat.m_misc.m_waits.m_sum);
+ break;
+ case 20: /* MIN_TIMER_MISC */
+ set_field_ulonglong(f, m_row.m_io_stat.m_misc.m_waits.m_min);
+ break;
+ case 21: /* AVG_TIMER_MISC */
+ set_field_ulonglong(f, m_row.m_io_stat.m_misc.m_waits.m_avg);
+ break;
+ case 22: /* MAX_TIMER_MISC */
+ set_field_ulonglong(f, m_row.m_io_stat.m_misc.m_waits.m_max);
+ break;
+
+ default:
+ DBUG_ASSERT(false);
+ break;
+ }
+ } // if
+ } // for
+
+ return 0;
+}
diff --git a/storage/perfschema/table_file_summary_by_event_name.h b/storage/perfschema/table_file_summary_by_event_name.h
new file mode 100644
index 00000000..ae2124fe
--- /dev/null
+++ b/storage/perfschema/table_file_summary_by_event_name.h
@@ -0,0 +1,97 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_FILE_SUMMARY_H
+#define TABLE_FILE_SUMMARY_H
+
+/**
+ @file storage/perfschema/table_file_summary_by_event_name.h
+ Table FILE_SUMMARY_BY_EVENT_NAME (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "table_helper.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/** A row of PERFORMANCE_SCHEMA.FILE_SUMMARY_BY_EVENT_NAME. */
+struct row_file_summary_by_event_name
+{
+ /** Column EVENT_NAME. */
+ PFS_event_name_row m_event_name;
+
+ /** Columns COUNT_STAR, SUM/MIN/AVG/MAX TIMER and NUMBER_OF_BYTES
+ for READ, WRITE and MISC operation types.
+ */
+ PFS_file_io_stat_row m_io_stat;
+};
+
+/** Table PERFORMANCE_SCHEMA.FILE_SUMMARY_BY_EVENT_NAME. */
+class table_file_summary_by_event_name : public PFS_engine_table
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+private:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_file_summary_by_event_name();
+
+public:
+ ~table_file_summary_by_event_name()
+ {}
+
+private:
+ void make_row(PFS_file_class *klass);
+
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ /** Current row. */
+ row_file_summary_by_event_name m_row;
+ /** True if the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ PFS_simple_index m_pos;
+ /** Next position. */
+ PFS_simple_index m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_file_summary_by_instance.cc b/storage/perfschema/table_file_summary_by_instance.cc
new file mode 100644
index 00000000..b05d1f24
--- /dev/null
+++ b/storage/perfschema/table_file_summary_by_instance.cc
@@ -0,0 +1,279 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_file_summary_by_instance.cc
+ Table FILE_SUMMARY_BY_INSTANCE (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "pfs_instr_class.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "table_file_summary_by_instance.h"
+#include "pfs_global.h"
+#include "pfs_buffer_container.h"
+#include "field.h"
+
+THR_LOCK table_file_summary_by_instance::m_table_lock;
+
+PFS_engine_table_share
+table_file_summary_by_instance::m_share=
+{
+ { C_STRING_WITH_LEN("file_summary_by_instance") },
+ &pfs_truncatable_acl,
+ table_file_summary_by_instance::create,
+ NULL, /* write_row */
+ table_file_summary_by_instance::delete_all_rows,
+ table_file_summary_by_instance::get_row_count,
+ sizeof(PFS_simple_index),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE file_summary_by_instance("
+ "FILE_NAME VARCHAR(512) not null,"
+ "EVENT_NAME VARCHAR(128) not null,"
+ "OBJECT_INSTANCE_BEGIN BIGINT unsigned not null,"
+ "COUNT_STAR BIGINT unsigned not null,"
+ "SUM_TIMER_WAIT BIGINT unsigned not null,"
+ "MIN_TIMER_WAIT BIGINT unsigned not null,"
+ "AVG_TIMER_WAIT BIGINT unsigned not null,"
+ "MAX_TIMER_WAIT BIGINT unsigned not null,"
+ "COUNT_READ BIGINT unsigned not null,"
+ "SUM_TIMER_READ BIGINT unsigned not null,"
+ "MIN_TIMER_READ BIGINT unsigned not null,"
+ "AVG_TIMER_READ BIGINT unsigned not null,"
+ "MAX_TIMER_READ BIGINT unsigned not null,"
+ "SUM_NUMBER_OF_BYTES_READ BIGINT not null,"
+ "COUNT_WRITE BIGINT unsigned not null,"
+ "SUM_TIMER_WRITE BIGINT unsigned not null,"
+ "MIN_TIMER_WRITE BIGINT unsigned not null,"
+ "AVG_TIMER_WRITE BIGINT unsigned not null,"
+ "MAX_TIMER_WRITE BIGINT unsigned not null,"
+ "SUM_NUMBER_OF_BYTES_WRITE BIGINT not null,"
+ "COUNT_MISC BIGINT unsigned not null,"
+ "SUM_TIMER_MISC BIGINT unsigned not null,"
+ "MIN_TIMER_MISC BIGINT unsigned not null,"
+ "AVG_TIMER_MISC BIGINT unsigned not null,"
+ "MAX_TIMER_MISC BIGINT unsigned not null)") },
+ false /* perpetual */
+};
+
+PFS_engine_table* table_file_summary_by_instance::create(void)
+{
+ return new table_file_summary_by_instance();
+}
+
+int table_file_summary_by_instance::delete_all_rows(void)
+{
+ reset_file_instance_io();
+ return 0;
+}
+
+ha_rows
+table_file_summary_by_instance::get_row_count(void)
+{
+ return global_file_container.get_row_count();
+}
+
+table_file_summary_by_instance::table_file_summary_by_instance()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(0), m_next_pos(0)
+{}
+
+void table_file_summary_by_instance::reset_position(void)
+{
+ m_pos.m_index= 0;
+ m_next_pos.m_index= 0;
+}
+
+int table_file_summary_by_instance::rnd_next(void)
+{
+ PFS_file *pfs;
+
+ m_pos.set_at(&m_next_pos);
+ PFS_file_iterator it= global_file_container.iterate(m_pos.m_index);
+ pfs= it.scan_next(& m_pos.m_index);
+ if (pfs != NULL)
+ {
+ make_row(pfs);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int table_file_summary_by_instance::rnd_pos(const void *pos)
+{
+ PFS_file *pfs;
+
+ set_position(pos);
+
+ pfs= global_file_container.get(m_pos.m_index);
+ if (pfs != NULL)
+ {
+ make_row(pfs);
+ return 0;
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+/**
+ Build a row.
+ @param pfs the file the cursor is reading
+*/
+void table_file_summary_by_instance::make_row(PFS_file *pfs)
+{
+ pfs_optimistic_state lock;
+ PFS_file_class *safe_class;
+
+ m_row_exists= false;
+
+ /* Protect this reader against a file delete */
+ pfs->m_lock.begin_optimistic_lock(&lock);
+
+ safe_class= sanitize_file_class(pfs->m_class);
+ if (unlikely(safe_class == NULL))
+ return;
+
+ m_row.m_filename= pfs->m_filename;
+ m_row.m_filename_length= pfs->m_filename_length;
+ m_row.m_event_name.make_row(safe_class);
+ m_row.m_identity= pfs->m_identity;
+
+ time_normalizer *normalizer= time_normalizer::get(wait_timer);
+
+ /* Collect timer and byte count stats */
+ m_row.m_io_stat.set(normalizer, &pfs->m_file_stat.m_io_stat);
+
+ if (pfs->m_lock.end_optimistic_lock(&lock))
+ m_row_exists= true;
+}
+
+int table_file_summary_by_instance::read_row_values(TABLE *table,
+ unsigned char *,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 0);
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* FILE_NAME */
+ set_field_varchar_utf8(f, m_row.m_filename, m_row.m_filename_length);
+ break;
+ case 1: /* EVENT_NAME */
+ m_row.m_event_name.set_field(f);
+ break;
+ case 2: /* OBJECT_INSTANCE */
+ set_field_ulonglong(f, (ulonglong)m_row.m_identity);
+ break;
+
+ case 3:/* COUNT_STAR */
+ set_field_ulonglong(f, m_row.m_io_stat.m_all.m_waits.m_count);
+ break;
+ case 4:/* SUM_TIMER_WAIT */
+ set_field_ulonglong(f, m_row.m_io_stat.m_all.m_waits.m_sum);
+ break;
+ case 5: /* MIN_TIMER_WAIT */
+ set_field_ulonglong(f, m_row.m_io_stat.m_all.m_waits.m_min);
+ break;
+ case 6: /* AVG_TIMER_WAIT */
+ set_field_ulonglong(f, m_row.m_io_stat.m_all.m_waits.m_avg);
+ break;
+ case 7: /* MAX_TIMER_WAIT */
+ set_field_ulonglong(f, m_row.m_io_stat.m_all.m_waits.m_max);
+ break;
+
+ case 8: /* COUNT_READ */
+ set_field_ulonglong(f, m_row.m_io_stat.m_read.m_waits.m_count);
+ break;
+ case 9: /* SUM_TIMER_READ */
+ set_field_ulonglong(f, m_row.m_io_stat.m_read.m_waits.m_sum);
+ break;
+ case 10: /* MIN_TIMER_READ */
+ set_field_ulonglong(f, m_row.m_io_stat.m_read.m_waits.m_min);
+ break;
+ case 11: /* AVG_TIMER_READ */
+ set_field_ulonglong(f, m_row.m_io_stat.m_read.m_waits.m_avg);
+ break;
+ case 12: /* MAX_TIMER_READ */
+ set_field_ulonglong(f, m_row.m_io_stat.m_read.m_waits.m_max);
+ break;
+ case 13: /* SUM_NUMBER_OF_BYTES_READ */
+ set_field_ulonglong(f, m_row.m_io_stat.m_read.m_bytes);
+ break;
+
+ case 14: /* COUNT_WRITE */
+ set_field_ulonglong(f, m_row.m_io_stat.m_write.m_waits.m_count);
+ break;
+ case 15: /* SUM_TIMER_WRITE */
+ set_field_ulonglong(f, m_row.m_io_stat.m_write.m_waits.m_sum);
+ break;
+ case 16: /* MIN_TIMER_WRITE */
+ set_field_ulonglong(f, m_row.m_io_stat.m_write.m_waits.m_min);
+ break;
+ case 17: /* AVG_TIMER_WRITE */
+ set_field_ulonglong(f, m_row.m_io_stat.m_write.m_waits.m_avg);
+ break;
+ case 18: /* MAX_TIMER_WRITE */
+ set_field_ulonglong(f, m_row.m_io_stat.m_write.m_waits.m_max);
+ break;
+ case 19: /* SUM_NUMBER_OF_BYTES_WRITE */
+ set_field_ulonglong(f, m_row.m_io_stat.m_write.m_bytes);
+ break;
+
+ case 20: /* COUNT_MISC */
+ set_field_ulonglong(f, m_row.m_io_stat.m_misc.m_waits.m_count);
+ break;
+ case 21: /* SUM_TIMER_MISC */
+ set_field_ulonglong(f, m_row.m_io_stat.m_misc.m_waits.m_sum);
+ break;
+ case 22: /* MIN_TIMER_MISC */
+ set_field_ulonglong(f, m_row.m_io_stat.m_misc.m_waits.m_min);
+ break;
+ case 23: /* AVG_TIMER_MISC */
+ set_field_ulonglong(f, m_row.m_io_stat.m_misc.m_waits.m_avg);
+ break;
+ case 24: /* MAX_TIMER_MISC */
+ set_field_ulonglong(f, m_row.m_io_stat.m_misc.m_waits.m_max);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_file_summary_by_instance.h b/storage/perfschema/table_file_summary_by_instance.h
new file mode 100644
index 00000000..7ea90bac
--- /dev/null
+++ b/storage/perfschema/table_file_summary_by_instance.h
@@ -0,0 +1,105 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_FILE_SUMMARY_BY_INSTANCE_H
+#define TABLE_FILE_SUMMARY_BY_INSTANCE_H
+
+/**
+ @file storage/perfschema/table_file_summary_by_instance.h
+ Table FILE_SUMMARY_BY_INSTANCE (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "table_helper.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/** A row of PERFORMANCE_SCHEMA.FILE_SUMMARY_BY_INSTANCE. */
+struct row_file_summary_by_instance
+{
+ /** Column FILE_NAME. */
+ const char *m_filename;
+ /** Length in bytes of @c m_filename. */
+ uint m_filename_length;
+
+ /** Column EVENT_NAME. */
+ PFS_event_name_row m_event_name;
+
+ /** Column OBJECT_INSTANCE_BEGIN */
+ const void *m_identity;
+ /**
+ Columns COUNT_STAR, SUM/MIN/AVG/MAX TIMER and NUMBER_OF_BYTES for READ,
+ WRITE and MISC operation types.
+ */
+ PFS_file_io_stat_row m_io_stat;
+};
+
+/** Table PERFORMANCE_SCHEMA.FILE_SUMMARY_BY_INSTANCE. */
+class table_file_summary_by_instance : public PFS_engine_table
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+private:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_file_summary_by_instance();
+
+public:
+ ~table_file_summary_by_instance()
+ {}
+
+private:
+ void make_row(PFS_file *pfs);
+
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ /** Current row. */
+ row_file_summary_by_instance m_row;
+ /** True if the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ PFS_simple_index m_pos;
+ /** Next position. */
+ PFS_simple_index m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_global_status.cc b/storage/perfschema/table_global_status.cc
new file mode 100644
index 00000000..a8d5bacf
--- /dev/null
+++ b/storage/perfschema/table_global_status.cc
@@ -0,0 +1,190 @@
+/* Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
+
+/**
+ @file storage/perfschema/table_global_status.cc
+ Table global_status (implementation).
+*/
+
+#include "my_global.h"
+#include "table_global_status.h"
+#include "my_thread.h"
+#include "pfs_instr_class.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "pfs_global.h"
+
+THR_LOCK table_global_status::m_table_lock;
+
+PFS_engine_table_share
+table_global_status::m_share=
+{
+ { C_STRING_WITH_LEN("global_status") },
+ &pfs_truncatable_world_acl,
+ table_global_status::create,
+ NULL, /* write_row */
+ table_global_status::delete_all_rows,
+ table_global_status::get_row_count,
+ sizeof(pos_t),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE global_status("
+ "VARIABLE_NAME VARCHAR(64) not null,"
+ "VARIABLE_VALUE VARCHAR(1024))") },
+ true /* perpetual */
+};
+
+PFS_engine_table*
+table_global_status::create(void)
+{
+ return new table_global_status();
+}
+
+int table_global_status::delete_all_rows(void)
+{
+ mysql_mutex_lock(&LOCK_status);
+ reset_status_by_thread();
+ reset_status_by_account();
+ reset_status_by_user();
+ reset_status_by_host();
+ reset_global_status();
+ mysql_mutex_unlock(&LOCK_status);
+ return 0;
+}
+
+ha_rows table_global_status::get_row_count(void)
+{
+ mysql_mutex_lock(&LOCK_status);
+ ha_rows status_var_count= all_status_vars.elements;
+ mysql_mutex_unlock(&LOCK_status);
+ return status_var_count;
+}
+
+table_global_status::table_global_status()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_status_cache(false), m_row_exists(false), m_pos(0), m_next_pos(0)
+{}
+
+void table_global_status::reset_position(void)
+{
+ m_pos.m_index= 0;
+ m_next_pos.m_index= 0;
+}
+
+int table_global_status::rnd_init(bool scan)
+{
+ /* Build a cache of all global status variables. Sum across threads. */
+ m_status_cache.materialize_global();
+
+ /* Record the current number of status variables to detect subsequent changes. */
+ ulonglong status_version= m_status_cache.get_status_array_version();
+
+ /*
+ The table context holds the current version of the global status array.
+ If scan == true, then allocate a new context from mem_root and store in TLS.
+ If scan == false, then restore from TLS.
+ */
+ m_context= (table_global_status_context *)current_thd->alloc(sizeof(table_global_status_context));
+ new(m_context) table_global_status_context(status_version, !scan);
+ return 0;
+}
+
+int table_global_status::rnd_next(void)
+{
+ for (m_pos.set_at(&m_next_pos);
+ m_pos.m_index < m_status_cache.size();
+ m_pos.next())
+ {
+ const Status_variable *status_var= m_status_cache.get(m_pos.m_index);
+ if (status_var != NULL)
+ {
+ make_row(status_var);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+ return HA_ERR_END_OF_FILE;
+}
+
+int table_global_status::rnd_pos(const void *pos)
+{
+ /* If global status array has changed, do nothing. */ // TODO: Issue warning
+ if (!m_context->versions_match())
+ return HA_ERR_RECORD_DELETED;
+
+ set_position(pos);
+ const Status_variable *status_var= m_status_cache.get(m_pos.m_index);
+ if (status_var != NULL)
+ {
+ make_row(status_var);
+ return 0;
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_global_status
+::make_row(const Status_variable *status_var)
+{
+ m_row_exists= false;
+ if (status_var->is_null())
+ return;
+ m_row.m_variable_name.make_row(status_var->m_name, status_var->m_name_length);
+ m_row.m_variable_value.make_row(status_var);
+ m_row_exists= true;
+}
+
+int table_global_status
+::read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* VARIABLE_NAME */
+ set_field_varchar_utf8(f, m_row.m_variable_name.m_str, m_row.m_variable_name.m_length);
+ break;
+ case 1: /* VARIABLE_VALUE */
+ m_row.m_variable_value.set_field(f);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_global_status.h b/storage/perfschema/table_global_status.h
new file mode 100644
index 00000000..a97ea9d0
--- /dev/null
+++ b/storage/perfschema/table_global_status.h
@@ -0,0 +1,118 @@
+/* Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
+
+#ifndef TABLE_GLOBAL_STATUS_H
+#define TABLE_GLOBAL_STATUS_H
+
+/**
+ @file storage/perfschema/table_global_status.h
+ Table global_status (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "pfs_variable.h"
+#include "table_helper.h"
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/**
+ A row of table
+ PERFORMANCE_SCHEMA.GLOBAL_STATUS.
+*/
+struct row_global_status
+{
+ /** Column VARIABLE_NAME. */
+ PFS_variable_name_row m_variable_name;
+ /** Column VARIABLE_VALUE. */
+ PFS_variable_value_row m_variable_value;
+};
+
+/**
+ Store and retrieve table state information for queries that reinstantiate
+ the table object.
+*/
+class table_global_status_context : public PFS_table_context
+{
+public:
+ table_global_status_context(ulonglong current_version, bool restore) :
+ PFS_table_context(current_version, restore, THR_PFS_SG) { }
+};
+
+/** Table PERFORMANCE_SCHEMA.GLOBAL_STATUS. */
+class table_global_status : public PFS_engine_table
+{
+ typedef PFS_simple_index pos_t;
+
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_init(bool scan);
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+ table_global_status();
+
+public:
+ ~table_global_status()
+ {}
+
+protected:
+ void make_row(const Status_variable *system_var);
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+ /** Fields definition. */
+ static TABLE_FIELD_DEF m_field_def;
+
+ /** Current THD variables. */
+ PFS_status_variable_cache m_status_cache;
+ /** Current row. */
+ row_global_status m_row;
+ /** True if the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ pos_t m_pos;
+ /** Next position. */
+ pos_t m_next_pos;
+
+ /** Table context with global status array version. */
+ table_global_status_context *m_context;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_global_variables.cc b/storage/perfschema/table_global_variables.cc
new file mode 100644
index 00000000..117e06e3
--- /dev/null
+++ b/storage/perfschema/table_global_variables.cc
@@ -0,0 +1,184 @@
+/* Copyright (c) 2015, 2018, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
+
+/**
+ @file storage/perfschema/table_global_variables.cc
+ Table GLOBAL_VARIABLES (implementation).
+*/
+
+#include "my_global.h"
+#include "table_global_variables.h"
+#include "my_thread.h"
+#include "pfs_instr_class.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "pfs_global.h"
+
+THR_LOCK table_global_variables::m_table_lock;
+
+PFS_engine_table_share
+table_global_variables::m_share=
+{
+ { C_STRING_WITH_LEN("global_variables") },
+ &pfs_readonly_world_acl,
+ table_global_variables::create,
+ NULL, /* write_row */
+ NULL, /* delete_all_rows */
+ table_global_variables::get_row_count,
+ sizeof(pos_t),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE global_variables("
+ "VARIABLE_NAME VARCHAR(64) not null,"
+ "VARIABLE_VALUE VARCHAR(1024))") },
+ true /* perpetual */
+};
+
+PFS_engine_table*
+table_global_variables::create(void)
+{
+ return new table_global_variables();
+}
+
+ha_rows table_global_variables::get_row_count(void)
+{
+ mysql_mutex_lock(&LOCK_plugin_delete);
+ mysql_prlock_rdlock(&LOCK_system_variables_hash);
+ ha_rows system_var_count= get_system_variable_hash_records();
+ mysql_prlock_unlock(&LOCK_system_variables_hash);
+ mysql_mutex_unlock(&LOCK_plugin_delete);
+ return system_var_count;
+}
+
+table_global_variables::table_global_variables()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_sysvar_cache(false), m_row_exists(false), m_pos(0), m_next_pos(0)
+{}
+
+void table_global_variables::reset_position(void)
+{
+ m_pos.m_index= 0;
+ m_next_pos.m_index= 0;
+}
+
+int table_global_variables::rnd_init(bool scan)
+{
+ /*
+ Build a list of system variables from the global system variable hash.
+ Filter by scope.
+ */
+ m_sysvar_cache.materialize_global();
+
+ /* Record the version of the system variable hash. */
+ ulonglong hash_version= m_sysvar_cache.get_sysvar_hash_version();
+
+ /*
+ The table context holds the current version of the system variable hash.
+ If scan == true, then allocate a new context from mem_root and store in TLS.
+ If scan == false, then restore from TLS.
+ */
+ m_context= (table_global_variables_context *)current_thd->alloc(sizeof(table_global_variables_context));
+ new(m_context) table_global_variables_context(hash_version, !scan);
+ return 0;
+}
+
+int table_global_variables::rnd_next(void)
+{
+ for (m_pos.set_at(&m_next_pos);
+ m_pos.m_index < m_sysvar_cache.size();
+ m_pos.next())
+ {
+ const System_variable *system_var= m_sysvar_cache.get(m_pos.m_index);
+ if (system_var != NULL)
+ {
+ make_row(system_var);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+ return HA_ERR_END_OF_FILE;
+}
+
+int table_global_variables::rnd_pos(const void *pos)
+{
+ /* If system variable hash changes, do nothing. */ // TODO: Issue warning
+ if (!m_context->versions_match())
+ return HA_ERR_RECORD_DELETED;
+
+ set_position(pos);
+ DBUG_ASSERT(m_pos.m_index < m_sysvar_cache.size());
+
+ const System_variable *system_var= m_sysvar_cache.get(m_pos.m_index);
+ if (system_var != NULL)
+ {
+ make_row(system_var);
+ return 0;
+ }
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_global_variables
+::make_row(const System_variable *system_var)
+{
+ m_row_exists= false;
+ if (system_var->is_null() || system_var->is_ignored())
+ return;
+ m_row.m_variable_name.make_row(system_var->m_name, system_var->m_name_length);
+ m_row.m_variable_value.make_row(system_var);
+ m_row_exists= true;
+}
+
+int table_global_variables
+::read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* VARIABLE_NAME */
+ set_field_varchar_utf8(f, m_row.m_variable_name.m_str, m_row.m_variable_name.m_length);
+ break;
+ case 1: /* VARIABLE_VALUE */
+ m_row.m_variable_value.set_field(f);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_global_variables.h b/storage/perfschema/table_global_variables.h
new file mode 100644
index 00000000..b9124e76
--- /dev/null
+++ b/storage/perfschema/table_global_variables.h
@@ -0,0 +1,117 @@
+/* Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
+
+#ifndef TABLE_GLOBAL_VARIABLES_H
+#define TABLE_GLOBAL_VARIABLES_H
+
+/**
+ @file storage/perfschema/table_global_variables.h
+ Table GLOBAL_VARIABLES (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "pfs_variable.h"
+#include "table_helper.h"
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/**
+ Store and retrieve table state information during queries that reinstantiate
+ the table object.
+*/
+class table_global_variables_context : public PFS_table_context
+{
+public:
+ table_global_variables_context(ulonglong hash_version, bool restore) :
+ PFS_table_context(hash_version, restore, THR_PFS_VG) {}
+};
+
+/**
+ A row of table
+ PERFORMANCE_SCHEMA.GLOBAL_VARIABLES.
+*/
+struct row_global_variables
+{
+ /** Column VARIABLE_NAME. */
+ PFS_variable_name_row m_variable_name;
+ /** Column VARIABLE_VALUE. */
+ PFS_variable_value_row m_variable_value;
+};
+
+/** Table PERFORMANCE_SCHEMA.GLOBAL_VARIABLES. */
+class table_global_variables : public PFS_engine_table
+{
+ typedef PFS_simple_index pos_t;
+
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static ha_rows get_row_count();
+
+ virtual int rnd_init(bool scan);
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+ table_global_variables();
+
+public:
+ ~table_global_variables()
+ {}
+
+protected:
+ void make_row(const System_variable *system_var);
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+ /** Fields definition. */
+ static TABLE_FIELD_DEF m_field_def;
+
+ /** Current THD variables. */
+ PFS_system_variable_cache m_sysvar_cache;
+ /** Current row. */
+ row_global_variables m_row;
+ /** True if the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ pos_t m_pos;
+ /** Next position. */
+ pos_t m_next_pos;
+
+ /** Table context with system variable hash version. */
+ table_global_variables_context *m_context;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_helper.cc b/storage/perfschema/table_helper.cc
new file mode 100644
index 00000000..55b13971
--- /dev/null
+++ b/storage/perfschema/table_helper.cc
@@ -0,0 +1,896 @@
+/* Copyright (c) 2010, 2016, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_helper.cc
+ Performance schema table helpers (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "pfs_engine_table.h"
+#include "table_helper.h"
+#include "pfs_host.h"
+#include "pfs_user.h"
+#include "pfs_account.h"
+#include "pfs_instr.h"
+#include "pfs_program.h"
+#include "field.h"
+#include "pfs_variable.h"
+
+int PFS_host_row::make_row(PFS_host *pfs)
+{
+ m_hostname_length= pfs->m_hostname_length;
+ if (m_hostname_length > sizeof(m_hostname))
+ return 1;
+ if (m_hostname_length > 0)
+ memcpy(m_hostname, pfs->m_hostname, sizeof(m_hostname));
+ return 0;
+}
+
+void PFS_host_row::set_field(Field *f)
+{
+ if (m_hostname_length > 0)
+ PFS_engine_table::set_field_char_utf8(f, m_hostname, m_hostname_length);
+ else
+ f->set_null();
+}
+
+int PFS_user_row::make_row(PFS_user *pfs)
+{
+ m_username_length= pfs->m_username_length;
+ if (m_username_length > sizeof(m_username))
+ return 1;
+ if (m_username_length > 0)
+ memcpy(m_username, pfs->m_username, sizeof(m_username));
+ return 0;
+}
+
+void PFS_user_row::set_field(Field *f)
+{
+ if (m_username_length > 0)
+ PFS_engine_table::set_field_char_utf8(f, m_username, m_username_length);
+ else
+ f->set_null();
+}
+
+int PFS_account_row::make_row(PFS_account *pfs)
+{
+ m_username_length= pfs->m_username_length;
+ if (m_username_length > sizeof(m_username))
+ return 1;
+ if (m_username_length > 0)
+ memcpy(m_username, pfs->m_username, sizeof(m_username));
+
+ m_hostname_length= pfs->m_hostname_length;
+ if (m_hostname_length > sizeof(m_hostname))
+ return 1;
+ if (m_hostname_length > 0)
+ memcpy(m_hostname, pfs->m_hostname, sizeof(m_hostname));
+
+ return 0;
+}
+
+void PFS_account_row::set_field(uint index, Field *f)
+{
+ switch (index)
+ {
+ case 0: /* USER */
+ if (m_username_length > 0)
+ PFS_engine_table::set_field_char_utf8(f, m_username, m_username_length);
+ else
+ f->set_null();
+ break;
+ case 1: /* HOST */
+ if (m_hostname_length > 0)
+ PFS_engine_table::set_field_char_utf8(f, m_hostname, m_hostname_length);
+ else
+ f->set_null();
+ break;
+ default:
+ DBUG_ASSERT(false);
+ break;
+ }
+}
+
+int PFS_digest_row::make_row(PFS_statements_digest_stat* pfs)
+{
+ m_schema_name_length= pfs->m_digest_key.m_schema_name_length;
+ if (m_schema_name_length > sizeof(m_schema_name))
+ m_schema_name_length= 0;
+ if (m_schema_name_length > 0)
+ memcpy(m_schema_name, pfs->m_digest_key.m_schema_name, m_schema_name_length);
+
+ size_t safe_byte_count= pfs->m_digest_storage.m_byte_count;
+ if (safe_byte_count > pfs_max_digest_length)
+ safe_byte_count= 0;
+
+ /*
+ "0" value for byte_count indicates special entry i.e. aggregated
+ stats at index 0 of statements_digest_stat_array. So do not calculate
+ digest/digest_text as it should always be "NULL".
+ */
+ if (safe_byte_count > 0)
+ {
+ /*
+ Calculate digest from MD5 HASH collected to be shown as
+ DIGEST in this row.
+ */
+ MD5_HASH_TO_STRING(pfs->m_digest_storage.m_md5, m_digest);
+ m_digest_length= MD5_HASH_TO_STRING_LENGTH;
+
+ /*
+ Calculate digest_text information from the token array collected
+ to be shown as DIGEST_TEXT column.
+ */
+ compute_digest_text(&pfs->m_digest_storage, &m_digest_text);
+
+ if (m_digest_text.length() == 0)
+ m_digest_length= 0;
+ }
+ else
+ {
+ m_digest_length= 0;
+ }
+
+ return 0;
+}
+
+void PFS_digest_row::set_field(uint index, Field *f)
+{
+ switch (index)
+ {
+ case 0: /* SCHEMA_NAME */
+ if (m_schema_name_length > 0)
+ PFS_engine_table::set_field_varchar_utf8(f, m_schema_name,
+ m_schema_name_length);
+ else
+ f->set_null();
+ break;
+ case 1: /* DIGEST */
+ if (m_digest_length > 0)
+ PFS_engine_table::set_field_varchar_utf8(f, m_digest,
+ m_digest_length);
+ else
+ f->set_null();
+ break;
+ case 2: /* DIGEST_TEXT */
+ if (m_digest_text.length() > 0)
+ PFS_engine_table::set_field_longtext_utf8(f, m_digest_text.ptr(),
+ m_digest_text.length());
+ else
+ f->set_null();
+ break;
+ default:
+ DBUG_ASSERT(false);
+ break;
+ }
+}
+
+int PFS_object_row::make_row(PFS_table_share *pfs)
+{
+ m_object_type= pfs->get_object_type();
+
+ m_schema_name_length= pfs->m_schema_name_length;
+ if (m_schema_name_length > sizeof(m_schema_name))
+ return 1;
+ if (m_schema_name_length > 0)
+ memcpy(m_schema_name, pfs->m_schema_name, sizeof(m_schema_name));
+
+ m_object_name_length= pfs->m_table_name_length;
+ if (m_object_name_length > sizeof(m_object_name))
+ return 1;
+ if (m_object_name_length > 0)
+ memcpy(m_object_name, pfs->m_table_name, sizeof(m_object_name));
+
+ return 0;
+}
+
+int PFS_object_row::make_row(PFS_program *pfs)
+{
+ m_object_type= pfs->m_type;
+
+ m_schema_name_length= pfs->m_schema_name_length;
+ if (m_schema_name_length > sizeof(m_schema_name))
+ return 1;
+ if (m_schema_name_length > 0)
+ memcpy(m_schema_name, pfs->m_schema_name, sizeof(m_schema_name));
+
+ m_object_name_length= pfs->m_object_name_length;
+ if (m_object_name_length > sizeof(m_object_name))
+ return 1;
+ if (m_object_name_length > 0)
+ memcpy(m_object_name, pfs->m_object_name, sizeof(m_object_name));
+
+ return 0;
+}
+
+int PFS_object_row::make_row(const MDL_key *mdl)
+{
+ MDL_key user_lock_workaround;
+ switch(mdl->mdl_namespace())
+ {
+ case MDL_key::BACKUP:
+ m_object_type= OBJECT_TYPE_BACKUP;
+ m_schema_name_length= 0;
+ m_object_name_length= 0;
+ break;
+ case MDL_key::SCHEMA:
+ m_object_type= OBJECT_TYPE_SCHEMA;
+ m_schema_name_length= mdl->db_name_length();
+ m_object_name_length= 0;
+ break;
+ case MDL_key::TABLE:
+ m_object_type= OBJECT_TYPE_TABLE;
+ m_schema_name_length= mdl->db_name_length();
+ m_object_name_length= mdl->name_length();
+ break;
+ case MDL_key::FUNCTION:
+ m_object_type= OBJECT_TYPE_FUNCTION;
+ m_schema_name_length= mdl->db_name_length();
+ m_object_name_length= mdl->name_length();
+ break;
+ case MDL_key::PROCEDURE:
+ m_object_type= OBJECT_TYPE_PROCEDURE;
+ m_schema_name_length= mdl->db_name_length();
+ m_object_name_length= mdl->name_length();
+ break;
+ case MDL_key::PACKAGE_BODY:
+ m_object_type= OBJECT_TYPE_PACKAGE_BODY;
+ m_schema_name_length= mdl->db_name_length();
+ m_object_name_length= mdl->name_length();
+ break;
+ case MDL_key::TRIGGER:
+ m_object_type= OBJECT_TYPE_TRIGGER;
+ m_schema_name_length= mdl->db_name_length();
+ m_object_name_length= mdl->name_length();
+ break;
+ case MDL_key::EVENT:
+ m_object_type= OBJECT_TYPE_EVENT;
+ m_schema_name_length= mdl->db_name_length();
+ m_object_name_length= mdl->name_length();
+ break;
+ case MDL_key::USER_LOCK:
+ m_object_type= OBJECT_TYPE_USER_LEVEL_LOCK;
+ user_lock_workaround.mdl_key_init(MDL_key::USER_LOCK, "", mdl->db_name());
+ mdl=& user_lock_workaround;
+ m_schema_name_length= 0;
+ m_object_name_length= mdl->name_length();
+ break;
+ case MDL_key::NAMESPACE_END:
+ default:
+ m_object_type= NO_OBJECT_TYPE;
+ m_schema_name_length= 0;
+ m_object_name_length= 0;
+ break;
+ }
+
+ if (m_schema_name_length > sizeof(m_schema_name))
+ return 1;
+ if (m_schema_name_length > 0)
+ memcpy(m_schema_name, mdl->db_name(), m_schema_name_length);
+
+ if (m_object_name_length > sizeof(m_object_name))
+ return 1;
+ if (m_object_name_length > 0)
+ memcpy(m_object_name, mdl->name(), m_object_name_length);
+
+ return 0;
+}
+
+void PFS_object_row::set_field(uint index, Field *f)
+{
+ switch(index)
+ {
+ case 0: /* OBJECT_TYPE */
+ set_field_object_type(f, m_object_type);
+ break;
+ case 1: /* SCHEMA_NAME */
+ PFS_engine_table::set_field_varchar_utf8(f, m_schema_name, m_schema_name_length);
+ break;
+ case 2: /* OBJECT_NAME */
+ PFS_engine_table::set_field_varchar_utf8(f, m_object_name, m_object_name_length);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+}
+
+void PFS_object_row::set_nullable_field(uint index, Field *f)
+{
+ switch(index)
+ {
+ case 0: /* OBJECT_TYPE */
+ if (m_object_type != NO_OBJECT_TYPE)
+ set_field_object_type(f, m_object_type);
+ else
+ f->set_null();
+ break;
+ case 1: /* SCHEMA_NAME */
+ if (m_schema_name_length > 0)
+ PFS_engine_table::set_field_varchar_utf8(f, m_schema_name, m_schema_name_length);
+ else
+ f->set_null();
+ break;
+ case 2: /* OBJECT_NAME */
+ if (m_object_name_length > 0)
+ PFS_engine_table::set_field_varchar_utf8(f, m_object_name, m_object_name_length);
+ else
+ f->set_null();
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+}
+
+int PFS_index_row::make_row(PFS_table_share *pfs,
+ PFS_table_share_index *pfs_index,
+ uint table_index)
+{
+ if (m_object_row.make_row(pfs))
+ return 1;
+
+ if (pfs_index == NULL)
+ {
+ if (table_index < MAX_INDEXES)
+ {
+ m_index_name_length= sprintf(m_index_name, "(index %d)", table_index);
+ }
+ else
+ {
+ m_index_name_length= 0;
+ }
+ return 0;
+ }
+
+ if (table_index < MAX_INDEXES)
+ {
+ m_index_name_length= pfs_index->m_key.m_name_length;
+ if (m_index_name_length > sizeof(m_index_name))
+ return 1;
+
+ memcpy(m_index_name, pfs_index->m_key.m_name, sizeof(m_index_name));
+ }
+ else
+ {
+ m_index_name_length= 0;
+ }
+
+ return 0;
+}
+
+void PFS_index_row::set_field(uint index, Field *f)
+{
+ switch(index)
+ {
+ case 0: /* OBJECT_TYPE */
+ case 1: /* SCHEMA_NAME */
+ case 2: /* OBJECT_NAME */
+ m_object_row.set_field(index, f);
+ break;
+ case 3: /* INDEX_NAME */
+ if (m_index_name_length > 0)
+ PFS_engine_table::set_field_varchar_utf8(f, m_index_name, m_index_name_length);
+ else
+ f->set_null();
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+}
+
+void PFS_statement_stat_row::set_field(uint index, Field *f)
+{
+ switch (index)
+ {
+ case 0: /* COUNT_STAR */
+ case 1: /* SUM_TIMER_WAIT */
+ case 2: /* MIN_TIMER_WAIT */
+ case 3: /* AVG_TIMER_WAIT */
+ case 4: /* MAX_TIMER_WAIT */
+ m_timer1_row.set_field(index, f);
+ break;
+ case 5: /* SUM_LOCK_TIME */
+ PFS_engine_table::set_field_ulonglong(f, m_lock_time);
+ break;
+ case 6: /* SUM_ERRORS */
+ PFS_engine_table::set_field_ulonglong(f, m_error_count);
+ break;
+ case 7: /* SUM_WARNINGS */
+ PFS_engine_table::set_field_ulonglong(f, m_warning_count);
+ break;
+ case 8: /* SUM_ROWS_AFFECTED */
+ PFS_engine_table::set_field_ulonglong(f, m_rows_affected);
+ break;
+ case 9: /* SUM_ROWS_SENT */
+ PFS_engine_table::set_field_ulonglong(f, m_rows_sent);
+ break;
+ case 10: /* SUM_ROWS_EXAMINED */
+ PFS_engine_table::set_field_ulonglong(f, m_rows_examined);
+ break;
+ case 11: /* SUM_CREATED_TMP_DISK_TABLES */
+ PFS_engine_table::set_field_ulonglong(f, m_created_tmp_disk_tables);
+ break;
+ case 12: /* SUM_CREATED_TMP_TABLES */
+ PFS_engine_table::set_field_ulonglong(f, m_created_tmp_tables);
+ break;
+ case 13: /* SUM_SELECT_FULL_JOIN */
+ PFS_engine_table::set_field_ulonglong(f, m_select_full_join);
+ break;
+ case 14: /* SUM_SELECT_FULL_RANGE_JOIN */
+ PFS_engine_table::set_field_ulonglong(f, m_select_full_range_join);
+ break;
+ case 15: /* SUM_SELECT_RANGE */
+ PFS_engine_table::set_field_ulonglong(f, m_select_range);
+ break;
+ case 16: /* SUM_SELECT_RANGE_CHECK */
+ PFS_engine_table::set_field_ulonglong(f, m_select_range_check);
+ break;
+ case 17: /* SUM_SELECT_SCAN */
+ PFS_engine_table::set_field_ulonglong(f, m_select_scan);
+ break;
+ case 18: /* SUM_SORT_MERGE_PASSES */
+ PFS_engine_table::set_field_ulonglong(f, m_sort_merge_passes);
+ break;
+ case 19: /* SUM_SORT_RANGE */
+ PFS_engine_table::set_field_ulonglong(f, m_sort_range);
+ break;
+ case 20: /* SUM_SORT_ROWS */
+ PFS_engine_table::set_field_ulonglong(f, m_sort_rows);
+ break;
+ case 21: /* SUM_SORT_SCAN */
+ PFS_engine_table::set_field_ulonglong(f, m_sort_scan);
+ break;
+ case 22: /* SUM_NO_INDEX_USED */
+ PFS_engine_table::set_field_ulonglong(f, m_no_index_used);
+ break;
+ case 23: /* SUM_NO_GOOD_INDEX_USED */
+ PFS_engine_table::set_field_ulonglong(f, m_no_good_index_used);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ break;
+ }
+}
+
+void PFS_transaction_stat_row::set_field(uint index, Field *f)
+{
+ switch (index)
+ {
+ case 0: /* COUNT_STAR */
+ case 1: /* SUM_TIMER_WAIT */
+ case 2: /* MIN_TIMER_WAIT */
+ case 3: /* AVG_TIMER_WAIT */
+ case 4: /* MAX_TIMER_WAIT */
+ m_timer1_row.set_field(index, f);
+ break;
+ case 5: /* COUNT_READ_WRITE */
+ case 6: /* SUM_TIMER_READ_WRITE */
+ case 7: /* MIN_TIMER_READ_WRITE */
+ case 8: /* AVG_TIMER_READ_WRITE */
+ case 9: /* MAX_TIMER_READ_WRITE */
+ m_read_write_row.set_field(index-5, f);
+ break;
+ case 10: /* COUNT_READ_ONLY */
+ case 11: /* SUM_TIMER_READ_ONLY */
+ case 12: /* MIN_TIMER_READ_ONLY */
+ case 13: /* AVG_TIMER_READ_ONLY */
+ case 14: /* MAX_TIMER_READ_ONLY */
+ m_read_only_row.set_field(index-10, f);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ break;
+ }
+}
+
+void PFS_connection_stat_row::set_field(uint index, Field *f)
+{
+ switch (index)
+ {
+ case 0: /* CURRENT_CONNECTIONS */
+ PFS_engine_table::set_field_ulonglong(f, m_current_connections);
+ break;
+ case 1: /* TOTAL_CONNECTIONS */
+ PFS_engine_table::set_field_ulonglong(f, m_total_connections);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ break;
+ }
+}
+
+void set_field_object_type(Field *f, enum_object_type object_type)
+{
+ switch (object_type)
+ {
+ case OBJECT_TYPE_EVENT:
+ PFS_engine_table::set_field_varchar_utf8(f, "EVENT", 5);
+ break;
+ case OBJECT_TYPE_FUNCTION:
+ PFS_engine_table::set_field_varchar_utf8(f, "FUNCTION", 8);
+ break;
+ case OBJECT_TYPE_PROCEDURE:
+ PFS_engine_table::set_field_varchar_utf8(f, "PROCEDURE", 9);
+ break;
+ case OBJECT_TYPE_TABLE:
+ PFS_engine_table::set_field_varchar_utf8(f, "TABLE", 5);
+ break;
+ case OBJECT_TYPE_TEMPORARY_TABLE:
+ PFS_engine_table::set_field_varchar_utf8(f, "TEMPORARY TABLE", 15);
+ break;
+ case OBJECT_TYPE_TRIGGER:
+ PFS_engine_table::set_field_varchar_utf8(f, "TRIGGER", 7);
+ break;
+ case OBJECT_TYPE_BACKUP:
+ PFS_engine_table::set_field_varchar_utf8(f, "BACKUP", 6);
+ break;
+ case OBJECT_TYPE_SCHEMA:
+ PFS_engine_table::set_field_varchar_utf8(f, "SCHEMA", 6);
+ break;
+ case OBJECT_TYPE_PACKAGE_BODY:
+ PFS_engine_table::set_field_varchar_utf8(f, "PACKAGE BODY", 12);
+ break;
+ case OBJECT_TYPE_USER_LEVEL_LOCK:
+ PFS_engine_table::set_field_varchar_utf8(f, "USER LEVEL LOCK", 15);
+ break;
+ case NO_OBJECT_TYPE:
+ default:
+ DBUG_ASSERT(false);
+ PFS_engine_table::set_field_varchar_utf8(f, "", 0);
+ break;
+ }
+}
+
+void set_field_lock_type(Field *f, PFS_TL_LOCK_TYPE lock_type)
+{
+ switch (lock_type)
+ {
+ case PFS_TL_READ:
+ PFS_engine_table::set_field_varchar_utf8(f, "READ", 4);
+ break;
+ case PFS_TL_READ_WITH_SHARED_LOCKS:
+ PFS_engine_table::set_field_varchar_utf8(f, "READ WITH SHARED LOCKS", 22);
+ break;
+ case PFS_TL_READ_HIGH_PRIORITY:
+ PFS_engine_table::set_field_varchar_utf8(f, "READ HIGH PRIORITY", 18);
+ break;
+ case PFS_TL_READ_NO_INSERT:
+ PFS_engine_table::set_field_varchar_utf8(f, "READ NO INSERT", 14);
+ break;
+ case PFS_TL_WRITE_ALLOW_WRITE:
+ PFS_engine_table::set_field_varchar_utf8(f, "WRITE ALLOW WRITE", 17);
+ break;
+ case PFS_TL_WRITE_CONCURRENT_INSERT:
+ PFS_engine_table::set_field_varchar_utf8(f, "WRITE CONCURRENT INSERT", 23);
+ break;
+ case PFS_TL_WRITE_LOW_PRIORITY:
+ PFS_engine_table::set_field_varchar_utf8(f, "WRITE LOW PRIORITY", 18);
+ break;
+ case PFS_TL_WRITE:
+ PFS_engine_table::set_field_varchar_utf8(f, "WRITE", 5);
+ break;
+ case PFS_TL_READ_EXTERNAL:
+ PFS_engine_table::set_field_varchar_utf8(f, "READ EXTERNAL", 13);
+ break;
+ case PFS_TL_WRITE_EXTERNAL:
+ PFS_engine_table::set_field_varchar_utf8(f, "WRITE EXTERNAL", 14);
+ break;
+ case PFS_TL_NONE:
+ f->set_null();
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+}
+
+void set_field_mdl_type(Field *f, opaque_mdl_type mdl_type, bool backup)
+{
+ if (backup)
+ {
+ switch (mdl_type)
+ {
+ case MDL_BACKUP_START:
+ PFS_engine_table::set_field_varchar_utf8(f, STRING_WITH_LEN("BACKUP_START"));
+ break;
+ case MDL_BACKUP_FLUSH:
+ PFS_engine_table::set_field_varchar_utf8(f, STRING_WITH_LEN("BACKUP_FLUSH"));
+ break;
+ case MDL_BACKUP_WAIT_FLUSH:
+ PFS_engine_table::set_field_varchar_utf8(f, STRING_WITH_LEN("BACKUP_WAIT_FLUSH"));
+ break;
+ case MDL_BACKUP_WAIT_DDL:
+ PFS_engine_table::set_field_varchar_utf8(f, STRING_WITH_LEN("BACKUP_WAIT_DDL"));
+ break;
+ case MDL_BACKUP_WAIT_COMMIT:
+ PFS_engine_table::set_field_varchar_utf8(f, STRING_WITH_LEN("BACKUP_WAIT_COMMIT"));
+ break;
+ case MDL_BACKUP_FTWRL1:
+ PFS_engine_table::set_field_varchar_utf8(f, STRING_WITH_LEN("BACKUP_FTWRL1"));
+ break;
+ case MDL_BACKUP_FTWRL2:
+ PFS_engine_table::set_field_varchar_utf8(f, STRING_WITH_LEN("BACKUP_FTWRL2"));
+ break;
+ case MDL_BACKUP_DML:
+ PFS_engine_table::set_field_varchar_utf8(f, STRING_WITH_LEN("BACKUP_DML"));
+ break;
+ case MDL_BACKUP_TRANS_DML:
+ PFS_engine_table::set_field_varchar_utf8(f, STRING_WITH_LEN("BACKUP_TRANS_DML"));
+ break;
+ case MDL_BACKUP_SYS_DML:
+ PFS_engine_table::set_field_varchar_utf8(f, STRING_WITH_LEN("BACKUP_SYS_DML"));
+ break;
+ case MDL_BACKUP_DDL:
+ PFS_engine_table::set_field_varchar_utf8(f, STRING_WITH_LEN("BACKUP_DDL"));
+ break;
+ case MDL_BACKUP_BLOCK_DDL:
+ PFS_engine_table::set_field_varchar_utf8(f, STRING_WITH_LEN("BACKUP_BLOCK_DDL"));
+ break;
+ case MDL_BACKUP_ALTER_COPY:
+ PFS_engine_table::set_field_varchar_utf8(f, STRING_WITH_LEN("BACKUP_ALTER_COPY"));
+ break;
+ case MDL_BACKUP_COMMIT:
+ PFS_engine_table::set_field_varchar_utf8(f, STRING_WITH_LEN("BACKUP_COMMIT"));
+ break;
+ case MDL_BACKUP_END:
+ PFS_engine_table::set_field_varchar_utf8(f, STRING_WITH_LEN("BACKUP_END"));
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ else
+ {
+ enum_mdl_type e= (enum_mdl_type) mdl_type;
+ switch (e)
+ {
+ case MDL_INTENTION_EXCLUSIVE:
+ PFS_engine_table::set_field_varchar_utf8(f, "INTENTION_EXCLUSIVE", 19);
+ break;
+ case MDL_SHARED:
+ PFS_engine_table::set_field_varchar_utf8(f, "SHARED", 6);
+ break;
+ case MDL_SHARED_HIGH_PRIO:
+ PFS_engine_table::set_field_varchar_utf8(f, "SHARED_HIGH_PRIO", 16);
+ break;
+ case MDL_SHARED_READ:
+ PFS_engine_table::set_field_varchar_utf8(f, "SHARED_READ", 11);
+ break;
+ case MDL_SHARED_WRITE:
+ PFS_engine_table::set_field_varchar_utf8(f, "SHARED_WRITE", 12);
+ break;
+ case MDL_SHARED_UPGRADABLE:
+ PFS_engine_table::set_field_varchar_utf8(f, "SHARED_UPGRADABLE", 17);
+ break;
+ case MDL_SHARED_NO_WRITE:
+ PFS_engine_table::set_field_varchar_utf8(f, "SHARED_NO_WRITE", 15);
+ break;
+ case MDL_SHARED_NO_READ_WRITE:
+ PFS_engine_table::set_field_varchar_utf8(f, "SHARED_NO_READ_WRITE", 20);
+ break;
+ case MDL_EXCLUSIVE:
+ PFS_engine_table::set_field_varchar_utf8(f, "EXCLUSIVE", 9);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+}
+
+void set_field_mdl_duration(Field *f, opaque_mdl_duration mdl_duration)
+{
+ enum_mdl_duration e= (enum_mdl_duration) mdl_duration;
+ switch (e)
+ {
+ case MDL_STATEMENT:
+ PFS_engine_table::set_field_varchar_utf8(f, "STATEMENT", 9);
+ break;
+ case MDL_TRANSACTION:
+ PFS_engine_table::set_field_varchar_utf8(f, "TRANSACTION", 11);
+ break;
+ case MDL_EXPLICIT:
+ PFS_engine_table::set_field_varchar_utf8(f, "EXPLICIT", 8);
+ break;
+ case MDL_DURATION_END:
+ default:
+ DBUG_ASSERT(false);
+ }
+}
+
+void set_field_mdl_status(Field *f, opaque_mdl_status mdl_status)
+{
+ MDL_ticket::enum_psi_status e= static_cast<MDL_ticket::enum_psi_status>(mdl_status);
+ switch (e)
+ {
+ case MDL_ticket::PENDING:
+ PFS_engine_table::set_field_varchar_utf8(f, "PENDING", 7);
+ break;
+ case MDL_ticket::GRANTED:
+ PFS_engine_table::set_field_varchar_utf8(f, "GRANTED", 7);
+ break;
+ case MDL_ticket::PRE_ACQUIRE_NOTIFY:
+ PFS_engine_table::set_field_varchar_utf8(f, "PRE_ACQUIRE_NOTIFY", 18);
+ break;
+ case MDL_ticket::POST_RELEASE_NOTIFY:
+ PFS_engine_table::set_field_varchar_utf8(f, "POST_RELEASE_NOTIFY", 19);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+}
+
+void PFS_memory_stat_row::set_field(uint index, Field *f)
+{
+ ssize_t val;
+
+ switch (index)
+ {
+ case 0: /* COUNT_ALLOC */
+ PFS_engine_table::set_field_ulonglong(f, m_stat.m_alloc_count);
+ break;
+ case 1: /* COUNT_FREE */
+ PFS_engine_table::set_field_ulonglong(f, m_stat.m_free_count);
+ break;
+ case 2: /* SUM_NUMBER_OF_BYTES_ALLOC */
+ PFS_engine_table::set_field_ulonglong(f, m_stat.m_alloc_size);
+ break;
+ case 3: /* SUM_NUMBER_OF_BYTES_FREE */
+ PFS_engine_table::set_field_ulonglong(f, m_stat.m_free_size);
+ break;
+ case 4: /* LOW_COUNT_USED */
+ val= m_stat.m_alloc_count - m_stat.m_free_count - m_stat.m_free_count_capacity;
+ PFS_engine_table::set_field_longlong(f, val);
+ break;
+ case 5: /* CURRENT_COUNT_USED */
+ val= m_stat.m_alloc_count - m_stat.m_free_count;
+ PFS_engine_table::set_field_longlong(f, val);
+ break;
+ case 6: /* HIGH_COUNT_USED */
+ val= m_stat.m_alloc_count - m_stat.m_free_count + m_stat.m_alloc_count_capacity;
+ PFS_engine_table::set_field_longlong(f, val);
+ break;
+ case 7: /* LOW_NUMBER_OF_BYTES_USED */
+ val= m_stat.m_alloc_size - m_stat.m_free_size - m_stat.m_free_size_capacity;
+ PFS_engine_table::set_field_longlong(f, val);
+ break;
+ case 8: /* CURRENT_NUMBER_OF_BYTES_USED */
+ val= m_stat.m_alloc_size - m_stat.m_free_size;
+ PFS_engine_table::set_field_longlong(f, val);
+ break;
+ case 9: /* HIGH_NUMBER_OF_BYTES_USED */
+ val= m_stat.m_alloc_size - m_stat.m_free_size + m_stat.m_alloc_size_capacity;
+ PFS_engine_table::set_field_longlong(f, val);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ break;
+ }
+}
+
+void set_field_isolation_level(Field *f, enum_isolation_level iso_level)
+{
+ switch (iso_level)
+ {
+ case TRANS_LEVEL_READ_UNCOMMITTED:
+ PFS_engine_table::set_field_varchar_utf8(f, "READ UNCOMMITTED", 16);
+ break;
+ case TRANS_LEVEL_READ_COMMITTED:
+ PFS_engine_table::set_field_varchar_utf8(f, "READ COMMITTED", 14);
+ break;
+ case TRANS_LEVEL_REPEATABLE_READ:
+ PFS_engine_table::set_field_varchar_utf8(f, "REPEATABLE READ", 15);
+ break;
+ case TRANS_LEVEL_SERIALIZABLE:
+ PFS_engine_table::set_field_varchar_utf8(f, "SERIALIZABLE", 12);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+}
+
+void set_field_xa_state(Field *f, enum_xa_transaction_state xa_state)
+{
+ switch (xa_state)
+ {
+ case TRANS_STATE_XA_NOTR:
+ PFS_engine_table::set_field_varchar_utf8(f, "NOTR", 4);
+ break;
+ case TRANS_STATE_XA_ACTIVE:
+ PFS_engine_table::set_field_varchar_utf8(f, "ACTIVE", 6);
+ break;
+ case TRANS_STATE_XA_IDLE:
+ PFS_engine_table::set_field_varchar_utf8(f, "IDLE", 4);
+ break;
+ case TRANS_STATE_XA_PREPARED:
+ PFS_engine_table::set_field_varchar_utf8(f, "PREPARED", 8);
+ break;
+ case TRANS_STATE_XA_ROLLBACK_ONLY:
+ PFS_engine_table::set_field_varchar_utf8(f, "ROLLBACK ONLY", 13);
+ break;
+ case TRANS_STATE_XA_COMMITTED:
+ PFS_engine_table::set_field_varchar_utf8(f, "COMMITTED", 9);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+}
+
+void PFS_variable_name_row::make_row(const char* str, size_t length)
+{
+ DBUG_ASSERT(length <= sizeof(m_str));
+ DBUG_ASSERT(length <= NAME_CHAR_LEN);
+
+ m_length= MY_MIN(static_cast<uint>(length), NAME_CHAR_LEN); /* enforce max name length */
+ if (m_length > 0)
+ memcpy(m_str, str, length);
+ m_str[m_length]= '\0';
+}
+
+void PFS_variable_value_row::make_row(const Status_variable *var)
+{
+ make_row(var->m_charset, var->m_value_str, var->m_value_length);
+}
+
+void PFS_variable_value_row::make_row(const System_variable *var)
+{
+ make_row(var->m_charset, var->m_value_str, var->m_value_length);
+}
+
+void PFS_variable_value_row::make_row(const CHARSET_INFO *cs, const char* str, size_t length)
+{
+ DBUG_ASSERT(cs != NULL);
+ DBUG_ASSERT(length <= sizeof(m_str));
+ if (length > 0)
+ {
+ memcpy(m_str, str, length);
+ }
+ m_length= static_cast<uint>(length);
+ m_charset= cs;
+}
+
+void PFS_variable_value_row::set_field(Field *f)
+{
+ PFS_engine_table::set_field_varchar(f, m_charset, m_str, m_length);
+}
+
+void PFS_user_variable_value_row::clear()
+{
+ my_free(m_value);
+ m_value= NULL;
+ m_value_length= 0;
+}
+
+void PFS_user_variable_value_row::make_row(const char* val, size_t length)
+{
+ if (length > 0)
+ {
+ m_value= (char*) my_malloc(PSI_NOT_INSTRUMENTED, length, MYF(0));
+ m_value_length= length;
+ memcpy(m_value, val, length);
+ }
+ else
+ {
+ m_value= NULL;
+ m_value_length= 0;
+ }
+}
+
diff --git a/storage/perfschema/table_helper.h b/storage/perfschema/table_helper.h
new file mode 100644
index 00000000..3ce74648
--- /dev/null
+++ b/storage/perfschema/table_helper.h
@@ -0,0 +1,702 @@
+/* Copyright (c) 2008, 2016, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef PFS_TABLE_HELPER_H
+#define PFS_TABLE_HELPER_H
+
+#include "pfs_column_types.h"
+#include "pfs_stat.h"
+#include "pfs_timer.h"
+#include "pfs_engine_table.h"
+#include "pfs_instr_class.h"
+#include "pfs_digest.h"
+
+/*
+ Write MD5 hash value in a string to be used
+ as DIGEST for the statement.
+*/
+#define MD5_HASH_TO_STRING(_hash, _str) \
+ sprintf(_str, "%02x%02x%02x%02x%02x%02x%02x%02x" \
+ "%02x%02x%02x%02x%02x%02x%02x%02x", \
+ _hash[0], _hash[1], _hash[2], _hash[3], \
+ _hash[4], _hash[5], _hash[6], _hash[7], \
+ _hash[8], _hash[9], _hash[10], _hash[11], \
+ _hash[12], _hash[13], _hash[14], _hash[15])
+
+#define MD5_HASH_TO_STRING_LENGTH 32
+
+struct PFS_host;
+struct PFS_user;
+struct PFS_account;
+struct PFS_object_name;
+struct PFS_program;
+class System_variable;
+class Status_variable;
+
+/**
+ @file storage/perfschema/table_helper.h
+ Performance schema table helpers (declarations).
+*/
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/** Namespace, internal views used within table setup_instruments. */
+struct PFS_instrument_view_constants
+{
+ static const uint FIRST_VIEW= 1;
+ static const uint VIEW_MUTEX= 1;
+ static const uint VIEW_RWLOCK= 2;
+ static const uint VIEW_COND= 3;
+ static const uint VIEW_FILE= 4;
+ static const uint VIEW_TABLE= 5;
+ static const uint VIEW_SOCKET= 6;
+ static const uint VIEW_IDLE= 7;
+ static const uint VIEW_METADATA= 8;
+ static const uint LAST_VIEW= 8;
+};
+
+/** Namespace, internal views used within object summaries. */
+struct PFS_object_view_constants
+{
+ static const uint FIRST_VIEW= 1;
+ static const uint VIEW_TABLE= 1;
+ static const uint VIEW_PROGRAM= 2;
+ static const uint LAST_VIEW= 2;
+};
+
+/** Row fragment for column HOST. */
+struct PFS_host_row
+{
+ /** Column HOST. */
+ char m_hostname[HOSTNAME_LENGTH];
+ /** Length in bytes of @c m_hostname. */
+ uint m_hostname_length;
+
+ /** Build a row from a memory buffer. */
+ int make_row(PFS_host *pfs);
+ /** Set a table field from the row. */
+ void set_field(Field *f);
+};
+
+/** Row fragment for column USER. */
+struct PFS_user_row
+{
+ /** Column USER. */
+ char m_username[USERNAME_LENGTH];
+ /** Length in bytes of @c m_username. */
+ uint m_username_length;
+
+ /** Build a row from a memory buffer. */
+ int make_row(PFS_user *pfs);
+ /** Set a table field from the row. */
+ void set_field(Field *f);
+};
+
+/** Row fragment for columns USER, HOST. */
+struct PFS_account_row
+{
+ /** Column USER. */
+ char m_username[USERNAME_LENGTH];
+ /** Length in bytes of @c m_username. */
+ uint m_username_length;
+ /** Column HOST. */
+ char m_hostname[HOSTNAME_LENGTH];
+ /** Length in bytes of @c m_hostname. */
+ uint m_hostname_length;
+
+ /** Build a row from a memory buffer. */
+ int make_row(PFS_account *pfs);
+ /** Set a table field from the row. */
+ void set_field(uint index, Field *f);
+};
+
+/** Row fragment for columns DIGEST, DIGEST_TEXT. */
+struct PFS_digest_row
+{
+ /** Column SCHEMA_NAME. */
+ char m_schema_name[NAME_LEN];
+ /** Length in bytes of @c m_schema_name. */
+ uint m_schema_name_length;
+ /** Column DIGEST. */
+ char m_digest[COL_DIGEST_SIZE];
+ /** Length in bytes of @c m_digest. */
+ uint m_digest_length;
+ /** Column DIGEST_TEXT. */
+ String m_digest_text;
+
+ /** Build a row from a memory buffer. */
+ int make_row(PFS_statements_digest_stat*);
+ /** Set a table field from the row. */
+ void set_field(uint index, Field *f);
+};
+
+/** Row fragment for column EVENT_NAME. */
+struct PFS_event_name_row
+{
+ /** Column EVENT_NAME. */
+ const char *m_name;
+ /** Length in bytes of @c m_name. */
+ uint m_name_length;
+
+ /** Build a row from a memory buffer. */
+ inline void make_row(PFS_instr_class *pfs)
+ {
+ m_name= pfs->m_name;
+ m_name_length= pfs->m_name_length;
+ }
+
+ /** Set a table field from the row. */
+ inline void set_field(Field *f)
+ {
+ PFS_engine_table::set_field_varchar_utf8(f, m_name, m_name_length);
+ }
+};
+
+/** Row fragment for columns OBJECT_TYPE, SCHEMA_NAME, OBJECT_NAME. */
+struct PFS_object_row
+{
+ /** Column OBJECT_TYPE. */
+ enum_object_type m_object_type;
+ /** Column SCHEMA_NAME. */
+ char m_schema_name[NAME_LEN];
+ /** Length in bytes of @c m_schema_name. */
+ uint m_schema_name_length;
+ /** Column OBJECT_NAME. */
+ char m_object_name[NAME_LEN];
+ /** Length in bytes of @c m_object_name. */
+ uint m_object_name_length;
+
+ /** Build a row from a memory buffer. */
+ int make_row(PFS_table_share *pfs);
+ int make_row(PFS_program *pfs);
+ int make_row(const MDL_key *pfs);
+ /** Set a table field from the row. */
+ void set_field(uint index, Field *f);
+ void set_nullable_field(uint index, Field *f);
+};
+
+/** Row fragment for columns OBJECT_TYPE, SCHEMA_NAME, OBJECT_NAME, INDEX_NAME. */
+struct PFS_index_row
+{
+ PFS_object_row m_object_row;
+ /** Column INDEX_NAME. */
+ char m_index_name[NAME_LEN];
+ /** Length in bytes of @c m_index_name. */
+ uint m_index_name_length;
+
+ /** Build a row from a memory buffer. */
+ int make_row(PFS_table_share *pfs, PFS_table_share_index *pfs_index,
+ uint table_index);
+ /** Set a table field from the row. */
+ void set_field(uint index, Field *f);
+};
+
+/** Row fragment for single statistics columns (COUNT, SUM, MIN, AVG, MAX) */
+struct PFS_stat_row
+{
+ /** Column COUNT_STAR. */
+ ulonglong m_count;
+ /** Column SUM_TIMER_WAIT. */
+ ulonglong m_sum;
+ /** Column MIN_TIMER_WAIT. */
+ ulonglong m_min;
+ /** Column AVG_TIMER_WAIT. */
+ ulonglong m_avg;
+ /** Column MAX_TIMER_WAIT. */
+ ulonglong m_max;
+
+ inline void reset()
+ {
+ m_count= 0;
+ m_sum= 0;
+ m_min= 0;
+ m_avg= 0;
+ m_max= 0;
+ }
+
+ /** Build a row with timer fields from a memory buffer. */
+ inline void set(time_normalizer *normalizer, const PFS_single_stat *stat)
+ {
+ m_count= stat->m_count;
+
+ if ((m_count != 0) && stat->has_timed_stats())
+ {
+ m_sum= normalizer->wait_to_pico(stat->m_sum);
+ m_min= normalizer->wait_to_pico(stat->m_min);
+ m_max= normalizer->wait_to_pico(stat->m_max);
+ m_avg= normalizer->wait_to_pico(stat->m_sum / m_count);
+ }
+ else
+ {
+ m_sum= 0;
+ m_min= 0;
+ m_avg= 0;
+ m_max= 0;
+ }
+ }
+
+ /** Set a table field from the row. */
+ void set_field(uint index, Field *f)
+ {
+ switch (index)
+ {
+ case 0: /* COUNT */
+ PFS_engine_table::set_field_ulonglong(f, m_count);
+ break;
+ case 1: /* SUM */
+ PFS_engine_table::set_field_ulonglong(f, m_sum);
+ break;
+ case 2: /* MIN */
+ PFS_engine_table::set_field_ulonglong(f, m_min);
+ break;
+ case 3: /* AVG */
+ PFS_engine_table::set_field_ulonglong(f, m_avg);
+ break;
+ case 4: /* MAX */
+ PFS_engine_table::set_field_ulonglong(f, m_max);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+};
+
+/** Row fragment for timer and byte count stats. Corresponds to PFS_byte_stat */
+struct PFS_byte_stat_row
+{
+ PFS_stat_row m_waits;
+ ulonglong m_bytes;
+
+ /** Build a row with timer and byte count fields from a memory buffer. */
+ inline void set(time_normalizer *normalizer, const PFS_byte_stat *stat)
+ {
+ m_waits.set(normalizer, stat);
+ m_bytes= stat->m_bytes;
+ }
+};
+
+/** Row fragment for table io statistics columns. */
+struct PFS_table_io_stat_row
+{
+ PFS_stat_row m_all;
+ PFS_stat_row m_all_read;
+ PFS_stat_row m_all_write;
+ PFS_stat_row m_fetch;
+ PFS_stat_row m_insert;
+ PFS_stat_row m_update;
+ PFS_stat_row m_delete;
+
+ /** Build a row from a memory buffer. */
+ inline void set(time_normalizer *normalizer, const PFS_table_io_stat *stat)
+ {
+ PFS_single_stat all_read;
+ PFS_single_stat all_write;
+ PFS_single_stat all;
+
+ m_fetch.set(normalizer, & stat->m_fetch);
+
+ all_read.aggregate(& stat->m_fetch);
+
+ m_insert.set(normalizer, & stat->m_insert);
+ m_update.set(normalizer, & stat->m_update);
+ m_delete.set(normalizer, & stat->m_delete);
+
+ all_write.aggregate(& stat->m_insert);
+ all_write.aggregate(& stat->m_update);
+ all_write.aggregate(& stat->m_delete);
+
+ all.aggregate(& all_read);
+ all.aggregate(& all_write);
+
+ m_all_read.set(normalizer, & all_read);
+ m_all_write.set(normalizer, & all_write);
+ m_all.set(normalizer, & all);
+ }
+};
+
+/** Row fragment for table lock statistics columns. */
+struct PFS_table_lock_stat_row
+{
+ PFS_stat_row m_all;
+ PFS_stat_row m_all_read;
+ PFS_stat_row m_all_write;
+ PFS_stat_row m_read_normal;
+ PFS_stat_row m_read_with_shared_locks;
+ PFS_stat_row m_read_high_priority;
+ PFS_stat_row m_read_no_insert;
+ PFS_stat_row m_read_external;
+ PFS_stat_row m_write_allow_write;
+ PFS_stat_row m_write_concurrent_insert;
+ PFS_stat_row m_write_delayed;
+ PFS_stat_row m_write_low_priority;
+ PFS_stat_row m_write_normal;
+ PFS_stat_row m_write_external;
+
+ /** Build a row from a memory buffer. */
+ inline void set(time_normalizer *normalizer, const PFS_table_lock_stat *stat)
+ {
+ PFS_single_stat all_read;
+ PFS_single_stat all_write;
+ PFS_single_stat all;
+
+ m_read_normal.set(normalizer, & stat->m_stat[PFS_TL_READ]);
+ m_read_with_shared_locks.set(normalizer, & stat->m_stat[PFS_TL_READ_WITH_SHARED_LOCKS]);
+ m_read_high_priority.set(normalizer, & stat->m_stat[PFS_TL_READ_HIGH_PRIORITY]);
+ m_read_no_insert.set(normalizer, & stat->m_stat[PFS_TL_READ_NO_INSERT]);
+ m_read_external.set(normalizer, & stat->m_stat[PFS_TL_READ_EXTERNAL]);
+
+ all_read.aggregate(& stat->m_stat[PFS_TL_READ]);
+ all_read.aggregate(& stat->m_stat[PFS_TL_READ_WITH_SHARED_LOCKS]);
+ all_read.aggregate(& stat->m_stat[PFS_TL_READ_HIGH_PRIORITY]);
+ all_read.aggregate(& stat->m_stat[PFS_TL_READ_NO_INSERT]);
+ all_read.aggregate(& stat->m_stat[PFS_TL_READ_EXTERNAL]);
+
+ m_write_allow_write.set(normalizer, & stat->m_stat[PFS_TL_WRITE_ALLOW_WRITE]);
+ m_write_concurrent_insert.set(normalizer, & stat->m_stat[PFS_TL_WRITE_CONCURRENT_INSERT]);
+ m_write_delayed.set(normalizer, & stat->m_stat[PFS_TL_WRITE_DELAYED]);
+ m_write_low_priority.set(normalizer, & stat->m_stat[PFS_TL_WRITE_LOW_PRIORITY]);
+ m_write_normal.set(normalizer, & stat->m_stat[PFS_TL_WRITE]);
+ m_write_external.set(normalizer, & stat->m_stat[PFS_TL_WRITE_EXTERNAL]);
+
+ all_write.aggregate(& stat->m_stat[PFS_TL_WRITE_ALLOW_WRITE]);
+ all_write.aggregate(& stat->m_stat[PFS_TL_WRITE_CONCURRENT_INSERT]);
+ all_write.aggregate(& stat->m_stat[PFS_TL_WRITE_DELAYED]);
+ all_write.aggregate(& stat->m_stat[PFS_TL_WRITE_LOW_PRIORITY]);
+ all_write.aggregate(& stat->m_stat[PFS_TL_WRITE]);
+ all_write.aggregate(& stat->m_stat[PFS_TL_WRITE_EXTERNAL]);
+
+ all.aggregate(& all_read);
+ all.aggregate(& all_write);
+
+ m_all_read.set(normalizer, & all_read);
+ m_all_write.set(normalizer, & all_write);
+ m_all.set(normalizer, & all);
+ }
+};
+
+/** Row fragment for stage statistics columns. */
+struct PFS_stage_stat_row
+{
+ PFS_stat_row m_timer1_row;
+
+ /** Build a row from a memory buffer. */
+ inline void set(time_normalizer *normalizer, const PFS_stage_stat *stat)
+ {
+ m_timer1_row.set(normalizer, & stat->m_timer1_stat);
+ }
+
+ /** Set a table field from the row. */
+ void set_field(uint index, Field *f)
+ {
+ m_timer1_row.set_field(index, f);
+ }
+};
+
+/** Row fragment for statement statistics columns. */
+struct PFS_statement_stat_row
+{
+ PFS_stat_row m_timer1_row;
+ ulonglong m_error_count;
+ ulonglong m_warning_count;
+ ulonglong m_rows_affected;
+ ulonglong m_lock_time;
+ ulonglong m_rows_sent;
+ ulonglong m_rows_examined;
+ ulonglong m_created_tmp_disk_tables;
+ ulonglong m_created_tmp_tables;
+ ulonglong m_select_full_join;
+ ulonglong m_select_full_range_join;
+ ulonglong m_select_range;
+ ulonglong m_select_range_check;
+ ulonglong m_select_scan;
+ ulonglong m_sort_merge_passes;
+ ulonglong m_sort_range;
+ ulonglong m_sort_rows;
+ ulonglong m_sort_scan;
+ ulonglong m_no_index_used;
+ ulonglong m_no_good_index_used;
+
+ /** Build a row from a memory buffer. */
+ inline void set(time_normalizer *normalizer, const PFS_statement_stat *stat)
+ {
+ if (stat->m_timer1_stat.m_count != 0)
+ {
+ m_timer1_row.set(normalizer, & stat->m_timer1_stat);
+
+ m_error_count= stat->m_error_count;
+ m_warning_count= stat->m_warning_count;
+ m_lock_time= stat->m_lock_time * MICROSEC_TO_PICOSEC;
+ m_rows_affected= stat->m_rows_affected;
+ m_rows_sent= stat->m_rows_sent;
+ m_rows_examined= stat->m_rows_examined;
+ m_created_tmp_disk_tables= stat->m_created_tmp_disk_tables;
+ m_created_tmp_tables= stat->m_created_tmp_tables;
+ m_select_full_join= stat->m_select_full_join;
+ m_select_full_range_join= stat->m_select_full_range_join;
+ m_select_range= stat->m_select_range;
+ m_select_range_check= stat->m_select_range_check;
+ m_select_scan= stat->m_select_scan;
+ m_sort_merge_passes= stat->m_sort_merge_passes;
+ m_sort_range= stat->m_sort_range;
+ m_sort_rows= stat->m_sort_rows;
+ m_sort_scan= stat->m_sort_scan;
+ m_no_index_used= stat->m_no_index_used;
+ m_no_good_index_used= stat->m_no_good_index_used;
+ }
+ else
+ {
+ m_timer1_row.reset();
+
+ m_error_count= 0;
+ m_warning_count= 0;
+ m_lock_time= 0;
+ m_rows_affected= 0;
+ m_rows_sent= 0;
+ m_rows_examined= 0;
+ m_created_tmp_disk_tables= 0;
+ m_created_tmp_tables= 0;
+ m_select_full_join= 0;
+ m_select_full_range_join= 0;
+ m_select_range= 0;
+ m_select_range_check= 0;
+ m_select_scan= 0;
+ m_sort_merge_passes= 0;
+ m_sort_range= 0;
+ m_sort_rows= 0;
+ m_sort_scan= 0;
+ m_no_index_used= 0;
+ m_no_good_index_used= 0;
+ }
+ }
+
+ /** Set a table field from the row. */
+ void set_field(uint index, Field *f);
+};
+
+/** Row fragment for stored program statistics. */
+struct PFS_sp_stat_row
+{
+ PFS_stat_row m_timer1_row;
+
+ /** Build a row from a memory buffer. */
+ inline void set(time_normalizer *normalizer, const PFS_sp_stat *stat)
+ {
+ m_timer1_row.set(normalizer, & stat->m_timer1_stat);
+ }
+
+ /** Set a table field from the row. */
+ inline void set_field(uint index, Field *f)
+ {
+ m_timer1_row.set_field(index, f);
+ }
+};
+
+/** Row fragment for transaction statistics columns. */
+struct PFS_transaction_stat_row
+{
+ PFS_stat_row m_timer1_row;
+ PFS_stat_row m_read_write_row;
+ PFS_stat_row m_read_only_row;
+ ulonglong m_savepoint_count;
+ ulonglong m_rollback_to_savepoint_count;
+ ulonglong m_release_savepoint_count;
+
+ /** Build a row from a memory buffer. */
+ inline void set(time_normalizer *normalizer, const PFS_transaction_stat *stat)
+ {
+ /* Combine read write/read only stats */
+ PFS_single_stat all;
+ all.aggregate(&stat->m_read_only_stat);
+ all.aggregate(&stat->m_read_write_stat);
+
+ m_timer1_row.set(normalizer, &all);
+ m_read_write_row.set(normalizer, &stat->m_read_write_stat);
+ m_read_only_row.set(normalizer, &stat->m_read_only_stat);
+ }
+
+ /** Set a table field from the row. */
+ void set_field(uint index, Field *f);
+};
+
+/** Row fragment for connection statistics. */
+struct PFS_connection_stat_row
+{
+ ulonglong m_current_connections;
+ ulonglong m_total_connections;
+
+ inline void set(const PFS_connection_stat *stat)
+ {
+ m_current_connections= stat->m_current_connections;
+ m_total_connections= stat->m_total_connections;
+ }
+
+ /** Set a table field from the row. */
+ void set_field(uint index, Field *f);
+};
+
+void set_field_object_type(Field *f, enum_object_type object_type);
+void set_field_lock_type(Field *f, PFS_TL_LOCK_TYPE lock_type);
+void set_field_mdl_type(Field *f, opaque_mdl_type mdl_type, bool backup);
+void set_field_mdl_duration(Field *f, opaque_mdl_duration mdl_duration);
+void set_field_mdl_status(Field *f, opaque_mdl_status mdl_status);
+void set_field_isolation_level(Field *f, enum_isolation_level iso_level);
+void set_field_xa_state(Field *f, enum_xa_transaction_state xa_state);
+
+/** Row fragment for socket io statistics columns. */
+struct PFS_socket_io_stat_row
+{
+ PFS_byte_stat_row m_read;
+ PFS_byte_stat_row m_write;
+ PFS_byte_stat_row m_misc;
+ PFS_byte_stat_row m_all;
+
+ inline void set(time_normalizer *normalizer, const PFS_socket_io_stat *stat)
+ {
+ PFS_byte_stat all;
+
+ m_read.set(normalizer, &stat->m_read);
+ m_write.set(normalizer, &stat->m_write);
+ m_misc.set(normalizer, &stat->m_misc);
+
+ /* Combine stats for all operations */
+ all.aggregate(&stat->m_read);
+ all.aggregate(&stat->m_write);
+ all.aggregate(&stat->m_misc);
+
+ m_all.set(normalizer, &all);
+ }
+};
+
+/** Row fragment for file io statistics columns. */
+struct PFS_file_io_stat_row
+{
+ PFS_byte_stat_row m_read;
+ PFS_byte_stat_row m_write;
+ PFS_byte_stat_row m_misc;
+ PFS_byte_stat_row m_all;
+
+ inline void set(time_normalizer *normalizer, const PFS_file_io_stat *stat)
+ {
+ PFS_byte_stat all;
+
+ m_read.set(normalizer, &stat->m_read);
+ m_write.set(normalizer, &stat->m_write);
+ m_misc.set(normalizer, &stat->m_misc);
+
+ /* Combine stats for all operations */
+ all.aggregate(&stat->m_read);
+ all.aggregate(&stat->m_write);
+ all.aggregate(&stat->m_misc);
+
+ m_all.set(normalizer, &all);
+ }
+};
+
+/** Row fragment for memory statistics columns. */
+struct PFS_memory_stat_row
+{
+ PFS_memory_stat m_stat;
+
+ /** Build a row from a memory buffer. */
+ inline void set(const PFS_memory_stat *stat)
+ {
+ m_stat= *stat;
+ }
+
+ /** Set a table field from the row. */
+ void set_field(uint index, Field *f);
+};
+
+struct PFS_variable_name_row
+{
+public:
+ PFS_variable_name_row()
+ {
+ m_str[0]= '\0';
+ m_length= 0;
+ }
+
+ void make_row(const char* str, size_t length);
+
+ char m_str[NAME_CHAR_LEN+1];
+ uint m_length;
+};
+
+struct PFS_variable_value_row
+{
+public:
+ /** Set the row from a status variable. */
+ void make_row(const Status_variable *var);
+
+ /** Set the row from a system variable. */
+ void make_row(const System_variable *var);
+
+ /** Set a table field from the row. */
+ void set_field(Field *f);
+
+private:
+ void make_row(const CHARSET_INFO *cs, const char* str, size_t length);
+
+ char m_str[1024];
+ uint m_length;
+ const CHARSET_INFO *m_charset;
+};
+
+struct PFS_user_variable_value_row
+{
+public:
+ PFS_user_variable_value_row()
+ : m_value(NULL), m_value_length(0)
+ {}
+
+ PFS_user_variable_value_row(const PFS_user_variable_value_row& rhs)
+ {
+ make_row(rhs.m_value, rhs.m_value_length);
+ }
+
+ ~PFS_user_variable_value_row()
+ {
+ clear();
+ }
+
+ void make_row(const char* val, size_t length);
+
+ const char *get_value() const
+ { return m_value; }
+
+ size_t get_value_length() const
+ { return m_value_length; }
+
+ void clear();
+
+private:
+ char *m_value;
+ size_t m_value_length;
+};
+
+/** @} */
+
+#endif
+
diff --git a/storage/perfschema/table_host_cache.cc b/storage/perfschema/table_host_cache.cc
new file mode 100644
index 00000000..e482ead2
--- /dev/null
+++ b/storage/perfschema/table_host_cache.cc
@@ -0,0 +1,372 @@
+/* Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_host_cache.cc
+ Table HOST_CACHE (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "table_host_cache.h"
+#include "hostname.h"
+#include "field.h"
+#include "sql_class.h"
+
+THR_LOCK table_host_cache::m_table_lock;
+
+PFS_engine_table_share
+table_host_cache::m_share=
+{
+ { C_STRING_WITH_LEN("host_cache") },
+ &pfs_truncatable_acl,
+ table_host_cache::create,
+ NULL, /* write_row */
+ table_host_cache::delete_all_rows,
+ table_host_cache::get_row_count,
+ sizeof(PFS_simple_index), /* ref length */
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE host_cache("
+ "IP VARCHAR(64) not null,"
+ "HOST VARCHAR(255) collate utf8_bin,"
+ "HOST_VALIDATED ENUM ('YES', 'NO') not null,"
+ "SUM_CONNECT_ERRORS BIGINT not null,"
+ "COUNT_HOST_BLOCKED_ERRORS BIGINT not null,"
+ "COUNT_NAMEINFO_TRANSIENT_ERRORS BIGINT not null,"
+ "COUNT_NAMEINFO_PERMANENT_ERRORS BIGINT not null,"
+ "COUNT_FORMAT_ERRORS BIGINT not null,"
+ "COUNT_ADDRINFO_TRANSIENT_ERRORS BIGINT not null,"
+ "COUNT_ADDRINFO_PERMANENT_ERRORS BIGINT not null,"
+ "COUNT_FCRDNS_ERRORS BIGINT not null,"
+ "COUNT_HOST_ACL_ERRORS BIGINT not null,"
+ "COUNT_NO_AUTH_PLUGIN_ERRORS BIGINT not null,"
+ "COUNT_AUTH_PLUGIN_ERRORS BIGINT not null,"
+ "COUNT_HANDSHAKE_ERRORS BIGINT not null,"
+ "COUNT_PROXY_USER_ERRORS BIGINT not null,"
+ "COUNT_PROXY_USER_ACL_ERRORS BIGINT not null,"
+ "COUNT_AUTHENTICATION_ERRORS BIGINT not null,"
+ "COUNT_SSL_ERRORS BIGINT not null,"
+ "COUNT_MAX_USER_CONNECTIONS_ERRORS BIGINT not null,"
+ "COUNT_MAX_USER_CONNECTIONS_PER_HOUR_ERRORS BIGINT not null,"
+ "COUNT_DEFAULT_DATABASE_ERRORS BIGINT not null,"
+ "COUNT_INIT_CONNECT_ERRORS BIGINT not null,"
+ "COUNT_LOCAL_ERRORS BIGINT not null,"
+ "COUNT_UNKNOWN_ERRORS BIGINT not null,"
+ "FIRST_SEEN TIMESTAMP(0) NOT NULL default 0,"
+ "LAST_SEEN TIMESTAMP(0) NOT NULL default 0,"
+ "FIRST_ERROR_SEEN TIMESTAMP(0) null default 0,"
+ "LAST_ERROR_SEEN TIMESTAMP(0) null default 0)") },
+ false /* perpetual */
+};
+
+PFS_engine_table* table_host_cache::create(void)
+{
+ table_host_cache *t= new table_host_cache();
+ if (t != NULL)
+ {
+ THD *thd= current_thd;
+ DBUG_ASSERT(thd != NULL);
+ t->materialize(thd);
+ }
+ return t;
+}
+
+int
+table_host_cache::delete_all_rows(void)
+{
+ /*
+ TRUNCATE TABLE performance_schema.host_cache
+ is an alternate syntax for
+ FLUSH HOSTS
+ */
+ hostname_cache_refresh();
+ return 0;
+}
+
+ha_rows
+table_host_cache::get_row_count(void)
+{
+ ha_rows count;
+ hostname_cache_lock();
+ count= hostname_cache_size();
+ hostname_cache_unlock();
+ return count;
+}
+
+table_host_cache::table_host_cache()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_all_rows(NULL), m_row_count(0),
+ m_row(NULL), m_pos(0), m_next_pos(0)
+{}
+
+void table_host_cache::materialize(THD *thd)
+{
+ Host_entry *current;
+ Host_entry *first;
+ uint size;
+ uint index;
+ row_host_cache *rows;
+ row_host_cache *row;
+
+ DBUG_ASSERT(m_all_rows == NULL);
+ DBUG_ASSERT(m_row_count == 0);
+
+ hostname_cache_lock();
+
+ size= hostname_cache_size();
+ if (size == 0)
+ {
+ /* Normal case, the cache is empty. */
+ goto end;
+ }
+
+ rows= (row_host_cache*) thd->alloc(size * sizeof(row_host_cache));
+ if (rows == NULL)
+ {
+ /* Out of memory, this thread will error out. */
+ goto end;
+ }
+
+ index= 0;
+ row= rows;
+
+ first= hostname_cache_first();
+ current= first;
+
+ while ((current != NULL) && (index < size))
+ {
+ make_row(current, row);
+ index++;
+ row++;
+ current= current->next();
+ }
+
+ m_all_rows= rows;
+ m_row_count= index;
+
+end:
+ hostname_cache_unlock();
+}
+
+void table_host_cache::make_row(Host_entry *entry, row_host_cache *row)
+{
+ row->m_ip_length= (int)strlen(entry->ip_key);
+ strcpy(row->m_ip, entry->ip_key);
+ row->m_hostname_length= entry->m_hostname_length;
+ if (row->m_hostname_length > 0)
+ strncpy(row->m_hostname, entry->m_hostname, row->m_hostname_length);
+ row->m_host_validated= entry->m_host_validated;
+ row->m_sum_connect_errors= entry->m_errors.m_connect;
+ row->m_count_host_blocked_errors= entry->m_errors.m_host_blocked;
+ row->m_count_nameinfo_transient_errors= entry->m_errors.m_nameinfo_transient;
+ row->m_count_nameinfo_permanent_errors= entry->m_errors.m_nameinfo_permanent;
+ row->m_count_format_errors= entry->m_errors.m_format;
+ row->m_count_addrinfo_transient_errors= entry->m_errors.m_addrinfo_transient;
+ row->m_count_addrinfo_permanent_errors= entry->m_errors.m_addrinfo_permanent;
+ row->m_count_fcrdns_errors= entry->m_errors.m_FCrDNS;
+ row->m_count_host_acl_errors= entry->m_errors.m_host_acl;
+ row->m_count_no_auth_plugin_errors= entry->m_errors.m_no_auth_plugin;
+ row->m_count_auth_plugin_errors= entry->m_errors.m_auth_plugin;
+ row->m_count_handshake_errors= entry->m_errors.m_handshake;
+ row->m_count_proxy_user_errors= entry->m_errors.m_proxy_user;
+ row->m_count_proxy_user_acl_errors= entry->m_errors.m_proxy_user_acl;
+ row->m_count_authentication_errors= entry->m_errors.m_authentication;
+ row->m_count_ssl_errors= entry->m_errors.m_ssl;
+ row->m_count_max_user_connection_errors= entry->m_errors.m_max_user_connection;
+ row->m_count_max_user_connection_per_hour_errors= entry->m_errors.m_max_user_connection_per_hour;
+ row->m_count_default_database_errors= entry->m_errors.m_default_database;
+ row->m_count_init_connect_errors= entry->m_errors.m_init_connect;
+ row->m_count_local_errors= entry->m_errors.m_local;
+
+ /*
+ Reserved for future use, to help with backward compatibility.
+ When new errors are added in entry->m_errors.m_xxx,
+ report them in this column (GA releases),
+ until the table HOST_CACHE structure can be extended (next development version).
+ */
+ row->m_count_unknown_errors= 0;
+
+ row->m_first_seen= entry->m_first_seen;
+ row->m_last_seen= entry->m_last_seen;
+ row->m_first_error_seen= entry->m_first_error_seen;
+ row->m_last_error_seen= entry->m_last_error_seen;
+}
+
+void table_host_cache::reset_position(void)
+{
+ m_pos.m_index= 0;
+ m_next_pos.m_index= 0;
+}
+
+int table_host_cache::rnd_next(void)
+{
+ int result;
+
+ m_pos.set_at(&m_next_pos);
+
+ if (m_pos.m_index < m_row_count)
+ {
+ m_row= &m_all_rows[m_pos.m_index];
+ m_next_pos.set_after(&m_pos);
+ result= 0;
+ }
+ else
+ {
+ m_row= NULL;
+ result= HA_ERR_END_OF_FILE;
+ }
+
+ return result;
+}
+
+int table_host_cache::rnd_pos(const void *pos)
+{
+ set_position(pos);
+ DBUG_ASSERT(m_pos.m_index < m_row_count);
+ m_row= &m_all_rows[m_pos.m_index];
+ return 0;
+}
+
+int table_host_cache::read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ DBUG_ASSERT(m_row);
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* IP */
+ set_field_varchar_utf8(f, m_row->m_ip, m_row->m_ip_length);
+ break;
+ case 1: /* HOST */
+ if (m_row->m_hostname_length > 0)
+ set_field_varchar_utf8(f, m_row->m_hostname, m_row->m_hostname_length);
+ else
+ f->set_null();
+ break;
+ case 2: /* HOST_VALIDATED */
+ set_field_enum(f, m_row->m_host_validated ? ENUM_YES : ENUM_NO);
+ break;
+ case 3: /* SUM_CONNECT_ERRORS */
+ set_field_ulonglong(f, m_row->m_sum_connect_errors);
+ break;
+ case 4: /* COUNT_HOST_BLOCKED_ERRORS. */
+ set_field_ulonglong(f, m_row->m_count_host_blocked_errors);
+ break;
+ case 5: /* COUNT_NAMEINFO_TRANSIENT_ERRORS */
+ set_field_ulonglong(f, m_row->m_count_nameinfo_transient_errors);
+ break;
+ case 6: /* COUNT_NAMEINFO_PERSISTENT_ERRORS */
+ set_field_ulonglong(f, m_row->m_count_nameinfo_permanent_errors);
+ break;
+ case 7: /* COUNT_FORMAT_ERRORS */
+ set_field_ulonglong(f, m_row->m_count_format_errors);
+ break;
+ case 8: /* COUNT_ADDRINFO_TRANSIENT_ERRORS */
+ set_field_ulonglong(f, m_row->m_count_addrinfo_transient_errors);
+ break;
+ case 9: /* COUNT_ADDRINFO_PERSISTENT_ERRORS */
+ set_field_ulonglong(f, m_row->m_count_addrinfo_permanent_errors);
+ break;
+ case 10: /* COUNT_FCRDNS_ERRORS */
+ set_field_ulonglong(f, m_row->m_count_fcrdns_errors);
+ break;
+ case 11: /* COUNT_HOST_ACL_ERRORS */
+ set_field_ulonglong(f, m_row->m_count_host_acl_errors);
+ break;
+ case 12: /* COUNT_NO_AUTH_PLUGIN_ERRORS */
+ set_field_ulonglong(f, m_row->m_count_no_auth_plugin_errors);
+ break;
+ case 13: /* COUNT_AUTH_PLUGIN_ERRORS */
+ set_field_ulonglong(f, m_row->m_count_auth_plugin_errors);
+ break;
+ case 14: /* COUNT_HANDSHAKE_ERRORS */
+ set_field_ulonglong(f, m_row->m_count_handshake_errors);
+ break;
+ case 15: /* COUNT_PROXY_USER_ERRORS */
+ set_field_ulonglong(f, m_row->m_count_proxy_user_errors);
+ break;
+ case 16: /* COUNT_PROXY_USER_ACL_ERRORS */
+ set_field_ulonglong(f, m_row->m_count_proxy_user_acl_errors);
+ break;
+ case 17: /* COUNT_AUTHENTICATION_ERRORS */
+ set_field_ulonglong(f, m_row->m_count_authentication_errors);
+ break;
+ case 18: /* COUNT_SSL_ERRORS */
+ set_field_ulonglong(f, m_row->m_count_ssl_errors);
+ break;
+ case 19: /* COUNT_MAX_USER_CONNECTION_ERRORS */
+ set_field_ulonglong(f, m_row->m_count_max_user_connection_errors);
+ break;
+ case 20: /* COUNT_MAX_USER_CONNECTION_PER_HOUR_ERRORS */
+ set_field_ulonglong(f, m_row->m_count_max_user_connection_per_hour_errors);
+ break;
+ case 21: /* COUNT_DEFAULT_DATABASE_ERRORS */
+ set_field_ulonglong(f, m_row->m_count_default_database_errors);
+ break;
+ case 22: /* COUNT_INIT_CONNECT_ERRORS */
+ set_field_ulonglong(f, m_row->m_count_init_connect_errors);
+ break;
+ case 23: /* COUNT_LOCAL_ERRORS */
+ set_field_ulonglong(f, m_row->m_count_local_errors);
+ break;
+ case 24: /* COUNT_UNKNOWN_ERRORS */
+ set_field_ulonglong(f, m_row->m_count_unknown_errors);
+ break;
+ case 25: /* FIRST_SEEN */
+ set_field_timestamp(f, m_row->m_first_seen);
+ break;
+ case 26: /* LAST_SEEN */
+ set_field_timestamp(f, m_row->m_last_seen);
+ break;
+ case 27: /* FIRST_ERROR_SEEN */
+ if (m_row->m_first_error_seen != 0)
+ set_field_timestamp(f, m_row->m_first_error_seen);
+ else
+ f->set_null();
+ break;
+ case 28: /* LAST_ERROR_SEEN */
+ if (m_row->m_last_error_seen != 0)
+ set_field_timestamp(f, m_row->m_last_error_seen);
+ else
+ f->set_null();
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_host_cache.h b/storage/perfschema/table_host_cache.h
new file mode 100644
index 00000000..57cd0fa0
--- /dev/null
+++ b/storage/perfschema/table_host_cache.h
@@ -0,0 +1,150 @@
+/* Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_HOST_CACHE_H
+#define TABLE_HOST_CACHE_H
+
+/**
+ @file storage/perfschema/table_host_cache.h
+ Table HOST_CACHE (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+
+class Host_entry;
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/** A row of PERFORMANCE_SCHEMA.HOST_CACHE. */
+struct row_host_cache
+{
+ /** Column IP. */
+ char m_ip[64];
+ uint m_ip_length;
+ /** Column HOST. */
+ char m_hostname[255];
+ uint m_hostname_length;
+ /** Column HOST_VALIDATED. */
+ bool m_host_validated;
+ /** Column SUM_CONNECT_ERRORS. */
+ ulonglong m_sum_connect_errors;
+ /** Column COUNT_HOST_BLOCKED_ERRORS. */
+ ulonglong m_count_host_blocked_errors;
+ /** Column COUNT_NAMEINFO_TRANSIENT_ERRORS. */
+ ulonglong m_count_nameinfo_transient_errors;
+ /** Column COUNT_NAMEINFO_PERMANENT_ERRORS. */
+ ulonglong m_count_nameinfo_permanent_errors;
+ /** Column COUNT_FORMAT_ERRORS. */
+ ulonglong m_count_format_errors;
+ /** Column COUNT_ADDRINFO_TRANSIENT_ERRORS. */
+ ulonglong m_count_addrinfo_transient_errors;
+ /** Column COUNT_ADDRINFO_PERMANENT_ERRORS. */
+ ulonglong m_count_addrinfo_permanent_errors;
+ /** Column COUNT_FCRDNS_ERRORS. */
+ ulonglong m_count_fcrdns_errors;
+ /** Column COUNT_HOST_ACL_ERRORS. */
+ ulonglong m_count_host_acl_errors;
+ /** Column COUNT_NO_AUTH_PLUGIN_ERRORS. */
+ ulonglong m_count_no_auth_plugin_errors;
+ /** Column COUNT_AUTH_PLUGIN_ERRORS. */
+ ulonglong m_count_auth_plugin_errors;
+ /** Column COUNT_HANDSHAKE_ERRORS. */
+ ulonglong m_count_handshake_errors;
+ /** Column COUNT_PROXY_USER_ERRORS. */
+ ulonglong m_count_proxy_user_errors;
+ /** Column COUNT_PROXY_USER_ACL_ERRORS. */
+ ulonglong m_count_proxy_user_acl_errors;
+ /** Column COUNT_AUTHENTICATION_ERRORS. */
+ ulonglong m_count_authentication_errors;
+ /** Column COUNT_SSL_ERRORS. */
+ ulonglong m_count_ssl_errors;
+ /** Column COUNT_MAX_USER_CONNECTION_ERRORS. */
+ ulonglong m_count_max_user_connection_errors;
+ /** Column COUNT_MAX_USER_CONNECTION_PER_HOUR_ERRORS. */
+ ulonglong m_count_max_user_connection_per_hour_errors;
+ /** Column COUNT_DEFAULT_DATABASE_ERRORS. */
+ ulonglong m_count_default_database_errors;
+ /** Column COUNT_INIT_CONNECT_ERRORS. */
+ ulonglong m_count_init_connect_errors;
+ /** Column COUNT_LOCAL_ERRORS. */
+ ulonglong m_count_local_errors;
+ /** Column COUNT_UNKNOWN_ERRORS. */
+ ulonglong m_count_unknown_errors;
+ /** Column FIRST_SEEN. */
+ ulonglong m_first_seen;
+ /** Column LAST_SEEN. */
+ ulonglong m_last_seen;
+ /** Column FIRST_ERROR_SEEN. */
+ ulonglong m_first_error_seen;
+ /** Column LAST_ERROR_SEEN. */
+ ulonglong m_last_error_seen;
+};
+
+/** Table PERFORMANCE_SCHEMA.HOST_CACHE. */
+class table_host_cache : public PFS_engine_table
+{
+public:
+ /** Table share. */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_host_cache();
+
+public:
+ ~table_host_cache()
+ {}
+
+private:
+ void materialize(THD *thd);
+ static void make_row(Host_entry *entry, row_host_cache *row);
+
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ row_host_cache *m_all_rows;
+ uint m_row_count;
+ /** Current row. */
+ row_host_cache *m_row;
+ /** Current position. */
+ PFS_simple_index m_pos;
+ /** Next position. */
+ PFS_simple_index m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_hosts.cc b/storage/perfschema/table_hosts.cc
new file mode 100644
index 00000000..8e71bfc6
--- /dev/null
+++ b/storage/perfschema/table_hosts.cc
@@ -0,0 +1,149 @@
+/* Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "table_hosts.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "pfs_account.h"
+#include "pfs_host.h"
+#include "pfs_visitor.h"
+#include "pfs_memory.h"
+#include "pfs_status.h"
+#include "field.h"
+
+THR_LOCK table_hosts::m_table_lock;
+
+PFS_engine_table_share
+table_hosts::m_share=
+{
+ { C_STRING_WITH_LEN("hosts") },
+ &pfs_truncatable_acl,
+ table_hosts::create,
+ NULL, /* write_row */
+ table_hosts::delete_all_rows,
+ cursor_by_host::get_row_count,
+ sizeof(PFS_simple_index), /* ref length */
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE hosts("
+ "HOST CHAR(" STRINGIFY_ARG(HOSTNAME_LENGTH) ") collate utf8_bin default null,"
+ "CURRENT_CONNECTIONS bigint not null,"
+ "TOTAL_CONNECTIONS bigint not null)") },
+ false /* perpetual */
+};
+
+PFS_engine_table* table_hosts::create()
+{
+ return new table_hosts();
+}
+
+int
+table_hosts::delete_all_rows(void)
+{
+ reset_events_waits_by_thread();
+ reset_events_waits_by_account();
+ reset_events_waits_by_host();
+ reset_events_stages_by_thread();
+ reset_events_stages_by_account();
+ reset_events_stages_by_host();
+ reset_events_statements_by_thread();
+ reset_events_statements_by_account();
+ reset_events_statements_by_host();
+ reset_events_transactions_by_thread();
+ reset_events_transactions_by_account();
+ reset_events_transactions_by_host();
+ reset_memory_by_thread();
+ reset_memory_by_account();
+ reset_memory_by_host();
+ reset_status_by_thread();
+ reset_status_by_account();
+ reset_status_by_host();
+ purge_all_account();
+ purge_all_host();
+ return 0;
+}
+
+table_hosts::table_hosts()
+ : cursor_by_host(& m_share),
+ m_row_exists(false)
+{}
+
+void table_hosts::make_row(PFS_host *pfs)
+{
+ pfs_optimistic_state lock;
+
+ m_row_exists= false;
+ pfs->m_lock.begin_optimistic_lock(&lock);
+
+ if (m_row.m_host.make_row(pfs))
+ return;
+
+ PFS_connection_stat_visitor visitor;
+ PFS_connection_iterator::visit_host(pfs,
+ true, /* accounts */
+ true, /* threads */
+ false, /* THDs */
+ & visitor);
+
+ if (! pfs->m_lock.end_optimistic_lock(& lock))
+ return;
+
+ m_row.m_connection_stat.set(& visitor.m_stat);
+ m_row_exists= true;
+}
+
+int table_hosts::read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* HOST */
+ m_row.m_host.set_field(f);
+ break;
+ case 1: /* CURRENT_CONNECTIONS */
+ case 2: /* TOTAL_CONNECTIONS */
+ m_row.m_connection_stat.set_field(f->field_index - 1, f);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+ return 0;
+}
+
diff --git a/storage/perfschema/table_hosts.h b/storage/perfschema/table_hosts.h
new file mode 100644
index 00000000..61c04d12
--- /dev/null
+++ b/storage/perfschema/table_hosts.h
@@ -0,0 +1,85 @@
+/* Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_HOSTS_H
+#define TABLE_HOSTS_H
+
+#include "pfs_column_types.h"
+#include "cursor_by_host.h"
+#include "table_helper.h"
+
+struct PFS_host;
+
+/**
+ \addtogroup Performance_schema_tables
+ @{
+*/
+
+/**
+ A row of PERFORMANCE_SCHEMA.HOSTS.
+*/
+struct row_hosts
+{
+ /** Column HOST. */
+ PFS_host_row m_host;
+ /** Columns CURRENT_CONNECTIONS, TOTAL_CONNECTIONS. */
+ PFS_connection_stat_row m_connection_stat;
+};
+
+/** Table PERFORMANCE_SCHEMA.THREADS. */
+class table_hosts : public cursor_by_host
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ /** Table builder */
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+
+protected:
+ table_hosts();
+
+public:
+ ~table_hosts()
+ {}
+
+private:
+ virtual void make_row(PFS_host *pfs);
+
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ /** Current row. */
+ row_hosts m_row;
+ /** True if the current row exists. */
+ bool m_row_exists;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_md_locks.cc b/storage/perfschema/table_md_locks.cc
new file mode 100644
index 00000000..9f78750e
--- /dev/null
+++ b/storage/perfschema/table_md_locks.cc
@@ -0,0 +1,207 @@
+/* Copyright (c) 2012, 2018, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_md_locks.cc
+ Table METADATA_LOCKS (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "pfs_instr.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "table_md_locks.h"
+#include "pfs_global.h"
+#include "pfs_buffer_container.h"
+#include "field.h"
+
+THR_LOCK table_metadata_locks::m_table_lock;
+
+PFS_engine_table_share
+table_metadata_locks::m_share=
+{
+ { C_STRING_WITH_LEN("metadata_locks") },
+ &pfs_readonly_acl,
+ table_metadata_locks::create,
+ NULL, /* write_row */
+ NULL, /* delete_all_rows */
+ table_metadata_locks::get_row_count,
+ sizeof(PFS_simple_index),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE metadata_locks("
+ "OBJECT_TYPE VARCHAR(64) not null,"
+ "OBJECT_SCHEMA VARCHAR(64),"
+ "OBJECT_NAME VARCHAR(64),"
+ "OBJECT_INSTANCE_BEGIN BIGINT unsigned not null,"
+ "LOCK_TYPE VARCHAR(32) not null,"
+ "LOCK_DURATION VARCHAR(32) not null,"
+ "LOCK_STATUS VARCHAR(32) not null,"
+ "SOURCE VARCHAR(64),"
+ "OWNER_THREAD_ID BIGINT unsigned,"
+ "OWNER_EVENT_ID BIGINT unsigned)")},
+ false /* perpetual */
+};
+
+PFS_engine_table* table_metadata_locks::create(void)
+{
+ return new table_metadata_locks();
+}
+
+ha_rows
+table_metadata_locks::get_row_count(void)
+{
+ return global_mdl_container.get_row_count();
+}
+
+table_metadata_locks::table_metadata_locks()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(0), m_next_pos(0)
+{}
+
+void table_metadata_locks::reset_position(void)
+{
+ m_pos.m_index= 0;
+ m_next_pos.m_index= 0;
+}
+
+int table_metadata_locks::rnd_next(void)
+{
+ PFS_metadata_lock *pfs;
+
+ m_pos.set_at(&m_next_pos);
+ PFS_mdl_iterator it= global_mdl_container.iterate(m_pos.m_index);
+ pfs= it.scan_next(& m_pos.m_index);
+ if (pfs != NULL)
+ {
+ make_row(pfs);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int table_metadata_locks::rnd_pos(const void *pos)
+{
+ PFS_metadata_lock *pfs;
+
+ set_position(pos);
+
+ pfs= global_mdl_container.get(m_pos.m_index);
+ if (pfs != NULL)
+ {
+ make_row(pfs);
+ return 0;
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_metadata_locks::make_row(PFS_metadata_lock *pfs)
+{
+ pfs_optimistic_state lock;
+
+ m_row_exists= false;
+
+ /* Protect this reader against a metadata lock destroy */
+ pfs->m_lock.begin_optimistic_lock(&lock);
+
+ m_row.m_identity= pfs->m_identity;
+ m_row.m_mdl_type= pfs->m_mdl_type;
+ m_row.m_mdl_duration= pfs->m_mdl_duration;
+ m_row.m_mdl_status= pfs->m_mdl_status;
+
+ /* Disable source file and line to avoid stale __FILE__ pointers. */
+ m_row.m_source_length= 0;
+
+ m_row.m_owner_thread_id= static_cast<ulong>(pfs->m_owner_thread_id);
+ m_row.m_owner_event_id= static_cast<ulong>(pfs->m_owner_event_id);
+
+ if (m_row.m_object.make_row(& pfs->m_mdl_key))
+ return;
+
+ if (pfs->m_lock.end_optimistic_lock(&lock))
+ m_row_exists= true;
+}
+
+int table_metadata_locks::read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* OBJECT_TYPE */
+ case 1: /* OBJECT_SCHEMA */
+ case 2: /* OBJECT_NAME */
+ m_row.m_object.set_nullable_field(f->field_index, f);
+ break;
+ case 3: /* OBJECT_INSTANCE */
+ set_field_ulonglong(f, (intptr) m_row.m_identity);
+ break;
+ case 4: /* LOCK_TYPE */
+ set_field_mdl_type(f, m_row.m_mdl_type, m_row.m_object.m_object_type == OBJECT_TYPE_BACKUP);
+ break;
+ case 5: /* LOCK_DURATION */
+ set_field_mdl_duration(f, m_row.m_mdl_duration);
+ break;
+ case 6: /* LOCK_STATUS */
+ set_field_mdl_status(f, m_row.m_mdl_status);
+ break;
+ case 7: /* SOURCE */
+ set_field_varchar_utf8(f, m_row.m_source, m_row.m_source_length);
+ break;
+ case 8: /* OWNER_THREAD_ID */
+ if (m_row.m_owner_thread_id != 0)
+ set_field_ulonglong(f, m_row.m_owner_thread_id);
+ else
+ f->set_null();
+ break;
+ case 9: /* OWNER_EVENT_ID */
+ if (m_row.m_owner_event_id != 0)
+ set_field_ulonglong(f, m_row.m_owner_event_id);
+ else
+ f->set_null();
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_md_locks.h b/storage/perfschema/table_md_locks.h
new file mode 100644
index 00000000..40b6d2f6
--- /dev/null
+++ b/storage/perfschema/table_md_locks.h
@@ -0,0 +1,106 @@
+/* Copyright (c) 2012, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_METADATA_LOCK_H
+#define TABLE_METADATA_LOCK_H
+
+/**
+ @file storage/perfschema/table_md_locks.h
+ Table METADATA_LOCKS (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "table_helper.h"
+
+struct PFS_metadata_lock;
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/** A row of table PERFORMANCE_SCHEMA.MUTEX_INSTANCES. */
+struct row_metadata_lock
+{
+ /** Column OBJECT_INSTANCE_BEGIN. */
+ const void *m_identity;
+ opaque_mdl_type m_mdl_type;
+ opaque_mdl_duration m_mdl_duration;
+ opaque_mdl_status m_mdl_status;
+ /** Column SOURCE. */
+ char m_source[COL_SOURCE_SIZE];
+ /** Length in bytes of @c m_source. */
+ uint m_source_length;
+ /** Column OWNER_THREAD_ID. */
+ ulong m_owner_thread_id;
+ /** Column OWNER_EVENT_ID. */
+ ulong m_owner_event_id;
+ /** Columns OBJECT_TYPE, OBJECT_SCHEMA, OBJECT_NAME. */
+ PFS_object_row m_object;
+};
+
+/** Table PERFORMANCE_SCHEMA.METADATA_LOCKS. */
+class table_metadata_locks : public PFS_engine_table
+{
+public:
+ /** Table share. */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static ha_rows get_row_count();
+
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+private:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_metadata_locks();
+
+public:
+ ~table_metadata_locks()
+ {}
+
+private:
+ void make_row(PFS_metadata_lock *pfs);
+
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+ /** Fields definition. */
+ static TABLE_FIELD_DEF m_field_def;
+
+ /** Current row. */
+ row_metadata_lock m_row;
+ /** True if the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ PFS_simple_index m_pos;
+ /** Next position. */
+ PFS_simple_index m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_mems_by_account_by_event_name.cc b/storage/perfschema/table_mems_by_account_by_event_name.cc
new file mode 100644
index 00000000..5c83c225
--- /dev/null
+++ b/storage/perfschema/table_mems_by_account_by_event_name.cc
@@ -0,0 +1,221 @@
+/* Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_mems_by_account_by_event_name.cc
+ Table MEMORY_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "pfs_instr_class.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "table_mems_by_account_by_event_name.h"
+#include "pfs_global.h"
+#include "pfs_visitor.h"
+#include "pfs_memory.h"
+#include "pfs_buffer_container.h"
+#include "field.h"
+
+THR_LOCK table_mems_by_account_by_event_name::m_table_lock;
+
+PFS_engine_table_share
+table_mems_by_account_by_event_name::m_share=
+{
+ { C_STRING_WITH_LEN("memory_summary_by_account_by_event_name") },
+ &pfs_readonly_acl,
+ table_mems_by_account_by_event_name::create,
+ NULL, /* write_row */
+ table_mems_by_account_by_event_name::delete_all_rows,
+ table_mems_by_account_by_event_name::get_row_count,
+ sizeof(pos_mems_by_account_by_event_name),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE memory_summary_by_account_by_event_name("
+ "USER CHAR(32) collate utf8_bin default null,"
+ "HOST CHAR(60) collate utf8_bin default null,"
+ "EVENT_NAME VARCHAR(128) not null,"
+ "COUNT_ALLOC BIGINT unsigned not null,"
+ "COUNT_FREE BIGINT unsigned not null,"
+ "SUM_NUMBER_OF_BYTES_ALLOC BIGINT unsigned not null,"
+ "SUM_NUMBER_OF_BYTES_FREE BIGINT unsigned not null,"
+ "LOW_COUNT_USED BIGINT not null,"
+ "CURRENT_COUNT_USED BIGINT not null,"
+ "HIGH_COUNT_USED BIGINT not null,"
+ "LOW_NUMBER_OF_BYTES_USED BIGINT not null,"
+ "CURRENT_NUMBER_OF_BYTES_USED BIGINT not null,"
+ "HIGH_NUMBER_OF_BYTES_USED BIGINT not null)")},
+ false /* perpetual */
+};
+
+PFS_engine_table* table_mems_by_account_by_event_name::create(void)
+{
+ return new table_mems_by_account_by_event_name();
+}
+
+int
+table_mems_by_account_by_event_name::delete_all_rows(void)
+{
+ reset_memory_by_thread();
+ reset_memory_by_account();
+ return 0;
+}
+
+ha_rows
+table_mems_by_account_by_event_name::get_row_count(void)
+{
+ return global_account_container.get_row_count() * memory_class_max;
+}
+
+table_mems_by_account_by_event_name::table_mems_by_account_by_event_name()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(), m_next_pos()
+{}
+
+void table_mems_by_account_by_event_name::reset_position(void)
+{
+ m_pos.reset();
+ m_next_pos.reset();
+}
+
+int table_mems_by_account_by_event_name::rnd_next(void)
+{
+ PFS_account *account;
+ PFS_memory_class *memory_class;
+ bool has_more_account= true;
+
+ for (m_pos.set_at(&m_next_pos);
+ has_more_account;
+ m_pos.next_account())
+ {
+ account= global_account_container.get(m_pos.m_index_1, & has_more_account);
+ if (account != NULL)
+ {
+ do
+ {
+ memory_class= find_memory_class(m_pos.m_index_2);
+ if (memory_class != NULL)
+ {
+ if (! memory_class->is_global())
+ {
+ make_row(account, memory_class);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+
+ m_pos.next_class();
+ }
+ }
+ while (memory_class != NULL);
+ }
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int table_mems_by_account_by_event_name::rnd_pos(const void *pos)
+{
+ PFS_account *account;
+ PFS_memory_class *memory_class;
+
+ set_position(pos);
+
+ account= global_account_container.get(m_pos.m_index_1);
+ if (account != NULL)
+ {
+ memory_class= find_memory_class(m_pos.m_index_2);
+ if (memory_class != NULL)
+ {
+ if (! memory_class->is_global())
+ {
+ make_row(account, memory_class);
+ return 0;
+ }
+ }
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_mems_by_account_by_event_name
+::make_row(PFS_account *account, PFS_memory_class *klass)
+{
+ pfs_optimistic_state lock;
+ m_row_exists= false;
+
+ account->m_lock.begin_optimistic_lock(&lock);
+
+ if (m_row.m_account.make_row(account))
+ return;
+
+ m_row.m_event_name.make_row(klass);
+
+ PFS_connection_memory_visitor visitor(klass);
+ PFS_connection_iterator::visit_account(account,
+ true, /* threads */
+ false, /* THDs */
+ & visitor);
+
+ if (! account->m_lock.end_optimistic_lock(&lock))
+ return;
+
+ m_row_exists= true;
+ m_row.m_stat.set(& visitor.m_stat);
+}
+
+int table_mems_by_account_by_event_name::read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* USER */
+ case 1: /* HOST */
+ m_row.m_account.set_field(f->field_index, f);
+ break;
+ case 2: /* EVENT_NAME */
+ m_row.m_event_name.set_field(f);
+ break;
+ default: /* 3, ... HIGH_NUMBER_OF_BYTES_USED */
+ m_row.m_stat.set_field(f->field_index - 3, f);
+ break;
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_mems_by_account_by_event_name.h b/storage/perfschema/table_mems_by_account_by_event_name.h
new file mode 100644
index 00000000..b6151246
--- /dev/null
+++ b/storage/perfschema/table_mems_by_account_by_event_name.h
@@ -0,0 +1,129 @@
+/* Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_MEMORY_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME_H
+#define TABLE_MEMORY_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME_H
+
+/**
+ @file storage/perfschema/table_mems_by_account_by_event_name.h
+ Table MEMORY_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_instr_class.h"
+#include "pfs_account.h"
+#include "table_helper.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/** A row of PERFORMANCE_SCHEMA.MEMORY_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME. */
+struct row_mems_by_account_by_event_name
+{
+ /** Column USER, HOST. */
+ PFS_account_row m_account;
+ /** Column EVENT_NAME. */
+ PFS_event_name_row m_event_name;
+ /** Columns COUNT_ALLOC, ... */
+ PFS_memory_stat_row m_stat;
+};
+
+/**
+ Position of a cursor on
+ PERFORMANCE_SCHEMA.EVENTS_MEMORY_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME.
+ Index 1 on account (0 based)
+ Index 2 on memory class (1 based)
+*/
+struct pos_mems_by_account_by_event_name
+: public PFS_double_index
+{
+ pos_mems_by_account_by_event_name()
+ : PFS_double_index(0, 1)
+ {}
+
+ inline void reset(void)
+ {
+ m_index_1= 0;
+ m_index_2= 1;
+ }
+
+ inline void next_account(void)
+ {
+ m_index_1++;
+ m_index_2= 1;
+ }
+
+ inline void next_class(void)
+ {
+ m_index_2++;
+ }
+};
+
+/** Table PERFORMANCE_SCHEMA.MEMORY_SUMMARY_BY_ACCOUNT_BY_EVENT_NAME. */
+class table_mems_by_account_by_event_name : public PFS_engine_table
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+private:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_mems_by_account_by_event_name();
+
+public:
+ ~table_mems_by_account_by_event_name()
+ {}
+
+private:
+ void make_row(PFS_account *account, PFS_memory_class *klass);
+
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+ /** Fields definition. */
+ static TABLE_FIELD_DEF m_field_def;
+
+ /** Current row. */
+ row_mems_by_account_by_event_name m_row;
+ /** True is the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ pos_mems_by_account_by_event_name m_pos;
+ /** Next position. */
+ pos_mems_by_account_by_event_name m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_mems_by_host_by_event_name.cc b/storage/perfschema/table_mems_by_host_by_event_name.cc
new file mode 100644
index 00000000..0921dfa4
--- /dev/null
+++ b/storage/perfschema/table_mems_by_host_by_event_name.cc
@@ -0,0 +1,221 @@
+/* Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_mems_by_host_by_event_name.cc
+ Table MEMORY_SUMMARY_BY_HOST_BY_EVENT_NAME (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "pfs_instr_class.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "table_mems_by_host_by_event_name.h"
+#include "pfs_global.h"
+#include "pfs_visitor.h"
+#include "pfs_memory.h"
+#include "pfs_buffer_container.h"
+#include "field.h"
+
+THR_LOCK table_mems_by_host_by_event_name::m_table_lock;
+
+PFS_engine_table_share
+table_mems_by_host_by_event_name::m_share=
+{
+ { C_STRING_WITH_LEN("memory_summary_by_host_by_event_name") },
+ &pfs_readonly_acl,
+ table_mems_by_host_by_event_name::create,
+ NULL, /* write_row */
+ table_mems_by_host_by_event_name::delete_all_rows,
+ table_mems_by_host_by_event_name::get_row_count,
+ sizeof(PFS_simple_index),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE memory_summary_by_host_by_event_name("
+ "HOST CHAR(60) collate utf8_bin default null,"
+ "EVENT_NAME VARCHAR(128) not null,"
+ "COUNT_ALLOC BIGINT unsigned not null,"
+ "COUNT_FREE BIGINT unsigned not null,"
+ "SUM_NUMBER_OF_BYTES_ALLOC BIGINT unsigned not null,"
+ "SUM_NUMBER_OF_BYTES_FREE BIGINT unsigned not null,"
+ "LOW_COUNT_USED BIGINT not null,"
+ "CURRENT_COUNT_USED BIGINT not null,"
+ "HIGH_COUNT_USED BIGINT not null,"
+ "LOW_NUMBER_OF_BYTES_USED BIGINT not null,"
+ "CURRENT_NUMBER_OF_BYTES_USED BIGINT not null,"
+ "HIGH_NUMBER_OF_BYTES_USED BIGINT not null)")},
+ false /* perpetual */
+};
+
+PFS_engine_table* table_mems_by_host_by_event_name::create(void)
+{
+ return new table_mems_by_host_by_event_name();
+}
+
+int
+table_mems_by_host_by_event_name::delete_all_rows(void)
+{
+ reset_memory_by_thread();
+ reset_memory_by_account();
+ reset_memory_by_host();
+ return 0;
+}
+
+ha_rows
+table_mems_by_host_by_event_name::get_row_count(void)
+{
+ return global_host_container.get_row_count() * memory_class_max;
+}
+
+table_mems_by_host_by_event_name::table_mems_by_host_by_event_name()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(), m_next_pos()
+{}
+
+void table_mems_by_host_by_event_name::reset_position(void)
+{
+ m_pos.reset();
+ m_next_pos.reset();
+}
+
+int table_mems_by_host_by_event_name::rnd_next(void)
+{
+ PFS_host *host;
+ PFS_memory_class *memory_class;
+ bool has_more_host= true;
+
+ for (m_pos.set_at(&m_next_pos);
+ has_more_host;
+ m_pos.next_host())
+ {
+ host= global_host_container.get(m_pos.m_index_1, & has_more_host);
+ if (host != NULL)
+ {
+ do
+ {
+ memory_class= find_memory_class(m_pos.m_index_2);
+ if (memory_class != NULL)
+ {
+ if (! memory_class->is_global())
+ {
+ make_row(host, memory_class);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+
+ m_pos.next_class();
+ }
+ }
+ while (memory_class != NULL);
+ }
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int table_mems_by_host_by_event_name::rnd_pos(const void *pos)
+{
+ PFS_host *host;
+ PFS_memory_class *memory_class;
+
+ set_position(pos);
+
+ host= global_host_container.get(m_pos.m_index_1);
+ if (host != NULL)
+ {
+ memory_class= find_memory_class(m_pos.m_index_2);
+ if (memory_class != NULL)
+ {
+ if (! memory_class->is_global())
+ {
+ make_row(host, memory_class);
+ return 0;
+ }
+ }
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_mems_by_host_by_event_name
+::make_row(PFS_host *host, PFS_memory_class *klass)
+{
+ pfs_optimistic_state lock;
+ m_row_exists= false;
+
+ host->m_lock.begin_optimistic_lock(&lock);
+
+ if (m_row.m_host.make_row(host))
+ return;
+
+ m_row.m_event_name.make_row(klass);
+
+ PFS_connection_memory_visitor visitor(klass);
+ PFS_connection_iterator::visit_host(host,
+ true, /* accounts */
+ true, /* threads */
+ false, /* THDs */
+ & visitor);
+
+ if (! host->m_lock.end_optimistic_lock(&lock))
+ return;
+
+ m_row_exists= true;
+ m_row.m_stat.set(& visitor.m_stat);
+}
+
+int table_mems_by_host_by_event_name::read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* HOST */
+ m_row.m_host.set_field(f);
+ break;
+ case 1: /* EVENT_NAME */
+ m_row.m_event_name.set_field(f);
+ break;
+ default: /* 2, ... HIGH_NUMBER_OF_BYTES_USED */
+ m_row.m_stat.set_field(f->field_index - 2, f);
+ break;
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_mems_by_host_by_event_name.h b/storage/perfschema/table_mems_by_host_by_event_name.h
new file mode 100644
index 00000000..1a55db2c
--- /dev/null
+++ b/storage/perfschema/table_mems_by_host_by_event_name.h
@@ -0,0 +1,129 @@
+/* Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_MEMORY_SUMMARY_BY_HOST_BY_EVENT_NAME_H
+#define TABLE_MEMORY_SUMMARY_BY_HOST_BY_EVENT_NAME_H
+
+/**
+ @file storage/perfschema/table_mems_by_host_by_event_name.h
+ Table MEMORY_SUMMARY_BY_HOST_BY_EVENT_NAME (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_instr_class.h"
+#include "pfs_host.h"
+#include "table_helper.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/** A row of PERFORMANCE_SCHEMA.MEMORY_SUMMARY_BY_HOST_BY_EVENT_NAME. */
+struct row_mems_by_host_by_event_name
+{
+ /** Column HOST */
+ PFS_host_row m_host;
+ /** Column EVENT_NAME. */
+ PFS_event_name_row m_event_name;
+ /** Columns COUNT_ALLOC, ... */
+ PFS_memory_stat_row m_stat;
+};
+
+/**
+ Position of a cursor on
+ PERFORMANCE_SCHEMA.EVENTS_MEMORY_SUMMARY_BY_HOST_BY_EVENT_NAME.
+ Index 1 on host (0 based)
+ Index 2 on memory class (1 based)
+*/
+struct pos_mems_by_host_by_event_name
+: public PFS_double_index
+{
+ pos_mems_by_host_by_event_name()
+ : PFS_double_index(0, 1)
+ {}
+
+ inline void reset(void)
+ {
+ m_index_1= 0;
+ m_index_2= 1;
+ }
+
+ inline void next_host(void)
+ {
+ m_index_1++;
+ m_index_2= 1;
+ }
+
+ inline void next_class(void)
+ {
+ m_index_2++;
+ }
+};
+
+/** Table PERFORMANCE_SCHEMA.MEMORY_SUMMARY_BY_HOST_BY_EVENT_NAME. */
+class table_mems_by_host_by_event_name : public PFS_engine_table
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+private:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_mems_by_host_by_event_name();
+
+public:
+ ~table_mems_by_host_by_event_name()
+ {}
+
+private:
+ void make_row(PFS_host *host, PFS_memory_class *klass);
+
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+ /** Fields definition. */
+ static TABLE_FIELD_DEF m_field_def;
+
+ /** Current row. */
+ row_mems_by_host_by_event_name m_row;
+ /** True is the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ pos_mems_by_host_by_event_name m_pos;
+ /** Next position. */
+ pos_mems_by_host_by_event_name m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_mems_by_thread_by_event_name.cc b/storage/perfschema/table_mems_by_thread_by_event_name.cc
new file mode 100644
index 00000000..9e36cb76
--- /dev/null
+++ b/storage/perfschema/table_mems_by_thread_by_event_name.cc
@@ -0,0 +1,214 @@
+/* Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_mems_by_thread_by_event_name.cc
+ Table MEMORY_SUMMARY_BY_THREAD_BY_EVENT_NAME (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "pfs_instr_class.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "table_mems_by_thread_by_event_name.h"
+#include "pfs_global.h"
+#include "pfs_visitor.h"
+#include "pfs_memory.h"
+#include "pfs_buffer_container.h"
+#include "field.h"
+
+THR_LOCK table_mems_by_thread_by_event_name::m_table_lock;
+
+PFS_engine_table_share
+table_mems_by_thread_by_event_name::m_share=
+{
+ { C_STRING_WITH_LEN("memory_summary_by_thread_by_event_name") },
+ &pfs_readonly_acl,
+ table_mems_by_thread_by_event_name::create,
+ NULL, /* write_row */
+ table_mems_by_thread_by_event_name::delete_all_rows,
+ table_mems_by_thread_by_event_name::get_row_count,
+ sizeof(PFS_simple_index),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE memory_summary_by_thread_by_event_name("
+ "THREAD_ID BIGINT unsigned not null,"
+ "EVENT_NAME VARCHAR(128) not null,"
+ "COUNT_ALLOC BIGINT unsigned not null,"
+ "COUNT_FREE BIGINT unsigned not null,"
+ "SUM_NUMBER_OF_BYTES_ALLOC BIGINT unsigned not null,"
+ "SUM_NUMBER_OF_BYTES_FREE BIGINT unsigned not null,"
+ "LOW_COUNT_USED BIGINT not null,"
+ "CURRENT_COUNT_USED BIGINT not null,"
+ "HIGH_COUNT_USED BIGINT not null,"
+ "LOW_NUMBER_OF_BYTES_USED BIGINT not null,"
+ "CURRENT_NUMBER_OF_BYTES_USED BIGINT not null,"
+ "HIGH_NUMBER_OF_BYTES_USED BIGINT not null)")},
+ false /* perpetual */
+};
+
+PFS_engine_table* table_mems_by_thread_by_event_name::create(void)
+{
+ return new table_mems_by_thread_by_event_name();
+}
+
+int
+table_mems_by_thread_by_event_name::delete_all_rows(void)
+{
+ reset_memory_by_thread();
+ return 0;
+}
+
+ha_rows
+table_mems_by_thread_by_event_name::get_row_count(void)
+{
+ return global_thread_container.get_row_count() * memory_class_max;
+}
+
+table_mems_by_thread_by_event_name::table_mems_by_thread_by_event_name()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(), m_next_pos()
+{}
+
+void table_mems_by_thread_by_event_name::reset_position(void)
+{
+ m_pos.reset();
+ m_next_pos.reset();
+}
+
+int table_mems_by_thread_by_event_name::rnd_next(void)
+{
+ PFS_thread *thread;
+ PFS_memory_class *memory_class;
+ bool has_more_thread= true;
+
+ for (m_pos.set_at(&m_next_pos);
+ has_more_thread;
+ m_pos.next_thread())
+ {
+ thread= global_thread_container.get(m_pos.m_index_1, & has_more_thread);
+ if (thread != NULL)
+ {
+ do
+ {
+ memory_class= find_memory_class(m_pos.m_index_2);
+ if (memory_class != NULL)
+ {
+ if (! memory_class->is_global())
+ {
+ make_row(thread, memory_class);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+
+ m_pos.next_class();
+ }
+ }
+ while (memory_class != NULL);
+ }
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int table_mems_by_thread_by_event_name::rnd_pos(const void *pos)
+{
+ PFS_thread *thread;
+ PFS_memory_class *memory_class;
+
+ set_position(pos);
+
+ thread= global_thread_container.get(m_pos.m_index_1);
+ if (thread != NULL)
+ {
+ memory_class= find_memory_class(m_pos.m_index_2);
+ if (memory_class != NULL)
+ {
+ if (! memory_class->is_global())
+ {
+ make_row(thread, memory_class);
+ return 0;
+ }
+ }
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_mems_by_thread_by_event_name
+::make_row(PFS_thread *thread, PFS_memory_class *klass)
+{
+ pfs_optimistic_state lock;
+ m_row_exists= false;
+
+ /* Protect this reader against a thread termination */
+ thread->m_lock.begin_optimistic_lock(&lock);
+
+ m_row.m_thread_internal_id= thread->m_thread_internal_id;
+
+ m_row.m_event_name.make_row(klass);
+
+ PFS_connection_memory_visitor visitor(klass);
+ PFS_connection_iterator::visit_thread(thread, & visitor);
+
+ if (! thread->m_lock.end_optimistic_lock(&lock))
+ return;
+
+ m_row_exists= true;
+ m_row.m_stat.set(& visitor.m_stat);
+}
+
+int table_mems_by_thread_by_event_name::read_row_values(TABLE *table,
+ unsigned char *,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 0);
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* THREAD_ID */
+ set_field_ulonglong(f, m_row.m_thread_internal_id);
+ break;
+ case 1: /* EVENT_NAME */
+ m_row.m_event_name.set_field(f);
+ break;
+ default: /* 2, ... HIGH_NUMBER_OF_BYTES_USED */
+ m_row.m_stat.set_field(f->field_index - 2, f);
+ break;
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_mems_by_thread_by_event_name.h b/storage/perfschema/table_mems_by_thread_by_event_name.h
new file mode 100644
index 00000000..f8608198
--- /dev/null
+++ b/storage/perfschema/table_mems_by_thread_by_event_name.h
@@ -0,0 +1,129 @@
+/* Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_MEMORY_SUMMARY_BY_THREAD_BY_EVENT_NAME_H
+#define TABLE_MEMORY_SUMMARY_BY_THREAD_BY_EVENT_NAME_H
+
+/**
+ @file storage/perfschema/table_mems_by_thread_by_event_name.h
+ Table MEMORY_SUMMARY_BY_THREAD_BY_EVENT_NAME (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "table_helper.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/** A row of PERFORMANCE_SCHEMA.MEMORY_SUMMARY_BY_THREAD_BY_EVENT_NAME. */
+struct row_mems_by_thread_by_event_name
+{
+ /** Column THREAD_ID. */
+ ulonglong m_thread_internal_id;
+ /** Column EVENT_NAME. */
+ PFS_event_name_row m_event_name;
+ /** Columns COUNT_ALLOC, ... */
+ PFS_memory_stat_row m_stat;
+};
+
+/**
+ Position of a cursor on
+ PERFORMANCE_SCHEMA.EVENTS_MEMORY_SUMMARY_BY_THREAD_BY_EVENT_NAME.
+ Index 1 on thread (0 based).
+ Index 2 on memory class (1 based).
+*/
+struct pos_mems_by_thread_by_event_name
+: public PFS_double_index
+{
+ pos_mems_by_thread_by_event_name()
+ : PFS_double_index(0, 1)
+ {}
+
+ inline void reset(void)
+ {
+ m_index_1= 0;
+ m_index_2= 1;
+ }
+
+ inline void next_thread(void)
+ {
+ m_index_1++;
+ m_index_2= 1;
+ }
+
+ inline void next_class(void)
+ {
+ m_index_2++;
+ }
+};
+
+/** Table PERFORMANCE_SCHEMA.MEMORY_SUMMARY_BY_THREAD_BY_EVENT_NAME. */
+class table_mems_by_thread_by_event_name : public PFS_engine_table
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+private:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_mems_by_thread_by_event_name();
+
+public:
+ ~table_mems_by_thread_by_event_name()
+ {}
+
+private:
+ void make_row(PFS_thread *thread, PFS_memory_class *klass);
+
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+ /** Fields definition. */
+ static TABLE_FIELD_DEF m_field_def;
+
+ /** Current row. */
+ row_mems_by_thread_by_event_name m_row;
+ /** True is the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ pos_mems_by_thread_by_event_name m_pos;
+ /** Next position. */
+ pos_mems_by_thread_by_event_name m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_mems_by_user_by_event_name.cc b/storage/perfschema/table_mems_by_user_by_event_name.cc
new file mode 100644
index 00000000..5d5ee89d
--- /dev/null
+++ b/storage/perfschema/table_mems_by_user_by_event_name.cc
@@ -0,0 +1,221 @@
+/* Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_mems_by_user_by_event_name.cc
+ Table MEMORY_SUMMARY_BY_USER_BY_EVENT_NAME (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "pfs_instr_class.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "table_mems_by_user_by_event_name.h"
+#include "pfs_global.h"
+#include "pfs_visitor.h"
+#include "pfs_memory.h"
+#include "pfs_buffer_container.h"
+#include "field.h"
+
+THR_LOCK table_mems_by_user_by_event_name::m_table_lock;
+
+PFS_engine_table_share
+table_mems_by_user_by_event_name::m_share=
+{
+ { C_STRING_WITH_LEN("memory_summary_by_user_by_event_name") },
+ &pfs_readonly_acl,
+ table_mems_by_user_by_event_name::create,
+ NULL, /* write_row */
+ table_mems_by_user_by_event_name::delete_all_rows,
+ table_mems_by_user_by_event_name::get_row_count,
+ sizeof(PFS_simple_index),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE memory_summary_by_user_by_event_name("
+ "USER CHAR(32) collate utf8_bin default null,"
+ "EVENT_NAME VARCHAR(128) not null,"
+ "COUNT_ALLOC BIGINT unsigned not null,"
+ "COUNT_FREE BIGINT unsigned not null,"
+ "SUM_NUMBER_OF_BYTES_ALLOC BIGINT unsigned not null,"
+ "SUM_NUMBER_OF_BYTES_FREE BIGINT unsigned not null,"
+ "LOW_COUNT_USED BIGINT not null,"
+ "CURRENT_COUNT_USED BIGINT not null,"
+ "HIGH_COUNT_USED BIGINT not null,"
+ "LOW_NUMBER_OF_BYTES_USED BIGINT not null,"
+ "CURRENT_NUMBER_OF_BYTES_USED BIGINT not null,"
+ "HIGH_NUMBER_OF_BYTES_USED BIGINT not null)")},
+ false /* perpetual */
+};
+
+PFS_engine_table* table_mems_by_user_by_event_name::create(void)
+{
+ return new table_mems_by_user_by_event_name();
+}
+
+int
+table_mems_by_user_by_event_name::delete_all_rows(void)
+{
+ reset_memory_by_thread();
+ reset_memory_by_account();
+ reset_memory_by_user();
+ return 0;
+}
+
+ha_rows
+table_mems_by_user_by_event_name::get_row_count(void)
+{
+ return global_user_container.get_row_count() * memory_class_max;
+}
+
+table_mems_by_user_by_event_name::table_mems_by_user_by_event_name()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(), m_next_pos()
+{}
+
+void table_mems_by_user_by_event_name::reset_position(void)
+{
+ m_pos.reset();
+ m_next_pos.reset();
+}
+
+int table_mems_by_user_by_event_name::rnd_next(void)
+{
+ PFS_user *user;
+ PFS_memory_class *memory_class;
+ bool has_more_user= true;
+
+ for (m_pos.set_at(&m_next_pos);
+ has_more_user;
+ m_pos.next_user())
+ {
+ user= global_user_container.get(m_pos.m_index_1, & has_more_user);
+ if (user != NULL)
+ {
+ do
+ {
+ memory_class= find_memory_class(m_pos.m_index_2);
+ if (memory_class != NULL)
+ {
+ if (! memory_class->is_global())
+ {
+ make_row(user, memory_class);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+
+ m_pos.next_class();
+ }
+ }
+ while (memory_class != NULL);
+ }
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int table_mems_by_user_by_event_name::rnd_pos(const void *pos)
+{
+ PFS_user *user;
+ PFS_memory_class *memory_class;
+
+ set_position(pos);
+
+ user= global_user_container.get(m_pos.m_index_1);
+ if (user != NULL)
+ {
+ memory_class= find_memory_class(m_pos.m_index_2);
+ if (memory_class != NULL)
+ {
+ if (! memory_class->is_global())
+ {
+ make_row(user, memory_class);
+ return 0;
+ }
+ }
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_mems_by_user_by_event_name
+::make_row(PFS_user *user, PFS_memory_class *klass)
+{
+ pfs_optimistic_state lock;
+ m_row_exists= false;
+
+ user->m_lock.begin_optimistic_lock(&lock);
+
+ if (m_row.m_user.make_row(user))
+ return;
+
+ m_row.m_event_name.make_row(klass);
+
+ PFS_connection_memory_visitor visitor(klass);
+ PFS_connection_iterator::visit_user(user,
+ true, /* accounts */
+ true, /* threads */
+ false, /* THDs */
+ & visitor);
+
+ if (! user->m_lock.end_optimistic_lock(&lock))
+ return;
+
+ m_row_exists= true;
+ m_row.m_stat.set(& visitor.m_stat);
+}
+
+int table_mems_by_user_by_event_name::read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* USER */
+ m_row.m_user.set_field(f);
+ break;
+ case 1: /* EVENT_NAME */
+ m_row.m_event_name.set_field(f);
+ break;
+ default: /* 2, ... HIGH_NUMBER_OF_BYTES_USED */
+ m_row.m_stat.set_field(f->field_index - 2, f);
+ break;
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_mems_by_user_by_event_name.h b/storage/perfschema/table_mems_by_user_by_event_name.h
new file mode 100644
index 00000000..2791e1d3
--- /dev/null
+++ b/storage/perfschema/table_mems_by_user_by_event_name.h
@@ -0,0 +1,129 @@
+/* Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_MEMORY_SUMMARY_BY_USER_BY_EVENT_NAME_H
+#define TABLE_MEMORY_SUMMARY_BY_USER_BY_EVENT_NAME_H
+
+/**
+ @file storage/perfschema/table_mems_by_user_by_event_name.h
+ Table MEMORY_SUMMARY_BY_USER_BY_EVENT_NAME (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_instr_class.h"
+#include "pfs_user.h"
+#include "table_helper.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/** A row of PERFORMANCE_SCHEMA.MEMORY_SUMMARY_BY_USER_BY_EVENT_NAME. */
+struct row_mems_by_user_by_event_name
+{
+ /** Column USER. */
+ PFS_user_row m_user;
+ /** Column EVENT_NAME. */
+ PFS_event_name_row m_event_name;
+ /** Columns COUNT_ALLOC, ... */
+ PFS_memory_stat_row m_stat;
+};
+
+/**
+ Position of a cursor on
+ PERFORMANCE_SCHEMA.EVENTS_MEMORY_SUMMARY_BY_USER_BY_EVENT_NAME.
+ Index 1 on user (0 based)
+ Index 2 on memory class (1 based)
+*/
+struct pos_mems_by_user_by_event_name
+: public PFS_double_index
+{
+ pos_mems_by_user_by_event_name()
+ : PFS_double_index(0, 1)
+ {}
+
+ inline void reset(void)
+ {
+ m_index_1= 0;
+ m_index_2= 1;
+ }
+
+ inline void next_user(void)
+ {
+ m_index_1++;
+ m_index_2= 1;
+ }
+
+ inline void next_class(void)
+ {
+ m_index_2++;
+ }
+};
+
+/** Table PERFORMANCE_SCHEMA.MEMORY_SUMMARY_BY_USER_BY_EVENT_NAME. */
+class table_mems_by_user_by_event_name : public PFS_engine_table
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+private:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_mems_by_user_by_event_name();
+
+public:
+ ~table_mems_by_user_by_event_name()
+ {}
+
+private:
+ void make_row(PFS_user *user, PFS_memory_class *klass);
+
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+ /** Fields definition. */
+ static TABLE_FIELD_DEF m_field_def;
+
+ /** Current row. */
+ row_mems_by_user_by_event_name m_row;
+ /** True is the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ pos_mems_by_user_by_event_name m_pos;
+ /** Next position. */
+ pos_mems_by_user_by_event_name m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_mems_global_by_event_name.cc b/storage/perfschema/table_mems_global_by_event_name.cc
new file mode 100644
index 00000000..93496e38
--- /dev/null
+++ b/storage/perfschema/table_mems_global_by_event_name.cc
@@ -0,0 +1,241 @@
+/* Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_mems_global_by_event_name.cc
+ Table MEMORY_SUMMARY_GLOBAL_BY_EVENT_NAME (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "pfs_instr_class.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "table_mems_global_by_event_name.h"
+#include "pfs_global.h"
+#include "pfs_visitor.h"
+#include "pfs_builtin_memory.h"
+#include "pfs_memory.h"
+#include "field.h"
+
+THR_LOCK table_mems_global_by_event_name::m_table_lock;
+
+PFS_engine_table_share
+table_mems_global_by_event_name::m_share=
+{
+ { C_STRING_WITH_LEN("memory_summary_global_by_event_name") },
+ &pfs_readonly_acl,
+ table_mems_global_by_event_name::create,
+ NULL, /* write_row */
+ table_mems_global_by_event_name::delete_all_rows,
+ table_mems_global_by_event_name::get_row_count,
+ sizeof(pos_t),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE memory_summary_global_by_event_name("
+ "EVENT_NAME VARCHAR(128) not null,"
+ "COUNT_ALLOC BIGINT unsigned not null,"
+ "COUNT_FREE BIGINT unsigned not null,"
+ "SUM_NUMBER_OF_BYTES_ALLOC BIGINT unsigned not null,"
+ "SUM_NUMBER_OF_BYTES_FREE BIGINT unsigned not null,"
+ "LOW_COUNT_USED BIGINT not null,"
+ "CURRENT_COUNT_USED BIGINT not null,"
+ "HIGH_COUNT_USED BIGINT not null,"
+ "LOW_NUMBER_OF_BYTES_USED BIGINT not null,"
+ "CURRENT_NUMBER_OF_BYTES_USED BIGINT not null,"
+ "HIGH_NUMBER_OF_BYTES_USED BIGINT not null)")},
+ false /* perpetual */
+};
+
+PFS_engine_table* table_mems_global_by_event_name::create(void)
+{
+ return new table_mems_global_by_event_name();
+}
+
+int
+table_mems_global_by_event_name::delete_all_rows(void)
+{
+ reset_memory_by_thread();
+ reset_memory_by_account();
+ reset_memory_by_user();
+ reset_memory_by_host();
+ reset_memory_global();
+ return 0;
+}
+
+ha_rows
+table_mems_global_by_event_name::get_row_count(void)
+{
+ return memory_class_max;
+}
+
+table_mems_global_by_event_name::table_mems_global_by_event_name()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(), m_next_pos()
+{}
+
+void table_mems_global_by_event_name::reset_position(void)
+{
+ m_pos.reset();
+ m_next_pos.reset();
+}
+
+int table_mems_global_by_event_name::rnd_next(void)
+{
+ PFS_memory_class *pfs;
+ PFS_builtin_memory_class *pfs_builtin;
+
+ /* Do not advertise hard coded instruments when disabled. */
+ if (! pfs_initialized)
+ return HA_ERR_END_OF_FILE;
+
+ for (m_pos.set_at(&m_next_pos);
+ m_pos.has_more_view();
+ m_pos.next_view())
+ {
+ switch (m_pos.m_index_1)
+ {
+ case pos_mems_global_by_event_name::VIEW_BUILTIN_MEMORY:
+ pfs_builtin= find_builtin_memory_class(m_pos.m_index_2);
+ if (pfs_builtin != NULL)
+ {
+ make_row(pfs_builtin);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ break;
+ case pos_mems_global_by_event_name::VIEW_MEMORY:
+ pfs= find_memory_class(m_pos.m_index_2);
+ if (pfs != NULL)
+ {
+ make_row(pfs);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ break;
+ }
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int table_mems_global_by_event_name::rnd_pos(const void *pos)
+{
+ PFS_builtin_memory_class *pfs_builtin;
+ PFS_memory_class *pfs;
+
+ /* Do not advertise hard coded instruments when disabled. */
+ if (! pfs_initialized)
+ return HA_ERR_END_OF_FILE;
+
+ set_position(pos);
+
+ switch(m_pos.m_index_1)
+ {
+ case pos_mems_global_by_event_name::VIEW_BUILTIN_MEMORY:
+ pfs_builtin= find_builtin_memory_class(m_pos.m_index_2);
+ if (pfs_builtin != NULL)
+ {
+ make_row(pfs_builtin);
+ return 0;
+ }
+ break;
+ case pos_mems_global_by_event_name::VIEW_MEMORY:
+ pfs= find_memory_class(m_pos.m_index_2);
+ if (pfs != NULL)
+ {
+ make_row(pfs);
+ return 0;
+ }
+ break;
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_mems_global_by_event_name::make_row(PFS_memory_class *klass)
+{
+ m_row.m_event_name.make_row(klass);
+
+ PFS_connection_memory_visitor visitor(klass);
+
+ if (klass->is_global())
+ {
+ PFS_connection_iterator::visit_global(false, /* hosts */
+ false, /* users */
+ false, /* accounts */
+ false, /* threads */
+ false, /* THDs */
+ &visitor);
+ }
+ else
+ {
+ PFS_connection_iterator::visit_global(true, /* hosts */
+ false, /* users */
+ true, /* accounts */
+ true, /* threads */
+ false, /* THDs */
+ &visitor);
+ }
+
+ m_row.m_stat.set(& visitor.m_stat);
+ m_row_exists= true;
+}
+
+void table_mems_global_by_event_name::make_row(PFS_builtin_memory_class *klass)
+{
+ m_row.m_event_name.make_row(& klass->m_class);
+ m_row.m_stat.set(& klass->m_stat);
+ m_row_exists= true;
+}
+
+int table_mems_global_by_event_name::read_row_values(TABLE *table,
+ unsigned char *,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 0);
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* EVENT_NAME */
+ m_row.m_event_name.set_field(f);
+ break;
+ default: /* 1, ... HIGH_NUMBER_OF_BYTES_USED */
+ m_row.m_stat.set_field(f->field_index - 1, f);
+ break;
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_mems_global_by_event_name.h b/storage/perfschema/table_mems_global_by_event_name.h
new file mode 100644
index 00000000..14a54142
--- /dev/null
+++ b/storage/perfschema/table_mems_global_by_event_name.h
@@ -0,0 +1,132 @@
+/* Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_MEMORY_SUMMARY_GLOBAL_BY_EVENT_NAME_H
+#define TABLE_MEMORY_SUMMARY_GLOBAL_BY_EVENT_NAME_H
+
+/**
+ @file storage/perfschema/table_mems_global_by_event_name.h
+ Table MEMORY_SUMMARY_GLOBAL_BY_EVENT_NAME (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_instr_class.h"
+#include "pfs_builtin_memory.h"
+#include "table_helper.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/** A row of PERFORMANCE_SCHEMA.MEMORY_SUMMARY_GLOBAL_BY_EVENT_NAME. */
+struct row_mems_global_by_event_name
+{
+ /** Column EVENT_NAME. */
+ PFS_event_name_row m_event_name;
+ /** Columns COUNT_ALLOC, ... */
+ PFS_memory_stat_row m_stat;
+};
+
+/**
+ Position of a cursor on
+ PERFORMANCE_SCHEMA.MEMORY_SUMMARY_GLOBAL_BY_EVENT_NAME.
+ Index 1 on view
+ Index 2 on instrument key (1 based)
+*/
+struct pos_mems_global_by_event_name : public PFS_double_index
+{
+ static const uint FIRST_VIEW= 1;
+ static const uint VIEW_BUILTIN_MEMORY= 1;
+ static const uint VIEW_MEMORY= 2;
+ static const uint LAST_VIEW= 2;
+
+ pos_mems_global_by_event_name()
+ : PFS_double_index(FIRST_VIEW, 1)
+ {}
+
+ inline void reset(void)
+ {
+ m_index_1= FIRST_VIEW;
+ m_index_2= 1;
+ }
+
+ inline bool has_more_view(void)
+ { return (m_index_1 <= LAST_VIEW); }
+
+ inline void next_view(void)
+ {
+ m_index_1++;
+ m_index_2= 1;
+ }
+};
+
+/** Table PERFORMANCE_SCHEMA.MEMORY_SUMMARY_GLOBAL_BY_EVENT_NAME. */
+class table_mems_global_by_event_name : public PFS_engine_table
+{
+ typedef pos_mems_global_by_event_name pos_t;
+
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+private:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_mems_global_by_event_name();
+
+public:
+ ~table_mems_global_by_event_name()
+ {}
+
+private:
+ void make_row(PFS_builtin_memory_class *klass);
+ void make_row(PFS_memory_class *klass);
+
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+ /** Fields definition. */
+ static TABLE_FIELD_DEF m_field_def;
+
+ /** Current row. */
+ row_mems_global_by_event_name m_row;
+ /** True is the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ pos_t m_pos;
+ /** Next position. */
+ pos_t m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_os_global_by_type.cc b/storage/perfschema/table_os_global_by_type.cc
new file mode 100644
index 00000000..f693a0f1
--- /dev/null
+++ b/storage/perfschema/table_os_global_by_type.cc
@@ -0,0 +1,303 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_os_global_by_type.cc
+ Table OBJECTS_SUMMARY_GLOBAL_BY_TYPE (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "pfs_instr_class.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "table_os_global_by_type.h"
+#include "pfs_global.h"
+#include "pfs_buffer_container.h"
+#include "field.h"
+
+THR_LOCK table_os_global_by_type::m_table_lock;
+
+PFS_engine_table_share
+table_os_global_by_type::m_share=
+{
+ { C_STRING_WITH_LEN("objects_summary_global_by_type") },
+ &pfs_truncatable_acl,
+ table_os_global_by_type::create,
+ NULL, /* write_row */
+ table_os_global_by_type::delete_all_rows,
+ table_os_global_by_type::get_row_count,
+ sizeof(pos_os_global_by_type),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE objects_summary_global_by_type("
+ "OBJECT_TYPE VARCHAR(64),"
+ "OBJECT_SCHEMA VARCHAR(64),"
+ "OBJECT_NAME VARCHAR(64),"
+ "COUNT_STAR BIGINT unsigned not null,"
+ "SUM_TIMER_WAIT BIGINT unsigned not null,"
+ "MIN_TIMER_WAIT BIGINT unsigned not null,"
+ "AVG_TIMER_WAIT BIGINT unsigned not null,"
+ "MAX_TIMER_WAIT BIGINT unsigned not null)") },
+ false /* perpetual */
+};
+
+PFS_engine_table*
+table_os_global_by_type::create(void)
+{
+ return new table_os_global_by_type();
+}
+
+int
+table_os_global_by_type::delete_all_rows(void)
+{
+ reset_table_waits_by_table_handle();
+ reset_table_waits_by_table();
+ return 0;
+}
+
+ha_rows
+table_os_global_by_type::get_row_count(void)
+{
+ return global_table_share_container.get_row_count() +
+ global_program_container.get_row_count();
+}
+
+table_os_global_by_type::table_os_global_by_type()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(), m_next_pos()
+{}
+
+void table_os_global_by_type::reset_position(void)
+{
+ m_pos.reset();
+ m_next_pos.reset();
+}
+
+int table_os_global_by_type::rnd_next(void)
+{
+ for (m_pos.set_at(&m_next_pos);
+ m_pos.has_more_view();
+ m_pos.next_view())
+ {
+ switch (m_pos.m_index_1) {
+ case pos_os_global_by_type::VIEW_TABLE:
+ {
+ PFS_table_share *table_share;
+ bool has_more_share= true;
+
+ for (;
+ has_more_share;
+ m_pos.m_index_2++)
+ {
+ table_share= global_table_share_container.get(m_pos.m_index_2, & has_more_share);
+ if (table_share != NULL)
+ {
+ make_table_row(table_share);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+ }
+ break;
+ case pos_os_global_by_type::VIEW_PROGRAM:
+ {
+ PFS_program *pfs_program;
+ bool has_more_program= true;
+
+ for (;
+ has_more_program;
+ m_pos.m_index_2++)
+ {
+ pfs_program= global_program_container.get(m_pos.m_index_2, & has_more_program);
+ if (pfs_program != NULL)
+ {
+ make_program_row(pfs_program);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+ }
+ break;
+ default:
+ break;
+ }
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int
+table_os_global_by_type::rnd_pos(const void *pos)
+{
+ set_position(pos);
+
+ switch (m_pos.m_index_1) {
+ case pos_os_global_by_type::VIEW_TABLE:
+ {
+ PFS_table_share *table_share;
+ table_share= global_table_share_container.get(m_pos.m_index_2);
+ if (table_share != NULL)
+ {
+ make_table_row(table_share);
+ return 0;
+ }
+ }
+ break;
+ case pos_os_global_by_type::VIEW_PROGRAM:
+ {
+ PFS_program *pfs_program;
+ pfs_program= global_program_container.get(m_pos.m_index_2);
+ if (pfs_program != NULL)
+ {
+ make_program_row(pfs_program);
+ return 0;
+ }
+ }
+ break;
+ default:
+ break;
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_os_global_by_type::make_program_row(PFS_program *pfs_program)
+{
+ pfs_optimistic_state lock;
+ PFS_single_stat cumulated_stat;
+
+ m_row_exists= false;
+
+ pfs_program->m_lock.begin_optimistic_lock(&lock);
+
+ m_row.m_object.make_row(pfs_program);
+
+ time_normalizer *normalizer= time_normalizer::get(wait_timer);
+ m_row.m_stat.set(normalizer, &pfs_program->m_sp_stat.m_timer1_stat);
+
+ if (! pfs_program->m_lock.end_optimistic_lock(&lock))
+ return;
+
+ m_row_exists= true;
+}
+
+void table_os_global_by_type::make_table_row(PFS_table_share *share)
+{
+ pfs_optimistic_state lock;
+ PFS_single_stat cumulated_stat;
+ uint safe_key_count;
+
+ m_row_exists= false;
+
+ share->m_lock.begin_optimistic_lock(&lock);
+
+ m_row.m_object.make_row(share);
+
+ /* This is a dirty read, some thread can write data while we are reading it */
+ safe_key_count= sanitize_index_count(share->m_key_count);
+
+ share->sum(& cumulated_stat, safe_key_count);
+
+ if (! share->m_lock.end_optimistic_lock(&lock))
+ return;
+
+ m_row_exists= true;
+
+ if (share->get_refcount() > 0)
+ {
+ /* For all the table handles still opened ... */
+ PFS_table_iterator it= global_table_container.iterate();
+ PFS_table *table= it.scan_next();
+
+ while (table != NULL)
+ {
+ if (table->m_share == share)
+ {
+ /*
+ If the opened table handle is for this table share,
+ aggregate the table handle statistics.
+ */
+ table->m_table_stat.sum(& cumulated_stat, safe_key_count);
+ }
+ table= it.scan_next();
+ }
+ }
+
+ time_normalizer *normalizer= time_normalizer::get(wait_timer);
+ m_row.m_stat.set(normalizer, &cumulated_stat);
+}
+
+int table_os_global_by_type::read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* OBJECT_TYPE */
+ set_field_object_type(f, m_row.m_object.m_object_type);
+ break;
+ case 1: /* SCHEMA_NAME */
+ set_field_varchar_utf8(f, m_row.m_object.m_schema_name,
+ m_row.m_object.m_schema_name_length);
+ break;
+ case 2: /* OBJECT_NAME */
+ set_field_varchar_utf8(f, m_row.m_object.m_object_name,
+ m_row.m_object.m_object_name_length);
+ break;
+ case 3: /* COUNT */
+ set_field_ulonglong(f, m_row.m_stat.m_count);
+ break;
+ case 4: /* SUM */
+ set_field_ulonglong(f, m_row.m_stat.m_sum);
+ break;
+ case 5: /* MIN */
+ set_field_ulonglong(f, m_row.m_stat.m_min);
+ break;
+ case 6: /* AVG */
+ set_field_ulonglong(f, m_row.m_stat.m_avg);
+ break;
+ case 7: /* MAX */
+ set_field_ulonglong(f, m_row.m_stat.m_max);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_os_global_by_type.h b/storage/perfschema/table_os_global_by_type.h
new file mode 100644
index 00000000..37e6db1e
--- /dev/null
+++ b/storage/perfschema/table_os_global_by_type.h
@@ -0,0 +1,131 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_OBJECTS_SUMMARY_GLOBAL_BY_TYPE_H
+#define TABLE_OBJECTS_SUMMARY_GLOBAL_BY_TYPE_H
+
+/**
+ @file storage/perfschema/table_os_global_by_type.h
+ Table OBJECTS_SUMMARY_GLOBAL_BY_TYPE (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "pfs_program.h"
+#include "table_helper.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/**
+ A row of table
+ PERFORMANCE_SCHEMA.OBJECTS_SUMMARY_GLOBAL_BY_TYPE.
+*/
+struct row_os_global_by_type
+{
+ /** Column OBJECT_TYPE, SCHEMA_NAME, OBJECT_NAME. */
+ PFS_object_row m_object;
+
+ /** Columns COUNT_STAR, SUM/MIN/AVG/MAX TIMER_WAIT. */
+ PFS_stat_row m_stat;
+};
+
+/**
+ Position of a cursor on
+ PERFORMANCE_SCHEMA.OBJECTS_SUMMARY_GLOBAL_BY_TYPE.
+ Index 1 on object type
+ Index 2 on object instance (0 based)
+*/
+struct pos_os_global_by_type : public PFS_double_index,
+ public PFS_object_view_constants
+{
+ pos_os_global_by_type()
+ : PFS_double_index(FIRST_VIEW, 0)
+ {}
+
+ inline void reset(void)
+ {
+ m_index_1= FIRST_VIEW;
+ m_index_2= 0;
+ }
+
+ inline bool has_more_view(void)
+ { return (m_index_1 <= LAST_VIEW); }
+
+ inline void next_view(void)
+ {
+ m_index_1++;
+ m_index_2= 0;
+ }
+};
+
+/** Table PERFORMANCE_SCHEMA.OBJECTS_SUMMARY_GLOBAL_BY_TYPE. */
+class table_os_global_by_type : public PFS_engine_table
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_os_global_by_type();
+
+public:
+ ~table_os_global_by_type()
+ {}
+
+protected:
+ void make_table_row(PFS_table_share *table_share);
+ void make_program_row(PFS_program *pfs_program);
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ /** Current row. */
+ row_os_global_by_type m_row;
+ /** True is the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ pos_os_global_by_type m_pos;
+ /** Next position. */
+ pos_os_global_by_type m_next_pos;
+};
+
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_performance_timers.cc b/storage/perfschema/table_performance_timers.cc
new file mode 100644
index 00000000..1c1d9c5a
--- /dev/null
+++ b/storage/perfschema/table_performance_timers.cc
@@ -0,0 +1,177 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_performance_timers.cc
+ Table PERFORMANCE_TIMERS (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "table_performance_timers.h"
+#include "pfs_timer.h"
+#include "pfs_global.h"
+#include "field.h"
+
+THR_LOCK table_performance_timers::m_table_lock;
+
+PFS_engine_table_share
+table_performance_timers::m_share=
+{
+ { C_STRING_WITH_LEN("performance_timers") },
+ &pfs_readonly_acl,
+ table_performance_timers::create,
+ NULL, /* write_row */
+ NULL, /* delete_all_rows */
+ table_performance_timers::get_row_count,
+ sizeof(PFS_simple_index), /* ref length */
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE performance_timers("
+ "TIMER_NAME ENUM ('CYCLE', 'NANOSECOND', 'MICROSECOND', 'MILLISECOND', 'TICK') not null,"
+ "TIMER_FREQUENCY BIGINT,"
+ "TIMER_RESOLUTION BIGINT,"
+ "TIMER_OVERHEAD BIGINT)") },
+ false /* perpetual */
+};
+
+PFS_engine_table* table_performance_timers::create(void)
+{
+ return new table_performance_timers();
+}
+
+ha_rows
+table_performance_timers::get_row_count(void)
+{
+ return COUNT_TIMER_NAME;
+}
+
+table_performance_timers::table_performance_timers()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row(NULL), m_pos(0), m_next_pos(0)
+{
+ int index;
+
+ index= (int)TIMER_NAME_CYCLE - FIRST_TIMER_NAME;
+ m_data[index].m_timer_name= TIMER_NAME_CYCLE;
+ m_data[index].m_info= sys_timer_info.cycles;
+
+ index= (int)TIMER_NAME_NANOSEC - FIRST_TIMER_NAME;
+ m_data[index].m_timer_name= TIMER_NAME_NANOSEC;
+ m_data[index].m_info= sys_timer_info.nanoseconds;
+
+ index= (int)TIMER_NAME_MICROSEC - FIRST_TIMER_NAME;
+ m_data[index].m_timer_name= TIMER_NAME_MICROSEC;
+ m_data[index].m_info= sys_timer_info.microseconds;
+
+ index= (int)TIMER_NAME_MILLISEC - FIRST_TIMER_NAME;
+ m_data[index].m_timer_name= TIMER_NAME_MILLISEC;
+ m_data[index].m_info= sys_timer_info.milliseconds;
+
+ index= (int)TIMER_NAME_TICK - FIRST_TIMER_NAME;
+ m_data[index].m_timer_name= TIMER_NAME_TICK;
+ m_data[index].m_info= sys_timer_info.ticks;
+}
+
+void table_performance_timers::reset_position(void)
+{
+ m_pos.m_index= 0;
+ m_next_pos.m_index= 0;
+}
+
+int table_performance_timers::rnd_next(void)
+{
+ int result;
+
+ m_pos.set_at(&m_next_pos);
+
+ if (m_pos.m_index < COUNT_TIMER_NAME)
+ {
+ m_row= &m_data[m_pos.m_index];
+ m_next_pos.set_after(&m_pos);
+ result= 0;
+ }
+ else
+ {
+ m_row= NULL;
+ result= HA_ERR_END_OF_FILE;
+ }
+
+ return result;
+}
+
+int table_performance_timers::rnd_pos(const void *pos)
+{
+ set_position(pos);
+ DBUG_ASSERT(m_pos.m_index < COUNT_TIMER_NAME);
+ m_row= &m_data[m_pos.m_index];
+ return 0;
+}
+
+int table_performance_timers::read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ DBUG_ASSERT(m_row);
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* TIMER_NAME */
+ set_field_enum(f, m_row->m_timer_name);
+ break;
+ case 1: /* TIMER_FREQUENCY */
+ if (m_row->m_info.routine != 0)
+ set_field_ulonglong(f, m_row->m_info.frequency);
+ else
+ f->set_null();
+ break;
+ case 2: /* TIMER_RESOLUTION */
+ if (m_row->m_info.routine != 0)
+ set_field_ulonglong(f, m_row->m_info.resolution);
+ else
+ f->set_null();
+ break;
+ case 3: /* TIMER_OVERHEAD */
+ if (m_row->m_info.routine != 0)
+ set_field_ulonglong(f, m_row->m_info.overhead);
+ else
+ f->set_null();
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_performance_timers.h b/storage/perfschema/table_performance_timers.h
new file mode 100644
index 00000000..fe5f9cd5
--- /dev/null
+++ b/storage/perfschema/table_performance_timers.h
@@ -0,0 +1,92 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_PERFORMANCE_TIMERS_H
+#define TABLE_PERFORMANCE_TIMERS_H
+
+/**
+ @file storage/perfschema/table_performance_timers.h
+ Table PERFORMANCE_TIMERS (declarations).
+*/
+
+#include <my_rdtsc.h>
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/** A row of PERFORMANCE_SCHEMA.PERFORMANCE_TIMERS. */
+struct row_performance_timers
+{
+ /** Column TIMER_NAME. */
+ enum_timer_name m_timer_name;
+ /**
+ Columns ROUTINE (not displayed), TIMER_OVERHEAD,
+ TIMER_FREQUENCY, TIMER_RESOLUTION.
+ */
+ struct my_timer_unit_info m_info;
+};
+
+/** Table PERFORMANCE_SCHEMA.PERFORMANCE_TIMERS. */
+class table_performance_timers : public PFS_engine_table
+{
+public:
+ /** Table share. */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static ha_rows get_row_count();
+
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+protected:
+ table_performance_timers();
+
+public:
+ ~table_performance_timers()
+ {}
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ /** Current row. */
+ row_performance_timers *m_row;
+ /** Current position. */
+ PFS_simple_index m_pos;
+ /** Next position. */
+ PFS_simple_index m_next_pos;
+ row_performance_timers m_data[COUNT_TIMER_NAME];
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_prepared_stmt_instances.cc b/storage/perfschema/table_prepared_stmt_instances.cc
new file mode 100644
index 00000000..6e93523d
--- /dev/null
+++ b/storage/perfschema/table_prepared_stmt_instances.cc
@@ -0,0 +1,294 @@
+/* Copyright (c) 2014, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_prepared_stmt_instances.cc
+ Table PREPARED_STATEMENTS_INSTANCES (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "pfs_instr_class.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "pfs_global.h"
+#include "pfs_instr.h"
+#include "pfs_timer.h"
+#include "pfs_visitor.h"
+#include "pfs_prepared_stmt.h"
+#include "table_prepared_stmt_instances.h"
+#include "pfs_buffer_container.h"
+#include "field.h"
+
+THR_LOCK table_prepared_stmt_instances::m_table_lock;
+
+PFS_engine_table_share
+table_prepared_stmt_instances::m_share=
+{
+ { C_STRING_WITH_LEN("prepared_statements_instances") },
+ &pfs_truncatable_acl,
+ table_prepared_stmt_instances::create,
+ NULL, /* write_row */
+ table_prepared_stmt_instances::delete_all_rows,
+ table_prepared_stmt_instances::get_row_count,
+ sizeof(PFS_simple_index),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE prepared_statements_instances("
+ "OBJECT_INSTANCE_BEGIN bigint(20) unsigned NOT NULL,"
+ "STATEMENT_ID bigint(20) unsigned NOT NULL,"
+ "STATEMENT_NAME varchar(64) default NULL,"
+ "SQL_TEXT longtext NOT NULL,"
+ "OWNER_THREAD_ID bigint(20) unsigned NOT NULL,"
+ "OWNER_EVENT_ID bigint(20) unsigned NOT NULL,"
+ "OWNER_OBJECT_TYPE enum('EVENT','FUNCTION','PROCEDURE','TABLE','TRIGGER') DEFAULT NULL,"
+ "OWNER_OBJECT_SCHEMA varchar(64) DEFAULT NULL,"
+ "OWNER_OBJECT_NAME varchar(64) DEFAULT NULL,"
+ "TIMER_PREPARE bigint(20) unsigned NOT NULL,"
+ "COUNT_REPREPARE bigint(20) unsigned NOT NULL,"
+ "COUNT_EXECUTE bigint(20) unsigned NOT NULL,"
+ "SUM_TIMER_EXECUTE bigint(20) unsigned NOT NULL,"
+ "MIN_TIMER_EXECUTE bigint(20) unsigned NOT NULL,"
+ "AVG_TIMER_EXECUTE bigint(20) unsigned NOT NULL,"
+ "MAX_TIMER_EXECUTE bigint(20) unsigned NOT NULL,"
+ "SUM_LOCK_TIME bigint(20) unsigned NOT NULL,"
+ "SUM_ERRORS bigint(20) unsigned NOT NULL,"
+ "SUM_WARNINGS bigint(20) unsigned NOT NULL,"
+ "SUM_ROWS_AFFECTED bigint(20) unsigned NOT NULL,"
+ "SUM_ROWS_SENT bigint(20) unsigned NOT NULL,"
+ "SUM_ROWS_EXAMINED bigint(20) unsigned NOT NULL,"
+ "SUM_CREATED_TMP_DISK_TABLES bigint(20) unsigned NOT NULL,"
+ "SUM_CREATED_TMP_TABLES bigint(20) unsigned NOT NULL,"
+ "SUM_SELECT_FULL_JOIN bigint(20) unsigned NOT NULL,"
+ "SUM_SELECT_FULL_RANGE_JOIN bigint(20) unsigned NOT NULL,"
+ "SUM_SELECT_RANGE bigint(20) unsigned NOT NULL,"
+ "SUM_SELECT_RANGE_CHECK bigint(20) unsigned NOT NULL,"
+ "SUM_SELECT_SCAN bigint(20) unsigned NOT NULL,"
+ "SUM_SORT_MERGE_PASSES bigint(20) unsigned NOT NULL,"
+ "SUM_SORT_RANGE bigint(20) unsigned NOT NULL,"
+ "SUM_SORT_ROWS bigint(20) unsigned NOT NULL,"
+ "SUM_SORT_SCAN bigint(20) unsigned NOT NULL,"
+ "SUM_NO_INDEX_USED bigint(20) unsigned NOT NULL,"
+ "SUM_NO_GOOD_INDEX_USED bigint(20) unsigned NOT NULL)")},
+ false /* perpetual */
+};
+
+PFS_engine_table*
+table_prepared_stmt_instances::create(void)
+{
+ return new table_prepared_stmt_instances();
+}
+
+int
+table_prepared_stmt_instances::delete_all_rows(void)
+{
+ reset_prepared_stmt_instances();
+ return 0;
+}
+
+ha_rows
+table_prepared_stmt_instances::get_row_count(void)
+{
+ return global_prepared_stmt_container.get_row_count();
+}
+
+table_prepared_stmt_instances::table_prepared_stmt_instances()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(0), m_next_pos(0)
+{}
+
+void table_prepared_stmt_instances::reset_position(void)
+{
+ m_pos= 0;
+ m_next_pos= 0;
+}
+
+int table_prepared_stmt_instances::rnd_next(void)
+{
+ PFS_prepared_stmt* pfs;
+
+ m_pos.set_at(&m_next_pos);
+ PFS_prepared_stmt_iterator it= global_prepared_stmt_container.iterate(m_pos.m_index);
+ pfs= it.scan_next(& m_pos.m_index);
+ if (pfs != NULL)
+ {
+ make_row(pfs);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int
+table_prepared_stmt_instances::rnd_pos(const void *pos)
+{
+ PFS_prepared_stmt* pfs;
+
+ set_position(pos);
+
+ pfs= global_prepared_stmt_container.get(m_pos.m_index);
+ if (pfs != NULL)
+ {
+ make_row(pfs);
+ return 0;
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+
+void table_prepared_stmt_instances::make_row(PFS_prepared_stmt* prepared_stmt)
+{
+ pfs_optimistic_state lock;
+ m_row_exists= false;
+
+ prepared_stmt->m_lock.begin_optimistic_lock(&lock);
+
+ m_row.m_identity= prepared_stmt->m_identity;
+
+ m_row.m_stmt_id= prepared_stmt->m_stmt_id;
+
+ m_row.m_owner_thread_id= prepared_stmt->m_owner_thread_id;
+ m_row.m_owner_event_id= prepared_stmt->m_owner_event_id;
+
+ m_row.m_stmt_name_length= prepared_stmt->m_stmt_name_length;
+ if(m_row.m_stmt_name_length > 0)
+ memcpy(m_row.m_stmt_name, prepared_stmt->m_stmt_name,
+ m_row.m_stmt_name_length);
+
+ m_row.m_sql_text_length= prepared_stmt->m_sqltext_length;
+ if(m_row.m_sql_text_length > 0)
+ memcpy(m_row.m_sql_text, prepared_stmt->m_sqltext,
+ m_row.m_sql_text_length);
+
+ m_row.m_owner_object_type= prepared_stmt->m_owner_object_type;
+
+ m_row.m_owner_object_name_length= prepared_stmt->m_owner_object_name_length;
+ if(m_row.m_owner_object_name_length > 0)
+ memcpy(m_row.m_owner_object_name, prepared_stmt->m_owner_object_name,
+ m_row.m_owner_object_name_length);
+
+ m_row.m_owner_object_schema_length= prepared_stmt->m_owner_object_schema_length;
+ if(m_row.m_owner_object_schema_length > 0)
+ memcpy(m_row.m_owner_object_schema, prepared_stmt->m_owner_object_schema,
+ m_row.m_owner_object_schema_length);
+
+ time_normalizer *normalizer= time_normalizer::get(statement_timer);
+ /* Get prepared statement prepare stats. */
+ m_row.m_prepare_stat.set(normalizer, & prepared_stmt->m_prepare_stat);
+ /* Get prepared statement reprepare stats. */
+ m_row.m_reprepare_stat.set(normalizer, & prepared_stmt->m_reprepare_stat);
+ /* Get prepared statement execute stats. */
+ m_row.m_execute_stat.set(normalizer, & prepared_stmt->m_execute_stat);
+
+ if (! prepared_stmt->m_lock.end_optimistic_lock(&lock))
+ return;
+
+ m_row_exists= true;
+}
+
+int table_prepared_stmt_instances
+::read_row_values(TABLE *table, unsigned char *buf, Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /*
+ Set the null bits.
+ */
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* OBJECT_INSTANCE_BEGIN */
+ set_field_ulonglong(f, (intptr)m_row.m_identity);
+ break;
+ case 1: /* STATEMENT_ID */
+ set_field_ulonglong(f, m_row.m_stmt_id);
+ break;
+ case 2: /* STATEMENT_NAME */
+ if(m_row.m_stmt_name_length > 0)
+ set_field_varchar_utf8(f, m_row.m_stmt_name,
+ m_row.m_stmt_name_length);
+ else
+ f->set_null();
+ break;
+ case 3: /* SQL_TEXT */
+ if(m_row.m_sql_text_length > 0)
+ set_field_longtext_utf8(f, m_row.m_sql_text,
+ m_row.m_sql_text_length);
+ else
+ f->set_null();
+ break;
+ case 4: /* OWNER_THREAD_ID */
+ set_field_ulonglong(f, m_row.m_owner_thread_id);
+ break;
+ case 5: /* OWNER_EVENT_ID */
+ if(m_row.m_owner_event_id > 0)
+ set_field_ulonglong(f, m_row.m_owner_event_id);
+ else
+ f->set_null();
+ break;
+ case 6: /* OWNER_OBJECT_TYPE */
+ if(m_row.m_owner_object_type != 0)
+ set_field_enum(f, m_row.m_owner_object_type);
+ else
+ f->set_null();
+ break;
+ case 7: /* OWNER_OBJECT_SCHEMA */
+ if(m_row.m_owner_object_schema_length > 0)
+ set_field_varchar_utf8(f, m_row.m_owner_object_schema,
+ m_row.m_owner_object_schema_length);
+ else
+ f->set_null();
+ break;
+ case 8: /* OWNER_OBJECT_NAME */
+ if(m_row.m_owner_object_name_length > 0)
+ set_field_varchar_utf8(f, m_row.m_owner_object_name,
+ m_row.m_owner_object_name_length);
+ else
+ f->set_null();
+ break;
+ case 9: /* TIMER_PREPARE */
+ m_row.m_prepare_stat.set_field(1, f);
+ break;
+ case 10: /* COUNT_REPREPARE */
+ m_row.m_reprepare_stat.set_field(0, f);
+ break;
+ default: /* 14, ... COUNT/SUM/MIN/AVG/MAX */
+ m_row.m_execute_stat.set_field(f->field_index - 11, f);
+ break;
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_prepared_stmt_instances.h b/storage/perfschema/table_prepared_stmt_instances.h
new file mode 100644
index 00000000..a17184d4
--- /dev/null
+++ b/storage/perfschema/table_prepared_stmt_instances.h
@@ -0,0 +1,132 @@
+/* Copyright (c) 2014, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_PREPARED_STMT_INSTANCES
+#define TABLE_PREPARED_STMT_INSTANCES
+
+/**
+ @file storage/perfschema/table_prepared_stmt_instances.h
+ Table PREPARED_STATEMENT_INSTANCE(declarations).
+*/
+
+#include "table_helper.h"
+#include "pfs_prepared_stmt.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/**
+ A row of table
+ PERFORMANCE_SCHEMA.PREPARED_STATEMENT_INSTANCES.
+*/
+struct row_prepared_stmt_instances
+{
+ /** Column OBJECT_INSTANCE_BEGIN. */
+ const void *m_identity;
+
+ /** Column STMT_ID. */
+ ulonglong m_stmt_id;
+
+ /** Column STMT_NAME. */
+ char m_stmt_name[COL_INFO_SIZE];
+ int m_stmt_name_length;
+
+ /** Column SQL_TEXT. */
+ char m_sql_text[COL_INFO_SIZE];
+ int m_sql_text_length;
+
+ /** Column OWNER_THREAD_ID. */
+ ulonglong m_owner_thread_id;
+
+ /** Column OWNER_EVENT_ID. */
+ ulonglong m_owner_event_id;
+
+ /** Column OWNER_OBJECT_TYPE. */
+ enum_object_type m_owner_object_type;
+
+ /** Column OWNER_OBJECT_SCHEMA */
+ char m_owner_object_schema[COL_OBJECT_SCHEMA_SIZE];
+ int m_owner_object_schema_length;
+
+ /** Column OWNER_OBJECT_NAME */
+ char m_owner_object_name[COL_OBJECT_NAME_SIZE];
+ int m_owner_object_name_length;
+
+ /** Columns TIMER_PREPARE. */
+ PFS_stat_row m_prepare_stat;
+
+ /** Columns COUNT_REPREPARE. */
+ PFS_stat_row m_reprepare_stat;
+
+ /** Columns COUNT_STAR...SUM_NO_GOOD_INDEX_USED. */
+ PFS_statement_stat_row m_execute_stat;
+};
+
+/** Table PERFORMANCE_SCHEMA.PREPARED_STATEMENT_INSTANCES. */
+class table_prepared_stmt_instances : public PFS_engine_table
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_prepared_stmt_instances();
+
+public:
+ ~table_prepared_stmt_instances()
+ {}
+
+protected:
+ void make_row(PFS_prepared_stmt*);
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+ /** Fields definition. */
+ static TABLE_FIELD_DEF m_field_def;
+
+ /** Current row. */
+ row_prepared_stmt_instances m_row;
+ /** True is the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ PFS_simple_index m_pos;
+ /** Next position. */
+ PFS_simple_index m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_replication_applier_configuration.cc b/storage/perfschema/table_replication_applier_configuration.cc
new file mode 100644
index 00000000..06de6c6e
--- /dev/null
+++ b/storage/perfschema/table_replication_applier_configuration.cc
@@ -0,0 +1,194 @@
+/*
+ Copyright (c) 2013, 2018, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
+
+/**
+ @file storage/perfschema/table_replication_applier_configuration.cc
+ Table replication_applier_configuration (implementation).
+*/
+
+//#define HAVE_REPLICATION
+
+#include "my_global.h"
+#include "table_replication_applier_configuration.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "slave.h"
+//#include "rpl_info.h"
+#include "rpl_rli.h"
+#include "rpl_mi.h"
+#include "sql_parse.h"
+//#include "rpl_msr.h" /* Multisource replication */
+
+#ifdef HAVE_REPLICATION
+THR_LOCK table_replication_applier_configuration::m_table_lock;
+
+PFS_engine_table_share
+table_replication_applier_configuration::m_share=
+{
+ { C_STRING_WITH_LEN("replication_applier_configuration") },
+ &pfs_readonly_acl,
+ table_replication_applier_configuration::create,
+ NULL, /* write_row */
+ NULL, /* delete_all_rows */
+ table_replication_applier_configuration::get_row_count,
+ sizeof(pos_t), /* ref length */
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE replication_applier_configuration("
+ "CHANNEL_NAME CHAR(64) collate utf8_general_ci not null,"
+ "DESIRED_DELAY INTEGER not null)") },
+ false /* perpetual */
+};
+
+PFS_engine_table* table_replication_applier_configuration::create(void)
+{
+ return new table_replication_applier_configuration();
+}
+
+table_replication_applier_configuration
+ ::table_replication_applier_configuration()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(0), m_next_pos(0)
+{}
+
+table_replication_applier_configuration
+ ::~table_replication_applier_configuration()
+{}
+
+void table_replication_applier_configuration::reset_position(void)
+{
+ m_pos.m_index= 0;
+ m_next_pos.m_index= 0;
+}
+
+
+ha_rows table_replication_applier_configuration::get_row_count()
+{
+ return master_info_index->master_info_hash.records;
+}
+
+
+int table_replication_applier_configuration::rnd_next(void)
+{
+ Master_info *mi;
+ mysql_mutex_lock(&LOCK_active_mi);
+
+ for (m_pos.set_at(&m_next_pos);
+ m_pos.m_index < master_info_index->master_info_hash.records;
+ m_pos.next())
+ {
+ mi= (Master_info *)my_hash_element(&master_info_index->master_info_hash, m_pos.m_index);
+
+ if (mi && mi->host[0])
+ {
+ make_row(mi);
+ m_next_pos.set_after(&m_pos);
+ mysql_mutex_unlock(&LOCK_active_mi);
+ return 0;
+ }
+ }
+
+ mysql_mutex_unlock(&LOCK_active_mi);
+ return HA_ERR_END_OF_FILE;
+}
+
+int table_replication_applier_configuration::rnd_pos(const void *pos)
+{
+ Master_info *mi;
+ int res= HA_ERR_RECORD_DELETED;
+
+ set_position(pos);
+
+ mysql_mutex_lock(&LOCK_active_mi);
+
+ if ((mi= (Master_info *)my_hash_element(&master_info_index->master_info_hash, m_pos.m_index)))
+ {
+ make_row(mi);
+ res= 0;
+ }
+
+ mysql_mutex_unlock(&LOCK_active_mi);
+ return res;
+}
+
+void table_replication_applier_configuration::make_row(Master_info *mi)
+{
+ m_row_exists= false;
+
+ DBUG_ASSERT(mi != NULL);
+
+ mysql_mutex_lock(&mi->data_lock);
+ mysql_mutex_lock(&mi->rli.data_lock);
+
+ m_row.channel_name_length= static_cast<uint>(mi->connection_name.length);
+ memcpy(m_row.channel_name, mi->connection_name.str, m_row.channel_name_length);
+ m_row.desired_delay= 0; //mi->rli->get_sql_delay();
+
+ mysql_mutex_unlock(&mi->rli.data_lock);
+ mysql_mutex_unlock(&mi->data_lock);
+
+ m_row_exists= true;
+}
+
+int table_replication_applier_configuration::read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /*
+ Note:
+ There are no NULL columns in this table,
+ so there are no null bits reserved for NULL flags per column.
+ There are no VARCHAR columns either, so the record is not
+ in HA_OPTION_PACK_RECORD format as most other performance_schema tables.
+ When HA_OPTION_PACK_RECORD is not set,
+ the table record reserves an extra null byte, see open_binary_frm().
+ */
+
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /**channel_name*/
+ set_field_char_utf8(f, m_row.channel_name, m_row.channel_name_length);
+ break;
+ case 1: /** desired_delay */
+ set_field_ulong(f, static_cast<ulong>(m_row.desired_delay));
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+ return 0;
+}
+#endif
diff --git a/storage/perfschema/table_replication_applier_configuration.h b/storage/perfschema/table_replication_applier_configuration.h
new file mode 100644
index 00000000..18321ac0
--- /dev/null
+++ b/storage/perfschema/table_replication_applier_configuration.h
@@ -0,0 +1,107 @@
+/*
+ Copyright (c) 2013, 2018, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
+
+
+#ifndef TABLE_REPLICATION_APPLIER_CONFIGURATION_H
+#define TABLE_REPLICATION_APPLIER_CONFIGURATION_H
+
+/**
+ @file storage/perfschema/table_replication_applier_configuration.h
+ Table replication_applier_configuration (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "rpl_mi.h"
+#include "mysql_com.h"
+#include "my_thread.h"
+//#include "rpl_msr.h"
+//#include "rpl_info.h" /*CHANNEL_NAME_LENGTH*/
+
+class Master_info;
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/** A row in the table*/
+struct st_row_applier_config {
+ char channel_name[CHANNEL_NAME_LENGTH];
+ uint channel_name_length;
+ time_t desired_delay;
+ bool desired_delay_is_set;
+};
+
+/** Table PERFORMANCE_SCHEMA.replication_applier_configuration */
+class table_replication_applier_configuration: public PFS_engine_table
+{
+ typedef PFS_simple_index pos_t;
+
+private:
+ void make_row(Master_info *mi);
+
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+ /** Fields definition. */
+ static TABLE_FIELD_DEF m_field_def;
+ /** Current row */
+ st_row_applier_config m_row;
+ /** True is the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ pos_t m_pos;
+ /** Next position. */
+ pos_t m_next_pos;
+
+protected:
+ /**
+ Read the current row values.
+ @param table Table handle
+ @param buf row buffer
+ @param fields Table fields
+ @param read_all true if all columns are read.
+ */
+
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_replication_applier_configuration();
+
+public:
+ ~table_replication_applier_configuration();
+
+ /** Table share. */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static ha_rows get_row_count();
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_replication_applier_status.cc b/storage/perfschema/table_replication_applier_status.cc
new file mode 100644
index 00000000..7083d3ac
--- /dev/null
+++ b/storage/perfschema/table_replication_applier_status.cc
@@ -0,0 +1,222 @@
+/*
+ Copyright (c) 2013, 2018, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
+
+/**
+ @file storage/perfschema/table_replication_applier_status.cc
+ Table replication_applier_status (implementation).
+*/
+
+//#define HAVE_REPLICATION
+
+#include "my_global.h"
+
+#ifdef HAVE_REPLICATION
+#include "table_replication_applier_status.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "slave.h"
+//#include "rpl_info.h"
+#include "rpl_rli.h"
+#include "rpl_mi.h"
+#include "sql_parse.h"
+//#include "rpl_msr.h" /*Multi source replication */
+
+THR_LOCK table_replication_applier_status::m_table_lock;
+
+PFS_engine_table_share
+table_replication_applier_status::m_share=
+{
+ { C_STRING_WITH_LEN("replication_applier_status") },
+ &pfs_readonly_acl,
+ table_replication_applier_status::create,
+ NULL, /* write_row */
+ NULL, /* delete_all_rows */
+ table_replication_applier_status::get_row_count, /* records */
+ sizeof(pos_t), /* ref length */
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE replication_applier_status("
+ "CHANNEL_NAME CHAR(64) collate utf8_general_ci not null,"
+ "SERVICE_STATE ENUM('ON','OFF') not null,"
+ "REMAINING_DELAY INTEGER unsigned,"
+ "COUNT_TRANSACTIONS_RETRIES BIGINT unsigned not null)") },
+ false /* perpetual */
+};
+
+
+PFS_engine_table* table_replication_applier_status::create(void)
+{
+ return new table_replication_applier_status();
+}
+
+table_replication_applier_status::table_replication_applier_status()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(0), m_next_pos(0)
+{}
+
+table_replication_applier_status::~table_replication_applier_status()
+{}
+
+void table_replication_applier_status::reset_position(void)
+{
+ m_pos.m_index= 0;
+ m_next_pos.m_index= 0;
+}
+
+ha_rows table_replication_applier_status::get_row_count()
+{
+ return master_info_index->master_info_hash.records;
+}
+
+
+int table_replication_applier_status::rnd_next(void)
+{
+ Master_info *mi;
+ mysql_mutex_lock(&LOCK_active_mi);
+
+ for (m_pos.set_at(&m_next_pos);
+ m_pos.m_index < master_info_index->master_info_hash.records;
+ m_pos.next())
+ {
+ mi= (Master_info *)my_hash_element(&master_info_index->master_info_hash, m_pos.m_index);
+
+ if (mi && mi->host[0])
+ {
+ make_row(mi);
+ m_next_pos.set_after(&m_pos);
+ mysql_mutex_unlock(&LOCK_active_mi);
+ return 0;
+ }
+ }
+
+ mysql_mutex_unlock(&LOCK_active_mi);
+ return HA_ERR_END_OF_FILE;
+}
+
+
+int table_replication_applier_status::rnd_pos(const void *pos)
+{
+ Master_info *mi=NULL;
+ int res= HA_ERR_RECORD_DELETED;
+
+ set_position(pos);
+
+ mysql_mutex_lock(&LOCK_active_mi);
+
+ if ((mi= (Master_info *)my_hash_element(&master_info_index->master_info_hash, m_pos.m_index)))
+ {
+ make_row(mi);
+ res= 0;
+ }
+
+ mysql_mutex_unlock(&LOCK_active_mi);
+ return res;
+}
+
+void table_replication_applier_status::make_row(Master_info *mi)
+{
+ char *slave_sql_running_state= NULL;
+
+ m_row_exists= false;
+
+ DBUG_ASSERT(mi != NULL);
+
+ m_row.channel_name_length= static_cast<uint>(mi->connection_name.length);
+ memcpy(m_row.channel_name, mi->connection_name.str, m_row.channel_name_length);
+
+ //mysql_mutex_lock(&mi->rli->info_thd_lock);
+
+ slave_sql_running_state= const_cast<char *>
+ (mi->rli.sql_driver_thd ?
+ mi->rli.sql_driver_thd->get_proc_info() : "");
+ //mysql_mutex_unlock(&mi->rli->info_thd_lock);
+
+
+ mysql_mutex_lock(&mi->data_lock);
+ mysql_mutex_lock(&mi->rli.data_lock);
+
+ if (mi->rli.slave_running)
+ m_row.service_state= PS_RPL_YES;
+ else
+ m_row.service_state= PS_RPL_NO;
+
+ m_row.remaining_delay= 0;
+ if (slave_sql_running_state == stage_sql_thd_waiting_until_delay.m_name)
+ {
+ time_t t= my_time(0), sql_delay_end= 0; //mi->rli.>get_sql_delay_end();
+ m_row.remaining_delay= (uint)(t < sql_delay_end ?
+ sql_delay_end - t : 0);
+ m_row.remaining_delay_is_set= true;
+ }
+ else
+ m_row.remaining_delay_is_set= false;
+
+ m_row.count_transactions_retries= mi->rli.retried_trans;
+
+ mysql_mutex_unlock(&mi->rli.data_lock);
+ mysql_mutex_unlock(&mi->data_lock);
+
+ m_row_exists= true;
+}
+
+int table_replication_applier_status::read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /**channel_name*/
+ set_field_char_utf8(f, m_row.channel_name, m_row.channel_name_length);
+ break;
+ case 1: /* service_state */
+ set_field_enum(f, m_row.service_state);
+ break;
+ case 2: /* remaining_delay */
+ if (m_row.remaining_delay_is_set)
+ set_field_ulong(f, m_row.remaining_delay);
+ else
+ f->set_null();
+ break;
+ case 3: /* total number of times transactions were retried */
+ set_field_ulonglong(f, m_row.count_transactions_retries);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+ return 0;
+}
+#endif
diff --git a/storage/perfschema/table_replication_applier_status.h b/storage/perfschema/table_replication_applier_status.h
new file mode 100644
index 00000000..95845f38
--- /dev/null
+++ b/storage/perfschema/table_replication_applier_status.h
@@ -0,0 +1,118 @@
+/*
+ Copyright (c) 2013, 2018, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
+
+
+#ifndef TABLE_REPLICATION_APPLIER_STATUS_H
+#define TABLE_REPLICATION_APPLIER_STATUS_H
+
+/**
+ @file storage/perfschema/table_replication_applier_status.h
+ Table replication_applier_status (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "rpl_mi.h"
+#include "mysql_com.h"
+//#include "rpl_msr.h"
+//#include "rpl_info.h" /*CHANNEL_NAME_LENGTH*/
+#include "my_thread.h"
+
+class Master_info;
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+#ifndef ENUM_RPL_YES_NO
+#define ENUM_RPL_YES_NO
+/** enum values for Service_State field*/
+enum enum_rpl_yes_no {
+ PS_RPL_YES= 1,
+ PS_RPL_NO
+};
+#endif
+
+/** A row in the table. */
+struct st_row_applier_status {
+ char channel_name[CHANNEL_NAME_LENGTH];
+ uint channel_name_length;
+ enum_rpl_yes_no service_state;
+ uint remaining_delay;
+ bool remaining_delay_is_set;
+ ulong count_transactions_retries;
+};
+
+/** Table PERFORMANCE_SCHEMA.replication_applier_status */
+class table_replication_applier_status: public PFS_engine_table
+{
+ typedef PFS_simple_index pos_t;
+
+private:
+ void make_row(Master_info *mi);
+
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+ /** Fields definition. */
+ static TABLE_FIELD_DEF m_field_def;
+ /** Current row */
+ st_row_applier_status m_row;
+ /** True is the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ pos_t m_pos;
+ /** Next position. */
+ pos_t m_next_pos;
+
+protected:
+ /**
+ Read the current row values.
+ @param table Table handle
+ @param buf row buffer
+ @param fields Table fields
+ @param read_all true if all columns are read.
+ */
+
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_replication_applier_status();
+
+public:
+ ~table_replication_applier_status();
+
+ /** Table share. */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static ha_rows get_row_count();
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_replication_applier_status_by_coordinator.cc b/storage/perfschema/table_replication_applier_status_by_coordinator.cc
new file mode 100644
index 00000000..beb8620b
--- /dev/null
+++ b/storage/perfschema/table_replication_applier_status_by_coordinator.cc
@@ -0,0 +1,249 @@
+/*
+ Copyright (c) 2013, 2018, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
+
+/**
+ @file storage/perfschema/table_replication_applier_status_by_cordinator.cc
+ Table replication_applier_status_by_coordinator (implementation).
+*/
+
+//#define HAVE_REPLICATION
+
+#include "my_global.h"
+
+#ifdef HAVE_REPLICATION
+#include "table_replication_applier_status_by_coordinator.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "slave.h"
+//#include "rpl_info.h"
+#include "rpl_rli.h"
+#include "rpl_mi.h"
+#include "sql_parse.h"
+//#include "rpl_msr.h" /* Multisource replication */
+
+THR_LOCK table_replication_applier_status_by_coordinator::m_table_lock;
+
+PFS_engine_table_share
+table_replication_applier_status_by_coordinator::m_share=
+{
+ { C_STRING_WITH_LEN("replication_applier_status_by_coordinator") },
+ &pfs_readonly_acl,
+ table_replication_applier_status_by_coordinator::create,
+ NULL, /* write_row */
+ NULL, /* delete_all_rows */
+ table_replication_applier_status_by_coordinator::get_row_count,
+ sizeof(pos_t), /* ref length */
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE replication_applier_status_by_coordinator("
+ "CHANNEL_NAME CHAR(64) collate utf8_general_ci not null,"
+ "THREAD_ID BIGINT UNSIGNED,"
+ "SERVICE_STATE ENUM('ON','OFF') not null,"
+ "LAST_ERROR_NUMBER INTEGER not null,"
+ "LAST_ERROR_MESSAGE VARCHAR(1024) not null,"
+ "LAST_ERROR_TIMESTAMP TIMESTAMP(0) not null)") },
+ false /* perpetual */
+};
+
+PFS_engine_table* table_replication_applier_status_by_coordinator::create(void)
+{
+ return new table_replication_applier_status_by_coordinator();
+}
+
+table_replication_applier_status_by_coordinator
+ ::table_replication_applier_status_by_coordinator()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(0), m_next_pos(0)
+{}
+
+table_replication_applier_status_by_coordinator
+ ::~table_replication_applier_status_by_coordinator()
+{}
+
+void table_replication_applier_status_by_coordinator::reset_position(void)
+{
+ m_pos.m_index= 0;
+ m_next_pos.m_index= 0;
+}
+
+ha_rows table_replication_applier_status_by_coordinator::get_row_count()
+{
+ return master_info_index->master_info_hash.records;
+}
+
+
+int table_replication_applier_status_by_coordinator::rnd_next(void)
+{
+ Master_info *mi;
+
+ mysql_mutex_lock(&LOCK_active_mi);
+
+
+ for (m_pos.set_at(&m_next_pos);
+ m_pos.m_index < master_info_index->master_info_hash.records;
+ m_pos.next())
+ {
+ mi= (Master_info *)my_hash_element(&master_info_index->master_info_hash, m_pos.m_index);
+
+ /*
+ Construct and display SQL Thread's (Coordinator) information in
+ 'replication_applier_status_by_coordinator' table only in the case of
+ multi threaded slave mode. Code should do nothing in the case of single
+ threaded slave mode. In case of single threaded slave mode SQL Thread's
+ status will be reported as part of
+ 'replication_applier_status_by_worker' table.
+ */
+ if (mi && mi->host[0] && /*mi->rli.get_worker_count() > */ 0)
+ {
+ make_row(mi);
+ m_next_pos.set_after(&m_pos);
+ mysql_mutex_unlock(&LOCK_active_mi);
+ return 0;
+ }
+ }
+
+ mysql_mutex_unlock(&LOCK_active_mi);
+ return HA_ERR_END_OF_FILE;
+}
+
+int table_replication_applier_status_by_coordinator::rnd_pos(const void *pos)
+{
+ Master_info *mi=NULL;
+ int res= HA_ERR_RECORD_DELETED;
+
+ set_position(pos);
+
+ mysql_mutex_lock(&LOCK_active_mi);
+
+ if ((mi= (Master_info *)my_hash_element(&master_info_index->master_info_hash, m_pos.m_index)))
+ {
+ make_row(mi);
+ res= 0;
+ }
+
+ mysql_mutex_unlock(&LOCK_active_mi);
+ return res;
+}
+
+void table_replication_applier_status_by_coordinator::make_row(Master_info *mi)
+{
+ m_row_exists= false;
+
+ DBUG_ASSERT(mi != NULL);
+
+ mysql_mutex_lock(&mi->rli.data_lock);
+
+ m_row.channel_name_length= static_cast<uint>(mi->connection_name.length);
+ memcpy(m_row.channel_name, mi->connection_name.str, m_row.channel_name_length);
+
+ if (mi->rli.slave_running)
+ {
+ PSI_thread *psi= thd_get_psi(mi->rli.sql_driver_thd);
+ PFS_thread *pfs= reinterpret_cast<PFS_thread *> (psi);
+ if(pfs)
+ {
+ m_row.thread_id= pfs->m_thread_internal_id;
+ m_row.thread_id_is_null= false;
+ }
+ else
+ m_row.thread_id_is_null= true;
+ }
+ else
+ m_row.thread_id_is_null= true;
+
+ if (mi->rli.slave_running)
+ m_row.service_state= PS_RPL_YES;
+ else
+ m_row.service_state= PS_RPL_NO;
+
+ mysql_mutex_lock(&mi->rli.err_lock);
+
+ m_row.last_error_number= (long int) mi->rli.last_error().number;
+ m_row.last_error_message_length= 0;
+ m_row.last_error_timestamp= 0;
+
+ /** if error, set error message and timestamp */
+ if (m_row.last_error_number)
+ {
+ char *temp_store= (char*) mi->rli.last_error().message;
+ m_row.last_error_message_length= static_cast<uint>(strlen(temp_store));
+ memcpy(m_row.last_error_message, temp_store,
+ m_row.last_error_message_length);
+
+ /** time in millisecond since epoch */
+ m_row.last_error_timestamp= 0;//(ulonglong)mi->rli.last_error().skr*1000000;
+ }
+
+ mysql_mutex_unlock(&mi->rli.err_lock);
+ mysql_mutex_unlock(&mi->rli.data_lock);
+
+ m_row_exists= true;
+}
+
+int table_replication_applier_status_by_coordinator
+ ::read_row_values(TABLE *table, unsigned char *buf,
+ Field **fields, bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* channel_name */
+ set_field_char_utf8(f, m_row.channel_name, m_row.channel_name_length);
+ break;
+ case 1: /*thread_id*/
+ if (!m_row.thread_id_is_null)
+ set_field_ulonglong(f, m_row.thread_id);
+ else
+ f->set_null();
+ break;
+ case 2: /*service_state*/
+ set_field_enum(f, m_row.service_state);
+ break;
+ case 3: /*last_error_number*/
+ set_field_ulong(f, m_row.last_error_number);
+ break;
+ case 4: /*last_error_message*/
+ set_field_varchar_utf8(f, m_row.last_error_message,
+ m_row.last_error_message_length);
+ break;
+ case 5: /*last_error_timestamp*/
+ set_field_timestamp(f, m_row.last_error_timestamp);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+ return 0;
+}
+#endif
diff --git a/storage/perfschema/table_replication_applier_status_by_coordinator.h b/storage/perfschema/table_replication_applier_status_by_coordinator.h
new file mode 100644
index 00000000..8c1d4c4f
--- /dev/null
+++ b/storage/perfschema/table_replication_applier_status_by_coordinator.h
@@ -0,0 +1,124 @@
+/*
+ Copyright (c) 2013, 2018, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
+
+
+#ifndef TABLE_REPLICATION_APPLIER_STATUS_BY_COORDINATOR_H
+#define TABLE_REPLICATION_APPLIER_STATUS_BY_COORDINATOR_H
+
+/**
+ @file storage/perfschema/table_replication_applier_applier_by_coordinator.h
+ Table replication_applier_status_by_coordinator(declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "rpl_mi.h"
+#include "mysql_com.h"
+//#include "rpl_msr.h"
+//#include "rpl_info.h" /*CHANNEL_NAME_LENGTH*/
+#include "my_thread.h"
+
+class Master_info;
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+#ifndef ENUM_RPL_YES_NO
+#define ENUM_RPL_YES_NO
+/** enum values for Service_State of coordinator thread */
+enum enum_rpl_yes_no {
+ PS_RPL_YES= 1, /* Service_State= on */
+ PS_RPL_NO /* Service_State= off */
+};
+#endif
+
+/*
+ A row in coordinator's table. The fields with string values have an
+ additional length field denoted by <field_name>_length.
+*/
+struct st_row_coordinator {
+ char channel_name[CHANNEL_NAME_LENGTH];
+ uint channel_name_length;
+ ulonglong thread_id;
+ bool thread_id_is_null;
+ enum_rpl_yes_no service_state;
+ uint last_error_number;
+ char last_error_message[MAX_SLAVE_ERRMSG];
+ uint last_error_message_length;
+ ulonglong last_error_timestamp;
+};
+
+/** Table PERFORMANCE_SCHEMA.replication_applier_status_by_coordinator */
+class table_replication_applier_status_by_coordinator: public PFS_engine_table
+{
+ typedef PFS_simple_index pos_t;
+
+private:
+ void make_row(Master_info *mi);
+
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+ /** Fields definition. */
+ static TABLE_FIELD_DEF m_field_def;
+ /** Current row */
+ st_row_coordinator m_row;
+ /** True is the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ pos_t m_pos;
+ /** Next position. */
+ pos_t m_next_pos;
+
+protected:
+ /**
+ Read the current row values.
+ @param table Table handle
+ @param buf row buffer
+ @param fields Table fields
+ @param read_all true if all columns are read.
+ */
+
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_replication_applier_status_by_coordinator();
+
+public:
+ ~table_replication_applier_status_by_coordinator();
+
+ /** Table share. */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static ha_rows get_row_count();
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_replication_applier_status_by_worker.cc b/storage/perfschema/table_replication_applier_status_by_worker.cc
new file mode 100644
index 00000000..4c7ca612
--- /dev/null
+++ b/storage/perfschema/table_replication_applier_status_by_worker.cc
@@ -0,0 +1,412 @@
+/*
+ Copyright (c) 2013, 2018, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
+
+/**
+ @file storage/perfschema/table_replication_applier_status_by_worker.cc
+ Table replication_applier_status_by_worker (implementation).
+*/
+
+//#define HAVE_REPLICATION
+
+#include "my_global.h"
+#include "table_replication_applier_status_by_worker.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "slave.h"
+//#include "rpl_info.h"
+#include "rpl_rli.h"
+#include "rpl_mi.h"
+#include "sql_parse.h"
+//#include "rpl_rli_pdb.h"
+//#include "rpl_msr.h" /*Multi source replication */
+
+THR_LOCK table_replication_applier_status_by_worker::m_table_lock;
+
+PFS_engine_table_share
+table_replication_applier_status_by_worker::m_share=
+{
+ { C_STRING_WITH_LEN("replication_applier_status_by_worker") },
+ &pfs_readonly_acl,
+ table_replication_applier_status_by_worker::create,
+ NULL, /* write_row */
+ NULL, /* delete_all_rows */
+ table_replication_applier_status_by_worker::get_row_count, /*records*/
+ sizeof(pos_t), /* ref length */
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE replication_applier_status_by_worker("
+ "CHANNEL_NAME CHAR(64) collate utf8_general_ci not null,"
+ "WORKER_ID BIGINT UNSIGNED not null,"
+ "THREAD_ID BIGINT UNSIGNED,"
+ "SERVICE_STATE ENUM('ON','OFF') not null,"
+ "LAST_SEEN_TRANSACTION CHAR(57) not null,"
+ "LAST_ERROR_NUMBER INTEGER not null,"
+ "LAST_ERROR_MESSAGE VARCHAR(1024) not null,"
+ "LAST_ERROR_TIMESTAMP TIMESTAMP(0) not null)") },
+ false /* perpetual */
+};
+
+PFS_engine_table* table_replication_applier_status_by_worker::create(void)
+{
+ return new table_replication_applier_status_by_worker();
+}
+
+table_replication_applier_status_by_worker
+ ::table_replication_applier_status_by_worker()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(), m_next_pos()
+{}
+
+table_replication_applier_status_by_worker
+ ::~table_replication_applier_status_by_worker()
+{}
+
+void table_replication_applier_status_by_worker::reset_position(void)
+{
+ m_pos.reset();
+ m_next_pos.reset();
+}
+
+ha_rows table_replication_applier_status_by_worker::get_row_count()
+{
+ /*
+ Return an estimate, number of master info's multipled by worker threads
+ */
+ return master_info_index->master_info_hash.records*32;
+}
+
+
+int table_replication_applier_status_by_worker::rnd_next(void)
+{
+ Slave_worker *worker;
+ Master_info *mi;
+ size_t wc;
+
+ mysql_mutex_lock(&LOCK_active_mi);
+
+ for (m_pos.set_at(&m_next_pos);
+ m_pos.has_more_channels(master_info_index->master_info_hash.records);
+ m_pos.next_channel())
+ {
+ mi= (Master_info *)my_hash_element(&master_info_index->master_info_hash, m_pos.m_index_1);
+
+ if (mi && mi->host[0])
+ {
+ wc= mi->rli->get_worker_count();
+
+ if (wc == 0)
+ {
+ /* Single Thread Slave */
+ make_row(mi);
+ m_next_pos.set_channel_after(&m_pos);
+ channel_map.unlock();
+ return 0;
+ }
+
+ for (; m_pos.m_index_2 < wc; m_pos.next_worker())
+ {
+ /* Multi Thread Slave */
+
+ worker = mi->rli->get_worker(m_pos.m_index_2);
+ if (worker)
+ {
+ make_row(worker);
+ m_next_pos.set_after(&m_pos);
+ channel_map.unlock();
+ return 0;
+ }
+ }
+ }
+ }
+
+ mysql_mutex_unlock(&LOCK_active_mi);
+ return HA_ERR_END_OF_FILE;
+}
+
+int table_replication_applier_status_by_worker::rnd_pos(const void *pos)
+{
+ Slave_worker *worker;
+ Master_info *mi;
+ int res= HA_ERR_RECORD_DELETED;
+ size_t wc;
+
+ set_position(pos);
+
+ mysql_mutex_lock(&LOCK_active_mi);
+
+ mi= (Master_info *)my_hash_element(&master_info_index->master_info_hash, m_pos.m_index_1);
+
+ if (!mi || !mi->host[0])
+ goto end;
+
+ wc = mi->rli->get_worker_count();
+
+ if (wc == 0)
+ {
+ /* Single Thread Slave */
+ make_row(mi);
+ res=0;
+ }
+ else
+ {
+ /* Multi Thread Slave */
+ if (m_pos.m_index_2 < wc)
+ {
+ worker = mi->rli->get_worker(m_pos.m_index_2);
+ if (worker != NULL)
+ {
+ make_row(worker);
+ res=0;
+ }
+ }
+ }
+
+end:
+ mysql_mutex_unlock(&LOCK_active_mi);
+ return res;
+}
+
+/**
+ Function to display SQL Thread's status as part of
+ 'replication_applier_status_by_worker' in single threaded slave mode.
+
+ @param[in] Master_info
+
+ @retval void
+*/
+void table_replication_applier_status_by_worker::make_row(Master_info *mi)
+{
+ m_row_exists= false;
+
+ m_row.worker_id= 0;
+
+ m_row.thread_id= 0;
+
+ DBUG_ASSERT(mi != NULL);
+ DBUG_ASSERT(mi->rli != NULL);
+
+ mysql_mutex_lock(&mi->rli->data_lock);
+
+ m_row.channel_name_length= strlen(mi->get_channel());
+ memcpy(m_row.channel_name, (char*)mi->get_channel(), m_row.channel_name_length);
+
+ if (mi->rli->slave_running)
+ {
+ PSI_thread *psi= thd_get_psi(mi->rli->info_thd);
+ PFS_thread *pfs= reinterpret_cast<PFS_thread *> (psi);
+ if(pfs)
+ {
+ m_row.thread_id= pfs->m_thread_internal_id;
+ m_row.thread_id_is_null= false;
+ }
+ else
+ m_row.thread_id_is_null= true;
+ }
+ else
+ m_row.thread_id_is_null= true;
+
+ if (mi->rli->slave_running)
+ m_row.service_state= PS_RPL_YES;
+ else
+ m_row.service_state= PS_RPL_NO;
+
+ if (mi->rli->currently_executing_gtid.type == GTID_GROUP)
+ {
+ global_sid_lock->rdlock();
+ m_row.last_seen_transaction_length=
+ mi->rli->currently_executing_gtid.to_string(global_sid_map,
+ m_row.last_seen_transaction);
+ global_sid_lock->unlock();
+ }
+ else if (mi->rli->currently_executing_gtid.type == ANONYMOUS_GROUP)
+ {
+ m_row.last_seen_transaction_length=
+ mi->rli->currently_executing_gtid.to_string((rpl_sid *)NULL,
+ m_row.last_seen_transaction);
+ }
+ else
+ {
+ /*
+ For SQL thread currently_executing_gtid, type is set to
+ AUTOMATIC_GROUP when the SQL thread is not executing any
+ transaction. For this case, the field should be empty.
+ */
+ DBUG_ASSERT(mi->rli->currently_executing_gtid.type == AUTOMATIC_GROUP);
+ m_row.last_seen_transaction_length= 0;
+ memcpy(m_row.last_seen_transaction, "", 1);
+ }
+
+ mysql_mutex_lock(&mi->rli->err_lock);
+
+ m_row.last_error_number= (long int) mi->rli->last_error().number;
+ m_row.last_error_message_length= 0;
+ m_row.last_error_timestamp= 0;
+
+ /** if error, set error message and timestamp */
+ if (m_row.last_error_number)
+ {
+ char *temp_store= (char*) mi->rli->last_error().message;
+ m_row.last_error_message_length= strlen(temp_store);
+ memcpy(m_row.last_error_message, temp_store,
+ m_row.last_error_message_length);
+
+ /** time in millisecond since epoch */
+ m_row.last_error_timestamp= (ulonglong)mi->rli->last_error().skr*1000000;
+ }
+
+ mysql_mutex_unlock(&mi->rli->err_lock);
+ mysql_mutex_unlock(&mi->rli->data_lock);
+ m_row_exists= true;
+}
+
+void table_replication_applier_status_by_worker::make_row(Slave_worker *w)
+{
+ m_row_exists= false;
+
+ m_row.worker_id= w->get_internal_id();
+
+ m_row.thread_id= 0;
+
+ m_row.channel_name_length= strlen(w->get_channel());
+ memcpy(m_row.channel_name, (char*)w->get_channel(), m_row.channel_name_length);
+
+ mysql_mutex_lock(&w->jobs_lock);
+ if (w->running_status == Slave_worker::RUNNING)
+ {
+ PSI_thread *psi= thd_get_psi(w->info_thd);
+ PFS_thread *pfs= reinterpret_cast<PFS_thread *> (psi);
+ if(pfs)
+ {
+ m_row.thread_id= pfs->m_thread_internal_id;
+ m_row.thread_id_is_null= false;
+ }
+ else /* no instrumentation found */
+ m_row.thread_id_is_null= true;
+ }
+ else
+ m_row.thread_id_is_null= true;
+
+ if (w->running_status == Slave_worker::RUNNING)
+ m_row.service_state= PS_RPL_YES;
+ else
+ m_row.service_state= PS_RPL_NO;
+
+ m_row.last_error_number= (unsigned int) w->last_error().number;
+
+ if (w->currently_executing_gtid.type == GTID_GROUP)
+ {
+ global_sid_lock->rdlock();
+ m_row.last_seen_transaction_length=
+ w->currently_executing_gtid.to_string(global_sid_map,
+ m_row.last_seen_transaction);
+ global_sid_lock->unlock();
+ }
+ else if (w->currently_executing_gtid.type == ANONYMOUS_GROUP)
+ {
+ m_row.last_seen_transaction_length=
+ w->currently_executing_gtid.to_string((rpl_sid *)NULL,
+ m_row.last_seen_transaction);
+ }
+ else
+ {
+ /*
+ For worker->currently_executing_gtid, type is set to
+ AUTOMATIC_GROUP when the worker is not executing any
+ transaction. For this case, the field should be empty.
+ */
+ DBUG_ASSERT(w->currently_executing_gtid.type == AUTOMATIC_GROUP);
+ m_row.last_seen_transaction_length= 0;
+ memcpy(m_row.last_seen_transaction, "", 1);
+ }
+
+ m_row.last_error_number= (unsigned int) w->last_error().number;
+ m_row.last_error_message_length= 0;
+ m_row.last_error_timestamp= 0;
+
+ /** if error, set error message and timestamp */
+ if (m_row.last_error_number)
+ {
+ char * temp_store= (char*)w->last_error().message;
+ m_row.last_error_message_length= strlen(temp_store);
+ memcpy(m_row.last_error_message, w->last_error().message,
+ m_row.last_error_message_length);
+
+ /** time in millisecond since epoch */
+ m_row.last_error_timestamp= (ulonglong)w->last_error().skr*1000000;
+ }
+ mysql_mutex_unlock(&w->jobs_lock);
+
+ m_row_exists= true;
+}
+
+int table_replication_applier_status_by_worker
+ ::read_row_values(TABLE *table, unsigned char *buf, Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /** channel_name */
+ set_field_char_utf8(f, m_row.channel_name, m_row.channel_name_length);
+ break;
+ case 1: /*worker_id*/
+ set_field_ulonglong(f, m_row.worker_id);
+ break;
+ case 2: /*thread_id*/
+ if(m_row.thread_id_is_null)
+ f->set_null();
+ else
+ set_field_ulonglong(f, m_row.thread_id);
+ break;
+ case 3: /*service_state*/
+ set_field_enum(f, m_row.service_state);
+ break;
+ case 4: /*last_seen_transaction*/
+ set_field_char_utf8(f, m_row.last_seen_transaction, m_row.last_seen_transaction_length);
+ break;
+ case 5: /*last_error_number*/
+ set_field_ulong(f, m_row.last_error_number);
+ break;
+ case 6: /*last_error_message*/
+ set_field_varchar_utf8(f, m_row.last_error_message, m_row.last_error_message_length);
+ break;
+ case 7: /*last_error_timestamp*/
+ set_field_timestamp(f, m_row.last_error_timestamp);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+ return 0;
+}
diff --git a/storage/perfschema/table_replication_applier_status_by_worker.h b/storage/perfschema/table_replication_applier_status_by_worker.h
new file mode 100644
index 00000000..0a881dae
--- /dev/null
+++ b/storage/perfschema/table_replication_applier_status_by_worker.h
@@ -0,0 +1,182 @@
+/*
+ Copyright (c) 2013, 2018, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
+
+
+#ifndef TABLE_REPLICATION_APPLIER_STATUS_BY_WORKER_H
+#define TABLE_REPLICATION_APPLIER_STATUS_BY_WORKER_H
+
+/**
+ @file storage/perfschema/table_replication_applier_status_by_worker.h
+ Table replication_applier_status_by_worker (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "rpl_mi.h"
+#include "mysql_com.h"
+//#include "rpl_rli_pdb.h"
+//#include "rpl_msr.h"
+//#include "rpl_info.h" /*CHANNEL_NAME_LENGTH*/
+#include "my_thread.h"
+
+class Slave_worker;
+class Master_info;
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+#ifndef ENUM_RPL_YES_NO
+#define ENUM_RPL_YES_NO
+/** enumerated values for service_state of worker thread*/
+enum enum_rpl_yes_no {
+ PS_RPL_YES= 1, /* service_state= on */
+ PS_RPL_NO /* service_state= off */
+};
+#endif
+
+/*
+ A row in worker's table. The fields with string values have an additional
+ length field denoted by <field_name>_length.
+*/
+struct st_row_worker {
+
+ char channel_name[CHANNEL_NAME_LENGTH];
+ uint channel_name_length;
+ /*
+ worker_id is added to the table because thread is killed at STOP SLAVE
+ but the status needs to show up, so worker_id is used as a permanent
+ identifier.
+ */
+ ulonglong worker_id;
+ ulonglong thread_id;
+ uint thread_id_is_null;
+ enum_rpl_yes_no service_state;
+ char last_seen_transaction[GTID_MAX_STR_LENGTH + 1];
+ uint last_seen_transaction_length;
+ uint last_error_number;
+ char last_error_message[MAX_SLAVE_ERRMSG];
+ uint last_error_message_length;
+ ulonglong last_error_timestamp;
+};
+
+/**
+ Position in table replication_applier_status_by_worker.
+ Index 1 for replication channel.
+ Index 2 for worker:
+ - position [0] is for Single Thread Slave (Master_info)
+ - position [1] .. [N] is for Multi Thread Slave (Slave_worker)
+*/
+struct pos_replication_applier_status_by_worker : public PFS_double_index
+{
+
+ pos_replication_applier_status_by_worker() : PFS_double_index(0, 0)
+ {}
+
+ inline void reset(void)
+ {
+ m_index_1= 0;
+ m_index_2= 0;
+ }
+
+ inline bool has_more_channels(uint num)
+ { return (m_index_1 < num); }
+
+ inline void next_channel(void)
+ {
+ m_index_1++;
+ m_index_2= 0;
+ }
+
+ inline void next_worker()
+ {
+ m_index_2++;
+ }
+
+ inline void
+ set_channel_after(const pos_replication_applier_status_by_worker *other)
+ {
+ m_index_1 = other->m_index_1 + 1;
+ m_index_2 = 0;
+ }
+};
+
+
+/** Table PERFORMANCE_SCHEMA.replication_applier_status_by_worker */
+class table_replication_applier_status_by_worker: public PFS_engine_table
+{
+ typedef pos_replication_applier_status_by_worker pos_t;
+
+private:
+ void make_row(Slave_worker *);
+ /*
+ Master_info to construct a row to display SQL Thread's status
+ information in STS mode
+ */
+ void make_row(Master_info *);
+
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+ /** Fields definition. */
+ static TABLE_FIELD_DEF m_field_def;
+ /** current row*/
+ st_row_worker m_row;
+ /** True is the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ pos_t m_pos;
+ /** Next position. */
+ pos_t m_next_pos;
+
+protected:
+ /**
+ Read the current row values.
+ @param table Table handle
+ @param buf row buffer
+ @param fields Table fields
+ @param read_all true if all columns are read.
+ */
+
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_replication_applier_status_by_worker();
+
+public:
+ ~table_replication_applier_status_by_worker();
+
+ /** Table share. */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static ha_rows get_row_count();
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_replication_connection_configuration.cc b/storage/perfschema/table_replication_connection_configuration.cc
new file mode 100644
index 00000000..6d358240
--- /dev/null
+++ b/storage/perfschema/table_replication_connection_configuration.cc
@@ -0,0 +1,333 @@
+/*
+ Copyright (c) 2013, 2018, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
+
+/**
+ @file storage/perfschema/table_replication_connection_configuration.cc
+ Table replication_connection_configuration (implementation).
+*/
+
+//#define HAVE_REPLICATION
+
+#include "my_global.h"
+#include "table_replication_connection_configuration.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "slave.h"
+//#include "rpl_info.h"
+#include "rpl_rli.h"
+#include "rpl_mi.h"
+#include "sql_parse.h"
+//#include "rpl_msr.h" /* Multisource replciation */
+
+#ifdef HAVE_REPLICATION
+THR_LOCK table_replication_connection_configuration::m_table_lock;
+
+PFS_engine_table_share
+table_replication_connection_configuration::m_share=
+{
+ { C_STRING_WITH_LEN("replication_connection_configuration") },
+ &pfs_readonly_acl,
+ table_replication_connection_configuration::create,
+ NULL, /* write_row */
+ NULL, /* delete_all_rows */
+ table_replication_connection_configuration::get_row_count, /* records */
+ sizeof(pos_t), /* ref length */
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE replication_connection_configuration("
+ "CHANNEL_NAME CHAR(64) collate utf8_general_ci not null,"
+ "HOST CHAR(60) collate utf8_bin not null,"
+ "PORT INTEGER not null,"
+ "USER CHAR(32) collate utf8_bin not null,"
+ "NETWORK_INTERFACE CHAR(60) collate utf8_bin not null,"
+ "AUTO_POSITION ENUM('1','0') not null,"
+ "SSL_ALLOWED ENUM('YES','NO','IGNORED') not null,"
+ "SSL_CA_FILE VARCHAR(512) not null,"
+ "SSL_CA_PATH VARCHAR(512) not null,"
+ "SSL_CERTIFICATE VARCHAR(512) not null,"
+ "SSL_CIPHER VARCHAR(512) not null,"
+ "SSL_KEY VARCHAR(512) not null,"
+ "SSL_VERIFY_SERVER_CERTIFICATE ENUM('YES','NO') not null,"
+ "SSL_CRL_FILE VARCHAR(255) not null,"
+ "SSL_CRL_PATH VARCHAR(255) not null,"
+ "CONNECTION_RETRY_INTERVAL INTEGER not null,"
+ "CONNECTION_RETRY_COUNT BIGINT unsigned not null,"
+ "HEARTBEAT_INTERVAL DOUBLE(10,3) unsigned not null COMMENT 'Number of seconds after which a heartbeat will be sent .',"
+ "TLS_VERSION VARCHAR(255) not null)") },
+ false /* perpetual */
+};
+
+
+PFS_engine_table* table_replication_connection_configuration::create(void)
+{
+ return new table_replication_connection_configuration();
+}
+
+table_replication_connection_configuration
+ ::table_replication_connection_configuration()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(0), m_next_pos(0)
+{}
+
+table_replication_connection_configuration
+ ::~table_replication_connection_configuration()
+{}
+
+void table_replication_connection_configuration::reset_position(void)
+{
+ m_pos.m_index= 0;
+ m_next_pos.m_index= 0;
+}
+
+ha_rows table_replication_connection_configuration::get_row_count()
+{
+ /*
+ We actually give the MAX_CHANNELS rather than the current
+ number of channels
+ */
+
+ return master_info_index->master_info_hash.records;
+}
+
+int table_replication_connection_configuration::rnd_next(void)
+{
+ Master_info *mi;
+
+ mysql_mutex_lock(&LOCK_active_mi);
+
+ for (m_pos.set_at(&m_next_pos);
+ m_pos.m_index < master_info_index->master_info_hash.records;
+ m_pos.next())
+ {
+ mi= (Master_info *)my_hash_element(&master_info_index->master_info_hash, m_pos.m_index);
+
+ if (mi && mi->host[0])
+ {
+ make_row(mi);
+ m_next_pos.set_after(&m_pos);
+ mysql_mutex_unlock(&LOCK_active_mi);
+ return 0;
+ }
+ }
+
+ mysql_mutex_unlock(&LOCK_active_mi);
+ return HA_ERR_END_OF_FILE;
+}
+
+int table_replication_connection_configuration::rnd_pos(const void *pos)
+{
+ Master_info *mi;
+ int res= HA_ERR_RECORD_DELETED;
+
+ mysql_mutex_lock(&LOCK_active_mi);
+
+ set_position(pos);
+
+ if ((mi= (Master_info *)my_hash_element(&master_info_index->master_info_hash, m_pos.m_index)))
+ {
+ make_row(mi);
+ res= 0;
+ }
+
+ mysql_mutex_unlock(&LOCK_active_mi);
+ return res;
+}
+
+void table_replication_connection_configuration::make_row(Master_info *mi)
+{
+ char * temp_store;
+
+ m_row_exists= false;
+
+
+ DBUG_ASSERT(mi != NULL);
+
+ mysql_mutex_lock(&mi->data_lock);
+ mysql_mutex_lock(&mi->rli.data_lock);
+
+ m_row.channel_name_length= static_cast<uint>(mi->connection_name.length);
+ memcpy(m_row.channel_name, mi->connection_name.str, m_row.channel_name_length);
+
+ m_row.host_length= static_cast<uint>(strlen(mi->host));
+ memcpy(m_row.host, mi->host, m_row.host_length);
+
+ m_row.port= (unsigned int) mi->port;
+
+ /* can't the user be NULL? */
+ temp_store= (char*)mi->user;
+ m_row.user_length= static_cast<uint>(strlen(temp_store));
+ memcpy(m_row.user, temp_store, m_row.user_length);
+
+ temp_store= const_cast<char*>(""); //(char*)mi->bind_addr;
+ m_row.network_interface_length= static_cast<uint>(strlen(temp_store));
+ memcpy(m_row.network_interface, temp_store, m_row.network_interface_length);
+
+ if (mi->using_gtid)
+ m_row.auto_position= PS_RPL_YES;
+ else
+ m_row.auto_position= PS_RPL_NO;
+
+#ifdef HAVE_OPENSSL
+ m_row.ssl_allowed= mi->ssl? PS_SSL_ALLOWED_YES:PS_SSL_ALLOWED_NO;
+#else
+ m_row.ssl_allowed= mi->ssl? PS_SSL_ALLOWED_IGNORED:PS_SSL_ALLOWED_NO;
+#endif
+
+ temp_store= (char*)mi->ssl_ca;
+ m_row.ssl_ca_file_length= static_cast<uint>(strlen(temp_store));
+ memcpy(m_row.ssl_ca_file, temp_store, m_row.ssl_ca_file_length);
+
+ temp_store= (char*)mi->ssl_capath;
+ m_row.ssl_ca_path_length= static_cast<uint>(strlen(temp_store));
+ memcpy(m_row.ssl_ca_path, temp_store, m_row.ssl_ca_path_length);
+
+ temp_store= (char*)mi->ssl_cert;
+ m_row.ssl_certificate_length= static_cast<uint>(strlen(temp_store));
+ memcpy(m_row.ssl_certificate, temp_store, m_row.ssl_certificate_length);
+
+ temp_store= (char*)mi->ssl_cipher;
+ m_row.ssl_cipher_length= static_cast<uint>(strlen(temp_store));
+ memcpy(m_row.ssl_cipher, temp_store, m_row.ssl_cipher_length);
+
+ temp_store= (char*)mi->ssl_key;
+ m_row.ssl_key_length= static_cast<uint>(strlen(temp_store));
+ memcpy(m_row.ssl_key, temp_store, m_row.ssl_key_length);
+
+ if (mi->ssl_verify_server_cert)
+ m_row.ssl_verify_server_certificate= PS_RPL_YES;
+ else
+ m_row.ssl_verify_server_certificate= PS_RPL_NO;
+
+ temp_store= (char*)mi->ssl_crl;
+ m_row.ssl_crl_file_length= static_cast<uint>(strlen(temp_store));
+ memcpy(m_row.ssl_crl_file, temp_store, m_row.ssl_crl_file_length);
+
+ temp_store= (char*)mi->ssl_crlpath;
+ m_row.ssl_crl_path_length= static_cast<uint>(strlen(temp_store));
+ memcpy(m_row.ssl_crl_path, temp_store, m_row.ssl_crl_path_length);
+
+ m_row.connection_retry_interval= (unsigned int) mi->connect_retry;
+
+ m_row.connection_retry_count= 0; //(ulong) mi->retry_count;
+
+ m_row.heartbeat_interval= (double)mi->heartbeat_period;
+
+ temp_store= (char*)""; //mi->tls_version;
+ m_row.tls_version_length= static_cast<uint>(strlen(temp_store));
+ memcpy(m_row.tls_version, temp_store, m_row.tls_version_length);
+
+ mysql_mutex_unlock(&mi->rli.data_lock);
+ mysql_mutex_unlock(&mi->data_lock);
+
+ m_row_exists= true;
+}
+
+int table_replication_connection_configuration::read_row_values(TABLE *table,
+ unsigned char *,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ DBUG_ASSERT(table->s->null_bytes == 0);
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /** channel_name */
+ set_field_char_utf8(f, m_row.channel_name, m_row.channel_name_length);
+ break;
+ case 1: /** host */
+ set_field_char_utf8(f, m_row.host, m_row.host_length);
+ break;
+ case 2: /** port */
+ set_field_ulong(f, m_row.port);
+ break;
+ case 3: /** user */
+ set_field_char_utf8(f, m_row.user, m_row.user_length);
+ break;
+ case 4: /** network_interface */
+ set_field_char_utf8(f, m_row.network_interface,
+ m_row.network_interface_length);
+ break;
+ case 5: /** auto_position */
+ set_field_enum(f, m_row.auto_position);
+ break;
+ case 6: /** ssl_allowed */
+ set_field_enum(f, m_row. ssl_allowed);
+ break;
+ case 7: /**ssl_ca_file */
+ set_field_varchar_utf8(f, m_row.ssl_ca_file,
+ m_row.ssl_ca_file_length);
+ break;
+ case 8: /** ssl_ca_path */
+ set_field_varchar_utf8(f, m_row.ssl_ca_path,
+ m_row.ssl_ca_path_length);
+ break;
+ case 9: /** ssl_certificate */
+ set_field_varchar_utf8(f, m_row.ssl_certificate,
+ m_row.ssl_certificate_length);
+ break;
+ case 10: /** ssl_cipher */
+ set_field_varchar_utf8(f, m_row.ssl_cipher, m_row.ssl_cipher_length);
+ break;
+ case 11: /** ssl_key */
+ set_field_varchar_utf8(f, m_row.ssl_key, m_row.ssl_key_length);
+ break;
+ case 12: /** ssl_verify_server_certificate */
+ set_field_enum(f, m_row.ssl_verify_server_certificate);
+ break;
+ case 13: /** ssl_crl_file */
+ set_field_varchar_utf8(f, m_row.ssl_crl_file,
+ m_row.ssl_crl_file_length);
+ break;
+ case 14: /** ssl_crl_path */
+ set_field_varchar_utf8(f, m_row.ssl_crl_path,
+ m_row.ssl_crl_path_length);
+ break;
+ case 15: /** connection_retry_interval */
+ set_field_ulong(f, m_row.connection_retry_interval);
+ break;
+ case 16: /** connect_retry_count */
+ set_field_ulonglong(f, m_row.connection_retry_count);
+ break;
+ case 17:/** number of seconds after which heartbeat will be sent */
+ set_field_double(f, m_row.heartbeat_interval);
+ break;
+ case 18: /** tls_version */
+ set_field_varchar_utf8(f, m_row.tls_version,
+ m_row.tls_version_length);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+ return 0;
+}
+#endif
diff --git a/storage/perfschema/table_replication_connection_configuration.h b/storage/perfschema/table_replication_connection_configuration.h
new file mode 100644
index 00000000..d1c8861c
--- /dev/null
+++ b/storage/perfschema/table_replication_connection_configuration.h
@@ -0,0 +1,152 @@
+/*
+ Copyright (c) 2013, 2018, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
+
+
+#ifndef TABLE_REPLICATION_CONFIGURATION_H
+#define TABLE_REPLICATION_CONFIGURATION_H
+
+/**
+ @file storage/perfschema/table_replication_connection_configuration.h
+ Table replication_connection_configuration (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "rpl_mi.h"
+#include "mysql_com.h"
+#include "my_thread.h"
+//#include "rpl_msr.h"
+//#include "rpl_info.h" /* CHANNEL_NAME_LENGTH*/
+
+class Master_info;
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+#ifndef ENUM_RPL_YES_NO
+#define ENUM_RPL_YES_NO
+enum enum_rpl_yes_no {
+ PS_RPL_YES= 1,
+ PS_RPL_NO
+};
+#endif
+
+/** enum values for SSL_Allowed*/
+enum enum_ssl_allowed {
+ PS_SSL_ALLOWED_YES= 1,
+ PS_SSL_ALLOWED_NO,
+ PS_SSL_ALLOWED_IGNORED
+};
+
+/**
+ A row in the table. The fields with string values have an additional
+ length field denoted by <field_name>_length.
+*/
+struct st_row_connect_config {
+ char channel_name[CHANNEL_NAME_LENGTH];
+ uint channel_name_length;
+ char host[HOSTNAME_LENGTH];
+ uint host_length;
+ uint port;
+ char user[USERNAME_LENGTH];
+ uint user_length;
+ char network_interface[HOSTNAME_LENGTH];
+ uint network_interface_length;
+ enum_rpl_yes_no auto_position;
+ enum_ssl_allowed ssl_allowed;
+ char ssl_ca_file[FN_REFLEN];
+ uint ssl_ca_file_length;
+ char ssl_ca_path[FN_REFLEN];
+ uint ssl_ca_path_length;
+ char ssl_certificate[FN_REFLEN];
+ uint ssl_certificate_length;
+ char ssl_cipher[FN_REFLEN];
+ uint ssl_cipher_length;
+ char ssl_key[FN_REFLEN];
+ uint ssl_key_length;
+ enum_rpl_yes_no ssl_verify_server_certificate;
+ char ssl_crl_file[FN_REFLEN];
+ uint ssl_crl_file_length;
+ char ssl_crl_path[FN_REFLEN];
+ uint ssl_crl_path_length;
+ uint connection_retry_interval;
+ ulong connection_retry_count;
+ double heartbeat_interval;
+ char tls_version[FN_REFLEN];
+ uint tls_version_length;
+};
+
+/** Table PERFORMANCE_SCHEMA.TABLE_REPLICATION_CONNECTION_CONFIGURATION. */
+class table_replication_connection_configuration: public PFS_engine_table
+{
+ typedef PFS_simple_index pos_t;
+
+private:
+ void make_row(Master_info *);
+
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+ /** Fields definition. */
+ static TABLE_FIELD_DEF m_field_def;
+ /** True if the current row exists. */
+ bool m_row_exists;
+ /** Current row */
+ st_row_connect_config m_row;
+ /** Current position. */
+ pos_t m_pos;
+ /** Next position. */
+ pos_t m_next_pos;
+
+protected:
+ /**
+ Read the current row values.
+ @param table Table handle
+ @param buf row buffer
+ @param fields Table fields
+ @param read_all true if all columns are read.
+ */
+
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_replication_connection_configuration();
+
+public:
+ ~table_replication_connection_configuration();
+
+ /** Table share. */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static ha_rows get_row_count();
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_replication_connection_status.cc b/storage/perfschema/table_replication_connection_status.cc
new file mode 100644
index 00000000..a4230913
--- /dev/null
+++ b/storage/perfschema/table_replication_connection_status.cc
@@ -0,0 +1,440 @@
+/*
+ Copyright (c) 2013, 2018, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
+
+/**
+ @file storage/perfschema/table_replication_connection_status.cc
+ Table replication_connection_status (implementation).
+*/
+
+//#define HAVE_REPLICATION
+
+#include "my_global.h"
+#include "table_replication_connection_status.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "slave.h"
+//#include "rpl_info.h"
+#include "rpl_rli.h"
+#include "rpl_mi.h"
+#include "sql_parse.h"
+//#include "rpl_msr.h" /* Multi source replication */
+#include "log.h"
+//#include "rpl_group_replication.h"
+
+/*
+ Callbacks implementation for GROUP_REPLICATION_CONNECTION_STATUS_CALLBACKS.
+*/
+static void set_channel_name(void* const context, const char& value,
+ size_t length)
+{
+}
+
+static void set_group_name(void* const context, const char& value,
+ size_t length)
+{
+ struct st_row_connect_status* row=
+ static_cast<struct st_row_connect_status*>(context);
+ const size_t max= UUID_LENGTH;
+ length= std::min(length, max);
+
+ row->group_name_is_null= false;
+ memcpy(row->group_name, &value, length);
+}
+
+static void set_source_uuid(void* const context, const char& value,
+ size_t length)
+{
+ struct st_row_connect_status* row=
+ static_cast<struct st_row_connect_status*>(context);
+ const size_t max= UUID_LENGTH;
+ length= std::min(length, max);
+
+ row->source_uuid_is_null= false;
+ memcpy(row->source_uuid, &value, length);
+}
+
+static void set_service_state(void* const context, bool value)
+{
+ struct st_row_connect_status* row=
+ static_cast<struct st_row_connect_status*>(context);
+
+ row->service_state= value ? PS_RPL_CONNECT_SERVICE_STATE_YES
+ : PS_RPL_CONNECT_SERVICE_STATE_NO;
+}
+
+
+THR_LOCK table_replication_connection_status::m_table_lock;
+
+
+/* Numbers in varchar count utf8 characters. */
+static const TABLE_FIELD_TYPE field_types[]=
+{
+ {
+ {C_STRING_WITH_LEN("CHANNEL_NAME")},
+ {C_STRING_WITH_LEN("char(64)")},
+ {NULL, 0}
+ },
+ {
+ {C_STRING_WITH_LEN("GROUP_NAME")},
+ {C_STRING_WITH_LEN("char(36)")},
+ {NULL, 0}
+ },
+ {
+ {C_STRING_WITH_LEN("SOURCE_UUID")},
+ {C_STRING_WITH_LEN("char(36)")},
+ {NULL, 0}
+ },
+ {
+ {C_STRING_WITH_LEN("THREAD_ID")},
+ {C_STRING_WITH_LEN("bigint(20)")},
+ {NULL, 0}
+ },
+ {
+ {C_STRING_WITH_LEN("SERVICE_STATE")},
+ {C_STRING_WITH_LEN("enum('ON','OFF','CONNECTING')")},
+ {NULL, 0}
+ },
+ {
+ {C_STRING_WITH_LEN("COUNT_RECEIVED_HEARTBEATS")},
+ {C_STRING_WITH_LEN("bigint(20)")},
+ {NULL, 0}
+ },
+ {
+ {C_STRING_WITH_LEN("LAST_HEARTBEAT_TIMESTAMP")},
+ {C_STRING_WITH_LEN("timestamp")},
+ {NULL, 0}
+ },
+ {
+ {C_STRING_WITH_LEN("RECEIVED_TRANSACTION_SET")},
+ {C_STRING_WITH_LEN("longtext")},
+ {NULL, 0}
+ },
+ {
+ {C_STRING_WITH_LEN("LAST_ERROR_NUMBER")},
+ {C_STRING_WITH_LEN("int(11)")},
+ {NULL, 0}
+ },
+ {
+ {C_STRING_WITH_LEN("LAST_ERROR_MESSAGE")},
+ {C_STRING_WITH_LEN("varchar(1024)")},
+ {NULL, 0}
+ },
+ {
+ {C_STRING_WITH_LEN("LAST_ERROR_TIMESTAMP")},
+ {C_STRING_WITH_LEN("timestamp")},
+ {NULL, 0}
+ }
+};
+
+TABLE_FIELD_DEF
+table_replication_connection_status::m_field_def= { 11, field_types };
+
+PFS_engine_table_share
+table_replication_connection_status::m_share=
+{
+ { C_STRING_WITH_LEN("replication_connection_status") },
+ &pfs_readonly_acl,
+ table_replication_connection_status::create,
+ NULL, /* write_row */
+ NULL, /* delete_all_rows */
+ table_replication_connection_status::get_row_count, /* records */
+ sizeof(pos_t), /* ref length */
+ &m_table_lock,
+ &m_field_def,
+ false, /* checked */
+ false /* perpetual */
+};
+
+PFS_engine_table* table_replication_connection_status::create(void)
+{
+ return new table_replication_connection_status();
+}
+
+table_replication_connection_status::table_replication_connection_status()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(0), m_next_pos(0)
+{
+}
+
+table_replication_connection_status::~table_replication_connection_status()
+{
+}
+
+void table_replication_connection_status::reset_position(void)
+{
+ m_pos.m_index= 0;
+ m_next_pos.m_index= 0;
+}
+
+ha_rows table_replication_connection_status::get_row_count()
+{
+ /*A lock is not needed for an estimate */
+ return channel_map.get_max_channels();
+}
+
+
+
+int table_replication_connection_status::rnd_next(void)
+{
+ Master_info *mi= NULL;
+ channel_map.rdlock();
+
+ for (m_pos.set_at(&m_next_pos);
+ m_pos.m_index < channel_map.get_max_channels();
+ m_pos.next())
+ {
+ mi= channel_map.get_mi_at_pos(m_pos.m_index);
+
+ if (mi && mi->host[0])
+ {
+ make_row(mi);
+ m_next_pos.set_after(&m_pos);
+ channel_map.unlock();
+ return 0;
+ }
+ }
+
+ channel_map.unlock();
+ return HA_ERR_END_OF_FILE;
+}
+
+int table_replication_connection_status::rnd_pos(const void *pos)
+{
+ Master_info *mi;
+ int res= HA_ERR_RECORD_DELETED;
+
+ set_position(pos);
+
+ channel_map.rdlock();
+
+ if ((mi= channel_map.get_mi_at_pos(m_pos.m_index)))
+ {
+ make_row(mi);
+ res= 0;
+ }
+
+ channel_map.unlock();
+ return res;
+}
+
+void table_replication_connection_status::make_row(Master_info *mi)
+{
+ DBUG_ENTER("table_replication_connection_status::make_row");
+ m_row_exists= false;
+ bool error= false;
+
+ /* Default values */
+ m_row.group_name_is_null= true;
+ m_row.source_uuid_is_null= true;
+ m_row.thread_id_is_null= true;
+ m_row.service_state= PS_RPL_CONNECT_SERVICE_STATE_NO;
+
+ DBUG_ASSERT(mi != NULL);
+ DBUG_ASSERT(mi->rli != NULL);
+
+ mysql_mutex_lock(&mi->data_lock);
+ mysql_mutex_lock(&mi->rli->data_lock);
+
+ m_row.channel_name_length= mi->get_channel() ? strlen(mi->get_channel()):0;
+ memcpy(m_row.channel_name, mi->get_channel(), m_row.channel_name_length);
+
+ if (is_group_replication_plugin_loaded() &&
+ channel_map.is_group_replication_channel_name(mi->get_channel(), true))
+ {
+ /*
+ Group Replication applier channel.
+ Set callbacks on GROUP_REPLICATION_GROUP_MEMBER_STATS_CALLBACKS.
+ */
+ const GROUP_REPLICATION_CONNECTION_STATUS_CALLBACKS callbacks=
+ {
+ &m_row,
+ &set_channel_name,
+ &set_group_name,
+ &set_source_uuid,
+ &set_service_state,
+ };
+
+ // Query plugin and let callbacks do their job.
+ if (get_group_replication_connection_status_info(callbacks))
+ {
+ DBUG_PRINT("info", ("Group Replication stats not available!"));
+ }
+ }
+ else
+ {
+ /* Slave channel. */
+ if (mi->master_uuid[0] != 0)
+ {
+ memcpy(m_row.source_uuid, mi->master_uuid, UUID_LENGTH);
+ m_row.source_uuid_is_null= false;
+ }
+
+ if (mi->slave_running == MYSQL_SLAVE_RUN_CONNECT)
+ m_row.service_state= PS_RPL_CONNECT_SERVICE_STATE_YES;
+ else
+ {
+ if (mi->slave_running == MYSQL_SLAVE_RUN_NOT_CONNECT)
+ m_row.service_state= PS_RPL_CONNECT_SERVICE_STATE_CONNECTING;
+ else
+ m_row.service_state= PS_RPL_CONNECT_SERVICE_STATE_NO;
+ }
+ }
+
+ if (mi->slave_running == MYSQL_SLAVE_RUN_CONNECT)
+ {
+ PSI_thread *psi= thd_get_psi(mi->info_thd);
+ PFS_thread *pfs= reinterpret_cast<PFS_thread *> (psi);
+ if(pfs)
+ {
+ m_row.thread_id= pfs->m_thread_internal_id;
+ m_row.thread_id_is_null= false;
+ }
+ }
+
+ m_row.count_received_heartbeats= mi->received_heartbeats;
+ /*
+ Time in Milliseconds since epoch. active_mi->last_heartbeat contains
+ number of seconds so we multiply by 1000000.
+ */
+ m_row.last_heartbeat_timestamp= (ulonglong)mi->last_heartbeat*1000000;
+
+ {
+ global_sid_lock->wrlock();
+ const Gtid_set* io_gtid_set= mi->rli->get_gtid_set();
+
+ if ((m_row.received_transaction_set_length=
+ io_gtid_set->to_string(&m_row.received_transaction_set)) < 0)
+ {
+ my_free(m_row.received_transaction_set);
+ m_row.received_transaction_set_length= 0;
+ global_sid_lock->unlock();
+ error= true;
+ goto end;
+ }
+ global_sid_lock->unlock();
+ }
+
+ /* Errors */
+ mysql_mutex_lock(&mi->err_lock);
+ mysql_mutex_lock(&mi->rli->err_lock);
+ m_row.last_error_number= (unsigned int) mi->last_error().number;
+ m_row.last_error_message_length= 0;
+ m_row.last_error_timestamp= 0;
+
+ /** If error, set error message and timestamp */
+ if (m_row.last_error_number)
+ {
+ char* temp_store= (char*)mi->last_error().message;
+ m_row.last_error_message_length= strlen(temp_store);
+ memcpy(m_row.last_error_message, temp_store,
+ m_row.last_error_message_length);
+
+ /*
+ Time in millisecond since epoch. active_mi->last_error().skr contains
+ number of seconds so we multiply by 1000000. */
+ m_row.last_error_timestamp= (ulonglong)mi->last_error().skr*1000000;
+ }
+ mysql_mutex_unlock(&mi->rli->err_lock);
+ mysql_mutex_unlock(&mi->err_lock);
+
+end:
+ mysql_mutex_unlock(&mi->rli->data_lock);
+ mysql_mutex_unlock(&mi->data_lock);
+
+ if (!error)
+ m_row_exists= true;
+ DBUG_VOID_RETURN;
+}
+
+int table_replication_connection_status::read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /** channel_name*/
+ set_field_char_utf8(f, m_row.channel_name,m_row.channel_name_length);
+ break;
+ case 1: /** group_name */
+ if (m_row.group_name_is_null)
+ f->set_null();
+ else
+ set_field_char_utf8(f, m_row.group_name, UUID_LENGTH);
+ break;
+ case 2: /** source_uuid */
+ if (m_row.source_uuid_is_null)
+ f->set_null();
+ else
+ set_field_char_utf8(f, m_row.source_uuid, UUID_LENGTH);
+ break;
+ case 3: /** thread_id */
+ if(m_row.thread_id_is_null)
+ f->set_null();
+ else
+ set_field_ulonglong(f, m_row.thread_id);
+ break;
+ case 4: /** service_state */
+ set_field_enum(f, m_row.service_state);
+ break;
+ case 5: /** number of heartbeat events received **/
+ set_field_ulonglong(f, m_row.count_received_heartbeats);
+ break;
+ case 6: /** time of receipt of last heartbeat event **/
+ set_field_timestamp(f, m_row.last_heartbeat_timestamp);
+ break;
+ case 7: /** received_transaction_set */
+ set_field_longtext_utf8(f, m_row.received_transaction_set,
+ m_row.received_transaction_set_length);
+ break;
+ case 8: /*last_error_number*/
+ set_field_ulong(f, m_row.last_error_number);
+ break;
+ case 9: /*last_error_message*/
+ set_field_varchar_utf8(f, m_row.last_error_message,
+ m_row.last_error_message_length);
+ break;
+ case 10: /*last_error_timestamp*/
+ set_field_timestamp(f, m_row.last_error_timestamp);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+ m_row.cleanup();
+
+ return 0;
+}
diff --git a/storage/perfschema/table_replication_connection_status.h b/storage/perfschema/table_replication_connection_status.h
new file mode 100644
index 00000000..a1a5eb11
--- /dev/null
+++ b/storage/perfschema/table_replication_connection_status.h
@@ -0,0 +1,150 @@
+/*
+ Copyright (c) 2013, 2018, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
+
+
+#ifndef TABLE_REPLICATION_CONNECTION_STATUS_H
+#define TABLE_REPLICATION_CONNECTION_STATUS_H
+
+/**
+ @file storage/perfschema/table_replication_connection_status.h
+ Table replication_connection_status (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "rpl_mi.h"
+#include "rpl_reporting.h" /* MAX_SLAVE_ERRMSG */
+#include "mysql_com.h"
+//#include "rpl_msr.h"
+//#include "rpl_info.h" /*CHANNEL_NAME_LENGTH */
+#include "my_thread.h"
+
+class Master_info;
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+#ifndef ENUM_RPL_YES_NO
+#define ENUM_RPL_YES_NO
+enum enum_rpl_yes_no {
+ PS_RPL_YES= 1,
+ PS_RPL_NO
+};
+#endif
+
+enum enum_rpl_connect_status_service_state {
+ PS_RPL_CONNECT_SERVICE_STATE_YES= 1,
+ PS_RPL_CONNECT_SERVICE_STATE_NO,
+ PS_RPL_CONNECT_SERVICE_STATE_CONNECTING
+};
+
+/*
+ A row in the table. The fields with string values have an additional
+ length field denoted by <field_name>_length.
+*/
+struct st_row_connect_status {
+ char group_name[NAME_LEN];
+ bool group_name_is_null;
+ char channel_name[CHANNEL_NAME_LENGTH];
+ uint channel_name_length;
+ char source_uuid[11]; // typeof(server_id) == uint32
+ bool source_uuid_is_null;
+ ulonglong thread_id;
+ bool thread_id_is_null;
+ enum_rpl_connect_status_service_state service_state;
+ ulonglong count_received_heartbeats;
+ ulonglong last_heartbeat_timestamp;
+ char* received_transaction_set;
+ int received_transaction_set_length;
+ uint last_error_number;
+ char last_error_message[MAX_SLAVE_ERRMSG];
+ uint last_error_message_length;
+ ulonglong last_error_timestamp;
+
+ st_row_connect_status() : received_transaction_set(NULL) {}
+
+ void cleanup()
+ {
+ if (received_transaction_set != NULL)
+ {
+ my_free(received_transaction_set);
+ received_transaction_set= NULL;
+ }
+ }
+};
+
+
+/** Table PERFORMANCE_SCHEMA.REPLICATION_CONNECTION_STATUS. */
+class table_replication_connection_status: public PFS_engine_table
+{
+ typedef PFS_simple_index pos_t;
+
+private:
+ void make_row(Master_info *mi);
+
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+ /** Fields definition. */
+ static TABLE_FIELD_DEF m_field_def;
+ /** True if the current row exists. */
+ bool m_row_exists;
+ /** Current row */
+ st_row_connect_status m_row;
+ /** Current position. */
+ pos_t m_pos;
+ /** Next position. */
+ pos_t m_next_pos;
+
+protected:
+ /**
+ Read the current row values.
+ @param table Table handle
+ @param buf row buffer
+ @param fields Table fields
+ @param read_all true if all columns are read.
+ */
+
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_replication_connection_status();
+
+public:
+ ~table_replication_connection_status();
+
+ /** Table share. */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static ha_rows get_row_count();
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_replication_group_member_stats.cc b/storage/perfschema/table_replication_group_member_stats.cc
new file mode 100644
index 00000000..f85a3e3f
--- /dev/null
+++ b/storage/perfschema/table_replication_group_member_stats.cc
@@ -0,0 +1,372 @@
+/*
+ Copyright (c) 2014, 2016, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
+
+/**
+ @file storage/perfschema/table_replication_group_member_stats.cc
+ Table replication_group_member_stats (implementation).
+*/
+
+//#define HAVE_REPLICATION
+
+#include "my_global.h"
+#include "table_replication_group_member_stats.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "log.h"
+#include "rpl_group_replication.h"
+
+/*
+ Callbacks implementation for GROUP_REPLICATION_GROUP_MEMBER_STATS_CALLBACKS.
+*/
+static void set_channel_name(void* const context, const char& value,
+ size_t length)
+{
+ struct st_row_group_member_stats* row=
+ static_cast<struct st_row_group_member_stats*>(context);
+ const size_t max= CHANNEL_NAME_LENGTH;
+ length= std::min(length, max);
+
+ row->channel_name_length= length;
+ memcpy(row->channel_name, &value, length);
+}
+
+static void set_view_id(void* const context, const char& value, size_t length)
+{
+ struct st_row_group_member_stats* row=
+ static_cast<struct st_row_group_member_stats*>(context);
+ const size_t max= HOSTNAME_LENGTH;
+ length= std::min(length, max);
+
+ row->view_id_length= length;
+ memcpy(row->view_id, &value, length);
+}
+
+static void set_member_id(void* const context, const char& value, size_t length)
+{
+ struct st_row_group_member_stats* row=
+ static_cast<struct st_row_group_member_stats*>(context);
+ const size_t max= UUID_LENGTH;
+ length= std::min(length, max);
+
+ row->member_id_length= length;
+ memcpy(row->member_id, &value, length);
+}
+
+static void set_transactions_committed(void* const context, const char& value,
+ size_t length)
+{
+ struct st_row_group_member_stats* row=
+ static_cast<struct st_row_group_member_stats*>(context);
+
+ if (row->trx_committed != NULL)
+ my_free(row->trx_committed);
+
+ row->trx_committed_length= length;
+ row->trx_committed= (char*) my_malloc(PSI_NOT_INSTRUMENTED,
+ length,
+ MYF(0));
+ memcpy(row->trx_committed, &value, length);
+}
+
+static void set_last_conflict_free_transaction(void* const context,
+ const char& value, size_t length)
+{
+ struct st_row_group_member_stats* row=
+ static_cast<struct st_row_group_member_stats*>(context);
+ const size_t max= Gtid::MAX_TEXT_LENGTH+1;
+ length= std::min(length, max);
+
+ row->last_cert_trx_length= length;
+ memcpy(row->last_cert_trx, &value, length);
+}
+
+static void set_transactions_in_queue(void* const context,
+ unsigned long long int value)
+{
+ struct st_row_group_member_stats* row=
+ static_cast<struct st_row_group_member_stats*>(context);
+ row->trx_in_queue= value;
+}
+
+static void set_transactions_certified(void* const context,
+ unsigned long long int value)
+{
+ struct st_row_group_member_stats* row=
+ static_cast<struct st_row_group_member_stats*>(context);
+ row->trx_checked= value;
+}
+
+static void set_transactions_conflicts_detected(void* const context,
+ unsigned long long int value)
+{
+ struct st_row_group_member_stats* row=
+ static_cast<struct st_row_group_member_stats*>(context);
+ row->trx_conflicts= value;
+}
+
+static void set_transactions_rows_in_validation(void* const context,
+ unsigned long long int value)
+{
+ struct st_row_group_member_stats* row=
+ static_cast<struct st_row_group_member_stats*>(context);
+ row->trx_rows_validating= value;
+}
+
+
+THR_LOCK table_replication_group_member_stats::m_table_lock;
+
+static const TABLE_FIELD_TYPE field_types[]=
+{
+ {
+ {C_STRING_WITH_LEN("CHANNEL_NAME")},
+ {C_STRING_WITH_LEN("char(64)")},
+ {NULL, 0}
+ },
+ {
+ {C_STRING_WITH_LEN("VIEW_ID")},
+ {C_STRING_WITH_LEN("char(60)")},
+ {NULL, 0}
+ },
+ {
+ {C_STRING_WITH_LEN("MEMBER_ID")},
+ {C_STRING_WITH_LEN("char(36)")},
+ {NULL, 0}
+ },
+ {
+ {C_STRING_WITH_LEN("COUNT_TRANSACTIONS_IN_QUEUE")},
+ {C_STRING_WITH_LEN("bigint")},
+ {NULL, 0}
+ },
+ {
+ {C_STRING_WITH_LEN("COUNT_TRANSACTIONS_CHECKED")},
+ {C_STRING_WITH_LEN("bigint")},
+ {NULL, 0}
+ },
+ {
+ {C_STRING_WITH_LEN("COUNT_CONFLICTS_DETECTED")},
+ {C_STRING_WITH_LEN("bigint")},
+ {NULL, 0}
+ },
+ {
+ {C_STRING_WITH_LEN("COUNT_TRANSACTIONS_ROWS_VALIDATING")},
+ {C_STRING_WITH_LEN("bigint")},
+ {NULL, 0}
+ },
+ {
+ {C_STRING_WITH_LEN("TRANSACTIONS_COMMITTED_ALL_MEMBERS")},
+ {C_STRING_WITH_LEN("longtext")},
+ {NULL, 0}
+ },
+ {
+ {C_STRING_WITH_LEN("LAST_CONFLICT_FREE_TRANSACTION")},
+ {C_STRING_WITH_LEN("text")},
+ {NULL, 0}
+ }
+};
+
+TABLE_FIELD_DEF
+table_replication_group_member_stats::m_field_def=
+{ 9, field_types };
+
+PFS_engine_table_share
+table_replication_group_member_stats::m_share=
+{
+ { C_STRING_WITH_LEN("replication_group_member_stats") },
+ &pfs_readonly_acl,
+ &table_replication_group_member_stats::create,
+ NULL, /* write_row */
+ NULL, /* delete_all_rows */
+ table_replication_group_member_stats::get_row_count,
+ sizeof(PFS_simple_index), /* ref length */
+ &m_table_lock,
+ &m_field_def,
+ false, /* checked */
+ false /* perpetual */
+};
+
+PFS_engine_table* table_replication_group_member_stats::create(void)
+{
+ return new table_replication_group_member_stats();
+}
+
+table_replication_group_member_stats::table_replication_group_member_stats()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(0), m_next_pos(0)
+{
+ m_row.trx_committed= NULL;
+}
+
+table_replication_group_member_stats::~table_replication_group_member_stats()
+{
+ if (m_row.trx_committed != NULL)
+ {
+ my_free(m_row.trx_committed);
+ m_row.trx_committed= NULL;
+ }
+}
+
+void table_replication_group_member_stats::reset_position(void)
+{
+ m_pos.m_index= 0;
+ m_next_pos.m_index= 0;
+}
+
+ha_rows table_replication_group_member_stats::get_row_count()
+{
+ uint row_count= 0;
+
+ if (is_group_replication_plugin_loaded())
+ row_count= 1;
+
+ return row_count;
+}
+
+int table_replication_group_member_stats::rnd_next(void)
+{
+ if (!is_group_replication_plugin_loaded())
+ return HA_ERR_END_OF_FILE;
+
+ m_pos.set_at(&m_next_pos);
+ if (m_pos.m_index == 0)
+ {
+ make_row();
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int table_replication_group_member_stats::rnd_pos(const void *pos)
+{
+ if (get_row_count() == 0)
+ return HA_ERR_END_OF_FILE;
+
+ set_position(pos);
+ DBUG_ASSERT(m_pos.m_index < 1);
+ make_row();
+
+ return 0;
+}
+
+void table_replication_group_member_stats::make_row()
+{
+ DBUG_ENTER("table_replication_group_member_stats::make_row");
+ // Set default values.
+ m_row_exists= false;
+ m_row.channel_name_length= 0;
+ m_row.view_id_length= 0;
+ m_row.member_id_length= 0;
+ m_row.trx_committed_length= 0;
+ m_row.last_cert_trx_length= 0;
+ m_row.trx_in_queue= 0;
+ m_row.trx_checked= 0;
+ m_row.trx_conflicts= 0;
+ m_row.trx_rows_validating= 0;
+
+ // Set callbacks on GROUP_REPLICATION_GROUP_MEMBER_STATS_CALLBACKS.
+ const GROUP_REPLICATION_GROUP_MEMBER_STATS_CALLBACKS callbacks=
+ {
+ &m_row,
+ &set_channel_name,
+ &set_view_id,
+ &set_member_id,
+ &set_transactions_committed,
+ &set_last_conflict_free_transaction,
+ &set_transactions_in_queue,
+ &set_transactions_certified,
+ &set_transactions_conflicts_detected,
+ &set_transactions_rows_in_validation,
+ };
+
+ // Query plugin and let callbacks do their job.
+ if (get_group_replication_group_member_stats_info(callbacks))
+ {
+ DBUG_PRINT("info", ("Group Replication stats not available!"));
+ }
+ else
+ {
+ m_row_exists= true;
+ }
+
+ DBUG_VOID_RETURN;
+}
+
+
+int table_replication_group_member_stats::read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ DBUG_ASSERT(table->s->null_bytes == 0);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /** channel_name */
+ set_field_char_utf8(f, m_row.channel_name,
+ m_row.channel_name_length);
+ break;
+ case 1: /** view id */
+ set_field_char_utf8(f, m_row.view_id, m_row.view_id_length);
+ break;
+ case 2: /** member_id */
+ set_field_char_utf8(f, m_row.member_id, m_row.member_id_length);
+ break;
+ case 3: /** transaction_in_queue */
+ set_field_ulonglong(f, m_row.trx_in_queue);
+ break;
+ case 4: /** transactions_certified */
+ set_field_ulonglong(f, m_row.trx_checked);
+ break;
+ case 5: /** negatively_certified_transaction */
+ set_field_ulonglong(f, m_row.trx_conflicts);
+ break;
+ case 6: /** certification_db_size */
+ set_field_ulonglong(f, m_row.trx_rows_validating);
+ break;
+ case 7: /** stable_set */
+ set_field_longtext_utf8(f, m_row.trx_committed,
+ m_row.trx_committed_length);
+ break;
+ case 8: /** last_certified_transaction */
+ set_field_longtext_utf8(f, m_row.last_cert_trx,
+ m_row.last_cert_trx_length);
+
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+ return 0;
+}
diff --git a/storage/perfschema/table_replication_group_member_stats.h b/storage/perfschema/table_replication_group_member_stats.h
new file mode 100644
index 00000000..f2fcaf55
--- /dev/null
+++ b/storage/perfschema/table_replication_group_member_stats.h
@@ -0,0 +1,116 @@
+/*
+ Copyright (c) 2014, 2016, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
+
+
+#ifndef TABLE_REPLICATION_GROUP_MEMBER_STATS_H
+#define TABLE_REPLICATION_GROUP_MEMBER_STATS_H
+
+/**
+ @file storage/perfschema/table_replication_group_member_stats.h
+ Table replication_group_member_stats (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "mysql_com.h"
+//#include "rpl_info.h"
+//#include "rpl_gtid.h"
+//#include <mysql/plugin_group_replication.h>
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/**
+ A row in node status table. The fields with string values have an additional
+ length field denoted by <field_name>_length.
+*/
+
+struct st_row_group_member_stats {
+ char channel_name[CHANNEL_NAME_LENGTH];
+ uint channel_name_length;
+ char view_id[HOSTNAME_LENGTH];
+ uint view_id_length;
+ char member_id[11]; // typeof(server_id) == uint32
+ uint member_id_length;
+ ulonglong trx_in_queue;
+ ulonglong trx_checked;
+ ulonglong trx_conflicts;
+ ulonglong trx_rows_validating;
+ char *trx_committed;
+ size_t trx_committed_length;
+ char last_cert_trx[GTID_MAX_STR_LENGTH + 1];
+ int last_cert_trx_length;
+};
+
+/** Table PERFORMANCE_SCHEMA.REPLICATION_GROUP_MEMBER_STATS. */
+class table_replication_group_member_stats: public PFS_engine_table
+{
+private:
+ void make_row();
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+ /** Fields definition. */
+ static TABLE_FIELD_DEF m_field_def;
+ /** True if the current row exists. */
+ bool m_row_exists;
+ /** Current row */
+ st_row_group_member_stats m_row;
+ /** Current position. */
+ PFS_simple_index m_pos;
+ /** Next position. */
+ PFS_simple_index m_next_pos;
+
+protected:
+ /**
+ Read the current row values.
+ @param table Table handle
+ @param buf row buffer
+ @param fields Table fields
+ @param read_all true if all columns are read.
+ */
+
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_replication_group_member_stats();
+
+public:
+ ~table_replication_group_member_stats();
+
+ /** Table share. */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static ha_rows get_row_count();
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+};
+
+/** @} */
+#endif
+
diff --git a/storage/perfschema/table_replication_group_members.cc b/storage/perfschema/table_replication_group_members.cc
new file mode 100644
index 00000000..5967b98c
--- /dev/null
+++ b/storage/perfschema/table_replication_group_members.cc
@@ -0,0 +1,281 @@
+/*
+ Copyright (c) 2013, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
+
+/**
+ @file storage/perfschema/table_replication_group_members.cc
+ Table replication_group_members (implementation).
+*/
+
+//#define HAVE_REPLICATION
+
+#include "my_global.h"
+#include "table_replication_group_members.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "log.h"
+//#include "rpl_group_replication.h"
+
+/*
+ Callbacks implementation for GROUP_REPLICATION_GROUP_MEMBERS_CALLBACKS.
+*/
+static void set_channel_name(void* const context, const char& value,
+ size_t length)
+{
+ struct st_row_group_members* row=
+ static_cast<struct st_row_group_members*>(context);
+ const size_t max= CHANNEL_NAME_LENGTH;
+ length= std::min(length, max);
+
+ row->channel_name_length= length;
+ memcpy(row->channel_name, &value, length);
+}
+
+static void set_member_id(void* const context, const char& value,
+ size_t length)
+{
+ struct st_row_group_members* row=
+ static_cast<struct st_row_group_members*>(context);
+ const size_t max= UUID_LENGTH;
+ length= std::min(length, max);
+
+ row->member_id_length= length;
+ memcpy(row->member_id, &value, length);
+}
+
+static void set_member_host(void* const context, const char& value,
+ size_t length)
+{
+ struct st_row_group_members* row=
+ static_cast<struct st_row_group_members*>(context);
+ const size_t max= HOSTNAME_LENGTH;
+ length= std::min(length, max);
+
+ row->member_host_length= length;
+ memcpy(row->member_host, &value, length);
+}
+
+static void set_member_port(void* const context, unsigned int value)
+{
+ struct st_row_group_members* row=
+ static_cast<struct st_row_group_members*>(context);
+ row->member_port= value;
+}
+
+static void set_member_state(void* const context, const char& value,
+ size_t length)
+{
+ struct st_row_group_members* row=
+ static_cast<struct st_row_group_members*>(context);
+ const size_t max= NAME_LEN;
+ length= std::min(length, max);
+
+ row->member_state_length= length;
+ memcpy(row->member_state, &value, length);
+}
+
+
+THR_LOCK table_replication_group_members::m_table_lock;
+
+/* Numbers in varchar count utf8 characters. */
+static const TABLE_FIELD_TYPE field_types[]=
+{
+ {
+ {C_STRING_WITH_LEN("CHANNEL_NAME")},
+ {C_STRING_WITH_LEN("char(64)")},
+ {NULL, 0}
+ },
+ {
+ {C_STRING_WITH_LEN("MEMBER_ID")},
+ {C_STRING_WITH_LEN("char(36)")},
+ {NULL, 0}
+ },
+ {
+ {C_STRING_WITH_LEN("MEMBER_HOST")},
+ {C_STRING_WITH_LEN("char(60)")},
+ {NULL, 0}
+ },
+ {
+ {C_STRING_WITH_LEN("MEMBER_PORT")},
+ {C_STRING_WITH_LEN("int(11)")},
+ {NULL, 0}
+ },
+ {
+ {C_STRING_WITH_LEN("MEMBER_STATE")},
+ {C_STRING_WITH_LEN("char(64)")},
+ {NULL, 0}
+ }
+};
+
+TABLE_FIELD_DEF
+table_replication_group_members::m_field_def=
+{ 5, field_types };
+
+PFS_engine_table_share
+table_replication_group_members::m_share=
+{
+ { C_STRING_WITH_LEN("replication_group_members") },
+ &pfs_readonly_acl,
+ &table_replication_group_members::create,
+ NULL, /* write_row */
+ NULL, /* delete_all_rows */
+ table_replication_group_members::get_row_count,
+ sizeof(PFS_simple_index), /* ref length */
+ &m_table_lock,
+ &m_field_def,
+ false, /* checked */
+ false /* perpetual */
+};
+
+PFS_engine_table* table_replication_group_members::create(void)
+{
+ return new table_replication_group_members();
+}
+
+table_replication_group_members::table_replication_group_members()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(0), m_next_pos(0)
+{}
+
+table_replication_group_members::~table_replication_group_members()
+{}
+
+void table_replication_group_members::reset_position(void)
+{
+ m_pos.m_index= 0;
+ m_next_pos.m_index= 0;
+}
+
+ha_rows table_replication_group_members::get_row_count()
+{
+ return get_group_replication_members_number_info();
+}
+
+int table_replication_group_members::rnd_next(void)
+{
+ if (!is_group_replication_plugin_loaded())
+ return HA_ERR_END_OF_FILE;
+
+ for (m_pos.set_at(&m_next_pos);
+ m_pos.m_index < get_row_count();
+ m_pos.next())
+ {
+ make_row(m_pos.m_index);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int table_replication_group_members::rnd_pos(const void *pos)
+{
+ if (!is_group_replication_plugin_loaded())
+ return HA_ERR_END_OF_FILE;
+
+ set_position(pos);
+ DBUG_ASSERT(m_pos.m_index < get_row_count());
+ make_row(m_pos.m_index);
+
+ return 0;
+}
+
+void table_replication_group_members::make_row(uint index)
+{
+ DBUG_ENTER("table_replication_group_members::make_row");
+ // Set default values.
+ m_row_exists= false;
+ m_row.channel_name_length= 0;
+ m_row.member_id_length= 0;
+ m_row.member_host_length= 0;
+ m_row.member_port= 0;
+ m_row.member_state_length= 0;
+
+ // Set callbacks on GROUP_REPLICATION_GROUP_MEMBERS_CALLBACKS.
+ const GROUP_REPLICATION_GROUP_MEMBERS_CALLBACKS callbacks=
+ {
+ &m_row,
+ &set_channel_name,
+ &set_member_id,
+ &set_member_host,
+ &set_member_port,
+ &set_member_state,
+ };
+
+ // Query plugin and let callbacks do their job.
+ if (get_group_replication_group_members_info(index, callbacks))
+ {
+ DBUG_PRINT("info", ("Group Replication stats not available!"));
+ }
+ else
+ {
+ m_row_exists= true;
+ }
+
+ DBUG_VOID_RETURN;
+}
+
+
+int table_replication_group_members::read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /** channel_name */
+ set_field_char_utf8(f, m_row.channel_name, m_row.channel_name_length);
+ break;
+ case 1: /** member_id */
+ set_field_char_utf8(f, m_row.member_id, m_row.member_id_length);
+ break;
+ case 2: /** member_host */
+ set_field_char_utf8(f, m_row.member_host, m_row.member_host_length);
+ break;
+ case 3: /** member_port */
+ if (m_row.member_port > 0)
+ set_field_ulong(f, m_row.member_port);
+ else
+ f->set_null();
+ break;
+ case 4: /** member_state */
+ set_field_char_utf8(f, m_row.member_state, m_row.member_state_length);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+ return 0;
+}
diff --git a/storage/perfschema/table_replication_group_members.h b/storage/perfschema/table_replication_group_members.h
new file mode 100644
index 00000000..8ce875eb
--- /dev/null
+++ b/storage/perfschema/table_replication_group_members.h
@@ -0,0 +1,108 @@
+/*
+ Copyright (c) 2013, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
+
+
+#ifndef TABLE_REPLICATION_GROUP_MEMBERS_H
+#define TABLE_REPLICATION_GROUP_MEMBERS_H
+
+/**
+ @file storage/perfschema/table_replication_group_members.h
+ Table replication_group_members (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "mysql_com.h"
+//#include "rpl_info.h"
+//#include <mysql/plugin_group_replication.h>
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/**
+ A row in connection nodes table. The fields with string values have an additional
+ length field denoted by <field_name>_length.
+*/
+struct st_row_group_members {
+ char channel_name[CHANNEL_NAME_LENGTH];
+ uint channel_name_length;
+ char member_id[11]; // typeof(server_id) == uint32
+ uint member_id_length;
+ char member_host[HOSTNAME_LENGTH];
+ uint member_host_length;
+ uint member_port;
+ char member_state[NAME_LEN];
+ uint member_state_length;
+};
+
+/** Table PERFORMANCE_SCHEMA.replication_group_members. */
+class table_replication_group_members: public PFS_engine_table
+{
+private:
+ void make_row(uint index);
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+ /** Fields definition. */
+ static TABLE_FIELD_DEF m_field_def;
+ /** True if the current row exists. */
+ bool m_row_exists;
+ /** Current row */
+ st_row_group_members m_row;
+ /** Current position. */
+ PFS_simple_index m_pos;
+ /** Next position. */
+ PFS_simple_index m_next_pos;
+
+protected:
+ /**
+ Read the current row values.
+ @param table Table handle
+ @param buf row buffer
+ @param fields Table fields
+ @param read_all true if all columns are read.
+ */
+
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_replication_group_members();
+
+public:
+ ~table_replication_group_members();
+
+ /** Table share. */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static ha_rows get_row_count();
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_session_account_connect_attrs.cc b/storage/perfschema/table_session_account_connect_attrs.cc
new file mode 100644
index 00000000..0e8be68d
--- /dev/null
+++ b/storage/perfschema/table_session_account_connect_attrs.cc
@@ -0,0 +1,82 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#include <my_global.h>
+#include "table_session_account_connect_attrs.h"
+
+THR_LOCK table_session_account_connect_attrs::m_table_lock;
+
+PFS_engine_table_share
+table_session_account_connect_attrs::m_share=
+{
+ { C_STRING_WITH_LEN("session_account_connect_attrs") },
+ &pfs_readonly_world_acl,
+ table_session_account_connect_attrs::create,
+ NULL, /* write_row */
+ NULL, /* delete_all_rows */
+ cursor_by_thread_connect_attr::get_row_count,
+ sizeof(pos_connect_attr_by_thread_by_attr), /* ref length */
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE session_account_connect_attrs("
+ "PROCESSLIST_ID INT NOT NULL,"
+ "ATTR_NAME VARCHAR(32) NOT NULL,"
+ "ATTR_VALUE VARCHAR(1024),"
+ "ORDINAL_POSITION INT"
+ ") CHARACTER SET utf8 COLLATE utf8_bin") },
+ false /* perpetual */
+};
+
+PFS_engine_table* table_session_account_connect_attrs::create()
+{
+ return new table_session_account_connect_attrs();
+}
+
+table_session_account_connect_attrs::table_session_account_connect_attrs()
+ : table_session_connect(&m_share)
+{}
+
+bool
+table_session_account_connect_attrs::thread_fits(PFS_thread *thread)
+{
+ PFS_thread *current_thread= PFS_thread::get_current_thread();
+ /* The current thread may not have instrumentation attached. */
+ if (current_thread == NULL)
+ return false;
+
+ /* The thread we compare to, by definition, has some instrumentation. */
+ DBUG_ASSERT(thread != NULL);
+
+ uint username_length= current_thread->m_username_length;
+ uint hostname_length= current_thread->m_hostname_length;
+
+ if ( (thread->m_username_length != username_length)
+ || (thread->m_hostname_length != hostname_length))
+ return false;
+
+ if (memcmp(thread->m_username, current_thread->m_username, username_length) != 0)
+ return false;
+
+ if (memcmp(thread->m_hostname, current_thread->m_hostname, hostname_length) != 0)
+ return false;
+
+ return true;
+}
diff --git a/storage/perfschema/table_session_account_connect_attrs.h b/storage/perfschema/table_session_account_connect_attrs.h
new file mode 100644
index 00000000..043f83da
--- /dev/null
+++ b/storage/perfschema/table_session_account_connect_attrs.h
@@ -0,0 +1,57 @@
+/* Copyright (c) 2012, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_SESSION_ACCOUNT_CONNECT_ATTRS_H
+#define TABLE_SESSION_ACCOUNT_CONNECT_ATTRS_H
+
+#include "table_session_connect.h"
+/**
+ \addtogroup Performance_schema_tables
+ @{
+*/
+
+/** Table PERFORMANCE_SCHEMA.SESSION_ACCOUNT_CONNECT_ATTRS. */
+class table_session_account_connect_attrs : public table_session_connect
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ /** Table builder */
+ static PFS_engine_table* create();
+
+protected:
+ table_session_account_connect_attrs();
+
+public:
+ ~table_session_account_connect_attrs()
+ {}
+
+protected:
+ virtual bool thread_fits(PFS_thread *thread);
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_session_connect.cc b/storage/perfschema/table_session_connect.cc
new file mode 100644
index 00000000..09f32fea
--- /dev/null
+++ b/storage/perfschema/table_session_connect.cc
@@ -0,0 +1,295 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#include <my_global.h>
+#include "table_session_connect.h"
+#include "field.h"
+
+table_session_connect::table_session_connect(const PFS_engine_table_share *share)
+ : cursor_by_thread_connect_attr(share)
+{
+ if (session_connect_attrs_size_per_thread > 0)
+ {
+ m_copy_session_connect_attrs= (char *) my_malloc(PSI_INSTRUMENT_ME,
+ session_connect_attrs_size_per_thread,
+ MYF(0));
+ }
+ else
+ {
+ m_copy_session_connect_attrs= NULL;
+ }
+ m_copy_session_connect_attrs_length= 0;
+}
+
+table_session_connect::~table_session_connect()
+{
+ my_free(m_copy_session_connect_attrs);
+}
+
+/**
+ Take a length encoded string
+
+ @arg ptr inout the input string array
+ @arg dest where to store the result
+ @arg dest_size max size of @c dest
+ @arg copied_len the actual length of the data copied
+ @arg start_ptr pointer to the start of input
+ @arg input_length the length of the incoming data
+ @arg copy_data copy the data or just skip the input
+ @arg from_cs character set in which @c ptr is encoded
+ @arg nchars_max maximum number of characters to read
+ @return status
+ @retval true parsing failed
+ @retval false parsing succeeded
+*/
+bool parse_length_encoded_string(const char **ptr,
+ char *dest, uint dest_size,
+ uint *copied_len,
+ const char *start_ptr, uint input_length,
+ bool copy_data,
+ const CHARSET_INFO *from_cs,
+ uint nchars_max)
+{
+ ulong copy_length, data_length;
+ String_copier copier;
+
+ copy_length= data_length= net_field_length((uchar **) ptr);
+
+ /* we don't tolerate NULL as a length */
+ if (data_length == NULL_LENGTH)
+ return true;
+
+ if (*ptr - start_ptr + data_length > input_length)
+ return true;
+
+ copy_length= copier.well_formed_copy(&my_charset_utf8mb3_bin, dest, dest_size,
+ from_cs, *ptr, data_length, nchars_max);
+ *copied_len= copy_length;
+ (*ptr)+= data_length;
+
+ return false;
+}
+
+/**
+ Take the nth attribute name/value pair
+
+ Parse the attributes blob form the beginning, skipping the attributes
+ whose number is lower than the one we seek.
+ When we reach the attribute at an index we're looking for the values
+ are copied to the output parameters.
+ If parsing fails or no more attributes are found the function stops
+ and returns an error code.
+
+ @arg connect_attrs pointer to the connect attributes blob
+ @arg connect_attrs_length length of @c connect_attrs
+ @arg connect_attrs_cs character set used to encode @c connect_attrs
+ @arg ordinal index of the attribute we need
+ @arg attr_name [out] buffer to receive the attribute name
+ @arg max_attr_name max size of @c attr_name in bytes
+ @arg attr_name_length [out] number of bytes written in @attr_name
+ @arg attr_value [out] buffer to receive the attribute name
+ @arg max_attr_value max size of @c attr_value in bytes
+ @arg attr_value_length [out] number of bytes written in @attr_value
+ @return status
+ @retval true requested attribute pair is found and copied
+ @retval false error. Either because of parsing or too few attributes.
+*/
+bool read_nth_attr(const char *connect_attrs,
+ uint connect_attrs_length,
+ const CHARSET_INFO *connect_attrs_cs,
+ uint ordinal,
+ char *attr_name, uint max_attr_name,
+ uint *attr_name_length,
+ char *attr_value, uint max_attr_value,
+ uint *attr_value_length)
+{
+ uint idx;
+ const char *ptr;
+
+ for (ptr= connect_attrs, idx= 0;
+ (uint)(ptr - connect_attrs) < connect_attrs_length && idx <= ordinal;
+ idx++)
+ {
+ uint copy_length;
+ /* do the copying only if we absolutely have to */
+ bool fill_in_attr_name= idx == ordinal;
+ bool fill_in_attr_value= idx == ordinal;
+
+ /* read the key */
+ if (parse_length_encoded_string(&ptr,
+ attr_name, max_attr_name, &copy_length,
+ connect_attrs,
+ connect_attrs_length,
+ fill_in_attr_name,
+ connect_attrs_cs, 32) ||
+ !copy_length
+ )
+ return false;
+
+ if (idx == ordinal)
+ *attr_name_length= copy_length;
+
+ /* read the value */
+ if (parse_length_encoded_string(&ptr,
+ attr_value, max_attr_value, &copy_length,
+ connect_attrs,
+ connect_attrs_length,
+ fill_in_attr_value,
+ connect_attrs_cs, 1024))
+ return false;
+
+ if (idx == ordinal)
+ *attr_value_length= copy_length;
+
+ if (idx == ordinal)
+ return true;
+ }
+
+ return false;
+}
+
+void table_session_connect::make_row(PFS_thread *pfs, uint ordinal)
+{
+ pfs_optimistic_state lock;
+ pfs_optimistic_state session_lock;
+ PFS_thread_class *safe_class;
+ const CHARSET_INFO *cs;
+
+ m_row_exists= false;
+
+ /* Protect this reader against thread termination */
+ pfs->m_lock.begin_optimistic_lock(&lock);
+ /* Protect this reader against writing on session attributes */
+ pfs->m_session_lock.begin_optimistic_lock(&session_lock);
+
+ safe_class= sanitize_thread_class(pfs->m_class);
+ if (unlikely(safe_class == NULL))
+ return;
+
+ /* Filtering threads must be done under the protection of the optimistic lock. */
+ if (! thread_fits(pfs))
+ return;
+
+ /* Make a safe copy of the session attributes */
+
+ if (m_copy_session_connect_attrs == NULL)
+ return;
+
+ m_copy_session_connect_attrs_length= pfs->m_session_connect_attrs_length;
+
+ if (m_copy_session_connect_attrs_length > session_connect_attrs_size_per_thread)
+ return;
+
+ memcpy(m_copy_session_connect_attrs,
+ pfs->m_session_connect_attrs,
+ m_copy_session_connect_attrs_length);
+
+ cs= get_charset(pfs->m_session_connect_attrs_cs_number, MYF(0));
+ if (cs == NULL)
+ return;
+
+ if (! pfs->m_session_lock.end_optimistic_lock(& session_lock))
+ return;
+
+ if (! pfs->m_lock.end_optimistic_lock(& lock))
+ return;
+
+ /*
+ Now we have a safe copy of the data,
+ that will not change while parsing it
+ */
+
+ /* populate the row */
+ if (read_nth_attr(m_copy_session_connect_attrs,
+ m_copy_session_connect_attrs_length,
+ cs,
+ ordinal,
+ m_row.m_attr_name, (uint) sizeof(m_row.m_attr_name),
+ &m_row.m_attr_name_length,
+ m_row.m_attr_value, (uint) sizeof(m_row.m_attr_value),
+ &m_row.m_attr_value_length))
+ {
+ /* we don't expect internal threads to have connection attributes */
+ if (pfs->m_processlist_id == 0)
+ return;
+
+ m_row.m_ordinal_position= ordinal;
+ m_row.m_process_id= pfs->m_processlist_id;
+
+ m_row_exists= true;
+ }
+}
+
+int table_session_connect::read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(!m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case FO_PROCESS_ID:
+ if (m_row.m_process_id != 0)
+ set_field_ulong(f, m_row.m_process_id);
+ else
+ f->set_null();
+ break;
+ case FO_ATTR_NAME:
+ set_field_varchar_utf8(f, m_row.m_attr_name,
+ m_row.m_attr_name_length);
+ break;
+ case FO_ATTR_VALUE:
+ if (m_row.m_attr_value_length)
+ set_field_varchar_utf8(f, m_row.m_attr_value,
+ m_row.m_attr_value_length);
+ else
+ f->set_null();
+ break;
+ case FO_ORDINAL_POSITION:
+ set_field_ulong(f, m_row.m_ordinal_position);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+ return 0;
+}
+
+bool
+table_session_connect::thread_fits(PFS_thread *thread)
+{
+ return true;
+}
+
diff --git a/storage/perfschema/table_session_connect.h b/storage/perfschema/table_session_connect.h
new file mode 100644
index 00000000..55433e25
--- /dev/null
+++ b/storage/perfschema/table_session_connect.h
@@ -0,0 +1,86 @@
+/* Copyright (c) 2012, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_SESSION_CONNECT_H
+#define TABLE_SESSION_CONNECT_H
+
+#include "pfs_column_types.h"
+#include "cursor_by_thread_connect_attr.h"
+#include "table_helper.h"
+
+#define MAX_ATTR_NAME_CHARS 32
+#define MAX_ATTR_VALUE_CHARS 1024
+#define MAX_UTF8_BYTES 6
+
+/** symbolic names for field offsets, keep in sync with field_types */
+enum field_offsets {
+ FO_PROCESS_ID,
+ FO_ATTR_NAME,
+ FO_ATTR_VALUE,
+ FO_ORDINAL_POSITION
+};
+
+/**
+ A row of PERFORMANCE_SCHEMA.SESSION_CONNECT_ATTRS and
+ PERFORMANCE_SCHEMA.SESSION_ACCOUNT_CONNECT_ATTRS.
+*/
+struct row_session_connect_attrs
+{
+ /** Column PROCESS_ID. */
+ ulong m_process_id;
+ /** Column ATTR_NAME. In UTF-8 */
+ char m_attr_name[MAX_ATTR_NAME_CHARS * MAX_UTF8_BYTES];
+ /** Length in bytes of @c m_attr_name. */
+ uint m_attr_name_length;
+ /** Column ATTR_VALUE. In UTF-8 */
+ char m_attr_value[MAX_ATTR_VALUE_CHARS * MAX_UTF8_BYTES];
+ /** Length in bytes of @c m_attr_name. */
+ uint m_attr_value_length;
+ /** Column ORDINAL_POSITION. */
+ ulong m_ordinal_position;
+};
+
+/** Abstract table PERFORMANCE_SCHEMA.SESSION_CONNECT_ATTRS. */
+class table_session_connect : public cursor_by_thread_connect_attr
+{
+protected:
+ table_session_connect(const PFS_engine_table_share *share);
+
+public:
+ ~table_session_connect();
+
+protected:
+ virtual void make_row(PFS_thread *pfs, uint ordinal);
+ virtual bool thread_fits(PFS_thread *thread);
+ virtual int read_row_values(TABLE *table, unsigned char *buf,
+ Field **fields, bool read_all);
+protected:
+ /** Current row. */
+ row_session_connect_attrs m_row;
+ /** Safe copy of @c PFS_thread::m_session_connect_attrs. */
+ char *m_copy_session_connect_attrs;
+ /** Safe copy of @c PFS_thread::m_session_connect_attrs_length. */
+ uint m_copy_session_connect_attrs_length;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_session_connect_attrs.cc b/storage/perfschema/table_session_connect_attrs.cc
new file mode 100644
index 00000000..cc3fae46
--- /dev/null
+++ b/storage/perfschema/table_session_connect_attrs.cc
@@ -0,0 +1,55 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#include <my_global.h>
+#include "table_session_connect_attrs.h"
+
+THR_LOCK table_session_connect_attrs::m_table_lock;
+
+PFS_engine_table_share
+table_session_connect_attrs::m_share=
+{
+ { C_STRING_WITH_LEN("session_connect_attrs") },
+ &pfs_readonly_acl,
+ table_session_connect_attrs::create,
+ NULL, /* write_row */
+ NULL, /* delete_all_rows */
+ cursor_by_thread_connect_attr::get_row_count,
+ sizeof(pos_connect_attr_by_thread_by_attr), /* ref length */
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE session_connect_attrs("
+ "PROCESSLIST_ID INT NOT NULL,"
+ "ATTR_NAME VARCHAR(32) NOT NULL,"
+ "ATTR_VALUE VARCHAR(1024),"
+ "ORDINAL_POSITION INT"
+ ") CHARACTER SET utf8 COLLATE utf8_bin") },
+ false /* perpetual */
+};
+
+PFS_engine_table* table_session_connect_attrs::create()
+{
+ return new table_session_connect_attrs();
+}
+
+table_session_connect_attrs::table_session_connect_attrs()
+ : table_session_connect(&m_share)
+{}
diff --git a/storage/perfschema/table_session_connect_attrs.h b/storage/perfschema/table_session_connect_attrs.h
new file mode 100644
index 00000000..09b9d1c4
--- /dev/null
+++ b/storage/perfschema/table_session_connect_attrs.h
@@ -0,0 +1,54 @@
+/* Copyright (c) 2012, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_SESSION_CONNECT_ATTRS_H
+#define TABLE_SESSION_CONNECT_ATTRS_H
+
+#include "table_session_connect.h"
+/**
+ \addtogroup Performance_schema_tables
+ @{
+*/
+
+/** Table PERFORMANCE_SCHEMA.SESSION_CONNECT_ATTRS. */
+class table_session_connect_attrs : public table_session_connect
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ /** Table builder */
+ static PFS_engine_table* create();
+
+protected:
+ table_session_connect_attrs();
+
+public:
+ ~table_session_connect_attrs()
+ {}
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_session_status.cc b/storage/perfschema/table_session_status.cc
new file mode 100644
index 00000000..acff99ca
--- /dev/null
+++ b/storage/perfschema/table_session_status.cc
@@ -0,0 +1,185 @@
+/* Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
+
+/**
+ @file storage/perfschema/table_session_status.cc
+ Table SESSION_STATUS (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "table_session_status.h"
+#include "pfs_instr_class.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "pfs_global.h"
+
+THR_LOCK table_session_status::m_table_lock;
+
+PFS_engine_table_share
+table_session_status::m_share=
+{
+ { C_STRING_WITH_LEN("session_status") },
+ &pfs_readonly_world_acl,
+ table_session_status::create,
+ NULL, /* write_row */
+ NULL, /* delete_all_rows */
+ table_session_status::get_row_count,
+ sizeof(pos_t),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE session_status("
+ "VARIABLE_NAME VARCHAR(64) not null,"
+ "VARIABLE_VALUE VARCHAR(1024))") },
+ true /* perpetual */
+};
+
+PFS_engine_table*
+table_session_status::create(void)
+{
+ return new table_session_status();
+}
+
+ha_rows table_session_status::get_row_count(void)
+{
+ mysql_mutex_lock(&LOCK_status);
+ ha_rows status_var_count= all_status_vars.elements;
+ mysql_mutex_unlock(&LOCK_status);
+ return status_var_count;
+}
+
+table_session_status::table_session_status()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_status_cache(false), m_row_exists(false), m_pos(0), m_next_pos(0)
+{}
+
+void table_session_status::reset_position(void)
+{
+ m_pos.m_index = 0;
+ m_next_pos.m_index = 0;
+}
+
+int table_session_status::rnd_init(bool scan)
+{
+ /* Build a cache of all status variables for this thread. */
+ m_status_cache.materialize_all(current_thd);
+
+ /* Record the current number of status variables to detect subsequent changes. */
+ ulonglong status_version= m_status_cache.get_status_array_version();
+
+ /*
+ The table context holds the current version of the global status array.
+ If scan == true, then allocate a new context from mem_root and store in TLS.
+ If scan == false, then restore from TLS.
+ */
+ m_context= (table_session_status_context *)current_thd->alloc(sizeof(table_session_status_context));
+ new(m_context) table_session_status_context(status_version, !scan);
+ return 0;
+}
+
+int table_session_status::rnd_next(void)
+{
+ for (m_pos.set_at(&m_next_pos);
+ m_pos.m_index < m_status_cache.size();
+ m_pos.next())
+ {
+ if (m_status_cache.is_materialized())
+ {
+ const Status_variable *stat_var= m_status_cache.get(m_pos.m_index);
+ if (stat_var != NULL)
+ {
+ make_row(stat_var);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+ }
+ return HA_ERR_END_OF_FILE;
+}
+
+int
+table_session_status::rnd_pos(const void *pos)
+{
+ /* If global status array has changed, do nothing. */ // TODO: warning
+ if (!m_context->versions_match())
+ return HA_ERR_RECORD_DELETED;
+
+ set_position(pos);
+ DBUG_ASSERT(m_pos.m_index < m_status_cache.size());
+
+ if (m_status_cache.is_materialized())
+ {
+ const Status_variable *stat_var= m_status_cache.get(m_pos.m_index);
+ if (stat_var != NULL)
+ {
+ make_row(stat_var);
+ return 0;
+ }
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_session_status
+::make_row(const Status_variable *status_var)
+{
+ m_row_exists= false;
+ m_row.m_variable_name.make_row(status_var->m_name, status_var->m_name_length);
+ m_row.m_variable_value.make_row(status_var);
+ m_row_exists= true;
+}
+
+int table_session_status
+::read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(!m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* VARIABLE_NAME */
+ set_field_varchar_utf8(f, m_row.m_variable_name.m_str, m_row.m_variable_name.m_length);
+ break;
+ case 1: /* VARIABLE_VALUE */
+ m_row.m_variable_value.set_field(f);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_session_status.h b/storage/perfschema/table_session_status.h
new file mode 100644
index 00000000..24634fe4
--- /dev/null
+++ b/storage/perfschema/table_session_status.h
@@ -0,0 +1,119 @@
+/* Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
+
+#ifndef TABLE_SESSION_STATUS_H
+#define TABLE_SESSION_STATUS_H
+
+/**
+ @file storage/perfschema/table_session_status.h
+ Table SESSION_STATUS (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "table_helper.h"
+#include "pfs_variable.h"
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/**
+ A row of table
+ PERFORMANCE_SCHEMA.SESSION_STATUS.
+*/
+struct row_session_status
+{
+ /** Column THREAD_ID. */
+ ulonglong m_thread_internal_id;
+ /** Column VARIABLE_NAME. */
+ PFS_variable_name_row m_variable_name;
+ /** Column VARIABLE_VALUE. */
+ PFS_variable_value_row m_variable_value;
+};
+
+/**
+ Store and retrieve table state information for queries that reinstantiate
+ the table object.
+*/
+class table_session_status_context : public PFS_table_context
+{
+public:
+ table_session_status_context(ulonglong current_version, bool restore) :
+ PFS_table_context(current_version, restore, THR_PFS_SS) { }
+};
+
+/** Table PERFORMANCE_SCHEMA.SESSION_STATUS. */
+class table_session_status : public PFS_engine_table
+{
+ typedef PFS_simple_index pos_t;
+
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static ha_rows get_row_count();
+
+ virtual int rnd_init(bool scan);
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+ table_session_status();
+
+public:
+ ~table_session_status()
+ {}
+
+protected:
+ void make_row(const Status_variable *status_var);
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+ /** Fields definition. */
+ static TABLE_FIELD_DEF m_field_def;
+
+ /** Current THD variables. */
+ PFS_status_variable_cache m_status_cache;
+ /** Current row. */
+ row_session_status m_row;
+ /** True if the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ pos_t m_pos;
+ /** Next position. */
+ pos_t m_next_pos;
+
+ /** Table context with global status array version. */
+ table_session_status_context *m_context;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_session_variables.cc b/storage/perfschema/table_session_variables.cc
new file mode 100644
index 00000000..3ed13145
--- /dev/null
+++ b/storage/perfschema/table_session_variables.cc
@@ -0,0 +1,187 @@
+/* Copyright (c) 2015, 2018, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
+
+/**
+ @file storage/perfschema/table_session_variables.cc
+ Table SESSION_VARIABLES (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "table_session_variables.h"
+#include "pfs_instr_class.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "pfs_global.h"
+
+THR_LOCK table_session_variables::m_table_lock;
+
+PFS_engine_table_share
+table_session_variables::m_share=
+{
+ { C_STRING_WITH_LEN("session_variables") },
+ &pfs_readonly_world_acl,
+ table_session_variables::create,
+ NULL, /* write_row */
+ NULL, /* delete_all_rows */
+ table_session_variables::get_row_count,
+ sizeof(pos_t),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE session_variables("
+ "VARIABLE_NAME VARCHAR(64) not null,"
+ "VARIABLE_VALUE VARCHAR(1024))") },
+ true /* perpetual */
+};
+
+PFS_engine_table*
+table_session_variables::create(void)
+{
+ return new table_session_variables();
+}
+
+ha_rows table_session_variables::get_row_count(void)
+{
+ mysql_mutex_lock(&LOCK_plugin_delete);
+ mysql_prlock_rdlock(&LOCK_system_variables_hash);
+ ha_rows system_var_count= get_system_variable_hash_records();
+ mysql_prlock_unlock(&LOCK_system_variables_hash);
+ mysql_mutex_unlock(&LOCK_plugin_delete);
+ return system_var_count;
+}
+
+table_session_variables::table_session_variables()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_sysvar_cache(false), m_row_exists(false), m_pos(0), m_next_pos(0)
+{}
+
+void table_session_variables::reset_position(void)
+{
+ m_pos.m_index = 0;
+ m_next_pos.m_index = 0;
+}
+
+int table_session_variables::rnd_init(bool scan)
+{
+ /* Build a cache of system variables for this thread. */
+ m_sysvar_cache.materialize_all(current_thd);
+
+ /* Record the version of the system variable hash. */
+ ulonglong hash_version= m_sysvar_cache.get_sysvar_hash_version();
+
+ /*
+ The table context holds the current version of the system variable hash.
+ If scan == true, then allocate a new context from mem_root and store in TLS.
+ If scan == false, then restore from TLS.
+ */
+ m_context= (table_session_variables_context *)current_thd->alloc(sizeof(table_session_variables_context));
+ new(m_context) table_session_variables_context(hash_version, !scan);
+ return 0;
+}
+
+int table_session_variables::rnd_next(void)
+{
+ for (m_pos.set_at(&m_next_pos);
+ m_pos.m_index < m_sysvar_cache.size();
+ m_pos.next())
+ {
+ if (m_sysvar_cache.is_materialized())
+ {
+ const System_variable *system_var= m_sysvar_cache.get(m_pos.m_index);
+ if (system_var != NULL)
+ {
+ make_row(system_var);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+ }
+ return HA_ERR_END_OF_FILE;
+}
+
+int table_session_variables::rnd_pos(const void *pos)
+{
+ /* If system variable hash changes, do nothing. */
+ if (!m_context->versions_match())
+ return HA_ERR_RECORD_DELETED;
+
+ set_position(pos);
+ DBUG_ASSERT(m_pos.m_index < m_sysvar_cache.size());
+
+ if (m_sysvar_cache.is_materialized())
+ {
+ const System_variable *system_var= m_sysvar_cache.get(m_pos.m_index);
+ if (system_var != NULL)
+ {
+ make_row(system_var);
+ return 0;
+ }
+ }
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_session_variables
+::make_row(const System_variable *system_var)
+{
+ m_row_exists= false;
+ if (system_var->is_null() || system_var->is_ignored())
+ return;
+ m_row.m_variable_name.make_row(system_var->m_name, system_var->m_name_length);
+ m_row.m_variable_value.make_row(system_var);
+ m_row_exists= true;
+}
+
+int table_session_variables
+::read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(!m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* VARIABLE_NAME */
+ set_field_varchar_utf8(f, m_row.m_variable_name.m_str, m_row.m_variable_name.m_length);
+ break;
+ case 1: /* VARIABLE_VALUE */
+ m_row.m_variable_value.set_field(f);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_session_variables.h b/storage/perfschema/table_session_variables.h
new file mode 100644
index 00000000..576bf73e
--- /dev/null
+++ b/storage/perfschema/table_session_variables.h
@@ -0,0 +1,117 @@
+/* Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
+
+#ifndef TABLE_SESSION_VARIABLES_H
+#define TABLE_SESSION_VARIABLES_H
+
+/**
+ @file storage/perfschema/table_session_variables.h
+ Table SESSION_VARIABLES (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "table_helper.h"
+#include "pfs_variable.h"
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/**
+ Store and retrieve table state information during queries that reinstantiate
+ the table object.
+*/
+class table_session_variables_context : public PFS_table_context
+{
+public:
+ table_session_variables_context(ulonglong hash_version, bool restore) :
+ PFS_table_context(hash_version, restore, THR_PFS_SV) {}
+};
+
+/**
+ A row of table
+ PERFORMANCE_SCHEMA.SESSION_VARIABLES.
+*/
+struct row_session_variables
+{
+ /** Column VARIABLE_NAME. */
+ PFS_variable_name_row m_variable_name;
+ /** Column VARIABLE_VALUE. */
+ PFS_variable_value_row m_variable_value;
+};
+
+/** Table PERFORMANCE_SCHEMA.SESSION_VARIABLES. */
+class table_session_variables : public PFS_engine_table
+{
+ typedef PFS_simple_index pos_t;
+
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static ha_rows get_row_count();
+
+ virtual int rnd_init(bool scan);
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+ table_session_variables();
+
+public:
+ ~table_session_variables()
+ {}
+
+protected:
+ void make_row(const System_variable *system_var);
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+ /** Fields definition. */
+ static TABLE_FIELD_DEF m_field_def;
+
+ /** Current THD variables. */
+ PFS_system_variable_cache m_sysvar_cache;
+ /** Current row. */
+ row_session_variables m_row;
+ /** True if the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ pos_t m_pos;
+ /** Next position. */
+ pos_t m_next_pos;
+
+ /** Table context with system variable hash version. */
+ table_session_variables_context *m_context;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_setup_actors.cc b/storage/perfschema/table_setup_actors.cc
new file mode 100644
index 00000000..e17bf312
--- /dev/null
+++ b/storage/perfschema/table_setup_actors.cc
@@ -0,0 +1,312 @@
+/* Copyright (c) 2010, 2016, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_setup_actors.cc
+ Table SETUP_ACTORS (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "pfs_instr_class.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "pfs_setup_actor.h"
+#include "table_setup_actors.h"
+#include "pfs_global.h"
+#include "pfs_buffer_container.h"
+#include "field.h"
+
+THR_LOCK table_setup_actors::m_table_lock;
+
+PFS_engine_table_share
+table_setup_actors::m_share=
+{
+ { C_STRING_WITH_LEN("setup_actors") },
+ &pfs_editable_acl,
+ table_setup_actors::create,
+ table_setup_actors::write_row,
+ table_setup_actors::delete_all_rows,
+ table_setup_actors::get_row_count,
+ sizeof(PFS_simple_index),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE setup_actors("
+ "HOST CHAR(" HOSTNAME_LENGTH_STR ") collate utf8_bin default '%' not null,"
+ "USER CHAR(" USERNAME_CHAR_LENGTH_STR ") collate utf8_bin default '%' not null,"
+ "ROLE CHAR(" USERNAME_CHAR_LENGTH_STR ") collate utf8_bin default '%' not null,"
+ "ENABLED ENUM('YES', 'NO') not null default 'YES',"
+ "HISTORY ENUM('YES', 'NO') not null default 'YES')") },
+ false /* perpetual */
+};
+
+PFS_engine_table* table_setup_actors::create()
+{
+ return new table_setup_actors();
+}
+
+int table_setup_actors::write_row(TABLE *table, const unsigned char *buf,
+ Field **fields)
+{
+ Field *f;
+ String user_data("%", 1, &my_charset_utf8mb3_bin);
+ String host_data("%", 1, &my_charset_utf8mb3_bin);
+ String role_data("%", 1, &my_charset_utf8mb3_bin);
+ String *user= &user_data;
+ String *host= &host_data;
+ String *role= &role_data;
+ enum_yes_no enabled_value= ENUM_YES;
+ enum_yes_no history_value= ENUM_YES;
+ bool enabled;
+ bool history;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (bitmap_is_set(table->write_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* HOST */
+ host= get_field_char_utf8(f, &host_data);
+ break;
+ case 1: /* USER */
+ user= get_field_char_utf8(f, &user_data);
+ break;
+ case 2: /* ROLE */
+ role= get_field_char_utf8(f, &role_data);
+ break;
+ case 3: /* ENABLED */
+ enabled_value= (enum_yes_no) get_field_enum(f);
+ break;
+ case 4: /* HISTORY */
+ history_value= (enum_yes_no) get_field_enum(f);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+
+ /* Reject illegal enum values in ENABLED */
+ if ((enabled_value != ENUM_YES) && (enabled_value != ENUM_NO))
+ return HA_ERR_NO_REFERENCED_ROW;
+
+ /* Reject illegal enum values in HISTORY */
+ if ((history_value != ENUM_YES) && (history_value != ENUM_NO))
+ return HA_ERR_NO_REFERENCED_ROW;
+
+ /* Reject if any of user/host/role is not provided */
+ if (user->length() == 0 || host->length() == 0 || role->length() == 0)
+ return HA_ERR_WRONG_COMMAND;
+
+ enabled= (enabled_value == ENUM_YES) ? true : false;
+ history= (history_value == ENUM_YES) ? true : false;
+
+ return insert_setup_actor(user, host, role, enabled, history);
+}
+
+int table_setup_actors::delete_all_rows(void)
+{
+ return reset_setup_actor();
+}
+
+ha_rows table_setup_actors::get_row_count(void)
+{
+ return global_setup_actor_container.get_row_count();
+}
+
+table_setup_actors::table_setup_actors()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(0), m_next_pos(0)
+{}
+
+void table_setup_actors::reset_position(void)
+{
+ m_pos.m_index= 0;
+ m_next_pos.m_index= 0;
+}
+
+int table_setup_actors::rnd_next()
+{
+ PFS_setup_actor *pfs;
+
+ m_pos.set_at(&m_next_pos);
+ PFS_setup_actor_iterator it= global_setup_actor_container.iterate(m_pos.m_index);
+ pfs= it.scan_next(& m_pos.m_index);
+ if (pfs != NULL)
+ {
+ make_row(pfs);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int table_setup_actors::rnd_pos(const void *pos)
+{
+ PFS_setup_actor *pfs;
+
+ set_position(pos);
+
+ pfs= global_setup_actor_container.get(m_pos.m_index);
+ if (pfs != NULL)
+ {
+ make_row(pfs);
+ return 0;
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_setup_actors::make_row(PFS_setup_actor *pfs)
+{
+ pfs_optimistic_state lock;
+
+ m_row_exists= false;
+
+ pfs->m_lock.begin_optimistic_lock(&lock);
+
+ m_row.m_hostname_length= pfs->m_hostname_length;
+ if (unlikely((m_row.m_hostname_length == 0) ||
+ (m_row.m_hostname_length > sizeof(m_row.m_hostname))))
+ return;
+ memcpy(m_row.m_hostname, pfs->m_hostname, m_row.m_hostname_length);
+
+ m_row.m_username_length= pfs->m_username_length;
+ if (unlikely((m_row.m_username_length == 0) ||
+ (m_row.m_username_length > sizeof(m_row.m_username))))
+ return;
+ memcpy(m_row.m_username, pfs->m_username, m_row.m_username_length);
+
+ m_row.m_rolename_length= pfs->m_rolename_length;
+ if (unlikely((m_row.m_rolename_length == 0) ||
+ (m_row.m_rolename_length > sizeof(m_row.m_rolename))))
+ return;
+ memcpy(m_row.m_rolename, pfs->m_rolename, m_row.m_rolename_length);
+
+ m_row.m_enabled_ptr= &pfs->m_enabled;
+ m_row.m_history_ptr= &pfs->m_history;
+
+ if (pfs->m_lock.end_optimistic_lock(&lock))
+ m_row_exists= true;
+}
+
+int table_setup_actors::read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 1);
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* HOST */
+ set_field_char_utf8(f, m_row.m_hostname, m_row.m_hostname_length);
+ break;
+ case 1: /* USER */
+ set_field_char_utf8(f, m_row.m_username, m_row.m_username_length);
+ break;
+ case 2: /* ROLE */
+ set_field_char_utf8(f, m_row.m_rolename, m_row.m_rolename_length);
+ break;
+ case 3: /* ENABLED */
+ set_field_enum(f, (*m_row.m_enabled_ptr) ? ENUM_YES : ENUM_NO);
+ break;
+ case 4: /* HISTORY */
+ set_field_enum(f, (*m_row.m_history_ptr) ? ENUM_YES : ENUM_NO);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+
+ return 0;
+}
+
+int table_setup_actors::update_row_values(TABLE *table,
+ const unsigned char *old_buf,
+ const unsigned char *new_buf,
+ Field **fields)
+{
+ int result;
+ Field *f;
+ enum_yes_no value;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (bitmap_is_set(table->write_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* HOST */
+ case 1: /* USER */
+ case 2: /* ROLE */
+ return HA_ERR_WRONG_COMMAND;
+ case 3: /* ENABLED */
+ value= (enum_yes_no) get_field_enum(f);
+ /* Reject illegal enum values in ENABLED */
+ if ((value != ENUM_YES) && (value != ENUM_NO))
+ return HA_ERR_NO_REFERENCED_ROW;
+ *m_row.m_enabled_ptr= (value == ENUM_YES) ? true : false;
+ break;
+ case 4: /* HISTORY */
+ value= (enum_yes_no) get_field_enum(f);
+ /* Reject illegal enum values in HISTORY */
+ if ((value != ENUM_YES) && (value != ENUM_NO))
+ return HA_ERR_NO_REFERENCED_ROW;
+ *m_row.m_history_ptr= (value == ENUM_YES) ? true : false;
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+
+ result= update_setup_actors_derived_flags();
+ return result;
+}
+
+int table_setup_actors::delete_row_values(TABLE *table,
+ const unsigned char *buf,
+ Field **fields)
+{
+ DBUG_ASSERT(m_row_exists);
+
+ CHARSET_INFO *cs= &my_charset_utf8mb3_bin;
+ String user(m_row.m_username, m_row.m_username_length, cs);
+ String role(m_row.m_rolename, m_row.m_rolename_length, cs);
+ String host(m_row.m_hostname, m_row.m_hostname_length, cs);
+
+ return delete_setup_actor(&user, &host, &role);
+}
+
diff --git a/storage/perfschema/table_setup_actors.h b/storage/perfschema/table_setup_actors.h
new file mode 100644
index 00000000..32a60331
--- /dev/null
+++ b/storage/perfschema/table_setup_actors.h
@@ -0,0 +1,115 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_SETUP_ACTORS_H
+#define TABLE_SETUP_ACTORS_H
+
+/**
+ @file storage/perfschema/table_setup_actors.h
+ Table SETUP_ACTORS (declarations).
+*/
+
+#include "pfs_engine_table.h"
+
+struct PFS_setup_actor;
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/** A row of PERFORMANCE_SCHEMA.SETUP_ACTORS. */
+struct row_setup_actors
+{
+ /** Column HOST. */
+ char m_hostname[HOSTNAME_LENGTH];
+ /** Length in bytes of @c m_hostname. */
+ uint m_hostname_length;
+ /** Column USER. */
+ char m_username[USERNAME_LENGTH];
+ /** Length in bytes of @c m_username. */
+ uint m_username_length;
+ /** Column ROLE. */
+ char m_rolename[16];
+ /** Length in bytes of @c m_rolename. */
+ uint m_rolename_length;
+ /** Column ENABLED. */
+ bool *m_enabled_ptr;
+ /** Column HISTORY. */
+ bool *m_history_ptr;
+};
+
+/** Table PERFORMANCE_SCHEMA.SETUP_ACTORS. */
+class table_setup_actors : public PFS_engine_table
+{
+public:
+ /** Table share. */
+ static PFS_engine_table_share m_share;
+ /** Table builder. */
+ static PFS_engine_table* create();
+ static int write_row(TABLE *table, const unsigned char *buf, Field **fields);
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ virtual int update_row_values(TABLE *table,
+ const unsigned char *old_buf,
+ const unsigned char *new_buf,
+ Field **fields);
+
+ virtual int delete_row_values(TABLE *table,
+ const unsigned char *buf,
+ Field **fields);
+
+ table_setup_actors();
+
+public:
+ ~table_setup_actors()
+ {}
+
+private:
+ void make_row(PFS_setup_actor *actor);
+
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ /** Current row. */
+ row_setup_actors m_row;
+ /** True if the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ PFS_simple_index m_pos;
+ /** Next position. */
+ PFS_simple_index m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_setup_consumers.cc b/storage/perfschema/table_setup_consumers.cc
new file mode 100644
index 00000000..1745bf35
--- /dev/null
+++ b/storage/perfschema/table_setup_consumers.cc
@@ -0,0 +1,275 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_setup_consumers.cc
+ Table SETUP_CONSUMERS (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "table_setup_consumers.h"
+#include "pfs_instr.h"
+#include "pfs_events_waits.h"
+#include "pfs_digest.h"
+#include "field.h"
+
+#define COUNT_SETUP_CONSUMERS 15
+
+static row_setup_consumers all_setup_consumers_data[COUNT_SETUP_CONSUMERS]=
+{
+ {
+ { C_STRING_WITH_LEN("events_stages_current") },
+ &flag_events_stages_current,
+ false,
+ false
+ },
+ {
+ { C_STRING_WITH_LEN("events_stages_history") },
+ &flag_events_stages_history,
+ false,
+ true
+ },
+ {
+ { C_STRING_WITH_LEN("events_stages_history_long") },
+ &flag_events_stages_history_long,
+ false,
+ true
+ },
+ {
+ { C_STRING_WITH_LEN("events_statements_current") },
+ &flag_events_statements_current,
+ false,
+ false
+ },
+ {
+ { C_STRING_WITH_LEN("events_statements_history") },
+ &flag_events_statements_history,
+ false,
+ true
+ },
+ {
+ { C_STRING_WITH_LEN("events_statements_history_long") },
+ &flag_events_statements_history_long,
+ false,
+ true
+ },
+ {
+ { C_STRING_WITH_LEN("events_transactions_current") },
+ &flag_events_transactions_current,
+ false,
+ false
+ },
+ {
+ { C_STRING_WITH_LEN("events_transactions_history") },
+ &flag_events_transactions_history,
+ false,
+ true
+ },
+ {
+ { C_STRING_WITH_LEN("events_transactions_history_long") },
+ &flag_events_transactions_history_long,
+ false,
+ true
+ },
+ {
+ { C_STRING_WITH_LEN("events_waits_current") },
+ &flag_events_waits_current,
+ false,
+ false
+ },
+ {
+ { C_STRING_WITH_LEN("events_waits_history") },
+ &flag_events_waits_history,
+ false,
+ true
+ },
+ {
+ { C_STRING_WITH_LEN("events_waits_history_long") },
+ &flag_events_waits_history_long,
+ false,
+ true
+ },
+ {
+ { C_STRING_WITH_LEN("global_instrumentation") },
+ &flag_global_instrumentation,
+ true,
+ true
+ },
+ {
+ { C_STRING_WITH_LEN("thread_instrumentation") },
+ &flag_thread_instrumentation,
+ false,
+ true
+ },
+ {
+ { C_STRING_WITH_LEN("statements_digest") },
+ &flag_statements_digest,
+ false,
+ false
+ }
+};
+
+THR_LOCK table_setup_consumers::m_table_lock;
+
+PFS_engine_table_share
+table_setup_consumers::m_share=
+{
+ { C_STRING_WITH_LEN("setup_consumers") },
+ &pfs_updatable_acl,
+ table_setup_consumers::create,
+ NULL, /* write_row */
+ NULL, /* delete_all_rows */
+ table_setup_consumers::get_row_count,
+ sizeof(PFS_simple_index), /* ref length */
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE setup_consumers("
+ "NAME VARCHAR(64) not null,"
+ "ENABLED ENUM ('YES', 'NO') not null)") },
+ false /* perpetual */
+};
+
+PFS_engine_table* table_setup_consumers::create(void)
+{
+ return new table_setup_consumers();
+}
+
+ha_rows
+table_setup_consumers::get_row_count(void)
+{
+ return COUNT_SETUP_CONSUMERS;
+}
+
+table_setup_consumers::table_setup_consumers()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row(NULL), m_pos(0), m_next_pos(0)
+{}
+
+void table_setup_consumers::reset_position(void)
+{
+ m_pos.m_index= 0;
+ m_next_pos.m_index= 0;
+}
+
+int table_setup_consumers::rnd_next(void)
+{
+ int result;
+
+ m_pos.set_at(&m_next_pos);
+
+ if (m_pos.m_index < COUNT_SETUP_CONSUMERS)
+ {
+ m_row= &all_setup_consumers_data[m_pos.m_index];
+ m_next_pos.set_after(&m_pos);
+ result= 0;
+ }
+ else
+ {
+ m_row= NULL;
+ result= HA_ERR_END_OF_FILE;
+ }
+
+ return result;
+}
+
+int table_setup_consumers::rnd_pos(const void *pos)
+{
+ set_position(pos);
+ DBUG_ASSERT(m_pos.m_index < COUNT_SETUP_CONSUMERS);
+ m_row= &all_setup_consumers_data[m_pos.m_index];
+ return 0;
+}
+
+int table_setup_consumers::read_row_values(TABLE *table,
+ unsigned char *,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ DBUG_ASSERT(m_row);
+
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 0);
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* NAME */
+ set_field_varchar_utf8(f, m_row->m_name.str,(uint) m_row->m_name.length);
+ break;
+ case 1: /* ENABLED */
+ set_field_enum(f, (*m_row->m_enabled_ptr) ? ENUM_YES : ENUM_NO);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+
+ return 0;
+}
+
+int table_setup_consumers::update_row_values(TABLE *table,
+ const unsigned char *,
+ const unsigned char *,
+ Field **fields)
+{
+ Field *f;
+ enum_yes_no value;
+
+ DBUG_ASSERT(m_row);
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (bitmap_is_set(table->write_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* NAME */
+ return HA_ERR_WRONG_COMMAND;
+ case 1: /* ENABLED */
+ {
+ value= (enum_yes_no) get_field_enum(f);
+ *m_row->m_enabled_ptr= (value == ENUM_YES) ? true : false;
+ break;
+ }
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+
+ if (m_row->m_instrument_refresh)
+ update_instruments_derived_flags();
+
+ if (m_row->m_thread_refresh)
+ update_thread_derived_flags();
+
+ return 0;
+}
+
+
diff --git a/storage/perfschema/table_setup_consumers.h b/storage/perfschema/table_setup_consumers.h
new file mode 100644
index 00000000..9d601622
--- /dev/null
+++ b/storage/perfschema/table_setup_consumers.h
@@ -0,0 +1,95 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_SETUP_CONSUMERS_H
+#define TABLE_SETUP_CONSUMERS_H
+
+/**
+ @file storage/perfschema/table_setup_consumers.h
+ Table SETUP_CONSUMERS (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/** A row of PERFORMANCE_SCHEMA.SETUP_CONSUMERS. */
+struct row_setup_consumers
+{
+ /** Column NAME. */
+ LEX_STRING m_name;
+ /** Column ENABLED. */
+ bool *m_enabled_ptr;
+ /** Hidden column, instrument refresh. */
+ bool m_instrument_refresh;
+ /** Hidden column, thread refresh. */
+ bool m_thread_refresh;
+};
+
+/** Table PERFORMANCE_SCHEMA.SETUP_CONSUMERS. */
+class table_setup_consumers : public PFS_engine_table
+{
+public:
+ /** Table share. */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static ha_rows get_row_count();
+
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ virtual int update_row_values(TABLE *table,
+ const unsigned char *old_buf,
+ const unsigned char *new_buf,
+ Field **fields);
+
+ table_setup_consumers();
+
+public:
+ ~table_setup_consumers()
+ {}
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ /** Current row. */
+ row_setup_consumers *m_row;
+ /** Current position. */
+ PFS_simple_index m_pos;
+ /** Next position. */
+ PFS_simple_index m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_setup_instruments.cc b/storage/perfschema/table_setup_instruments.cc
new file mode 100644
index 00000000..69e48b9c
--- /dev/null
+++ b/storage/perfschema/table_setup_instruments.cc
@@ -0,0 +1,372 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_setup_instruments.cc
+ Table SETUP_INSTRUMENTS (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "pfs_instr_class.h"
+#include "pfs_builtin_memory.h"
+#include "pfs_instr.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "table_setup_instruments.h"
+#include "pfs_global.h"
+#include "pfs_setup_object.h"
+#include "field.h"
+
+THR_LOCK table_setup_instruments::m_table_lock;
+
+PFS_engine_table_share
+table_setup_instruments::m_share=
+{
+ { C_STRING_WITH_LEN("setup_instruments") },
+ &pfs_updatable_acl,
+ table_setup_instruments::create,
+ NULL, /* write_row */
+ NULL, /* delete_all_rows */
+ table_setup_instruments::get_row_count,
+ sizeof(pos_setup_instruments),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE setup_instruments("
+ "NAME VARCHAR(128) not null,"
+ "ENABLED ENUM ('YES', 'NO') not null,"
+ "TIMED ENUM ('YES', 'NO') not null)") },
+ false /* perpetual */
+};
+
+PFS_engine_table* table_setup_instruments::create(void)
+{
+ return new table_setup_instruments();
+}
+
+ha_rows
+table_setup_instruments::get_row_count(void)
+{
+ return wait_class_max
+ + stage_class_max
+ + statement_class_max
+ + transaction_class_max
+ + memory_class_max;
+}
+
+table_setup_instruments::table_setup_instruments()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_pos(), m_next_pos()
+{}
+
+void table_setup_instruments::reset_position(void)
+{
+ m_pos.reset();
+ m_next_pos.reset();
+}
+
+int table_setup_instruments::rnd_next(void)
+{
+ PFS_instr_class *instr_class= NULL;
+ PFS_builtin_memory_class *pfs_builtin;
+ bool update_enabled;
+ bool update_timed;
+
+ /* Do not advertise hard coded instruments when disabled. */
+ if (! pfs_initialized)
+ return HA_ERR_END_OF_FILE;
+
+ for (m_pos.set_at(&m_next_pos);
+ m_pos.has_more_view();
+ m_pos.next_view())
+ {
+ update_enabled= true;
+ update_timed= true;
+
+ switch (m_pos.m_index_1)
+ {
+ case pos_setup_instruments::VIEW_MUTEX:
+ instr_class= find_mutex_class(m_pos.m_index_2);
+ break;
+ case pos_setup_instruments::VIEW_RWLOCK:
+ instr_class= find_rwlock_class(m_pos.m_index_2);
+ break;
+ case pos_setup_instruments::VIEW_COND:
+ instr_class= find_cond_class(m_pos.m_index_2);
+ break;
+ case pos_setup_instruments::VIEW_THREAD:
+ /* Not used yet */
+ break;
+ case pos_setup_instruments::VIEW_FILE:
+ instr_class= find_file_class(m_pos.m_index_2);
+ break;
+ case pos_setup_instruments::VIEW_TABLE:
+ instr_class= find_table_class(m_pos.m_index_2);
+ break;
+ case pos_setup_instruments::VIEW_STAGE:
+ instr_class= find_stage_class(m_pos.m_index_2);
+ break;
+ case pos_setup_instruments::VIEW_STATEMENT:
+ instr_class= find_statement_class(m_pos.m_index_2);
+ break;
+ case pos_setup_instruments::VIEW_TRANSACTION:
+ instr_class= find_transaction_class(m_pos.m_index_2);
+ break;
+ case pos_setup_instruments::VIEW_SOCKET:
+ instr_class= find_socket_class(m_pos.m_index_2);
+ break;
+ case pos_setup_instruments::VIEW_IDLE:
+ instr_class= find_idle_class(m_pos.m_index_2);
+ break;
+ case pos_setup_instruments::VIEW_BUILTIN_MEMORY:
+ update_enabled= false;
+ update_timed= false;
+ pfs_builtin= find_builtin_memory_class(m_pos.m_index_2);
+ if (pfs_builtin != NULL)
+ instr_class= & pfs_builtin->m_class;
+ else
+ instr_class= NULL;
+ break;
+ case pos_setup_instruments::VIEW_MEMORY:
+ update_timed= false;
+ instr_class= find_memory_class(m_pos.m_index_2);
+ break;
+ case pos_setup_instruments::VIEW_METADATA:
+ instr_class= find_metadata_class(m_pos.m_index_2);
+ break;
+ }
+ if (instr_class)
+ {
+ make_row(instr_class, update_enabled, update_timed);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int table_setup_instruments::rnd_pos(const void *pos)
+{
+ PFS_instr_class *instr_class= NULL;
+ PFS_builtin_memory_class *pfs_builtin;
+ bool update_enabled;
+ bool update_timed;
+
+ /* Do not advertise hard coded instruments when disabled. */
+ if (! pfs_initialized)
+ return HA_ERR_END_OF_FILE;
+
+ set_position(pos);
+
+ update_enabled= true;
+ update_timed= true;
+
+ switch (m_pos.m_index_1)
+ {
+ case pos_setup_instruments::VIEW_MUTEX:
+ instr_class= find_mutex_class(m_pos.m_index_2);
+ break;
+ case pos_setup_instruments::VIEW_RWLOCK:
+ instr_class= find_rwlock_class(m_pos.m_index_2);
+ break;
+ case pos_setup_instruments::VIEW_COND:
+ instr_class= find_cond_class(m_pos.m_index_2);
+ break;
+ case pos_setup_instruments::VIEW_THREAD:
+ /* Not used yet */
+ break;
+ case pos_setup_instruments::VIEW_FILE:
+ instr_class= find_file_class(m_pos.m_index_2);
+ break;
+ case pos_setup_instruments::VIEW_TABLE:
+ instr_class= find_table_class(m_pos.m_index_2);
+ break;
+ case pos_setup_instruments::VIEW_STAGE:
+ instr_class= find_stage_class(m_pos.m_index_2);
+ break;
+ case pos_setup_instruments::VIEW_STATEMENT:
+ instr_class= find_statement_class(m_pos.m_index_2);
+ break;
+ case pos_setup_instruments::VIEW_TRANSACTION:
+ instr_class= find_transaction_class(m_pos.m_index_2);
+ break;
+ case pos_setup_instruments::VIEW_SOCKET:
+ instr_class= find_socket_class(m_pos.m_index_2);
+ break;
+ case pos_setup_instruments::VIEW_IDLE:
+ instr_class= find_idle_class(m_pos.m_index_2);
+ break;
+ case pos_setup_instruments::VIEW_BUILTIN_MEMORY:
+ update_enabled= false;
+ update_timed= false;
+ pfs_builtin= find_builtin_memory_class(m_pos.m_index_2);
+ if (pfs_builtin != NULL)
+ instr_class= & pfs_builtin->m_class;
+ else
+ instr_class= NULL;
+ break;
+ case pos_setup_instruments::VIEW_MEMORY:
+ update_timed= false;
+ instr_class= find_memory_class(m_pos.m_index_2);
+ break;
+ case pos_setup_instruments::VIEW_METADATA:
+ instr_class= find_metadata_class(m_pos.m_index_2);
+ break;
+ }
+ if (instr_class)
+ {
+ make_row(instr_class, update_enabled, update_timed);
+ return 0;
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_setup_instruments::make_row(PFS_instr_class *klass, bool update_enabled, bool update_timed)
+{
+ m_row.m_instr_class= klass;
+ m_row.m_update_enabled= update_enabled;
+ m_row.m_update_timed= update_timed;
+}
+
+int table_setup_instruments::read_row_values(TABLE *table,
+ unsigned char *,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ DBUG_ASSERT(table->s->null_bytes == 0);
+
+ /*
+ The row always exist, the instrument classes
+ are static and never disappear.
+ */
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* NAME */
+ set_field_varchar_utf8(f, m_row.m_instr_class->m_name, m_row.m_instr_class->m_name_length);
+ break;
+ case 1: /* ENABLED */
+ set_field_enum(f, m_row.m_instr_class->m_enabled ? ENUM_YES : ENUM_NO);
+ break;
+ case 2: /* TIMED */
+ set_field_enum(f, m_row.m_instr_class->m_timed ? ENUM_YES : ENUM_NO);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+
+ return 0;
+}
+
+int table_setup_instruments::update_row_values(TABLE *table,
+ const unsigned char *,
+ const unsigned char *,
+ Field **fields)
+{
+ Field *f;
+ enum_yes_no value;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (bitmap_is_set(table->write_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* NAME */
+ return HA_ERR_WRONG_COMMAND;
+ case 1: /* ENABLED */
+ /* Do not raise error if m_update_enabled is false, silently ignore. */
+ if (m_row.m_update_enabled)
+ {
+ value= (enum_yes_no) get_field_enum(f);
+ m_row.m_instr_class->m_enabled= (value == ENUM_YES) ? true : false;
+ }
+ break;
+ case 2: /* TIMED */
+ /* Do not raise error if m_update_timed is false, silently ignore. */
+ if (m_row.m_update_timed)
+ {
+ value= (enum_yes_no) get_field_enum(f);
+ m_row.m_instr_class->m_timed= (value == ENUM_YES) ? true : false;
+ }
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+
+ switch (m_pos.m_index_1)
+ {
+ case pos_setup_instruments::VIEW_MUTEX:
+ update_mutex_derived_flags();
+ break;
+ case pos_setup_instruments::VIEW_RWLOCK:
+ update_rwlock_derived_flags();
+ break;
+ case pos_setup_instruments::VIEW_COND:
+ update_cond_derived_flags();
+ break;
+ case pos_setup_instruments::VIEW_THREAD:
+ /* Not used yet */
+ break;
+ case pos_setup_instruments::VIEW_FILE:
+ update_file_derived_flags();
+ break;
+ case pos_setup_instruments::VIEW_TABLE:
+ update_table_derived_flags();
+ break;
+ case pos_setup_instruments::VIEW_STAGE:
+ case pos_setup_instruments::VIEW_STATEMENT:
+ case pos_setup_instruments::VIEW_TRANSACTION:
+ /* No flag to update. */
+ break;
+ case pos_setup_instruments::VIEW_SOCKET:
+ update_socket_derived_flags();
+ break;
+ case pos_setup_instruments::VIEW_IDLE:
+ /* No flag to update. */
+ break;
+ case pos_setup_instruments::VIEW_BUILTIN_MEMORY:
+ case pos_setup_instruments::VIEW_MEMORY:
+ /* No flag to update. */
+ break;
+ case pos_setup_instruments::VIEW_METADATA:
+ update_metadata_derived_flags();
+ break;
+ default:
+ DBUG_ASSERT(false);
+ break;
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_setup_instruments.h b/storage/perfschema/table_setup_instruments.h
new file mode 100644
index 00000000..42aa2dd9
--- /dev/null
+++ b/storage/perfschema/table_setup_instruments.h
@@ -0,0 +1,135 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_SETUP_INSTRUMENTS_H
+#define TABLE_SETUP_INSTRUMENTS_H
+
+/**
+ @file storage/perfschema/table_setup_instruments.h
+ Table SETUP_INSTRUMENTS (declarations).
+*/
+
+#include "pfs_instr_class.h"
+#include "pfs_engine_table.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/** A row of PERFORMANCE_SCHEMA.SETUP_INSTRUMENTS. */
+struct row_setup_instruments
+{
+ /** Columns NAME, ENABLED, TIMED. */
+ PFS_instr_class *m_instr_class;
+ /** True if column ENABLED can be updated. */
+ bool m_update_enabled;
+ /** True if column TIMED can be updated. */
+ bool m_update_timed;
+};
+
+/** Position of a cursor on PERFORMANCE_SCHEMA.SETUP_INSTRUMENTS. */
+struct pos_setup_instruments : public PFS_double_index
+{
+ static const uint FIRST_VIEW= 1;
+ static const uint VIEW_MUTEX= 1;
+ static const uint VIEW_RWLOCK= 2;
+ static const uint VIEW_COND= 3;
+ static const uint VIEW_THREAD= 4;
+ static const uint VIEW_FILE= 5;
+ static const uint VIEW_TABLE= 6;
+ static const uint VIEW_STAGE= 7;
+ static const uint VIEW_STATEMENT= 8;
+ static const uint VIEW_TRANSACTION=9;
+ static const uint VIEW_SOCKET= 10;
+ static const uint VIEW_IDLE= 11;
+ static const uint VIEW_BUILTIN_MEMORY= 12;
+ static const uint VIEW_MEMORY= 13;
+ static const uint VIEW_METADATA= 14;
+ static const uint LAST_VIEW= 14;
+
+ pos_setup_instruments()
+ : PFS_double_index(FIRST_VIEW, 1)
+ {}
+
+ inline void reset(void)
+ {
+ m_index_1= FIRST_VIEW;
+ m_index_2= 1;
+ }
+
+ inline bool has_more_view(void)
+ { return (m_index_1 <= LAST_VIEW); }
+
+ inline void next_view(void)
+ {
+ m_index_1++;
+ m_index_2= 1;
+ }
+};
+
+/** Table PERFORMANCE_SCHEMA.SETUP_INSTRUMENTS. */
+class table_setup_instruments : public PFS_engine_table
+{
+public:
+ /** Table share. */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static ha_rows get_row_count();
+
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ virtual int update_row_values(TABLE *table,
+ const unsigned char *old_buf,
+ const unsigned char *new_buf,
+ Field **fields);
+
+ table_setup_instruments();
+
+public:
+ ~table_setup_instruments()
+ {}
+
+private:
+ void make_row(PFS_instr_class *klass, bool update_enabled, bool update_timed);
+
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ /** Current row. */
+ row_setup_instruments m_row;
+ /** Current position. */
+ pos_setup_instruments m_pos;
+ /** Next position. */
+ pos_setup_instruments m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_setup_objects.cc b/storage/perfschema/table_setup_objects.cc
new file mode 100644
index 00000000..cccbd64f
--- /dev/null
+++ b/storage/perfschema/table_setup_objects.cc
@@ -0,0 +1,334 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_setup_objects.cc
+ Table SETUP_OBJECTS (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "pfs_instr.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "pfs_setup_object.h"
+#include "table_setup_objects.h"
+#include "table_helper.h"
+#include "pfs_global.h"
+#include "pfs_buffer_container.h"
+#include "field.h"
+
+THR_LOCK table_setup_objects::m_table_lock;
+
+PFS_engine_table_share
+table_setup_objects::m_share=
+{
+ { C_STRING_WITH_LEN("setup_objects") },
+ &pfs_editable_acl,
+ table_setup_objects::create,
+ table_setup_objects::write_row,
+ table_setup_objects::delete_all_rows,
+ table_setup_objects::get_row_count,
+ sizeof(PFS_simple_index),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE setup_objects("
+ "OBJECT_TYPE ENUM ('EVENT','FUNCTION','PROCEDURE','TABLE','TRIGGER') not null default 'TABLE',"
+ "OBJECT_SCHEMA VARCHAR(64) default '%',"
+ "OBJECT_NAME VARCHAR(64) not null default '%',"
+ "ENABLED ENUM ('YES', 'NO') not null default 'YES',"
+ "TIMED ENUM ('YES', 'NO') not null default 'YES')") },
+ false /* perpetual */
+};
+
+int update_derived_flags()
+{
+ PFS_thread *thread= PFS_thread::get_current_thread();
+ if (unlikely(thread == NULL))
+ return HA_ERR_OUT_OF_MEM;
+
+ update_table_share_derived_flags(thread);
+ update_program_share_derived_flags(thread);
+ update_table_derived_flags();
+ return 0;
+}
+
+PFS_engine_table* table_setup_objects::create(void)
+{
+ return new table_setup_objects();
+}
+
+int table_setup_objects::write_row(TABLE *table, const unsigned char *buf,
+ Field **fields)
+{
+ int result;
+ Field *f;
+ enum_object_type object_type= OBJECT_TYPE_TABLE;
+ String object_schema_data("%", 1, &my_charset_utf8mb3_bin);
+ String object_name_data("%", 1, &my_charset_utf8mb3_bin);
+ String *object_schema= &object_schema_data;
+ String *object_name= &object_name_data;
+ enum_yes_no enabled_value= ENUM_YES;
+ enum_yes_no timed_value= ENUM_YES;
+ bool enabled= true;
+ bool timed= true;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (bitmap_is_set(table->write_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* OBJECT_TYPE */
+ object_type= (enum_object_type) get_field_enum(f);
+ break;
+ case 1: /* OBJECT_SCHEMA */
+ object_schema= get_field_varchar_utf8(f, &object_schema_data);
+ break;
+ case 2: /* OBJECT_NAME */
+ object_name= get_field_varchar_utf8(f, &object_name_data);
+ break;
+ case 3: /* ENABLED */
+ enabled_value= (enum_yes_no) get_field_enum(f);
+ break;
+ case 4: /* TIMED */
+ timed_value= (enum_yes_no) get_field_enum(f);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+
+ /* Reject illegal enum values in OBJECT_TYPE */
+ if (object_type < FIRST_OBJECT_TYPE ||
+ object_type > LAST_OBJECT_TYPE ||
+ object_type == OBJECT_TYPE_TEMPORARY_TABLE)
+ return HA_ERR_NO_REFERENCED_ROW;
+
+ /* Reject illegal enum values in ENABLED */
+ if ((enabled_value != ENUM_YES) && (enabled_value != ENUM_NO))
+ return HA_ERR_NO_REFERENCED_ROW;
+
+ /* Reject illegal enum values in TIMED */
+ if ((timed_value != ENUM_YES) && (timed_value != ENUM_NO))
+ return HA_ERR_NO_REFERENCED_ROW;
+
+ enabled= (enabled_value == ENUM_YES) ? true : false;
+ timed= (timed_value == ENUM_YES) ? true : false;
+
+ result= insert_setup_object(object_type, object_schema, object_name,
+ enabled, timed);
+ if (result == 0)
+ result= update_derived_flags();
+ return result;
+}
+
+int table_setup_objects::delete_all_rows(void)
+{
+ int result= reset_setup_object();
+ if (result == 0)
+ result= update_derived_flags();
+ return result;
+}
+
+ha_rows table_setup_objects::get_row_count(void)
+{
+ return global_setup_object_container.get_row_count();
+}
+
+table_setup_objects::table_setup_objects()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(0), m_next_pos(0)
+{}
+
+void table_setup_objects::reset_position(void)
+{
+ m_pos.m_index= 0;
+ m_next_pos.m_index= 0;
+}
+
+int table_setup_objects::rnd_next(void)
+{
+ PFS_setup_object *pfs;
+
+ m_pos.set_at(&m_next_pos);
+ PFS_setup_object_iterator it= global_setup_object_container.iterate(m_pos.m_index);
+ pfs= it.scan_next(& m_pos.m_index);
+ if (pfs != NULL)
+ {
+ make_row(pfs);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int table_setup_objects::rnd_pos(const void *pos)
+{
+ PFS_setup_object *pfs;
+
+ set_position(pos);
+
+ pfs= global_setup_object_container.get(m_pos.m_index);
+ if (pfs != NULL)
+ {
+ make_row(pfs);
+ return 0;
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_setup_objects::make_row(PFS_setup_object *pfs)
+{
+ pfs_optimistic_state lock;
+
+ m_row_exists= false;
+
+ pfs->m_lock.begin_optimistic_lock(&lock);
+
+ m_row.m_object_type= pfs->get_object_type();
+ memcpy(m_row.m_schema_name, pfs->m_schema_name, pfs->m_schema_name_length);
+ m_row.m_schema_name_length= pfs->m_schema_name_length;
+ memcpy(m_row.m_object_name, pfs->m_object_name, pfs->m_object_name_length);
+ m_row.m_object_name_length= pfs->m_object_name_length;
+ m_row.m_enabled_ptr= &pfs->m_enabled;
+ m_row.m_timed_ptr= &pfs->m_timed;
+
+ if (pfs->m_lock.end_optimistic_lock(&lock))
+ m_row_exists= true;
+}
+
+int table_setup_objects::read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* OBJECT_TYPE */
+ set_field_enum(f, m_row.m_object_type);
+ break;
+ case 1: /* OBJECT_SCHEMA */
+ if (m_row.m_schema_name_length)
+ set_field_varchar_utf8(f, m_row.m_schema_name,
+ m_row.m_schema_name_length);
+ else
+ f->set_null();
+ break;
+ case 2: /* OBJECT_NAME */
+ if (m_row.m_object_name_length)
+ set_field_varchar_utf8(f, m_row.m_object_name,
+ m_row.m_object_name_length);
+ else
+ f->set_null();
+ break;
+ case 3: /* ENABLED */
+ set_field_enum(f, (*m_row.m_enabled_ptr) ? ENUM_YES : ENUM_NO);
+ break;
+ case 4: /* TIMED */
+ set_field_enum(f, (*m_row.m_timed_ptr) ? ENUM_YES : ENUM_NO);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+
+ return 0;
+}
+
+int table_setup_objects::update_row_values(TABLE *table,
+ const unsigned char *,
+ const unsigned char *,
+ Field **fields)
+{
+ int result;
+ Field *f;
+ enum_yes_no value;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (bitmap_is_set(table->write_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* OBJECT_TYPE */
+ case 1: /* OBJECT_SCHEMA */
+ case 2: /* OBJECT_NAME */
+ return HA_ERR_WRONG_COMMAND;
+ case 3: /* ENABLED */
+ value= (enum_yes_no) get_field_enum(f);
+ /* Reject illegal enum values in ENABLED */
+ if ((value != ENUM_YES) && (value != ENUM_NO))
+ return HA_ERR_NO_REFERENCED_ROW;
+ *m_row.m_enabled_ptr= (value == ENUM_YES) ? true : false;
+ break;
+ case 4: /* TIMED */
+ value= (enum_yes_no) get_field_enum(f);
+ /* Reject illegal enum values in TIMED */
+ if ((value != ENUM_YES) && (value != ENUM_NO))
+ return HA_ERR_NO_REFERENCED_ROW;
+ *m_row.m_timed_ptr= (value == ENUM_YES) ? true : false;
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+
+ result= update_derived_flags();
+ return result;
+}
+
+int table_setup_objects::delete_row_values(TABLE *table,
+ const unsigned char *buf,
+ Field **fields)
+{
+ DBUG_ASSERT(m_row_exists);
+
+ CHARSET_INFO *cs= &my_charset_utf8mb3_bin;
+ enum_object_type object_type= OBJECT_TYPE_TABLE;
+ String object_schema(m_row.m_schema_name, m_row.m_schema_name_length, cs);
+ String object_name(m_row.m_object_name, m_row.m_object_name_length, cs);
+
+ int result= delete_setup_object(object_type, &object_schema, &object_name);
+
+ if (result == 0)
+ result= update_derived_flags();
+ return result;
+}
+
diff --git a/storage/perfschema/table_setup_objects.h b/storage/perfschema/table_setup_objects.h
new file mode 100644
index 00000000..abe36f73
--- /dev/null
+++ b/storage/perfschema/table_setup_objects.h
@@ -0,0 +1,114 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_SETUP_OBJECTS_H
+#define TABLE_SETUP_OBJECTS_H
+
+/**
+ @file storage/perfschema/table_setup_objects.h
+ Table SETUP_OBJECTS (declarations).
+*/
+
+#include "pfs_engine_table.h"
+#include "table_helper.h"
+
+struct PFS_setup_object;
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/** A row of PERFORMANCE_SCHEMA.SETUP_OBJECTS. */
+struct row_setup_objects
+{
+ /** Column OBJECT_TYPE. */
+ enum_object_type m_object_type;
+ /** Column SCHEMA_NAME. */
+ char m_schema_name[NAME_LEN];
+ /** Length in bytes of @c m_schema_name. */
+ uint m_schema_name_length;
+ /** Column OBJECT_NAME. */
+ char m_object_name[NAME_LEN];
+ /** Length in bytes of @c m_object_name. */
+ uint m_object_name_length;
+ /** Column ENABLED. */
+ bool *m_enabled_ptr;
+ /** Column TIMED. */
+ bool *m_timed_ptr;
+};
+
+/** Table PERFORMANCE_SCHEMA.SETUP_OBJECTS. */
+class table_setup_objects : public PFS_engine_table
+{
+public:
+ /** Table share. */
+ static PFS_engine_table_share m_share;
+ /** Table builder. */
+ static PFS_engine_table* create();
+ static int write_row(TABLE *table, const unsigned char *buf, Field **fields);
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ virtual int update_row_values(TABLE *table,
+ const unsigned char *old_buf,
+ const unsigned char *new_buf,
+ Field **fields);
+
+ virtual int delete_row_values(TABLE *table,
+ const unsigned char *buf,
+ Field **fields);
+
+ table_setup_objects();
+
+public:
+ ~table_setup_objects()
+ {}
+
+private:
+ void make_row(PFS_setup_object *pfs);
+
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ /** Current row. */
+ row_setup_objects m_row;
+ /** True is the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ PFS_simple_index m_pos;
+ /** Next position. */
+ PFS_simple_index m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_setup_timers.cc b/storage/perfschema/table_setup_timers.cc
new file mode 100644
index 00000000..d5656ea2
--- /dev/null
+++ b/storage/perfschema/table_setup_timers.cc
@@ -0,0 +1,205 @@
+/* Copyright (c) 2008, 2017, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_setup_timers.cc
+ Table SETUP_TIMERS (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "table_setup_timers.h"
+#include "pfs_column_values.h"
+#include "pfs_timer.h"
+#include "field.h"
+#include "derror.h" /* ER_THD */
+
+#define COUNT_SETUP_TIMERS 5
+
+static row_setup_timers all_setup_timers_data[COUNT_SETUP_TIMERS]=
+{
+ {
+ { C_STRING_WITH_LEN("idle") },
+ &idle_timer
+ },
+ {
+ { C_STRING_WITH_LEN("wait") },
+ &wait_timer
+ },
+ {
+ { C_STRING_WITH_LEN("stage") },
+ &stage_timer
+ },
+ {
+ { C_STRING_WITH_LEN("statement") },
+ &statement_timer
+ },
+ {
+ { C_STRING_WITH_LEN("transaction") },
+ &transaction_timer
+ }
+};
+
+THR_LOCK table_setup_timers::m_table_lock;
+
+PFS_engine_table_share
+table_setup_timers::m_share=
+{
+ { C_STRING_WITH_LEN("setup_timers") },
+ &pfs_updatable_acl,
+ table_setup_timers::create,
+ NULL, /* write_row */
+ NULL, /* delete_all_rows */
+ table_setup_timers::get_row_count,
+ sizeof(PFS_simple_index),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE setup_timers("
+ "NAME VARCHAR(64) not null,"
+ "TIMER_NAME ENUM ('CYCLE', 'NANOSECOND', 'MICROSECOND', 'MILLISECOND', 'TICK') not null)") },
+ false /* perpetual */
+};
+
+PFS_engine_table* table_setup_timers::create(void)
+{
+ THD *thd = current_thd;
+ push_warning_printf(thd,
+ Sql_condition::WARN_LEVEL_WARN,
+ ER_WARN_DEPRECATED_SYNTAX_NO_REPLACEMENT,
+ ER_THD(thd, ER_WARN_DEPRECATED_SYNTAX_NO_REPLACEMENT),
+ "performance_schema.setup_timers");
+
+ return new table_setup_timers();
+}
+
+ha_rows
+table_setup_timers::get_row_count(void)
+{
+ return COUNT_SETUP_TIMERS;
+}
+
+table_setup_timers::table_setup_timers()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row(NULL), m_pos(0), m_next_pos(0)
+{}
+
+void table_setup_timers::reset_position(void)
+{
+ m_pos.m_index= 0;
+ m_next_pos.m_index= 0;
+}
+
+int table_setup_timers::rnd_next(void)
+{
+ int result;
+
+ m_pos.set_at(&m_next_pos);
+
+ if (m_pos.m_index < COUNT_SETUP_TIMERS)
+ {
+ m_row= &all_setup_timers_data[m_pos.m_index];
+ m_next_pos.set_after(&m_pos);
+ result= 0;
+ }
+ else
+ {
+ m_row= NULL;
+ result= HA_ERR_END_OF_FILE;
+ }
+
+ return result;
+}
+
+int table_setup_timers::rnd_pos(const void *pos)
+{
+ set_position(pos);
+ DBUG_ASSERT(m_pos.m_index < COUNT_SETUP_TIMERS);
+ m_row= &all_setup_timers_data[m_pos.m_index];
+ return 0;
+}
+
+int table_setup_timers::read_row_values(TABLE *table,
+ unsigned char *,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ DBUG_ASSERT(m_row);
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 0);
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* NAME */
+ set_field_varchar_utf8(f, m_row->m_name.str,(uint) m_row->m_name.length);
+ break;
+ case 1: /* TIMER_NAME */
+ set_field_enum(f, *(m_row->m_timer_name_ptr));
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+
+ return 0;
+}
+
+int table_setup_timers::update_row_values(TABLE *table,
+ const unsigned char *,
+ const unsigned char *,
+ Field **fields)
+{
+ Field *f;
+ longlong value;
+
+ DBUG_ASSERT(m_row);
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (bitmap_is_set(table->write_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* NAME */
+ return HA_ERR_WRONG_COMMAND;
+ case 1: /* TIMER_NAME */
+ value= get_field_enum(f);
+ if ((value >= FIRST_TIMER_NAME) && (value <= LAST_TIMER_NAME))
+ *(m_row->m_timer_name_ptr)= (enum_timer_name) value;
+ else
+ return HA_ERR_WRONG_COMMAND;
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_setup_timers.h b/storage/perfschema/table_setup_timers.h
new file mode 100644
index 00000000..43100bf3
--- /dev/null
+++ b/storage/perfschema/table_setup_timers.h
@@ -0,0 +1,91 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_SETUP_TIMERS_H
+#define TABLE_SETUP_TIMERS_H
+
+/**
+ @file storage/perfschema/table_setup_timers.h
+ Table SETUP_TIMERS (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/** A row of table PERFORMANCE_SCHEMA.SETUP_TIMERS. */
+struct row_setup_timers
+{
+ /** Column NAME. */
+ LEX_STRING m_name;
+ /** Column TIMER_NAME. */
+ enum_timer_name *m_timer_name_ptr;
+};
+
+/** Table PERFORMANCE_SCHEMA.SETUP_TIMERS. */
+class table_setup_timers : public PFS_engine_table
+{
+public:
+ /** Table share. */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static ha_rows get_row_count();
+
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ virtual int update_row_values(TABLE *table,
+ const unsigned char *old_buf,
+ const unsigned char *new_buf,
+ Field **fields);
+
+ table_setup_timers();
+
+public:
+ ~table_setup_timers()
+ {}
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ /** Current row. */
+ row_setup_timers *m_row;
+ /** Current position. */
+ PFS_simple_index m_pos;
+ /** Next position. */
+ PFS_simple_index m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_socket_instances.cc b/storage/perfschema/table_socket_instances.cc
new file mode 100644
index 00000000..24c9b0d0
--- /dev/null
+++ b/storage/perfschema/table_socket_instances.cc
@@ -0,0 +1,208 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_socket_instances.cc
+ Table SOCKET_INSTANCES (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "pfs_instr.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "table_socket_instances.h"
+#include "pfs_global.h"
+#include "pfs_buffer_container.h"
+#include "field.h"
+
+THR_LOCK table_socket_instances::m_table_lock;
+
+PFS_engine_table_share
+table_socket_instances::m_share=
+{
+ { C_STRING_WITH_LEN("socket_instances") },
+ &pfs_readonly_acl,
+ table_socket_instances::create,
+ NULL, /* write_row */
+ NULL, /* delete_all_rows */
+ table_socket_instances::get_row_count,
+ sizeof(PFS_simple_index),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE socket_instances("
+ "EVENT_NAME VARCHAR(128) not null,"
+ "OBJECT_INSTANCE_BEGIN BIGINT unsigned not null,"
+ "THREAD_ID BIGINT unsigned,"
+ "SOCKET_ID INTEGER not null,"
+ "IP VARCHAR(64) not null,"
+ "PORT INTEGER not null,"
+ "STATE ENUM('IDLE','ACTIVE') not null)") },
+ false /* perpetual */
+};
+
+PFS_engine_table* table_socket_instances::create(void)
+{
+ return new table_socket_instances();
+}
+
+ha_rows
+table_socket_instances::get_row_count(void)
+{
+ return global_socket_container.get_row_count();
+}
+
+table_socket_instances::table_socket_instances()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(0), m_next_pos(0)
+{}
+
+void table_socket_instances::reset_position(void)
+{
+ m_pos.m_index= 0;
+ m_next_pos.m_index= 0;
+}
+
+int table_socket_instances::rnd_next(void)
+{
+ PFS_socket *pfs;
+
+ m_pos.set_at(&m_next_pos);
+ PFS_socket_iterator it= global_socket_container.iterate(m_pos.m_index);
+ pfs= it.scan_next(& m_pos.m_index);
+ if (pfs != NULL)
+ {
+ make_row(pfs);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int table_socket_instances::rnd_pos(const void *pos)
+{
+ PFS_socket *pfs;
+
+ set_position(pos);
+
+ pfs= global_socket_container.get(m_pos.m_index);
+ if (pfs != NULL)
+ {
+ make_row(pfs);
+ return 0;
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_socket_instances::make_row(PFS_socket *pfs)
+{
+ pfs_optimistic_state lock;
+ PFS_socket_class *safe_class;
+
+ m_row_exists= false;
+
+ /* Protect this reader against a socket delete */
+ pfs->m_lock.begin_optimistic_lock(&lock);
+
+ safe_class= sanitize_socket_class(pfs->m_class);
+ if (unlikely(safe_class == NULL))
+ return;
+
+ /** Extract ip address and port from raw address */
+ m_row.m_ip_length= pfs_get_socket_address(m_row.m_ip, sizeof(m_row.m_ip),
+ &m_row.m_port,
+ &pfs->m_sock_addr, pfs->m_addr_len);
+ m_row.m_event_name= safe_class->m_name;
+ m_row.m_event_name_length= safe_class->m_name_length;
+ m_row.m_identity= pfs->m_identity;
+ m_row.m_fd= pfs->m_fd;
+ m_row.m_state= (pfs->m_idle ? PSI_SOCKET_STATE_IDLE
+ : PSI_SOCKET_STATE_ACTIVE);
+ PFS_thread *safe_thread= sanitize_thread(pfs->m_thread_owner);
+
+ if (safe_thread != NULL)
+ {
+ m_row.m_thread_id= safe_thread->m_thread_internal_id;
+ m_row.m_thread_id_set= true;
+ }
+ else
+ m_row.m_thread_id_set= false;
+
+
+ if (pfs->m_lock.end_optimistic_lock(&lock))
+ m_row_exists= true;
+}
+
+int table_socket_instances::read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(!m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* EVENT_NAME */
+ set_field_varchar_utf8(f, m_row.m_event_name, m_row.m_event_name_length);
+ break;
+ case 1: /* OBJECT_INSTANCE_BEGIN */
+ set_field_ulonglong(f, (intptr)m_row.m_identity);
+ break;
+ case 2: /* THREAD_ID */
+ if (m_row.m_thread_id_set)
+ set_field_ulonglong(f, m_row.m_thread_id);
+ else
+ f->set_null();
+ break;
+ case 3: /* SOCKET_ID */
+ set_field_ulong(f, m_row.m_fd);
+ break;
+ case 4: /* IP */
+ set_field_varchar_utf8(f, m_row.m_ip, m_row.m_ip_length);
+ break;
+ case 5: /* PORT */
+ set_field_ulong(f, m_row.m_port);
+ break;
+ case 6: /* STATE */
+ set_field_enum(f, m_row.m_state);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_socket_instances.h b/storage/perfschema/table_socket_instances.h
new file mode 100644
index 00000000..4e32bbdc
--- /dev/null
+++ b/storage/perfschema/table_socket_instances.h
@@ -0,0 +1,108 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_SOCKET_INSTANCES_H
+#define TABLE_SOCKET_INSTANCES_H
+
+/**
+ @file storage/perfschema/table_socket_instances.h
+ Table SOCKET_INSTANCES (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/** A row of PERFORMANCE_SCHEMA.SOCKET_INSTANCES. */
+struct row_socket_instances
+{
+ /** Column EVENT_NAME. */
+ const char *m_event_name;
+ /** Length in bytes of @c m_event_name. */
+ uint m_event_name_length;
+ /** Column OBJECT_INSTANCE_BEGIN */
+ const void *m_identity;
+ /** Column THREAD_ID */
+ ulonglong m_thread_id;
+ /** True if thread_is is set */
+ bool m_thread_id_set;
+ /** Column SOCKET_ID */
+ uint m_fd;
+ /** Socket ip address, IPV4 or IPV6 */
+ char m_ip[INET6_ADDRSTRLEN+1];
+ /** Length in bytes of @c m_ip. */
+ uint m_ip_length;
+ /** Column PORT */
+ uint m_port;
+ /** Socket state: ACTIVE or IDLE */
+ PSI_socket_state m_state;
+
+ row_socket_instances() {m_thread_id_set= false;}
+};
+
+/** Table PERFORMANCE_SCHEMA.SOCKET_INSTANCES. */
+class table_socket_instances : public PFS_engine_table
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static ha_rows get_row_count();
+
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+private:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_socket_instances();
+
+public:
+ ~table_socket_instances()
+ {}
+
+private:
+ void make_row(PFS_socket *pfs);
+
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ /** Current row. */
+ row_socket_instances m_row;
+ /** True if the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ PFS_simple_index m_pos;
+ /** Next position. */
+ PFS_simple_index m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_socket_summary_by_event_name.cc b/storage/perfschema/table_socket_summary_by_event_name.cc
new file mode 100644
index 00000000..bdfff756
--- /dev/null
+++ b/storage/perfschema/table_socket_summary_by_event_name.cc
@@ -0,0 +1,255 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_socket_summary_by_event_name.cc
+ Table SOCKET_EVENT_NAMES (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "pfs_instr.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "table_socket_summary_by_event_name.h"
+#include "pfs_global.h"
+#include "pfs_visitor.h"
+#include "field.h"
+
+THR_LOCK table_socket_summary_by_event_name::m_table_lock;
+
+PFS_engine_table_share
+table_socket_summary_by_event_name::m_share=
+{
+ { C_STRING_WITH_LEN("socket_summary_by_event_name") },
+ &pfs_readonly_acl,
+ table_socket_summary_by_event_name::create,
+ NULL, /* write_row */
+ table_socket_summary_by_event_name::delete_all_rows,
+ table_socket_summary_by_event_name::get_row_count,
+ sizeof(PFS_simple_index),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE socket_summary_by_event_name("
+ "EVENT_NAME VARCHAR(128) not null,"
+ "COUNT_STAR BIGINT unsigned not null,"
+ "SUM_TIMER_WAIT BIGINT unsigned not null,"
+ "MIN_TIMER_WAIT BIGINT unsigned not null,"
+ "AVG_TIMER_WAIT BIGINT unsigned not null,"
+ "MAX_TIMER_WAIT BIGINT unsigned not null,"
+ "COUNT_READ BIGINT unsigned not null,"
+ "SUM_TIMER_READ BIGINT unsigned not null,"
+ "MIN_TIMER_READ BIGINT unsigned not null,"
+ "AVG_TIMER_READ BIGINT unsigned not null,"
+ "MAX_TIMER_READ BIGINT unsigned not null,"
+ "SUM_NUMBER_OF_BYTES_READ BIGINT unsigned not null,"
+ "COUNT_WRITE BIGINT unsigned not null,"
+ "SUM_TIMER_WRITE BIGINT unsigned not null,"
+ "MIN_TIMER_WRITE BIGINT unsigned not null,"
+ "AVG_TIMER_WRITE BIGINT unsigned not null,"
+ "MAX_TIMER_WRITE BIGINT unsigned not null,"
+ "SUM_NUMBER_OF_BYTES_WRITE BIGINT unsigned not null,"
+ "COUNT_MISC BIGINT unsigned not null,"
+ "SUM_TIMER_MISC BIGINT unsigned not null,"
+ "MIN_TIMER_MISC BIGINT unsigned not null,"
+ "AVG_TIMER_MISC BIGINT unsigned not null,"
+ "MAX_TIMER_MISC BIGINT unsigned not null)") },
+ false /* perpetual */
+};
+
+PFS_engine_table* table_socket_summary_by_event_name::create(void)
+{
+ return new table_socket_summary_by_event_name();
+}
+
+table_socket_summary_by_event_name::table_socket_summary_by_event_name()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(1), m_next_pos(1)
+{}
+
+int table_socket_summary_by_event_name::delete_all_rows(void)
+{
+ reset_socket_instance_io();
+ reset_socket_class_io();
+ return 0;
+}
+
+ha_rows
+table_socket_summary_by_event_name::get_row_count(void)
+{
+ return socket_class_max;
+}
+
+void table_socket_summary_by_event_name::reset_position(void)
+{
+ m_pos.m_index= 1;
+ m_next_pos.m_index= 1;
+}
+
+int table_socket_summary_by_event_name::rnd_next(void)
+{
+ PFS_socket_class *socket_class;
+
+ m_pos.set_at(&m_next_pos);
+
+ socket_class= find_socket_class(m_pos.m_index);
+ if (socket_class)
+ {
+ make_row(socket_class);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int table_socket_summary_by_event_name::rnd_pos(const void *pos)
+{
+ PFS_socket_class *socket_class;
+
+ set_position(pos);
+
+ socket_class= find_socket_class(m_pos.m_index);
+ if (socket_class)
+ {
+ make_row(socket_class);
+ return 0;
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_socket_summary_by_event_name::make_row(PFS_socket_class *socket_class)
+{
+ m_row.m_event_name.make_row(socket_class);
+
+ PFS_instance_socket_io_stat_visitor visitor;
+ PFS_instance_iterator::visit_socket_instances(socket_class, &visitor);
+
+ time_normalizer *normalizer= time_normalizer::get(wait_timer);
+
+ /* Collect timer and byte count stats */
+ m_row.m_io_stat.set(normalizer, &visitor.m_socket_io_stat);
+ m_row_exists= true;
+}
+
+int table_socket_summary_by_event_name::read_row_values(TABLE *table,
+ unsigned char *,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(!m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 0);
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* EVENT_NAME */
+ m_row.m_event_name.set_field(f);
+ break;
+ case 1: /* COUNT_STAR */
+ set_field_ulonglong(f, m_row.m_io_stat.m_all.m_waits.m_count);
+ break;
+ case 2: /* SUM_TIMER_WAIT */
+ set_field_ulonglong(f, m_row.m_io_stat.m_all.m_waits.m_sum);
+ break;
+ case 3: /* MIN_TIMER_WAIT */
+ set_field_ulonglong(f, m_row.m_io_stat.m_all.m_waits.m_min);
+ break;
+ case 4: /* AVG_TIMER_WAIT */
+ set_field_ulonglong(f, m_row.m_io_stat.m_all.m_waits.m_avg);
+ break;
+ case 5: /* MAX_TIMER_WAIT */
+ set_field_ulonglong(f, m_row.m_io_stat.m_all.m_waits.m_max);
+ break;
+
+ case 6: /* COUNT_READ */
+ set_field_ulonglong(f, m_row.m_io_stat.m_read.m_waits.m_count);
+ break;
+ case 7: /* SUM_TIMER_READ */
+ set_field_ulonglong(f, m_row.m_io_stat.m_read.m_waits.m_sum);
+ break;
+ case 8: /* MIN_TIMER_READ */
+ set_field_ulonglong(f, m_row.m_io_stat.m_read.m_waits.m_min);
+ break;
+ case 9: /* AVG_TIMER_READ */
+ set_field_ulonglong(f, m_row.m_io_stat.m_read.m_waits.m_avg);
+ break;
+ case 10: /* MAX_TIMER_READ */
+ set_field_ulonglong(f, m_row.m_io_stat.m_read.m_waits.m_max);
+ break;
+ case 11: /* SUM_NUMBER_OF_BYTES_READ */
+ set_field_ulonglong(f, m_row.m_io_stat.m_read.m_bytes);
+ break;
+
+ case 12: /* COUNT_WRITE */
+ set_field_ulonglong(f, m_row.m_io_stat.m_write.m_waits.m_count);
+ break;
+ case 13: /* SUM_TIMER_WRITE */
+ set_field_ulonglong(f, m_row.m_io_stat.m_write.m_waits.m_sum);
+ break;
+ case 14: /* MIN_TIMER_WRITE */
+ set_field_ulonglong(f, m_row.m_io_stat.m_write.m_waits.m_min);
+ break;
+ case 15: /* AVG_TIMER_WRITE */
+ set_field_ulonglong(f, m_row.m_io_stat.m_write.m_waits.m_avg);
+ break;
+ case 16: /* MAX_TIMER_WRITE */
+ set_field_ulonglong(f, m_row.m_io_stat.m_write.m_waits.m_max);
+ break;
+ case 17: /* SUM_NUMBER_OF_BYTES_WRITE */
+ set_field_ulonglong(f, m_row.m_io_stat.m_write.m_bytes);
+ break;
+
+ case 18: /* COUNT_MISC */
+ set_field_ulonglong(f, m_row.m_io_stat.m_misc.m_waits.m_count);
+ break;
+ case 19: /* SUM_TIMER_MISC */
+ set_field_ulonglong(f, m_row.m_io_stat.m_misc.m_waits.m_sum);
+ break;
+ case 20: /* MIN_TIMER_MISC */
+ set_field_ulonglong(f, m_row.m_io_stat.m_misc.m_waits.m_min);
+ break;
+ case 21: /* AVG_TIMER_MISC */
+ set_field_ulonglong(f, m_row.m_io_stat.m_misc.m_waits.m_avg);
+ break;
+ case 22: /* MAX_TIMER_MISC */
+ set_field_ulonglong(f, m_row.m_io_stat.m_misc.m_waits.m_max);
+ break;
+
+ default:
+ DBUG_ASSERT(false);
+ break;
+ }
+ } // if
+ } // for
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_socket_summary_by_event_name.h b/storage/perfschema/table_socket_summary_by_event_name.h
new file mode 100644
index 00000000..e25d38b9
--- /dev/null
+++ b/storage/perfschema/table_socket_summary_by_event_name.h
@@ -0,0 +1,98 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_SOCKET_SUMMARY_BY_EVENT_NAME_H
+#define TABLE_SOCKET_SUMMARY_BY_EVENT_NAME_H
+
+/**
+ @file storage/perfschema/table_socket_summary_by_event_name.h
+ Table SOCKET_SUMMARY_BY_EVENT_NAME (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "table_helper.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/**
+ A row of table
+ PERFORMANCE_SCHEMA.SOCKET_SUMMARY_BY_EVENT_NAME.
+*/
+struct row_socket_summary_by_event_name
+{
+ /** Column EVENT_NAME. */
+ PFS_event_name_row m_event_name;
+
+ /** Columns COUNT_STAR, SUM/MIN/AVG/MAX TIMER and NUMBER_OF_BYTES for each operation. */
+ PFS_socket_io_stat_row m_io_stat;
+};
+
+/** Table PERFORMANCE_SCHEMA.SOCKET_SUMMARY_BY_EVENT_NAME. */
+class table_socket_summary_by_event_name : public PFS_engine_table
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+private:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_socket_summary_by_event_name();
+
+public:
+ ~table_socket_summary_by_event_name()
+ {}
+
+private:
+ void make_row(PFS_socket_class *socket_class);
+
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ /** Current row. */
+ row_socket_summary_by_event_name m_row;
+ /** True if the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ PFS_simple_index m_pos;
+ /** Next position. */
+ PFS_simple_index m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_socket_summary_by_instance.cc b/storage/perfschema/table_socket_summary_by_instance.cc
new file mode 100644
index 00000000..372cde61
--- /dev/null
+++ b/storage/perfschema/table_socket_summary_by_instance.cc
@@ -0,0 +1,271 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_socket_summary_by_instance.cc
+ Table SOCKET_SUMMARY_BY_INSTANCE (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "pfs_instr.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "table_socket_summary_by_instance.h"
+#include "pfs_global.h"
+#include "pfs_buffer_container.h"
+#include "field.h"
+
+THR_LOCK table_socket_summary_by_instance::m_table_lock;
+
+PFS_engine_table_share
+table_socket_summary_by_instance::m_share=
+{
+ { C_STRING_WITH_LEN("socket_summary_by_instance") },
+ &pfs_readonly_acl,
+ table_socket_summary_by_instance::create,
+ NULL, /* write_row */
+ table_socket_summary_by_instance::delete_all_rows,
+ table_socket_summary_by_instance::get_row_count,
+ sizeof(PFS_simple_index),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE socket_summary_by_instance("
+ "EVENT_NAME VARCHAR(128) not null,"
+ "OBJECT_INSTANCE_BEGIN BIGINT unsigned not null,"
+ "COUNT_STAR BIGINT unsigned not null,"
+ "SUM_TIMER_WAIT BIGINT unsigned not null,"
+ "MIN_TIMER_WAIT BIGINT unsigned not null,"
+ "AVG_TIMER_WAIT BIGINT unsigned not null,"
+ "MAX_TIMER_WAIT BIGINT unsigned not null,"
+ "COUNT_READ BIGINT unsigned not null,"
+ "SUM_TIMER_READ BIGINT unsigned not null,"
+ "MIN_TIMER_READ BIGINT unsigned not null,"
+ "AVG_TIMER_READ BIGINT unsigned not null,"
+ "MAX_TIMER_READ BIGINT unsigned not null,"
+ "SUM_NUMBER_OF_BYTES_READ BIGINT unsigned not null,"
+ "COUNT_WRITE BIGINT unsigned not null,"
+ "SUM_TIMER_WRITE BIGINT unsigned not null,"
+ "MIN_TIMER_WRITE BIGINT unsigned not null,"
+ "AVG_TIMER_WRITE BIGINT unsigned not null,"
+ "MAX_TIMER_WRITE BIGINT unsigned not null,"
+ "SUM_NUMBER_OF_BYTES_WRITE BIGINT unsigned not null,"
+ "COUNT_MISC BIGINT unsigned not null,"
+ "SUM_TIMER_MISC BIGINT unsigned not null,"
+ "MIN_TIMER_MISC BIGINT unsigned not null,"
+ "AVG_TIMER_MISC BIGINT unsigned not null,"
+ "MAX_TIMER_MISC BIGINT unsigned not null)") },
+ false /* perpetual */
+};
+
+PFS_engine_table* table_socket_summary_by_instance::create(void)
+{
+ return new table_socket_summary_by_instance();
+}
+
+table_socket_summary_by_instance::table_socket_summary_by_instance()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(0), m_next_pos(0)
+{}
+
+int table_socket_summary_by_instance::delete_all_rows(void)
+{
+ reset_socket_instance_io();
+ return 0;
+}
+
+ha_rows
+table_socket_summary_by_instance::get_row_count(void)
+{
+ return global_socket_container.get_row_count();
+}
+
+void table_socket_summary_by_instance::reset_position(void)
+{
+ m_pos.m_index= 0;
+ m_next_pos.m_index= 0;
+}
+
+int table_socket_summary_by_instance::rnd_next(void)
+{
+ PFS_socket *pfs;
+
+ m_pos.set_at(&m_next_pos);
+ PFS_socket_iterator it= global_socket_container.iterate(m_pos.m_index);
+ pfs= it.scan_next(& m_pos.m_index);
+ if (pfs != NULL)
+ {
+ make_row(pfs);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int table_socket_summary_by_instance::rnd_pos(const void *pos)
+{
+ PFS_socket *pfs;
+
+ set_position(pos);
+
+ pfs= global_socket_container.get(m_pos.m_index);
+ if (pfs != NULL)
+ {
+ make_row(pfs);
+ return 0;
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_socket_summary_by_instance::make_row(PFS_socket *pfs)
+{
+ pfs_optimistic_state lock;
+ PFS_socket_class *safe_class;
+
+ m_row_exists= false;
+
+ /* Protect this reader against a socket delete */
+ pfs->m_lock.begin_optimistic_lock(&lock);
+
+ safe_class= sanitize_socket_class(pfs->m_class);
+ if (unlikely(safe_class == NULL))
+ return;
+
+ m_row.m_event_name.make_row(safe_class);
+ m_row.m_identity= pfs->m_identity;
+
+ time_normalizer *normalizer= time_normalizer::get(wait_timer);
+
+ /* Collect timer and byte count stats */
+ m_row.m_io_stat.set(normalizer, &pfs->m_socket_stat.m_io_stat);
+
+ if (!pfs->m_lock.end_optimistic_lock(&lock))
+ return;
+
+ m_row_exists= true;
+}
+
+int table_socket_summary_by_instance::read_row_values(TABLE *table,
+ unsigned char *,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(!m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 0);
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* EVENT_NAME */
+ m_row.m_event_name.set_field(f);
+ break;
+ case 1: /* OBJECT_INSTANCE */
+ set_field_ulonglong(f, (intptr)m_row.m_identity);
+ break;
+
+ case 2:/* COUNT_STAR */
+ set_field_ulonglong(f, m_row.m_io_stat.m_all.m_waits.m_count);
+ break;
+ case 3:/* SUM_TIMER_WAIT */
+ set_field_ulonglong(f, m_row.m_io_stat.m_all.m_waits.m_sum);
+ break;
+ case 4: /* MIN_TIMER_WAIT */
+ set_field_ulonglong(f, m_row.m_io_stat.m_all.m_waits.m_min);
+ break;
+ case 5: /* AVG_TIMER_WAIT */
+ set_field_ulonglong(f, m_row.m_io_stat.m_all.m_waits.m_avg);
+ break;
+ case 6: /* MAX_TIMER_WAIT */
+ set_field_ulonglong(f, m_row.m_io_stat.m_all.m_waits.m_max);
+ break;
+
+ case 7: /* COUNT_READ */
+ set_field_ulonglong(f, m_row.m_io_stat.m_read.m_waits.m_count);
+ break;
+ case 8: /* SUM_TIMER_READ */
+ set_field_ulonglong(f, m_row.m_io_stat.m_read.m_waits.m_sum);
+ break;
+ case 9: /* MIN_TIMER_READ */
+ set_field_ulonglong(f, m_row.m_io_stat.m_read.m_waits.m_min);
+ break;
+ case 10: /* AVG_TIMER_READ */
+ set_field_ulonglong(f, m_row.m_io_stat.m_read.m_waits.m_avg);
+ break;
+ case 11: /* MAX_TIMER_READ */
+ set_field_ulonglong(f, m_row.m_io_stat.m_read.m_waits.m_max);
+ break;
+ case 12: /* SUM_NUMBER_OF_BYTES_READ */
+ set_field_ulonglong(f, m_row.m_io_stat.m_read.m_bytes);
+ break;
+
+ case 13: /* COUNT_WRITE */
+ set_field_ulonglong(f, m_row.m_io_stat.m_write.m_waits.m_count);
+ break;
+ case 14: /* SUM_TIMER_WRITE */
+ set_field_ulonglong(f, m_row.m_io_stat.m_write.m_waits.m_sum);
+ break;
+ case 15: /* MIN_TIMER_WRITE */
+ set_field_ulonglong(f, m_row.m_io_stat.m_write.m_waits.m_min);
+ break;
+ case 16: /* AVG_TIMER_WRITE */
+ set_field_ulonglong(f, m_row.m_io_stat.m_write.m_waits.m_avg);
+ break;
+ case 17: /* MAX_TIMER_WRITE */
+ set_field_ulonglong(f, m_row.m_io_stat.m_write.m_waits.m_max);
+ break;
+ case 18: /* SUM_NUMBER_OF_BYTES_WRITE */
+ set_field_ulonglong(f, m_row.m_io_stat.m_write.m_bytes);
+ break;
+
+ case 19: /* COUNT_MISC */
+ set_field_ulonglong(f, m_row.m_io_stat.m_misc.m_waits.m_count);
+ break;
+ case 20: /* SUM_TIMER_MISC */
+ set_field_ulonglong(f, m_row.m_io_stat.m_misc.m_waits.m_sum);
+ break;
+ case 21: /* MIN_TIMER_MISC */
+ set_field_ulonglong(f, m_row.m_io_stat.m_misc.m_waits.m_min);
+ break;
+ case 22: /* AVG_TIMER_MISC */
+ set_field_ulonglong(f, m_row.m_io_stat.m_misc.m_waits.m_avg);
+ break;
+ case 23: /* MAX_TIMER_MISC */
+ set_field_ulonglong(f, m_row.m_io_stat.m_misc.m_waits.m_max);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ break;
+ }
+ }
+ }
+
+ return 0;
+}
diff --git a/storage/perfschema/table_socket_summary_by_instance.h b/storage/perfschema/table_socket_summary_by_instance.h
new file mode 100644
index 00000000..3f6d1295
--- /dev/null
+++ b/storage/perfschema/table_socket_summary_by_instance.h
@@ -0,0 +1,101 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_SOCKET_SUMMARY_BY_INSTANCE_H
+#define TABLE_SOCKET_SUMMARY_BY_INSTANCE_H
+
+/**
+ @file storage/perfschema/table_socket_summary_by_instance.h
+ Table SOCKET_SUMMARY_BY_INSTANCE (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "table_helper.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/**
+ A row of table
+ PERFORMANCE_SCHEMA.SOCKET_SUMMARY_BY_INSTANCE.
+*/
+struct row_socket_summary_by_instance
+{
+ /** Column EVENT_NAME. */
+ PFS_event_name_row m_event_name;
+
+ /** Column OBJECT_INSTANCE_BEGIN */
+ const void *m_identity;
+
+ /** Columns COUNT_STAR, SUM/MIN/AVG/MAX TIMER and NUMBER_OF_BYTES for each operation. */
+ PFS_socket_io_stat_row m_io_stat;
+};
+
+/** Table PERFORMANCE_SCHEMA.SOCKET_SUMMARY_BY_INSTANCE. */
+class table_socket_summary_by_instance : public PFS_engine_table
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+private:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_socket_summary_by_instance();
+
+public:
+ ~table_socket_summary_by_instance()
+ {}
+
+private:
+ void make_row(PFS_socket *pfs);
+
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ /** Current row. */
+ row_socket_summary_by_instance m_row;
+ /** True if the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ PFS_simple_index m_pos;
+ /** Next position. */
+ PFS_simple_index m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_status_by_account.cc b/storage/perfschema/table_status_by_account.cc
new file mode 100644
index 00000000..30a1b6db
--- /dev/null
+++ b/storage/perfschema/table_status_by_account.cc
@@ -0,0 +1,246 @@
+/* Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
+
+/**
+ @file storage/perfschema/table_status_by_account.cc
+ Table STATUS_BY_ACCOUNT (implementation).
+*/
+
+#include "my_global.h"
+#include "table_status_by_account.h"
+#include "my_thread.h"
+#include "pfs_instr_class.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "pfs_global.h"
+#include "pfs_account.h"
+
+THR_LOCK table_status_by_account::m_table_lock;
+
+PFS_engine_table_share
+table_status_by_account::m_share=
+{
+ { C_STRING_WITH_LEN("status_by_account") },
+ &pfs_truncatable_acl,
+ table_status_by_account::create,
+ NULL, /* write_row */
+ table_status_by_account::delete_all_rows,
+ table_status_by_account::get_row_count,
+ sizeof(pos_t),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE status_by_account("
+ "USER CHAR(32) collate utf8_bin default null,"
+ "HOST CHAR(60) collate utf8_bin default null,"
+ "VARIABLE_NAME VARCHAR(64) not null,"
+ "VARIABLE_VALUE VARCHAR(1024))") },
+ false /* perpetual */
+};
+
+PFS_engine_table*
+table_status_by_account::create(void)
+{
+ return new table_status_by_account();
+}
+
+int table_status_by_account::delete_all_rows(void)
+{
+ mysql_mutex_lock(&LOCK_status);
+ reset_status_by_thread();
+ reset_status_by_account();
+ mysql_mutex_unlock(&LOCK_status);
+ return 0;
+}
+
+ha_rows table_status_by_account::get_row_count(void)
+{
+ mysql_mutex_lock(&LOCK_status);
+ size_t status_var_count= all_status_vars.elements;
+ mysql_mutex_unlock(&LOCK_status);
+ return (global_account_container.get_row_count() * status_var_count);
+}
+
+table_status_by_account::table_status_by_account()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_status_cache(true), m_row_exists(false), m_pos(), m_next_pos()
+{}
+
+void table_status_by_account::reset_position(void)
+{
+ m_pos.reset();
+ m_next_pos.reset();
+}
+
+int table_status_by_account::rnd_init(bool scan)
+{
+ if (show_compatibility_56)
+ return 0;
+
+ /*
+ Build array of SHOW_VARs from the global status array prior to materializing
+ threads in rnd_next() or rnd_pos().
+ */
+ m_status_cache.initialize_client_session();
+
+ /* Use the current number of status variables to detect changes. */
+ ulonglong status_version= m_status_cache.get_status_array_version();
+
+ /*
+ The table context holds the current version of the global status array
+ and a record of which accounts were materialized. If scan == true, then
+ allocate a new context from mem_root and store in TLS. If scan == false,
+ then restore from TLS.
+ */
+ m_context= (table_status_by_account_context *)current_thd->alloc(sizeof(table_status_by_account_context));
+ new(m_context) table_status_by_account_context(status_version, !scan);
+ return 0;
+}
+
+int table_status_by_account::rnd_next(void)
+{
+ if (show_compatibility_56)
+ return HA_ERR_END_OF_FILE;
+
+ /* If status array changes, exit with warning. */ // TODO: Issue warning
+ if (!m_context->versions_match())
+ return HA_ERR_END_OF_FILE;
+
+ /*
+ For each account, build a cache of status variables using totals from all
+ threads associated with the account.
+ */
+ bool has_more_account= true;
+
+ for (m_pos.set_at(&m_next_pos);
+ has_more_account;
+ m_pos.next_account())
+ {
+ PFS_account *pfs_account= global_account_container.get(m_pos.m_index_1, &has_more_account);
+
+ if (m_status_cache.materialize_account(pfs_account) == 0)
+ {
+ /* Mark this account as materialized. */
+ m_context->set_item(m_pos.m_index_1);
+
+ /* Get the next status variable. */
+ const Status_variable *stat_var= m_status_cache.get(m_pos.m_index_2);
+ if (stat_var != NULL)
+ {
+ make_row(pfs_account, stat_var);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+ }
+ return HA_ERR_END_OF_FILE;
+}
+
+int
+table_status_by_account::rnd_pos(const void *pos)
+{
+ if (show_compatibility_56)
+ return HA_ERR_RECORD_DELETED;
+
+ /* If status array changes, exit with warning. */ // TODO: Issue warning
+ if (!m_context->versions_match())
+ return HA_ERR_END_OF_FILE;
+
+ set_position(pos);
+ DBUG_ASSERT(m_pos.m_index_1 < global_account_container.get_row_count());
+
+ PFS_account *pfs_account= global_account_container.get(m_pos.m_index_1);
+
+ /*
+ Only materialize threads that were previously materialized by rnd_next().
+ If a account cannot be rematerialized, then do nothing.
+ */
+ if (m_context->is_item_set(m_pos.m_index_1) &&
+ m_status_cache.materialize_account(pfs_account) == 0)
+ {
+ const Status_variable *stat_var= m_status_cache.get(m_pos.m_index_2);
+ if (stat_var != NULL)
+ {
+ make_row(pfs_account, stat_var);
+ return 0;
+ }
+ }
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_status_by_account
+::make_row(PFS_account *pfs_account, const Status_variable *status_var)
+{
+ pfs_optimistic_state lock;
+ m_row_exists= false;
+ pfs_account->m_lock.begin_optimistic_lock(&lock);
+
+ if (m_row.m_account.make_row(pfs_account))
+ return;
+
+ m_row.m_variable_name.make_row(status_var->m_name, status_var->m_name_length);
+ m_row.m_variable_value.make_row(status_var);
+
+ if (!pfs_account->m_lock.end_optimistic_lock(&lock))
+ return;
+
+ m_row_exists= true;
+}
+
+int table_status_by_account
+::read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* USER */
+ case 1: /* HOST */
+ m_row.m_account.set_field(f->field_index, f);
+ break;
+ case 2: /* VARIABLE_NAME */
+ set_field_varchar_utf8(f, m_row.m_variable_name.m_str, m_row.m_variable_name.m_length);
+ break;
+ case 3: /* VARIABLE_VALUE */
+ m_row.m_variable_value.set_field(f);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_status_by_account.h b/storage/perfschema/table_status_by_account.h
new file mode 100644
index 00000000..401a184d
--- /dev/null
+++ b/storage/perfschema/table_status_by_account.h
@@ -0,0 +1,156 @@
+/* Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
+
+#ifndef TABLE_STATUS_BY_ACCOUNT_H
+#define TABLE_STATUS_BY_ACCOUNT_H
+
+/**
+ @file storage/perfschema/table_status_by_account.h
+ Table STATUS_BY_ACCOUNT (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "pfs_account.h"
+#include "pfs_account.h"
+#include "pfs_host.h"
+#include "table_helper.h"
+#include "pfs_variable.h"
+#include "pfs_buffer_container.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/**
+ A row of table
+ PERFORMANCE_SCHEMA.STATUS_BY_ACCOUNT.
+*/
+struct row_status_by_account
+{
+ /** Column USER, HOST. */
+ PFS_account_row m_account;
+ /** Column VARIABLE_NAME. */
+ PFS_variable_name_row m_variable_name;
+ /** Column VARIABLE_VALUE. */
+ PFS_variable_value_row m_variable_value;
+};
+
+/**
+ Position of a cursor on
+ PERFORMANCE_SCHEMA.STATUS_BY_ACCOUNT.
+ Index 1 on account (0 based)
+ Index 2 on status variable (0 based)
+*/
+struct pos_status_by_account
+: public PFS_double_index
+{
+ pos_status_by_account()
+ : PFS_double_index(0, 0)
+ {}
+
+ inline void reset(void)
+ {
+ m_index_1= 0;
+ m_index_2= 0;
+ }
+
+ inline bool has_more_account(void)
+ { return (m_index_1 < global_account_container.get_row_count()); }
+
+ inline void next_account(void)
+ {
+ m_index_1++;
+ m_index_2= 0;
+ }
+};
+
+/**
+ Store and retrieve table state information for queries that reinstantiate
+ the table object.
+*/
+class table_status_by_account_context : public PFS_table_context
+{
+public:
+ table_status_by_account_context(ulonglong current_version, bool restore) :
+ PFS_table_context(current_version, global_account_container.get_row_count(), restore, THR_PFS_SBH) { }
+};
+
+/** Table PERFORMANCE_SCHEMA.STATUS_BY_ACCOUNT. */
+class table_status_by_account : public PFS_engine_table
+{
+ typedef pos_status_by_account pos_t;
+
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_init(bool scan);
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+ table_status_by_account();
+
+public:
+ ~table_status_by_account()
+ {}
+
+protected:
+ int materialize(PFS_thread *pfs_thread);
+ void make_row(PFS_account *pfs_account, const Status_variable *status_var);
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+ /** Fields definition. */
+ static TABLE_FIELD_DEF m_field_def;
+
+ /** Status variable cache for one account. */
+ PFS_status_variable_cache m_status_cache;
+
+ /** Current row. */
+ row_status_by_account m_row;
+ /** True if the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ pos_t m_pos;
+ /** Next position. */
+ pos_t m_next_pos;
+
+ /** Table context with global status array version and map of materialized threads. */
+ table_status_by_account_context *m_context;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_status_by_host.cc b/storage/perfschema/table_status_by_host.cc
new file mode 100644
index 00000000..cd41fcaa
--- /dev/null
+++ b/storage/perfschema/table_status_by_host.cc
@@ -0,0 +1,245 @@
+/* Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
+
+/**
+ @file storage/perfschema/table_status_by_host.cc
+ Table STATUS_BY_HOST (implementation).
+*/
+
+#include "my_global.h"
+#include "table_status_by_host.h"
+#include "my_thread.h"
+#include "pfs_instr_class.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "pfs_global.h"
+#include "pfs_account.h"
+
+THR_LOCK table_status_by_host::m_table_lock;
+
+PFS_engine_table_share
+table_status_by_host::m_share=
+{
+ { C_STRING_WITH_LEN("status_by_host") },
+ &pfs_truncatable_acl,
+ table_status_by_host::create,
+ NULL, /* write_row */
+ table_status_by_host::delete_all_rows,
+ table_status_by_host::get_row_count,
+ sizeof(pos_t),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE status_by_host("
+ "HOST CHAR(60) collate utf8_bin default null,"
+ "VARIABLE_NAME VARCHAR(64) not null,"
+ "VARIABLE_VALUE VARCHAR(1024))") },
+ false /* perpetual */
+};
+
+PFS_engine_table*
+table_status_by_host::create(void)
+{
+ return new table_status_by_host();
+}
+
+int table_status_by_host::delete_all_rows(void)
+{
+ mysql_mutex_lock(&LOCK_status);
+ reset_status_by_thread();
+ reset_status_by_account();
+ reset_status_by_host();
+ mysql_mutex_unlock(&LOCK_status);
+ return 0;
+}
+
+ha_rows table_status_by_host::get_row_count(void)
+{
+ mysql_mutex_lock(&LOCK_status);
+ size_t status_var_count= all_status_vars.elements;
+ mysql_mutex_unlock(&LOCK_status);
+ return (global_host_container.get_row_count() * status_var_count);
+}
+
+table_status_by_host::table_status_by_host()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_status_cache(true), m_row_exists(false), m_pos(), m_next_pos()
+{}
+
+void table_status_by_host::reset_position(void)
+{
+ m_pos.reset();
+ m_next_pos.reset();
+}
+
+int table_status_by_host::rnd_init(bool scan)
+{
+ if (show_compatibility_56)
+ return 0;
+
+ /*
+ Build array of SHOW_VARs from the global status array prior to materializing
+ threads in rnd_next() or rnd_pos().
+ */
+ m_status_cache.initialize_client_session();
+
+ /* Use the current number of status variables to detect changes. */
+ ulonglong status_version= m_status_cache.get_status_array_version();
+
+ /*
+ The table context holds the current version of the global status array
+ and a record of which hosts were materialized. If scan == true, then
+ allocate a new context from mem_root and store in TLS. If scan == false,
+ then restore from TLS.
+ */
+ m_context= (table_status_by_host_context *)current_thd->alloc(sizeof(table_status_by_host_context));
+ new(m_context) table_status_by_host_context(status_version, !scan);
+ return 0;
+}
+
+int table_status_by_host::rnd_next(void)
+{
+ if (show_compatibility_56)
+ return HA_ERR_END_OF_FILE;
+
+ /* If status array changes, exit with warning. */ // TODO: Issue warning
+ if (!m_context->versions_match())
+ return HA_ERR_END_OF_FILE;
+
+ /*
+ For each user, build a cache of status variables using totals from all
+ threads associated with the host.
+ */
+ bool has_more_host= true;
+
+ for (m_pos.set_at(&m_next_pos);
+ has_more_host;
+ m_pos.next_host())
+ {
+ PFS_host *pfs_host= global_host_container.get(m_pos.m_index_1, &has_more_host);
+
+ if (m_status_cache.materialize_host(pfs_host) == 0)
+ {
+ /* Mark this host as materialized. */
+ m_context->set_item(m_pos.m_index_1);
+
+ /* Get the next status variable. */
+ const Status_variable *stat_var= m_status_cache.get(m_pos.m_index_2);
+ if (stat_var != NULL)
+ {
+ make_row(pfs_host, stat_var);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+ }
+ return HA_ERR_END_OF_FILE;
+}
+
+int
+table_status_by_host::rnd_pos(const void *pos)
+{
+ if (show_compatibility_56)
+ return 0;
+
+ /* If status array changes, exit with warning. */ // TODO: Issue warning
+ if (!m_context->versions_match())
+ return HA_ERR_END_OF_FILE;
+
+ set_position(pos);
+ DBUG_ASSERT(m_pos.m_index_1 < global_host_container.get_row_count());
+
+ PFS_host *pfs_host= global_host_container.get(m_pos.m_index_1);
+
+ /*
+ Only materialize threads that were previously materialized by rnd_next().
+ If a host cannot be rematerialized, then do nothing.
+ */
+ if (m_context->is_item_set(m_pos.m_index_1) &&
+ m_status_cache.materialize_host(pfs_host) == 0)
+ {
+ const Status_variable *stat_var= m_status_cache.get(m_pos.m_index_2);
+ if (stat_var != NULL)
+ {
+ make_row(pfs_host, stat_var);
+ return 0;
+ }
+ }
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_status_by_host
+::make_row(PFS_host *pfs_host, const Status_variable *status_var)
+{
+ pfs_optimistic_state lock;
+ m_row_exists= false;
+ pfs_host->m_lock.begin_optimistic_lock(&lock);
+
+ if (m_row.m_host.make_row(pfs_host))
+ return;
+
+ m_row.m_variable_name.make_row(status_var->m_name, status_var->m_name_length);
+ m_row.m_variable_value.make_row(status_var);
+
+ if (!pfs_host->m_lock.end_optimistic_lock(&lock))
+ return;
+
+ m_row_exists= true;
+}
+
+int table_status_by_host
+::read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* HOST */
+ m_row.m_host.set_field(f);
+ break;
+ case 1: /* VARIABLE_NAME */
+ set_field_varchar_utf8(f, m_row.m_variable_name.m_str, m_row.m_variable_name.m_length);
+ break;
+ case 2: /* VARIABLE_VALUE */
+ m_row.m_variable_value.set_field(f);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_status_by_host.h b/storage/perfschema/table_status_by_host.h
new file mode 100644
index 00000000..e4c6bf25
--- /dev/null
+++ b/storage/perfschema/table_status_by_host.h
@@ -0,0 +1,154 @@
+/* Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
+
+#ifndef TABLE_STATUS_BY_HOST_H
+#define TABLE_STATUS_BY_HOST_H
+
+/**
+ @file storage/perfschema/table_status_by_host.h
+ Table STATUS_BY_HOST (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "pfs_host.h"
+#include "table_helper.h"
+#include "pfs_variable.h"
+#include "pfs_buffer_container.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/**
+ A row of table
+ PERFORMANCE_SCHEMA.STATUS_BY_HOST.
+*/
+struct row_status_by_host
+{
+ /** Column HOST */
+ PFS_host_row m_host;
+ /** Column VARIABLE_NAME. */
+ PFS_variable_name_row m_variable_name;
+ /** Column VARIABLE_VALUE. */
+ PFS_variable_value_row m_variable_value;
+};
+
+/**
+ Position of a cursor on
+ PERFORMANCE_SCHEMA.STATUS_BY_HOST.
+ Index 1 on host (0 based)
+ Index 2 on status variable (0 based)
+*/
+struct pos_status_by_host
+: public PFS_double_index
+{
+ pos_status_by_host()
+ : PFS_double_index(0, 0)
+ {}
+
+ inline void reset(void)
+ {
+ m_index_1= 0;
+ m_index_2= 0;
+ }
+
+ inline bool has_more_host(void)
+ { return (m_index_1 < global_host_container.get_row_count()); }
+
+ inline void next_host(void)
+ {
+ m_index_1++;
+ m_index_2= 0;
+ }
+};
+
+/**
+ Store and retrieve table state information for queries that reinstantiate
+ the table object.
+*/
+class table_status_by_host_context : public PFS_table_context
+{
+public:
+ table_status_by_host_context(ulonglong current_version, bool restore) :
+ PFS_table_context(current_version, global_host_container.get_row_count(), restore, THR_PFS_SBH) { }
+};
+
+/** Table PERFORMANCE_SCHEMA.STATUS_BY_HOST. */
+class table_status_by_host : public PFS_engine_table
+{
+ typedef pos_status_by_host pos_t;
+
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_init(bool scan);
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+ table_status_by_host();
+
+public:
+ ~table_status_by_host()
+ {}
+
+protected:
+ int materialize(PFS_thread *thread);
+ void make_row(PFS_host *pfs_host, const Status_variable *status_var);
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+ /** Fields definition. */
+ static TABLE_FIELD_DEF m_field_def;
+
+ /** Status variable cache for one host. */
+ PFS_status_variable_cache m_status_cache;
+
+ /** Current row. */
+ row_status_by_host m_row;
+ /** True if the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ pos_t m_pos;
+ /** Next position. */
+ pos_t m_next_pos;
+
+ /** Table context with global status array version and map of materialized threads. */
+ table_status_by_host_context *m_context;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_status_by_thread.cc b/storage/perfschema/table_status_by_thread.cc
new file mode 100644
index 00000000..d9af7e49
--- /dev/null
+++ b/storage/perfschema/table_status_by_thread.cc
@@ -0,0 +1,239 @@
+/* Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
+
+/**
+ @file storage/perfschema/table_status_by_thread.cc
+ Table STATUS_BY_THREAD (implementation).
+*/
+
+#include "my_global.h"
+#include "table_status_by_thread.h"
+#include "my_thread.h"
+#include "pfs_instr_class.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "pfs_global.h"
+
+THR_LOCK table_status_by_thread::m_table_lock;
+
+PFS_engine_table_share
+table_status_by_thread::m_share=
+{
+ { C_STRING_WITH_LEN("status_by_thread") },
+ &pfs_truncatable_acl,
+ table_status_by_thread::create,
+ NULL, /* write_row */
+ table_status_by_thread::delete_all_rows,
+ table_status_by_thread::get_row_count,
+ sizeof(pos_t),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE status_by_thread("
+ "THREAD_ID BIGINT unsigned not null,"
+ "VARIABLE_NAME VARCHAR(64) not null,"
+ "VARIABLE_VALUE VARCHAR(1024))") },
+ false /* perpetual */
+};
+
+PFS_engine_table*
+table_status_by_thread::create(void)
+{
+ return new table_status_by_thread();
+}
+
+int table_status_by_thread::delete_all_rows(void)
+{
+ /* Lock required to aggregate to global_status_vars. */
+ mysql_mutex_lock(&LOCK_status);
+
+ reset_status_by_thread();
+
+ mysql_mutex_unlock(&LOCK_status);
+ return 0;
+}
+
+ha_rows table_status_by_thread::get_row_count(void)
+{
+ mysql_mutex_lock(&LOCK_status);
+ size_t status_var_count= all_status_vars.elements;
+ mysql_mutex_unlock(&LOCK_status);
+ return (global_thread_container.get_row_count() * status_var_count);
+}
+
+table_status_by_thread::table_status_by_thread()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_status_cache(true), m_row_exists(false), m_pos(), m_next_pos()
+{}
+
+void table_status_by_thread::reset_position(void)
+{
+ m_pos.reset();
+ m_next_pos.reset();
+}
+
+int table_status_by_thread::rnd_init(bool scan)
+{
+ if (show_compatibility_56)
+ return 0;
+
+ /*
+ Build array of SHOW_VARs from the global status array prior to materializing
+ threads in rnd_next() or rnd_pos().
+ */
+ m_status_cache.initialize_session();
+
+ /* Record the current number of status variables to detect subsequent changes. */
+ ulonglong status_version= m_status_cache.get_status_array_version();
+
+ /*
+ The table context holds the current version of the global status array
+ and a record of which threads were materialized. If scan == true, then
+ allocate a new context from mem_root and store in TLS. If scan == false,
+ then restore from TLS.
+ */
+ m_context= (table_status_by_thread_context *)current_thd->alloc(sizeof(table_status_by_thread_context));
+ new(m_context) table_status_by_thread_context(status_version, !scan);
+ return 0;
+}
+
+int table_status_by_thread::rnd_next(void)
+{
+ if (show_compatibility_56)
+ return HA_ERR_END_OF_FILE;
+
+ /* If global status array changes, exit with warning. */ // TODO: Issue warning
+ if (!m_context->versions_match())
+ return HA_ERR_END_OF_FILE;
+
+ bool has_more_thread= true;
+
+ for (m_pos.set_at(&m_next_pos);
+ has_more_thread;
+ m_pos.next_thread())
+ {
+ PFS_thread *pfs_thread= global_thread_container.get(m_pos.m_index_1, &has_more_thread);
+ if (m_status_cache.materialize_session(pfs_thread) == 0)
+ {
+ /* Mark this thread as materialized. */
+ m_context->set_item(m_pos.m_index_1);
+ const Status_variable *stat_var= m_status_cache.get(m_pos.m_index_2);
+ if (stat_var != NULL)
+ {
+ make_row(pfs_thread, stat_var);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+ }
+ return HA_ERR_END_OF_FILE;
+}
+
+int
+table_status_by_thread::rnd_pos(const void *pos)
+{
+ if (show_compatibility_56)
+ return HA_ERR_RECORD_DELETED;
+
+ /* If global status array has changed, do nothing. */
+ if (!m_context->versions_match())
+ return HA_ERR_RECORD_DELETED;
+
+ set_position(pos);
+ DBUG_ASSERT(m_pos.m_index_1 < global_thread_container.get_row_count());
+
+ PFS_thread *pfs_thread= global_thread_container.get(m_pos.m_index_1);
+ /*
+ Only materialize threads that were previously materialized by rnd_next().
+ If a thread cannot be rematerialized, then do nothing.
+ */
+ if (m_context->is_item_set(m_pos.m_index_1) &&
+ m_status_cache.materialize_session(pfs_thread) == 0)
+ {
+ const Status_variable *stat_var= m_status_cache.get(m_pos.m_index_2);
+ if (stat_var != NULL)
+ {
+ make_row(pfs_thread, stat_var);
+ return 0;
+ }
+ }
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_status_by_thread
+::make_row(PFS_thread *thread, const Status_variable *status_var)
+{
+ pfs_optimistic_state lock;
+ m_row_exists= false;
+ if (status_var->is_null())
+ return;
+
+ /* Protect this reader against a thread termination */
+ thread->m_lock.begin_optimistic_lock(&lock);
+
+ m_row.m_thread_internal_id= thread->m_thread_internal_id;
+ m_row.m_variable_name.make_row(status_var->m_name, status_var->m_name_length);
+ m_row.m_variable_value.make_row(status_var);
+
+ if (!thread->m_lock.end_optimistic_lock(&lock))
+ return;
+
+ m_row_exists= true;
+}
+
+int table_status_by_thread
+::read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* THREAD_ID */
+ set_field_ulonglong(f, m_row.m_thread_internal_id);
+ break;
+ case 1: /* VARIABLE_NAME */
+ set_field_varchar_utf8(f, m_row.m_variable_name.m_str, m_row.m_variable_name.m_length);
+ break;
+ case 2: /* VARIABLE_VALUE */
+ m_row.m_variable_value.set_field(f);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_status_by_thread.h b/storage/perfschema/table_status_by_thread.h
new file mode 100644
index 00000000..f8de21dc
--- /dev/null
+++ b/storage/perfschema/table_status_by_thread.h
@@ -0,0 +1,151 @@
+/* Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
+
+#ifndef TABLE_STATUS_BY_THREAD_H
+#define TABLE_STATUS_BY_THREAD_H
+
+/**
+ @file storage/perfschema/table_status_by_thread.h
+ Table STATUS_BY_THREAD (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "table_helper.h"
+#include "pfs_variable.h"
+#include "pfs_buffer_container.h"
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/**
+ A row of table
+ PERFORMANCE_SCHEMA.STATUS_BY_THREAD.
+*/
+struct row_status_by_thread
+{
+ /** Column THREAD_ID. */
+ ulonglong m_thread_internal_id;
+ /** Column VARIABLE_NAME. */
+ PFS_variable_name_row m_variable_name;
+ /** Column VARIABLE_VALUE. */
+ PFS_variable_value_row m_variable_value;
+};
+
+/**
+ Position of a cursor on
+ PERFORMANCE_SCHEMA.STATUS_BY_THREAD.
+ Index 1 on thread (0 based)
+ Index 2 on status variable (0 based)
+*/
+struct pos_status_by_thread
+: public PFS_double_index
+{
+ pos_status_by_thread()
+ : PFS_double_index(0, 0)
+ {}
+
+ inline void reset(void)
+ {
+ m_index_1= 0;
+ m_index_2= 0;
+ }
+
+ inline bool has_more_thread(void)
+ { return (m_index_1 < global_thread_container.get_row_count()); }
+
+ inline void next_thread(void)
+ {
+ m_index_1++;
+ m_index_2= 0;
+ }
+};
+
+/**
+ Store and retrieve table state information for queries that reinstantiate
+ the table object.
+*/
+class table_status_by_thread_context : public PFS_table_context
+{
+public:
+ table_status_by_thread_context(ulonglong current_version, bool restore) :
+ PFS_table_context(current_version, global_thread_container.get_row_count(), restore, THR_PFS_SBT) { }
+};
+
+/** Table PERFORMANCE_SCHEMA.STATUS_BY_THREAD. */
+class table_status_by_thread : public PFS_engine_table
+{
+ typedef pos_status_by_thread pos_t;
+
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_init(bool scan);
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+ table_status_by_thread();
+
+public:
+ ~table_status_by_thread()
+ {}
+
+protected:
+ int materialize(PFS_thread *thread);
+ void make_row(PFS_thread *thread, const Status_variable *status_var);
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+ /** Fields definition. */
+ static TABLE_FIELD_DEF m_field_def;
+
+ /** Current THD variables. */
+ PFS_status_variable_cache m_status_cache;
+ /** Current row. */
+ row_status_by_thread m_row;
+ /** True if the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ pos_t m_pos;
+ /** Next position. */
+ pos_t m_next_pos;
+
+ /** Table context with global status array version and map of materialized threads. */
+ table_status_by_thread_context *m_context;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_status_by_user.cc b/storage/perfschema/table_status_by_user.cc
new file mode 100644
index 00000000..921a7224
--- /dev/null
+++ b/storage/perfschema/table_status_by_user.cc
@@ -0,0 +1,246 @@
+/* Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
+
+/**
+ @file storage/perfschema/table_status_by_user.cc
+ Table STATUS_BY_USER (implementation).
+*/
+
+#include "my_global.h"
+#include "table_status_by_user.h"
+#include "my_thread.h"
+#include "pfs_instr_class.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "pfs_global.h"
+#include "pfs_account.h"
+#include "pfs_visitor.h"
+
+THR_LOCK table_status_by_user::m_table_lock;
+
+PFS_engine_table_share
+table_status_by_user::m_share=
+{
+ { C_STRING_WITH_LEN("status_by_user") },
+ &pfs_truncatable_acl,
+ table_status_by_user::create,
+ NULL, /* write_row */
+ table_status_by_user::delete_all_rows,
+ table_status_by_user::get_row_count,
+ sizeof(pos_t),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE status_by_user("
+ "USER CHAR(32) collate utf8_bin default null,"
+ "VARIABLE_NAME VARCHAR(64) not null,"
+ "VARIABLE_VALUE VARCHAR(1024))") },
+ false /* perpetual */
+};
+
+PFS_engine_table*
+table_status_by_user::create(void)
+{
+ return new table_status_by_user();
+}
+
+int table_status_by_user::delete_all_rows(void)
+{
+ mysql_mutex_lock(&LOCK_status);
+ reset_status_by_thread();
+ reset_status_by_account();
+ reset_status_by_user();
+ mysql_mutex_unlock(&LOCK_status);
+ return 0;
+}
+
+ha_rows table_status_by_user::get_row_count(void)
+{
+ mysql_mutex_lock(&LOCK_status);
+ size_t status_var_count= all_status_vars.elements;
+ mysql_mutex_unlock(&LOCK_status);
+ return (global_user_container.get_row_count() * status_var_count);
+}
+
+table_status_by_user::table_status_by_user()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_status_cache(true), m_row_exists(false), m_pos(), m_next_pos()
+{}
+
+void table_status_by_user::reset_position(void)
+{
+ m_pos.reset();
+ m_next_pos.reset();
+}
+
+int table_status_by_user::rnd_init(bool scan)
+{
+ if (show_compatibility_56)
+ return 0;
+
+ /*
+ Build array of SHOW_VARs from the global status array prior to materializing
+ threads in rnd_next() or rnd_pos().
+ */
+ m_status_cache.initialize_client_session();
+
+ /* Use the current number of status variables to detect changes. */
+ ulonglong status_version= m_status_cache.get_status_array_version();
+
+ /*
+ The table context holds the current version of the global status array
+ and a record of which users were materialized. If scan == true, then
+ allocate a new context from mem_root and store in TLS. If scan == false,
+ then restore from TLS.
+ */
+ m_context= (table_status_by_user_context *)current_thd->alloc(sizeof(table_status_by_user_context));
+ new(m_context) table_status_by_user_context(status_version, !scan);
+ return 0;
+}
+
+int table_status_by_user::rnd_next(void)
+{
+ if (show_compatibility_56)
+ return HA_ERR_END_OF_FILE;
+
+ /* If status array changes, exit with warning. */ // TODO: Issue warning
+ if (!m_context->versions_match())
+ return HA_ERR_END_OF_FILE;
+
+ /*
+ For each user, build a cache of status variables using totals from all
+ threads associated with the user.
+ */
+ bool has_more_user= true;
+
+ for (m_pos.set_at(&m_next_pos);
+ has_more_user;
+ m_pos.next_user())
+ {
+ PFS_user *pfs_user= global_user_container.get(m_pos.m_index_1, &has_more_user);
+
+ if (m_status_cache.materialize_user(pfs_user) == 0)
+ {
+ /* Mark this user as materialized. */
+ m_context->set_item(m_pos.m_index_1);
+
+ /* Get the next status variable. */
+ const Status_variable *stat_var= m_status_cache.get(m_pos.m_index_2);
+ if (stat_var != NULL)
+ {
+ make_row(pfs_user, stat_var);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+ }
+ return HA_ERR_END_OF_FILE;
+}
+
+int
+table_status_by_user::rnd_pos(const void *pos)
+{
+ if (show_compatibility_56)
+ return HA_ERR_RECORD_DELETED;
+
+ /* If status array changes, exit with warning. */ // TODO: Issue warning
+ if (!m_context->versions_match())
+ return HA_ERR_END_OF_FILE;
+
+ set_position(pos);
+ DBUG_ASSERT(m_pos.m_index_1 < global_user_container.get_row_count());
+
+ PFS_user *pfs_user= global_user_container.get(m_pos.m_index_1);
+
+ /*
+ Only materialize threads that were previously materialized by rnd_next().
+ If a user cannot be rematerialized, then do nothing.
+ */
+ if (m_context->is_item_set(m_pos.m_index_1) &&
+ m_status_cache.materialize_user(pfs_user) == 0)
+ {
+ const Status_variable *stat_var= m_status_cache.get(m_pos.m_index_2);
+ if (stat_var != NULL)
+ {
+ make_row(pfs_user, stat_var);
+ return 0;
+ }
+ }
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_status_by_user
+::make_row(PFS_user *user, const Status_variable *status_var)
+{
+ pfs_optimistic_state lock;
+ m_row_exists= false;
+ user->m_lock.begin_optimistic_lock(&lock);
+
+ if (m_row.m_user.make_row(user))
+ return;
+
+ m_row.m_variable_name.make_row(status_var->m_name, status_var->m_name_length);
+ m_row.m_variable_value.make_row(status_var);
+
+ if (!user->m_lock.end_optimistic_lock(&lock))
+ return;
+
+ m_row_exists= true;
+}
+
+int table_status_by_user
+::read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* USER */
+ m_row.m_user.set_field(f);
+ break;
+ case 1: /* VARIABLE_NAME */
+ set_field_varchar_utf8(f, m_row.m_variable_name.m_str, m_row.m_variable_name.m_length);
+ break;
+ case 2: /* VARIABLE_VALUE */
+ m_row.m_variable_value.set_field(f);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_status_by_user.h b/storage/perfschema/table_status_by_user.h
new file mode 100644
index 00000000..6b4a67b4
--- /dev/null
+++ b/storage/perfschema/table_status_by_user.h
@@ -0,0 +1,153 @@
+/* Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
+
+#ifndef TABLE_STATUS_BY_USER_H
+#define TABLE_STATUS_BY_USER_H
+
+/**
+ @file storage/perfschema/table_status_by_user.h
+ Table STATUS_BY_USER (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "pfs_user.h"
+#include "table_helper.h"
+#include "pfs_variable.h"
+#include "pfs_buffer_container.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/**
+ A row of table
+ PERFORMANCE_SCHEMA.STATUS_BY_USER.
+*/
+struct row_status_by_user
+{
+ /** Column USER */
+ PFS_user_row m_user;
+ /** Column VARIABLE_NAME. */
+ PFS_variable_name_row m_variable_name;
+ /** Column VARIABLE_VALUE. */
+ PFS_variable_value_row m_variable_value;
+};
+
+/**
+ Position of a cursor on
+ PERFORMANCE_SCHEMA.STATUS_BY_USER.
+ Index 1 on user (0 based)
+ Index 2 on status variable (0 based)
+*/
+struct pos_status_by_user
+: public PFS_double_index
+{
+ pos_status_by_user()
+ : PFS_double_index(0, 0)
+ {}
+
+ inline void reset(void)
+ {
+ m_index_1= 0;
+ m_index_2= 0;
+ }
+
+ inline bool has_more_user(void)
+ { return (m_index_1 < global_user_container.get_row_count()); }
+
+ inline void next_user(void)
+ {
+ m_index_1++;
+ m_index_2= 0;
+ }
+};
+
+/**
+ Store and retrieve table state information for queries that reinstantiate
+ the table object.
+*/
+class table_status_by_user_context : public PFS_table_context
+{
+public:
+ table_status_by_user_context(ulonglong current_version, bool restore) :
+ PFS_table_context(current_version, global_user_container.get_row_count(), restore, THR_PFS_SBU) { }
+};
+
+/** Table PERFORMANCE_SCHEMA.STATUS_BY_USER. */
+class table_status_by_user : public PFS_engine_table
+{
+ typedef pos_status_by_user pos_t;
+
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_init(bool scan);
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+ table_status_by_user();
+
+public:
+ ~table_status_by_user() { }
+
+protected:
+ int materialize(PFS_thread *thread);
+ void make_row(PFS_user *user, const Status_variable *status_var);
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+ /** Fields definition. */
+ static TABLE_FIELD_DEF m_field_def;
+
+ /** Status variable cache for one user. */
+ PFS_status_variable_cache m_status_cache;
+
+ /** Current row. */
+ row_status_by_user m_row;
+ /** True if the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ pos_t m_pos;
+ /** Next position. */
+ pos_t m_next_pos;
+
+ /** Table context with global status array version and map of materialized threads. */
+ table_status_by_user_context *m_context;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_sync_instances.cc b/storage/perfschema/table_sync_instances.cc
new file mode 100644
index 00000000..5b9f90c1
--- /dev/null
+++ b/storage/perfschema/table_sync_instances.cc
@@ -0,0 +1,472 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_sync_instances.cc
+ Table MUTEX_INSTANCES, RWLOCK_INSTANCES
+ and COND_INSTANCES (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "pfs_instr.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "table_sync_instances.h"
+#include "pfs_global.h"
+#include "pfs_buffer_container.h"
+#include "field.h"
+
+THR_LOCK table_mutex_instances::m_table_lock;
+
+PFS_engine_table_share
+table_mutex_instances::m_share=
+{
+ { C_STRING_WITH_LEN("mutex_instances") },
+ &pfs_readonly_acl,
+ table_mutex_instances::create,
+ NULL, /* write_row */
+ NULL, /* delete_all_rows */
+ table_mutex_instances::get_row_count,
+ sizeof(PFS_simple_index),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE mutex_instances("
+ "NAME VARCHAR(128) not null,"
+ "OBJECT_INSTANCE_BEGIN BIGINT unsigned not null,"
+ "LOCKED_BY_THREAD_ID BIGINT unsigned)") },
+ false /* perpetual */
+};
+
+PFS_engine_table* table_mutex_instances::create(void)
+{
+ return new table_mutex_instances();
+}
+
+ha_rows
+table_mutex_instances::get_row_count(void)
+{
+ return global_mutex_container.get_row_count();
+}
+
+table_mutex_instances::table_mutex_instances()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(0), m_next_pos(0)
+{}
+
+void table_mutex_instances::reset_position(void)
+{
+ m_pos.m_index= 0;
+ m_next_pos.m_index= 0;
+}
+
+int table_mutex_instances::rnd_next(void)
+{
+ PFS_mutex *pfs;
+
+ m_pos.set_at(&m_next_pos);
+ PFS_mutex_iterator it= global_mutex_container.iterate(m_pos.m_index);
+ pfs= it.scan_next(& m_pos.m_index);
+ if (pfs != NULL)
+ {
+ make_row(pfs);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int table_mutex_instances::rnd_pos(const void *pos)
+{
+ PFS_mutex *pfs;
+
+ set_position(pos);
+
+ pfs= global_mutex_container.get(m_pos.m_index);
+ if (pfs != NULL)
+ {
+ make_row(pfs);
+ return 0;
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_mutex_instances::make_row(PFS_mutex *pfs)
+{
+ pfs_optimistic_state lock;
+ PFS_mutex_class *safe_class;
+
+ m_row_exists= false;
+
+ /* Protect this reader against a mutex destroy */
+ pfs->m_lock.begin_optimistic_lock(&lock);
+
+ safe_class= sanitize_mutex_class(pfs->m_class);
+ if (unlikely(safe_class == NULL))
+ return;
+
+ m_row.m_name= safe_class->m_name;
+ m_row.m_name_length= safe_class->m_name_length;
+ m_row.m_identity= pfs->m_identity;
+
+ /* Protect this reader against a mutex unlock */
+ PFS_thread *safe_owner= sanitize_thread(pfs->m_owner);
+ if (safe_owner)
+ {
+ m_row.m_locked_by_thread_id= safe_owner->m_thread_internal_id;
+ m_row.m_locked= true;
+ }
+ else
+ m_row.m_locked= false;
+
+ if (pfs->m_lock.end_optimistic_lock(&lock))
+ m_row_exists= true;
+}
+
+int table_mutex_instances::read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* NAME */
+ set_field_varchar_utf8(f, m_row.m_name, m_row.m_name_length);
+ break;
+ case 1: /* OBJECT_INSTANCE */
+ set_field_ulonglong(f, (intptr) m_row.m_identity);
+ break;
+ case 2: /* LOCKED_BY_THREAD_ID */
+ if (m_row.m_locked)
+ set_field_ulonglong(f, m_row.m_locked_by_thread_id);
+ else
+ f->set_null();
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+
+ return 0;
+}
+
+THR_LOCK table_rwlock_instances::m_table_lock;
+
+PFS_engine_table_share
+table_rwlock_instances::m_share=
+{
+ { C_STRING_WITH_LEN("rwlock_instances") },
+ &pfs_readonly_acl,
+ table_rwlock_instances::create,
+ NULL, /* write_row */
+ NULL, /* delete_all_rows */
+ table_rwlock_instances::get_row_count,
+ sizeof(PFS_simple_index),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE rwlock_instances("
+ "NAME VARCHAR(128) not null,"
+ "OBJECT_INSTANCE_BEGIN BIGINT unsigned not null,"
+ "WRITE_LOCKED_BY_THREAD_ID BIGINT unsigned,"
+ "READ_LOCKED_BY_COUNT INTEGER unsigned not null)") },
+ false /* perpetual */
+};
+
+PFS_engine_table* table_rwlock_instances::create(void)
+{
+ return new table_rwlock_instances();
+}
+
+ha_rows
+table_rwlock_instances::get_row_count(void)
+{
+ return global_rwlock_container.get_row_count();
+}
+
+table_rwlock_instances::table_rwlock_instances()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(0), m_next_pos(0)
+{}
+
+void table_rwlock_instances::reset_position(void)
+{
+ m_pos.m_index= 0;
+ m_next_pos.m_index= 0;
+}
+
+int table_rwlock_instances::rnd_next(void)
+{
+ PFS_rwlock *pfs;
+
+ m_pos.set_at(&m_next_pos);
+ PFS_rwlock_iterator it= global_rwlock_container.iterate(m_pos.m_index);
+ pfs= it.scan_next(& m_pos.m_index);
+ if (pfs != NULL)
+ {
+ make_row(pfs);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int table_rwlock_instances::rnd_pos(const void *pos)
+{
+ PFS_rwlock *pfs;
+
+ set_position(pos);
+
+ pfs= global_rwlock_container.get(m_pos.m_index);
+ if (pfs != NULL)
+ {
+ make_row(pfs);
+ return 0;
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_rwlock_instances::make_row(PFS_rwlock *pfs)
+{
+ pfs_optimistic_state lock;
+ PFS_rwlock_class *safe_class;
+
+ m_row_exists= false;
+
+ /* Protect this reader against a rwlock destroy */
+ pfs->m_lock.begin_optimistic_lock(&lock);
+
+ safe_class= sanitize_rwlock_class(pfs->m_class);
+ if (unlikely(safe_class == NULL))
+ return;
+
+ m_row.m_name= safe_class->m_name;
+ m_row.m_name_length= safe_class->m_name_length;
+ m_row.m_identity= pfs->m_identity;
+
+ /* Protect this reader against a rwlock unlock in the writer */
+ PFS_thread *safe_writer= sanitize_thread(pfs->m_writer);
+ if (safe_writer)
+ {
+ m_row.m_write_locked_by_thread_id= safe_writer->m_thread_internal_id;
+ m_row.m_readers= 0;
+ m_row.m_write_locked= true;
+ }
+ else
+ {
+ m_row.m_readers= pfs->m_readers;
+ m_row.m_write_locked= false;
+ }
+
+ if (pfs->m_lock.end_optimistic_lock(&lock))
+ m_row_exists= true;
+}
+
+int table_rwlock_instances::read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* NAME */
+ set_field_varchar_utf8(f, m_row.m_name, m_row.m_name_length);
+ break;
+ case 1: /* OBJECT_INSTANCE */
+ set_field_ulonglong(f, (intptr) m_row.m_identity);
+ break;
+ case 2: /* WRITE_LOCKED_BY_THREAD_ID */
+ if (m_row.m_write_locked)
+ set_field_ulonglong(f, m_row.m_write_locked_by_thread_id);
+ else
+ f->set_null();
+ break;
+ case 3: /* READ_LOCKED_BY_COUNT */
+ set_field_ulong(f, m_row.m_readers);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+
+ return 0;
+}
+
+THR_LOCK table_cond_instances::m_table_lock;
+
+PFS_engine_table_share
+table_cond_instances::m_share=
+{
+ { C_STRING_WITH_LEN("cond_instances") },
+ &pfs_readonly_acl,
+ table_cond_instances::create,
+ NULL, /* write_row */
+ NULL, /* delete_all_rows */
+ table_cond_instances::get_row_count,
+ sizeof(PFS_simple_index),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE cond_instances("
+ "NAME VARCHAR(128) not null,"
+ "OBJECT_INSTANCE_BEGIN BIGINT unsigned not null)") },
+ false /* perpetual */
+};
+
+PFS_engine_table* table_cond_instances::create(void)
+{
+ return new table_cond_instances();
+}
+
+ha_rows
+table_cond_instances::get_row_count(void)
+{
+ return global_cond_container.get_row_count();
+}
+
+table_cond_instances::table_cond_instances()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(0), m_next_pos(0)
+{}
+
+void table_cond_instances::reset_position(void)
+{
+ m_pos.m_index= 0;
+ m_next_pos.m_index= 0;
+}
+
+int table_cond_instances::rnd_next(void)
+{
+ PFS_cond *pfs;
+
+ m_pos.set_at(&m_next_pos);
+ PFS_cond_iterator it= global_cond_container.iterate(m_pos.m_index);
+ pfs= it.scan_next(& m_pos.m_index);
+ if (pfs != NULL)
+ {
+ make_row(pfs);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int table_cond_instances::rnd_pos(const void *pos)
+{
+ PFS_cond *pfs;
+
+ set_position(pos);
+
+ pfs= global_cond_container.get(m_pos.m_index);
+ if (pfs != NULL)
+ {
+ make_row(pfs);
+ return 0;
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_cond_instances::make_row(PFS_cond *pfs)
+{
+ pfs_optimistic_state lock;
+ PFS_cond_class *safe_class;
+
+ m_row_exists= false;
+
+ /* Protect this reader against a cond destroy */
+ pfs->m_lock.begin_optimistic_lock(&lock);
+
+ safe_class= sanitize_cond_class(pfs->m_class);
+ if (unlikely(safe_class == NULL))
+ return;
+
+ m_row.m_name= safe_class->m_name;
+ m_row.m_name_length= safe_class->m_name_length;
+ m_row.m_identity= pfs->m_identity;
+
+ if (pfs->m_lock.end_optimistic_lock(&lock))
+ m_row_exists= true;
+}
+
+int table_cond_instances::read_row_values(TABLE *table,
+ unsigned char *,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 0);
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* NAME */
+ set_field_varchar_utf8(f, m_row.m_name, m_row.m_name_length);
+ break;
+ case 1: /* OBJECT_INSTANCE */
+ set_field_ulonglong(f, (intptr) m_row.m_identity);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_sync_instances.h b/storage/perfschema/table_sync_instances.h
new file mode 100644
index 00000000..6cf8f0f3
--- /dev/null
+++ b/storage/perfschema/table_sync_instances.h
@@ -0,0 +1,210 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_SYNC_INSTANCE_H
+#define TABLE_SYNC_INSTANCE_H
+
+/**
+ @file storage/perfschema/table_sync_instances.h
+ Table MUTEX_INSTANCES, RWLOCK_INSTANCES and COND_INSTANCES (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+
+struct PFS_mutex;
+struct PFS_rwlock;
+struct PFS_cond;
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/** A row of table PERFORMANCE_SCHEMA.MUTEX_INSTANCES. */
+struct row_mutex_instances
+{
+ /** Column NAME. */
+ const char *m_name;
+ /** Length in bytes of @c m_name. */
+ uint m_name_length;
+ /** Column OBJECT_INSTANCE_BEGIN. */
+ const void *m_identity;
+ /** True if column LOCKED_BY_THREAD_ID is not null. */
+ bool m_locked;
+ /** Column LOCKED_BY_THREAD_ID. */
+ ulonglong m_locked_by_thread_id;
+};
+
+/** Table PERFORMANCE_SCHEMA.MUTEX_INSTANCES. */
+class table_mutex_instances : public PFS_engine_table
+{
+public:
+ /** Table share. */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static ha_rows get_row_count();
+
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+private:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_mutex_instances();
+
+public:
+ ~table_mutex_instances()
+ {}
+
+private:
+ void make_row(PFS_mutex *pfs);
+
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ /** Current row. */
+ row_mutex_instances m_row;
+ /** True if the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ PFS_simple_index m_pos;
+ /** Next position. */
+ PFS_simple_index m_next_pos;
+};
+
+/** A row of table PERFORMANCE_SCHEMA.RWLOCK_INSTANCES. */
+struct row_rwlock_instances
+{
+ /** Column NAME. */
+ const char *m_name;
+ /** Length in bytes of @c m_name. */
+ uint m_name_length;
+ /** Column OBJECT_INSTANCE_BEGIN. */
+ const void *m_identity;
+ /** True if column WRITE_LOCKED_BY_THREAD_ID is not null. */
+ bool m_write_locked;
+ /** Column WRITE_LOCKED_BY_THREAD_ID. */
+ ulonglong m_write_locked_by_thread_id;
+ /** Column READ_LOCKED_BY_COUNT. */
+ ulong m_readers;
+};
+
+/** Table PERFORMANCE_SCHEMA.RWLOCK_INSTANCES. */
+class table_rwlock_instances : public PFS_engine_table
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static ha_rows get_row_count();
+
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+private:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_rwlock_instances();
+
+public:
+ ~table_rwlock_instances()
+ {}
+
+private:
+ void make_row(PFS_rwlock *pfs);
+
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ /** Current row. */
+ row_rwlock_instances m_row;
+ /** True if the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ PFS_simple_index m_pos;
+ /** Next position. */
+ PFS_simple_index m_next_pos;
+};
+
+/** A row of table PERFORMANCE_SCHEMA.COND_INSTANCES. */
+struct row_cond_instances
+{
+ /** Column NAME. */
+ const char *m_name;
+ /** Length in bytes of @c m_name. */
+ uint m_name_length;
+ /** Column OBJECT_INSTANCE_BEGIN. */
+ const void *m_identity;
+};
+
+/** Table PERFORMANCE_SCHEMA.COND_INSTANCES. */
+class table_cond_instances : public PFS_engine_table
+{
+public:
+ /** Table share. */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static ha_rows get_row_count();
+
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+private:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_cond_instances();
+
+public:
+ ~table_cond_instances()
+ {}
+
+private:
+ void make_row(PFS_cond *pfs);
+
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ /** Current row. */
+ row_cond_instances m_row;
+ /** True if the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ PFS_simple_index m_pos;
+ /** Next position. */
+ PFS_simple_index m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_table_handles.cc b/storage/perfschema/table_table_handles.cc
new file mode 100644
index 00000000..ab6ed357
--- /dev/null
+++ b/storage/perfschema/table_table_handles.cc
@@ -0,0 +1,214 @@
+/* Copyright (c) 2012, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_table_handles.cc
+ Table TABLE_TABLE_HANDLES (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "pfs_instr_class.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "table_table_handles.h"
+#include "pfs_global.h"
+#include "pfs_stat.h"
+#include "pfs_buffer_container.h"
+#include "field.h"
+
+THR_LOCK table_table_handles::m_table_lock;
+
+PFS_engine_table_share
+table_table_handles::m_share=
+{
+ { C_STRING_WITH_LEN("table_handles") },
+ &pfs_readonly_acl,
+ table_table_handles::create,
+ NULL, /* write_row */
+ NULL, /* delete_all_rows */
+ table_table_handles::get_row_count,
+ sizeof(PFS_simple_index),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE table_handles("
+ "OBJECT_TYPE VARCHAR(64) not null,"
+ "OBJECT_SCHEMA VARCHAR(64) not null,"
+ "OBJECT_NAME VARCHAR(64) not null,"
+ "OBJECT_INSTANCE_BEGIN BIGINT unsigned not null,"
+ "OWNER_THREAD_ID BIGINT unsigned,"
+ "OWNER_EVENT_ID BIGINT unsigned,"
+ "INTERNAL_LOCK VARCHAR(64),"
+ "EXTERNAL_LOCK VARCHAR(64))") },
+ false /* perpetual */
+};
+
+PFS_engine_table*
+table_table_handles::create(void)
+{
+ return new table_table_handles();
+}
+
+ha_rows
+table_table_handles::get_row_count(void)
+{
+ return global_table_container.get_row_count();
+}
+
+table_table_handles::table_table_handles()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(0), m_next_pos(0)
+{}
+
+void table_table_handles::reset_position(void)
+{
+ m_pos.m_index= 0;
+ m_next_pos.m_index= 0;
+}
+
+int table_table_handles::rnd_init(bool scan)
+{
+ return 0;
+}
+
+int table_table_handles::rnd_next(void)
+{
+ PFS_table *pfs;
+
+ m_pos.set_at(&m_next_pos);
+ PFS_table_iterator it= global_table_container.iterate(m_pos.m_index);
+ pfs= it.scan_next(& m_pos.m_index);
+ if (pfs != NULL)
+ {
+ make_row(pfs);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int
+table_table_handles::rnd_pos(const void *pos)
+{
+ PFS_table *pfs;
+
+ set_position(pos);
+
+ pfs= global_table_container.get(m_pos.m_index);
+ if (pfs != NULL)
+ {
+ make_row(pfs);
+ return 0;
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_table_handles::make_row(PFS_table *table)
+{
+ pfs_optimistic_state lock;
+ PFS_table_share *share;
+ PFS_thread *thread;
+
+ m_row_exists= false;
+
+ table->m_lock.begin_optimistic_lock(&lock);
+
+ share= sanitize_table_share(table->m_share);
+ if (share == NULL)
+ return;
+
+ if (m_row.m_object.make_row(share))
+ return;
+
+ m_row.m_identity= table->m_identity;
+
+ thread= sanitize_thread(table->m_thread_owner);
+ if (thread != NULL)
+ {
+ m_row.m_owner_thread_id= thread->m_thread_internal_id;
+ m_row.m_owner_event_id= table->m_owner_event_id;
+ }
+ else
+ {
+ m_row.m_owner_thread_id= 0;
+ m_row.m_owner_event_id= 0;
+ }
+
+ m_row.m_internal_lock= table->m_internal_lock;
+ m_row.m_external_lock= table->m_external_lock;
+
+ if (! table->m_lock.end_optimistic_lock(&lock))
+ return;
+
+ m_row_exists= true;
+}
+
+int table_table_handles::read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* OBJECT_TYPE */
+ case 1: /* SCHEMA_NAME */
+ case 2: /* OBJECT_NAME */
+ m_row.m_object.set_field(f->field_index, f);
+ break;
+ case 3: /* OBJECT_INSTANCE_BEGIN */
+ set_field_ulonglong(f, (intptr) m_row.m_identity);
+ break;
+ case 4: /* OWNER_THREAD_ID */
+ set_field_ulonglong(f, m_row.m_owner_thread_id);
+ break;
+ case 5: /* OWNER_EVENT_ID */
+ set_field_ulonglong(f, m_row.m_owner_event_id);
+ break;
+ case 6: /* INTERNAL_LOCK */
+ set_field_lock_type(f, m_row.m_internal_lock);
+ break;
+ case 7: /* EXTERNAL_LOCK */
+ set_field_lock_type(f, m_row.m_external_lock);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_table_handles.h b/storage/perfschema/table_table_handles.h
new file mode 100644
index 00000000..0f1f76f4
--- /dev/null
+++ b/storage/perfschema/table_table_handles.h
@@ -0,0 +1,108 @@
+/* Copyright (c) 2012, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_TABLE_HANDLES_H
+#define TABLE_TABLE_HANDLES_H
+
+/**
+ @file storage/perfschema/table_table_handles.h
+ Table TABLE_HANDLES (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "table_helper.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/**
+ A row of table
+ PERFORMANCE_SCHEMA.TABLE_HANDLES.
+*/
+struct row_table_handles
+{
+ /** Column OBJECT_TYPE, SCHEMA_NAME, OBJECT_NAME. */
+ PFS_object_row m_object;
+ /** Column OBJECT_INSTANCE_BEGIN. */
+ const void *m_identity;
+ /** Column OWNER_THREAD_ID. */
+ ulonglong m_owner_thread_id;
+ /** Column OWNER_EVENT_ID. */
+ ulonglong m_owner_event_id;
+ /** Column INTERNAL_LOCK. */
+ PFS_TL_LOCK_TYPE m_internal_lock;
+ /** Column EXTERNAL_LOCK. */
+ PFS_TL_LOCK_TYPE m_external_lock;
+};
+
+/** Table PERFORMANCE_SCHEMA.TABLE_HANDLES. */
+class table_table_handles : public PFS_engine_table
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static ha_rows get_row_count();
+
+ virtual int rnd_init(bool scan);
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_table_handles();
+
+public:
+ ~table_table_handles()
+ {}
+
+protected:
+ void make_row(PFS_table *table);
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+ /** Fields definition. */
+ static TABLE_FIELD_DEF m_field_def;
+
+ /** Current row. */
+ row_table_handles m_row;
+ /** True is the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ PFS_simple_index m_pos;
+ /** Next position. */
+ PFS_simple_index m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_threads.cc b/storage/perfschema/table_threads.cc
new file mode 100644
index 00000000..a752902c
--- /dev/null
+++ b/storage/perfschema/table_threads.cc
@@ -0,0 +1,365 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "table_threads.h"
+#include "sql_parse.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+
+THR_LOCK table_threads::m_table_lock;
+
+PFS_engine_table_share
+table_threads::m_share=
+{
+ { C_STRING_WITH_LEN("threads") },
+ &pfs_updatable_acl,
+ table_threads::create,
+ NULL, /* write_row */
+ NULL, /* delete_all_rows */
+ cursor_by_thread::get_row_count,
+ sizeof(PFS_simple_index), /* ref length */
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE threads("
+ "THREAD_ID BIGINT unsigned not null,"
+ "NAME VARCHAR(128) not null,"
+ "TYPE VARCHAR(10) not null,"
+ "PROCESSLIST_ID BIGINT unsigned,"
+ "PROCESSLIST_USER VARCHAR(" USERNAME_CHAR_LENGTH_STR "),"
+ "PROCESSLIST_HOST VARCHAR(" HOSTNAME_LENGTH_STR "),"
+ "PROCESSLIST_DB VARCHAR(64),"
+ "PROCESSLIST_COMMAND VARCHAR(16),"
+ "PROCESSLIST_TIME BIGINT,"
+ "PROCESSLIST_STATE VARCHAR(64),"
+ "PROCESSLIST_INFO LONGTEXT,"
+ "PARENT_THREAD_ID BIGINT unsigned,"
+ "ROLE VARCHAR(64),"
+ "INSTRUMENTED ENUM ('YES', 'NO') not null,"
+ "HISTORY ENUM ('YES', 'NO') not null,"
+ "CONNECTION_TYPE VARCHAR(16),"
+ "THREAD_OS_ID BIGINT unsigned)") },
+ false /* perpetual */
+};
+
+PFS_engine_table* table_threads::create()
+{
+ return new table_threads();
+}
+
+table_threads::table_threads()
+ : cursor_by_thread(& m_share),
+ m_row_exists(false)
+{}
+
+void table_threads::make_row(PFS_thread *pfs)
+{
+ pfs_optimistic_state lock;
+ pfs_optimistic_state session_lock;
+ pfs_optimistic_state stmt_lock;
+ PFS_stage_class *stage_class;
+ PFS_thread_class *safe_class;
+
+ m_row_exists= false;
+
+ /* Protect this reader against thread termination */
+ pfs->m_lock.begin_optimistic_lock(&lock);
+
+ safe_class= sanitize_thread_class(pfs->m_class);
+ if (unlikely(safe_class == NULL))
+ return;
+
+ m_row.m_thread_internal_id= pfs->m_thread_internal_id;
+ m_row.m_parent_thread_internal_id= pfs->m_parent_thread_internal_id;
+ m_row.m_processlist_id= pfs->m_processlist_id;
+ m_row.m_thread_os_id= pfs->m_thread_os_id;
+ m_row.m_name= safe_class->m_name;
+ m_row.m_name_length= safe_class->m_name_length;
+
+ /* Protect this reader against session attribute changes */
+ pfs->m_session_lock.begin_optimistic_lock(&session_lock);
+
+ m_row.m_username_length= pfs->m_username_length;
+ if (unlikely(m_row.m_username_length > sizeof(m_row.m_username)))
+ return;
+ if (m_row.m_username_length != 0)
+ memcpy(m_row.m_username, pfs->m_username, m_row.m_username_length);
+
+ m_row.m_hostname_length= pfs->m_hostname_length;
+ if (unlikely(m_row.m_hostname_length > sizeof(m_row.m_hostname)))
+ return;
+ if (m_row.m_hostname_length != 0)
+ memcpy(m_row.m_hostname, pfs->m_hostname, m_row.m_hostname_length);
+
+ if (! pfs->m_session_lock.end_optimistic_lock(& session_lock))
+ {
+ /*
+ One of the columns:
+ - PROCESSLIST_USER
+ - PROCESSLIST_HOST
+ is being updated.
+ Do not discard the entire row.
+ Do not loop waiting for a stable value.
+ Just return NULL values.
+ */
+ m_row.m_username_length= 0;
+ m_row.m_hostname_length= 0;
+ }
+
+ /* Protect this reader against statement attributes changes */
+ pfs->m_stmt_lock.begin_optimistic_lock(&stmt_lock);
+
+ m_row.m_dbname_length= pfs->m_dbname_length;
+ if (unlikely(m_row.m_dbname_length > sizeof(m_row.m_dbname)))
+ return;
+ if (m_row.m_dbname_length != 0)
+ memcpy(m_row.m_dbname, pfs->m_dbname, m_row.m_dbname_length);
+
+ m_row.m_processlist_info_ptr= & pfs->m_processlist_info[0];
+ m_row.m_processlist_info_length= pfs->m_processlist_info_length;
+
+ if (! pfs->m_stmt_lock.end_optimistic_lock(& stmt_lock))
+ {
+ /*
+ One of the columns:
+ - PROCESSLIST_DB
+ - PROCESSLIST_INFO
+ is being updated.
+ Do not discard the entire row.
+ Do not loop waiting for a stable value.
+ Just return NULL values.
+ */
+ m_row.m_dbname_length= 0;
+ m_row.m_processlist_info_length= 0;
+ }
+
+ /* Dirty read, sanitize the command. */
+ m_row.m_command= pfs->m_command;
+ if ((m_row.m_command < 0) || (m_row.m_command > COM_END))
+ m_row.m_command= COM_END;
+
+ m_row.m_start_time= pfs->m_start_time;
+
+ stage_class= find_stage_class(pfs->m_stage);
+ if (stage_class != NULL)
+ {
+ m_row.m_processlist_state_ptr= stage_class->m_name + stage_class->m_prefix_length;
+ m_row.m_processlist_state_length= stage_class->m_name_length - stage_class->m_prefix_length;
+ }
+ else
+ {
+ m_row.m_processlist_state_length= 0;
+ }
+ m_row.m_connection_type = pfs->m_connection_type;
+
+
+ m_row.m_enabled= pfs->m_enabled;
+ m_row.m_history= pfs->m_history;
+ m_row.m_psi= pfs;
+
+ if (pfs->m_lock.end_optimistic_lock(& lock))
+ m_row_exists= true;
+}
+
+int table_threads::read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+ const char *str= NULL;
+ size_t len= 0;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 2);
+ buf[0]= 0;
+ buf[1]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* THREAD_ID */
+ set_field_ulonglong(f, m_row.m_thread_internal_id);
+ break;
+ case 1: /* NAME */
+ set_field_varchar_utf8(f, m_row.m_name, m_row.m_name_length);
+ break;
+ case 2: /* TYPE */
+ if (m_row.m_processlist_id != 0)
+ set_field_varchar_utf8(f, "FOREGROUND", 10);
+ else
+ set_field_varchar_utf8(f, "BACKGROUND", 10);
+ break;
+ case 3: /* PROCESSLIST_ID */
+ if (m_row.m_processlist_id != 0)
+ set_field_ulonglong(f, m_row.m_processlist_id);
+ else
+ f->set_null();
+ break;
+ case 4: /* PROCESSLIST_USER */
+ if (m_row.m_username_length > 0)
+ set_field_varchar_utf8(f, m_row.m_username,
+ m_row.m_username_length);
+ else
+ f->set_null();
+ break;
+ case 5: /* PROCESSLIST_HOST */
+ if (m_row.m_hostname_length > 0)
+ set_field_varchar_utf8(f, m_row.m_hostname,
+ m_row.m_hostname_length);
+ else
+ f->set_null();
+ break;
+ case 6: /* PROCESSLIST_DB */
+ if (m_row.m_dbname_length > 0)
+ set_field_varchar_utf8(f, m_row.m_dbname,
+ m_row.m_dbname_length);
+ else
+ f->set_null();
+ break;
+ case 7: /* PROCESSLIST_COMMAND */
+ if (m_row.m_processlist_id != 0)
+ set_field_varchar_utf8(f, command_name[m_row.m_command].str,
+ (uint)command_name[m_row.m_command].length);
+ else
+ f->set_null();
+ break;
+ case 8: /* PROCESSLIST_TIME */
+ if (m_row.m_start_time)
+ {
+ time_t now= my_time(0);
+ ulonglong elapsed= (now > m_row.m_start_time ? now - m_row.m_start_time : 0);
+ set_field_ulonglong(f, elapsed);
+ }
+ else
+ f->set_null();
+ break;
+ case 9: /* PROCESSLIST_STATE */
+ /* This column's datatype is declared as varchar(64). Thread's state
+ message cannot be more than 64 characters. Otherwise, we will end up
+ in 'data truncated' warning/error (depends sql_mode setting) when
+ server is updating this column for those threads. To prevent this
+ kind of issue, an assert is added.
+ */
+ DBUG_ASSERT(m_row.m_processlist_state_length <= f->char_length());
+ if (m_row.m_processlist_state_length > 0)
+ set_field_varchar_utf8(f, m_row.m_processlist_state_ptr,
+ m_row.m_processlist_state_length);
+ else
+ f->set_null();
+ break;
+ case 10: /* PROCESSLIST_INFO */
+ if (m_row.m_processlist_info_length > 0)
+ set_field_longtext_utf8(f, m_row.m_processlist_info_ptr,
+ m_row.m_processlist_info_length);
+ else
+ f->set_null();
+ break;
+ case 11: /* PARENT_THREAD_ID */
+ if (m_row.m_parent_thread_internal_id != 0)
+ set_field_ulonglong(f, m_row.m_parent_thread_internal_id);
+ else
+ f->set_null();
+ break;
+ case 12: /* ROLE */
+ f->set_null();
+ break;
+ case 13: /* INSTRUMENTED */
+ set_field_enum(f, m_row.m_enabled ? ENUM_YES : ENUM_NO);
+ break;
+ case 14: /* HISTORY */
+ set_field_enum(f, m_row.m_history ? ENUM_YES : ENUM_NO);
+ break;
+ case 15: /* CONNECTION_TYPE */
+ str= vio_type_name(m_row.m_connection_type, & len);
+ if (len > 0)
+ set_field_varchar_utf8(f, str, (uint)len);
+ else
+ f->set_null();
+ break;
+ case 16: /* THREAD_OS_ID */
+ if (m_row.m_thread_os_id > 0)
+ set_field_ulonglong(f, m_row.m_thread_os_id);
+ else
+ f->set_null();
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+ return 0;
+}
+
+int table_threads::update_row_values(TABLE *table,
+ const unsigned char *old_buf,
+ const unsigned char *new_buf,
+ Field **fields)
+{
+ Field *f;
+ enum_yes_no value;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (bitmap_is_set(table->write_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* THREAD_ID */
+ case 1: /* NAME */
+ case 2: /* TYPE */
+ case 3: /* PROCESSLIST_ID */
+ case 4: /* PROCESSLIST_USER */
+ case 5: /* PROCESSLIST_HOST */
+ case 6: /* PROCESSLIST_DB */
+ case 7: /* PROCESSLIST_COMMAND */
+ case 8: /* PROCESSLIST_TIME */
+ case 9: /* PROCESSLIST_STATE */
+ case 10: /* PROCESSLIST_INFO */
+ case 11: /* PARENT_THREAD_ID */
+ case 12: /* ROLE */
+ return HA_ERR_WRONG_COMMAND;
+ case 13: /* INSTRUMENTED */
+ value= (enum_yes_no) get_field_enum(f);
+ m_row.m_psi->set_enabled((value == ENUM_YES) ? true : false);
+ break;
+ case 14: /* HISTORY */
+ value= (enum_yes_no) get_field_enum(f);
+ m_row.m_psi->set_history((value == ENUM_YES) ? true : false);
+ break;
+ case 15: /* CONNECTION_TYPE */
+ case 16: /* THREAD_OS_ID */
+ return HA_ERR_WRONG_COMMAND;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+ return 0;
+}
+
diff --git a/storage/perfschema/table_threads.h b/storage/perfschema/table_threads.h
new file mode 100644
index 00000000..88302ea6
--- /dev/null
+++ b/storage/perfschema/table_threads.h
@@ -0,0 +1,128 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_THREADS_H
+#define TABLE_THREADS_H
+
+#include "pfs_column_types.h"
+#include "cursor_by_thread.h"
+
+struct PFS_thread;
+
+/**
+ \addtogroup Performance_schema_tables
+ @{
+*/
+
+/**
+ A row of PERFORMANCE_SCHEMA.THREADS.
+*/
+struct row_threads
+{
+ /** Column THREAD_ID. */
+ ulonglong m_thread_internal_id;
+ /** Column PROCESSLIST_ID. */
+ ulonglong m_processlist_id;
+ /** Column NAME. */
+ const char* m_name;
+ /** Length in bytes of @c m_name. */
+ uint m_name_length;
+ /** Column PROCESSLIST_USER. */
+ char m_username[USERNAME_LENGTH];
+ /** Length in bytes of @c m_username. */
+ uint m_username_length;
+ /** Column PROCESSLIST_HOST. */
+ char m_hostname[HOSTNAME_LENGTH];
+ /** Length in bytes of @c m_hostname. */
+ uint m_hostname_length;
+ /** Column PROCESSLIST_DB. */
+ char m_dbname[NAME_LEN];
+ /** Length in bytes of @c m_dbname. */
+ uint m_dbname_length;
+ /** Column PROCESSLIST_COMMAND. */
+ int m_command;
+ /** Column PROCESSLIST_TIME. */
+ time_t m_start_time;
+ /** Column PROCESSLIST_STATE. */
+ const char* m_processlist_state_ptr;
+ /** Length in bytes of @c m_processlist_state_ptr. */
+ uint m_processlist_state_length;
+ /** Column PROCESSLIST_INFO. */
+ const char* m_processlist_info_ptr;
+ /** Length in bytes of @c m_processlist_info_ptr. */
+ uint m_processlist_info_length;
+ /** Column INSTRUMENTED (read). */
+ bool m_enabled;
+ /** Column HISTORY (read). */
+ bool m_history;
+ /** INSTRUMENTED and HISTORY (write). */
+ PFS_thread *m_psi;
+ /** Column PARENT_THREAD_ID. */
+ ulonglong m_parent_thread_internal_id;
+ /** Column CONNECTION_TYPE. */
+ enum_vio_type m_connection_type;
+ /** Column THREAD_OS_ID. */
+ my_thread_os_id_t m_thread_os_id;
+};
+
+/** Table PERFORMANCE_SCHEMA.THREADS. */
+class table_threads : public cursor_by_thread
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ /** Table builder */
+ static PFS_engine_table* create();
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+
+ virtual int update_row_values(TABLE *table,
+ const unsigned char *old_buf,
+ const unsigned char *new_buf,
+ Field **fields);
+
+protected:
+ table_threads();
+
+public:
+ ~table_threads()
+ {}
+
+private:
+ virtual void make_row(PFS_thread *pfs);
+
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ /** Current row. */
+ row_threads m_row;
+ /** True if the current row exists. */
+ bool m_row_exists;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_tiws_by_index_usage.cc b/storage/perfschema/table_tiws_by_index_usage.cc
new file mode 100644
index 00000000..a1a7343e
--- /dev/null
+++ b/storage/perfschema/table_tiws_by_index_usage.cc
@@ -0,0 +1,371 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_tiws_by_index_usage.cc
+ Table TABLE_IO_WAITS_SUMMARY_BY_INDEX_USAGE (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "pfs_instr_class.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "table_tiws_by_index_usage.h"
+#include "pfs_global.h"
+#include "pfs_visitor.h"
+#include "pfs_buffer_container.h"
+#include "field.h"
+
+THR_LOCK table_tiws_by_index_usage::m_table_lock;
+
+PFS_engine_table_share
+table_tiws_by_index_usage::m_share=
+{
+ { C_STRING_WITH_LEN("table_io_waits_summary_by_index_usage") },
+ &pfs_truncatable_acl,
+ table_tiws_by_index_usage::create,
+ NULL, /* write_row */
+ table_tiws_by_index_usage::delete_all_rows,
+ table_tiws_by_index_usage::get_row_count,
+ sizeof(pos_tiws_by_index_usage),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE table_io_waits_summary_by_index_usage("
+ "OBJECT_TYPE VARCHAR(64),"
+ "OBJECT_SCHEMA VARCHAR(64),"
+ "OBJECT_NAME VARCHAR(64),"
+ "INDEX_NAME VARCHAR(64),"
+ "COUNT_STAR BIGINT unsigned not null,"
+ "SUM_TIMER_WAIT BIGINT unsigned not null,"
+ "MIN_TIMER_WAIT BIGINT unsigned not null,"
+ "AVG_TIMER_WAIT BIGINT unsigned not null,"
+ "MAX_TIMER_WAIT BIGINT unsigned not null,"
+ "COUNT_READ BIGINT unsigned not null,"
+ "SUM_TIMER_READ BIGINT unsigned not null,"
+ "MIN_TIMER_READ BIGINT unsigned not null,"
+ "AVG_TIMER_READ BIGINT unsigned not null,"
+ "MAX_TIMER_READ BIGINT unsigned not null,"
+ "COUNT_WRITE BIGINT unsigned not null,"
+ "SUM_TIMER_WRITE BIGINT unsigned not null,"
+ "MIN_TIMER_WRITE BIGINT unsigned not null,"
+ "AVG_TIMER_WRITE BIGINT unsigned not null,"
+ "MAX_TIMER_WRITE BIGINT unsigned not null,"
+ "COUNT_FETCH BIGINT unsigned not null,"
+ "SUM_TIMER_FETCH BIGINT unsigned not null,"
+ "MIN_TIMER_FETCH BIGINT unsigned not null,"
+ "AVG_TIMER_FETCH BIGINT unsigned not null,"
+ "MAX_TIMER_FETCH BIGINT unsigned not null,"
+ "COUNT_INSERT BIGINT unsigned not null,"
+ "SUM_TIMER_INSERT BIGINT unsigned not null,"
+ "MIN_TIMER_INSERT BIGINT unsigned not null,"
+ "AVG_TIMER_INSERT BIGINT unsigned not null,"
+ "MAX_TIMER_INSERT BIGINT unsigned not null,"
+ "COUNT_UPDATE BIGINT unsigned not null,"
+ "SUM_TIMER_UPDATE BIGINT unsigned not null,"
+ "MIN_TIMER_UPDATE BIGINT unsigned not null,"
+ "AVG_TIMER_UPDATE BIGINT unsigned not null,"
+ "MAX_TIMER_UPDATE BIGINT unsigned not null,"
+ "COUNT_DELETE BIGINT unsigned not null,"
+ "SUM_TIMER_DELETE BIGINT unsigned not null,"
+ "MIN_TIMER_DELETE BIGINT unsigned not null,"
+ "AVG_TIMER_DELETE BIGINT unsigned not null,"
+ "MAX_TIMER_DELETE BIGINT unsigned not null)") },
+ false /* perpetual */
+};
+
+PFS_engine_table*
+table_tiws_by_index_usage::create(void)
+{
+ return new table_tiws_by_index_usage();
+}
+
+int
+table_tiws_by_index_usage::delete_all_rows(void)
+{
+ reset_table_io_waits_by_table_handle();
+ reset_table_io_waits_by_table();
+ return 0;
+}
+
+ha_rows
+table_tiws_by_index_usage::get_row_count(void)
+{
+ return global_table_share_index_container.get_row_count();
+}
+
+table_tiws_by_index_usage::table_tiws_by_index_usage()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(), m_next_pos()
+{}
+
+void table_tiws_by_index_usage::reset_position(void)
+{
+ m_pos.reset();
+ m_next_pos.reset();
+}
+
+int table_tiws_by_index_usage::rnd_init(bool scan)
+{
+ m_normalizer= time_normalizer::get(wait_timer);
+ return 0;
+}
+
+int table_tiws_by_index_usage::rnd_next(void)
+{
+ PFS_table_share *table_share;
+ bool has_more_table= true;
+
+ for (m_pos.set_at(&m_next_pos);
+ has_more_table;
+ m_pos.next_table())
+ {
+ table_share= global_table_share_container.get(m_pos.m_index_1, & has_more_table);
+ if (table_share != NULL)
+ {
+ if (table_share->m_enabled)
+ {
+ uint safe_key_count= sanitize_index_count(table_share->m_key_count);
+ if (m_pos.m_index_2 < safe_key_count)
+ {
+ make_row(table_share, m_pos.m_index_2);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ if (m_pos.m_index_2 <= MAX_INDEXES)
+ {
+ m_pos.m_index_2= MAX_INDEXES;
+ make_row(table_share, m_pos.m_index_2);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+ }
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int
+table_tiws_by_index_usage::rnd_pos(const void *pos)
+{
+ PFS_table_share *table_share;
+
+ set_position(pos);
+
+ table_share= global_table_share_container.get(m_pos.m_index_1);
+ if (table_share != NULL)
+ {
+ if (table_share->m_enabled)
+ {
+ uint safe_key_count= sanitize_index_count(table_share->m_key_count);
+ if (m_pos.m_index_2 < safe_key_count)
+ {
+ make_row(table_share, m_pos.m_index_2);
+ return 0;
+ }
+ if (m_pos.m_index_2 == MAX_INDEXES)
+ {
+ make_row(table_share, m_pos.m_index_2);
+ return 0;
+ }
+ }
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_tiws_by_index_usage::make_row(PFS_table_share *pfs_share,
+ uint index)
+{
+ PFS_table_share_index *pfs_index;
+ pfs_optimistic_state lock;
+
+ DBUG_ASSERT(index <= MAX_INDEXES);
+
+ m_row_exists= false;
+
+ pfs_share->m_lock.begin_optimistic_lock(&lock);
+
+ PFS_index_io_stat_visitor visitor;
+ PFS_object_iterator::visit_table_indexes(pfs_share, index, & visitor);
+
+ if (! visitor.m_stat.m_has_data)
+ {
+ pfs_index= pfs_share->find_index_stat(index);
+ if (pfs_index == NULL)
+ return;
+ }
+ else
+ {
+ pfs_index= pfs_share->find_index_stat(index);
+ }
+
+ if (m_row.m_index.make_row(pfs_share, pfs_index, index))
+ return;
+
+ if (! pfs_share->m_lock.end_optimistic_lock(&lock))
+ return;
+
+ m_row_exists= true;
+ m_row.m_stat.set(m_normalizer, & visitor.m_stat);
+}
+
+int table_tiws_by_index_usage::read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* OBJECT_TYPE */
+ case 1: /* SCHEMA_NAME */
+ case 2: /* OBJECT_NAME */
+ case 3: /* INDEX_NAME */
+ m_row.m_index.set_field(f->field_index, f);
+ break;
+ case 4: /* COUNT_STAR */
+ set_field_ulonglong(f, m_row.m_stat.m_all.m_count);
+ break;
+ case 5: /* SUM */
+ set_field_ulonglong(f, m_row.m_stat.m_all.m_sum);
+ break;
+ case 6: /* MIN */
+ set_field_ulonglong(f, m_row.m_stat.m_all.m_min);
+ break;
+ case 7: /* AVG */
+ set_field_ulonglong(f, m_row.m_stat.m_all.m_avg);
+ break;
+ case 8: /* MAX */
+ set_field_ulonglong(f, m_row.m_stat.m_all.m_max);
+ break;
+ case 9: /* COUNT_READ */
+ set_field_ulonglong(f, m_row.m_stat.m_all_read.m_count);
+ break;
+ case 10: /* SUM_READ */
+ set_field_ulonglong(f, m_row.m_stat.m_all_read.m_sum);
+ break;
+ case 11: /* MIN_READ */
+ set_field_ulonglong(f, m_row.m_stat.m_all_read.m_min);
+ break;
+ case 12: /* AVG_READ */
+ set_field_ulonglong(f, m_row.m_stat.m_all_read.m_avg);
+ break;
+ case 13: /* MAX_READ */
+ set_field_ulonglong(f, m_row.m_stat.m_all_read.m_max);
+ break;
+ case 14: /* COUNT_WRITE */
+ set_field_ulonglong(f, m_row.m_stat.m_all_write.m_count);
+ break;
+ case 15: /* SUM_WRITE */
+ set_field_ulonglong(f, m_row.m_stat.m_all_write.m_sum);
+ break;
+ case 16: /* MIN_WRITE */
+ set_field_ulonglong(f, m_row.m_stat.m_all_write.m_min);
+ break;
+ case 17: /* AVG_WRITE */
+ set_field_ulonglong(f, m_row.m_stat.m_all_write.m_avg);
+ break;
+ case 18: /* MAX_WRITE */
+ set_field_ulonglong(f, m_row.m_stat.m_all_write.m_max);
+ break;
+ case 19: /* COUNT_FETCH */
+ set_field_ulonglong(f, m_row.m_stat.m_fetch.m_count);
+ break;
+ case 20: /* SUM_FETCH */
+ set_field_ulonglong(f, m_row.m_stat.m_fetch.m_sum);
+ break;
+ case 21: /* MIN_FETCH */
+ set_field_ulonglong(f, m_row.m_stat.m_fetch.m_min);
+ break;
+ case 22: /* AVG_FETCH */
+ set_field_ulonglong(f, m_row.m_stat.m_fetch.m_avg);
+ break;
+ case 23: /* MAX_FETCH */
+ set_field_ulonglong(f, m_row.m_stat.m_fetch.m_max);
+ break;
+ case 24: /* COUNT_INSERT */
+ set_field_ulonglong(f, m_row.m_stat.m_insert.m_count);
+ break;
+ case 25: /* SUM_INSERT */
+ set_field_ulonglong(f, m_row.m_stat.m_insert.m_sum);
+ break;
+ case 26: /* MIN_INSERT */
+ set_field_ulonglong(f, m_row.m_stat.m_insert.m_min);
+ break;
+ case 27: /* AVG_INSERT */
+ set_field_ulonglong(f, m_row.m_stat.m_insert.m_avg);
+ break;
+ case 28: /* MAX_INSERT */
+ set_field_ulonglong(f, m_row.m_stat.m_insert.m_max);
+ break;
+ case 29: /* COUNT_UPDATE */
+ set_field_ulonglong(f, m_row.m_stat.m_update.m_count);
+ break;
+ case 30: /* SUM_UPDATE */
+ set_field_ulonglong(f, m_row.m_stat.m_update.m_sum);
+ break;
+ case 31: /* MIN_UPDATE */
+ set_field_ulonglong(f, m_row.m_stat.m_update.m_min);
+ break;
+ case 32: /* AVG_UPDATE */
+ set_field_ulonglong(f, m_row.m_stat.m_update.m_avg);
+ break;
+ case 33: /* MAX_UPDATE */
+ set_field_ulonglong(f, m_row.m_stat.m_update.m_max);
+ break;
+ case 34: /* COUNT_DELETE */
+ set_field_ulonglong(f, m_row.m_stat.m_delete.m_count);
+ break;
+ case 35: /* SUM_DELETE */
+ set_field_ulonglong(f, m_row.m_stat.m_delete.m_sum);
+ break;
+ case 36: /* MIN_DELETE */
+ set_field_ulonglong(f, m_row.m_stat.m_delete.m_min);
+ break;
+ case 37: /* AVG_DELETE */
+ set_field_ulonglong(f, m_row.m_stat.m_delete.m_avg);
+ break;
+ case 38: /* MAX_DELETE */
+ set_field_ulonglong(f, m_row.m_stat.m_delete.m_max);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_tiws_by_index_usage.h b/storage/perfschema/table_tiws_by_index_usage.h
new file mode 100644
index 00000000..cc6ee5eb
--- /dev/null
+++ b/storage/perfschema/table_tiws_by_index_usage.h
@@ -0,0 +1,124 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_IO_WAIT_SUMMARY_BY_INDEX_USAGE_H
+#define TABLE_IO_WAIT_SUMMARY_BY_INDEX_USAGE_H
+
+/**
+ @file storage/perfschema/table_tiws_by_index_usage.h
+ Table TABLE_IO_WAIT_SUMMARY_BY_INDEX_USAGE (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "table_helper.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/**
+ A row of table
+ PERFORMANCE_SCHEMA.TABLE_IO_WAIT_SUMMARY_BY_INDEX.
+*/
+struct row_tiws_by_index_usage
+{
+ /** Column OBJECT_TYPE, SCHEMA_NAME, OBJECT_NAME, INDEX_NAME. */
+ PFS_index_row m_index;
+ /** Columns COUNT/SUM/MIN/AVG/MAX (+_READ, +WRITE). */
+ PFS_table_io_stat_row m_stat;
+};
+
+/**
+ Position of a cursor on
+ PERFORMANCE_SCHEMA.TABLE_IO_WAIT_SUMMARY_BY_INDEX.
+ Index 1 on global_table_share_container (0 based)
+ Index 2 on index (0 based)
+*/
+struct pos_tiws_by_index_usage : public PFS_double_index
+{
+ pos_tiws_by_index_usage()
+ : PFS_double_index(0, 0)
+ {}
+
+ inline void reset(void)
+ {
+ m_index_1= 0;
+ m_index_2= 0;
+ }
+
+ inline void next_table(void)
+ {
+ m_index_1++;
+ m_index_2= 0;
+ }
+};
+
+/** Table PERFORMANCE_SCHEMA.TABLE_IO_WAIT_SUMMARY_BY_INDEX. */
+class table_tiws_by_index_usage : public PFS_engine_table
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_init(bool scan);
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_tiws_by_index_usage();
+
+public:
+ ~table_tiws_by_index_usage()
+ {}
+
+protected:
+ void make_row(PFS_table_share *table_share, uint index);
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ /** Current row. */
+ row_tiws_by_index_usage m_row;
+ /** True is the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ pos_tiws_by_index_usage m_pos;
+ /** Next position. */
+ pos_tiws_by_index_usage m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_tiws_by_table.cc b/storage/perfschema/table_tiws_by_table.cc
new file mode 100644
index 00000000..abd45a7b
--- /dev/null
+++ b/storage/perfschema/table_tiws_by_table.cc
@@ -0,0 +1,333 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_tiws_by_table.cc
+ Table TABLE_IO_WAITS_SUMMARY_BY_TABLE (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "pfs_instr_class.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "table_tiws_by_table.h"
+#include "pfs_global.h"
+#include "pfs_visitor.h"
+#include "pfs_buffer_container.h"
+#include "field.h"
+
+THR_LOCK table_tiws_by_table::m_table_lock;
+
+PFS_engine_table_share
+table_tiws_by_table::m_share=
+{
+ { C_STRING_WITH_LEN("table_io_waits_summary_by_table") },
+ &pfs_truncatable_acl,
+ table_tiws_by_table::create,
+ NULL, /* write_row */
+ table_tiws_by_table::delete_all_rows,
+ table_tiws_by_table::get_row_count,
+ sizeof(PFS_simple_index),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE table_io_waits_summary_by_table("
+ "OBJECT_TYPE VARCHAR(64),"
+ "OBJECT_SCHEMA VARCHAR(64),"
+ "OBJECT_NAME VARCHAR(64),"
+ "COUNT_STAR BIGINT unsigned not null,"
+ "SUM_TIMER_WAIT BIGINT unsigned not null,"
+ "MIN_TIMER_WAIT BIGINT unsigned not null,"
+ "AVG_TIMER_WAIT BIGINT unsigned not null,"
+ "MAX_TIMER_WAIT BIGINT unsigned not null,"
+ "COUNT_READ BIGINT unsigned not null,"
+ "SUM_TIMER_READ BIGINT unsigned not null,"
+ "MIN_TIMER_READ BIGINT unsigned not null,"
+ "AVG_TIMER_READ BIGINT unsigned not null,"
+ "MAX_TIMER_READ BIGINT unsigned not null,"
+ "COUNT_WRITE BIGINT unsigned not null,"
+ "SUM_TIMER_WRITE BIGINT unsigned not null,"
+ "MIN_TIMER_WRITE BIGINT unsigned not null,"
+ "AVG_TIMER_WRITE BIGINT unsigned not null,"
+ "MAX_TIMER_WRITE BIGINT unsigned not null,"
+ "COUNT_FETCH BIGINT unsigned not null,"
+ "SUM_TIMER_FETCH BIGINT unsigned not null,"
+ "MIN_TIMER_FETCH BIGINT unsigned not null,"
+ "AVG_TIMER_FETCH BIGINT unsigned not null,"
+ "MAX_TIMER_FETCH BIGINT unsigned not null,"
+ "COUNT_INSERT BIGINT unsigned not null,"
+ "SUM_TIMER_INSERT BIGINT unsigned not null,"
+ "MIN_TIMER_INSERT BIGINT unsigned not null,"
+ "AVG_TIMER_INSERT BIGINT unsigned not null,"
+ "MAX_TIMER_INSERT BIGINT unsigned not null,"
+ "COUNT_UPDATE BIGINT unsigned not null,"
+ "SUM_TIMER_UPDATE BIGINT unsigned not null,"
+ "MIN_TIMER_UPDATE BIGINT unsigned not null,"
+ "AVG_TIMER_UPDATE BIGINT unsigned not null,"
+ "MAX_TIMER_UPDATE BIGINT unsigned not null,"
+ "COUNT_DELETE BIGINT unsigned not null,"
+ "SUM_TIMER_DELETE BIGINT unsigned not null,"
+ "MIN_TIMER_DELETE BIGINT unsigned not null,"
+ "AVG_TIMER_DELETE BIGINT unsigned not null,"
+ "MAX_TIMER_DELETE BIGINT unsigned not null)") },
+ false /* perpetual */
+};
+
+PFS_engine_table*
+table_tiws_by_table::create(void)
+{
+ return new table_tiws_by_table();
+}
+
+int
+table_tiws_by_table::delete_all_rows(void)
+{
+ reset_table_io_waits_by_table_handle();
+ reset_table_io_waits_by_table();
+ return 0;
+}
+
+ha_rows
+table_tiws_by_table::get_row_count(void)
+{
+ return global_table_share_container.get_row_count();
+}
+
+table_tiws_by_table::table_tiws_by_table()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(0), m_next_pos(0)
+{}
+
+void table_tiws_by_table::reset_position(void)
+{
+ m_pos.m_index= 0;
+ m_next_pos.m_index= 0;
+}
+
+int table_tiws_by_table::rnd_init(bool scan)
+{
+ m_normalizer= time_normalizer::get(wait_timer);
+ return 0;
+}
+
+int table_tiws_by_table::rnd_next(void)
+{
+ PFS_table_share *pfs;
+
+ m_pos.set_at(&m_next_pos);
+ PFS_table_share_iterator it= global_table_share_container.iterate(m_pos.m_index);
+ do
+ {
+ pfs= it.scan_next(& m_pos.m_index);
+ if (pfs != NULL)
+ {
+ if (pfs->m_enabled)
+ {
+ make_row(pfs);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+ } while (pfs != NULL);
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int
+table_tiws_by_table::rnd_pos(const void *pos)
+{
+ PFS_table_share *pfs;
+
+ set_position(pos);
+
+ pfs= global_table_share_container.get(m_pos.m_index);
+ if (pfs != NULL)
+ {
+ if (pfs->m_enabled)
+ {
+ make_row(pfs);
+ return 0;
+ }
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_tiws_by_table::make_row(PFS_table_share *share)
+{
+ pfs_optimistic_state lock;
+
+ m_row_exists= false;
+
+ share->m_lock.begin_optimistic_lock(&lock);
+
+ if (m_row.m_object.make_row(share))
+ return;
+
+ PFS_table_io_stat_visitor visitor;
+ PFS_object_iterator::visit_tables(share, & visitor);
+
+ if (! share->m_lock.end_optimistic_lock(&lock))
+ return;
+
+ m_row_exists= true;
+ m_row.m_stat.set(m_normalizer, &visitor.m_stat);
+}
+
+int table_tiws_by_table::read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* OBJECT_TYPE */
+ case 1: /* SCHEMA_NAME */
+ case 2: /* OBJECT_NAME */
+ m_row.m_object.set_field(f->field_index, f);
+ break;
+ case 3: /* COUNT_STAR */
+ set_field_ulonglong(f, m_row.m_stat.m_all.m_count);
+ break;
+ case 4: /* SUM */
+ set_field_ulonglong(f, m_row.m_stat.m_all.m_sum);
+ break;
+ case 5: /* MIN */
+ set_field_ulonglong(f, m_row.m_stat.m_all.m_min);
+ break;
+ case 6: /* AVG */
+ set_field_ulonglong(f, m_row.m_stat.m_all.m_avg);
+ break;
+ case 7: /* MAX */
+ set_field_ulonglong(f, m_row.m_stat.m_all.m_max);
+ break;
+ case 8: /* COUNT_READ */
+ set_field_ulonglong(f, m_row.m_stat.m_all_read.m_count);
+ break;
+ case 9: /* SUM_READ */
+ set_field_ulonglong(f, m_row.m_stat.m_all_read.m_sum);
+ break;
+ case 10: /* MIN_READ */
+ set_field_ulonglong(f, m_row.m_stat.m_all_read.m_min);
+ break;
+ case 11: /* AVG_READ */
+ set_field_ulonglong(f, m_row.m_stat.m_all_read.m_avg);
+ break;
+ case 12: /* MAX_READ */
+ set_field_ulonglong(f, m_row.m_stat.m_all_read.m_max);
+ break;
+ case 13: /* COUNT_WRITE */
+ set_field_ulonglong(f, m_row.m_stat.m_all_write.m_count);
+ break;
+ case 14: /* SUM_WRITE */
+ set_field_ulonglong(f, m_row.m_stat.m_all_write.m_sum);
+ break;
+ case 15: /* MIN_WRITE */
+ set_field_ulonglong(f, m_row.m_stat.m_all_write.m_min);
+ break;
+ case 16: /* AVG_WRITE */
+ set_field_ulonglong(f, m_row.m_stat.m_all_write.m_avg);
+ break;
+ case 17: /* MAX_WRITE */
+ set_field_ulonglong(f, m_row.m_stat.m_all_write.m_max);
+ break;
+ case 18: /* COUNT_FETCH */
+ set_field_ulonglong(f, m_row.m_stat.m_fetch.m_count);
+ break;
+ case 19: /* SUM_FETCH */
+ set_field_ulonglong(f, m_row.m_stat.m_fetch.m_sum);
+ break;
+ case 20: /* MIN_FETCH */
+ set_field_ulonglong(f, m_row.m_stat.m_fetch.m_min);
+ break;
+ case 21: /* AVG_FETCH */
+ set_field_ulonglong(f, m_row.m_stat.m_fetch.m_avg);
+ break;
+ case 22: /* MAX_FETCH */
+ set_field_ulonglong(f, m_row.m_stat.m_fetch.m_max);
+ break;
+ case 23: /* COUNT_INSERT */
+ set_field_ulonglong(f, m_row.m_stat.m_insert.m_count);
+ break;
+ case 24: /* SUM_INSERT */
+ set_field_ulonglong(f, m_row.m_stat.m_insert.m_sum);
+ break;
+ case 25: /* MIN_INSERT */
+ set_field_ulonglong(f, m_row.m_stat.m_insert.m_min);
+ break;
+ case 26: /* AVG_INSERT */
+ set_field_ulonglong(f, m_row.m_stat.m_insert.m_avg);
+ break;
+ case 27: /* MAX_INSERT */
+ set_field_ulonglong(f, m_row.m_stat.m_insert.m_max);
+ break;
+ case 28: /* COUNT_UPDATE */
+ set_field_ulonglong(f, m_row.m_stat.m_update.m_count);
+ break;
+ case 29: /* SUM_UPDATE */
+ set_field_ulonglong(f, m_row.m_stat.m_update.m_sum);
+ break;
+ case 30: /* MIN_UPDATE */
+ set_field_ulonglong(f, m_row.m_stat.m_update.m_min);
+ break;
+ case 31: /* AVG_UPDATE */
+ set_field_ulonglong(f, m_row.m_stat.m_update.m_avg);
+ break;
+ case 32: /* MAX_UPDATE */
+ set_field_ulonglong(f, m_row.m_stat.m_update.m_max);
+ break;
+ case 33: /* COUNT_DELETE */
+ set_field_ulonglong(f, m_row.m_stat.m_delete.m_count);
+ break;
+ case 34: /* SUM_DELETE */
+ set_field_ulonglong(f, m_row.m_stat.m_delete.m_sum);
+ break;
+ case 35: /* MIN_DELETE */
+ set_field_ulonglong(f, m_row.m_stat.m_delete.m_min);
+ break;
+ case 36: /* AVG_DELETE */
+ set_field_ulonglong(f, m_row.m_stat.m_delete.m_avg);
+ break;
+ case 37: /* MAX_DELETE */
+ set_field_ulonglong(f, m_row.m_stat.m_delete.m_max);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_tiws_by_table.h b/storage/perfschema/table_tiws_by_table.h
new file mode 100644
index 00000000..4100a991
--- /dev/null
+++ b/storage/perfschema/table_tiws_by_table.h
@@ -0,0 +1,99 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_IO_WAITS_SUMMARY_BY_TABLE_H
+#define TABLE_IO_WAITS_SUMMARY_BY_TABLE_H
+
+/**
+ @file storage/perfschema/table_tiws_by_table.h
+ Table TABLE_IO_WAITS_SUMMARY_BY_TABLE (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "table_helper.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/**
+ A row of table
+ PERFORMANCE_SCHEMA.TABLE_IO_WAITS_SUMMARY_BY_TABLE.
+*/
+struct row_tiws_by_table
+{
+ /** Column OBJECT_TYPE, SCHEMA_NAME, OBJECT_NAME. */
+ PFS_object_row m_object;
+ /** Columns COUNT/SUM/MIN/AVG/MAX (+_READ, +WRITE). */
+ PFS_table_io_stat_row m_stat;
+};
+
+/** Table PERFORMANCE_SCHEMA.TABLE_IO_WAITS_SUMMARY_BY_TABLE. */
+class table_tiws_by_table : public PFS_engine_table
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_init(bool scan);
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_tiws_by_table();
+
+public:
+ ~table_tiws_by_table()
+ {}
+
+protected:
+ void make_row(PFS_table_share *table_share);
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ /** Current row. */
+ row_tiws_by_table m_row;
+ /** True is the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ PFS_simple_index m_pos;
+ /** Next position. */
+ PFS_simple_index m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_tlws_by_table.cc b/storage/perfschema/table_tlws_by_table.cc
new file mode 100644
index 00000000..8f4bc2ae
--- /dev/null
+++ b/storage/perfschema/table_tlws_by_table.cc
@@ -0,0 +1,485 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/**
+ @file storage/perfschema/table_tlws_by_table.cc
+ Table TABLE_LOCK_WAITS_SUMMARY_BY_TABLE (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "pfs_instr_class.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "table_tlws_by_table.h"
+#include "pfs_global.h"
+#include "pfs_visitor.h"
+#include "pfs_buffer_container.h"
+#include "field.h"
+
+THR_LOCK table_tlws_by_table::m_table_lock;
+
+PFS_engine_table_share
+table_tlws_by_table::m_share=
+{
+ { C_STRING_WITH_LEN("table_lock_waits_summary_by_table") },
+ &pfs_truncatable_acl,
+ table_tlws_by_table::create,
+ NULL, /* write_row */
+ table_tlws_by_table::delete_all_rows,
+ table_tlws_by_table::get_row_count,
+ sizeof(PFS_simple_index),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE table_lock_waits_summary_by_table("
+ "OBJECT_TYPE VARCHAR(64),"
+ "OBJECT_SCHEMA VARCHAR(64),"
+ "OBJECT_NAME VARCHAR(64),"
+ "COUNT_STAR BIGINT unsigned not null,"
+ "SUM_TIMER_WAIT BIGINT unsigned not null,"
+ "MIN_TIMER_WAIT BIGINT unsigned not null,"
+ "AVG_TIMER_WAIT BIGINT unsigned not null,"
+ "MAX_TIMER_WAIT BIGINT unsigned not null,"
+ "COUNT_READ BIGINT unsigned not null,"
+ "SUM_TIMER_READ BIGINT unsigned not null,"
+ "MIN_TIMER_READ BIGINT unsigned not null,"
+ "AVG_TIMER_READ BIGINT unsigned not null,"
+ "MAX_TIMER_READ BIGINT unsigned not null,"
+ "COUNT_WRITE BIGINT unsigned not null,"
+ "SUM_TIMER_WRITE BIGINT unsigned not null,"
+ "MIN_TIMER_WRITE BIGINT unsigned not null,"
+ "AVG_TIMER_WRITE BIGINT unsigned not null,"
+ "MAX_TIMER_WRITE BIGINT unsigned not null,"
+ "COUNT_READ_NORMAL BIGINT unsigned not null,"
+ "SUM_TIMER_READ_NORMAL BIGINT unsigned not null,"
+ "MIN_TIMER_READ_NORMAL BIGINT unsigned not null,"
+ "AVG_TIMER_READ_NORMAL BIGINT unsigned not null,"
+ "MAX_TIMER_READ_NORMAL BIGINT unsigned not null,"
+ "COUNT_READ_WITH_SHARED_LOCKS BIGINT unsigned not null,"
+ "SUM_TIMER_READ_WITH_SHARED_LOCKS BIGINT unsigned not null,"
+ "MIN_TIMER_READ_WITH_SHARED_LOCKS BIGINT unsigned not null,"
+ "AVG_TIMER_READ_WITH_SHARED_LOCKS BIGINT unsigned not null,"
+ "MAX_TIMER_READ_WITH_SHARED_LOCKS BIGINT unsigned not null,"
+ "COUNT_READ_HIGH_PRIORITY BIGINT unsigned not null,"
+ "SUM_TIMER_READ_HIGH_PRIORITY BIGINT unsigned not null,"
+ "MIN_TIMER_READ_HIGH_PRIORITY BIGINT unsigned not null,"
+ "AVG_TIMER_READ_HIGH_PRIORITY BIGINT unsigned not null,"
+ "MAX_TIMER_READ_HIGH_PRIORITY BIGINT unsigned not null,"
+ "COUNT_READ_NO_INSERT BIGINT unsigned not null,"
+ "SUM_TIMER_READ_NO_INSERT BIGINT unsigned not null,"
+ "MIN_TIMER_READ_NO_INSERT BIGINT unsigned not null,"
+ "AVG_TIMER_READ_NO_INSERT BIGINT unsigned not null,"
+ "MAX_TIMER_READ_NO_INSERT BIGINT unsigned not null,"
+ "COUNT_READ_EXTERNAL BIGINT unsigned not null,"
+ "SUM_TIMER_READ_EXTERNAL BIGINT unsigned not null,"
+ "MIN_TIMER_READ_EXTERNAL BIGINT unsigned not null,"
+ "AVG_TIMER_READ_EXTERNAL BIGINT unsigned not null,"
+ "MAX_TIMER_READ_EXTERNAL BIGINT unsigned not null,"
+ "COUNT_WRITE_ALLOW_WRITE BIGINT unsigned not null,"
+ "SUM_TIMER_WRITE_ALLOW_WRITE BIGINT unsigned not null,"
+ "MIN_TIMER_WRITE_ALLOW_WRITE BIGINT unsigned not null,"
+ "AVG_TIMER_WRITE_ALLOW_WRITE BIGINT unsigned not null,"
+ "MAX_TIMER_WRITE_ALLOW_WRITE BIGINT unsigned not null,"
+ "COUNT_WRITE_CONCURRENT_INSERT BIGINT unsigned not null,"
+ "SUM_TIMER_WRITE_CONCURRENT_INSERT BIGINT unsigned not null,"
+ "MIN_TIMER_WRITE_CONCURRENT_INSERT BIGINT unsigned not null,"
+ "AVG_TIMER_WRITE_CONCURRENT_INSERT BIGINT unsigned not null,"
+ "MAX_TIMER_WRITE_CONCURRENT_INSERT BIGINT unsigned not null,"
+ "COUNT_WRITE_DELAYED BIGINT unsigned not null,"
+ "SUM_TIMER_WRITE_DELAYED BIGINT unsigned not null,"
+ "MIN_TIMER_WRITE_DELAYED BIGINT unsigned not null,"
+ "AVG_TIMER_WRITE_DELAYED BIGINT unsigned not null,"
+ "MAX_TIMER_WRITE_DELAYED BIGINT unsigned not null,"
+ "COUNT_WRITE_LOW_PRIORITY BIGINT unsigned not null,"
+ "SUM_TIMER_WRITE_LOW_PRIORITY BIGINT unsigned not null,"
+ "MIN_TIMER_WRITE_LOW_PRIORITY BIGINT unsigned not null,"
+ "AVG_TIMER_WRITE_LOW_PRIORITY BIGINT unsigned not null,"
+ "MAX_TIMER_WRITE_LOW_PRIORITY BIGINT unsigned not null,"
+ "COUNT_WRITE_NORMAL BIGINT unsigned not null,"
+ "SUM_TIMER_WRITE_NORMAL BIGINT unsigned not null,"
+ "MIN_TIMER_WRITE_NORMAL BIGINT unsigned not null,"
+ "AVG_TIMER_WRITE_NORMAL BIGINT unsigned not null,"
+ "MAX_TIMER_WRITE_NORMAL BIGINT unsigned not null,"
+ "COUNT_WRITE_EXTERNAL BIGINT unsigned not null,"
+ "SUM_TIMER_WRITE_EXTERNAL BIGINT unsigned not null,"
+ "MIN_TIMER_WRITE_EXTERNAL BIGINT unsigned not null,"
+ "AVG_TIMER_WRITE_EXTERNAL BIGINT unsigned not null,"
+ "MAX_TIMER_WRITE_EXTERNAL BIGINT unsigned not null)") },
+ false /* perpetual */
+};
+
+PFS_engine_table*
+table_tlws_by_table::create(void)
+{
+ return new table_tlws_by_table();
+}
+
+int
+table_tlws_by_table::delete_all_rows(void)
+{
+ reset_table_lock_waits_by_table_handle();
+ reset_table_lock_waits_by_table();
+ return 0;
+}
+
+ha_rows
+table_tlws_by_table::get_row_count(void)
+{
+ return global_table_share_container.get_row_count();
+}
+
+table_tlws_by_table::table_tlws_by_table()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(0), m_next_pos(0)
+{}
+
+void table_tlws_by_table::reset_position(void)
+{
+ m_pos.m_index= 0;
+ m_next_pos.m_index= 0;
+}
+
+int table_tlws_by_table::rnd_init(bool scan)
+{
+ m_normalizer= time_normalizer::get(wait_timer);
+ return 0;
+}
+
+int table_tlws_by_table::rnd_next(void)
+{
+ PFS_table_share *pfs;
+
+ m_pos.set_at(&m_next_pos);
+ PFS_table_share_iterator it= global_table_share_container.iterate(m_pos.m_index);
+ do
+ {
+ pfs= it.scan_next(& m_pos.m_index);
+ if (pfs != NULL)
+ {
+ if (pfs->m_enabled)
+ {
+ make_row(pfs);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+ } while (pfs != NULL);
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int
+table_tlws_by_table::rnd_pos(const void *pos)
+{
+ PFS_table_share *pfs;
+
+ set_position(pos);
+
+ pfs= global_table_share_container.get(m_pos.m_index);
+ if (pfs != NULL)
+ {
+ if (pfs->m_enabled)
+ {
+ make_row(pfs);
+ return 0;
+ }
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_tlws_by_table::make_row(PFS_table_share *share)
+{
+ pfs_optimistic_state lock;
+
+ m_row_exists= false;
+
+ share->m_lock.begin_optimistic_lock(&lock);
+
+ if (m_row.m_object.make_row(share))
+ return;
+
+ PFS_table_lock_stat_visitor visitor;
+ PFS_object_iterator::visit_tables(share, & visitor);
+
+ if (! share->m_lock.end_optimistic_lock(&lock))
+ return;
+
+ m_row_exists= true;
+ m_row.m_stat.set(m_normalizer, &visitor.m_stat);
+}
+
+int table_tlws_by_table::read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* OBJECT_TYPE */
+ case 1: /* SCHEMA_NAME */
+ case 2: /* OBJECT_NAME */
+ m_row.m_object.set_field(f->field_index, f);
+ break;
+ case 3: /* COUNT_STAR */
+ set_field_ulonglong(f, m_row.m_stat.m_all.m_count);
+ break;
+ case 4: /* SUM_TIMER */
+ set_field_ulonglong(f, m_row.m_stat.m_all.m_sum);
+ break;
+ case 5: /* MIN_TIMER */
+ set_field_ulonglong(f, m_row.m_stat.m_all.m_min);
+ break;
+ case 6: /* AVG_TIMER */
+ set_field_ulonglong(f, m_row.m_stat.m_all.m_avg);
+ break;
+ case 7: /* MAX_TIMER */
+ set_field_ulonglong(f, m_row.m_stat.m_all.m_max);
+ break;
+ case 8: /* COUNT_READ */
+ set_field_ulonglong(f, m_row.m_stat.m_all_read.m_count);
+ break;
+ case 9: /* SUM_TIMER_READ */
+ set_field_ulonglong(f, m_row.m_stat.m_all_read.m_sum);
+ break;
+ case 10: /* MIN_TIMER_READ */
+ set_field_ulonglong(f, m_row.m_stat.m_all_read.m_min);
+ break;
+ case 11: /* AVG_TIMER_READ */
+ set_field_ulonglong(f, m_row.m_stat.m_all_read.m_avg);
+ break;
+ case 12: /* MAX_TIMER_READ */
+ set_field_ulonglong(f, m_row.m_stat.m_all_read.m_max);
+ break;
+ case 13: /* COUNT_WRITE */
+ set_field_ulonglong(f, m_row.m_stat.m_all_write.m_count);
+ break;
+ case 14: /* SUM_TIMER_WRITE */
+ set_field_ulonglong(f, m_row.m_stat.m_all_write.m_sum);
+ break;
+ case 15: /* MIN_TIMER_WRITE */
+ set_field_ulonglong(f, m_row.m_stat.m_all_write.m_min);
+ break;
+ case 16: /* AVG_TIMER_WRITE */
+ set_field_ulonglong(f, m_row.m_stat.m_all_write.m_avg);
+ break;
+ case 17: /* MAX_TIMER_WRITE */
+ set_field_ulonglong(f, m_row.m_stat.m_all_write.m_max);
+ break;
+
+ case 18: /* COUNT_READ_NORMAL */
+ set_field_ulonglong(f, m_row.m_stat.m_read_normal.m_count);
+ break;
+ case 19: /* SUM_TIMER_READ_NORMAL */
+ set_field_ulonglong(f, m_row.m_stat.m_read_normal.m_sum);
+ break;
+ case 20: /* MIN_TIMER_READ_NORMAL */
+ set_field_ulonglong(f, m_row.m_stat.m_read_normal.m_min);
+ break;
+ case 21: /* AVG_TIMER_READ_NORMAL */
+ set_field_ulonglong(f, m_row.m_stat.m_read_normal.m_avg);
+ break;
+ case 22: /* MAX_TIMER_READ_NORMAL */
+ set_field_ulonglong(f, m_row.m_stat.m_read_normal.m_max);
+ break;
+
+ case 23: /* COUNT_READ_WITH_SHARED_LOCKS */
+ set_field_ulonglong(f, m_row.m_stat.m_read_with_shared_locks.m_count);
+ break;
+ case 24: /* SUM_TIMER_READ_WITH_SHARED_LOCKS */
+ set_field_ulonglong(f, m_row.m_stat.m_read_with_shared_locks.m_sum);
+ break;
+ case 25: /* MIN_TIMER_READ_WITH_SHARED_LOCKS */
+ set_field_ulonglong(f, m_row.m_stat.m_read_with_shared_locks.m_min);
+ break;
+ case 26: /* AVG_TIMER_READ_WITH_SHARED_LOCKS */
+ set_field_ulonglong(f, m_row.m_stat.m_read_with_shared_locks.m_avg);
+ break;
+ case 27: /* MAX_TIMER_READ_WITH_SHARED_LOCKS */
+ set_field_ulonglong(f, m_row.m_stat.m_read_with_shared_locks.m_max);
+ break;
+
+ case 28: /* COUNT_READ_HIGH_PRIORITY */
+ set_field_ulonglong(f, m_row.m_stat.m_read_high_priority.m_count);
+ break;
+ case 29: /* SUM_TIMER_READ_HIGH_PRIORITY */
+ set_field_ulonglong(f, m_row.m_stat.m_read_high_priority.m_sum);
+ break;
+ case 30: /* MIN_TIMER_READ_HIGH_PRIORITY */
+ set_field_ulonglong(f, m_row.m_stat.m_read_high_priority.m_min);
+ break;
+ case 31: /* AVG_TIMER_READ_HIGH_PRIORITY */
+ set_field_ulonglong(f, m_row.m_stat.m_read_high_priority.m_avg);
+ break;
+ case 32: /* MAX_TIMER_READ_HIGH_PRIORITY */
+ set_field_ulonglong(f, m_row.m_stat.m_read_high_priority.m_max);
+ break;
+
+ case 33: /* COUNT_READ_NO_INSERT */
+ set_field_ulonglong(f, m_row.m_stat.m_read_no_insert.m_count);
+ break;
+ case 34: /* SUM_TIMER_READ_NO_INSERT */
+ set_field_ulonglong(f, m_row.m_stat.m_read_no_insert.m_sum);
+ break;
+ case 35: /* MIN_TIMER_READ_NO_INSERT */
+ set_field_ulonglong(f, m_row.m_stat.m_read_no_insert.m_min);
+ break;
+ case 36: /* AVG_TIMER_READ_NO_INSERT */
+ set_field_ulonglong(f, m_row.m_stat.m_read_no_insert.m_avg);
+ break;
+ case 37: /* MAX_TIMER_READ_NO_INSERT */
+ set_field_ulonglong(f, m_row.m_stat.m_read_no_insert.m_max);
+ break;
+
+ case 38: /* COUNT_READ_EXTERNAL */
+ set_field_ulonglong(f, m_row.m_stat.m_read_external.m_count);
+ break;
+ case 39: /* SUM_TIMER_READ_EXTERNAL */
+ set_field_ulonglong(f, m_row.m_stat.m_read_external.m_sum);
+ break;
+ case 40: /* MIN_TIMER_READ_EXTERNAL */
+ set_field_ulonglong(f, m_row.m_stat.m_read_external.m_min);
+ break;
+ case 41: /* AVG_TIMER_READ_EXTERNAL */
+ set_field_ulonglong(f, m_row.m_stat.m_read_external.m_avg);
+ break;
+ case 42: /* MAX_TIMER_READ_EXTERNAL */
+ set_field_ulonglong(f, m_row.m_stat.m_read_external.m_max);
+ break;
+
+ case 43: /* COUNT_WRITE_ALLOW_WRITE */
+ set_field_ulonglong(f, m_row.m_stat.m_write_allow_write.m_count);
+ break;
+ case 44: /* SUM_TIMER_WRITE_ALLOW_WRITE */
+ set_field_ulonglong(f, m_row.m_stat.m_write_allow_write.m_sum);
+ break;
+ case 45: /* MIN_TIMER_WRITE_ALLOW_WRITE */
+ set_field_ulonglong(f, m_row.m_stat.m_write_allow_write.m_min);
+ break;
+ case 46: /* AVG_TIMER_WRITE_ALLOW_WRITE */
+ set_field_ulonglong(f, m_row.m_stat.m_write_allow_write.m_avg);
+ break;
+ case 47: /* MAX_TIMER_WRITE_ALLOW_WRITE */
+ set_field_ulonglong(f, m_row.m_stat.m_write_allow_write.m_max);
+ break;
+
+ case 48: /* COUNT_WRITE_CONCURRENT_INSERT */
+ set_field_ulonglong(f, m_row.m_stat.m_write_concurrent_insert.m_count);
+ break;
+ case 49: /* SUM_TIMER_WRITE_CONCURRENT_INSERT */
+ set_field_ulonglong(f, m_row.m_stat.m_write_concurrent_insert.m_sum);
+ break;
+ case 50: /* MIN_TIMER_WRITE_CONCURRENT_INSERT */
+ set_field_ulonglong(f, m_row.m_stat.m_write_concurrent_insert.m_min);
+ break;
+ case 51: /* AVG_TIMER_WRITE_CONCURRENT_INSERT */
+ set_field_ulonglong(f, m_row.m_stat.m_write_concurrent_insert.m_avg);
+ break;
+ case 52: /* MAX_TIMER_WRITE_CONCURRENT_INSERT */
+ set_field_ulonglong(f, m_row.m_stat.m_write_concurrent_insert.m_max);
+ break;
+
+ case 53: /* COUNT_WRITE_DELAYED */
+ set_field_ulonglong(f, m_row.m_stat.m_write_delayed.m_count);
+ break;
+ case 54: /* SUM_TIMER_WRITE_DELAYED */
+ set_field_ulonglong(f, m_row.m_stat.m_write_delayed.m_sum);
+ break;
+ case 55: /* MIN_TIMER_WRITE_DELAYED */
+ set_field_ulonglong(f, m_row.m_stat.m_write_delayed.m_min);
+ break;
+ case 56: /* AVG_TIMER_WRITE_DELAYED */
+ set_field_ulonglong(f, m_row.m_stat.m_write_delayed.m_avg);
+ break;
+ case 57: /* MAX_TIMER_WRITE_DELAYED */
+ set_field_ulonglong(f, m_row.m_stat.m_write_delayed.m_max);
+ break;
+
+ case 58: /* COUNT_WRITE_LOW_PRIORITY */
+ set_field_ulonglong(f, m_row.m_stat.m_write_low_priority.m_count);
+ break;
+ case 59: /* SUM_TIMER_WRITE_LOW_PRIORITY */
+ set_field_ulonglong(f, m_row.m_stat.m_write_low_priority.m_sum);
+ break;
+ case 60: /* MIN_TIMER_WRITE_LOW_PRIORITY */
+ set_field_ulonglong(f, m_row.m_stat.m_write_low_priority.m_min);
+ break;
+ case 61: /* AVG_TIMER_WRITE_LOW_PRIORITY */
+ set_field_ulonglong(f, m_row.m_stat.m_write_low_priority.m_avg);
+ break;
+ case 62: /* MAX_TIMER_WRITE_LOW_PRIORITY */
+ set_field_ulonglong(f, m_row.m_stat.m_write_low_priority.m_max);
+ break;
+
+ case 63: /* COUNT_WRITE_NORMAL */
+ set_field_ulonglong(f, m_row.m_stat.m_write_normal.m_count);
+ break;
+ case 64: /* SUM_TIMER_WRITE_NORMAL */
+ set_field_ulonglong(f, m_row.m_stat.m_write_normal.m_sum);
+ break;
+ case 65: /* MIN_TIMER_WRITE_NORMAL */
+ set_field_ulonglong(f, m_row.m_stat.m_write_normal.m_min);
+ break;
+ case 66: /* AVG_TIMER_WRITE_NORMAL */
+ set_field_ulonglong(f, m_row.m_stat.m_write_normal.m_avg);
+ break;
+ case 67: /* MAX_TIMER_WRITE_NORMAL */
+ set_field_ulonglong(f, m_row.m_stat.m_write_normal.m_max);
+ break;
+
+ case 68: /* COUNT_WRITE_EXTERNAL */
+ set_field_ulonglong(f, m_row.m_stat.m_write_external.m_count);
+ break;
+ case 69: /* SUM_TIMER_WRITE_EXTERNAL */
+ set_field_ulonglong(f, m_row.m_stat.m_write_external.m_sum);
+ break;
+ case 70: /* MIN_TIMER_WRITE_EXTERNAL */
+ set_field_ulonglong(f, m_row.m_stat.m_write_external.m_min);
+ break;
+ case 71: /* AVG_TIMER_WRITE_EXTERNAL */
+ set_field_ulonglong(f, m_row.m_stat.m_write_external.m_avg);
+ break;
+ case 72: /* MAX_TIMER_WRITE_EXTERNAL */
+ set_field_ulonglong(f, m_row.m_stat.m_write_external.m_max);
+ break;
+
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_tlws_by_table.h b/storage/perfschema/table_tlws_by_table.h
new file mode 100644
index 00000000..7cc4b666
--- /dev/null
+++ b/storage/perfschema/table_tlws_by_table.h
@@ -0,0 +1,99 @@
+/* Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_LOCK_WAITS_SUMMARY_BY_TABLE_H
+#define TABLE_LOCK_WAITS_SUMMARY_BY_TABLE_H
+
+/**
+ @file storage/perfschema/table_tlws_by_table.h
+ Table TABLE_LOCK_WAITS_SUMMARY_BY_TABLE (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "table_helper.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/**
+ A row of table
+ PERFORMANCE_SCHEMA.TABLE_LOCK_WAITS_SUMMARY_BY_TABLE.
+*/
+struct row_tlws_by_table
+{
+ /** Column OBJECT_TYPE, SCHEMA_NAME, OBJECT_NAME. */
+ PFS_object_row m_object;
+ /** Columns COUNT/SUM/MIN/AVG/MAX READ/WRITE/READ_NORMAL/etc. */
+ PFS_table_lock_stat_row m_stat;
+};
+
+/** Table PERFORMANCE_SCHEMA.TABLE_LOCK_WAITS_SUMMARY_BY_TABLE. */
+class table_tlws_by_table : public PFS_engine_table
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+ static ha_rows get_row_count();
+
+ virtual int rnd_init(bool scan);
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_tlws_by_table();
+
+public:
+ ~table_tlws_by_table()
+ {}
+
+protected:
+ void make_row(PFS_table_share *table_share);
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ /** Current row. */
+ row_tlws_by_table m_row;
+ /** True is the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ PFS_simple_index m_pos;
+ /** Next position. */
+ PFS_simple_index m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_users.cc b/storage/perfschema/table_users.cc
new file mode 100644
index 00000000..734ff7a4
--- /dev/null
+++ b/storage/perfschema/table_users.cc
@@ -0,0 +1,149 @@
+/* Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "table_users.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "pfs_account.h"
+#include "pfs_user.h"
+#include "pfs_visitor.h"
+#include "pfs_memory.h"
+#include "pfs_status.h"
+#include "field.h"
+
+THR_LOCK table_users::m_table_lock;
+
+PFS_engine_table_share
+table_users::m_share=
+{
+ { C_STRING_WITH_LEN("users") },
+ &pfs_truncatable_acl,
+ table_users::create,
+ NULL, /* write_row */
+ table_users::delete_all_rows,
+ cursor_by_user::get_row_count,
+ sizeof(PFS_simple_index), /* ref length */
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE users("
+ "USER CHAR(" USERNAME_CHAR_LENGTH_STR ") collate utf8_bin default null,"
+ "CURRENT_CONNECTIONS bigint not null,"
+ "TOTAL_CONNECTIONS bigint not null)") },
+ false /* perpetual */
+};
+
+PFS_engine_table* table_users::create()
+{
+ return new table_users();
+}
+
+int
+table_users::delete_all_rows(void)
+{
+ reset_events_waits_by_thread();
+ reset_events_waits_by_account();
+ reset_events_waits_by_user();
+ reset_events_stages_by_thread();
+ reset_events_stages_by_account();
+ reset_events_stages_by_user();
+ reset_events_statements_by_thread();
+ reset_events_statements_by_account();
+ reset_events_statements_by_user();
+ reset_events_transactions_by_thread();
+ reset_events_transactions_by_account();
+ reset_events_transactions_by_user();
+ reset_memory_by_thread();
+ reset_memory_by_account();
+ reset_memory_by_user();
+ reset_status_by_thread();
+ reset_status_by_account();
+ reset_status_by_user();
+ purge_all_account();
+ purge_all_user();
+ return 0;
+}
+
+table_users::table_users()
+ : cursor_by_user(& m_share),
+ m_row_exists(false)
+{}
+
+void table_users::make_row(PFS_user *pfs)
+{
+ pfs_optimistic_state lock;
+
+ m_row_exists= false;
+ pfs->m_lock.begin_optimistic_lock(&lock);
+
+ if (m_row.m_user.make_row(pfs))
+ return;
+
+ PFS_connection_stat_visitor visitor;
+ PFS_connection_iterator::visit_user(pfs,
+ true, /* accounts */
+ true, /* threads */
+ false, /* THDs */
+ & visitor);
+
+ if (! pfs->m_lock.end_optimistic_lock(& lock))
+ return;
+
+ m_row.m_connection_stat.set(& visitor.m_stat);
+ m_row_exists= true;
+}
+
+int table_users::read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* USER */
+ m_row.m_user.set_field(f);
+ break;
+ case 1: /* CURRENT_CONNECTIONS */
+ case 2: /* TOTAL_CONNECTIONS */
+ m_row.m_connection_stat.set_field(f->field_index - 1, f);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+ return 0;
+}
+
diff --git a/storage/perfschema/table_users.h b/storage/perfschema/table_users.h
new file mode 100644
index 00000000..1c3cc647
--- /dev/null
+++ b/storage/perfschema/table_users.h
@@ -0,0 +1,85 @@
+/* Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#ifndef TABLE_USERS_H
+#define TABLE_USERS_H
+
+#include "pfs_column_types.h"
+#include "cursor_by_user.h"
+#include "table_helper.h"
+
+struct PFS_user;
+
+/**
+ \addtogroup Performance_schema_tables
+ @{
+*/
+
+/**
+ A row of PERFORMANCE_SCHEMA.USERS.
+*/
+struct row_users
+{
+ /** Column USER. */
+ PFS_user_row m_user;
+ /** Columns CURRENT_CONNECTIONS, TOTAL_CONNECTIONS. */
+ PFS_connection_stat_row m_connection_stat;
+};
+
+/** Table PERFORMANCE_SCHEMA.USERS. */
+class table_users : public cursor_by_user
+{
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ /** Table builder */
+ static PFS_engine_table* create();
+ static int delete_all_rows();
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+
+protected:
+ table_users();
+
+public:
+ ~table_users()
+ {}
+
+private:
+ virtual void make_row(PFS_user *pfs);
+
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+
+ /** Current row. */
+ row_users m_row;
+ /** True if the current row exists. */
+ bool m_row_exists;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_uvar_by_thread.cc b/storage/perfschema/table_uvar_by_thread.cc
new file mode 100644
index 00000000..77764c00
--- /dev/null
+++ b/storage/perfschema/table_uvar_by_thread.cc
@@ -0,0 +1,329 @@
+/* Copyright (c) 2013, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
+
+/**
+ @file storage/perfschema/table_uvar_by_thread.cc
+ Table USER_VARIABLES_BY_THREAD (implementation).
+*/
+
+#include "my_global.h"
+#include "my_thread.h"
+#include "pfs_instr_class.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "table_uvar_by_thread.h"
+#include "pfs_global.h"
+#include "pfs_visitor.h"
+#include "pfs_buffer_container.h"
+
+/* Iteration on THD from the sql layer. */
+#include "sql_class.h"
+#include "mysqld_thd_manager.h"
+
+class Find_thd_user_var : public Find_THD_Impl
+{
+public:
+ Find_thd_user_var(THD *unsafe_thd)
+ : m_unsafe_thd(unsafe_thd)
+ {}
+
+ virtual bool operator()(THD *thd)
+ {
+ if (thd != m_unsafe_thd)
+ return false;
+
+ if (thd->user_vars.records == 0)
+ return false;
+
+ mysql_mutex_lock(&thd->LOCK_thd_data);
+ return true;
+ }
+
+private:
+ THD *m_unsafe_thd;
+};
+
+void User_variables::materialize(PFS_thread *pfs, THD *thd)
+{
+ reset();
+
+ m_pfs= pfs;
+ m_thread_internal_id= pfs->m_thread_internal_id;
+ m_array.reserve(thd->user_vars.records);
+
+ user_var_entry *sql_uvar;
+
+ uint index= 0;
+ User_variable empty;
+
+ /* Protects thd->user_vars. */
+ mysql_mutex_assert_owner(&thd->LOCK_thd_data);
+
+ for (;;)
+ {
+ sql_uvar= reinterpret_cast<user_var_entry*> (my_hash_element(& thd->user_vars, index));
+ if (sql_uvar == NULL)
+ break;
+
+ /*
+ m_array is a container of objects (not pointers)
+
+ Naive code can:
+ - build locally a new entry
+ - add it to the container
+ but this causes useless object construction, destruction, and deep copies.
+
+ What we do here:
+ - add a dummy (empty) entry
+ - the container does a deep copy on something empty,
+ so that there is nothing to copy.
+ - get a reference to the entry added in the container
+ - complete -- in place -- the entry initialization
+ */
+ m_array.push(empty);
+ User_variable & pfs_uvar= *m_array.back();
+
+ /* Copy VARIABLE_NAME */
+ const char *name= sql_uvar->name.str;
+ size_t name_length= sql_uvar->name.length;
+ DBUG_ASSERT(name_length <= sizeof(pfs_uvar.m_name));
+ pfs_uvar.m_name.make_row(name, name_length);
+
+ /* Copy VARIABLE_VALUE */
+ bool null_value;
+ String *str_value;
+ String str_buffer;
+ uint decimals= 0;
+ str_value= sql_uvar->val_str(& null_value, & str_buffer, decimals);
+ if (str_value != NULL)
+ {
+ pfs_uvar.m_value.make_row(str_value->ptr(), str_value->length());
+ }
+ else
+ {
+ pfs_uvar.m_value.make_row(NULL, 0);
+ }
+
+ index++;
+ }
+}
+
+THR_LOCK table_uvar_by_thread::m_table_lock;
+
+PFS_engine_table_share
+table_uvar_by_thread::m_share=
+{
+ { C_STRING_WITH_LEN("user_variables_by_thread") },
+ &pfs_readonly_acl,
+ table_uvar_by_thread::create,
+ NULL, /* write_row */
+ NULL, /* delete_all_rows */
+ table_uvar_by_thread::get_row_count,
+ sizeof(pos_t),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE user_variables_by_thread("
+ "THREAD_ID BIGINT unsigned not null,"
+ "VARIABLE_NAME VARCHAR(64) not null,"
+ "VARIABLE_VALUE LONGBLOB)") },
+ false /* perpetual */
+};
+
+PFS_engine_table*
+table_uvar_by_thread::create(void)
+{
+ return new table_uvar_by_thread();
+}
+
+ha_rows
+table_uvar_by_thread::get_row_count(void)
+{
+ /*
+ This is an estimate only, not a hard limit.
+ The row count is given as a multiple of thread_max,
+ so that a join between:
+ - table performance_schema.threads
+ - table performance_schema.user_variables_by_thread
+ will still evaluate relative table sizes correctly
+ when deciding a join order.
+ */
+ return global_thread_container.get_row_count() * 10;
+}
+
+table_uvar_by_thread::table_uvar_by_thread()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_row_exists(false), m_pos(), m_next_pos()
+{}
+
+void table_uvar_by_thread::reset_position(void)
+{
+ m_pos.reset();
+ m_next_pos.reset();
+}
+
+int table_uvar_by_thread::rnd_next(void)
+{
+ PFS_thread *thread;
+ bool has_more_thread= true;
+
+ for (m_pos.set_at(&m_next_pos);
+ has_more_thread;
+ m_pos.next_thread())
+ {
+ thread= global_thread_container.get(m_pos.m_index_1, & has_more_thread);
+ if (thread != NULL)
+ {
+ if (materialize(thread) == 0)
+ {
+ const User_variable *uvar= m_THD_cache.get(m_pos.m_index_2);
+ if (uvar != NULL)
+ {
+ make_row(thread, uvar);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+ }
+ }
+
+ return HA_ERR_END_OF_FILE;
+}
+
+int
+table_uvar_by_thread::rnd_pos(const void *pos)
+{
+ PFS_thread *thread;
+
+ set_position(pos);
+
+ thread= global_thread_container.get(m_pos.m_index_1);
+ if (thread != NULL)
+ {
+ if (materialize(thread) == 0)
+ {
+ const User_variable *uvar= m_THD_cache.get(m_pos.m_index_2);
+ if (uvar != NULL)
+ {
+ make_row(thread, uvar);
+ return 0;
+ }
+ }
+ }
+
+ return HA_ERR_RECORD_DELETED;
+}
+
+int table_uvar_by_thread::materialize(PFS_thread *thread)
+{
+ if (m_THD_cache.is_materialized(thread))
+ return 0;
+
+ if (! thread->m_lock.is_populated())
+ return 1;
+
+ THD *unsafe_thd= thread->m_thd;
+ if (unsafe_thd == NULL)
+ return 1;
+
+ Find_thd_user_var finder(unsafe_thd);
+ THD *safe_thd= Global_THD_manager::get_instance()->find_thd(&finder);
+ if (safe_thd == NULL)
+ return 1;
+
+ m_THD_cache.materialize(thread, safe_thd);
+ mysql_mutex_unlock(&safe_thd->LOCK_thd_data);
+ return 0;
+}
+
+void table_uvar_by_thread
+::make_row(PFS_thread *thread, const User_variable *uvar)
+{
+ pfs_optimistic_state lock;
+ m_row_exists= false;
+
+ /* Protect this reader against a thread termination */
+ thread->m_lock.begin_optimistic_lock(&lock);
+
+ m_row.m_thread_internal_id= thread->m_thread_internal_id;
+
+ /* uvar is materialized, pointing to it directly. */
+ m_row.m_variable_name= & uvar->m_name;
+ m_row.m_variable_value= & uvar->m_value;
+
+ if (! thread->m_lock.end_optimistic_lock(&lock))
+ return;
+
+ m_row_exists= true;
+}
+
+int table_uvar_by_thread
+::read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ DBUG_ASSERT(m_row.m_variable_name != NULL);
+ DBUG_ASSERT(m_row.m_variable_value != NULL);
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* THREAD_ID */
+ set_field_ulonglong(f, m_row.m_thread_internal_id);
+ break;
+ case 1: /* VARIABLE_NAME */
+ set_field_varchar_utf8(f,
+ m_row.m_variable_name->m_str,
+ m_row.m_variable_name->m_length);
+ break;
+ case 2: /* VARIABLE_VALUE */
+ if (m_row.m_variable_value->get_value_length() > 0)
+ {
+ set_field_blob(f,
+ m_row.m_variable_value->get_value(),
+ static_cast<uint>(m_row.m_variable_value->get_value_length()));
+ }
+ else
+ {
+ f->set_null();
+ }
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_uvar_by_thread.h b/storage/perfschema/table_uvar_by_thread.h
new file mode 100644
index 00000000..a7334b2b
--- /dev/null
+++ b/storage/perfschema/table_uvar_by_thread.h
@@ -0,0 +1,195 @@
+/* Copyright (c) 2013, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
+
+#ifndef TABLE_UVAR_BY_THREAD_H
+#define TABLE_UVAR_BY_THREAD_H
+
+/**
+ @file storage/perfschema/table_uvar_by_thread.h
+ Table USER_VARIABLES_BY_THREAD (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "table_helper.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+struct User_variable
+{
+public:
+ User_variable()
+ {}
+
+ User_variable(const User_variable& uv)
+ : m_name(uv.m_name), m_value(uv.m_value)
+ {}
+
+ ~User_variable()
+ {}
+
+ PFS_variable_name_row m_name;
+ PFS_user_variable_value_row m_value;
+};
+
+class User_variables
+{
+ typedef Dynamic_array<User_variable> User_variable_array;
+
+public:
+ User_variables()
+ : m_pfs(NULL), m_thread_internal_id(0), m_array(PSI_INSTRUMENT_MEM)
+ {
+ }
+
+ void reset()
+ {
+ m_pfs= NULL;
+ m_thread_internal_id= 0;
+ for (uint i=0; i < m_array.elements(); i++)
+ m_array.at(i).~User_variable();
+ m_array.clear();
+ }
+
+ void materialize(PFS_thread *pfs, THD *thd);
+
+ bool is_materialized(PFS_thread *pfs)
+ {
+ DBUG_ASSERT(pfs != NULL);
+ if (m_pfs != pfs)
+ return false;
+ if (m_thread_internal_id != pfs->m_thread_internal_id)
+ return false;
+ return true;
+ }
+
+ const User_variable *get(uint index) const
+ {
+ if (index >= m_array.elements())
+ return NULL;
+
+ const User_variable *p= & m_array.at(index);
+ return p;
+ }
+
+private:
+ PFS_thread *m_pfs;
+ ulonglong m_thread_internal_id;
+ User_variable_array m_array;
+};
+
+/**
+ A row of table
+ PERFORMANCE_SCHEMA.USER_VARIABLES_BY_THREAD.
+*/
+struct row_uvar_by_thread
+{
+ /** Column THREAD_ID. */
+ ulonglong m_thread_internal_id;
+ /** Column VARIABLE_NAME. */
+ const PFS_variable_name_row *m_variable_name;
+ /** Column VARIABLE_VALUE. */
+ const PFS_user_variable_value_row *m_variable_value;
+};
+
+/**
+ Position of a cursor on
+ PERFORMANCE_SCHEMA.USER_VARIABLES_BY_THREAD.
+ Index 1 on thread (0 based)
+ Index 2 on user variable (0 based)
+*/
+struct pos_uvar_by_thread
+: public PFS_double_index
+{
+ pos_uvar_by_thread()
+ : PFS_double_index(0, 0)
+ {}
+
+ inline void reset(void)
+ {
+ m_index_1= 0;
+ m_index_2= 0;
+ }
+
+ inline void next_thread(void)
+ {
+ m_index_1++;
+ m_index_2= 0;
+ }
+};
+
+/** Table PERFORMANCE_SCHEMA.USER_VARIABLES_BY_THREAD. */
+class table_uvar_by_thread : public PFS_engine_table
+{
+ typedef pos_uvar_by_thread pos_t;
+
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static ha_rows get_row_count();
+
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+
+ table_uvar_by_thread();
+
+public:
+ ~table_uvar_by_thread()
+ { m_THD_cache.reset(); }
+
+protected:
+ int materialize(PFS_thread *thread);
+ void make_row(PFS_thread *thread, const User_variable *uvar);
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+ /** Fields definition. */
+ static TABLE_FIELD_DEF m_field_def;
+
+ /** Current THD user variables. */
+ User_variables m_THD_cache;
+ /** Current row. */
+ row_uvar_by_thread m_row;
+ /** True is the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ pos_t m_pos;
+ /** Next position. */
+ pos_t m_next_pos;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/table_variables_by_thread.cc b/storage/perfschema/table_variables_by_thread.cc
new file mode 100644
index 00000000..b43c6cd8
--- /dev/null
+++ b/storage/perfschema/table_variables_by_thread.cc
@@ -0,0 +1,229 @@
+/* Copyright (c) 2015, 2018, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
+
+/**
+ @file storage/perfschema/table_variables_by_thread.cc
+ Table VARIABLES_BY_THREAD (implementation).
+*/
+
+#include "my_global.h"
+#include "table_variables_by_thread.h"
+#include "my_thread.h"
+#include "pfs_instr_class.h"
+#include "pfs_column_types.h"
+#include "pfs_column_values.h"
+#include "pfs_global.h"
+
+THR_LOCK table_variables_by_thread::m_table_lock;
+
+PFS_engine_table_share
+table_variables_by_thread::m_share=
+{
+ { C_STRING_WITH_LEN("variables_by_thread") },
+ &pfs_readonly_acl,
+ table_variables_by_thread::create,
+ NULL, /* write_row */
+ NULL, /* delete_all_rows */
+ table_variables_by_thread::get_row_count,
+ sizeof(pos_t),
+ &m_table_lock,
+ { C_STRING_WITH_LEN("CREATE TABLE user_variables_by_thread("
+ "THREAD_ID BIGINT unsigned not null,"
+ "VARIABLE_NAME VARCHAR(64) not null,"
+ "VARIABLE_VALUE VARCHAR(1024))") },
+ true /* perpetual */
+};
+
+PFS_engine_table*
+table_variables_by_thread::create(void)
+{
+ return new table_variables_by_thread();
+}
+
+ha_rows table_variables_by_thread::get_row_count(void)
+{
+ mysql_mutex_lock(&LOCK_plugin_delete);
+ mysql_prlock_rdlock(&LOCK_system_variables_hash);
+ ulong system_var_count= get_system_variable_hash_records();
+ mysql_prlock_unlock(&LOCK_system_variables_hash);
+ mysql_mutex_unlock(&LOCK_plugin_delete);
+ return (global_thread_container.get_row_count() * system_var_count);
+}
+
+table_variables_by_thread::table_variables_by_thread()
+ : PFS_engine_table(&m_share, &m_pos),
+ m_sysvar_cache(true), m_row_exists(false), m_pos(), m_next_pos(), m_context(NULL)
+{}
+
+void table_variables_by_thread::reset_position(void)
+{
+ m_pos.reset();
+ m_next_pos.reset();
+}
+
+int table_variables_by_thread::rnd_init(bool scan)
+{
+ /*
+ Build array of SHOW_VARs from system variable hash prior to materializing
+ threads in rnd_next() or rnd_pos().
+ */
+ m_sysvar_cache.initialize_session();
+
+ /* Record the version of the system variable hash. */
+ ulonglong hash_version= m_sysvar_cache.get_sysvar_hash_version();
+
+ /*
+ The table context holds the current version of the system variable hash and
+ a record of which threads were materialized.
+ If scan == true, then allocate a new context from mem_root and store in TLS.
+ If scan == false, then restore from TLS.
+ */
+ m_context= (table_variables_by_thread_context *)current_thd->alloc(sizeof(table_variables_by_thread_context));
+ new(m_context) table_variables_by_thread_context(hash_version, !scan);
+ return 0;
+}
+
+int table_variables_by_thread::rnd_next(void)
+{
+ /* If system variable hash changes, exit with warning. */ // TODO: Issue warning
+ if (!m_context->versions_match())
+ return HA_ERR_END_OF_FILE;
+
+ bool has_more_thread= true;
+
+ for (m_pos.set_at(&m_next_pos);
+ has_more_thread;
+ m_pos.next_thread())
+ {
+ PFS_thread *pfs_thread= global_thread_container.get(m_pos.m_index_1, &has_more_thread);
+
+ /* Materialize all variables for the current thread. Assign a dedicated mem_root. */
+ if (m_sysvar_cache.materialize_session(pfs_thread, true) == 0)
+ {
+ /* Mark this thread as materialized. */
+ m_context->set_item(m_pos.m_index_1);
+
+ const System_variable *system_var= m_sysvar_cache.get(m_pos.m_index_2);
+ if (system_var != NULL)
+ {
+ make_row(pfs_thread, system_var);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+ }
+ return HA_ERR_END_OF_FILE;
+}
+
+int
+table_variables_by_thread::rnd_pos(const void *pos)
+{
+ /* If system variable hash changes, do nothing. */
+ if (!m_context->versions_match())
+ return HA_ERR_RECORD_DELETED;
+
+ set_position(pos);
+ DBUG_ASSERT(m_pos.m_index_1 < global_thread_container.get_row_count());
+
+ PFS_thread *pfs_thread= global_thread_container.get(m_pos.m_index_1);
+ /*
+ Only materialize threads that were previously materialized by rnd_next().
+ If a thread cannot be rematerialized, then do nothing.
+ Only materialize the requested system variable to avoid repeated
+ materialization of each thread, such as with ORDER BY variable_name.
+ */
+ if (m_context->is_item_set(m_pos.m_index_1) &&
+ /* Materialize only the requested variable. */
+ m_sysvar_cache.materialize_session(pfs_thread, m_pos.m_index_2) == 0)
+ {
+ /* Get the first (and only) element from the cache. */
+ const System_variable *system_var= m_sysvar_cache.get();
+ if (system_var != NULL)
+ {
+ make_row(pfs_thread, system_var);
+ m_next_pos.set_after(&m_pos);
+ return 0;
+ }
+ }
+ return HA_ERR_RECORD_DELETED;
+}
+
+void table_variables_by_thread
+::make_row(PFS_thread *thread, const System_variable *system_var)
+{
+ pfs_optimistic_state lock;
+ m_row_exists= false;
+ if (system_var->is_null() || system_var->is_ignored())
+ return;
+
+ /* Protect this reader against a thread termination */
+ thread->m_lock.begin_optimistic_lock(&lock);
+
+ m_row.m_thread_internal_id= thread->m_thread_internal_id;
+ m_row.m_variable_name.make_row(system_var->m_name, system_var->m_name_length);
+ m_row.m_variable_value.make_row(system_var);
+
+ if (!thread->m_lock.end_optimistic_lock(&lock))
+ return;
+
+ m_row_exists= true;
+}
+
+int table_variables_by_thread
+::read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all)
+{
+ Field *f;
+
+ if (unlikely(! m_row_exists))
+ return HA_ERR_RECORD_DELETED;
+
+ /* Set the null bits */
+ DBUG_ASSERT(table->s->null_bytes == 1);
+ buf[0]= 0;
+
+ for (; (f= *fields) ; fields++)
+ {
+ if (read_all || bitmap_is_set(table->read_set, f->field_index))
+ {
+ switch(f->field_index)
+ {
+ case 0: /* THREAD_ID */
+ set_field_ulonglong(f, m_row.m_thread_internal_id);
+ break;
+ case 1: /* VARIABLE_NAME */
+ set_field_varchar_utf8(f, m_row.m_variable_name.m_str, m_row.m_variable_name.m_length);
+ break;
+ case 2: /* VARIABLE_VALUE */
+ m_row.m_variable_value.set_field(f);
+ break;
+ default:
+ DBUG_ASSERT(false);
+ }
+ }
+ }
+
+ return 0;
+}
+
diff --git a/storage/perfschema/table_variables_by_thread.h b/storage/perfschema/table_variables_by_thread.h
new file mode 100644
index 00000000..d628707f
--- /dev/null
+++ b/storage/perfschema/table_variables_by_thread.h
@@ -0,0 +1,151 @@
+/* Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
+
+#ifndef TABLE_VARIABLES_BY_THREAD_H
+#define TABLE_VARIABLES_BY_THREAD_H
+
+/**
+ @file storage/perfschema/table_variables_by_thread.h
+ Table VARIABLES_BY_THREAD (declarations).
+*/
+
+#include "pfs_column_types.h"
+#include "pfs_engine_table.h"
+#include "pfs_instr_class.h"
+#include "pfs_instr.h"
+#include "table_helper.h"
+#include "pfs_variable.h"
+#include "pfs_buffer_container.h"
+
+/**
+ @addtogroup Performance_schema_tables
+ @{
+*/
+
+/**
+ A row of table
+ PERFORMANCE_SCHEMA.VARIABLES_BY_THREAD.
+*/
+struct row_variables_by_thread
+{
+ /** Column THREAD_ID. */
+ ulonglong m_thread_internal_id;
+ /** Column VARIABLE_NAME. */
+ PFS_variable_name_row m_variable_name;
+ /** Column VARIABLE_VALUE. */
+ PFS_variable_value_row m_variable_value;
+};
+
+/**
+ Position of a cursor on
+ PERFORMANCE_SCHEMA.VARIABLES_BY_THREAD.
+ Index 1 on thread (0 based)
+ Index 2 on system variable (0 based)
+*/
+struct pos_variables_by_thread
+: public PFS_double_index
+{
+ pos_variables_by_thread()
+ : PFS_double_index(0, 0)
+ {}
+
+ inline void reset(void)
+ {
+ m_index_1= 0;
+ m_index_2= 0;
+ }
+
+ inline bool has_more_thread(void)
+ { return (m_index_1 < global_thread_container.get_row_count()); }
+
+ inline void next_thread(void)
+ {
+ m_index_1++;
+ m_index_2= 0;
+ }
+};
+
+/**
+ Store and retrieve table state information during queries that reinstantiate
+ the table object.
+*/
+class table_variables_by_thread_context : public PFS_table_context
+{
+public:
+ table_variables_by_thread_context(ulonglong hash_version, bool restore) :
+ PFS_table_context(hash_version, global_thread_container.get_row_count(), restore, THR_PFS_VBT) { }
+};
+
+/** Table PERFORMANCE_SCHEMA.VARIABLES_BY_THREAD. */
+class table_variables_by_thread : public PFS_engine_table
+{
+ typedef pos_variables_by_thread pos_t;
+
+public:
+ /** Table share */
+ static PFS_engine_table_share m_share;
+ static PFS_engine_table* create();
+ static ha_rows get_row_count();
+
+ virtual int rnd_init(bool scan);
+ virtual int rnd_next();
+ virtual int rnd_pos(const void *pos);
+ virtual void reset_position(void);
+
+protected:
+ virtual int read_row_values(TABLE *table,
+ unsigned char *buf,
+ Field **fields,
+ bool read_all);
+ table_variables_by_thread();
+
+public:
+ ~table_variables_by_thread()
+ {}
+
+protected:
+ int materialize(PFS_thread *thread);
+ void make_row(PFS_thread *thread, const System_variable *system_var);
+
+private:
+ /** Table share lock. */
+ static THR_LOCK m_table_lock;
+ /** Fields definition. */
+ static TABLE_FIELD_DEF m_field_def;
+
+ /** Current THD variables. */
+ PFS_system_variable_cache m_sysvar_cache;
+ /** Current row. */
+ row_variables_by_thread m_row;
+ /** True if the current row exists. */
+ bool m_row_exists;
+ /** Current position. */
+ pos_t m_pos;
+ /** Next position. */
+ pos_t m_next_pos;
+
+ /** Table context with system variable hash version and map of materialized threads. */
+ table_variables_by_thread_context *m_context;
+};
+
+/** @} */
+#endif
diff --git a/storage/perfschema/unittest/CMakeLists.txt b/storage/perfschema/unittest/CMakeLists.txt
new file mode 100644
index 00000000..1bba2673
--- /dev/null
+++ b/storage/perfschema/unittest/CMakeLists.txt
@@ -0,0 +1,40 @@
+# Copyright (c) 2009, 2019, Oracle and/or its affiliates. All rights reserved.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License, version 2.0,
+# as published by the Free Software Foundation.
+#
+# This program is also distributed with certain software (including
+# but not limited to OpenSSL) that is licensed under separate terms,
+# as designated in a particular file or component or in included license
+# documentation. The authors of MySQL hereby grant you an additional
+# permission to link the program and your derivative works with the
+# separately licensed software that they have included with MySQL.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License, version 2.0, for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA
+
+INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/include
+ ${CMAKE_SOURCE_DIR}/include/mysql
+ ${PCRE_INCLUDES}
+ ${CMAKE_SOURCE_DIR}/sql
+ ${SSL_INCLUDE_DIRS}
+ ${CMAKE_SOURCE_DIR}/unittest/mytap
+ ${CMAKE_SOURCE_DIR}/storage/perfschema)
+
+ADD_DEFINITIONS(-DMYSQL_SERVER ${SSL_DEFINES})
+
+ADD_CONVENIENCE_LIBRARY(pfs_server_stubs pfs_server_stubs.cc)
+
+ADD_DEPENDENCIES(pfs_server_stubs GenError)
+
+MY_ADD_TESTS(pfs_instr_class pfs_instr_class-oom pfs_instr pfs_instr-oom
+ pfs_account-oom pfs_host-oom pfs_timer pfs_user-oom pfs_noop pfs
+ pfs_misc
+ EXT "cc" LINK_LIBRARIES perfschema mysys pfs_server_stubs)
diff --git a/storage/perfschema/unittest/conf.txt b/storage/perfschema/unittest/conf.txt
new file mode 100644
index 00000000..f84ba331
--- /dev/null
+++ b/storage/perfschema/unittest/conf.txt
@@ -0,0 +1,427 @@
+# Copyright (c) 2009, 2010, Oracle and/or its affiliates.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License, version 2.0,
+# as published by the Free Software Foundation.
+#
+# This program is also distributed with certain software (including
+# but not limited to OpenSSL) that is licensed under separate terms,
+# as designated in a particular file or component or in included license
+# documentation. The authors of MySQL hereby grant you an additional
+# permission to link the program and your derivative works with the
+# separately licensed software that they have included with MySQL.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License, version 2.0, for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA
+
+Performance schema test configurations.
+(Used internally for performance testing)
+
+Configuration PERFSCHEMA-COMPILED-OUT
+=====================================
+
+Description
+-----------
+
+Reference for timings, server built without the performance schema.
+
+Compiling options
+-----------------
+
+./configure --without-perfschema
+
+Server start options
+--------------------
+
+N/A
+
+Configuration
+-------------
+
+N/A
+
+Pre-test queries
+----------------
+
+select version();
+
+This is just to make sure the build is not including the performance schema.
+
+Post-test queries
+-----------------
+
+N/A
+
+Configuration PERFSCHEMA-DISABLED
+=================================
+
+Description
+-----------
+
+Server built with the performance schema,
+but the performance schema is disabled at startup.
+
+Compiling options
+-----------------
+
+./configure --with-perfschema
+
+Server start options
+--------------------
+
+./mysqld --disable-performance-schema
+
+Configuration
+-------------
+
+N/A
+
+Pre-test queries
+----------------
+
+select version();
+show engine performance_schema status;
+show variables like "performance%";
+show status like "performance%";
+select * from performance_schema.PERFORMANCE_TIMERS;
+select * from performance_schema.SETUP_CONSUMERS;
+select * from performance_schema.SETUP_INSTRUMENTS;
+select * from performance_schema.SETUP_TIMERS;
+
+Post-test queries
+-----------------
+
+N/A
+
+Configuration PERFSCHEMA-ENABLED-STANDBY
+========================================
+
+Description
+-----------
+
+Server built with the performance schema.
+The performance schema is enabled at startup,
+but configured to not record anything.
+This is a "stanby" configuration, in the sense that the DBA can add
+dynamically more setup options later to get data.
+
+Compiling options
+-----------------
+
+./configure --with-perfschema
+
+Server start options
+--------------------
+
+./mysqld --enable-performance-schema
+
+Configuration
+-------------
+
+UPDATE performance_schema.SETUP_INSTRUMENTS
+ set enabled='NO', timed='NO';
+
+UPDATE performance_schema.SETUP_CONSUMERS
+ set enabled='NO';
+
+Pre-test queries
+----------------
+
+select version();
+show engine performance_schema status;
+show variables like "performance%";
+show status like "performance%";
+select * from performance_schema.PERFORMANCE_TIMERS;
+select * from performance_schema.SETUP_CONSUMERS;
+select * from performance_schema.SETUP_INSTRUMENTS;
+select * from performance_schema.SETUP_TIMERS;
+
+Post-test queries
+-----------------
+
+show engine performance_schema status;
+show variables like "performance%";
+show status like "performance%";
+
+Configuration PERFSCHEMA-ENABLED-CURRENT
+========================================
+
+Description
+-----------
+
+Server built with the performance schema.
+The performance schema is enabled at startup.
+All instruments are enabled but not timed,
+and only one consumer (EVENTS_WAITS_CURRENT) is set.
+
+Compiling options
+-----------------
+
+./configure --with-perfschema
+
+Server start options
+--------------------
+
+./mysqld --enable-performance-schema
+
+Configuration
+-------------
+
+UPDATE performance_schema.SETUP_INSTRUMENTS
+ set enabled='YES', timed='NO';
+
+UPDATE performance_schema.SETUP_CONSUMERS
+ set enabled='NO';
+
+UPDATE performance_schema.SETUP_CONSUMERS
+ set enabled='YES' where name='EVENTS_WAITS_CURRENT';
+
+Pre-test queries
+----------------
+
+select version();
+show engine performance_schema status;
+show variables like "performance%";
+show status like "performance%";
+select * from performance_schema.PERFORMANCE_TIMERS;
+select * from performance_schema.SETUP_CONSUMERS;
+select * from performance_schema.SETUP_INSTRUMENTS;
+select * from performance_schema.SETUP_TIMERS;
+
+Post-test queries
+-----------------
+
+show engine performance_schema status;
+show variables like "performance%";
+show status like "performance%";
+
+Configuration PERFSCHEMA-ENABLED-CURRENT-CYCLE
+==============================================
+
+Description
+-----------
+
+Server built with the performance schema.
+The performance schema is enabled at startup.
+All instruments are enabled and timed,
+and only one consumer (EVENTS_WAITS_CURRENT) is set.
+The timer used is CYCLE.
+
+Compiling options
+-----------------
+
+./configure --with-perfschema
+
+Server start options
+--------------------
+
+./mysqld --enable-performance-schema
+
+Configuration
+-------------
+
+UPDATE performance_schema.SETUP_INSTRUMENTS
+ set enabled='YES', timed='YES';
+
+UPDATE performance_schema.SETUP_TIMERS
+ set timer_name='CYCLE';
+
+UPDATE performance_schema.SETUP_CONSUMERS
+ set enabled='NO';
+
+UPDATE performance_schema.SETUP_CONSUMERS
+ set enabled='YES' where name='EVENTS_WAITS_CURRENT';
+
+Pre-test queries
+----------------
+
+select version();
+show engine performance_schema status;
+show variables like "performance%";
+show status like "performance%";
+select * from performance_schema.PERFORMANCE_TIMERS;
+select * from performance_schema.SETUP_CONSUMERS;
+select * from performance_schema.SETUP_INSTRUMENTS;
+select * from performance_schema.SETUP_TIMERS;
+
+Post-test queries
+-----------------
+
+show engine performance_schema status;
+show variables like "performance%";
+show status like "performance%";
+
+Configuration PERFSCHEMA-ENABLED-HISTORY-CYCLE
+==============================================
+
+Description
+-----------
+
+Server built with the performance schema.
+The performance schema is enabled at startup.
+All instruments are enabled and timed, in CYCLE.
+Two consumers (EVENTS_WAITS_CURRENT, EVENTS_WAITS_HISTORY) are set.
+
+Compiling options
+-----------------
+
+./configure --with-perfschema
+
+Server start options
+--------------------
+
+./mysqld --enable-performance-schema
+
+Configuration
+-------------
+
+UPDATE performance_schema.SETUP_INSTRUMENTS
+ set enabled='YES', timed='YES';
+
+UPDATE performance_schema.SETUP_TIMERS
+ set timer_name='CYCLE';
+
+UPDATE performance_schema.SETUP_CONSUMERS
+ set enabled='NO';
+
+UPDATE performance_schema.SETUP_CONSUMERS
+ set enabled='YES' where name='EVENTS_WAITS_CURRENT';
+
+UPDATE performance_schema.SETUP_CONSUMERS
+ set enabled='YES' where name='EVENTS_WAITS_HISTORY';
+
+Pre-test queries
+----------------
+
+select version();
+show engine performance_schema status;
+show variables like "performance%";
+show status like "performance%";
+select * from performance_schema.PERFORMANCE_TIMERS;
+select * from performance_schema.SETUP_CONSUMERS;
+select * from performance_schema.SETUP_INSTRUMENTS;
+select * from performance_schema.SETUP_TIMERS;
+
+Post-test queries
+-----------------
+
+show engine performance_schema status;
+show variables like "performance%";
+show status like "performance%";
+
+Configuration PERFSCHEMA-ENABLED-HISTORY_LONG-CYCLE
+===================================================
+
+Description
+-----------
+
+Server built with the performance schema.
+The performance schema is enabled at startup.
+All instruments are enabled and timed, in CYCLE.
+Two consumers (EVENTS_WAITS_CURRENT, EVENTS_WAITS_HISTORY_LONG) are set.
+
+Compiling options
+-----------------
+
+./configure --with-perfschema
+
+Server start options
+--------------------
+
+./mysqld --enable-performance-schema
+
+Configuration
+-------------
+
+UPDATE performance_schema.SETUP_INSTRUMENTS
+ set enabled='YES', timed='YES';
+
+UPDATE performance_schema.SETUP_TIMERS
+ set timer_name='CYCLE';
+
+UPDATE performance_schema.SETUP_CONSUMERS
+ set enabled='NO';
+
+UPDATE performance_schema.SETUP_CONSUMERS
+ set enabled='YES' where name='EVENTS_WAITS_CURRENT';
+
+UPDATE performance_schema.SETUP_CONSUMERS
+ set enabled='YES' where name='EVENTS_WAITS_HISTORY_LONG';
+
+Pre-test queries
+----------------
+
+select version();
+show engine performance_schema status;
+show variables like "performance%";
+show status like "performance%";
+select * from performance_schema.PERFORMANCE_TIMERS;
+select * from performance_schema.SETUP_CONSUMERS;
+select * from performance_schema.SETUP_INSTRUMENTS;
+select * from performance_schema.SETUP_TIMERS;
+
+Post-test queries
+-----------------
+
+show engine performance_schema status;
+show variables like "performance%";
+show status like "performance%";
+
+Configuration PERFSCHEMA-ENABLED-BIGBANG-CYCLE
+==============================================
+
+Description
+-----------
+
+Server built with the performance schema.
+The performance schema is enabled at startup.
+All instruments are enabled and timed, in CYCLE.
+All possible consumers are enabled.
+
+Compiling options
+-----------------
+
+./configure --with-perfschema
+
+Server start options
+--------------------
+
+./mysqld --enable-performance-schema
+
+Configuration
+-------------
+
+UPDATE performance_schema.SETUP_INSTRUMENTS
+ set enabled='YES', timed='YES';
+
+UPDATE performance_schema.SETUP_TIMERS
+ set timer_name='CYCLE';
+
+UPDATE performance_schema.SETUP_CONSUMERS
+ set enabled='YES';
+
+Pre-test queries
+----------------
+
+select version();
+show engine performance_schema status;
+show variables like "performance%";
+show status like "performance%";
+select * from performance_schema.PERFORMANCE_TIMERS;
+select * from performance_schema.SETUP_CONSUMERS;
+select * from performance_schema.SETUP_INSTRUMENTS;
+select * from performance_schema.SETUP_TIMERS;
+
+Post-test queries
+-----------------
+
+show engine performance_schema status;
+show variables like "performance%";
+show status like "performance%";
+
diff --git a/storage/perfschema/unittest/pfs-t.cc b/storage/perfschema/unittest/pfs-t.cc
new file mode 100644
index 00000000..43d9d8d2
--- /dev/null
+++ b/storage/perfschema/unittest/pfs-t.cc
@@ -0,0 +1,1909 @@
+/* Copyright (c) 2008, 2017, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#include <my_global.h>
+#include <my_thread.h>
+#include <pfs_server.h>
+#include <pfs_instr_class.h>
+#include <pfs_instr.h>
+#include <pfs_global.h>
+#include <pfs_buffer_container.h>
+#include <tap.h>
+
+#include <string.h>
+#include <memory.h>
+
+#include "stub_print_error.h"
+#include "stub_pfs_defaults.h"
+#include "stub_global_status_var.h"
+
+void unload_performance_schema();
+
+/* test helpers, to simulate the setup */
+
+void setup_thread(PSI_thread *t, bool enabled)
+{
+ PFS_thread *t2= (PFS_thread*) t;
+ t2->m_enabled= enabled;
+}
+
+/* test helpers, to inspect data */
+
+PFS_file* lookup_file_by_name(const char* name)
+{
+ PFS_file *pfs;
+ size_t len= strlen(name);
+ size_t dirlen;
+ const char *filename;
+ size_t filename_length;
+
+ PFS_file_iterator it= global_file_container.iterate();
+ pfs= it.scan_next();
+
+ while (pfs != NULL)
+ {
+ /*
+ When a file "foo" is instrumented, the name is normalized
+ to "/path/to/current/directory/foo", so we remove the
+ directory name here to find it back.
+ */
+ dirlen= dirname_length(pfs->m_filename);
+ filename= pfs->m_filename + dirlen;
+ filename_length= pfs->m_filename_length - dirlen;
+ if ((len == filename_length) &&
+ (strncmp(name, filename, filename_length) == 0))
+ return pfs;
+
+ pfs= it.scan_next();
+ }
+
+ return NULL;
+}
+
+/* tests */
+
+void test_bootstrap()
+{
+ void *psi;
+ void *psi_2;
+ PSI_bootstrap *boot;
+ PFS_global_param param;
+
+ diag("test_bootstrap");
+
+ memset(& param, 0xFF, sizeof(param));
+ param.m_enabled= true;
+ param.m_mutex_class_sizing= 0;
+ param.m_rwlock_class_sizing= 0;
+ param.m_cond_class_sizing= 0;
+ param.m_thread_class_sizing= 0;
+ param.m_table_share_sizing= 0;
+ param.m_file_class_sizing= 0;
+ param.m_socket_class_sizing= 0;
+ param.m_mutex_sizing= 0;
+ param.m_rwlock_sizing= 0;
+ param.m_cond_sizing= 0;
+ param.m_thread_sizing= 0;
+ param.m_table_sizing= 0;
+ param.m_file_sizing= 0;
+ param.m_file_handle_sizing= 0;
+ param.m_socket_sizing= 0;
+ param.m_events_waits_history_sizing= 0;
+ param.m_events_waits_history_long_sizing= 0;
+ param.m_setup_actor_sizing= 0;
+ param.m_setup_object_sizing= 0;
+ param.m_user_sizing= 0;
+ param.m_account_sizing= 0;
+ param.m_host_sizing= 0;
+ param.m_stage_class_sizing= 0;
+ param.m_events_stages_history_sizing= 0;
+ param.m_events_stages_history_long_sizing= 0;
+ param.m_statement_class_sizing= 0;
+ param.m_events_statements_history_sizing= 0;
+ param.m_events_statements_history_long_sizing= 0;
+ param.m_events_transactions_history_sizing= 0;
+ param.m_events_transactions_history_long_sizing= 0;
+ param.m_digest_sizing= 0;
+ param.m_session_connect_attrs_sizing= 0;
+ param.m_program_sizing= 0;
+ param.m_statement_stack_sizing= 0;
+ param.m_memory_class_sizing= 0;
+ param.m_metadata_lock_sizing= 0;
+ param.m_max_digest_length= 0;
+ param.m_max_sql_text_length= 0;
+
+ param.m_hints.m_table_definition_cache = 100;
+ param.m_hints.m_table_open_cache = 100;
+ param.m_hints.m_max_connections = 100;
+ param.m_hints.m_open_files_limit = 100;
+ param.m_hints.m_max_prepared_stmt_count= 100;
+
+ pre_initialize_performance_schema();
+ boot= initialize_performance_schema(& param);
+ ok(boot != NULL, "boot");
+ ok(boot->get_interface != NULL, "boot->get_interface");
+
+ psi= boot->get_interface(0);
+ ok(psi == NULL, "no version 0");
+
+ psi= boot->get_interface(PSI_VERSION_1);
+ ok(psi != NULL, "version 1");
+
+ psi_2= boot->get_interface(PSI_VERSION_2);
+ ok(psi_2 == NULL, "version 2");
+
+ unload_performance_schema();
+}
+
+/*
+ Not a test, helper for testing pfs.cc
+*/
+PSI * load_perfschema()
+{
+ PSI *psi;
+ PSI_bootstrap *boot;
+ PFS_global_param param;
+
+ memset(& param, 0xFF, sizeof(param));
+ param.m_enabled= true;
+ param.m_mutex_class_sizing= 10;
+ param.m_rwlock_class_sizing= 10;
+ param.m_cond_class_sizing= 10;
+ param.m_thread_class_sizing= 10;
+ param.m_table_share_sizing= 10;
+ param.m_file_class_sizing= 10;
+ param.m_socket_class_sizing= 10;
+ param.m_mutex_sizing= 10;
+ param.m_rwlock_sizing= 10;
+ param.m_cond_sizing= 10;
+ param.m_thread_sizing= 10;
+ param.m_table_sizing= 10;
+ param.m_file_sizing= 10;
+ param.m_file_handle_sizing= 50;
+ param.m_socket_sizing= 10;
+ param.m_events_waits_history_sizing= 10;
+ param.m_events_waits_history_long_sizing= 10;
+ param.m_setup_actor_sizing= 0;
+ param.m_setup_object_sizing= 0;
+ param.m_user_sizing= 0;
+ param.m_account_sizing= 0;
+ param.m_host_sizing= 0;
+ param.m_stage_class_sizing= 0;
+ param.m_events_stages_history_sizing= 0;
+ param.m_events_stages_history_long_sizing= 0;
+ param.m_statement_class_sizing= 0;
+ param.m_events_statements_history_sizing= 0;
+ param.m_events_statements_history_long_sizing= 0;
+ param.m_events_transactions_history_sizing= 0;
+ param.m_events_transactions_history_long_sizing= 0;
+ param.m_digest_sizing= 0;
+ param.m_session_connect_attrs_sizing= 0;
+ param.m_program_sizing= 0;
+ param.m_statement_stack_sizing= 10;
+ param.m_memory_class_sizing= 10;
+ param.m_metadata_lock_sizing= 10;
+ param.m_max_digest_length= 0;
+ param.m_max_sql_text_length= 1000;
+
+ param.m_hints.m_table_definition_cache = 100;
+ param.m_hints.m_table_open_cache = 100;
+ param.m_hints.m_max_connections = 100;
+ param.m_hints.m_open_files_limit = 100;
+ param.m_hints.m_max_prepared_stmt_count= 100;
+
+ pre_initialize_performance_schema();
+ /* test_bootstrap() covered this, assuming it just works */
+ boot= initialize_performance_schema(& param);
+ psi= (PSI *)boot->get_interface(PSI_VERSION_1);
+
+ /* Reset every consumer to a known state */
+ flag_global_instrumentation= true;
+ flag_thread_instrumentation= true;
+
+ return (PSI*) psi;
+}
+
+void unload_performance_schema()
+{
+ cleanup_table_share();
+ cleanup_instruments();
+ cleanup_sync_class();
+ cleanup_thread_class();
+ cleanup_table_share();
+ cleanup_file_class();
+ cleanup_stage_class();
+ cleanup_statement_class();
+ cleanup_socket_class();
+ cleanup_events_waits_history_long();
+ cleanup_events_stages_history_long();
+ cleanup_events_statements_history_long();
+ cleanup_table_share_hash();
+ cleanup_file_hash();
+ cleanup_digest();
+
+ shutdown_performance_schema();
+}
+
+void test_bad_registration()
+{
+ PSI *psi;
+
+ diag("test_bad_registration");
+
+ psi= load_perfschema();
+
+ /*
+ Test that length('wait/synch/mutex/' (17) + category + '/' (1)) < 32
+ --> category can be up to 13 chars for a mutex.
+ */
+
+ PSI_mutex_key dummy_mutex_key= 9999;
+ PSI_mutex_info bad_mutex_1[]=
+ {
+ { & dummy_mutex_key, "X", 0}
+ };
+
+ psi->register_mutex("/", bad_mutex_1, 1);
+ ok(dummy_mutex_key == 0, "zero key");
+ dummy_mutex_key= 9999;
+ psi->register_mutex("a/", bad_mutex_1, 1);
+ ok(dummy_mutex_key == 0, "zero key");
+ dummy_mutex_key= 9999;
+ psi->register_mutex("/b", bad_mutex_1, 1);
+ ok(dummy_mutex_key == 0, "zero key");
+ dummy_mutex_key= 9999;
+ psi->register_mutex("a/b", bad_mutex_1, 1);
+ ok(dummy_mutex_key == 0, "zero key");
+ dummy_mutex_key= 9999;
+ psi->register_mutex("12345678901234", bad_mutex_1, 1);
+ ok(dummy_mutex_key == 0, "zero key");
+ dummy_mutex_key= 9999;
+ psi->register_mutex("1234567890123", bad_mutex_1, 1);
+ ok(dummy_mutex_key == 1, "assigned key");
+
+ /*
+ Test that length('wait/synch/mutex/' (17) + category + '/' (1) + name) <= 128
+ --> category + name can be up to 110 chars for a mutex.
+ */
+
+ dummy_mutex_key= 9999;
+ PSI_mutex_info bad_mutex_2[]=
+ {
+ { & dummy_mutex_key,
+ /* 110 chars name */
+ "12345678901234567890123456789012345678901234567890"
+ "12345678901234567890123456789012345678901234567890"
+ "1234567890",
+ 0}
+ };
+
+ psi->register_mutex("X", bad_mutex_2, 1);
+ ok(dummy_mutex_key == 0, "zero key");
+
+ dummy_mutex_key= 9999;
+ PSI_mutex_info bad_mutex_3[]=
+ {
+ { & dummy_mutex_key,
+ /* 109 chars name */
+ "12345678901234567890123456789012345678901234567890"
+ "12345678901234567890123456789012345678901234567890"
+ "123456789",
+ 0}
+ };
+
+ psi->register_mutex("XX", bad_mutex_3, 1);
+ ok(dummy_mutex_key == 0, "zero key");
+
+ psi->register_mutex("X", bad_mutex_3, 1);
+ ok(dummy_mutex_key == 2, "assigned key");
+
+ /*
+ Test that length('wait/synch/rwlock/' (18) + category + '/' (1)) < 32
+ --> category can be up to 12 chars for a rwlock.
+ */
+
+ PSI_rwlock_key dummy_rwlock_key= 9999;
+ PSI_rwlock_info bad_rwlock_1[]=
+ {
+ { & dummy_rwlock_key, "X", 0}
+ };
+
+ psi->register_rwlock("/", bad_rwlock_1, 1);
+ ok(dummy_rwlock_key == 0, "zero key");
+ dummy_rwlock_key= 9999;
+ psi->register_rwlock("a/", bad_rwlock_1, 1);
+ ok(dummy_rwlock_key == 0, "zero key");
+ dummy_rwlock_key= 9999;
+ psi->register_rwlock("/b", bad_rwlock_1, 1);
+ ok(dummy_rwlock_key == 0, "zero key");
+ dummy_rwlock_key= 9999;
+ psi->register_rwlock("a/b", bad_rwlock_1, 1);
+ ok(dummy_rwlock_key == 0, "zero key");
+ dummy_rwlock_key= 9999;
+ psi->register_rwlock("1234567890123", bad_rwlock_1, 1);
+ ok(dummy_rwlock_key == 0, "zero key");
+ dummy_rwlock_key= 9999;
+ psi->register_rwlock("123456789012", bad_rwlock_1, 1);
+ ok(dummy_rwlock_key == 1, "assigned key");
+
+ /*
+ Test that length('wait/synch/rwlock/' (18) + category + '/' (1) + name) <= 128
+ --> category + name can be up to 109 chars for a rwlock.
+ */
+
+ dummy_rwlock_key= 9999;
+ PSI_rwlock_info bad_rwlock_2[]=
+ {
+ { & dummy_rwlock_key,
+ /* 109 chars name */
+ "12345678901234567890123456789012345678901234567890"
+ "12345678901234567890123456789012345678901234567890"
+ "123456789",
+ 0}
+ };
+
+ psi->register_rwlock("X", bad_rwlock_2, 1);
+ ok(dummy_rwlock_key == 0, "zero key");
+
+ dummy_rwlock_key= 9999;
+ PSI_rwlock_info bad_rwlock_2_sx[]=
+ {
+ { & dummy_rwlock_key,
+ /* 109 chars name */
+ "12345678901234567890123456789012345678901234567890"
+ "12345678901234567890123456789012345678901234567890"
+ "123456789",
+ PSI_RWLOCK_FLAG_SX}
+ };
+
+ psi->register_rwlock("Y", bad_rwlock_2_sx, 1);
+ ok(dummy_rwlock_key == 0, "zero key SX");
+
+ dummy_rwlock_key= 9999;
+ PSI_rwlock_info bad_rwlock_3[]=
+ {
+ { & dummy_rwlock_key,
+ /* 108 chars name */
+ "12345678901234567890123456789012345678901234567890"
+ "12345678901234567890123456789012345678901234567890"
+ "12345678",
+ 0}
+ };
+
+ psi->register_rwlock("XX", bad_rwlock_3, 1);
+ ok(dummy_rwlock_key == 0, "zero key");
+
+ psi->register_rwlock("X", bad_rwlock_3, 1);
+ ok(dummy_rwlock_key == 2, "assigned key");
+
+ dummy_rwlock_key= 9999;
+ PSI_rwlock_info bad_rwlock_3_sx[]=
+ {
+ { & dummy_rwlock_key,
+ /* 108 chars name */
+ "12345678901234567890123456789012345678901234567890"
+ "12345678901234567890123456789012345678901234567890"
+ "12345678",
+ PSI_RWLOCK_FLAG_SX}
+ };
+
+ psi->register_rwlock("YY", bad_rwlock_3_sx, 1);
+ ok(dummy_rwlock_key == 0, "zero key SX");
+
+ psi->register_rwlock("Y", bad_rwlock_3_sx, 1);
+ ok(dummy_rwlock_key == 3, "assigned key SX");
+
+ /*
+ Test that length('wait/synch/cond/' (16) + category + '/' (1)) < 32
+ --> category can be up to 14 chars for a cond.
+ */
+
+ PSI_cond_key dummy_cond_key= 9999;
+ PSI_cond_info bad_cond_1[]=
+ {
+ { & dummy_cond_key, "X", 0}
+ };
+
+ psi->register_cond("/", bad_cond_1, 1);
+ ok(dummy_cond_key == 0, "zero key");
+ dummy_cond_key= 9999;
+ psi->register_cond("a/", bad_cond_1, 1);
+ ok(dummy_cond_key == 0, "zero key");
+ dummy_cond_key= 9999;
+ psi->register_cond("/b", bad_cond_1, 1);
+ ok(dummy_cond_key == 0, "zero key");
+ dummy_cond_key= 9999;
+ psi->register_cond("a/b", bad_cond_1, 1);
+ ok(dummy_cond_key == 0, "zero key");
+ dummy_cond_key= 9999;
+ psi->register_cond("123456789012345", bad_cond_1, 1);
+ ok(dummy_cond_key == 0, "zero key");
+ dummy_cond_key= 9999;
+ psi->register_cond("12345678901234", bad_cond_1, 1);
+ ok(dummy_cond_key == 1, "assigned key");
+
+ /*
+ Test that length('wait/synch/cond/' (16) + category + '/' (1) + name) <= 128
+ --> category + name can be up to 111 chars for a cond.
+ */
+
+ dummy_cond_key= 9999;
+ PSI_cond_info bad_cond_2[]=
+ {
+ { & dummy_cond_key,
+ /* 111 chars name */
+ "12345678901234567890123456789012345678901234567890"
+ "12345678901234567890123456789012345678901234567890"
+ "12345678901",
+ 0}
+ };
+
+ psi->register_cond("X", bad_cond_2, 1);
+ ok(dummy_cond_key == 0, "zero key");
+
+ dummy_cond_key= 9999;
+ PSI_cond_info bad_cond_3[]=
+ {
+ { & dummy_cond_key,
+ /* 110 chars name */
+ "12345678901234567890123456789012345678901234567890"
+ "12345678901234567890123456789012345678901234567890"
+ "1234567890",
+ 0}
+ };
+
+ psi->register_cond("XX", bad_cond_3, 1);
+ ok(dummy_cond_key == 0, "zero key");
+
+ psi->register_cond("X", bad_cond_3, 1);
+ ok(dummy_cond_key == 2, "assigned key");
+
+ /*
+ Test that length('thread/' (7) + category + '/' (1)) < 32
+ --> category can be up to 23 chars for a thread.
+ */
+
+ PSI_thread_key dummy_thread_key= 9999;
+ PSI_thread_info bad_thread_1[]=
+ {
+ { & dummy_thread_key, "X", 0}
+ };
+
+ psi->register_thread("/", bad_thread_1, 1);
+ ok(dummy_thread_key == 0, "zero key");
+ dummy_thread_key= 9999;
+ psi->register_thread("a/", bad_thread_1, 1);
+ ok(dummy_thread_key == 0, "zero key");
+ dummy_thread_key= 9999;
+ psi->register_thread("/b", bad_thread_1, 1);
+ ok(dummy_thread_key == 0, "zero key");
+ dummy_thread_key= 9999;
+ psi->register_thread("a/b", bad_thread_1, 1);
+ ok(dummy_thread_key == 0, "zero key");
+ dummy_thread_key= 9999;
+ psi->register_thread("123456789012345678901234", bad_thread_1, 1);
+ ok(dummy_thread_key == 0, "zero key");
+ dummy_thread_key= 9999;
+ psi->register_thread("12345678901234567890123", bad_thread_1, 1);
+ ok(dummy_thread_key == 1, "assigned key");
+
+ /*
+ Test that length('thread/' (7) + category + '/' (1) + name) <= 128
+ --> category + name can be up to 120 chars for a thread.
+ */
+
+ dummy_thread_key= 9999;
+ PSI_thread_info bad_thread_2[]=
+ {
+ { & dummy_thread_key,
+ /* 120 chars name */
+ "12345678901234567890123456789012345678901234567890"
+ "12345678901234567890123456789012345678901234567890"
+ "12345678901234567890",
+ 0}
+ };
+
+ psi->register_thread("X", bad_thread_2, 1);
+ ok(dummy_thread_key == 0, "zero key");
+
+ dummy_thread_key= 9999;
+ PSI_thread_info bad_thread_3[]=
+ {
+ { & dummy_thread_key,
+ /* 119 chars name */
+ "12345678901234567890123456789012345678901234567890"
+ "12345678901234567890123456789012345678901234567890"
+ "1234567890123456789",
+ 0}
+ };
+
+ psi->register_thread("XX", bad_thread_3, 1);
+ ok(dummy_thread_key == 0, "zero key");
+
+ psi->register_thread("X", bad_thread_3, 1);
+ ok(dummy_thread_key == 2, "assigned key");
+
+ /*
+ Test that length('wait/io/file/' (13) + category + '/' (1)) < 32
+ --> category can be up to 17 chars for a file.
+ */
+
+ PSI_file_key dummy_file_key= 9999;
+ PSI_file_info bad_file_1[]=
+ {
+ { & dummy_file_key, "X", 0}
+ };
+
+ psi->register_file("/", bad_file_1, 1);
+ ok(dummy_file_key == 0, "zero key");
+ dummy_file_key= 9999;
+ psi->register_file("a/", bad_file_1, 1);
+ ok(dummy_file_key == 0, "zero key");
+ dummy_file_key= 9999;
+ psi->register_file("/b", bad_file_1, 1);
+ ok(dummy_file_key == 0, "zero key");
+ dummy_file_key= 9999;
+ psi->register_file("a/b", bad_file_1, 1);
+ ok(dummy_file_key == 0, "zero key");
+ dummy_file_key= 9999;
+ psi->register_file("123456789012345678", bad_file_1, 1);
+ ok(dummy_file_key == 0, "zero key");
+ dummy_file_key= 9999;
+ psi->register_file("12345678901234567", bad_file_1, 1);
+ ok(dummy_file_key == 1, "assigned key");
+
+ /*
+ Test that length('wait/io/file/' (13) + category + '/' (1) + name) <= 128
+ --> category + name can be up to 114 chars for a file.
+ */
+
+ dummy_file_key= 9999;
+ PSI_file_info bad_file_2[]=
+ {
+ { & dummy_file_key,
+ /* 114 chars name */
+ "12345678901234567890123456789012345678901234567890"
+ "12345678901234567890123456789012345678901234567890"
+ "12345678901234",
+ 0}
+ };
+
+ psi->register_file("X", bad_file_2, 1);
+ ok(dummy_file_key == 0, "zero key");
+
+ dummy_file_key= 9999;
+ PSI_file_info bad_file_3[]=
+ {
+ { & dummy_file_key,
+ /* 113 chars name */
+ "12345678901234567890123456789012345678901234567890"
+ "12345678901234567890123456789012345678901234567890"
+ "1234567890123",
+ 0}
+ };
+
+ psi->register_file("XX", bad_file_3, 1);
+ ok(dummy_file_key == 0, "zero key");
+
+ psi->register_file("X", bad_file_3, 1);
+ ok(dummy_file_key == 2, "assigned key");
+
+ /*
+ Test that length('wait/io/socket/' (15) + category + '/' (1)) < 32
+ --> category can be up to 15 chars for a socket.
+ */
+
+ PSI_socket_key dummy_socket_key= 9999;
+ PSI_socket_info bad_socket_1[]=
+ {
+ { & dummy_socket_key, "X", 0}
+ };
+
+ psi->register_socket("/", bad_socket_1, 1);
+ ok(dummy_socket_key == 0, "zero key");
+ dummy_socket_key= 9999;
+ psi->register_socket("a/", bad_socket_1, 1);
+ ok(dummy_socket_key == 0, "zero key");
+ dummy_socket_key= 9999;
+ psi->register_socket("/b", bad_socket_1, 1);
+ ok(dummy_socket_key == 0, "zero key");
+ dummy_socket_key= 9999;
+ psi->register_socket("a/b", bad_socket_1, 1);
+ ok(dummy_socket_key == 0, "zero key");
+ dummy_socket_key= 9999;
+ psi->register_socket("1234567890123456", bad_socket_1, 1);
+ ok(dummy_socket_key == 0, "zero key");
+ dummy_socket_key= 9999;
+ psi->register_socket("123456789012345", bad_socket_1, 1);
+ ok(dummy_socket_key == 1, "assigned key");
+
+ /*
+ Test that length('wait/io/socket/' (15) + category + '/' (1) + name) <= 128
+ --> category + name can be up to 112 chars for a socket.
+ */
+
+ dummy_socket_key= 9999;
+ PSI_socket_info bad_socket_2[]=
+ {
+ { & dummy_socket_key,
+ /* 112 chars name */
+ "12345678901234567890123456789012345678901234567890"
+ "12345678901234567890123456789012345678901234567890"
+ "123456789012",
+ 0}
+ };
+
+ psi->register_socket("X", bad_socket_2, 1);
+ ok(dummy_socket_key == 0, "zero key");
+
+ dummy_socket_key= 9999;
+ PSI_socket_info bad_socket_3[]=
+ {
+ { & dummy_socket_key,
+ /* 111 chars name */
+ "12345678901234567890123456789012345678901234567890"
+ "12345678901234567890123456789012345678901234567890"
+ "12345678901",
+ 0}
+ };
+
+ psi->register_socket("XX", bad_socket_3, 1);
+ ok(dummy_socket_key == 0, "zero key");
+
+ psi->register_socket("X", bad_socket_3, 1);
+ ok(dummy_socket_key == 2, "assigned key");
+
+ unload_performance_schema();
+}
+
+void test_init_disabled()
+{
+ PSI *psi;
+
+ diag("test_init_disabled");
+
+ psi= load_perfschema();
+
+ PSI_mutex_key mutex_key_A;
+ PSI_mutex_info all_mutex[]=
+ {
+ { & mutex_key_A, "M-A", 0}
+ };
+
+ PSI_rwlock_key rwlock_key_A;
+ PSI_rwlock_info all_rwlock[]=
+ {
+ { & rwlock_key_A, "RW-A", 0}
+ };
+
+ PSI_cond_key cond_key_A;
+ PSI_cond_info all_cond[]=
+ {
+ { & cond_key_A, "C-A", 0}
+ };
+
+ PSI_file_key file_key_A;
+ PSI_file_info all_file[]=
+ {
+ { & file_key_A, "F-A", 0}
+ };
+
+ PSI_socket_key socket_key_A;
+ PSI_socket_info all_socket[]=
+ {
+ { & socket_key_A, "S-A", 0}
+ };
+
+ PSI_thread_key thread_key_1;
+ PSI_thread_info all_thread[]=
+ {
+ { & thread_key_1, "T-1", 0}
+ };
+
+ psi->register_mutex("test", all_mutex, 1);
+ psi->register_rwlock("test", all_rwlock, 1);
+ psi->register_cond("test", all_cond, 1);
+ psi->register_file("test", all_file, 1);
+ psi->register_socket("test", all_socket, 1);
+ psi->register_thread("test", all_thread, 1);
+
+ PFS_mutex_class *mutex_class_A;
+ PFS_rwlock_class *rwlock_class_A;
+ PFS_cond_class *cond_class_A;
+ PFS_file_class *file_class_A;
+ PFS_socket_class *socket_class_A;
+ PSI_mutex *mutex_A1;
+ PSI_rwlock *rwlock_A1;
+ PSI_cond *cond_A1;
+ PFS_file *file_A1;
+ PSI_socket *socket_A1;
+ PSI_thread *thread_1;
+
+ /* Preparation */
+
+ thread_1= psi->new_thread(thread_key_1, NULL, 0);
+ ok(thread_1 != NULL, "T-1");
+ psi->set_thread_id(thread_1, 1);
+
+ mutex_class_A= find_mutex_class(mutex_key_A);
+ ok(mutex_class_A != NULL, "mutex class A");
+
+ rwlock_class_A= find_rwlock_class(rwlock_key_A);
+ ok(rwlock_class_A != NULL, "rwlock class A");
+
+ cond_class_A= find_cond_class(cond_key_A);
+ ok(cond_class_A != NULL, "cond class A");
+
+ file_class_A= find_file_class(file_key_A);
+ ok(file_class_A != NULL, "file class A");
+
+ socket_class_A= find_socket_class(socket_key_A);
+ ok(socket_class_A != NULL, "socket class A");
+
+ /*
+ Pretend thread T-1 is running, and disabled, with thread_instrumentation.
+ Disabled instruments are still created so they can be enabled later.
+ */
+
+ /* ------------------------------------------------------------------------ */
+
+ psi->set_thread(thread_1);
+ setup_thread(thread_1, false);
+
+ /* disabled M-A + disabled T-1: instrumentation */
+
+ mutex_class_A->m_enabled= false;
+ mutex_A1= psi->init_mutex(mutex_key_A, NULL);
+ ok(mutex_A1 != NULL, "mutex_A1 disabled, instrumented");
+
+ /* enabled M-A + disabled T-1: instrumentation (for later) */
+
+ mutex_class_A->m_enabled= true;
+ mutex_A1= psi->init_mutex(mutex_key_A, NULL);
+ ok(mutex_A1 != NULL, "mutex_A1 enabled, instrumented");
+
+ /* broken key + disabled T-1: no instrumentation */
+
+ mutex_class_A->m_enabled= true;
+ mutex_A1= psi->init_mutex(0, NULL);
+ ok(mutex_A1 == NULL, "mutex key 0 not instrumented");
+ mutex_A1= psi->init_mutex(99, NULL);
+ ok(mutex_A1 == NULL, "broken mutex key not instrumented");
+
+ /* disabled RW-A + disabled T-1: no instrumentation */
+
+ rwlock_class_A->m_enabled= false;
+ rwlock_A1= psi->init_rwlock(rwlock_key_A, NULL);
+ ok(rwlock_A1 != NULL, "rwlock_A1 disabled, instrumented");
+
+ /* enabled RW-A + disabled T-1: instrumentation (for later) */
+
+ rwlock_class_A->m_enabled= true;
+ rwlock_A1= psi->init_rwlock(rwlock_key_A, NULL);
+ ok(rwlock_A1 != NULL, "rwlock_A1 enabled, instrumented");
+
+ /* broken key + disabled T-1: no instrumentation */
+
+ rwlock_class_A->m_enabled= true;
+ rwlock_A1= psi->init_rwlock(0, NULL);
+ ok(rwlock_A1 == NULL, "rwlock key 0 not instrumented");
+ rwlock_A1= psi->init_rwlock(99, NULL);
+ ok(rwlock_A1 == NULL, "broken rwlock key not instrumented");
+
+ /* disabled C-A + disabled T-1: no instrumentation */
+
+ cond_class_A->m_enabled= false;
+ cond_A1= psi->init_cond(cond_key_A, NULL);
+ ok(cond_A1 != NULL, "cond_A1 disabled, instrumented");
+
+ /* enabled C-A + disabled T-1: instrumentation (for later) */
+
+ cond_class_A->m_enabled= true;
+ cond_A1= psi->init_cond(cond_key_A, NULL);
+ ok(cond_A1 != NULL, "cond_A1 enabled, instrumented");
+
+ /* broken key + disabled T-1: no instrumentation */
+
+ cond_class_A->m_enabled= true;
+ cond_A1= psi->init_cond(0, NULL);
+ ok(cond_A1 == NULL, "cond key 0 not instrumented");
+ cond_A1= psi->init_cond(99, NULL);
+ ok(cond_A1 == NULL, "broken cond key not instrumented");
+
+ /* disabled F-A + disabled T-1: no instrumentation */
+
+ file_class_A->m_enabled= false;
+ psi->create_file(file_key_A, "foo", (File) 12);
+ file_A1= lookup_file_by_name("foo");
+ ok(file_A1 == NULL, "not instrumented");
+
+ /* enabled F-A + disabled T-1: no instrumentation */
+
+ file_class_A->m_enabled= true;
+ psi->create_file(file_key_A, "foo", (File) 12);
+ file_A1= lookup_file_by_name("foo");
+ ok(file_A1 == NULL, "not instrumented");
+
+ /* broken key + disabled T-1: no instrumentation */
+
+ file_class_A->m_enabled= true;
+ psi->create_file(0, "foo", (File) 12);
+ file_A1= lookup_file_by_name("foo");
+ ok(file_A1 == NULL, "file_A1 not instrumented");
+ psi->create_file(99, "foo", (File) 12);
+ file_A1= lookup_file_by_name("foo");
+ ok(file_A1 == NULL, "file_A1 not instrumented");
+
+ /* disabled S-A + disabled T-1: no instrumentation */
+
+ socket_class_A->m_enabled= false;
+ socket_A1= psi->init_socket(socket_key_A, NULL, NULL, 0);
+ ok(socket_A1 != NULL, "socket_A1 disabled, instrumented");
+
+ /* enabled S-A + disabled T-1: instrumentation (for later) */
+
+ socket_class_A->m_enabled= true;
+ socket_A1= psi->init_socket(socket_key_A, NULL, NULL, 0);
+ ok(socket_A1 != NULL, "socket_A1 enabled, instrumented");
+
+ /* broken key + disabled T-1: no instrumentation */
+
+ socket_class_A->m_enabled= true;
+ socket_A1= psi->init_socket(0, NULL, NULL, 0);
+ ok(socket_A1 == NULL, "socket key 0 not instrumented");
+ socket_A1= psi->init_socket(99, NULL, NULL, 0);
+ ok(socket_A1 == NULL, "broken socket key not instrumented");
+
+ /* Pretend thread T-1 is enabled */
+ /* ----------------------------- */
+
+ setup_thread(thread_1, true);
+
+ /* disabled M-A + enabled T-1: no instrumentation */
+
+ mutex_class_A->m_enabled= false;
+ mutex_A1= psi->init_mutex(mutex_key_A, NULL);
+ ok(mutex_A1 != NULL, "mutex_A1 disabled, instrumented");
+
+ /* enabled M-A + enabled T-1: instrumentation */
+
+ mutex_class_A->m_enabled= true;
+ mutex_A1= psi->init_mutex(mutex_key_A, NULL);
+ ok(mutex_A1 != NULL, "mutex_A1 enabled, instrumented");
+ psi->destroy_mutex(mutex_A1);
+
+ /* broken key + enabled T-1: no instrumentation */
+
+ mutex_class_A->m_enabled= true;
+ mutex_A1= psi->init_mutex(0, NULL);
+ ok(mutex_A1 == NULL, "mutex_A1 not instrumented");
+ mutex_A1= psi->init_mutex(99, NULL);
+ ok(mutex_A1 == NULL, "mutex_A1 not instrumented");
+
+ /* disabled RW-A + enabled T-1: no instrumentation */
+
+ rwlock_class_A->m_enabled= false;
+ rwlock_A1= psi->init_rwlock(rwlock_key_A, NULL);
+ ok(rwlock_A1 != NULL, "rwlock_A1 disabled, instrumented");
+
+ /* enabled RW-A + enabled T-1: instrumentation */
+
+ rwlock_class_A->m_enabled= true;
+ rwlock_A1= psi->init_rwlock(rwlock_key_A, NULL);
+ ok(rwlock_A1 != NULL, "rwlock_A1 enabled, instrumented");
+ psi->destroy_rwlock(rwlock_A1);
+
+ /* broken key + enabled T-1: no instrumentation */
+
+ rwlock_class_A->m_enabled= true;
+ rwlock_A1= psi->init_rwlock(0, NULL);
+ ok(rwlock_A1 == NULL, "rwlock_A1 not instrumented");
+ rwlock_A1= psi->init_rwlock(99, NULL);
+ ok(rwlock_A1 == NULL, "rwlock_A1 not instrumented");
+
+ /* disabled C-A + enabled T-1: no instrumentation */
+
+ cond_class_A->m_enabled= false;
+ cond_A1= psi->init_cond(cond_key_A, NULL);
+ ok(cond_A1 != NULL, "cond_A1 disabled, instrumented");
+
+ /* enabled C-A + enabled T-1: instrumentation */
+
+ cond_class_A->m_enabled= true;
+ cond_A1= psi->init_cond(cond_key_A, NULL);
+ ok(cond_A1 != NULL, "cond_A1 enabled, instrumented");
+ psi->destroy_cond(cond_A1);
+
+ /* broken key + enabled T-1: no instrumentation */
+
+ cond_class_A->m_enabled= true;
+ cond_A1= psi->init_cond(0, NULL);
+ ok(cond_A1 == NULL, "cond_A1 not instrumented");
+ cond_A1= psi->init_cond(99, NULL);
+ ok(cond_A1 == NULL, "cond_A1 not instrumented");
+
+ /* disabled F-A + enabled T-1: no instrumentation */
+
+ file_class_A->m_enabled= false;
+ psi->create_file(file_key_A, "foo", (File) 12);
+ file_A1= lookup_file_by_name("foo");
+ ok(file_A1 == NULL, "file_A1 not instrumented");
+
+ /* enabled F-A + open failed + enabled T-1: no instrumentation */
+
+ file_class_A->m_enabled= true;
+ psi->create_file(file_key_A, "foo", (File) -1);
+ file_A1= lookup_file_by_name("foo");
+ ok(file_A1 == NULL, "file_A1 not instrumented");
+
+ /* enabled F-A + out-of-descriptors + enabled T-1: no instrumentation */
+
+ file_class_A->m_enabled= true;
+ psi->create_file(file_key_A, "foo", (File) 65000);
+ file_A1= lookup_file_by_name("foo");
+ ok(file_A1 == NULL, "file_A1 not instrumented");
+ ok(file_handle_lost == 1, "lost a file handle");
+ file_handle_lost= 0;
+
+ /* enabled F-A + enabled T-1: instrumentation */
+
+ file_class_A->m_enabled= true;
+ psi->create_file(file_key_A, "foo-instrumented", (File) 12);
+ file_A1= lookup_file_by_name("foo-instrumented");
+ ok(file_A1 != NULL, "file_A1 instrumented");
+ destroy_file(reinterpret_cast<PFS_thread*>(psi->get_thread()), file_A1);
+
+ /* broken key + enabled T-1: no instrumentation */
+
+ file_class_A->m_enabled= true;
+ psi->create_file(0, "foo", (File) 12);
+ file_A1= lookup_file_by_name("foo");
+ ok(file_A1 == NULL, "file key 0 not instrumented");
+ psi->create_file(99, "foo", (File) 12);
+ file_A1= lookup_file_by_name("foo");
+ ok(file_A1 == NULL, "broken file key not instrumented");
+
+ /* disabled S-A + enabled T-1: no instrumentation */
+
+ socket_class_A->m_enabled= false;
+ ok(socket_A1 == NULL, "socket_A1 not instrumented");
+
+ /* enabled S-A + enabled T-1: instrumentation */
+
+ socket_class_A->m_enabled= true;
+ socket_A1= psi->init_socket(socket_key_A, NULL, NULL, 0);
+ ok(socket_A1 != NULL, "socket_A1 instrumented");
+ psi->destroy_socket(socket_A1);
+
+ /* broken key + enabled T-1: no instrumentation */
+
+ socket_class_A->m_enabled= true;
+ socket_A1= psi->init_socket(0, NULL, NULL, 0);
+ ok(socket_A1 == NULL, "socket_A1 not instrumented");
+ socket_A1= psi->init_socket(99, NULL, NULL, 0);
+ ok(socket_A1 == NULL, "socket_A1 not instrumented");
+
+ /* Pretend the running thread is not instrumented */
+ /* ---------------------------------------------- */
+
+ psi->delete_current_thread();
+
+ /* disabled M-A + unknown thread: no instrumentation */
+
+ mutex_class_A->m_enabled= false;
+ mutex_A1= psi->init_mutex(mutex_key_A, NULL);
+ ok(mutex_A1 != NULL, "mutex_A1 disabled, instrumented");
+
+ /* enabled M-A + unknown thread: instrumentation (for later) */
+
+ mutex_class_A->m_enabled= true;
+ mutex_A1= psi->init_mutex(mutex_key_A, NULL);
+ ok(mutex_A1 != NULL, "mutex_A1 enabled, instrumented");
+
+ /* broken key + unknown thread: no instrumentation */
+
+ mutex_class_A->m_enabled= true;
+ mutex_A1= psi->init_mutex(0, NULL);
+ ok(mutex_A1 == NULL, "mutex key 0 not instrumented");
+ mutex_A1= psi->init_mutex(99, NULL);
+ ok(mutex_A1 == NULL, "broken mutex key not instrumented");
+
+ /* disabled RW-A + unknown thread: no instrumentation */
+
+ rwlock_class_A->m_enabled= false;
+ rwlock_A1= psi->init_rwlock(rwlock_key_A, NULL);
+ ok(rwlock_A1 != NULL, "rwlock_A1 disabled, instrumented");
+
+ /* enabled RW-A + unknown thread: instrumentation (for later) */
+
+ rwlock_class_A->m_enabled= true;
+ rwlock_A1= psi->init_rwlock(rwlock_key_A, NULL);
+ ok(rwlock_A1 != NULL, "rwlock_A1 enabled, instrumented");
+
+ /* broken key + unknown thread: no instrumentation */
+
+ rwlock_class_A->m_enabled= true;
+ rwlock_A1= psi->init_rwlock(0, NULL);
+ ok(rwlock_A1 == NULL, "rwlock key 0 not instrumented");
+ rwlock_A1= psi->init_rwlock(99, NULL);
+ ok(rwlock_A1 == NULL, "broken rwlock key not instrumented");
+
+ /* disabled C-A + unknown thread: no instrumentation */
+
+ cond_class_A->m_enabled= false;
+ cond_A1= psi->init_cond(cond_key_A, NULL);
+ ok(cond_A1 != NULL, "cond_A1 disabled, instrumented");
+
+ /* enabled C-A + unknown thread: instrumentation (for later) */
+
+ cond_class_A->m_enabled= true;
+ cond_A1= psi->init_cond(cond_key_A, NULL);
+ ok(cond_A1 != NULL, "cond_A1 enabled, instrumented");
+
+ /* broken key + unknown thread: no instrumentation */
+
+ cond_class_A->m_enabled= true;
+ cond_A1= psi->init_cond(0, NULL);
+ ok(cond_A1 == NULL, "cond key 0 not instrumented");
+ cond_A1= psi->init_cond(99, NULL);
+ ok(cond_A1 == NULL, "broken cond key not instrumented");
+
+ /* disabled F-A + unknown thread: no instrumentation */
+
+ file_class_A->m_enabled= false;
+ psi->create_file(file_key_A, "foo", (File) 12);
+ file_A1= lookup_file_by_name("foo");
+ ok(file_A1 == NULL, "file_A1 not instrumented");
+
+ /* enabled F-A + unknown thread: no instrumentation */
+
+ file_class_A->m_enabled= true;
+ psi->create_file(file_key_A, "foo", (File) 12);
+ file_A1= lookup_file_by_name("foo");
+ ok(file_A1 == NULL, "file_A1 not instrumented");
+
+ /* broken key + unknown thread: no instrumentation */
+
+ file_class_A->m_enabled= true;
+ psi->create_file(0, "foo", (File) 12);
+ file_A1= lookup_file_by_name("foo");
+ ok(file_A1 == NULL, "not instrumented");
+ psi->create_file(99, "foo", (File) 12);
+ file_A1= lookup_file_by_name("foo");
+ ok(file_A1 == NULL, "not instrumented");
+
+ /* disabled S-A + unknown thread: no instrumentation */
+
+ socket_class_A->m_enabled= false;
+ socket_A1= psi->init_socket(socket_key_A, NULL, NULL, 0);
+ ok(socket_A1 != NULL, "socket_A1 disabled, instrumented");
+
+ /* enabled S-A + unknown thread: instrumentation (for later) */
+
+ socket_class_A->m_enabled= true;
+ socket_A1= psi->init_socket(socket_key_A, NULL, NULL, 0);
+ ok(socket_A1 != NULL, "socket_A1 enabled, instrumented");
+
+ /* broken key + unknown thread: no instrumentation */
+
+ socket_class_A->m_enabled= true;
+ socket_A1= psi->init_socket(0, NULL, NULL, 0);
+ ok(socket_A1 == NULL, "socket key 0 not instrumented");
+ socket_A1= psi->init_socket(99, NULL, NULL, 0);
+ ok(socket_A1 == NULL, "broken socket key not instrumented");
+
+ unload_performance_schema();
+}
+
+void test_locker_disabled()
+{
+ PSI *psi;
+
+ diag("test_locker_disabled");
+
+ psi= load_perfschema();
+
+ PSI_mutex_key mutex_key_A;
+ PSI_mutex_info all_mutex[]=
+ {
+ { & mutex_key_A, "M-A", 0}
+ };
+
+ PSI_rwlock_key rwlock_key_A;
+ PSI_rwlock_info all_rwlock[]=
+ {
+ { & rwlock_key_A, "RW-A", 0}
+ };
+
+ PSI_cond_key cond_key_A;
+ PSI_cond_info all_cond[]=
+ {
+ { & cond_key_A, "C-A", 0}
+ };
+
+ PSI_file_key file_key_A;
+ PSI_file_info all_file[]=
+ {
+ { & file_key_A, "F-A", 0}
+ };
+
+ PSI_socket_key socket_key_A;
+ PSI_socket_info all_socket[]=
+ {
+ { & socket_key_A, "S-A", 0}
+ };
+
+ PSI_thread_key thread_key_1;
+ PSI_thread_info all_thread[]=
+ {
+ { & thread_key_1, "T-1", 0}
+ };
+
+ psi->register_mutex("test", all_mutex, 1);
+ psi->register_rwlock("test", all_rwlock, 1);
+ psi->register_cond("test", all_cond, 1);
+ psi->register_file("test", all_file, 1);
+ psi->register_socket("test", all_socket, 1);
+ psi->register_thread("test", all_thread, 1);
+
+ PFS_mutex_class *mutex_class_A;
+ PFS_rwlock_class *rwlock_class_A;
+ PFS_cond_class *cond_class_A;
+ PFS_file_class *file_class_A;
+ PFS_socket_class *socket_class_A;
+ PSI_mutex *mutex_A1;
+ PSI_rwlock *rwlock_A1;
+ PSI_cond *cond_A1;
+ PSI_file *file_A1;
+ PSI_socket *socket_A1;
+ PSI_thread *thread_1;
+
+ /* Preparation */
+
+ thread_1= psi->new_thread(thread_key_1, NULL, 0);
+ ok(thread_1 != NULL, "T-1");
+ psi->set_thread_id(thread_1, 1);
+
+ mutex_class_A= find_mutex_class(mutex_key_A);
+ ok(mutex_class_A != NULL, "mutex info A");
+
+ rwlock_class_A= find_rwlock_class(rwlock_key_A);
+ ok(rwlock_class_A != NULL, "rwlock info A");
+
+ cond_class_A= find_cond_class(cond_key_A);
+ ok(cond_class_A != NULL, "cond info A");
+
+ file_class_A= find_file_class(file_key_A);
+ ok(file_class_A != NULL, "file info A");
+
+ socket_class_A= find_socket_class(socket_key_A);
+ ok(socket_class_A != NULL, "socket info A");
+
+ /* Pretend thread T-1 is running, and enabled */
+ /* ------------------------------------------ */
+
+ psi->set_thread(thread_1);
+ setup_thread(thread_1, true);
+
+ /* Enable all instruments, instantiate objects */
+
+ mutex_class_A->m_enabled= true;
+ mutex_A1= psi->init_mutex(mutex_key_A, NULL);
+ ok(mutex_A1 != NULL, "instrumented");
+
+ rwlock_class_A->m_enabled= true;
+ rwlock_A1= psi->init_rwlock(rwlock_key_A, NULL);
+ ok(rwlock_A1 != NULL, "instrumented");
+
+ cond_class_A->m_enabled= true;
+ cond_A1= psi->init_cond(cond_key_A, NULL);
+ ok(cond_A1 != NULL, "instrumented");
+
+ file_class_A->m_enabled= true;
+ psi->create_file(file_key_A, "foo", (File) 12);
+ file_A1= (PSI_file*) lookup_file_by_name("foo");
+ ok(file_A1 != NULL, "instrumented");
+ destroy_file(reinterpret_cast<PFS_thread*>(psi->get_thread()),
+ reinterpret_cast<PFS_file*>(file_A1));
+
+ socket_class_A->m_enabled= true;
+ socket_A1= psi->init_socket(socket_key_A, NULL, NULL, 0);
+ ok(socket_A1 != NULL, "instrumented");
+
+ /* Socket lockers require a thread owner */
+ psi->set_socket_thread_owner(socket_A1);
+
+ PSI_mutex_locker *mutex_locker;
+ PSI_mutex_locker_state mutex_state;
+ PSI_rwlock_locker *rwlock_locker;
+ PSI_rwlock_locker_state rwlock_state;
+ PSI_cond_locker *cond_locker;
+ PSI_cond_locker_state cond_state;
+ PSI_file_locker *file_locker;
+ PSI_file_locker_state file_state;
+ PSI_socket_locker *socket_locker;
+ PSI_socket_locker_state socket_state;
+
+ /* Pretend thread T-1 is disabled */
+ /* ------------------------------ */
+
+ setup_thread(thread_1, false);
+ flag_events_waits_current= true;
+ mutex_class_A->m_enabled= true;
+ rwlock_class_A->m_enabled= true;
+ cond_class_A->m_enabled= true;
+ file_class_A->m_enabled= true;
+ socket_class_A->m_enabled= true;
+
+ mutex_locker= psi->start_mutex_wait(&mutex_state, mutex_A1, PSI_MUTEX_LOCK, "foo.cc", 12);
+ ok(mutex_locker == NULL, "no locker (T-1 disabled)");
+ rwlock_locker= psi->start_rwlock_rdwait(&rwlock_state, rwlock_A1, PSI_RWLOCK_READLOCK, "foo.cc", 12);
+ ok(rwlock_locker == NULL, "no locker (T-1 disabled)");
+ cond_locker= psi->start_cond_wait(&cond_state, cond_A1, mutex_A1, PSI_COND_WAIT, "foo.cc", 12);
+ ok(cond_locker == NULL, "no locker (T-1 disabled)");
+ file_locker= psi->get_thread_file_name_locker(&file_state, file_key_A, PSI_FILE_OPEN, "xxx", NULL);
+ ok(file_locker == NULL, "no locker (T-1 disabled)");
+ file_locker= psi->get_thread_file_stream_locker(&file_state, file_A1, PSI_FILE_READ);
+ ok(file_locker == NULL, "no locker (T-1 disabled)");
+ file_locker= psi->get_thread_file_descriptor_locker(&file_state, (File) 12, PSI_FILE_READ);
+ ok(file_locker == NULL, "no locker (T-1 disabled)");
+ socket_locker= psi->start_socket_wait(&socket_state, socket_A1, PSI_SOCKET_SEND, 12, "foo.cc", 12);
+ ok(socket_locker == NULL, "no locker (T-1 disabled)");
+
+ /* Pretend the global consumer is disabled */
+ /* --------------------------------------- */
+
+ setup_thread(thread_1, true);
+ flag_global_instrumentation= false;
+ mutex_class_A->m_enabled= true;
+ rwlock_class_A->m_enabled= true;
+ cond_class_A->m_enabled= true;
+ file_class_A->m_enabled= true;
+ socket_class_A->m_enabled= true;
+ update_instruments_derived_flags();
+
+ mutex_locker= psi->start_mutex_wait(&mutex_state, mutex_A1, PSI_MUTEX_LOCK, "foo.cc", 12);
+ ok(mutex_locker == NULL, "no locker (global disabled)");
+ rwlock_locker= psi->start_rwlock_rdwait(&rwlock_state, rwlock_A1, PSI_RWLOCK_READLOCK, "foo.cc", 12);
+ ok(rwlock_locker == NULL, "no locker (global disabled)");
+ cond_locker= psi->start_cond_wait(&cond_state, cond_A1, mutex_A1, PSI_COND_WAIT, "foo.cc", 12);
+ ok(cond_locker == NULL, "no locker (global disabled)");
+ file_locker= psi->get_thread_file_name_locker(&file_state, file_key_A, PSI_FILE_OPEN, "xxx", NULL);
+ ok(file_locker == NULL, "no locker (global disabled)");
+ file_locker= psi->get_thread_file_stream_locker(&file_state, file_A1, PSI_FILE_READ);
+ ok(file_locker == NULL, "no locker (global disabled)");
+ file_locker= psi->get_thread_file_descriptor_locker(&file_state, (File) 12, PSI_FILE_READ);
+ ok(file_locker == NULL, "no locker (global disabled)");
+ socket_locker= psi->start_socket_wait(&socket_state, socket_A1, PSI_SOCKET_SEND, 12, "foo.cc", 12);
+ ok(socket_locker == NULL, "no locker (global disabled)");
+
+ /* Pretend the mode is global, counted only */
+ /* ---------------------------------------- */
+
+ setup_thread(thread_1, true);
+ flag_global_instrumentation= true;
+ flag_thread_instrumentation= false;
+ mutex_class_A->m_enabled= true;
+ mutex_class_A->m_timed= false;
+ rwlock_class_A->m_enabled= true;
+ rwlock_class_A->m_timed= false;
+ cond_class_A->m_enabled= true;
+ cond_class_A->m_timed= false;
+ file_class_A->m_enabled= true;
+ file_class_A->m_timed= false;
+ socket_class_A->m_enabled= true;
+ socket_class_A->m_timed= false;
+ update_instruments_derived_flags();
+
+ mutex_locker= psi->start_mutex_wait(&mutex_state, mutex_A1, PSI_MUTEX_LOCK, "foo.cc", 12);
+ ok(mutex_locker == NULL, "no locker (global counted)");
+ rwlock_locker= psi->start_rwlock_rdwait(&rwlock_state, rwlock_A1, PSI_RWLOCK_READLOCK, "foo.cc", 12);
+ ok(rwlock_locker == NULL, "no locker (global counted)");
+ cond_locker= psi->start_cond_wait(&cond_state, cond_A1, mutex_A1, PSI_COND_WAIT, "foo.cc", 12);
+ ok(cond_locker == NULL, "no locker (global counted)");
+ file_locker= psi->get_thread_file_name_locker(&file_state, file_key_A, PSI_FILE_OPEN, "xxx", NULL);
+ ok(file_locker != NULL, "locker (global counted)");
+ psi->start_file_wait(file_locker, 10, __FILE__, __LINE__);
+ psi->end_file_wait(file_locker, 10);
+ file_locker= psi->get_thread_file_stream_locker(&file_state, file_A1, PSI_FILE_READ);
+ ok(file_locker != NULL, "locker (global counted)");
+ psi->start_file_wait(file_locker, 10, __FILE__, __LINE__);
+ psi->end_file_wait(file_locker, 10);
+ file_locker= psi->get_thread_file_descriptor_locker(&file_state, (File) 12, PSI_FILE_READ);
+ ok(file_locker != NULL, "locker (global counted)");
+ psi->start_file_wait(file_locker, 10, __FILE__, __LINE__);
+ psi->end_file_wait(file_locker, 10);
+ /* The null locker shortcut applies only to socket ops with no byte count */
+ socket_locker= psi->start_socket_wait(&socket_state, socket_A1, PSI_SOCKET_BIND, 0, "foo.cc", 12);
+ ok(socket_locker == NULL, "no locker (global counted)");
+
+ /* TODO */
+
+ /* Pretend the instrument is disabled */
+ /* ---------------------------------- */
+
+ setup_thread(thread_1, true);
+ flag_global_instrumentation= true;
+ flag_events_waits_current= true;
+ mutex_class_A->m_enabled= false;
+ rwlock_class_A->m_enabled= false;
+ cond_class_A->m_enabled= false;
+ file_class_A->m_enabled= false;
+ socket_class_A->m_enabled= false;
+ update_instruments_derived_flags();
+
+ mutex_locker= psi->start_mutex_wait(&mutex_state, mutex_A1, PSI_MUTEX_LOCK, "foo.cc", 12);
+ ok(mutex_locker == NULL, "no locker");
+ rwlock_locker= psi->start_rwlock_rdwait(&rwlock_state, rwlock_A1, PSI_RWLOCK_READLOCK, "foo.cc", 12);
+ ok(rwlock_locker == NULL, "no locker");
+ cond_locker= psi->start_cond_wait(&cond_state, cond_A1, mutex_A1, PSI_COND_WAIT, "foo.cc", 12);
+ ok(cond_locker == NULL, "no locker");
+ file_locker= psi->get_thread_file_name_locker(&file_state, file_key_A, PSI_FILE_OPEN, "xxx", NULL);
+ ok(file_locker == NULL, "no locker");
+ file_locker= psi->get_thread_file_stream_locker(&file_state, file_A1, PSI_FILE_READ);
+ ok(file_locker == NULL, "no locker");
+ file_locker= psi->get_thread_file_descriptor_locker(&file_state, (File) 12, PSI_FILE_READ);
+ ok(file_locker == NULL, "no locker");
+ socket_locker= psi->start_socket_wait(&socket_state, socket_A1, PSI_SOCKET_SEND, 12, "foo.cc", 12);
+ ok(socket_locker == NULL, "no locker");
+
+ /* Pretend everything is enabled and timed */
+ /* --------------------------------------- */
+
+ setup_thread(thread_1, true);
+ flag_global_instrumentation= true;
+ flag_thread_instrumentation= true;
+ flag_events_waits_current= true;
+ mutex_class_A->m_enabled= true;
+ mutex_class_A->m_timed= true;
+ rwlock_class_A->m_enabled= true;
+ rwlock_class_A->m_timed= true;
+ cond_class_A->m_enabled= true;
+ cond_class_A->m_timed= true;
+ file_class_A->m_enabled= true;
+ file_class_A->m_timed= true;
+ socket_class_A->m_enabled= true;
+ socket_class_A->m_timed= true;
+ update_instruments_derived_flags();
+
+ mutex_locker= psi->start_mutex_wait(&mutex_state, mutex_A1, PSI_MUTEX_LOCK, __FILE__, __LINE__);
+ ok(mutex_locker != NULL, "locker");
+ psi->end_mutex_wait(mutex_locker, 0);
+ rwlock_locker= psi->start_rwlock_rdwait(&rwlock_state, rwlock_A1, PSI_RWLOCK_READLOCK, __FILE__, __LINE__);
+ ok(rwlock_locker != NULL, "locker");
+ psi->end_rwlock_rdwait(rwlock_locker, 0);
+ cond_locker= psi->start_cond_wait(&cond_state, cond_A1, mutex_A1, PSI_COND_WAIT, __FILE__, __LINE__);
+ ok(cond_locker != NULL, "locker");
+ psi->end_cond_wait(cond_locker, 0);
+ file_locker= psi->get_thread_file_name_locker(&file_state, file_key_A, PSI_FILE_STREAM_OPEN, "xxx", NULL);
+ ok(file_locker != NULL, "locker");
+ psi->start_file_open_wait(file_locker, __FILE__, __LINE__);
+ psi->end_file_open_wait(file_locker, NULL);
+ file_locker= psi->get_thread_file_stream_locker(&file_state, file_A1, PSI_FILE_READ);
+ ok(file_locker != NULL, "locker");
+ psi->start_file_wait(file_locker, 10, __FILE__, __LINE__);
+ psi->end_file_wait(file_locker, 10);
+ file_locker= psi->get_thread_file_descriptor_locker(&file_state, (File) 12, PSI_FILE_READ);
+ ok(file_locker != NULL, "locker");
+ psi->start_file_wait(file_locker, 10, __FILE__, __LINE__);
+ psi->end_file_wait(file_locker, 10);
+ socket_locker= psi->start_socket_wait(&socket_state, socket_A1, PSI_SOCKET_SEND, 12, "foo.cc", 12);
+ ok(socket_locker != NULL, "locker");
+ psi->end_socket_wait(socket_locker, 10);
+
+ /* Pretend the socket does not have a thread owner */
+ /* ---------------------------------------------- */
+
+ socket_class_A->m_enabled= true;
+ socket_A1= psi->init_socket(socket_key_A, NULL, NULL, 0);
+ ok(socket_A1 != NULL, "instrumented");
+ /* Socket thread owner has not been set */
+ socket_locker= psi->start_socket_wait(&socket_state, socket_A1, PSI_SOCKET_SEND, 12, "foo.cc", 12);
+ ok(socket_locker != NULL, "locker (owner not used)");
+ psi->end_socket_wait(socket_locker, 10);
+
+ /* Pretend the running thread is not instrumented */
+ /* ---------------------------------------------- */
+
+ psi->delete_current_thread();
+ flag_events_waits_current= true;
+ mutex_class_A->m_enabled= true;
+ rwlock_class_A->m_enabled= true;
+ cond_class_A->m_enabled= true;
+ file_class_A->m_enabled= true;
+ socket_class_A->m_enabled= true;
+ update_instruments_derived_flags();
+
+ mutex_locker= psi->start_mutex_wait(&mutex_state, mutex_A1, PSI_MUTEX_LOCK, "foo.cc", 12);
+ ok(mutex_locker == NULL, "no locker");
+ rwlock_locker= psi->start_rwlock_rdwait(&rwlock_state, rwlock_A1, PSI_RWLOCK_READLOCK, "foo.cc", 12);
+ ok(rwlock_locker == NULL, "no locker");
+ cond_locker= psi->start_cond_wait(&cond_state, cond_A1, mutex_A1, PSI_COND_WAIT, "foo.cc", 12);
+ ok(cond_locker == NULL, "no locker");
+ file_locker= psi->get_thread_file_name_locker(&file_state, file_key_A, PSI_FILE_OPEN, "xxx", NULL);
+ ok(file_locker == NULL, "no locker");
+ file_locker= psi->get_thread_file_stream_locker(&file_state, file_A1, PSI_FILE_READ);
+ ok(file_locker == NULL, "no locker");
+ file_locker= psi->get_thread_file_descriptor_locker(&file_state, (File) 12, PSI_FILE_READ);
+ ok(file_locker == NULL, "no locker");
+ socket_locker= psi->start_socket_wait(&socket_state, socket_A1, PSI_SOCKET_SEND, 12, "foo.cc", 12);
+ ok(socket_locker == NULL, "no locker");
+
+ unload_performance_schema();
+}
+
+void test_file_instrumentation_leak()
+{
+ PSI *psi;
+
+ diag("test_file_instrumentation_leak");
+
+ psi= load_perfschema();
+
+ PSI_file_key file_key_A;
+ PSI_file_key file_key_B;
+ PSI_file_info all_file[]=
+ {
+ { & file_key_A, "F-A", 0},
+ { & file_key_B, "F-B", 0}
+ };
+
+ PSI_thread_key thread_key_1;
+ PSI_thread_info all_thread[]=
+ {
+ { & thread_key_1, "T-1", 0}
+ };
+
+ psi->register_file("test", all_file, 2);
+ psi->register_thread("test", all_thread, 1);
+
+ PFS_file_class *file_class_A;
+ PFS_file_class *file_class_B;
+ PSI_file_locker_state file_state;
+ PSI_thread *thread_1;
+
+ /* Preparation */
+
+ thread_1= psi->new_thread(thread_key_1, NULL, 0);
+ ok(thread_1 != NULL, "T-1");
+ psi->set_thread_id(thread_1, 1);
+
+ file_class_A= find_file_class(file_key_A);
+ ok(file_class_A != NULL, "file info A");
+
+ file_class_B= find_file_class(file_key_B);
+ ok(file_class_B != NULL, "file info B");
+
+ psi->set_thread(thread_1);
+
+ /* Pretend everything is enabled */
+ /* ----------------------------- */
+
+ setup_thread(thread_1, true);
+ flag_events_waits_current= true;
+ file_class_A->m_enabled= true;
+ file_class_B->m_enabled= true;
+
+ PSI_file_locker *file_locker;
+
+ /* Simulate OPEN + READ of 100 bytes + CLOSE on descriptor 12 */
+
+ file_locker= psi->get_thread_file_name_locker(&file_state, file_key_A, PSI_FILE_OPEN, "AAA", NULL);
+ ok(file_locker != NULL, "locker");
+ psi->start_file_open_wait(file_locker, __FILE__, __LINE__);
+ psi->end_file_open_wait_and_bind_to_descriptor(file_locker, 12);
+
+ file_locker= psi->get_thread_file_descriptor_locker(&file_state, (File) 12, PSI_FILE_READ);
+ ok(file_locker != NULL, "locker");
+ psi->start_file_wait(file_locker, 100, __FILE__, __LINE__);
+ psi->end_file_wait(file_locker, 100);
+
+ file_locker= psi->get_thread_file_descriptor_locker(&file_state, (File) 12, PSI_FILE_CLOSE);
+ ok(file_locker != NULL, "locker");
+ psi->start_file_wait(file_locker, 0, __FILE__, __LINE__);
+ psi->end_file_wait(file_locker, 0);
+
+ /* Simulate uninstrumented-OPEN + WRITE on descriptor 24 */
+
+ file_locker= psi->get_thread_file_descriptor_locker(&file_state, (File) 24, PSI_FILE_WRITE);
+ ok(file_locker == NULL, "no locker, since the open was not instrumented");
+
+ /*
+ Simulate uninstrumented-OPEN + WRITE on descriptor 12 :
+ the instrumentation should not leak (don't charge the file io on unknown B to "AAA")
+ */
+
+ file_locker= psi->get_thread_file_descriptor_locker(&file_state, (File) 12, PSI_FILE_WRITE);
+ ok(file_locker == NULL, "no locker, no leak");
+
+ unload_performance_schema();
+}
+
+void test_enabled()
+{
+#ifdef LATER
+ PSI *psi;
+
+ diag("test_enabled");
+
+ psi= load_perfschema();
+
+ PSI_mutex_key mutex_key_A;
+ PSI_mutex_key mutex_key_B;
+ PSI_mutex_info all_mutex[]=
+ {
+ { & mutex_key_A, "M-A", 0},
+ { & mutex_key_B, "M-B", 0}
+ };
+
+ PSI_rwlock_key rwlock_key_A;
+ PSI_rwlock_key rwlock_key_B;
+ PSI_rwlock_info all_rwlock[]=
+ {
+ { & rwlock_key_A, "RW-A", 0},
+ { & rwlock_key_B, "RW-B", 0}
+ };
+
+ PSI_cond_key cond_key_A;
+ PSI_cond_key cond_key_B;
+ PSI_cond_info all_cond[]=
+ {
+ { & cond_key_A, "C-A", 0},
+ { & cond_key_B, "C-B", 0}
+ };
+
+ unload_performance_schema();
+#endif
+}
+
+void test_event_name_index()
+{
+ PSI *psi;
+ PSI_bootstrap *boot;
+ PFS_global_param param;
+
+ diag("test_event_name_index");
+
+ memset(& param, 0xFF, sizeof(param));
+ param.m_enabled= true;
+
+ /* NOTE: Need to add 4 to each index: table io, table lock, idle, metadata lock */
+
+ /* Per mutex info waits should be at [0..9] */
+ param.m_mutex_class_sizing= 10;
+ /* Per rwlock info waits should be at [10..29] */
+ param.m_rwlock_class_sizing= 20;
+ /* Per cond info waits should be at [30..69] */
+ param.m_cond_class_sizing= 40;
+ /* Per file info waits should be at [70..149] */
+ param.m_file_class_sizing= 80;
+ /* Per socket info waits should be at [150..309] */
+ param.m_socket_class_sizing= 160;
+ /* Per table info waits should be at [310] */
+ param.m_table_share_sizing= 320;
+
+ param.m_thread_class_sizing= 0;
+ param.m_user_sizing= 0;
+ param.m_account_sizing= 0;
+ param.m_host_sizing= 0;
+ param.m_stage_class_sizing= 0;
+ param.m_events_stages_history_sizing= 0;
+ param.m_events_stages_history_long_sizing= 0;
+ param.m_statement_class_sizing= 0;
+ param.m_events_statements_history_sizing= 0;
+ param.m_events_statements_history_long_sizing= 0;
+ param.m_events_transactions_history_sizing= 0;
+ param.m_events_transactions_history_long_sizing= 0;
+ param.m_digest_sizing= 0;
+ param.m_session_connect_attrs_sizing= 0;
+ param.m_program_sizing= 0;
+ param.m_statement_stack_sizing= 10;
+ param.m_memory_class_sizing= 12;
+ param.m_metadata_lock_sizing= 10;
+ param.m_max_digest_length= 0;
+ param.m_max_sql_text_length= 1000;
+
+ param.m_mutex_sizing= 0;
+ param.m_rwlock_sizing= 0;
+ param.m_cond_sizing= 0;
+ param.m_thread_sizing= 0;
+ param.m_table_sizing= 0;
+ param.m_file_sizing= 0;
+ param.m_file_handle_sizing= 0;
+ param.m_socket_sizing= 0;
+ param.m_events_waits_history_sizing= 0;
+ param.m_events_waits_history_long_sizing= 0;
+ param.m_setup_actor_sizing= 0;
+ param.m_setup_object_sizing= 0;
+
+ param.m_hints.m_table_definition_cache = 100;
+ param.m_hints.m_table_open_cache = 100;
+ param.m_hints.m_max_connections = 100;
+ param.m_hints.m_open_files_limit = 100;
+ param.m_hints.m_max_prepared_stmt_count= 100;
+
+ pre_initialize_performance_schema();
+ boot= initialize_performance_schema(& param);
+ ok(boot != NULL, "bootstrap");
+ psi= (PSI*) boot->get_interface(PSI_VERSION_1);
+ ok(psi != NULL, "psi");
+
+ PFS_mutex_class *mutex_class;
+ PSI_mutex_key dummy_mutex_key_1;
+ PSI_mutex_key dummy_mutex_key_2;
+ PSI_mutex_info dummy_mutexes[]=
+ {
+ { & dummy_mutex_key_1, "M-1", 0},
+ { & dummy_mutex_key_2, "M-2", 0}
+ };
+
+ psi->register_mutex("X", dummy_mutexes, 2);
+ mutex_class= find_mutex_class(dummy_mutex_key_1);
+ ok(mutex_class != NULL, "mutex class 1");
+ ok(mutex_class->m_event_name_index == 4, "index 4");
+ mutex_class= find_mutex_class(dummy_mutex_key_2);
+ ok(mutex_class != NULL, "mutex class 2");
+ ok(mutex_class->m_event_name_index == 5, "index 5");
+
+ PFS_rwlock_class *rwlock_class;
+ PSI_rwlock_key dummy_rwlock_key_1;
+ PSI_rwlock_key dummy_rwlock_key_2;
+ PSI_rwlock_info dummy_rwlocks[]=
+ {
+ { & dummy_rwlock_key_1, "RW-1", 0},
+ { & dummy_rwlock_key_2, "RW-2", 0}
+ };
+
+ psi->register_rwlock("X", dummy_rwlocks, 2);
+ rwlock_class= find_rwlock_class(dummy_rwlock_key_1);
+ ok(rwlock_class != NULL, "rwlock class 1");
+ ok(rwlock_class->m_event_name_index == 14, "index 14");
+ rwlock_class= find_rwlock_class(dummy_rwlock_key_2);
+ ok(rwlock_class != NULL, "rwlock class 2");
+ ok(rwlock_class->m_event_name_index == 15, "index 15");
+
+ PFS_cond_class *cond_class;
+ PSI_cond_key dummy_cond_key_1;
+ PSI_cond_key dummy_cond_key_2;
+ PSI_cond_info dummy_conds[]=
+ {
+ { & dummy_cond_key_1, "C-1", 0},
+ { & dummy_cond_key_2, "C-2", 0}
+ };
+
+ psi->register_cond("X", dummy_conds, 2);
+ cond_class= find_cond_class(dummy_cond_key_1);
+ ok(cond_class != NULL, "cond class 1");
+ ok(cond_class->m_event_name_index == 34, "index 34");
+ cond_class= find_cond_class(dummy_cond_key_2);
+ ok(cond_class != NULL, "cond class 2");
+ ok(cond_class->m_event_name_index == 35, "index 35");
+
+ PFS_file_class *file_class;
+ PSI_file_key dummy_file_key_1;
+ PSI_file_key dummy_file_key_2;
+ PSI_file_info dummy_files[]=
+ {
+ { & dummy_file_key_1, "F-1", 0},
+ { & dummy_file_key_2, "F-2", 0}
+ };
+
+ psi->register_file("X", dummy_files, 2);
+ file_class= find_file_class(dummy_file_key_1);
+ ok(file_class != NULL, "file class 1");
+ ok(file_class->m_event_name_index == 74, "index 74");
+ file_class= find_file_class(dummy_file_key_2);
+ ok(file_class != NULL, "file class 2");
+ ok(file_class->m_event_name_index == 75, "index 75");
+
+ PFS_socket_class *socket_class;
+ PSI_socket_key dummy_socket_key_1;
+ PSI_socket_key dummy_socket_key_2;
+ PSI_socket_info dummy_sockets[]=
+ {
+ { & dummy_socket_key_1, "S-1", 0},
+ { & dummy_socket_key_2, "S-2", 0}
+ };
+
+ psi->register_socket("X", dummy_sockets, 2);
+ socket_class= find_socket_class(dummy_socket_key_1);
+ ok(socket_class != NULL, "socket class 1");
+ ok(socket_class->m_event_name_index == 154, "index 154");
+ socket_class= find_socket_class(dummy_socket_key_2);
+ ok(socket_class != NULL, "socket class 2");
+ ok(socket_class->m_event_name_index == 155, "index 155");
+
+ ok(global_table_io_class.m_event_name_index == 0, "index 0");
+ ok(global_table_lock_class.m_event_name_index == 1, "index 1");
+ ok(wait_class_max= 314, "314 event names"); // 4 global classes
+
+ shutdown_performance_schema();
+}
+
+void test_memory_instruments()
+{
+ PSI *psi;
+ PSI_thread *owner;
+
+ diag("test_memory_instruments");
+
+ psi= load_perfschema();
+
+ PSI_memory_key memory_key_A;
+ PSI_memory_info all_memory[]=
+ {
+ { & memory_key_A, "M-A", 0}
+ };
+
+ PSI_thread_key thread_key_1;
+ PSI_thread_info all_thread[]=
+ {
+ { & thread_key_1, "T-1", 0}
+ };
+
+ psi->register_memory("test", all_memory, 1);
+ psi->register_thread("test", all_thread, 1);
+
+ PFS_memory_class *memory_class_A;
+ PSI_thread *thread_1;
+ PSI_memory_key key;
+
+ /* Preparation */
+
+ thread_1= psi->new_thread(thread_key_1, NULL, 0);
+ ok(thread_1 != NULL, "T-1");
+ psi->set_thread_id(thread_1, 1);
+
+ memory_class_A= find_memory_class(memory_key_A);
+ ok(memory_class_A != NULL, "memory info A");
+
+ /* Pretend thread T-1 is running, and enabled */
+ /* ------------------------------------------ */
+
+ psi->set_thread(thread_1);
+ setup_thread(thread_1, true);
+
+ /* Enable all instruments */
+
+ memory_class_A->m_enabled= true;
+
+ /* for coverage, need to print stats collected. */
+
+ key= psi->memory_alloc(memory_key_A, 100, & owner);
+ ok(key == memory_key_A, "alloc memory info A");
+ key= psi->memory_realloc(memory_key_A, 100, 200, & owner);
+ ok(key == memory_key_A, "realloc memory info A");
+ key= psi->memory_realloc(memory_key_A, 200, 300, & owner);
+ ok(key == memory_key_A, "realloc up memory info A");
+ key= psi->memory_realloc(memory_key_A, 300, 50, & owner);
+ ok(key == memory_key_A, "realloc down memory info A");
+ psi->memory_free(memory_key_A, 50, owner);
+
+ /* Use global instrumentation only */
+ /* ------------------------------- */
+
+ flag_thread_instrumentation= false;
+
+ key= psi->memory_alloc(memory_key_A, 100, & owner);
+ ok(key == memory_key_A, "alloc memory info A");
+ key= psi->memory_realloc(memory_key_A, 100, 200, & owner);
+ ok(key == memory_key_A, "realloc memory info A");
+ key= psi->memory_realloc(memory_key_A, 200, 300, & owner);
+ ok(key == memory_key_A, "realloc up memory info A");
+ key= psi->memory_realloc(memory_key_A, 300, 50, & owner);
+ ok(key == memory_key_A, "realloc down memory info A");
+ psi->memory_free(memory_key_A, 50, owner);
+
+ /* Garbage, for robustness */
+ /* ----------------------- */
+
+ key= psi->memory_alloc(9999, 100, & owner);
+ ok(key == PSI_NOT_INSTRUMENTED, "alloc with unknown key");
+ key= psi->memory_realloc(PSI_NOT_INSTRUMENTED, 100, 200, & owner);
+ ok(key == PSI_NOT_INSTRUMENTED, "realloc with unknown key");
+ psi->memory_free(PSI_NOT_INSTRUMENTED, 200, owner);
+
+ shutdown_performance_schema();
+}
+
+void test_leaks()
+{
+ PSI_bootstrap *boot;
+ PFS_global_param param;
+
+ /* Allocate everything, to make sure cleanup does not forget anything. */
+
+ memset(& param, 0xFF, sizeof(param));
+ param.m_enabled= true;
+ param.m_mutex_class_sizing= 10;
+ param.m_rwlock_class_sizing= 10;
+ param.m_cond_class_sizing= 10;
+ param.m_thread_class_sizing= 10;
+ param.m_table_share_sizing= 10;
+ param.m_file_class_sizing= 10;
+ param.m_socket_class_sizing= 10;
+ param.m_mutex_sizing= 1000;
+ param.m_rwlock_sizing= 1000;
+ param.m_cond_sizing= 1000;
+ param.m_thread_sizing= 1000;
+ param.m_table_sizing= 1000;
+ param.m_file_sizing= 1000;
+ param.m_file_handle_sizing= 1000;
+ param.m_socket_sizing= 1000;
+ param.m_events_waits_history_sizing= 10;
+ param.m_events_waits_history_long_sizing= 1000;
+ param.m_setup_actor_sizing= 1000;
+ param.m_setup_object_sizing= 1000;
+ param.m_host_sizing= 1000;
+ param.m_user_sizing= 1000;
+ param.m_account_sizing= 1000;
+ param.m_stage_class_sizing= 10;
+ param.m_events_stages_history_sizing= 10;
+ param.m_events_stages_history_long_sizing= 1000;
+ param.m_statement_class_sizing= 10;
+ param.m_events_statements_history_sizing= 10;
+ param.m_events_statements_history_long_sizing= 1000;
+ param.m_session_connect_attrs_sizing= 1000;
+ param.m_memory_class_sizing= 10;
+ param.m_metadata_lock_sizing= 1000;
+ param.m_digest_sizing= 1000;
+ param.m_program_sizing= 1000;
+ param.m_statement_stack_sizing= 10;
+ param.m_max_digest_length= 1000;
+ param.m_max_sql_text_length= 1000;
+
+ param.m_hints.m_table_definition_cache = 100;
+ param.m_hints.m_table_open_cache = 100;
+ param.m_hints.m_max_connections = 100;
+ param.m_hints.m_open_files_limit = 100;
+ param.m_hints.m_max_prepared_stmt_count= 100;
+
+ pre_initialize_performance_schema();
+ boot= initialize_performance_schema(& param);
+ ok(boot != NULL, "bootstrap");
+ shutdown_performance_schema();
+
+ /* Leaks will be reported with valgrind */
+}
+
+void do_all_tests()
+{
+ /* Using initialize_performance_schema(), no partial init needed. */
+
+ test_bootstrap();
+ test_bad_registration();
+ test_init_disabled();
+ test_locker_disabled();
+ test_file_instrumentation_leak();
+ test_event_name_index();
+ test_memory_instruments();
+ test_leaks();
+}
+
+int main(int argc, char **argv)
+{
+ plan(232);
+ MY_INIT(argv[0]);
+ do_all_tests();
+ my_end(0);
+ return (exit_status());
+}
diff --git a/storage/perfschema/unittest/pfs_account-oom-t.cc b/storage/perfschema/unittest/pfs_account-oom-t.cc
new file mode 100644
index 00000000..185b0a65
--- /dev/null
+++ b/storage/perfschema/unittest/pfs_account-oom-t.cc
@@ -0,0 +1,174 @@
+/* Copyright (c) 2011, 2017, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#include <my_global.h>
+#include <my_thread.h>
+#include <pfs_instr.h>
+#include <pfs_stat.h>
+#include <pfs_global.h>
+#include <pfs_defaults.h>
+#include <pfs_user.h>
+#include <pfs_host.h>
+#include <pfs_account.h>
+#include <pfs_buffer_container.h>
+#include <tap.h>
+
+#include "stub_pfs_global.h"
+#include "stub_global_status_var.h"
+
+#include <string.h> /* memset */
+
+PFS_thread pfs_thread;
+
+void initialize_performance_schema_helper(PFS_global_param *param)
+{
+ stub_alloc_always_fails= false;
+ stub_alloc_fails_after_count= 1000;
+
+ param->m_enabled= true;
+ param->m_thread_class_sizing= 10;
+ param->m_thread_sizing= 1000;
+ param->m_account_sizing= 1000;
+ transaction_class_max= 0;
+
+ pfs_thread.m_account_hash_pins= NULL;
+
+ init_event_name_sizing(param);
+ init_sync_class(param->m_mutex_class_sizing, param->m_rwlock_class_sizing, param->m_cond_class_sizing);
+ init_thread_class(param->m_thread_class_sizing);
+ init_table_share(param->m_table_share_sizing);
+ init_table_share_lock_stat(param->m_table_lock_stat_sizing);
+ init_table_share_index_stat(param->m_index_stat_sizing);
+ init_file_class(param->m_file_class_sizing);
+ init_stage_class(param->m_stage_class_sizing);
+ init_statement_class(param->m_statement_class_sizing);
+ init_socket_class(param->m_socket_class_sizing);
+ init_memory_class(param->m_memory_class_sizing);
+ init_instruments(param);
+ init_events_waits_history_long(param->m_events_waits_history_long_sizing);
+ init_events_stages_history_long(param->m_events_stages_history_long_sizing);
+ init_events_statements_history_long(param->m_events_statements_history_long_sizing);
+ init_events_transactions_history_long(param->m_events_transactions_history_long_sizing);
+ init_file_hash(param);
+ init_table_share_hash(param);
+ init_setup_actor(param);
+ init_setup_actor_hash(param);
+ init_setup_object(param);
+ init_setup_object_hash(param);
+ init_host(param);
+ init_host_hash(param);
+ init_user(param);
+ init_user_hash(param);
+ init_account(param);
+ init_account_hash(param);
+ init_digest(param);
+ init_digest_hash(param);
+ init_program(param);
+ init_program_hash(param);
+ init_prepared_stmt(param);
+ pfs_initialized= true;
+}
+
+void test_oom()
+{
+ PFS_global_param param;
+ PFS_account *pfs_account;
+ const char *username= "username";
+ const char *hostname= "hostname";
+
+ uint user_len= (uint)strlen(username);
+ uint host_len= (uint)strlen(hostname);
+
+ /* Account. */
+ memset(&param, 0, sizeof(param));
+ initialize_performance_schema_helper(&param);
+ stub_alloc_fails_after_count= 1;
+ pfs_account= find_or_create_account(&pfs_thread, username, user_len, hostname, host_len);
+ ok(pfs_account == NULL, "oom (account)");
+ ok(global_account_container.m_lost == 1, "lost (account)");
+ shutdown_performance_schema();
+
+ /* Account waits. */
+ memset(&param, 0, sizeof(param));
+ param.m_mutex_class_sizing= 10;
+ initialize_performance_schema_helper(&param);
+ stub_alloc_fails_after_count= 2;
+ pfs_account= find_or_create_account(&pfs_thread, username, user_len, hostname, host_len);
+ ok(pfs_account == NULL, "oom (account waits)");
+ ok(global_account_container.m_lost == 1, "lost (account waits)");
+ shutdown_performance_schema();
+
+
+ /* Account stages. */
+ memset(&param, 0, sizeof(param));
+ param.m_stage_class_sizing= 10;
+ initialize_performance_schema_helper(&param);
+ stub_alloc_fails_after_count= 3;
+ pfs_account= find_or_create_account(&pfs_thread, username, user_len, hostname, host_len);
+ ok(pfs_account == NULL, "oom (account stages)");
+ ok(global_account_container.m_lost == 1, "lost (account stages)");
+ shutdown_performance_schema();
+
+ /* Account statements. */
+ memset(&param, 0, sizeof(param));
+ param.m_statement_class_sizing= 10;
+ initialize_performance_schema_helper(&param);
+ stub_alloc_fails_after_count= 3;
+ pfs_account= find_or_create_account(&pfs_thread, username, user_len, hostname, host_len);
+ ok(pfs_account == NULL, "oom (account statements)");
+ ok(global_account_container.m_lost == 1, "lost (account statements)");
+ shutdown_performance_schema();
+
+ /* Account transactions. */
+ memset(&param, 0, sizeof(param));
+ initialize_performance_schema_helper(&param);
+ transaction_class_max= 1;
+ stub_alloc_fails_after_count= 3;
+ pfs_account= find_or_create_account(&pfs_thread, username, user_len, hostname, host_len);
+ ok(pfs_account == NULL, "oom (account transactions)");
+ ok(global_account_container.m_lost == 1, "lost (account transactions)");
+ shutdown_performance_schema();
+
+ /* Account memory. */
+ memset(&param, 0, sizeof(param));
+ param.m_memory_class_sizing= 10;
+ initialize_performance_schema_helper(&param);
+ stub_alloc_fails_after_count= 3;
+ pfs_account= find_or_create_account(&pfs_thread, username, user_len, hostname, host_len);
+ ok(pfs_account == NULL, "oom (account memory)");
+ ok(global_account_container.m_lost == 1, "lost (account memory)");
+ shutdown_performance_schema();
+}
+
+void do_all_tests()
+{
+ test_oom();
+}
+
+int main(int, char **)
+{
+ plan(12);
+ MY_INIT("pfs_account-oom-t");
+ do_all_tests();
+ my_end(0);
+ return (exit_status());
+}
diff --git a/storage/perfschema/unittest/pfs_connect_attr-t.cc b/storage/perfschema/unittest/pfs_connect_attr-t.cc
new file mode 100644
index 00000000..b57ead3e
--- /dev/null
+++ b/storage/perfschema/unittest/pfs_connect_attr-t.cc
@@ -0,0 +1,352 @@
+/* Copyright (c) 2008, 2017, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#include <my_global.h>
+#include <my_thread.h>
+#include <pfs_server.h>
+#include <pfs_instr_class.h>
+#include <pfs_instr.h>
+#include <pfs_global.h>
+#include <tap.h>
+
+
+#include <string.h>
+#include <memory.h>
+
+/* test helpers, to inspect data */
+bool read_nth_attr(const char *connect_attrs, uint connect_attrs_length,
+ const CHARSET_INFO *connect_attrs_cs,
+ uint ordinal,
+ char *attr_name, uint max_attr_name,
+ uint *attr_name_length,
+ char *attr_value, uint max_attr_value,
+ uint *attr_value_length);
+
+void test_blob_parser()
+{
+ char name[100], value[4096];
+ unsigned char packet[10000], *ptr;
+ uint name_len, value_len, idx, packet_length;
+ bool result;
+ const CHARSET_INFO *cs= &my_charset_utf8mb3_bin;
+
+ diag("test_blob_parser");
+
+ result= read_nth_attr("", 0, cs, 0,
+ name, 32, &name_len, value, 1024, &value_len);
+ ok(result == false, "zero length blob");
+
+
+ result= read_nth_attr("\x1", 1, cs, 0,
+ name, 32, &name_len, value, 1024, &value_len);
+ ok(result == false, "invalid key length");
+
+
+ result= read_nth_attr("\x2k1\x1", 4, cs, 0,
+ name, 32, &name_len, value, 1024, &value_len);
+ ok(result == false, "invalid value length");
+
+
+ result= read_nth_attr("\x2k1\x2v1", 6, cs, 0,
+ name, 32, &name_len, value, 1024, &value_len);
+ ok(result == true, "one pair return");
+ ok(name_len == 2, "one pair attr name length");
+ ok(!strncmp(name, "k1", name_len), "one pair attr name");
+ ok(value_len == 2, "one pair value length");
+ ok(!strncmp(value, "v1", value_len), "one pair value");
+
+ result= read_nth_attr("\x2k1\x2v1", 6, cs, 1,
+ name, 32, &name_len, value, 1024, &value_len);
+ ok(result == false, "no second arg");
+
+ result= read_nth_attr("\x2k1\x2v1\x2k2\x2v2", 12, cs, 1,
+ name, 32, &name_len, value, 1024, &value_len);
+ ok(result == true, "two pairs return");
+ ok(name_len == 2, "two pairs attr name length");
+ ok(!strncmp(name, "k2", name_len), "two pairs attr name");
+ ok(value_len == 2, "two pairs value length");
+ ok(!strncmp(value, "v2", value_len), "two pairs value");
+
+ result= read_nth_attr("\x2k1\xff\x2k2\x2v2", 12, cs, 1,
+ name, 32, &name_len, value, 1024, &value_len);
+ ok(result == false, "two pairs first value bad return");
+
+ result= read_nth_attr("\x2k1\x2v1\x2k2\x2v2", 10, cs, 1,
+ name, 32, &name_len, value, 1024, &value_len);
+ ok(result == false, "two pairs wrong global length");
+
+ result= read_nth_attr("\x21z123456789z123456789z123456789z12\x2v1", 37, cs, 0,
+ name, 32, &name_len, value, 1024, &value_len);
+ ok(result == true, "attr name overflow");
+ ok(name_len == 32, "attr name overflow length");
+ ok(!strncmp(name, "z123456789z123456789z123456789z1", name_len),
+ "attr name overflow name");
+ ok(value_len == 2, "attr name overflow value length");
+ ok(!strncmp(value, "v1", value_len), "attr name overflow value");
+
+ packet[0]= 2;
+ packet[1]= 'k';
+ packet[2]= '1';
+ ptr= net_store_length(packet + 3, 1025);
+ for (idx= 0; idx < 1025; idx++)
+ *ptr++= '0' + (idx % 10);
+ packet_length= (uint) (ptr - packet);
+ result= read_nth_attr((char *) packet, packet_length, cs, 0,
+ name, 32, &name_len, value, 1024, &value_len);
+ ok(result == true, "attr value overflow");
+ ok(name_len == 2, "attr value overflow length");
+ ok(!strncmp(name, "k1", name_len), "attr value overflow name");
+ ok(value_len == 1024, "attr value overflow value length");
+ for (idx= 0; idx < 1024; idx++)
+ {
+ if (value[idx] != (char) ('0' + (idx % 10)))
+ break;
+ }
+ ok (idx == 1024, "attr value overflow value");
+
+ result= read_nth_attr("\x21z123456789z123456789z123456789z12\x2v1\x2k2\x2v2",
+ 43, cs, 1,
+ name, 32, &name_len, value, 1024, &value_len);
+ ok(result == true, "prev attr name overflow");
+ ok(name_len == 2, "prev attr name overflow length");
+ ok(!strncmp(name, "k2", name_len),
+ "prev attr name overflow name");
+ ok(value_len == 2, "prev attr name overflow value length");
+ ok(!strncmp(value, "v2", value_len), "prev attr name overflow value");
+
+
+ packet[1]= 'k';
+ packet[2]= '1';
+ packet[3]= 2;
+ packet[4]= 'v';
+ packet[5]= '1';
+
+ for(idx= 251; idx < 256; idx++)
+ {
+ packet[0]= idx;
+ result= read_nth_attr((char *) packet, 6, cs, 0,
+ name, 32, &name_len, value, 1024, &value_len);
+ ok(result == false, "invalid string length %d", idx);
+ }
+
+ memset(packet, 0, sizeof(packet));
+ for (idx=0; idx < 1660 /* *6 = 9960 */; idx++)
+ memcpy(packet + idx * 6, "\x2k1\x2v1", 6);
+ result= read_nth_attr((char *) packet, 8192, cs, 1364,
+ name, 32, &name_len, value, 1024, &value_len);
+ ok(result == true, "last valid attribute %d", 1364);
+ result= read_nth_attr((char *) packet, 8192, cs, 1365,
+ name, 32, &name_len, value, 1024, &value_len);
+ ok(result == false, "first attribute that's cut %d", 1365);
+}
+
+void test_multibyte_lengths()
+{
+ char name[100], value[4096];
+ uint name_len, value_len;
+ bool result;
+ const CHARSET_INFO *cs= &my_charset_utf8mb3_bin;
+
+ unsigned char var_len_packet[] = {
+ 252, 2, 0, 'k', '1',
+ 253, 2, 0, 0, 'v', '1',
+ 254, 2, 0, 0, 0, 0, 0, 0, 0, 'k', '2',
+ 254, 2, 0, 0, 0, 0, 0, 0, 0, 'v', '2'
+ };
+
+ result= read_nth_attr((char *) var_len_packet, sizeof(var_len_packet), cs, 0,
+ name, 32, &name_len, value, 1024, &value_len);
+ ok(result == true, "multibyte lengths return");
+ ok(name_len == 2, "multibyte lengths name length");
+ ok(!strncmp(name, "k1", name_len), "multibyte lengths attr name");
+ ok(value_len == 2, "multibyte lengths value length");
+ ok(!strncmp(value, "v1", value_len), "multibyte lengths value");
+
+ result= read_nth_attr((char *) var_len_packet, sizeof(var_len_packet), cs, 1,
+ name, 32, &name_len, value, 1024, &value_len);
+ ok(result == true, "multibyte lengths second attr return");
+ ok(name_len == 2, "multibyte lengths second attr name length");
+ ok(!strncmp(name, "k2", name_len), "multibyte lengths second attr attr name");
+ ok(value_len == 2, "multibyte lengths value length");
+ ok(!strncmp(value, "v2", value_len), "multibyte lengths second attr value");
+}
+
+
+void test_utf8_parser()
+{
+ /* utf8 max byte length per character is 6 */
+ char name[33 * 6], value[1024 * 6], packet[1500 * 6], *ptr;
+ uint name_len, value_len;
+ bool result;
+ const CHARSET_INFO *cs= &my_charset_utf8mb3_bin;
+
+ /* note : this is encoded in utf-8 */
+ const char *attr1= "Георги";
+ const char *val1= "Кодинов";
+ const char *attr2= "Пловдив";
+ const char *val2= "България";
+
+ ptr= packet;
+ *ptr++= strlen(attr1);
+ memcpy(ptr, attr1, strlen(attr1));
+ ptr+= strlen(attr1);
+ *ptr++= strlen(val1);
+ memcpy(ptr, val1, strlen(val1));
+ ptr+= strlen(val1);
+
+ *ptr++= strlen(attr2);
+ memcpy(ptr, attr2, strlen(attr2));
+ ptr+= strlen(attr2);
+ *ptr++= strlen(val2);
+ memcpy(ptr, val2, strlen(val2));
+ ptr+= strlen(val2);
+
+ diag("test_utf8_parser attr pair #1");
+
+ result= read_nth_attr((char *) packet, ptr - packet, cs, 0,
+ name, sizeof(name), &name_len,
+ value, sizeof(value), &value_len);
+ ok(result == true, "return");
+ ok(name_len == strlen(attr1), "name length");
+ ok(!strncmp(name, attr1, name_len), "attr name");
+ ok(value_len == strlen(val1), "value length");
+ ok(!strncmp(value, val1, value_len), "value");
+
+ diag("test_utf8_parser attr pair #2");
+ result= read_nth_attr((char *) packet, ptr - packet, cs, 1,
+ name, sizeof(name), &name_len,
+ value, sizeof(value), &value_len);
+ ok(result == true, "return");
+ ok(name_len == strlen(attr2), "name length");
+ ok(!strncmp(name, attr2, name_len), "attr name");
+ ok(value_len == strlen(val2), "value length");
+ ok(!strncmp(value, val2, value_len), "value");
+}
+
+
+void test_utf8_parser_bad_encoding()
+{
+ /* utf8 max byte length per character is 3*/
+ char name[33 * 3], value[1024 * 3], packet[1500 * 3], *ptr;
+ uint name_len, value_len;
+ bool result;
+ const CHARSET_INFO *cs= &my_charset_utf8mb3_bin;
+
+ /* note : this is encoded in utf-8 */
+ const char *attr= "Георги";
+ const char *val= "Кодинов";
+
+ ptr= packet;
+ *ptr++= strlen(attr);
+ memcpy(ptr, attr, strlen(attr));
+ ptr[0]= (char)0xFA; // invalid UTF-8 char
+ ptr+= strlen(attr);
+ *ptr++= strlen(val);
+ memcpy(ptr, val, strlen(val));
+ ptr+= strlen(val);
+
+ diag("test_utf8_parser_bad_encoding");
+
+ result= read_nth_attr((char *) packet, ptr - packet, cs, 0,
+ name, sizeof(name), &name_len,
+ value, sizeof(value), &value_len);
+ ok(result == false, "return");
+}
+
+const CHARSET_INFO *cs_cp1251;
+
+void test_cp1251_parser()
+{
+ /* utf8 max byte length per character is 3*/
+ char name[33 * 3], value[1024 * 3], packet[1500 * 3], *ptr;
+ uint name_len, value_len;
+ bool result;
+
+ /* note : this is Георги in windows-1251 */
+ const char *attr1= "\xc3\xe5\xee\xf0\xe3\xe8";
+ /* note : this is Кодинов in windows-1251 */
+ const char *val1= "\xca\xee\xe4\xe8\xed\xee\xe2";
+ /* note : this is Пловдив in windows-1251 */
+ const char *attr2= "\xcf\xeb\xee\xe2\xe4\xe8\xe2";
+ /* note : this is България in windows-1251 */
+ const char *val2= "\xc1\xfa\xeb\xe3\xe0\xf0\xe8\xff";
+
+ ptr= packet;
+ *ptr++= strlen(attr1);
+ memcpy(ptr, attr1, strlen(attr1));
+ ptr+= strlen(attr1);
+ *ptr++= strlen(val1);
+ memcpy(ptr, val1, strlen(val1));
+ ptr+= strlen(val1);
+
+ *ptr++= strlen(attr2);
+ memcpy(ptr, attr2, strlen(attr2));
+ ptr+= strlen(attr2);
+ *ptr++= strlen(val2);
+ memcpy(ptr, val2, strlen(val2));
+ ptr+= strlen(val2);
+
+ diag("test_cp1251_parser attr pair #1");
+
+ result= read_nth_attr((char *) packet, ptr - packet, cs_cp1251, 0,
+ name, sizeof(name), &name_len,
+ value, sizeof(value), &value_len);
+ ok(result == true, "return");
+ /* need to compare to the UTF-8 equivalents */
+ ok(name_len == strlen("Георги"), "name length");
+ ok(!strncmp(name, "Георги", name_len), "attr name");
+ ok(value_len == strlen("Кодинов"), "value length");
+ ok(!strncmp(value, "Кодинов", value_len), "value");
+
+ diag("test_cp1251_parser attr pair #2");
+ result= read_nth_attr((char *) packet, ptr - packet, cs_cp1251, 1,
+ name, sizeof(name), &name_len,
+ value, sizeof(value), &value_len);
+ ok(result == true, "return");
+ /* need to compare to the UTF-8 equivalents */
+ ok(name_len == strlen("Пловдив"), "name length");
+ ok(!strncmp(name, "Пловдив", name_len), "attr name");
+ ok(value_len == strlen("България"), "value length");
+ ok(!strncmp(value, "България", value_len), "value");
+}
+
+
+void do_all_tests()
+{
+ test_blob_parser();
+ test_multibyte_lengths();
+ test_utf8_parser();
+ test_utf8_parser_bad_encoding();
+ test_cp1251_parser();
+}
+
+int main(int, char **)
+{
+ MY_INIT("pfs_connect_attr-t");
+
+ cs_cp1251= get_charset_by_csname("cp1251", MY_CS_PRIMARY, MYF(0));
+ if (!cs_cp1251)
+ diag("skipping the cp1251 tests : missing character set");
+ plan(59 + (cs_cp1251 ? 10 : 0));
+ do_all_tests();
+ return (exit_status());
+}
diff --git a/storage/perfschema/unittest/pfs_host-oom-t.cc b/storage/perfschema/unittest/pfs_host-oom-t.cc
new file mode 100644
index 00000000..e97a1170
--- /dev/null
+++ b/storage/perfschema/unittest/pfs_host-oom-t.cc
@@ -0,0 +1,148 @@
+/* Copyright (c) 2011, 2017, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#include <my_global.h>
+#include <my_thread.h>
+#include <pfs_instr.h>
+#include <pfs_stat.h>
+#include <pfs_global.h>
+#include <pfs_host.h>
+#include <pfs_buffer_container.h>
+#include <tap.h>
+
+#include "stub_pfs_global.h"
+#include "stub_global_status_var.h"
+
+#include <string.h> /* memset */
+
+extern struct PSI_bootstrap PFS_bootstrap;
+
+void test_oom()
+{
+ PSI *psi;
+ PFS_global_param param;
+ PSI_bootstrap *boot;
+
+ memset(& param, 0xFF, sizeof(param));
+ param.m_enabled= true;
+ param.m_mutex_class_sizing= 0;
+ param.m_rwlock_class_sizing= 0;
+ param.m_cond_class_sizing= 0;
+ param.m_thread_class_sizing= 10;
+ param.m_table_share_sizing= 0;
+ param.m_file_class_sizing= 0;
+ param.m_socket_class_sizing= 0;
+ param.m_mutex_sizing= 0;
+ param.m_rwlock_sizing= 0;
+ param.m_cond_sizing= 0;
+ param.m_thread_sizing= 1000;
+ param.m_table_sizing= 0;
+ param.m_file_sizing= 0;
+ param.m_file_handle_sizing= 0;
+ param.m_socket_sizing= 0;
+ param.m_events_waits_history_sizing= 10;
+ param.m_events_waits_history_long_sizing= 0;
+ param.m_setup_actor_sizing= 0;
+ param.m_setup_object_sizing= 0;
+ param.m_user_sizing= 0;
+ param.m_host_sizing= 1000;
+ param.m_account_sizing= 0;
+ param.m_stage_class_sizing= 50;
+ param.m_events_stages_history_sizing= 0;
+ param.m_events_stages_history_long_sizing= 0;
+ param.m_statement_class_sizing= 50;
+ param.m_events_statements_history_sizing= 0;
+ param.m_events_statements_history_long_sizing= 0;
+ param.m_events_transactions_history_sizing= 0;
+ param.m_events_transactions_history_long_sizing= 0;
+ param.m_digest_sizing= 0;
+ param.m_session_connect_attrs_sizing= 0;
+ param.m_program_sizing= 0;
+ param.m_statement_stack_sizing= 0;
+ param.m_memory_class_sizing= 10;
+ param.m_metadata_lock_sizing= 0;
+ param.m_max_digest_length= 0;
+ param.m_max_sql_text_length= 0;
+
+ /* Setup */
+
+ stub_alloc_always_fails= false;
+ stub_alloc_fails_after_count= 1000;
+
+ pre_initialize_performance_schema();
+ boot= initialize_performance_schema(&param);
+ psi= (PSI *)boot->get_interface(PSI_VERSION_1);
+
+ PSI_thread_key thread_key_1;
+ PSI_thread_info all_thread[]=
+ {
+ {&thread_key_1, "T-1", 0}
+ };
+ psi->register_thread("test", all_thread, 1);
+
+ PSI_thread *thread_1= psi->new_thread(thread_key_1, NULL, 0);
+ psi->set_thread(thread_1);
+
+ /* Tests */
+
+ int first_fail= 1;
+ stub_alloc_fails_after_count= first_fail;
+ psi->set_thread_account("", 0, "host1", 5);
+ ok(global_host_container.m_lost == 1, "oom (host)");
+
+ stub_alloc_fails_after_count= first_fail + 1;
+ psi->set_thread_account("", 0, "host2", 5);
+ ok(global_host_container.m_lost == 2, "oom (host waits)");
+
+ stub_alloc_fails_after_count= first_fail + 2;
+ psi->set_thread_account("", 0, "host3", 5);
+ ok(global_host_container.m_lost == 3, "oom (host stages)");
+
+ stub_alloc_fails_after_count= first_fail + 3;
+ psi->set_thread_account("", 0, "host4", 5);
+ ok(global_host_container.m_lost == 4, "oom (host statements)");
+
+ stub_alloc_fails_after_count= first_fail + 4;
+ psi->set_thread_account("", 0, "host5", 5);
+ ok(global_host_container.m_lost == 5, "oom (host transactions)");
+
+ stub_alloc_fails_after_count= first_fail + 5;
+ psi->set_thread_account("", 0, "host6", 5);
+ ok(global_host_container.m_lost == 6, "oom (host memory)");
+
+ shutdown_performance_schema();
+}
+
+void do_all_tests()
+{
+ test_oom();
+}
+
+int main(int, char **)
+{
+ plan(6);
+ MY_INIT("pfs_host-oom-t");
+ do_all_tests();
+ my_end(0);
+ return (exit_status());
+}
+
diff --git a/storage/perfschema/unittest/pfs_instr-oom-t.cc b/storage/perfschema/unittest/pfs_instr-oom-t.cc
new file mode 100644
index 00000000..9472d8aa
--- /dev/null
+++ b/storage/perfschema/unittest/pfs_instr-oom-t.cc
@@ -0,0 +1,459 @@
+/* Copyright (c) 2008, 2017, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
+
+#include <my_global.h>
+#include <my_thread.h>
+#include <pfs_instr.h>
+#include <pfs_stat.h>
+#include <pfs_global.h>
+#include <pfs_user.h>
+#include <pfs_host.h>
+#include <pfs_account.h>
+#include <pfs_instr_class.h>
+#include <pfs_buffer_container.h>
+#include <tap.h>
+
+#include "stub_pfs_global.h"
+#include "stub_global_status_var.h"
+
+#include <string.h> /* memset */
+
+extern struct PSI_bootstrap PFS_bootstrap;
+
+PSI_thread_key thread_key_1;
+PSI_thread_info all_thread[]=
+{
+ {&thread_key_1, "T-1", 0}
+};
+
+/** Simulate initialize_performance_schema(). */
+
+PSI * initialize_performance_schema_helper(PFS_global_param *param)
+{
+ PSI *psi;
+
+ stub_alloc_always_fails= false;
+ stub_alloc_fails_after_count= 1000;
+
+ param->m_enabled= true;
+ param->m_thread_class_sizing= 10;
+ param->m_thread_sizing= 1000;
+
+ pre_initialize_performance_schema();
+
+ init_event_name_sizing(param);
+ init_sync_class(param->m_mutex_class_sizing, param->m_rwlock_class_sizing, param->m_cond_class_sizing);
+ init_thread_class(param->m_thread_class_sizing);
+ init_table_share(param->m_table_share_sizing);
+ init_table_share_lock_stat(param->m_table_lock_stat_sizing);
+ init_table_share_index_stat(param->m_index_stat_sizing);
+ init_file_class(param->m_file_class_sizing);
+ init_stage_class(param->m_stage_class_sizing);
+ init_statement_class(param->m_statement_class_sizing);
+ init_socket_class(param->m_socket_class_sizing);
+ init_memory_class(param->m_memory_class_sizing);
+ init_instruments(param);
+ init_events_waits_history_long(param->m_events_waits_history_long_sizing);
+ init_events_stages_history_long(param->m_events_stages_history_long_sizing);
+ init_events_statements_history_long(param->m_events_statements_history_long_sizing);
+ init_events_transactions_history_long(param->m_events_transactions_history_long_sizing);
+ init_file_hash(param);
+ init_table_share_hash(param);
+ init_setup_actor(param);
+ init_setup_actor_hash(param);
+ init_setup_object(param);
+ init_setup_object_hash(param);
+ init_host(param);
+ init_host_hash(param);
+ init_user(param);
+ init_user_hash(param);
+ init_account(param);
+ init_account_hash(param);
+ init_digest(param);
+ init_digest_hash(param);
+ init_program(param);
+ init_program_hash(param);
+ init_prepared_stmt(param);
+ pfs_initialized= true;
+
+ PSI_bootstrap *boot= &PFS_bootstrap;
+ psi= (PSI *)boot->get_interface(PSI_VERSION_1);
+ psi->register_thread("test", all_thread, 1);
+ return (psi);
+}
+
+void test_oom()
+{
+ int rc;
+ PSI *psi;
+ PFS_global_param param;
+
+ stub_alloc_always_fails= false;
+ stub_alloc_fails_after_count= 1000;
+
+ PFS_mutex_class dummy_mutex_class;
+ PFS_rwlock_class dummy_rwlock_class;
+ PFS_cond_class dummy_cond_class;
+ PFS_thread_class dummy_thread_class;
+ PFS_file_class dummy_file_class;
+ PFS_socket_class dummy_socket_class;
+ PFS_table_share dummy_table_share;
+ PFS_mutex *mutex_1;
+ PFS_mutex *mutex_2;
+ PFS_rwlock *rwlock_1;
+ PFS_rwlock *rwlock_2;
+ PFS_cond *cond_1;
+ PFS_cond *cond_2;
+ PFS_thread *thread_1;
+ PFS_thread *thread_2;
+ PFS_file *file_1;
+ PFS_file *file_2;
+ PFS_socket *socket_1;
+ PFS_socket *socket_2;
+ PFS_table *table_1;
+ PFS_table *table_2;
+
+ memset(& param, 0xFF, sizeof(param));
+ param.m_enabled= true;
+ param.m_mutex_class_sizing= 1;
+ param.m_rwlock_class_sizing= 1;
+ param.m_cond_class_sizing= 1;
+ param.m_thread_class_sizing= 1;
+ param.m_table_share_sizing= 1;
+ param.m_file_class_sizing= 1;
+ param.m_socket_class_sizing= 1;
+ param.m_mutex_sizing= 1;
+ param.m_rwlock_sizing= 1;
+ param.m_cond_sizing= 1;
+ param.m_thread_sizing= 1;
+ param.m_table_sizing= 1;
+ param.m_file_sizing= 1;
+ param.m_file_handle_sizing= 100;
+ param.m_socket_sizing= 2;
+ param.m_events_waits_history_sizing= 10;
+ param.m_events_waits_history_long_sizing= 10000;
+ param.m_setup_actor_sizing= 0;
+ param.m_setup_object_sizing= 0;
+ param.m_host_sizing= 0;
+ param.m_user_sizing= 0;
+ param.m_account_sizing= 0;
+ param.m_stage_class_sizing= 0;
+ param.m_events_stages_history_sizing= 0;
+ param.m_events_stages_history_long_sizing= 0;
+ param.m_statement_class_sizing= 0;
+ param.m_events_statements_history_sizing= 0;
+ param.m_events_statements_history_long_sizing= 0;
+ param.m_events_transactions_history_sizing= 0;
+ param.m_events_transactions_history_long_sizing= 0;
+ param.m_digest_sizing= 0;
+ param.m_session_connect_attrs_sizing= 0;
+ param.m_program_sizing= 0;
+ param.m_prepared_stmt_sizing= 0;
+ param.m_statement_stack_sizing= 0;
+ param.m_memory_class_sizing= 1;
+ param.m_metadata_lock_sizing= 0;
+ param.m_max_digest_length= 0;
+ param.m_max_sql_text_length= 0;
+
+ init_event_name_sizing(&param);
+ rc= init_instruments(&param);
+ ok(rc == 0, "instances init");
+
+ dummy_mutex_class.m_event_name_index= 0;
+ dummy_mutex_class.m_flags= 0;
+ dummy_mutex_class.m_enabled= true;
+ dummy_mutex_class.m_volatility= PSI_VOLATILITY_UNKNOWN;
+ dummy_rwlock_class.m_event_name_index= 1;
+ dummy_rwlock_class.m_flags= 0;
+ dummy_rwlock_class.m_enabled= true;
+ dummy_rwlock_class.m_volatility= PSI_VOLATILITY_UNKNOWN;
+ dummy_cond_class.m_event_name_index= 2;
+ dummy_cond_class.m_flags= 0;
+ dummy_cond_class.m_enabled= true;
+ dummy_cond_class.m_volatility = PSI_VOLATILITY_UNKNOWN;
+ dummy_file_class.m_event_name_index= 3;
+ dummy_file_class.m_flags= 0;
+ dummy_file_class.m_enabled= true;
+ dummy_file_class.m_volatility = PSI_VOLATILITY_UNKNOWN;
+ dummy_socket_class.m_event_name_index= 4;
+ dummy_socket_class.m_flags= 0;
+ dummy_socket_class.m_enabled= true;
+ dummy_socket_class.m_volatility = PSI_VOLATILITY_UNKNOWN;
+ dummy_table_share.m_enabled= true;
+ dummy_table_share.m_timed= true;
+
+ /* Create mutex. */
+ stub_alloc_always_fails= false;
+ mutex_1= create_mutex(&dummy_mutex_class, NULL);
+ ok(mutex_1 != NULL, "create mutex");
+ destroy_mutex(mutex_1);
+ cleanup_instruments();
+
+ stub_alloc_always_fails= true;
+ mutex_2= create_mutex(&dummy_mutex_class, NULL);
+ ok(mutex_2 == NULL, "oom (create mutex)");
+
+ /* Create rwlock. */
+ stub_alloc_always_fails = false;
+ rc = init_instruments(&param);
+ ok(rc == 0, "instances init");
+ rwlock_1= create_rwlock(&dummy_rwlock_class, NULL);
+ ok(rwlock_1 != NULL, "create rwlock");
+ destroy_rwlock(rwlock_1);
+ cleanup_instruments();
+
+ stub_alloc_always_fails= true;
+ rwlock_2= create_rwlock(&dummy_rwlock_class, NULL);
+ ok(rwlock_2 == NULL, "oom (create rwlock)");
+
+ /* Create cond. */
+ stub_alloc_always_fails = false;
+ rc = init_instruments(&param);
+ ok(rc == 0, "instances init");
+ cond_1= create_cond(&dummy_cond_class, NULL);
+ ok(cond_1 != NULL, "create cond");
+ destroy_cond(cond_1);
+ cleanup_instruments();
+
+ stub_alloc_always_fails= true;
+ cond_2= create_cond(&dummy_cond_class, NULL);
+ ok(cond_2 == NULL, "oom (create cond)");
+
+ /* Create file. */
+ PFS_thread fake_thread;
+ rc = init_instruments(&param);
+ fake_thread.m_filename_hash_pins= NULL;
+ init_file_hash(&param);
+
+ stub_alloc_always_fails = true;
+ file_2 = find_or_create_file(&fake_thread, &dummy_file_class, "dummy", 5, true);
+ ok(file_2 == NULL, "oom (create file)");
+
+ stub_alloc_always_fails= false;
+ file_1= find_or_create_file(&fake_thread, &dummy_file_class, "dummy", 5, true);
+ ok(file_1 != NULL, "create file");
+ release_file(file_1);
+ cleanup_instruments();
+
+ /* Create socket. */
+ stub_alloc_always_fails = false;
+ rc = init_instruments(&param);
+ ok(rc == 0, "instances init");
+ socket_1= create_socket(&dummy_socket_class, NULL, NULL, 0);
+ ok(socket_1 != NULL, "create socket");
+ destroy_socket(socket_1);
+ cleanup_instruments();
+
+ stub_alloc_always_fails= true;
+ socket_2= create_socket(&dummy_socket_class, NULL, NULL, 0);
+ ok(socket_2 == NULL, "oom (create socket)");
+
+ /* Create table. */
+ stub_alloc_always_fails= false;
+ rc = init_instruments(&param);
+ table_1= create_table(&dummy_table_share, &fake_thread, NULL);
+ ok(table_1 != NULL, "create table");
+ destroy_table(table_1);
+ cleanup_instruments();
+
+ stub_alloc_always_fails= true;
+ table_2= create_table(&dummy_table_share, &fake_thread, NULL);
+ ok(table_2 == NULL, "oom (create table)");
+
+ /* Create thread. */
+ stub_alloc_always_fails= false;
+ rc = init_instruments(&param);
+ thread_1= create_thread(&dummy_thread_class, NULL, 0);
+ ok(thread_1 != NULL, "create thread");
+ destroy_thread(thread_1);
+ cleanup_instruments();
+
+ stub_alloc_always_fails= true;
+ thread_2= create_thread(&dummy_thread_class, NULL, 0);
+ ok(thread_2 == NULL, "oom (create thread)");
+
+ PSI_thread *thread;
+
+ /* Per thread wait. */
+ memset(&param, 0, sizeof(param));
+ param.m_mutex_class_sizing= 50;
+ param.m_rwlock_class_sizing= 50;
+ param.m_cond_class_sizing= 50;
+ param.m_file_class_sizing= 50;
+ param.m_socket_class_sizing= 0;
+ psi= initialize_performance_schema_helper(&param);
+ stub_alloc_fails_after_count= 2;
+ thread= psi->new_thread(thread_key_1, NULL, 0);
+ ok(thread == NULL, "oom (per thread wait)");
+
+ cleanup_sync_class();
+ cleanup_thread_class();
+ cleanup_file_class();
+ cleanup_instruments();
+
+ /* Thread waits history sizing. */
+ memset(&param, 0, sizeof(param));
+ param.m_enabled= true;
+ param.m_events_waits_history_sizing= 10;
+ psi= initialize_performance_schema_helper(&param);
+ stub_alloc_fails_after_count= 3;
+ thread= psi->new_thread(thread_key_1, NULL, 0);
+ ok(thread == NULL, "oom (thread waits history sizing)");
+
+ cleanup_thread_class();
+ cleanup_instruments();
+
+ /* Per thread stages. */
+ memset(&param, 0, sizeof(param));
+ param.m_stage_class_sizing= 50;
+ psi= initialize_performance_schema_helper(&param);
+ stub_alloc_fails_after_count= 3;
+ thread= psi->new_thread(thread_key_1, NULL, 0);
+ ok(thread == NULL, "oom (per thread stages)");
+
+ cleanup_stage_class();
+ cleanup_thread_class();
+ cleanup_instruments();
+ cleanup_stage_class();
+
+ /* Thread stages history sizing. */
+ memset(&param, 0, sizeof(param));
+ param.m_events_stages_history_sizing= 10;
+ psi= initialize_performance_schema_helper(&param);
+ stub_alloc_fails_after_count= 3;
+ thread= psi->new_thread(thread_key_1, NULL, 0);
+ ok(thread == NULL, "oom (thread stages history sizing)");
+
+ cleanup_instruments();
+ cleanup_thread_class();
+
+ /* Per thread statements. */
+ memset(&param, 0, sizeof(param));
+ param.m_stage_class_sizing= 50;
+ psi= initialize_performance_schema_helper(&param);
+ init_statement_class(param.m_statement_class_sizing);
+ stub_alloc_fails_after_count= 3;
+ thread= psi->new_thread(thread_key_1, NULL, 0);
+ ok(thread == NULL, "oom (per thread statements)");
+
+ cleanup_stage_class();
+ cleanup_statement_class();
+ cleanup_thread_class();
+ cleanup_instruments();
+
+ /* Thread statements history sizing. */
+ memset(&param, 0, sizeof(param));
+ param.m_events_statements_history_sizing= 10;
+ psi= initialize_performance_schema_helper(&param);
+ stub_alloc_fails_after_count= 3;
+ thread= psi->new_thread(thread_key_1, NULL, 0);
+ ok(thread == NULL, "oom (thread statements history sizing)");
+
+ cleanup_thread_class();
+ cleanup_instruments();
+
+ /* Per thread transactions. */
+ memset(&param, 0, sizeof(param));
+ psi= initialize_performance_schema_helper(&param);
+ transaction_class_max= 1; // set by register_global_classes();
+ stub_alloc_fails_after_count= 3;
+ thread= psi->new_thread(thread_key_1, NULL, 0);
+ ok(thread == NULL, "oom (per thread transactions)");
+ transaction_class_max= 0;
+
+ cleanup_thread_class();
+ cleanup_instruments();
+
+ /* Thread transactions history sizing. */
+ memset(&param, 0, sizeof(param));
+ param.m_events_transactions_history_sizing= 10;
+ psi= initialize_performance_schema_helper(&param);
+ stub_alloc_fails_after_count= 3;
+ thread= psi->new_thread(thread_key_1, NULL, 0);
+ ok(thread == NULL, "oom (thread transactions history sizing)");
+
+ cleanup_thread_class();
+ cleanup_instruments();
+
+ /* Global stages. */
+ memset(&param, 0, sizeof(param));
+ param.m_enabled= true;
+ param.m_mutex_class_sizing= 10;
+ param.m_stage_class_sizing= 20;
+
+ stub_alloc_fails_after_count= 2;
+ init_event_name_sizing(&param);
+ rc= init_stage_class(param.m_stage_class_sizing);
+ ok(rc == 0, "init stage class");
+ rc= init_instruments(& param);
+ ok(rc == 1, "oom (global stages)");
+
+ cleanup_stage_class();
+ cleanup_instruments();
+
+ /* Global statements. */
+ memset(&param, 0, sizeof(param));
+ param.m_enabled= true;
+ param.m_mutex_class_sizing= 10;
+ param.m_statement_class_sizing= 20;
+
+ stub_alloc_fails_after_count= 2;
+ init_event_name_sizing(&param);
+ rc= init_statement_class(param.m_statement_class_sizing);
+ ok(rc == 0, "init statement class");
+ rc= init_instruments(&param);
+ ok(rc == 1, "oom (global statements)");
+
+ cleanup_statement_class();
+ cleanup_instruments();
+
+ /* Global memory. */
+ memset(&param, 0, sizeof(param));
+ param.m_enabled= true;
+ param.m_mutex_class_sizing= 10;
+ param.m_memory_class_sizing= 20;
+
+ stub_alloc_fails_after_count= 2;
+ init_event_name_sizing(&param);
+ rc= init_memory_class(param.m_memory_class_sizing);
+ ok(rc == 0, "init memory class");
+ rc= init_instruments(& param);
+ ok(rc == 1, "oom (global memory)");
+
+ cleanup_memory_class();
+ cleanup_instruments();
+}
+
+void do_all_tests()
+{
+ test_oom();
+}
+
+int main(int argc, char **argv)
+{
+ plan(32);
+ MY_INIT(argv[0]);
+ do_all_tests();
+ my_end(0);
+ return exit_status();
+}
+
diff --git a/storage/perfschema/unittest/pfs_instr-t.cc b/storage/perfschema/unittest/pfs_instr-t.cc
new file mode 100644
index 00000000..d4401ab7
--- /dev/null
+++ b/storage/perfschema/unittest/pfs_instr-t.cc
@@ -0,0 +1,488 @@
+/* Copyright (c) 2008, 2017, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#include <my_global.h>
+#include <my_thread.h>
+#include <pfs_instr.h>
+#include <pfs_stat.h>
+#include <pfs_global.h>
+#include <pfs_instr_class.h>
+#include <pfs_buffer_container.h>
+#include <tap.h>
+
+#include "stub_global_status_var.h"
+
+#include <memory.h>
+
+PFS_global_param param;
+
+void test_no_instruments()
+{
+ int rc;
+
+ memset(& param, 0xFF, sizeof(param));
+ param.m_enabled= true;
+ param.m_mutex_class_sizing= 0;
+ param.m_rwlock_class_sizing= 0;
+ param.m_cond_class_sizing= 0;
+ param.m_thread_class_sizing= 0;
+ param.m_table_share_sizing= 0;
+ param.m_file_class_sizing= 0;
+ param.m_socket_class_sizing= 0;
+ param.m_mutex_sizing= 0;
+ param.m_rwlock_sizing= 0;
+ param.m_cond_sizing= 0;
+ param.m_thread_sizing= 0;
+ param.m_table_sizing= 0;
+ param.m_file_sizing= 0;
+ param.m_file_handle_sizing= 0;
+ param.m_socket_sizing= 0;
+ param.m_events_waits_history_sizing= 0;
+ param.m_events_waits_history_long_sizing= 0;
+ param.m_setup_actor_sizing= 0;
+ param.m_setup_object_sizing= 0;
+ param.m_host_sizing= 0;
+ param.m_user_sizing= 0;
+ param.m_account_sizing= 0;
+ param.m_stage_class_sizing= 0;
+ param.m_events_stages_history_sizing= 0;
+ param.m_events_stages_history_long_sizing= 0;
+ param.m_statement_class_sizing= 0;
+ param.m_events_statements_history_sizing= 0;
+ param.m_events_statements_history_long_sizing= 0;
+ param.m_events_transactions_history_sizing= 0;
+ param.m_events_transactions_history_long_sizing= 0;
+ param.m_digest_sizing= 0;
+ param.m_session_connect_attrs_sizing= 0;
+ param.m_program_sizing= 0;
+ param.m_prepared_stmt_sizing= 0;
+ param.m_statement_stack_sizing= 0;
+ param.m_memory_class_sizing= 0;
+ param.m_metadata_lock_sizing= 0;
+
+ init_event_name_sizing(& param);
+ rc= init_instruments(& param);
+ ok(rc == 0, "zero init");
+
+ cleanup_instruments();
+}
+
+void test_no_instances()
+{
+ int rc;
+ PFS_mutex_class dummy_mutex_class;
+ PFS_rwlock_class dummy_rwlock_class;
+ PFS_cond_class dummy_cond_class;
+ PFS_thread_class dummy_thread_class;
+ PFS_file_class dummy_file_class;
+ PFS_table_share dummy_table_share;
+ PFS_socket_class dummy_socket_class;
+ PFS_mutex *mutex;
+ PFS_rwlock *rwlock;
+ PFS_cond *cond;
+ PFS_thread *thread;
+ PFS_file *file;
+ PFS_socket *socket;
+ PFS_table *table;
+
+ dummy_mutex_class.m_event_name_index = 0;
+ dummy_mutex_class.m_flags = 0;
+ dummy_mutex_class.m_enabled = true;
+ dummy_mutex_class.m_volatility = PSI_VOLATILITY_UNKNOWN;
+ dummy_rwlock_class.m_event_name_index = 1;
+ dummy_rwlock_class.m_flags = 0;
+ dummy_rwlock_class.m_enabled = true;
+ dummy_rwlock_class.m_volatility = PSI_VOLATILITY_UNKNOWN;
+ dummy_cond_class.m_event_name_index = 2;
+ dummy_cond_class.m_flags = 0;
+ dummy_cond_class.m_enabled = true;
+ dummy_cond_class.m_volatility = PSI_VOLATILITY_UNKNOWN;
+ dummy_file_class.m_event_name_index = 3;
+ dummy_file_class.m_flags = 0;
+ dummy_file_class.m_enabled = true;
+ dummy_file_class.m_volatility = PSI_VOLATILITY_UNKNOWN;
+ dummy_socket_class.m_event_name_index = 4;
+ dummy_socket_class.m_flags = 0;
+ dummy_socket_class.m_enabled = true;
+ dummy_socket_class.m_volatility = PSI_VOLATILITY_UNKNOWN;
+
+ memset(& param, 0xFF, sizeof(param));
+ param.m_enabled= true;
+ param.m_mutex_class_sizing= 1;
+ param.m_rwlock_class_sizing= 1;
+ param.m_cond_class_sizing= 1;
+ param.m_thread_class_sizing= 1;
+ param.m_table_share_sizing= 1;
+ param.m_file_class_sizing= 1;
+ param.m_socket_class_sizing= 0;
+ param.m_mutex_sizing= 0;
+ param.m_rwlock_sizing= 0;
+ param.m_cond_sizing= 0;
+ param.m_thread_sizing= 0;
+ param.m_table_sizing= 0;
+ param.m_file_sizing= 0;
+ param.m_file_handle_sizing= 0;
+ param.m_socket_sizing= 0;
+ param.m_events_waits_history_sizing= 0;
+ param.m_events_waits_history_long_sizing= 0;
+ param.m_setup_actor_sizing= 0;
+ param.m_setup_object_sizing= 0;
+ param.m_host_sizing= 0;
+ param.m_user_sizing= 0;
+ param.m_account_sizing= 0;
+ param.m_stage_class_sizing= 0;
+ param.m_events_stages_history_sizing= 0;
+ param.m_events_stages_history_long_sizing= 0;
+ param.m_statement_class_sizing= 0;
+ param.m_events_statements_history_sizing= 0;
+ param.m_events_statements_history_long_sizing= 0;
+ param.m_events_transactions_history_sizing= 0;
+ param.m_events_transactions_history_long_sizing= 0;
+ param.m_digest_sizing= 0;
+ param.m_session_connect_attrs_sizing= 0;
+ param.m_program_sizing= 0;
+ param.m_prepared_stmt_sizing= 0;
+ param.m_statement_stack_sizing= 0;
+ param.m_memory_class_sizing= 1;
+ param.m_metadata_lock_sizing= 0;
+
+ init_event_name_sizing(& param);
+ rc= init_instruments(& param);
+ ok(rc == 0, "no instances init");
+
+ mutex= create_mutex(& dummy_mutex_class, NULL);
+ ok(mutex == NULL, "no mutex");
+ ok(global_mutex_container.get_lost_counter() == 1, "lost 1");
+ mutex= create_mutex(& dummy_mutex_class, NULL);
+ ok(mutex == NULL, "no mutex");
+ ok(global_mutex_container.get_lost_counter() == 2, "lost 2");
+
+ rwlock= create_rwlock(& dummy_rwlock_class, NULL);
+ ok(rwlock == NULL, "no rwlock");
+ ok(global_rwlock_container.m_lost == 1, "lost 1");
+ rwlock= create_rwlock(& dummy_rwlock_class, NULL);
+ ok(rwlock == NULL, "no rwlock");
+ ok(global_rwlock_container.m_lost == 2, "lost 2");
+
+ cond= create_cond(& dummy_cond_class, NULL);
+ ok(cond == NULL, "no cond");
+ ok(global_cond_container.m_lost == 1, "lost 1");
+ cond= create_cond(& dummy_cond_class, NULL);
+ ok(cond == NULL, "no cond");
+ ok(global_cond_container.m_lost == 2, "lost 2");
+
+ thread= create_thread(& dummy_thread_class, NULL, 0);
+ ok(thread == NULL, "no thread");
+ ok(global_thread_container.m_lost == 1, "lost 1");
+ thread= create_thread(& dummy_thread_class, NULL, 0);
+ ok(thread == NULL, "no thread");
+ ok(global_thread_container.m_lost == 2, "lost 2");
+
+ PFS_thread fake_thread;
+ fake_thread.m_filename_hash_pins= NULL;
+
+ file= find_or_create_file(& fake_thread, & dummy_file_class, "dummy", 5, true);
+ ok(file == NULL, "no file");
+ ok(global_file_container.m_lost == 1, "lost 1");
+ file= find_or_create_file(& fake_thread, & dummy_file_class, "dummy", 5, true);
+ ok(file == NULL, "no file");
+ ok(global_file_container.m_lost == 2, "lost 2");
+
+ init_file_hash(& param);
+
+ file= find_or_create_file(& fake_thread, & dummy_file_class, "dummy", 5, true);
+ ok(file == NULL, "no file");
+ ok(global_file_container.m_lost == 3, "lost 3");
+ file= find_or_create_file(& fake_thread, & dummy_file_class, "dummy", 5, true);
+ ok(file == NULL, "no file");
+ ok(global_file_container.m_lost == 4, "lost 4");
+
+ char long_file_name[10000];
+ int size= sizeof(long_file_name);
+ memset(long_file_name, 'X', size);
+
+ file= find_or_create_file(& fake_thread, & dummy_file_class, long_file_name, size, true);
+ ok(file == NULL, "no file");
+ ok(global_file_container.m_lost == 5, "lost 5");
+
+ table= create_table(& dummy_table_share, & fake_thread, NULL);
+ ok(table == NULL, "no table");
+ ok(global_table_container.m_lost == 1, "lost 1");
+ table= create_table(& dummy_table_share, & fake_thread, NULL);
+ ok(table == NULL, "no table");
+ ok(global_table_container.m_lost == 2, "lost 2");
+
+ socket= create_socket(& dummy_socket_class, NULL, NULL, 0);
+ ok(socket == NULL, "no socket");
+ ok(global_socket_container.m_lost == 1, "lost 1");
+ socket= create_socket(& dummy_socket_class, NULL, NULL, 0);
+ ok(socket == NULL, "no socket");
+ ok(global_socket_container.m_lost == 2, "lost 2");
+
+ /* No result to test, just make sure it does not crash */
+ reset_events_waits_by_instance();
+ reset_events_waits_by_thread();
+
+ cleanup_file_hash();
+ cleanup_instruments();
+}
+
+void test_with_instances()
+{
+ int rc;
+ PFS_mutex_class dummy_mutex_class;
+ PFS_rwlock_class dummy_rwlock_class;
+ PFS_cond_class dummy_cond_class;
+ PFS_thread_class dummy_thread_class;
+ PFS_file_class dummy_file_class;
+ PFS_socket_class dummy_socket_class;
+ PFS_table_share dummy_table_share;
+ PFS_mutex *mutex_1;
+ PFS_mutex *mutex_2;
+ PFS_rwlock *rwlock_1;
+ PFS_rwlock *rwlock_2;
+ PFS_cond *cond_1;
+ PFS_cond *cond_2;
+ PFS_thread *thread_1;
+ PFS_thread *thread_2;
+ PFS_file *file_1;
+ PFS_file *file_2;
+ PFS_socket *socket_1;
+ PFS_socket *socket_2;
+ PFS_table *table_1;
+ PFS_table *table_2;
+
+ memset(& param, 0xFF, sizeof(param));
+ param.m_enabled= true;
+ param.m_mutex_class_sizing= 1;
+ param.m_rwlock_class_sizing= 1;
+ param.m_cond_class_sizing= 1;
+ param.m_thread_class_sizing= 1;
+ param.m_table_share_sizing= 1;
+ param.m_file_class_sizing= 1;
+ param.m_socket_class_sizing= 1;
+ param.m_mutex_sizing= 2;
+ param.m_rwlock_sizing= 2;
+ param.m_cond_sizing= 2;
+ param.m_thread_sizing= 2;
+ param.m_table_sizing= 2;
+ param.m_file_sizing= 2;
+ param.m_file_handle_sizing= 100;
+ param.m_socket_sizing= 2;
+ param.m_events_waits_history_sizing= 10;
+ param.m_events_waits_history_long_sizing= 10000;
+ param.m_setup_actor_sizing= 0;
+ param.m_setup_object_sizing= 0;
+ param.m_host_sizing= 0;
+ param.m_user_sizing= 0;
+ param.m_account_sizing= 0;
+ param.m_stage_class_sizing= 0;
+ param.m_events_stages_history_sizing= 0;
+ param.m_events_stages_history_long_sizing= 0;
+ param.m_statement_class_sizing= 0;
+ param.m_events_statements_history_sizing= 0;
+ param.m_events_statements_history_long_sizing= 0;
+ param.m_events_transactions_history_sizing= 0;
+ param.m_events_transactions_history_long_sizing= 0;
+ param.m_digest_sizing= 0;
+ param.m_session_connect_attrs_sizing= 0;
+ param.m_program_sizing= 0;
+ param.m_prepared_stmt_sizing= 0;
+ param.m_statement_stack_sizing= 0;
+ param.m_memory_class_sizing= 1;
+ param.m_metadata_lock_sizing= 0;
+
+ init_event_name_sizing(& param);
+ rc= init_instruments(& param);
+ ok(rc == 0, "instances init");
+
+ dummy_mutex_class.m_event_name_index= 0;
+ dummy_mutex_class.m_flags= 0;
+ dummy_mutex_class.m_enabled= true;
+ dummy_mutex_class.m_volatility = PSI_VOLATILITY_UNKNOWN;
+ dummy_rwlock_class.m_event_name_index= 1;
+ dummy_rwlock_class.m_flags= 0;
+ dummy_rwlock_class.m_enabled= true;
+ dummy_rwlock_class.m_volatility = PSI_VOLATILITY_UNKNOWN;
+ dummy_cond_class.m_event_name_index= 2;
+ dummy_cond_class.m_flags= 0;
+ dummy_cond_class.m_enabled= true;
+ dummy_cond_class.m_volatility = PSI_VOLATILITY_UNKNOWN;
+ dummy_file_class.m_event_name_index= 3;
+ dummy_file_class.m_flags= 0;
+ dummy_file_class.m_enabled= true;
+ dummy_file_class.m_volatility = PSI_VOLATILITY_UNKNOWN;
+ dummy_socket_class.m_event_name_index= 4;
+ dummy_socket_class.m_flags= 0;
+ dummy_socket_class.m_enabled= true;
+ dummy_socket_class.m_volatility = PSI_VOLATILITY_UNKNOWN;
+
+ dummy_table_share.m_enabled= true;
+ dummy_table_share.m_timed= true;
+
+ mutex_1= create_mutex(& dummy_mutex_class, NULL);
+ ok(mutex_1 != NULL, "mutex");
+ ok(global_mutex_container.get_lost_counter() == 0, "not lost");
+ mutex_2= create_mutex(& dummy_mutex_class, NULL);
+ ok(mutex_2 != NULL, "mutex");
+ ok(global_mutex_container.get_lost_counter() == 0, "not lost");
+ mutex_2= create_mutex(& dummy_mutex_class, NULL);
+ ok(mutex_2 == NULL, "no mutex");
+ ok(global_mutex_container.get_lost_counter() == 1, "lost 1");
+ destroy_mutex(mutex_1);
+ mutex_2= create_mutex(& dummy_mutex_class, NULL);
+ ok(mutex_2 != NULL, "mutex");
+ ok(global_mutex_container.get_lost_counter() == 1, "no new loss");
+
+ rwlock_1= create_rwlock(& dummy_rwlock_class, NULL);
+ ok(rwlock_1 != NULL, "rwlock");
+ ok(global_rwlock_container.m_lost == 0, "not lost");
+ rwlock_2= create_rwlock(& dummy_rwlock_class, NULL);
+ ok(rwlock_2 != NULL, "rwlock");
+ ok(global_rwlock_container.m_lost == 0, "not lost");
+ rwlock_2= create_rwlock(& dummy_rwlock_class, NULL);
+ ok(rwlock_2 == NULL, "no rwlock");
+ ok(global_rwlock_container.m_lost == 1, "lost 1");
+ destroy_rwlock(rwlock_1);
+ rwlock_2= create_rwlock(& dummy_rwlock_class, NULL);
+ ok(rwlock_2 != NULL, "rwlock");
+ ok(global_rwlock_container.m_lost == 1, "no new loss");
+
+ cond_1= create_cond(& dummy_cond_class, NULL);
+ ok(cond_1 != NULL, "cond");
+ ok(global_cond_container.m_lost == 0, "not lost");
+ cond_2= create_cond(& dummy_cond_class, NULL);
+ ok(cond_2 != NULL, "cond");
+ ok(global_cond_container.m_lost == 0, "not lost");
+ cond_2= create_cond(& dummy_cond_class, NULL);
+ ok(cond_2 == NULL, "no cond");
+ ok(global_cond_container.m_lost == 1, "lost 1");
+ destroy_cond(cond_1);
+ cond_2= create_cond(& dummy_cond_class, NULL);
+ ok(cond_2 != NULL, "cond");
+ ok(global_cond_container.m_lost == 1, "no new loss");
+
+ thread_1= create_thread(& dummy_thread_class, NULL, 0);
+ ok(thread_1 != NULL, "thread");
+ ok(global_thread_container.m_lost == 0, "not lost");
+ thread_2= create_thread(& dummy_thread_class, NULL, 0);
+ ok(thread_2 != NULL, "thread");
+ ok(global_thread_container.m_lost == 0, "not lost");
+ thread_2= create_thread(& dummy_thread_class, NULL, 0);
+ ok(thread_2 == NULL, "no thread");
+ ok(global_thread_container.m_lost == 1, "lost 1");
+ destroy_thread(thread_1);
+ thread_2= create_thread(& dummy_thread_class, NULL, 0);
+ ok(thread_2 != NULL, "thread");
+ ok(global_thread_container.m_lost == 1, "no new loss");
+
+ PFS_thread fake_thread;
+ fake_thread.m_filename_hash_pins= NULL;
+
+ file_1= find_or_create_file(& fake_thread, & dummy_file_class, "dummy", 5, true);
+ ok(file_1 == NULL, "no file");
+ ok(global_file_container.m_lost == 1, "lost 1");
+ file_1= find_or_create_file(& fake_thread, & dummy_file_class, "dummy", 5, true);
+ ok(file_1 == NULL, "no file");
+ ok(global_file_container.m_lost == 2, "lost 2");
+
+ init_file_hash(& param);
+ global_file_container.m_lost= 0;
+
+ file_1= find_or_create_file(& fake_thread, & dummy_file_class, "dummy_A", 7, true);
+ ok(file_1 != NULL, "file");
+ ok(file_1->m_file_stat.m_open_count == 1, "open count 1");
+ ok(global_file_container.m_lost == 0, "not lost");
+ file_2= find_or_create_file(& fake_thread, & dummy_file_class, "dummy_A", 7, true);
+ ok(file_1 == file_2, "same file");
+ ok(file_1->m_file_stat.m_open_count == 2, "open count 2");
+ ok(global_file_container.m_lost == 0, "not lost");
+ release_file(file_2);
+ ok(file_1->m_file_stat.m_open_count == 1, "open count 1");
+ file_2= find_or_create_file(& fake_thread, & dummy_file_class, "dummy_B", 7, true);
+ ok(file_2 != NULL, "file");
+ ok(global_file_container.m_lost == 0, "not lost");
+ file_2= find_or_create_file(& fake_thread, & dummy_file_class, "dummy_C", 7, true);
+ ok(file_2 == NULL, "no file");
+ ok(global_file_container.m_lost == 1, "lost");
+ release_file(file_1);
+ /* the file still exists, not destroyed */
+ ok(file_1->m_file_stat.m_open_count == 0, "open count 0");
+ file_2= find_or_create_file(& fake_thread, & dummy_file_class, "dummy_D", 7, true);
+ ok(file_2 == NULL, "no file");
+ ok(global_file_container.m_lost == 2, "lost");
+
+ socket_1= create_socket(& dummy_socket_class, NULL, NULL, 0);
+ ok(socket_1 != NULL, "socket");
+ ok(global_socket_container.m_lost == 0, "not lost");
+ socket_2= create_socket(& dummy_socket_class, NULL, NULL, 0);
+ ok(socket_2 != NULL, "socket");
+ ok(global_socket_container.m_lost == 0, "not lost");
+ socket_2= create_socket(& dummy_socket_class, NULL, NULL, 0);
+ ok(socket_2 == NULL, "no socket");
+ ok(global_socket_container.m_lost == 1, "lost 1");
+ destroy_socket(socket_1);
+ socket_2= create_socket(& dummy_socket_class, NULL, NULL, 0);
+ ok(socket_2 != NULL, "socket");
+ ok(global_socket_container.m_lost == 1, "no new loss");
+
+ table_1= create_table(& dummy_table_share, & fake_thread, NULL);
+ ok(table_1 != NULL, "table");
+ ok(global_table_container.m_lost == 0, "not lost");
+ table_2= create_table(& dummy_table_share, & fake_thread, NULL);
+ ok(table_2 != NULL, "table");
+ ok(global_table_container.m_lost == 0, "not lost");
+ table_2= create_table(& dummy_table_share, & fake_thread, NULL);
+ ok(table_2 == NULL, "no table");
+ ok(global_table_container.m_lost == 1, "lost 1");
+ destroy_table(table_1);
+ table_2= create_table(& dummy_table_share, & fake_thread, NULL);
+ ok(table_2 != NULL, "table");
+ ok(global_table_container.m_lost == 1, "no new loss");
+
+ //TODO: test that cleanup works
+ reset_events_waits_by_instance();
+ reset_events_waits_by_thread();
+
+ cleanup_file_hash();
+ cleanup_instruments();
+}
+
+void do_all_tests()
+{
+ flag_global_instrumentation= true;
+ flag_thread_instrumentation= true;
+
+ test_no_instruments();
+ test_no_instances();
+ test_with_instances();
+}
+
+int main(int argc, char **argv)
+{
+ plan(103);
+ MY_INIT(argv[0]);
+ do_all_tests();
+ my_end(0);
+ return (exit_status());
+}
+
diff --git a/storage/perfschema/unittest/pfs_instr_class-oom-t.cc b/storage/perfschema/unittest/pfs_instr_class-oom-t.cc
new file mode 100644
index 00000000..0f9d6ef0
--- /dev/null
+++ b/storage/perfschema/unittest/pfs_instr_class-oom-t.cc
@@ -0,0 +1,114 @@
+/* Copyright (c) 2008, 2017, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#include <my_global.h>
+#include <my_thread.h>
+#include <pfs_instr_class.h>
+#include <pfs_instr.h>
+#include <pfs_global.h>
+#include <tap.h>
+#include <sql_class.h>
+#include <pfs_buffer_container.h>
+
+#include "stub_pfs_global.h"
+#include "stub_global_status_var.h"
+
+void test_oom()
+{
+ int rc;
+ PFS_global_param param;
+ TABLE_SHARE table_share;
+ PFS_thread pfs_thread;
+ PFS_table_share *pfs_table_share;
+
+ rc= init_sync_class(1000, 0, 0);
+ ok(rc == 1, "oom (mutex)");
+ rc= init_sync_class(0, 1000, 0);
+ ok(rc == 1, "oom (rwlock)");
+ rc= init_sync_class(0, 0, 1000);
+ ok(rc == 1, "oom (cond)");
+ rc= init_thread_class(1000);
+ ok(rc == 1, "oom (thread)");
+ rc= init_file_class(1000);
+ ok(rc == 1, "oom (file)");
+ rc= init_socket_class(1000);
+ ok(rc == 1, "oom (socket)");
+ rc= init_stage_class(1000);
+ ok(rc == 1, "oom (stage)");
+ rc= init_statement_class(1000);
+ ok(rc == 1, "oom (statement)");
+ rc= init_memory_class(1000);
+ ok(rc == 1, "oom (memory)");
+
+ cleanup_sync_class();
+ cleanup_thread_class();
+ cleanup_file_class();
+ cleanup_table_share();
+ cleanup_socket_class();
+ cleanup_stage_class();
+ cleanup_statement_class();
+ cleanup_memory_class();
+
+ /* Table share classes. */
+ memset(&param, 0, sizeof(param));
+ param.m_enabled= true;
+ param.m_table_share_sizing= 100;
+ param.m_setup_object_sizing= 100;
+
+ pfs_thread.m_table_share_hash_pins= NULL;
+ pfs_thread.m_setup_object_hash_pins= NULL;
+
+ char db_name[]= "schema 1";
+ char table_name[]= "table 1";
+ table_share.db.str= db_name;
+ table_share.db.length= strlen(db_name);
+ table_share.table_name.str= table_name;
+ table_share.table_name.length= strlen(table_name);
+
+ init_table_share(param.m_table_share_sizing);
+ init_table_share_hash(&param);
+ init_setup_object_hash(&param);
+
+ stub_alloc_always_fails= false;
+ pfs_table_share= find_or_create_table_share(&pfs_thread, false, &table_share);
+ ok(pfs_table_share == NULL, "oom (pfs table share)");
+ ok(global_table_share_container.m_lost == 1, "oom (table share)");
+
+ cleanup_table_share();
+ cleanup_table_share_hash();
+ cleanup_setup_object_hash();
+}
+
+void do_all_tests()
+{
+ test_oom();
+}
+
+int main(int argc, char **argv)
+{
+ plan(11);
+ MY_INIT(argv[0]);
+ do_all_tests();
+ my_end(0);
+ return (exit_status());
+}
+
diff --git a/storage/perfschema/unittest/pfs_instr_class-t.cc b/storage/perfschema/unittest/pfs_instr_class-t.cc
new file mode 100644
index 00000000..3dfd725c
--- /dev/null
+++ b/storage/perfschema/unittest/pfs_instr_class-t.cc
@@ -0,0 +1,750 @@
+/* Copyright (c) 2008, 2017, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#include <my_global.h>
+#include <my_thread.h>
+#include <string.h> // strncpy
+#include <pfs_instr_class.h>
+#include <pfs_instr.h>
+#include <pfs_global.h>
+#include <tap.h>
+
+#include "stub_global_status_var.h"
+
+void test_no_registration()
+{
+ int rc;
+ PFS_sync_key key;
+ PFS_thread_key thread_key;
+ PFS_file_key file_key;
+ PFS_socket_key socket_key;
+ PFS_memory_key memory_key;
+ PFS_mutex_class *mutex;
+ PFS_rwlock_class *rwlock;
+ PFS_cond_class *cond;
+ PFS_thread_class *thread;
+ PFS_file_class *file;
+ PFS_socket_class *socket;
+ PFS_memory_class *memory;
+ /* PFS_table_share *table; */
+
+ rc= init_sync_class(0, 0, 0);
+ ok(rc == 0, "zero init (sync)");
+ rc= init_thread_class(0);
+ ok(rc == 0, "zero init (thread)");
+ rc= init_file_class(0);
+ ok(rc == 0, "zero init (file)");
+ rc= init_socket_class(0);
+ ok(rc == 0, "zero init (socket)");
+ rc= init_table_share(0);
+ ok(rc == 0, "zero init (table)");
+ rc= init_memory_class(0);
+ ok(rc == 0, "zero init (memory)");
+
+ key= register_mutex_class("FOO", 3, 0);
+ ok(key == 0, "no mutex registered");
+ key= register_mutex_class("BAR", 3, 0);
+ ok(key == 0, "no mutex registered");
+ key= register_mutex_class("FOO", 3, 0);
+ ok(key == 0, "no mutex registered");
+
+ key= register_rwlock_class("FOO", 3, 0);
+ ok(key == 0, "no rwlock registered");
+ key= register_rwlock_class("BAR", 3, 0);
+ ok(key == 0, "no rwlock registered");
+ key= register_rwlock_class("FOO", 3, 0);
+ ok(key == 0, "no rwlock registered");
+
+ key= register_cond_class("FOO", 3, 0);
+ ok(key == 0, "no cond registered");
+ key= register_cond_class("BAR", 3, 0);
+ ok(key == 0, "no cond registered");
+ key= register_cond_class("FOO", 3, 0);
+ ok(key == 0, "no cond registered");
+
+ thread_key= register_thread_class("FOO", 3, 0);
+ ok(thread_key == 0, "no thread registered");
+ thread_key= register_thread_class("BAR", 3, 0);
+ ok(thread_key == 0, "no thread registered");
+ thread_key= register_thread_class("FOO", 3, 0);
+ ok(thread_key == 0, "no thread registered");
+
+ file_key= register_file_class("FOO", 3, 0);
+ ok(file_key == 0, "no file registered");
+ file_key= register_file_class("BAR", 3, 0);
+ ok(file_key == 0, "no file registered");
+ file_key= register_file_class("FOO", 3, 0);
+ ok(file_key == 0, "no file registered");
+
+ socket_key= register_socket_class("FOO", 3, 0);
+ ok(socket_key == 0, "no socket registered");
+ socket_key= register_socket_class("BAR", 3, 0);
+ ok(socket_key == 0, "no socket registered");
+ socket_key= register_socket_class("FOO", 3, 0);
+ ok(socket_key == 0, "no socket registered");
+
+ memory_key= register_memory_class("FOO", 3, 0);
+ ok(memory_key == 0, "no memory registered");
+ memory_key= register_memory_class("BAR", 3, 0);
+ ok(memory_key == 0, "no memory registered");
+ memory_key= register_memory_class("FOO", 3, 0);
+ ok(memory_key == 0, "no memory registered");
+
+#ifdef LATER
+ PFS_thread fake_thread;
+ fake_thread.m_table_share_hash_pins= NULL;
+
+ table= find_or_create_table_share(& fake_thread, false, "foo_db", 6, "foo_table", 9);
+ ok(table == NULL, "not created");
+ table= find_or_create_table_share(& fake_thread, false, "bar_db", 6, "bar_table", 9);
+ ok(table == NULL, "not created");
+ table= find_or_create_table_share(& fake_thread, false, "foo_db", 6, "foo_table", 9);
+ ok(table == NULL, "not created");
+#endif
+
+ mutex= find_mutex_class(0);
+ ok(mutex == NULL, "no mutex key 0");
+ mutex= find_mutex_class(1);
+ ok(mutex == NULL, "no mutex key 1");
+ mutex= find_mutex_class(9999);
+ ok(mutex == NULL, "no mutex key 9999");
+
+ rwlock= find_rwlock_class(0);
+ ok(rwlock == NULL, "no rwlock key 0");
+ rwlock= find_rwlock_class(1);
+ ok(rwlock == NULL, "no rwlock key 1");
+ rwlock= find_rwlock_class(9999);
+ ok(rwlock == NULL, "no rwlock key 9999");
+
+ cond= find_cond_class(0);
+ ok(cond == NULL, "no cond key 0");
+ cond= find_cond_class(1);
+ ok(cond == NULL, "no cond key 1");
+ cond= find_cond_class(9999);
+ ok(cond == NULL, "no cond key 9999");
+
+ thread= find_thread_class(0);
+ ok(thread == NULL, "no thread key 0");
+ thread= find_thread_class(1);
+ ok(thread == NULL, "no thread key 1");
+ thread= find_thread_class(9999);
+ ok(thread == NULL, "no thread key 9999");
+
+ file= find_file_class(0);
+ ok(file == NULL, "no file key 0");
+ file= find_file_class(1);
+ ok(file == NULL, "no file key 1");
+ file= find_file_class(9999);
+ ok(file == NULL, "no file key 9999");
+
+ socket= find_socket_class(0);
+ ok(socket == NULL, "no socket key 0");
+ socket= find_socket_class(1);
+ ok(socket == NULL, "no socket key 1");
+ socket= find_socket_class(9999);
+ ok(socket == NULL, "no socket key 9999");
+
+ memory= find_memory_class(0);
+ ok(memory == NULL, "no memory key 0");
+ memory= find_memory_class(1);
+ ok(memory == NULL, "no memory key 1");
+ memory= find_memory_class(9999);
+ ok(memory == NULL, "no memory key 9999");
+
+ cleanup_sync_class();
+ cleanup_thread_class();
+ cleanup_file_class();
+ cleanup_socket_class();
+ cleanup_table_share();
+ cleanup_memory_class();
+}
+
+void test_mutex_registration()
+{
+ int rc;
+ PFS_sync_key key;
+ PFS_mutex_class *mutex;
+
+ rc= init_sync_class(5, 0, 0);
+ ok(rc == 0, "room for 5 mutex");
+
+ key= register_mutex_class("FOO", 3, 0);
+ ok(key == 1, "foo registered");
+ key= register_mutex_class("BAR", 3, 0);
+ ok(key == 2, "bar registered");
+ key= register_mutex_class("FOO", 3, 0);
+ ok(key == 1, "foo re registered");
+ key= register_mutex_class("M-3", 3, 0);
+ ok(key == 3, "M-3 registered");
+ key= register_mutex_class("M-4", 3, 0);
+ ok(key == 4, "M-4 registered");
+ key= register_mutex_class("M-5", 3, 0);
+ ok(key == 5, "M-5 registered");
+ ok(mutex_class_lost == 0, "lost nothing");
+ key= register_mutex_class("M-6", 3, 0);
+ ok(key == 0, "M-6 not registered");
+ ok(mutex_class_lost == 1, "lost 1 mutex");
+ key= register_mutex_class("M-7", 3, 0);
+ ok(key == 0, "M-7 not registered");
+ ok(mutex_class_lost == 2, "lost 2 mutex");
+ key= register_mutex_class("M-3", 3, 0);
+ ok(key == 3, "M-3 re registered");
+ ok(mutex_class_lost == 2, "lost 2 mutex");
+ key= register_mutex_class("M-5", 3, 0);
+ ok(key == 5, "M-5 re registered");
+ ok(mutex_class_lost == 2, "lost 2 mutex");
+
+ mutex= find_mutex_class(0);
+ ok(mutex == NULL, "no key 0");
+ mutex= find_mutex_class(3);
+ ok(mutex != NULL, "found key 3");
+ ok(strncmp(mutex->m_name, "M-3", 3) == 0, "key 3 is M-3");
+ ok(mutex->m_name_length == 3, "name length 3");
+ mutex= find_mutex_class(9999);
+ ok(mutex == NULL, "no key 9999");
+
+ cleanup_sync_class();
+}
+
+void test_rwlock_registration()
+{
+ int rc;
+ PFS_sync_key key;
+ PFS_rwlock_class *rwlock;
+
+ rc= init_sync_class(0, 5, 0);
+ ok(rc == 0, "room for 5 rwlock");
+
+ key= register_rwlock_class("FOO", 3, 0);
+ ok(key == 1, "foo registered");
+ key= register_rwlock_class("BAR", 3, 0);
+ ok(key == 2, "bar registered");
+ key= register_rwlock_class("FOO", 3, 0);
+ ok(key == 1, "foo re registered");
+ key= register_rwlock_class("RW-3", 4, 0);
+ ok(key == 3, "RW-3 registered");
+ key= register_rwlock_class("RW-4", 4, 0);
+ ok(key == 4, "RW-4 registered");
+ key= register_rwlock_class("RW-5", 4, 0);
+ ok(key == 5, "RW-5 registered");
+ key= register_rwlock_class("RW-6", 4, 0);
+ ok(key == 0, "RW-6 not registered");
+ key= register_rwlock_class("RW-7", 4, 0);
+ ok(key == 0, "RW-7 not registered");
+ key= register_rwlock_class("RW-3", 4, 0);
+ ok(key == 3, "RW-3 re registered");
+ key= register_rwlock_class("RW-5", 4, 0);
+ ok(key == 5, "RW-5 re registered");
+
+ rwlock= find_rwlock_class(0);
+ ok(rwlock == NULL, "no key 0");
+ rwlock= find_rwlock_class(3);
+ ok(rwlock != NULL, "found key 3");
+ ok(strncmp(rwlock->m_name, "RW-3", 4) == 0, "key 3 is RW-3");
+ ok(rwlock->m_name_length == 4, "name length 4");
+ rwlock= find_rwlock_class(9999);
+ ok(rwlock == NULL, "no key 9999");
+
+ cleanup_sync_class();
+}
+
+void test_cond_registration()
+{
+ int rc;
+ PFS_sync_key key;
+ PFS_cond_class *cond;
+
+ rc= init_sync_class(0, 0, 5);
+ ok(rc == 0, "room for 5 cond");
+
+ key= register_cond_class("FOO", 3, 0);
+ ok(key == 1, "foo registered");
+ key= register_cond_class("BAR", 3, 0);
+ ok(key == 2, "bar registered");
+ key= register_cond_class("FOO", 3, 0);
+ ok(key == 1, "foo re registered");
+ key= register_cond_class("C-3", 3, 0);
+ ok(key == 3, "C-3 registered");
+ key= register_cond_class("C-4", 3, 0);
+ ok(key == 4, "C-4 registered");
+ key= register_cond_class("C-5", 3, 0);
+ ok(key == 5, "C-5 registered");
+ key= register_cond_class("C-6", 3, 0);
+ ok(key == 0, "C-6 not registered");
+ key= register_cond_class("C-7", 3, 0);
+ ok(key == 0, "C-7 not registered");
+ key= register_cond_class("C-3", 3, 0);
+ ok(key == 3, "C-3 re registered");
+ key= register_cond_class("C-5", 3, 0);
+ ok(key == 5, "C-5 re registered");
+
+ cond= find_cond_class(0);
+ ok(cond == NULL, "no key 0");
+ cond= find_cond_class(3);
+ ok(cond != NULL, "found key 3");
+ ok(strncmp(cond->m_name, "C-3", 3) == 0, "key 3 is C-3");
+ ok(cond->m_name_length == 3, "name length 3");
+ cond= find_cond_class(9999);
+ ok(cond == NULL, "no key 9999");
+
+ cleanup_sync_class();
+}
+
+void test_thread_registration()
+{
+ int rc;
+ PFS_thread_key key;
+ PFS_thread_class *thread;
+
+ rc= init_thread_class(5);
+ ok(rc == 0, "room for 5 thread");
+
+ key= register_thread_class("FOO", 3, 0);
+ ok(key == 1, "foo registered");
+ key= register_thread_class("BAR", 3, 0);
+ ok(key == 2, "bar registered");
+ key= register_thread_class("FOO", 3, 0);
+ ok(key == 1, "foo re registered");
+ key= register_thread_class("Thread-3", 8, 0);
+ ok(key == 3, "Thread-3 registered");
+ key= register_thread_class("Thread-4", 8, 0);
+ ok(key == 4, "Thread-4 registered");
+ key= register_thread_class("Thread-5", 8, 0);
+ ok(key == 5, "Thread-5 registered");
+ key= register_thread_class("Thread-6", 8, 0);
+ ok(key == 0, "Thread-6 not registered");
+ key= register_thread_class("Thread-7", 8, 0);
+ ok(key == 0, "Thread-7 not registered");
+ key= register_thread_class("Thread-3", 8, 0);
+ ok(key == 3, "Thread-3 re registered");
+ key= register_thread_class("Thread-5", 8, 0);
+ ok(key == 5, "Thread-5 re registered");
+
+ thread= find_thread_class(0);
+ ok(thread == NULL, "no key 0");
+ thread= find_thread_class(3);
+ ok(thread != NULL, "found key 3");
+ ok(strncmp(thread->m_name, "Thread-3", 8) == 0, "key 3 is Thread-3");
+ ok(thread->m_name_length == 8, "name length 8");
+ thread= find_thread_class(9999);
+ ok(thread == NULL, "no key 9999");
+
+ cleanup_thread_class();
+}
+
+void test_file_registration()
+{
+ int rc;
+ PFS_file_key key;
+ PFS_file_class *file;
+
+ rc= init_file_class(5);
+ ok(rc == 0, "room for 5 file");
+
+ key= register_file_class("FOO", 3, 0);
+ ok(key == 1, "foo registered");
+ key= register_file_class("BAR", 3, 0);
+ ok(key == 2, "bar registered");
+ key= register_file_class("FOO", 3, 0);
+ ok(key == 1, "foo re registered");
+ key= register_file_class("File-3", 6, 0);
+ ok(key == 3, "File-3 registered");
+ key= register_file_class("File-4", 6, 0);
+ ok(key == 4, "File-4 registered");
+ key= register_file_class("File-5", 6, 0);
+ ok(key == 5, "File-5 registered");
+ key= register_file_class("File-6", 6, 0);
+ ok(key == 0, "File-6 not registered");
+ key= register_file_class("File-7", 6, 0);
+ ok(key == 0, "File-7 not registered");
+ key= register_file_class("File-3", 6, 0);
+ ok(key == 3, "File-3 re registered");
+ key= register_file_class("File-5", 6, 0);
+ ok(key == 5, "File-5 re registered");
+
+ file= find_file_class(0);
+ ok(file == NULL, "no key 0");
+ file= find_file_class(3);
+ ok(file != NULL, "found key 3");
+ ok(strncmp(file->m_name, "File-3", 6) == 0, "key 3 is File-3");
+ ok(file->m_name_length == 6, "name length 6");
+ file= find_file_class(9999);
+ ok(file == NULL, "no key 9999");
+
+ cleanup_file_class();
+}
+
+void test_socket_registration()
+{
+ int rc;
+ PFS_socket_key key;
+ PFS_socket_class *socket;
+
+ rc= init_socket_class(5);
+ ok(rc == 0, "room for 5 socket");
+
+ key= register_socket_class("FOO", 3, 0);
+ ok(key == 1, "foo registered");
+ key= register_socket_class("BAR", 3, 0);
+ ok(key == 2, "bar registered");
+ key= register_socket_class("FOO", 3, 0);
+ ok(key == 1, "foo re registered");
+ key= register_socket_class("Socket-3", 8, 0);
+ ok(key == 3, "Socket-3 registered");
+ key= register_socket_class("Socket-4", 8, 0);
+ ok(key == 4, "Socket-4 registered");
+ key= register_socket_class("Socket-5", 8, 0);
+ ok(key == 5, "Socket-5 registered");
+ ok(socket_class_lost == 0, "lost nothing");
+ key= register_socket_class("Socket-6", 8, 0);
+ ok(key == 0, "Socket-6 not registered");
+ ok(socket_class_lost == 1, "lost 1 socket");
+ key= register_socket_class("Socket-7", 8, 0);
+ ok(key == 0, "Socket-7 not registered");
+ ok(socket_class_lost == 2, "lost 2 socket");
+ key= register_socket_class("Socket-3", 8, 0);
+ ok(key == 3, "Socket-3 re registered");
+ ok(socket_class_lost == 2, "lost 2 socket");
+ key= register_socket_class("Socket-5", 8, 0);
+ ok(key == 5, "Socket-5 re registered");
+ ok(socket_class_lost == 2, "lost 2 socket");
+
+ socket= find_socket_class(0);
+ ok(socket == NULL, "no key 0");
+ socket= find_socket_class(3);
+ ok(socket != NULL, "found key 3");
+ ok(strncmp(socket->m_name, "Socket-3", 8) == 0, "key 3 is Socket-3");
+ ok(socket->m_name_length == 8, "name length 3");
+ socket= find_socket_class(9999);
+ ok(socket == NULL, "no key 9999");
+
+ cleanup_socket_class();
+}
+
+void test_table_registration()
+{
+#ifdef LATER
+ PFS_table_share *table_share;
+ PFS_table_share *table_share_2;
+
+ PFS_thread fake_thread;
+ fake_thread.m_table_share_hash_pins= NULL;
+
+ table_share_lost= 0;
+ table_share= find_or_create_table_share(& fake_thread, false, "db1", 3, "t1", 2);
+ ok(table_share == NULL, "not created");
+ ok(table_share_lost == 1, "lost the table");
+
+ table_share_lost= 0;
+ init_table_share(5);
+ init_table_share_hash();
+
+ table_share= find_or_create_table_share(& fake_thread, false, "db1", 3, "t1", 2);
+ ok(table_share != NULL, "created db1.t1");
+ ok(table_share_lost == 0, "not lost");
+
+ table_share_2= find_or_create_table_share(& fake_thread, false, "db1", 3, "t1", 2);
+ ok(table_share_2 != NULL, "found db1.t1");
+ ok(table_share_lost == 0, "not lost");
+ ok(table_share == table_share_2, "same table");
+
+ table_share_2= find_or_create_table_share(& fake_thread, false, "db1", 3, "t2", 2);
+ ok(table_share_2 != NULL, "created db1.t2");
+ ok(table_share_lost == 0, "not lost");
+
+ table_share_2= find_or_create_table_share(& fake_thread, false, "db2", 3, "t1", 2);
+ ok(table_share_2 != NULL, "created db2.t1");
+ ok(table_share_lost == 0, "not lost");
+
+ table_share_2= find_or_create_table_share(& fake_thread, false, "db2", 3, "t2", 2);
+ ok(table_share_2 != NULL, "created db2.t2");
+ ok(table_share_lost == 0, "not lost");
+
+ table_share_2= find_or_create_table_share(& fake_thread, false, "db3", 3, "t3", 2);
+ ok(table_share_2 != NULL, "created db3.t3");
+ ok(table_share_lost == 0, "not lost");
+
+ table_share_2= find_or_create_table_share(& fake_thread, false, "db4", 3, "t4", 2);
+ ok(table_share_2 == NULL, "lost db4.t4");
+ ok(table_share_lost == 1, "lost");
+
+ table_share_lost= 0;
+ table_share_2= find_or_create_table_share(& fake_thread, false, "db1", 3, "t2", 2);
+ ok(table_share_2 != NULL, "found db1.t2");
+ ok(table_share_lost == 0, "not lost");
+ ok(strncmp(table_share_2->m_schema_name, "db1", 3) == 0 , "schema db1");
+ ok(table_share_2->m_schema_name_length == 3, "length 3");
+ ok(strncmp(table_share_2->m_table_name, "t2", 2) == 0 , "table t2");
+ ok(table_share_2->m_table_name_length == 2, "length 2");
+
+ cleanup_table_share_hash();
+ cleanup_table_share();
+#endif
+}
+
+void test_memory_registration()
+{
+ int rc;
+ PFS_memory_key key;
+ PFS_memory_class *memory;
+
+ rc= init_memory_class(5);
+ ok(rc == 0, "room for 5 memory");
+
+ key= register_memory_class("FOO", 3, 0);
+ ok(key == 1, "foo registered");
+ key= register_memory_class("BAR", 3, 0);
+ ok(key == 2, "bar registered");
+ key= register_memory_class("FOO", 3, 0);
+ ok(key == 1, "foo re registered");
+ key= register_memory_class("Memory-3", 8, 0);
+ ok(key == 3, "Memory-3 registered");
+ key= register_memory_class("Memory-4", 8, 0);
+ ok(key == 4, "Memory-4 registered");
+ key= register_memory_class("Memory-5", 8, 0);
+ ok(key == 5, "Memory-5 registered");
+ ok(memory_class_lost == 0, "lost nothing");
+ key= register_memory_class("Memory-6", 8, 0);
+ ok(key == 0, "Memory-6 not registered");
+ ok(memory_class_lost == 1, "lost 1 memory");
+ key= register_memory_class("Memory-7", 8, 0);
+ ok(key == 0, "Memory-7 not registered");
+ ok(memory_class_lost == 2, "lost 2 memory");
+ key= register_memory_class("Memory-3", 8, 0);
+ ok(key == 3, "Memory-3 re registered");
+ ok(memory_class_lost == 2, "lost 2 memory");
+ key= register_memory_class("Memory-5", 8, 0);
+ ok(key == 5, "Memory-5 re registered");
+ ok(memory_class_lost == 2, "lost 2 memory");
+
+ memory= find_memory_class(0);
+ ok(memory == NULL, "no key 0");
+ memory= find_memory_class(3);
+ ok(memory != NULL, "found key 3");
+ ok(strncmp(memory->m_name, "Memory-3", 8) == 0, "key 3 is Memory-3");
+ ok(memory->m_name_length == 8, "name length 3");
+ memory= find_memory_class(9999);
+ ok(memory == NULL, "no key 9999");
+
+ cleanup_memory_class();
+}
+
+#ifdef LATER
+void set_wait_stat(PFS_instr_class *klass)
+{
+ PFS_single_stat *stat;
+ stat= & global_instr_class_waits_array[klass->m_event_name_index];
+
+ stat->m_count= 12;
+ stat->m_min= 5;
+ stat->m_max= 120;
+ stat->m_sum= 999;
+}
+
+bool is_empty_stat(PFS_instr_class *klass)
+{
+ PFS_single_stat *stat;
+ stat= & global_instr_class_waits_array[klass->m_event_name_index];
+
+ if (stat->m_count != 0)
+ return false;
+ if (stat->m_min != (ulonglong) -1)
+ return false;
+ if (stat->m_max != 0)
+ return false;
+ if (stat->m_sum != 0)
+ return false;
+ return true;
+}
+#endif
+
+void test_instruments_reset()
+{
+ int rc;
+ PFS_sync_key key;
+ PFS_file_key file_key;
+ PFS_socket_key socket_key;
+ PFS_mutex_class *mutex_1;
+ PFS_mutex_class *mutex_2;
+ PFS_mutex_class *mutex_3;
+ PFS_rwlock_class *rwlock_1;
+ PFS_rwlock_class *rwlock_2;
+ PFS_rwlock_class *rwlock_3;
+ PFS_cond_class *cond_1;
+ PFS_cond_class *cond_2;
+ PFS_cond_class *cond_3;
+ PFS_file_class *file_1;
+ PFS_file_class *file_2;
+ PFS_file_class *file_3;
+ PFS_socket_class *socket_1;
+ PFS_socket_class *socket_2;
+ PFS_socket_class *socket_3;
+
+ rc= init_sync_class(3, 3, 3);
+ ok(rc == 0, "init (sync)");
+ rc= init_thread_class(3);
+ ok(rc == 0, "init (thread)");
+ rc= init_file_class(3);
+ ok(rc == 0, "init (file)");
+ rc= init_socket_class(3);
+ ok(rc == 0, "init (socket)");
+
+ key= register_mutex_class("M-1", 3, 0);
+ ok(key == 1, "mutex registered");
+ key= register_mutex_class("M-2", 3, 0);
+ ok(key == 2, "mutex registered");
+ key= register_mutex_class("M-3", 3, 0);
+ ok(key == 3, "mutex registered");
+
+ key= register_rwlock_class("RW-1", 4, 0);
+ ok(key == 1, "rwlock registered");
+ key= register_rwlock_class("RW-2", 4, 0);
+ ok(key == 2, "rwlock registered");
+ key= register_rwlock_class("RW-3", 4, 0);
+ ok(key == 3, "rwlock registered");
+
+ key= register_cond_class("C-1", 3, 0);
+ ok(key == 1, "cond registered");
+ key= register_cond_class("C-2", 3, 0);
+ ok(key == 2, "cond registered");
+ key= register_cond_class("C-3", 3, 0);
+ ok(key == 3, "cond registered");
+
+ file_key= register_file_class("F-1", 3, 0);
+ ok(file_key == 1, "file registered");
+ file_key= register_file_class("F-2", 3, 0);
+ ok(file_key == 2, "file registered");
+ file_key= register_file_class("F-3", 3, 0);
+ ok(file_key == 3, "file registered");
+
+ socket_key= register_socket_class("S-1", 3, 0);
+ ok(socket_key == 1, "socket registered");
+ socket_key= register_socket_class("S-2", 3, 0);
+ ok(socket_key == 2, "socket registered");
+ socket_key= register_socket_class("S-3", 3, 0);
+ ok(socket_key == 3, "socket registered");
+
+ mutex_1= find_mutex_class(1);
+ ok(mutex_1 != NULL, "mutex key 1");
+ mutex_2= find_mutex_class(2);
+ ok(mutex_2 != NULL, "mutex key 2");
+ mutex_3= find_mutex_class(3);
+ ok(mutex_3 != NULL, "mutex key 3");
+
+ rwlock_1= find_rwlock_class(1);
+ ok(rwlock_1 != NULL, "rwlock key 1");
+ rwlock_2= find_rwlock_class(2);
+ ok(rwlock_2 != NULL, "rwlock key 2");
+ rwlock_3= find_rwlock_class(3);
+ ok(rwlock_3 != NULL, "rwlock key 3");
+
+ cond_1= find_cond_class(1);
+ ok(cond_1 != NULL, "cond key 1");
+ cond_2= find_cond_class(2);
+ ok(cond_2 != NULL, "cond key 2");
+ cond_3= find_cond_class(3);
+ ok(cond_3 != NULL, "cond key 3");
+
+ file_1= find_file_class(1);
+ ok(file_1 != NULL, "file key 1");
+ file_2= find_file_class(2);
+ ok(file_2 != NULL, "file key 2");
+ file_3= find_file_class(3);
+ ok(file_3 != NULL, "file key 3");
+
+ socket_1= find_socket_class(1);
+ ok(socket_1 != NULL, "socket key 1");
+ socket_2= find_socket_class(2);
+ ok(socket_2 != NULL, "socket key 2");
+ socket_3= find_socket_class(3);
+ ok(socket_3 != NULL, "socket key 3");
+
+#ifdef LATER
+ set_wait_stat(mutex_1);
+ set_wait_stat(mutex_2);
+ set_wait_stat(mutex_3);
+ set_wait_stat(rwlock_1);
+ set_wait_stat(rwlock_2);
+ set_wait_stat(rwlock_3);
+ set_wait_stat(cond_1);
+ set_wait_stat(cond_2);
+ set_wait_stat(cond_3);
+ set_wait_stat(file_1);
+ set_wait_stat(file_2);
+ set_wait_stat(file_3);
+
+ ok(! is_empty_stat(mutex_1), "mutex_1 stat is populated");
+ ok(! is_empty_stat(mutex_2), "mutex_2 stat is populated");
+ ok(! is_empty_stat(mutex_3), "mutex_3 stat is populated");
+ ok(! is_empty_stat(rwlock_1), "rwlock_1 stat is populated");
+ ok(! is_empty_stat(rwlock_2), "rwlock_2 stat is populated");
+ ok(! is_empty_stat(rwlock_3), "rwlock_3 stat is populated");
+ ok(! is_empty_stat(cond_1), "cond_1 stat is populated");
+ ok(! is_empty_stat(cond_2), "cond_2 stat is populated");
+ ok(! is_empty_stat(cond_3), "cond_3 stat is populated");
+ ok(! is_empty_stat(file_1), "file_1 stat is populated");
+ ok(! is_empty_stat(file_2), "file_2 stat is populated");
+ ok(! is_empty_stat(file_3), "file_3 stat is populated");
+
+ reset_global_wait_stat();
+
+ ok(is_empty_stat(mutex_1), "mutex_1 stat is cleared");
+ ok(is_empty_stat(mutex_2), "mutex_2 stat is cleared");
+ ok(is_empty_stat(mutex_3), "mutex_3 stat is cleared");
+ ok(is_empty_stat(rwlock_1), "rwlock_1 stat is cleared");
+ ok(is_empty_stat(rwlock_2), "rwlock_2 stat is cleared");
+ ok(is_empty_stat(rwlock_3), "rwlock_3 stat is cleared");
+ ok(is_empty_stat(cond_1), "cond_1 stat is cleared");
+ ok(is_empty_stat(cond_2), "cond_2 stat is cleared");
+ ok(is_empty_stat(cond_3), "cond_3 stat is cleared");
+ ok(is_empty_stat(file_1), "file_1 stat is cleared");
+ ok(is_empty_stat(file_2), "file_2 stat is cleared");
+ ok(is_empty_stat(file_3), "file_3 stat is cleared");
+#endif
+
+ cleanup_sync_class();
+ cleanup_file_class();
+ cleanup_socket_class();
+}
+
+void do_all_tests()
+{
+ test_no_registration();
+ test_mutex_registration();
+ test_rwlock_registration();
+ test_cond_registration();
+ test_thread_registration();
+ test_file_registration();
+ test_socket_registration();
+ test_table_registration();
+ test_memory_registration();
+ test_instruments_reset();
+}
+
+int main(int argc, char **argv)
+{
+ plan(209);
+ MY_INIT(argv[0]);
+ do_all_tests();
+ my_end(0);
+ return (exit_status());
+}
diff --git a/storage/perfschema/unittest/pfs_misc-t.cc b/storage/perfschema/unittest/pfs_misc-t.cc
new file mode 100644
index 00000000..d8217800
--- /dev/null
+++ b/storage/perfschema/unittest/pfs_misc-t.cc
@@ -0,0 +1,95 @@
+/* Copyright (c) 2015, 2017, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#include <my_global.h>
+#include <my_thread.h>
+#include <pfs_instr.h>
+#include <pfs_stat.h>
+#include <pfs_global.h>
+#include <pfs_instr_class.h>
+#include <pfs_buffer_container.h>
+#include <tap.h>
+
+#include "stub_global_status_var.h"
+
+#include <memory.h>
+
+void test_digest_length_overflow()
+{
+ if (sizeof(size_t) != 4)
+ {
+ skip(3, "digest length overflow requires a 32-bit environment");
+ return;
+ }
+
+ PFS_global_param param;
+ memset(&param, 0, sizeof(param));
+ param.m_enabled= true;
+ /*
+ Force 32-bit arithmetic overflow using the digest memory allocation
+ parameters. The Performance Schema should detect the overflow, free
+ allocated memory and abort initialization with a warning.
+ */
+
+ /* Max digest length, events_statements_history_long. */
+ param.m_events_statements_history_long_sizing= 10000;
+ param.m_digest_sizing= 1000;
+ param.m_max_digest_length= (1024 * 1024);
+ param.m_max_sql_text_length= 0;
+ pfs_max_digest_length= param.m_max_digest_length;
+ pfs_max_sqltext= param.m_max_sql_text_length;
+
+ int rc = init_events_statements_history_long(param.m_events_statements_history_long_sizing);
+ ok(rc == 1, "digest length overflow (init_events_statements_history_long");
+
+ /* Max sql text length, events_statements_history_long. */
+ param.m_max_sql_text_length= (1024 * 1024);
+ param.m_max_digest_length= 0;
+ pfs_max_digest_length= param.m_max_digest_length;
+ pfs_max_sqltext= param.m_max_sql_text_length;
+
+ rc = init_events_statements_history_long(param.m_events_statements_history_long_sizing);
+ ok(rc == 1, "sql text length overflow (init_events_statements_history_long");
+
+ /* Max digest length, events_statements_summary_by_digest. */
+ param.m_max_digest_length= (1024 * 1024);
+ param.m_digest_sizing= 10000;
+ pfs_max_digest_length= param.m_max_digest_length;
+ pfs_max_sqltext= param.m_max_sql_text_length;
+
+ rc = init_digest(&param);
+ ok(rc == 1, "digest length overflow (init_digest)");
+}
+
+void do_all_tests()
+{
+ test_digest_length_overflow();
+}
+
+int main(int, char **)
+{
+ plan(3);
+ MY_INIT("pfs_misc-t");
+ do_all_tests();
+ my_end(0);
+ return (exit_status());
+}
diff --git a/storage/perfschema/unittest/pfs_noop-t.cc b/storage/perfschema/unittest/pfs_noop-t.cc
new file mode 100644
index 00000000..2756680d
--- /dev/null
+++ b/storage/perfschema/unittest/pfs_noop-t.cc
@@ -0,0 +1,242 @@
+/* Copyright (c) 2013, 2017, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
+
+#include <my_global.h>
+#include <my_thread.h>
+#include <pfs_server.h>
+#include <pfs_instr_class.h>
+#include <pfs_instr.h>
+#include <pfs_global.h>
+#include <tap.h>
+
+#include <string.h>
+#include <memory.h>
+
+#include "stub_print_error.h"
+#include "stub_pfs_defaults.h"
+
+void test_noop()
+{
+ PSI_mutex *mutex;
+ PSI_rwlock *rwlock;
+ PSI_cond *cond;
+ PSI_socket *socket;
+ PSI_table_share *table_share;
+ PSI_table *table;
+ PSI_file *file;
+ PSI_thread *thread;
+ PSI_file_locker *file_locker;
+ PSI_idle_locker *idle_locker;
+ PSI_mutex_locker *mutex_locker;
+ PSI_rwlock_locker *rwlock_locker;
+ PSI_cond_locker *cond_locker;
+ PSI_table_locker *table_locker;
+ PSI_statement_locker *statement_locker;
+ PSI_transaction_locker *transaction_locker;
+ PSI_socket_locker *socket_locker;
+ PSI_digest_locker *digest_locker;
+ PSI_sp_locker *sp_locker;
+ PSI_sp_share *sp_share;
+ PSI_memory_key memory_key;
+ PSI_metadata_lock *metadata_lock;
+ PSI_metadata_locker *metadata_locker;
+ PSI_thread *owner;
+
+ diag("test_noop");
+
+ PSI_server->register_mutex(NULL, NULL, 0);
+ PSI_server->register_rwlock(NULL, NULL, 0);
+ PSI_server->register_cond(NULL, NULL, 0);
+ PSI_server->register_thread(NULL, NULL, 0);
+ PSI_server->register_file(NULL, NULL, 0);
+ PSI_server->register_stage(NULL, NULL, 0);
+ PSI_server->register_statement(NULL, NULL, 0);
+ PSI_server->register_socket(NULL, NULL, 0);
+
+ ok(true, "register");
+ mutex= PSI_server->init_mutex(1, NULL);
+ ok(mutex == NULL, "no mutex");
+ PSI_server->destroy_mutex(NULL);
+ rwlock= PSI_server->init_rwlock(1, NULL);
+ ok(rwlock == NULL, "no rwlock");
+ PSI_server->destroy_rwlock(NULL);
+ cond= PSI_server->init_cond(1, NULL);
+ ok(cond == NULL, "no cond");
+ PSI_server->destroy_cond(NULL);
+ socket= PSI_server->init_socket(1, NULL, NULL, 0);
+ ok(socket == NULL, "no socket");
+ PSI_server->destroy_socket(NULL);
+ table_share= PSI_server->get_table_share(false, NULL);
+ ok(table_share == NULL, "no table_share");
+ PSI_server->release_table_share(NULL);
+ PSI_server->drop_table_share(false, NULL, 0, NULL, 0);
+ table= PSI_server->open_table(NULL, NULL);
+ ok(table == NULL, "no table");
+ PSI_server->unbind_table(NULL);
+ table= PSI_server->rebind_table(NULL, NULL, NULL);
+ ok(table == NULL, "no table");
+ PSI_server->close_table(NULL, NULL);
+ PSI_server->create_file(1, NULL, 2);
+ /* TODO: spawn thread */
+ thread= PSI_server->new_thread(1, NULL, 2);
+ ok(thread == NULL, "no thread");
+ PSI_server->set_thread_id(NULL, 1);
+ thread= PSI_server->get_thread();
+ ok(thread == NULL, "no thread");
+ PSI_server->set_thread_user(NULL, 0);
+ PSI_server->set_thread_account(NULL, 0, NULL, 0);
+ PSI_server->set_thread_db(NULL, 0);
+ PSI_server->set_thread_command(1);
+ PSI_server->set_thread_start_time(1);
+ PSI_server->set_thread_state(NULL);
+ PSI_server->set_thread_info(NULL, 0);
+ PSI_server->set_thread(NULL);
+ PSI_server->delete_current_thread();
+ PSI_server->delete_thread(NULL);
+ file_locker= PSI_server->get_thread_file_name_locker(NULL, 1, PSI_FILE_OPEN, NULL, NULL);
+ ok(file_locker == NULL, "no file_locker");
+ file_locker= PSI_server->get_thread_file_stream_locker(NULL, NULL, PSI_FILE_OPEN);
+ ok(file_locker == NULL, "no file_locker");
+ file_locker= PSI_server->get_thread_file_descriptor_locker(NULL, 0, PSI_FILE_OPEN);
+ ok(file_locker == NULL, "no file_locker");
+ PSI_server->unlock_mutex(NULL);
+ PSI_server->unlock_rwlock(NULL);
+ PSI_server->signal_cond(NULL);
+ PSI_server->broadcast_cond(NULL);
+ idle_locker= PSI_server->start_idle_wait(NULL, NULL, 0);
+ ok(idle_locker == NULL, "no idle_locker");
+ PSI_server->end_idle_wait(NULL);
+ mutex_locker= PSI_server->start_mutex_wait(NULL, NULL, PSI_MUTEX_LOCK, NULL, 0);
+ ok(mutex_locker == NULL, "no mutex_locker");
+ PSI_server->end_mutex_wait(NULL, 0);
+ rwlock_locker= PSI_server->start_rwlock_rdwait(NULL, NULL, PSI_RWLOCK_READLOCK, NULL, 0);
+ ok(rwlock_locker == NULL, "no rwlock_locker");
+ PSI_server->end_rwlock_rdwait(NULL, 0);
+ rwlock_locker= PSI_server->start_rwlock_wrwait(NULL, NULL, PSI_RWLOCK_WRITELOCK, NULL, 0);
+ ok(rwlock_locker == NULL, "no rwlock_locker");
+ PSI_server->end_rwlock_wrwait(NULL, 0);
+ cond_locker= PSI_server->start_cond_wait(NULL, NULL, NULL, PSI_COND_WAIT, NULL, 0);
+ ok(cond_locker == NULL, "no cond_locker");
+ PSI_server->end_cond_wait(NULL, 0);
+ table_locker= PSI_server->start_table_io_wait(NULL, NULL, PSI_TABLE_FETCH_ROW, 0, NULL, 0);
+ ok(table_locker == NULL, "no table_locker");
+ PSI_server->end_table_io_wait(NULL, 0);
+ table_locker= PSI_server->start_table_lock_wait(NULL, NULL, PSI_TABLE_LOCK, 0, NULL, 0);
+ ok(table_locker == NULL, "no table_locker");
+ PSI_server->end_table_lock_wait(NULL);
+ PSI_server->start_file_open_wait(NULL, NULL, 0);
+ file= PSI_server->end_file_open_wait(NULL, NULL);
+ ok(file == NULL, "no file");
+ PSI_server->end_file_open_wait_and_bind_to_descriptor(NULL, 0);
+ PSI_server->start_file_wait(NULL, 0, NULL, 0);
+ PSI_server->end_file_wait(NULL, 0);
+ PSI_server->start_file_close_wait(NULL, NULL, 0);
+ PSI_server->end_file_close_wait(NULL, 0);
+ PSI_server->end_file_rename_wait(NULL, NULL, NULL, 0);
+ PSI_server->start_stage(1, NULL, 0);
+
+ PSI_stage_progress *progress;
+ progress= PSI_server->get_current_stage_progress();
+ ok(progress == NULL, "no progress");
+
+ PSI_server->end_stage();
+ statement_locker= PSI_server->get_thread_statement_locker(NULL, 1, NULL, NULL);
+ ok(statement_locker == NULL, "no statement_locker");
+ statement_locker= PSI_server->refine_statement(NULL, 1);
+ ok(statement_locker == NULL, "no statement_locker");
+ PSI_server->start_statement(NULL, NULL, 0, NULL, 0);
+ PSI_server->set_statement_text(NULL, NULL, 0);
+ PSI_server->set_statement_lock_time(NULL, 0);
+ PSI_server->set_statement_rows_sent(NULL, 0);
+ PSI_server->set_statement_rows_examined(NULL, 0);
+ PSI_server->inc_statement_created_tmp_disk_tables(NULL, 0);
+ PSI_server->inc_statement_created_tmp_tables(NULL, 0);
+ PSI_server->inc_statement_select_full_join(NULL, 0);
+ PSI_server->inc_statement_select_full_range_join(NULL, 0);
+ PSI_server->inc_statement_select_range(NULL, 0);
+ PSI_server->inc_statement_select_range_check(NULL, 0);
+ PSI_server->inc_statement_select_scan(NULL, 0);
+ PSI_server->inc_statement_sort_merge_passes(NULL, 0);
+ PSI_server->inc_statement_sort_range(NULL, 0);
+ PSI_server->inc_statement_sort_rows(NULL, 0);
+ PSI_server->inc_statement_sort_scan(NULL, 0);
+ PSI_server->set_statement_no_index_used(NULL);
+ PSI_server->set_statement_no_good_index_used(NULL);
+ PSI_server->end_statement(NULL, NULL);
+ socket_locker= PSI_server->start_socket_wait(NULL, NULL, PSI_SOCKET_SEND, 1, NULL, 0);
+ ok(socket_locker == NULL, "no socket_locker");
+ PSI_server->end_socket_wait(NULL, 0);
+ PSI_server->set_socket_state(NULL, PSI_SOCKET_STATE_IDLE);
+ PSI_server->set_socket_info(NULL, NULL, NULL, 0);
+ PSI_server->set_socket_thread_owner(NULL);
+ digest_locker= PSI_server->digest_start(NULL);
+ ok(digest_locker == NULL, "no digest_locker");
+ PSI_server->digest_end(NULL, NULL);
+ sp_locker= PSI_server->start_sp(NULL, NULL);
+ ok(sp_locker == NULL, "no sp_locker");
+ PSI_server->end_sp(NULL);
+ PSI_server->drop_sp(0, NULL, 0, NULL, 0);
+ sp_share= PSI_server->get_sp_share(0, NULL, 0, NULL, 0);
+ ok(sp_share == NULL, "no sp_share");
+ PSI_server->release_sp_share(NULL);
+ PSI_server->register_memory(NULL, NULL, 0);
+ memory_key= PSI_server->memory_alloc(0, 0, & owner);
+ ok(memory_key == PSI_NOT_INSTRUMENTED, "no memory_key");
+ memory_key= PSI_server->memory_realloc(0, 0, 0, & owner);
+ ok(memory_key == PSI_NOT_INSTRUMENTED, "no memory_key");
+ PSI_server->memory_free(0, 0, NULL);
+ PSI_server->unlock_table(NULL);
+ metadata_lock= PSI_server->create_metadata_lock(NULL, NULL, 1, 2, 3, NULL, 0);
+ ok(metadata_lock == NULL, "no metadata_lock");
+ PSI_server->set_metadata_lock_status(NULL, 0);
+ PSI_server->destroy_metadata_lock(NULL);
+ metadata_locker= PSI_server->start_metadata_wait(NULL, NULL, NULL, 0);
+ ok(metadata_locker == NULL, "no metadata_locker");
+ PSI_server->end_metadata_wait(NULL, 0);
+
+ transaction_locker= PSI_server->get_thread_transaction_locker(NULL, NULL, 0, 1, false, 1);
+ ok(transaction_locker == NULL, "no transaction_locker");
+ PSI_server->start_transaction(NULL, NULL, 0);
+ PSI_server->end_transaction(NULL, true);
+
+ PSI_server->set_transaction_gtid(NULL, NULL, NULL);
+ PSI_server->set_transaction_trxid(NULL, NULL);
+ PSI_server->set_transaction_xa_state(NULL, 1);
+ PSI_server->set_transaction_xid(NULL, NULL, 1);
+ PSI_server->inc_transaction_release_savepoint(NULL, 1);
+ PSI_server->inc_transaction_rollback_to_savepoint(NULL, 1);
+ PSI_server->inc_transaction_savepoints(NULL, 1);
+
+ PSI_server->set_thread_THD(NULL, NULL);
+
+ ok(true, "all noop api called");
+}
+
+int main(int, char **)
+{
+ plan(34);
+
+ MY_INIT("pfs_noop-t");
+ test_noop();
+ return (exit_status());
+}
+
diff --git a/storage/perfschema/unittest/pfs_server_stubs.cc b/storage/perfschema/unittest/pfs_server_stubs.cc
new file mode 100644
index 00000000..5a855b2c
--- /dev/null
+++ b/storage/perfschema/unittest/pfs_server_stubs.cc
@@ -0,0 +1,63 @@
+/* Copyright (c) 2010, 2017, Oracle and/or its affiliates. All rights
+ reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/*
+ Minimal code to be able to link a unit test.
+*/
+
+#include "my_global.h"
+#include "m_ctype.h"
+#include "sql_class.h"
+#include "sql_show.h"
+
+struct system_status_var global_status_var;
+struct sql_digest_storage;
+
+uint lower_case_table_names= 0;
+CHARSET_INFO *files_charset_info= NULL;
+CHARSET_INFO *system_charset_info= NULL;
+
+void compute_digest_md5(const sql_digest_storage *, unsigned char *)
+{
+}
+
+void reset_status_vars()
+{
+}
+
+void sql_print_warning(const char *format, ...)
+{
+ /* Do not pollute the unit test output with annoying messages. */
+}
+
+class sys_var { public: enum where { AUTO }; };
+void set_sys_var_value_origin(void *ptr, enum sys_var::where here)
+{
+}
+
+enum sys_var::where get_sys_var_value_origin(void *ptr)
+{
+ return sys_var::AUTO;
+}
+
+MY_TIMER_INFO sys_timer_info;
diff --git a/storage/perfschema/unittest/pfs_timer-t.cc b/storage/perfschema/unittest/pfs_timer-t.cc
new file mode 100644
index 00000000..6c852242
--- /dev/null
+++ b/storage/perfschema/unittest/pfs_timer-t.cc
@@ -0,0 +1,128 @@
+/* Copyright (c) 2008, 2017, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#include <my_global.h>
+#include <my_pthread.h>
+#include <pfs_timer.h>
+#include "my_sys.h"
+#include <tap.h>
+
+void test_timers()
+{
+ ulonglong t1_a;
+ ulonglong t2_a;
+ ulonglong t3_a;
+ ulonglong t4_a;
+ ulonglong t5_a;
+ ulonglong t1_b;
+ ulonglong t2_b;
+ ulonglong t3_b;
+ ulonglong t4_b;
+ ulonglong t5_b;
+
+ my_timer_init(&sys_timer_info);
+
+ init_timers();
+
+ t1_a= get_timer_pico_value(TIMER_NAME_CYCLE);
+ /* Wait 5 seconds */
+ my_sleep(5000000);
+ t1_b= get_timer_pico_value(TIMER_NAME_CYCLE);
+
+ t2_a= get_timer_pico_value(TIMER_NAME_NANOSEC);
+ my_sleep(5000000);
+ t2_b= get_timer_pico_value(TIMER_NAME_NANOSEC);
+
+ t3_a= get_timer_pico_value(TIMER_NAME_MICROSEC);
+ my_sleep(5000000);
+ t3_b= get_timer_pico_value(TIMER_NAME_MICROSEC);
+
+ t4_a= get_timer_pico_value(TIMER_NAME_MILLISEC);
+ my_sleep(5000000);
+ t4_b= get_timer_pico_value(TIMER_NAME_MILLISEC);
+
+ t5_a= get_timer_pico_value(TIMER_NAME_TICK);
+ my_sleep(5000000);
+ t5_b= get_timer_pico_value(TIMER_NAME_TICK);
+
+ /*
+ Print the timer values, for manual inspection by a human.
+ Tests involving low level timers can not be automated.
+ */
+ diag("cycle a: %13llu", t1_a);
+ diag("nano a: %13llu", t2_a);
+ diag("micro a: %13llu", t3_a);
+ diag("milli a: %13llu", t4_a);
+ diag("tick a: %13llu", t5_a);
+
+ diag("cycle b: %13llu", t1_b);
+ diag("nano b: %13llu", t2_b);
+ diag("micro b: %13llu", t3_b);
+ diag("milli b: %13llu", t4_b);
+ diag("tick b: %13llu", t5_b);
+
+ diag("cycle b-a: %13llu", t1_b-t1_a);
+ diag("nano b-a: %13llu", t2_b-t2_a);
+ diag("micro b-a: %13llu", t3_b-t3_a);
+ diag("milli b-a: %13llu", t4_b-t4_a);
+ diag("tick b-a: %13llu", t5_b-t5_a);
+
+ if ((t1_a == 0) && (t1_b == 0))
+ skip(1, "cycle timer not implemented");
+ else
+ ok(t1_b > t1_a, "cycle timer ascending");
+
+ if ((t2_a == 0) && (t2_b == 0))
+ skip(1, "nano timer not implemented");
+ else
+ ok(t2_b > t2_a, "nano timer ascending");
+
+ if ((t3_a == 0) && (t3_b == 0))
+ skip(1, "micro timer not implemented");
+ else
+ ok(t3_b > t3_a, "micro timer ascending");
+
+ if ((t4_a == 0) && (t4_b == 0))
+ skip(1, "milli timer not implemented");
+ else
+ ok(t4_b > t4_a, "milli timer ascending");
+
+ if ((t5_a == 0) && (t5_b == 0))
+ skip(1, "tick timer not implemented");
+ else
+ ok(t5_b > t5_a, "tick timer ascending");
+}
+
+void do_all_tests()
+{
+ test_timers();
+}
+
+int main(int, char **)
+{
+ plan(5);
+ MY_INIT("pfs_timer-t");
+ do_all_tests();
+ my_end(0);
+ return (exit_status());
+}
+
diff --git a/storage/perfschema/unittest/pfs_user-oom-t.cc b/storage/perfschema/unittest/pfs_user-oom-t.cc
new file mode 100644
index 00000000..864275b7
--- /dev/null
+++ b/storage/perfschema/unittest/pfs_user-oom-t.cc
@@ -0,0 +1,146 @@
+/* Copyright (c) 2011, 2017, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#include <my_global.h>
+#include <my_thread.h>
+#include <pfs_instr.h>
+#include <pfs_stat.h>
+#include <pfs_global.h>
+#include <pfs_user.h>
+#include <pfs_buffer_container.h>
+#include <tap.h>
+
+#include "stub_pfs_global.h"
+#include "stub_global_status_var.h"
+
+#include <string.h> /* memset */
+
+void test_oom()
+{
+ PSI *psi;
+ PFS_global_param param;
+ PSI_bootstrap *boot;
+
+ memset(& param, 0xFF, sizeof(param));
+ param.m_enabled= true;
+ param.m_mutex_class_sizing= 0;
+ param.m_rwlock_class_sizing= 0;
+ param.m_cond_class_sizing= 0;
+ param.m_thread_class_sizing= 10;
+ param.m_table_share_sizing= 0;
+ param.m_file_class_sizing= 0;
+ param.m_socket_class_sizing= 0;
+ param.m_mutex_sizing= 0;
+ param.m_rwlock_sizing= 0;
+ param.m_cond_sizing= 0;
+ param.m_thread_sizing= 1000;
+ param.m_table_sizing= 0;
+ param.m_file_sizing= 0;
+ param.m_file_handle_sizing= 0;
+ param.m_socket_sizing= 0;
+ param.m_events_waits_history_sizing= 10;
+ param.m_events_waits_history_long_sizing= 0;
+ param.m_setup_actor_sizing= 0;
+ param.m_setup_object_sizing= 0;
+ param.m_host_sizing= 0;
+ param.m_user_sizing= 1000;
+ param.m_account_sizing= 0;
+ param.m_stage_class_sizing= 50;
+ param.m_events_stages_history_sizing= 0;
+ param.m_events_stages_history_long_sizing= 0;
+ param.m_statement_class_sizing= 50;
+ param.m_events_statements_history_sizing= 0;
+ param.m_events_statements_history_long_sizing= 0;
+ param.m_events_transactions_history_sizing= 0;
+ param.m_events_transactions_history_long_sizing= 0;
+ param.m_digest_sizing= 0;
+ param.m_session_connect_attrs_sizing= 0;
+ param.m_program_sizing= 0;
+ param.m_statement_stack_sizing= 0;
+ param.m_memory_class_sizing= 10;
+ param.m_metadata_lock_sizing= 0;
+ param.m_max_digest_length= 0;
+ param.m_max_sql_text_length= 0;
+
+ /* Setup */
+
+ stub_alloc_always_fails= false;
+ stub_alloc_fails_after_count= 1000;
+
+ pre_initialize_performance_schema();
+ boot= initialize_performance_schema(&param);
+ psi= (PSI *)boot->get_interface(PSI_VERSION_1);
+
+ PSI_thread_key thread_key_1;
+ PSI_thread_info all_thread[]=
+ {
+ {&thread_key_1, "T-1", 0}
+ };
+ psi->register_thread("test", all_thread, 1);
+
+ PSI_thread *thread_1= psi->new_thread(thread_key_1, NULL, 0);
+ psi->set_thread(thread_1);
+
+ /* Tests */
+
+ int first_fail= 1;
+ stub_alloc_fails_after_count= first_fail;
+ psi->set_thread_account("user1", 5, "", 0);
+ ok(global_user_container.m_lost == 1, "oom (user)");
+
+ stub_alloc_fails_after_count= first_fail + 1;
+ psi->set_thread_account("user2", 5, "", 0);
+ ok(global_user_container.m_lost == 2, "oom (user waits)");
+
+ stub_alloc_fails_after_count= first_fail + 2;
+ psi->set_thread_account("user3", 5, "", 0);
+ ok(global_user_container.m_lost == 3, "oom (user stages)");
+
+ stub_alloc_fails_after_count= first_fail + 3;
+ psi->set_thread_account("user4", 5, "", 0);
+ ok(global_user_container.m_lost == 4, "oom (user statements)");
+
+ stub_alloc_fails_after_count= first_fail + 4;
+ psi->set_thread_account("user5", 5, "", 0);
+ ok(global_user_container.m_lost == 5, "oom (user transactions)");
+
+ stub_alloc_fails_after_count= first_fail + 5;
+ psi->set_thread_account("user6", 5, "", 0);
+ ok(global_user_container.m_lost == 6, "oom (user memory)");
+
+ shutdown_performance_schema();
+}
+
+void do_all_tests()
+{
+ test_oom();
+}
+
+int main(int, char **)
+{
+ plan(6);
+ MY_INIT("pfs_user-oom-t");
+ do_all_tests();
+ my_end(0);
+ return (exit_status());
+}
+
diff --git a/storage/perfschema/unittest/stub_global_status_var.h b/storage/perfschema/unittest/stub_global_status_var.h
new file mode 100644
index 00000000..c870b863
--- /dev/null
+++ b/storage/perfschema/unittest/stub_global_status_var.h
@@ -0,0 +1,31 @@
+/* Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
+
+#include <my_global.h>
+#include <my_sys.h>
+#include <pfs_global.h>
+#include <string.h>
+
+
+void add_to_status(STATUS_VAR *to_var, STATUS_VAR *from_var)
+{
+}
diff --git a/storage/perfschema/unittest/stub_pfs_defaults.h b/storage/perfschema/unittest/stub_pfs_defaults.h
new file mode 100644
index 00000000..95150873
--- /dev/null
+++ b/storage/perfschema/unittest/stub_pfs_defaults.h
@@ -0,0 +1,30 @@
+/* Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#include <my_global.h>
+#include <pfs.h>
+#include <pfs_defaults.h>
+
+void install_default_setup(PSI_bootstrap *)
+{
+}
+
diff --git a/storage/perfschema/unittest/stub_pfs_global.h b/storage/perfschema/unittest/stub_pfs_global.h
new file mode 100644
index 00000000..23b731cb
--- /dev/null
+++ b/storage/perfschema/unittest/stub_pfs_global.h
@@ -0,0 +1,89 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#include <my_global.h>
+#include <my_sys.h>
+#include <pfs_global.h>
+#include <string.h>
+
+bool pfs_initialized= false;
+size_t pfs_allocated_memory_size= 0;
+size_t pfs_allocated_memory_count= 0;
+
+bool stub_alloc_always_fails= true;
+int stub_alloc_fails_after_count= 0;
+
+void *pfs_malloc(PFS_builtin_memory_class *klass, size_t size, myf)
+{
+ /*
+ Catch non initialized sizing parameter in the unit tests.
+ */
+ DBUG_ASSERT(size <= 100*1024*1024);
+
+ if (stub_alloc_always_fails)
+ return NULL;
+
+ if (--stub_alloc_fails_after_count <= 0)
+ return NULL;
+
+ void *ptr= malloc(size);
+ if (ptr != NULL)
+ memset(ptr, 0, size);
+ return ptr;
+}
+
+void pfs_free(PFS_builtin_memory_class *, size_t, void *ptr)
+{
+ if (ptr != NULL)
+ free(ptr);
+}
+
+void *pfs_malloc_array(PFS_builtin_memory_class *klass, size_t n, size_t size, myf flags)
+{
+ size_t array_size= n * size;
+ /* Check for overflow before allocating. */
+ if (is_overflow(array_size, n, size))
+ return NULL;
+ return pfs_malloc(klass, array_size, flags);
+}
+
+void pfs_free_array(PFS_builtin_memory_class *klass, size_t n, size_t size, void *ptr)
+{
+ if (ptr == NULL)
+ return;
+ size_t array_size= n * size;
+ return pfs_free(klass, array_size, ptr);
+}
+
+bool is_overflow(size_t product, size_t n1, size_t n2)
+{
+ if (n1 != 0 && (product / n1 != n2))
+ return true;
+ else
+ return false;
+}
+
+void pfs_print_error(const char *format, ...)
+{
+}
+
+
diff --git a/storage/perfschema/unittest/stub_print_error.h b/storage/perfschema/unittest/stub_print_error.h
new file mode 100644
index 00000000..8d87fbe5
--- /dev/null
+++ b/storage/perfschema/unittest/stub_print_error.h
@@ -0,0 +1,72 @@
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License, version 2.0,
+ as published by the Free Software Foundation.
+
+ This program is also distributed with certain software (including
+ but not limited to OpenSSL) that is licensed under separate terms,
+ as designated in a particular file or component or in included license
+ documentation. The authors of MySQL hereby grant you an additional
+ permission to link the program and your derivative works with the
+ separately licensed software that they have included with MySQL.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License, version 2.0, for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
+
+#include <my_global.h>
+#include <my_sys.h>
+#include <pfs_global.h>
+
+bool pfs_initialized= false;
+
+void *pfs_malloc(PFS_builtin_memory_class *klass, size_t size, myf flags)
+{
+ void *ptr= malloc(size);
+ if (ptr && (flags & MY_ZEROFILL))
+ memset(ptr, 0, size);
+ return ptr;
+}
+
+void pfs_free(PFS_builtin_memory_class *, size_t, void *ptr)
+{
+ if (ptr != NULL)
+ free(ptr);
+}
+
+void *pfs_malloc_array(PFS_builtin_memory_class *klass, size_t n, size_t size, myf flags)
+{
+ size_t array_size= n * size;
+ /* Check for overflow before allocating. */
+ if (is_overflow(array_size, n, size))
+ return NULL;
+ return pfs_malloc(klass, array_size, flags);
+}
+
+void pfs_free_array(PFS_builtin_memory_class *klass, size_t n, size_t size, void *ptr)
+{
+ if (ptr == NULL)
+ return;
+ size_t array_size= n * size;
+ return pfs_free(klass, array_size, ptr);
+}
+
+bool is_overflow(size_t product, size_t n1, size_t n2)
+{
+ if (n1 != 0 && (product / n1 != n2))
+ return true;
+ else
+ return false;
+}
+
+void pfs_print_error(const char *format, ...)
+{
+ /* Do not pollute the unit test output with annoying messages. */
+}
+