1 // Copyright (c) 2007, Google Inc.
2 // All rights reserved.
3 //
4 // Redistribution and use in source and binary forms, with or without
5 // modification, are permitted provided that the following conditions are
6 // met:
7 //
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
13 // distribution.
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.
17 //
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.
29
30 // Author: Alfred Peng
31
32 #include <signal.h>
33 #include <sys/stat.h>
34 #include <sys/types.h>
35 #include <unistd.h>
36
37 #include <cassert>
38 #include <cstdlib>
39 #include <ctime>
40
41 #include "client/solaris/handler/exception_handler.h"
42 #include "common/solaris/guid_creator.h"
43 #include "common/solaris/message_output.h"
44 #include "google_breakpad/common/minidump_format.h"
45
46 namespace google_breakpad {
47
48 // Signals that we are interested.
49 static const int kSigTable[] = {
50 SIGSEGV,
51 SIGABRT,
52 SIGFPE,
53 SIGILL,
54 SIGBUS
55 };
56
57 std::vector<ExceptionHandler*> *ExceptionHandler::handler_stack_ = NULL;
58 int ExceptionHandler::handler_stack_index_ = 0;
59 pthread_mutex_t ExceptionHandler::handler_stack_mutex_ =
60 PTHREAD_MUTEX_INITIALIZER;
61
ExceptionHandler(const string & dump_path,FilterCallback filter,MinidumpCallback callback,void * callback_context,bool install_handler)62 ExceptionHandler::ExceptionHandler(const string &dump_path,
63 FilterCallback filter,
64 MinidumpCallback callback,
65 void *callback_context,
66 bool install_handler)
67 : filter_(filter),
68 callback_(callback),
69 callback_context_(callback_context),
70 dump_path_(),
71 installed_handler_(install_handler) {
72 set_dump_path(dump_path);
73
74 if (install_handler) {
75 SetupHandler();
76 }
77
78 if (install_handler) {
79 pthread_mutex_lock(&handler_stack_mutex_);
80
81 if (handler_stack_ == NULL)
82 handler_stack_ = new std::vector<ExceptionHandler *>;
83 handler_stack_->push_back(this);
84 pthread_mutex_unlock(&handler_stack_mutex_);
85 }
86 }
87
~ExceptionHandler()88 ExceptionHandler::~ExceptionHandler() {
89 TeardownAllHandlers();
90 pthread_mutex_lock(&handler_stack_mutex_);
91 if (handler_stack_->back() == this) {
92 handler_stack_->pop_back();
93 } else {
94 print_message1(2, "warning: removing Breakpad handler out of order\n");
95 for (std::vector<ExceptionHandler *>::iterator iterator =
96 handler_stack_->begin();
97 iterator != handler_stack_->end();
98 ++iterator) {
99 if (*iterator == this) {
100 handler_stack_->erase(iterator);
101 }
102 }
103 }
104
105 if (handler_stack_->empty()) {
106 // When destroying the last ExceptionHandler that installed a handler,
107 // clean up the handler stack.
108 delete handler_stack_;
109 handler_stack_ = NULL;
110 }
111 pthread_mutex_unlock(&handler_stack_mutex_);
112 }
113
WriteMinidump()114 bool ExceptionHandler::WriteMinidump() {
115 return InternalWriteMinidump(0, 0, NULL);
116 }
117
118 // static
WriteMinidump(const string & dump_path,MinidumpCallback callback,void * callback_context)119 bool ExceptionHandler::WriteMinidump(const string &dump_path,
120 MinidumpCallback callback,
121 void *callback_context) {
122 ExceptionHandler handler(dump_path, NULL, callback,
123 callback_context, false);
124 return handler.InternalWriteMinidump(0, 0, NULL);
125 }
126
SetupHandler()127 void ExceptionHandler::SetupHandler() {
128 // Signal on a different stack to avoid using the stack
129 // of the crashing lwp.
130 struct sigaltstack sig_stack;
131 sig_stack.ss_sp = malloc(MINSIGSTKSZ);
132 if (sig_stack.ss_sp == NULL)
133 return;
134 sig_stack.ss_size = MINSIGSTKSZ;
135 sig_stack.ss_flags = 0;
136
137 if (sigaltstack(&sig_stack, NULL) < 0)
138 return;
139 for (size_t i = 0; i < sizeof(kSigTable) / sizeof(kSigTable[0]); ++i)
140 SetupHandler(kSigTable[i]);
141 }
142
SetupHandler(int signo)143 void ExceptionHandler::SetupHandler(int signo) {
144 struct sigaction act, old_act;
145 act.sa_handler = HandleException;
146 act.sa_flags = SA_ONSTACK;
147 if (sigaction(signo, &act, &old_act) < 0)
148 return;
149 old_handlers_[signo] = old_act.sa_handler;
150 }
151
TeardownHandler(int signo)152 void ExceptionHandler::TeardownHandler(int signo) {
153 if (old_handlers_.find(signo) != old_handlers_.end()) {
154 struct sigaction act;
155 act.sa_handler = old_handlers_[signo];
156 act.sa_flags = 0;
157 sigaction(signo, &act, 0);
158 }
159 }
160
TeardownAllHandlers()161 void ExceptionHandler::TeardownAllHandlers() {
162 for (size_t i = 0; i < sizeof(kSigTable) / sizeof(kSigTable[0]); ++i) {
163 TeardownHandler(kSigTable[i]);
164 }
165 }
166
167 // static
HandleException(int signo)168 void ExceptionHandler::HandleException(int signo) {
169 //void ExceptionHandler::HandleException(int signo, siginfo_t *sip, ucontext_t *sig_ctx) {
170 // The context information about the signal is put on the stack of
171 // the signal handler frame as value parameter. For some reasons, the
172 // prototype of the handler doesn't declare this information as parameter, we
173 // will do it by hand. The stack layout for a signal handler frame is here:
174 // http://src.opensolaris.org/source/xref/onnv/onnv-gate/usr/src/lib/libproc/common/Pstack.c#81
175 //
176 // However, if we are being called by another signal handler passing the
177 // signal up the chain, then we may not have this random extra parameter,
178 // so we may have to walk the stack to find it. We do the actual work
179 // on another thread, where it's a little safer, but we want the ebp
180 // from this frame to find it.
181 uintptr_t current_ebp = (uintptr_t)_getfp();
182
183 pthread_mutex_lock(&handler_stack_mutex_);
184 ExceptionHandler *current_handler =
185 handler_stack_->at(handler_stack_->size() - ++handler_stack_index_);
186 pthread_mutex_unlock(&handler_stack_mutex_);
187
188 // Restore original handler.
189 current_handler->TeardownHandler(signo);
190
191 ucontext_t *sig_ctx = NULL;
192 if (current_handler->InternalWriteMinidump(signo, current_ebp, &sig_ctx)) {
193 // if (current_handler->InternalWriteMinidump(signo, &sig_ctx)) {
194 // Fully handled this exception, safe to exit.
195 exit(EXIT_FAILURE);
196 } else {
197 // Exception not fully handled, will call the next handler in stack to
198 // process it.
199 typedef void (*SignalHandler)(int signo);
200 SignalHandler old_handler =
201 reinterpret_cast<SignalHandler>(current_handler->old_handlers_[signo]);
202 if (old_handler != NULL)
203 old_handler(signo);
204 }
205
206 pthread_mutex_lock(&handler_stack_mutex_);
207 current_handler->SetupHandler(signo);
208 --handler_stack_index_;
209 // All the handlers in stack have been invoked to handle the exception,
210 // normally the process should be terminated and should not reach here.
211 // In case we got here, ask the OS to handle it to avoid endless loop,
212 // normally the OS will generate a core and termiate the process. This
213 // may be desired to debug the program.
214 if (handler_stack_index_ == 0)
215 signal(signo, SIG_DFL);
216 pthread_mutex_unlock(&handler_stack_mutex_);
217 }
218
InternalWriteMinidump(int signo,uintptr_t sighandler_ebp,ucontext_t ** sig_ctx)219 bool ExceptionHandler::InternalWriteMinidump(int signo,
220 uintptr_t sighandler_ebp,
221 ucontext_t **sig_ctx) {
222 if (filter_ && !filter_(callback_context_))
223 return false;
224
225 bool success = false;
226 GUID guid;
227 char guid_str[kGUIDStringLength + 1];
228 if (CreateGUID(&guid) && GUIDToString(&guid, guid_str, sizeof(guid_str))) {
229 char minidump_path[PATH_MAX];
230 snprintf(minidump_path, sizeof(minidump_path), "%s/%s.dmp",
231 dump_path_c_, guid_str);
232
233 // Block all the signals we want to process when writing minidump.
234 // We don't want it to be interrupted.
235 sigset_t sig_blocked, sig_old;
236 bool blocked = true;
237 sigfillset(&sig_blocked);
238 for (size_t i = 0; i < sizeof(kSigTable) / sizeof(kSigTable[0]); ++i)
239 sigdelset(&sig_blocked, kSigTable[i]);
240 if (sigprocmask(SIG_BLOCK, &sig_blocked, &sig_old) != 0) {
241 blocked = false;
242 print_message1(2, "HandleException: failed to block signals.\n");
243 }
244
245 success = minidump_generator_.WriteMinidumpToFile(
246 minidump_path, signo, sighandler_ebp, sig_ctx);
247
248 // Unblock the signals.
249 if (blocked)
250 sigprocmask(SIG_SETMASK, &sig_old, &sig_old);
251
252 if (callback_)
253 success = callback_(dump_path_c_, guid_str, callback_context_, success);
254 }
255 return success;
256 }
257
258 } // namespace google_breakpad
259