/*
|
* 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 <stdio.h>
|
|
#include <mutex>
|
#include <string>
|
#include <vector>
|
|
#include "android-base/logging.h"
|
#include "android-base/stringprintf.h"
|
#include "jni.h"
|
#include "jvmti.h"
|
#include "scoped_local_ref.h"
|
|
// Test infrastructure
|
#include "jni_helper.h"
|
#include "jvmti_helper.h"
|
#include "test_env.h"
|
#include "ti_macros.h"
|
|
namespace art {
|
namespace Test924Threads {
|
|
struct WaiterStruct {
|
std::atomic<bool> started;
|
std::atomic<bool> finish;
|
};
|
|
extern "C" JNIEXPORT jlong JNICALL Java_art_Test924_nativeWaiterStructAlloc(
|
JNIEnv* env, jclass TestClass ATTRIBUTE_UNUSED) {
|
WaiterStruct* s = nullptr;
|
if (JvmtiErrorToException(env,
|
jvmti_env,
|
jvmti_env->Allocate(sizeof(WaiterStruct),
|
reinterpret_cast<unsigned char**>(&s)))) {
|
return 0;
|
}
|
s->started = false;
|
s->finish = false;
|
return static_cast<jlong>(reinterpret_cast<intptr_t>(s));
|
}
|
|
extern "C" JNIEXPORT void JNICALL Java_art_Test924_nativeWaiterStructWaitForNative(
|
JNIEnv* env ATTRIBUTE_UNUSED, jclass TestClass ATTRIBUTE_UNUSED, jlong waiter_struct) {
|
WaiterStruct* s = reinterpret_cast<WaiterStruct*>(static_cast<intptr_t>(waiter_struct));
|
while (!s->started) { }
|
}
|
|
extern "C" JNIEXPORT void JNICALL Java_art_Test924_nativeWaiterStructFinish(
|
JNIEnv* env ATTRIBUTE_UNUSED, jclass TestClass ATTRIBUTE_UNUSED, jlong waiter_struct) {
|
WaiterStruct* s = reinterpret_cast<WaiterStruct*>(static_cast<intptr_t>(waiter_struct));
|
s->finish = true;
|
}
|
|
extern "C" JNIEXPORT void JNICALL Java_art_Test924_nativeLoop(JNIEnv* env,
|
jclass TestClass ATTRIBUTE_UNUSED,
|
jlong waiter_struct) {
|
WaiterStruct* s = reinterpret_cast<WaiterStruct*>(static_cast<intptr_t>(waiter_struct));
|
s->started = true;
|
while (!s->finish) { }
|
JvmtiErrorToException(env, jvmti_env, jvmti_env->Deallocate(reinterpret_cast<unsigned char*>(s)));
|
}
|
|
// private static native Thread getCurrentThread();
|
// private static native Object[] getThreadInfo(Thread t);
|
|
extern "C" JNIEXPORT jthread JNICALL Java_art_Test924_getCurrentThread(
|
JNIEnv* env, jclass Main_klass ATTRIBUTE_UNUSED) {
|
jthread thread = nullptr;
|
jvmtiError result = jvmti_env->GetCurrentThread(&thread);
|
if (JvmtiErrorToException(env, jvmti_env, result)) {
|
return nullptr;
|
}
|
return thread;
|
}
|
|
extern "C" JNIEXPORT jobjectArray JNICALL Java_art_Test924_getThreadInfo(
|
JNIEnv* env, jclass Main_klass ATTRIBUTE_UNUSED, jthread thread) {
|
jvmtiThreadInfo info;
|
memset(&info, 0, sizeof(jvmtiThreadInfo));
|
|
jvmtiError result = jvmti_env->GetThreadInfo(thread, &info);
|
if (JvmtiErrorToException(env, jvmti_env, result)) {
|
return nullptr;
|
}
|
|
auto callback = [&](jint component_index) -> jobject {
|
switch (component_index) {
|
// The name.
|
case 0:
|
return (info.name == nullptr) ? nullptr : env->NewStringUTF(info.name);
|
|
// The priority. Use a string for simplicity of construction.
|
case 1:
|
return env->NewStringUTF(android::base::StringPrintf("%d", info.priority).c_str());
|
|
// Whether it's a daemon. Use a string for simplicity of construction.
|
case 2:
|
return env->NewStringUTF(info.is_daemon == JNI_TRUE ? "true" : "false");
|
|
// The thread group;
|
case 3:
|
return env->NewLocalRef(info.thread_group);
|
|
// The context classloader.
|
case 4:
|
return env->NewLocalRef(info.context_class_loader);
|
}
|
LOG(FATAL) << "Should not reach here";
|
UNREACHABLE();
|
};
|
jobjectArray ret = CreateObjectArray(env, 5, "java/lang/Object", callback);
|
|
jvmti_env->Deallocate(reinterpret_cast<unsigned char*>(info.name));
|
if (info.thread_group != nullptr) {
|
env->DeleteLocalRef(info.thread_group);
|
}
|
if (info.context_class_loader != nullptr) {
|
env->DeleteLocalRef(info.context_class_loader);
|
}
|
|
return ret;
|
}
|
|
extern "C" JNIEXPORT jint JNICALL Java_art_Test924_getThreadState(
|
JNIEnv* env, jclass Main_klass ATTRIBUTE_UNUSED, jthread thread) {
|
jint state;
|
jvmtiError result = jvmti_env->GetThreadState(thread, &state);
|
if (JvmtiErrorToException(env, jvmti_env, result)) {
|
return 0;
|
}
|
return state;
|
}
|
|
extern "C" JNIEXPORT jobjectArray JNICALL Java_art_Test924_getAllThreads(
|
JNIEnv* env, jclass Main_klass ATTRIBUTE_UNUSED) {
|
jint thread_count;
|
jthread* threads;
|
|
jvmtiError result = jvmti_env->GetAllThreads(&thread_count, &threads);
|
if (JvmtiErrorToException(env, jvmti_env, result)) {
|
return nullptr;
|
}
|
|
auto callback = [&](jint index) {
|
return threads[index];
|
};
|
jobjectArray ret = CreateObjectArray(env, thread_count, "java/lang/Thread", callback);
|
|
jvmti_env->Deallocate(reinterpret_cast<unsigned char*>(threads));
|
|
return ret;
|
}
|
|
extern "C" JNIEXPORT jlong JNICALL Java_art_Test924_getTLS(
|
JNIEnv* env, jclass Main_klass ATTRIBUTE_UNUSED, jthread thread) {
|
void* tls;
|
jvmtiError result = jvmti_env->GetThreadLocalStorage(thread, &tls);
|
if (JvmtiErrorToException(env, jvmti_env, result)) {
|
return 0;
|
}
|
return static_cast<jlong>(reinterpret_cast<uintptr_t>(tls));
|
}
|
|
extern "C" JNIEXPORT void JNICALL Java_art_Test924_setTLS(
|
JNIEnv* env, jclass Main_klass ATTRIBUTE_UNUSED, jthread thread, jlong val) {
|
const void* tls = reinterpret_cast<void*>(static_cast<uintptr_t>(val));
|
jvmtiError result = jvmti_env->SetThreadLocalStorage(thread, tls);
|
JvmtiErrorToException(env, jvmti_env, result);
|
}
|
|
static std::mutex gEventsMutex;
|
static std::vector<std::string> gEvents;
|
|
static void JNICALL ThreadEvent(jvmtiEnv* jvmti_env,
|
JNIEnv* jni_env,
|
jthread thread,
|
bool is_start) {
|
jvmtiThreadInfo info;
|
{
|
std::lock_guard<std::mutex> guard(gEventsMutex);
|
|
jvmtiError result = jvmti_env->GetThreadInfo(thread, &info);
|
if (result != JVMTI_ERROR_NONE) {
|
gEvents.push_back("Error getting thread info");
|
return;
|
}
|
|
gEvents.push_back(android::base::StringPrintf("Thread(%s): %s",
|
info.name,
|
is_start ? "start" : "end"));
|
}
|
|
jvmti_env->Deallocate(reinterpret_cast<unsigned char*>(info.name));
|
jni_env->DeleteLocalRef(info.thread_group);
|
jni_env->DeleteLocalRef(info.context_class_loader);
|
}
|
|
static void JNICALL ThreadStart(jvmtiEnv* jvmti_env,
|
JNIEnv* jni_env,
|
jthread thread) {
|
ThreadEvent(jvmti_env, jni_env, thread, true);
|
}
|
|
static void JNICALL ThreadEnd(jvmtiEnv* jvmti_env,
|
JNIEnv* jni_env,
|
jthread thread) {
|
ThreadEvent(jvmti_env, jni_env, thread, false);
|
}
|
|
extern "C" JNIEXPORT void JNICALL Java_art_Test924_enableThreadEvents(
|
JNIEnv* env, jclass Main_klass ATTRIBUTE_UNUSED, jboolean b) {
|
if (b == JNI_FALSE) {
|
jvmtiError ret = jvmti_env->SetEventNotificationMode(JVMTI_DISABLE,
|
JVMTI_EVENT_THREAD_START,
|
nullptr);
|
if (JvmtiErrorToException(env, jvmti_env, ret)) {
|
return;
|
}
|
ret = jvmti_env->SetEventNotificationMode(JVMTI_DISABLE,
|
JVMTI_EVENT_THREAD_END,
|
nullptr);
|
JvmtiErrorToException(env, jvmti_env, ret);
|
return;
|
}
|
|
jvmtiEventCallbacks callbacks;
|
memset(&callbacks, 0, sizeof(jvmtiEventCallbacks));
|
callbacks.ThreadStart = ThreadStart;
|
callbacks.ThreadEnd = ThreadEnd;
|
jvmtiError ret = jvmti_env->SetEventCallbacks(&callbacks, sizeof(callbacks));
|
if (JvmtiErrorToException(env, jvmti_env, ret)) {
|
return;
|
}
|
|
ret = jvmti_env->SetEventNotificationMode(JVMTI_ENABLE,
|
JVMTI_EVENT_THREAD_START,
|
nullptr);
|
if (JvmtiErrorToException(env, jvmti_env, ret)) {
|
return;
|
}
|
ret = jvmti_env->SetEventNotificationMode(JVMTI_ENABLE,
|
JVMTI_EVENT_THREAD_END,
|
nullptr);
|
JvmtiErrorToException(env, jvmti_env, ret);
|
}
|
|
extern "C" JNIEXPORT jobjectArray JNICALL Java_art_Test924_getThreadEventMessages(
|
JNIEnv* env, jclass Main_klass ATTRIBUTE_UNUSED) {
|
std::lock_guard<std::mutex> guard(gEventsMutex);
|
jobjectArray ret = CreateObjectArray(env,
|
static_cast<jint>(gEvents.size()),
|
"java/lang/String",
|
[&](jint i) {
|
return env->NewStringUTF(gEvents[i].c_str());
|
});
|
gEvents.clear();
|
return ret;
|
}
|
|
} // namespace Test924Threads
|
} // namespace art
|
