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