jvmti-agents/simple-profile/simple_profile.cc

// Copyright (C) 2020 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//

#include <android-base/logging.h>
#include <fcntl.h>
#include <jni.h>
#include <jvmti.h>

#include <atomic>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <memory>
#include <sstream>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>

#include "android-base/unique_fd.h"
#include "nativehelper/scoped_local_ref.h"

namespace simple_profile {

static constexpr jint kArtTiVersion = JVMTI_VERSION_1_2 | 0x40000000;

#define CHECK_JVMTI(a) CHECK_EQ(JVMTI_ERROR_NONE, a)

struct DataDefinition {
  std::string_view class_name;
  std::string_view method_name;
  std::string_view method_descriptor;
  uint64_t count;
};

std::ostream& operator<<(std::ostream& os, const DataDefinition& dd) {
  return os << "{\"class_name\":\"" << dd.class_name << "\",\"method_name\":\"" << dd.method_name
            << "\",\"method_descriptor\":\"" << dd.method_descriptor << "\",\"count\":" << dd.count
            << "}";
}

class SimpleProfileData {
 public:
  SimpleProfileData(
      jvmtiEnv* env, std::string out_fd_name, int fd, bool dump_on_shutdown, bool dump_on_main_stop)
      : dump_id_(0),
        out_fd_name_(std::move(out_fd_name)),
        out_fd_(fd),
        shutdown_(false),
        dump_on_shutdown_(dump_on_shutdown || dump_on_main_stop),
        dump_on_main_stop_(dump_on_main_stop) {
    CHECK_JVMTI(env->CreateRawMonitor("simple_profile_mon", &mon_));
    method_counts_.reserve(10000);
  }

  void Dump(jvmtiEnv* jvmti);
  void Enter(jvmtiEnv* jvmti, JNIEnv* env, jmethodID meth);

  void RunDumpLoop(jvmtiEnv* jvmti, JNIEnv* env);

  static SimpleProfileData* GetProfileData(jvmtiEnv* env) {
    void* data;
    CHECK_JVMTI(env->GetEnvironmentLocalStorage(&data));
    return static_cast<SimpleProfileData*>(data);
  }

  void FinishInitialization(jvmtiEnv* jvmti, JNIEnv* jni, jthread cur);
  void Shutdown(jvmtiEnv* jvmti, JNIEnv* jni);

 private:
  void DoDump(jvmtiEnv* jvmti, JNIEnv* jni, const std::unordered_map<jmethodID, uint64_t>& copy);

  jlong dump_id_;
  jrawMonitorID mon_;
  std::string out_fd_name_;
  int out_fd_;
  std::unordered_map<jmethodID, uint64_t> method_counts_;
  bool shutdown_;
  bool dump_on_shutdown_;
  bool dump_on_main_stop_;
};

struct ScopedJvmtiMonitor {
 public:
  ScopedJvmtiMonitor(jvmtiEnv* env, jrawMonitorID mon) : jvmti_(env), mon_(mon) {
    CHECK_JVMTI(jvmti_->RawMonitorEnter(mon_));
  }

  ~ScopedJvmtiMonitor() {
    CHECK_JVMTI(jvmti_->RawMonitorExit(mon_));
  }

  void Notify() {
    CHECK_JVMTI(jvmti_->RawMonitorNotifyAll(mon_));
  }

  void Wait() {
    CHECK_JVMTI(jvmti_->RawMonitorWait(mon_, 0));
  }

 private:
  jvmtiEnv* jvmti_;
  jrawMonitorID mon_;
};

void SimpleProfileData::Enter(jvmtiEnv* jvmti, JNIEnv* env, jmethodID meth) {
  ScopedJvmtiMonitor sjm(jvmti, mon_);
  // Keep all classes from being unloaded to allow us to know we can get the method info later.
  jclass tmp;
  CHECK_JVMTI(jvmti->GetMethodDeclaringClass(meth, &tmp));
  ScopedLocalRef<jclass> klass(env, tmp);
  jlong tag;
  CHECK_JVMTI(jvmti->GetTag(klass.get(), &tag));
  if (tag == 0) {
    CHECK_JVMTI(jvmti->SetTag(klass.get(), 1u));
    env->NewGlobalRef(klass.get());
  }
  method_counts_.insert({ meth, 0u }).first->second++;
}

void SimpleProfileData::Dump(jvmtiEnv* jvmti) {
  ScopedJvmtiMonitor sjm(jvmti, mon_);
  dump_id_++;
  sjm.Notify();
}

void SimpleProfileData::RunDumpLoop(jvmtiEnv* jvmti, JNIEnv* env) {
  jlong current_id = 0;
  do {
    std::unordered_map<jmethodID, uint64_t> copy;
    {
      ScopedJvmtiMonitor sjm(jvmti, mon_);
      while (!shutdown_ && current_id == dump_id_) {
        sjm.Wait();
      }
      if (shutdown_) {
        break;
      }
      current_id = dump_id_;
      copy = method_counts_;
    }
    DoDump(jvmti, env, std::move(copy));
  } while (true);
}

void SimpleProfileData::Shutdown(jvmtiEnv* jvmti, JNIEnv* jni) {
  std::unordered_map<jmethodID, uint64_t> copy;
  {
    ScopedJvmtiMonitor sjm(jvmti, mon_);
    if (shutdown_) {
      return;
    }
    shutdown_ = true;
    copy = method_counts_;
    sjm.Notify();
  }
  if (dump_on_shutdown_) {
    DoDump(jvmti, jni, std::move(copy));
  }
}

void SimpleProfileData::FinishInitialization(jvmtiEnv* jvmti, JNIEnv* env, jthread cur) {
  // Finish up startup.
  // Create a Thread object.
  std::string name = std::string("profile dump Thread: ") + this->out_fd_name_;
  ScopedLocalRef<jobject> thread_name(env, env->NewStringUTF(name.c_str()));
  CHECK_NE(thread_name.get(), nullptr);

  ScopedLocalRef<jclass> thread_klass(env, env->FindClass("java/lang/Thread"));
  CHECK_NE(thread_klass.get(), nullptr);
  ScopedLocalRef<jobject> thread(env, env->AllocObject(thread_klass.get()));
  CHECK_NE(thread.get(), nullptr);
  jmethodID initID = env->GetMethodID(thread_klass.get(), "<init>", "(Ljava/lang/String;)V");
  jmethodID setDaemonId = env->GetMethodID(thread_klass.get(), "setDaemon", "(Z)V");
  CHECK_NE(initID, nullptr);
  CHECK_NE(setDaemonId, nullptr);
  env->CallNonvirtualVoidMethod(thread.get(), thread_klass.get(), initID, thread_name.get());
  env->CallVoidMethod(thread.get(), setDaemonId, JNI_TRUE);
  CHECK(!env->ExceptionCheck());

  CHECK_JVMTI(jvmti->RunAgentThread(
      thread.get(),
      [](jvmtiEnv* jvmti, JNIEnv* jni, [[maybe_unused]] void* unused_data) {
        SimpleProfileData* data = SimpleProfileData::GetProfileData(jvmti);
        data->RunDumpLoop(jvmti, jni);
      },
      nullptr,
      JVMTI_THREAD_NORM_PRIORITY));

  CHECK_JVMTI(jvmti->SetEventNotificationMode(JVMTI_ENABLE, JVMTI_EVENT_METHOD_ENTRY, nullptr));
  CHECK_JVMTI(
      jvmti->SetEventNotificationMode(JVMTI_ENABLE, JVMTI_EVENT_DATA_DUMP_REQUEST, nullptr));
  if (dump_on_main_stop_) {
    CHECK_JVMTI(jvmti->SetEventNotificationMode(JVMTI_ENABLE, JVMTI_EVENT_THREAD_END, cur));
  }
  CHECK_JVMTI(jvmti->SetEventNotificationMode(JVMTI_ENABLE, JVMTI_EVENT_VM_DEATH, nullptr));
}

class ScopedClassInfo {
 public:
  ScopedClassInfo(jvmtiEnv* jvmti_env, jclass c)
      : jvmti_env_(jvmti_env), class_(c), name_(nullptr), generic_(nullptr) {}

  ~ScopedClassInfo() {
    if (class_ != nullptr) {
      jvmti_env_->Deallocate(reinterpret_cast<unsigned char*>(name_));
      jvmti_env_->Deallocate(reinterpret_cast<unsigned char*>(generic_));
    }
  }

  bool Init() {
    if (class_ == nullptr) {
      name_ = const_cast<char*>("<NONE>");
      generic_ = const_cast<char*>("<NONE>");
      return true;
    } else {
      return jvmti_env_->GetClassSignature(class_, &name_, &generic_) == JVMTI_ERROR_NONE;
    }
  }

  jclass GetClass() const {
    return class_;
  }
  const char* GetName() const {
    return name_;
  }
  // Generic type parameters, whatever is in the <> for a class
  const char* GetGeneric() const {
    return generic_;
  }

 private:
  jvmtiEnv* jvmti_env_;
  jclass class_;
  char* name_;
  char* generic_;
};

class ScopedMethodInfo {
 public:
  ScopedMethodInfo(jvmtiEnv* jvmti_env, JNIEnv* env, jmethodID method)
      : jvmti_env_(jvmti_env),
        env_(env),
        method_(method),
        declaring_class_(nullptr),
        class_info_(nullptr),
        name_(nullptr),
        signature_(nullptr),
        generic_(nullptr) {}

  ~ScopedMethodInfo() {
    env_->DeleteLocalRef(declaring_class_);
    jvmti_env_->Deallocate(reinterpret_cast<unsigned char*>(name_));
    jvmti_env_->Deallocate(reinterpret_cast<unsigned char*>(signature_));
    jvmti_env_->Deallocate(reinterpret_cast<unsigned char*>(generic_));
  }

  bool Init() {
    if (jvmti_env_->GetMethodDeclaringClass(method_, &declaring_class_) != JVMTI_ERROR_NONE) {
      LOG(INFO) << "No decl";
      return false;
    }
    class_info_.reset(new ScopedClassInfo(jvmti_env_, declaring_class_));
    return class_info_->Init() &&
           (jvmti_env_->GetMethodName(method_, &name_, &signature_, &generic_) == JVMTI_ERROR_NONE);
  }

  const ScopedClassInfo& GetDeclaringClassInfo() const {
    return *class_info_;
  }

  jclass GetDeclaringClass() const {
    return declaring_class_;
  }

  const char* GetName() const {
    return name_;
  }

  const char* GetSignature() const {
    return signature_;
  }

  const char* GetGeneric() const {
    return generic_;
  }

 private:
  jvmtiEnv* jvmti_env_;
  JNIEnv* env_;
  jmethodID method_;
  jclass declaring_class_;
  std::unique_ptr<ScopedClassInfo> class_info_;
  char* name_;
  char* signature_;
  char* generic_;

  friend std::ostream& operator<<(std::ostream& os, ScopedMethodInfo const& method);
};

std::ostream& operator<<(std::ostream& os, const ScopedMethodInfo* method) {
  return os << *method;
}

std::ostream& operator<<(std::ostream& os, ScopedMethodInfo const& method) {
  return os << method.GetDeclaringClassInfo().GetName() << "->" << method.GetName()
            << method.GetSignature();
}

void SimpleProfileData::DoDump(jvmtiEnv* jvmti,
                               JNIEnv* jni,
                               const std::unordered_map<jmethodID, uint64_t>& copy) {
  std::ostringstream oss;
  oss << "[";
  bool is_first = true;
  for (auto [meth, cnt] : copy) {
    ScopedMethodInfo smi(jvmti, jni, meth);
    if (!smi.Init()) {
      continue;
    }
    if (!is_first) {
      oss << "," << std::endl;
    }
    is_first = false;
    oss << DataDefinition {
      .class_name = smi.GetDeclaringClassInfo().GetName(),
      .method_name = smi.GetName(),
      .method_descriptor = smi.GetSignature(),
      .count = cnt,
    };
  }
  oss << "]";
  CHECK_GE(TEMP_FAILURE_RETRY(write(out_fd_, oss.str().c_str(), oss.str().size())), 0)
      << strerror(errno) << out_fd_ << " " << out_fd_name_;
  fsync(out_fd_);
}

static void DataDumpCb(jvmtiEnv* jvmti_env) {
  SimpleProfileData* data = SimpleProfileData::GetProfileData(jvmti_env);
  data->Dump(jvmti_env);
}

static void MethodEntryCB(jvmtiEnv* jvmti_env,
                          JNIEnv* env,
                          [[maybe_unused]] jthread thread,
                          jmethodID method) {
  SimpleProfileData* data = SimpleProfileData::GetProfileData(jvmti_env);
  data->Enter(jvmti_env, env, method);
}

static void VMInitCB(jvmtiEnv* jvmti, JNIEnv* env, jthread thr) {
  SimpleProfileData* data = SimpleProfileData::GetProfileData(jvmti);
  data->FinishInitialization(jvmti, env, thr);
}
static void VMDeathCB(jvmtiEnv* jvmti, JNIEnv* env) {
  SimpleProfileData* data = SimpleProfileData::GetProfileData(jvmti);
  data->Shutdown(jvmti, env);
}

// Fills targets with the breakpoints to add.
// Lname/of/Klass;->methodName(Lsig/of/Method)Lreturn/Type;@location,<...>
static bool ParseArgs(const std::string& start_options,
                      /*out*/ std::string* fd_name,
                      /*out*/ int* fd,
                      /*out*/ bool* dump_on_shutdown,
                      /*out*/ bool* dump_on_main_stop) {
  std::istringstream iss(start_options);
  std::string item;
  *dump_on_main_stop = false;
  *dump_on_shutdown = false;
  bool has_fd = false;
  while (std::getline(iss, item, ',')) {
    if (item == "dump_on_shutdown") {
      *dump_on_shutdown = true;
    } else if (item == "dump_on_main_stop") {
      *dump_on_main_stop = true;
    } else if (has_fd) {
      LOG(ERROR) << "Too many args!";
      return false;
    } else {
      has_fd = true;
      *fd_name = item;
      *fd = TEMP_FAILURE_RETRY(open(fd_name->c_str(), O_WRONLY | O_CLOEXEC | O_CREAT, 00666));
      CHECK_GE(*fd, 0) << strerror(errno);
    }
  }
  return has_fd;
}

enum class StartType {
  OnAttach,
  OnLoad,
};

static jint SetupJvmtiEnv(JavaVM* vm, jvmtiEnv** jvmti) {
  jint res = 0;
  res = vm->GetEnv(reinterpret_cast<void**>(jvmti), JVMTI_VERSION_1_1);

  if (res != JNI_OK || *jvmti == nullptr) {
    LOG(ERROR) << "Unable to access JVMTI, error code " << res;
    return vm->GetEnv(reinterpret_cast<void**>(jvmti), kArtTiVersion);
  }
  return res;
}

static jint AgentStart(StartType start,
                       JavaVM* vm,
                       const char* options,
                       [[maybe_unused]] void* reserved) {
  if (options == nullptr) {
    options = "";
  }
  jvmtiEnv* jvmti = nullptr;
  jvmtiError error = JVMTI_ERROR_NONE;
  {
    jint res = 0;
    res = SetupJvmtiEnv(vm, &jvmti);

    if (res != JNI_OK || jvmti == nullptr) {
      LOG(ERROR) << "Unable to access JVMTI, error code " << res;
      return JNI_ERR;
    }
  }

  int fd;
  std::string fd_name;
  bool dump_on_shutdown;
  bool dump_on_main_stop;
  if (!ParseArgs(options,
                 /*out*/ &fd_name,
                 /*out*/ &fd,
                 /*out*/ &dump_on_shutdown,
                 /*out*/ &dump_on_main_stop)) {
    LOG(ERROR) << "failed to get output file from " << options << "!";
    return JNI_ERR;
  }

  void* data_mem = nullptr;
  error = jvmti->Allocate(sizeof(SimpleProfileData), reinterpret_cast<unsigned char**>(&data_mem));
  if (error != JVMTI_ERROR_NONE) {
    LOG(ERROR) << "Unable to alloc memory for breakpoint target data";
    return JNI_ERR;
  }

  SimpleProfileData* data =
      new (data_mem) SimpleProfileData(jvmti, fd_name, fd, dump_on_shutdown, dump_on_main_stop);
  error = jvmti->SetEnvironmentLocalStorage(data);
  if (error != JVMTI_ERROR_NONE) {
    LOG(ERROR) << "Unable to set local storage";
    return JNI_ERR;
  }

  jvmtiCapabilities caps {};
  caps.can_generate_method_entry_events = JNI_TRUE;
  caps.can_tag_objects = JNI_TRUE;
  error = jvmti->AddCapabilities(&caps);
  if (error != JVMTI_ERROR_NONE) {
    LOG(ERROR) << "Unable to set caps";
    return JNI_ERR;
  }

  jvmtiEventCallbacks callbacks {};
  callbacks.MethodEntry = &MethodEntryCB;
  callbacks.VMInit = &VMInitCB;
  callbacks.DataDumpRequest = &DataDumpCb;
  callbacks.VMDeath = &VMDeathCB;
  callbacks.ThreadEnd = [](jvmtiEnv* env, JNIEnv* jni, [[maybe_unused]] jthread thr) {
    VMDeathCB(env, jni);
  };

  error = jvmti->SetEventCallbacks(&callbacks, static_cast<jint>(sizeof(callbacks)));

  if (error != JVMTI_ERROR_NONE) {
    LOG(ERROR) << "Unable to set event callbacks.";
    return JNI_ERR;
  }

  if (start == StartType::OnAttach) {
    JNIEnv* env = nullptr;
    jint res = 0;
    res = vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_2);
    if (res != JNI_OK || env == nullptr) {
      LOG(ERROR) << "Unable to get jnienv";
      return JNI_ERR;
    }
    jthread temp;
    ScopedLocalRef<jthread> cur(env, nullptr);
    CHECK_JVMTI(jvmti->GetCurrentThread(&temp));
    cur.reset(temp);
    VMInitCB(jvmti, env, cur.get());
  } else {
    error = jvmti->SetEventNotificationMode(
        JVMTI_ENABLE, JVMTI_EVENT_VM_INIT, nullptr /* all threads */);
    if (error != JVMTI_ERROR_NONE) {
      LOG(ERROR) << "Unable to set event vminit";
      return JNI_ERR;
    }
  }
  return JNI_OK;
}

// Late attachment (e.g. 'am attach-agent').
extern "C" JNIEXPORT jint JNICALL Agent_OnAttach(JavaVM* vm, char* options, void* reserved) {
  return AgentStart(StartType::OnAttach, vm, options, reserved);
}

// Early attachment
extern "C" JNIEXPORT jint JNICALL Agent_OnLoad(JavaVM* jvm, char* options, void* reserved) {
  return AgentStart(StartType::OnLoad, jvm, options, reserved);
}

}  // namespace simple_profile