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 18 #ifndef ART_RUNTIME_FAULT_HANDLER_H_ 19 #define ART_RUNTIME_FAULT_HANDLER_H_ 20 21 #include <signal.h> 22 #include <vector> 23 #include <setjmp.h> 24 #include <stdint.h> 25 26 #include "base/mutex.h" // For annotalysis. 27 28 namespace art { 29 30 class ArtMethod; 31 class FaultHandler; 32 33 class FaultManager { 34 public: 35 FaultManager(); 36 ~FaultManager(); 37 38 void Init(); 39 40 // Unclaim signals. 41 void Release(); 42 43 // Unclaim signals and delete registered handlers. 44 void Shutdown(); 45 46 // Try to handle a fault, returns true if successful. 47 bool HandleFault(int sig, siginfo_t* info, void* context); 48 49 // Added handlers are owned by the fault handler and will be freed on Shutdown(). 50 void AddHandler(FaultHandler* handler, bool generated_code); 51 void RemoveHandler(FaultHandler* handler); 52 53 // Note that the following two functions are called in the context of a signal handler. 54 // The IsInGeneratedCode() function checks that the mutator lock is held before it 55 // calls GetMethodAndReturnPCAndSP(). 56 // TODO: think about adding lock assertions and fake lock and unlock functions. 57 void GetMethodAndReturnPcAndSp(siginfo_t* siginfo, void* context, ArtMethod** out_method, 58 uintptr_t* out_return_pc, uintptr_t* out_sp) 59 NO_THREAD_SAFETY_ANALYSIS; 60 bool IsInGeneratedCode(siginfo_t* siginfo, void *context, bool check_dex_pc) 61 NO_THREAD_SAFETY_ANALYSIS; 62 63 private: 64 // The HandleFaultByOtherHandlers function is only called by HandleFault function for generated code. 65 bool HandleFaultByOtherHandlers(int sig, siginfo_t* info, void* context) 66 NO_THREAD_SAFETY_ANALYSIS; 67 68 std::vector<FaultHandler*> generated_code_handlers_; 69 std::vector<FaultHandler*> other_handlers_; 70 struct sigaction oldaction_; 71 bool initialized_; 72 DISALLOW_COPY_AND_ASSIGN(FaultManager); 73 }; 74 75 class FaultHandler { 76 public: 77 explicit FaultHandler(FaultManager* manager); ~FaultHandler()78 virtual ~FaultHandler() {} GetFaultManager()79 FaultManager* GetFaultManager() { 80 return manager_; 81 } 82 83 virtual bool Action(int sig, siginfo_t* siginfo, void* context) = 0; 84 85 protected: 86 FaultManager* const manager_; 87 88 private: 89 DISALLOW_COPY_AND_ASSIGN(FaultHandler); 90 }; 91 92 class NullPointerHandler FINAL : public FaultHandler { 93 public: 94 explicit NullPointerHandler(FaultManager* manager); 95 96 bool Action(int sig, siginfo_t* siginfo, void* context) OVERRIDE; 97 IsValidImplicitCheck(siginfo_t * siginfo)98 static bool IsValidImplicitCheck(siginfo_t* siginfo) { 99 // Our implicit NPE checks always limit the range to a page. 100 // Note that the runtime will do more exhaustive checks (that we cannot 101 // reasonably do in signal processing code) based on the dex instruction 102 // faulting. 103 return CanDoImplicitNullCheckOn(reinterpret_cast<uintptr_t>(siginfo->si_addr)); 104 } 105 106 private: 107 DISALLOW_COPY_AND_ASSIGN(NullPointerHandler); 108 }; 109 110 class SuspensionHandler FINAL : public FaultHandler { 111 public: 112 explicit SuspensionHandler(FaultManager* manager); 113 114 bool Action(int sig, siginfo_t* siginfo, void* context) OVERRIDE; 115 116 private: 117 DISALLOW_COPY_AND_ASSIGN(SuspensionHandler); 118 }; 119 120 class StackOverflowHandler FINAL : public FaultHandler { 121 public: 122 explicit StackOverflowHandler(FaultManager* manager); 123 124 bool Action(int sig, siginfo_t* siginfo, void* context) OVERRIDE; 125 126 private: 127 DISALLOW_COPY_AND_ASSIGN(StackOverflowHandler); 128 }; 129 130 class JavaStackTraceHandler FINAL : public FaultHandler { 131 public: 132 explicit JavaStackTraceHandler(FaultManager* manager); 133 134 bool Action(int sig, siginfo_t* siginfo, void* context) OVERRIDE NO_THREAD_SAFETY_ANALYSIS; 135 136 private: 137 DISALLOW_COPY_AND_ASSIGN(JavaStackTraceHandler); 138 }; 139 140 // Statically allocated so the the signal handler can Get access to it. 141 extern FaultManager fault_manager; 142 143 } // namespace art 144 #endif // ART_RUNTIME_FAULT_HANDLER_H_ 145 146