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, 373 insertions, 0 deletions

diff --git a/sql/signal_handler.cc b/sql/signal_handler.cc
new file mode 100644
index 00000000..534a9a1c
--- /dev/null
+++ b/sql/signal_handler.cc
@@ -0,0 +1,373 @@
+/* Copyright (c) 2011, 2012, Oracle and/or its affiliates.
+   Copyright (c) 2011, 2021, MariaDB Corporation.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; version 2 of the License.
+
+   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 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 "mariadb.h"
+#include "my_dbug.h"
+#include <signal.h>
+
+//#include "sys_vars.h"
+#include <keycache.h>
+#include "mysqld.h"
+#include "sql_class.h"
+#include "my_stacktrace.h"
+#include <source_revision.h>
+
+#ifdef _WIN32
+#include <crtdbg.h>
+#include <direct.h>
+#define SIGNAL_FMT "exception 0x%x"
+#else
+#define SIGNAL_FMT "signal %d"
+#endif
+
+
+#if defined(__APPLE__) || defined(__FreeBSD__)
+#include <sys/sysctl.h>
+#endif
+
+#ifndef PATH_MAX
+#define PATH_MAX 4096
+#endif
+
+/*
+  We are handling signals/exceptions in this file.
+  Any global variables we read should be 'volatile sig_atomic_t'
+  to guarantee that we read some consistent value.
+ */
+static volatile sig_atomic_t segfaulted= 0;
+extern ulong max_used_connections;
+extern volatile sig_atomic_t calling_initgroups;
+
+extern const char *optimizer_switch_names[];
+
+static inline void output_core_info()
+{
+  /* proc is optional on some BSDs so it can't hurt to look */
+#if defined(HAVE_READLINK) && !defined(__APPLE__) && !defined(__FreeBSD__)
+  char buff[PATH_MAX];
+  ssize_t len;
+  int fd;
+  if ((len= readlink("/proc/self/cwd", buff, sizeof(buff)-1)) >= 0)
+  {
+    buff[len]= 0;
+    my_safe_printf_stderr("Writing a core file...\nWorking directory at %.*s\n",
+                          (int) len, buff);
+  }
+#ifdef __FreeBSD__
+  if ((fd= open("/proc/curproc/rlimit", O_RDONLY)) >= 0)
+#else
+  if ((fd= open("/proc/self/limits", O_RDONLY)) >= 0)
+#endif
+  {
+    my_safe_printf_stderr("Resource Limits:\n");
+    while ((len= read(fd, (uchar*)buff, sizeof(buff))) > 0)
+    {
+      my_write_stderr(buff, len);
+    }
+    close(fd);
+  }
+#ifdef __linux__
+  if ((fd= open("/proc/sys/kernel/core_pattern", O_RDONLY)) >= 0)
+  {
+    len= read(fd, (uchar*)buff, sizeof(buff));
+    my_safe_printf_stderr("Core pattern: %.*s\n", (int) len, buff);
+    close(fd);
+  }
+  if ((fd= open("/proc/version", O_RDONLY)) >= 0)
+  {
+    len= read(fd, (uchar*)buff, sizeof(buff));
+    my_safe_printf_stderr("Kernel version: %.*s\n", (int) len, buff);
+    close(fd);
+  }
+#endif
+#elif defined(__APPLE__) || defined(__FreeBSD__)
+  char buff[PATH_MAX];
+  size_t len = sizeof(buff);
+  if (sysctlbyname("kern.corefile", buff, &len, NULL, 0) == 0)
+  {
+    my_safe_printf_stderr("Core pattern: %.*s\n", (int) len, buff);
+  }
+  if (sysctlbyname("kern.version", buff, &len, NULL, 0) == 0)
+  {
+    my_safe_printf_stderr("Kernel version: %.*s\n", (int) len, buff);
+  }
+#elif defined(HAVE_GETCWD)
+  char buff[80];
+
+  if (getcwd(buff, sizeof(buff)))
+  {
+    my_safe_printf_stderr("Writing a core file at %.*s\n", (int) sizeof(buff), buff);
+    fflush(stderr);
+  }
+#endif
+}
+
+/**
+ * Handler for fatal signals on POSIX, exception handler on Windows.
+ *
+ * Fatal events (seg.fault, bus error etc.) will trigger
+ * this signal handler.  The handler will try to dump relevant
+ * debugging information to stderr and dump a core image.
+ *
+ * POSIX : Signal handlers should, if possible, only use a set of 'safe' system 
+ * calls and library functions.  A list of safe calls in POSIX systems
+ * are available at:
+ *  http://pubs.opengroup.org/onlinepubs/009695399/functions/xsh_chap02_04.html
+ *
+ * @param sig Signal number /Exception code
+*/
+extern "C" sig_handler handle_fatal_signal(int sig)
+{
+  time_t curr_time;
+  struct tm tm;
+#ifdef HAVE_STACKTRACE
+  THD *thd;
+  /*
+     This flag remembers if the query pointer was found invalid.
+     We will try and print the query at the end of the signal handler, in case
+     we're wrong.
+  */
+  bool print_invalid_query_pointer= false;
+#endif
+
+  if (segfaulted)
+  {
+    my_safe_printf_stderr("Fatal " SIGNAL_FMT " while backtracing\n", sig);
+    goto end;
+  }
+  segfaulted = 1;
+  DBUG_PRINT("error", ("handling fatal signal"));
+
+  curr_time= my_time(0);
+  localtime_r(&curr_time, &tm);
+
+  my_safe_printf_stderr("%02d%02d%02d %2d:%02d:%02d ",
+                        tm.tm_year % 100, tm.tm_mon+1, tm.tm_mday,
+                        tm.tm_hour, tm.tm_min, tm.tm_sec);
+  if (opt_expect_abort
+#ifdef _WIN32
+    && sig == (int)EXCEPTION_BREAKPOINT /* __debugbreak in my_sigabrt_hander() */
+#else
+    && sig == SIGABRT
+#endif
+    )
+  {
+    fprintf(stderr,"[Note] mysqld did an expected abort\n");
+    goto end;
+  }
+
+  my_safe_printf_stderr("[ERROR] mysqld got " SIGNAL_FMT " ;\n",sig);
+
+  my_safe_printf_stderr("%s",
+                        "Sorry, we probably made a mistake, and this is a bug.\n\n"
+                        "Your assistance in bug reporting will enable us to fix this for the next release.\n"
+                        "To report this bug, see https://mariadb.com/kb/en/reporting-bugs\n\n");
+
+  my_safe_printf_stderr("%s",
+    "We will try our best to scrape up some info that will hopefully help\n"
+    "diagnose the problem, but since we have already crashed, \n"
+    "something is definitely wrong and this may fail.\n\n");
+
+  set_server_version(server_version, sizeof(server_version));
+  my_safe_printf_stderr("Server version: %s source revision: %s\n",
+		        server_version, SOURCE_REVISION);
+
+  if (dflt_key_cache)
+    my_safe_printf_stderr("key_buffer_size=%zu\n",
+                          dflt_key_cache->key_cache_mem_size);
+
+  my_safe_printf_stderr("read_buffer_size=%lu\n",
+                        global_system_variables.read_buff_size);
+
+  my_safe_printf_stderr("max_used_connections=%lu\n",
+                        max_used_connections);
+
+  if (thread_scheduler)
+    my_safe_printf_stderr("max_threads=%lu\n",
+                          thread_scheduler->max_threads +
+                          extra_max_connections);
+
+  my_safe_printf_stderr("thread_count=%u\n", THD_count::value());
+
+  if (dflt_key_cache && thread_scheduler)
+  {
+    size_t used_mem=
+        (dflt_key_cache->key_cache_mem_size +
+         (global_system_variables.read_buff_size +
+          (size_t) global_system_variables.sortbuff_size) *
+             (thread_scheduler->max_threads + extra_max_connections) +
+         (max_connections + extra_max_connections) * sizeof(THD)) / 1024;
+
+    my_safe_printf_stderr("It is possible that mysqld could use up to \n"
+                          "key_buffer_size + "
+                          "(read_buffer_size + sort_buffer_size)*max_threads = "
+                          "%zu K  bytes of memory\n", used_mem);
+
+    my_safe_printf_stderr("%s",
+                          "Hope that's ok; if not, decrease some variables in "
+                          "the equation.\n\n");
+  }
+
+#ifdef HAVE_STACKTRACE
+  thd= current_thd;
+
+  if (opt_stack_trace)
+  {
+    my_safe_printf_stderr("Thread pointer: %p\n", thd);
+    my_safe_printf_stderr("%s",
+      "Attempting backtrace. You can use the following "
+      "information to find out\n"
+      "where mysqld died. If you see no messages after this, something went\n"
+      "terribly wrong...\n");
+    my_print_stacktrace(thd ? (uchar*) thd->thread_stack : NULL,
+                        (ulong)my_thread_stack_size, 0);
+  }
+  if (thd)
+  {
+    const char *kreason= "UNKNOWN";
+    switch (thd->killed) {
+    case NOT_KILLED:
+    case KILL_HARD_BIT:
+      kreason= "NOT_KILLED";
+      break;
+    case KILL_BAD_DATA:
+    case KILL_BAD_DATA_HARD:
+      kreason= "KILL_BAD_DATA";
+      break;
+    case KILL_CONNECTION:
+    case KILL_CONNECTION_HARD:
+      kreason= "KILL_CONNECTION";
+      break;
+    case KILL_QUERY:
+    case KILL_QUERY_HARD:
+      kreason= "KILL_QUERY";
+      break;
+    case KILL_TIMEOUT:
+    case KILL_TIMEOUT_HARD:
+      kreason= "KILL_TIMEOUT";
+      break;
+    case KILL_SYSTEM_THREAD:
+    case KILL_SYSTEM_THREAD_HARD:
+      kreason= "KILL_SYSTEM_THREAD";
+      break;
+    case KILL_SERVER:
+    case KILL_SERVER_HARD:
+      kreason= "KILL_SERVER";
+      break;
+    case ABORT_QUERY:
+    case ABORT_QUERY_HARD:
+      kreason= "ABORT_QUERY";
+      break;
+    case KILL_SLAVE_SAME_ID:
+      kreason= "KILL_SLAVE_SAME_ID";
+      break;
+    case KILL_WAIT_TIMEOUT:
+    case KILL_WAIT_TIMEOUT_HARD:
+      kreason= "KILL_WAIT_TIMEOUT";
+      break;
+    }
+    my_safe_printf_stderr("%s", "\n"
+      "Trying to get some variables.\n"
+      "Some pointers may be invalid and cause the dump to abort.\n");
+
+    my_safe_printf_stderr("Query (%p): ", thd->query());
+    if (my_safe_print_str(thd->query(), MY_MIN(65536U, thd->query_length())))
+    {
+      // Query was found invalid. We will try to print it at the end.
+      print_invalid_query_pointer= true;
+    }
+
+    my_safe_printf_stderr("\nConnection ID (thread ID): %lu\n",
+                          (ulong) thd->thread_id);
+    my_safe_printf_stderr("Status: %s\n\n", kreason);
+    my_safe_printf_stderr("%s", "Optimizer switch: ");
+    ulonglong optsw= thd->variables.optimizer_switch;
+    for (uint i= 0; optimizer_switch_names[i+1]; i++, optsw >>= 1)
+    {
+      if (i)
+        my_safe_printf_stderr("%s", ",");
+      my_safe_printf_stderr("%s=%s",
+              optimizer_switch_names[i], optsw & 1 ? "on" : "off");
+    }
+    my_safe_printf_stderr("%s", "\n\n");
+  }
+  my_safe_printf_stderr("%s",
+    "The manual page at "
+    "https://mariadb.com/kb/en/how-to-produce-a-full-stack-trace-for-mariadbd/ contains\n"
+    "information that should help you find out what is causing the crash.\n");
+
+#endif /* HAVE_STACKTRACE */
+
+#ifdef HAVE_INITGROUPS
+  if (calling_initgroups)
+  {
+    my_safe_printf_stderr("%s", "\n"
+      "This crash occurred while the server was calling initgroups(). This is\n"
+      "often due to the use of a mysqld that is statically linked against \n"
+      "glibc and configured to use LDAP in /etc/nsswitch.conf.\n"
+      "You will need to either upgrade to a version of glibc that does not\n"
+      "have this problem (2.3.4 or later when used with nscd),\n"
+      "disable LDAP in your nsswitch.conf, or use a "
+      "mysqld that is not statically linked.\n");
+  }
+#endif
+
+  if (locked_in_memory)
+  {
+    my_safe_printf_stderr("%s", "\n"
+      "The \"--memlock\" argument, which was enabled, "
+      "uses system calls that are\n"
+      "unreliable and unstable on some operating systems and "
+      "operating-system versions (notably, some versions of Linux).\n"
+      "This crash could be due to use of those buggy OS calls.\n"
+      "You should consider whether you really need the "
+      "\"--memlock\" parameter and/or consult the OS distributer about "
+      "\"mlockall\" bugs.\n");
+  }
+
+#ifdef HAVE_STACKTRACE
+  if (print_invalid_query_pointer)
+  {
+    my_safe_printf_stderr(
+        "\nWe think the query pointer is invalid, but we will try "
+        "to print it anyway. \n"
+        "Query: ");
+    my_write_stderr(thd->query(), MY_MIN(65536U, thd->query_length()));
+    my_safe_printf_stderr("\n\n");
+  }
+#endif
+
+  output_core_info();
+#ifdef HAVE_WRITE_CORE
+  if (test_flags & TEST_CORE_ON_SIGNAL)
+  {
+    my_write_core(sig);
+  }
+#endif
+
+end:
+#ifndef _WIN32
+  /*
+     Quit, without running destructors (etc.)
+     Use a signal, because the parent (systemd) can check that with WIFSIGNALED
+     On Windows, do not terminate, but pass control to exception filter.
+  */
+  signal(sig, SIG_DFL);
+  kill(getpid(), sig);
+#else
+  return;
+#endif
+}