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 /*
18  * Preparation and completion of hprof data generation.  The output is
19  * written into two files and then combined.  This is necessary because
20  * we generate some of the data (strings and classes) while we dump the
21  * heap, and some analysis tools require that the class and string data
22  * appear first.
23  */
24 
25 #include "hprof.h"
26 
27 #include <errno.h>
28 #include <fcntl.h>
29 #include <stdio.h>
30 #include <string.h>
31 #include <sys/time.h>
32 #include <sys/uio.h>
33 #include <time.h>
34 #include <unistd.h>
35 
36 #include <set>
37 
38 #include <android-base/logging.h>
39 #include <android-base/stringprintf.h>
40 
41 #include "art_field-inl.h"
42 #include "art_method-inl.h"
43 #include "base/array_ref.h"
44 #include "base/file_utils.h"
45 #include "base/logging.h"
46 #include "base/macros.h"
47 #include "base/mutex.h"
48 #include "base/os.h"
49 #include "base/safe_map.h"
50 #include "base/time_utils.h"
51 #include "base/unix_file/fd_file.h"
52 #include "class_linker.h"
53 #include "class_root.h"
54 #include "common_throws.h"
55 #include "debugger.h"
56 #include "dex/dex_file-inl.h"
57 #include "gc/accounting/heap_bitmap.h"
58 #include "gc/allocation_record.h"
59 #include "gc/heap-visit-objects-inl.h"
60 #include "gc/heap.h"
61 #include "gc/scoped_gc_critical_section.h"
62 #include "gc/space/space.h"
63 #include "gc_root.h"
64 #include "mirror/class-inl.h"
65 #include "mirror/class.h"
66 #include "mirror/object-refvisitor-inl.h"
67 #include "runtime_globals.h"
68 #include "scoped_thread_state_change-inl.h"
69 #include "thread_list.h"
70 
71 namespace art {
72 
73 namespace hprof {
74 
75 static constexpr bool kDirectStream = true;
76 
77 static constexpr uint32_t kHprofTime = 0;
78 static constexpr uint32_t kHprofNullThread = 0;
79 
80 static constexpr size_t kMaxObjectsPerSegment = 128;
81 static constexpr size_t kMaxBytesPerSegment = 4096;
82 
83 // The static field-name for the synthetic object generated to account for class static overhead.
84 static constexpr const char* kClassOverheadName = "$classOverhead";
85 
86 enum HprofTag {
87   HPROF_TAG_STRING = 0x01,
88   HPROF_TAG_LOAD_CLASS = 0x02,
89   HPROF_TAG_UNLOAD_CLASS = 0x03,
90   HPROF_TAG_STACK_FRAME = 0x04,
91   HPROF_TAG_STACK_TRACE = 0x05,
92   HPROF_TAG_ALLOC_SITES = 0x06,
93   HPROF_TAG_HEAP_SUMMARY = 0x07,
94   HPROF_TAG_START_THREAD = 0x0A,
95   HPROF_TAG_END_THREAD = 0x0B,
96   HPROF_TAG_HEAP_DUMP = 0x0C,
97   HPROF_TAG_HEAP_DUMP_SEGMENT = 0x1C,
98   HPROF_TAG_HEAP_DUMP_END = 0x2C,
99   HPROF_TAG_CPU_SAMPLES = 0x0D,
100   HPROF_TAG_CONTROL_SETTINGS = 0x0E,
101 };
102 
103 // Values for the first byte of HEAP_DUMP and HEAP_DUMP_SEGMENT records:
104 enum HprofHeapTag {
105   // Traditional.
106   HPROF_ROOT_UNKNOWN = 0xFF,
107   HPROF_ROOT_JNI_GLOBAL = 0x01,
108   HPROF_ROOT_JNI_LOCAL = 0x02,
109   HPROF_ROOT_JAVA_FRAME = 0x03,
110   HPROF_ROOT_NATIVE_STACK = 0x04,
111   HPROF_ROOT_STICKY_CLASS = 0x05,
112   HPROF_ROOT_THREAD_BLOCK = 0x06,
113   HPROF_ROOT_MONITOR_USED = 0x07,
114   HPROF_ROOT_THREAD_OBJECT = 0x08,
115   HPROF_CLASS_DUMP = 0x20,
116   HPROF_INSTANCE_DUMP = 0x21,
117   HPROF_OBJECT_ARRAY_DUMP = 0x22,
118   HPROF_PRIMITIVE_ARRAY_DUMP = 0x23,
119 
120   // Android.
121   HPROF_HEAP_DUMP_INFO = 0xfe,
122   HPROF_ROOT_INTERNED_STRING = 0x89,
123   HPROF_ROOT_FINALIZING = 0x8a,  // Obsolete.
124   HPROF_ROOT_DEBUGGER = 0x8b,
125   HPROF_ROOT_REFERENCE_CLEANUP = 0x8c,  // Obsolete.
126   HPROF_ROOT_VM_INTERNAL = 0x8d,
127   HPROF_ROOT_JNI_MONITOR = 0x8e,
128   HPROF_UNREACHABLE = 0x90,  // Obsolete.
129   HPROF_PRIMITIVE_ARRAY_NODATA_DUMP = 0xc3,  // Obsolete.
130 };
131 
132 enum HprofHeapId {
133   HPROF_HEAP_DEFAULT = 0,
134   HPROF_HEAP_ZYGOTE = 'Z',
135   HPROF_HEAP_APP = 'A',
136   HPROF_HEAP_IMAGE = 'I',
137 };
138 
139 enum HprofBasicType {
140   hprof_basic_object = 2,
141   hprof_basic_boolean = 4,
142   hprof_basic_char = 5,
143   hprof_basic_float = 6,
144   hprof_basic_double = 7,
145   hprof_basic_byte = 8,
146   hprof_basic_short = 9,
147   hprof_basic_int = 10,
148   hprof_basic_long = 11,
149 };
150 
151 using HprofStringId = uint32_t;
152 using HprofClassObjectId = uint32_t;
153 using HprofClassSerialNumber = uint32_t;
154 using HprofStackTraceSerialNumber = uint32_t;
155 using HprofStackFrameId = uint32_t;
156 static constexpr HprofStackTraceSerialNumber kHprofNullStackTrace = 0;
157 
158 class EndianOutput {
159  public:
EndianOutput()160   EndianOutput() : length_(0), sum_length_(0), max_length_(0), started_(false) {}
~EndianOutput()161   virtual ~EndianOutput() {}
162 
StartNewRecord(uint8_t tag,uint32_t time)163   void StartNewRecord(uint8_t tag, uint32_t time) {
164     if (length_ > 0) {
165       EndRecord();
166     }
167     DCHECK_EQ(length_, 0U);
168     AddU1(tag);
169     AddU4(time);
170     AddU4(0xdeaddead);  // Length, replaced on flush.
171     started_ = true;
172   }
173 
EndRecord()174   void EndRecord() {
175     // Replace length in header.
176     if (started_) {
177       UpdateU4(sizeof(uint8_t) + sizeof(uint32_t),
178                length_ - sizeof(uint8_t) - 2 * sizeof(uint32_t));
179     }
180 
181     HandleEndRecord();
182 
183     sum_length_ += length_;
184     max_length_ = std::max(max_length_, length_);
185     length_ = 0;
186     started_ = false;
187   }
188 
AddU1(uint8_t value)189   void AddU1(uint8_t value) {
190     AddU1List(&value, 1);
191   }
AddU2(uint16_t value)192   void AddU2(uint16_t value) {
193     AddU2List(&value, 1);
194   }
AddU4(uint32_t value)195   void AddU4(uint32_t value) {
196     AddU4List(&value, 1);
197   }
198 
AddU8(uint64_t value)199   void AddU8(uint64_t value) {
200     AddU8List(&value, 1);
201   }
202 
AddObjectId(const mirror::Object * value)203   void AddObjectId(const mirror::Object* value) {
204     AddU4(PointerToLowMemUInt32(value));
205   }
206 
AddStackTraceSerialNumber(HprofStackTraceSerialNumber value)207   void AddStackTraceSerialNumber(HprofStackTraceSerialNumber value) {
208     AddU4(value);
209   }
210 
211   // The ID for the synthetic object generated to account for class static overhead.
AddClassStaticsId(const mirror::Class * value)212   void AddClassStaticsId(const mirror::Class* value) {
213     AddU4(1 | PointerToLowMemUInt32(value));
214   }
215 
AddJniGlobalRefId(jobject value)216   void AddJniGlobalRefId(jobject value) {
217     AddU4(PointerToLowMemUInt32(value));
218   }
219 
AddClassId(HprofClassObjectId value)220   void AddClassId(HprofClassObjectId value) {
221     AddU4(value);
222   }
223 
AddStringId(HprofStringId value)224   void AddStringId(HprofStringId value) {
225     AddU4(value);
226   }
227 
AddU1List(const uint8_t * values,size_t count)228   void AddU1List(const uint8_t* values, size_t count) {
229     HandleU1List(values, count);
230     length_ += count;
231   }
AddU2List(const uint16_t * values,size_t count)232   void AddU2List(const uint16_t* values, size_t count) {
233     HandleU2List(values, count);
234     length_ += count * sizeof(uint16_t);
235   }
AddU4List(const uint32_t * values,size_t count)236   void AddU4List(const uint32_t* values, size_t count) {
237     HandleU4List(values, count);
238     length_ += count * sizeof(uint32_t);
239   }
UpdateU4(size_t offset,uint32_t new_value ATTRIBUTE_UNUSED)240   virtual void UpdateU4(size_t offset, uint32_t new_value ATTRIBUTE_UNUSED) {
241     DCHECK_LE(offset, length_ - 4);
242   }
AddU8List(const uint64_t * values,size_t count)243   void AddU8List(const uint64_t* values, size_t count) {
244     HandleU8List(values, count);
245     length_ += count * sizeof(uint64_t);
246   }
247 
AddIdList(mirror::ObjectArray<mirror::Object> * values)248   void AddIdList(mirror::ObjectArray<mirror::Object>* values)
249       REQUIRES_SHARED(Locks::mutator_lock_) {
250     const int32_t length = values->GetLength();
251     for (int32_t i = 0; i < length; ++i) {
252       AddObjectId(values->GetWithoutChecks(i).Ptr());
253     }
254   }
255 
AddUtf8String(const char * str)256   void AddUtf8String(const char* str) {
257     // The terminating NUL character is NOT written.
258     AddU1List((const uint8_t*)str, strlen(str));
259   }
260 
Length() const261   size_t Length() const {
262     return length_;
263   }
264 
SumLength() const265   size_t SumLength() const {
266     return sum_length_;
267   }
268 
MaxLength() const269   size_t MaxLength() const {
270     return max_length_;
271   }
272 
273  protected:
HandleU1List(const uint8_t * values ATTRIBUTE_UNUSED,size_t count ATTRIBUTE_UNUSED)274   virtual void HandleU1List(const uint8_t* values ATTRIBUTE_UNUSED,
275                             size_t count ATTRIBUTE_UNUSED) {
276   }
HandleU1AsU2List(const uint8_t * values ATTRIBUTE_UNUSED,size_t count ATTRIBUTE_UNUSED)277   virtual void HandleU1AsU2List(const uint8_t* values ATTRIBUTE_UNUSED,
278                                 size_t count ATTRIBUTE_UNUSED) {
279   }
HandleU2List(const uint16_t * values ATTRIBUTE_UNUSED,size_t count ATTRIBUTE_UNUSED)280   virtual void HandleU2List(const uint16_t* values ATTRIBUTE_UNUSED,
281                             size_t count ATTRIBUTE_UNUSED) {
282   }
HandleU4List(const uint32_t * values ATTRIBUTE_UNUSED,size_t count ATTRIBUTE_UNUSED)283   virtual void HandleU4List(const uint32_t* values ATTRIBUTE_UNUSED,
284                             size_t count ATTRIBUTE_UNUSED) {
285   }
HandleU8List(const uint64_t * values ATTRIBUTE_UNUSED,size_t count ATTRIBUTE_UNUSED)286   virtual void HandleU8List(const uint64_t* values ATTRIBUTE_UNUSED,
287                             size_t count ATTRIBUTE_UNUSED) {
288   }
HandleEndRecord()289   virtual void HandleEndRecord() {
290   }
291 
292   size_t length_;      // Current record size.
293   size_t sum_length_;  // Size of all data.
294   size_t max_length_;  // Maximum seen length.
295   bool started_;       // Was StartRecord called?
296 };
297 
298 // This keeps things buffered until flushed.
299 class EndianOutputBuffered : public EndianOutput {
300  public:
EndianOutputBuffered(size_t reserve_size)301   explicit EndianOutputBuffered(size_t reserve_size) {
302     buffer_.reserve(reserve_size);
303   }
~EndianOutputBuffered()304   virtual ~EndianOutputBuffered() {}
305 
UpdateU4(size_t offset,uint32_t new_value)306   void UpdateU4(size_t offset, uint32_t new_value) override {
307     DCHECK_LE(offset, length_ - 4);
308     buffer_[offset + 0] = static_cast<uint8_t>((new_value >> 24) & 0xFF);
309     buffer_[offset + 1] = static_cast<uint8_t>((new_value >> 16) & 0xFF);
310     buffer_[offset + 2] = static_cast<uint8_t>((new_value >> 8)  & 0xFF);
311     buffer_[offset + 3] = static_cast<uint8_t>((new_value >> 0)  & 0xFF);
312   }
313 
314  protected:
HandleU1List(const uint8_t * values,size_t count)315   void HandleU1List(const uint8_t* values, size_t count) override {
316     DCHECK_EQ(length_, buffer_.size());
317     buffer_.insert(buffer_.end(), values, values + count);
318   }
319 
HandleU1AsU2List(const uint8_t * values,size_t count)320   void HandleU1AsU2List(const uint8_t* values, size_t count) override {
321     DCHECK_EQ(length_, buffer_.size());
322     // All 8-bits are grouped in 2 to make 16-bit block like Java Char
323     if (count & 1) {
324       buffer_.push_back(0);
325     }
326     for (size_t i = 0; i < count; ++i) {
327       uint8_t value = *values;
328       buffer_.push_back(value);
329       values++;
330     }
331   }
332 
HandleU2List(const uint16_t * values,size_t count)333   void HandleU2List(const uint16_t* values, size_t count) override {
334     DCHECK_EQ(length_, buffer_.size());
335     for (size_t i = 0; i < count; ++i) {
336       uint16_t value = *values;
337       buffer_.push_back(static_cast<uint8_t>((value >> 8) & 0xFF));
338       buffer_.push_back(static_cast<uint8_t>((value >> 0) & 0xFF));
339       values++;
340     }
341   }
342 
HandleU4List(const uint32_t * values,size_t count)343   void HandleU4List(const uint32_t* values, size_t count) override {
344     DCHECK_EQ(length_, buffer_.size());
345     for (size_t i = 0; i < count; ++i) {
346       uint32_t value = *values;
347       buffer_.push_back(static_cast<uint8_t>((value >> 24) & 0xFF));
348       buffer_.push_back(static_cast<uint8_t>((value >> 16) & 0xFF));
349       buffer_.push_back(static_cast<uint8_t>((value >> 8)  & 0xFF));
350       buffer_.push_back(static_cast<uint8_t>((value >> 0)  & 0xFF));
351       values++;
352     }
353   }
354 
HandleU8List(const uint64_t * values,size_t count)355   void HandleU8List(const uint64_t* values, size_t count) override {
356     DCHECK_EQ(length_, buffer_.size());
357     for (size_t i = 0; i < count; ++i) {
358       uint64_t value = *values;
359       buffer_.push_back(static_cast<uint8_t>((value >> 56) & 0xFF));
360       buffer_.push_back(static_cast<uint8_t>((value >> 48) & 0xFF));
361       buffer_.push_back(static_cast<uint8_t>((value >> 40) & 0xFF));
362       buffer_.push_back(static_cast<uint8_t>((value >> 32) & 0xFF));
363       buffer_.push_back(static_cast<uint8_t>((value >> 24) & 0xFF));
364       buffer_.push_back(static_cast<uint8_t>((value >> 16) & 0xFF));
365       buffer_.push_back(static_cast<uint8_t>((value >> 8)  & 0xFF));
366       buffer_.push_back(static_cast<uint8_t>((value >> 0)  & 0xFF));
367       values++;
368     }
369   }
370 
HandleEndRecord()371   void HandleEndRecord() override {
372     DCHECK_EQ(buffer_.size(), length_);
373     if (kIsDebugBuild && started_) {
374       uint32_t stored_length =
375           static_cast<uint32_t>(buffer_[5]) << 24 |
376           static_cast<uint32_t>(buffer_[6]) << 16 |
377           static_cast<uint32_t>(buffer_[7]) << 8 |
378           static_cast<uint32_t>(buffer_[8]);
379       DCHECK_EQ(stored_length, length_ - sizeof(uint8_t) - 2 * sizeof(uint32_t));
380     }
381     HandleFlush(buffer_.data(), length_);
382     buffer_.clear();
383   }
384 
HandleFlush(const uint8_t * buffer ATTRIBUTE_UNUSED,size_t length ATTRIBUTE_UNUSED)385   virtual void HandleFlush(const uint8_t* buffer ATTRIBUTE_UNUSED, size_t length ATTRIBUTE_UNUSED) {
386   }
387 
388   std::vector<uint8_t> buffer_;
389 };
390 
391 class FileEndianOutput final : public EndianOutputBuffered {
392  public:
FileEndianOutput(File * fp,size_t reserved_size)393   FileEndianOutput(File* fp, size_t reserved_size)
394       : EndianOutputBuffered(reserved_size), fp_(fp), errors_(false) {
395     DCHECK(fp != nullptr);
396   }
~FileEndianOutput()397   ~FileEndianOutput() {
398   }
399 
Errors()400   bool Errors() {
401     return errors_;
402   }
403 
404  protected:
HandleFlush(const uint8_t * buffer,size_t length)405   void HandleFlush(const uint8_t* buffer, size_t length) override {
406     if (!errors_) {
407       errors_ = !fp_->WriteFully(buffer, length);
408     }
409   }
410 
411  private:
412   File* fp_;
413   bool errors_;
414 };
415 
416 class VectorEndianOuputput final : public EndianOutputBuffered {
417  public:
VectorEndianOuputput(std::vector<uint8_t> & data,size_t reserved_size)418   VectorEndianOuputput(std::vector<uint8_t>& data, size_t reserved_size)
419       : EndianOutputBuffered(reserved_size), full_data_(data) {}
~VectorEndianOuputput()420   ~VectorEndianOuputput() {}
421 
422  protected:
HandleFlush(const uint8_t * buf,size_t length)423   void HandleFlush(const uint8_t* buf, size_t length) override {
424     size_t old_size = full_data_.size();
425     full_data_.resize(old_size + length);
426     memcpy(full_data_.data() + old_size, buf, length);
427   }
428 
429  private:
430   std::vector<uint8_t>& full_data_;
431 };
432 
433 #define __ output_->
434 
435 class Hprof : public SingleRootVisitor {
436  public:
Hprof(const char * output_filename,int fd,bool direct_to_ddms)437   Hprof(const char* output_filename, int fd, bool direct_to_ddms)
438       : filename_(output_filename),
439         fd_(fd),
440         direct_to_ddms_(direct_to_ddms) {
441     LOG(INFO) << "hprof: heap dump \"" << filename_ << "\" starting...";
442   }
443 
Dump()444   void Dump()
445     REQUIRES(Locks::mutator_lock_)
446     REQUIRES(!Locks::heap_bitmap_lock_, !Locks::alloc_tracker_lock_) {
447     {
448       MutexLock mu(Thread::Current(), *Locks::alloc_tracker_lock_);
449       if (Runtime::Current()->GetHeap()->IsAllocTrackingEnabled()) {
450         PopulateAllocationTrackingTraces();
451       }
452     }
453 
454     // First pass to measure the size of the dump.
455     size_t overall_size;
456     size_t max_length;
457     {
458       EndianOutput count_output;
459       output_ = &count_output;
460       ProcessHeap(false);
461       overall_size = count_output.SumLength();
462       max_length = count_output.MaxLength();
463       output_ = nullptr;
464     }
465 
466     bool okay;
467     visited_objects_.clear();
468     if (direct_to_ddms_) {
469       if (kDirectStream) {
470         okay = DumpToDdmsDirect(overall_size, max_length, CHUNK_TYPE("HPDS"));
471       } else {
472         okay = DumpToDdmsBuffered(overall_size, max_length);
473       }
474     } else {
475       okay = DumpToFile(overall_size, max_length);
476     }
477 
478     if (okay) {
479       const uint64_t duration = NanoTime() - start_ns_;
480       LOG(INFO) << "hprof: heap dump completed (" << PrettySize(RoundUp(overall_size, KB))
481                 << ") in " << PrettyDuration(duration)
482                 << " objects " << total_objects_
483                 << " objects with stack traces " << total_objects_with_stack_trace_;
484     }
485   }
486 
487  private:
488   void DumpHeapObject(mirror::Object* obj)
489       REQUIRES_SHARED(Locks::mutator_lock_);
490 
491   void DumpHeapClass(mirror::Class* klass)
492       REQUIRES_SHARED(Locks::mutator_lock_);
493 
494   void DumpHeapArray(mirror::Array* obj, mirror::Class* klass)
495       REQUIRES_SHARED(Locks::mutator_lock_);
496 
497   void DumpFakeObjectArray(mirror::Object* obj, const std::set<mirror::Object*>& elements)
498       REQUIRES_SHARED(Locks::mutator_lock_);
499 
500   void DumpHeapInstanceObject(mirror::Object* obj,
501                               mirror::Class* klass,
502                               const std::set<mirror::Object*>& fake_roots)
503       REQUIRES_SHARED(Locks::mutator_lock_);
504 
505   bool AddRuntimeInternalObjectsField(mirror::Class* klass) REQUIRES_SHARED(Locks::mutator_lock_);
506 
ProcessHeap(bool header_first)507   void ProcessHeap(bool header_first)
508       REQUIRES(Locks::mutator_lock_) {
509     // Reset current heap and object count.
510     current_heap_ = HPROF_HEAP_DEFAULT;
511     objects_in_segment_ = 0;
512 
513     if (header_first) {
514       ProcessHeader(true);
515       ProcessBody();
516     } else {
517       ProcessBody();
518       ProcessHeader(false);
519     }
520   }
521 
ProcessBody()522   void ProcessBody() REQUIRES(Locks::mutator_lock_) {
523     Runtime* const runtime = Runtime::Current();
524     // Walk the roots and the heap.
525     output_->StartNewRecord(HPROF_TAG_HEAP_DUMP_SEGMENT, kHprofTime);
526 
527     simple_roots_.clear();
528     runtime->VisitRoots(this);
529     runtime->VisitImageRoots(this);
530     auto dump_object = [this](mirror::Object* obj) REQUIRES_SHARED(Locks::mutator_lock_) {
531       DCHECK(obj != nullptr);
532       DumpHeapObject(obj);
533     };
534     runtime->GetHeap()->VisitObjectsPaused(dump_object);
535     output_->StartNewRecord(HPROF_TAG_HEAP_DUMP_END, kHprofTime);
536     output_->EndRecord();
537   }
538 
ProcessHeader(bool string_first)539   void ProcessHeader(bool string_first) REQUIRES(Locks::mutator_lock_) {
540     // Write the header.
541     WriteFixedHeader();
542     // Write the string and class tables, and any stack traces, to the header.
543     // (jhat requires that these appear before any of the data in the body that refers to them.)
544     // jhat also requires the string table appear before class table and stack traces.
545     // However, WriteStackTraces() can modify the string table, so it's necessary to call
546     // WriteStringTable() last in the first pass, to compute the correct length of the output.
547     if (string_first) {
548       WriteStringTable();
549     }
550     WriteClassTable();
551     WriteStackTraces();
552     if (!string_first) {
553       WriteStringTable();
554     }
555     output_->EndRecord();
556   }
557 
WriteClassTable()558   void WriteClassTable() REQUIRES_SHARED(Locks::mutator_lock_) {
559     for (const auto& p : classes_) {
560       mirror::Class* c = p.first;
561       HprofClassSerialNumber sn = p.second;
562       CHECK(c != nullptr);
563       output_->StartNewRecord(HPROF_TAG_LOAD_CLASS, kHprofTime);
564       // LOAD CLASS format:
565       // U4: class serial number (always > 0)
566       // ID: class object ID. We use the address of the class object structure as its ID.
567       // U4: stack trace serial number
568       // ID: class name string ID
569       __ AddU4(sn);
570       __ AddObjectId(c);
571       __ AddStackTraceSerialNumber(LookupStackTraceSerialNumber(c));
572       __ AddStringId(LookupClassNameId(c));
573     }
574   }
575 
WriteStringTable()576   void WriteStringTable() {
577     for (const auto& p : strings_) {
578       const std::string& string = p.first;
579       const HprofStringId id = p.second;
580 
581       output_->StartNewRecord(HPROF_TAG_STRING, kHprofTime);
582 
583       // STRING format:
584       // ID:  ID for this string
585       // U1*: UTF8 characters for string (NOT null terminated)
586       //      (the record format encodes the length)
587       __ AddU4(id);
588       __ AddUtf8String(string.c_str());
589     }
590   }
591 
StartNewHeapDumpSegment()592   void StartNewHeapDumpSegment() {
593     // This flushes the old segment and starts a new one.
594     output_->StartNewRecord(HPROF_TAG_HEAP_DUMP_SEGMENT, kHprofTime);
595     objects_in_segment_ = 0;
596     // Starting a new HEAP_DUMP resets the heap to default.
597     current_heap_ = HPROF_HEAP_DEFAULT;
598   }
599 
CheckHeapSegmentConstraints()600   void CheckHeapSegmentConstraints() {
601     if (objects_in_segment_ >= kMaxObjectsPerSegment || output_->Length() >= kMaxBytesPerSegment) {
602       StartNewHeapDumpSegment();
603     }
604   }
605 
606   void VisitRoot(mirror::Object* obj, const RootInfo& root_info)
607       override REQUIRES_SHARED(Locks::mutator_lock_);
608   void MarkRootObject(const mirror::Object* obj, jobject jni_obj, HprofHeapTag heap_tag,
609                       uint32_t thread_serial);
610 
LookupClassId(mirror::Class * c)611   HprofClassObjectId LookupClassId(mirror::Class* c) REQUIRES_SHARED(Locks::mutator_lock_) {
612     if (c != nullptr) {
613       auto it = classes_.find(c);
614       if (it == classes_.end()) {
615         // first time to see this class
616         HprofClassSerialNumber sn = next_class_serial_number_++;
617         classes_.Put(c, sn);
618         // Make sure that we've assigned a string ID for this class' name
619         LookupClassNameId(c);
620       }
621     }
622     return PointerToLowMemUInt32(c);
623   }
624 
LookupStackTraceSerialNumber(const mirror::Object * obj)625   HprofStackTraceSerialNumber LookupStackTraceSerialNumber(const mirror::Object* obj)
626       REQUIRES_SHARED(Locks::mutator_lock_) {
627     auto r = allocation_records_.find(obj);
628     if (r == allocation_records_.end()) {
629       return kHprofNullStackTrace;
630     } else {
631       const gc::AllocRecordStackTrace* trace = r->second;
632       auto result = traces_.find(trace);
633       CHECK(result != traces_.end());
634       return result->second;
635     }
636   }
637 
LookupStringId(mirror::String * string)638   HprofStringId LookupStringId(mirror::String* string) REQUIRES_SHARED(Locks::mutator_lock_) {
639     return LookupStringId(string->ToModifiedUtf8());
640   }
641 
LookupStringId(const char * string)642   HprofStringId LookupStringId(const char* string) {
643     return LookupStringId(std::string(string));
644   }
645 
LookupStringId(const std::string & string)646   HprofStringId LookupStringId(const std::string& string) {
647     auto it = strings_.find(string);
648     if (it != strings_.end()) {
649       return it->second;
650     }
651     HprofStringId id = next_string_id_++;
652     strings_.Put(string, id);
653     return id;
654   }
655 
LookupClassNameId(mirror::Class * c)656   HprofStringId LookupClassNameId(mirror::Class* c) REQUIRES_SHARED(Locks::mutator_lock_) {
657     return LookupStringId(c->PrettyDescriptor());
658   }
659 
WriteFixedHeader()660   void WriteFixedHeader() {
661     // Write the file header.
662     // U1: NUL-terminated magic string.
663     const char magic[] = "JAVA PROFILE 1.0.3";
664     __ AddU1List(reinterpret_cast<const uint8_t*>(magic), sizeof(magic));
665 
666     // U4: size of identifiers.  We're using addresses as IDs and our heap references are stored
667     // as uint32_t.
668     // Note of warning: hprof-conv hard-codes the size of identifiers to 4.
669     static_assert(sizeof(mirror::HeapReference<mirror::Object>) == sizeof(uint32_t),
670                   "Unexpected HeapReference size");
671     __ AddU4(sizeof(uint32_t));
672 
673     // The current time, in milliseconds since 0:00 GMT, 1/1/70.
674     timeval now;
675     const uint64_t nowMs = (gettimeofday(&now, nullptr) < 0) ? 0 :
676         (uint64_t)now.tv_sec * 1000 + now.tv_usec / 1000;
677     // TODO: It seems it would be correct to use U8.
678     // U4: high word of the 64-bit time.
679     __ AddU4(static_cast<uint32_t>(nowMs >> 32));
680     // U4: low word of the 64-bit time.
681     __ AddU4(static_cast<uint32_t>(nowMs & 0xFFFFFFFF));
682   }
683 
WriteStackTraces()684   void WriteStackTraces() REQUIRES_SHARED(Locks::mutator_lock_) {
685     // Write a dummy stack trace record so the analysis tools don't freak out.
686     output_->StartNewRecord(HPROF_TAG_STACK_TRACE, kHprofTime);
687     __ AddStackTraceSerialNumber(kHprofNullStackTrace);
688     __ AddU4(kHprofNullThread);
689     __ AddU4(0);    // no frames
690 
691     // TODO: jhat complains "WARNING: Stack trace not found for serial # -1", but no trace should
692     // have -1 as its serial number (as long as HprofStackTraceSerialNumber doesn't overflow).
693     for (const auto& it : traces_) {
694       const gc::AllocRecordStackTrace* trace = it.first;
695       HprofStackTraceSerialNumber trace_sn = it.second;
696       size_t depth = trace->GetDepth();
697 
698       // First write stack frames of the trace
699       for (size_t i = 0; i < depth; ++i) {
700         const gc::AllocRecordStackTraceElement* frame = &trace->GetStackElement(i);
701         ArtMethod* method = frame->GetMethod();
702         CHECK(method != nullptr);
703         output_->StartNewRecord(HPROF_TAG_STACK_FRAME, kHprofTime);
704         // STACK FRAME format:
705         // ID: stack frame ID. We use the address of the AllocRecordStackTraceElement object as its ID.
706         // ID: method name string ID
707         // ID: method signature string ID
708         // ID: source file name string ID
709         // U4: class serial number
710         // U4: >0, line number; 0, no line information available; -1, unknown location
711         auto frame_result = frames_.find(frame);
712         CHECK(frame_result != frames_.end());
713         __ AddU4(frame_result->second);
714         __ AddStringId(LookupStringId(method->GetName()));
715         __ AddStringId(LookupStringId(method->GetSignature().ToString()));
716         const char* source_file = method->GetDeclaringClassSourceFile();
717         if (source_file == nullptr) {
718           source_file = "";
719         }
720         __ AddStringId(LookupStringId(source_file));
721         auto class_result = classes_.find(method->GetDeclaringClass().Ptr());
722         CHECK(class_result != classes_.end());
723         __ AddU4(class_result->second);
724         __ AddU4(frame->ComputeLineNumber());
725       }
726 
727       // Then write the trace itself
728       output_->StartNewRecord(HPROF_TAG_STACK_TRACE, kHprofTime);
729       // STACK TRACE format:
730       // U4: stack trace serial number. We use the address of the AllocRecordStackTrace object as its serial number.
731       // U4: thread serial number. We use Thread::GetTid().
732       // U4: number of frames
733       // [ID]*: series of stack frame ID's
734       __ AddStackTraceSerialNumber(trace_sn);
735       __ AddU4(trace->GetTid());
736       __ AddU4(depth);
737       for (size_t i = 0; i < depth; ++i) {
738         const gc::AllocRecordStackTraceElement* frame = &trace->GetStackElement(i);
739         auto frame_result = frames_.find(frame);
740         CHECK(frame_result != frames_.end());
741         __ AddU4(frame_result->second);
742       }
743     }
744   }
745 
DumpToDdmsBuffered(size_t overall_size ATTRIBUTE_UNUSED,size_t max_length ATTRIBUTE_UNUSED)746   bool DumpToDdmsBuffered(size_t overall_size ATTRIBUTE_UNUSED, size_t max_length ATTRIBUTE_UNUSED)
747       REQUIRES(Locks::mutator_lock_) {
748     LOG(FATAL) << "Unimplemented";
749     UNREACHABLE();
750     //        // Send the data off to DDMS.
751     //        iovec iov[2];
752     //        iov[0].iov_base = header_data_ptr_;
753     //        iov[0].iov_len = header_data_size_;
754     //        iov[1].iov_base = body_data_ptr_;
755     //        iov[1].iov_len = body_data_size_;
756     //        Dbg::DdmSendChunkV(CHUNK_TYPE("HPDS"), iov, 2);
757   }
758 
DumpToFile(size_t overall_size,size_t max_length)759   bool DumpToFile(size_t overall_size, size_t max_length)
760       REQUIRES(Locks::mutator_lock_) {
761     // Where exactly are we writing to?
762     int out_fd;
763     if (fd_ >= 0) {
764       out_fd = DupCloexec(fd_);
765       if (out_fd < 0) {
766         ThrowRuntimeException("Couldn't dump heap; dup(%d) failed: %s", fd_, strerror(errno));
767         return false;
768       }
769     } else {
770       out_fd = open(filename_.c_str(), O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, 0644);
771       if (out_fd < 0) {
772         ThrowRuntimeException("Couldn't dump heap; open(\"%s\") failed: %s", filename_.c_str(),
773                               strerror(errno));
774         return false;
775       }
776     }
777 
778     std::unique_ptr<File> file(new File(out_fd, filename_, true));
779     bool okay;
780     {
781       FileEndianOutput file_output(file.get(), max_length);
782       output_ = &file_output;
783       ProcessHeap(true);
784       okay = !file_output.Errors();
785 
786       if (okay) {
787         // Check for expected size. Output is expected to be less-or-equal than first phase, see
788         // b/23521263.
789         DCHECK_LE(file_output.SumLength(), overall_size);
790       }
791       output_ = nullptr;
792     }
793 
794     if (okay) {
795       okay = file->FlushCloseOrErase() == 0;
796     } else {
797       file->Erase();
798     }
799     if (!okay) {
800       std::string msg(android::base::StringPrintf("Couldn't dump heap; writing \"%s\" failed: %s",
801                                                   filename_.c_str(),
802                                                   strerror(errno)));
803       ThrowRuntimeException("%s", msg.c_str());
804       LOG(ERROR) << msg;
805     }
806 
807     return okay;
808   }
809 
DumpToDdmsDirect(size_t overall_size,size_t max_length,uint32_t chunk_type)810   bool DumpToDdmsDirect(size_t overall_size, size_t max_length, uint32_t chunk_type)
811       REQUIRES(Locks::mutator_lock_) {
812     CHECK(direct_to_ddms_);
813 
814     std::vector<uint8_t> out_data;
815 
816     // TODO It would be really good to have some streaming thing again. b/73084059
817     VectorEndianOuputput output(out_data, max_length);
818     output_ = &output;
819 
820     // Write the dump.
821     ProcessHeap(true);
822 
823     Runtime::Current()->GetRuntimeCallbacks()->DdmPublishChunk(
824         chunk_type, ArrayRef<const uint8_t>(out_data.data(), out_data.size()));
825 
826     // Check for expected size. See DumpToFile for comment.
827     DCHECK_LE(output.SumLength(), overall_size);
828     output_ = nullptr;
829 
830     return true;
831   }
832 
PopulateAllocationTrackingTraces()833   void PopulateAllocationTrackingTraces()
834       REQUIRES(Locks::mutator_lock_, Locks::alloc_tracker_lock_) {
835     gc::AllocRecordObjectMap* records = Runtime::Current()->GetHeap()->GetAllocationRecords();
836     CHECK(records != nullptr);
837     HprofStackTraceSerialNumber next_trace_sn = kHprofNullStackTrace + 1;
838     HprofStackFrameId next_frame_id = 0;
839     size_t count = 0;
840 
841     for (auto it = records->Begin(), end = records->End(); it != end; ++it) {
842       const mirror::Object* obj = it->first.Read();
843       if (obj == nullptr) {
844         continue;
845       }
846       ++count;
847       const gc::AllocRecordStackTrace* trace = it->second.GetStackTrace();
848 
849       // Copy the pair into a real hash map to speed up look up.
850       auto records_result = allocation_records_.emplace(obj, trace);
851       // The insertion should always succeed, i.e. no duplicate object pointers in "records"
852       CHECK(records_result.second);
853 
854       // Generate serial numbers for traces, and IDs for frames.
855       auto traces_result = traces_.find(trace);
856       if (traces_result == traces_.end()) {
857         traces_.emplace(trace, next_trace_sn++);
858         // only check frames if the trace is newly discovered
859         for (size_t i = 0, depth = trace->GetDepth(); i < depth; ++i) {
860           const gc::AllocRecordStackTraceElement* frame = &trace->GetStackElement(i);
861           auto frames_result = frames_.find(frame);
862           if (frames_result == frames_.end()) {
863             frames_.emplace(frame, next_frame_id++);
864           }
865         }
866       }
867     }
868     CHECK_EQ(traces_.size(), next_trace_sn - kHprofNullStackTrace - 1);
869     CHECK_EQ(frames_.size(), next_frame_id);
870     total_objects_with_stack_trace_ = count;
871   }
872 
873   // If direct_to_ddms_ is set, "filename_" and "fd" will be ignored.
874   // Otherwise, "filename_" must be valid, though if "fd" >= 0 it will
875   // only be used for debug messages.
876   std::string filename_;
877   int fd_;
878   bool direct_to_ddms_;
879 
880   uint64_t start_ns_ = NanoTime();
881 
882   EndianOutput* output_ = nullptr;
883 
884   HprofHeapId current_heap_ = HPROF_HEAP_DEFAULT;  // Which heap we're currently dumping.
885   size_t objects_in_segment_ = 0;
886 
887   size_t total_objects_ = 0u;
888   size_t total_objects_with_stack_trace_ = 0u;
889 
890   HprofStringId next_string_id_ = 0x400000;
891   SafeMap<std::string, HprofStringId> strings_;
892   HprofClassSerialNumber next_class_serial_number_ = 1;
893   SafeMap<mirror::Class*, HprofClassSerialNumber> classes_;
894 
895   std::unordered_map<const gc::AllocRecordStackTrace*, HprofStackTraceSerialNumber,
896                      gc::HashAllocRecordTypesPtr<gc::AllocRecordStackTrace>,
897                      gc::EqAllocRecordTypesPtr<gc::AllocRecordStackTrace>> traces_;
898   std::unordered_map<const gc::AllocRecordStackTraceElement*, HprofStackFrameId,
899                      gc::HashAllocRecordTypesPtr<gc::AllocRecordStackTraceElement>,
900                      gc::EqAllocRecordTypesPtr<gc::AllocRecordStackTraceElement>> frames_;
901   std::unordered_map<const mirror::Object*, const gc::AllocRecordStackTrace*> allocation_records_;
902 
903   // Set used to keep track of what simple root records we have already
904   // emitted, to avoid emitting duplicate entries. The simple root records are
905   // those that contain no other information than the root type and the object
906   // id. A pair of root type and object id is packed into a uint64_t, with
907   // the root type in the upper 32 bits and the object id in the lower 32
908   // bits.
909   std::unordered_set<uint64_t> simple_roots_;
910 
911   // To make sure we don't dump the same object multiple times. b/34967844
912   std::unordered_set<mirror::Object*> visited_objects_;
913 
914   friend class GcRootVisitor;
915   DISALLOW_COPY_AND_ASSIGN(Hprof);
916 };
917 
SignatureToBasicTypeAndSize(const char * sig,size_t * size_out)918 static HprofBasicType SignatureToBasicTypeAndSize(const char* sig, size_t* size_out) {
919   char c = sig[0];
920   HprofBasicType ret;
921   size_t size;
922 
923   switch (c) {
924     case '[':
925     case 'L':
926       ret = hprof_basic_object;
927       size = 4;
928       break;
929     case 'Z':
930       ret = hprof_basic_boolean;
931       size = 1;
932       break;
933     case 'C':
934       ret = hprof_basic_char;
935       size = 2;
936       break;
937     case 'F':
938       ret = hprof_basic_float;
939       size = 4;
940       break;
941     case 'D':
942       ret = hprof_basic_double;
943       size = 8;
944       break;
945     case 'B':
946       ret = hprof_basic_byte;
947       size = 1;
948       break;
949     case 'S':
950       ret = hprof_basic_short;
951       size = 2;
952       break;
953     case 'I':
954       ret = hprof_basic_int;
955       size = 4;
956       break;
957     case 'J':
958       ret = hprof_basic_long;
959       size = 8;
960       break;
961     default:
962       LOG(FATAL) << "UNREACHABLE";
963       UNREACHABLE();
964   }
965 
966   if (size_out != nullptr) {
967     *size_out = size;
968   }
969 
970   return ret;
971 }
972 
973 // Always called when marking objects, but only does
974 // something when ctx->gc_scan_state_ is non-zero, which is usually
975 // only true when marking the root set or unreachable
976 // objects.  Used to add rootset references to obj.
MarkRootObject(const mirror::Object * obj,jobject jni_obj,HprofHeapTag heap_tag,uint32_t thread_serial)977 void Hprof::MarkRootObject(const mirror::Object* obj, jobject jni_obj, HprofHeapTag heap_tag,
978                            uint32_t thread_serial) {
979   if (heap_tag == 0) {
980     return;
981   }
982 
983   CheckHeapSegmentConstraints();
984 
985   switch (heap_tag) {
986     // ID: object ID
987     case HPROF_ROOT_UNKNOWN:
988     case HPROF_ROOT_STICKY_CLASS:
989     case HPROF_ROOT_MONITOR_USED:
990     case HPROF_ROOT_INTERNED_STRING:
991     case HPROF_ROOT_DEBUGGER:
992     case HPROF_ROOT_VM_INTERNAL: {
993       uint64_t key = (static_cast<uint64_t>(heap_tag) << 32) | PointerToLowMemUInt32(obj);
994       if (simple_roots_.insert(key).second) {
995         __ AddU1(heap_tag);
996         __ AddObjectId(obj);
997       }
998       break;
999     }
1000 
1001       // ID: object ID
1002       // ID: JNI global ref ID
1003     case HPROF_ROOT_JNI_GLOBAL:
1004       __ AddU1(heap_tag);
1005       __ AddObjectId(obj);
1006       __ AddJniGlobalRefId(jni_obj);
1007       break;
1008 
1009       // ID: object ID
1010       // U4: thread serial number
1011       // U4: frame number in stack trace (-1 for empty)
1012     case HPROF_ROOT_JNI_LOCAL:
1013     case HPROF_ROOT_JNI_MONITOR:
1014     case HPROF_ROOT_JAVA_FRAME:
1015       __ AddU1(heap_tag);
1016       __ AddObjectId(obj);
1017       __ AddU4(thread_serial);
1018       __ AddU4((uint32_t)-1);
1019       break;
1020 
1021       // ID: object ID
1022       // U4: thread serial number
1023     case HPROF_ROOT_NATIVE_STACK:
1024     case HPROF_ROOT_THREAD_BLOCK:
1025       __ AddU1(heap_tag);
1026       __ AddObjectId(obj);
1027       __ AddU4(thread_serial);
1028       break;
1029 
1030       // ID: thread object ID
1031       // U4: thread serial number
1032       // U4: stack trace serial number
1033     case HPROF_ROOT_THREAD_OBJECT:
1034       __ AddU1(heap_tag);
1035       __ AddObjectId(obj);
1036       __ AddU4(thread_serial);
1037       __ AddU4((uint32_t)-1);    // xxx
1038       break;
1039 
1040     case HPROF_CLASS_DUMP:
1041     case HPROF_INSTANCE_DUMP:
1042     case HPROF_OBJECT_ARRAY_DUMP:
1043     case HPROF_PRIMITIVE_ARRAY_DUMP:
1044     case HPROF_HEAP_DUMP_INFO:
1045     case HPROF_PRIMITIVE_ARRAY_NODATA_DUMP:
1046       // Ignored.
1047       break;
1048 
1049     case HPROF_ROOT_FINALIZING:
1050     case HPROF_ROOT_REFERENCE_CLEANUP:
1051     case HPROF_UNREACHABLE:
1052       LOG(FATAL) << "obsolete tag " << static_cast<int>(heap_tag);
1053       UNREACHABLE();
1054   }
1055 
1056   ++objects_in_segment_;
1057 }
1058 
AddRuntimeInternalObjectsField(mirror::Class * klass)1059 bool Hprof::AddRuntimeInternalObjectsField(mirror::Class* klass) {
1060   if (klass->IsDexCacheClass()) {
1061     return true;
1062   }
1063   // IsClassLoaderClass is true for subclasses of classloader but we only want to add the fake
1064   // field to the java.lang.ClassLoader class.
1065   if (klass->IsClassLoaderClass() && klass->GetSuperClass()->IsObjectClass()) {
1066     return true;
1067   }
1068   return false;
1069 }
1070 
DumpHeapObject(mirror::Object * obj)1071 void Hprof::DumpHeapObject(mirror::Object* obj) {
1072   // Ignore classes that are retired.
1073   if (obj->IsClass() && obj->AsClass()->IsRetired()) {
1074     return;
1075   }
1076   DCHECK(visited_objects_.insert(obj).second)
1077       << "Already visited " << obj << "(" << obj->PrettyTypeOf() << ")";
1078 
1079   ++total_objects_;
1080 
1081   class RootCollector {
1082    public:
1083     RootCollector() {}
1084 
1085     void operator()(mirror::Object*, MemberOffset, bool) const {}
1086 
1087     // Note that these don't have read barriers. Its OK however since the GC is guaranteed to not be
1088     // running during the hprof dumping process.
1089     void VisitRootIfNonNull(mirror::CompressedReference<mirror::Object>* root) const
1090         REQUIRES_SHARED(Locks::mutator_lock_) {
1091       if (!root->IsNull()) {
1092         VisitRoot(root);
1093       }
1094     }
1095 
1096     void VisitRoot(mirror::CompressedReference<mirror::Object>* root) const
1097         REQUIRES_SHARED(Locks::mutator_lock_) {
1098       roots_.insert(root->AsMirrorPtr());
1099     }
1100 
1101     const std::set<mirror::Object*>& GetRoots() const {
1102       return roots_;
1103     }
1104 
1105    private:
1106     // These roots are actually live from the object. Avoid marking them as roots in hprof to make
1107     // it easier to debug class unloading.
1108     mutable std::set<mirror::Object*> roots_;
1109   };
1110 
1111   RootCollector visitor;
1112   // Collect all native roots.
1113   if (!obj->IsClass()) {
1114     obj->VisitReferences(visitor, VoidFunctor());
1115   }
1116 
1117   gc::Heap* const heap = Runtime::Current()->GetHeap();
1118   const gc::space::ContinuousSpace* const space = heap->FindContinuousSpaceFromObject(obj, true);
1119   HprofHeapId heap_type = HPROF_HEAP_APP;
1120   if (space != nullptr) {
1121     if (space->IsZygoteSpace()) {
1122       heap_type = HPROF_HEAP_ZYGOTE;
1123       VisitRoot(obj, RootInfo(kRootVMInternal));
1124     } else if (space->IsImageSpace() && heap->ObjectIsInBootImageSpace(obj)) {
1125       // Only count objects in the boot image as HPROF_HEAP_IMAGE, this leaves app image objects as
1126       // HPROF_HEAP_APP. b/35762934
1127       heap_type = HPROF_HEAP_IMAGE;
1128       VisitRoot(obj, RootInfo(kRootVMInternal));
1129     }
1130   } else {
1131     const auto* los = heap->GetLargeObjectsSpace();
1132     if (los->Contains(obj) && los->IsZygoteLargeObject(Thread::Current(), obj)) {
1133       heap_type = HPROF_HEAP_ZYGOTE;
1134       VisitRoot(obj, RootInfo(kRootVMInternal));
1135     }
1136   }
1137   CheckHeapSegmentConstraints();
1138 
1139   if (heap_type != current_heap_) {
1140     HprofStringId nameId;
1141 
1142     // This object is in a different heap than the current one.
1143     // Emit a HEAP_DUMP_INFO tag to change heaps.
1144     __ AddU1(HPROF_HEAP_DUMP_INFO);
1145     __ AddU4(static_cast<uint32_t>(heap_type));   // uint32_t: heap type
1146     switch (heap_type) {
1147     case HPROF_HEAP_APP:
1148       nameId = LookupStringId("app");
1149       break;
1150     case HPROF_HEAP_ZYGOTE:
1151       nameId = LookupStringId("zygote");
1152       break;
1153     case HPROF_HEAP_IMAGE:
1154       nameId = LookupStringId("image");
1155       break;
1156     default:
1157       // Internal error
1158       LOG(ERROR) << "Unexpected desiredHeap";
1159       nameId = LookupStringId("<ILLEGAL>");
1160       break;
1161     }
1162     __ AddStringId(nameId);
1163     current_heap_ = heap_type;
1164   }
1165 
1166   mirror::Class* c = obj->GetClass();
1167   if (c == nullptr) {
1168     // This object will bother HprofReader, because it has a null
1169     // class, so just don't dump it. It could be
1170     // gDvm.unlinkedJavaLangClass or it could be an object just
1171     // allocated which hasn't been initialized yet.
1172   } else {
1173     if (obj->IsClass()) {
1174       DumpHeapClass(obj->AsClass().Ptr());
1175     } else if (c->IsArrayClass()) {
1176       DumpHeapArray(obj->AsArray().Ptr(), c);
1177     } else {
1178       DumpHeapInstanceObject(obj, c, visitor.GetRoots());
1179     }
1180   }
1181 
1182   ++objects_in_segment_;
1183 }
1184 
DumpHeapClass(mirror::Class * klass)1185 void Hprof::DumpHeapClass(mirror::Class* klass) {
1186   if (!klass->IsResolved()) {
1187     // Class is allocated but not yet resolved: we cannot access its fields or super class.
1188     return;
1189   }
1190 
1191   // Note: We will emit instance fields of Class as synthetic static fields with a prefix of
1192   //       "$class$" so the class fields are visible in hprof dumps. For tools to account for that
1193   //       correctly, we'll emit an instance size of zero for java.lang.Class, and also emit the
1194   //       instance fields of java.lang.Object.
1195   //
1196   //       For other overhead (currently only the embedded vtable), we will generate a synthetic
1197   //       byte array (or field[s] in case the overhead size is of reference size or less).
1198 
1199   const size_t num_static_fields = klass->NumStaticFields();
1200 
1201   // Total class size:
1202   //   * class instance fields (including Object instance fields)
1203   //   * vtable
1204   //   * class static fields
1205   const size_t total_class_size = klass->GetClassSize();
1206 
1207   // Base class size (common parts of all Class instances):
1208   //   * class instance fields (including Object instance fields)
1209   constexpr size_t base_class_size = sizeof(mirror::Class);
1210   CHECK_LE(base_class_size, total_class_size);
1211 
1212   // Difference of Total and Base:
1213   //   * vtable
1214   //   * class static fields
1215   const size_t base_overhead_size = total_class_size - base_class_size;
1216 
1217   // Tools (ahat/Studio) will count the static fields and account for them in the class size. We
1218   // must thus subtract them from base_overhead_size or they will be double-counted.
1219   size_t class_static_fields_size = 0;
1220   for (ArtField& class_static_field : klass->GetSFields()) {
1221     size_t size = 0;
1222     SignatureToBasicTypeAndSize(class_static_field.GetTypeDescriptor(), &size);
1223     class_static_fields_size += size;
1224   }
1225 
1226   CHECK_GE(base_overhead_size, class_static_fields_size);
1227   // Now we have:
1228   //   * vtable
1229   const size_t base_no_statics_overhead_size = base_overhead_size - class_static_fields_size;
1230 
1231   // We may decide to display native overhead (the actual IMT, ArtFields and ArtMethods) in the
1232   // future.
1233   const size_t java_heap_overhead_size = base_no_statics_overhead_size;
1234 
1235   // For overhead greater 4, we'll allocate a synthetic array.
1236   if (java_heap_overhead_size > 4) {
1237     // Create a byte array to reflect the allocation of the
1238     // StaticField array at the end of this class.
1239     __ AddU1(HPROF_PRIMITIVE_ARRAY_DUMP);
1240     __ AddClassStaticsId(klass);
1241     __ AddStackTraceSerialNumber(LookupStackTraceSerialNumber(klass));
1242     __ AddU4(java_heap_overhead_size - 4);
1243     __ AddU1(hprof_basic_byte);
1244     for (size_t i = 0; i < java_heap_overhead_size - 4; ++i) {
1245       __ AddU1(0);
1246     }
1247   }
1248   const size_t java_heap_overhead_field_count = java_heap_overhead_size > 0
1249                                                     ? (java_heap_overhead_size == 3 ? 2u : 1u)
1250                                                     : 0;
1251 
1252   __ AddU1(HPROF_CLASS_DUMP);
1253   __ AddClassId(LookupClassId(klass));
1254   __ AddStackTraceSerialNumber(LookupStackTraceSerialNumber(klass));
1255   __ AddClassId(LookupClassId(klass->GetSuperClass().Ptr()));
1256   __ AddObjectId(klass->GetClassLoader().Ptr());
1257   __ AddObjectId(nullptr);    // no signer
1258   __ AddObjectId(nullptr);    // no prot domain
1259   __ AddObjectId(nullptr);    // reserved
1260   __ AddObjectId(nullptr);    // reserved
1261   // Instance size.
1262   if (klass->IsClassClass()) {
1263     // As mentioned above, we will emit instance fields as synthetic static fields. So the
1264     // base object is "empty."
1265     __ AddU4(0);
1266   } else if (klass->IsStringClass()) {
1267     // Strings are variable length with character data at the end like arrays.
1268     // This outputs the size of an empty string.
1269     __ AddU4(sizeof(mirror::String));
1270   } else if (klass->IsArrayClass() || klass->IsPrimitive()) {
1271     __ AddU4(0);
1272   } else {
1273     __ AddU4(klass->GetObjectSize());  // instance size
1274   }
1275 
1276   __ AddU2(0);  // empty const pool
1277 
1278   // Static fields
1279   //
1280   // Note: we report Class' and Object's instance fields here, too. This is for visibility reasons.
1281   //       (b/38167721)
1282   mirror::Class* class_class = klass->GetClass();
1283 
1284   DCHECK(class_class->GetSuperClass()->IsObjectClass());
1285   const size_t static_fields_reported = class_class->NumInstanceFields()
1286                                         + class_class->GetSuperClass()->NumInstanceFields()
1287                                         + java_heap_overhead_field_count
1288                                         + num_static_fields;
1289   __ AddU2(dchecked_integral_cast<uint16_t>(static_fields_reported));
1290 
1291   if (java_heap_overhead_size != 0) {
1292     __ AddStringId(LookupStringId(kClassOverheadName));
1293     size_t overhead_fields = 0;
1294     if (java_heap_overhead_size > 4) {
1295       __ AddU1(hprof_basic_object);
1296       __ AddClassStaticsId(klass);
1297       ++overhead_fields;
1298     } else {
1299       switch (java_heap_overhead_size) {
1300         case 4: {
1301           __ AddU1(hprof_basic_int);
1302           __ AddU4(0);
1303           ++overhead_fields;
1304           break;
1305         }
1306 
1307         case 2: {
1308           __ AddU1(hprof_basic_short);
1309           __ AddU2(0);
1310           ++overhead_fields;
1311           break;
1312         }
1313 
1314         case 3: {
1315           __ AddU1(hprof_basic_short);
1316           __ AddU2(0);
1317           __ AddStringId(LookupStringId(std::string(kClassOverheadName) + "2"));
1318           ++overhead_fields;
1319         }
1320         FALLTHROUGH_INTENDED;
1321 
1322         case 1: {
1323           __ AddU1(hprof_basic_byte);
1324           __ AddU1(0);
1325           ++overhead_fields;
1326           break;
1327         }
1328       }
1329     }
1330     DCHECK_EQ(java_heap_overhead_field_count, overhead_fields);
1331   }
1332 
1333   // Helper lambda to emit the given static field. The second argument name_fn will be called to
1334   // generate the name to emit. This can be used to emit something else than the field's actual
1335   // name.
1336   auto static_field_writer = [&](ArtField& field, auto name_fn)
1337       REQUIRES_SHARED(Locks::mutator_lock_) {
1338     __ AddStringId(LookupStringId(name_fn(field)));
1339 
1340     size_t size;
1341     HprofBasicType t = SignatureToBasicTypeAndSize(field.GetTypeDescriptor(), &size);
1342     __ AddU1(t);
1343     switch (t) {
1344       case hprof_basic_byte:
1345         __ AddU1(field.GetByte(klass));
1346         return;
1347       case hprof_basic_boolean:
1348         __ AddU1(field.GetBoolean(klass));
1349         return;
1350       case hprof_basic_char:
1351         __ AddU2(field.GetChar(klass));
1352         return;
1353       case hprof_basic_short:
1354         __ AddU2(field.GetShort(klass));
1355         return;
1356       case hprof_basic_float:
1357       case hprof_basic_int:
1358       case hprof_basic_object:
1359         __ AddU4(field.Get32(klass));
1360         return;
1361       case hprof_basic_double:
1362       case hprof_basic_long:
1363         __ AddU8(field.Get64(klass));
1364         return;
1365     }
1366     LOG(FATAL) << "Unexpected size " << size;
1367     UNREACHABLE();
1368   };
1369 
1370   {
1371     auto class_instance_field_name_fn = [](ArtField& field) REQUIRES_SHARED(Locks::mutator_lock_) {
1372       return std::string("$class$") + field.GetName();
1373     };
1374     for (ArtField& class_instance_field : class_class->GetIFields()) {
1375       static_field_writer(class_instance_field, class_instance_field_name_fn);
1376     }
1377     for (ArtField& object_instance_field : class_class->GetSuperClass()->GetIFields()) {
1378       static_field_writer(object_instance_field, class_instance_field_name_fn);
1379     }
1380   }
1381 
1382   {
1383     auto class_static_field_name_fn = [](ArtField& field) REQUIRES_SHARED(Locks::mutator_lock_) {
1384       return field.GetName();
1385     };
1386     for (ArtField& class_static_field : klass->GetSFields()) {
1387       static_field_writer(class_static_field, class_static_field_name_fn);
1388     }
1389   }
1390 
1391   // Instance fields for this class (no superclass fields)
1392   int iFieldCount = klass->NumInstanceFields();
1393   // add_internal_runtime_objects is only for classes that may retain objects live through means
1394   // other than fields. It is never the case for strings.
1395   const bool add_internal_runtime_objects = AddRuntimeInternalObjectsField(klass);
1396   if (klass->IsStringClass() || add_internal_runtime_objects) {
1397     __ AddU2((uint16_t)iFieldCount + 1);
1398   } else {
1399     __ AddU2((uint16_t)iFieldCount);
1400   }
1401   for (int i = 0; i < iFieldCount; ++i) {
1402     ArtField* f = klass->GetInstanceField(i);
1403     __ AddStringId(LookupStringId(f->GetName()));
1404     HprofBasicType t = SignatureToBasicTypeAndSize(f->GetTypeDescriptor(), nullptr);
1405     __ AddU1(t);
1406   }
1407   // Add native value character array for strings / byte array for compressed strings.
1408   if (klass->IsStringClass()) {
1409     __ AddStringId(LookupStringId("value"));
1410     __ AddU1(hprof_basic_object);
1411   } else if (add_internal_runtime_objects) {
1412     __ AddStringId(LookupStringId("runtimeInternalObjects"));
1413     __ AddU1(hprof_basic_object);
1414   }
1415 }
1416 
DumpFakeObjectArray(mirror::Object * obj,const std::set<mirror::Object * > & elements)1417 void Hprof::DumpFakeObjectArray(mirror::Object* obj, const std::set<mirror::Object*>& elements) {
1418   __ AddU1(HPROF_OBJECT_ARRAY_DUMP);
1419   __ AddObjectId(obj);
1420   __ AddStackTraceSerialNumber(LookupStackTraceSerialNumber(obj));
1421   __ AddU4(elements.size());
1422   __ AddClassId(LookupClassId(GetClassRoot<mirror::ObjectArray<mirror::Object>>().Ptr()));
1423   for (mirror::Object* e : elements) {
1424     __ AddObjectId(e);
1425   }
1426 }
1427 
DumpHeapArray(mirror::Array * obj,mirror::Class * klass)1428 void Hprof::DumpHeapArray(mirror::Array* obj, mirror::Class* klass) {
1429   uint32_t length = obj->GetLength();
1430 
1431   if (obj->IsObjectArray()) {
1432     // obj is an object array.
1433     __ AddU1(HPROF_OBJECT_ARRAY_DUMP);
1434 
1435     __ AddObjectId(obj);
1436     __ AddStackTraceSerialNumber(LookupStackTraceSerialNumber(obj));
1437     __ AddU4(length);
1438     __ AddClassId(LookupClassId(klass));
1439 
1440     // Dump the elements, which are always objects or null.
1441     __ AddIdList(obj->AsObjectArray<mirror::Object>().Ptr());
1442   } else {
1443     size_t size;
1444     HprofBasicType t = SignatureToBasicTypeAndSize(
1445         Primitive::Descriptor(klass->GetComponentType()->GetPrimitiveType()), &size);
1446 
1447     // obj is a primitive array.
1448     __ AddU1(HPROF_PRIMITIVE_ARRAY_DUMP);
1449 
1450     __ AddObjectId(obj);
1451     __ AddStackTraceSerialNumber(LookupStackTraceSerialNumber(obj));
1452     __ AddU4(length);
1453     __ AddU1(t);
1454 
1455     // Dump the raw, packed element values.
1456     if (size == 1) {
1457       __ AddU1List(reinterpret_cast<const uint8_t*>(obj->GetRawData(sizeof(uint8_t), 0)), length);
1458     } else if (size == 2) {
1459       __ AddU2List(reinterpret_cast<const uint16_t*>(obj->GetRawData(sizeof(uint16_t), 0)), length);
1460     } else if (size == 4) {
1461       __ AddU4List(reinterpret_cast<const uint32_t*>(obj->GetRawData(sizeof(uint32_t), 0)), length);
1462     } else if (size == 8) {
1463       __ AddU8List(reinterpret_cast<const uint64_t*>(obj->GetRawData(sizeof(uint64_t), 0)), length);
1464     }
1465   }
1466 }
1467 
DumpHeapInstanceObject(mirror::Object * obj,mirror::Class * klass,const std::set<mirror::Object * > & fake_roots)1468 void Hprof::DumpHeapInstanceObject(mirror::Object* obj,
1469                                    mirror::Class* klass,
1470                                    const std::set<mirror::Object*>& fake_roots) {
1471   // obj is an instance object.
1472   __ AddU1(HPROF_INSTANCE_DUMP);
1473   __ AddObjectId(obj);
1474   __ AddStackTraceSerialNumber(LookupStackTraceSerialNumber(obj));
1475   __ AddClassId(LookupClassId(klass));
1476 
1477   // Reserve some space for the length of the instance data, which we won't
1478   // know until we're done writing it.
1479   size_t size_patch_offset = output_->Length();
1480   __ AddU4(0x77777777);
1481 
1482   // What we will use for the string value if the object is a string.
1483   mirror::Object* string_value = nullptr;
1484   mirror::Object* fake_object_array = nullptr;
1485 
1486   // Write the instance data;  fields for this class, followed by super class fields, and so on.
1487   do {
1488     const size_t instance_fields = klass->NumInstanceFields();
1489     for (size_t i = 0; i < instance_fields; ++i) {
1490       ArtField* f = klass->GetInstanceField(i);
1491       size_t size;
1492       HprofBasicType t = SignatureToBasicTypeAndSize(f->GetTypeDescriptor(), &size);
1493       switch (t) {
1494       case hprof_basic_byte:
1495         __ AddU1(f->GetByte(obj));
1496         break;
1497       case hprof_basic_boolean:
1498         __ AddU1(f->GetBoolean(obj));
1499         break;
1500       case hprof_basic_char:
1501         __ AddU2(f->GetChar(obj));
1502         break;
1503       case hprof_basic_short:
1504         __ AddU2(f->GetShort(obj));
1505         break;
1506       case hprof_basic_int:
1507         if (mirror::kUseStringCompression &&
1508             klass->IsStringClass() &&
1509             f->GetOffset().SizeValue() == mirror::String::CountOffset().SizeValue()) {
1510           // Store the string length instead of the raw count field with compression flag.
1511           __ AddU4(obj->AsString()->GetLength());
1512           break;
1513         }
1514         FALLTHROUGH_INTENDED;
1515       case hprof_basic_float:
1516       case hprof_basic_object:
1517         __ AddU4(f->Get32(obj));
1518         break;
1519       case hprof_basic_double:
1520       case hprof_basic_long:
1521         __ AddU8(f->Get64(obj));
1522         break;
1523       }
1524     }
1525     // Add value field for String if necessary.
1526     if (klass->IsStringClass()) {
1527       ObjPtr<mirror::String> s = obj->AsString();
1528       if (s->GetLength() == 0) {
1529         // If string is empty, use an object-aligned address within the string for the value.
1530         string_value = reinterpret_cast<mirror::Object*>(
1531             reinterpret_cast<uintptr_t>(s.Ptr()) + kObjectAlignment);
1532       } else {
1533         if (s->IsCompressed()) {
1534           string_value = reinterpret_cast<mirror::Object*>(s->GetValueCompressed());
1535         } else {
1536           string_value = reinterpret_cast<mirror::Object*>(s->GetValue());
1537         }
1538       }
1539       __ AddObjectId(string_value);
1540     } else if (AddRuntimeInternalObjectsField(klass)) {
1541       // We need an id that is guaranteed to not be used, use 1/2 of the object alignment.
1542       fake_object_array = reinterpret_cast<mirror::Object*>(
1543           reinterpret_cast<uintptr_t>(obj) + kObjectAlignment / 2);
1544       __ AddObjectId(fake_object_array);
1545     }
1546     klass = klass->GetSuperClass().Ptr();
1547   } while (klass != nullptr);
1548 
1549   // Patch the instance field length.
1550   __ UpdateU4(size_patch_offset, output_->Length() - (size_patch_offset + 4));
1551 
1552   // Output native value character array for strings.
1553   CHECK_EQ(obj->IsString(), string_value != nullptr);
1554   if (string_value != nullptr) {
1555     ObjPtr<mirror::String> s = obj->AsString();
1556     __ AddU1(HPROF_PRIMITIVE_ARRAY_DUMP);
1557     __ AddObjectId(string_value);
1558     __ AddStackTraceSerialNumber(LookupStackTraceSerialNumber(obj));
1559     __ AddU4(s->GetLength());
1560     if (s->IsCompressed()) {
1561       __ AddU1(hprof_basic_byte);
1562       __ AddU1List(s->GetValueCompressed(), s->GetLength());
1563     } else {
1564       __ AddU1(hprof_basic_char);
1565       __ AddU2List(s->GetValue(), s->GetLength());
1566     }
1567   } else if (fake_object_array != nullptr) {
1568     DumpFakeObjectArray(fake_object_array, fake_roots);
1569   }
1570 }
1571 
VisitRoot(mirror::Object * obj,const RootInfo & info)1572 void Hprof::VisitRoot(mirror::Object* obj, const RootInfo& info) {
1573   static const HprofHeapTag xlate[] = {
1574     HPROF_ROOT_UNKNOWN,
1575     HPROF_ROOT_JNI_GLOBAL,
1576     HPROF_ROOT_JNI_LOCAL,
1577     HPROF_ROOT_JAVA_FRAME,
1578     HPROF_ROOT_NATIVE_STACK,
1579     HPROF_ROOT_STICKY_CLASS,
1580     HPROF_ROOT_THREAD_BLOCK,
1581     HPROF_ROOT_MONITOR_USED,
1582     HPROF_ROOT_THREAD_OBJECT,
1583     HPROF_ROOT_INTERNED_STRING,
1584     HPROF_ROOT_FINALIZING,
1585     HPROF_ROOT_DEBUGGER,
1586     HPROF_ROOT_REFERENCE_CLEANUP,
1587     HPROF_ROOT_VM_INTERNAL,
1588     HPROF_ROOT_JNI_MONITOR,
1589   };
1590   CHECK_LT(info.GetType(), sizeof(xlate) / sizeof(HprofHeapTag));
1591   if (obj == nullptr) {
1592     return;
1593   }
1594   MarkRootObject(obj, nullptr, xlate[info.GetType()], info.GetThreadId());
1595 }
1596 
1597 // If "direct_to_ddms" is true, the other arguments are ignored, and data is
1598 // sent directly to DDMS.
1599 // If "fd" is >= 0, the output will be written to that file descriptor.
1600 // Otherwise, "filename" is used to create an output file.
DumpHeap(const char * filename,int fd,bool direct_to_ddms)1601 void DumpHeap(const char* filename, int fd, bool direct_to_ddms) {
1602   CHECK(filename != nullptr);
1603   Thread* self = Thread::Current();
1604   // Need to take a heap dump while GC isn't running. See the comment in Heap::VisitObjects().
1605   // Also we need the critical section to avoid visiting the same object twice. See b/34967844
1606   gc::ScopedGCCriticalSection gcs(self,
1607                                   gc::kGcCauseHprof,
1608                                   gc::kCollectorTypeHprof);
1609   ScopedSuspendAll ssa(__FUNCTION__, true /* long suspend */);
1610   Hprof hprof(filename, fd, direct_to_ddms);
1611   hprof.Dump();
1612 }
1613 
1614 }  // namespace hprof
1615 }  // namespace art
1616