/*

 * Copyright (c) 2005, 2018, 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.

 *

 * 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 "precompiled.hpp"

#include "jvm.h"

#include "classfile/classLoaderData.inline.hpp"

#include "classfile/classLoaderDataGraph.hpp"

#include "classfile/symbolTable.hpp"

#include "classfile/systemDictionary.hpp"

#include "classfile/vmSymbols.hpp"

#include "gc/shared/gcLocker.hpp"

#include "gc/shared/gcVMOperations.hpp"

#include "memory/allocation.inline.hpp"

#include "memory/resourceArea.hpp"

#include "memory/universe.hpp"

#include "oops/objArrayKlass.hpp"

#include "oops/objArrayOop.inline.hpp"

#include "oops/oop.inline.hpp"

#include "oops/typeArrayOop.inline.hpp"

#include "runtime/frame.inline.hpp"

#include "runtime/handles.inline.hpp"

#include "runtime/javaCalls.hpp"

#include "runtime/jniHandles.hpp"

#include "runtime/os.inline.hpp"

#include "runtime/reflectionUtils.hpp"

#include "runtime/thread.inline.hpp"

#include "runtime/threadSMR.hpp"

#include "runtime/vframe.hpp"

#include "runtime/vmThread.hpp"

#include "runtime/vmOperations.hpp"

#include "services/heapDumper.hpp"

#include "services/threadService.hpp"

#include "utilities/macros.hpp"

#include "utilities/ostream.hpp"

/*

 * HPROF binary format - description copied from:

 *   src/share/demo/jvmti/hprof/hprof_io.c

 *

 *

 *  header    "JAVA PROFILE 1.0.2" (0-terminated)

 *

 *  u4        size of identifiers. Identifiers are used to represent

 *            UTF8 strings, objects, stack traces, etc. They usually

 *            have the same size as host pointers. For example, on

 *            Solaris and Win32, the size is 4.

 * u4         high word

 * u4         low word    number of milliseconds since 0:00 GMT, 1/1/70

 * [record]*  a sequence of records.

 *

 *

 * Record format:

 *

 * u1         a TAG denoting the type of the record

 * u4         number of *microseconds* since the time stamp in the

 *            header. (wraps around in a little more than an hour)

 * u4         number of bytes *remaining* in the record. Note that

 *            this number excludes the tag and the length field itself.

 * [u1]*      BODY of the record (a sequence of bytes)

 *

 *

 * The following TAGs are supported:

 *

 * TAG           BODY       notes

 *----------------------------------------------------------

 * HPROF_UTF8               a UTF8-encoded name

 *

 *               id         name ID

 *               [u1]*      UTF8 characters (no trailing zero)

 *

 * HPROF_LOAD_CLASS         a newly loaded class

 *

 *                u4        class serial number (> 0)

 *                id        class object ID

 *                u4        stack trace serial number

 *                id        class name ID

 *

 * HPROF_UNLOAD_CLASS       an unloading class

 *

 *                u4        class serial_number

 *

 * HPROF_FRAME              a Java stack frame

 *

 *                id        stack frame ID

 *                id        method name ID

 *                id        method signature ID

 *                id        source file name ID

 *                u4        class serial number

 *                i4        line number. >0: normal

 *                                       -1: unknown

 *                                       -2: compiled method

 *                                       -3: native method

 *

 * HPROF_TRACE              a Java stack trace

 *

 *               u4         stack trace serial number

 *               u4         thread serial number

 *               u4         number of frames

 *               [id]*      stack frame IDs

 *

 *

 * HPROF_ALLOC_SITES        a set of heap allocation sites, obtained after GC

 *

 *               u2         flags 0x0001: incremental vs. complete

 *                                0x0002: sorted by allocation vs. live

 *                                0x0004: whether to force a GC

 *               u4         cutoff ratio

 *               u4         total live bytes

 *               u4         total live instances

 *               u8         total bytes allocated

 *               u8         total instances allocated

 *               u4         number of sites that follow

 *               [u1        is_array: 0:  normal object

 *                                    2:  object array

 *                                    4:  boolean array

 *                                    5:  char array

 *                                    6:  float array

 *                                    7:  double array

 *                                    8:  byte array

 *                                    9:  short array

 *                                    10: int array

 *                                    11: long array

 *                u4        class serial number (may be zero during startup)

 *                u4        stack trace serial number

 *                u4        number of bytes alive

 *                u4        number of instances alive

 *                u4        number of bytes allocated

 *                u4]*      number of instance allocated

 *

 * HPROF_START_THREAD       a newly started thread.

 *

 *               u4         thread serial number (> 0)

 *               id         thread object ID

 *               u4         stack trace serial number

 *               id         thread name ID

 *               id         thread group name ID

 *               id         thread group parent name ID

 *

 * HPROF_END_THREAD         a terminating thread.

 *

 *               u4         thread serial number

 *

 * HPROF_HEAP_SUMMARY       heap summary

 *

 *               u4         total live bytes

 *               u4         total live instances

 *               u8         total bytes allocated

 *               u8         total instances allocated

 *

 * HPROF_HEAP_DUMP          denote a heap dump

 *

 *               [heap dump sub-records]*

 *

 *                          There are four kinds of heap dump sub-records:

 *

 *               u1         sub-record type

 *

 *               HPROF_GC_ROOT_UNKNOWN         unknown root

 *

 *                          id         object ID

 *

 *               HPROF_GC_ROOT_THREAD_OBJ      thread object

 *

 *                          id         thread object ID  (may be 0 for a

 *                                     thread newly attached through JNI)

 *                          u4         thread sequence number

 *                          u4         stack trace sequence number

 *

 *               HPROF_GC_ROOT_JNI_GLOBAL      JNI global ref root

 *

 *                          id         object ID

 *                          id         JNI global ref ID

 *

 *               HPROF_GC_ROOT_JNI_LOCAL       JNI local ref

 *

 *                          id         object ID

 *                          u4         thread serial number

 *                          u4         frame # in stack trace (-1 for empty)

 *

 *               HPROF_GC_ROOT_JAVA_FRAME      Java stack frame

 *

 *                          id         object ID

 *                          u4         thread serial number

 *                          u4         frame # in stack trace (-1 for empty)

 *

 *               HPROF_GC_ROOT_NATIVE_STACK    Native stack

 *

 *                          id         object ID

 *                          u4         thread serial number

 *

 *               HPROF_GC_ROOT_STICKY_CLASS    System class

 *

 *                          id         object ID

 *

 *               HPROF_GC_ROOT_THREAD_BLOCK    Reference from thread block

 *

 *                          id         object ID

 *                          u4         thread serial number

 *

 *               HPROF_GC_ROOT_MONITOR_USED    Busy monitor

 *

 *                          id         object ID

 *

 *               HPROF_GC_CLASS_DUMP           dump of a class object

 *

 *                          id         class object ID

 *                          u4         stack trace serial number

 *                          id         super class object ID

 *                          id         class loader object ID

 *                          id         signers object ID

 *                          id         protection domain object ID

 *                          id         reserved

 *                          id         reserved

 *

 *                          u4         instance size (in bytes)

 *

 *                          u2         size of constant pool

 *                          [u2,       constant pool index,

 *                           ty,       type

 *                                     2:  object

 *                                     4:  boolean

 *                                     5:  char

 *                                     6:  float

 *                                     7:  double

 *                                     8:  byte

 *                                     9:  short

 *                                     10: int

 *                                     11: long

 *                           vl]*      and value

 *

 *                          u2         number of static fields

 *                          [id,       static field name,

 *                           ty,       type,

 *                           vl]*      and value

 *

 *                          u2         number of inst. fields (not inc. super)

 *                          [id,       instance field name,

 *                           ty]*      type

 *

 *               HPROF_GC_INSTANCE_DUMP        dump of a normal object

 *

 *                          id         object ID

 *                          u4         stack trace serial number

 *                          id         class object ID

 *                          u4         number of bytes that follow

 *                          [vl]*      instance field values (class, followed

 *                                     by super, super's super ...)

 *

 *               HPROF_GC_OBJ_ARRAY_DUMP       dump of an object array

 *

 *                          id         array object ID

 *                          u4         stack trace serial number

 *                          u4         number of elements

 *                          id         array class ID

 *                          [id]*      elements

 *

 *               HPROF_GC_PRIM_ARRAY_DUMP      dump of a primitive array

 *

 *                          id         array object ID

 *                          u4         stack trace serial number

 *                          u4         number of elements

 *                          u1         element type

 *                                     4:  boolean array

 *                                     5:  char array

 *                                     6:  float array

 *                                     7:  double array

 *                                     8:  byte array

 *                                     9:  short array

 *                                     10: int array

 *                                     11: long array

 *                          [u1]*      elements

 *

 * HPROF_CPU_SAMPLES        a set of sample traces of running threads

 *

 *                u4        total number of samples

 *                u4        # of traces

 *               [u4        # of samples

 *                u4]*      stack trace serial number

 *

 * HPROF_CONTROL_SETTINGS   the settings of on/off switches

 *

 *                u4        0x00000001: alloc traces on/off

 *                          0x00000002: cpu sampling on/off

 *                u2        stack trace depth

 *

 *

 * When the header is "JAVA PROFILE 1.0.2" a heap dump can optionally

 * be generated as a sequence of heap dump segments. This sequence is

 * terminated by an end record. The additional tags allowed by format

 * "JAVA PROFILE 1.0.2" are:

 *

 * HPROF_HEAP_DUMP_SEGMENT  denote a heap dump segment

 *

 *               [heap dump sub-records]*

 *               The same sub-record types allowed by HPROF_HEAP_DUMP

 *

 * HPROF_HEAP_DUMP_END      denotes the end of a heap dump

 *

 */

// HPROF tags

typedef enum {

  // top-level records

  HPROF_UTF8                    = 0x01,

  HPROF_LOAD_CLASS              = 0x02,

  HPROF_UNLOAD_CLASS            = 0x03,

  HPROF_FRAME                   = 0x04,

  HPROF_TRACE                   = 0x05,

  HPROF_ALLOC_SITES             = 0x06,

  HPROF_HEAP_SUMMARY            = 0x07,

  HPROF_START_THREAD            = 0x0A,

  HPROF_END_THREAD              = 0x0B,

  HPROF_HEAP_DUMP               = 0x0C,

  HPROF_CPU_SAMPLES             = 0x0D,

  HPROF_CONTROL_SETTINGS        = 0x0E,

  // 1.0.2 record types

  HPROF_HEAP_DUMP_SEGMENT       = 0x1C,

  HPROF_HEAP_DUMP_END           = 0x2C,

  // field types

  HPROF_ARRAY_OBJECT            = 0x01,

  HPROF_NORMAL_OBJECT           = 0x02,

  HPROF_BOOLEAN                 = 0x04,

  HPROF_CHAR                    = 0x05,

  HPROF_FLOAT                   = 0x06,

  HPROF_DOUBLE                  = 0x07,

  HPROF_BYTE                    = 0x08,

  HPROF_SHORT                   = 0x09,

  HPROF_INT                     = 0x0A,

  HPROF_LONG                    = 0x0B,

  // data-dump sub-records

  HPROF_GC_ROOT_UNKNOWN         = 0xFF,

  HPROF_GC_ROOT_JNI_GLOBAL      = 0x01,

  HPROF_GC_ROOT_JNI_LOCAL       = 0x02,

  HPROF_GC_ROOT_JAVA_FRAME      = 0x03,

  HPROF_GC_ROOT_NATIVE_STACK    = 0x04,

  HPROF_GC_ROOT_STICKY_CLASS    = 0x05,

  HPROF_GC_ROOT_THREAD_BLOCK    = 0x06,

  HPROF_GC_ROOT_MONITOR_USED    = 0x07,

  HPROF_GC_ROOT_THREAD_OBJ      = 0x08,

  HPROF_GC_CLASS_DUMP           = 0x20,

  HPROF_GC_INSTANCE_DUMP        = 0x21,

  HPROF_GC_OBJ_ARRAY_DUMP       = 0x22,

  HPROF_GC_PRIM_ARRAY_DUMP      = 0x23

} hprofTag;

// Default stack trace ID (used for dummy HPROF_TRACE record)

enum {

  STACK_TRACE_ID = 1,

  INITIAL_CLASS_COUNT = 200

};

// Supports I/O operations on a dump file

class DumpWriter : public StackObj {

 private:

  enum {

    io_buffer_size  = 8*M

  };

  int _fd;              // file descriptor (-1 if dump file not open)

  julong _bytes_written; // number of byte written to dump file

  char* _buffer;    // internal buffer

  size_t _size;

  size_t _pos;

  jlong _dump_start;

  char* _error;   // error message when I/O fails

  void set_file_descriptor(int fd)              { _fd = fd; }

  int file_descriptor() const                   { return _fd; }

  char* buffer() const                          { return _buffer; }

  size_t buffer_size() const                    { return _size; }

  size_t position() const                       { return _pos; }

  void set_position(size_t pos)                 { _pos = pos; }

  void set_error(const char* error)             { _error = (char*)os::strdup(error); }

  // all I/O go through this function

  void write_internal(void* s, size_t len);

 public:

  DumpWriter(const char* path);

  ~DumpWriter();

  void close();

  bool is_open() const                  { return file_descriptor() >= 0; }

  void flush();

  jlong dump_start() const                      { return _dump_start; }

  void set_dump_start(jlong pos);

  julong current_record_length();

  // total number of bytes written to the disk

  julong bytes_written() const          { return _bytes_written; }

  // adjust the number of bytes written to disk (used to keep the count

  // of the number of bytes written in case of rewrites)

  void adjust_bytes_written(jlong n)    { _bytes_written += n; }

  // number of (buffered) bytes as yet unwritten to the dump file

  size_t bytes_unwritten() const        { return position(); }

  char* error() const                   { return _error; }

  jlong current_offset();

  void seek_to_offset(jlong pos);

  // writer functions

  void write_raw(void* s, size_t len);

  void write_u1(u1 x)                   { write_raw((void*)&x, 1); }

  void write_u2(u2 x);

  void write_u4(u4 x);

  void write_u8(u8 x);

  void write_objectID(oop o);

  void write_symbolID(Symbol* o);

  void write_classID(Klass* k);

  void write_id(u4 x);

};

DumpWriter::DumpWriter(const char* path) {

  // try to allocate an I/O buffer of io_buffer_size. If there isn't

  // sufficient memory then reduce size until we can allocate something.

  _size = io_buffer_size;

  do {

    _buffer = (char*)os::malloc(_size, mtInternal);

    if (_buffer == NULL) {

      _size = _size >> 1;

    }

  } while (_buffer == NULL && _size > 0);

  assert((_size > 0 && _buffer != NULL) || (_size == 0 && _buffer == NULL), "sanity check");

  _pos = 0;

  _error = NULL;

  _bytes_written = 0L;

  _dump_start = (jlong)-1;

  _fd = os::create_binary_file(path, false);    // don't replace existing file

  // if the open failed we record the error

  if (_fd < 0) {

    _error = (char*)os::strdup(os::strerror(errno));

  }

}

DumpWriter::~DumpWriter() {

  // flush and close dump file

  if (is_open()) {

    close();

  }

  if (_buffer != NULL) os::free(_buffer);

  if (_error != NULL) os::free(_error);

}

// closes dump file (if open)

void DumpWriter::close() {

  // flush and close dump file

  if (is_open()) {

    flush();

    os::close(file_descriptor());

    set_file_descriptor(-1);

  }

}

// sets the dump starting position

void DumpWriter::set_dump_start(jlong pos) {

  _dump_start = pos;

}

julong DumpWriter::current_record_length() {

  if (is_open()) {

    // calculate the size of the dump record

    julong dump_end = bytes_written() + bytes_unwritten();

    assert(dump_end == (size_t)current_offset(), "checking");

    julong dump_len = dump_end - dump_start() - 4;

    return dump_len;

  }

  return 0;

}

// write directly to the file

void DumpWriter::write_internal(void* s, size_t len) {

  if (is_open()) {

    const char* pos = (char*)s;

    ssize_t n = 0;

    while (len > 0) {

      uint tmp = (uint)MIN2(len, (size_t)UINT_MAX);

      n = os::write(file_descriptor(), pos, tmp);

      if (n < 0) {

        // EINTR cannot happen here, os::write will take care of that

        set_error(os::strerror(errno));