Home | History | Annotate | Download | only in breakpoint-logger 
      1 // Copyright (C) 2017 The Android Open Source Project
      2 //
      3 // Licensed under the Apache License, Version 2.0 (the "License");
      4 // you may not use this file except in compliance with the License.
      5 // You may obtain a copy of the License at
      6 //
      7 //      http://www.apache.org/licenses/LICENSE-2.0
      8 //
      9 // Unless required by applicable law or agreed to in writing, software
     10 // distributed under the License is distributed on an "AS IS" BASIS,
     11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     12 // See the License for the specific language governing permissions and
     13 // limitations under the License.
     14 //
     15 
     16 #include <android-base/logging.h>
     17 #include <atomic>
     18 #include <iostream>
     19 #include <iomanip>
     20 #include <jni.h>
     21 #include <jvmti.h>
     22 #include <memory>
     23 #include <string>
     24 #include <vector>
     25 
     26 namespace breakpoint_logger {
     27 
     28 struct SingleBreakpointTarget {
     29   std::string class_name;
     30   std::string method_name;
     31   std::string method_sig;
     32   jlocation location;
     33 };
     34 
     35 struct BreakpointTargets {
     36   std::vector<SingleBreakpointTarget> bps;
     37 };
     38 
     39 static void VMInitCB(jvmtiEnv* jvmti, JNIEnv* env, jthread thr ATTRIBUTE_UNUSED) {
     40   BreakpointTargets* all_targets = nullptr;
     41   jvmtiError err = jvmti->GetEnvironmentLocalStorage(reinterpret_cast<void**>(&all_targets));
     42   if (err != JVMTI_ERROR_NONE || all_targets == nullptr) {
     43     env->FatalError("unable to get breakpoint targets");
     44   }
     45   for (const SingleBreakpointTarget& target : all_targets->bps) {
     46     jclass k = env->FindClass(target.class_name.c_str());
     47     if (env->ExceptionCheck()) {
     48       env->ExceptionDescribe();
     49       env->FatalError("Could not find class!");
     50       return;
     51     }
     52     jmethodID m = env->GetMethodID(k, target.method_name.c_str(), target.method_sig.c_str());
     53     if (env->ExceptionCheck()) {
     54       env->ExceptionClear();
     55       m = env->GetStaticMethodID(k, target.method_name.c_str(), target.method_sig.c_str());
     56       if (env->ExceptionCheck()) {
     57         env->ExceptionDescribe();
     58         env->FatalError("Could not find method!");
     59         return;
     60       }
     61     }
     62     err = jvmti->SetBreakpoint(m, target.location);
     63     if (err != JVMTI_ERROR_NONE) {
     64       env->FatalError("unable to set breakpoint");
     65       return;
     66     }
     67     env->DeleteLocalRef(k);
     68   }
     69 }
     70 
     71 class ScopedThreadInfo {
     72  public:
     73   ScopedThreadInfo(jvmtiEnv* jvmti_env, JNIEnv* env, jthread thread)
     74       : jvmti_env_(jvmti_env), env_(env), free_name_(false) {
     75     memset(&info_, 0, sizeof(info_));
     76     if (thread == nullptr) {
     77       info_.name = const_cast<char*>("<NULLPTR>");
     78     } else if (jvmti_env->GetThreadInfo(thread, &info_) != JVMTI_ERROR_NONE) {
     79       info_.name = const_cast<char*>("<UNKNOWN THREAD>");
     80     } else {
     81       free_name_ = true;
     82     }
     83   }
     84 
     85   ~ScopedThreadInfo() {
     86     if (free_name_) {
     87       jvmti_env_->Deallocate(reinterpret_cast<unsigned char*>(info_.name));
     88     }
     89     env_->DeleteLocalRef(info_.thread_group);
     90     env_->DeleteLocalRef(info_.context_class_loader);
     91   }
     92 
     93   const char* GetName() const {
     94     return info_.name;
     95   }
     96 
     97  private:
     98   jvmtiEnv* jvmti_env_;
     99   JNIEnv* env_;
    100   bool free_name_;
    101   jvmtiThreadInfo info_;
    102 };
    103 
    104 class ScopedClassInfo {
    105  public:
    106   ScopedClassInfo(jvmtiEnv* jvmti_env, jclass c)
    107       : jvmti_env_(jvmti_env),
    108         class_(c),
    109         name_(nullptr),
    110         generic_(nullptr),
    111         file_(nullptr),
    112         debug_ext_(nullptr) {}
    113 
    114   ~ScopedClassInfo() {
    115     if (class_ != nullptr) {
    116       jvmti_env_->Deallocate(reinterpret_cast<unsigned char*>(name_));
    117       jvmti_env_->Deallocate(reinterpret_cast<unsigned char*>(generic_));
    118       jvmti_env_->Deallocate(reinterpret_cast<unsigned char*>(file_));
    119       jvmti_env_->Deallocate(reinterpret_cast<unsigned char*>(debug_ext_));
    120     }
    121   }
    122 
    123   bool Init() {
    124     if (class_ == nullptr) {
    125       name_ = const_cast<char*>("<NONE>");
    126       generic_ = const_cast<char*>("<NONE>");
    127       return true;
    128     } else {
    129       jvmtiError ret1 = jvmti_env_->GetSourceFileName(class_, &file_);
    130       jvmtiError ret2 = jvmti_env_->GetSourceDebugExtension(class_, &debug_ext_);
    131       return jvmti_env_->GetClassSignature(class_, &name_, &generic_) == JVMTI_ERROR_NONE &&
    132           ret1 != JVMTI_ERROR_MUST_POSSESS_CAPABILITY &&
    133           ret1 != JVMTI_ERROR_INVALID_CLASS &&
    134           ret2 != JVMTI_ERROR_MUST_POSSESS_CAPABILITY &&
    135           ret2 != JVMTI_ERROR_INVALID_CLASS;
    136     }
    137   }
    138 
    139   jclass GetClass() const {
    140     return class_;
    141   }
    142   const char* GetName() const {
    143     return name_;
    144   }
    145   // Generic type parameters, whatever is in the <> for a class
    146   const char* GetGeneric() const {
    147     return generic_;
    148   }
    149   const char* GetSourceDebugExtension() const {
    150     if (debug_ext_ == nullptr) {
    151       return "<UNKNOWN_SOURCE_DEBUG_EXTENSION>";
    152     } else {
    153       return debug_ext_;
    154     }
    155   }
    156   const char* GetSourceFileName() const {
    157     if (file_ == nullptr) {
    158       return "<UNKNOWN_FILE>";
    159     } else {
    160       return file_;
    161     }
    162   }
    163 
    164  private:
    165   jvmtiEnv* jvmti_env_;
    166   jclass class_;
    167   char* name_;
    168   char* generic_;
    169   char* file_;
    170   char* debug_ext_;
    171 };
    172 
    173 class ScopedMethodInfo {
    174  public:
    175   ScopedMethodInfo(jvmtiEnv* jvmti_env, JNIEnv* env, jmethodID method)
    176       : jvmti_env_(jvmti_env),
    177         env_(env),
    178         method_(method),
    179         declaring_class_(nullptr),
    180         class_info_(nullptr),
    181         name_(nullptr),
    182         signature_(nullptr),
    183         generic_(nullptr),
    184         first_line_(-1) {}
    185 
    186   ~ScopedMethodInfo() {
    187     env_->DeleteLocalRef(declaring_class_);
    188     jvmti_env_->Deallocate(reinterpret_cast<unsigned char*>(name_));
    189     jvmti_env_->Deallocate(reinterpret_cast<unsigned char*>(signature_));
    190     jvmti_env_->Deallocate(reinterpret_cast<unsigned char*>(generic_));
    191   }
    192 
    193   bool Init() {
    194     if (jvmti_env_->GetMethodDeclaringClass(method_, &declaring_class_) != JVMTI_ERROR_NONE) {
    195       return false;
    196     }
    197     class_info_.reset(new ScopedClassInfo(jvmti_env_, declaring_class_));
    198     jint nlines;
    199     jvmtiLineNumberEntry* lines;
    200     jvmtiError err = jvmti_env_->GetLineNumberTable(method_, &nlines, &lines);
    201     if (err == JVMTI_ERROR_NONE) {
    202       if (nlines > 0) {
    203         first_line_ = lines[0].line_number;
    204       }
    205       jvmti_env_->Deallocate(reinterpret_cast<unsigned char*>(lines));
    206     } else if (err != JVMTI_ERROR_ABSENT_INFORMATION &&
    207                err != JVMTI_ERROR_NATIVE_METHOD) {
    208       return false;
    209     }
    210     return class_info_->Init() &&
    211         (jvmti_env_->GetMethodName(method_, &name_, &signature_, &generic_) == JVMTI_ERROR_NONE);
    212   }
    213 
    214   const ScopedClassInfo& GetDeclaringClassInfo() const {
    215     return *class_info_;
    216   }
    217 
    218   jclass GetDeclaringClass() const {
    219     return declaring_class_;
    220   }
    221 
    222   const char* GetName() const {
    223     return name_;
    224   }
    225 
    226   const char* GetSignature() const {
    227     return signature_;
    228   }
    229 
    230   const char* GetGeneric() const {
    231     return generic_;
    232   }
    233 
    234   jint GetFirstLine() const {
    235     return first_line_;
    236   }
    237 
    238  private:
    239   jvmtiEnv* jvmti_env_;
    240   JNIEnv* env_;
    241   jmethodID method_;
    242   jclass declaring_class_;
    243   std::unique_ptr<ScopedClassInfo> class_info_;
    244   char* name_;
    245   char* signature_;
    246   char* generic_;
    247   jint first_line_;
    248 
    249   friend std::ostream& operator<<(std::ostream& os, ScopedMethodInfo const& method);
    250 };
    251 
    252 std::ostream& operator<<(std::ostream& os, const ScopedMethodInfo* method) {
    253   return os << *method;
    254 }
    255 
    256 std::ostream& operator<<(std::ostream& os, ScopedMethodInfo const& method) {
    257   return os << method.GetDeclaringClassInfo().GetName() << "->" << method.GetName()
    258             << method.GetSignature() << " (source: "
    259             << method.GetDeclaringClassInfo().GetSourceFileName() << ":" << method.GetFirstLine()
    260             << ")";
    261 }
    262 
    263 static void BreakpointCB(jvmtiEnv* jvmti_env,
    264                          JNIEnv* env,
    265                          jthread thread,
    266                          jmethodID method,
    267                          jlocation location) {
    268   ScopedThreadInfo info(jvmti_env, env, thread);
    269   ScopedMethodInfo method_info(jvmti_env, env, method);
    270   if (!method_info.Init()) {
    271     LOG(ERROR) << "Unable to get method info!";
    272     return;
    273   }
    274   LOG(WARNING) << "Breakpoint at location: 0x" << std::setw(8) << std::setfill('0') << std::hex
    275             << location << " in method " << method_info << " thread: " << info.GetName();
    276 }
    277 
    278 static std::string SubstrOf(const std::string& s, size_t start, size_t end) {
    279   if (end == std::string::npos) {
    280     end = s.size();
    281   }
    282   if (end == start) {
    283     return "";
    284   }
    285   CHECK_GT(end, start) << "cannot get substr of " << s;
    286   return s.substr(start, end - start);
    287 }
    288 
    289 static bool ParseSingleBreakpoint(const std::string& bp, /*out*/SingleBreakpointTarget* target) {
    290   std::string option = bp;
    291   if (option.empty() || option[0] != 'L' || option.find(';') == std::string::npos) {
    292     LOG(ERROR) << option << " doesn't look like it has a class name";
    293     return false;
    294   }
    295   target->class_name = SubstrOf(option, 1, option.find(';'));
    296 
    297   option = SubstrOf(option, option.find(';') + 1, std::string::npos);
    298   if (option.size() < 2 || option[0] != '-' || option[1] != '>') {
    299     LOG(ERROR) << bp << " doesn't seem to indicate a method, expected ->";
    300     return false;
    301   }
    302   option = SubstrOf(option, 2, std::string::npos);
    303   size_t sig_start = option.find('(');
    304   size_t loc_start = option.find('@');
    305   if (option.empty() || sig_start == std::string::npos) {
    306     LOG(ERROR) << bp << " doesn't seem to have a method sig!";
    307     return false;
    308   } else if (loc_start == std::string::npos ||
    309              loc_start < sig_start ||
    310              loc_start + 1 >= option.size()) {
    311     LOG(ERROR) << bp << " doesn't seem to have a valid location!";
    312     return false;
    313   }
    314   target->method_name = SubstrOf(option, 0, sig_start);
    315   target->method_sig = SubstrOf(option, sig_start, loc_start);
    316   target->location = std::stol(SubstrOf(option, loc_start + 1, std::string::npos));
    317   return true;
    318 }
    319 
    320 static std::string RemoveLastOption(const std::string& op) {
    321   if (op.find(',') == std::string::npos) {
    322     return "";
    323   } else {
    324     return SubstrOf(op, op.find(',') + 1, std::string::npos);
    325   }
    326 }
    327 
    328 // Fills targets with the breakpoints to add.
    329 // Lname/of/Klass;->methodName(Lsig/of/Method)Lreturn/Type;@location,<...>
    330 static bool ParseArgs(const std::string& start_options,
    331                       /*out*/BreakpointTargets* targets) {
    332   for (std::string options = start_options;
    333        !options.empty();
    334        options = RemoveLastOption(options)) {
    335     SingleBreakpointTarget target;
    336     std::string next = SubstrOf(options, 0, options.find(','));
    337     if (!ParseSingleBreakpoint(next, /*out*/ &target)) {
    338       LOG(ERROR) << "Unable to parse breakpoint from " << next;
    339       return false;
    340     }
    341     targets->bps.push_back(target);
    342   }
    343   return true;
    344 }
    345 
    346 enum class StartType {
    347   OnAttach, OnLoad,
    348 };
    349 
    350 static jint AgentStart(StartType start,
    351                        JavaVM* vm,
    352                        char* options,
    353                        void* reserved ATTRIBUTE_UNUSED) {
    354   jvmtiEnv* jvmti = nullptr;
    355   jvmtiError error = JVMTI_ERROR_NONE;
    356   {
    357     jint res = 0;
    358     res = vm->GetEnv(reinterpret_cast<void**>(&jvmti), JVMTI_VERSION_1_1);
    359 
    360     if (res != JNI_OK || jvmti == nullptr) {
    361       LOG(ERROR) << "Unable to access JVMTI, error code " << res;
    362       return JNI_ERR;
    363     }
    364   }
    365 
    366   void* bp_target_mem = nullptr;
    367   error = jvmti->Allocate(sizeof(BreakpointTargets),
    368                           reinterpret_cast<unsigned char**>(&bp_target_mem));
    369   if (error != JVMTI_ERROR_NONE) {
    370     LOG(ERROR) << "Unable to alloc memory for breakpoint target data";
    371     return JNI_ERR;
    372   }
    373 
    374   BreakpointTargets* data = new(bp_target_mem) BreakpointTargets;
    375   error = jvmti->SetEnvironmentLocalStorage(data);
    376   if (error != JVMTI_ERROR_NONE) {
    377     LOG(ERROR) << "Unable to set local storage";
    378     return JNI_ERR;
    379   }
    380 
    381   if (!ParseArgs(options, /*out*/data)) {
    382     LOG(ERROR) << "failed to parse breakpoint list!";
    383     return JNI_ERR;
    384   }
    385 
    386   jvmtiCapabilities caps{};
    387   caps.can_generate_breakpoint_events = JNI_TRUE;
    388   caps.can_get_line_numbers           = JNI_TRUE;
    389   caps.can_get_source_file_name       = JNI_TRUE;
    390   caps.can_get_source_debug_extension = JNI_TRUE;
    391   error = jvmti->AddCapabilities(&caps);
    392   if (error != JVMTI_ERROR_NONE) {
    393     LOG(ERROR) << "Unable to set caps";
    394     return JNI_ERR;
    395   }
    396 
    397   jvmtiEventCallbacks callbacks{};
    398   callbacks.Breakpoint = &BreakpointCB;
    399   callbacks.VMInit = &VMInitCB;
    400 
    401   error = jvmti->SetEventCallbacks(&callbacks, static_cast<jint>(sizeof(callbacks)));
    402 
    403   if (error != JVMTI_ERROR_NONE) {
    404     LOG(ERROR) << "Unable to set event callbacks.";
    405     return JNI_ERR;
    406   }
    407 
    408   error = jvmti->SetEventNotificationMode(JVMTI_ENABLE,
    409                                           JVMTI_EVENT_BREAKPOINT,
    410                                           nullptr /* all threads */);
    411   if (error != JVMTI_ERROR_NONE) {
    412     LOG(ERROR) << "Unable to enable breakpoint event";
    413     return JNI_ERR;
    414   }
    415   if (start == StartType::OnAttach) {
    416     JNIEnv* env = nullptr;
    417     jint res = 0;
    418     res = vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_2);
    419     if (res != JNI_OK || env == nullptr) {
    420       LOG(ERROR) << "Unable to get jnienv";
    421       return JNI_ERR;
    422     }
    423     VMInitCB(jvmti, env, nullptr);
    424   } else {
    425     error = jvmti->SetEventNotificationMode(JVMTI_ENABLE,
    426                                             JVMTI_EVENT_VM_INIT,
    427                                             nullptr /* all threads */);
    428     if (error != JVMTI_ERROR_NONE) {
    429       LOG(ERROR) << "Unable to set event vminit";
    430       return JNI_ERR;
    431     }
    432   }
    433   return JNI_OK;
    434 }
    435 
    436 // Late attachment (e.g. 'am attach-agent').
    437 extern "C" JNIEXPORT jint JNICALL Agent_OnAttach(JavaVM *vm, char* options, void* reserved) {
    438   return AgentStart(StartType::OnAttach, vm, options, reserved);
    439 }
    440 
    441 // Early attachment
    442 extern "C" JNIEXPORT jint JNICALL Agent_OnLoad(JavaVM* jvm, char* options, void* reserved) {
    443   return AgentStart(StartType::OnLoad, jvm, options, reserved);
    444 }
    445 
    446 }  // namespace breakpoint_logger
    447 
    448