1 // Copyright (c) 2008, Google Inc.
2 // All rights reserved.
4 // Redistribution and use in source and binary forms, with or without
5 // modification, are permitted provided that the following conditions are
8 // * Redistributions of source code must retain the above copyright
9 // notice, this list of conditions and the following disclaimer.
10 // * Redistributions in binary form must reproduce the above
11 // copyright notice, this list of conditions and the following disclaimer
12 // in the documentation and/or other materials provided with the
14 // * Neither the name of Google Inc. nor the names of its
15 // contributors may be used to endorse or promote products derived from
16 // this software without specific prior written permission.
18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 // Author: Satoru Takabayashi
32 // Implementation of InstallFailureSignalHandler().
34 #include "utilities.h"
35 #include "stacktrace.h"
36 #include "symbolize.h"
37 #include "glog/logging.h"
41 #ifdef HAVE_UCONTEXT_H
42 # include <ucontext.h>
44 #ifdef HAVE_SYS_UCONTEXT_H
45 # include <sys/ucontext.h>
49 _START_GOOGLE_NAMESPACE_
53 // We'll install the failure signal handler for these signals. We could
54 // use strsignal() to get signal names, but we don't use it to avoid
55 // introducing yet another #ifdef complication.
57 // The list should be synced with the comment in signalhandler.h.
61 } kFailureSignals[] = {
62 { SIGSEGV, "SIGSEGV" },
65 { SIGABRT, "SIGABRT" },
67 { SIGTERM, "SIGTERM" },
70 // Returns the program counter from signal context, NULL if unknown.
71 void* GetPC(void* ucontext_in_void) {
72 #if (defined(HAVE_UCONTEXT_H) || defined(HAVE_SYS_UCONTEXT_H)) && defined(PC_FROM_UCONTEXT)
73 if (ucontext_in_void != NULL) {
74 ucontext_t *context = reinterpret_cast<ucontext_t *>(ucontext_in_void);
75 return (void*)context->PC_FROM_UCONTEXT;
81 // The class is used for formatting error messages. We don't use printf()
82 // as it's not async signal safe.
83 class MinimalFormatter {
85 MinimalFormatter(char *buffer, int size)
91 // Returns the number of bytes written in the buffer.
92 int num_bytes_written() const { return cursor_ - buffer_; }
94 // Appends string from "str" and updates the internal cursor.
95 void AppendString(const char* str) {
97 while (str[i] != '\0' && cursor_ + i < end_) {
104 // Formats "number" in "radix" and updates the internal cursor.
105 // Lowercase letters are used for 'a' - 'z'.
106 void AppendUint64(uint64 number, int radix) {
108 while (cursor_ + i < end_) {
109 const int tmp = number % radix;
111 cursor_[i] = (tmp < 10 ? '0' + tmp : 'a' + tmp - 10);
117 // Reverse the bytes written.
118 std::reverse(cursor_, cursor_ + i);
122 // Formats "number" as hexadecimal number, and updates the internal
123 // cursor. Padding will be added in front if needed.
124 void AppendHexWithPadding(uint64 number, int width) {
125 char* start = cursor_;
127 AppendUint64(number, 16);
128 // Move to right and add padding in front if needed.
129 if (cursor_ < start + width) {
130 const int64 delta = start + width - cursor_;
131 std::copy(start, cursor_, start + delta);
132 std::fill(start, start + delta, ' ');
133 cursor_ = start + width;
140 const char * const end_;
143 // Writes the given data with the size to the standard error.
144 void WriteToStderr(const char* data, int size) {
145 write(STDERR_FILENO, data, size);
148 // The writer function can be changed by InstallFailureWriter().
149 void (*g_failure_writer)(const char* data, int size) = WriteToStderr;
151 // Dumps time information. We don't dump human-readable time information
152 // as localtime() is not guaranteed to be async signal safe.
153 void DumpTimeInfo() {
154 time_t time_in_sec = time(NULL);
155 char buf[256]; // Big enough for time info.
156 MinimalFormatter formatter(buf, sizeof(buf));
157 formatter.AppendString("*** Aborted at ");
158 formatter.AppendUint64(time_in_sec, 10);
159 formatter.AppendString(" (unix time)");
160 formatter.AppendString(" try \"date -d @");
161 formatter.AppendUint64(time_in_sec, 10);
162 formatter.AppendString("\" if you are using GNU date ***\n");
163 g_failure_writer(buf, formatter.num_bytes_written());
166 // Dumps information about the signal to STDERR.
167 void DumpSignalInfo(int signal_number, siginfo_t *siginfo) {
168 // Get the signal name.
169 const char* signal_name = NULL;
170 for (int i = 0; i < ARRAYSIZE(kFailureSignals); ++i) {
171 if (signal_number == kFailureSignals[i].number) {
172 signal_name = kFailureSignals[i].name;
176 char buf[256]; // Big enough for signal info.
177 MinimalFormatter formatter(buf, sizeof(buf));
179 formatter.AppendString("*** ");
181 formatter.AppendString(signal_name);
183 // Use the signal number if the name is unknown. The signal name
184 // should be known, but just in case.
185 formatter.AppendString("Signal ");
186 formatter.AppendUint64(signal_number, 10);
188 formatter.AppendString(" (@0x");
189 formatter.AppendUint64(reinterpret_cast<uintptr_t>(siginfo->si_addr), 16);
190 formatter.AppendString(")");
191 formatter.AppendString(" received by PID ");
192 formatter.AppendUint64(getpid(), 10);
193 formatter.AppendString(" (TID 0x");
194 // We assume pthread_t is an integral number or a pointer, rather
195 // than a complex struct. In some environments, pthread_self()
196 // returns an uint64 but in some other environments pthread_self()
197 // returns a pointer. Hence we use C-style cast here, rather than
198 // reinterpret/static_cast, to support both types of environments.
199 formatter.AppendUint64((uintptr_t)pthread_self(), 16);
200 formatter.AppendString(") ");
201 // Only linux has the PID of the signal sender in si_pid.
203 formatter.AppendString("from PID ");
204 formatter.AppendUint64(siginfo->si_pid, 10);
205 formatter.AppendString("; ");
207 formatter.AppendString("stack trace: ***\n");
208 g_failure_writer(buf, formatter.num_bytes_written());
211 // Dumps information about the stack frame to STDERR.
212 void DumpStackFrameInfo(const char* prefix, void* pc) {
213 // Get the symbol name.
214 const char *symbol = "(unknown)";
215 char symbolized[1024]; // Big enough for a sane symbol.
216 // Symbolizes the previous address of pc because pc may be in the
218 if (Symbolize(reinterpret_cast<char *>(pc) - 1,
219 symbolized, sizeof(symbolized))) {
223 char buf[1024]; // Big enough for stack frame info.
224 MinimalFormatter formatter(buf, sizeof(buf));
226 formatter.AppendString(prefix);
227 formatter.AppendString("@ ");
228 const int width = 2 * sizeof(void*) + 2; // + 2 for "0x".
229 formatter.AppendHexWithPadding(reinterpret_cast<uintptr_t>(pc), width);
230 formatter.AppendString(" ");
231 formatter.AppendString(symbol);
232 formatter.AppendString("\n");
233 g_failure_writer(buf, formatter.num_bytes_written());
236 // Invoke the default signal handler.
237 void InvokeDefaultSignalHandler(int signal_number) {
238 struct sigaction sig_action;
239 memset(&sig_action, 0, sizeof(sig_action));
240 sigemptyset(&sig_action.sa_mask);
241 sig_action.sa_handler = SIG_DFL;
242 sigaction(signal_number, &sig_action, NULL);
243 kill(getpid(), signal_number);
246 // This variable is used for protecting FailureSignalHandler() from
247 // dumping stuff while another thread is doing it. Our policy is to let
248 // the first thread dump stuff and let other threads wait.
249 // See also comments in FailureSignalHandler().
250 static pthread_t* g_entered_thread_id_pointer = NULL;
252 // Dumps signal and stack frame information, and invokes the default
253 // signal handler once our job is done.
254 void FailureSignalHandler(int signal_number,
255 siginfo_t *signal_info,
257 // First check if we've already entered the function. We use an atomic
258 // compare and swap operation for platforms that support it. For other
259 // platforms, we use a naive method that could lead to a subtle race.
261 // We assume pthread_self() is async signal safe, though it's not
262 // officially guaranteed.
263 pthread_t my_thread_id = pthread_self();
264 // NOTE: We could simply use pthread_t rather than pthread_t* for this,
265 // if pthread_self() is guaranteed to return non-zero value for thread
266 // ids, but there is no such guarantee. We need to distinguish if the
267 // old value (value returned from __sync_val_compare_and_swap) is
268 // different from the original value (in this case NULL).
269 pthread_t* old_thread_id_pointer =
270 glog_internal_namespace_::sync_val_compare_and_swap(
271 &g_entered_thread_id_pointer,
272 static_cast<pthread_t*>(NULL),
274 if (old_thread_id_pointer != NULL) {
275 // We've already entered the signal handler. What should we do?
276 if (pthread_equal(my_thread_id, *g_entered_thread_id_pointer)) {
277 // It looks the current thread is reentering the signal handler.
278 // Something must be going wrong (maybe we are reentering by another
279 // type of signal?). Kill ourself by the default signal handler.
280 InvokeDefaultSignalHandler(signal_number);
282 // Another thread is dumping stuff. Let's wait until that thread
283 // finishes the job and kills the process.
288 // This is the first time we enter the signal handler. We are going to
289 // do some interesting stuff from here.
290 // TODO(satorux): We might want to set timeout here using alarm(), but
291 // mixing alarm() and sleep() can be a bad idea.
293 // First dump time info.
296 // Get the program counter from ucontext.
297 void *pc = GetPC(ucontext);
298 DumpStackFrameInfo("PC: ", pc);
300 #ifdef HAVE_STACKTRACE
301 // Get the stack traces.
303 // +1 to exclude this function.
304 const int depth = GetStackTrace(stack, ARRAYSIZE(stack), 1);
305 DumpSignalInfo(signal_number, signal_info);
306 // Dump the stack traces.
307 for (int i = 0; i < depth; ++i) {
308 DumpStackFrameInfo(" ", stack[i]);
312 // *** TRANSITION ***
314 // BEFORE this point, all code must be async-termination-safe!
315 // (See WARNING above.)
317 // AFTER this point, we do unsafe things, like using LOG()!
318 // The process could be terminated or hung at any time. We try to
319 // do more useful things first and riskier things later.
321 // Flush the logs before we do anything in case 'anything'
323 FlushLogFilesUnsafe(0);
325 // Kill ourself by the default signal handler.
326 InvokeDefaultSignalHandler(signal_number);
331 void InstallFailureSignalHandler() {
332 // Build the sigaction struct.
333 struct sigaction sig_action;
334 memset(&sig_action, 0, sizeof(sig_action));
335 sigemptyset(&sig_action.sa_mask);
336 sig_action.sa_flags |= SA_SIGINFO;
337 sig_action.sa_sigaction = &FailureSignalHandler;
339 for (int i = 0; i < ARRAYSIZE(kFailureSignals); ++i) {
340 CHECK_ERR(sigaction(kFailureSignals[i].number, &sig_action, NULL));
344 void InstallFailureWriter(void (*writer)(const char* data, int size)) {
345 g_failure_writer = writer;
348 _END_GOOGLE_NAMESPACE_