Alex Light | 95c9ef9 | 2018-08-30 12:50:46 -0700 | [diff] [blame] | 1 | // Copyright (C) 2018 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 | |
| 18 | #include <atomic> |
| 19 | #include <iomanip> |
| 20 | #include <iostream> |
| 21 | #include <istream> |
| 22 | #include <jni.h> |
| 23 | #include <jvmti.h> |
| 24 | #include <memory> |
| 25 | #include <sstream> |
| 26 | #include <string.h> |
| 27 | #include <string> |
| 28 | #include <vector> |
| 29 | |
| 30 | namespace fieldnull { |
| 31 | |
| 32 | #define CHECK_JVMTI(x) CHECK_EQ((x), JVMTI_ERROR_NONE) |
| 33 | |
| 34 | // Special art ti-version number. We will use this as a fallback if we cannot get a regular JVMTI |
| 35 | // env. |
| 36 | static constexpr jint kArtTiVersion = JVMTI_VERSION_1_2 | 0x40000000; |
| 37 | |
| 38 | static JavaVM* java_vm = nullptr; |
| 39 | |
| 40 | // Field is "Lclass/name/here;.field_name:Lfield/type/here;" |
| 41 | static std::pair<jclass, jfieldID> SplitField(JNIEnv* env, const std::string& field_id) { |
| 42 | CHECK_EQ(field_id[0], 'L'); |
| 43 | env->PushLocalFrame(1); |
| 44 | std::istringstream is(field_id); |
| 45 | std::string class_name; |
| 46 | std::string field_name; |
| 47 | std::string field_type; |
| 48 | |
| 49 | std::getline(is, class_name, '.'); |
| 50 | std::getline(is, field_name, ':'); |
| 51 | std::getline(is, field_type, '\0'); |
| 52 | |
| 53 | jclass klass = reinterpret_cast<jclass>( |
| 54 | env->NewGlobalRef(env->FindClass(class_name.substr(1, class_name.size() - 2).c_str()))); |
| 55 | jfieldID field = env->GetFieldID(klass, field_name.c_str(), field_type.c_str()); |
| 56 | CHECK(klass != nullptr); |
| 57 | CHECK(field != nullptr); |
| 58 | LOG(INFO) << "listing field " << field_id; |
| 59 | env->PopLocalFrame(nullptr); |
| 60 | return std::make_pair(klass, field); |
| 61 | } |
| 62 | |
| 63 | static std::vector<std::pair<jclass, jfieldID>> GetRequestedFields(JNIEnv* env, |
| 64 | const std::string& args) { |
| 65 | std::vector<std::pair<jclass, jfieldID>> res; |
| 66 | std::stringstream args_stream(args); |
| 67 | std::string item; |
| 68 | while (std::getline(args_stream, item, ',')) { |
| 69 | if (item == "") { |
| 70 | continue; |
| 71 | } |
| 72 | res.push_back(SplitField(env, item)); |
| 73 | } |
| 74 | return res; |
| 75 | } |
| 76 | |
| 77 | static jint SetupJvmtiEnv(JavaVM* vm, jvmtiEnv** jvmti) { |
| 78 | jint res = 0; |
| 79 | res = vm->GetEnv(reinterpret_cast<void**>(jvmti), JVMTI_VERSION_1_1); |
| 80 | |
| 81 | if (res != JNI_OK || *jvmti == nullptr) { |
| 82 | LOG(ERROR) << "Unable to access JVMTI, error code " << res; |
| 83 | return vm->GetEnv(reinterpret_cast<void**>(jvmti), kArtTiVersion); |
| 84 | } |
| 85 | return res; |
| 86 | } |
| 87 | |
| 88 | struct RequestList { |
| 89 | std::vector<std::pair<jclass, jfieldID>> fields_; |
| 90 | }; |
| 91 | |
| 92 | static void DataDumpRequestCb(jvmtiEnv* jvmti) { |
| 93 | JNIEnv* env = nullptr; |
| 94 | CHECK_EQ(java_vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6), JNI_OK); |
| 95 | LOG(INFO) << "Dumping counts of null fields."; |
| 96 | LOG(INFO) << "\t" << "Field name" |
| 97 | << "\t" << "null count" |
| 98 | << "\t" << "total count"; |
| 99 | RequestList* list; |
| 100 | CHECK_JVMTI(jvmti->GetEnvironmentLocalStorage(reinterpret_cast<void**>(&list))); |
| 101 | for (std::pair<jclass, jfieldID>& p : list->fields_) { |
| 102 | jclass klass = p.first; |
| 103 | jfieldID field = p.second; |
| 104 | // Make sure all instances of the class are tagged with the klass ptr value. Since this is a |
| 105 | // global ref it's guaranteed to be unique. |
| 106 | CHECK_JVMTI(jvmti->IterateOverInstancesOfClass( |
| 107 | p.first, |
| 108 | // We need to do this to all objects every time since we might be looking for multiple |
| 109 | // fields in classes that are subtypes of each other. |
| 110 | JVMTI_HEAP_OBJECT_EITHER, |
| 111 | /* class_tag, size, tag_ptr, user_data*/ |
| 112 | [](jlong, jlong, jlong* tag_ptr, void* klass) -> jvmtiIterationControl { |
| 113 | *tag_ptr = static_cast<jlong>(reinterpret_cast<intptr_t>(klass)); |
| 114 | return JVMTI_ITERATION_CONTINUE; |
| 115 | }, |
| 116 | klass)); |
| 117 | jobject* obj_list; |
| 118 | jint obj_len; |
| 119 | jlong tag = static_cast<jlong>(reinterpret_cast<intptr_t>(klass)); |
| 120 | CHECK_JVMTI(jvmti->GetObjectsWithTags(1, &tag, &obj_len, &obj_list, nullptr)); |
| 121 | |
| 122 | uint64_t null_cnt = 0; |
| 123 | for (jint i = 0; i < obj_len; i++) { |
| 124 | if (env->GetObjectField(obj_list[i], field) == nullptr) { |
| 125 | null_cnt++; |
| 126 | } |
| 127 | } |
| 128 | |
| 129 | char* field_name; |
| 130 | char* field_sig; |
| 131 | char* class_name; |
| 132 | CHECK_JVMTI(jvmti->GetFieldName(klass, field, &field_name, &field_sig, nullptr)); |
| 133 | CHECK_JVMTI(jvmti->GetClassSignature(klass, &class_name, nullptr)); |
| 134 | LOG(INFO) << "\t" << class_name << "." << field_name << ":" << field_sig |
| 135 | << "\t" << null_cnt |
| 136 | << "\t" << obj_len; |
| 137 | CHECK_JVMTI(jvmti->Deallocate(reinterpret_cast<unsigned char*>(field_name))); |
| 138 | CHECK_JVMTI(jvmti->Deallocate(reinterpret_cast<unsigned char*>(field_sig))); |
| 139 | CHECK_JVMTI(jvmti->Deallocate(reinterpret_cast<unsigned char*>(class_name))); |
| 140 | } |
| 141 | } |
| 142 | |
| 143 | static void VMDeathCb(jvmtiEnv* jvmti, JNIEnv* env ATTRIBUTE_UNUSED) { |
| 144 | DataDumpRequestCb(jvmti); |
| 145 | RequestList* list = nullptr; |
| 146 | CHECK_JVMTI(jvmti->GetEnvironmentLocalStorage(reinterpret_cast<void**>(&list))); |
| 147 | delete list; |
| 148 | } |
| 149 | |
Andreas Gampe | f1235e6 | 2018-09-06 19:44:11 -0700 | [diff] [blame] | 150 | static void CreateFieldList(jvmtiEnv* jvmti, JNIEnv* env, const std::string& args) { |
Alex Light | 95c9ef9 | 2018-08-30 12:50:46 -0700 | [diff] [blame] | 151 | RequestList* list = nullptr; |
| 152 | CHECK_JVMTI(jvmti->Allocate(sizeof(*list), reinterpret_cast<unsigned char**>(&list))); |
| 153 | new (list) RequestList { .fields_ = GetRequestedFields(env, args), }; |
| 154 | CHECK_JVMTI(jvmti->SetEnvironmentLocalStorage(list)); |
| 155 | } |
| 156 | |
| 157 | static void VMInitCb(jvmtiEnv* jvmti, JNIEnv* env, jobject thr ATTRIBUTE_UNUSED) { |
| 158 | char* args = nullptr; |
| 159 | CHECK_JVMTI(jvmti->GetEnvironmentLocalStorage(reinterpret_cast<void**>(&args))); |
| 160 | CHECK_JVMTI(jvmti->SetEnvironmentLocalStorage(nullptr)); |
| 161 | CreateFieldList(jvmti, env, args); |
| 162 | CHECK_JVMTI(jvmti->SetEventNotificationMode(JVMTI_ENABLE, JVMTI_EVENT_VM_DEATH, nullptr)); |
| 163 | CHECK_JVMTI(jvmti->SetEventNotificationMode(JVMTI_ENABLE, |
| 164 | JVMTI_EVENT_DATA_DUMP_REQUEST, |
| 165 | nullptr)); |
| 166 | CHECK_JVMTI(jvmti->Deallocate(reinterpret_cast<unsigned char*>(args))); |
| 167 | } |
| 168 | |
| 169 | static jint AgentStart(JavaVM* vm, char* options, bool is_onload) { |
Andreas Gampe | 9b031f7 | 2018-10-04 11:03:34 -0700 | [diff] [blame] | 170 | android::base::InitLogging(/* argv= */nullptr); |
Alex Light | 95c9ef9 | 2018-08-30 12:50:46 -0700 | [diff] [blame] | 171 | java_vm = vm; |
| 172 | jvmtiEnv* jvmti = nullptr; |
| 173 | if (SetupJvmtiEnv(vm, &jvmti) != JNI_OK) { |
| 174 | LOG(ERROR) << "Could not get JVMTI env or ArtTiEnv!"; |
| 175 | return JNI_ERR; |
| 176 | } |
| 177 | jvmtiCapabilities caps { .can_tag_objects = 1, }; |
| 178 | CHECK_JVMTI(jvmti->AddCapabilities(&caps)); |
| 179 | jvmtiEventCallbacks cb { |
| 180 | .VMInit = VMInitCb, |
Alex Light | 95c9ef9 | 2018-08-30 12:50:46 -0700 | [diff] [blame] | 181 | .VMDeath = VMDeathCb, |
Nick Desaulniers | a7239b5 | 2019-10-09 15:22:43 -0700 | [diff] [blame] | 182 | .DataDumpRequest = DataDumpRequestCb, |
Alex Light | 95c9ef9 | 2018-08-30 12:50:46 -0700 | [diff] [blame] | 183 | }; |
| 184 | CHECK_JVMTI(jvmti->SetEventCallbacks(&cb, sizeof(cb))); |
| 185 | if (is_onload) { |
| 186 | unsigned char* ptr = nullptr; |
| 187 | CHECK_JVMTI(jvmti->Allocate(strlen(options) + 1, &ptr)); |
| 188 | strcpy(reinterpret_cast<char*>(ptr), options); |
| 189 | CHECK_JVMTI(jvmti->SetEnvironmentLocalStorage(ptr)); |
| 190 | CHECK_JVMTI(jvmti->SetEventNotificationMode(JVMTI_ENABLE, JVMTI_EVENT_VM_INIT, nullptr)); |
| 191 | } else { |
| 192 | JNIEnv* env = nullptr; |
| 193 | CHECK_EQ(vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6), JNI_OK); |
| 194 | CreateFieldList(jvmti, env, options); |
| 195 | CHECK_JVMTI(jvmti->SetEventNotificationMode(JVMTI_ENABLE, JVMTI_EVENT_VM_DEATH, nullptr)); |
| 196 | CHECK_JVMTI(jvmti->SetEventNotificationMode(JVMTI_ENABLE, |
| 197 | JVMTI_EVENT_DATA_DUMP_REQUEST, |
| 198 | nullptr)); |
| 199 | } |
| 200 | return JNI_OK; |
| 201 | } |
| 202 | |
| 203 | // Late attachment (e.g. 'am attach-agent'). |
| 204 | extern "C" JNIEXPORT jint JNICALL Agent_OnAttach(JavaVM *vm, |
| 205 | char* options, |
| 206 | void* reserved ATTRIBUTE_UNUSED) { |
Andreas Gampe | 9b031f7 | 2018-10-04 11:03:34 -0700 | [diff] [blame] | 207 | return AgentStart(vm, options, /*is_onload=*/false); |
Alex Light | 95c9ef9 | 2018-08-30 12:50:46 -0700 | [diff] [blame] | 208 | } |
| 209 | |
| 210 | // Early attachment |
| 211 | extern "C" JNIEXPORT jint JNICALL Agent_OnLoad(JavaVM* jvm, |
| 212 | char* options, |
| 213 | void* reserved ATTRIBUTE_UNUSED) { |
Andreas Gampe | 9b031f7 | 2018-10-04 11:03:34 -0700 | [diff] [blame] | 214 | return AgentStart(jvm, options, /*is_onload=*/true); |
Alex Light | 95c9ef9 | 2018-08-30 12:50:46 -0700 | [diff] [blame] | 215 | } |
| 216 | |
| 217 | } // namespace fieldnull |
| 218 | |