/*

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

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "jvmti.h"

#ifdef __cplusplus

extern "C" {

#endif

#ifndef JNI_ENV_ARG

#ifdef __cplusplus

#define JNI_ENV_ARG(x, y) y

#define JNI_ENV_PTR(x) x

#else

#define JNI_ENV_ARG(x,y) x, y

#define JNI_ENV_PTR(x) (*x)

#endif

#endif

#define TRUE 1

#define FALSE 0

#define PRINT_OUT 1

static jvmtiEnv *jvmti = NULL;

static jvmtiEnv *second_jvmti = NULL;

typedef struct _ObjectTrace{

  jweak object;

  jlong size;

  jvmtiFrameInfo* frames;

  size_t frame_count;

  jthread thread;

} ObjectTrace;

typedef struct _EventStorage {

  int live_object_additions;

  int live_object_size;

  int live_object_count;

  ObjectTrace** live_objects;

  int garbage_history_size;

  int garbage_history_index;

  ObjectTrace** garbage_collected_objects;

  // Two separate monitors to separate storage data race and the compaction field

  // data race.

  jrawMonitorID storage_monitor;

  int compaction_required;

  jrawMonitorID compaction_monitor;

} EventStorage;

typedef struct _ExpectedContentFrame {

  const char *name;

  const char *signature;

  const char *file_name;

  int line_number;

} ExpectedContentFrame;

static

void event_storage_lock(EventStorage* storage) {

  (*jvmti)->RawMonitorEnter(jvmti, storage->storage_monitor);

}

static

void event_storage_unlock(EventStorage* storage) {

  (*jvmti)->RawMonitorExit(jvmti, storage->storage_monitor);

}

static

void event_storage_lock_compaction(EventStorage* storage) {

  (*jvmti)->RawMonitorEnter(jvmti, storage->compaction_monitor);

}

static

void event_storage_unlock_compaction(EventStorage* storage) {

  (*jvmti)->RawMonitorExit(jvmti, storage->compaction_monitor);

}

// Given a method and a location, this method gets the line number.

static

jint get_line_number(jvmtiEnv* jvmti, jmethodID method,

                     jlocation location) {

  // Read the line number table.

  jvmtiLineNumberEntry *table_ptr = 0;

  jint line_number_table_entries;

  int l;

  jlocation last_location;

  int jvmti_error = (*jvmti)->GetLineNumberTable(jvmti, method,

                                                 &line_number_table_entries,

                                                 &table_ptr);

  if (JVMTI_ERROR_NONE != jvmti_error) {

    return -1;

  }

  if (line_number_table_entries <= 0) {

    return -1;

  }

  if (line_number_table_entries == 1) {

    return table_ptr[0].line_number;

  }

  // Go through all the line numbers...

  last_location = table_ptr[0].start_location;

  for (l = 1; l < line_number_table_entries; l++) {

    // ... and if you see one that is in the right place for your

    // location, you've found the line number!

    if ((location < table_ptr[l].start_location) &&

        (location >= last_location)) {

      return table_ptr[l - 1].line_number;

    }

    last_location = table_ptr[l].start_location;

  }

  if (location >= last_location) {

    return table_ptr[line_number_table_entries - 1].line_number;

  } else {

    return -1;

  }

}

static void print_out_frames(JNIEnv* env, ObjectTrace* trace) {

  jvmtiFrameInfo* frames = trace->frames;

  size_t i;

  for (i = 0; i < trace->frame_count; i++) {

    // Get basic information out of the trace.

    jlocation bci = frames[i].location;

    jmethodID methodid = frames[i].method;

    char *name = NULL, *signature = NULL, *file_name = NULL;

    jclass declaring_class;

    int line_number;

    jvmtiError err;

    if (bci < 0) {

      fprintf(stderr, "\tNative frame\n");

      continue;

    }

    // Transform into usable information.

    line_number = get_line_number(jvmti, methodid, bci);

    if (JVMTI_ERROR_NONE !=

        (*jvmti)->GetMethodName(jvmti, methodid, &name, &signature, 0)) {

      fprintf(stderr, "\tUnknown method name\n");

      continue;

    }

    if (JVMTI_ERROR_NONE !=

        (*jvmti)->GetMethodDeclaringClass(jvmti, methodid, &declaring_class)) {

      fprintf(stderr, "\tUnknown class\n");

      continue;

    }

    err = (*jvmti)->GetSourceFileName(jvmti, declaring_class,

                                      &file_name);

    if (err != JVMTI_ERROR_NONE) {

      fprintf(stderr, "\tUnknown file\n");

      continue;

    }

    // Compare now, none should be NULL.

    if (name == NULL) {

      fprintf(stderr, "\tUnknown name\n");

      continue;

    }

    if (file_name == NULL) {

      fprintf(stderr, "\tUnknown file\n");

      continue;

    }

    if (signature == NULL) {

      fprintf(stderr, "\tUnknown signature\n");

      continue;

    }

    fprintf(stderr, "\t%s%s (%s: %d)\n",

            name, signature, file_name, line_number);

  }

}

static jboolean check_sample_content(JNIEnv* env,

                                     ObjectTrace* trace,

                                     ExpectedContentFrame *expected,

                                     size_t expected_count,

                                     jboolean check_lines,

                                     int print_out_comparisons) {

  jvmtiFrameInfo* frames;

  size_t i;

  if (expected_count > trace->frame_count) {

    return FALSE;

  }

  frames = trace->frames;

  for (i = 0; i < expected_count; i++) {

    // Get basic information out of the trace.

    jlocation bci = frames[i].location;

    jmethodID methodid = frames[i].method;

    char *name = NULL, *signature = NULL, *file_name = NULL;

    jclass declaring_class;

    int line_number;

    jboolean differ;

    jvmtiError err;

    if (bci < 0 && expected[i].line_number != -1) {

      return FALSE;

    }

    // Transform into usable information.

    line_number = get_line_number(jvmti, methodid, bci);

    (*jvmti)->GetMethodName(jvmti, methodid, &name, &signature, 0);

    if (JVMTI_ERROR_NONE !=

        (*jvmti)->GetMethodDeclaringClass(jvmti, methodid, &declaring_class)) {

      return FALSE;

    }

    err = (*jvmti)->GetSourceFileName(jvmti, declaring_class,

                                      &file_name);

    if (err != JVMTI_ERROR_NONE) {

      return FALSE;

    }

    // Compare now, none should be NULL.

    if (name == NULL) {

      return FALSE;

    }

    if (file_name == NULL) {

      return FALSE;

    }

    if (signature == NULL) {

      return FALSE;

    }

    differ = (strcmp(name, expected[i].name) ||

              strcmp(signature, expected[i].signature) ||

              strcmp(file_name, expected[i].file_name) ||

              (check_lines && line_number != expected[i].line_number));

    if (print_out_comparisons) {

      fprintf(stderr, "\tComparing: (check_lines: %d)\n", check_lines);

      fprintf(stderr, "\t\tNames: %s and %s\n", name, expected[i].name);

      fprintf(stderr, "\t\tSignatures: %s and %s\n", signature, expected[i].signature);

      fprintf(stderr, "\t\tFile name: %s and %s\n", file_name, expected[i].file_name);

      fprintf(stderr, "\t\tLines: %d and %d\n", line_number, expected[i].line_number);

      fprintf(stderr, "\t\tResult is %d\n", differ);

    }

    if (differ) {

      return FALSE;

    }

  }

  return TRUE;

}

// Static native API for various tests.

static void fill_native_frames(JNIEnv* env, jobjectArray frames,

                               ExpectedContentFrame* native_frames, size_t size) {

  size_t i;

  for (i = 0; i < size; i++) {

    jobject obj = (*env)->GetObjectArrayElement(env, frames, (jsize) i);

    jclass frame_class = (*env)->GetObjectClass(env, obj);

    jfieldID line_number_field_id = (*env)->GetFieldID(env, frame_class,

                                                       "lineNumber", "I");

    int line_number = (*env)->GetIntField(env, obj, line_number_field_id);

    jfieldID string_id = (*env)->GetFieldID(env, frame_class, "method",

                                            "Ljava/lang/String;");

    jstring string_object = (jstring) (*env)->GetObjectField(env, obj,

                                                             string_id);

    const char* method = (*env)->GetStringUTFChars(env, string_object, 0);

    const char* file_name;

    const char* signature;

    string_id = (*env)->GetFieldID(env, frame_class, "fileName",

                                   "Ljava/lang/String;");

    string_object = (jstring) (*env)->GetObjectField(env, obj, string_id);

    file_name = (*env)->GetStringUTFChars(env, string_object, 0);

    string_id = (*env)->GetFieldID(env, frame_class, "signature",

                                   "Ljava/lang/String;");

    string_object = (jstring) (*env)->GetObjectField(env, obj, string_id);

    signature= (*env)->GetStringUTFChars(env, string_object, 0);

    native_frames[i].name = method;

    native_frames[i].file_name = file_name;

    native_frames[i].signature = signature;

    native_frames[i].line_number = line_number;

  }

}

// Internal storage system implementation.

static EventStorage global_event_storage;

static EventStorage second_global_event_storage;

static void event_storage_set_compaction_required(EventStorage* storage) {

  event_storage_lock_compaction(storage);

  storage->compaction_required = 1;

  event_storage_unlock_compaction(storage);

}

static int event_storage_get_compaction_required(EventStorage* storage) {

  int result;

  event_storage_lock_compaction(storage);

  result = storage->compaction_required;

  event_storage_unlock_compaction(storage);

  return result;

}

static void event_storage_set_garbage_history(EventStorage* storage, int value) {

  size_t size;

  event_storage_lock(storage);

  global_event_storage.garbage_history_size = value;

  free(global_event_storage.garbage_collected_objects);

  size = sizeof(*global_event_storage.garbage_collected_objects) * value;

  global_event_storage.garbage_collected_objects = malloc(size);

  memset(global_event_storage.garbage_collected_objects, 0, size);

  event_storage_unlock(storage);

}

// No mutex here, it is handled by the caller.

static void event_storage_add_garbage_collected_object(EventStorage* storage,

                                                       ObjectTrace* object) {

  int idx = storage->garbage_history_index;

  ObjectTrace* old_object = storage->garbage_collected_objects[idx];

  if (old_object != NULL) {

    free(old_object->frames);

    free(storage->garbage_collected_objects[idx]);

  }

  storage->garbage_collected_objects[idx] = object;

  storage->garbage_history_index = (idx + 1) % storage->garbage_history_size;

}

static int event_storage_get_count(EventStorage* storage) {

  int result;

  event_storage_lock(storage);

  result = storage->live_object_count;

  event_storage_unlock(storage);

  return result;

}

  double accumulation = 0;

  int max_size;

  int i;

  event_storage_lock(storage);

  max_size = storage->live_object_count;

  for (i = 0; i < max_size; i++) {

    accumulation += storage->live_objects[i]->size;

  }

  event_storage_unlock(storage);

  return accumulation / max_size;

}

static jboolean event_storage_contains(JNIEnv* env,

                                       EventStorage* storage,

                                       ExpectedContentFrame* frames,

                                       size_t size,

                                       jboolean check_lines) {

  int i;

  event_storage_lock(storage);

  fprintf(stderr, "Checking storage count %d\n", storage->live_object_count);

  for (i = 0; i < storage->live_object_count; i++) {

    ObjectTrace* trace = storage->live_objects[i];

    if (check_sample_content(env, trace, frames, size, check_lines, PRINT_OUT)) {

      event_storage_unlock(storage);

      return TRUE;

    }

  }

  event_storage_unlock(storage);

  return FALSE;

}

static jboolean event_storage_garbage_contains(JNIEnv* env,

                                               EventStorage* storage,

                                               ExpectedContentFrame* frames,

                                               size_t size,

                                               jboolean check_lines) {

  int i;

  event_storage_lock(storage);

  fprintf(stderr, "Checking garbage storage count %d\n",

          storage->garbage_history_size);

  for (i = 0; i < storage->garbage_history_size; i++) {

    ObjectTrace* trace = storage->garbage_collected_objects[i];

    if (trace == NULL) {

      continue;

    }

    if (check_sample_content(env, trace, frames, size, check_lines, PRINT_OUT)) {

      event_storage_unlock(storage);

      return TRUE;

    }

  }

  event_storage_unlock(storage);

  return FALSE;

}

// No mutex here, handled by the caller.

static void event_storage_augment_storage(EventStorage* storage) {

  int new_max = (storage->live_object_size * 2) + 1;

  ObjectTrace** new_objects = malloc(new_max * sizeof(*new_objects));

  int current_count = storage->live_object_count;

  memcpy(new_objects, storage->live_objects, current_count * sizeof(*new_objects));

  free(storage->live_objects);

  storage->live_objects = new_objects;

  storage->live_object_size = new_max;

}

static void event_storage_add(EventStorage* storage,

                              JNIEnv* jni,

                              jthread thread,

                              jobject object,

                              jclass klass,

                              jlong size) {

  jvmtiFrameInfo frames[64];

  jint count;

  jvmtiError err;

  err = (*jvmti)->GetStackTrace(jvmti, thread, 0, 64, frames, &count);

  if (err == JVMTI_ERROR_NONE && count >= 1) {

    ObjectTrace* live_object;

    jvmtiFrameInfo* allocated_frames = (jvmtiFrameInfo*) malloc(count * sizeof(*allocated_frames));

    memcpy(allocated_frames, frames, count * sizeof(*allocated_frames));

    live_object = (ObjectTrace*) malloc(sizeof(*live_object));

    live_object->frames = allocated_frames;

    live_object->frame_count = count;

    live_object->size = size;

    live_object->thread = thread;

    live_object->object = (*jni)->NewWeakGlobalRef(jni, object);

    // Only now lock and get things done quickly.

    event_storage_lock(storage);

    storage->live_object_additions++;

    if (storage->live_object_count >= storage->live_object_size) {

      event_storage_augment_storage(storage);

    }

    assert(storage->live_object_count < storage->live_object_size);

    if (PRINT_OUT) {

      fprintf(stderr, "Adding trace for thread %p, frame_count %d, storage %p\n",

              thread, count, storage);

      print_out_frames(jni, live_object);

    }

    storage->live_objects[storage->live_object_count] = live_object;

    storage->live_object_count++;

    event_storage_unlock(storage);

  }

}

static void event_storage_compact(EventStorage* storage, JNIEnv* jni) {

  int max, i, dest;

  ObjectTrace** live_objects;

  event_storage_lock_compaction(storage);

  storage->compaction_required = 0;

  event_storage_unlock_compaction(storage);

  event_storage_lock(storage);

  max = storage->live_object_count;

  live_objects = storage->live_objects;

  for (i = 0, dest = 0; i < max; i++) {

    ObjectTrace* live_object = live_objects[i];

    jweak object = live_object->object;

    if (!(*jni)->IsSameObject(jni, object, NULL)) {

      if (dest != i) {

        live_objects[dest] = live_object;

        dest++;

      }

    } else {

      (*jni)->DeleteWeakGlobalRef(jni, object);

      live_object->object = NULL;

      event_storage_add_garbage_collected_object(storage, live_object);

    }

  }

  storage->live_object_count = dest;

  event_storage_unlock(storage);

}

static void event_storage_free_objects(ObjectTrace** array, int max) {

  int i;