Drizzled Public API Documentation

signal_handler.cc
1 /* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2  * vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3  *
4  * Copyright (C) 2008 Sun Microsystems, Inc.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; version 2 of the License.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
18  */
19 
20 #include <config.h>
21 
22 #include <signal.h>
23 
24 #include <drizzled/signal_handler.h>
25 #include <drizzled/drizzled.h>
26 #include <drizzled/session.h>
27 #include <drizzled/session/cache.h>
28 #include <drizzled/internal/my_sys.h>
29 #include <drizzled/probes.h>
30 #include <drizzled/plugin.h>
31 #include <drizzled/plugin/scheduler.h>
32 #include <drizzled/current_session.h>
33 #include <drizzled/util/backtrace.h>
34 #include <drizzled/statistics_variables.h>
35 #include <drizzled/system_variables.h>
36 
37 #define DRIZZLE_UNIX_SOCKET_PATH "/tmp/mysql.socket"
38 
39 using namespace drizzled;
40 namespace fs= boost::filesystem;
41 
42 static uint32_t killed_threads;
43 static bool segfaulted= false;
44 
45 /*
46  * We declare these extern "C" because they are passed to system callback functions
47  * and Sun Studio does not like it when those don't have C linkage. We prefix them
48  * because extern "C"-ing something effectively removes the namespace from the
49  * linker symbols, meaning they would be exporting symbols like "print_signal_warning
50  */
51 extern "C"
52 {
53 
54 void drizzled_sigint_handler(int sig){
55  struct sigaction sa;
56  switch(sig){
57  case SIGINT:{
58  if (fs::exists(DRIZZLE_UNIX_SOCKET_PATH))
59  {
60  fs::remove(DRIZZLE_UNIX_SOCKET_PATH);
61  }
62  sa.sa_handler=SIG_DFL;
63  sigaction(SIGINT, &sa, NULL);
64  pthread_kill(pthread_self(),SIGINT);
65  break;
66  }
67  }
68 }
69 
70 void drizzled_print_signal_warning(int sig)
71 {
72  if (global_system_variables.log_warnings)
73  errmsg_printf(error::WARN, _("Got signal %d from thread %"PRIu32),
74  sig, global_thread_id);
75 #ifndef HAVE_BSD_SIGNALS
76  sigset_t set;
77  sigemptyset(&set);
78 
79  struct sigaction sa;
80  sa.sa_handler= drizzled_print_signal_warning;
81  sa.sa_mask= set;
82  sa.sa_flags= 0;
83  sigaction(sig, &sa, NULL); /* int. thread system calls */
84 #endif
85  if (sig == SIGALRM)
86  alarm(2); /* reschedule alarm */
87 }
88 
90 void drizzled_end_thread_signal(int )
91 {
92  Session *session= current_session;
93  if (session)
94  {
95  Session::shared_ptr session_ptr(session::Cache::find(session->getSessionId()));
96  if (not session_ptr) // We need to make we have a lock on session before we do anything with it.
97  return;
98 
99  killed_threads++;
100 
101  // We need to get the ID before we kill off the session
102  session_ptr->scheduler->killSessionNow(session_ptr);
103  DRIZZLE_CONNECTION_DONE(session_ptr->getSessionId());
104  }
105 }
106 
107 static void write_core(int sig)
108 {
109  signal(sig, SIG_DFL);
110 #ifdef HAVE_gcov
111  /*
112  For GCOV build, crashing will prevent the writing of code coverage
113  information from this process, causing gcov output to be incomplete.
114  So we force the writing of coverage information here before terminating.
115  */
116  extern void __gcov_flush(void);
117  __gcov_flush();
118 #endif
119  pthread_kill(pthread_self(), sig);
120 #if defined(P_MYID) && !defined(SCO)
121  /* On Solaris, the above kill is not enough */
122  sigsend(P_PID,P_MYID,sig);
123 #endif
124 }
125 
126 void drizzled_handle_segfault(int sig)
127 {
128  time_t curr_time;
129  struct tm tm;
130 
131  /*
132  Strictly speaking, one needs a mutex here
133  but since we have got SIGSEGV already, things are a mess
134  so not having the mutex is not as bad as possibly using a buggy
135  mutex - so we keep things simple
136  */
137  if (segfaulted)
138  {
139  fprintf(stderr, _("Fatal signal %d while backtracing\n"), sig);
140  exit(1);
141  }
142 
143  segfaulted= true;
144 
145  curr_time= time(NULL);
146  if(curr_time == (time_t)-1)
147  {
148  fprintf(stderr, _("Fatal: time() call failed\n"));
149  exit(1);
150  }
151 
152  localtime_r(&curr_time, &tm);
153 
154  fprintf(stderr,_("%02d%02d%02d %2d:%02d:%02d - drizzled got signal %d;\n"
155  "This could be because you hit a bug. It is also possible that "
156  "this binary\n or one of the libraries it was linked against is "
157  "corrupt, improperly built,\n or misconfigured. This error can "
158  "also be caused by malfunctioning hardware.\n"),
159  tm.tm_year % 100, tm.tm_mon+1, tm.tm_mday,
160  tm.tm_hour, tm.tm_min, tm.tm_sec,
161  sig);
162  fprintf(stderr, _("We will try our best to scrape up some info that "
163  "will hopefully help diagnose\n"
164  "the problem, but since we have already crashed, "
165  "something is definitely wrong\nand this may fail.\n\n"));
166  fprintf(stderr, "read_buffer_size=%ld\n", (long) global_system_variables.read_buff_size);
167  fprintf(stderr, "max_used_connections=%"PRIu64"\n", current_global_counters.max_used_connections);
168  fprintf(stderr, "connection_count=%u\n", uint32_t(connection_count));
169  fprintf(stderr, _("It is possible that drizzled could use up to \n"
170  "(read_buffer_size + sort_buffer_size)*thread_count\n"
171  "bytes of memory\n"
172  "Hope that's ok; if not, decrease some variables in the "
173  "equation.\n\n"));
174 
175  call_backtrace();
176 
177  write_core(sig);
178 
179  exit(1);
180 }
181 
182 } /* extern "C" */
session_id_t getSessionId() const
Definition: session.h:644