dalvik_system_DexFile.cc revision d91b8a2464b99625efe03caf7d30c8372bc378ed 
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 "oat_file_manager.h"
31#include "os.h"
32#include "profiler.h"
33#include "runtime.h"
34#include "scoped_thread_state_change.h"
35#include "ScopedLocalRef.h"
36#include "ScopedUtfChars.h"
37#include "utils.h"
38#include "well_known_classes.h"
39#include "zip_archive.h"
40
41namespace art {
42
43static bool ConvertJavaArrayToDexFiles(
44    JNIEnv* env,
45    jobject arrayObject,
46    /*out*/ std::vector<const DexFile*>& dex_files,
47    /*out*/ const OatFile*& oat_file) {
48  jarray array = reinterpret_cast<jarray>(arrayObject);
49
50  jsize array_size = env->GetArrayLength(array);
51  if (env->ExceptionCheck() == JNI_TRUE) {
52    return false;
53  }
54
55  // TODO: Optimize. On 32bit we can use an int array.
56  jboolean is_long_data_copied;
57  jlong* long_data = env->GetLongArrayElements(reinterpret_cast<jlongArray>(array),
58                                               &is_long_data_copied);
59  if (env->ExceptionCheck() == JNI_TRUE) {
60    return false;
61  }
62
63  oat_file = reinterpret_cast<const OatFile*>(static_cast<uintptr_t>(long_data[kOatFileIndex]));
64  dex_files.reserve(array_size - 1);
65  for (jsize i = kDexFileIndexStart; i < array_size; ++i) {
66    dex_files.push_back(reinterpret_cast<const DexFile*>(static_cast<uintptr_t>(long_data[i])));
67  }
68
69  env->ReleaseLongArrayElements(reinterpret_cast<jlongArray>(array), long_data, JNI_ABORT);
70  return env->ExceptionCheck() != JNI_TRUE;
71}
72
73static jlongArray ConvertDexFilesToJavaArray(JNIEnv* env,
74                                             const OatFile* oat_file,
75                                             std::vector<std::unique_ptr<const DexFile>>& vec) {
76  // Add one for the oat file.
77  jlongArray long_array = env->NewLongArray(static_cast<jsize>(kDexFileIndexStart + vec.size()));
78  if (env->ExceptionCheck() == JNI_TRUE) {
79    return nullptr;
80  }
81
82  jboolean is_long_data_copied;
83  jlong* long_data = env->GetLongArrayElements(long_array, &is_long_data_copied);
84  if (env->ExceptionCheck() == JNI_TRUE) {
85    return nullptr;
86  }
87
88  long_data[kOatFileIndex] = reinterpret_cast<uintptr_t>(oat_file);
89  for (size_t i = 0; i < vec.size(); ++i) {
90    long_data[kDexFileIndexStart + i] = reinterpret_cast<uintptr_t>(vec[i].get());
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(JNIEnv* env,
153                                         jclass,
154                                         jstring javaSourceName,
155                                         jstring javaOutputName,
156                                         jint flags ATTRIBUTE_UNUSED,
157                                         jobject class_loader,
158                                         jobjectArray dex_elements) {
159  ScopedUtfChars sourceName(env, javaSourceName);
160  if (sourceName.c_str() == nullptr) {
161    return 0;
162  }
163  NullableScopedUtfChars outputName(env, javaOutputName);
164  if (env->ExceptionCheck()) {
165    return 0;
166  }
167  Runtime* const runtime = Runtime::Current();
168  ClassLinker* linker = runtime->GetClassLinker();
169  std::vector<std::unique_ptr<const DexFile>> dex_files;
170  std::vector<std::string> error_msgs;
171  const OatFile* oat_file = nullptr;
172
173  dex_files = runtime->GetOatFileManager().OpenDexFilesFromOat(sourceName.c_str(),
174                                                               outputName.c_str(),
175                                                               class_loader,
176                                                               dex_elements,
177                                                               /*out*/ &oat_file,
178                                                               /*out*/ &error_msgs);
179
180  if (!dex_files.empty()) {
181    jlongArray array = ConvertDexFilesToJavaArray(env, oat_file, dex_files);
182    if (array == nullptr) {
183      ScopedObjectAccess soa(env);
184      for (auto& dex_file : dex_files) {
185        if (linker->FindDexCache(soa.Self(), *dex_file, true) != nullptr) {
186          dex_file.release();
187        }
188      }
189    }
190    return array;
191  } else {
192    ScopedObjectAccess soa(env);
193    CHECK(!error_msgs.empty());
194    // The most important message is at the end. So set up nesting by going forward, which will
195    // wrap the existing exception as a cause for the following one.
196    auto it = error_msgs.begin();
197    auto itEnd = error_msgs.end();
198    for ( ; it != itEnd; ++it) {
199      ThrowWrappedIOException("%s", it->c_str());
200    }
201
202    return nullptr;
203  }
204}
205
206static jboolean DexFile_closeDexFile(JNIEnv* env, jclass, jobject cookie) {
207  std::vector<const DexFile*> dex_files;
208  const OatFile* oat_file;
209  if (!ConvertJavaArrayToDexFiles(env, cookie, dex_files, oat_file)) {
210    Thread::Current()->AssertPendingException();
211    return JNI_FALSE;
212  }
213  Runtime* const runtime = Runtime::Current();
214  bool all_deleted = true;
215  {
216    ScopedObjectAccess soa(env);
217    mirror::Object* dex_files_object = soa.Decode<mirror::Object*>(cookie);
218    mirror::LongArray* long_dex_files = dex_files_object->AsLongArray();
219    // Delete dex files associated with this dalvik.system.DexFile since there should not be running
220    // code using it. dex_files is a vector due to multidex.
221    ClassLinker* const class_linker = runtime->GetClassLinker();
222    int32_t i = kDexFileIndexStart;  // Oat file is at index 0.
223    for (const DexFile* dex_file : dex_files) {
224      if (dex_file != nullptr) {
225        // Only delete the dex file if the dex cache is not found to prevent runtime crashes if there
226        // are calls to DexFile.close while the ART DexFile is still in use.
227        if (class_linker->FindDexCache(soa.Self(), *dex_file, true) == nullptr) {
228          // Clear the element in the array so that we can call close again.
229          long_dex_files->Set(i, 0);
230          delete dex_file;
231        } else {
232          all_deleted = false;
233        }
234      }
235      ++i;
236    }
237  }
238
239  // oat_file can be null if we are running without dex2oat.
240  if (all_deleted && oat_file != nullptr) {
241    // If all of the dex files are no longer in use we can unmap the corresponding oat file.
242    VLOG(class_linker) << "Unregistering " << oat_file;
243    runtime->GetOatFileManager().UnRegisterAndDeleteOatFile(oat_file);
244  }
245  return all_deleted ? JNI_TRUE : JNI_FALSE;
246}
247
248static jclass DexFile_defineClassNative(JNIEnv* env,
249                                        jclass,
250                                        jstring javaName,
251                                        jobject javaLoader,
252                                        jobject cookie,
253                                        jobject dexFile) {
254  std::vector<const DexFile*> dex_files;
255  const OatFile* oat_file;
256  if (!ConvertJavaArrayToDexFiles(env, cookie, /*out*/ dex_files, /*out*/ oat_file)) {
257    VLOG(class_linker) << "Failed to find dex_file";
258    DCHECK(env->ExceptionCheck());
259    return nullptr;
260  }
261
262  ScopedUtfChars class_name(env, javaName);
263  if (class_name.c_str() == nullptr) {
264    VLOG(class_linker) << "Failed to find class_name";
265    return nullptr;
266  }
267  const std::string descriptor(DotToDescriptor(class_name.c_str()));
268  const size_t hash(ComputeModifiedUtf8Hash(descriptor.c_str()));
269  for (auto& dex_file : dex_files) {
270    const DexFile::ClassDef* dex_class_def = dex_file->FindClassDef(descriptor.c_str(), hash);
271    if (dex_class_def != nullptr) {
272      ScopedObjectAccess soa(env);
273      ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
274      StackHandleScope<1> hs(soa.Self());
275      Handle<mirror::ClassLoader> class_loader(
276          hs.NewHandle(soa.Decode<mirror::ClassLoader*>(javaLoader)));
277      class_linker->RegisterDexFile(
278          *dex_file,
279          class_linker->GetOrCreateAllocatorForClassLoader(class_loader.Get()));
280      mirror::Class* result = class_linker->DefineClass(soa.Self(),
281                                                        descriptor.c_str(),
282                                                        hash,
283                                                        class_loader,
284                                                        *dex_file,
285                                                        *dex_class_def);
286      // Add the used dex file. This only required for the DexFile.loadClass API since normal
287      // class loaders already keep their dex files live.
288      class_linker->InsertDexFileInToClassLoader(soa.Decode<mirror::Object*>(dexFile),
289                                                 class_loader.Get());
290      if (result != nullptr) {
291        VLOG(class_linker) << "DexFile_defineClassNative returning " << result
292                           << " for " << class_name.c_str();
293        return soa.AddLocalReference<jclass>(result);
294      }
295    }
296  }
297  VLOG(class_linker) << "Failed to find dex_class_def " << class_name.c_str();
298  return nullptr;
299}
300
301// Needed as a compare functor for sets of const char
302struct CharPointerComparator {
303  bool operator()(const char *str1, const char *str2) const {
304    return strcmp(str1, str2) < 0;
305  }
306};
307
308// Note: this can be an expensive call, as we sort out duplicates in MultiDex files.
309static jobjectArray DexFile_getClassNameList(JNIEnv* env, jclass, jobject cookie) {
310  const OatFile* oat_file = nullptr;
311  std::vector<const DexFile*> dex_files;
312  if (!ConvertJavaArrayToDexFiles(env, cookie, /*out */ dex_files, /* out */ oat_file)) {
313    DCHECK(env->ExceptionCheck());
314    return nullptr;
315  }
316
317  // Push all class descriptors into a set. Use set instead of unordered_set as we want to
318  // retrieve all in the end.
319  std::set<const char*, CharPointerComparator> descriptors;
320  for (auto& dex_file : dex_files) {
321    for (size_t i = 0; i < dex_file->NumClassDefs(); ++i) {
322      const DexFile::ClassDef& class_def = dex_file->GetClassDef(i);
323      const char* descriptor = dex_file->GetClassDescriptor(class_def);
324      descriptors.insert(descriptor);
325    }
326  }
327
328  // Now create output array and copy the set into it.
329  jobjectArray result = env->NewObjectArray(descriptors.size(),
330                                            WellKnownClasses::java_lang_String,
331                                            nullptr);
332  if (result != nullptr) {
333    auto it = descriptors.begin();
334    auto it_end = descriptors.end();
335    jsize i = 0;
336    for (; it != it_end; it++, ++i) {
337      std::string descriptor(DescriptorToDot(*it));
338      ScopedLocalRef<jstring> jdescriptor(env, env->NewStringUTF(descriptor.c_str()));
339      if (jdescriptor.get() == nullptr) {
340        return nullptr;
341      }
342      env->SetObjectArrayElement(result, i, jdescriptor.get());
343    }
344  }
345  return result;
346}
347
348static jint GetDexOptNeeded(JNIEnv* env,
349                            const char* filename,
350                            const char* instruction_set,
351                            const int target_compilation_type_mask) {
352  if ((filename == nullptr) || !OS::FileExists(filename)) {
353    LOG(ERROR) << "DexFile_getDexOptNeeded file '" << filename << "' does not exist";
354    ScopedLocalRef<jclass> fnfe(env, env->FindClass("java/io/FileNotFoundException"));
355    const char* message = (filename == nullptr) ? "<empty file name>" : filename;
356    env->ThrowNew(fnfe.get(), message);
357    return -1;
358  }
359
360  const InstructionSet target_instruction_set = GetInstructionSetFromString(instruction_set);
361  if (target_instruction_set == kNone) {
362    ScopedLocalRef<jclass> iae(env, env->FindClass("java/lang/IllegalArgumentException"));
363    std::string message(StringPrintf("Instruction set %s is invalid.", instruction_set));
364    env->ThrowNew(iae.get(), message.c_str());
365    return -1;
366  }
367
368  // TODO: Verify the dex location is well formed, and throw an IOException if
369  // not?
370  OatFileAssistant oat_file_assistant(filename, target_compilation_type_mask,
371      target_instruction_set, false);
372
373  // Always treat elements of the bootclasspath as up-to-date.
374  if (oat_file_assistant.IsInBootClassPath()) {
375    return OatFileAssistant::kNoDexOptNeeded;
376  }
377
378  return oat_file_assistant.GetDexOptNeeded();
379}
380
381static jint DexFile_getDexOptNeeded(JNIEnv* env,
382                                    jclass,
383                                    jstring javaFilename,
384                                    jstring javaInstructionSet,
385                                    jint javaTargetCompilationTypeMask) {
386  ScopedUtfChars filename(env, javaFilename);
387  if (env->ExceptionCheck()) {
388    return -1;
389  }
390
391  ScopedUtfChars instruction_set(env, javaInstructionSet);
392  if (env->ExceptionCheck()) {
393    return -1;
394  }
395
396  return GetDexOptNeeded(env,
397                         filename.c_str(),
398                         instruction_set.c_str(),
399                         javaTargetCompilationTypeMask);
400}
401
402// public API
403static jboolean DexFile_isDexOptNeeded(JNIEnv* env, jclass, jstring javaFilename) {
404  const char* instruction_set = GetInstructionSetString(kRuntimeISA);
405  ScopedUtfChars filename(env, javaFilename);
406  jint status = GetDexOptNeeded(
407      env,
408      filename.c_str(),
409      instruction_set,
410      OatFileAssistant::kFullCompilation | OatFileAssistant::kProfileGuideCompilation);
411  return (status != OatFileAssistant::kNoDexOptNeeded) ? JNI_TRUE : JNI_FALSE;
412}
413
414static JNINativeMethod gMethods[] = {
415  NATIVE_METHOD(DexFile, closeDexFile, "(Ljava/lang/Object;)Z"),
416  NATIVE_METHOD(DexFile,
417                defineClassNative,
418                "(Ljava/lang/String;"
419                "Ljava/lang/ClassLoader;"
420                "Ljava/lang/Object;"
421                "Ldalvik/system/DexFile;"
422                ")Ljava/lang/Class;"),
423  NATIVE_METHOD(DexFile, getClassNameList, "(Ljava/lang/Object;)[Ljava/lang/String;"),
424  NATIVE_METHOD(DexFile, isDexOptNeeded, "(Ljava/lang/String;)Z"),
425  NATIVE_METHOD(DexFile, getDexOptNeeded,
426                "(Ljava/lang/String;Ljava/lang/String;I)I"),
427  NATIVE_METHOD(DexFile, openDexFileNative,
428                "(Ljava/lang/String;"
429                "Ljava/lang/String;"
430                "I"
431                "Ljava/lang/ClassLoader;"
432                "[Ldalvik/system/DexPathList$Element;"
433                ")Ljava/lang/Object;"),
434};
435
436void register_dalvik_system_DexFile(JNIEnv* env) {
437  REGISTER_NATIVE_METHODS("dalvik/system/DexFile");
438}
439
440}  // namespace art
441