runtime/fault_handler.h

   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   void EnsureArtActionInFrontOfSignalChain();
  46
  47   void HandleFault(int sig, siginfo_t* info, void* context);
  48   void HandleNestedSignal(int sig, siginfo_t* info, void* context);
  49
  50   // Added handlers are owned by the fault handler and will be freed on Shutdown().
  51   void AddHandler(FaultHandler* handler, bool generated_code);
  52   void RemoveHandler(FaultHandler* handler);
  53
  54   // Note that the following two functions are called in the context of a signal handler.
  55   // The IsInGeneratedCode() function checks that the mutator lock is held before it
  56   // calls GetMethodAndReturnPCAndSP().
  57   // TODO: think about adding lock assertions and fake lock and unlock functions.
  58   void GetMethodAndReturnPcAndSp(siginfo_t* siginfo, void* context, ArtMethod** out_method,
  59                                  uintptr_t* out_return_pc, uintptr_t* out_sp)
  60                                  NO_THREAD_SAFETY_ANALYSIS;
  61   bool IsInGeneratedCode(siginfo_t* siginfo, void *context, bool check_dex_pc)
  62                          NO_THREAD_SAFETY_ANALYSIS;
  63
  64  private:
  65   // The HandleFaultByOtherHandlers function is only called by HandleFault function for generated code.
  66   bool HandleFaultByOtherHandlers(int sig, siginfo_t* info, void* context)
  67                                   NO_THREAD_SAFETY_ANALYSIS;
  68
  69   std::vector<FaultHandler*> generated_code_handlers_;
  70   std::vector<FaultHandler*> other_handlers_;
  71   struct sigaction oldaction_;
  72   bool initialized_;
  73   DISALLOW_COPY_AND_ASSIGN(FaultManager);
  74 };
  75
  76 class FaultHandler {
  77  public:
  78   explicit FaultHandler(FaultManager* manager);
  79   virtual ~FaultHandler() {}
  80   FaultManager* GetFaultManager() {
  81     return manager_;
  82   }
  83
  84   virtual bool Action(int sig, siginfo_t* siginfo, void* context) = 0;
  85
  86  protected:
  87   FaultManager* const manager_;
  88
  89  private:
  90   DISALLOW_COPY_AND_ASSIGN(FaultHandler);
  91 };
  92
  93 class NullPointerHandler FINAL : public FaultHandler {
  94  public:
  95   explicit NullPointerHandler(FaultManager* manager);
  96
  97   bool Action(int sig, siginfo_t* siginfo, void* context) OVERRIDE;
  98
  99  private:
 100   DISALLOW_COPY_AND_ASSIGN(NullPointerHandler);
 101 };
 102
 103 class SuspensionHandler FINAL : public FaultHandler {
 104  public:
 105   explicit SuspensionHandler(FaultManager* manager);
 106
 107   bool Action(int sig, siginfo_t* siginfo, void* context) OVERRIDE;
 108
 109  private:
 110   DISALLOW_COPY_AND_ASSIGN(SuspensionHandler);
 111 };
 112
 113 class StackOverflowHandler FINAL : public FaultHandler {
 114  public:
 115   explicit StackOverflowHandler(FaultManager* manager);
 116
 117   bool Action(int sig, siginfo_t* siginfo, void* context) OVERRIDE;
 118
 119  private:
 120   DISALLOW_COPY_AND_ASSIGN(StackOverflowHandler);
 121 };
 122
 123 class JavaStackTraceHandler FINAL : public FaultHandler {
 124  public:
 125   explicit JavaStackTraceHandler(FaultManager* manager);
 126
 127   bool Action(int sig, siginfo_t* siginfo, void* context) OVERRIDE NO_THREAD_SAFETY_ANALYSIS;
 128
 129  private:
 130   DISALLOW_COPY_AND_ASSIGN(JavaStackTraceHandler);
 131 };
 132
 133 // Statically allocated so the the signal handler can Get access to it.
 134 extern FaultManager fault_manager;
 135
 136 }       // namespace art
 137 #endif  // ART_RUNTIME_FAULT_HANDLER_H_
 138