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

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

1 files changed, 295 insertions, 0 deletions

diff --git a/storage/perfschema/table_session_connect.cc b/storage/perfschema/table_session_connect.cc
new file mode 100644
index 00000000..54511e1b
--- /dev/null
+++ b/storage/perfschema/table_session_connect.cc
@@ -0,0 +1,295 @@
+/* Copyright (c) 2008, 2023, 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 */
+
+#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 */
+  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:
+        assert(false);
+      }
+    }
+  }
+  return 0;
+}
+
+bool
+table_session_connect::thread_fits(PFS_thread *thread)
+{
+  return true;
+}
+