dalvik_system_DexFile.cc revision 80b37b7e679a530738c9bcbd39873b6dacf177e5 
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(
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  Runtime* const runtime = Runtime::Current();
164  ClassLinker* linker = runtime->GetClassLinker();
165  std::vector<std::unique_ptr<const DexFile>> dex_files;
166  std::vector<std::string> error_msgs;
167  const OatFile* oat_file = nullptr;
168
169  dex_files = runtime->GetOatFileManager().OpenDexFilesFromOat(sourceName.c_str(),
170                                                               outputName.c_str(),
171                                                               /*out*/ &oat_file,
172                                                               /*out*/ &error_msgs);
173
174  if (!dex_files.empty()) {
175    jlongArray array = ConvertDexFilesToJavaArray(env, oat_file, dex_files);
176    if (array == nullptr) {
177      ScopedObjectAccess soa(env);
178      for (auto& dex_file : dex_files) {
179        if (linker->FindDexCache(soa.Self(), *dex_file, true) != nullptr) {
180          dex_file.release();
181        }
182      }
183    }
184    return array;
185  } else {
186    ScopedObjectAccess soa(env);
187    CHECK(!error_msgs.empty());
188    // The most important message is at the end. So set up nesting by going forward, which will
189    // wrap the existing exception as a cause for the following one.
190    auto it = error_msgs.begin();
191    auto itEnd = error_msgs.end();
192    for ( ; it != itEnd; ++it) {
193      ThrowWrappedIOException("%s", it->c_str());
194    }
195
196    return nullptr;
197  }
198}
199
200static jboolean DexFile_closeDexFile(JNIEnv* env, jclass, jobject cookie) {
201  std::vector<const DexFile*> dex_files;
202  const OatFile* oat_file;
203  if (!ConvertJavaArrayToDexFiles(env, cookie, dex_files, oat_file)) {
204    Thread::Current()->AssertPendingException();
205    return JNI_FALSE;
206  }
207  Runtime* const runtime = Runtime::Current();
208  bool all_deleted = true;
209  {
210    ScopedObjectAccess soa(env);
211    mirror::Object* dex_files_object = soa.Decode<mirror::Object*>(cookie);
212    mirror::LongArray* long_dex_files = dex_files_object->AsLongArray();
213    // Delete dex files associated with this dalvik.system.DexFile since there should not be running
214    // code using it. dex_files is a vector due to multidex.
215    ClassLinker* const class_linker = runtime->GetClassLinker();
216    int32_t i = kDexFileIndexStart;  // Oat file is at index 0.
217    for (const DexFile* dex_file : dex_files) {
218      if (dex_file != nullptr) {
219        // Only delete the dex file if the dex cache is not found to prevent runtime crashes if there
220        // are calls to DexFile.close while the ART DexFile is still in use.
221        if (class_linker->FindDexCache(soa.Self(), *dex_file, true) == nullptr) {
222          // Clear the element in the array so that we can call close again.
223          long_dex_files->Set(i, 0);
224          delete dex_file;
225        } else {
226          all_deleted = false;
227        }
228      }
229      ++i;
230    }
231  }
232
233  // oat_file can be null if we are running without dex2oat.
234  if (all_deleted && oat_file != nullptr) {
235    // If all of the dex files are no longer in use we can unmap the corresponding oat file.
236    VLOG(class_linker) << "Unregistering " << oat_file;
237    runtime->GetOatFileManager().UnRegisterAndDeleteOatFile(oat_file);
238  }
239  return all_deleted ? JNI_TRUE : JNI_FALSE;
240}
241
242static jclass DexFile_defineClassNative(JNIEnv* env,
243                                        jclass,
244                                        jstring javaName,
245                                        jobject javaLoader,
246                                        jobject cookie) {
247  std::vector<const DexFile*> dex_files;
248  const OatFile* oat_file;
249  if (!ConvertJavaArrayToDexFiles(env, cookie, /*out*/ dex_files, /*out*/ oat_file)) {
250    VLOG(class_linker) << "Failed to find dex_file";
251    DCHECK(env->ExceptionCheck());
252    return nullptr;
253  }
254
255  ScopedUtfChars class_name(env, javaName);
256  if (class_name.c_str() == nullptr) {
257    VLOG(class_linker) << "Failed to find class_name";
258    return nullptr;
259  }
260  const std::string descriptor(DotToDescriptor(class_name.c_str()));
261  const size_t hash(ComputeModifiedUtf8Hash(descriptor.c_str()));
262  for (auto& dex_file : dex_files) {
263    const DexFile::ClassDef* dex_class_def = dex_file->FindClassDef(descriptor.c_str(), hash);
264    if (dex_class_def != nullptr) {
265      ScopedObjectAccess soa(env);
266      ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
267      class_linker->RegisterDexFile(*dex_file);
268      StackHandleScope<1> hs(soa.Self());
269      Handle<mirror::ClassLoader> class_loader(
270          hs.NewHandle(soa.Decode<mirror::ClassLoader*>(javaLoader)));
271      mirror::Class* result = class_linker->DefineClass(soa.Self(),
272                                                        descriptor.c_str(),
273                                                        hash,
274                                                        class_loader,
275                                                        *dex_file,
276                                                        *dex_class_def);
277      if (result != nullptr) {
278        VLOG(class_linker) << "DexFile_defineClassNative returning " << result
279                           << " for " << class_name.c_str();
280        return soa.AddLocalReference<jclass>(result);
281      }
282    }
283  }
284  VLOG(class_linker) << "Failed to find dex_class_def " << class_name.c_str();
285  return nullptr;
286}
287
288// Needed as a compare functor for sets of const char
289struct CharPointerComparator {
290  bool operator()(const char *str1, const char *str2) const {
291    return strcmp(str1, str2) < 0;
292  }
293};
294
295// Note: this can be an expensive call, as we sort out duplicates in MultiDex files.
296static jobjectArray DexFile_getClassNameList(JNIEnv* env, jclass, jobject cookie) {
297  const OatFile* oat_file = nullptr;
298  std::vector<const DexFile*> dex_files;
299  if (!ConvertJavaArrayToDexFiles(env, cookie, /*out */ dex_files, /* out */ oat_file)) {
300    DCHECK(env->ExceptionCheck());
301    return nullptr;
302  }
303
304  // Push all class descriptors into a set. Use set instead of unordered_set as we want to
305  // retrieve all in the end.
306  std::set<const char*, CharPointerComparator> descriptors;
307  for (auto& dex_file : dex_files) {
308    for (size_t i = 0; i < dex_file->NumClassDefs(); ++i) {
309      const DexFile::ClassDef& class_def = dex_file->GetClassDef(i);
310      const char* descriptor = dex_file->GetClassDescriptor(class_def);
311      descriptors.insert(descriptor);
312    }
313  }
314
315  // Now create output array and copy the set into it.
316  jobjectArray result = env->NewObjectArray(descriptors.size(),
317                                            WellKnownClasses::java_lang_String,
318                                            nullptr);
319  if (result != nullptr) {
320    auto it = descriptors.begin();
321    auto it_end = descriptors.end();
322    jsize i = 0;
323    for (; it != it_end; it++, ++i) {
324      std::string descriptor(DescriptorToDot(*it));
325      ScopedLocalRef<jstring> jdescriptor(env, env->NewStringUTF(descriptor.c_str()));
326      if (jdescriptor.get() == nullptr) {
327        return nullptr;
328      }
329      env->SetObjectArrayElement(result, i, jdescriptor.get());
330    }
331  }
332  return result;
333}
334
335static jint GetDexOptNeeded(JNIEnv* env,
336                            const char* filename,
337                            const char* pkgname,
338                            const char* instruction_set,
339                            const jboolean defer) {
340  if ((filename == nullptr) || !OS::FileExists(filename)) {
341    LOG(ERROR) << "DexFile_getDexOptNeeded file '" << filename << "' does not exist";
342    ScopedLocalRef<jclass> fnfe(env, env->FindClass("java/io/FileNotFoundException"));
343    const char* message = (filename == nullptr) ? "<empty file name>" : filename;
344    env->ThrowNew(fnfe.get(), message);
345    return OatFileAssistant::kNoDexOptNeeded;
346  }
347
348  const InstructionSet target_instruction_set = GetInstructionSetFromString(instruction_set);
349  if (target_instruction_set == kNone) {
350    ScopedLocalRef<jclass> iae(env, env->FindClass("java/lang/IllegalArgumentException"));
351    std::string message(StringPrintf("Instruction set %s is invalid.", instruction_set));
352    env->ThrowNew(iae.get(), message.c_str());
353    return 0;
354  }
355
356  // TODO: Verify the dex location is well formed, and throw an IOException if
357  // not?
358
359  OatFileAssistant oat_file_assistant(filename, target_instruction_set, false, pkgname);
360
361  // Always treat elements of the bootclasspath as up-to-date.
362  if (oat_file_assistant.IsInBootClassPath()) {
363    return OatFileAssistant::kNoDexOptNeeded;
364  }
365
366  // TODO: Checking the profile should probably be done in the GetStatus()
367  // function. We have it here because GetStatus() should not be copying
368  // profile files. But who should be copying profile files?
369  if (oat_file_assistant.OdexFileIsOutOfDate()) {
370    // Needs recompile if profile has changed significantly.
371    if (Runtime::Current()->GetProfilerOptions().IsEnabled()) {
372      if (oat_file_assistant.IsProfileChangeSignificant()) {
373        if (!defer) {
374          oat_file_assistant.CopyProfileFile();
375        }
376        return OatFileAssistant::kDex2OatNeeded;
377      } else if (oat_file_assistant.ProfileExists()
378          && !oat_file_assistant.OldProfileExists()) {
379        if (!defer) {
380          oat_file_assistant.CopyProfileFile();
381        }
382      }
383    }
384  }
385
386  return oat_file_assistant.GetDexOptNeeded();
387}
388
389static jint DexFile_getDexOptNeeded(JNIEnv* env,
390                                    jclass,
391                                    jstring javaFilename,
392                                    jstring javaPkgname,
393                                    jstring javaInstructionSet,
394                                    jboolean defer) {
395  ScopedUtfChars filename(env, javaFilename);
396  if (env->ExceptionCheck()) {
397    return 0;
398  }
399
400  NullableScopedUtfChars pkgname(env, javaPkgname);
401
402  ScopedUtfChars instruction_set(env, javaInstructionSet);
403  if (env->ExceptionCheck()) {
404    return 0;
405  }
406
407  return GetDexOptNeeded(env,
408                         filename.c_str(),
409                         pkgname.c_str(),
410                         instruction_set.c_str(),
411                         defer);
412}
413
414// public API, null pkgname
415static jboolean DexFile_isDexOptNeeded(JNIEnv* env, jclass, jstring javaFilename) {
416  const char* instruction_set = GetInstructionSetString(kRuntimeISA);
417  ScopedUtfChars filename(env, javaFilename);
418  jint status = GetDexOptNeeded(env, filename.c_str(), nullptr /* pkgname */,
419                                instruction_set, false /* defer */);
420  return (status != OatFileAssistant::kNoDexOptNeeded) ? JNI_TRUE : JNI_FALSE;
421}
422
423static JNINativeMethod gMethods[] = {
424  NATIVE_METHOD(DexFile, closeDexFile, "(Ljava/lang/Object;)Z"),
425  NATIVE_METHOD(DexFile, defineClassNative,
426                "(Ljava/lang/String;Ljava/lang/ClassLoader;Ljava/lang/Object;)Ljava/lang/Class;"),
427  NATIVE_METHOD(DexFile, getClassNameList, "(Ljava/lang/Object;)[Ljava/lang/String;"),
428  NATIVE_METHOD(DexFile, isDexOptNeeded, "(Ljava/lang/String;)Z"),
429  NATIVE_METHOD(DexFile, getDexOptNeeded,
430                "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Z)I"),
431  NATIVE_METHOD(DexFile, openDexFileNative,
432                "(Ljava/lang/String;Ljava/lang/String;I)Ljava/lang/Object;"),
433};
434
435void register_dalvik_system_DexFile(JNIEnv* env) {
436  REGISTER_NATIVE_METHODS("dalvik/system/DexFile");
437}
438
439}  // namespace art
440