← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/signal_handler.cc

  • Committer: Patrick Crews
  • Date: 2010-08-17 16:41:12 UTC
  • mfrom: (1711.6.2 staging)
  • mto: This revision was merged to the branch mainline in revision 1714.
  • Revision ID: gleebix@gmail.com-20100817164112-vaa55iprokbg6m1k
Merge Brian's recursive mutex removal tree

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/signal_handler.cc
24
24
#include "drizzled/signal_handler.h"
25
25
#include "drizzled/drizzled.h"
26
26
#include "drizzled/session.h"
27
 
#include "drizzled/session/cache.h"
28
27
#include "drizzled/internal/my_sys.h"
29
28
#include "drizzled/probes.h"
30
29
#include "drizzled/plugin.h"
31
30
#include "drizzled/plugin/scheduler.h"
32
 
 
33
 
#include "drizzled/util/backtrace.h"
 
31
#include "plugin/myisam/keycache.h"
34
32
 
35
33
using namespace drizzled;
36
34
 
49
47
void drizzled_print_signal_warning(int sig)
50
48
{
51
49
  if (global_system_variables.log_warnings)
52
 
    errmsg_printf(ERRMSG_LVL_WARN, _("Got signal %d from thread %"PRIu32),
 
50
    errmsg_printf(ERRMSG_LVL_WARN, _("Got signal %d from thread %"PRIu64),
53
51
                  sig, global_thread_id);
54
52
#ifndef HAVE_BSD_SIGNALS
55
53
  sigset_t set;
68
66
/** Called when a thread is aborted. */
69
67
void drizzled_end_thread_signal(int )
70
68
{
71
 
  Session *session= current_session;
 
69
  Session *session=current_session;
72
70
  if (session)
73
71
  {
74
 
    Session::shared_ptr session_ptr(session::Cache::singleton().find(session->getSessionId()));
75
 
    if (not session_ptr) // We need to make we have a lock on session before we do anything with it.
76
 
      return;
77
 
 
78
72
    killed_threads++;
79
 
 
80
 
    // We need to get the ID before we kill off the session
81
 
    session_ptr->scheduler->killSessionNow(session_ptr);
82
 
    DRIZZLE_CONNECTION_DONE(session_ptr->getSessionId());
 
73
    session->scheduler->killSessionNow(session);
 
74
    DRIZZLE_CONNECTION_DONE(session->thread_id);
83
75
  }
84
 
}
85
 
 
86
 
static void write_core(int sig)
87
 
{
88
 
  signal(sig, SIG_DFL);
89
 
#ifdef HAVE_gcov
90
 
  /*
91
 
    For GCOV build, crashing will prevent the writing of code coverage
92
 
    information from this process, causing gcov output to be incomplete.
93
 
    So we force the writing of coverage information here before terminating.
94
 
  */
95
 
  extern void __gcov_flush(void);
96
 
  __gcov_flush();
97
 
#endif
98
 
  pthread_kill(pthread_self(), sig);
99
 
#if defined(P_MYID) && !defined(SCO)
100
 
  /* On Solaris, the above kill is not enough */
101
 
  sigsend(P_PID,P_MYID,sig);
102
 
#endif
 
76
  return;
103
77
}
104
78
 
105
79
void drizzled_handle_segfault(int sig)
146
120
  fprintf(stderr, "max_used_connections=%"PRIu64"\n", current_global_counters.max_used_connections);
147
121
  fprintf(stderr, "connection_count=%u\n", uint32_t(connection_count));
148
122
  fprintf(stderr, _("It is possible that drizzled could use up to \n"
149
 
                    "(read_buffer_size + sort_buffer_size)*thread_count\n"
 
123
                    "key_buffer_size + (read_buffer_size + "
 
124
                    "sort_buffer_size)*thread_count\n"
150
125
                    "bytes of memory\n"
151
126
                    "Hope that's ok; if not, decrease some variables in the "
152
127
                    "equation.\n\n"));
153
128
 
154
 
  drizzled::util::custom_backtrace();
155
 
 
156
 
  write_core(sig);
 
129
#ifdef HAVE_STACKTRACE
 
130
  Session *session= current_session;
 
131
 
 
132
  if (! (test_flags.test(TEST_NO_STACKTRACE)))
 
133
  {
 
134
    fprintf(stderr,"session: 0x%lx\n",(long) session);
 
135
    fprintf(stderr,_("Attempting backtrace. You can use the following "
 
136
                     "information to find out\n"
 
137
                     "where drizzled died. If you see no messages after this, "
 
138
                     "something went\n"
 
139
                     "terribly wrong...\n"));
 
140
    print_stacktrace(session ? (unsigned char*) session->thread_stack : (unsigned char*) 0,
 
141
                     my_thread_stack_size);
 
142
  }
 
143
  if (session)
 
144
  {
 
145
    const char *kreason= "UNKNOWN";
 
146
    switch (session->killed) {
 
147
    case Session::NOT_KILLED:
 
148
      kreason= "NOT_KILLED";
 
149
      break;
 
150
    case Session::KILL_BAD_DATA:
 
151
      kreason= "KILL_BAD_DATA";
 
152
      break;
 
153
    case Session::KILL_CONNECTION:
 
154
      kreason= "KILL_CONNECTION";
 
155
      break;
 
156
    case Session::KILL_QUERY:
 
157
      kreason= "KILL_QUERY";
 
158
      break;
 
159
    case Session::KILLED_NO_VALUE:
 
160
      kreason= "KILLED_NO_VALUE";
 
161
      break;
 
162
    }
 
163
    fprintf(stderr, _("Trying to get some variables.\n"
 
164
                      "Some pointers may be invalid and cause the "
 
165
                      "dump to abort...\n"));
 
166
    safe_print_str("session->query", session->query, 1024);
 
167
    fprintf(stderr, "session->thread_id=%"PRIu32"\n", (uint32_t) session->thread_id);
 
168
    fprintf(stderr, "session->killed=%s\n", kreason);
 
169
  }
 
170
  fflush(stderr);
 
171
#endif /* HAVE_STACKTRACE */
 
172
 
 
173
  if (calling_initgroups)
 
174
    fprintf(stderr, _("\nThis crash occurred while the server was calling "
 
175
                      "initgroups(). This is\n"
 
176
                      "often due to the use of a drizzled that is statically "
 
177
                      "linked against glibc\n"
 
178
                      "and configured to use LDAP in /etc/nsswitch.conf. "
 
179
                      "You will need to either\n"
 
180
                      "upgrade to a version of glibc that does not have this "
 
181
                      "problem (2.3.4 or\n"
 
182
                      "later when used with nscd), disable LDAP in your "
 
183
                      "nsswitch.conf, or use a\n"
 
184
                      "drizzled that is not statically linked.\n"));
 
185
 
 
186
  if (internal::thd_lib_detected == THD_LIB_LT && !getenv("LD_ASSUME_KERNEL"))
 
187
    fprintf(stderr,
 
188
            _("\nYou are running a statically-linked LinuxThreads binary "
 
189
              "on an NPTL system.\n"
 
190
              "This can result in crashes on some distributions due "
 
191
              "to LT/NPTL conflicts.\n"
 
192
              "You should either build a dynamically-linked binary, or force "
 
193
              "LinuxThreads\n"
 
194
              "to be used with the LD_ASSUME_KERNEL environment variable. "
 
195
              "Please consult\n"
 
196
              "the documentation for your distribution on how to do that.\n"));
 
197
 
 
198
#ifdef HAVE_WRITE_CORE
 
199
  if (test_flags.test(TEST_CORE_ON_SIGNAL))
 
200
  {
 
201
    fprintf(stderr, _("Writing a core file\n"));
 
202
    fflush(stderr);
 
203
    write_core(sig);
 
204
  }
 
205
#endif
157
206
 
158
207
  exit(1);
159
208
}