1 /* 2 * Copyright (C) 2017 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 "verification.h" 18 19 #include <iomanip> 20 #include <sstream> 21 22 #include "art_field-inl.h" 23 #include "base/file_utils.h" 24 #include "base/logging.h" 25 #include "mirror/class-inl.h" 26 #include "mirror/object-refvisitor-inl.h" 27 28 namespace art { 29 namespace gc { 30 31 std::string Verification::DumpRAMAroundAddress(uintptr_t addr, uintptr_t bytes) const { 32 const uintptr_t dump_start = addr - bytes; 33 const uintptr_t dump_end = addr + bytes; 34 std::ostringstream oss; 35 if (dump_start < dump_end && 36 IsAddressInHeapSpace(reinterpret_cast<const void*>(dump_start)) && 37 IsAddressInHeapSpace(reinterpret_cast<const void*>(dump_end - 1))) { 38 oss << " adjacent_ram="; 39 for (uintptr_t p = dump_start; p < dump_end; ++p) { 40 if (p == addr) { 41 // Marker of where the address is. 42 oss << "|"; 43 } 44 uint8_t* ptr = reinterpret_cast<uint8_t*>(p); 45 oss << std::hex << std::setfill('0') << std::setw(2) << static_cast<uintptr_t>(*ptr); 46 } 47 } else { 48 oss << " <invalid address>"; 49 } 50 return oss.str(); 51 } 52 53 std::string Verification::DumpObjectInfo(const void* addr, const char* tag) const { 54 std::ostringstream oss; 55 oss << tag << "=" << addr; 56 if (IsValidHeapObjectAddress(addr)) { 57 mirror::Object* obj = reinterpret_cast<mirror::Object*>(const_cast<void*>(addr)); 58 mirror::Class* klass = obj->GetClass<kVerifyNone, kWithoutReadBarrier>(); 59 oss << " klass=" << klass; 60 if (IsValidClass(klass)) { 61 oss << "(" << klass->PrettyClass() << ")"; 62 if (klass->IsArrayClass<kVerifyNone>()) { 63 oss << " length=" << obj->AsArray<kVerifyNone>()->GetLength(); 64 } 65 } else { 66 oss << " <invalid address>"; 67 } 68 space::Space* const space = heap_->FindSpaceFromAddress(addr); 69 if (space != nullptr) { 70 oss << " space=" << *space; 71 } 72 accounting::CardTable* card_table = heap_->GetCardTable(); 73 if (card_table->AddrIsInCardTable(addr)) { 74 oss << " card=" << static_cast<size_t>( 75 card_table->GetCard(reinterpret_cast<const mirror::Object*>(addr))); 76 } 77 // Dump adjacent RAM. 78 oss << DumpRAMAroundAddress(reinterpret_cast<uintptr_t>(addr), 4 * kObjectAlignment); 79 } else { 80 oss << " <invalid address>"; 81 } 82 return oss.str(); 83 } 84 85 void Verification::LogHeapCorruption(ObjPtr<mirror::Object> holder, 86 MemberOffset offset, 87 mirror::Object* ref, 88 bool fatal) const { 89 // Lowest priority logging first: 90 PrintFileToLog("/proc/self/maps", android::base::LogSeverity::FATAL_WITHOUT_ABORT); 91 MemMap::DumpMaps(LOG_STREAM(FATAL_WITHOUT_ABORT), /* terse= */ true); 92 Runtime::Current()->GetHeap()->DumpSpaces(LOG_STREAM(FATAL_WITHOUT_ABORT)); 93 // Buffer the output in the string stream since it is more important than the stack traces 94 // and we want it to have log priority. The stack traces are printed from Runtime::Abort 95 // which is called from LOG(FATAL) but before the abort message. 96 std::ostringstream oss; 97 oss << "GC tried to mark invalid reference " << ref << std::endl; 98 oss << DumpObjectInfo(ref, "ref") << "\n"; 99 oss << DumpObjectInfo(holder.Ptr(), "holder"); 100 if (holder != nullptr) { 101 mirror::Class* holder_klass = holder->GetClass<kVerifyNone, kWithoutReadBarrier>(); 102 if (IsValidClass(holder_klass)) { 103 oss << " field_offset=" << offset.Uint32Value(); 104 ArtField* field = holder->FindFieldByOffset(offset); 105 if (field != nullptr) { 106 oss << " name=" << field->GetName(); 107 } 108 } 109 mirror::HeapReference<mirror::Object>* addr = holder->GetFieldObjectReferenceAddr(offset); 110 oss << " reference addr" 111 << DumpRAMAroundAddress(reinterpret_cast<uintptr_t>(addr), 4 * kObjectAlignment); 112 } 113 114 if (fatal) { 115 LOG(FATAL) << oss.str(); 116 } else { 117 LOG(FATAL_WITHOUT_ABORT) << oss.str(); 118 } 119 } 120 121 bool Verification::IsAddressInHeapSpace(const void* addr, space::Space** out_space) const { 122 space::Space* const space = heap_->FindSpaceFromAddress(addr); 123 if (space != nullptr) { 124 if (out_space != nullptr) { 125 *out_space = space; 126 } 127 return true; 128 } 129 return false; 130 } 131 132 bool Verification::IsValidHeapObjectAddress(const void* addr, space::Space** out_space) const { 133 return IsAligned<kObjectAlignment>(addr) && IsAddressInHeapSpace(addr, out_space); 134 } 135 136 bool Verification::IsValidClass(const void* addr) const { 137 if (!IsValidHeapObjectAddress(addr)) { 138 return false; 139 } 140 mirror::Class* klass = reinterpret_cast<mirror::Class*>(const_cast<void*>(addr)); 141 mirror::Class* k1 = klass->GetClass<kVerifyNone, kWithoutReadBarrier>(); 142 if (!IsValidHeapObjectAddress(k1)) { 143 return false; 144 } 145 // `k1` should be class class, take the class again to verify. 146 // Note that this check may not be valid for the no image space since the class class might move 147 // around from moving GC. 148 mirror::Class* k2 = k1->GetClass<kVerifyNone, kWithoutReadBarrier>(); 149 if (!IsValidHeapObjectAddress(k2)) { 150 return false; 151 } 152 return k1 == k2; 153 } 154 155 using ObjectSet = std::set<mirror::Object*>; 156 using WorkQueue = std::deque<std::pair<mirror::Object*, std::string>>; 157 158 // Use for visiting the GcRoots held live by ArtFields, ArtMethods, and ClassLoaders. 159 class Verification::BFSFindReachable { 160 public: 161 explicit BFSFindReachable(ObjectSet* visited) : visited_(visited) {} 162 163 void operator()(mirror::Object* obj, MemberOffset offset, bool is_static ATTRIBUTE_UNUSED) const 164 REQUIRES_SHARED(Locks::mutator_lock_) { 165 ArtField* field = obj->FindFieldByOffset(offset); 166 Visit(obj->GetFieldObject<mirror::Object>(offset), 167 field != nullptr ? field->GetName() : ""); 168 } 169 170 void VisitRootIfNonNull(mirror::CompressedReference<mirror::Object>* root) const 171 REQUIRES_SHARED(Locks::mutator_lock_) { 172 if (!root->IsNull()) { 173 VisitRoot(root); 174 } 175 } 176 177 void VisitRoot(mirror::CompressedReference<mirror::Object>* root) const 178 REQUIRES_SHARED(Locks::mutator_lock_) { 179 Visit(root->AsMirrorPtr(), "!nativeRoot"); 180 } 181 182 void Visit(mirror::Object* ref, const std::string& field_name) const 183 REQUIRES_SHARED(Locks::mutator_lock_) { 184 if (ref != nullptr && visited_->insert(ref).second) { 185 new_visited_.emplace_back(ref, field_name); 186 } 187 } 188 189 const WorkQueue& NewlyVisited() const { 190 return new_visited_; 191 } 192 193 private: 194 ObjectSet* visited_; 195 mutable WorkQueue new_visited_; 196 }; 197 198 class Verification::CollectRootVisitor : public SingleRootVisitor { 199 public: 200 CollectRootVisitor(ObjectSet* visited, WorkQueue* work) : visited_(visited), work_(work) {} 201 202 void VisitRoot(mirror::Object* obj, const RootInfo& info) 203 override REQUIRES_SHARED(Locks::mutator_lock_) { 204 if (obj != nullptr && visited_->insert(obj).second) { 205 std::ostringstream oss; 206 oss << info.ToString() << " = " << obj << "(" << obj->PrettyTypeOf() << ")"; 207 work_->emplace_back(obj, oss.str()); 208 } 209 } 210 211 private: 212 ObjectSet* const visited_; 213 WorkQueue* const work_; 214 }; 215 216 std::string Verification::FirstPathFromRootSet(ObjPtr<mirror::Object> target) const { 217 Runtime* const runtime = Runtime::Current(); 218 std::set<mirror::Object*> visited; 219 std::deque<std::pair<mirror::Object*, std::string>> work; 220 { 221 CollectRootVisitor root_visitor(&visited, &work); 222 runtime->VisitRoots(&root_visitor, kVisitRootFlagAllRoots); 223 } 224 while (!work.empty()) { 225 auto pair = work.front(); 226 work.pop_front(); 227 if (pair.first == target) { 228 return pair.second; 229 } 230 BFSFindReachable visitor(&visited); 231 pair.first->VisitReferences(visitor, VoidFunctor()); 232 for (auto&& pair2 : visitor.NewlyVisited()) { 233 std::ostringstream oss; 234 mirror::Object* obj = pair2.first; 235 oss << pair.second << " -> " << obj << "(" << obj->PrettyTypeOf() << ")." << pair2.second; 236 work.emplace_back(obj, oss.str()); 237 } 238 } 239 return "<no path found>"; 240 } 241 242 } // namespace gc 243 } // namespace art 244
