| /* Copyright (C) 2016 The Android Open Source Project |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This file implements interfaces from the file jvmti.h. This implementation |
| * is licensed under the same terms as the file jvmti.h. The |
| * copyright and license information for the file jvmti.h follows. |
| * |
| * Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| #include "ti_class_definition.h" |
| |
| #include "base/array_slice.h" |
| #include "base/logging.h" |
| #include "class_linker-inl.h" |
| #include "class_root.h" |
| #include "dex/dex_file.h" |
| #include "fixed_up_dex_file.h" |
| #include "handle.h" |
| #include "handle_scope-inl.h" |
| #include "mirror/class-inl.h" |
| #include "mirror/class_ext.h" |
| #include "mirror/object-inl.h" |
| #include "reflection.h" |
| #include "thread.h" |
| |
| namespace openjdkjvmti { |
| |
| void ArtClassDefinition::InitializeMemory() const { |
| DCHECK(art::MemMap::kCanReplaceMapping); |
| VLOG(signals) << "Initializing de-quickened memory for dex file of " << name_; |
| CHECK(dex_data_mmap_.IsValid()); |
| CHECK(temp_mmap_.IsValid()); |
| CHECK_EQ(dex_data_mmap_.GetProtect(), PROT_NONE); |
| CHECK_EQ(temp_mmap_.GetProtect(), PROT_READ | PROT_WRITE); |
| |
| std::string desc = std::string("L") + name_ + ";"; |
| std::unique_ptr<FixedUpDexFile> |
| fixed_dex_file(FixedUpDexFile::Create(*initial_dex_file_unquickened_, desc.c_str())); |
| CHECK(fixed_dex_file.get() != nullptr); |
| CHECK_LE(fixed_dex_file->Size(), temp_mmap_.Size()); |
| CHECK_EQ(temp_mmap_.Size(), dex_data_mmap_.Size()); |
| // Copy the data to the temp mmap. |
| memcpy(temp_mmap_.Begin(), fixed_dex_file->Begin(), fixed_dex_file->Size()); |
| |
| // Move the mmap atomically. |
| art::MemMap source; |
| source.swap(temp_mmap_); |
| std::string error; |
| CHECK(dex_data_mmap_.ReplaceWith(&source, &error)) << "Failed to replace mmap for " |
| << name_ << " because " << error; |
| CHECK(dex_data_mmap_.Protect(PROT_READ)); |
| } |
| |
| bool ArtClassDefinition::IsModified() const { |
| // RedefineClasses calls always are 'modified' since they need to change the current_dex_file of |
| // the class. |
| if (redefined_) { |
| return true; |
| } |
| |
| // Check to see if any change has taken place. |
| if (current_dex_file_.data() == dex_data_.data()) { |
| // no change at all. |
| return false; |
| } |
| |
| // The dex_data_ was never touched by the agents. |
| if (dex_data_mmap_.IsValid() && dex_data_mmap_.GetProtect() == PROT_NONE) { |
| if (current_dex_file_.data() == dex_data_mmap_.Begin()) { |
| // the dex_data_ looks like it changed (not equal to current_dex_file_) but we never |
| // initialized the dex_data_mmap_. This means the new_dex_data was filled in without looking |
| // at the initial dex_data_. |
| return true; |
| } else if (dex_data_.data() == dex_data_mmap_.Begin()) { |
| // The dex file used to have modifications but they were not added again. |
| return true; |
| } else { |
| // It's not clear what happened. It's possible that the agent got the current dex file data |
| // from some other source so we need to initialize everything to see if it is the same. |
| VLOG(signals) << "Lazy dex file for " << name_ << " was never touched but the dex_data_ is " |
| << "changed! Need to initialize the memory to see if anything changed"; |
| InitializeMemory(); |
| } |
| } |
| |
| // We can definitely read current_dex_file_ and dex_file_ without causing page faults. |
| |
| // Check if the dex file we want to set is the same as the current one. |
| // Unfortunately we need to do this check even if no modifications have been done since it could |
| // be that agents were removed in the mean-time so we still have a different dex file. The dex |
| // checksum means this is likely to be fairly fast. |
| return current_dex_file_.size() != dex_data_.size() || |
| memcmp(current_dex_file_.data(), dex_data_.data(), current_dex_file_.size()) != 0; |
| } |
| |
| jvmtiError ArtClassDefinition::InitCommon(art::Thread* self, jclass klass) { |
| art::ScopedObjectAccess soa(self); |
| art::ObjPtr<art::mirror::Class> m_klass(soa.Decode<art::mirror::Class>(klass)); |
| if (m_klass.IsNull()) { |
| return ERR(INVALID_CLASS); |
| } |
| initialized_ = true; |
| klass_ = klass; |
| loader_ = soa.AddLocalReference<jobject>(m_klass->GetClassLoader()); |
| std::string descriptor_store; |
| std::string descriptor(m_klass->GetDescriptor(&descriptor_store)); |
| name_ = descriptor.substr(1, descriptor.size() - 2); |
| // Android doesn't really have protection domains. |
| protection_domain_ = nullptr; |
| return OK; |
| } |
| |
| static void DequickenDexFile(const art::DexFile* dex_file, |
| const char* descriptor, |
| /*out*/std::vector<unsigned char>* dex_data) |
| REQUIRES_SHARED(art::Locks::mutator_lock_) { |
| std::unique_ptr<FixedUpDexFile> fixed_dex_file( |
| FixedUpDexFile::Create(*dex_file, descriptor)); |
| dex_data->resize(fixed_dex_file->Size()); |
| memcpy(dex_data->data(), fixed_dex_file->Begin(), fixed_dex_file->Size()); |
| } |
| |
| // Gets the data surrounding the given class. |
| static void GetDexDataForRetransformation(art::Handle<art::mirror::Class> klass, |
| /*out*/std::vector<unsigned char>* dex_data) |
| REQUIRES_SHARED(art::Locks::mutator_lock_) { |
| art::StackHandleScope<3> hs(art::Thread::Current()); |
| art::Handle<art::mirror::ClassExt> ext(hs.NewHandle(klass->GetExtData())); |
| const art::DexFile* dex_file = nullptr; |
| if (!ext.IsNull()) { |
| art::Handle<art::mirror::Object> orig_dex(hs.NewHandle(ext->GetOriginalDexFile())); |
| if (!orig_dex.IsNull()) { |
| if (orig_dex->IsArrayInstance()) { |
| DCHECK(orig_dex->GetClass()->GetComponentType()->IsPrimitiveByte()); |
| art::Handle<art::mirror::ByteArray> orig_dex_bytes( |
| hs.NewHandle(art::down_cast<art::mirror::ByteArray*>(orig_dex->AsArray()))); |
| dex_data->resize(orig_dex_bytes->GetLength()); |
| memcpy(dex_data->data(), orig_dex_bytes->GetData(), dex_data->size()); |
| return; |
| } else if (orig_dex->IsDexCache()) { |
| dex_file = orig_dex->AsDexCache()->GetDexFile(); |
| } else { |
| DCHECK(orig_dex->GetClass()->DescriptorEquals("Ljava/lang/Long;")) |
| << "Expected java/lang/Long but found object of type " |
| << orig_dex->GetClass()->PrettyClass(); |
| art::ObjPtr<art::mirror::Class> prim_long_class( |
| art::GetClassRoot(art::ClassRoot::kPrimitiveLong)); |
| art::JValue val; |
| if (!art::UnboxPrimitiveForResult(orig_dex.Get(), prim_long_class, &val)) { |
| // This should never happen. |
| LOG(FATAL) << "Unable to unbox a primitive long value!"; |
| } |
| dex_file = reinterpret_cast<const art::DexFile*>(static_cast<uintptr_t>(val.GetJ())); |
| } |
| } |
| } |
| if (dex_file == nullptr) { |
| dex_file = &klass->GetDexFile(); |
| } |
| std::string storage; |
| DequickenDexFile(dex_file, klass->GetDescriptor(&storage), dex_data); |
| } |
| |
| static bool DexNeedsDequickening(art::Handle<art::mirror::Class> klass, |
| /*out*/ bool* from_class_ext) |
| REQUIRES_SHARED(art::Locks::mutator_lock_) { |
| art::ObjPtr<art::mirror::ClassExt> ext(klass->GetExtData()); |
| if (ext.IsNull()) { |
| // We don't seem to have ever been redefined so be conservative and say we need de-quickening. |
| *from_class_ext = false; |
| return true; |
| } |
| art::ObjPtr<art::mirror::Object> orig_dex(ext->GetOriginalDexFile()); |
| if (orig_dex.IsNull()) { |
| // We don't seem to have ever been redefined so be conservative and say we need de-quickening. |
| *from_class_ext = false; |
| return true; |
| } else if (!orig_dex->IsArrayInstance()) { |
| // We were redefined but the original is held in a dex-cache or dex file. This means that the |
| // original dex file is the one from the disk, which might be quickened. |
| DCHECK(orig_dex->IsDexCache() || orig_dex->GetClass()->DescriptorEquals("Ljava/lang/Long;")); |
| *from_class_ext = true; |
| return true; |
| } else { |
| // An array instance means the original-dex-file is from a redefineClasses which cannot have any |
| // quickening, so it's fine to use directly. |
| DCHECK(orig_dex->GetClass()->GetComponentType()->IsPrimitiveByte()); |
| *from_class_ext = true; |
| return false; |
| } |
| } |
| |
| static const art::DexFile* GetQuickenedDexFile(art::Handle<art::mirror::Class> klass) |
| REQUIRES_SHARED(art::Locks::mutator_lock_) { |
| art::ObjPtr<art::mirror::ClassExt> ext(klass->GetExtData()); |
| if (ext.IsNull() || ext->GetOriginalDexFile() == nullptr) { |
| return &klass->GetDexFile(); |
| } |
| |
| art::ObjPtr<art::mirror::Object> orig_dex(ext->GetOriginalDexFile()); |
| DCHECK(!orig_dex->IsArrayInstance()); |
| if (orig_dex->IsDexCache()) { |
| return orig_dex->AsDexCache()->GetDexFile(); |
| } |
| |
| DCHECK(orig_dex->GetClass()->DescriptorEquals("Ljava/lang/Long;")) |
| << "Expected java/lang/Long but found object of type " |
| << orig_dex->GetClass()->PrettyClass(); |
| art::ObjPtr<art::mirror::Class> prim_long_class( |
| art::GetClassRoot(art::ClassRoot::kPrimitiveLong)); |
| art::JValue val; |
| if (!art::UnboxPrimitiveForResult(orig_dex.Ptr(), prim_long_class, &val)) { |
| LOG(FATAL) << "Unable to unwrap a long value!"; |
| } |
| return reinterpret_cast<const art::DexFile*>(static_cast<uintptr_t>(val.GetJ())); |
| } |
| |
| template<typename GetOriginalDexFile> |
| void ArtClassDefinition::InitWithDex(GetOriginalDexFile get_original, |
| const art::DexFile* quick_dex) { |
| art::Thread* self = art::Thread::Current(); |
| DCHECK(quick_dex != nullptr); |
| if (art::MemMap::kCanReplaceMapping && kEnableOnDemandDexDequicken) { |
| size_t dequick_size = quick_dex->GetDequickenedSize(); |
| std::string mmap_name("anon-mmap-for-redefine: "); |
| mmap_name += name_; |
| std::string error; |
| dex_data_mmap_ = art::MemMap::MapAnonymous(mmap_name.c_str(), |
| dequick_size, |
| PROT_NONE, |
| /*low_4gb=*/ false, |
| &error); |
| mmap_name += "-TEMP"; |
| temp_mmap_ = art::MemMap::MapAnonymous(mmap_name.c_str(), |
| dequick_size, |
| PROT_READ | PROT_WRITE, |
| /*low_4gb=*/ false, |
| &error); |
| if (UNLIKELY(dex_data_mmap_.IsValid() && temp_mmap_.IsValid())) { |
| // Need to save the initial dexfile so we don't need to search for it in the fault-handler. |
| initial_dex_file_unquickened_ = quick_dex; |
| dex_data_ = art::ArrayRef<const unsigned char>(dex_data_mmap_.Begin(), |
| dex_data_mmap_.Size()); |
| if (from_class_ext_) { |
| // We got initial from class_ext so the current one must have undergone redefinition so no |
| // cdex or quickening stuff. |
| // We can only do this if it's not a first load. |
| DCHECK(klass_ != nullptr); |
| const art::DexFile& cur_dex = self->DecodeJObject(klass_)->AsClass()->GetDexFile(); |
| current_dex_file_ = art::ArrayRef<const unsigned char>(cur_dex.Begin(), cur_dex.Size()); |
| } else { |
| // This class hasn't been redefined before. The dequickened current data is the same as the |
| // dex_data_mmap_ when it's filled it. We don't need to copy anything because the mmap will |
| // not be cleared until after everything is done. |
| current_dex_file_ = art::ArrayRef<const unsigned char>(dex_data_mmap_.Begin(), |
| dequick_size); |
| } |
| return; |
| } |
| } |
| dex_data_mmap_.Reset(); |
| temp_mmap_.Reset(); |
| // Failed to mmap a large enough area (or on-demand dequickening was disabled). This is |
| // unfortunate. Since currently the size is just a guess though we might as well try to do it |
| // manually. |
| get_original(/*out*/&dex_data_memory_); |
| dex_data_ = art::ArrayRef<const unsigned char>(dex_data_memory_); |
| if (from_class_ext_) { |
| // We got initial from class_ext so the current one must have undergone redefinition so no |
| // cdex or quickening stuff. |
| // We can only do this if it's not a first load. |
| DCHECK(klass_ != nullptr); |
| const art::DexFile& cur_dex = self->DecodeJObject(klass_)->AsClass()->GetDexFile(); |
| current_dex_file_ = art::ArrayRef<const unsigned char>(cur_dex.Begin(), cur_dex.Size()); |
| } else { |
| // No redefinition must have ever happened so the (dequickened) cur_dex is the same as the |
| // initial dex_data. We need to copy it into another buffer to keep it around if we have a |
| // real redefinition. |
| current_dex_memory_.resize(dex_data_.size()); |
| memcpy(current_dex_memory_.data(), dex_data_.data(), current_dex_memory_.size()); |
| current_dex_file_ = art::ArrayRef<const unsigned char>(current_dex_memory_); |
| } |
| } |
| |
| jvmtiError ArtClassDefinition::Init(art::Thread* self, jclass klass) { |
| jvmtiError res = InitCommon(self, klass); |
| if (res != OK) { |
| return res; |
| } |
| art::ScopedObjectAccess soa(self); |
| art::StackHandleScope<1> hs(self); |
| art::Handle<art::mirror::Class> m_klass(hs.NewHandle(self->DecodeJObject(klass)->AsClass())); |
| if (!DexNeedsDequickening(m_klass, &from_class_ext_)) { |
| // We don't need to do any dequickening. We want to copy the data just so we don't need to deal |
| // with the GC moving it around. |
| art::ObjPtr<art::mirror::ByteArray> orig_dex( |
| m_klass->GetExtData()->GetOriginalDexFile()->AsByteArray()); |
| dex_data_memory_.resize(orig_dex->GetLength()); |
| memcpy(dex_data_memory_.data(), orig_dex->GetData(), dex_data_memory_.size()); |
| dex_data_ = art::ArrayRef<const unsigned char>(dex_data_memory_); |
| |
| // Since we are here we must not have any quickened instructions since we were redefined. |
| const art::DexFile& cur_dex = m_klass->GetDexFile(); |
| DCHECK(from_class_ext_); |
| current_dex_file_ = art::ArrayRef<const unsigned char>(cur_dex.Begin(), cur_dex.Size()); |
| return OK; |
| } |
| |
| // We need to dequicken stuff. This is often super slow (10's of ms). Instead we will do it |
| // dynamically. |
| const art::DexFile* quick_dex = GetQuickenedDexFile(m_klass); |
| auto get_original = [&](/*out*/std::vector<unsigned char>* dex_data) |
| REQUIRES_SHARED(art::Locks::mutator_lock_) { |
| GetDexDataForRetransformation(m_klass, dex_data); |
| }; |
| InitWithDex(get_original, quick_dex); |
| return OK; |
| } |
| |
| jvmtiError ArtClassDefinition::Init(art::Thread* self, const jvmtiClassDefinition& def) { |
| jvmtiError res = InitCommon(self, def.klass); |
| if (res != OK) { |
| return res; |
| } |
| // We are being directly redefined. |
| redefined_ = true; |
| current_dex_file_ = art::ArrayRef<const unsigned char>(def.class_bytes, def.class_byte_count); |
| dex_data_ = art::ArrayRef<const unsigned char>(def.class_bytes, def.class_byte_count); |
| return OK; |
| } |
| |
| void ArtClassDefinition::InitFirstLoad(const char* descriptor, |
| art::Handle<art::mirror::ClassLoader> klass_loader, |
| const art::DexFile& dex_file) { |
| art::Thread* self = art::Thread::Current(); |
| art::ScopedObjectAccess soa(self); |
| initialized_ = true; |
| // No Class |
| klass_ = nullptr; |
| loader_ = soa.AddLocalReference<jobject>(klass_loader.Get()); |
| std::string descriptor_str(descriptor); |
| name_ = descriptor_str.substr(1, descriptor_str.size() - 2); |
| // Android doesn't really have protection domains. |
| protection_domain_ = nullptr; |
| auto get_original = [&](/*out*/std::vector<unsigned char>* dex_data) |
| REQUIRES_SHARED(art::Locks::mutator_lock_) { |
| DequickenDexFile(&dex_file, descriptor, dex_data); |
| }; |
| InitWithDex(get_original, &dex_file); |
| } |
| |
| } // namespace openjdkjvmti |