blob: a55d7f1793b59afc14121769b2a36c0c131e8bd0 [file] [log] [blame]
/*
* Copyright (C) 2008 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <unistd.h>
#include "class_linker.h"
#include "class_loader.h"
#include "dex_file.h"
#include "image.h"
#include "jni_internal.h"
#include "logging.h"
#include "os.h"
#include "runtime.h"
#include "scoped_thread_state_change.h"
#include "ScopedLocalRef.h"
#include "ScopedUtfChars.h"
#include "gc/space.h"
#include "toStringArray.h"
#include "zip_archive.h"
namespace art {
// A smart pointer that provides read-only access to a Java string's UTF chars.
// Unlike libcore's NullableScopedUtfChars, this will *not* throw NullPointerException if
// passed a null jstring. The correct idiom is:
//
// NullableScopedUtfChars name(env, javaName);
// if (env->ExceptionCheck()) {
// return NULL;
// }
// // ... use name.c_str()
//
// TODO: rewrite to get rid of this, or change ScopedUtfChars to offer this option.
class NullableScopedUtfChars {
public:
NullableScopedUtfChars(JNIEnv* env, jstring s) : mEnv(env), mString(s) {
mUtfChars = (s != NULL) ? env->GetStringUTFChars(s, NULL) : NULL;
}
~NullableScopedUtfChars() {
if (mUtfChars) {
mEnv->ReleaseStringUTFChars(mString, mUtfChars);
}
}
const char* c_str() const {
return mUtfChars;
}
size_t size() const {
return strlen(mUtfChars);
}
// Element access.
const char& operator[](size_t n) const {
return mUtfChars[n];
}
private:
JNIEnv* mEnv;
jstring mString;
const char* mUtfChars;
// Disallow copy and assignment.
NullableScopedUtfChars(const NullableScopedUtfChars&);
void operator=(const NullableScopedUtfChars&);
};
static jint DexFile_openDexFile(JNIEnv* env, jclass, jstring javaSourceName, jstring javaOutputName, jint) {
ScopedUtfChars sourceName(env, javaSourceName);
if (sourceName.c_str() == NULL) {
return 0;
}
std::string source(sourceName.c_str());
NullableScopedUtfChars outputName(env, javaOutputName);
if (env->ExceptionCheck()) {
return 0;
}
ScopedObjectAccess soa(env);
const DexFile* dex_file;
if (outputName.c_str() == NULL) {
dex_file = Runtime::Current()->GetClassLinker()->FindDexFileInOatFileFromDexLocation(source);
} else {
std::string output(outputName.c_str());
dex_file =
Runtime::Current()->GetClassLinker()->FindOrCreateOatFileForDexLocation(source, output);
}
if (dex_file == NULL) {
LOG(WARNING) << "Failed to open dex file: " << source;
Thread::Current()->ThrowNewExceptionF("Ljava/io/IOException;", "Unable to open dex file: %s",
source.c_str());
return 0;
}
return static_cast<jint>(reinterpret_cast<uintptr_t>(dex_file));
}
static const DexFile* toDexFile(int dex_file_address)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
const DexFile* dex_file = reinterpret_cast<const DexFile*>(static_cast<uintptr_t>(dex_file_address));
if (dex_file == NULL) {
Thread::Current()->ThrowNewExceptionF("Ljava/lang/NullPointerException;", "dex_file == null");
}
return dex_file;
}
static void DexFile_closeDexFile(JNIEnv* env, jclass, jint cookie) {
const DexFile* dex_file;
{
ScopedObjectAccess soa(env);
dex_file = toDexFile(cookie);
}
if (dex_file == NULL) {
return;
}
if (Runtime::Current()->GetClassLinker()->IsDexFileRegistered(*dex_file)) {
return;
}
delete dex_file;
}
static jclass DexFile_defineClassNative(JNIEnv* env, jclass, jstring javaName, jobject javaLoader,
jint cookie) {
ScopedObjectAccess soa(env);
const DexFile* dex_file = toDexFile(cookie);
if (dex_file == NULL) {
return NULL;
}
ScopedUtfChars class_name(env, javaName);
if (class_name.c_str() == NULL) {
return NULL;
}
const std::string descriptor(DotToDescriptor(class_name.c_str()));
const DexFile::ClassDef* dex_class_def = dex_file->FindClassDef(descriptor);
if (dex_class_def == NULL) {
return NULL;
}
ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
class_linker->RegisterDexFile(*dex_file);
Object* class_loader_object = soa.Decode<Object*>(javaLoader);
ClassLoader* class_loader = down_cast<ClassLoader*>(class_loader_object);
Class* result = class_linker->DefineClass(descriptor, class_loader, *dex_file, *dex_class_def);
return soa.AddLocalReference<jclass>(result);
}
static jobjectArray DexFile_getClassNameList(JNIEnv* env, jclass, jint cookie) {
const DexFile* dex_file;
{
ScopedObjectAccess soa(env);
dex_file = toDexFile(cookie);
}
if (dex_file == NULL) {
return NULL;
}
std::vector<std::string> class_names;
for (size_t i = 0; i < dex_file->NumClassDefs(); ++i) {
const DexFile::ClassDef& class_def = dex_file->GetClassDef(i);
const char* descriptor = dex_file->GetClassDescriptor(class_def);
class_names.push_back(DescriptorToDot(descriptor));
}
return toStringArray(env, class_names);
}
static jboolean DexFile_isDexOptNeeded(JNIEnv* env, jclass, jstring javaFilename) {
bool debug_logging = false;
ScopedUtfChars filename(env, javaFilename);
if (filename.c_str() == NULL) {
LOG(ERROR) << "DexFile_isDexOptNeeded null filename";
return JNI_TRUE;
}
if (!OS::FileExists(filename.c_str())) {
LOG(ERROR) << "DexFile_isDexOptNeeded file '" << filename.c_str() << "' does not exist";
ScopedObjectAccess soa(env);
Thread::Current()->ThrowNewExceptionF("Ljava/io/FileNotFoundException;", "%s", filename.c_str());
return JNI_TRUE;
}
// Always treat elements of the bootclasspath as up-to-date. The
// fact that code is running at all means that this should be true.
Runtime* runtime = Runtime::Current();
ClassLinker* class_linker = runtime->GetClassLinker();
const std::vector<const DexFile*>& boot_class_path = class_linker->GetBootClassPath();
for (size_t i = 0; i < boot_class_path.size(); i++) {
if (boot_class_path[i]->GetLocation() == filename.c_str()) {
if (debug_logging) {
LOG(INFO) << "DexFile_isDexOptNeeded ignoring boot class path file: " << filename.c_str();
}
return JNI_FALSE;
}
}
// Check if we have an oat file next to the dex file.
std::string oat_filename(OatFile::DexFilenameToOatFilename(filename.c_str()));
UniquePtr<const OatFile> oat_file(
OatFile::Open(oat_filename, oat_filename, NULL, OatFile::kRelocNone));
if (oat_file.get() != NULL && oat_file->GetOatDexFile(filename.c_str()) != NULL) {
uint32_t location_checksum;
// If we have no classes.dex checksum such as in a user build, assume up-to-date.
if (!DexFile::GetChecksum(filename.c_str(), location_checksum)) {
if (debug_logging) {
LOG(INFO) << "DexFile_isDexOptNeeded ignoring precompiled stripped file: " << filename.c_str();
}
return JNI_FALSE;
}
ScopedObjectAccess soa(env);
if (ClassLinker::VerifyOatFileChecksums(oat_file.get(), filename.c_str(), location_checksum)) {
if (debug_logging) {
LOG(INFO) << "DexFile_isDexOptNeeded precompiled file " << oat_filename
<< " is up-to-date checksum compared to " << filename.c_str();
}
return JNI_FALSE;
}
}
// Check if we have an oat file in the cache
std::string cache_location(GetArtCacheFilenameOrDie(oat_filename));
oat_file.reset(
OatFile::Open(cache_location, oat_filename, NULL, OatFile::kRelocNone));
if (oat_file.get() == NULL) {
LOG(INFO) << "DexFile_isDexOptNeeded cache file " << cache_location
<< " does not exist for " << filename.c_str();
return JNI_TRUE;
}
Heap* heap = runtime->GetHeap();
const Spaces& spaces = heap->GetSpaces();
// TODO: C++0x auto
for (Spaces::const_iterator cur = spaces.begin(); cur != spaces.end(); ++cur) {
if ((*cur)->IsImageSpace()) {
// TODO: Ensure this works with multiple image spaces.
const ImageHeader& image_header = (*cur)->AsImageSpace()->GetImageHeader();
if (oat_file->GetOatHeader().GetImageFileLocationOatChecksum() != image_header.GetOatChecksum()) {
ScopedObjectAccess soa(env);
LOG(INFO) << "DexFile_isDexOptNeeded cache file " << cache_location
<< " has out-of-date oat checksum compared to "
<< image_header.GetImageRoot(ImageHeader::kOatLocation)->AsString()->ToModifiedUtf8();
return JNI_TRUE;
}
if (oat_file->GetOatHeader().GetImageFileLocationOatBegin()
!= reinterpret_cast<uint32_t>(image_header.GetOatBegin())) {
ScopedObjectAccess soa(env);
LOG(INFO) << "DexFile_isDexOptNeeded cache file " << cache_location
<< " has out-of-date oat begin compared to "
<< image_header.GetImageRoot(ImageHeader::kOatLocation)->AsString()->ToModifiedUtf8();
return JNI_TRUE;
}
}
}
uint32_t location_checksum;
if (!DexFile::GetChecksum(filename.c_str(), location_checksum)) {
LOG(ERROR) << "DexFile_isDexOptNeeded failed to compute checksum of " << filename.c_str();
return JNI_TRUE;
}
ScopedObjectAccess soa(env);
if (!ClassLinker::VerifyOatFileChecksums(oat_file.get(), filename.c_str(), location_checksum)) {
LOG(INFO) << "DexFile_isDexOptNeeded cache file " << cache_location
<< " has out-of-date checksum compared to " << filename.c_str();
return JNI_TRUE;
}
if (debug_logging) {
LOG(INFO) << "DexFile_isDexOptNeeded cache file " << cache_location
<< " is up-to-date for " << filename.c_str();
}
return JNI_FALSE;
}
static JNINativeMethod gMethods[] = {
NATIVE_METHOD(DexFile, closeDexFile, "(I)V"),
NATIVE_METHOD(DexFile, defineClassNative, "(Ljava/lang/String;Ljava/lang/ClassLoader;I)Ljava/lang/Class;"),
NATIVE_METHOD(DexFile, getClassNameList, "(I)[Ljava/lang/String;"),
NATIVE_METHOD(DexFile, isDexOptNeeded, "(Ljava/lang/String;)Z"),
NATIVE_METHOD(DexFile, openDexFile, "(Ljava/lang/String;Ljava/lang/String;I)I"),
};
void register_dalvik_system_DexFile(JNIEnv* env) {
REGISTER_NATIVE_METHODS("dalvik/system/DexFile");
}
} // namespace art