Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2008 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
| 17 | #include "fault_handler.h" |
Ian Rogers | 22d5e73 | 2014-07-15 22:23:51 -0700 | [diff] [blame] | 18 | |
Dave Allison | 8ce6b90 | 2014-08-26 11:07:58 -0700 | [diff] [blame] | 19 | #include <setjmp.h> |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 20 | #include <sys/mman.h> |
| 21 | #include <sys/ucontext.h> |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 22 | |
| 23 | #include "art_method-inl.h" |
Josh Gao | 143f61c | 2017-04-17 20:10:29 -0700 | [diff] [blame] | 24 | #include "base/safe_copy.h" |
Andreas Gampe | 928f72b | 2014-09-09 19:53:48 -0700 | [diff] [blame] | 25 | #include "base/stl_util.h" |
Ian Rogers | 22d5e73 | 2014-07-15 22:23:51 -0700 | [diff] [blame] | 26 | #include "mirror/class.h" |
Josh Gao | 143f61c | 2017-04-17 20:10:29 -0700 | [diff] [blame] | 27 | #include "mirror/object_reference.h" |
Nicolas Geoffray | 524e7ea | 2015-10-16 17:13:34 +0100 | [diff] [blame] | 28 | #include "oat_quick_method_header.h" |
Dave Allison | f4b80bc | 2014-05-14 15:41:25 -0700 | [diff] [blame] | 29 | #include "sigchain.h" |
Ian Rogers | 22d5e73 | 2014-07-15 22:23:51 -0700 | [diff] [blame] | 30 | #include "thread-inl.h" |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 31 | #include "verify_object-inl.h" |
| 32 | |
| 33 | namespace art { |
| 34 | // Static fault manger object accessed by signal handler. |
| 35 | FaultManager fault_manager; |
| 36 | |
Narayan Kamath | c37769b | 2015-06-17 09:49:40 +0100 | [diff] [blame] | 37 | extern "C" __attribute__((visibility("default"))) void art_sigsegv_fault() { |
Dave Allison | f4b80bc | 2014-05-14 15:41:25 -0700 | [diff] [blame] | 38 | // Set a breakpoint here to be informed when a SIGSEGV is unhandled by ART. |
| 39 | VLOG(signals)<< "Caught unknown SIGSEGV in ART fault handler - chaining to next handler."; |
| 40 | } |
Dave Allison | f4b80bc | 2014-05-14 15:41:25 -0700 | [diff] [blame] | 41 | |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 42 | // Signal handler called on SIGSEGV. |
Josh Gao | 85a78cf | 2017-03-20 16:26:42 -0700 | [diff] [blame] | 43 | static bool art_fault_handler(int sig, siginfo_t* info, void* context) { |
| 44 | return fault_manager.HandleFault(sig, info, context); |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 45 | } |
| 46 | |
Josh Gao | 143f61c | 2017-04-17 20:10:29 -0700 | [diff] [blame] | 47 | #if defined(__linux__) |
| 48 | |
| 49 | // Change to verify the safe implementations against the original ones. |
| 50 | constexpr bool kVerifySafeImpls = false; |
| 51 | |
| 52 | // Provide implementations of ArtMethod::GetDeclaringClass and VerifyClassClass that use SafeCopy |
| 53 | // to safely dereference pointers which are potentially garbage. |
| 54 | // Only available on Linux due to availability of SafeCopy. |
| 55 | |
| 56 | static mirror::Class* SafeGetDeclaringClass(ArtMethod* method) |
| 57 | REQUIRES_SHARED(Locks::mutator_lock_) { |
| 58 | char* method_declaring_class = |
| 59 | reinterpret_cast<char*>(method) + ArtMethod::DeclaringClassOffset().SizeValue(); |
| 60 | |
| 61 | // ArtMethod::declaring_class_ is a GcRoot<mirror::Class>. |
| 62 | // Read it out into as a CompressedReference directly for simplicity's sake. |
| 63 | mirror::CompressedReference<mirror::Class> cls; |
| 64 | ssize_t rc = SafeCopy(&cls, method_declaring_class, sizeof(cls)); |
| 65 | CHECK_NE(-1, rc); |
| 66 | |
| 67 | if (kVerifySafeImpls) { |
| 68 | mirror::Class* actual_class = method->GetDeclaringClassUnchecked<kWithoutReadBarrier>(); |
| 69 | CHECK_EQ(actual_class, cls.AsMirrorPtr()); |
| 70 | } |
| 71 | |
| 72 | if (rc != sizeof(cls)) { |
| 73 | return nullptr; |
| 74 | } |
| 75 | |
| 76 | return cls.AsMirrorPtr(); |
| 77 | } |
| 78 | |
| 79 | static mirror::Class* SafeGetClass(mirror::Object* obj) REQUIRES_SHARED(Locks::mutator_lock_) { |
| 80 | char* obj_cls = reinterpret_cast<char*>(obj) + mirror::Object::ClassOffset().SizeValue(); |
| 81 | |
Nicolas Geoffray | d4ac767 | 2017-04-20 12:50:13 +0100 | [diff] [blame^] | 82 | mirror::HeapReference<mirror::Class> cls = |
| 83 | mirror::HeapReference<mirror::Class>::FromMirrorPtr(nullptr); |
Josh Gao | 143f61c | 2017-04-17 20:10:29 -0700 | [diff] [blame] | 84 | ssize_t rc = SafeCopy(&cls, obj_cls, sizeof(cls)); |
| 85 | CHECK_NE(-1, rc); |
| 86 | |
| 87 | if (kVerifySafeImpls) { |
| 88 | mirror::Class* actual_class = obj->GetClass<kVerifyNone>(); |
| 89 | CHECK_EQ(actual_class, cls.AsMirrorPtr()); |
| 90 | } |
| 91 | |
| 92 | if (rc != sizeof(cls)) { |
| 93 | return nullptr; |
| 94 | } |
| 95 | |
| 96 | return cls.AsMirrorPtr(); |
| 97 | } |
| 98 | |
| 99 | static bool SafeVerifyClassClass(mirror::Class* cls) REQUIRES_SHARED(Locks::mutator_lock_) { |
| 100 | mirror::Class* c_c = SafeGetClass(cls); |
| 101 | bool result = c_c != nullptr && c_c == SafeGetClass(c_c); |
| 102 | |
| 103 | if (kVerifySafeImpls) { |
| 104 | CHECK_EQ(VerifyClassClass(cls), result); |
| 105 | } |
| 106 | |
| 107 | return result; |
| 108 | } |
| 109 | |
| 110 | #else |
| 111 | |
Josh Gao | 77c1415 | 2017-04-19 13:20:19 -0700 | [diff] [blame] | 112 | static mirror::Class* SafeGetDeclaringClass(ArtMethod* method_obj) |
| 113 | REQUIRES_SHARED(Locks::mutator_lock_) { |
Josh Gao | 143f61c | 2017-04-17 20:10:29 -0700 | [diff] [blame] | 114 | return method_obj->GetDeclaringClassUnchecked<kWithoutReadBarrier>(); |
| 115 | } |
| 116 | |
Josh Gao | 77c1415 | 2017-04-19 13:20:19 -0700 | [diff] [blame] | 117 | static bool SafeVerifyClassClass(mirror::Class* cls) REQUIRES_SHARED(Locks::mutator_lock_) { |
Josh Gao | 143f61c | 2017-04-17 20:10:29 -0700 | [diff] [blame] | 118 | return VerifyClassClass(cls); |
| 119 | } |
| 120 | #endif |
| 121 | |
| 122 | |
Dave Allison | 1f8ef6f | 2014-08-20 17:38:41 -0700 | [diff] [blame] | 123 | FaultManager::FaultManager() : initialized_(false) { |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 124 | sigaction(SIGSEGV, nullptr, &oldaction_); |
| 125 | } |
| 126 | |
| 127 | FaultManager::~FaultManager() { |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 128 | } |
| 129 | |
| 130 | void FaultManager::Init() { |
Dave Allison | 1f8ef6f | 2014-08-20 17:38:41 -0700 | [diff] [blame] | 131 | CHECK(!initialized_); |
Josh Gao | 85a78cf | 2017-03-20 16:26:42 -0700 | [diff] [blame] | 132 | AddSpecialSignalHandlerFn(SIGSEGV, art_fault_handler); |
Dave Allison | 1f8ef6f | 2014-08-20 17:38:41 -0700 | [diff] [blame] | 133 | initialized_ = true; |
| 134 | } |
| 135 | |
Andreas Gampe | 928f72b | 2014-09-09 19:53:48 -0700 | [diff] [blame] | 136 | void FaultManager::Release() { |
Dave Allison | 1f8ef6f | 2014-08-20 17:38:41 -0700 | [diff] [blame] | 137 | if (initialized_) { |
Josh Gao | 85a78cf | 2017-03-20 16:26:42 -0700 | [diff] [blame] | 138 | RemoveSpecialSignalHandlerFn(SIGSEGV, art_fault_handler); |
Dave Allison | 1f8ef6f | 2014-08-20 17:38:41 -0700 | [diff] [blame] | 139 | initialized_ = false; |
| 140 | } |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 141 | } |
| 142 | |
Andreas Gampe | 928f72b | 2014-09-09 19:53:48 -0700 | [diff] [blame] | 143 | void FaultManager::Shutdown() { |
| 144 | if (initialized_) { |
| 145 | Release(); |
| 146 | |
| 147 | // Free all handlers. |
| 148 | STLDeleteElements(&generated_code_handlers_); |
| 149 | STLDeleteElements(&other_handlers_); |
| 150 | } |
| 151 | } |
| 152 | |
jgu21 | 1376bdf | 2016-01-18 09:12:33 -0500 | [diff] [blame] | 153 | bool FaultManager::HandleFaultByOtherHandlers(int sig, siginfo_t* info, void* context) { |
Andreas Gampe | d14b73d | 2016-04-18 17:15:42 -0700 | [diff] [blame] | 154 | if (other_handlers_.empty()) { |
| 155 | return false; |
| 156 | } |
| 157 | |
Dave Allison | 0c2894b | 2014-08-29 12:06:16 -0700 | [diff] [blame] | 158 | Thread* self = Thread::Current(); |
| 159 | |
jgu21 | 1376bdf | 2016-01-18 09:12:33 -0500 | [diff] [blame] | 160 | DCHECK(self != nullptr); |
| 161 | DCHECK(Runtime::Current() != nullptr); |
| 162 | DCHECK(Runtime::Current()->IsStarted()); |
Josh Gao | efd20cb | 2017-02-28 16:53:59 -0800 | [diff] [blame] | 163 | for (const auto& handler : other_handlers_) { |
| 164 | if (handler->Action(sig, info, context)) { |
| 165 | return true; |
Ian Rogers | ad11e7a | 2014-11-11 16:55:11 -0800 | [diff] [blame] | 166 | } |
| 167 | } |
jgu21 | 1376bdf | 2016-01-18 09:12:33 -0500 | [diff] [blame] | 168 | return false; |
| 169 | } |
| 170 | |
Josh Gao | 85a78cf | 2017-03-20 16:26:42 -0700 | [diff] [blame] | 171 | bool FaultManager::HandleFault(int sig, siginfo_t* info, void* context) { |
| 172 | VLOG(signals) << "Handling fault"; |
Josh Gao | efd20cb | 2017-02-28 16:53:59 -0800 | [diff] [blame] | 173 | |
| 174 | #ifdef TEST_NESTED_SIGNAL |
Josh Gao | 85a78cf | 2017-03-20 16:26:42 -0700 | [diff] [blame] | 175 | // Simulate a crash in a handler. |
| 176 | raise(SIGSEGV); |
Josh Gao | efd20cb | 2017-02-28 16:53:59 -0800 | [diff] [blame] | 177 | #endif |
| 178 | |
Josh Gao | 85a78cf | 2017-03-20 16:26:42 -0700 | [diff] [blame] | 179 | if (IsInGeneratedCode(info, context, true)) { |
| 180 | VLOG(signals) << "in generated code, looking for handler"; |
| 181 | for (const auto& handler : generated_code_handlers_) { |
| 182 | VLOG(signals) << "invoking Action on handler " << handler; |
| 183 | if (handler->Action(sig, info, context)) { |
| 184 | // We have handled a signal so it's time to return from the |
| 185 | // signal handler to the appropriate place. |
| 186 | return true; |
Josh Gao | efd20cb | 2017-02-28 16:53:59 -0800 | [diff] [blame] | 187 | } |
Josh Gao | 85a78cf | 2017-03-20 16:26:42 -0700 | [diff] [blame] | 188 | } |
Josh Gao | efd20cb | 2017-02-28 16:53:59 -0800 | [diff] [blame] | 189 | |
Josh Gao | 85a78cf | 2017-03-20 16:26:42 -0700 | [diff] [blame] | 190 | // We hit a signal we didn't handle. This might be something for which |
| 191 | // we can give more information about so call all registered handlers to |
| 192 | // see if it is. |
| 193 | if (HandleFaultByOtherHandlers(sig, info, context)) { |
| 194 | return true; |
jgu21 | 1376bdf | 2016-01-18 09:12:33 -0500 | [diff] [blame] | 195 | } |
| 196 | } |
Dave Allison | f4b80bc | 2014-05-14 15:41:25 -0700 | [diff] [blame] | 197 | |
Dave Allison | 8be44cf | 2014-09-04 14:33:42 -0700 | [diff] [blame] | 198 | // Set a breakpoint in this function to catch unhandled signals. |
| 199 | art_sigsegv_fault(); |
Josh Gao | 85a78cf | 2017-03-20 16:26:42 -0700 | [diff] [blame] | 200 | return false; |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 201 | } |
| 202 | |
Mathieu Chartier | c751fdc | 2014-03-30 15:25:44 -0700 | [diff] [blame] | 203 | void FaultManager::AddHandler(FaultHandler* handler, bool generated_code) { |
Andreas Gampe | 928f72b | 2014-09-09 19:53:48 -0700 | [diff] [blame] | 204 | DCHECK(initialized_); |
Mathieu Chartier | c751fdc | 2014-03-30 15:25:44 -0700 | [diff] [blame] | 205 | if (generated_code) { |
| 206 | generated_code_handlers_.push_back(handler); |
| 207 | } else { |
| 208 | other_handlers_.push_back(handler); |
| 209 | } |
| 210 | } |
| 211 | |
| 212 | void FaultManager::RemoveHandler(FaultHandler* handler) { |
| 213 | auto it = std::find(generated_code_handlers_.begin(), generated_code_handlers_.end(), handler); |
| 214 | if (it != generated_code_handlers_.end()) { |
| 215 | generated_code_handlers_.erase(it); |
| 216 | return; |
| 217 | } |
| 218 | auto it2 = std::find(other_handlers_.begin(), other_handlers_.end(), handler); |
| 219 | if (it2 != other_handlers_.end()) { |
| 220 | other_handlers_.erase(it); |
| 221 | return; |
| 222 | } |
| 223 | LOG(FATAL) << "Attempted to remove non existent handler " << handler; |
| 224 | } |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 225 | |
| 226 | // This function is called within the signal handler. It checks that |
| 227 | // the mutator_lock is held (shared). No annotalysis is done. |
Dave Allison | 69dfe51 | 2014-07-11 17:11:58 +0000 | [diff] [blame] | 228 | bool FaultManager::IsInGeneratedCode(siginfo_t* siginfo, void* context, bool check_dex_pc) { |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 229 | // We can only be running Java code in the current thread if it |
| 230 | // is in Runnable state. |
Dave Allison | 5cd3375 | 2014-04-15 15:57:58 -0700 | [diff] [blame] | 231 | VLOG(signals) << "Checking for generated code"; |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 232 | Thread* thread = Thread::Current(); |
| 233 | if (thread == nullptr) { |
Dave Allison | 5cd3375 | 2014-04-15 15:57:58 -0700 | [diff] [blame] | 234 | VLOG(signals) << "no current thread"; |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 235 | return false; |
| 236 | } |
| 237 | |
| 238 | ThreadState state = thread->GetState(); |
| 239 | if (state != kRunnable) { |
Dave Allison | 5cd3375 | 2014-04-15 15:57:58 -0700 | [diff] [blame] | 240 | VLOG(signals) << "not runnable"; |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 241 | return false; |
| 242 | } |
| 243 | |
| 244 | // Current thread is runnable. |
| 245 | // Make sure it has the mutator lock. |
| 246 | if (!Locks::mutator_lock_->IsSharedHeld(thread)) { |
Dave Allison | 5cd3375 | 2014-04-15 15:57:58 -0700 | [diff] [blame] | 247 | VLOG(signals) << "no lock"; |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 248 | return false; |
| 249 | } |
| 250 | |
Nicolas Geoffray | 7bf2b4f | 2015-07-08 10:11:59 +0000 | [diff] [blame] | 251 | ArtMethod* method_obj = nullptr; |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 252 | uintptr_t return_pc = 0; |
Mathieu Chartier | c751fdc | 2014-03-30 15:25:44 -0700 | [diff] [blame] | 253 | uintptr_t sp = 0; |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 254 | |
| 255 | // Get the architecture specific method address and return address. These |
Mathieu Chartier | c751fdc | 2014-03-30 15:25:44 -0700 | [diff] [blame] | 256 | // are in architecture specific files in arch/<arch>/fault_handler_<arch>. |
Dave Allison | dfd3b47 | 2014-07-16 16:04:32 -0700 | [diff] [blame] | 257 | GetMethodAndReturnPcAndSp(siginfo, context, &method_obj, &return_pc, &sp); |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 258 | |
| 259 | // If we don't have a potential method, we're outta here. |
Dave Allison | 5cd3375 | 2014-04-15 15:57:58 -0700 | [diff] [blame] | 260 | VLOG(signals) << "potential method: " << method_obj; |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 261 | // TODO: Check linear alloc and image. |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 262 | DCHECK_ALIGNED(ArtMethod::Size(kRuntimePointerSize), sizeof(void*)) |
Nicolas Geoffray | 7bf2b4f | 2015-07-08 10:11:59 +0000 | [diff] [blame] | 263 | << "ArtMethod is not pointer aligned"; |
| 264 | if (method_obj == nullptr || !IsAligned<sizeof(void*)>(method_obj)) { |
Dave Allison | 5cd3375 | 2014-04-15 15:57:58 -0700 | [diff] [blame] | 265 | VLOG(signals) << "no method"; |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 266 | return false; |
| 267 | } |
| 268 | |
| 269 | // Verify that the potential method is indeed a method. |
| 270 | // TODO: check the GC maps to make sure it's an object. |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 271 | // Check that the class pointer inside the object is not null and is aligned. |
Hiroshi Yamauchi | 2cd334a | 2015-01-09 14:03:35 -0800 | [diff] [blame] | 272 | // No read barrier because method_obj may not be a real object. |
Josh Gao | 143f61c | 2017-04-17 20:10:29 -0700 | [diff] [blame] | 273 | mirror::Class* cls = SafeGetDeclaringClass(method_obj); |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 274 | if (cls == nullptr) { |
Dave Allison | 5cd3375 | 2014-04-15 15:57:58 -0700 | [diff] [blame] | 275 | VLOG(signals) << "not a class"; |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 276 | return false; |
| 277 | } |
Josh Gao | 143f61c | 2017-04-17 20:10:29 -0700 | [diff] [blame] | 278 | |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 279 | if (!IsAligned<kObjectAlignment>(cls)) { |
Dave Allison | 5cd3375 | 2014-04-15 15:57:58 -0700 | [diff] [blame] | 280 | VLOG(signals) << "not aligned"; |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 281 | return false; |
| 282 | } |
| 283 | |
Josh Gao | 143f61c | 2017-04-17 20:10:29 -0700 | [diff] [blame] | 284 | if (!SafeVerifyClassClass(cls)) { |
Dave Allison | 5cd3375 | 2014-04-15 15:57:58 -0700 | [diff] [blame] | 285 | VLOG(signals) << "not a class class"; |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 286 | return false; |
| 287 | } |
| 288 | |
Nicolas Geoffray | 524e7ea | 2015-10-16 17:13:34 +0100 | [diff] [blame] | 289 | const OatQuickMethodHeader* method_header = method_obj->GetOatQuickMethodHeader(return_pc); |
Nicolas Geoffray | 6bc4374 | 2015-10-12 18:11:10 +0100 | [diff] [blame] | 290 | |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 291 | // We can be certain that this is a method now. Check if we have a GC map |
| 292 | // at the return PC address. |
Dave Allison | f943914 | 2014-03-27 15:10:22 -0700 | [diff] [blame] | 293 | if (true || kIsDebugBuild) { |
Dave Allison | 5cd3375 | 2014-04-15 15:57:58 -0700 | [diff] [blame] | 294 | VLOG(signals) << "looking for dex pc for return pc " << std::hex << return_pc; |
Nicolas Geoffray | 6bc4374 | 2015-10-12 18:11:10 +0100 | [diff] [blame] | 295 | uint32_t sought_offset = return_pc - |
Nicolas Geoffray | 524e7ea | 2015-10-16 17:13:34 +0100 | [diff] [blame] | 296 | reinterpret_cast<uintptr_t>(method_header->GetEntryPoint()); |
Dave Allison | 5cd3375 | 2014-04-15 15:57:58 -0700 | [diff] [blame] | 297 | VLOG(signals) << "pc offset: " << std::hex << sought_offset; |
Dave Allison | f943914 | 2014-03-27 15:10:22 -0700 | [diff] [blame] | 298 | } |
Nicolas Geoffray | 524e7ea | 2015-10-16 17:13:34 +0100 | [diff] [blame] | 299 | uint32_t dexpc = method_header->ToDexPc(method_obj, return_pc, false); |
Dave Allison | 5cd3375 | 2014-04-15 15:57:58 -0700 | [diff] [blame] | 300 | VLOG(signals) << "dexpc: " << dexpc; |
Mathieu Chartier | c751fdc | 2014-03-30 15:25:44 -0700 | [diff] [blame] | 301 | return !check_dex_pc || dexpc != DexFile::kDexNoIndex; |
| 302 | } |
| 303 | |
| 304 | FaultHandler::FaultHandler(FaultManager* manager) : manager_(manager) { |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 305 | } |
| 306 | |
| 307 | // |
| 308 | // Null pointer fault handler |
| 309 | // |
Mathieu Chartier | c751fdc | 2014-03-30 15:25:44 -0700 | [diff] [blame] | 310 | NullPointerHandler::NullPointerHandler(FaultManager* manager) : FaultHandler(manager) { |
| 311 | manager_->AddHandler(this, true); |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 312 | } |
| 313 | |
| 314 | // |
| 315 | // Suspension fault handler |
| 316 | // |
Mathieu Chartier | c751fdc | 2014-03-30 15:25:44 -0700 | [diff] [blame] | 317 | SuspensionHandler::SuspensionHandler(FaultManager* manager) : FaultHandler(manager) { |
| 318 | manager_->AddHandler(this, true); |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 319 | } |
| 320 | |
| 321 | // |
| 322 | // Stack overflow fault handler |
| 323 | // |
Mathieu Chartier | c751fdc | 2014-03-30 15:25:44 -0700 | [diff] [blame] | 324 | StackOverflowHandler::StackOverflowHandler(FaultManager* manager) : FaultHandler(manager) { |
| 325 | manager_->AddHandler(this, true); |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 326 | } |
Mathieu Chartier | c751fdc | 2014-03-30 15:25:44 -0700 | [diff] [blame] | 327 | |
| 328 | // |
| 329 | // Stack trace handler, used to help get a stack trace from SIGSEGV inside of compiled code. |
| 330 | // |
| 331 | JavaStackTraceHandler::JavaStackTraceHandler(FaultManager* manager) : FaultHandler(manager) { |
| 332 | manager_->AddHandler(this, false); |
| 333 | } |
| 334 | |
Roland Levillain | 4b8f1ec | 2015-08-26 18:34:03 +0100 | [diff] [blame] | 335 | bool JavaStackTraceHandler::Action(int sig ATTRIBUTE_UNUSED, siginfo_t* siginfo, void* context) { |
Mathieu Chartier | c751fdc | 2014-03-30 15:25:44 -0700 | [diff] [blame] | 336 | // Make sure that we are in the generated code, but we may not have a dex pc. |
Dave Allison | 8ce6b90 | 2014-08-26 11:07:58 -0700 | [diff] [blame] | 337 | bool in_generated_code = manager_->IsInGeneratedCode(siginfo, context, false); |
Dave Allison | 8ce6b90 | 2014-08-26 11:07:58 -0700 | [diff] [blame] | 338 | if (in_generated_code) { |
Mathieu Chartier | c751fdc | 2014-03-30 15:25:44 -0700 | [diff] [blame] | 339 | LOG(ERROR) << "Dumping java stack trace for crash in generated code"; |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 340 | ArtMethod* method = nullptr; |
Mathieu Chartier | c751fdc | 2014-03-30 15:25:44 -0700 | [diff] [blame] | 341 | uintptr_t return_pc = 0; |
| 342 | uintptr_t sp = 0; |
Mathieu Chartier | c751fdc | 2014-03-30 15:25:44 -0700 | [diff] [blame] | 343 | Thread* self = Thread::Current(); |
Dave Allison | 8ce6b90 | 2014-08-26 11:07:58 -0700 | [diff] [blame] | 344 | |
Dave Allison | 0c2894b | 2014-08-29 12:06:16 -0700 | [diff] [blame] | 345 | manager_->GetMethodAndReturnPcAndSp(siginfo, context, &method, &return_pc, &sp); |
| 346 | // Inside of generated code, sp[0] is the method, so sp is the frame. |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 347 | self->SetTopOfStack(reinterpret_cast<ArtMethod**>(sp)); |
Andreas Gampe | 3fec9ac | 2016-09-13 10:47:28 -0700 | [diff] [blame] | 348 | self->DumpJavaStack(LOG_STREAM(ERROR)); |
Mathieu Chartier | c751fdc | 2014-03-30 15:25:44 -0700 | [diff] [blame] | 349 | } |
Dave Allison | 8ce6b90 | 2014-08-26 11:07:58 -0700 | [diff] [blame] | 350 | |
Mathieu Chartier | c751fdc | 2014-03-30 15:25:44 -0700 | [diff] [blame] | 351 | return false; // Return false since we want to propagate the fault to the main signal handler. |
| 352 | } |
| 353 | |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 354 | } // namespace art |