Merge "ART: Fix os << std::string* errors"
diff --git a/Android.bp b/Android.bp
index 8678fd0..1b66e6f 100644
--- a/Android.bp
+++ b/Android.bp
@@ -42,4 +42,5 @@
"tools/cpp-define-generator",
"tools/dmtracedump",
"tools/titrace",
+ "tools/wrapagentproperties",
]
diff --git a/runtime/jit/profile_compilation_info.cc b/runtime/jit/profile_compilation_info.cc
index 57fc4976..12fa49e 100644
--- a/runtime/jit/profile_compilation_info.cc
+++ b/runtime/jit/profile_compilation_info.cc
@@ -143,8 +143,7 @@
if (data == nullptr) {
return false;
}
- data->AddMethod(flags, ref.index);
- return true;
+ return data->AddMethod(flags, ref.index);
}
bool ProfileCompilationInfo::AddMethodIndex(MethodHotness::Flag flags,
@@ -158,8 +157,7 @@
if (data == nullptr) {
return false;
}
- data->AddMethod(flags, method_idx);
- return true;
+ return data->AddMethod(flags, method_idx);
}
bool ProfileCompilationInfo::AddMethods(const std::vector<ProfileMethodInfo>& methods) {
@@ -592,7 +590,14 @@
// This should always be the case since since the cache map is managed by ProfileCompilationInfo.
DCHECK_EQ(profile_key, result->profile_key);
DCHECK_EQ(profile_index, result->profile_index);
- DCHECK_EQ(num_method_ids, result->num_method_ids);
+
+ if (num_method_ids != result->num_method_ids) {
+ // This should not happen... added to help investigating b/65812889.
+ LOG(ERROR) << "num_method_ids mismatch for dex " << profile_key
+ << ", expected=" << num_method_ids
+ << ", actual=" << result->num_method_ids;
+ return nullptr;
+ }
return result;
}
@@ -1342,8 +1347,8 @@
DexFileData* dex_data = GetOrAddDexFileData(method_ref.dex_file);
if (dex_data != nullptr) {
// TODO: Add inline caches.
- dex_data->AddMethod(static_cast<MethodHotness::Flag>(hotness.GetFlags()), method_ref.index);
- return true;
+ return dex_data->AddMethod(
+ static_cast<MethodHotness::Flag>(hotness.GetFlags()), method_ref.index);
}
return false;
}
@@ -1727,7 +1732,12 @@
}
// Mark a method as executed at least once.
-void ProfileCompilationInfo::DexFileData::AddMethod(MethodHotness::Flag flags, size_t index) {
+bool ProfileCompilationInfo::DexFileData::AddMethod(MethodHotness::Flag flags, size_t index) {
+ if (index >= num_method_ids) {
+ LOG(ERROR) << "Invalid method index " << index << ". num_method_ids=" << num_method_ids;
+ return false;
+ }
+
if ((flags & MethodHotness::kFlagStartup) != 0) {
method_bitmap.StoreBit(MethodBitIndex(/*startup*/ true, index), /*value*/ true);
}
@@ -1739,6 +1749,7 @@
index,
InlineCacheMap(std::less<uint16_t>(), arena_->Adapter(kArenaAllocProfile)));
}
+ return true;
}
ProfileCompilationInfo::MethodHotness ProfileCompilationInfo::DexFileData::GetHotnessInfo(
diff --git a/runtime/jit/profile_compilation_info.h b/runtime/jit/profile_compilation_info.h
index 5c7448f..009554c 100644
--- a/runtime/jit/profile_compilation_info.h
+++ b/runtime/jit/profile_compilation_info.h
@@ -290,7 +290,9 @@
}
for (Iterator it = index_begin; it != index_end; ++it) {
DCHECK_LT(*it, data->num_method_ids);
- data->AddMethod(flags, *it);
+ if (!data->AddMethod(flags, *it)) {
+ return false;
+ }
}
return true;
}
@@ -444,7 +446,7 @@
}
// Mark a method as executed at least once.
- void AddMethod(MethodHotness::Flag flags, size_t index);
+ bool AddMethod(MethodHotness::Flag flags, size_t index);
void MergeBitmap(const DexFileData& other) {
DCHECK_EQ(bitmap_storage.size(), other.bitmap_storage.size());
diff --git a/tools/libjdwp-compat.props b/tools/libjdwp-compat.props
new file mode 100644
index 0000000..c573b24
--- /dev/null
+++ b/tools/libjdwp-compat.props
@@ -0,0 +1,18 @@
+# Copyright 2017 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.
+#
+# These are properties that are needed for RI jdwp to run.
+java.vm.info=mixed mode
+sun.boot.class.path=
+sun.boot.library.path=
diff --git a/tools/run-jdwp-tests.sh b/tools/run-jdwp-tests.sh
index 2e59af9..d0e35ac 100755
--- a/tools/run-jdwp-tests.sh
+++ b/tools/run-jdwp-tests.sh
@@ -45,6 +45,8 @@
debug="no"
verbose="no"
image="-Ximage:/data/art-test/core.art"
+with_jdwp_path=""
+agent_wrapper=""
vm_args=""
# By default, we run the whole JDWP test suite.
test="org.apache.harmony.jpda.tests.share.AllTests"
@@ -89,6 +91,14 @@
# We don't care about jit with the RI
use_jit=false
shift
+ elif [[ $1 == --agent-wrapper ]]; then
+ # Remove the --agent-wrapper from the arguments.
+ args=${args/$1}
+ shift
+ agent_wrapper=${agent_wrapper}${1},
+ # Remove the argument
+ args=${args/$1}
+ shift
elif [[ $1 == -Ximage:* ]]; then
image="$1"
shift
@@ -119,8 +129,7 @@
# Remove the --jdwp-path from the arguments.
args=${args/$1}
shift
- vm_args="${vm_args} --vm-arg -Djpda.settings.debuggeeAgentArgument=\"-agentpath:\""
- vm_args="${vm_args} --vm-arg -Djpda.settings.debuggeeAgentName=$1"
+ with_jdwp_path=$1
# Remove the path from the arguments.
args=${args/$1}
shift
@@ -140,6 +149,10 @@
if [[ $mode == "ri" ]]; then
using_jack="false"
+ if [[ "x$with_jdwp_path" != "x" ]]; then
+ vm_args="${vm_args} --vm-arg -Djpda.settings.debuggeeAgentArgument=-agentpath:${agent_wrapper}"
+ vm_args="${vm_args} --vm-arg -Djpda.settings.debuggeeAgentName=$with_jdwp_path"
+ fi
if [[ "x$image" != "x" ]]; then
echo "Cannot use -Ximage: with --mode=jvm"
exit 1
@@ -148,6 +161,10 @@
exit 1
fi
else
+ if [[ "x$with_jdwp_path" != "x" ]]; then
+ vm_args="${vm_args} --vm-arg -Djpda.settings.debuggeeAgentArgument=-agentpath:${agent_wrapper}"
+ vm_args="${vm_args} --vm-arg -Djpda.settings.debuggeeAgentName=${with_jdwp_path}"
+ fi
vm_args="$vm_args --vm-arg -Xcompiler-option --vm-arg --debuggable"
# Make sure the debuggee doesn't clean up what the debugger has generated.
art_debugee="$art_debugee --no-clean"
diff --git a/tools/wrapagentproperties/Android.bp b/tools/wrapagentproperties/Android.bp
new file mode 100644
index 0000000..c39b81a
--- /dev/null
+++ b/tools/wrapagentproperties/Android.bp
@@ -0,0 +1,66 @@
+//
+// Copyright (C) 2017 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.
+//
+
+// Build variants {target,host} x {debug,ndebug} x {32,64}
+
+cc_defaults {
+ name: "wrapagentproperties-defaults",
+ host_supported: true,
+ srcs: ["wrapagentproperties.cc"],
+ defaults: ["art_defaults"],
+
+ // Note that this tool needs to be built for both 32-bit and 64-bit since it requires
+ // to be same ISA as what it is attached to.
+ compile_multilib: "both",
+
+ shared_libs: [
+ "libbase"
+ ],
+ target: {
+ android: {
+ },
+ host: {
+ },
+ },
+ header_libs: [
+ "libopenjdkjvmti_headers",
+ ],
+ multilib: {
+ lib32: {
+ suffix: "32",
+ },
+ lib64: {
+ suffix: "64",
+ },
+ },
+ symlink_preferred_arch: true,
+}
+
+art_cc_library {
+ name: "libwrapagentproperties",
+ defaults: ["wrapagentproperties-defaults"],
+ shared_libs: [
+ ],
+}
+
+art_cc_library {
+ name: "libwrapagentpropertiesd",
+ defaults: [
+ "art_debug_defaults",
+ "wrapagentproperties-defaults",
+ ],
+ shared_libs: [ ],
+}
diff --git a/tools/wrapagentproperties/README.md b/tools/wrapagentproperties/README.md
new file mode 100644
index 0000000..d968087
--- /dev/null
+++ b/tools/wrapagentproperties/README.md
@@ -0,0 +1,30 @@
+# wrapagentproperties
+
+wrapagentproperties is a JVMTI agent that lets one change the returned values of
+an agents GetSystemPropert{y,ies} calls.
+
+# Usage
+### Build
+> `make libwrapagentproperties` # or 'make libwrapagentpropertiesd' with debugging checks enabled
+
+The libraries will be built for 32-bit, 64-bit, host and target. Below examples
+assume you want to use the 64-bit version.
+
+### Command Line
+#### ART
+> `art -Xplugin:$ANDROID_HOST_OUT/lib64/libopenjdkjvmti.so -agentpath:$ANDROID_HOST_OUT/lib64/libwrapagentproperties.so=/path/to/prop.file,/path/to/agent=agent-args -cp tmp/java/helloworld.dex -Xint helloworld`
+
+* `-Xplugin` and `-agentpath` need to be used, otherwise libtitrace agent will fail during init.
+* If using `libartd.so`, make sure to use the debug version of jvmti.
+
+### prop file format.
+
+The property file is a text file containing the values of java properties you
+wish to override. The format is property=value on each line. Blank lines and
+lines beginning with "#" are ignored.
+
+#### Example prop file
+
+ # abc.prop
+ abc.def=123
+ def.hij=a big deal
diff --git a/tools/wrapagentproperties/wrapagentproperties.cc b/tools/wrapagentproperties/wrapagentproperties.cc
new file mode 100644
index 0000000..dca6270
--- /dev/null
+++ b/tools/wrapagentproperties/wrapagentproperties.cc
@@ -0,0 +1,346 @@
+// Copyright (C) 2017 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 <atomic>
+#include <dlfcn.h>
+#include <iostream>
+#include <fstream>
+#include <iomanip>
+#include <jni.h>
+#include <jvmti.h>
+#include <unordered_map>
+#include <unordered_set>
+#include <memory>
+#include <mutex>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace wrapagentproperties {
+
+using PropMap = std::unordered_map<std::string, std::string>;
+static constexpr const char* kOnLoad = "Agent_OnLoad";
+static constexpr const char* kOnAttach = "Agent_OnAttach";
+static constexpr const char* kOnUnload= "Agent_OnUnload";
+struct ProxyJavaVM;
+using AgentLoadFunction = jint (*)(ProxyJavaVM*, const char*, void*);
+using AgentUnloadFunction = jint (*)(JavaVM*);
+
+// Global namespace. Shared by every usage of this wrapper unfortunately.
+// We need to keep track of them to call Agent_OnUnload.
+static std::mutex unload_mutex;
+
+struct Unloader {
+ AgentUnloadFunction unload;
+ void* dlclose_handle;
+};
+static std::vector<Unloader> unload_functions;
+
+static jint CreateJvmtiEnv(ProxyJavaVM* vm, void** out_env, jint version);
+
+struct ProxyJavaVM {
+ const struct JNIInvokeInterface* functions;
+ JavaVM* real_vm;
+ PropMap* map;
+ void* dlopen_handle;
+ AgentLoadFunction load;
+ AgentLoadFunction attach;
+
+ ProxyJavaVM(JavaVM* vm, const std::string& agent_lib, PropMap* map)
+ : functions(CreateInvokeInterface()),
+ real_vm(vm),
+ map(map),
+ dlopen_handle(dlopen(agent_lib.c_str(), RTLD_LAZY)),
+ load(nullptr),
+ attach(nullptr) {
+ CHECK(dlopen_handle != nullptr) << "unable to open " << agent_lib;
+ {
+ std::lock_guard<std::mutex> lk(unload_mutex);
+ unload_functions.push_back({
+ reinterpret_cast<AgentUnloadFunction>(dlsym(dlopen_handle, kOnUnload)),
+ dlopen_handle
+ });
+ }
+ attach = reinterpret_cast<AgentLoadFunction>(dlsym(dlopen_handle, kOnAttach));
+ load = reinterpret_cast<AgentLoadFunction>(dlsym(dlopen_handle, kOnLoad));
+ }
+
+ // TODO Use this to cleanup
+ static jint WrapDestroyJavaVM(ProxyJavaVM* vm) {
+ return vm->real_vm->DestroyJavaVM();
+ }
+ static jint WrapAttachCurrentThread(ProxyJavaVM* vm, JNIEnv** env, void* res) {
+ return vm->real_vm->AttachCurrentThread(env, res);
+ }
+ static jint WrapDetachCurrentThread(ProxyJavaVM* vm) {
+ return vm->real_vm->DetachCurrentThread();
+ }
+ static jint WrapAttachCurrentThreadAsDaemon(ProxyJavaVM* vm, JNIEnv** env, void* res) {
+ return vm->real_vm->AttachCurrentThreadAsDaemon(env, res);
+ }
+
+ static jint WrapGetEnv(ProxyJavaVM* vm, void** out_env, jint version) {
+ switch (version) {
+ case JVMTI_VERSION:
+ case JVMTI_VERSION_1:
+ case JVMTI_VERSION_1_1:
+ case JVMTI_VERSION_1_2:
+ return CreateJvmtiEnv(vm, out_env, version);
+ default:
+ if ((version & 0x30000000) == 0x30000000) {
+ LOG(ERROR) << "Version number 0x" << std::hex << version << " looks like a JVMTI "
+ << "version but it is not one that is recognized. The wrapper might not "
+ << "function correctly! Continuing anyway.";
+ }
+ return vm->real_vm->GetEnv(out_env, version);
+ }
+ }
+
+ static JNIInvokeInterface* CreateInvokeInterface() {
+ JNIInvokeInterface* out = new JNIInvokeInterface;
+ memset(out, 0, sizeof(JNIInvokeInterface));
+ out->DestroyJavaVM = reinterpret_cast<jint (*)(JavaVM*)>(WrapDestroyJavaVM);
+ out->AttachCurrentThread =
+ reinterpret_cast<jint(*)(JavaVM*, JNIEnv**, void*)>(WrapAttachCurrentThread);
+ out->DetachCurrentThread = reinterpret_cast<jint(*)(JavaVM*)>(WrapDetachCurrentThread);
+ out->GetEnv = reinterpret_cast<jint(*)(JavaVM*, void**, jint)>(WrapGetEnv);
+ out->AttachCurrentThreadAsDaemon =
+ reinterpret_cast<jint(*)(JavaVM*, JNIEnv**, void*)>(WrapAttachCurrentThreadAsDaemon);
+ return out;
+ }
+};
+
+
+struct ExtraJvmtiInterface : public jvmtiInterface_1_ {
+ ProxyJavaVM* proxy_vm;
+ jvmtiInterface_1_ const* original_interface;
+
+ static jvmtiError WrapDisposeEnvironment(jvmtiEnv* env) {
+ ExtraJvmtiInterface* funcs = reinterpret_cast<ExtraJvmtiInterface*>(
+ const_cast<jvmtiInterface_1_*>(env->functions));
+ jvmtiInterface_1_** out_iface = const_cast<jvmtiInterface_1_**>(&env->functions);
+ *out_iface = const_cast<jvmtiInterface_1_*>(funcs->original_interface);
+ funcs->original_interface->Deallocate(env, reinterpret_cast<unsigned char*>(funcs));
+ jvmtiError res = (*out_iface)->DisposeEnvironment(env);
+ return res;
+ }
+
+ static jvmtiError WrapGetSystemProperty(jvmtiEnv* env, const char* prop, char** out) {
+ ExtraJvmtiInterface* funcs = reinterpret_cast<ExtraJvmtiInterface*>(
+ const_cast<jvmtiInterface_1_*>(env->functions));
+ if (funcs->proxy_vm->map->find(prop) != funcs->proxy_vm->map->end()) {
+ std::string str_prop(prop);
+ const std::string& val = funcs->proxy_vm->map->at(str_prop);
+ jvmtiError res = env->Allocate(val.size() + 1, reinterpret_cast<unsigned char**>(out));
+ if (res != JVMTI_ERROR_NONE) {
+ return res;
+ }
+ strcpy(*out, val.c_str());
+ return JVMTI_ERROR_NONE;
+ } else {
+ return funcs->original_interface->GetSystemProperty(env, prop, out);
+ }
+ }
+
+ static jvmtiError WrapGetSystemProperties(jvmtiEnv* env, jint* cnt, char*** prop_ptr) {
+ ExtraJvmtiInterface* funcs = reinterpret_cast<ExtraJvmtiInterface*>(
+ const_cast<jvmtiInterface_1_*>(env->functions));
+ jint init_cnt;
+ char** init_prop_ptr;
+ jvmtiError res = funcs->original_interface->GetSystemProperties(env, &init_cnt, &init_prop_ptr);
+ if (res != JVMTI_ERROR_NONE) {
+ return res;
+ }
+ std::unordered_set<std::string> all_props;
+ for (const auto& p : *funcs->proxy_vm->map) {
+ all_props.insert(p.first);
+ }
+ for (jint i = 0; i < init_cnt; i++) {
+ all_props.insert(init_prop_ptr[i]);
+ env->Deallocate(reinterpret_cast<unsigned char*>(init_prop_ptr[i]));
+ }
+ env->Deallocate(reinterpret_cast<unsigned char*>(init_prop_ptr));
+ *cnt = all_props.size();
+ res = env->Allocate(all_props.size() * sizeof(char*),
+ reinterpret_cast<unsigned char**>(prop_ptr));
+ if (res != JVMTI_ERROR_NONE) {
+ return res;
+ }
+ char** out_prop_ptr = *prop_ptr;
+ jint i = 0;
+ for (const std::string& p : all_props) {
+ res = env->Allocate(p.size() + 1, reinterpret_cast<unsigned char**>(&out_prop_ptr[i]));
+ if (res != JVMTI_ERROR_NONE) {
+ return res;
+ }
+ strcpy(out_prop_ptr[i], p.c_str());
+ i++;
+ }
+ CHECK_EQ(i, *cnt);
+ return JVMTI_ERROR_NONE;
+ }
+
+ static jvmtiError WrapSetSystemProperty(jvmtiEnv* env, const char* prop, const char* val) {
+ ExtraJvmtiInterface* funcs = reinterpret_cast<ExtraJvmtiInterface*>(
+ const_cast<jvmtiInterface_1_*>(env->functions));
+ jvmtiError res = funcs->original_interface->SetSystemProperty(env, prop, val);
+ if (res != JVMTI_ERROR_NONE) {
+ return res;
+ }
+ if (funcs->proxy_vm->map->find(prop) != funcs->proxy_vm->map->end()) {
+ funcs->proxy_vm->map->at(prop) = val;
+ }
+ return JVMTI_ERROR_NONE;
+ }
+
+ // TODO It would be way better to actually set up a full proxy like we did for JavaVM but the
+ // number of functions makes it not worth it.
+ static jint SetupProxyJvmtiEnv(ProxyJavaVM* vm, jvmtiEnv* real_env) {
+ ExtraJvmtiInterface* new_iface = nullptr;
+ if (JVMTI_ERROR_NONE != real_env->Allocate(sizeof(ExtraJvmtiInterface),
+ reinterpret_cast<unsigned char**>(&new_iface))) {
+ LOG(ERROR) << "Could not allocate extra space for new jvmti interface struct";
+ return JNI_ERR;
+ }
+ memcpy(new_iface, real_env->functions, sizeof(jvmtiInterface_1_));
+ new_iface->proxy_vm = vm;
+ new_iface->original_interface = real_env->functions;
+
+ // Replace these functions with the new ones.
+ new_iface->DisposeEnvironment = WrapDisposeEnvironment;
+ new_iface->GetSystemProperty = WrapGetSystemProperty;
+ new_iface->GetSystemProperties = WrapGetSystemProperties;
+ new_iface->SetSystemProperty = WrapSetSystemProperty;
+
+ // Replace the functions table with our new one with replaced functions.
+ jvmtiInterface_1_** out_iface = const_cast<jvmtiInterface_1_**>(&real_env->functions);
+ *out_iface = new_iface;
+ return JNI_OK;
+ }
+};
+
+static jint CreateJvmtiEnv(ProxyJavaVM* vm, void** out_env, jint version) {
+ jint res = vm->real_vm->GetEnv(out_env, version);
+ if (res != JNI_OK) {
+ LOG(WARNING) << "Could not create jvmtiEnv to proxy!";
+ return res;
+ }
+ return ExtraJvmtiInterface::SetupProxyJvmtiEnv(vm, reinterpret_cast<jvmtiEnv*>(*out_env));
+}
+
+enum class StartType {
+ OnAttach, OnLoad,
+};
+
+static jint CallNextAgent(StartType start,
+ ProxyJavaVM* vm,
+ std::string options,
+ void* reserved) {
+ // TODO It might be good to set it up so that the library is unloaded even if no jvmtiEnv's are
+ // created but this isn't expected to be common so we will just not bother.
+ return ((start == StartType::OnLoad) ? vm->load : vm->attach)(vm, options.c_str(), reserved);
+}
+
+static std::string substrOf(const std::string& s, size_t start, size_t end) {
+ if (end == start) {
+ return "";
+ } else if (end == std::string::npos) {
+ end = s.size();
+ }
+ return s.substr(start, end - start);
+}
+
+static PropMap* ReadPropMap(const std::string& file) {
+ std::unique_ptr<PropMap> map(new PropMap);
+ std::ifstream prop_file(file, std::ios::in);
+ std::string line;
+ while (std::getline(prop_file, line)) {
+ if (line.size() == 0 || line[0] == '#') {
+ continue;
+ }
+ if (line.find('=') == std::string::npos) {
+ LOG(INFO) << "line: " << line << " didn't have a '='";
+ return nullptr;
+ }
+ std::string prop = substrOf(line, 0, line.find('='));
+ std::string val = substrOf(line, line.find('=') + 1, std::string::npos);
+ LOG(INFO) << "Overriding property " << std::quoted(prop) << " new value is "
+ << std::quoted(val);
+ map->insert({prop, val});
+ }
+ return map.release();
+}
+
+static bool ParseArgs(const std::string& options,
+ /*out*/std::string* prop_file,
+ /*out*/std::string* agent_lib,
+ /*out*/std::string* agent_options) {
+ if (options.find(',') == std::string::npos) {
+ LOG(ERROR) << "No agent lib in " << options;
+ return false;
+ }
+ *prop_file = substrOf(options, 0, options.find(','));
+ *agent_lib = substrOf(options, options.find(',') + 1, options.find('='));
+ if (options.find('=') != std::string::npos) {
+ *agent_options = substrOf(options, options.find('=') + 1, std::string::npos);
+ } else {
+ *agent_options = "";
+ }
+ return true;
+}
+
+static jint AgentStart(StartType start, JavaVM* vm, char* options, void* reserved) {
+ std::string agent_lib;
+ std::string agent_options;
+ std::string prop_file;
+ if (!ParseArgs(options, /*out*/ &prop_file, /*out*/ &agent_lib, /*out*/ &agent_options)) {
+ return JNI_ERR;
+ }
+ // It would be good to not leak these but since they will live for almost the whole program run
+ // anyway it isn't a huge deal.
+ PropMap* map = ReadPropMap(prop_file);
+ if (map == nullptr) {
+ LOG(ERROR) << "unable to read property file at " << std::quoted(prop_file) << "!";
+ return JNI_ERR;
+ }
+ ProxyJavaVM* proxy = new ProxyJavaVM(vm, agent_lib, map);
+ LOG(INFO) << "Chaining to next agent[" << std::quoted(agent_lib) << "] options=["
+ << std::quoted(agent_options) << "]";
+ return CallNextAgent(start, proxy, agent_options, reserved);
+}
+
+// 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
+// (e.g. 'java -agentpath:/path/to/libwrapagentproperties.so=/path/to/propfile,/path/to/wrapped.so=[ops]').
+extern "C" JNIEXPORT jint JNICALL Agent_OnLoad(JavaVM* jvm, char* options, void* reserved) {
+ return AgentStart(StartType::OnLoad, jvm, options, reserved);
+}
+
+extern "C" JNIEXPORT void JNICALL Agent_OnUnload(JavaVM* jvm) {
+ std::lock_guard<std::mutex> lk(unload_mutex);
+ for (const Unloader& u : unload_functions) {
+ u.unload(jvm);
+ dlclose(u.dlclose_handle);
+ }
+ unload_functions.clear();
+}
+
+} // namespace wrapagentproperties
+