dalvik_system_DexFile.cc revision 1d7d7f15f9fbb1111d4b7d79c1dab2f49a5960dc
1/* 2 * Copyright (C) 2008 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 "dalvik_system_DexFile.h" 18 19#include "base/logging.h" 20#include "base/stl_util.h" 21#include "base/stringprintf.h" 22#include "class_linker.h" 23#include "common_throws.h" 24#include "dex_file-inl.h" 25#include "jni_internal.h" 26#include "mirror/class_loader.h" 27#include "mirror/object-inl.h" 28#include "mirror/string.h" 29#include "oat_file_assistant.h" 30#include "os.h" 31#include "profiler.h" 32#include "runtime.h" 33#include "scoped_thread_state_change.h" 34#include "ScopedLocalRef.h" 35#include "ScopedUtfChars.h" 36#include "utils.h" 37#include "well_known_classes.h" 38#include "zip_archive.h" 39 40namespace art { 41 42static std::unique_ptr<std::vector<const DexFile*>> 43ConvertJavaArrayToNative(JNIEnv* env, jobject arrayObject) { 44 jarray array = reinterpret_cast<jarray>(arrayObject); 45 46 jsize array_size = env->GetArrayLength(array); 47 if (env->ExceptionCheck() == JNI_TRUE) { 48 return std::unique_ptr<std::vector<const DexFile*>>(); 49 } 50 51 // TODO: Optimize. On 32bit we can use an int array. 52 jboolean is_long_data_copied; 53 jlong* long_data = env->GetLongArrayElements(reinterpret_cast<jlongArray>(array), 54 &is_long_data_copied); 55 if (env->ExceptionCheck() == JNI_TRUE) { 56 return std::unique_ptr<std::vector<const DexFile*>>(); 57 } 58 59 std::unique_ptr<std::vector<const DexFile*>> ret(new std::vector<const DexFile*>()); 60 ret->reserve(array_size); 61 for (jsize i = 0; i < array_size; ++i) { 62 ret->push_back(reinterpret_cast<const DexFile*>(static_cast<uintptr_t>(*(long_data + i)))); 63 } 64 65 env->ReleaseLongArrayElements(reinterpret_cast<jlongArray>(array), long_data, JNI_ABORT); 66 if (env->ExceptionCheck() == JNI_TRUE) { 67 return std::unique_ptr<std::vector<const DexFile*>>(); 68 } 69 70 return ret; 71} 72 73static jlongArray ConvertNativeToJavaArray(JNIEnv* env, 74 std::vector<std::unique_ptr<const DexFile>>& vec) { 75 size_t vec_size = vec.size(); 76 jlongArray long_array = env->NewLongArray(static_cast<jsize>(vec_size)); 77 if (env->ExceptionCheck() == JNI_TRUE) { 78 return nullptr; 79 } 80 81 jboolean is_long_data_copied; 82 jlong* long_data = env->GetLongArrayElements(long_array, &is_long_data_copied); 83 if (env->ExceptionCheck() == JNI_TRUE) { 84 return nullptr; 85 } 86 87 jlong* tmp = long_data; 88 for (auto& dex_file : vec) { 89 *tmp = reinterpret_cast<uintptr_t>(dex_file.get()); 90 tmp++; 91 } 92 93 env->ReleaseLongArrayElements(long_array, long_data, 0); 94 if (env->ExceptionCheck() == JNI_TRUE) { 95 return nullptr; 96 } 97 98 // Now release all the unique_ptrs. 99 for (auto& dex_file : vec) { 100 dex_file.release(); 101 } 102 103 return long_array; 104} 105 106// A smart pointer that provides read-only access to a Java string's UTF chars. 107// Unlike libcore's NullableScopedUtfChars, this will *not* throw NullPointerException if 108// passed a null jstring. The correct idiom is: 109// 110// NullableScopedUtfChars name(env, javaName); 111// if (env->ExceptionCheck()) { 112// return null; 113// } 114// // ... use name.c_str() 115// 116// TODO: rewrite to get rid of this, or change ScopedUtfChars to offer this option. 117class NullableScopedUtfChars { 118 public: 119 NullableScopedUtfChars(JNIEnv* env, jstring s) : mEnv(env), mString(s) { 120 mUtfChars = (s != nullptr) ? env->GetStringUTFChars(s, nullptr) : nullptr; 121 } 122 123 ~NullableScopedUtfChars() { 124 if (mUtfChars) { 125 mEnv->ReleaseStringUTFChars(mString, mUtfChars); 126 } 127 } 128 129 const char* c_str() const { 130 return mUtfChars; 131 } 132 133 size_t size() const { 134 return strlen(mUtfChars); 135 } 136 137 // Element access. 138 const char& operator[](size_t n) const { 139 return mUtfChars[n]; 140 } 141 142 private: 143 JNIEnv* mEnv; 144 jstring mString; 145 const char* mUtfChars; 146 147 // Disallow copy and assignment. 148 NullableScopedUtfChars(const NullableScopedUtfChars&); 149 void operator=(const NullableScopedUtfChars&); 150}; 151 152static jobject DexFile_openDexFileNative( 153 JNIEnv* env, jclass, jstring javaSourceName, jstring javaOutputName, jint) { 154 ScopedUtfChars sourceName(env, javaSourceName); 155 if (sourceName.c_str() == nullptr) { 156 return 0; 157 } 158 NullableScopedUtfChars outputName(env, javaOutputName); 159 if (env->ExceptionCheck()) { 160 return 0; 161 } 162 163 ClassLinker* linker = Runtime::Current()->GetClassLinker(); 164 std::vector<std::unique_ptr<const DexFile>> dex_files; 165 std::vector<std::string> error_msgs; 166 167 dex_files = linker->OpenDexFilesFromOat(sourceName.c_str(), outputName.c_str(), &error_msgs); 168 169 if (!dex_files.empty()) { 170 jlongArray array = ConvertNativeToJavaArray(env, dex_files); 171 if (array == nullptr) { 172 ScopedObjectAccess soa(env); 173 for (auto& dex_file : dex_files) { 174 if (linker->FindDexCache(soa.Self(), *dex_file, true) != nullptr) { 175 dex_file.release(); 176 } 177 } 178 } 179 return array; 180 } else { 181 ScopedObjectAccess soa(env); 182 CHECK(!error_msgs.empty()); 183 // The most important message is at the end. So set up nesting by going forward, which will 184 // wrap the existing exception as a cause for the following one. 185 auto it = error_msgs.begin(); 186 auto itEnd = error_msgs.end(); 187 for ( ; it != itEnd; ++it) { 188 ThrowWrappedIOException("%s", it->c_str()); 189 } 190 191 return nullptr; 192 } 193} 194 195static jboolean DexFile_closeDexFile(JNIEnv* env, jclass, jobject cookie) { 196 ScopedObjectAccess soa(env); 197 mirror::Object* dex_files_object = soa.Decode<mirror::Object*>(cookie); 198 if (dex_files_object == nullptr) { 199 ThrowNullPointerException("cookie == null"); 200 return JNI_FALSE; 201 } 202 mirror::LongArray* dex_files = dex_files_object->AsLongArray(); 203 204 // Delete dex files associated with this dalvik.system.DexFile since there should not be running 205 // code using it. dex_files is a vector due to multidex. 206 ClassLinker* const class_linker = Runtime::Current()->GetClassLinker(); 207 bool all_deleted = true; 208 for (int32_t i = 0, count = dex_files->GetLength(); i < count; ++i) { 209 auto* dex_file = reinterpret_cast<DexFile*>(dex_files->Get(i)); 210 if (dex_file == nullptr) { 211 continue; 212 } 213 // Only delete the dex file if the dex cache is not found to prevent runtime crashes if there 214 // are calls to DexFile.close while the ART DexFile is still in use. 215 if (class_linker->FindDexCache(soa.Self(), *dex_file, true) == nullptr) { 216 // Clear the element in the array so that we can call close again. 217 dex_files->Set(i, 0); 218 delete dex_file; 219 } else { 220 all_deleted = false; 221 } 222 } 223 224 // TODO: Also unmap the OatFile for this dalvik.system.DexFile. 225 226 return all_deleted ? JNI_TRUE : JNI_FALSE; 227} 228 229static jclass DexFile_defineClassNative(JNIEnv* env, jclass, jstring javaName, jobject javaLoader, 230 jobject cookie) { 231 std::unique_ptr<std::vector<const DexFile*>> dex_files = ConvertJavaArrayToNative(env, cookie); 232 if (dex_files.get() == nullptr) { 233 VLOG(class_linker) << "Failed to find dex_file"; 234 DCHECK(env->ExceptionCheck()); 235 return nullptr; 236 } 237 238 ScopedUtfChars class_name(env, javaName); 239 if (class_name.c_str() == nullptr) { 240 VLOG(class_linker) << "Failed to find class_name"; 241 return nullptr; 242 } 243 const std::string descriptor(DotToDescriptor(class_name.c_str())); 244 const size_t hash(ComputeModifiedUtf8Hash(descriptor.c_str())); 245 for (auto& dex_file : *dex_files) { 246 const DexFile::ClassDef* dex_class_def = dex_file->FindClassDef(descriptor.c_str(), hash); 247 if (dex_class_def != nullptr) { 248 ScopedObjectAccess soa(env); 249 ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); 250 class_linker->RegisterDexFile(*dex_file); 251 StackHandleScope<1> hs(soa.Self()); 252 Handle<mirror::ClassLoader> class_loader( 253 hs.NewHandle(soa.Decode<mirror::ClassLoader*>(javaLoader))); 254 mirror::Class* result = class_linker->DefineClass(soa.Self(), descriptor.c_str(), hash, 255 class_loader, *dex_file, *dex_class_def); 256 if (result != nullptr) { 257 VLOG(class_linker) << "DexFile_defineClassNative returning " << result 258 << " for " << class_name.c_str(); 259 return soa.AddLocalReference<jclass>(result); 260 } 261 } 262 } 263 VLOG(class_linker) << "Failed to find dex_class_def " << class_name.c_str(); 264 return nullptr; 265} 266 267// Needed as a compare functor for sets of const char 268struct CharPointerComparator { 269 bool operator()(const char *str1, const char *str2) const { 270 return strcmp(str1, str2) < 0; 271 } 272}; 273 274// Note: this can be an expensive call, as we sort out duplicates in MultiDex files. 275static jobjectArray DexFile_getClassNameList(JNIEnv* env, jclass, jobject cookie) { 276 std::unique_ptr<std::vector<const DexFile*>> dex_files = ConvertJavaArrayToNative(env, cookie); 277 if (dex_files.get() == nullptr) { 278 DCHECK(env->ExceptionCheck()); 279 return nullptr; 280 } 281 282 // Push all class descriptors into a set. Use set instead of unordered_set as we want to 283 // retrieve all in the end. 284 std::set<const char*, CharPointerComparator> descriptors; 285 for (auto& dex_file : *dex_files) { 286 for (size_t i = 0; i < dex_file->NumClassDefs(); ++i) { 287 const DexFile::ClassDef& class_def = dex_file->GetClassDef(i); 288 const char* descriptor = dex_file->GetClassDescriptor(class_def); 289 descriptors.insert(descriptor); 290 } 291 } 292 293 // Now create output array and copy the set into it. 294 jobjectArray result = env->NewObjectArray(descriptors.size(), WellKnownClasses::java_lang_String, 295 nullptr); 296 if (result != nullptr) { 297 auto it = descriptors.begin(); 298 auto it_end = descriptors.end(); 299 jsize i = 0; 300 for (; it != it_end; it++, ++i) { 301 std::string descriptor(DescriptorToDot(*it)); 302 ScopedLocalRef<jstring> jdescriptor(env, env->NewStringUTF(descriptor.c_str())); 303 if (jdescriptor.get() == nullptr) { 304 return nullptr; 305 } 306 env->SetObjectArrayElement(result, i, jdescriptor.get()); 307 } 308 } 309 return result; 310} 311 312static jint GetDexOptNeeded(JNIEnv* env, const char* filename, 313 const char* pkgname, const char* instruction_set, const jboolean defer) { 314 315 if ((filename == nullptr) || !OS::FileExists(filename)) { 316 LOG(ERROR) << "DexFile_getDexOptNeeded file '" << filename << "' does not exist"; 317 ScopedLocalRef<jclass> fnfe(env, env->FindClass("java/io/FileNotFoundException")); 318 const char* message = (filename == nullptr) ? "<empty file name>" : filename; 319 env->ThrowNew(fnfe.get(), message); 320 return OatFileAssistant::kNoDexOptNeeded; 321 } 322 323 const InstructionSet target_instruction_set = GetInstructionSetFromString(instruction_set); 324 if (target_instruction_set == kNone) { 325 ScopedLocalRef<jclass> iae(env, env->FindClass("java/lang/IllegalArgumentException")); 326 std::string message(StringPrintf("Instruction set %s is invalid.", instruction_set)); 327 env->ThrowNew(iae.get(), message.c_str()); 328 return 0; 329 } 330 331 // TODO: Verify the dex location is well formed, and throw an IOException if 332 // not? 333 334 OatFileAssistant oat_file_assistant(filename, target_instruction_set, false, pkgname); 335 336 // Always treat elements of the bootclasspath as up-to-date. 337 if (oat_file_assistant.IsInBootClassPath()) { 338 return OatFileAssistant::kNoDexOptNeeded; 339 } 340 341 // TODO: Checking the profile should probably be done in the GetStatus() 342 // function. We have it here because GetStatus() should not be copying 343 // profile files. But who should be copying profile files? 344 if (oat_file_assistant.OdexFileIsOutOfDate()) { 345 // Needs recompile if profile has changed significantly. 346 if (Runtime::Current()->GetProfilerOptions().IsEnabled()) { 347 if (oat_file_assistant.IsProfileChangeSignificant()) { 348 if (!defer) { 349 oat_file_assistant.CopyProfileFile(); 350 } 351 return OatFileAssistant::kDex2OatNeeded; 352 } else if (oat_file_assistant.ProfileExists() 353 && !oat_file_assistant.OldProfileExists()) { 354 if (!defer) { 355 oat_file_assistant.CopyProfileFile(); 356 } 357 } 358 } 359 } 360 361 return oat_file_assistant.GetDexOptNeeded(); 362} 363 364static jint DexFile_getDexOptNeeded(JNIEnv* env, jclass, jstring javaFilename, 365 jstring javaPkgname, jstring javaInstructionSet, jboolean defer) { 366 ScopedUtfChars filename(env, javaFilename); 367 if (env->ExceptionCheck()) { 368 return 0; 369 } 370 371 NullableScopedUtfChars pkgname(env, javaPkgname); 372 373 ScopedUtfChars instruction_set(env, javaInstructionSet); 374 if (env->ExceptionCheck()) { 375 return 0; 376 } 377 378 return GetDexOptNeeded(env, filename.c_str(), pkgname.c_str(), 379 instruction_set.c_str(), defer); 380} 381 382// public API, null pkgname 383static jboolean DexFile_isDexOptNeeded(JNIEnv* env, jclass, jstring javaFilename) { 384 const char* instruction_set = GetInstructionSetString(kRuntimeISA); 385 ScopedUtfChars filename(env, javaFilename); 386 jint status = GetDexOptNeeded(env, filename.c_str(), nullptr /* pkgname */, 387 instruction_set, false /* defer */); 388 return (status != OatFileAssistant::kNoDexOptNeeded) ? JNI_TRUE : JNI_FALSE; 389} 390 391static JNINativeMethod gMethods[] = { 392 NATIVE_METHOD(DexFile, closeDexFile, "(Ljava/lang/Object;)Z"), 393 NATIVE_METHOD(DexFile, defineClassNative, 394 "(Ljava/lang/String;Ljava/lang/ClassLoader;Ljava/lang/Object;)Ljava/lang/Class;"), 395 NATIVE_METHOD(DexFile, getClassNameList, "(Ljava/lang/Object;)[Ljava/lang/String;"), 396 NATIVE_METHOD(DexFile, isDexOptNeeded, "(Ljava/lang/String;)Z"), 397 NATIVE_METHOD(DexFile, getDexOptNeeded, 398 "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Z)I"), 399 NATIVE_METHOD(DexFile, openDexFileNative, 400 "(Ljava/lang/String;Ljava/lang/String;I)Ljava/lang/Object;"), 401}; 402 403void register_dalvik_system_DexFile(JNIEnv* env) { 404 REGISTER_NATIVE_METHODS("dalvik/system/DexFile"); 405} 406 407} // namespace art 408