Adding upstream version 1:10.6.11.upstream/1%10.6.11upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 493 insertions, 0 deletions

diff --git a/storage/perfschema/table_sync_instances.cc b/storage/perfschema/table_sync_instances.cc
new file mode 100644
index 00000000..5f2c7091
--- /dev/null
+++ b/storage/perfschema/table_sync_instances.cc
@@ -0,0 +1,493 @@
+/* Copyright (c) 2008, 2022, 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 */
+
+/**
+  @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_state
+table_mutex_instances::m_share_state = {
+  false /* m_checked */
+};
+
+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 comment 'Instrument name associated with the mutex.',"
+                      "OBJECT_INSTANCE_BEGIN BIGINT unsigned not null comment 'Memory address of the instrumented mutex.',"
+                      "LOCKED_BY_THREAD_ID BIGINT unsigned comment 'The THREAD_ID of the locking thread if a thread has a mutex locked, otherwise NULL.')") },
+  false, /* m_perpetual */
+  false, /* m_optional */
+  &m_share_state
+};
+
+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 */
+  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:
+        assert(false);
+      }
+    }
+  }
+
+  return 0;
+}
+
+THR_LOCK table_rwlock_instances::m_table_lock;
+
+PFS_engine_table_share_state
+table_rwlock_instances::m_share_state = {
+  false /* m_checked */
+};
+
+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 comment 'Instrument name associated with the read write lock',"
+                      "OBJECT_INSTANCE_BEGIN BIGINT unsigned not null comment 'Address in memory of the instrumented lock',"
+                      "WRITE_LOCKED_BY_THREAD_ID BIGINT unsigned comment 'THREAD_ID of the locking thread if locked in write (exclusive) mode, otherwise NULL.',"
+                      "READ_LOCKED_BY_COUNT INTEGER unsigned not null comment 'Count of current read locks held')") },
+  false, /* m_perpetual */
+  false, /* m_optional */
+  &m_share_state
+};
+
+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 */
+  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:
+        assert(false);
+      }
+    }
+  }
+
+  return 0;
+}
+
+THR_LOCK table_cond_instances::m_table_lock;
+
+PFS_engine_table_share_state
+table_cond_instances::m_share_state = {
+  false /* m_checked */
+};
+
+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 comment 'Client user name for the connection, or NULL if an internal thread.',"
+                      "OBJECT_INSTANCE_BEGIN BIGINT unsigned not null comment 'Address in memory of the instrumented condition.')") },
+  false, /* m_perpetual */
+  false, /* m_optional */
+  &m_share_state
+};
+
+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 */
+  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:
+        assert(false);
+      }
+    }
+  }
+
+  return 0;
+}
+