1 /* 2 * Copyright (C) 2016 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #include "common_helper.h" 18 19 #include <deque> 20 #include <map> 21 #include <stdio.h> 22 #include <sstream> 23 #include <string> 24 #include <vector> 25 26 #include "jni.h" 27 #include "jvmti.h" 28 29 #include "jvmti_helper.h" 30 #include "test_env.h" 31 32 namespace art { 33 34 static void SetupCommonRedefine(); 35 static void SetupCommonRetransform(); 36 static void SetupCommonTransform(); 37 template <bool is_redefine> 38 static void throwCommonRedefinitionError(jvmtiEnv* jvmti, 39 JNIEnv* env, 40 jint num_targets, 41 jclass* target, 42 jvmtiError res) { 43 std::stringstream err; 44 char* error = nullptr; 45 jvmti->GetErrorName(res, &error); 46 err << "Failed to " << (is_redefine ? "redefine" : "retransform") << " class"; 47 if (num_targets > 1) { 48 err << "es"; 49 } 50 err << " <"; 51 for (jint i = 0; i < num_targets; i++) { 52 char* signature = nullptr; 53 char* generic = nullptr; 54 jvmti->GetClassSignature(target[i], &signature, &generic); 55 if (i != 0) { 56 err << ", "; 57 } 58 err << signature; 59 jvmti->Deallocate(reinterpret_cast<unsigned char*>(signature)); 60 jvmti->Deallocate(reinterpret_cast<unsigned char*>(generic)); 61 } 62 err << "> due to " << error; 63 std::string message = err.str(); 64 jvmti->Deallocate(reinterpret_cast<unsigned char*>(error)); 65 env->ThrowNew(env->FindClass("java/lang/Exception"), message.c_str()); 66 } 67 68 #define CONFIGURATION_COMMON_REDEFINE 0 69 #define CONFIGURATION_COMMON_RETRANSFORM 1 70 #define CONFIGURATION_COMMON_TRANSFORM 2 71 72 extern "C" JNIEXPORT void JNICALL Java_art_Redefinition_nativeSetTestConfiguration(JNIEnv*, 73 jclass, 74 jint type) { 75 switch (type) { 76 case CONFIGURATION_COMMON_REDEFINE: { 77 SetupCommonRedefine(); 78 return; 79 } 80 case CONFIGURATION_COMMON_RETRANSFORM: { 81 SetupCommonRetransform(); 82 return; 83 } 84 case CONFIGURATION_COMMON_TRANSFORM: { 85 SetupCommonTransform(); 86 return; 87 } 88 default: { 89 LOG(FATAL) << "Unknown test configuration: " << type; 90 } 91 } 92 } 93 94 namespace common_redefine { 95 96 static void throwRedefinitionError(jvmtiEnv* jvmti, 97 JNIEnv* env, 98 jint num_targets, 99 jclass* target, 100 jvmtiError res) { 101 return throwCommonRedefinitionError<true>(jvmti, env, num_targets, target, res); 102 } 103 104 static void DoMultiClassRedefine(jvmtiEnv* jvmti_env, 105 JNIEnv* env, 106 jint num_redefines, 107 jclass* targets, 108 jbyteArray* class_file_bytes, 109 jbyteArray* dex_file_bytes) { 110 std::vector<jvmtiClassDefinition> defs; 111 for (jint i = 0; i < num_redefines; i++) { 112 jbyteArray desired_array = IsJVM() ? class_file_bytes[i] : dex_file_bytes[i]; 113 jint len = static_cast<jint>(env->GetArrayLength(desired_array)); 114 const unsigned char* redef_bytes = reinterpret_cast<const unsigned char*>( 115 env->GetByteArrayElements(desired_array, nullptr)); 116 defs.push_back({targets[i], static_cast<jint>(len), redef_bytes}); 117 } 118 jvmtiError res = jvmti_env->RedefineClasses(num_redefines, defs.data()); 119 if (res != JVMTI_ERROR_NONE) { 120 throwRedefinitionError(jvmti_env, env, num_redefines, targets, res); 121 } 122 } 123 124 static void DoClassRedefine(jvmtiEnv* jvmti_env, 125 JNIEnv* env, 126 jclass target, 127 jbyteArray class_file_bytes, 128 jbyteArray dex_file_bytes) { 129 return DoMultiClassRedefine(jvmti_env, env, 1, &target, &class_file_bytes, &dex_file_bytes); 130 } 131 132 // Magic JNI export that classes can use for redefining classes. 133 // To use classes should declare this as a native function with signature (Ljava/lang/Class;[B[B)V 134 extern "C" JNIEXPORT void JNICALL Java_art_Redefinition_doCommonClassRedefinition( 135 JNIEnv* env, jclass, jclass target, jbyteArray class_file_bytes, jbyteArray dex_file_bytes) { 136 DoClassRedefine(jvmti_env, env, target, class_file_bytes, dex_file_bytes); 137 } 138 139 // Magic JNI export that classes can use for redefining classes. 140 // To use classes should declare this as a native function with signature 141 // ([Ljava/lang/Class;[[B[[B)V 142 extern "C" JNIEXPORT void JNICALL Java_art_Redefinition_doCommonMultiClassRedefinition( 143 JNIEnv* env, 144 jclass, 145 jobjectArray targets, 146 jobjectArray class_file_bytes, 147 jobjectArray dex_file_bytes) { 148 std::vector<jclass> classes; 149 std::vector<jbyteArray> class_files; 150 std::vector<jbyteArray> dex_files; 151 jint len = env->GetArrayLength(targets); 152 if (len != env->GetArrayLength(class_file_bytes) || len != env->GetArrayLength(dex_file_bytes)) { 153 env->ThrowNew(env->FindClass("java/lang/IllegalArgumentException"), 154 "the three array arguments passed to this function have different lengths!"); 155 return; 156 } 157 for (jint i = 0; i < len; i++) { 158 classes.push_back(static_cast<jclass>(env->GetObjectArrayElement(targets, i))); 159 dex_files.push_back(static_cast<jbyteArray>(env->GetObjectArrayElement(dex_file_bytes, i))); 160 class_files.push_back(static_cast<jbyteArray>(env->GetObjectArrayElement(class_file_bytes, i))); 161 } 162 return DoMultiClassRedefine(jvmti_env, 163 env, 164 len, 165 classes.data(), 166 class_files.data(), 167 dex_files.data()); 168 } 169 170 // Get all capabilities except those related to retransformation. 171 jint OnLoad(JavaVM* vm, 172 char* options ATTRIBUTE_UNUSED, 173 void* reserved ATTRIBUTE_UNUSED) { 174 if (vm->GetEnv(reinterpret_cast<void**>(&jvmti_env), JVMTI_VERSION_1_0)) { 175 printf("Unable to get jvmti env!\n"); 176 return 1; 177 } 178 SetupCommonRedefine(); 179 return 0; 180 } 181 182 } // namespace common_redefine 183 184 namespace common_retransform { 185 186 struct CommonTransformationResult { 187 std::vector<unsigned char> class_bytes; 188 std::vector<unsigned char> dex_bytes; 189 190 CommonTransformationResult(size_t class_size, size_t dex_size) 191 : class_bytes(class_size), dex_bytes(dex_size) {} 192 193 CommonTransformationResult() = default; 194 CommonTransformationResult(CommonTransformationResult&&) = default; 195 CommonTransformationResult(CommonTransformationResult&) = default; 196 }; 197 198 // Map from class name to transformation result. 199 std::map<std::string, std::deque<CommonTransformationResult>> gTransformations; 200 bool gPopTransformations = true; 201 202 extern "C" JNIEXPORT void JNICALL Java_art_Redefinition_addCommonTransformationResult( 203 JNIEnv* env, jclass, jstring class_name, jbyteArray class_array, jbyteArray dex_array) { 204 const char* name_chrs = env->GetStringUTFChars(class_name, nullptr); 205 std::string name_str(name_chrs); 206 env->ReleaseStringUTFChars(class_name, name_chrs); 207 CommonTransformationResult trans(env->GetArrayLength(class_array), 208 env->GetArrayLength(dex_array)); 209 if (env->ExceptionOccurred()) { 210 return; 211 } 212 env->GetByteArrayRegion(class_array, 213 0, 214 env->GetArrayLength(class_array), 215 reinterpret_cast<jbyte*>(trans.class_bytes.data())); 216 if (env->ExceptionOccurred()) { 217 return; 218 } 219 env->GetByteArrayRegion(dex_array, 220 0, 221 env->GetArrayLength(dex_array), 222 reinterpret_cast<jbyte*>(trans.dex_bytes.data())); 223 if (env->ExceptionOccurred()) { 224 return; 225 } 226 if (gTransformations.find(name_str) == gTransformations.end()) { 227 std::deque<CommonTransformationResult> list; 228 gTransformations[name_str] = std::move(list); 229 } 230 gTransformations[name_str].push_back(std::move(trans)); 231 } 232 233 // The hook we are using. 234 void JNICALL CommonClassFileLoadHookRetransformable(jvmtiEnv* jvmti_env, 235 JNIEnv* jni_env ATTRIBUTE_UNUSED, 236 jclass class_being_redefined ATTRIBUTE_UNUSED, 237 jobject loader ATTRIBUTE_UNUSED, 238 const char* name, 239 jobject protection_domain ATTRIBUTE_UNUSED, 240 jint class_data_len ATTRIBUTE_UNUSED, 241 const unsigned char* class_dat ATTRIBUTE_UNUSED, 242 jint* new_class_data_len, 243 unsigned char** new_class_data) { 244 std::string name_str(name); 245 if (gTransformations.find(name_str) != gTransformations.end() && 246 gTransformations[name_str].size() > 0) { 247 CommonTransformationResult& res = gTransformations[name_str][0]; 248 const std::vector<unsigned char>& desired_array = IsJVM() ? res.class_bytes : res.dex_bytes; 249 unsigned char* new_data; 250 CHECK_EQ(JVMTI_ERROR_NONE, jvmti_env->Allocate(desired_array.size(), &new_data)); 251 memcpy(new_data, desired_array.data(), desired_array.size()); 252 *new_class_data = new_data; 253 *new_class_data_len = desired_array.size(); 254 if (gPopTransformations) { 255 gTransformations[name_str].pop_front(); 256 } 257 } 258 } 259 260 extern "C" JNIEXPORT void Java_art_Redefinition_setPopRetransformations(JNIEnv*, 261 jclass, 262 jboolean enable) { 263 gPopTransformations = enable; 264 } 265 266 extern "C" JNIEXPORT void Java_art_Redefinition_popTransformationFor(JNIEnv* env, 267 jclass, 268 jstring class_name) { 269 const char* name_chrs = env->GetStringUTFChars(class_name, nullptr); 270 std::string name_str(name_chrs); 271 env->ReleaseStringUTFChars(class_name, name_chrs); 272 if (gTransformations.find(name_str) != gTransformations.end() && 273 gTransformations[name_str].size() > 0) { 274 gTransformations[name_str].pop_front(); 275 } else { 276 std::stringstream err; 277 err << "No transformations found for class " << name_str; 278 std::string message = err.str(); 279 env->ThrowNew(env->FindClass("java/lang/Exception"), message.c_str()); 280 } 281 } 282 283 extern "C" JNIEXPORT void Java_art_Redefinition_enableCommonRetransformation(JNIEnv* env, 284 jclass, 285 jboolean enable) { 286 jvmtiError res = jvmti_env->SetEventNotificationMode(enable ? JVMTI_ENABLE : JVMTI_DISABLE, 287 JVMTI_EVENT_CLASS_FILE_LOAD_HOOK, 288 nullptr); 289 if (res != JVMTI_ERROR_NONE) { 290 JvmtiErrorToException(env, jvmti_env, res); 291 } 292 } 293 294 static void throwRetransformationError(jvmtiEnv* jvmti, 295 JNIEnv* env, 296 jint num_targets, 297 jclass* targets, 298 jvmtiError res) { 299 return throwCommonRedefinitionError<false>(jvmti, env, num_targets, targets, res); 300 } 301 302 static void DoClassRetransformation(jvmtiEnv* jvmti_env, JNIEnv* env, jobjectArray targets) { 303 std::vector<jclass> classes; 304 jint len = env->GetArrayLength(targets); 305 for (jint i = 0; i < len; i++) { 306 classes.push_back(static_cast<jclass>(env->GetObjectArrayElement(targets, i))); 307 } 308 jvmtiError res = jvmti_env->RetransformClasses(len, classes.data()); 309 if (res != JVMTI_ERROR_NONE) { 310 throwRetransformationError(jvmti_env, env, len, classes.data(), res); 311 } 312 } 313 314 extern "C" JNIEXPORT void JNICALL Java_art_Redefinition_doCommonClassRetransformation( 315 JNIEnv* env, jclass, jobjectArray targets) { 316 jvmtiCapabilities caps; 317 jvmtiError caps_err = jvmti_env->GetCapabilities(&caps); 318 if (caps_err != JVMTI_ERROR_NONE) { 319 env->ThrowNew(env->FindClass("java/lang/Exception"), 320 "Unable to get current jvmtiEnv capabilities"); 321 return; 322 } 323 324 // Allocate a new environment if we don't have the can_retransform_classes capability needed to 325 // call the RetransformClasses function. 326 jvmtiEnv* real_env = nullptr; 327 if (caps.can_retransform_classes != 1) { 328 JavaVM* vm = nullptr; 329 if (env->GetJavaVM(&vm) != 0 || 330 vm->GetEnv(reinterpret_cast<void**>(&real_env), JVMTI_VERSION_1_0) != 0) { 331 env->ThrowNew(env->FindClass("java/lang/Exception"), 332 "Unable to create temporary jvmtiEnv for RetransformClasses call."); 333 return; 334 } 335 SetAllCapabilities(real_env); 336 } else { 337 real_env = jvmti_env; 338 } 339 DoClassRetransformation(real_env, env, targets); 340 if (caps.can_retransform_classes != 1) { 341 real_env->DisposeEnvironment(); 342 } 343 } 344 345 // Get all capabilities except those related to retransformation. 346 jint OnLoad(JavaVM* vm, 347 char* options ATTRIBUTE_UNUSED, 348 void* reserved ATTRIBUTE_UNUSED) { 349 if (vm->GetEnv(reinterpret_cast<void**>(&jvmti_env), JVMTI_VERSION_1_0)) { 350 printf("Unable to get jvmti env!\n"); 351 return 1; 352 } 353 SetupCommonRetransform(); 354 return 0; 355 } 356 357 } // namespace common_retransform 358 359 namespace common_transform { 360 361 // Get all capabilities except those related to retransformation. 362 jint OnLoad(JavaVM* vm, 363 char* options ATTRIBUTE_UNUSED, 364 void* reserved ATTRIBUTE_UNUSED) { 365 if (vm->GetEnv(reinterpret_cast<void**>(&jvmti_env), JVMTI_VERSION_1_0)) { 366 printf("Unable to get jvmti env!\n"); 367 return 1; 368 } 369 SetupCommonTransform(); 370 return 0; 371 } 372 373 } // namespace common_transform 374 375 static void SetupCommonRedefine() { 376 jvmtiCapabilities caps; 377 jvmti_env->GetPotentialCapabilities(&caps); 378 caps.can_retransform_classes = 0; 379 caps.can_retransform_any_class = 0; 380 jvmti_env->AddCapabilities(&caps); 381 } 382 383 static void SetupCommonRetransform() { 384 SetAllCapabilities(jvmti_env); 385 jvmtiEventCallbacks cb; 386 memset(&cb, 0, sizeof(cb)); 387 cb.ClassFileLoadHook = common_retransform::CommonClassFileLoadHookRetransformable; 388 jvmtiError res = jvmti_env->SetEventCallbacks(&cb, sizeof(cb)); 389 CHECK_EQ(res, JVMTI_ERROR_NONE); 390 common_retransform::gTransformations.clear(); 391 } 392 393 static void SetupCommonTransform() { 394 // Don't set the retransform caps 395 jvmtiCapabilities caps; 396 jvmti_env->GetPotentialCapabilities(&caps); 397 caps.can_retransform_classes = 0; 398 caps.can_retransform_any_class = 0; 399 jvmti_env->AddCapabilities(&caps); 400 401 // Use the same callback as the retransform test. 402 jvmtiEventCallbacks cb; 403 memset(&cb, 0, sizeof(cb)); 404 cb.ClassFileLoadHook = common_retransform::CommonClassFileLoadHookRetransformable; 405 jvmtiError res = jvmti_env->SetEventCallbacks(&cb, sizeof(cb)); 406 CHECK_EQ(res, JVMTI_ERROR_NONE); 407 common_retransform::gTransformations.clear(); 408 } 409 410 } // namespace art 411
